diff --git a/.asf.yaml b/.asf.yaml
index 968c6779215a..9541db89daf8 100644
--- a/.asf.yaml
+++ b/.asf.yaml
@@ -38,4 +38,10 @@ github:
         # require branches to be up-to-date before merging
         strict: true
         # don't require any jobs to pass
-        contexts: []
\ No newline at end of file
+        contexts: []
+
+# publishes the content of the `asf-site` branch to
+# https://arrow.apache.org/rust/
+publish:
+  whoami: asf-site
+  subdir: rust
diff --git a/.gitattributes b/.gitattributes
index fac7bf85a77f..b7b0d51ff478 100644
--- a/.gitattributes
+++ b/.gitattributes
@@ -1,6 +1,3 @@
-r/R/RcppExports.R linguist-generated=true
-r/R/arrowExports.R linguist-generated=true
-r/src/RcppExports.cpp linguist-generated=true
-r/src/arrowExports.cpp linguist-generated=true
-r/man/*.Rd linguist-generated=true
-
+parquet/src/format.rs linguist-generated
+arrow-flight/src/arrow.flight.protocol.rs linguist-generated
+arrow-flight/src/sql/arrow.flight.protocol.sql.rs linguist-generated
diff --git a/.github/actions/setup-builder/action.yaml b/.github/actions/setup-builder/action.yaml
index 0ef6532da477..aa1d1d9c14da 100644
--- a/.github/actions/setup-builder/action.yaml
+++ b/.github/actions/setup-builder/action.yaml
@@ -20,8 +20,12 @@ description: 'Prepare Rust Build Environment'
 inputs:
   rust-version:
     description: 'version of rust to install (e.g. stable)'
-    required: true
+    required: false
     default: 'stable'
+  target:
+    description: 'target architecture(s)'
+    required: false
+    default: 'x86_64-unknown-linux-gnu'
 runs:
   using: "composite"
   steps:
@@ -51,6 +55,17 @@ runs:
       shell: bash
       run: |
         echo "Installing ${{ inputs.rust-version }}"
-        rustup toolchain install ${{ inputs.rust-version }}
+        rustup toolchain install ${{ inputs.rust-version }} --target ${{ inputs.target }}
         rustup default ${{ inputs.rust-version }}
-        echo "CARGO_TARGET_DIR=/github/home/target" >> $GITHUB_ENV
+    - name: Disable debuginfo generation
+      # Disable full debug symbol generation to speed up CI build and keep memory down
+      # "1" means line tables only, which is useful for panic tracebacks.
+      shell: bash
+      run: echo "RUSTFLAGS=-C debuginfo=1" >> $GITHUB_ENV
+    - name: Enable backtraces
+      shell: bash
+      run: echo "RUST_BACKTRACE=1" >> $GITHUB_ENV
+    - name: Fixup git permissions
+      # https://github.com/actions/checkout/issues/766
+      shell: bash
+      run: git config --global --add safe.directory "$GITHUB_WORKSPACE"
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index 9c4cda5d034d..ffde5378da93 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -6,10 +6,17 @@ updates:
       interval: daily
     open-pull-requests-limit: 10
     target-branch: master
-    labels: [auto-dependencies]
+    labels: [ auto-dependencies, arrow ]
+  - package-ecosystem: cargo
+    directory: "/object_store"
+    schedule:
+      interval: daily
+    open-pull-requests-limit: 10
+    target-branch: master
+    labels: [ auto-dependencies, object_store ]
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
       interval: "daily"
     open-pull-requests-limit: 10
-    labels: [auto-dependencies]
+    labels: [ auto-dependencies ]
diff --git a/.github/workflows/arrow.yml b/.github/workflows/arrow.yml
index 16cd9a9a0a5a..d3b2526740fa 100644
--- a/.github/workflows/arrow.yml
+++ b/.github/workflows/arrow.yml
@@ -18,6 +18,10 @@
 # tests for arrow crate
 name: arrow
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
 on:
   # always trigger
   push:
@@ -25,8 +29,23 @@ on:
       - master
   pull_request:
     paths:
-      - arrow/**
       - .github/**
+      - arrow-arith/**
+      - arrow-array/**
+      - arrow-buffer/**
+      - arrow-cast/**
+      - arrow-csv/**
+      - arrow-data/**
+      - arrow-integration-test/**
+      - arrow-ipc/**
+      - arrow-json/**
+      - arrow-avro/**
+      - arrow-ord/**
+      - arrow-row/**
+      - arrow-schema/**
+      - arrow-select/**
+      - arrow-string/**
+      - arrow/**
 
 jobs:
 
@@ -36,24 +55,46 @@ jobs:
     runs-on: ubuntu-latest
     container:
       image: amd64/rust
-      env:
-        # Disable full debug symbol generation to speed up CI build and keep memory down
-        # "1" means line tables only, which is useful for panic tracebacks.
-        RUSTFLAGS: "-C debuginfo=1"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
-        with:
-          rust-version: stable
-      - name: Test
-        run: |
-          cargo test -p arrow
-      - name: Test --features=force_validate,prettyprint,ffi
-        run: |
-          cargo test -p arrow --features=force_validate,prettyprint,ffi
+      - name: Test arrow-buffer with all features
+        run: cargo test -p arrow-buffer --all-features
+      - name: Test arrow-data with all features
+        run: cargo test -p arrow-data --all-features
+      - name: Test arrow-schema with all features
+        run: cargo test -p arrow-schema --all-features
+      - name: Test arrow-array with all features
+        run: cargo test -p arrow-array --all-features
+      - name: Test arrow-select with all features
+        run: cargo test -p arrow-select --all-features
+      - name: Test arrow-cast with all features
+        run: cargo test -p arrow-cast --all-features
+      - name: Test arrow-ipc with all features
+        run: cargo test -p arrow-ipc --all-features
+      - name: Test arrow-csv with all features
+        run: cargo test -p arrow-csv --all-features
+      - name: Test arrow-json with all features
+        run: cargo test -p arrow-json --all-features
+      - name: Test arrow-avro with all features
+        run: cargo test -p arrow-avro --all-features
+      - name: Test arrow-string with all features
+        run: cargo test -p arrow-string --all-features
+      - name: Test arrow-ord with all features
+        run: cargo test -p arrow-ord --all-features
+      - name: Test arrow-arith with all features
+        run: cargo test -p arrow-arith --all-features
+      - name: Test arrow-row with all features
+        run: cargo test -p arrow-row --all-features
+      - name: Test arrow-integration-test with all features
+        run: cargo test -p arrow-integration-test --all-features
+      - name: Test arrow with default features
+        run: cargo test -p arrow
+      - name: Test arrow with all features except pyarrow
+        run: cargo test -p arrow --features=force_validate,prettyprint,ipc_compression,ffi,chrono-tz
       - name: Run examples
         run: |
           # Test arrow examples
@@ -61,100 +102,55 @@ jobs:
           cargo run --example dynamic_types
           cargo run --example read_csv
           cargo run --example read_csv_infer_schema
+      - name: Run non-archery based integration-tests
+        run: cargo test -p arrow-integration-testing
 
-  # test compilaton features
+  # test compilation features
   linux-features:
     name: Check Compilation
     runs-on: ubuntu-latest
     container:
       image: amd64/rust
-      env:
-        # Disable full debug symbol generation to speed up CI build and keep memory down
-        # "1" means line tables only, which is useful for panic tracebacks.
-        RUSTFLAGS: "-C debuginfo=1"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
-        with:
-          rust-version: stable
       - name: Check compilation
-        run: |
-          cargo check -p arrow
+        run: cargo check -p arrow
       - name: Check compilation --no-default-features
-        run: |
-          cargo check -p arrow --no-default-features
+        run: cargo check -p arrow --no-default-features
       - name: Check compilation --all-targets
-        run: |
-          cargo check -p arrow --all-targets
+        run: cargo check -p arrow --all-targets
       - name: Check compilation --no-default-features --all-targets
-        run: |
-          cargo check -p arrow --no-default-features --all-targets
+        run: cargo check -p arrow --no-default-features --all-targets
       - name: Check compilation --no-default-features --all-targets --features test_utils
-        run: |
-          cargo check -p arrow --no-default-features --all-targets --features test_utils
-
-  # test the --features "simd" of the arrow crate. This requires nightly Rust.
-  linux-test-simd:
-    name: Test SIMD on AMD64 Rust ${{ matrix.rust }}
-    runs-on: ubuntu-latest
-    container:
-      image: amd64/rust
-      env:
-        # Disable full debug symbol generation to speed up CI build and keep memory down
-        # "1" means line tables only, which is useful for panic tracebacks.
-        RUSTFLAGS: "-C debuginfo=1"
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          submodules: true
-      - name: Setup Rust toolchain
-        uses: ./.github/actions/setup-builder
-        with:
-          rust-version: nightly
-      - name: Run tests --features "simd"
-        run: |
-          cargo test -p arrow --features "simd"
-      - name: Check compilation --features "simd"
-        run: |
-          cargo check -p arrow --features simd
-      - name: Check compilation --features simd --all-targets
-        run: |
-          cargo check -p arrow --features simd --all-targets
+        run: cargo check -p arrow --no-default-features --all-targets --features test_utils
+      - name: Check compilation --no-default-features --all-targets --features ffi
+        run: cargo check -p arrow --no-default-features --all-targets --features ffi
+      - name: Check compilation --no-default-features --all-targets --features chrono-tz
+        run: cargo check -p arrow --no-default-features --all-targets --features chrono-tz
 
 
-  # test the arrow crate builds against wasm32 in stable rust
+  # test the arrow crate builds against wasm32 in nightly rust
   wasm32-build:
     name: Build wasm32
     runs-on: ubuntu-latest
     container:
       image: amd64/rust
-      env:
-        # Disable full debug symbol generation to speed up CI build and keep memory down
-        # "1" means line tables only, which is useful for panic tracebacks.
-        RUSTFLAGS: "-C debuginfo=1"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
-      - name: Cache Cargo
-        uses: actions/cache@v3
+      - name: Setup Rust toolchain
+        uses: ./.github/actions/setup-builder
         with:
-          path: /github/home/.cargo
-          key: cargo-wasm32-cache3-
-      - name: Setup Rust toolchain for WASM
-        run: |
-          rustup toolchain install nightly
-          rustup override set nightly
-          rustup target add wasm32-unknown-unknown
-          rustup target add wasm32-wasi
-      - name: Build
-        run: |
-          cd arrow
-          cargo build --no-default-features --features=csv,ipc,simd,ffi --target wasm32-unknown-unknown
-          cargo build --no-default-features --features=csv,ipc,simd,ffi --target wasm32-wasi
+          target: wasm32-unknown-unknown,wasm32-wasi
+      - name: Build wasm32-unknown-unknown
+        run: cargo build -p arrow --no-default-features --features=json,csv,ipc,ffi --target wasm32-unknown-unknown
+      - name: Build wasm32-wasi
+        run: cargo build -p arrow --no-default-features --features=json,csv,ipc,ffi --target wasm32-wasi
 
   clippy:
     name: Clippy
@@ -162,14 +158,42 @@ jobs:
     container:
       image: amd64/rust
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
-        with:
-          rust-version: stable
       - name: Setup Clippy
-        run: |
-          rustup component add clippy
-      - name: Run clippy
-        run: |
-          cargo clippy -p arrow --features=prettyprint,csv,ipc,test_utils,ffi --all-targets -- -D warnings
+        run: rustup component add clippy
+      - name: Clippy arrow-buffer with all features
+        run: cargo clippy -p arrow-buffer --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-data with all features
+        run: cargo clippy -p arrow-data --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-schema with all features
+        run: cargo clippy -p arrow-schema --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-array with all features
+        run: cargo clippy -p arrow-array --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-select with all features
+        run: cargo clippy -p arrow-select --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-cast with all features
+        run: cargo clippy -p arrow-cast --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-ipc with all features
+        run: cargo clippy -p arrow-ipc --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-csv with all features
+        run: cargo clippy -p arrow-csv --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-json with all features
+        run: cargo clippy -p arrow-json --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-avro with all features
+        run: cargo clippy -p arrow-avro --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-string with all features
+        run: cargo clippy -p arrow-string --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-ord with all features
+        run: cargo clippy -p arrow-ord --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-arith with all features
+        run: cargo clippy -p arrow-arith --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-row with all features
+        run: cargo clippy -p arrow-row --all-targets --all-features -- -D warnings
+      - name: Clippy arrow with all features
+        run: cargo clippy -p arrow --all-features --all-targets -- -D warnings
+      - name: Clippy arrow-integration-test with all features
+        run: cargo clippy -p arrow-integration-test --all-targets --all-features -- -D warnings
+      - name: Clippy arrow-integration-testing with all features
+        run: cargo clippy -p arrow-integration-testing --all-targets --all-features -- -D warnings
diff --git a/.github/workflows/arrow_flight.yml b/.github/workflows/arrow_flight.yml
index 86a67ff9a6a4..242e0f2a3b0d 100644
--- a/.github/workflows/arrow_flight.yml
+++ b/.github/workflows/arrow_flight.yml
@@ -19,6 +19,9 @@
 # tests for arrow_flight crate
 name: arrow_flight
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
 
 # trigger for all PRs that touch certain files and changes to master
 on:
@@ -27,35 +30,51 @@ on:
       - master
   pull_request:
     paths:
-      - arrow/**
+      - arrow-array/**
+      - arrow-buffer/**
+      - arrow-cast/**
+      - arrow-data/**
       - arrow-flight/**
+      - arrow-ipc/**
+      - arrow-schema/**
+      - arrow-select/**
       - .github/**
 
 jobs:
-  # test the crate
   linux-test:
     name: Test
     runs-on: ubuntu-latest
     container:
       image: amd64/rust
-      env:
-        # Disable full debug symbol generation to speed up CI build and keep memory down
-        # "1" means line tables only, which is useful for panic tracebacks.
-        RUSTFLAGS: "-C debuginfo=1"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
-        with:
-          rust-version: stable
       - name: Test
         run: |
           cargo test -p arrow-flight
       - name: Test --all-features
         run: |
           cargo test -p arrow-flight --all-features
+      - name: Test --examples
+        run: |
+          cargo test -p arrow-flight  --features=flight-sql-experimental,tls --examples
+
+  vendor:
+    name: Verify Vendored Code
+    runs-on: ubuntu-latest
+    container:
+      image: amd64/rust
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Rust toolchain
+        uses: ./.github/actions/setup-builder
+      - name: Run gen
+        run: ./arrow-flight/regen.sh
+      - name: Verify workspace clean (if this fails, run ./arrow-flight/regen.sh and check in results)
+        run: git diff --exit-code
 
   clippy:
     name: Clippy
@@ -63,14 +82,10 @@ jobs:
     container:
       image: amd64/rust
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
-        with:
-          rust-version: stable
       - name: Setup Clippy
-        run: |
-          rustup component add clippy
+        run: rustup component add clippy
       - name: Run clippy
-        run: |
-          cargo clippy -p arrow-flight --all-features -- -D warnings
+        run: cargo clippy -p arrow-flight --all-targets --all-features -- -D warnings
diff --git a/.github/workflows/audit.yml b/.github/workflows/audit.yml
new file mode 100644
index 000000000000..2c1dcdfd2100
--- /dev/null
+++ b/.github/workflows/audit.yml
@@ -0,0 +1,43 @@
+# 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: audit
+
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
+# trigger for all PRs that touch certain files and changes to master
+on:
+  push:
+    branches:
+      - master
+  pull_request:
+    paths:
+      - '**/Cargo.toml'
+      - '**/Cargo.lock'
+
+jobs:
+  cargo-audit:
+    name: Audit
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Install cargo-audit
+        run: cargo install cargo-audit
+      - name: Run audit check
+        run: cargo audit
diff --git a/.github/workflows/cancel.yml b/.github/workflows/cancel.yml
deleted file mode 100644
index a98c8ee5d225..000000000000
--- a/.github/workflows/cancel.yml
+++ /dev/null
@@ -1,54 +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.
-
-# Attempt to cancel stale workflow runs to save github actions runner time
-name: cancel
-
-on:
-  workflow_run:
-    # The name of another workflow (whichever one) that always runs on PRs
-    workflows: ['Dev']
-    types: ['requested']
-
-jobs:
-  cancel-stale-workflow-runs:
-    name: "Cancel stale workflow runs"
-    runs-on: ubuntu-latest
-    steps:
-      # Unfortunately, we need to define a separate cancellation step for
-      # each workflow where we want to cancel stale runs.
-      - uses: potiuk/cancel-workflow-runs@master
-        name: "Cancel stale Dev runs"
-        with:
-          cancelMode: allDuplicates
-          token: ${{ secrets.GITHUB_TOKEN }}
-          workflowFileName: dev.yml
-          skipEventTypes: '["push", "schedule"]'
-      - uses: potiuk/cancel-workflow-runs@master
-        name: "Cancel stale Integration runs"
-        with:
-          cancelMode: allDuplicates
-          token: ${{ secrets.GITHUB_TOKEN }}
-          workflowFileName: integration.yml
-          skipEventTypes: '["push", "schedule"]'
-      - uses: potiuk/cancel-workflow-runs@master
-        name: "Cancel stale Rust runs"
-        with:
-          cancelMode: allDuplicates
-          token: ${{ secrets.GITHUB_TOKEN }}
-          workflowFileName: rust.yml
-          skipEventTypes: '["push", "schedule"]'
diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml
index e688428e187c..37d697dc3440 100644
--- a/.github/workflows/coverage.yml
+++ b/.github/workflows/coverage.yml
@@ -17,6 +17,10 @@
 
 name: coverage
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
 # Trigger only on pushes to master, not pull requests
 on:
   push:
@@ -32,7 +36,7 @@ jobs:
     # otherwise we get this error:
     # Failed to run tests: ASLR disable failed: EPERM: Operation not permitted
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Setup Rust toolchain
@@ -47,7 +51,7 @@ jobs:
           curl -LO https://github.com/protocolbuffers/protobuf/releases/download/v21.4/protoc-21.4-linux-x86_64.zip
           unzip protoc-21.4-linux-x86_64.zip
       - name: Cache Cargo
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: /home/runner/.cargo
           key: cargo-coverage-cache3-
diff --git a/.github/workflows/dev.yml b/.github/workflows/dev.yml
index 57dc19482761..2026e257ab29 100644
--- a/.github/workflows/dev.yml
+++ b/.github/workflows/dev.yml
@@ -17,6 +17,10 @@
 
 name: dev
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
 # trigger for all PRs and changes to master
 on:
   push:
@@ -34,9 +38,9 @@ jobs:
     name: Release Audit Tool (RAT)
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Setup Python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: 3.8
       - name: Audit licenses
@@ -46,12 +50,12 @@ jobs:
     name: Markdown format
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
         with:
           node-version: "14"
       - name: Prettier check
         run: |
           # if you encounter error, run the command below and commit the changes
-          npx prettier@2.3.2 --write {arrow,arrow-flight,dev,integration-testing,parquet}/**/*.md README.md CODE_OF_CONDUCT.md CONTRIBUTING.md
+          npx prettier@2.3.2 --write {arrow,arrow-flight,dev,arrow-integration-testing,parquet}/**/*.md README.md CODE_OF_CONDUCT.md CONTRIBUTING.md
           git diff --exit-code
diff --git a/.github/workflows/dev_pr.yml b/.github/workflows/dev_pr.yml
index 64f7ecc0039f..0d60ae006796 100644
--- a/.github/workflows/dev_pr.yml
+++ b/.github/workflows/dev_pr.yml
@@ -17,6 +17,10 @@
 
 name: dev_pr
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
 # Trigger whenever a PR is changed (title as well as new / changed commits)
 on:
   pull_request_target:
@@ -29,15 +33,18 @@ jobs:
   process:
     name: Process
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      pull-requests: write
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: Assign GitHub labels
         if: |
           github.event_name == 'pull_request_target' &&
             (github.event.action == 'opened' ||
              github.event.action == 'synchronize')
-        uses: actions/labeler@v4.0.0
+        uses: actions/labeler@v5.0.0
         with:
           repo-token: ${{ secrets.GITHUB_TOKEN }}
           configuration-path: .github/workflows/dev_pr/labeler.yml
diff --git a/.github/workflows/dev_pr/labeler.yml b/.github/workflows/dev_pr/labeler.yml
index aadf9c377c64..cae015018eac 100644
--- a/.github/workflows/dev_pr/labeler.yml
+++ b/.github/workflows/dev_pr/labeler.yml
@@ -16,16 +16,40 @@
 # under the License.
 
 arrow:
-  - arrow/**/*
+  - changed-files:
+    - any-glob-to-any-file:
+      - 'arrow-arith/**/*'
+      - 'arrow-array/**/*'
+      - 'arrow-buffer/**/*'
+      - 'arrow-cast/**/*'
+      - 'arrow-csv/**/*'
+      - 'arrow-data/**/*'
+      - 'arrow-flight/**/*'
+      - 'arrow-integration-test/**/*'
+      - 'arrow-integration-testing/**/*'
+      - 'arrow-ipc/**/*'
+      - 'arrow-json/**/*'
+      - 'arrow-avro/**/*'
+      - 'arrow-ord/**/*'
+      - 'arrow-row/**/*'
+      - 'arrow-schema/**/*'
+      - 'arrow-select/**/*'
+      - 'arrow-string/**/*'
+      - 'arrow/**/*'
 
 arrow-flight:
-  - arrow-flight/**/*
+  - changed-files:
+    - any-glob-to-any-file:
+      - 'arrow-flight/**/*'
 
 parquet:
-  - parquet/**/*
+  - changed-files:
+    - any-glob-to-any-file: [ 'parquet/**/*' ]
 
 parquet-derive:
-  - parquet_derive/**/*
+  - changed-files:
+    - any-glob-to-any-file: [ 'parquet_derive/**/*' ]
 
 object-store:
-  - object_store/**/*
+  - changed-files:
+    - any-glob-to-any-file: [ 'object_store/**/*' ]
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
index 5e82d76febe6..12ff6e3cfe8d 100644
--- a/.github/workflows/docs.yml
+++ b/.github/workflows/docs.yml
@@ -17,6 +17,10 @@
 
 name: docs
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
 # trigger for all PRs and changes to master
 on:
   push:
@@ -37,19 +41,57 @@ jobs:
     container:
       image: ${{ matrix.arch }}/rust
       env:
-        RUSTDOCFLAGS: "-Dwarnings"
+        RUSTDOCFLAGS: "-Dwarnings --enable-index-page -Zunstable-options"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Install python dev
         run: |
           apt update
-          apt install -y libpython3.9-dev
+          apt install -y libpython3.11-dev
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
         with:
           rust-version: ${{ matrix.rust }}
       - name: Run cargo doc
+        run: cargo doc --document-private-items --no-deps --workspace --all-features
+      - name: Fix file permissions
+        shell: sh
+        run: |
+          chmod -c -R +rX "target/doc" |
+          while read line; do
+              echo "::warning title=Invalid file permissions automatically fixed::$line"
+          done
+      - name: Upload artifacts
+        uses: actions/upload-pages-artifact@v3
+        with:
+          name: crate-docs
+          path: target/doc
+
+  deploy:
+    # Only deploy if a push to master
+    if: github.ref_name == 'master' && github.event_name == 'push'
+    needs: docs
+    permissions:
+      contents: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Download crate docs
+        uses: actions/download-artifact@v4
+        with:
+          name: crate-docs
+          path: website/build
+      - name: Prepare website
         run: |
-          cargo doc --document-private-items --no-deps --workspace --all-features
+          tar -xf website/build/artifact.tar -C website/build
+          rm website/build/artifact.tar
+          cp .asf.yaml ./website/build/.asf.yaml
+      - name: Deploy to gh-pages
+        uses: peaceiris/actions-gh-pages@v3.9.3
+        if: github.event_name == 'push' && github.ref_name == 'master'
+        with:
+          github_token: ${{ secrets.GITHUB_TOKEN }}
+          publish_dir: website/build
+          publish_branch: asf-site
diff --git a/.github/workflows/integration.yml b/.github/workflows/integration.yml
index 81969466ebf4..193f30d8588f 100644
--- a/.github/workflows/integration.yml
+++ b/.github/workflows/integration.yml
@@ -17,6 +17,10 @@
 
 name: integration
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
 # trigger for all PRs that touch certain files and changes to master
 on:
   push:
@@ -24,36 +28,77 @@ on:
       - master
   pull_request:
     paths:
-      - arrow/**
-      - arrow-pyarrow-integration-testing/**
-      - integration-testing/**
       - .github/**
+      - arrow-array/**
+      - arrow-buffer/**
+      - arrow-cast/**
+      - arrow-csv/**
+      - arrow-data/**
+      - arrow-integration-test/**
+      - arrow-integration-testing/**
+      - arrow-ipc/**
+      - arrow-json/**
+      - arrow-avro/**
+      - arrow-ord/**
+      - arrow-pyarrow-integration-testing/**
+      - arrow-schema/**
+      - arrow-select/**
+      - arrow-sort/**
+      - arrow-string/**
+      - arrow/**
 
 jobs:
 
   integration:
     name: Archery test With other arrows
     runs-on: ubuntu-latest
+    container:
+      image: apache/arrow-dev:amd64-conda-integration
+    env:
+      ARROW_USE_CCACHE: OFF
+      ARROW_CPP_EXE_PATH: /build/cpp/debug
+      ARROW_RUST_EXE_PATH: /build/rust/debug
+      BUILD_DOCS_CPP: OFF
+      ARROW_INTEGRATION_CPP: ON
+      ARROW_INTEGRATION_CSHARP: ON
+      ARROW_INTEGRATION_GO: ON
+      ARROW_INTEGRATION_JAVA: ON
+      ARROW_INTEGRATION_JS: ON
+      # https://github.com/apache/arrow/pull/38403/files#r1371281630
+      ARCHERY_INTEGRATION_WITH_RUST: ON
+      # These are necessary because the github runner overrides $HOME
+      # https://github.com/actions/runner/issues/863
+      RUSTUP_HOME: /root/.rustup
+      CARGO_HOME: /root/.cargo
+    defaults:
+      run:
+        shell: bash
     steps:
+      # This is necessary so that actions/checkout can find git
+      - name: Export conda path
+        run: echo "/opt/conda/envs/arrow/bin" >> $GITHUB_PATH
+      # This is necessary so that Rust can find cargo
+      - name: Export cargo path
+        run: echo "/root/.cargo/bin" >> $GITHUB_PATH
+      - name: Check rustup
+        run: which rustup
+      - name: Check cmake
+        run: which cmake
       - name: Checkout Arrow
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           repository: apache/arrow
           submodules: true
           fetch-depth: 0
       - name: Checkout Arrow Rust
-        uses: actions/checkout@v3
+        uses: actions/checkout@v4
         with:
           path: rust
           fetch-depth: 0
-      - name: Setup Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: 3.8
-      - name: Setup Archery
-        run: pip install -e dev/archery[docker]
-      - name: Execute Docker Build
-        run: archery docker run -e ARCHERY_INTEGRATION_WITH_RUST=1 conda-integration
+      - name: Build
+        run: conda run --no-capture-output ci/scripts/integration_arrow_build.sh $PWD /build
+      - name: Run
+        run: conda run --no-capture-output ci/scripts/integration_arrow.sh $PWD /build
 
   # test FFI against the C-Data interface exposed by pyarrow
   pyarrow-integration-test:
@@ -61,9 +106,11 @@ jobs:
     runs-on: ubuntu-latest
     strategy:
       matrix:
-        rust: [stable]
+        rust: [ stable ]
+        # PyArrow 13 was the last version prior to introduction to Arrow PyCapsules
+        pyarrow: [ "13", "14" ]
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Setup Rust toolchain
@@ -72,33 +119,33 @@ jobs:
           rustup default ${{ matrix.rust }}
           rustup component add rustfmt clippy
       - name: Cache Cargo
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: /home/runner/.cargo
           key: cargo-maturin-cache-
       - name: Cache Rust dependencies
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: /home/runner/target
           # this key is not equal because maturin uses different compilation flags.
           key: ${{ runner.os }}-${{ matrix.arch }}-target-maturin-cache-${{ matrix.rust }}-
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         with:
-          python-version: '3.7'
+          python-version: '3.8'
       - name: Upgrade pip and setuptools
         run: pip install --upgrade pip setuptools wheel virtualenv
       - name: Create virtualenv and install dependencies
         run: |
           virtualenv venv
           source venv/bin/activate
-          pip install maturin toml pytest pytz pyarrow>=5.0
+          pip install maturin toml pytest pytz pyarrow==${{ matrix.pyarrow }}
+      - name: Run Rust tests
+        run: |
+          source venv/bin/activate
+          cargo test -p arrow --test pyarrow --features pyarrow
       - name: Run tests
-        env:
-          CARGO_HOME: "/home/runner/.cargo"
-          CARGO_TARGET_DIR: "/home/runner/target"
         run: |
           source venv/bin/activate
-          pushd arrow-pyarrow-integration-testing
+          cd arrow-pyarrow-integration-testing
           maturin develop
           pytest -v .
-          popd
diff --git a/.github/workflows/miri.sh b/.github/workflows/miri.sh
index 56da5c5c5d3e..86be2100ee67 100755
--- a/.github/workflows/miri.sh
+++ b/.github/workflows/miri.sh
@@ -5,13 +5,16 @@
 # Must be run with nightly rust for example
 # rustup default nightly
 
+set -e
 
-# stacked borrows checking uses too much memory to run successfully in github actions
-# re-enable if the CI is migrated to something more powerful (https://github.com/apache/arrow-rs/issues/1833)
-# see also https://github.com/rust-lang/miri/issues/1367
-export MIRIFLAGS="-Zmiri-disable-isolation -Zmiri-disable-stacked-borrows"
+export MIRIFLAGS="-Zmiri-disable-isolation"
 cargo miri setup
 cargo clean
 
 echo "Starting Arrow MIRI run..."
-cargo miri test -p arrow -- --skip csv --skip ipc --skip json
+cargo miri test -p arrow-buffer
+cargo miri test -p arrow-data --features ffi
+cargo miri test -p arrow-schema --features ffi
+cargo miri test -p arrow-ord
+cargo miri test -p arrow-array
+cargo miri test -p arrow-arith
\ No newline at end of file
diff --git a/.github/workflows/miri.yaml b/.github/workflows/miri.yaml
index b4669bbcccc0..19b432121b6f 100644
--- a/.github/workflows/miri.yaml
+++ b/.github/workflows/miri.yaml
@@ -17,6 +17,10 @@
 
 name: miri
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
 # trigger for all PRs that touch certain files and changes to master
 on:
   push:
@@ -24,15 +28,26 @@ on:
       - master
   pull_request:
     paths:
-      - arrow/**
       - .github/**
+      - arrow-array/**
+      - arrow-buffer/**
+      - arrow-cast/**
+      - arrow-csv/**
+      - arrow-data/**
+      - arrow-ipc/**
+      - arrow-json/**
+      - arrow-avro/**
+      - arrow-schema/**
+      - arrow-select/**
+      - arrow-string/**
+      - arrow/**
 
 jobs:
   miri-checks:
     name: MIRI
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Setup Rust toolchain
@@ -44,5 +59,4 @@ jobs:
         env:
           RUST_BACKTRACE: full
           RUST_LOG: "trace"
-        run: |
-          bash .github/workflows/miri.sh
+        run: bash .github/workflows/miri.sh
diff --git a/.github/workflows/object_store.yml b/.github/workflows/object_store.yml
index 6c81604a96a2..33e4613afa33 100644
--- a/.github/workflows/object_store.yml
+++ b/.github/workflows/object_store.yml
@@ -19,6 +19,10 @@
 # tests for `object_store` crate
 name: object_store
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
 # trigger for all PRs that touch certain files and changes to master
 on:
   push:
@@ -35,77 +39,119 @@ jobs:
     runs-on: ubuntu-latest
     container:
       image: amd64/rust
+    defaults:
+      run:
+        working-directory: object_store
     steps:
-      - uses: actions/checkout@v3
-      - name: Setup Rust toolchain with clippy
-        run: |
-          rustup toolchain install stable
-          rustup default stable
-          rustup component add clippy
-      - name: Run clippy
-        run: |
-          cargo clippy -p object_store --all-features -- -D warnings
+      - uses: actions/checkout@v4
+      - name: Setup Rust toolchain
+        uses: ./.github/actions/setup-builder
+      - name: Setup Clippy
+        run: rustup component add clippy
+      # Run different tests for the library on its own as well as
+      # all targets to ensure that it still works in the absence of
+      # features that might be enabled by dev-dependencies of other
+      # targets.
+      - name: Run clippy with default features
+        run: cargo clippy -- -D warnings
+      - name: Run clippy with aws feature
+        run: cargo clippy --features aws -- -D warnings
+      - name: Run clippy with gcp feature
+        run: cargo clippy --features gcp -- -D warnings
+      - name: Run clippy with azure feature
+        run: cargo clippy --features azure -- -D warnings
+      - name: Run clippy with http feature
+        run: cargo clippy --features http -- -D warnings
+      - name: Run clippy with all features
+        run: cargo clippy --all-features -- -D warnings
+      - name: Run clippy with all features and all targets
+        run: cargo clippy --all-features --all-targets -- -D warnings
+
+  # test doc links still work
+  #
+  # Note that since object_store is not part of the main workspace,
+  # this needs a separate docs job as it is not covered by
+  # `cargo doc --workspace`
+  docs:
+    name: Rustdocs
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: object_store
+    env:
+      RUSTDOCFLAGS: "-Dwarnings"
+    steps:
+      - uses: actions/checkout@v4
+      - name: Run cargo doc
+        run: cargo doc --document-private-items --no-deps --workspace --all-features
 
   # test the crate
+  # This runs outside a container to workaround lack of support for passing arguments
+  # to service containers - https://github.com/orgs/community/discussions/26688
   linux-test:
     name: Emulator Tests
     runs-on: ubuntu-latest
-    services:
-      fake-gcs:
-        image: fsouza/fake-gcs-server
-        ports:
-          - 4443:4443
-      localstack:
-        image: localstack/localstack:0.14.4
-        ports:
-          - 4566:4566
-      azurite:
-        image: mcr.microsoft.com/azure-storage/azurite
-        ports:
-          - 10000:10002
-    container:
-      image: amd64/rust
-      env:
-        # Disable full debug symbol generation to speed up CI build and keep memory down
-        # "1" means line tables only, which is useful for panic tracebacks.
-        RUSTFLAGS: "-C debuginfo=1"
-        # https://github.com/rust-lang/cargo/issues/10280
-        CARGO_NET_GIT_FETCH_WITH_CLI: "true"
-        RUST_BACKTRACE: "1"
-        # Run integration tests
-        TEST_INTEGRATION: 1
-        AWS_DEFAULT_REGION: "us-east-1"
-        AWS_ACCESS_KEY_ID: test
-        AWS_SECRET_ACCESS_KEY: test
-        AWS_ENDPOINT: http://localstack:4566
-        AZURE_USE_EMULATOR: "1"
-        AZURITE_BLOB_STORAGE_URL: "http://azurite:10000"
-        AZURITE_QUEUE_STORAGE_URL: "http://azurite:10001"
-        GOOGLE_SERVICE_ACCOUNT: "/tmp/gcs.json"
-        OBJECT_STORE_BUCKET: test-bucket
+    defaults:
+      run:
+        working-directory: object_store
+    env:
+      # Disable full debug symbol generation to speed up CI build and keep memory down
+      # "1" means line tables only, which is useful for panic tracebacks.
+      RUSTFLAGS: "-C debuginfo=1"
+      RUST_BACKTRACE: "1"
+      # Run integration tests
+      TEST_INTEGRATION: 1
+      EC2_METADATA_ENDPOINT: http://localhost:1338
+      AZURE_CONTAINER_NAME: test-bucket
+      AZURE_STORAGE_USE_EMULATOR: "1"
+      AZURITE_BLOB_STORAGE_URL: "http://localhost:10000"
+      AZURITE_QUEUE_STORAGE_URL: "http://localhost:10001"
+      AWS_BUCKET: test-bucket
+      AWS_DEFAULT_REGION: "us-east-1"
+      AWS_ACCESS_KEY_ID: test
+      AWS_SECRET_ACCESS_KEY: test
+      AWS_ENDPOINT: http://localhost:4566
+      AWS_ALLOW_HTTP: true
+      AWS_COPY_IF_NOT_EXISTS: dynamo:test-table:2000
+      AWS_CONDITIONAL_PUT: dynamo:test-table:2000
+      AWS_SERVER_SIDE_ENCRYPTION: aws:kms
+      HTTP_URL: "http://localhost:8080"
+      GOOGLE_BUCKET: test-bucket
+      GOOGLE_SERVICE_ACCOUNT: "/tmp/gcs.json"
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
+      # We are forced to use docker commands instead of service containers as we need to override the entrypoints
+      # which is currently not supported - https://github.com/actions/runner/discussions/1872
       - name: Configure Fake GCS Server (GCP emulation)
+        # Custom image - see fsouza/fake-gcs-server#1164
         run: |
-          curl --insecure -v -X POST --data-binary '{"name":"test-bucket"}' -H "Content-Type: application/json" "https://fake-gcs:4443/storage/v1/b"
-          echo '{"gcs_base_url": "https://fake-gcs:4443", "disable_oauth": true, "client_email": "", "private_key": ""}' > "$GOOGLE_SERVICE_ACCOUNT"
+          echo "GCS_CONTAINER=$(docker run -d -p 4443:4443 tustvold/fake-gcs-server -scheme http -backend memory -public-host localhost:4443)" >> $GITHUB_ENV
+          # Give the container a moment to start up prior to configuring it
+          sleep 1
+          curl -v -X POST --data-binary '{"name":"test-bucket"}' -H "Content-Type: application/json" "http://localhost:4443/storage/v1/b"
+          echo '{"gcs_base_url": "http://localhost:4443", "disable_oauth": true, "client_email": "", "private_key": "", "private_key_id": ""}' > "$GOOGLE_SERVICE_ACCOUNT"
+
+      - name: Setup WebDav
+        run: docker run -d -p 8080:80 rclone/rclone serve webdav /data --addr :80
 
       - name: Setup LocalStack (AWS emulation)
         run: |
-          cd /tmp
-          curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o "awscliv2.zip"
-          unzip awscliv2.zip
-          ./aws/install
-          aws --endpoint-url=http://localstack:4566 s3 mb s3://test-bucket
+          echo "LOCALSTACK_CONTAINER=$(docker run -d -p 4566:4566 localstack/localstack@sha256:a0b79cb2430f1818de2c66ce89d41bba40f5a1823410f5a7eaf3494b692eed97)" >> $GITHUB_ENV
+          echo "EC2_METADATA_CONTAINER=$(docker run -d -p 1338:1338 amazon/amazon-ec2-metadata-mock:v1.9.2 --imdsv2)" >> $GITHUB_ENV
+          aws --endpoint-url=http://localhost:4566 s3 mb s3://test-bucket
+          aws --endpoint-url=http://localhost:4566 dynamodb create-table --table-name test-table --key-schema AttributeName=path,KeyType=HASH AttributeName=etag,KeyType=RANGE --attribute-definitions AttributeName=path,AttributeType=S AttributeName=etag,AttributeType=S --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
+
+          KMS_KEY=$(aws --endpoint-url=http://localhost:4566 kms create-key --description "test key")
+          echo "AWS_SSE_KMS_KEY_ID=$(echo $KMS_KEY | jq -r .KeyMetadata.KeyId)" >> $GITHUB_ENV
 
       - name: Configure Azurite (Azure emulation)
-          # the magical connection string is from
-          # https://docs.microsoft.com/en-us/azure/storage/common/storage-use-azurite?tabs=visual-studio#http-connection-strings
+        # the magical connection string is from
+        # https://docs.microsoft.com/en-us/azure/storage/common/storage-use-azurite?tabs=visual-studio#http-connection-strings
         run: |
-          curl -sL https://aka.ms/InstallAzureCLIDeb | bash
-          az storage container create -n test-bucket --connection-string 'DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://azurite:10000/devstoreaccount1;QueueEndpoint=http://azurite:10001/devstoreaccount1;'
+          echo "AZURITE_CONTAINER=$(docker run -d -p 10000:10000 -p 10001:10001 -p 10002:10002 mcr.microsoft.com/azure-storage/azurite)" >> $GITHUB_ENV
+          az storage container create -n test-bucket --connection-string 'DefaultEndpointsProtocol=http;AccountName=devstoreaccount1;AccountKey=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==;BlobEndpoint=http://localhost:10000/devstoreaccount1;QueueEndpoint=http://localhost:10001/devstoreaccount1;'
 
       - name: Setup Rust toolchain
         run: |
@@ -113,6 +159,42 @@ jobs:
           rustup default stable
 
       - name: Run object_store tests
-        run: |
-          # run tests
-          cargo test -p object_store --features=aws,azure,azure_test,gcp
+        run: cargo test --features=aws,azure,gcp,http
+
+      - name: GCS Output
+        if: ${{ !cancelled() }}
+        run: docker logs $GCS_CONTAINER
+
+      - name: LocalStack Output
+        if: ${{ !cancelled() }}
+        run: docker logs $LOCALSTACK_CONTAINER
+
+      - name: EC2 Metadata Output
+        if: ${{ !cancelled() }}
+        run: docker logs $EC2_METADATA_CONTAINER
+
+      - name: Azurite Output
+        if: ${{ !cancelled() }}
+        run: docker logs $AZURITE_CONTAINER
+
+  # test the object_store crate builds against wasm32 in stable rust
+  wasm32-build:
+    name: Build wasm32
+    runs-on: ubuntu-latest
+    container:
+      image: amd64/rust
+    defaults:
+      run:
+        working-directory: object_store
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - name: Setup Rust toolchain
+        uses: ./.github/actions/setup-builder
+        with:
+          target: wasm32-unknown-unknown,wasm32-wasi
+      - name: Build wasm32-unknown-unknown
+        run: cargo build --target wasm32-unknown-unknown
+      - name: Build wasm32-wasi
+        run: cargo build --target wasm32-wasi
diff --git a/.github/workflows/parquet.yml b/.github/workflows/parquet.yml
index e3f66751044f..a4e654892662 100644
--- a/.github/workflows/parquet.yml
+++ b/.github/workflows/parquet.yml
@@ -19,6 +19,9 @@
 # tests for parquet crate
 name: "parquet"
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
 
 # trigger for all PRs that touch certain files and changes to master
 on:
@@ -28,6 +31,16 @@ on:
   pull_request:
     paths:
       - arrow/**
+      - arrow-array/**
+      - arrow-buffer/**
+      - arrow-cast/**
+      - arrow-data/**
+      - arrow-schema/**
+      - arrow-select/**
+      - arrow-ipc/**
+      - arrow-csv/**
+      - arrow-json/**
+      - arrow-avro/**
       - parquet/**
       - .github/**
 
@@ -38,44 +51,35 @@ jobs:
     runs-on: ubuntu-latest
     container:
       image: amd64/rust
-      env:
-        # Disable full debug symbol generation to speed up CI build and keep memory down
-        # "1" means line tables only, which is useful for panic tracebacks.
-        RUSTFLAGS: "-C debuginfo=1"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
-        with:
-          rust-version: stable
       - name: Test
-        run: |
-          cargo test -p parquet
+        run: cargo test -p parquet
       - name: Test --all-features
+        run: cargo test -p parquet --all-features
+      - name: Run examples
         run: |
-          cargo test -p parquet --all-features
-
+          # Test parquet examples
+          cargo run -p parquet --example read_parquet
+          cargo run -p parquet --example async_read_parquet --features="async"
+          cargo run -p parquet --example read_with_rowgroup --features="async"
 
-  # test compilaton
+  # test compilation
   linux-features:
     name: Check Compilation
     runs-on: ubuntu-latest
     container:
       image: amd64/rust
-      env:
-        # Disable full debug symbol generation to speed up CI build and keep memory down
-        # "1" means line tables only, which is useful for panic tracebacks.
-        RUSTFLAGS: "-C debuginfo=1"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
-        with:
-          rust-version: stable
 
         # Run different tests for the library on its own as well as
         # all targets to ensure that it still works in the absence of
@@ -88,29 +92,78 @@ jobs:
         # 3. compiles with just arrow feature
         # 3. compiles with all features
       - name: Check compilation
-        run: |
-          cargo check -p parquet
+        run: cargo check -p parquet
       - name: Check compilation --no-default-features
-        run: |
-          cargo check -p parquet --no-default-features
+        run: cargo check -p parquet --no-default-features
       - name: Check compilation --no-default-features --features arrow
-        run: |
-          cargo check -p parquet --no-default-features --features arrow
+        run: cargo check -p parquet --no-default-features --features arrow
       - name: Check compilation --no-default-features --all-features
-        run: |
-          cargo check -p parquet --all-features
+        run: cargo check -p parquet --all-features
       - name: Check compilation --all-targets
-        run: |
-          cargo check -p parquet --all-targets
+        run: cargo check -p parquet --all-targets
       - name: Check compilation --all-targets --no-default-features
-        run: |
-          cargo check -p parquet --all-targets --no-default-features
+        run: cargo check -p parquet --all-targets --no-default-features
       - name: Check compilation  --all-targets --no-default-features --features arrow
-        run: |
-          cargo check -p parquet --all-targets --no-default-features --features arrow
+        run: cargo check -p parquet --all-targets --no-default-features --features arrow
       - name: Check compilation  --all-targets --all-features
+        run: cargo check -p parquet --all-targets --all-features
+      - name: Check compilation  --all-targets --no-default-features --features json
+        run: cargo check -p parquet --all-targets --no-default-features --features json
+
+  # test the parquet crate builds against wasm32 in stable rust
+  wasm32-build:
+    name: Build wasm32
+    runs-on: ubuntu-latest
+    container:
+      image: amd64/rust
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          submodules: true
+      - name: Setup Rust toolchain
+        uses: ./.github/actions/setup-builder
+        with:
+          target: wasm32-unknown-unknown,wasm32-wasi
+      - name: Install clang # Needed for zlib compilation
+        run: apt-get update && apt-get install -y clang gcc-multilib
+      - name: Build wasm32-unknown-unknown
+        run: cargo build -p parquet --target wasm32-unknown-unknown
+      - name: Build wasm32-wasi
+        run: cargo build -p parquet --target wasm32-wasi
+
+  pyspark-integration-test:
+    name: PySpark Integration Test
+    runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        rust: [ stable ]
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.10"
+          cache: "pip"
+      - name: Install Python dependencies
         run: |
-          cargo check -p parquet --all-targets --all-features
+          cd parquet/pytest
+          pip install -r requirements.txt
+      - name: Black check the test files
+        run: |
+          cd parquet/pytest
+          black --check *.py --verbose
+      - name: Setup Rust toolchain
+        run: |
+          rustup toolchain install ${{ matrix.rust }}
+          rustup default ${{ matrix.rust }}
+      - name: Install binary for checking
+        run: |
+          cargo install --path parquet --bin parquet-show-bloom-filter --features=cli
+          cargo install --path parquet --bin parquet-fromcsv --features=arrow,cli
+      - name: Run pytest
+        run: |
+          cd parquet/pytest
+          pytest -v
 
   clippy:
     name: Clippy
@@ -118,14 +171,10 @@ jobs:
     container:
       image: amd64/rust
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
-        with:
-          rust-version: stable
       - name: Setup Clippy
-        run: |
-          rustup component add clippy
+        run: rustup component add clippy
       - name: Run clippy
-        run: |
-          cargo clippy -p parquet --all-targets --all-features -- -D warnings
+        run: cargo clippy -p parquet --all-targets --all-features -- -D warnings
diff --git a/.github/workflows/parquet_derive.yml b/.github/workflows/parquet_derive.yml
index bd70fc30d1c5..d8b02f73a8aa 100644
--- a/.github/workflows/parquet_derive.yml
+++ b/.github/workflows/parquet_derive.yml
@@ -19,6 +19,9 @@
 # tests for parquet_derive crate
 name: parquet_derive
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
 
 # trigger for all PRs that touch certain files and changes to master
 on:
@@ -39,21 +42,14 @@ jobs:
     runs-on: ubuntu-latest
     container:
       image: amd64/rust
-      env:
-        # Disable full debug symbol generation to speed up CI build and keep memory down
-        # "1" means line tables only, which is useful for panic tracebacks.
-        RUSTFLAGS: "-C debuginfo=1"
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
-        with:
-          rust-version: stable
       - name: Test
-        run: |
-          cargo test -p parquet_derive
+        run: cargo test -p parquet_derive
 
   clippy:
     name: Clippy
@@ -61,14 +57,10 @@ jobs:
     container:
       image: amd64/rust
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: Setup Rust toolchain
         uses: ./.github/actions/setup-builder
-        with:
-          rust-version: stable
       - name: Setup Clippy
-        run: |
-          rustup component add clippy
+        run: rustup component add clippy
       - name: Run clippy
-        run: |
-          cargo clippy -p parquet_derive --all-features -- -D warnings
+        run: cargo clippy -p parquet_derive --all-features -- -D warnings
diff --git a/.github/workflows/rust.yml b/.github/workflows/rust.yml
index c04d5643b49a..d8d892ea9404 100644
--- a/.github/workflows/rust.yml
+++ b/.github/workflows/rust.yml
@@ -18,6 +18,10 @@
 # workspace wide tests
 name: rust
 
+concurrency:
+  group: ${{ github.repository }}-${{ github.head_ref || github.sha }}-${{ github.workflow }}
+  cancel-in-progress: true
+
 # trigger for all PRs and changes to master
 on:
   push:
@@ -33,12 +37,11 @@ jobs:
     name: Test on Mac
     runs-on: macos-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Install protoc with brew
-        run: |
-          brew install protobuf
+        run: brew install protobuf
       - name: Setup Rust toolchain
         run: |
           rustup toolchain install stable --no-self-update
@@ -57,7 +60,7 @@ jobs:
     name: Test on Windows
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           submodules: true
       - name: Install protobuf compiler in /d/protoc
@@ -90,11 +93,43 @@ jobs:
     container:
       image: amd64/rust
     steps:
-      - uses: actions/checkout@v3
-      - name: Setup toolchain
-        run: |
-          rustup toolchain install stable
-          rustup default stable
-          rustup component add rustfmt
-      - name: Run
+      - uses: actions/checkout@v4
+      - name: Setup Rust toolchain
+        uses: ./.github/actions/setup-builder
+      - name: Setup rustfmt
+        run: rustup component add rustfmt
+      - name: Format arrow
+        run: cargo fmt --all -- --check
+      - name: Format object_store
+        working-directory: object_store
         run: cargo fmt --all -- --check
+
+  msrv:
+    name: Verify MSRV
+    runs-on: ubuntu-latest
+    container:
+      image: amd64/rust
+    steps:
+      - uses: actions/checkout@v4
+      - name: Setup Rust toolchain
+        uses: ./.github/actions/setup-builder
+      - name: Install cargo-msrv
+        run: cargo install cargo-msrv
+      - name: Downgrade arrow dependencies
+        run: cargo update -p ahash --precise 0.8.7
+      - name: Check arrow
+        working-directory: arrow
+        run: cargo msrv verify
+      - name: Check parquet
+        working-directory: parquet
+        run: cargo msrv verify
+      - name: Check arrow-flight
+        working-directory: arrow-flight
+        run: cargo msrv verify
+      - name: Downgrade object_store dependencies
+        working-directory: object_store
+        # Necessary because 1.30.0 updates MSRV to 1.63
+        run: cargo update -p tokio --precise 1.29.1
+      - name: Check object_store
+        working-directory: object_store
+        run: cargo msrv verify
diff --git a/.github_changelog_generator b/.github_changelog_generator
index 9a9a84344866..a8279702b3aa 100644
--- a/.github_changelog_generator
+++ b/.github_changelog_generator
@@ -24,5 +24,5 @@ add-sections={"documentation":{"prefix":"**Documentation updates:**","labels":["
 #pull-requests=false
 # so that the component is shown associated with the issue
 issue-line-labels=arrow,parquet,arrow-flight
-exclude-labels=development-process,invalid,object-store
+exclude-labels=development-process,invalid,object-store,question
 breaking_labels=api-change
diff --git a/.gitignore b/.gitignore
index 2088dd5d2068..0788daea0166 100644
--- a/.gitignore
+++ b/.gitignore
@@ -5,9 +5,95 @@ rusty-tags.vi
 .flatbuffers/
 .idea/
 .vscode
+.devcontainer
 venv/*
 # created by doctests
 parquet/data.parquet
 # release notes cache
 .githubchangeloggenerator.cache
-.githubchangeloggenerator.cache.log
\ No newline at end of file
+.githubchangeloggenerator.cache.log
+justfile
+.prettierignore
+.env
+.editorconfig
+# local azurite file
+__azurite*
+__blobstorage__
+
+# .bak files
+*.bak
+*.bak2
+# OS-specific .gitignores
+
+# Mac .gitignore
+# General
+.DS_Store
+.AppleDouble
+.LSOverride
+
+# Icon must end with two \r
+Icon
+
+# Thumbnails
+._*
+
+# Files that might appear in the root of a volume
+.DocumentRevisions-V100
+.fseventsd
+.Spotlight-V100
+.TemporaryItems
+.Trashes
+.VolumeIcon.icns
+.com.apple.timemachine.donotpresent
+
+# Directories potentially created on remote AFP share
+.AppleDB
+.AppleDesktop
+Network Trash Folder
+Temporary Items
+.apdisk
+
+# Linux .gitignore
+*~
+
+# temporary files which can be created if a process still has a handle open of a deleted file
+.fuse_hidden*
+
+# KDE directory preferences
+.directory
+
+# Linux trash folder which might appear on any partition or disk
+.Trash-*
+
+# .nfs files are created when an open file is removed but is still being accessed
+.nfs*
+
+# Windows .gitignore
+# Windows thumbnail cache files
+Thumbs.db
+Thumbs.db:encryptable
+ehthumbs.db
+ehthumbs_vista.db
+
+# Dump file
+*.stackdump
+
+# Folder config file
+[Dd]esktop.ini
+
+# Recycle Bin used on file shares
+$RECYCLE.BIN/
+
+# Windows Installer files
+*.cab
+*.msi
+*.msix
+*.msm
+*.msp
+
+# Windows shortcuts
+*.lnk
+
+# Python virtual env in parquet crate
+parquet/pytest/venv/
+__pycache__/
diff --git a/CHANGELOG-old.md b/CHANGELOG-old.md
index 25be8961d2d8..5df29b350b85 100644
--- a/CHANGELOG-old.md
+++ b/CHANGELOG-old.md
@@ -17,9 +17,2423 @@
   under the License.
 -->
 
-
 # Historical Changelog
 
+## [49.0.0](https://github.com/apache/arrow-rs/tree/49.0.0) (2023-11-07)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/48.0.0...49.0.0)
+
+**Breaking changes:**
+
+- Return row count when inferring schema from JSON [\#5008](https://github.com/apache/arrow-rs/pull/5008) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([asayers](https://github.com/asayers))
+- Update object\_store 0.8.0 [\#5043](https://github.com/apache/arrow-rs/pull/5043) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Cast from integer/timestamp to timestamp/integer [\#5039](https://github.com/apache/arrow-rs/issues/5039) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support casting from integer to binary [\#5014](https://github.com/apache/arrow-rs/issues/5014) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Return row count when inferring schema from JSON [\#5007](https://github.com/apache/arrow-rs/issues/5007) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- \[FlightSQL\] Allow custom commands in get-flight-info [\#4996](https://github.com/apache/arrow-rs/issues/4996) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Support `RecordBatch::remove_column()` and `Schema::remove_field()` [\#4952](https://github.com/apache/arrow-rs/issues/4952) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `arrow_json`: support `binary` deserialization [\#4945](https://github.com/apache/arrow-rs/issues/4945) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support StructArray in Cast Kernel [\#4908](https://github.com/apache/arrow-rs/issues/4908) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- There exists a `ParquetRecordWriter` proc macro in `parquet_derive`, but `ParquetRecordReader` is missing [\#4772](https://github.com/apache/arrow-rs/issues/4772) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Fixed bugs:**
+
+- Regression when serializing large json numbers [\#5038](https://github.com/apache/arrow-rs/issues/5038) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- RowSelection::intersection Produces Invalid RowSelection [\#5036](https://github.com/apache/arrow-rs/issues/5036) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Incorrect comment on arrow::compute::kernels::sort::sort\_to\_indices [\#5029](https://github.com/apache/arrow-rs/issues/5029) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Documentation updates:**
+
+- chore: Update docs to refer to non deprecated function \(`partition`\) [\#5027](https://github.com/apache/arrow-rs/pull/5027) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+
+**Merged pull requests:**
+
+- Parquet f32/f64 handle signed zeros in statistics [\#5048](https://github.com/apache/arrow-rs/pull/5048) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jefffrey](https://github.com/Jefffrey))
+- Fix serialization of large integers in JSON \(\#5038\) [\#5042](https://github.com/apache/arrow-rs/pull/5042) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix RowSelection::intersection \(\#5036\) [\#5041](https://github.com/apache/arrow-rs/pull/5041) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Cast from integer/timestamp to timestamp/integer [\#5040](https://github.com/apache/arrow-rs/pull/5040) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- doc: update comment on sort\_to\_indices to reflect correct ordering [\#5033](https://github.com/apache/arrow-rs/pull/5033) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([westonpace](https://github.com/westonpace))
+- Support casting from integer to binary [\#5015](https://github.com/apache/arrow-rs/pull/5015) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Update tracing-log requirement from 0.1 to 0.2 [\#4998](https://github.com/apache/arrow-rs/pull/4998) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- feat\(flight-sql\): Allow custom commands in get-flight-info [\#4997](https://github.com/apache/arrow-rs/pull/4997) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([amartins23](https://github.com/amartins23))
+- \[MINOR\] No need to jump to web pages [\#4994](https://github.com/apache/arrow-rs/pull/4994) ([smallzhongfeng](https://github.com/smallzhongfeng))
+- Support metadata in SchemaBuilder [\#4987](https://github.com/apache/arrow-rs/pull/4987) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: support schema change by idx and reverse [\#4985](https://github.com/apache/arrow-rs/pull/4985) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([fansehep](https://github.com/fansehep))
+- Bump actions/setup-node from 3 to 4 [\#4982](https://github.com/apache/arrow-rs/pull/4982) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add arrow\_cast::base64 and document usage in arrow\_json [\#4975](https://github.com/apache/arrow-rs/pull/4975) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add SchemaBuilder::remove \(\#4952\) [\#4964](https://github.com/apache/arrow-rs/pull/4964) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add `Field::remove()`, `Schema::remove()`, and `RecordBatch::remove_column()` APIs [\#4959](https://github.com/apache/arrow-rs/pull/4959) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Folyd](https://github.com/Folyd))
+- Add `RecordReader` trait and proc macro to implement it for a struct [\#4773](https://github.com/apache/arrow-rs/pull/4773) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Joseph-Rance](https://github.com/Joseph-Rance))
+## [48.0.0](https://github.com/apache/arrow-rs/tree/48.0.0) (2023-10-18)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/47.0.0...48.0.0)
+
+**Breaking changes:**
+
+- Evaluate null\_regex for string type in csv \(now such values will be parsed as `Null` rather than `""`\) [\#4942](https://github.com/apache/arrow-rs/pull/4942) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([haohuaijin](https://github.com/haohuaijin))
+- fix\(csv\)!: infer null for empty column. [\#4910](https://github.com/apache/arrow-rs/pull/4910) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kskalski](https://github.com/kskalski))
+- feat: log headers/trailers in flight CLI \(+ minor fixes\) [\#4898](https://github.com/apache/arrow-rs/pull/4898) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([crepererum](https://github.com/crepererum))
+- fix\(arrow-json\)!: include null fields in schema inference with a type of Null [\#4894](https://github.com/apache/arrow-rs/pull/4894) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kskalski](https://github.com/kskalski))
+- Mark OnCloseRowGroup Send [\#4893](https://github.com/apache/arrow-rs/pull/4893) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([devinjdangelo](https://github.com/devinjdangelo))
+- Specialize Thrift Decoding \(~40% Faster\) \(\#4891\) [\#4892](https://github.com/apache/arrow-rs/pull/4892) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Make ArrowRowGroupWriter Public and SerializedRowGroupWriter Send [\#4850](https://github.com/apache/arrow-rs/pull/4850) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([devinjdangelo](https://github.com/devinjdangelo))
+
+**Implemented enhancements:**
+
+- Allow schema fields to merge with `Null` datatype [\#4901](https://github.com/apache/arrow-rs/issues/4901) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add option to FlightDataEncoder to always send dictionaries [\#4895](https://github.com/apache/arrow-rs/issues/4895) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Rework Thrift Encoding / Decoding of Parquet Metadata [\#4891](https://github.com/apache/arrow-rs/issues/4891) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Plans for supporting Extension Array to support Fixed shape tensor Array [\#4890](https://github.com/apache/arrow-rs/issues/4890)
+- Implement Take for UnionArray [\#4882](https://github.com/apache/arrow-rs/issues/4882) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Check precision overflow for casting floating to decimal [\#4865](https://github.com/apache/arrow-rs/issues/4865) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Replace lexical [\#4774](https://github.com/apache/arrow-rs/issues/4774) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add read access to settings in `csv::WriterBuilder` [\#4735](https://github.com/apache/arrow-rs/issues/4735) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Improve the performance of "DictionaryValue" row encoding [\#4712](https://github.com/apache/arrow-rs/issues/4712) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Fixed bugs:**
+
+- Should we make blank values and empty string to `None` in csv? [\#4939](https://github.com/apache/arrow-rs/issues/4939) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- \[FlightSQL\] SubstraitPlan structure is not exported [\#4932](https://github.com/apache/arrow-rs/issues/4932) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Loading page index breaks skipping of pages with nested types [\#4921](https://github.com/apache/arrow-rs/issues/4921) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- CSV schema inference assumes `Utf8` for empty columns [\#4903](https://github.com/apache/arrow-rs/issues/4903) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- parquet: Field Ids are not read from a Parquet file without serialized arrow schema [\#4877](https://github.com/apache/arrow-rs/issues/4877) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- make\_primitive\_scalar function loses DataType Internal information [\#4851](https://github.com/apache/arrow-rs/issues/4851) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- StructBuilder doesn't handle nulls correctly for empty structs [\#4842](https://github.com/apache/arrow-rs/issues/4842) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `NullArray::is_null()` returns `false` incorrectly [\#4835](https://github.com/apache/arrow-rs/issues/4835) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- cast\_string\_to\_decimal should check precision overflow [\#4829](https://github.com/apache/arrow-rs/issues/4829) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Null fields are omitted by `infer_json_schema_from_seekable` [\#4814](https://github.com/apache/arrow-rs/issues/4814) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- Support for reading JSON Array to Arrow [\#4905](https://github.com/apache/arrow-rs/issues/4905) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Assume Pages Delimit Records When Offset Index Loaded \(\#4921\) [\#4943](https://github.com/apache/arrow-rs/pull/4943) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Update pyo3 requirement from 0.19 to 0.20 [\#4941](https://github.com/apache/arrow-rs/pull/4941) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([crepererum](https://github.com/crepererum))
+- Add `FileWriter` schema getter [\#4940](https://github.com/apache/arrow-rs/pull/4940) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([haixuanTao](https://github.com/haixuanTao))
+- feat: support parsing for parquet writer option [\#4938](https://github.com/apache/arrow-rs/pull/4938) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([fansehep](https://github.com/fansehep))
+- Export `SubstraitPlan` structure in arrow\_flight::sql \(\#4932\) [\#4933](https://github.com/apache/arrow-rs/pull/4933) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([amartins23](https://github.com/amartins23))
+- Update zstd requirement from 0.12.0 to 0.13.0 [\#4923](https://github.com/apache/arrow-rs/pull/4923) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- feat: add method for async read bloom filter [\#4917](https://github.com/apache/arrow-rs/pull/4917) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([hengfeiyang](https://github.com/hengfeiyang))
+- Minor: Clarify rationale for `FlightDataEncoder` API, add examples [\#4916](https://github.com/apache/arrow-rs/pull/4916) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Update regex-syntax requirement from 0.7.1 to 0.8.0 [\#4914](https://github.com/apache/arrow-rs/pull/4914) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- feat: document & streamline flight SQL CLI [\#4912](https://github.com/apache/arrow-rs/pull/4912) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([crepererum](https://github.com/crepererum))
+- Support Arbitrary JSON values in JSON Reader \(\#4905\) [\#4911](https://github.com/apache/arrow-rs/pull/4911) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Cleanup CSV WriterBuilder, Default to AutoSI Second Precision \(\#4735\) [\#4909](https://github.com/apache/arrow-rs/pull/4909) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update proc-macro2 requirement from =1.0.68 to =1.0.69 [\#4907](https://github.com/apache/arrow-rs/pull/4907) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- chore: add csv example [\#4904](https://github.com/apache/arrow-rs/pull/4904) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([fansehep](https://github.com/fansehep))
+- feat\(schema\): allow null fields to be merged with other datatypes [\#4902](https://github.com/apache/arrow-rs/pull/4902) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kskalski](https://github.com/kskalski))
+- Update proc-macro2 requirement from =1.0.67 to =1.0.68 [\#4900](https://github.com/apache/arrow-rs/pull/4900) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add option to `FlightDataEncoder` to always resend batch dictionaries [\#4896](https://github.com/apache/arrow-rs/pull/4896) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alexwilcoxson-rel](https://github.com/alexwilcoxson-rel))
+- Fix integration tests [\#4889](https://github.com/apache/arrow-rs/pull/4889) ([tustvold](https://github.com/tustvold))
+- Support Parsing Avro File Headers [\#4888](https://github.com/apache/arrow-rs/pull/4888) ([tustvold](https://github.com/tustvold))
+- Support parquet bloom filter length [\#4885](https://github.com/apache/arrow-rs/pull/4885) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([letian-jiang](https://github.com/letian-jiang))
+- Replace lz4 with lz4\_flex Allowing Compilation for WASM [\#4884](https://github.com/apache/arrow-rs/pull/4884) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Implement Take for UnionArray [\#4883](https://github.com/apache/arrow-rs/pull/4883) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([avantgardnerio](https://github.com/avantgardnerio))
+- Update tonic-build requirement from =0.10.1 to =0.10.2 [\#4881](https://github.com/apache/arrow-rs/pull/4881) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- parquet: Read field IDs from Parquet Schema [\#4878](https://github.com/apache/arrow-rs/pull/4878) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Samrose-Ahmed](https://github.com/Samrose-Ahmed))
+- feat: improve flight CLI error handling [\#4873](https://github.com/apache/arrow-rs/pull/4873) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([crepererum](https://github.com/crepererum))
+- Support Encoding Parquet Columns in Parallel [\#4871](https://github.com/apache/arrow-rs/pull/4871) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Check precision overflow for casting floating to decimal [\#4866](https://github.com/apache/arrow-rs/pull/4866) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Make align\_buffers as public API [\#4863](https://github.com/apache/arrow-rs/pull/4863) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Enable new integration tests \(\#4828\) [\#4862](https://github.com/apache/arrow-rs/pull/4862) ([tustvold](https://github.com/tustvold))
+- Faster Serde Integration \(~80% faster\) [\#4861](https://github.com/apache/arrow-rs/pull/4861) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- fix: make\_primitive\_scalar bug [\#4852](https://github.com/apache/arrow-rs/pull/4852) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([JasonLi-cn](https://github.com/JasonLi-cn))
+- Update tonic-build requirement from =0.10.0 to =0.10.1 [\#4846](https://github.com/apache/arrow-rs/pull/4846) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Allow Constructing Non-Empty StructArray with no Fields \(\#4842\) [\#4845](https://github.com/apache/arrow-rs/pull/4845) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Refine documentation to `Array::is_null` [\#4838](https://github.com/apache/arrow-rs/pull/4838) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- fix: add missing precision overflow checking for `cast_string_to_decimal` [\#4830](https://github.com/apache/arrow-rs/pull/4830) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jonahgao](https://github.com/jonahgao))
+## [47.0.0](https://github.com/apache/arrow-rs/tree/47.0.0) (2023-09-19)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/46.0.0...47.0.0)
+
+**Breaking changes:**
+
+- Make FixedSizeBinaryArray value\_data return a reference [\#4820](https://github.com/apache/arrow-rs/issues/4820) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Update prost to v0.12.1 [\#4825](https://github.com/apache/arrow-rs/pull/4825) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- feat: FixedSizeBinaryArray::value\_data return reference [\#4821](https://github.com/apache/arrow-rs/pull/4821) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Stateless Row Encoding / Don't Preserve Dictionaries in `RowConverter` \(\#4811\) [\#4819](https://github.com/apache/arrow-rs/pull/4819) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- fix: entries field is non-nullable [\#4808](https://github.com/apache/arrow-rs/pull/4808) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Fix flight sql do put handling, add bind parameter support to FlightSQL cli client [\#4797](https://github.com/apache/arrow-rs/pull/4797) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([suremarc](https://github.com/suremarc))
+- Remove unused dyn\_cmp\_dict feature [\#4766](https://github.com/apache/arrow-rs/pull/4766) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add underlying `std::io::Error` to `IoError` and add `IpcError` variant [\#4726](https://github.com/apache/arrow-rs/pull/4726) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alexandreyc](https://github.com/alexandreyc))
+
+**Implemented enhancements:**
+
+- Row Format Adapative Block Size  [\#4812](https://github.com/apache/arrow-rs/issues/4812) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Stateless Row Conversion [\#4811](https://github.com/apache/arrow-rs/issues/4811) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Add option to specify custom null values for CSV reader [\#4794](https://github.com/apache/arrow-rs/issues/4794) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- parquet::record::RowIter cannot be customized with batch\_size and defaults to 1024 [\#4782](https://github.com/apache/arrow-rs/issues/4782) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- `DynScalar` abstraction \(something that makes it easy to create scalar `Datum`s\) [\#4781](https://github.com/apache/arrow-rs/issues/4781) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `Datum` is not exported as part of `arrow` \(it is only exported in `arrow_array`\) [\#4780](https://github.com/apache/arrow-rs/issues/4780) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `Scalar` is not exported as part of `arrow` \(it is only exported in `arrow_array`\) [\#4779](https://github.com/apache/arrow-rs/issues/4779) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support IntoPyArrow for impl RecordBatchReader [\#4730](https://github.com/apache/arrow-rs/issues/4730) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Datum Based String Kernels [\#4595](https://github.com/apache/arrow-rs/issues/4595) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Fixed bugs:**
+
+- MapArray::new\_from\_strings creates nullable entries field [\#4807](https://github.com/apache/arrow-rs/issues/4807) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- pyarrow module can't roundtrip tensor arrays [\#4805](https://github.com/apache/arrow-rs/issues/4805) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `concat_batches` errors with "schema mismatch" error when only metadata differs [\#4799](https://github.com/apache/arrow-rs/issues/4799) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- panic in `cmp` kernels with DictionaryArrays:  `Option::unwrap()` on a `None` value' [\#4788](https://github.com/apache/arrow-rs/issues/4788) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- stream ffi panics if schema metadata values aren't valid utf8 [\#4750](https://github.com/apache/arrow-rs/issues/4750) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Regression: Incorrect Sorting of `*ListArray` in 46.0.0 [\#4746](https://github.com/apache/arrow-rs/issues/4746) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Row is no longer comparable after reuse [\#4741](https://github.com/apache/arrow-rs/issues/4741) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- DoPut FlightSQL handler inadvertently consumes schema at start of Request\<Streaming\<FlightData\>\> [\#4658](https://github.com/apache/arrow-rs/issues/4658)
+- Return error when converting schema  [\#4752](https://github.com/apache/arrow-rs/pull/4752) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Implement PyArrowType for `Box<dyn RecordBatchReader + Send>` [\#4751](https://github.com/apache/arrow-rs/pull/4751) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+
+**Closed issues:**
+
+- Building arrow-rust for target wasm32-wasi falied to compile packed\_simd\_2 [\#4717](https://github.com/apache/arrow-rs/issues/4717)
+
+**Merged pull requests:**
+
+- Respect FormatOption::nulls for NullArray [\#4836](https://github.com/apache/arrow-rs/pull/4836) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix merge\_dictionary\_values in selection kernels [\#4833](https://github.com/apache/arrow-rs/pull/4833) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix like scalar null [\#4832](https://github.com/apache/arrow-rs/pull/4832) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- More chrono deprecations [\#4822](https://github.com/apache/arrow-rs/pull/4822) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+-  Adaptive Row Block Size \(\#4812\) [\#4818](https://github.com/apache/arrow-rs/pull/4818) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update proc-macro2 requirement from =1.0.66 to =1.0.67 [\#4816](https://github.com/apache/arrow-rs/pull/4816) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Do not check schema for equality in concat\_batches [\#4815](https://github.com/apache/arrow-rs/pull/4815) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- fix: export record batch through stream [\#4806](https://github.com/apache/arrow-rs/pull/4806) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Improve CSV Reader Benchmark Coverage of Small Primitives [\#4803](https://github.com/apache/arrow-rs/pull/4803) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- csv: Add option to specify custom null values [\#4795](https://github.com/apache/arrow-rs/pull/4795) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([vrongmeal](https://github.com/vrongmeal))
+- Expand docstring and add example to `Scalar` [\#4793](https://github.com/apache/arrow-rs/pull/4793) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Re-export array crate root \(\#4780\) \(\#4779\) [\#4791](https://github.com/apache/arrow-rs/pull/4791) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix DictionaryArray::normalized\_keys \(\#4788\) [\#4789](https://github.com/apache/arrow-rs/pull/4789) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Allow custom tree builder for parquet::record::RowIter [\#4783](https://github.com/apache/arrow-rs/pull/4783) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([YuraKotov](https://github.com/YuraKotov))
+- Bump actions/checkout from 3 to 4 [\#4767](https://github.com/apache/arrow-rs/pull/4767) ([dependabot[bot]](https://github.com/apps/dependabot))
+- fix: avoid panic if offset index not exists. [\#4761](https://github.com/apache/arrow-rs/pull/4761) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([RinChanNOWWW](https://github.com/RinChanNOWWW))
+- Relax constraints on PyArrowType [\#4757](https://github.com/apache/arrow-rs/pull/4757) ([tustvold](https://github.com/tustvold))
+- Chrono deprecations [\#4748](https://github.com/apache/arrow-rs/pull/4748) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix List Sorting, Revert Removal of Rank Kernels [\#4747](https://github.com/apache/arrow-rs/pull/4747) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Clear row buffer before reuse [\#4742](https://github.com/apache/arrow-rs/pull/4742) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([yjshen](https://github.com/yjshen))
+- Datum based like kernels \(\#4595\) [\#4732](https://github.com/apache/arrow-rs/pull/4732) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- feat: expose DoGet response headers & trailers [\#4727](https://github.com/apache/arrow-rs/pull/4727) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([crepererum](https://github.com/crepererum))
+- Cleanup length and bit\_length kernels [\#4718](https://github.com/apache/arrow-rs/pull/4718) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+## [46.0.0](https://github.com/apache/arrow-rs/tree/46.0.0) (2023-08-21)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/45.0.0...46.0.0)
+
+**Breaking changes:**
+
+- API improvement: `batches_to_flight_data` forces clone [\#4656](https://github.com/apache/arrow-rs/issues/4656) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add AnyDictionary Abstraction and Take ArrayRef in DictionaryArray::with\_values [\#4707](https://github.com/apache/arrow-rs/pull/4707) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Cleanup parquet type builders [\#4706](https://github.com/apache/arrow-rs/pull/4706) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Take kernel dyn Array [\#4705](https://github.com/apache/arrow-rs/pull/4705) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Improve ergonomics of Scalar [\#4704](https://github.com/apache/arrow-rs/pull/4704) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Datum based comparison kernels \(\#4596\) [\#4701](https://github.com/apache/arrow-rs/pull/4701) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Improve `Array` Logical Nullability [\#4691](https://github.com/apache/arrow-rs/pull/4691) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Validate ArrayData Buffer Alignment and Automatically Align IPC buffers \(\#4255\) [\#4681](https://github.com/apache/arrow-rs/pull/4681) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- More intuitive bool-to-string casting [\#4666](https://github.com/apache/arrow-rs/pull/4666) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([fsdvh](https://github.com/fsdvh))
+- enhancement: batches\_to\_flight\_data use a schema ref as param. [\#4665](https://github.com/apache/arrow-rs/pull/4665) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([jackwener](https://github.com/jackwener))
+- fix: from\_thrift avoid panic when stats in invalid. [\#4642](https://github.com/apache/arrow-rs/pull/4642) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([jackwener](https://github.com/jackwener))
+- bug: Add some missing field in row group metadata: ordinal, total co… [\#4636](https://github.com/apache/arrow-rs/pull/4636) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([liurenjie1024](https://github.com/liurenjie1024))
+- Remove deprecated limit kernel [\#4597](https://github.com/apache/arrow-rs/pull/4597) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- parquet: support setting the field\_id with an ArrowWriter [\#4702](https://github.com/apache/arrow-rs/issues/4702) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support references in i256 arithmetic ops [\#4694](https://github.com/apache/arrow-rs/issues/4694) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Precision-Loss Decimal Arithmetic [\#4664](https://github.com/apache/arrow-rs/issues/4664) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Faster i256 Division [\#4663](https://github.com/apache/arrow-rs/issues/4663) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support `concat_batches` for 0 columns [\#4661](https://github.com/apache/arrow-rs/issues/4661) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `filter_record_batch` should support filtering record batch without columns [\#4647](https://github.com/apache/arrow-rs/issues/4647) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Improve speed of `lexicographical_partition_ranges` [\#4614](https://github.com/apache/arrow-rs/issues/4614) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- object\_store: multipart ranges for HTTP [\#4612](https://github.com/apache/arrow-rs/issues/4612)
+- Add Rank Function [\#4606](https://github.com/apache/arrow-rs/issues/4606) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Datum Based Comparison Kernels [\#4596](https://github.com/apache/arrow-rs/issues/4596) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Convenience method to create `DataType::List` correctly [\#4544](https://github.com/apache/arrow-rs/issues/4544) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Remove Deprecated Arithmetic Kernels [\#4481](https://github.com/apache/arrow-rs/issues/4481) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Equality kernel where null==null gives true  [\#4438](https://github.com/apache/arrow-rs/issues/4438) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Parquet ArrowWriter Ignores Nulls in Dictionary Values [\#4690](https://github.com/apache/arrow-rs/issues/4690) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Schema Nullability Validation Fails to Account for Dictionary Nulls [\#4689](https://github.com/apache/arrow-rs/issues/4689) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Comparison Kernels Ignore Nulls in Dictionary Values [\#4688](https://github.com/apache/arrow-rs/issues/4688) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Casting List to String Ignores Format Options [\#4669](https://github.com/apache/arrow-rs/issues/4669) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Double free in C Stream Interface [\#4659](https://github.com/apache/arrow-rs/issues/4659) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- CI Failing On Packed SIMD [\#4651](https://github.com/apache/arrow-rs/issues/4651) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `RowInterner::size()` much too low for high cardinality dictionary columns [\#4645](https://github.com/apache/arrow-rs/issues/4645) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Decimal PrimitiveArray change datatype after try\_unary  [\#4644](https://github.com/apache/arrow-rs/issues/4644)
+- Better explanation in docs for Dictionary field encoding using RowConverter [\#4639](https://github.com/apache/arrow-rs/issues/4639) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `List(FixedSizeBinary)` array equality check may return wrong result [\#4637](https://github.com/apache/arrow-rs/issues/4637) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `arrow::compute::nullif` panics if `NullArray` is provided [\#4634](https://github.com/apache/arrow-rs/issues/4634) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Empty lists in FixedSizeListArray::try\_new is not handled [\#4623](https://github.com/apache/arrow-rs/issues/4623) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Bounds checking in `MutableBuffer::set_null_bits` can be bypassed [\#4620](https://github.com/apache/arrow-rs/issues/4620) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- TypedDictionaryArray Misleading Null Behaviour [\#4616](https://github.com/apache/arrow-rs/issues/4616) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- bug: Parquet writer missing row group metadata fields such as `compressed_size`, `file offset`. [\#4610](https://github.com/apache/arrow-rs/issues/4610) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- `new_null_array` generates an invalid union array [\#4600](https://github.com/apache/arrow-rs/issues/4600) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Footer parsing fails for very large parquet file. [\#4592](https://github.com/apache/arrow-rs/issues/4592) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- bug\(parquet\): Disabling global statistics but enabling for particular column breaks reading [\#4587](https://github.com/apache/arrow-rs/issues/4587) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- `arrow::compute::concat` panics for dense union arrays with non-trivial type IDs [\#4578](https://github.com/apache/arrow-rs/issues/4578) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- \[object\_store\] when Create a AmazonS3 instance  work with MinIO without set endpoint got error MissingRegion [\#4617](https://github.com/apache/arrow-rs/issues/4617)
+
+**Merged pull requests:**
+
+- Add distinct kernels \(\#960\) \(\#4438\) [\#4716](https://github.com/apache/arrow-rs/pull/4716) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update parquet object\_store 0.7 [\#4715](https://github.com/apache/arrow-rs/pull/4715) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Support Field ID in ArrowWriter \(\#4702\) [\#4710](https://github.com/apache/arrow-rs/pull/4710) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Remove rank kernels [\#4703](https://github.com/apache/arrow-rs/pull/4703) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support references in i256 arithmetic ops [\#4692](https://github.com/apache/arrow-rs/pull/4692) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Cleanup DynComparator \(\#2654\) [\#4687](https://github.com/apache/arrow-rs/pull/4687) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Separate metadata fetch from `ArrowReaderBuilder` construction \(\#4674\) [\#4676](https://github.com/apache/arrow-rs/pull/4676) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- cleanup some assert\(\) with error propagation [\#4673](https://github.com/apache/arrow-rs/pull/4673) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([zeevm](https://github.com/zeevm))
+- Faster i256 Division \(2-100x\) \(\#4663\) [\#4672](https://github.com/apache/arrow-rs/pull/4672) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix MSRV CI [\#4671](https://github.com/apache/arrow-rs/pull/4671) ([tustvold](https://github.com/tustvold))
+- Fix equality of nested nullable FixedSizeBinary \(\#4637\) [\#4670](https://github.com/apache/arrow-rs/pull/4670) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use ArrayFormatter in cast kernel [\#4668](https://github.com/apache/arrow-rs/pull/4668) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Minor: Improve API docs for FlightSQL metadata builders [\#4667](https://github.com/apache/arrow-rs/pull/4667) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Support `concat_batches` for 0 columns [\#4662](https://github.com/apache/arrow-rs/pull/4662) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
+- fix ownership of c stream error [\#4660](https://github.com/apache/arrow-rs/pull/4660) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Minor: Fix illustration for dict encoding [\#4657](https://github.com/apache/arrow-rs/pull/4657) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([JayjeetAtGithub](https://github.com/JayjeetAtGithub))
+- minor: move comment to the correct location [\#4655](https://github.com/apache/arrow-rs/pull/4655) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jackwener](https://github.com/jackwener))
+- Update packed\_simd and run miri tests on simd code [\#4654](https://github.com/apache/arrow-rs/pull/4654) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jhorstmann](https://github.com/jhorstmann))
+- impl `From<Vec<T>>` for `BufferBuilder` and `MutableBuffer` [\#4650](https://github.com/apache/arrow-rs/pull/4650) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- Filter record batch with 0 columns [\#4648](https://github.com/apache/arrow-rs/pull/4648) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
+- Account for child `Bucket` size in OrderPreservingInterner [\#4646](https://github.com/apache/arrow-rs/pull/4646) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Implement `Default`,`Extend` and `FromIterator` for `BufferBuilder` [\#4638](https://github.com/apache/arrow-rs/pull/4638) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- fix\(select\): handle `NullArray` in `nullif` [\#4635](https://github.com/apache/arrow-rs/pull/4635) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kawadakk](https://github.com/kawadakk))
+- Move `BufferBuilder` to `arrow-buffer` [\#4630](https://github.com/apache/arrow-rs/pull/4630) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- allow zero sized empty fixed [\#4626](https://github.com/apache/arrow-rs/pull/4626) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([smiklos](https://github.com/smiklos))
+- fix: compute\_dictionary\_mapping use wrong offsetSize [\#4625](https://github.com/apache/arrow-rs/pull/4625) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jackwener](https://github.com/jackwener))
+- impl `FromIterator` for `MutableBuffer` [\#4624](https://github.com/apache/arrow-rs/pull/4624) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- expand docs for FixedSizeListArray [\#4622](https://github.com/apache/arrow-rs/pull/4622) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([smiklos](https://github.com/smiklos))
+- fix\(buffer\): panic on end index overflow in `MutableBuffer::set_null_bits` [\#4621](https://github.com/apache/arrow-rs/pull/4621) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kawadakk](https://github.com/kawadakk))
+- impl `Default` for `arrow_buffer::buffer::MutableBuffer` [\#4619](https://github.com/apache/arrow-rs/pull/4619) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- Minor: improve docs and add example for lexicographical\_partition\_ranges [\#4615](https://github.com/apache/arrow-rs/pull/4615) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Cleanup sort [\#4613](https://github.com/apache/arrow-rs/pull/4613) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add rank function \(\#4606\) [\#4609](https://github.com/apache/arrow-rs/pull/4609) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add more docs and examples for ListArray and OffsetsBuffer [\#4607](https://github.com/apache/arrow-rs/pull/4607) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Simplify dictionary sort [\#4605](https://github.com/apache/arrow-rs/pull/4605) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Consolidate sort benchmarks [\#4604](https://github.com/apache/arrow-rs/pull/4604) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Don't Reorder Nulls in sort\_to\_indices \(\#4545\) [\#4603](https://github.com/apache/arrow-rs/pull/4603) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- fix\(data\): create child arrays of correct length when building a sparse union null array [\#4601](https://github.com/apache/arrow-rs/pull/4601) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kawadakk](https://github.com/kawadakk))
+- Use u32 metadata\_len when parsing footer of parquet. [\#4599](https://github.com/apache/arrow-rs/pull/4599) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Berrysoft](https://github.com/Berrysoft))
+- fix\(data\): map type ID to child index before indexing a union child array [\#4598](https://github.com/apache/arrow-rs/pull/4598) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kawadakk](https://github.com/kawadakk))
+- Remove deprecated arithmetic kernels \(\#4481\) [\#4594](https://github.com/apache/arrow-rs/pull/4594) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Test Disabled Page Statistics \(\#4587\) [\#4589](https://github.com/apache/arrow-rs/pull/4589) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Cleanup ArrayData::buffers [\#4583](https://github.com/apache/arrow-rs/pull/4583) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use contains\_nulls in ArrayData equality of byte arrays [\#4582](https://github.com/apache/arrow-rs/pull/4582) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Vectorized lexicographical\_partition\_ranges \(~80% faster\) [\#4575](https://github.com/apache/arrow-rs/pull/4575) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- chore: add datatype new\_list [\#4561](https://github.com/apache/arrow-rs/pull/4561) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([fansehep](https://github.com/fansehep))
+## [45.0.0](https://github.com/apache/arrow-rs/tree/45.0.0) (2023-07-30)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/44.0.0...45.0.0)
+
+**Breaking changes:**
+
+- Fix timezoned timestamp arithmetic [\#4546](https://github.com/apache/arrow-rs/pull/4546) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alexandreyc](https://github.com/alexandreyc))
+
+**Implemented enhancements:**
+
+- Use FormatOptions in Const Contexts [\#4580](https://github.com/apache/arrow-rs/issues/4580) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Human Readable Duration Display [\#4554](https://github.com/apache/arrow-rs/issues/4554) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `BooleanBuilder`: Add `validity_slice` method for accessing validity bits [\#4535](https://github.com/apache/arrow-rs/issues/4535) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support `FixedSizedListArray` for `length` kernel [\#4517](https://github.com/apache/arrow-rs/issues/4517) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `RowCoverter::convert` that targets an existing `Rows` [\#4479](https://github.com/apache/arrow-rs/issues/4479) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Panic `assertion failed: idx < self.len` when casting DictionaryArrays with nulls [\#4576](https://github.com/apache/arrow-rs/issues/4576) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- arrow-arith is\_null is buggy with NullArray [\#4565](https://github.com/apache/arrow-rs/issues/4565) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Incorrect Interval to Duration Casting [\#4553](https://github.com/apache/arrow-rs/issues/4553) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Too large validity buffer pre-allocation in `FixedSizeListBuilder::new` [\#4549](https://github.com/apache/arrow-rs/issues/4549) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Like with wildcards fail to match fields with new lines. [\#4547](https://github.com/apache/arrow-rs/issues/4547) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Timestamp Interval Arithmetic Ignores Timezone [\#4457](https://github.com/apache/arrow-rs/issues/4457) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- refactor: simplify hour\_dyn\(\) with time\_fraction\_dyn\(\) [\#4588](https://github.com/apache/arrow-rs/pull/4588) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jackwener](https://github.com/jackwener))
+- Move from\_iter\_values to GenericByteArray [\#4586](https://github.com/apache/arrow-rs/pull/4586) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Mark GenericByteArray::new\_unchecked unsafe [\#4584](https://github.com/apache/arrow-rs/pull/4584) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Configurable Duration Display [\#4581](https://github.com/apache/arrow-rs/pull/4581) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix take\_bytes Null and Overflow Handling \(\#4576\) [\#4579](https://github.com/apache/arrow-rs/pull/4579) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Move chrono-tz arithmetic tests to integration [\#4571](https://github.com/apache/arrow-rs/pull/4571) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Write Page Offset Index For All-Nan Pages [\#4567](https://github.com/apache/arrow-rs/pull/4567) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([MachaelLee](https://github.com/MachaelLee))
+- support NullArray un arith/boolean kernel [\#4566](https://github.com/apache/arrow-rs/pull/4566) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([smiklos](https://github.com/smiklos))
+- Remove Sync from arrow-flight example [\#4564](https://github.com/apache/arrow-rs/pull/4564) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Fix interval to duration casting \(\#4553\) [\#4562](https://github.com/apache/arrow-rs/pull/4562) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- docs: fix wrong parameter name [\#4559](https://github.com/apache/arrow-rs/pull/4559) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([SteveLauC](https://github.com/SteveLauC))
+- Fix FixedSizeListBuilder capacity \(\#4549\) [\#4552](https://github.com/apache/arrow-rs/pull/4552) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- docs: fix wrong inline code snippet in parquet document [\#4550](https://github.com/apache/arrow-rs/pull/4550) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([SteveLauC](https://github.com/SteveLauC))
+- fix multiline wildcard likes \(fixes \#4547\) [\#4548](https://github.com/apache/arrow-rs/pull/4548) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([nl5887](https://github.com/nl5887))
+- Provide default `is_empty` impl for `arrow::array::ArrayBuilder` [\#4543](https://github.com/apache/arrow-rs/pull/4543) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- Add RowConverter::append \(\#4479\) [\#4541](https://github.com/apache/arrow-rs/pull/4541) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Clarify GenericColumnReader::read\_records [\#4540](https://github.com/apache/arrow-rs/pull/4540) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Initial loongarch port [\#4538](https://github.com/apache/arrow-rs/pull/4538) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([xiangzhai](https://github.com/xiangzhai))
+- Update proc-macro2 requirement from =1.0.64 to =1.0.66 [\#4537](https://github.com/apache/arrow-rs/pull/4537) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- add a validity slice access for boolean array builders [\#4536](https://github.com/apache/arrow-rs/pull/4536) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([ChristianBeilschmidt](https://github.com/ChristianBeilschmidt))
+- use new num version instead of explicit num-complex dependency [\#4532](https://github.com/apache/arrow-rs/pull/4532) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mwlon](https://github.com/mwlon))
+- feat: Support `FixedSizedListArray` for `length` kernel [\#4520](https://github.com/apache/arrow-rs/pull/4520) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+## [44.0.0](https://github.com/apache/arrow-rs/tree/44.0.0) (2023-07-14)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/43.0.0...44.0.0)
+
+**Breaking changes:**
+
+- Use Parser for cast kernel \(\#4512\) [\#4513](https://github.com/apache/arrow-rs/pull/4513) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add Datum based arithmetic kernels \(\#3999\)  [\#4465](https://github.com/apache/arrow-rs/pull/4465) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- eq\_dyn\_binary\_scalar should support FixedSizeBinary types [\#4491](https://github.com/apache/arrow-rs/issues/4491) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Port Tests from Deprecated Arithmetic Kernels [\#4480](https://github.com/apache/arrow-rs/issues/4480) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Implement RecordBatchReader for Boxed trait object [\#4474](https://github.com/apache/arrow-rs/issues/4474) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support `Date` - `Date` kernel [\#4383](https://github.com/apache/arrow-rs/issues/4383) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Default FlightSqlService Implementations [\#4372](https://github.com/apache/arrow-rs/issues/4372) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Fixed bugs:**
+
+- Parquet: `AsyncArrowWriter` to a file corrupts the footer for large columns [\#4526](https://github.com/apache/arrow-rs/issues/4526) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- \[object\_store\] Failure to send bytes to azure [\#4522](https://github.com/apache/arrow-rs/issues/4522)
+- Cannot cast string '2021-01-02' to value of Date64 type [\#4512](https://github.com/apache/arrow-rs/issues/4512) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Incorrect Interval Subtraction [\#4489](https://github.com/apache/arrow-rs/issues/4489) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Interval Negation Incorrect [\#4488](https://github.com/apache/arrow-rs/issues/4488) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Parquet: AsyncArrowWriter inner buffer is not correctly limited and causes OOM [\#4477](https://github.com/apache/arrow-rs/issues/4477) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Merged pull requests:**
+
+- Fix AsyncArrowWriter flush for large buffer sizes \(\#4526\) [\#4527](https://github.com/apache/arrow-rs/pull/4527) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Cleanup cast\_primitive\_to\_list [\#4511](https://github.com/apache/arrow-rs/pull/4511) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Bump actions/upload-pages-artifact from 1 to 2 [\#4508](https://github.com/apache/arrow-rs/pull/4508) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Support Date - Date \(\#4383\) [\#4504](https://github.com/apache/arrow-rs/pull/4504) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Bump actions/labeler from 4.2.0 to 4.3.0 [\#4501](https://github.com/apache/arrow-rs/pull/4501) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Update proc-macro2 requirement from =1.0.63 to =1.0.64 [\#4500](https://github.com/apache/arrow-rs/pull/4500) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add negate kernels \(\#4488\) [\#4494](https://github.com/apache/arrow-rs/pull/4494) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add Datum Arithmetic tests, Fix Interval Substraction \(\#4480\) [\#4493](https://github.com/apache/arrow-rs/pull/4493) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- support FixedSizeBinary types in eq\_dyn\_binary\_scalar/neq\_dyn\_binary\_scalar [\#4492](https://github.com/apache/arrow-rs/pull/4492) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([maxburke](https://github.com/maxburke))
+- Add default implementations to the FlightSqlService trait [\#4485](https://github.com/apache/arrow-rs/pull/4485) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([rossjones](https://github.com/rossjones))
+- add num-complex requirement [\#4482](https://github.com/apache/arrow-rs/pull/4482) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mwlon](https://github.com/mwlon))
+- fix incorrect buffer size limiting in parquet async writer [\#4478](https://github.com/apache/arrow-rs/pull/4478) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([richox](https://github.com/richox))
+- feat: support RecordBatchReader on boxed trait objects [\#4475](https://github.com/apache/arrow-rs/pull/4475) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Improve in-place primitive sorts by 13-67% [\#4473](https://github.com/apache/arrow-rs/pull/4473) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Add Scalar/Datum abstraction \(\#1047\) [\#4393](https://github.com/apache/arrow-rs/pull/4393) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+## [43.0.0](https://github.com/apache/arrow-rs/tree/43.0.0) (2023-06-30)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/42.0.0...43.0.0)
+
+**Breaking changes:**
+
+- Simplify ffi import/export [\#4447](https://github.com/apache/arrow-rs/pull/4447) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Virgiel](https://github.com/Virgiel))
+- Return Result from Parquet Row APIs [\#4428](https://github.com/apache/arrow-rs/pull/4428) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([zeevm](https://github.com/zeevm))
+- Remove Binary Dictionary Arithmetic Support [\#4407](https://github.com/apache/arrow-rs/pull/4407) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Request: a way to copy a `Row` to `Rows` [\#4466](https://github.com/apache/arrow-rs/issues/4466) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Reuse schema when importing from FFI [\#4444](https://github.com/apache/arrow-rs/issues/4444) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- \[FlightSQL\] Allow implementations of `FlightSqlService` to handle custom actions and commands [\#4439](https://github.com/apache/arrow-rs/issues/4439)
+- Support `NullBuilder` [\#4429](https://github.com/apache/arrow-rs/issues/4429) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Regression in  in parquet `42.0.0` : Bad parquet column indexes for All Null Columns, resulting in `Parquet error: StructArrayReader out of sync` on read [\#4459](https://github.com/apache/arrow-rs/issues/4459) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Regression in 42.0.0: Parsing fractional intervals without leading 0 is not supported [\#4424](https://github.com/apache/arrow-rs/issues/4424) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Documentation updates:**
+
+- doc: deploy crate docs to GitHub pages [\#4436](https://github.com/apache/arrow-rs/pull/4436) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([xxchan](https://github.com/xxchan))
+
+**Merged pull requests:**
+
+- Append Row to Rows \(\#4466\) [\#4470](https://github.com/apache/arrow-rs/pull/4470) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat\(flight-sql\): Allow implementations of FlightSqlService to handle custom actions and commands [\#4463](https://github.com/apache/arrow-rs/pull/4463) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([amartins23](https://github.com/amartins23))
+- Docs: Add clearer API doc links [\#4461](https://github.com/apache/arrow-rs/pull/4461) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Fix empty offset index for all null columns \(\#4459\) [\#4460](https://github.com/apache/arrow-rs/pull/4460) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Bump peaceiris/actions-gh-pages from 3.9.2 to 3.9.3 [\#4455](https://github.com/apache/arrow-rs/pull/4455) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Convince the compiler to auto-vectorize the range check in parquet DictionaryBuffer [\#4453](https://github.com/apache/arrow-rs/pull/4453) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([jhorstmann](https://github.com/jhorstmann))
+- fix docs deployment [\#4452](https://github.com/apache/arrow-rs/pull/4452) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([xxchan](https://github.com/xxchan))
+- Update indexmap requirement from 1.9 to 2.0 [\#4451](https://github.com/apache/arrow-rs/pull/4451) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Update proc-macro2 requirement from =1.0.60 to =1.0.63 [\#4450](https://github.com/apache/arrow-rs/pull/4450) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump actions/deploy-pages from 1 to 2 [\#4449](https://github.com/apache/arrow-rs/pull/4449) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Revise error message in From\<Buffer\> for ScalarBuffer [\#4446](https://github.com/apache/arrow-rs/pull/4446) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- minor: remove useless mut [\#4443](https://github.com/apache/arrow-rs/pull/4443) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jackwener](https://github.com/jackwener))
+- unify substring for binary&utf8 [\#4442](https://github.com/apache/arrow-rs/pull/4442) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jackwener](https://github.com/jackwener))
+- Casting fixedsizelist to list/largelist [\#4433](https://github.com/apache/arrow-rs/pull/4433) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jayzhan211](https://github.com/jayzhan211))
+- feat: support `NullBuilder` [\#4430](https://github.com/apache/arrow-rs/pull/4430) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Remove Float64 -\> Float32 cast in IPC Reader [\#4427](https://github.com/apache/arrow-rs/pull/4427) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([ming08108](https://github.com/ming08108))
+- Parse intervals like `.5` the same as `0.5` [\#4425](https://github.com/apache/arrow-rs/pull/4425) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- feat: add strict mode to json reader [\#4421](https://github.com/apache/arrow-rs/pull/4421) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([blinkseb](https://github.com/blinkseb))
+- Add DictionaryArray::occupancy [\#4415](https://github.com/apache/arrow-rs/pull/4415) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+## [42.0.0](https://github.com/apache/arrow-rs/tree/42.0.0) (2023-06-16)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/41.0.0...42.0.0)
+
+**Breaking changes:**
+
+- Remove 64-bit to 32-bit Cast from IPC Reader [\#4412](https://github.com/apache/arrow-rs/pull/4412) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([ming08108](https://github.com/ming08108))
+- Truncate Min/Max values in the Column Index [\#4389](https://github.com/apache/arrow-rs/pull/4389) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([AdamGS](https://github.com/AdamGS))
+- feat\(flight\): harmonize server metadata APIs [\#4384](https://github.com/apache/arrow-rs/pull/4384) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([roeap](https://github.com/roeap))
+- Move record delimiting into ColumnReader \(\#4365\) [\#4376](https://github.com/apache/arrow-rs/pull/4376) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Changed array\_to\_json\_array to take &dyn Array [\#4370](https://github.com/apache/arrow-rs/pull/4370) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dadepo](https://github.com/dadepo))
+- Make PrimitiveArray::with\_timezone consuming [\#4366](https://github.com/apache/arrow-rs/pull/4366) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Add doc example of constructing a MapArray [\#4385](https://github.com/apache/arrow-rs/issues/4385) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support `millisecond` and `microsecond` functions [\#4374](https://github.com/apache/arrow-rs/issues/4374) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Changed array\_to\_json\_array to take &dyn Array [\#4369](https://github.com/apache/arrow-rs/issues/4369) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- compute::ord kernel for getting min and max of two scalar/array values [\#4347](https://github.com/apache/arrow-rs/issues/4347) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Release 41.0.0 of arrow/arrow-flight/parquet/parquet-derive [\#4346](https://github.com/apache/arrow-rs/issues/4346)
+- Refactor CAST tests to use new cast array syntax [\#4336](https://github.com/apache/arrow-rs/issues/4336) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- pass bytes directly to parquet's KeyValue [\#4317](https://github.com/apache/arrow-rs/issues/4317)
+- PyArrow conversions could return TypeError if provided incorrect Python type [\#4312](https://github.com/apache/arrow-rs/issues/4312) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Have array\_to\_json\_array support Map [\#4297](https://github.com/apache/arrow-rs/issues/4297) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- FlightSQL: Add helpers to create `CommandGetXdbcTypeInfo` responses \(`XdbcInfoValue` and builders\) [\#4257](https://github.com/apache/arrow-rs/issues/4257) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Have array\_to\_json\_array support FixedSizeList  [\#4248](https://github.com/apache/arrow-rs/issues/4248) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Truncate ColumnIndex ByteArray Statistics [\#4126](https://github.com/apache/arrow-rs/issues/4126) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Arrow compute kernel regards selection vector [\#4095](https://github.com/apache/arrow-rs/issues/4095) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Wrongly calculated data compressed length in IPC writer [\#4410](https://github.com/apache/arrow-rs/issues/4410) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Take Kernel Handles Nullable Indices Incorrectly [\#4404](https://github.com/apache/arrow-rs/issues/4404) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- StructBuilder::new Doesn't Validate Builder DataTypes [\#4397](https://github.com/apache/arrow-rs/issues/4397) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Parquet error: Not all children array length are the same! when using RowSelection to read a parquet file [\#4396](https://github.com/apache/arrow-rs/issues/4396)
+- RecordReader::skip\_records Is Incorrect for Repeated Columns [\#4368](https://github.com/apache/arrow-rs/issues/4368) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- List-of-String Array panics in the presence of row filters [\#4365](https://github.com/apache/arrow-rs/issues/4365) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Fail to read block compressed gzip files with parquet-fromcsv [\#4173](https://github.com/apache/arrow-rs/issues/4173) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Closed issues:**
+
+- Have a parquet file not able to be deduped via arrow-rs, complains about Decimal precision? [\#4356](https://github.com/apache/arrow-rs/issues/4356)
+- Question: Could we move `dict_id, dict_is_ordered` into DataType? [\#4325](https://github.com/apache/arrow-rs/issues/4325)
+
+**Merged pull requests:**
+
+- Fix reading gzip file with multiple gzip headers in parquet-fromcsv. [\#4419](https://github.com/apache/arrow-rs/pull/4419) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([ghuls](https://github.com/ghuls))
+- Cleanup nullif kernel [\#4416](https://github.com/apache/arrow-rs/pull/4416) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix bug in IPC logic that determines if the buffer should be compressed or not [\#4411](https://github.com/apache/arrow-rs/pull/4411) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([lwpyr](https://github.com/lwpyr))
+- Faster unpacking of Int32Type dictionary [\#4406](https://github.com/apache/arrow-rs/pull/4406) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Improve `take` kernel performance on primitive arrays, fix bad null index handling  \(\#4404\) [\#4405](https://github.com/apache/arrow-rs/pull/4405) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- More take benchmarks [\#4403](https://github.com/apache/arrow-rs/pull/4403) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add `BooleanBuffer::new_unset` and `BooleanBuffer::new_set` and `BooleanArray::new_null` constructors [\#4402](https://github.com/apache/arrow-rs/pull/4402) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add PrimitiveBuilder type constructors [\#4401](https://github.com/apache/arrow-rs/pull/4401) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- StructBuilder Validate Child Data \(\#4397\) [\#4400](https://github.com/apache/arrow-rs/pull/4400) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Faster UTF-8 truncation [\#4399](https://github.com/apache/arrow-rs/pull/4399) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Minor: Derive `Hash` impls for `CastOptions` and `FormatOptions` [\#4395](https://github.com/apache/arrow-rs/pull/4395) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Fix typo in README [\#4394](https://github.com/apache/arrow-rs/pull/4394) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([okue](https://github.com/okue))
+- Improve parquet `WriterProperites` and `ReaderProperties` docs [\#4392](https://github.com/apache/arrow-rs/pull/4392) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([alamb](https://github.com/alamb))
+- Cleanup downcast macros [\#4391](https://github.com/apache/arrow-rs/pull/4391) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update proc-macro2 requirement from =1.0.59 to =1.0.60 [\#4388](https://github.com/apache/arrow-rs/pull/4388) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Consolidate ByteArray::from\_iterator [\#4386](https://github.com/apache/arrow-rs/pull/4386) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add MapArray constructors and doc example [\#4382](https://github.com/apache/arrow-rs/pull/4382) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Documentation Improvements [\#4381](https://github.com/apache/arrow-rs/pull/4381) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add NullBuffer and BooleanBuffer From conversions [\#4380](https://github.com/apache/arrow-rs/pull/4380) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add more examples of constructing Boolean, Primitive, String,  and Decimal Arrays, and From impl for i256 [\#4379](https://github.com/apache/arrow-rs/pull/4379) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Add ListArrayReader benchmarks [\#4378](https://github.com/apache/arrow-rs/pull/4378) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Update comfy-table requirement from 6.0 to 7.0 [\#4377](https://github.com/apache/arrow-rs/pull/4377) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- feat: Add`microsecond` and `millisecond` kernels [\#4375](https://github.com/apache/arrow-rs/pull/4375) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Update hashbrown requirement from 0.13 to 0.14 [\#4373](https://github.com/apache/arrow-rs/pull/4373) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- minor: use as\_boolean to resolve TODO [\#4367](https://github.com/apache/arrow-rs/pull/4367) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jackwener](https://github.com/jackwener))
+- Have array\_to\_json\_array support MapArray [\#4364](https://github.com/apache/arrow-rs/pull/4364) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dadepo](https://github.com/dadepo))
+- deprecate: as\_decimal\_array [\#4363](https://github.com/apache/arrow-rs/pull/4363) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Add support for FixedSizeList in array\_to\_json\_array [\#4361](https://github.com/apache/arrow-rs/pull/4361) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dadepo](https://github.com/dadepo))
+- refact: use as\_primitive in cast.rs test [\#4360](https://github.com/apache/arrow-rs/pull/4360) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- feat\(flight\): add xdbc type info helpers [\#4359](https://github.com/apache/arrow-rs/pull/4359) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([roeap](https://github.com/roeap))
+- Minor: float16 to json [\#4358](https://github.com/apache/arrow-rs/pull/4358) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Raise TypeError on PyArrow import [\#4316](https://github.com/apache/arrow-rs/pull/4316) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Arrow Cast: Fixed Point Arithmetic for Interval Parsing [\#4291](https://github.com/apache/arrow-rs/pull/4291) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mr-brobot](https://github.com/mr-brobot))
+## [41.0.0](https://github.com/apache/arrow-rs/tree/41.0.0) (2023-06-02)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/40.0.0...41.0.0)
+
+**Breaking changes:**
+
+- Rename list contains kernels to in\_list \(\#4289\) [\#4342](https://github.com/apache/arrow-rs/pull/4342) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Move BooleanBufferBuilder and NullBufferBuilder to arrow\_buffer [\#4338](https://github.com/apache/arrow-rs/pull/4338) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add separate row\_count and level\_count to PageMetadata \(\#4321\)  [\#4326](https://github.com/apache/arrow-rs/pull/4326) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Treat legacy TIMSETAMP\_X converted types as UTC [\#4309](https://github.com/apache/arrow-rs/pull/4309) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([sergiimk](https://github.com/sergiimk))
+- Simplify parquet PageIterator [\#4306](https://github.com/apache/arrow-rs/pull/4306) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add Builder style APIs and docs for `FlightData`,` FlightInfo`, `FlightEndpoint`, `Locaation` and `Ticket` [\#4294](https://github.com/apache/arrow-rs/pull/4294) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Make GenericColumnWriter Send [\#4287](https://github.com/apache/arrow-rs/pull/4287) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- feat: update flight-sql to latest specs [\#4250](https://github.com/apache/arrow-rs/pull/4250) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([roeap](https://github.com/roeap))
+- feat\(api!\): make ArrowArrayStreamReader Send [\#4232](https://github.com/apache/arrow-rs/pull/4232) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+
+**Implemented enhancements:**
+
+- Make SerializedRowGroupReader::new\(\) Public [\#4330](https://github.com/apache/arrow-rs/issues/4330) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Speed up i256 division and remainder operations [\#4302](https://github.com/apache/arrow-rs/issues/4302) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- export function parquet\_to\_array\_schema\_and\_fields [\#4298](https://github.com/apache/arrow-rs/issues/4298) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- FLightSQL: add helpers to create `CommandGetCatalogs`, `CommandGetSchemas`, and `CommandGetTables` requests [\#4295](https://github.com/apache/arrow-rs/issues/4295) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Make ColumnWriter Send [\#4286](https://github.com/apache/arrow-rs/issues/4286) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Add Builder for `FlightInfo` to make it easier to create new requests [\#4281](https://github.com/apache/arrow-rs/issues/4281) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Support Writing/Reading Decimal256 to/from Parquet [\#4264](https://github.com/apache/arrow-rs/issues/4264) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- FlightSQL: Add helpers to create `CommandGetSqlInfo` responses \(`SqlInfoValue` and builders\) [\#4256](https://github.com/apache/arrow-rs/issues/4256) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Update flight-sql implementation to latest specs [\#4249](https://github.com/apache/arrow-rs/issues/4249) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Make ArrowArrayStreamReader Send [\#4222](https://github.com/apache/arrow-rs/issues/4222) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support writing FixedSizeList to Parquet [\#4214](https://github.com/apache/arrow-rs/issues/4214) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Cast between `Intervals` [\#4181](https://github.com/apache/arrow-rs/issues/4181) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Splice Parquet Data [\#4155](https://github.com/apache/arrow-rs/issues/4155) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- CSV Schema More Flexible Timestamp Inference [\#4131](https://github.com/apache/arrow-rs/issues/4131) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Doc for arrow\_flight::sql is missing enums that are Xdbc related [\#4339](https://github.com/apache/arrow-rs/issues/4339) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- concat\_batches panics with total\_len \<= bit\_len assertion for records with lists [\#4324](https://github.com/apache/arrow-rs/issues/4324) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Incorrect PageMetadata Row Count returned for V1 DataPage [\#4321](https://github.com/apache/arrow-rs/issues/4321) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- \[parquet\] Not following the spec for TIMESTAMP\_MILLIS legacy converted types [\#4308](https://github.com/apache/arrow-rs/issues/4308) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- ambiguous glob re-exports of contains\_utf8 [\#4289](https://github.com/apache/arrow-rs/issues/4289) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- flight\_sql\_client --header "key: value" yields a value with a leading whitespace [\#4270](https://github.com/apache/arrow-rs/issues/4270) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Casting Timestamp to date is off by one day for dates before 1970-01-01 [\#4211](https://github.com/apache/arrow-rs/issues/4211) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Don't infer 16-byte decimal as decimal256 [\#4349](https://github.com/apache/arrow-rs/pull/4349) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Fix MutableArrayData::extend\_nulls \(\#1230\) [\#4343](https://github.com/apache/arrow-rs/pull/4343) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update FlightSQL metadata locations, names and docs [\#4341](https://github.com/apache/arrow-rs/pull/4341) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- chore: expose Xdbc related FlightSQL enums [\#4340](https://github.com/apache/arrow-rs/pull/4340) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([appletreeisyellow](https://github.com/appletreeisyellow))
+- Update pyo3 requirement from 0.18 to 0.19 [\#4335](https://github.com/apache/arrow-rs/pull/4335) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Skip unnecessary null checks in MutableArrayData [\#4333](https://github.com/apache/arrow-rs/pull/4333) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: add read parquet by custom rowgroup examples [\#4332](https://github.com/apache/arrow-rs/pull/4332) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([sundy-li](https://github.com/sundy-li))
+- Make SerializedRowGroupReader::new\(\) public [\#4331](https://github.com/apache/arrow-rs/pull/4331) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([burmecia](https://github.com/burmecia))
+- Don't split record across pages \(\#3680\) [\#4327](https://github.com/apache/arrow-rs/pull/4327) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- fix date conversion if timestamp below unixtimestamp [\#4323](https://github.com/apache/arrow-rs/pull/4323) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([comphead](https://github.com/comphead))
+- Short-circuit on exhausted page in skip\_records [\#4320](https://github.com/apache/arrow-rs/pull/4320) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Handle trailing padding when skipping repetition levels \(\#3911\) [\#4319](https://github.com/apache/arrow-rs/pull/4319) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Use `page_size` consistently, deprecate `pagesize` in parquet WriterProperties [\#4313](https://github.com/apache/arrow-rs/pull/4313) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([alamb](https://github.com/alamb))
+- Add roundtrip tests for Decimal256 and fix issues \(\#4264\) [\#4311](https://github.com/apache/arrow-rs/pull/4311) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Expose page-level arrow reader API \(\#4298\) [\#4307](https://github.com/apache/arrow-rs/pull/4307) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Speed up i256 division and remainder operations [\#4303](https://github.com/apache/arrow-rs/pull/4303) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- feat\(flight\): support int32\_to\_int32\_list\_map in sql infos [\#4300](https://github.com/apache/arrow-rs/pull/4300) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([roeap](https://github.com/roeap))
+- feat\(flight\): add helpers to handle `CommandGetCatalogs`, `CommandGetSchemas`, and `CommandGetTables` requests [\#4296](https://github.com/apache/arrow-rs/pull/4296) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([roeap](https://github.com/roeap))
+- Improve docs and tests for `SqlInfoList [\#4293](https://github.com/apache/arrow-rs/pull/4293) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- minor: fix arrow\_row docs.rs links [\#4292](https://github.com/apache/arrow-rs/pull/4292) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([roeap](https://github.com/roeap))
+- Update proc-macro2 requirement from =1.0.58 to =1.0.59 [\#4290](https://github.com/apache/arrow-rs/pull/4290) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Improve `ArrowWriter` memory usage: Buffer Pages in ArrowWriter instead of RecordBatch \(\#3871\) [\#4280](https://github.com/apache/arrow-rs/pull/4280) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Minor: Add more docstrings in arrow-flight [\#4279](https://github.com/apache/arrow-rs/pull/4279) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Add `Debug` impls for `ArrowWriter` and `SerializedFileWriter` [\#4278](https://github.com/apache/arrow-rs/pull/4278) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([alamb](https://github.com/alamb))
+- Expose `RecordBatchWriter` to `arrow` crate [\#4277](https://github.com/apache/arrow-rs/pull/4277) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alexandreyc](https://github.com/alexandreyc))
+- Update criterion requirement from 0.4 to 0.5 [\#4275](https://github.com/apache/arrow-rs/pull/4275) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add parquet-concat [\#4274](https://github.com/apache/arrow-rs/pull/4274) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Convert FixedSizeListArray to GenericListArray [\#4273](https://github.com/apache/arrow-rs/pull/4273) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: support 'Decimal256' for parquet [\#4272](https://github.com/apache/arrow-rs/pull/4272) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Weijun-H](https://github.com/Weijun-H))
+- Strip leading whitespace from flight\_sql\_client custom header values [\#4271](https://github.com/apache/arrow-rs/pull/4271) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([mkmik](https://github.com/mkmik))
+- Add Append Column API \(\#4155\) [\#4269](https://github.com/apache/arrow-rs/pull/4269) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Derive Default for WriterProperties [\#4268](https://github.com/apache/arrow-rs/pull/4268) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Parquet Reader/writer for fixed-size list arrays  [\#4267](https://github.com/apache/arrow-rs/pull/4267) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([dexterduck](https://github.com/dexterduck))
+- feat\(flight\): add sql-info helpers [\#4266](https://github.com/apache/arrow-rs/pull/4266) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([roeap](https://github.com/roeap))
+- Convert parquet metadata back to builders [\#4265](https://github.com/apache/arrow-rs/pull/4265) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add constructors for FixedSize array types \(\#3879\) [\#4263](https://github.com/apache/arrow-rs/pull/4263) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Extract IPC ArrayReader struct [\#4259](https://github.com/apache/arrow-rs/pull/4259) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update object\_store requirement from 0.5 to 0.6 [\#4258](https://github.com/apache/arrow-rs/pull/4258) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Support Absolute Timestamps in CSV Schema Inference \(\#4131\) [\#4217](https://github.com/apache/arrow-rs/pull/4217) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: cast between `Intervals` [\#4182](https://github.com/apache/arrow-rs/pull/4182) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+## [40.0.0](https://github.com/apache/arrow-rs/tree/40.0.0) (2023-05-19)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/39.0.0...40.0.0)
+
+**Breaking changes:**
+
+- Prefetch page index \(\#4090\) [\#4216](https://github.com/apache/arrow-rs/pull/4216) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add RecordBatchWriter trait and implement it for CSV, JSON, IPC and P… [\#4206](https://github.com/apache/arrow-rs/pull/4206) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alexandreyc](https://github.com/alexandreyc))
+- Remove powf\_scalar kernel [\#4187](https://github.com/apache/arrow-rs/pull/4187) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Allow format specification in cast [\#4169](https://github.com/apache/arrow-rs/pull/4169) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([parthchandra](https://github.com/parthchandra))
+
+**Implemented enhancements:**
+
+- ObjectStore with\_url Should Handle Path [\#4199](https://github.com/apache/arrow-rs/issues/4199)
+- Support `Interval` +/- `Interval` [\#4178](https://github.com/apache/arrow-rs/issues/4178) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- \[parquet\] add compression info to `print_column_chunk_metadata()` [\#4172](https://github.com/apache/arrow-rs/issues/4172) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Allow cast to take in a format specification [\#4168](https://github.com/apache/arrow-rs/issues/4168) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support extended pow arithmetic [\#4166](https://github.com/apache/arrow-rs/issues/4166) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Preload page index for async ParquetObjectReader [\#4090](https://github.com/apache/arrow-rs/issues/4090) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Fixed bugs:**
+
+- Subtracting `Timestamp` from `Timestamp`  should produce a `Duration` \(not `Timestamp`\)  [\#3964](https://github.com/apache/arrow-rs/issues/3964) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Arrow Arithmetic: Subtract timestamps [\#4244](https://github.com/apache/arrow-rs/pull/4244) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mr-brobot](https://github.com/mr-brobot))
+- Update proc-macro2 requirement from =1.0.57 to =1.0.58 [\#4236](https://github.com/apache/arrow-rs/pull/4236) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Fix Nightly Clippy Lints [\#4233](https://github.com/apache/arrow-rs/pull/4233) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Minor: use all primitive types in test\_layouts [\#4229](https://github.com/apache/arrow-rs/pull/4229) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Add close method to RecordBatchWriter trait [\#4228](https://github.com/apache/arrow-rs/pull/4228) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alexandreyc](https://github.com/alexandreyc))
+- Update proc-macro2 requirement from =1.0.56 to =1.0.57 [\#4219](https://github.com/apache/arrow-rs/pull/4219) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Feat docs [\#4215](https://github.com/apache/arrow-rs/pull/4215) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Folyd](https://github.com/Folyd))
+- feat: Support bitwise and boolean aggregate functions [\#4210](https://github.com/apache/arrow-rs/pull/4210) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Document how to sort a RecordBatch [\#4204](https://github.com/apache/arrow-rs/pull/4204) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix incorrect cast Timestamp with Timezone [\#4201](https://github.com/apache/arrow-rs/pull/4201) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([aprimadi](https://github.com/aprimadi))
+- Add implementation of `RecordBatchReader` for CSV reader [\#4195](https://github.com/apache/arrow-rs/pull/4195) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alexandreyc](https://github.com/alexandreyc))
+- Add Sliced ListArray test \(\#3748\) [\#4186](https://github.com/apache/arrow-rs/pull/4186) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- refactor: simplify can\_cast\_types code. [\#4185](https://github.com/apache/arrow-rs/pull/4185) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jackwener](https://github.com/jackwener))
+- Minor: support new types in struct\_builder.rs [\#4177](https://github.com/apache/arrow-rs/pull/4177) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- feat: add compression info to print\_column\_chunk\_metadata\(\) [\#4176](https://github.com/apache/arrow-rs/pull/4176) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([SteveLauC](https://github.com/SteveLauC))
+## [39.0.0](https://github.com/apache/arrow-rs/tree/39.0.0) (2023-05-05)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/38.0.0...39.0.0)
+
+**Breaking changes:**
+
+- Allow creating unbuffered streamreader [\#4165](https://github.com/apache/arrow-rs/pull/4165) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([ming08108](https://github.com/ming08108))
+- Cleanup ChunkReader \(\#4118\) [\#4156](https://github.com/apache/arrow-rs/pull/4156) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Remove Type from NativeIndex [\#4146](https://github.com/apache/arrow-rs/pull/4146) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Don't Duplicate Offset Index on RowGroupMetadata [\#4142](https://github.com/apache/arrow-rs/pull/4142) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Return BooleanBuffer from BooleanBufferBuilder [\#4140](https://github.com/apache/arrow-rs/pull/4140) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Cleanup CSV schema inference \(\#4129\) \(\#4130\) [\#4133](https://github.com/apache/arrow-rs/pull/4133) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Remove deprecated parquet ArrowReader [\#4125](https://github.com/apache/arrow-rs/pull/4125) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- refactor: construct `StructArray` w/ `FieldRef` [\#4116](https://github.com/apache/arrow-rs/pull/4116) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([crepererum](https://github.com/crepererum))
+- Ignore Field Metadata in equals\_datatype for Dictionary, RunEndEncoded, Map and Union [\#4111](https://github.com/apache/arrow-rs/pull/4111) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Add StructArray Constructors \(\#3879\) [\#4064](https://github.com/apache/arrow-rs/pull/4064) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Release 39.0.0 of arrow/arrow-flight/parquet/parquet-derive \(next release after 38.0.0\) [\#4170](https://github.com/apache/arrow-rs/issues/4170) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Fixed point decimal multiplication for DictionaryArray [\#4135](https://github.com/apache/arrow-rs/issues/4135) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Remove Seek Requirement from CSV ReaderBuilder [\#4130](https://github.com/apache/arrow-rs/issues/4130) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Inconsistent CSV Inference and Parsing DateTime Handling [\#4129](https://github.com/apache/arrow-rs/issues/4129) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support accessing ipc Reader/Writer inner by reference [\#4121](https://github.com/apache/arrow-rs/issues/4121)
+- Add Type Declarations for All Primitive Tensors and Buffer Builders [\#4112](https://github.com/apache/arrow-rs/issues/4112) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support `Interval + Timestamp` and `Interval + Date` in addition to `Timestamp + Interval` and `Interval + Date` [\#4094](https://github.com/apache/arrow-rs/issues/4094) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Enable setting FlightDescriptor on FlightDataEncoderBuilder [\#3855](https://github.com/apache/arrow-rs/issues/3855) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Fixed bugs:**
+
+- Parquet Page Index Reader Assumes Consecutive Offsets [\#4149](https://github.com/apache/arrow-rs/issues/4149) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Equality of nested data types [\#4110](https://github.com/apache/arrow-rs/issues/4110) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Documentation updates:**
+
+- Improve Documentation of Parquet ChunkReader [\#4118](https://github.com/apache/arrow-rs/issues/4118)
+
+**Closed issues:**
+
+- add specific error log for empty JSON array [\#4105](https://github.com/apache/arrow-rs/issues/4105) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Prep for 39.0.0 [\#4171](https://github.com/apache/arrow-rs/pull/4171) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([iajoiner](https://github.com/iajoiner))
+- Support Compression in parquet-fromcsv [\#4160](https://github.com/apache/arrow-rs/pull/4160) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([suxiaogang223](https://github.com/suxiaogang223))
+- feat: support bitwise shift left/right with scalars [\#4159](https://github.com/apache/arrow-rs/pull/4159) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Cleanup reading page index \(\#4149\) \(\#4090\) [\#4151](https://github.com/apache/arrow-rs/pull/4151) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- feat: support `bitwise` shift left/right [\#4148](https://github.com/apache/arrow-rs/pull/4148) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- Don't hardcode port in FlightSQL tests [\#4145](https://github.com/apache/arrow-rs/pull/4145) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Better flight SQL example codes [\#4144](https://github.com/apache/arrow-rs/pull/4144) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([sundy-li](https://github.com/sundy-li))
+- chore: clean the code by using `as_primitive` [\#4143](https://github.com/apache/arrow-rs/pull/4143) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- docs: fix the wrong ln command in CONTRIBUTING.md [\#4139](https://github.com/apache/arrow-rs/pull/4139) ([SteveLauC](https://github.com/SteveLauC))
+- Infer Float64 for JSON Numerics Beyond Bounds of i64 [\#4138](https://github.com/apache/arrow-rs/pull/4138) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([SteveLauC](https://github.com/SteveLauC))
+- Support fixed point multiplication for DictionaryArray of Decimals [\#4136](https://github.com/apache/arrow-rs/pull/4136) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Make arrow\_json::ReaderBuilder method names consistent [\#4128](https://github.com/apache/arrow-rs/pull/4128) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: add get\_{ref, mut} to arrow\_ipc Reader and Writer [\#4122](https://github.com/apache/arrow-rs/pull/4122) ([sticnarf](https://github.com/sticnarf))
+- feat: support `Interval` + `Timestamp` and `Interval` + `Date` [\#4117](https://github.com/apache/arrow-rs/pull/4117) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- Support NullArray in JSON Reader [\#4114](https://github.com/apache/arrow-rs/pull/4114) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jiangzhx](https://github.com/jiangzhx))
+- Add Type Declarations for All Primitive Tensors and Buffer Builders [\#4113](https://github.com/apache/arrow-rs/pull/4113) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Update regex-syntax requirement from 0.6.27 to 0.7.1 [\#4107](https://github.com/apache/arrow-rs/pull/4107) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- feat: set FlightDescriptor on FlightDataEncoderBuilder [\#4101](https://github.com/apache/arrow-rs/pull/4101) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([Weijun-H](https://github.com/Weijun-H))
+- optimize cast for same decimal type and same scale [\#4088](https://github.com/apache/arrow-rs/pull/4088) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+
+## [38.0.0](https://github.com/apache/arrow-rs/tree/38.0.0) (2023-04-21)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/37.0.0...38.0.0)
+
+**Breaking changes:**
+
+- Remove DataType from PrimitiveArray constructors [\#4098](https://github.com/apache/arrow-rs/pull/4098) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use Into\<Arc\<str\>\> for PrimitiveArray::with\_timezone [\#4097](https://github.com/apache/arrow-rs/pull/4097) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Store StructArray entries in MapArray [\#4085](https://github.com/apache/arrow-rs/pull/4085) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add DictionaryArray Constructors \(\#3879\)  [\#4068](https://github.com/apache/arrow-rs/pull/4068) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Relax JSON schema inference generics [\#4063](https://github.com/apache/arrow-rs/pull/4063) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Remove ArrayData from Array \(\#3880\) [\#4061](https://github.com/apache/arrow-rs/pull/4061) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add CommandGetXdbcTypeInfo to Flight SQL Server [\#4055](https://github.com/apache/arrow-rs/pull/4055) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([c-thiel](https://github.com/c-thiel))
+- Remove old JSON Reader and Decoder \(\#3610\) [\#4052](https://github.com/apache/arrow-rs/pull/4052) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use BufRead for JSON Schema Inference [\#4041](https://github.com/apache/arrow-rs/pull/4041) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([WenyXu](https://github.com/WenyXu))
+
+**Implemented enhancements:**
+
+- Support dyn\_compare\_scalar for Decimal256 [\#4083](https://github.com/apache/arrow-rs/issues/4083) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Better JSON Reader Error Messages [\#4076](https://github.com/apache/arrow-rs/issues/4076) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Additional data type groups [\#4056](https://github.com/apache/arrow-rs/issues/4056) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Async JSON reader [\#4043](https://github.com/apache/arrow-rs/issues/4043) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Field::contains Should Recurse into DataType [\#4029](https://github.com/apache/arrow-rs/issues/4029) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Prevent UnionArray with Repeated Type IDs [\#3982](https://github.com/apache/arrow-rs/issues/3982) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support  `Timestamp` `+`/`-` `Interval` types [\#3963](https://github.com/apache/arrow-rs/issues/3963) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- First-Class Array Abstractions [\#3880](https://github.com/apache/arrow-rs/issues/3880) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Fixed bugs:**
+
+- Update readme to remove reference to Jira [\#4091](https://github.com/apache/arrow-rs/issues/4091)
+- OffsetBuffer::new Rejects 0 Offsets [\#4066](https://github.com/apache/arrow-rs/issues/4066) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Parquet AsyncArrowWriter not shutting down inner async writer.  [\#4058](https://github.com/apache/arrow-rs/issues/4058) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Flight SQL Server missing command type.googleapis.com/arrow.flight.protocol.sql.CommandGetXdbcTypeInfo [\#4054](https://github.com/apache/arrow-rs/issues/4054) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- RawJsonReader Errors with Empty Schema [\#4053](https://github.com/apache/arrow-rs/issues/4053) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- RawJsonReader Integer Truncation [\#4049](https://github.com/apache/arrow-rs/issues/4049) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Sparse UnionArray Equality Incorrect Offset Handling [\#4044](https://github.com/apache/arrow-rs/issues/4044) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Documentation updates:**
+
+- Write blog about improvements in JSON and CSV processing [\#4062](https://github.com/apache/arrow-rs/issues/4062) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- Parquet reader of Int96 columns and coercion to timestamps [\#4075](https://github.com/apache/arrow-rs/issues/4075)
+- Serializing timestamp from int \(json raw decoder\) [\#4069](https://github.com/apache/arrow-rs/issues/4069) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support casting to/from Interval and Duration [\#3998](https://github.com/apache/arrow-rs/issues/3998) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Fix Docs Typos [\#4100](https://github.com/apache/arrow-rs/pull/4100) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([rnarkk](https://github.com/rnarkk))
+- Update tonic-build requirement from =0.9.1 to =0.9.2 [\#4099](https://github.com/apache/arrow-rs/pull/4099) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Increase minimum chrono version to 0.4.24 [\#4093](https://github.com/apache/arrow-rs/pull/4093) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Simplify reference to GitHub issues [\#4092](https://github.com/apache/arrow-rs/pull/4092) ([bkmgit](https://github.com/bkmgit))
+- \[Minor\]: Add `Hash` trait to SortOptions. [\#4089](https://github.com/apache/arrow-rs/pull/4089) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mustafasrepo](https://github.com/mustafasrepo))
+- Include byte offsets in parquet-layout [\#4086](https://github.com/apache/arrow-rs/pull/4086) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- feat: Support dyn\_compare\_scalar for Decimal256 [\#4084](https://github.com/apache/arrow-rs/pull/4084) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Add ByteArray constructors \(\#3879\)  [\#4081](https://github.com/apache/arrow-rs/pull/4081) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update prost-build requirement from =0.11.8 to =0.11.9 [\#4080](https://github.com/apache/arrow-rs/pull/4080) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Improve JSON decoder errors \(\#4076\) [\#4079](https://github.com/apache/arrow-rs/pull/4079) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix Timestamp Numeric Truncation in JSON Reader [\#4074](https://github.com/apache/arrow-rs/pull/4074) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Serialize numeric to tape \(\#4069\) [\#4073](https://github.com/apache/arrow-rs/pull/4073) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: Prevent UnionArray with Repeated Type IDs [\#4070](https://github.com/apache/arrow-rs/pull/4070) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- Add PrimitiveArray::try\_new \(\#3879\) [\#4067](https://github.com/apache/arrow-rs/pull/4067) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add ListArray Constructors \(\#3879\)  [\#4065](https://github.com/apache/arrow-rs/pull/4065) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Shutdown parquet async writer [\#4059](https://github.com/apache/arrow-rs/pull/4059) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([kindly](https://github.com/kindly))
+- feat: additional data type groups [\#4057](https://github.com/apache/arrow-rs/pull/4057) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Fix precision loss in Raw JSON decoder \(\#4049\) [\#4051](https://github.com/apache/arrow-rs/pull/4051) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use lexical\_core in CSV and JSON parser \(~25% faster\) [\#4050](https://github.com/apache/arrow-rs/pull/4050) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add offsets accessors to variable length arrays \(\#3879\) [\#4048](https://github.com/apache/arrow-rs/pull/4048) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Document Async decoder usage \(\#4043\) \(\#78\) [\#4046](https://github.com/apache/arrow-rs/pull/4046) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix sparse union array equality \(\#4044\) [\#4045](https://github.com/apache/arrow-rs/pull/4045) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: DataType::contains support nested type [\#4042](https://github.com/apache/arrow-rs/pull/4042) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- feat: Support Timestamp +/- Interval types [\#4038](https://github.com/apache/arrow-rs/pull/4038) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- Fix object\_store CI [\#4037](https://github.com/apache/arrow-rs/pull/4037) ([tustvold](https://github.com/tustvold))
+- feat: cast from/to interval and duration [\#4020](https://github.com/apache/arrow-rs/pull/4020) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+
+## [37.0.0](https://github.com/apache/arrow-rs/tree/37.0.0) (2023-04-07)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/36.0.0...37.0.0)
+
+**Breaking changes:**
+
+- Fix timestamp handling in cast kernel \(\#1936\) \(\#4033\) [\#4034](https://github.com/apache/arrow-rs/pull/4034) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update tonic 0.9.1 [\#4011](https://github.com/apache/arrow-rs/pull/4011) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Use FieldRef in DataType \(\#3955\) [\#3983](https://github.com/apache/arrow-rs/pull/3983) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Store Timezone as Arc\<str\> [\#3976](https://github.com/apache/arrow-rs/pull/3976) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Panic instead of discarding nulls converting StructArray to RecordBatch -  \(\#3951\) [\#3953](https://github.com/apache/arrow-rs/pull/3953) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix\(flight\_sql\): PreparedStatement has no token for auth. [\#3948](https://github.com/apache/arrow-rs/pull/3948) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([youngsofun](https://github.com/youngsofun))
+- Add Strongly Typed Array Slice \(\#3929\) [\#3930](https://github.com/apache/arrow-rs/pull/3930) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add Zero-Copy Conversion between Vec and MutableBuffer [\#3920](https://github.com/apache/arrow-rs/pull/3920) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Support Decimals cast to Utf8/LargeUtf [\#3991](https://github.com/apache/arrow-rs/issues/3991) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support Date32/Date64 minus Interval [\#3962](https://github.com/apache/arrow-rs/issues/3962) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Reduce Cloning of Field [\#3955](https://github.com/apache/arrow-rs/issues/3955) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Support Deserializing Serde DataTypes to Arrow [\#3949](https://github.com/apache/arrow-rs/issues/3949) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add multiply\_fixed\_point [\#3946](https://github.com/apache/arrow-rs/issues/3946) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Strongly Typed Array Slicing [\#3929](https://github.com/apache/arrow-rs/issues/3929) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Make it easier to match FlightSQL messages [\#3874](https://github.com/apache/arrow-rs/issues/3874) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Support Casting Between Binary / LargeBinary and FixedSizeBinary [\#3826](https://github.com/apache/arrow-rs/issues/3826) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Incorrect Overflow Casting String to Timestamp [\#4033](https://github.com/apache/arrow-rs/issues/4033)
+- f16::ZERO and f16::ONE are mixed up [\#4016](https://github.com/apache/arrow-rs/issues/4016) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Handle overflow precision when casting from integer to decimal [\#3995](https://github.com/apache/arrow-rs/issues/3995) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- PrimitiveDictionaryBuilder.finish should use actual value type [\#3971](https://github.com/apache/arrow-rs/issues/3971) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- RecordBatch From StructArray Silently Discards Nulls [\#3952](https://github.com/apache/arrow-rs/issues/3952) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- I256 Checked Subtraction Overflows for i256::MINUS\_ONE [\#3942](https://github.com/apache/arrow-rs/issues/3942) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- I256 Checked Multiply Overflows for i256::MIN [\#3941](https://github.com/apache/arrow-rs/issues/3941) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- Remove non-existent `js` feature from README [\#4000](https://github.com/apache/arrow-rs/issues/4000) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support take on MapArray [\#3875](https://github.com/apache/arrow-rs/issues/3875) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Prep for 37.0.0 [\#4031](https://github.com/apache/arrow-rs/pull/4031) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([iajoiner](https://github.com/iajoiner))
+- Add RecordBatch::with\_schema [\#4028](https://github.com/apache/arrow-rs/pull/4028) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Only require compatible batch schema in ArrowWriter [\#4027](https://github.com/apache/arrow-rs/pull/4027) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add Fields::contains [\#4026](https://github.com/apache/arrow-rs/pull/4026) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Minor: add methods "is\_positive" and "signum" to i256 [\#4024](https://github.com/apache/arrow-rs/pull/4024) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Deprecate Array::data \(\#3880\) [\#4019](https://github.com/apache/arrow-rs/pull/4019) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: add tests for ArrowNativeTypeOp [\#4018](https://github.com/apache/arrow-rs/pull/4018) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- fix: f16::ZERO and f16::ONE are mixed up [\#4017](https://github.com/apache/arrow-rs/pull/4017) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Minor: Float16Tensor [\#4013](https://github.com/apache/arrow-rs/pull/4013) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Add FlightSQL module docs and links to `arrow-flight` crates [\#4012](https://github.com/apache/arrow-rs/pull/4012) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Update proc-macro2 requirement from =1.0.54 to =1.0.56 [\#4008](https://github.com/apache/arrow-rs/pull/4008) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Cleanup Primitive take [\#4006](https://github.com/apache/arrow-rs/pull/4006) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Deprecate combine\_option\_bitmap [\#4005](https://github.com/apache/arrow-rs/pull/4005) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Minor: add tests for BooleanBuffer [\#4004](https://github.com/apache/arrow-rs/pull/4004) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- feat: support to read/write customized metadata in ipc files [\#4003](https://github.com/apache/arrow-rs/pull/4003) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([framlog](https://github.com/framlog))
+- Cleanup more uses of Array::data \(\#3880\) [\#4002](https://github.com/apache/arrow-rs/pull/4002) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Remove js feature from README [\#4001](https://github.com/apache/arrow-rs/pull/4001) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([akazukin5151](https://github.com/akazukin5151))
+- feat: add the implementation BitXor to BooleanBuffer [\#3997](https://github.com/apache/arrow-rs/pull/3997) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Handle precision overflow when casting from integer to decimal [\#3996](https://github.com/apache/arrow-rs/pull/3996) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Support CAST from Decimal datatype to String [\#3994](https://github.com/apache/arrow-rs/pull/3994) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([comphead](https://github.com/comphead))
+- Add Field Constructors for Complex Fields [\#3992](https://github.com/apache/arrow-rs/pull/3992) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- fix: remove unused type parameters. [\#3986](https://github.com/apache/arrow-rs/pull/3986) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([youngsofun](https://github.com/youngsofun))
+- Add UnionFields \(\#3955\) [\#3981](https://github.com/apache/arrow-rs/pull/3981) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Cleanup Fields Serde [\#3980](https://github.com/apache/arrow-rs/pull/3980) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support Rust structures --\> `RecordBatch` by adding `Serde` support to `RawDecoder` \(\#3949\) [\#3979](https://github.com/apache/arrow-rs/pull/3979) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Convert string\_to\_timestamp\_nanos to doctest [\#3978](https://github.com/apache/arrow-rs/pull/3978) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix documentation of string\_to\_timestamp\_nanos [\#3977](https://github.com/apache/arrow-rs/pull/3977) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([byteink](https://github.com/byteink))
+- add Date32/Date64 support to subtract\_dyn [\#3974](https://github.com/apache/arrow-rs/pull/3974) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([SinanGncgl](https://github.com/SinanGncgl))
+- PrimitiveDictionaryBuilder.finish should use actual value type [\#3972](https://github.com/apache/arrow-rs/pull/3972) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Update proc-macro2 requirement from =1.0.53 to =1.0.54 [\#3968](https://github.com/apache/arrow-rs/pull/3968) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Async writer tweaks [\#3967](https://github.com/apache/arrow-rs/pull/3967) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Fix reading ipc files with unordered projections [\#3966](https://github.com/apache/arrow-rs/pull/3966) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([framlog](https://github.com/framlog))
+- Add Fields abstraction \(\#3955\) [\#3965](https://github.com/apache/arrow-rs/pull/3965) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- feat: cast between `Binary`/`LargeBinary` and `FixedSizeBinary` [\#3961](https://github.com/apache/arrow-rs/pull/3961) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- feat: support async writer \(\#1269\) [\#3957](https://github.com/apache/arrow-rs/pull/3957) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([ShiKaiWi](https://github.com/ShiKaiWi))
+- Add ListBuilder::append\_value \(\#3949\) [\#3954](https://github.com/apache/arrow-rs/pull/3954) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Improve array builder documentation \(\#3949\) [\#3951](https://github.com/apache/arrow-rs/pull/3951) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Faster i256 parsing [\#3950](https://github.com/apache/arrow-rs/pull/3950) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add multiply\_fixed\_point [\#3945](https://github.com/apache/arrow-rs/pull/3945) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- feat: enable metadata import/export through C data interface [\#3944](https://github.com/apache/arrow-rs/pull/3944) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Fix checked i256 arithmetic \(\#3942\) \(\#3941\) [\#3943](https://github.com/apache/arrow-rs/pull/3943) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Avoid memory copies in take\_list [\#3940](https://github.com/apache/arrow-rs/pull/3940) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Faster decimal parsing \(30-60%\) [\#3939](https://github.com/apache/arrow-rs/pull/3939) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([spebern](https://github.com/spebern))
+- Fix: FlightSqlClient panic when execute\_update. [\#3938](https://github.com/apache/arrow-rs/pull/3938) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([youngsofun](https://github.com/youngsofun))
+- Cleanup row count handling in JSON writer [\#3934](https://github.com/apache/arrow-rs/pull/3934) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add typed buffers to UnionArray \(\#3880\) [\#3933](https://github.com/apache/arrow-rs/pull/3933) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: add take for MapArray [\#3925](https://github.com/apache/arrow-rs/pull/3925) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Deprecate Array::data\_ref \(\#3880\) [\#3923](https://github.com/apache/arrow-rs/pull/3923) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Zero-copy conversion from Vec to PrimitiveArray [\#3917](https://github.com/apache/arrow-rs/pull/3917) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: Add Commands enum to decode prost messages to strong type [\#3887](https://github.com/apache/arrow-rs/pull/3887) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([stuartcarnie](https://github.com/stuartcarnie))
+## [36.0.0](https://github.com/apache/arrow-rs/tree/36.0.0) (2023-03-24)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/35.0.0...36.0.0)
+
+**Breaking changes:**
+
+- Use dyn Array in sort kernels [\#3931](https://github.com/apache/arrow-rs/pull/3931) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Enforce struct nullability in JSON raw reader \(\#3900\) \(\#3904\) [\#3906](https://github.com/apache/arrow-rs/pull/3906) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Return ScalarBuffer from PrimitiveArray::values \(\#3879\) [\#3896](https://github.com/apache/arrow-rs/pull/3896) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use BooleanBuffer in BooleanArray \(\#3879\) [\#3895](https://github.com/apache/arrow-rs/pull/3895) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Seal ArrowPrimitiveType [\#3882](https://github.com/apache/arrow-rs/pull/3882) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support compression levels [\#3847](https://github.com/apache/arrow-rs/pull/3847) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([spebern](https://github.com/spebern))
+
+**Implemented enhancements:**
+
+- Improve speed of parsing string to Times [\#3919](https://github.com/apache/arrow-rs/issues/3919) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- feat: add comparison/sort support for Float16 [\#3914](https://github.com/apache/arrow-rs/issues/3914)
+- Pinned version in arrow-flight's build-dependencies are causing conflicts [\#3876](https://github.com/apache/arrow-rs/issues/3876)
+- Add compression options \(levels\) [\#3844](https://github.com/apache/arrow-rs/issues/3844) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use Unsigned Integer for Fixed Size DataType [\#3815](https://github.com/apache/arrow-rs/issues/3815)
+- Common trait for RecordBatch and StructArray [\#3764](https://github.com/apache/arrow-rs/issues/3764) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Allow precision loss on multiplying decimal arrays [\#3689](https://github.com/apache/arrow-rs/issues/3689) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Raw JSON Reader Allows Non-Nullable Struct Children to Contain Nulls [\#3904](https://github.com/apache/arrow-rs/issues/3904)
+- Nullable field with nested not nullable map in json [\#3900](https://github.com/apache/arrow-rs/issues/3900)
+- parquet\_derive doesn't support Vec\<u8\> [\#3864](https://github.com/apache/arrow-rs/issues/3864) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- \[REGRESSION\] Parsing timestamps with lower case time separator [\#3863](https://github.com/apache/arrow-rs/issues/3863) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- \[REGRESSION\] Parsing timestamps with leap seconds [\#3861](https://github.com/apache/arrow-rs/issues/3861) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- \[REGRESSION\] Parsing timestamps with fractional seconds / microseconds / milliseconds / nanoseconds [\#3859](https://github.com/apache/arrow-rs/issues/3859) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- CSV Reader Doesn't set Timezone [\#3841](https://github.com/apache/arrow-rs/issues/3841)
+- PyArrowConvert Leaks Memory [\#3683](https://github.com/apache/arrow-rs/issues/3683) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Derive RunArray Clone [\#3932](https://github.com/apache/arrow-rs/pull/3932) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Move protoc generation to binary crate, unpin prost/tonic build \(\#3876\) [\#3927](https://github.com/apache/arrow-rs/pull/3927) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Fix JSON Temporal Encoding of Multiple Batches [\#3924](https://github.com/apache/arrow-rs/pull/3924) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([doki23](https://github.com/doki23))
+- Cleanup uses of Array::data\_ref \(\#3880\) [\#3918](https://github.com/apache/arrow-rs/pull/3918) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support microsecond and nanosecond in interval parsing [\#3916](https://github.com/apache/arrow-rs/pull/3916) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- feat: add comparison/sort support for Float16 [\#3915](https://github.com/apache/arrow-rs/pull/3915) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([izveigor](https://github.com/izveigor))
+- Add AsArray trait for more ergonomic downcasting [\#3912](https://github.com/apache/arrow-rs/pull/3912) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add OffsetBuffer::new [\#3910](https://github.com/apache/arrow-rs/pull/3910) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add PrimitiveArray::new \(\#3879\) [\#3909](https://github.com/apache/arrow-rs/pull/3909) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support timezones in CSV reader \(\#3841\) [\#3908](https://github.com/apache/arrow-rs/pull/3908) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Improve ScalarBuffer debug output [\#3907](https://github.com/apache/arrow-rs/pull/3907) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update proc-macro2 requirement from =1.0.52 to =1.0.53 [\#3905](https://github.com/apache/arrow-rs/pull/3905) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Re-export parquet compression level structs [\#3903](https://github.com/apache/arrow-rs/pull/3903) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Fix parsing timestamps of exactly 32 characters [\#3902](https://github.com/apache/arrow-rs/pull/3902) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add iterators to BooleanBuffer and NullBuffer [\#3901](https://github.com/apache/arrow-rs/pull/3901) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Array equality for &dyn Array \(\#3880\) [\#3899](https://github.com/apache/arrow-rs/pull/3899) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add BooleanArray::new \(\#3879\) [\#3898](https://github.com/apache/arrow-rs/pull/3898) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Revert structured ArrayData \(\#3877\) [\#3894](https://github.com/apache/arrow-rs/pull/3894) ([tustvold](https://github.com/tustvold))
+- Fix pyarrow memory leak \(\#3683\) [\#3893](https://github.com/apache/arrow-rs/pull/3893) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Minor: add examples for `ListBuilder` and `GenericListBuilder` [\#3891](https://github.com/apache/arrow-rs/pull/3891) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Update syn requirement from 1.0 to 2.0 [\#3890](https://github.com/apache/arrow-rs/pull/3890) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Use of `mul_checked` to avoid silent overflow in interval arithmetic [\#3886](https://github.com/apache/arrow-rs/pull/3886) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- Flesh out NullBuffer abstraction \(\#3880\) [\#3885](https://github.com/apache/arrow-rs/pull/3885) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Implement Bit Operations for i256 [\#3884](https://github.com/apache/arrow-rs/pull/3884) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Flatten arrow\_buffer [\#3883](https://github.com/apache/arrow-rs/pull/3883) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add Array::to\_data and Array::nulls \(\#3880\) [\#3881](https://github.com/apache/arrow-rs/pull/3881) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Added support for byte vectors and slices to parquet\_derive \(\#3864\) [\#3878](https://github.com/apache/arrow-rs/pull/3878) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([waymost](https://github.com/waymost))
+- chore: remove LevelDecoder [\#3872](https://github.com/apache/arrow-rs/pull/3872) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Weijun-H](https://github.com/Weijun-H))
+- Parse timestamps with leap seconds \(\#3861\) [\#3862](https://github.com/apache/arrow-rs/pull/3862) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Faster time parsing \(~93% faster\) [\#3860](https://github.com/apache/arrow-rs/pull/3860) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Parse timestamps with arbitrary seconds fraction [\#3858](https://github.com/apache/arrow-rs/pull/3858) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add BitIterator [\#3856](https://github.com/apache/arrow-rs/pull/3856) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Improve decimal parsing performance [\#3854](https://github.com/apache/arrow-rs/pull/3854) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([spebern](https://github.com/spebern))
+- Update proc-macro2 requirement from =1.0.51 to =1.0.52 [\#3853](https://github.com/apache/arrow-rs/pull/3853) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Update bitflags requirement from 1.2.1 to 2.0.0 [\#3852](https://github.com/apache/arrow-rs/pull/3852) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add offset pushdown to parquet [\#3848](https://github.com/apache/arrow-rs/pull/3848) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add timezone support to JSON reader [\#3845](https://github.com/apache/arrow-rs/pull/3845) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Allow precision loss on multiplying decimal arrays [\#3690](https://github.com/apache/arrow-rs/pull/3690) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+
+## [35.0.0](https://github.com/apache/arrow-rs/tree/35.0.0) (2023-03-10)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/34.0.0...35.0.0)
+
+**Breaking changes:**
+
+- Add RunEndBuffer \(\#1799\) [\#3817](https://github.com/apache/arrow-rs/pull/3817) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Restrict DictionaryArray to ArrowDictionaryKeyType [\#3813](https://github.com/apache/arrow-rs/pull/3813) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- refactor: assorted `FlightSqlServiceClient` improvements [\#3788](https://github.com/apache/arrow-rs/pull/3788) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([crepererum](https://github.com/crepererum))
+- minor: make Parquet CLI input args consistent [\#3786](https://github.com/apache/arrow-rs/pull/3786) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([XinyuZeng](https://github.com/XinyuZeng))
+- Return Buffers from ArrayData::buffers instead of slice \(\#1799\) [\#3783](https://github.com/apache/arrow-rs/pull/3783) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use NullBuffer in ArrayData \(\#3775\) [\#3778](https://github.com/apache/arrow-rs/pull/3778) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Support timestamp/time and date types in json decoder [\#3834](https://github.com/apache/arrow-rs/issues/3834) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support decoding decimals in new raw json decoder [\#3819](https://github.com/apache/arrow-rs/issues/3819) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Timezone Aware Timestamp Parsing [\#3794](https://github.com/apache/arrow-rs/issues/3794) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Preallocate buffers for FixedSizeBinary array creation [\#3792](https://github.com/apache/arrow-rs/issues/3792) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Make Parquet CLI args consistent [\#3785](https://github.com/apache/arrow-rs/issues/3785) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Creates PrimitiveDictionaryBuilder from provided keys and values builders [\#3776](https://github.com/apache/arrow-rs/issues/3776) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use NullBuffer in ArrayData  [\#3775](https://github.com/apache/arrow-rs/issues/3775) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support unary\_dict\_mut in arth  [\#3710](https://github.com/apache/arrow-rs/issues/3710) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support cast \<\> String to interval [\#3643](https://github.com/apache/arrow-rs/issues/3643) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support Zero-Copy Conversion from Vec to/from MutableBuffer [\#3516](https://github.com/apache/arrow-rs/issues/3516) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Timestamp Unit Casts are Unchecked [\#3833](https://github.com/apache/arrow-rs/issues/3833) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- regexp\_match skips first match when returning match [\#3803](https://github.com/apache/arrow-rs/issues/3803) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Cast to timestamp with time zone returns timestamp [\#3800](https://github.com/apache/arrow-rs/issues/3800) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Schema-level metadata is not encoded in Flight responses [\#3779](https://github.com/apache/arrow-rs/issues/3779) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Closed issues:**
+
+- FlightSQL CLI client: simple test [\#3814](https://github.com/apache/arrow-rs/issues/3814) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Merged pull requests:**
+
+- refactor: timestamp overflow check [\#3840](https://github.com/apache/arrow-rs/pull/3840) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- Prep for 35.0.0 [\#3836](https://github.com/apache/arrow-rs/pull/3836) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([iajoiner](https://github.com/iajoiner))
+- Support timestamp/time and date json decoding [\#3835](https://github.com/apache/arrow-rs/pull/3835) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([spebern](https://github.com/spebern))
+- Make dictionary preservation optional in row encoding [\#3831](https://github.com/apache/arrow-rs/pull/3831) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Move prettyprint to arrow-cast [\#3828](https://github.com/apache/arrow-rs/pull/3828) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Support decoding decimals in raw decoder [\#3820](https://github.com/apache/arrow-rs/pull/3820) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([spebern](https://github.com/spebern))
+- Add ArrayDataLayout, port validation \(\#1799\) [\#3818](https://github.com/apache/arrow-rs/pull/3818) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- test: add test for FlightSQL CLI client [\#3816](https://github.com/apache/arrow-rs/pull/3816) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([crepererum](https://github.com/crepererum))
+- Add regexp\_match docs [\#3812](https://github.com/apache/arrow-rs/pull/3812) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- fix: Ensure Flight schema includes parent metadata [\#3811](https://github.com/apache/arrow-rs/pull/3811) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([stuartcarnie](https://github.com/stuartcarnie))
+- fix: regexp\_match skips first match [\#3807](https://github.com/apache/arrow-rs/pull/3807) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- fix: change uft8 to timestamp with timezone [\#3806](https://github.com/apache/arrow-rs/pull/3806) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- Support reading decimal arrays from json [\#3805](https://github.com/apache/arrow-rs/pull/3805) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([spebern](https://github.com/spebern))
+- Add unary\_dict\_mut [\#3804](https://github.com/apache/arrow-rs/pull/3804) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Faster timestamp parsing \(~70-90% faster\) [\#3801](https://github.com/apache/arrow-rs/pull/3801) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add concat\_elements\_bytes [\#3798](https://github.com/apache/arrow-rs/pull/3798) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Timezone aware timestamp parsing \(\#3794\) [\#3795](https://github.com/apache/arrow-rs/pull/3795) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Preallocate buffers for FixedSizeBinary array creation [\#3793](https://github.com/apache/arrow-rs/pull/3793) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([maxburke](https://github.com/maxburke))
+- feat: simple flight sql CLI client [\#3789](https://github.com/apache/arrow-rs/pull/3789) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([crepererum](https://github.com/crepererum))
+- Creates PrimitiveDictionaryBuilder from provided keys and values builders [\#3777](https://github.com/apache/arrow-rs/pull/3777) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- ArrayData Enumeration for Remaining Layouts [\#3769](https://github.com/apache/arrow-rs/pull/3769) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update prost-build requirement from =0.11.7 to =0.11.8 [\#3767](https://github.com/apache/arrow-rs/pull/3767) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Implement concat\_elements\_dyn kernel [\#3763](https://github.com/apache/arrow-rs/pull/3763) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- Support for casting `Utf8` and `LargeUtf8` --\>  `Interval` [\#3762](https://github.com/apache/arrow-rs/pull/3762) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([doki23](https://github.com/doki23))
+- into\_inner\(\) for CSV Writer [\#3759](https://github.com/apache/arrow-rs/pull/3759) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Weijun-H](https://github.com/Weijun-H))
+- Zero-copy Vec conversion \(\#3516\) \(\#1176\) [\#3756](https://github.com/apache/arrow-rs/pull/3756) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- ArrayData Enumeration for Primitive, Binary and UTF8 [\#3749](https://github.com/apache/arrow-rs/pull/3749) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add `into_primitive_dict_builder` to `DictionaryArray` [\#3715](https://github.com/apache/arrow-rs/pull/3715) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+
+## [34.0.0](https://github.com/apache/arrow-rs/tree/34.0.0) (2023-02-24)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/33.0.0...34.0.0)
+
+**Breaking changes:**
+
+- Infer 2020-03-19 00:00:00 as timestamp not Date64 in CSV \(\#3744\) [\#3746](https://github.com/apache/arrow-rs/pull/3746) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Implement fallible streams for `FlightClient::do_put` [\#3464](https://github.com/apache/arrow-rs/pull/3464) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+
+**Implemented enhancements:**
+
+- Support casting string to timestamp with microsecond resolution [\#3751](https://github.com/apache/arrow-rs/issues/3751)
+- Add datatime/interval/duration into comparison kernels [\#3729](https://github.com/apache/arrow-rs/issues/3729) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- ! \(not\) operator overload for SortOptions [\#3726](https://github.com/apache/arrow-rs/issues/3726) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- parquet: convert Bytes to ByteArray directly [\#3719](https://github.com/apache/arrow-rs/issues/3719) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Implement simple RecordBatchReader [\#3704](https://github.com/apache/arrow-rs/issues/3704)
+- Is possible to implement GenericListArray::from\_iter ? [\#3702](https://github.com/apache/arrow-rs/issues/3702)
+- `take_run` improvements [\#3701](https://github.com/apache/arrow-rs/issues/3701) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support `as_mut_any`  in Array trait  [\#3655](https://github.com/apache/arrow-rs/issues/3655)
+- `Array` --\> `Display` formatter that supports more options and is configurable [\#3638](https://github.com/apache/arrow-rs/issues/3638) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- arrow-csv: support decimal256 [\#3474](https://github.com/apache/arrow-rs/issues/3474) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- CSV reader infers Date64 type for fields like "2020-03-19 00:00:00" that it can't parse to Date64 [\#3744](https://github.com/apache/arrow-rs/issues/3744) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Update to 34.0.0 and update changelog  [\#3757](https://github.com/apache/arrow-rs/pull/3757) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([iajoiner](https://github.com/iajoiner))
+- Update MIRI for split crates \(\#2594\) [\#3754](https://github.com/apache/arrow-rs/pull/3754) ([tustvold](https://github.com/tustvold))
+- Update prost-build requirement from =0.11.6 to =0.11.7 [\#3753](https://github.com/apache/arrow-rs/pull/3753) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Enable casting of string to timestamp with microsecond resolution [\#3752](https://github.com/apache/arrow-rs/pull/3752) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([gruuya](https://github.com/gruuya))
+- Use Typed Buffers in Arrays \(\#1811\) \(\#1176\) [\#3743](https://github.com/apache/arrow-rs/pull/3743) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Cleanup arithmetic kernel type constraints [\#3739](https://github.com/apache/arrow-rs/pull/3739) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Make dictionary kernels optional for comparison benchmark [\#3738](https://github.com/apache/arrow-rs/pull/3738) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support String Coercion in Raw JSON Reader [\#3736](https://github.com/apache/arrow-rs/pull/3736) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([rguerreiromsft](https://github.com/rguerreiromsft))
+- replace for loop by try\_for\_each [\#3734](https://github.com/apache/arrow-rs/pull/3734) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([suxiaogang223](https://github.com/suxiaogang223))
+- feat: implement generic record batch reader [\#3733](https://github.com/apache/arrow-rs/pull/3733) ([wjones127](https://github.com/wjones127))
+- \[minor\] fix doc test fail [\#3732](https://github.com/apache/arrow-rs/pull/3732) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Add datetime/interval/duration into dyn scalar comparison [\#3730](https://github.com/apache/arrow-rs/pull/3730) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Using Borrow\<Value\> on infer\_json\_schema\_from\_iterator [\#3728](https://github.com/apache/arrow-rs/pull/3728) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([rguerreiromsft](https://github.com/rguerreiromsft))
+- Not operator overload for SortOptions [\#3727](https://github.com/apache/arrow-rs/pull/3727) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([berkaysynnada](https://github.com/berkaysynnada))
+- fix: encoding batch with no columns [\#3724](https://github.com/apache/arrow-rs/pull/3724) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([wangrunji0408](https://github.com/wangrunji0408))
+- feat: impl `Ord`/`PartialOrd` for `SortOptions` [\#3723](https://github.com/apache/arrow-rs/pull/3723) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([crepererum](https://github.com/crepererum))
+- Add From\<Bytes\> for ByteArray [\#3720](https://github.com/apache/arrow-rs/pull/3720) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Deprecate old JSON reader \(\#3610\) [\#3718](https://github.com/apache/arrow-rs/pull/3718) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add pretty format with options [\#3717](https://github.com/apache/arrow-rs/pull/3717) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Remove unreachable decimal take [\#3716](https://github.com/apache/arrow-rs/pull/3716) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Feat: arrow csv decimal256 [\#3711](https://github.com/apache/arrow-rs/pull/3711) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([suxiaogang223](https://github.com/suxiaogang223))
+- perf: `take_run` improvements [\#3705](https://github.com/apache/arrow-rs/pull/3705) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Add raw MapArrayReader [\#3703](https://github.com/apache/arrow-rs/pull/3703) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: Sort kernel for `RunArray` [\#3695](https://github.com/apache/arrow-rs/pull/3695) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- perf: Remove sorting to yield sorted\_rank [\#3693](https://github.com/apache/arrow-rs/pull/3693) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- fix: Handle sliced array in run array iterator [\#3681](https://github.com/apache/arrow-rs/pull/3681) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+
+## [33.0.0](https://github.com/apache/arrow-rs/tree/33.0.0) (2023-02-10)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/32.0.0...33.0.0)
+
+**Breaking changes:**
+
+- Use ArrayFormatter in Cast Kernel [\#3668](https://github.com/apache/arrow-rs/pull/3668) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use dyn Array in cast kernels [\#3667](https://github.com/apache/arrow-rs/pull/3667) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Return references from FixedSizeListArray and MapArray [\#3652](https://github.com/apache/arrow-rs/pull/3652) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Lazy array display \(\#3638\) [\#3647](https://github.com/apache/arrow-rs/pull/3647) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use array\_value\_to\_string in arrow-csv [\#3514](https://github.com/apache/arrow-rs/pull/3514) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([JayjeetAtGithub](https://github.com/JayjeetAtGithub))
+
+**Implemented enhancements:**
+
+- Support UTF8 cast to Timestamp with timezone [\#3664](https://github.com/apache/arrow-rs/issues/3664)
+- Add modulus\_dyn and modulus\_scalar\_dyn [\#3648](https://github.com/apache/arrow-rs/issues/3648) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- A trait for append\_value and append\_null on ArrayBuilders [\#3644](https://github.com/apache/arrow-rs/issues/3644)
+- Improve error message "batches\[0\] schema is different with argument schema" [\#3628](https://github.com/apache/arrow-rs/issues/3628) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Specified version of helper function to cast binary to string [\#3623](https://github.com/apache/arrow-rs/issues/3623) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Casting generic binary to generic string [\#3606](https://github.com/apache/arrow-rs/issues/3606) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use `array_value_to_string` in `arrow-csv`  [\#3483](https://github.com/apache/arrow-rs/issues/3483) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- ArrowArray::try\_from\_raw Misleading Signature [\#3684](https://github.com/apache/arrow-rs/issues/3684) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- PyArrowConvert Leaks Memory [\#3683](https://github.com/apache/arrow-rs/issues/3683) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Arrow-csv reader cannot produce RecordBatch even if the bytes are necessary [\#3674](https://github.com/apache/arrow-rs/issues/3674)
+- FFI Fails to Account For Offsets [\#3671](https://github.com/apache/arrow-rs/issues/3671) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Regression in CSV reader error handling [\#3656](https://github.com/apache/arrow-rs/issues/3656) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- UnionArray Child and Value Fail to Account for non-contiguous Type IDs [\#3653](https://github.com/apache/arrow-rs/issues/3653) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Panic when accessing RecordBatch from pyarrow [\#3646](https://github.com/apache/arrow-rs/issues/3646) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Multiplication for decimals is incorrect [\#3645](https://github.com/apache/arrow-rs/issues/3645)
+- Inconsistent output between pretty print and CSV writer for Arrow [\#3513](https://github.com/apache/arrow-rs/issues/3513) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- Release 33.0.0 of arrow/arrow-flight/parquet/parquet-derive \(next release after 32.0.0\)  [\#3682](https://github.com/apache/arrow-rs/issues/3682)
+- Release `32.0.0` of `arrow`/`arrow-flight`/`parquet`/`parquet-derive` \(next release after `31.0.0`\) [\#3584](https://github.com/apache/arrow-rs/issues/3584) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Merged pull requests:**
+
+- Move FFI to sub-crates [\#3687](https://github.com/apache/arrow-rs/pull/3687) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update to 33.0.0 and update changelog [\#3686](https://github.com/apache/arrow-rs/pull/3686) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([iajoiner](https://github.com/iajoiner))
+- Cleanup FFI interface \(\#3684\) \(\#3683\) [\#3685](https://github.com/apache/arrow-rs/pull/3685) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- fix: take\_run benchmark parameter [\#3679](https://github.com/apache/arrow-rs/pull/3679) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Minor: Add some examples to Date\*Array and Time\*Array [\#3678](https://github.com/apache/arrow-rs/pull/3678) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Add CSV Decoder::capacity \(\#3674\) [\#3677](https://github.com/apache/arrow-rs/pull/3677) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add ArrayData::new\_null and DataType::primitive\_width [\#3676](https://github.com/apache/arrow-rs/pull/3676) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix FFI which fails to account for offsets [\#3675](https://github.com/apache/arrow-rs/pull/3675) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Support UTF8 cast to Timestamp with timezone [\#3673](https://github.com/apache/arrow-rs/pull/3673) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([comphead](https://github.com/comphead))
+- Fix Date64Array docs [\#3670](https://github.com/apache/arrow-rs/pull/3670) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update proc-macro2 requirement from =1.0.50 to =1.0.51 [\#3669](https://github.com/apache/arrow-rs/pull/3669) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add timezone accessor for Timestamp\*Array [\#3666](https://github.com/apache/arrow-rs/pull/3666) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Faster timezone cast [\#3665](https://github.com/apache/arrow-rs/pull/3665) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat + fix: IPC support for run encoded array. [\#3662](https://github.com/apache/arrow-rs/pull/3662) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Implement std::fmt::Write for StringBuilder \(\#3638\) [\#3659](https://github.com/apache/arrow-rs/pull/3659) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Include line and field number in CSV UTF-8 error \(\#3656\) [\#3657](https://github.com/apache/arrow-rs/pull/3657) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Handle non-contiguous type\_ids in UnionArray \(\#3653\) [\#3654](https://github.com/apache/arrow-rs/pull/3654) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add modulus\_dyn and modulus\_scalar\_dyn [\#3649](https://github.com/apache/arrow-rs/pull/3649) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Improve error message with detailed schema [\#3637](https://github.com/apache/arrow-rs/pull/3637) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Veeupup](https://github.com/Veeupup))
+- Add limit to ArrowReaderBuilder to push limit down to parquet reader [\#3633](https://github.com/apache/arrow-rs/pull/3633) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
+- chore: delete wrong comment and refactor set\_metadata in `Field` [\#3630](https://github.com/apache/arrow-rs/pull/3630) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([chunshao90](https://github.com/chunshao90))
+- Fix typo in comment [\#3627](https://github.com/apache/arrow-rs/pull/3627) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([kjschiroo](https://github.com/kjschiroo))
+- Minor: Update doc strings about Page Index / Column Index [\#3625](https://github.com/apache/arrow-rs/pull/3625) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([alamb](https://github.com/alamb))
+- Specified version of helper function to cast binary to string [\#3624](https://github.com/apache/arrow-rs/pull/3624) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- feat: take kernel for RunArray [\#3622](https://github.com/apache/arrow-rs/pull/3622) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Remove BitSliceIterator specialization from try\_for\_each\_valid\_idx [\#3621](https://github.com/apache/arrow-rs/pull/3621) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Reduce PrimitiveArray::try\_unary codegen [\#3619](https://github.com/apache/arrow-rs/pull/3619) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Reduce Dictionary Builder Codegen [\#3616](https://github.com/apache/arrow-rs/pull/3616) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Minor: Add test for dictionary encoding of batches [\#3608](https://github.com/apache/arrow-rs/pull/3608) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Casting generic binary to generic string [\#3607](https://github.com/apache/arrow-rs/pull/3607) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add ArrayAccessor, Iterator, Extend and benchmarks for RunArray [\#3603](https://github.com/apache/arrow-rs/pull/3603) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+
+## [32.0.0](https://github.com/apache/arrow-rs/tree/32.0.0) (2023-01-27)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/31.0.0...32.0.0)
+
+**Breaking changes:**
+
+- Allow `StringArray` construction with `Vec<Option<String>>` [\#3602](https://github.com/apache/arrow-rs/pull/3602) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([sinistersnare](https://github.com/sinistersnare))
+- Use native types in PageIndex \(\#3575\) [\#3578](https://github.com/apache/arrow-rs/pull/3578) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add external variant to ParquetError \(\#3285\) [\#3574](https://github.com/apache/arrow-rs/pull/3574) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Return reference from ListArray::values [\#3561](https://github.com/apache/arrow-rs/pull/3561) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: Add `RunEndEncodedArray` [\#3553](https://github.com/apache/arrow-rs/pull/3553) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+
+**Implemented enhancements:**
+
+- There should be a `From<Vec<Option<String>>>` impl for `GenericStringArray<OffsetSize>` [\#3599](https://github.com/apache/arrow-rs/issues/3599) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- FlightDataEncoder Optionally send Schema even when no record batches [\#3591](https://github.com/apache/arrow-rs/issues/3591) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Use Native Types in PageIndex [\#3575](https://github.com/apache/arrow-rs/issues/3575) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Packing array into dictionary of generic byte array [\#3571](https://github.com/apache/arrow-rs/issues/3571) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Implement `Error::Source` for ArrowError and FlightError [\#3566](https://github.com/apache/arrow-rs/issues/3566) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- \[FlightSQL\] Allow access to underlying FlightClient [\#3551](https://github.com/apache/arrow-rs/issues/3551) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Arrow CSV writer should not fail when cannot cast the value [\#3547](https://github.com/apache/arrow-rs/issues/3547) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Write Deprecated Min Max Statistics When ColumnOrder Signed [\#3526](https://github.com/apache/arrow-rs/issues/3526) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Improve Performance of JSON Reader [\#3441](https://github.com/apache/arrow-rs/issues/3441)
+- Support footer kv metadata for IPC file [\#3432](https://github.com/apache/arrow-rs/issues/3432)
+- Add `External` variant to ParquetError [\#3285](https://github.com/apache/arrow-rs/issues/3285) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Fixed bugs:**
+
+- Nullif of NULL Predicate is not NULL [\#3589](https://github.com/apache/arrow-rs/issues/3589)
+- BooleanBufferBuilder Fails to Clear Set Bits On Truncate [\#3587](https://github.com/apache/arrow-rs/issues/3587) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `nullif` incorrectly calculates `null_count`, sometimes panics with subtraction overflow error [\#3579](https://github.com/apache/arrow-rs/issues/3579) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Meet warning when use pyarrow [\#3543](https://github.com/apache/arrow-rs/issues/3543) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Incorrect row group total\_byte\_size written to parquet file [\#3530](https://github.com/apache/arrow-rs/issues/3530) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Overflow when casting timestamps prior to the epoch [\#3512](https://github.com/apache/arrow-rs/issues/3512) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- Panic on Key Overflow in Dictionary Builders [\#3562](https://github.com/apache/arrow-rs/issues/3562) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Bumping version gives compilation error \(arrow-array\) [\#3525](https://github.com/apache/arrow-rs/issues/3525)
+
+**Merged pull requests:**
+
+- Add Push-Based CSV Decoder [\#3604](https://github.com/apache/arrow-rs/pull/3604) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update to flatbuffers 23.1.21 [\#3597](https://github.com/apache/arrow-rs/pull/3597) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Faster BooleanBufferBuilder::append\_n for true values [\#3596](https://github.com/apache/arrow-rs/pull/3596) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support sending schemas for empty streams [\#3594](https://github.com/apache/arrow-rs/pull/3594) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Faster ListArray to StringArray conversion [\#3593](https://github.com/apache/arrow-rs/pull/3593) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add conversion from StringArray to BinaryArray [\#3592](https://github.com/apache/arrow-rs/pull/3592) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix nullif null count \(\#3579\) [\#3590](https://github.com/apache/arrow-rs/pull/3590) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Clear bits in BooleanBufferBuilder \(\#3587\) [\#3588](https://github.com/apache/arrow-rs/pull/3588) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Iterate all dictionary key types in cast test [\#3585](https://github.com/apache/arrow-rs/pull/3585) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Propagate EOF Error from AsyncRead [\#3576](https://github.com/apache/arrow-rs/pull/3576) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Sach1nAgarwal](https://github.com/Sach1nAgarwal))
+- Show row\_counts also for \(FixedLen\)ByteArray [\#3573](https://github.com/apache/arrow-rs/pull/3573) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([bmmeijers](https://github.com/bmmeijers))
+- Packing array into dictionary of generic byte array [\#3572](https://github.com/apache/arrow-rs/pull/3572) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Remove unwrap on datetime cast for CSV writer [\#3570](https://github.com/apache/arrow-rs/pull/3570) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([comphead](https://github.com/comphead))
+- Implement `std::error::Error::source` for `ArrowError` and `FlightError` [\#3567](https://github.com/apache/arrow-rs/pull/3567) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Improve GenericBytesBuilder offset overflow panic message \(\#139\) [\#3564](https://github.com/apache/arrow-rs/pull/3564) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Implement Extend for ArrayBuilder \(\#1841\) [\#3563](https://github.com/apache/arrow-rs/pull/3563) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update pyarrow method call with kwargs [\#3560](https://github.com/apache/arrow-rs/pull/3560) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Frankonly](https://github.com/Frankonly))
+- Update pyo3 requirement from 0.17 to 0.18 [\#3557](https://github.com/apache/arrow-rs/pull/3557) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Expose Inner FlightServiceClient on FlightSqlServiceClient \(\#3551\) [\#3556](https://github.com/apache/arrow-rs/pull/3556) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Fix final page row count in parquet-index binary [\#3554](https://github.com/apache/arrow-rs/pull/3554) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Parquet Avoid Reading 8 Byte Footer Twice from AsyncRead [\#3550](https://github.com/apache/arrow-rs/pull/3550) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Sach1nAgarwal](https://github.com/Sach1nAgarwal))
+- Improve concat kernel capacity estimation [\#3546](https://github.com/apache/arrow-rs/pull/3546) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update proc-macro2 requirement from =1.0.49 to =1.0.50 [\#3545](https://github.com/apache/arrow-rs/pull/3545) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Update pyarrow method call to avoid warning [\#3544](https://github.com/apache/arrow-rs/pull/3544) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Frankonly](https://github.com/Frankonly))
+- Enable casting between Utf8/LargeUtf8 and Binary/LargeBinary [\#3542](https://github.com/apache/arrow-rs/pull/3542) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Use GHA concurrency groups \(\#3495\) [\#3538](https://github.com/apache/arrow-rs/pull/3538) ([tustvold](https://github.com/tustvold))
+- set sum of uncompressed column size as row group size for parquet files [\#3531](https://github.com/apache/arrow-rs/pull/3531) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([sidred](https://github.com/sidred))
+- Minor: Add documentation about memory use for ArrayData [\#3529](https://github.com/apache/arrow-rs/pull/3529) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Upgrade to clap 4.1 + fix test [\#3528](https://github.com/apache/arrow-rs/pull/3528) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Write backwards compatible row group statistics \(\#3526\) [\#3527](https://github.com/apache/arrow-rs/pull/3527) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- No panic on timestamp buffer overflow [\#3519](https://github.com/apache/arrow-rs/pull/3519) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([comphead](https://github.com/comphead))
+- Support casting from binary to dictionary of binary [\#3482](https://github.com/apache/arrow-rs/pull/3482) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add Raw JSON Reader \(~2.5x faster\) [\#3479](https://github.com/apache/arrow-rs/pull/3479) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+## [31.0.0](https://github.com/apache/arrow-rs/tree/31.0.0) (2023-01-13)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/30.0.1...31.0.0)
+
+**Breaking changes:**
+
+- support RFC3339 style timestamps in `arrow-json`  [\#3449](https://github.com/apache/arrow-rs/pull/3449) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([JayjeetAtGithub](https://github.com/JayjeetAtGithub))
+- Improve arrow flight batch splitting and naming [\#3444](https://github.com/apache/arrow-rs/pull/3444) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Parquet record API: timestamp as signed integer [\#3437](https://github.com/apache/arrow-rs/pull/3437) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([ByteBaker](https://github.com/ByteBaker))
+- Support decimal int32/64 for writer [\#3431](https://github.com/apache/arrow-rs/pull/3431) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([liukun4515](https://github.com/liukun4515))
+
+**Implemented enhancements:**
+
+- Support casting  Date32 to timestamp [\#3504](https://github.com/apache/arrow-rs/issues/3504) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support casting strings like `'2001-01-01'` to timestamp [\#3492](https://github.com/apache/arrow-rs/issues/3492) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- CLI to "rewrite" parquet files [\#3476](https://github.com/apache/arrow-rs/issues/3476) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Add more dictionary value type support to `build_compare` [\#3465](https://github.com/apache/arrow-rs/issues/3465)
+- Allow `concat_batches` to take non owned RecordBatch [\#3456](https://github.com/apache/arrow-rs/issues/3456) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Release Arrow `30.0.1` \(maintenance release for `30.0.0`\) [\#3455](https://github.com/apache/arrow-rs/issues/3455)
+- Add string comparisons \(starts\_with, ends\_with, and contains\) to kernel [\#3442](https://github.com/apache/arrow-rs/issues/3442) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- make\_builder Loses Timezone and Decimal Scale Information [\#3435](https://github.com/apache/arrow-rs/issues/3435) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use RFC3339 style timestamps in arrow-json [\#3416](https://github.com/apache/arrow-rs/issues/3416) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- ArrayData`get_slice_memory_size`   or similar [\#3407](https://github.com/apache/arrow-rs/issues/3407) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Fixed bugs:**
+
+- Unable to read CSV with null boolean value [\#3521](https://github.com/apache/arrow-rs/issues/3521) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Make consistent behavior on zeros equality on floating point types [\#3509](https://github.com/apache/arrow-rs/issues/3509)
+- Sliced batch w/ bool column doesn't roundtrip through IPC [\#3496](https://github.com/apache/arrow-rs/issues/3496) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- take kernel on List array introduces nulls instead of empty lists [\#3471](https://github.com/apache/arrow-rs/issues/3471) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Infinite Loop If Skipping More CSV Lines than Present [\#3469](https://github.com/apache/arrow-rs/issues/3469) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Fix reading null booleans from CSV [\#3523](https://github.com/apache/arrow-rs/pull/3523) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- minor fix: use the unified decimal type builder [\#3522](https://github.com/apache/arrow-rs/pull/3522) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([liukun4515](https://github.com/liukun4515))
+- Update version to `31.0.0` and add changelog [\#3518](https://github.com/apache/arrow-rs/pull/3518) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([iajoiner](https://github.com/iajoiner))
+- Additional nullif re-export [\#3515](https://github.com/apache/arrow-rs/pull/3515) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Make consistent behavior on zeros equality on floating point types [\#3510](https://github.com/apache/arrow-rs/pull/3510) ([viirya](https://github.com/viirya))
+- Enable cast Date32 to Timestamp [\#3508](https://github.com/apache/arrow-rs/pull/3508) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([comphead](https://github.com/comphead))
+- Update prost-build requirement from =0.11.5 to =0.11.6 [\#3507](https://github.com/apache/arrow-rs/pull/3507) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- minor fix for the comments [\#3505](https://github.com/apache/arrow-rs/pull/3505) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Fix DataTypeLayout for LargeList [\#3503](https://github.com/apache/arrow-rs/pull/3503) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add string comparisons \(starts\_with, ends\_with, and contains\) to kernel [\#3502](https://github.com/apache/arrow-rs/pull/3502) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([snmvaughan](https://github.com/snmvaughan))
+- Add a function to get memory size of array slice [\#3501](https://github.com/apache/arrow-rs/pull/3501) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Fix IPCWriter for Sliced BooleanArray [\#3498](https://github.com/apache/arrow-rs/pull/3498) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([crepererum](https://github.com/crepererum))
+- Fix: Added support to cast string without time [\#3494](https://github.com/apache/arrow-rs/pull/3494) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([gaelwjl](https://github.com/gaelwjl))
+- Fix negative interval prettyprint [\#3491](https://github.com/apache/arrow-rs/pull/3491) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Fixes a broken link in the arrow lib.rs rustdoc [\#3487](https://github.com/apache/arrow-rs/pull/3487) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([AdamGS](https://github.com/AdamGS))
+- Refactoring build\_compare for decimal and using downcast\_primitive [\#3484](https://github.com/apache/arrow-rs/pull/3484) ([viirya](https://github.com/viirya))
+- Add tests for record batch size splitting logic in FlightClient [\#3481](https://github.com/apache/arrow-rs/pull/3481) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- change `concat_batches` parameter to non owned reference [\#3480](https://github.com/apache/arrow-rs/pull/3480) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- feat: add `parquet-rewrite` CLI [\#3477](https://github.com/apache/arrow-rs/pull/3477) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([crepererum](https://github.com/crepererum))
+- Preserve empty list array elements in take kernel [\#3473](https://github.com/apache/arrow-rs/pull/3473) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jonmmease](https://github.com/jonmmease))
+- Add a test for stream writer for writing sliced array [\#3472](https://github.com/apache/arrow-rs/pull/3472) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Fix CSV infinite loop and improve error messages [\#3470](https://github.com/apache/arrow-rs/pull/3470) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add more dictionary value type support to `build_compare` [\#3466](https://github.com/apache/arrow-rs/pull/3466) ([viirya](https://github.com/viirya))
+- Add tests for `FlightClient::{list_flights, list_actions, do_action, get_schema}` [\#3463](https://github.com/apache/arrow-rs/pull/3463) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Minor: add ticket links to failing ipc integration tests [\#3461](https://github.com/apache/arrow-rs/pull/3461) ([alamb](https://github.com/alamb))
+- feat: `column_name` based index access for `RecordBatch` and `StructArray` [\#3458](https://github.com/apache/arrow-rs/pull/3458) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Support Decimal256 in FFI [\#3453](https://github.com/apache/arrow-rs/pull/3453) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Remove multiversion dependency [\#3452](https://github.com/apache/arrow-rs/pull/3452) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Re-export nullif kernel [\#3451](https://github.com/apache/arrow-rs/pull/3451) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Meaningful error message for map builder with null keys [\#3450](https://github.com/apache/arrow-rs/pull/3450) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Parquet writer v2: clear buffer after page flush [\#3447](https://github.com/apache/arrow-rs/pull/3447) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([askoa](https://github.com/askoa))
+- Verify ArrayData::data\_type compatible in PrimitiveArray::from [\#3440](https://github.com/apache/arrow-rs/pull/3440) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Preserve DataType metadata in make\_builder [\#3438](https://github.com/apache/arrow-rs/pull/3438) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Consolidate arrow ipc tests and increase coverage [\#3427](https://github.com/apache/arrow-rs/pull/3427) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Generic bytes dictionary builder [\#3426](https://github.com/apache/arrow-rs/pull/3426) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Minor: Improve docs for arrow-ipc, remove clippy ignore [\#3421](https://github.com/apache/arrow-rs/pull/3421) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- refactor: convert `*like_dyn`, `*like_utf8_scalar_dyn` and  `*like_dict` functions to macros [\#3411](https://github.com/apache/arrow-rs/pull/3411) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Add parquet-index binary [\#3405](https://github.com/apache/arrow-rs/pull/3405) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Complete mid-level `FlightClient` [\#3402](https://github.com/apache/arrow-rs/pull/3402) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Implement `RecordBatch` \<--\> `FlightData` encode/decode + tests [\#3391](https://github.com/apache/arrow-rs/pull/3391) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Provide `into_builder` for bytearray [\#3326](https://github.com/apache/arrow-rs/pull/3326) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+
+## [30.0.1](https://github.com/apache/arrow-rs/tree/30.0.1) (2023-01-04)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/30.0.0...30.0.1)
+
+**Implemented enhancements:**
+
+- Generic bytes dictionary builder [\#3425](https://github.com/apache/arrow-rs/issues/3425) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Derive Clone for the builders in object-store. [\#3419](https://github.com/apache/arrow-rs/issues/3419)
+- Mid-level `ArrowFlight` Client [\#3371](https://github.com/apache/arrow-rs/issues/3371) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Improve performance of the CSV parser [\#3338](https://github.com/apache/arrow-rs/issues/3338) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- `nullif` kernel no longer exported [\#3454](https://github.com/apache/arrow-rs/issues/3454) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- PrimitiveArray from ArrayData Unsound For IntervalArray [\#3439](https://github.com/apache/arrow-rs/issues/3439) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- LZ4-compressed PQ files unreadable by Pandas and ClickHouse [\#3433](https://github.com/apache/arrow-rs/issues/3433) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Parquet Record API: Cannot convert date before Unix epoch to json [\#3430](https://github.com/apache/arrow-rs/issues/3430) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- parquet-fromcsv with writer version v2 does not stop [\#3408](https://github.com/apache/arrow-rs/issues/3408) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+## [30.0.0](https://github.com/apache/arrow-rs/tree/30.0.0) (2022-12-29)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/29.0.0...30.0.0)
+
+**Breaking changes:**
+
+- Infer Parquet JSON Logical and Converted Type as UTF-8 [\#3376](https://github.com/apache/arrow-rs/pull/3376) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Use custom Any instead of prost\_types [\#3360](https://github.com/apache/arrow-rs/pull/3360) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Use bytes in arrow-flight [\#3359](https://github.com/apache/arrow-rs/pull/3359) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Add derived implementations of Clone and Debug for `ParquetObjectReader` [\#3381](https://github.com/apache/arrow-rs/issues/3381) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Speed up TrackedWrite [\#3366](https://github.com/apache/arrow-rs/issues/3366) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Is it possible for ArrowWriter to write key\_value\_metadata after write all records [\#3356](https://github.com/apache/arrow-rs/issues/3356) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Add UnionArray test to arrow-pyarrow integration test [\#3346](https://github.com/apache/arrow-rs/issues/3346)
+- Document / Deprecate arrow\_flight::utils::flight\_data\_from\_arrow\_batch [\#3312](https://github.com/apache/arrow-rs/issues/3312) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- \[FlightSQL\] Support HTTPs [\#3309](https://github.com/apache/arrow-rs/issues/3309) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Support UnionArray in ffi [\#3304](https://github.com/apache/arrow-rs/issues/3304) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add support for Azure Data Lake Storage Gen2 \(aka: ADLS Gen2\) in Object Store library [\#3283](https://github.com/apache/arrow-rs/issues/3283)
+- Support casting from String to Decimal [\#3280](https://github.com/apache/arrow-rs/issues/3280) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Allow ArrowCSV writer to control the display of NULL values [\#3268](https://github.com/apache/arrow-rs/issues/3268) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- FlightSQL example is broken [\#3386](https://github.com/apache/arrow-rs/issues/3386) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- CSV Reader Bounds Incorrectly Handles Header [\#3364](https://github.com/apache/arrow-rs/issues/3364) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Incorrect output string from `try_to_type`  [\#3350](https://github.com/apache/arrow-rs/issues/3350)
+- Decimal arithmetic computation fails to run because decimal type equality [\#3344](https://github.com/apache/arrow-rs/issues/3344) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Pretty print not implemented for Map [\#3322](https://github.com/apache/arrow-rs/issues/3322) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- ILIKE Kernels Inconsistent Case Folding [\#3311](https://github.com/apache/arrow-rs/issues/3311) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Documentation updates:**
+
+- minor: Improve arrow-flight docs [\#3372](https://github.com/apache/arrow-rs/pull/3372) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+
+**Merged pull requests:**
+
+- Version 30.0.0 release notes and changelog [\#3406](https://github.com/apache/arrow-rs/pull/3406) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Ends ParquetRecordBatchStream when polling on StreamState::Error [\#3404](https://github.com/apache/arrow-rs/pull/3404) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([viirya](https://github.com/viirya))
+- fix clippy issues [\#3398](https://github.com/apache/arrow-rs/pull/3398) ([Jimexist](https://github.com/Jimexist))
+- Upgrade multiversion to 0.7.1 [\#3396](https://github.com/apache/arrow-rs/pull/3396) ([viirya](https://github.com/viirya))
+- Make FlightSQL Support HTTPs [\#3388](https://github.com/apache/arrow-rs/pull/3388) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([viirya](https://github.com/viirya))
+- Fix broken FlightSQL example [\#3387](https://github.com/apache/arrow-rs/pull/3387) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([viirya](https://github.com/viirya))
+- Update prost-build [\#3385](https://github.com/apache/arrow-rs/pull/3385) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Split out arrow-arith \(\#2594\) [\#3384](https://github.com/apache/arrow-rs/pull/3384) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add derive for Clone and Debug for `ParquetObjectReader` [\#3382](https://github.com/apache/arrow-rs/pull/3382) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([kszlim](https://github.com/kszlim))
+- Initial Mid-level `FlightClient` [\#3378](https://github.com/apache/arrow-rs/pull/3378) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- Document all features on docs.rs [\#3377](https://github.com/apache/arrow-rs/pull/3377) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Split out arrow-row \(\#2594\) [\#3375](https://github.com/apache/arrow-rs/pull/3375) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Remove unnecessary flush calls on TrackedWrite [\#3374](https://github.com/apache/arrow-rs/pull/3374) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([viirya](https://github.com/viirya))
+- Update proc-macro2 requirement from =1.0.47 to =1.0.49 [\#3369](https://github.com/apache/arrow-rs/pull/3369) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add CSV build\_buffered \(\#3338\) [\#3368](https://github.com/apache/arrow-rs/pull/3368) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: add append\_key\_value\_metadata [\#3367](https://github.com/apache/arrow-rs/pull/3367) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([jiacai2050](https://github.com/jiacai2050))
+- Add csv-core based reader \(\#3338\) [\#3365](https://github.com/apache/arrow-rs/pull/3365) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Put BufWriter into TrackedWrite [\#3361](https://github.com/apache/arrow-rs/pull/3361) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([viirya](https://github.com/viirya))
+- Add CSV reader benchmark \(\#3338\) [\#3357](https://github.com/apache/arrow-rs/pull/3357) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use ArrayData::ptr\_eq in DictionaryTracker [\#3354](https://github.com/apache/arrow-rs/pull/3354) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Deprecate flight\_data\_from\_arrow\_batch [\#3353](https://github.com/apache/arrow-rs/pull/3353) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([Dandandan](https://github.com/Dandandan))
+- Fix incorrect output string from try\_to\_type [\#3351](https://github.com/apache/arrow-rs/pull/3351) ([viirya](https://github.com/viirya))
+- Fix unary\_dyn for decimal scalar arithmetic computation [\#3345](https://github.com/apache/arrow-rs/pull/3345) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add UnionArray test to arrow-pyarrow integration test [\#3343](https://github.com/apache/arrow-rs/pull/3343) ([viirya](https://github.com/viirya))
+- feat: configure null value in arrow csv writer [\#3342](https://github.com/apache/arrow-rs/pull/3342) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Optimize bulk writing of all blocks of bloom filter [\#3340](https://github.com/apache/arrow-rs/pull/3340) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([viirya](https://github.com/viirya))
+- Add MapArray to pretty print [\#3339](https://github.com/apache/arrow-rs/pull/3339) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Update prost-build 0.11.4 [\#3334](https://github.com/apache/arrow-rs/pull/3334) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Faster Parquet Bloom Writer [\#3333](https://github.com/apache/arrow-rs/pull/3333) ([tustvold](https://github.com/tustvold))
+- Add bloom filter benchmark for parquet writer [\#3323](https://github.com/apache/arrow-rs/pull/3323) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([viirya](https://github.com/viirya))
+- Add ASCII fast path for ILIKE scalar \(90% faster\) [\#3306](https://github.com/apache/arrow-rs/pull/3306) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support UnionArray in ffi [\#3305](https://github.com/apache/arrow-rs/pull/3305) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Support casting from String to Decimal [\#3281](https://github.com/apache/arrow-rs/pull/3281) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- add more integration test for parquet bloom filter round trip tests [\#3210](https://github.com/apache/arrow-rs/pull/3210) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jimexist](https://github.com/Jimexist))
+## [29.0.0](https://github.com/apache/arrow-rs/tree/29.0.0) (2022-12-09)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/28.0.0...29.0.0)
+
+**Breaking changes:**
+
+- Minor: Allow `Field::new` and `Field::new_with_dict` to take existing `String` as well as `&str` [\#3288](https://github.com/apache/arrow-rs/pull/3288) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- update `&Option<T>` to `Option<&T>` [\#3249](https://github.com/apache/arrow-rs/pull/3249) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jimexist](https://github.com/Jimexist))
+- Hide `*_dict_scalar` kernels behind `*_dyn` kernels [\#3202](https://github.com/apache/arrow-rs/pull/3202) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+
+**Implemented enhancements:**
+
+- Support writing BloomFilter in arrow\_writer [\#3275](https://github.com/apache/arrow-rs/issues/3275) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support casting from unsigned numeric to Decimal256 [\#3272](https://github.com/apache/arrow-rs/issues/3272) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support casting from Decimal256 to float types [\#3266](https://github.com/apache/arrow-rs/issues/3266) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Make arithmetic kernels supports DictionaryArray of DecimalType [\#3254](https://github.com/apache/arrow-rs/issues/3254) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Casting from Decimal256 to unsigned numeric [\#3239](https://github.com/apache/arrow-rs/issues/3239) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- precision is not considered when cast value to decimal [\#3223](https://github.com/apache/arrow-rs/issues/3223) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use RegexSet in arrow\_csv::infer\_field\_schema [\#3211](https://github.com/apache/arrow-rs/issues/3211) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Implement FlightSQL Client [\#3206](https://github.com/apache/arrow-rs/issues/3206) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Add binary\_mut and try\_binary\_mut [\#3143](https://github.com/apache/arrow-rs/issues/3143) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add try\_unary\_mut [\#3133](https://github.com/apache/arrow-rs/issues/3133) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Skip null buffer when importing FFI ArrowArray struct if no null buffer in the spec [\#3290](https://github.com/apache/arrow-rs/issues/3290) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- using ahash `compile-time-rng` kills reproducible builds [\#3271](https://github.com/apache/arrow-rs/issues/3271) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Decimal128 to Decimal256 Overflows [\#3265](https://github.com/apache/arrow-rs/issues/3265) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `nullif` panics on empty array [\#3261](https://github.com/apache/arrow-rs/issues/3261) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Some more inconsistency between can\_cast\_types  and cast\_with\_options [\#3250](https://github.com/apache/arrow-rs/issues/3250) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Enable casting between Dictionary of DecimalArray and DecimalArray [\#3237](https://github.com/apache/arrow-rs/issues/3237) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- new\_null\_array Panics creating StructArray with non-nullable fields [\#3226](https://github.com/apache/arrow-rs/issues/3226) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- bool should cast from/to Float16Type as `can_cast_types` returns true [\#3221](https://github.com/apache/arrow-rs/issues/3221) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Utf8 and LargeUtf8 cannot cast from/to Float16 but can\_cast\_types returns true [\#3220](https://github.com/apache/arrow-rs/issues/3220) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Re-enable some tests in `arrow-cast` crate [\#3219](https://github.com/apache/arrow-rs/issues/3219) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Off-by-one buffer size error triggers Panic when constructing RecordBatch from IPC bytes \(should return an Error\) [\#3215](https://github.com/apache/arrow-rs/issues/3215) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- arrow to and from pyarrow conversion results in changes in schema [\#3136](https://github.com/apache/arrow-rs/issues/3136) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Documentation updates:**
+
+- better document when we need `LargeUtf8` instead of `Utf8` [\#3228](https://github.com/apache/arrow-rs/issues/3228) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Use BufWriter when writing bloom filters and limit tests \(\#3318\) [\#3319](https://github.com/apache/arrow-rs/pull/3319) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Use take for dictionary like comparisons [\#3313](https://github.com/apache/arrow-rs/pull/3313) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update versions to  29.0.0 and update CHANGELOG [\#3315](https://github.com/apache/arrow-rs/pull/3315) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([alamb](https://github.com/alamb))
+- refactor: Merge similar functions `ilike_scalar` and `nilike_scalar` [\#3303](https://github.com/apache/arrow-rs/pull/3303) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Split out arrow-ord \(\#2594\) [\#3299](https://github.com/apache/arrow-rs/pull/3299) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Split out arrow-string \(\#2594\) [\#3295](https://github.com/apache/arrow-rs/pull/3295) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Skip null buffer when importing FFI ArrowArray struct if no null buffer in the spec [\#3293](https://github.com/apache/arrow-rs/pull/3293) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Don't use dangling NonNull as sentinel [\#3289](https://github.com/apache/arrow-rs/pull/3289) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Set bloom filter on byte array [\#3284](https://github.com/apache/arrow-rs/pull/3284) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([viirya](https://github.com/viirya))
+- Fix ipc schema custom\_metadata serialization [\#3282](https://github.com/apache/arrow-rs/pull/3282) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Disable const-random ahash feature on non-WASM \(\#3271\) [\#3277](https://github.com/apache/arrow-rs/pull/3277) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- fix\(ffi\): handle null data buffers from empty arrays [\#3276](https://github.com/apache/arrow-rs/pull/3276) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Support casting from unsigned numeric to Decimal256 [\#3273](https://github.com/apache/arrow-rs/pull/3273) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add parquet-layout binary [\#3269](https://github.com/apache/arrow-rs/pull/3269) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Support casting from Decimal256 to float types [\#3267](https://github.com/apache/arrow-rs/pull/3267) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Simplify decimal cast logic [\#3264](https://github.com/apache/arrow-rs/pull/3264) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix panic on nullif empty array \(\#3261\) [\#3263](https://github.com/apache/arrow-rs/pull/3263) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add BooleanArray::from\_unary and BooleanArray::from\_binary [\#3258](https://github.com/apache/arrow-rs/pull/3258) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Minor: Remove parquet build script [\#3257](https://github.com/apache/arrow-rs/pull/3257) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Make arithmetic kernels supports DictionaryArray of DecimalType [\#3255](https://github.com/apache/arrow-rs/pull/3255) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Support List and LargeList in Row format \(\#3159\) [\#3251](https://github.com/apache/arrow-rs/pull/3251) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Don't recurse to children in ArrayData::try\_new [\#3248](https://github.com/apache/arrow-rs/pull/3248) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Validate dictionaries read over IPC [\#3247](https://github.com/apache/arrow-rs/pull/3247) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix MapBuilder example [\#3246](https://github.com/apache/arrow-rs/pull/3246) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Loosen nullability restrictions added in \#3205 \(\#3226\) [\#3244](https://github.com/apache/arrow-rs/pull/3244) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Better document implications of offsets \(\#3228\) [\#3243](https://github.com/apache/arrow-rs/pull/3243) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add new API to validate the precision for decimal array [\#3242](https://github.com/apache/arrow-rs/pull/3242) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Move nullif to arrow-select \(\#2594\) [\#3241](https://github.com/apache/arrow-rs/pull/3241) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Casting from Decimal256 to unsigned numeric [\#3240](https://github.com/apache/arrow-rs/pull/3240) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Enable casting between Dictionary of DecimalArray and DecimalArray [\#3238](https://github.com/apache/arrow-rs/pull/3238) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Remove unwraps from 'create\_primitive\_array' [\#3232](https://github.com/apache/arrow-rs/pull/3232) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([aarashy](https://github.com/aarashy))
+- Fix CI build by upgrading tonic-build to 0.8.4 [\#3231](https://github.com/apache/arrow-rs/pull/3231) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([viirya](https://github.com/viirya))
+- Remove negative scale check [\#3230](https://github.com/apache/arrow-rs/pull/3230) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Update prost-build requirement from =0.11.2 to =0.11.3 [\#3225](https://github.com/apache/arrow-rs/pull/3225) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Get the round result for decimal to a decimal with smaller scale  [\#3224](https://github.com/apache/arrow-rs/pull/3224) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Move tests which require chrono-tz feature from `arrow-cast` to `arrow` [\#3222](https://github.com/apache/arrow-rs/pull/3222) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- add test cases for extracting week with/without timezone [\#3218](https://github.com/apache/arrow-rs/pull/3218) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([waitingkuo](https://github.com/waitingkuo))
+- Use RegexSet for matching DataType [\#3217](https://github.com/apache/arrow-rs/pull/3217) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Update tonic-build to 0.8.3 [\#3214](https://github.com/apache/arrow-rs/pull/3214) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Support StructArray in Row Format \(\#3159\) [\#3212](https://github.com/apache/arrow-rs/pull/3212) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Infer timestamps from CSV files [\#3209](https://github.com/apache/arrow-rs/pull/3209) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- fix bug: cast decimal256 to other decimal with no-safe [\#3208](https://github.com/apache/arrow-rs/pull/3208) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- FlightSQL Client & integration test [\#3207](https://github.com/apache/arrow-rs/pull/3207) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([avantgardnerio](https://github.com/avantgardnerio))
+- Ensure StructArrays check nullability of fields [\#3205](https://github.com/apache/arrow-rs/pull/3205) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Remove special case ArrayData equality for decimals [\#3204](https://github.com/apache/arrow-rs/pull/3204) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add a cast test case for decimal negative scale [\#3203](https://github.com/apache/arrow-rs/pull/3203) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Move zip and shift kernels to arrow-select [\#3201](https://github.com/apache/arrow-rs/pull/3201) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Deprecate limit kernel [\#3200](https://github.com/apache/arrow-rs/pull/3200) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use SlicesIterator for ArrayData Equality [\#3198](https://github.com/apache/arrow-rs/pull/3198) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add \_dyn kernels of like, ilike, nlike, nilike kernels for dictionary support [\#3197](https://github.com/apache/arrow-rs/pull/3197) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Adding scalar nlike\_dyn, ilike\_dyn, nilike\_dyn kernels [\#3195](https://github.com/apache/arrow-rs/pull/3195) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Use self capture in DataType [\#3190](https://github.com/apache/arrow-rs/pull/3190) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- To pyarrow with schema [\#3188](https://github.com/apache/arrow-rs/pull/3188) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([doki23](https://github.com/doki23))
+- Support Duration in array\_value\_to\_string [\#3183](https://github.com/apache/arrow-rs/pull/3183) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Support `FixedSizeBinary` in Row format [\#3182](https://github.com/apache/arrow-rs/pull/3182) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add binary\_mut and try\_binary\_mut [\#3144](https://github.com/apache/arrow-rs/pull/3144) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add try\_unary\_mut [\#3134](https://github.com/apache/arrow-rs/pull/3134) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+## [28.0.0](https://github.com/apache/arrow-rs/tree/28.0.0) (2022-11-25)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/27.0.0...28.0.0)
+
+**Breaking changes:**
+
+- StructArray::columns return slice [\#3186](https://github.com/apache/arrow-rs/pull/3186) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Return slice from GenericByteArray::value\_data [\#3171](https://github.com/apache/arrow-rs/pull/3171) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support decimal negative scale [\#3152](https://github.com/apache/arrow-rs/pull/3152) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- refactor: convert `Field::metadata` to `HashMap` [\#3148](https://github.com/apache/arrow-rs/pull/3148) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([crepererum](https://github.com/crepererum))
+- Don't Skip Serializing Empty Metadata \(\#3082\) [\#3126](https://github.com/apache/arrow-rs/pull/3126) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Add Decimal128, Decimal256, Float16 to DataType::is\_numeric [\#3121](https://github.com/apache/arrow-rs/pull/3121) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Upgrade to thrift 0.17 and fix issues [\#3104](https://github.com/apache/arrow-rs/pull/3104) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jimexist](https://github.com/Jimexist))
+- Fix prettyprint for Interval second fractions [\#3093](https://github.com/apache/arrow-rs/pull/3093) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Remove Option from `Field::metadata` [\#3091](https://github.com/apache/arrow-rs/pull/3091) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+
+**Implemented enhancements:**
+
+- Add iterator to RowSelection [\#3172](https://github.com/apache/arrow-rs/issues/3172) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- create an integration test set for parquet crate against pyspark for working with bloom filters [\#3167](https://github.com/apache/arrow-rs/issues/3167) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Row Format Size Tracking [\#3160](https://github.com/apache/arrow-rs/issues/3160) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add ArrayBuilder::finish\_cloned\(\) [\#3154](https://github.com/apache/arrow-rs/issues/3154) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Optimize memory usage of json reader [\#3150](https://github.com/apache/arrow-rs/issues/3150)
+- Add `Field::size` and `DataType::size` [\#3147](https://github.com/apache/arrow-rs/issues/3147) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add like\_utf8\_scalar\_dyn kernel [\#3145](https://github.com/apache/arrow-rs/issues/3145) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- support comparison for decimal128 array with scalar in kernel [\#3140](https://github.com/apache/arrow-rs/issues/3140) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- audit and create a document for bloom filter configurations [\#3138](https://github.com/apache/arrow-rs/issues/3138) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Should be the rounding vs truncation when cast decimal to smaller scale  [\#3137](https://github.com/apache/arrow-rs/issues/3137) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Upgrade chrono to 0.4.23 [\#3120](https://github.com/apache/arrow-rs/issues/3120)
+- Implements more temporal kernels using time\_fraction\_dyn [\#3108](https://github.com/apache/arrow-rs/issues/3108) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Upgrade to thrift 0.17 [\#3105](https://github.com/apache/arrow-rs/issues/3105) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Be able to parse time formatted strings [\#3100](https://github.com/apache/arrow-rs/issues/3100) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Improve "Fail to merge schema" error messages [\#3095](https://github.com/apache/arrow-rs/issues/3095) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Expose `SortingColumn` when reading and writing parquet metadata [\#3090](https://github.com/apache/arrow-rs/issues/3090) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Change Field::metadata to HashMap [\#3086](https://github.com/apache/arrow-rs/issues/3086) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support bloom filter reading and writing for parquet [\#3023](https://github.com/apache/arrow-rs/issues/3023) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- API to take back ownership of an ArrayRef [\#2901](https://github.com/apache/arrow-rs/issues/2901) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Specialized Interleave Kernel [\#2864](https://github.com/apache/arrow-rs/issues/2864) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- arithmetic overflow leads to segfault in `concat_batches` [\#3123](https://github.com/apache/arrow-rs/issues/3123) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Clippy failing on master : error: use of deprecated associated function chrono::NaiveDate::from\_ymd: use from\_ymd\_opt\(\) instead [\#3097](https://github.com/apache/arrow-rs/issues/3097) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Pretty print for interval types has wrong formatting [\#3092](https://github.com/apache/arrow-rs/issues/3092) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Field is not serializable with binary formats [\#3082](https://github.com/apache/arrow-rs/issues/3082) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Decimal Casts are Unchecked [\#2986](https://github.com/apache/arrow-rs/issues/2986) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- Release Arrow `27.0.0` \(next release after `26.0.0`\) [\#3045](https://github.com/apache/arrow-rs/issues/3045) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Perf about ParquetRecordBatchStream vs ParquetRecordBatchReader [\#2916](https://github.com/apache/arrow-rs/issues/2916)
+
+**Merged pull requests:**
+
+- Improve regex related kernels by upto 85% [\#3192](https://github.com/apache/arrow-rs/pull/3192) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Derive clone for arrays [\#3184](https://github.com/apache/arrow-rs/pull/3184) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Row decode cleanups [\#3180](https://github.com/apache/arrow-rs/pull/3180) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update zstd requirement from 0.11.1 to 0.12.0 [\#3178](https://github.com/apache/arrow-rs/pull/3178) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Move decimal constants from `arrow-data` to `arrow-schema` crate [\#3177](https://github.com/apache/arrow-rs/pull/3177) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- bloom filter part V: add an integration with pytest against pyspark [\#3176](https://github.com/apache/arrow-rs/pull/3176) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jimexist](https://github.com/Jimexist))
+- Bloom filter config tweaks \(\#3023\) [\#3175](https://github.com/apache/arrow-rs/pull/3175) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add RowParser [\#3174](https://github.com/apache/arrow-rs/pull/3174) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add `RowSelection::iter()`, `Into<Vec<RowSelector>>` and example [\#3173](https://github.com/apache/arrow-rs/pull/3173) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([alamb](https://github.com/alamb))
+- Add read parquet examples [\#3170](https://github.com/apache/arrow-rs/pull/3170) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([xudong963](https://github.com/xudong963))
+- Faster BinaryArray to StringArray conversion \(~67%\) [\#3168](https://github.com/apache/arrow-rs/pull/3168) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Remove unnecessary downcasts in builders [\#3166](https://github.com/apache/arrow-rs/pull/3166) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- bloom filter part IV: adjust writer properties, bloom filter properties, and incorporate into column encoder [\#3165](https://github.com/apache/arrow-rs/pull/3165) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jimexist](https://github.com/Jimexist))
+- Fix parquet decimal precision [\#3164](https://github.com/apache/arrow-rs/pull/3164) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([psvri](https://github.com/psvri))
+- Add Row size methods \(\#3160\) [\#3163](https://github.com/apache/arrow-rs/pull/3163) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Prevent precision=0 for decimal type [\#3162](https://github.com/apache/arrow-rs/pull/3162) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Remove unnecessary Buffer::from\_slice\_ref reference [\#3161](https://github.com/apache/arrow-rs/pull/3161) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add finish\_cloned to ArrayBuilder [\#3158](https://github.com/apache/arrow-rs/pull/3158) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Check overflow in MutableArrayData extend offsets \(\#3123\) [\#3157](https://github.com/apache/arrow-rs/pull/3157) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Extend Decimal256 as Primitive [\#3156](https://github.com/apache/arrow-rs/pull/3156) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Doc improvements [\#3155](https://github.com/apache/arrow-rs/pull/3155) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Add collect.rs example [\#3153](https://github.com/apache/arrow-rs/pull/3153) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Implement Neg for i256 [\#3151](https://github.com/apache/arrow-rs/pull/3151) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- feat: `{Field,DataType}::size` [\#3149](https://github.com/apache/arrow-rs/pull/3149) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([crepererum](https://github.com/crepererum))
+- Add like\_utf8\_scalar\_dyn kernel [\#3146](https://github.com/apache/arrow-rs/pull/3146) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- comparison op: decimal128 array with scalar [\#3141](https://github.com/apache/arrow-rs/pull/3141) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Cast: should get the round result for decimal to a decimal with smaller scale [\#3139](https://github.com/apache/arrow-rs/pull/3139) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Fix Panic on Reading Corrupt Parquet Schema \(\#2855\) [\#3130](https://github.com/apache/arrow-rs/pull/3130) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([psvri](https://github.com/psvri))
+- Clippy parquet fixes [\#3124](https://github.com/apache/arrow-rs/pull/3124) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Add GenericByteBuilder \(\#2969\) [\#3122](https://github.com/apache/arrow-rs/pull/3122) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- parquet bloom filter part III: add sbbf writer, remove `bloom` default feature, add reader properties [\#3119](https://github.com/apache/arrow-rs/pull/3119) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jimexist](https://github.com/Jimexist))
+- Add downcast\_array \(\#2901\) [\#3117](https://github.com/apache/arrow-rs/pull/3117) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add COW conversion for Buffer and PrimitiveArray and unary\_mut [\#3115](https://github.com/apache/arrow-rs/pull/3115) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Include field name in merge error message [\#3113](https://github.com/apache/arrow-rs/pull/3113) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([andygrove](https://github.com/andygrove))
+- Add PrimitiveArray::unary\_opt [\#3110](https://github.com/apache/arrow-rs/pull/3110) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Implements more temporal kernels using time\_fraction\_dyn [\#3107](https://github.com/apache/arrow-rs/pull/3107) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- cast: support unsigned numeric type to decimal128 [\#3106](https://github.com/apache/arrow-rs/pull/3106) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Expose `SortingColumn` in parquet files [\#3103](https://github.com/apache/arrow-rs/pull/3103) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([askoa](https://github.com/askoa))
+- parquet bloom filter part II: read sbbf bitset from row group reader, update API, and add cli demo [\#3102](https://github.com/apache/arrow-rs/pull/3102) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jimexist](https://github.com/Jimexist))
+- Parse Time32/Time64 from formatted string [\#3101](https://github.com/apache/arrow-rs/pull/3101) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Cleanup temporal \_internal functions [\#3099](https://github.com/apache/arrow-rs/pull/3099) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Improve schema mismatch error message [\#3098](https://github.com/apache/arrow-rs/pull/3098) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- Fix clippy by avoiding deprecated functions in chrono [\#3096](https://github.com/apache/arrow-rs/pull/3096) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Minor: Add diagrams and documentation to row format [\#3094](https://github.com/apache/arrow-rs/pull/3094) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Minor: Use ArrowNativeTypeOp instead of total\_cmp directly [\#3087](https://github.com/apache/arrow-rs/pull/3087) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Check overflow while casting between decimal types [\#3076](https://github.com/apache/arrow-rs/pull/3076) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- add bloom filter implementation based on split block \(sbbf\) spec [\#3057](https://github.com/apache/arrow-rs/pull/3057) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jimexist](https://github.com/Jimexist))
+- Add FixedSizeBinaryArray::try\_from\_sparse\_iter\_with\_size [\#3054](https://github.com/apache/arrow-rs/pull/3054) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([maxburke](https://github.com/maxburke))
+## [27.0.0](https://github.com/apache/arrow-rs/tree/27.0.0) (2022-11-11)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/26.0.0...27.0.0)
+
+**Breaking changes:**
+
+- Recurse into Dictionary value type in DataType::is\_nested [\#3083](https://github.com/apache/arrow-rs/pull/3083) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- early type checks in `RowConverter` [\#3080](https://github.com/apache/arrow-rs/pull/3080) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([crepererum](https://github.com/crepererum))
+- Add Decimal128 and Decimal256 to downcast\_primitive [\#3056](https://github.com/apache/arrow-rs/pull/3056) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Replace remaining \_generic temporal kernels with \_dyn kernels [\#3046](https://github.com/apache/arrow-rs/pull/3046) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Replace year\_generic with year\_dyn [\#3041](https://github.com/apache/arrow-rs/pull/3041) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Validate decimal256 with i256 directly [\#3025](https://github.com/apache/arrow-rs/pull/3025) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Hadoop LZ4 Support for LZ4 Codec [\#3013](https://github.com/apache/arrow-rs/pull/3013) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([marioloko](https://github.com/marioloko))
+- Replace hour\_generic with hour\_dyn [\#3006](https://github.com/apache/arrow-rs/pull/3006) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Accept any &dyn Array in nullif kernel [\#2940](https://github.com/apache/arrow-rs/pull/2940) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Row Format: Option to detach/own a row [\#3078](https://github.com/apache/arrow-rs/issues/3078) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Row Format: API to check if datatypes are supported [\#3077](https://github.com/apache/arrow-rs/issues/3077) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Deprecate Buffer::count\_set\_bits [\#3067](https://github.com/apache/arrow-rs/issues/3067) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add Decimal128 and Decimal256 to downcast\_primitive [\#3055](https://github.com/apache/arrow-rs/issues/3055) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Improved UX of  creating `TimestampNanosecondArray` with timezones [\#3042](https://github.com/apache/arrow-rs/issues/3042) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Cast decimal256 to signed integer [\#3039](https://github.com/apache/arrow-rs/issues/3039) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support casting Date64 to Timestamp [\#3037](https://github.com/apache/arrow-rs/issues/3037) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Check overflow when casting floating point value to decimal256 [\#3032](https://github.com/apache/arrow-rs/issues/3032) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Compare i256 in validate\_decimal256\_precision [\#3024](https://github.com/apache/arrow-rs/issues/3024) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Check overflow when casting floating point value to decimal128 [\#3020](https://github.com/apache/arrow-rs/issues/3020) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add macro downcast\_temporal\_array [\#3008](https://github.com/apache/arrow-rs/issues/3008) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Replace hour\_generic with hour\_dyn [\#3005](https://github.com/apache/arrow-rs/issues/3005) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Replace temporal \_generic kernels with dyn [\#3004](https://github.com/apache/arrow-rs/issues/3004) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add `RowSelection::intersection` [\#3003](https://github.com/apache/arrow-rs/issues/3003) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- I would like to round rather than truncate when casting f64 to decimal [\#2997](https://github.com/apache/arrow-rs/issues/2997) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- arrow::compute::kernels::temporal should support nanoseconds [\#2995](https://github.com/apache/arrow-rs/issues/2995) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Release Arrow `26.0.0` \(next release after `25.0.0`\) [\#2953](https://github.com/apache/arrow-rs/issues/2953) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Add timezone offset for debug format of Timestamp with Timezone [\#2917](https://github.com/apache/arrow-rs/issues/2917) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support merge RowSelectors when creating RowSelection [\#2858](https://github.com/apache/arrow-rs/issues/2858) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Fixed bugs:**
+
+- Inconsistent Nan Handling Between Scalar and Non-Scalar Comparison Kernels [\#3074](https://github.com/apache/arrow-rs/issues/3074) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Debug format for timestamp ignores timezone [\#3069](https://github.com/apache/arrow-rs/issues/3069) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Row format decode loses timezone [\#3063](https://github.com/apache/arrow-rs/issues/3063) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- binary operator produces incorrect result on arrays with resized null buffer [\#3061](https://github.com/apache/arrow-rs/issues/3061) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- RLEDecoder Panics on Null Padded Pages [\#3035](https://github.com/apache/arrow-rs/issues/3035) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Nullif with incorrect valid\_count [\#3031](https://github.com/apache/arrow-rs/issues/3031) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- RLEDecoder::get\_batch\_with\_dict may panic on bit-packed runs longer than 1024 [\#3029](https://github.com/apache/arrow-rs/issues/3029) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Converted type is None according to Parquet Tools then utilizing logical types [\#3017](https://github.com/apache/arrow-rs/issues/3017)
+- CompressionCodec LZ4 incompatible with C++ implementation [\#2988](https://github.com/apache/arrow-rs/issues/2988) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Documentation updates:**
+
+- Mark parquet predicate pushdown as complete [\#2987](https://github.com/apache/arrow-rs/pull/2987) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+
+**Merged pull requests:**
+
+- Improved UX of  creating `TimestampNanosecondArray` with timezones [\#3088](https://github.com/apache/arrow-rs/pull/3088) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([src255](https://github.com/src255))
+- Remove unused range module [\#3085](https://github.com/apache/arrow-rs/pull/3085) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Make intersect\_row\_selections a member function [\#3084](https://github.com/apache/arrow-rs/pull/3084) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Update hashbrown requirement from 0.12 to 0.13 [\#3081](https://github.com/apache/arrow-rs/pull/3081) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- feat: add `OwnedRow` [\#3079](https://github.com/apache/arrow-rs/pull/3079) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([crepererum](https://github.com/crepererum))
+- Use ArrowNativeTypeOp on non-scalar comparison kernels [\#3075](https://github.com/apache/arrow-rs/pull/3075) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add missing inline to ArrowNativeTypeOp [\#3073](https://github.com/apache/arrow-rs/pull/3073) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- fix debug information for Timestamp with Timezone  [\#3072](https://github.com/apache/arrow-rs/pull/3072) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([waitingkuo](https://github.com/waitingkuo))
+- Deprecate Buffer::count\_set\_bits \(\#3067\) [\#3071](https://github.com/apache/arrow-rs/pull/3071) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add compare to ArrowNativeTypeOp [\#3070](https://github.com/apache/arrow-rs/pull/3070) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Minor: Improve docstrings on WriterPropertiesBuilder [\#3068](https://github.com/apache/arrow-rs/pull/3068) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([alamb](https://github.com/alamb))
+- Faster f64 inequality [\#3065](https://github.com/apache/arrow-rs/pull/3065) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix row format decode loses timezone \(\#3063\) [\#3064](https://github.com/apache/arrow-rs/pull/3064) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix null\_count computation in binary [\#3062](https://github.com/apache/arrow-rs/pull/3062) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Faster f64 equality [\#3060](https://github.com/apache/arrow-rs/pull/3060) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update arrow-flight subcrates \(\#3044\) [\#3052](https://github.com/apache/arrow-rs/pull/3052) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Minor: Remove cloning ArrayData in with\_precision\_and\_scale [\#3050](https://github.com/apache/arrow-rs/pull/3050) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Split out arrow-json \(\#3044\) [\#3049](https://github.com/apache/arrow-rs/pull/3049) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Move `intersect_row_selections` from datafusion to arrow-rs. [\#3047](https://github.com/apache/arrow-rs/pull/3047) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Split out arrow-csv \(\#2594\) [\#3044](https://github.com/apache/arrow-rs/pull/3044) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Move reader\_parser to arrow-cast \(\#3022\) [\#3043](https://github.com/apache/arrow-rs/pull/3043) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Cast decimal256 to signed integer [\#3040](https://github.com/apache/arrow-rs/pull/3040) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Enable casting from Date64 to Timestamp [\#3038](https://github.com/apache/arrow-rs/pull/3038) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([gruuya](https://github.com/gruuya))
+- Fix decoding long and/or padded RLE data \(\#3029\) \(\#3035\) [\#3036](https://github.com/apache/arrow-rs/pull/3036) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Fix nullif when existing array has no nulls [\#3034](https://github.com/apache/arrow-rs/pull/3034) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Check overflow when casting floating point value to decimal256 [\#3033](https://github.com/apache/arrow-rs/pull/3033) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Update parquet to depend on arrow subcrates [\#3028](https://github.com/apache/arrow-rs/pull/3028) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Make various i256 methods const [\#3026](https://github.com/apache/arrow-rs/pull/3026) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Split out arrow-ipc [\#3022](https://github.com/apache/arrow-rs/pull/3022) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Check overflow while casting floating point value to decimal128 [\#3021](https://github.com/apache/arrow-rs/pull/3021) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Update arrow-flight [\#3019](https://github.com/apache/arrow-rs/pull/3019) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Move ArrowNativeTypeOp to arrow-array \(\#2594\) [\#3018](https://github.com/apache/arrow-rs/pull/3018) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support cast timestamp to time [\#3016](https://github.com/apache/arrow-rs/pull/3016) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([naosense](https://github.com/naosense))
+- Add filter example [\#3014](https://github.com/apache/arrow-rs/pull/3014) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Check overflow when casting integer to decimal [\#3009](https://github.com/apache/arrow-rs/pull/3009) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add macro downcast\_temporal\_array [\#3007](https://github.com/apache/arrow-rs/pull/3007) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Parquet Writer: Make column descriptor public on the writer [\#3002](https://github.com/apache/arrow-rs/pull/3002) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([pier-oliviert](https://github.com/pier-oliviert))
+- Update chrono-tz requirement from 0.7 to 0.8 [\#3001](https://github.com/apache/arrow-rs/pull/3001) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Round instead of Truncate while casting float to decimal [\#3000](https://github.com/apache/arrow-rs/pull/3000) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([waitingkuo](https://github.com/waitingkuo))
+- Support Predicate Pushdown for Parquet Lists \(\#2108\) [\#2999](https://github.com/apache/arrow-rs/pull/2999) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Split out arrow-cast \(\#2594\) [\#2998](https://github.com/apache/arrow-rs/pull/2998) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- `arrow::compute::kernels::temporal` should support nanoseconds  [\#2996](https://github.com/apache/arrow-rs/pull/2996) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([comphead](https://github.com/comphead))
+- Add `RowSelection::from_selectors_and_combine` to  merge RowSelectors  [\#2994](https://github.com/apache/arrow-rs/pull/2994) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Simplify Single-Column Dictionary Sort [\#2993](https://github.com/apache/arrow-rs/pull/2993) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Minor: Add entry to changelog for 26.0.0 RC2 fix [\#2992](https://github.com/apache/arrow-rs/pull/2992) ([alamb](https://github.com/alamb))
+- Fix ignored limit on `lexsort_to_indices` [\#2991](https://github.com/apache/arrow-rs/pull/2991) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Add clone and equal functions for CastOptions [\#2985](https://github.com/apache/arrow-rs/pull/2985) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- minor: remove redundant prefix [\#2983](https://github.com/apache/arrow-rs/pull/2983) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([jackwener](https://github.com/jackwener))
+- Compare dictionary decimal arrays [\#2982](https://github.com/apache/arrow-rs/pull/2982) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Compare dictionary and non-dictionary decimal arrays [\#2980](https://github.com/apache/arrow-rs/pull/2980) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add decimal comparison kernel support [\#2978](https://github.com/apache/arrow-rs/pull/2978) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Move concat kernel to arrow-select \(\#2594\) [\#2976](https://github.com/apache/arrow-rs/pull/2976) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Specialize interleave for byte arrays \(\#2864\) [\#2975](https://github.com/apache/arrow-rs/pull/2975) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use unary function for numeric to decimal cast [\#2973](https://github.com/apache/arrow-rs/pull/2973) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Specialize filter kernel for binary arrays \(\#2969\) [\#2971](https://github.com/apache/arrow-rs/pull/2971) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Combine take\_utf8 and take\_binary \(\#2969\) [\#2970](https://github.com/apache/arrow-rs/pull/2970) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Faster Scalar Dictionary Comparison ~10% [\#2968](https://github.com/apache/arrow-rs/pull/2968) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Move `byte_size` from datafusion::physical\_expr [\#2965](https://github.com/apache/arrow-rs/pull/2965) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([avantgardnerio](https://github.com/avantgardnerio))
+- Pass decompressed size to parquet Codec::decompress \(\#2956\) [\#2959](https://github.com/apache/arrow-rs/pull/2959) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([marioloko](https://github.com/marioloko))
+- Add Decimal Arithmetic [\#2881](https://github.com/apache/arrow-rs/pull/2881) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+## [26.0.0](https://github.com/apache/arrow-rs/tree/26.0.0) (2022-10-28)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/25.0.0...26.0.0)
+
+**Breaking changes:**
+
+- Cast Timestamps to RFC3339 strings [\#2934](https://github.com/apache/arrow-rs/issues/2934)
+- Remove Unused NativeDecimalType [\#2945](https://github.com/apache/arrow-rs/pull/2945) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Format Timestamps as RFC3339 [\#2939](https://github.com/apache/arrow-rs/pull/2939) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([waitingkuo](https://github.com/waitingkuo))
+- Update flatbuffers to resolve RUSTSEC-2021-0122 [\#2895](https://github.com/apache/arrow-rs/pull/2895) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- replace `from_timestamp` by `from_timestamp_opt` [\#2894](https://github.com/apache/arrow-rs/pull/2894) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([waitingkuo](https://github.com/waitingkuo))
+
+**Implemented enhancements:**
+
+- Optimized way to count the numbers of `true` and `false` values in a BooleanArray [\#2963](https://github.com/apache/arrow-rs/issues/2963) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add pow to i256 [\#2954](https://github.com/apache/arrow-rs/issues/2954) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Write Generic Code over \[Large\]BinaryArray and \[Large\]StringArray [\#2946](https://github.com/apache/arrow-rs/issues/2946) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add Page Row Count Limit [\#2941](https://github.com/apache/arrow-rs/issues/2941) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- prettyprint to show timezone offset for timestamp with timezone [\#2937](https://github.com/apache/arrow-rs/issues/2937) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Cast numeric to decimal256 [\#2922](https://github.com/apache/arrow-rs/issues/2922) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add `freeze_with_dictionary` API to `MutableArrayData` [\#2914](https://github.com/apache/arrow-rs/issues/2914) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support decimal256 array in sort kernels [\#2911](https://github.com/apache/arrow-rs/issues/2911) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- support `[+/-]hhmm` and `[+/-]hh` as fixedoffset timezone format [\#2910](https://github.com/apache/arrow-rs/issues/2910) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Cleanup decimal sort function [\#2907](https://github.com/apache/arrow-rs/issues/2907) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- replace `from_timestamp` by `from_timestamp_opt` [\#2892](https://github.com/apache/arrow-rs/issues/2892) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Move Primitive arity kernels to arrow-array [\#2787](https://github.com/apache/arrow-rs/issues/2787) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- add overflow-checking for negative arithmetic kernel [\#2662](https://github.com/apache/arrow-rs/issues/2662) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Subtle compatibility issue with serve\_arrow [\#2952](https://github.com/apache/arrow-rs/issues/2952)
+- error\[E0599\]: no method named `total_cmp` found for struct `f16` in the current scope [\#2926](https://github.com/apache/arrow-rs/issues/2926) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Fail at rowSelection `and_then` method [\#2925](https://github.com/apache/arrow-rs/issues/2925) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Ordering not implemented for FixedSizeBinary types [\#2904](https://github.com/apache/arrow-rs/issues/2904) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Parquet API: Could not convert timestamp before unix epoch to string/json [\#2897](https://github.com/apache/arrow-rs/issues/2897) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Overly Pessimistic RLE Size Estimation [\#2889](https://github.com/apache/arrow-rs/issues/2889) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Memory alignment error in `RawPtrBox::new` [\#2882](https://github.com/apache/arrow-rs/issues/2882) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Compilation error under chrono-tz feature [\#2878](https://github.com/apache/arrow-rs/issues/2878) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- AHash Statically Allocates 64 bytes [\#2875](https://github.com/apache/arrow-rs/issues/2875) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- `parquet::arrow::arrow_writer::ArrowWriter` ignores page size properties [\#2853](https://github.com/apache/arrow-rs/issues/2853) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Documentation updates:**
+
+- Document crate topology \(\#2594\) [\#2913](https://github.com/apache/arrow-rs/pull/2913) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Closed issues:**
+
+- SerializedFileWriter comments about multiple call on consumed self [\#2935](https://github.com/apache/arrow-rs/issues/2935) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Pointer freed error when deallocating ArrayData with shared memory buffer [\#2874](https://github.com/apache/arrow-rs/issues/2874)
+- Release Arrow `25.0.0` \(next release after `24.0.0`\) [\#2820](https://github.com/apache/arrow-rs/issues/2820) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Replace DecimalArray with PrimitiveArray [\#2637](https://github.com/apache/arrow-rs/issues/2637) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Fix ignored limit on lexsort\_to\_indices (#2991) [\#2991](https://github.com/apache/arrow-rs/pull/2991) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Fix GenericListArray::try\_new\_from\_array\_data error message \(\#526\) [\#2961](https://github.com/apache/arrow-rs/pull/2961) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix take string on sliced indices [\#2960](https://github.com/apache/arrow-rs/pull/2960) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add BooleanArray::true\_count and BooleanArray::false\_count [\#2957](https://github.com/apache/arrow-rs/pull/2957) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add pow to i256 [\#2955](https://github.com/apache/arrow-rs/pull/2955) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- fix datatype for timestamptz debug fmt [\#2948](https://github.com/apache/arrow-rs/pull/2948) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([waitingkuo](https://github.com/waitingkuo))
+- Add GenericByteArray \(\#2946\) [\#2947](https://github.com/apache/arrow-rs/pull/2947) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Specialize interleave string ~2-3x faster [\#2944](https://github.com/apache/arrow-rs/pull/2944) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Added support for LZ4\_RAW compression. \(\#1604\) [\#2943](https://github.com/apache/arrow-rs/pull/2943) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([marioloko](https://github.com/marioloko))
+- Add optional page row count limit for parquet `WriterProperties` \(\#2941\) [\#2942](https://github.com/apache/arrow-rs/pull/2942) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Cleanup orphaned doc comments \(\#2935\) [\#2938](https://github.com/apache/arrow-rs/pull/2938) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- support more fixedoffset tz format [\#2936](https://github.com/apache/arrow-rs/pull/2936) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([waitingkuo](https://github.com/waitingkuo))
+- Benchmark with prepared row converter [\#2930](https://github.com/apache/arrow-rs/pull/2930) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add lexsort benchmark \(\#2871\) [\#2929](https://github.com/apache/arrow-rs/pull/2929) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Improve panic messages for RowSelection::and\_then \(\#2925\) [\#2928](https://github.com/apache/arrow-rs/pull/2928) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Update required half from 2.0 --\> 2.1 [\#2927](https://github.com/apache/arrow-rs/pull/2927) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Cast numeric to decimal256 [\#2923](https://github.com/apache/arrow-rs/pull/2923) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Cleanup generated proto code [\#2921](https://github.com/apache/arrow-rs/pull/2921) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([tustvold](https://github.com/tustvold))
+- Deprecate TimestampArray from\_vec and from\_opt\_vec [\#2919](https://github.com/apache/arrow-rs/pull/2919) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support decimal256 array in sort kernels [\#2912](https://github.com/apache/arrow-rs/pull/2912) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add timezone abstraction [\#2909](https://github.com/apache/arrow-rs/pull/2909) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Cleanup decimal sort function [\#2908](https://github.com/apache/arrow-rs/pull/2908) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Simplify TimestampArray from\_vec with timezone [\#2906](https://github.com/apache/arrow-rs/pull/2906) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Implement ord for FixedSizeBinary types [\#2905](https://github.com/apache/arrow-rs/pull/2905) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([maxburke](https://github.com/maxburke))
+- Update chrono-tz requirement from 0.6 to 0.7 [\#2903](https://github.com/apache/arrow-rs/pull/2903) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Parquet record api support timestamp before epoch [\#2899](https://github.com/apache/arrow-rs/pull/2899) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([AnthonyPoncet](https://github.com/AnthonyPoncet))
+- Specialize interleave integer [\#2898](https://github.com/apache/arrow-rs/pull/2898) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support overflow-checking variant of negate kernel [\#2893](https://github.com/apache/arrow-rs/pull/2893) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Respect Page Size Limits in ArrowWriter \(\#2853\) [\#2890](https://github.com/apache/arrow-rs/pull/2890) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Improve row format docs [\#2888](https://github.com/apache/arrow-rs/pull/2888) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add FixedSizeList::from\_iter\_primitive [\#2887](https://github.com/apache/arrow-rs/pull/2887) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Simplify ListArray::from\_iter\_primitive [\#2886](https://github.com/apache/arrow-rs/pull/2886) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Split out value selection kernels into arrow-select \(\#2594\) [\#2885](https://github.com/apache/arrow-rs/pull/2885) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Increase default IPC alignment to 64 \(\#2883\) [\#2884](https://github.com/apache/arrow-rs/pull/2884) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Copying inappropriately aligned buffer in ipc reader [\#2883](https://github.com/apache/arrow-rs/pull/2883) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Validate decimal IPC read \(\#2387\) [\#2880](https://github.com/apache/arrow-rs/pull/2880) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix compilation error under `chrono-tz` feature [\#2879](https://github.com/apache/arrow-rs/pull/2879) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Don't validate decimal precision in ArrayData \(\#2637\) [\#2873](https://github.com/apache/arrow-rs/pull/2873) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add downcast\_integer and downcast\_primitive [\#2872](https://github.com/apache/arrow-rs/pull/2872) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Filter DecimalArray as PrimitiveArray ~5x Faster \(\#2637\) [\#2870](https://github.com/apache/arrow-rs/pull/2870) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Treat DecimalArray as PrimitiveArray in row format [\#2866](https://github.com/apache/arrow-rs/pull/2866) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+## [25.0.0](https://github.com/apache/arrow-rs/tree/25.0.0) (2022-10-14)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/24.0.0...25.0.0)
+
+**Breaking changes:**
+
+- Make DecimalArray as PrimitiveArray [\#2857](https://github.com/apache/arrow-rs/pull/2857) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- fix timestamp parsing while no explicit timezone given [\#2814](https://github.com/apache/arrow-rs/pull/2814) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([waitingkuo](https://github.com/waitingkuo))
+- Support Arbitrary Number of Arrays in downcast\_primitive\_array [\#2809](https://github.com/apache/arrow-rs/pull/2809) ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Restore Integration test JSON schema serialization  [\#2876](https://github.com/apache/arrow-rs/issues/2876) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Fix various invalid\_html\_tags clippy error [\#2861](https://github.com/apache/arrow-rs/issues/2861) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Replace complicated temporal macro with generic functions [\#2851](https://github.com/apache/arrow-rs/issues/2851) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add NaN handling in dyn scalar comparison kernels [\#2829](https://github.com/apache/arrow-rs/issues/2829) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add overflow-checking variant of sum kernel [\#2821](https://github.com/apache/arrow-rs/issues/2821) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Update to Clap 4 [\#2817](https://github.com/apache/arrow-rs/issues/2817) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Safe API to Operate on Dictionary Values [\#2797](https://github.com/apache/arrow-rs/issues/2797) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add modulus op into `ArrowNativeTypeOp` [\#2753](https://github.com/apache/arrow-rs/issues/2753) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Allow creating of TimeUnit instances without direct dependency on parquet-format [\#2708](https://github.com/apache/arrow-rs/issues/2708) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Arrow Row Format [\#2677](https://github.com/apache/arrow-rs/issues/2677) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Don't try to infer nulls in CSV schema inference [\#2859](https://github.com/apache/arrow-rs/issues/2859) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `parquet::arrow::arrow_writer::ArrowWriter` ignores page size properties [\#2853](https://github.com/apache/arrow-rs/issues/2853) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Introducing ArrowNativeTypeOp made it impossible to call kernels from generics [\#2839](https://github.com/apache/arrow-rs/issues/2839) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Unsound ArrayData to Array Conversions [\#2834](https://github.com/apache/arrow-rs/issues/2834) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Regression: `the trait bound for<'de> arrow::datatypes::Schema: serde::de::Deserialize<'de> is not satisfied` [\#2825](https://github.com/apache/arrow-rs/issues/2825) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- convert string to timestamp shouldn't apply local timezone offset if there's no explicit timezone info in the string [\#2813](https://github.com/apache/arrow-rs/issues/2813) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- Add pub api for checking column index is sorted [\#2848](https://github.com/apache/arrow-rs/issues/2848) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Merged pull requests:**
+
+- Take decimal as primitive \(\#2637\) [\#2869](https://github.com/apache/arrow-rs/pull/2869) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Split out arrow-integration-test crate [\#2868](https://github.com/apache/arrow-rs/pull/2868) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Decimal cleanup \(\#2637\) [\#2865](https://github.com/apache/arrow-rs/pull/2865) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix various invalid\_html\_tags clippy errors [\#2862](https://github.com/apache/arrow-rs/pull/2862) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([viirya](https://github.com/viirya))
+- Don't try to infer nullability in CSV reader [\#2860](https://github.com/apache/arrow-rs/pull/2860) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
+- Fix page size on dictionary fallback [\#2854](https://github.com/apache/arrow-rs/pull/2854) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
+- Replace complicated temporal macro with generic functions [\#2850](https://github.com/apache/arrow-rs/pull/2850) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- \[feat\] Add pub api for checking column index is sorted. [\#2849](https://github.com/apache/arrow-rs/pull/2849) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- parquet: Add `snap` option to README [\#2847](https://github.com/apache/arrow-rs/pull/2847) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([exyi](https://github.com/exyi))
+- Cleanup cast kernel [\#2846](https://github.com/apache/arrow-rs/pull/2846) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Simplify ArrowNativeType [\#2841](https://github.com/apache/arrow-rs/pull/2841) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Expose ArrowNativeTypeOp trait to make it useful for type bound [\#2840](https://github.com/apache/arrow-rs/pull/2840) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add `interleave` kernel \(\#1523\) [\#2838](https://github.com/apache/arrow-rs/pull/2838) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Handle empty offsets buffer \(\#1824\) [\#2836](https://github.com/apache/arrow-rs/pull/2836) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Validate ArrayData type when converting to Array \(\#2834\) [\#2835](https://github.com/apache/arrow-rs/pull/2835) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Derive ArrowPrimitiveType for Decimal128Type and Decimal256Type \(\#2637\) [\#2833](https://github.com/apache/arrow-rs/pull/2833) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add NaN handling in dyn scalar comparison kernels [\#2830](https://github.com/apache/arrow-rs/pull/2830) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Simplify OrderPreservingInterner allocation strategy ~97% faster \(\#2677\) [\#2827](https://github.com/apache/arrow-rs/pull/2827) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Convert rows to arrays \(\#2677\) [\#2826](https://github.com/apache/arrow-rs/pull/2826) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add overflow-checking variant of sum kernel [\#2822](https://github.com/apache/arrow-rs/pull/2822) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Update Clap dependency to version 4 [\#2819](https://github.com/apache/arrow-rs/pull/2819) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([jgoday](https://github.com/jgoday))
+- Fix i256 checked multiplication [\#2818](https://github.com/apache/arrow-rs/pull/2818) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add string\_dictionary benches for row format \(\#2677\) [\#2816](https://github.com/apache/arrow-rs/pull/2816) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add OrderPreservingInterner::lookup \(\#2677\) [\#2815](https://github.com/apache/arrow-rs/pull/2815) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Simplify FixedLengthEncoding [\#2812](https://github.com/apache/arrow-rs/pull/2812) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Implement ArrowNumericType for Float16Type [\#2810](https://github.com/apache/arrow-rs/pull/2810) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add DictionaryArray::with\_values to make it easier to operate on dictionary values [\#2798](https://github.com/apache/arrow-rs/pull/2798) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add i256 \(\#2637\) [\#2781](https://github.com/apache/arrow-rs/pull/2781) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add modulus ops into `ArrowNativeTypeOp` [\#2756](https://github.com/apache/arrow-rs/pull/2756) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- feat: cast List / LargeList to Utf8 / LargeUtf8 [\#2588](https://github.com/apache/arrow-rs/pull/2588) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([gandronchik](https://github.com/gandronchik))
+
+## [24.0.0](https://github.com/apache/arrow-rs/tree/24.0.0) (2022-09-30)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/23.0.0...24.0.0)
+
+**Breaking changes:**
+
+- Cleanup `ArrowNativeType` \(\#1918\) [\#2793](https://github.com/apache/arrow-rs/pull/2793) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Remove `ArrowNativeType::FromStr` [\#2775](https://github.com/apache/arrow-rs/pull/2775) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Split out `arrow-array`  crate \(\#2594\) [\#2769](https://github.com/apache/arrow-rs/pull/2769) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add `dyn_arith_dict` feature flag [\#2760](https://github.com/apache/arrow-rs/pull/2760) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Split out `arrow-data` into a separate crate [\#2746](https://github.com/apache/arrow-rs/pull/2746) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Split out arrow-schema \(\#2594\) [\#2711](https://github.com/apache/arrow-rs/pull/2711) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Include field name in Parquet PrimitiveTypeBuilder error messages [\#2804](https://github.com/apache/arrow-rs/issues/2804) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Add PrimitiveArray::reinterpret\_cast [\#2785](https://github.com/apache/arrow-rs/issues/2785)
+- BinaryBuilder and StringBuilder initialization parameters in struct\_builder may be wrong [\#2783](https://github.com/apache/arrow-rs/issues/2783) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add divide scalar dyn kernel which produces null for division by zero [\#2767](https://github.com/apache/arrow-rs/issues/2767) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add divide dyn kernel which produces null for division by zero [\#2763](https://github.com/apache/arrow-rs/issues/2763) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Improve performance of checked kernels on non-null data [\#2747](https://github.com/apache/arrow-rs/issues/2747) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add overflow-checking variants of arithmetic dyn kernels [\#2739](https://github.com/apache/arrow-rs/issues/2739) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- The `binary` function should not panic on unequaled array length. [\#2721](https://github.com/apache/arrow-rs/issues/2721) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- min compute kernel is incorrect with sliced buffers in arrow 23 [\#2779](https://github.com/apache/arrow-rs/issues/2779) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `try_unary_dict` should check value type of dictionary array [\#2754](https://github.com/apache/arrow-rs/issues/2754) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- Add back JSON import/export for schema [\#2762](https://github.com/apache/arrow-rs/issues/2762)
+- null casting and coercion for Decimal128  [\#2761](https://github.com/apache/arrow-rs/issues/2761)
+- Json decoder behavior changed from versions 21 to 21 and returns non-sensical num\_rows for RecordBatch [\#2722](https://github.com/apache/arrow-rs/issues/2722) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Release Arrow `23.0.0` \(next release after `22.0.0`\) [\#2665](https://github.com/apache/arrow-rs/issues/2665) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Merged pull requests:**
+
+- add field name to parquet PrimitiveTypeBuilder error messages [\#2805](https://github.com/apache/arrow-rs/pull/2805) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([andygrove](https://github.com/andygrove))
+- Add struct equality test case \(\#514\) [\#2791](https://github.com/apache/arrow-rs/pull/2791) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Move unary kernels to arrow-array \(\#2787\) [\#2789](https://github.com/apache/arrow-rs/pull/2789) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Disable test harness for string\_dictionary\_builder benchmark [\#2788](https://github.com/apache/arrow-rs/pull/2788) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add PrimitiveArray::reinterpret\_cast \(\#2785\) [\#2786](https://github.com/apache/arrow-rs/pull/2786) ([tustvold](https://github.com/tustvold))
+- Fix BinaryBuilder and StringBuilder Capacity Allocation in StructBuilder [\#2784](https://github.com/apache/arrow-rs/pull/2784) ([chunshao90](https://github.com/chunshao90))
+- Fix min/max computation for sliced arrays \(\#2779\) [\#2780](https://github.com/apache/arrow-rs/pull/2780) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix Backwards Compatible Parquet List Encodings \(\#1915\) [\#2774](https://github.com/apache/arrow-rs/pull/2774) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- MINOR: Fix clippy for rust 1.64.0 [\#2772](https://github.com/apache/arrow-rs/pull/2772) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- MINOR: Fix clippy for rust 1.64.0 [\#2771](https://github.com/apache/arrow-rs/pull/2771) ([viirya](https://github.com/viirya))
+- Add divide scalar dyn kernel which produces null for division by zero [\#2768](https://github.com/apache/arrow-rs/pull/2768) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add divide dyn kernel which produces null for division by zero [\#2764](https://github.com/apache/arrow-rs/pull/2764) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add value type check in try\_unary\_dict [\#2755](https://github.com/apache/arrow-rs/pull/2755) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Fix `verify_release_candidate.sh` for new arrow subcrates [\#2752](https://github.com/apache/arrow-rs/pull/2752) ([alamb](https://github.com/alamb))
+- Fix: Issue 2721 : binary function should not panic but return error w… [\#2750](https://github.com/apache/arrow-rs/pull/2750) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([aksharau](https://github.com/aksharau))
+- Speed up checked kernels for non-null data \(~1.4-5x faster\) [\#2749](https://github.com/apache/arrow-rs/pull/2749) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
+- Add overflow-checking variants of arithmetic dyn kernels [\#2740](https://github.com/apache/arrow-rs/pull/2740) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Trim parquet row selection [\#2705](https://github.com/apache/arrow-rs/pull/2705) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+
+## [23.0.0](https://github.com/apache/arrow-rs/tree/24.0.0) (2022-09-16)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/22.0.0...23.0.0)
+
+**Breaking changes:**
+
+- Move JSON Test Format To integration-testing [\#2724](https://github.com/apache/arrow-rs/pull/2724) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Split out arrow-buffer crate \(\#2594\) [\#2693](https://github.com/apache/arrow-rs/pull/2693) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Simplify DictionaryBuilder constructors \(\#2684\) \(\#2054\) [\#2685](https://github.com/apache/arrow-rs/pull/2685) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Deprecate RecordBatch::concat replace with concat\_batches \(\#2594\) [\#2683](https://github.com/apache/arrow-rs/pull/2683) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add overflow-checking variant for primitive arithmetic kernels and explicitly define overflow behavior [\#2643](https://github.com/apache/arrow-rs/pull/2643) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Update thrift v0.16 and vendor parquet-format \(\#2502\) [\#2626](https://github.com/apache/arrow-rs/pull/2626) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Update flight definitions including backwards-incompatible change to GetSchema [\#2586](https://github.com/apache/arrow-rs/pull/2586) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([liukun4515](https://github.com/liukun4515))
+
+**Implemented enhancements:**
+
+- Cleanup like and nlike utf8 kernels [\#2744](https://github.com/apache/arrow-rs/issues/2744) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Speedup eq and neq kernels for utf8 arrays [\#2742](https://github.com/apache/arrow-rs/issues/2742) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- API for more ergonomic construction of `RecordBatchOptions` [\#2728](https://github.com/apache/arrow-rs/issues/2728) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Automate updates to `CHANGELOG-old.md` [\#2726](https://github.com/apache/arrow-rs/issues/2726)
+- Don't check the `DivideByZero` error for float modulus [\#2720](https://github.com/apache/arrow-rs/issues/2720) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `try_binary` should not panic on unequaled array length. [\#2715](https://github.com/apache/arrow-rs/issues/2715) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add benchmark for bitwise operation [\#2714](https://github.com/apache/arrow-rs/issues/2714) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add overflow-checking variants of arithmetic scalar dyn kernels [\#2712](https://github.com/apache/arrow-rs/issues/2712) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add divide\_opt kernel which produce null values on division by zero error [\#2709](https://github.com/apache/arrow-rs/issues/2709) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add `DataType` function to detect nested types [\#2704](https://github.com/apache/arrow-rs/issues/2704) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add support of sorting dictionary of other primitive types [\#2700](https://github.com/apache/arrow-rs/issues/2700) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Sort indices of dictionary string values [\#2697](https://github.com/apache/arrow-rs/issues/2697) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support empty projection in `RecordBatch::project` [\#2690](https://github.com/apache/arrow-rs/issues/2690) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support sorting dictionary encoded primitive integer arrays [\#2679](https://github.com/apache/arrow-rs/issues/2679) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use BitIndexIterator in min\_max\_helper [\#2674](https://github.com/apache/arrow-rs/issues/2674) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support building comparator for dictionaries of primitive integer values [\#2672](https://github.com/apache/arrow-rs/issues/2672) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Change max/min string macro to generic helper function `min_max_helper` [\#2657](https://github.com/apache/arrow-rs/issues/2657) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add overflow-checking variant of arithmetic scalar kernels [\#2651](https://github.com/apache/arrow-rs/issues/2651) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Compare dictionary with binary array [\#2644](https://github.com/apache/arrow-rs/issues/2644) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add overflow-checking variant for primitive arithmetic kernels [\#2642](https://github.com/apache/arrow-rs/issues/2642) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use `downcast_primitive_array` in arithmetic kernels [\#2639](https://github.com/apache/arrow-rs/issues/2639) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support DictionaryArray in temporal kernels [\#2622](https://github.com/apache/arrow-rs/issues/2622) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Inline Generated Thift Code Into Parquet Crate [\#2502](https://github.com/apache/arrow-rs/issues/2502) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Fixed bugs:**
+
+- Escape contains patterns for utf8 like kernels [\#2745](https://github.com/apache/arrow-rs/issues/2745) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Float Array should not panic on `DivideByZero` in the `Divide` kernel [\#2719](https://github.com/apache/arrow-rs/issues/2719) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- DictionaryBuilders can Create Invalid DictionaryArrays [\#2684](https://github.com/apache/arrow-rs/issues/2684) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `arrow` crate does not build with `features = ["ffi"]` and `default_features = false`. [\#2670](https://github.com/apache/arrow-rs/issues/2670) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Invalid results with `RowSelector` having `row_count` of 0 [\#2669](https://github.com/apache/arrow-rs/issues/2669) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- clippy error: unresolved import `crate::array::layout` [\#2659](https://github.com/apache/arrow-rs/issues/2659) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Cast the numeric without the `CastOptions` [\#2648](https://github.com/apache/arrow-rs/issues/2648) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Explicitly define overflow behavior for primitive arithmetic kernels [\#2641](https://github.com/apache/arrow-rs/issues/2641) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- update the `flight.proto` and fix schema to SchemaResult [\#2571](https://github.com/apache/arrow-rs/issues/2571) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Panic when first data page is skipped using ColumnChunkData::Sparse [\#2543](https://github.com/apache/arrow-rs/issues/2543) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- `SchemaResult` in IPC deviates from other implementations [\#2445](https://github.com/apache/arrow-rs/issues/2445) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+
+**Closed issues:**
+
+- Implement collect for int values [\#2696](https://github.com/apache/arrow-rs/issues/2696) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Speedup string equal/not equal to empty string, cleanup like/ilike kernels, fix escape bug [\#2743](https://github.com/apache/arrow-rs/pull/2743) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
+- Partially flatten arrow-buffer [\#2737](https://github.com/apache/arrow-rs/pull/2737) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Automate updates to `CHANGELOG-old.md` [\#2732](https://github.com/apache/arrow-rs/pull/2732) ([iajoiner](https://github.com/iajoiner))
+- Update read parquet example in parquet/arrow home [\#2730](https://github.com/apache/arrow-rs/pull/2730) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([datapythonista](https://github.com/datapythonista))
+- Better construction of RecordBatchOptions [\#2729](https://github.com/apache/arrow-rs/pull/2729) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([askoa](https://github.com/askoa))
+- benchmark: bitwise operation [\#2718](https://github.com/apache/arrow-rs/pull/2718) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Update `try_binary` and `checked_ops`, and remove `math_checked_op` [\#2717](https://github.com/apache/arrow-rs/pull/2717) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Support bitwise op in kernel: or,xor,not [\#2716](https://github.com/apache/arrow-rs/pull/2716) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Add overflow-checking variants of arithmetic scalar dyn kernels [\#2713](https://github.com/apache/arrow-rs/pull/2713) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add divide\_opt kernel which produce null values on division by zero error [\#2710](https://github.com/apache/arrow-rs/pull/2710) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add DataType::is\_nested\(\) [\#2707](https://github.com/apache/arrow-rs/pull/2707) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kfastov](https://github.com/kfastov))
+- Update criterion requirement from 0.3 to 0.4 [\#2706](https://github.com/apache/arrow-rs/pull/2706) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Support bitwise and operation in the kernel [\#2703](https://github.com/apache/arrow-rs/pull/2703) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Add support of sorting dictionary of other primitive arrays [\#2701](https://github.com/apache/arrow-rs/pull/2701) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Clarify docs of binary and string builders [\#2699](https://github.com/apache/arrow-rs/pull/2699) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([datapythonista](https://github.com/datapythonista))
+- Sort indices of dictionary string values [\#2698](https://github.com/apache/arrow-rs/pull/2698) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add support for empty projection in RecordBatch::project [\#2691](https://github.com/apache/arrow-rs/pull/2691) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
+- Temporarily disable Golang integration tests re-enable JS [\#2689](https://github.com/apache/arrow-rs/pull/2689) ([tustvold](https://github.com/tustvold))
+- Verify valid UTF-8 when converting byte array \(\#2205\) [\#2686](https://github.com/apache/arrow-rs/pull/2686) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support sorting dictionary encoded primitive integer arrays [\#2680](https://github.com/apache/arrow-rs/pull/2680) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Skip RowSelectors with zero rows [\#2678](https://github.com/apache/arrow-rs/pull/2678) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([askoa](https://github.com/askoa))
+- Faster Null Path Selection in ArrayData Equality [\#2676](https://github.com/apache/arrow-rs/pull/2676) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([dhruv9vats](https://github.com/dhruv9vats))
+- Use BitIndexIterator in min\_max\_helper [\#2675](https://github.com/apache/arrow-rs/pull/2675) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Support building comparator for dictionaries of primitive integer values [\#2673](https://github.com/apache/arrow-rs/pull/2673) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- json feature always requires base64 feature [\#2668](https://github.com/apache/arrow-rs/pull/2668) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([eagletmt](https://github.com/eagletmt))
+- Add try\_unary, binary, try\_binary kernels ~90% faster [\#2666](https://github.com/apache/arrow-rs/pull/2666) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use downcast\_dictionary\_array in unary\_dyn [\#2663](https://github.com/apache/arrow-rs/pull/2663) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- optimize the `numeric_cast_with_error` [\#2661](https://github.com/apache/arrow-rs/pull/2661) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- ffi feature also requires layout [\#2660](https://github.com/apache/arrow-rs/pull/2660) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Change max/min string macro to generic helper function min\_max\_helper [\#2658](https://github.com/apache/arrow-rs/pull/2658) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Fix flaky test `test_fuzz_async_reader_selection` [\#2656](https://github.com/apache/arrow-rs/pull/2656) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
+- MINOR: Ignore flaky test test\_fuzz\_async\_reader\_selection [\#2655](https://github.com/apache/arrow-rs/pull/2655) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([viirya](https://github.com/viirya))
+- MutableBuffer::typed\_data - shared ref access to the typed slice [\#2652](https://github.com/apache/arrow-rs/pull/2652) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([medwards](https://github.com/medwards))
+- Overflow-checking variant of arithmetic scalar kernels [\#2650](https://github.com/apache/arrow-rs/pull/2650) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- support `CastOption` for casting numeric [\#2649](https://github.com/apache/arrow-rs/pull/2649) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Help LLVM vectorize comparison kernel ~50-80% faster [\#2646](https://github.com/apache/arrow-rs/pull/2646) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support comparison between dictionary array and binary array [\#2645](https://github.com/apache/arrow-rs/pull/2645) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Use `downcast_primitive_array` in arithmetic kernels [\#2640](https://github.com/apache/arrow-rs/pull/2640) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Fully qualifying parquet items [\#2638](https://github.com/apache/arrow-rs/pull/2638) ([dingxiangfei2009](https://github.com/dingxiangfei2009))
+- Support DictionaryArray in temporal kernels [\#2623](https://github.com/apache/arrow-rs/pull/2623) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Comparable Row Format [\#2593](https://github.com/apache/arrow-rs/pull/2593) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix bug in page skipping [\#2552](https://github.com/apache/arrow-rs/pull/2552) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
+
+## [22.0.0](https://github.com/apache/arrow-rs/tree/22.0.0) (2022-09-02)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/21.0.0...22.0.0)
+
+**Breaking changes:**
+
+- Use `total_cmp` for floating value ordering and remove `nan_ordering` feature flag [\#2614](https://github.com/apache/arrow-rs/pull/2614) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Gate dyn comparison of dictionary arrays behind `dyn_cmp_dict` [\#2597](https://github.com/apache/arrow-rs/pull/2597) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Move JsonSerializable to json module \(\#2300\) [\#2595](https://github.com/apache/arrow-rs/pull/2595) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Decimal precision scale datatype change [\#2532](https://github.com/apache/arrow-rs/pull/2532) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Refactor PrimitiveBuilder Constructors [\#2518](https://github.com/apache/arrow-rs/pull/2518) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Refactoring DecimalBuilder constructors [\#2517](https://github.com/apache/arrow-rs/pull/2517) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Refactor FixedSizeBinaryBuilder Constructors [\#2516](https://github.com/apache/arrow-rs/pull/2516) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Refactor BooleanBuilder Constructors [\#2515](https://github.com/apache/arrow-rs/pull/2515) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Refactor UnionBuilder Constructors [\#2488](https://github.com/apache/arrow-rs/pull/2488) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+
+**Implemented enhancements:**
+
+- Add  Macros to assist with static dispatch [\#2635](https://github.com/apache/arrow-rs/issues/2635) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support comparison between DictionaryArray and BooleanArray [\#2617](https://github.com/apache/arrow-rs/issues/2617) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use `total_cmp` for floating value ordering and remove `nan_ordering` feature flag [\#2613](https://github.com/apache/arrow-rs/issues/2613) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support empty projection in CSV, JSON readers [\#2603](https://github.com/apache/arrow-rs/issues/2603) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support SQL-compliant NaN ordering between for DictionaryArray and non-DictionaryArray [\#2599](https://github.com/apache/arrow-rs/issues/2599) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add `dyn_cmp_dict` feature flag to gate dyn comparison of dictionary arrays [\#2596](https://github.com/apache/arrow-rs/issues/2596) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add max\_dyn and min\_dyn for max/min for dictionary array [\#2584](https://github.com/apache/arrow-rs/issues/2584) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Allow FlightSQL implementers to extend `do_get()` [\#2581](https://github.com/apache/arrow-rs/issues/2581) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Support SQL-compliant behavior on `eq_dyn`, `neq_dyn`, `lt_dyn`, `lt_eq_dyn`, `gt_dyn`, `gt_eq_dyn` [\#2569](https://github.com/apache/arrow-rs/issues/2569) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add sql-compliant feature for enabling sql-compliant kernel behavior [\#2568](https://github.com/apache/arrow-rs/issues/2568)
+- Calculate `sum` for dictionary array [\#2565](https://github.com/apache/arrow-rs/issues/2565) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add test for float nan comparison [\#2556](https://github.com/apache/arrow-rs/issues/2556) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Compare dictionary with string array [\#2548](https://github.com/apache/arrow-rs/issues/2548) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Compare dictionary with primitive array in `lt_dyn`, `lt_eq_dyn`, `gt_dyn`, `gt_eq_dyn` [\#2538](https://github.com/apache/arrow-rs/issues/2538) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Compare dictionary with primitive array in `eq_dyn` and `neq_dyn` [\#2535](https://github.com/apache/arrow-rs/issues/2535) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- UnionBuilder Create Children With Capacity [\#2523](https://github.com/apache/arrow-rs/issues/2523) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Speed up `like_utf8_scalar` for `%pat%` [\#2519](https://github.com/apache/arrow-rs/issues/2519) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Replace macro with TypedDictionaryArray in comparison kernels [\#2513](https://github.com/apache/arrow-rs/issues/2513) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use same codebase for boolean kernels [\#2507](https://github.com/apache/arrow-rs/issues/2507) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use u8 for Decimal Precision and Scale [\#2496](https://github.com/apache/arrow-rs/issues/2496) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Integrate skip row without pageIndex in SerializedPageReader in Fuzz Test [\#2475](https://github.com/apache/arrow-rs/issues/2475) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Avoid unnecessary copies in Arrow IPC reader [\#2437](https://github.com/apache/arrow-rs/issues/2437) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add GenericColumnReader::skip\_records Missing OffsetIndex Fallback [\#2433](https://github.com/apache/arrow-rs/issues/2433) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support Reading PageIndex with ParquetRecordBatchStream [\#2430](https://github.com/apache/arrow-rs/issues/2430) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Specialize FixedLenByteArrayReader for Parquet [\#2318](https://github.com/apache/arrow-rs/issues/2318) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Make JSON support Optional via Feature Flag [\#2300](https://github.com/apache/arrow-rs/issues/2300) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Fixed bugs:**
+
+- Casting timestamp array to string should not ignore timezone [\#2607](https://github.com/apache/arrow-rs/issues/2607) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Ilike\_ut8\_scalar kernels have incorrect logic [\#2544](https://github.com/apache/arrow-rs/issues/2544) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Always validate the array data when creating array in IPC reader [\#2541](https://github.com/apache/arrow-rs/issues/2541) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Int96Converter Truncates Timestamps [\#2480](https://github.com/apache/arrow-rs/issues/2480) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Error Reading Page Index When Not Available  [\#2434](https://github.com/apache/arrow-rs/issues/2434) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- `ParquetFileArrowReader::get_record_reader[_by_column]` `batch_size` overallocates [\#2321](https://github.com/apache/arrow-rs/issues/2321) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Documentation updates:**
+
+- Document All Arrow Features in docs.rs [\#2633](https://github.com/apache/arrow-rs/issues/2633) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- Add support for CAST from `Interval(DayTime)` to `Timestamp(Nanosecond, None)` [\#2606](https://github.com/apache/arrow-rs/issues/2606) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Why do we check for null in TypedDictionaryArray value function [\#2564](https://github.com/apache/arrow-rs/issues/2564) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add the `length` field for `Buffer` [\#2524](https://github.com/apache/arrow-rs/issues/2524) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Avoid large over allocate buffer in async reader [\#2512](https://github.com/apache/arrow-rs/issues/2512) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Rewriting Decimal Builders using `const_generic`. [\#2390](https://github.com/apache/arrow-rs/issues/2390) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Rewrite Decimal Array using `const_generic` [\#2384](https://github.com/apache/arrow-rs/issues/2384) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Add downcast macros \(\#2635\) [\#2636](https://github.com/apache/arrow-rs/pull/2636) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Document all arrow features in docs.rs \(\#2633\) [\#2634](https://github.com/apache/arrow-rs/pull/2634) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Document dyn\_cmp\_dict [\#2624](https://github.com/apache/arrow-rs/pull/2624) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support comparison between DictionaryArray and BooleanArray [\#2618](https://github.com/apache/arrow-rs/pull/2618) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Cast timestamp array to string array with timezone [\#2608](https://github.com/apache/arrow-rs/pull/2608) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Support empty projection in CSV and JSON readers [\#2604](https://github.com/apache/arrow-rs/pull/2604) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
+- Make JSON support optional via a feature flag \(\#2300\) [\#2601](https://github.com/apache/arrow-rs/pull/2601) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support SQL-compliant NaN ordering for DictionaryArray and non-DictionaryArray [\#2600](https://github.com/apache/arrow-rs/pull/2600) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Split out integration test plumbing \(\#2594\) \(\#2300\) [\#2598](https://github.com/apache/arrow-rs/pull/2598) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Refactor Binary Builder and String Builder Constructors [\#2592](https://github.com/apache/arrow-rs/pull/2592) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Dictionary like scalar kernels [\#2591](https://github.com/apache/arrow-rs/pull/2591) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Validate dictionary key in TypedDictionaryArray \(\#2578\) [\#2589](https://github.com/apache/arrow-rs/pull/2589) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add max\_dyn and min\_dyn for max/min for dictionary array [\#2585](https://github.com/apache/arrow-rs/pull/2585) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Code cleanup of array value functions [\#2583](https://github.com/apache/arrow-rs/pull/2583) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Allow overriding of do\_get & export useful macro [\#2582](https://github.com/apache/arrow-rs/pull/2582) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([avantgardnerio](https://github.com/avantgardnerio))
+- MINOR: Upgrade to pyo3 0.17 [\#2576](https://github.com/apache/arrow-rs/pull/2576) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([andygrove](https://github.com/andygrove))
+- Support SQL-compliant NaN behavior on eq\_dyn, neq\_dyn, lt\_dyn, lt\_eq\_dyn, gt\_dyn, gt\_eq\_dyn [\#2570](https://github.com/apache/arrow-rs/pull/2570) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add sum\_dyn to calculate sum for dictionary array [\#2566](https://github.com/apache/arrow-rs/pull/2566) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- struct UnionBuilder will create child buffers with capacity [\#2560](https://github.com/apache/arrow-rs/pull/2560) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kastolars](https://github.com/kastolars))
+- Don't panic on RleValueEncoder::flush\_buffer if empty \(\#2558\) [\#2559](https://github.com/apache/arrow-rs/pull/2559) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add the `length` field for Buffer and use more `Buffer` in IPC reader to avoid memory copy. [\#2557](https://github.com/apache/arrow-rs/pull/2557) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([HaoYang670](https://github.com/HaoYang670))
+- Add test for float nan comparison [\#2555](https://github.com/apache/arrow-rs/pull/2555) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Compare dictionary array with string array [\#2549](https://github.com/apache/arrow-rs/pull/2549) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Always validate the array data \(except the `Decimal`\) when creating array in IPC reader [\#2547](https://github.com/apache/arrow-rs/pull/2547) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- MINOR: Fix test\_row\_type\_validation test [\#2546](https://github.com/apache/arrow-rs/pull/2546) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Fix ilike\_utf8\_scalar kernels [\#2545](https://github.com/apache/arrow-rs/pull/2545) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- fix typo [\#2540](https://github.com/apache/arrow-rs/pull/2540) ([00Masato](https://github.com/00Masato))
+- Compare dictionary array and primitive array in lt\_dyn, lt\_eq\_dyn, gt\_dyn, gt\_eq\_dyn kernels [\#2539](https://github.com/apache/arrow-rs/pull/2539) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- \[MINOR\]Avoid large over allocate buffer in async reader [\#2537](https://github.com/apache/arrow-rs/pull/2537) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Compare dictionary with primitive array in `eq_dyn` and `neq_dyn` [\#2533](https://github.com/apache/arrow-rs/pull/2533) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add iterator for FixedSizeBinaryArray [\#2531](https://github.com/apache/arrow-rs/pull/2531) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- add bench: decimal with byte array and fixed length byte array [\#2529](https://github.com/apache/arrow-rs/pull/2529) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([liukun4515](https://github.com/liukun4515))
+- Add FixedLengthByteArrayReader Remove ComplexObjectArrayReader [\#2528](https://github.com/apache/arrow-rs/pull/2528) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Split out byte array decoders \(\#2318\) [\#2527](https://github.com/apache/arrow-rs/pull/2527) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Use offset index in ParquetRecordBatchStream [\#2526](https://github.com/apache/arrow-rs/pull/2526) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
+- Clean the `create_array` in IPC reader. [\#2525](https://github.com/apache/arrow-rs/pull/2525) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Remove DecimalByteArrayConvert \(\#2480\) [\#2522](https://github.com/apache/arrow-rs/pull/2522) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Improve performance of `%pat%` \(\>3x speedup\) [\#2521](https://github.com/apache/arrow-rs/pull/2521) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
+- remove len field from MapBuilder [\#2520](https://github.com/apache/arrow-rs/pull/2520) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+-  Replace macro with TypedDictionaryArray in comparison kernels [\#2514](https://github.com/apache/arrow-rs/pull/2514) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Avoid large over allocate buffer in sync reader [\#2511](https://github.com/apache/arrow-rs/pull/2511) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Avoid useless memory copies in IPC reader. [\#2510](https://github.com/apache/arrow-rs/pull/2510) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Refactor boolean kernels to use same codebase [\#2508](https://github.com/apache/arrow-rs/pull/2508) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Remove Int96Converter \(\#2480\) [\#2481](https://github.com/apache/arrow-rs/pull/2481) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+
+## [21.0.0](https://github.com/apache/arrow-rs/tree/21.0.0) (2022-08-18)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/20.0.0...21.0.0)
+
+**Breaking changes:**
+
+- Return structured `ColumnCloseResult` \(\#2465\) [\#2466](https://github.com/apache/arrow-rs/pull/2466) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Push `ChunkReader` into `SerializedPageReader` \(\#2463\) [\#2464](https://github.com/apache/arrow-rs/pull/2464) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Revise FromIterator for Decimal128Array to use Into instead of Borrow [\#2442](https://github.com/apache/arrow-rs/pull/2442) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Use Fixed-Length Array in BasicDecimal new and raw\_value [\#2405](https://github.com/apache/arrow-rs/pull/2405) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Remove deprecated ParquetWriter [\#2380](https://github.com/apache/arrow-rs/pull/2380) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Remove deprecated SliceableCursor and InMemoryWriteableCursor [\#2378](https://github.com/apache/arrow-rs/pull/2378) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- add into\_inner method to ArrowWriter [\#2491](https://github.com/apache/arrow-rs/issues/2491) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Remove byteorder dependency [\#2472](https://github.com/apache/arrow-rs/issues/2472) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Return Structured ColumnCloseResult from GenericColumnWriter::close [\#2465](https://github.com/apache/arrow-rs/issues/2465) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Push `ChunkReader` into `SerializedPageReader` [\#2463](https://github.com/apache/arrow-rs/issues/2463) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support SerializedPageReader::skip\_page without OffsetIndex [\#2459](https://github.com/apache/arrow-rs/issues/2459) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support Time64/Time32 comparison [\#2457](https://github.com/apache/arrow-rs/issues/2457) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Revise FromIterator for Decimal128Array to use Into instead of Borrow [\#2441](https://github.com/apache/arrow-rs/issues/2441) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support `RowFilter` within`ParquetRecordBatchReader` [\#2431](https://github.com/apache/arrow-rs/issues/2431) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Remove the field `StructBuilder::len` [\#2429](https://github.com/apache/arrow-rs/issues/2429) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Standardize creation and configuration of parquet --\> Arrow readers \( `ParquetRecordBatchReaderBuilder`\) [\#2427](https://github.com/apache/arrow-rs/issues/2427) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Use `OffsetIndex` to Prune IO in `ParquetRecordBatchStream` [\#2426](https://github.com/apache/arrow-rs/issues/2426) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support `peek_next_page` and `skip_next_page` in `InMemoryPageReader` [\#2406](https://github.com/apache/arrow-rs/issues/2406) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support casting from `Utf8`/`LargeUtf8` to `Binary`/`LargeBinary` [\#2402](https://github.com/apache/arrow-rs/issues/2402) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support casting between `Decimal128` and `Decimal256` arrays [\#2375](https://github.com/apache/arrow-rs/issues/2375) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Combine multiple selections into the same batch size in `skip_records` [\#2358](https://github.com/apache/arrow-rs/issues/2358) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Add API to change timezone for timestamp array [\#2346](https://github.com/apache/arrow-rs/issues/2346) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Change the output of `read_buffer` Arrow IPC API to return `Result<_>` [\#2342](https://github.com/apache/arrow-rs/issues/2342) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Allow `skip_records` in `GenericColumnReader` to skip across row groups [\#2331](https://github.com/apache/arrow-rs/issues/2331) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Optimize the validation of `Decimal256` [\#2320](https://github.com/apache/arrow-rs/issues/2320) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Implement Skip for `DeltaBitPackDecoder` [\#2281](https://github.com/apache/arrow-rs/issues/2281) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Changes to `ParquetRecordBatchStream` to support row filtering in DataFusion [\#2270](https://github.com/apache/arrow-rs/issues/2270) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Add `ArrayReader::skip_records` API [\#2197](https://github.com/apache/arrow-rs/issues/2197) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Fixed bugs:**
+
+- Panic in SerializedPageReader without offset index [\#2503](https://github.com/apache/arrow-rs/issues/2503) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- MapArray columns don't handle null values correctly [\#2484](https://github.com/apache/arrow-rs/issues/2484) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- There is no compiler error when using an invalid Decimal type. [\#2440](https://github.com/apache/arrow-rs/issues/2440) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Flight SQL Server sends incorrect response for `DoPutUpdateResult` [\#2403](https://github.com/apache/arrow-rs/issues/2403) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- `AsyncFileReader`No Longer Object-Safe [\#2372](https://github.com/apache/arrow-rs/issues/2372) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- StructBuilder Does not Verify Child Lengths [\#2252](https://github.com/apache/arrow-rs/issues/2252) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Closed issues:**
+
+- Combine `DecimalArray` validation [\#2447](https://github.com/apache/arrow-rs/issues/2447) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Merged pull requests:**
+
+- Fix bug in page skipping [\#2504](https://github.com/apache/arrow-rs/pull/2504) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
+- Fix `MapArrayReader` \(\#2484\) \(\#1699\) \(\#1561\) [\#2500](https://github.com/apache/arrow-rs/pull/2500) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add API to Retrieve Finished Writer from Parquet Writer [\#2498](https://github.com/apache/arrow-rs/pull/2498) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([jiacai2050](https://github.com/jiacai2050))
+- Derive Copy,Clone for BasicDecimal [\#2495](https://github.com/apache/arrow-rs/pull/2495) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- remove byteorder dependency from parquet [\#2486](https://github.com/apache/arrow-rs/pull/2486) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([psvri](https://github.com/psvri))
+- parquet-read: add support to read parquet data from stdin [\#2482](https://github.com/apache/arrow-rs/pull/2482) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([nvartolomei](https://github.com/nvartolomei))
+- Remove Position trait \(\#1163\) [\#2479](https://github.com/apache/arrow-rs/pull/2479) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add ChunkReader::get\_bytes [\#2478](https://github.com/apache/arrow-rs/pull/2478) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- RFC: Simplify decimal \(\#2440\) [\#2477](https://github.com/apache/arrow-rs/pull/2477) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use Parquet OffsetIndex to prune IO with RowSelection [\#2473](https://github.com/apache/arrow-rs/pull/2473) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
+- Remove unnecessary Option from Int96 [\#2471](https://github.com/apache/arrow-rs/pull/2471) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- remove len field from StructBuilder [\#2468](https://github.com/apache/arrow-rs/pull/2468) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Make Parquet reader filter APIs public \(\#1792\) [\#2467](https://github.com/apache/arrow-rs/pull/2467) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- enable ipc compression feature for integration test [\#2462](https://github.com/apache/arrow-rs/pull/2462) ([liukun4515](https://github.com/liukun4515))
+- Simplify implementation of Schema [\#2461](https://github.com/apache/arrow-rs/pull/2461) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Support skip\_page missing OffsetIndex Fallback in SerializedPageReader [\#2460](https://github.com/apache/arrow-rs/pull/2460) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- support time32/time64 comparison [\#2458](https://github.com/apache/arrow-rs/pull/2458) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([waitingkuo](https://github.com/waitingkuo))
+- Utf8array casting [\#2456](https://github.com/apache/arrow-rs/pull/2456) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- Remove outdated license text [\#2455](https://github.com/apache/arrow-rs/pull/2455) ([alamb](https://github.com/alamb))
+- Support RowFilter within ParquetRecordBatchReader \(\#2431\) [\#2452](https://github.com/apache/arrow-rs/pull/2452) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- benchmark: decimal builder and vec to decimal array [\#2450](https://github.com/apache/arrow-rs/pull/2450) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Collocate Decimal Array Validation Logic [\#2446](https://github.com/apache/arrow-rs/pull/2446) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Minor: Move From trait for Decimal256 impl to decimal.rs [\#2443](https://github.com/apache/arrow-rs/pull/2443) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- decimal benchmark: arrow reader decimal from parquet int32 and int64 [\#2438](https://github.com/apache/arrow-rs/pull/2438) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([liukun4515](https://github.com/liukun4515))
+- MINOR: Simplify `split_second` function [\#2436](https://github.com/apache/arrow-rs/pull/2436) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add ParquetRecordBatchReaderBuilder \(\#2427\) [\#2435](https://github.com/apache/arrow-rs/pull/2435) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- refactor: refine validation for decimal128 array [\#2428](https://github.com/apache/arrow-rs/pull/2428) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Benchmark of casting decimal arrays [\#2424](https://github.com/apache/arrow-rs/pull/2424) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Test non-annotated repeated fields \(\#2394\) [\#2422](https://github.com/apache/arrow-rs/pull/2422) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Fix \#2416 Automatic version updates for github actions with dependabot [\#2417](https://github.com/apache/arrow-rs/pull/2417) ([iemejia](https://github.com/iemejia))
+- Add validation logic for StructBuilder::finish [\#2413](https://github.com/apache/arrow-rs/pull/2413) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([psvri](https://github.com/psvri))
+- test: add test for reading decimal value from primitive array reader [\#2411](https://github.com/apache/arrow-rs/pull/2411) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([liukun4515](https://github.com/liukun4515))
+- Upgrade ahash to 0.8 [\#2410](https://github.com/apache/arrow-rs/pull/2410) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
+- Support peek\_next\_page and skip\_next\_page in InMemoryPageReader [\#2407](https://github.com/apache/arrow-rs/pull/2407) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Fix DoPutUpdateResult [\#2404](https://github.com/apache/arrow-rs/pull/2404) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([avantgardnerio](https://github.com/avantgardnerio))
+- Implement Skip for DeltaBitPackDecoder [\#2393](https://github.com/apache/arrow-rs/pull/2393) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- fix: Don't instantiate the scalar composition code quadratically for dictionaries [\#2391](https://github.com/apache/arrow-rs/pull/2391) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Marwes](https://github.com/Marwes))
+- MINOR: Remove unused trait and some cleanup [\#2389](https://github.com/apache/arrow-rs/pull/2389) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Decouple parquet fuzz tests from converter \(\#1661\) [\#2386](https://github.com/apache/arrow-rs/pull/2386) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Rewrite `Decimal` and `DecimalArray` using `const_generic` [\#2383](https://github.com/apache/arrow-rs/pull/2383) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Simplify BitReader \(~5-10% faster\) [\#2381](https://github.com/apache/arrow-rs/pull/2381) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Fix parquet clippy lints \(\#1254\) [\#2377](https://github.com/apache/arrow-rs/pull/2377) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Cast between `Decimal128` and `Decimal256` arrays [\#2376](https://github.com/apache/arrow-rs/pull/2376) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- support compression for IPC with revamped feature flags [\#2369](https://github.com/apache/arrow-rs/pull/2369) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Implement AsyncFileReader for `Box<dyn AsyncFileReader>` [\#2368](https://github.com/apache/arrow-rs/pull/2368) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Remove get\_byte\_ranges where bound [\#2366](https://github.com/apache/arrow-rs/pull/2366) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- refactor: Make read\_num\_bytes a function instead of a macro [\#2364](https://github.com/apache/arrow-rs/pull/2364) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Marwes](https://github.com/Marwes))
+- refactor: Group metrics into page and column metrics structs [\#2363](https://github.com/apache/arrow-rs/pull/2363) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Marwes](https://github.com/Marwes))
+- Speed up `Decimal256` validation based on bytes comparison and add benchmark test [\#2360](https://github.com/apache/arrow-rs/pull/2360) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Combine multiple selections into the same batch size in skip\_records [\#2359](https://github.com/apache/arrow-rs/pull/2359) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Add API to change timezone for timestamp array [\#2347](https://github.com/apache/arrow-rs/pull/2347) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Clean the code in `field.rs` and add more tests [\#2345](https://github.com/apache/arrow-rs/pull/2345) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Add Parquet RowFilter API [\#2335](https://github.com/apache/arrow-rs/pull/2335) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Make skip\_records in complex\_object\_array can skip cross row groups [\#2332](https://github.com/apache/arrow-rs/pull/2332) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Integrate Record Skipping into Column Reader Fuzz Test [\#2315](https://github.com/apache/arrow-rs/pull/2315) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+
+## [20.0.0](https://github.com/apache/arrow-rs/tree/20.0.0) (2022-08-05)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/19.0.0...20.0.0)
+
+**Breaking changes:**
+
+- Add more const evaluation for `GenericBinaryArray` and `GenericListArray`: add `PREFIX` and data type constructor [\#2327](https://github.com/apache/arrow-rs/pull/2327) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Make FFI support optional, change APIs to be `safe` \(\#2302\) [\#2303](https://github.com/apache/arrow-rs/pull/2303) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Remove `test_utils` from default features \(\#2298\) [\#2299](https://github.com/apache/arrow-rs/pull/2299) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Rename `DataType::Decimal` to `DataType::Decimal128` [\#2229](https://github.com/apache/arrow-rs/pull/2229) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Add `Decimal128Iter` and `Decimal256Iter` and do maximum precision/scale check [\#2140](https://github.com/apache/arrow-rs/pull/2140) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+
+**Implemented enhancements:**
+
+- Add the constant data type constructors for `ListArray` [\#2311](https://github.com/apache/arrow-rs/issues/2311) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Update `FlightSqlService` trait to pass session info along [\#2308](https://github.com/apache/arrow-rs/issues/2308) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Optimize `take_bits` for non-null indices [\#2306](https://github.com/apache/arrow-rs/issues/2306) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Make FFI support optional via Feature Flag `ffi` [\#2302](https://github.com/apache/arrow-rs/issues/2302) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Mark `ffi::ArrowArray::try_new` is safe [\#2301](https://github.com/apache/arrow-rs/issues/2301) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Remove test\_utils from default arrow-rs features [\#2298](https://github.com/apache/arrow-rs/issues/2298) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Remove `JsonEqual` trait [\#2296](https://github.com/apache/arrow-rs/issues/2296) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Move `with_precision_and_scale` to `Decimal` array traits [\#2291](https://github.com/apache/arrow-rs/issues/2291) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Improve readability and maybe performance of string --\> numeric/time/date/timetamp cast kernels [\#2285](https://github.com/apache/arrow-rs/issues/2285) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add vectorized unpacking for 8, 16, and 64 bit integers [\#2276](https://github.com/apache/arrow-rs/issues/2276) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Use initial capacity for interner hashmap [\#2273](https://github.com/apache/arrow-rs/issues/2273) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+-  Impl FromIterator for Decimal256Array [\#2248](https://github.com/apache/arrow-rs/issues/2248) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Separate `ArrayReader::next_batch`with `ArrayReader::read_records` and `ArrayReader::consume_batch` [\#2236](https://github.com/apache/arrow-rs/issues/2236) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Rename `DataType::Decimal` to `DataType::Decimal128` [\#2228](https://github.com/apache/arrow-rs/issues/2228) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Automatically Grow Parquet BitWriter Buffer [\#2226](https://github.com/apache/arrow-rs/issues/2226) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Add `append_option` support to `Decimal128Builder` and `Decimal256Builder` [\#2224](https://github.com/apache/arrow-rs/issues/2224) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Split the `FixedSizeBinaryArray` and `FixedSizeListArray` from `array_binary.rs` and `array_list.rs` [\#2217](https://github.com/apache/arrow-rs/issues/2217) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Don't `Box` Values in `PrimitiveDictionaryBuilder` [\#2215](https://github.com/apache/arrow-rs/issues/2215) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use BitChunks in equal\_bits [\#2186](https://github.com/apache/arrow-rs/issues/2186) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Implement `Hash` for `Schema` [\#2182](https://github.com/apache/arrow-rs/issues/2182) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- read decimal data type from parquet file with binary physical type [\#2159](https://github.com/apache/arrow-rs/issues/2159) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- The `GenericStringBuilder` should use `GenericBinaryBuilder` [\#2156](https://github.com/apache/arrow-rs/issues/2156) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Update Rust version to 1.62 [\#2143](https://github.com/apache/arrow-rs/issues/2143) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- Check precision and scale against maximum value when constructing `Decimal128` and `Decimal256` [\#2139](https://github.com/apache/arrow-rs/issues/2139) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use `ArrayAccessor` in `Decimal128Iter` and `Decimal256Iter` [\#2138](https://github.com/apache/arrow-rs/issues/2138) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use `ArrayAccessor` and `FromIterator` in Cast Kernels [\#2137](https://github.com/apache/arrow-rs/issues/2137) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add `TypedDictionaryArray` for more ergonomic interaction with `DictionaryArray` [\#2136](https://github.com/apache/arrow-rs/issues/2136) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use `ArrayAccessor` in Comparison Kernels [\#2135](https://github.com/apache/arrow-rs/issues/2135) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support `peek_next_page()` and s`kip_next_page` in `InMemoryColumnChunkReader` [\#2129](https://github.com/apache/arrow-rs/issues/2129) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Lazily materialize the null buffer builder for all array builders. [\#2125](https://github.com/apache/arrow-rs/issues/2125) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Do value validation for `Decimal256` [\#2112](https://github.com/apache/arrow-rs/issues/2112) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support `skip_def_levels`  for `ColumnLevelDecoder` [\#2107](https://github.com/apache/arrow-rs/issues/2107) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Add integration test for scan rows  with selection [\#2106](https://github.com/apache/arrow-rs/issues/2106) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support for casting from Utf8/String to `Time32` / `Time64` [\#2053](https://github.com/apache/arrow-rs/issues/2053) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Update prost and tonic related crates [\#2268](https://github.com/apache/arrow-rs/pull/2268) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([carols10cents](https://github.com/carols10cents))
+
+**Fixed bugs:**
+
+- temporal conversion functions cannot work on negative input properly [\#2325](https://github.com/apache/arrow-rs/issues/2325) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- IPC writer should truncate string array with all empty string [\#2312](https://github.com/apache/arrow-rs/issues/2312) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Error order for comparing `Decimal128` or `Decimal256` [\#2256](https://github.com/apache/arrow-rs/issues/2256) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Fix maximum and minimum for decimal values for precision greater than 38 [\#2246](https://github.com/apache/arrow-rs/issues/2246) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `IntervalMonthDayNanoType::make_value()` does not match C implementation [\#2234](https://github.com/apache/arrow-rs/issues/2234) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `FlightSqlService` trait does not allow `impl`s to do handshake [\#2210](https://github.com/apache/arrow-rs/issues/2210) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
+- `EnabledStatistics::None` not working [\#2185](https://github.com/apache/arrow-rs/issues/2185) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Boolean ArrayData Equality Incorrect Slice Handling [\#2184](https://github.com/apache/arrow-rs/issues/2184) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Publicly export MapFieldNames [\#2118](https://github.com/apache/arrow-rs/issues/2118) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+
+**Documentation updates:**
+
+- Update instructions on How to join the slack \#arrow-rust channel -- or maybe try to switch to discord?? [\#2192](https://github.com/apache/arrow-rs/issues/2192)
+- \[Minor\] Improve arrow and parquet READMEs, document parquet feature flags [\#2324](https://github.com/apache/arrow-rs/pull/2324) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+
+**Performance improvements:**
+
+- Improve speed of writing string dictionaries to parquet by skipping a copy\(\#1764\)  [\#2322](https://github.com/apache/arrow-rs/pull/2322) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+
+**Closed issues:**
+
+- Fix wrong logic in calculate\_row\_count when skipping values [\#2328](https://github.com/apache/arrow-rs/issues/2328) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support filter for parquet data type [\#2126](https://github.com/apache/arrow-rs/issues/2126) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Make skip value in ByteArrayDecoderDictionary avoid decoding [\#2088](https://github.com/apache/arrow-rs/issues/2088) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+
+**Merged pull requests:**
+
+- fix: Fix skip error in calculate\_row\_count. [\#2329](https://github.com/apache/arrow-rs/pull/2329) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- temporal conversion functions should work on negative input properly [\#2326](https://github.com/apache/arrow-rs/pull/2326) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Increase DeltaBitPackEncoder miniblock size to 64 for 64-bit integers  \(\#2282\) [\#2319](https://github.com/apache/arrow-rs/pull/2319) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Remove JsonEqual [\#2317](https://github.com/apache/arrow-rs/pull/2317) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- fix: IPC writer should truncate string array with all empty string [\#2314](https://github.com/apache/arrow-rs/pull/2314) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([JasonLi-cn](https://github.com/JasonLi-cn))
+- Pass pull `Request<FlightDescriptor>` to `FlightSqlService` `impl`s  [\#2309](https://github.com/apache/arrow-rs/pull/2309) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([avantgardnerio](https://github.com/avantgardnerio))
+- Speedup take\_boolean / take\_bits for non-null indices \(~4 - 5x speedup\) [\#2307](https://github.com/apache/arrow-rs/pull/2307) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
+- Add typed dictionary \(\#2136\) [\#2297](https://github.com/apache/arrow-rs/pull/2297) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- \[Minor\] Improve types shown in cast error messages [\#2295](https://github.com/apache/arrow-rs/pull/2295) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Move `with_precision_and_scale` to `BasicDecimalArray` trait [\#2292](https://github.com/apache/arrow-rs/pull/2292) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Replace the `fn get_data_type` by `const DATA_TYPE` in BinaryArray and StringArray [\#2289](https://github.com/apache/arrow-rs/pull/2289) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Clean up string casts and improve performance [\#2284](https://github.com/apache/arrow-rs/pull/2284) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- \[Minor\] Add tests for temporal cast error paths [\#2283](https://github.com/apache/arrow-rs/pull/2283) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Add unpack8, unpack16, unpack64 \(\#2276\) ~10-50% faster [\#2278](https://github.com/apache/arrow-rs/pull/2278) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Fix bugs in the `from_list` function. [\#2277](https://github.com/apache/arrow-rs/pull/2277) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- fix: use signed comparator to compare decimal128 and decimal256 [\#2275](https://github.com/apache/arrow-rs/pull/2275) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
+- Use initial capacity for interner hashmap [\#2272](https://github.com/apache/arrow-rs/pull/2272) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Dandandan](https://github.com/Dandandan))
+- Remove fallibility from paruqet RleEncoder \(\#2226\) [\#2259](https://github.com/apache/arrow-rs/pull/2259) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Fix escaped like wildcards in `like_utf8` / `nlike_utf8` kernels [\#2258](https://github.com/apache/arrow-rs/pull/2258) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([daniel-martinez-maqueda-sap](https://github.com/daniel-martinez-maqueda-sap))
+- Add tests for reading nested decimal arrays from parquet [\#2254](https://github.com/apache/arrow-rs/pull/2254) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- feat: Implement string cast operations for Time32 and Time64 [\#2251](https://github.com/apache/arrow-rs/pull/2251) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([stuartcarnie](https://github.com/stuartcarnie))
+- move `FixedSizeList` to `array_fixed_size_list.rs` [\#2250](https://github.com/apache/arrow-rs/pull/2250) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Impl FromIterator for Decimal256Array [\#2247](https://github.com/apache/arrow-rs/pull/2247) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Fix max and min value for decimal precision greater than 38 [\#2245](https://github.com/apache/arrow-rs/pull/2245) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Make `Schema::fields` and `Schema::metadata` `pub` \(public\) [\#2239](https://github.com/apache/arrow-rs/pull/2239) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- \[Minor\] Improve Schema metadata mismatch error [\#2238](https://github.com/apache/arrow-rs/pull/2238) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Separate ArrayReader::next\_batch with read\_records and consume\_batch [\#2237](https://github.com/apache/arrow-rs/pull/2237) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Update `IntervalMonthDayNanoType::make_value()` to conform to specifications [\#2235](https://github.com/apache/arrow-rs/pull/2235) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([avantgardnerio](https://github.com/avantgardnerio))
+- Disable value validation for Decimal256 case [\#2232](https://github.com/apache/arrow-rs/pull/2232) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Automatically grow parquet BitWriter \(\#2226\) \(~10% faster\) [\#2231](https://github.com/apache/arrow-rs/pull/2231) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Only trigger `arrow` CI on changes to arrow [\#2227](https://github.com/apache/arrow-rs/pull/2227) ([alamb](https://github.com/alamb))
+- Add append\_option support to decimal builders [\#2225](https://github.com/apache/arrow-rs/pull/2225) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([bphillips-exos](https://github.com/bphillips-exos))
+- Optimized writing of byte array to parquet \(\#1764\) \(2x faster\) [\#2221](https://github.com/apache/arrow-rs/pull/2221) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Increase test coverage of ArrowWriter [\#2220](https://github.com/apache/arrow-rs/pull/2220) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Update instructions on how to join the Slack channel [\#2219](https://github.com/apache/arrow-rs/pull/2219) ([HaoYang670](https://github.com/HaoYang670))
+- Move `FixedSizeBinaryArray` to `array_fixed_size_binary.rs` [\#2218](https://github.com/apache/arrow-rs/pull/2218) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Avoid boxing in PrimitiveDictionaryBuilder [\#2216](https://github.com/apache/arrow-rs/pull/2216) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- remove redundant CI benchmark check, cleanups [\#2212](https://github.com/apache/arrow-rs/pull/2212) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([alamb](https://github.com/alamb))
+- Update `FlightSqlService` trait to proxy handshake [\#2211](https://github.com/apache/arrow-rs/pull/2211) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([avantgardnerio](https://github.com/avantgardnerio))
+- parquet: export json api with `serde_json` feature name [\#2209](https://github.com/apache/arrow-rs/pull/2209) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([flisky](https://github.com/flisky))
+- Cleanup record skipping logic and tests \(\#2158\) [\#2199](https://github.com/apache/arrow-rs/pull/2199) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Use BitChunks in equal\_bits [\#2194](https://github.com/apache/arrow-rs/pull/2194) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Fix disabling parquet statistics \(\#2185\) [\#2191](https://github.com/apache/arrow-rs/pull/2191) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Change CI names to match crate names [\#2189](https://github.com/apache/arrow-rs/pull/2189) ([alamb](https://github.com/alamb))
+- Fix offset handling in boolean\_equal \(\#2184\) [\#2187](https://github.com/apache/arrow-rs/pull/2187) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Implement `Hash` for `Schema` [\#2183](https://github.com/apache/arrow-rs/pull/2183) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([crepererum](https://github.com/crepererum))
+- Let the `StringBuilder` use `BinaryBuilder` [\#2181](https://github.com/apache/arrow-rs/pull/2181) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Use ArrayAccessor and FromIterator in Cast Kernels [\#2169](https://github.com/apache/arrow-rs/pull/2169) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Split most arrow specific CI checks into their own workflows \(reduce common CI time to 21 minutes\) [\#2168](https://github.com/apache/arrow-rs/pull/2168) ([alamb](https://github.com/alamb))
+- Remove another attempt to cache target directory in action.yaml [\#2167](https://github.com/apache/arrow-rs/pull/2167) ([alamb](https://github.com/alamb))
+- Run actions on push to master, pull requests [\#2166](https://github.com/apache/arrow-rs/pull/2166) ([alamb](https://github.com/alamb))
+- Break parquet\_derive and arrow\_flight tests into their own workflows [\#2165](https://github.com/apache/arrow-rs/pull/2165) ([alamb](https://github.com/alamb))
+- \[minor\] use type aliases refine code. [\#2161](https://github.com/apache/arrow-rs/pull/2161) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- parquet reader: Support reading decimals from parquet `BYTE_ARRAY` type [\#2160](https://github.com/apache/arrow-rs/pull/2160) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([liukun4515](https://github.com/liukun4515))
+- Add integration test for scan rows with selection [\#2158](https://github.com/apache/arrow-rs/pull/2158) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Use ArrayAccessor in Comparison Kernels [\#2157](https://github.com/apache/arrow-rs/pull/2157) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Implement `peek\_next\_page` and `skip\_next\_page` for `InMemoryColumnCh… [\#2155](https://github.com/apache/arrow-rs/pull/2155) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
+- Avoid decoding unneeded values in ByteArrayDecoderDictionary [\#2154](https://github.com/apache/arrow-rs/pull/2154) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
+- Only run integration tests when `arrow` changes [\#2152](https://github.com/apache/arrow-rs/pull/2152) ([alamb](https://github.com/alamb))
+- Break out docs CI job to its own github action [\#2151](https://github.com/apache/arrow-rs/pull/2151) ([alamb](https://github.com/alamb))
+- Do not pretend to cache rust build artifacts, speed up CI by ~20% [\#2150](https://github.com/apache/arrow-rs/pull/2150) ([alamb](https://github.com/alamb))
+- Update rust version to 1.62 [\#2144](https://github.com/apache/arrow-rs/pull/2144) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Make MapFieldNames public \(\#2118\) [\#2134](https://github.com/apache/arrow-rs/pull/2134) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add ArrayAccessor trait, remove duplication in array iterators \(\#1948\) [\#2133](https://github.com/apache/arrow-rs/pull/2133) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Lazily materialize the null buffer builder for all array builders. [\#2127](https://github.com/apache/arrow-rs/pull/2127) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
+- Faster parquet DictEncoder \(~20%\) [\#2123](https://github.com/apache/arrow-rs/pull/2123) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Add validation for Decimal256 [\#2113](https://github.com/apache/arrow-rs/pull/2113) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Support skip\_def\_levels for ColumnLevelDecoder [\#2111](https://github.com/apache/arrow-rs/pull/2111) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
+- Donate `object_store` code from object\_store\_rs to arrow-rs [\#2081](https://github.com/apache/arrow-rs/pull/2081) ([alamb](https://github.com/alamb))
+- Improve `validate_utf8` performance [\#2048](https://github.com/apache/arrow-rs/pull/2048) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tfeda](https://github.com/tfeda))
+
 ## [19.0.0](https://github.com/apache/arrow-rs/tree/19.0.0) (2022-07-22)
 
 [Full Changelog](https://github.com/apache/arrow-rs/compare/18.0.0...19.0.0)
@@ -171,7 +2585,7 @@
 - Incorrect `null_count` of DictionaryArray [\#1962](https://github.com/apache/arrow-rs/issues/1962) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 - Support multi diskRanges for ChunkReader [\#1955](https://github.com/apache/arrow-rs/issues/1955) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
 - Persisting Arrow timestamps with Parquet produces missing `TIMESTAMP` in schema [\#1920](https://github.com/apache/arrow-rs/issues/1920) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- Sperate get\_next\_page\_header from get\_next\_page in PageReader [\#1834](https://github.com/apache/arrow-rs/issues/1834) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Separate get\_next\_page\_header from get\_next\_page in PageReader [\#1834](https://github.com/apache/arrow-rs/issues/1834) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
 
 **Merged pull requests:**
 
@@ -228,7 +2642,7 @@
 - `PrimitiveArray::from_iter` should omit validity buffer if all values are valid [\#1856](https://github.com/apache/arrow-rs/issues/1856) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 - Add `from(v: Vec<Option<&[u8]>>)` and `from(v: Vec<&[u8]>)` for `FixedSizedBInaryArray` [\#1852](https://github.com/apache/arrow-rs/issues/1852) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 - Add `Vec`-inspired APIs to `BufferBuilder` [\#1850](https://github.com/apache/arrow-rs/issues/1850) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- PyArrow intergation test for C Stream Interface [\#1847](https://github.com/apache/arrow-rs/issues/1847) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- PyArrow integration test for C Stream Interface [\#1847](https://github.com/apache/arrow-rs/issues/1847) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 - Add `nilike` support in `comparison` [\#1845](https://github.com/apache/arrow-rs/issues/1845) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 - Split up `arrow::array::builder` module [\#1843](https://github.com/apache/arrow-rs/issues/1843) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 - Add `quarter` support in `temporal` kernels [\#1835](https://github.com/apache/arrow-rs/issues/1835) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
@@ -625,7 +3039,7 @@
 
 **Fixed bugs:**
 
-- Error Infering Schema for LogicalType::UNKNOWN [\#1557](https://github.com/apache/arrow-rs/issues/1557) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Error Inferring Schema for LogicalType::UNKNOWN [\#1557](https://github.com/apache/arrow-rs/issues/1557) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
 - Read dictionary from nested struct in ipc stream reader panics [\#1549](https://github.com/apache/arrow-rs/issues/1549) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 - `filter` produces invalid sparse `UnionArray`s [\#1547](https://github.com/apache/arrow-rs/issues/1547) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 - Documentation for `GenericListBuilder` is not exposed.  [\#1518](https://github.com/apache/arrow-rs/issues/1518) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
@@ -1151,7 +3565,7 @@
 * [094037d418381584178db1d886cad3b5024b414a](https://github.com/apache/arrow-rs/commit/094037d418381584178db1d886cad3b5024b414a) Update comfy-table to 5.0 ([#957](https://github.com/apache/arrow-rs/pull/957)) ([#964](https://github.com/apache/arrow-rs/pull/964))
 * [9f635021eee6786c5377c891218c5f88ebce07c3](https://github.com/apache/arrow-rs/commit/9f635021eee6786c5377c891218c5f88ebce07c3) Fix csv writing of timestamps to show timezone. ([#849](https://github.com/apache/arrow-rs/pull/849)) ([#963](https://github.com/apache/arrow-rs/pull/963))
 * [f7deba4c3a050a52608462ee8a827bb8f6364140](https://github.com/apache/arrow-rs/commit/f7deba4c3a050a52608462ee8a827bb8f6364140) Adding ability to parse float from number with leading decimal ([#831](https://github.com/apache/arrow-rs/pull/831)) ([#962](https://github.com/apache/arrow-rs/pull/962))
-* [59f96e842d05b63882f7ba285c66a9739761cf84](https://github.com/apache/arrow-rs/commit/59f96e842d05b63882f7ba285c66a9739761cf84) add ilike comparitor ([#874](https://github.com/apache/arrow-rs/pull/874)) ([#961](https://github.com/apache/arrow-rs/pull/961))
+* [59f96e842d05b63882f7ba285c66a9739761cf84](https://github.com/apache/arrow-rs/commit/59f96e842d05b63882f7ba285c66a9739761cf84) add ilike comparator ([#874](https://github.com/apache/arrow-rs/pull/874)) ([#961](https://github.com/apache/arrow-rs/pull/961))
 * [54023c8a5543c9f9fa4955afa01189029f3e96f5](https://github.com/apache/arrow-rs/commit/54023c8a5543c9f9fa4955afa01189029f3e96f5) Remove unpassable cargo publish check from verify-release-candidate.sh ([#882](https://github.com/apache/arrow-rs/pull/882)) ([#949](https://github.com/apache/arrow-rs/pull/949))
 
 
@@ -1248,7 +3662,7 @@
 **Fixed bugs:**
 
 - Converting from string to timestamp uses microseconds instead of milliseconds [\#780](https://github.com/apache/arrow-rs/issues/780)
-- Document has no link to `RowColumIter` [\#762](https://github.com/apache/arrow-rs/issues/762)
+- Document has no link to `RowColumnIter` [\#762](https://github.com/apache/arrow-rs/issues/762)
 - length on slices with null doesn't work [\#744](https://github.com/apache/arrow-rs/issues/744)
 
 ## [5.4.0](https://github.com/apache/arrow-rs/tree/5.4.0) (2021-09-10)
@@ -1306,7 +3720,7 @@
 - Remove undefined behavior in `value` method of boolean and primitive arrays [\#645](https://github.com/apache/arrow-rs/issues/645)
 - Avoid materialization of indices in filter\_record\_batch for single arrays [\#636](https://github.com/apache/arrow-rs/issues/636)
 - Add a note about arrow crate security / safety [\#627](https://github.com/apache/arrow-rs/issues/627)
-- Allow the creation of String arrays from an interator of &Option\<&str\> [\#598](https://github.com/apache/arrow-rs/issues/598)
+- Allow the creation of String arrays from an iterator of &Option\<&str\> [\#598](https://github.com/apache/arrow-rs/issues/598)
 - Support arrow map datatype [\#395](https://github.com/apache/arrow-rs/issues/395)
 
 **Fixed bugs:**
@@ -1435,7 +3849,7 @@
 - Add C data interface for decimal128 and timestamp [\#453](https://github.com/apache/arrow-rs/pull/453) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alippai](https://github.com/alippai))
 - Implement the Iterator trait for the json Reader. [\#451](https://github.com/apache/arrow-rs/pull/451) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([LaurentMazare](https://github.com/LaurentMazare))
 - Update release docs + release email template [\#450](https://github.com/apache/arrow-rs/pull/450) ([alamb](https://github.com/alamb))
-- remove clippy unnecessary wraps suppresions in cast kernel [\#449](https://github.com/apache/arrow-rs/pull/449) ([Jimexist](https://github.com/Jimexist))
+- remove clippy unnecessary wraps suppression in cast kernel [\#449](https://github.com/apache/arrow-rs/pull/449) ([Jimexist](https://github.com/Jimexist))
 - Use partition for bool sort [\#448](https://github.com/apache/arrow-rs/pull/448) ([Jimexist](https://github.com/Jimexist))
 - remove unnecessary wraps in sort [\#445](https://github.com/apache/arrow-rs/pull/445) ([Jimexist](https://github.com/Jimexist))
 - Python FFI bridge for Schema, Field and DataType  [\#439](https://github.com/apache/arrow-rs/pull/439) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kszucs](https://github.com/kszucs))
@@ -1508,7 +3922,7 @@
 - ARROW-12504: Buffer::from\_slice\_ref set correct capacity [\#18](https://github.com/apache/arrow-rs/pull/18) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
 - Add GitHub templates [\#17](https://github.com/apache/arrow-rs/pull/17) ([andygrove](https://github.com/andygrove))
 - ARROW-12493: Add support for writing dictionary arrays to CSV and JSON [\#16](https://github.com/apache/arrow-rs/pull/16) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
-- ARROW-12426: \[Rust\] Fix concatentation of arrow dictionaries [\#15](https://github.com/apache/arrow-rs/pull/15) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- ARROW-12426: \[Rust\] Fix concatenation of arrow dictionaries [\#15](https://github.com/apache/arrow-rs/pull/15) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
 - Update repository and homepage urls [\#14](https://github.com/apache/arrow-rs/pull/14) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Dandandan](https://github.com/Dandandan))
 - Added rebase-needed bot [\#13](https://github.com/apache/arrow-rs/pull/13) ([jorgecarleitao](https://github.com/jorgecarleitao))
 - Added Integration tests against arrow [\#10](https://github.com/apache/arrow-rs/pull/10) ([jorgecarleitao](https://github.com/jorgecarleitao))
@@ -1652,7 +4066,7 @@
 - Support sort [\#215](https://github.com/apache/arrow-rs/issues/215) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 - Support stable Rust [\#214](https://github.com/apache/arrow-rs/issues/214) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 - Remove Rust and point integration tests to arrow-rs repo [\#211](https://github.com/apache/arrow-rs/issues/211) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- ArrayData buffers are inconsistent accross implementations [\#207](https://github.com/apache/arrow-rs/issues/207)
+- ArrayData buffers are inconsistent across implementations [\#207](https://github.com/apache/arrow-rs/issues/207)
 - 3.0.1 patch release [\#204](https://github.com/apache/arrow-rs/issues/204)
 - Document patch release process [\#202](https://github.com/apache/arrow-rs/issues/202)
 - Simplify Offset [\#186](https://github.com/apache/arrow-rs/issues/186) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 87f67015f22e..4c173bfdeda0 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -19,156 +19,148 @@
 
 # Changelog
 
-## [20.0.0](https://github.com/apache/arrow-rs/tree/20.0.0) (2022-08-05)
+## [50.0.0](https://github.com/apache/arrow-rs/tree/50.0.0) (2024-01-08)
 
-[Full Changelog](https://github.com/apache/arrow-rs/compare/19.0.0...20.0.0)
+[Full Changelog](https://github.com/apache/arrow-rs/compare/49.0.0...50.0.0)
 
 **Breaking changes:**
 
-- Add more const evaluation for `GenericBinaryArray` and `GenericListArray`: add `PREFIX` and data type constructor [\#2327](https://github.com/apache/arrow-rs/pull/2327) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
-- Make FFI support optional, change APIs to be `safe` \(\#2302\) [\#2303](https://github.com/apache/arrow-rs/pull/2303) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
-- Remove `test_utils` from default features \(\#2298\) [\#2299](https://github.com/apache/arrow-rs/pull/2299) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
-- Rename `DataType::Decimal` to `DataType::Decimal128` [\#2229](https://github.com/apache/arrow-rs/pull/2229) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
-- Add `Decimal128Iter` and `Decimal256Iter` and do maximum precision/scale check [\#2140](https://github.com/apache/arrow-rs/pull/2140) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Make regexp\_match take scalar pattern and flag [\#5245](https://github.com/apache/arrow-rs/pull/5245) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Use Vec in ColumnReader \(\#5177\) [\#5193](https://github.com/apache/arrow-rs/pull/5193) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Remove SIMD Feature [\#5184](https://github.com/apache/arrow-rs/pull/5184) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Use Total Ordering for Aggregates and Refactor for Better Auto-Vectorization [\#5100](https://github.com/apache/arrow-rs/pull/5100) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jhorstmann](https://github.com/jhorstmann))
+- Allow the `zip` compute function to operator on `Scalar` values via `Datum` [\#5086](https://github.com/apache/arrow-rs/pull/5086) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Nathan-Fenner](https://github.com/Nathan-Fenner))
+- Improve C Data Interface and Add Integration Testing Entrypoints [\#5080](https://github.com/apache/arrow-rs/pull/5080) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([pitrou](https://github.com/pitrou))
+- Parquet: read/write f16 for Arrow [\#5003](https://github.com/apache/arrow-rs/pull/5003) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jefffrey](https://github.com/Jefffrey))
 
 **Implemented enhancements:**
 
-- Add the constant data type constructors for `ListArray` [\#2311](https://github.com/apache/arrow-rs/issues/2311) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Update `FlightSqlService` trait to pass session info along [\#2308](https://github.com/apache/arrow-rs/issues/2308) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
-- Optimize `take_bits` for non-null indices [\#2306](https://github.com/apache/arrow-rs/issues/2306) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Make FFI support optional via Feature Flag `ffi` [\#2302](https://github.com/apache/arrow-rs/issues/2302) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Mark `ffi::ArrowArray::try_new` is safe [\#2301](https://github.com/apache/arrow-rs/issues/2301) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Remove test\_utils from default arrow-rs features [\#2298](https://github.com/apache/arrow-rs/issues/2298) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Remove `JsonEqual` trait [\#2296](https://github.com/apache/arrow-rs/issues/2296) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Move `with_precision_and_scale` to `Decimal` array traits [\#2291](https://github.com/apache/arrow-rs/issues/2291) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Improve readability and maybe performance of string --\> numeric/time/date/timetamp cast kernels [\#2285](https://github.com/apache/arrow-rs/issues/2285) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Add vectorized unpacking for 8, 16, and 64 bit integers [\#2276](https://github.com/apache/arrow-rs/issues/2276) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- Use initial capacity for interner hashmap [\#2273](https://github.com/apache/arrow-rs/issues/2273) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
--  Impl FromIterator for Decimal256Array [\#2248](https://github.com/apache/arrow-rs/issues/2248) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Separate `ArrayReader::next_batch`with `ArrayReader::read_records` and `ArrayReader::consume_batch` [\#2236](https://github.com/apache/arrow-rs/issues/2236) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- Rename `DataType::Decimal` to `DataType::Decimal128` [\#2228](https://github.com/apache/arrow-rs/issues/2228) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Automatically Grow Parquet BitWriter Buffer [\#2226](https://github.com/apache/arrow-rs/issues/2226) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- Add `append_option` support to `Decimal128Builder` and `Decimal256Builder` [\#2224](https://github.com/apache/arrow-rs/issues/2224) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Split the `FixedSizeBinaryArray` and `FixedSizeListArray` from `array_binary.rs` and `array_list.rs` [\#2217](https://github.com/apache/arrow-rs/issues/2217) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Don't `Box` Values in `PrimitiveDictionaryBuilder` [\#2215](https://github.com/apache/arrow-rs/issues/2215) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Use BitChunks in equal\_bits [\#2186](https://github.com/apache/arrow-rs/issues/2186) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Implement `Hash` for `Schema` [\#2182](https://github.com/apache/arrow-rs/issues/2182) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- read decimal data type from parquet file with binary physical type [\#2159](https://github.com/apache/arrow-rs/issues/2159) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- The `GenericStringBuilder` should use `GenericBinaryBuilder` [\#2156](https://github.com/apache/arrow-rs/issues/2156) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Update Rust version to 1.62 [\#2143](https://github.com/apache/arrow-rs/issues/2143) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
-- Check precision and scale against maximum value when constructing `Decimal128` and `Decimal256` [\#2139](https://github.com/apache/arrow-rs/issues/2139) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Use `ArrayAccessor` in `Decimal128Iter` and `Decimal256Iter` [\#2138](https://github.com/apache/arrow-rs/issues/2138) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Use `ArrayAccessor` and `FromIterator` in Cast Kernels [\#2137](https://github.com/apache/arrow-rs/issues/2137) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Add `TypedDictionaryArray` for more ergonomic interaction with `DictionaryArray` [\#2136](https://github.com/apache/arrow-rs/issues/2136) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Use `ArrayAccessor` in Comparison Kernels [\#2135](https://github.com/apache/arrow-rs/issues/2135) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Support `peek_next_page()` and s`kip_next_page` in `InMemoryColumnChunkReader` [\#2129](https://github.com/apache/arrow-rs/issues/2129) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- Lazily materialize the null buffer builder for all array builders. [\#2125](https://github.com/apache/arrow-rs/issues/2125) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Do value validation for `Decimal256` [\#2112](https://github.com/apache/arrow-rs/issues/2112) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Support `skip_def_levels`  for `ColumnLevelDecoder` [\#2107](https://github.com/apache/arrow-rs/issues/2107) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- Add integration test for scan rows  with selection [\#2106](https://github.com/apache/arrow-rs/issues/2106) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- Support for casting from Utf8/String to `Time32` / `Time64` [\#2053](https://github.com/apache/arrow-rs/issues/2053) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Update prost and tonic related crates [\#2268](https://github.com/apache/arrow-rs/pull/2268) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([carols10cents](https://github.com/carols10cents))
+- Support get offsets or blocks info from arrow file.  [\#5252](https://github.com/apache/arrow-rs/issues/5252) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Make regexp\_match take scalar pattern and flag [\#5246](https://github.com/apache/arrow-rs/issues/5246) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Cannot access pen state website on arrow-row [\#5238](https://github.com/apache/arrow-rs/issues/5238) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- RecordBatch with\_schema's error message is hard to read [\#5227](https://github.com/apache/arrow-rs/issues/5227) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support cast between StructArray. [\#5219](https://github.com/apache/arrow-rs/issues/5219) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Remove nightly-only simd feature and related code in ArrowNumericType [\#5185](https://github.com/apache/arrow-rs/issues/5185) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Use Vec instead of Slice in ColumnReader [\#5177](https://github.com/apache/arrow-rs/issues/5177) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Request to Memmap Arrow IPC files on disk [\#5153](https://github.com/apache/arrow-rs/issues/5153) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- GenericColumnReader::read\_records Yields Truncated Records [\#5150](https://github.com/apache/arrow-rs/issues/5150) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Nested Schema Projection [\#5148](https://github.com/apache/arrow-rs/issues/5148) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support specifying `quote` and `escape` in Csv `WriterBuilder` [\#5146](https://github.com/apache/arrow-rs/issues/5146) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support casting of Float16 with other numeric types [\#5138](https://github.com/apache/arrow-rs/issues/5138) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Parquet: read parquet metadata with page index in async and with size hints [\#5129](https://github.com/apache/arrow-rs/issues/5129) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Cast from floating/timestamp to timestamp/floating [\#5122](https://github.com/apache/arrow-rs/issues/5122) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Support Casting List To/From LargeList in Cast Kernel [\#5113](https://github.com/apache/arrow-rs/issues/5113) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Expose a path for converting `bytes::Bytes` into `arrow_buffer::Buffer` without copy [\#5104](https://github.com/apache/arrow-rs/issues/5104) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- API inconsistency of ListBuilder make it hard to use as nested builder [\#5098](https://github.com/apache/arrow-rs/issues/5098) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Parquet: don't truncate min/max statistics for float16 and decimal when writing file [\#5075](https://github.com/apache/arrow-rs/issues/5075) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Parquet: derive boundary order when writing columns [\#5074](https://github.com/apache/arrow-rs/issues/5074) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Support new Arrow PyCapsule Interface for Python FFI [\#5067](https://github.com/apache/arrow-rs/issues/5067) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- `48.0.1 ` arrow patch release [\#5050](https://github.com/apache/arrow-rs/issues/5050) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Binary columns do not receive truncated statistics [\#5037](https://github.com/apache/arrow-rs/issues/5037) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Re-evaluate Explicit SIMD Aggregations [\#5032](https://github.com/apache/arrow-rs/issues/5032) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Min/Max Kernels Should Use Total Ordering [\#5031](https://github.com/apache/arrow-rs/issues/5031) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Allow `zip` compute kernel to take `Scalar` / `Datum`  [\#5011](https://github.com/apache/arrow-rs/issues/5011) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Add Float16/Half-float logical type to Parquet [\#4986](https://github.com/apache/arrow-rs/issues/4986) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- feat: cast \(Large\)List to FixedSizeList [\#5081](https://github.com/apache/arrow-rs/pull/5081) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([wjones127](https://github.com/wjones127))
+- Update Parquet Encoding Documentation [\#5051](https://github.com/apache/arrow-rs/issues/5051) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
 
 **Fixed bugs:**
 
-- temporal conversion functions cannot work on negative input properly [\#2325](https://github.com/apache/arrow-rs/issues/2325) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- IPC writer should truncate string array with all empty string [\#2312](https://github.com/apache/arrow-rs/issues/2312) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Error order for comparing `Decimal128` or `Decimal256` [\#2256](https://github.com/apache/arrow-rs/issues/2256) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Fix maximum and minimum for decimal values for precision greater than 38 [\#2246](https://github.com/apache/arrow-rs/issues/2246) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- `IntervalMonthDayNanoType::make_value()` does not match C implementation [\#2234](https://github.com/apache/arrow-rs/issues/2234) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- `FlightSqlService` trait does not allow `impl`s to do handshake [\#2210](https://github.com/apache/arrow-rs/issues/2210) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)]
-- `EnabledStatistics::None` not working [\#2185](https://github.com/apache/arrow-rs/issues/2185) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- Boolean ArrayData Equality Incorrect Slice Handling [\#2184](https://github.com/apache/arrow-rs/issues/2184) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-- Publicly export MapFieldNames [\#2118](https://github.com/apache/arrow-rs/issues/2118) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
-
-**Documentation updates:**
-
-- Update instructions on How to join the slack \#arrow-rust channel -- or maybe try to switch to discord?? [\#2192](https://github.com/apache/arrow-rs/issues/2192)
-- \[Minor\] Improve arrow and parquet READMEs, document parquet feature flags [\#2324](https://github.com/apache/arrow-rs/pull/2324) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- json schema inference can't handle null field turned into object field in subsequent rows [\#5215](https://github.com/apache/arrow-rs/issues/5215) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Invalid trailing content after `Z` in timezone is ignored [\#5182](https://github.com/apache/arrow-rs/issues/5182) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Take panics on a fixed size list array when given null indices [\#5169](https://github.com/apache/arrow-rs/issues/5169) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- EnabledStatistics::Page  does not take effect on ByteArrayEncoder [\#5162](https://github.com/apache/arrow-rs/issues/5162) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Parquet: ColumnOrder not being written when writing parquet files [\#5152](https://github.com/apache/arrow-rs/issues/5152) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Parquet: Interval columns shouldn't write min/max stats [\#5145](https://github.com/apache/arrow-rs/issues/5145) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+-  cast `Utf8` to decimal failure [\#5127](https://github.com/apache/arrow-rs/issues/5127) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- coerce\_primitive not honored when decoding from serde object [\#5095](https://github.com/apache/arrow-rs/issues/5095) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- Unsound MutableArrayData Constructor [\#5091](https://github.com/apache/arrow-rs/issues/5091) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
+- RowGroupReader.get\_row\_iter\(\) fails with Path ColumnPath not found [\#5064](https://github.com/apache/arrow-rs/issues/5064) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- cast format 'yyyymmdd'  to Date32 give a error [\#5044](https://github.com/apache/arrow-rs/issues/5044) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 
 **Performance improvements:**
 
-- Improve speed of writing string dictionaries to parquet by skipping a copy\(\#1764\)  [\#2322](https://github.com/apache/arrow-rs/pull/2322) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- ArrowArrayStreamReader imports FFI\_ArrowSchema on each iteration [\#5103](https://github.com/apache/arrow-rs/issues/5103) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)]
 
 **Closed issues:**
 
-- Fix wrong logic in calculate\_row\_count when skipping values [\#2328](https://github.com/apache/arrow-rs/issues/2328) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- Support filter for parquet data type [\#2126](https://github.com/apache/arrow-rs/issues/2126) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
-- Make skip value in ByteArrayDecoderDictionary avoid decoding [\#2088](https://github.com/apache/arrow-rs/issues/2088) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)]
+- Working example of list\_flights with ObjectStore [\#5116](https://github.com/apache/arrow-rs/issues/5116)
+- \(object\_store\) Error broken pipe on S3 multipart upload [\#5106](https://github.com/apache/arrow-rs/issues/5106)
 
 **Merged pull requests:**
 
-- fix: Fix skip error in calculate\_row\_count. [\#2329](https://github.com/apache/arrow-rs/pull/2329) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
-- temporal conversion functions should work on negative input properly [\#2326](https://github.com/apache/arrow-rs/pull/2326) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
-- Increase DeltaBitPackEncoder miniblock size to 64 for 64-bit integers  \(\#2282\) [\#2319](https://github.com/apache/arrow-rs/pull/2319) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
-- Remove JsonEqual [\#2317](https://github.com/apache/arrow-rs/pull/2317) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
-- fix: IPC writer should truncate string array with all empty string [\#2314](https://github.com/apache/arrow-rs/pull/2314) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([JasonLi-cn](https://github.com/JasonLi-cn))
-- Pass pull `Request<FlightDescriptor>` to `FlightSqlService` `impl`s  [\#2309](https://github.com/apache/arrow-rs/pull/2309) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([avantgardnerio](https://github.com/avantgardnerio))
-- Speedup take\_boolean / take\_bits for non-null indices \(~4 - 5x speedup\) [\#2307](https://github.com/apache/arrow-rs/pull/2307) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Dandandan](https://github.com/Dandandan))
-- Add typed dictionary \(\#2136\) [\#2297](https://github.com/apache/arrow-rs/pull/2297) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
-- \[Minor\] Improve types shown in cast error messages [\#2295](https://github.com/apache/arrow-rs/pull/2295) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
-- Move `with_precision_and_scale` to `BasicDecimalArray` trait [\#2292](https://github.com/apache/arrow-rs/pull/2292) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
-- Replace the `fn get_data_type` by `const DATA_TYPE` in BinaryArray and StringArray [\#2289](https://github.com/apache/arrow-rs/pull/2289) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
-- Clean up string casts and improve performance [\#2284](https://github.com/apache/arrow-rs/pull/2284) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
-- \[Minor\] Add tests for temporal cast error paths [\#2283](https://github.com/apache/arrow-rs/pull/2283) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
-- Add unpack8, unpack16, unpack64 \(\#2276\) ~10-50% faster [\#2278](https://github.com/apache/arrow-rs/pull/2278) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
-- Fix bugs in the `from_list` function. [\#2277](https://github.com/apache/arrow-rs/pull/2277) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
-- fix: use signed comparator to compare decimal128 and decimal256 [\#2275](https://github.com/apache/arrow-rs/pull/2275) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([liukun4515](https://github.com/liukun4515))
-- Use initial capacity for interner hashmap [\#2272](https://github.com/apache/arrow-rs/pull/2272) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Dandandan](https://github.com/Dandandan))
-- Remove fallibility from paruqet RleEncoder \(\#2226\) [\#2259](https://github.com/apache/arrow-rs/pull/2259) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
-- Fix escaped like wildcards in `like_utf8` / `nlike_utf8` kernels [\#2258](https://github.com/apache/arrow-rs/pull/2258) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([daniel-martinez-maqueda-sap](https://github.com/daniel-martinez-maqueda-sap))
-- Add tests for reading nested decimal arrays from parquet [\#2254](https://github.com/apache/arrow-rs/pull/2254) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
-- feat: Implement string cast operations for Time32 and Time64 [\#2251](https://github.com/apache/arrow-rs/pull/2251) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([stuartcarnie](https://github.com/stuartcarnie))
-- move `FixedSizeList` to `array_fixed_size_list.rs` [\#2250](https://github.com/apache/arrow-rs/pull/2250) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
-- Impl FromIterator for Decimal256Array [\#2247](https://github.com/apache/arrow-rs/pull/2247) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
-- Fix max and min value for decimal precision greater than 38 [\#2245](https://github.com/apache/arrow-rs/pull/2245) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
-- Make `Schema::fields` and `Schema::metadata` `pub` \(public\) [\#2239](https://github.com/apache/arrow-rs/pull/2239) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
-- \[Minor\] Improve Schema metadata mismatch error [\#2238](https://github.com/apache/arrow-rs/pull/2238) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
-- Separate ArrayReader::next\_batch with read\_records and consume\_batch [\#2237](https://github.com/apache/arrow-rs/pull/2237) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
-- Update `IntervalMonthDayNanoType::make_value()` to conform to specifications [\#2235](https://github.com/apache/arrow-rs/pull/2235) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([avantgardnerio](https://github.com/avantgardnerio))
-- Disable value validation for Decimal256 case [\#2232](https://github.com/apache/arrow-rs/pull/2232) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
-- Automatically grow parquet BitWriter \(\#2226\) \(~10% faster\) [\#2231](https://github.com/apache/arrow-rs/pull/2231) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
-- Only trigger `arrow` CI on changes to arrow [\#2227](https://github.com/apache/arrow-rs/pull/2227) ([alamb](https://github.com/alamb))
-- Add append\_option support to decimal builders [\#2225](https://github.com/apache/arrow-rs/pull/2225) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([bphillips-exos](https://github.com/bphillips-exos))
-- Optimized writing of byte array to parquet \(\#1764\) \(2x faster\) [\#2221](https://github.com/apache/arrow-rs/pull/2221) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
-- Increase test coverage of ArrowWriter [\#2220](https://github.com/apache/arrow-rs/pull/2220) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
-- Update instructions on how to join the Slack channel [\#2219](https://github.com/apache/arrow-rs/pull/2219) ([HaoYang670](https://github.com/HaoYang670))
-- Move `FixedSizeBinaryArray` to `array_fixed_size_binary.rs` [\#2218](https://github.com/apache/arrow-rs/pull/2218) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
-- Avoid boxing in PrimitiveDictionaryBuilder [\#2216](https://github.com/apache/arrow-rs/pull/2216) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
-- remove redundant CI benchmark check, cleanups [\#2212](https://github.com/apache/arrow-rs/pull/2212) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([alamb](https://github.com/alamb))
-- Update `FlightSqlService` trait to proxy handshake [\#2211](https://github.com/apache/arrow-rs/pull/2211) [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([avantgardnerio](https://github.com/avantgardnerio))
-- parquet: export json api with `serde_json` feature name [\#2209](https://github.com/apache/arrow-rs/pull/2209) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([flisky](https://github.com/flisky))
-- Cleanup record skipping logic and tests \(\#2158\) [\#2199](https://github.com/apache/arrow-rs/pull/2199) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
-- Use BitChunks in equal\_bits [\#2194](https://github.com/apache/arrow-rs/pull/2194) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
-- Fix disabling parquet statistics \(\#2185\) [\#2191](https://github.com/apache/arrow-rs/pull/2191) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
-- Change CI names to match crate names [\#2189](https://github.com/apache/arrow-rs/pull/2189) ([alamb](https://github.com/alamb))
-- Fix offset handling in boolean\_equal \(\#2184\) [\#2187](https://github.com/apache/arrow-rs/pull/2187) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
-- Implement `Hash` for `Schema` [\#2183](https://github.com/apache/arrow-rs/pull/2183) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([crepererum](https://github.com/crepererum))
-- Let the `StringBuilder` use `BinaryBuilder` [\#2181](https://github.com/apache/arrow-rs/pull/2181) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
-- Use ArrayAccessor and FromIterator in Cast Kernels [\#2169](https://github.com/apache/arrow-rs/pull/2169) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
-- Split most arrow specific CI checks into their own workflows \(reduce common CI time to 21 minutes\) [\#2168](https://github.com/apache/arrow-rs/pull/2168) ([alamb](https://github.com/alamb))
-- Remove another attempt to cache target directory in action.yaml [\#2167](https://github.com/apache/arrow-rs/pull/2167) ([alamb](https://github.com/alamb))
-- Run actions on push to master, pull requests [\#2166](https://github.com/apache/arrow-rs/pull/2166) ([alamb](https://github.com/alamb))
-- Break parquet\_derive and arrow\_flight tests into their own workflows [\#2165](https://github.com/apache/arrow-rs/pull/2165) ([alamb](https://github.com/alamb))
-- \[minor\] use type aliases refine code. [\#2161](https://github.com/apache/arrow-rs/pull/2161) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
-- parquet reader: Support reading decimals from parquet `BYTE_ARRAY` type [\#2160](https://github.com/apache/arrow-rs/pull/2160) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([liukun4515](https://github.com/liukun4515))
-- Add integration test for scan rows with selection [\#2158](https://github.com/apache/arrow-rs/pull/2158) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
-- Use ArrayAccessor in Comparison Kernels [\#2157](https://github.com/apache/arrow-rs/pull/2157) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
-- Implement `peek\_next\_page` and `skip\_next\_page` for `InMemoryColumnCh… [\#2155](https://github.com/apache/arrow-rs/pull/2155) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
-- Avoid decoding unneeded values in ByteArrayDecoderDictionary [\#2154](https://github.com/apache/arrow-rs/pull/2154) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([thinkharderdev](https://github.com/thinkharderdev))
-- Only run integration tests when `arrow` changes [\#2152](https://github.com/apache/arrow-rs/pull/2152) ([alamb](https://github.com/alamb))
-- Break out docs CI job to its own github action [\#2151](https://github.com/apache/arrow-rs/pull/2151) ([alamb](https://github.com/alamb))
-- Do not pretend to cache rust build artifacts, speed up CI by ~20% [\#2150](https://github.com/apache/arrow-rs/pull/2150) ([alamb](https://github.com/alamb))
-- Update rust version to 1.62 [\#2144](https://github.com/apache/arrow-rs/pull/2144) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([Ted-Jiang](https://github.com/Ted-Jiang))
-- Make MapFieldNames public \(\#2118\) [\#2134](https://github.com/apache/arrow-rs/pull/2134) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
-- Add ArrayAccessor trait, remove duplication in array iterators \(\#1948\) [\#2133](https://github.com/apache/arrow-rs/pull/2133) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
-- Lazily materialize the null buffer builder for all array builders. [\#2127](https://github.com/apache/arrow-rs/pull/2127) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([HaoYang670](https://github.com/HaoYang670))
-- Faster parquet DictEncoder \(~20%\) [\#2123](https://github.com/apache/arrow-rs/pull/2123) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
-- Add validation for Decimal256 [\#2113](https://github.com/apache/arrow-rs/pull/2113) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
-- Support skip\_def\_levels for ColumnLevelDecoder [\#2111](https://github.com/apache/arrow-rs/pull/2111) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Ted-Jiang](https://github.com/Ted-Jiang))
-- Donate `object_store` code from object\_store\_rs to arrow-rs [\#2081](https://github.com/apache/arrow-rs/pull/2081) ([alamb](https://github.com/alamb))
-- Improve `validate_utf8` performance [\#2048](https://github.com/apache/arrow-rs/pull/2048) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tfeda](https://github.com/tfeda))
-
-
-
-\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*
+- Update parquet object\_store dependency to 0.9.0 [\#5290](https://github.com/apache/arrow-rs/pull/5290) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Update proc-macro2 requirement from =1.0.75 to =1.0.76 [\#5289](https://github.com/apache/arrow-rs/pull/5289) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Enable JS tests again [\#5287](https://github.com/apache/arrow-rs/pull/5287) ([domoritz](https://github.com/domoritz))
+- Update proc-macro2 requirement from =1.0.74 to =1.0.75 [\#5279](https://github.com/apache/arrow-rs/pull/5279) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Update proc-macro2 requirement from =1.0.73 to =1.0.74 [\#5271](https://github.com/apache/arrow-rs/pull/5271) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Update proc-macro2 requirement from =1.0.71 to =1.0.73 [\#5265](https://github.com/apache/arrow-rs/pull/5265) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Update docs for datatypes [\#5260](https://github.com/apache/arrow-rs/pull/5260) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Don't suppress errors in ArrowArrayStreamReader [\#5256](https://github.com/apache/arrow-rs/pull/5256) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Add IPC FileDecoder [\#5249](https://github.com/apache/arrow-rs/pull/5249) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- optimize the next function of ArrowArrayStreamReader [\#5248](https://github.com/apache/arrow-rs/pull/5248) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([doki23](https://github.com/doki23))
+- ci: Fail Miri CI on first failure [\#5243](https://github.com/apache/arrow-rs/pull/5243) ([Jefffrey](https://github.com/Jefffrey))
+- Remove 'unwrap' from Result [\#5241](https://github.com/apache/arrow-rs/pull/5241) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([zeevm](https://github.com/zeevm))
+- Update arrow-row docs URL [\#5239](https://github.com/apache/arrow-rs/pull/5239) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([thomas-k-cameron](https://github.com/thomas-k-cameron))
+- Improve regexp kernels performance by avoiding cloning Regex [\#5235](https://github.com/apache/arrow-rs/pull/5235) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Update proc-macro2 requirement from =1.0.70 to =1.0.71 [\#5231](https://github.com/apache/arrow-rs/pull/5231) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Minor: Improve comments and errors for ArrowPredicate [\#5230](https://github.com/apache/arrow-rs/pull/5230) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([alamb](https://github.com/alamb))
+- Bump actions/upload-pages-artifact from 2 to 3 [\#5229](https://github.com/apache/arrow-rs/pull/5229) ([dependabot[bot]](https://github.com/apps/dependabot))
+- make with\_schema's error more readable [\#5228](https://github.com/apache/arrow-rs/pull/5228) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([shuoli84](https://github.com/shuoli84))
+- Use `try_new` when casting between structs to propagate error [\#5226](https://github.com/apache/arrow-rs/pull/5226) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- feat\(cast\): support cast between struct [\#5221](https://github.com/apache/arrow-rs/pull/5221) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([my-vegetable-has-exploded](https://github.com/my-vegetable-has-exploded))
+- Add `entries` to `MapBuilder` to return both key and value array builders [\#5218](https://github.com/apache/arrow-rs/pull/5218) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- fix\(json\): fix inferring object after field was null [\#5216](https://github.com/apache/arrow-rs/pull/5216) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kskalski](https://github.com/kskalski))
+- Support MapBuilder in make\_builder [\#5210](https://github.com/apache/arrow-rs/pull/5210) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- impl `From<OffsetBuffer<T>>` for `ScalarBuffer<T>` [\#5203](https://github.com/apache/arrow-rs/pull/5203) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- impl `From<BufferBuilder<T>>` for `Buffer` [\#5202](https://github.com/apache/arrow-rs/pull/5202) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- impl `From<BufferBuilder<T>>` for `ScalarBuffer<T>` [\#5201](https://github.com/apache/arrow-rs/pull/5201) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- feat: Support  quote and escape in Csv WriterBuilder [\#5196](https://github.com/apache/arrow-rs/pull/5196) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([my-vegetable-has-exploded](https://github.com/my-vegetable-has-exploded))
+- chore: simplify cast\_string\_to\_interval [\#5195](https://github.com/apache/arrow-rs/pull/5195) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jackwener](https://github.com/jackwener))
+- Clarify interval comparison behavior with documentation and tests [\#5192](https://github.com/apache/arrow-rs/pull/5192) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([alamb](https://github.com/alamb))
+- Add `BooleanArray::into_parts` method [\#5191](https://github.com/apache/arrow-rs/pull/5191) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- Fix deprecated note for `Buffer::from_raw_parts` [\#5190](https://github.com/apache/arrow-rs/pull/5190) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([mbrobbel](https://github.com/mbrobbel))
+- Fix: Ensure Timestamp Parsing Rejects Characters After 'Z [\#5189](https://github.com/apache/arrow-rs/pull/5189) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([razeghi71](https://github.com/razeghi71))
+- Simplify parquet statistics generation [\#5183](https://github.com/apache/arrow-rs/pull/5183) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Parquet: Ensure page statistics are written only when conifgured from the Arrow Writer [\#5181](https://github.com/apache/arrow-rs/pull/5181) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([AdamGS](https://github.com/AdamGS))
+- Blockwise IO in IPC FileReader \(\#5153\) [\#5179](https://github.com/apache/arrow-rs/pull/5179) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Replace ScalarBuffer in Parquet with Vec \(\#1849\) \(\#5177\) [\#5178](https://github.com/apache/arrow-rs/pull/5178) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
+- Bump actions/setup-python from 4 to 5 [\#5175](https://github.com/apache/arrow-rs/pull/5175) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add `LargeListBuilder` to `make_builder` [\#5171](https://github.com/apache/arrow-rs/pull/5171) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- fix: ensure take\_fixed\_size\_list can handle null indices [\#5170](https://github.com/apache/arrow-rs/pull/5170) ([westonpace](https://github.com/westonpace))
+- Removing redundant `as casts` in parquet [\#5168](https://github.com/apache/arrow-rs/pull/5168) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([psvri](https://github.com/psvri))
+- Bump actions/labeler from 4.3.0 to 5.0.0 [\#5167](https://github.com/apache/arrow-rs/pull/5167) ([dependabot[bot]](https://github.com/apps/dependabot))
+- improve: make RunArray displayable [\#5166](https://github.com/apache/arrow-rs/pull/5166) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([yukkit](https://github.com/yukkit))
+- ci: Add cargo audit CI action [\#5160](https://github.com/apache/arrow-rs/pull/5160) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Parquet: write column\_orders in FileMetaData [\#5158](https://github.com/apache/arrow-rs/pull/5158) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jefffrey](https://github.com/Jefffrey))
+- Adding `is_null` datatype shortcut method [\#5157](https://github.com/apache/arrow-rs/pull/5157) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([comphead](https://github.com/comphead))
+- Parquet: don't truncate f16/decimal min/max stats [\#5154](https://github.com/apache/arrow-rs/pull/5154) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jefffrey](https://github.com/Jefffrey))
+- Support nested schema projection \(\#5148\) [\#5149](https://github.com/apache/arrow-rs/pull/5149) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Parquet: omit min/max for interval columns when writing stats [\#5147](https://github.com/apache/arrow-rs/pull/5147) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jefffrey](https://github.com/Jefffrey))
+- Deprecate Fields::remove and Schema::remove [\#5144](https://github.com/apache/arrow-rs/pull/5144) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Support casting of Float16 with other numeric types [\#5139](https://github.com/apache/arrow-rs/pull/5139) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Parquet: Make `MetadataLoader` public [\#5137](https://github.com/apache/arrow-rs/pull/5137) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([AdamGS](https://github.com/AdamGS))
+- Add FileReaderBuilder for arrow-ipc to allow reading large no. of column files [\#5136](https://github.com/apache/arrow-rs/pull/5136) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Parquet: clear metadata and project fields of ParquetRecordBatchStream::schema [\#5135](https://github.com/apache/arrow-rs/pull/5135) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jefffrey](https://github.com/Jefffrey))
+- JSON: write struct array nulls as null [\#5133](https://github.com/apache/arrow-rs/pull/5133) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Update proc-macro2 requirement from =1.0.69 to =1.0.70 [\#5131](https://github.com/apache/arrow-rs/pull/5131) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Fix negative decimal string [\#5128](https://github.com/apache/arrow-rs/pull/5128) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Cleanup list casting and support nested lists \(\#5113\) [\#5124](https://github.com/apache/arrow-rs/pull/5124) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Cast from numeric/timestamp to timestamp/numeric [\#5123](https://github.com/apache/arrow-rs/pull/5123) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Improve cast docs [\#5114](https://github.com/apache/arrow-rs/pull/5114) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update prost-build requirement from =0.12.2 to =0.12.3 [\#5112](https://github.com/apache/arrow-rs/pull/5112) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Parquet: derive boundary order when writing [\#5110](https://github.com/apache/arrow-rs/pull/5110) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jefffrey](https://github.com/Jefffrey))
+- Implementing `ArrayBuilder` for `Box<dyn ArrayBuilder>` [\#5109](https://github.com/apache/arrow-rs/pull/5109) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([viirya](https://github.com/viirya))
+- Fix 'ColumnPath not found' error reading Parquet files with nested REPEATED fields [\#5102](https://github.com/apache/arrow-rs/pull/5102) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([mmaitre314](https://github.com/mmaitre314))
+- fix: coerce\_primitive for serde decoded data [\#5101](https://github.com/apache/arrow-rs/pull/5101) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([fansehep](https://github.com/fansehep))
+- Extend aggregation benchmarks [\#5096](https://github.com/apache/arrow-rs/pull/5096) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([jhorstmann](https://github.com/jhorstmann))
+- Expand parquet crate overview doc [\#5093](https://github.com/apache/arrow-rs/pull/5093) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([mmaitre314](https://github.com/mmaitre314))
+- Ensure arrays passed to MutableArrayData have same type \(\#5091\) [\#5092](https://github.com/apache/arrow-rs/pull/5092) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- Update prost-build requirement from =0.12.1 to =0.12.2 [\#5088](https://github.com/apache/arrow-rs/pull/5088) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] [[arrow-flight](https://github.com/apache/arrow-rs/labels/arrow-flight)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add FFI from\_raw [\#5082](https://github.com/apache/arrow-rs/pull/5082) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([tustvold](https://github.com/tustvold))
+- \[fix \#5044\] Support converting 'yyyymmdd' format to date [\#5078](https://github.com/apache/arrow-rs/pull/5078) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Tangruilin](https://github.com/Tangruilin))
+- Enable truncation of binary statistics columns [\#5076](https://github.com/apache/arrow-rs/pull/5076) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([emcake](https://github.com/emcake))
+- IPC writer truncated sliced list/map values [\#5071](https://github.com/apache/arrow-rs/pull/5071) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([Jefffrey](https://github.com/Jefffrey))
+- Implement Arrow PyCapsule Interface [\#5070](https://github.com/apache/arrow-rs/pull/5070) [[arrow](https://github.com/apache/arrow-rs/labels/arrow)] ([kylebarron](https://github.com/kylebarron))
+- Remove ByteBufferPtr and replace with Bytes [\#5055](https://github.com/apache/arrow-rs/pull/5055) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([Jefffrey](https://github.com/Jefffrey))
+- Support multiple GZip members in parquet page [\#4951](https://github.com/apache/arrow-rs/pull/4951) [[parquet](https://github.com/apache/arrow-rs/labels/parquet)] ([tustvold](https://github.com/tustvold))
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 4e4c53e5e2bd..9614ed2e5688 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -78,7 +78,7 @@ git submodule update --init
 
 This populates data in two git submodules:
 
-- `../parquet_testing/data` (sourced from https://github.com/apache/parquet-testing.git)
+- `../parquet-testing/data` (sourced from https://github.com/apache/parquet-testing.git)
 - `../testing` (sourced from https://github.com/apache/arrow-testing)
 
 By default, `cargo test` will look for these directories at their
@@ -150,7 +150,7 @@ If the file already exists, to avoid mistakenly **overriding**, you MAY have to
 the link source or file content. Else if not exist, let's safely soft link [pre-commit.sh](pre-commit.sh) as file `.git/hooks/pre-commit`:
 
 ```bash
-ln -s  ../../rust/pre-commit.sh .git/hooks/pre-commit
+ln -s  ../../pre-commit.sh .git/hooks/pre-commit
 ```
 
 If sometimes you want to commit without checking, just run `git commit` with `--no-verify`:
diff --git a/Cargo.toml b/Cargo.toml
index 9bf55c0f2360..bbbf907ba7f0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -16,15 +16,32 @@
 # under the License.
 
 [workspace]
+
 members = [
-        "arrow",
-        "parquet",
-        "parquet_derive",
-        "parquet_derive_test",
-        "arrow-flight",
-        "integration-testing",
-        "object_store",
+    "arrow",
+    "arrow-arith",
+    "arrow-array",
+    "arrow-avro",
+    "arrow-buffer",
+    "arrow-cast",
+    "arrow-csv",
+    "arrow-data",
+    "arrow-flight",
+    "arrow-flight/gen",
+    "arrow-integration-test",
+    "arrow-integration-testing",
+    "arrow-ipc",
+    "arrow-json",
+    "arrow-ord",
+    "arrow-row",
+    "arrow-schema",
+    "arrow-select",
+    "arrow-string",
+    "parquet",
+    "parquet_derive",
+    "parquet_derive_test",
 ]
+
 # Enable the version 2 feature resolver, which avoids unifying features for targets that are not being built
 #
 # Critically this prevents dev-dependencies from enabling features even when not building a target that
@@ -35,7 +52,45 @@ members = [
 #
 resolver = "2"
 
-# this package is excluded because it requires different compilation flags, thereby significantly changing
-# how it is compiled within the workspace, causing the whole workspace to be compiled from scratch
-# this way, this is a stand-alone package that compiles independently of the others.
-exclude = ["arrow-pyarrow-integration-testing"]
+exclude = [
+    # arrow-pyarrow-integration-testing is excluded because it requires different compilation flags, thereby
+    # significantly changing how it is compiled within the workspace, causing the whole workspace to be compiled from
+    # scratch this way, this is a stand-alone package that compiles independently of the others.
+    "arrow-pyarrow-integration-testing",
+    # object_store is excluded because it follows a separate release cycle from the other arrow crates
+    "object_store"
+]
+
+[workspace.package]
+version = "50.0.0"
+homepage = "https://github.com/apache/arrow-rs"
+repository = "https://github.com/apache/arrow-rs"
+authors = ["Apache Arrow <dev@arrow.apache.org>"]
+license = "Apache-2.0"
+keywords = ["arrow"]
+include = [
+    "benches/*.rs",
+    "src/**/*.rs",
+    "Cargo.toml",
+]
+edition = "2021"
+rust-version = "1.62"
+
+[workspace.dependencies]
+arrow = { version = "50.0.0", path = "./arrow", default-features = false }
+arrow-arith = { version = "50.0.0", path = "./arrow-arith" }
+arrow-array = { version = "50.0.0", path = "./arrow-array" }
+arrow-buffer = { version = "50.0.0", path = "./arrow-buffer" }
+arrow-cast = { version = "50.0.0", path = "./arrow-cast" }
+arrow-csv = { version = "50.0.0", path = "./arrow-csv" }
+arrow-data = { version = "50.0.0", path = "./arrow-data" }
+arrow-ipc = { version = "50.0.0", path = "./arrow-ipc" }
+arrow-json = { version = "50.0.0", path = "./arrow-json" }
+arrow-ord = { version = "50.0.0", path = "./arrow-ord" }
+arrow-row = { version = "50.0.0", path = "./arrow-row" }
+arrow-schema = { version = "50.0.0", path = "./arrow-schema" }
+arrow-select = { version = "50.0.0", path = "./arrow-select" }
+arrow-string = { version = "50.0.0", path = "./arrow-string" }
+parquet = { version = "50.0.0", path = "./parquet", default-features = false }
+
+chrono = { version = "0.4.34", default-features = false, features = ["clock"] }
diff --git a/LICENSE.txt b/LICENSE.txt
index 4cec07fd0c99..d74c6b599d2a 100644
--- a/LICENSE.txt
+++ b/LICENSE.txt
@@ -201,674 +201,6 @@
    See the License for the specific language governing permissions and
    limitations under the License.
 
---------------------------------------------------------------------------------
-
-src/plasma/fling.cc and src/plasma/fling.h: Apache 2.0
-
-Copyright 2013 Sharvil Nanavati
-
-Licensed 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.
-
---------------------------------------------------------------------------------
-
-src/plasma/thirdparty/ae: Modified / 3-Clause BSD
-
-Copyright (c) 2006-2010, Salvatore Sanfilippo <antirez at gmail dot com>
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
- * Redistributions of source code must retain the above copyright notice,
-   this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
- * Neither the name of Redis nor the names of its contributors may be used
-   to endorse or promote products derived from this software without
-   specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
-LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
-CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
-SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
-INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
-CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-src/plasma/thirdparty/dlmalloc.c: CC0
-
-This is a version (aka dlmalloc) of malloc/free/realloc written by
-Doug Lea and released to the public domain, as explained at
-http://creativecommons.org/publicdomain/zero/1.0/ Send questions,
-comments, complaints, performance data, etc to dl@cs.oswego.edu
-
---------------------------------------------------------------------------------
-
-src/plasma/common.cc (some portions)
-
-Copyright (c) Austin Appleby (aappleby (AT) gmail)
-
-Some portions of this file are derived from code in the MurmurHash project
-
-All code is released to the public domain. For business purposes, Murmurhash is
-under the MIT license.
-
-https://sites.google.com/site/murmurhash/
-
---------------------------------------------------------------------------------
-
-src/arrow/util (some portions): Apache 2.0, and 3-clause BSD
-
-Some portions of this module are derived from code in the Chromium project,
-copyright (c) Google inc and (c) The Chromium Authors and licensed under the
-Apache 2.0 License or the under the 3-clause BSD license:
-
-  Copyright (c) 2013 The Chromium Authors. All rights reserved.
-
-  Redistribution and use in source and binary forms, with or without
-  modification, are permitted provided that the following conditions are
-  met:
-
-     * Redistributions of source code must retain the above copyright
-  notice, this list of conditions and the following disclaimer.
-     * Redistributions in binary form must reproduce the above
-  copyright notice, this list of conditions and the following disclaimer
-  in the documentation and/or other materials provided with the
-  distribution.
-     * Neither the name of Google Inc. nor the names of its
-  contributors may be used to endorse or promote products derived from
-  this software without specific prior written permission.
-
-  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-  "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-  LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-  A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-  OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-  SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-  DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-  THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-  (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-  OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-This project includes code from Daniel Lemire's FrameOfReference project.
-
-https://github.com/lemire/FrameOfReference/blob/6ccaf9e97160f9a3b299e23a8ef739e711ef0c71/src/bpacking.cpp
-
-Copyright: 2013 Daniel Lemire
-Home page: http://lemire.me/en/
-Project page: https://github.com/lemire/FrameOfReference
-License: Apache License Version 2.0 http://www.apache.org/licenses/LICENSE-2.0
-
---------------------------------------------------------------------------------
-
-This project includes code from the TensorFlow project
-
-Copyright 2015 The TensorFlow Authors. All Rights Reserved.
-
-Licensed 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.
-
---------------------------------------------------------------------------------
-
-This project includes code from the NumPy project.
-
-https://github.com/numpy/numpy/blob/e1f191c46f2eebd6cb892a4bfe14d9dd43a06c4e/numpy/core/src/multiarray/multiarraymodule.c#L2910
-
-https://github.com/numpy/numpy/blob/68fd82271b9ea5a9e50d4e761061dfcca851382a/numpy/core/src/multiarray/datetime.c
-
-Copyright (c) 2005-2017, NumPy Developers.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-       notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-       copyright notice, this list of conditions and the following
-       disclaimer in the documentation and/or other materials provided
-       with the distribution.
-
-    * Neither the name of the NumPy Developers nor the names of any
-       contributors may be used to endorse or promote products derived
-       from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-This project includes code from the Boost project
-
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
---------------------------------------------------------------------------------
-
-This project includes code from the FlatBuffers project
-
-Copyright 2014 Google Inc.
-
-Licensed 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.
-
---------------------------------------------------------------------------------
-
-This project includes code from the tslib project
-
-Copyright 2015 Microsoft Corporation. All rights reserved.
-
-Licensed 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.
-
---------------------------------------------------------------------------------
-
-This project includes code from the jemalloc project
-
-https://github.com/jemalloc/jemalloc
-
-Copyright (C) 2002-2017 Jason Evans <jasone@canonware.com>.
-All rights reserved.
-Copyright (C) 2007-2012 Mozilla Foundation.  All rights reserved.
-Copyright (C) 2009-2017 Facebook, Inc.  All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-1. Redistributions of source code must retain the above copyright notice(s),
-   this list of conditions and the following disclaimer.
-2. Redistributions in binary form must reproduce the above copyright notice(s),
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) ``AS IS'' AND ANY EXPRESS
-OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
-MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO
-EVENT SHALL THE COPYRIGHT HOLDER(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
-PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
-LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE
-OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
-ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
---------------------------------------------------------------------------------
-
-This project includes code from the Go project, BSD 3-clause license + PATENTS
-weak patent termination clause
-(https://github.com/golang/go/blob/master/PATENTS).
-
-Copyright (c) 2009 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-This project includes code from the hs2client
-
-https://github.com/cloudera/hs2client
-
-Copyright 2016 Cloudera Inc.
-
-Licensed 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.
-
---------------------------------------------------------------------------------
-
-The script ci/scripts/util_wait_for_it.sh has the following license
-
-Copyright (c) 2016 Giles Hall
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
---------------------------------------------------------------------------------
-
-The script r/configure has the following license (MIT)
-
-Copyright (c) 2017, Jeroen Ooms and Jim Hester
-
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
---------------------------------------------------------------------------------
-
-cpp/src/arrow/util/logging.cc, cpp/src/arrow/util/logging.h and
-cpp/src/arrow/util/logging-test.cc are adapted from
-Ray Project (https://github.com/ray-project/ray) (Apache 2.0).
-
-Copyright (c) 2016 Ray Project (https://github.com/ray-project/ray)
-
-Licensed 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.
-
---------------------------------------------------------------------------------
-The files cpp/src/arrow/vendored/datetime/date.h, cpp/src/arrow/vendored/datetime/tz.h,
-cpp/src/arrow/vendored/datetime/tz_private.h, cpp/src/arrow/vendored/datetime/ios.h,
-cpp/src/arrow/vendored/datetime/ios.mm,
-cpp/src/arrow/vendored/datetime/tz.cpp are adapted from
-Howard Hinnant's date library (https://github.com/HowardHinnant/date)
-It is licensed under MIT license.
-
-The MIT License (MIT)
-Copyright (c) 2015, 2016, 2017 Howard Hinnant
-Copyright (c) 2016 Adrian Colomitchi
-Copyright (c) 2017 Florian Dang
-Copyright (c) 2017 Paul Thompson
-Copyright (c) 2018 Tomasz Kamiński
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
---------------------------------------------------------------------------------
-
-The file cpp/src/arrow/util/utf8.h includes code adapted from the page
-  https://bjoern.hoehrmann.de/utf-8/decoder/dfa/
-with the following license (MIT)
-
-Copyright (c) 2008-2009 Bjoern Hoehrmann <bjoern@hoehrmann.de>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
---------------------------------------------------------------------------------
-
-The file cpp/src/arrow/vendored/string_view.hpp has the following license
-
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
---------------------------------------------------------------------------------
-
-The files in cpp/src/arrow/vendored/xxhash/ have the following license
-(BSD 2-Clause License)
-
-xxHash Library
-Copyright (c) 2012-2014, Yann Collet
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice, this
-  list of conditions and the following disclaimer in the documentation and/or
-  other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-You can contact the author at :
-- xxHash homepage: http://www.xxhash.com
-- xxHash source repository : https://github.com/Cyan4973/xxHash
-
---------------------------------------------------------------------------------
-
-The files in cpp/src/arrow/vendored/double-conversion/ have the following license
-(BSD 3-Clause License)
-
-Copyright 2006-2011, the V8 project authors. All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-    * Neither the name of Google Inc. nor the names of its
-      contributors may be used to endorse or promote products derived
-      from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-The files in cpp/src/arrow/vendored/uriparser/ have the following license
-(BSD 3-Clause License)
-
-uriparser - RFC 3986 URI parsing library
-
-Copyright (C) 2007, Weijia Song <songweijia@gmail.com>
-Copyright (C) 2007, Sebastian Pipping <sebastian@pipping.org>
-All rights reserved.
-
-Redistribution  and use in source and binary forms, with or without
-modification,  are permitted provided that the following conditions
-are met:
-
-    * Redistributions   of  source  code  must  retain  the   above
-      copyright  notice, this list of conditions and the  following
-      disclaimer.
-
-    * Redistributions  in  binary  form must  reproduce  the  above
-      copyright  notice, this list of conditions and the  following
-      disclaimer   in  the  documentation  and/or  other  materials
-      provided with the distribution.
-
-    * Neither  the name of the <ORGANIZATION> nor the names of  its
-      contributors  may  be  used to endorse  or  promote  products
-      derived  from  this software without specific  prior  written
-      permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS  IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT  NOT
-LIMITED  TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND  FITNESS
-FOR  A  PARTICULAR  PURPOSE ARE DISCLAIMED. IN NO EVENT  SHALL  THE
-COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-INCIDENTAL,    SPECIAL,   EXEMPLARY,   OR   CONSEQUENTIAL   DAMAGES
-(INCLUDING,  BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES;  LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
-HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
-STRICT  LIABILITY,  OR  TORT (INCLUDING  NEGLIGENCE  OR  OTHERWISE)
-ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
-OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-The files under dev/tasks/conda-recipes have the following license
-
-BSD 3-clause license
-Copyright (c) 2015-2018, conda-forge
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-3. Neither the name of the copyright holder nor the names of its contributors
-   may be used to endorse or promote products derived from this software without
-   specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
-TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
-THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-The files in cpp/src/arrow/vendored/utfcpp/ have the following license
-
-Copyright 2006-2018 Nemanja Trifunovic
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
---------------------------------------------------------------------------------
-
-This project includes code from Apache Kudu.
-
- * cpp/cmake_modules/CompilerInfo.cmake is based on Kudu's cmake_modules/CompilerInfo.cmake
-
-Copyright: 2016 The Apache Software Foundation.
-Home page: https://kudu.apache.org/
-License: http://www.apache.org/licenses/LICENSE-2.0
-
---------------------------------------------------------------------------------
-
-This project includes code from Apache Impala (incubating), formerly
-Impala. The Impala code and rights were donated to the ASF as part of the
-Incubator process after the initial code imports into Apache Parquet.
-
-Copyright: 2012 Cloudera, Inc.
-Copyright: 2016 The Apache Software Foundation.
-Home page: http://impala.apache.org/
-License: http://www.apache.org/licenses/LICENSE-2.0
-
---------------------------------------------------------------------------------
 
 This project includes code from Apache Aurora.
 
@@ -878,1343 +210,3 @@ This project includes code from Apache Aurora.
 Copyright: 2016 The Apache Software Foundation.
 Home page: https://aurora.apache.org/
 License: http://www.apache.org/licenses/LICENSE-2.0
-
---------------------------------------------------------------------------------
-
-This project includes code from the Google styleguide.
-
-* cpp/build-support/cpplint.py is based on the scripts from the Google styleguide.
-
-Copyright: 2009 Google Inc. All rights reserved.
-Homepage: https://github.com/google/styleguide
-License: 3-clause BSD
-
---------------------------------------------------------------------------------
-
-This project includes code from Snappy.
-
-* cpp/cmake_modules/{SnappyCMakeLists.txt,SnappyConfig.h} are based on code
-  from Google's Snappy project.
-
-Copyright: 2009 Google Inc. All rights reserved.
-Homepage: https://github.com/google/snappy
-License: 3-clause BSD
-
---------------------------------------------------------------------------------
-
-This project includes code from the manylinux project.
-
-* python/manylinux1/scripts/{build_python.sh,python-tag-abi-tag.py,
-  requirements.txt} are based on code from the manylinux project.
-
-Copyright: 2016 manylinux
-Homepage: https://github.com/pypa/manylinux
-License: The MIT License (MIT)
-
---------------------------------------------------------------------------------
-
-This project includes code from the cymove project:
-
-* python/pyarrow/includes/common.pxd includes code from the cymove project
-
-The MIT License (MIT)
-Copyright (c) 2019 Omer Ozarslan
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
-DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
-OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE
-OR OTHER DEALINGS IN THE SOFTWARE.
-
---------------------------------------------------------------------------------
-
-The projects includes code from the Ursabot project under the dev/archery
-directory.
-
-License: BSD 2-Clause
-
-Copyright 2019 RStudio, Inc.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-1. Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-This project include code from mingw-w64.
-
-* cpp/src/arrow/util/cpu-info.cc has a polyfill for mingw-w64 < 5
-
-Copyright (c) 2009 - 2013 by the mingw-w64 project
-Homepage: https://mingw-w64.org
-License: Zope Public License (ZPL) Version 2.1.
-
----------------------------------------------------------------------------------
-
-This project include code from Google's Asylo project.
-
-* cpp/src/arrow/result.h is based on status_or.h
-
-Copyright (c)  Copyright 2017 Asylo authors
-Homepage: https://asylo.dev/
-License: Apache 2.0
-
---------------------------------------------------------------------------------
-
-This project includes code from Google's protobuf project
-
-* cpp/src/arrow/result.h ARROW_ASSIGN_OR_RAISE is based off ASSIGN_OR_RETURN
-
-Copyright 2008 Google Inc.  All rights reserved.
-Homepage: https://developers.google.com/protocol-buffers/
-License:
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-    * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-Code generated by the Protocol Buffer compiler is owned by the owner
-of the input file used when generating it.  This code is not
-standalone and requires a support library to be linked with it.  This
-support library is itself covered by the above license.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency LLVM is statically linked in certain binary distributions.
-Additionally some sections of source code have been derived from sources in LLVM
-and have been clearly labeled as such. LLVM has the following license:
-
-==============================================================================
-The LLVM Project is under the Apache License v2.0 with LLVM Exceptions:
-==============================================================================
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-    TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-    1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-    2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-    3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-    4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-    5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-    6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-    7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-    8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-    9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-    END OF TERMS AND CONDITIONS
-
-    APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-    Copyright [yyyy] [name of copyright owner]
-
-    Licensed 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.
-
-
----- LLVM Exceptions to the Apache 2.0 License ----
-
-As an exception, if, as a result of your compiling your source code, portions
-of this Software are embedded into an Object form of such source code, you
-may redistribute such embedded portions in such Object form without complying
-with the conditions of Sections 4(a), 4(b) and 4(d) of the License.
-
-In addition, if you combine or link compiled forms of this Software with
-software that is licensed under the GPLv2 ("Combined Software") and if a
-court of competent jurisdiction determines that the patent provision (Section
-3), the indemnity provision (Section 9) or other Section of the License
-conflicts with the conditions of the GPLv2, you may retroactively and
-prospectively choose to deem waived or otherwise exclude such Section(s) of
-the License, but only in their entirety and only with respect to the Combined
-Software.
-
-==============================================================================
-Software from third parties included in the LLVM Project:
-==============================================================================
-The LLVM Project contains third party software which is under different license
-terms. All such code will be identified clearly using at least one of two
-mechanisms:
-1) It will be in a separate directory tree with its own `LICENSE.txt` or
-   `LICENSE` file at the top containing the specific license and restrictions
-   which apply to that software, or
-2) It will contain specific license and restriction terms at the top of every
-   file.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency gRPC is statically linked in certain binary
-distributions, like the python wheels. gRPC has the following license:
-
-Copyright 2014 gRPC authors.
-
-Licensed 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.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency Apache Thrift is statically linked in certain binary
-distributions, like the python wheels. Apache Thrift has the following license:
-
-Apache Thrift
-Copyright (C) 2006 - 2019, The Apache Software Foundation
-
-This product includes software developed at
-The Apache Software Foundation (http://www.apache.org/).
-
-Licensed 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.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency Apache ORC is statically linked in certain binary
-distributions, like the python wheels. Apache ORC has the following license:
-
-Apache ORC
-Copyright 2013-2019 The Apache Software Foundation
-
-This product includes software developed by The Apache Software
-Foundation (http://www.apache.org/).
-
-This product includes software developed by Hewlett-Packard:
-(c) Copyright [2014-2015] Hewlett-Packard Development Company, L.P
-
-Licensed 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.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency zstd is statically linked in certain binary
-distributions, like the python wheels. ZSTD has the following license:
-
-BSD License
-
-For Zstandard software
-
-Copyright (c) 2016-present, Facebook, Inc. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
- * Redistributions of source code must retain the above copyright notice, this
-   list of conditions and the following disclaimer.
-
- * Redistributions in binary form must reproduce the above copyright notice,
-   this list of conditions and the following disclaimer in the documentation
-   and/or other materials provided with the distribution.
-
- * Neither the name Facebook nor the names of its contributors may be used to
-   endorse or promote products derived from this software without specific
-   prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency lz4 is statically linked in certain binary
-distributions, like the python wheels. lz4 has the following license:
-
-LZ4 Library
-Copyright (c) 2011-2016, Yann Collet
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without modification,
-are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice, this
-  list of conditions and the following disclaimer in the documentation and/or
-  other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
-ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
-ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
-(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
-ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
-SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency Brotli is statically linked in certain binary
-distributions, like the python wheels. Brotli has the following license:
-
-Copyright (c) 2009, 2010, 2013-2016 by the Brotli Authors.
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency rapidjson is statically linked in certain binary
-distributions, like the python wheels. rapidjson and its dependencies have the
-following licenses:
-
-Tencent is pleased to support the open source community by making RapidJSON
-available.
-
-Copyright (C) 2015 THL A29 Limited, a Tencent company, and Milo Yip.
-All rights reserved.
-
-If you have downloaded a copy of the RapidJSON binary from Tencent, please note
-that the RapidJSON binary is licensed under the MIT License.
-If you have downloaded a copy of the RapidJSON source code from Tencent, please
-note that RapidJSON source code is licensed under the MIT License, except for
-the third-party components listed below which are subject to different license
-terms.  Your integration of RapidJSON into your own projects may require
-compliance with the MIT License, as well as the other licenses applicable to
-the third-party components included within RapidJSON. To avoid the problematic
-JSON license in your own projects, it's sufficient to exclude the
-bin/jsonchecker/ directory, as it's the only code under the JSON license.
-A copy of the MIT License is included in this file.
-
-Other dependencies and licenses:
-
-    Open Source Software Licensed Under the BSD License:
-    --------------------------------------------------------------------
-
-    The msinttypes r29
-    Copyright (c) 2006-2013 Alexander Chemeris
-    All rights reserved.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are met:
-
-    * Redistributions of source code must retain the above copyright notice,
-    this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright notice,
-    this list of conditions and the following disclaimer in the documentation
-    and/or other materials provided with the distribution.
-    * Neither the name of  copyright holder nor the names of its contributors
-    may be used to endorse or promote products derived from this software
-    without specific prior written permission.
-
-    THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND ANY
-    EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
-    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-    DISCLAIMED. IN NO EVENT SHALL THE REGENTS AND CONTRIBUTORS BE LIABLE FOR
-    ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-    DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-    SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
-    OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
-    DAMAGE.
-
-    Open Source Software Licensed Under the JSON License:
-    --------------------------------------------------------------------
-
-    json.org
-    Copyright (c) 2002 JSON.org
-    All Rights Reserved.
-
-    JSON_checker
-    Copyright (c) 2002 JSON.org
-    All Rights Reserved.
-
-
-    Terms of the JSON License:
-    ---------------------------------------------------
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included in
-    all copies or substantial portions of the Software.
-
-    The Software shall be used for Good, not Evil.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-
-
-    Terms of the MIT License:
-    --------------------------------------------------------------------
-
-    Permission is hereby granted, free of charge, to any person obtaining a
-    copy of this software and associated documentation files (the "Software"),
-    to deal in the Software without restriction, including without limitation
-    the rights to use, copy, modify, merge, publish, distribute, sublicense,
-    and/or sell copies of the Software, and to permit persons to whom the
-    Software is furnished to do so, subject to the following conditions:
-
-    The above copyright notice and this permission notice shall be included
-    in all copies or substantial portions of the Software.
-
-    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
-    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-    DEALINGS IN THE SOFTWARE.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency snappy is statically linked in certain binary
-distributions, like the python wheels. snappy has the following license:
-
-Copyright 2011, Google Inc.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright notice,
-      this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above copyright notice,
-      this list of conditions and the following disclaimer in the documentation
-      and/or other materials provided with the distribution.
-    * Neither the name of Google Inc. nor the names of its contributors may be
-      used to endorse or promote products derived from this software without
-      specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-===
-
-Some of the benchmark data in testdata/ is licensed differently:
-
- - fireworks.jpeg is Copyright 2013 Steinar H. Gunderson, and
-   is licensed under the Creative Commons Attribution 3.0 license
-   (CC-BY-3.0). See https://creativecommons.org/licenses/by/3.0/
-   for more information.
-
- - kppkn.gtb is taken from the Gaviota chess tablebase set, and
-   is licensed under the MIT License. See
-   https://sites.google.com/site/gaviotachessengine/Home/endgame-tablebases-1
-   for more information.
-
- - paper-100k.pdf is an excerpt (bytes 92160 to 194560) from the paper
-   “Combinatorial Modeling of Chromatin Features Quantitatively Predicts DNA
-   Replication Timing in _Drosophila_” by Federico Comoglio and Renato Paro,
-   which is licensed under the CC-BY license. See
-   http://www.ploscompbiol.org/static/license for more ifnormation.
-
- - alice29.txt, asyoulik.txt, plrabn12.txt and lcet10.txt are from Project
-   Gutenberg. The first three have expired copyrights and are in the public
-   domain; the latter does not have expired copyright, but is still in the
-   public domain according to the license information
-   (http://www.gutenberg.org/ebooks/53).
-
---------------------------------------------------------------------------------
-
-3rdparty dependency gflags is statically linked in certain binary
-distributions, like the python wheels. gflags has the following license:
-
-Copyright (c) 2006, Google Inc.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-    * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency glog is statically linked in certain binary
-distributions, like the python wheels. glog has the following license:
-
-Copyright (c) 2008, Google Inc.
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-    * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-A function gettimeofday in utilities.cc is based on
-
-http://www.google.com/codesearch/p?hl=en#dR3YEbitojA/COPYING&q=GetSystemTimeAsFileTime%20license:bsd
-
-The license of this code is:
-
-Copyright (c) 2003-2008, Jouni Malinen <j@w1.fi> and contributors
-All Rights Reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-1. Redistributions of source code must retain the above copyright
-   notice, this list of conditions and the following disclaimer.
-
-2. Redistributions in binary form must reproduce the above copyright
-   notice, this list of conditions and the following disclaimer in the
-   documentation and/or other materials provided with the distribution.
-
-3. Neither the name(s) of the above-listed copyright holder(s) nor the
-   names of its contributors may be used to endorse or promote products
-   derived from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency re2 is statically linked in certain binary
-distributions, like the python wheels. re2 has the following license:
-
-Copyright (c) 2009 The RE2 Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-      notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-      copyright notice, this list of conditions and the following
-      disclaimer in the documentation and/or other materials provided
-      with the distribution.
-    * Neither the name of Google Inc. nor the names of its contributors
-      may be used to endorse or promote products derived from this
-      software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency c-ares is statically linked in certain binary
-distributions, like the python wheels. c-ares has the following license:
-
-# c-ares license
-
-Copyright (c) 2007 - 2018, Daniel Stenberg with many contributors, see AUTHORS
-file.
-
-Copyright 1998 by the Massachusetts Institute of Technology.
-
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted, provided that
-the above copyright notice appear in all copies and that both that copyright
-notice and this permission notice appear in supporting documentation, and that
-the name of M.I.T. not be used in advertising or publicity pertaining to
-distribution of the software without specific, written prior permission.
-M.I.T. makes no representations about the suitability of this software for any
-purpose.  It is provided "as is" without express or implied warranty.
-
---------------------------------------------------------------------------------
-
-3rdparty dependency zlib is redistributed as a dynamically linked shared
-library in certain binary distributions, like the python wheels. In the future
-this will likely change to static linkage. zlib has the following license:
-
-zlib.h -- interface of the 'zlib' general purpose compression library
-  version 1.2.11, January 15th, 2017
-
-  Copyright (C) 1995-2017 Jean-loup Gailly and Mark Adler
-
-  This software is provided 'as-is', without any express or implied
-  warranty.  In no event will the authors be held liable for any damages
-  arising from the use of this software.
-
-  Permission is granted to anyone to use this software for any purpose,
-  including commercial applications, and to alter it and redistribute it
-  freely, subject to the following restrictions:
-
-  1. The origin of this software must not be misrepresented; you must not
-     claim that you wrote the original software. If you use this software
-     in a product, an acknowledgment in the product documentation would be
-     appreciated but is not required.
-  2. Altered source versions must be plainly marked as such, and must not be
-     misrepresented as being the original software.
-  3. This notice may not be removed or altered from any source distribution.
-
-  Jean-loup Gailly        Mark Adler
-  jloup@gzip.org          madler@alumni.caltech.edu
-
---------------------------------------------------------------------------------
-
-3rdparty dependency openssl is redistributed as a dynamically linked shared
-library in certain binary distributions, like the python wheels. openssl
-preceding version 3 has the following license:
-
-  LICENSE ISSUES
-  ==============
-
-  The OpenSSL toolkit stays under a double license, i.e. both the conditions of
-  the OpenSSL License and the original SSLeay license apply to the toolkit.
-  See below for the actual license texts.
-
-  OpenSSL License
-  ---------------
-
-/* ====================================================================
- * Copyright (c) 1998-2019 The OpenSSL Project.  All rights reserved.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- *
- * 1. Redistributions of source code must retain the above copyright
- *    notice, this list of conditions and the following disclaimer.
- *
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in
- *    the documentation and/or other materials provided with the
- *    distribution.
- *
- * 3. All advertising materials mentioning features or use of this
- *    software must display the following acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
- *
- * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
- *    endorse or promote products derived from this software without
- *    prior written permission. For written permission, please contact
- *    openssl-core@openssl.org.
- *
- * 5. Products derived from this software may not be called "OpenSSL"
- *    nor may "OpenSSL" appear in their names without prior written
- *    permission of the OpenSSL Project.
- *
- * 6. Redistributions of any form whatsoever must retain the following
- *    acknowledgment:
- *    "This product includes software developed by the OpenSSL Project
- *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
- *
- * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
- * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
- * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
- * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
- * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
- * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
- * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
- * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
- * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
- * OF THE POSSIBILITY OF SUCH DAMAGE.
- * ====================================================================
- *
- * This product includes cryptographic software written by Eric Young
- * (eay@cryptsoft.com).  This product includes software written by Tim
- * Hudson (tjh@cryptsoft.com).
- *
- */
-
- Original SSLeay License
- -----------------------
-
-/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
- * All rights reserved.
- *
- * This package is an SSL implementation written
- * by Eric Young (eay@cryptsoft.com).
- * The implementation was written so as to conform with Netscapes SSL.
- *
- * This library is free for commercial and non-commercial use as long as
- * the following conditions are aheared to.  The following conditions
- * apply to all code found in this distribution, be it the RC4, RSA,
- * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
- * included with this distribution is covered by the same copyright terms
- * except that the holder is Tim Hudson (tjh@cryptsoft.com).
- *
- * Copyright remains Eric Young's, and as such any Copyright notices in
- * the code are not to be removed.
- * If this package is used in a product, Eric Young should be given attribution
- * as the author of the parts of the library used.
- * This can be in the form of a textual message at program startup or
- * in documentation (online or textual) provided with the package.
- *
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions
- * are met:
- * 1. Redistributions of source code must retain the copyright
- *    notice, this list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright
- *    notice, this list of conditions and the following disclaimer in the
- *    documentation and/or other materials provided with the distribution.
- * 3. All advertising materials mentioning features or use of this software
- *    must display the following acknowledgement:
- *    "This product includes cryptographic software written by
- *     Eric Young (eay@cryptsoft.com)"
- *    The word 'cryptographic' can be left out if the rouines from the library
- *    being used are not cryptographic related :-).
- * 4. If you include any Windows specific code (or a derivative thereof) from
- *    the apps directory (application code) you must include an acknowledgement:
- *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
- *
- * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
- * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
- * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
- * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
- * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
- * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
- * SUCH DAMAGE.
- *
- * The licence and distribution terms for any publically available version or
- * derivative of this code cannot be changed.  i.e. this code cannot simply be
- * copied and put under another distribution licence
- * [including the GNU Public Licence.]
- */
-
---------------------------------------------------------------------------------
-
-This project includes code from the rtools-backports project.
-
-* ci/scripts/PKGBUILD and ci/scripts/r_windows_build.sh are based on code
-  from the rtools-backports project.
-
-Copyright: Copyright (c) 2013 - 2019, Алексей and Jeroen Ooms.
-All rights reserved.
-Homepage: https://github.com/r-windows/rtools-backports
-License: 3-clause BSD
-
---------------------------------------------------------------------------------
-
-Some code from pandas has been adapted for the pyarrow codebase. pandas is
-available under the 3-clause BSD license, which follows:
-
-pandas license
-==============
-
-Copyright (c) 2011-2012, Lambda Foundry, Inc. and PyData Development Team
-All rights reserved.
-
-Copyright (c) 2008-2011 AQR Capital Management, LLC
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-    * Redistributions of source code must retain the above copyright
-       notice, this list of conditions and the following disclaimer.
-
-    * Redistributions in binary form must reproduce the above
-       copyright notice, this list of conditions and the following
-       disclaimer in the documentation and/or other materials provided
-       with the distribution.
-
-    * Neither the name of the copyright holder nor the names of any
-       contributors may be used to endorse or promote products derived
-       from this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
---------------------------------------------------------------------------------
-
-Some bits from DyND, in particular aspects of the build system, have been
-adapted from libdynd and dynd-python under the terms of the BSD 2-clause
-license
-
-The BSD 2-Clause License
-
-    Copyright (C) 2011-12, Dynamic NDArray Developers
-    All rights reserved.
-
-    Redistribution and use in source and binary forms, with or without
-    modification, are permitted provided that the following conditions are
-    met:
-
-        * Redistributions of source code must retain the above copyright
-           notice, this list of conditions and the following disclaimer.
-
-        * Redistributions in binary form must reproduce the above
-           copyright notice, this list of conditions and the following
-           disclaimer in the documentation and/or other materials provided
-           with the distribution.
-
-    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-    A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-    OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-    SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-    LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-    DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-    THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-    (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-    OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-Dynamic NDArray Developers list:
-
- * Mark Wiebe
- * Continuum Analytics
-
---------------------------------------------------------------------------------
-
-Some source code from Ibis (https://github.com/cloudera/ibis) has been adapted
-for PyArrow. Ibis is released under the Apache License, Version 2.0.
-
---------------------------------------------------------------------------------
-
-This project includes code from the autobrew project.
-
-* r/tools/autobrew and dev/tasks/homebrew-formulae/autobrew/apache-arrow.rb
-  are based on code from the autobrew project.
-
-Copyright (c) 2019, Jeroen Ooms
-License: MIT
-Homepage: https://github.com/jeroen/autobrew
-
---------------------------------------------------------------------------------
-
-dev/tasks/homebrew-formulae/apache-arrow.rb has the following license:
-
-BSD 2-Clause License
-
-Copyright (c) 2009-present, Homebrew contributors
-All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are met:
-
-* Redistributions of source code must retain the above copyright notice, this
-  list of conditions and the following disclaimer.
-
-* Redistributions in binary form must reproduce the above copyright notice,
-  this list of conditions and the following disclaimer in the documentation
-  and/or other materials provided with the distribution.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
-AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
-DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
-FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
-DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
-SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
-OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-----------------------------------------------------------------------
-
-cpp/src/arrow/vendored/base64.cpp has the following license
-
-ZLIB License
-
-Copyright (C) 2004-2017 René Nyffenegger
-
-This source code is provided 'as-is', without any express or implied
-warranty. In no event will the author be held liable for any damages arising
-from the use of this software.
-
-Permission is granted to anyone to use this software for any purpose, including
-commercial applications, and to alter it and redistribute it freely, subject to
-the following restrictions:
-
-1. The origin of this source code must not be misrepresented; you must not
-   claim that you wrote the original source code. If you use this source code
-   in a product, an acknowledgment in the product documentation would be
-   appreciated but is not required.
-
-2. Altered source versions must be plainly marked as such, and must not be
-   misrepresented as being the original source code.
-
-3. This notice may not be removed or altered from any source distribution.
-
-René Nyffenegger rene.nyffenegger@adp-gmbh.ch
-
---------------------------------------------------------------------------------
-
-The file cpp/src/arrow/vendored/optional.hpp has the following license
-
-Boost Software License - Version 1.0 - August 17th, 2003
-
-Permission is hereby granted, free of charge, to any person or organization
-obtaining a copy of the software and accompanying documentation covered by
-this license (the "Software") to use, reproduce, display, distribute,
-execute, and transmit the Software, and to prepare derivative works of the
-Software, and to permit third-parties to whom the Software is furnished to
-do so, all subject to the following:
-
-The copyright notices in the Software and this entire statement, including
-the above license grant, this restriction and the following disclaimer,
-must be included in all copies of the Software, in whole or in part, and
-all derivative works of the Software, unless such copies or derivative
-works are solely in the form of machine-executable object code generated by
-a source language processor.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE, TITLE AND NON-INFRINGEMENT. IN NO EVENT
-SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
-FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
-ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.
-
---------------------------------------------------------------------------------
-
-This project includes code from Folly.
-
- * cpp/src/arrow/vendored/ProducerConsumerQueue.h
-
-is based on Folly's
-
- * folly/Portability.h
- * folly/lang/Align.h
- * folly/ProducerConsumerQueue.h
-
-Copyright: Copyright (c) Facebook, Inc. and its affiliates.
-Home page: https://github.com/facebook/folly
-License: http://www.apache.org/licenses/LICENSE-2.0
-
---------------------------------------------------------------------------------
-
-The file cpp/src/arrow/vendored/musl/strptime.c has the following license
-
-Copyright © 2005-2020 Rich Felker, et al.
-
-Permission is hereby granted, free of charge, to any person obtaining
-a copy of this software and associated documentation files (the
-"Software"), to deal in the Software without restriction, including
-without limitation the rights to use, copy, modify, merge, publish,
-distribute, sublicense, and/or sell copies of the Software, and to
-permit persons to whom the Software is furnished to do so, subject to
-the following conditions:
-
-The above copyright notice and this permission notice shall be
-included in all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
-EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
-MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
-IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
-TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
-SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
---------------------------------------------------------------------------------
-
-The file cpp/cmake_modules/BuildUtils.cmake contains code from
-
-https://gist.github.com/cristianadam/ef920342939a89fae3e8a85ca9459b49
-
-which is made available under the MIT license
-
-Copyright (c) 2019 Cristian Adam
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
---------------------------------------------------------------------------------
-
-The files in cpp/src/arrow/vendored/portable-snippets/ contain code from
-
-https://github.com/nemequ/portable-snippets
-
-and have the following copyright notice:
-
-Each source file contains a preamble explaining the license situation
-for that file, which takes priority over this file.  With the
-exception of some code pulled in from other repositories (such as
-µnit, an MIT-licensed project which is used for testing), the code is
-public domain, released using the CC0 1.0 Universal dedication (*).
-
-(*) https://creativecommons.org/publicdomain/zero/1.0/legalcode
-
---------------------------------------------------------------------------------
-
-The files in cpp/src/arrow/vendored/fast_float/ contain code from
-
-https://github.com/lemire/fast_float
-
-which is made available under the Apache License 2.0.
-
---------------------------------------------------------------------------------
-
-The file python/pyarrow/vendored/version.py contains code from
-
-https://github.com/pypa/packaging/
-
-which is made available under both the Apache license v2.0 and the
-BSD 2-clause license.
diff --git a/README.md b/README.md
index 987826b32216..7d4fa7103c5d 100644
--- a/README.md
+++ b/README.md
@@ -25,11 +25,14 @@ Welcome to the implementation of Arrow, the popular in-memory columnar format, i
 
 This repo contains the following main components:
 
-| Crate        | Description                                                        | Documentation              |
-| ------------ | ------------------------------------------------------------------ | -------------------------- |
-| arrow        | Core functionality (memory layout, arrays, low level computations) | [(README)][arrow-readme]   |
-| parquet      | Support for Parquet columnar file format                           | [(README)][parquet-readme] |
-| arrow-flight | Support for Arrow-Flight IPC protocol                              | [(README)][flight-readme]  |
+| Crate        | Description                                                               | Latest API Docs                                | README                         |
+| ------------ | ------------------------------------------------------------------------- | ---------------------------------------------- | ------------------------------ |
+| arrow        | Core functionality (memory layout, arrays, low level computations)        | [docs.rs](https://docs.rs/arrow/latest)        | [(README)][arrow-readme]       |
+| parquet      | Support for Parquet columnar file format                                  | [docs.rs](https://docs.rs/parquet/latest)      | [(README)][parquet-readme]     |
+| arrow-flight | Support for Arrow-Flight IPC protocol                                     | [docs.rs](https://docs.rs/arrow-flight/latest) | [(README)][flight-readme]      |
+| object-store | Support for object store interactions (aws, azure, gcp, local, in-memory) | [docs.rs](https://docs.rs/object_store/latest) | [(README)][objectstore-readme] |
+
+The current development version the API documentation in this repo can be found [here](https://arrow.apache.org/rust).
 
 There are two related crates in a different repository
 
@@ -57,8 +60,8 @@ a great place to meet other contributors and get guidance on where to contribute
 2. the [GitHub Discussions][discussions]
 3. the [Discord channel](https://discord.gg/YAb2TdazKQ)
 
-Unlike other parts of the Arrow ecosystem, the Rust implementation uses [GitHub issues][issues] as the system of record for new features
-and bug fixes and this plays a critical role in the release process.
+The Rust implementation uses [GitHub issues][issues] as the system of record for new features and bug fixes and
+this plays a critical role in the release process.
 
 For design discussions we generally collaborate on Google documents and file a GitHub issue linking to the document.
 
@@ -69,7 +72,8 @@ There is more information in the [contributing] guide.
 [contributing]: CONTRIBUTING.md
 [parquet-readme]: parquet/README.md
 [flight-readme]: arrow-flight/README.md
-[datafusion-readme]: https://github.com/apache/arrow-datafusion/blob/master/README.md
-[ballista-readme]: https://github.com/apache/arrow-ballista/blob/master/README.md
+[datafusion-readme]: https://github.com/apache/arrow-datafusion/blob/main/README.md
+[ballista-readme]: https://github.com/apache/arrow-ballista/blob/main/README.md
+[objectstore-readme]: object_store/README.md
 [issues]: https://github.com/apache/arrow-rs/issues
 [discussions]: https://github.com/apache/arrow-rs/discussions
diff --git a/arrow-arith/Cargo.toml b/arrow-arith/Cargo.toml
new file mode 100644
index 000000000000..d2ee0b9e2c72
--- /dev/null
+++ b/arrow-arith/Cargo.toml
@@ -0,0 +1,45 @@
+# 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]
+name = "arrow-arith"
+version = { workspace = true }
+description = "Arrow arithmetic kernels"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_arith"
+path = "src/lib.rs"
+bench = false
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-data = { workspace = true }
+arrow-schema = { workspace = true }
+chrono = { workspace = true }
+half = { version = "2.1", default-features = false }
+num = { version = "0.4", default-features = false, features = ["std"] }
+
+[dev-dependencies]
diff --git a/arrow-arith/src/aggregate.rs b/arrow-arith/src/aggregate.rs
new file mode 100644
index 000000000000..20ff0711d735
--- /dev/null
+++ b/arrow-arith/src/aggregate.rs
@@ -0,0 +1,1420 @@
+// 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.
+
+//! Defines aggregations over Arrow arrays.
+
+use arrow_array::cast::*;
+use arrow_array::iterator::ArrayIter;
+use arrow_array::*;
+use arrow_buffer::{ArrowNativeType, NullBuffer};
+use arrow_data::bit_iterator::try_for_each_valid_idx;
+use arrow_schema::ArrowError;
+use arrow_schema::*;
+use std::borrow::BorrowMut;
+use std::ops::{BitAnd, BitOr, BitXor};
+
+/// An accumulator for primitive numeric values.
+trait NumericAccumulator<T: ArrowNativeTypeOp>: Copy + Default {
+    /// Accumulate a non-null value.
+    fn accumulate(&mut self, value: T);
+    /// Accumulate a nullable values.
+    /// If `valid` is false the `value` should not affect the accumulator state.
+    fn accumulate_nullable(&mut self, value: T, valid: bool);
+    /// Merge another accumulator into this accumulator
+    fn merge(&mut self, other: Self);
+    /// Return the aggregated value.
+    fn finish(&mut self) -> T;
+}
+
+/// Helper for branchlessly selecting either `a` or `b` based on the boolean `m`.
+/// After verifying the generated assembly this can be a simple `if`.
+#[inline(always)]
+fn select<T: Copy>(m: bool, a: T, b: T) -> T {
+    if m {
+        a
+    } else {
+        b
+    }
+}
+
+#[derive(Clone, Copy)]
+struct SumAccumulator<T: ArrowNativeTypeOp> {
+    sum: T,
+}
+
+impl<T: ArrowNativeTypeOp> Default for SumAccumulator<T> {
+    fn default() -> Self {
+        Self { sum: T::ZERO }
+    }
+}
+
+impl<T: ArrowNativeTypeOp> NumericAccumulator<T> for SumAccumulator<T> {
+    fn accumulate(&mut self, value: T) {
+        self.sum = self.sum.add_wrapping(value);
+    }
+
+    fn accumulate_nullable(&mut self, value: T, valid: bool) {
+        let sum = self.sum;
+        self.sum = select(valid, sum.add_wrapping(value), sum)
+    }
+
+    fn merge(&mut self, other: Self) {
+        self.sum = self.sum.add_wrapping(other.sum);
+    }
+
+    fn finish(&mut self) -> T {
+        self.sum
+    }
+}
+
+#[derive(Clone, Copy)]
+struct MinAccumulator<T: ArrowNativeTypeOp> {
+    min: T,
+}
+
+impl<T: ArrowNativeTypeOp> Default for MinAccumulator<T> {
+    fn default() -> Self {
+        Self {
+            min: T::MAX_TOTAL_ORDER,
+        }
+    }
+}
+
+impl<T: ArrowNativeTypeOp> NumericAccumulator<T> for MinAccumulator<T> {
+    fn accumulate(&mut self, value: T) {
+        let min = self.min;
+        self.min = select(value.is_lt(min), value, min);
+    }
+
+    fn accumulate_nullable(&mut self, value: T, valid: bool) {
+        let min = self.min;
+        let is_lt = valid & value.is_lt(min);
+        self.min = select(is_lt, value, min);
+    }
+
+    fn merge(&mut self, other: Self) {
+        self.accumulate(other.min)
+    }
+
+    fn finish(&mut self) -> T {
+        self.min
+    }
+}
+
+#[derive(Clone, Copy)]
+struct MaxAccumulator<T: ArrowNativeTypeOp> {
+    max: T,
+}
+
+impl<T: ArrowNativeTypeOp> Default for MaxAccumulator<T> {
+    fn default() -> Self {
+        Self {
+            max: T::MIN_TOTAL_ORDER,
+        }
+    }
+}
+
+impl<T: ArrowNativeTypeOp> NumericAccumulator<T> for MaxAccumulator<T> {
+    fn accumulate(&mut self, value: T) {
+        let max = self.max;
+        self.max = select(value.is_gt(max), value, max);
+    }
+
+    fn accumulate_nullable(&mut self, value: T, valid: bool) {
+        let max = self.max;
+        let is_gt = value.is_gt(max) & valid;
+        self.max = select(is_gt, value, max);
+    }
+
+    fn merge(&mut self, other: Self) {
+        self.accumulate(other.max)
+    }
+
+    fn finish(&mut self) -> T {
+        self.max
+    }
+}
+
+fn reduce_accumulators<T: ArrowNativeTypeOp, A: NumericAccumulator<T>, const LANES: usize>(
+    mut acc: [A; LANES],
+) -> A {
+    assert!(LANES > 0 && LANES.is_power_of_two());
+    let mut len = LANES;
+
+    // attempt at tree reduction, unfortunately llvm does not fully recognize this pattern,
+    // but the generated code is still a little faster than purely sequential reduction for floats.
+    while len >= 2 {
+        let mid = len / 2;
+        let (h, t) = acc[..len].split_at_mut(mid);
+
+        for i in 0..mid {
+            h[i].merge(t[i]);
+        }
+        len /= 2;
+    }
+    acc[0]
+}
+
+#[inline(always)]
+fn aggregate_nonnull_chunk<T: ArrowNativeTypeOp, A: NumericAccumulator<T>, const LANES: usize>(
+    acc: &mut [A; LANES],
+    values: &[T; LANES],
+) {
+    for i in 0..LANES {
+        acc[i].accumulate(values[i]);
+    }
+}
+
+#[inline(always)]
+fn aggregate_nullable_chunk<T: ArrowNativeTypeOp, A: NumericAccumulator<T>, const LANES: usize>(
+    acc: &mut [A; LANES],
+    values: &[T; LANES],
+    validity: u64,
+) {
+    let mut bit = 1;
+    for i in 0..LANES {
+        acc[i].accumulate_nullable(values[i], (validity & bit) != 0);
+        bit <<= 1;
+    }
+}
+
+fn aggregate_nonnull_simple<T: ArrowNativeTypeOp, A: NumericAccumulator<T>>(values: &[T]) -> T {
+    return values
+        .iter()
+        .copied()
+        .fold(A::default(), |mut a, b| {
+            a.accumulate(b);
+            a
+        })
+        .finish();
+}
+
+#[inline(never)]
+fn aggregate_nonnull_lanes<T: ArrowNativeTypeOp, A: NumericAccumulator<T>, const LANES: usize>(
+    values: &[T],
+) -> T {
+    // aggregating into multiple independent accumulators allows the compiler to use vector registers
+    // with a single accumulator the compiler would not be allowed to reorder floating point addition
+    let mut acc = [A::default(); LANES];
+    let mut chunks = values.chunks_exact(LANES);
+    chunks.borrow_mut().for_each(|chunk| {
+        aggregate_nonnull_chunk(&mut acc, chunk[..LANES].try_into().unwrap());
+    });
+
+    let remainder = chunks.remainder();
+    for i in 0..remainder.len() {
+        acc[i].accumulate(remainder[i]);
+    }
+
+    reduce_accumulators(acc).finish()
+}
+
+#[inline(never)]
+fn aggregate_nullable_lanes<T: ArrowNativeTypeOp, A: NumericAccumulator<T>, const LANES: usize>(
+    values: &[T],
+    validity: &NullBuffer,
+) -> T {
+    assert!(LANES > 0 && 64 % LANES == 0);
+    assert_eq!(values.len(), validity.len());
+
+    // aggregating into multiple independent accumulators allows the compiler to use vector registers
+    let mut acc = [A::default(); LANES];
+    // we process 64 bits of validity at a time
+    let mut values_chunks = values.chunks_exact(64);
+    let validity_chunks = validity.inner().bit_chunks();
+    let mut validity_chunks_iter = validity_chunks.iter();
+
+    values_chunks.borrow_mut().for_each(|chunk| {
+        // Safety: we asserted that values and validity have the same length and trust the iterator impl
+        let mut validity = unsafe { validity_chunks_iter.next().unwrap_unchecked() };
+        // chunk further based on the number of vector lanes
+        chunk.chunks_exact(LANES).for_each(|chunk| {
+            aggregate_nullable_chunk(&mut acc, chunk[..LANES].try_into().unwrap(), validity);
+            validity >>= LANES;
+        });
+    });
+
+    let remainder = values_chunks.remainder();
+    if !remainder.is_empty() {
+        let mut validity = validity_chunks.remainder_bits();
+
+        let mut remainder_chunks = remainder.chunks_exact(LANES);
+        remainder_chunks.borrow_mut().for_each(|chunk| {
+            aggregate_nullable_chunk(&mut acc, chunk[..LANES].try_into().unwrap(), validity);
+            validity >>= LANES;
+        });
+
+        let remainder = remainder_chunks.remainder();
+        if !remainder.is_empty() {
+            let mut bit = 1;
+            for i in 0..remainder.len() {
+                acc[i].accumulate_nullable(remainder[i], (validity & bit) != 0);
+                bit <<= 1;
+            }
+        }
+    }
+
+    reduce_accumulators(acc).finish()
+}
+
+/// The preferred vector size in bytes for the target platform.
+/// Note that the avx512 target feature is still unstable and this also means it is not detected on stable rust.
+const PREFERRED_VECTOR_SIZE: usize =
+    if cfg!(all(target_arch = "x86_64", target_feature = "avx512f")) {
+        64
+    } else if cfg!(all(target_arch = "x86_64", target_feature = "avx")) {
+        32
+    } else {
+        16
+    };
+
+/// non-nullable aggregation requires fewer temporary registers so we can use more of them for accumulators
+const PREFERRED_VECTOR_SIZE_NON_NULL: usize = PREFERRED_VECTOR_SIZE * 2;
+
+/// Generic aggregation for any primitive type.
+/// Returns None if there are no non-null values in `array`.
+fn aggregate<T: ArrowNativeTypeOp, P: ArrowPrimitiveType<Native = T>, A: NumericAccumulator<T>>(
+    array: &PrimitiveArray<P>,
+) -> Option<T> {
+    let null_count = array.null_count();
+    if null_count == array.len() {
+        return None;
+    }
+    let values = array.values().as_ref();
+    match array.nulls() {
+        Some(nulls) if null_count > 0 => {
+            // const generics depending on a generic type parameter are not supported
+            // so we have to match and call aggregate with the corresponding constant
+            match PREFERRED_VECTOR_SIZE / std::mem::size_of::<T>() {
+                64 => Some(aggregate_nullable_lanes::<T, A, 64>(values, nulls)),
+                32 => Some(aggregate_nullable_lanes::<T, A, 32>(values, nulls)),
+                16 => Some(aggregate_nullable_lanes::<T, A, 16>(values, nulls)),
+                8 => Some(aggregate_nullable_lanes::<T, A, 8>(values, nulls)),
+                4 => Some(aggregate_nullable_lanes::<T, A, 4>(values, nulls)),
+                2 => Some(aggregate_nullable_lanes::<T, A, 2>(values, nulls)),
+                _ => Some(aggregate_nullable_lanes::<T, A, 1>(values, nulls)),
+            }
+        }
+        _ => {
+            let is_float = matches!(
+                array.data_type(),
+                DataType::Float16 | DataType::Float32 | DataType::Float64
+            );
+            if is_float {
+                match PREFERRED_VECTOR_SIZE_NON_NULL / std::mem::size_of::<T>() {
+                    64 => Some(aggregate_nonnull_lanes::<T, A, 64>(values)),
+                    32 => Some(aggregate_nonnull_lanes::<T, A, 32>(values)),
+                    16 => Some(aggregate_nonnull_lanes::<T, A, 16>(values)),
+                    8 => Some(aggregate_nonnull_lanes::<T, A, 8>(values)),
+                    4 => Some(aggregate_nonnull_lanes::<T, A, 4>(values)),
+                    2 => Some(aggregate_nonnull_lanes::<T, A, 2>(values)),
+                    _ => Some(aggregate_nonnull_simple::<T, A>(values)),
+                }
+            } else {
+                // for non-null integers its better to not chunk ourselves and instead
+                // let llvm fully handle loop unrolling and vectorization
+                Some(aggregate_nonnull_simple::<T, A>(values))
+            }
+        }
+    }
+}
+
+/// Returns the minimum value in the boolean array.
+///
+/// ```
+/// # use arrow_array::BooleanArray;
+/// # use arrow_arith::aggregate::min_boolean;
+///
+/// let a = BooleanArray::from(vec![Some(true), None, Some(false)]);
+/// assert_eq!(min_boolean(&a), Some(false))
+/// ```
+pub fn min_boolean(array: &BooleanArray) -> Option<bool> {
+    // short circuit if all nulls / zero length array
+    if array.null_count() == array.len() {
+        return None;
+    }
+
+    // Note the min bool is false (0), so short circuit as soon as we see it
+    array
+        .iter()
+        .find(|&b| b == Some(false))
+        .flatten()
+        .or(Some(true))
+}
+
+/// Returns the maximum value in the boolean array
+///
+/// ```
+/// # use arrow_array::BooleanArray;
+/// # use arrow_arith::aggregate::max_boolean;
+///
+/// let a = BooleanArray::from(vec![Some(true), None, Some(false)]);
+/// assert_eq!(max_boolean(&a), Some(true))
+/// ```
+pub fn max_boolean(array: &BooleanArray) -> Option<bool> {
+    // short circuit if all nulls / zero length array
+    if array.null_count() == array.len() {
+        return None;
+    }
+
+    // Note the max bool is true (1), so short circuit as soon as we see it
+    array
+        .iter()
+        .find(|&b| b == Some(true))
+        .flatten()
+        .or(Some(false))
+}
+
+/// Helper to compute min/max of [`ArrayAccessor`].
+fn min_max_helper<T, A: ArrayAccessor<Item = T>, F>(array: A, cmp: F) -> Option<T>
+where
+    F: Fn(&T, &T) -> bool,
+{
+    let null_count = array.null_count();
+    if null_count == array.len() {
+        None
+    } else if null_count == 0 {
+        // JUSTIFICATION
+        //  Benefit:  ~8% speedup
+        //  Soundness: `i` is always within the array bounds
+        (0..array.len())
+            .map(|i| unsafe { array.value_unchecked(i) })
+            .reduce(|acc, item| if cmp(&acc, &item) { item } else { acc })
+    } else {
+        let nulls = array.nulls().unwrap();
+        unsafe {
+            let idx = nulls.valid_indices().reduce(|acc_idx, idx| {
+                let acc = array.value_unchecked(acc_idx);
+                let item = array.value_unchecked(idx);
+                if cmp(&acc, &item) {
+                    idx
+                } else {
+                    acc_idx
+                }
+            });
+            idx.map(|idx| array.value_unchecked(idx))
+        }
+    }
+}
+
+/// Returns the maximum value in the binary array, according to the natural order.
+pub fn max_binary<T: OffsetSizeTrait>(array: &GenericBinaryArray<T>) -> Option<&[u8]> {
+    min_max_helper::<&[u8], _, _>(array, |a, b| *a < *b)
+}
+
+/// Returns the minimum value in the binary array, according to the natural order.
+pub fn min_binary<T: OffsetSizeTrait>(array: &GenericBinaryArray<T>) -> Option<&[u8]> {
+    min_max_helper::<&[u8], _, _>(array, |a, b| *a > *b)
+}
+
+/// Returns the maximum value in the string array, according to the natural order.
+pub fn max_string<T: OffsetSizeTrait>(array: &GenericStringArray<T>) -> Option<&str> {
+    min_max_helper::<&str, _, _>(array, |a, b| *a < *b)
+}
+
+/// Returns the minimum value in the string array, according to the natural order.
+pub fn min_string<T: OffsetSizeTrait>(array: &GenericStringArray<T>) -> Option<&str> {
+    min_max_helper::<&str, _, _>(array, |a, b| *a > *b)
+}
+
+/// Returns the sum of values in the array.
+///
+/// This doesn't detect overflow. Once overflowing, the result will wrap around.
+/// For an overflow-checking variant, use `sum_array_checked` instead.
+pub fn sum_array<T, A: ArrayAccessor<Item = T::Native>>(array: A) -> Option<T::Native>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    match array.data_type() {
+        DataType::Dictionary(_, _) => {
+            let null_count = array.null_count();
+
+            if null_count == array.len() {
+                return None;
+            }
+
+            let iter = ArrayIter::new(array);
+            let sum = iter
+                .into_iter()
+                .fold(T::default_value(), |accumulator, value| {
+                    if let Some(value) = value {
+                        accumulator.add_wrapping(value)
+                    } else {
+                        accumulator
+                    }
+                });
+
+            Some(sum)
+        }
+        _ => sum::<T>(as_primitive_array(&array)),
+    }
+}
+
+/// Returns the sum of values in the array.
+///
+/// This detects overflow and returns an `Err` for that. For an non-overflow-checking variant,
+/// use `sum_array` instead.
+pub fn sum_array_checked<T, A: ArrayAccessor<Item = T::Native>>(
+    array: A,
+) -> Result<Option<T::Native>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    match array.data_type() {
+        DataType::Dictionary(_, _) => {
+            let null_count = array.null_count();
+
+            if null_count == array.len() {
+                return Ok(None);
+            }
+
+            let iter = ArrayIter::new(array);
+            let sum = iter
+                .into_iter()
+                .try_fold(T::default_value(), |accumulator, value| {
+                    if let Some(value) = value {
+                        accumulator.add_checked(value)
+                    } else {
+                        Ok(accumulator)
+                    }
+                })?;
+
+            Ok(Some(sum))
+        }
+        _ => sum_checked::<T>(as_primitive_array(&array)),
+    }
+}
+
+/// Returns the min of values in the array of `ArrowNumericType` type, or dictionary
+/// array with value of `ArrowNumericType` type.
+pub fn min_array<T, A: ArrayAccessor<Item = T::Native>>(array: A) -> Option<T::Native>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeType,
+{
+    min_max_array_helper::<T, A, _, _>(array, |a, b| a.is_gt(*b), min)
+}
+
+/// Returns the max of values in the array of `ArrowNumericType` type, or dictionary
+/// array with value of `ArrowNumericType` type.
+pub fn max_array<T, A: ArrayAccessor<Item = T::Native>>(array: A) -> Option<T::Native>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    min_max_array_helper::<T, A, _, _>(array, |a, b| a.is_lt(*b), max)
+}
+
+fn min_max_array_helper<T, A: ArrayAccessor<Item = T::Native>, F, M>(
+    array: A,
+    cmp: F,
+    m: M,
+) -> Option<T::Native>
+where
+    T: ArrowNumericType,
+    F: Fn(&T::Native, &T::Native) -> bool,
+    M: Fn(&PrimitiveArray<T>) -> Option<T::Native>,
+{
+    match array.data_type() {
+        DataType::Dictionary(_, _) => min_max_helper::<T::Native, _, _>(array, cmp),
+        _ => m(as_primitive_array(&array)),
+    }
+}
+
+macro_rules! bit_operation {
+    ($NAME:ident, $OP:ident, $NATIVE:ident, $DEFAULT:expr, $DOC:expr) => {
+        #[doc = $DOC]
+        ///
+        /// Returns `None` if the array is empty or only contains null values.
+        pub fn $NAME<T>(array: &PrimitiveArray<T>) -> Option<T::Native>
+        where
+            T: ArrowNumericType,
+            T::Native: $NATIVE<Output = T::Native> + ArrowNativeTypeOp,
+        {
+            let default;
+            if $DEFAULT == -1 {
+                default = T::Native::ONE.neg_wrapping();
+            } else {
+                default = T::default_value();
+            }
+
+            let null_count = array.null_count();
+
+            if null_count == array.len() {
+                return None;
+            }
+
+            let data: &[T::Native] = array.values();
+
+            match array.nulls() {
+                None => {
+                    let result = data
+                        .iter()
+                        .fold(default, |accumulator, value| accumulator.$OP(*value));
+
+                    Some(result)
+                }
+                Some(nulls) => {
+                    let mut result = default;
+                    let data_chunks = data.chunks_exact(64);
+                    let remainder = data_chunks.remainder();
+
+                    let bit_chunks = nulls.inner().bit_chunks();
+                    data_chunks
+                        .zip(bit_chunks.iter())
+                        .for_each(|(chunk, mask)| {
+                            // index_mask has value 1 << i in the loop
+                            let mut index_mask = 1;
+                            chunk.iter().for_each(|value| {
+                                if (mask & index_mask) != 0 {
+                                    result = result.$OP(*value);
+                                }
+                                index_mask <<= 1;
+                            });
+                        });
+
+                    let remainder_bits = bit_chunks.remainder_bits();
+
+                    remainder.iter().enumerate().for_each(|(i, value)| {
+                        if remainder_bits & (1 << i) != 0 {
+                            result = result.$OP(*value);
+                        }
+                    });
+
+                    Some(result)
+                }
+            }
+        }
+    };
+}
+
+bit_operation!(
+    bit_and,
+    bitand,
+    BitAnd,
+    -1,
+    "Returns the bitwise and of all non-null input values."
+);
+bit_operation!(
+    bit_or,
+    bitor,
+    BitOr,
+    0,
+    "Returns the bitwise or of all non-null input values."
+);
+bit_operation!(
+    bit_xor,
+    bitxor,
+    BitXor,
+    0,
+    "Returns the bitwise xor of all non-null input values."
+);
+
+/// Returns true if all non-null input values are true, otherwise false.
+///
+/// Returns `None` if the array is empty or only contains null values.
+pub fn bool_and(array: &BooleanArray) -> Option<bool> {
+    if array.null_count() == array.len() {
+        return None;
+    }
+    Some(array.false_count() == 0)
+}
+
+/// Returns true if any non-null input value is true, otherwise false.
+///
+/// Returns `None` if the array is empty or only contains null values.
+pub fn bool_or(array: &BooleanArray) -> Option<bool> {
+    if array.null_count() == array.len() {
+        return None;
+    }
+    Some(array.true_count() != 0)
+}
+
+/// Returns the sum of values in the primitive array.
+///
+/// Returns `Ok(None)` if the array is empty or only contains null values.
+///
+/// This detects overflow and returns an `Err` for that. For an non-overflow-checking variant,
+/// use `sum` instead.
+pub fn sum_checked<T>(array: &PrimitiveArray<T>) -> Result<Option<T::Native>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    let null_count = array.null_count();
+
+    if null_count == array.len() {
+        return Ok(None);
+    }
+
+    let data: &[T::Native] = array.values();
+
+    match array.nulls() {
+        None => {
+            let sum = data
+                .iter()
+                .try_fold(T::default_value(), |accumulator, value| {
+                    accumulator.add_checked(*value)
+                })?;
+
+            Ok(Some(sum))
+        }
+        Some(nulls) => {
+            let mut sum = T::default_value();
+
+            try_for_each_valid_idx(
+                nulls.len(),
+                nulls.offset(),
+                nulls.null_count(),
+                Some(nulls.validity()),
+                |idx| {
+                    unsafe { sum = sum.add_checked(array.value_unchecked(idx))? };
+                    Ok::<_, ArrowError>(())
+                },
+            )?;
+
+            Ok(Some(sum))
+        }
+    }
+}
+
+/// Returns the sum of values in the primitive array.
+///
+/// Returns `None` if the array is empty or only contains null values.
+///
+/// This doesn't detect overflow in release mode by default. Once overflowing, the result will
+/// wrap around. For an overflow-checking variant, use `sum_checked` instead.
+pub fn sum<T: ArrowNumericType>(array: &PrimitiveArray<T>) -> Option<T::Native>
+where
+    T::Native: ArrowNativeTypeOp,
+{
+    aggregate::<T::Native, T, SumAccumulator<T::Native>>(array)
+}
+
+/// Returns the minimum value in the array, according to the natural order.
+/// For floating point arrays any NaN values are considered to be greater than any other non-null value
+pub fn min<T: ArrowNumericType>(array: &PrimitiveArray<T>) -> Option<T::Native>
+where
+    T::Native: PartialOrd,
+{
+    aggregate::<T::Native, T, MinAccumulator<T::Native>>(array)
+}
+
+/// Returns the maximum value in the array, according to the natural order.
+/// For floating point arrays any NaN values are considered to be greater than any other non-null value
+pub fn max<T: ArrowNumericType>(array: &PrimitiveArray<T>) -> Option<T::Native>
+where
+    T::Native: PartialOrd,
+{
+    aggregate::<T::Native, T, MaxAccumulator<T::Native>>(array)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::types::*;
+    use arrow_buffer::NullBuffer;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_primitive_array_sum() {
+        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        assert_eq!(15, sum(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_float_sum() {
+        let a = Float64Array::from(vec![1.1, 2.2, 3.3, 4.4, 5.5]);
+        assert_eq!(16.5, sum(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_sum_with_nulls() {
+        let a = Int32Array::from(vec![None, Some(2), Some(3), None, Some(5)]);
+        assert_eq!(10, sum(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_sum_all_nulls() {
+        let a = Int32Array::from(vec![None, None, None]);
+        assert_eq!(None, sum(&a));
+    }
+
+    #[test]
+    fn test_primitive_array_sum_large_float_64() {
+        let c = Float64Array::new((1..=100).map(|x| x as f64).collect(), None);
+        assert_eq!(Some((1..=100).sum::<i64>() as f64), sum(&c));
+
+        // create an array that actually has non-zero values at the invalid indices
+        let validity = NullBuffer::new((1..=100).map(|x| x % 3 == 0).collect());
+        let c = Float64Array::new((1..=100).map(|x| x as f64).collect(), Some(validity));
+
+        assert_eq!(
+            Some((1..=100).filter(|i| i % 3 == 0).sum::<i64>() as f64),
+            sum(&c)
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_sum_large_float_32() {
+        let c = Float32Array::new((1..=100).map(|x| x as f32).collect(), None);
+        assert_eq!(Some((1..=100).sum::<i64>() as f32), sum(&c));
+
+        // create an array that actually has non-zero values at the invalid indices
+        let validity = NullBuffer::new((1..=100).map(|x| x % 3 == 0).collect());
+        let c = Float32Array::new((1..=100).map(|x| x as f32).collect(), Some(validity));
+
+        assert_eq!(
+            Some((1..=100).filter(|i| i % 3 == 0).sum::<i64>() as f32),
+            sum(&c)
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_sum_large_64() {
+        let c = Int64Array::new((1..=100).collect(), None);
+        assert_eq!(Some((1..=100).sum()), sum(&c));
+
+        // create an array that actually has non-zero values at the invalid indices
+        let validity = NullBuffer::new((1..=100).map(|x| x % 3 == 0).collect());
+        let c = Int64Array::new((1..=100).collect(), Some(validity));
+
+        assert_eq!(Some((1..=100).filter(|i| i % 3 == 0).sum()), sum(&c));
+    }
+
+    #[test]
+    fn test_primitive_array_sum_large_32() {
+        let c = Int32Array::new((1..=100).collect(), None);
+        assert_eq!(Some((1..=100).sum()), sum(&c));
+
+        // create an array that actually has non-zero values at the invalid indices
+        let validity = NullBuffer::new((1..=100).map(|x| x % 3 == 0).collect());
+        let c = Int32Array::new((1..=100).collect(), Some(validity));
+        assert_eq!(Some((1..=100).filter(|i| i % 3 == 0).sum()), sum(&c));
+    }
+
+    #[test]
+    fn test_primitive_array_sum_large_16() {
+        let c = Int16Array::new((1..=100).collect(), None);
+        assert_eq!(Some((1..=100).sum()), sum(&c));
+
+        // create an array that actually has non-zero values at the invalid indices
+        let validity = NullBuffer::new((1..=100).map(|x| x % 3 == 0).collect());
+        let c = Int16Array::new((1..=100).collect(), Some(validity));
+        assert_eq!(Some((1..=100).filter(|i| i % 3 == 0).sum()), sum(&c));
+    }
+
+    #[test]
+    fn test_primitive_array_sum_large_8() {
+        let c = UInt8Array::new((1..=100).collect(), None);
+        assert_eq!(
+            Some((1..=100).fold(0_u8, |a, x| a.wrapping_add(x))),
+            sum(&c)
+        );
+
+        // create an array that actually has non-zero values at the invalid indices
+        let validity = NullBuffer::new((1..=100).map(|x| x % 3 == 0).collect());
+        let c = UInt8Array::new((1..=100).collect(), Some(validity));
+        assert_eq!(
+            Some(
+                (1..=100)
+                    .filter(|i| i % 3 == 0)
+                    .fold(0_u8, |a, x| a.wrapping_add(x))
+            ),
+            sum(&c)
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_bit_and() {
+        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        assert_eq!(0, bit_and(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_bit_and_with_nulls() {
+        let a = Int32Array::from(vec![None, Some(2), Some(3), None, None]);
+        assert_eq!(2, bit_and(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_bit_and_all_nulls() {
+        let a = Int32Array::from(vec![None, None, None]);
+        assert_eq!(None, bit_and(&a));
+    }
+
+    #[test]
+    fn test_primitive_array_bit_or() {
+        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        assert_eq!(7, bit_or(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_bit_or_with_nulls() {
+        let a = Int32Array::from(vec![None, Some(2), Some(3), None, Some(5)]);
+        assert_eq!(7, bit_or(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_bit_or_all_nulls() {
+        let a = Int32Array::from(vec![None, None, None]);
+        assert_eq!(None, bit_or(&a));
+    }
+
+    #[test]
+    fn test_primitive_array_bit_xor() {
+        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        assert_eq!(1, bit_xor(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_bit_xor_with_nulls() {
+        let a = Int32Array::from(vec![None, Some(2), Some(3), None, Some(5)]);
+        assert_eq!(4, bit_xor(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_bit_xor_all_nulls() {
+        let a = Int32Array::from(vec![None, None, None]);
+        assert_eq!(None, bit_xor(&a));
+    }
+
+    #[test]
+    fn test_primitive_array_bool_and() {
+        let a = BooleanArray::from(vec![true, false, true, false, true]);
+        assert!(!bool_and(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_bool_and_with_nulls() {
+        let a = BooleanArray::from(vec![None, Some(true), Some(true), None, Some(true)]);
+        assert!(bool_and(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_bool_and_all_nulls() {
+        let a = BooleanArray::from(vec![None, None, None]);
+        assert_eq!(None, bool_and(&a));
+    }
+
+    #[test]
+    fn test_primitive_array_bool_or() {
+        let a = BooleanArray::from(vec![true, false, true, false, true]);
+        assert!(bool_or(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_bool_or_with_nulls() {
+        let a = BooleanArray::from(vec![None, Some(false), Some(false), None, Some(false)]);
+        assert!(!bool_or(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_bool_or_all_nulls() {
+        let a = BooleanArray::from(vec![None, None, None]);
+        assert_eq!(None, bool_or(&a));
+    }
+
+    #[test]
+    fn test_primitive_array_min_max() {
+        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
+        assert_eq!(5, min(&a).unwrap());
+        assert_eq!(9, max(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_min_max_with_nulls() {
+        let a = Int32Array::from(vec![Some(5), None, None, Some(8), Some(9)]);
+        assert_eq!(5, min(&a).unwrap());
+        assert_eq!(9, max(&a).unwrap());
+    }
+
+    #[test]
+    fn test_primitive_min_max_1() {
+        let a = Int32Array::from(vec![None, None, Some(5), Some(2)]);
+        assert_eq!(Some(2), min(&a));
+        assert_eq!(Some(5), max(&a));
+    }
+
+    #[test]
+    fn test_primitive_min_max_float_large_nonnull_array() {
+        let a: Float64Array = (0..256).map(|i| Some((i + 1) as f64)).collect();
+        // min/max are on boundaries of chunked data
+        assert_eq!(Some(1.0), min(&a));
+        assert_eq!(Some(256.0), max(&a));
+
+        // max is last value in remainder after chunking
+        let a: Float64Array = (0..255).map(|i| Some((i + 1) as f64)).collect();
+        assert_eq!(Some(255.0), max(&a));
+
+        // max is first value in remainder after chunking
+        let a: Float64Array = (0..257).map(|i| Some((i + 1) as f64)).collect();
+        assert_eq!(Some(257.0), max(&a));
+    }
+
+    #[test]
+    fn test_primitive_min_max_float_large_nullable_array() {
+        let a: Float64Array = (0..256)
+            .map(|i| {
+                if (i + 1) % 3 == 0 {
+                    None
+                } else {
+                    Some((i + 1) as f64)
+                }
+            })
+            .collect();
+        // min/max are on boundaries of chunked data
+        assert_eq!(Some(1.0), min(&a));
+        assert_eq!(Some(256.0), max(&a));
+
+        let a: Float64Array = (0..256)
+            .map(|i| {
+                if i == 0 || i == 255 {
+                    None
+                } else {
+                    Some((i + 1) as f64)
+                }
+            })
+            .collect();
+        // boundaries of chunked data are null
+        assert_eq!(Some(2.0), min(&a));
+        assert_eq!(Some(255.0), max(&a));
+
+        let a: Float64Array = (0..256)
+            .map(|i| if i != 100 { None } else { Some((i) as f64) })
+            .collect();
+        // a single non-null value somewhere in the middle
+        assert_eq!(Some(100.0), min(&a));
+        assert_eq!(Some(100.0), max(&a));
+
+        // max is last value in remainder after chunking
+        let a: Float64Array = (0..255).map(|i| Some((i + 1) as f64)).collect();
+        assert_eq!(Some(255.0), max(&a));
+
+        // max is first value in remainder after chunking
+        let a: Float64Array = (0..257).map(|i| Some((i + 1) as f64)).collect();
+        assert_eq!(Some(257.0), max(&a));
+    }
+
+    #[test]
+    fn test_primitive_min_max_float_edge_cases() {
+        let a: Float64Array = (0..100).map(|_| Some(f64::NEG_INFINITY)).collect();
+        assert_eq!(Some(f64::NEG_INFINITY), min(&a));
+        assert_eq!(Some(f64::NEG_INFINITY), max(&a));
+
+        let a: Float64Array = (0..100).map(|_| Some(f64::MIN)).collect();
+        assert_eq!(Some(f64::MIN), min(&a));
+        assert_eq!(Some(f64::MIN), max(&a));
+
+        let a: Float64Array = (0..100).map(|_| Some(f64::MAX)).collect();
+        assert_eq!(Some(f64::MAX), min(&a));
+        assert_eq!(Some(f64::MAX), max(&a));
+
+        let a: Float64Array = (0..100).map(|_| Some(f64::INFINITY)).collect();
+        assert_eq!(Some(f64::INFINITY), min(&a));
+        assert_eq!(Some(f64::INFINITY), max(&a));
+    }
+
+    #[test]
+    fn test_primitive_min_max_float_all_nans_non_null() {
+        let a: Float64Array = (0..100).map(|_| Some(f64::NAN)).collect();
+        assert!(max(&a).unwrap().is_nan());
+        assert!(min(&a).unwrap().is_nan());
+    }
+
+    #[test]
+    fn test_primitive_min_max_float_negative_nan() {
+        let a: Float64Array =
+            Float64Array::from(vec![f64::NEG_INFINITY, f64::NAN, f64::INFINITY, -f64::NAN]);
+        let max = max(&a).unwrap();
+        let min = min(&a).unwrap();
+        assert!(max.is_nan());
+        assert!(max.is_sign_positive());
+
+        assert!(min.is_nan());
+        assert!(min.is_sign_negative());
+    }
+
+    #[test]
+    fn test_primitive_min_max_float_first_nan_nonnull() {
+        let a: Float64Array = (0..100)
+            .map(|i| {
+                if i == 0 {
+                    Some(f64::NAN)
+                } else {
+                    Some(i as f64)
+                }
+            })
+            .collect();
+        assert_eq!(Some(1.0), min(&a));
+        assert!(max(&a).unwrap().is_nan());
+    }
+
+    #[test]
+    fn test_primitive_min_max_float_last_nan_nonnull() {
+        let a: Float64Array = (0..100)
+            .map(|i| {
+                if i == 99 {
+                    Some(f64::NAN)
+                } else {
+                    Some((i + 1) as f64)
+                }
+            })
+            .collect();
+        assert_eq!(Some(1.0), min(&a));
+        assert!(max(&a).unwrap().is_nan());
+    }
+
+    #[test]
+    fn test_primitive_min_max_float_first_nan_nullable() {
+        let a: Float64Array = (0..100)
+            .map(|i| {
+                if i == 0 {
+                    Some(f64::NAN)
+                } else if i % 2 == 0 {
+                    None
+                } else {
+                    Some(i as f64)
+                }
+            })
+            .collect();
+        assert_eq!(Some(1.0), min(&a));
+        assert!(max(&a).unwrap().is_nan());
+    }
+
+    #[test]
+    fn test_primitive_min_max_float_last_nan_nullable() {
+        let a: Float64Array = (0..100)
+            .map(|i| {
+                if i == 99 {
+                    Some(f64::NAN)
+                } else if i % 2 == 0 {
+                    None
+                } else {
+                    Some(i as f64)
+                }
+            })
+            .collect();
+        assert_eq!(Some(1.0), min(&a));
+        assert!(max(&a).unwrap().is_nan());
+    }
+
+    #[test]
+    fn test_primitive_min_max_float_inf_and_nans() {
+        let a: Float64Array = (0..100)
+            .map(|i| {
+                let x = match i % 10 {
+                    0 => f64::NEG_INFINITY,
+                    1 => f64::MIN,
+                    2 => f64::MAX,
+                    4 => f64::INFINITY,
+                    5 => f64::NAN,
+                    _ => i as f64,
+                };
+                Some(x)
+            })
+            .collect();
+        assert_eq!(Some(f64::NEG_INFINITY), min(&a));
+        assert!(max(&a).unwrap().is_nan());
+    }
+
+    #[test]
+    fn test_binary_min_max_with_nulls() {
+        let a = BinaryArray::from(vec![
+            Some("b".as_bytes()),
+            None,
+            None,
+            Some(b"a"),
+            Some(b"c"),
+        ]);
+        assert_eq!(Some("a".as_bytes()), min_binary(&a));
+        assert_eq!(Some("c".as_bytes()), max_binary(&a));
+    }
+
+    #[test]
+    fn test_binary_min_max_no_null() {
+        let a = BinaryArray::from(vec![Some("b".as_bytes()), Some(b"a"), Some(b"c")]);
+        assert_eq!(Some("a".as_bytes()), min_binary(&a));
+        assert_eq!(Some("c".as_bytes()), max_binary(&a));
+    }
+
+    #[test]
+    fn test_binary_min_max_all_nulls() {
+        let a = BinaryArray::from(vec![None, None]);
+        assert_eq!(None, min_binary(&a));
+        assert_eq!(None, max_binary(&a));
+    }
+
+    #[test]
+    fn test_binary_min_max_1() {
+        let a = BinaryArray::from(vec![None, None, Some("b".as_bytes()), Some(b"a")]);
+        assert_eq!(Some("a".as_bytes()), min_binary(&a));
+        assert_eq!(Some("b".as_bytes()), max_binary(&a));
+    }
+
+    #[test]
+    fn test_string_min_max_with_nulls() {
+        let a = StringArray::from(vec![Some("b"), None, None, Some("a"), Some("c")]);
+        assert_eq!(Some("a"), min_string(&a));
+        assert_eq!(Some("c"), max_string(&a));
+    }
+
+    #[test]
+    fn test_string_min_max_all_nulls() {
+        let v: Vec<Option<&str>> = vec![None, None];
+        let a = StringArray::from(v);
+        assert_eq!(None, min_string(&a));
+        assert_eq!(None, max_string(&a));
+    }
+
+    #[test]
+    fn test_string_min_max_1() {
+        let a = StringArray::from(vec![None, None, Some("b"), Some("a")]);
+        assert_eq!(Some("a"), min_string(&a));
+        assert_eq!(Some("b"), max_string(&a));
+    }
+
+    #[test]
+    fn test_boolean_min_max_empty() {
+        let a = BooleanArray::from(vec![] as Vec<Option<bool>>);
+        assert_eq!(None, min_boolean(&a));
+        assert_eq!(None, max_boolean(&a));
+    }
+
+    #[test]
+    fn test_boolean_min_max_all_null() {
+        let a = BooleanArray::from(vec![None, None]);
+        assert_eq!(None, min_boolean(&a));
+        assert_eq!(None, max_boolean(&a));
+    }
+
+    #[test]
+    fn test_boolean_min_max_no_null() {
+        let a = BooleanArray::from(vec![Some(true), Some(false), Some(true)]);
+        assert_eq!(Some(false), min_boolean(&a));
+        assert_eq!(Some(true), max_boolean(&a));
+    }
+
+    #[test]
+    fn test_boolean_min_max() {
+        let a = BooleanArray::from(vec![Some(true), Some(true), None, Some(false), None]);
+        assert_eq!(Some(false), min_boolean(&a));
+        assert_eq!(Some(true), max_boolean(&a));
+
+        let a = BooleanArray::from(vec![None, Some(true), None, Some(false), None]);
+        assert_eq!(Some(false), min_boolean(&a));
+        assert_eq!(Some(true), max_boolean(&a));
+
+        let a = BooleanArray::from(vec![Some(false), Some(true), None, Some(false), None]);
+        assert_eq!(Some(false), min_boolean(&a));
+        assert_eq!(Some(true), max_boolean(&a));
+    }
+
+    #[test]
+    fn test_boolean_min_max_smaller() {
+        let a = BooleanArray::from(vec![Some(false)]);
+        assert_eq!(Some(false), min_boolean(&a));
+        assert_eq!(Some(false), max_boolean(&a));
+
+        let a = BooleanArray::from(vec![None, Some(false)]);
+        assert_eq!(Some(false), min_boolean(&a));
+        assert_eq!(Some(false), max_boolean(&a));
+
+        let a = BooleanArray::from(vec![None, Some(true)]);
+        assert_eq!(Some(true), min_boolean(&a));
+        assert_eq!(Some(true), max_boolean(&a));
+
+        let a = BooleanArray::from(vec![Some(true)]);
+        assert_eq!(Some(true), min_boolean(&a));
+        assert_eq!(Some(true), max_boolean(&a));
+    }
+
+    #[test]
+    fn test_sum_dyn() {
+        let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
+        let values = Arc::new(values) as ArrayRef;
+        let keys = Int8Array::from_iter_values([2_i8, 3, 4]);
+
+        let dict_array = DictionaryArray::new(keys, values.clone());
+        let array = dict_array.downcast_dict::<Int8Array>().unwrap();
+        assert_eq!(39, sum_array::<Int8Type, _>(array).unwrap());
+
+        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        assert_eq!(15, sum_array::<Int32Type, _>(&a).unwrap());
+
+        let keys = Int8Array::from(vec![Some(2_i8), None, Some(4)]);
+        let dict_array = DictionaryArray::new(keys, values.clone());
+        let array = dict_array.downcast_dict::<Int8Array>().unwrap();
+        assert_eq!(26, sum_array::<Int8Type, _>(array).unwrap());
+
+        let keys = Int8Array::from(vec![None, None, None]);
+        let dict_array = DictionaryArray::new(keys, values.clone());
+        let array = dict_array.downcast_dict::<Int8Array>().unwrap();
+        assert!(sum_array::<Int8Type, _>(array).is_none());
+    }
+
+    #[test]
+    fn test_max_min_dyn() {
+        let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
+        let keys = Int8Array::from_iter_values([2_i8, 3, 4]);
+        let values = Arc::new(values) as ArrayRef;
+
+        let dict_array = DictionaryArray::new(keys, values.clone());
+        let array = dict_array.downcast_dict::<Int8Array>().unwrap();
+        assert_eq!(14, max_array::<Int8Type, _>(array).unwrap());
+
+        let array = dict_array.downcast_dict::<Int8Array>().unwrap();
+        assert_eq!(12, min_array::<Int8Type, _>(array).unwrap());
+
+        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        assert_eq!(5, max_array::<Int32Type, _>(&a).unwrap());
+        assert_eq!(1, min_array::<Int32Type, _>(&a).unwrap());
+
+        let keys = Int8Array::from(vec![Some(2_i8), None, Some(7)]);
+        let dict_array = DictionaryArray::new(keys, values.clone());
+        let array = dict_array.downcast_dict::<Int8Array>().unwrap();
+        assert_eq!(17, max_array::<Int8Type, _>(array).unwrap());
+        let array = dict_array.downcast_dict::<Int8Array>().unwrap();
+        assert_eq!(12, min_array::<Int8Type, _>(array).unwrap());
+
+        let keys = Int8Array::from(vec![None, None, None]);
+        let dict_array = DictionaryArray::new(keys, values.clone());
+        let array = dict_array.downcast_dict::<Int8Array>().unwrap();
+        assert!(max_array::<Int8Type, _>(array).is_none());
+        let array = dict_array.downcast_dict::<Int8Array>().unwrap();
+        assert!(min_array::<Int8Type, _>(array).is_none());
+    }
+
+    #[test]
+    fn test_max_min_dyn_nan() {
+        let values = Float32Array::from(vec![5.0_f32, 2.0_f32, f32::NAN]);
+        let keys = Int8Array::from_iter_values([0_i8, 1, 2]);
+
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+        let array = dict_array.downcast_dict::<Float32Array>().unwrap();
+        assert!(max_array::<Float32Type, _>(array).unwrap().is_nan());
+
+        let array = dict_array.downcast_dict::<Float32Array>().unwrap();
+        assert_eq!(2.0_f32, min_array::<Float32Type, _>(array).unwrap());
+    }
+
+    #[test]
+    fn test_min_max_sliced_primitive() {
+        let expected = Some(4.0);
+        let input: Float64Array = vec![None, Some(4.0)].into_iter().collect();
+        let actual = min(&input);
+        assert_eq!(actual, expected);
+        let actual = max(&input);
+        assert_eq!(actual, expected);
+
+        let sliced_input: Float64Array = vec![None, None, None, None, None, Some(4.0)]
+            .into_iter()
+            .collect();
+        let sliced_input = sliced_input.slice(4, 2);
+
+        assert_eq!(&sliced_input, &input);
+
+        let actual = min(&sliced_input);
+        assert_eq!(actual, expected);
+        let actual = max(&sliced_input);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_min_max_sliced_boolean() {
+        let expected = Some(true);
+        let input: BooleanArray = vec![None, Some(true)].into_iter().collect();
+        let actual = min_boolean(&input);
+        assert_eq!(actual, expected);
+        let actual = max_boolean(&input);
+        assert_eq!(actual, expected);
+
+        let sliced_input: BooleanArray = vec![None, None, None, None, None, Some(true)]
+            .into_iter()
+            .collect();
+        let sliced_input = sliced_input.slice(4, 2);
+
+        assert_eq!(sliced_input, input);
+
+        let actual = min_boolean(&sliced_input);
+        assert_eq!(actual, expected);
+        let actual = max_boolean(&sliced_input);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_min_max_sliced_string() {
+        let expected = Some("foo");
+        let input: StringArray = vec![None, Some("foo")].into_iter().collect();
+        let actual = min_string(&input);
+        assert_eq!(actual, expected);
+        let actual = max_string(&input);
+        assert_eq!(actual, expected);
+
+        let sliced_input: StringArray = vec![None, None, None, None, None, Some("foo")]
+            .into_iter()
+            .collect();
+        let sliced_input = sliced_input.slice(4, 2);
+
+        assert_eq!(&sliced_input, &input);
+
+        let actual = min_string(&sliced_input);
+        assert_eq!(actual, expected);
+        let actual = max_string(&sliced_input);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_min_max_sliced_binary() {
+        let expected: Option<&[u8]> = Some(&[5]);
+        let input: BinaryArray = vec![None, Some(&[5])].into_iter().collect();
+        let actual = min_binary(&input);
+        assert_eq!(actual, expected);
+        let actual = max_binary(&input);
+        assert_eq!(actual, expected);
+
+        let sliced_input: BinaryArray = vec![None, None, None, None, None, Some(&[5])]
+            .into_iter()
+            .collect();
+        let sliced_input = sliced_input.slice(4, 2);
+
+        assert_eq!(&sliced_input, &input);
+
+        let actual = min_binary(&sliced_input);
+        assert_eq!(actual, expected);
+        let actual = max_binary(&sliced_input);
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_sum_overflow() {
+        let a = Int32Array::from(vec![i32::MAX, 1]);
+
+        assert_eq!(sum(&a).unwrap(), -2147483648);
+        assert_eq!(sum_array::<Int32Type, _>(&a).unwrap(), -2147483648);
+    }
+
+    #[test]
+    fn test_sum_checked_overflow() {
+        let a = Int32Array::from(vec![i32::MAX, 1]);
+
+        sum_checked(&a).expect_err("overflow should be detected");
+        sum_array_checked::<Int32Type, _>(&a).expect_err("overflow should be detected");
+    }
+}
diff --git a/arrow-arith/src/arithmetic.rs b/arrow-arith/src/arithmetic.rs
new file mode 100644
index 000000000000..124614d77f97
--- /dev/null
+++ b/arrow-arith/src/arithmetic.rs
@@ -0,0 +1,341 @@
+// 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.
+
+//! Defines basic arithmetic kernels for `PrimitiveArrays`.
+//!
+//! These kernels can leverage SIMD if available on your system.  Currently no runtime
+//! detection is provided, you should enable the specific SIMD intrinsics using
+//! `RUSTFLAGS="-C target-feature=+avx2"` for example.  See the documentation
+//! [here](https://doc.rust-lang.org/stable/core/arch/) for more information.
+
+use crate::arity::*;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::i256;
+use arrow_buffer::ArrowNativeType;
+use arrow_schema::*;
+use std::cmp::min;
+use std::sync::Arc;
+
+/// Returns the precision and scale of the result of a multiplication of two decimal types,
+/// and the divisor for fixed point multiplication.
+fn get_fixed_point_info(
+    left: (u8, i8),
+    right: (u8, i8),
+    required_scale: i8,
+) -> Result<(u8, i8, i256), ArrowError> {
+    let product_scale = left.1 + right.1;
+    let precision = min(left.0 + right.0 + 1, DECIMAL128_MAX_PRECISION);
+
+    if required_scale > product_scale {
+        return Err(ArrowError::ComputeError(format!(
+            "Required scale {} is greater than product scale {}",
+            required_scale, product_scale
+        )));
+    }
+
+    let divisor = i256::from_i128(10).pow_wrapping((product_scale - required_scale) as u32);
+
+    Ok((precision, product_scale, divisor))
+}
+
+/// Perform `left * right` operation on two decimal arrays. If either left or right value is
+/// null then the result is also null.
+///
+/// This performs decimal multiplication which allows precision loss if an exact representation
+/// is not possible for the result, according to the required scale. In the case, the result
+/// will be rounded to the required scale.
+///
+/// If the required scale is greater than the product scale, an error is returned.
+///
+/// This doesn't detect overflow. Once overflowing, the result will wrap around.
+///
+/// It is implemented for compatibility with precision loss `multiply` function provided by
+/// other data processing engines. For multiplication with precision loss detection, use
+/// `multiply_dyn` or `multiply_dyn_checked` instead.
+pub fn multiply_fixed_point_dyn(
+    left: &dyn Array,
+    right: &dyn Array,
+    required_scale: i8,
+) -> Result<ArrayRef, ArrowError> {
+    match (left.data_type(), right.data_type()) {
+        (DataType::Decimal128(_, _), DataType::Decimal128(_, _)) => {
+            let left = left.as_any().downcast_ref::<Decimal128Array>().unwrap();
+            let right = right.as_any().downcast_ref::<Decimal128Array>().unwrap();
+
+            multiply_fixed_point(left, right, required_scale).map(|a| Arc::new(a) as ArrayRef)
+        }
+        (_, _) => Err(ArrowError::CastError(format!(
+            "Unsupported data type {}, {}",
+            left.data_type(),
+            right.data_type()
+        ))),
+    }
+}
+
+/// Perform `left * right` operation on two decimal arrays. If either left or right value is
+/// null then the result is also null.
+///
+/// This performs decimal multiplication which allows precision loss if an exact representation
+/// is not possible for the result, according to the required scale. In the case, the result
+/// will be rounded to the required scale.
+///
+/// If the required scale is greater than the product scale, an error is returned.
+///
+/// It is implemented for compatibility with precision loss `multiply` function provided by
+/// other data processing engines. For multiplication with precision loss detection, use
+/// `multiply` or `multiply_checked` instead.
+pub fn multiply_fixed_point_checked(
+    left: &PrimitiveArray<Decimal128Type>,
+    right: &PrimitiveArray<Decimal128Type>,
+    required_scale: i8,
+) -> Result<PrimitiveArray<Decimal128Type>, ArrowError> {
+    let (precision, product_scale, divisor) = get_fixed_point_info(
+        (left.precision(), left.scale()),
+        (right.precision(), right.scale()),
+        required_scale,
+    )?;
+
+    if required_scale == product_scale {
+        return try_binary::<_, _, _, Decimal128Type>(left, right, |a, b| a.mul_checked(b))?
+            .with_precision_and_scale(precision, required_scale);
+    }
+
+    try_binary::<_, _, _, Decimal128Type>(left, right, |a, b| {
+        let a = i256::from_i128(a);
+        let b = i256::from_i128(b);
+
+        let mut mul = a.wrapping_mul(b);
+        mul = divide_and_round::<Decimal256Type>(mul, divisor);
+        mul.to_i128().ok_or_else(|| {
+            ArrowError::ComputeError(format!("Overflow happened on: {:?} * {:?}", a, b))
+        })
+    })
+    .and_then(|a| a.with_precision_and_scale(precision, required_scale))
+}
+
+/// Perform `left * right` operation on two decimal arrays. If either left or right value is
+/// null then the result is also null.
+///
+/// This performs decimal multiplication which allows precision loss if an exact representation
+/// is not possible for the result, according to the required scale. In the case, the result
+/// will be rounded to the required scale.
+///
+/// If the required scale is greater than the product scale, an error is returned.
+///
+/// This doesn't detect overflow. Once overflowing, the result will wrap around.
+/// For an overflow-checking variant, use `multiply_fixed_point_checked` instead.
+///
+/// It is implemented for compatibility with precision loss `multiply` function provided by
+/// other data processing engines. For multiplication with precision loss detection, use
+/// `multiply` or `multiply_checked` instead.
+pub fn multiply_fixed_point(
+    left: &PrimitiveArray<Decimal128Type>,
+    right: &PrimitiveArray<Decimal128Type>,
+    required_scale: i8,
+) -> Result<PrimitiveArray<Decimal128Type>, ArrowError> {
+    let (precision, product_scale, divisor) = get_fixed_point_info(
+        (left.precision(), left.scale()),
+        (right.precision(), right.scale()),
+        required_scale,
+    )?;
+
+    if required_scale == product_scale {
+        return binary(left, right, |a, b| a.mul_wrapping(b))?
+            .with_precision_and_scale(precision, required_scale);
+    }
+
+    binary::<_, _, _, Decimal128Type>(left, right, |a, b| {
+        let a = i256::from_i128(a);
+        let b = i256::from_i128(b);
+
+        let mut mul = a.wrapping_mul(b);
+        mul = divide_and_round::<Decimal256Type>(mul, divisor);
+        mul.as_i128()
+    })
+    .and_then(|a| a.with_precision_and_scale(precision, required_scale))
+}
+
+/// Divide a decimal native value by given divisor and round the result.
+fn divide_and_round<I>(input: I::Native, div: I::Native) -> I::Native
+where
+    I: DecimalType,
+    I::Native: ArrowNativeTypeOp,
+{
+    let d = input.div_wrapping(div);
+    let r = input.mod_wrapping(div);
+
+    let half = div.div_wrapping(I::Native::from_usize(2).unwrap());
+    let half_neg = half.neg_wrapping();
+
+    // Round result
+    match input >= I::Native::ZERO {
+        true if r >= half => d.add_wrapping(I::Native::ONE),
+        false if r <= half_neg => d.sub_wrapping(I::Native::ONE),
+        _ => d,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::numeric::mul;
+
+    #[test]
+    fn test_decimal_multiply_allow_precision_loss() {
+        // Overflow happening as i128 cannot hold multiplying result.
+        // [123456789]
+        let a = Decimal128Array::from(vec![123456789000000000000000000])
+            .with_precision_and_scale(38, 18)
+            .unwrap();
+
+        // [10]
+        let b = Decimal128Array::from(vec![10000000000000000000])
+            .with_precision_and_scale(38, 18)
+            .unwrap();
+
+        let err = mul(&a, &b).unwrap_err();
+        assert!(err
+            .to_string()
+            .contains("Overflow happened on: 123456789000000000000000000 * 10000000000000000000"));
+
+        // Allow precision loss.
+        let result = multiply_fixed_point_checked(&a, &b, 28).unwrap();
+        // [1234567890]
+        let expected = Decimal128Array::from(vec![12345678900000000000000000000000000000])
+            .with_precision_and_scale(38, 28)
+            .unwrap();
+
+        assert_eq!(&expected, &result);
+        assert_eq!(
+            result.value_as_string(0),
+            "1234567890.0000000000000000000000000000"
+        );
+
+        // Rounding case
+        // [0.000000000000000001, 123456789.555555555555555555, 1.555555555555555555]
+        let a = Decimal128Array::from(vec![1, 123456789555555555555555555, 1555555555555555555])
+            .with_precision_and_scale(38, 18)
+            .unwrap();
+
+        // [1.555555555555555555, 11.222222222222222222, 0.000000000000000001]
+        let b = Decimal128Array::from(vec![1555555555555555555, 11222222222222222222, 1])
+            .with_precision_and_scale(38, 18)
+            .unwrap();
+
+        let result = multiply_fixed_point_checked(&a, &b, 28).unwrap();
+        // [
+        //    0.0000000000000000015555555556,
+        //    1385459527.2345679012071330528765432099,
+        //    0.0000000000000000015555555556
+        // ]
+        let expected = Decimal128Array::from(vec![
+            15555555556,
+            13854595272345679012071330528765432099,
+            15555555556,
+        ])
+        .with_precision_and_scale(38, 28)
+        .unwrap();
+
+        assert_eq!(&expected, &result);
+
+        // Rounded the value "1385459527.234567901207133052876543209876543210".
+        assert_eq!(
+            result.value_as_string(1),
+            "1385459527.2345679012071330528765432099"
+        );
+        assert_eq!(result.value_as_string(0), "0.0000000000000000015555555556");
+        assert_eq!(result.value_as_string(2), "0.0000000000000000015555555556");
+
+        let a = Decimal128Array::from(vec![1230])
+            .with_precision_and_scale(4, 2)
+            .unwrap();
+
+        let b = Decimal128Array::from(vec![1000])
+            .with_precision_and_scale(4, 2)
+            .unwrap();
+
+        // Required scale is same as the product of the input scales. Behavior is same as multiply.
+        let result = multiply_fixed_point_checked(&a, &b, 4).unwrap();
+        assert_eq!(result.precision(), 9);
+        assert_eq!(result.scale(), 4);
+
+        let expected = mul(&a, &b).unwrap();
+        assert_eq!(expected.as_ref(), &result);
+
+        // Required scale cannot be larger than the product of the input scales.
+        let result = multiply_fixed_point_checked(&a, &b, 5).unwrap_err();
+        assert!(result
+            .to_string()
+            .contains("Required scale 5 is greater than product scale 4"));
+    }
+
+    #[test]
+    fn test_decimal_multiply_allow_precision_loss_overflow() {
+        // [99999999999123456789]
+        let a = Decimal128Array::from(vec![99999999999123456789000000000000000000])
+            .with_precision_and_scale(38, 18)
+            .unwrap();
+
+        // [9999999999910]
+        let b = Decimal128Array::from(vec![9999999999910000000000000000000])
+            .with_precision_and_scale(38, 18)
+            .unwrap();
+
+        let err = multiply_fixed_point_checked(&a, &b, 28).unwrap_err();
+        assert!(err.to_string().contains(
+            "Overflow happened on: 99999999999123456789000000000000000000 * 9999999999910000000000000000000"
+        ));
+
+        let result = multiply_fixed_point(&a, &b, 28).unwrap();
+        let expected = Decimal128Array::from(vec![62946009661555981610246871926660136960])
+            .with_precision_and_scale(38, 28)
+            .unwrap();
+
+        assert_eq!(&expected, &result);
+    }
+
+    #[test]
+    fn test_decimal_multiply_fixed_point() {
+        // [123456789]
+        let a = Decimal128Array::from(vec![123456789000000000000000000])
+            .with_precision_and_scale(38, 18)
+            .unwrap();
+
+        // [10]
+        let b = Decimal128Array::from(vec![10000000000000000000])
+            .with_precision_and_scale(38, 18)
+            .unwrap();
+
+        // `multiply` overflows on this case.
+        let err = mul(&a, &b).unwrap_err();
+        assert_eq!(err.to_string(), "Compute error: Overflow happened on: 123456789000000000000000000 * 10000000000000000000");
+
+        // Avoid overflow by reducing the scale.
+        let result = multiply_fixed_point(&a, &b, 28).unwrap();
+        // [1234567890]
+        let expected = Decimal128Array::from(vec![12345678900000000000000000000000000000])
+            .with_precision_and_scale(38, 28)
+            .unwrap();
+
+        assert_eq!(&expected, &result);
+        assert_eq!(
+            result.value_as_string(0),
+            "1234567890.0000000000000000000000000000"
+        );
+    }
+}
diff --git a/arrow-arith/src/arity.rs b/arrow-arith/src/arity.rs
new file mode 100644
index 000000000000..3d8214d89dc3
--- /dev/null
+++ b/arrow-arith/src/arity.rs
@@ -0,0 +1,544 @@
+// 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.
+
+//! Defines kernels suitable to perform operations to primitive arrays.
+
+use arrow_array::builder::BufferBuilder;
+use arrow_array::types::ArrowDictionaryKeyType;
+use arrow_array::*;
+use arrow_buffer::buffer::NullBuffer;
+use arrow_buffer::{Buffer, MutableBuffer};
+use arrow_data::ArrayData;
+use arrow_schema::ArrowError;
+use std::sync::Arc;
+
+/// See [`PrimitiveArray::unary`]
+pub fn unary<I, F, O>(array: &PrimitiveArray<I>, op: F) -> PrimitiveArray<O>
+where
+    I: ArrowPrimitiveType,
+    O: ArrowPrimitiveType,
+    F: Fn(I::Native) -> O::Native,
+{
+    array.unary(op)
+}
+
+/// See [`PrimitiveArray::unary_mut`]
+pub fn unary_mut<I, F>(
+    array: PrimitiveArray<I>,
+    op: F,
+) -> Result<PrimitiveArray<I>, PrimitiveArray<I>>
+where
+    I: ArrowPrimitiveType,
+    F: Fn(I::Native) -> I::Native,
+{
+    array.unary_mut(op)
+}
+
+/// See [`PrimitiveArray::try_unary`]
+pub fn try_unary<I, F, O>(array: &PrimitiveArray<I>, op: F) -> Result<PrimitiveArray<O>, ArrowError>
+where
+    I: ArrowPrimitiveType,
+    O: ArrowPrimitiveType,
+    F: Fn(I::Native) -> Result<O::Native, ArrowError>,
+{
+    array.try_unary(op)
+}
+
+/// See [`PrimitiveArray::try_unary_mut`]
+pub fn try_unary_mut<I, F>(
+    array: PrimitiveArray<I>,
+    op: F,
+) -> Result<Result<PrimitiveArray<I>, ArrowError>, PrimitiveArray<I>>
+where
+    I: ArrowPrimitiveType,
+    F: Fn(I::Native) -> Result<I::Native, ArrowError>,
+{
+    array.try_unary_mut(op)
+}
+
+/// A helper function that applies an infallible unary function to a dictionary array with primitive value type.
+fn unary_dict<K, F, T>(array: &DictionaryArray<K>, op: F) -> Result<ArrayRef, ArrowError>
+where
+    K: ArrowDictionaryKeyType + ArrowNumericType,
+    T: ArrowPrimitiveType,
+    F: Fn(T::Native) -> T::Native,
+{
+    let dict_values = array.values().as_any().downcast_ref().unwrap();
+    let values = unary::<T, F, T>(dict_values, op);
+    Ok(Arc::new(array.with_values(Arc::new(values))))
+}
+
+/// A helper function that applies a fallible unary function to a dictionary array with primitive value type.
+fn try_unary_dict<K, F, T>(array: &DictionaryArray<K>, op: F) -> Result<ArrayRef, ArrowError>
+where
+    K: ArrowDictionaryKeyType + ArrowNumericType,
+    T: ArrowPrimitiveType,
+    F: Fn(T::Native) -> Result<T::Native, ArrowError>,
+{
+    if !PrimitiveArray::<T>::is_compatible(&array.value_type()) {
+        return Err(ArrowError::CastError(format!(
+            "Cannot perform the unary operation of type {} on dictionary array of value type {}",
+            T::DATA_TYPE,
+            array.value_type()
+        )));
+    }
+
+    let dict_values = array.values().as_any().downcast_ref().unwrap();
+    let values = try_unary::<T, F, T>(dict_values, op)?;
+    Ok(Arc::new(array.with_values(Arc::new(values))))
+}
+
+/// Applies an infallible unary function to an array with primitive values.
+#[deprecated(note = "Use arrow_array::AnyDictionaryArray")]
+pub fn unary_dyn<F, T>(array: &dyn Array, op: F) -> Result<ArrayRef, ArrowError>
+where
+    T: ArrowPrimitiveType,
+    F: Fn(T::Native) -> T::Native,
+{
+    downcast_dictionary_array! {
+        array => unary_dict::<_, F, T>(array, op),
+        t => {
+            if PrimitiveArray::<T>::is_compatible(t) {
+                Ok(Arc::new(unary::<T, F, T>(
+                    array.as_any().downcast_ref::<PrimitiveArray<T>>().unwrap(),
+                    op,
+                )))
+            } else {
+                Err(ArrowError::NotYetImplemented(format!(
+                    "Cannot perform unary operation of type {} on array of type {}",
+                    T::DATA_TYPE,
+                    t
+                )))
+            }
+        }
+    }
+}
+
+/// Applies a fallible unary function to an array with primitive values.
+#[deprecated(note = "Use arrow_array::AnyDictionaryArray")]
+pub fn try_unary_dyn<F, T>(array: &dyn Array, op: F) -> Result<ArrayRef, ArrowError>
+where
+    T: ArrowPrimitiveType,
+    F: Fn(T::Native) -> Result<T::Native, ArrowError>,
+{
+    downcast_dictionary_array! {
+        array => if array.values().data_type() == &T::DATA_TYPE {
+            try_unary_dict::<_, F, T>(array, op)
+        } else {
+            Err(ArrowError::NotYetImplemented(format!(
+                "Cannot perform unary operation on dictionary array of type {}",
+                array.data_type()
+            )))
+        },
+        t => {
+            if PrimitiveArray::<T>::is_compatible(t) {
+                Ok(Arc::new(try_unary::<T, F, T>(
+                    array.as_any().downcast_ref::<PrimitiveArray<T>>().unwrap(),
+                    op,
+                )?))
+            } else {
+                Err(ArrowError::NotYetImplemented(format!(
+                    "Cannot perform unary operation of type {} on array of type {}",
+                    T::DATA_TYPE,
+                    t
+                )))
+            }
+        }
+    }
+}
+
+/// Given two arrays of length `len`, calls `op(a[i], b[i])` for `i` in `0..len`, collecting
+/// the results in a [`PrimitiveArray`]. If any index is null in either `a` or `b`, the
+/// corresponding index in the result will also be null
+///
+/// Like [`unary`] the provided function is evaluated for every index, ignoring validity. This
+/// is beneficial when the cost of the operation is low compared to the cost of branching, and
+/// especially when the operation can be vectorised, however, requires `op` to be infallible
+/// for all possible values of its inputs
+///
+/// # Error
+///
+/// This function gives error if the arrays have different lengths
+pub fn binary<A, B, F, O>(
+    a: &PrimitiveArray<A>,
+    b: &PrimitiveArray<B>,
+    op: F,
+) -> Result<PrimitiveArray<O>, ArrowError>
+where
+    A: ArrowPrimitiveType,
+    B: ArrowPrimitiveType,
+    O: ArrowPrimitiveType,
+    F: Fn(A::Native, B::Native) -> O::Native,
+{
+    if a.len() != b.len() {
+        return Err(ArrowError::ComputeError(
+            "Cannot perform binary operation on arrays of different length".to_string(),
+        ));
+    }
+
+    if a.is_empty() {
+        return Ok(PrimitiveArray::from(ArrayData::new_empty(&O::DATA_TYPE)));
+    }
+
+    let nulls = NullBuffer::union(a.logical_nulls().as_ref(), b.logical_nulls().as_ref());
+
+    let values = a.values().iter().zip(b.values()).map(|(l, r)| op(*l, *r));
+    // JUSTIFICATION
+    //  Benefit
+    //      ~60% speedup
+    //  Soundness
+    //      `values` is an iterator with a known size from a PrimitiveArray
+    let buffer = unsafe { Buffer::from_trusted_len_iter(values) };
+    Ok(PrimitiveArray::new(buffer.into(), nulls))
+}
+
+/// Given two arrays of length `len`, calls `op(a[i], b[i])` for `i` in `0..len`, mutating
+/// the mutable [`PrimitiveArray`] `a`. If any index is null in either `a` or `b`, the
+/// corresponding index in the result will also be null.
+///
+/// Mutable primitive array means that the buffer is not shared with other arrays.
+/// As a result, this mutates the buffer directly without allocating new buffer.
+///
+/// Like [`unary`] the provided function is evaluated for every index, ignoring validity. This
+/// is beneficial when the cost of the operation is low compared to the cost of branching, and
+/// especially when the operation can be vectorised, however, requires `op` to be infallible
+/// for all possible values of its inputs
+///
+/// # Error
+///
+/// This function gives error if the arrays have different lengths.
+/// This function gives error of original [`PrimitiveArray`] `a` if it is not a mutable
+/// primitive array.
+pub fn binary_mut<T, F>(
+    a: PrimitiveArray<T>,
+    b: &PrimitiveArray<T>,
+    op: F,
+) -> Result<Result<PrimitiveArray<T>, ArrowError>, PrimitiveArray<T>>
+where
+    T: ArrowPrimitiveType,
+    F: Fn(T::Native, T::Native) -> T::Native,
+{
+    if a.len() != b.len() {
+        return Ok(Err(ArrowError::ComputeError(
+            "Cannot perform binary operation on arrays of different length".to_string(),
+        )));
+    }
+
+    if a.is_empty() {
+        return Ok(Ok(PrimitiveArray::from(ArrayData::new_empty(
+            &T::DATA_TYPE,
+        ))));
+    }
+
+    let nulls = NullBuffer::union(a.logical_nulls().as_ref(), b.logical_nulls().as_ref());
+
+    let mut builder = a.into_builder()?;
+
+    builder
+        .values_slice_mut()
+        .iter_mut()
+        .zip(b.values())
+        .for_each(|(l, r)| *l = op(*l, *r));
+
+    let array_builder = builder.finish().into_data().into_builder().nulls(nulls);
+
+    let array_data = unsafe { array_builder.build_unchecked() };
+    Ok(Ok(PrimitiveArray::<T>::from(array_data)))
+}
+
+/// Applies the provided fallible binary operation across `a` and `b`, returning any error,
+/// and collecting the results into a [`PrimitiveArray`]. If any index is null in either `a`
+/// or `b`, the corresponding index in the result will also be null
+///
+/// Like [`try_unary`] the function is only evaluated for non-null indices
+///
+/// # Error
+///
+/// Return an error if the arrays have different lengths or
+/// the operation is under erroneous
+pub fn try_binary<A: ArrayAccessor, B: ArrayAccessor, F, O>(
+    a: A,
+    b: B,
+    op: F,
+) -> Result<PrimitiveArray<O>, ArrowError>
+where
+    O: ArrowPrimitiveType,
+    F: Fn(A::Item, B::Item) -> Result<O::Native, ArrowError>,
+{
+    if a.len() != b.len() {
+        return Err(ArrowError::ComputeError(
+            "Cannot perform a binary operation on arrays of different length".to_string(),
+        ));
+    }
+    if a.is_empty() {
+        return Ok(PrimitiveArray::from(ArrayData::new_empty(&O::DATA_TYPE)));
+    }
+    let len = a.len();
+
+    if a.null_count() == 0 && b.null_count() == 0 {
+        try_binary_no_nulls(len, a, b, op)
+    } else {
+        let nulls =
+            NullBuffer::union(a.logical_nulls().as_ref(), b.logical_nulls().as_ref()).unwrap();
+
+        let mut buffer = BufferBuilder::<O::Native>::new(len);
+        buffer.append_n_zeroed(len);
+        let slice = buffer.as_slice_mut();
+
+        nulls.try_for_each_valid_idx(|idx| {
+            unsafe {
+                *slice.get_unchecked_mut(idx) = op(a.value_unchecked(idx), b.value_unchecked(idx))?
+            };
+            Ok::<_, ArrowError>(())
+        })?;
+
+        let values = buffer.finish().into();
+        Ok(PrimitiveArray::new(values, Some(nulls)))
+    }
+}
+
+/// Applies the provided fallible binary operation across `a` and `b` by mutating the mutable
+/// [`PrimitiveArray`] `a` with the results, returning any error. If any index is null in
+/// either `a` or `b`, the corresponding index in the result will also be null
+///
+/// Like [`try_unary`] the function is only evaluated for non-null indices
+///
+/// Mutable primitive array means that the buffer is not shared with other arrays.
+/// As a result, this mutates the buffer directly without allocating new buffer.
+///
+/// # Error
+///
+/// Return an error if the arrays have different lengths or
+/// the operation is under erroneous.
+/// This function gives error of original [`PrimitiveArray`] `a` if it is not a mutable
+/// primitive array.
+pub fn try_binary_mut<T, F>(
+    a: PrimitiveArray<T>,
+    b: &PrimitiveArray<T>,
+    op: F,
+) -> Result<Result<PrimitiveArray<T>, ArrowError>, PrimitiveArray<T>>
+where
+    T: ArrowPrimitiveType,
+    F: Fn(T::Native, T::Native) -> Result<T::Native, ArrowError>,
+{
+    if a.len() != b.len() {
+        return Ok(Err(ArrowError::ComputeError(
+            "Cannot perform binary operation on arrays of different length".to_string(),
+        )));
+    }
+    let len = a.len();
+
+    if a.is_empty() {
+        return Ok(Ok(PrimitiveArray::from(ArrayData::new_empty(
+            &T::DATA_TYPE,
+        ))));
+    }
+
+    if a.null_count() == 0 && b.null_count() == 0 {
+        try_binary_no_nulls_mut(len, a, b, op)
+    } else {
+        let nulls =
+            NullBuffer::union(a.logical_nulls().as_ref(), b.logical_nulls().as_ref()).unwrap();
+
+        let mut builder = a.into_builder()?;
+
+        let slice = builder.values_slice_mut();
+
+        let r = nulls.try_for_each_valid_idx(|idx| {
+            unsafe {
+                *slice.get_unchecked_mut(idx) =
+                    op(*slice.get_unchecked(idx), b.value_unchecked(idx))?
+            };
+            Ok::<_, ArrowError>(())
+        });
+        if let Err(err) = r {
+            return Ok(Err(err));
+        }
+        let array_builder = builder.finish().into_data().into_builder();
+        let array_data = unsafe { array_builder.nulls(Some(nulls)).build_unchecked() };
+        Ok(Ok(PrimitiveArray::<T>::from(array_data)))
+    }
+}
+
+/// This intentional inline(never) attribute helps LLVM optimize the loop.
+#[inline(never)]
+fn try_binary_no_nulls<A: ArrayAccessor, B: ArrayAccessor, F, O>(
+    len: usize,
+    a: A,
+    b: B,
+    op: F,
+) -> Result<PrimitiveArray<O>, ArrowError>
+where
+    O: ArrowPrimitiveType,
+    F: Fn(A::Item, B::Item) -> Result<O::Native, ArrowError>,
+{
+    let mut buffer = MutableBuffer::new(len * O::get_byte_width());
+    for idx in 0..len {
+        unsafe {
+            buffer.push_unchecked(op(a.value_unchecked(idx), b.value_unchecked(idx))?);
+        };
+    }
+    Ok(PrimitiveArray::new(buffer.into(), None))
+}
+
+/// This intentional inline(never) attribute helps LLVM optimize the loop.
+#[inline(never)]
+fn try_binary_no_nulls_mut<T, F>(
+    len: usize,
+    a: PrimitiveArray<T>,
+    b: &PrimitiveArray<T>,
+    op: F,
+) -> Result<Result<PrimitiveArray<T>, ArrowError>, PrimitiveArray<T>>
+where
+    T: ArrowPrimitiveType,
+    F: Fn(T::Native, T::Native) -> Result<T::Native, ArrowError>,
+{
+    let mut builder = a.into_builder()?;
+    let slice = builder.values_slice_mut();
+
+    for idx in 0..len {
+        unsafe {
+            match op(*slice.get_unchecked(idx), b.value_unchecked(idx)) {
+                Ok(value) => *slice.get_unchecked_mut(idx) = value,
+                Err(err) => return Ok(Err(err)),
+            };
+        };
+    }
+    Ok(Ok(builder.finish()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::builder::*;
+    use arrow_array::types::*;
+
+    #[test]
+    #[allow(deprecated)]
+    fn test_unary_f64_slice() {
+        let input = Float64Array::from(vec![Some(5.1f64), None, Some(6.8), None, Some(7.2)]);
+        let input_slice = input.slice(1, 4);
+        let result = unary(&input_slice, |n| n.round());
+        assert_eq!(
+            result,
+            Float64Array::from(vec![None, Some(7.0), None, Some(7.0)])
+        );
+
+        let result = unary_dyn::<_, Float64Type>(&input_slice, |n| n + 1.0).unwrap();
+
+        assert_eq!(
+            result.as_any().downcast_ref::<Float64Array>().unwrap(),
+            &Float64Array::from(vec![None, Some(7.8), None, Some(8.2)])
+        );
+    }
+
+    #[test]
+    #[allow(deprecated)]
+    fn test_unary_dict_and_unary_dyn() {
+        let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::new();
+        builder.append(5).unwrap();
+        builder.append(6).unwrap();
+        builder.append(7).unwrap();
+        builder.append(8).unwrap();
+        builder.append_null();
+        builder.append(9).unwrap();
+        let dictionary_array = builder.finish();
+
+        let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::new();
+        builder.append(6).unwrap();
+        builder.append(7).unwrap();
+        builder.append(8).unwrap();
+        builder.append(9).unwrap();
+        builder.append_null();
+        builder.append(10).unwrap();
+        let expected = builder.finish();
+
+        let result = unary_dict::<_, _, Int32Type>(&dictionary_array, |n| n + 1).unwrap();
+        assert_eq!(
+            result
+                .as_any()
+                .downcast_ref::<DictionaryArray<Int8Type>>()
+                .unwrap(),
+            &expected
+        );
+
+        let result = unary_dyn::<_, Int32Type>(&dictionary_array, |n| n + 1).unwrap();
+        assert_eq!(
+            result
+                .as_any()
+                .downcast_ref::<DictionaryArray<Int8Type>>()
+                .unwrap(),
+            &expected
+        );
+    }
+
+    #[test]
+    fn test_binary_mut() {
+        let a = Int32Array::from(vec![15, 14, 9, 8, 1]);
+        let b = Int32Array::from(vec![Some(1), None, Some(3), None, Some(5)]);
+        let c = binary_mut(a, &b, |l, r| l + r).unwrap().unwrap();
+
+        let expected = Int32Array::from(vec![Some(16), None, Some(12), None, Some(6)]);
+        assert_eq!(c, expected);
+    }
+
+    #[test]
+    fn test_try_binary_mut() {
+        let a = Int32Array::from(vec![15, 14, 9, 8, 1]);
+        let b = Int32Array::from(vec![Some(1), None, Some(3), None, Some(5)]);
+        let c = try_binary_mut(a, &b, |l, r| Ok(l + r)).unwrap().unwrap();
+
+        let expected = Int32Array::from(vec![Some(16), None, Some(12), None, Some(6)]);
+        assert_eq!(c, expected);
+
+        let a = Int32Array::from(vec![15, 14, 9, 8, 1]);
+        let b = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        let c = try_binary_mut(a, &b, |l, r| Ok(l + r)).unwrap().unwrap();
+        let expected = Int32Array::from(vec![16, 16, 12, 12, 6]);
+        assert_eq!(c, expected);
+
+        let a = Int32Array::from(vec![15, 14, 9, 8, 1]);
+        let b = Int32Array::from(vec![Some(1), None, Some(3), None, Some(5)]);
+        let _ = try_binary_mut(a, &b, |l, r| {
+            if l == 1 {
+                Err(ArrowError::InvalidArgumentError(
+                    "got error".parse().unwrap(),
+                ))
+            } else {
+                Ok(l + r)
+            }
+        })
+        .unwrap()
+        .expect_err("should got error");
+    }
+
+    #[test]
+    fn test_unary_dict_mut() {
+        let values = Int32Array::from(vec![Some(10), Some(20), None]);
+        let keys = Int8Array::from_iter_values([0, 0, 1, 2]);
+        let dictionary = DictionaryArray::new(keys, Arc::new(values));
+
+        let updated = dictionary.unary_mut::<_, Int32Type>(|x| x + 1).unwrap();
+        let typed = updated.downcast_dict::<Int32Array>().unwrap();
+        assert_eq!(typed.value(0), 11);
+        assert_eq!(typed.value(1), 11);
+        assert_eq!(typed.value(2), 21);
+
+        let values = updated.values();
+        assert!(values.is_null(2));
+    }
+}
diff --git a/arrow-arith/src/bitwise.rs b/arrow-arith/src/bitwise.rs
new file mode 100644
index 000000000000..c829a3c29fff
--- /dev/null
+++ b/arrow-arith/src/bitwise.rs
@@ -0,0 +1,390 @@
+// 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.
+
+use crate::arity::{binary, unary};
+use arrow_array::*;
+use arrow_buffer::ArrowNativeType;
+use arrow_schema::ArrowError;
+use num::traits::{WrappingShl, WrappingShr};
+use std::ops::{BitAnd, BitOr, BitXor, Not};
+
+/// The helper function for bitwise operation with two array
+fn bitwise_op<T, F>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+    op: F,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    F: Fn(T::Native, T::Native) -> T::Native,
+{
+    binary(left, right, op)
+}
+
+/// Perform `left & right` operation on two arrays. If either left or right value is null
+/// then the result is also null.
+pub fn bitwise_and<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: BitAnd<Output = T::Native>,
+{
+    bitwise_op(left, right, |a, b| a & b)
+}
+
+/// Perform `left | right` operation on two arrays. If either left or right value is null
+/// then the result is also null.
+pub fn bitwise_or<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: BitOr<Output = T::Native>,
+{
+    bitwise_op(left, right, |a, b| a | b)
+}
+
+/// Perform `left ^ right` operation on two arrays. If either left or right value is null
+/// then the result is also null.
+pub fn bitwise_xor<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: BitXor<Output = T::Native>,
+{
+    bitwise_op(left, right, |a, b| a ^ b)
+}
+
+/// Perform bitwise `left << right` operation on two arrays. If either left or right value is null
+/// then the result is also null.
+pub fn bitwise_shift_left<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: WrappingShl<Output = T::Native>,
+{
+    bitwise_op(left, right, |a, b| {
+        let b = b.as_usize();
+        a.wrapping_shl(b as u32)
+    })
+}
+
+/// Perform bitwise `left >> right` operation on two arrays. If either left or right value is null
+/// then the result is also null.
+pub fn bitwise_shift_right<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: WrappingShr<Output = T::Native>,
+{
+    bitwise_op(left, right, |a, b| {
+        let b = b.as_usize();
+        a.wrapping_shr(b as u32)
+    })
+}
+
+/// Perform `!array` operation on array. If array value is null
+/// then the result is also null.
+pub fn bitwise_not<T>(array: &PrimitiveArray<T>) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: Not<Output = T::Native>,
+{
+    Ok(unary(array, |value| !value))
+}
+
+/// Perform `left & !right` operation on two arrays. If either left or right value is null
+/// then the result is also null.
+pub fn bitwise_and_not<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: BitAnd<Output = T::Native>,
+    T::Native: Not<Output = T::Native>,
+{
+    bitwise_op(left, right, |a, b| a & !b)
+}
+
+/// Perform bitwise `and` every value in an array with the scalar. If any value in the array is null then the
+/// result is also null.
+pub fn bitwise_and_scalar<T>(
+    array: &PrimitiveArray<T>,
+    scalar: T::Native,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: BitAnd<Output = T::Native>,
+{
+    Ok(unary(array, |value| value & scalar))
+}
+
+/// Perform bitwise `or` every value in an array with the scalar. If any value in the array is null then the
+/// result is also null.
+pub fn bitwise_or_scalar<T>(
+    array: &PrimitiveArray<T>,
+    scalar: T::Native,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: BitOr<Output = T::Native>,
+{
+    Ok(unary(array, |value| value | scalar))
+}
+
+/// Perform bitwise `xor` every value in an array with the scalar. If any value in the array is null then the
+/// result is also null.
+pub fn bitwise_xor_scalar<T>(
+    array: &PrimitiveArray<T>,
+    scalar: T::Native,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: BitXor<Output = T::Native>,
+{
+    Ok(unary(array, |value| value ^ scalar))
+}
+
+/// Perform bitwise `left << right` every value in an array with the scalar. If any value in the array is null then the
+/// result is also null.
+pub fn bitwise_shift_left_scalar<T>(
+    array: &PrimitiveArray<T>,
+    scalar: T::Native,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: WrappingShl<Output = T::Native>,
+{
+    Ok(unary(array, |value| {
+        let scalar = scalar.as_usize();
+        value.wrapping_shl(scalar as u32)
+    }))
+}
+
+/// Perform bitwise `left >> right` every value in an array with the scalar. If any value in the array is null then the
+/// result is also null.
+pub fn bitwise_shift_right_scalar<T>(
+    array: &PrimitiveArray<T>,
+    scalar: T::Native,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: WrappingShr<Output = T::Native>,
+{
+    Ok(unary(array, |value| {
+        let scalar = scalar.as_usize();
+        value.wrapping_shr(scalar as u32)
+    }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_bitwise_and_array() -> Result<(), ArrowError> {
+        // unsigned value
+        let left = UInt64Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let right = UInt64Array::from(vec![Some(5), Some(10), Some(8), Some(12)]);
+        let expected = UInt64Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let result = bitwise_and(&left, &right)?;
+        assert_eq!(expected, result);
+
+        // signed value
+        let left = Int32Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let right = Int32Array::from(vec![Some(5), Some(-10), Some(8), Some(12)]);
+        let expected = Int32Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let result = bitwise_and(&left, &right)?;
+        assert_eq!(expected, result);
+        Ok(())
+    }
+
+    #[test]
+    fn test_bitwise_shift_left() {
+        let left = UInt64Array::from(vec![Some(1), Some(2), None, Some(4), Some(8)]);
+        let right = UInt64Array::from(vec![Some(5), Some(10), Some(8), Some(12), Some(u64::MAX)]);
+        let expected = UInt64Array::from(vec![Some(32), Some(2048), None, Some(16384), Some(0)]);
+        let result = bitwise_shift_left(&left, &right).unwrap();
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_bitwise_shift_left_scalar() {
+        let left = UInt64Array::from(vec![Some(1), Some(2), None, Some(4), Some(8)]);
+        let scalar = 2;
+        let expected = UInt64Array::from(vec![Some(4), Some(8), None, Some(16), Some(32)]);
+        let result = bitwise_shift_left_scalar(&left, scalar).unwrap();
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_bitwise_shift_right() {
+        let left = UInt64Array::from(vec![Some(32), Some(2048), None, Some(16384), Some(3)]);
+        let right = UInt64Array::from(vec![Some(5), Some(10), Some(8), Some(12), Some(65)]);
+        let expected = UInt64Array::from(vec![Some(1), Some(2), None, Some(4), Some(1)]);
+        let result = bitwise_shift_right(&left, &right).unwrap();
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_bitwise_shift_right_scalar() {
+        let left = UInt64Array::from(vec![Some(32), Some(2048), None, Some(16384), Some(3)]);
+        let scalar = 2;
+        let expected = UInt64Array::from(vec![Some(8), Some(512), None, Some(4096), Some(0)]);
+        let result = bitwise_shift_right_scalar(&left, scalar).unwrap();
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_bitwise_and_array_scalar() {
+        // unsigned value
+        let left = UInt64Array::from(vec![Some(15), Some(2), None, Some(4)]);
+        let scalar = 7;
+        let expected = UInt64Array::from(vec![Some(7), Some(2), None, Some(4)]);
+        let result = bitwise_and_scalar(&left, scalar).unwrap();
+        assert_eq!(expected, result);
+
+        // signed value
+        let left = Int32Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let scalar = -20;
+        let expected = Int32Array::from(vec![Some(0), Some(0), None, Some(4)]);
+        let result = bitwise_and_scalar(&left, scalar).unwrap();
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_bitwise_or_array() {
+        // unsigned value
+        let left = UInt64Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let right = UInt64Array::from(vec![Some(7), Some(5), Some(8), Some(13)]);
+        let expected = UInt64Array::from(vec![Some(7), Some(7), None, Some(13)]);
+        let result = bitwise_or(&left, &right).unwrap();
+        assert_eq!(expected, result);
+
+        // signed value
+        let left = Int32Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let right = Int32Array::from(vec![Some(-7), Some(-5), Some(8), Some(13)]);
+        let expected = Int32Array::from(vec![Some(-7), Some(-5), None, Some(13)]);
+        let result = bitwise_or(&left, &right).unwrap();
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_bitwise_not_array() {
+        // unsigned value
+        let array = UInt64Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let expected = UInt64Array::from(vec![
+            Some(18446744073709551614),
+            Some(18446744073709551613),
+            None,
+            Some(18446744073709551611),
+        ]);
+        let result = bitwise_not(&array).unwrap();
+        assert_eq!(expected, result);
+        // signed value
+        let array = Int32Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let expected = Int32Array::from(vec![Some(-2), Some(-3), None, Some(-5)]);
+        let result = bitwise_not(&array).unwrap();
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_bitwise_and_not_array() {
+        // unsigned value
+        let left = UInt64Array::from(vec![Some(8), Some(2), None, Some(4)]);
+        let right = UInt64Array::from(vec![Some(7), Some(5), Some(8), Some(13)]);
+        let expected = UInt64Array::from(vec![Some(8), Some(2), None, Some(0)]);
+        let result = bitwise_and_not(&left, &right).unwrap();
+        assert_eq!(expected, result);
+        assert_eq!(
+            bitwise_and(&left, &bitwise_not(&right).unwrap()).unwrap(),
+            result
+        );
+
+        // signed value
+        let left = Int32Array::from(vec![Some(2), Some(1), None, Some(3)]);
+        let right = Int32Array::from(vec![Some(-7), Some(-5), Some(8), Some(13)]);
+        let expected = Int32Array::from(vec![Some(2), Some(0), None, Some(2)]);
+        let result = bitwise_and_not(&left, &right).unwrap();
+        assert_eq!(expected, result);
+        assert_eq!(
+            bitwise_and(&left, &bitwise_not(&right).unwrap()).unwrap(),
+            result
+        );
+    }
+
+    #[test]
+    fn test_bitwise_or_array_scalar() {
+        // unsigned value
+        let left = UInt64Array::from(vec![Some(15), Some(2), None, Some(4)]);
+        let scalar = 7;
+        let expected = UInt64Array::from(vec![Some(15), Some(7), None, Some(7)]);
+        let result = bitwise_or_scalar(&left, scalar).unwrap();
+        assert_eq!(expected, result);
+
+        // signed value
+        let left = Int32Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let scalar = 20;
+        let expected = Int32Array::from(vec![Some(21), Some(22), None, Some(20)]);
+        let result = bitwise_or_scalar(&left, scalar).unwrap();
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_bitwise_xor_array() {
+        // unsigned value
+        let left = UInt64Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let right = UInt64Array::from(vec![Some(7), Some(5), Some(8), Some(13)]);
+        let expected = UInt64Array::from(vec![Some(6), Some(7), None, Some(9)]);
+        let result = bitwise_xor(&left, &right).unwrap();
+        assert_eq!(expected, result);
+
+        // signed value
+        let left = Int32Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let right = Int32Array::from(vec![Some(-7), Some(5), Some(8), Some(-13)]);
+        let expected = Int32Array::from(vec![Some(-8), Some(7), None, Some(-9)]);
+        let result = bitwise_xor(&left, &right).unwrap();
+        assert_eq!(expected, result);
+    }
+
+    #[test]
+    fn test_bitwise_xor_array_scalar() {
+        // unsigned value
+        let left = UInt64Array::from(vec![Some(15), Some(2), None, Some(4)]);
+        let scalar = 7;
+        let expected = UInt64Array::from(vec![Some(8), Some(5), None, Some(3)]);
+        let result = bitwise_xor_scalar(&left, scalar).unwrap();
+        assert_eq!(expected, result);
+
+        // signed value
+        let left = Int32Array::from(vec![Some(1), Some(2), None, Some(4)]);
+        let scalar = -20;
+        let expected = Int32Array::from(vec![Some(-19), Some(-18), None, Some(-24)]);
+        let result = bitwise_xor_scalar(&left, scalar).unwrap();
+        assert_eq!(expected, result);
+    }
+}
diff --git a/arrow/src/compute/kernels/boolean.rs b/arrow-arith/src/boolean.rs
similarity index 50%
rename from arrow/src/compute/kernels/boolean.rs
rename to arrow-arith/src/boolean.rs
index 209edc48d195..ea8e12abbe2c 100644
--- a/arrow/src/compute/kernels/boolean.rs
+++ b/arrow-arith/src/boolean.rs
@@ -22,220 +22,10 @@
 //! `RUSTFLAGS="-C target-feature=+avx2"` for example.  See the documentation
 //! [here](https://doc.rust-lang.org/stable/core/arch/) for more information.
 
-use std::ops::Not;
-
-use crate::array::{Array, ArrayData, BooleanArray, PrimitiveArray};
-use crate::buffer::{
-    buffer_bin_and, buffer_bin_or, buffer_unary_not, Buffer, MutableBuffer,
-};
-use crate::compute::util::combine_option_bitmap;
-use crate::datatypes::{ArrowNumericType, DataType};
-use crate::error::{ArrowError, Result};
-use crate::util::bit_util::{ceil, round_upto_multiple_of_64};
-use core::iter;
-use num::Zero;
-
-fn binary_boolean_kleene_kernel<F>(
-    left: &BooleanArray,
-    right: &BooleanArray,
-    op: F,
-) -> Result<BooleanArray>
-where
-    F: Fn(u64, u64, u64, u64) -> (u64, u64),
-{
-    if left.len() != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform bitwise operation on arrays of different length".to_string(),
-        ));
-    }
-
-    // length and offset of boolean array is measured in bits
-    let len = left.len();
-
-    // result length measured in bytes (incl. remainder)
-    let mut result_len = round_upto_multiple_of_64(len) / 8;
-    // The iterator that applies the kleene_op closure always chains an additional iteration
-    // for the remainder chunk, even without a remainder. If the remainder is absent
-    // (length % 64 == 0), kleene_op would resize the result buffers (value_buffer and
-    // valid_buffer) to store 8 additional bytes, because result_len wouldn't include a remainder
-    // chunk. The resizing is unnecessary and expensive. We can prevent it by adding 8 bytes to
-    // result_len here. Nonetheless, all bits of these 8 bytes will be 0.
-    if len % 64 == 0 {
-        result_len += 8;
-    }
-
-    let mut value_buffer = MutableBuffer::new(result_len);
-    let mut valid_buffer = MutableBuffer::new(result_len);
-
-    let kleene_op = |((left_data, left_valid), (right_data, right_valid)): (
-        (u64, u64),
-        (u64, u64),
-    )| {
-        let left_true = left_valid & left_data;
-        let left_false = left_valid & !left_data;
-
-        let right_true = right_valid & right_data;
-        let right_false = right_valid & !right_data;
-
-        let (value, valid) = op(left_true, left_false, right_true, right_false);
-
-        value_buffer.extend_from_slice(&[value]);
-        valid_buffer.extend_from_slice(&[valid]);
-    };
-
-    let left_offset = left.offset();
-    let right_offset = right.offset();
-
-    let left_buffer = left.values();
-    let right_buffer = right.values();
-
-    let left_chunks = left_buffer.bit_chunks(left_offset, len);
-    let right_chunks = right_buffer.bit_chunks(right_offset, len);
-
-    let left_rem = left_chunks.remainder_bits();
-    let right_rem = right_chunks.remainder_bits();
-
-    let opt_left_valid_chunks_and_rem = left
-        .data_ref()
-        .null_buffer()
-        .map(|b| b.bit_chunks(left_offset, len))
-        .map(|chunks| (chunks.iter(), chunks.remainder_bits()));
-    let opt_right_valid_chunks_and_rem = right
-        .data_ref()
-        .null_buffer()
-        .map(|b| b.bit_chunks(right_offset, len))
-        .map(|chunks| (chunks.iter(), chunks.remainder_bits()));
-
-    match (
-        opt_left_valid_chunks_and_rem,
-        opt_right_valid_chunks_and_rem,
-    ) {
-        (
-            Some((left_valid_chunks, left_valid_rem)),
-            Some((right_valid_chunks, right_valid_rem)),
-        ) => {
-            left_chunks
-                .iter()
-                .zip(left_valid_chunks)
-                .zip(right_chunks.iter().zip(right_valid_chunks))
-                .chain(iter::once((
-                    (left_rem, left_valid_rem),
-                    (right_rem, right_valid_rem),
-                )))
-                .for_each(kleene_op);
-        }
-        (Some((left_valid_chunks, left_valid_rem)), None) => {
-            left_chunks
-                .iter()
-                .zip(left_valid_chunks)
-                .zip(right_chunks.iter().zip(iter::repeat(u64::MAX)))
-                .chain(iter::once((
-                    (left_rem, left_valid_rem),
-                    (right_rem, u64::MAX),
-                )))
-                .for_each(kleene_op);
-        }
-        (None, Some((right_valid_chunks, right_valid_rem))) => {
-            left_chunks
-                .iter()
-                .zip(iter::repeat(u64::MAX))
-                .zip(right_chunks.iter().zip(right_valid_chunks))
-                .chain(iter::once((
-                    (left_rem, u64::MAX),
-                    (right_rem, right_valid_rem),
-                )))
-                .for_each(kleene_op);
-        }
-        (None, None) => {
-            left_chunks
-                .iter()
-                .zip(iter::repeat(u64::MAX))
-                .zip(right_chunks.iter().zip(iter::repeat(u64::MAX)))
-                .chain(iter::once(((left_rem, u64::MAX), (right_rem, u64::MAX))))
-                .for_each(kleene_op);
-        }
-    };
-
-    let bool_buffer: Buffer = value_buffer.into();
-    let bool_valid_buffer: Buffer = valid_buffer.into();
-
-    let array_data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            len,
-            None,
-            Some(bool_valid_buffer),
-            left_offset,
-            vec![bool_buffer],
-            vec![],
-        )
-    };
-
-    Ok(BooleanArray::from(array_data))
-}
-
-/// Helper function to implement binary kernels
-pub(crate) fn binary_boolean_kernel<F>(
-    left: &BooleanArray,
-    right: &BooleanArray,
-    op: F,
-) -> Result<BooleanArray>
-where
-    F: Fn(&Buffer, usize, &Buffer, usize, usize) -> Buffer,
-{
-    if left.len() != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform bitwise operation on arrays of different length".to_string(),
-        ));
-    }
-
-    let len = left.len();
-
-    let left_data = left.data_ref();
-    let right_data = right.data_ref();
-    let null_bit_buffer = combine_option_bitmap(&[left_data, right_data], len)?;
-
-    let left_buffer = &left_data.buffers()[0];
-    let right_buffer = &right_data.buffers()[0];
-    let left_offset = left.offset();
-    let right_offset = right.offset();
-
-    let values = op(left_buffer, left_offset, right_buffer, right_offset, len);
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            len,
-            None,
-            null_bit_buffer,
-            0,
-            vec![values],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Performs `AND` operation on two arrays. If either left or right value is null then the
-/// result is also null.
-/// # Error
-/// This function errors when the arrays have different lengths.
-/// # Example
-/// ```rust
-/// use arrow::array::BooleanArray;
-/// use arrow::error::Result;
-/// use arrow::compute::kernels::boolean::and;
-/// # fn main() -> Result<()> {
-/// let a = BooleanArray::from(vec![Some(false), Some(true), None]);
-/// let b = BooleanArray::from(vec![Some(true), Some(true), Some(false)]);
-/// let and_ab = and(&a, &b)?;
-/// assert_eq!(and_ab, BooleanArray::from(vec![Some(false), Some(true), None]));
-/// # Ok(())
-/// # }
-/// ```
-pub fn and(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
-    binary_boolean_kernel(left, right, buffer_bin_and)
-}
+use arrow_array::*;
+use arrow_buffer::buffer::{bitwise_bin_op_helper, bitwise_quaternary_op_helper};
+use arrow_buffer::{buffer_bin_and_not, BooleanBuffer, NullBuffer};
+use arrow_schema::ArrowError;
 
 /// Logical 'and' boolean values with Kleene logic
 ///
@@ -256,55 +46,80 @@ pub fn and(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
 /// # Example
 ///
 /// ```rust
-/// use arrow::array::BooleanArray;
-/// use arrow::error::Result;
-/// use arrow::compute::kernels::boolean::and_kleene;
-/// # fn main() -> Result<()> {
+/// # use arrow_array::BooleanArray;
+/// # use arrow_arith::boolean::and_kleene;
 /// let a = BooleanArray::from(vec![Some(true), Some(false), None]);
 /// let b = BooleanArray::from(vec![None, None, None]);
-/// let and_ab = and_kleene(&a, &b)?;
+/// let and_ab = and_kleene(&a, &b).unwrap();
 /// assert_eq!(and_ab, BooleanArray::from(vec![None, Some(false), None]));
-/// # Ok(())
-/// # }
 /// ```
 ///
 /// # Fails
 ///
 /// If the operands have different lengths
-pub fn and_kleene(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
-    if left.null_count().is_zero() && right.null_count().is_zero() {
-        return and(left, right);
+pub fn and_kleene(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    if left.len() != right.len() {
+        return Err(ArrowError::ComputeError(
+            "Cannot perform bitwise operation on arrays of different length".to_string(),
+        ));
     }
 
-    let op = |left_true, left_false, right_true, right_false| {
-        (
-            left_true & right_true,
-            left_false | right_false | (left_true & right_true),
-        )
+    let left_values = left.values();
+    let right_values = right.values();
+
+    let buffer = match (left.nulls(), right.nulls()) {
+        (None, None) => None,
+        (Some(left_null_buffer), None) => {
+            // The right side has no null values.
+            // The final null bit is set only if:
+            // 1. left null bit is set, or
+            // 2. right data bit is false (because null AND false = false).
+            Some(bitwise_bin_op_helper(
+                left_null_buffer.buffer(),
+                left_null_buffer.offset(),
+                right_values.inner(),
+                right_values.offset(),
+                left.len(),
+                |a, b| a | !b,
+            ))
+        }
+        (None, Some(right_null_buffer)) => {
+            // Same as above
+            Some(bitwise_bin_op_helper(
+                right_null_buffer.buffer(),
+                right_null_buffer.offset(),
+                left_values.inner(),
+                left_values.offset(),
+                left.len(),
+                |a, b| a | !b,
+            ))
+        }
+        (Some(left_null_buffer), Some(right_null_buffer)) => {
+            // Follow the same logic above. Both sides have null values.
+            // Assume a is left null bits, b is left data bits, c is right null bits,
+            // d is right data bits.
+            // The final null bits are:
+            // (a | (c & !d)) & (c | (a & !b))
+            Some(bitwise_quaternary_op_helper(
+                [
+                    left_null_buffer.buffer(),
+                    left_values.inner(),
+                    right_null_buffer.buffer(),
+                    right_values.inner(),
+                ],
+                [
+                    left_null_buffer.offset(),
+                    left_values.offset(),
+                    right_null_buffer.offset(),
+                    right_values.offset(),
+                ],
+                left.len(),
+                |a, b, c, d| (a | (c & !d)) & (c | (a & !b)),
+            ))
+        }
     };
-
-    binary_boolean_kleene_kernel(left, right, op)
-}
-
-/// Performs `OR` operation on two arrays. If either left or right value is null then the
-/// result is also null.
-/// # Error
-/// This function errors when the arrays have different lengths.
-/// # Example
-/// ```rust
-/// use arrow::array::BooleanArray;
-/// use arrow::error::Result;
-/// use arrow::compute::kernels::boolean::or;
-/// # fn main() -> Result<()> {
-/// let a = BooleanArray::from(vec![Some(false), Some(true), None]);
-/// let b = BooleanArray::from(vec![Some(true), Some(true), Some(false)]);
-/// let or_ab = or(&a, &b)?;
-/// assert_eq!(or_ab, BooleanArray::from(vec![Some(true), Some(true), None]));
-/// # Ok(())
-/// # }
-/// ```
-pub fn or(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
-    binary_boolean_kernel(left, right, buffer_bin_or)
+    let nulls = buffer.map(|b| NullBuffer::new(BooleanBuffer::new(b, 0, left.len())));
+    Ok(BooleanArray::new(left_values & right_values, nulls))
 }
 
 /// Logical 'or' boolean values with Kleene logic
@@ -326,34 +141,156 @@ pub fn or(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
 /// # Example
 ///
 /// ```rust
-/// use arrow::array::BooleanArray;
-/// use arrow::error::Result;
-/// use arrow::compute::kernels::boolean::or_kleene;
-/// # fn main() -> Result<()> {
+/// # use arrow_array::BooleanArray;
+/// # use arrow_arith::boolean::or_kleene;
 /// let a = BooleanArray::from(vec![Some(true), Some(false), None]);
 /// let b = BooleanArray::from(vec![None, None, None]);
-/// let or_ab = or_kleene(&a, &b)?;
+/// let or_ab = or_kleene(&a, &b).unwrap();
 /// assert_eq!(or_ab, BooleanArray::from(vec![Some(true), None, None]));
-/// # Ok(())
-/// # }
 /// ```
 ///
 /// # Fails
 ///
 /// If the operands have different lengths
-pub fn or_kleene(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
-    if left.null_count().is_zero() && right.null_count().is_zero() {
-        return or(left, right);
+pub fn or_kleene(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    if left.len() != right.len() {
+        return Err(ArrowError::ComputeError(
+            "Cannot perform bitwise operation on arrays of different length".to_string(),
+        ));
     }
 
-    let op = |left_true, left_false, right_true, right_false| {
-        (
-            left_true | right_true,
-            left_true | right_true | (left_false & right_false),
-        )
+    let left_values = left.values();
+    let right_values = right.values();
+
+    let buffer = match (left.nulls(), right.nulls()) {
+        (None, None) => None,
+        (Some(left_nulls), None) => {
+            // The right side has no null values.
+            // The final null bit is set only if:
+            // 1. left null bit is set, or
+            // 2. right data bit is true (because null OR true = true).
+            Some(bitwise_bin_op_helper(
+                left_nulls.buffer(),
+                left_nulls.offset(),
+                right_values.inner(),
+                right_values.offset(),
+                left.len(),
+                |a, b| a | b,
+            ))
+        }
+        (None, Some(right_nulls)) => {
+            // Same as above
+            Some(bitwise_bin_op_helper(
+                right_nulls.buffer(),
+                right_nulls.offset(),
+                left_values.inner(),
+                left_values.offset(),
+                left.len(),
+                |a, b| a | b,
+            ))
+        }
+        (Some(left_nulls), Some(right_nulls)) => {
+            // Follow the same logic above. Both sides have null values.
+            // Assume a is left null bits, b is left data bits, c is right null bits,
+            // d is right data bits.
+            // The final null bits are:
+            // (a | (c & d)) & (c | (a & b))
+            Some(bitwise_quaternary_op_helper(
+                [
+                    left_nulls.buffer(),
+                    left_values.inner(),
+                    right_nulls.buffer(),
+                    right_values.inner(),
+                ],
+                [
+                    left_nulls.offset(),
+                    left_values.offset(),
+                    right_nulls.offset(),
+                    right_values.offset(),
+                ],
+                left.len(),
+                |a, b, c, d| (a | (c & d)) & (c | (a & b)),
+            ))
+        }
     };
 
-    binary_boolean_kleene_kernel(left, right, op)
+    let nulls = buffer.map(|b| NullBuffer::new(BooleanBuffer::new(b, 0, left.len())));
+    Ok(BooleanArray::new(left_values | right_values, nulls))
+}
+
+/// Helper function to implement binary kernels
+pub(crate) fn binary_boolean_kernel<F>(
+    left: &BooleanArray,
+    right: &BooleanArray,
+    op: F,
+) -> Result<BooleanArray, ArrowError>
+where
+    F: Fn(&BooleanBuffer, &BooleanBuffer) -> BooleanBuffer,
+{
+    if left.len() != right.len() {
+        return Err(ArrowError::ComputeError(
+            "Cannot perform bitwise operation on arrays of different length".to_string(),
+        ));
+    }
+
+    let nulls = NullBuffer::union(left.nulls(), right.nulls());
+    let values = op(left.values(), right.values());
+    Ok(BooleanArray::new(values, nulls))
+}
+
+/// Performs `AND` operation on two arrays. If either left or right value is null then the
+/// result is also null.
+/// # Error
+/// This function errors when the arrays have different lengths.
+/// # Example
+/// ```rust
+/// # use arrow_array::BooleanArray;
+/// # use arrow_arith::boolean::and;
+/// let a = BooleanArray::from(vec![Some(false), Some(true), None]);
+/// let b = BooleanArray::from(vec![Some(true), Some(true), Some(false)]);
+/// let and_ab = and(&a, &b).unwrap();
+/// assert_eq!(and_ab, BooleanArray::from(vec![Some(false), Some(true), None]));
+/// ```
+pub fn and(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    binary_boolean_kernel(left, right, |a, b| a & b)
+}
+
+/// Performs `OR` operation on two arrays. If either left or right value is null then the
+/// result is also null.
+/// # Error
+/// This function errors when the arrays have different lengths.
+/// # Example
+/// ```rust
+/// # use arrow_array::BooleanArray;
+/// # use arrow_arith::boolean::or;
+/// let a = BooleanArray::from(vec![Some(false), Some(true), None]);
+/// let b = BooleanArray::from(vec![Some(true), Some(true), Some(false)]);
+/// let or_ab = or(&a, &b).unwrap();
+/// assert_eq!(or_ab, BooleanArray::from(vec![Some(true), Some(true), None]));
+/// ```
+pub fn or(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    binary_boolean_kernel(left, right, |a, b| a | b)
+}
+
+/// Performs `AND_NOT` operation on two arrays. If either left or right value is null then the
+/// result is also null.
+/// # Error
+/// This function errors when the arrays have different lengths.
+/// # Example
+/// ```rust
+/// # use arrow_array::BooleanArray;
+/// # use arrow_arith::boolean::{and, not, and_not};
+/// let a = BooleanArray::from(vec![Some(false), Some(true), None]);
+/// let b = BooleanArray::from(vec![Some(true), Some(true), Some(false)]);
+/// let andn_ab = and_not(&a, &b).unwrap();
+/// assert_eq!(andn_ab, BooleanArray::from(vec![Some(false), Some(false), None]));
+/// // It's equal to and(left, not(right))
+/// assert_eq!(andn_ab, and(&a, &not(&b).unwrap()).unwrap());
+pub fn and_not(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    binary_boolean_kernel(left, right, |a, b| {
+        let buffer = buffer_bin_and_not(a.inner(), b.offset(), b.inner(), a.offset(), a.len());
+        BooleanBuffer::new(buffer, left.offset(), left.len())
+    })
 }
 
 /// Performs unary `NOT` operation on an arrays. If value is null then the result is also
@@ -362,40 +299,16 @@ pub fn or_kleene(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArr
 /// This function never errors. It returns an error for consistency.
 /// # Example
 /// ```rust
-/// use arrow::array::BooleanArray;
-/// use arrow::error::Result;
-/// use arrow::compute::kernels::boolean::not;
-/// # fn main() -> Result<()> {
+/// # use arrow_array::BooleanArray;
+/// # use arrow_arith::boolean::not;
 /// let a = BooleanArray::from(vec![Some(false), Some(true), None]);
-/// let not_a = not(&a)?;
+/// let not_a = not(&a).unwrap();
 /// assert_eq!(not_a, BooleanArray::from(vec![Some(true), Some(false), None]));
-/// # Ok(())
-/// # }
 /// ```
-pub fn not(left: &BooleanArray) -> Result<BooleanArray> {
-    let left_offset = left.offset();
-    let len = left.len();
-
-    let data = left.data_ref();
-    let null_bit_buffer = data
-        .null_bitmap()
-        .as_ref()
-        .map(|b| b.bits.bit_slice(left_offset, len));
-
-    let values = buffer_unary_not(&data.buffers()[0], left_offset, len);
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            len,
-            None,
-            null_bit_buffer,
-            0,
-            vec![values],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
+pub fn not(left: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    let nulls = left.nulls().cloned();
+    let values = !left.values();
+    Ok(BooleanArray::new(values, nulls))
 }
 
 /// Returns a non-null [BooleanArray] with whether each value of the array is null.
@@ -403,40 +316,19 @@ pub fn not(left: &BooleanArray) -> Result<BooleanArray> {
 /// This function never errors.
 /// # Example
 /// ```rust
-/// # use arrow::error::Result;
-/// use arrow::array::BooleanArray;
-/// use arrow::compute::kernels::boolean::is_null;
-/// # fn main() -> Result<()> {
+/// # use arrow_array::BooleanArray;
+/// # use arrow_arith::boolean::is_null;
 /// let a = BooleanArray::from(vec![Some(false), Some(true), None]);
-/// let a_is_null = is_null(&a)?;
+/// let a_is_null = is_null(&a).unwrap();
 /// assert_eq!(a_is_null, BooleanArray::from(vec![false, false, true]));
-/// # Ok(())
-/// # }
 /// ```
-pub fn is_null(input: &dyn Array) -> Result<BooleanArray> {
-    let len = input.len();
-
-    let output = match input.data_ref().null_buffer() {
-        None => {
-            let len_bytes = ceil(len, 8);
-            MutableBuffer::from_len_zeroed(len_bytes).into()
-        }
-        Some(buffer) => buffer_unary_not(buffer, input.offset(), len),
+pub fn is_null(input: &dyn Array) -> Result<BooleanArray, ArrowError> {
+    let values = match input.logical_nulls() {
+        None => BooleanBuffer::new_unset(input.len()),
+        Some(nulls) => !nulls.inner(),
     };
 
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            len,
-            None,
-            None,
-            0,
-            vec![output],
-            vec![],
-        )
-    };
-
-    Ok(BooleanArray::from(data))
+    Ok(BooleanArray::new(values, None))
 }
 
 /// Returns a non-null [BooleanArray] with whether each value of the array is not null.
@@ -444,141 +336,23 @@ pub fn is_null(input: &dyn Array) -> Result<BooleanArray> {
 /// This function never errors.
 /// # Example
 /// ```rust
-/// # use arrow::error::Result;
-/// use arrow::array::BooleanArray;
-/// use arrow::compute::kernels::boolean::is_not_null;
-/// # fn main() -> Result<()> {
+/// # use arrow_array::BooleanArray;
+/// # use arrow_arith::boolean::is_not_null;
 /// let a = BooleanArray::from(vec![Some(false), Some(true), None]);
-/// let a_is_not_null = is_not_null(&a)?;
+/// let a_is_not_null = is_not_null(&a).unwrap();
 /// assert_eq!(a_is_not_null, BooleanArray::from(vec![true, true, false]));
-/// # Ok(())
-/// # }
 /// ```
-pub fn is_not_null(input: &dyn Array) -> Result<BooleanArray> {
-    let len = input.len();
-
-    let output = match input.data_ref().null_buffer() {
-        None => {
-            let len_bytes = ceil(len, 8);
-            MutableBuffer::new(len_bytes)
-                .with_bitset(len_bytes, true)
-                .into()
-        }
-        Some(buffer) => buffer.bit_slice(input.offset(), len),
-    };
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            len,
-            None,
-            None,
-            0,
-            vec![output],
-            vec![],
-        )
-    };
-
-    Ok(BooleanArray::from(data))
-}
-
-/// Copies original array, setting null bit to true if a secondary comparison boolean array is set to true.
-/// Typically used to implement NULLIF.
-// NOTE: For now this only supports Primitive Arrays.  Although the code could be made generic, the issue
-// is that currently the bitmap operations result in a final bitmap which is aligned to bit 0, and thus
-// the left array's data needs to be sliced to a new offset, and for non-primitive arrays shifting the
-// data might be too complicated.   In the future, to avoid shifting left array's data, we could instead
-// shift the final bitbuffer to the right, prepending with 0's instead.
-pub fn nullif<T>(
-    left: &PrimitiveArray<T>,
-    right: &BooleanArray,
-) -> Result<PrimitiveArray<T>>
-where
-    T: ArrowNumericType,
-{
-    if left.len() != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform comparison operation on arrays of different length"
-                .to_string(),
-        ));
-    }
-    let left_data = left.data();
-    let right_data = right.data();
-
-    // If left has no bitmap, create a new one with all values set for nullity op later
-    // left=0 (null)   right=null       output bitmap=null
-    // left=0          right=1          output bitmap=null
-    // left=1 (set)    right=null       output bitmap=set   (passthrough)
-    // left=1          right=1 & comp=true    output bitmap=null
-    // left=1          right=1 & comp=false   output bitmap=set
-    //
-    // Thus: result = left null bitmap & (!right_values | !right_bitmap)
-    //              OR left null bitmap & !(right_values & right_bitmap)
-    //
-    // Do the right expression !(right_values & right_bitmap) first since there are two steps
-    // TRICK: convert BooleanArray buffer as a bitmap for faster operation
-    let right_combo_buffer = match right.data().null_bitmap() {
-        Some(right_bitmap) => {
-            // NOTE: right values and bitmaps are combined and stay at bit offset right.offset()
-            (right.values() & &right_bitmap.bits).ok().map(|b| b.not())
-        }
-        None => Some(!right.values()),
-    };
-
-    // AND of original left null bitmap with right expression
-    // Here we take care of the possible offsets of the left and right arrays all at once.
-    let modified_null_buffer = match left_data.null_bitmap() {
-        Some(left_null_bitmap) => match right_combo_buffer {
-            Some(rcb) => Some(buffer_bin_and(
-                &left_null_bitmap.bits,
-                left_data.offset(),
-                &rcb,
-                right_data.offset(),
-                left_data.len(),
-            )),
-            None => Some(
-                left_null_bitmap
-                    .bits
-                    .bit_slice(left_data.offset(), left.len()),
-            ),
-        },
-        None => right_combo_buffer
-            .map(|rcb| rcb.bit_slice(right_data.offset(), right_data.len())),
-    };
-
-    // Align/shift left data on offset as needed, since new bitmaps are shifted and aligned to 0 already
-    // NOTE: this probably only works for primitive arrays.
-    let data_buffers = if left.offset() == 0 {
-        left_data.buffers().to_vec()
-    } else {
-        // Shift each data buffer by type's bit_width * offset.
-        left_data
-            .buffers()
-            .iter()
-            .map(|buf| buf.slice(left.offset() * T::get_byte_width()))
-            .collect::<Vec<_>>()
-    };
-
-    // Construct new array with same values but modified null bitmap
-    // TODO: shift data buffer as needed
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            T::DATA_TYPE,
-            left.len(),
-            None, // force new to compute the number of null bits
-            modified_null_buffer,
-            0, // No need for offset since left data has been shifted
-            data_buffers,
-            left_data.child_data().to_vec(),
-        )
+pub fn is_not_null(input: &dyn Array) -> Result<BooleanArray, ArrowError> {
+    let values = match input.logical_nulls() {
+        None => BooleanBuffer::new_set(input.len()),
+        Some(n) => n.inner().clone(),
     };
-    Ok(PrimitiveArray::<T>::from(data))
+    Ok(BooleanArray::new(values, None))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::array::{ArrayRef, Int32Array};
     use std::sync::Arc;
 
     #[test]
@@ -603,6 +377,18 @@ mod tests {
         assert_eq!(c, expected);
     }
 
+    #[test]
+    fn test_bool_array_and_not() {
+        let a = BooleanArray::from(vec![false, false, true, true]);
+        let b = BooleanArray::from(vec![false, true, false, true]);
+        let c = and_not(&a, &b).unwrap();
+
+        let expected = BooleanArray::from(vec![false, false, true, false]);
+
+        assert_eq!(c, expected);
+        assert_eq!(c, and(&a, &not(&b).unwrap()).unwrap());
+    }
+
     #[test]
     fn test_bool_array_or_nulls() {
         let a = BooleanArray::from(vec![
@@ -644,33 +430,6 @@ mod tests {
         assert_eq!(c, expected);
     }
 
-    #[test]
-    fn test_binary_boolean_kleene_kernel() {
-        // the kleene kernel is based on chunking and we want to also create
-        // cases, where the number of values is not a multiple of 64
-        for &value in [true, false].iter() {
-            for &is_valid in [true, false].iter() {
-                for &n in [0usize, 1, 63, 64, 65, 127, 128].iter() {
-                    let a = BooleanArray::from(vec![Some(true); n]);
-                    let b = BooleanArray::from(vec![None; n]);
-
-                    let result = binary_boolean_kleene_kernel(&a, &b, |_, _, _, _| {
-                        let tmp_value = if value { u64::MAX } else { 0 };
-                        let tmp_is_valid = if is_valid { u64::MAX } else { 0 };
-                        (tmp_value, tmp_is_valid)
-                    })
-                    .unwrap();
-
-                    assert_eq!(result.len(), n);
-                    (0..n).for_each(|idx| {
-                        assert_eq!(value, result.value(idx));
-                        assert_eq!(is_valid, result.is_valid(idx));
-                    });
-                }
-            }
-        }
-    }
-
     #[test]
     fn test_boolean_array_kleene_no_remainder() {
         let n = 1024;
@@ -768,7 +527,7 @@ mod tests {
         let a = BooleanArray::from(vec![false, false, false, true, true, true]);
 
         // ensure null bitmap of a is absent
-        assert!(a.data_ref().null_bitmap().is_none());
+        assert!(a.nulls().is_none());
 
         let b = BooleanArray::from(vec![
             Some(true),
@@ -780,7 +539,7 @@ mod tests {
         ]);
 
         // ensure null bitmap of b is present
-        assert!(b.data_ref().null_bitmap().is_some());
+        assert!(b.nulls().is_some());
 
         let c = or_kleene(&a, &b).unwrap();
 
@@ -808,12 +567,12 @@ mod tests {
         ]);
 
         // ensure null bitmap of b is absent
-        assert!(a.data_ref().null_bitmap().is_some());
+        assert!(a.nulls().is_some());
 
         let b = BooleanArray::from(vec![false, false, false, true, true, true]);
 
         // ensure null bitmap of a is present
-        assert!(b.data_ref().null_bitmap().is_none());
+        assert!(b.nulls().is_none());
 
         let c = or_kleene(&a, &b).unwrap();
 
@@ -846,8 +605,7 @@ mod tests {
         let a = a.as_any().downcast_ref::<BooleanArray>().unwrap();
         let c = not(a).unwrap();
 
-        let expected =
-            BooleanArray::from(vec![Some(false), Some(true), None, Some(false)]);
+        let expected = BooleanArray::from(vec![Some(false), Some(true), None, Some(false)]);
 
         assert_eq!(c, expected);
     }
@@ -896,12 +654,10 @@ mod tests {
     #[test]
     fn test_bool_array_and_sliced_same_offset() {
         let a = BooleanArray::from(vec![
-            false, false, false, false, false, false, false, false, false, false, true,
-            true,
+            false, false, false, false, false, false, false, false, false, false, true, true,
         ]);
         let b = BooleanArray::from(vec![
-            false, false, false, false, false, false, false, false, false, true, false,
-            true,
+            false, false, false, false, false, false, false, false, false, true, false, true,
         ]);
 
         let a = a.slice(8, 4);
@@ -919,12 +675,10 @@ mod tests {
     #[test]
     fn test_bool_array_and_sliced_same_offset_mod8() {
         let a = BooleanArray::from(vec![
-            false, false, true, true, false, false, false, false, false, false, false,
-            false,
+            false, false, true, true, false, false, false, false, false, false, false, false,
         ]);
         let b = BooleanArray::from(vec![
-            false, false, false, false, false, false, false, false, false, true, false,
-            true,
+            false, false, false, false, false, false, false, false, false, true, false, true,
         ]);
 
         let a = a.slice(0, 4);
@@ -942,8 +696,7 @@ mod tests {
     #[test]
     fn test_bool_array_and_sliced_offset1() {
         let a = BooleanArray::from(vec![
-            false, false, false, false, false, false, false, false, false, false, true,
-            true,
+            false, false, false, false, false, false, false, false, false, false, true, true,
         ]);
         let b = BooleanArray::from(vec![false, true, false, true]);
 
@@ -961,8 +714,7 @@ mod tests {
     fn test_bool_array_and_sliced_offset2() {
         let a = BooleanArray::from(vec![false, false, true, true]);
         let b = BooleanArray::from(vec![
-            false, false, false, false, false, false, false, false, false, true, false,
-            true,
+            false, false, false, false, false, false, false, false, false, true, false, true,
         ]);
 
         let b = b.slice(8, 4);
@@ -995,8 +747,7 @@ mod tests {
 
         let c = and(a, b).unwrap();
 
-        let expected =
-            BooleanArray::from(vec![Some(false), Some(false), None, Some(true)]);
+        let expected = BooleanArray::from(vec![Some(false), Some(false), None, Some(true)]);
 
         assert_eq!(expected, c);
     }
@@ -1010,7 +761,7 @@ mod tests {
         let expected = BooleanArray::from(vec![false, false, false, false]);
 
         assert_eq!(expected, res);
-        assert_eq!(None, res.data_ref().null_bitmap());
+        assert!(res.nulls().is_none());
     }
 
     #[test]
@@ -1018,12 +769,12 @@ mod tests {
         let a = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1]);
         let a = a.slice(8, 4);
 
-        let res = is_null(a.as_ref()).unwrap();
+        let res = is_null(&a).unwrap();
 
         let expected = BooleanArray::from(vec![false, false, false, false]);
 
         assert_eq!(expected, res);
-        assert_eq!(None, res.data_ref().null_bitmap());
+        assert!(res.nulls().is_none());
     }
 
     #[test]
@@ -1035,7 +786,7 @@ mod tests {
         let expected = BooleanArray::from(vec![true, true, true, true]);
 
         assert_eq!(expected, res);
-        assert_eq!(None, res.data_ref().null_bitmap());
+        assert!(res.nulls().is_none());
     }
 
     #[test]
@@ -1043,12 +794,12 @@ mod tests {
         let a = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 7, 6, 5, 4, 3, 2, 1]);
         let a = a.slice(8, 4);
 
-        let res = is_not_null(a.as_ref()).unwrap();
+        let res = is_not_null(&a).unwrap();
 
         let expected = BooleanArray::from(vec![true, true, true, true]);
 
         assert_eq!(expected, res);
-        assert_eq!(None, res.data_ref().null_bitmap());
+        assert!(res.nulls().is_none());
     }
 
     #[test]
@@ -1060,7 +811,7 @@ mod tests {
         let expected = BooleanArray::from(vec![false, true, false, true]);
 
         assert_eq!(expected, res);
-        assert_eq!(None, res.data_ref().null_bitmap());
+        assert!(res.nulls().is_none());
     }
 
     #[test]
@@ -1086,12 +837,12 @@ mod tests {
         ]);
         let a = a.slice(8, 4);
 
-        let res = is_null(a.as_ref()).unwrap();
+        let res = is_null(&a).unwrap();
 
         let expected = BooleanArray::from(vec![false, true, false, true]);
 
         assert_eq!(expected, res);
-        assert_eq!(None, res.data_ref().null_bitmap());
+        assert!(res.nulls().is_none());
     }
 
     #[test]
@@ -1103,7 +854,7 @@ mod tests {
         let expected = BooleanArray::from(vec![true, false, true, false]);
 
         assert_eq!(expected, res);
-        assert_eq!(None, res.data_ref().null_bitmap());
+        assert!(res.nulls().is_none());
     }
 
     #[test]
@@ -1129,57 +880,35 @@ mod tests {
         ]);
         let a = a.slice(8, 4);
 
-        let res = is_not_null(a.as_ref()).unwrap();
+        let res = is_not_null(&a).unwrap();
 
         let expected = BooleanArray::from(vec![true, false, true, false]);
 
         assert_eq!(expected, res);
-        assert_eq!(None, res.data_ref().null_bitmap());
+        assert!(res.nulls().is_none());
     }
 
     #[test]
-    fn test_nullif_int_array() {
-        let a = Int32Array::from(vec![Some(15), None, Some(8), Some(1), Some(9)]);
-        let comp =
-            BooleanArray::from(vec![Some(false), None, Some(true), Some(false), None]);
-        let res = nullif(&a, &comp).unwrap();
+    fn test_null_array_is_null() {
+        let a = NullArray::new(3);
 
-        let expected = Int32Array::from(vec![
-            Some(15),
-            None,
-            None, // comp true, slot 2 turned into null
-            Some(1),
-            // Even though comp array / right is null, should still pass through original value
-            // comp true, slot 2 turned into null
-            Some(9),
-        ]);
+        let res = is_null(&a).unwrap();
+
+        let expected = BooleanArray::from(vec![true, true, true]);
 
         assert_eq!(expected, res);
+        assert!(res.nulls().is_none());
     }
 
     #[test]
-    fn test_nullif_int_array_offset() {
-        let a = Int32Array::from(vec![None, Some(15), Some(8), Some(1), Some(9)]);
-        let a = a.slice(1, 3); // Some(15), Some(8), Some(1)
-        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
-        let comp = BooleanArray::from(vec![
-            Some(false),
-            Some(false),
-            Some(false),
-            None,
-            Some(true),
-            Some(false),
-            None,
-        ]);
-        let comp = comp.slice(2, 3); // Some(false), None, Some(true)
-        let comp = comp.as_any().downcast_ref::<BooleanArray>().unwrap();
-        let res = nullif(a, comp).unwrap();
-
-        let expected = Int32Array::from(vec![
-            Some(15), // False => keep it
-            Some(8),  // None => keep it
-            None,     // true => None
-        ]);
-        assert_eq!(&expected, &res)
+    fn test_null_array_is_not_null() {
+        let a = NullArray::new(3);
+
+        let res = is_not_null(&a).unwrap();
+
+        let expected = BooleanArray::from(vec![false, false, false]);
+
+        assert_eq!(expected, res);
+        assert!(res.nulls().is_none());
     }
 }
diff --git a/arrow/src/compute/kernels/mod.rs b/arrow-arith/src/lib.rs
similarity index 75%
rename from arrow/src/compute/kernels/mod.rs
rename to arrow-arith/src/lib.rs
index c615d3a55e1a..2d5451e04dd2 100644
--- a/arrow/src/compute/kernels/mod.rs
+++ b/arrow-arith/src/lib.rs
@@ -15,25 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Computation kernels on Arrow Arrays
+//! Arrow arithmetic and aggregation kernels
 
 pub mod aggregate;
+#[doc(hidden)] // Kernels to be removed in a future release
 pub mod arithmetic;
 pub mod arity;
+pub mod bitwise;
 pub mod boolean;
-pub mod cast;
-pub mod cast_utils;
-pub mod comparison;
-pub mod concat;
-pub mod concat_elements;
-pub mod filter;
-pub mod length;
-pub mod limit;
-pub mod partition;
-pub mod regexp;
-pub mod sort;
-pub mod substring;
-pub mod take;
+pub mod numeric;
 pub mod temporal;
-pub mod window;
-pub mod zip;
diff --git a/arrow-arith/src/numeric.rs b/arrow-arith/src/numeric.rs
new file mode 100644
index 000000000000..b2c87bba5143
--- /dev/null
+++ b/arrow-arith/src/numeric.rs
@@ -0,0 +1,1520 @@
+// 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.
+
+//! Defines numeric arithmetic kernels on [`PrimitiveArray`], such as [`add`]
+
+use std::cmp::Ordering;
+use std::fmt::Formatter;
+use std::sync::Arc;
+
+use arrow_array::cast::AsArray;
+use arrow_array::timezone::Tz;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::ArrowNativeType;
+use arrow_schema::{ArrowError, DataType, IntervalUnit, TimeUnit};
+
+use crate::arity::{binary, try_binary};
+
+/// Perform `lhs + rhs`, returning an error on overflow
+pub fn add(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<ArrayRef, ArrowError> {
+    arithmetic_op(Op::Add, lhs, rhs)
+}
+
+/// Perform `lhs + rhs`, wrapping on overflow for [`DataType::is_integer`]
+pub fn add_wrapping(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<ArrayRef, ArrowError> {
+    arithmetic_op(Op::AddWrapping, lhs, rhs)
+}
+
+/// Perform `lhs - rhs`, returning an error on overflow
+pub fn sub(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<ArrayRef, ArrowError> {
+    arithmetic_op(Op::Sub, lhs, rhs)
+}
+
+/// Perform `lhs - rhs`, wrapping on overflow for [`DataType::is_integer`]
+pub fn sub_wrapping(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<ArrayRef, ArrowError> {
+    arithmetic_op(Op::SubWrapping, lhs, rhs)
+}
+
+/// Perform `lhs * rhs`, returning an error on overflow
+pub fn mul(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<ArrayRef, ArrowError> {
+    arithmetic_op(Op::Mul, lhs, rhs)
+}
+
+/// Perform `lhs * rhs`, wrapping on overflow for [`DataType::is_integer`]
+pub fn mul_wrapping(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<ArrayRef, ArrowError> {
+    arithmetic_op(Op::MulWrapping, lhs, rhs)
+}
+
+/// Perform `lhs / rhs`
+///
+/// Overflow or division by zero will result in an error, with exception to
+/// floating point numbers, which instead follow the IEEE 754 rules
+pub fn div(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<ArrayRef, ArrowError> {
+    arithmetic_op(Op::Div, lhs, rhs)
+}
+
+/// Perform `lhs % rhs`
+///
+/// Overflow or division by zero will result in an error, with exception to
+/// floating point numbers, which instead follow the IEEE 754 rules
+pub fn rem(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<ArrayRef, ArrowError> {
+    arithmetic_op(Op::Rem, lhs, rhs)
+}
+
+macro_rules! neg_checked {
+    ($t:ty, $a:ident) => {{
+        let array = $a
+            .as_primitive::<$t>()
+            .try_unary::<_, $t, _>(|x| x.neg_checked())?;
+        Ok(Arc::new(array))
+    }};
+}
+
+macro_rules! neg_wrapping {
+    ($t:ty, $a:ident) => {{
+        let array = $a.as_primitive::<$t>().unary::<_, $t>(|x| x.neg_wrapping());
+        Ok(Arc::new(array))
+    }};
+}
+
+/// Negates each element of  `array`, returning an error on overflow
+///
+/// Note: negation of unsigned arrays is not supported and will return in an error,
+/// for wrapping unsigned negation consider using [`neg_wrapping`][neg_wrapping()]
+pub fn neg(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    use DataType::*;
+    use IntervalUnit::*;
+    use TimeUnit::*;
+
+    match array.data_type() {
+        Int8 => neg_checked!(Int8Type, array),
+        Int16 => neg_checked!(Int16Type, array),
+        Int32 => neg_checked!(Int32Type, array),
+        Int64 => neg_checked!(Int64Type, array),
+        Float16 => neg_wrapping!(Float16Type, array),
+        Float32 => neg_wrapping!(Float32Type, array),
+        Float64 => neg_wrapping!(Float64Type, array),
+        Decimal128(p, s) => {
+            let a = array
+                .as_primitive::<Decimal128Type>()
+                .try_unary::<_, Decimal128Type, _>(|x| x.neg_checked())?;
+
+            Ok(Arc::new(a.with_precision_and_scale(*p, *s)?))
+        }
+        Decimal256(p, s) => {
+            let a = array
+                .as_primitive::<Decimal256Type>()
+                .try_unary::<_, Decimal256Type, _>(|x| x.neg_checked())?;
+
+            Ok(Arc::new(a.with_precision_and_scale(*p, *s)?))
+        }
+        Duration(Second) => neg_checked!(DurationSecondType, array),
+        Duration(Millisecond) => neg_checked!(DurationMillisecondType, array),
+        Duration(Microsecond) => neg_checked!(DurationMicrosecondType, array),
+        Duration(Nanosecond) => neg_checked!(DurationNanosecondType, array),
+        Interval(YearMonth) => neg_checked!(IntervalYearMonthType, array),
+        Interval(DayTime) => {
+            let a = array
+                .as_primitive::<IntervalDayTimeType>()
+                .try_unary::<_, IntervalDayTimeType, ArrowError>(|x| {
+                    let (days, ms) = IntervalDayTimeType::to_parts(x);
+                    Ok(IntervalDayTimeType::make_value(
+                        days.neg_checked()?,
+                        ms.neg_checked()?,
+                    ))
+                })?;
+            Ok(Arc::new(a))
+        }
+        Interval(MonthDayNano) => {
+            let a = array
+                .as_primitive::<IntervalMonthDayNanoType>()
+                .try_unary::<_, IntervalMonthDayNanoType, ArrowError>(|x| {
+                    let (months, days, nanos) = IntervalMonthDayNanoType::to_parts(x);
+                    Ok(IntervalMonthDayNanoType::make_value(
+                        months.neg_checked()?,
+                        days.neg_checked()?,
+                        nanos.neg_checked()?,
+                    ))
+                })?;
+            Ok(Arc::new(a))
+        }
+        t => Err(ArrowError::InvalidArgumentError(format!(
+            "Invalid arithmetic operation: !{t}"
+        ))),
+    }
+}
+
+/// Negates each element of  `array`, wrapping on overflow for [`DataType::is_integer`]
+pub fn neg_wrapping(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    downcast_integer! {
+        array.data_type() => (neg_wrapping, array),
+        _ => neg(array),
+    }
+}
+
+/// An enumeration of arithmetic operations
+///
+/// This allows sharing the type dispatch logic across the various kernels
+#[derive(Debug, Copy, Clone)]
+enum Op {
+    AddWrapping,
+    Add,
+    SubWrapping,
+    Sub,
+    MulWrapping,
+    Mul,
+    Div,
+    Rem,
+}
+
+impl std::fmt::Display for Op {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Op::AddWrapping | Op::Add => write!(f, "+"),
+            Op::SubWrapping | Op::Sub => write!(f, "-"),
+            Op::MulWrapping | Op::Mul => write!(f, "*"),
+            Op::Div => write!(f, "/"),
+            Op::Rem => write!(f, "%"),
+        }
+    }
+}
+
+impl Op {
+    fn commutative(&self) -> bool {
+        matches!(self, Self::Add | Self::AddWrapping)
+    }
+}
+
+/// Dispatch the given `op` to the appropriate specialized kernel
+fn arithmetic_op(op: Op, lhs: &dyn Datum, rhs: &dyn Datum) -> Result<ArrayRef, ArrowError> {
+    use DataType::*;
+    use IntervalUnit::*;
+    use TimeUnit::*;
+
+    macro_rules! integer_helper {
+        ($t:ty, $op:ident, $l:ident, $l_scalar:ident, $r:ident, $r_scalar:ident) => {
+            integer_op::<$t>($op, $l, $l_scalar, $r, $r_scalar)
+        };
+    }
+
+    let (l, l_scalar) = lhs.get();
+    let (r, r_scalar) = rhs.get();
+    downcast_integer! {
+        l.data_type(), r.data_type() => (integer_helper, op, l, l_scalar, r, r_scalar),
+        (Float16, Float16) => float_op::<Float16Type>(op, l, l_scalar, r, r_scalar),
+        (Float32, Float32) => float_op::<Float32Type>(op, l, l_scalar, r, r_scalar),
+        (Float64, Float64) => float_op::<Float64Type>(op, l, l_scalar, r, r_scalar),
+        (Timestamp(Second, _), _) => timestamp_op::<TimestampSecondType>(op, l, l_scalar, r, r_scalar),
+        (Timestamp(Millisecond, _), _) => timestamp_op::<TimestampMillisecondType>(op, l, l_scalar, r, r_scalar),
+        (Timestamp(Microsecond, _), _) => timestamp_op::<TimestampMicrosecondType>(op, l, l_scalar, r, r_scalar),
+        (Timestamp(Nanosecond, _), _) => timestamp_op::<TimestampNanosecondType>(op, l, l_scalar, r, r_scalar),
+        (Duration(Second), Duration(Second)) => duration_op::<DurationSecondType>(op, l, l_scalar, r, r_scalar),
+        (Duration(Millisecond), Duration(Millisecond)) => duration_op::<DurationMillisecondType>(op, l, l_scalar, r, r_scalar),
+        (Duration(Microsecond), Duration(Microsecond)) => duration_op::<DurationMicrosecondType>(op, l, l_scalar, r, r_scalar),
+        (Duration(Nanosecond), Duration(Nanosecond)) => duration_op::<DurationNanosecondType>(op, l, l_scalar, r, r_scalar),
+        (Interval(YearMonth), Interval(YearMonth)) => interval_op::<IntervalYearMonthType>(op, l, l_scalar, r, r_scalar),
+        (Interval(DayTime), Interval(DayTime)) => interval_op::<IntervalDayTimeType>(op, l, l_scalar, r, r_scalar),
+        (Interval(MonthDayNano), Interval(MonthDayNano)) => interval_op::<IntervalMonthDayNanoType>(op, l, l_scalar, r, r_scalar),
+        (Date32, _) => date_op::<Date32Type>(op, l, l_scalar, r, r_scalar),
+        (Date64, _) => date_op::<Date64Type>(op, l, l_scalar, r, r_scalar),
+        (Decimal128(_, _), Decimal128(_, _)) => decimal_op::<Decimal128Type>(op, l, l_scalar, r, r_scalar),
+        (Decimal256(_, _), Decimal256(_, _)) => decimal_op::<Decimal256Type>(op, l, l_scalar, r, r_scalar),
+        (l_t, r_t) => match (l_t, r_t) {
+            (Duration(_) | Interval(_), Date32 | Date64 | Timestamp(_, _)) if op.commutative() => {
+                arithmetic_op(op, rhs, lhs)
+            }
+            _ => Err(ArrowError::InvalidArgumentError(
+              format!("Invalid arithmetic operation: {l_t} {op} {r_t}")
+            ))
+        }
+    }
+}
+
+/// Perform an infallible binary operation on potentially scalar inputs
+macro_rules! op {
+    ($l:ident, $l_s:expr, $r:ident, $r_s:expr, $op:expr) => {
+        match ($l_s, $r_s) {
+            (true, true) | (false, false) => binary($l, $r, |$l, $r| $op)?,
+            (true, false) => match ($l.null_count() == 0).then(|| $l.value(0)) {
+                None => PrimitiveArray::new_null($r.len()),
+                Some($l) => $r.unary(|$r| $op),
+            },
+            (false, true) => match ($r.null_count() == 0).then(|| $r.value(0)) {
+                None => PrimitiveArray::new_null($l.len()),
+                Some($r) => $l.unary(|$l| $op),
+            },
+        }
+    };
+}
+
+/// Same as `op` but with a type hint for the returned array
+macro_rules! op_ref {
+    ($t:ty, $l:ident, $l_s:expr, $r:ident, $r_s:expr, $op:expr) => {{
+        let array: PrimitiveArray<$t> = op!($l, $l_s, $r, $r_s, $op);
+        Arc::new(array)
+    }};
+}
+
+/// Perform a fallible binary operation on potentially scalar inputs
+macro_rules! try_op {
+    ($l:ident, $l_s:expr, $r:ident, $r_s:expr, $op:expr) => {
+        match ($l_s, $r_s) {
+            (true, true) | (false, false) => try_binary($l, $r, |$l, $r| $op)?,
+            (true, false) => match ($l.null_count() == 0).then(|| $l.value(0)) {
+                None => PrimitiveArray::new_null($r.len()),
+                Some($l) => $r.try_unary(|$r| $op)?,
+            },
+            (false, true) => match ($r.null_count() == 0).then(|| $r.value(0)) {
+                None => PrimitiveArray::new_null($l.len()),
+                Some($r) => $l.try_unary(|$l| $op)?,
+            },
+        }
+    };
+}
+
+/// Same as `try_op` but with a type hint for the returned array
+macro_rules! try_op_ref {
+    ($t:ty, $l:ident, $l_s:expr, $r:ident, $r_s:expr, $op:expr) => {{
+        let array: PrimitiveArray<$t> = try_op!($l, $l_s, $r, $r_s, $op);
+        Arc::new(array)
+    }};
+}
+
+/// Perform an arithmetic operation on integers
+fn integer_op<T: ArrowPrimitiveType>(
+    op: Op,
+    l: &dyn Array,
+    l_s: bool,
+    r: &dyn Array,
+    r_s: bool,
+) -> Result<ArrayRef, ArrowError> {
+    let l = l.as_primitive::<T>();
+    let r = r.as_primitive::<T>();
+    let array: PrimitiveArray<T> = match op {
+        Op::AddWrapping => op!(l, l_s, r, r_s, l.add_wrapping(r)),
+        Op::Add => try_op!(l, l_s, r, r_s, l.add_checked(r)),
+        Op::SubWrapping => op!(l, l_s, r, r_s, l.sub_wrapping(r)),
+        Op::Sub => try_op!(l, l_s, r, r_s, l.sub_checked(r)),
+        Op::MulWrapping => op!(l, l_s, r, r_s, l.mul_wrapping(r)),
+        Op::Mul => try_op!(l, l_s, r, r_s, l.mul_checked(r)),
+        Op::Div => try_op!(l, l_s, r, r_s, l.div_checked(r)),
+        Op::Rem => try_op!(l, l_s, r, r_s, l.mod_checked(r)),
+    };
+    Ok(Arc::new(array))
+}
+
+/// Perform an arithmetic operation on floats
+fn float_op<T: ArrowPrimitiveType>(
+    op: Op,
+    l: &dyn Array,
+    l_s: bool,
+    r: &dyn Array,
+    r_s: bool,
+) -> Result<ArrayRef, ArrowError> {
+    let l = l.as_primitive::<T>();
+    let r = r.as_primitive::<T>();
+    let array: PrimitiveArray<T> = match op {
+        Op::AddWrapping | Op::Add => op!(l, l_s, r, r_s, l.add_wrapping(r)),
+        Op::SubWrapping | Op::Sub => op!(l, l_s, r, r_s, l.sub_wrapping(r)),
+        Op::MulWrapping | Op::Mul => op!(l, l_s, r, r_s, l.mul_wrapping(r)),
+        Op::Div => op!(l, l_s, r, r_s, l.div_wrapping(r)),
+        Op::Rem => op!(l, l_s, r, r_s, l.mod_wrapping(r)),
+    };
+    Ok(Arc::new(array))
+}
+
+/// Arithmetic trait for timestamp arrays
+trait TimestampOp: ArrowTimestampType {
+    type Duration: ArrowPrimitiveType<Native = i64>;
+
+    fn add_year_month(timestamp: i64, delta: i32, tz: Tz) -> Option<i64>;
+    fn add_day_time(timestamp: i64, delta: i64, tz: Tz) -> Option<i64>;
+    fn add_month_day_nano(timestamp: i64, delta: i128, tz: Tz) -> Option<i64>;
+
+    fn sub_year_month(timestamp: i64, delta: i32, tz: Tz) -> Option<i64>;
+    fn sub_day_time(timestamp: i64, delta: i64, tz: Tz) -> Option<i64>;
+    fn sub_month_day_nano(timestamp: i64, delta: i128, tz: Tz) -> Option<i64>;
+}
+
+macro_rules! timestamp {
+    ($t:ty, $d:ty) => {
+        impl TimestampOp for $t {
+            type Duration = $d;
+
+            fn add_year_month(left: i64, right: i32, tz: Tz) -> Option<i64> {
+                Self::add_year_months(left, right, tz)
+            }
+
+            fn add_day_time(left: i64, right: i64, tz: Tz) -> Option<i64> {
+                Self::add_day_time(left, right, tz)
+            }
+
+            fn add_month_day_nano(left: i64, right: i128, tz: Tz) -> Option<i64> {
+                Self::add_month_day_nano(left, right, tz)
+            }
+
+            fn sub_year_month(left: i64, right: i32, tz: Tz) -> Option<i64> {
+                Self::subtract_year_months(left, right, tz)
+            }
+
+            fn sub_day_time(left: i64, right: i64, tz: Tz) -> Option<i64> {
+                Self::subtract_day_time(left, right, tz)
+            }
+
+            fn sub_month_day_nano(left: i64, right: i128, tz: Tz) -> Option<i64> {
+                Self::subtract_month_day_nano(left, right, tz)
+            }
+        }
+    };
+}
+timestamp!(TimestampSecondType, DurationSecondType);
+timestamp!(TimestampMillisecondType, DurationMillisecondType);
+timestamp!(TimestampMicrosecondType, DurationMicrosecondType);
+timestamp!(TimestampNanosecondType, DurationNanosecondType);
+
+/// Perform arithmetic operation on a timestamp array
+fn timestamp_op<T: TimestampOp>(
+    op: Op,
+    l: &dyn Array,
+    l_s: bool,
+    r: &dyn Array,
+    r_s: bool,
+) -> Result<ArrayRef, ArrowError> {
+    use DataType::*;
+    use IntervalUnit::*;
+
+    let l = l.as_primitive::<T>();
+    let l_tz: Tz = l.timezone().unwrap_or("+00:00").parse()?;
+
+    let array: PrimitiveArray<T> = match (op, r.data_type()) {
+        (Op::Sub | Op::SubWrapping, Timestamp(unit, _)) if unit == &T::UNIT => {
+            let r = r.as_primitive::<T>();
+            return Ok(try_op_ref!(T::Duration, l, l_s, r, r_s, l.sub_checked(r)));
+        }
+
+        (Op::Add | Op::AddWrapping, Duration(unit)) if unit == &T::UNIT => {
+            let r = r.as_primitive::<T::Duration>();
+            try_op!(l, l_s, r, r_s, l.add_checked(r))
+        }
+        (Op::Sub | Op::SubWrapping, Duration(unit)) if unit == &T::UNIT => {
+            let r = r.as_primitive::<T::Duration>();
+            try_op!(l, l_s, r, r_s, l.sub_checked(r))
+        }
+
+        (Op::Add | Op::AddWrapping, Interval(YearMonth)) => {
+            let r = r.as_primitive::<IntervalYearMonthType>();
+            try_op!(
+                l,
+                l_s,
+                r,
+                r_s,
+                T::add_year_month(l, r, l_tz).ok_or(ArrowError::ComputeError(
+                    "Timestamp out of range".to_string()
+                ))
+            )
+        }
+        (Op::Sub | Op::SubWrapping, Interval(YearMonth)) => {
+            let r = r.as_primitive::<IntervalYearMonthType>();
+            try_op!(
+                l,
+                l_s,
+                r,
+                r_s,
+                T::sub_year_month(l, r, l_tz).ok_or(ArrowError::ComputeError(
+                    "Timestamp out of range".to_string()
+                ))
+            )
+        }
+
+        (Op::Add | Op::AddWrapping, Interval(DayTime)) => {
+            let r = r.as_primitive::<IntervalDayTimeType>();
+            try_op!(
+                l,
+                l_s,
+                r,
+                r_s,
+                T::add_day_time(l, r, l_tz).ok_or(ArrowError::ComputeError(
+                    "Timestamp out of range".to_string()
+                ))
+            )
+        }
+        (Op::Sub | Op::SubWrapping, Interval(DayTime)) => {
+            let r = r.as_primitive::<IntervalDayTimeType>();
+            try_op!(
+                l,
+                l_s,
+                r,
+                r_s,
+                T::sub_day_time(l, r, l_tz).ok_or(ArrowError::ComputeError(
+                    "Timestamp out of range".to_string()
+                ))
+            )
+        }
+
+        (Op::Add | Op::AddWrapping, Interval(MonthDayNano)) => {
+            let r = r.as_primitive::<IntervalMonthDayNanoType>();
+            try_op!(
+                l,
+                l_s,
+                r,
+                r_s,
+                T::add_month_day_nano(l, r, l_tz).ok_or(ArrowError::ComputeError(
+                    "Timestamp out of range".to_string()
+                ))
+            )
+        }
+        (Op::Sub | Op::SubWrapping, Interval(MonthDayNano)) => {
+            let r = r.as_primitive::<IntervalMonthDayNanoType>();
+            try_op!(
+                l,
+                l_s,
+                r,
+                r_s,
+                T::sub_month_day_nano(l, r, l_tz).ok_or(ArrowError::ComputeError(
+                    "Timestamp out of range".to_string()
+                ))
+            )
+        }
+        _ => {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Invalid timestamp arithmetic operation: {} {op} {}",
+                l.data_type(),
+                r.data_type()
+            )))
+        }
+    };
+    Ok(Arc::new(array.with_timezone_opt(l.timezone())))
+}
+
+/// Arithmetic trait for date arrays
+///
+/// Note: these should be fallible (#4456)
+trait DateOp: ArrowTemporalType {
+    fn add_year_month(timestamp: Self::Native, delta: i32) -> Self::Native;
+    fn add_day_time(timestamp: Self::Native, delta: i64) -> Self::Native;
+    fn add_month_day_nano(timestamp: Self::Native, delta: i128) -> Self::Native;
+
+    fn sub_year_month(timestamp: Self::Native, delta: i32) -> Self::Native;
+    fn sub_day_time(timestamp: Self::Native, delta: i64) -> Self::Native;
+    fn sub_month_day_nano(timestamp: Self::Native, delta: i128) -> Self::Native;
+}
+
+macro_rules! date {
+    ($t:ty) => {
+        impl DateOp for $t {
+            fn add_year_month(left: Self::Native, right: i32) -> Self::Native {
+                Self::add_year_months(left, right)
+            }
+
+            fn add_day_time(left: Self::Native, right: i64) -> Self::Native {
+                Self::add_day_time(left, right)
+            }
+
+            fn add_month_day_nano(left: Self::Native, right: i128) -> Self::Native {
+                Self::add_month_day_nano(left, right)
+            }
+
+            fn sub_year_month(left: Self::Native, right: i32) -> Self::Native {
+                Self::subtract_year_months(left, right)
+            }
+
+            fn sub_day_time(left: Self::Native, right: i64) -> Self::Native {
+                Self::subtract_day_time(left, right)
+            }
+
+            fn sub_month_day_nano(left: Self::Native, right: i128) -> Self::Native {
+                Self::subtract_month_day_nano(left, right)
+            }
+        }
+    };
+}
+date!(Date32Type);
+date!(Date64Type);
+
+/// Arithmetic trait for interval arrays
+trait IntervalOp: ArrowPrimitiveType {
+    fn add(left: Self::Native, right: Self::Native) -> Result<Self::Native, ArrowError>;
+    fn sub(left: Self::Native, right: Self::Native) -> Result<Self::Native, ArrowError>;
+}
+
+impl IntervalOp for IntervalYearMonthType {
+    fn add(left: Self::Native, right: Self::Native) -> Result<Self::Native, ArrowError> {
+        left.add_checked(right)
+    }
+
+    fn sub(left: Self::Native, right: Self::Native) -> Result<Self::Native, ArrowError> {
+        left.sub_checked(right)
+    }
+}
+
+impl IntervalOp for IntervalDayTimeType {
+    fn add(left: Self::Native, right: Self::Native) -> Result<Self::Native, ArrowError> {
+        let (l_days, l_ms) = Self::to_parts(left);
+        let (r_days, r_ms) = Self::to_parts(right);
+        let days = l_days.add_checked(r_days)?;
+        let ms = l_ms.add_checked(r_ms)?;
+        Ok(Self::make_value(days, ms))
+    }
+
+    fn sub(left: Self::Native, right: Self::Native) -> Result<Self::Native, ArrowError> {
+        let (l_days, l_ms) = Self::to_parts(left);
+        let (r_days, r_ms) = Self::to_parts(right);
+        let days = l_days.sub_checked(r_days)?;
+        let ms = l_ms.sub_checked(r_ms)?;
+        Ok(Self::make_value(days, ms))
+    }
+}
+
+impl IntervalOp for IntervalMonthDayNanoType {
+    fn add(left: Self::Native, right: Self::Native) -> Result<Self::Native, ArrowError> {
+        let (l_months, l_days, l_nanos) = Self::to_parts(left);
+        let (r_months, r_days, r_nanos) = Self::to_parts(right);
+        let months = l_months.add_checked(r_months)?;
+        let days = l_days.add_checked(r_days)?;
+        let nanos = l_nanos.add_checked(r_nanos)?;
+        Ok(Self::make_value(months, days, nanos))
+    }
+
+    fn sub(left: Self::Native, right: Self::Native) -> Result<Self::Native, ArrowError> {
+        let (l_months, l_days, l_nanos) = Self::to_parts(left);
+        let (r_months, r_days, r_nanos) = Self::to_parts(right);
+        let months = l_months.sub_checked(r_months)?;
+        let days = l_days.sub_checked(r_days)?;
+        let nanos = l_nanos.sub_checked(r_nanos)?;
+        Ok(Self::make_value(months, days, nanos))
+    }
+}
+
+/// Perform arithmetic operation on an interval array
+fn interval_op<T: IntervalOp>(
+    op: Op,
+    l: &dyn Array,
+    l_s: bool,
+    r: &dyn Array,
+    r_s: bool,
+) -> Result<ArrayRef, ArrowError> {
+    let l = l.as_primitive::<T>();
+    let r = r.as_primitive::<T>();
+    match op {
+        Op::Add | Op::AddWrapping => Ok(try_op_ref!(T, l, l_s, r, r_s, T::add(l, r))),
+        Op::Sub | Op::SubWrapping => Ok(try_op_ref!(T, l, l_s, r, r_s, T::sub(l, r))),
+        _ => Err(ArrowError::InvalidArgumentError(format!(
+            "Invalid interval arithmetic operation: {} {op} {}",
+            l.data_type(),
+            r.data_type()
+        ))),
+    }
+}
+
+fn duration_op<T: ArrowPrimitiveType>(
+    op: Op,
+    l: &dyn Array,
+    l_s: bool,
+    r: &dyn Array,
+    r_s: bool,
+) -> Result<ArrayRef, ArrowError> {
+    let l = l.as_primitive::<T>();
+    let r = r.as_primitive::<T>();
+    match op {
+        Op::Add | Op::AddWrapping => Ok(try_op_ref!(T, l, l_s, r, r_s, l.add_checked(r))),
+        Op::Sub | Op::SubWrapping => Ok(try_op_ref!(T, l, l_s, r, r_s, l.sub_checked(r))),
+        _ => Err(ArrowError::InvalidArgumentError(format!(
+            "Invalid duration arithmetic operation: {} {op} {}",
+            l.data_type(),
+            r.data_type()
+        ))),
+    }
+}
+
+/// Perform arithmetic operation on a date array
+fn date_op<T: DateOp>(
+    op: Op,
+    l: &dyn Array,
+    l_s: bool,
+    r: &dyn Array,
+    r_s: bool,
+) -> Result<ArrayRef, ArrowError> {
+    use DataType::*;
+    use IntervalUnit::*;
+
+    const NUM_SECONDS_IN_DAY: i64 = 60 * 60 * 24;
+
+    let r_t = r.data_type();
+    match (T::DATA_TYPE, op, r_t) {
+        (Date32, Op::Sub | Op::SubWrapping, Date32) => {
+            let l = l.as_primitive::<Date32Type>();
+            let r = r.as_primitive::<Date32Type>();
+            return Ok(op_ref!(
+                DurationSecondType,
+                l,
+                l_s,
+                r,
+                r_s,
+                ((l as i64) - (r as i64)) * NUM_SECONDS_IN_DAY
+            ));
+        }
+        (Date64, Op::Sub | Op::SubWrapping, Date64) => {
+            let l = l.as_primitive::<Date64Type>();
+            let r = r.as_primitive::<Date64Type>();
+            let result = try_op_ref!(DurationMillisecondType, l, l_s, r, r_s, l.sub_checked(r));
+            return Ok(result);
+        }
+        _ => {}
+    }
+
+    let l = l.as_primitive::<T>();
+    match (op, r_t) {
+        (Op::Add | Op::AddWrapping, Interval(YearMonth)) => {
+            let r = r.as_primitive::<IntervalYearMonthType>();
+            Ok(op_ref!(T, l, l_s, r, r_s, T::add_year_month(l, r)))
+        }
+        (Op::Sub | Op::SubWrapping, Interval(YearMonth)) => {
+            let r = r.as_primitive::<IntervalYearMonthType>();
+            Ok(op_ref!(T, l, l_s, r, r_s, T::sub_year_month(l, r)))
+        }
+
+        (Op::Add | Op::AddWrapping, Interval(DayTime)) => {
+            let r = r.as_primitive::<IntervalDayTimeType>();
+            Ok(op_ref!(T, l, l_s, r, r_s, T::add_day_time(l, r)))
+        }
+        (Op::Sub | Op::SubWrapping, Interval(DayTime)) => {
+            let r = r.as_primitive::<IntervalDayTimeType>();
+            Ok(op_ref!(T, l, l_s, r, r_s, T::sub_day_time(l, r)))
+        }
+
+        (Op::Add | Op::AddWrapping, Interval(MonthDayNano)) => {
+            let r = r.as_primitive::<IntervalMonthDayNanoType>();
+            Ok(op_ref!(T, l, l_s, r, r_s, T::add_month_day_nano(l, r)))
+        }
+        (Op::Sub | Op::SubWrapping, Interval(MonthDayNano)) => {
+            let r = r.as_primitive::<IntervalMonthDayNanoType>();
+            Ok(op_ref!(T, l, l_s, r, r_s, T::sub_month_day_nano(l, r)))
+        }
+
+        _ => Err(ArrowError::InvalidArgumentError(format!(
+            "Invalid date arithmetic operation: {} {op} {}",
+            l.data_type(),
+            r.data_type()
+        ))),
+    }
+}
+
+/// Perform arithmetic operation on decimal arrays
+fn decimal_op<T: DecimalType>(
+    op: Op,
+    l: &dyn Array,
+    l_s: bool,
+    r: &dyn Array,
+    r_s: bool,
+) -> Result<ArrayRef, ArrowError> {
+    let l = l.as_primitive::<T>();
+    let r = r.as_primitive::<T>();
+
+    let (p1, s1, p2, s2) = match (l.data_type(), r.data_type()) {
+        (DataType::Decimal128(p1, s1), DataType::Decimal128(p2, s2)) => (p1, s1, p2, s2),
+        (DataType::Decimal256(p1, s1), DataType::Decimal256(p2, s2)) => (p1, s1, p2, s2),
+        _ => unreachable!(),
+    };
+
+    // Follow the Hive decimal arithmetic rules
+    // https://cwiki.apache.org/confluence/download/attachments/27362075/Hive_Decimal_Precision_Scale_Support.pdf
+    let array: PrimitiveArray<T> = match op {
+        Op::Add | Op::AddWrapping | Op::Sub | Op::SubWrapping => {
+            // max(s1, s2)
+            let result_scale = *s1.max(s2);
+
+            // max(s1, s2) + max(p1-s1, p2-s2) + 1
+            let result_precision =
+                (result_scale.saturating_add((*p1 as i8 - s1).max(*p2 as i8 - s2)) as u8)
+                    .saturating_add(1)
+                    .min(T::MAX_PRECISION);
+
+            let l_mul = T::Native::usize_as(10).pow_checked((result_scale - s1) as _)?;
+            let r_mul = T::Native::usize_as(10).pow_checked((result_scale - s2) as _)?;
+
+            match op {
+                Op::Add | Op::AddWrapping => {
+                    try_op!(
+                        l,
+                        l_s,
+                        r,
+                        r_s,
+                        l.mul_checked(l_mul)?.add_checked(r.mul_checked(r_mul)?)
+                    )
+                }
+                Op::Sub | Op::SubWrapping => {
+                    try_op!(
+                        l,
+                        l_s,
+                        r,
+                        r_s,
+                        l.mul_checked(l_mul)?.sub_checked(r.mul_checked(r_mul)?)
+                    )
+                }
+                _ => unreachable!(),
+            }
+            .with_precision_and_scale(result_precision, result_scale)?
+        }
+        Op::Mul | Op::MulWrapping => {
+            let result_precision = p1.saturating_add(p2 + 1).min(T::MAX_PRECISION);
+            let result_scale = s1.saturating_add(*s2);
+            if result_scale > T::MAX_SCALE {
+                // SQL standard says that if the resulting scale of a multiply operation goes
+                // beyond the maximum, rounding is not acceptable and thus an error occurs
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Output scale of {} {op} {} would exceed max scale of {}",
+                    l.data_type(),
+                    r.data_type(),
+                    T::MAX_SCALE
+                )));
+            }
+
+            try_op!(l, l_s, r, r_s, l.mul_checked(r))
+                .with_precision_and_scale(result_precision, result_scale)?
+        }
+
+        Op::Div => {
+            // Follow postgres and MySQL adding a fixed scale increment of 4
+            // s1 + 4
+            let result_scale = s1.saturating_add(4).min(T::MAX_SCALE);
+            let mul_pow = result_scale - s1 + s2;
+
+            // p1 - s1 + s2 + result_scale
+            let result_precision = (mul_pow.saturating_add(*p1 as i8) as u8).min(T::MAX_PRECISION);
+
+            let (l_mul, r_mul) = match mul_pow.cmp(&0) {
+                Ordering::Greater => (
+                    T::Native::usize_as(10).pow_checked(mul_pow as _)?,
+                    T::Native::ONE,
+                ),
+                Ordering::Equal => (T::Native::ONE, T::Native::ONE),
+                Ordering::Less => (
+                    T::Native::ONE,
+                    T::Native::usize_as(10).pow_checked(mul_pow.neg_wrapping() as _)?,
+                ),
+            };
+
+            try_op!(
+                l,
+                l_s,
+                r,
+                r_s,
+                l.mul_checked(l_mul)?.div_checked(r.mul_checked(r_mul)?)
+            )
+            .with_precision_and_scale(result_precision, result_scale)?
+        }
+
+        Op::Rem => {
+            // max(s1, s2)
+            let result_scale = *s1.max(s2);
+            // min(p1-s1, p2 -s2) + max( s1,s2 )
+            let result_precision =
+                (result_scale.saturating_add((*p1 as i8 - s1).min(*p2 as i8 - s2)) as u8)
+                    .min(T::MAX_PRECISION);
+
+            let l_mul = T::Native::usize_as(10).pow_wrapping((result_scale - s1) as _);
+            let r_mul = T::Native::usize_as(10).pow_wrapping((result_scale - s2) as _);
+
+            try_op!(
+                l,
+                l_s,
+                r,
+                r_s,
+                l.mul_checked(l_mul)?.mod_checked(r.mul_checked(r_mul)?)
+            )
+            .with_precision_and_scale(result_precision, result_scale)?
+        }
+    };
+
+    Ok(Arc::new(array))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::temporal_conversions::{as_date, as_datetime};
+    use arrow_buffer::{i256, ScalarBuffer};
+    use chrono::{DateTime, NaiveDate};
+
+    fn test_neg_primitive<T: ArrowPrimitiveType>(
+        input: &[T::Native],
+        out: Result<&[T::Native], &str>,
+    ) {
+        let a = PrimitiveArray::<T>::new(ScalarBuffer::from(input.to_vec()), None);
+        match out {
+            Ok(expected) => {
+                let result = neg(&a).unwrap();
+                assert_eq!(result.as_primitive::<T>().values(), expected);
+            }
+            Err(e) => {
+                let err = neg(&a).unwrap_err().to_string();
+                assert_eq!(e, err);
+            }
+        }
+    }
+
+    #[test]
+    fn test_neg() {
+        let input = &[1, -5, 2, 693, 3929];
+        let output = &[-1, 5, -2, -693, -3929];
+        test_neg_primitive::<Int32Type>(input, Ok(output));
+
+        let input = &[1, -5, 2, 693, 3929];
+        let output = &[-1, 5, -2, -693, -3929];
+        test_neg_primitive::<Int64Type>(input, Ok(output));
+        test_neg_primitive::<DurationSecondType>(input, Ok(output));
+        test_neg_primitive::<DurationMillisecondType>(input, Ok(output));
+        test_neg_primitive::<DurationMicrosecondType>(input, Ok(output));
+        test_neg_primitive::<DurationNanosecondType>(input, Ok(output));
+
+        let input = &[f32::MAX, f32::MIN, f32::INFINITY, 1.3, 0.5];
+        let output = &[f32::MIN, f32::MAX, f32::NEG_INFINITY, -1.3, -0.5];
+        test_neg_primitive::<Float32Type>(input, Ok(output));
+
+        test_neg_primitive::<Int32Type>(
+            &[i32::MIN],
+            Err("Compute error: Overflow happened on: -2147483648"),
+        );
+        test_neg_primitive::<Int64Type>(
+            &[i64::MIN],
+            Err("Compute error: Overflow happened on: -9223372036854775808"),
+        );
+        test_neg_primitive::<DurationSecondType>(
+            &[i64::MIN],
+            Err("Compute error: Overflow happened on: -9223372036854775808"),
+        );
+
+        let r = neg_wrapping(&Int32Array::from(vec![i32::MIN])).unwrap();
+        assert_eq!(r.as_primitive::<Int32Type>().value(0), i32::MIN);
+
+        let r = neg_wrapping(&Int64Array::from(vec![i64::MIN])).unwrap();
+        assert_eq!(r.as_primitive::<Int64Type>().value(0), i64::MIN);
+
+        let err = neg_wrapping(&DurationSecondArray::from(vec![i64::MIN]))
+            .unwrap_err()
+            .to_string();
+
+        assert_eq!(
+            err,
+            "Compute error: Overflow happened on: -9223372036854775808"
+        );
+
+        let a = Decimal128Array::from(vec![1, 3, -44, 2, 4])
+            .with_precision_and_scale(9, 6)
+            .unwrap();
+
+        let r = neg(&a).unwrap();
+        assert_eq!(r.data_type(), a.data_type());
+        assert_eq!(
+            r.as_primitive::<Decimal128Type>().values(),
+            &[-1, -3, 44, -2, -4]
+        );
+
+        let a = Decimal256Array::from(vec![
+            i256::from_i128(342),
+            i256::from_i128(-4949),
+            i256::from_i128(3),
+        ])
+        .with_precision_and_scale(9, 6)
+        .unwrap();
+
+        let r = neg(&a).unwrap();
+        assert_eq!(r.data_type(), a.data_type());
+        assert_eq!(
+            r.as_primitive::<Decimal256Type>().values(),
+            &[
+                i256::from_i128(-342),
+                i256::from_i128(4949),
+                i256::from_i128(-3),
+            ]
+        );
+
+        let a = IntervalYearMonthArray::from(vec![
+            IntervalYearMonthType::make_value(2, 4),
+            IntervalYearMonthType::make_value(2, -4),
+            IntervalYearMonthType::make_value(-3, -5),
+        ]);
+        let r = neg(&a).unwrap();
+        assert_eq!(
+            r.as_primitive::<IntervalYearMonthType>().values(),
+            &[
+                IntervalYearMonthType::make_value(-2, -4),
+                IntervalYearMonthType::make_value(-2, 4),
+                IntervalYearMonthType::make_value(3, 5),
+            ]
+        );
+
+        let a = IntervalDayTimeArray::from(vec![
+            IntervalDayTimeType::make_value(2, 4),
+            IntervalDayTimeType::make_value(2, -4),
+            IntervalDayTimeType::make_value(-3, -5),
+        ]);
+        let r = neg(&a).unwrap();
+        assert_eq!(
+            r.as_primitive::<IntervalDayTimeType>().values(),
+            &[
+                IntervalDayTimeType::make_value(-2, -4),
+                IntervalDayTimeType::make_value(-2, 4),
+                IntervalDayTimeType::make_value(3, 5),
+            ]
+        );
+
+        let a = IntervalMonthDayNanoArray::from(vec![
+            IntervalMonthDayNanoType::make_value(2, 4, 5953394),
+            IntervalMonthDayNanoType::make_value(2, -4, -45839),
+            IntervalMonthDayNanoType::make_value(-3, -5, 6944),
+        ]);
+        let r = neg(&a).unwrap();
+        assert_eq!(
+            r.as_primitive::<IntervalMonthDayNanoType>().values(),
+            &[
+                IntervalMonthDayNanoType::make_value(-2, -4, -5953394),
+                IntervalMonthDayNanoType::make_value(-2, 4, 45839),
+                IntervalMonthDayNanoType::make_value(3, 5, -6944),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_integer() {
+        let a = Int32Array::from(vec![4, 3, 5, -6, 100]);
+        let b = Int32Array::from(vec![6, 2, 5, -7, 3]);
+        let result = add(&a, &b).unwrap();
+        assert_eq!(
+            result.as_ref(),
+            &Int32Array::from(vec![10, 5, 10, -13, 103])
+        );
+        let result = sub(&a, &b).unwrap();
+        assert_eq!(result.as_ref(), &Int32Array::from(vec![-2, 1, 0, 1, 97]));
+        let result = div(&a, &b).unwrap();
+        assert_eq!(result.as_ref(), &Int32Array::from(vec![0, 1, 1, 0, 33]));
+        let result = mul(&a, &b).unwrap();
+        assert_eq!(result.as_ref(), &Int32Array::from(vec![24, 6, 25, 42, 300]));
+        let result = rem(&a, &b).unwrap();
+        assert_eq!(result.as_ref(), &Int32Array::from(vec![4, 1, 0, -6, 1]));
+
+        let a = Int8Array::from(vec![Some(2), None, Some(45)]);
+        let b = Int8Array::from(vec![Some(5), Some(3), None]);
+        let result = add(&a, &b).unwrap();
+        assert_eq!(result.as_ref(), &Int8Array::from(vec![Some(7), None, None]));
+
+        let a = UInt8Array::from(vec![56, 5, 3]);
+        let b = UInt8Array::from(vec![200, 2, 5]);
+        let err = add(&a, &b).unwrap_err().to_string();
+        assert_eq!(err, "Compute error: Overflow happened on: 56 + 200");
+        let result = add_wrapping(&a, &b).unwrap();
+        assert_eq!(result.as_ref(), &UInt8Array::from(vec![0, 7, 8]));
+
+        let a = UInt8Array::from(vec![34, 5, 3]);
+        let b = UInt8Array::from(vec![200, 2, 5]);
+        let err = sub(&a, &b).unwrap_err().to_string();
+        assert_eq!(err, "Compute error: Overflow happened on: 34 - 200");
+        let result = sub_wrapping(&a, &b).unwrap();
+        assert_eq!(result.as_ref(), &UInt8Array::from(vec![90, 3, 254]));
+
+        let a = UInt8Array::from(vec![34, 5, 3]);
+        let b = UInt8Array::from(vec![200, 2, 5]);
+        let err = mul(&a, &b).unwrap_err().to_string();
+        assert_eq!(err, "Compute error: Overflow happened on: 34 * 200");
+        let result = mul_wrapping(&a, &b).unwrap();
+        assert_eq!(result.as_ref(), &UInt8Array::from(vec![144, 10, 15]));
+
+        let a = Int16Array::from(vec![i16::MIN]);
+        let b = Int16Array::from(vec![-1]);
+        let err = div(&a, &b).unwrap_err().to_string();
+        assert_eq!(err, "Compute error: Overflow happened on: -32768 / -1");
+
+        let a = Int16Array::from(vec![21]);
+        let b = Int16Array::from(vec![0]);
+        let err = div(&a, &b).unwrap_err().to_string();
+        assert_eq!(err, "Divide by zero error");
+
+        let a = Int16Array::from(vec![21]);
+        let b = Int16Array::from(vec![0]);
+        let err = rem(&a, &b).unwrap_err().to_string();
+        assert_eq!(err, "Divide by zero error");
+    }
+
+    #[test]
+    fn test_float() {
+        let a = Float32Array::from(vec![1., f32::MAX, 6., -4., -1., 0.]);
+        let b = Float32Array::from(vec![1., f32::MAX, f32::MAX, -3., 45., 0.]);
+        let result = add(&a, &b).unwrap();
+        assert_eq!(
+            result.as_ref(),
+            &Float32Array::from(vec![2., f32::INFINITY, f32::MAX, -7., 44.0, 0.])
+        );
+
+        let result = sub(&a, &b).unwrap();
+        assert_eq!(
+            result.as_ref(),
+            &Float32Array::from(vec![0., 0., f32::MIN, -1., -46., 0.])
+        );
+
+        let result = mul(&a, &b).unwrap();
+        assert_eq!(
+            result.as_ref(),
+            &Float32Array::from(vec![1., f32::INFINITY, f32::INFINITY, 12., -45., 0.])
+        );
+
+        let result = div(&a, &b).unwrap();
+        let r = result.as_primitive::<Float32Type>();
+        assert_eq!(r.value(0), 1.);
+        assert_eq!(r.value(1), 1.);
+        assert!(r.value(2) < f32::EPSILON);
+        assert_eq!(r.value(3), -4. / -3.);
+        assert!(r.value(5).is_nan());
+
+        let result = rem(&a, &b).unwrap();
+        let r = result.as_primitive::<Float32Type>();
+        assert_eq!(&r.values()[..5], &[0., 0., 6., -1., -1.]);
+        assert!(r.value(5).is_nan());
+    }
+
+    #[test]
+    fn test_decimal() {
+        // 0.015 7.842 -0.577 0.334 -0.078 0.003
+        let a = Decimal128Array::from(vec![15, 0, -577, 334, -78, 3])
+            .with_precision_and_scale(12, 3)
+            .unwrap();
+
+        // 5.4 0 -35.6 0.3 0.6 7.45
+        let b = Decimal128Array::from(vec![54, 34, -356, 3, 6, 745])
+            .with_precision_and_scale(12, 1)
+            .unwrap();
+
+        let result = add(&a, &b).unwrap();
+        assert_eq!(result.data_type(), &DataType::Decimal128(15, 3));
+        assert_eq!(
+            result.as_primitive::<Decimal128Type>().values(),
+            &[5415, 3400, -36177, 634, 522, 74503]
+        );
+
+        let result = sub(&a, &b).unwrap();
+        assert_eq!(result.data_type(), &DataType::Decimal128(15, 3));
+        assert_eq!(
+            result.as_primitive::<Decimal128Type>().values(),
+            &[-5385, -3400, 35023, 34, -678, -74497]
+        );
+
+        let result = mul(&a, &b).unwrap();
+        assert_eq!(result.data_type(), &DataType::Decimal128(25, 4));
+        assert_eq!(
+            result.as_primitive::<Decimal128Type>().values(),
+            &[810, 0, 205412, 1002, -468, 2235]
+        );
+
+        let result = div(&a, &b).unwrap();
+        assert_eq!(result.data_type(), &DataType::Decimal128(17, 7));
+        assert_eq!(
+            result.as_primitive::<Decimal128Type>().values(),
+            &[27777, 0, 162078, 11133333, -1300000, 402]
+        );
+
+        let result = rem(&a, &b).unwrap();
+        assert_eq!(result.data_type(), &DataType::Decimal128(12, 3));
+        assert_eq!(
+            result.as_primitive::<Decimal128Type>().values(),
+            &[15, 0, -577, 34, -78, 3]
+        );
+
+        let a = Decimal128Array::from(vec![1])
+            .with_precision_and_scale(3, 3)
+            .unwrap();
+        let b = Decimal128Array::from(vec![1])
+            .with_precision_and_scale(37, 37)
+            .unwrap();
+        let err = mul(&a, &b).unwrap_err().to_string();
+        assert_eq!(err, "Invalid argument error: Output scale of Decimal128(3, 3) * Decimal128(37, 37) would exceed max scale of 38");
+
+        let a = Decimal128Array::from(vec![1])
+            .with_precision_and_scale(3, -2)
+            .unwrap();
+        let err = add(&a, &b).unwrap_err().to_string();
+        assert_eq!(err, "Compute error: Overflow happened on: 10 ^ 39");
+
+        let a = Decimal128Array::from(vec![10])
+            .with_precision_and_scale(3, -1)
+            .unwrap();
+        let err = add(&a, &b).unwrap_err().to_string();
+        assert_eq!(
+            err,
+            "Compute error: Overflow happened on: 10 * 100000000000000000000000000000000000000"
+        );
+
+        let b = Decimal128Array::from(vec![0])
+            .with_precision_and_scale(1, 1)
+            .unwrap();
+        let err = div(&a, &b).unwrap_err().to_string();
+        assert_eq!(err, "Divide by zero error");
+        let err = rem(&a, &b).unwrap_err().to_string();
+        assert_eq!(err, "Divide by zero error");
+    }
+
+    fn test_timestamp_impl<T: TimestampOp>() {
+        let a = PrimitiveArray::<T>::new(vec![2000000, 434030324, 53943340].into(), None);
+        let b = PrimitiveArray::<T>::new(vec![329593, 59349, 694994].into(), None);
+
+        let result = sub(&a, &b).unwrap();
+        assert_eq!(
+            result.as_primitive::<T::Duration>().values(),
+            &[1670407, 433970975, 53248346]
+        );
+
+        let r2 = add(&b, &result.as_ref()).unwrap();
+        assert_eq!(r2.as_ref(), &a);
+
+        let r3 = add(&result.as_ref(), &b).unwrap();
+        assert_eq!(r3.as_ref(), &a);
+
+        let format_array = |x: &dyn Array| -> Vec<String> {
+            x.as_primitive::<T>()
+                .values()
+                .into_iter()
+                .map(|x| as_datetime::<T>(*x).unwrap().to_string())
+                .collect()
+        };
+
+        let values = vec![
+            "1970-01-01T00:00:00Z",
+            "2010-04-01T04:00:20Z",
+            "1960-01-30T04:23:20Z",
+        ]
+        .into_iter()
+        .map(|x| T::make_value(DateTime::parse_from_rfc3339(x).unwrap().naive_utc()).unwrap())
+        .collect();
+
+        let a = PrimitiveArray::<T>::new(values, None);
+        let b = IntervalYearMonthArray::from(vec![
+            IntervalYearMonthType::make_value(5, 34),
+            IntervalYearMonthType::make_value(-2, 4),
+            IntervalYearMonthType::make_value(7, -4),
+        ]);
+        let r4 = add(&a, &b).unwrap();
+        assert_eq!(
+            &format_array(r4.as_ref()),
+            &[
+                "1977-11-01 00:00:00".to_string(),
+                "2008-08-01 04:00:20".to_string(),
+                "1966-09-30 04:23:20".to_string()
+            ]
+        );
+
+        let r5 = sub(&r4, &b).unwrap();
+        assert_eq!(r5.as_ref(), &a);
+
+        let b = IntervalDayTimeArray::from(vec![
+            IntervalDayTimeType::make_value(5, 454000),
+            IntervalDayTimeType::make_value(-34, 0),
+            IntervalDayTimeType::make_value(7, -4000),
+        ]);
+        let r6 = add(&a, &b).unwrap();
+        assert_eq!(
+            &format_array(r6.as_ref()),
+            &[
+                "1970-01-06 00:07:34".to_string(),
+                "2010-02-26 04:00:20".to_string(),
+                "1960-02-06 04:23:16".to_string()
+            ]
+        );
+
+        let r7 = sub(&r6, &b).unwrap();
+        assert_eq!(r7.as_ref(), &a);
+
+        let b = IntervalMonthDayNanoArray::from(vec![
+            IntervalMonthDayNanoType::make_value(344, 34, -43_000_000_000),
+            IntervalMonthDayNanoType::make_value(-593, -33, 13_000_000_000),
+            IntervalMonthDayNanoType::make_value(5, 2, 493_000_000_000),
+        ]);
+        let r8 = add(&a, &b).unwrap();
+        assert_eq!(
+            &format_array(r8.as_ref()),
+            &[
+                "1998-10-04 23:59:17".to_string(),
+                "1960-09-29 04:00:33".to_string(),
+                "1960-07-02 04:31:33".to_string()
+            ]
+        );
+
+        let r9 = sub(&r8, &b).unwrap();
+        // Note: subtraction is not the inverse of addition for intervals
+        assert_eq!(
+            &format_array(r9.as_ref()),
+            &[
+                "1970-01-02 00:00:00".to_string(),
+                "2010-04-02 04:00:20".to_string(),
+                "1960-01-31 04:23:20".to_string()
+            ]
+        );
+    }
+
+    #[test]
+    fn test_timestamp() {
+        test_timestamp_impl::<TimestampSecondType>();
+        test_timestamp_impl::<TimestampMillisecondType>();
+        test_timestamp_impl::<TimestampMicrosecondType>();
+        test_timestamp_impl::<TimestampNanosecondType>();
+    }
+
+    #[test]
+    fn test_interval() {
+        let a = IntervalYearMonthArray::from(vec![
+            IntervalYearMonthType::make_value(32, 4),
+            IntervalYearMonthType::make_value(32, 4),
+        ]);
+        let b = IntervalYearMonthArray::from(vec![
+            IntervalYearMonthType::make_value(-4, 6),
+            IntervalYearMonthType::make_value(-3, 23),
+        ]);
+        let result = add(&a, &b).unwrap();
+        assert_eq!(
+            result.as_ref(),
+            &IntervalYearMonthArray::from(vec![
+                IntervalYearMonthType::make_value(28, 10),
+                IntervalYearMonthType::make_value(29, 27)
+            ])
+        );
+        let result = sub(&a, &b).unwrap();
+        assert_eq!(
+            result.as_ref(),
+            &IntervalYearMonthArray::from(vec![
+                IntervalYearMonthType::make_value(36, -2),
+                IntervalYearMonthType::make_value(35, -19)
+            ])
+        );
+
+        let a = IntervalDayTimeArray::from(vec![
+            IntervalDayTimeType::make_value(32, 4),
+            IntervalDayTimeType::make_value(32, 4),
+        ]);
+        let b = IntervalDayTimeArray::from(vec![
+            IntervalDayTimeType::make_value(-4, 6),
+            IntervalDayTimeType::make_value(-3, 23),
+        ]);
+        let result = add(&a, &b).unwrap();
+        assert_eq!(
+            result.as_ref(),
+            &IntervalDayTimeArray::from(vec![
+                IntervalDayTimeType::make_value(28, 10),
+                IntervalDayTimeType::make_value(29, 27)
+            ])
+        );
+        let result = sub(&a, &b).unwrap();
+        assert_eq!(
+            result.as_ref(),
+            &IntervalDayTimeArray::from(vec![
+                IntervalDayTimeType::make_value(36, -2),
+                IntervalDayTimeType::make_value(35, -19)
+            ])
+        );
+        let a = IntervalMonthDayNanoArray::from(vec![
+            IntervalMonthDayNanoType::make_value(32, 4, 4000000000000),
+            IntervalMonthDayNanoType::make_value(32, 4, 45463000000000000),
+        ]);
+        let b = IntervalMonthDayNanoArray::from(vec![
+            IntervalMonthDayNanoType::make_value(-4, 6, 46000000000000),
+            IntervalMonthDayNanoType::make_value(-3, 23, 3564000000000000),
+        ]);
+        let result = add(&a, &b).unwrap();
+        assert_eq!(
+            result.as_ref(),
+            &IntervalMonthDayNanoArray::from(vec![
+                IntervalMonthDayNanoType::make_value(28, 10, 50000000000000),
+                IntervalMonthDayNanoType::make_value(29, 27, 49027000000000000)
+            ])
+        );
+        let result = sub(&a, &b).unwrap();
+        assert_eq!(
+            result.as_ref(),
+            &IntervalMonthDayNanoArray::from(vec![
+                IntervalMonthDayNanoType::make_value(36, -2, -42000000000000),
+                IntervalMonthDayNanoType::make_value(35, -19, 41899000000000000)
+            ])
+        );
+        let a = IntervalMonthDayNanoArray::from(vec![i64::MAX as i128]);
+        let b = IntervalMonthDayNanoArray::from(vec![1]);
+        let err = add(&a, &b).unwrap_err().to_string();
+        assert_eq!(
+            err,
+            "Compute error: Overflow happened on: 9223372036854775807 + 1"
+        );
+    }
+
+    fn test_duration_impl<T: ArrowPrimitiveType<Native = i64>>() {
+        let a = PrimitiveArray::<T>::new(vec![1000, 4394, -3944].into(), None);
+        let b = PrimitiveArray::<T>::new(vec![4, -5, -243].into(), None);
+
+        let result = add(&a, &b).unwrap();
+        assert_eq!(result.as_primitive::<T>().values(), &[1004, 4389, -4187]);
+        let result = sub(&a, &b).unwrap();
+        assert_eq!(result.as_primitive::<T>().values(), &[996, 4399, -3701]);
+
+        let err = mul(&a, &b).unwrap_err().to_string();
+        assert!(
+            err.contains("Invalid duration arithmetic operation"),
+            "{err}"
+        );
+
+        let err = div(&a, &b).unwrap_err().to_string();
+        assert!(
+            err.contains("Invalid duration arithmetic operation"),
+            "{err}"
+        );
+
+        let err = rem(&a, &b).unwrap_err().to_string();
+        assert!(
+            err.contains("Invalid duration arithmetic operation"),
+            "{err}"
+        );
+
+        let a = PrimitiveArray::<T>::new(vec![i64::MAX].into(), None);
+        let b = PrimitiveArray::<T>::new(vec![1].into(), None);
+        let err = add(&a, &b).unwrap_err().to_string();
+        assert_eq!(
+            err,
+            "Compute error: Overflow happened on: 9223372036854775807 + 1"
+        );
+    }
+
+    #[test]
+    fn test_duration() {
+        test_duration_impl::<DurationSecondType>();
+        test_duration_impl::<DurationMillisecondType>();
+        test_duration_impl::<DurationMicrosecondType>();
+        test_duration_impl::<DurationNanosecondType>();
+    }
+
+    fn test_date_impl<T: ArrowPrimitiveType, F>(f: F)
+    where
+        F: Fn(NaiveDate) -> T::Native,
+        T::Native: TryInto<i64>,
+    {
+        let a = PrimitiveArray::<T>::new(
+            vec![
+                f(NaiveDate::from_ymd_opt(1979, 1, 30).unwrap()),
+                f(NaiveDate::from_ymd_opt(2010, 4, 3).unwrap()),
+                f(NaiveDate::from_ymd_opt(2008, 2, 29).unwrap()),
+            ]
+            .into(),
+            None,
+        );
+
+        let b = IntervalYearMonthArray::from(vec![
+            IntervalYearMonthType::make_value(34, 2),
+            IntervalYearMonthType::make_value(3, -3),
+            IntervalYearMonthType::make_value(-12, 4),
+        ]);
+
+        let format_array = |x: &dyn Array| -> Vec<String> {
+            x.as_primitive::<T>()
+                .values()
+                .into_iter()
+                .map(|x| {
+                    as_date::<T>((*x).try_into().ok().unwrap())
+                        .unwrap()
+                        .to_string()
+                })
+                .collect()
+        };
+
+        let result = add(&a, &b).unwrap();
+        assert_eq!(
+            &format_array(result.as_ref()),
+            &[
+                "2013-03-30".to_string(),
+                "2013-01-03".to_string(),
+                "1996-06-29".to_string(),
+            ]
+        );
+        let result = sub(&result, &b).unwrap();
+        assert_eq!(result.as_ref(), &a);
+
+        let b = IntervalDayTimeArray::from(vec![
+            IntervalDayTimeType::make_value(34, 2),
+            IntervalDayTimeType::make_value(3, -3),
+            IntervalDayTimeType::make_value(-12, 4),
+        ]);
+
+        let result = add(&a, &b).unwrap();
+        assert_eq!(
+            &format_array(result.as_ref()),
+            &[
+                "1979-03-05".to_string(),
+                "2010-04-06".to_string(),
+                "2008-02-17".to_string(),
+            ]
+        );
+        let result = sub(&result, &b).unwrap();
+        assert_eq!(result.as_ref(), &a);
+
+        let b = IntervalMonthDayNanoArray::from(vec![
+            IntervalMonthDayNanoType::make_value(34, 2, -34353534),
+            IntervalMonthDayNanoType::make_value(3, -3, 2443),
+            IntervalMonthDayNanoType::make_value(-12, 4, 2323242423232),
+        ]);
+
+        let result = add(&a, &b).unwrap();
+        assert_eq!(
+            &format_array(result.as_ref()),
+            &[
+                "1981-12-02".to_string(),
+                "2010-06-30".to_string(),
+                "2007-03-04".to_string(),
+            ]
+        );
+        let result = sub(&result, &b).unwrap();
+        assert_eq!(
+            &format_array(result.as_ref()),
+            &[
+                "1979-01-31".to_string(),
+                "2010-04-02".to_string(),
+                "2008-02-29".to_string(),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_date() {
+        test_date_impl::<Date32Type, _>(Date32Type::from_naive_date);
+        test_date_impl::<Date64Type, _>(Date64Type::from_naive_date);
+
+        let a = Date32Array::from(vec![i32::MIN, i32::MAX, 23, 7684]);
+        let b = Date32Array::from(vec![i32::MIN, i32::MIN, -2, 45]);
+        let result = sub(&a, &b).unwrap();
+        assert_eq!(
+            result.as_primitive::<DurationSecondType>().values(),
+            &[0, 371085174288000, 2160000, 660009600]
+        );
+
+        let a = Date64Array::from(vec![4343, 76676, 3434]);
+        let b = Date64Array::from(vec![3, -5, 5]);
+        let result = sub(&a, &b).unwrap();
+        assert_eq!(
+            result.as_primitive::<DurationMillisecondType>().values(),
+            &[4340, 76681, 3429]
+        );
+
+        let a = Date64Array::from(vec![i64::MAX]);
+        let b = Date64Array::from(vec![-1]);
+        let err = sub(&a, &b).unwrap_err().to_string();
+        assert_eq!(
+            err,
+            "Compute error: Overflow happened on: 9223372036854775807 - -1"
+        );
+    }
+}
diff --git a/arrow-arith/src/temporal.rs b/arrow-arith/src/temporal.rs
new file mode 100644
index 000000000000..d52af32f42c4
--- /dev/null
+++ b/arrow-arith/src/temporal.rs
@@ -0,0 +1,1503 @@
+// 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.
+
+//! Defines temporal kernels for time and date related functions.
+
+use std::sync::Arc;
+
+use arrow_array::cast::AsArray;
+use chrono::{Datelike, NaiveDateTime, Offset, TimeZone, Timelike, Utc};
+
+use arrow_array::temporal_conversions::{
+    date32_to_datetime, date64_to_datetime, timestamp_ms_to_datetime, timestamp_ns_to_datetime,
+    timestamp_s_to_datetime, timestamp_us_to_datetime, MICROSECONDS, MICROSECONDS_IN_DAY,
+    MILLISECONDS, MILLISECONDS_IN_DAY, NANOSECONDS, NANOSECONDS_IN_DAY, SECONDS_IN_DAY,
+};
+use arrow_array::timezone::Tz;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::ArrowNativeType;
+use arrow_schema::{ArrowError, DataType};
+
+/// Valid parts to extract from date/time/timestamp arrays.
+///
+/// See [`date_part`].
+///
+/// Marked as non-exhaustive as may expand to support more types of
+/// date parts in the future.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum DatePart {
+    /// Quarter of the year, in range `1..=4`
+    Quarter,
+    /// Calendar year
+    Year,
+    /// Month in the year, in range `1..=12`
+    Month,
+    /// ISO week of the year, in range `1..=53`
+    Week,
+    /// Day of the month, in range `1..=31`
+    Day,
+    /// Day of the week, in range `0..=6`, where Sunday is `0`
+    DayOfWeekSunday0,
+    /// Day of the week, in range `0..=6`, where Monday is `0`
+    DayOfWeekMonday0,
+    /// Day of year, in range `1..=366`
+    DayOfYear,
+    /// Hour of the day, in range `0..=23`
+    Hour,
+    /// Minute of the hour, in range `0..=59`
+    Minute,
+    /// Second of the minute, in range `0..=59`
+    Second,
+    /// Millisecond of the second
+    Millisecond,
+    /// Microsecond of the second
+    Microsecond,
+    /// Nanosecond of the second
+    Nanosecond,
+}
+
+impl std::fmt::Display for DatePart {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{:?}", self)
+    }
+}
+
+/// Returns function to extract relevant [`DatePart`] from types like a
+/// [`NaiveDateTime`] or [`DateTime`].
+///
+/// [`DateTime`]: chrono::DateTime
+fn get_date_time_part_extract_fn<T>(part: DatePart) -> fn(T) -> i32
+where
+    T: ChronoDateExt + Datelike + Timelike,
+{
+    match part {
+        DatePart::Quarter => |d| d.quarter() as i32,
+        DatePart::Year => |d| d.year(),
+        DatePart::Month => |d| d.month() as i32,
+        DatePart::Week => |d| d.iso_week().week() as i32,
+        DatePart::Day => |d| d.day() as i32,
+        DatePart::DayOfWeekSunday0 => |d| d.num_days_from_sunday(),
+        DatePart::DayOfWeekMonday0 => |d| d.num_days_from_monday(),
+        DatePart::DayOfYear => |d| d.ordinal() as i32,
+        DatePart::Hour => |d| d.hour() as i32,
+        DatePart::Minute => |d| d.minute() as i32,
+        DatePart::Second => |d| d.second() as i32,
+        DatePart::Millisecond => |d| (d.nanosecond() / 1_000_000) as i32,
+        DatePart::Microsecond => |d| (d.nanosecond() / 1_000) as i32,
+        DatePart::Nanosecond => |d| (d.nanosecond()) as i32,
+    }
+}
+
+/// Given an array, return a new array with the extracted [`DatePart`] as signed 32-bit
+/// integer values.
+///
+/// Currently only supports temporal types:
+///   - Date32/Date64
+///   - Time32/Time64
+///   - Timestamp
+///
+/// Returns an [`Int32Array`] unless input was a dictionary type, in which case returns
+/// the dictionary but with this function applied onto its values.
+///
+/// If array passed in is not of the above listed types (or is a dictionary array where the
+/// values array isn't of the above listed types), then this function will return an error.
+///
+/// # Examples
+///
+/// ```
+/// # use arrow_array::{Int32Array, TimestampMicrosecondArray};
+/// # use arrow_arith::temporal::{DatePart, date_part};
+/// let input: TimestampMicrosecondArray =
+///     vec![Some(1612025847000000), None, Some(1722015847000000)].into();
+///
+/// let actual = date_part(&input, DatePart::Week).unwrap();
+/// let expected: Int32Array = vec![Some(4), None, Some(30)].into();
+/// assert_eq!(actual.as_ref(), &expected);
+/// ```
+pub fn date_part(array: &dyn Array, part: DatePart) -> Result<ArrayRef, ArrowError> {
+    downcast_temporal_array!(
+        array => {
+            let array = array.date_part(part)?;
+            let array = Arc::new(array) as ArrayRef;
+            Ok(array)
+        }
+        // TODO: support interval
+        // DataType::Interval(_) => {
+        //     todo!();
+        // }
+        DataType::Dictionary(_, _) => {
+            let array = array.as_any_dictionary();
+            let values = date_part(array.values(), part)?;
+            let values = Arc::new(values) as ArrayRef;
+            let new_array = array.with_values(values);
+            Ok(new_array)
+        }
+        t => return_compute_error_with!(format!("{part} does not support"), t),
+    )
+}
+
+/// Used to integrate new [`date_part()`] method with deprecated shims such as
+/// [`hour()`] and [`week()`].
+fn date_part_primitive<T: ArrowTemporalType>(
+    array: &PrimitiveArray<T>,
+    part: DatePart,
+) -> Result<Int32Array, ArrowError> {
+    let array = date_part(array, part)?;
+    Ok(array.as_primitive::<Int32Type>().to_owned())
+}
+
+/// Extract optional [`Tz`] from timestamp data types, returning error
+/// if called with a non-timestamp type.
+fn get_tz(dt: &DataType) -> Result<Option<Tz>, ArrowError> {
+    match dt {
+        DataType::Timestamp(_, Some(tz)) => Ok(Some(tz.parse::<Tz>()?)),
+        DataType::Timestamp(_, None) => Ok(None),
+        _ => Err(ArrowError::CastError(format!("Not a timestamp type: {dt}"))),
+    }
+}
+
+/// Implement the specialized functions for extracting date part from temporal arrays.
+trait ExtractDatePartExt {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError>;
+}
+
+impl ExtractDatePartExt for PrimitiveArray<Time32SecondType> {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
+        #[inline]
+        fn range_check(s: i32) -> bool {
+            (0..SECONDS_IN_DAY as i32).contains(&s)
+        }
+        match part {
+            DatePart::Hour => Ok(self.unary_opt(|s| range_check(s).then_some(s / 3_600))),
+            DatePart::Minute => Ok(self.unary_opt(|s| range_check(s).then_some((s / 60) % 60))),
+            DatePart::Second => Ok(self.unary_opt(|s| range_check(s).then_some(s % 60))),
+            // Time32Second only encodes number of seconds, so these will always be 0 (if in valid range)
+            DatePart::Millisecond | DatePart::Microsecond | DatePart::Nanosecond => {
+                Ok(self.unary_opt(|s| range_check(s).then_some(0)))
+            }
+            _ => return_compute_error_with!(format!("{part} does not support"), self.data_type()),
+        }
+    }
+}
+
+impl ExtractDatePartExt for PrimitiveArray<Time32MillisecondType> {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
+        #[inline]
+        fn range_check(ms: i32) -> bool {
+            (0..MILLISECONDS_IN_DAY as i32).contains(&ms)
+        }
+        let milliseconds = MILLISECONDS as i32;
+        match part {
+            DatePart::Hour => {
+                Ok(self.unary_opt(|ms| range_check(ms).then_some(ms / 3_600 / milliseconds)))
+            }
+            DatePart::Minute => {
+                Ok(self.unary_opt(|ms| range_check(ms).then_some((ms / 60 / milliseconds) % 60)))
+            }
+            DatePart::Second => {
+                Ok(self.unary_opt(|ms| range_check(ms).then_some((ms / milliseconds) % 60)))
+            }
+            DatePart::Millisecond => {
+                Ok(self.unary_opt(|ms| range_check(ms).then_some(ms % milliseconds)))
+            }
+            DatePart::Microsecond => {
+                Ok(self.unary_opt(|ms| range_check(ms).then_some((ms % milliseconds) * 1_000)))
+            }
+            DatePart::Nanosecond => {
+                Ok(self.unary_opt(|ms| range_check(ms).then_some((ms % milliseconds) * 1_000_000)))
+            }
+            _ => return_compute_error_with!(format!("{part} does not support"), self.data_type()),
+        }
+    }
+}
+
+impl ExtractDatePartExt for PrimitiveArray<Time64MicrosecondType> {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
+        #[inline]
+        fn range_check(us: i64) -> bool {
+            (0..MICROSECONDS_IN_DAY).contains(&us)
+        }
+        match part {
+            DatePart::Hour => {
+                Ok(self
+                    .unary_opt(|us| range_check(us).then_some((us / 3_600 / MICROSECONDS) as i32)))
+            }
+            DatePart::Minute => Ok(self
+                .unary_opt(|us| range_check(us).then_some(((us / 60 / MICROSECONDS) % 60) as i32))),
+            DatePart::Second => {
+                Ok(self
+                    .unary_opt(|us| range_check(us).then_some(((us / MICROSECONDS) % 60) as i32)))
+            }
+            DatePart::Millisecond => Ok(self
+                .unary_opt(|us| range_check(us).then_some(((us % MICROSECONDS) / 1_000) as i32))),
+            DatePart::Microsecond => {
+                Ok(self.unary_opt(|us| range_check(us).then_some((us % MICROSECONDS) as i32)))
+            }
+            DatePart::Nanosecond => Ok(self
+                .unary_opt(|us| range_check(us).then_some(((us % MICROSECONDS) * 1_000) as i32))),
+            _ => return_compute_error_with!(format!("{part} does not support"), self.data_type()),
+        }
+    }
+}
+
+impl ExtractDatePartExt for PrimitiveArray<Time64NanosecondType> {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
+        #[inline]
+        fn range_check(ns: i64) -> bool {
+            (0..NANOSECONDS_IN_DAY).contains(&ns)
+        }
+        match part {
+            DatePart::Hour => {
+                Ok(self
+                    .unary_opt(|ns| range_check(ns).then_some((ns / 3_600 / NANOSECONDS) as i32)))
+            }
+            DatePart::Minute => Ok(self
+                .unary_opt(|ns| range_check(ns).then_some(((ns / 60 / NANOSECONDS) % 60) as i32))),
+            DatePart::Second => Ok(
+                self.unary_opt(|ns| range_check(ns).then_some(((ns / NANOSECONDS) % 60) as i32))
+            ),
+            DatePart::Millisecond => Ok(self.unary_opt(|ns| {
+                range_check(ns).then_some(((ns % NANOSECONDS) / 1_000_000) as i32)
+            })),
+            DatePart::Microsecond => {
+                Ok(self
+                    .unary_opt(|ns| range_check(ns).then_some(((ns % NANOSECONDS) / 1_000) as i32)))
+            }
+            DatePart::Nanosecond => {
+                Ok(self.unary_opt(|ns| range_check(ns).then_some((ns % NANOSECONDS) as i32)))
+            }
+            _ => return_compute_error_with!(format!("{part} does not support"), self.data_type()),
+        }
+    }
+}
+
+impl ExtractDatePartExt for PrimitiveArray<Date32Type> {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
+        // Date32 only encodes number of days, so these will always be 0
+        if let DatePart::Hour
+        | DatePart::Minute
+        | DatePart::Second
+        | DatePart::Millisecond
+        | DatePart::Microsecond
+        | DatePart::Nanosecond = part
+        {
+            Ok(Int32Array::new(
+                vec![0; self.len()].into(),
+                self.nulls().cloned(),
+            ))
+        } else {
+            let map_func = get_date_time_part_extract_fn(part);
+            Ok(self.unary_opt(|d| date32_to_datetime(d).map(map_func)))
+        }
+    }
+}
+
+impl ExtractDatePartExt for PrimitiveArray<Date64Type> {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
+        let map_func = get_date_time_part_extract_fn(part);
+        Ok(self.unary_opt(|d| date64_to_datetime(d).map(map_func)))
+    }
+}
+
+impl ExtractDatePartExt for PrimitiveArray<TimestampSecondType> {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
+        // TimestampSecond only encodes number of seconds, so these will always be 0
+        let array =
+            if let DatePart::Millisecond | DatePart::Microsecond | DatePart::Nanosecond = part {
+                Int32Array::new(vec![0; self.len()].into(), self.nulls().cloned())
+            } else if let Some(tz) = get_tz(self.data_type())? {
+                let map_func = get_date_time_part_extract_fn(part);
+                self.unary_opt(|d| {
+                    timestamp_s_to_datetime(d)
+                        .map(|c| Utc.from_utc_datetime(&c).with_timezone(&tz))
+                        .map(map_func)
+                })
+            } else {
+                let map_func = get_date_time_part_extract_fn(part);
+                self.unary_opt(|d| timestamp_s_to_datetime(d).map(map_func))
+            };
+        Ok(array)
+    }
+}
+
+impl ExtractDatePartExt for PrimitiveArray<TimestampMillisecondType> {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
+        let array = if let Some(tz) = get_tz(self.data_type())? {
+            let map_func = get_date_time_part_extract_fn(part);
+            self.unary_opt(|d| {
+                timestamp_ms_to_datetime(d)
+                    .map(|c| Utc.from_utc_datetime(&c).with_timezone(&tz))
+                    .map(map_func)
+            })
+        } else {
+            let map_func = get_date_time_part_extract_fn(part);
+            self.unary_opt(|d| timestamp_ms_to_datetime(d).map(map_func))
+        };
+        Ok(array)
+    }
+}
+
+impl ExtractDatePartExt for PrimitiveArray<TimestampMicrosecondType> {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
+        let array = if let Some(tz) = get_tz(self.data_type())? {
+            let map_func = get_date_time_part_extract_fn(part);
+            self.unary_opt(|d| {
+                timestamp_us_to_datetime(d)
+                    .map(|c| Utc.from_utc_datetime(&c).with_timezone(&tz))
+                    .map(map_func)
+            })
+        } else {
+            let map_func = get_date_time_part_extract_fn(part);
+            self.unary_opt(|d| timestamp_us_to_datetime(d).map(map_func))
+        };
+        Ok(array)
+    }
+}
+
+impl ExtractDatePartExt for PrimitiveArray<TimestampNanosecondType> {
+    fn date_part(&self, part: DatePart) -> Result<Int32Array, ArrowError> {
+        let array = if let Some(tz) = get_tz(self.data_type())? {
+            let map_func = get_date_time_part_extract_fn(part);
+            self.unary_opt(|d| {
+                timestamp_ns_to_datetime(d)
+                    .map(|c| Utc.from_utc_datetime(&c).with_timezone(&tz))
+                    .map(map_func)
+            })
+        } else {
+            let map_func = get_date_time_part_extract_fn(part);
+            self.unary_opt(|d| timestamp_ns_to_datetime(d).map(map_func))
+        };
+        Ok(array)
+    }
+}
+
+macro_rules! return_compute_error_with {
+    ($msg:expr, $param:expr) => {
+        return { Err(ArrowError::ComputeError(format!("{}: {:?}", $msg, $param))) }
+    };
+}
+
+pub(crate) use return_compute_error_with;
+
+// Internal trait, which is used for mapping values from DateLike structures
+trait ChronoDateExt {
+    /// Returns a value in range `1..=4` indicating the quarter this date falls into
+    fn quarter(&self) -> u32;
+
+    /// Returns a value in range `0..=3` indicating the quarter (zero-based) this date falls into
+    fn quarter0(&self) -> u32;
+
+    /// Returns the day of week; Monday is encoded as `0`, Tuesday as `1`, etc.
+    fn num_days_from_monday(&self) -> i32;
+
+    /// Returns the day of week; Sunday is encoded as `0`, Monday as `1`, etc.
+    fn num_days_from_sunday(&self) -> i32;
+}
+
+impl<T: Datelike> ChronoDateExt for T {
+    fn quarter(&self) -> u32 {
+        self.quarter0() + 1
+    }
+
+    fn quarter0(&self) -> u32 {
+        self.month0() / 3
+    }
+
+    fn num_days_from_monday(&self) -> i32 {
+        self.weekday().num_days_from_monday() as i32
+    }
+
+    fn num_days_from_sunday(&self) -> i32 {
+        self.weekday().num_days_from_sunday() as i32
+    }
+}
+
+/// Parse the given string into a string representing fixed-offset that is correct as of the given
+/// UTC NaiveDateTime.
+/// Note that the offset is function of time and can vary depending on whether daylight savings is
+/// in effect or not. e.g. Australia/Sydney is +10:00 or +11:00 depending on DST.
+#[deprecated(note = "Use arrow_array::timezone::Tz instead")]
+pub fn using_chrono_tz_and_utc_naive_date_time(
+    tz: &str,
+    utc: NaiveDateTime,
+) -> Option<chrono::offset::FixedOffset> {
+    let tz: Tz = tz.parse().ok()?;
+    Some(tz.offset_from_utc_datetime(&utc).fix())
+}
+
+/// Extracts the hours of a given array as an array of integers within
+/// the range of [0, 23]. If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn hour_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Hour)
+}
+
+/// Extracts the hours of a given temporal primitive array as an array of integers within
+/// the range of [0, 23].
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn hour<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Hour)
+}
+
+/// Extracts the years of a given temporal array as an array of integers.
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn year_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Year)
+}
+
+/// Extracts the years of a given temporal primitive array as an array of integers
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn year<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Year)
+}
+
+/// Extracts the quarter of a given temporal array as an array of integersa within
+/// the range of [1, 4]. If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn quarter_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Quarter)
+}
+
+/// Extracts the quarter of a given temporal primitive array as an array of integers within
+/// the range of [1, 4].
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn quarter<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Quarter)
+}
+
+/// Extracts the month of a given temporal array as an array of integers.
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn month_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Month)
+}
+
+/// Extracts the month of a given temporal primitive array as an array of integers within
+/// the range of [1, 12].
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn month<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Month)
+}
+
+/// Extracts the day of week of a given temporal array as an array of
+/// integers.
+///
+/// Monday is encoded as `0`, Tuesday as `1`, etc.
+///
+/// See also [`num_days_from_sunday`] which starts at Sunday.
+///
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn num_days_from_monday_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::DayOfWeekMonday0)
+}
+
+/// Extracts the day of week of a given temporal primitive array as an array of
+/// integers.
+///
+/// Monday is encoded as `0`, Tuesday as `1`, etc.
+///
+/// See also [`num_days_from_sunday`] which starts at Sunday.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn num_days_from_monday<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::DayOfWeekMonday0)
+}
+
+/// Extracts the day of week of a given temporal array as an array of
+/// integers, starting at Sunday.
+///
+/// Sunday is encoded as `0`, Monday as `1`, etc.
+///
+/// See also [`num_days_from_monday`] which starts at Monday.
+///
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn num_days_from_sunday_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::DayOfWeekSunday0)
+}
+
+/// Extracts the day of week of a given temporal primitive array as an array of
+/// integers, starting at Sunday.
+///
+/// Sunday is encoded as `0`, Monday as `1`, etc.
+///
+/// See also [`num_days_from_monday`] which starts at Monday.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn num_days_from_sunday<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::DayOfWeekSunday0)
+}
+
+/// Extracts the day of a given temporal array as an array of integers.
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn day_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Day)
+}
+
+/// Extracts the day of a given temporal primitive array as an array of integers
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn day<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Day)
+}
+
+/// Extracts the day of year of a given temporal array as an array of integers
+/// The day of year that ranges from 1 to 366.
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn doy_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::DayOfYear)
+}
+
+/// Extracts the day of year of a given temporal primitive array as an array of integers
+/// The day of year that ranges from 1 to 366
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn doy<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    T::Native: ArrowNativeType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::DayOfYear)
+}
+
+/// Extracts the minutes of a given temporal primitive array as an array of integers
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn minute<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Minute)
+}
+
+/// Extracts the week of a given temporal array as an array of integers.
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn week_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Week)
+}
+
+/// Extracts the week of a given temporal primitive array as an array of integers
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn week<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Week)
+}
+
+/// Extracts the seconds of a given temporal primitive array as an array of integers
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn second<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Second)
+}
+
+/// Extracts the nanoseconds of a given temporal primitive array as an array of integers
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn nanosecond<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Nanosecond)
+}
+
+/// Extracts the nanoseconds of a given temporal primitive array as an array of integers.
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn nanosecond_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Nanosecond)
+}
+
+/// Extracts the microseconds of a given temporal primitive array as an array of integers
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn microsecond<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Microsecond)
+}
+
+/// Extracts the microseconds of a given temporal primitive array as an array of integers.
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn microsecond_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Microsecond)
+}
+
+/// Extracts the milliseconds of a given temporal primitive array as an array of integers
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn millisecond<T>(array: &PrimitiveArray<T>) -> Result<Int32Array, ArrowError>
+where
+    T: ArrowTemporalType + ArrowNumericType,
+    i64: From<T::Native>,
+{
+    date_part_primitive(array, DatePart::Millisecond)
+}
+
+/// Extracts the milliseconds of a given temporal primitive array as an array of integers.
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn millisecond_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Millisecond)
+}
+
+/// Extracts the minutes of a given temporal array as an array of integers.
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn minute_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Minute)
+}
+
+/// Extracts the seconds of a given temporal array as an array of integers.
+/// If the given array isn't temporal primitive or dictionary array,
+/// an `Err` will be returned.
+#[deprecated(since = "51.0.0", note = "Use `date_part` instead")]
+pub fn second_dyn(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    date_part(array, DatePart::Second)
+}
+
+#[cfg(test)]
+#[allow(deprecated)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_temporal_array_date64_hour() {
+        let a: PrimitiveArray<Date64Type> =
+            vec![Some(1514764800000), None, Some(1550636625000)].into();
+
+        let b = hour(&a).unwrap();
+        assert_eq!(0, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(4, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date32_hour() {
+        let a: PrimitiveArray<Date32Type> = vec![Some(15147), None, Some(15148)].into();
+
+        let b = hour(&a).unwrap();
+        assert_eq!(0, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(0, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_time32_second_hour() {
+        let a: PrimitiveArray<Time32SecondType> = vec![37800, 86339].into();
+
+        let b = hour(&a).unwrap();
+        assert_eq!(10, b.value(0));
+        assert_eq!(23, b.value(1));
+    }
+
+    #[test]
+    fn test_temporal_array_time64_micro_hour() {
+        let a: PrimitiveArray<Time64MicrosecondType> = vec![37800000000, 86339000000].into();
+
+        let b = hour(&a).unwrap();
+        assert_eq!(10, b.value(0));
+        assert_eq!(23, b.value(1));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_micro_hour() {
+        let a: TimestampMicrosecondArray = vec![37800000000, 86339000000].into();
+
+        let b = hour(&a).unwrap();
+        assert_eq!(10, b.value(0));
+        assert_eq!(23, b.value(1));
+    }
+
+    #[test]
+    fn test_temporal_array_date64_year() {
+        let a: PrimitiveArray<Date64Type> =
+            vec![Some(1514764800000), None, Some(1550636625000)].into();
+
+        let b = year(&a).unwrap();
+        assert_eq!(2018, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(2019, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date32_year() {
+        let a: PrimitiveArray<Date32Type> = vec![Some(15147), None, Some(15448)].into();
+
+        let b = year(&a).unwrap();
+        assert_eq!(2011, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(2012, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date64_quarter() {
+        //1514764800000 -> 2018-01-01
+        //1566275025000 -> 2019-08-20
+        let a: PrimitiveArray<Date64Type> =
+            vec![Some(1514764800000), None, Some(1566275025000)].into();
+
+        let b = quarter(&a).unwrap();
+        assert_eq!(1, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(3, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date32_quarter() {
+        let a: PrimitiveArray<Date32Type> = vec![Some(1), None, Some(300)].into();
+
+        let b = quarter(&a).unwrap();
+        assert_eq!(1, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(4, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_quarter_with_timezone() {
+        // 24 * 60 * 60 = 86400
+        let a = TimestampSecondArray::from(vec![86400 * 90]).with_timezone("+00:00".to_string());
+        let b = quarter(&a).unwrap();
+        assert_eq!(2, b.value(0));
+        let a = TimestampSecondArray::from(vec![86400 * 90]).with_timezone("-10:00".to_string());
+        let b = quarter(&a).unwrap();
+        assert_eq!(1, b.value(0));
+    }
+
+    #[test]
+    fn test_temporal_array_date64_month() {
+        //1514764800000 -> 2018-01-01
+        //1550636625000 -> 2019-02-20
+        let a: PrimitiveArray<Date64Type> =
+            vec![Some(1514764800000), None, Some(1550636625000)].into();
+
+        let b = month(&a).unwrap();
+        assert_eq!(1, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(2, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date32_month() {
+        let a: PrimitiveArray<Date32Type> = vec![Some(1), None, Some(31)].into();
+
+        let b = month(&a).unwrap();
+        assert_eq!(1, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(2, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_month_with_timezone() {
+        // 24 * 60 * 60 = 86400
+        let a = TimestampSecondArray::from(vec![86400 * 31]).with_timezone("+00:00".to_string());
+        let b = month(&a).unwrap();
+        assert_eq!(2, b.value(0));
+        let a = TimestampSecondArray::from(vec![86400 * 31]).with_timezone("-10:00".to_string());
+        let b = month(&a).unwrap();
+        assert_eq!(1, b.value(0));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_day_with_timezone() {
+        // 24 * 60 * 60 = 86400
+        let a = TimestampSecondArray::from(vec![86400]).with_timezone("+00:00".to_string());
+        let b = day(&a).unwrap();
+        assert_eq!(2, b.value(0));
+        let a = TimestampSecondArray::from(vec![86400]).with_timezone("-10:00".to_string());
+        let b = day(&a).unwrap();
+        assert_eq!(1, b.value(0));
+    }
+
+    #[test]
+    fn test_temporal_array_date64_weekday() {
+        //1514764800000 -> 2018-01-01 (Monday)
+        //1550636625000 -> 2019-02-20 (Wednesday)
+        let a: PrimitiveArray<Date64Type> =
+            vec![Some(1514764800000), None, Some(1550636625000)].into();
+
+        let b = num_days_from_monday(&a).unwrap();
+        assert_eq!(0, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(2, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date64_weekday0() {
+        //1483228800000 -> 2017-01-01 (Sunday)
+        //1514764800000 -> 2018-01-01 (Monday)
+        //1550636625000 -> 2019-02-20 (Wednesday)
+        let a: PrimitiveArray<Date64Type> = vec![
+            Some(1483228800000),
+            None,
+            Some(1514764800000),
+            Some(1550636625000),
+        ]
+        .into();
+
+        let b = num_days_from_sunday(&a).unwrap();
+        assert_eq!(0, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(1, b.value(2));
+        assert_eq!(3, b.value(3));
+    }
+
+    #[test]
+    fn test_temporal_array_date64_day() {
+        //1514764800000 -> 2018-01-01
+        //1550636625000 -> 2019-02-20
+        let a: PrimitiveArray<Date64Type> =
+            vec![Some(1514764800000), None, Some(1550636625000)].into();
+
+        let b = day(&a).unwrap();
+        assert_eq!(1, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(20, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date32_day() {
+        let a: PrimitiveArray<Date32Type> = vec![Some(0), None, Some(31)].into();
+
+        let b = day(&a).unwrap();
+        assert_eq!(1, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(1, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date64_doy() {
+        //1483228800000 -> 2017-01-01 (Sunday)
+        //1514764800000 -> 2018-01-01
+        //1550636625000 -> 2019-02-20
+        let a: PrimitiveArray<Date64Type> = vec![
+            Some(1483228800000),
+            Some(1514764800000),
+            None,
+            Some(1550636625000),
+        ]
+        .into();
+
+        let b = doy(&a).unwrap();
+        assert_eq!(1, b.value(0));
+        assert_eq!(1, b.value(1));
+        assert!(!b.is_valid(2));
+        assert_eq!(51, b.value(3));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_micro_year() {
+        let a: TimestampMicrosecondArray =
+            vec![Some(1612025847000000), None, Some(1722015847000000)].into();
+
+        let b = year(&a).unwrap();
+        assert_eq!(2021, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(2024, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date64_minute() {
+        let a: PrimitiveArray<Date64Type> =
+            vec![Some(1514764800000), None, Some(1550636625000)].into();
+
+        let b = minute(&a).unwrap();
+        assert_eq!(0, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(23, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_micro_minute() {
+        let a: TimestampMicrosecondArray =
+            vec![Some(1612025847000000), None, Some(1722015847000000)].into();
+
+        let b = minute(&a).unwrap();
+        assert_eq!(57, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(44, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date32_week() {
+        let a: PrimitiveArray<Date32Type> = vec![Some(0), None, Some(7)].into();
+
+        let b = week(&a).unwrap();
+        assert_eq!(1, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(2, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date64_week() {
+        // 1646116175000 -> 2022.03.01 , 1641171600000 -> 2022.01.03
+        // 1640998800000 -> 2022.01.01
+        let a: PrimitiveArray<Date64Type> = vec![
+            Some(1646116175000),
+            None,
+            Some(1641171600000),
+            Some(1640998800000),
+        ]
+        .into();
+
+        let b = week(&a).unwrap();
+        assert_eq!(9, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(1, b.value(2));
+        assert_eq!(52, b.value(3));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_micro_week() {
+        //1612025847000000 -> 2021.1.30
+        //1722015847000000 -> 2024.7.27
+        let a: TimestampMicrosecondArray =
+            vec![Some(1612025847000000), None, Some(1722015847000000)].into();
+
+        let b = week(&a).unwrap();
+        assert_eq!(4, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(30, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_date64_second() {
+        let a: PrimitiveArray<Date64Type> =
+            vec![Some(1514764800000), None, Some(1550636625000)].into();
+
+        let b = second(&a).unwrap();
+        assert_eq!(0, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(45, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_micro_second() {
+        let a: TimestampMicrosecondArray =
+            vec![Some(1612025847000000), None, Some(1722015847000000)].into();
+
+        let b = second(&a).unwrap();
+        assert_eq!(27, b.value(0));
+        assert!(!b.is_valid(1));
+        assert_eq!(7, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_second_with_timezone() {
+        let a = TimestampSecondArray::from(vec![10, 20]).with_timezone("+00:00".to_string());
+        let b = second(&a).unwrap();
+        assert_eq!(10, b.value(0));
+        assert_eq!(20, b.value(1));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_minute_with_timezone() {
+        let a = TimestampSecondArray::from(vec![0, 60]).with_timezone("+00:50".to_string());
+        let b = minute(&a).unwrap();
+        assert_eq!(50, b.value(0));
+        assert_eq!(51, b.value(1));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_minute_with_negative_timezone() {
+        let a = TimestampSecondArray::from(vec![60 * 55]).with_timezone("-00:50".to_string());
+        let b = minute(&a).unwrap();
+        assert_eq!(5, b.value(0));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_hour_with_timezone() {
+        let a = TimestampSecondArray::from(vec![60 * 60 * 10]).with_timezone("+01:00".to_string());
+        let b = hour(&a).unwrap();
+        assert_eq!(11, b.value(0));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_hour_with_timezone_without_colon() {
+        let a = TimestampSecondArray::from(vec![60 * 60 * 10]).with_timezone("+0100".to_string());
+        let b = hour(&a).unwrap();
+        assert_eq!(11, b.value(0));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_hour_with_timezone_without_minutes() {
+        let a = TimestampSecondArray::from(vec![60 * 60 * 10]).with_timezone("+01".to_string());
+        let b = hour(&a).unwrap();
+        assert_eq!(11, b.value(0));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_hour_with_timezone_without_initial_sign() {
+        let a = TimestampSecondArray::from(vec![60 * 60 * 10]).with_timezone("0100".to_string());
+        let err = hour(&a).unwrap_err().to_string();
+        assert!(err.contains("Invalid timezone"), "{}", err);
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_hour_with_timezone_with_only_colon() {
+        let a = TimestampSecondArray::from(vec![60 * 60 * 10]).with_timezone("01:00".to_string());
+        let err = hour(&a).unwrap_err().to_string();
+        assert!(err.contains("Invalid timezone"), "{}", err);
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_week_without_timezone() {
+        // 1970-01-01T00:00:00                     -> 1970-01-01T00:00:00 Thursday (week 1)
+        // 1970-01-01T00:00:00 + 4 days            -> 1970-01-05T00:00:00 Monday   (week 2)
+        // 1970-01-01T00:00:00 + 4 days - 1 second -> 1970-01-04T23:59:59 Sunday   (week 1)
+        let a = TimestampSecondArray::from(vec![0, 86400 * 4, 86400 * 4 - 1]);
+        let b = week(&a).unwrap();
+        assert_eq!(1, b.value(0));
+        assert_eq!(2, b.value(1));
+        assert_eq!(1, b.value(2));
+    }
+
+    #[test]
+    fn test_temporal_array_timestamp_week_with_timezone() {
+        // 1970-01-01T01:00:00+01:00                     -> 1970-01-01T01:00:00+01:00 Thursday (week 1)
+        // 1970-01-01T01:00:00+01:00 + 4 days            -> 1970-01-05T01:00:00+01:00 Monday   (week 2)
+        // 1970-01-01T01:00:00+01:00 + 4 days - 1 second -> 1970-01-05T00:59:59+01:00 Monday   (week 2)
+        let a = TimestampSecondArray::from(vec![0, 86400 * 4, 86400 * 4 - 1])
+            .with_timezone("+01:00".to_string());
+        let b = week(&a).unwrap();
+        assert_eq!(1, b.value(0));
+        assert_eq!(2, b.value(1));
+        assert_eq!(2, b.value(2));
+    }
+
+    #[test]
+    fn test_hour_minute_second_dictionary_array() {
+        let a = TimestampSecondArray::from(vec![
+            60 * 60 * 10 + 61,
+            60 * 60 * 20 + 122,
+            60 * 60 * 30 + 183,
+        ])
+        .with_timezone("+01:00".to_string());
+
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 1]);
+        let dict = DictionaryArray::try_new(keys.clone(), Arc::new(a)).unwrap();
+
+        let b = hour_dyn(&dict).unwrap();
+
+        let expected_dict =
+            DictionaryArray::new(keys.clone(), Arc::new(Int32Array::from(vec![11, 21, 7])));
+        let expected = Arc::new(expected_dict) as ArrayRef;
+        assert_eq!(&expected, &b);
+
+        let b = date_part(&dict, DatePart::Minute).unwrap();
+
+        let b_old = minute_dyn(&dict).unwrap();
+
+        let expected_dict =
+            DictionaryArray::new(keys.clone(), Arc::new(Int32Array::from(vec![1, 2, 3])));
+        let expected = Arc::new(expected_dict) as ArrayRef;
+        assert_eq!(&expected, &b);
+        assert_eq!(&expected, &b_old);
+
+        let b = date_part(&dict, DatePart::Second).unwrap();
+
+        let b_old = second_dyn(&dict).unwrap();
+
+        let expected_dict =
+            DictionaryArray::new(keys.clone(), Arc::new(Int32Array::from(vec![1, 2, 3])));
+        let expected = Arc::new(expected_dict) as ArrayRef;
+        assert_eq!(&expected, &b);
+        assert_eq!(&expected, &b_old);
+
+        let b = date_part(&dict, DatePart::Nanosecond).unwrap();
+
+        let expected_dict =
+            DictionaryArray::new(keys, Arc::new(Int32Array::from(vec![0, 0, 0, 0, 0])));
+        let expected = Arc::new(expected_dict) as ArrayRef;
+        assert_eq!(&expected, &b);
+    }
+
+    #[test]
+    fn test_year_dictionary_array() {
+        let a: PrimitiveArray<Date64Type> = vec![Some(1514764800000), Some(1550636625000)].into();
+
+        let keys = Int8Array::from_iter_values([0_i8, 1, 1, 0]);
+        let dict = DictionaryArray::new(keys.clone(), Arc::new(a));
+
+        let b = year_dyn(&dict).unwrap();
+
+        let expected_dict = DictionaryArray::new(
+            keys,
+            Arc::new(Int32Array::from(vec![2018, 2019, 2019, 2018])),
+        );
+        let expected = Arc::new(expected_dict) as ArrayRef;
+        assert_eq!(&expected, &b);
+    }
+
+    #[test]
+    fn test_quarter_month_dictionary_array() {
+        //1514764800000 -> 2018-01-01
+        //1566275025000 -> 2019-08-20
+        let a: PrimitiveArray<Date64Type> = vec![Some(1514764800000), Some(1566275025000)].into();
+
+        let keys = Int8Array::from_iter_values([0_i8, 1, 1, 0]);
+        let dict = DictionaryArray::new(keys.clone(), Arc::new(a));
+
+        let b = quarter_dyn(&dict).unwrap();
+
+        let expected =
+            DictionaryArray::new(keys.clone(), Arc::new(Int32Array::from(vec![1, 3, 3, 1])));
+        assert_eq!(b.as_ref(), &expected);
+
+        let b = month_dyn(&dict).unwrap();
+
+        let expected = DictionaryArray::new(keys, Arc::new(Int32Array::from(vec![1, 8, 8, 1])));
+        assert_eq!(b.as_ref(), &expected);
+    }
+
+    #[test]
+    fn test_num_days_from_monday_sunday_day_doy_week_dictionary_array() {
+        //1514764800000 -> 2018-01-01 (Monday)
+        //1550636625000 -> 2019-02-20 (Wednesday)
+        let a: PrimitiveArray<Date64Type> = vec![Some(1514764800000), Some(1550636625000)].into();
+
+        let keys = Int8Array::from(vec![Some(0_i8), Some(1), Some(1), Some(0), None]);
+        let dict = DictionaryArray::new(keys.clone(), Arc::new(a));
+
+        let b = num_days_from_monday_dyn(&dict).unwrap();
+
+        let a = Int32Array::from(vec![Some(0), Some(2), Some(2), Some(0), None]);
+        let expected = DictionaryArray::new(keys.clone(), Arc::new(a));
+        assert_eq!(b.as_ref(), &expected);
+
+        let b = num_days_from_sunday_dyn(&dict).unwrap();
+
+        let a = Int32Array::from(vec![Some(1), Some(3), Some(3), Some(1), None]);
+        let expected = DictionaryArray::new(keys.clone(), Arc::new(a));
+        assert_eq!(b.as_ref(), &expected);
+
+        let b = day_dyn(&dict).unwrap();
+
+        let a = Int32Array::from(vec![Some(1), Some(20), Some(20), Some(1), None]);
+        let expected = DictionaryArray::new(keys.clone(), Arc::new(a));
+        assert_eq!(b.as_ref(), &expected);
+
+        let b = doy_dyn(&dict).unwrap();
+
+        let a = Int32Array::from(vec![Some(1), Some(51), Some(51), Some(1), None]);
+        let expected = DictionaryArray::new(keys.clone(), Arc::new(a));
+        assert_eq!(b.as_ref(), &expected);
+
+        let b = week_dyn(&dict).unwrap();
+
+        let a = Int32Array::from(vec![Some(1), Some(8), Some(8), Some(1), None]);
+        let expected = DictionaryArray::new(keys, Arc::new(a));
+        assert_eq!(b.as_ref(), &expected);
+    }
+
+    #[test]
+    fn test_temporal_array_date64_nanosecond() {
+        // new Date(1667328721453)
+        // Tue Nov 01 2022 11:52:01 GMT-0700 (Pacific Daylight Time)
+        //
+        // new Date(1667328721453).getMilliseconds()
+        // 453
+
+        let a: PrimitiveArray<Date64Type> = vec![None, Some(1667328721453)].into();
+
+        let b = nanosecond(&a).unwrap();
+        assert!(!b.is_valid(0));
+        assert_eq!(453_000_000, b.value(1));
+
+        let keys = Int8Array::from(vec![Some(0_i8), Some(1), Some(1)]);
+        let dict = DictionaryArray::new(keys.clone(), Arc::new(a));
+        let b = nanosecond_dyn(&dict).unwrap();
+
+        let a = Int32Array::from(vec![None, Some(453_000_000)]);
+        let expected_dict = DictionaryArray::new(keys, Arc::new(a));
+        let expected = Arc::new(expected_dict) as ArrayRef;
+        assert_eq!(&expected, &b);
+    }
+
+    #[test]
+    fn test_temporal_array_date64_microsecond() {
+        let a: PrimitiveArray<Date64Type> = vec![None, Some(1667328721453)].into();
+
+        let b = microsecond(&a).unwrap();
+        assert!(!b.is_valid(0));
+        assert_eq!(453_000, b.value(1));
+
+        let keys = Int8Array::from(vec![Some(0_i8), Some(1), Some(1)]);
+        let dict = DictionaryArray::new(keys.clone(), Arc::new(a));
+        let b = microsecond_dyn(&dict).unwrap();
+
+        let a = Int32Array::from(vec![None, Some(453_000)]);
+        let expected_dict = DictionaryArray::new(keys, Arc::new(a));
+        let expected = Arc::new(expected_dict) as ArrayRef;
+        assert_eq!(&expected, &b);
+    }
+
+    #[test]
+    fn test_temporal_array_date64_millisecond() {
+        let a: PrimitiveArray<Date64Type> = vec![None, Some(1667328721453)].into();
+
+        let b = millisecond(&a).unwrap();
+        assert!(!b.is_valid(0));
+        assert_eq!(453, b.value(1));
+
+        let keys = Int8Array::from(vec![Some(0_i8), Some(1), Some(1)]);
+        let dict = DictionaryArray::new(keys.clone(), Arc::new(a));
+        let b = millisecond_dyn(&dict).unwrap();
+
+        let a = Int32Array::from(vec![None, Some(453)]);
+        let expected_dict = DictionaryArray::new(keys, Arc::new(a));
+        let expected = Arc::new(expected_dict) as ArrayRef;
+        assert_eq!(&expected, &b);
+    }
+
+    #[test]
+    fn test_temporal_array_time64_nanoseconds() {
+        // 23:32:50.123456789
+        let input: Time64NanosecondArray = vec![Some(84_770_123_456_789)].into();
+
+        let actual = date_part(&input, DatePart::Hour).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(23, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Minute).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(32, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Second).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(50, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Millisecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(123, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Microsecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(123_456, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Nanosecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(123_456_789, actual.value(0));
+
+        // invalid values should turn into null
+        let input: Time64NanosecondArray = vec![
+            Some(-1),
+            Some(86_400_000_000_000),
+            Some(86_401_000_000_000),
+            None,
+        ]
+        .into();
+        let actual = date_part(&input, DatePart::Hour).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        let expected: Int32Array = vec![None, None, None, None].into();
+        assert_eq!(&expected, actual);
+    }
+
+    #[test]
+    fn test_temporal_array_time64_microseconds() {
+        // 23:32:50.123456
+        let input: Time64MicrosecondArray = vec![Some(84_770_123_456)].into();
+
+        let actual = date_part(&input, DatePart::Hour).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(23, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Minute).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(32, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Second).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(50, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Millisecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(123, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Microsecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(123_456, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Nanosecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(123_456_000, actual.value(0));
+
+        // invalid values should turn into null
+        let input: Time64MicrosecondArray =
+            vec![Some(-1), Some(86_400_000_000), Some(86_401_000_000), None].into();
+        let actual = date_part(&input, DatePart::Hour).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        let expected: Int32Array = vec![None, None, None, None].into();
+        assert_eq!(&expected, actual);
+    }
+
+    #[test]
+    fn test_temporal_array_time32_milliseconds() {
+        // 23:32:50.123
+        let input: Time32MillisecondArray = vec![Some(84_770_123)].into();
+
+        let actual = date_part(&input, DatePart::Hour).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(23, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Minute).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(32, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Second).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(50, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Millisecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(123, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Microsecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(123_000, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Nanosecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(123_000_000, actual.value(0));
+
+        // invalid values should turn into null
+        let input: Time32MillisecondArray =
+            vec![Some(-1), Some(86_400_000), Some(86_401_000), None].into();
+        let actual = date_part(&input, DatePart::Hour).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        let expected: Int32Array = vec![None, None, None, None].into();
+        assert_eq!(&expected, actual);
+    }
+
+    #[test]
+    fn test_temporal_array_time32_seconds() {
+        // 23:32:50
+        let input: Time32SecondArray = vec![84_770].into();
+
+        let actual = date_part(&input, DatePart::Hour).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(23, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Minute).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(32, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Second).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(50, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Millisecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(0, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Microsecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(0, actual.value(0));
+
+        let actual = date_part(&input, DatePart::Nanosecond).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        assert_eq!(0, actual.value(0));
+
+        // invalid values should turn into null
+        let input: Time32SecondArray = vec![Some(-1), Some(86_400), Some(86_401), None].into();
+        let actual = date_part(&input, DatePart::Hour).unwrap();
+        let actual = actual.as_primitive::<Int32Type>();
+        let expected: Int32Array = vec![None, None, None, None].into();
+        assert_eq!(&expected, actual);
+    }
+
+    #[test]
+    fn test_temporal_array_time_invalid_parts() {
+        fn ensure_returns_error(array: &dyn Array) {
+            let invalid_parts = [
+                DatePart::Quarter,
+                DatePart::Year,
+                DatePart::Month,
+                DatePart::Week,
+                DatePart::Day,
+                DatePart::DayOfWeekSunday0,
+                DatePart::DayOfWeekMonday0,
+                DatePart::DayOfYear,
+            ];
+
+            for part in invalid_parts {
+                let err = date_part(array, part).unwrap_err();
+                let expected = format!(
+                    "Compute error: {part} does not support: {}",
+                    array.data_type()
+                );
+                assert_eq!(expected, err.to_string());
+            }
+        }
+
+        ensure_returns_error(&Time32SecondArray::from(vec![0]));
+        ensure_returns_error(&Time32MillisecondArray::from(vec![0]));
+        ensure_returns_error(&Time64MicrosecondArray::from(vec![0]));
+        ensure_returns_error(&Time64NanosecondArray::from(vec![0]));
+    }
+}
diff --git a/arrow-array/Cargo.toml b/arrow-array/Cargo.toml
new file mode 100644
index 000000000000..04eec8df6379
--- /dev/null
+++ b/arrow-array/Cargo.toml
@@ -0,0 +1,61 @@
+# 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]
+name = "arrow-array"
+version = { workspace = true }
+description = "Array abstractions for Apache Arrow"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_array"
+path = "src/lib.rs"
+bench = false
+
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+ahash = { version = "0.8", default-features = false, features = ["compile-time-rng"] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+ahash = { version = "0.8", default-features = false, features = ["runtime-rng"] }
+
+[dependencies]
+arrow-buffer = { workspace = true }
+arrow-schema = { workspace = true }
+arrow-data = { workspace = true }
+chrono = { workspace = true }
+chrono-tz = { version = "0.8", optional = true }
+num = { version = "0.4.1", default-features = false, features = ["std"] }
+half = { version = "2.1", default-features = false, features = ["num-traits"] }
+hashbrown = { version = "0.14", default-features = false }
+
+[dev-dependencies]
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
+criterion = { version = "0.5", default-features = false }
+
+[build-dependencies]
+
+[[bench]]
+name = "occupancy"
+harness = false
diff --git a/arrow-array/benches/occupancy.rs b/arrow-array/benches/occupancy.rs
new file mode 100644
index 000000000000..ed4b94351c28
--- /dev/null
+++ b/arrow-array/benches/occupancy.rs
@@ -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.
+
+use arrow_array::types::Int32Type;
+use arrow_array::{DictionaryArray, Int32Array};
+use arrow_buffer::NullBuffer;
+use criterion::*;
+use rand::{thread_rng, Rng};
+use std::sync::Arc;
+
+fn gen_dict(
+    len: usize,
+    values_len: usize,
+    occupancy: f64,
+    null_percent: f64,
+) -> DictionaryArray<Int32Type> {
+    let mut rng = thread_rng();
+    let values = Int32Array::from(vec![0; values_len]);
+    let max_key = (values_len as f64 * occupancy) as i32;
+    let keys = (0..len).map(|_| rng.gen_range(0..max_key)).collect();
+    let nulls = (0..len).map(|_| !rng.gen_bool(null_percent)).collect();
+
+    let keys = Int32Array::new(keys, Some(NullBuffer::new(nulls)));
+    DictionaryArray::new(keys, Arc::new(values))
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    for values in [10, 100, 512] {
+        for occupancy in [1., 0.5, 0.1] {
+            for null_percent in [0.0, 0.1, 0.5, 0.9] {
+                let dict = gen_dict(1024, values, occupancy, null_percent);
+                c.bench_function(&format!("occupancy(values: {values}, occupancy: {occupancy}, null_percent: {null_percent})"), |b| {
+                    b.iter(|| {
+                        black_box(&dict).occupancy()
+                    });
+                });
+            }
+        }
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow-array/src/arithmetic.rs b/arrow-array/src/arithmetic.rs
new file mode 100644
index 000000000000..590536190309
--- /dev/null
+++ b/arrow-array/src/arithmetic.rs
@@ -0,0 +1,854 @@
+// 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.
+
+use arrow_buffer::{i256, ArrowNativeType};
+use arrow_schema::ArrowError;
+use half::f16;
+use num::complex::ComplexFloat;
+use std::cmp::Ordering;
+
+/// Trait for [`ArrowNativeType`] that adds checked and unchecked arithmetic operations,
+/// and totally ordered comparison operations
+///
+/// The APIs with `_wrapping` suffix do not perform overflow-checking. For integer
+/// types they will wrap around the boundary of the type. For floating point types they
+/// will overflow to INF or -INF preserving the expected sign value
+///
+/// Note `div_wrapping` and `mod_wrapping` will panic for integer types if `rhs` is zero
+/// although this may be subject to change <https://github.com/apache/arrow-rs/issues/2647>
+///
+/// The APIs with `_checked` suffix perform overflow-checking. For integer types
+/// these will return `Err` instead of wrapping. For floating point types they will
+/// overflow to INF or -INF preserving the expected sign value
+///
+/// Comparison of integer types is as per normal integer comparison rules, floating
+/// point values are compared as per IEEE 754's totalOrder predicate see [`f32::total_cmp`]
+///
+pub trait ArrowNativeTypeOp: ArrowNativeType {
+    /// The additive identity
+    const ZERO: Self;
+
+    /// The multiplicative identity
+    const ONE: Self;
+
+    /// The minimum value and identity for the `max` aggregation.
+    /// Note that the aggregation uses the total order predicate for floating point values,
+    /// which means that this value is a negative NaN.
+    const MIN_TOTAL_ORDER: Self;
+
+    /// The maximum value and identity for the `min` aggregation.
+    /// Note that the aggregation uses the total order predicate for floating point values,
+    /// which means that this value is a positive NaN.
+    const MAX_TOTAL_ORDER: Self;
+
+    /// Checked addition operation
+    fn add_checked(self, rhs: Self) -> Result<Self, ArrowError>;
+
+    /// Wrapping addition operation
+    fn add_wrapping(self, rhs: Self) -> Self;
+
+    /// Checked subtraction operation
+    fn sub_checked(self, rhs: Self) -> Result<Self, ArrowError>;
+
+    /// Wrapping subtraction operation
+    fn sub_wrapping(self, rhs: Self) -> Self;
+
+    /// Checked multiplication operation
+    fn mul_checked(self, rhs: Self) -> Result<Self, ArrowError>;
+
+    /// Wrapping multiplication operation
+    fn mul_wrapping(self, rhs: Self) -> Self;
+
+    /// Checked division operation
+    fn div_checked(self, rhs: Self) -> Result<Self, ArrowError>;
+
+    /// Wrapping division operation
+    fn div_wrapping(self, rhs: Self) -> Self;
+
+    /// Checked remainder operation
+    fn mod_checked(self, rhs: Self) -> Result<Self, ArrowError>;
+
+    /// Wrapping remainder operation
+    fn mod_wrapping(self, rhs: Self) -> Self;
+
+    /// Checked negation operation
+    fn neg_checked(self) -> Result<Self, ArrowError>;
+
+    /// Wrapping negation operation
+    fn neg_wrapping(self) -> Self;
+
+    /// Checked exponentiation operation
+    fn pow_checked(self, exp: u32) -> Result<Self, ArrowError>;
+
+    /// Wrapping exponentiation operation
+    fn pow_wrapping(self, exp: u32) -> Self;
+
+    /// Returns true if zero else false
+    fn is_zero(self) -> bool;
+
+    /// Compare operation
+    fn compare(self, rhs: Self) -> Ordering;
+
+    /// Equality operation
+    fn is_eq(self, rhs: Self) -> bool;
+
+    /// Not equal operation
+    #[inline]
+    fn is_ne(self, rhs: Self) -> bool {
+        !self.is_eq(rhs)
+    }
+
+    /// Less than operation
+    #[inline]
+    fn is_lt(self, rhs: Self) -> bool {
+        self.compare(rhs).is_lt()
+    }
+
+    /// Less than equals operation
+    #[inline]
+    fn is_le(self, rhs: Self) -> bool {
+        self.compare(rhs).is_le()
+    }
+
+    /// Greater than operation
+    #[inline]
+    fn is_gt(self, rhs: Self) -> bool {
+        self.compare(rhs).is_gt()
+    }
+
+    /// Greater than equals operation
+    #[inline]
+    fn is_ge(self, rhs: Self) -> bool {
+        self.compare(rhs).is_ge()
+    }
+}
+
+macro_rules! native_type_op {
+    ($t:tt) => {
+        native_type_op!($t, 0, 1, $t::MIN, $t::MAX);
+    };
+    ($t:tt, $zero:expr, $one: expr, $min: expr, $max: expr) => {
+        impl ArrowNativeTypeOp for $t {
+            const ZERO: Self = $zero;
+            const ONE: Self = $one;
+            const MIN_TOTAL_ORDER: Self = $min;
+            const MAX_TOTAL_ORDER: Self = $max;
+
+            #[inline]
+            fn add_checked(self, rhs: Self) -> Result<Self, ArrowError> {
+                self.checked_add(rhs).ok_or_else(|| {
+                    ArrowError::ComputeError(format!(
+                        "Overflow happened on: {:?} + {:?}",
+                        self, rhs
+                    ))
+                })
+            }
+
+            #[inline]
+            fn add_wrapping(self, rhs: Self) -> Self {
+                self.wrapping_add(rhs)
+            }
+
+            #[inline]
+            fn sub_checked(self, rhs: Self) -> Result<Self, ArrowError> {
+                self.checked_sub(rhs).ok_or_else(|| {
+                    ArrowError::ComputeError(format!(
+                        "Overflow happened on: {:?} - {:?}",
+                        self, rhs
+                    ))
+                })
+            }
+
+            #[inline]
+            fn sub_wrapping(self, rhs: Self) -> Self {
+                self.wrapping_sub(rhs)
+            }
+
+            #[inline]
+            fn mul_checked(self, rhs: Self) -> Result<Self, ArrowError> {
+                self.checked_mul(rhs).ok_or_else(|| {
+                    ArrowError::ComputeError(format!(
+                        "Overflow happened on: {:?} * {:?}",
+                        self, rhs
+                    ))
+                })
+            }
+
+            #[inline]
+            fn mul_wrapping(self, rhs: Self) -> Self {
+                self.wrapping_mul(rhs)
+            }
+
+            #[inline]
+            fn div_checked(self, rhs: Self) -> Result<Self, ArrowError> {
+                if rhs.is_zero() {
+                    Err(ArrowError::DivideByZero)
+                } else {
+                    self.checked_div(rhs).ok_or_else(|| {
+                        ArrowError::ComputeError(format!(
+                            "Overflow happened on: {:?} / {:?}",
+                            self, rhs
+                        ))
+                    })
+                }
+            }
+
+            #[inline]
+            fn div_wrapping(self, rhs: Self) -> Self {
+                self.wrapping_div(rhs)
+            }
+
+            #[inline]
+            fn mod_checked(self, rhs: Self) -> Result<Self, ArrowError> {
+                if rhs.is_zero() {
+                    Err(ArrowError::DivideByZero)
+                } else {
+                    self.checked_rem(rhs).ok_or_else(|| {
+                        ArrowError::ComputeError(format!(
+                            "Overflow happened on: {:?} % {:?}",
+                            self, rhs
+                        ))
+                    })
+                }
+            }
+
+            #[inline]
+            fn mod_wrapping(self, rhs: Self) -> Self {
+                self.wrapping_rem(rhs)
+            }
+
+            #[inline]
+            fn neg_checked(self) -> Result<Self, ArrowError> {
+                self.checked_neg().ok_or_else(|| {
+                    ArrowError::ComputeError(format!("Overflow happened on: {:?}", self))
+                })
+            }
+
+            #[inline]
+            fn pow_checked(self, exp: u32) -> Result<Self, ArrowError> {
+                self.checked_pow(exp).ok_or_else(|| {
+                    ArrowError::ComputeError(format!("Overflow happened on: {:?} ^ {exp:?}", self))
+                })
+            }
+
+            #[inline]
+            fn pow_wrapping(self, exp: u32) -> Self {
+                self.wrapping_pow(exp)
+            }
+
+            #[inline]
+            fn neg_wrapping(self) -> Self {
+                self.wrapping_neg()
+            }
+
+            #[inline]
+            fn is_zero(self) -> bool {
+                self == Self::ZERO
+            }
+
+            #[inline]
+            fn compare(self, rhs: Self) -> Ordering {
+                self.cmp(&rhs)
+            }
+
+            #[inline]
+            fn is_eq(self, rhs: Self) -> bool {
+                self == rhs
+            }
+        }
+    };
+}
+
+native_type_op!(i8);
+native_type_op!(i16);
+native_type_op!(i32);
+native_type_op!(i64);
+native_type_op!(i128);
+native_type_op!(u8);
+native_type_op!(u16);
+native_type_op!(u32);
+native_type_op!(u64);
+native_type_op!(i256, i256::ZERO, i256::ONE, i256::MIN, i256::MAX);
+
+macro_rules! native_type_float_op {
+    ($t:tt, $zero:expr, $one:expr, $min:expr, $max:expr) => {
+        impl ArrowNativeTypeOp for $t {
+            const ZERO: Self = $zero;
+            const ONE: Self = $one;
+            const MIN_TOTAL_ORDER: Self = $min;
+            const MAX_TOTAL_ORDER: Self = $max;
+
+            #[inline]
+            fn add_checked(self, rhs: Self) -> Result<Self, ArrowError> {
+                Ok(self + rhs)
+            }
+
+            #[inline]
+            fn add_wrapping(self, rhs: Self) -> Self {
+                self + rhs
+            }
+
+            #[inline]
+            fn sub_checked(self, rhs: Self) -> Result<Self, ArrowError> {
+                Ok(self - rhs)
+            }
+
+            #[inline]
+            fn sub_wrapping(self, rhs: Self) -> Self {
+                self - rhs
+            }
+
+            #[inline]
+            fn mul_checked(self, rhs: Self) -> Result<Self, ArrowError> {
+                Ok(self * rhs)
+            }
+
+            #[inline]
+            fn mul_wrapping(self, rhs: Self) -> Self {
+                self * rhs
+            }
+
+            #[inline]
+            fn div_checked(self, rhs: Self) -> Result<Self, ArrowError> {
+                if rhs.is_zero() {
+                    Err(ArrowError::DivideByZero)
+                } else {
+                    Ok(self / rhs)
+                }
+            }
+
+            #[inline]
+            fn div_wrapping(self, rhs: Self) -> Self {
+                self / rhs
+            }
+
+            #[inline]
+            fn mod_checked(self, rhs: Self) -> Result<Self, ArrowError> {
+                if rhs.is_zero() {
+                    Err(ArrowError::DivideByZero)
+                } else {
+                    Ok(self % rhs)
+                }
+            }
+
+            #[inline]
+            fn mod_wrapping(self, rhs: Self) -> Self {
+                self % rhs
+            }
+
+            #[inline]
+            fn neg_checked(self) -> Result<Self, ArrowError> {
+                Ok(-self)
+            }
+
+            #[inline]
+            fn neg_wrapping(self) -> Self {
+                -self
+            }
+
+            #[inline]
+            fn pow_checked(self, exp: u32) -> Result<Self, ArrowError> {
+                Ok(self.powi(exp as i32))
+            }
+
+            #[inline]
+            fn pow_wrapping(self, exp: u32) -> Self {
+                self.powi(exp as i32)
+            }
+
+            #[inline]
+            fn is_zero(self) -> bool {
+                self == $zero
+            }
+
+            #[inline]
+            fn compare(self, rhs: Self) -> Ordering {
+                <$t>::total_cmp(&self, &rhs)
+            }
+
+            #[inline]
+            fn is_eq(self, rhs: Self) -> bool {
+                // Equivalent to `self.total_cmp(&rhs).is_eq()`
+                // but LLVM isn't able to realise this is bitwise equality
+                // https://rust.godbolt.org/z/347nWGxoW
+                self.to_bits() == rhs.to_bits()
+            }
+        }
+    };
+}
+
+// the smallest/largest bit patterns for floating point numbers are NaN, but differ from the canonical NAN constants.
+// See test_float_total_order_min_max for details.
+native_type_float_op!(
+    f16,
+    f16::ZERO,
+    f16::ONE,
+    f16::from_bits(-1 as _),
+    f16::from_bits(i16::MAX as _)
+);
+// from_bits is not yet stable as const fn, see https://github.com/rust-lang/rust/issues/72447
+native_type_float_op!(
+    f32,
+    0.,
+    1.,
+    unsafe { std::mem::transmute(-1_i32) },
+    unsafe { std::mem::transmute(i32::MAX) }
+);
+native_type_float_op!(
+    f64,
+    0.,
+    1.,
+    unsafe { std::mem::transmute(-1_i64) },
+    unsafe { std::mem::transmute(i64::MAX) }
+);
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_native_type_is_zero() {
+        assert!(0_i8.is_zero());
+        assert!(0_i16.is_zero());
+        assert!(0_i32.is_zero());
+        assert!(0_i64.is_zero());
+        assert!(0_i128.is_zero());
+        assert!(i256::ZERO.is_zero());
+        assert!(0_u8.is_zero());
+        assert!(0_u16.is_zero());
+        assert!(0_u32.is_zero());
+        assert!(0_u64.is_zero());
+        assert!(f16::ZERO.is_zero());
+        assert!(0.0_f32.is_zero());
+        assert!(0.0_f64.is_zero());
+    }
+
+    #[test]
+    fn test_native_type_comparison() {
+        // is_eq
+        assert!(8_i8.is_eq(8_i8));
+        assert!(8_i16.is_eq(8_i16));
+        assert!(8_i32.is_eq(8_i32));
+        assert!(8_i64.is_eq(8_i64));
+        assert!(8_i128.is_eq(8_i128));
+        assert!(i256::from_parts(8, 0).is_eq(i256::from_parts(8, 0)));
+        assert!(8_u8.is_eq(8_u8));
+        assert!(8_u16.is_eq(8_u16));
+        assert!(8_u32.is_eq(8_u32));
+        assert!(8_u64.is_eq(8_u64));
+        assert!(f16::from_f32(8.0).is_eq(f16::from_f32(8.0)));
+        assert!(8.0_f32.is_eq(8.0_f32));
+        assert!(8.0_f64.is_eq(8.0_f64));
+
+        // is_ne
+        assert!(8_i8.is_ne(1_i8));
+        assert!(8_i16.is_ne(1_i16));
+        assert!(8_i32.is_ne(1_i32));
+        assert!(8_i64.is_ne(1_i64));
+        assert!(8_i128.is_ne(1_i128));
+        assert!(i256::from_parts(8, 0).is_ne(i256::from_parts(1, 0)));
+        assert!(8_u8.is_ne(1_u8));
+        assert!(8_u16.is_ne(1_u16));
+        assert!(8_u32.is_ne(1_u32));
+        assert!(8_u64.is_ne(1_u64));
+        assert!(f16::from_f32(8.0).is_ne(f16::from_f32(1.0)));
+        assert!(8.0_f32.is_ne(1.0_f32));
+        assert!(8.0_f64.is_ne(1.0_f64));
+
+        // is_lt
+        assert!(8_i8.is_lt(10_i8));
+        assert!(8_i16.is_lt(10_i16));
+        assert!(8_i32.is_lt(10_i32));
+        assert!(8_i64.is_lt(10_i64));
+        assert!(8_i128.is_lt(10_i128));
+        assert!(i256::from_parts(8, 0).is_lt(i256::from_parts(10, 0)));
+        assert!(8_u8.is_lt(10_u8));
+        assert!(8_u16.is_lt(10_u16));
+        assert!(8_u32.is_lt(10_u32));
+        assert!(8_u64.is_lt(10_u64));
+        assert!(f16::from_f32(8.0).is_lt(f16::from_f32(10.0)));
+        assert!(8.0_f32.is_lt(10.0_f32));
+        assert!(8.0_f64.is_lt(10.0_f64));
+
+        // is_gt
+        assert!(8_i8.is_gt(1_i8));
+        assert!(8_i16.is_gt(1_i16));
+        assert!(8_i32.is_gt(1_i32));
+        assert!(8_i64.is_gt(1_i64));
+        assert!(8_i128.is_gt(1_i128));
+        assert!(i256::from_parts(8, 0).is_gt(i256::from_parts(1, 0)));
+        assert!(8_u8.is_gt(1_u8));
+        assert!(8_u16.is_gt(1_u16));
+        assert!(8_u32.is_gt(1_u32));
+        assert!(8_u64.is_gt(1_u64));
+        assert!(f16::from_f32(8.0).is_gt(f16::from_f32(1.0)));
+        assert!(8.0_f32.is_gt(1.0_f32));
+        assert!(8.0_f64.is_gt(1.0_f64));
+    }
+
+    #[test]
+    fn test_native_type_add() {
+        // add_wrapping
+        assert_eq!(8_i8.add_wrapping(2_i8), 10_i8);
+        assert_eq!(8_i16.add_wrapping(2_i16), 10_i16);
+        assert_eq!(8_i32.add_wrapping(2_i32), 10_i32);
+        assert_eq!(8_i64.add_wrapping(2_i64), 10_i64);
+        assert_eq!(8_i128.add_wrapping(2_i128), 10_i128);
+        assert_eq!(
+            i256::from_parts(8, 0).add_wrapping(i256::from_parts(2, 0)),
+            i256::from_parts(10, 0)
+        );
+        assert_eq!(8_u8.add_wrapping(2_u8), 10_u8);
+        assert_eq!(8_u16.add_wrapping(2_u16), 10_u16);
+        assert_eq!(8_u32.add_wrapping(2_u32), 10_u32);
+        assert_eq!(8_u64.add_wrapping(2_u64), 10_u64);
+        assert_eq!(
+            f16::from_f32(8.0).add_wrapping(f16::from_f32(2.0)),
+            f16::from_f32(10.0)
+        );
+        assert_eq!(8.0_f32.add_wrapping(2.0_f32), 10_f32);
+        assert_eq!(8.0_f64.add_wrapping(2.0_f64), 10_f64);
+
+        // add_checked
+        assert_eq!(8_i8.add_checked(2_i8).unwrap(), 10_i8);
+        assert_eq!(8_i16.add_checked(2_i16).unwrap(), 10_i16);
+        assert_eq!(8_i32.add_checked(2_i32).unwrap(), 10_i32);
+        assert_eq!(8_i64.add_checked(2_i64).unwrap(), 10_i64);
+        assert_eq!(8_i128.add_checked(2_i128).unwrap(), 10_i128);
+        assert_eq!(
+            i256::from_parts(8, 0)
+                .add_checked(i256::from_parts(2, 0))
+                .unwrap(),
+            i256::from_parts(10, 0)
+        );
+        assert_eq!(8_u8.add_checked(2_u8).unwrap(), 10_u8);
+        assert_eq!(8_u16.add_checked(2_u16).unwrap(), 10_u16);
+        assert_eq!(8_u32.add_checked(2_u32).unwrap(), 10_u32);
+        assert_eq!(8_u64.add_checked(2_u64).unwrap(), 10_u64);
+        assert_eq!(
+            f16::from_f32(8.0).add_checked(f16::from_f32(2.0)).unwrap(),
+            f16::from_f32(10.0)
+        );
+        assert_eq!(8.0_f32.add_checked(2.0_f32).unwrap(), 10_f32);
+        assert_eq!(8.0_f64.add_checked(2.0_f64).unwrap(), 10_f64);
+    }
+
+    #[test]
+    fn test_native_type_sub() {
+        // sub_wrapping
+        assert_eq!(8_i8.sub_wrapping(2_i8), 6_i8);
+        assert_eq!(8_i16.sub_wrapping(2_i16), 6_i16);
+        assert_eq!(8_i32.sub_wrapping(2_i32), 6_i32);
+        assert_eq!(8_i64.sub_wrapping(2_i64), 6_i64);
+        assert_eq!(8_i128.sub_wrapping(2_i128), 6_i128);
+        assert_eq!(
+            i256::from_parts(8, 0).sub_wrapping(i256::from_parts(2, 0)),
+            i256::from_parts(6, 0)
+        );
+        assert_eq!(8_u8.sub_wrapping(2_u8), 6_u8);
+        assert_eq!(8_u16.sub_wrapping(2_u16), 6_u16);
+        assert_eq!(8_u32.sub_wrapping(2_u32), 6_u32);
+        assert_eq!(8_u64.sub_wrapping(2_u64), 6_u64);
+        assert_eq!(
+            f16::from_f32(8.0).sub_wrapping(f16::from_f32(2.0)),
+            f16::from_f32(6.0)
+        );
+        assert_eq!(8.0_f32.sub_wrapping(2.0_f32), 6_f32);
+        assert_eq!(8.0_f64.sub_wrapping(2.0_f64), 6_f64);
+
+        // sub_checked
+        assert_eq!(8_i8.sub_checked(2_i8).unwrap(), 6_i8);
+        assert_eq!(8_i16.sub_checked(2_i16).unwrap(), 6_i16);
+        assert_eq!(8_i32.sub_checked(2_i32).unwrap(), 6_i32);
+        assert_eq!(8_i64.sub_checked(2_i64).unwrap(), 6_i64);
+        assert_eq!(8_i128.sub_checked(2_i128).unwrap(), 6_i128);
+        assert_eq!(
+            i256::from_parts(8, 0)
+                .sub_checked(i256::from_parts(2, 0))
+                .unwrap(),
+            i256::from_parts(6, 0)
+        );
+        assert_eq!(8_u8.sub_checked(2_u8).unwrap(), 6_u8);
+        assert_eq!(8_u16.sub_checked(2_u16).unwrap(), 6_u16);
+        assert_eq!(8_u32.sub_checked(2_u32).unwrap(), 6_u32);
+        assert_eq!(8_u64.sub_checked(2_u64).unwrap(), 6_u64);
+        assert_eq!(
+            f16::from_f32(8.0).sub_checked(f16::from_f32(2.0)).unwrap(),
+            f16::from_f32(6.0)
+        );
+        assert_eq!(8.0_f32.sub_checked(2.0_f32).unwrap(), 6_f32);
+        assert_eq!(8.0_f64.sub_checked(2.0_f64).unwrap(), 6_f64);
+    }
+
+    #[test]
+    fn test_native_type_mul() {
+        // mul_wrapping
+        assert_eq!(8_i8.mul_wrapping(2_i8), 16_i8);
+        assert_eq!(8_i16.mul_wrapping(2_i16), 16_i16);
+        assert_eq!(8_i32.mul_wrapping(2_i32), 16_i32);
+        assert_eq!(8_i64.mul_wrapping(2_i64), 16_i64);
+        assert_eq!(8_i128.mul_wrapping(2_i128), 16_i128);
+        assert_eq!(
+            i256::from_parts(8, 0).mul_wrapping(i256::from_parts(2, 0)),
+            i256::from_parts(16, 0)
+        );
+        assert_eq!(8_u8.mul_wrapping(2_u8), 16_u8);
+        assert_eq!(8_u16.mul_wrapping(2_u16), 16_u16);
+        assert_eq!(8_u32.mul_wrapping(2_u32), 16_u32);
+        assert_eq!(8_u64.mul_wrapping(2_u64), 16_u64);
+        assert_eq!(
+            f16::from_f32(8.0).mul_wrapping(f16::from_f32(2.0)),
+            f16::from_f32(16.0)
+        );
+        assert_eq!(8.0_f32.mul_wrapping(2.0_f32), 16_f32);
+        assert_eq!(8.0_f64.mul_wrapping(2.0_f64), 16_f64);
+
+        // mul_checked
+        assert_eq!(8_i8.mul_checked(2_i8).unwrap(), 16_i8);
+        assert_eq!(8_i16.mul_checked(2_i16).unwrap(), 16_i16);
+        assert_eq!(8_i32.mul_checked(2_i32).unwrap(), 16_i32);
+        assert_eq!(8_i64.mul_checked(2_i64).unwrap(), 16_i64);
+        assert_eq!(8_i128.mul_checked(2_i128).unwrap(), 16_i128);
+        assert_eq!(
+            i256::from_parts(8, 0)
+                .mul_checked(i256::from_parts(2, 0))
+                .unwrap(),
+            i256::from_parts(16, 0)
+        );
+        assert_eq!(8_u8.mul_checked(2_u8).unwrap(), 16_u8);
+        assert_eq!(8_u16.mul_checked(2_u16).unwrap(), 16_u16);
+        assert_eq!(8_u32.mul_checked(2_u32).unwrap(), 16_u32);
+        assert_eq!(8_u64.mul_checked(2_u64).unwrap(), 16_u64);
+        assert_eq!(
+            f16::from_f32(8.0).mul_checked(f16::from_f32(2.0)).unwrap(),
+            f16::from_f32(16.0)
+        );
+        assert_eq!(8.0_f32.mul_checked(2.0_f32).unwrap(), 16_f32);
+        assert_eq!(8.0_f64.mul_checked(2.0_f64).unwrap(), 16_f64);
+    }
+
+    #[test]
+    fn test_native_type_div() {
+        // div_wrapping
+        assert_eq!(8_i8.div_wrapping(2_i8), 4_i8);
+        assert_eq!(8_i16.div_wrapping(2_i16), 4_i16);
+        assert_eq!(8_i32.div_wrapping(2_i32), 4_i32);
+        assert_eq!(8_i64.div_wrapping(2_i64), 4_i64);
+        assert_eq!(8_i128.div_wrapping(2_i128), 4_i128);
+        assert_eq!(
+            i256::from_parts(8, 0).div_wrapping(i256::from_parts(2, 0)),
+            i256::from_parts(4, 0)
+        );
+        assert_eq!(8_u8.div_wrapping(2_u8), 4_u8);
+        assert_eq!(8_u16.div_wrapping(2_u16), 4_u16);
+        assert_eq!(8_u32.div_wrapping(2_u32), 4_u32);
+        assert_eq!(8_u64.div_wrapping(2_u64), 4_u64);
+        assert_eq!(
+            f16::from_f32(8.0).div_wrapping(f16::from_f32(2.0)),
+            f16::from_f32(4.0)
+        );
+        assert_eq!(8.0_f32.div_wrapping(2.0_f32), 4_f32);
+        assert_eq!(8.0_f64.div_wrapping(2.0_f64), 4_f64);
+
+        // div_checked
+        assert_eq!(8_i8.div_checked(2_i8).unwrap(), 4_i8);
+        assert_eq!(8_i16.div_checked(2_i16).unwrap(), 4_i16);
+        assert_eq!(8_i32.div_checked(2_i32).unwrap(), 4_i32);
+        assert_eq!(8_i64.div_checked(2_i64).unwrap(), 4_i64);
+        assert_eq!(8_i128.div_checked(2_i128).unwrap(), 4_i128);
+        assert_eq!(
+            i256::from_parts(8, 0)
+                .div_checked(i256::from_parts(2, 0))
+                .unwrap(),
+            i256::from_parts(4, 0)
+        );
+        assert_eq!(8_u8.div_checked(2_u8).unwrap(), 4_u8);
+        assert_eq!(8_u16.div_checked(2_u16).unwrap(), 4_u16);
+        assert_eq!(8_u32.div_checked(2_u32).unwrap(), 4_u32);
+        assert_eq!(8_u64.div_checked(2_u64).unwrap(), 4_u64);
+        assert_eq!(
+            f16::from_f32(8.0).div_checked(f16::from_f32(2.0)).unwrap(),
+            f16::from_f32(4.0)
+        );
+        assert_eq!(8.0_f32.div_checked(2.0_f32).unwrap(), 4_f32);
+        assert_eq!(8.0_f64.div_checked(2.0_f64).unwrap(), 4_f64);
+    }
+
+    #[test]
+    fn test_native_type_mod() {
+        // mod_wrapping
+        assert_eq!(9_i8.mod_wrapping(2_i8), 1_i8);
+        assert_eq!(9_i16.mod_wrapping(2_i16), 1_i16);
+        assert_eq!(9_i32.mod_wrapping(2_i32), 1_i32);
+        assert_eq!(9_i64.mod_wrapping(2_i64), 1_i64);
+        assert_eq!(9_i128.mod_wrapping(2_i128), 1_i128);
+        assert_eq!(
+            i256::from_parts(9, 0).mod_wrapping(i256::from_parts(2, 0)),
+            i256::from_parts(1, 0)
+        );
+        assert_eq!(9_u8.mod_wrapping(2_u8), 1_u8);
+        assert_eq!(9_u16.mod_wrapping(2_u16), 1_u16);
+        assert_eq!(9_u32.mod_wrapping(2_u32), 1_u32);
+        assert_eq!(9_u64.mod_wrapping(2_u64), 1_u64);
+        assert_eq!(
+            f16::from_f32(9.0).mod_wrapping(f16::from_f32(2.0)),
+            f16::from_f32(1.0)
+        );
+        assert_eq!(9.0_f32.mod_wrapping(2.0_f32), 1_f32);
+        assert_eq!(9.0_f64.mod_wrapping(2.0_f64), 1_f64);
+
+        // mod_checked
+        assert_eq!(9_i8.mod_checked(2_i8).unwrap(), 1_i8);
+        assert_eq!(9_i16.mod_checked(2_i16).unwrap(), 1_i16);
+        assert_eq!(9_i32.mod_checked(2_i32).unwrap(), 1_i32);
+        assert_eq!(9_i64.mod_checked(2_i64).unwrap(), 1_i64);
+        assert_eq!(9_i128.mod_checked(2_i128).unwrap(), 1_i128);
+        assert_eq!(
+            i256::from_parts(9, 0)
+                .mod_checked(i256::from_parts(2, 0))
+                .unwrap(),
+            i256::from_parts(1, 0)
+        );
+        assert_eq!(9_u8.mod_checked(2_u8).unwrap(), 1_u8);
+        assert_eq!(9_u16.mod_checked(2_u16).unwrap(), 1_u16);
+        assert_eq!(9_u32.mod_checked(2_u32).unwrap(), 1_u32);
+        assert_eq!(9_u64.mod_checked(2_u64).unwrap(), 1_u64);
+        assert_eq!(
+            f16::from_f32(9.0).mod_checked(f16::from_f32(2.0)).unwrap(),
+            f16::from_f32(1.0)
+        );
+        assert_eq!(9.0_f32.mod_checked(2.0_f32).unwrap(), 1_f32);
+        assert_eq!(9.0_f64.mod_checked(2.0_f64).unwrap(), 1_f64);
+    }
+
+    #[test]
+    fn test_native_type_neg() {
+        // neg_wrapping
+        assert_eq!(8_i8.neg_wrapping(), -8_i8);
+        assert_eq!(8_i16.neg_wrapping(), -8_i16);
+        assert_eq!(8_i32.neg_wrapping(), -8_i32);
+        assert_eq!(8_i64.neg_wrapping(), -8_i64);
+        assert_eq!(8_i128.neg_wrapping(), -8_i128);
+        assert_eq!(i256::from_parts(8, 0).neg_wrapping(), i256::from_i128(-8));
+        assert_eq!(8_u8.neg_wrapping(), u8::MAX - 7_u8);
+        assert_eq!(8_u16.neg_wrapping(), u16::MAX - 7_u16);
+        assert_eq!(8_u32.neg_wrapping(), u32::MAX - 7_u32);
+        assert_eq!(8_u64.neg_wrapping(), u64::MAX - 7_u64);
+        assert_eq!(f16::from_f32(8.0).neg_wrapping(), f16::from_f32(-8.0));
+        assert_eq!(8.0_f32.neg_wrapping(), -8_f32);
+        assert_eq!(8.0_f64.neg_wrapping(), -8_f64);
+
+        // neg_checked
+        assert_eq!(8_i8.neg_checked().unwrap(), -8_i8);
+        assert_eq!(8_i16.neg_checked().unwrap(), -8_i16);
+        assert_eq!(8_i32.neg_checked().unwrap(), -8_i32);
+        assert_eq!(8_i64.neg_checked().unwrap(), -8_i64);
+        assert_eq!(8_i128.neg_checked().unwrap(), -8_i128);
+        assert_eq!(
+            i256::from_parts(8, 0).neg_checked().unwrap(),
+            i256::from_i128(-8)
+        );
+        assert!(8_u8.neg_checked().is_err());
+        assert!(8_u16.neg_checked().is_err());
+        assert!(8_u32.neg_checked().is_err());
+        assert!(8_u64.neg_checked().is_err());
+        assert_eq!(
+            f16::from_f32(8.0).neg_checked().unwrap(),
+            f16::from_f32(-8.0)
+        );
+        assert_eq!(8.0_f32.neg_checked().unwrap(), -8_f32);
+        assert_eq!(8.0_f64.neg_checked().unwrap(), -8_f64);
+    }
+
+    #[test]
+    fn test_native_type_pow() {
+        // pow_wrapping
+        assert_eq!(8_i8.pow_wrapping(2_u32), 64_i8);
+        assert_eq!(8_i16.pow_wrapping(2_u32), 64_i16);
+        assert_eq!(8_i32.pow_wrapping(2_u32), 64_i32);
+        assert_eq!(8_i64.pow_wrapping(2_u32), 64_i64);
+        assert_eq!(8_i128.pow_wrapping(2_u32), 64_i128);
+        assert_eq!(
+            i256::from_parts(8, 0).pow_wrapping(2_u32),
+            i256::from_parts(64, 0)
+        );
+        assert_eq!(8_u8.pow_wrapping(2_u32), 64_u8);
+        assert_eq!(8_u16.pow_wrapping(2_u32), 64_u16);
+        assert_eq!(8_u32.pow_wrapping(2_u32), 64_u32);
+        assert_eq!(8_u64.pow_wrapping(2_u32), 64_u64);
+        assert_eq!(f16::from_f32(8.0).pow_wrapping(2_u32), f16::from_f32(64.0));
+        assert_eq!(8.0_f32.pow_wrapping(2_u32), 64_f32);
+        assert_eq!(8.0_f64.pow_wrapping(2_u32), 64_f64);
+
+        // pow_checked
+        assert_eq!(8_i8.pow_checked(2_u32).unwrap(), 64_i8);
+        assert_eq!(8_i16.pow_checked(2_u32).unwrap(), 64_i16);
+        assert_eq!(8_i32.pow_checked(2_u32).unwrap(), 64_i32);
+        assert_eq!(8_i64.pow_checked(2_u32).unwrap(), 64_i64);
+        assert_eq!(8_i128.pow_checked(2_u32).unwrap(), 64_i128);
+        assert_eq!(
+            i256::from_parts(8, 0).pow_checked(2_u32).unwrap(),
+            i256::from_parts(64, 0)
+        );
+        assert_eq!(8_u8.pow_checked(2_u32).unwrap(), 64_u8);
+        assert_eq!(8_u16.pow_checked(2_u32).unwrap(), 64_u16);
+        assert_eq!(8_u32.pow_checked(2_u32).unwrap(), 64_u32);
+        assert_eq!(8_u64.pow_checked(2_u32).unwrap(), 64_u64);
+        assert_eq!(
+            f16::from_f32(8.0).pow_checked(2_u32).unwrap(),
+            f16::from_f32(64.0)
+        );
+        assert_eq!(8.0_f32.pow_checked(2_u32).unwrap(), 64_f32);
+        assert_eq!(8.0_f64.pow_checked(2_u32).unwrap(), 64_f64);
+    }
+
+    #[test]
+    fn test_float_total_order_min_max() {
+        assert!(<f64 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_lt(f64::NEG_INFINITY));
+        assert!(<f64 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_gt(f64::INFINITY));
+
+        assert!(<f64 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_nan());
+        assert!(<f64 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_sign_negative());
+        assert!(<f64 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_lt(-f64::NAN));
+
+        assert!(<f64 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_nan());
+        assert!(<f64 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_sign_positive());
+        assert!(<f64 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_gt(f64::NAN));
+
+        assert!(<f32 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_lt(f32::NEG_INFINITY));
+        assert!(<f32 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_gt(f32::INFINITY));
+
+        assert!(<f32 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_nan());
+        assert!(<f32 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_sign_negative());
+        assert!(<f32 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_lt(-f32::NAN));
+
+        assert!(<f32 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_nan());
+        assert!(<f32 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_sign_positive());
+        assert!(<f32 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_gt(f32::NAN));
+
+        assert!(<f16 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_lt(f16::NEG_INFINITY));
+        assert!(<f16 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_gt(f16::INFINITY));
+
+        assert!(<f16 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_nan());
+        assert!(<f16 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_sign_negative());
+        assert!(<f16 as ArrowNativeTypeOp>::MIN_TOTAL_ORDER.is_lt(-f16::NAN));
+
+        assert!(<f16 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_nan());
+        assert!(<f16 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_sign_positive());
+        assert!(<f16 as ArrowNativeTypeOp>::MAX_TOTAL_ORDER.is_gt(f16::NAN));
+    }
+}
diff --git a/arrow/src/array/array_binary.rs b/arrow-array/src/array/binary_array.rs
similarity index 60%
rename from arrow/src/array/array_binary.rs
rename to arrow-array/src/array/binary_array.rs
index 12c6978107d1..6b18cbc2d9f7 100644
--- a/arrow/src/array/array_binary.rs
+++ b/arrow-array/src/array/binary_array.rs
@@ -15,113 +15,21 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::convert::From;
-use std::fmt;
-use std::{any::Any, iter::FromIterator};
-
-use super::{
-    array::print_long_array, raw_pointer::RawPtrBox, Array, ArrayData, GenericBinaryIter,
-    GenericListArray, OffsetSizeTrait,
-};
-use crate::array::array::ArrayAccessor;
-use crate::buffer::Buffer;
-use crate::util::bit_util;
-use crate::{buffer::MutableBuffer, datatypes::DataType};
-
-/// See [`BinaryArray`] and [`LargeBinaryArray`] for storing
-/// binary data.
-pub struct GenericBinaryArray<OffsetSize: OffsetSizeTrait> {
-    data: ArrayData,
-    value_offsets: RawPtrBox<OffsetSize>,
-    value_data: RawPtrBox<u8>,
-}
+use crate::types::{ByteArrayType, GenericBinaryType};
+use crate::{Array, GenericByteArray, GenericListArray, GenericStringArray, OffsetSizeTrait};
+use arrow_data::ArrayData;
+use arrow_schema::DataType;
 
-impl<OffsetSize: OffsetSizeTrait> GenericBinaryArray<OffsetSize> {
-    /// Data type of the array.
-    pub const DATA_TYPE: DataType = if OffsetSize::IS_LARGE {
-        DataType::LargeBinary
-    } else {
-        DataType::Binary
-    };
+/// A [`GenericBinaryArray`] for storing `[u8]`
+pub type GenericBinaryArray<OffsetSize> = GenericByteArray<GenericBinaryType<OffsetSize>>;
 
+impl<OffsetSize: OffsetSizeTrait> GenericBinaryArray<OffsetSize> {
     /// Get the data type of the array.
     #[deprecated(note = "please use `Self::DATA_TYPE` instead")]
     pub const fn get_data_type() -> DataType {
         Self::DATA_TYPE
     }
 
-    /// Returns the length for value at index `i`.
-    #[inline]
-    pub fn value_length(&self, i: usize) -> OffsetSize {
-        let offsets = self.value_offsets();
-        offsets[i + 1] - offsets[i]
-    }
-
-    /// Returns a clone of the value data buffer
-    pub fn value_data(&self) -> Buffer {
-        self.data.buffers()[1].clone()
-    }
-
-    /// Returns the offset values in the offsets buffer
-    #[inline]
-    pub fn value_offsets(&self) -> &[OffsetSize] {
-        // Soundness
-        //     pointer alignment & location is ensured by RawPtrBox
-        //     buffer bounds/offset is ensured by the ArrayData instance.
-        unsafe {
-            std::slice::from_raw_parts(
-                self.value_offsets.as_ptr().add(self.data.offset()),
-                self.len() + 1,
-            )
-        }
-    }
-
-    /// Returns the element at index `i` as bytes slice
-    /// # Safety
-    /// Caller is responsible for ensuring that the index is within the bounds of the array
-    pub unsafe fn value_unchecked(&self, i: usize) -> &[u8] {
-        let end = *self.value_offsets().get_unchecked(i + 1);
-        let start = *self.value_offsets().get_unchecked(i);
-
-        // Soundness
-        // pointer alignment & location is ensured by RawPtrBox
-        // buffer bounds/offset is ensured by the value_offset invariants
-
-        // Safety of `to_isize().unwrap()`
-        // `start` and `end` are &OffsetSize, which is a generic type that implements the
-        // OffsetSizeTrait. Currently, only i32 and i64 implement OffsetSizeTrait,
-        // both of which should cleanly cast to isize on an architecture that supports
-        // 32/64-bit offsets
-        std::slice::from_raw_parts(
-            self.value_data.as_ptr().offset(start.to_isize().unwrap()),
-            (end - start).to_usize().unwrap(),
-        )
-    }
-
-    /// Returns the element at index `i` as bytes slice
-    pub fn value(&self, i: usize) -> &[u8] {
-        assert!(i < self.data.len(), "BinaryArray out of bounds access");
-        //Soundness: length checked above, offset buffer length is 1 larger than logical array length
-        let end = unsafe { self.value_offsets().get_unchecked(i + 1) };
-        let start = unsafe { self.value_offsets().get_unchecked(i) };
-
-        // Soundness
-        // pointer alignment & location is ensured by RawPtrBox
-        // buffer bounds/offset is ensured by the value_offset invariants
-
-        // Safety of `to_isize().unwrap()`
-        // `start` and `end` are &OffsetSize, which is a generic type that implements the
-        // OffsetSizeTrait. Currently, only i32 and i64 implement OffsetSizeTrait,
-        // both of which should cleanly cast to isize on an architecture that supports
-        // 32/64-bit offsets
-        unsafe {
-            std::slice::from_raw_parts(
-                self.value_data.as_ptr().offset(start.to_isize().unwrap()),
-                (*end - *start).to_usize().unwrap(),
-            )
-        }
-    }
-
     /// Creates a [GenericBinaryArray] from a vector of byte slices
     ///
     /// See also [`Self::from_iter_values`]
@@ -135,13 +43,14 @@ impl<OffsetSize: OffsetSizeTrait> GenericBinaryArray<OffsetSize> {
     }
 
     fn from_list(v: GenericListArray<OffsetSize>) -> Self {
+        let v = v.into_data();
         assert_eq!(
-            v.data_ref().child_data().len(),
+            v.child_data().len(),
             1,
             "BinaryArray can only be created from list array of u8 values \
              (i.e. List<PrimitiveArray<u8>>)."
         );
-        let child_data = &v.data_ref().child_data()[0];
+        let child_data = &v.child_data()[0];
 
         assert_eq!(
             child_data.child_data().len(),
@@ -163,50 +72,14 @@ impl<OffsetSize: OffsetSizeTrait> GenericBinaryArray<OffsetSize> {
         let builder = ArrayData::builder(Self::DATA_TYPE)
             .len(v.len())
             .offset(v.offset())
-            .add_buffer(v.data_ref().buffers()[0].clone())
+            .add_buffer(v.buffers()[0].clone())
             .add_buffer(child_data.buffers()[0].slice(child_data.offset()))
-            .null_bit_buffer(v.data_ref().null_buffer().cloned());
+            .nulls(v.nulls().cloned());
 
         let data = unsafe { builder.build_unchecked() };
         Self::from(data)
     }
 
-    /// Creates a [`GenericBinaryArray`] based on an iterator of values without nulls
-    pub fn from_iter_values<Ptr, I>(iter: I) -> Self
-    where
-        Ptr: AsRef<[u8]>,
-        I: IntoIterator<Item = Ptr>,
-    {
-        let iter = iter.into_iter();
-        let (_, data_len) = iter.size_hint();
-        let data_len = data_len.expect("Iterator must be sized"); // panic if no upper bound.
-
-        let mut offsets =
-            MutableBuffer::new((data_len + 1) * std::mem::size_of::<OffsetSize>());
-        let mut values = MutableBuffer::new(0);
-
-        let mut length_so_far = OffsetSize::zero();
-        offsets.push(length_so_far);
-
-        for s in iter {
-            let s = s.as_ref();
-            length_so_far += OffsetSize::from_usize(s.len()).unwrap();
-            offsets.push(length_so_far);
-            values.extend_from_slice(s);
-        }
-
-        // iterator size hint may not be correct so compute the actual number of offsets
-        assert!(!offsets.is_empty()); // wrote at least one
-        let actual_len = (offsets.len() / std::mem::size_of::<OffsetSize>()) - 1;
-
-        let array_data = ArrayData::builder(Self::DATA_TYPE)
-            .len(actual_len)
-            .add_buffer(offsets.into())
-            .add_buffer(values.into());
-        let array_data = unsafe { array_data.build_unchecked() };
-        Self::from(array_data)
-    }
-
     /// Returns an iterator that returns the values of `array.value(i)` for an iterator with each element `i`
     pub fn take_iter<'a>(
         &'a self,
@@ -227,84 +100,7 @@ impl<OffsetSize: OffsetSizeTrait> GenericBinaryArray<OffsetSize> {
     }
 }
 
-impl<'a, T: OffsetSizeTrait> GenericBinaryArray<T> {
-    /// constructs a new iterator
-    pub fn iter(&'a self) -> GenericBinaryIter<'a, T> {
-        GenericBinaryIter::<'a, T>::new(self)
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> fmt::Debug for GenericBinaryArray<OffsetSize> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let prefix = OffsetSize::PREFIX;
-
-        write!(f, "{}BinaryArray\n[\n", prefix)?;
-        print_long_array(self, f, |array, index, f| {
-            fmt::Debug::fmt(&array.value(index), f)
-        })?;
-        write!(f, "]")
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> Array for GenericBinaryArray<OffsetSize> {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.into()
-    }
-}
-
-impl<'a, OffsetSize: OffsetSizeTrait> ArrayAccessor
-    for &'a GenericBinaryArray<OffsetSize>
-{
-    type Item = &'a [u8];
-
-    fn value(&self, index: usize) -> Self::Item {
-        GenericBinaryArray::value(self, index)
-    }
-
-    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
-        GenericBinaryArray::value_unchecked(self, index)
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> From<ArrayData> for GenericBinaryArray<OffsetSize> {
-    fn from(data: ArrayData) -> Self {
-        assert_eq!(
-            data.data_type(),
-            &Self::DATA_TYPE,
-            "[Large]BinaryArray expects Datatype::[Large]Binary"
-        );
-        assert_eq!(
-            data.buffers().len(),
-            2,
-            "BinaryArray data should contain 2 buffers only (offsets and values)"
-        );
-        let offsets = data.buffers()[0].as_ptr();
-        let values = data.buffers()[1].as_ptr();
-        Self {
-            data,
-            value_offsets: unsafe { RawPtrBox::new(offsets) },
-            value_data: unsafe { RawPtrBox::new(values) },
-        }
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> From<GenericBinaryArray<OffsetSize>> for ArrayData {
-    fn from(array: GenericBinaryArray<OffsetSize>) -> Self {
-        array.data
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> From<Vec<Option<&[u8]>>>
-    for GenericBinaryArray<OffsetSize>
-{
+impl<OffsetSize: OffsetSizeTrait> From<Vec<Option<&[u8]>>> for GenericBinaryArray<OffsetSize> {
     fn from(v: Vec<Option<&[u8]>>) -> Self {
         Self::from_opt_vec(v)
     }
@@ -322,59 +118,23 @@ impl<T: OffsetSizeTrait> From<GenericListArray<T>> for GenericBinaryArray<T> {
     }
 }
 
-impl<Ptr, OffsetSize: OffsetSizeTrait> FromIterator<Option<Ptr>>
+impl<OffsetSize: OffsetSizeTrait> From<GenericStringArray<OffsetSize>>
     for GenericBinaryArray<OffsetSize>
-where
-    Ptr: AsRef<[u8]>,
 {
-    fn from_iter<I: IntoIterator<Item = Option<Ptr>>>(iter: I) -> Self {
-        let iter = iter.into_iter();
-        let (_, data_len) = iter.size_hint();
-        let data_len = data_len.expect("Iterator must be sized"); // panic if no upper bound.
-
-        let mut offsets = Vec::with_capacity(data_len + 1);
-        let mut values = Vec::new();
-        let mut null_buf = MutableBuffer::new_null(data_len);
-        let mut length_so_far: OffsetSize = OffsetSize::zero();
-        offsets.push(length_so_far);
-
-        {
-            let null_slice = null_buf.as_slice_mut();
-
-            for (i, s) in iter.enumerate() {
-                if let Some(s) = s {
-                    let s = s.as_ref();
-                    bit_util::set_bit(null_slice, i);
-                    length_so_far += OffsetSize::from_usize(s.len()).unwrap();
-                    values.extend_from_slice(s);
-                }
-                // always add an element in offsets
-                offsets.push(length_so_far);
-            }
-        }
+    fn from(value: GenericStringArray<OffsetSize>) -> Self {
+        let builder = value
+            .into_data()
+            .into_builder()
+            .data_type(GenericBinaryType::<OffsetSize>::DATA_TYPE);
 
-        // calculate actual data_len, which may be different from the iterator's upper bound
-        let data_len = offsets.len() - 1;
-        let array_data = ArrayData::builder(Self::DATA_TYPE)
-            .len(data_len)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
-            .add_buffer(Buffer::from_slice_ref(&values))
-            .null_bit_buffer(Some(null_buf.into()));
-        let array_data = unsafe { array_data.build_unchecked() };
-        Self::from(array_data)
+        // Safety:
+        // A StringArray is a valid BinaryArray
+        Self::from(unsafe { builder.build_unchecked() })
     }
 }
 
-impl<'a, T: OffsetSizeTrait> IntoIterator for &'a GenericBinaryArray<T> {
-    type Item = Option<&'a [u8]>;
-    type IntoIter = GenericBinaryIter<'a, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        GenericBinaryIter::<'a, T>::new(self)
-    }
-}
-
-/// An array where each element contains 0 or more bytes.
+/// A [`GenericBinaryArray`] of `[u8]` using `i32` offsets
+///
 /// The byte length of each element is represented by an i32.
 ///
 /// # Examples
@@ -382,7 +142,7 @@ impl<'a, T: OffsetSizeTrait> IntoIterator for &'a GenericBinaryArray<T> {
 /// Create a BinaryArray from a vector of byte slices.
 ///
 /// ```
-/// use arrow::array::{Array, BinaryArray};
+/// use arrow_array::{Array, BinaryArray};
 /// let values: Vec<&[u8]> =
 ///     vec![b"one", b"two", b"", b"three"];
 /// let array = BinaryArray::from_vec(values);
@@ -396,7 +156,7 @@ impl<'a, T: OffsetSizeTrait> IntoIterator for &'a GenericBinaryArray<T> {
 /// Create a BinaryArray from a vector of Optional (null) byte slices.
 ///
 /// ```
-/// use arrow::array::{Array, BinaryArray};
+/// use arrow_array::{Array, BinaryArray};
 /// let values: Vec<Option<&[u8]>> =
 ///     vec![Some(b"one"), Some(b"two"), None, Some(b""), Some(b"three")];
 /// let array = BinaryArray::from_opt_vec(values);
@@ -412,17 +172,17 @@ impl<'a, T: OffsetSizeTrait> IntoIterator for &'a GenericBinaryArray<T> {
 /// assert!(!array.is_null(4));
 /// ```
 ///
+/// See [`GenericByteArray`] for more information and examples
 pub type BinaryArray = GenericBinaryArray<i32>;
 
-/// An array where each element contains 0 or more bytes.
-/// The byte length of each element is represented by an i64.
+/// A [`GenericBinaryArray`] of `[u8]` using `i64` offsets
 ///
 /// # Examples
 ///
 /// Create a LargeBinaryArray from a vector of byte slices.
 ///
 /// ```
-/// use arrow::array::{Array, LargeBinaryArray};
+/// use arrow_array::{Array, LargeBinaryArray};
 /// let values: Vec<&[u8]> =
 ///     vec![b"one", b"two", b"", b"three"];
 /// let array = LargeBinaryArray::from_vec(values);
@@ -436,7 +196,7 @@ pub type BinaryArray = GenericBinaryArray<i32>;
 /// Create a LargeBinaryArray from a vector of Optional (null) byte slices.
 ///
 /// ```
-/// use arrow::array::{Array, LargeBinaryArray};
+/// use arrow_array::{Array, LargeBinaryArray};
 /// let values: Vec<Option<&[u8]>> =
 ///     vec![Some(b"one"), Some(b"two"), None, Some(b""), Some(b"three")];
 /// let array = LargeBinaryArray::from_opt_vec(values);
@@ -452,12 +212,16 @@ pub type BinaryArray = GenericBinaryArray<i32>;
 /// assert!(!array.is_null(4));
 /// ```
 ///
+/// See [`GenericByteArray`] for more information and examples
 pub type LargeBinaryArray = GenericBinaryArray<i64>;
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{array::ListArray, datatypes::Field};
+    use crate::{ListArray, StringArray};
+    use arrow_buffer::Buffer;
+    use arrow_schema::Field;
+    use std::sync::Arc;
 
     #[test]
     fn test_binary_array() {
@@ -469,8 +233,8 @@ mod tests {
         // Array data: ["hello", "", "parquet"]
         let array_data = ArrayData::builder(DataType::Binary)
             .len(3)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
-            .add_buffer(Buffer::from_slice_ref(&values))
+            .add_buffer(Buffer::from_slice_ref(offsets))
+            .add_buffer(Buffer::from_slice_ref(values))
             .build()
             .unwrap();
         let binary_array = BinaryArray::from(array_data);
@@ -508,8 +272,8 @@ mod tests {
         let array_data = ArrayData::builder(DataType::Binary)
             .len(2)
             .offset(1)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
-            .add_buffer(Buffer::from_slice_ref(&values))
+            .add_buffer(Buffer::from_slice_ref(offsets))
+            .add_buffer(Buffer::from_slice_ref(values))
             .build()
             .unwrap();
         let binary_array = BinaryArray::from(array_data);
@@ -533,8 +297,8 @@ mod tests {
         // Array data: ["hello", "", "parquet"]
         let array_data = ArrayData::builder(DataType::LargeBinary)
             .len(3)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
-            .add_buffer(Buffer::from_slice_ref(&values))
+            .add_buffer(Buffer::from_slice_ref(offsets))
+            .add_buffer(Buffer::from_slice_ref(values))
             .build()
             .unwrap();
         let binary_array = LargeBinaryArray::from(array_data);
@@ -572,8 +336,8 @@ mod tests {
         let array_data = ArrayData::builder(DataType::LargeBinary)
             .len(2)
             .offset(1)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
-            .add_buffer(Buffer::from_slice_ref(&values))
+            .add_buffer(Buffer::from_slice_ref(offsets))
+            .add_buffer(Buffer::from_slice_ref(values))
             .build()
             .unwrap();
         let binary_array = LargeBinaryArray::from(array_data);
@@ -602,28 +366,27 @@ mod tests {
         // Array data: ["hello", "", "parquet"]
         let array_data1 = ArrayData::builder(GenericBinaryArray::<O>::DATA_TYPE)
             .len(3)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
-            .add_buffer(Buffer::from_slice_ref(&values))
+            .add_buffer(Buffer::from_slice_ref(offsets))
+            .add_buffer(Buffer::from_slice_ref(values))
             .build()
             .unwrap();
         let binary_array1 = GenericBinaryArray::<O>::from(array_data1);
 
-        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Box::new(
-            Field::new("item", DataType::UInt8, false),
-        ));
+        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Arc::new(Field::new(
+            "item",
+            DataType::UInt8,
+            false,
+        )));
 
         let array_data2 = ArrayData::builder(data_type)
             .len(3)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
+            .add_buffer(Buffer::from_slice_ref(offsets))
             .add_child_data(child_data)
             .build()
             .unwrap();
         let list_array = GenericListArray::<O>::from(array_data2);
         let binary_array2 = GenericBinaryArray::<O>::from(list_array);
 
-        assert_eq!(2, binary_array2.data().buffers().len());
-        assert_eq!(0, binary_array2.data().child_data().len());
-
         assert_eq!(binary_array1.len(), binary_array2.len());
         assert_eq!(binary_array1.null_count(), binary_array2.null_count());
         assert_eq!(binary_array1.value_offsets(), binary_array2.value_offsets());
@@ -657,16 +420,18 @@ mod tests {
             .unwrap();
 
         let offsets = [0, 5, 8, 15].map(|n| O::from_usize(n).unwrap());
-        let null_buffer = Buffer::from_slice_ref(&[0b101]);
-        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Box::new(
-            Field::new("item", DataType::UInt8, false),
-        ));
+        let null_buffer = Buffer::from_slice_ref([0b101]);
+        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Arc::new(Field::new(
+            "item",
+            DataType::UInt8,
+            false,
+        )));
 
         // [None, Some(b"Parquet")]
         let array_data = ArrayData::builder(data_type)
             .len(2)
             .offset(1)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
+            .add_buffer(Buffer::from_slice_ref(offsets))
             .null_bit_buffer(Some(null_buffer))
             .add_child_data(child_data)
             .build()
@@ -691,26 +456,26 @@ mod tests {
         _test_generic_binary_array_from_list_array_with_offset::<i64>();
     }
 
-    fn _test_generic_binary_array_from_list_array_with_child_nulls_failed<
-        O: OffsetSizeTrait,
-    >() {
+    fn _test_generic_binary_array_from_list_array_with_child_nulls_failed<O: OffsetSizeTrait>() {
         let values = b"HelloArrow";
         let child_data = ArrayData::builder(DataType::UInt8)
             .len(10)
             .add_buffer(Buffer::from(&values[..]))
-            .null_bit_buffer(Some(Buffer::from_slice_ref(&[0b1010101010])))
+            .null_bit_buffer(Some(Buffer::from_slice_ref([0b1010101010])))
             .build()
             .unwrap();
 
         let offsets = [0, 5, 10].map(|n| O::from_usize(n).unwrap());
-        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Box::new(
-            Field::new("item", DataType::UInt8, false),
-        ));
+        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Arc::new(Field::new(
+            "item",
+            DataType::UInt8,
+            true,
+        )));
 
         // [None, Some(b"Parquet")]
         let array_data = ArrayData::builder(data_type)
             .len(2)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
+            .add_buffer(Buffer::from_slice_ref(offsets))
             .add_child_data(child_data)
             .build()
             .unwrap();
@@ -763,7 +528,7 @@ mod tests {
             .scan(0usize, |pos, i| {
                 if *pos < 10 {
                     *pos += 1;
-                    Some(Some(format!("value {}", i)))
+                    Some(Some(format!("value {i}")))
                 } else {
                     // actually returns up to 10 values
                     None
@@ -782,24 +547,21 @@ mod tests {
 
     #[test]
     #[should_panic(
-        expected = "assertion failed: `(left == right)`\n  left: `UInt32`,\n \
-                    right: `UInt8`: BinaryArray can only be created from List<u8> arrays, \
-                    mismatched data types."
+        expected = "BinaryArray can only be created from List<u8> arrays, mismatched data types."
     )]
     fn test_binary_array_from_incorrect_list_array() {
         let values: [u32; 12] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
         let values_data = ArrayData::builder(DataType::UInt32)
             .len(12)
-            .add_buffer(Buffer::from_slice_ref(&values))
+            .add_buffer(Buffer::from_slice_ref(values))
             .build()
             .unwrap();
         let offsets: [i32; 4] = [0, 5, 5, 12];
 
-        let data_type =
-            DataType::List(Box::new(Field::new("item", DataType::UInt32, false)));
+        let data_type = DataType::List(Arc::new(Field::new("item", DataType::UInt32, false)));
         let array_data = ArrayData::builder(data_type)
             .len(3)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
+            .add_buffer(Buffer::from_slice_ref(offsets))
             .add_child_data(values_data)
             .build()
             .unwrap();
@@ -808,27 +570,35 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "BinaryArray out of bounds access")]
+    #[should_panic(
+        expected = "Trying to access an element at index 4 from a BinaryArray of length 3"
+    )]
     fn test_binary_array_get_value_index_out_of_bound() {
-        let values: [u8; 12] =
-            [104, 101, 108, 108, 111, 112, 97, 114, 113, 117, 101, 116];
+        let values: [u8; 12] = [104, 101, 108, 108, 111, 112, 97, 114, 113, 117, 101, 116];
         let offsets: [i32; 4] = [0, 5, 5, 12];
         let array_data = ArrayData::builder(DataType::Binary)
             .len(3)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
-            .add_buffer(Buffer::from_slice_ref(&values))
+            .add_buffer(Buffer::from_slice_ref(offsets))
+            .add_buffer(Buffer::from_slice_ref(values))
             .build()
             .unwrap();
         let binary_array = BinaryArray::from(array_data);
         binary_array.value(4);
     }
 
+    #[test]
+    #[should_panic(expected = "LargeBinaryArray expects DataType::LargeBinary")]
+    fn test_binary_array_validation() {
+        let array = BinaryArray::from_iter_values([&[1, 2]]);
+        let _ = LargeBinaryArray::from(array.into_data());
+    }
+
     #[test]
     fn test_binary_array_all_null() {
         let data = vec![None];
         let array = BinaryArray::from(data);
         array
-            .data()
+            .into_data()
             .validate_full()
             .expect("All null array has valid array data");
     }
@@ -838,8 +608,36 @@ mod tests {
         let data = vec![None];
         let array = LargeBinaryArray::from(data);
         array
-            .data()
+            .into_data()
             .validate_full()
             .expect("All null array has valid array data");
     }
+
+    #[test]
+    fn test_empty_offsets() {
+        let string = BinaryArray::from(
+            ArrayData::builder(DataType::Binary)
+                .buffers(vec![Buffer::from(&[]), Buffer::from(&[])])
+                .build()
+                .unwrap(),
+        );
+        assert_eq!(string.value_offsets(), &[0]);
+        let string = LargeBinaryArray::from(
+            ArrayData::builder(DataType::LargeBinary)
+                .buffers(vec![Buffer::from(&[]), Buffer::from(&[])])
+                .build()
+                .unwrap(),
+        );
+        assert_eq!(string.len(), 0);
+        assert_eq!(string.value_offsets(), &[0]);
+    }
+
+    #[test]
+    fn test_to_from_string() {
+        let s = StringArray::from_iter_values(["a", "b", "c", "d"]);
+        let b = BinaryArray::from(s.clone());
+        let sa = StringArray::from(b); // Performs UTF-8 validation again
+
+        assert_eq!(s, sa);
+    }
 }
diff --git a/arrow-array/src/array/boolean_array.rs b/arrow-array/src/array/boolean_array.rs
new file mode 100644
index 000000000000..fe374d965714
--- /dev/null
+++ b/arrow-array/src/array/boolean_array.rs
@@ -0,0 +1,643 @@
+// 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.
+
+use crate::array::print_long_array;
+use crate::builder::BooleanBuilder;
+use crate::iterator::BooleanIter;
+use crate::{Array, ArrayAccessor, ArrayRef, Scalar};
+use arrow_buffer::{bit_util, BooleanBuffer, MutableBuffer, NullBuffer};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::DataType;
+use std::any::Any;
+use std::sync::Arc;
+
+/// An array of [boolean values](https://arrow.apache.org/docs/format/Columnar.html#fixed-size-primitive-layout)
+///
+/// # Example: From a Vec
+///
+/// ```
+/// # use arrow_array::{Array, BooleanArray};
+/// let arr: BooleanArray = vec![true, true, false].into();
+/// ```
+///
+/// # Example: From an optional Vec
+///
+/// ```
+/// # use arrow_array::{Array, BooleanArray};
+/// let arr: BooleanArray = vec![Some(true), None, Some(false)].into();
+/// ```
+///
+/// # Example: From an iterator
+///
+/// ```
+/// # use arrow_array::{Array, BooleanArray};
+/// let arr: BooleanArray = (0..5).map(|x| (x % 2 == 0).then(|| x % 3 == 0)).collect();
+/// let values: Vec<_> = arr.iter().collect();
+/// assert_eq!(&values, &[Some(true), None, Some(false), None, Some(false)])
+/// ```
+///
+/// # Example: Using Builder
+///
+/// ```
+/// # use arrow_array::Array;
+/// # use arrow_array::builder::BooleanBuilder;
+/// let mut builder = BooleanBuilder::new();
+/// builder.append_value(true);
+/// builder.append_null();
+/// builder.append_value(false);
+/// let array = builder.finish();
+/// let values: Vec<_> = array.iter().collect();
+/// assert_eq!(&values, &[Some(true), None, Some(false)])
+/// ```
+///
+#[derive(Clone)]
+pub struct BooleanArray {
+    values: BooleanBuffer,
+    nulls: Option<NullBuffer>,
+}
+
+impl std::fmt::Debug for BooleanArray {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "BooleanArray\n[\n")?;
+        print_long_array(self, f, |array, index, f| {
+            std::fmt::Debug::fmt(&array.value(index), f)
+        })?;
+        write!(f, "]")
+    }
+}
+
+impl BooleanArray {
+    /// Create a new [`BooleanArray`] from the provided values and nulls
+    ///
+    /// # Panics
+    ///
+    /// Panics if `values.len() != nulls.len()`
+    pub fn new(values: BooleanBuffer, nulls: Option<NullBuffer>) -> Self {
+        if let Some(n) = nulls.as_ref() {
+            assert_eq!(values.len(), n.len());
+        }
+        Self { values, nulls }
+    }
+
+    /// Create a new [`BooleanArray`] with length `len` consisting only of nulls
+    pub fn new_null(len: usize) -> Self {
+        Self {
+            values: BooleanBuffer::new_unset(len),
+            nulls: Some(NullBuffer::new_null(len)),
+        }
+    }
+
+    /// Create a new [`Scalar`] from `value`
+    pub fn new_scalar(value: bool) -> Scalar<Self> {
+        let values = match value {
+            true => BooleanBuffer::new_set(1),
+            false => BooleanBuffer::new_unset(1),
+        };
+        Scalar::new(Self::new(values, None))
+    }
+
+    /// Returns the length of this array.
+    pub fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    /// Returns whether this array is empty.
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, length: usize) -> Self {
+        Self {
+            values: self.values.slice(offset, length),
+            nulls: self.nulls.as_ref().map(|n| n.slice(offset, length)),
+        }
+    }
+
+    /// Returns a new boolean array builder
+    pub fn builder(capacity: usize) -> BooleanBuilder {
+        BooleanBuilder::with_capacity(capacity)
+    }
+
+    /// Returns the underlying [`BooleanBuffer`] holding all the values of this array
+    pub fn values(&self) -> &BooleanBuffer {
+        &self.values
+    }
+
+    /// Returns the number of non null, true values within this array
+    pub fn true_count(&self) -> usize {
+        match self.nulls() {
+            Some(nulls) => {
+                let null_chunks = nulls.inner().bit_chunks().iter_padded();
+                let value_chunks = self.values().bit_chunks().iter_padded();
+                null_chunks
+                    .zip(value_chunks)
+                    .map(|(a, b)| (a & b).count_ones() as usize)
+                    .sum()
+            }
+            None => self.values().count_set_bits(),
+        }
+    }
+
+    /// Returns the number of non null, false values within this array
+    pub fn false_count(&self) -> usize {
+        self.len() - self.null_count() - self.true_count()
+    }
+
+    /// Returns the boolean value at index `i`.
+    ///
+    /// # Safety
+    /// This doesn't check bounds, the caller must ensure that index < self.len()
+    pub unsafe fn value_unchecked(&self, i: usize) -> bool {
+        self.values.value_unchecked(i)
+    }
+
+    /// Returns the boolean value at index `i`.
+    /// # Panics
+    /// Panics if index `i` is out of bounds
+    pub fn value(&self, i: usize) -> bool {
+        assert!(
+            i < self.len(),
+            "Trying to access an element at index {} from a BooleanArray of length {}",
+            i,
+            self.len()
+        );
+        // Safety:
+        // `i < self.len()
+        unsafe { self.value_unchecked(i) }
+    }
+
+    /// Returns an iterator that returns the values of `array.value(i)` for an iterator with each element `i`
+    pub fn take_iter<'a>(
+        &'a self,
+        indexes: impl Iterator<Item = Option<usize>> + 'a,
+    ) -> impl Iterator<Item = Option<bool>> + 'a {
+        indexes.map(|opt_index| opt_index.map(|index| self.value(index)))
+    }
+
+    /// Returns an iterator that returns the values of `array.value(i)` for an iterator with each element `i`
+    /// # Safety
+    ///
+    /// caller must ensure that the offsets in the iterator are less than the array len()
+    pub unsafe fn take_iter_unchecked<'a>(
+        &'a self,
+        indexes: impl Iterator<Item = Option<usize>> + 'a,
+    ) -> impl Iterator<Item = Option<bool>> + 'a {
+        indexes.map(|opt_index| opt_index.map(|index| self.value_unchecked(index)))
+    }
+
+    /// Create a [`BooleanArray`] by evaluating the operation for
+    /// each element of the provided array
+    ///
+    /// ```
+    /// # use arrow_array::{BooleanArray, Int32Array};
+    ///
+    /// let array = Int32Array::from(vec![1, 2, 3, 4, 5]);
+    /// let r = BooleanArray::from_unary(&array, |x| x > 2);
+    /// assert_eq!(&r, &BooleanArray::from(vec![false, false, true, true, true]));
+    /// ```
+    pub fn from_unary<T: ArrayAccessor, F>(left: T, mut op: F) -> Self
+    where
+        F: FnMut(T::Item) -> bool,
+    {
+        let nulls = left.logical_nulls();
+        let values = BooleanBuffer::collect_bool(left.len(), |i| unsafe {
+            // SAFETY: i in range 0..len
+            op(left.value_unchecked(i))
+        });
+        Self::new(values, nulls)
+    }
+
+    /// Create a [`BooleanArray`] by evaluating the binary operation for
+    /// each element of the provided arrays
+    ///
+    /// ```
+    /// # use arrow_array::{BooleanArray, Int32Array};
+    ///
+    /// let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+    /// let b = Int32Array::from(vec![1, 2, 0, 2, 5]);
+    /// let r = BooleanArray::from_binary(&a, &b, |a, b| a == b);
+    /// assert_eq!(&r, &BooleanArray::from(vec![true, true, false, false, true]));
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// This function panics if left and right are not the same length
+    ///
+    pub fn from_binary<T: ArrayAccessor, S: ArrayAccessor, F>(left: T, right: S, mut op: F) -> Self
+    where
+        F: FnMut(T::Item, S::Item) -> bool,
+    {
+        assert_eq!(left.len(), right.len());
+
+        let nulls = NullBuffer::union(
+            left.logical_nulls().as_ref(),
+            right.logical_nulls().as_ref(),
+        );
+        let values = BooleanBuffer::collect_bool(left.len(), |i| unsafe {
+            // SAFETY: i in range 0..len
+            op(left.value_unchecked(i), right.value_unchecked(i))
+        });
+        Self::new(values, nulls)
+    }
+
+    /// Deconstruct this array into its constituent parts
+    pub fn into_parts(self) -> (BooleanBuffer, Option<NullBuffer>) {
+        (self.values, self.nulls)
+    }
+}
+
+impl Array for BooleanArray {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.into()
+    }
+
+    fn data_type(&self) -> &DataType {
+        &DataType::Boolean
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
+    fn offset(&self) -> usize {
+        self.values.offset()
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.nulls.as_ref()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        let mut sum = self.values.inner().capacity();
+        if let Some(x) = &self.nulls {
+            sum += x.buffer().capacity()
+        }
+        sum
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        std::mem::size_of::<Self>() + self.get_buffer_memory_size()
+    }
+}
+
+impl<'a> ArrayAccessor for &'a BooleanArray {
+    type Item = bool;
+
+    fn value(&self, index: usize) -> Self::Item {
+        BooleanArray::value(self, index)
+    }
+
+    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
+        BooleanArray::value_unchecked(self, index)
+    }
+}
+
+impl From<Vec<bool>> for BooleanArray {
+    fn from(data: Vec<bool>) -> Self {
+        let mut mut_buf = MutableBuffer::new_null(data.len());
+        {
+            let mut_slice = mut_buf.as_slice_mut();
+            for (i, b) in data.iter().enumerate() {
+                if *b {
+                    bit_util::set_bit(mut_slice, i);
+                }
+            }
+        }
+        let array_data = ArrayData::builder(DataType::Boolean)
+            .len(data.len())
+            .add_buffer(mut_buf.into());
+
+        let array_data = unsafe { array_data.build_unchecked() };
+        BooleanArray::from(array_data)
+    }
+}
+
+impl From<Vec<Option<bool>>> for BooleanArray {
+    fn from(data: Vec<Option<bool>>) -> Self {
+        data.iter().collect()
+    }
+}
+
+impl From<ArrayData> for BooleanArray {
+    fn from(data: ArrayData) -> Self {
+        assert_eq!(
+            data.data_type(),
+            &DataType::Boolean,
+            "BooleanArray expected ArrayData with type {} got {}",
+            DataType::Boolean,
+            data.data_type()
+        );
+        assert_eq!(
+            data.buffers().len(),
+            1,
+            "BooleanArray data should contain a single buffer only (values buffer)"
+        );
+        let values = BooleanBuffer::new(data.buffers()[0].clone(), data.offset(), data.len());
+
+        Self {
+            values,
+            nulls: data.nulls().cloned(),
+        }
+    }
+}
+
+impl From<BooleanArray> for ArrayData {
+    fn from(array: BooleanArray) -> Self {
+        let builder = ArrayDataBuilder::new(DataType::Boolean)
+            .len(array.values.len())
+            .offset(array.values.offset())
+            .nulls(array.nulls)
+            .buffers(vec![array.values.into_inner()]);
+
+        unsafe { builder.build_unchecked() }
+    }
+}
+
+impl<'a> IntoIterator for &'a BooleanArray {
+    type Item = Option<bool>;
+    type IntoIter = BooleanIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        BooleanIter::<'a>::new(self)
+    }
+}
+
+impl<'a> BooleanArray {
+    /// constructs a new iterator
+    pub fn iter(&'a self) -> BooleanIter<'a> {
+        BooleanIter::<'a>::new(self)
+    }
+}
+
+impl<Ptr: std::borrow::Borrow<Option<bool>>> FromIterator<Ptr> for BooleanArray {
+    fn from_iter<I: IntoIterator<Item = Ptr>>(iter: I) -> Self {
+        let iter = iter.into_iter();
+        let (_, data_len) = iter.size_hint();
+        let data_len = data_len.expect("Iterator must be sized"); // panic if no upper bound.
+
+        let num_bytes = bit_util::ceil(data_len, 8);
+        let mut null_builder = MutableBuffer::from_len_zeroed(num_bytes);
+        let mut val_builder = MutableBuffer::from_len_zeroed(num_bytes);
+
+        let data = val_builder.as_slice_mut();
+
+        let null_slice = null_builder.as_slice_mut();
+        iter.enumerate().for_each(|(i, item)| {
+            if let Some(a) = item.borrow() {
+                bit_util::set_bit(null_slice, i);
+                if *a {
+                    bit_util::set_bit(data, i);
+                }
+            }
+        });
+
+        let data = unsafe {
+            ArrayData::new_unchecked(
+                DataType::Boolean,
+                data_len,
+                None,
+                Some(null_builder.into()),
+                0,
+                vec![val_builder.into()],
+                vec![],
+            )
+        };
+        BooleanArray::from(data)
+    }
+}
+
+impl From<BooleanBuffer> for BooleanArray {
+    fn from(values: BooleanBuffer) -> Self {
+        Self {
+            values,
+            nulls: None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_buffer::Buffer;
+    use rand::{thread_rng, Rng};
+
+    #[test]
+    fn test_boolean_fmt_debug() {
+        let arr = BooleanArray::from(vec![true, false, false]);
+        assert_eq!(
+            "BooleanArray\n[\n  true,\n  false,\n  false,\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    fn test_boolean_with_null_fmt_debug() {
+        let mut builder = BooleanArray::builder(3);
+        builder.append_value(true);
+        builder.append_null();
+        builder.append_value(false);
+        let arr = builder.finish();
+        assert_eq!(
+            "BooleanArray\n[\n  true,\n  null,\n  false,\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    fn test_boolean_array_from_vec() {
+        let buf = Buffer::from([10_u8]);
+        let arr = BooleanArray::from(vec![false, true, false, true]);
+        assert_eq!(&buf, arr.values().inner());
+        assert_eq!(4, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(0, arr.null_count());
+        for i in 0..4 {
+            assert!(!arr.is_null(i));
+            assert!(arr.is_valid(i));
+            assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {i}")
+        }
+    }
+
+    #[test]
+    fn test_boolean_array_from_vec_option() {
+        let buf = Buffer::from([10_u8]);
+        let arr = BooleanArray::from(vec![Some(false), Some(true), None, Some(true)]);
+        assert_eq!(&buf, arr.values().inner());
+        assert_eq!(4, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(1, arr.null_count());
+        for i in 0..4 {
+            if i == 2 {
+                assert!(arr.is_null(i));
+                assert!(!arr.is_valid(i));
+            } else {
+                assert!(!arr.is_null(i));
+                assert!(arr.is_valid(i));
+                assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {i}")
+            }
+        }
+    }
+
+    #[test]
+    fn test_boolean_array_from_iter() {
+        let v = vec![Some(false), Some(true), Some(false), Some(true)];
+        let arr = v.into_iter().collect::<BooleanArray>();
+        assert_eq!(4, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(0, arr.null_count());
+        assert!(arr.nulls().is_none());
+        for i in 0..3 {
+            assert!(!arr.is_null(i));
+            assert!(arr.is_valid(i));
+            assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {i}")
+        }
+    }
+
+    #[test]
+    fn test_boolean_array_from_nullable_iter() {
+        let v = vec![Some(true), None, Some(false), None];
+        let arr = v.into_iter().collect::<BooleanArray>();
+        assert_eq!(4, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(2, arr.null_count());
+        assert!(arr.nulls().is_some());
+
+        assert!(arr.is_valid(0));
+        assert!(arr.is_null(1));
+        assert!(arr.is_valid(2));
+        assert!(arr.is_null(3));
+
+        assert!(arr.value(0));
+        assert!(!arr.value(2));
+    }
+
+    #[test]
+    fn test_boolean_array_builder() {
+        // Test building a boolean array with ArrayData builder and offset
+        // 000011011
+        let buf = Buffer::from([27_u8]);
+        let buf2 = buf.clone();
+        let data = ArrayData::builder(DataType::Boolean)
+            .len(5)
+            .offset(2)
+            .add_buffer(buf)
+            .build()
+            .unwrap();
+        let arr = BooleanArray::from(data);
+        assert_eq!(&buf2, arr.values().inner());
+        assert_eq!(5, arr.len());
+        assert_eq!(2, arr.offset());
+        assert_eq!(0, arr.null_count());
+        for i in 0..3 {
+            assert_eq!(i != 0, arr.value(i), "failed at {i}");
+        }
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Trying to access an element at index 4 from a BooleanArray of length 3"
+    )]
+    fn test_fixed_size_binary_array_get_value_index_out_of_bound() {
+        let v = vec![Some(true), None, Some(false)];
+        let array = v.into_iter().collect::<BooleanArray>();
+
+        array.value(4);
+    }
+
+    #[test]
+    #[should_panic(expected = "BooleanArray data should contain a single buffer only \
+                               (values buffer)")]
+    // Different error messages, so skip for now
+    // https://github.com/apache/arrow-rs/issues/1545
+    #[cfg(not(feature = "force_validate"))]
+    fn test_boolean_array_invalid_buffer_len() {
+        let data = unsafe {
+            ArrayData::builder(DataType::Boolean)
+                .len(5)
+                .build_unchecked()
+        };
+        drop(BooleanArray::from(data));
+    }
+
+    #[test]
+    #[should_panic(expected = "BooleanArray expected ArrayData with type Boolean got Int32")]
+    fn test_from_array_data_validation() {
+        let _ = BooleanArray::from(ArrayData::new_empty(&DataType::Int32));
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Takes too long
+    fn test_true_false_count() {
+        let mut rng = thread_rng();
+
+        for _ in 0..10 {
+            // No nulls
+            let d: Vec<_> = (0..2000).map(|_| rng.gen_bool(0.5)).collect();
+            let b = BooleanArray::from(d.clone());
+
+            let expected_true = d.iter().filter(|x| **x).count();
+            assert_eq!(b.true_count(), expected_true);
+            assert_eq!(b.false_count(), d.len() - expected_true);
+
+            // With nulls
+            let d: Vec<_> = (0..2000)
+                .map(|_| rng.gen_bool(0.5).then(|| rng.gen_bool(0.5)))
+                .collect();
+            let b = BooleanArray::from(d.clone());
+
+            let expected_true = d.iter().filter(|x| matches!(x, Some(true))).count();
+            assert_eq!(b.true_count(), expected_true);
+
+            let expected_false = d.iter().filter(|x| matches!(x, Some(false))).count();
+            assert_eq!(b.false_count(), expected_false);
+        }
+    }
+
+    #[test]
+    fn test_into_parts() {
+        let boolean_array = [Some(true), None, Some(false)]
+            .into_iter()
+            .collect::<BooleanArray>();
+        let (values, nulls) = boolean_array.into_parts();
+        assert_eq!(values.values(), &[0b0000_0001]);
+        assert!(nulls.is_some());
+        assert_eq!(nulls.unwrap().buffer().as_slice(), &[0b0000_0101]);
+
+        let boolean_array =
+            BooleanArray::from(vec![false, false, false, false, false, false, false, true]);
+        let (values, nulls) = boolean_array.into_parts();
+        assert_eq!(values.values(), &[0b1000_0000]);
+        assert!(nulls.is_none());
+    }
+}
diff --git a/arrow-array/src/array/byte_array.rs b/arrow-array/src/array/byte_array.rs
new file mode 100644
index 000000000000..db825bbea97d
--- /dev/null
+++ b/arrow-array/src/array/byte_array.rs
@@ -0,0 +1,617 @@
+// 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.
+
+use crate::array::{get_offsets, print_long_array};
+use crate::builder::GenericByteBuilder;
+use crate::iterator::ArrayIter;
+use crate::types::bytes::ByteArrayNativeType;
+use crate::types::ByteArrayType;
+use crate::{Array, ArrayAccessor, ArrayRef, OffsetSizeTrait, Scalar};
+use arrow_buffer::{ArrowNativeType, Buffer, MutableBuffer};
+use arrow_buffer::{NullBuffer, OffsetBuffer};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType};
+use std::any::Any;
+use std::sync::Arc;
+
+/// An array of [variable length byte arrays](https://arrow.apache.org/docs/format/Columnar.html#variable-size-binary-layout)
+///
+/// See [`StringArray`] and [`LargeStringArray`] for storing utf8 encoded string data
+///
+/// See [`BinaryArray`] and [`LargeBinaryArray`] for storing arbitrary bytes
+///
+/// # Example: From a Vec
+///
+/// ```
+/// # use arrow_array::{Array, GenericByteArray, types::Utf8Type};
+/// let arr: GenericByteArray<Utf8Type> = vec!["hello", "world", ""].into();
+/// assert_eq!(arr.value_data(), b"helloworld");
+/// assert_eq!(arr.value_offsets(), &[0, 5, 10, 10]);
+/// let values: Vec<_> = arr.iter().collect();
+/// assert_eq!(values, &[Some("hello"), Some("world"), Some("")]);
+/// ```
+///
+/// # Example: From an optional Vec
+///
+/// ```
+/// # use arrow_array::{Array, GenericByteArray, types::Utf8Type};
+/// let arr: GenericByteArray<Utf8Type> = vec![Some("hello"), Some("world"), Some(""), None].into();
+/// assert_eq!(arr.value_data(), b"helloworld");
+/// assert_eq!(arr.value_offsets(), &[0, 5, 10, 10, 10]);
+/// let values: Vec<_> = arr.iter().collect();
+/// assert_eq!(values, &[Some("hello"), Some("world"), Some(""), None]);
+/// ```
+///
+/// # Example: From an iterator of option
+///
+/// ```
+/// # use arrow_array::{Array, GenericByteArray, types::Utf8Type};
+/// let arr: GenericByteArray<Utf8Type> = (0..5).map(|x| (x % 2 == 0).then(|| x.to_string())).collect();
+/// let values: Vec<_> = arr.iter().collect();
+/// assert_eq!(values, &[Some("0"), None, Some("2"), None, Some("4")]);
+/// ```
+///
+/// # Example: Using Builder
+///
+/// ```
+/// # use arrow_array::Array;
+/// # use arrow_array::builder::GenericByteBuilder;
+/// # use arrow_array::types::Utf8Type;
+/// let mut builder = GenericByteBuilder::<Utf8Type>::new();
+/// builder.append_value("hello");
+/// builder.append_null();
+/// builder.append_value("world");
+/// let array = builder.finish();
+/// let values: Vec<_> = array.iter().collect();
+/// assert_eq!(values, &[Some("hello"), None, Some("world")]);
+/// ```
+///
+/// [`StringArray`]: crate::StringArray
+/// [`LargeStringArray`]: crate::LargeStringArray
+/// [`BinaryArray`]: crate::BinaryArray
+/// [`LargeBinaryArray`]: crate::LargeBinaryArray
+pub struct GenericByteArray<T: ByteArrayType> {
+    data_type: DataType,
+    value_offsets: OffsetBuffer<T::Offset>,
+    value_data: Buffer,
+    nulls: Option<NullBuffer>,
+}
+
+impl<T: ByteArrayType> Clone for GenericByteArray<T> {
+    fn clone(&self) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            value_offsets: self.value_offsets.clone(),
+            value_data: self.value_data.clone(),
+            nulls: self.nulls.clone(),
+        }
+    }
+}
+
+impl<T: ByteArrayType> GenericByteArray<T> {
+    /// Data type of the array.
+    pub const DATA_TYPE: DataType = T::DATA_TYPE;
+
+    /// Create a new [`GenericByteArray`] from the provided parts, panicking on failure
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`GenericByteArray::try_new`] returns an error
+    pub fn new(
+        offsets: OffsetBuffer<T::Offset>,
+        values: Buffer,
+        nulls: Option<NullBuffer>,
+    ) -> Self {
+        Self::try_new(offsets, values, nulls).unwrap()
+    }
+
+    /// Create a new [`GenericByteArray`] from the provided parts, returning an error on failure
+    ///
+    /// # Errors
+    ///
+    /// * `offsets.len() - 1 != nulls.len()`
+    /// * Any consecutive pair of `offsets` does not denote a valid slice of `values`
+    pub fn try_new(
+        offsets: OffsetBuffer<T::Offset>,
+        values: Buffer,
+        nulls: Option<NullBuffer>,
+    ) -> Result<Self, ArrowError> {
+        let len = offsets.len() - 1;
+
+        // Verify that each pair of offsets is a valid slices of values
+        T::validate(&offsets, &values)?;
+
+        if let Some(n) = nulls.as_ref() {
+            if n.len() != len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Incorrect length of null buffer for {}{}Array, expected {len} got {}",
+                    T::Offset::PREFIX,
+                    T::PREFIX,
+                    n.len(),
+                )));
+            }
+        }
+
+        Ok(Self {
+            data_type: T::DATA_TYPE,
+            value_offsets: offsets,
+            value_data: values,
+            nulls,
+        })
+    }
+
+    /// Create a new [`GenericByteArray`] from the provided parts, without validation
+    ///
+    /// # Safety
+    ///
+    /// Safe if [`Self::try_new`] would not error
+    pub unsafe fn new_unchecked(
+        offsets: OffsetBuffer<T::Offset>,
+        values: Buffer,
+        nulls: Option<NullBuffer>,
+    ) -> Self {
+        Self {
+            data_type: T::DATA_TYPE,
+            value_offsets: offsets,
+            value_data: values,
+            nulls,
+        }
+    }
+
+    /// Create a new [`GenericByteArray`] of length `len` where all values are null
+    pub fn new_null(len: usize) -> Self {
+        Self {
+            data_type: T::DATA_TYPE,
+            value_offsets: OffsetBuffer::new_zeroed(len),
+            value_data: MutableBuffer::new(0).into(),
+            nulls: Some(NullBuffer::new_null(len)),
+        }
+    }
+
+    /// Create a new [`Scalar`] from `v`
+    pub fn new_scalar(value: impl AsRef<T::Native>) -> Scalar<Self> {
+        Scalar::new(Self::from_iter_values(std::iter::once(value)))
+    }
+
+    /// Creates a [`GenericByteArray`] based on an iterator of values without nulls
+    pub fn from_iter_values<Ptr, I>(iter: I) -> Self
+    where
+        Ptr: AsRef<T::Native>,
+        I: IntoIterator<Item = Ptr>,
+    {
+        let iter = iter.into_iter();
+        let (_, data_len) = iter.size_hint();
+        let data_len = data_len.expect("Iterator must be sized"); // panic if no upper bound.
+
+        let mut offsets = MutableBuffer::new((data_len + 1) * std::mem::size_of::<T::Offset>());
+        offsets.push(T::Offset::usize_as(0));
+
+        let mut values = MutableBuffer::new(0);
+        for s in iter {
+            let s: &[u8] = s.as_ref().as_ref();
+            values.extend_from_slice(s);
+            offsets.push(T::Offset::usize_as(values.len()));
+        }
+
+        T::Offset::from_usize(values.len()).expect("offset overflow");
+        let offsets = Buffer::from(offsets);
+
+        // Safety: valid by construction
+        let value_offsets = unsafe { OffsetBuffer::new_unchecked(offsets.into()) };
+
+        Self {
+            data_type: T::DATA_TYPE,
+            value_data: values.into(),
+            value_offsets,
+            nulls: None,
+        }
+    }
+
+    /// Deconstruct this array into its constituent parts
+    pub fn into_parts(self) -> (OffsetBuffer<T::Offset>, Buffer, Option<NullBuffer>) {
+        (self.value_offsets, self.value_data, self.nulls)
+    }
+
+    /// Returns the length for value at index `i`.
+    /// # Panics
+    /// Panics if index `i` is out of bounds.
+    #[inline]
+    pub fn value_length(&self, i: usize) -> T::Offset {
+        let offsets = self.value_offsets();
+        offsets[i + 1] - offsets[i]
+    }
+
+    /// Returns a reference to the offsets of this array
+    ///
+    /// Unlike [`Self::value_offsets`] this returns the [`OffsetBuffer`]
+    /// allowing for zero-copy cloning
+    #[inline]
+    pub fn offsets(&self) -> &OffsetBuffer<T::Offset> {
+        &self.value_offsets
+    }
+
+    /// Returns the values of this array
+    ///
+    /// Unlike [`Self::value_data`] this returns the [`Buffer`]
+    /// allowing for zero-copy cloning
+    #[inline]
+    pub fn values(&self) -> &Buffer {
+        &self.value_data
+    }
+
+    /// Returns the raw value data
+    pub fn value_data(&self) -> &[u8] {
+        self.value_data.as_slice()
+    }
+
+    /// Returns true if all data within this array is ASCII
+    pub fn is_ascii(&self) -> bool {
+        let offsets = self.value_offsets();
+        let start = offsets.first().unwrap();
+        let end = offsets.last().unwrap();
+        self.value_data()[start.as_usize()..end.as_usize()].is_ascii()
+    }
+
+    /// Returns the offset values in the offsets buffer
+    #[inline]
+    pub fn value_offsets(&self) -> &[T::Offset] {
+        &self.value_offsets
+    }
+
+    /// Returns the element at index `i`
+    /// # Safety
+    /// Caller is responsible for ensuring that the index is within the bounds of the array
+    pub unsafe fn value_unchecked(&self, i: usize) -> &T::Native {
+        let end = *self.value_offsets().get_unchecked(i + 1);
+        let start = *self.value_offsets().get_unchecked(i);
+
+        // Soundness
+        // pointer alignment & location is ensured by RawPtrBox
+        // buffer bounds/offset is ensured by the value_offset invariants
+
+        // Safety of `to_isize().unwrap()`
+        // `start` and `end` are &OffsetSize, which is a generic type that implements the
+        // OffsetSizeTrait. Currently, only i32 and i64 implement OffsetSizeTrait,
+        // both of which should cleanly cast to isize on an architecture that supports
+        // 32/64-bit offsets
+        let b = std::slice::from_raw_parts(
+            self.value_data.as_ptr().offset(start.to_isize().unwrap()),
+            (end - start).to_usize().unwrap(),
+        );
+
+        // SAFETY:
+        // ArrayData is valid
+        T::Native::from_bytes_unchecked(b)
+    }
+
+    /// Returns the element at index `i`
+    /// # Panics
+    /// Panics if index `i` is out of bounds.
+    pub fn value(&self, i: usize) -> &T::Native {
+        assert!(
+            i < self.len(),
+            "Trying to access an element at index {} from a {}{}Array of length {}",
+            i,
+            T::Offset::PREFIX,
+            T::PREFIX,
+            self.len()
+        );
+        // SAFETY:
+        // Verified length above
+        unsafe { self.value_unchecked(i) }
+    }
+
+    /// constructs a new iterator
+    pub fn iter(&self) -> ArrayIter<&Self> {
+        ArrayIter::new(self)
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, length: usize) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            value_offsets: self.value_offsets.slice(offset, length),
+            value_data: self.value_data.clone(),
+            nulls: self.nulls.as_ref().map(|n| n.slice(offset, length)),
+        }
+    }
+
+    /// Returns `GenericByteBuilder` of this byte array for mutating its values if the underlying
+    /// offset and data buffers are not shared by others.
+    pub fn into_builder(self) -> Result<GenericByteBuilder<T>, Self> {
+        let len = self.len();
+        let value_len = T::Offset::as_usize(self.value_offsets()[len] - self.value_offsets()[0]);
+
+        let data = self.into_data();
+        let null_bit_buffer = data.nulls().map(|b| b.inner().sliced());
+
+        let element_len = std::mem::size_of::<T::Offset>();
+        let offset_buffer = data.buffers()[0]
+            .slice_with_length(data.offset() * element_len, (len + 1) * element_len);
+
+        let element_len = std::mem::size_of::<u8>();
+        let value_buffer = data.buffers()[1]
+            .slice_with_length(data.offset() * element_len, value_len * element_len);
+
+        drop(data);
+
+        let try_mutable_null_buffer = match null_bit_buffer {
+            None => Ok(None),
+            Some(null_buffer) => {
+                // Null buffer exists, tries to make it mutable
+                null_buffer.into_mutable().map(Some)
+            }
+        };
+
+        let try_mutable_buffers = match try_mutable_null_buffer {
+            Ok(mutable_null_buffer) => {
+                // Got mutable null buffer, tries to get mutable value buffer
+                let try_mutable_offset_buffer = offset_buffer.into_mutable();
+                let try_mutable_value_buffer = value_buffer.into_mutable();
+
+                // try_mutable_offset_buffer.map(...).map_err(...) doesn't work as the compiler complains
+                // mutable_null_buffer is moved into map closure.
+                match (try_mutable_offset_buffer, try_mutable_value_buffer) {
+                    (Ok(mutable_offset_buffer), Ok(mutable_value_buffer)) => unsafe {
+                        Ok(GenericByteBuilder::<T>::new_from_buffer(
+                            mutable_offset_buffer,
+                            mutable_value_buffer,
+                            mutable_null_buffer,
+                        ))
+                    },
+                    (Ok(mutable_offset_buffer), Err(value_buffer)) => Err((
+                        mutable_offset_buffer.into(),
+                        value_buffer,
+                        mutable_null_buffer.map(|b| b.into()),
+                    )),
+                    (Err(offset_buffer), Ok(mutable_value_buffer)) => Err((
+                        offset_buffer,
+                        mutable_value_buffer.into(),
+                        mutable_null_buffer.map(|b| b.into()),
+                    )),
+                    (Err(offset_buffer), Err(value_buffer)) => Err((
+                        offset_buffer,
+                        value_buffer,
+                        mutable_null_buffer.map(|b| b.into()),
+                    )),
+                }
+            }
+            Err(mutable_null_buffer) => {
+                // Unable to get mutable null buffer
+                Err((offset_buffer, value_buffer, Some(mutable_null_buffer)))
+            }
+        };
+
+        match try_mutable_buffers {
+            Ok(builder) => Ok(builder),
+            Err((offset_buffer, value_buffer, null_bit_buffer)) => {
+                let builder = ArrayData::builder(T::DATA_TYPE)
+                    .len(len)
+                    .add_buffer(offset_buffer)
+                    .add_buffer(value_buffer)
+                    .null_bit_buffer(null_bit_buffer);
+
+                let array_data = unsafe { builder.build_unchecked() };
+                let array = GenericByteArray::<T>::from(array_data);
+
+                Err(array)
+            }
+        }
+    }
+}
+
+impl<T: ByteArrayType> std::fmt::Debug for GenericByteArray<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{}{}Array\n[\n", T::Offset::PREFIX, T::PREFIX)?;
+        print_long_array(self, f, |array, index, f| {
+            std::fmt::Debug::fmt(&array.value(index), f)
+        })?;
+        write!(f, "]")
+    }
+}
+
+impl<T: ByteArrayType> Array for GenericByteArray<T> {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.into()
+    }
+
+    fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.value_offsets.len() - 1
+    }
+
+    fn is_empty(&self) -> bool {
+        self.value_offsets.len() <= 1
+    }
+
+    fn offset(&self) -> usize {
+        0
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.nulls.as_ref()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        let mut sum = self.value_offsets.inner().inner().capacity();
+        sum += self.value_data.capacity();
+        if let Some(x) = &self.nulls {
+            sum += x.buffer().capacity()
+        }
+        sum
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        std::mem::size_of::<Self>() + self.get_buffer_memory_size()
+    }
+}
+
+impl<'a, T: ByteArrayType> ArrayAccessor for &'a GenericByteArray<T> {
+    type Item = &'a T::Native;
+
+    fn value(&self, index: usize) -> Self::Item {
+        GenericByteArray::value(self, index)
+    }
+
+    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
+        GenericByteArray::value_unchecked(self, index)
+    }
+}
+
+impl<T: ByteArrayType> From<ArrayData> for GenericByteArray<T> {
+    fn from(data: ArrayData) -> Self {
+        assert_eq!(
+            data.data_type(),
+            &Self::DATA_TYPE,
+            "{}{}Array expects DataType::{}",
+            T::Offset::PREFIX,
+            T::PREFIX,
+            Self::DATA_TYPE
+        );
+        assert_eq!(
+            data.buffers().len(),
+            2,
+            "{}{}Array data should contain 2 buffers only (offsets and values)",
+            T::Offset::PREFIX,
+            T::PREFIX,
+        );
+        // SAFETY:
+        // ArrayData is valid, and verified type above
+        let value_offsets = unsafe { get_offsets(&data) };
+        let value_data = data.buffers()[1].clone();
+        Self {
+            value_offsets,
+            value_data,
+            data_type: data.data_type().clone(),
+            nulls: data.nulls().cloned(),
+        }
+    }
+}
+
+impl<T: ByteArrayType> From<GenericByteArray<T>> for ArrayData {
+    fn from(array: GenericByteArray<T>) -> Self {
+        let len = array.len();
+
+        let offsets = array.value_offsets.into_inner().into_inner();
+        let builder = ArrayDataBuilder::new(array.data_type)
+            .len(len)
+            .buffers(vec![offsets, array.value_data])
+            .nulls(array.nulls);
+
+        unsafe { builder.build_unchecked() }
+    }
+}
+
+impl<'a, T: ByteArrayType> IntoIterator for &'a GenericByteArray<T> {
+    type Item = Option<&'a T::Native>;
+    type IntoIter = ArrayIter<Self>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ArrayIter::new(self)
+    }
+}
+
+impl<'a, Ptr, T: ByteArrayType> FromIterator<&'a Option<Ptr>> for GenericByteArray<T>
+where
+    Ptr: AsRef<T::Native> + 'a,
+{
+    fn from_iter<I: IntoIterator<Item = &'a Option<Ptr>>>(iter: I) -> Self {
+        iter.into_iter()
+            .map(|o| o.as_ref().map(|p| p.as_ref()))
+            .collect()
+    }
+}
+
+impl<Ptr, T: ByteArrayType> FromIterator<Option<Ptr>> for GenericByteArray<T>
+where
+    Ptr: AsRef<T::Native>,
+{
+    fn from_iter<I: IntoIterator<Item = Option<Ptr>>>(iter: I) -> Self {
+        let iter = iter.into_iter();
+        let mut builder = GenericByteBuilder::with_capacity(iter.size_hint().0, 1024);
+        builder.extend(iter);
+        builder.finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{BinaryArray, StringArray};
+    use arrow_buffer::{Buffer, NullBuffer, OffsetBuffer};
+
+    #[test]
+    fn try_new() {
+        let data = Buffer::from_slice_ref("helloworld");
+        let offsets = OffsetBuffer::new(vec![0, 5, 10].into());
+        StringArray::new(offsets.clone(), data.clone(), None);
+
+        let nulls = NullBuffer::new_null(3);
+        let err =
+            StringArray::try_new(offsets.clone(), data.clone(), Some(nulls.clone())).unwrap_err();
+        assert_eq!(err.to_string(), "Invalid argument error: Incorrect length of null buffer for StringArray, expected 2 got 3");
+
+        let err = BinaryArray::try_new(offsets.clone(), data.clone(), Some(nulls)).unwrap_err();
+        assert_eq!(err.to_string(), "Invalid argument error: Incorrect length of null buffer for BinaryArray, expected 2 got 3");
+
+        let non_utf8_data = Buffer::from_slice_ref(b"he\xFFloworld");
+        let err = StringArray::try_new(offsets.clone(), non_utf8_data.clone(), None).unwrap_err();
+        assert_eq!(err.to_string(), "Invalid argument error: Encountered non UTF-8 data: invalid utf-8 sequence of 1 bytes from index 2");
+
+        BinaryArray::new(offsets, non_utf8_data, None);
+
+        let offsets = OffsetBuffer::new(vec![0, 5, 11].into());
+        let err = StringArray::try_new(offsets.clone(), data.clone(), None).unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Offset of 11 exceeds length of values 10"
+        );
+
+        let err = BinaryArray::try_new(offsets.clone(), data, None).unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Maximum offset of 11 is larger than values of length 10"
+        );
+
+        let non_ascii_data = Buffer::from_slice_ref("heìloworld");
+        StringArray::new(offsets.clone(), non_ascii_data.clone(), None);
+        BinaryArray::new(offsets, non_ascii_data.clone(), None);
+
+        let offsets = OffsetBuffer::new(vec![0, 3, 10].into());
+        let err = StringArray::try_new(offsets.clone(), non_ascii_data.clone(), None).unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Split UTF-8 codepoint at offset 3"
+        );
+
+        BinaryArray::new(offsets, non_ascii_data, None);
+    }
+}
diff --git a/arrow-array/src/array/dictionary_array.rs b/arrow-array/src/array/dictionary_array.rs
new file mode 100644
index 000000000000..1f4d83b1c5d0
--- /dev/null
+++ b/arrow-array/src/array/dictionary_array.rs
@@ -0,0 +1,1378 @@
+// 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.
+
+use crate::builder::{PrimitiveDictionaryBuilder, StringDictionaryBuilder};
+use crate::cast::AsArray;
+use crate::iterator::ArrayIter;
+use crate::types::*;
+use crate::{
+    make_array, Array, ArrayAccessor, ArrayRef, ArrowNativeTypeOp, ArrowPrimitiveType,
+    PrimitiveArray, StringArray,
+};
+use arrow_buffer::bit_util::set_bit;
+use arrow_buffer::buffer::NullBuffer;
+use arrow_buffer::{ArrowNativeType, BooleanBuffer, BooleanBufferBuilder};
+use arrow_data::ArrayData;
+use arrow_schema::{ArrowError, DataType};
+use std::any::Any;
+use std::sync::Arc;
+
+/// A [`DictionaryArray`] indexed by `i8`
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, Int8DictionaryArray, Int8Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: Int8DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.keys(), &Int8Array::from(vec![0, 0, 1, 2]));
+/// assert_eq!(array.values(), &values);
+/// ```
+///
+/// See [`DictionaryArray`] for more information and examples
+pub type Int8DictionaryArray = DictionaryArray<Int8Type>;
+
+/// A [`DictionaryArray`] indexed by `i16`
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, Int16DictionaryArray, Int16Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: Int16DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.keys(), &Int16Array::from(vec![0, 0, 1, 2]));
+/// assert_eq!(array.values(), &values);
+/// ```
+///
+/// See [`DictionaryArray`] for more information and examples
+pub type Int16DictionaryArray = DictionaryArray<Int16Type>;
+
+/// A [`DictionaryArray`] indexed by `i32`
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, Int32DictionaryArray, Int32Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: Int32DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.keys(), &Int32Array::from(vec![0, 0, 1, 2]));
+/// assert_eq!(array.values(), &values);
+/// ```
+///
+/// See [`DictionaryArray`] for more information and examples
+pub type Int32DictionaryArray = DictionaryArray<Int32Type>;
+
+/// A [`DictionaryArray`] indexed by `i64`
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, Int64DictionaryArray, Int64Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: Int64DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.keys(), &Int64Array::from(vec![0, 0, 1, 2]));
+/// assert_eq!(array.values(), &values);
+/// ```
+///
+/// See [`DictionaryArray`] for more information and examples
+pub type Int64DictionaryArray = DictionaryArray<Int64Type>;
+
+/// A [`DictionaryArray`] indexed by `u8`
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, UInt8DictionaryArray, UInt8Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: UInt8DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.keys(), &UInt8Array::from(vec![0, 0, 1, 2]));
+/// assert_eq!(array.values(), &values);
+/// ```
+///
+/// See [`DictionaryArray`] for more information and examples
+pub type UInt8DictionaryArray = DictionaryArray<UInt8Type>;
+
+/// A [`DictionaryArray`] indexed by `u16`
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, UInt16DictionaryArray, UInt16Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: UInt16DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.keys(), &UInt16Array::from(vec![0, 0, 1, 2]));
+/// assert_eq!(array.values(), &values);
+/// ```
+///
+/// See [`DictionaryArray`] for more information and examples
+pub type UInt16DictionaryArray = DictionaryArray<UInt16Type>;
+
+/// A [`DictionaryArray`] indexed by `u32`
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, UInt32DictionaryArray, UInt32Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: UInt32DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.keys(), &UInt32Array::from(vec![0, 0, 1, 2]));
+/// assert_eq!(array.values(), &values);
+/// ```
+///
+/// See [`DictionaryArray`] for more information and examples
+pub type UInt32DictionaryArray = DictionaryArray<UInt32Type>;
+
+/// A [`DictionaryArray`] indexed by `u64`
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, UInt64DictionaryArray, UInt64Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: UInt64DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.keys(), &UInt64Array::from(vec![0, 0, 1, 2]));
+/// assert_eq!(array.values(), &values);
+/// ```
+///
+/// See [`DictionaryArray`] for more information and examples
+pub type UInt64DictionaryArray = DictionaryArray<UInt64Type>;
+
+/// An array of [dictionary encoded values](https://arrow.apache.org/docs/format/Columnar.html#dictionary-encoded-layout)
+///
+/// This is mostly used to represent strings or a limited set of primitive types as integers,
+/// for example when doing NLP analysis or representing chromosomes by name.
+///
+/// [`DictionaryArray`] are represented using a `keys` array and a
+/// `values` array, which may be different lengths. The `keys` array
+/// stores indexes in the `values` array which holds
+/// the corresponding logical value, as shown here:
+///
+/// ```text
+/// ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+///   ┌─────────────────┐  ┌─────────┐ │     ┌─────────────────┐
+/// │ │        A        │  │    0    │       │        A        │     values[keys[0]]
+///   ├─────────────────┤  ├─────────┤ │     ├─────────────────┤
+/// │ │        D        │  │    2    │       │        B        │     values[keys[1]]
+///   ├─────────────────┤  ├─────────┤ │     ├─────────────────┤
+/// │ │        B        │  │    2    │       │        B        │     values[keys[2]]
+///   └─────────────────┘  ├─────────┤ │     ├─────────────────┤
+/// │                      │    1    │       │        D        │     values[keys[3]]
+///                        ├─────────┤ │     ├─────────────────┤
+/// │                      │    1    │       │        D        │     values[keys[4]]
+///                        ├─────────┤ │     ├─────────────────┤
+/// │                      │    0    │       │        A        │     values[keys[5]]
+///                        └─────────┘ │     └─────────────────┘
+/// │       values            keys
+///  ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
+///                                             Logical array
+///                                                Contents
+///           DictionaryArray
+///              length = 6
+/// ```
+///
+/// # Example: From Nullable Data
+///
+/// ```
+/// # use arrow_array::{DictionaryArray, Int8Array, types::Int8Type};
+/// let test = vec!["a", "a", "b", "c"];
+/// let array : DictionaryArray<Int8Type> = test.iter().map(|&x| if x == "b" {None} else {Some(x)}).collect();
+/// assert_eq!(array.keys(), &Int8Array::from(vec![Some(0), Some(0), None, Some(1)]));
+/// ```
+///
+/// # Example: From Non-Nullable Data
+///
+/// ```
+/// # use arrow_array::{DictionaryArray, Int8Array, types::Int8Type};
+/// let test = vec!["a", "a", "b", "c"];
+/// let array : DictionaryArray<Int8Type> = test.into_iter().collect();
+/// assert_eq!(array.keys(), &Int8Array::from(vec![0, 0, 1, 2]));
+/// ```
+///
+/// # Example: From Existing Arrays
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::{DictionaryArray, Int8Array, StringArray, types::Int8Type};
+/// // You can form your own DictionaryArray by providing the
+/// // values (dictionary) and keys (indexes into the dictionary):
+/// let values = StringArray::from_iter_values(["a", "b", "c"]);
+/// let keys = Int8Array::from_iter_values([0, 0, 1, 2]);
+/// let array = DictionaryArray::<Int8Type>::try_new(keys, Arc::new(values)).unwrap();
+/// let expected: DictionaryArray::<Int8Type> = vec!["a", "a", "b", "c"].into_iter().collect();
+/// assert_eq!(&array, &expected);
+/// ```
+///
+/// # Example: Using Builder
+///
+/// ```
+/// # use arrow_array::{Array, StringArray};
+/// # use arrow_array::builder::StringDictionaryBuilder;
+/// # use arrow_array::types::Int32Type;
+/// let mut builder = StringDictionaryBuilder::<Int32Type>::new();
+/// builder.append_value("a");
+/// builder.append_null();
+/// builder.append_value("a");
+/// builder.append_value("b");
+/// let array = builder.finish();
+///
+/// let values: Vec<_> = array.downcast_dict::<StringArray>().unwrap().into_iter().collect();
+/// assert_eq!(&values, &[Some("a"), None, Some("a"), Some("b")]);
+/// ```
+pub struct DictionaryArray<K: ArrowDictionaryKeyType> {
+    data_type: DataType,
+
+    /// The keys of this dictionary. These are constructed from the
+    /// buffer and null bitmap of `data`.  Also, note that these do
+    /// not correspond to the true values of this array. Rather, they
+    /// map to the real values.
+    keys: PrimitiveArray<K>,
+
+    /// Array of dictionary values (can by any DataType).
+    values: ArrayRef,
+
+    /// Values are ordered.
+    is_ordered: bool,
+}
+
+impl<K: ArrowDictionaryKeyType> Clone for DictionaryArray<K> {
+    fn clone(&self) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            keys: self.keys.clone(),
+            values: self.values.clone(),
+            is_ordered: self.is_ordered,
+        }
+    }
+}
+
+impl<K: ArrowDictionaryKeyType> DictionaryArray<K> {
+    /// Attempt to create a new DictionaryArray with a specified keys
+    /// (indexes into the dictionary) and values (dictionary)
+    /// array.
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`Self::try_new`] returns an error
+    pub fn new(keys: PrimitiveArray<K>, values: ArrayRef) -> Self {
+        Self::try_new(keys, values).unwrap()
+    }
+
+    /// Attempt to create a new DictionaryArray with a specified keys
+    /// (indexes into the dictionary) and values (dictionary)
+    /// array.
+    ///
+    /// # Errors
+    ///
+    /// Returns an error if any `keys[i] >= values.len() || keys[i] < 0`
+    pub fn try_new(keys: PrimitiveArray<K>, values: ArrayRef) -> Result<Self, ArrowError> {
+        let data_type = DataType::Dictionary(
+            Box::new(keys.data_type().clone()),
+            Box::new(values.data_type().clone()),
+        );
+
+        let zero = K::Native::usize_as(0);
+        let values_len = values.len();
+
+        if let Some((idx, v)) =
+            keys.values().iter().enumerate().find(|(idx, v)| {
+                (v.is_lt(zero) || v.as_usize() >= values_len) && keys.is_valid(*idx)
+            })
+        {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Invalid dictionary key {v:?} at index {idx}, expected 0 <= key < {values_len}",
+            )));
+        }
+
+        Ok(Self {
+            data_type,
+            keys,
+            values,
+            is_ordered: false,
+        })
+    }
+
+    /// Create a new [`DictionaryArray`] without performing validation
+    ///
+    /// # Safety
+    ///
+    /// Safe provided [`Self::try_new`] would not return an error
+    pub unsafe fn new_unchecked(keys: PrimitiveArray<K>, values: ArrayRef) -> Self {
+        let data_type = DataType::Dictionary(
+            Box::new(keys.data_type().clone()),
+            Box::new(values.data_type().clone()),
+        );
+
+        Self {
+            data_type,
+            keys,
+            values,
+            is_ordered: false,
+        }
+    }
+
+    /// Deconstruct this array into its constituent parts
+    pub fn into_parts(self) -> (PrimitiveArray<K>, ArrayRef) {
+        (self.keys, self.values)
+    }
+
+    /// Return an array view of the keys of this dictionary as a PrimitiveArray.
+    pub fn keys(&self) -> &PrimitiveArray<K> {
+        &self.keys
+    }
+
+    /// If `value` is present in `values` (aka the dictionary),
+    /// returns the corresponding key (index into the `values`
+    /// array). Otherwise returns `None`.
+    ///
+    /// Panics if `values` is not a [`StringArray`].
+    pub fn lookup_key(&self, value: &str) -> Option<K::Native> {
+        let rd_buf: &StringArray = self.values.as_any().downcast_ref::<StringArray>().unwrap();
+
+        (0..rd_buf.len())
+            .position(|i| rd_buf.value(i) == value)
+            .and_then(K::Native::from_usize)
+    }
+
+    /// Returns a reference to the dictionary values array
+    pub fn values(&self) -> &ArrayRef {
+        &self.values
+    }
+
+    /// Returns a clone of the value type of this list.
+    pub fn value_type(&self) -> DataType {
+        self.values.data_type().clone()
+    }
+
+    /// The length of the dictionary is the length of the keys array.
+    pub fn len(&self) -> usize {
+        self.keys.len()
+    }
+
+    /// Whether this dictionary is empty
+    pub fn is_empty(&self) -> bool {
+        self.keys.is_empty()
+    }
+
+    /// Currently exists for compatibility purposes with Arrow IPC.
+    pub fn is_ordered(&self) -> bool {
+        self.is_ordered
+    }
+
+    /// Return an iterator over the keys (indexes into the dictionary)
+    pub fn keys_iter(&self) -> impl Iterator<Item = Option<usize>> + '_ {
+        self.keys.iter().map(|key| key.map(|k| k.as_usize()))
+    }
+
+    /// Return the value of `keys` (the dictionary key) at index `i`,
+    /// cast to `usize`, `None` if the value at `i` is `NULL`.
+    pub fn key(&self, i: usize) -> Option<usize> {
+        self.keys.is_valid(i).then(|| self.keys.value(i).as_usize())
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, length: usize) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            keys: self.keys.slice(offset, length),
+            values: self.values.clone(),
+            is_ordered: self.is_ordered,
+        }
+    }
+
+    /// Downcast this dictionary to a [`TypedDictionaryArray`]
+    ///
+    /// ```
+    /// use arrow_array::{Array, ArrayAccessor, DictionaryArray, StringArray, types::Int32Type};
+    ///
+    /// let orig = [Some("a"), Some("b"), None];
+    /// let dictionary = DictionaryArray::<Int32Type>::from_iter(orig);
+    /// let typed = dictionary.downcast_dict::<StringArray>().unwrap();
+    /// assert_eq!(typed.value(0), "a");
+    /// assert_eq!(typed.value(1), "b");
+    /// assert!(typed.is_null(2));
+    /// ```
+    ///
+    pub fn downcast_dict<V: 'static>(&self) -> Option<TypedDictionaryArray<'_, K, V>> {
+        let values = self.values.as_any().downcast_ref()?;
+        Some(TypedDictionaryArray {
+            dictionary: self,
+            values,
+        })
+    }
+
+    /// Returns a new dictionary with the same keys as the current instance
+    /// but with a different set of dictionary values
+    ///
+    /// This can be used to perform an operation on the values of a dictionary
+    ///
+    /// # Panics
+    ///
+    /// Panics if `values` has a length less than the current values
+    ///
+    /// ```
+    /// # use std::sync::Arc;
+    /// # use arrow_array::builder::PrimitiveDictionaryBuilder;
+    /// # use arrow_array::{Int8Array, Int64Array, ArrayAccessor};
+    /// # use arrow_array::types::{Int32Type, Int8Type};
+    ///
+    /// // Construct a Dict(Int32, Int8)
+    /// let mut builder = PrimitiveDictionaryBuilder::<Int32Type, Int8Type>::with_capacity(2, 200);
+    /// for i in 0..100 {
+    ///     builder.append(i % 2).unwrap();
+    /// }
+    ///
+    /// let dictionary = builder.finish();
+    ///
+    /// // Perform a widening cast of dictionary values
+    /// let typed_dictionary = dictionary.downcast_dict::<Int8Array>().unwrap();
+    /// let values: Int64Array = typed_dictionary.values().unary(|x| x as i64);
+    ///
+    /// // Create a Dict(Int32,
+    /// let new = dictionary.with_values(Arc::new(values));
+    ///
+    /// // Verify values are as expected
+    /// let new_typed = new.downcast_dict::<Int64Array>().unwrap();
+    /// for i in 0..100 {
+    ///     assert_eq!(new_typed.value(i), (i % 2) as i64)
+    /// }
+    /// ```
+    ///
+    pub fn with_values(&self, values: ArrayRef) -> Self {
+        assert!(values.len() >= self.values.len());
+        let data_type =
+            DataType::Dictionary(Box::new(K::DATA_TYPE), Box::new(values.data_type().clone()));
+        Self {
+            data_type,
+            keys: self.keys.clone(),
+            values,
+            is_ordered: false,
+        }
+    }
+
+    /// Returns `PrimitiveDictionaryBuilder` of this dictionary array for mutating
+    /// its keys and values if the underlying data buffer is not shared by others.
+    pub fn into_primitive_dict_builder<V>(self) -> Result<PrimitiveDictionaryBuilder<K, V>, Self>
+    where
+        V: ArrowPrimitiveType,
+    {
+        if !self.value_type().is_primitive() {
+            return Err(self);
+        }
+
+        let key_array = self.keys().clone();
+        let value_array = self.values().as_primitive::<V>().clone();
+
+        drop(self.keys);
+        drop(self.values);
+
+        let key_builder = key_array.into_builder();
+        let value_builder = value_array.into_builder();
+
+        match (key_builder, value_builder) {
+            (Ok(key_builder), Ok(value_builder)) => Ok(unsafe {
+                PrimitiveDictionaryBuilder::new_from_builders(key_builder, value_builder)
+            }),
+            (Err(key_array), Ok(mut value_builder)) => {
+                Err(Self::try_new(key_array, Arc::new(value_builder.finish())).unwrap())
+            }
+            (Ok(mut key_builder), Err(value_array)) => {
+                Err(Self::try_new(key_builder.finish(), Arc::new(value_array)).unwrap())
+            }
+            (Err(key_array), Err(value_array)) => {
+                Err(Self::try_new(key_array, Arc::new(value_array)).unwrap())
+            }
+        }
+    }
+
+    /// Applies an unary and infallible function to a mutable dictionary array.
+    /// Mutable dictionary array means that the buffers are not shared with other arrays.
+    /// As a result, this mutates the buffers directly without allocating new buffers.
+    ///
+    /// # Implementation
+    ///
+    /// This will apply the function for all dictionary values, including those on null slots.
+    /// This implies that the operation must be infallible for any value of the corresponding type
+    /// or this function may panic.
+    /// # Example
+    /// ```
+    /// # use std::sync::Arc;
+    /// # use arrow_array::{Array, ArrayAccessor, DictionaryArray, StringArray, types::{Int8Type, Int32Type}};
+    /// # use arrow_array::{Int8Array, Int32Array};
+    /// let values = Int32Array::from(vec![Some(10), Some(20), None]);
+    /// let keys = Int8Array::from_iter_values([0, 0, 1, 2]);
+    /// let dictionary = DictionaryArray::<Int8Type>::try_new(keys, Arc::new(values)).unwrap();
+    /// let c = dictionary.unary_mut::<_, Int32Type>(|x| x + 1).unwrap();
+    /// let typed = c.downcast_dict::<Int32Array>().unwrap();
+    /// assert_eq!(typed.value(0), 11);
+    /// assert_eq!(typed.value(1), 11);
+    /// assert_eq!(typed.value(2), 21);
+    /// ```
+    pub fn unary_mut<F, V>(self, op: F) -> Result<DictionaryArray<K>, DictionaryArray<K>>
+    where
+        V: ArrowPrimitiveType,
+        F: Fn(V::Native) -> V::Native,
+    {
+        let mut builder: PrimitiveDictionaryBuilder<K, V> = self.into_primitive_dict_builder()?;
+        builder
+            .values_slice_mut()
+            .iter_mut()
+            .for_each(|v| *v = op(*v));
+        Ok(builder.finish())
+    }
+
+    /// Computes an occupancy mask for this dictionary's values
+    ///
+    /// For each value in [`Self::values`] the corresponding bit will be set in the
+    /// returned mask if it is referenced by a key in this [`DictionaryArray`]
+    pub fn occupancy(&self) -> BooleanBuffer {
+        let len = self.values.len();
+        let mut builder = BooleanBufferBuilder::new(len);
+        builder.resize(len);
+        let slice = builder.as_slice_mut();
+        match self.keys.nulls().filter(|n| n.null_count() > 0) {
+            Some(n) => {
+                let v = self.keys.values();
+                n.valid_indices()
+                    .for_each(|idx| set_bit(slice, v[idx].as_usize()))
+            }
+            None => {
+                let v = self.keys.values();
+                v.iter().for_each(|v| set_bit(slice, v.as_usize()))
+            }
+        }
+        builder.finish()
+    }
+}
+
+/// Constructs a `DictionaryArray` from an array data reference.
+impl<T: ArrowDictionaryKeyType> From<ArrayData> for DictionaryArray<T> {
+    fn from(data: ArrayData) -> Self {
+        assert_eq!(
+            data.buffers().len(),
+            1,
+            "DictionaryArray data should contain a single buffer only (keys)."
+        );
+        assert_eq!(
+            data.child_data().len(),
+            1,
+            "DictionaryArray should contain a single child array (values)."
+        );
+
+        if let DataType::Dictionary(key_data_type, _) = data.data_type() {
+            assert_eq!(
+                &T::DATA_TYPE,
+                key_data_type.as_ref(),
+                "DictionaryArray's data type must match, expected {} got {}",
+                T::DATA_TYPE,
+                key_data_type
+            );
+
+            let values = make_array(data.child_data()[0].clone());
+            let data_type = data.data_type().clone();
+
+            // create a zero-copy of the keys' data
+            // SAFETY:
+            // ArrayData is valid and verified type above
+
+            let keys = PrimitiveArray::<T>::from(unsafe {
+                data.into_builder()
+                    .data_type(T::DATA_TYPE)
+                    .child_data(vec![])
+                    .build_unchecked()
+            });
+
+            Self {
+                data_type,
+                keys,
+                values,
+                is_ordered: false,
+            }
+        } else {
+            panic!("DictionaryArray must have Dictionary data type.")
+        }
+    }
+}
+
+impl<T: ArrowDictionaryKeyType> From<DictionaryArray<T>> for ArrayData {
+    fn from(array: DictionaryArray<T>) -> Self {
+        let builder = array
+            .keys
+            .into_data()
+            .into_builder()
+            .data_type(array.data_type)
+            .child_data(vec![array.values.to_data()]);
+
+        unsafe { builder.build_unchecked() }
+    }
+}
+
+/// Constructs a `DictionaryArray` from an iterator of optional strings.
+///
+/// # Example:
+/// ```
+/// use arrow_array::{DictionaryArray, PrimitiveArray, StringArray, types::Int8Type};
+///
+/// let test = vec!["a", "a", "b", "c"];
+/// let array: DictionaryArray<Int8Type> = test
+///     .iter()
+///     .map(|&x| if x == "b" { None } else { Some(x) })
+///     .collect();
+/// assert_eq!(
+///     "DictionaryArray {keys: PrimitiveArray<Int8>\n[\n  0,\n  0,\n  null,\n  1,\n] values: StringArray\n[\n  \"a\",\n  \"c\",\n]}\n",
+///     format!("{:?}", array)
+/// );
+/// ```
+impl<'a, T: ArrowDictionaryKeyType> FromIterator<Option<&'a str>> for DictionaryArray<T> {
+    fn from_iter<I: IntoIterator<Item = Option<&'a str>>>(iter: I) -> Self {
+        let it = iter.into_iter();
+        let (lower, _) = it.size_hint();
+        let mut builder = StringDictionaryBuilder::with_capacity(lower, 256, 1024);
+        builder.extend(it);
+        builder.finish()
+    }
+}
+
+/// Constructs a `DictionaryArray` from an iterator of strings.
+///
+/// # Example:
+///
+/// ```
+/// use arrow_array::{DictionaryArray, PrimitiveArray, StringArray, types::Int8Type};
+///
+/// let test = vec!["a", "a", "b", "c"];
+/// let array: DictionaryArray<Int8Type> = test.into_iter().collect();
+/// assert_eq!(
+///     "DictionaryArray {keys: PrimitiveArray<Int8>\n[\n  0,\n  0,\n  1,\n  2,\n] values: StringArray\n[\n  \"a\",\n  \"b\",\n  \"c\",\n]}\n",
+///     format!("{:?}", array)
+/// );
+/// ```
+impl<'a, T: ArrowDictionaryKeyType> FromIterator<&'a str> for DictionaryArray<T> {
+    fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> Self {
+        let it = iter.into_iter();
+        let (lower, _) = it.size_hint();
+        let mut builder = StringDictionaryBuilder::with_capacity(lower, 256, 1024);
+        it.for_each(|i| {
+            builder
+                .append(i)
+                .expect("Unable to append a value to a dictionary array.");
+        });
+
+        builder.finish()
+    }
+}
+
+impl<T: ArrowDictionaryKeyType> Array for DictionaryArray<T> {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.into()
+    }
+
+    fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.keys.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.keys.is_empty()
+    }
+
+    fn offset(&self) -> usize {
+        self.keys.offset()
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.keys.nulls()
+    }
+
+    fn logical_nulls(&self) -> Option<NullBuffer> {
+        match self.values.nulls() {
+            None => self.nulls().cloned(),
+            Some(value_nulls) => {
+                let mut builder = BooleanBufferBuilder::new(self.len());
+                match self.keys.nulls() {
+                    Some(n) => builder.append_buffer(n.inner()),
+                    None => builder.append_n(self.len(), true),
+                }
+                for (idx, k) in self.keys.values().iter().enumerate() {
+                    let k = k.as_usize();
+                    // Check range to allow for nulls
+                    if k < value_nulls.len() && value_nulls.is_null(k) {
+                        builder.set_bit(idx, false);
+                    }
+                }
+                Some(builder.finish().into())
+            }
+        }
+    }
+
+    fn is_nullable(&self) -> bool {
+        !self.is_empty() && (self.nulls().is_some() || self.values.is_nullable())
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        self.keys.get_buffer_memory_size() + self.values.get_buffer_memory_size()
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        std::mem::size_of::<Self>()
+            + self.keys.get_buffer_memory_size()
+            + self.values.get_array_memory_size()
+    }
+}
+
+impl<T: ArrowDictionaryKeyType> std::fmt::Debug for DictionaryArray<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        writeln!(
+            f,
+            "DictionaryArray {{keys: {:?} values: {:?}}}",
+            self.keys, self.values
+        )
+    }
+}
+
+/// A [`DictionaryArray`] typed on its child values array
+///
+/// Implements [`ArrayAccessor`] allowing fast access to its elements
+///
+/// ```
+/// use arrow_array::{DictionaryArray, StringArray, types::Int32Type};
+///
+/// let orig = ["a", "b", "a", "b"];
+/// let dictionary = DictionaryArray::<Int32Type>::from_iter(orig);
+///
+/// // `TypedDictionaryArray` allows you to access the values directly
+/// let typed = dictionary.downcast_dict::<StringArray>().unwrap();
+///
+/// for (maybe_val, orig) in typed.into_iter().zip(orig) {
+///     assert_eq!(maybe_val.unwrap(), orig)
+/// }
+/// ```
+pub struct TypedDictionaryArray<'a, K: ArrowDictionaryKeyType, V> {
+    /// The dictionary array
+    dictionary: &'a DictionaryArray<K>,
+    /// The values of the dictionary
+    values: &'a V,
+}
+
+// Manually implement `Clone` to avoid `V: Clone` type constraint
+impl<'a, K: ArrowDictionaryKeyType, V> Clone for TypedDictionaryArray<'a, K, V> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'a, K: ArrowDictionaryKeyType, V> Copy for TypedDictionaryArray<'a, K, V> {}
+
+impl<'a, K: ArrowDictionaryKeyType, V> std::fmt::Debug for TypedDictionaryArray<'a, K, V> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        writeln!(f, "TypedDictionaryArray({:?})", self.dictionary)
+    }
+}
+
+impl<'a, K: ArrowDictionaryKeyType, V> TypedDictionaryArray<'a, K, V> {
+    /// Returns the keys of this [`TypedDictionaryArray`]
+    pub fn keys(&self) -> &'a PrimitiveArray<K> {
+        self.dictionary.keys()
+    }
+
+    /// Returns the values of this [`TypedDictionaryArray`]
+    pub fn values(&self) -> &'a V {
+        self.values
+    }
+}
+
+impl<'a, K: ArrowDictionaryKeyType, V: Sync> Array for TypedDictionaryArray<'a, K, V> {
+    fn as_any(&self) -> &dyn Any {
+        self.dictionary
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.dictionary.to_data()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.dictionary.into_data()
+    }
+
+    fn data_type(&self) -> &DataType {
+        self.dictionary.data_type()
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.dictionary.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.dictionary.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.dictionary.is_empty()
+    }
+
+    fn offset(&self) -> usize {
+        self.dictionary.offset()
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.dictionary.nulls()
+    }
+
+    fn logical_nulls(&self) -> Option<NullBuffer> {
+        self.dictionary.logical_nulls()
+    }
+
+    fn is_nullable(&self) -> bool {
+        self.dictionary.is_nullable()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        self.dictionary.get_buffer_memory_size()
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        self.dictionary.get_array_memory_size()
+    }
+}
+
+impl<'a, K, V> IntoIterator for TypedDictionaryArray<'a, K, V>
+where
+    K: ArrowDictionaryKeyType,
+    Self: ArrayAccessor,
+{
+    type Item = Option<<Self as ArrayAccessor>::Item>;
+    type IntoIter = ArrayIter<Self>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        ArrayIter::new(self)
+    }
+}
+
+impl<'a, K, V> ArrayAccessor for TypedDictionaryArray<'a, K, V>
+where
+    K: ArrowDictionaryKeyType,
+    V: Sync + Send,
+    &'a V: ArrayAccessor,
+    <&'a V as ArrayAccessor>::Item: Default,
+{
+    type Item = <&'a V as ArrayAccessor>::Item;
+
+    fn value(&self, index: usize) -> Self::Item {
+        assert!(
+            index < self.len(),
+            "Trying to access an element at index {} from a TypedDictionaryArray of length {}",
+            index,
+            self.len()
+        );
+        unsafe { self.value_unchecked(index) }
+    }
+
+    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
+        let val = self.dictionary.keys.value_unchecked(index);
+        let value_idx = val.as_usize();
+
+        // As dictionary keys are only verified for non-null indexes
+        // we must check the value is within bounds
+        match value_idx < self.values.len() {
+            true => self.values.value_unchecked(value_idx),
+            false => Default::default(),
+        }
+    }
+}
+
+/// A [`DictionaryArray`] with the key type erased
+///
+/// This can be used to efficiently implement kernels for all possible dictionary
+/// keys without needing to create specialized implementations for each key type
+///
+/// For example
+///
+/// ```
+/// # use arrow_array::*;
+/// # use arrow_array::cast::AsArray;
+/// # use arrow_array::builder::PrimitiveDictionaryBuilder;
+/// # use arrow_array::types::*;
+/// # use arrow_schema::ArrowError;
+/// # use std::sync::Arc;
+///
+/// fn to_string(a: &dyn Array) -> Result<ArrayRef, ArrowError> {
+///     if let Some(d) = a.as_any_dictionary_opt() {
+///         // Recursively handle dictionary input
+///         let r = to_string(d.values().as_ref())?;
+///         return Ok(d.with_values(r));
+///     }
+///     downcast_primitive_array! {
+///         a => Ok(Arc::new(a.iter().map(|x| x.map(|x| x.to_string())).collect::<StringArray>())),
+///         d => Err(ArrowError::InvalidArgumentError(format!("{d:?} not supported")))
+///     }
+/// }
+///
+/// let result = to_string(&Int32Array::from(vec![1, 2, 3])).unwrap();
+/// let actual = result.as_string::<i32>().iter().map(Option::unwrap).collect::<Vec<_>>();
+/// assert_eq!(actual, &["1", "2", "3"]);
+///
+/// let mut dict = PrimitiveDictionaryBuilder::<Int32Type, UInt16Type>::new();
+/// dict.extend([Some(1), Some(1), Some(2), Some(3), Some(2)]);
+/// let dict = dict.finish();
+///
+/// let r = to_string(&dict).unwrap();
+/// let r = r.as_dictionary::<Int32Type>().downcast_dict::<StringArray>().unwrap();
+/// assert_eq!(r.keys(), dict.keys()); // Keys are the same
+///
+/// let actual = r.into_iter().map(Option::unwrap).collect::<Vec<_>>();
+/// assert_eq!(actual, &["1", "1", "2", "3", "2"]);
+/// ```
+///
+/// See [`AsArray::as_any_dictionary_opt`] and [`AsArray::as_any_dictionary`]
+pub trait AnyDictionaryArray: Array {
+    /// Returns the primitive keys of this dictionary as an [`Array`]
+    fn keys(&self) -> &dyn Array;
+
+    /// Returns the values of this dictionary
+    fn values(&self) -> &ArrayRef;
+
+    /// Returns the keys of this dictionary as usize
+    ///
+    /// The values for nulls will be arbitrary, but are guaranteed
+    /// to be in the range `0..self.values.len()`
+    ///
+    /// # Panic
+    ///
+    /// Panics if `values.len() == 0`
+    fn normalized_keys(&self) -> Vec<usize>;
+
+    /// Create a new [`DictionaryArray`] replacing `values` with the new values
+    ///
+    /// See [`DictionaryArray::with_values`]
+    fn with_values(&self, values: ArrayRef) -> ArrayRef;
+}
+
+impl<K: ArrowDictionaryKeyType> AnyDictionaryArray for DictionaryArray<K> {
+    fn keys(&self) -> &dyn Array {
+        &self.keys
+    }
+
+    fn values(&self) -> &ArrayRef {
+        self.values()
+    }
+
+    fn normalized_keys(&self) -> Vec<usize> {
+        let v_len = self.values().len();
+        assert_ne!(v_len, 0);
+        let iter = self.keys().values().iter();
+        iter.map(|x| x.as_usize().min(v_len - 1)).collect()
+    }
+
+    fn with_values(&self, values: ArrayRef) -> ArrayRef {
+        Arc::new(self.with_values(values))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::builder::PrimitiveDictionaryBuilder;
+    use crate::cast::as_dictionary_array;
+    use crate::types::{Int32Type, Int8Type, UInt32Type, UInt8Type};
+    use crate::{Int16Array, Int32Array, Int8Array};
+    use arrow_buffer::{Buffer, ToByteSlice};
+    use std::sync::Arc;
+
+    #[test]
+    fn test_dictionary_array() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int8)
+            .len(8)
+            .add_buffer(Buffer::from(
+                &[10_i8, 11, 12, 13, 14, 15, 16, 17].to_byte_slice(),
+            ))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        let keys = Buffer::from(&[2_i16, 3, 4].to_byte_slice());
+
+        // Construct a dictionary array from the above two
+        let key_type = DataType::Int16;
+        let value_type = DataType::Int8;
+        let dict_data_type = DataType::Dictionary(Box::new(key_type), Box::new(value_type));
+        let dict_data = ArrayData::builder(dict_data_type.clone())
+            .len(3)
+            .add_buffer(keys.clone())
+            .add_child_data(value_data.clone())
+            .build()
+            .unwrap();
+        let dict_array = Int16DictionaryArray::from(dict_data);
+
+        let values = dict_array.values();
+        assert_eq!(value_data, values.to_data());
+        assert_eq!(DataType::Int8, dict_array.value_type());
+        assert_eq!(3, dict_array.len());
+
+        // Null count only makes sense in terms of the component arrays.
+        assert_eq!(0, dict_array.null_count());
+        assert_eq!(0, dict_array.values().null_count());
+        assert_eq!(dict_array.keys(), &Int16Array::from(vec![2_i16, 3, 4]));
+
+        // Now test with a non-zero offset
+        let dict_data = ArrayData::builder(dict_data_type)
+            .len(2)
+            .offset(1)
+            .add_buffer(keys)
+            .add_child_data(value_data.clone())
+            .build()
+            .unwrap();
+        let dict_array = Int16DictionaryArray::from(dict_data);
+
+        let values = dict_array.values();
+        assert_eq!(value_data, values.to_data());
+        assert_eq!(DataType::Int8, dict_array.value_type());
+        assert_eq!(2, dict_array.len());
+        assert_eq!(dict_array.keys(), &Int16Array::from(vec![3_i16, 4]));
+    }
+
+    #[test]
+    fn test_dictionary_array_fmt_debug() {
+        let mut builder = PrimitiveDictionaryBuilder::<UInt8Type, UInt32Type>::with_capacity(3, 2);
+        builder.append(12345678).unwrap();
+        builder.append_null();
+        builder.append(22345678).unwrap();
+        let array = builder.finish();
+        assert_eq!(
+            "DictionaryArray {keys: PrimitiveArray<UInt8>\n[\n  0,\n  null,\n  1,\n] values: PrimitiveArray<UInt32>\n[\n  12345678,\n  22345678,\n]}\n",
+            format!("{array:?}")
+        );
+
+        let mut builder = PrimitiveDictionaryBuilder::<UInt8Type, UInt32Type>::with_capacity(20, 2);
+        for _ in 0..20 {
+            builder.append(1).unwrap();
+        }
+        let array = builder.finish();
+        assert_eq!(
+            "DictionaryArray {keys: PrimitiveArray<UInt8>\n[\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n] values: PrimitiveArray<UInt32>\n[\n  1,\n]}\n",
+            format!("{array:?}")
+        );
+    }
+
+    #[test]
+    fn test_dictionary_array_from_iter() {
+        let test = vec!["a", "a", "b", "c"];
+        let array: DictionaryArray<Int8Type> = test
+            .iter()
+            .map(|&x| if x == "b" { None } else { Some(x) })
+            .collect();
+        assert_eq!(
+            "DictionaryArray {keys: PrimitiveArray<Int8>\n[\n  0,\n  0,\n  null,\n  1,\n] values: StringArray\n[\n  \"a\",\n  \"c\",\n]}\n",
+            format!("{array:?}")
+        );
+
+        let array: DictionaryArray<Int8Type> = test.into_iter().collect();
+        assert_eq!(
+            "DictionaryArray {keys: PrimitiveArray<Int8>\n[\n  0,\n  0,\n  1,\n  2,\n] values: StringArray\n[\n  \"a\",\n  \"b\",\n  \"c\",\n]}\n",
+            format!("{array:?}")
+        );
+    }
+
+    #[test]
+    fn test_dictionary_array_reverse_lookup_key() {
+        let test = vec!["a", "a", "b", "c"];
+        let array: DictionaryArray<Int8Type> = test.into_iter().collect();
+
+        assert_eq!(array.lookup_key("c"), Some(2));
+
+        // Direction of building a dictionary is the iterator direction
+        let test = vec!["t3", "t3", "t2", "t2", "t1", "t3", "t4", "t1", "t0"];
+        let array: DictionaryArray<Int8Type> = test.into_iter().collect();
+
+        assert_eq!(array.lookup_key("t1"), Some(2));
+        assert_eq!(array.lookup_key("non-existent"), None);
+    }
+
+    #[test]
+    fn test_dictionary_keys_as_primitive_array() {
+        let test = vec!["a", "b", "c", "a"];
+        let array: DictionaryArray<Int8Type> = test.into_iter().collect();
+
+        let keys = array.keys();
+        assert_eq!(&DataType::Int8, keys.data_type());
+        assert_eq!(0, keys.null_count());
+        assert_eq!(&[0, 1, 2, 0], keys.values());
+    }
+
+    #[test]
+    fn test_dictionary_keys_as_primitive_array_with_null() {
+        let test = vec![Some("a"), None, Some("b"), None, None, Some("a")];
+        let array: DictionaryArray<Int32Type> = test.into_iter().collect();
+
+        let keys = array.keys();
+        assert_eq!(&DataType::Int32, keys.data_type());
+        assert_eq!(3, keys.null_count());
+
+        assert!(keys.is_valid(0));
+        assert!(!keys.is_valid(1));
+        assert!(keys.is_valid(2));
+        assert!(!keys.is_valid(3));
+        assert!(!keys.is_valid(4));
+        assert!(keys.is_valid(5));
+
+        assert_eq!(0, keys.value(0));
+        assert_eq!(1, keys.value(2));
+        assert_eq!(0, keys.value(5));
+    }
+
+    #[test]
+    fn test_dictionary_all_nulls() {
+        let test = vec![None, None, None];
+        let array: DictionaryArray<Int32Type> = test.into_iter().collect();
+        array
+            .into_data()
+            .validate_full()
+            .expect("All null array has valid array data");
+    }
+
+    #[test]
+    fn test_dictionary_iter() {
+        // Construct a value array
+        let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
+        let keys = Int16Array::from_iter_values([2_i16, 3, 4]);
+
+        // Construct a dictionary array from the above two
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+
+        let mut key_iter = dict_array.keys_iter();
+        assert_eq!(2, key_iter.next().unwrap().unwrap());
+        assert_eq!(3, key_iter.next().unwrap().unwrap());
+        assert_eq!(4, key_iter.next().unwrap().unwrap());
+        assert!(key_iter.next().is_none());
+
+        let mut iter = dict_array
+            .values()
+            .as_any()
+            .downcast_ref::<Int8Array>()
+            .unwrap()
+            .take_iter(dict_array.keys_iter());
+
+        assert_eq!(12, iter.next().unwrap().unwrap());
+        assert_eq!(13, iter.next().unwrap().unwrap());
+        assert_eq!(14, iter.next().unwrap().unwrap());
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_dictionary_iter_with_null() {
+        let test = vec![Some("a"), None, Some("b"), None, None, Some("a")];
+        let array: DictionaryArray<Int32Type> = test.into_iter().collect();
+
+        let mut iter = array
+            .values()
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap()
+            .take_iter(array.keys_iter());
+
+        assert_eq!("a", iter.next().unwrap().unwrap());
+        assert!(iter.next().unwrap().is_none());
+        assert_eq!("b", iter.next().unwrap().unwrap());
+        assert!(iter.next().unwrap().is_none());
+        assert!(iter.next().unwrap().is_none());
+        assert_eq!("a", iter.next().unwrap().unwrap());
+        assert!(iter.next().is_none());
+    }
+
+    #[test]
+    fn test_dictionary_key() {
+        let keys = Int8Array::from(vec![Some(2), None, Some(1)]);
+        let values = StringArray::from(vec!["foo", "bar", "baz", "blarg"]);
+
+        let array = DictionaryArray::new(keys, Arc::new(values));
+        assert_eq!(array.key(0), Some(2));
+        assert_eq!(array.key(1), None);
+        assert_eq!(array.key(2), Some(1));
+    }
+
+    #[test]
+    fn test_try_new() {
+        let values: StringArray = [Some("foo"), Some("bar"), Some("baz")]
+            .into_iter()
+            .collect();
+        let keys: Int32Array = [Some(0), Some(2), None, Some(1)].into_iter().collect();
+
+        let array = DictionaryArray::new(keys, Arc::new(values));
+        assert_eq!(array.keys().data_type(), &DataType::Int32);
+        assert_eq!(array.values().data_type(), &DataType::Utf8);
+
+        assert_eq!(array.null_count(), 1);
+
+        assert!(array.keys().is_valid(0));
+        assert!(array.keys().is_valid(1));
+        assert!(array.keys().is_null(2));
+        assert!(array.keys().is_valid(3));
+
+        assert_eq!(array.keys().value(0), 0);
+        assert_eq!(array.keys().value(1), 2);
+        assert_eq!(array.keys().value(3), 1);
+
+        assert_eq!(
+            "DictionaryArray {keys: PrimitiveArray<Int32>\n[\n  0,\n  2,\n  null,\n  1,\n] values: StringArray\n[\n  \"foo\",\n  \"bar\",\n  \"baz\",\n]}\n",
+            format!("{array:?}")
+        );
+    }
+
+    #[test]
+    #[should_panic(expected = "Invalid dictionary key 3 at index 1, expected 0 <= key < 2")]
+    fn test_try_new_index_too_large() {
+        let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
+        // dictionary only has 2 values, so offset 3 is out of bounds
+        let keys: Int32Array = [Some(0), Some(3)].into_iter().collect();
+        DictionaryArray::new(keys, Arc::new(values));
+    }
+
+    #[test]
+    #[should_panic(expected = "Invalid dictionary key -100 at index 0, expected 0 <= key < 2")]
+    fn test_try_new_index_too_small() {
+        let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
+        let keys: Int32Array = [Some(-100)].into_iter().collect();
+        DictionaryArray::new(keys, Arc::new(values));
+    }
+
+    #[test]
+    #[should_panic(expected = "DictionaryArray's data type must match, expected Int64 got Int32")]
+    fn test_from_array_data_validation() {
+        let a = DictionaryArray::<Int32Type>::from_iter(["32"]);
+        let _ = DictionaryArray::<Int64Type>::from(a.into_data());
+    }
+
+    #[test]
+    fn test_into_primitive_dict_builder() {
+        let values = Int32Array::from_iter_values([10_i32, 12, 15]);
+        let keys = Int8Array::from_iter_values([1_i8, 0, 2, 0]);
+
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+
+        let boxed: ArrayRef = Arc::new(dict_array);
+        let col: DictionaryArray<Int8Type> = as_dictionary_array(&boxed).clone();
+
+        drop(boxed);
+
+        let mut builder = col.into_primitive_dict_builder::<Int32Type>().unwrap();
+
+        let slice = builder.values_slice_mut();
+        assert_eq!(slice, &[10, 12, 15]);
+
+        slice[0] = 4;
+        slice[1] = 2;
+        slice[2] = 1;
+
+        let values = Int32Array::from_iter_values([4_i32, 2, 1]);
+        let keys = Int8Array::from_iter_values([1_i8, 0, 2, 0]);
+
+        let expected = DictionaryArray::new(keys, Arc::new(values));
+
+        let new_array = builder.finish();
+        assert_eq!(expected, new_array);
+    }
+
+    #[test]
+    fn test_into_primitive_dict_builder_cloned_array() {
+        let values = Int32Array::from_iter_values([10_i32, 12, 15]);
+        let keys = Int8Array::from_iter_values([1_i8, 0, 2, 0]);
+
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+
+        let boxed: ArrayRef = Arc::new(dict_array);
+
+        let col: DictionaryArray<Int8Type> = DictionaryArray::<Int8Type>::from(boxed.to_data());
+        let err = col.into_primitive_dict_builder::<Int32Type>();
+
+        let returned = err.unwrap_err();
+
+        let values = Int32Array::from_iter_values([10_i32, 12, 15]);
+        let keys = Int8Array::from_iter_values([1_i8, 0, 2, 0]);
+
+        let expected = DictionaryArray::new(keys, Arc::new(values));
+        assert_eq!(expected, returned);
+    }
+
+    #[test]
+    fn test_occupancy() {
+        let keys = Int32Array::new((100..200).collect(), None);
+        let values = Int32Array::from(vec![0; 1024]);
+        let dict = DictionaryArray::new(keys, Arc::new(values));
+        for (idx, v) in dict.occupancy().iter().enumerate() {
+            let expected = (100..200).contains(&idx);
+            assert_eq!(v, expected, "{idx}");
+        }
+
+        let keys = Int32Array::new(
+            (0..100).collect(),
+            Some((0..100).map(|x| x % 4 == 0).collect()),
+        );
+        let values = Int32Array::from(vec![0; 1024]);
+        let dict = DictionaryArray::new(keys, Arc::new(values));
+        for (idx, v) in dict.occupancy().iter().enumerate() {
+            let expected = idx % 4 == 0 && idx < 100;
+            assert_eq!(v, expected, "{idx}");
+        }
+    }
+
+    #[test]
+    fn test_iterator_nulls() {
+        let keys = Int32Array::new(
+            vec![0, 700, 1, 2].into(),
+            Some(NullBuffer::from(vec![true, false, true, true])),
+        );
+        let values = Int32Array::from(vec![Some(50), None, Some(2)]);
+        let dict = DictionaryArray::new(keys, Arc::new(values));
+        let values: Vec<_> = dict
+            .downcast_dict::<Int32Array>()
+            .unwrap()
+            .into_iter()
+            .collect();
+        assert_eq!(values, &[Some(50), None, None, Some(2)])
+    }
+
+    #[test]
+    fn test_normalized_keys() {
+        let values = vec![132, 0, 1].into();
+        let nulls = NullBuffer::from(vec![false, true, true]);
+        let keys = Int32Array::new(values, Some(nulls));
+        let dictionary = DictionaryArray::new(keys, Arc::new(Int32Array::new_null(2)));
+        assert_eq!(&dictionary.normalized_keys(), &[1, 0, 1])
+    }
+}
diff --git a/arrow/src/array/array_fixed_size_binary.rs b/arrow-array/src/array/fixed_size_binary_array.rs
similarity index 54%
rename from arrow/src/array/array_fixed_size_binary.rs
rename to arrow-array/src/array/fixed_size_binary_array.rs
index a811917c727c..d89bbd5ad084 100644
--- a/arrow/src/array/array_fixed_size_binary.rs
+++ b/arrow-array/src/array/fixed_size_binary_array.rs
@@ -15,26 +15,24 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::array::print_long_array;
+use crate::iterator::FixedSizeBinaryIter;
+use crate::{Array, ArrayAccessor, ArrayRef, FixedSizeListArray};
+use arrow_buffer::buffer::NullBuffer;
+use arrow_buffer::{bit_util, ArrowNativeType, BooleanBuffer, Buffer, MutableBuffer};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType};
 use std::any::Any;
-use std::convert::From;
-use std::fmt;
-
-use super::{
-    array::print_long_array, raw_pointer::RawPtrBox, Array, ArrayData, FixedSizeListArray,
-};
-use crate::buffer::Buffer;
-use crate::error::{ArrowError, Result};
-use crate::util::bit_util;
-use crate::{buffer::MutableBuffer, datatypes::DataType};
-
-/// An array where each element is a fixed-size sequence of bytes.
+use std::sync::Arc;
+
+/// An array of [fixed size binary arrays](https://arrow.apache.org/docs/format/Columnar.html#fixed-size-primitive-layout)
 ///
 /// # Examples
 ///
 /// Create an array from an iterable argument of byte slices.
 ///
 /// ```
-///    use arrow::array::{Array, FixedSizeBinaryArray};
+///    use arrow_array::{Array, FixedSizeBinaryArray};
 ///    let input_arg = vec![ vec![1, 2], vec![3, 4], vec![5, 6] ];
 ///    let arr = FixedSizeBinaryArray::try_from_iter(input_arg.into_iter()).unwrap();
 ///
@@ -44,27 +42,103 @@ use crate::{buffer::MutableBuffer, datatypes::DataType};
 /// Create an array from an iterable argument of sparse byte slices.
 /// Sparsity means that the input argument can contain `None` items.
 /// ```
-///    use arrow::array::{Array, FixedSizeBinaryArray};
+///    use arrow_array::{Array, FixedSizeBinaryArray};
 ///    let input_arg = vec![ None, Some(vec![7, 8]), Some(vec![9, 10]), None, Some(vec![13, 14]) ];
-///    let arr = FixedSizeBinaryArray::try_from_sparse_iter(input_arg.into_iter()).unwrap();
+///    let arr = FixedSizeBinaryArray::try_from_sparse_iter_with_size(input_arg.into_iter(), 2).unwrap();
 ///    assert_eq!(5, arr.len())
 ///
 /// ```
 ///
+#[derive(Clone)]
 pub struct FixedSizeBinaryArray {
-    data: ArrayData,
-    value_data: RawPtrBox<u8>,
-    length: i32,
+    data_type: DataType, // Must be DataType::FixedSizeBinary(value_length)
+    value_data: Buffer,
+    nulls: Option<NullBuffer>,
+    len: usize,
+    value_length: i32,
 }
 
 impl FixedSizeBinaryArray {
+    /// Create a new [`FixedSizeBinaryArray`] with `size` element size, panicking on failure
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`Self::try_new`] returns an error
+    pub fn new(size: i32, values: Buffer, nulls: Option<NullBuffer>) -> Self {
+        Self::try_new(size, values, nulls).unwrap()
+    }
+
+    /// Create a new [`FixedSizeBinaryArray`] from the provided parts, returning an error on failure
+    ///
+    /// # Errors
+    ///
+    /// * `size < 0`
+    /// * `values.len() / size != nulls.len()`
+    pub fn try_new(
+        size: i32,
+        values: Buffer,
+        nulls: Option<NullBuffer>,
+    ) -> Result<Self, ArrowError> {
+        let data_type = DataType::FixedSizeBinary(size);
+        let s = size.to_usize().ok_or_else(|| {
+            ArrowError::InvalidArgumentError(format!("Size cannot be negative, got {}", size))
+        })?;
+
+        let len = values.len() / s;
+        if let Some(n) = nulls.as_ref() {
+            if n.len() != len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Incorrect length of null buffer for FixedSizeBinaryArray, expected {} got {}",
+                    len,
+                    n.len(),
+                )));
+            }
+        }
+
+        Ok(Self {
+            data_type,
+            value_data: values,
+            value_length: size,
+            nulls,
+            len,
+        })
+    }
+
+    /// Create a new [`FixedSizeBinaryArray`] of length `len` where all values are null
+    ///
+    /// # Panics
+    ///
+    /// Panics if
+    ///
+    /// * `size < 0`
+    /// * `size * len` would overflow `usize`
+    pub fn new_null(size: i32, len: usize) -> Self {
+        let capacity = size.to_usize().unwrap().checked_mul(len).unwrap();
+        Self {
+            data_type: DataType::FixedSizeBinary(size),
+            value_data: MutableBuffer::new(capacity).into(),
+            nulls: Some(NullBuffer::new_null(len)),
+            value_length: size,
+            len,
+        }
+    }
+
+    /// Deconstruct this array into its constituent parts
+    pub fn into_parts(self) -> (i32, Buffer, Option<NullBuffer>) {
+        (self.value_length, self.value_data, self.nulls)
+    }
+
     /// Returns the element at index `i` as a byte slice.
+    /// # Panics
+    /// Panics if index `i` is out of bounds.
     pub fn value(&self, i: usize) -> &[u8] {
         assert!(
-            i < self.data.len(),
-            "FixedSizeBinaryArray out of bounds access"
+            i < self.len(),
+            "Trying to access an element at index {} from a FixedSizeBinaryArray of length {}",
+            i,
+            self.len()
         );
-        let offset = i + self.data.offset();
+        let offset = i + self.offset();
         unsafe {
             let pos = self.value_offset_at(offset);
             std::slice::from_raw_parts(
@@ -78,7 +152,7 @@ impl FixedSizeBinaryArray {
     /// # Safety
     /// Caller is responsible for ensuring that the index is within the bounds of the array
     pub unsafe fn value_unchecked(&self, i: usize) -> &[u8] {
-        let offset = i + self.data.offset();
+        let offset = i + self.offset();
         let pos = self.value_offset_at(offset);
         std::slice::from_raw_parts(
             self.value_data.as_ptr().offset(pos as isize),
@@ -91,7 +165,7 @@ impl FixedSizeBinaryArray {
     /// Note this doesn't do any bound checking, for performance reason.
     #[inline]
     pub fn value_offset(&self, i: usize) -> i32 {
-        self.value_offset_at(self.data.offset() + i)
+        self.value_offset_at(self.offset() + i)
     }
 
     /// Returns the length for an element.
@@ -99,12 +173,39 @@ impl FixedSizeBinaryArray {
     /// All elements have the same length as the array is a fixed size.
     #[inline]
     pub fn value_length(&self) -> i32 {
-        self.length
+        self.value_length
+    }
+
+    /// Returns the values of this array.
+    ///
+    /// Unlike [`Self::value_data`] this returns the [`Buffer`]
+    /// allowing for zero-copy cloning.
+    #[inline]
+    pub fn values(&self) -> &Buffer {
+        &self.value_data
     }
 
-    /// Returns a clone of the value data buffer
-    pub fn value_data(&self) -> Buffer {
-        self.data.buffers()[0].clone()
+    /// Returns the raw value data.
+    pub fn value_data(&self) -> &[u8] {
+        self.value_data.as_slice()
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, len: usize) -> Self {
+        assert!(
+            offset.saturating_add(len) <= self.len,
+            "the length + offset of the sliced FixedSizeBinaryArray cannot exceed the existing length"
+        );
+
+        let size = self.value_length as usize;
+
+        Self {
+            data_type: self.data_type.clone(),
+            nulls: self.nulls.as_ref().map(|n| n.slice(offset, len)),
+            value_length: self.value_length,
+            value_data: self.value_data.slice_with_length(offset * size, len * size),
+            len,
+        }
     }
 
     /// Create an array from an iterable argument of sparse byte slices.
@@ -114,7 +215,7 @@ impl FixedSizeBinaryArray {
     /// # Examples
     ///
     /// ```
-    /// use arrow::array::FixedSizeBinaryArray;
+    /// use arrow_array::FixedSizeBinaryArray;
     /// let input_arg = vec![
     ///     None,
     ///     Some(vec![7, 8]),
@@ -129,7 +230,10 @@ impl FixedSizeBinaryArray {
     /// # Errors
     ///
     /// Returns error if argument has length zero, or sizes of nested slices don't match.
-    pub fn try_from_sparse_iter<T, U>(mut iter: T) -> Result<Self>
+    #[deprecated(
+        note = "This function will fail if the iterator produces only None values; prefer `try_from_sparse_iter_with_size`"
+    )]
+    pub fn try_from_sparse_iter<T, U>(mut iter: T) -> Result<Self, ArrowError>
     where
         T: Iterator<Item = Option<U>>,
         U: AsRef<[u8]>,
@@ -137,10 +241,13 @@ impl FixedSizeBinaryArray {
         let mut len = 0;
         let mut size = None;
         let mut byte = 0;
-        let mut null_buf = MutableBuffer::from_len_zeroed(0);
-        let mut buffer = MutableBuffer::from_len_zeroed(0);
+
+        let iter_size_hint = iter.size_hint().0;
+        let mut null_buf = MutableBuffer::new(bit_util::ceil(iter_size_hint, 8));
+        let mut buffer = MutableBuffer::new(0);
+
         let mut prepend = 0;
-        iter.try_for_each(|item| -> Result<()> {
+        iter.try_for_each(|item| -> Result<(), ArrowError> {
             // extend null bitmask by one byte per each 8 items
             if byte == 0 {
                 null_buf.push(0u8);
@@ -159,7 +266,12 @@ impl FixedSizeBinaryArray {
                         )));
                     }
                 } else {
-                    size = Some(slice.len());
+                    let len = slice.len();
+                    size = Some(len);
+                    // Now that we know how large each element is we can reserve
+                    // sufficient capacity in the underlying mutable buffer for
+                    // the data.
+                    buffer.reserve(iter_size_hint * len);
                     buffer.extend_zeros(slice.len() * prepend);
                 }
                 bit_util::set_bit(null_buf.as_slice_mut(), len);
@@ -181,19 +293,94 @@ impl FixedSizeBinaryArray {
             ));
         }
 
-        let size = size.unwrap_or(0);
-        let array_data = unsafe {
-            ArrayData::new_unchecked(
-                DataType::FixedSizeBinary(size as i32),
-                len,
-                None,
-                Some(null_buf.into()),
-                0,
-                vec![buffer.into()],
-                vec![],
-            )
-        };
-        Ok(FixedSizeBinaryArray::from(array_data))
+        let null_buf = BooleanBuffer::new(null_buf.into(), 0, len);
+        let nulls = Some(NullBuffer::new(null_buf)).filter(|n| n.null_count() > 0);
+
+        let size = size.unwrap_or(0) as i32;
+        Ok(Self {
+            data_type: DataType::FixedSizeBinary(size),
+            value_data: buffer.into(),
+            nulls,
+            value_length: size,
+            len,
+        })
+    }
+
+    /// Create an array from an iterable argument of sparse byte slices.
+    /// Sparsity means that items returned by the iterator are optional, i.e input argument can
+    /// contain `None` items. In cases where the iterator returns only `None` values, this
+    /// also takes a size parameter to ensure that the a valid FixedSizeBinaryArray is still
+    /// created.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use arrow_array::FixedSizeBinaryArray;
+    /// let input_arg = vec![
+    ///     None,
+    ///     Some(vec![7, 8]),
+    ///     Some(vec![9, 10]),
+    ///     None,
+    ///     Some(vec![13, 14]),
+    ///     None,
+    /// ];
+    /// let array = FixedSizeBinaryArray::try_from_sparse_iter_with_size(input_arg.into_iter(), 2).unwrap();
+    /// ```
+    ///
+    /// # Errors
+    ///
+    /// Returns error if argument has length zero, or sizes of nested slices don't match.
+    pub fn try_from_sparse_iter_with_size<T, U>(mut iter: T, size: i32) -> Result<Self, ArrowError>
+    where
+        T: Iterator<Item = Option<U>>,
+        U: AsRef<[u8]>,
+    {
+        let mut len = 0;
+        let mut byte = 0;
+
+        let iter_size_hint = iter.size_hint().0;
+        let mut null_buf = MutableBuffer::new(bit_util::ceil(iter_size_hint, 8));
+        let mut buffer = MutableBuffer::new(iter_size_hint * (size as usize));
+
+        iter.try_for_each(|item| -> Result<(), ArrowError> {
+            // extend null bitmask by one byte per each 8 items
+            if byte == 0 {
+                null_buf.push(0u8);
+                byte = 8;
+            }
+            byte -= 1;
+
+            if let Some(slice) = item {
+                let slice = slice.as_ref();
+                if size as usize != slice.len() {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "Nested array size mismatch: one is {}, and the other is {}",
+                        size,
+                        slice.len()
+                    )));
+                }
+
+                bit_util::set_bit(null_buf.as_slice_mut(), len);
+                buffer.extend_from_slice(slice);
+            } else {
+                buffer.extend_zeros(size as usize);
+            }
+
+            len += 1;
+
+            Ok(())
+        })?;
+
+        let null_buf = BooleanBuffer::new(null_buf.into(), 0, len);
+        let nulls = Some(NullBuffer::new(null_buf)).filter(|n| n.null_count() > 0);
+
+        Ok(Self {
+            data_type: DataType::FixedSizeBinary(size),
+            value_data: buffer.into(),
+            nulls,
+            len,
+            value_length: size,
+        })
     }
 
     /// Create an array from an iterable argument of byte slices.
@@ -201,7 +388,7 @@ impl FixedSizeBinaryArray {
     /// # Examples
     ///
     /// ```
-    /// use arrow::array::FixedSizeBinaryArray;
+    /// use arrow_array::FixedSizeBinaryArray;
     /// let input_arg = vec![
     ///     vec![1, 2],
     ///     vec![3, 4],
@@ -213,15 +400,17 @@ impl FixedSizeBinaryArray {
     /// # Errors
     ///
     /// Returns error if argument has length zero, or sizes of nested slices don't match.
-    pub fn try_from_iter<T, U>(mut iter: T) -> Result<Self>
+    pub fn try_from_iter<T, U>(mut iter: T) -> Result<Self, ArrowError>
     where
         T: Iterator<Item = U>,
         U: AsRef<[u8]>,
     {
         let mut len = 0;
         let mut size = None;
-        let mut buffer = MutableBuffer::from_len_zeroed(0);
-        iter.try_for_each(|item| -> Result<()> {
+        let iter_size_hint = iter.size_hint().0;
+        let mut buffer = MutableBuffer::new(0);
+
+        iter.try_for_each(|item| -> Result<(), ArrowError> {
             let slice = item.as_ref();
             if let Some(size) = size {
                 if size != slice.len() {
@@ -232,8 +421,11 @@ impl FixedSizeBinaryArray {
                     )));
                 }
             } else {
-                size = Some(slice.len());
+                let len = slice.len();
+                size = Some(len);
+                buffer.reserve(iter_size_hint * len);
             }
+
             buffer.extend_from_slice(slice);
 
             len += 1;
@@ -247,17 +439,24 @@ impl FixedSizeBinaryArray {
             ));
         }
 
-        let size = size.unwrap_or(0);
-        let array_data = ArrayData::builder(DataType::FixedSizeBinary(size as i32))
-            .len(len)
-            .add_buffer(buffer.into());
-        let array_data = unsafe { array_data.build_unchecked() };
-        Ok(FixedSizeBinaryArray::from(array_data))
+        let size = size.unwrap_or(0).try_into().unwrap();
+        Ok(Self {
+            data_type: DataType::FixedSizeBinary(size),
+            value_data: buffer.into(),
+            nulls: None,
+            value_length: size,
+            len,
+        })
     }
 
     #[inline]
     fn value_offset_at(&self, i: usize) -> i32 {
-        self.length * i as i32
+        self.value_length * i as i32
+    }
+
+    /// constructs a new iterator
+    pub fn iter(&self) -> FixedSizeBinaryIter<'_> {
+        FixedSizeBinaryIter::new(self)
     }
 }
 
@@ -268,35 +467,48 @@ impl From<ArrayData> for FixedSizeBinaryArray {
             1,
             "FixedSizeBinaryArray data should contain 1 buffer only (values)"
         );
-        let value_data = data.buffers()[0].as_ptr();
-        let length = match data.data_type() {
+        let value_length = match data.data_type() {
             DataType::FixedSizeBinary(len) => *len,
             _ => panic!("Expected data type to be FixedSizeBinary"),
         };
+
+        let size = value_length as usize;
+        let value_data =
+            data.buffers()[0].slice_with_length(data.offset() * size, data.len() * size);
+
         Self {
-            data,
-            value_data: unsafe { RawPtrBox::new(value_data) },
-            length,
+            data_type: data.data_type().clone(),
+            nulls: data.nulls().cloned(),
+            len: data.len(),
+            value_data,
+            value_length,
         }
     }
 }
 
 impl From<FixedSizeBinaryArray> for ArrayData {
     fn from(array: FixedSizeBinaryArray) -> Self {
-        array.data
+        let builder = ArrayDataBuilder::new(array.data_type)
+            .len(array.len)
+            .buffers(vec![array.value_data])
+            .nulls(array.nulls);
+
+        unsafe { builder.build_unchecked() }
     }
 }
 
 /// Creates a `FixedSizeBinaryArray` from `FixedSizeList<u8>` array
 impl From<FixedSizeListArray> for FixedSizeBinaryArray {
     fn from(v: FixedSizeListArray) -> Self {
+        let value_len = v.value_length();
+        let v = v.into_data();
         assert_eq!(
-            v.data_ref().child_data().len(),
+            v.child_data().len(),
             1,
             "FixedSizeBinaryArray can only be created from list array of u8 values \
              (i.e. FixedSizeList<PrimitiveArray<u8>>)."
         );
-        let child_data = &v.data_ref().child_data()[0];
+        let child_data = &v.child_data()[0];
 
         assert_eq!(
             child_data.child_data().len(),
@@ -315,11 +527,11 @@ impl From<FixedSizeListArray> for FixedSizeBinaryArray {
             "The child array cannot contain null values."
         );
 
-        let builder = ArrayData::builder(DataType::FixedSizeBinary(v.value_length()))
+        let builder = ArrayData::builder(DataType::FixedSizeBinary(value_len))
             .len(v.len())
             .offset(v.offset())
             .add_buffer(child_data.buffers()[0].slice(child_data.offset()))
-            .null_bit_buffer(v.data_ref().null_buffer().cloned());
+            .nulls(v.nulls().cloned());
 
         let data = unsafe { builder.build_unchecked() };
         Self::from(data)
@@ -328,6 +540,7 @@ impl From<FixedSizeListArray> for FixedSizeBinaryArray {
 
 impl From<Vec<Option<&[u8]>>> for FixedSizeBinaryArray {
     fn from(v: Vec<Option<&[u8]>>) -> Self {
+        #[allow(deprecated)]
         Self::try_from_sparse_iter(v.into_iter()).unwrap()
     }
 }
@@ -338,11 +551,11 @@ impl From<Vec<&[u8]>> for FixedSizeBinaryArray {
     }
 }
 
-impl fmt::Debug for FixedSizeBinaryArray {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl std::fmt::Debug for FixedSizeBinaryArray {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "FixedSizeBinaryArray<{}>\n[\n", self.value_length())?;
         print_long_array(self, f, |array, index, f| {
-            fmt::Debug::fmt(&array.value(index), f)
+            std::fmt::Debug::fmt(&array.value(index), f)
         })?;
         write!(f, "]")
     }
@@ -353,24 +566,78 @@ impl Array for FixedSizeBinaryArray {
         self
     }
 
-    fn data(&self) -> &ArrayData {
-        &self.data
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
     }
 
     fn into_data(self) -> ArrayData {
         self.into()
     }
+
+    fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.len
+    }
+
+    fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    fn offset(&self) -> usize {
+        0
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.nulls.as_ref()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        let mut sum = self.value_data.capacity();
+        if let Some(n) = &self.nulls {
+            sum += n.buffer().capacity();
+        }
+        sum
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        std::mem::size_of::<Self>() + self.get_buffer_memory_size()
+    }
+}
+
+impl<'a> ArrayAccessor for &'a FixedSizeBinaryArray {
+    type Item = &'a [u8];
+
+    fn value(&self, index: usize) -> Self::Item {
+        FixedSizeBinaryArray::value(self, index)
+    }
+
+    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
+        FixedSizeBinaryArray::value_unchecked(self, index)
+    }
+}
+
+impl<'a> IntoIterator for &'a FixedSizeBinaryArray {
+    type Item = Option<&'a [u8]>;
+    type IntoIter = FixedSizeBinaryIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        FixedSizeBinaryIter::<'a>::new(self)
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    use crate::RecordBatch;
+    use arrow_schema::{Field, Schema};
     use std::sync::Arc;
 
-    use crate::{
-        datatypes::{Field, Schema},
-        record_batch::RecordBatch,
-    };
-
     use super::*;
 
     #[test]
@@ -421,9 +688,9 @@ mod tests {
             fixed_size_binary_array.value(1)
         );
         assert_eq!(2, fixed_size_binary_array.len());
-        assert_eq!(5, fixed_size_binary_array.value_offset(0));
+        assert_eq!(0, fixed_size_binary_array.value_offset(0));
         assert_eq!(5, fixed_size_binary_array.value_length());
-        assert_eq!(10, fixed_size_binary_array.value_offset(1));
+        assert_eq!(5, fixed_size_binary_array.value_offset(1));
     }
 
     #[test]
@@ -432,19 +699,19 @@ mod tests {
         let values_data = ArrayData::builder(DataType::UInt8)
             .len(12)
             .offset(2)
-            .add_buffer(Buffer::from_slice_ref(&values))
+            .add_buffer(Buffer::from_slice_ref(values))
             .build()
             .unwrap();
         // [null, [10, 11, 12, 13]]
         let array_data = unsafe {
             ArrayData::builder(DataType::FixedSizeList(
-                Box::new(Field::new("item", DataType::UInt8, false)),
+                Arc::new(Field::new("item", DataType::UInt8, false)),
                 4,
             ))
             .len(2)
             .offset(1)
             .add_child_data(values_data)
-            .null_bit_buffer(Some(Buffer::from_slice_ref(&[0b101])))
+            .null_bit_buffer(Some(Buffer::from_slice_ref([0b101])))
             .build_unchecked()
         };
         let list_array = FixedSizeListArray::from(array_data);
@@ -468,13 +735,13 @@ mod tests {
         let values: [u32; 12] = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
         let values_data = ArrayData::builder(DataType::UInt32)
             .len(12)
-            .add_buffer(Buffer::from_slice_ref(&values))
+            .add_buffer(Buffer::from_slice_ref(values))
             .build()
             .unwrap();
 
         let array_data = unsafe {
             ArrayData::builder(DataType::FixedSizeList(
-                Box::new(Field::new("item", DataType::Binary, false)),
+                Arc::new(Field::new("item", DataType::Binary, false)),
                 4,
             ))
             .len(3)
@@ -491,14 +758,14 @@ mod tests {
         let values = [0_u8, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11];
         let values_data = ArrayData::builder(DataType::UInt8)
             .len(12)
-            .add_buffer(Buffer::from_slice_ref(&values))
-            .null_bit_buffer(Some(Buffer::from_slice_ref(&[0b101010101010])))
+            .add_buffer(Buffer::from_slice_ref(values))
+            .null_bit_buffer(Some(Buffer::from_slice_ref([0b101010101010])))
             .build()
             .unwrap();
 
         let array_data = unsafe {
             ArrayData::builder(DataType::FixedSizeList(
-                Box::new(Field::new("item", DataType::UInt8, false)),
+                Arc::new(Field::new("item", DataType::UInt8, false)),
                 4,
             ))
             .len(3)
@@ -521,7 +788,7 @@ mod tests {
         let arr = FixedSizeBinaryArray::from(array_data);
         assert_eq!(
             "FixedSizeBinaryArray<5>\n[\n  [104, 101, 108, 108, 111],\n  [116, 104, 101, 114, 101],\n  [97, 114, 114, 111, 119],\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -538,8 +805,8 @@ mod tests {
     fn test_all_none_fixed_size_binary_array_from_sparse_iter() {
         let none_option: Option<[u8; 32]> = None;
         let input_arg = vec![none_option, none_option, none_option];
-        let arr =
-            FixedSizeBinaryArray::try_from_sparse_iter(input_arg.into_iter()).unwrap();
+        #[allow(deprecated)]
+        let arr = FixedSizeBinaryArray::try_from_sparse_iter(input_arg.into_iter()).unwrap();
         assert_eq!(0, arr.value_length());
         assert_eq!(3, arr.len())
     }
@@ -553,9 +820,24 @@ mod tests {
             None,
             Some(vec![13, 14]),
         ];
+        #[allow(deprecated)]
+        let arr = FixedSizeBinaryArray::try_from_sparse_iter(input_arg.iter().cloned()).unwrap();
+        assert_eq!(2, arr.value_length());
+        assert_eq!(5, arr.len());
+
         let arr =
-            FixedSizeBinaryArray::try_from_sparse_iter(input_arg.into_iter()).unwrap();
+            FixedSizeBinaryArray::try_from_sparse_iter_with_size(input_arg.into_iter(), 2).unwrap();
         assert_eq!(2, arr.value_length());
+        assert_eq!(5, arr.len());
+    }
+
+    #[test]
+    fn test_fixed_size_binary_array_from_sparse_iter_with_size_all_none() {
+        let input_arg = vec![None, None, None, None, None] as Vec<Option<Vec<u8>>>;
+
+        let arr = FixedSizeBinaryArray::try_from_sparse_iter_with_size(input_arg.into_iter(), 16)
+            .unwrap();
+        assert_eq!(16, arr.value_length());
         assert_eq!(5, arr.len())
     }
 
@@ -620,29 +902,65 @@ mod tests {
     #[test]
     fn fixed_size_binary_array_all_null() {
         let data = vec![None] as Vec<Option<String>>;
-        let array = FixedSizeBinaryArray::try_from_sparse_iter(data.into_iter()).unwrap();
+        let array =
+            FixedSizeBinaryArray::try_from_sparse_iter_with_size(data.into_iter(), 0).unwrap();
         array
-            .data()
+            .into_data()
             .validate_full()
             .expect("All null array has valid array data");
     }
 
     #[test]
     // Test for https://github.com/apache/arrow-rs/issues/1390
-    #[should_panic(
-        expected = "column types must match schema types, expected FixedSizeBinary(2) but found FixedSizeBinary(0) at column index 0"
-    )]
     fn fixed_size_binary_array_all_null_in_batch_with_schema() {
-        let schema =
-            Schema::new(vec![Field::new("a", DataType::FixedSizeBinary(2), true)]);
+        let schema = Schema::new(vec![Field::new("a", DataType::FixedSizeBinary(2), true)]);
 
         let none_option: Option<[u8; 2]> = None;
-        let item = FixedSizeBinaryArray::try_from_sparse_iter(
+        let item = FixedSizeBinaryArray::try_from_sparse_iter_with_size(
             vec![none_option, none_option, none_option].into_iter(),
+            2,
         )
         .unwrap();
 
         // Should not panic
         RecordBatch::try_new(Arc::new(schema), vec![Arc::new(item)]).unwrap();
     }
+
+    #[test]
+    #[should_panic(
+        expected = "Trying to access an element at index 4 from a FixedSizeBinaryArray of length 3"
+    )]
+    fn test_fixed_size_binary_array_get_value_index_out_of_bound() {
+        let values = vec![Some("one".as_bytes()), Some(b"two"), None];
+        let array = FixedSizeBinaryArray::from(values);
+
+        array.value(4);
+    }
+
+    #[test]
+    fn test_constructors() {
+        let buffer = Buffer::from_vec(vec![0_u8; 10]);
+        let a = FixedSizeBinaryArray::new(2, buffer.clone(), None);
+        assert_eq!(a.len(), 5);
+
+        let nulls = NullBuffer::new_null(5);
+        FixedSizeBinaryArray::new(2, buffer.clone(), Some(nulls));
+
+        let a = FixedSizeBinaryArray::new(3, buffer.clone(), None);
+        assert_eq!(a.len(), 3);
+
+        let nulls = NullBuffer::new_null(3);
+        FixedSizeBinaryArray::new(3, buffer.clone(), Some(nulls));
+
+        let err = FixedSizeBinaryArray::try_new(-1, buffer.clone(), None).unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Size cannot be negative, got -1"
+        );
+
+        let nulls = NullBuffer::new_null(3);
+        let err = FixedSizeBinaryArray::try_new(2, buffer, Some(nulls)).unwrap_err();
+        assert_eq!(err.to_string(), "Invalid argument error: Incorrect length of null buffer for FixedSizeBinaryArray, expected 5 got 3");
+    }
 }
diff --git a/arrow-array/src/array/fixed_size_list_array.rs b/arrow-array/src/array/fixed_size_list_array.rs
new file mode 100644
index 000000000000..f8f01516e3d4
--- /dev/null
+++ b/arrow-array/src/array/fixed_size_list_array.rs
@@ -0,0 +1,677 @@
+// 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.
+
+use crate::array::print_long_array;
+use crate::builder::{FixedSizeListBuilder, PrimitiveBuilder};
+use crate::iterator::FixedSizeListIter;
+use crate::{make_array, Array, ArrayAccessor, ArrayRef, ArrowPrimitiveType};
+use arrow_buffer::buffer::NullBuffer;
+use arrow_buffer::ArrowNativeType;
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType, FieldRef};
+use std::any::Any;
+use std::sync::Arc;
+
+/// An array of [fixed length lists], similar to JSON arrays
+/// (e.g. `["A", "B"]`).
+///
+/// Lists are represented using a `values` child
+/// array where each list has a fixed size of `value_length`.
+///
+/// Use [`FixedSizeListBuilder`] to construct a [`FixedSizeListArray`].
+///
+/// # Representation
+///
+/// A [`FixedSizeListArray`] can represent a list of values of any other
+/// supported Arrow type. Each element of the `FixedSizeListArray` itself is
+/// a list which may contain NULL and non-null values,
+/// or may itself be NULL.
+///
+/// For example, this `FixedSizeListArray` stores lists of strings:
+///
+/// ```text
+/// ┌─────────────┐
+/// │    [A,B]    │
+/// ├─────────────┤
+/// │    NULL     │
+/// ├─────────────┤
+/// │   [C,NULL]  │
+/// └─────────────┘
+/// ```
+///
+/// The `values` of this `FixedSizeListArray`s are stored in a child
+/// [`StringArray`] where logical null values take up `values_length` slots in the array
+/// as shown in the following diagram. The logical values
+/// are shown on the left, and the actual `FixedSizeListArray` encoding on the right
+///
+/// ```text
+///                                 ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┐
+///                                                         ┌ ─ ─ ─ ─ ─ ─ ─ ─┐    
+///  ┌─────────────┐                │     ┌───┐               ┌───┐ ┌──────┐      │
+///  │   [A,B]     │                      │ 1 │             │ │ 1 │ │  A   │ │ 0  
+///  ├─────────────┤                │     ├───┤               ├───┤ ├──────┤      │
+///  │    NULL     │                      │ 0 │             │ │ 1 │ │  B   │ │ 1  
+///  ├─────────────┤                │     ├───┤               ├───┤ ├──────┤      │
+///  │  [C,NULL]   │                      │ 1 │             │ │ 0 │ │ ???? │ │ 2  
+///  └─────────────┘                │     └───┘               ├───┤ ├──────┤      │
+///                                                         | │ 0 │ │ ???? │ │ 3  
+///  Logical Values                 │   Validity              ├───┤ ├──────┤      │
+///                                     (nulls)             │ │ 1 │ │  C   │ │ 4  
+///                                 │                         ├───┤ ├──────┤      │
+///                                                         │ │ 0 │ │ ???? │ │ 5  
+///                                 │                         └───┘ └──────┘      │
+///                                                         │     Values     │    
+///                                 │   FixedSizeListArray        (Array)         │
+///                                                         └ ─ ─ ─ ─ ─ ─ ─ ─┘    
+///                                 └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
+/// ```
+///
+/// # Example
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::{Array, FixedSizeListArray, Int32Array};
+/// # use arrow_data::ArrayData;
+/// # use arrow_schema::{DataType, Field};
+/// # use arrow_buffer::Buffer;
+/// // Construct a value array
+/// let value_data = ArrayData::builder(DataType::Int32)
+///     .len(9)
+///     .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8]))
+///     .build()
+///     .unwrap();
+/// let list_data_type = DataType::FixedSizeList(
+///     Arc::new(Field::new("item", DataType::Int32, false)),
+///     3,
+/// );
+/// let list_data = ArrayData::builder(list_data_type.clone())
+///     .len(3)
+///     .add_child_data(value_data.clone())
+///     .build()
+///     .unwrap();
+/// let list_array = FixedSizeListArray::from(list_data);
+/// let list0 = list_array.value(0);
+/// let list1 = list_array.value(1);
+/// let list2 = list_array.value(2);
+///
+/// assert_eq!( &[0, 1, 2], list0.as_any().downcast_ref::<Int32Array>().unwrap().values());
+/// assert_eq!( &[3, 4, 5], list1.as_any().downcast_ref::<Int32Array>().unwrap().values());
+/// assert_eq!( &[6, 7, 8], list2.as_any().downcast_ref::<Int32Array>().unwrap().values());
+/// ```
+///
+/// [`StringArray`]: crate::array::StringArray
+/// [fixed size arrays](https://arrow.apache.org/docs/format/Columnar.html#fixed-size-list-layout)
+#[derive(Clone)]
+pub struct FixedSizeListArray {
+    data_type: DataType, // Must be DataType::FixedSizeList(value_length)
+    values: ArrayRef,
+    nulls: Option<NullBuffer>,
+    value_length: i32,
+    len: usize,
+}
+
+impl FixedSizeListArray {
+    /// Create a new [`FixedSizeListArray`] with `size` element size, panicking on failure
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`Self::try_new`] returns an error
+    pub fn new(field: FieldRef, size: i32, values: ArrayRef, nulls: Option<NullBuffer>) -> Self {
+        Self::try_new(field, size, values, nulls).unwrap()
+    }
+
+    /// Create a new [`FixedSizeListArray`] from the provided parts, returning an error on failure
+    ///
+    /// # Errors
+    ///
+    /// * `size < 0`
+    /// * `values.len() / size != nulls.len()`
+    /// * `values.data_type() != field.data_type()`
+    /// * `!field.is_nullable() && !nulls.expand(size).contains(values.logical_nulls())`
+    pub fn try_new(
+        field: FieldRef,
+        size: i32,
+        values: ArrayRef,
+        nulls: Option<NullBuffer>,
+    ) -> Result<Self, ArrowError> {
+        let s = size.to_usize().ok_or_else(|| {
+            ArrowError::InvalidArgumentError(format!("Size cannot be negative, got {}", size))
+        })?;
+
+        let len = values.len() / s.max(1);
+        if let Some(n) = nulls.as_ref() {
+            if n.len() != len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Incorrect length of null buffer for FixedSizeListArray, expected {} got {}",
+                    len,
+                    n.len(),
+                )));
+            }
+        }
+
+        if field.data_type() != values.data_type() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "FixedSizeListArray expected data type {} got {} for {:?}",
+                field.data_type(),
+                values.data_type(),
+                field.name()
+            )));
+        }
+
+        if let Some(a) = values.logical_nulls() {
+            let nulls_valid = field.is_nullable()
+                || nulls
+                    .as_ref()
+                    .map(|n| n.expand(size as _).contains(&a))
+                    .unwrap_or_default();
+
+            if !nulls_valid {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Found unmasked nulls for non-nullable FixedSizeListArray field {:?}",
+                    field.name()
+                )));
+            }
+        }
+
+        let data_type = DataType::FixedSizeList(field, size);
+        Ok(Self {
+            data_type,
+            values,
+            value_length: size,
+            nulls,
+            len,
+        })
+    }
+
+    /// Create a new [`FixedSizeListArray`] of length `len` where all values are null
+    ///
+    /// # Panics
+    ///
+    /// Panics if
+    ///
+    /// * `size < 0`
+    /// * `size * len` would overflow `usize`
+    pub fn new_null(field: FieldRef, size: i32, len: usize) -> Self {
+        let capacity = size.to_usize().unwrap().checked_mul(len).unwrap();
+        Self {
+            values: make_array(ArrayData::new_null(field.data_type(), capacity)),
+            data_type: DataType::FixedSizeList(field, size),
+            nulls: Some(NullBuffer::new_null(len)),
+            value_length: size,
+            len,
+        }
+    }
+
+    /// Deconstruct this array into its constituent parts
+    pub fn into_parts(self) -> (FieldRef, i32, ArrayRef, Option<NullBuffer>) {
+        let f = match self.data_type {
+            DataType::FixedSizeList(f, _) => f,
+            _ => unreachable!(),
+        };
+        (f, self.value_length, self.values, self.nulls)
+    }
+
+    /// Returns a reference to the values of this list.
+    pub fn values(&self) -> &ArrayRef {
+        &self.values
+    }
+
+    /// Returns a clone of the value type of this list.
+    pub fn value_type(&self) -> DataType {
+        self.values.data_type().clone()
+    }
+
+    /// Returns ith value of this list array.
+    pub fn value(&self, i: usize) -> ArrayRef {
+        self.values
+            .slice(self.value_offset(i) as usize, self.value_length() as usize)
+    }
+
+    /// Returns the offset for value at index `i`.
+    ///
+    /// Note this doesn't do any bound checking, for performance reason.
+    #[inline]
+    pub fn value_offset(&self, i: usize) -> i32 {
+        self.value_offset_at(i)
+    }
+
+    /// Returns the length for an element.
+    ///
+    /// All elements have the same length as the array is a fixed size.
+    #[inline]
+    pub const fn value_length(&self) -> i32 {
+        self.value_length
+    }
+
+    #[inline]
+    const fn value_offset_at(&self, i: usize) -> i32 {
+        i as i32 * self.value_length
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, len: usize) -> Self {
+        assert!(
+            offset.saturating_add(len) <= self.len,
+            "the length + offset of the sliced FixedSizeListArray cannot exceed the existing length"
+        );
+        let size = self.value_length as usize;
+
+        Self {
+            data_type: self.data_type.clone(),
+            values: self.values.slice(offset * size, len * size),
+            nulls: self.nulls.as_ref().map(|n| n.slice(offset, len)),
+            value_length: self.value_length,
+            len,
+        }
+    }
+
+    /// Creates a [`FixedSizeListArray`] from an iterator of primitive values
+    /// # Example
+    /// ```
+    /// # use arrow_array::FixedSizeListArray;
+    /// # use arrow_array::types::Int32Type;
+    ///
+    /// let data = vec![
+    ///    Some(vec![Some(0), Some(1), Some(2)]),
+    ///    None,
+    ///    Some(vec![Some(3), None, Some(5)]),
+    ///    Some(vec![Some(6), Some(7), Some(45)]),
+    /// ];
+    /// let list_array = FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(data, 3);
+    /// println!("{:?}", list_array);
+    /// ```
+    pub fn from_iter_primitive<T, P, I>(iter: I, length: i32) -> Self
+    where
+        T: ArrowPrimitiveType,
+        P: IntoIterator<Item = Option<<T as ArrowPrimitiveType>::Native>>,
+        I: IntoIterator<Item = Option<P>>,
+    {
+        let l = length as usize;
+        let iter = iter.into_iter();
+        let size_hint = iter.size_hint().0;
+        let mut builder = FixedSizeListBuilder::with_capacity(
+            PrimitiveBuilder::<T>::with_capacity(size_hint * l),
+            length,
+            size_hint,
+        );
+
+        for i in iter {
+            match i {
+                Some(p) => {
+                    for t in p {
+                        builder.values().append_option(t);
+                    }
+                    builder.append(true);
+                }
+                None => {
+                    builder.values().append_nulls(l);
+                    builder.append(false)
+                }
+            }
+        }
+        builder.finish()
+    }
+
+    /// constructs a new iterator
+    pub fn iter(&self) -> FixedSizeListIter<'_> {
+        FixedSizeListIter::new(self)
+    }
+}
+
+impl From<ArrayData> for FixedSizeListArray {
+    fn from(data: ArrayData) -> Self {
+        let value_length = match data.data_type() {
+            DataType::FixedSizeList(_, len) => *len,
+            _ => {
+                panic!("FixedSizeListArray data should contain a FixedSizeList data type")
+            }
+        };
+
+        let size = value_length as usize;
+        let values =
+            make_array(data.child_data()[0].slice(data.offset() * size, data.len() * size));
+        Self {
+            data_type: data.data_type().clone(),
+            values,
+            nulls: data.nulls().cloned(),
+            value_length,
+            len: data.len(),
+        }
+    }
+}
+
+impl From<FixedSizeListArray> for ArrayData {
+    fn from(array: FixedSizeListArray) -> Self {
+        let builder = ArrayDataBuilder::new(array.data_type)
+            .len(array.len)
+            .nulls(array.nulls)
+            .child_data(vec![array.values.to_data()]);
+
+        unsafe { builder.build_unchecked() }
+    }
+}
+
+impl Array for FixedSizeListArray {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.into()
+    }
+
+    fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.len
+    }
+
+    fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    fn offset(&self) -> usize {
+        0
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.nulls.as_ref()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        let mut size = self.values.get_buffer_memory_size();
+        if let Some(n) = self.nulls.as_ref() {
+            size += n.buffer().capacity();
+        }
+        size
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        let mut size = std::mem::size_of::<Self>() + self.values.get_array_memory_size();
+        if let Some(n) = self.nulls.as_ref() {
+            size += n.buffer().capacity();
+        }
+        size
+    }
+}
+
+impl ArrayAccessor for FixedSizeListArray {
+    type Item = ArrayRef;
+
+    fn value(&self, index: usize) -> Self::Item {
+        FixedSizeListArray::value(self, index)
+    }
+
+    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
+        FixedSizeListArray::value(self, index)
+    }
+}
+
+impl std::fmt::Debug for FixedSizeListArray {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "FixedSizeListArray<{}>\n[\n", self.value_length())?;
+        print_long_array(self, f, |array, index, f| {
+            std::fmt::Debug::fmt(&array.value(index), f)
+        })?;
+        write!(f, "]")
+    }
+}
+
+impl<'a> ArrayAccessor for &'a FixedSizeListArray {
+    type Item = ArrayRef;
+
+    fn value(&self, index: usize) -> Self::Item {
+        FixedSizeListArray::value(self, index)
+    }
+
+    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
+        FixedSizeListArray::value(self, index)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow_buffer::{bit_util, BooleanBuffer, Buffer};
+    use arrow_schema::Field;
+
+    use crate::cast::AsArray;
+    use crate::types::Int32Type;
+    use crate::Int32Array;
+
+    use super::*;
+
+    #[test]
+    fn test_fixed_size_list_array() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(9)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7, 8]))
+            .build()
+            .unwrap();
+
+        // Construct a list array from the above two
+        let list_data_type =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, false)), 3);
+        let list_data = ArrayData::builder(list_data_type.clone())
+            .len(3)
+            .add_child_data(value_data.clone())
+            .build()
+            .unwrap();
+        let list_array = FixedSizeListArray::from(list_data);
+
+        assert_eq!(value_data, list_array.values().to_data());
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(3, list_array.len());
+        assert_eq!(0, list_array.null_count());
+        assert_eq!(6, list_array.value_offset(2));
+        assert_eq!(3, list_array.value_length());
+        assert_eq!(0, list_array.value(0).as_primitive::<Int32Type>().value(0));
+        for i in 0..3 {
+            assert!(list_array.is_valid(i));
+            assert!(!list_array.is_null(i));
+        }
+
+        // Now test with a non-zero offset
+        let list_data = ArrayData::builder(list_data_type)
+            .len(2)
+            .offset(1)
+            .add_child_data(value_data.clone())
+            .build()
+            .unwrap();
+        let list_array = FixedSizeListArray::from(list_data);
+
+        assert_eq!(value_data.slice(3, 6), list_array.values().to_data());
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(2, list_array.len());
+        assert_eq!(0, list_array.null_count());
+        assert_eq!(3, list_array.value(0).as_primitive::<Int32Type>().value(0));
+        assert_eq!(3, list_array.value_offset(1));
+        assert_eq!(3, list_array.value_length());
+    }
+
+    #[test]
+    #[should_panic(expected = "assertion failed: (offset + length) <= self.len()")]
+    // Different error messages, so skip for now
+    // https://github.com/apache/arrow-rs/issues/1545
+    #[cfg(not(feature = "force_validate"))]
+    fn test_fixed_size_list_array_unequal_children() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(8)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+            .build()
+            .unwrap();
+
+        // Construct a list array from the above two
+        let list_data_type =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, false)), 3);
+        let list_data = unsafe {
+            ArrayData::builder(list_data_type)
+                .len(3)
+                .add_child_data(value_data)
+                .build_unchecked()
+        };
+        drop(FixedSizeListArray::from(list_data));
+    }
+
+    #[test]
+    fn test_fixed_size_list_array_slice() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(10)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
+            .build()
+            .unwrap();
+
+        // Set null buts for the nested array:
+        //  [[0, 1], null, null, [6, 7], [8, 9]]
+        // 01011001 00000001
+        let mut null_bits: [u8; 1] = [0; 1];
+        bit_util::set_bit(&mut null_bits, 0);
+        bit_util::set_bit(&mut null_bits, 3);
+        bit_util::set_bit(&mut null_bits, 4);
+
+        // Construct a fixed size list array from the above two
+        let list_data_type =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, false)), 2);
+        let list_data = ArrayData::builder(list_data_type)
+            .len(5)
+            .add_child_data(value_data.clone())
+            .null_bit_buffer(Some(Buffer::from(null_bits)))
+            .build()
+            .unwrap();
+        let list_array = FixedSizeListArray::from(list_data);
+
+        assert_eq!(value_data, list_array.values().to_data());
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(5, list_array.len());
+        assert_eq!(2, list_array.null_count());
+        assert_eq!(6, list_array.value_offset(3));
+        assert_eq!(2, list_array.value_length());
+
+        let sliced_array = list_array.slice(1, 4);
+        assert_eq!(4, sliced_array.len());
+        assert_eq!(2, sliced_array.null_count());
+
+        for i in 0..sliced_array.len() {
+            if bit_util::get_bit(&null_bits, 1 + i) {
+                assert!(sliced_array.is_valid(i));
+            } else {
+                assert!(sliced_array.is_null(i));
+            }
+        }
+
+        // Check offset and length for each non-null value.
+        let sliced_list_array = sliced_array
+            .as_any()
+            .downcast_ref::<FixedSizeListArray>()
+            .unwrap();
+        assert_eq!(2, sliced_list_array.value_length());
+        assert_eq!(4, sliced_list_array.value_offset(2));
+        assert_eq!(6, sliced_list_array.value_offset(3));
+    }
+
+    #[test]
+    #[should_panic(expected = "the offset of the new Buffer cannot exceed the existing length")]
+    fn test_fixed_size_list_array_index_out_of_bound() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(10)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
+            .build()
+            .unwrap();
+
+        // Set null buts for the nested array:
+        //  [[0, 1], null, null, [6, 7], [8, 9]]
+        // 01011001 00000001
+        let mut null_bits: [u8; 1] = [0; 1];
+        bit_util::set_bit(&mut null_bits, 0);
+        bit_util::set_bit(&mut null_bits, 3);
+        bit_util::set_bit(&mut null_bits, 4);
+
+        // Construct a fixed size list array from the above two
+        let list_data_type =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, false)), 2);
+        let list_data = ArrayData::builder(list_data_type)
+            .len(5)
+            .add_child_data(value_data)
+            .null_bit_buffer(Some(Buffer::from(null_bits)))
+            .build()
+            .unwrap();
+        let list_array = FixedSizeListArray::from(list_data);
+
+        list_array.value(10);
+    }
+
+    #[test]
+    fn test_fixed_size_list_constructors() {
+        let values = Arc::new(Int32Array::from_iter([
+            Some(1),
+            Some(2),
+            None,
+            None,
+            Some(3),
+            Some(4),
+        ]));
+
+        let field = Arc::new(Field::new("item", DataType::Int32, true));
+        let list = FixedSizeListArray::new(field.clone(), 2, values.clone(), None);
+        assert_eq!(list.len(), 3);
+
+        let nulls = NullBuffer::new_null(3);
+        let list = FixedSizeListArray::new(field.clone(), 2, values.clone(), Some(nulls));
+        assert_eq!(list.len(), 3);
+
+        let list = FixedSizeListArray::new(field.clone(), 4, values.clone(), None);
+        assert_eq!(list.len(), 1);
+
+        let err = FixedSizeListArray::try_new(field.clone(), -1, values.clone(), None).unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Size cannot be negative, got -1"
+        );
+
+        let list = FixedSizeListArray::new(field.clone(), 0, values.clone(), None);
+        assert_eq!(list.len(), 6);
+
+        let nulls = NullBuffer::new_null(2);
+        let err = FixedSizeListArray::try_new(field, 2, values.clone(), Some(nulls)).unwrap_err();
+        assert_eq!(err.to_string(), "Invalid argument error: Incorrect length of null buffer for FixedSizeListArray, expected 3 got 2");
+
+        let field = Arc::new(Field::new("item", DataType::Int32, false));
+        let err = FixedSizeListArray::try_new(field.clone(), 2, values.clone(), None).unwrap_err();
+        assert_eq!(err.to_string(), "Invalid argument error: Found unmasked nulls for non-nullable FixedSizeListArray field \"item\"");
+
+        // Valid as nulls in child masked by parent
+        let nulls = NullBuffer::new(BooleanBuffer::new(vec![0b0000101].into(), 0, 3));
+        FixedSizeListArray::new(field, 2, values.clone(), Some(nulls));
+
+        let field = Arc::new(Field::new("item", DataType::Int64, true));
+        let err = FixedSizeListArray::try_new(field, 2, values, None).unwrap_err();
+        assert_eq!(err.to_string(), "Invalid argument error: FixedSizeListArray expected data type Int64 got Int32 for \"item\"");
+    }
+}
diff --git a/arrow-array/src/array/list_array.rs b/arrow-array/src/array/list_array.rs
new file mode 100644
index 000000000000..ba3719392ebe
--- /dev/null
+++ b/arrow-array/src/array/list_array.rs
@@ -0,0 +1,1224 @@
+// 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.
+
+use crate::array::{get_offsets, make_array, print_long_array};
+use crate::builder::{GenericListBuilder, PrimitiveBuilder};
+use crate::{
+    iterator::GenericListArrayIter, new_empty_array, Array, ArrayAccessor, ArrayRef,
+    ArrowPrimitiveType, FixedSizeListArray,
+};
+use arrow_buffer::{ArrowNativeType, NullBuffer, OffsetBuffer};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType, FieldRef};
+use num::Integer;
+use std::any::Any;
+use std::sync::Arc;
+
+/// A type that can be used within a variable-size array to encode offset information
+///
+/// See [`ListArray`], [`LargeListArray`], [`BinaryArray`], [`LargeBinaryArray`],
+/// [`StringArray`] and [`LargeStringArray`]
+///
+/// [`BinaryArray`]: crate::array::BinaryArray
+/// [`LargeBinaryArray`]: crate::array::LargeBinaryArray
+/// [`StringArray`]: crate::array::StringArray
+/// [`LargeStringArray`]: crate::array::LargeStringArray
+pub trait OffsetSizeTrait: ArrowNativeType + std::ops::AddAssign + Integer {
+    /// True for 64 bit offset size and false for 32 bit offset size
+    const IS_LARGE: bool;
+    /// Prefix for the offset size
+    const PREFIX: &'static str;
+}
+
+impl OffsetSizeTrait for i32 {
+    const IS_LARGE: bool = false;
+    const PREFIX: &'static str = "";
+}
+
+impl OffsetSizeTrait for i64 {
+    const IS_LARGE: bool = true;
+    const PREFIX: &'static str = "Large";
+}
+
+/// An array of [variable length lists], similar to JSON arrays
+/// (e.g. `["A", "B", "C"]`).
+///
+/// Lists are represented using `offsets` into a `values` child
+/// array. Offsets are stored in two adjacent entries of an
+/// [`OffsetBuffer`].
+///
+/// Arrow defines [`ListArray`] with `i32` offsets and
+/// [`LargeListArray`] with `i64` offsets.
+///
+/// Use [`GenericListBuilder`] to construct a [`GenericListArray`].
+///
+/// # Representation
+///
+/// A [`ListArray`] can represent a list of values of any other
+/// supported Arrow type. Each element of the `ListArray` itself is
+/// a list which may be empty, may contain NULL and non-null values,
+/// or may itself be NULL.
+///
+/// For example, the `ListArray` shown in the following diagram stores
+/// lists of strings. Note that `[]` represents an empty (length
+/// 0), but non NULL list.
+///
+/// ```text
+/// ┌─────────────┐
+/// │   [A,B,C]   │
+/// ├─────────────┤
+/// │     []      │
+/// ├─────────────┤
+/// │    NULL     │
+/// ├─────────────┤
+/// │     [D]     │
+/// ├─────────────┤
+/// │  [NULL, F]  │
+/// └─────────────┘
+/// ```
+///
+/// The `values` are stored in a child [`StringArray`] and the offsets
+/// are stored in an [`OffsetBuffer`] as shown in the following
+/// diagram. The logical values and offsets are shown on the left, and
+/// the actual `ListArray` encoding on the right.
+///
+/// ```text
+///                                         ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+///                                                                 ┌ ─ ─ ─ ─ ─ ─ ┐    │
+///  ┌─────────────┐  ┌───────┐             │     ┌───┐   ┌───┐       ┌───┐ ┌───┐
+///  │   [A,B,C]   │  │ (0,3) │                   │ 1 │   │ 0 │     │ │ 1 │ │ A │ │ 0  │
+///  ├─────────────┤  ├───────┤             │     ├───┤   ├───┤       ├───┤ ├───┤
+///  │      []     │  │ (3,3) │                   │ 1 │   │ 3 │     │ │ 1 │ │ B │ │ 1  │
+///  ├─────────────┤  ├───────┤             │     ├───┤   ├───┤       ├───┤ ├───┤
+///  │    NULL     │  │ (3,4) │                   │ 0 │   │ 3 │     │ │ 1 │ │ C │ │ 2  │
+///  ├─────────────┤  ├───────┤             │     ├───┤   ├───┤       ├───┤ ├───┤
+///  │     [D]     │  │ (4,5) │                   │ 1 │   │ 4 │     │ │ ? │ │ ? │ │ 3  │
+///  ├─────────────┤  ├───────┤             │     ├───┤   ├───┤       ├───┤ ├───┤
+///  │  [NULL, F]  │  │ (5,7) │                   │ 1 │   │ 5 │     │ │ 1 │ │ D │ │ 4  │
+///  └─────────────┘  └───────┘             │     └───┘   ├───┤       ├───┤ ├───┤
+///                                                       │ 7 │     │ │ 0 │ │ ? │ │ 5  │
+///                                         │  Validity   └───┘       ├───┤ ├───┤
+///     Logical       Logical                  (nulls)   Offsets    │ │ 1 │ │ F │ │ 6  │
+///      Values       Offsets               │                         └───┘ └───┘
+///                                                                 │    Values   │    │
+///                 (offsets[i],            │   ListArray               (Array)
+///                offsets[i+1])                                    └ ─ ─ ─ ─ ─ ─ ┘    │
+///                                         └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
+///
+///
+/// ```
+///
+/// [`StringArray`]: crate::array::StringArray
+/// [variable length lists]: https://arrow.apache.org/docs/format/Columnar.html#variable-size-list-layout
+pub struct GenericListArray<OffsetSize: OffsetSizeTrait> {
+    data_type: DataType,
+    nulls: Option<NullBuffer>,
+    values: ArrayRef,
+    value_offsets: OffsetBuffer<OffsetSize>,
+}
+
+impl<OffsetSize: OffsetSizeTrait> Clone for GenericListArray<OffsetSize> {
+    fn clone(&self) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            nulls: self.nulls.clone(),
+            values: self.values.clone(),
+            value_offsets: self.value_offsets.clone(),
+        }
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait> GenericListArray<OffsetSize> {
+    /// The data type constructor of list array.
+    /// The input is the schema of the child array and
+    /// the output is the [`DataType`], List or LargeList.
+    pub const DATA_TYPE_CONSTRUCTOR: fn(FieldRef) -> DataType = if OffsetSize::IS_LARGE {
+        DataType::LargeList
+    } else {
+        DataType::List
+    };
+
+    /// Create a new [`GenericListArray`] from the provided parts
+    ///
+    /// # Errors
+    ///
+    /// Errors if
+    ///
+    /// * `offsets.len() - 1 != nulls.len()`
+    /// * `offsets.last() > values.len()`
+    /// * `!field.is_nullable() && values.is_nullable()`
+    /// * `field.data_type() != values.data_type()`
+    pub fn try_new(
+        field: FieldRef,
+        offsets: OffsetBuffer<OffsetSize>,
+        values: ArrayRef,
+        nulls: Option<NullBuffer>,
+    ) -> Result<Self, ArrowError> {
+        let len = offsets.len() - 1; // Offsets guaranteed to not be empty
+        let end_offset = offsets.last().unwrap().as_usize();
+        // don't need to check other values of `offsets` because they are checked
+        // during construction of `OffsetBuffer`
+        if end_offset > values.len() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Max offset of {end_offset} exceeds length of values {}",
+                values.len()
+            )));
+        }
+
+        if let Some(n) = nulls.as_ref() {
+            if n.len() != len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Incorrect length of null buffer for {}ListArray, expected {len} got {}",
+                    OffsetSize::PREFIX,
+                    n.len(),
+                )));
+            }
+        }
+        if !field.is_nullable() && values.is_nullable() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Non-nullable field of {}ListArray {:?} cannot contain nulls",
+                OffsetSize::PREFIX,
+                field.name()
+            )));
+        }
+
+        if field.data_type() != values.data_type() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "{}ListArray expected data type {} got {} for {:?}",
+                OffsetSize::PREFIX,
+                field.data_type(),
+                values.data_type(),
+                field.name()
+            )));
+        }
+
+        Ok(Self {
+            data_type: Self::DATA_TYPE_CONSTRUCTOR(field),
+            nulls,
+            values,
+            value_offsets: offsets,
+        })
+    }
+
+    /// Create a new [`GenericListArray`] from the provided parts
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`Self::try_new`] returns an error
+    pub fn new(
+        field: FieldRef,
+        offsets: OffsetBuffer<OffsetSize>,
+        values: ArrayRef,
+        nulls: Option<NullBuffer>,
+    ) -> Self {
+        Self::try_new(field, offsets, values, nulls).unwrap()
+    }
+
+    /// Create a new [`GenericListArray`] of length `len` where all values are null
+    pub fn new_null(field: FieldRef, len: usize) -> Self {
+        let values = new_empty_array(field.data_type());
+        Self {
+            data_type: Self::DATA_TYPE_CONSTRUCTOR(field),
+            nulls: Some(NullBuffer::new_null(len)),
+            value_offsets: OffsetBuffer::new_zeroed(len),
+            values,
+        }
+    }
+
+    /// Deconstruct this array into its constituent parts
+    pub fn into_parts(
+        self,
+    ) -> (
+        FieldRef,
+        OffsetBuffer<OffsetSize>,
+        ArrayRef,
+        Option<NullBuffer>,
+    ) {
+        let f = match self.data_type {
+            DataType::List(f) | DataType::LargeList(f) => f,
+            _ => unreachable!(),
+        };
+        (f, self.value_offsets, self.values, self.nulls)
+    }
+
+    /// Returns a reference to the offsets of this list
+    ///
+    /// Unlike [`Self::value_offsets`] this returns the [`OffsetBuffer`]
+    /// allowing for zero-copy cloning
+    #[inline]
+    pub fn offsets(&self) -> &OffsetBuffer<OffsetSize> {
+        &self.value_offsets
+    }
+
+    /// Returns a reference to the values of this list
+    #[inline]
+    pub fn values(&self) -> &ArrayRef {
+        &self.values
+    }
+
+    /// Returns a clone of the value type of this list.
+    pub fn value_type(&self) -> DataType {
+        self.values.data_type().clone()
+    }
+
+    /// Returns ith value of this list array.
+    /// # Safety
+    /// Caller must ensure that the index is within the array bounds
+    pub unsafe fn value_unchecked(&self, i: usize) -> ArrayRef {
+        let end = self.value_offsets().get_unchecked(i + 1).as_usize();
+        let start = self.value_offsets().get_unchecked(i).as_usize();
+        self.values.slice(start, end - start)
+    }
+
+    /// Returns ith value of this list array.
+    pub fn value(&self, i: usize) -> ArrayRef {
+        let end = self.value_offsets()[i + 1].as_usize();
+        let start = self.value_offsets()[i].as_usize();
+        self.values.slice(start, end - start)
+    }
+
+    /// Returns the offset values in the offsets buffer
+    #[inline]
+    pub fn value_offsets(&self) -> &[OffsetSize] {
+        &self.value_offsets
+    }
+
+    /// Returns the length for value at index `i`.
+    #[inline]
+    pub fn value_length(&self, i: usize) -> OffsetSize {
+        let offsets = self.value_offsets();
+        offsets[i + 1] - offsets[i]
+    }
+
+    /// constructs a new iterator
+    pub fn iter<'a>(&'a self) -> GenericListArrayIter<'a, OffsetSize> {
+        GenericListArrayIter::<'a, OffsetSize>::new(self)
+    }
+
+    #[inline]
+    fn get_type(data_type: &DataType) -> Option<&DataType> {
+        match (OffsetSize::IS_LARGE, data_type) {
+            (true, DataType::LargeList(child)) | (false, DataType::List(child)) => {
+                Some(child.data_type())
+            }
+            _ => None,
+        }
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, length: usize) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            nulls: self.nulls.as_ref().map(|n| n.slice(offset, length)),
+            values: self.values.clone(),
+            value_offsets: self.value_offsets.slice(offset, length),
+        }
+    }
+
+    /// Creates a [`GenericListArray`] from an iterator of primitive values
+    /// # Example
+    /// ```
+    /// # use arrow_array::ListArray;
+    /// # use arrow_array::types::Int32Type;
+    ///
+    /// let data = vec![
+    ///    Some(vec![Some(0), Some(1), Some(2)]),
+    ///    None,
+    ///    Some(vec![Some(3), None, Some(5)]),
+    ///    Some(vec![Some(6), Some(7)]),
+    /// ];
+    /// let list_array = ListArray::from_iter_primitive::<Int32Type, _, _>(data);
+    /// println!("{:?}", list_array);
+    /// ```
+    pub fn from_iter_primitive<T, P, I>(iter: I) -> Self
+    where
+        T: ArrowPrimitiveType,
+        P: IntoIterator<Item = Option<<T as ArrowPrimitiveType>::Native>>,
+        I: IntoIterator<Item = Option<P>>,
+    {
+        let iter = iter.into_iter();
+        let size_hint = iter.size_hint().0;
+        let mut builder =
+            GenericListBuilder::with_capacity(PrimitiveBuilder::<T>::new(), size_hint);
+
+        for i in iter {
+            match i {
+                Some(p) => {
+                    for t in p {
+                        builder.values().append_option(t);
+                    }
+                    builder.append(true);
+                }
+                None => builder.append(false),
+            }
+        }
+        builder.finish()
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait> From<ArrayData> for GenericListArray<OffsetSize> {
+    fn from(data: ArrayData) -> Self {
+        Self::try_new_from_array_data(data)
+            .expect("Expected infallible creation of GenericListArray from ArrayDataRef failed")
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait> From<GenericListArray<OffsetSize>> for ArrayData {
+    fn from(array: GenericListArray<OffsetSize>) -> Self {
+        let len = array.len();
+        let builder = ArrayDataBuilder::new(array.data_type)
+            .len(len)
+            .nulls(array.nulls)
+            .buffers(vec![array.value_offsets.into_inner().into_inner()])
+            .child_data(vec![array.values.to_data()]);
+
+        unsafe { builder.build_unchecked() }
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait> From<FixedSizeListArray> for GenericListArray<OffsetSize> {
+    fn from(value: FixedSizeListArray) -> Self {
+        let (field, size) = match value.data_type() {
+            DataType::FixedSizeList(f, size) => (f, *size as usize),
+            _ => unreachable!(),
+        };
+
+        let offsets = OffsetBuffer::from_lengths(std::iter::repeat(size).take(value.len()));
+
+        Self {
+            data_type: Self::DATA_TYPE_CONSTRUCTOR(field.clone()),
+            nulls: value.nulls().cloned(),
+            values: value.values().clone(),
+            value_offsets: offsets,
+        }
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait> GenericListArray<OffsetSize> {
+    fn try_new_from_array_data(data: ArrayData) -> Result<Self, ArrowError> {
+        if data.buffers().len() != 1 {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "ListArray data should contain a single buffer only (value offsets), had {}",
+                data.buffers().len()
+            )));
+        }
+
+        if data.child_data().len() != 1 {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "ListArray should contain a single child array (values array), had {}",
+                data.child_data().len()
+            )));
+        }
+
+        let values = data.child_data()[0].clone();
+
+        if let Some(child_data_type) = Self::get_type(data.data_type()) {
+            if values.data_type() != child_data_type {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "[Large]ListArray's child datatype {:?} does not \
+                             correspond to the List's datatype {:?}",
+                    values.data_type(),
+                    child_data_type
+                )));
+            }
+        } else {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "[Large]ListArray's datatype must be [Large]ListArray(). It is {:?}",
+                data.data_type()
+            )));
+        }
+
+        let values = make_array(values);
+        // SAFETY:
+        // ArrayData is valid, and verified type above
+        let value_offsets = unsafe { get_offsets(&data) };
+
+        Ok(Self {
+            data_type: data.data_type().clone(),
+            nulls: data.nulls().cloned(),
+            values,
+            value_offsets,
+        })
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait> Array for GenericListArray<OffsetSize> {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.into()
+    }
+
+    fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.value_offsets.len() - 1
+    }
+
+    fn is_empty(&self) -> bool {
+        self.value_offsets.len() <= 1
+    }
+
+    fn offset(&self) -> usize {
+        0
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.nulls.as_ref()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        let mut size = self.values.get_buffer_memory_size();
+        size += self.value_offsets.inner().inner().capacity();
+        if let Some(n) = self.nulls.as_ref() {
+            size += n.buffer().capacity();
+        }
+        size
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        let mut size = std::mem::size_of::<Self>() + self.values.get_array_memory_size();
+        size += self.value_offsets.inner().inner().capacity();
+        if let Some(n) = self.nulls.as_ref() {
+            size += n.buffer().capacity();
+        }
+        size
+    }
+}
+
+impl<'a, OffsetSize: OffsetSizeTrait> ArrayAccessor for &'a GenericListArray<OffsetSize> {
+    type Item = ArrayRef;
+
+    fn value(&self, index: usize) -> Self::Item {
+        GenericListArray::value(self, index)
+    }
+
+    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
+        GenericListArray::value(self, index)
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait> std::fmt::Debug for GenericListArray<OffsetSize> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let prefix = OffsetSize::PREFIX;
+
+        write!(f, "{prefix}ListArray\n[\n")?;
+        print_long_array(self, f, |array, index, f| {
+            std::fmt::Debug::fmt(&array.value(index), f)
+        })?;
+        write!(f, "]")
+    }
+}
+
+/// A [`GenericListArray`] of variable size lists, storing offsets as `i32`.
+///
+// See [`ListBuilder`](crate::builder::ListBuilder) for how to construct a [`ListArray`]
+pub type ListArray = GenericListArray<i32>;
+
+/// A [`GenericListArray`] of variable size lists, storing offsets as `i64`.
+///
+// See [`LargeListBuilder`](crate::builder::LargeListBuilder) for how to construct a [`LargeListArray`]
+pub type LargeListArray = GenericListArray<i64>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::builder::{FixedSizeListBuilder, Int32Builder, ListBuilder};
+    use crate::cast::AsArray;
+    use crate::types::Int32Type;
+    use crate::{Int32Array, Int64Array};
+    use arrow_buffer::{bit_util, Buffer, ScalarBuffer};
+    use arrow_schema::Field;
+
+    fn create_from_buffers() -> ListArray {
+        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+        let values = Int32Array::from(vec![0, 1, 2, 3, 4, 5, 6, 7]);
+        let offsets = OffsetBuffer::new(ScalarBuffer::from(vec![0, 3, 6, 8]));
+        let field = Arc::new(Field::new("item", DataType::Int32, true));
+        ListArray::new(field, offsets, Arc::new(values), None)
+    }
+
+    #[test]
+    fn test_from_iter_primitive() {
+        let data = vec![
+            Some(vec![Some(0), Some(1), Some(2)]),
+            Some(vec![Some(3), Some(4), Some(5)]),
+            Some(vec![Some(6), Some(7)]),
+        ];
+        let list_array = ListArray::from_iter_primitive::<Int32Type, _, _>(data);
+
+        let another = create_from_buffers();
+        assert_eq!(list_array, another)
+    }
+
+    #[test]
+    fn test_empty_list_array() {
+        // Construct an empty value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(0)
+            .add_buffer(Buffer::from([]))
+            .build()
+            .unwrap();
+
+        // Construct an empty offset buffer
+        let value_offsets = Buffer::from([]);
+
+        // Construct a list array from the above two
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
+        let list_data = ArrayData::builder(list_data_type)
+            .len(0)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data)
+            .build()
+            .unwrap();
+
+        let list_array = ListArray::from(list_data);
+        assert_eq!(list_array.len(), 0)
+    }
+
+    #[test]
+    fn test_list_array() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(8)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+        let value_offsets = Buffer::from_slice_ref([0, 3, 6, 8]);
+
+        // Construct a list array from the above two
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
+        let list_data = ArrayData::builder(list_data_type.clone())
+            .len(3)
+            .add_buffer(value_offsets.clone())
+            .add_child_data(value_data.clone())
+            .build()
+            .unwrap();
+        let list_array = ListArray::from(list_data);
+
+        let values = list_array.values();
+        assert_eq!(value_data, values.to_data());
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(3, list_array.len());
+        assert_eq!(0, list_array.null_count());
+        assert_eq!(6, list_array.value_offsets()[2]);
+        assert_eq!(2, list_array.value_length(2));
+        assert_eq!(
+            0,
+            list_array
+                .value(0)
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .unwrap()
+                .value(0)
+        );
+        assert_eq!(
+            0,
+            unsafe { list_array.value_unchecked(0) }
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .unwrap()
+                .value(0)
+        );
+        for i in 0..3 {
+            assert!(list_array.is_valid(i));
+            assert!(!list_array.is_null(i));
+        }
+
+        // Now test with a non-zero offset (skip first element)
+        //  [[3, 4, 5], [6, 7]]
+        let list_data = ArrayData::builder(list_data_type)
+            .len(2)
+            .offset(1)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data.clone())
+            .build()
+            .unwrap();
+        let list_array = ListArray::from(list_data);
+
+        let values = list_array.values();
+        assert_eq!(value_data, values.to_data());
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(2, list_array.len());
+        assert_eq!(0, list_array.null_count());
+        assert_eq!(6, list_array.value_offsets()[1]);
+        assert_eq!(2, list_array.value_length(1));
+        assert_eq!(
+            3,
+            list_array
+                .value(0)
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .unwrap()
+                .value(0)
+        );
+        assert_eq!(
+            3,
+            unsafe { list_array.value_unchecked(0) }
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .unwrap()
+                .value(0)
+        );
+    }
+
+    #[test]
+    fn test_large_list_array() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(8)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+        let value_offsets = Buffer::from_slice_ref([0i64, 3, 6, 8]);
+
+        // Construct a list array from the above two
+        let list_data_type = DataType::new_large_list(DataType::Int32, false);
+        let list_data = ArrayData::builder(list_data_type.clone())
+            .len(3)
+            .add_buffer(value_offsets.clone())
+            .add_child_data(value_data.clone())
+            .build()
+            .unwrap();
+        let list_array = LargeListArray::from(list_data);
+
+        let values = list_array.values();
+        assert_eq!(value_data, values.to_data());
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(3, list_array.len());
+        assert_eq!(0, list_array.null_count());
+        assert_eq!(6, list_array.value_offsets()[2]);
+        assert_eq!(2, list_array.value_length(2));
+        assert_eq!(
+            0,
+            list_array
+                .value(0)
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .unwrap()
+                .value(0)
+        );
+        assert_eq!(
+            0,
+            unsafe { list_array.value_unchecked(0) }
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .unwrap()
+                .value(0)
+        );
+        for i in 0..3 {
+            assert!(list_array.is_valid(i));
+            assert!(!list_array.is_null(i));
+        }
+
+        // Now test with a non-zero offset
+        //  [[3, 4, 5], [6, 7]]
+        let list_data = ArrayData::builder(list_data_type)
+            .len(2)
+            .offset(1)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data.clone())
+            .build()
+            .unwrap();
+        let list_array = LargeListArray::from(list_data);
+
+        let values = list_array.values();
+        assert_eq!(value_data, values.to_data());
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(2, list_array.len());
+        assert_eq!(0, list_array.null_count());
+        assert_eq!(6, list_array.value_offsets()[1]);
+        assert_eq!(2, list_array.value_length(1));
+        assert_eq!(
+            3,
+            list_array
+                .value(0)
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .unwrap()
+                .value(0)
+        );
+        assert_eq!(
+            3,
+            unsafe { list_array.value_unchecked(0) }
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .unwrap()
+                .value(0)
+        );
+    }
+
+    #[test]
+    fn test_list_array_slice() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(10)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[0, 1], null, null, [2, 3], [4, 5], null, [6, 7, 8], null, [9]]
+        let value_offsets = Buffer::from_slice_ref([0, 2, 2, 2, 4, 6, 6, 9, 9, 10]);
+        // 01011001 00000001
+        let mut null_bits: [u8; 2] = [0; 2];
+        bit_util::set_bit(&mut null_bits, 0);
+        bit_util::set_bit(&mut null_bits, 3);
+        bit_util::set_bit(&mut null_bits, 4);
+        bit_util::set_bit(&mut null_bits, 6);
+        bit_util::set_bit(&mut null_bits, 8);
+
+        // Construct a list array from the above two
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
+        let list_data = ArrayData::builder(list_data_type)
+            .len(9)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data.clone())
+            .null_bit_buffer(Some(Buffer::from(null_bits)))
+            .build()
+            .unwrap();
+        let list_array = ListArray::from(list_data);
+
+        let values = list_array.values();
+        assert_eq!(value_data, values.to_data());
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(9, list_array.len());
+        assert_eq!(4, list_array.null_count());
+        assert_eq!(2, list_array.value_offsets()[3]);
+        assert_eq!(2, list_array.value_length(3));
+
+        let sliced_array = list_array.slice(1, 6);
+        assert_eq!(6, sliced_array.len());
+        assert_eq!(3, sliced_array.null_count());
+
+        for i in 0..sliced_array.len() {
+            if bit_util::get_bit(&null_bits, 1 + i) {
+                assert!(sliced_array.is_valid(i));
+            } else {
+                assert!(sliced_array.is_null(i));
+            }
+        }
+
+        // Check offset and length for each non-null value.
+        let sliced_list_array = sliced_array.as_any().downcast_ref::<ListArray>().unwrap();
+        assert_eq!(2, sliced_list_array.value_offsets()[2]);
+        assert_eq!(2, sliced_list_array.value_length(2));
+        assert_eq!(4, sliced_list_array.value_offsets()[3]);
+        assert_eq!(2, sliced_list_array.value_length(3));
+        assert_eq!(6, sliced_list_array.value_offsets()[5]);
+        assert_eq!(3, sliced_list_array.value_length(5));
+    }
+
+    #[test]
+    fn test_large_list_array_slice() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(10)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[0, 1], null, null, [2, 3], [4, 5], null, [6, 7, 8], null, [9]]
+        let value_offsets = Buffer::from_slice_ref([0i64, 2, 2, 2, 4, 6, 6, 9, 9, 10]);
+        // 01011001 00000001
+        let mut null_bits: [u8; 2] = [0; 2];
+        bit_util::set_bit(&mut null_bits, 0);
+        bit_util::set_bit(&mut null_bits, 3);
+        bit_util::set_bit(&mut null_bits, 4);
+        bit_util::set_bit(&mut null_bits, 6);
+        bit_util::set_bit(&mut null_bits, 8);
+
+        // Construct a list array from the above two
+        let list_data_type = DataType::new_large_list(DataType::Int32, false);
+        let list_data = ArrayData::builder(list_data_type)
+            .len(9)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data.clone())
+            .null_bit_buffer(Some(Buffer::from(null_bits)))
+            .build()
+            .unwrap();
+        let list_array = LargeListArray::from(list_data);
+
+        let values = list_array.values();
+        assert_eq!(value_data, values.to_data());
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(9, list_array.len());
+        assert_eq!(4, list_array.null_count());
+        assert_eq!(2, list_array.value_offsets()[3]);
+        assert_eq!(2, list_array.value_length(3));
+
+        let sliced_array = list_array.slice(1, 6);
+        assert_eq!(6, sliced_array.len());
+        assert_eq!(3, sliced_array.null_count());
+
+        for i in 0..sliced_array.len() {
+            if bit_util::get_bit(&null_bits, 1 + i) {
+                assert!(sliced_array.is_valid(i));
+            } else {
+                assert!(sliced_array.is_null(i));
+            }
+        }
+
+        // Check offset and length for each non-null value.
+        let sliced_list_array = sliced_array
+            .as_any()
+            .downcast_ref::<LargeListArray>()
+            .unwrap();
+        assert_eq!(2, sliced_list_array.value_offsets()[2]);
+        assert_eq!(2, sliced_list_array.value_length(2));
+        assert_eq!(4, sliced_list_array.value_offsets()[3]);
+        assert_eq!(2, sliced_list_array.value_length(3));
+        assert_eq!(6, sliced_list_array.value_offsets()[5]);
+        assert_eq!(3, sliced_list_array.value_length(5));
+    }
+
+    #[test]
+    #[should_panic(expected = "index out of bounds: the len is 10 but the index is 11")]
+    fn test_list_array_index_out_of_bound() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(10)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[0, 1], null, null, [2, 3], [4, 5], null, [6, 7, 8], null, [9]]
+        let value_offsets = Buffer::from_slice_ref([0i64, 2, 2, 2, 4, 6, 6, 9, 9, 10]);
+        // 01011001 00000001
+        let mut null_bits: [u8; 2] = [0; 2];
+        bit_util::set_bit(&mut null_bits, 0);
+        bit_util::set_bit(&mut null_bits, 3);
+        bit_util::set_bit(&mut null_bits, 4);
+        bit_util::set_bit(&mut null_bits, 6);
+        bit_util::set_bit(&mut null_bits, 8);
+
+        // Construct a list array from the above two
+        let list_data_type = DataType::new_large_list(DataType::Int32, false);
+        let list_data = ArrayData::builder(list_data_type)
+            .len(9)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data)
+            .null_bit_buffer(Some(Buffer::from(null_bits)))
+            .build()
+            .unwrap();
+        let list_array = LargeListArray::from(list_data);
+        assert_eq!(9, list_array.len());
+
+        list_array.value(10);
+    }
+    #[test]
+    #[should_panic(expected = "ListArray data should contain a single buffer only (value offsets)")]
+    // Different error messages, so skip for now
+    // https://github.com/apache/arrow-rs/issues/1545
+    #[cfg(not(feature = "force_validate"))]
+    fn test_list_array_invalid_buffer_len() {
+        let value_data = unsafe {
+            ArrayData::builder(DataType::Int32)
+                .len(8)
+                .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+                .build_unchecked()
+        };
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
+        let list_data = unsafe {
+            ArrayData::builder(list_data_type)
+                .len(3)
+                .add_child_data(value_data)
+                .build_unchecked()
+        };
+        drop(ListArray::from(list_data));
+    }
+
+    #[test]
+    #[should_panic(expected = "ListArray should contain a single child array (values array)")]
+    // Different error messages, so skip for now
+    // https://github.com/apache/arrow-rs/issues/1545
+    #[cfg(not(feature = "force_validate"))]
+    fn test_list_array_invalid_child_array_len() {
+        let value_offsets = Buffer::from_slice_ref([0, 2, 5, 7]);
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
+        let list_data = unsafe {
+            ArrayData::builder(list_data_type)
+                .len(3)
+                .add_buffer(value_offsets)
+                .build_unchecked()
+        };
+        drop(ListArray::from(list_data));
+    }
+
+    #[test]
+    #[should_panic(expected = "[Large]ListArray's datatype must be [Large]ListArray(). It is List")]
+    fn test_from_array_data_validation() {
+        let mut builder = ListBuilder::new(Int32Builder::new());
+        builder.values().append_value(1);
+        builder.append(true);
+        let array = builder.finish();
+        let _ = LargeListArray::from(array.into_data());
+    }
+
+    #[test]
+    fn test_list_array_offsets_need_not_start_at_zero() {
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(8)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+            .build()
+            .unwrap();
+
+        let value_offsets = Buffer::from_slice_ref([2, 2, 5, 7]);
+
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
+        let list_data = ArrayData::builder(list_data_type)
+            .len(3)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data)
+            .build()
+            .unwrap();
+
+        let list_array = ListArray::from(list_data);
+        assert_eq!(list_array.value_length(0), 0);
+        assert_eq!(list_array.value_length(1), 3);
+        assert_eq!(list_array.value_length(2), 2);
+    }
+
+    #[test]
+    #[should_panic(expected = "Memory pointer is not aligned with the specified scalar type")]
+    // Different error messages, so skip for now
+    // https://github.com/apache/arrow-rs/issues/1545
+    #[cfg(not(feature = "force_validate"))]
+    fn test_primitive_array_alignment() {
+        let buf = Buffer::from_slice_ref([0_u64]);
+        let buf2 = buf.slice(1);
+        let array_data = unsafe {
+            ArrayData::builder(DataType::Int32)
+                .add_buffer(buf2)
+                .build_unchecked()
+        };
+        drop(Int32Array::from(array_data));
+    }
+
+    #[test]
+    #[should_panic(expected = "Memory pointer is not aligned with the specified scalar type")]
+    // Different error messages, so skip for now
+    // https://github.com/apache/arrow-rs/issues/1545
+    #[cfg(not(feature = "force_validate"))]
+    fn test_list_array_alignment() {
+        let buf = Buffer::from_slice_ref([0_u64]);
+        let buf2 = buf.slice(1);
+
+        let values: [i32; 8] = [0; 8];
+        let value_data = unsafe {
+            ArrayData::builder(DataType::Int32)
+                .add_buffer(Buffer::from_slice_ref(values))
+                .build_unchecked()
+        };
+
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
+        let list_data = unsafe {
+            ArrayData::builder(list_data_type)
+                .add_buffer(buf2)
+                .add_child_data(value_data)
+                .build_unchecked()
+        };
+        drop(ListArray::from(list_data));
+    }
+
+    #[test]
+    fn list_array_equality() {
+        // test scaffold
+        fn do_comparison(
+            lhs_data: Vec<Option<Vec<Option<i32>>>>,
+            rhs_data: Vec<Option<Vec<Option<i32>>>>,
+            should_equal: bool,
+        ) {
+            let lhs = ListArray::from_iter_primitive::<Int32Type, _, _>(lhs_data.clone());
+            let rhs = ListArray::from_iter_primitive::<Int32Type, _, _>(rhs_data.clone());
+            assert_eq!(lhs == rhs, should_equal);
+
+            let lhs = LargeListArray::from_iter_primitive::<Int32Type, _, _>(lhs_data);
+            let rhs = LargeListArray::from_iter_primitive::<Int32Type, _, _>(rhs_data);
+            assert_eq!(lhs == rhs, should_equal);
+        }
+
+        do_comparison(
+            vec![
+                Some(vec![Some(0), Some(1), Some(2)]),
+                None,
+                Some(vec![Some(3), None, Some(5)]),
+                Some(vec![Some(6), Some(7)]),
+            ],
+            vec![
+                Some(vec![Some(0), Some(1), Some(2)]),
+                None,
+                Some(vec![Some(3), None, Some(5)]),
+                Some(vec![Some(6), Some(7)]),
+            ],
+            true,
+        );
+
+        do_comparison(
+            vec![
+                None,
+                None,
+                Some(vec![Some(3), None, Some(5)]),
+                Some(vec![Some(6), Some(7)]),
+            ],
+            vec![
+                Some(vec![Some(0), Some(1), Some(2)]),
+                None,
+                Some(vec![Some(3), None, Some(5)]),
+                Some(vec![Some(6), Some(7)]),
+            ],
+            false,
+        );
+
+        do_comparison(
+            vec![
+                None,
+                None,
+                Some(vec![Some(3), None, Some(5)]),
+                Some(vec![Some(6), Some(7)]),
+            ],
+            vec![
+                None,
+                None,
+                Some(vec![Some(3), None, Some(5)]),
+                Some(vec![Some(0), Some(0)]),
+            ],
+            false,
+        );
+
+        do_comparison(
+            vec![None, None, Some(vec![Some(1)])],
+            vec![None, None, Some(vec![Some(2)])],
+            false,
+        );
+    }
+
+    #[test]
+    fn test_empty_offsets() {
+        let f = Arc::new(Field::new("element", DataType::Int32, true));
+        let string = ListArray::from(
+            ArrayData::builder(DataType::List(f.clone()))
+                .buffers(vec![Buffer::from(&[])])
+                .add_child_data(ArrayData::new_empty(&DataType::Int32))
+                .build()
+                .unwrap(),
+        );
+        assert_eq!(string.value_offsets(), &[0]);
+        let string = LargeListArray::from(
+            ArrayData::builder(DataType::LargeList(f))
+                .buffers(vec![Buffer::from(&[])])
+                .add_child_data(ArrayData::new_empty(&DataType::Int32))
+                .build()
+                .unwrap(),
+        );
+        assert_eq!(string.len(), 0);
+        assert_eq!(string.value_offsets(), &[0]);
+    }
+
+    #[test]
+    fn test_try_new() {
+        let offsets = OffsetBuffer::new(vec![0, 1, 4, 5].into());
+        let values = Int32Array::new(vec![1, 2, 3, 4, 5].into(), None);
+        let values = Arc::new(values) as ArrayRef;
+
+        let field = Arc::new(Field::new("element", DataType::Int32, false));
+        ListArray::new(field.clone(), offsets.clone(), values.clone(), None);
+
+        let nulls = NullBuffer::new_null(3);
+        ListArray::new(field.clone(), offsets, values.clone(), Some(nulls));
+
+        let nulls = NullBuffer::new_null(3);
+        let offsets = OffsetBuffer::new(vec![0, 1, 2, 4, 5].into());
+        let err = LargeListArray::try_new(field, offsets.clone(), values.clone(), Some(nulls))
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Incorrect length of null buffer for LargeListArray, expected 4 got 3"
+        );
+
+        let field = Arc::new(Field::new("element", DataType::Int64, false));
+        let err = LargeListArray::try_new(field.clone(), offsets.clone(), values.clone(), None)
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: LargeListArray expected data type Int64 got Int32 for \"element\""
+        );
+
+        let nulls = NullBuffer::new_null(7);
+        let values = Int64Array::new(vec![0; 7].into(), Some(nulls));
+        let values = Arc::new(values);
+
+        let err =
+            LargeListArray::try_new(field, offsets.clone(), values.clone(), None).unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Non-nullable field of LargeListArray \"element\" cannot contain nulls"
+        );
+
+        let field = Arc::new(Field::new("element", DataType::Int64, true));
+        LargeListArray::new(field.clone(), offsets.clone(), values, None);
+
+        let values = Int64Array::new(vec![0; 2].into(), None);
+        let err = LargeListArray::try_new(field, offsets, Arc::new(values), None).unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Max offset of 5 exceeds length of values 2"
+        );
+    }
+
+    #[test]
+    fn test_from_fixed_size_list() {
+        let mut builder = FixedSizeListBuilder::new(Int32Builder::new(), 3);
+        builder.values().append_slice(&[1, 2, 3]);
+        builder.append(true);
+        builder.values().append_slice(&[0, 0, 0]);
+        builder.append(false);
+        builder.values().append_slice(&[4, 5, 6]);
+        builder.append(true);
+        let list: ListArray = builder.finish().into();
+
+        let values: Vec<_> = list
+            .iter()
+            .map(|x| x.map(|x| x.as_primitive::<Int32Type>().values().to_vec()))
+            .collect();
+        assert_eq!(values, vec![Some(vec![1, 2, 3]), None, Some(vec![4, 5, 6])])
+    }
+}
diff --git a/arrow-array/src/array/map_array.rs b/arrow-array/src/array/map_array.rs
new file mode 100644
index 000000000000..bde7fdd5a953
--- /dev/null
+++ b/arrow-array/src/array/map_array.rs
@@ -0,0 +1,802 @@
+// 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.
+
+use crate::array::{get_offsets, print_long_array};
+use crate::iterator::MapArrayIter;
+use crate::{make_array, Array, ArrayAccessor, ArrayRef, ListArray, StringArray, StructArray};
+use arrow_buffer::{ArrowNativeType, Buffer, NullBuffer, OffsetBuffer, ToByteSlice};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType, Field, FieldRef};
+use std::any::Any;
+use std::sync::Arc;
+
+/// An array of key-value maps
+///
+/// Keys should always be non-null, but values can be null.
+///
+/// [`MapArray`] is physically a [`ListArray`] of key values pairs stored as an `entries`
+/// [`StructArray`] with 2 child fields.
+///
+/// See [`MapBuilder`](crate::builder::MapBuilder) for how to construct a [`MapArray`]
+#[derive(Clone)]
+pub struct MapArray {
+    data_type: DataType,
+    nulls: Option<NullBuffer>,
+    /// The [`StructArray`] that is the direct child of this array
+    entries: StructArray,
+    /// The start and end offsets of each entry
+    value_offsets: OffsetBuffer<i32>,
+}
+
+impl MapArray {
+    /// Create a new [`MapArray`] from the provided parts
+    ///
+    /// See [`MapBuilder`](crate::builder::MapBuilder) for a higher-level interface
+    /// to construct a [`MapArray`]
+    ///
+    /// # Errors
+    ///
+    /// Errors if
+    ///
+    /// * `offsets.len() - 1 != nulls.len()`
+    /// * `offsets.last() > entries.len()`
+    /// * `field.is_nullable()`
+    /// * `entries.null_count() != 0`
+    /// * `entries.columns().len() != 2`
+    /// * `field.data_type() != entries.data_type()`
+    pub fn try_new(
+        field: FieldRef,
+        offsets: OffsetBuffer<i32>,
+        entries: StructArray,
+        nulls: Option<NullBuffer>,
+        ordered: bool,
+    ) -> Result<Self, ArrowError> {
+        let len = offsets.len() - 1; // Offsets guaranteed to not be empty
+        let end_offset = offsets.last().unwrap().as_usize();
+        // don't need to check other values of `offsets` because they are checked
+        // during construction of `OffsetBuffer`
+        if end_offset > entries.len() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Max offset of {end_offset} exceeds length of entries {}",
+                entries.len()
+            )));
+        }
+
+        if let Some(n) = nulls.as_ref() {
+            if n.len() != len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Incorrect length of null buffer for MapArray, expected {len} got {}",
+                    n.len(),
+                )));
+            }
+        }
+        if field.is_nullable() || entries.null_count() != 0 {
+            return Err(ArrowError::InvalidArgumentError(
+                "MapArray entries cannot contain nulls".to_string(),
+            ));
+        }
+
+        if field.data_type() != entries.data_type() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "MapArray expected data type {} got {} for {:?}",
+                field.data_type(),
+                entries.data_type(),
+                field.name()
+            )));
+        }
+
+        if entries.columns().len() != 2 {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "MapArray entries must contain two children, got {}",
+                entries.columns().len()
+            )));
+        }
+
+        Ok(Self {
+            data_type: DataType::Map(field, ordered),
+            nulls,
+            entries,
+            value_offsets: offsets,
+        })
+    }
+
+    /// Create a new [`MapArray`] from the provided parts
+    ///
+    /// See [`MapBuilder`](crate::builder::MapBuilder) for a higher-level interface
+    /// to construct a [`MapArray`]
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`Self::try_new`] returns an error
+    pub fn new(
+        field: FieldRef,
+        offsets: OffsetBuffer<i32>,
+        entries: StructArray,
+        nulls: Option<NullBuffer>,
+        ordered: bool,
+    ) -> Self {
+        Self::try_new(field, offsets, entries, nulls, ordered).unwrap()
+    }
+
+    /// Deconstruct this array into its constituent parts
+    pub fn into_parts(
+        self,
+    ) -> (
+        FieldRef,
+        OffsetBuffer<i32>,
+        StructArray,
+        Option<NullBuffer>,
+        bool,
+    ) {
+        let (f, ordered) = match self.data_type {
+            DataType::Map(f, ordered) => (f, ordered),
+            _ => unreachable!(),
+        };
+        (f, self.value_offsets, self.entries, self.nulls, ordered)
+    }
+
+    /// Returns a reference to the offsets of this map
+    ///
+    /// Unlike [`Self::value_offsets`] this returns the [`OffsetBuffer`]
+    /// allowing for zero-copy cloning
+    #[inline]
+    pub fn offsets(&self) -> &OffsetBuffer<i32> {
+        &self.value_offsets
+    }
+
+    /// Returns a reference to the keys of this map
+    pub fn keys(&self) -> &ArrayRef {
+        self.entries.column(0)
+    }
+
+    /// Returns a reference to the values of this map
+    pub fn values(&self) -> &ArrayRef {
+        self.entries.column(1)
+    }
+
+    /// Returns a reference to the [`StructArray`] entries of this map
+    pub fn entries(&self) -> &StructArray {
+        &self.entries
+    }
+
+    /// Returns the data type of the map's keys.
+    pub fn key_type(&self) -> &DataType {
+        self.keys().data_type()
+    }
+
+    /// Returns the data type of the map's values.
+    pub fn value_type(&self) -> &DataType {
+        self.values().data_type()
+    }
+
+    /// Returns ith value of this map array.
+    ///
+    /// # Safety
+    /// Caller must ensure that the index is within the array bounds
+    pub unsafe fn value_unchecked(&self, i: usize) -> StructArray {
+        let end = *self.value_offsets().get_unchecked(i + 1);
+        let start = *self.value_offsets().get_unchecked(i);
+        self.entries
+            .slice(start.to_usize().unwrap(), (end - start).to_usize().unwrap())
+    }
+
+    /// Returns ith value of this map array.
+    ///
+    /// This is a [`StructArray`] containing two fields
+    pub fn value(&self, i: usize) -> StructArray {
+        let end = self.value_offsets()[i + 1] as usize;
+        let start = self.value_offsets()[i] as usize;
+        self.entries.slice(start, end - start)
+    }
+
+    /// Returns the offset values in the offsets buffer
+    #[inline]
+    pub fn value_offsets(&self) -> &[i32] {
+        &self.value_offsets
+    }
+
+    /// Returns the length for value at index `i`.
+    #[inline]
+    pub fn value_length(&self, i: usize) -> i32 {
+        let offsets = self.value_offsets();
+        offsets[i + 1] - offsets[i]
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, length: usize) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            nulls: self.nulls.as_ref().map(|n| n.slice(offset, length)),
+            entries: self.entries.clone(),
+            value_offsets: self.value_offsets.slice(offset, length),
+        }
+    }
+
+    /// constructs a new iterator
+    pub fn iter(&self) -> MapArrayIter<'_> {
+        MapArrayIter::new(self)
+    }
+}
+
+impl From<ArrayData> for MapArray {
+    fn from(data: ArrayData) -> Self {
+        Self::try_new_from_array_data(data)
+            .expect("Expected infallible creation of MapArray from ArrayData failed")
+    }
+}
+
+impl From<MapArray> for ArrayData {
+    fn from(array: MapArray) -> Self {
+        let len = array.len();
+        let builder = ArrayDataBuilder::new(array.data_type)
+            .len(len)
+            .nulls(array.nulls)
+            .buffers(vec![array.value_offsets.into_inner().into_inner()])
+            .child_data(vec![array.entries.to_data()]);
+
+        unsafe { builder.build_unchecked() }
+    }
+}
+
+impl MapArray {
+    fn try_new_from_array_data(data: ArrayData) -> Result<Self, ArrowError> {
+        if !matches!(data.data_type(), DataType::Map(_, _)) {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "MapArray expected ArrayData with DataType::Map got {}",
+                data.data_type()
+            )));
+        }
+
+        if data.buffers().len() != 1 {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "MapArray data should contain a single buffer only (value offsets), had {}",
+                data.len()
+            )));
+        }
+
+        if data.child_data().len() != 1 {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "MapArray should contain a single child array (values array), had {}",
+                data.child_data().len()
+            )));
+        }
+
+        let entries = data.child_data()[0].clone();
+
+        if let DataType::Struct(fields) = entries.data_type() {
+            if fields.len() != 2 {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "MapArray should contain a struct array with 2 fields, have {} fields",
+                    fields.len()
+                )));
+            }
+        } else {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "MapArray should contain a struct array child, found {:?}",
+                entries.data_type()
+            )));
+        }
+        let entries = entries.into();
+
+        // SAFETY:
+        // ArrayData is valid, and verified type above
+        let value_offsets = unsafe { get_offsets(&data) };
+
+        Ok(Self {
+            data_type: data.data_type().clone(),
+            nulls: data.nulls().cloned(),
+            entries,
+            value_offsets,
+        })
+    }
+
+    /// Creates map array from provided keys, values and entry_offsets.
+    pub fn new_from_strings<'a>(
+        keys: impl Iterator<Item = &'a str>,
+        values: &dyn Array,
+        entry_offsets: &[u32],
+    ) -> Result<Self, ArrowError> {
+        let entry_offsets_buffer = Buffer::from(entry_offsets.to_byte_slice());
+        let keys_data = StringArray::from_iter_values(keys);
+
+        let keys_field = Arc::new(Field::new("keys", DataType::Utf8, false));
+        let values_field = Arc::new(Field::new(
+            "values",
+            values.data_type().clone(),
+            values.null_count() > 0,
+        ));
+
+        let entry_struct = StructArray::from(vec![
+            (keys_field, Arc::new(keys_data) as ArrayRef),
+            (values_field, make_array(values.to_data())),
+        ]);
+
+        let map_data_type = DataType::Map(
+            Arc::new(Field::new(
+                "entries",
+                entry_struct.data_type().clone(),
+                false,
+            )),
+            false,
+        );
+        let map_data = ArrayData::builder(map_data_type)
+            .len(entry_offsets.len() - 1)
+            .add_buffer(entry_offsets_buffer)
+            .add_child_data(entry_struct.into_data())
+            .build()?;
+
+        Ok(MapArray::from(map_data))
+    }
+}
+
+impl Array for MapArray {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.clone().into_data()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.into()
+    }
+
+    fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.value_offsets.len() - 1
+    }
+
+    fn is_empty(&self) -> bool {
+        self.value_offsets.len() <= 1
+    }
+
+    fn offset(&self) -> usize {
+        0
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.nulls.as_ref()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        let mut size = self.entries.get_buffer_memory_size();
+        size += self.value_offsets.inner().inner().capacity();
+        if let Some(n) = self.nulls.as_ref() {
+            size += n.buffer().capacity();
+        }
+        size
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        let mut size = std::mem::size_of::<Self>() + self.entries.get_array_memory_size();
+        size += self.value_offsets.inner().inner().capacity();
+        if let Some(n) = self.nulls.as_ref() {
+            size += n.buffer().capacity();
+        }
+        size
+    }
+}
+
+impl<'a> ArrayAccessor for &'a MapArray {
+    type Item = StructArray;
+
+    fn value(&self, index: usize) -> Self::Item {
+        MapArray::value(self, index)
+    }
+
+    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
+        MapArray::value(self, index)
+    }
+}
+
+impl std::fmt::Debug for MapArray {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "MapArray\n[\n")?;
+        print_long_array(self, f, |array, index, f| {
+            std::fmt::Debug::fmt(&array.value(index), f)
+        })?;
+        write!(f, "]")
+    }
+}
+
+impl From<MapArray> for ListArray {
+    fn from(value: MapArray) -> Self {
+        let field = match value.data_type() {
+            DataType::Map(field, _) => field,
+            _ => unreachable!("This should be a map type."),
+        };
+        let data_type = DataType::List(field.clone());
+        let builder = value.into_data().into_builder().data_type(data_type);
+        let array_data = unsafe { builder.build_unchecked() };
+
+        ListArray::from(array_data)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::cast::AsArray;
+    use crate::types::UInt32Type;
+    use crate::{Int32Array, UInt32Array};
+    use arrow_schema::Fields;
+    use std::sync::Arc;
+
+    use super::*;
+
+    fn create_from_buffers() -> MapArray {
+        // Construct key and values
+        let keys_data = ArrayData::builder(DataType::Int32)
+            .len(8)
+            .add_buffer(Buffer::from(&[0, 1, 2, 3, 4, 5, 6, 7].to_byte_slice()))
+            .build()
+            .unwrap();
+        let values_data = ArrayData::builder(DataType::UInt32)
+            .len(8)
+            .add_buffer(Buffer::from(
+                &[0u32, 10, 20, 30, 40, 50, 60, 70].to_byte_slice(),
+            ))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+        let entry_offsets = Buffer::from(&[0, 3, 6, 8].to_byte_slice());
+
+        let keys = Arc::new(Field::new("keys", DataType::Int32, false));
+        let values = Arc::new(Field::new("values", DataType::UInt32, false));
+        let entry_struct = StructArray::from(vec![
+            (keys, make_array(keys_data)),
+            (values, make_array(values_data)),
+        ]);
+
+        // Construct a map array from the above two
+        let map_data_type = DataType::Map(
+            Arc::new(Field::new(
+                "entries",
+                entry_struct.data_type().clone(),
+                false,
+            )),
+            false,
+        );
+        let map_data = ArrayData::builder(map_data_type)
+            .len(3)
+            .add_buffer(entry_offsets)
+            .add_child_data(entry_struct.into_data())
+            .build()
+            .unwrap();
+        MapArray::from(map_data)
+    }
+
+    #[test]
+    fn test_map_array() {
+        // Construct key and values
+        let key_data = ArrayData::builder(DataType::Int32)
+            .len(8)
+            .add_buffer(Buffer::from(&[0, 1, 2, 3, 4, 5, 6, 7].to_byte_slice()))
+            .build()
+            .unwrap();
+        let value_data = ArrayData::builder(DataType::UInt32)
+            .len(8)
+            .add_buffer(Buffer::from(
+                &[0u32, 10, 20, 0, 40, 0, 60, 70].to_byte_slice(),
+            ))
+            .null_bit_buffer(Some(Buffer::from(&[0b11010110])))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+        let entry_offsets = Buffer::from(&[0, 3, 6, 8].to_byte_slice());
+
+        let keys_field = Arc::new(Field::new("keys", DataType::Int32, false));
+        let values_field = Arc::new(Field::new("values", DataType::UInt32, true));
+        let entry_struct = StructArray::from(vec![
+            (keys_field.clone(), make_array(key_data)),
+            (values_field.clone(), make_array(value_data.clone())),
+        ]);
+
+        // Construct a map array from the above two
+        let map_data_type = DataType::Map(
+            Arc::new(Field::new(
+                "entries",
+                entry_struct.data_type().clone(),
+                false,
+            )),
+            false,
+        );
+        let map_data = ArrayData::builder(map_data_type)
+            .len(3)
+            .add_buffer(entry_offsets)
+            .add_child_data(entry_struct.into_data())
+            .build()
+            .unwrap();
+        let map_array = MapArray::from(map_data);
+
+        assert_eq!(value_data, map_array.values().to_data());
+        assert_eq!(&DataType::UInt32, map_array.value_type());
+        assert_eq!(3, map_array.len());
+        assert_eq!(0, map_array.null_count());
+        assert_eq!(6, map_array.value_offsets()[2]);
+        assert_eq!(2, map_array.value_length(2));
+
+        let key_array = Arc::new(Int32Array::from(vec![0, 1, 2])) as ArrayRef;
+        let value_array =
+            Arc::new(UInt32Array::from(vec![None, Some(10u32), Some(20)])) as ArrayRef;
+        let struct_array = StructArray::from(vec![
+            (keys_field.clone(), key_array),
+            (values_field.clone(), value_array),
+        ]);
+        assert_eq!(
+            struct_array,
+            StructArray::from(map_array.value(0).into_data())
+        );
+        assert_eq!(
+            &struct_array,
+            unsafe { map_array.value_unchecked(0) }
+                .as_any()
+                .downcast_ref::<StructArray>()
+                .unwrap()
+        );
+        for i in 0..3 {
+            assert!(map_array.is_valid(i));
+            assert!(!map_array.is_null(i));
+        }
+
+        // Now test with a non-zero offset
+        let map_array = map_array.slice(1, 2);
+
+        assert_eq!(value_data, map_array.values().to_data());
+        assert_eq!(&DataType::UInt32, map_array.value_type());
+        assert_eq!(2, map_array.len());
+        assert_eq!(0, map_array.null_count());
+        assert_eq!(6, map_array.value_offsets()[1]);
+        assert_eq!(2, map_array.value_length(1));
+
+        let key_array = Arc::new(Int32Array::from(vec![3, 4, 5])) as ArrayRef;
+        let value_array = Arc::new(UInt32Array::from(vec![None, Some(40), None])) as ArrayRef;
+        let struct_array =
+            StructArray::from(vec![(keys_field, key_array), (values_field, value_array)]);
+        assert_eq!(
+            &struct_array,
+            map_array
+                .value(0)
+                .as_any()
+                .downcast_ref::<StructArray>()
+                .unwrap()
+        );
+        assert_eq!(
+            &struct_array,
+            unsafe { map_array.value_unchecked(0) }
+                .as_any()
+                .downcast_ref::<StructArray>()
+                .unwrap()
+        );
+    }
+
+    #[test]
+    #[ignore = "Test fails because slice of <list<struct>> is still buggy"]
+    fn test_map_array_slice() {
+        let map_array = create_from_buffers();
+
+        let sliced_array = map_array.slice(1, 2);
+        assert_eq!(2, sliced_array.len());
+        assert_eq!(1, sliced_array.offset());
+        let sliced_array_data = sliced_array.to_data();
+        for array_data in sliced_array_data.child_data() {
+            assert_eq!(array_data.offset(), 1);
+        }
+
+        // Check offset and length for each non-null value.
+        let sliced_map_array = sliced_array.as_any().downcast_ref::<MapArray>().unwrap();
+        assert_eq!(3, sliced_map_array.value_offsets()[0]);
+        assert_eq!(3, sliced_map_array.value_length(0));
+        assert_eq!(6, sliced_map_array.value_offsets()[1]);
+        assert_eq!(2, sliced_map_array.value_length(1));
+
+        // Construct key and values
+        let keys_data = ArrayData::builder(DataType::Int32)
+            .len(5)
+            .add_buffer(Buffer::from(&[3, 4, 5, 6, 7].to_byte_slice()))
+            .build()
+            .unwrap();
+        let values_data = ArrayData::builder(DataType::UInt32)
+            .len(5)
+            .add_buffer(Buffer::from(&[30u32, 40, 50, 60, 70].to_byte_slice()))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[3, 4, 5], [6, 7]]
+        let entry_offsets = Buffer::from(&[0, 3, 5].to_byte_slice());
+
+        let keys = Arc::new(Field::new("keys", DataType::Int32, false));
+        let values = Arc::new(Field::new("values", DataType::UInt32, false));
+        let entry_struct = StructArray::from(vec![
+            (keys, make_array(keys_data)),
+            (values, make_array(values_data)),
+        ]);
+
+        // Construct a map array from the above two
+        let map_data_type = DataType::Map(
+            Arc::new(Field::new(
+                "entries",
+                entry_struct.data_type().clone(),
+                false,
+            )),
+            false,
+        );
+        let expected_map_data = ArrayData::builder(map_data_type)
+            .len(2)
+            .add_buffer(entry_offsets)
+            .add_child_data(entry_struct.into_data())
+            .build()
+            .unwrap();
+        let expected_map_array = MapArray::from(expected_map_data);
+
+        assert_eq!(&expected_map_array, sliced_map_array)
+    }
+
+    #[test]
+    #[should_panic(expected = "index out of bounds: the len is ")]
+    fn test_map_array_index_out_of_bound() {
+        let map_array = create_from_buffers();
+
+        map_array.value(map_array.len());
+    }
+
+    #[test]
+    #[should_panic(expected = "MapArray expected ArrayData with DataType::Map got Dictionary")]
+    fn test_from_array_data_validation() {
+        // A DictionaryArray has similar buffer layout to a MapArray
+        // but the meaning of the values differs
+        let struct_t = DataType::Struct(Fields::from(vec![
+            Field::new("keys", DataType::Int32, true),
+            Field::new("values", DataType::UInt32, true),
+        ]));
+        let dict_t = DataType::Dictionary(Box::new(DataType::Int32), Box::new(struct_t));
+        let _ = MapArray::from(ArrayData::new_empty(&dict_t));
+    }
+
+    #[test]
+    fn test_new_from_strings() {
+        let keys = vec!["a", "b", "c", "d", "e", "f", "g", "h"];
+        let values_data = UInt32Array::from(vec![0u32, 10, 20, 30, 40, 50, 60, 70]);
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[a, b, c], [d, e, f], [g, h]]
+        let entry_offsets = [0, 3, 6, 8];
+
+        let map_array =
+            MapArray::new_from_strings(keys.clone().into_iter(), &values_data, &entry_offsets)
+                .unwrap();
+
+        assert_eq!(
+            &values_data,
+            map_array.values().as_primitive::<UInt32Type>()
+        );
+        assert_eq!(&DataType::UInt32, map_array.value_type());
+        assert_eq!(3, map_array.len());
+        assert_eq!(0, map_array.null_count());
+        assert_eq!(6, map_array.value_offsets()[2]);
+        assert_eq!(2, map_array.value_length(2));
+
+        let key_array = Arc::new(StringArray::from(vec!["a", "b", "c"])) as ArrayRef;
+        let value_array = Arc::new(UInt32Array::from(vec![0u32, 10, 20])) as ArrayRef;
+        let keys_field = Arc::new(Field::new("keys", DataType::Utf8, false));
+        let values_field = Arc::new(Field::new("values", DataType::UInt32, false));
+        let struct_array =
+            StructArray::from(vec![(keys_field, key_array), (values_field, value_array)]);
+        assert_eq!(
+            struct_array,
+            StructArray::from(map_array.value(0).into_data())
+        );
+        assert_eq!(
+            &struct_array,
+            unsafe { map_array.value_unchecked(0) }
+                .as_any()
+                .downcast_ref::<StructArray>()
+                .unwrap()
+        );
+        for i in 0..3 {
+            assert!(map_array.is_valid(i));
+            assert!(!map_array.is_null(i));
+        }
+    }
+
+    #[test]
+    fn test_try_new() {
+        let offsets = OffsetBuffer::new(vec![0, 1, 4, 5].into());
+        let fields = Fields::from(vec![
+            Field::new("key", DataType::Int32, false),
+            Field::new("values", DataType::Int32, false),
+        ]);
+        let columns = vec![
+            Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])) as _,
+            Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])) as _,
+        ];
+
+        let entries = StructArray::new(fields.clone(), columns, None);
+        let field = Arc::new(Field::new("entries", DataType::Struct(fields), false));
+
+        MapArray::new(field.clone(), offsets.clone(), entries.clone(), None, false);
+
+        let nulls = NullBuffer::new_null(3);
+        MapArray::new(field.clone(), offsets, entries.clone(), Some(nulls), false);
+
+        let nulls = NullBuffer::new_null(3);
+        let offsets = OffsetBuffer::new(vec![0, 1, 2, 4, 5].into());
+        let err = MapArray::try_new(
+            field.clone(),
+            offsets.clone(),
+            entries.clone(),
+            Some(nulls),
+            false,
+        )
+        .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Incorrect length of null buffer for MapArray, expected 4 got 3"
+        );
+
+        let err = MapArray::try_new(field, offsets.clone(), entries.slice(0, 2), None, false)
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Max offset of 5 exceeds length of entries 2"
+        );
+
+        let field = Arc::new(Field::new("element", DataType::Int64, false));
+        let err = MapArray::try_new(field, offsets.clone(), entries, None, false)
+            .unwrap_err()
+            .to_string();
+
+        assert!(
+            err.starts_with("Invalid argument error: MapArray expected data type Int64 got Struct"),
+            "{err}"
+        );
+
+        let fields = Fields::from(vec![
+            Field::new("a", DataType::Int32, false),
+            Field::new("b", DataType::Int32, false),
+            Field::new("c", DataType::Int32, false),
+        ]);
+        let columns = vec![
+            Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])) as _,
+            Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])) as _,
+            Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5])) as _,
+        ];
+
+        let s = StructArray::new(fields.clone(), columns, None);
+        let field = Arc::new(Field::new("entries", DataType::Struct(fields), false));
+        let err = MapArray::try_new(field, offsets, s, None, false).unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: MapArray entries must contain two children, got 3"
+        );
+    }
+}
diff --git a/arrow/src/array/array.rs b/arrow-array/src/array/mod.rs
similarity index 53%
rename from arrow/src/array/array.rs
rename to arrow-array/src/array/mod.rs
index 9766f857c727..7aa3f92bfbd2 100644
--- a/arrow/src/array/array.rs
+++ b/arrow-array/src/array/mod.rs
@@ -15,118 +15,146 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! The concrete array definitions
+
+mod binary_array;
+
+use crate::types::*;
+use arrow_buffer::{ArrowNativeType, NullBuffer, OffsetBuffer, ScalarBuffer};
+use arrow_data::ArrayData;
+use arrow_schema::{DataType, IntervalUnit, TimeUnit};
 use std::any::Any;
-use std::convert::From;
-use std::fmt;
 use std::sync::Arc;
 
-use super::*;
-use crate::buffer::{Buffer, MutableBuffer};
+pub use binary_array::*;
+
+mod boolean_array;
+pub use boolean_array::*;
+
+mod byte_array;
+pub use byte_array::*;
+
+mod dictionary_array;
+pub use dictionary_array::*;
+
+mod fixed_size_binary_array;
+pub use fixed_size_binary_array::*;
+
+mod fixed_size_list_array;
+pub use fixed_size_list_array::*;
+
+mod list_array;
+pub use list_array::*;
+
+mod map_array;
+pub use map_array::*;
+
+mod null_array;
+pub use null_array::*;
+
+mod primitive_array;
+pub use primitive_array::*;
+
+mod string_array;
+pub use string_array::*;
 
-/// Trait for dealing with different types of array at runtime when the type of the
-/// array is not known in advance.
-pub trait Array: fmt::Debug + Send + Sync {
-    /// Returns the array as [`Any`](std::any::Any) so that it can be
+mod struct_array;
+pub use struct_array::*;
+
+mod union_array;
+pub use union_array::*;
+
+mod run_array;
+pub use run_array::*;
+
+/// An array in the [arrow columnar format](https://arrow.apache.org/docs/format/Columnar.html)
+pub trait Array: std::fmt::Debug + Send + Sync {
+    /// Returns the array as [`Any`] so that it can be
     /// downcasted to a specific implementation.
     ///
     /// # Example:
     ///
     /// ```
-    /// use std::sync::Arc;
-    /// use arrow::array::Int32Array;
-    /// use arrow::datatypes::{Schema, Field, DataType};
-    /// use arrow::record_batch::RecordBatch;
+    /// # use std::sync::Arc;
+    /// # use arrow_array::{Int32Array, RecordBatch};
+    /// # use arrow_schema::{Schema, Field, DataType, ArrowError};
     ///
-    /// # fn main() -> arrow::error::Result<()> {
     /// let id = Int32Array::from(vec![1, 2, 3, 4, 5]);
     /// let batch = RecordBatch::try_new(
     ///     Arc::new(Schema::new(vec![Field::new("id", DataType::Int32, false)])),
     ///     vec![Arc::new(id)]
-    /// )?;
+    /// ).unwrap();
     ///
     /// let int32array = batch
     ///     .column(0)
     ///     .as_any()
     ///     .downcast_ref::<Int32Array>()
     ///     .expect("Failed to downcast");
-    /// # Ok(())
-    /// # }
     /// ```
     fn as_any(&self) -> &dyn Any;
 
-    /// Returns a reference to the underlying data of this array.
-    fn data(&self) -> &ArrayData;
+    /// Returns the underlying data of this array
+    fn to_data(&self) -> ArrayData;
 
-    /// Returns the underlying data of this array.
+    /// Returns the underlying data of this array
+    ///
+    /// Unlike [`Array::to_data`] this consumes self, allowing it avoid unnecessary clones
     fn into_data(self) -> ArrayData;
 
-    /// Returns a reference-counted pointer to the underlying data of this array.
-    fn data_ref(&self) -> &ArrayData {
-        self.data()
-    }
-
-    /// Returns a reference to the [`DataType`](crate::datatypes::DataType) of this array.
+    /// Returns a reference to the [`DataType`] of this array.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::datatypes::DataType;
-    /// use arrow::array::{Array, Int32Array};
+    /// use arrow_schema::DataType;
+    /// use arrow_array::{Array, Int32Array};
     ///
     /// let array = Int32Array::from(vec![1, 2, 3, 4, 5]);
     ///
     /// assert_eq!(*array.data_type(), DataType::Int32);
     /// ```
-    fn data_type(&self) -> &DataType {
-        self.data_ref().data_type()
-    }
+    fn data_type(&self) -> &DataType;
 
     /// Returns a zero-copy slice of this array with the indicated offset and length.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{Array, Int32Array};
+    /// use arrow_array::{Array, Int32Array};
     ///
     /// let array = Int32Array::from(vec![1, 2, 3, 4, 5]);
     /// // Make slice over the values [2, 3, 4]
     /// let array_slice = array.slice(1, 3);
     ///
-    /// assert_eq!(array_slice.as_ref(), &Int32Array::from(vec![2, 3, 4]));
+    /// assert_eq!(&array_slice, &Int32Array::from(vec![2, 3, 4]));
     /// ```
-    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
-        make_array(self.data_ref().slice(offset, length))
-    }
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef;
 
     /// Returns the length (i.e., number of elements) of this array.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{Array, Int32Array};
+    /// use arrow_array::{Array, Int32Array};
     ///
     /// let array = Int32Array::from(vec![1, 2, 3, 4, 5]);
     ///
     /// assert_eq!(array.len(), 5);
     /// ```
-    fn len(&self) -> usize {
-        self.data_ref().len()
-    }
+    fn len(&self) -> usize;
 
     /// Returns whether this array is empty.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{Array, Int32Array};
+    /// use arrow_array::{Array, Int32Array};
     ///
     /// let array = Int32Array::from(vec![1, 2, 3, 4, 5]);
     ///
     /// assert_eq!(array.is_empty(), false);
     /// ```
-    fn is_empty(&self) -> bool {
-        self.data_ref().is_empty()
-    }
+    fn is_empty(&self) -> bool;
 
     /// Returns the offset into the underlying data used by this array(-slice).
     /// Note that the underlying data can be shared by many arrays.
@@ -135,43 +163,83 @@ pub trait Array: fmt::Debug + Send + Sync {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{Array, Int32Array};
+    /// use arrow_array::{Array, BooleanArray};
     ///
-    /// let array = Int32Array::from(vec![1, 2, 3, 4, 5]);
-    /// // Make slice over the values [2, 3, 4]
+    /// let array = BooleanArray::from(vec![false, false, true, true]);
     /// let array_slice = array.slice(1, 3);
     ///
     /// assert_eq!(array.offset(), 0);
     /// assert_eq!(array_slice.offset(), 1);
     /// ```
-    fn offset(&self) -> usize {
-        self.data_ref().offset()
+    fn offset(&self) -> usize;
+
+    /// Returns the null buffer of this array if any.
+    ///
+    /// The null buffer contains the "physical" nulls of an array, that is how
+    /// the nulls are represented in the underlying arrow format.
+    ///
+    /// The physical representation is efficient, but is sometimes non intuitive
+    /// for certain array types such as those with nullable child arrays like
+    /// [`DictionaryArray::values`] or [`RunArray::values`], or without a
+    /// null buffer, such as [`NullArray`].
+    ///
+    /// To determine if each element of such an array is "logically" null,
+    /// use the slower [`Array::logical_nulls`] to obtain a computed mask.
+    fn nulls(&self) -> Option<&NullBuffer>;
+
+    /// Returns a potentially computed [`NullBuffer`] that represents the logical
+    /// null values of this array, if any.
+    ///
+    /// Logical nulls represent the values that are null in the array,
+    /// regardless of the underlying physical arrow representation.
+    ///
+    /// For most array types, this is equivalent to the "physical" nulls
+    /// returned by [`Array::nulls`]. It is different for the following cases, because which
+    /// elements are null is not encoded in a single null buffer:
+    ///
+    /// * [`DictionaryArray`] where [`DictionaryArray::values`] contains nulls
+    /// * [`RunArray`] where [`RunArray::values`] contains nulls
+    /// * [`NullArray`] where all indices are nulls
+    ///
+    /// In these cases a logical [`NullBuffer`] will be computed, encoding the
+    /// logical nullability of these arrays, beyond what is encoded in
+    /// [`Array::nulls`]
+    fn logical_nulls(&self) -> Option<NullBuffer> {
+        self.nulls().cloned()
     }
 
-    /// Returns whether the element at `index` is null.
-    /// When using this function on a slice, the index is relative to the slice.
+    /// Returns whether the element at `index` is null according to [`Array::nulls`]
+    ///
+    /// Note: For performance reasons, this method returns nullability solely as determined by the
+    /// null buffer. This difference can lead to surprising results, for example, [`NullArray::is_null`] always
+    /// returns `false` as the array lacks a null buffer. Similarly [`DictionaryArray`] and [`RunArray`] may
+    /// encode nullability in their children. See [`Self::logical_nulls`] for more information.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{Array, Int32Array};
+    /// use arrow_array::{Array, Int32Array, NullArray};
     ///
     /// let array = Int32Array::from(vec![Some(1), None]);
-    ///
     /// assert_eq!(array.is_null(0), false);
     /// assert_eq!(array.is_null(1), true);
+    ///
+    /// // NullArrays do not have a null buffer, and therefore always
+    /// // return false for is_null.
+    /// let array = NullArray::new(1);
+    /// assert_eq!(array.is_null(0), false);
     /// ```
     fn is_null(&self, index: usize) -> bool {
-        self.data_ref().is_null(index)
+        self.nulls().map(|n| n.is_null(index)).unwrap_or_default()
     }
 
-    /// Returns whether the element at `index` is not null.
-    /// When using this function on a slice, the index is relative to the slice.
+    /// Returns whether the element at `index` is *not* null, the
+    /// opposite of [`Self::is_null`].
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{Array, Int32Array};
+    /// use arrow_array::{Array, Int32Array};
     ///
     /// let array = Int32Array::from(vec![Some(1), None]);
     ///
@@ -179,15 +247,18 @@ pub trait Array: fmt::Debug + Send + Sync {
     /// assert_eq!(array.is_valid(1), false);
     /// ```
     fn is_valid(&self, index: usize) -> bool {
-        self.data_ref().is_valid(index)
+        !self.is_null(index)
     }
 
-    /// Returns the total number of null values in this array.
+    /// Returns the total number of physical null values in this array.
+    ///
+    /// Note: this method returns the physical null count, i.e. that encoded in [`Array::nulls`],
+    /// see [`Array::logical_nulls`] for logical nullability
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::{Array, Int32Array};
+    /// use arrow_array::{Array, Int32Array};
     ///
     /// // Construct an array with values [1, NULL, NULL]
     /// let array = Int32Array::from(vec![Some(1), None, None]);
@@ -195,27 +266,35 @@ pub trait Array: fmt::Debug + Send + Sync {
     /// assert_eq!(array.null_count(), 2);
     /// ```
     fn null_count(&self) -> usize {
-        self.data_ref().null_count()
+        self.nulls().map(|n| n.null_count()).unwrap_or_default()
+    }
+
+    /// Returns `false` if the array is guaranteed to not contain any logical nulls
+    ///
+    /// In general this will be equivalent to `Array::null_count() != 0` but may differ in the
+    /// presence of logical nullability, see [`Array::logical_nulls`].
+    ///
+    /// Implementations will return `true` unless they can cheaply prove no logical nulls
+    /// are present. For example a [`DictionaryArray`] with nullable values will still return true,
+    /// even if the nulls present in [`DictionaryArray::values`] are not referenced by any key,
+    /// and therefore would not appear in [`Array::logical_nulls`].
+    fn is_nullable(&self) -> bool {
+        self.null_count() != 0
     }
 
     /// Returns the total number of bytes of memory pointed to by this array.
     /// The buffers store bytes in the Arrow memory format, and include the data as well as the validity map.
-    fn get_buffer_memory_size(&self) -> usize {
-        self.data_ref().get_buffer_memory_size()
-    }
+    /// Note that this does not always correspond to the exact memory usage of an array,
+    /// since multiple arrays can share the same buffers or slices thereof.
+    fn get_buffer_memory_size(&self) -> usize;
 
     /// Returns the total number of bytes of memory occupied physically by this array.
     /// This value will always be greater than returned by `get_buffer_memory_size()` and
     /// includes the overhead of the data structures that contain the pointers to the various buffers.
-    fn get_array_memory_size(&self) -> usize {
-        // both data.get_array_memory_size and size_of_val(self) include ArrayData fields,
-        // to only count additional fields of this array substract size_of(ArrayData)
-        self.data_ref().get_array_memory_size() + std::mem::size_of_val(self)
-            - std::mem::size_of::<ArrayData>()
-    }
+    fn get_array_memory_size(&self) -> usize;
 }
 
-/// A reference-counted reference to a generic `Array`.
+/// A reference-counted reference to a generic `Array`
 pub type ArrayRef = Arc<dyn Array>;
 
 /// Ergonomics: Allow use of an ArrayRef as an `&dyn Array`
@@ -224,16 +303,12 @@ impl Array for ArrayRef {
         self.as_ref().as_any()
     }
 
-    fn data(&self) -> &ArrayData {
-        self.as_ref().data()
+    fn to_data(&self) -> ArrayData {
+        self.as_ref().to_data()
     }
 
     fn into_data(self) -> ArrayData {
-        self.into()
-    }
-
-    fn data_ref(&self) -> &ArrayData {
-        self.as_ref().data_ref()
+        self.to_data()
     }
 
     fn data_type(&self) -> &DataType {
@@ -256,6 +331,14 @@ impl Array for ArrayRef {
         self.as_ref().offset()
     }
 
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.as_ref().nulls()
+    }
+
+    fn logical_nulls(&self) -> Option<NullBuffer> {
+        self.as_ref().logical_nulls()
+    }
+
     fn is_null(&self, index: usize) -> bool {
         self.as_ref().is_null(index)
     }
@@ -268,6 +351,10 @@ impl Array for ArrayRef {
         self.as_ref().null_count()
     }
 
+    fn is_nullable(&self) -> bool {
+        self.as_ref().is_nullable()
+    }
+
     fn get_buffer_memory_size(&self) -> usize {
         self.as_ref().get_buffer_memory_size()
     }
@@ -282,16 +369,12 @@ impl<'a, T: Array> Array for &'a T {
         T::as_any(self)
     }
 
-    fn data(&self) -> &ArrayData {
-        T::data(self)
+    fn to_data(&self) -> ArrayData {
+        T::to_data(self)
     }
 
     fn into_data(self) -> ArrayData {
-        self.data().clone()
-    }
-
-    fn data_ref(&self) -> &ArrayData {
-        T::data_ref(self)
+        self.to_data()
     }
 
     fn data_type(&self) -> &DataType {
@@ -314,6 +397,14 @@ impl<'a, T: Array> Array for &'a T {
         T::offset(self)
     }
 
+    fn nulls(&self) -> Option<&NullBuffer> {
+        T::nulls(self)
+    }
+
+    fn logical_nulls(&self) -> Option<NullBuffer> {
+        T::logical_nulls(self)
+    }
+
     fn is_null(&self, index: usize) -> bool {
         T::is_null(self, index)
     }
@@ -326,6 +417,10 @@ impl<'a, T: Array> Array for &'a T {
         T::null_count(self)
     }
 
+    fn is_nullable(&self) -> bool {
+        T::is_nullable(self)
+    }
+
     fn get_buffer_memory_size(&self) -> usize {
         T::get_buffer_memory_size(self)
     }
@@ -336,7 +431,16 @@ impl<'a, T: Array> Array for &'a T {
 }
 
 /// A generic trait for accessing the values of an [`Array`]
+///
+/// # Validity
+///
+/// An [`ArrayAccessor`] must always return a well-defined value for an index that is
+/// within the bounds `0..Array::len`, including for null indexes where [`Array::is_null`] is true.
+///
+/// The value at null indexes is unspecified, and implementations must not rely on a specific
+/// value such as [`Default::default`] being returned, however, it must not be undefined
 pub trait ArrayAccessor: Array {
+    /// The Arrow type of the element being accessed.
     type Item: Send + Sync;
 
     /// Returns the element at index `i`
@@ -350,6 +454,84 @@ pub trait ArrayAccessor: Array {
     unsafe fn value_unchecked(&self, index: usize) -> Self::Item;
 }
 
+impl PartialEq for dyn Array + '_ {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl<T: Array> PartialEq<T> for dyn Array + '_ {
+    fn eq(&self, other: &T) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl PartialEq for NullArray {
+    fn eq(&self, other: &NullArray) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl<T: ArrowPrimitiveType> PartialEq for PrimitiveArray<T> {
+    fn eq(&self, other: &PrimitiveArray<T>) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl<K: ArrowDictionaryKeyType> PartialEq for DictionaryArray<K> {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl PartialEq for BooleanArray {
+    fn eq(&self, other: &BooleanArray) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait> PartialEq for GenericStringArray<OffsetSize> {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait> PartialEq for GenericBinaryArray<OffsetSize> {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl PartialEq for FixedSizeBinaryArray {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait> PartialEq for GenericListArray<OffsetSize> {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl PartialEq for MapArray {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl PartialEq for FixedSizeListArray {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
+impl PartialEq for StructArray {
+    fn eq(&self, other: &Self) -> bool {
+        self.to_data().eq(&other.to_data())
+    }
+}
+
 /// Constructs an array using the input `data`.
 /// Returns a reference-counted `Array` instance.
 pub fn make_array(data: ArrayData) -> ArrayRef {
@@ -368,9 +550,7 @@ pub fn make_array(data: ArrayData) -> ArrayRef {
         DataType::Float64 => Arc::new(Float64Array::from(data)) as ArrayRef,
         DataType::Date32 => Arc::new(Date32Array::from(data)) as ArrayRef,
         DataType::Date64 => Arc::new(Date64Array::from(data)) as ArrayRef,
-        DataType::Time32(TimeUnit::Second) => {
-            Arc::new(Time32SecondArray::from(data)) as ArrayRef
-        }
+        DataType::Time32(TimeUnit::Second) => Arc::new(Time32SecondArray::from(data)) as ArrayRef,
         DataType::Time32(TimeUnit::Millisecond) => {
             Arc::new(Time32MillisecondArray::from(data)) as ArrayRef
         }
@@ -415,62 +595,36 @@ pub fn make_array(data: ArrayData) -> ArrayRef {
         }
         DataType::Binary => Arc::new(BinaryArray::from(data)) as ArrayRef,
         DataType::LargeBinary => Arc::new(LargeBinaryArray::from(data)) as ArrayRef,
-        DataType::FixedSizeBinary(_) => {
-            Arc::new(FixedSizeBinaryArray::from(data)) as ArrayRef
-        }
+        DataType::FixedSizeBinary(_) => Arc::new(FixedSizeBinaryArray::from(data)) as ArrayRef,
         DataType::Utf8 => Arc::new(StringArray::from(data)) as ArrayRef,
         DataType::LargeUtf8 => Arc::new(LargeStringArray::from(data)) as ArrayRef,
         DataType::List(_) => Arc::new(ListArray::from(data)) as ArrayRef,
         DataType::LargeList(_) => Arc::new(LargeListArray::from(data)) as ArrayRef,
         DataType::Struct(_) => Arc::new(StructArray::from(data)) as ArrayRef,
         DataType::Map(_, _) => Arc::new(MapArray::from(data)) as ArrayRef,
-        DataType::Union(_, _, _) => Arc::new(UnionArray::from(data)) as ArrayRef,
-        DataType::FixedSizeList(_, _) => {
-            Arc::new(FixedSizeListArray::from(data)) as ArrayRef
-        }
+        DataType::Union(_, _) => Arc::new(UnionArray::from(data)) as ArrayRef,
+        DataType::FixedSizeList(_, _) => Arc::new(FixedSizeListArray::from(data)) as ArrayRef,
         DataType::Dictionary(ref key_type, _) => match key_type.as_ref() {
-            DataType::Int8 => {
-                Arc::new(DictionaryArray::<Int8Type>::from(data)) as ArrayRef
-            }
-            DataType::Int16 => {
-                Arc::new(DictionaryArray::<Int16Type>::from(data)) as ArrayRef
-            }
-            DataType::Int32 => {
-                Arc::new(DictionaryArray::<Int32Type>::from(data)) as ArrayRef
-            }
-            DataType::Int64 => {
-                Arc::new(DictionaryArray::<Int64Type>::from(data)) as ArrayRef
-            }
-            DataType::UInt8 => {
-                Arc::new(DictionaryArray::<UInt8Type>::from(data)) as ArrayRef
-            }
-            DataType::UInt16 => {
-                Arc::new(DictionaryArray::<UInt16Type>::from(data)) as ArrayRef
-            }
-            DataType::UInt32 => {
-                Arc::new(DictionaryArray::<UInt32Type>::from(data)) as ArrayRef
-            }
-            DataType::UInt64 => {
-                Arc::new(DictionaryArray::<UInt64Type>::from(data)) as ArrayRef
-            }
-            dt => panic!("Unexpected dictionary key type {:?}", dt),
+            DataType::Int8 => Arc::new(DictionaryArray::<Int8Type>::from(data)) as ArrayRef,
+            DataType::Int16 => Arc::new(DictionaryArray::<Int16Type>::from(data)) as ArrayRef,
+            DataType::Int32 => Arc::new(DictionaryArray::<Int32Type>::from(data)) as ArrayRef,
+            DataType::Int64 => Arc::new(DictionaryArray::<Int64Type>::from(data)) as ArrayRef,
+            DataType::UInt8 => Arc::new(DictionaryArray::<UInt8Type>::from(data)) as ArrayRef,
+            DataType::UInt16 => Arc::new(DictionaryArray::<UInt16Type>::from(data)) as ArrayRef,
+            DataType::UInt32 => Arc::new(DictionaryArray::<UInt32Type>::from(data)) as ArrayRef,
+            DataType::UInt64 => Arc::new(DictionaryArray::<UInt64Type>::from(data)) as ArrayRef,
+            dt => panic!("Unexpected dictionary key type {dt:?}"),
+        },
+        DataType::RunEndEncoded(ref run_ends_type, _) => match run_ends_type.data_type() {
+            DataType::Int16 => Arc::new(RunArray::<Int16Type>::from(data)) as ArrayRef,
+            DataType::Int32 => Arc::new(RunArray::<Int32Type>::from(data)) as ArrayRef,
+            DataType::Int64 => Arc::new(RunArray::<Int64Type>::from(data)) as ArrayRef,
+            dt => panic!("Unexpected data type for run_ends array {dt:?}"),
         },
         DataType::Null => Arc::new(NullArray::from(data)) as ArrayRef,
         DataType::Decimal128(_, _) => Arc::new(Decimal128Array::from(data)) as ArrayRef,
         DataType::Decimal256(_, _) => Arc::new(Decimal256Array::from(data)) as ArrayRef,
-        dt => panic!("Unexpected data type {:?}", dt),
-    }
-}
-
-impl From<ArrayData> for ArrayRef {
-    fn from(data: ArrayData) -> Self {
-        make_array(data)
-    }
-}
-
-impl From<ArrayRef> for ArrayData {
-    fn from(array: ArrayRef) -> Self {
-        array.data().clone()
+        dt => panic!("Unexpected data type {dt:?}"),
     }
 }
 
@@ -478,8 +632,8 @@ impl From<ArrayRef> for ArrayData {
 ///
 /// ```
 /// use std::sync::Arc;
-/// use arrow::datatypes::DataType;
-/// use arrow::array::{ArrayRef, Int32Array, new_empty_array};
+/// use arrow_schema::DataType;
+/// use arrow_array::{ArrayRef, Int32Array, new_empty_array};
 ///
 /// let empty_array = new_empty_array(&DataType::Int32);
 /// let array: ArrayRef = Arc::new(Int32Array::from(vec![] as Vec<i32>));
@@ -496,8 +650,8 @@ pub fn new_empty_array(data_type: &DataType) -> ArrayRef {
 ///
 /// ```
 /// use std::sync::Arc;
-/// use arrow::datatypes::DataType;
-/// use arrow::array::{ArrayRef, Int32Array, new_null_array};
+/// use arrow_schema::DataType;
+/// use arrow_array::{ArrayRef, Int32Array, new_null_array};
 ///
 /// let null_array = new_null_array(&DataType::Int32, 3);
 /// let array: ArrayRef = Arc::new(Int32Array::from(vec![None, None, None]));
@@ -505,217 +659,32 @@ pub fn new_empty_array(data_type: &DataType) -> ArrayRef {
 /// assert_eq!(&array, &null_array);
 /// ```
 pub fn new_null_array(data_type: &DataType, length: usize) -> ArrayRef {
-    // context: https://github.com/apache/arrow/pull/9469#discussion_r574761687
-    match data_type {
-        DataType::Null => Arc::new(NullArray::new(length)),
-        DataType::Boolean => {
-            let null_buf: Buffer = MutableBuffer::new_null(length).into();
-            make_array(unsafe {
-                ArrayData::new_unchecked(
-                    data_type.clone(),
-                    length,
-                    Some(length),
-                    Some(null_buf.clone()),
-                    0,
-                    vec![null_buf],
-                    vec![],
-                )
-            })
-        }
-        DataType::Int8 => new_null_sized_array::<Int8Type>(data_type, length),
-        DataType::UInt8 => new_null_sized_array::<UInt8Type>(data_type, length),
-        DataType::Int16 => new_null_sized_array::<Int16Type>(data_type, length),
-        DataType::UInt16 => new_null_sized_array::<UInt16Type>(data_type, length),
-        DataType::Float16 => new_null_sized_array::<Float16Type>(data_type, length),
-        DataType::Int32 => new_null_sized_array::<Int32Type>(data_type, length),
-        DataType::UInt32 => new_null_sized_array::<UInt32Type>(data_type, length),
-        DataType::Float32 => new_null_sized_array::<Float32Type>(data_type, length),
-        DataType::Date32 => new_null_sized_array::<Date32Type>(data_type, length),
-        // expanding this into Date23{unit}Type results in needless branching
-        DataType::Time32(_) => new_null_sized_array::<Int32Type>(data_type, length),
-        DataType::Int64 => new_null_sized_array::<Int64Type>(data_type, length),
-        DataType::UInt64 => new_null_sized_array::<UInt64Type>(data_type, length),
-        DataType::Float64 => new_null_sized_array::<Float64Type>(data_type, length),
-        DataType::Date64 => new_null_sized_array::<Date64Type>(data_type, length),
-        // expanding this into Timestamp{unit}Type results in needless branching
-        DataType::Timestamp(_, _) => new_null_sized_array::<Int64Type>(data_type, length),
-        DataType::Time64(_) => new_null_sized_array::<Int64Type>(data_type, length),
-        DataType::Duration(_) => new_null_sized_array::<Int64Type>(data_type, length),
-        DataType::Interval(unit) => match unit {
-            IntervalUnit::YearMonth => {
-                new_null_sized_array::<IntervalYearMonthType>(data_type, length)
-            }
-            IntervalUnit::DayTime => {
-                new_null_sized_array::<IntervalDayTimeType>(data_type, length)
-            }
-            IntervalUnit::MonthDayNano => {
-                new_null_sized_array::<IntervalMonthDayNanoType>(data_type, length)
-            }
-        },
-        DataType::FixedSizeBinary(value_len) => make_array(unsafe {
-            ArrayData::new_unchecked(
-                data_type.clone(),
-                length,
-                Some(length),
-                Some(MutableBuffer::new_null(length).into()),
-                0,
-                vec![Buffer::from(vec![0u8; *value_len as usize * length])],
-                vec![],
-            )
-        }),
-        DataType::Binary | DataType::Utf8 => {
-            new_null_binary_array::<i32>(data_type, length)
-        }
-        DataType::LargeBinary | DataType::LargeUtf8 => {
-            new_null_binary_array::<i64>(data_type, length)
-        }
-        DataType::List(field) => {
-            new_null_list_array::<i32>(data_type, field.data_type(), length)
-        }
-        DataType::LargeList(field) => {
-            new_null_list_array::<i64>(data_type, field.data_type(), length)
-        }
-        DataType::FixedSizeList(field, value_len) => make_array(unsafe {
-            ArrayData::new_unchecked(
-                data_type.clone(),
-                length,
-                Some(length),
-                Some(MutableBuffer::new_null(length).into()),
-                0,
-                vec![],
-                vec![
-                    new_null_array(field.data_type(), *value_len as usize * length)
-                        .data()
-                        .clone(),
-                ],
-            )
-        }),
-        DataType::Struct(fields) => {
-            let fields: Vec<_> = fields
-                .iter()
-                .map(|field| (field.clone(), new_null_array(field.data_type(), length)))
-                .collect();
-
-            let null_buffer = MutableBuffer::new_null(length);
-            Arc::new(StructArray::from((fields, null_buffer.into())))
-        }
-        DataType::Map(field, _keys_sorted) => {
-            new_null_list_array::<i32>(data_type, field.data_type(), length)
-        }
-        DataType::Union(_, _, _) => {
-            unimplemented!("Creating null Union array not yet supported")
-        }
-        DataType::Dictionary(key, value) => {
-            let keys = new_null_array(key, length);
-            let keys = keys.data();
-
-            make_array(unsafe {
-                ArrayData::new_unchecked(
-                    data_type.clone(),
-                    length,
-                    Some(length),
-                    keys.null_buffer().cloned(),
-                    0,
-                    keys.buffers().into(),
-                    vec![new_empty_array(value.as_ref()).into_data()],
-                )
-            })
-        }
-        DataType::Decimal128(_, _) => {
-            new_null_sized_decimal(data_type, length, std::mem::size_of::<i128>())
-        }
-        DataType::Decimal256(_, _) => new_null_sized_decimal(data_type, length, 32),
-    }
-}
-
-#[inline]
-fn new_null_list_array<OffsetSize: OffsetSizeTrait>(
-    data_type: &DataType,
-    child_data_type: &DataType,
-    length: usize,
-) -> ArrayRef {
-    make_array(unsafe {
-        ArrayData::new_unchecked(
-            data_type.clone(),
-            length,
-            Some(length),
-            Some(MutableBuffer::new_null(length).into()),
-            0,
-            vec![Buffer::from(
-                vec![OffsetSize::zero(); length + 1].to_byte_slice(),
-            )],
-            vec![ArrayData::new_empty(child_data_type)],
-        )
-    })
+    make_array(ArrayData::new_null(data_type, length))
 }
 
-#[inline]
-fn new_null_binary_array<OffsetSize: OffsetSizeTrait>(
-    data_type: &DataType,
-    length: usize,
-) -> ArrayRef {
-    make_array(unsafe {
-        ArrayData::new_unchecked(
-            data_type.clone(),
-            length,
-            Some(length),
-            Some(MutableBuffer::new_null(length).into()),
-            0,
-            vec![
-                Buffer::from(vec![OffsetSize::zero(); length + 1].to_byte_slice()),
-                MutableBuffer::new(0).into(),
-            ],
-            vec![],
-        )
-    })
-}
-
-#[inline]
-fn new_null_sized_array<T: ArrowPrimitiveType>(
-    data_type: &DataType,
-    length: usize,
-) -> ArrayRef {
-    make_array(unsafe {
-        ArrayData::new_unchecked(
-            data_type.clone(),
-            length,
-            Some(length),
-            Some(MutableBuffer::new_null(length).into()),
-            0,
-            vec![Buffer::from(vec![0u8; length * T::get_byte_width()])],
-            vec![],
-        )
-    })
-}
-
-#[inline]
-fn new_null_sized_decimal(
-    data_type: &DataType,
-    length: usize,
-    byte_width: usize,
-) -> ArrayRef {
-    make_array(unsafe {
-        ArrayData::new_unchecked(
-            data_type.clone(),
-            length,
-            Some(length),
-            Some(MutableBuffer::new_null(length).into()),
-            0,
-            vec![Buffer::from(vec![0u8; length * byte_width])],
-            vec![],
-        )
-    })
+/// Helper function that gets offset from an [`ArrayData`]
+///
+/// # Safety
+///
+/// - ArrayData must contain a valid [`OffsetBuffer`] as its first buffer
+unsafe fn get_offsets<O: ArrowNativeType>(data: &ArrayData) -> OffsetBuffer<O> {
+    match data.is_empty() && data.buffers()[0].is_empty() {
+        true => OffsetBuffer::new_empty(),
+        false => {
+            let buffer =
+                ScalarBuffer::new(data.buffers()[0].clone(), data.offset(), data.len() + 1);
+            // Safety:
+            // ArrayData is valid
+            unsafe { OffsetBuffer::new_unchecked(buffer) }
+        }
+    }
 }
 
-// Helper function for printing potentially long arrays.
-pub(super) fn print_long_array<A, F>(
-    array: &A,
-    f: &mut fmt::Formatter,
-    print_item: F,
-) -> fmt::Result
+/// Helper function for printing potentially long arrays.
+fn print_long_array<A, F>(array: &A, f: &mut std::fmt::Formatter, print_item: F) -> std::fmt::Result
 where
     A: Array,
-    F: Fn(&A, usize, &mut fmt::Formatter) -> fmt::Result,
+    F: Fn(&A, usize, &mut std::fmt::Formatter) -> std::fmt::Result,
 {
     let head = std::cmp::min(10, array.len());
 
@@ -751,6 +720,10 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::cast::{as_union_array, downcast_array};
+    use crate::downcast_run_array;
+    use arrow_buffer::MutableBuffer;
+    use arrow_schema::{Field, Fields, UnionFields, UnionMode};
 
     #[test]
     fn test_empty_primitive() {
@@ -771,8 +744,7 @@ mod tests {
 
     #[test]
     fn test_empty_list_primitive() {
-        let data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
+        let data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
         let array = new_empty_array(&data_type);
         let a = array.as_any().downcast_ref::<ListArray>().unwrap();
         assert_eq!(a.len(), 0);
@@ -801,8 +773,9 @@ mod tests {
 
     #[test]
     fn test_null_struct() {
-        let struct_type =
-            DataType::Struct(vec![Field::new("data", DataType::Int64, false)]);
+        // It is possible to create a null struct containing a non-nullable child
+        // see https://github.com/apache/arrow-rs/pull/3244 for details
+        let struct_type = DataType::Struct(vec![Field::new("data", DataType::Int64, false)].into());
         let array = new_null_array(&struct_type, 9);
 
         let a = array.as_any().downcast_ref::<StructArray>().unwrap();
@@ -829,8 +802,7 @@ mod tests {
 
     #[test]
     fn test_null_list_primitive() {
-        let data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, true)));
+        let data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, true)));
         let array = new_null_array(&data_type, 9);
         let a = array.as_any().downcast_ref::<ListArray>().unwrap();
         assert_eq!(a.len(), 9);
@@ -843,12 +815,12 @@ mod tests {
     #[test]
     fn test_null_map() {
         let data_type = DataType::Map(
-            Box::new(Field::new(
+            Arc::new(Field::new(
                 "entry",
-                DataType::Struct(vec![
+                DataType::Struct(Fields::from(vec![
                     Field::new("key", DataType::Utf8, false),
                     Field::new("value", DataType::Int32, true),
-                ]),
+                ])),
                 false,
             )),
             false,
@@ -864,8 +836,8 @@ mod tests {
 
     #[test]
     fn test_null_dictionary() {
-        let values = vec![None, None, None, None, None, None, None, None, None]
-            as Vec<Option<&str>>;
+        let values =
+            vec![None, None, None, None, None, None, None, None, None] as Vec<Option<&str>>;
 
         let array: DictionaryArray<Int8Type> = values.into_iter().collect();
         let array = Arc::new(array) as ArrayRef;
@@ -873,39 +845,120 @@ mod tests {
         let null_array = new_null_array(array.data_type(), 9);
         assert_eq!(&array, &null_array);
         assert_eq!(
-            array.data().buffers()[0].len(),
-            null_array.data().buffers()[0].len()
+            array.to_data().buffers()[0].len(),
+            null_array.to_data().buffers()[0].len()
         );
     }
 
+    #[test]
+    fn test_null_union() {
+        for mode in [UnionMode::Sparse, UnionMode::Dense] {
+            let data_type = DataType::Union(
+                UnionFields::new(
+                    vec![2, 1],
+                    vec![
+                        Field::new("foo", DataType::Int32, true),
+                        Field::new("bar", DataType::Int64, true),
+                    ],
+                ),
+                mode,
+            );
+            let array = new_null_array(&data_type, 4);
+
+            let array = as_union_array(array.as_ref());
+            assert_eq!(array.len(), 4);
+            assert_eq!(array.null_count(), 0);
+
+            for i in 0..4 {
+                let a = array.value(i);
+                assert_eq!(a.len(), 1);
+                assert_eq!(a.null_count(), 1);
+                assert!(a.is_null(0))
+            }
+
+            array.to_data().validate_full().unwrap();
+        }
+    }
+
+    #[test]
+    #[allow(unused_parens)]
+    fn test_null_runs() {
+        for r in [DataType::Int16, DataType::Int32, DataType::Int64] {
+            let data_type = DataType::RunEndEncoded(
+                Arc::new(Field::new("run_ends", r, false)),
+                Arc::new(Field::new("values", DataType::Utf8, true)),
+            );
+
+            let array = new_null_array(&data_type, 4);
+            let array = array.as_ref();
+
+            downcast_run_array! {
+                array => {
+                    assert_eq!(array.len(), 4);
+                    assert_eq!(array.null_count(), 0);
+                    assert_eq!(array.values().len(), 1);
+                    assert_eq!(array.values().null_count(), 1);
+                    assert_eq!(array.run_ends().len(), 4);
+                    assert_eq!(array.run_ends().values(), &[4]);
+
+                    let idx = array.get_physical_indices(&[0, 1, 2, 3]).unwrap();
+                    assert_eq!(idx, &[0,0,0,0]);
+                }
+                d => unreachable!("{d}")
+            }
+        }
+    }
+
+    #[test]
+    fn test_null_fixed_size_binary() {
+        for size in [1, 2, 7] {
+            let array = new_null_array(&DataType::FixedSizeBinary(size), 6);
+            let array = array
+                .as_ref()
+                .as_any()
+                .downcast_ref::<FixedSizeBinaryArray>()
+                .unwrap();
+
+            assert_eq!(array.len(), 6);
+            assert_eq!(array.null_count(), 6);
+            array.iter().for_each(|x| assert!(x.is_none()));
+        }
+    }
+
     #[test]
     fn test_memory_size_null() {
         let null_arr = NullArray::new(32);
 
         assert_eq!(0, null_arr.get_buffer_memory_size());
         assert_eq!(
-            std::mem::size_of::<NullArray>(),
+            std::mem::size_of::<usize>(),
             null_arr.get_array_memory_size()
         );
-        assert_eq!(
-            std::mem::size_of::<NullArray>(),
-            std::mem::size_of::<ArrayData>(),
-        );
     }
 
     #[test]
     fn test_memory_size_primitive() {
         let arr = PrimitiveArray::<Int64Type>::from_iter_values(0..128);
-        let empty =
-            PrimitiveArray::<Int64Type>::from(ArrayData::new_empty(arr.data_type()));
+        let empty = PrimitiveArray::<Int64Type>::from(ArrayData::new_empty(arr.data_type()));
 
-        // substract empty array to avoid magic numbers for the size of additional fields
+        // subtract empty array to avoid magic numbers for the size of additional fields
         assert_eq!(
             arr.get_array_memory_size() - empty.get_array_memory_size(),
             128 * std::mem::size_of::<i64>()
         );
     }
 
+    #[test]
+    fn test_memory_size_primitive_sliced() {
+        let arr = PrimitiveArray::<Int64Type>::from_iter_values(0..128);
+        let slice1 = arr.slice(0, 64);
+        let slice2 = arr.slice(64, 64);
+
+        // both slices report the full buffer memory usage, even though the buffers are shared
+        assert_eq!(slice1.get_array_memory_size(), arr.get_array_memory_size());
+        assert_eq!(slice2.get_array_memory_size(), arr.get_array_memory_size());
+    }
+
     #[test]
     fn test_memory_size_primitive_nullable() {
         let arr: PrimitiveArray<Int64Type> = (0..128)
@@ -923,12 +976,11 @@ mod tests {
         // which includes the optional validity buffer
         // plus one buffer on the heap
         assert_eq!(
-            std::mem::size_of::<PrimitiveArray<Int64Type>>()
-                + std::mem::size_of::<Buffer>(),
+            std::mem::size_of::<PrimitiveArray<Int64Type>>(),
             empty_with_bitmap.get_array_memory_size()
         );
 
-        // substract empty array to avoid magic numbers for the size of additional fields
+        // subtract empty array to avoid magic numbers for the size of additional fields
         // the size of the validity bitmap is rounded up to 64 bytes
         assert_eq!(
             arr.get_array_memory_size() - empty_with_bitmap.get_array_memory_size(),
@@ -943,19 +995,17 @@ mod tests {
             (0..256).map(|i| (i % values.len()) as i16),
         );
 
-        let dict_data = ArrayData::builder(DataType::Dictionary(
+        let dict_data_type = DataType::Dictionary(
             Box::new(keys.data_type().clone()),
             Box::new(values.data_type().clone()),
-        ))
-        .len(keys.len())
-        .buffers(keys.data_ref().buffers().to_vec())
-        .child_data(vec![ArrayData::builder(DataType::Int64)
-            .len(values.len())
-            .buffers(values.data_ref().buffers().to_vec())
+        );
+        let dict_data = keys
+            .into_data()
+            .into_builder()
+            .data_type(dict_data_type)
+            .child_data(vec![values.into_data()])
             .build()
-            .unwrap()])
-        .build()
-        .unwrap();
+            .unwrap();
 
         let empty_data = ArrayData::new_empty(&DataType::Dictionary(
             Box::new(DataType::Int16),
@@ -1001,4 +1051,15 @@ mod tests {
         assert!(compute_my_thing(&arr));
         assert!(compute_my_thing(arr.as_ref()));
     }
+
+    #[test]
+    fn test_downcast_array() {
+        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
+
+        let boxed: ArrayRef = Arc::new(array);
+        let array: Int32Array = downcast_array(&boxed);
+
+        let expected: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
+        assert_eq!(array, expected);
+    }
 }
diff --git a/arrow/src/array/null.rs b/arrow-array/src/array/null_array.rs
similarity index 50%
rename from arrow/src/array/null.rs
rename to arrow-array/src/array/null_array.rs
index 467121f6ccfa..af3ec0b57d27 100644
--- a/arrow/src/array/null.rs
+++ b/arrow-array/src/array/null_array.rs
@@ -17,32 +17,33 @@
 
 //! Contains the `NullArray` type.
 
+use crate::builder::NullBuilder;
+use crate::{Array, ArrayRef};
+use arrow_buffer::buffer::NullBuffer;
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::DataType;
 use std::any::Any;
-use std::fmt;
+use std::sync::Arc;
 
-use crate::array::{Array, ArrayData};
-use crate::datatypes::*;
-
-/// An Array where all elements are nulls
+/// An array of [null values](https://arrow.apache.org/docs/format/Columnar.html#null-layout)
 ///
 /// A `NullArray` is a simplified array where all values are null.
 ///
 /// # Example: Create an array
 ///
 /// ```
-/// use arrow::array::{Array, NullArray};
+/// use arrow_array::{Array, NullArray};
 ///
-/// # fn main() -> arrow::error::Result<()> {
 /// let array = NullArray::new(10);
 ///
+/// assert!(array.is_nullable());
 /// assert_eq!(array.len(), 10);
-/// assert_eq!(array.null_count(), 10);
-///
-/// # Ok(())
-/// # }
+/// assert_eq!(array.null_count(), 0);
+/// assert_eq!(array.logical_nulls().unwrap().null_count(), 10);
 /// ```
+#[derive(Clone)]
 pub struct NullArray {
-    data: ArrayData,
+    len: usize,
 }
 
 impl NullArray {
@@ -52,9 +53,22 @@ impl NullArray {
     /// other [`DataType`].
     ///
     pub fn new(length: usize) -> Self {
-        let array_data = ArrayData::builder(DataType::Null).len(length);
-        let array_data = unsafe { array_data.build_unchecked() };
-        NullArray::from(array_data)
+        Self { len: length }
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, len: usize) -> Self {
+        assert!(
+            offset.saturating_add(len) <= self.len,
+            "the length + offset of the sliced BooleanBuffer cannot exceed the existing length"
+        );
+
+        Self { len }
+    }
+
+    /// Returns a new null array builder
+    pub fn builder(capacity: usize) -> NullBuilder {
+        NullBuilder::with_capacity(capacity)
     }
 }
 
@@ -63,30 +77,52 @@ impl Array for NullArray {
         self
     }
 
-    fn data(&self) -> &ArrayData {
-        &self.data
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
     }
 
     fn into_data(self) -> ArrayData {
         self.into()
     }
 
-    /// Returns whether the element at `index` is null.
-    /// All elements of a `NullArray` are always null.
-    fn is_null(&self, _index: usize) -> bool {
-        true
+    fn data_type(&self) -> &DataType {
+        &DataType::Null
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.len
+    }
+
+    fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    fn offset(&self) -> usize {
+        0
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        None
+    }
+
+    fn logical_nulls(&self) -> Option<NullBuffer> {
+        (self.len != 0).then(|| NullBuffer::new_null(self.len))
+    }
+
+    fn is_nullable(&self) -> bool {
+        !self.is_empty()
     }
 
-    /// Returns whether the element at `index` is valid.
-    /// All elements of a `NullArray` are always invalid.
-    fn is_valid(&self, _index: usize) -> bool {
-        false
+    fn get_buffer_memory_size(&self) -> usize {
+        0
     }
 
-    /// Returns the total number of null values in this array.
-    /// The null count of a `NullArray` always equals its length.
-    fn null_count(&self) -> usize {
-        self.data_ref().len()
+    fn get_array_memory_size(&self) -> usize {
+        std::mem::size_of::<Self>()
     }
 }
 
@@ -103,21 +139,22 @@ impl From<ArrayData> for NullArray {
             "NullArray data should contain 0 buffers"
         );
         assert!(
-            data.null_buffer().is_none(),
+            data.nulls().is_none(),
             "NullArray data should not contain a null buffer, as no buffers are required"
         );
-        Self { data }
+        Self { len: data.len() }
     }
 }
 
 impl From<NullArray> for ArrayData {
     fn from(array: NullArray) -> Self {
-        array.data
+        let builder = ArrayDataBuilder::new(DataType::Null).len(array.len);
+        unsafe { builder.build_unchecked() }
     }
 }
 
-impl fmt::Debug for NullArray {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl std::fmt::Debug for NullArray {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "NullArray({})", self.len())
     }
 }
@@ -131,8 +168,10 @@ mod tests {
         let null_arr = NullArray::new(32);
 
         assert_eq!(null_arr.len(), 32);
-        assert_eq!(null_arr.null_count(), 32);
-        assert!(!null_arr.is_valid(0));
+        assert_eq!(null_arr.null_count(), 0);
+        assert_eq!(null_arr.logical_nulls().unwrap().null_count(), 32);
+        assert!(null_arr.is_valid(0));
+        assert!(null_arr.is_nullable());
     }
 
     #[test]
@@ -141,13 +180,15 @@ mod tests {
 
         let array2 = array1.slice(8, 16);
         assert_eq!(array2.len(), 16);
-        assert_eq!(array2.null_count(), 16);
-        assert_eq!(array2.offset(), 8);
+        assert_eq!(array2.null_count(), 0);
+        assert_eq!(array2.logical_nulls().unwrap().null_count(), 16);
+        assert!(array2.is_valid(0));
+        assert!(array2.is_nullable());
     }
 
     #[test]
     fn test_debug_null_array() {
         let array = NullArray::new(1024 * 1024);
-        assert_eq!(format!("{:?}", array), "NullArray(1048576)");
+        assert_eq!(format!("{array:?}"), "NullArray(1048576)");
     }
 }
diff --git a/arrow-array/src/array/primitive_array.rs b/arrow-array/src/array/primitive_array.rs
new file mode 100644
index 000000000000..a800aa6bf924
--- /dev/null
+++ b/arrow-array/src/array/primitive_array.rs
@@ -0,0 +1,2564 @@
+// 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.
+
+use crate::array::print_long_array;
+use crate::builder::{BooleanBufferBuilder, BufferBuilder, PrimitiveBuilder};
+use crate::iterator::PrimitiveIter;
+use crate::temporal_conversions::{
+    as_date, as_datetime, as_datetime_with_timezone, as_duration, as_time,
+};
+use crate::timezone::Tz;
+use crate::trusted_len::trusted_len_unzip;
+use crate::types::*;
+use crate::{Array, ArrayAccessor, ArrayRef, Scalar};
+use arrow_buffer::{i256, ArrowNativeType, Buffer, NullBuffer, ScalarBuffer};
+use arrow_data::bit_iterator::try_for_each_valid_idx;
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType};
+use chrono::{DateTime, Duration, NaiveDate, NaiveDateTime, NaiveTime};
+use half::f16;
+use std::any::Any;
+use std::sync::Arc;
+
+/// A [`PrimitiveArray`] of `i8`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::Int8Array;
+/// // Create from Vec<Option<i8>>
+/// let arr = Int8Array::from(vec![Some(1), None, Some(2)]);
+/// // Create from Vec<i8>
+/// let arr = Int8Array::from(vec![1, 2, 3]);
+/// // Create iter/collect
+/// let arr: Int8Array = std::iter::repeat(42).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type Int8Array = PrimitiveArray<Int8Type>;
+
+/// A [`PrimitiveArray`] of `i16`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::Int16Array;
+/// // Create from Vec<Option<i16>>
+/// let arr = Int16Array::from(vec![Some(1), None, Some(2)]);
+/// // Create from Vec<i16>
+/// let arr = Int16Array::from(vec![1, 2, 3]);
+/// // Create iter/collect
+/// let arr: Int16Array = std::iter::repeat(42).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type Int16Array = PrimitiveArray<Int16Type>;
+
+/// A [`PrimitiveArray`] of `i32`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::Int32Array;
+/// // Create from Vec<Option<i32>>
+/// let arr = Int32Array::from(vec![Some(1), None, Some(2)]);
+/// // Create from Vec<i32>
+/// let arr = Int32Array::from(vec![1, 2, 3]);
+/// // Create iter/collect
+/// let arr: Int32Array = std::iter::repeat(42).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type Int32Array = PrimitiveArray<Int32Type>;
+
+/// A [`PrimitiveArray`] of `i64`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::Int64Array;
+/// // Create from Vec<Option<i64>>
+/// let arr = Int64Array::from(vec![Some(1), None, Some(2)]);
+/// // Create from Vec<i64>
+/// let arr = Int64Array::from(vec![1, 2, 3]);
+/// // Create iter/collect
+/// let arr: Int64Array = std::iter::repeat(42).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type Int64Array = PrimitiveArray<Int64Type>;
+
+/// A [`PrimitiveArray`] of `u8`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::UInt8Array;
+/// // Create from Vec<Option<u8>>
+/// let arr = UInt8Array::from(vec![Some(1), None, Some(2)]);
+/// // Create from Vec<u8>
+/// let arr = UInt8Array::from(vec![1, 2, 3]);
+/// // Create iter/collect
+/// let arr: UInt8Array = std::iter::repeat(42).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type UInt8Array = PrimitiveArray<UInt8Type>;
+
+/// A [`PrimitiveArray`] of `u16`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::UInt16Array;
+/// // Create from Vec<Option<u16>>
+/// let arr = UInt16Array::from(vec![Some(1), None, Some(2)]);
+/// // Create from Vec<u16>
+/// let arr = UInt16Array::from(vec![1, 2, 3]);
+/// // Create iter/collect
+/// let arr: UInt16Array = std::iter::repeat(42).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type UInt16Array = PrimitiveArray<UInt16Type>;
+
+/// A [`PrimitiveArray`] of `u32`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::UInt32Array;
+/// // Create from Vec<Option<u32>>
+/// let arr = UInt32Array::from(vec![Some(1), None, Some(2)]);
+/// // Create from Vec<u32>
+/// let arr = UInt32Array::from(vec![1, 2, 3]);
+/// // Create iter/collect
+/// let arr: UInt32Array = std::iter::repeat(42).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type UInt32Array = PrimitiveArray<UInt32Type>;
+
+/// A [`PrimitiveArray`] of `u64`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::UInt64Array;
+/// // Create from Vec<Option<u64>>
+/// let arr = UInt64Array::from(vec![Some(1), None, Some(2)]);
+/// // Create from Vec<u64>
+/// let arr = UInt64Array::from(vec![1, 2, 3]);
+/// // Create iter/collect
+/// let arr: UInt64Array = std::iter::repeat(42).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type UInt64Array = PrimitiveArray<UInt64Type>;
+
+/// A [`PrimitiveArray`] of `f16`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::Float16Array;
+/// use half::f16;
+/// // Create from Vec<Option<f16>>
+/// let arr = Float16Array::from(vec![Some(f16::from_f64(1.0)), Some(f16::from_f64(2.0))]);
+/// // Create from Vec<i8>
+/// let arr = Float16Array::from(vec![f16::from_f64(1.0), f16::from_f64(2.0), f16::from_f64(3.0)]);
+/// // Create iter/collect
+/// let arr: Float16Array = std::iter::repeat(f16::from_f64(1.0)).take(10).collect();
+/// ```
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::Float16Array;
+/// use half::f16;
+/// let arr : Float16Array = [Some(f16::from_f64(1.0)), Some(f16::from_f64(2.0))].into_iter().collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type Float16Array = PrimitiveArray<Float16Type>;
+
+/// A [`PrimitiveArray`] of `f32`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::Float32Array;
+/// // Create from Vec<Option<f32>>
+/// let arr = Float32Array::from(vec![Some(1.0), None, Some(2.0)]);
+/// // Create from Vec<f32>
+/// let arr = Float32Array::from(vec![1.0, 2.0, 3.0]);
+/// // Create iter/collect
+/// let arr: Float32Array = std::iter::repeat(42.0).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type Float32Array = PrimitiveArray<Float32Type>;
+
+/// A [`PrimitiveArray`] of `f64`
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::Float32Array;
+/// // Create from Vec<Option<f32>>
+/// let arr = Float32Array::from(vec![Some(1.0), None, Some(2.0)]);
+/// // Create from Vec<f32>
+/// let arr = Float32Array::from(vec![1.0, 2.0, 3.0]);
+/// // Create iter/collect
+/// let arr: Float32Array = std::iter::repeat(42.0).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type Float64Array = PrimitiveArray<Float64Type>;
+
+/// A [`PrimitiveArray`] of seconds since UNIX epoch stored as `i64`
+///
+/// This type is similar to the [`chrono::DateTime`] type and can hold
+/// values such as `1970-05-09 14:25:11 +01:00`
+///
+/// See also [`Timestamp`](arrow_schema::DataType::Timestamp).
+///
+/// # Example: UTC timestamps post epoch
+/// ```
+/// # use arrow_array::TimestampSecondArray;
+/// use arrow_array::timezone::Tz;
+/// // Corresponds to single element array with entry 1970-05-09T14:25:11+0:00
+/// let arr = TimestampSecondArray::from(vec![11111111]);
+/// // OR
+/// let arr = TimestampSecondArray::from(vec![Some(11111111)]);
+/// let utc_tz: Tz = "+00:00".parse().unwrap();
+///
+/// assert_eq!(arr.value_as_datetime_with_tz(0, utc_tz).map(|v| v.to_string()).unwrap(), "1970-05-09 14:25:11 +00:00")
+/// ```
+///
+/// # Example: UTC timestamps pre epoch
+/// ```
+/// # use arrow_array::TimestampSecondArray;
+/// use arrow_array::timezone::Tz;
+/// // Corresponds to single element array with entry 1969-08-25T09:34:49+0:00
+/// let arr = TimestampSecondArray::from(vec![-11111111]);
+/// // OR
+/// let arr = TimestampSecondArray::from(vec![Some(-11111111)]);
+/// let utc_tz: Tz = "+00:00".parse().unwrap();
+///
+/// assert_eq!(arr.value_as_datetime_with_tz(0, utc_tz).map(|v| v.to_string()).unwrap(), "1969-08-25 09:34:49 +00:00")
+/// ```
+///
+/// # Example: With timezone specified
+/// ```
+/// # use arrow_array::TimestampSecondArray;
+/// use arrow_array::timezone::Tz;
+/// // Corresponds to single element array with entry 1970-05-10T00:25:11+10:00
+/// let arr = TimestampSecondArray::from(vec![11111111]).with_timezone("+10:00".to_string());
+/// // OR
+/// let arr = TimestampSecondArray::from(vec![Some(11111111)]).with_timezone("+10:00".to_string());
+/// let sydney_tz: Tz = "+10:00".parse().unwrap();
+///
+/// assert_eq!(arr.value_as_datetime_with_tz(0, sydney_tz).map(|v| v.to_string()).unwrap(), "1970-05-10 00:25:11 +10:00")
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type TimestampSecondArray = PrimitiveArray<TimestampSecondType>;
+
+/// A [`PrimitiveArray`] of milliseconds since UNIX epoch stored as `i64`
+///
+/// See examples for [`TimestampSecondArray`]
+pub type TimestampMillisecondArray = PrimitiveArray<TimestampMillisecondType>;
+
+/// A [`PrimitiveArray`] of microseconds since UNIX epoch stored as `i64`
+///
+/// See examples for [`TimestampSecondArray`]
+pub type TimestampMicrosecondArray = PrimitiveArray<TimestampMicrosecondType>;
+
+/// A [`PrimitiveArray`] of nanoseconds since UNIX epoch stored as `i64`
+///
+/// See examples for [`TimestampSecondArray`]
+pub type TimestampNanosecondArray = PrimitiveArray<TimestampNanosecondType>;
+
+/// A [`PrimitiveArray`] of days since UNIX epoch stored as `i32`
+///
+/// This type is similar to the [`chrono::NaiveDate`] type and can hold
+/// values such as `2018-11-13`
+pub type Date32Array = PrimitiveArray<Date32Type>;
+
+/// A [`PrimitiveArray`] of milliseconds since UNIX epoch stored as `i64`
+///
+/// This type is similar to the [`chrono::NaiveDate`] type and can hold
+/// values such as `2018-11-13`
+pub type Date64Array = PrimitiveArray<Date64Type>;
+
+/// A [`PrimitiveArray`] of seconds since midnight stored as `i32`
+///
+/// This type is similar to the [`chrono::NaiveTime`] type and can
+/// hold values such as `00:02:00`
+pub type Time32SecondArray = PrimitiveArray<Time32SecondType>;
+
+/// A [`PrimitiveArray`] of milliseconds since midnight stored as `i32`
+///
+/// This type is similar to the [`chrono::NaiveTime`] type and can
+/// hold values such as `00:02:00.123`
+pub type Time32MillisecondArray = PrimitiveArray<Time32MillisecondType>;
+
+/// A [`PrimitiveArray`] of microseconds since midnight stored as `i64`
+///
+/// This type is similar to the [`chrono::NaiveTime`] type and can
+/// hold values such as `00:02:00.123456`
+pub type Time64MicrosecondArray = PrimitiveArray<Time64MicrosecondType>;
+
+/// A [`PrimitiveArray`] of nanoseconds since midnight stored as `i64`
+///
+/// This type is similar to the [`chrono::NaiveTime`] type and can
+/// hold values such as `00:02:00.123456789`
+pub type Time64NanosecondArray = PrimitiveArray<Time64NanosecondType>;
+
+/// A [`PrimitiveArray`] of “calendar” intervals in months
+///
+/// See [`IntervalYearMonthType`] for details on representation and caveats.
+pub type IntervalYearMonthArray = PrimitiveArray<IntervalYearMonthType>;
+
+/// A [`PrimitiveArray`] of “calendar” intervals in days and milliseconds
+///
+/// See [`IntervalDayTimeType`] for details on representation and caveats.
+pub type IntervalDayTimeArray = PrimitiveArray<IntervalDayTimeType>;
+
+/// A [`PrimitiveArray`] of “calendar” intervals in  months, days, and nanoseconds.
+///
+/// See [`IntervalMonthDayNanoType`] for details on representation and caveats.
+pub type IntervalMonthDayNanoArray = PrimitiveArray<IntervalMonthDayNanoType>;
+
+/// A [`PrimitiveArray`] of elapsed durations in seconds
+pub type DurationSecondArray = PrimitiveArray<DurationSecondType>;
+
+/// A [`PrimitiveArray`] of elapsed durations in milliseconds
+pub type DurationMillisecondArray = PrimitiveArray<DurationMillisecondType>;
+
+/// A [`PrimitiveArray`] of elapsed durations in microseconds
+pub type DurationMicrosecondArray = PrimitiveArray<DurationMicrosecondType>;
+
+/// A [`PrimitiveArray`] of elapsed durations in nanoseconds
+pub type DurationNanosecondArray = PrimitiveArray<DurationNanosecondType>;
+
+/// A [`PrimitiveArray`] of 128-bit fixed point decimals
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::Decimal128Array;
+/// // Create from Vec<Option<i18>>
+/// let arr = Decimal128Array::from(vec![Some(1), None, Some(2)]);
+/// // Create from Vec<i128>
+/// let arr = Decimal128Array::from(vec![1, 2, 3]);
+/// // Create iter/collect
+/// let arr: Decimal128Array = std::iter::repeat(42).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type Decimal128Array = PrimitiveArray<Decimal128Type>;
+
+/// A [`PrimitiveArray`] of 256-bit fixed point decimals
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::Decimal256Array;
+/// use arrow_buffer::i256;
+/// // Create from Vec<Option<i256>>
+/// let arr = Decimal256Array::from(vec![Some(i256::from(1)), None, Some(i256::from(2))]);
+/// // Create from Vec<i256>
+/// let arr = Decimal256Array::from(vec![i256::from(1), i256::from(2), i256::from(3)]);
+/// // Create iter/collect
+/// let arr: Decimal256Array = std::iter::repeat(i256::from(42)).take(10).collect();
+/// ```
+///
+/// See [`PrimitiveArray`] for more information and examples
+pub type Decimal256Array = PrimitiveArray<Decimal256Type>;
+
+pub use crate::types::ArrowPrimitiveType;
+
+/// An array of [primitive values](https://arrow.apache.org/docs/format/Columnar.html#fixed-size-primitive-layout)
+///
+/// # Example: From a Vec
+///
+/// ```
+/// # use arrow_array::{Array, PrimitiveArray, types::Int32Type};
+/// let arr: PrimitiveArray<Int32Type> = vec![1, 2, 3, 4].into();
+/// assert_eq!(4, arr.len());
+/// assert_eq!(0, arr.null_count());
+/// assert_eq!(arr.values(), &[1, 2, 3, 4])
+/// ```
+///
+/// # Example: From an optional Vec
+///
+/// ```
+/// # use arrow_array::{Array, PrimitiveArray, types::Int32Type};
+/// let arr: PrimitiveArray<Int32Type> = vec![Some(1), None, Some(3), None].into();
+/// assert_eq!(4, arr.len());
+/// assert_eq!(2, arr.null_count());
+/// // Note: values for null indexes are arbitrary
+/// assert_eq!(arr.values(), &[1, 0, 3, 0])
+/// ```
+///
+/// # Example: From an iterator of values
+///
+/// ```
+/// # use arrow_array::{Array, PrimitiveArray, types::Int32Type};
+/// let arr: PrimitiveArray<Int32Type> = (0..10).map(|x| x + 1).collect();
+/// assert_eq!(10, arr.len());
+/// assert_eq!(0, arr.null_count());
+/// for i in 0..10i32 {
+///     assert_eq!(i + 1, arr.value(i as usize));
+/// }
+/// ```
+///
+/// # Example: From an iterator of option
+///
+/// ```
+/// # use arrow_array::{Array, PrimitiveArray, types::Int32Type};
+/// let arr: PrimitiveArray<Int32Type> = (0..10).map(|x| (x % 2 == 0).then_some(x)).collect();
+/// assert_eq!(10, arr.len());
+/// assert_eq!(5, arr.null_count());
+/// // Note: values for null indexes are arbitrary
+/// assert_eq!(arr.values(), &[0, 0, 2, 0, 4, 0, 6, 0, 8, 0])
+/// ```
+///
+/// # Example: Using Builder
+///
+/// ```
+/// # use arrow_array::Array;
+/// # use arrow_array::builder::PrimitiveBuilder;
+/// # use arrow_array::types::Int32Type;
+/// let mut builder = PrimitiveBuilder::<Int32Type>::new();
+/// builder.append_value(1);
+/// builder.append_null();
+/// builder.append_value(2);
+/// let array = builder.finish();
+/// // Note: values for null indexes are arbitrary
+/// assert_eq!(array.values(), &[1, 0, 2]);
+/// assert!(array.is_null(1));
+/// ```
+pub struct PrimitiveArray<T: ArrowPrimitiveType> {
+    data_type: DataType,
+    /// Values data
+    values: ScalarBuffer<T::Native>,
+    nulls: Option<NullBuffer>,
+}
+
+impl<T: ArrowPrimitiveType> Clone for PrimitiveArray<T> {
+    fn clone(&self) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            values: self.values.clone(),
+            nulls: self.nulls.clone(),
+        }
+    }
+}
+
+impl<T: ArrowPrimitiveType> PrimitiveArray<T> {
+    /// Create a new [`PrimitiveArray`] from the provided values and nulls
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`Self::try_new`] returns an error
+    ///
+    /// # Example
+    ///
+    /// Creating a [`PrimitiveArray`] directly from a [`ScalarBuffer`] and [`NullBuffer`] using
+    /// this constructor is the most performant approach, avoiding any additional allocations
+    ///
+    /// ```
+    /// # use arrow_array::Int32Array;
+    /// # use arrow_array::types::Int32Type;
+    /// # use arrow_buffer::NullBuffer;
+    /// // [1, 2, 3, 4]
+    /// let array = Int32Array::new(vec![1, 2, 3, 4].into(), None);
+    /// // [1, null, 3, 4]
+    /// let nulls = NullBuffer::from(vec![true, false, true, true]);
+    /// let array = Int32Array::new(vec![1, 2, 3, 4].into(), Some(nulls));
+    /// ```
+    pub fn new(values: ScalarBuffer<T::Native>, nulls: Option<NullBuffer>) -> Self {
+        Self::try_new(values, nulls).unwrap()
+    }
+
+    /// Create a new [`PrimitiveArray`] of the given length where all values are null
+    pub fn new_null(length: usize) -> Self {
+        Self {
+            data_type: T::DATA_TYPE,
+            values: vec![T::Native::usize_as(0); length].into(),
+            nulls: Some(NullBuffer::new_null(length)),
+        }
+    }
+
+    /// Create a new [`PrimitiveArray`] from the provided values and nulls
+    ///
+    /// # Errors
+    ///
+    /// Errors if:
+    /// - `values.len() != nulls.len()`
+    pub fn try_new(
+        values: ScalarBuffer<T::Native>,
+        nulls: Option<NullBuffer>,
+    ) -> Result<Self, ArrowError> {
+        if let Some(n) = nulls.as_ref() {
+            if n.len() != values.len() {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Incorrect length of null buffer for PrimitiveArray, expected {} got {}",
+                    values.len(),
+                    n.len(),
+                )));
+            }
+        }
+
+        Ok(Self {
+            data_type: T::DATA_TYPE,
+            values,
+            nulls,
+        })
+    }
+
+    /// Create a new [`Scalar`] from `value`
+    pub fn new_scalar(value: T::Native) -> Scalar<Self> {
+        Scalar::new(Self {
+            data_type: T::DATA_TYPE,
+            values: vec![value].into(),
+            nulls: None,
+        })
+    }
+
+    /// Deconstruct this array into its constituent parts
+    pub fn into_parts(self) -> (DataType, ScalarBuffer<T::Native>, Option<NullBuffer>) {
+        (self.data_type, self.values, self.nulls)
+    }
+
+    /// Overrides the [`DataType`] of this [`PrimitiveArray`]
+    ///
+    /// Prefer using [`Self::with_timezone`] or [`Self::with_precision_and_scale`] where
+    /// the primitive type is suitably constrained, as these cannot panic
+    ///
+    /// # Panics
+    ///
+    /// Panics if ![Self::is_compatible]
+    pub fn with_data_type(self, data_type: DataType) -> Self {
+        Self::assert_compatible(&data_type);
+        Self { data_type, ..self }
+    }
+
+    /// Asserts that `data_type` is compatible with `Self`
+    fn assert_compatible(data_type: &DataType) {
+        assert!(
+            Self::is_compatible(data_type),
+            "PrimitiveArray expected data type {} got {}",
+            T::DATA_TYPE,
+            data_type
+        );
+    }
+
+    /// Returns the length of this array.
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    /// Returns whether this array is empty.
+    pub fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
+    /// Returns the values of this array
+    #[inline]
+    pub fn values(&self) -> &ScalarBuffer<T::Native> {
+        &self.values
+    }
+
+    /// Returns a new primitive array builder
+    pub fn builder(capacity: usize) -> PrimitiveBuilder<T> {
+        PrimitiveBuilder::<T>::with_capacity(capacity)
+    }
+
+    /// Returns if this [`PrimitiveArray`] is compatible with the provided [`DataType`]
+    ///
+    /// This is equivalent to `data_type == T::DATA_TYPE`, however ignores timestamp
+    /// timezones and decimal precision and scale
+    pub fn is_compatible(data_type: &DataType) -> bool {
+        match T::DATA_TYPE {
+            DataType::Timestamp(t1, _) => {
+                matches!(data_type, DataType::Timestamp(t2, _) if &t1 == t2)
+            }
+            DataType::Decimal128(_, _) => matches!(data_type, DataType::Decimal128(_, _)),
+            DataType::Decimal256(_, _) => matches!(data_type, DataType::Decimal256(_, _)),
+            _ => T::DATA_TYPE.eq(data_type),
+        }
+    }
+
+    /// Returns the primitive value at index `i`.
+    ///
+    /// # Safety
+    ///
+    /// caller must ensure that the passed in offset is less than the array len()
+    #[inline]
+    pub unsafe fn value_unchecked(&self, i: usize) -> T::Native {
+        *self.values.get_unchecked(i)
+    }
+
+    /// Returns the primitive value at index `i`.
+    /// # Panics
+    /// Panics if index `i` is out of bounds
+    #[inline]
+    pub fn value(&self, i: usize) -> T::Native {
+        assert!(
+            i < self.len(),
+            "Trying to access an element at index {} from a PrimitiveArray of length {}",
+            i,
+            self.len()
+        );
+        unsafe { self.value_unchecked(i) }
+    }
+
+    /// Creates a PrimitiveArray based on an iterator of values without nulls
+    pub fn from_iter_values<I: IntoIterator<Item = T::Native>>(iter: I) -> Self {
+        let val_buf: Buffer = iter.into_iter().collect();
+        let len = val_buf.len() / std::mem::size_of::<T::Native>();
+        Self {
+            data_type: T::DATA_TYPE,
+            values: ScalarBuffer::new(val_buf, 0, len),
+            nulls: None,
+        }
+    }
+
+    /// Creates a PrimitiveArray based on a constant value with `count` elements
+    pub fn from_value(value: T::Native, count: usize) -> Self {
+        unsafe {
+            let val_buf = Buffer::from_trusted_len_iter((0..count).map(|_| value));
+            Self::new(val_buf.into(), None)
+        }
+    }
+
+    /// Returns an iterator that returns the values of `array.value(i)` for an iterator with each element `i`
+    pub fn take_iter<'a>(
+        &'a self,
+        indexes: impl Iterator<Item = Option<usize>> + 'a,
+    ) -> impl Iterator<Item = Option<T::Native>> + 'a {
+        indexes.map(|opt_index| opt_index.map(|index| self.value(index)))
+    }
+
+    /// Returns an iterator that returns the values of `array.value(i)` for an iterator with each element `i`
+    /// # Safety
+    ///
+    /// caller must ensure that the offsets in the iterator are less than the array len()
+    pub unsafe fn take_iter_unchecked<'a>(
+        &'a self,
+        indexes: impl Iterator<Item = Option<usize>> + 'a,
+    ) -> impl Iterator<Item = Option<T::Native>> + 'a {
+        indexes.map(|opt_index| opt_index.map(|index| self.value_unchecked(index)))
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, length: usize) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            values: self.values.slice(offset, length),
+            nulls: self.nulls.as_ref().map(|n| n.slice(offset, length)),
+        }
+    }
+
+    /// Reinterprets this array's contents as a different data type without copying
+    ///
+    /// This can be used to efficiently convert between primitive arrays with the
+    /// same underlying representation
+    ///
+    /// Note: this will not modify the underlying values, and therefore may change
+    /// the semantic values of the array, e.g. 100 milliseconds in a [`TimestampNanosecondArray`]
+    /// will become 100 seconds in a [`TimestampSecondArray`].
+    ///
+    /// For casts that preserve the semantic value, check out the
+    /// [compute kernels](https://docs.rs/arrow/latest/arrow/compute/kernels/cast/index.html).
+    ///
+    /// ```
+    /// # use arrow_array::{Int64Array, TimestampNanosecondArray};
+    /// let a = Int64Array::from_iter_values([1, 2, 3, 4]);
+    /// let b: TimestampNanosecondArray = a.reinterpret_cast();
+    /// ```
+    pub fn reinterpret_cast<K>(&self) -> PrimitiveArray<K>
+    where
+        K: ArrowPrimitiveType<Native = T::Native>,
+    {
+        let d = self.to_data().into_builder().data_type(K::DATA_TYPE);
+
+        // SAFETY:
+        // Native type is the same
+        PrimitiveArray::from(unsafe { d.build_unchecked() })
+    }
+
+    /// Applies an unary and infallible function to a primitive array.
+    /// This is the fastest way to perform an operation on a primitive array when
+    /// the benefits of a vectorized operation outweigh the cost of branching nulls and non-nulls.
+    ///
+    /// # Implementation
+    ///
+    /// This will apply the function for all values, including those on null slots.
+    /// This implies that the operation must be infallible for any value of the corresponding type
+    /// or this function may panic.
+    /// # Example
+    /// ```rust
+    /// # use arrow_array::{Int32Array, types::Int32Type};
+    /// # fn main() {
+    /// let array = Int32Array::from(vec![Some(5), Some(7), None]);
+    /// let c = array.unary(|x| x * 2 + 1);
+    /// assert_eq!(c, Int32Array::from(vec![Some(11), Some(15), None]));
+    /// # }
+    /// ```
+    pub fn unary<F, O>(&self, op: F) -> PrimitiveArray<O>
+    where
+        O: ArrowPrimitiveType,
+        F: Fn(T::Native) -> O::Native,
+    {
+        let nulls = self.nulls().cloned();
+        let values = self.values().iter().map(|v| op(*v));
+        // JUSTIFICATION
+        //  Benefit
+        //      ~60% speedup
+        //  Soundness
+        //      `values` is an iterator with a known size because arrays are sized.
+        let buffer = unsafe { Buffer::from_trusted_len_iter(values) };
+        PrimitiveArray::new(buffer.into(), nulls)
+    }
+
+    /// Applies an unary and infallible function to a mutable primitive array.
+    /// Mutable primitive array means that the buffer is not shared with other arrays.
+    /// As a result, this mutates the buffer directly without allocating new buffer.
+    ///
+    /// # Implementation
+    ///
+    /// This will apply the function for all values, including those on null slots.
+    /// This implies that the operation must be infallible for any value of the corresponding type
+    /// or this function may panic.
+    /// # Example
+    /// ```rust
+    /// # use arrow_array::{Int32Array, types::Int32Type};
+    /// # fn main() {
+    /// let array = Int32Array::from(vec![Some(5), Some(7), None]);
+    /// let c = array.unary_mut(|x| x * 2 + 1).unwrap();
+    /// assert_eq!(c, Int32Array::from(vec![Some(11), Some(15), None]));
+    /// # }
+    /// ```
+    pub fn unary_mut<F>(self, op: F) -> Result<PrimitiveArray<T>, PrimitiveArray<T>>
+    where
+        F: Fn(T::Native) -> T::Native,
+    {
+        let mut builder = self.into_builder()?;
+        builder
+            .values_slice_mut()
+            .iter_mut()
+            .for_each(|v| *v = op(*v));
+        Ok(builder.finish())
+    }
+
+    /// Applies a unary and fallible function to all valid values in a primitive array
+    ///
+    /// This is unlike [`Self::unary`] which will apply an infallible function to all rows
+    /// regardless of validity, in many cases this will be significantly faster and should
+    /// be preferred if `op` is infallible.
+    ///
+    /// Note: LLVM is currently unable to effectively vectorize fallible operations
+    pub fn try_unary<F, O, E>(&self, op: F) -> Result<PrimitiveArray<O>, E>
+    where
+        O: ArrowPrimitiveType,
+        F: Fn(T::Native) -> Result<O::Native, E>,
+    {
+        let len = self.len();
+
+        let nulls = self.nulls().cloned();
+        let mut buffer = BufferBuilder::<O::Native>::new(len);
+        buffer.append_n_zeroed(len);
+        let slice = buffer.as_slice_mut();
+
+        let f = |idx| {
+            unsafe { *slice.get_unchecked_mut(idx) = op(self.value_unchecked(idx))? };
+            Ok::<_, E>(())
+        };
+
+        match &nulls {
+            Some(nulls) => nulls.try_for_each_valid_idx(f)?,
+            None => (0..len).try_for_each(f)?,
+        }
+
+        let values = buffer.finish().into();
+        Ok(PrimitiveArray::new(values, nulls))
+    }
+
+    /// Applies an unary and fallible function to all valid values in a mutable primitive array.
+    /// Mutable primitive array means that the buffer is not shared with other arrays.
+    /// As a result, this mutates the buffer directly without allocating new buffer.
+    ///
+    /// This is unlike [`Self::unary_mut`] which will apply an infallible function to all rows
+    /// regardless of validity, in many cases this will be significantly faster and should
+    /// be preferred if `op` is infallible.
+    ///
+    /// This returns an `Err` when the input array is shared buffer with other
+    /// array. In the case, returned `Err` wraps input array. If the function
+    /// encounters an error during applying on values. In the case, this returns an `Err` within
+    /// an `Ok` which wraps the actual error.
+    ///
+    /// Note: LLVM is currently unable to effectively vectorize fallible operations
+    pub fn try_unary_mut<F, E>(
+        self,
+        op: F,
+    ) -> Result<Result<PrimitiveArray<T>, E>, PrimitiveArray<T>>
+    where
+        F: Fn(T::Native) -> Result<T::Native, E>,
+    {
+        let len = self.len();
+        let null_count = self.null_count();
+        let mut builder = self.into_builder()?;
+
+        let (slice, null_buffer) = builder.slices_mut();
+
+        let r = try_for_each_valid_idx(len, 0, null_count, null_buffer.as_deref(), |idx| {
+            unsafe { *slice.get_unchecked_mut(idx) = op(*slice.get_unchecked(idx))? };
+            Ok::<_, E>(())
+        });
+
+        if let Err(err) = r {
+            return Ok(Err(err));
+        }
+
+        Ok(Ok(builder.finish()))
+    }
+
+    /// Applies a unary and nullable function to all valid values in a primitive array
+    ///
+    /// This is unlike [`Self::unary`] which will apply an infallible function to all rows
+    /// regardless of validity, in many cases this will be significantly faster and should
+    /// be preferred if `op` is infallible.
+    ///
+    /// Note: LLVM is currently unable to effectively vectorize fallible operations
+    pub fn unary_opt<F, O>(&self, op: F) -> PrimitiveArray<O>
+    where
+        O: ArrowPrimitiveType,
+        F: Fn(T::Native) -> Option<O::Native>,
+    {
+        let len = self.len();
+        let (nulls, null_count, offset) = match self.nulls() {
+            Some(n) => (Some(n.validity()), n.null_count(), n.offset()),
+            None => (None, 0, 0),
+        };
+
+        let mut null_builder = BooleanBufferBuilder::new(len);
+        match nulls {
+            Some(b) => null_builder.append_packed_range(offset..offset + len, b),
+            None => null_builder.append_n(len, true),
+        }
+
+        let mut buffer = BufferBuilder::<O::Native>::new(len);
+        buffer.append_n_zeroed(len);
+        let slice = buffer.as_slice_mut();
+
+        let mut out_null_count = null_count;
+
+        let _ = try_for_each_valid_idx(len, offset, null_count, nulls, |idx| {
+            match op(unsafe { self.value_unchecked(idx) }) {
+                Some(v) => unsafe { *slice.get_unchecked_mut(idx) = v },
+                None => {
+                    out_null_count += 1;
+                    null_builder.set_bit(idx, false);
+                }
+            }
+            Ok::<_, ()>(())
+        });
+
+        let nulls = null_builder.finish();
+        let values = buffer.finish().into();
+        let nulls = unsafe { NullBuffer::new_unchecked(nulls, out_null_count) };
+        PrimitiveArray::new(values, Some(nulls))
+    }
+
+    /// Returns `PrimitiveBuilder` of this primitive array for mutating its values if the underlying
+    /// data buffer is not shared by others.
+    pub fn into_builder(self) -> Result<PrimitiveBuilder<T>, Self> {
+        let len = self.len();
+        let data = self.into_data();
+        let null_bit_buffer = data.nulls().map(|b| b.inner().sliced());
+
+        let element_len = std::mem::size_of::<T::Native>();
+        let buffer =
+            data.buffers()[0].slice_with_length(data.offset() * element_len, len * element_len);
+
+        drop(data);
+
+        let try_mutable_null_buffer = match null_bit_buffer {
+            None => Ok(None),
+            Some(null_buffer) => {
+                // Null buffer exists, tries to make it mutable
+                null_buffer.into_mutable().map(Some)
+            }
+        };
+
+        let try_mutable_buffers = match try_mutable_null_buffer {
+            Ok(mutable_null_buffer) => {
+                // Got mutable null buffer, tries to get mutable value buffer
+                let try_mutable_buffer = buffer.into_mutable();
+
+                // try_mutable_buffer.map(...).map_err(...) doesn't work as the compiler complains
+                // mutable_null_buffer is moved into map closure.
+                match try_mutable_buffer {
+                    Ok(mutable_buffer) => Ok(PrimitiveBuilder::<T>::new_from_buffer(
+                        mutable_buffer,
+                        mutable_null_buffer,
+                    )),
+                    Err(buffer) => Err((buffer, mutable_null_buffer.map(|b| b.into()))),
+                }
+            }
+            Err(mutable_null_buffer) => {
+                // Unable to get mutable null buffer
+                Err((buffer, Some(mutable_null_buffer)))
+            }
+        };
+
+        match try_mutable_buffers {
+            Ok(builder) => Ok(builder),
+            Err((buffer, null_bit_buffer)) => {
+                let builder = ArrayData::builder(T::DATA_TYPE)
+                    .len(len)
+                    .add_buffer(buffer)
+                    .null_bit_buffer(null_bit_buffer);
+
+                let array_data = unsafe { builder.build_unchecked() };
+                let array = PrimitiveArray::<T>::from(array_data);
+
+                Err(array)
+            }
+        }
+    }
+}
+
+impl<T: ArrowPrimitiveType> From<PrimitiveArray<T>> for ArrayData {
+    fn from(array: PrimitiveArray<T>) -> Self {
+        let builder = ArrayDataBuilder::new(array.data_type)
+            .len(array.values.len())
+            .nulls(array.nulls)
+            .buffers(vec![array.values.into_inner()]);
+
+        unsafe { builder.build_unchecked() }
+    }
+}
+
+impl<T: ArrowPrimitiveType> Array for PrimitiveArray<T> {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.into()
+    }
+
+    fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.values.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.values.is_empty()
+    }
+
+    fn offset(&self) -> usize {
+        0
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.nulls.as_ref()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        let mut size = self.values.inner().capacity();
+        if let Some(n) = self.nulls.as_ref() {
+            size += n.buffer().capacity();
+        }
+        size
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        std::mem::size_of::<Self>() + self.get_buffer_memory_size()
+    }
+}
+
+impl<'a, T: ArrowPrimitiveType> ArrayAccessor for &'a PrimitiveArray<T> {
+    type Item = T::Native;
+
+    fn value(&self, index: usize) -> Self::Item {
+        PrimitiveArray::value(self, index)
+    }
+
+    #[inline]
+    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
+        PrimitiveArray::value_unchecked(self, index)
+    }
+}
+
+impl<T: ArrowTemporalType> PrimitiveArray<T>
+where
+    i64: From<T::Native>,
+{
+    /// Returns value as a chrono `NaiveDateTime`, handling time resolution
+    ///
+    /// If a data type cannot be converted to `NaiveDateTime`, a `None` is returned.
+    /// A valid value is expected, thus the user should first check for validity.
+    pub fn value_as_datetime(&self, i: usize) -> Option<NaiveDateTime> {
+        as_datetime::<T>(i64::from(self.value(i)))
+    }
+
+    /// Returns value as a chrono `NaiveDateTime`, handling time resolution with the provided tz
+    ///
+    /// functionally it is same as `value_as_datetime`, however it adds
+    /// the passed tz to the to-be-returned NaiveDateTime
+    pub fn value_as_datetime_with_tz(&self, i: usize, tz: Tz) -> Option<DateTime<Tz>> {
+        as_datetime_with_timezone::<T>(i64::from(self.value(i)), tz)
+    }
+
+    /// Returns value as a chrono `NaiveDate` by using `Self::datetime()`
+    ///
+    /// If a data type cannot be converted to `NaiveDate`, a `None` is returned
+    pub fn value_as_date(&self, i: usize) -> Option<NaiveDate> {
+        self.value_as_datetime(i).map(|datetime| datetime.date())
+    }
+
+    /// Returns a value as a chrono `NaiveTime`
+    ///
+    /// `Date32` and `Date64` return UTC midnight as they do not have time resolution
+    pub fn value_as_time(&self, i: usize) -> Option<NaiveTime> {
+        as_time::<T>(i64::from(self.value(i)))
+    }
+
+    /// Returns a value as a chrono `Duration`
+    ///
+    /// If a data type cannot be converted to `Duration`, a `None` is returned
+    pub fn value_as_duration(&self, i: usize) -> Option<Duration> {
+        as_duration::<T>(i64::from(self.value(i)))
+    }
+}
+
+impl<T: ArrowPrimitiveType> std::fmt::Debug for PrimitiveArray<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        let data_type = self.data_type();
+
+        write!(f, "PrimitiveArray<{data_type:?}>\n[\n")?;
+        print_long_array(self, f, |array, index, f| match data_type {
+            DataType::Date32 | DataType::Date64 => {
+                let v = self.value(index).to_isize().unwrap() as i64;
+                match as_date::<T>(v) {
+                    Some(date) => write!(f, "{date:?}"),
+                    None => {
+                        write!(
+                            f,
+                            "Cast error: Failed to convert {v} to temporal for {data_type:?}"
+                        )
+                    }
+                }
+            }
+            DataType::Time32(_) | DataType::Time64(_) => {
+                let v = self.value(index).to_isize().unwrap() as i64;
+                match as_time::<T>(v) {
+                    Some(time) => write!(f, "{time:?}"),
+                    None => {
+                        write!(
+                            f,
+                            "Cast error: Failed to convert {v} to temporal for {data_type:?}"
+                        )
+                    }
+                }
+            }
+            DataType::Timestamp(_, tz_string_opt) => {
+                let v = self.value(index).to_isize().unwrap() as i64;
+                match tz_string_opt {
+                    // for Timestamp with TimeZone
+                    Some(tz_string) => {
+                        match tz_string.parse::<Tz>() {
+                            // if the time zone is valid, construct a DateTime<Tz> and format it as rfc3339
+                            Ok(tz) => match as_datetime_with_timezone::<T>(v, tz) {
+                                Some(datetime) => write!(f, "{}", datetime.to_rfc3339()),
+                                None => write!(f, "null"),
+                            },
+                            // if the time zone is invalid, shows NaiveDateTime with an error message
+                            Err(_) => match as_datetime::<T>(v) {
+                                Some(datetime) => {
+                                    write!(f, "{datetime:?} (Unknown Time Zone '{tz_string}')")
+                                }
+                                None => write!(f, "null"),
+                            },
+                        }
+                    }
+                    // for Timestamp without TimeZone
+                    None => match as_datetime::<T>(v) {
+                        Some(datetime) => write!(f, "{datetime:?}"),
+                        None => write!(f, "null"),
+                    },
+                }
+            }
+            _ => std::fmt::Debug::fmt(&array.value(index), f),
+        })?;
+        write!(f, "]")
+    }
+}
+
+impl<'a, T: ArrowPrimitiveType> IntoIterator for &'a PrimitiveArray<T> {
+    type Item = Option<<T as ArrowPrimitiveType>::Native>;
+    type IntoIter = PrimitiveIter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        PrimitiveIter::<'a, T>::new(self)
+    }
+}
+
+impl<'a, T: ArrowPrimitiveType> PrimitiveArray<T> {
+    /// constructs a new iterator
+    pub fn iter(&'a self) -> PrimitiveIter<'a, T> {
+        PrimitiveIter::<'a, T>::new(self)
+    }
+}
+
+/// An optional primitive value
+///
+/// This struct is used as an adapter when creating `PrimitiveArray` from an iterator.
+/// `FromIterator` for `PrimitiveArray` takes an iterator where the elements can be `into`
+/// this struct. So once implementing `From` or `Into` trait for a type, an iterator of
+/// the type can be collected to `PrimitiveArray`.
+#[derive(Debug)]
+pub struct NativeAdapter<T: ArrowPrimitiveType> {
+    /// Corresponding Rust native type if available
+    pub native: Option<T::Native>,
+}
+
+macro_rules! def_from_for_primitive {
+    ( $ty:ident, $tt:tt) => {
+        impl From<$tt> for NativeAdapter<$ty> {
+            fn from(value: $tt) -> Self {
+                NativeAdapter {
+                    native: Some(value),
+                }
+            }
+        }
+    };
+}
+
+def_from_for_primitive!(Int8Type, i8);
+def_from_for_primitive!(Int16Type, i16);
+def_from_for_primitive!(Int32Type, i32);
+def_from_for_primitive!(Int64Type, i64);
+def_from_for_primitive!(UInt8Type, u8);
+def_from_for_primitive!(UInt16Type, u16);
+def_from_for_primitive!(UInt32Type, u32);
+def_from_for_primitive!(UInt64Type, u64);
+def_from_for_primitive!(Float16Type, f16);
+def_from_for_primitive!(Float32Type, f32);
+def_from_for_primitive!(Float64Type, f64);
+def_from_for_primitive!(Decimal128Type, i128);
+def_from_for_primitive!(Decimal256Type, i256);
+
+impl<T: ArrowPrimitiveType> From<Option<<T as ArrowPrimitiveType>::Native>> for NativeAdapter<T> {
+    fn from(value: Option<<T as ArrowPrimitiveType>::Native>) -> Self {
+        NativeAdapter { native: value }
+    }
+}
+
+impl<T: ArrowPrimitiveType> From<&Option<<T as ArrowPrimitiveType>::Native>> for NativeAdapter<T> {
+    fn from(value: &Option<<T as ArrowPrimitiveType>::Native>) -> Self {
+        NativeAdapter { native: *value }
+    }
+}
+
+impl<T: ArrowPrimitiveType, Ptr: Into<NativeAdapter<T>>> FromIterator<Ptr> for PrimitiveArray<T> {
+    fn from_iter<I: IntoIterator<Item = Ptr>>(iter: I) -> Self {
+        let iter = iter.into_iter();
+        let (lower, _) = iter.size_hint();
+
+        let mut null_builder = BooleanBufferBuilder::new(lower);
+
+        let buffer: Buffer = iter
+            .map(|item| {
+                if let Some(a) = item.into().native {
+                    null_builder.append(true);
+                    a
+                } else {
+                    null_builder.append(false);
+                    // this ensures that null items on the buffer are not arbitrary.
+                    // This is important because fallible operations can use null values (e.g. a vectorized "add")
+                    // which may panic (e.g. overflow if the number on the slots happen to be very large).
+                    T::Native::default()
+                }
+            })
+            .collect();
+
+        let len = null_builder.len();
+
+        let data = unsafe {
+            ArrayData::new_unchecked(
+                T::DATA_TYPE,
+                len,
+                None,
+                Some(null_builder.into()),
+                0,
+                vec![buffer],
+                vec![],
+            )
+        };
+        PrimitiveArray::from(data)
+    }
+}
+
+impl<T: ArrowPrimitiveType> PrimitiveArray<T> {
+    /// Creates a [`PrimitiveArray`] from an iterator of trusted length.
+    /// # Safety
+    /// The iterator must be [`TrustedLen`](https://doc.rust-lang.org/std/iter/trait.TrustedLen.html).
+    /// I.e. that `size_hint().1` correctly reports its length.
+    #[inline]
+    pub unsafe fn from_trusted_len_iter<I, P>(iter: I) -> Self
+    where
+        P: std::borrow::Borrow<Option<<T as ArrowPrimitiveType>::Native>>,
+        I: IntoIterator<Item = P>,
+    {
+        let iterator = iter.into_iter();
+        let (_, upper) = iterator.size_hint();
+        let len = upper.expect("trusted_len_unzip requires an upper limit");
+
+        let (null, buffer) = trusted_len_unzip(iterator);
+
+        let data =
+            ArrayData::new_unchecked(T::DATA_TYPE, len, None, Some(null), 0, vec![buffer], vec![]);
+        PrimitiveArray::from(data)
+    }
+}
+
+// TODO: the macro is needed here because we'd get "conflicting implementations" error
+// otherwise with both `From<Vec<T::Native>>` and `From<Vec<Option<T::Native>>>`.
+// We should revisit this in future.
+macro_rules! def_numeric_from_vec {
+    ( $ty:ident ) => {
+        impl From<Vec<<$ty as ArrowPrimitiveType>::Native>> for PrimitiveArray<$ty> {
+            fn from(data: Vec<<$ty as ArrowPrimitiveType>::Native>) -> Self {
+                let array_data = ArrayData::builder($ty::DATA_TYPE)
+                    .len(data.len())
+                    .add_buffer(Buffer::from_vec(data));
+                let array_data = unsafe { array_data.build_unchecked() };
+                PrimitiveArray::from(array_data)
+            }
+        }
+
+        // Constructs a primitive array from a vector. Should only be used for testing.
+        impl From<Vec<Option<<$ty as ArrowPrimitiveType>::Native>>> for PrimitiveArray<$ty> {
+            fn from(data: Vec<Option<<$ty as ArrowPrimitiveType>::Native>>) -> Self {
+                PrimitiveArray::from_iter(data.iter())
+            }
+        }
+    };
+}
+
+def_numeric_from_vec!(Int8Type);
+def_numeric_from_vec!(Int16Type);
+def_numeric_from_vec!(Int32Type);
+def_numeric_from_vec!(Int64Type);
+def_numeric_from_vec!(UInt8Type);
+def_numeric_from_vec!(UInt16Type);
+def_numeric_from_vec!(UInt32Type);
+def_numeric_from_vec!(UInt64Type);
+def_numeric_from_vec!(Float16Type);
+def_numeric_from_vec!(Float32Type);
+def_numeric_from_vec!(Float64Type);
+def_numeric_from_vec!(Decimal128Type);
+def_numeric_from_vec!(Decimal256Type);
+
+def_numeric_from_vec!(Date32Type);
+def_numeric_from_vec!(Date64Type);
+def_numeric_from_vec!(Time32SecondType);
+def_numeric_from_vec!(Time32MillisecondType);
+def_numeric_from_vec!(Time64MicrosecondType);
+def_numeric_from_vec!(Time64NanosecondType);
+def_numeric_from_vec!(IntervalYearMonthType);
+def_numeric_from_vec!(IntervalDayTimeType);
+def_numeric_from_vec!(IntervalMonthDayNanoType);
+def_numeric_from_vec!(DurationSecondType);
+def_numeric_from_vec!(DurationMillisecondType);
+def_numeric_from_vec!(DurationMicrosecondType);
+def_numeric_from_vec!(DurationNanosecondType);
+def_numeric_from_vec!(TimestampSecondType);
+def_numeric_from_vec!(TimestampMillisecondType);
+def_numeric_from_vec!(TimestampMicrosecondType);
+def_numeric_from_vec!(TimestampNanosecondType);
+
+impl<T: ArrowTimestampType> PrimitiveArray<T> {
+    /// Construct a timestamp array from a vec of i64 values and an optional timezone
+    #[deprecated(note = "Use with_timezone_opt instead")]
+    pub fn from_vec(data: Vec<i64>, timezone: Option<String>) -> Self
+    where
+        Self: From<Vec<i64>>,
+    {
+        Self::from(data).with_timezone_opt(timezone)
+    }
+
+    /// Construct a timestamp array from a vec of `Option<i64>` values and an optional timezone
+    #[deprecated(note = "Use with_timezone_opt instead")]
+    pub fn from_opt_vec(data: Vec<Option<i64>>, timezone: Option<String>) -> Self
+    where
+        Self: From<Vec<Option<i64>>>,
+    {
+        Self::from(data).with_timezone_opt(timezone)
+    }
+
+    /// Returns the timezone of this array if any
+    pub fn timezone(&self) -> Option<&str> {
+        match self.data_type() {
+            DataType::Timestamp(_, tz) => tz.as_deref(),
+            _ => unreachable!(),
+        }
+    }
+
+    /// Construct a timestamp array with new timezone
+    pub fn with_timezone(self, timezone: impl Into<Arc<str>>) -> Self {
+        self.with_timezone_opt(Some(timezone.into()))
+    }
+
+    /// Construct a timestamp array with UTC
+    pub fn with_timezone_utc(self) -> Self {
+        self.with_timezone("+00:00")
+    }
+
+    /// Construct a timestamp array with an optional timezone
+    pub fn with_timezone_opt<S: Into<Arc<str>>>(self, timezone: Option<S>) -> Self {
+        Self {
+            data_type: DataType::Timestamp(T::UNIT, timezone.map(Into::into)),
+            ..self
+        }
+    }
+}
+
+/// Constructs a `PrimitiveArray` from an array data reference.
+impl<T: ArrowPrimitiveType> From<ArrayData> for PrimitiveArray<T> {
+    fn from(data: ArrayData) -> Self {
+        Self::assert_compatible(data.data_type());
+        assert_eq!(
+            data.buffers().len(),
+            1,
+            "PrimitiveArray data should contain a single buffer only (values buffer)"
+        );
+
+        let values = ScalarBuffer::new(data.buffers()[0].clone(), data.offset(), data.len());
+        Self {
+            data_type: data.data_type().clone(),
+            values,
+            nulls: data.nulls().cloned(),
+        }
+    }
+}
+
+impl<T: DecimalType + ArrowPrimitiveType> PrimitiveArray<T> {
+    /// Returns a Decimal array with the same data as self, with the
+    /// specified precision and scale.
+    ///
+    /// See [`validate_decimal_precision_and_scale`]
+    pub fn with_precision_and_scale(self, precision: u8, scale: i8) -> Result<Self, ArrowError> {
+        validate_decimal_precision_and_scale::<T>(precision, scale)?;
+        Ok(Self {
+            data_type: T::TYPE_CONSTRUCTOR(precision, scale),
+            ..self
+        })
+    }
+
+    /// Validates values in this array can be properly interpreted
+    /// with the specified precision.
+    pub fn validate_decimal_precision(&self, precision: u8) -> Result<(), ArrowError> {
+        (0..self.len()).try_for_each(|idx| {
+            if self.is_valid(idx) {
+                let decimal = unsafe { self.value_unchecked(idx) };
+                T::validate_decimal_precision(decimal, precision)
+            } else {
+                Ok(())
+            }
+        })
+    }
+
+    /// Validates the Decimal Array, if the value of slot is overflow for the specified precision, and
+    /// will be casted to Null
+    pub fn null_if_overflow_precision(&self, precision: u8) -> Self {
+        self.unary_opt::<_, T>(|v| {
+            (T::validate_decimal_precision(v, precision).is_ok()).then_some(v)
+        })
+    }
+
+    /// Returns [`Self::value`] formatted as a string
+    pub fn value_as_string(&self, row: usize) -> String {
+        T::format_decimal(self.value(row), self.precision(), self.scale())
+    }
+
+    /// Returns the decimal precision of this array
+    pub fn precision(&self) -> u8 {
+        match T::BYTE_LENGTH {
+            16 => {
+                if let DataType::Decimal128(p, _) = self.data_type() {
+                    *p
+                } else {
+                    unreachable!(
+                        "Decimal128Array datatype is not DataType::Decimal128 but {}",
+                        self.data_type()
+                    )
+                }
+            }
+            32 => {
+                if let DataType::Decimal256(p, _) = self.data_type() {
+                    *p
+                } else {
+                    unreachable!(
+                        "Decimal256Array datatype is not DataType::Decimal256 but {}",
+                        self.data_type()
+                    )
+                }
+            }
+            other => unreachable!("Unsupported byte length for decimal array {}", other),
+        }
+    }
+
+    /// Returns the decimal scale of this array
+    pub fn scale(&self) -> i8 {
+        match T::BYTE_LENGTH {
+            16 => {
+                if let DataType::Decimal128(_, s) = self.data_type() {
+                    *s
+                } else {
+                    unreachable!(
+                        "Decimal128Array datatype is not DataType::Decimal128 but {}",
+                        self.data_type()
+                    )
+                }
+            }
+            32 => {
+                if let DataType::Decimal256(_, s) = self.data_type() {
+                    *s
+                } else {
+                    unreachable!(
+                        "Decimal256Array datatype is not DataType::Decimal256 but {}",
+                        self.data_type()
+                    )
+                }
+            }
+            other => unreachable!("Unsupported byte length for decimal array {}", other),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::builder::{Decimal128Builder, Decimal256Builder};
+    use crate::cast::downcast_array;
+    use crate::{ArrayRef, BooleanArray};
+    use arrow_schema::TimeUnit;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_primitive_array_from_vec() {
+        let buf = Buffer::from_slice_ref([0, 1, 2, 3, 4]);
+        let arr = Int32Array::from(vec![0, 1, 2, 3, 4]);
+        assert_eq!(&buf, arr.values.inner());
+        assert_eq!(5, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(0, arr.null_count());
+        for i in 0..5 {
+            assert!(!arr.is_null(i));
+            assert!(arr.is_valid(i));
+            assert_eq!(i as i32, arr.value(i));
+        }
+    }
+
+    #[test]
+    fn test_primitive_array_from_vec_option() {
+        // Test building a primitive array with null values
+        let arr = Int32Array::from(vec![Some(0), None, Some(2), None, Some(4)]);
+        assert_eq!(5, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(2, arr.null_count());
+        for i in 0..5 {
+            if i % 2 == 0 {
+                assert!(!arr.is_null(i));
+                assert!(arr.is_valid(i));
+                assert_eq!(i as i32, arr.value(i));
+            } else {
+                assert!(arr.is_null(i));
+                assert!(!arr.is_valid(i));
+            }
+        }
+    }
+
+    #[test]
+    fn test_date64_array_from_vec_option() {
+        // Test building a primitive array with null values
+        // we use Int32 and Int64 as a backing array, so all Int32 and Int64 conventions
+        // work
+        let arr: PrimitiveArray<Date64Type> =
+            vec![Some(1550902545147), None, Some(1550902545147)].into();
+        assert_eq!(3, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(1, arr.null_count());
+        for i in 0..3 {
+            if i % 2 == 0 {
+                assert!(!arr.is_null(i));
+                assert!(arr.is_valid(i));
+                assert_eq!(1550902545147, arr.value(i));
+                // roundtrip to and from datetime
+                assert_eq!(
+                    1550902545147,
+                    arr.value_as_datetime(i).unwrap().timestamp_millis()
+                );
+            } else {
+                assert!(arr.is_null(i));
+                assert!(!arr.is_valid(i));
+            }
+        }
+    }
+
+    #[test]
+    fn test_time32_millisecond_array_from_vec() {
+        // 1:        00:00:00.001
+        // 37800005: 10:30:00.005
+        // 86399210: 23:59:59.210
+        let arr: PrimitiveArray<Time32MillisecondType> = vec![1, 37_800_005, 86_399_210].into();
+        assert_eq!(3, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(0, arr.null_count());
+        let formatted = ["00:00:00.001", "10:30:00.005", "23:59:59.210"];
+        for (i, formatted) in formatted.iter().enumerate().take(3) {
+            // check that we can't create dates or datetimes from time instances
+            assert_eq!(None, arr.value_as_datetime(i));
+            assert_eq!(None, arr.value_as_date(i));
+            let time = arr.value_as_time(i).unwrap();
+            assert_eq!(*formatted, time.format("%H:%M:%S%.3f").to_string());
+        }
+    }
+
+    #[test]
+    fn test_time64_nanosecond_array_from_vec() {
+        // Test building a primitive array with null values
+        // we use Int32 and Int64 as a backing array, so all Int32 and Int64 conventions
+        // work
+
+        // 1e6:        00:00:00.001
+        // 37800005e6: 10:30:00.005
+        // 86399210e6: 23:59:59.210
+        let arr: PrimitiveArray<Time64NanosecondType> =
+            vec![1_000_000, 37_800_005_000_000, 86_399_210_000_000].into();
+        assert_eq!(3, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(0, arr.null_count());
+        let formatted = ["00:00:00.001", "10:30:00.005", "23:59:59.210"];
+        for (i, item) in formatted.iter().enumerate().take(3) {
+            // check that we can't create dates or datetimes from time instances
+            assert_eq!(None, arr.value_as_datetime(i));
+            assert_eq!(None, arr.value_as_date(i));
+            let time = arr.value_as_time(i).unwrap();
+            assert_eq!(*item, time.format("%H:%M:%S%.3f").to_string());
+        }
+    }
+
+    #[test]
+    fn test_interval_array_from_vec() {
+        // intervals are currently not treated specially, but are Int32 and Int64 arrays
+        let arr = IntervalYearMonthArray::from(vec![Some(1), None, Some(-5)]);
+        assert_eq!(3, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(1, arr.null_count());
+        assert_eq!(1, arr.value(0));
+        assert_eq!(1, arr.values()[0]);
+        assert!(arr.is_null(1));
+        assert_eq!(-5, arr.value(2));
+        assert_eq!(-5, arr.values()[2]);
+
+        // a day_time interval contains days and milliseconds, but we do not yet have accessors for the values
+        let arr = IntervalDayTimeArray::from(vec![Some(1), None, Some(-5)]);
+        assert_eq!(3, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(1, arr.null_count());
+        assert_eq!(1, arr.value(0));
+        assert_eq!(1, arr.values()[0]);
+        assert!(arr.is_null(1));
+        assert_eq!(-5, arr.value(2));
+        assert_eq!(-5, arr.values()[2]);
+
+        // a month_day_nano interval contains months, days and nanoseconds,
+        // but we do not yet have accessors for the values.
+        // TODO: implement month, day, and nanos access method for month_day_nano.
+        let arr = IntervalMonthDayNanoArray::from(vec![
+            Some(100000000000000000000),
+            None,
+            Some(-500000000000000000000),
+        ]);
+        assert_eq!(3, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(1, arr.null_count());
+        assert_eq!(100000000000000000000, arr.value(0));
+        assert_eq!(100000000000000000000, arr.values()[0]);
+        assert!(arr.is_null(1));
+        assert_eq!(-500000000000000000000, arr.value(2));
+        assert_eq!(-500000000000000000000, arr.values()[2]);
+    }
+
+    #[test]
+    fn test_duration_array_from_vec() {
+        let arr = DurationSecondArray::from(vec![Some(1), None, Some(-5)]);
+        assert_eq!(3, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(1, arr.null_count());
+        assert_eq!(1, arr.value(0));
+        assert_eq!(1, arr.values()[0]);
+        assert!(arr.is_null(1));
+        assert_eq!(-5, arr.value(2));
+        assert_eq!(-5, arr.values()[2]);
+
+        let arr = DurationMillisecondArray::from(vec![Some(1), None, Some(-5)]);
+        assert_eq!(3, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(1, arr.null_count());
+        assert_eq!(1, arr.value(0));
+        assert_eq!(1, arr.values()[0]);
+        assert!(arr.is_null(1));
+        assert_eq!(-5, arr.value(2));
+        assert_eq!(-5, arr.values()[2]);
+
+        let arr = DurationMicrosecondArray::from(vec![Some(1), None, Some(-5)]);
+        assert_eq!(3, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(1, arr.null_count());
+        assert_eq!(1, arr.value(0));
+        assert_eq!(1, arr.values()[0]);
+        assert!(arr.is_null(1));
+        assert_eq!(-5, arr.value(2));
+        assert_eq!(-5, arr.values()[2]);
+
+        let arr = DurationNanosecondArray::from(vec![Some(1), None, Some(-5)]);
+        assert_eq!(3, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(1, arr.null_count());
+        assert_eq!(1, arr.value(0));
+        assert_eq!(1, arr.values()[0]);
+        assert!(arr.is_null(1));
+        assert_eq!(-5, arr.value(2));
+        assert_eq!(-5, arr.values()[2]);
+    }
+
+    #[test]
+    fn test_timestamp_array_from_vec() {
+        let arr = TimestampSecondArray::from(vec![1, -5]);
+        assert_eq!(2, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(0, arr.null_count());
+        assert_eq!(1, arr.value(0));
+        assert_eq!(-5, arr.value(1));
+        assert_eq!(&[1, -5], arr.values());
+
+        let arr = TimestampMillisecondArray::from(vec![1, -5]);
+        assert_eq!(2, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(0, arr.null_count());
+        assert_eq!(1, arr.value(0));
+        assert_eq!(-5, arr.value(1));
+        assert_eq!(&[1, -5], arr.values());
+
+        let arr = TimestampMicrosecondArray::from(vec![1, -5]);
+        assert_eq!(2, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(0, arr.null_count());
+        assert_eq!(1, arr.value(0));
+        assert_eq!(-5, arr.value(1));
+        assert_eq!(&[1, -5], arr.values());
+
+        let arr = TimestampNanosecondArray::from(vec![1, -5]);
+        assert_eq!(2, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(0, arr.null_count());
+        assert_eq!(1, arr.value(0));
+        assert_eq!(-5, arr.value(1));
+        assert_eq!(&[1, -5], arr.values());
+    }
+
+    #[test]
+    fn test_primitive_array_slice() {
+        let arr = Int32Array::from(vec![
+            Some(0),
+            None,
+            Some(2),
+            None,
+            Some(4),
+            Some(5),
+            Some(6),
+            None,
+            None,
+        ]);
+        assert_eq!(9, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(4, arr.null_count());
+
+        let arr2 = arr.slice(2, 5);
+        assert_eq!(5, arr2.len());
+        assert_eq!(1, arr2.null_count());
+
+        for i in 0..arr2.len() {
+            assert_eq!(i == 1, arr2.is_null(i));
+            assert_eq!(i != 1, arr2.is_valid(i));
+        }
+        let int_arr2 = arr2.as_any().downcast_ref::<Int32Array>().unwrap();
+        assert_eq!(2, int_arr2.values()[0]);
+        assert_eq!(&[4, 5, 6], &int_arr2.values()[2..5]);
+
+        let arr3 = arr2.slice(2, 3);
+        assert_eq!(3, arr3.len());
+        assert_eq!(0, arr3.null_count());
+
+        let int_arr3 = arr3.as_any().downcast_ref::<Int32Array>().unwrap();
+        assert_eq!(&[4, 5, 6], int_arr3.values());
+        assert_eq!(4, int_arr3.value(0));
+        assert_eq!(5, int_arr3.value(1));
+        assert_eq!(6, int_arr3.value(2));
+    }
+
+    #[test]
+    fn test_boolean_array_slice() {
+        let arr = BooleanArray::from(vec![
+            Some(true),
+            None,
+            Some(false),
+            None,
+            Some(true),
+            Some(false),
+            Some(true),
+            Some(false),
+            None,
+            Some(true),
+        ]);
+
+        assert_eq!(10, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(3, arr.null_count());
+
+        let arr2 = arr.slice(3, 5);
+        assert_eq!(5, arr2.len());
+        assert_eq!(3, arr2.offset());
+        assert_eq!(1, arr2.null_count());
+
+        let bool_arr = arr2.as_any().downcast_ref::<BooleanArray>().unwrap();
+
+        assert!(!bool_arr.is_valid(0));
+
+        assert!(bool_arr.is_valid(1));
+        assert!(bool_arr.value(1));
+
+        assert!(bool_arr.is_valid(2));
+        assert!(!bool_arr.value(2));
+
+        assert!(bool_arr.is_valid(3));
+        assert!(bool_arr.value(3));
+
+        assert!(bool_arr.is_valid(4));
+        assert!(!bool_arr.value(4));
+    }
+
+    #[test]
+    fn test_int32_fmt_debug() {
+        let arr = Int32Array::from(vec![0, 1, 2, 3, 4]);
+        assert_eq!(
+            "PrimitiveArray<Int32>\n[\n  0,\n  1,\n  2,\n  3,\n  4,\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    fn test_fmt_debug_up_to_20_elements() {
+        (1..=20).for_each(|i| {
+            let values = (0..i).collect::<Vec<i16>>();
+            let array_expected = format!(
+                "PrimitiveArray<Int16>\n[\n{}\n]",
+                values
+                    .iter()
+                    .map(|v| { format!("  {v},") })
+                    .collect::<Vec<String>>()
+                    .join("\n")
+            );
+            let array = Int16Array::from(values);
+
+            assert_eq!(array_expected, format!("{array:?}"));
+        })
+    }
+
+    #[test]
+    fn test_int32_with_null_fmt_debug() {
+        let mut builder = Int32Array::builder(3);
+        builder.append_slice(&[0, 1]);
+        builder.append_null();
+        builder.append_slice(&[3, 4]);
+        let arr = builder.finish();
+        assert_eq!(
+            "PrimitiveArray<Int32>\n[\n  0,\n  1,\n  null,\n  3,\n  4,\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    fn test_timestamp_fmt_debug() {
+        let arr: PrimitiveArray<TimestampMillisecondType> =
+            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000]);
+        assert_eq!(
+            "PrimitiveArray<Timestamp(Millisecond, None)>\n[\n  2018-12-31T00:00:00,\n  2018-12-31T00:00:00,\n  1921-01-02T00:00:00,\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    fn test_timestamp_utc_fmt_debug() {
+        let arr: PrimitiveArray<TimestampMillisecondType> =
+            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000])
+                .with_timezone_utc();
+        assert_eq!(
+            "PrimitiveArray<Timestamp(Millisecond, Some(\"+00:00\"))>\n[\n  2018-12-31T00:00:00+00:00,\n  2018-12-31T00:00:00+00:00,\n  1921-01-02T00:00:00+00:00,\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "chrono-tz")]
+    fn test_timestamp_with_named_tz_fmt_debug() {
+        let arr: PrimitiveArray<TimestampMillisecondType> =
+            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000])
+                .with_timezone("Asia/Taipei".to_string());
+        assert_eq!(
+            "PrimitiveArray<Timestamp(Millisecond, Some(\"Asia/Taipei\"))>\n[\n  2018-12-31T08:00:00+08:00,\n  2018-12-31T08:00:00+08:00,\n  1921-01-02T08:00:00+08:00,\n]",
+            format!("{:?}", arr)
+        );
+    }
+
+    #[test]
+    #[cfg(not(feature = "chrono-tz"))]
+    fn test_timestamp_with_named_tz_fmt_debug() {
+        let arr: PrimitiveArray<TimestampMillisecondType> =
+            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000])
+                .with_timezone("Asia/Taipei".to_string());
+
+        println!("{arr:?}");
+
+        assert_eq!(
+            "PrimitiveArray<Timestamp(Millisecond, Some(\"Asia/Taipei\"))>\n[\n  2018-12-31T00:00:00 (Unknown Time Zone 'Asia/Taipei'),\n  2018-12-31T00:00:00 (Unknown Time Zone 'Asia/Taipei'),\n  1921-01-02T00:00:00 (Unknown Time Zone 'Asia/Taipei'),\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    fn test_timestamp_with_fixed_offset_tz_fmt_debug() {
+        let arr: PrimitiveArray<TimestampMillisecondType> =
+            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000])
+                .with_timezone("+08:00".to_string());
+        assert_eq!(
+            "PrimitiveArray<Timestamp(Millisecond, Some(\"+08:00\"))>\n[\n  2018-12-31T08:00:00+08:00,\n  2018-12-31T08:00:00+08:00,\n  1921-01-02T08:00:00+08:00,\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    fn test_timestamp_with_incorrect_tz_fmt_debug() {
+        let arr: PrimitiveArray<TimestampMillisecondType> =
+            TimestampMillisecondArray::from(vec![1546214400000, 1546214400000, -1546214400000])
+                .with_timezone("xxx".to_string());
+        assert_eq!(
+            "PrimitiveArray<Timestamp(Millisecond, Some(\"xxx\"))>\n[\n  2018-12-31T00:00:00 (Unknown Time Zone 'xxx'),\n  2018-12-31T00:00:00 (Unknown Time Zone 'xxx'),\n  1921-01-02T00:00:00 (Unknown Time Zone 'xxx'),\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    #[cfg(feature = "chrono-tz")]
+    fn test_timestamp_with_tz_with_daylight_saving_fmt_debug() {
+        let arr: PrimitiveArray<TimestampMillisecondType> = TimestampMillisecondArray::from(vec![
+            1647161999000,
+            1647162000000,
+            1667717999000,
+            1667718000000,
+        ])
+        .with_timezone("America/Denver".to_string());
+        assert_eq!(
+            "PrimitiveArray<Timestamp(Millisecond, Some(\"America/Denver\"))>\n[\n  2022-03-13T01:59:59-07:00,\n  2022-03-13T03:00:00-06:00,\n  2022-11-06T00:59:59-06:00,\n  2022-11-06T01:00:00-06:00,\n]",
+            format!("{:?}", arr)
+        );
+    }
+
+    #[test]
+    fn test_date32_fmt_debug() {
+        let arr: PrimitiveArray<Date32Type> = vec![12356, 13548, -365].into();
+        assert_eq!(
+            "PrimitiveArray<Date32>\n[\n  2003-10-31,\n  2007-02-04,\n  1969-01-01,\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    fn test_time32second_fmt_debug() {
+        let arr: PrimitiveArray<Time32SecondType> = vec![7201, 60054].into();
+        assert_eq!(
+            "PrimitiveArray<Time32(Second)>\n[\n  02:00:01,\n  16:40:54,\n]",
+            format!("{arr:?}")
+        );
+    }
+
+    #[test]
+    fn test_time32second_invalid_neg() {
+        // chrono::NaiveDatetime::from_timestamp_opt returns None while input is invalid
+        let arr: PrimitiveArray<Time32SecondType> = vec![-7201, -60054].into();
+        assert_eq!(
+        "PrimitiveArray<Time32(Second)>\n[\n  Cast error: Failed to convert -7201 to temporal for Time32(Second),\n  Cast error: Failed to convert -60054 to temporal for Time32(Second),\n]",
+            // "PrimitiveArray<Time32(Second)>\n[\n  null,\n  null,\n]",
+            format!("{arr:?}")
+        )
+    }
+
+    #[test]
+    fn test_timestamp_micros_out_of_range() {
+        // replicate the issue from https://github.com/apache/arrow-datafusion/issues/3832
+        let arr: PrimitiveArray<TimestampMicrosecondType> = vec![9065525203050843594].into();
+        assert_eq!(
+            "PrimitiveArray<Timestamp(Microsecond, None)>\n[\n  null,\n]",
+            format!("{arr:?}")
+        )
+    }
+
+    #[test]
+    fn test_primitive_array_builder() {
+        // Test building a primitive array with ArrayData builder and offset
+        let buf = Buffer::from_slice_ref([0i32, 1, 2, 3, 4, 5, 6]);
+        let buf2 = buf.slice_with_length(8, 20);
+        let data = ArrayData::builder(DataType::Int32)
+            .len(5)
+            .offset(2)
+            .add_buffer(buf)
+            .build()
+            .unwrap();
+        let arr = Int32Array::from(data);
+        assert_eq!(&buf2, arr.values.inner());
+        assert_eq!(5, arr.len());
+        assert_eq!(0, arr.null_count());
+        for i in 0..3 {
+            assert_eq!((i + 2) as i32, arr.value(i));
+        }
+    }
+
+    #[test]
+    fn test_primitive_from_iter_values() {
+        // Test building a primitive array with from_iter_values
+        let arr: PrimitiveArray<Int32Type> = PrimitiveArray::from_iter_values(0..10);
+        assert_eq!(10, arr.len());
+        assert_eq!(0, arr.null_count());
+        for i in 0..10i32 {
+            assert_eq!(i, arr.value(i as usize));
+        }
+    }
+
+    #[test]
+    fn test_primitive_array_from_unbound_iter() {
+        // iterator that doesn't declare (upper) size bound
+        let value_iter = (0..)
+            .scan(0usize, |pos, i| {
+                if *pos < 10 {
+                    *pos += 1;
+                    Some(Some(i))
+                } else {
+                    // actually returns up to 10 values
+                    None
+                }
+            })
+            // limited using take()
+            .take(100);
+
+        let (_, upper_size_bound) = value_iter.size_hint();
+        // the upper bound, defined by take above, is 100
+        assert_eq!(upper_size_bound, Some(100));
+        let primitive_array: PrimitiveArray<Int32Type> = value_iter.collect();
+        // but the actual number of items in the array should be 10
+        assert_eq!(primitive_array.len(), 10);
+    }
+
+    #[test]
+    fn test_primitive_array_from_non_null_iter() {
+        let iter = (0..10_i32).map(Some);
+        let primitive_array = PrimitiveArray::<Int32Type>::from_iter(iter);
+        assert_eq!(primitive_array.len(), 10);
+        assert_eq!(primitive_array.null_count(), 0);
+        assert!(primitive_array.nulls().is_none());
+        assert_eq!(primitive_array.values(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
+    }
+
+    #[test]
+    #[should_panic(expected = "PrimitiveArray data should contain a single buffer only \
+                               (values buffer)")]
+    // Different error messages, so skip for now
+    // https://github.com/apache/arrow-rs/issues/1545
+    #[cfg(not(feature = "force_validate"))]
+    fn test_primitive_array_invalid_buffer_len() {
+        let buffer = Buffer::from_slice_ref([0i32, 1, 2, 3, 4]);
+        let data = unsafe {
+            ArrayData::builder(DataType::Int32)
+                .add_buffer(buffer.clone())
+                .add_buffer(buffer)
+                .len(5)
+                .build_unchecked()
+        };
+
+        drop(Int32Array::from(data));
+    }
+
+    #[test]
+    fn test_access_array_concurrently() {
+        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
+        let ret = std::thread::spawn(move || a.value(3)).join();
+
+        assert!(ret.is_ok());
+        assert_eq!(8, ret.ok().unwrap());
+    }
+
+    #[test]
+    fn test_primitive_array_creation() {
+        let array1: Int8Array = [10_i8, 11, 12, 13, 14].into_iter().collect();
+        let array2: Int8Array = [10_i8, 11, 12, 13, 14].into_iter().map(Some).collect();
+
+        assert_eq!(array1, array2);
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Trying to access an element at index 4 from a PrimitiveArray of length 3"
+    )]
+    fn test_string_array_get_value_index_out_of_bound() {
+        let array: Int8Array = [10_i8, 11, 12].into_iter().collect();
+
+        array.value(4);
+    }
+
+    #[test]
+    #[should_panic(expected = "PrimitiveArray expected data type Int64 got Int32")]
+    fn test_from_array_data_validation() {
+        let foo = PrimitiveArray::<Int32Type>::from_iter([1, 2, 3]);
+        let _ = PrimitiveArray::<Int64Type>::from(foo.into_data());
+    }
+
+    #[test]
+    fn test_decimal128() {
+        let values: Vec<_> = vec![0, 1, -1, i128::MIN, i128::MAX];
+        let array: PrimitiveArray<Decimal128Type> =
+            PrimitiveArray::from_iter(values.iter().copied());
+        assert_eq!(array.values(), &values);
+
+        let array: PrimitiveArray<Decimal128Type> =
+            PrimitiveArray::from_iter_values(values.iter().copied());
+        assert_eq!(array.values(), &values);
+
+        let array = PrimitiveArray::<Decimal128Type>::from(values.clone());
+        assert_eq!(array.values(), &values);
+
+        let array = PrimitiveArray::<Decimal128Type>::from(array.to_data());
+        assert_eq!(array.values(), &values);
+    }
+
+    #[test]
+    fn test_decimal256() {
+        let values: Vec<_> = vec![i256::ZERO, i256::ONE, i256::MINUS_ONE, i256::MIN, i256::MAX];
+
+        let array: PrimitiveArray<Decimal256Type> =
+            PrimitiveArray::from_iter(values.iter().copied());
+        assert_eq!(array.values(), &values);
+
+        let array: PrimitiveArray<Decimal256Type> =
+            PrimitiveArray::from_iter_values(values.iter().copied());
+        assert_eq!(array.values(), &values);
+
+        let array = PrimitiveArray::<Decimal256Type>::from(values.clone());
+        assert_eq!(array.values(), &values);
+
+        let array = PrimitiveArray::<Decimal256Type>::from(array.to_data());
+        assert_eq!(array.values(), &values);
+    }
+
+    #[test]
+    fn test_decimal_array() {
+        // let val_8887: [u8; 16] = [192, 219, 180, 17, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
+        // let val_neg_8887: [u8; 16] = [64, 36, 75, 238, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255];
+        let values: [u8; 32] = [
+            192, 219, 180, 17, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 36, 75, 238, 253, 255, 255,
+            255, 255, 255, 255, 255, 255, 255, 255, 255,
+        ];
+        let array_data = ArrayData::builder(DataType::Decimal128(38, 6))
+            .len(2)
+            .add_buffer(Buffer::from(&values[..]))
+            .build()
+            .unwrap();
+        let decimal_array = Decimal128Array::from(array_data);
+        assert_eq!(8_887_000_000_i128, decimal_array.value(0));
+        assert_eq!(-8_887_000_000_i128, decimal_array.value(1));
+    }
+
+    #[test]
+    fn test_decimal_append_error_value() {
+        let mut decimal_builder = Decimal128Builder::with_capacity(10);
+        decimal_builder.append_value(123456);
+        decimal_builder.append_value(12345);
+        let result = decimal_builder.finish().with_precision_and_scale(5, 3);
+        assert!(result.is_ok());
+        let arr = result.unwrap();
+        assert_eq!("12.345", arr.value_as_string(1));
+
+        // Validate it explicitly
+        let result = arr.validate_decimal_precision(5);
+        let error = result.unwrap_err();
+        assert_eq!(
+            "Invalid argument error: 123456 is too large to store in a Decimal128 of precision 5. Max is 99999",
+            error.to_string()
+        );
+
+        decimal_builder = Decimal128Builder::new();
+        decimal_builder.append_value(100);
+        decimal_builder.append_value(99);
+        decimal_builder.append_value(-100);
+        decimal_builder.append_value(-99);
+        let result = decimal_builder.finish().with_precision_and_scale(2, 1);
+        assert!(result.is_ok());
+        let arr = result.unwrap();
+        assert_eq!("9.9", arr.value_as_string(1));
+        assert_eq!("-9.9", arr.value_as_string(3));
+
+        // Validate it explicitly
+        let result = arr.validate_decimal_precision(2);
+        let error = result.unwrap_err();
+        assert_eq!(
+            "Invalid argument error: 100 is too large to store in a Decimal128 of precision 2. Max is 99",
+            error.to_string()
+        );
+    }
+
+    #[test]
+    fn test_decimal_from_iter_values() {
+        let array = Decimal128Array::from_iter_values(vec![-100, 0, 101]);
+        assert_eq!(array.len(), 3);
+        assert_eq!(array.data_type(), &DataType::Decimal128(38, 10));
+        assert_eq!(-100_i128, array.value(0));
+        assert!(!array.is_null(0));
+        assert_eq!(0_i128, array.value(1));
+        assert!(!array.is_null(1));
+        assert_eq!(101_i128, array.value(2));
+        assert!(!array.is_null(2));
+    }
+
+    #[test]
+    fn test_decimal_from_iter() {
+        let array: Decimal128Array = vec![Some(-100), None, Some(101)].into_iter().collect();
+        assert_eq!(array.len(), 3);
+        assert_eq!(array.data_type(), &DataType::Decimal128(38, 10));
+        assert_eq!(-100_i128, array.value(0));
+        assert!(!array.is_null(0));
+        assert!(array.is_null(1));
+        assert_eq!(101_i128, array.value(2));
+        assert!(!array.is_null(2));
+    }
+
+    #[test]
+    fn test_decimal_iter_sized() {
+        let data = vec![Some(-100), None, Some(101)];
+        let array: Decimal128Array = data.into_iter().collect();
+        let mut iter = array.into_iter();
+
+        // is exact sized
+        assert_eq!(array.len(), 3);
+
+        // size_hint is reported correctly
+        assert_eq!(iter.size_hint(), (3, Some(3)));
+        iter.next().unwrap();
+        assert_eq!(iter.size_hint(), (2, Some(2)));
+        iter.next().unwrap();
+        iter.next().unwrap();
+        assert_eq!(iter.size_hint(), (0, Some(0)));
+        assert!(iter.next().is_none());
+        assert_eq!(iter.size_hint(), (0, Some(0)));
+    }
+
+    #[test]
+    fn test_decimal_array_value_as_string() {
+        let arr = [123450, -123450, 100, -100, 10, -10, 0]
+            .into_iter()
+            .map(Some)
+            .collect::<Decimal128Array>()
+            .with_precision_and_scale(6, 3)
+            .unwrap();
+
+        assert_eq!("123.450", arr.value_as_string(0));
+        assert_eq!("-123.450", arr.value_as_string(1));
+        assert_eq!("0.100", arr.value_as_string(2));
+        assert_eq!("-0.100", arr.value_as_string(3));
+        assert_eq!("0.010", arr.value_as_string(4));
+        assert_eq!("-0.010", arr.value_as_string(5));
+        assert_eq!("0.000", arr.value_as_string(6));
+    }
+
+    #[test]
+    fn test_decimal_array_with_precision_and_scale() {
+        let arr = Decimal128Array::from_iter_values([12345, 456, 7890, -123223423432432])
+            .with_precision_and_scale(20, 2)
+            .unwrap();
+
+        assert_eq!(arr.data_type(), &DataType::Decimal128(20, 2));
+        assert_eq!(arr.precision(), 20);
+        assert_eq!(arr.scale(), 2);
+
+        let actual: Vec<_> = (0..arr.len()).map(|i| arr.value_as_string(i)).collect();
+        let expected = vec!["123.45", "4.56", "78.90", "-1232234234324.32"];
+
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "-123223423432432 is too small to store in a Decimal128 of precision 5. Min is -99999"
+    )]
+    fn test_decimal_array_with_precision_and_scale_out_of_range() {
+        let arr = Decimal128Array::from_iter_values([12345, 456, 7890, -123223423432432])
+            // precision is too small to hold value
+            .with_precision_and_scale(5, 2)
+            .unwrap();
+        arr.validate_decimal_precision(5).unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "precision cannot be 0, has to be between [1, 38]")]
+    fn test_decimal_array_with_precision_zero() {
+        Decimal128Array::from_iter_values([12345, 456])
+            .with_precision_and_scale(0, 2)
+            .unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "precision 40 is greater than max 38")]
+    fn test_decimal_array_with_precision_and_scale_invalid_precision() {
+        Decimal128Array::from_iter_values([12345, 456])
+            .with_precision_and_scale(40, 2)
+            .unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "scale 40 is greater than max 38")]
+    fn test_decimal_array_with_precision_and_scale_invalid_scale() {
+        Decimal128Array::from_iter_values([12345, 456])
+            .with_precision_and_scale(20, 40)
+            .unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "scale 10 is greater than precision 4")]
+    fn test_decimal_array_with_precision_and_scale_invalid_precision_and_scale() {
+        Decimal128Array::from_iter_values([12345, 456])
+            .with_precision_and_scale(4, 10)
+            .unwrap();
+    }
+
+    #[test]
+    fn test_decimal_array_set_null_if_overflow_with_precision() {
+        let array = Decimal128Array::from(vec![Some(123456), Some(123), None, Some(123456)]);
+        let result = array.null_if_overflow_precision(5);
+        let expected = Decimal128Array::from(vec![None, Some(123), None, None]);
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_decimal256_iter() {
+        let mut builder = Decimal256Builder::with_capacity(30);
+        let decimal1 = i256::from_i128(12345);
+        builder.append_value(decimal1);
+
+        builder.append_null();
+
+        let decimal2 = i256::from_i128(56789);
+        builder.append_value(decimal2);
+
+        let array: Decimal256Array = builder.finish().with_precision_and_scale(76, 6).unwrap();
+
+        let collected: Vec<_> = array.iter().collect();
+        assert_eq!(vec![Some(decimal1), None, Some(decimal2)], collected);
+    }
+
+    #[test]
+    fn test_from_iter_decimal256array() {
+        let value1 = i256::from_i128(12345);
+        let value2 = i256::from_i128(56789);
+
+        let mut array: Decimal256Array =
+            vec![Some(value1), None, Some(value2)].into_iter().collect();
+        array = array.with_precision_and_scale(76, 10).unwrap();
+        assert_eq!(array.len(), 3);
+        assert_eq!(array.data_type(), &DataType::Decimal256(76, 10));
+        assert_eq!(value1, array.value(0));
+        assert!(!array.is_null(0));
+        assert!(array.is_null(1));
+        assert_eq!(value2, array.value(2));
+        assert!(!array.is_null(2));
+    }
+
+    #[test]
+    fn test_from_iter_decimal128array() {
+        let mut array: Decimal128Array = vec![Some(-100), None, Some(101)].into_iter().collect();
+        array = array.with_precision_and_scale(38, 10).unwrap();
+        assert_eq!(array.len(), 3);
+        assert_eq!(array.data_type(), &DataType::Decimal128(38, 10));
+        assert_eq!(-100_i128, array.value(0));
+        assert!(!array.is_null(0));
+        assert!(array.is_null(1));
+        assert_eq!(101_i128, array.value(2));
+        assert!(!array.is_null(2));
+    }
+
+    #[test]
+    fn test_unary_opt() {
+        let array = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7]);
+        let r = array.unary_opt::<_, Int32Type>(|x| (x % 2 != 0).then_some(x));
+
+        let expected = Int32Array::from(vec![Some(1), None, Some(3), None, Some(5), None, Some(7)]);
+        assert_eq!(r, expected);
+
+        let r = expected.unary_opt::<_, Int32Type>(|x| (x % 3 != 0).then_some(x));
+        let expected = Int32Array::from(vec![Some(1), None, None, None, Some(5), None, Some(7)]);
+        assert_eq!(r, expected);
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Trying to access an element at index 4 from a PrimitiveArray of length 3"
+    )]
+    fn test_fixed_size_binary_array_get_value_index_out_of_bound() {
+        let array = Decimal128Array::from(vec![-100, 0, 101]);
+        array.value(4);
+    }
+
+    #[test]
+    fn test_into_builder() {
+        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
+
+        let boxed: ArrayRef = Arc::new(array);
+        let col: Int32Array = downcast_array(&boxed);
+        drop(boxed);
+
+        let mut builder = col.into_builder().unwrap();
+
+        let slice = builder.values_slice_mut();
+        assert_eq!(slice, &[1, 2, 3]);
+
+        slice[0] = 4;
+        slice[1] = 2;
+        slice[2] = 1;
+
+        let expected: Int32Array = vec![Some(4), Some(2), Some(1)].into_iter().collect();
+
+        let new_array = builder.finish();
+        assert_eq!(expected, new_array);
+    }
+
+    #[test]
+    fn test_into_builder_cloned_array() {
+        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
+
+        let boxed: ArrayRef = Arc::new(array);
+
+        let col: Int32Array = PrimitiveArray::<Int32Type>::from(boxed.to_data());
+        let err = col.into_builder();
+
+        match err {
+            Ok(_) => panic!("Should not get builder from cloned array"),
+            Err(returned) => {
+                let expected: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
+                assert_eq!(expected, returned)
+            }
+        }
+    }
+
+    #[test]
+    fn test_into_builder_on_sliced_array() {
+        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
+        let slice = array.slice(1, 2);
+        let col: Int32Array = downcast_array(&slice);
+
+        drop(slice);
+
+        col.into_builder()
+            .expect_err("Should not build builder from sliced array");
+    }
+
+    #[test]
+    fn test_unary_mut() {
+        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
+
+        let c = array.unary_mut(|x| x * 2 + 1).unwrap();
+        let expected: Int32Array = vec![3, 5, 7].into_iter().map(Some).collect();
+
+        assert_eq!(expected, c);
+
+        let array: Int32Array = Int32Array::from(vec![Some(5), Some(7), None]);
+        let c = array.unary_mut(|x| x * 2 + 1).unwrap();
+        assert_eq!(c, Int32Array::from(vec![Some(11), Some(15), None]));
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "PrimitiveArray expected data type Interval(MonthDayNano) got Interval(DayTime)"
+    )]
+    fn test_invalid_interval_type() {
+        let array = IntervalDayTimeArray::from(vec![1, 2, 3]);
+        let _ = IntervalMonthDayNanoArray::from(array.into_data());
+    }
+
+    #[test]
+    fn test_timezone() {
+        let array = TimestampNanosecondArray::from_iter_values([1, 2]);
+        assert_eq!(array.timezone(), None);
+
+        let array = array.with_timezone("+02:00");
+        assert_eq!(array.timezone(), Some("+02:00"));
+    }
+
+    #[test]
+    fn test_try_new() {
+        Int32Array::new(vec![1, 2, 3, 4].into(), None);
+        Int32Array::new(vec![1, 2, 3, 4].into(), Some(NullBuffer::new_null(4)));
+
+        let err = Int32Array::try_new(vec![1, 2, 3, 4].into(), Some(NullBuffer::new_null(3)))
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Incorrect length of null buffer for PrimitiveArray, expected 4 got 3"
+        );
+
+        TimestampNanosecondArray::new(vec![1, 2, 3, 4].into(), None).with_data_type(
+            DataType::Timestamp(TimeUnit::Nanosecond, Some("03:00".into())),
+        );
+    }
+
+    #[test]
+    #[should_panic(expected = "PrimitiveArray expected data type Int32 got Date32")]
+    fn test_with_data_type() {
+        Int32Array::new(vec![1, 2, 3, 4].into(), None).with_data_type(DataType::Date32);
+    }
+
+    #[test]
+    fn test_time_32second_output() {
+        let array: Time32SecondArray = vec![
+            Some(-1),
+            Some(0),
+            Some(86_399),
+            Some(86_400),
+            Some(86_401),
+            None,
+        ]
+        .into();
+        let debug_str = format!("{:?}", array);
+        assert_eq!("PrimitiveArray<Time32(Second)>\n[\n  Cast error: Failed to convert -1 to temporal for Time32(Second),\n  00:00:00,\n  23:59:59,\n  Cast error: Failed to convert 86400 to temporal for Time32(Second),\n  Cast error: Failed to convert 86401 to temporal for Time32(Second),\n  null,\n]",
+    debug_str
+    );
+    }
+
+    #[test]
+    fn test_time_32millisecond_debug_output() {
+        let array: Time32MillisecondArray = vec![
+            Some(-1),
+            Some(0),
+            Some(86_399_000),
+            Some(86_400_000),
+            Some(86_401_000),
+            None,
+        ]
+        .into();
+        let debug_str = format!("{:?}", array);
+        assert_eq!("PrimitiveArray<Time32(Millisecond)>\n[\n  Cast error: Failed to convert -1 to temporal for Time32(Millisecond),\n  00:00:00,\n  23:59:59,\n  Cast error: Failed to convert 86400000 to temporal for Time32(Millisecond),\n  Cast error: Failed to convert 86401000 to temporal for Time32(Millisecond),\n  null,\n]",
+            debug_str
+        );
+    }
+
+    #[test]
+    fn test_time_64nanosecond_debug_output() {
+        let array: Time64NanosecondArray = vec![
+            Some(-1),
+            Some(0),
+            Some(86_399 * 1_000_000_000),
+            Some(86_400 * 1_000_000_000),
+            Some(86_401 * 1_000_000_000),
+            None,
+        ]
+        .into();
+        let debug_str = format!("{:?}", array);
+        assert_eq!(
+        "PrimitiveArray<Time64(Nanosecond)>\n[\n  Cast error: Failed to convert -1 to temporal for Time64(Nanosecond),\n  00:00:00,\n  23:59:59,\n  Cast error: Failed to convert 86400000000000 to temporal for Time64(Nanosecond),\n  Cast error: Failed to convert 86401000000000 to temporal for Time64(Nanosecond),\n  null,\n]",
+            debug_str
+        );
+    }
+
+    #[test]
+    fn test_time_64microsecond_debug_output() {
+        let array: Time64MicrosecondArray = vec![
+            Some(-1),
+            Some(0),
+            Some(86_399 * 1_000_000),
+            Some(86_400 * 1_000_000),
+            Some(86_401 * 1_000_000),
+            None,
+        ]
+        .into();
+        let debug_str = format!("{:?}", array);
+        assert_eq!("PrimitiveArray<Time64(Microsecond)>\n[\n  Cast error: Failed to convert -1 to temporal for Time64(Microsecond),\n  00:00:00,\n  23:59:59,\n  Cast error: Failed to convert 86400000000 to temporal for Time64(Microsecond),\n  Cast error: Failed to convert 86401000000 to temporal for Time64(Microsecond),\n  null,\n]", debug_str);
+    }
+}
diff --git a/arrow-array/src/array/run_array.rs b/arrow-array/src/array/run_array.rs
new file mode 100644
index 000000000000..4877f9f850a3
--- /dev/null
+++ b/arrow-array/src/array/run_array.rs
@@ -0,0 +1,1095 @@
+// 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.
+
+use std::any::Any;
+use std::sync::Arc;
+
+use arrow_buffer::{ArrowNativeType, BooleanBufferBuilder, NullBuffer, RunEndBuffer};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType, Field};
+
+use crate::{
+    builder::StringRunBuilder,
+    make_array,
+    run_iterator::RunArrayIter,
+    types::{Int16Type, Int32Type, Int64Type, RunEndIndexType},
+    Array, ArrayAccessor, ArrayRef, PrimitiveArray,
+};
+
+/// An array of [run-end encoded values](https://arrow.apache.org/docs/format/Columnar.html#run-end-encoded-layout)
+///
+/// This encoding is variation on [run-length encoding (RLE)](https://en.wikipedia.org/wiki/Run-length_encoding)
+/// and is good for representing data containing same values repeated consecutively.
+///
+/// [`RunArray`] contains `run_ends` array and `values` array of same length.
+/// The `run_ends` array stores the indexes at which the run ends. The `values` array
+/// stores the value of each run. Below example illustrates how a logical array is represented in
+/// [`RunArray`]
+///
+///
+/// ```text
+/// ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─┐
+///   ┌─────────────────┐  ┌─────────┐       ┌─────────────────┐
+/// │ │        A        │  │    2    │ │     │        A        │     
+///   ├─────────────────┤  ├─────────┤       ├─────────────────┤
+/// │ │        D        │  │    3    │ │     │        A        │    run length of 'A' = runs_ends[0] - 0 = 2
+///   ├─────────────────┤  ├─────────┤       ├─────────────────┤
+/// │ │        B        │  │    6    │ │     │        D        │    run length of 'D' = run_ends[1] - run_ends[0] = 1
+///   └─────────────────┘  └─────────┘       ├─────────────────┤
+/// │        values          run_ends  │     │        B        │     
+///                                          ├─────────────────┤
+/// └ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─┘     │        B        │     
+///                                          ├─────────────────┤
+///                RunArray                  │        B        │    run length of 'B' = run_ends[2] - run_ends[1] = 3
+///               length = 3                 └─────────────────┘
+///  
+///                                             Logical array
+///                                                Contents
+/// ```
+
+pub struct RunArray<R: RunEndIndexType> {
+    data_type: DataType,
+    run_ends: RunEndBuffer<R::Native>,
+    values: ArrayRef,
+}
+
+impl<R: RunEndIndexType> Clone for RunArray<R> {
+    fn clone(&self) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            run_ends: self.run_ends.clone(),
+            values: self.values.clone(),
+        }
+    }
+}
+
+impl<R: RunEndIndexType> RunArray<R> {
+    /// Calculates the logical length of the array encoded
+    /// by the given run_ends array.
+    pub fn logical_len(run_ends: &PrimitiveArray<R>) -> usize {
+        let len = run_ends.len();
+        if len == 0 {
+            return 0;
+        }
+        run_ends.value(len - 1).as_usize()
+    }
+
+    /// Attempts to create RunArray using given run_ends (index where a run ends)
+    /// and the values (value of the run). Returns an error if the given data is not compatible
+    /// with RunEndEncoded specification.
+    pub fn try_new(run_ends: &PrimitiveArray<R>, values: &dyn Array) -> Result<Self, ArrowError> {
+        let run_ends_type = run_ends.data_type().clone();
+        let values_type = values.data_type().clone();
+        let ree_array_type = DataType::RunEndEncoded(
+            Arc::new(Field::new("run_ends", run_ends_type, false)),
+            Arc::new(Field::new("values", values_type, true)),
+        );
+        let len = RunArray::logical_len(run_ends);
+        let builder = ArrayDataBuilder::new(ree_array_type)
+            .len(len)
+            .add_child_data(run_ends.to_data())
+            .add_child_data(values.to_data());
+
+        // `build_unchecked` is used to avoid recursive validation of child arrays.
+        let array_data = unsafe { builder.build_unchecked() };
+
+        // Safety: `validate_data` checks below
+        //    1. The given array data has exactly two child arrays.
+        //    2. The first child array (run_ends) has valid data type.
+        //    3. run_ends array does not have null values
+        //    4. run_ends array has non-zero and strictly increasing values.
+        //    5. The length of run_ends array and values array are the same.
+        array_data.validate_data()?;
+
+        Ok(array_data.into())
+    }
+
+    /// Returns a reference to [`RunEndBuffer`]
+    pub fn run_ends(&self) -> &RunEndBuffer<R::Native> {
+        &self.run_ends
+    }
+
+    /// Returns a reference to values array
+    ///
+    /// Note: any slicing of this [`RunArray`] array is not applied to the returned array
+    /// and must be handled separately
+    pub fn values(&self) -> &ArrayRef {
+        &self.values
+    }
+
+    /// Returns the physical index at which the array slice starts.
+    pub fn get_start_physical_index(&self) -> usize {
+        self.run_ends.get_start_physical_index()
+    }
+
+    /// Returns the physical index at which the array slice ends.
+    pub fn get_end_physical_index(&self) -> usize {
+        self.run_ends.get_end_physical_index()
+    }
+
+    /// Downcast this [`RunArray`] to a [`TypedRunArray`]
+    ///
+    /// ```
+    /// use arrow_array::{Array, ArrayAccessor, RunArray, StringArray, types::Int32Type};
+    ///
+    /// let orig = [Some("a"), Some("b"), None];
+    /// let run_array = RunArray::<Int32Type>::from_iter(orig);
+    /// let typed = run_array.downcast::<StringArray>().unwrap();
+    /// assert_eq!(typed.value(0), "a");
+    /// assert_eq!(typed.value(1), "b");
+    /// assert!(typed.values().is_null(2));
+    /// ```
+    ///
+    pub fn downcast<V: 'static>(&self) -> Option<TypedRunArray<'_, R, V>> {
+        let values = self.values.as_any().downcast_ref()?;
+        Some(TypedRunArray {
+            run_array: self,
+            values,
+        })
+    }
+
+    /// Returns index to the physical array for the given index to the logical array.
+    /// This function adjusts the input logical index based on `ArrayData::offset`
+    /// Performs a binary search on the run_ends array for the input index.
+    ///
+    /// The result is arbitrary if `logical_index >= self.len()`
+    pub fn get_physical_index(&self, logical_index: usize) -> usize {
+        self.run_ends.get_physical_index(logical_index)
+    }
+
+    /// Returns the physical indices of the input logical indices. Returns error if any of the logical
+    /// index cannot be converted to physical index. The logical indices are sorted and iterated along
+    /// with run_ends array to find matching physical index. The approach used here was chosen over
+    /// finding physical index for each logical index using binary search using the function
+    /// `get_physical_index`. Running benchmarks on both approaches showed that the approach used here
+    /// scaled well for larger inputs.
+    /// See <https://github.com/apache/arrow-rs/pull/3622#issuecomment-1407753727> for more details.
+    #[inline]
+    pub fn get_physical_indices<I>(&self, logical_indices: &[I]) -> Result<Vec<usize>, ArrowError>
+    where
+        I: ArrowNativeType,
+    {
+        let len = self.run_ends().len();
+        let offset = self.run_ends().offset();
+
+        let indices_len = logical_indices.len();
+
+        if indices_len == 0 {
+            return Ok(vec![]);
+        }
+
+        // `ordered_indices` store index into `logical_indices` and can be used
+        // to iterate `logical_indices` in sorted order.
+        let mut ordered_indices: Vec<usize> = (0..indices_len).collect();
+
+        // Instead of sorting `logical_indices` directly, sort the `ordered_indices`
+        // whose values are index of `logical_indices`
+        ordered_indices.sort_unstable_by(|lhs, rhs| {
+            logical_indices[*lhs]
+                .partial_cmp(&logical_indices[*rhs])
+                .unwrap()
+        });
+
+        // Return early if all the logical indices cannot be converted to physical indices.
+        let largest_logical_index = logical_indices[*ordered_indices.last().unwrap()].as_usize();
+        if largest_logical_index >= len {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Cannot convert all logical indices to physical indices. The logical index cannot be converted is {largest_logical_index}.",
+            )));
+        }
+
+        // Skip some physical indices based on offset.
+        let skip_value = self.get_start_physical_index();
+
+        let mut physical_indices = vec![0; indices_len];
+
+        let mut ordered_index = 0_usize;
+        for (physical_index, run_end) in self.run_ends.values().iter().enumerate().skip(skip_value)
+        {
+            // Get the run end index (relative to offset) of current physical index
+            let run_end_value = run_end.as_usize() - offset;
+
+            // All the `logical_indices` that are less than current run end index
+            // belongs to current physical index.
+            while ordered_index < indices_len
+                && logical_indices[ordered_indices[ordered_index]].as_usize() < run_end_value
+            {
+                physical_indices[ordered_indices[ordered_index]] = physical_index;
+                ordered_index += 1;
+            }
+        }
+
+        // If there are input values >= run_ends.last_value then we'll not be able to convert
+        // all logical indices to physical indices.
+        if ordered_index < logical_indices.len() {
+            let logical_index = logical_indices[ordered_indices[ordered_index]].as_usize();
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Cannot convert all logical indices to physical indices. The logical index cannot be converted is {logical_index}.",
+            )));
+        }
+        Ok(physical_indices)
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, length: usize) -> Self {
+        Self {
+            data_type: self.data_type.clone(),
+            run_ends: self.run_ends.slice(offset, length),
+            values: self.values.clone(),
+        }
+    }
+}
+
+impl<R: RunEndIndexType> From<ArrayData> for RunArray<R> {
+    // The method assumes the caller already validated the data using `ArrayData::validate_data()`
+    fn from(data: ArrayData) -> Self {
+        match data.data_type() {
+            DataType::RunEndEncoded(_, _) => {}
+            _ => {
+                panic!("Invalid data type for RunArray. The data type should be DataType::RunEndEncoded");
+            }
+        }
+
+        // Safety
+        // ArrayData is valid
+        let child = &data.child_data()[0];
+        assert_eq!(child.data_type(), &R::DATA_TYPE, "Incorrect run ends type");
+        let run_ends = unsafe {
+            let scalar = child.buffers()[0].clone().into();
+            RunEndBuffer::new_unchecked(scalar, data.offset(), data.len())
+        };
+
+        let values = make_array(data.child_data()[1].clone());
+        Self {
+            data_type: data.data_type().clone(),
+            run_ends,
+            values,
+        }
+    }
+}
+
+impl<R: RunEndIndexType> From<RunArray<R>> for ArrayData {
+    fn from(array: RunArray<R>) -> Self {
+        let len = array.run_ends.len();
+        let offset = array.run_ends.offset();
+
+        let run_ends = ArrayDataBuilder::new(R::DATA_TYPE)
+            .len(array.run_ends.values().len())
+            .buffers(vec![array.run_ends.into_inner().into_inner()]);
+
+        let run_ends = unsafe { run_ends.build_unchecked() };
+
+        let builder = ArrayDataBuilder::new(array.data_type)
+            .len(len)
+            .offset(offset)
+            .child_data(vec![run_ends, array.values.to_data()]);
+
+        unsafe { builder.build_unchecked() }
+    }
+}
+
+impl<T: RunEndIndexType> Array for RunArray<T> {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.into()
+    }
+
+    fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.run_ends.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.run_ends.is_empty()
+    }
+
+    fn offset(&self) -> usize {
+        self.run_ends.offset()
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        None
+    }
+
+    fn logical_nulls(&self) -> Option<NullBuffer> {
+        let len = self.len();
+        let nulls = self.values.logical_nulls()?;
+        let mut out = BooleanBufferBuilder::new(len);
+        let offset = self.run_ends.offset();
+        let mut valid_start = 0;
+        let mut last_end = 0;
+        for (idx, end) in self.run_ends.values().iter().enumerate() {
+            let end = end.as_usize();
+            if end < offset {
+                continue;
+            }
+            let end = (end - offset).min(len);
+            if nulls.is_null(idx) {
+                if valid_start < last_end {
+                    out.append_n(last_end - valid_start, true);
+                }
+                out.append_n(end - last_end, false);
+                valid_start = end;
+            }
+            last_end = end;
+            if end == len {
+                break;
+            }
+        }
+        if valid_start < len {
+            out.append_n(len - valid_start, true)
+        }
+        // Sanity check
+        assert_eq!(out.len(), len);
+        Some(out.finish().into())
+    }
+
+    fn is_nullable(&self) -> bool {
+        !self.is_empty() && self.values.is_nullable()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        self.run_ends.inner().inner().capacity() + self.values.get_buffer_memory_size()
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        std::mem::size_of::<Self>()
+            + self.run_ends.inner().inner().capacity()
+            + self.values.get_array_memory_size()
+    }
+}
+
+impl<R: RunEndIndexType> std::fmt::Debug for RunArray<R> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        writeln!(
+            f,
+            "RunArray {{run_ends: {:?}, values: {:?}}}",
+            self.run_ends.values(),
+            self.values
+        )
+    }
+}
+
+/// Constructs a `RunArray` from an iterator of optional strings.
+///
+/// # Example:
+/// ```
+/// use arrow_array::{RunArray, PrimitiveArray, StringArray, types::Int16Type};
+///
+/// let test = vec!["a", "a", "b", "c", "c"];
+/// let array: RunArray<Int16Type> = test
+///     .iter()
+///     .map(|&x| if x == "b" { None } else { Some(x) })
+///     .collect();
+/// assert_eq!(
+///     "RunArray {run_ends: [2, 3, 5], values: StringArray\n[\n  \"a\",\n  null,\n  \"c\",\n]}\n",
+///     format!("{:?}", array)
+/// );
+/// ```
+impl<'a, T: RunEndIndexType> FromIterator<Option<&'a str>> for RunArray<T> {
+    fn from_iter<I: IntoIterator<Item = Option<&'a str>>>(iter: I) -> Self {
+        let it = iter.into_iter();
+        let (lower, _) = it.size_hint();
+        let mut builder = StringRunBuilder::with_capacity(lower, 256);
+        it.for_each(|i| {
+            builder.append_option(i);
+        });
+
+        builder.finish()
+    }
+}
+
+/// Constructs a `RunArray` from an iterator of strings.
+///
+/// # Example:
+///
+/// ```
+/// use arrow_array::{RunArray, PrimitiveArray, StringArray, types::Int16Type};
+///
+/// let test = vec!["a", "a", "b", "c"];
+/// let array: RunArray<Int16Type> = test.into_iter().collect();
+/// assert_eq!(
+///     "RunArray {run_ends: [2, 3, 4], values: StringArray\n[\n  \"a\",\n  \"b\",\n  \"c\",\n]}\n",
+///     format!("{:?}", array)
+/// );
+/// ```
+impl<'a, T: RunEndIndexType> FromIterator<&'a str> for RunArray<T> {
+    fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> Self {
+        let it = iter.into_iter();
+        let (lower, _) = it.size_hint();
+        let mut builder = StringRunBuilder::with_capacity(lower, 256);
+        it.for_each(|i| {
+            builder.append_value(i);
+        });
+
+        builder.finish()
+    }
+}
+
+///
+/// A [`RunArray`] with `i16` run ends
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, Int16RunArray, Int16Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: Int16RunArray = vec!["a", "a", "b", "c", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.run_ends().values(), &[2, 3, 5]);
+/// assert_eq!(array.values(), &values);
+/// ```
+pub type Int16RunArray = RunArray<Int16Type>;
+
+///
+/// A [`RunArray`] with `i32` run ends
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, Int32RunArray, Int32Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: Int32RunArray = vec!["a", "a", "b", "c", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.run_ends().values(), &[2, 3, 5]);
+/// assert_eq!(array.values(), &values);
+/// ```
+pub type Int32RunArray = RunArray<Int32Type>;
+
+///
+/// A [`RunArray`] with `i64` run ends
+///
+/// # Example: Using `collect`
+/// ```
+/// # use arrow_array::{Array, Int64RunArray, Int64Array, StringArray};
+/// # use std::sync::Arc;
+///
+/// let array: Int64RunArray = vec!["a", "a", "b", "c", "c"].into_iter().collect();
+/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+/// assert_eq!(array.run_ends().values(), &[2, 3, 5]);
+/// assert_eq!(array.values(), &values);
+/// ```
+pub type Int64RunArray = RunArray<Int64Type>;
+
+/// A [`RunArray`] typed typed on its child values array
+///
+/// Implements [`ArrayAccessor`] and [`IntoIterator`] allowing fast access to its elements
+///
+/// ```
+/// use arrow_array::{RunArray, StringArray, types::Int32Type};
+///
+/// let orig = ["a", "b", "a", "b"];
+/// let ree_array = RunArray::<Int32Type>::from_iter(orig);
+///
+/// // `TypedRunArray` allows you to access the values directly
+/// let typed = ree_array.downcast::<StringArray>().unwrap();
+///
+/// for (maybe_val, orig) in typed.into_iter().zip(orig) {
+///     assert_eq!(maybe_val.unwrap(), orig)
+/// }
+/// ```
+pub struct TypedRunArray<'a, R: RunEndIndexType, V> {
+    /// The run array
+    run_array: &'a RunArray<R>,
+
+    /// The values of the run_array
+    values: &'a V,
+}
+
+// Manually implement `Clone` to avoid `V: Clone` type constraint
+impl<'a, R: RunEndIndexType, V> Clone for TypedRunArray<'a, R, V> {
+    fn clone(&self) -> Self {
+        *self
+    }
+}
+
+impl<'a, R: RunEndIndexType, V> Copy for TypedRunArray<'a, R, V> {}
+
+impl<'a, R: RunEndIndexType, V> std::fmt::Debug for TypedRunArray<'a, R, V> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        writeln!(f, "TypedRunArray({:?})", self.run_array)
+    }
+}
+
+impl<'a, R: RunEndIndexType, V> TypedRunArray<'a, R, V> {
+    /// Returns the run_ends of this [`TypedRunArray`]
+    pub fn run_ends(&self) -> &'a RunEndBuffer<R::Native> {
+        self.run_array.run_ends()
+    }
+
+    /// Returns the values of this [`TypedRunArray`]
+    pub fn values(&self) -> &'a V {
+        self.values
+    }
+
+    /// Returns the run array of this [`TypedRunArray`]
+    pub fn run_array(&self) -> &'a RunArray<R> {
+        self.run_array
+    }
+}
+
+impl<'a, R: RunEndIndexType, V: Sync> Array for TypedRunArray<'a, R, V> {
+    fn as_any(&self) -> &dyn Any {
+        self.run_array
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.run_array.to_data()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.run_array.into_data()
+    }
+
+    fn data_type(&self) -> &DataType {
+        self.run_array.data_type()
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.run_array.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.run_array.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.run_array.is_empty()
+    }
+
+    fn offset(&self) -> usize {
+        self.run_array.offset()
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.run_array.nulls()
+    }
+
+    fn logical_nulls(&self) -> Option<NullBuffer> {
+        self.run_array.logical_nulls()
+    }
+
+    fn is_nullable(&self) -> bool {
+        self.run_array.is_nullable()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        self.run_array.get_buffer_memory_size()
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        self.run_array.get_array_memory_size()
+    }
+}
+
+// Array accessor converts the index of logical array to the index of the physical array
+// using binary search. The time complexity is O(log N) where N is number of runs.
+impl<'a, R, V> ArrayAccessor for TypedRunArray<'a, R, V>
+where
+    R: RunEndIndexType,
+    V: Sync + Send,
+    &'a V: ArrayAccessor,
+    <&'a V as ArrayAccessor>::Item: Default,
+{
+    type Item = <&'a V as ArrayAccessor>::Item;
+
+    fn value(&self, logical_index: usize) -> Self::Item {
+        assert!(
+            logical_index < self.len(),
+            "Trying to access an element at index {} from a TypedRunArray of length {}",
+            logical_index,
+            self.len()
+        );
+        unsafe { self.value_unchecked(logical_index) }
+    }
+
+    unsafe fn value_unchecked(&self, logical_index: usize) -> Self::Item {
+        let physical_index = self.run_array.get_physical_index(logical_index);
+        self.values().value_unchecked(physical_index)
+    }
+}
+
+impl<'a, R, V> IntoIterator for TypedRunArray<'a, R, V>
+where
+    R: RunEndIndexType,
+    V: Sync + Send,
+    &'a V: ArrayAccessor,
+    <&'a V as ArrayAccessor>::Item: Default,
+{
+    type Item = Option<<&'a V as ArrayAccessor>::Item>;
+    type IntoIter = RunArrayIter<'a, R, V>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        RunArrayIter::new(self)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use rand::seq::SliceRandom;
+    use rand::thread_rng;
+    use rand::Rng;
+
+    use super::*;
+    use crate::builder::PrimitiveRunBuilder;
+    use crate::cast::AsArray;
+    use crate::types::{Int16Type, Int32Type, Int8Type, UInt32Type};
+    use crate::{Array, Int32Array, StringArray};
+
+    fn build_input_array(size: usize) -> Vec<Option<i32>> {
+        // The input array is created by shuffling and repeating
+        // the seed values random number of times.
+        let mut seed: Vec<Option<i32>> = vec![
+            None,
+            None,
+            None,
+            Some(1),
+            Some(2),
+            Some(3),
+            Some(4),
+            Some(5),
+            Some(6),
+            Some(7),
+            Some(8),
+            Some(9),
+        ];
+        let mut result: Vec<Option<i32>> = Vec::with_capacity(size);
+        let mut ix = 0;
+        let mut rng = thread_rng();
+        // run length can go up to 8. Cap the max run length for smaller arrays to size / 2.
+        let max_run_length = 8_usize.min(1_usize.max(size / 2));
+        while result.len() < size {
+            // shuffle the seed array if all the values are iterated.
+            if ix == 0 {
+                seed.shuffle(&mut rng);
+            }
+            // repeat the items between 1 and 8 times. Cap the length for smaller sized arrays
+            let num = max_run_length.min(rand::thread_rng().gen_range(1..=max_run_length));
+            for _ in 0..num {
+                result.push(seed[ix]);
+            }
+            ix += 1;
+            if ix == seed.len() {
+                ix = 0
+            }
+        }
+        result.resize(size, None);
+        result
+    }
+
+    // Asserts that `logical_array[logical_indices[*]] == physical_array[physical_indices[*]]`
+    fn compare_logical_and_physical_indices(
+        logical_indices: &[u32],
+        logical_array: &[Option<i32>],
+        physical_indices: &[usize],
+        physical_array: &PrimitiveArray<Int32Type>,
+    ) {
+        assert_eq!(logical_indices.len(), physical_indices.len());
+
+        // check value in logical index in the logical_array matches physical index in physical_array
+        logical_indices
+            .iter()
+            .map(|f| f.as_usize())
+            .zip(physical_indices.iter())
+            .for_each(|(logical_ix, physical_ix)| {
+                let expected = logical_array[logical_ix];
+                match expected {
+                    Some(val) => {
+                        assert!(physical_array.is_valid(*physical_ix));
+                        let actual = physical_array.value(*physical_ix);
+                        assert_eq!(val, actual);
+                    }
+                    None => {
+                        assert!(physical_array.is_null(*physical_ix))
+                    }
+                };
+            });
+    }
+    #[test]
+    fn test_run_array() {
+        // Construct a value array
+        let value_data =
+            PrimitiveArray::<Int8Type>::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
+
+        // Construct a run_ends array:
+        let run_ends_values = [4_i16, 6, 7, 9, 13, 18, 20, 22];
+        let run_ends_data =
+            PrimitiveArray::<Int16Type>::from_iter_values(run_ends_values.iter().copied());
+
+        // Construct a run ends encoded array from the above two
+        let ree_array = RunArray::<Int16Type>::try_new(&run_ends_data, &value_data).unwrap();
+
+        assert_eq!(ree_array.len(), 22);
+        assert_eq!(ree_array.null_count(), 0);
+
+        let values = ree_array.values();
+        assert_eq!(value_data.into_data(), values.to_data());
+        assert_eq!(&DataType::Int8, values.data_type());
+
+        let run_ends = ree_array.run_ends();
+        assert_eq!(run_ends.values(), &run_ends_values);
+    }
+
+    #[test]
+    fn test_run_array_fmt_debug() {
+        let mut builder = PrimitiveRunBuilder::<Int16Type, UInt32Type>::with_capacity(3);
+        builder.append_value(12345678);
+        builder.append_null();
+        builder.append_value(22345678);
+        let array = builder.finish();
+        assert_eq!(
+            "RunArray {run_ends: [1, 2, 3], values: PrimitiveArray<UInt32>\n[\n  12345678,\n  null,\n  22345678,\n]}\n",
+            format!("{array:?}")
+        );
+
+        let mut builder = PrimitiveRunBuilder::<Int16Type, UInt32Type>::with_capacity(20);
+        for _ in 0..20 {
+            builder.append_value(1);
+        }
+        let array = builder.finish();
+
+        assert_eq!(array.len(), 20);
+        assert_eq!(array.null_count(), 0);
+
+        assert_eq!(
+            "RunArray {run_ends: [20], values: PrimitiveArray<UInt32>\n[\n  1,\n]}\n",
+            format!("{array:?}")
+        );
+    }
+
+    #[test]
+    fn test_run_array_from_iter() {
+        let test = vec!["a", "a", "b", "c"];
+        let array: RunArray<Int16Type> = test
+            .iter()
+            .map(|&x| if x == "b" { None } else { Some(x) })
+            .collect();
+        assert_eq!(
+            "RunArray {run_ends: [2, 3, 4], values: StringArray\n[\n  \"a\",\n  null,\n  \"c\",\n]}\n",
+            format!("{array:?}")
+        );
+
+        assert_eq!(array.len(), 4);
+        assert_eq!(array.null_count(), 0);
+
+        let array: RunArray<Int16Type> = test.into_iter().collect();
+        assert_eq!(
+            "RunArray {run_ends: [2, 3, 4], values: StringArray\n[\n  \"a\",\n  \"b\",\n  \"c\",\n]}\n",
+            format!("{array:?}")
+        );
+    }
+
+    #[test]
+    fn test_run_array_run_ends_as_primitive_array() {
+        let test = vec!["a", "b", "c", "a"];
+        let array: RunArray<Int16Type> = test.into_iter().collect();
+
+        assert_eq!(array.len(), 4);
+        assert_eq!(array.null_count(), 0);
+
+        let run_ends = array.run_ends();
+        assert_eq!(&[1, 2, 3, 4], run_ends.values());
+    }
+
+    #[test]
+    fn test_run_array_as_primitive_array_with_null() {
+        let test = vec![Some("a"), None, Some("b"), None, None, Some("a")];
+        let array: RunArray<Int32Type> = test.into_iter().collect();
+
+        assert_eq!(array.len(), 6);
+        assert_eq!(array.null_count(), 0);
+
+        let run_ends = array.run_ends();
+        assert_eq!(&[1, 2, 3, 5, 6], run_ends.values());
+
+        let values_data = array.values();
+        assert_eq!(2, values_data.null_count());
+        assert_eq!(5, values_data.len());
+    }
+
+    #[test]
+    fn test_run_array_all_nulls() {
+        let test = vec![None, None, None];
+        let array: RunArray<Int32Type> = test.into_iter().collect();
+
+        assert_eq!(array.len(), 3);
+        assert_eq!(array.null_count(), 0);
+
+        let run_ends = array.run_ends();
+        assert_eq!(3, run_ends.len());
+        assert_eq!(&[3], run_ends.values());
+
+        let values_data = array.values();
+        assert_eq!(1, values_data.null_count());
+    }
+
+    #[test]
+    fn test_run_array_try_new() {
+        let values: StringArray = [Some("foo"), Some("bar"), None, Some("baz")]
+            .into_iter()
+            .collect();
+        let run_ends: Int32Array = [Some(1), Some(2), Some(3), Some(4)].into_iter().collect();
+
+        let array = RunArray::<Int32Type>::try_new(&run_ends, &values).unwrap();
+        assert_eq!(array.values().data_type(), &DataType::Utf8);
+
+        assert_eq!(array.null_count(), 0);
+        assert_eq!(array.len(), 4);
+        assert_eq!(array.values().null_count(), 1);
+
+        assert_eq!(
+            "RunArray {run_ends: [1, 2, 3, 4], values: StringArray\n[\n  \"foo\",\n  \"bar\",\n  null,\n  \"baz\",\n]}\n",
+            format!("{array:?}")
+        );
+    }
+
+    #[test]
+    fn test_run_array_int16_type_definition() {
+        let array: Int16RunArray = vec!["a", "a", "b", "c", "c"].into_iter().collect();
+        let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
+        assert_eq!(array.run_ends().values(), &[2, 3, 5]);
+        assert_eq!(array.values(), &values);
+    }
+
+    #[test]
+    fn test_run_array_empty_string() {
+        let array: Int16RunArray = vec!["a", "a", "", "", "c"].into_iter().collect();
+        let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "", "c"]));
+        assert_eq!(array.run_ends().values(), &[2, 4, 5]);
+        assert_eq!(array.values(), &values);
+    }
+
+    #[test]
+    fn test_run_array_length_mismatch() {
+        let values: StringArray = [Some("foo"), Some("bar"), None, Some("baz")]
+            .into_iter()
+            .collect();
+        let run_ends: Int32Array = [Some(1), Some(2), Some(3)].into_iter().collect();
+
+        let actual = RunArray::<Int32Type>::try_new(&run_ends, &values);
+        let expected = ArrowError::InvalidArgumentError("The run_ends array length should be the same as values array length. Run_ends array length is 3, values array length is 4".to_string());
+        assert_eq!(expected.to_string(), actual.err().unwrap().to_string());
+    }
+
+    #[test]
+    fn test_run_array_run_ends_with_null() {
+        let values: StringArray = [Some("foo"), Some("bar"), Some("baz")]
+            .into_iter()
+            .collect();
+        let run_ends: Int32Array = [Some(1), None, Some(3)].into_iter().collect();
+
+        let actual = RunArray::<Int32Type>::try_new(&run_ends, &values);
+        let expected = ArrowError::InvalidArgumentError(
+            "Found null values in run_ends array. The run_ends array should not have null values."
+                .to_string(),
+        );
+        assert_eq!(expected.to_string(), actual.err().unwrap().to_string());
+    }
+
+    #[test]
+    fn test_run_array_run_ends_with_zeroes() {
+        let values: StringArray = [Some("foo"), Some("bar"), Some("baz")]
+            .into_iter()
+            .collect();
+        let run_ends: Int32Array = [Some(0), Some(1), Some(3)].into_iter().collect();
+
+        let actual = RunArray::<Int32Type>::try_new(&run_ends, &values);
+        let expected = ArrowError::InvalidArgumentError("The values in run_ends array should be strictly positive. Found value 0 at index 0 that does not match the criteria.".to_string());
+        assert_eq!(expected.to_string(), actual.err().unwrap().to_string());
+    }
+
+    #[test]
+    fn test_run_array_run_ends_non_increasing() {
+        let values: StringArray = [Some("foo"), Some("bar"), Some("baz")]
+            .into_iter()
+            .collect();
+        let run_ends: Int32Array = [Some(1), Some(4), Some(4)].into_iter().collect();
+
+        let actual = RunArray::<Int32Type>::try_new(&run_ends, &values);
+        let expected = ArrowError::InvalidArgumentError("The values in run_ends array should be strictly increasing. Found value 4 at index 2 with previous value 4 that does not match the criteria.".to_string());
+        assert_eq!(expected.to_string(), actual.err().unwrap().to_string());
+    }
+
+    #[test]
+    #[should_panic(expected = "Incorrect run ends type")]
+    fn test_run_array_run_ends_data_type_mismatch() {
+        let a = RunArray::<Int32Type>::from_iter(["32"]);
+        let _ = RunArray::<Int64Type>::from(a.into_data());
+    }
+
+    #[test]
+    fn test_ree_array_accessor() {
+        let input_array = build_input_array(256);
+
+        // Encode the input_array to ree_array
+        let mut builder =
+            PrimitiveRunBuilder::<Int16Type, Int32Type>::with_capacity(input_array.len());
+        builder.extend(input_array.iter().copied());
+        let run_array = builder.finish();
+        let typed = run_array.downcast::<PrimitiveArray<Int32Type>>().unwrap();
+
+        // Access every index and check if the value in the input array matches returned value.
+        for (i, inp_val) in input_array.iter().enumerate() {
+            if let Some(val) = inp_val {
+                let actual = typed.value(i);
+                assert_eq!(*val, actual)
+            } else {
+                let physical_ix = run_array.get_physical_index(i);
+                assert!(typed.values().is_null(physical_ix));
+            };
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Takes too long
+    fn test_get_physical_indices() {
+        // Test for logical lengths starting from 10 to 250 increasing by 10
+        for logical_len in (0..250).step_by(10) {
+            let input_array = build_input_array(logical_len);
+
+            // create run array using input_array
+            let mut builder = PrimitiveRunBuilder::<Int32Type, Int32Type>::new();
+            builder.extend(input_array.clone().into_iter());
+
+            let run_array = builder.finish();
+            let physical_values_array = run_array.values().as_primitive::<Int32Type>();
+
+            // create an array consisting of all the indices repeated twice and shuffled.
+            let mut logical_indices: Vec<u32> = (0_u32..(logical_len as u32)).collect();
+            // add same indices once more
+            logical_indices.append(&mut logical_indices.clone());
+            let mut rng = thread_rng();
+            logical_indices.shuffle(&mut rng);
+
+            let physical_indices = run_array.get_physical_indices(&logical_indices).unwrap();
+
+            assert_eq!(logical_indices.len(), physical_indices.len());
+
+            // check value in logical index in the input_array matches physical index in typed_run_array
+            compare_logical_and_physical_indices(
+                &logical_indices,
+                &input_array,
+                &physical_indices,
+                physical_values_array,
+            );
+        }
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Takes too long
+    fn test_get_physical_indices_sliced() {
+        let total_len = 80;
+        let input_array = build_input_array(total_len);
+
+        // Encode the input_array to run array
+        let mut builder =
+            PrimitiveRunBuilder::<Int16Type, Int32Type>::with_capacity(input_array.len());
+        builder.extend(input_array.iter().copied());
+        let run_array = builder.finish();
+        let physical_values_array = run_array.values().as_primitive::<Int32Type>();
+
+        // test for all slice lengths.
+        for slice_len in 1..=total_len {
+            // create an array consisting of all the indices repeated twice and shuffled.
+            let mut logical_indices: Vec<u32> = (0_u32..(slice_len as u32)).collect();
+            // add same indices once more
+            logical_indices.append(&mut logical_indices.clone());
+            let mut rng = thread_rng();
+            logical_indices.shuffle(&mut rng);
+
+            // test for offset = 0 and slice length = slice_len
+            // slice the input array using which the run array was built.
+            let sliced_input_array = &input_array[0..slice_len];
+
+            // slice the run array
+            let sliced_run_array: RunArray<Int16Type> =
+                run_array.slice(0, slice_len).into_data().into();
+
+            // Get physical indices.
+            let physical_indices = sliced_run_array
+                .get_physical_indices(&logical_indices)
+                .unwrap();
+
+            compare_logical_and_physical_indices(
+                &logical_indices,
+                sliced_input_array,
+                &physical_indices,
+                physical_values_array,
+            );
+
+            // test for offset = total_len - slice_len and slice length = slice_len
+            // slice the input array using which the run array was built.
+            let sliced_input_array = &input_array[total_len - slice_len..total_len];
+
+            // slice the run array
+            let sliced_run_array: RunArray<Int16Type> = run_array
+                .slice(total_len - slice_len, slice_len)
+                .into_data()
+                .into();
+
+            // Get physical indices
+            let physical_indices = sliced_run_array
+                .get_physical_indices(&logical_indices)
+                .unwrap();
+
+            compare_logical_and_physical_indices(
+                &logical_indices,
+                sliced_input_array,
+                &physical_indices,
+                physical_values_array,
+            );
+        }
+    }
+
+    #[test]
+    fn test_logical_nulls() {
+        let run = Int32Array::from(vec![3, 6, 9, 12]);
+        let values = Int32Array::from(vec![Some(0), None, Some(1), None]);
+        let array = RunArray::try_new(&run, &values).unwrap();
+
+        let expected = [
+            true, true, true, false, false, false, true, true, true, false, false, false,
+        ];
+
+        let n = array.logical_nulls().unwrap();
+        assert_eq!(n.null_count(), 6);
+
+        let slices = [(0, 12), (0, 2), (2, 5), (3, 0), (3, 3), (3, 4), (4, 8)];
+        for (offset, length) in slices {
+            let a = array.slice(offset, length);
+            let n = a.logical_nulls().unwrap();
+            let n = n.into_iter().collect::<Vec<_>>();
+            assert_eq!(&n, &expected[offset..offset + length], "{offset} {length}");
+        }
+    }
+}
diff --git a/arrow/src/array/array_string.rs b/arrow-array/src/array/string_array.rs
similarity index 55%
rename from arrow/src/array/array_string.rs
rename to arrow-array/src/array/string_array.rs
index b72152cc4acd..9d266e0ca4b8 100644
--- a/arrow/src/array/array_string.rs
+++ b/arrow-array/src/array/string_array.rs
@@ -15,69 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::convert::From;
-use std::fmt;
-use std::{any::Any, iter::FromIterator};
-
-use super::{
-    array::print_long_array, raw_pointer::RawPtrBox, Array, ArrayData,
-    GenericBinaryArray, GenericListArray, GenericStringIter, OffsetSizeTrait,
-};
-use crate::array::array::ArrayAccessor;
-use crate::buffer::Buffer;
-use crate::util::bit_util;
-use crate::{buffer::MutableBuffer, datatypes::DataType};
-
-/// Generic struct for \[Large\]StringArray
-///
-/// See [`StringArray`] and [`LargeStringArray`] for storing
-/// specific string data.
-pub struct GenericStringArray<OffsetSize: OffsetSizeTrait> {
-    data: ArrayData,
-    value_offsets: RawPtrBox<OffsetSize>,
-    value_data: RawPtrBox<u8>,
-}
+use crate::types::GenericStringType;
+use crate::{GenericBinaryArray, GenericByteArray, GenericListArray, OffsetSizeTrait};
+use arrow_schema::{ArrowError, DataType};
 
-impl<OffsetSize: OffsetSizeTrait> GenericStringArray<OffsetSize> {
-    /// Data type of the array.
-    pub const DATA_TYPE: DataType = if OffsetSize::IS_LARGE {
-        DataType::LargeUtf8
-    } else {
-        DataType::Utf8
-    };
+/// A [`GenericByteArray`] for storing `str`
+pub type GenericStringArray<OffsetSize> = GenericByteArray<GenericStringType<OffsetSize>>;
 
+impl<OffsetSize: OffsetSizeTrait> GenericStringArray<OffsetSize> {
     /// Get the data type of the array.
     #[deprecated(note = "please use `Self::DATA_TYPE` instead")]
     pub const fn get_data_type() -> DataType {
         Self::DATA_TYPE
     }
 
-    /// Returns the length for the element at index `i`.
-    #[inline]
-    pub fn value_length(&self, i: usize) -> OffsetSize {
-        let offsets = self.value_offsets();
-        offsets[i + 1] - offsets[i]
-    }
-
-    /// Returns the offset values in the offsets buffer
-    #[inline]
-    pub fn value_offsets(&self) -> &[OffsetSize] {
-        // Soundness
-        //     pointer alignment & location is ensured by RawPtrBox
-        //     buffer bounds/offset is ensured by the ArrayData instance.
-        unsafe {
-            std::slice::from_raw_parts(
-                self.value_offsets.as_ptr().add(self.data.offset()),
-                self.len() + 1,
-            )
-        }
-    }
-
-    /// Returns a clone of the value data buffer
-    pub fn value_data(&self) -> Buffer {
-        self.data.buffers()[1].clone()
-    }
-
     /// Returns the number of `Unicode Scalar Value` in the string at index `i`.
     /// # Performance
     /// This function has `O(n)` time complexity where `n` is the string length.
@@ -87,116 +38,6 @@ impl<OffsetSize: OffsetSizeTrait> GenericStringArray<OffsetSize> {
         self.value(i).chars().count()
     }
 
-    /// Returns the element at index
-    /// # Safety
-    /// caller is responsible for ensuring that index is within the array bounds
-    #[inline]
-    pub unsafe fn value_unchecked(&self, i: usize) -> &str {
-        let end = self.value_offsets().get_unchecked(i + 1);
-        let start = self.value_offsets().get_unchecked(i);
-
-        // Soundness
-        // pointer alignment & location is ensured by RawPtrBox
-        // buffer bounds/offset is ensured by the value_offset invariants
-        // ISSUE: utf-8 well formedness is not checked
-
-        // Safety of `to_isize().unwrap()`
-        // `start` and `end` are &OffsetSize, which is a generic type that implements the
-        // OffsetSizeTrait. Currently, only i32 and i64 implement OffsetSizeTrait,
-        // both of which should cleanly cast to isize on an architecture that supports
-        // 32/64-bit offsets
-        let slice = std::slice::from_raw_parts(
-            self.value_data.as_ptr().offset(start.to_isize().unwrap()),
-            (*end - *start).to_usize().unwrap(),
-        );
-        std::str::from_utf8_unchecked(slice)
-    }
-
-    /// Returns the element at index `i` as &str
-    #[inline]
-    pub fn value(&self, i: usize) -> &str {
-        assert!(i < self.data.len(), "StringArray out of bounds access");
-        // Safety:
-        // `i < self.data.len()
-        unsafe { self.value_unchecked(i) }
-    }
-
-    /// Convert a list array to a string array.
-    /// This method is unsound because it does
-    /// not check the utf-8 validation for each element.
-    fn from_list(v: GenericListArray<OffsetSize>) -> Self {
-        assert_eq!(
-            v.data_ref().child_data().len(),
-            1,
-            "StringArray can only be created from list array of u8 values \
-             (i.e. List<PrimitiveArray<u8>>)."
-        );
-        let child_data = &v.data_ref().child_data()[0];
-
-        assert_eq!(
-            child_data.child_data().len(),
-            0,
-            "StringArray can only be created from list array of u8 values \
-             (i.e. List<PrimitiveArray<u8>>)."
-        );
-        assert_eq!(
-            child_data.data_type(),
-            &DataType::UInt8,
-            "StringArray can only be created from List<u8> arrays, mismatched data types."
-        );
-        assert_eq!(
-            child_data.null_count(),
-            0,
-            "The child array cannot contain null values."
-        );
-
-        let builder = ArrayData::builder(Self::DATA_TYPE)
-            .len(v.len())
-            .offset(v.offset())
-            .add_buffer(v.data().buffers()[0].clone())
-            .add_buffer(child_data.buffers()[0].slice(child_data.offset()))
-            .null_bit_buffer(v.data().null_buffer().cloned());
-
-        let array_data = unsafe { builder.build_unchecked() };
-        Self::from(array_data)
-    }
-
-    /// Creates a [`GenericStringArray`] based on an iterator of values without nulls
-    pub fn from_iter_values<Ptr, I>(iter: I) -> Self
-    where
-        Ptr: AsRef<str>,
-        I: IntoIterator<Item = Ptr>,
-    {
-        let iter = iter.into_iter();
-        let (_, data_len) = iter.size_hint();
-        let data_len = data_len.expect("Iterator must be sized"); // panic if no upper bound.
-
-        let mut offsets =
-            MutableBuffer::new((data_len + 1) * std::mem::size_of::<OffsetSize>());
-        let mut values = MutableBuffer::new(0);
-
-        let mut length_so_far = OffsetSize::zero();
-        offsets.push(length_so_far);
-
-        for i in iter {
-            let s = i.as_ref();
-            length_so_far += OffsetSize::from_usize(s.len()).unwrap();
-            offsets.push(length_so_far);
-            values.extend_from_slice(s.as_bytes());
-        }
-
-        // iterator size hint may not be correct so compute the actual number of offsets
-        assert!(!offsets.is_empty()); // wrote at least one
-        let actual_len = (offsets.len() / std::mem::size_of::<OffsetSize>()) - 1;
-
-        let array_data = ArrayData::builder(Self::DATA_TYPE)
-            .len(actual_len)
-            .add_buffer(offsets.into())
-            .add_buffer(values.into());
-        let array_data = unsafe { array_data.build_unchecked() };
-        Self::from(array_data)
-    }
-
     /// Returns an iterator that returns the values of `array.value(i)` for an iterator with each element `i`
     pub fn take_iter<'a>(
         &'a self,
@@ -215,120 +56,12 @@ impl<OffsetSize: OffsetSizeTrait> GenericStringArray<OffsetSize> {
     ) -> impl Iterator<Item = Option<&str>> + 'a {
         indexes.map(|opt_index| opt_index.map(|index| self.value_unchecked(index)))
     }
-}
-
-impl<'a, Ptr, OffsetSize: OffsetSizeTrait> FromIterator<&'a Option<Ptr>>
-    for GenericStringArray<OffsetSize>
-where
-    Ptr: AsRef<str> + 'a,
-{
-    /// Creates a [`GenericStringArray`] based on an iterator of `Option` references.
-    fn from_iter<I: IntoIterator<Item = &'a Option<Ptr>>>(iter: I) -> Self {
-        // Convert each owned Ptr into &str and wrap in an owned `Option`
-        let iter = iter.into_iter().map(|o| o.as_ref().map(|p| p.as_ref()));
-        // Build a `GenericStringArray` with the resulting iterator
-        iter.collect::<GenericStringArray<OffsetSize>>()
-    }
-}
-
-impl<Ptr, OffsetSize: OffsetSizeTrait> FromIterator<Option<Ptr>>
-    for GenericStringArray<OffsetSize>
-where
-    Ptr: AsRef<str>,
-{
-    /// Creates a [`GenericStringArray`] based on an iterator of [`Option`]s
-    fn from_iter<I: IntoIterator<Item = Option<Ptr>>>(iter: I) -> Self {
-        let iter = iter.into_iter();
-        let (_, data_len) = iter.size_hint();
-        let data_len = data_len.expect("Iterator must be sized"); // panic if no upper bound.
-
-        let offset_size = std::mem::size_of::<OffsetSize>();
-        let mut offsets = MutableBuffer::new((data_len + 1) * offset_size);
-        let mut values = MutableBuffer::new(0);
-        let mut null_buf = MutableBuffer::new_null(data_len);
-        let null_slice = null_buf.as_slice_mut();
-        let mut length_so_far = OffsetSize::zero();
-        offsets.push(length_so_far);
-
-        for (i, s) in iter.enumerate() {
-            let value_bytes = if let Some(ref s) = s {
-                // set null bit
-                bit_util::set_bit(null_slice, i);
-                let s_bytes = s.as_ref().as_bytes();
-                length_so_far += OffsetSize::from_usize(s_bytes.len()).unwrap();
-                s_bytes
-            } else {
-                b""
-            };
-            values.extend_from_slice(value_bytes);
-            offsets.push(length_so_far);
-        }
-
-        // calculate actual data_len, which may be different from the iterator's upper bound
-        let data_len = (offsets.len() / offset_size) - 1;
-        let array_data = ArrayData::builder(Self::DATA_TYPE)
-            .len(data_len)
-            .add_buffer(offsets.into())
-            .add_buffer(values.into())
-            .null_bit_buffer(Some(null_buf.into()));
-        let array_data = unsafe { array_data.build_unchecked() };
-        Self::from(array_data)
-    }
-}
-
-impl<'a, T: OffsetSizeTrait> IntoIterator for &'a GenericStringArray<T> {
-    type Item = Option<&'a str>;
-    type IntoIter = GenericStringIter<'a, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        GenericStringIter::<'a, T>::new(self)
-    }
-}
 
-impl<'a, T: OffsetSizeTrait> GenericStringArray<T> {
-    /// constructs a new iterator
-    pub fn iter(&'a self) -> GenericStringIter<'a, T> {
-        GenericStringIter::<'a, T>::new(self)
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> fmt::Debug for GenericStringArray<OffsetSize> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let prefix = OffsetSize::PREFIX;
-
-        write!(f, "{}StringArray\n[\n", prefix)?;
-        print_long_array(self, f, |array, index, f| {
-            fmt::Debug::fmt(&array.value(index), f)
-        })?;
-        write!(f, "]")
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> Array for GenericStringArray<OffsetSize> {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.into()
-    }
-}
-
-impl<'a, OffsetSize: OffsetSizeTrait> ArrayAccessor
-    for &'a GenericStringArray<OffsetSize>
-{
-    type Item = &'a str;
-
-    fn value(&self, index: usize) -> Self::Item {
-        GenericStringArray::value(self, index)
-    }
-
-    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
-        GenericStringArray::value_unchecked(self, index)
+    /// Fallibly creates a [`GenericStringArray`] from a [`GenericBinaryArray`] returning
+    /// an error if [`GenericBinaryArray`] contains invalid UTF-8 data
+    pub fn try_from_binary(v: GenericBinaryArray<OffsetSize>) -> Result<Self, ArrowError> {
+        let (offsets, values, nulls) = v.into_parts();
+        Self::try_new(offsets, values, nulls)
     }
 }
 
@@ -336,7 +69,7 @@ impl<OffsetSize: OffsetSizeTrait> From<GenericListArray<OffsetSize>>
     for GenericStringArray<OffsetSize>
 {
     fn from(v: GenericListArray<OffsetSize>) -> Self {
-        GenericStringArray::<OffsetSize>::from_list(v)
+        GenericBinaryArray::<OffsetSize>::from(v).into()
     }
 }
 
@@ -344,37 +77,11 @@ impl<OffsetSize: OffsetSizeTrait> From<GenericBinaryArray<OffsetSize>>
     for GenericStringArray<OffsetSize>
 {
     fn from(v: GenericBinaryArray<OffsetSize>) -> Self {
-        let builder = v.into_data().into_builder().data_type(Self::DATA_TYPE);
-        let data = unsafe { builder.build_unchecked() };
-        Self::from(data)
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> From<ArrayData> for GenericStringArray<OffsetSize> {
-    fn from(data: ArrayData) -> Self {
-        assert_eq!(
-            data.data_type(),
-            &Self::DATA_TYPE,
-            "[Large]StringArray expects Datatype::[Large]Utf8"
-        );
-        assert_eq!(
-            data.buffers().len(),
-            2,
-            "StringArray data should contain 2 buffers only (offsets and values)"
-        );
-        let offsets = data.buffers()[0].as_ptr();
-        let values = data.buffers()[1].as_ptr();
-        Self {
-            data,
-            value_offsets: unsafe { RawPtrBox::new(offsets) },
-            value_data: unsafe { RawPtrBox::new(values) },
-        }
+        Self::try_from_binary(v).unwrap()
     }
 }
 
-impl<OffsetSize: OffsetSizeTrait> From<Vec<Option<&str>>>
-    for GenericStringArray<OffsetSize>
-{
+impl<OffsetSize: OffsetSizeTrait> From<Vec<Option<&str>>> for GenericStringArray<OffsetSize> {
     fn from(v: Vec<Option<&str>>) -> Self {
         v.into_iter().collect()
     }
@@ -386,51 +93,82 @@ impl<OffsetSize: OffsetSizeTrait> From<Vec<&str>> for GenericStringArray<OffsetS
     }
 }
 
-impl<OffsetSize: OffsetSizeTrait> From<Vec<String>> for GenericStringArray<OffsetSize> {
-    fn from(v: Vec<String>) -> Self {
-        Self::from_iter_values(v)
+impl<OffsetSize: OffsetSizeTrait> From<Vec<Option<String>>> for GenericStringArray<OffsetSize> {
+    fn from(v: Vec<Option<String>>) -> Self {
+        v.into_iter().collect()
     }
 }
 
-impl<OffsetSize: OffsetSizeTrait> From<GenericStringArray<OffsetSize>> for ArrayData {
-    fn from(array: GenericStringArray<OffsetSize>) -> Self {
-        array.data
+impl<OffsetSize: OffsetSizeTrait> From<Vec<String>> for GenericStringArray<OffsetSize> {
+    fn from(v: Vec<String>) -> Self {
+        Self::from_iter_values(v)
     }
 }
 
-/// An array where each element is a variable-sized sequence of bytes representing a string
-/// whose maximum length (in bytes) is represented by a i32.
+/// A [`GenericStringArray`] of `str` using `i32` offsets
 ///
-/// Example
+/// # Examples
 ///
+/// Construction
+///
+/// ```
+/// # use arrow_array::StringArray;
+/// // Create from Vec<Option<&str>>
+/// let arr = StringArray::from(vec![Some("foo"), Some("bar"), None, Some("baz")]);
+/// // Create from Vec<&str>
+/// let arr = StringArray::from(vec!["foo", "bar", "baz"]);
+/// // Create from iter/collect (requires Option<&str>)
+/// let arr: StringArray = std::iter::repeat(Some("foo")).take(10).collect();
 /// ```
-/// use arrow::array::StringArray;
+///
+/// Construction and Access
+///
+/// ```
+/// # use arrow_array::StringArray;
 /// let array = StringArray::from(vec![Some("foo"), None, Some("bar")]);
 /// assert_eq!(array.value(0), "foo");
 /// ```
+///
+/// See [`GenericByteArray`] for more information and examples
 pub type StringArray = GenericStringArray<i32>;
 
-/// An array where each element is a variable-sized sequence of bytes representing a string
-/// whose maximum length (in bytes) is represented by a i64.
+/// A [`GenericStringArray`] of `str` using `i64` offsets
+///
+/// # Examples
+///
+/// Construction
+///
+/// ```
+/// # use arrow_array::LargeStringArray;
+/// // Create from Vec<Option<&str>>
+/// let arr = LargeStringArray::from(vec![Some("foo"), Some("bar"), None, Some("baz")]);
+/// // Create from Vec<&str>
+/// let arr = LargeStringArray::from(vec!["foo", "bar", "baz"]);
+/// // Create from iter/collect (requires Option<&str>)
+/// let arr: LargeStringArray = std::iter::repeat(Some("foo")).take(10).collect();
+/// ```
 ///
-/// Example
+/// Construction and Access
 ///
 /// ```
-/// use arrow::array::LargeStringArray;
+/// use arrow_array::LargeStringArray;
 /// let array = LargeStringArray::from(vec![Some("foo"), None, Some("bar")]);
 /// assert_eq!(array.value(2), "bar");
 /// ```
+///
+/// See [`GenericByteArray`] for more information and examples
 pub type LargeStringArray = GenericStringArray<i64>;
 
 #[cfg(test)]
 mod tests {
-
-    use crate::{
-        array::{ListBuilder, StringBuilder},
-        datatypes::Field,
-    };
-
     use super::*;
+    use crate::builder::{ListBuilder, PrimitiveBuilder, StringBuilder};
+    use crate::types::UInt8Type;
+    use crate::Array;
+    use arrow_buffer::Buffer;
+    use arrow_data::ArrayData;
+    use arrow_schema::Field;
+    use std::sync::Arc;
 
     #[test]
     fn test_string_array_from_u8_slice() {
@@ -458,7 +196,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "[Large]StringArray expects Datatype::[Large]Utf8")]
+    #[should_panic(expected = "StringArray expects DataType::Utf8")]
     fn test_string_array_from_int() {
         let array = LargeStringArray::from(vec!["a", "b"]);
         drop(StringArray::from(array.into_data()));
@@ -492,7 +230,7 @@ mod tests {
 
     #[test]
     fn test_nested_string_array() {
-        let string_builder = StringBuilder::new(3);
+        let string_builder = StringBuilder::with_capacity(3, 10);
         let mut list_of_string_builder = ListBuilder::new(string_builder);
 
         list_of_string_builder.values().append_value("foo");
@@ -521,7 +259,9 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "StringArray out of bounds access")]
+    #[should_panic(
+        expected = "Trying to access an element at index 4 from a StringArray of length 3"
+    )]
     fn test_string_array_get_value_index_out_of_bound() {
         let values: [u8; 12] = [
             b'h', b'e', b'l', b'l', b'o', b'p', b'a', b'r', b'q', b'u', b'e', b't',
@@ -529,8 +269,8 @@ mod tests {
         let offsets: [i32; 4] = [0, 5, 5, 12];
         let array_data = ArrayData::builder(DataType::Utf8)
             .len(3)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
-            .add_buffer(Buffer::from_slice_ref(&values))
+            .add_buffer(Buffer::from_slice_ref(offsets))
+            .add_buffer(Buffer::from_slice_ref(values))
             .build()
             .unwrap();
         let string_array = StringArray::from(array_data);
@@ -542,7 +282,7 @@ mod tests {
         let arr: StringArray = vec!["hello", "arrow"].into();
         assert_eq!(
             "StringArray\n[\n  \"hello\",\n  \"arrow\",\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -551,7 +291,7 @@ mod tests {
         let arr: LargeStringArray = vec!["hello", "arrow"].into();
         assert_eq!(
             "LargeStringArray\n[\n  \"hello\",\n  \"arrow\",\n]",
-            format!("{:?}", arr)
+            format!("{arr:?}")
         );
     }
 
@@ -578,11 +318,18 @@ mod tests {
 
     #[test]
     fn test_string_array_from_iter_values() {
-        let data = vec!["hello", "hello2"];
+        let data = ["hello", "hello2"];
         let array1 = StringArray::from_iter_values(data.iter());
 
         assert_eq!(array1.value(0), "hello");
         assert_eq!(array1.value(1), "hello2");
+
+        // Also works with String types.
+        let data2 = ["goodbye".to_string(), "goodbye2".to_string()];
+        let array2 = StringArray::from_iter_values(data2.iter());
+
+        assert_eq!(array2.value(0), "goodbye");
+        assert_eq!(array2.value(1), "goodbye2");
     }
 
     #[test]
@@ -592,7 +339,7 @@ mod tests {
             .scan(0usize, |pos, i| {
                 if *pos < 10 {
                     *pos += 1;
-                    Some(Some(format!("value {}", i)))
+                    Some(Some(format!("value {i}")))
                 } else {
                     // actually returns up to 10 values
                     None
@@ -611,20 +358,20 @@ mod tests {
 
     #[test]
     fn test_string_array_all_null() {
-        let data = vec![None];
+        let data: Vec<Option<&str>> = vec![None];
         let array = StringArray::from(data);
         array
-            .data()
+            .into_data()
             .validate_full()
             .expect("All null array has valid array data");
     }
 
     #[test]
     fn test_large_string_array_all_null() {
-        let data = vec![None];
+        let data: Vec<Option<&str>> = vec![None];
         let array = LargeStringArray::from(data);
         array
-            .data()
+            .into_data()
             .validate_full()
             .expect("All null array has valid array data");
     }
@@ -685,13 +432,11 @@ mod tests {
         let expected: LargeStringArray = data.clone().into_iter().map(Some).collect();
 
         // Iterator reports too many items
-        let arr =
-            LargeStringArray::from_iter_values(BadIterator::new(3, 10, data.clone()));
+        let arr = LargeStringArray::from_iter_values(BadIterator::new(3, 10, data.clone()));
         assert_eq!(expected, arr);
 
         // Iterator reports too few items
-        let arr =
-            LargeStringArray::from_iter_values(BadIterator::new(3, 1, data.clone()));
+        let arr = LargeStringArray::from_iter_values(BadIterator::new(3, 1, data.clone()));
         assert_eq!(expected, arr);
     }
 
@@ -706,16 +451,18 @@ mod tests {
             .unwrap();
 
         let offsets = [0, 5, 8, 15].map(|n| O::from_usize(n).unwrap());
-        let null_buffer = Buffer::from_slice_ref(&[0b101]);
-        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Box::new(
-            Field::new("item", DataType::UInt8, false),
-        ));
+        let null_buffer = Buffer::from_slice_ref([0b101]);
+        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Arc::new(Field::new(
+            "item",
+            DataType::UInt8,
+            false,
+        )));
 
         // [None, Some("Parquet")]
         let array_data = ArrayData::builder(data_type)
             .len(2)
             .offset(1)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
+            .add_buffer(Buffer::from_slice_ref(offsets))
             .null_bit_buffer(Some(null_buffer))
             .add_child_data(child_data)
             .build()
@@ -740,26 +487,29 @@ mod tests {
         _test_generic_string_array_from_list_array::<i64>();
     }
 
-    fn _test_generic_string_array_from_list_array_with_child_nulls_failed<
-        O: OffsetSizeTrait,
-    >() {
+    fn _test_generic_string_array_from_list_array_with_child_nulls_failed<O: OffsetSizeTrait>() {
         let values = b"HelloArrow";
         let child_data = ArrayData::builder(DataType::UInt8)
             .len(10)
             .add_buffer(Buffer::from(&values[..]))
-            .null_bit_buffer(Some(Buffer::from_slice_ref(&[0b1010101010])))
+            .null_bit_buffer(Some(Buffer::from_slice_ref([0b1010101010])))
             .build()
             .unwrap();
 
         let offsets = [0, 5, 10].map(|n| O::from_usize(n).unwrap());
-        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Box::new(
-            Field::new("item", DataType::UInt8, false),
-        ));
+
+        // It is possible to create a null struct containing a non-nullable child
+        // see https://github.com/apache/arrow-rs/pull/3244 for details
+        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Arc::new(Field::new(
+            "item",
+            DataType::UInt8,
+            true,
+        )));
 
         // [None, Some(b"Parquet")]
         let array_data = ArrayData::builder(data_type)
             .len(2)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
+            .add_buffer(Buffer::from_slice_ref(offsets))
             .add_child_data(child_data)
             .build()
             .unwrap();
@@ -769,7 +519,7 @@ mod tests {
 
     #[test]
     #[should_panic(expected = "The child array cannot contain null values.")]
-    fn test_stirng_array_from_list_array_with_child_nulls_failed() {
+    fn test_string_array_from_list_array_with_child_nulls_failed() {
         _test_generic_string_array_from_list_array_with_child_nulls_failed::<i32>();
     }
 
@@ -788,13 +538,15 @@ mod tests {
             .unwrap();
 
         let offsets = [0, 2, 3].map(|n| O::from_usize(n).unwrap());
-        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Box::new(
-            Field::new("item", DataType::UInt16, false),
-        ));
+        let data_type = GenericListArray::<O>::DATA_TYPE_CONSTRUCTOR(Arc::new(Field::new(
+            "item",
+            DataType::UInt16,
+            false,
+        )));
 
         let array_data = ArrayData::builder(data_type)
             .len(2)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
+            .add_buffer(Buffer::from_slice_ref(offsets))
             .add_child_data(child_data)
             .build()
             .unwrap();
@@ -804,7 +556,7 @@ mod tests {
 
     #[test]
     #[should_panic(
-        expected = "StringArray can only be created from List<u8> arrays, mismatched data types."
+        expected = "BinaryArray can only be created from List<u8> arrays, mismatched data types."
     )]
     fn test_string_array_from_list_array_wrong_type() {
         _test_generic_string_array_from_list_array_wrong_type::<i32>();
@@ -812,9 +564,67 @@ mod tests {
 
     #[test]
     #[should_panic(
-        expected = "StringArray can only be created from List<u8> arrays, mismatched data types."
+        expected = "BinaryArray can only be created from List<u8> arrays, mismatched data types."
     )]
     fn test_large_string_array_from_list_array_wrong_type() {
-        _test_generic_string_array_from_list_array_wrong_type::<i32>();
+        _test_generic_string_array_from_list_array_wrong_type::<i64>();
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Encountered non UTF-8 data: invalid utf-8 sequence of 1 bytes from index 0"
+    )]
+    fn test_list_array_utf8_validation() {
+        let mut builder = ListBuilder::new(PrimitiveBuilder::<UInt8Type>::new());
+        builder.values().append_value(0xFF);
+        builder.append(true);
+        let list = builder.finish();
+        let _ = StringArray::from(list);
+    }
+
+    #[test]
+    fn test_empty_offsets() {
+        let string = StringArray::from(
+            ArrayData::builder(DataType::Utf8)
+                .buffers(vec![Buffer::from(&[]), Buffer::from(&[])])
+                .build()
+                .unwrap(),
+        );
+        assert_eq!(string.len(), 0);
+        assert_eq!(string.value_offsets(), &[0]);
+
+        let string = LargeStringArray::from(
+            ArrayData::builder(DataType::LargeUtf8)
+                .buffers(vec![Buffer::from(&[]), Buffer::from(&[])])
+                .build()
+                .unwrap(),
+        );
+        assert_eq!(string.len(), 0);
+        assert_eq!(string.value_offsets(), &[0]);
+    }
+
+    #[test]
+    fn test_into_builder() {
+        let array: StringArray = vec!["hello", "arrow"].into();
+
+        // Append values
+        let mut builder = array.into_builder().unwrap();
+
+        builder.append_value("rust");
+
+        let expected: StringArray = vec!["hello", "arrow", "rust"].into();
+        let array = builder.finish();
+        assert_eq!(expected, array);
+    }
+
+    #[test]
+    fn test_into_builder_err() {
+        let array: StringArray = vec!["hello", "arrow"].into();
+
+        // Clone it, so we cannot get a mutable builder back
+        let shared_array = array.clone();
+
+        let err_return = array.into_builder().unwrap_err();
+        assert_eq!(&err_return, &shared_array);
     }
 }
diff --git a/arrow-array/src/array/struct_array.rs b/arrow-array/src/array/struct_array.rs
new file mode 100644
index 000000000000..699da28cf7a3
--- /dev/null
+++ b/arrow-array/src/array/struct_array.rs
@@ -0,0 +1,735 @@
+// 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.
+
+use crate::{make_array, new_null_array, Array, ArrayRef, RecordBatch};
+use arrow_buffer::{BooleanBuffer, Buffer, NullBuffer};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType, Field, FieldRef, Fields, SchemaBuilder};
+use std::sync::Arc;
+use std::{any::Any, ops::Index};
+
+/// An array of [structs](https://arrow.apache.org/docs/format/Columnar.html#struct-layout)
+///
+/// Each child (called *field*) is represented by a separate array.
+///
+/// # Comparison with [RecordBatch]
+///
+/// Both [`RecordBatch`] and [`StructArray`] represent a collection of columns / arrays with the
+/// same length.
+///
+/// However, there are a couple of key differences:
+///
+/// * [`StructArray`] can be nested within other [`Array`], including itself
+/// * [`RecordBatch`] can contain top-level metadata on its associated [`Schema`][arrow_schema::Schema]
+/// * [`StructArray`] can contain top-level nulls, i.e. `null`
+/// * [`RecordBatch`] can only represent nulls in its child columns, i.e. `{"field": null}`
+///
+/// [`StructArray`] is therefore a more general data container than [`RecordBatch`], and as such
+/// code that needs to handle both will typically share an implementation in terms of
+/// [`StructArray`] and convert to/from [`RecordBatch`] as necessary.
+///
+/// [`From`] implementations are provided to facilitate this conversion, however, converting
+/// from a [`StructArray`] containing top-level nulls to a [`RecordBatch`] will panic, as there
+/// is no way to preserve them.
+///
+/// # Example: Create an array from a vector of fields
+///
+/// ```
+/// use std::sync::Arc;
+/// use arrow_array::{Array, ArrayRef, BooleanArray, Int32Array, StructArray};
+/// use arrow_schema::{DataType, Field};
+///
+/// let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
+/// let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
+///
+/// let struct_array = StructArray::from(vec![
+///     (
+///         Arc::new(Field::new("b", DataType::Boolean, false)),
+///         boolean.clone() as ArrayRef,
+///     ),
+///     (
+///         Arc::new(Field::new("c", DataType::Int32, false)),
+///         int.clone() as ArrayRef,
+///     ),
+/// ]);
+/// assert_eq!(struct_array.column(0).as_ref(), boolean.as_ref());
+/// assert_eq!(struct_array.column(1).as_ref(), int.as_ref());
+/// assert_eq!(4, struct_array.len());
+/// assert_eq!(0, struct_array.null_count());
+/// assert_eq!(0, struct_array.offset());
+/// ```
+#[derive(Clone)]
+pub struct StructArray {
+    len: usize,
+    data_type: DataType,
+    nulls: Option<NullBuffer>,
+    fields: Vec<ArrayRef>,
+}
+
+impl StructArray {
+    /// Create a new [`StructArray`] from the provided parts, panicking on failure
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`Self::try_new`] returns an error
+    pub fn new(fields: Fields, arrays: Vec<ArrayRef>, nulls: Option<NullBuffer>) -> Self {
+        Self::try_new(fields, arrays, nulls).unwrap()
+    }
+
+    /// Create a new [`StructArray`] from the provided parts, returning an error on failure
+    ///
+    /// # Errors
+    ///
+    /// Errors if
+    ///
+    /// * `fields.len() != arrays.len()`
+    /// * `fields[i].data_type() != arrays[i].data_type()`
+    /// * `arrays[i].len() != arrays[j].len()`
+    /// * `arrays[i].len() != nulls.len()`
+    /// * `!fields[i].is_nullable() && !nulls.contains(arrays[i].nulls())`
+    pub fn try_new(
+        fields: Fields,
+        arrays: Vec<ArrayRef>,
+        nulls: Option<NullBuffer>,
+    ) -> Result<Self, ArrowError> {
+        if fields.len() != arrays.len() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Incorrect number of arrays for StructArray fields, expected {} got {}",
+                fields.len(),
+                arrays.len()
+            )));
+        }
+        let len = arrays.first().map(|x| x.len()).unwrap_or_default();
+
+        if let Some(n) = nulls.as_ref() {
+            if n.len() != len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Incorrect number of nulls for StructArray, expected {len} got {}",
+                    n.len(),
+                )));
+            }
+        }
+
+        for (f, a) in fields.iter().zip(&arrays) {
+            if f.data_type() != a.data_type() {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Incorrect datatype for StructArray field {:?}, expected {} got {}",
+                    f.name(),
+                    f.data_type(),
+                    a.data_type()
+                )));
+            }
+
+            if a.len() != len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Incorrect array length for StructArray field {:?}, expected {} got {}",
+                    f.name(),
+                    len,
+                    a.len()
+                )));
+            }
+
+            if !f.is_nullable() {
+                if let Some(a) = a.logical_nulls() {
+                    if !nulls.as_ref().map(|n| n.contains(&a)).unwrap_or_default() {
+                        return Err(ArrowError::InvalidArgumentError(format!(
+                            "Found unmasked nulls for non-nullable StructArray field {:?}",
+                            f.name()
+                        )));
+                    }
+                }
+            }
+        }
+
+        Ok(Self {
+            len,
+            data_type: DataType::Struct(fields),
+            nulls: nulls.filter(|n| n.null_count() > 0),
+            fields: arrays,
+        })
+    }
+
+    /// Create a new [`StructArray`] of length `len` where all values are null
+    pub fn new_null(fields: Fields, len: usize) -> Self {
+        let arrays = fields
+            .iter()
+            .map(|f| new_null_array(f.data_type(), len))
+            .collect();
+
+        Self {
+            len,
+            data_type: DataType::Struct(fields),
+            nulls: Some(NullBuffer::new_null(len)),
+            fields: arrays,
+        }
+    }
+
+    /// Create a new [`StructArray`] from the provided parts without validation
+    ///
+    /// # Safety
+    ///
+    /// Safe if [`Self::new`] would not panic with the given arguments
+    pub unsafe fn new_unchecked(
+        fields: Fields,
+        arrays: Vec<ArrayRef>,
+        nulls: Option<NullBuffer>,
+    ) -> Self {
+        let len = arrays.first().map(|x| x.len()).unwrap_or_default();
+        Self {
+            len,
+            data_type: DataType::Struct(fields),
+            nulls,
+            fields: arrays,
+        }
+    }
+
+    /// Create a new [`StructArray`] containing no fields
+    ///
+    /// # Panics
+    ///
+    /// If `len != nulls.len()`
+    pub fn new_empty_fields(len: usize, nulls: Option<NullBuffer>) -> Self {
+        if let Some(n) = &nulls {
+            assert_eq!(len, n.len())
+        }
+        Self {
+            len,
+            data_type: DataType::Struct(Fields::empty()),
+            fields: vec![],
+            nulls,
+        }
+    }
+
+    /// Deconstruct this array into its constituent parts
+    pub fn into_parts(self) -> (Fields, Vec<ArrayRef>, Option<NullBuffer>) {
+        let f = match self.data_type {
+            DataType::Struct(f) => f,
+            _ => unreachable!(),
+        };
+        (f, self.fields, self.nulls)
+    }
+
+    /// Returns the field at `pos`.
+    pub fn column(&self, pos: usize) -> &ArrayRef {
+        &self.fields[pos]
+    }
+
+    /// Return the number of fields in this struct array
+    pub fn num_columns(&self) -> usize {
+        self.fields.len()
+    }
+
+    /// Returns the fields of the struct array
+    pub fn columns(&self) -> &[ArrayRef] {
+        &self.fields
+    }
+
+    /// Returns child array refs of the struct array
+    #[deprecated(note = "Use columns().to_vec()")]
+    pub fn columns_ref(&self) -> Vec<ArrayRef> {
+        self.columns().to_vec()
+    }
+
+    /// Return field names in this struct array
+    pub fn column_names(&self) -> Vec<&str> {
+        match self.data_type() {
+            DataType::Struct(fields) => fields
+                .iter()
+                .map(|f| f.name().as_str())
+                .collect::<Vec<&str>>(),
+            _ => unreachable!("Struct array's data type is not struct!"),
+        }
+    }
+
+    /// Returns the [`Fields`] of this [`StructArray`]
+    pub fn fields(&self) -> &Fields {
+        match self.data_type() {
+            DataType::Struct(f) => f,
+            _ => unreachable!(),
+        }
+    }
+
+    /// Return child array whose field name equals to column_name
+    ///
+    /// Note: A schema can currently have duplicate field names, in which case
+    /// the first field will always be selected.
+    /// This issue will be addressed in [ARROW-11178](https://issues.apache.org/jira/browse/ARROW-11178)
+    pub fn column_by_name(&self, column_name: &str) -> Option<&ArrayRef> {
+        self.column_names()
+            .iter()
+            .position(|c| c == &column_name)
+            .map(|pos| self.column(pos))
+    }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, len: usize) -> Self {
+        assert!(
+            offset.saturating_add(len) <= self.len,
+            "the length + offset of the sliced StructArray cannot exceed the existing length"
+        );
+
+        let fields = self.fields.iter().map(|a| a.slice(offset, len)).collect();
+
+        Self {
+            len,
+            data_type: self.data_type.clone(),
+            nulls: self.nulls.as_ref().map(|n| n.slice(offset, len)),
+            fields,
+        }
+    }
+}
+
+impl From<ArrayData> for StructArray {
+    fn from(data: ArrayData) -> Self {
+        let fields = data
+            .child_data()
+            .iter()
+            .map(|cd| make_array(cd.clone()))
+            .collect();
+
+        Self {
+            len: data.len(),
+            data_type: data.data_type().clone(),
+            nulls: data.nulls().cloned(),
+            fields,
+        }
+    }
+}
+
+impl From<StructArray> for ArrayData {
+    fn from(array: StructArray) -> Self {
+        let builder = ArrayDataBuilder::new(array.data_type)
+            .len(array.len)
+            .nulls(array.nulls)
+            .child_data(array.fields.iter().map(|x| x.to_data()).collect());
+
+        unsafe { builder.build_unchecked() }
+    }
+}
+
+impl TryFrom<Vec<(&str, ArrayRef)>> for StructArray {
+    type Error = ArrowError;
+
+    /// builds a StructArray from a vector of names and arrays.
+    fn try_from(values: Vec<(&str, ArrayRef)>) -> Result<Self, ArrowError> {
+        let (schema, arrays): (SchemaBuilder, _) = values
+            .into_iter()
+            .map(|(name, array)| {
+                (
+                    Field::new(name, array.data_type().clone(), array.is_nullable()),
+                    array,
+                )
+            })
+            .unzip();
+
+        StructArray::try_new(schema.finish().fields, arrays, None)
+    }
+}
+
+impl Array for StructArray {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
+    }
+
+    fn into_data(self) -> ArrayData {
+        self.into()
+    }
+
+    fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.len
+    }
+
+    fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    fn offset(&self) -> usize {
+        0
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        self.nulls.as_ref()
+    }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        let mut size = self.fields.iter().map(|a| a.get_buffer_memory_size()).sum();
+        if let Some(n) = self.nulls.as_ref() {
+            size += n.buffer().capacity();
+        }
+        size
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        let mut size = self.fields.iter().map(|a| a.get_array_memory_size()).sum();
+        size += std::mem::size_of::<Self>();
+        if let Some(n) = self.nulls.as_ref() {
+            size += n.buffer().capacity();
+        }
+        size
+    }
+}
+
+impl From<Vec<(FieldRef, ArrayRef)>> for StructArray {
+    fn from(v: Vec<(FieldRef, ArrayRef)>) -> Self {
+        let (schema, arrays): (SchemaBuilder, _) = v.into_iter().unzip();
+        StructArray::new(schema.finish().fields, arrays, None)
+    }
+}
+
+impl std::fmt::Debug for StructArray {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "StructArray\n[\n")?;
+        for (child_index, name) in self.column_names().iter().enumerate() {
+            let column = self.column(child_index);
+            writeln!(
+                f,
+                "-- child {}: \"{}\" ({:?})",
+                child_index,
+                name,
+                column.data_type()
+            )?;
+            std::fmt::Debug::fmt(column, f)?;
+            writeln!(f)?;
+        }
+        write!(f, "]")
+    }
+}
+
+impl From<(Vec<(FieldRef, ArrayRef)>, Buffer)> for StructArray {
+    fn from(pair: (Vec<(FieldRef, ArrayRef)>, Buffer)) -> Self {
+        let len = pair.0.first().map(|x| x.1.len()).unwrap_or_default();
+        let (fields, arrays): (SchemaBuilder, Vec<_>) = pair.0.into_iter().unzip();
+        let nulls = NullBuffer::new(BooleanBuffer::new(pair.1, 0, len));
+        Self::new(fields.finish().fields, arrays, Some(nulls))
+    }
+}
+
+impl From<RecordBatch> for StructArray {
+    fn from(value: RecordBatch) -> Self {
+        Self {
+            len: value.num_rows(),
+            data_type: DataType::Struct(value.schema().fields().clone()),
+            nulls: None,
+            fields: value.columns().to_vec(),
+        }
+    }
+}
+
+impl Index<&str> for StructArray {
+    type Output = ArrayRef;
+
+    /// Get a reference to a column's array by name.
+    ///
+    /// Note: A schema can currently have duplicate field names, in which case
+    /// the first field will always be selected.
+    /// This issue will be addressed in [ARROW-11178](https://issues.apache.org/jira/browse/ARROW-11178)
+    ///
+    /// # Panics
+    ///
+    /// Panics if the name is not in the schema.
+    fn index(&self, name: &str) -> &Self::Output {
+        self.column_by_name(name).unwrap()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::{BooleanArray, Float32Array, Float64Array, Int32Array, Int64Array, StringArray};
+    use arrow_buffer::ToByteSlice;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_struct_array_builder() {
+        let boolean_array = BooleanArray::from(vec![false, false, true, true]);
+        let int_array = Int64Array::from(vec![42, 28, 19, 31]);
+
+        let fields = vec![
+            Field::new("a", DataType::Boolean, false),
+            Field::new("b", DataType::Int64, false),
+        ];
+        let struct_array_data = ArrayData::builder(DataType::Struct(fields.into()))
+            .len(4)
+            .add_child_data(boolean_array.to_data())
+            .add_child_data(int_array.to_data())
+            .build()
+            .unwrap();
+        let struct_array = StructArray::from(struct_array_data);
+
+        assert_eq!(struct_array.column(0).as_ref(), &boolean_array);
+        assert_eq!(struct_array.column(1).as_ref(), &int_array);
+    }
+
+    #[test]
+    fn test_struct_array_from() {
+        let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
+        let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
+
+        let struct_array = StructArray::from(vec![
+            (
+                Arc::new(Field::new("b", DataType::Boolean, false)),
+                boolean.clone() as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new("c", DataType::Int32, false)),
+                int.clone() as ArrayRef,
+            ),
+        ]);
+        assert_eq!(struct_array.column(0).as_ref(), boolean.as_ref());
+        assert_eq!(struct_array.column(1).as_ref(), int.as_ref());
+        assert_eq!(4, struct_array.len());
+        assert_eq!(0, struct_array.null_count());
+        assert_eq!(0, struct_array.offset());
+    }
+
+    /// validates that struct can be accessed using `column_name` as index i.e. `struct_array["column_name"]`.
+    #[test]
+    fn test_struct_array_index_access() {
+        let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
+        let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
+
+        let struct_array = StructArray::from(vec![
+            (
+                Arc::new(Field::new("b", DataType::Boolean, false)),
+                boolean.clone() as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new("c", DataType::Int32, false)),
+                int.clone() as ArrayRef,
+            ),
+        ]);
+        assert_eq!(struct_array["b"].as_ref(), boolean.as_ref());
+        assert_eq!(struct_array["c"].as_ref(), int.as_ref());
+    }
+
+    /// validates that the in-memory representation follows [the spec](https://arrow.apache.org/docs/format/Columnar.html#struct-layout)
+    #[test]
+    fn test_struct_array_from_vec() {
+        let strings: ArrayRef = Arc::new(StringArray::from(vec![
+            Some("joe"),
+            None,
+            None,
+            Some("mark"),
+        ]));
+        let ints: ArrayRef = Arc::new(Int32Array::from(vec![Some(1), Some(2), None, Some(4)]));
+
+        let arr =
+            StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())]).unwrap();
+
+        let struct_data = arr.into_data();
+        assert_eq!(4, struct_data.len());
+        assert_eq!(0, struct_data.null_count());
+
+        let expected_string_data = ArrayData::builder(DataType::Utf8)
+            .len(4)
+            .null_bit_buffer(Some(Buffer::from(&[9_u8])))
+            .add_buffer(Buffer::from(&[0, 3, 3, 3, 7].to_byte_slice()))
+            .add_buffer(Buffer::from(b"joemark"))
+            .build()
+            .unwrap();
+
+        let expected_int_data = ArrayData::builder(DataType::Int32)
+            .len(4)
+            .null_bit_buffer(Some(Buffer::from(&[11_u8])))
+            .add_buffer(Buffer::from(&[1, 2, 0, 4].to_byte_slice()))
+            .build()
+            .unwrap();
+
+        assert_eq!(expected_string_data, struct_data.child_data()[0]);
+        assert_eq!(expected_int_data, struct_data.child_data()[1]);
+    }
+
+    #[test]
+    fn test_struct_array_from_vec_error() {
+        let strings: ArrayRef = Arc::new(StringArray::from(vec![
+            Some("joe"),
+            None,
+            None,
+            // 3 elements, not 4
+        ]));
+        let ints: ArrayRef = Arc::new(Int32Array::from(vec![Some(1), Some(2), None, Some(4)]));
+
+        let err = StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
+            .unwrap_err()
+            .to_string();
+
+        assert_eq!(
+            err,
+            "Invalid argument error: Incorrect array length for StructArray field \"f2\", expected 3 got 4"
+        )
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Incorrect datatype for StructArray field \\\"b\\\", expected Int16 got Boolean"
+    )]
+    fn test_struct_array_from_mismatched_types_single() {
+        drop(StructArray::from(vec![(
+            Arc::new(Field::new("b", DataType::Int16, false)),
+            Arc::new(BooleanArray::from(vec![false, false, true, true])) as Arc<dyn Array>,
+        )]));
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Incorrect datatype for StructArray field \\\"b\\\", expected Int16 got Boolean"
+    )]
+    fn test_struct_array_from_mismatched_types_multiple() {
+        drop(StructArray::from(vec![
+            (
+                Arc::new(Field::new("b", DataType::Int16, false)),
+                Arc::new(BooleanArray::from(vec![false, false, true, true])) as Arc<dyn Array>,
+            ),
+            (
+                Arc::new(Field::new("c", DataType::Utf8, false)),
+                Arc::new(Int32Array::from(vec![42, 28, 19, 31])),
+            ),
+        ]));
+    }
+
+    #[test]
+    fn test_struct_array_slice() {
+        let boolean_data = ArrayData::builder(DataType::Boolean)
+            .len(5)
+            .add_buffer(Buffer::from([0b00010000]))
+            .null_bit_buffer(Some(Buffer::from([0b00010001])))
+            .build()
+            .unwrap();
+        let int_data = ArrayData::builder(DataType::Int32)
+            .len(5)
+            .add_buffer(Buffer::from([0, 28, 42, 0, 0].to_byte_slice()))
+            .null_bit_buffer(Some(Buffer::from([0b00000110])))
+            .build()
+            .unwrap();
+
+        let field_types = vec![
+            Field::new("a", DataType::Boolean, true),
+            Field::new("b", DataType::Int32, true),
+        ];
+        let struct_array_data = ArrayData::builder(DataType::Struct(field_types.into()))
+            .len(5)
+            .add_child_data(boolean_data.clone())
+            .add_child_data(int_data.clone())
+            .null_bit_buffer(Some(Buffer::from([0b00010111])))
+            .build()
+            .unwrap();
+        let struct_array = StructArray::from(struct_array_data);
+
+        assert_eq!(5, struct_array.len());
+        assert_eq!(1, struct_array.null_count());
+        assert!(struct_array.is_valid(0));
+        assert!(struct_array.is_valid(1));
+        assert!(struct_array.is_valid(2));
+        assert!(struct_array.is_null(3));
+        assert!(struct_array.is_valid(4));
+        assert_eq!(boolean_data, struct_array.column(0).to_data());
+        assert_eq!(int_data, struct_array.column(1).to_data());
+
+        let c0 = struct_array.column(0);
+        let c0 = c0.as_any().downcast_ref::<BooleanArray>().unwrap();
+        assert_eq!(5, c0.len());
+        assert_eq!(3, c0.null_count());
+        assert!(c0.is_valid(0));
+        assert!(!c0.value(0));
+        assert!(c0.is_null(1));
+        assert!(c0.is_null(2));
+        assert!(c0.is_null(3));
+        assert!(c0.is_valid(4));
+        assert!(c0.value(4));
+
+        let c1 = struct_array.column(1);
+        let c1 = c1.as_any().downcast_ref::<Int32Array>().unwrap();
+        assert_eq!(5, c1.len());
+        assert_eq!(3, c1.null_count());
+        assert!(c1.is_null(0));
+        assert!(c1.is_valid(1));
+        assert_eq!(28, c1.value(1));
+        assert!(c1.is_valid(2));
+        assert_eq!(42, c1.value(2));
+        assert!(c1.is_null(3));
+        assert!(c1.is_null(4));
+
+        let sliced_array = struct_array.slice(2, 3);
+        let sliced_array = sliced_array.as_any().downcast_ref::<StructArray>().unwrap();
+        assert_eq!(3, sliced_array.len());
+        assert_eq!(1, sliced_array.null_count());
+        assert!(sliced_array.is_valid(0));
+        assert!(sliced_array.is_null(1));
+        assert!(sliced_array.is_valid(2));
+
+        let sliced_c0 = sliced_array.column(0);
+        let sliced_c0 = sliced_c0.as_any().downcast_ref::<BooleanArray>().unwrap();
+        assert_eq!(3, sliced_c0.len());
+        assert!(sliced_c0.is_null(0));
+        assert!(sliced_c0.is_null(1));
+        assert!(sliced_c0.is_valid(2));
+        assert!(sliced_c0.value(2));
+
+        let sliced_c1 = sliced_array.column(1);
+        let sliced_c1 = sliced_c1.as_any().downcast_ref::<Int32Array>().unwrap();
+        assert_eq!(3, sliced_c1.len());
+        assert!(sliced_c1.is_valid(0));
+        assert_eq!(42, sliced_c1.value(0));
+        assert!(sliced_c1.is_null(1));
+        assert!(sliced_c1.is_null(2));
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Incorrect array length for StructArray field \\\"c\\\", expected 1 got 2"
+    )]
+    fn test_invalid_struct_child_array_lengths() {
+        drop(StructArray::from(vec![
+            (
+                Arc::new(Field::new("b", DataType::Float32, false)),
+                Arc::new(Float32Array::from(vec![1.1])) as Arc<dyn Array>,
+            ),
+            (
+                Arc::new(Field::new("c", DataType::Float64, false)),
+                Arc::new(Float64Array::from(vec![2.2, 3.3])),
+            ),
+        ]));
+    }
+
+    #[test]
+    fn test_struct_array_from_empty() {
+        let sa = StructArray::from(vec![]);
+        assert!(sa.is_empty())
+    }
+
+    #[test]
+    #[should_panic(expected = "Found unmasked nulls for non-nullable StructArray field \\\"c\\\"")]
+    fn test_struct_array_from_mismatched_nullability() {
+        drop(StructArray::from(vec![(
+            Arc::new(Field::new("c", DataType::Int32, false)),
+            Arc::new(Int32Array::from(vec![Some(42), None, Some(19)])) as ArrayRef,
+        )]));
+    }
+}
diff --git a/arrow/src/array/array_union.rs b/arrow-array/src/array/union_array.rs
similarity index 69%
rename from arrow/src/array/array_union.rs
rename to arrow-array/src/array/union_array.rs
index 09cc1ab59fea..94ac0bc879e4 100644
--- a/arrow/src/array/array_union.rs
+++ b/arrow-array/src/array/union_array.rs
@@ -15,26 +15,26 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::{make_array, Array, ArrayRef};
+use arrow_buffer::buffer::NullBuffer;
+use arrow_buffer::{Buffer, ScalarBuffer};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType, Field, UnionFields, UnionMode};
 /// Contains the `UnionArray` type.
 ///
-use crate::array::{make_array, Array, ArrayData, ArrayRef};
-use crate::buffer::Buffer;
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-
-use core::fmt;
 use std::any::Any;
+use std::sync::Arc;
 
-/// An Array that can represent slots of varying types.
+/// An array of [values of varying types](https://arrow.apache.org/docs/format/Columnar.html#union-layout)
 ///
 /// Each slot in a [UnionArray] can have a value chosen from a number
 /// of types.  Each of the possible types are named like the fields of
-/// a [`StructArray`](crate::array::StructArray).  A `UnionArray` can
+/// a [`StructArray`](crate::StructArray).  A `UnionArray` can
 /// have two possible memory layouts, "dense" or "sparse".  For more
 /// information on please see the
 /// [specification](https://arrow.apache.org/docs/format/Columnar.html#union-layout).
 ///
-/// [UnionBuilder](crate::array::UnionBuilder) can be used to
+/// [UnionBuilder](crate::builder::UnionBuilder) can be used to
 /// create [UnionArray]'s of primitive types. `UnionArray`'s of nested
 /// types are also supported but not via `UnionBuilder`, see the tests
 /// for examples.
@@ -42,10 +42,10 @@ use std::any::Any;
 /// # Examples
 /// ## Create a dense UnionArray `[1, 3.2, 34]`
 /// ```
-/// use arrow::buffer::Buffer;
-/// use arrow::datatypes::*;
+/// use arrow_buffer::Buffer;
+/// use arrow_schema::*;
 /// use std::sync::Arc;
-/// use arrow::array::{Array, Int32Array, Float64Array, UnionArray};
+/// use arrow_array::{Array, Int32Array, Float64Array, UnionArray};
 ///
 /// let int_array = Int32Array::from(vec![1, 34]);
 /// let float_array = Float64Array::from(vec![3.2]);
@@ -76,10 +76,10 @@ use std::any::Any;
 ///
 /// ## Create a sparse UnionArray `[1, 3.2, 34]`
 /// ```
-/// use arrow::buffer::Buffer;
-/// use arrow::datatypes::*;
+/// use arrow_buffer::Buffer;
+/// use arrow_schema::*;
 /// use std::sync::Arc;
-/// use arrow::array::{Array, Int32Array, Float64Array, UnionArray};
+/// use arrow_array::{Array, Int32Array, Float64Array, UnionArray};
 ///
 /// let int_array = Int32Array::from(vec![Some(1), None, Some(34)]);
 /// let float_array = Float64Array::from(vec![None, Some(3.2), None]);
@@ -106,9 +106,12 @@ use std::any::Any;
 /// let value = array.value(2).as_any().downcast_ref::<Int32Array>().unwrap().value(0);
 /// assert_eq!(34, value);
 /// ```
+#[derive(Clone)]
 pub struct UnionArray {
-    data: ArrayData,
-    boxed_fields: Vec<ArrayRef>,
+    data_type: DataType,
+    type_ids: ScalarBuffer<i8>,
+    offsets: Option<ScalarBuffer<i32>>,
+    fields: Vec<Option<ArrayRef>>,
 }
 
 impl UnionArray {
@@ -142,8 +145,7 @@ impl UnionArray {
         value_offsets: Option<Buffer>,
         child_arrays: Vec<(Field, ArrayRef)>,
     ) -> Self {
-        let (field_types, field_values): (Vec<_>, Vec<_>) =
-            child_arrays.into_iter().unzip();
+        let (fields, field_values): (Vec<_>, Vec<_>) = child_arrays.into_iter().unzip();
         let len = type_ids.len();
 
         let mode = if value_offsets.is_some() {
@@ -153,8 +155,7 @@ impl UnionArray {
         };
 
         let builder = ArrayData::builder(DataType::Union(
-            field_types,
-            Vec::from(field_type_ids),
+            UnionFields::new(field_type_ids.iter().copied(), fields),
             mode,
         ))
         .add_buffer(type_ids)
@@ -174,12 +175,11 @@ impl UnionArray {
         type_ids: Buffer,
         value_offsets: Option<Buffer>,
         child_arrays: Vec<(Field, ArrayRef)>,
-    ) -> Result<Self> {
+    ) -> Result<Self, ArrowError> {
         if let Some(b) = &value_offsets {
             if ((type_ids.len()) * 4) != b.len() {
                 return Err(ArrowError::InvalidArgumentError(
-                    "Type Ids and Offsets represent a different number of array slots."
-                        .to_string(),
+                    "Type Ids and Offsets represent a different number of array slots.".to_string(),
                 ));
             }
         }
@@ -193,8 +193,7 @@ impl UnionArray {
         if !invalid_type_ids.is_empty() {
             return Err(ArrowError::InvalidArgumentError(format!(
                 "Type Ids must be positive and cannot be greater than the number of \
-                child arrays, found:\n{:?}",
-                invalid_type_ids
+                child arrays, found:\n{invalid_type_ids:?}"
             )));
         }
 
@@ -209,18 +208,16 @@ impl UnionArray {
             if !invalid_offsets.is_empty() {
                 return Err(ArrowError::InvalidArgumentError(format!(
                     "Offsets must be positive and within the length of the Array, \
-                    found:\n{:?}",
-                    invalid_offsets
+                    found:\n{invalid_offsets:?}"
                 )));
             }
         }
 
         // Unsafe Justification: arguments were validated above (and
         // re-revalidated as part of data().validate() below)
-        let new_self = unsafe {
-            Self::new_unchecked(field_type_ids, type_ids, value_offsets, child_arrays)
-        };
-        new_self.data().validate()?;
+        let new_self =
+            unsafe { Self::new_unchecked(field_type_ids, type_ids, value_offsets, child_arrays) };
+        new_self.to_data().validate()?;
 
         Ok(new_self)
     }
@@ -232,9 +229,8 @@ impl UnionArray {
     /// Panics if the `type_id` provided is less than zero or greater than the number of types
     /// in the `Union`.
     pub fn child(&self, type_id: i8) -> &ArrayRef {
-        assert!(0 <= type_id);
-        assert!((type_id as usize) < self.boxed_fields.len());
-        &self.boxed_fields[type_id as usize]
+        let boxed = &self.fields[type_id as usize];
+        boxed.as_ref().expect("invalid type id")
     }
 
     /// Returns the `type_id` for the array slot at `index`.
@@ -243,8 +239,17 @@ impl UnionArray {
     ///
     /// Panics if `index` is greater than the length of the array.
     pub fn type_id(&self, index: usize) -> i8 {
-        assert!(index < self.len());
-        self.data().buffers()[0].as_slice()[self.offset() + index] as i8
+        self.type_ids[index]
+    }
+
+    /// Returns the `type_ids` buffer for this array
+    pub fn type_ids(&self) -> &ScalarBuffer<i8> {
+        &self.type_ids
+    }
+
+    /// Returns the `offsets` buffer if this is a dense array
+    pub fn offsets(&self) -> Option<&ScalarBuffer<i32>> {
+        self.offsets.as_ref()
     }
 
     /// Returns the offset into the underlying values array for the array slot at `index`.
@@ -252,33 +257,30 @@ impl UnionArray {
     /// # Panics
     ///
     /// Panics if `index` is greater than the length of the array.
-    pub fn value_offset(&self, index: usize) -> i32 {
+    pub fn value_offset(&self, index: usize) -> usize {
         assert!(index < self.len());
-        if self.is_dense() {
-            self.data().buffers()[1].typed_data::<i32>()[self.offset() + index]
-        } else {
-            (self.offset() + index) as i32
+        match &self.offsets {
+            Some(offsets) => offsets[index] as usize,
+            None => self.offset() + index,
         }
     }
 
-    /// Returns the array's value at `index`.
-    ///
+    /// Returns the array's value at index `i`.
     /// # Panics
-    ///
-    /// Panics if `index` is greater than the length of the array.
-    pub fn value(&self, index: usize) -> ArrayRef {
-        let type_id = self.type_id(index);
-        let value_offset = self.value_offset(index) as usize;
-        let child_data = self.boxed_fields[type_id as usize].clone();
-        child_data.slice(value_offset, 1)
+    /// Panics if index `i` is out of bounds
+    pub fn value(&self, i: usize) -> ArrayRef {
+        let type_id = self.type_id(i);
+        let value_offset = self.value_offset(i);
+        let child = self.child(type_id);
+        child.slice(value_offset, 1)
     }
 
     /// Returns the names of the types in the union.
     pub fn type_names(&self) -> Vec<&str> {
-        match self.data.data_type() {
-            DataType::Union(fields, _, _) => fields
+        match self.data_type() {
+            DataType::Union(fields, _) => fields
                 .iter()
-                .map(|f| f.name().as_str())
+                .map(|(_, f)| f.name().as_str())
                 .collect::<Vec<&str>>(),
             _ => unreachable!("Union array's data type is not a union!"),
         }
@@ -286,26 +288,94 @@ impl UnionArray {
 
     /// Returns whether the `UnionArray` is dense (or sparse if `false`).
     fn is_dense(&self) -> bool {
-        match self.data.data_type() {
-            DataType::Union(_, _, mode) => mode == &UnionMode::Dense,
+        match self.data_type() {
+            DataType::Union(_, mode) => mode == &UnionMode::Dense,
             _ => unreachable!("Union array's data type is not a union!"),
         }
     }
+
+    /// Returns a zero-copy slice of this array with the indicated offset and length.
+    pub fn slice(&self, offset: usize, length: usize) -> Self {
+        let (offsets, fields) = match self.offsets.as_ref() {
+            // If dense union, slice offsets
+            Some(offsets) => (Some(offsets.slice(offset, length)), self.fields.clone()),
+            // Otherwise need to slice sparse children
+            None => {
+                let fields = self
+                    .fields
+                    .iter()
+                    .map(|x| x.as_ref().map(|x| x.slice(offset, length)))
+                    .collect();
+                (None, fields)
+            }
+        };
+
+        Self {
+            data_type: self.data_type.clone(),
+            type_ids: self.type_ids.slice(offset, length),
+            offsets,
+            fields,
+        }
+    }
 }
 
 impl From<ArrayData> for UnionArray {
     fn from(data: ArrayData) -> Self {
-        let mut boxed_fields = vec![];
-        for cd in data.child_data() {
-            boxed_fields.push(make_array(cd.clone()));
+        let (fields, mode) = match data.data_type() {
+            DataType::Union(fields, mode) => (fields, *mode),
+            d => panic!("UnionArray expected ArrayData with type Union got {d}"),
+        };
+        let (type_ids, offsets) = match mode {
+            UnionMode::Sparse => (
+                ScalarBuffer::new(data.buffers()[0].clone(), data.offset(), data.len()),
+                None,
+            ),
+            UnionMode::Dense => (
+                ScalarBuffer::new(data.buffers()[0].clone(), data.offset(), data.len()),
+                Some(ScalarBuffer::new(
+                    data.buffers()[1].clone(),
+                    data.offset(),
+                    data.len(),
+                )),
+            ),
+        };
+
+        let max_id = fields.iter().map(|(i, _)| i).max().unwrap_or_default() as usize;
+        let mut boxed_fields = vec![None; max_id + 1];
+        for (cd, (field_id, _)) in data.child_data().iter().zip(fields.iter()) {
+            boxed_fields[field_id as usize] = Some(make_array(cd.clone()));
+        }
+        Self {
+            data_type: data.data_type().clone(),
+            type_ids,
+            offsets,
+            fields: boxed_fields,
         }
-        Self { data, boxed_fields }
     }
 }
 
 impl From<UnionArray> for ArrayData {
     fn from(array: UnionArray) -> Self {
-        array.data
+        let len = array.len();
+        let f = match &array.data_type {
+            DataType::Union(f, _) => f,
+            _ => unreachable!(),
+        };
+        let buffers = match array.offsets {
+            Some(o) => vec![array.type_ids.into_inner(), o.into_inner()],
+            None => vec![array.type_ids.into_inner()],
+        };
+
+        let child = f
+            .iter()
+            .map(|(i, _)| array.fields[i as usize].as_ref().unwrap().to_data())
+            .collect();
+
+        let builder = ArrayDataBuilder::new(array.data_type)
+            .len(len)
+            .buffers(buffers)
+            .child_data(child);
+        unsafe { builder.build_unchecked() }
     }
 }
 
@@ -314,14 +384,38 @@ impl Array for UnionArray {
         self
     }
 
-    fn data(&self) -> &ArrayData {
-        &self.data
+    fn to_data(&self) -> ArrayData {
+        self.clone().into()
     }
 
     fn into_data(self) -> ArrayData {
         self.into()
     }
 
+    fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    fn slice(&self, offset: usize, length: usize) -> ArrayRef {
+        Arc::new(self.slice(offset, length))
+    }
+
+    fn len(&self) -> usize {
+        self.type_ids.len()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.type_ids.is_empty()
+    }
+
+    fn offset(&self) -> usize {
+        0
+    }
+
+    fn nulls(&self) -> Option<&NullBuffer> {
+        None
+    }
+
     /// Union types always return non null as there is no validity buffer.
     /// To check validity correctly you must check the underlying vector.
     fn is_null(&self, _index: usize) -> bool {
@@ -339,35 +433,66 @@ impl Array for UnionArray {
     fn null_count(&self) -> usize {
         0
     }
+
+    fn get_buffer_memory_size(&self) -> usize {
+        let mut sum = self.type_ids.inner().capacity();
+        if let Some(o) = self.offsets.as_ref() {
+            sum += o.inner().capacity()
+        }
+        self.fields
+            .iter()
+            .flat_map(|x| x.as_ref().map(|x| x.get_buffer_memory_size()))
+            .sum::<usize>()
+            + sum
+    }
+
+    fn get_array_memory_size(&self) -> usize {
+        let mut sum = self.type_ids.inner().capacity();
+        if let Some(o) = self.offsets.as_ref() {
+            sum += o.inner().capacity()
+        }
+        std::mem::size_of::<Self>()
+            + self
+                .fields
+                .iter()
+                .flat_map(|x| x.as_ref().map(|x| x.get_array_memory_size()))
+                .sum::<usize>()
+            + sum
+    }
 }
 
-impl fmt::Debug for UnionArray {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+impl std::fmt::Debug for UnionArray {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         let header = if self.is_dense() {
             "UnionArray(Dense)\n["
         } else {
             "UnionArray(Sparse)\n["
         };
-        writeln!(f, "{}", header)?;
+        writeln!(f, "{header}")?;
 
         writeln!(f, "-- type id buffer:")?;
-        writeln!(f, "{:?}", self.data().buffers()[0])?;
+        writeln!(f, "{:?}", self.type_ids)?;
 
-        if self.is_dense() {
+        if let Some(offsets) = &self.offsets {
             writeln!(f, "-- offsets buffer:")?;
-            writeln!(f, "{:?}", self.data().buffers()[1])?;
+            writeln!(f, "{:?}", offsets)?;
         }
 
-        for (child_index, name) in self.type_names().iter().enumerate() {
-            let column = &self.boxed_fields[child_index];
+        let fields = match self.data_type() {
+            DataType::Union(fields, _) => fields,
+            _ => unreachable!(),
+        };
+
+        for (type_id, field) in fields.iter() {
+            let child = self.child(type_id);
             writeln!(
                 f,
                 "-- child {}: \"{}\" ({:?})",
-                child_index,
-                *name,
-                column.data_type()
+                type_id,
+                field.name(),
+                field.data_type()
             )?;
-            fmt::Debug::fmt(column, f)?;
+            std::fmt::Debug::fmt(child, f)?;
             writeln!(f)?;
         }
         writeln!(f, "]")
@@ -378,16 +503,17 @@ impl fmt::Debug for UnionArray {
 mod tests {
     use super::*;
 
+    use crate::builder::UnionBuilder;
+    use crate::cast::AsArray;
+    use crate::types::{Float32Type, Float64Type, Int32Type, Int64Type};
+    use crate::RecordBatch;
+    use crate::{Float64Array, Int32Array, Int64Array, StringArray};
+    use arrow_schema::Schema;
     use std::sync::Arc;
 
-    use crate::array::*;
-    use crate::buffer::Buffer;
-    use crate::datatypes::{DataType, Field};
-    use crate::record_batch::RecordBatch;
-
     #[test]
     fn test_dense_i32() {
-        let mut builder = UnionBuilder::new_dense(7);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append::<Int32Type>("b", 2).unwrap();
         builder.append::<Int32Type>("c", 3).unwrap();
@@ -398,39 +524,33 @@ mod tests {
         let union = builder.build().unwrap();
 
         let expected_type_ids = vec![0_i8, 1, 2, 0, 2, 0, 1];
-        let expected_value_offsets = vec![0_i32, 0, 0, 1, 1, 2, 1];
+        let expected_offsets = vec![0_i32, 0, 0, 1, 1, 2, 1];
         let expected_array_values = [1_i32, 2, 3, 4, 5, 6, 7];
 
         // Check type ids
-        assert_eq!(
-            union.data().buffers()[0],
-            Buffer::from_slice_ref(&expected_type_ids)
-        );
+        assert_eq!(*union.type_ids(), expected_type_ids);
         for (i, id) in expected_type_ids.iter().enumerate() {
             assert_eq!(id, &union.type_id(i));
         }
 
         // Check offsets
-        assert_eq!(
-            union.data().buffers()[1],
-            Buffer::from_slice_ref(&expected_value_offsets)
-        );
-        for (i, id) in expected_value_offsets.iter().enumerate() {
-            assert_eq!(&union.value_offset(i), id);
+        assert_eq!(*union.offsets().unwrap(), expected_offsets);
+        for (i, id) in expected_offsets.iter().enumerate() {
+            assert_eq!(union.value_offset(i), *id as usize);
         }
 
         // Check data
         assert_eq!(
-            union.data().child_data()[0].buffers()[0],
-            Buffer::from_slice_ref(&[1_i32, 4, 6])
+            *union.child(0).as_primitive::<Int32Type>().values(),
+            [1_i32, 4, 6]
         );
         assert_eq!(
-            union.data().child_data()[1].buffers()[0],
-            Buffer::from_slice_ref(&[2_i32, 7])
+            *union.child(1).as_primitive::<Int32Type>().values(),
+            [2_i32, 7]
         );
         assert_eq!(
-            union.data().child_data()[2].buffers()[0],
-            Buffer::from_slice_ref(&[3_i32, 5]),
+            *union.child(2).as_primitive::<Int32Type>().values(),
+            [3_i32, 5]
         );
 
         assert_eq!(expected_array_values.len(), union.len());
@@ -447,10 +567,10 @@ mod tests {
     #[test]
     #[cfg_attr(miri, ignore)]
     fn test_dense_i32_large() {
-        let mut builder = UnionBuilder::new_dense(1024);
+        let mut builder = UnionBuilder::new_dense();
 
         let expected_type_ids = vec![0_i8; 1024];
-        let expected_value_offsets: Vec<_> = (0..1024).collect();
+        let expected_offsets: Vec<_> = (0..1024).collect();
         let expected_array_values: Vec<_> = (1..=1024).collect();
 
         expected_array_values
@@ -460,27 +580,21 @@ mod tests {
         let union = builder.build().unwrap();
 
         // Check type ids
-        assert_eq!(
-            union.data().buffers()[0],
-            Buffer::from_slice_ref(&expected_type_ids)
-        );
+        assert_eq!(*union.type_ids(), expected_type_ids);
         for (i, id) in expected_type_ids.iter().enumerate() {
             assert_eq!(id, &union.type_id(i));
         }
 
         // Check offsets
-        assert_eq!(
-            union.data().buffers()[1],
-            Buffer::from_slice_ref(&expected_value_offsets)
-        );
-        for (i, id) in expected_value_offsets.iter().enumerate() {
-            assert_eq!(&union.value_offset(i), id);
+        assert_eq!(*union.offsets().unwrap(), expected_offsets);
+        for (i, id) in expected_offsets.iter().enumerate() {
+            assert_eq!(union.value_offset(i), *id as usize);
         }
 
         for (i, expected_value) in expected_array_values.iter().enumerate() {
             assert!(!union.is_null(i));
             let slot = union.value(i);
-            let slot = slot.as_any().downcast_ref::<Int32Array>().unwrap();
+            let slot = slot.as_primitive::<Int32Type>();
             assert_eq!(slot.len(), 1);
             let value = slot.value(0);
             assert_eq!(expected_value, &value);
@@ -489,7 +603,7 @@ mod tests {
 
     #[test]
     fn test_dense_mixed() {
-        let mut builder = UnionBuilder::new_dense(7);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append::<Int64Type>("c", 3).unwrap();
         builder.append::<Int32Type>("a", 4).unwrap();
@@ -539,7 +653,7 @@ mod tests {
 
     #[test]
     fn test_dense_mixed_with_nulls() {
-        let mut builder = UnionBuilder::new_dense(7);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append::<Int64Type>("c", 3).unwrap();
         builder.append::<Int32Type>("a", 10).unwrap();
@@ -587,7 +701,7 @@ mod tests {
 
     #[test]
     fn test_dense_mixed_with_nulls_and_offset() {
-        let mut builder = UnionBuilder::new_dense(7);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append::<Int64Type>("c", 3).unwrap();
         builder.append::<Int32Type>("a", 10).unwrap();
@@ -629,10 +743,10 @@ mod tests {
         let float_array = Float64Array::from(vec![10.0]);
 
         let type_ids = [1_i8, 0, 0, 2, 0, 1];
-        let value_offsets = [0_i32, 0, 1, 0, 2, 1];
+        let offsets = [0_i32, 0, 1, 0, 2, 1];
 
-        let type_id_buffer = Buffer::from_slice_ref(&type_ids);
-        let value_offsets_buffer = Buffer::from_slice_ref(&value_offsets);
+        let type_id_buffer = Buffer::from_slice_ref(type_ids);
+        let value_offsets_buffer = Buffer::from_slice_ref(offsets);
 
         let children: Vec<(Field, Arc<dyn Array>)> = vec![
             (
@@ -654,18 +768,15 @@ mod tests {
         .unwrap();
 
         // Check type ids
-        assert_eq!(Buffer::from_slice_ref(&type_ids), array.data().buffers()[0]);
+        assert_eq!(*array.type_ids(), type_ids);
         for (i, id) in type_ids.iter().enumerate() {
             assert_eq!(id, &array.type_id(i));
         }
 
         // Check offsets
-        assert_eq!(
-            Buffer::from_slice_ref(&value_offsets),
-            array.data().buffers()[1]
-        );
-        for (i, id) in value_offsets.iter().enumerate() {
-            assert_eq!(id, &array.value_offset(i));
+        assert_eq!(*array.offsets().unwrap(), offsets);
+        for (i, id) in offsets.iter().enumerate() {
+            assert_eq!(*id as usize, array.value_offset(i));
         }
 
         // Check values
@@ -714,7 +825,7 @@ mod tests {
 
     #[test]
     fn test_sparse_i32() {
-        let mut builder = UnionBuilder::new_sparse(7);
+        let mut builder = UnionBuilder::new_sparse();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append::<Int32Type>("b", 2).unwrap();
         builder.append::<Int32Type>("c", 3).unwrap();
@@ -728,29 +839,26 @@ mod tests {
         let expected_array_values = [1_i32, 2, 3, 4, 5, 6, 7];
 
         // Check type ids
-        assert_eq!(
-            Buffer::from_slice_ref(&expected_type_ids),
-            union.data().buffers()[0]
-        );
+        assert_eq!(*union.type_ids(), expected_type_ids);
         for (i, id) in expected_type_ids.iter().enumerate() {
             assert_eq!(id, &union.type_id(i));
         }
 
         // Check offsets, sparse union should only have a single buffer
-        assert_eq!(union.data().buffers().len(), 1);
+        assert!(union.offsets().is_none());
 
         // Check data
         assert_eq!(
-            union.data().child_data()[0].buffers()[0],
-            Buffer::from_slice_ref(&[1_i32, 0, 0, 4, 0, 6, 0]),
+            *union.child(0).as_primitive::<Int32Type>().values(),
+            [1_i32, 0, 0, 4, 0, 6, 0],
         );
         assert_eq!(
-            Buffer::from_slice_ref(&[0_i32, 2_i32, 0, 0, 0, 0, 7]),
-            union.data().child_data()[1].buffers()[0]
+            *union.child(1).as_primitive::<Int32Type>().values(),
+            [0_i32, 2_i32, 0, 0, 0, 0, 7]
         );
         assert_eq!(
-            Buffer::from_slice_ref(&[0_i32, 0, 3_i32, 0, 5, 0, 0]),
-            union.data().child_data()[2].buffers()[0]
+            *union.child(2).as_primitive::<Int32Type>().values(),
+            [0_i32, 0, 3_i32, 0, 5, 0, 0]
         );
 
         assert_eq!(expected_array_values.len(), union.len());
@@ -766,7 +874,7 @@ mod tests {
 
     #[test]
     fn test_sparse_mixed() {
-        let mut builder = UnionBuilder::new_sparse(5);
+        let mut builder = UnionBuilder::new_sparse();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append::<Float64Type>("c", 3.0).unwrap();
         builder.append::<Int32Type>("a", 4).unwrap();
@@ -777,16 +885,13 @@ mod tests {
         let expected_type_ids = vec![0_i8, 1, 0, 1, 0];
 
         // Check type ids
-        assert_eq!(
-            Buffer::from_slice_ref(&expected_type_ids),
-            union.data().buffers()[0]
-        );
+        assert_eq!(*union.type_ids(), expected_type_ids);
         for (i, id) in expected_type_ids.iter().enumerate() {
             assert_eq!(id, &union.type_id(i));
         }
 
         // Check offsets, sparse union should only have a single buffer, i.e. no offsets
-        assert_eq!(union.data().buffers().len(), 1);
+        assert!(union.offsets().is_none());
 
         for i in 0..union.len() {
             let slot = union.value(i);
@@ -829,7 +934,7 @@ mod tests {
 
     #[test]
     fn test_sparse_mixed_with_nulls() {
-        let mut builder = UnionBuilder::new_sparse(5);
+        let mut builder = UnionBuilder::new_sparse();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append_null::<Int32Type>("a").unwrap();
         builder.append::<Float64Type>("c", 3.0).unwrap();
@@ -839,16 +944,13 @@ mod tests {
         let expected_type_ids = vec![0_i8, 0, 1, 0];
 
         // Check type ids
-        assert_eq!(
-            Buffer::from_slice_ref(&expected_type_ids),
-            union.data().buffers()[0]
-        );
+        assert_eq!(*union.type_ids(), expected_type_ids);
         for (i, id) in expected_type_ids.iter().enumerate() {
             assert_eq!(id, &union.type_id(i));
         }
 
         // Check offsets, sparse union should only have a single buffer, i.e. no offsets
-        assert_eq!(union.data().buffers().len(), 1);
+        assert!(union.offsets().is_none());
 
         for i in 0..union.len() {
             let slot = union.value(i);
@@ -882,7 +984,7 @@ mod tests {
 
     #[test]
     fn test_sparse_mixed_with_nulls_and_offset() {
-        let mut builder = UnionBuilder::new_sparse(5);
+        let mut builder = UnionBuilder::new_sparse();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append_null::<Int32Type>("a").unwrap();
         builder.append::<Float64Type>("c", 3.0).unwrap();
@@ -899,7 +1001,7 @@ mod tests {
             match i {
                 0 => assert!(slot.is_null(0)),
                 1 => {
-                    let slot = slot.as_any().downcast_ref::<Float64Array>().unwrap();
+                    let slot = slot.as_primitive::<Float64Type>();
                     assert!(!slot.is_null(0));
                     assert_eq!(slot.len(), 1);
                     let value = slot.value(0);
@@ -907,7 +1009,7 @@ mod tests {
                 }
                 2 => assert!(slot.is_null(0)),
                 3 => {
-                    let slot = slot.as_any().downcast_ref::<Int32Array>().unwrap();
+                    let slot = slot.as_primitive::<Int32Type>();
                     assert!(!slot.is_null(0));
                     assert_eq!(slot.len(), 1);
                     let value = slot.value(0);
@@ -928,8 +1030,8 @@ mod tests {
     }
 
     #[test]
-    fn test_union_array_validaty() {
-        let mut builder = UnionBuilder::new_sparse(5);
+    fn test_union_array_validity() {
+        let mut builder = UnionBuilder::new_sparse();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append_null::<Int32Type>("a").unwrap();
         builder.append::<Float64Type>("c", 3.0).unwrap();
@@ -939,7 +1041,7 @@ mod tests {
 
         test_union_validity(&union);
 
-        let mut builder = UnionBuilder::new_dense(5);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append_null::<Int32Type>("a").unwrap();
         builder.append::<Float64Type>("c", 3.0).unwrap();
@@ -952,10 +1054,16 @@ mod tests {
 
     #[test]
     fn test_type_check() {
-        let mut builder = UnionBuilder::new_sparse(2);
+        let mut builder = UnionBuilder::new_sparse();
         builder.append::<Float32Type>("a", 1.0).unwrap();
         let err = builder.append::<Int32Type>("a", 1).unwrap_err().to_string();
-        assert!(err.contains("Attempt to write col \"a\" with type Int32 doesn't match existing type Float32"), "{}", err);
+        assert!(
+            err.contains(
+                "Attempt to write col \"a\" with type Int32 doesn't match existing type Float32"
+            ),
+            "{}",
+            err
+        );
     }
 
     #[test]
@@ -992,34 +1100,104 @@ mod tests {
             assert_eq!(union_slice.type_id(2), 1);
 
             let slot = union_slice.value(0);
-            let array = slot.as_any().downcast_ref::<Int32Array>().unwrap();
+            let array = slot.as_primitive::<Int32Type>();
             assert_eq!(array.len(), 1);
             assert!(array.is_null(0));
 
             let slot = union_slice.value(1);
-            let array = slot.as_any().downcast_ref::<Float64Array>().unwrap();
+            let array = slot.as_primitive::<Float64Type>();
             assert_eq!(array.len(), 1);
             assert!(array.is_valid(0));
             assert_eq!(array.value(0), 3.0);
 
             let slot = union_slice.value(2);
-            let array = slot.as_any().downcast_ref::<Float64Array>().unwrap();
+            let array = slot.as_primitive::<Float64Type>();
             assert_eq!(array.len(), 1);
             assert!(array.is_null(0));
         }
 
         // Sparse Union
-        let builder = UnionBuilder::new_sparse(5);
+        let builder = UnionBuilder::new_sparse();
         let record_batch = create_batch(create_union(builder));
         // [null, 3.0, null]
         let record_batch_slice = record_batch.slice(1, 3);
         test_slice_union(record_batch_slice);
 
         // Dense Union
-        let builder = UnionBuilder::new_dense(5);
+        let builder = UnionBuilder::new_dense();
         let record_batch = create_batch(create_union(builder));
         // [null, 3.0, null]
         let record_batch_slice = record_batch.slice(1, 3);
         test_slice_union(record_batch_slice);
     }
+
+    #[test]
+    fn test_custom_type_ids() {
+        let data_type = DataType::Union(
+            UnionFields::new(
+                vec![8, 4, 9],
+                vec![
+                    Field::new("strings", DataType::Utf8, false),
+                    Field::new("integers", DataType::Int32, false),
+                    Field::new("floats", DataType::Float64, false),
+                ],
+            ),
+            UnionMode::Dense,
+        );
+
+        let string_array = StringArray::from(vec!["foo", "bar", "baz"]);
+        let int_array = Int32Array::from(vec![5, 6, 4]);
+        let float_array = Float64Array::from(vec![10.0]);
+
+        let type_ids = Buffer::from_vec(vec![4_i8, 8, 4, 8, 9, 4, 8]);
+        let value_offsets = Buffer::from_vec(vec![0_i32, 0, 1, 1, 0, 2, 2]);
+
+        let data = ArrayData::builder(data_type)
+            .len(7)
+            .buffers(vec![type_ids, value_offsets])
+            .child_data(vec![
+                string_array.into_data(),
+                int_array.into_data(),
+                float_array.into_data(),
+            ])
+            .build()
+            .unwrap();
+
+        let array = UnionArray::from(data);
+
+        let v = array.value(0);
+        assert_eq!(v.data_type(), &DataType::Int32);
+        assert_eq!(v.len(), 1);
+        assert_eq!(v.as_primitive::<Int32Type>().value(0), 5);
+
+        let v = array.value(1);
+        assert_eq!(v.data_type(), &DataType::Utf8);
+        assert_eq!(v.len(), 1);
+        assert_eq!(v.as_string::<i32>().value(0), "foo");
+
+        let v = array.value(2);
+        assert_eq!(v.data_type(), &DataType::Int32);
+        assert_eq!(v.len(), 1);
+        assert_eq!(v.as_primitive::<Int32Type>().value(0), 6);
+
+        let v = array.value(3);
+        assert_eq!(v.data_type(), &DataType::Utf8);
+        assert_eq!(v.len(), 1);
+        assert_eq!(v.as_string::<i32>().value(0), "bar");
+
+        let v = array.value(4);
+        assert_eq!(v.data_type(), &DataType::Float64);
+        assert_eq!(v.len(), 1);
+        assert_eq!(v.as_primitive::<Float64Type>().value(0), 10.0);
+
+        let v = array.value(5);
+        assert_eq!(v.data_type(), &DataType::Int32);
+        assert_eq!(v.len(), 1);
+        assert_eq!(v.as_primitive::<Int32Type>().value(0), 4);
+
+        let v = array.value(6);
+        assert_eq!(v.data_type(), &DataType::Utf8);
+        assert_eq!(v.len(), 1);
+        assert_eq!(v.as_string::<i32>().value(0), "baz");
+    }
 }
diff --git a/arrow/src/array/builder/boolean_builder.rs b/arrow-array/src/builder/boolean_builder.rs
similarity index 60%
rename from arrow/src/array/builder/boolean_builder.rs
rename to arrow-array/src/builder/boolean_builder.rs
index e28e37bc9e2d..7e59d940a50e 100644
--- a/arrow/src/array/builder/boolean_builder.rs
+++ b/arrow-array/src/builder/boolean_builder.rs
@@ -15,50 +15,45 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::builder::{ArrayBuilder, BooleanBufferBuilder};
+use crate::{ArrayRef, BooleanArray};
+use arrow_buffer::Buffer;
+use arrow_buffer::NullBufferBuilder;
+use arrow_data::ArrayData;
+use arrow_schema::{ArrowError, DataType};
 use std::any::Any;
 use std::sync::Arc;
 
-use crate::array::ArrayBuilder;
-use crate::array::ArrayData;
-use crate::array::ArrayRef;
-use crate::array::BooleanArray;
-use crate::datatypes::DataType;
-
-use crate::error::ArrowError;
-use crate::error::Result;
-
-use super::BooleanBufferBuilder;
-use super::NullBufferBuilder;
-
-///  Array builder for fixed-width primitive types
+/// Builder for [`BooleanArray`]
 ///
 /// # Example
 ///
 /// Create a `BooleanArray` from a `BooleanBuilder`
 ///
 /// ```
-///     use arrow::array::{Array, BooleanArray, BooleanBuilder};
 ///
-///     let mut b = BooleanBuilder::new(4);
-///     b.append_value(true);
-///     b.append_null();
-///     b.append_value(false);
-///     b.append_value(true);
-///     let arr = b.finish();
+/// # use arrow_array::{Array, BooleanArray, builder::BooleanBuilder};
 ///
-///     assert_eq!(4, arr.len());
-///     assert_eq!(1, arr.null_count());
-///     assert_eq!(true, arr.value(0));
-///     assert!(arr.is_valid(0));
-///     assert!(!arr.is_null(0));
-///     assert!(!arr.is_valid(1));
-///     assert!(arr.is_null(1));
-///     assert_eq!(false, arr.value(2));
-///     assert!(arr.is_valid(2));
-///     assert!(!arr.is_null(2));
-///     assert_eq!(true, arr.value(3));
-///     assert!(arr.is_valid(3));
-///     assert!(!arr.is_null(3));
+/// let mut b = BooleanBuilder::new();
+/// b.append_value(true);
+/// b.append_null();
+/// b.append_value(false);
+/// b.append_value(true);
+/// let arr = b.finish();
+///
+/// assert_eq!(4, arr.len());
+/// assert_eq!(1, arr.null_count());
+/// assert_eq!(true, arr.value(0));
+/// assert!(arr.is_valid(0));
+/// assert!(!arr.is_null(0));
+/// assert!(!arr.is_valid(1));
+/// assert!(arr.is_null(1));
+/// assert_eq!(false, arr.value(2));
+/// assert!(arr.is_valid(2));
+/// assert!(!arr.is_null(2));
+/// assert_eq!(true, arr.value(3));
+/// assert!(arr.is_valid(3));
+/// assert!(!arr.is_null(3));
 /// ```
 #[derive(Debug)]
 pub struct BooleanBuilder {
@@ -66,9 +61,20 @@ pub struct BooleanBuilder {
     null_buffer_builder: NullBufferBuilder,
 }
 
+impl Default for BooleanBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl BooleanBuilder {
-    /// Creates a new primitive array builder
-    pub fn new(capacity: usize) -> Self {
+    /// Creates a new boolean builder
+    pub fn new() -> Self {
+        Self::with_capacity(1024)
+    }
+
+    /// Creates a new boolean builder with space for `capacity` elements without re-allocating
+    pub fn with_capacity(capacity: usize) -> Self {
         Self {
             values_builder: BooleanBufferBuilder::new(capacity),
             null_buffer_builder: NullBufferBuilder::new(capacity),
@@ -121,7 +127,7 @@ impl BooleanBuilder {
     ///
     /// Returns an error if the slices are of different lengths
     #[inline]
-    pub fn append_values(&mut self, values: &[bool], is_valid: &[bool]) -> Result<()> {
+    pub fn append_values(&mut self, values: &[bool], is_valid: &[bool]) -> Result<(), ArrowError> {
         if values.len() != is_valid.len() {
             Err(ArrowError::InvalidArgumentError(
                 "Value and validity lengths must be equal".to_string(),
@@ -139,12 +145,31 @@ impl BooleanBuilder {
         let null_bit_buffer = self.null_buffer_builder.finish();
         let builder = ArrayData::builder(DataType::Boolean)
             .len(len)
-            .add_buffer(self.values_builder.finish())
-            .null_bit_buffer(null_bit_buffer);
+            .add_buffer(self.values_builder.finish().into_inner())
+            .nulls(null_bit_buffer);
 
         let array_data = unsafe { builder.build_unchecked() };
         BooleanArray::from(array_data)
     }
+
+    /// Builds the [BooleanArray] without resetting the builder.
+    pub fn finish_cloned(&self) -> BooleanArray {
+        let len = self.len();
+        let nulls = self.null_buffer_builder.finish_cloned();
+        let value_buffer = Buffer::from_slice_ref(self.values_builder.as_slice());
+        let builder = ArrayData::builder(DataType::Boolean)
+            .len(len)
+            .add_buffer(value_buffer)
+            .nulls(nulls);
+
+        let array_data = unsafe { builder.build_unchecked() };
+        BooleanArray::from(array_data)
+    }
+
+    /// Returns the current null buffer as a slice
+    pub fn validity_slice(&self) -> Option<&[u8]> {
+        self.null_buffer_builder.as_slice()
+    }
 }
 
 impl ArrayBuilder for BooleanBuilder {
@@ -168,21 +193,31 @@ impl ArrayBuilder for BooleanBuilder {
         self.values_builder.len()
     }
 
-    /// Returns whether the number of array slots is zero
-    fn is_empty(&self) -> bool {
-        self.values_builder.is_empty()
-    }
-
     /// Builds the array and reset this builder.
     fn finish(&mut self) -> ArrayRef {
         Arc::new(self.finish())
     }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+}
+
+impl Extend<Option<bool>> for BooleanBuilder {
+    #[inline]
+    fn extend<T: IntoIterator<Item = Option<bool>>>(&mut self, iter: T) {
+        for v in iter {
+            self.append_option(v)
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{array::Array, buffer::Buffer};
+    use crate::Array;
+    use arrow_buffer::Buffer;
 
     #[test]
     fn test_boolean_array_builder() {
@@ -198,21 +233,20 @@ mod tests {
         }
 
         let arr = builder.finish();
-        assert_eq!(&buf, arr.values());
+        assert_eq!(&buf, arr.values().inner());
         assert_eq!(10, arr.len());
         assert_eq!(0, arr.offset());
         assert_eq!(0, arr.null_count());
         for i in 0..10 {
             assert!(!arr.is_null(i));
             assert!(arr.is_valid(i));
-            assert_eq!(i == 3 || i == 6 || i == 9, arr.value(i), "failed at {}", i)
+            assert_eq!(i == 3 || i == 6 || i == 9, arr.value(i), "failed at {i}")
         }
     }
 
     #[test]
     fn test_boolean_array_builder_append_slice() {
-        let arr1 =
-            BooleanArray::from(vec![Some(true), Some(false), None, None, Some(false)]);
+        let arr1 = BooleanArray::from(vec![Some(true), Some(false), None, None, Some(false)]);
 
         let mut builder = BooleanArray::builder(0);
         builder.append_slice(&[true, false]);
@@ -247,6 +281,41 @@ mod tests {
 
         let array = builder.finish();
         assert_eq!(0, array.null_count());
-        assert!(array.data().null_buffer().is_none());
+        assert!(array.nulls().is_none());
+    }
+
+    #[test]
+    fn test_boolean_array_builder_finish_cloned() {
+        let mut builder = BooleanArray::builder(16);
+        builder.append_option(Some(true));
+        builder.append_value(false);
+        builder.append_slice(&[true, false, true]);
+        let mut array = builder.finish_cloned();
+        assert_eq!(3, array.true_count());
+        assert_eq!(2, array.false_count());
+
+        builder
+            .append_values(&[false, false, true], &[true, true, true])
+            .unwrap();
+
+        array = builder.finish();
+        assert_eq!(4, array.true_count());
+        assert_eq!(4, array.false_count());
+
+        assert_eq!(0, array.null_count());
+        assert!(array.nulls().is_none());
+    }
+
+    #[test]
+    fn test_extend() {
+        let mut builder = BooleanBuilder::new();
+        builder.extend([false, false, true, false, false].into_iter().map(Some));
+        builder.extend([true, true, false].into_iter().map(Some));
+        let array = builder.finish();
+        let values = array.iter().map(|x| x.unwrap()).collect::<Vec<_>>();
+        assert_eq!(
+            &values,
+            &[false, false, true, false, false, true, true, false]
+        )
     }
 }
diff --git a/arrow-array/src/builder/buffer_builder.rs b/arrow-array/src/builder/buffer_builder.rs
new file mode 100644
index 000000000000..2b66a8187fa9
--- /dev/null
+++ b/arrow-array/src/builder/buffer_builder.rs
@@ -0,0 +1,226 @@
+// 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.
+
+use crate::array::ArrowPrimitiveType;
+pub use arrow_buffer::BufferBuilder;
+use half::f16;
+
+use crate::types::*;
+
+/// Buffer builder for signed 8-bit integer type.
+pub type Int8BufferBuilder = BufferBuilder<i8>;
+/// Buffer builder for signed 16-bit integer type.
+pub type Int16BufferBuilder = BufferBuilder<i16>;
+/// Buffer builder for signed 32-bit integer type.
+pub type Int32BufferBuilder = BufferBuilder<i32>;
+/// Buffer builder for signed 64-bit integer type.
+pub type Int64BufferBuilder = BufferBuilder<i64>;
+/// Buffer builder for usigned 8-bit integer type.
+pub type UInt8BufferBuilder = BufferBuilder<u8>;
+/// Buffer builder for usigned 16-bit integer type.
+pub type UInt16BufferBuilder = BufferBuilder<u16>;
+/// Buffer builder for usigned 32-bit integer type.
+pub type UInt32BufferBuilder = BufferBuilder<u32>;
+/// Buffer builder for usigned 64-bit integer type.
+pub type UInt64BufferBuilder = BufferBuilder<u64>;
+/// Buffer builder for 16-bit floating point type.
+pub type Float16BufferBuilder = BufferBuilder<f16>;
+/// Buffer builder for 32-bit floating point type.
+pub type Float32BufferBuilder = BufferBuilder<f32>;
+/// Buffer builder for 64-bit floating point type.
+pub type Float64BufferBuilder = BufferBuilder<f64>;
+
+/// Buffer builder for 128-bit decimal type.
+pub type Decimal128BufferBuilder = BufferBuilder<<Decimal128Type as ArrowPrimitiveType>::Native>;
+/// Buffer builder for 256-bit decimal type.
+pub type Decimal256BufferBuilder = BufferBuilder<<Decimal256Type as ArrowPrimitiveType>::Native>;
+
+/// Buffer builder for timestamp type of second unit.
+pub type TimestampSecondBufferBuilder =
+    BufferBuilder<<TimestampSecondType as ArrowPrimitiveType>::Native>;
+/// Buffer builder for timestamp type of millisecond unit.
+pub type TimestampMillisecondBufferBuilder =
+    BufferBuilder<<TimestampMillisecondType as ArrowPrimitiveType>::Native>;
+/// Buffer builder for timestamp type of microsecond unit.
+pub type TimestampMicrosecondBufferBuilder =
+    BufferBuilder<<TimestampMicrosecondType as ArrowPrimitiveType>::Native>;
+/// Buffer builder for timestamp type of nanosecond unit.
+pub type TimestampNanosecondBufferBuilder =
+    BufferBuilder<<TimestampNanosecondType as ArrowPrimitiveType>::Native>;
+
+/// Buffer builder for 32-bit date type.
+pub type Date32BufferBuilder = BufferBuilder<<Date32Type as ArrowPrimitiveType>::Native>;
+/// Buffer builder for 64-bit date type.
+pub type Date64BufferBuilder = BufferBuilder<<Date64Type as ArrowPrimitiveType>::Native>;
+
+/// Buffer builder for 32-bit elaspsed time since midnight of second unit.
+pub type Time32SecondBufferBuilder =
+    BufferBuilder<<Time32SecondType as ArrowPrimitiveType>::Native>;
+/// Buffer builder for 32-bit elaspsed time since midnight of millisecond unit.
+pub type Time32MillisecondBufferBuilder =
+    BufferBuilder<<Time32MillisecondType as ArrowPrimitiveType>::Native>;
+/// Buffer builder for 64-bit elaspsed time since midnight of microsecond unit.
+pub type Time64MicrosecondBufferBuilder =
+    BufferBuilder<<Time64MicrosecondType as ArrowPrimitiveType>::Native>;
+/// Buffer builder for 64-bit elaspsed time since midnight of nanosecond unit.
+pub type Time64NanosecondBufferBuilder =
+    BufferBuilder<<Time64NanosecondType as ArrowPrimitiveType>::Native>;
+
+/// Buffer builder for “calendar” interval in months.
+pub type IntervalYearMonthBufferBuilder =
+    BufferBuilder<<IntervalYearMonthType as ArrowPrimitiveType>::Native>;
+/// Buffer builder for “calendar” interval in days and milliseconds.
+pub type IntervalDayTimeBufferBuilder =
+    BufferBuilder<<IntervalDayTimeType as ArrowPrimitiveType>::Native>;
+/// Buffer builder “calendar” interval in months, days, and nanoseconds.
+pub type IntervalMonthDayNanoBufferBuilder =
+    BufferBuilder<<IntervalMonthDayNanoType as ArrowPrimitiveType>::Native>;
+
+/// Buffer builder for elaspsed time of second unit.
+pub type DurationSecondBufferBuilder =
+    BufferBuilder<<DurationSecondType as ArrowPrimitiveType>::Native>;
+/// Buffer builder for elaspsed time of milliseconds unit.
+pub type DurationMillisecondBufferBuilder =
+    BufferBuilder<<DurationMillisecondType as ArrowPrimitiveType>::Native>;
+/// Buffer builder for elaspsed time of microseconds unit.
+pub type DurationMicrosecondBufferBuilder =
+    BufferBuilder<<DurationMicrosecondType as ArrowPrimitiveType>::Native>;
+/// Buffer builder for elaspsed time of nanoseconds unit.
+pub type DurationNanosecondBufferBuilder =
+    BufferBuilder<<DurationNanosecondType as ArrowPrimitiveType>::Native>;
+
+#[cfg(test)]
+mod tests {
+    use crate::builder::{ArrayBuilder, Int32BufferBuilder, Int8Builder, UInt8BufferBuilder};
+    use crate::Array;
+
+    #[test]
+    fn test_builder_i32_empty() {
+        let mut b = Int32BufferBuilder::new(5);
+        assert_eq!(0, b.len());
+        assert_eq!(16, b.capacity());
+        let a = b.finish();
+        assert_eq!(0, a.len());
+    }
+
+    #[test]
+    fn test_builder_i32_alloc_zero_bytes() {
+        let mut b = Int32BufferBuilder::new(0);
+        b.append(123);
+        let a = b.finish();
+        assert_eq!(4, a.len());
+    }
+
+    #[test]
+    fn test_builder_i32() {
+        let mut b = Int32BufferBuilder::new(5);
+        for i in 0..5 {
+            b.append(i);
+        }
+        assert_eq!(16, b.capacity());
+        let a = b.finish();
+        assert_eq!(20, a.len());
+    }
+
+    #[test]
+    fn test_builder_i32_grow_buffer() {
+        let mut b = Int32BufferBuilder::new(2);
+        assert_eq!(16, b.capacity());
+        for i in 0..20 {
+            b.append(i);
+        }
+        assert_eq!(32, b.capacity());
+        let a = b.finish();
+        assert_eq!(80, a.len());
+    }
+
+    #[test]
+    fn test_builder_finish() {
+        let mut b = Int32BufferBuilder::new(5);
+        assert_eq!(16, b.capacity());
+        for i in 0..10 {
+            b.append(i);
+        }
+        let mut a = b.finish();
+        assert_eq!(40, a.len());
+        assert_eq!(0, b.len());
+        assert_eq!(0, b.capacity());
+
+        // Try build another buffer after cleaning up.
+        for i in 0..20 {
+            b.append(i)
+        }
+        assert_eq!(32, b.capacity());
+        a = b.finish();
+        assert_eq!(80, a.len());
+    }
+
+    #[test]
+    fn test_reserve() {
+        let mut b = UInt8BufferBuilder::new(2);
+        assert_eq!(64, b.capacity());
+        b.reserve(64);
+        assert_eq!(64, b.capacity());
+        b.reserve(65);
+        assert_eq!(128, b.capacity());
+
+        let mut b = Int32BufferBuilder::new(2);
+        assert_eq!(16, b.capacity());
+        b.reserve(16);
+        assert_eq!(16, b.capacity());
+        b.reserve(17);
+        assert_eq!(32, b.capacity());
+    }
+
+    #[test]
+    fn test_append_slice() {
+        let mut b = UInt8BufferBuilder::new(0);
+        b.append_slice(b"Hello, ");
+        b.append_slice(b"World!");
+        let buffer = b.finish();
+        assert_eq!(13, buffer.len());
+
+        let mut b = Int32BufferBuilder::new(0);
+        b.append_slice(&[32, 54]);
+        let buffer = b.finish();
+        assert_eq!(8, buffer.len());
+    }
+
+    #[test]
+    fn test_append_values() {
+        let mut a = Int8Builder::new();
+        a.append_value(1);
+        a.append_null();
+        a.append_value(-2);
+        assert_eq!(a.len(), 3);
+
+        // append values
+        let values = &[1, 2, 3, 4];
+        let is_valid = &[true, true, false, true];
+        a.append_values(values, is_valid);
+
+        assert_eq!(a.len(), 7);
+        let array = a.finish();
+        assert_eq!(array.value(0), 1);
+        assert!(array.is_null(1));
+        assert_eq!(array.value(2), -2);
+        assert_eq!(array.value(3), 1);
+        assert_eq!(array.value(4), 2);
+        assert!(array.is_null(5));
+        assert_eq!(array.value(6), 4);
+    }
+}
diff --git a/arrow/src/array/builder/fixed_size_binary_builder.rs b/arrow-array/src/builder/fixed_size_binary_builder.rs
similarity index 56%
rename from arrow/src/array/builder/fixed_size_binary_builder.rs
rename to arrow-array/src/builder/fixed_size_binary_builder.rs
index 96f90c4cae28..0a50eb8a50e9 100644
--- a/arrow/src/array/builder/fixed_size_binary_builder.rs
+++ b/arrow-array/src/builder/fixed_size_binary_builder.rs
@@ -15,16 +15,31 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::{
-    ArrayBuilder, ArrayData, ArrayRef, FixedSizeBinaryArray, UInt8BufferBuilder,
-};
-use crate::datatypes::DataType;
-use crate::error::{ArrowError, Result};
+use crate::builder::{ArrayBuilder, UInt8BufferBuilder};
+use crate::{ArrayRef, FixedSizeBinaryArray};
+use arrow_buffer::Buffer;
+use arrow_buffer::NullBufferBuilder;
+use arrow_data::ArrayData;
+use arrow_schema::{ArrowError, DataType};
 use std::any::Any;
 use std::sync::Arc;
 
-use super::NullBufferBuilder;
-
+/// Builder for [`FixedSizeBinaryArray`]
+/// ```
+/// # use arrow_array::builder::FixedSizeBinaryBuilder;
+/// # use arrow_array::Array;
+/// #
+/// let mut builder = FixedSizeBinaryBuilder::with_capacity(3, 5);
+/// // [b"hello", null, b"arrow"]
+/// builder.append_value(b"hello").unwrap();
+/// builder.append_null();
+/// builder.append_value(b"arrow").unwrap();
+///
+/// let array = builder.finish();
+/// assert_eq!(array.value(0), b"hello");
+/// assert!(array.is_null(1));
+/// assert_eq!(array.value(2), b"arrow");
+/// ```
 #[derive(Debug)]
 pub struct FixedSizeBinaryBuilder {
     values_builder: UInt8BufferBuilder,
@@ -33,21 +48,21 @@ pub struct FixedSizeBinaryBuilder {
 }
 
 impl FixedSizeBinaryBuilder {
-    /// Creates a new [`FixedSizeBinaryBuilder`], `capacity` is the number of bytes in the values
-    /// buffer
-    pub fn new(capacity: usize, byte_width: i32) -> Self {
+    /// Creates a new [`FixedSizeBinaryBuilder`]
+    pub fn new(byte_width: i32) -> Self {
+        Self::with_capacity(1024, byte_width)
+    }
+
+    /// Creates a new [`FixedSizeBinaryBuilder`], `capacity` is the number of byte slices
+    /// that can be appended without reallocating
+    pub fn with_capacity(capacity: usize, byte_width: i32) -> Self {
         assert!(
             byte_width >= 0,
-            "value length ({}) of the array must >= 0",
-            byte_width
+            "value length ({byte_width}) of the array must >= 0"
         );
         Self {
-            values_builder: UInt8BufferBuilder::new(capacity),
-            null_buffer_builder: NullBufferBuilder::new(if byte_width > 0 {
-                capacity / byte_width as usize
-            } else {
-                0
-            }),
+            values_builder: UInt8BufferBuilder::new(capacity * byte_width as usize),
+            null_buffer_builder: NullBufferBuilder::new(capacity),
             value_length: byte_width,
         }
     }
@@ -57,10 +72,11 @@ impl FixedSizeBinaryBuilder {
     /// Automatically update the null buffer to delimit the slice appended in as a
     /// distinct value element.
     #[inline]
-    pub fn append_value(&mut self, value: impl AsRef<[u8]>) -> Result<()> {
+    pub fn append_value(&mut self, value: impl AsRef<[u8]>) -> Result<(), ArrowError> {
         if self.value_length != value.as_ref().len() as i32 {
             Err(ArrowError::InvalidArgumentError(
-                "Byte slice does not have the same length as FixedSizeBinaryBuilder value lengths".to_string()
+                "Byte slice does not have the same length as FixedSizeBinaryBuilder value lengths"
+                    .to_string(),
             ))
         } else {
             self.values_builder.append_slice(value.as_ref());
@@ -80,11 +96,22 @@ impl FixedSizeBinaryBuilder {
     /// Builds the [`FixedSizeBinaryArray`] and reset this builder.
     pub fn finish(&mut self) -> FixedSizeBinaryArray {
         let array_length = self.len();
-        let array_data_builder =
-            ArrayData::builder(DataType::FixedSizeBinary(self.value_length))
-                .add_buffer(self.values_builder.finish())
-                .null_bit_buffer(self.null_buffer_builder.finish())
-                .len(array_length);
+        let array_data_builder = ArrayData::builder(DataType::FixedSizeBinary(self.value_length))
+            .add_buffer(self.values_builder.finish())
+            .nulls(self.null_buffer_builder.finish())
+            .len(array_length);
+        let array_data = unsafe { array_data_builder.build_unchecked() };
+        FixedSizeBinaryArray::from(array_data)
+    }
+
+    /// Builds the [`FixedSizeBinaryArray`] without resetting the builder.
+    pub fn finish_cloned(&self) -> FixedSizeBinaryArray {
+        let array_length = self.len();
+        let values_buffer = Buffer::from_slice_ref(self.values_builder.as_slice());
+        let array_data_builder = ArrayData::builder(DataType::FixedSizeBinary(self.value_length))
+            .add_buffer(values_buffer)
+            .nulls(self.null_buffer_builder.finish_cloned())
+            .len(array_length);
         let array_data = unsafe { array_data_builder.build_unchecked() };
         FixedSizeBinaryArray::from(array_data)
     }
@@ -111,28 +138,28 @@ impl ArrayBuilder for FixedSizeBinaryBuilder {
         self.null_buffer_builder.len()
     }
 
-    /// Returns whether the number of array slots is zero
-    fn is_empty(&self) -> bool {
-        self.null_buffer_builder.is_empty()
-    }
-
     /// Builds the array and reset this builder.
     fn finish(&mut self) -> ArrayRef {
         Arc::new(self.finish())
     }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
-    use crate::array::Array;
-    use crate::array::FixedSizeBinaryArray;
-    use crate::datatypes::DataType;
+    use crate::Array;
+    use crate::FixedSizeBinaryArray;
+    use arrow_schema::DataType;
 
     #[test]
     fn test_fixed_size_binary_builder() {
-        let mut builder = FixedSizeBinaryBuilder::new(15, 5);
+        let mut builder = FixedSizeBinaryBuilder::with_capacity(3, 5);
 
         //  [b"hello", null, "arrow"]
         builder.append_value(b"hello").unwrap();
@@ -147,9 +174,39 @@ mod tests {
         assert_eq!(5, array.value_length());
     }
 
+    #[test]
+    fn test_fixed_size_binary_builder_finish_cloned() {
+        let mut builder = FixedSizeBinaryBuilder::with_capacity(3, 5);
+
+        //  [b"hello", null, "arrow"]
+        builder.append_value(b"hello").unwrap();
+        builder.append_null();
+        builder.append_value(b"arrow").unwrap();
+        let mut array: FixedSizeBinaryArray = builder.finish_cloned();
+
+        assert_eq!(&DataType::FixedSizeBinary(5), array.data_type());
+        assert_eq!(3, array.len());
+        assert_eq!(1, array.null_count());
+        assert_eq!(10, array.value_offset(2));
+        assert_eq!(5, array.value_length());
+
+        //  [b"finis", null, "clone"]
+        builder.append_value(b"finis").unwrap();
+        builder.append_null();
+        builder.append_value(b"clone").unwrap();
+
+        array = builder.finish();
+
+        assert_eq!(&DataType::FixedSizeBinary(5), array.data_type());
+        assert_eq!(6, array.len());
+        assert_eq!(2, array.null_count());
+        assert_eq!(25, array.value_offset(5));
+        assert_eq!(5, array.value_length());
+    }
+
     #[test]
     fn test_fixed_size_binary_builder_with_zero_value_length() {
-        let mut builder = FixedSizeBinaryBuilder::new(0, 0);
+        let mut builder = FixedSizeBinaryBuilder::new(0);
 
         builder.append_value(b"").unwrap();
         builder.append_null();
@@ -171,12 +228,12 @@ mod tests {
         expected = "Byte slice does not have the same length as FixedSizeBinaryBuilder value lengths"
     )]
     fn test_fixed_size_binary_builder_with_inconsistent_value_length() {
-        let mut builder = FixedSizeBinaryBuilder::new(15, 4);
+        let mut builder = FixedSizeBinaryBuilder::with_capacity(1, 4);
         builder.append_value(b"hello").unwrap();
     }
     #[test]
     fn test_fixed_size_binary_builder_empty() {
-        let mut builder = FixedSizeBinaryBuilder::new(15, 5);
+        let mut builder = FixedSizeBinaryBuilder::new(5);
         assert!(builder.is_empty());
 
         let fixed_size_binary_array = builder.finish();
@@ -190,6 +247,6 @@ mod tests {
     #[test]
     #[should_panic(expected = "value length (-1) of the array must >= 0")]
     fn test_fixed_size_binary_builder_invalid_value_length() {
-        let _ = FixedSizeBinaryBuilder::new(15, -1);
+        let _ = FixedSizeBinaryBuilder::with_capacity(15, -1);
     }
 }
diff --git a/arrow/src/array/builder/fixed_size_list_builder.rs b/arrow-array/src/builder/fixed_size_list_builder.rs
similarity index 57%
rename from arrow/src/array/builder/fixed_size_list_builder.rs
rename to arrow-array/src/builder/fixed_size_list_builder.rs
index 343ce3657b31..0fe779d5c1a2 100644
--- a/arrow/src/array/builder/fixed_size_list_builder.rs
+++ b/arrow-array/src/builder/fixed_size_list_builder.rs
@@ -15,19 +15,53 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::builder::ArrayBuilder;
+use crate::{ArrayRef, FixedSizeListArray};
+use arrow_buffer::NullBufferBuilder;
+use arrow_data::ArrayData;
+use arrow_schema::{DataType, Field};
 use std::any::Any;
 use std::sync::Arc;
 
-use crate::array::ArrayData;
-use crate::array::ArrayRef;
-use crate::array::FixedSizeListArray;
-use crate::datatypes::DataType;
-use crate::datatypes::Field;
-
-use super::ArrayBuilder;
-use super::NullBufferBuilder;
-
-///  Array builder for [`FixedSizeListArray`]
+///  Builder for [`FixedSizeListArray`]
+/// ```
+/// use arrow_array::{builder::{Int32Builder, FixedSizeListBuilder}, Array, Int32Array};
+/// let values_builder = Int32Builder::new();
+/// let mut builder = FixedSizeListBuilder::new(values_builder, 3);
+///
+/// //  [[0, 1, 2], null, [3, null, 5], [6, 7, null]]
+/// builder.values().append_value(0);
+/// builder.values().append_value(1);
+/// builder.values().append_value(2);
+/// builder.append(true);
+/// builder.values().append_null();
+/// builder.values().append_null();
+/// builder.values().append_null();
+/// builder.append(false);
+/// builder.values().append_value(3);
+/// builder.values().append_null();
+/// builder.values().append_value(5);
+/// builder.append(true);
+/// builder.values().append_value(6);
+/// builder.values().append_value(7);
+/// builder.values().append_null();
+/// builder.append(true);
+/// let list_array = builder.finish();
+/// assert_eq!(
+///     *list_array.value(0),
+///     Int32Array::from(vec![Some(0), Some(1), Some(2)])
+/// );
+/// assert!(list_array.is_null(1));
+/// assert_eq!(
+///     *list_array.value(2),
+///     Int32Array::from(vec![Some(3), None, Some(5)])
+/// );
+/// assert_eq!(
+///     *list_array.value(3),
+///     Int32Array::from(vec![Some(6), Some(7), None])
+/// )
+/// ```
+///
 #[derive(Debug)]
 pub struct FixedSizeListBuilder<T: ArrayBuilder> {
     null_buffer_builder: NullBufferBuilder,
@@ -39,7 +73,11 @@ impl<T: ArrayBuilder> FixedSizeListBuilder<T> {
     /// Creates a new [`FixedSizeListBuilder`] from a given values array builder
     /// `value_length` is the number of values within each array
     pub fn new(values_builder: T, value_length: i32) -> Self {
-        let capacity = values_builder.len();
+        let capacity = values_builder
+            .len()
+            .checked_div(value_length as _)
+            .unwrap_or_default();
+
         Self::with_capacity(values_builder, value_length, capacity)
     }
 
@@ -79,15 +117,15 @@ where
         self.null_buffer_builder.len()
     }
 
-    /// Returns whether the number of array slots is zero
-    fn is_empty(&self) -> bool {
-        self.null_buffer_builder.is_empty()
-    }
-
     /// Builds the array and reset this builder.
     fn finish(&mut self) -> ArrayRef {
         Arc::new(self.finish())
     }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
 }
 
 impl<T: ArrayBuilder> FixedSizeListBuilder<T>
@@ -102,6 +140,7 @@ where
         &mut self.values_builder
     }
 
+    /// Returns the length of the list
     pub fn value_length(&self) -> i32 {
         self.list_len
     }
@@ -115,30 +154,53 @@ where
     /// Builds the [`FixedSizeListBuilder`] and reset this builder.
     pub fn finish(&mut self) -> FixedSizeListArray {
         let len = self.len();
-        let values_arr = self
-            .values_builder
-            .as_any_mut()
-            .downcast_mut::<T>()
-            .unwrap()
-            .finish();
-        let values_data = values_arr.data();
-
-        assert!(
-            values_data.len() == len * self.list_len as usize,
+        let values_arr = self.values_builder.finish();
+        let values_data = values_arr.to_data();
+
+        assert_eq!(
+            values_data.len(), len * self.list_len as usize,
             "Length of the child array ({}) must be the multiple of the value length ({}) and the array length ({}).",
             values_data.len(),
             self.list_len,
             len,
         );
 
-        let null_bit_buffer = self.null_buffer_builder.finish();
+        let nulls = self.null_buffer_builder.finish();
         let array_data = ArrayData::builder(DataType::FixedSizeList(
-            Box::new(Field::new("item", values_data.data_type().clone(), true)),
+            Arc::new(Field::new("item", values_data.data_type().clone(), true)),
             self.list_len,
         ))
         .len(len)
-        .add_child_data(values_data.clone())
-        .null_bit_buffer(null_bit_buffer);
+        .add_child_data(values_data)
+        .nulls(nulls);
+
+        let array_data = unsafe { array_data.build_unchecked() };
+
+        FixedSizeListArray::from(array_data)
+    }
+
+    /// Builds the [`FixedSizeListBuilder`] without resetting the builder.
+    pub fn finish_cloned(&self) -> FixedSizeListArray {
+        let len = self.len();
+        let values_arr = self.values_builder.finish_cloned();
+        let values_data = values_arr.to_data();
+
+        assert_eq!(
+            values_data.len(), len * self.list_len as usize,
+            "Length of the child array ({}) must be the multiple of the value length ({}) and the array length ({}).",
+            values_data.len(),
+            self.list_len,
+            len,
+        );
+
+        let nulls = self.null_buffer_builder.finish_cloned();
+        let array_data = ArrayData::builder(DataType::FixedSizeList(
+            Arc::new(Field::new("item", values_data.data_type().clone(), true)),
+            self.list_len,
+        ))
+        .len(len)
+        .add_child_data(values_data)
+        .nulls(nulls);
 
         let array_data = unsafe { array_data.build_unchecked() };
 
@@ -150,13 +212,13 @@ where
 mod tests {
     use super::*;
 
-    use crate::array::Array;
-    use crate::array::Int32Array;
-    use crate::array::Int32Builder;
+    use crate::builder::Int32Builder;
+    use crate::Array;
+    use crate::Int32Array;
 
     #[test]
     fn test_fixed_size_list_array_builder() {
-        let values_builder = Int32Builder::new(10);
+        let values_builder = Int32Builder::new();
         let mut builder = FixedSizeListBuilder::new(values_builder, 3);
 
         //  [[0, 1, 2], null, [3, null, 5], [6, 7, null]]
@@ -185,6 +247,48 @@ mod tests {
         assert_eq!(3, list_array.value_length());
     }
 
+    #[test]
+    fn test_fixed_size_list_array_builder_finish_cloned() {
+        let values_builder = Int32Builder::new();
+        let mut builder = FixedSizeListBuilder::new(values_builder, 3);
+
+        //  [[0, 1, 2], null, [3, null, 5], [6, 7, null]]
+        builder.values().append_value(0);
+        builder.values().append_value(1);
+        builder.values().append_value(2);
+        builder.append(true);
+        builder.values().append_null();
+        builder.values().append_null();
+        builder.values().append_null();
+        builder.append(false);
+        builder.values().append_value(3);
+        builder.values().append_null();
+        builder.values().append_value(5);
+        builder.append(true);
+        let mut list_array = builder.finish_cloned();
+
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(3, list_array.len());
+        assert_eq!(1, list_array.null_count());
+        assert_eq!(3, list_array.value_length());
+
+        builder.values().append_value(6);
+        builder.values().append_value(7);
+        builder.values().append_null();
+        builder.append(true);
+        builder.values().append_null();
+        builder.values().append_null();
+        builder.values().append_null();
+        builder.append(false);
+        list_array = builder.finish();
+
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(5, list_array.len());
+        assert_eq!(2, list_array.null_count());
+        assert_eq!(6, list_array.value_offset(2));
+        assert_eq!(3, list_array.value_length());
+    }
+
     #[test]
     fn test_fixed_size_list_array_builder_empty() {
         let values_builder = Int32Array::builder(5);
diff --git a/arrow-array/src/builder/generic_byte_run_builder.rs b/arrow-array/src/builder/generic_byte_run_builder.rs
new file mode 100644
index 000000000000..3cde76c4a039
--- /dev/null
+++ b/arrow-array/src/builder/generic_byte_run_builder.rs
@@ -0,0 +1,514 @@
+// 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.
+
+use crate::types::bytes::ByteArrayNativeType;
+use std::{any::Any, sync::Arc};
+
+use crate::{
+    types::{BinaryType, ByteArrayType, LargeBinaryType, LargeUtf8Type, RunEndIndexType, Utf8Type},
+    ArrayRef, ArrowPrimitiveType, RunArray,
+};
+
+use super::{ArrayBuilder, GenericByteBuilder, PrimitiveBuilder};
+
+use arrow_buffer::ArrowNativeType;
+
+/// Builder for [`RunArray`] of [`GenericByteArray`](crate::array::GenericByteArray)
+///
+/// # Example:
+///
+/// ```
+///
+/// # use arrow_array::builder::GenericByteRunBuilder;
+/// # use arrow_array::{GenericByteArray, BinaryArray};
+/// # use arrow_array::types::{BinaryType, Int16Type};
+/// # use arrow_array::{Array, Int16Array};
+/// # use arrow_array::cast::AsArray;
+///
+/// let mut builder =
+/// GenericByteRunBuilder::<Int16Type, BinaryType>::new();
+/// builder.extend([Some(b"abc"), Some(b"abc"), None, Some(b"def")].into_iter());
+/// builder.append_value(b"def");
+/// builder.append_null();
+/// let array = builder.finish();
+///
+/// assert_eq!(array.run_ends().values(), &[2, 3, 5, 6]);
+///
+/// let av = array.values();
+///
+/// assert!(!av.is_null(0));
+/// assert!(av.is_null(1));
+/// assert!(!av.is_null(2));
+/// assert!(av.is_null(3));
+///
+/// // Values are polymorphic and so require a downcast.
+/// let ava: &BinaryArray = av.as_binary();
+///
+/// assert_eq!(ava.value(0), b"abc");
+/// assert_eq!(ava.value(2), b"def");
+/// ```
+#[derive(Debug)]
+pub struct GenericByteRunBuilder<R, V>
+where
+    R: ArrowPrimitiveType,
+    V: ByteArrayType,
+{
+    run_ends_builder: PrimitiveBuilder<R>,
+    values_builder: GenericByteBuilder<V>,
+    current_value: Vec<u8>,
+    has_current_value: bool,
+    current_run_end_index: usize,
+    prev_run_end_index: usize,
+}
+
+impl<R, V> Default for GenericByteRunBuilder<R, V>
+where
+    R: ArrowPrimitiveType,
+    V: ByteArrayType,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<R, V> GenericByteRunBuilder<R, V>
+where
+    R: ArrowPrimitiveType,
+    V: ByteArrayType,
+{
+    /// Creates a new `GenericByteRunBuilder`
+    pub fn new() -> Self {
+        Self {
+            run_ends_builder: PrimitiveBuilder::new(),
+            values_builder: GenericByteBuilder::<V>::new(),
+            current_value: Vec::new(),
+            has_current_value: false,
+            current_run_end_index: 0,
+            prev_run_end_index: 0,
+        }
+    }
+
+    /// Creates a new `GenericByteRunBuilder` with the provided capacity
+    ///
+    /// `capacity`: the expected number of run-end encoded values.
+    /// `data_capacity`: the expected number of bytes of run end encoded values
+    pub fn with_capacity(capacity: usize, data_capacity: usize) -> Self {
+        Self {
+            run_ends_builder: PrimitiveBuilder::with_capacity(capacity),
+            values_builder: GenericByteBuilder::<V>::with_capacity(capacity, data_capacity),
+            current_value: Vec::new(),
+            has_current_value: false,
+            current_run_end_index: 0,
+            prev_run_end_index: 0,
+        }
+    }
+}
+
+impl<R, V> ArrayBuilder for GenericByteRunBuilder<R, V>
+where
+    R: RunEndIndexType,
+    V: ByteArrayType,
+{
+    /// Returns the builder as a non-mutable `Any` reference.
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// Returns the builder as a mutable `Any` reference.
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    /// Returns the boxed builder as a box of `Any`.
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    /// Returns the length of logical array encoded by
+    /// the eventual runs array.
+    fn len(&self) -> usize {
+        self.current_run_end_index
+    }
+
+    /// Builds the array and reset this builder.
+    fn finish(&mut self) -> ArrayRef {
+        Arc::new(self.finish())
+    }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+}
+
+impl<R, V> GenericByteRunBuilder<R, V>
+where
+    R: RunEndIndexType,
+    V: ByteArrayType,
+{
+    /// Appends optional value to the logical array encoded by the RunArray.
+    pub fn append_option(&mut self, input_value: Option<impl AsRef<V::Native>>) {
+        match input_value {
+            Some(value) => self.append_value(value),
+            None => self.append_null(),
+        }
+    }
+
+    /// Appends value to the logical array encoded by the RunArray.
+    pub fn append_value(&mut self, input_value: impl AsRef<V::Native>) {
+        let value: &[u8] = input_value.as_ref().as_ref();
+        if !self.has_current_value {
+            self.append_run_end();
+            self.current_value.extend_from_slice(value);
+            self.has_current_value = true;
+        } else if self.current_value.as_slice() != value {
+            self.append_run_end();
+            self.current_value.clear();
+            self.current_value.extend_from_slice(value);
+        }
+        self.current_run_end_index += 1;
+    }
+
+    /// Appends null to the logical array encoded by the RunArray.
+    pub fn append_null(&mut self) {
+        if self.has_current_value {
+            self.append_run_end();
+            self.current_value.clear();
+            self.has_current_value = false;
+        }
+        self.current_run_end_index += 1;
+    }
+
+    /// Creates the RunArray and resets the builder.
+    /// Panics if RunArray cannot be built.
+    pub fn finish(&mut self) -> RunArray<R> {
+        // write the last run end to the array.
+        self.append_run_end();
+
+        // reset the run end index to zero.
+        self.current_value.clear();
+        self.has_current_value = false;
+        self.current_run_end_index = 0;
+        self.prev_run_end_index = 0;
+
+        // build the run encoded array by adding run_ends and values array as its children.
+        let run_ends_array = self.run_ends_builder.finish();
+        let values_array = self.values_builder.finish();
+        RunArray::<R>::try_new(&run_ends_array, &values_array).unwrap()
+    }
+
+    /// Creates the RunArray and without resetting the builder.
+    /// Panics if RunArray cannot be built.
+    pub fn finish_cloned(&self) -> RunArray<R> {
+        let mut run_ends_array = self.run_ends_builder.finish_cloned();
+        let mut values_array = self.values_builder.finish_cloned();
+
+        // Add current run if one exists
+        if self.prev_run_end_index != self.current_run_end_index {
+            let mut run_end_builder = run_ends_array.into_builder().unwrap();
+            let mut values_builder = values_array.into_builder().unwrap();
+            self.append_run_end_with_builders(&mut run_end_builder, &mut values_builder);
+            run_ends_array = run_end_builder.finish();
+            values_array = values_builder.finish();
+        }
+
+        RunArray::<R>::try_new(&run_ends_array, &values_array).unwrap()
+    }
+
+    // Appends the current run to the array.
+    fn append_run_end(&mut self) {
+        // empty array or the function called without appending any value.
+        if self.prev_run_end_index == self.current_run_end_index {
+            return;
+        }
+        let run_end_index = self.run_end_index_as_native();
+        self.run_ends_builder.append_value(run_end_index);
+        if self.has_current_value {
+            let slice = self.current_value.as_slice();
+            let native = unsafe {
+                // Safety:
+                // As self.current_value is created from V::Native. The value V::Native can be
+                // built back from the bytes without validations
+                V::Native::from_bytes_unchecked(slice)
+            };
+            self.values_builder.append_value(native);
+        } else {
+            self.values_builder.append_null();
+        }
+        self.prev_run_end_index = self.current_run_end_index;
+    }
+
+    // Similar to `append_run_end` but on custom builders.
+    // Used in `finish_cloned` which is not suppose to mutate `self`.
+    fn append_run_end_with_builders(
+        &self,
+        run_ends_builder: &mut PrimitiveBuilder<R>,
+        values_builder: &mut GenericByteBuilder<V>,
+    ) {
+        let run_end_index = self.run_end_index_as_native();
+        run_ends_builder.append_value(run_end_index);
+        if self.has_current_value {
+            let slice = self.current_value.as_slice();
+            let native = unsafe {
+                // Safety:
+                // As self.current_value is created from V::Native. The value V::Native can be
+                // built back from the bytes without validations
+                V::Native::from_bytes_unchecked(slice)
+            };
+            values_builder.append_value(native);
+        } else {
+            values_builder.append_null();
+        }
+    }
+
+    fn run_end_index_as_native(&self) -> R::Native {
+        R::Native::from_usize(self.current_run_end_index).unwrap_or_else(|| {
+            panic!(
+                "Cannot convert the value {} from `usize` to native form of arrow datatype {}",
+                self.current_run_end_index,
+                R::DATA_TYPE
+            )
+        })
+    }
+}
+
+impl<R, V, S> Extend<Option<S>> for GenericByteRunBuilder<R, V>
+where
+    R: RunEndIndexType,
+    V: ByteArrayType,
+    S: AsRef<V::Native>,
+{
+    fn extend<T: IntoIterator<Item = Option<S>>>(&mut self, iter: T) {
+        for elem in iter {
+            self.append_option(elem);
+        }
+    }
+}
+
+/// Builder for [`RunArray`] of [`StringArray`](crate::array::StringArray)
+///
+/// ```
+/// // Create a run-end encoded array with run-end indexes data type as `i16`.
+/// // The encoded values are Strings.
+///
+/// # use arrow_array::builder::StringRunBuilder;
+/// # use arrow_array::{Int16Array, StringArray};
+/// # use arrow_array::types::Int16Type;
+/// # use arrow_array::cast::AsArray;
+/// #
+/// let mut builder = StringRunBuilder::<Int16Type>::new();
+///
+/// // The builder builds the dictionary value by value
+/// builder.append_value("abc");
+/// builder.append_null();
+/// builder.extend([Some("def"), Some("def"), Some("abc")]);
+/// let array = builder.finish();
+///
+/// assert_eq!(array.run_ends().values(), &[1, 2, 4, 5]);
+///
+/// // Values are polymorphic and so require a downcast.
+/// let av = array.values();
+/// let ava: &StringArray = av.as_string::<i32>();
+///
+/// assert_eq!(ava.value(0), "abc");
+/// assert!(av.is_null(1));
+/// assert_eq!(ava.value(2), "def");
+/// assert_eq!(ava.value(3), "abc");
+///
+/// ```
+pub type StringRunBuilder<K> = GenericByteRunBuilder<K, Utf8Type>;
+
+/// Builder for [`RunArray`] of [`LargeStringArray`](crate::array::LargeStringArray)
+pub type LargeStringRunBuilder<K> = GenericByteRunBuilder<K, LargeUtf8Type>;
+
+/// Builder for [`RunArray`] of [`BinaryArray`](crate::array::BinaryArray)
+///
+/// ```
+/// // Create a run-end encoded array with run-end indexes data type as `i16`.
+/// // The encoded data is binary values.
+///
+/// # use arrow_array::builder::BinaryRunBuilder;
+/// # use arrow_array::{BinaryArray, Int16Array};
+/// # use arrow_array::cast::AsArray;
+/// # use arrow_array::types::Int16Type;
+///
+/// let mut builder = BinaryRunBuilder::<Int16Type>::new();
+///
+/// // The builder builds the dictionary value by value
+/// builder.append_value(b"abc");
+/// builder.append_null();
+/// builder.extend([Some(b"def"), Some(b"def"), Some(b"abc")]);
+/// let array = builder.finish();
+///
+/// assert_eq!(array.run_ends().values(), &[1, 2, 4, 5]);
+///
+/// // Values are polymorphic and so require a downcast.
+/// let av = array.values();
+/// let ava: &BinaryArray = av.as_binary();
+///
+/// assert_eq!(ava.value(0), b"abc");
+/// assert!(av.is_null(1));
+/// assert_eq!(ava.value(2), b"def");
+/// assert_eq!(ava.value(3), b"abc");
+///
+/// ```
+pub type BinaryRunBuilder<K> = GenericByteRunBuilder<K, BinaryType>;
+
+/// Builder for [`RunArray`] of [`LargeBinaryArray`](crate::array::LargeBinaryArray)
+pub type LargeBinaryRunBuilder<K> = GenericByteRunBuilder<K, LargeBinaryType>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::array::Array;
+    use crate::cast::AsArray;
+    use crate::types::{Int16Type, Int32Type};
+    use crate::GenericByteArray;
+    use crate::Int16RunArray;
+
+    fn test_bytes_run_builder<T>(values: Vec<&T::Native>)
+    where
+        T: ByteArrayType,
+        <T as ByteArrayType>::Native: PartialEq,
+        <T as ByteArrayType>::Native: AsRef<<T as ByteArrayType>::Native>,
+    {
+        let mut builder = GenericByteRunBuilder::<Int16Type, T>::new();
+        builder.append_value(values[0]);
+        builder.append_value(values[0]);
+        builder.append_value(values[0]);
+        builder.append_null();
+        builder.append_null();
+        builder.append_value(values[1]);
+        builder.append_value(values[1]);
+        builder.append_value(values[2]);
+        builder.append_value(values[2]);
+        builder.append_value(values[2]);
+        builder.append_value(values[2]);
+        let array = builder.finish();
+
+        assert_eq!(array.len(), 11);
+        assert_eq!(array.null_count(), 0);
+
+        assert_eq!(array.run_ends().values(), &[3, 5, 7, 11]);
+
+        // Values are polymorphic and so require a downcast.
+        let av = array.values();
+        let ava: &GenericByteArray<T> = av.as_any().downcast_ref::<GenericByteArray<T>>().unwrap();
+
+        assert_eq!(*ava.value(0), *values[0]);
+        assert!(ava.is_null(1));
+        assert_eq!(*ava.value(2), *values[1]);
+        assert_eq!(*ava.value(3), *values[2]);
+    }
+
+    #[test]
+    fn test_string_run_builder() {
+        test_bytes_run_builder::<Utf8Type>(vec!["abc", "def", "ghi"]);
+    }
+
+    #[test]
+    fn test_string_run_builder_with_empty_strings() {
+        test_bytes_run_builder::<Utf8Type>(vec!["abc", "", "ghi"]);
+    }
+
+    #[test]
+    fn test_binary_run_builder() {
+        test_bytes_run_builder::<BinaryType>(vec![b"abc", b"def", b"ghi"]);
+    }
+
+    fn test_bytes_run_builder_finish_cloned<T>(values: Vec<&T::Native>)
+    where
+        T: ByteArrayType,
+        <T as ByteArrayType>::Native: PartialEq,
+        <T as ByteArrayType>::Native: AsRef<<T as ByteArrayType>::Native>,
+    {
+        let mut builder = GenericByteRunBuilder::<Int16Type, T>::new();
+
+        builder.append_value(values[0]);
+        builder.append_null();
+        builder.append_value(values[1]);
+        builder.append_value(values[1]);
+        builder.append_value(values[0]);
+        let mut array: Int16RunArray = builder.finish_cloned();
+
+        assert_eq!(array.len(), 5);
+        assert_eq!(array.null_count(), 0);
+
+        assert_eq!(array.run_ends().values(), &[1, 2, 4, 5]);
+
+        // Values are polymorphic and so require a downcast.
+        let av = array.values();
+        let ava: &GenericByteArray<T> = av.as_any().downcast_ref::<GenericByteArray<T>>().unwrap();
+
+        assert_eq!(ava.value(0), values[0]);
+        assert!(ava.is_null(1));
+        assert_eq!(ava.value(2), values[1]);
+        assert_eq!(ava.value(3), values[0]);
+
+        // Append last value before `finish_cloned` (`value[0]`) again and ensure it has only
+        // one entry in final output.
+        builder.append_value(values[0]);
+        builder.append_value(values[0]);
+        builder.append_value(values[1]);
+        array = builder.finish();
+
+        assert_eq!(array.len(), 8);
+        assert_eq!(array.null_count(), 0);
+
+        assert_eq!(array.run_ends().values(), &[1, 2, 4, 7, 8]);
+
+        // Values are polymorphic and so require a downcast.
+        let av2 = array.values();
+        let ava2: &GenericByteArray<T> =
+            av2.as_any().downcast_ref::<GenericByteArray<T>>().unwrap();
+
+        assert_eq!(ava2.value(0), values[0]);
+        assert!(ava2.is_null(1));
+        assert_eq!(ava2.value(2), values[1]);
+        // The value appended before and after `finish_cloned` has only one entry.
+        assert_eq!(ava2.value(3), values[0]);
+        assert_eq!(ava2.value(4), values[1]);
+    }
+
+    #[test]
+    fn test_string_run_builder_finish_cloned() {
+        test_bytes_run_builder_finish_cloned::<Utf8Type>(vec!["abc", "def", "ghi"]);
+    }
+
+    #[test]
+    fn test_binary_run_builder_finish_cloned() {
+        test_bytes_run_builder_finish_cloned::<BinaryType>(vec![b"abc", b"def", b"ghi"]);
+    }
+
+    #[test]
+    fn test_extend() {
+        let mut builder = StringRunBuilder::<Int32Type>::new();
+        builder.extend(["a", "a", "a", "", "", "b", "b"].into_iter().map(Some));
+        builder.extend(["b", "cupcakes", "cupcakes"].into_iter().map(Some));
+        let array = builder.finish();
+
+        assert_eq!(array.len(), 10);
+        assert_eq!(array.run_ends().values(), &[3, 5, 8, 10]);
+
+        let str_array = array.values().as_string::<i32>();
+        assert_eq!(str_array.value(0), "a");
+        assert_eq!(str_array.value(1), "");
+        assert_eq!(str_array.value(2), "b");
+        assert_eq!(str_array.value(3), "cupcakes");
+    }
+}
diff --git a/arrow-array/src/builder/generic_bytes_builder.rs b/arrow-array/src/builder/generic_bytes_builder.rs
new file mode 100644
index 000000000000..2c7ee7a3e448
--- /dev/null
+++ b/arrow-array/src/builder/generic_bytes_builder.rs
@@ -0,0 +1,482 @@
+// 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.
+
+use crate::builder::{ArrayBuilder, BufferBuilder, UInt8BufferBuilder};
+use crate::types::{ByteArrayType, GenericBinaryType, GenericStringType};
+use crate::{ArrayRef, GenericByteArray, OffsetSizeTrait};
+use arrow_buffer::NullBufferBuilder;
+use arrow_buffer::{ArrowNativeType, Buffer, MutableBuffer};
+use arrow_data::ArrayDataBuilder;
+use std::any::Any;
+use std::fmt::Write;
+use std::sync::Arc;
+
+/// Builder for [`GenericByteArray`]
+pub struct GenericByteBuilder<T: ByteArrayType> {
+    value_builder: UInt8BufferBuilder,
+    offsets_builder: BufferBuilder<T::Offset>,
+    null_buffer_builder: NullBufferBuilder,
+}
+
+impl<T: ByteArrayType> GenericByteBuilder<T> {
+    /// Creates a new [`GenericByteBuilder`].
+    pub fn new() -> Self {
+        Self::with_capacity(1024, 1024)
+    }
+
+    /// Creates a new [`GenericByteBuilder`].
+    ///
+    /// - `item_capacity` is the number of items to pre-allocate.
+    ///   The size of the preallocated buffer of offsets is the number of items plus one.
+    /// - `data_capacity` is the total number of bytes of data to pre-allocate
+    ///   (for all items, not per item).
+    pub fn with_capacity(item_capacity: usize, data_capacity: usize) -> Self {
+        let mut offsets_builder = BufferBuilder::<T::Offset>::new(item_capacity + 1);
+        offsets_builder.append(T::Offset::from_usize(0).unwrap());
+        Self {
+            value_builder: UInt8BufferBuilder::new(data_capacity),
+            offsets_builder,
+            null_buffer_builder: NullBufferBuilder::new(item_capacity),
+        }
+    }
+
+    /// Creates a new  [`GenericByteBuilder`] from buffers.
+    ///
+    /// # Safety
+    /// This doesn't verify buffer contents as it assumes the buffers are from existing and
+    /// valid [`GenericByteArray`].
+    pub unsafe fn new_from_buffer(
+        offsets_buffer: MutableBuffer,
+        value_buffer: MutableBuffer,
+        null_buffer: Option<MutableBuffer>,
+    ) -> Self {
+        let offsets_builder = BufferBuilder::<T::Offset>::new_from_buffer(offsets_buffer);
+        let value_builder = BufferBuilder::<u8>::new_from_buffer(value_buffer);
+
+        let null_buffer_builder = null_buffer
+            .map(|buffer| NullBufferBuilder::new_from_buffer(buffer, offsets_builder.len() - 1))
+            .unwrap_or_else(|| NullBufferBuilder::new_with_len(offsets_builder.len() - 1));
+
+        Self {
+            offsets_builder,
+            value_builder,
+            null_buffer_builder,
+        }
+    }
+
+    #[inline]
+    fn next_offset(&self) -> T::Offset {
+        T::Offset::from_usize(self.value_builder.len()).expect("byte array offset overflow")
+    }
+
+    /// Appends a value into the builder.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the resulting length of [`Self::values_slice`] would exceed `T::Offset::MAX`
+    #[inline]
+    pub fn append_value(&mut self, value: impl AsRef<T::Native>) {
+        self.value_builder.append_slice(value.as_ref().as_ref());
+        self.null_buffer_builder.append(true);
+        self.offsets_builder.append(self.next_offset());
+    }
+
+    /// Append an `Option` value into the builder.
+    #[inline]
+    pub fn append_option(&mut self, value: Option<impl AsRef<T::Native>>) {
+        match value {
+            None => self.append_null(),
+            Some(v) => self.append_value(v),
+        };
+    }
+
+    /// Append a null value into the builder.
+    #[inline]
+    pub fn append_null(&mut self) {
+        self.null_buffer_builder.append(false);
+        self.offsets_builder.append(self.next_offset());
+    }
+
+    /// Builds the [`GenericByteArray`] and reset this builder.
+    pub fn finish(&mut self) -> GenericByteArray<T> {
+        let array_type = T::DATA_TYPE;
+        let array_builder = ArrayDataBuilder::new(array_type)
+            .len(self.len())
+            .add_buffer(self.offsets_builder.finish())
+            .add_buffer(self.value_builder.finish())
+            .nulls(self.null_buffer_builder.finish());
+
+        self.offsets_builder.append(self.next_offset());
+        let array_data = unsafe { array_builder.build_unchecked() };
+        GenericByteArray::from(array_data)
+    }
+
+    /// Builds the [`GenericByteArray`] without resetting the builder.
+    pub fn finish_cloned(&self) -> GenericByteArray<T> {
+        let array_type = T::DATA_TYPE;
+        let offset_buffer = Buffer::from_slice_ref(self.offsets_builder.as_slice());
+        let value_buffer = Buffer::from_slice_ref(self.value_builder.as_slice());
+        let array_builder = ArrayDataBuilder::new(array_type)
+            .len(self.len())
+            .add_buffer(offset_buffer)
+            .add_buffer(value_buffer)
+            .nulls(self.null_buffer_builder.finish_cloned());
+
+        let array_data = unsafe { array_builder.build_unchecked() };
+        GenericByteArray::from(array_data)
+    }
+
+    /// Returns the current values buffer as a slice
+    pub fn values_slice(&self) -> &[u8] {
+        self.value_builder.as_slice()
+    }
+
+    /// Returns the current offsets buffer as a slice
+    pub fn offsets_slice(&self) -> &[T::Offset] {
+        self.offsets_builder.as_slice()
+    }
+
+    /// Returns the current null buffer as a slice
+    pub fn validity_slice(&self) -> Option<&[u8]> {
+        self.null_buffer_builder.as_slice()
+    }
+
+    /// Returns the current null buffer as a mutable slice
+    pub fn validity_slice_mut(&mut self) -> Option<&mut [u8]> {
+        self.null_buffer_builder.as_slice_mut()
+    }
+}
+
+impl<T: ByteArrayType> std::fmt::Debug for GenericByteBuilder<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}{}Builder", T::Offset::PREFIX, T::PREFIX)?;
+        f.debug_struct("")
+            .field("value_builder", &self.value_builder)
+            .field("offsets_builder", &self.offsets_builder)
+            .field("null_buffer_builder", &self.null_buffer_builder)
+            .finish()
+    }
+}
+
+impl<T: ByteArrayType> Default for GenericByteBuilder<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<T: ByteArrayType> ArrayBuilder for GenericByteBuilder<T> {
+    /// Returns the number of binary slots in the builder
+    fn len(&self) -> usize {
+        self.null_buffer_builder.len()
+    }
+
+    /// Builds the array and reset this builder.
+    fn finish(&mut self) -> ArrayRef {
+        Arc::new(self.finish())
+    }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+
+    /// Returns the builder as a non-mutable `Any` reference.
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// Returns the builder as a mutable `Any` reference.
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    /// Returns the boxed builder as a box of `Any`.
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+}
+
+impl<T: ByteArrayType, V: AsRef<T::Native>> Extend<Option<V>> for GenericByteBuilder<T> {
+    #[inline]
+    fn extend<I: IntoIterator<Item = Option<V>>>(&mut self, iter: I) {
+        for v in iter {
+            self.append_option(v)
+        }
+    }
+}
+
+/// Array builder for [`GenericStringArray`][crate::GenericStringArray]
+///
+/// Values can be appended using [`GenericByteBuilder::append_value`], and nulls with
+/// [`GenericByteBuilder::append_null`] as normal.
+///
+/// Additionally implements [`std::fmt::Write`] with any written data included in the next
+/// appended value. This allows use with [`std::fmt::Display`] without intermediate allocations
+///
+/// ```
+/// # use std::fmt::Write;
+/// # use arrow_array::builder::GenericStringBuilder;
+/// let mut builder = GenericStringBuilder::<i32>::new();
+///
+/// // Write data
+/// write!(builder, "foo").unwrap();
+/// write!(builder, "bar").unwrap();
+///
+/// // Finish value
+/// builder.append_value("baz");
+///
+/// // Write second value
+/// write!(builder, "v2").unwrap();
+/// builder.append_value("");
+///
+/// let array = builder.finish();
+/// assert_eq!(array.value(0), "foobarbaz");
+/// assert_eq!(array.value(1), "v2");
+/// ```
+pub type GenericStringBuilder<O> = GenericByteBuilder<GenericStringType<O>>;
+
+impl<O: OffsetSizeTrait> Write for GenericStringBuilder<O> {
+    fn write_str(&mut self, s: &str) -> std::fmt::Result {
+        self.value_builder.append_slice(s.as_bytes());
+        Ok(())
+    }
+}
+
+///  Array builder for [`GenericBinaryArray`][crate::GenericBinaryArray]
+pub type GenericBinaryBuilder<O> = GenericByteBuilder<GenericBinaryType<O>>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::array::{Array, OffsetSizeTrait};
+    use crate::GenericStringArray;
+
+    fn _test_generic_binary_builder<O: OffsetSizeTrait>() {
+        let mut builder = GenericBinaryBuilder::<O>::new();
+
+        builder.append_value(b"hello");
+        builder.append_value(b"");
+        builder.append_null();
+        builder.append_value(b"rust");
+
+        let array = builder.finish();
+
+        assert_eq!(4, array.len());
+        assert_eq!(1, array.null_count());
+        assert_eq!(b"hello", array.value(0));
+        assert_eq!([] as [u8; 0], array.value(1));
+        assert!(array.is_null(2));
+        assert_eq!(b"rust", array.value(3));
+        assert_eq!(O::from_usize(5).unwrap(), array.value_offsets()[2]);
+        assert_eq!(O::from_usize(4).unwrap(), array.value_length(3));
+    }
+
+    #[test]
+    fn test_binary_builder() {
+        _test_generic_binary_builder::<i32>()
+    }
+
+    #[test]
+    fn test_large_binary_builder() {
+        _test_generic_binary_builder::<i64>()
+    }
+
+    fn _test_generic_binary_builder_all_nulls<O: OffsetSizeTrait>() {
+        let mut builder = GenericBinaryBuilder::<O>::new();
+        builder.append_null();
+        builder.append_null();
+        builder.append_null();
+        assert_eq!(3, builder.len());
+        assert!(!builder.is_empty());
+
+        let array = builder.finish();
+        assert_eq!(3, array.null_count());
+        assert_eq!(3, array.len());
+        assert!(array.is_null(0));
+        assert!(array.is_null(1));
+        assert!(array.is_null(2));
+    }
+
+    #[test]
+    fn test_binary_builder_all_nulls() {
+        _test_generic_binary_builder_all_nulls::<i32>()
+    }
+
+    #[test]
+    fn test_large_binary_builder_all_nulls() {
+        _test_generic_binary_builder_all_nulls::<i64>()
+    }
+
+    fn _test_generic_binary_builder_reset<O: OffsetSizeTrait>() {
+        let mut builder = GenericBinaryBuilder::<O>::new();
+
+        builder.append_value(b"hello");
+        builder.append_value(b"");
+        builder.append_null();
+        builder.append_value(b"rust");
+        builder.finish();
+
+        assert!(builder.is_empty());
+
+        builder.append_value(b"parquet");
+        builder.append_null();
+        builder.append_value(b"arrow");
+        builder.append_value(b"");
+        let array = builder.finish();
+
+        assert_eq!(4, array.len());
+        assert_eq!(1, array.null_count());
+        assert_eq!(b"parquet", array.value(0));
+        assert!(array.is_null(1));
+        assert_eq!(b"arrow", array.value(2));
+        assert_eq!(b"", array.value(1));
+        assert_eq!(O::zero(), array.value_offsets()[0]);
+        assert_eq!(O::from_usize(7).unwrap(), array.value_offsets()[2]);
+        assert_eq!(O::from_usize(5).unwrap(), array.value_length(2));
+    }
+
+    #[test]
+    fn test_binary_builder_reset() {
+        _test_generic_binary_builder_reset::<i32>()
+    }
+
+    #[test]
+    fn test_large_binary_builder_reset() {
+        _test_generic_binary_builder_reset::<i64>()
+    }
+
+    fn _test_generic_string_array_builder<O: OffsetSizeTrait>() {
+        let mut builder = GenericStringBuilder::<O>::new();
+        let owned = "arrow".to_owned();
+
+        builder.append_value("hello");
+        builder.append_value("");
+        builder.append_value(&owned);
+        builder.append_null();
+        builder.append_option(Some("rust"));
+        builder.append_option(None::<&str>);
+        builder.append_option(None::<String>);
+        assert_eq!(7, builder.len());
+
+        assert_eq!(
+            GenericStringArray::<O>::from(vec![
+                Some("hello"),
+                Some(""),
+                Some("arrow"),
+                None,
+                Some("rust"),
+                None,
+                None
+            ]),
+            builder.finish()
+        );
+    }
+
+    #[test]
+    fn test_string_array_builder() {
+        _test_generic_string_array_builder::<i32>()
+    }
+
+    #[test]
+    fn test_large_string_array_builder() {
+        _test_generic_string_array_builder::<i64>()
+    }
+
+    fn _test_generic_string_array_builder_finish<O: OffsetSizeTrait>() {
+        let mut builder = GenericStringBuilder::<O>::with_capacity(3, 11);
+
+        builder.append_value("hello");
+        builder.append_value("rust");
+        builder.append_null();
+
+        builder.finish();
+        assert!(builder.is_empty());
+        assert_eq!(&[O::zero()], builder.offsets_slice());
+
+        builder.append_value("arrow");
+        builder.append_value("parquet");
+        let arr = builder.finish();
+        // array should not have null buffer because there is not `null` value.
+        assert!(arr.nulls().is_none());
+        assert_eq!(GenericStringArray::<O>::from(vec!["arrow", "parquet"]), arr,)
+    }
+
+    #[test]
+    fn test_string_array_builder_finish() {
+        _test_generic_string_array_builder_finish::<i32>()
+    }
+
+    #[test]
+    fn test_large_string_array_builder_finish() {
+        _test_generic_string_array_builder_finish::<i64>()
+    }
+
+    fn _test_generic_string_array_builder_finish_cloned<O: OffsetSizeTrait>() {
+        let mut builder = GenericStringBuilder::<O>::with_capacity(3, 11);
+
+        builder.append_value("hello");
+        builder.append_value("rust");
+        builder.append_null();
+
+        let mut arr = builder.finish_cloned();
+        assert!(!builder.is_empty());
+        assert_eq!(3, arr.len());
+
+        builder.append_value("arrow");
+        builder.append_value("parquet");
+        arr = builder.finish();
+
+        assert!(arr.nulls().is_some());
+        assert_eq!(&[O::zero()], builder.offsets_slice());
+        assert_eq!(5, arr.len());
+    }
+
+    #[test]
+    fn test_string_array_builder_finish_cloned() {
+        _test_generic_string_array_builder_finish_cloned::<i32>()
+    }
+
+    #[test]
+    fn test_large_string_array_builder_finish_cloned() {
+        _test_generic_string_array_builder_finish_cloned::<i64>()
+    }
+
+    #[test]
+    fn test_extend() {
+        let mut builder = GenericStringBuilder::<i32>::new();
+        builder.extend(["a", "b", "c", "", "a", "b", "c"].into_iter().map(Some));
+        builder.extend(["d", "cupcakes", "hello"].into_iter().map(Some));
+        let array = builder.finish();
+        assert_eq!(array.value_offsets(), &[0, 1, 2, 3, 3, 4, 5, 6, 7, 15, 20]);
+        assert_eq!(array.value_data(), b"abcabcdcupcakeshello");
+    }
+
+    #[test]
+    fn test_write() {
+        let mut builder = GenericStringBuilder::<i32>::new();
+        write!(builder, "foo").unwrap();
+        builder.append_value("");
+        writeln!(builder, "bar").unwrap();
+        builder.append_value("");
+        write!(builder, "fiz").unwrap();
+        write!(builder, "buz").unwrap();
+        builder.append_value("");
+        let a = builder.finish();
+        let r: Vec<_> = a.iter().map(|x| x.unwrap()).collect();
+        assert_eq!(r, &["foo", "bar\n", "fizbuz"])
+    }
+}
diff --git a/arrow-array/src/builder/generic_bytes_dictionary_builder.rs b/arrow-array/src/builder/generic_bytes_dictionary_builder.rs
new file mode 100644
index 000000000000..b0c722ae7cda
--- /dev/null
+++ b/arrow-array/src/builder/generic_bytes_dictionary_builder.rs
@@ -0,0 +1,626 @@
+// 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.
+
+use crate::builder::{ArrayBuilder, GenericByteBuilder, PrimitiveBuilder};
+use crate::types::{ArrowDictionaryKeyType, ByteArrayType, GenericBinaryType, GenericStringType};
+use crate::{Array, ArrayRef, DictionaryArray, GenericByteArray};
+use arrow_buffer::ArrowNativeType;
+use arrow_schema::{ArrowError, DataType};
+use hashbrown::hash_map::RawEntryMut;
+use hashbrown::HashMap;
+use std::any::Any;
+use std::sync::Arc;
+
+/// Builder for [`DictionaryArray`] of [`GenericByteArray`]
+///
+/// For example to map a set of byte indices to String values. Note that
+/// the use of a `HashMap` here will not scale to very large arrays or
+/// result in an ordered dictionary.
+#[derive(Debug)]
+pub struct GenericByteDictionaryBuilder<K, T>
+where
+    K: ArrowDictionaryKeyType,
+    T: ByteArrayType,
+{
+    state: ahash::RandomState,
+    /// Used to provide a lookup from string value to key type
+    ///
+    /// Note: usize's hash implementation is not used, instead the raw entry
+    /// API is used to store keys w.r.t the hash of the strings themselves
+    ///
+    dedup: HashMap<usize, (), ()>,
+
+    keys_builder: PrimitiveBuilder<K>,
+    values_builder: GenericByteBuilder<T>,
+}
+
+impl<K, T> Default for GenericByteDictionaryBuilder<K, T>
+where
+    K: ArrowDictionaryKeyType,
+    T: ByteArrayType,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<K, T> GenericByteDictionaryBuilder<K, T>
+where
+    K: ArrowDictionaryKeyType,
+    T: ByteArrayType,
+{
+    /// Creates a new `GenericByteDictionaryBuilder`
+    pub fn new() -> Self {
+        let keys_builder = PrimitiveBuilder::new();
+        let values_builder = GenericByteBuilder::<T>::new();
+        Self {
+            state: Default::default(),
+            dedup: HashMap::with_capacity_and_hasher(keys_builder.capacity(), ()),
+            keys_builder,
+            values_builder,
+        }
+    }
+
+    /// Creates a new `GenericByteDictionaryBuilder` with the provided capacities
+    ///
+    /// `keys_capacity`: the number of keys, i.e. length of array to build
+    /// `value_capacity`: the number of distinct dictionary values, i.e. size of dictionary
+    /// `data_capacity`: the total number of bytes of all distinct bytes in the dictionary
+    pub fn with_capacity(
+        keys_capacity: usize,
+        value_capacity: usize,
+        data_capacity: usize,
+    ) -> Self {
+        Self {
+            state: Default::default(),
+            dedup: Default::default(),
+            keys_builder: PrimitiveBuilder::with_capacity(keys_capacity),
+            values_builder: GenericByteBuilder::<T>::with_capacity(value_capacity, data_capacity),
+        }
+    }
+
+    /// Creates a new `GenericByteDictionaryBuilder` from a keys capacity and a dictionary
+    /// which is initialized with the given values.
+    /// The indices of those dictionary values are used as keys.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use arrow_array::builder::StringDictionaryBuilder;
+    /// # use arrow_array::{Int16Array, StringArray};
+    ///
+    /// let dictionary_values = StringArray::from(vec![None, Some("abc"), Some("def")]);
+    ///
+    /// let mut builder = StringDictionaryBuilder::new_with_dictionary(3, &dictionary_values).unwrap();
+    /// builder.append("def").unwrap();
+    /// builder.append_null();
+    /// builder.append("abc").unwrap();
+    ///
+    /// let dictionary_array = builder.finish();
+    ///
+    /// let keys = dictionary_array.keys();
+    ///
+    /// assert_eq!(keys, &Int16Array::from(vec![Some(2), None, Some(1)]));
+    /// ```
+    pub fn new_with_dictionary(
+        keys_capacity: usize,
+        dictionary_values: &GenericByteArray<T>,
+    ) -> Result<Self, ArrowError> {
+        let state = ahash::RandomState::default();
+        let dict_len = dictionary_values.len();
+
+        let mut dedup = HashMap::with_capacity_and_hasher(dict_len, ());
+
+        let values_len = dictionary_values.value_data().len();
+        let mut values_builder = GenericByteBuilder::<T>::with_capacity(dict_len, values_len);
+
+        K::Native::from_usize(dictionary_values.len())
+            .ok_or(ArrowError::DictionaryKeyOverflowError)?;
+
+        for (idx, maybe_value) in dictionary_values.iter().enumerate() {
+            match maybe_value {
+                Some(value) => {
+                    let value_bytes: &[u8] = value.as_ref();
+                    let hash = state.hash_one(value_bytes);
+
+                    let entry = dedup.raw_entry_mut().from_hash(hash, |idx: &usize| {
+                        value_bytes == get_bytes(&values_builder, *idx)
+                    });
+
+                    if let RawEntryMut::Vacant(v) = entry {
+                        v.insert_with_hasher(hash, idx, (), |idx| {
+                            state.hash_one(get_bytes(&values_builder, *idx))
+                        });
+                    }
+
+                    values_builder.append_value(value);
+                }
+                None => values_builder.append_null(),
+            }
+        }
+
+        Ok(Self {
+            state,
+            dedup,
+            keys_builder: PrimitiveBuilder::with_capacity(keys_capacity),
+            values_builder,
+        })
+    }
+}
+
+impl<K, T> ArrayBuilder for GenericByteDictionaryBuilder<K, T>
+where
+    K: ArrowDictionaryKeyType,
+    T: ByteArrayType,
+{
+    /// Returns the builder as an non-mutable `Any` reference.
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// Returns the builder as an mutable `Any` reference.
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    /// Returns the boxed builder as a box of `Any`.
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    /// Returns the number of array slots in the builder
+    fn len(&self) -> usize {
+        self.keys_builder.len()
+    }
+
+    /// Builds the array and reset this builder.
+    fn finish(&mut self) -> ArrayRef {
+        Arc::new(self.finish())
+    }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+}
+
+impl<K, T> GenericByteDictionaryBuilder<K, T>
+where
+    K: ArrowDictionaryKeyType,
+    T: ByteArrayType,
+{
+    /// Append a value to the array. Return an existing index
+    /// if already present in the values array or a new index if the
+    /// value is appended to the values array.
+    ///
+    /// Returns an error if the new index would overflow the key type.
+    pub fn append(&mut self, value: impl AsRef<T::Native>) -> Result<K::Native, ArrowError> {
+        let value_native: &T::Native = value.as_ref();
+        let value_bytes: &[u8] = value_native.as_ref();
+
+        let state = &self.state;
+        let storage = &mut self.values_builder;
+        let hash = state.hash_one(value_bytes);
+
+        let entry = self
+            .dedup
+            .raw_entry_mut()
+            .from_hash(hash, |idx| value_bytes == get_bytes(storage, *idx));
+
+        let key = match entry {
+            RawEntryMut::Occupied(entry) => K::Native::usize_as(*entry.into_key()),
+            RawEntryMut::Vacant(entry) => {
+                let idx = storage.len();
+                storage.append_value(value);
+
+                entry.insert_with_hasher(hash, idx, (), |idx| {
+                    state.hash_one(get_bytes(storage, *idx))
+                });
+
+                K::Native::from_usize(idx).ok_or(ArrowError::DictionaryKeyOverflowError)?
+            }
+        };
+        self.keys_builder.append_value(key);
+
+        Ok(key)
+    }
+
+    /// Infallibly append a value to this builder
+    ///
+    /// # Panics
+    ///
+    /// Panics if the resulting length of the dictionary values array would exceed `T::Native::MAX`
+    pub fn append_value(&mut self, value: impl AsRef<T::Native>) {
+        self.append(value).expect("dictionary key overflow");
+    }
+
+    /// Appends a null slot into the builder
+    #[inline]
+    pub fn append_null(&mut self) {
+        self.keys_builder.append_null()
+    }
+
+    /// Append an `Option` value into the builder
+    ///
+    /// # Panics
+    ///
+    /// Panics if the resulting length of the dictionary values array would exceed `T::Native::MAX`
+    #[inline]
+    pub fn append_option(&mut self, value: Option<impl AsRef<T::Native>>) {
+        match value {
+            None => self.append_null(),
+            Some(v) => self.append_value(v),
+        };
+    }
+
+    /// Builds the `DictionaryArray` and reset this builder.
+    pub fn finish(&mut self) -> DictionaryArray<K> {
+        self.dedup.clear();
+        let values = self.values_builder.finish();
+        let keys = self.keys_builder.finish();
+
+        let data_type = DataType::Dictionary(Box::new(K::DATA_TYPE), Box::new(T::DATA_TYPE));
+
+        let builder = keys
+            .into_data()
+            .into_builder()
+            .data_type(data_type)
+            .child_data(vec![values.into_data()]);
+
+        DictionaryArray::from(unsafe { builder.build_unchecked() })
+    }
+
+    /// Builds the `DictionaryArray` without resetting the builder.
+    pub fn finish_cloned(&self) -> DictionaryArray<K> {
+        let values = self.values_builder.finish_cloned();
+        let keys = self.keys_builder.finish_cloned();
+
+        let data_type = DataType::Dictionary(Box::new(K::DATA_TYPE), Box::new(T::DATA_TYPE));
+
+        let builder = keys
+            .into_data()
+            .into_builder()
+            .data_type(data_type)
+            .child_data(vec![values.into_data()]);
+
+        DictionaryArray::from(unsafe { builder.build_unchecked() })
+    }
+}
+
+impl<K: ArrowDictionaryKeyType, T: ByteArrayType, V: AsRef<T::Native>> Extend<Option<V>>
+    for GenericByteDictionaryBuilder<K, T>
+{
+    #[inline]
+    fn extend<I: IntoIterator<Item = Option<V>>>(&mut self, iter: I) {
+        for v in iter {
+            self.append_option(v)
+        }
+    }
+}
+
+fn get_bytes<T: ByteArrayType>(values: &GenericByteBuilder<T>, idx: usize) -> &[u8] {
+    let offsets = values.offsets_slice();
+    let values = values.values_slice();
+
+    let end_offset = offsets[idx + 1].as_usize();
+    let start_offset = offsets[idx].as_usize();
+
+    &values[start_offset..end_offset]
+}
+
+/// Builder for [`DictionaryArray`] of [`StringArray`](crate::array::StringArray)
+///
+/// ```
+/// // Create a dictionary array indexed by bytes whose values are Strings.
+/// // It can thus hold up to 256 distinct string values.
+///
+/// # use arrow_array::builder::StringDictionaryBuilder;
+/// # use arrow_array::{Int8Array, StringArray};
+/// # use arrow_array::types::Int8Type;
+///
+/// let mut builder = StringDictionaryBuilder::<Int8Type>::new();
+///
+/// // The builder builds the dictionary value by value
+/// builder.append("abc").unwrap();
+/// builder.append_null();
+/// builder.append("def").unwrap();
+/// builder.append("def").unwrap();
+/// builder.append("abc").unwrap();
+/// let array = builder.finish();
+///
+/// assert_eq!(
+///   array.keys(),
+///   &Int8Array::from(vec![Some(0), None, Some(1), Some(1), Some(0)])
+/// );
+///
+/// // Values are polymorphic and so require a downcast.
+/// let av = array.values();
+/// let ava: &StringArray = av.as_any().downcast_ref::<StringArray>().unwrap();
+///
+/// assert_eq!(ava.value(0), "abc");
+/// assert_eq!(ava.value(1), "def");
+///
+/// ```
+pub type StringDictionaryBuilder<K> = GenericByteDictionaryBuilder<K, GenericStringType<i32>>;
+
+/// Builder for [`DictionaryArray`] of [`LargeStringArray`](crate::array::LargeStringArray)
+pub type LargeStringDictionaryBuilder<K> = GenericByteDictionaryBuilder<K, GenericStringType<i64>>;
+
+/// Builder for [`DictionaryArray`] of [`BinaryArray`](crate::array::BinaryArray)
+///
+/// ```
+/// // Create a dictionary array indexed by bytes whose values are binary.
+/// // It can thus hold up to 256 distinct binary values.
+///
+/// # use arrow_array::builder::BinaryDictionaryBuilder;
+/// # use arrow_array::{BinaryArray, Int8Array};
+/// # use arrow_array::types::Int8Type;
+///
+/// let mut builder = BinaryDictionaryBuilder::<Int8Type>::new();
+///
+/// // The builder builds the dictionary value by value
+/// builder.append(b"abc").unwrap();
+/// builder.append_null();
+/// builder.append(b"def").unwrap();
+/// builder.append(b"def").unwrap();
+/// builder.append(b"abc").unwrap();
+/// let array = builder.finish();
+///
+/// assert_eq!(
+///   array.keys(),
+///   &Int8Array::from(vec![Some(0), None, Some(1), Some(1), Some(0)])
+/// );
+///
+/// // Values are polymorphic and so require a downcast.
+/// let av = array.values();
+/// let ava: &BinaryArray = av.as_any().downcast_ref::<BinaryArray>().unwrap();
+///
+/// assert_eq!(ava.value(0), b"abc");
+/// assert_eq!(ava.value(1), b"def");
+///
+/// ```
+pub type BinaryDictionaryBuilder<K> = GenericByteDictionaryBuilder<K, GenericBinaryType<i32>>;
+
+/// Builder for [`DictionaryArray`] of [`LargeBinaryArray`](crate::array::LargeBinaryArray)
+pub type LargeBinaryDictionaryBuilder<K> = GenericByteDictionaryBuilder<K, GenericBinaryType<i64>>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::array::Array;
+    use crate::array::Int8Array;
+    use crate::types::{Int16Type, Int32Type, Int8Type, Utf8Type};
+    use crate::{BinaryArray, StringArray};
+
+    fn test_bytes_dictionary_builder<T>(values: Vec<&T::Native>)
+    where
+        T: ByteArrayType,
+        <T as ByteArrayType>::Native: PartialEq,
+        <T as ByteArrayType>::Native: AsRef<<T as ByteArrayType>::Native>,
+    {
+        let mut builder = GenericByteDictionaryBuilder::<Int8Type, T>::new();
+        builder.append(values[0]).unwrap();
+        builder.append_null();
+        builder.append(values[1]).unwrap();
+        builder.append(values[1]).unwrap();
+        builder.append(values[0]).unwrap();
+        let array = builder.finish();
+
+        assert_eq!(
+            array.keys(),
+            &Int8Array::from(vec![Some(0), None, Some(1), Some(1), Some(0)])
+        );
+
+        // Values are polymorphic and so require a downcast.
+        let av = array.values();
+        let ava: &GenericByteArray<T> = av.as_any().downcast_ref::<GenericByteArray<T>>().unwrap();
+
+        assert_eq!(*ava.value(0), *values[0]);
+        assert_eq!(*ava.value(1), *values[1]);
+    }
+
+    #[test]
+    fn test_string_dictionary_builder() {
+        test_bytes_dictionary_builder::<GenericStringType<i32>>(vec!["abc", "def"]);
+    }
+
+    #[test]
+    fn test_binary_dictionary_builder() {
+        test_bytes_dictionary_builder::<GenericBinaryType<i32>>(vec![b"abc", b"def"]);
+    }
+
+    fn test_bytes_dictionary_builder_finish_cloned<T>(values: Vec<&T::Native>)
+    where
+        T: ByteArrayType,
+        <T as ByteArrayType>::Native: PartialEq,
+        <T as ByteArrayType>::Native: AsRef<<T as ByteArrayType>::Native>,
+    {
+        let mut builder = GenericByteDictionaryBuilder::<Int8Type, T>::new();
+
+        builder.append(values[0]).unwrap();
+        builder.append_null();
+        builder.append(values[1]).unwrap();
+        builder.append(values[1]).unwrap();
+        builder.append(values[0]).unwrap();
+        let mut array = builder.finish_cloned();
+
+        assert_eq!(
+            array.keys(),
+            &Int8Array::from(vec![Some(0), None, Some(1), Some(1), Some(0)])
+        );
+
+        // Values are polymorphic and so require a downcast.
+        let av = array.values();
+        let ava: &GenericByteArray<T> = av.as_any().downcast_ref::<GenericByteArray<T>>().unwrap();
+
+        assert_eq!(ava.value(0), values[0]);
+        assert_eq!(ava.value(1), values[1]);
+
+        builder.append(values[0]).unwrap();
+        builder.append(values[2]).unwrap();
+        builder.append(values[1]).unwrap();
+
+        array = builder.finish();
+
+        assert_eq!(
+            array.keys(),
+            &Int8Array::from(vec![
+                Some(0),
+                None,
+                Some(1),
+                Some(1),
+                Some(0),
+                Some(0),
+                Some(2),
+                Some(1)
+            ])
+        );
+
+        // Values are polymorphic and so require a downcast.
+        let av2 = array.values();
+        let ava2: &GenericByteArray<T> =
+            av2.as_any().downcast_ref::<GenericByteArray<T>>().unwrap();
+
+        assert_eq!(ava2.value(0), values[0]);
+        assert_eq!(ava2.value(1), values[1]);
+        assert_eq!(ava2.value(2), values[2]);
+    }
+
+    #[test]
+    fn test_string_dictionary_builder_finish_cloned() {
+        test_bytes_dictionary_builder_finish_cloned::<GenericStringType<i32>>(vec![
+            "abc", "def", "ghi",
+        ]);
+    }
+
+    #[test]
+    fn test_binary_dictionary_builder_finish_cloned() {
+        test_bytes_dictionary_builder_finish_cloned::<GenericBinaryType<i32>>(vec![
+            b"abc", b"def", b"ghi",
+        ]);
+    }
+
+    fn test_bytes_dictionary_builder_with_existing_dictionary<T>(
+        dictionary: GenericByteArray<T>,
+        values: Vec<&T::Native>,
+    ) where
+        T: ByteArrayType,
+        <T as ByteArrayType>::Native: PartialEq,
+        <T as ByteArrayType>::Native: AsRef<<T as ByteArrayType>::Native>,
+    {
+        let mut builder =
+            GenericByteDictionaryBuilder::<Int8Type, T>::new_with_dictionary(6, &dictionary)
+                .unwrap();
+        builder.append(values[0]).unwrap();
+        builder.append_null();
+        builder.append(values[1]).unwrap();
+        builder.append(values[1]).unwrap();
+        builder.append(values[0]).unwrap();
+        builder.append(values[2]).unwrap();
+        let array = builder.finish();
+
+        assert_eq!(
+            array.keys(),
+            &Int8Array::from(vec![Some(2), None, Some(1), Some(1), Some(2), Some(3)])
+        );
+
+        // Values are polymorphic and so require a downcast.
+        let av = array.values();
+        let ava: &GenericByteArray<T> = av.as_any().downcast_ref::<GenericByteArray<T>>().unwrap();
+
+        assert!(!ava.is_valid(0));
+        assert_eq!(ava.value(1), values[1]);
+        assert_eq!(ava.value(2), values[0]);
+        assert_eq!(ava.value(3), values[2]);
+    }
+
+    #[test]
+    fn test_string_dictionary_builder_with_existing_dictionary() {
+        test_bytes_dictionary_builder_with_existing_dictionary::<GenericStringType<i32>>(
+            StringArray::from(vec![None, Some("def"), Some("abc")]),
+            vec!["abc", "def", "ghi"],
+        );
+    }
+
+    #[test]
+    fn test_binary_dictionary_builder_with_existing_dictionary() {
+        let values: Vec<Option<&[u8]>> = vec![None, Some(b"def"), Some(b"abc")];
+        test_bytes_dictionary_builder_with_existing_dictionary::<GenericBinaryType<i32>>(
+            BinaryArray::from(values),
+            vec![b"abc", b"def", b"ghi"],
+        );
+    }
+
+    fn test_bytes_dictionary_builder_with_reserved_null_value<T>(
+        dictionary: GenericByteArray<T>,
+        values: Vec<&T::Native>,
+    ) where
+        T: ByteArrayType,
+        <T as ByteArrayType>::Native: PartialEq,
+        <T as ByteArrayType>::Native: AsRef<<T as ByteArrayType>::Native>,
+    {
+        let mut builder =
+            GenericByteDictionaryBuilder::<Int16Type, T>::new_with_dictionary(4, &dictionary)
+                .unwrap();
+        builder.append(values[0]).unwrap();
+        builder.append_null();
+        builder.append(values[1]).unwrap();
+        builder.append(values[0]).unwrap();
+        let array = builder.finish();
+
+        assert!(array.is_null(1));
+        assert!(!array.is_valid(1));
+
+        let keys = array.keys();
+
+        assert_eq!(keys.value(0), 1);
+        assert!(keys.is_null(1));
+        // zero initialization is currently guaranteed by Buffer allocation and resizing
+        assert_eq!(keys.value(1), 0);
+        assert_eq!(keys.value(2), 2);
+        assert_eq!(keys.value(3), 1);
+    }
+
+    #[test]
+    fn test_string_dictionary_builder_with_reserved_null_value() {
+        let v: Vec<Option<&str>> = vec![None];
+        test_bytes_dictionary_builder_with_reserved_null_value::<GenericStringType<i32>>(
+            StringArray::from(v),
+            vec!["abc", "def"],
+        );
+    }
+
+    #[test]
+    fn test_binary_dictionary_builder_with_reserved_null_value() {
+        let values: Vec<Option<&[u8]>> = vec![None];
+        test_bytes_dictionary_builder_with_reserved_null_value::<GenericBinaryType<i32>>(
+            BinaryArray::from(values),
+            vec![b"abc", b"def"],
+        );
+    }
+
+    #[test]
+    fn test_extend() {
+        let mut builder = GenericByteDictionaryBuilder::<Int32Type, Utf8Type>::new();
+        builder.extend(["a", "b", "c", "a", "b", "c"].into_iter().map(Some));
+        builder.extend(["c", "d", "a"].into_iter().map(Some));
+        let dict = builder.finish();
+        assert_eq!(dict.keys().values(), &[0, 1, 2, 0, 1, 2, 2, 3, 0]);
+        assert_eq!(dict.values().len(), 4);
+    }
+}
diff --git a/arrow-array/src/builder/generic_list_builder.rs b/arrow-array/src/builder/generic_list_builder.rs
new file mode 100644
index 000000000000..b857224c5da6
--- /dev/null
+++ b/arrow-array/src/builder/generic_list_builder.rs
@@ -0,0 +1,801 @@
+// 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.
+
+use crate::builder::{ArrayBuilder, BufferBuilder};
+use crate::{Array, ArrayRef, GenericListArray, OffsetSizeTrait};
+use arrow_buffer::NullBufferBuilder;
+use arrow_buffer::{Buffer, OffsetBuffer};
+use arrow_schema::{Field, FieldRef};
+use std::any::Any;
+use std::sync::Arc;
+
+/// Builder for [`GenericListArray`]
+///
+/// Use [`ListBuilder`] to build [`ListArray`]s and [`LargeListBuilder`] to build [`LargeListArray`]s.
+///
+/// # Example
+///
+/// Here is code that constructs a ListArray with the contents:
+/// `[[A,B,C], [], NULL, [D], [NULL, F]]`
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::{builder::ListBuilder, builder::StringBuilder, ArrayRef, StringArray, Array};
+/// #
+/// let values_builder = StringBuilder::new();
+/// let mut builder = ListBuilder::new(values_builder);
+///
+/// // [A, B, C]
+/// builder.values().append_value("A");
+/// builder.values().append_value("B");
+/// builder.values().append_value("C");
+/// builder.append(true);
+///
+/// // [ ] (empty list)
+/// builder.append(true);
+///
+/// // Null
+/// builder.values().append_value("?"); // irrelevant
+/// builder.append(false);
+///
+/// // [D]
+/// builder.values().append_value("D");
+/// builder.append(true);
+///
+/// // [NULL, F]
+/// builder.values().append_null();
+/// builder.values().append_value("F");
+/// builder.append(true);
+///
+/// // Build the array
+/// let array = builder.finish();
+///
+/// // Values is a string array
+/// // "A", "B" "C", "?", "D", NULL, "F"
+/// assert_eq!(
+///   array.values().as_ref(),
+///   &StringArray::from(vec![
+///     Some("A"), Some("B"), Some("C"),
+///     Some("?"), Some("D"), None,
+///     Some("F")
+///   ])
+/// );
+///
+/// // Offsets are indexes into the values array
+/// assert_eq!(
+///   array.value_offsets(),
+///   &[0, 3, 3, 4, 5, 7]
+/// );
+/// ```
+///
+/// [`ListBuilder`]: crate::builder::ListBuilder
+/// [`ListArray`]: crate::array::ListArray
+/// [`LargeListBuilder`]: crate::builder::LargeListBuilder
+/// [`LargeListArray`]: crate::array::LargeListArray
+#[derive(Debug)]
+pub struct GenericListBuilder<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> {
+    offsets_builder: BufferBuilder<OffsetSize>,
+    null_buffer_builder: NullBufferBuilder,
+    values_builder: T,
+    field: Option<FieldRef>,
+}
+
+impl<O: OffsetSizeTrait, T: ArrayBuilder + Default> Default for GenericListBuilder<O, T> {
+    fn default() -> Self {
+        Self::new(T::default())
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> GenericListBuilder<OffsetSize, T> {
+    /// Creates a new [`GenericListBuilder`] from a given values array builder
+    pub fn new(values_builder: T) -> Self {
+        let capacity = values_builder.len();
+        Self::with_capacity(values_builder, capacity)
+    }
+
+    /// Creates a new [`GenericListBuilder`] from a given values array builder
+    /// `capacity` is the number of items to pre-allocate space for in this builder
+    pub fn with_capacity(values_builder: T, capacity: usize) -> Self {
+        let mut offsets_builder = BufferBuilder::<OffsetSize>::new(capacity + 1);
+        offsets_builder.append(OffsetSize::zero());
+        Self {
+            offsets_builder,
+            null_buffer_builder: NullBufferBuilder::new(capacity),
+            values_builder,
+            field: None,
+        }
+    }
+
+    /// Override the field passed to [`GenericListArray::new`]
+    ///
+    /// By default a nullable field is created with the name `item`
+    ///
+    /// Note: [`Self::finish`] and [`Self::finish_cloned`] will panic if the
+    /// field's data type does not match that of `T`
+    pub fn with_field(self, field: impl Into<FieldRef>) -> Self {
+        Self {
+            field: Some(field.into()),
+            ..self
+        }
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> ArrayBuilder
+    for GenericListBuilder<OffsetSize, T>
+where
+    T: 'static,
+{
+    /// Returns the builder as a non-mutable `Any` reference.
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// Returns the builder as a mutable `Any` reference.
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    /// Returns the boxed builder as a box of `Any`.
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    /// Returns the number of array slots in the builder
+    fn len(&self) -> usize {
+        self.null_buffer_builder.len()
+    }
+
+    /// Builds the array and reset this builder.
+    fn finish(&mut self) -> ArrayRef {
+        Arc::new(self.finish())
+    }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+}
+
+impl<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> GenericListBuilder<OffsetSize, T>
+where
+    T: 'static,
+{
+    /// Returns the child array builder as a mutable reference.
+    ///
+    /// This mutable reference can be used to append values into the child array builder,
+    /// but you must call [`append`](#method.append) to delimit each distinct list value.
+    pub fn values(&mut self) -> &mut T {
+        &mut self.values_builder
+    }
+
+    /// Returns the child array builder as an immutable reference
+    pub fn values_ref(&self) -> &T {
+        &self.values_builder
+    }
+
+    /// Finish the current variable-length list array slot
+    ///
+    /// # Panics
+    ///
+    /// Panics if the length of [`Self::values`] exceeds `OffsetSize::MAX`
+    #[inline]
+    pub fn append(&mut self, is_valid: bool) {
+        self.offsets_builder.append(self.next_offset());
+        self.null_buffer_builder.append(is_valid);
+    }
+
+    /// Returns the next offset
+    ///
+    /// # Panics
+    ///
+    /// Panics if the length of [`Self::values`] exceeds `OffsetSize::MAX`
+    #[inline]
+    fn next_offset(&self) -> OffsetSize {
+        OffsetSize::from_usize(self.values_builder.len()).unwrap()
+    }
+
+    /// Append a value to this [`GenericListBuilder`]
+    ///
+    /// ```
+    /// # use arrow_array::builder::{Int32Builder, ListBuilder};
+    /// # use arrow_array::cast::AsArray;
+    /// # use arrow_array::{Array, Int32Array};
+    /// # use arrow_array::types::Int32Type;
+    /// let mut builder = ListBuilder::new(Int32Builder::new());
+    ///
+    /// builder.append_value([Some(1), Some(2), Some(3)]);
+    /// builder.append_value([]);
+    /// builder.append_value([None]);
+    ///
+    /// let array = builder.finish();
+    /// assert_eq!(array.len(), 3);
+    ///
+    /// assert_eq!(array.value_offsets(), &[0, 3, 3, 4]);
+    /// let values = array.values().as_primitive::<Int32Type>();
+    /// assert_eq!(values, &Int32Array::from(vec![Some(1), Some(2), Some(3), None]));
+    /// ```
+    ///
+    /// This is an alternative API to appending directly to [`Self::values`] and
+    /// delimiting the result with [`Self::append`]
+    ///
+    /// ```
+    /// # use arrow_array::builder::{Int32Builder, ListBuilder};
+    /// # use arrow_array::cast::AsArray;
+    /// # use arrow_array::{Array, Int32Array};
+    /// # use arrow_array::types::Int32Type;
+    /// let mut builder = ListBuilder::new(Int32Builder::new());
+    ///
+    /// builder.values().append_value(1);
+    /// builder.values().append_value(2);
+    /// builder.values().append_value(3);
+    /// builder.append(true);
+    /// builder.append(true);
+    /// builder.values().append_null();
+    /// builder.append(true);
+    ///
+    /// let array = builder.finish();
+    /// assert_eq!(array.len(), 3);
+    ///
+    /// assert_eq!(array.value_offsets(), &[0, 3, 3, 4]);
+    /// let values = array.values().as_primitive::<Int32Type>();
+    /// assert_eq!(values, &Int32Array::from(vec![Some(1), Some(2), Some(3), None]));
+    /// ```
+    #[inline]
+    pub fn append_value<I, V>(&mut self, i: I)
+    where
+        T: Extend<Option<V>>,
+        I: IntoIterator<Item = Option<V>>,
+    {
+        self.extend(std::iter::once(Some(i)))
+    }
+
+    /// Append a null to this [`GenericListBuilder`]
+    ///
+    /// See [`Self::append_value`] for an example use.
+    #[inline]
+    pub fn append_null(&mut self) {
+        self.offsets_builder.append(self.next_offset());
+        self.null_buffer_builder.append_null();
+    }
+
+    /// Appends an optional value into this [`GenericListBuilder`]
+    ///
+    /// If `Some` calls [`Self::append_value`] otherwise calls [`Self::append_null`]
+    #[inline]
+    pub fn append_option<I, V>(&mut self, i: Option<I>)
+    where
+        T: Extend<Option<V>>,
+        I: IntoIterator<Item = Option<V>>,
+    {
+        match i {
+            Some(i) => self.append_value(i),
+            None => self.append_null(),
+        }
+    }
+
+    /// Builds the [`GenericListArray`] and reset this builder.
+    pub fn finish(&mut self) -> GenericListArray<OffsetSize> {
+        let values = self.values_builder.finish();
+        let nulls = self.null_buffer_builder.finish();
+
+        let offsets = self.offsets_builder.finish();
+        // Safety: Safe by construction
+        let offsets = unsafe { OffsetBuffer::new_unchecked(offsets.into()) };
+        self.offsets_builder.append(OffsetSize::zero());
+
+        let field = match &self.field {
+            Some(f) => f.clone(),
+            None => Arc::new(Field::new("item", values.data_type().clone(), true)),
+        };
+
+        GenericListArray::new(field, offsets, values, nulls)
+    }
+
+    /// Builds the [`GenericListArray`] without resetting the builder.
+    pub fn finish_cloned(&self) -> GenericListArray<OffsetSize> {
+        let values = self.values_builder.finish_cloned();
+        let nulls = self.null_buffer_builder.finish_cloned();
+
+        let offsets = Buffer::from_slice_ref(self.offsets_builder.as_slice());
+        // Safety: safe by construction
+        let offsets = unsafe { OffsetBuffer::new_unchecked(offsets.into()) };
+
+        let field = match &self.field {
+            Some(f) => f.clone(),
+            None => Arc::new(Field::new("item", values.data_type().clone(), true)),
+        };
+
+        GenericListArray::new(field, offsets, values, nulls)
+    }
+
+    /// Returns the current offsets buffer as a slice
+    pub fn offsets_slice(&self) -> &[OffsetSize] {
+        self.offsets_builder.as_slice()
+    }
+}
+
+impl<O, B, V, E> Extend<Option<V>> for GenericListBuilder<O, B>
+where
+    O: OffsetSizeTrait,
+    B: ArrayBuilder + Extend<E>,
+    V: IntoIterator<Item = E>,
+{
+    #[inline]
+    fn extend<T: IntoIterator<Item = Option<V>>>(&mut self, iter: T) {
+        for v in iter {
+            match v {
+                Some(elements) => {
+                    self.values_builder.extend(elements);
+                    self.append(true);
+                }
+                None => self.append(false),
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::builder::{make_builder, Int32Builder, ListBuilder};
+    use crate::cast::AsArray;
+    use crate::types::Int32Type;
+    use crate::{Array, Int32Array};
+    use arrow_schema::DataType;
+
+    fn _test_generic_list_array_builder<O: OffsetSizeTrait>() {
+        let values_builder = Int32Builder::with_capacity(10);
+        let mut builder = GenericListBuilder::<O, _>::new(values_builder);
+
+        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+        builder.values().append_value(0);
+        builder.values().append_value(1);
+        builder.values().append_value(2);
+        builder.append(true);
+        builder.values().append_value(3);
+        builder.values().append_value(4);
+        builder.values().append_value(5);
+        builder.append(true);
+        builder.values().append_value(6);
+        builder.values().append_value(7);
+        builder.append(true);
+        let list_array = builder.finish();
+
+        let list_values = list_array.values().as_primitive::<Int32Type>();
+        assert_eq!(list_values.values(), &[0, 1, 2, 3, 4, 5, 6, 7]);
+        assert_eq!(list_array.value_offsets(), [0, 3, 6, 8].map(O::usize_as));
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(3, list_array.len());
+        assert_eq!(0, list_array.null_count());
+        assert_eq!(O::from_usize(6).unwrap(), list_array.value_offsets()[2]);
+        assert_eq!(O::from_usize(2).unwrap(), list_array.value_length(2));
+        for i in 0..3 {
+            assert!(list_array.is_valid(i));
+            assert!(!list_array.is_null(i));
+        }
+    }
+
+    #[test]
+    fn test_list_array_builder() {
+        _test_generic_list_array_builder::<i32>()
+    }
+
+    #[test]
+    fn test_large_list_array_builder() {
+        _test_generic_list_array_builder::<i64>()
+    }
+
+    fn _test_generic_list_array_builder_nulls<O: OffsetSizeTrait>() {
+        let values_builder = Int32Builder::with_capacity(10);
+        let mut builder = GenericListBuilder::<O, _>::new(values_builder);
+
+        //  [[0, 1, 2], null, [3, null, 5], [6, 7]]
+        builder.values().append_value(0);
+        builder.values().append_value(1);
+        builder.values().append_value(2);
+        builder.append(true);
+        builder.append(false);
+        builder.values().append_value(3);
+        builder.values().append_null();
+        builder.values().append_value(5);
+        builder.append(true);
+        builder.values().append_value(6);
+        builder.values().append_value(7);
+        builder.append(true);
+
+        let list_array = builder.finish();
+
+        assert_eq!(DataType::Int32, list_array.value_type());
+        assert_eq!(4, list_array.len());
+        assert_eq!(1, list_array.null_count());
+        assert_eq!(O::from_usize(3).unwrap(), list_array.value_offsets()[2]);
+        assert_eq!(O::from_usize(3).unwrap(), list_array.value_length(2));
+    }
+
+    #[test]
+    fn test_list_array_builder_nulls() {
+        _test_generic_list_array_builder_nulls::<i32>()
+    }
+
+    #[test]
+    fn test_large_list_array_builder_nulls() {
+        _test_generic_list_array_builder_nulls::<i64>()
+    }
+
+    #[test]
+    fn test_list_array_builder_finish() {
+        let values_builder = Int32Array::builder(5);
+        let mut builder = ListBuilder::new(values_builder);
+
+        builder.values().append_slice(&[1, 2, 3]);
+        builder.append(true);
+        builder.values().append_slice(&[4, 5, 6]);
+        builder.append(true);
+
+        let mut arr = builder.finish();
+        assert_eq!(2, arr.len());
+        assert!(builder.is_empty());
+
+        builder.values().append_slice(&[7, 8, 9]);
+        builder.append(true);
+        arr = builder.finish();
+        assert_eq!(1, arr.len());
+        assert!(builder.is_empty());
+    }
+
+    #[test]
+    fn test_list_array_builder_finish_cloned() {
+        let values_builder = Int32Array::builder(5);
+        let mut builder = ListBuilder::new(values_builder);
+
+        builder.values().append_slice(&[1, 2, 3]);
+        builder.append(true);
+        builder.values().append_slice(&[4, 5, 6]);
+        builder.append(true);
+
+        let mut arr = builder.finish_cloned();
+        assert_eq!(2, arr.len());
+        assert!(!builder.is_empty());
+
+        builder.values().append_slice(&[7, 8, 9]);
+        builder.append(true);
+        arr = builder.finish();
+        assert_eq!(3, arr.len());
+        assert!(builder.is_empty());
+    }
+
+    #[test]
+    fn test_list_list_array_builder() {
+        let primitive_builder = Int32Builder::with_capacity(10);
+        let values_builder = ListBuilder::new(primitive_builder);
+        let mut builder = ListBuilder::new(values_builder);
+
+        //  [[[1, 2], [3, 4]], [[5, 6, 7], null, [8]], null, [[9, 10]]]
+        builder.values().values().append_value(1);
+        builder.values().values().append_value(2);
+        builder.values().append(true);
+        builder.values().values().append_value(3);
+        builder.values().values().append_value(4);
+        builder.values().append(true);
+        builder.append(true);
+
+        builder.values().values().append_value(5);
+        builder.values().values().append_value(6);
+        builder.values().values().append_value(7);
+        builder.values().append(true);
+        builder.values().append(false);
+        builder.values().values().append_value(8);
+        builder.values().append(true);
+        builder.append(true);
+
+        builder.append(false);
+
+        builder.values().values().append_value(9);
+        builder.values().values().append_value(10);
+        builder.values().append(true);
+        builder.append(true);
+
+        let l1 = builder.finish();
+
+        assert_eq!(4, l1.len());
+        assert_eq!(1, l1.null_count());
+
+        assert_eq!(l1.value_offsets(), &[0, 2, 5, 5, 6]);
+        let l2 = l1.values().as_list::<i32>();
+
+        assert_eq!(6, l2.len());
+        assert_eq!(1, l2.null_count());
+        assert_eq!(l2.value_offsets(), &[0, 2, 4, 7, 7, 8, 10]);
+
+        let i1 = l2.values().as_primitive::<Int32Type>();
+        assert_eq!(10, i1.len());
+        assert_eq!(0, i1.null_count());
+        assert_eq!(i1.values(), &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    }
+
+    #[test]
+    fn test_extend() {
+        let mut builder = ListBuilder::new(Int32Builder::new());
+        builder.extend([
+            Some(vec![Some(1), Some(2), Some(7), None]),
+            Some(vec![]),
+            Some(vec![Some(4), Some(5)]),
+            None,
+        ]);
+
+        let array = builder.finish();
+        assert_eq!(array.value_offsets(), [0, 4, 4, 6, 6]);
+        assert_eq!(array.null_count(), 1);
+        assert!(array.is_null(3));
+        let elements = array.values().as_primitive::<Int32Type>();
+        assert_eq!(elements.values(), &[1, 2, 7, 0, 4, 5]);
+        assert_eq!(elements.null_count(), 1);
+        assert!(elements.is_null(3));
+    }
+
+    #[test]
+    fn test_boxed_primitive_aray_builder() {
+        let values_builder = make_builder(&DataType::Int32, 5);
+        let mut builder = ListBuilder::new(values_builder);
+
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_slice(&[1, 2, 3]);
+        builder.append(true);
+
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_slice(&[4, 5, 6]);
+        builder.append(true);
+
+        let arr = builder.finish();
+        assert_eq!(2, arr.len());
+
+        let elements = arr.values().as_primitive::<Int32Type>();
+        assert_eq!(elements.values(), &[1, 2, 3, 4, 5, 6]);
+    }
+
+    #[test]
+    fn test_boxed_list_list_array_builder() {
+        // This test is same as `test_list_list_array_builder` but uses boxed builders.
+        let values_builder = make_builder(
+            &DataType::List(Arc::new(Field::new("item", DataType::Int32, true))),
+            10,
+        );
+        test_boxed_generic_list_generic_list_array_builder::<i32>(values_builder);
+    }
+
+    #[test]
+    fn test_boxed_large_list_large_list_array_builder() {
+        // This test is same as `test_list_list_array_builder` but uses boxed builders.
+        let values_builder = make_builder(
+            &DataType::LargeList(Arc::new(Field::new("item", DataType::Int32, true))),
+            10,
+        );
+        test_boxed_generic_list_generic_list_array_builder::<i64>(values_builder);
+    }
+
+    fn test_boxed_generic_list_generic_list_array_builder<O: OffsetSizeTrait + PartialEq>(
+        values_builder: Box<dyn ArrayBuilder>,
+    ) {
+        let mut builder: GenericListBuilder<O, Box<dyn ArrayBuilder>> =
+            GenericListBuilder::<O, Box<dyn ArrayBuilder>>::new(values_builder);
+
+        //  [[[1, 2], [3, 4]], [[5, 6, 7], null, [8]], null, [[9, 10]]]
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_value(1);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_value(2);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .append(true);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_value(3);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_value(4);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .append(true);
+        builder.append(true);
+
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_value(5);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_value(6);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an (Large)ListBuilder")
+            .append_value(7);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .append(true);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .append(false);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_value(8);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .append(true);
+        builder.append(true);
+
+        builder.append(false);
+
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_value(9);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_value(10);
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<GenericListBuilder<O, Box<dyn ArrayBuilder>>>()
+            .expect("should be an (Large)ListBuilder")
+            .append(true);
+        builder.append(true);
+
+        let l1 = builder.finish();
+
+        assert_eq!(4, l1.len());
+        assert_eq!(1, l1.null_count());
+
+        assert_eq!(l1.value_offsets(), &[0, 2, 5, 5, 6].map(O::usize_as));
+        let l2 = l1.values().as_list::<O>();
+
+        assert_eq!(6, l2.len());
+        assert_eq!(1, l2.null_count());
+        assert_eq!(l2.value_offsets(), &[0, 2, 4, 7, 7, 8, 10].map(O::usize_as));
+
+        let i1 = l2.values().as_primitive::<Int32Type>();
+        assert_eq!(10, i1.len());
+        assert_eq!(0, i1.null_count());
+        assert_eq!(i1.values(), &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+    }
+
+    #[test]
+    fn test_with_field() {
+        let field = Arc::new(Field::new("bar", DataType::Int32, false));
+        let mut builder = ListBuilder::new(Int32Builder::new()).with_field(field.clone());
+        builder.append_value([Some(1), Some(2), Some(3)]);
+        builder.append_null(); // This is fine as nullability refers to nullability of values
+        builder.append_value([Some(4)]);
+        let array = builder.finish();
+        assert_eq!(array.len(), 3);
+        assert_eq!(array.data_type(), &DataType::List(field.clone()));
+
+        builder.append_value([Some(4), Some(5)]);
+        let array = builder.finish();
+        assert_eq!(array.data_type(), &DataType::List(field));
+        assert_eq!(array.len(), 1);
+    }
+
+    #[test]
+    #[should_panic(expected = "Non-nullable field of ListArray \\\"item\\\" cannot contain nulls")]
+    fn test_checks_nullability() {
+        let field = Arc::new(Field::new("item", DataType::Int32, false));
+        let mut builder = ListBuilder::new(Int32Builder::new()).with_field(field.clone());
+        builder.append_value([Some(1), None]);
+        builder.finish();
+    }
+
+    #[test]
+    #[should_panic(expected = "ListArray expected data type Int64 got Int32")]
+    fn test_checks_data_type() {
+        let field = Arc::new(Field::new("item", DataType::Int64, false));
+        let mut builder = ListBuilder::new(Int32Builder::new()).with_field(field.clone());
+        builder.append_value([Some(1)]);
+        builder.finish();
+    }
+}
diff --git a/arrow-array/src/builder/map_builder.rs b/arrow-array/src/builder/map_builder.rs
new file mode 100644
index 000000000000..edc45c2c23b7
--- /dev/null
+++ b/arrow-array/src/builder/map_builder.rs
@@ -0,0 +1,299 @@
+// 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.
+
+use crate::builder::{ArrayBuilder, BufferBuilder};
+use crate::{Array, ArrayRef, MapArray, StructArray};
+use arrow_buffer::Buffer;
+use arrow_buffer::{NullBuffer, NullBufferBuilder};
+use arrow_data::ArrayData;
+use arrow_schema::{ArrowError, DataType, Field};
+use std::any::Any;
+use std::sync::Arc;
+
+/// Builder for [`MapArray`]
+///
+/// ```
+/// # use arrow_array::builder::{Int32Builder, MapBuilder, StringBuilder};
+/// # use arrow_array::{Int32Array, StringArray};
+///
+/// let string_builder = StringBuilder::new();
+/// let int_builder = Int32Builder::with_capacity(4);
+///
+/// // Construct `[{"joe": 1}, {"blogs": 2, "foo": 4}, {}, null]`
+/// let mut builder = MapBuilder::new(None, string_builder, int_builder);
+///
+/// builder.keys().append_value("joe");
+/// builder.values().append_value(1);
+/// builder.append(true).unwrap();
+///
+/// builder.keys().append_value("blogs");
+/// builder.values().append_value(2);
+/// builder.keys().append_value("foo");
+/// builder.values().append_value(4);
+/// builder.append(true).unwrap();
+/// builder.append(true).unwrap();
+/// builder.append(false).unwrap();
+///
+/// let array = builder.finish();
+/// assert_eq!(array.value_offsets(), &[0, 1, 3, 3, 3]);
+/// assert_eq!(array.values().as_ref(), &Int32Array::from(vec![1, 2, 4]));
+/// assert_eq!(array.keys().as_ref(), &StringArray::from(vec!["joe", "blogs", "foo"]));
+///
+/// ```
+#[derive(Debug)]
+pub struct MapBuilder<K: ArrayBuilder, V: ArrayBuilder> {
+    offsets_builder: BufferBuilder<i32>,
+    null_buffer_builder: NullBufferBuilder,
+    field_names: MapFieldNames,
+    key_builder: K,
+    value_builder: V,
+}
+
+/// The [`Field`] names for a [`MapArray`]
+#[derive(Debug, Clone)]
+pub struct MapFieldNames {
+    /// [`Field`] name for map entries
+    pub entry: String,
+    /// [`Field`] name for map key
+    pub key: String,
+    /// [`Field`] name for map value
+    pub value: String,
+}
+
+impl Default for MapFieldNames {
+    fn default() -> Self {
+        Self {
+            entry: "entries".to_string(),
+            key: "keys".to_string(),
+            value: "values".to_string(),
+        }
+    }
+}
+
+impl<K: ArrayBuilder, V: ArrayBuilder> MapBuilder<K, V> {
+    /// Creates a new `MapBuilder`
+    pub fn new(field_names: Option<MapFieldNames>, key_builder: K, value_builder: V) -> Self {
+        let capacity = key_builder.len();
+        Self::with_capacity(field_names, key_builder, value_builder, capacity)
+    }
+
+    /// Creates a new `MapBuilder` with capacity
+    pub fn with_capacity(
+        field_names: Option<MapFieldNames>,
+        key_builder: K,
+        value_builder: V,
+        capacity: usize,
+    ) -> Self {
+        let mut offsets_builder = BufferBuilder::<i32>::new(capacity + 1);
+        offsets_builder.append(0);
+        Self {
+            offsets_builder,
+            null_buffer_builder: NullBufferBuilder::new(capacity),
+            field_names: field_names.unwrap_or_default(),
+            key_builder,
+            value_builder,
+        }
+    }
+
+    /// Returns the key array builder of the map
+    pub fn keys(&mut self) -> &mut K {
+        &mut self.key_builder
+    }
+
+    /// Returns the value array builder of the map
+    pub fn values(&mut self) -> &mut V {
+        &mut self.value_builder
+    }
+
+    /// Returns both the key and value array builders of the map
+    pub fn entries(&mut self) -> (&mut K, &mut V) {
+        (&mut self.key_builder, &mut self.value_builder)
+    }
+
+    /// Finish the current map array slot
+    ///
+    /// Returns an error if the key and values builders are in an inconsistent state.
+    #[inline]
+    pub fn append(&mut self, is_valid: bool) -> Result<(), ArrowError> {
+        if self.key_builder.len() != self.value_builder.len() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Cannot append to a map builder when its keys and values have unequal lengths of {} and {}",
+                self.key_builder.len(),
+                self.value_builder.len()
+            )));
+        }
+        self.offsets_builder.append(self.key_builder.len() as i32);
+        self.null_buffer_builder.append(is_valid);
+        Ok(())
+    }
+
+    /// Builds the [`MapArray`]
+    pub fn finish(&mut self) -> MapArray {
+        let len = self.len();
+        // Build the keys
+        let keys_arr = self.key_builder.finish();
+        let values_arr = self.value_builder.finish();
+        let offset_buffer = self.offsets_builder.finish();
+        self.offsets_builder.append(0);
+        let null_bit_buffer = self.null_buffer_builder.finish();
+
+        self.finish_helper(keys_arr, values_arr, offset_buffer, null_bit_buffer, len)
+    }
+
+    /// Builds the [`MapArray`] without resetting the builder.
+    pub fn finish_cloned(&self) -> MapArray {
+        let len = self.len();
+        // Build the keys
+        let keys_arr = self.key_builder.finish_cloned();
+        let values_arr = self.value_builder.finish_cloned();
+        let offset_buffer = Buffer::from_slice_ref(self.offsets_builder.as_slice());
+        let nulls = self.null_buffer_builder.finish_cloned();
+        self.finish_helper(keys_arr, values_arr, offset_buffer, nulls, len)
+    }
+
+    fn finish_helper(
+        &self,
+        keys_arr: Arc<dyn Array>,
+        values_arr: Arc<dyn Array>,
+        offset_buffer: Buffer,
+        nulls: Option<NullBuffer>,
+        len: usize,
+    ) -> MapArray {
+        assert!(
+            keys_arr.null_count() == 0,
+            "Keys array must have no null values, found {} null value(s)",
+            keys_arr.null_count()
+        );
+
+        let keys_field = Arc::new(Field::new(
+            self.field_names.key.as_str(),
+            keys_arr.data_type().clone(),
+            false, // always non-nullable
+        ));
+        let values_field = Arc::new(Field::new(
+            self.field_names.value.as_str(),
+            values_arr.data_type().clone(),
+            true,
+        ));
+
+        let struct_array =
+            StructArray::from(vec![(keys_field, keys_arr), (values_field, values_arr)]);
+
+        let map_field = Arc::new(Field::new(
+            self.field_names.entry.as_str(),
+            struct_array.data_type().clone(),
+            false, // always non-nullable
+        ));
+        let array_data = ArrayData::builder(DataType::Map(map_field, false)) // TODO: support sorted keys
+            .len(len)
+            .add_buffer(offset_buffer)
+            .add_child_data(struct_array.into_data())
+            .nulls(nulls);
+
+        let array_data = unsafe { array_data.build_unchecked() };
+
+        MapArray::from(array_data)
+    }
+}
+
+impl<K: ArrayBuilder, V: ArrayBuilder> ArrayBuilder for MapBuilder<K, V> {
+    fn len(&self) -> usize {
+        self.null_buffer_builder.len()
+    }
+
+    fn finish(&mut self) -> ArrayRef {
+        Arc::new(self.finish())
+    }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::builder::{make_builder, Int32Builder, StringBuilder};
+    use crate::{Int32Array, StringArray};
+
+    use super::*;
+
+    #[test]
+    #[should_panic(expected = "Keys array must have no null values, found 1 null value(s)")]
+    fn test_map_builder_with_null_keys_panics() {
+        let mut builder = MapBuilder::new(None, StringBuilder::new(), Int32Builder::new());
+        builder.keys().append_null();
+        builder.values().append_value(42);
+        builder.append(true).unwrap();
+
+        builder.finish();
+    }
+
+    #[test]
+    fn test_boxed_map_builder() {
+        let keys_builder = make_builder(&DataType::Utf8, 5);
+        let values_builder = make_builder(&DataType::Int32, 5);
+
+        let mut builder = MapBuilder::new(None, keys_builder, values_builder);
+        builder
+            .keys()
+            .as_any_mut()
+            .downcast_mut::<StringBuilder>()
+            .expect("should be an StringBuilder")
+            .append_value("1");
+        builder
+            .values()
+            .as_any_mut()
+            .downcast_mut::<Int32Builder>()
+            .expect("should be an Int32Builder")
+            .append_value(42);
+        builder.append(true).unwrap();
+
+        let map_array = builder.finish();
+
+        assert_eq!(
+            map_array
+                .keys()
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .expect("should be an StringArray")
+                .value(0),
+            "1"
+        );
+        assert_eq!(
+            map_array
+                .values()
+                .as_any()
+                .downcast_ref::<Int32Array>()
+                .expect("should be an Int32Array")
+                .value(0),
+            42
+        );
+    }
+}
diff --git a/arrow-array/src/builder/mod.rs b/arrow-array/src/builder/mod.rs
new file mode 100644
index 000000000000..d33e565a868b
--- /dev/null
+++ b/arrow-array/src/builder/mod.rs
@@ -0,0 +1,314 @@
+// 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.
+
+//! Defines push-based APIs for constructing arrays
+//!
+//! # Basic Usage
+//!
+//! Builders can be used to build simple, non-nested arrays
+//!
+//! ```
+//! # use arrow_array::builder::Int32Builder;
+//! # use arrow_array::PrimitiveArray;
+//! let mut a = Int32Builder::new();
+//! a.append_value(1);
+//! a.append_null();
+//! a.append_value(2);
+//! let a = a.finish();
+//!
+//! assert_eq!(a, PrimitiveArray::from(vec![Some(1), None, Some(2)]));
+//! ```
+//!
+//! ```
+//! # use arrow_array::builder::StringBuilder;
+//! # use arrow_array::{Array, StringArray};
+//! let mut a = StringBuilder::new();
+//! a.append_value("foo");
+//! a.append_value("bar");
+//! a.append_null();
+//! let a = a.finish();
+//!
+//! assert_eq!(a, StringArray::from_iter([Some("foo"), Some("bar"), None]));
+//! ```
+//!
+//! # Nested Usage
+//!
+//! Builders can also be used to build more complex nested arrays, such as lists
+//!
+//! ```
+//! # use arrow_array::builder::{Int32Builder, ListBuilder};
+//! # use arrow_array::ListArray;
+//! # use arrow_array::types::Int32Type;
+//! let mut a = ListBuilder::new(Int32Builder::new());
+//! // [1, 2]
+//! a.values().append_value(1);
+//! a.values().append_value(2);
+//! a.append(true);
+//! // null
+//! a.append(false);
+//! // []
+//! a.append(true);
+//! // [3, null]
+//! a.values().append_value(3);
+//! a.values().append_null();
+//! a.append(true);
+//!
+//! // [[1, 2], null, [], [3, null]]
+//! let a = a.finish();
+//!
+//! assert_eq!(a, ListArray::from_iter_primitive::<Int32Type, _, _>([
+//!     Some(vec![Some(1), Some(2)]),
+//!     None,
+//!     Some(vec![]),
+//!     Some(vec![Some(3), None])]
+//! ))
+//! ```
+//!
+//! # Custom Builders
+//!
+//! It is common to have a collection of statically defined Rust types that
+//! you want to convert to Arrow arrays.
+//!
+//! An example of doing so is below
+//!
+//! ```
+//! # use std::any::Any;
+//! # use arrow_array::builder::{ArrayBuilder, Int32Builder, ListBuilder, StringBuilder};
+//! # use arrow_array::{ArrayRef, RecordBatch, StructArray};
+//! # use arrow_schema::{DataType, Field};
+//! # use std::sync::Arc;
+//! /// A custom row representation
+//! struct MyRow {
+//!     i32: i32,
+//!     optional_i32: Option<i32>,
+//!     string: Option<String>,
+//!     i32_list: Option<Vec<Option<i32>>>,
+//! }
+//!
+//! /// Converts `Vec<Row>` into `StructArray`
+//! #[derive(Debug, Default)]
+//! struct MyRowBuilder {
+//!     i32: Int32Builder,
+//!     string: StringBuilder,
+//!     i32_list: ListBuilder<Int32Builder>,
+//! }
+//!
+//! impl MyRowBuilder {
+//!     fn append(&mut self, row: &MyRow) {
+//!         self.i32.append_value(row.i32);
+//!         self.string.append_option(row.string.as_ref());
+//!         self.i32_list.append_option(row.i32_list.as_ref().map(|x| x.iter().copied()));
+//!     }
+//!
+//!     /// Note: returns StructArray to allow nesting within another array if desired
+//!     fn finish(&mut self) -> StructArray {
+//!         let i32 = Arc::new(self.i32.finish()) as ArrayRef;
+//!         let i32_field = Arc::new(Field::new("i32", DataType::Int32, false));
+//!
+//!         let string = Arc::new(self.string.finish()) as ArrayRef;
+//!         let string_field = Arc::new(Field::new("i32", DataType::Utf8, false));
+//!
+//!         let i32_list = Arc::new(self.i32_list.finish()) as ArrayRef;
+//!         let value_field = Arc::new(Field::new("item", DataType::Int32, true));
+//!         let i32_list_field = Arc::new(Field::new("i32_list", DataType::List(value_field), true));
+//!
+//!         StructArray::from(vec![
+//!             (i32_field, i32),
+//!             (string_field, string),
+//!             (i32_list_field, i32_list),
+//!         ])
+//!     }
+//! }
+//!
+//! impl<'a> Extend<&'a MyRow> for MyRowBuilder {
+//!     fn extend<T: IntoIterator<Item = &'a MyRow>>(&mut self, iter: T) {
+//!         iter.into_iter().for_each(|row| self.append(row));
+//!     }
+//! }
+//!
+//! /// Converts a slice of [`MyRow`] to a [`RecordBatch`]
+//! fn rows_to_batch(rows: &[MyRow]) -> RecordBatch {
+//!     let mut builder = MyRowBuilder::default();
+//!     builder.extend(rows);
+//!     RecordBatch::from(&builder.finish())
+//! }
+//! ```
+
+pub use arrow_buffer::BooleanBufferBuilder;
+
+mod boolean_builder;
+pub use boolean_builder::*;
+mod buffer_builder;
+pub use buffer_builder::*;
+mod fixed_size_binary_builder;
+pub use fixed_size_binary_builder::*;
+mod fixed_size_list_builder;
+pub use fixed_size_list_builder::*;
+mod generic_bytes_builder;
+pub use generic_bytes_builder::*;
+mod generic_list_builder;
+pub use generic_list_builder::*;
+mod map_builder;
+pub use map_builder::*;
+mod null_builder;
+pub use null_builder::*;
+mod primitive_builder;
+pub use primitive_builder::*;
+mod primitive_dictionary_builder;
+pub use primitive_dictionary_builder::*;
+mod primitive_run_builder;
+pub use primitive_run_builder::*;
+mod struct_builder;
+pub use struct_builder::*;
+mod generic_bytes_dictionary_builder;
+pub use generic_bytes_dictionary_builder::*;
+mod generic_byte_run_builder;
+pub use generic_byte_run_builder::*;
+mod union_builder;
+pub use union_builder::*;
+
+use crate::ArrayRef;
+use std::any::Any;
+
+/// Trait for dealing with different array builders at runtime
+///
+/// # Example
+///
+/// ```
+/// // Create
+/// # use arrow_array::{ArrayRef, StringArray};
+/// # use arrow_array::builder::{ArrayBuilder, Float64Builder, Int64Builder, StringBuilder};
+///
+/// let mut data_builders: Vec<Box<dyn ArrayBuilder>> = vec![
+///     Box::new(Float64Builder::new()),
+///     Box::new(Int64Builder::new()),
+///     Box::new(StringBuilder::new()),
+/// ];
+///
+/// // Fill
+/// data_builders[0]
+///     .as_any_mut()
+///     .downcast_mut::<Float64Builder>()
+///     .unwrap()
+///     .append_value(3.14);
+/// data_builders[1]
+///     .as_any_mut()
+///     .downcast_mut::<Int64Builder>()
+///     .unwrap()
+///     .append_value(-1);
+/// data_builders[2]
+///     .as_any_mut()
+///     .downcast_mut::<StringBuilder>()
+///     .unwrap()
+///     .append_value("🍎");
+///
+/// // Finish
+/// let array_refs: Vec<ArrayRef> = data_builders
+///     .iter_mut()
+///     .map(|builder| builder.finish())
+///     .collect();
+/// assert_eq!(array_refs[0].len(), 1);
+/// assert_eq!(array_refs[1].is_null(0), false);
+/// assert_eq!(
+///     array_refs[2]
+///         .as_any()
+///         .downcast_ref::<StringArray>()
+///         .unwrap()
+///         .value(0),
+///     "🍎"
+/// );
+/// ```
+pub trait ArrayBuilder: Any + Send + Sync {
+    /// Returns the number of array slots in the builder
+    fn len(&self) -> usize;
+
+    /// Returns whether number of array slots is zero
+    fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Builds the array
+    fn finish(&mut self) -> ArrayRef;
+
+    /// Builds the array without resetting the underlying builder.
+    fn finish_cloned(&self) -> ArrayRef;
+
+    /// Returns the builder as a non-mutable `Any` reference.
+    ///
+    /// This is most useful when one wants to call non-mutable APIs on a specific builder
+    /// type. In this case, one can first cast this into a `Any`, and then use
+    /// `downcast_ref` to get a reference on the specific builder.
+    fn as_any(&self) -> &dyn Any;
+
+    /// Returns the builder as a mutable `Any` reference.
+    ///
+    /// This is most useful when one wants to call mutable APIs on a specific builder
+    /// type. In this case, one can first cast this into a `Any`, and then use
+    /// `downcast_mut` to get a reference on the specific builder.
+    fn as_any_mut(&mut self) -> &mut dyn Any;
+
+    /// Returns the boxed builder as a box of `Any`.
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any>;
+}
+
+impl ArrayBuilder for Box<dyn ArrayBuilder> {
+    fn len(&self) -> usize {
+        (**self).len()
+    }
+
+    fn is_empty(&self) -> bool {
+        (**self).is_empty()
+    }
+
+    fn finish(&mut self) -> ArrayRef {
+        (**self).finish()
+    }
+
+    fn finish_cloned(&self) -> ArrayRef {
+        (**self).finish_cloned()
+    }
+
+    fn as_any(&self) -> &dyn Any {
+        (**self).as_any()
+    }
+
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        (**self).as_any_mut()
+    }
+
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+}
+
+/// Builder for [`ListArray`](crate::array::ListArray)
+pub type ListBuilder<T> = GenericListBuilder<i32, T>;
+
+/// Builder for [`LargeListArray`](crate::array::LargeListArray)
+pub type LargeListBuilder<T> = GenericListBuilder<i64, T>;
+
+/// Builder for [`BinaryArray`](crate::array::BinaryArray)
+pub type BinaryBuilder = GenericBinaryBuilder<i32>;
+
+/// Builder for [`LargeBinaryArray`](crate::array::LargeBinaryArray)
+pub type LargeBinaryBuilder = GenericBinaryBuilder<i64>;
+
+/// Builder for [`StringArray`](crate::array::StringArray)
+pub type StringBuilder = GenericStringBuilder<i32>;
+
+/// Builder for [`LargeStringArray`](crate::array::LargeStringArray)
+pub type LargeStringBuilder = GenericStringBuilder<i64>;
diff --git a/arrow-array/src/builder/null_builder.rs b/arrow-array/src/builder/null_builder.rs
new file mode 100644
index 000000000000..53a6b103d541
--- /dev/null
+++ b/arrow-array/src/builder/null_builder.rs
@@ -0,0 +1,180 @@
+// 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.
+
+use crate::builder::ArrayBuilder;
+use crate::{ArrayRef, NullArray};
+use arrow_data::ArrayData;
+use arrow_schema::DataType;
+use std::any::Any;
+use std::sync::Arc;
+
+/// Builder for [`NullArray`]
+///
+/// # Example
+///
+/// Create a `NullArray` from a `NullBuilder`
+///
+/// ```
+///
+/// # use arrow_array::{Array, NullArray, builder::NullBuilder};
+///
+/// let mut b = NullBuilder::new();
+/// b.append_empty_value();
+/// b.append_null();
+/// b.append_nulls(3);
+/// b.append_empty_values(3);
+/// let arr = b.finish();
+///
+/// assert_eq!(8, arr.len());
+/// assert_eq!(0, arr.null_count());
+/// ```
+#[derive(Debug)]
+pub struct NullBuilder {
+    len: usize,
+}
+
+impl Default for NullBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl NullBuilder {
+    /// Creates a new null builder
+    pub fn new() -> Self {
+        Self { len: 0 }
+    }
+
+    /// Creates a new null builder with space for `capacity` elements without re-allocating
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self { len: capacity }
+    }
+
+    /// Returns the capacity of this builder measured in slots of type `T`
+    pub fn capacity(&self) -> usize {
+        self.len
+    }
+
+    /// Appends a null slot into the builder
+    #[inline]
+    pub fn append_null(&mut self) {
+        self.len += 1;
+    }
+
+    /// Appends `n` `null`s into the builder.
+    #[inline]
+    pub fn append_nulls(&mut self, n: usize) {
+        self.len += n;
+    }
+
+    /// Appends a null slot into the builder
+    #[inline]
+    pub fn append_empty_value(&mut self) {
+        self.append_null();
+    }
+
+    /// Appends `n` `null`s into the builder.
+    #[inline]
+    pub fn append_empty_values(&mut self, n: usize) {
+        self.append_nulls(n);
+    }
+
+    /// Builds the [NullArray] and reset this builder.
+    pub fn finish(&mut self) -> NullArray {
+        let len = self.len();
+        let builder = ArrayData::new_null(&DataType::Null, len).into_builder();
+
+        let array_data = unsafe { builder.build_unchecked() };
+        NullArray::from(array_data)
+    }
+
+    /// Builds the [NullArray] without resetting the builder.
+    pub fn finish_cloned(&self) -> NullArray {
+        let len = self.len();
+        let builder = ArrayData::new_null(&DataType::Null, len).into_builder();
+
+        let array_data = unsafe { builder.build_unchecked() };
+        NullArray::from(array_data)
+    }
+}
+
+impl ArrayBuilder for NullBuilder {
+    /// Returns the builder as a non-mutable `Any` reference.
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// Returns the builder as a mutable `Any` reference.
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    /// Returns the boxed builder as a box of `Any`.
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    /// Returns the number of array slots in the builder
+    fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Builds the array and reset this builder.
+    fn finish(&mut self) -> ArrayRef {
+        Arc::new(self.finish())
+    }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Array;
+
+    #[test]
+    fn test_null_array_builder() {
+        let mut builder = NullArray::builder(10);
+        builder.append_null();
+        builder.append_nulls(4);
+        builder.append_empty_value();
+        builder.append_empty_values(4);
+
+        let arr = builder.finish();
+        assert_eq!(20, arr.len());
+        assert_eq!(0, arr.offset());
+        assert_eq!(0, arr.null_count());
+        assert!(arr.is_nullable());
+    }
+
+    #[test]
+    fn test_null_array_builder_finish_cloned() {
+        let mut builder = NullArray::builder(16);
+        builder.append_null();
+        builder.append_empty_value();
+        builder.append_empty_values(3);
+        let mut array = builder.finish_cloned();
+        assert_eq!(21, array.len());
+
+        builder.append_empty_values(5);
+        array = builder.finish();
+        assert_eq!(26, array.len());
+    }
+}
diff --git a/arrow/src/array/builder/primitive_builder.rs b/arrow-array/src/builder/primitive_builder.rs
similarity index 50%
rename from arrow/src/array/builder/primitive_builder.rs
rename to arrow-array/src/builder/primitive_builder.rs
index 3b9db1f01e67..0aad2dbfce0e 100644
--- a/arrow/src/array/builder/primitive_builder.rs
+++ b/arrow-array/src/builder/primitive_builder.rs
@@ -15,21 +15,89 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::builder::{ArrayBuilder, BufferBuilder};
+use crate::types::*;
+use crate::{ArrayRef, ArrowPrimitiveType, PrimitiveArray};
+use arrow_buffer::NullBufferBuilder;
+use arrow_buffer::{Buffer, MutableBuffer};
+use arrow_data::ArrayData;
+use arrow_schema::{ArrowError, DataType};
 use std::any::Any;
 use std::sync::Arc;
 
-use crate::array::ArrayData;
-use crate::array::ArrayRef;
-use crate::array::PrimitiveArray;
-use crate::datatypes::ArrowPrimitiveType;
-
-use super::{ArrayBuilder, BufferBuilder, NullBufferBuilder};
-
-///  Array builder for fixed-width primitive types
+/// A signed 8-bit integer array builder.
+pub type Int8Builder = PrimitiveBuilder<Int8Type>;
+/// A signed 16-bit integer array builder.
+pub type Int16Builder = PrimitiveBuilder<Int16Type>;
+/// A signed 32-bit integer array builder.
+pub type Int32Builder = PrimitiveBuilder<Int32Type>;
+/// A signed 64-bit integer array builder.
+pub type Int64Builder = PrimitiveBuilder<Int64Type>;
+/// An usigned 8-bit integer array builder.
+pub type UInt8Builder = PrimitiveBuilder<UInt8Type>;
+/// An usigned 16-bit integer array builder.
+pub type UInt16Builder = PrimitiveBuilder<UInt16Type>;
+/// An usigned 32-bit integer array builder.
+pub type UInt32Builder = PrimitiveBuilder<UInt32Type>;
+/// An usigned 64-bit integer array builder.
+pub type UInt64Builder = PrimitiveBuilder<UInt64Type>;
+/// A 16-bit floating point array builder.
+pub type Float16Builder = PrimitiveBuilder<Float16Type>;
+/// A 32-bit floating point array builder.
+pub type Float32Builder = PrimitiveBuilder<Float32Type>;
+/// A 64-bit floating point array builder.
+pub type Float64Builder = PrimitiveBuilder<Float64Type>;
+
+/// A timestamp second array builder.
+pub type TimestampSecondBuilder = PrimitiveBuilder<TimestampSecondType>;
+/// A timestamp millisecond array builder.
+pub type TimestampMillisecondBuilder = PrimitiveBuilder<TimestampMillisecondType>;
+/// A timestamp microsecond array builder.
+pub type TimestampMicrosecondBuilder = PrimitiveBuilder<TimestampMicrosecondType>;
+/// A timestamp nanosecond array builder.
+pub type TimestampNanosecondBuilder = PrimitiveBuilder<TimestampNanosecondType>;
+
+/// A 32-bit date array builder.
+pub type Date32Builder = PrimitiveBuilder<Date32Type>;
+/// A 64-bit date array builder.
+pub type Date64Builder = PrimitiveBuilder<Date64Type>;
+
+/// A 32-bit elaspsed time in seconds array builder.
+pub type Time32SecondBuilder = PrimitiveBuilder<Time32SecondType>;
+/// A 32-bit elaspsed time in milliseconds array builder.
+pub type Time32MillisecondBuilder = PrimitiveBuilder<Time32MillisecondType>;
+/// A 64-bit elaspsed time in microseconds array builder.
+pub type Time64MicrosecondBuilder = PrimitiveBuilder<Time64MicrosecondType>;
+/// A 64-bit elaspsed time in nanoseconds array builder.
+pub type Time64NanosecondBuilder = PrimitiveBuilder<Time64NanosecondType>;
+
+/// A “calendar” interval in months array builder.
+pub type IntervalYearMonthBuilder = PrimitiveBuilder<IntervalYearMonthType>;
+/// A “calendar” interval in days and milliseconds array builder.
+pub type IntervalDayTimeBuilder = PrimitiveBuilder<IntervalDayTimeType>;
+/// A “calendar” interval in months, days, and nanoseconds array builder.
+pub type IntervalMonthDayNanoBuilder = PrimitiveBuilder<IntervalMonthDayNanoType>;
+
+/// An elapsed time in seconds array builder.
+pub type DurationSecondBuilder = PrimitiveBuilder<DurationSecondType>;
+/// An elapsed time in milliseconds array builder.
+pub type DurationMillisecondBuilder = PrimitiveBuilder<DurationMillisecondType>;
+/// An elapsed time in microseconds array builder.
+pub type DurationMicrosecondBuilder = PrimitiveBuilder<DurationMicrosecondType>;
+/// An elapsed time in nanoseconds array builder.
+pub type DurationNanosecondBuilder = PrimitiveBuilder<DurationNanosecondType>;
+
+/// A decimal 128 array builder
+pub type Decimal128Builder = PrimitiveBuilder<Decimal128Type>;
+/// A decimal 256 array builder
+pub type Decimal256Builder = PrimitiveBuilder<Decimal256Type>;
+
+/// Builder for [`PrimitiveArray`]
 #[derive(Debug)]
 pub struct PrimitiveBuilder<T: ArrowPrimitiveType> {
     values_builder: BufferBuilder<T::Native>,
     null_buffer_builder: NullBufferBuilder,
+    data_type: DataType,
 }
 
 impl<T: ArrowPrimitiveType> ArrayBuilder for PrimitiveBuilder<T> {
@@ -53,26 +121,75 @@ impl<T: ArrowPrimitiveType> ArrayBuilder for PrimitiveBuilder<T> {
         self.values_builder.len()
     }
 
-    /// Returns whether the number of array slots is zero
-    fn is_empty(&self) -> bool {
-        self.values_builder.is_empty()
-    }
-
     /// Builds the array and reset this builder.
     fn finish(&mut self) -> ArrayRef {
         Arc::new(self.finish())
     }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+}
+
+impl<T: ArrowPrimitiveType> Default for PrimitiveBuilder<T> {
+    fn default() -> Self {
+        Self::new()
+    }
 }
 
 impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     /// Creates a new primitive array builder
-    pub fn new(capacity: usize) -> Self {
+    pub fn new() -> Self {
+        Self::with_capacity(1024)
+    }
+
+    /// Creates a new primitive array builder with capacity no of items
+    pub fn with_capacity(capacity: usize) -> Self {
         Self {
             values_builder: BufferBuilder::<T::Native>::new(capacity),
             null_buffer_builder: NullBufferBuilder::new(capacity),
+            data_type: T::DATA_TYPE,
         }
     }
 
+    /// Creates a new primitive array builder from buffers
+    pub fn new_from_buffer(
+        values_buffer: MutableBuffer,
+        null_buffer: Option<MutableBuffer>,
+    ) -> Self {
+        let values_builder = BufferBuilder::<T::Native>::new_from_buffer(values_buffer);
+
+        let null_buffer_builder = null_buffer
+            .map(|buffer| NullBufferBuilder::new_from_buffer(buffer, values_builder.len()))
+            .unwrap_or_else(|| NullBufferBuilder::new_with_len(values_builder.len()));
+
+        Self {
+            values_builder,
+            null_buffer_builder,
+            data_type: T::DATA_TYPE,
+        }
+    }
+
+    /// By default [`PrimitiveBuilder`] uses [`ArrowPrimitiveType::DATA_TYPE`] as the
+    /// data type of the generated array.
+    ///
+    /// This method allows overriding the data type, to allow specifying timezones
+    /// for [`DataType::Timestamp`] or precision and scale for [`DataType::Decimal128`] and [`DataType::Decimal256`]
+    ///
+    /// # Panics
+    ///
+    /// This method panics if `data_type` is not [PrimitiveArray::is_compatible]
+    pub fn with_data_type(self, data_type: DataType) -> Self {
+        assert!(
+            PrimitiveArray::<T>::is_compatible(&data_type),
+            "incompatible data type for builder, expected {} got {}",
+            T::DATA_TYPE,
+            data_type
+        );
+        Self { data_type, ..self }
+    }
+
     /// Returns the capacity of this builder measured in slots of type `T`
     pub fn capacity(&self) -> usize {
         self.values_builder.capacity()
@@ -92,6 +209,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
         self.values_builder.advance(1);
     }
 
+    /// Appends `n` no. of null's into the builder
     #[inline]
     pub fn append_nulls(&mut self, n: usize) {
         self.null_buffer_builder.append_n_nulls(n);
@@ -115,6 +233,10 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     }
 
     /// Appends values from a slice of type `T` and a validity boolean slice
+    ///
+    /// # Panics
+    ///
+    /// Panics if `values` and `is_valid` have different lengths
     #[inline]
     pub fn append_values(&mut self, values: &[T::Native], is_valid: &[bool]) {
         assert_eq!(
@@ -132,10 +254,7 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     /// This requires the iterator be a trusted length. This could instead require
     /// the iterator implement `TrustedLen` once that is stabilized.
     #[inline]
-    pub unsafe fn append_trusted_len_iter(
-        &mut self,
-        iter: impl IntoIterator<Item = T::Native>,
-    ) {
+    pub unsafe fn append_trusted_len_iter(&mut self, iter: impl IntoIterator<Item = T::Native>) {
         let iter = iter.into_iter();
         let len = iter
             .size_hint()
@@ -149,11 +268,25 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     /// Builds the [`PrimitiveArray`] and reset this builder.
     pub fn finish(&mut self) -> PrimitiveArray<T> {
         let len = self.len();
-        let null_bit_buffer = self.null_buffer_builder.finish();
-        let builder = ArrayData::builder(T::DATA_TYPE)
+        let nulls = self.null_buffer_builder.finish();
+        let builder = ArrayData::builder(self.data_type.clone())
             .len(len)
             .add_buffer(self.values_builder.finish())
-            .null_bit_buffer(null_bit_buffer);
+            .nulls(nulls);
+
+        let array_data = unsafe { builder.build_unchecked() };
+        PrimitiveArray::<T>::from(array_data)
+    }
+
+    /// Builds the [`PrimitiveArray`] without resetting the builder.
+    pub fn finish_cloned(&self) -> PrimitiveArray<T> {
+        let len = self.len();
+        let nulls = self.null_buffer_builder.finish_cloned();
+        let values_buffer = Buffer::from_slice_ref(self.values_builder.as_slice());
+        let builder = ArrayData::builder(self.data_type.clone())
+            .len(len)
+            .add_buffer(values_buffer)
+            .nulls(nulls);
 
         let array_data = unsafe { builder.build_unchecked() };
         PrimitiveArray::<T>::from(array_data)
@@ -163,19 +296,78 @@ impl<T: ArrowPrimitiveType> PrimitiveBuilder<T> {
     pub fn values_slice(&self) -> &[T::Native] {
         self.values_builder.as_slice()
     }
+
+    /// Returns the current values buffer as a mutable slice
+    pub fn values_slice_mut(&mut self) -> &mut [T::Native] {
+        self.values_builder.as_slice_mut()
+    }
+
+    /// Returns the current null buffer as a slice
+    pub fn validity_slice(&self) -> Option<&[u8]> {
+        self.null_buffer_builder.as_slice()
+    }
+
+    /// Returns the current null buffer as a mutable slice
+    pub fn validity_slice_mut(&mut self) -> Option<&mut [u8]> {
+        self.null_buffer_builder.as_slice_mut()
+    }
+
+    /// Returns the current values buffer and null buffer as a slice
+    pub fn slices_mut(&mut self) -> (&mut [T::Native], Option<&mut [u8]>) {
+        (
+            self.values_builder.as_slice_mut(),
+            self.null_buffer_builder.as_slice_mut(),
+        )
+    }
+}
+
+impl<P: DecimalType> PrimitiveBuilder<P> {
+    /// Sets the precision and scale
+    pub fn with_precision_and_scale(self, precision: u8, scale: i8) -> Result<Self, ArrowError> {
+        validate_decimal_precision_and_scale::<P>(precision, scale)?;
+        Ok(Self {
+            data_type: P::TYPE_CONSTRUCTOR(precision, scale),
+            ..self
+        })
+    }
+}
+
+impl<P: ArrowTimestampType> PrimitiveBuilder<P> {
+    /// Sets the timezone
+    pub fn with_timezone(self, timezone: impl Into<Arc<str>>) -> Self {
+        self.with_timezone_opt(Some(timezone.into()))
+    }
+
+    /// Sets an optional timezone
+    pub fn with_timezone_opt<S: Into<Arc<str>>>(self, timezone: Option<S>) -> Self {
+        Self {
+            data_type: DataType::Timestamp(P::UNIT, timezone.map(Into::into)),
+            ..self
+        }
+    }
+}
+
+impl<P: ArrowPrimitiveType> Extend<Option<P::Native>> for PrimitiveBuilder<P> {
+    #[inline]
+    fn extend<T: IntoIterator<Item = Option<P::Native>>>(&mut self, iter: T) {
+        for v in iter {
+            self.append_option(v)
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
+    use arrow_buffer::Buffer;
+    use arrow_schema::TimeUnit;
 
     use crate::array::Array;
     use crate::array::BooleanArray;
     use crate::array::Date32Array;
     use crate::array::Int32Array;
-    use crate::array::Int32Builder;
     use crate::array::TimestampSecondArray;
-    use crate::buffer::Buffer;
+    use crate::builder::Int32Builder;
 
     #[test]
     fn test_primitive_array_builder_i32() {
@@ -271,14 +463,14 @@ mod tests {
         }
 
         let arr = builder.finish();
-        assert_eq!(&buf, arr.values());
+        assert_eq!(&buf, arr.values().inner());
         assert_eq!(10, arr.len());
         assert_eq!(0, arr.offset());
         assert_eq!(0, arr.null_count());
         for i in 0..10 {
             assert!(!arr.is_null(i));
             assert!(arr.is_valid(i));
-            assert_eq!(i == 3 || i == 6 || i == 9, arr.value(i), "failed at {}", i)
+            assert_eq!(i == 3 || i == 6 || i == 9, arr.value(i), "failed at {i}")
         }
     }
 
@@ -355,7 +547,7 @@ mod tests {
 
     #[test]
     fn test_primitive_array_builder_finish() {
-        let mut builder = Int32Builder::new(5);
+        let mut builder = Int32Builder::new();
         builder.append_slice(&[2, 4, 6, 8]);
         let mut arr = builder.finish();
         assert_eq!(4, arr.len());
@@ -366,4 +558,56 @@ mod tests {
         assert_eq!(5, arr.len());
         assert_eq!(0, builder.len());
     }
+
+    #[test]
+    fn test_primitive_array_builder_finish_cloned() {
+        let mut builder = Int32Builder::new();
+        builder.append_value(23);
+        builder.append_value(45);
+        let result = builder.finish_cloned();
+        assert_eq!(result, Int32Array::from(vec![23, 45]));
+        builder.append_value(56);
+        assert_eq!(builder.finish_cloned(), Int32Array::from(vec![23, 45, 56]));
+
+        builder.append_slice(&[2, 4, 6, 8]);
+        let mut arr = builder.finish();
+        assert_eq!(7, arr.len());
+        assert_eq!(arr, Int32Array::from(vec![23, 45, 56, 2, 4, 6, 8]));
+        assert_eq!(0, builder.len());
+
+        builder.append_slice(&[1, 3, 5, 7, 9]);
+        arr = builder.finish();
+        assert_eq!(5, arr.len());
+        assert_eq!(0, builder.len());
+    }
+
+    #[test]
+    fn test_primitive_array_builder_with_data_type() {
+        let mut builder = Decimal128Builder::new().with_data_type(DataType::Decimal128(1, 2));
+        builder.append_value(1);
+        let array = builder.finish();
+        assert_eq!(array.precision(), 1);
+        assert_eq!(array.scale(), 2);
+
+        let data_type = DataType::Timestamp(TimeUnit::Nanosecond, Some("+00:00".into()));
+        let mut builder = TimestampNanosecondBuilder::new().with_data_type(data_type.clone());
+        builder.append_value(1);
+        let array = builder.finish();
+        assert_eq!(array.data_type(), &data_type);
+    }
+
+    #[test]
+    #[should_panic(expected = "incompatible data type for builder, expected Int32 got Int64")]
+    fn test_invalid_with_data_type() {
+        Int32Builder::new().with_data_type(DataType::Int64);
+    }
+
+    #[test]
+    fn test_extend() {
+        let mut builder = PrimitiveBuilder::<Int16Type>::new();
+        builder.extend([1, 2, 3, 5, 2, 4, 4].into_iter().map(Some));
+        builder.extend([2, 4, 6, 2].into_iter().map(Some));
+        let array = builder.finish();
+        assert_eq!(array.values(), &[1, 2, 3, 5, 2, 4, 4, 2, 4, 6, 2]);
+    }
 }
diff --git a/arrow-array/src/builder/primitive_dictionary_builder.rs b/arrow-array/src/builder/primitive_dictionary_builder.rs
new file mode 100644
index 000000000000..a47b2d30d4f3
--- /dev/null
+++ b/arrow-array/src/builder/primitive_dictionary_builder.rs
@@ -0,0 +1,398 @@
+// 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.
+
+use crate::builder::{ArrayBuilder, PrimitiveBuilder};
+use crate::types::ArrowDictionaryKeyType;
+use crate::{Array, ArrayRef, ArrowPrimitiveType, DictionaryArray};
+use arrow_buffer::{ArrowNativeType, ToByteSlice};
+use arrow_schema::{ArrowError, DataType};
+use std::any::Any;
+use std::collections::hash_map::Entry;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+/// Wraps a type implementing `ToByteSlice` implementing `Hash` and `Eq` for it
+///
+/// This is necessary to handle types such as f32, which don't natively implement these
+#[derive(Debug)]
+struct Value<T>(T);
+
+impl<T: ToByteSlice> std::hash::Hash for Value<T> {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.to_byte_slice().hash(state)
+    }
+}
+
+impl<T: ToByteSlice> PartialEq for Value<T> {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.to_byte_slice().eq(other.0.to_byte_slice())
+    }
+}
+
+impl<T: ToByteSlice> Eq for Value<T> {}
+
+/// Builder for [`DictionaryArray`] of [`PrimitiveArray`](crate::array::PrimitiveArray)
+///
+/// # Example:
+///
+/// ```
+///
+/// # use arrow_array::builder::PrimitiveDictionaryBuilder;
+/// # use arrow_array::types::{UInt32Type, UInt8Type};
+/// # use arrow_array::{Array, UInt32Array, UInt8Array};
+///
+/// let mut builder = PrimitiveDictionaryBuilder::<UInt8Type, UInt32Type>::new();
+///  builder.append(12345678).unwrap();
+///  builder.append_null();
+///  builder.append(22345678).unwrap();
+///  let array = builder.finish();
+///
+///  assert_eq!(
+///      array.keys(),
+///      &UInt8Array::from(vec![Some(0), None, Some(1)])
+///  );
+///
+///  // Values are polymorphic and so require a downcast.
+///  let av = array.values();
+///  let ava: &UInt32Array = av.as_any().downcast_ref::<UInt32Array>().unwrap();
+///  let avs: &[u32] = ava.values();
+///
+///  assert!(!array.is_null(0));
+///  assert!(array.is_null(1));
+///  assert!(!array.is_null(2));
+///
+///  assert_eq!(avs, &[12345678, 22345678]);
+/// ```
+#[derive(Debug)]
+pub struct PrimitiveDictionaryBuilder<K, V>
+where
+    K: ArrowPrimitiveType,
+    V: ArrowPrimitiveType,
+{
+    keys_builder: PrimitiveBuilder<K>,
+    values_builder: PrimitiveBuilder<V>,
+    map: HashMap<Value<V::Native>, usize>,
+}
+
+impl<K, V> Default for PrimitiveDictionaryBuilder<K, V>
+where
+    K: ArrowPrimitiveType,
+    V: ArrowPrimitiveType,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<K, V> PrimitiveDictionaryBuilder<K, V>
+where
+    K: ArrowPrimitiveType,
+    V: ArrowPrimitiveType,
+{
+    /// Creates a new `PrimitiveDictionaryBuilder`.
+    pub fn new() -> Self {
+        Self {
+            keys_builder: PrimitiveBuilder::new(),
+            values_builder: PrimitiveBuilder::new(),
+            map: HashMap::new(),
+        }
+    }
+
+    /// Creates a new `PrimitiveDictionaryBuilder` from the provided keys and values builders.
+    ///
+    /// # Panics
+    ///
+    /// This method panics if `keys_builder` or `values_builder` is not empty.
+    pub fn new_from_empty_builders(
+        keys_builder: PrimitiveBuilder<K>,
+        values_builder: PrimitiveBuilder<V>,
+    ) -> Self {
+        assert!(
+            keys_builder.is_empty() && values_builder.is_empty(),
+            "keys and values builders must be empty"
+        );
+        Self {
+            keys_builder,
+            values_builder,
+            map: HashMap::new(),
+        }
+    }
+
+    /// Creates a new `PrimitiveDictionaryBuilder` from existing `PrimitiveBuilder`s of keys and values.
+    ///
+    /// # Safety
+    ///
+    /// caller must ensure that the passed in builders are valid for DictionaryArray.
+    pub unsafe fn new_from_builders(
+        keys_builder: PrimitiveBuilder<K>,
+        values_builder: PrimitiveBuilder<V>,
+    ) -> Self {
+        let keys = keys_builder.values_slice();
+        let values = values_builder.values_slice();
+        let mut map = HashMap::with_capacity(values.len());
+
+        keys.iter().zip(values.iter()).for_each(|(key, value)| {
+            map.insert(Value(*value), K::Native::to_usize(*key).unwrap());
+        });
+
+        Self {
+            keys_builder,
+            values_builder,
+            map,
+        }
+    }
+
+    /// Creates a new `PrimitiveDictionaryBuilder` with the provided capacities
+    ///
+    /// `keys_capacity`: the number of keys, i.e. length of array to build
+    /// `values_capacity`: the number of distinct dictionary values, i.e. size of dictionary
+    pub fn with_capacity(keys_capacity: usize, values_capacity: usize) -> Self {
+        Self {
+            keys_builder: PrimitiveBuilder::with_capacity(keys_capacity),
+            values_builder: PrimitiveBuilder::with_capacity(values_capacity),
+            map: HashMap::with_capacity(values_capacity),
+        }
+    }
+}
+
+impl<K, V> ArrayBuilder for PrimitiveDictionaryBuilder<K, V>
+where
+    K: ArrowDictionaryKeyType,
+    V: ArrowPrimitiveType,
+{
+    /// Returns the builder as an non-mutable `Any` reference.
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// Returns the builder as an mutable `Any` reference.
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    /// Returns the boxed builder as a box of `Any`.
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    /// Returns the number of array slots in the builder
+    fn len(&self) -> usize {
+        self.keys_builder.len()
+    }
+
+    /// Builds the array and reset this builder.
+    fn finish(&mut self) -> ArrayRef {
+        Arc::new(self.finish())
+    }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+}
+
+impl<K, V> PrimitiveDictionaryBuilder<K, V>
+where
+    K: ArrowDictionaryKeyType,
+    V: ArrowPrimitiveType,
+{
+    /// Append a primitive value to the array. Return an existing index
+    /// if already present in the values array or a new index if the
+    /// value is appended to the values array.
+    #[inline]
+    pub fn append(&mut self, value: V::Native) -> Result<K::Native, ArrowError> {
+        let key = match self.map.entry(Value(value)) {
+            Entry::Vacant(vacant) => {
+                // Append new value.
+                let key = self.values_builder.len();
+                self.values_builder.append_value(value);
+                vacant.insert(key);
+                K::Native::from_usize(key).ok_or(ArrowError::DictionaryKeyOverflowError)?
+            }
+            Entry::Occupied(o) => K::Native::usize_as(*o.get()),
+        };
+
+        self.keys_builder.append_value(key);
+        Ok(key)
+    }
+
+    /// Infallibly append a value to this builder
+    ///
+    /// # Panics
+    ///
+    /// Panics if the resulting length of the dictionary values array would exceed `T::Native::MAX`
+    #[inline]
+    pub fn append_value(&mut self, value: V::Native) {
+        self.append(value).expect("dictionary key overflow");
+    }
+
+    /// Appends a null slot into the builder
+    #[inline]
+    pub fn append_null(&mut self) {
+        self.keys_builder.append_null()
+    }
+
+    /// Append an `Option` value into the builder
+    ///
+    /// # Panics
+    ///
+    /// Panics if the resulting length of the dictionary values array would exceed `T::Native::MAX`
+    #[inline]
+    pub fn append_option(&mut self, value: Option<V::Native>) {
+        match value {
+            None => self.append_null(),
+            Some(v) => self.append_value(v),
+        };
+    }
+
+    /// Builds the `DictionaryArray` and reset this builder.
+    pub fn finish(&mut self) -> DictionaryArray<K> {
+        self.map.clear();
+        let values = self.values_builder.finish();
+        let keys = self.keys_builder.finish();
+
+        let data_type =
+            DataType::Dictionary(Box::new(K::DATA_TYPE), Box::new(values.data_type().clone()));
+
+        let builder = keys
+            .into_data()
+            .into_builder()
+            .data_type(data_type)
+            .child_data(vec![values.into_data()]);
+
+        DictionaryArray::from(unsafe { builder.build_unchecked() })
+    }
+
+    /// Builds the `DictionaryArray` without resetting the builder.
+    pub fn finish_cloned(&self) -> DictionaryArray<K> {
+        let values = self.values_builder.finish_cloned();
+        let keys = self.keys_builder.finish_cloned();
+
+        let data_type = DataType::Dictionary(Box::new(K::DATA_TYPE), Box::new(V::DATA_TYPE));
+
+        let builder = keys
+            .into_data()
+            .into_builder()
+            .data_type(data_type)
+            .child_data(vec![values.into_data()]);
+
+        DictionaryArray::from(unsafe { builder.build_unchecked() })
+    }
+
+    /// Returns the current dictionary values buffer as a slice
+    pub fn values_slice(&self) -> &[V::Native] {
+        self.values_builder.values_slice()
+    }
+
+    /// Returns the current dictionary values buffer as a mutable slice
+    pub fn values_slice_mut(&mut self) -> &mut [V::Native] {
+        self.values_builder.values_slice_mut()
+    }
+}
+
+impl<K: ArrowDictionaryKeyType, P: ArrowPrimitiveType> Extend<Option<P::Native>>
+    for PrimitiveDictionaryBuilder<K, P>
+{
+    #[inline]
+    fn extend<T: IntoIterator<Item = Option<P::Native>>>(&mut self, iter: T) {
+        for v in iter {
+            self.append_option(v)
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::array::Array;
+    use crate::array::UInt32Array;
+    use crate::array::UInt8Array;
+    use crate::builder::Decimal128Builder;
+    use crate::types::{Decimal128Type, Int32Type, UInt32Type, UInt8Type};
+
+    #[test]
+    fn test_primitive_dictionary_builder() {
+        let mut builder = PrimitiveDictionaryBuilder::<UInt8Type, UInt32Type>::with_capacity(3, 2);
+        builder.append(12345678).unwrap();
+        builder.append_null();
+        builder.append(22345678).unwrap();
+        let array = builder.finish();
+
+        assert_eq!(
+            array.keys(),
+            &UInt8Array::from(vec![Some(0), None, Some(1)])
+        );
+
+        // Values are polymorphic and so require a downcast.
+        let av = array.values();
+        let ava: &UInt32Array = av.as_any().downcast_ref::<UInt32Array>().unwrap();
+        let avs: &[u32] = ava.values();
+
+        assert!(!array.is_null(0));
+        assert!(array.is_null(1));
+        assert!(!array.is_null(2));
+
+        assert_eq!(avs, &[12345678, 22345678]);
+    }
+
+    #[test]
+    fn test_extend() {
+        let mut builder = PrimitiveDictionaryBuilder::<Int32Type, Int32Type>::new();
+        builder.extend([1, 2, 3, 1, 2, 3, 1, 2, 3].into_iter().map(Some));
+        builder.extend([4, 5, 1, 3, 1].into_iter().map(Some));
+        let dict = builder.finish();
+        assert_eq!(
+            dict.keys().values(),
+            &[0, 1, 2, 0, 1, 2, 0, 1, 2, 3, 4, 0, 2, 0]
+        );
+        assert_eq!(dict.values().len(), 5);
+    }
+
+    #[test]
+    #[should_panic(expected = "DictionaryKeyOverflowError")]
+    fn test_primitive_dictionary_overflow() {
+        let mut builder =
+            PrimitiveDictionaryBuilder::<UInt8Type, UInt32Type>::with_capacity(257, 257);
+        // 256 unique keys.
+        for i in 0..256 {
+            builder.append(i + 1000).unwrap();
+        }
+        // Special error if the key overflows (256th entry)
+        builder.append(1257).unwrap();
+    }
+
+    #[test]
+    fn test_primitive_dictionary_with_builders() {
+        let keys_builder = PrimitiveBuilder::<Int32Type>::new();
+        let values_builder = Decimal128Builder::new().with_data_type(DataType::Decimal128(1, 2));
+        let mut builder =
+            PrimitiveDictionaryBuilder::<Int32Type, Decimal128Type>::new_from_empty_builders(
+                keys_builder,
+                values_builder,
+            );
+        let dict_array = builder.finish();
+        assert_eq!(dict_array.value_type(), DataType::Decimal128(1, 2));
+        assert_eq!(
+            dict_array.data_type(),
+            &DataType::Dictionary(
+                Box::new(DataType::Int32),
+                Box::new(DataType::Decimal128(1, 2)),
+            )
+        );
+    }
+}
diff --git a/arrow-array/src/builder/primitive_run_builder.rs b/arrow-array/src/builder/primitive_run_builder.rs
new file mode 100644
index 000000000000..01a989199b58
--- /dev/null
+++ b/arrow-array/src/builder/primitive_run_builder.rs
@@ -0,0 +1,311 @@
+// 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.
+
+use std::{any::Any, sync::Arc};
+
+use crate::{types::RunEndIndexType, ArrayRef, ArrowPrimitiveType, RunArray};
+
+use super::{ArrayBuilder, PrimitiveBuilder};
+
+use arrow_buffer::ArrowNativeType;
+
+/// Builder for [`RunArray`] of [`PrimitiveArray`](crate::array::PrimitiveArray)
+///
+/// # Example:
+///
+/// ```
+///
+/// # use arrow_array::builder::PrimitiveRunBuilder;
+/// # use arrow_array::cast::AsArray;
+/// # use arrow_array::types::{UInt32Type, Int16Type};
+/// # use arrow_array::{Array, UInt32Array, Int16Array};
+///
+/// let mut builder =
+/// PrimitiveRunBuilder::<Int16Type, UInt32Type>::new();
+/// builder.append_value(1234);
+/// builder.append_value(1234);
+/// builder.append_value(1234);
+/// builder.append_null();
+/// builder.append_value(5678);
+/// builder.append_value(5678);
+/// let array = builder.finish();
+///
+/// assert_eq!(array.run_ends().values(), &[3, 4, 6]);
+///
+/// let av = array.values();
+///
+/// assert!(!av.is_null(0));
+/// assert!(av.is_null(1));
+/// assert!(!av.is_null(2));
+///
+/// // Values are polymorphic and so require a downcast.
+/// let ava: &UInt32Array = av.as_primitive::<UInt32Type>();
+///
+/// assert_eq!(ava, &UInt32Array::from(vec![Some(1234), None, Some(5678)]));
+/// ```
+#[derive(Debug)]
+pub struct PrimitiveRunBuilder<R, V>
+where
+    R: RunEndIndexType,
+    V: ArrowPrimitiveType,
+{
+    run_ends_builder: PrimitiveBuilder<R>,
+    values_builder: PrimitiveBuilder<V>,
+    current_value: Option<V::Native>,
+    current_run_end_index: usize,
+    prev_run_end_index: usize,
+}
+
+impl<R, V> Default for PrimitiveRunBuilder<R, V>
+where
+    R: RunEndIndexType,
+    V: ArrowPrimitiveType,
+{
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<R, V> PrimitiveRunBuilder<R, V>
+where
+    R: RunEndIndexType,
+    V: ArrowPrimitiveType,
+{
+    /// Creates a new `PrimitiveRunBuilder`
+    pub fn new() -> Self {
+        Self {
+            run_ends_builder: PrimitiveBuilder::new(),
+            values_builder: PrimitiveBuilder::new(),
+            current_value: None,
+            current_run_end_index: 0,
+            prev_run_end_index: 0,
+        }
+    }
+
+    /// Creates a new `PrimitiveRunBuilder` with the provided capacity
+    ///
+    /// `capacity`: the expected number of run-end encoded values.
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            run_ends_builder: PrimitiveBuilder::with_capacity(capacity),
+            values_builder: PrimitiveBuilder::with_capacity(capacity),
+            current_value: None,
+            current_run_end_index: 0,
+            prev_run_end_index: 0,
+        }
+    }
+}
+
+impl<R, V> ArrayBuilder for PrimitiveRunBuilder<R, V>
+where
+    R: RunEndIndexType,
+    V: ArrowPrimitiveType,
+{
+    /// Returns the builder as a non-mutable `Any` reference.
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// Returns the builder as a mutable `Any` reference.
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    /// Returns the boxed builder as a box of `Any`.
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+
+    /// Returns the length of logical array encoded by
+    /// the eventual runs array.
+    fn len(&self) -> usize {
+        self.current_run_end_index
+    }
+
+    /// Builds the array and reset this builder.
+    fn finish(&mut self) -> ArrayRef {
+        Arc::new(self.finish())
+    }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+}
+
+impl<R, V> PrimitiveRunBuilder<R, V>
+where
+    R: RunEndIndexType,
+    V: ArrowPrimitiveType,
+{
+    /// Appends optional value to the logical array encoded by the RunArray.
+    pub fn append_option(&mut self, value: Option<V::Native>) {
+        if self.current_run_end_index == 0 {
+            self.current_run_end_index = 1;
+            self.current_value = value;
+            return;
+        }
+        if self.current_value != value {
+            self.append_run_end();
+            self.current_value = value;
+        }
+
+        self.current_run_end_index += 1;
+    }
+
+    /// Appends value to the logical array encoded by the run-ends array.
+    pub fn append_value(&mut self, value: V::Native) {
+        self.append_option(Some(value))
+    }
+
+    /// Appends null to the logical array encoded by the run-ends array.
+    pub fn append_null(&mut self) {
+        self.append_option(None)
+    }
+
+    /// Creates the RunArray and resets the builder.
+    /// Panics if RunArray cannot be built.
+    pub fn finish(&mut self) -> RunArray<R> {
+        // write the last run end to the array.
+        self.append_run_end();
+
+        // reset the run index to zero.
+        self.current_value = None;
+        self.current_run_end_index = 0;
+
+        // build the run encoded array by adding run_ends and values array as its children.
+        let run_ends_array = self.run_ends_builder.finish();
+        let values_array = self.values_builder.finish();
+        RunArray::<R>::try_new(&run_ends_array, &values_array).unwrap()
+    }
+
+    /// Creates the RunArray and without resetting the builder.
+    /// Panics if RunArray cannot be built.
+    pub fn finish_cloned(&self) -> RunArray<R> {
+        let mut run_ends_array = self.run_ends_builder.finish_cloned();
+        let mut values_array = self.values_builder.finish_cloned();
+
+        // Add current run if one exists
+        if self.prev_run_end_index != self.current_run_end_index {
+            let mut run_end_builder = run_ends_array.into_builder().unwrap();
+            let mut values_builder = values_array.into_builder().unwrap();
+            self.append_run_end_with_builders(&mut run_end_builder, &mut values_builder);
+            run_ends_array = run_end_builder.finish();
+            values_array = values_builder.finish();
+        }
+
+        RunArray::try_new(&run_ends_array, &values_array).unwrap()
+    }
+
+    // Appends the current run to the array.
+    fn append_run_end(&mut self) {
+        // empty array or the function called without appending any value.
+        if self.prev_run_end_index == self.current_run_end_index {
+            return;
+        }
+        let run_end_index = self.run_end_index_as_native();
+        self.run_ends_builder.append_value(run_end_index);
+        self.values_builder.append_option(self.current_value);
+        self.prev_run_end_index = self.current_run_end_index;
+    }
+
+    // Similar to `append_run_end` but on custom builders.
+    // Used in `finish_cloned` which is not suppose to mutate `self`.
+    fn append_run_end_with_builders(
+        &self,
+        run_ends_builder: &mut PrimitiveBuilder<R>,
+        values_builder: &mut PrimitiveBuilder<V>,
+    ) {
+        let run_end_index = self.run_end_index_as_native();
+        run_ends_builder.append_value(run_end_index);
+        values_builder.append_option(self.current_value);
+    }
+
+    fn run_end_index_as_native(&self) -> R::Native {
+        R::Native::from_usize(self.current_run_end_index)
+        .unwrap_or_else(|| panic!(
+                "Cannot convert `current_run_end_index` {} from `usize` to native form of arrow datatype {}",
+                self.current_run_end_index,
+                R::DATA_TYPE
+        ))
+    }
+}
+
+impl<R, V> Extend<Option<V::Native>> for PrimitiveRunBuilder<R, V>
+where
+    R: RunEndIndexType,
+    V: ArrowPrimitiveType,
+{
+    fn extend<T: IntoIterator<Item = Option<V::Native>>>(&mut self, iter: T) {
+        for elem in iter {
+            self.append_option(elem);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::builder::PrimitiveRunBuilder;
+    use crate::cast::AsArray;
+    use crate::types::{Int16Type, UInt32Type};
+    use crate::{Array, UInt32Array};
+
+    #[test]
+    fn test_primitive_ree_array_builder() {
+        let mut builder = PrimitiveRunBuilder::<Int16Type, UInt32Type>::new();
+        builder.append_value(1234);
+        builder.append_value(1234);
+        builder.append_value(1234);
+        builder.append_null();
+        builder.append_value(5678);
+        builder.append_value(5678);
+
+        let array = builder.finish();
+
+        assert_eq!(array.null_count(), 0);
+        assert_eq!(array.len(), 6);
+
+        assert_eq!(array.run_ends().values(), &[3, 4, 6]);
+
+        let av = array.values();
+
+        assert!(!av.is_null(0));
+        assert!(av.is_null(1));
+        assert!(!av.is_null(2));
+
+        // Values are polymorphic and so require a downcast.
+        let ava: &UInt32Array = av.as_primitive::<UInt32Type>();
+
+        assert_eq!(ava, &UInt32Array::from(vec![Some(1234), None, Some(5678)]));
+    }
+
+    #[test]
+    fn test_extend() {
+        let mut builder = PrimitiveRunBuilder::<Int16Type, Int16Type>::new();
+        builder.extend([1, 2, 2, 5, 5, 4, 4].into_iter().map(Some));
+        builder.extend([4, 4, 6, 2].into_iter().map(Some));
+        let array = builder.finish();
+
+        assert_eq!(array.len(), 11);
+        assert_eq!(array.null_count(), 0);
+        assert_eq!(array.run_ends().values(), &[1, 3, 5, 9, 10, 11]);
+        assert_eq!(
+            array.values().as_primitive::<Int16Type>().values(),
+            &[1, 2, 5, 4, 6, 2]
+        );
+    }
+}
diff --git a/arrow-array/src/builder/struct_builder.rs b/arrow-array/src/builder/struct_builder.rs
new file mode 100644
index 000000000000..917b58522f66
--- /dev/null
+++ b/arrow-array/src/builder/struct_builder.rs
@@ -0,0 +1,646 @@
+// 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.
+
+use crate::builder::*;
+use crate::{ArrayRef, StructArray};
+use arrow_buffer::NullBufferBuilder;
+use arrow_schema::{DataType, Fields, IntervalUnit, SchemaBuilder, TimeUnit};
+use std::any::Any;
+use std::sync::Arc;
+
+/// Builder for [`StructArray`]
+///
+/// Note that callers should make sure that methods of all the child field builders are
+/// properly called to maintain the consistency of the data structure.
+pub struct StructBuilder {
+    fields: Fields,
+    field_builders: Vec<Box<dyn ArrayBuilder>>,
+    null_buffer_builder: NullBufferBuilder,
+}
+
+impl std::fmt::Debug for StructBuilder {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("StructBuilder")
+            .field("fields", &self.fields)
+            .field("bitmap_builder", &self.null_buffer_builder)
+            .field("len", &self.len())
+            .finish()
+    }
+}
+
+impl ArrayBuilder for StructBuilder {
+    /// Returns the number of array slots in the builder.
+    ///
+    /// Note that this always return the first child field builder's length, and it is
+    /// the caller's responsibility to maintain the consistency that all the child field
+    /// builder should have the equal number of elements.
+    fn len(&self) -> usize {
+        self.null_buffer_builder.len()
+    }
+
+    /// Builds the array.
+    fn finish(&mut self) -> ArrayRef {
+        Arc::new(self.finish())
+    }
+
+    /// Builds the array without resetting the builder.
+    fn finish_cloned(&self) -> ArrayRef {
+        Arc::new(self.finish_cloned())
+    }
+
+    /// Returns the builder as a non-mutable `Any` reference.
+    ///
+    /// This is most useful when one wants to call non-mutable APIs on a specific builder
+    /// type. In this case, one can first cast this into a `Any`, and then use
+    /// `downcast_ref` to get a reference on the specific builder.
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    /// Returns the builder as a mutable `Any` reference.
+    ///
+    /// This is most useful when one wants to call mutable APIs on a specific builder
+    /// type. In this case, one can first cast this into a `Any`, and then use
+    /// `downcast_mut` to get a reference on the specific builder.
+    fn as_any_mut(&mut self) -> &mut dyn Any {
+        self
+    }
+
+    /// Returns the boxed builder as a box of `Any`.
+    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
+        self
+    }
+}
+
+/// Returns a builder with capacity `capacity` that corresponds to the datatype `DataType`
+/// This function is useful to construct arrays from an arbitrary vectors with known/expected
+/// schema.
+pub fn make_builder(datatype: &DataType, capacity: usize) -> Box<dyn ArrayBuilder> {
+    use crate::builder::*;
+    match datatype {
+        DataType::Null => Box::new(NullBuilder::with_capacity(capacity)),
+        DataType::Boolean => Box::new(BooleanBuilder::with_capacity(capacity)),
+        DataType::Int8 => Box::new(Int8Builder::with_capacity(capacity)),
+        DataType::Int16 => Box::new(Int16Builder::with_capacity(capacity)),
+        DataType::Int32 => Box::new(Int32Builder::with_capacity(capacity)),
+        DataType::Int64 => Box::new(Int64Builder::with_capacity(capacity)),
+        DataType::UInt8 => Box::new(UInt8Builder::with_capacity(capacity)),
+        DataType::UInt16 => Box::new(UInt16Builder::with_capacity(capacity)),
+        DataType::UInt32 => Box::new(UInt32Builder::with_capacity(capacity)),
+        DataType::UInt64 => Box::new(UInt64Builder::with_capacity(capacity)),
+        DataType::Float16 => Box::new(Float16Builder::with_capacity(capacity)),
+        DataType::Float32 => Box::new(Float32Builder::with_capacity(capacity)),
+        DataType::Float64 => Box::new(Float64Builder::with_capacity(capacity)),
+        DataType::Binary => Box::new(BinaryBuilder::with_capacity(capacity, 1024)),
+        DataType::LargeBinary => Box::new(LargeBinaryBuilder::with_capacity(capacity, 1024)),
+        DataType::FixedSizeBinary(len) => {
+            Box::new(FixedSizeBinaryBuilder::with_capacity(capacity, *len))
+        }
+        DataType::Decimal128(p, s) => Box::new(
+            Decimal128Builder::with_capacity(capacity).with_data_type(DataType::Decimal128(*p, *s)),
+        ),
+        DataType::Decimal256(p, s) => Box::new(
+            Decimal256Builder::with_capacity(capacity).with_data_type(DataType::Decimal256(*p, *s)),
+        ),
+        DataType::Utf8 => Box::new(StringBuilder::with_capacity(capacity, 1024)),
+        DataType::LargeUtf8 => Box::new(LargeStringBuilder::with_capacity(capacity, 1024)),
+        DataType::Date32 => Box::new(Date32Builder::with_capacity(capacity)),
+        DataType::Date64 => Box::new(Date64Builder::with_capacity(capacity)),
+        DataType::Time32(TimeUnit::Second) => {
+            Box::new(Time32SecondBuilder::with_capacity(capacity))
+        }
+        DataType::Time32(TimeUnit::Millisecond) => {
+            Box::new(Time32MillisecondBuilder::with_capacity(capacity))
+        }
+        DataType::Time64(TimeUnit::Microsecond) => {
+            Box::new(Time64MicrosecondBuilder::with_capacity(capacity))
+        }
+        DataType::Time64(TimeUnit::Nanosecond) => {
+            Box::new(Time64NanosecondBuilder::with_capacity(capacity))
+        }
+        DataType::Timestamp(TimeUnit::Second, tz) => Box::new(
+            TimestampSecondBuilder::with_capacity(capacity)
+                .with_data_type(DataType::Timestamp(TimeUnit::Second, tz.clone())),
+        ),
+        DataType::Timestamp(TimeUnit::Millisecond, tz) => Box::new(
+            TimestampMillisecondBuilder::with_capacity(capacity)
+                .with_data_type(DataType::Timestamp(TimeUnit::Millisecond, tz.clone())),
+        ),
+        DataType::Timestamp(TimeUnit::Microsecond, tz) => Box::new(
+            TimestampMicrosecondBuilder::with_capacity(capacity)
+                .with_data_type(DataType::Timestamp(TimeUnit::Microsecond, tz.clone())),
+        ),
+        DataType::Timestamp(TimeUnit::Nanosecond, tz) => Box::new(
+            TimestampNanosecondBuilder::with_capacity(capacity)
+                .with_data_type(DataType::Timestamp(TimeUnit::Nanosecond, tz.clone())),
+        ),
+        DataType::Interval(IntervalUnit::YearMonth) => {
+            Box::new(IntervalYearMonthBuilder::with_capacity(capacity))
+        }
+        DataType::Interval(IntervalUnit::DayTime) => {
+            Box::new(IntervalDayTimeBuilder::with_capacity(capacity))
+        }
+        DataType::Interval(IntervalUnit::MonthDayNano) => {
+            Box::new(IntervalMonthDayNanoBuilder::with_capacity(capacity))
+        }
+        DataType::Duration(TimeUnit::Second) => {
+            Box::new(DurationSecondBuilder::with_capacity(capacity))
+        }
+        DataType::Duration(TimeUnit::Millisecond) => {
+            Box::new(DurationMillisecondBuilder::with_capacity(capacity))
+        }
+        DataType::Duration(TimeUnit::Microsecond) => {
+            Box::new(DurationMicrosecondBuilder::with_capacity(capacity))
+        }
+        DataType::Duration(TimeUnit::Nanosecond) => {
+            Box::new(DurationNanosecondBuilder::with_capacity(capacity))
+        }
+        DataType::List(field) => {
+            let builder = make_builder(field.data_type(), capacity);
+            Box::new(ListBuilder::with_capacity(builder, capacity))
+        }
+        DataType::LargeList(field) => {
+            let builder = make_builder(field.data_type(), capacity);
+            Box::new(LargeListBuilder::with_capacity(builder, capacity))
+        }
+        DataType::Map(field, _) => match field.data_type() {
+            DataType::Struct(fields) => {
+                let map_field_names = MapFieldNames {
+                    key: fields[0].name().clone(),
+                    value: fields[1].name().clone(),
+                    entry: field.name().clone(),
+                };
+                let key_builder = make_builder(fields[0].data_type(), capacity);
+                let value_builder = make_builder(fields[1].data_type(), capacity);
+                Box::new(MapBuilder::with_capacity(
+                    Some(map_field_names),
+                    key_builder,
+                    value_builder,
+                    capacity,
+                ))
+            }
+            t => panic!("The field of Map data type {t:?} should has a child Struct field"),
+        },
+        DataType::Struct(fields) => Box::new(StructBuilder::from_fields(fields.clone(), capacity)),
+        t => panic!("Data type {t:?} is not currently supported"),
+    }
+}
+
+impl StructBuilder {
+    /// Creates a new `StructBuilder`
+    pub fn new(fields: impl Into<Fields>, field_builders: Vec<Box<dyn ArrayBuilder>>) -> Self {
+        Self {
+            field_builders,
+            fields: fields.into(),
+            null_buffer_builder: NullBufferBuilder::new(0),
+        }
+    }
+
+    /// Creates a new `StructBuilder` from [`Fields`] and `capacity`
+    pub fn from_fields(fields: impl Into<Fields>, capacity: usize) -> Self {
+        let fields = fields.into();
+        let mut builders = Vec::with_capacity(fields.len());
+        for field in &fields {
+            builders.push(make_builder(field.data_type(), capacity));
+        }
+        Self::new(fields, builders)
+    }
+
+    /// Returns a mutable reference to the child field builder at index `i`.
+    /// Result will be `None` if the input type `T` provided doesn't match the actual
+    /// field builder's type.
+    pub fn field_builder<T: ArrayBuilder>(&mut self, i: usize) -> Option<&mut T> {
+        self.field_builders[i].as_any_mut().downcast_mut::<T>()
+    }
+
+    /// Returns the number of fields for the struct this builder is building.
+    pub fn num_fields(&self) -> usize {
+        self.field_builders.len()
+    }
+
+    /// Appends an element (either null or non-null) to the struct. The actual elements
+    /// should be appended for each child sub-array in a consistent way.
+    #[inline]
+    pub fn append(&mut self, is_valid: bool) {
+        self.null_buffer_builder.append(is_valid);
+    }
+
+    /// Appends a null element to the struct.
+    #[inline]
+    pub fn append_null(&mut self) {
+        self.append(false)
+    }
+
+    /// Builds the `StructArray` and reset this builder.
+    pub fn finish(&mut self) -> StructArray {
+        self.validate_content();
+        if self.fields.is_empty() {
+            return StructArray::new_empty_fields(self.len(), self.null_buffer_builder.finish());
+        }
+
+        let arrays = self.field_builders.iter_mut().map(|f| f.finish()).collect();
+        let nulls = self.null_buffer_builder.finish();
+        StructArray::new(self.fields.clone(), arrays, nulls)
+    }
+
+    /// Builds the `StructArray` without resetting the builder.
+    pub fn finish_cloned(&self) -> StructArray {
+        self.validate_content();
+
+        if self.fields.is_empty() {
+            return StructArray::new_empty_fields(
+                self.len(),
+                self.null_buffer_builder.finish_cloned(),
+            );
+        }
+
+        let arrays = self
+            .field_builders
+            .iter()
+            .map(|f| f.finish_cloned())
+            .collect();
+
+        let nulls = self.null_buffer_builder.finish_cloned();
+
+        StructArray::new(self.fields.clone(), arrays, nulls)
+    }
+
+    /// Constructs and validates contents in the builder to ensure that
+    /// - fields and field_builders are of equal length
+    /// - the number of items in individual field_builders are equal to self.len()
+    fn validate_content(&self) {
+        if self.fields.len() != self.field_builders.len() {
+            panic!("Number of fields is not equal to the number of field_builders.");
+        }
+        self.field_builders.iter().enumerate().for_each(|(idx, x)| {
+            if x.len() != self.len() {
+                let builder = SchemaBuilder::from(&self.fields);
+                let schema = builder.finish();
+
+                panic!("{}", format!(
+                    "StructBuilder ({:?}) and field_builder with index {} ({:?}) are of unequal lengths: ({} != {}).",
+                    schema,
+                    idx,
+                    self.fields[idx].data_type(),
+                    self.len(),
+                    x.len()
+                ));
+            }
+        });
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_buffer::Buffer;
+    use arrow_data::ArrayData;
+    use arrow_schema::Field;
+
+    use crate::array::Array;
+
+    #[test]
+    fn test_struct_array_builder() {
+        let string_builder = StringBuilder::new();
+        let int_builder = Int32Builder::new();
+
+        let fields = vec![
+            Field::new("f1", DataType::Utf8, true),
+            Field::new("f2", DataType::Int32, true),
+        ];
+        let field_builders = vec![
+            Box::new(string_builder) as Box<dyn ArrayBuilder>,
+            Box::new(int_builder) as Box<dyn ArrayBuilder>,
+        ];
+
+        let mut builder = StructBuilder::new(fields, field_builders);
+        assert_eq!(2, builder.num_fields());
+
+        let string_builder = builder
+            .field_builder::<StringBuilder>(0)
+            .expect("builder at field 0 should be string builder");
+        string_builder.append_value("joe");
+        string_builder.append_null();
+        string_builder.append_null();
+        string_builder.append_value("mark");
+
+        let int_builder = builder
+            .field_builder::<Int32Builder>(1)
+            .expect("builder at field 1 should be int builder");
+        int_builder.append_value(1);
+        int_builder.append_value(2);
+        int_builder.append_null();
+        int_builder.append_value(4);
+
+        builder.append(true);
+        builder.append(true);
+        builder.append_null();
+        builder.append(true);
+
+        let struct_data = builder.finish().into_data();
+
+        assert_eq!(4, struct_data.len());
+        assert_eq!(1, struct_data.null_count());
+        assert_eq!(&[11_u8], struct_data.nulls().unwrap().validity());
+
+        let expected_string_data = ArrayData::builder(DataType::Utf8)
+            .len(4)
+            .null_bit_buffer(Some(Buffer::from(&[9_u8])))
+            .add_buffer(Buffer::from_slice_ref([0, 3, 3, 3, 7]))
+            .add_buffer(Buffer::from_slice_ref(b"joemark"))
+            .build()
+            .unwrap();
+
+        let expected_int_data = ArrayData::builder(DataType::Int32)
+            .len(4)
+            .null_bit_buffer(Some(Buffer::from_slice_ref([11_u8])))
+            .add_buffer(Buffer::from_slice_ref([1, 2, 0, 4]))
+            .build()
+            .unwrap();
+
+        assert_eq!(expected_string_data, struct_data.child_data()[0]);
+        assert_eq!(expected_int_data, struct_data.child_data()[1]);
+    }
+
+    #[test]
+    fn test_struct_array_builder_finish() {
+        let int_builder = Int32Builder::new();
+        let bool_builder = BooleanBuilder::new();
+
+        let fields = vec![
+            Field::new("f1", DataType::Int32, false),
+            Field::new("f2", DataType::Boolean, false),
+        ];
+        let field_builders = vec![
+            Box::new(int_builder) as Box<dyn ArrayBuilder>,
+            Box::new(bool_builder) as Box<dyn ArrayBuilder>,
+        ];
+
+        let mut builder = StructBuilder::new(fields, field_builders);
+        builder
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_slice(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        builder
+            .field_builder::<BooleanBuilder>(1)
+            .unwrap()
+            .append_slice(&[
+                false, true, false, true, false, true, false, true, false, true,
+            ]);
+
+        // Append slot values - all are valid.
+        for _ in 0..10 {
+            builder.append(true);
+        }
+
+        assert_eq!(10, builder.len());
+
+        let arr = builder.finish();
+
+        assert_eq!(10, arr.len());
+        assert_eq!(0, builder.len());
+
+        builder
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_slice(&[1, 3, 5, 7, 9]);
+        builder
+            .field_builder::<BooleanBuilder>(1)
+            .unwrap()
+            .append_slice(&[false, true, false, true, false]);
+
+        // Append slot values - all are valid.
+        for _ in 0..5 {
+            builder.append(true);
+        }
+
+        assert_eq!(5, builder.len());
+
+        let arr = builder.finish();
+
+        assert_eq!(5, arr.len());
+        assert_eq!(0, builder.len());
+    }
+
+    #[test]
+    fn test_struct_array_builder_finish_cloned() {
+        let int_builder = Int32Builder::new();
+        let bool_builder = BooleanBuilder::new();
+
+        let fields = vec![
+            Field::new("f1", DataType::Int32, false),
+            Field::new("f2", DataType::Boolean, false),
+        ];
+        let field_builders = vec![
+            Box::new(int_builder) as Box<dyn ArrayBuilder>,
+            Box::new(bool_builder) as Box<dyn ArrayBuilder>,
+        ];
+
+        let mut builder = StructBuilder::new(fields, field_builders);
+        builder
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_slice(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
+        builder
+            .field_builder::<BooleanBuilder>(1)
+            .unwrap()
+            .append_slice(&[
+                false, true, false, true, false, true, false, true, false, true,
+            ]);
+
+        // Append slot values - all are valid.
+        for _ in 0..10 {
+            builder.append(true);
+        }
+
+        assert_eq!(10, builder.len());
+
+        let mut arr = builder.finish_cloned();
+
+        assert_eq!(10, arr.len());
+        assert_eq!(10, builder.len());
+
+        builder
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_slice(&[1, 3, 5, 7, 9]);
+        builder
+            .field_builder::<BooleanBuilder>(1)
+            .unwrap()
+            .append_slice(&[false, true, false, true, false]);
+
+        // Append slot values - all are valid.
+        for _ in 0..5 {
+            builder.append(true);
+        }
+
+        assert_eq!(15, builder.len());
+
+        arr = builder.finish();
+
+        assert_eq!(15, arr.len());
+        assert_eq!(0, builder.len());
+    }
+
+    #[test]
+    fn test_struct_array_builder_from_schema() {
+        let mut fields = vec![
+            Field::new("f1", DataType::Float32, false),
+            Field::new("f2", DataType::Utf8, false),
+        ];
+        let sub_fields = vec![
+            Field::new("g1", DataType::Int32, false),
+            Field::new("g2", DataType::Boolean, false),
+        ];
+        let struct_type = DataType::Struct(sub_fields.into());
+        fields.push(Field::new("f3", struct_type, false));
+
+        let mut builder = StructBuilder::from_fields(fields, 5);
+        assert_eq!(3, builder.num_fields());
+        assert!(builder.field_builder::<Float32Builder>(0).is_some());
+        assert!(builder.field_builder::<StringBuilder>(1).is_some());
+        assert!(builder.field_builder::<StructBuilder>(2).is_some());
+    }
+
+    #[test]
+    fn test_datatype_properties() {
+        let fields = Fields::from(vec![
+            Field::new("f1", DataType::Decimal128(1, 2), false),
+            Field::new(
+                "f2",
+                DataType::Timestamp(TimeUnit::Millisecond, Some("+00:00".into())),
+                false,
+            ),
+        ]);
+        let mut builder = StructBuilder::from_fields(fields.clone(), 1);
+        builder
+            .field_builder::<Decimal128Builder>(0)
+            .unwrap()
+            .append_value(1);
+        builder
+            .field_builder::<TimestampMillisecondBuilder>(1)
+            .unwrap()
+            .append_value(1);
+        builder.append(true);
+        let array = builder.finish();
+
+        assert_eq!(array.data_type(), &DataType::Struct(fields.clone()));
+        assert_eq!(array.column(0).data_type(), fields[0].data_type());
+        assert_eq!(array.column(1).data_type(), fields[1].data_type());
+    }
+
+    #[test]
+    #[should_panic(expected = "Data type Dictionary(Int32, Utf8) is not currently supported")]
+    fn test_struct_array_builder_from_schema_unsupported_type() {
+        let fields = vec![
+            Field::new("f1", DataType::Int16, false),
+            Field::new(
+                "f2",
+                DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
+                false,
+            ),
+        ];
+
+        let _ = StructBuilder::from_fields(fields, 5);
+    }
+
+    #[test]
+    fn test_struct_array_builder_field_builder_type_mismatch() {
+        let int_builder = Int32Builder::with_capacity(10);
+
+        let fields = vec![Field::new("f1", DataType::Int32, false)];
+        let field_builders = vec![Box::new(int_builder) as Box<dyn ArrayBuilder>];
+
+        let mut builder = StructBuilder::new(fields, field_builders);
+        assert!(builder.field_builder::<BinaryBuilder>(0).is_none());
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "StructBuilder (Schema { fields: [Field { name: \"f1\", data_type: Int32, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, Field { name: \"f2\", data_type: Boolean, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }], metadata: {} }) and field_builder with index 1 (Boolean) are of unequal lengths: (2 != 1)."
+    )]
+    fn test_struct_array_builder_unequal_field_builders_lengths() {
+        let mut int_builder = Int32Builder::with_capacity(10);
+        let mut bool_builder = BooleanBuilder::new();
+
+        int_builder.append_value(1);
+        int_builder.append_value(2);
+        bool_builder.append_value(true);
+
+        let fields = vec![
+            Field::new("f1", DataType::Int32, false),
+            Field::new("f2", DataType::Boolean, false),
+        ];
+        let field_builders = vec![
+            Box::new(int_builder) as Box<dyn ArrayBuilder>,
+            Box::new(bool_builder) as Box<dyn ArrayBuilder>,
+        ];
+
+        let mut builder = StructBuilder::new(fields, field_builders);
+        builder.append(true);
+        builder.append(true);
+        builder.finish();
+    }
+
+    #[test]
+    #[should_panic(expected = "Number of fields is not equal to the number of field_builders.")]
+    fn test_struct_array_builder_unequal_field_field_builders() {
+        let int_builder = Int32Builder::with_capacity(10);
+
+        let fields = vec![
+            Field::new("f1", DataType::Int32, false),
+            Field::new("f2", DataType::Boolean, false),
+        ];
+        let field_builders = vec![Box::new(int_builder) as Box<dyn ArrayBuilder>];
+
+        let mut builder = StructBuilder::new(fields, field_builders);
+        builder.finish();
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Incorrect datatype for StructArray field \\\"timestamp\\\", expected Timestamp(Nanosecond, Some(\\\"UTC\\\")) got Timestamp(Nanosecond, None)"
+    )]
+    fn test_struct_array_mismatch_builder() {
+        let fields = vec![Field::new(
+            "timestamp",
+            DataType::Timestamp(TimeUnit::Nanosecond, Some("UTC".to_owned().into())),
+            false,
+        )];
+
+        let field_builders: Vec<Box<dyn ArrayBuilder>> =
+            vec![Box::new(TimestampNanosecondBuilder::new())];
+
+        let mut sa = StructBuilder::new(fields, field_builders);
+        sa.finish();
+    }
+
+    #[test]
+    fn test_empty() {
+        let mut builder = StructBuilder::new(Fields::empty(), vec![]);
+        builder.append(true);
+        builder.append(false);
+
+        let a1 = builder.finish_cloned();
+        let a2 = builder.finish();
+        assert_eq!(a1, a2);
+        assert_eq!(a1.len(), 2);
+        assert_eq!(a1.null_count(), 1);
+        assert!(a1.is_valid(0));
+        assert!(a1.is_null(1));
+    }
+}
diff --git a/arrow/src/array/builder/union_builder.rs b/arrow-array/src/builder/union_builder.rs
similarity index 72%
rename from arrow/src/array/builder/union_builder.rs
rename to arrow-array/src/builder/union_builder.rs
index 8ef5028afc8c..4f88c9d41b9a 100644
--- a/arrow/src/array/builder/union_builder.rs
+++ b/arrow-array/src/builder/union_builder.rs
@@ -15,24 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::builder::buffer_builder::{Int32BufferBuilder, Int8BufferBuilder};
+use crate::builder::BufferBuilder;
+use crate::{make_array, ArrowPrimitiveType, UnionArray};
+use arrow_buffer::NullBufferBuilder;
+use arrow_buffer::{ArrowNativeType, Buffer};
+use arrow_data::ArrayDataBuilder;
+use arrow_schema::{ArrowError, DataType, Field};
 use std::any::Any;
 use std::collections::HashMap;
 
-use crate::array::ArrayDataBuilder;
-use crate::array::Int32BufferBuilder;
-use crate::array::Int8BufferBuilder;
-use crate::array::UnionArray;
-use crate::buffer::Buffer;
-
-use crate::datatypes::DataType;
-use crate::datatypes::Field;
-use crate::datatypes::{ArrowNativeType, ArrowPrimitiveType};
-use crate::error::{ArrowError, Result};
-
-use super::{BufferBuilder, NullBufferBuilder};
-
-use crate::array::make_array;
-
 /// `FieldData` is a helper struct to track the state of the fields in the `UnionBuilder`.
 #[derive(Debug)]
 struct FieldData {
@@ -73,13 +65,13 @@ impl<T: ArrowNativeType> FieldDataValues for BufferBuilder<T> {
 
 impl FieldData {
     /// Creates a new `FieldData`.
-    fn new<T: ArrowPrimitiveType>(type_id: i8, data_type: DataType) -> Self {
+    fn new<T: ArrowPrimitiveType>(type_id: i8, data_type: DataType, capacity: usize) -> Self {
         Self {
             type_id,
             data_type,
             slots: 0,
-            values_buffer: Box::new(BufferBuilder::<T::Native>::new(1)),
-            null_buffer_builder: NullBufferBuilder::new(1),
+            values_buffer: Box::new(BufferBuilder::<T::Native>::new(capacity)),
+            null_buffer_builder: NullBufferBuilder::new(capacity),
         }
     }
 
@@ -103,47 +95,47 @@ impl FieldData {
     }
 }
 
-/// Builder type for creating a new `UnionArray`.
+/// Builder for [`UnionArray`]
 ///
 /// Example: **Dense Memory Layout**
 ///
 /// ```
-/// use arrow::array::UnionBuilder;
-/// use arrow::datatypes::{Float64Type, Int32Type};
+/// # use arrow_array::builder::UnionBuilder;
+/// # use arrow_array::types::{Float64Type, Int32Type};
 ///
-/// let mut builder = UnionBuilder::new_dense(3);
+/// let mut builder = UnionBuilder::new_dense();
 /// builder.append::<Int32Type>("a", 1).unwrap();
 /// builder.append::<Float64Type>("b", 3.0).unwrap();
 /// builder.append::<Int32Type>("a", 4).unwrap();
 /// let union = builder.build().unwrap();
 ///
-/// assert_eq!(union.type_id(0), 0_i8);
-/// assert_eq!(union.type_id(1), 1_i8);
-/// assert_eq!(union.type_id(2), 0_i8);
+/// assert_eq!(union.type_id(0), 0);
+/// assert_eq!(union.type_id(1), 1);
+/// assert_eq!(union.type_id(2), 0);
 ///
-/// assert_eq!(union.value_offset(0), 0_i32);
-/// assert_eq!(union.value_offset(1), 0_i32);
-/// assert_eq!(union.value_offset(2), 1_i32);
+/// assert_eq!(union.value_offset(0), 0);
+/// assert_eq!(union.value_offset(1), 0);
+/// assert_eq!(union.value_offset(2), 1);
 /// ```
 ///
 /// Example: **Sparse Memory Layout**
 /// ```
-/// use arrow::array::UnionBuilder;
-/// use arrow::datatypes::{Float64Type, Int32Type};
+/// # use arrow_array::builder::UnionBuilder;
+/// # use arrow_array::types::{Float64Type, Int32Type};
 ///
-/// let mut builder = UnionBuilder::new_sparse(3);
+/// let mut builder = UnionBuilder::new_sparse();
 /// builder.append::<Int32Type>("a", 1).unwrap();
 /// builder.append::<Float64Type>("b", 3.0).unwrap();
 /// builder.append::<Int32Type>("a", 4).unwrap();
 /// let union = builder.build().unwrap();
 ///
-/// assert_eq!(union.type_id(0), 0_i8);
-/// assert_eq!(union.type_id(1), 1_i8);
-/// assert_eq!(union.type_id(2), 0_i8);
+/// assert_eq!(union.type_id(0), 0);
+/// assert_eq!(union.type_id(1), 1);
+/// assert_eq!(union.type_id(2), 0);
 ///
-/// assert_eq!(union.value_offset(0), 0_i32);
-/// assert_eq!(union.value_offset(1), 1_i32);
-/// assert_eq!(union.value_offset(2), 2_i32);
+/// assert_eq!(union.value_offset(0), 0);
+/// assert_eq!(union.value_offset(1), 1);
+/// assert_eq!(union.value_offset(2), 2);
 /// ```
 #[derive(Debug)]
 pub struct UnionBuilder {
@@ -155,26 +147,39 @@ pub struct UnionBuilder {
     type_id_builder: Int8BufferBuilder,
     /// Builder to keep track of offsets (`None` for sparse unions)
     value_offset_builder: Option<Int32BufferBuilder>,
+    initial_capacity: usize,
 }
 
 impl UnionBuilder {
     /// Creates a new dense array builder.
-    pub fn new_dense(capacity: usize) -> Self {
+    pub fn new_dense() -> Self {
+        Self::with_capacity_dense(1024)
+    }
+
+    /// Creates a new sparse array builder.
+    pub fn new_sparse() -> Self {
+        Self::with_capacity_sparse(1024)
+    }
+
+    /// Creates a new dense array builder with capacity.
+    pub fn with_capacity_dense(capacity: usize) -> Self {
         Self {
             len: 0,
             fields: HashMap::default(),
             type_id_builder: Int8BufferBuilder::new(capacity),
             value_offset_builder: Some(Int32BufferBuilder::new(capacity)),
+            initial_capacity: capacity,
         }
     }
 
-    /// Creates a new sparse array builder.
-    pub fn new_sparse(capacity: usize) -> Self {
+    /// Creates a new sparse array builder  with capacity.
+    pub fn with_capacity_sparse(capacity: usize) -> Self {
         Self {
             len: 0,
             fields: HashMap::default(),
             type_id_builder: Int8BufferBuilder::new(capacity),
             value_offset_builder: None,
+            initial_capacity: capacity,
         }
     }
 
@@ -186,7 +191,10 @@ impl UnionBuilder {
     /// is part of the final array, appending a NULL requires
     /// specifying which field (child) to use.
     #[inline]
-    pub fn append_null<T: ArrowPrimitiveType>(&mut self, type_name: &str) -> Result<()> {
+    pub fn append_null<T: ArrowPrimitiveType>(
+        &mut self,
+        type_name: &str,
+    ) -> Result<(), ArrowError> {
         self.append_option::<T>(type_name, None)
     }
 
@@ -196,7 +204,7 @@ impl UnionBuilder {
         &mut self,
         type_name: &str,
         v: T::Native,
-    ) -> Result<()> {
+    ) -> Result<(), ArrowError> {
         self.append_option::<T>(type_name, Some(v))
     }
 
@@ -204,21 +212,34 @@ impl UnionBuilder {
         &mut self,
         type_name: &str,
         v: Option<T::Native>,
-    ) -> Result<()> {
+    ) -> Result<(), ArrowError> {
         let type_name = type_name.to_string();
 
         let mut field_data = match self.fields.remove(&type_name) {
             Some(data) => {
                 if data.data_type != T::DATA_TYPE {
-                    return Err(ArrowError::InvalidArgumentError(format!("Attempt to write col \"{}\" with type {} doesn't match existing type {}", type_name, T::DATA_TYPE, data.data_type)));
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "Attempt to write col \"{}\" with type {} doesn't match existing type {}",
+                        type_name,
+                        T::DATA_TYPE,
+                        data.data_type
+                    )));
                 }
                 data
             }
             None => match self.value_offset_builder {
-                Some(_) => FieldData::new::<T>(self.fields.len() as i8, T::DATA_TYPE),
+                Some(_) => FieldData::new::<T>(
+                    self.fields.len() as i8,
+                    T::DATA_TYPE,
+                    self.initial_capacity,
+                ),
+                // In the case of a sparse union, we should pass the maximum of the currently length and the capacity.
                 None => {
-                    let mut fd =
-                        FieldData::new::<T>(self.fields.len() as i8, T::DATA_TYPE);
+                    let mut fd = FieldData::new::<T>(
+                        self.fields.len() as i8,
+                        T::DATA_TYPE,
+                        self.len.max(self.initial_capacity),
+                    );
                     for _ in 0..self.len {
                         fd.append_null();
                     }
@@ -253,7 +274,7 @@ impl UnionBuilder {
     }
 
     /// Builds this builder creating a new `UnionArray`.
-    pub fn build(mut self) -> Result<UnionArray> {
+    pub fn build(mut self) -> Result<UnionArray, ArrowError> {
         let type_id_buffer = self.type_id_builder.finish();
         let value_offsets_buffer = self.value_offset_builder.map(|mut b| b.finish());
         let mut children = Vec::new();
@@ -272,11 +293,11 @@ impl UnionBuilder {
             let arr_data_builder = ArrayDataBuilder::new(data_type.clone())
                 .add_buffer(buffer)
                 .len(slots)
-                .null_bit_buffer(bitmap_builder.finish());
+                .nulls(bitmap_builder.finish());
 
             let arr_data_ref = unsafe { arr_data_builder.build_unchecked() };
             let array_ref = make_array(arr_data_ref);
-            children.push((type_id, (Field::new(&name, data_type, false), array_ref)))
+            children.push((type_id, (Field::new(name, data_type, false), array_ref)))
         }
 
         children.sort_by(|a, b| {
diff --git a/arrow-array/src/cast.rs b/arrow-array/src/cast.rs
new file mode 100644
index 000000000000..2e21f3e7e640
--- /dev/null
+++ b/arrow-array/src/cast.rs
@@ -0,0 +1,969 @@
+// 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.
+
+//! Defines helper functions for downcasting [`dyn Array`](Array) to concrete types
+
+use crate::array::*;
+use crate::types::*;
+use arrow_data::ArrayData;
+
+/// Repeats the provided pattern based on the number of comma separated identifiers
+#[doc(hidden)]
+#[macro_export]
+macro_rules! repeat_pat {
+    ($e:pat, $v_:expr) => {
+        $e
+    };
+    ($e:pat, $v_:expr $(, $tail:expr)+) => {
+        ($e, $crate::repeat_pat!($e $(, $tail)+))
+    }
+}
+
+/// Given one or more expressions evaluating to an integer [`DataType`] invokes the provided macro
+/// `m` with the corresponding integer [`ArrowPrimitiveType`], followed by any additional arguments
+///
+/// ```
+/// # use arrow_array::{downcast_primitive, ArrowPrimitiveType, downcast_integer};
+/// # use arrow_schema::DataType;
+///
+/// macro_rules! dictionary_key_size_helper {
+///   ($t:ty, $o:ty) => {
+///       std::mem::size_of::<<$t as ArrowPrimitiveType>::Native>() as $o
+///   };
+/// }
+///
+/// fn dictionary_key_size(t: &DataType) -> u8 {
+///     match t {
+///         DataType::Dictionary(k, _) => downcast_integer! {
+///             k.as_ref() => (dictionary_key_size_helper, u8),
+///             _ => unreachable!(),
+///         },
+///         _ => u8::MAX,
+///     }
+/// }
+///
+/// assert_eq!(dictionary_key_size(&DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8))), 4);
+/// assert_eq!(dictionary_key_size(&DataType::Dictionary(Box::new(DataType::Int64), Box::new(DataType::Utf8))), 8);
+/// assert_eq!(dictionary_key_size(&DataType::Dictionary(Box::new(DataType::UInt16), Box::new(DataType::Utf8))), 2);
+/// ```
+///
+/// [`DataType`]: arrow_schema::DataType
+#[macro_export]
+macro_rules! downcast_integer {
+    ($($data_type:expr),+ => ($m:path $(, $args:tt)*), $($p:pat => $fallback:expr $(,)*)*) => {
+        match ($($data_type),+) {
+            $crate::repeat_pat!(arrow_schema::DataType::Int8, $($data_type),+) => {
+                $m!($crate::types::Int8Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Int16, $($data_type),+) => {
+                $m!($crate::types::Int16Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Int32, $($data_type),+) => {
+                $m!($crate::types::Int32Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Int64, $($data_type),+) => {
+                $m!($crate::types::Int64Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::UInt8, $($data_type),+) => {
+                $m!($crate::types::UInt8Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::UInt16, $($data_type),+) => {
+                $m!($crate::types::UInt16Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::UInt32, $($data_type),+) => {
+                $m!($crate::types::UInt32Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::UInt64, $($data_type),+) => {
+                $m!($crate::types::UInt64Type $(, $args)*)
+            }
+            $($p => $fallback,)*
+        }
+    };
+}
+
+/// Given one or more expressions evaluating to an integer [`DataType`] invokes the provided macro
+/// `m` with the corresponding integer [`RunEndIndexType`], followed by any additional arguments
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::{downcast_primitive, ArrowPrimitiveType, downcast_run_end_index};
+/// # use arrow_schema::{DataType, Field};
+///
+/// macro_rules! run_end_size_helper {
+///   ($t:ty, $o:ty) => {
+///       std::mem::size_of::<<$t as ArrowPrimitiveType>::Native>() as $o
+///   };
+/// }
+///
+/// fn run_end_index_size(t: &DataType) -> u8 {
+///     match t {
+///         DataType::RunEndEncoded(k, _) => downcast_run_end_index! {
+///             k.data_type() => (run_end_size_helper, u8),
+///             _ => unreachable!(),
+///         },
+///         _ => u8::MAX,
+///     }
+/// }
+///
+/// assert_eq!(run_end_index_size(&DataType::RunEndEncoded(Arc::new(Field::new("a", DataType::Int32, false)), Arc::new(Field::new("b", DataType::Utf8, true)))), 4);
+/// assert_eq!(run_end_index_size(&DataType::RunEndEncoded(Arc::new(Field::new("a", DataType::Int64, false)), Arc::new(Field::new("b", DataType::Utf8, true)))), 8);
+/// assert_eq!(run_end_index_size(&DataType::RunEndEncoded(Arc::new(Field::new("a", DataType::Int16, false)), Arc::new(Field::new("b", DataType::Utf8, true)))), 2);
+/// ```
+///
+/// [`DataType`]: arrow_schema::DataType
+#[macro_export]
+macro_rules! downcast_run_end_index {
+    ($($data_type:expr),+ => ($m:path $(, $args:tt)*), $($p:pat => $fallback:expr $(,)*)*) => {
+        match ($($data_type),+) {
+            $crate::repeat_pat!(arrow_schema::DataType::Int16, $($data_type),+) => {
+                $m!($crate::types::Int16Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Int32, $($data_type),+) => {
+                $m!($crate::types::Int32Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Int64, $($data_type),+) => {
+                $m!($crate::types::Int64Type $(, $args)*)
+            }
+            $($p => $fallback,)*
+        }
+    };
+}
+
+/// Given one or more expressions evaluating to primitive [`DataType`] invokes the provided macro
+/// `m` with the corresponding [`ArrowPrimitiveType`], followed by any additional arguments
+///
+/// ```
+/// # use arrow_array::{downcast_temporal, ArrowPrimitiveType};
+/// # use arrow_schema::DataType;
+///
+/// macro_rules! temporal_size_helper {
+///   ($t:ty, $o:ty) => {
+///       std::mem::size_of::<<$t as ArrowPrimitiveType>::Native>() as $o
+///   };
+/// }
+///
+/// fn temporal_size(t: &DataType) -> u8 {
+///     downcast_temporal! {
+///         t => (temporal_size_helper, u8),
+///         _ => u8::MAX
+///     }
+/// }
+///
+/// assert_eq!(temporal_size(&DataType::Date32), 4);
+/// assert_eq!(temporal_size(&DataType::Date64), 8);
+/// ```
+///
+/// [`DataType`]: arrow_schema::DataType
+#[macro_export]
+macro_rules! downcast_temporal {
+    ($($data_type:expr),+ => ($m:path $(, $args:tt)*), $($p:pat => $fallback:expr $(,)*)*) => {
+        match ($($data_type),+) {
+            $crate::repeat_pat!(arrow_schema::DataType::Time32(arrow_schema::TimeUnit::Second), $($data_type),+) => {
+                $m!($crate::types::Time32SecondType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Time32(arrow_schema::TimeUnit::Millisecond), $($data_type),+) => {
+                $m!($crate::types::Time32MillisecondType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Time64(arrow_schema::TimeUnit::Microsecond), $($data_type),+) => {
+                $m!($crate::types::Time64MicrosecondType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Time64(arrow_schema::TimeUnit::Nanosecond), $($data_type),+) => {
+                $m!($crate::types::Time64NanosecondType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Date32, $($data_type),+) => {
+                $m!($crate::types::Date32Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Date64, $($data_type),+) => {
+                $m!($crate::types::Date64Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Timestamp(arrow_schema::TimeUnit::Second, _), $($data_type),+) => {
+                $m!($crate::types::TimestampSecondType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Timestamp(arrow_schema::TimeUnit::Millisecond, _), $($data_type),+) => {
+                $m!($crate::types::TimestampMillisecondType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Timestamp(arrow_schema::TimeUnit::Microsecond, _), $($data_type),+) => {
+                $m!($crate::types::TimestampMicrosecondType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Timestamp(arrow_schema::TimeUnit::Nanosecond, _), $($data_type),+) => {
+                $m!($crate::types::TimestampNanosecondType $(, $args)*)
+            }
+            $($p => $fallback,)*
+        }
+    };
+}
+
+/// Downcast an [`Array`] to a temporal [`PrimitiveArray`] based on its [`DataType`]
+/// accepts a number of subsequent patterns to match the data type
+///
+/// ```
+/// # use arrow_array::{Array, downcast_temporal_array, cast::as_string_array};
+/// # use arrow_schema::DataType;
+///
+/// fn print_temporal(array: &dyn Array) {
+///     downcast_temporal_array!(
+///         array => {
+///             for v in array {
+///                 println!("{:?}", v);
+///             }
+///         }
+///         DataType::Utf8 => {
+///             for v in as_string_array(array) {
+///                 println!("{:?}", v);
+///             }
+///         }
+///         t => println!("Unsupported datatype {}", t)
+///     )
+/// }
+/// ```
+///
+/// [`DataType`]: arrow_schema::DataType
+#[macro_export]
+macro_rules! downcast_temporal_array {
+    ($values:ident => $e:expr, $($p:pat => $fallback:expr $(,)*)*) => {
+        $crate::downcast_temporal_array!($values => {$e} $($p => $fallback)*)
+    };
+    (($($values:ident),+) => $e:expr, $($p:pat => $fallback:expr $(,)*)*) => {
+        $crate::downcast_temporal_array!($($values),+ => {$e} $($p => $fallback)*)
+    };
+    ($($values:ident),+ => $e:block $($p:pat => $fallback:expr $(,)*)*) => {
+        $crate::downcast_temporal_array!(($($values),+) => $e $($p => $fallback)*)
+    };
+    (($($values:ident),+) => $e:block $($p:pat => $fallback:expr $(,)*)*) => {
+        $crate::downcast_temporal!{
+            $($values.data_type()),+ => ($crate::downcast_primitive_array_helper, $($values),+, $e),
+            $($p => $fallback,)*
+        }
+    };
+}
+
+/// Given one or more expressions evaluating to primitive [`DataType`] invokes the provided macro
+/// `m` with the corresponding [`ArrowPrimitiveType`], followed by any additional arguments
+///
+/// ```
+/// # use arrow_array::{downcast_primitive, ArrowPrimitiveType};
+/// # use arrow_schema::DataType;
+///
+/// macro_rules! primitive_size_helper {
+///   ($t:ty, $o:ty) => {
+///       std::mem::size_of::<<$t as ArrowPrimitiveType>::Native>() as $o
+///   };
+/// }
+///
+/// fn primitive_size(t: &DataType) -> u8 {
+///     downcast_primitive! {
+///         t => (primitive_size_helper, u8),
+///         _ => u8::MAX
+///     }
+/// }
+///
+/// assert_eq!(primitive_size(&DataType::Int32), 4);
+/// assert_eq!(primitive_size(&DataType::Int64), 8);
+/// assert_eq!(primitive_size(&DataType::Float16), 2);
+/// assert_eq!(primitive_size(&DataType::Decimal128(38, 10)), 16);
+/// assert_eq!(primitive_size(&DataType::Decimal256(76, 20)), 32);
+/// ```
+///
+/// [`DataType`]: arrow_schema::DataType
+#[macro_export]
+macro_rules! downcast_primitive {
+    ($($data_type:expr),+ => ($m:path $(, $args:tt)*), $($p:pat => $fallback:expr $(,)*)*) => {
+        $crate::downcast_integer! {
+            $($data_type),+ => ($m $(, $args)*),
+            $crate::repeat_pat!(arrow_schema::DataType::Float16, $($data_type),+) => {
+                $m!($crate::types::Float16Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Float32, $($data_type),+) => {
+                $m!($crate::types::Float32Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Float64, $($data_type),+) => {
+                $m!($crate::types::Float64Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Decimal128(_, _), $($data_type),+) => {
+                $m!($crate::types::Decimal128Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Decimal256(_, _), $($data_type),+) => {
+                $m!($crate::types::Decimal256Type $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Interval(arrow_schema::IntervalUnit::YearMonth), $($data_type),+) => {
+                $m!($crate::types::IntervalYearMonthType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Interval(arrow_schema::IntervalUnit::DayTime), $($data_type),+) => {
+                $m!($crate::types::IntervalDayTimeType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Interval(arrow_schema::IntervalUnit::MonthDayNano), $($data_type),+) => {
+                $m!($crate::types::IntervalMonthDayNanoType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Duration(arrow_schema::TimeUnit::Second), $($data_type),+) => {
+                $m!($crate::types::DurationSecondType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Duration(arrow_schema::TimeUnit::Millisecond), $($data_type),+) => {
+                $m!($crate::types::DurationMillisecondType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Duration(arrow_schema::TimeUnit::Microsecond), $($data_type),+) => {
+                $m!($crate::types::DurationMicrosecondType $(, $args)*)
+            }
+            $crate::repeat_pat!(arrow_schema::DataType::Duration(arrow_schema::TimeUnit::Nanosecond), $($data_type),+) => {
+                $m!($crate::types::DurationNanosecondType $(, $args)*)
+            }
+            _ => {
+                $crate::downcast_temporal! {
+                    $($data_type),+ => ($m $(, $args)*),
+                    $($p => $fallback,)*
+                }
+            }
+        }
+    };
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! downcast_primitive_array_helper {
+    ($t:ty, $($values:ident),+, $e:block) => {{
+        $(let $values = $crate::cast::as_primitive_array::<$t>($values);)+
+        $e
+    }};
+}
+
+/// Downcast an [`Array`] to a [`PrimitiveArray`] based on its [`DataType`]
+/// accepts a number of subsequent patterns to match the data type
+///
+/// ```
+/// # use arrow_array::{Array, downcast_primitive_array, cast::as_string_array};
+/// # use arrow_schema::DataType;
+///
+/// fn print_primitive(array: &dyn Array) {
+///     downcast_primitive_array!(
+///         array => {
+///             for v in array {
+///                 println!("{:?}", v);
+///             }
+///         }
+///         DataType::Utf8 => {
+///             for v in as_string_array(array) {
+///                 println!("{:?}", v);
+///             }
+///         }
+///         t => println!("Unsupported datatype {}", t)
+///     )
+/// }
+/// ```
+///
+/// [`DataType`]: arrow_schema::DataType
+#[macro_export]
+macro_rules! downcast_primitive_array {
+    ($values:ident => $e:expr, $($p:pat => $fallback:expr $(,)*)*) => {
+        $crate::downcast_primitive_array!($values => {$e} $($p => $fallback)*)
+    };
+    (($($values:ident),+) => $e:expr, $($p:pat => $fallback:expr $(,)*)*) => {
+        $crate::downcast_primitive_array!($($values),+ => {$e} $($p => $fallback)*)
+    };
+    ($($values:ident),+ => $e:block $($p:pat => $fallback:expr $(,)*)*) => {
+        $crate::downcast_primitive_array!(($($values),+) => $e $($p => $fallback)*)
+    };
+    (($($values:ident),+) => $e:block $($p:pat => $fallback:expr $(,)*)*) => {
+        $crate::downcast_primitive!{
+            $($values.data_type()),+ => ($crate::downcast_primitive_array_helper, $($values),+, $e),
+            $($p => $fallback,)*
+        }
+    };
+}
+
+/// Force downcast of an [`Array`], such as an [`ArrayRef`], to
+/// [`PrimitiveArray<T>`], panic'ing on failure.
+///
+/// # Example
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::{ArrayRef, Int32Array};
+/// # use arrow_array::cast::as_primitive_array;
+/// # use arrow_array::types::Int32Type;
+///
+/// let arr: ArrayRef = Arc::new(Int32Array::from(vec![Some(1)]));
+///
+/// // Downcast an `ArrayRef` to Int32Array / PrimitiveArray<Int32>:
+/// let primitive_array: &Int32Array = as_primitive_array(&arr);
+///
+/// // Equivalently:
+/// let primitive_array = as_primitive_array::<Int32Type>(&arr);
+///
+/// // This is the equivalent of:
+/// let primitive_array = arr
+///     .as_any()
+///     .downcast_ref::<Int32Array>()
+///     .unwrap();
+/// ```
+
+pub fn as_primitive_array<T>(arr: &dyn Array) -> &PrimitiveArray<T>
+where
+    T: ArrowPrimitiveType,
+{
+    arr.as_any()
+        .downcast_ref::<PrimitiveArray<T>>()
+        .expect("Unable to downcast to primitive array")
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! downcast_dictionary_array_helper {
+    ($t:ty, $($values:ident),+, $e:block) => {{
+        $(let $values = $crate::cast::as_dictionary_array::<$t>($values);)+
+        $e
+    }};
+}
+
+/// Downcast an [`Array`] to a [`DictionaryArray`] based on its [`DataType`], accepts
+/// a number of subsequent patterns to match the data type
+///
+/// ```
+/// # use arrow_array::{Array, StringArray, downcast_dictionary_array, cast::as_string_array};
+/// # use arrow_schema::DataType;
+///
+/// fn print_strings(array: &dyn Array) {
+///     downcast_dictionary_array!(
+///         array => match array.values().data_type() {
+///             DataType::Utf8 => {
+///                 for v in array.downcast_dict::<StringArray>().unwrap() {
+///                     println!("{:?}", v);
+///                 }
+///             }
+///             t => println!("Unsupported dictionary value type {}", t),
+///         },
+///         DataType::Utf8 => {
+///             for v in as_string_array(array) {
+///                 println!("{:?}", v);
+///             }
+///         }
+///         t => println!("Unsupported datatype {}", t)
+///     )
+/// }
+/// ```
+///
+/// [`DataType`]: arrow_schema::DataType
+#[macro_export]
+macro_rules! downcast_dictionary_array {
+    ($values:ident => $e:expr, $($p:pat => $fallback:expr $(,)*)*) => {
+        downcast_dictionary_array!($values => {$e} $($p => $fallback)*)
+    };
+
+    ($values:ident => $e:block $($p:pat => $fallback:expr $(,)*)*) => {
+        match $values.data_type() {
+            arrow_schema::DataType::Dictionary(k, _) => {
+                $crate::downcast_integer! {
+                    k.as_ref() => ($crate::downcast_dictionary_array_helper, $values, $e),
+                    k => unreachable!("unsupported dictionary key type: {}", k)
+                }
+            }
+            $($p => $fallback,)*
+        }
+    }
+}
+
+/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
+/// [`DictionaryArray<T>`], panic'ing on failure.
+///
+/// # Example
+///
+/// ```
+/// # use arrow_array::{ArrayRef, DictionaryArray};
+/// # use arrow_array::cast::as_dictionary_array;
+/// # use arrow_array::types::Int32Type;
+///
+/// let arr: DictionaryArray<Int32Type> = vec![Some("foo")].into_iter().collect();
+/// let arr: ArrayRef = std::sync::Arc::new(arr);
+/// let dict_array: &DictionaryArray<Int32Type> = as_dictionary_array::<Int32Type>(&arr);
+/// ```
+pub fn as_dictionary_array<T>(arr: &dyn Array) -> &DictionaryArray<T>
+where
+    T: ArrowDictionaryKeyType,
+{
+    arr.as_any()
+        .downcast_ref::<DictionaryArray<T>>()
+        .expect("Unable to downcast to dictionary array")
+}
+
+/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
+/// [`RunArray<T>`], panic'ing on failure.
+///
+/// # Example
+///
+/// ```
+/// # use arrow_array::{ArrayRef, RunArray};
+/// # use arrow_array::cast::as_run_array;
+/// # use arrow_array::types::Int32Type;
+///
+/// let arr: RunArray<Int32Type> = vec![Some("foo")].into_iter().collect();
+/// let arr: ArrayRef = std::sync::Arc::new(arr);
+/// let run_array: &RunArray<Int32Type> = as_run_array::<Int32Type>(&arr);
+/// ```
+pub fn as_run_array<T>(arr: &dyn Array) -> &RunArray<T>
+where
+    T: RunEndIndexType,
+{
+    arr.as_any()
+        .downcast_ref::<RunArray<T>>()
+        .expect("Unable to downcast to run array")
+}
+
+#[macro_export]
+#[doc(hidden)]
+macro_rules! downcast_run_array_helper {
+    ($t:ty, $($values:ident),+, $e:block) => {{
+        $(let $values = $crate::cast::as_run_array::<$t>($values);)+
+        $e
+    }};
+}
+
+/// Downcast an [`Array`] to a [`RunArray`] based on its [`DataType`], accepts
+/// a number of subsequent patterns to match the data type
+///
+/// ```
+/// # use arrow_array::{Array, StringArray, downcast_run_array, cast::as_string_array};
+/// # use arrow_schema::DataType;
+///
+/// fn print_strings(array: &dyn Array) {
+///     downcast_run_array!(
+///         array => match array.values().data_type() {
+///             DataType::Utf8 => {
+///                 for v in array.downcast::<StringArray>().unwrap() {
+///                     println!("{:?}", v);
+///                 }
+///             }
+///             t => println!("Unsupported run array value type {}", t),
+///         },
+///         DataType::Utf8 => {
+///             for v in as_string_array(array) {
+///                 println!("{:?}", v);
+///             }
+///         }
+///         t => println!("Unsupported datatype {}", t)
+///     )
+/// }
+/// ```
+///
+/// [`DataType`]: arrow_schema::DataType
+#[macro_export]
+macro_rules! downcast_run_array {
+    ($values:ident => $e:expr, $($p:pat => $fallback:expr $(,)*)*) => {
+        downcast_run_array!($values => {$e} $($p => $fallback)*)
+    };
+
+    ($values:ident => $e:block $($p:pat => $fallback:expr $(,)*)*) => {
+        match $values.data_type() {
+            arrow_schema::DataType::RunEndEncoded(k, _) => {
+                $crate::downcast_run_end_index! {
+                    k.data_type() => ($crate::downcast_run_array_helper, $values, $e),
+                    k => unreachable!("unsupported run end index type: {}", k)
+                }
+            }
+            $($p => $fallback,)*
+        }
+    }
+}
+
+/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
+/// [`GenericListArray<T>`], panicking on failure.
+pub fn as_generic_list_array<S: OffsetSizeTrait>(arr: &dyn Array) -> &GenericListArray<S> {
+    arr.as_any()
+        .downcast_ref::<GenericListArray<S>>()
+        .expect("Unable to downcast to list array")
+}
+
+/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
+/// [`ListArray`], panicking on failure.
+#[inline]
+pub fn as_list_array(arr: &dyn Array) -> &ListArray {
+    as_generic_list_array::<i32>(arr)
+}
+
+/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
+/// [`FixedSizeListArray`], panicking on failure.
+#[inline]
+pub fn as_fixed_size_list_array(arr: &dyn Array) -> &FixedSizeListArray {
+    arr.as_any()
+        .downcast_ref::<FixedSizeListArray>()
+        .expect("Unable to downcast to fixed size list array")
+}
+
+/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
+/// [`LargeListArray`], panicking on failure.
+#[inline]
+pub fn as_large_list_array(arr: &dyn Array) -> &LargeListArray {
+    as_generic_list_array::<i64>(arr)
+}
+
+/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
+/// [`GenericBinaryArray<S>`], panicking on failure.
+#[inline]
+pub fn as_generic_binary_array<S: OffsetSizeTrait>(arr: &dyn Array) -> &GenericBinaryArray<S> {
+    arr.as_any()
+        .downcast_ref::<GenericBinaryArray<S>>()
+        .expect("Unable to downcast to binary array")
+}
+
+/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
+/// [`StringArray`], panicking on failure.
+///
+/// # Example
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::cast::as_string_array;
+/// # use arrow_array::{ArrayRef, StringArray};
+///
+/// let arr: ArrayRef = Arc::new(StringArray::from_iter(vec![Some("foo")]));
+/// let string_array = as_string_array(&arr);
+/// ```
+pub fn as_string_array(arr: &dyn Array) -> &StringArray {
+    arr.as_any()
+        .downcast_ref::<StringArray>()
+        .expect("Unable to downcast to StringArray")
+}
+
+/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
+/// [`BooleanArray`], panicking on failure.
+///
+/// # Example
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::{ArrayRef, BooleanArray};
+/// # use arrow_array::cast::as_boolean_array;
+///
+/// let arr: ArrayRef = Arc::new(BooleanArray::from_iter(vec![Some(true)]));
+/// let boolean_array = as_boolean_array(&arr);
+/// ```
+pub fn as_boolean_array(arr: &dyn Array) -> &BooleanArray {
+    arr.as_any()
+        .downcast_ref::<BooleanArray>()
+        .expect("Unable to downcast to BooleanArray")
+}
+
+macro_rules! array_downcast_fn {
+    ($name: ident, $arrty: ty, $arrty_str:expr) => {
+        #[doc = "Force downcast of an [`Array`], such as an [`ArrayRef`] to "]
+        #[doc = $arrty_str]
+        pub fn $name(arr: &dyn Array) -> &$arrty {
+            arr.as_any().downcast_ref::<$arrty>().expect(concat!(
+                "Unable to downcast to typed array through ",
+                stringify!($name)
+            ))
+        }
+    };
+
+    // use recursive macro to generate dynamic doc string for a given array type
+    ($name: ident, $arrty: ty) => {
+        array_downcast_fn!(
+            $name,
+            $arrty,
+            concat!("[`", stringify!($arrty), "`], panicking on failure.")
+        );
+    };
+}
+
+array_downcast_fn!(as_largestring_array, LargeStringArray);
+array_downcast_fn!(as_null_array, NullArray);
+array_downcast_fn!(as_struct_array, StructArray);
+array_downcast_fn!(as_union_array, UnionArray);
+array_downcast_fn!(as_map_array, MapArray);
+
+/// Force downcast of an Array, such as an ArrayRef to Decimal128Array, panic’ing on failure.
+#[deprecated(note = "please use `as_primitive_array::<Decimal128Type>` instead")]
+pub fn as_decimal_array(arr: &dyn Array) -> &PrimitiveArray<Decimal128Type> {
+    as_primitive_array::<Decimal128Type>(arr)
+}
+
+/// Downcasts a `dyn Array` to a concrete type
+///
+/// ```
+/// # use arrow_array::{BooleanArray, Int32Array, RecordBatch, StringArray};
+/// # use arrow_array::cast::downcast_array;
+/// struct ConcreteBatch {
+///     col1: Int32Array,
+///     col2: BooleanArray,
+///     col3: StringArray,
+/// }
+///
+/// impl ConcreteBatch {
+///     fn new(batch: &RecordBatch) -> Self {
+///         Self {
+///             col1: downcast_array(batch.column(0).as_ref()),
+///             col2: downcast_array(batch.column(1).as_ref()),
+///             col3: downcast_array(batch.column(2).as_ref()),
+///         }
+///     }
+/// }
+/// ```
+///
+/// # Panics
+///
+/// Panics if array is not of the correct data type
+pub fn downcast_array<T>(array: &dyn Array) -> T
+where
+    T: From<ArrayData>,
+{
+    T::from(array.to_data())
+}
+
+mod private {
+    pub trait Sealed {}
+}
+
+/// An extension trait for `dyn Array` that provides ergonomic downcasting
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::{ArrayRef, Int32Array};
+/// # use arrow_array::cast::AsArray;
+/// # use arrow_array::types::Int32Type;
+/// let col = Arc::new(Int32Array::from(vec![1, 2, 3])) as ArrayRef;
+/// assert_eq!(col.as_primitive::<Int32Type>().values(), &[1, 2, 3]);
+/// ```
+pub trait AsArray: private::Sealed {
+    /// Downcast this to a [`BooleanArray`] returning `None` if not possible
+    fn as_boolean_opt(&self) -> Option<&BooleanArray>;
+
+    /// Downcast this to a [`BooleanArray`] panicking if not possible
+    fn as_boolean(&self) -> &BooleanArray {
+        self.as_boolean_opt().expect("boolean array")
+    }
+
+    /// Downcast this to a [`PrimitiveArray`] returning `None` if not possible
+    fn as_primitive_opt<T: ArrowPrimitiveType>(&self) -> Option<&PrimitiveArray<T>>;
+
+    /// Downcast this to a [`PrimitiveArray`] panicking if not possible
+    fn as_primitive<T: ArrowPrimitiveType>(&self) -> &PrimitiveArray<T> {
+        self.as_primitive_opt().expect("primitive array")
+    }
+
+    /// Downcast this to a [`GenericByteArray`] returning `None` if not possible
+    fn as_bytes_opt<T: ByteArrayType>(&self) -> Option<&GenericByteArray<T>>;
+
+    /// Downcast this to a [`GenericByteArray`] panicking if not possible
+    fn as_bytes<T: ByteArrayType>(&self) -> &GenericByteArray<T> {
+        self.as_bytes_opt().expect("byte array")
+    }
+
+    /// Downcast this to a [`GenericStringArray`] returning `None` if not possible
+    fn as_string_opt<O: OffsetSizeTrait>(&self) -> Option<&GenericStringArray<O>> {
+        self.as_bytes_opt()
+    }
+
+    /// Downcast this to a [`GenericStringArray`] panicking if not possible
+    fn as_string<O: OffsetSizeTrait>(&self) -> &GenericStringArray<O> {
+        self.as_bytes_opt().expect("string array")
+    }
+
+    /// Downcast this to a [`GenericBinaryArray`] returning `None` if not possible
+    fn as_binary_opt<O: OffsetSizeTrait>(&self) -> Option<&GenericBinaryArray<O>> {
+        self.as_bytes_opt()
+    }
+
+    /// Downcast this to a [`GenericBinaryArray`] panicking if not possible
+    fn as_binary<O: OffsetSizeTrait>(&self) -> &GenericBinaryArray<O> {
+        self.as_bytes_opt().expect("binary array")
+    }
+
+    /// Downcast this to a [`StructArray`] returning `None` if not possible
+    fn as_struct_opt(&self) -> Option<&StructArray>;
+
+    /// Downcast this to a [`StructArray`] panicking if not possible
+    fn as_struct(&self) -> &StructArray {
+        self.as_struct_opt().expect("struct array")
+    }
+
+    /// Downcast this to a [`GenericListArray`] returning `None` if not possible
+    fn as_list_opt<O: OffsetSizeTrait>(&self) -> Option<&GenericListArray<O>>;
+
+    /// Downcast this to a [`GenericListArray`] panicking if not possible
+    fn as_list<O: OffsetSizeTrait>(&self) -> &GenericListArray<O> {
+        self.as_list_opt().expect("list array")
+    }
+
+    /// Downcast this to a [`FixedSizeBinaryArray`] returning `None` if not possible
+    fn as_fixed_size_binary_opt(&self) -> Option<&FixedSizeBinaryArray>;
+
+    /// Downcast this to a [`FixedSizeBinaryArray`] panicking if not possible
+    fn as_fixed_size_binary(&self) -> &FixedSizeBinaryArray {
+        self.as_fixed_size_binary_opt()
+            .expect("fixed size binary array")
+    }
+
+    /// Downcast this to a [`FixedSizeListArray`] returning `None` if not possible
+    fn as_fixed_size_list_opt(&self) -> Option<&FixedSizeListArray>;
+
+    /// Downcast this to a [`FixedSizeListArray`] panicking if not possible
+    fn as_fixed_size_list(&self) -> &FixedSizeListArray {
+        self.as_fixed_size_list_opt()
+            .expect("fixed size list array")
+    }
+
+    /// Downcast this to a [`MapArray`] returning `None` if not possible
+    fn as_map_opt(&self) -> Option<&MapArray>;
+
+    /// Downcast this to a [`MapArray`] panicking if not possible
+    fn as_map(&self) -> &MapArray {
+        self.as_map_opt().expect("map array")
+    }
+
+    /// Downcast this to a [`DictionaryArray`] returning `None` if not possible
+    fn as_dictionary_opt<K: ArrowDictionaryKeyType>(&self) -> Option<&DictionaryArray<K>>;
+
+    /// Downcast this to a [`DictionaryArray`] panicking if not possible
+    fn as_dictionary<K: ArrowDictionaryKeyType>(&self) -> &DictionaryArray<K> {
+        self.as_dictionary_opt().expect("dictionary array")
+    }
+
+    /// Downcasts this to a [`AnyDictionaryArray`] returning `None` if not possible
+    fn as_any_dictionary_opt(&self) -> Option<&dyn AnyDictionaryArray>;
+
+    /// Downcasts this to a [`AnyDictionaryArray`] panicking if not possible
+    fn as_any_dictionary(&self) -> &dyn AnyDictionaryArray {
+        self.as_any_dictionary_opt().expect("any dictionary array")
+    }
+}
+
+impl private::Sealed for dyn Array + '_ {}
+impl AsArray for dyn Array + '_ {
+    fn as_boolean_opt(&self) -> Option<&BooleanArray> {
+        self.as_any().downcast_ref()
+    }
+
+    fn as_primitive_opt<T: ArrowPrimitiveType>(&self) -> Option<&PrimitiveArray<T>> {
+        self.as_any().downcast_ref()
+    }
+
+    fn as_bytes_opt<T: ByteArrayType>(&self) -> Option<&GenericByteArray<T>> {
+        self.as_any().downcast_ref()
+    }
+
+    fn as_struct_opt(&self) -> Option<&StructArray> {
+        self.as_any().downcast_ref()
+    }
+
+    fn as_list_opt<O: OffsetSizeTrait>(&self) -> Option<&GenericListArray<O>> {
+        self.as_any().downcast_ref()
+    }
+
+    fn as_fixed_size_binary_opt(&self) -> Option<&FixedSizeBinaryArray> {
+        self.as_any().downcast_ref()
+    }
+
+    fn as_fixed_size_list_opt(&self) -> Option<&FixedSizeListArray> {
+        self.as_any().downcast_ref()
+    }
+
+    fn as_map_opt(&self) -> Option<&MapArray> {
+        self.as_any().downcast_ref()
+    }
+
+    fn as_dictionary_opt<K: ArrowDictionaryKeyType>(&self) -> Option<&DictionaryArray<K>> {
+        self.as_any().downcast_ref()
+    }
+
+    fn as_any_dictionary_opt(&self) -> Option<&dyn AnyDictionaryArray> {
+        let array = self;
+        downcast_dictionary_array! {
+            array => Some(array),
+            _ => None
+        }
+    }
+}
+
+impl private::Sealed for ArrayRef {}
+impl AsArray for ArrayRef {
+    fn as_boolean_opt(&self) -> Option<&BooleanArray> {
+        self.as_ref().as_boolean_opt()
+    }
+
+    fn as_primitive_opt<T: ArrowPrimitiveType>(&self) -> Option<&PrimitiveArray<T>> {
+        self.as_ref().as_primitive_opt()
+    }
+
+    fn as_bytes_opt<T: ByteArrayType>(&self) -> Option<&GenericByteArray<T>> {
+        self.as_ref().as_bytes_opt()
+    }
+
+    fn as_struct_opt(&self) -> Option<&StructArray> {
+        self.as_ref().as_struct_opt()
+    }
+
+    fn as_list_opt<O: OffsetSizeTrait>(&self) -> Option<&GenericListArray<O>> {
+        self.as_ref().as_list_opt()
+    }
+
+    fn as_fixed_size_binary_opt(&self) -> Option<&FixedSizeBinaryArray> {
+        self.as_ref().as_fixed_size_binary_opt()
+    }
+
+    fn as_fixed_size_list_opt(&self) -> Option<&FixedSizeListArray> {
+        self.as_ref().as_fixed_size_list_opt()
+    }
+
+    fn as_map_opt(&self) -> Option<&MapArray> {
+        self.as_any().downcast_ref()
+    }
+
+    fn as_dictionary_opt<K: ArrowDictionaryKeyType>(&self) -> Option<&DictionaryArray<K>> {
+        self.as_ref().as_dictionary_opt()
+    }
+
+    fn as_any_dictionary_opt(&self) -> Option<&dyn AnyDictionaryArray> {
+        self.as_ref().as_any_dictionary_opt()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow_buffer::i256;
+    use std::sync::Arc;
+
+    use super::*;
+
+    #[test]
+    fn test_as_primitive_array_ref() {
+        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
+        assert!(!as_primitive_array::<Int32Type>(&array).is_empty());
+
+        // should also work when wrapped in an Arc
+        let array: ArrayRef = Arc::new(array);
+        assert!(!as_primitive_array::<Int32Type>(&array).is_empty());
+    }
+
+    #[test]
+    fn test_as_string_array_ref() {
+        let array: StringArray = vec!["foo", "bar"].into_iter().map(Some).collect();
+        assert!(!as_string_array(&array).is_empty());
+
+        // should also work when wrapped in an Arc
+        let array: ArrayRef = Arc::new(array);
+        assert!(!as_string_array(&array).is_empty())
+    }
+
+    #[test]
+    fn test_decimal128array() {
+        let a = Decimal128Array::from_iter_values([1, 2, 4, 5]);
+        assert!(!as_primitive_array::<Decimal128Type>(&a).is_empty());
+    }
+
+    #[test]
+    fn test_decimal256array() {
+        let a = Decimal256Array::from_iter_values([1, 2, 4, 5].into_iter().map(i256::from_i128));
+        assert!(!as_primitive_array::<Decimal256Type>(&a).is_empty());
+    }
+}
diff --git a/arrow-array/src/delta.rs b/arrow-array/src/delta.rs
new file mode 100644
index 000000000000..d9aa4aa6de5d
--- /dev/null
+++ b/arrow-array/src/delta.rs
@@ -0,0 +1,285 @@
+// MIT License
+//
+// Copyright (c) 2020-2022 Oliver Margetts
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in all
+// copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+// SOFTWARE.
+
+// Copied from chronoutil crate
+
+//! Contains utility functions for shifting Date objects.
+use chrono::{DateTime, Datelike, Days, Months, TimeZone};
+use std::cmp::Ordering;
+
+/// Shift a date by the given number of months.
+pub(crate) fn shift_months<D>(date: D, months: i32) -> D
+where
+    D: Datelike + std::ops::Add<Months, Output = D> + std::ops::Sub<Months, Output = D>,
+{
+    match months.cmp(&0) {
+        Ordering::Equal => date,
+        Ordering::Greater => date + Months::new(months as u32),
+        Ordering::Less => date - Months::new(months.unsigned_abs()),
+    }
+}
+
+/// Add the given number of months to the given datetime.
+///
+/// Returns `None` when it will result in overflow.
+pub(crate) fn add_months_datetime<Tz: TimeZone>(
+    dt: DateTime<Tz>,
+    months: i32,
+) -> Option<DateTime<Tz>> {
+    match months.cmp(&0) {
+        Ordering::Equal => Some(dt),
+        Ordering::Greater => dt.checked_add_months(Months::new(months as u32)),
+        Ordering::Less => dt.checked_sub_months(Months::new(months.unsigned_abs())),
+    }
+}
+
+/// Add the given number of days to the given datetime.
+///
+/// Returns `None` when it will result in overflow.
+pub(crate) fn add_days_datetime<Tz: TimeZone>(dt: DateTime<Tz>, days: i32) -> Option<DateTime<Tz>> {
+    match days.cmp(&0) {
+        Ordering::Equal => Some(dt),
+        Ordering::Greater => dt.checked_add_days(Days::new(days as u64)),
+        Ordering::Less => dt.checked_sub_days(Days::new(days.unsigned_abs() as u64)),
+    }
+}
+
+/// Substract the given number of months to the given datetime.
+///
+/// Returns `None` when it will result in overflow.
+pub(crate) fn sub_months_datetime<Tz: TimeZone>(
+    dt: DateTime<Tz>,
+    months: i32,
+) -> Option<DateTime<Tz>> {
+    match months.cmp(&0) {
+        Ordering::Equal => Some(dt),
+        Ordering::Greater => dt.checked_sub_months(Months::new(months as u32)),
+        Ordering::Less => dt.checked_add_months(Months::new(months.unsigned_abs())),
+    }
+}
+
+/// Substract the given number of days to the given datetime.
+///
+/// Returns `None` when it will result in overflow.
+pub(crate) fn sub_days_datetime<Tz: TimeZone>(dt: DateTime<Tz>, days: i32) -> Option<DateTime<Tz>> {
+    match days.cmp(&0) {
+        Ordering::Equal => Some(dt),
+        Ordering::Greater => dt.checked_sub_days(Days::new(days as u64)),
+        Ordering::Less => dt.checked_add_days(Days::new(days.unsigned_abs() as u64)),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+
+    use chrono::naive::{NaiveDate, NaiveDateTime, NaiveTime};
+
+    use super::*;
+
+    #[test]
+    fn test_shift_months() {
+        let base = NaiveDate::from_ymd_opt(2020, 1, 31).unwrap();
+
+        assert_eq!(
+            shift_months(base, 0),
+            NaiveDate::from_ymd_opt(2020, 1, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 1),
+            NaiveDate::from_ymd_opt(2020, 2, 29).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 2),
+            NaiveDate::from_ymd_opt(2020, 3, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 3),
+            NaiveDate::from_ymd_opt(2020, 4, 30).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 4),
+            NaiveDate::from_ymd_opt(2020, 5, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 5),
+            NaiveDate::from_ymd_opt(2020, 6, 30).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 6),
+            NaiveDate::from_ymd_opt(2020, 7, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 7),
+            NaiveDate::from_ymd_opt(2020, 8, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 8),
+            NaiveDate::from_ymd_opt(2020, 9, 30).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 9),
+            NaiveDate::from_ymd_opt(2020, 10, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 10),
+            NaiveDate::from_ymd_opt(2020, 11, 30).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 11),
+            NaiveDate::from_ymd_opt(2020, 12, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 12),
+            NaiveDate::from_ymd_opt(2021, 1, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 13),
+            NaiveDate::from_ymd_opt(2021, 2, 28).unwrap()
+        );
+
+        assert_eq!(
+            shift_months(base, -1),
+            NaiveDate::from_ymd_opt(2019, 12, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -2),
+            NaiveDate::from_ymd_opt(2019, 11, 30).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -3),
+            NaiveDate::from_ymd_opt(2019, 10, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -4),
+            NaiveDate::from_ymd_opt(2019, 9, 30).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -5),
+            NaiveDate::from_ymd_opt(2019, 8, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -6),
+            NaiveDate::from_ymd_opt(2019, 7, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -7),
+            NaiveDate::from_ymd_opt(2019, 6, 30).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -8),
+            NaiveDate::from_ymd_opt(2019, 5, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -9),
+            NaiveDate::from_ymd_opt(2019, 4, 30).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -10),
+            NaiveDate::from_ymd_opt(2019, 3, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -11),
+            NaiveDate::from_ymd_opt(2019, 2, 28).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -12),
+            NaiveDate::from_ymd_opt(2019, 1, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -13),
+            NaiveDate::from_ymd_opt(2018, 12, 31).unwrap()
+        );
+
+        assert_eq!(
+            shift_months(base, 1265),
+            NaiveDate::from_ymd_opt(2125, 6, 30).unwrap()
+        );
+    }
+
+    #[test]
+    fn test_shift_months_with_overflow() {
+        let base = NaiveDate::from_ymd_opt(2020, 12, 31).unwrap();
+
+        assert_eq!(shift_months(base, 0), base);
+        assert_eq!(
+            shift_months(base, 1),
+            NaiveDate::from_ymd_opt(2021, 1, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 2),
+            NaiveDate::from_ymd_opt(2021, 2, 28).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 12),
+            NaiveDate::from_ymd_opt(2021, 12, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 18),
+            NaiveDate::from_ymd_opt(2022, 6, 30).unwrap()
+        );
+
+        assert_eq!(
+            shift_months(base, -1),
+            NaiveDate::from_ymd_opt(2020, 11, 30).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -2),
+            NaiveDate::from_ymd_opt(2020, 10, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -10),
+            NaiveDate::from_ymd_opt(2020, 2, 29).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -12),
+            NaiveDate::from_ymd_opt(2019, 12, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, -18),
+            NaiveDate::from_ymd_opt(2019, 6, 30).unwrap()
+        );
+    }
+
+    #[test]
+    fn test_shift_months_datetime() {
+        let date = NaiveDate::from_ymd_opt(2020, 1, 31).unwrap();
+        let o_clock = NaiveTime::from_hms_opt(1, 2, 3).unwrap();
+
+        let base = NaiveDateTime::new(date, o_clock);
+
+        assert_eq!(
+            shift_months(base, 0).date(),
+            NaiveDate::from_ymd_opt(2020, 1, 31).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 1).date(),
+            NaiveDate::from_ymd_opt(2020, 2, 29).unwrap()
+        );
+        assert_eq!(
+            shift_months(base, 2).date(),
+            NaiveDate::from_ymd_opt(2020, 3, 31).unwrap()
+        );
+        assert_eq!(shift_months(base, 0).time(), o_clock);
+        assert_eq!(shift_months(base, 1).time(), o_clock);
+        assert_eq!(shift_months(base, 2).time(), o_clock);
+    }
+}
diff --git a/arrow/src/array/iterator.rs b/arrow-array/src/iterator.rs
similarity index 73%
rename from arrow/src/array/iterator.rs
rename to arrow-array/src/iterator.rs
index 7cc9bde6b4c5..3f9cc0d525c1 100644
--- a/arrow/src/array/iterator.rs
+++ b/arrow-array/src/iterator.rs
@@ -15,19 +15,39 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::array::ArrayAccessor;
-use crate::array::BasicDecimalArray;
+//! Idiomatic iterators for [`Array`](crate::Array)
 
-use super::{
-    Array, BooleanArray, Decimal128Array, GenericBinaryArray, GenericListArray,
+use crate::array::{
+    ArrayAccessor, BooleanArray, FixedSizeBinaryArray, GenericBinaryArray, GenericListArray,
     GenericStringArray, PrimitiveArray,
 };
-
-/// an iterator that returns Some(T) or None, that can be used on any [`ArrayAccessor`]
-// Note: This implementation is based on std's [Vec]s' [IntoIter].
+use crate::{FixedSizeListArray, MapArray};
+use arrow_buffer::NullBuffer;
+
+/// An iterator that returns Some(T) or None, that can be used on any [`ArrayAccessor`]
+///
+/// # Performance
+///
+/// [`ArrayIter`] provides an idiomatic way to iterate over an array, however, this
+/// comes at the cost of performance. In particular the interleaved handling of
+/// the null mask is often sub-optimal.
+///
+/// If performing an infallible operation, it is typically faster to perform the operation
+/// on every index of the array, and handle the null mask separately. For [`PrimitiveArray`]
+/// this functionality is provided by [`compute::unary`]
+///
+/// If performing a fallible operation, it isn't possible to perform the operation independently
+/// of the null mask, as this might result in a spurious failure on a null index. However,
+/// there are more efficient ways to iterate over just the non-null indices, this functionality
+/// is provided by [`compute::try_unary`]
+///
+/// [`PrimitiveArray`]: crate::PrimitiveArray
+/// [`compute::unary`]: https://docs.rs/arrow/latest/arrow/compute/fn.unary.html
+/// [`compute::try_unary`]: https://docs.rs/arrow/latest/arrow/compute/fn.try_unary.html
 #[derive(Debug)]
 pub struct ArrayIter<T: ArrayAccessor> {
     array: T,
+    logical_nulls: Option<NullBuffer>,
     current: usize,
     current_end: usize,
 }
@@ -36,12 +56,22 @@ impl<T: ArrayAccessor> ArrayIter<T> {
     /// create a new iterator
     pub fn new(array: T) -> Self {
         let len = array.len();
+        let logical_nulls = array.logical_nulls();
         ArrayIter {
             array,
+            logical_nulls,
             current: 0,
             current_end: len,
         }
     }
+
+    #[inline]
+    fn is_null(&self, idx: usize) -> bool {
+        self.logical_nulls
+            .as_ref()
+            .map(|x| x.is_null(idx))
+            .unwrap_or_default()
+    }
 }
 
 impl<T: ArrayAccessor> Iterator for ArrayIter<T> {
@@ -51,7 +81,7 @@ impl<T: ArrayAccessor> Iterator for ArrayIter<T> {
     fn next(&mut self) -> Option<Self::Item> {
         if self.current == self.current_end {
             None
-        } else if self.array.is_null(self.current) {
+        } else if self.is_null(self.current) {
             self.current += 1;
             Some(None)
         } else {
@@ -80,7 +110,7 @@ impl<T: ArrayAccessor> DoubleEndedIterator for ArrayIter<T> {
             None
         } else {
             self.current_end -= 1;
-            Some(if self.array.is_null(self.current_end) {
+            Some(if self.is_null(self.current_end) {
                 None
             } else {
                 // Safety:
@@ -99,74 +129,20 @@ impl<T: ArrayAccessor> ExactSizeIterator for ArrayIter<T> {}
 
 /// an iterator that returns Some(T) or None, that can be used on any PrimitiveArray
 pub type PrimitiveIter<'a, T> = ArrayIter<&'a PrimitiveArray<T>>;
+/// an iterator that returns Some(T) or None, that can be used on any BooleanArray
 pub type BooleanIter<'a> = ArrayIter<&'a BooleanArray>;
+/// an iterator that returns Some(T) or None, that can be used on any Utf8Array
 pub type GenericStringIter<'a, T> = ArrayIter<&'a GenericStringArray<T>>;
+/// an iterator that returns Some(T) or None, that can be used on any BinaryArray
 pub type GenericBinaryIter<'a, T> = ArrayIter<&'a GenericBinaryArray<T>>;
+/// an iterator that returns Some(T) or None, that can be used on any FixedSizeBinaryArray
+pub type FixedSizeBinaryIter<'a> = ArrayIter<&'a FixedSizeBinaryArray>;
+/// an iterator that returns Some(T) or None, that can be used on any FixedSizeListArray
+pub type FixedSizeListIter<'a> = ArrayIter<&'a FixedSizeListArray>;
+/// an iterator that returns Some(T) or None, that can be used on any ListArray
 pub type GenericListArrayIter<'a, O> = ArrayIter<&'a GenericListArray<O>>;
-
-pub type BasicDecimalIter<'a, const BYTE_WIDTH: usize> =
-    ArrayIter<&'a BasicDecimalArray<BYTE_WIDTH>>;
-/// an iterator that returns `Some(Decimal128)` or `None`, that can be used on a
-/// [`Decimal128Array`]
-pub type Decimal128Iter<'a> = BasicDecimalIter<'a, 16>;
-
-/// an iterator that returns `Some(Decimal256)` or `None`, that can be used on a
-/// [`super::Decimal256Array`]
-pub type Decimal256Iter<'a> = BasicDecimalIter<'a, 32>;
-/// an iterator that returns `Some(i128)` or `None`, that can be used on a
-/// [`Decimal128Array`]
-#[derive(Debug)]
-#[deprecated(note = "Please use `Decimal128Iter` instead. \
-    `DecimalIter` iterates `Decimal128` values as i128 values. \
-    This is kept mostly for back-compatibility purpose. Suggests to use `Decimal128Array.iter()` \
-    that returns `Decimal128Iter`.")]
-pub struct DecimalIter<'a> {
-    array: &'a Decimal128Array,
-    current: usize,
-    current_end: usize,
-}
-
-#[allow(deprecated)]
-impl<'a> DecimalIter<'a> {
-    pub fn new(array: &'a Decimal128Array) -> Self {
-        Self {
-            array,
-            current: 0,
-            current_end: array.len(),
-        }
-    }
-}
-
-#[allow(deprecated)]
-impl<'a> std::iter::Iterator for DecimalIter<'a> {
-    type Item = Option<i128>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.current == self.current_end {
-            None
-        } else {
-            let old = self.current;
-            self.current += 1;
-            // TODO: Improve performance by avoiding bounds check here
-            // (by using adding a `value_unchecked, for example)
-            if self.array.is_null(old) {
-                Some(None)
-            } else {
-                Some(Some(self.array.value(old).as_i128()))
-            }
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let remain = self.current_end - self.current;
-        (remain, Some(remain))
-    }
-}
-
-/// iterator has known size.
-#[allow(deprecated)]
-impl<'a> std::iter::ExactSizeIterator for DecimalIter<'a> {}
+/// an iterator that returns Some(T) or None, that can be used on any MapArray
+pub type MapArrayIter<'a> = ArrayIter<&'a MapArray>;
 
 #[cfg(test)]
 mod tests {
@@ -211,8 +187,7 @@ mod tests {
 
     #[test]
     fn test_string_array_iter_round_trip() {
-        let array =
-            StringArray::from(vec![Some("a"), None, Some("aaa"), None, Some("aaaaa")]);
+        let array = StringArray::from(vec![Some("a"), None, Some("aaa"), None, Some("aaaaa")]);
         let array = Arc::new(array) as ArrayRef;
 
         let array = array.as_any().downcast_ref::<StringArray>().unwrap();
@@ -235,8 +210,7 @@ mod tests {
 
         // check if DoubleEndedIterator is implemented
         let result: StringArray = array.iter().rev().collect();
-        let rev_array =
-            StringArray::from(vec![Some("aaaaa"), None, Some("aaa"), None, Some("a")]);
+        let rev_array = StringArray::from(vec![Some("aaaaa"), None, Some("aaa"), None, Some("a")]);
         assert_eq!(result, rev_array);
         // check if ExactSizeIterator is implemented
         let _ = array.iter().rposition(|opt_b| opt_b == Some("a"));
diff --git a/arrow-array/src/lib.rs b/arrow-array/src/lib.rs
new file mode 100644
index 000000000000..ef98c5efefb0
--- /dev/null
+++ b/arrow-array/src/lib.rs
@@ -0,0 +1,239 @@
+// 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.
+
+//! The central type in Apache Arrow are arrays, which are a known-length sequence of values
+//! all having the same type. This crate provides concrete implementations of each type, as
+//! well as an [`Array`] trait that can be used for type-erasure.
+//!
+//! # Building an Array
+//!
+//! Most [`Array`] implementations can be constructed directly from iterators or [`Vec`]
+//!
+//! ```
+//! # use arrow_array::{Int32Array, ListArray, StringArray};
+//! # use arrow_array::types::Int32Type;
+//! #
+//! Int32Array::from(vec![1, 2]);
+//! Int32Array::from(vec![Some(1), None]);
+//! Int32Array::from_iter([1, 2, 3, 4]);
+//! Int32Array::from_iter([Some(1), Some(2), None, Some(4)]);
+//!
+//! StringArray::from(vec!["foo", "bar"]);
+//! StringArray::from(vec![Some("foo"), None]);
+//! StringArray::from_iter([Some("foo"), None]);
+//! StringArray::from_iter_values(["foo", "bar"]);
+//!
+//! ListArray::from_iter_primitive::<Int32Type, _, _>([
+//!     Some(vec![Some(1), None, Some(3)]),
+//!     None,
+//!     Some(vec![])
+//! ]);
+//! ```
+//!
+//! Additionally [`ArrayBuilder`](builder::ArrayBuilder) implementations can be
+//! used to construct arrays with a push-based interface
+//!
+//! ```
+//! # use arrow_array::Int16Array;
+//! #
+//! // Create a new builder with a capacity of 100
+//! let mut builder = Int16Array::builder(100);
+//!
+//! // Append a single primitive value
+//! builder.append_value(1);
+//! // Append a null value
+//! builder.append_null();
+//! // Append a slice of primitive values
+//! builder.append_slice(&[2, 3, 4]);
+//!
+//! // Build the array
+//! let array = builder.finish();
+//!
+//! assert_eq!(5, array.len());
+//! assert_eq!(2, array.value(2));
+//! assert_eq!(&array.values()[3..5], &[3, 4])
+//! ```
+//!
+//! # Low-level API
+//!
+//! Internally, arrays consist of one or more shared memory regions backed by a [`Buffer`],
+//! the number and meaning of which depend on the array’s data type, as documented in
+//! the [Arrow specification].
+//!
+//! For example, the type [`Int16Array`] represents an array of 16-bit integers and consists of:
+//!
+//! * An optional [`NullBuffer`] identifying any null values
+//! * A contiguous [`ScalarBuffer<i16>`] of values
+//!
+//! Similarly, the type [`StringArray`] represents an array of UTF-8 strings and consists of:
+//!
+//! * An optional [`NullBuffer`] identifying any null values
+//! * An offsets [`OffsetBuffer<i32>`] identifying valid UTF-8 sequences within the values buffer
+//! * A values [`Buffer`] of UTF-8 encoded string data
+//!
+//! Array constructors such as [`PrimitiveArray::try_new`] provide the ability to cheaply
+//! construct an array from these parts, with functions such as [`PrimitiveArray::into_parts`]
+//! providing the reverse operation.
+//!
+//! ```
+//! # use arrow_array::{Array, Int32Array, StringArray};
+//! # use arrow_buffer::OffsetBuffer;
+//! #
+//! // Create a Int32Array from Vec without copying
+//! let array = Int32Array::new(vec![1, 2, 3].into(), None);
+//! assert_eq!(array.values(), &[1, 2, 3]);
+//! assert_eq!(array.null_count(), 0);
+//!
+//! // Create a StringArray from parts
+//! let offsets = OffsetBuffer::new(vec![0, 5, 10].into());
+//! let array = StringArray::new(offsets, b"helloworld".into(), None);
+//! let values: Vec<_> = array.iter().map(|x| x.unwrap()).collect();
+//! assert_eq!(values, &["hello", "world"]);
+//! ```
+//!
+//! As [`Buffer`], and its derivatives, can be created from [`Vec`] without copying, this provides
+//! an efficient way to not only interoperate with other Rust code, but also implement kernels
+//! optimised for the arrow data layout - e.g. by handling buffers instead of values.
+//!
+//! # Zero-Copy Slicing
+//!
+//! Given an [`Array`] of arbitrary length, it is possible to create an owned slice of this
+//! data. Internally this just increments some ref-counts, and so is incredibly cheap
+//!
+//! ```rust
+//! # use arrow_array::Int32Array;
+//! let array = Int32Array::from_iter([1, 2, 3]);
+//!
+//! // Slice with offset 1 and length 2
+//! let sliced = array.slice(1, 2);
+//! assert_eq!(sliced.values(), &[2, 3]);
+//! ```
+//!
+//! # Downcasting an Array
+//!
+//! Arrays are often passed around as a dynamically typed [`&dyn Array`] or [`ArrayRef`].
+//! For example, [`RecordBatch`](`crate::RecordBatch`) stores columns as [`ArrayRef`].
+//!
+//! Whilst these arrays can be passed directly to the [`compute`], [`csv`], [`json`], etc... APIs,
+//! it is often the case that you wish to interact with the concrete arrays directly.
+//!
+//! This requires downcasting to the concrete type of the array:
+//!
+//! ```
+//! # use arrow_array::{Array, Float32Array, Int32Array};
+//!
+//! // Safely downcast an `Array` to an `Int32Array` and compute the sum
+//! // using native i32 values
+//! fn sum_int32(array: &dyn Array) -> i32 {
+//!     let integers: &Int32Array = array.as_any().downcast_ref().unwrap();
+//!     integers.iter().map(|val| val.unwrap_or_default()).sum()
+//! }
+//!
+//! // Safely downcasts the array to a `Float32Array` and returns a &[f32] view of the data
+//! // Note: the values for positions corresponding to nulls will be arbitrary (but still valid f32)
+//! fn as_f32_slice(array: &dyn Array) -> &[f32] {
+//!     array.as_any().downcast_ref::<Float32Array>().unwrap().values()
+//! }
+//! ```
+//!
+//! The [`cast::AsArray`] extension trait can make this more ergonomic
+//!
+//! ```
+//! # use arrow_array::Array;
+//! # use arrow_array::cast::{AsArray, as_primitive_array};
+//! # use arrow_array::types::Float32Type;
+//!
+//! fn as_f32_slice(array: &dyn Array) -> &[f32] {
+//!     array.as_primitive::<Float32Type>().values()
+//! }
+//! ```
+//!
+//! [`ScalarBuffer<T>`]: arrow_buffer::ScalarBuffer
+//! [`ScalarBuffer<i16>`]: arrow_buffer::ScalarBuffer
+//! [`OffsetBuffer<i32>`]: arrow_buffer::OffsetBuffer
+//! [`NullBuffer`]: arrow_buffer::NullBuffer
+//! [Arrow specification]: https://arrow.apache.org/docs/format/Columnar.html
+//! [`&dyn Array`]: Array
+//! [`NullBuffer`]: arrow_buffer::NullBuffer
+//! [`Buffer`]: arrow_buffer::Buffer
+//! [`compute`]: https://docs.rs/arrow/latest/arrow/compute/index.html
+//! [`json`]: https://docs.rs/arrow/latest/arrow/json/index.html
+//! [`csv`]: https://docs.rs/arrow/latest/arrow/csv/index.html
+
+#![deny(rustdoc::broken_intra_doc_links)]
+#![warn(missing_docs)]
+
+pub mod array;
+pub use array::*;
+
+mod record_batch;
+pub use record_batch::{
+    RecordBatch, RecordBatchIterator, RecordBatchOptions, RecordBatchReader, RecordBatchWriter,
+};
+
+mod arithmetic;
+pub use arithmetic::ArrowNativeTypeOp;
+
+mod numeric;
+pub use numeric::*;
+
+mod scalar;
+pub use scalar::*;
+
+pub mod builder;
+pub mod cast;
+mod delta;
+pub mod iterator;
+pub mod run_iterator;
+pub mod temporal_conversions;
+pub mod timezone;
+mod trusted_len;
+pub mod types;
+
+#[cfg(test)]
+mod tests {
+    use crate::builder::*;
+
+    #[test]
+    fn test_buffer_builder_availability() {
+        let _builder = Int8BufferBuilder::new(10);
+        let _builder = Int16BufferBuilder::new(10);
+        let _builder = Int32BufferBuilder::new(10);
+        let _builder = Int64BufferBuilder::new(10);
+        let _builder = UInt16BufferBuilder::new(10);
+        let _builder = UInt32BufferBuilder::new(10);
+        let _builder = Float32BufferBuilder::new(10);
+        let _builder = Float64BufferBuilder::new(10);
+        let _builder = TimestampSecondBufferBuilder::new(10);
+        let _builder = TimestampMillisecondBufferBuilder::new(10);
+        let _builder = TimestampMicrosecondBufferBuilder::new(10);
+        let _builder = TimestampNanosecondBufferBuilder::new(10);
+        let _builder = Date32BufferBuilder::new(10);
+        let _builder = Date64BufferBuilder::new(10);
+        let _builder = Time32SecondBufferBuilder::new(10);
+        let _builder = Time32MillisecondBufferBuilder::new(10);
+        let _builder = Time64MicrosecondBufferBuilder::new(10);
+        let _builder = Time64NanosecondBufferBuilder::new(10);
+        let _builder = IntervalYearMonthBufferBuilder::new(10);
+        let _builder = IntervalDayTimeBufferBuilder::new(10);
+        let _builder = IntervalMonthDayNanoBufferBuilder::new(10);
+        let _builder = DurationSecondBufferBuilder::new(10);
+        let _builder = DurationMillisecondBufferBuilder::new(10);
+        let _builder = DurationMicrosecondBufferBuilder::new(10);
+        let _builder = DurationNanosecondBufferBuilder::new(10);
+    }
+}
diff --git a/parquet/build.rs b/arrow-array/src/numeric.rs
similarity index 72%
rename from parquet/build.rs
rename to arrow-array/src/numeric.rs
index 8aada1835ce1..a3cd7bde5d36 100644
--- a/parquet/build.rs
+++ b/arrow-array/src/numeric.rs
@@ -15,10 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-fn main() {
-    // Set Parquet version and "created by" string.
-    let version = env!("CARGO_PKG_VERSION");
-    let created_by = format!("parquet-rs version {}", version);
-    println!("cargo:rustc-env=PARQUET_VERSION={}", version);
-    println!("cargo:rustc-env=PARQUET_CREATED_BY={}", created_by);
-}
+use crate::ArrowPrimitiveType;
+
+/// A subtype of primitive type that represents numeric values.
+pub trait ArrowNumericType: ArrowPrimitiveType {}
+
+impl<T: ArrowPrimitiveType> ArrowNumericType for T {}
diff --git a/arrow/src/record_batch.rs b/arrow-array/src/record_batch.rs
similarity index 62%
rename from arrow/src/record_batch.rs
rename to arrow-array/src/record_batch.rs
index 47257b496c1b..d89020a65681 100644
--- a/arrow/src/record_batch.rs
+++ b/arrow-array/src/record_batch.rs
@@ -16,17 +16,50 @@
 // under the License.
 
 //! A two-dimensional batch of column-oriented data with a defined
-//! [schema](crate::datatypes::Schema).
+//! [schema](arrow_schema::Schema).
 
+use crate::{new_empty_array, Array, ArrayRef, StructArray};
+use arrow_schema::{ArrowError, DataType, Field, Schema, SchemaBuilder, SchemaRef};
+use std::ops::Index;
 use std::sync::Arc;
 
-use crate::array::*;
-use crate::compute::kernels::concat::concat;
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
+/// Trait for types that can read `RecordBatch`'s.
+///
+/// To create from an iterator, see [RecordBatchIterator].
+pub trait RecordBatchReader: Iterator<Item = Result<RecordBatch, ArrowError>> {
+    /// Returns the schema of this `RecordBatchReader`.
+    ///
+    /// Implementation of this trait should guarantee that all `RecordBatch`'s returned by this
+    /// reader should have the same schema as returned from this method.
+    fn schema(&self) -> SchemaRef;
+
+    /// Reads the next `RecordBatch`.
+    #[deprecated(
+        since = "2.0.0",
+        note = "This method is deprecated in favour of `next` from the trait Iterator."
+    )]
+    fn next_batch(&mut self) -> Result<Option<RecordBatch>, ArrowError> {
+        self.next().transpose()
+    }
+}
+
+impl<R: RecordBatchReader + ?Sized> RecordBatchReader for Box<R> {
+    fn schema(&self) -> SchemaRef {
+        self.as_ref().schema()
+    }
+}
+
+/// Trait for types that can write `RecordBatch`'s.
+pub trait RecordBatchWriter {
+    /// Write a single batch to the writer.
+    fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError>;
+
+    /// Write footer or termination data, then mark the writer as done.
+    fn close(self) -> Result<(), ArrowError>;
+}
 
 /// A two-dimensional batch of column-oriented data with a defined
-/// [schema](crate::datatypes::Schema).
+/// [schema](arrow_schema::Schema).
 ///
 /// A `RecordBatch` is a two-dimensional dataset of a number of
 /// contiguous arrays, each the same length.
@@ -35,8 +68,6 @@ use crate::error::{ArrowError, Result};
 ///
 /// Record batches are a convenient unit of work for various
 /// serialization and computation functions, possibly incremental.
-/// See also [CSV reader](crate::csv::Reader) and
-/// [JSON reader](crate::json::Reader).
 #[derive(Clone, Debug, PartialEq)]
 pub struct RecordBatch {
     schema: SchemaRef,
@@ -62,12 +93,10 @@ impl RecordBatch {
     /// # Example
     ///
     /// ```
-    /// use std::sync::Arc;
-    /// use arrow::array::Int32Array;
-    /// use arrow::datatypes::{Schema, Field, DataType};
-    /// use arrow::record_batch::RecordBatch;
+    /// # use std::sync::Arc;
+    /// # use arrow_array::{Int32Array, RecordBatch};
+    /// # use arrow_schema::{DataType, Field, Schema};
     ///
-    /// # fn main() -> arrow::error::Result<()> {
     /// let id_array = Int32Array::from(vec![1, 2, 3, 4, 5]);
     /// let schema = Schema::new(vec![
     ///     Field::new("id", DataType::Int32, false)
@@ -76,12 +105,10 @@ impl RecordBatch {
     /// let batch = RecordBatch::try_new(
     ///     Arc::new(schema),
     ///     vec![Arc::new(id_array)]
-    /// )?;
-    /// # Ok(())
-    /// # }
+    /// ).unwrap();
     /// ```
-    pub fn try_new(schema: SchemaRef, columns: Vec<ArrayRef>) -> Result<Self> {
-        let options = RecordBatchOptions::default();
+    pub fn try_new(schema: SchemaRef, columns: Vec<ArrayRef>) -> Result<Self, ArrowError> {
+        let options = RecordBatchOptions::new();
         Self::try_new_impl(schema, columns, &options)
     }
 
@@ -93,7 +120,7 @@ impl RecordBatch {
         schema: SchemaRef,
         columns: Vec<ArrayRef>,
         options: &RecordBatchOptions,
-    ) -> Result<Self> {
+    ) -> Result<Self, ArrowError> {
         Self::try_new_impl(schema, columns, options)
     }
 
@@ -118,7 +145,7 @@ impl RecordBatch {
         schema: SchemaRef,
         columns: Vec<ArrayRef>,
         options: &RecordBatchOptions,
-    ) -> Result<Self> {
+    ) -> Result<Self, ArrowError> {
         // check that number of fields in schema match column length
         if schema.fields().len() != columns.len() {
             return Err(ArrowError::InvalidArgumentError(format!(
@@ -128,7 +155,6 @@ impl RecordBatch {
             )));
         }
 
-        // check that all columns have the same row count
         let row_count = options
             .row_count
             .or_else(|| columns.first().map(|col| col.len()))
@@ -147,11 +173,10 @@ impl RecordBatch {
             }
         }
 
+        // check that all columns have the same row count
         if columns.iter().any(|c| c.len() != row_count) {
             let err = match options.row_count {
-                Some(_) => {
-                    "all columns in a record batch must have the specified row count"
-                }
+                Some(_) => "all columns in a record batch must have the specified row count",
                 None => "all columns in a record batch must have the same length",
             };
             return Err(ArrowError::InvalidArgumentError(err.to_string()));
@@ -160,9 +185,7 @@ impl RecordBatch {
         // function for comparing column type and field type
         // return true if 2 types are not matched
         let type_not_match = if options.match_field_names {
-            |(_, (col_type, field_type)): &(usize, (&DataType, &DataType))| {
-                col_type != field_type
-            }
+            |(_, (col_type, field_type)): &(usize, (&DataType, &DataType))| col_type != field_type
         } else {
             |(_, (col_type, field_type)): &(usize, (&DataType, &DataType))| {
                 !col_type.equals_datatype(field_type)
@@ -179,10 +202,7 @@ impl RecordBatch {
 
         if let Some((i, (col_type, field_type))) = not_match {
             return Err(ArrowError::InvalidArgumentError(format!(
-                "column types must match schema types, expected {:?} but found {:?} at column index {}",
-                field_type,
-                col_type,
-                i)));
+                "column types must match schema types, expected {field_type:?} but found {col_type:?} at column index {i}")));
         }
 
         Ok(RecordBatch {
@@ -192,13 +212,32 @@ impl RecordBatch {
         })
     }
 
-    /// Returns the [`Schema`](crate::datatypes::Schema) of the record batch.
+    /// Override the schema of this [`RecordBatch`]
+    ///
+    /// Returns an error if `schema` is not a superset of the current schema
+    /// as determined by [`Schema::contains`]
+    pub fn with_schema(self, schema: SchemaRef) -> Result<Self, ArrowError> {
+        if !schema.contains(self.schema.as_ref()) {
+            return Err(ArrowError::SchemaError(format!(
+                "target schema is not superset of current schema target={schema} current={}",
+                self.schema
+            )));
+        }
+
+        Ok(Self {
+            schema,
+            columns: self.columns,
+            row_count: self.row_count,
+        })
+    }
+
+    /// Returns the [`Schema`] of the record batch.
     pub fn schema(&self) -> SchemaRef {
         self.schema.clone()
     }
 
     /// Projects the schema onto the specified columns
-    pub fn project(&self, indices: &[usize]) -> Result<RecordBatch> {
+    pub fn project(&self, indices: &[usize]) -> Result<RecordBatch, ArrowError> {
         let projected_schema = self.schema.project(indices)?;
         let batch_fields = indices
             .iter()
@@ -211,9 +250,16 @@ impl RecordBatch {
                     ))
                 })
             })
-            .collect::<Result<Vec<_>>>()?;
-
-        RecordBatch::try_new(SchemaRef::new(projected_schema), batch_fields)
+            .collect::<Result<Vec<_>, _>>()?;
+
+        RecordBatch::try_new_with_options(
+            SchemaRef::new(projected_schema),
+            batch_fields,
+            &RecordBatchOptions {
+                match_field_names: true,
+                row_count: Some(self.row_count),
+            },
+        )
     }
 
     /// Returns the number of columns in the record batch.
@@ -221,22 +267,18 @@ impl RecordBatch {
     /// # Example
     ///
     /// ```
-    /// use std::sync::Arc;
-    /// use arrow::array::Int32Array;
-    /// use arrow::datatypes::{Schema, Field, DataType};
-    /// use arrow::record_batch::RecordBatch;
+    /// # use std::sync::Arc;
+    /// # use arrow_array::{Int32Array, RecordBatch};
+    /// # use arrow_schema::{DataType, Field, Schema};
     ///
-    /// # fn main() -> arrow::error::Result<()> {
     /// let id_array = Int32Array::from(vec![1, 2, 3, 4, 5]);
     /// let schema = Schema::new(vec![
     ///     Field::new("id", DataType::Int32, false)
     /// ]);
     ///
-    /// let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(id_array)])?;
+    /// let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(id_array)]).unwrap();
     ///
     /// assert_eq!(batch.num_columns(), 1);
-    /// # Ok(())
-    /// # }
     /// ```
     pub fn num_columns(&self) -> usize {
         self.columns.len()
@@ -247,22 +289,18 @@ impl RecordBatch {
     /// # Example
     ///
     /// ```
-    /// use std::sync::Arc;
-    /// use arrow::array::Int32Array;
-    /// use arrow::datatypes::{Schema, Field, DataType};
-    /// use arrow::record_batch::RecordBatch;
+    /// # use std::sync::Arc;
+    /// # use arrow_array::{Int32Array, RecordBatch};
+    /// # use arrow_schema::{DataType, Field, Schema};
     ///
-    /// # fn main() -> arrow::error::Result<()> {
     /// let id_array = Int32Array::from(vec![1, 2, 3, 4, 5]);
     /// let schema = Schema::new(vec![
     ///     Field::new("id", DataType::Int32, false)
     /// ]);
     ///
-    /// let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(id_array)])?;
+    /// let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(id_array)]).unwrap();
     ///
     /// assert_eq!(batch.num_rows(), 5);
-    /// # Ok(())
-    /// # }
     /// ```
     pub fn num_rows(&self) -> usize {
         self.row_count
@@ -277,11 +315,52 @@ impl RecordBatch {
         &self.columns[index]
     }
 
+    /// Get a reference to a column's array by name.
+    pub fn column_by_name(&self, name: &str) -> Option<&ArrayRef> {
+        self.schema()
+            .column_with_name(name)
+            .map(|(index, _)| &self.columns[index])
+    }
+
     /// Get a reference to all columns in the record batch.
     pub fn columns(&self) -> &[ArrayRef] {
         &self.columns[..]
     }
 
+    /// Remove column by index and return it.
+    ///
+    /// Return the `ArrayRef` if the column is removed.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `index`` out of bounds.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use std::sync::Arc;
+    /// use arrow_array::{BooleanArray, Int32Array, RecordBatch};
+    /// use arrow_schema::{DataType, Field, Schema};
+    /// let id_array = Int32Array::from(vec![1, 2, 3, 4, 5]);
+    /// let bool_array = BooleanArray::from(vec![true, false, false, true, true]);
+    /// let schema = Schema::new(vec![
+    ///     Field::new("id", DataType::Int32, false),
+    ///     Field::new("bool", DataType::Boolean, false),
+    /// ]);
+    ///
+    /// let mut batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(id_array), Arc::new(bool_array)]).unwrap();
+    ///
+    /// let removed_column = batch.remove_column(0);
+    /// assert_eq!(removed_column.as_any().downcast_ref::<Int32Array>().unwrap(), &Int32Array::from(vec![1, 2, 3, 4, 5]));
+    /// assert_eq!(batch.num_columns(), 1);
+    /// ```
+    pub fn remove_column(&mut self, index: usize) -> ArrayRef {
+        let mut builder = SchemaBuilder::from(self.schema.as_ref());
+        builder.remove(index);
+        self.schema = Arc::new(builder.finish());
+        self.columns.remove(index)
+    }
+
     /// Return a new RecordBatch where each column is sliced
     /// according to `offset` and `length`
     ///
@@ -316,10 +395,8 @@ impl RecordBatch {
     ///
     /// Example:
     /// ```
-    /// use std::sync::Arc;
-    /// use arrow::array::{ArrayRef, Int32Array, StringArray};
-    /// use arrow::datatypes::{Schema, Field, DataType};
-    /// use arrow::record_batch::RecordBatch;
+    /// # use std::sync::Arc;
+    /// # use arrow_array::{ArrayRef, Int32Array, RecordBatch, StringArray};
     ///
     /// let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2]));
     /// let b: ArrayRef = Arc::new(StringArray::from(vec!["a", "b"]));
@@ -329,7 +406,7 @@ impl RecordBatch {
     ///   ("b", b),
     /// ]);
     /// ```
-    pub fn try_from_iter<I, F>(value: I) -> Result<Self>
+    pub fn try_from_iter<I, F>(value: I) -> Result<Self, ArrowError>
     where
         I: IntoIterator<Item = (F, ArrayRef)>,
         F: AsRef<str>,
@@ -353,10 +430,8 @@ impl RecordBatch {
     ///
     /// Example:
     /// ```
-    /// use std::sync::Arc;
-    /// use arrow::array::{ArrayRef, Int32Array, StringArray};
-    /// use arrow::datatypes::{Schema, Field, DataType};
-    /// use arrow::record_batch::RecordBatch;
+    /// # use std::sync::Arc;
+    /// # use arrow_array::{ArrayRef, Int32Array, RecordBatch, StringArray};
     ///
     /// let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2]));
     /// let b: ArrayRef = Arc::new(StringArray::from(vec![Some("a"), Some("b")]));
@@ -368,54 +443,32 @@ impl RecordBatch {
     ///   ("b", b, true),
     /// ]);
     /// ```
-    pub fn try_from_iter_with_nullable<I, F>(value: I) -> Result<Self>
+    pub fn try_from_iter_with_nullable<I, F>(value: I) -> Result<Self, ArrowError>
     where
         I: IntoIterator<Item = (F, ArrayRef, bool)>,
         F: AsRef<str>,
     {
-        // TODO: implement `TryFrom` trait, once
-        // https://github.com/rust-lang/rust/issues/50133 is no longer an
-        // issue
-        let (fields, columns) = value
-            .into_iter()
-            .map(|(field_name, array, nullable)| {
-                let field_name = field_name.as_ref();
-                let field = Field::new(field_name, array.data_type().clone(), nullable);
-                (field, array)
-            })
-            .unzip();
+        let iter = value.into_iter();
+        let capacity = iter.size_hint().0;
+        let mut schema = SchemaBuilder::with_capacity(capacity);
+        let mut columns = Vec::with_capacity(capacity);
+
+        for (field_name, array, nullable) in iter {
+            let field_name = field_name.as_ref();
+            schema.push(Field::new(field_name, array.data_type().clone(), nullable));
+            columns.push(array);
+        }
 
-        let schema = Arc::new(Schema::new(fields));
+        let schema = Arc::new(schema.finish());
         RecordBatch::try_new(schema, columns)
     }
 
-    /// Concatenates `batches` together into a single record batch.
-    pub fn concat(schema: &SchemaRef, batches: &[Self]) -> Result<Self> {
-        if batches.is_empty() {
-            return Ok(RecordBatch::new_empty(schema.clone()));
-        }
-        if let Some((i, _)) = batches
+    /// Returns the total number of bytes of memory occupied physically by this batch.
+    pub fn get_array_memory_size(&self) -> usize {
+        self.columns()
             .iter()
-            .enumerate()
-            .find(|&(_, batch)| batch.schema() != *schema)
-        {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "batches[{}] schema is different with argument schema.",
-                i
-            )));
-        }
-        let field_num = schema.fields().len();
-        let mut arrays = Vec::with_capacity(field_num);
-        for i in 0..field_num {
-            let array = concat(
-                &batches
-                    .iter()
-                    .map(|batch| batch.column(i).as_ref())
-                    .collect::<Vec<_>>(),
-            )?;
-            arrays.push(array);
-        }
-        Self::try_new(schema.clone(), arrays)
+            .map(|array| array.get_array_memory_size())
+            .sum()
     }
 }
 
@@ -430,71 +483,148 @@ pub struct RecordBatchOptions {
     pub row_count: Option<usize>,
 }
 
-impl Default for RecordBatchOptions {
-    fn default() -> Self {
+impl RecordBatchOptions {
+    /// Creates a new `RecordBatchOptions`
+    pub fn new() -> Self {
         Self {
             match_field_names: true,
             row_count: None,
         }
     }
+    /// Sets the row_count of RecordBatchOptions and returns self
+    pub fn with_row_count(mut self, row_count: Option<usize>) -> Self {
+        self.row_count = row_count;
+        self
+    }
+    /// Sets the match_field_names of RecordBatchOptions and returns self
+    pub fn with_match_field_names(mut self, match_field_names: bool) -> Self {
+        self.match_field_names = match_field_names;
+        self
+    }
+}
+impl Default for RecordBatchOptions {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl From<StructArray> for RecordBatch {
+    fn from(value: StructArray) -> Self {
+        let row_count = value.len();
+        let (fields, columns, nulls) = value.into_parts();
+        assert_eq!(
+            nulls.map(|n| n.null_count()).unwrap_or_default(),
+            0,
+            "Cannot convert nullable StructArray to RecordBatch, see StructArray documentation"
+        );
+
+        RecordBatch {
+            schema: Arc::new(Schema::new(fields)),
+            row_count,
+            columns,
+        }
+    }
 }
 
 impl From<&StructArray> for RecordBatch {
-    /// Create a record batch from struct array, where each field of
-    /// the `StructArray` becomes a `Field` in the schema.
-    ///
-    /// This currently does not flatten and nested struct types
     fn from(struct_array: &StructArray) -> Self {
-        if let DataType::Struct(fields) = struct_array.data_type() {
-            let schema = Schema::new(fields.clone());
-            let columns = struct_array.boxed_fields.clone();
-            RecordBatch {
-                schema: Arc::new(schema),
-                row_count: struct_array.len(),
-                columns,
-            }
-        } else {
-            unreachable!("unable to get datatype as struct")
-        }
+        struct_array.clone().into()
     }
 }
 
-impl From<RecordBatch> for StructArray {
-    fn from(batch: RecordBatch) -> Self {
-        batch
-            .schema
-            .fields
-            .iter()
-            .zip(batch.columns.iter())
-            .map(|t| (t.0.clone(), t.1.clone()))
-            .collect::<Vec<(Field, ArrayRef)>>()
-            .into()
+impl Index<&str> for RecordBatch {
+    type Output = ArrayRef;
+
+    /// Get a reference to a column's array by name.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the name is not in the schema.
+    fn index(&self, name: &str) -> &Self::Output {
+        self.column_by_name(name).unwrap()
     }
 }
 
-/// Trait for types that can read `RecordBatch`'s.
-pub trait RecordBatchReader: Iterator<Item = Result<RecordBatch>> {
-    /// Returns the schema of this `RecordBatchReader`.
+/// Generic implementation of [RecordBatchReader] that wraps an iterator.
+///
+/// # Example
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::{ArrayRef, Int32Array, RecordBatch, StringArray, RecordBatchIterator, RecordBatchReader};
+/// #
+/// let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2]));
+/// let b: ArrayRef = Arc::new(StringArray::from(vec!["a", "b"]));
+///
+/// let record_batch = RecordBatch::try_from_iter(vec![
+///   ("a", a),
+///   ("b", b),
+/// ]).unwrap();
+///
+/// let batches: Vec<RecordBatch> = vec![record_batch.clone(), record_batch.clone()];
+///
+/// let mut reader = RecordBatchIterator::new(batches.into_iter().map(Ok), record_batch.schema());
+///
+/// assert_eq!(reader.schema(), record_batch.schema());
+/// assert_eq!(reader.next().unwrap().unwrap(), record_batch);
+/// # assert_eq!(reader.next().unwrap().unwrap(), record_batch);
+/// # assert!(reader.next().is_none());
+/// ```
+pub struct RecordBatchIterator<I>
+where
+    I: IntoIterator<Item = Result<RecordBatch, ArrowError>>,
+{
+    inner: I::IntoIter,
+    inner_schema: SchemaRef,
+}
+
+impl<I> RecordBatchIterator<I>
+where
+    I: IntoIterator<Item = Result<RecordBatch, ArrowError>>,
+{
+    /// Create a new [RecordBatchIterator].
     ///
-    /// Implementation of this trait should guarantee that all `RecordBatch`'s returned by this
-    /// reader should have the same schema as returned from this method.
-    fn schema(&self) -> SchemaRef;
+    /// If `iter` is an infallible iterator, use `.map(Ok)`.
+    pub fn new(iter: I, schema: SchemaRef) -> Self {
+        Self {
+            inner: iter.into_iter(),
+            inner_schema: schema,
+        }
+    }
+}
 
-    /// Reads the next `RecordBatch`.
-    #[deprecated(
-        since = "2.0.0",
-        note = "This method is deprecated in favour of `next` from the trait Iterator."
-    )]
-    fn next_batch(&mut self) -> Result<Option<RecordBatch>> {
-        self.next().transpose()
+impl<I> Iterator for RecordBatchIterator<I>
+where
+    I: IntoIterator<Item = Result<RecordBatch, ArrowError>>,
+{
+    type Item = I::Item;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.inner.next()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl<I> RecordBatchReader for RecordBatchIterator<I>
+where
+    I: IntoIterator<Item = Result<RecordBatch, ArrowError>>,
+{
+    fn schema(&self) -> SchemaRef {
+        self.inner_schema.clone()
     }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use std::collections::HashMap;
 
-    use crate::buffer::Buffer;
+    use super::*;
+    use crate::{BooleanArray, Int32Array, Int64Array, Int8Array, ListArray, StringArray};
+    use arrow_buffer::{Buffer, ToByteSlice};
+    use arrow_data::{ArrayData, ArrayDataBuilder};
+    use arrow_schema::Fields;
 
     #[test]
     fn create_record_batch() {
@@ -507,18 +637,32 @@ mod tests {
         let b = StringArray::from(vec!["a", "b", "c", "d", "e"]);
 
         let record_batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)])
-                .unwrap();
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]).unwrap();
         check_batch(record_batch, 5)
     }
 
+    #[test]
+    fn byte_size_should_not_regress() {
+        let schema = Schema::new(vec![
+            Field::new("a", DataType::Int32, false),
+            Field::new("b", DataType::Utf8, false),
+        ]);
+
+        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        let b = StringArray::from(vec!["a", "b", "c", "d", "e"]);
+
+        let record_batch =
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]).unwrap();
+        assert_eq!(record_batch.get_array_memory_size(), 364);
+    }
+
     fn check_batch(record_batch: RecordBatch, num_rows: usize) {
         assert_eq!(num_rows, record_batch.num_rows());
         assert_eq!(2, record_batch.num_columns());
         assert_eq!(&DataType::Int32, record_batch.schema().field(0).data_type());
         assert_eq!(&DataType::Utf8, record_batch.schema().field(1).data_type());
-        assert_eq!(num_rows, record_batch.column(0).data().len());
-        assert_eq!(num_rows, record_batch.column(1).data().len());
+        assert_eq!(num_rows, record_batch.column(0).len());
+        assert_eq!(num_rows, record_batch.column(1).len());
     }
 
     #[test]
@@ -534,8 +678,7 @@ mod tests {
         let b = StringArray::from(vec!["a", "b", "c", "d", "e", "f", "h", "i"]);
 
         let record_batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)])
-                .unwrap();
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]).unwrap();
 
         let offset = 2;
         let length = 5;
@@ -559,7 +702,7 @@ mod tests {
     #[test]
     #[should_panic(expected = "assertion failed: (offset + length) <= self.num_rows()")]
     fn create_record_batch_slice_empty_batch() {
-        let schema = Schema::new(vec![]);
+        let schema = Schema::empty();
 
         let record_batch = RecordBatch::new_empty(Arc::new(schema));
 
@@ -584,8 +727,8 @@ mod tests {
         ]));
         let b: ArrayRef = Arc::new(StringArray::from(vec!["a", "b", "c", "d", "e"]));
 
-        let record_batch = RecordBatch::try_from_iter(vec![("a", a), ("b", b)])
-            .expect("valid conversion");
+        let record_batch =
+            RecordBatch::try_from_iter(vec![("a", a), ("b", b)]).expect("valid conversion");
 
         let expected_schema = Schema::new(vec![
             Field::new("a", DataType::Int32, true),
@@ -601,11 +744,9 @@ mod tests {
         let b: ArrayRef = Arc::new(StringArray::from(vec!["a", "b", "c", "d", "e"]));
 
         // Note there are no nulls in a or b, but we specify that b is nullable
-        let record_batch = RecordBatch::try_from_iter_with_nullable(vec![
-            ("a", a, false),
-            ("b", b, true),
-        ])
-        .expect("valid conversion");
+        let record_batch =
+            RecordBatch::try_from_iter_with_nullable(vec![("a", a, false), ("b", b, true)])
+                .expect("valid conversion");
 
         let expected_schema = Schema::new(vec![
             Field::new("a", DataType::Int32, false),
@@ -627,34 +768,29 @@ mod tests {
 
     #[test]
     fn create_record_batch_field_name_mismatch() {
-        let struct_fields = vec![
+        let fields = vec![
             Field::new("a1", DataType::Int32, false),
-            Field::new(
-                "a2",
-                DataType::List(Box::new(Field::new("item", DataType::Int8, false))),
-                false,
-            ),
+            Field::new_list("a2", Field::new("item", DataType::Int8, false), false),
         ];
-        let struct_type = DataType::Struct(struct_fields);
-        let schema = Arc::new(Schema::new(vec![Field::new("a", struct_type, true)]));
+        let schema = Arc::new(Schema::new(vec![Field::new_struct("a", fields, true)]));
 
         let a1: ArrayRef = Arc::new(Int32Array::from(vec![1, 2]));
         let a2_child = Int8Array::from(vec![1, 2, 3, 4]);
-        let a2 = ArrayDataBuilder::new(DataType::List(Box::new(Field::new(
+        let a2 = ArrayDataBuilder::new(DataType::List(Arc::new(Field::new(
             "array",
             DataType::Int8,
             false,
         ))))
         .add_child_data(a2_child.into_data())
         .len(2)
-        .add_buffer(Buffer::from(vec![0i32, 3, 4].to_byte_slice()))
+        .add_buffer(Buffer::from([0i32, 3, 4].to_byte_slice()))
         .build()
         .unwrap();
         let a2: ArrayRef = Arc::new(ListArray::from(a2));
-        let a = ArrayDataBuilder::new(DataType::Struct(vec![
+        let a = ArrayDataBuilder::new(DataType::Struct(Fields::from(vec![
             Field::new("aa1", DataType::Int32, false),
             Field::new("a2", a2.data_type().clone(), false),
-        ]))
+        ])))
         .add_child_data(a1.into_data())
         .add_child_data(a2.into_data())
         .len(2)
@@ -682,8 +818,7 @@ mod tests {
         let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
         let b = Int32Array::from(vec![1, 2, 3, 4, 5]);
 
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]);
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]);
         assert!(batch.is_err());
     }
 
@@ -693,11 +828,11 @@ mod tests {
         let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
         let struct_array = StructArray::from(vec![
             (
-                Field::new("b", DataType::Boolean, false),
+                Arc::new(Field::new("b", DataType::Boolean, false)),
                 boolean.clone() as ArrayRef,
             ),
             (
-                Field::new("c", DataType::Int32, false),
+                Arc::new(Field::new("c", DataType::Int32, false)),
                 int.clone() as ArrayRef,
             ),
         ]);
@@ -707,84 +842,12 @@ mod tests {
         assert_eq!(4, batch.num_rows());
         assert_eq!(
             struct_array.data_type(),
-            &DataType::Struct(batch.schema().fields().to_vec())
+            &DataType::Struct(batch.schema().fields().clone())
         );
         assert_eq!(batch.column(0).as_ref(), boolean.as_ref());
         assert_eq!(batch.column(1).as_ref(), int.as_ref());
     }
 
-    #[test]
-    fn concat_record_batches() {
-        let schema = Arc::new(Schema::new(vec![
-            Field::new("a", DataType::Int32, false),
-            Field::new("b", DataType::Utf8, false),
-        ]));
-        let batch1 = RecordBatch::try_new(
-            schema.clone(),
-            vec![
-                Arc::new(Int32Array::from(vec![1, 2])),
-                Arc::new(StringArray::from(vec!["a", "b"])),
-            ],
-        )
-        .unwrap();
-        let batch2 = RecordBatch::try_new(
-            schema.clone(),
-            vec![
-                Arc::new(Int32Array::from(vec![3, 4])),
-                Arc::new(StringArray::from(vec!["c", "d"])),
-            ],
-        )
-        .unwrap();
-        let new_batch = RecordBatch::concat(&schema, &[batch1, batch2]).unwrap();
-        assert_eq!(new_batch.schema().as_ref(), schema.as_ref());
-        assert_eq!(2, new_batch.num_columns());
-        assert_eq!(4, new_batch.num_rows());
-    }
-
-    #[test]
-    fn concat_empty_record_batch() {
-        let schema = Arc::new(Schema::new(vec![
-            Field::new("a", DataType::Int32, false),
-            Field::new("b", DataType::Utf8, false),
-        ]));
-        let batch = RecordBatch::concat(&schema, &[]).unwrap();
-        assert_eq!(batch.schema().as_ref(), schema.as_ref());
-        assert_eq!(0, batch.num_rows());
-    }
-
-    #[test]
-    fn concat_record_batches_of_different_schemas() {
-        let schema1 = Arc::new(Schema::new(vec![
-            Field::new("a", DataType::Int32, false),
-            Field::new("b", DataType::Utf8, false),
-        ]));
-        let schema2 = Arc::new(Schema::new(vec![
-            Field::new("c", DataType::Int32, false),
-            Field::new("d", DataType::Utf8, false),
-        ]));
-        let batch1 = RecordBatch::try_new(
-            schema1.clone(),
-            vec![
-                Arc::new(Int32Array::from(vec![1, 2])),
-                Arc::new(StringArray::from(vec!["a", "b"])),
-            ],
-        )
-        .unwrap();
-        let batch2 = RecordBatch::try_new(
-            schema2,
-            vec![
-                Arc::new(Int32Array::from(vec![3, 4])),
-                Arc::new(StringArray::from(vec!["c", "d"])),
-            ],
-        )
-        .unwrap();
-        let error = RecordBatch::concat(&schema1, &[batch1, batch2]).unwrap_err();
-        assert_eq!(
-            error.to_string(),
-            "Invalid argument error: batches[1] schema is different with argument schema.",
-        );
-    }
-
     #[test]
     fn record_batch_equality() {
         let id_arr1 = Int32Array::from(vec![1, 2, 3, 4]);
@@ -816,6 +879,22 @@ mod tests {
         assert_eq!(batch1, batch2);
     }
 
+    /// validates if the record batch can be accessed using `column_name` as index i.e. `record_batch["column_name"]`
+    #[test]
+    fn record_batch_index_access() {
+        let id_arr = Arc::new(Int32Array::from(vec![1, 2, 3, 4]));
+        let val_arr = Arc::new(Int32Array::from(vec![5, 6, 7, 8]));
+        let schema1 = Schema::new(vec![
+            Field::new("id", DataType::Int32, false),
+            Field::new("val", DataType::Int32, false),
+        ]);
+        let record_batch =
+            RecordBatch::try_new(Arc::new(schema1), vec![id_arr.clone(), val_arr.clone()]).unwrap();
+
+        assert_eq!(record_batch["id"].as_ref(), id_arr.as_ref());
+        assert_eq!(record_batch["val"].as_ref(), val_arr.as_ref());
+    }
+
     #[test]
     fn record_batch_vals_ne() {
         let id_arr1 = Int32Array::from(vec![1, 2, 3, 4]);
@@ -948,35 +1027,48 @@ mod tests {
         let b: ArrayRef = Arc::new(StringArray::from(vec!["a", "b", "c"]));
         let c: ArrayRef = Arc::new(StringArray::from(vec!["d", "e", "f"]));
 
-        let record_batch = RecordBatch::try_from_iter(vec![
-            ("a", a.clone()),
-            ("b", b.clone()),
-            ("c", c.clone()),
-        ])
-        .expect("valid conversion");
+        let record_batch =
+            RecordBatch::try_from_iter(vec![("a", a.clone()), ("b", b.clone()), ("c", c.clone())])
+                .expect("valid conversion");
 
-        let expected = RecordBatch::try_from_iter(vec![("a", a), ("c", c)])
-            .expect("valid conversion");
+        let expected =
+            RecordBatch::try_from_iter(vec![("a", a), ("c", c)]).expect("valid conversion");
 
         assert_eq!(expected, record_batch.project(&[0, 2]).unwrap());
     }
 
+    #[test]
+    fn project_empty() {
+        let c: ArrayRef = Arc::new(StringArray::from(vec!["d", "e", "f"]));
+
+        let record_batch =
+            RecordBatch::try_from_iter(vec![("c", c.clone())]).expect("valid conversion");
+
+        let expected = RecordBatch::try_new_with_options(
+            Arc::new(Schema::empty()),
+            vec![],
+            &RecordBatchOptions {
+                match_field_names: true,
+                row_count: Some(3),
+            },
+        )
+        .expect("valid conversion");
+
+        assert_eq!(expected, record_batch.project(&[]).unwrap());
+    }
+
     #[test]
     fn test_no_column_record_batch() {
-        let schema = Arc::new(Schema::new(vec![]));
+        let schema = Arc::new(Schema::empty());
 
         let err = RecordBatch::try_new(schema.clone(), vec![]).unwrap_err();
         assert!(err
             .to_string()
             .contains("must either specify a row count or at least one column"));
 
-        let options = RecordBatchOptions {
-            row_count: Some(10),
-            ..Default::default()
-        };
+        let options = RecordBatchOptions::new().with_row_count(Some(10));
 
-        let ok =
-            RecordBatch::try_new_with_options(schema.clone(), vec![], &options).unwrap();
+        let ok = RecordBatch::try_new_with_options(schema.clone(), vec![], &options).unwrap();
         assert_eq!(ok.num_rows(), 10);
 
         let a = ok.slice(2, 5);
@@ -998,4 +1090,98 @@ mod tests {
         );
         assert_eq!("Invalid argument error: Column 'a' is declared as non-nullable but contains null values", format!("{}", maybe_batch.err().unwrap()));
     }
+    #[test]
+    fn test_record_batch_options() {
+        let options = RecordBatchOptions::new()
+            .with_match_field_names(false)
+            .with_row_count(Some(20));
+        assert!(!options.match_field_names);
+        assert_eq!(options.row_count.unwrap(), 20)
+    }
+
+    #[test]
+    #[should_panic(expected = "Cannot convert nullable StructArray to RecordBatch")]
+    fn test_from_struct() {
+        let s = StructArray::from(ArrayData::new_null(
+            // Note child is not nullable
+            &DataType::Struct(vec![Field::new("foo", DataType::Int32, false)].into()),
+            2,
+        ));
+        let _ = RecordBatch::from(s);
+    }
+
+    #[test]
+    fn test_with_schema() {
+        let required_schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
+        let required_schema = Arc::new(required_schema);
+        let nullable_schema = Schema::new(vec![Field::new("a", DataType::Int32, true)]);
+        let nullable_schema = Arc::new(nullable_schema);
+
+        let batch = RecordBatch::try_new(
+            required_schema.clone(),
+            vec![Arc::new(Int32Array::from(vec![1, 2, 3])) as _],
+        )
+        .unwrap();
+
+        // Can add nullability
+        let batch = batch.with_schema(nullable_schema.clone()).unwrap();
+
+        // Cannot remove nullability
+        batch.clone().with_schema(required_schema).unwrap_err();
+
+        // Can add metadata
+        let metadata = vec![("foo".to_string(), "bar".to_string())]
+            .into_iter()
+            .collect();
+        let metadata_schema = nullable_schema.as_ref().clone().with_metadata(metadata);
+        let batch = batch.with_schema(Arc::new(metadata_schema)).unwrap();
+
+        // Cannot remove metadata
+        batch.with_schema(nullable_schema).unwrap_err();
+    }
+
+    #[test]
+    fn test_boxed_reader() {
+        // Make sure we can pass a boxed reader to a function generic over
+        // RecordBatchReader.
+        let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
+        let schema = Arc::new(schema);
+
+        let reader = RecordBatchIterator::new(std::iter::empty(), schema);
+        let reader: Box<dyn RecordBatchReader + Send> = Box::new(reader);
+
+        fn get_size(reader: impl RecordBatchReader) -> usize {
+            reader.size_hint().0
+        }
+
+        let size = get_size(reader);
+        assert_eq!(size, 0);
+    }
+
+    #[test]
+    fn test_remove_column_maintains_schema_metadata() {
+        let id_array = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        let bool_array = BooleanArray::from(vec![true, false, false, true, true]);
+
+        let mut metadata = HashMap::new();
+        metadata.insert("foo".to_string(), "bar".to_string());
+        let schema = Schema::new(vec![
+            Field::new("id", DataType::Int32, false),
+            Field::new("bool", DataType::Boolean, false),
+        ])
+        .with_metadata(metadata);
+
+        let mut batch = RecordBatch::try_new(
+            Arc::new(schema),
+            vec![Arc::new(id_array), Arc::new(bool_array)],
+        )
+        .unwrap();
+
+        let _removed_column = batch.remove_column(0);
+        assert_eq!(batch.schema().metadata().len(), 1);
+        assert_eq!(
+            batch.schema().metadata().get("foo").unwrap().as_str(),
+            "bar"
+        );
+    }
 }
diff --git a/arrow-array/src/run_iterator.rs b/arrow-array/src/run_iterator.rs
new file mode 100644
index 000000000000..7a98fccb73b5
--- /dev/null
+++ b/arrow-array/src/run_iterator.rs
@@ -0,0 +1,384 @@
+// 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.
+
+//! Idiomatic iterator for [`RunArray`](crate::Array)
+
+use crate::{array::ArrayAccessor, types::RunEndIndexType, Array, TypedRunArray};
+use arrow_buffer::ArrowNativeType;
+
+/// The [`RunArrayIter`] provides an idiomatic way to iterate over the run array.
+/// It returns Some(T) if there is a value or None if the value is null.
+///
+/// The iterator comes with a cost as it has to iterate over three arrays to determine
+/// the value to be returned. The run_ends array is used to determine the index of the value.
+/// The nulls array is used to determine if the value is null and the values array is used to
+/// get the value.
+///
+/// Unlike other iterators in this crate, [`RunArrayIter`] does not use [`ArrayAccessor`]
+/// because the run array accessor does binary search to access each value which is too slow.
+/// The run array iterator can determine the next value in constant time.
+///
+#[derive(Debug)]
+pub struct RunArrayIter<'a, R, V>
+where
+    R: RunEndIndexType,
+    V: Sync + Send,
+    &'a V: ArrayAccessor,
+    <&'a V as ArrayAccessor>::Item: Default,
+{
+    array: TypedRunArray<'a, R, V>,
+    current_front_logical: usize,
+    current_front_physical: usize,
+    current_back_logical: usize,
+    current_back_physical: usize,
+}
+
+impl<'a, R, V> RunArrayIter<'a, R, V>
+where
+    R: RunEndIndexType,
+    V: Sync + Send,
+    &'a V: ArrayAccessor,
+    <&'a V as ArrayAccessor>::Item: Default,
+{
+    /// create a new iterator
+    pub fn new(array: TypedRunArray<'a, R, V>) -> Self {
+        let current_front_physical = array.run_array().get_start_physical_index();
+        let current_back_physical = array.run_array().get_end_physical_index() + 1;
+        RunArrayIter {
+            array,
+            current_front_logical: array.offset(),
+            current_front_physical,
+            current_back_logical: array.offset() + array.len(),
+            current_back_physical,
+        }
+    }
+}
+
+impl<'a, R, V> Iterator for RunArrayIter<'a, R, V>
+where
+    R: RunEndIndexType,
+    V: Sync + Send,
+    &'a V: ArrayAccessor,
+    <&'a V as ArrayAccessor>::Item: Default,
+{
+    type Item = Option<<&'a V as ArrayAccessor>::Item>;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.current_front_logical == self.current_back_logical {
+            return None;
+        }
+
+        // If current logical index is greater than current run end index then increment
+        // the physical index.
+        let run_ends = self.array.run_ends().values();
+        if self.current_front_logical >= run_ends[self.current_front_physical].as_usize() {
+            // As the run_ends is expected to be strictly increasing, there
+            // should be at least one logical entry in one physical entry. Because of this
+            // reason the next value can be accessed by incrementing physical index once.
+            self.current_front_physical += 1;
+        }
+        if self.array.values().is_null(self.current_front_physical) {
+            self.current_front_logical += 1;
+            Some(None)
+        } else {
+            self.current_front_logical += 1;
+            // Safety:
+            // The self.current_physical is kept within bounds of self.current_logical.
+            // The self.current_logical will not go out of bounds because of the check
+            // `self.current_logical = self.current_end_logical` above.
+            unsafe {
+                Some(Some(
+                    self.array
+                        .values()
+                        .value_unchecked(self.current_front_physical),
+                ))
+            }
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        (
+            self.current_back_logical - self.current_front_logical,
+            Some(self.current_back_logical - self.current_front_logical),
+        )
+    }
+}
+
+impl<'a, R, V> DoubleEndedIterator for RunArrayIter<'a, R, V>
+where
+    R: RunEndIndexType,
+    V: Sync + Send,
+    &'a V: ArrayAccessor,
+    <&'a V as ArrayAccessor>::Item: Default,
+{
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.current_back_logical == self.current_front_logical {
+            return None;
+        }
+
+        self.current_back_logical -= 1;
+
+        let run_ends = self.array.run_ends().values();
+        if self.current_back_physical > 0
+            && self.current_back_logical < run_ends[self.current_back_physical - 1].as_usize()
+        {
+            // As the run_ends is expected to be strictly increasing, there
+            // should be at least one logical entry in one physical entry. Because of this
+            // reason the next value can be accessed by decrementing physical index once.
+            self.current_back_physical -= 1;
+        }
+        Some(if self.array.values().is_null(self.current_back_physical) {
+            None
+        } else {
+            // Safety:
+            // The check `self.current_end_physical > 0` ensures the value will not underflow.
+            // Also self.current_end_physical starts with array.len() and
+            // decrements based on the bounds of self.current_end_logical.
+            unsafe {
+                Some(
+                    self.array
+                        .values()
+                        .value_unchecked(self.current_back_physical),
+                )
+            }
+        })
+    }
+}
+
+/// all arrays have known size.
+impl<'a, R, V> ExactSizeIterator for RunArrayIter<'a, R, V>
+where
+    R: RunEndIndexType,
+    V: Sync + Send,
+    &'a V: ArrayAccessor,
+    <&'a V as ArrayAccessor>::Item: Default,
+{
+}
+
+#[cfg(test)]
+mod tests {
+    use rand::{seq::SliceRandom, thread_rng, Rng};
+
+    use crate::{
+        array::{Int32Array, StringArray},
+        builder::PrimitiveRunBuilder,
+        types::{Int16Type, Int32Type},
+        Array, Int64RunArray, PrimitiveArray, RunArray,
+    };
+
+    fn build_input_array(size: usize) -> Vec<Option<i32>> {
+        // The input array is created by shuffling and repeating
+        // the seed values random number of times.
+        let mut seed: Vec<Option<i32>> = vec![
+            None,
+            None,
+            None,
+            Some(1),
+            Some(2),
+            Some(3),
+            Some(4),
+            Some(5),
+            Some(6),
+            Some(7),
+            Some(8),
+            Some(9),
+        ];
+        let mut result: Vec<Option<i32>> = Vec::with_capacity(size);
+        let mut ix = 0;
+        let mut rng = thread_rng();
+        // run length can go up to 8. Cap the max run length for smaller arrays to size / 2.
+        let max_run_length = 8_usize.min(1_usize.max(size / 2));
+        while result.len() < size {
+            // shuffle the seed array if all the values are iterated.
+            if ix == 0 {
+                seed.shuffle(&mut rng);
+            }
+            // repeat the items between 1 and 8 times. Cap the length for smaller sized arrays
+            let num = max_run_length.min(rand::thread_rng().gen_range(1..=max_run_length));
+            for _ in 0..num {
+                result.push(seed[ix]);
+            }
+            ix += 1;
+            if ix == seed.len() {
+                ix = 0
+            }
+        }
+        result.resize(size, None);
+        result
+    }
+
+    #[test]
+    fn test_primitive_array_iter_round_trip() {
+        let mut input_vec = vec![
+            Some(32),
+            Some(32),
+            None,
+            Some(64),
+            Some(64),
+            Some(64),
+            Some(72),
+        ];
+        let mut builder = PrimitiveRunBuilder::<Int32Type, Int32Type>::new();
+        builder.extend(input_vec.iter().copied());
+        let ree_array = builder.finish();
+        let ree_array = ree_array.downcast::<Int32Array>().unwrap();
+
+        let output_vec: Vec<Option<i32>> = ree_array.into_iter().collect();
+        assert_eq!(input_vec, output_vec);
+
+        let rev_output_vec: Vec<Option<i32>> = ree_array.into_iter().rev().collect();
+        input_vec.reverse();
+        assert_eq!(input_vec, rev_output_vec);
+    }
+
+    #[test]
+    fn test_double_ended() {
+        let input_vec = vec![
+            Some(32),
+            Some(32),
+            None,
+            Some(64),
+            Some(64),
+            Some(64),
+            Some(72),
+        ];
+        let mut builder = PrimitiveRunBuilder::<Int32Type, Int32Type>::new();
+        builder.extend(input_vec);
+        let ree_array = builder.finish();
+        let ree_array = ree_array.downcast::<Int32Array>().unwrap();
+
+        let mut iter = ree_array.into_iter();
+        assert_eq!(Some(Some(32)), iter.next());
+        assert_eq!(Some(Some(72)), iter.next_back());
+        assert_eq!(Some(Some(32)), iter.next());
+        assert_eq!(Some(Some(64)), iter.next_back());
+        assert_eq!(Some(None), iter.next());
+        assert_eq!(Some(Some(64)), iter.next_back());
+        assert_eq!(Some(Some(64)), iter.next());
+        assert_eq!(None, iter.next_back());
+        assert_eq!(None, iter.next());
+    }
+
+    #[test]
+    fn test_run_iterator_comprehensive() {
+        // Test forward and backward iterator for different array lengths.
+        let logical_lengths = vec![1_usize, 2, 3, 4, 15, 16, 17, 63, 64, 65];
+
+        for logical_len in logical_lengths {
+            let input_array = build_input_array(logical_len);
+
+            let mut run_array_builder = PrimitiveRunBuilder::<Int32Type, Int32Type>::new();
+            run_array_builder.extend(input_array.iter().copied());
+            let run_array = run_array_builder.finish();
+            let typed_array = run_array.downcast::<Int32Array>().unwrap();
+
+            // test forward iterator
+            let mut input_iter = input_array.iter().copied();
+            let mut run_array_iter = typed_array.into_iter();
+            for _ in 0..logical_len {
+                assert_eq!(input_iter.next(), run_array_iter.next());
+            }
+            assert_eq!(None, run_array_iter.next());
+
+            // test reverse iterator
+            let mut input_iter = input_array.iter().rev().copied();
+            let mut run_array_iter = typed_array.into_iter().rev();
+            for _ in 0..logical_len {
+                assert_eq!(input_iter.next(), run_array_iter.next());
+            }
+            assert_eq!(None, run_array_iter.next());
+        }
+    }
+
+    #[test]
+    fn test_string_array_iter_round_trip() {
+        let input_vec = vec!["ab", "ab", "ba", "cc", "cc"];
+        let input_ree_array: Int64RunArray = input_vec.into_iter().collect();
+        let string_ree_array = input_ree_array.downcast::<StringArray>().unwrap();
+
+        // to and from iter, with a +1
+        let result: Vec<Option<String>> = string_ree_array
+            .into_iter()
+            .map(|e| {
+                e.map(|e| {
+                    let mut a = e.to_string();
+                    a.push('b');
+                    a
+                })
+            })
+            .collect();
+
+        let result_asref: Vec<Option<&str>> = result.iter().map(|f| f.as_deref()).collect();
+
+        let expected_vec = vec![
+            Some("abb"),
+            Some("abb"),
+            Some("bab"),
+            Some("ccb"),
+            Some("ccb"),
+        ];
+
+        assert_eq!(expected_vec, result_asref);
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // Takes too long
+    fn test_sliced_run_array_iterator() {
+        let total_len = 80;
+        let input_array = build_input_array(total_len);
+
+        // Encode the input_array to run array
+        let mut builder =
+            PrimitiveRunBuilder::<Int16Type, Int32Type>::with_capacity(input_array.len());
+        builder.extend(input_array.iter().copied());
+        let run_array = builder.finish();
+
+        // test for all slice lengths.
+        for slice_len in 1..=total_len {
+            // test for offset = 0, slice length = slice_len
+            let sliced_run_array: RunArray<Int16Type> =
+                run_array.slice(0, slice_len).into_data().into();
+            let sliced_typed_run_array = sliced_run_array
+                .downcast::<PrimitiveArray<Int32Type>>()
+                .unwrap();
+
+            // Iterate on sliced typed run array
+            let actual: Vec<Option<i32>> = sliced_typed_run_array.into_iter().collect();
+            let expected: Vec<Option<i32>> = input_array.iter().take(slice_len).copied().collect();
+            assert_eq!(expected, actual);
+
+            // test for offset = total_len - slice_len, length = slice_len
+            let sliced_run_array: RunArray<Int16Type> = run_array
+                .slice(total_len - slice_len, slice_len)
+                .into_data()
+                .into();
+            let sliced_typed_run_array = sliced_run_array
+                .downcast::<PrimitiveArray<Int32Type>>()
+                .unwrap();
+
+            // Iterate on sliced typed run array
+            let actual: Vec<Option<i32>> = sliced_typed_run_array.into_iter().collect();
+            let expected: Vec<Option<i32>> = input_array
+                .iter()
+                .skip(total_len - slice_len)
+                .copied()
+                .collect();
+            assert_eq!(expected, actual);
+        }
+    }
+}
diff --git a/arrow-array/src/scalar.rs b/arrow-array/src/scalar.rs
new file mode 100644
index 000000000000..f2a696a8f329
--- /dev/null
+++ b/arrow-array/src/scalar.rs
@@ -0,0 +1,146 @@
+// 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.
+
+use crate::Array;
+
+/// A possibly [`Scalar`] [`Array`]
+///
+/// This allows optimised binary kernels where one or more arguments are constant
+///
+/// ```
+/// # use arrow_array::*;
+/// # use arrow_buffer::{BooleanBuffer, MutableBuffer, NullBuffer};
+/// # use arrow_schema::ArrowError;
+/// #
+/// fn eq_impl<T: ArrowPrimitiveType>(
+///     a: &PrimitiveArray<T>,
+///     a_scalar: bool,
+///     b: &PrimitiveArray<T>,
+///     b_scalar: bool,
+/// ) -> BooleanArray {
+///     let (array, scalar) = match (a_scalar, b_scalar) {
+///         (true, true) | (false, false) => {
+///             let len = a.len().min(b.len());
+///             let nulls = NullBuffer::union(a.nulls(), b.nulls());
+///             let buffer = BooleanBuffer::collect_bool(len, |idx| a.value(idx) == b.value(idx));
+///             return BooleanArray::new(buffer, nulls);
+///         }
+///         (true, false) => (b, (a.null_count() == 0).then(|| a.value(0))),
+///         (false, true) => (a, (b.null_count() == 0).then(|| b.value(0))),
+///     };
+///     match scalar {
+///         Some(v) => {
+///             let len = array.len();
+///             let nulls = array.nulls().cloned();
+///             let buffer = BooleanBuffer::collect_bool(len, |idx| array.value(idx) == v);
+///             BooleanArray::new(buffer, nulls)
+///         }
+///         None => BooleanArray::new_null(array.len()),
+///     }
+/// }
+///
+/// pub fn eq(l: &dyn Datum, r: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+///     let (l_array, l_scalar) = l.get();
+///     let (r_array, r_scalar) = r.get();
+///     downcast_primitive_array!(
+///         (l_array, r_array) => Ok(eq_impl(l_array, l_scalar, r_array, r_scalar)),
+///         (a, b) => Err(ArrowError::NotYetImplemented(format!("{a} == {b}"))),
+///     )
+/// }
+///
+/// // Comparison of two arrays
+/// let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+/// let b = Int32Array::from(vec![1, 2, 4, 7, 3]);
+/// let r = eq(&a, &b).unwrap();
+/// let values: Vec<_> = r.values().iter().collect();
+/// assert_eq!(values, &[true, true, false, false, false]);
+///
+/// // Comparison of an array and a scalar
+/// let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+/// let b = Int32Array::new_scalar(1);
+/// let r = eq(&a, &b).unwrap();
+/// let values: Vec<_> = r.values().iter().collect();
+/// assert_eq!(values, &[true, false, false, false, false]);
+pub trait Datum {
+    /// Returns the value for this [`Datum`] and a boolean indicating if the value is scalar
+    fn get(&self) -> (&dyn Array, bool);
+}
+
+impl<T: Array> Datum for T {
+    fn get(&self) -> (&dyn Array, bool) {
+        (self, false)
+    }
+}
+
+impl Datum for dyn Array {
+    fn get(&self) -> (&dyn Array, bool) {
+        (self, false)
+    }
+}
+
+impl Datum for &dyn Array {
+    fn get(&self) -> (&dyn Array, bool) {
+        (*self, false)
+    }
+}
+
+/// A wrapper around a single value [`Array`] that implements
+/// [`Datum`] and indicates [compute] kernels should treat this array
+/// as a scalar value (a single value).
+///
+/// Using a [`Scalar`] is often much more efficient than creating an
+/// [`Array`] with the same (repeated) value.
+///
+/// See [`Datum`] for more information.
+///
+/// # Example
+///
+/// ```rust
+/// # use arrow_array::{Scalar, Int32Array, ArrayRef};
+/// # fn get_array() -> ArrayRef { std::sync::Arc::new(Int32Array::from(vec![42])) }
+/// // Create a (typed) scalar for Int32Array for the value 42
+/// let scalar = Scalar::new(Int32Array::from(vec![42]));
+///
+/// // Create a scalar using PrimtiveArray::scalar
+/// let scalar = Int32Array::new_scalar(42);
+///
+/// // create a scalar from an ArrayRef (for dynamic typed Arrays)
+/// let array: ArrayRef = get_array();
+/// let scalar = Scalar::new(array);
+/// ```
+///
+/// [compute]: https://docs.rs/arrow/latest/arrow/compute/index.html
+#[derive(Debug, Copy, Clone)]
+pub struct Scalar<T: Array>(T);
+
+impl<T: Array> Scalar<T> {
+    /// Create a new [`Scalar`] from an [`Array`]
+    ///
+    /// # Panics
+    ///
+    /// Panics if `array.len() != 1`
+    pub fn new(array: T) -> Self {
+        assert_eq!(array.len(), 1);
+        Self(array)
+    }
+}
+
+impl<T: Array> Datum for Scalar<T> {
+    fn get(&self) -> (&dyn Array, bool) {
+        (&self.0, true)
+    }
+}
diff --git a/arrow-array/src/temporal_conversions.rs b/arrow-array/src/temporal_conversions.rs
new file mode 100644
index 000000000000..e0edcc9bc182
--- /dev/null
+++ b/arrow-array/src/temporal_conversions.rs
@@ -0,0 +1,347 @@
+// 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.
+
+//! Conversion methods for dates and times.
+
+use crate::timezone::Tz;
+use crate::ArrowPrimitiveType;
+use arrow_schema::{DataType, TimeUnit};
+use chrono::{DateTime, Duration, NaiveDate, NaiveDateTime, NaiveTime, TimeZone, Timelike, Utc};
+
+/// Number of seconds in a day
+pub const SECONDS_IN_DAY: i64 = 86_400;
+/// Number of milliseconds in a second
+pub const MILLISECONDS: i64 = 1_000;
+/// Number of microseconds in a second
+pub const MICROSECONDS: i64 = 1_000_000;
+/// Number of nanoseconds in a second
+pub const NANOSECONDS: i64 = 1_000_000_000;
+
+/// Number of milliseconds in a day
+pub const MILLISECONDS_IN_DAY: i64 = SECONDS_IN_DAY * MILLISECONDS;
+/// Number of microseconds in a day
+pub const MICROSECONDS_IN_DAY: i64 = SECONDS_IN_DAY * MICROSECONDS;
+/// Number of nanoseconds in a day
+pub const NANOSECONDS_IN_DAY: i64 = SECONDS_IN_DAY * NANOSECONDS;
+/// Number of days between 0001-01-01 and 1970-01-01
+pub const EPOCH_DAYS_FROM_CE: i32 = 719_163;
+
+/// converts a `i32` representing a `date32` to [`NaiveDateTime`]
+#[inline]
+pub fn date32_to_datetime(v: i32) -> Option<NaiveDateTime> {
+    NaiveDateTime::from_timestamp_opt(v as i64 * SECONDS_IN_DAY, 0)
+}
+
+/// converts a `i64` representing a `date64` to [`NaiveDateTime`]
+#[inline]
+pub fn date64_to_datetime(v: i64) -> Option<NaiveDateTime> {
+    let (sec, milli_sec) = split_second(v, MILLISECONDS);
+
+    NaiveDateTime::from_timestamp_opt(
+        // extract seconds from milliseconds
+        sec,
+        // discard extracted seconds and convert milliseconds to nanoseconds
+        milli_sec * MICROSECONDS as u32,
+    )
+}
+
+/// converts a `i32` representing a `time32(s)` to [`NaiveDateTime`]
+#[inline]
+pub fn time32s_to_time(v: i32) -> Option<NaiveTime> {
+    NaiveTime::from_num_seconds_from_midnight_opt(v as u32, 0)
+}
+
+/// converts a `i32` representing a `time32(ms)` to [`NaiveDateTime`]
+#[inline]
+pub fn time32ms_to_time(v: i32) -> Option<NaiveTime> {
+    let v = v as i64;
+    NaiveTime::from_num_seconds_from_midnight_opt(
+        // extract seconds from milliseconds
+        (v / MILLISECONDS) as u32,
+        // discard extracted seconds and convert milliseconds to
+        // nanoseconds
+        (v % MILLISECONDS * MICROSECONDS) as u32,
+    )
+}
+
+/// converts a `i64` representing a `time64(us)` to [`NaiveDateTime`]
+#[inline]
+pub fn time64us_to_time(v: i64) -> Option<NaiveTime> {
+    NaiveTime::from_num_seconds_from_midnight_opt(
+        // extract seconds from microseconds
+        (v / MICROSECONDS) as u32,
+        // discard extracted seconds and convert microseconds to
+        // nanoseconds
+        (v % MICROSECONDS * MILLISECONDS) as u32,
+    )
+}
+
+/// converts a `i64` representing a `time64(ns)` to [`NaiveDateTime`]
+#[inline]
+pub fn time64ns_to_time(v: i64) -> Option<NaiveTime> {
+    NaiveTime::from_num_seconds_from_midnight_opt(
+        // extract seconds from nanoseconds
+        (v / NANOSECONDS) as u32,
+        // discard extracted seconds
+        (v % NANOSECONDS) as u32,
+    )
+}
+
+/// converts [`NaiveTime`] to a `i32` representing a `time32(s)`
+#[inline]
+pub fn time_to_time32s(v: NaiveTime) -> i32 {
+    v.num_seconds_from_midnight() as i32
+}
+
+/// converts [`NaiveTime`] to a `i32` representing a `time32(ms)`
+#[inline]
+pub fn time_to_time32ms(v: NaiveTime) -> i32 {
+    (v.num_seconds_from_midnight() as i64 * MILLISECONDS
+        + v.nanosecond() as i64 * MILLISECONDS / NANOSECONDS) as i32
+}
+
+/// converts [`NaiveTime`] to a `i64` representing a `time64(us)`
+#[inline]
+pub fn time_to_time64us(v: NaiveTime) -> i64 {
+    v.num_seconds_from_midnight() as i64 * MICROSECONDS
+        + v.nanosecond() as i64 * MICROSECONDS / NANOSECONDS
+}
+
+/// converts [`NaiveTime`] to a `i64` representing a `time64(ns)`
+#[inline]
+pub fn time_to_time64ns(v: NaiveTime) -> i64 {
+    v.num_seconds_from_midnight() as i64 * NANOSECONDS + v.nanosecond() as i64
+}
+
+/// converts a `i64` representing a `timestamp(s)` to [`NaiveDateTime`]
+#[inline]
+pub fn timestamp_s_to_datetime(v: i64) -> Option<NaiveDateTime> {
+    NaiveDateTime::from_timestamp_opt(v, 0)
+}
+
+/// converts a `i64` representing a `timestamp(ms)` to [`NaiveDateTime`]
+#[inline]
+pub fn timestamp_ms_to_datetime(v: i64) -> Option<NaiveDateTime> {
+    let (sec, milli_sec) = split_second(v, MILLISECONDS);
+
+    NaiveDateTime::from_timestamp_opt(
+        // extract seconds from milliseconds
+        sec,
+        // discard extracted seconds and convert milliseconds to nanoseconds
+        milli_sec * MICROSECONDS as u32,
+    )
+}
+
+/// converts a `i64` representing a `timestamp(us)` to [`NaiveDateTime`]
+#[inline]
+pub fn timestamp_us_to_datetime(v: i64) -> Option<NaiveDateTime> {
+    let (sec, micro_sec) = split_second(v, MICROSECONDS);
+
+    NaiveDateTime::from_timestamp_opt(
+        // extract seconds from microseconds
+        sec,
+        // discard extracted seconds and convert microseconds to nanoseconds
+        micro_sec * MILLISECONDS as u32,
+    )
+}
+
+/// converts a `i64` representing a `timestamp(ns)` to [`NaiveDateTime`]
+#[inline]
+pub fn timestamp_ns_to_datetime(v: i64) -> Option<NaiveDateTime> {
+    let (sec, nano_sec) = split_second(v, NANOSECONDS);
+
+    NaiveDateTime::from_timestamp_opt(
+        // extract seconds from nanoseconds
+        sec, // discard extracted seconds
+        nano_sec,
+    )
+}
+
+#[inline]
+pub(crate) fn split_second(v: i64, base: i64) -> (i64, u32) {
+    (v.div_euclid(base), v.rem_euclid(base) as u32)
+}
+
+/// converts a `i64` representing a `duration(s)` to [`Duration`]
+#[inline]
+pub fn duration_s_to_duration(v: i64) -> Duration {
+    Duration::seconds(v)
+}
+
+/// converts a `i64` representing a `duration(ms)` to [`Duration`]
+#[inline]
+pub fn duration_ms_to_duration(v: i64) -> Duration {
+    Duration::milliseconds(v)
+}
+
+/// converts a `i64` representing a `duration(us)` to [`Duration`]
+#[inline]
+pub fn duration_us_to_duration(v: i64) -> Duration {
+    Duration::microseconds(v)
+}
+
+/// converts a `i64` representing a `duration(ns)` to [`Duration`]
+#[inline]
+pub fn duration_ns_to_duration(v: i64) -> Duration {
+    Duration::nanoseconds(v)
+}
+
+/// Converts an [`ArrowPrimitiveType`] to [`NaiveDateTime`]
+pub fn as_datetime<T: ArrowPrimitiveType>(v: i64) -> Option<NaiveDateTime> {
+    match T::DATA_TYPE {
+        DataType::Date32 => date32_to_datetime(v as i32),
+        DataType::Date64 => date64_to_datetime(v),
+        DataType::Time32(_) | DataType::Time64(_) => None,
+        DataType::Timestamp(unit, _) => match unit {
+            TimeUnit::Second => timestamp_s_to_datetime(v),
+            TimeUnit::Millisecond => timestamp_ms_to_datetime(v),
+            TimeUnit::Microsecond => timestamp_us_to_datetime(v),
+            TimeUnit::Nanosecond => timestamp_ns_to_datetime(v),
+        },
+        // interval is not yet fully documented [ARROW-3097]
+        DataType::Interval(_) => None,
+        _ => None,
+    }
+}
+
+/// Converts an [`ArrowPrimitiveType`] to [`DateTime<Tz>`]
+pub fn as_datetime_with_timezone<T: ArrowPrimitiveType>(v: i64, tz: Tz) -> Option<DateTime<Tz>> {
+    let naive = as_datetime::<T>(v)?;
+    Some(Utc.from_utc_datetime(&naive).with_timezone(&tz))
+}
+
+/// Converts an [`ArrowPrimitiveType`] to [`NaiveDate`]
+pub fn as_date<T: ArrowPrimitiveType>(v: i64) -> Option<NaiveDate> {
+    as_datetime::<T>(v).map(|datetime| datetime.date())
+}
+
+/// Converts an [`ArrowPrimitiveType`] to [`NaiveTime`]
+pub fn as_time<T: ArrowPrimitiveType>(v: i64) -> Option<NaiveTime> {
+    match T::DATA_TYPE {
+        DataType::Time32(unit) => {
+            // safe to immediately cast to u32 as `self.value(i)` is positive i32
+            let v = v as u32;
+            match unit {
+                TimeUnit::Second => time32s_to_time(v as i32),
+                TimeUnit::Millisecond => time32ms_to_time(v as i32),
+                _ => None,
+            }
+        }
+        DataType::Time64(unit) => match unit {
+            TimeUnit::Microsecond => time64us_to_time(v),
+            TimeUnit::Nanosecond => time64ns_to_time(v),
+            _ => None,
+        },
+        DataType::Timestamp(_, _) => as_datetime::<T>(v).map(|datetime| datetime.time()),
+        DataType::Date32 | DataType::Date64 => NaiveTime::from_hms_opt(0, 0, 0),
+        DataType::Interval(_) => None,
+        _ => None,
+    }
+}
+
+/// Converts an [`ArrowPrimitiveType`] to [`Duration`]
+pub fn as_duration<T: ArrowPrimitiveType>(v: i64) -> Option<Duration> {
+    match T::DATA_TYPE {
+        DataType::Duration(unit) => match unit {
+            TimeUnit::Second => Some(duration_s_to_duration(v)),
+            TimeUnit::Millisecond => Some(duration_ms_to_duration(v)),
+            TimeUnit::Microsecond => Some(duration_us_to_duration(v)),
+            TimeUnit::Nanosecond => Some(duration_ns_to_duration(v)),
+        },
+        _ => None,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::temporal_conversions::{
+        date64_to_datetime, split_second, timestamp_ms_to_datetime, timestamp_ns_to_datetime,
+        timestamp_us_to_datetime, NANOSECONDS,
+    };
+    use chrono::NaiveDateTime;
+
+    #[test]
+    fn negative_input_timestamp_ns_to_datetime() {
+        assert_eq!(
+            timestamp_ns_to_datetime(-1),
+            NaiveDateTime::from_timestamp_opt(-1, 999_999_999)
+        );
+
+        assert_eq!(
+            timestamp_ns_to_datetime(-1_000_000_001),
+            NaiveDateTime::from_timestamp_opt(-2, 999_999_999)
+        );
+    }
+
+    #[test]
+    fn negative_input_timestamp_us_to_datetime() {
+        assert_eq!(
+            timestamp_us_to_datetime(-1),
+            NaiveDateTime::from_timestamp_opt(-1, 999_999_000)
+        );
+
+        assert_eq!(
+            timestamp_us_to_datetime(-1_000_001),
+            NaiveDateTime::from_timestamp_opt(-2, 999_999_000)
+        );
+    }
+
+    #[test]
+    fn negative_input_timestamp_ms_to_datetime() {
+        assert_eq!(
+            timestamp_ms_to_datetime(-1),
+            NaiveDateTime::from_timestamp_opt(-1, 999_000_000)
+        );
+
+        assert_eq!(
+            timestamp_ms_to_datetime(-1_001),
+            NaiveDateTime::from_timestamp_opt(-2, 999_000_000)
+        );
+    }
+
+    #[test]
+    fn negative_input_date64_to_datetime() {
+        assert_eq!(
+            date64_to_datetime(-1),
+            NaiveDateTime::from_timestamp_opt(-1, 999_000_000)
+        );
+
+        assert_eq!(
+            date64_to_datetime(-1_001),
+            NaiveDateTime::from_timestamp_opt(-2, 999_000_000)
+        );
+    }
+
+    #[test]
+    fn test_split_seconds() {
+        let (sec, nano_sec) = split_second(100, NANOSECONDS);
+        assert_eq!(sec, 0);
+        assert_eq!(nano_sec, 100);
+
+        let (sec, nano_sec) = split_second(123_000_000_456, NANOSECONDS);
+        assert_eq!(sec, 123);
+        assert_eq!(nano_sec, 456);
+
+        let (sec, nano_sec) = split_second(-1, NANOSECONDS);
+        assert_eq!(sec, -1);
+        assert_eq!(nano_sec, 999_999_999);
+
+        let (sec, nano_sec) = split_second(-123_000_000_001, NANOSECONDS);
+        assert_eq!(sec, -124);
+        assert_eq!(nano_sec, 999_999_999);
+    }
+}
diff --git a/arrow-array/src/timezone.rs b/arrow-array/src/timezone.rs
new file mode 100644
index 000000000000..dc91886f34c5
--- /dev/null
+++ b/arrow-array/src/timezone.rs
@@ -0,0 +1,339 @@
+// 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.
+
+//! Timezone for timestamp arrays
+
+use arrow_schema::ArrowError;
+use chrono::FixedOffset;
+pub use private::{Tz, TzOffset};
+
+/// Parses a fixed offset of the form "+09:00", "-09" or "+0930"
+fn parse_fixed_offset(tz: &str) -> Option<FixedOffset> {
+    let bytes = tz.as_bytes();
+
+    let mut values = match bytes.len() {
+        // [+-]XX:XX
+        6 if bytes[3] == b':' => [bytes[1], bytes[2], bytes[4], bytes[5]],
+        // [+-]XXXX
+        5 => [bytes[1], bytes[2], bytes[3], bytes[4]],
+        // [+-]XX
+        3 => [bytes[1], bytes[2], b'0', b'0'],
+        _ => return None,
+    };
+    values.iter_mut().for_each(|x| *x = x.wrapping_sub(b'0'));
+    if values.iter().any(|x| *x > 9) {
+        return None;
+    }
+    let secs =
+        (values[0] * 10 + values[1]) as i32 * 60 * 60 + (values[2] * 10 + values[3]) as i32 * 60;
+
+    match bytes[0] {
+        b'+' => FixedOffset::east_opt(secs),
+        b'-' => FixedOffset::west_opt(secs),
+        _ => None,
+    }
+}
+
+#[cfg(feature = "chrono-tz")]
+mod private {
+    use super::*;
+    use chrono::offset::TimeZone;
+    use chrono::{LocalResult, NaiveDate, NaiveDateTime, Offset};
+    use std::str::FromStr;
+
+    /// An [`Offset`] for [`Tz`]
+    #[derive(Debug, Copy, Clone)]
+    pub struct TzOffset {
+        tz: Tz,
+        offset: FixedOffset,
+    }
+
+    impl std::fmt::Display for TzOffset {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.offset.fmt(f)
+        }
+    }
+
+    impl Offset for TzOffset {
+        fn fix(&self) -> FixedOffset {
+            self.offset
+        }
+    }
+
+    /// An Arrow [`TimeZone`]
+    #[derive(Debug, Copy, Clone)]
+    pub struct Tz(TzInner);
+
+    #[derive(Debug, Copy, Clone)]
+    enum TzInner {
+        Timezone(chrono_tz::Tz),
+        Offset(FixedOffset),
+    }
+
+    impl FromStr for Tz {
+        type Err = ArrowError;
+
+        fn from_str(tz: &str) -> Result<Self, Self::Err> {
+            match parse_fixed_offset(tz) {
+                Some(offset) => Ok(Self(TzInner::Offset(offset))),
+                None => Ok(Self(TzInner::Timezone(tz.parse().map_err(|e| {
+                    ArrowError::ParseError(format!("Invalid timezone \"{tz}\": {e}"))
+                })?))),
+            }
+        }
+    }
+
+    macro_rules! tz {
+        ($s:ident, $tz:ident, $b:block) => {
+            match $s.0 {
+                TzInner::Timezone($tz) => $b,
+                TzInner::Offset($tz) => $b,
+            }
+        };
+    }
+
+    impl TimeZone for Tz {
+        type Offset = TzOffset;
+
+        fn from_offset(offset: &Self::Offset) -> Self {
+            offset.tz
+        }
+
+        fn offset_from_local_date(&self, local: &NaiveDate) -> LocalResult<Self::Offset> {
+            tz!(self, tz, {
+                tz.offset_from_local_date(local).map(|x| TzOffset {
+                    tz: *self,
+                    offset: x.fix(),
+                })
+            })
+        }
+
+        fn offset_from_local_datetime(&self, local: &NaiveDateTime) -> LocalResult<Self::Offset> {
+            tz!(self, tz, {
+                tz.offset_from_local_datetime(local).map(|x| TzOffset {
+                    tz: *self,
+                    offset: x.fix(),
+                })
+            })
+        }
+
+        fn offset_from_utc_date(&self, utc: &NaiveDate) -> Self::Offset {
+            tz!(self, tz, {
+                TzOffset {
+                    tz: *self,
+                    offset: tz.offset_from_utc_date(utc).fix(),
+                }
+            })
+        }
+
+        fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> Self::Offset {
+            tz!(self, tz, {
+                TzOffset {
+                    tz: *self,
+                    offset: tz.offset_from_utc_datetime(utc).fix(),
+                }
+            })
+        }
+    }
+
+    #[cfg(test)]
+    mod tests {
+        use super::*;
+        use chrono::{Timelike, Utc};
+
+        #[test]
+        fn test_with_timezone() {
+            let vals = [
+                Utc.timestamp_millis_opt(37800000).unwrap(),
+                Utc.timestamp_millis_opt(86339000).unwrap(),
+            ];
+
+            assert_eq!(10, vals[0].hour());
+            assert_eq!(23, vals[1].hour());
+
+            let tz: Tz = "America/Los_Angeles".parse().unwrap();
+
+            assert_eq!(2, vals[0].with_timezone(&tz).hour());
+            assert_eq!(15, vals[1].with_timezone(&tz).hour());
+        }
+
+        #[test]
+        fn test_using_chrono_tz_and_utc_naive_date_time() {
+            let sydney_tz = "Australia/Sydney".to_string();
+            let tz: Tz = sydney_tz.parse().unwrap();
+            let sydney_offset_without_dst = FixedOffset::east_opt(10 * 60 * 60).unwrap();
+            let sydney_offset_with_dst = FixedOffset::east_opt(11 * 60 * 60).unwrap();
+            // Daylight savings ends
+            // When local daylight time was about to reach
+            // Sunday, 4 April 2021, 3:00:00 am clocks were turned backward 1 hour to
+            // Sunday, 4 April 2021, 2:00:00 am local standard time instead.
+
+            // Daylight savings starts
+            // When local standard time was about to reach
+            // Sunday, 3 October 2021, 2:00:00 am clocks were turned forward 1 hour to
+            // Sunday, 3 October 2021, 3:00:00 am local daylight time instead.
+
+            // Sydney 2021-04-04T02:30:00+11:00 is 2021-04-03T15:30:00Z
+            let utc_just_before_sydney_dst_ends = NaiveDate::from_ymd_opt(2021, 4, 3)
+                .unwrap()
+                .and_hms_nano_opt(15, 30, 0, 0)
+                .unwrap();
+            assert_eq!(
+                tz.offset_from_utc_datetime(&utc_just_before_sydney_dst_ends)
+                    .fix(),
+                sydney_offset_with_dst
+            );
+            // Sydney 2021-04-04T02:30:00+10:00 is 2021-04-03T16:30:00Z
+            let utc_just_after_sydney_dst_ends = NaiveDate::from_ymd_opt(2021, 4, 3)
+                .unwrap()
+                .and_hms_nano_opt(16, 30, 0, 0)
+                .unwrap();
+            assert_eq!(
+                tz.offset_from_utc_datetime(&utc_just_after_sydney_dst_ends)
+                    .fix(),
+                sydney_offset_without_dst
+            );
+            // Sydney 2021-10-03T01:30:00+10:00 is 2021-10-02T15:30:00Z
+            let utc_just_before_sydney_dst_starts = NaiveDate::from_ymd_opt(2021, 10, 2)
+                .unwrap()
+                .and_hms_nano_opt(15, 30, 0, 0)
+                .unwrap();
+            assert_eq!(
+                tz.offset_from_utc_datetime(&utc_just_before_sydney_dst_starts)
+                    .fix(),
+                sydney_offset_without_dst
+            );
+            // Sydney 2021-04-04T03:30:00+11:00 is 2021-10-02T16:30:00Z
+            let utc_just_after_sydney_dst_starts = NaiveDate::from_ymd_opt(2022, 10, 2)
+                .unwrap()
+                .and_hms_nano_opt(16, 30, 0, 0)
+                .unwrap();
+            assert_eq!(
+                tz.offset_from_utc_datetime(&utc_just_after_sydney_dst_starts)
+                    .fix(),
+                sydney_offset_with_dst
+            );
+        }
+    }
+}
+
+#[cfg(not(feature = "chrono-tz"))]
+mod private {
+    use super::*;
+    use chrono::offset::TimeZone;
+    use chrono::{FixedOffset, LocalResult, NaiveDate, NaiveDateTime, Offset};
+    use std::str::FromStr;
+
+    /// An [`Offset`] for [`Tz`]
+    #[derive(Debug, Copy, Clone)]
+    pub struct TzOffset(FixedOffset);
+
+    impl std::fmt::Display for TzOffset {
+        fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+            self.0.fmt(f)
+        }
+    }
+
+    impl Offset for TzOffset {
+        fn fix(&self) -> FixedOffset {
+            self.0
+        }
+    }
+
+    /// An Arrow [`TimeZone`]
+    #[derive(Debug, Copy, Clone)]
+    pub struct Tz(FixedOffset);
+
+    impl FromStr for Tz {
+        type Err = ArrowError;
+
+        fn from_str(tz: &str) -> Result<Self, Self::Err> {
+            let offset = parse_fixed_offset(tz).ok_or_else(|| {
+                ArrowError::ParseError(format!(
+                    "Invalid timezone \"{tz}\": only offset based timezones supported without chrono-tz feature"
+                ))
+            })?;
+            Ok(Self(offset))
+        }
+    }
+
+    impl TimeZone for Tz {
+        type Offset = TzOffset;
+
+        fn from_offset(offset: &Self::Offset) -> Self {
+            Self(offset.0)
+        }
+
+        fn offset_from_local_date(&self, local: &NaiveDate) -> LocalResult<Self::Offset> {
+            self.0.offset_from_local_date(local).map(TzOffset)
+        }
+
+        fn offset_from_local_datetime(&self, local: &NaiveDateTime) -> LocalResult<Self::Offset> {
+            self.0.offset_from_local_datetime(local).map(TzOffset)
+        }
+
+        fn offset_from_utc_date(&self, utc: &NaiveDate) -> Self::Offset {
+            TzOffset(self.0.offset_from_utc_date(utc).fix())
+        }
+
+        fn offset_from_utc_datetime(&self, utc: &NaiveDateTime) -> Self::Offset {
+            TzOffset(self.0.offset_from_utc_datetime(utc).fix())
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use chrono::{NaiveDate, Offset, TimeZone};
+
+    #[test]
+    fn test_with_offset() {
+        let t = NaiveDate::from_ymd_opt(2000, 1, 1).unwrap();
+
+        let tz: Tz = "-00:00".parse().unwrap();
+        assert_eq!(tz.offset_from_utc_date(&t).fix().local_minus_utc(), 0);
+        let tz: Tz = "+00:00".parse().unwrap();
+        assert_eq!(tz.offset_from_utc_date(&t).fix().local_minus_utc(), 0);
+
+        let tz: Tz = "-10:00".parse().unwrap();
+        assert_eq!(
+            tz.offset_from_utc_date(&t).fix().local_minus_utc(),
+            -10 * 60 * 60
+        );
+        let tz: Tz = "+09:00".parse().unwrap();
+        assert_eq!(
+            tz.offset_from_utc_date(&t).fix().local_minus_utc(),
+            9 * 60 * 60
+        );
+
+        let tz = "+09".parse::<Tz>().unwrap();
+        assert_eq!(
+            tz.offset_from_utc_date(&t).fix().local_minus_utc(),
+            9 * 60 * 60
+        );
+
+        let tz = "+0900".parse::<Tz>().unwrap();
+        assert_eq!(
+            tz.offset_from_utc_date(&t).fix().local_minus_utc(),
+            9 * 60 * 60
+        );
+
+        let err = "+9:00".parse::<Tz>().unwrap_err().to_string();
+        assert!(err.contains("Invalid timezone"), "{}", err);
+    }
+}
diff --git a/arrow/src/util/trusted_len.rs b/arrow-array/src/trusted_len.rs
similarity index 94%
rename from arrow/src/util/trusted_len.rs
rename to arrow-array/src/trusted_len.rs
index 84a66238b634..781cad38f7e9 100644
--- a/arrow/src/util/trusted_len.rs
+++ b/arrow-array/src/trusted_len.rs
@@ -15,11 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use super::bit_util;
-use crate::{
-    buffer::{Buffer, MutableBuffer},
-    datatypes::ArrowNativeType,
-};
+use arrow_buffer::{bit_util, ArrowNativeType, Buffer, MutableBuffer};
 
 /// Creates two [`Buffer`]s from an iterator of `Option`.
 /// The first buffer corresponds to a bitmap buffer, the second one
@@ -67,7 +63,7 @@ mod tests {
 
     #[test]
     fn trusted_len_unzip_good() {
-        let vec = vec![Some(1u32), None];
+        let vec = [Some(1u32), None];
         let (null, buffer) = unsafe { trusted_len_unzip(vec.iter()) };
         assert_eq!(null.as_slice(), &[0b00000001]);
         assert_eq!(buffer.as_slice(), &[1u8, 0, 0, 0, 0, 0, 0, 0]);
diff --git a/arrow-array/src/types.rs b/arrow-array/src/types.rs
new file mode 100644
index 000000000000..6e177838c4f5
--- /dev/null
+++ b/arrow-array/src/types.rs
@@ -0,0 +1,1634 @@
+// 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.
+
+//! Zero-sized types used to parameterize generic array implementations
+
+use crate::delta::{
+    add_days_datetime, add_months_datetime, shift_months, sub_days_datetime, sub_months_datetime,
+};
+use crate::temporal_conversions::as_datetime_with_timezone;
+use crate::timezone::Tz;
+use crate::{ArrowNativeTypeOp, OffsetSizeTrait};
+use arrow_buffer::{i256, Buffer, OffsetBuffer};
+use arrow_data::decimal::{validate_decimal256_precision, validate_decimal_precision};
+use arrow_schema::{
+    ArrowError, DataType, IntervalUnit, TimeUnit, DECIMAL128_MAX_PRECISION, DECIMAL128_MAX_SCALE,
+    DECIMAL256_MAX_PRECISION, DECIMAL256_MAX_SCALE, DECIMAL_DEFAULT_SCALE,
+};
+use chrono::{Duration, NaiveDate, NaiveDateTime};
+use half::f16;
+use std::marker::PhantomData;
+use std::ops::{Add, Sub};
+
+// BooleanType is special: its bit-width is not the size of the primitive type, and its `index`
+// operation assumes bit-packing.
+/// A boolean datatype
+#[derive(Debug)]
+pub struct BooleanType {}
+
+impl BooleanType {
+    /// The corresponding Arrow data type
+    pub const DATA_TYPE: DataType = DataType::Boolean;
+}
+
+/// Trait bridging the dynamic-typed nature of Arrow (via [`DataType`]) with the
+/// static-typed nature of rust types ([`ArrowNativeType`]) for all types that implement [`ArrowNativeType`].
+///
+/// [`ArrowNativeType`]: arrow_buffer::ArrowNativeType
+pub trait ArrowPrimitiveType: primitive::PrimitiveTypeSealed + 'static {
+    /// Corresponding Rust native type for the primitive type.
+    type Native: ArrowNativeTypeOp;
+
+    /// the corresponding Arrow data type of this primitive type.
+    const DATA_TYPE: DataType;
+
+    /// Returns the byte width of this primitive type.
+    fn get_byte_width() -> usize {
+        std::mem::size_of::<Self::Native>()
+    }
+
+    /// Returns a default value of this primitive type.
+    ///
+    /// This is useful for aggregate array ops like `sum()`, `mean()`.
+    fn default_value() -> Self::Native {
+        Default::default()
+    }
+}
+
+mod primitive {
+    pub trait PrimitiveTypeSealed {}
+}
+
+macro_rules! make_type {
+    ($name:ident, $native_ty:ty, $data_ty:expr, $doc_string: literal) => {
+        #[derive(Debug)]
+        #[doc = $doc_string]
+        pub struct $name {}
+
+        impl ArrowPrimitiveType for $name {
+            type Native = $native_ty;
+            const DATA_TYPE: DataType = $data_ty;
+        }
+
+        impl primitive::PrimitiveTypeSealed for $name {}
+    };
+}
+
+make_type!(Int8Type, i8, DataType::Int8, "A signed 8-bit integer type.");
+make_type!(
+    Int16Type,
+    i16,
+    DataType::Int16,
+    "A signed 16-bit integer type."
+);
+make_type!(
+    Int32Type,
+    i32,
+    DataType::Int32,
+    "A signed 32-bit integer type."
+);
+make_type!(
+    Int64Type,
+    i64,
+    DataType::Int64,
+    "A signed 64-bit integer type."
+);
+make_type!(
+    UInt8Type,
+    u8,
+    DataType::UInt8,
+    "An unsigned 8-bit integer type."
+);
+make_type!(
+    UInt16Type,
+    u16,
+    DataType::UInt16,
+    "An unsigned 16-bit integer type."
+);
+make_type!(
+    UInt32Type,
+    u32,
+    DataType::UInt32,
+    "An unsigned 32-bit integer type."
+);
+make_type!(
+    UInt64Type,
+    u64,
+    DataType::UInt64,
+    "An unsigned 64-bit integer type."
+);
+make_type!(
+    Float16Type,
+    f16,
+    DataType::Float16,
+    "A 16-bit floating point number type."
+);
+make_type!(
+    Float32Type,
+    f32,
+    DataType::Float32,
+    "A 32-bit floating point number type."
+);
+make_type!(
+    Float64Type,
+    f64,
+    DataType::Float64,
+    "A 64-bit floating point number type."
+);
+make_type!(
+    TimestampSecondType,
+    i64,
+    DataType::Timestamp(TimeUnit::Second, None),
+    "A timestamp second type with an optional timezone."
+);
+make_type!(
+    TimestampMillisecondType,
+    i64,
+    DataType::Timestamp(TimeUnit::Millisecond, None),
+    "A timestamp millisecond type with an optional timezone."
+);
+make_type!(
+    TimestampMicrosecondType,
+    i64,
+    DataType::Timestamp(TimeUnit::Microsecond, None),
+    "A timestamp microsecond type with an optional timezone."
+);
+make_type!(
+    TimestampNanosecondType,
+    i64,
+    DataType::Timestamp(TimeUnit::Nanosecond, None),
+    "A timestamp nanosecond type with an optional timezone."
+);
+make_type!(
+    Date32Type,
+    i32,
+    DataType::Date32,
+    "A 32-bit date type representing the elapsed time since UNIX epoch in days(32 bits)."
+);
+make_type!(
+    Date64Type,
+    i64,
+    DataType::Date64,
+    "A 64-bit date type representing the elapsed time since UNIX epoch in milliseconds(64 bits)."
+);
+make_type!(
+    Time32SecondType,
+    i32,
+    DataType::Time32(TimeUnit::Second),
+    "A 32-bit time type representing the elapsed time since midnight in seconds."
+);
+make_type!(
+    Time32MillisecondType,
+    i32,
+    DataType::Time32(TimeUnit::Millisecond),
+    "A 32-bit time type representing the elapsed time since midnight in milliseconds."
+);
+make_type!(
+    Time64MicrosecondType,
+    i64,
+    DataType::Time64(TimeUnit::Microsecond),
+    "A 64-bit time type representing the elapsed time since midnight in microseconds."
+);
+make_type!(
+    Time64NanosecondType,
+    i64,
+    DataType::Time64(TimeUnit::Nanosecond),
+    "A 64-bit time type representing the elapsed time since midnight in nanoseconds."
+);
+make_type!(
+    IntervalYearMonthType,
+    i32,
+    DataType::Interval(IntervalUnit::YearMonth),
+    "A “calendar” interval stored as the number of whole months."
+);
+make_type!(
+    IntervalDayTimeType,
+    i64,
+    DataType::Interval(IntervalUnit::DayTime),
+    r#"A “calendar” interval type in days and milliseconds.
+
+## Representation
+This type is stored as a single 64 bit integer, interpreted as two i32 fields:
+1. the number of elapsed days
+2. The number of milliseconds (no leap seconds),
+
+```text
+ ┌──────────────┬──────────────┐
+ │     Days     │ Milliseconds │
+ │  (32 bits)   │  (32 bits)   │
+ └──────────────┴──────────────┘
+ 0              31            63 bit offset
+```
+Please see the [Arrow Spec](https://github.com/apache/arrow/blob/081b4022fe6f659d8765efc82b3f4787c5039e3c/format/Schema.fbs#L406-L408) for more details
+
+## Note on Comparing and Ordering for Calendar Types
+
+Values of `IntervalDayTimeType` are compared using their binary representation,
+which can lead to surprising results. Please see the description of ordering on
+[`IntervalMonthDayNanoType`] for more details
+"#
+);
+make_type!(
+    IntervalMonthDayNanoType,
+    i128,
+    DataType::Interval(IntervalUnit::MonthDayNano),
+    r#"A “calendar” interval type in months, days, and nanoseconds.
+
+## Representation
+This type is stored as a single 128 bit integer,
+interpreted as three different signed integral fields:
+
+1. The number of months (32 bits)
+2. The number days (32 bits)
+2. The number of nanoseconds (64 bits).
+
+Nanoseconds does not allow for leap seconds.
+Each field is independent (e.g. there is no constraint that the quantity of
+nanoseconds represents less than a day's worth of time).
+
+```text
+┌──────────────────────────────┬─────────────┬──────────────┐
+│            Nanos             │    Days     │    Months    │
+│          (64 bits)           │ (32 bits)   │  (32 bits)   │
+└──────────────────────────────┴─────────────┴──────────────┘
+  0                            63            95           127 bit offset
+```
+Please see the [Arrow Spec](https://github.com/apache/arrow/blob/081b4022fe6f659d8765efc82b3f4787c5039e3c/format/Schema.fbs#L409-L415) for more details
+
+## Note on Comparing and Ordering for Calendar Types
+Values of `IntervalMonthDayNanoType` are compared using their binary representation,
+which can lead to surprising results.
+
+Spans of time measured in calendar units are not fixed in absolute size (e.g.
+number of seconds) which makes defining comparisons and ordering non trivial.
+For example `1 month` is 28 days for February but `1 month` is 31 days
+in December.
+
+This makes the seemingly simple operation of comparing two intervals
+complicated in practice. For example is `1 month` more or less than `30 days`? The
+answer depends on what month you are talking about.
+
+This crate defines comparisons for calendar types using their binary
+representation which is fast and efficient, but leads
+to potentially surprising results.
+
+For example a
+`IntervalMonthDayNano` of `1 month` will compare as **greater** than a
+`IntervalMonthDayNano` of `100 days` because the binary representation of `1 month`
+is larger than the binary representation of 100 days.
+"#
+);
+make_type!(
+    DurationSecondType,
+    i64,
+    DataType::Duration(TimeUnit::Second),
+    "An elapsed time type in seconds."
+);
+make_type!(
+    DurationMillisecondType,
+    i64,
+    DataType::Duration(TimeUnit::Millisecond),
+    "An elapsed time type in milliseconds."
+);
+make_type!(
+    DurationMicrosecondType,
+    i64,
+    DataType::Duration(TimeUnit::Microsecond),
+    "An elapsed time type in microseconds."
+);
+make_type!(
+    DurationNanosecondType,
+    i64,
+    DataType::Duration(TimeUnit::Nanosecond),
+    "An elapsed time type in nanoseconds."
+);
+
+/// A subtype of primitive type that represents legal dictionary keys.
+/// See <https://arrow.apache.org/docs/format/Columnar.html>
+pub trait ArrowDictionaryKeyType: ArrowPrimitiveType {}
+
+impl ArrowDictionaryKeyType for Int8Type {}
+
+impl ArrowDictionaryKeyType for Int16Type {}
+
+impl ArrowDictionaryKeyType for Int32Type {}
+
+impl ArrowDictionaryKeyType for Int64Type {}
+
+impl ArrowDictionaryKeyType for UInt8Type {}
+
+impl ArrowDictionaryKeyType for UInt16Type {}
+
+impl ArrowDictionaryKeyType for UInt32Type {}
+
+impl ArrowDictionaryKeyType for UInt64Type {}
+
+/// A subtype of primitive type that is used as run-ends index
+/// in `RunArray`.
+/// See <https://arrow.apache.org/docs/format/Columnar.html>
+pub trait RunEndIndexType: ArrowPrimitiveType {}
+
+impl RunEndIndexType for Int16Type {}
+
+impl RunEndIndexType for Int32Type {}
+
+impl RunEndIndexType for Int64Type {}
+
+/// A subtype of primitive type that represents temporal values.
+pub trait ArrowTemporalType: ArrowPrimitiveType {}
+
+impl ArrowTemporalType for TimestampSecondType {}
+impl ArrowTemporalType for TimestampMillisecondType {}
+impl ArrowTemporalType for TimestampMicrosecondType {}
+impl ArrowTemporalType for TimestampNanosecondType {}
+impl ArrowTemporalType for Date32Type {}
+impl ArrowTemporalType for Date64Type {}
+impl ArrowTemporalType for Time32SecondType {}
+impl ArrowTemporalType for Time32MillisecondType {}
+impl ArrowTemporalType for Time64MicrosecondType {}
+impl ArrowTemporalType for Time64NanosecondType {}
+// impl ArrowTemporalType for IntervalYearMonthType {}
+// impl ArrowTemporalType for IntervalDayTimeType {}
+// impl ArrowTemporalType for IntervalMonthDayNanoType {}
+impl ArrowTemporalType for DurationSecondType {}
+impl ArrowTemporalType for DurationMillisecondType {}
+impl ArrowTemporalType for DurationMicrosecondType {}
+impl ArrowTemporalType for DurationNanosecondType {}
+
+/// A timestamp type allows us to create array builders that take a timestamp.
+pub trait ArrowTimestampType: ArrowTemporalType<Native = i64> {
+    /// The [`TimeUnit`] of this timestamp.
+    const UNIT: TimeUnit;
+
+    /// Returns the `TimeUnit` of this timestamp.
+    #[deprecated(note = "Use Self::UNIT")]
+    fn get_time_unit() -> TimeUnit {
+        Self::UNIT
+    }
+
+    /// Creates a ArrowTimestampType::Native from the provided [`NaiveDateTime`]
+    ///
+    /// See [`DataType::Timestamp`] for more information on timezone handling
+    fn make_value(naive: NaiveDateTime) -> Option<i64>;
+}
+
+impl ArrowTimestampType for TimestampSecondType {
+    const UNIT: TimeUnit = TimeUnit::Second;
+
+    fn make_value(naive: NaiveDateTime) -> Option<i64> {
+        Some(naive.timestamp())
+    }
+}
+impl ArrowTimestampType for TimestampMillisecondType {
+    const UNIT: TimeUnit = TimeUnit::Millisecond;
+
+    fn make_value(naive: NaiveDateTime) -> Option<i64> {
+        let millis = naive.timestamp().checked_mul(1_000)?;
+        millis.checked_add(naive.timestamp_subsec_millis() as i64)
+    }
+}
+impl ArrowTimestampType for TimestampMicrosecondType {
+    const UNIT: TimeUnit = TimeUnit::Microsecond;
+
+    fn make_value(naive: NaiveDateTime) -> Option<i64> {
+        let micros = naive.timestamp().checked_mul(1_000_000)?;
+        micros.checked_add(naive.timestamp_subsec_micros() as i64)
+    }
+}
+impl ArrowTimestampType for TimestampNanosecondType {
+    const UNIT: TimeUnit = TimeUnit::Nanosecond;
+
+    fn make_value(naive: NaiveDateTime) -> Option<i64> {
+        let nanos = naive.timestamp().checked_mul(1_000_000_000)?;
+        nanos.checked_add(naive.timestamp_subsec_nanos() as i64)
+    }
+}
+
+fn add_year_months<T: ArrowTimestampType>(
+    timestamp: <T as ArrowPrimitiveType>::Native,
+    delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+    tz: Tz,
+) -> Option<<T as ArrowPrimitiveType>::Native> {
+    let months = IntervalYearMonthType::to_months(delta);
+    let res = as_datetime_with_timezone::<T>(timestamp, tz)?;
+    let res = add_months_datetime(res, months)?;
+    let res = res.naive_utc();
+    T::make_value(res)
+}
+
+fn add_day_time<T: ArrowTimestampType>(
+    timestamp: <T as ArrowPrimitiveType>::Native,
+    delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+    tz: Tz,
+) -> Option<<T as ArrowPrimitiveType>::Native> {
+    let (days, ms) = IntervalDayTimeType::to_parts(delta);
+    let res = as_datetime_with_timezone::<T>(timestamp, tz)?;
+    let res = add_days_datetime(res, days)?;
+    let res = res.checked_add_signed(Duration::milliseconds(ms as i64))?;
+    let res = res.naive_utc();
+    T::make_value(res)
+}
+
+fn add_month_day_nano<T: ArrowTimestampType>(
+    timestamp: <T as ArrowPrimitiveType>::Native,
+    delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+    tz: Tz,
+) -> Option<<T as ArrowPrimitiveType>::Native> {
+    let (months, days, nanos) = IntervalMonthDayNanoType::to_parts(delta);
+    let res = as_datetime_with_timezone::<T>(timestamp, tz)?;
+    let res = add_months_datetime(res, months)?;
+    let res = add_days_datetime(res, days)?;
+    let res = res.checked_add_signed(Duration::nanoseconds(nanos))?;
+    let res = res.naive_utc();
+    T::make_value(res)
+}
+
+fn subtract_year_months<T: ArrowTimestampType>(
+    timestamp: <T as ArrowPrimitiveType>::Native,
+    delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+    tz: Tz,
+) -> Option<<T as ArrowPrimitiveType>::Native> {
+    let months = IntervalYearMonthType::to_months(delta);
+    let res = as_datetime_with_timezone::<T>(timestamp, tz)?;
+    let res = sub_months_datetime(res, months)?;
+    let res = res.naive_utc();
+    T::make_value(res)
+}
+
+fn subtract_day_time<T: ArrowTimestampType>(
+    timestamp: <T as ArrowPrimitiveType>::Native,
+    delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+    tz: Tz,
+) -> Option<<T as ArrowPrimitiveType>::Native> {
+    let (days, ms) = IntervalDayTimeType::to_parts(delta);
+    let res = as_datetime_with_timezone::<T>(timestamp, tz)?;
+    let res = sub_days_datetime(res, days)?;
+    let res = res.checked_sub_signed(Duration::milliseconds(ms as i64))?;
+    let res = res.naive_utc();
+    T::make_value(res)
+}
+
+fn subtract_month_day_nano<T: ArrowTimestampType>(
+    timestamp: <T as ArrowPrimitiveType>::Native,
+    delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+    tz: Tz,
+) -> Option<<T as ArrowPrimitiveType>::Native> {
+    let (months, days, nanos) = IntervalMonthDayNanoType::to_parts(delta);
+    let res = as_datetime_with_timezone::<T>(timestamp, tz)?;
+    let res = sub_months_datetime(res, months)?;
+    let res = sub_days_datetime(res, days)?;
+    let res = res.checked_sub_signed(Duration::nanoseconds(nanos))?;
+    let res = res.naive_utc();
+    T::make_value(res)
+}
+
+impl TimestampSecondType {
+    /// Adds the given IntervalYearMonthType to an arrow TimestampSecondType.
+    ///
+    /// Returns `None` when it will result in overflow.
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_year_months(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_year_months::<Self>(timestamp, delta, tz)
+    }
+
+    /// Adds the given IntervalDayTimeType to an arrow TimestampSecondType.
+    ///
+    /// Returns `None` when it will result in overflow.
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_day_time(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_day_time::<Self>(timestamp, delta, tz)
+    }
+
+    /// Adds the given IntervalMonthDayNanoType to an arrow TimestampSecondType
+    ///
+    /// Returns `None` when it will result in overflow.
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_month_day_nano(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_month_day_nano::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalYearMonthType to an arrow TimestampSecondType
+    ///
+    /// Returns `None` when it will result in overflow.
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_year_months(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_year_months::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalDayTimeType to an arrow TimestampSecondType
+    ///
+    /// Returns `None` when it will result in overflow.
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_day_time(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_day_time::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalMonthDayNanoType to an arrow TimestampSecondType
+    ///
+    /// Returns `None` when it will result in overflow.
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_month_day_nano(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_month_day_nano::<Self>(timestamp, delta, tz)
+    }
+}
+
+impl TimestampMicrosecondType {
+    /// Adds the given IntervalYearMonthType to an arrow TimestampMicrosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_year_months(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_year_months::<Self>(timestamp, delta, tz)
+    }
+
+    /// Adds the given IntervalDayTimeType to an arrow TimestampMicrosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_day_time(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_day_time::<Self>(timestamp, delta, tz)
+    }
+
+    /// Adds the given IntervalMonthDayNanoType to an arrow TimestampMicrosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_month_day_nano(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_month_day_nano::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalYearMonthType to an arrow TimestampMicrosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_year_months(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_year_months::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalDayTimeType to an arrow TimestampMicrosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_day_time(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_day_time::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalMonthDayNanoType to an arrow TimestampMicrosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_month_day_nano(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_month_day_nano::<Self>(timestamp, delta, tz)
+    }
+}
+
+impl TimestampMillisecondType {
+    /// Adds the given IntervalYearMonthType to an arrow TimestampMillisecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_year_months(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_year_months::<Self>(timestamp, delta, tz)
+    }
+
+    /// Adds the given IntervalDayTimeType to an arrow TimestampMillisecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_day_time(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_day_time::<Self>(timestamp, delta, tz)
+    }
+
+    /// Adds the given IntervalMonthDayNanoType to an arrow TimestampMillisecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_month_day_nano(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_month_day_nano::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalYearMonthType to an arrow TimestampMillisecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_year_months(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_year_months::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalDayTimeType to an arrow TimestampMillisecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_day_time(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_day_time::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalMonthDayNanoType to an arrow TimestampMillisecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_month_day_nano(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_month_day_nano::<Self>(timestamp, delta, tz)
+    }
+}
+
+impl TimestampNanosecondType {
+    /// Adds the given IntervalYearMonthType to an arrow TimestampNanosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_year_months(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_year_months::<Self>(timestamp, delta, tz)
+    }
+
+    /// Adds the given IntervalDayTimeType to an arrow TimestampNanosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_day_time(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_day_time::<Self>(timestamp, delta, tz)
+    }
+
+    /// Adds the given IntervalMonthDayNanoType to an arrow TimestampNanosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn add_month_day_nano(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        add_month_day_nano::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalYearMonthType to an arrow TimestampNanosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_year_months(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_year_months::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalDayTimeType to an arrow TimestampNanosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_day_time(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_day_time::<Self>(timestamp, delta, tz)
+    }
+
+    /// Subtracts the given IntervalMonthDayNanoType to an arrow TimestampNanosecondType
+    ///
+    /// # Arguments
+    ///
+    /// * `timestamp` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    /// * `tz` - The timezone in which to interpret `timestamp`
+    pub fn subtract_month_day_nano(
+        timestamp: <Self as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+        tz: Tz,
+    ) -> Option<<Self as ArrowPrimitiveType>::Native> {
+        subtract_month_day_nano::<Self>(timestamp, delta, tz)
+    }
+}
+
+impl IntervalYearMonthType {
+    /// Creates a IntervalYearMonthType::Native
+    ///
+    /// # Arguments
+    ///
+    /// * `years` - The number of years (+/-) represented in this interval
+    /// * `months` - The number of months (+/-) represented in this interval
+    #[inline]
+    pub fn make_value(
+        years: i32,
+        months: i32,
+    ) -> <IntervalYearMonthType as ArrowPrimitiveType>::Native {
+        years * 12 + months
+    }
+
+    /// Turns a IntervalYearMonthType type into an i32 of months.
+    ///
+    /// This operation is technically a no-op, it is included for comprehensiveness.
+    ///
+    /// # Arguments
+    ///
+    /// * `i` - The IntervalYearMonthType::Native to convert
+    #[inline]
+    pub fn to_months(i: <IntervalYearMonthType as ArrowPrimitiveType>::Native) -> i32 {
+        i
+    }
+}
+
+impl IntervalDayTimeType {
+    /// Creates a IntervalDayTimeType::Native
+    ///
+    /// # Arguments
+    ///
+    /// * `days` - The number of days (+/-) represented in this interval
+    /// * `millis` - The number of milliseconds (+/-) represented in this interval
+    #[inline]
+    pub fn make_value(
+        days: i32,
+        millis: i32,
+    ) -> <IntervalDayTimeType as ArrowPrimitiveType>::Native {
+        /*
+        https://github.com/apache/arrow/blob/02c8598d264c839a5b5cf3109bfd406f3b8a6ba5/cpp/src/arrow/type.h#L1433
+        struct DayMilliseconds {
+            int32_t days = 0;
+            int32_t milliseconds = 0;
+            ...
+        }
+        64      56      48      40      32      24      16      8       0
+        +-------+-------+-------+-------+-------+-------+-------+-------+
+        |             days              |         milliseconds          |
+        +-------+-------+-------+-------+-------+-------+-------+-------+
+        */
+        let m = millis as u64 & u32::MAX as u64;
+        let d = (days as u64 & u32::MAX as u64) << 32;
+        (m | d) as <IntervalDayTimeType as ArrowPrimitiveType>::Native
+    }
+
+    /// Turns a IntervalDayTimeType into a tuple of (days, milliseconds)
+    ///
+    /// # Arguments
+    ///
+    /// * `i` - The IntervalDayTimeType to convert
+    #[inline]
+    pub fn to_parts(i: <IntervalDayTimeType as ArrowPrimitiveType>::Native) -> (i32, i32) {
+        let days = (i >> 32) as i32;
+        let ms = i as i32;
+        (days, ms)
+    }
+}
+
+impl IntervalMonthDayNanoType {
+    /// Creates a IntervalMonthDayNanoType::Native
+    ///
+    /// # Arguments
+    ///
+    /// * `months` - The number of months (+/-) represented in this interval
+    /// * `days` - The number of days (+/-) represented in this interval
+    /// * `nanos` - The number of nanoseconds (+/-) represented in this interval
+    #[inline]
+    pub fn make_value(
+        months: i32,
+        days: i32,
+        nanos: i64,
+    ) -> <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native {
+        /*
+        https://github.com/apache/arrow/blob/02c8598d264c839a5b5cf3109bfd406f3b8a6ba5/cpp/src/arrow/type.h#L1475
+        struct MonthDayNanos {
+            int32_t months;
+            int32_t days;
+            int64_t nanoseconds;
+        }
+        128     112     96      80      64      48      32      16      0
+        +-------+-------+-------+-------+-------+-------+-------+-------+
+        |     months    |      days     |             nanos             |
+        +-------+-------+-------+-------+-------+-------+-------+-------+
+        */
+        let m = (months as u128 & u32::MAX as u128) << 96;
+        let d = (days as u128 & u32::MAX as u128) << 64;
+        let n = nanos as u128 & u64::MAX as u128;
+        (m | d | n) as <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native
+    }
+
+    /// Turns a IntervalMonthDayNanoType into a tuple of (months, days, nanos)
+    ///
+    /// # Arguments
+    ///
+    /// * `i` - The IntervalMonthDayNanoType to convert
+    #[inline]
+    pub fn to_parts(
+        i: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+    ) -> (i32, i32, i64) {
+        let months = (i >> 96) as i32;
+        let days = (i >> 64) as i32;
+        let nanos = i as i64;
+        (months, days, nanos)
+    }
+}
+
+impl Date32Type {
+    /// Converts an arrow Date32Type into a chrono::NaiveDate
+    ///
+    /// # Arguments
+    ///
+    /// * `i` - The Date32Type to convert
+    pub fn to_naive_date(i: <Date32Type as ArrowPrimitiveType>::Native) -> NaiveDate {
+        let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap();
+        epoch.add(Duration::days(i as i64))
+    }
+
+    /// Converts a chrono::NaiveDate into an arrow Date32Type
+    ///
+    /// # Arguments
+    ///
+    /// * `d` - The NaiveDate to convert
+    pub fn from_naive_date(d: NaiveDate) -> <Date32Type as ArrowPrimitiveType>::Native {
+        let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap();
+        d.sub(epoch).num_days() as <Date32Type as ArrowPrimitiveType>::Native
+    }
+
+    /// Adds the given IntervalYearMonthType to an arrow Date32Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    pub fn add_year_months(
+        date: <Date32Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+    ) -> <Date32Type as ArrowPrimitiveType>::Native {
+        let prior = Date32Type::to_naive_date(date);
+        let months = IntervalYearMonthType::to_months(delta);
+        let posterior = shift_months(prior, months);
+        Date32Type::from_naive_date(posterior)
+    }
+
+    /// Adds the given IntervalDayTimeType to an arrow Date32Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    pub fn add_day_time(
+        date: <Date32Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+    ) -> <Date32Type as ArrowPrimitiveType>::Native {
+        let (days, ms) = IntervalDayTimeType::to_parts(delta);
+        let res = Date32Type::to_naive_date(date);
+        let res = res.add(Duration::days(days as i64));
+        let res = res.add(Duration::milliseconds(ms as i64));
+        Date32Type::from_naive_date(res)
+    }
+
+    /// Adds the given IntervalMonthDayNanoType to an arrow Date32Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    pub fn add_month_day_nano(
+        date: <Date32Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+    ) -> <Date32Type as ArrowPrimitiveType>::Native {
+        let (months, days, nanos) = IntervalMonthDayNanoType::to_parts(delta);
+        let res = Date32Type::to_naive_date(date);
+        let res = shift_months(res, months);
+        let res = res.add(Duration::days(days as i64));
+        let res = res.add(Duration::nanoseconds(nanos));
+        Date32Type::from_naive_date(res)
+    }
+
+    /// Subtract the given IntervalYearMonthType to an arrow Date32Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to subtract
+    pub fn subtract_year_months(
+        date: <Date32Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+    ) -> <Date32Type as ArrowPrimitiveType>::Native {
+        let prior = Date32Type::to_naive_date(date);
+        let months = IntervalYearMonthType::to_months(-delta);
+        let posterior = shift_months(prior, months);
+        Date32Type::from_naive_date(posterior)
+    }
+
+    /// Subtract the given IntervalDayTimeType to an arrow Date32Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to subtract
+    pub fn subtract_day_time(
+        date: <Date32Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+    ) -> <Date32Type as ArrowPrimitiveType>::Native {
+        let (days, ms) = IntervalDayTimeType::to_parts(delta);
+        let res = Date32Type::to_naive_date(date);
+        let res = res.sub(Duration::days(days as i64));
+        let res = res.sub(Duration::milliseconds(ms as i64));
+        Date32Type::from_naive_date(res)
+    }
+
+    /// Subtract the given IntervalMonthDayNanoType to an arrow Date32Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to subtract
+    pub fn subtract_month_day_nano(
+        date: <Date32Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+    ) -> <Date32Type as ArrowPrimitiveType>::Native {
+        let (months, days, nanos) = IntervalMonthDayNanoType::to_parts(delta);
+        let res = Date32Type::to_naive_date(date);
+        let res = shift_months(res, -months);
+        let res = res.sub(Duration::days(days as i64));
+        let res = res.sub(Duration::nanoseconds(nanos));
+        Date32Type::from_naive_date(res)
+    }
+}
+
+impl Date64Type {
+    /// Converts an arrow Date64Type into a chrono::NaiveDate
+    ///
+    /// # Arguments
+    ///
+    /// * `i` - The Date64Type to convert
+    pub fn to_naive_date(i: <Date64Type as ArrowPrimitiveType>::Native) -> NaiveDate {
+        let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap();
+        epoch.add(Duration::milliseconds(i))
+    }
+
+    /// Converts a chrono::NaiveDate into an arrow Date64Type
+    ///
+    /// # Arguments
+    ///
+    /// * `d` - The NaiveDate to convert
+    pub fn from_naive_date(d: NaiveDate) -> <Date64Type as ArrowPrimitiveType>::Native {
+        let epoch = NaiveDate::from_ymd_opt(1970, 1, 1).unwrap();
+        d.sub(epoch).num_milliseconds() as <Date64Type as ArrowPrimitiveType>::Native
+    }
+
+    /// Adds the given IntervalYearMonthType to an arrow Date64Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    pub fn add_year_months(
+        date: <Date64Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+    ) -> <Date64Type as ArrowPrimitiveType>::Native {
+        let prior = Date64Type::to_naive_date(date);
+        let months = IntervalYearMonthType::to_months(delta);
+        let posterior = shift_months(prior, months);
+        Date64Type::from_naive_date(posterior)
+    }
+
+    /// Adds the given IntervalDayTimeType to an arrow Date64Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    pub fn add_day_time(
+        date: <Date64Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+    ) -> <Date64Type as ArrowPrimitiveType>::Native {
+        let (days, ms) = IntervalDayTimeType::to_parts(delta);
+        let res = Date64Type::to_naive_date(date);
+        let res = res.add(Duration::days(days as i64));
+        let res = res.add(Duration::milliseconds(ms as i64));
+        Date64Type::from_naive_date(res)
+    }
+
+    /// Adds the given IntervalMonthDayNanoType to an arrow Date64Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to add
+    pub fn add_month_day_nano(
+        date: <Date64Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+    ) -> <Date64Type as ArrowPrimitiveType>::Native {
+        let (months, days, nanos) = IntervalMonthDayNanoType::to_parts(delta);
+        let res = Date64Type::to_naive_date(date);
+        let res = shift_months(res, months);
+        let res = res.add(Duration::days(days as i64));
+        let res = res.add(Duration::nanoseconds(nanos));
+        Date64Type::from_naive_date(res)
+    }
+
+    /// Subtract the given IntervalYearMonthType to an arrow Date64Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to subtract
+    pub fn subtract_year_months(
+        date: <Date64Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
+    ) -> <Date64Type as ArrowPrimitiveType>::Native {
+        let prior = Date64Type::to_naive_date(date);
+        let months = IntervalYearMonthType::to_months(-delta);
+        let posterior = shift_months(prior, months);
+        Date64Type::from_naive_date(posterior)
+    }
+
+    /// Subtract the given IntervalDayTimeType to an arrow Date64Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to subtract
+    pub fn subtract_day_time(
+        date: <Date64Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
+    ) -> <Date64Type as ArrowPrimitiveType>::Native {
+        let (days, ms) = IntervalDayTimeType::to_parts(delta);
+        let res = Date64Type::to_naive_date(date);
+        let res = res.sub(Duration::days(days as i64));
+        let res = res.sub(Duration::milliseconds(ms as i64));
+        Date64Type::from_naive_date(res)
+    }
+
+    /// Subtract the given IntervalMonthDayNanoType to an arrow Date64Type
+    ///
+    /// # Arguments
+    ///
+    /// * `date` - The date on which to perform the operation
+    /// * `delta` - The interval to subtract
+    pub fn subtract_month_day_nano(
+        date: <Date64Type as ArrowPrimitiveType>::Native,
+        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
+    ) -> <Date64Type as ArrowPrimitiveType>::Native {
+        let (months, days, nanos) = IntervalMonthDayNanoType::to_parts(delta);
+        let res = Date64Type::to_naive_date(date);
+        let res = shift_months(res, -months);
+        let res = res.sub(Duration::days(days as i64));
+        let res = res.sub(Duration::nanoseconds(nanos));
+        Date64Type::from_naive_date(res)
+    }
+}
+
+/// Crate private types for Decimal Arrays
+///
+/// Not intended to be used outside this crate
+mod decimal {
+    use super::*;
+
+    pub trait DecimalTypeSealed {}
+    impl DecimalTypeSealed for Decimal128Type {}
+    impl DecimalTypeSealed for Decimal256Type {}
+}
+
+/// A trait over the decimal types, used by [`PrimitiveArray`] to provide a generic
+/// implementation across the various decimal types
+///
+/// Implemented by [`Decimal128Type`] and [`Decimal256Type`] for [`Decimal128Array`]
+/// and [`Decimal256Array`] respectively
+///
+/// [`PrimitiveArray`]: crate::array::PrimitiveArray
+/// [`Decimal128Array`]: crate::array::Decimal128Array
+/// [`Decimal256Array`]: crate::array::Decimal256Array
+pub trait DecimalType:
+    'static + Send + Sync + ArrowPrimitiveType + decimal::DecimalTypeSealed
+{
+    /// Width of the type
+    const BYTE_LENGTH: usize;
+    /// Maximum number of significant digits
+    const MAX_PRECISION: u8;
+    /// Maximum no of digits after the decimal point (note the scale can be negative)
+    const MAX_SCALE: i8;
+    /// fn to create its [`DataType`]
+    const TYPE_CONSTRUCTOR: fn(u8, i8) -> DataType;
+    /// Default values for [`DataType`]
+    const DEFAULT_TYPE: DataType;
+
+    /// "Decimal128" or "Decimal256", for use in error messages
+    const PREFIX: &'static str;
+
+    /// Formats the decimal value with the provided precision and scale
+    fn format_decimal(value: Self::Native, precision: u8, scale: i8) -> String;
+
+    /// Validates that `value` contains no more than `precision` decimal digits
+    fn validate_decimal_precision(value: Self::Native, precision: u8) -> Result<(), ArrowError>;
+}
+
+/// Validate that `precision` and `scale` are valid for `T`
+///
+/// Returns an Error if:
+/// - `precision` is zero
+/// - `precision` is larger than `T:MAX_PRECISION`
+/// - `scale` is larger than `T::MAX_SCALE`
+/// - `scale` is > `precision`
+pub fn validate_decimal_precision_and_scale<T: DecimalType>(
+    precision: u8,
+    scale: i8,
+) -> Result<(), ArrowError> {
+    if precision == 0 {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "precision cannot be 0, has to be between [1, {}]",
+            T::MAX_PRECISION
+        )));
+    }
+    if precision > T::MAX_PRECISION {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "precision {} is greater than max {}",
+            precision,
+            T::MAX_PRECISION
+        )));
+    }
+    if scale > T::MAX_SCALE {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "scale {} is greater than max {}",
+            scale,
+            T::MAX_SCALE
+        )));
+    }
+    if scale > 0 && scale as u8 > precision {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "scale {scale} is greater than precision {precision}"
+        )));
+    }
+
+    Ok(())
+}
+
+/// The decimal type for a Decimal128Array
+#[derive(Debug)]
+pub struct Decimal128Type {}
+
+impl DecimalType for Decimal128Type {
+    const BYTE_LENGTH: usize = 16;
+    const MAX_PRECISION: u8 = DECIMAL128_MAX_PRECISION;
+    const MAX_SCALE: i8 = DECIMAL128_MAX_SCALE;
+    const TYPE_CONSTRUCTOR: fn(u8, i8) -> DataType = DataType::Decimal128;
+    const DEFAULT_TYPE: DataType =
+        DataType::Decimal128(DECIMAL128_MAX_PRECISION, DECIMAL_DEFAULT_SCALE);
+    const PREFIX: &'static str = "Decimal128";
+
+    fn format_decimal(value: Self::Native, precision: u8, scale: i8) -> String {
+        format_decimal_str(&value.to_string(), precision as usize, scale)
+    }
+
+    fn validate_decimal_precision(num: i128, precision: u8) -> Result<(), ArrowError> {
+        validate_decimal_precision(num, precision)
+    }
+}
+
+impl ArrowPrimitiveType for Decimal128Type {
+    type Native = i128;
+
+    const DATA_TYPE: DataType = <Self as DecimalType>::DEFAULT_TYPE;
+}
+
+impl primitive::PrimitiveTypeSealed for Decimal128Type {}
+
+/// The decimal type for a Decimal256Array
+#[derive(Debug)]
+pub struct Decimal256Type {}
+
+impl DecimalType for Decimal256Type {
+    const BYTE_LENGTH: usize = 32;
+    const MAX_PRECISION: u8 = DECIMAL256_MAX_PRECISION;
+    const MAX_SCALE: i8 = DECIMAL256_MAX_SCALE;
+    const TYPE_CONSTRUCTOR: fn(u8, i8) -> DataType = DataType::Decimal256;
+    const DEFAULT_TYPE: DataType =
+        DataType::Decimal256(DECIMAL256_MAX_PRECISION, DECIMAL_DEFAULT_SCALE);
+    const PREFIX: &'static str = "Decimal256";
+
+    fn format_decimal(value: Self::Native, precision: u8, scale: i8) -> String {
+        format_decimal_str(&value.to_string(), precision as usize, scale)
+    }
+
+    fn validate_decimal_precision(num: i256, precision: u8) -> Result<(), ArrowError> {
+        validate_decimal256_precision(num, precision)
+    }
+}
+
+impl ArrowPrimitiveType for Decimal256Type {
+    type Native = i256;
+
+    const DATA_TYPE: DataType = <Self as DecimalType>::DEFAULT_TYPE;
+}
+
+impl primitive::PrimitiveTypeSealed for Decimal256Type {}
+
+fn format_decimal_str(value_str: &str, precision: usize, scale: i8) -> String {
+    let (sign, rest) = match value_str.strip_prefix('-') {
+        Some(stripped) => ("-", stripped),
+        None => ("", value_str),
+    };
+    let bound = precision.min(rest.len()) + sign.len();
+    let value_str = &value_str[0..bound];
+
+    if scale == 0 {
+        value_str.to_string()
+    } else if scale < 0 {
+        let padding = value_str.len() + scale.unsigned_abs() as usize;
+        format!("{value_str:0<padding$}")
+    } else if rest.len() > scale as usize {
+        // Decimal separator is in the middle of the string
+        let (whole, decimal) = value_str.split_at(value_str.len() - scale as usize);
+        format!("{whole}.{decimal}")
+    } else {
+        // String has to be padded
+        format!("{}0.{:0>width$}", sign, rest, width = scale as usize)
+    }
+}
+
+/// Crate private types for Byte Arrays
+///
+/// Not intended to be used outside this crate
+pub(crate) mod bytes {
+    use super::*;
+
+    pub trait ByteArrayTypeSealed {}
+    impl<O: OffsetSizeTrait> ByteArrayTypeSealed for GenericStringType<O> {}
+    impl<O: OffsetSizeTrait> ByteArrayTypeSealed for GenericBinaryType<O> {}
+
+    pub trait ByteArrayNativeType: std::fmt::Debug + Send + Sync {
+        /// # Safety
+        ///
+        /// `b` must be a valid byte sequence for `Self`
+        unsafe fn from_bytes_unchecked(b: &[u8]) -> &Self;
+    }
+
+    impl ByteArrayNativeType for [u8] {
+        #[inline]
+        unsafe fn from_bytes_unchecked(b: &[u8]) -> &Self {
+            b
+        }
+    }
+
+    impl ByteArrayNativeType for str {
+        #[inline]
+        unsafe fn from_bytes_unchecked(b: &[u8]) -> &Self {
+            std::str::from_utf8_unchecked(b)
+        }
+    }
+}
+
+/// A trait over the variable-size byte array types
+///
+/// See [Variable Size Binary Layout](https://arrow.apache.org/docs/format/Columnar.html#variable-size-binary-layout)
+pub trait ByteArrayType: 'static + Send + Sync + bytes::ByteArrayTypeSealed {
+    /// Type of offset i.e i32/i64
+    type Offset: OffsetSizeTrait;
+    /// Type for representing its equivalent rust type i.e
+    /// Utf8Array will have native type has &str
+    /// BinaryArray will have type as [u8]
+    type Native: bytes::ByteArrayNativeType + AsRef<Self::Native> + AsRef<[u8]> + ?Sized;
+
+    /// "Binary" or "String", for use in error messages
+    const PREFIX: &'static str;
+
+    /// Datatype of array elements
+    const DATA_TYPE: DataType;
+
+    /// Verifies that every consecutive pair of `offsets` denotes a valid slice of `values`
+    fn validate(offsets: &OffsetBuffer<Self::Offset>, values: &Buffer) -> Result<(), ArrowError>;
+}
+
+/// [`ByteArrayType`] for string arrays
+pub struct GenericStringType<O: OffsetSizeTrait> {
+    phantom: PhantomData<O>,
+}
+
+impl<O: OffsetSizeTrait> ByteArrayType for GenericStringType<O> {
+    type Offset = O;
+    type Native = str;
+    const PREFIX: &'static str = "String";
+
+    const DATA_TYPE: DataType = if O::IS_LARGE {
+        DataType::LargeUtf8
+    } else {
+        DataType::Utf8
+    };
+
+    fn validate(offsets: &OffsetBuffer<Self::Offset>, values: &Buffer) -> Result<(), ArrowError> {
+        // Verify that the slice as a whole is valid UTF-8
+        let validated = std::str::from_utf8(values).map_err(|e| {
+            ArrowError::InvalidArgumentError(format!("Encountered non UTF-8 data: {e}"))
+        })?;
+
+        // Verify each offset is at a valid character boundary in this UTF-8 array
+        for offset in offsets.iter() {
+            let o = offset.as_usize();
+            if !validated.is_char_boundary(o) {
+                if o < validated.len() {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "Split UTF-8 codepoint at offset {o}"
+                    )));
+                }
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Offset of {o} exceeds length of values {}",
+                    validated.len()
+                )));
+            }
+        }
+        Ok(())
+    }
+}
+
+/// An arrow utf8 array with i32 offsets
+pub type Utf8Type = GenericStringType<i32>;
+/// An arrow utf8 array with i64 offsets
+pub type LargeUtf8Type = GenericStringType<i64>;
+
+/// [`ByteArrayType`] for binary arrays
+pub struct GenericBinaryType<O: OffsetSizeTrait> {
+    phantom: PhantomData<O>,
+}
+
+impl<O: OffsetSizeTrait> ByteArrayType for GenericBinaryType<O> {
+    type Offset = O;
+    type Native = [u8];
+    const PREFIX: &'static str = "Binary";
+
+    const DATA_TYPE: DataType = if O::IS_LARGE {
+        DataType::LargeBinary
+    } else {
+        DataType::Binary
+    };
+
+    fn validate(offsets: &OffsetBuffer<Self::Offset>, values: &Buffer) -> Result<(), ArrowError> {
+        // offsets are guaranteed to be monotonically increasing and non-empty
+        let max_offset = offsets.last().unwrap().as_usize();
+        if values.len() < max_offset {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Maximum offset of {max_offset} is larger than values of length {}",
+                values.len()
+            )));
+        }
+        Ok(())
+    }
+}
+
+/// An arrow binary array with i32 offsets
+pub type BinaryType = GenericBinaryType<i32>;
+/// An arrow binary array with i64 offsets
+pub type LargeBinaryType = GenericBinaryType<i64>;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_data::{layout, BufferSpec};
+
+    #[test]
+    fn month_day_nano_should_roundtrip() {
+        let value = IntervalMonthDayNanoType::make_value(1, 2, 3);
+        assert_eq!(IntervalMonthDayNanoType::to_parts(value), (1, 2, 3));
+    }
+
+    #[test]
+    fn month_day_nano_should_roundtrip_neg() {
+        let value = IntervalMonthDayNanoType::make_value(-1, -2, -3);
+        assert_eq!(IntervalMonthDayNanoType::to_parts(value), (-1, -2, -3));
+    }
+
+    #[test]
+    fn day_time_should_roundtrip() {
+        let value = IntervalDayTimeType::make_value(1, 2);
+        assert_eq!(IntervalDayTimeType::to_parts(value), (1, 2));
+    }
+
+    #[test]
+    fn day_time_should_roundtrip_neg() {
+        let value = IntervalDayTimeType::make_value(-1, -2);
+        assert_eq!(IntervalDayTimeType::to_parts(value), (-1, -2));
+    }
+
+    #[test]
+    fn year_month_should_roundtrip() {
+        let value = IntervalYearMonthType::make_value(1, 2);
+        assert_eq!(IntervalYearMonthType::to_months(value), 14);
+    }
+
+    #[test]
+    fn year_month_should_roundtrip_neg() {
+        let value = IntervalYearMonthType::make_value(-1, -2);
+        assert_eq!(IntervalYearMonthType::to_months(value), -14);
+    }
+
+    fn test_layout<T: ArrowPrimitiveType>() {
+        let layout = layout(&T::DATA_TYPE);
+
+        assert_eq!(layout.buffers.len(), 1);
+
+        let spec = &layout.buffers[0];
+        assert_eq!(
+            spec,
+            &BufferSpec::FixedWidth {
+                byte_width: std::mem::size_of::<T::Native>(),
+                alignment: std::mem::align_of::<T::Native>(),
+            }
+        );
+    }
+
+    #[test]
+    fn test_layouts() {
+        test_layout::<Int8Type>();
+        test_layout::<Int16Type>();
+        test_layout::<Int32Type>();
+        test_layout::<Int64Type>();
+        test_layout::<UInt8Type>();
+        test_layout::<UInt16Type>();
+        test_layout::<UInt32Type>();
+        test_layout::<UInt64Type>();
+        test_layout::<Float16Type>();
+        test_layout::<Float32Type>();
+        test_layout::<Float64Type>();
+        test_layout::<Decimal128Type>();
+        test_layout::<Decimal256Type>();
+        test_layout::<TimestampNanosecondType>();
+        test_layout::<TimestampMillisecondType>();
+        test_layout::<TimestampMicrosecondType>();
+        test_layout::<TimestampNanosecondType>();
+        test_layout::<TimestampSecondType>();
+        test_layout::<Date32Type>();
+        test_layout::<Date64Type>();
+        test_layout::<Time32SecondType>();
+        test_layout::<Time32MillisecondType>();
+        test_layout::<Time64MicrosecondType>();
+        test_layout::<Time64NanosecondType>();
+        test_layout::<IntervalMonthDayNanoType>();
+        test_layout::<IntervalDayTimeType>();
+        test_layout::<IntervalYearMonthType>();
+        test_layout::<DurationNanosecondType>();
+        test_layout::<DurationMicrosecondType>();
+        test_layout::<DurationMillisecondType>();
+        test_layout::<DurationSecondType>();
+    }
+}
diff --git a/arrow-avro/Cargo.toml b/arrow-avro/Cargo.toml
new file mode 100644
index 000000000000..d2436f0c15de
--- /dev/null
+++ b/arrow-avro/Cargo.toml
@@ -0,0 +1,56 @@
+# 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]
+name = "arrow-avro"
+version = { workspace = true }
+description = "Support for parsing Avro format into the Arrow format"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_avro"
+path = "src/lib.rs"
+bench = false
+
+[features]
+default = ["deflate", "snappy", "zstd"]
+deflate = ["flate2"]
+snappy = ["snap", "crc"]
+
+[dependencies]
+arrow-array = { workspace = true  }
+arrow-buffer = { workspace = true  }
+arrow-cast = { workspace = true  }
+arrow-data = { workspace = true  }
+arrow-schema = { workspace = true  }
+serde_json = { version = "1.0", default-features = false, features = ["std"] }
+serde = { version = "1.0.188", features = ["derive"] }
+flate2 = { version = "1.0", default-features = false, features = ["rust_backend"], optional = true }
+snap = { version = "1.0", default-features = false, optional = true }
+zstd = { version = "0.13", default-features = false, optional = true }
+crc = { version = "3.0", optional = true }
+
+
+[dev-dependencies]
+
diff --git a/arrow-avro/src/codec.rs b/arrow-avro/src/codec.rs
new file mode 100644
index 000000000000..1e2acd99d828
--- /dev/null
+++ b/arrow-avro/src/codec.rs
@@ -0,0 +1,315 @@
+// 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.
+
+use crate::schema::{Attributes, ComplexType, PrimitiveType, Record, Schema, TypeName};
+use arrow_schema::{
+    ArrowError, DataType, Field, FieldRef, IntervalUnit, SchemaBuilder, SchemaRef, TimeUnit,
+};
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+/// Avro types are not nullable, with nullability instead encoded as a union
+/// where one of the variants is the null type.
+///
+/// To accommodate this we special case two-variant unions where one of the
+/// variants is the null type, and use this to derive arrow's notion of nullability
+#[derive(Debug, Copy, Clone)]
+enum Nulls {
+    /// The nulls are encoded as the first union variant
+    NullFirst,
+    /// The nulls are encoded as the second union variant
+    NullSecond,
+}
+
+/// An Avro datatype mapped to the arrow data model
+#[derive(Debug, Clone)]
+pub struct AvroDataType {
+    nulls: Option<Nulls>,
+    metadata: HashMap<String, String>,
+    codec: Codec,
+}
+
+impl AvroDataType {
+    /// Returns an arrow [`Field`] with the given name
+    pub fn field_with_name(&self, name: &str) -> Field {
+        let d = self.codec.data_type();
+        Field::new(name, d, self.nulls.is_some()).with_metadata(self.metadata.clone())
+    }
+}
+
+/// A named [`AvroDataType`]
+#[derive(Debug, Clone)]
+pub struct AvroField {
+    name: String,
+    data_type: AvroDataType,
+}
+
+impl AvroField {
+    /// Returns the arrow [`Field`]
+    pub fn field(&self) -> Field {
+        self.data_type.field_with_name(&self.name)
+    }
+
+    /// Returns the [`Codec`]
+    pub fn codec(&self) -> &Codec {
+        &self.data_type.codec
+    }
+}
+
+impl<'a> TryFrom<&Schema<'a>> for AvroField {
+    type Error = ArrowError;
+
+    fn try_from(schema: &Schema<'a>) -> Result<Self, Self::Error> {
+        match schema {
+            Schema::Complex(ComplexType::Record(r)) => {
+                let mut resolver = Resolver::default();
+                let data_type = make_data_type(schema, None, &mut resolver)?;
+                Ok(AvroField {
+                    data_type,
+                    name: r.name.to_string(),
+                })
+            }
+            _ => Err(ArrowError::ParseError(format!(
+                "Expected record got {schema:?}"
+            ))),
+        }
+    }
+}
+
+/// An Avro encoding
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#encodings>
+#[derive(Debug, Clone)]
+pub enum Codec {
+    Null,
+    Boolean,
+    Int32,
+    Int64,
+    Float32,
+    Float64,
+    Binary,
+    Utf8,
+    Date32,
+    TimeMillis,
+    TimeMicros,
+    /// TimestampMillis(is_utc)
+    TimestampMillis(bool),
+    /// TimestampMicros(is_utc)
+    TimestampMicros(bool),
+    Fixed(i32),
+    List(Arc<AvroDataType>),
+    Struct(Arc<[AvroField]>),
+    Duration,
+}
+
+impl Codec {
+    fn data_type(&self) -> DataType {
+        match self {
+            Self::Null => DataType::Null,
+            Self::Boolean => DataType::Boolean,
+            Self::Int32 => DataType::Int32,
+            Self::Int64 => DataType::Int64,
+            Self::Float32 => DataType::Float32,
+            Self::Float64 => DataType::Float64,
+            Self::Binary => DataType::Binary,
+            Self::Utf8 => DataType::Utf8,
+            Self::Date32 => DataType::Date32,
+            Self::TimeMillis => DataType::Time32(TimeUnit::Millisecond),
+            Self::TimeMicros => DataType::Time64(TimeUnit::Microsecond),
+            Self::TimestampMillis(is_utc) => {
+                DataType::Timestamp(TimeUnit::Millisecond, is_utc.then(|| "+00:00".into()))
+            }
+            Self::TimestampMicros(is_utc) => {
+                DataType::Timestamp(TimeUnit::Microsecond, is_utc.then(|| "+00:00".into()))
+            }
+            Self::Duration => DataType::Interval(IntervalUnit::MonthDayNano),
+            Self::Fixed(size) => DataType::FixedSizeBinary(*size),
+            Self::List(f) => DataType::List(Arc::new(f.field_with_name("item"))),
+            Self::Struct(f) => DataType::Struct(f.iter().map(|x| x.field()).collect()),
+        }
+    }
+}
+
+impl From<PrimitiveType> for Codec {
+    fn from(value: PrimitiveType) -> Self {
+        match value {
+            PrimitiveType::Null => Self::Null,
+            PrimitiveType::Boolean => Self::Boolean,
+            PrimitiveType::Int => Self::Int32,
+            PrimitiveType::Long => Self::Int64,
+            PrimitiveType::Float => Self::Float32,
+            PrimitiveType::Double => Self::Float64,
+            PrimitiveType::Bytes => Self::Binary,
+            PrimitiveType::String => Self::Utf8,
+        }
+    }
+}
+
+/// Resolves Avro type names to [`AvroDataType`]
+///
+/// See <https://avro.apache.org/docs/1.11.1/specification/#names>
+#[derive(Debug, Default)]
+struct Resolver<'a> {
+    map: HashMap<(&'a str, &'a str), AvroDataType>,
+}
+
+impl<'a> Resolver<'a> {
+    fn register(&mut self, name: &'a str, namespace: Option<&'a str>, schema: AvroDataType) {
+        self.map.insert((name, namespace.unwrap_or("")), schema);
+    }
+
+    fn resolve(&self, name: &str, namespace: Option<&'a str>) -> Result<AvroDataType, ArrowError> {
+        let (namespace, name) = name
+            .rsplit_once('.')
+            .unwrap_or_else(|| (namespace.unwrap_or(""), name));
+
+        self.map
+            .get(&(namespace, name))
+            .ok_or_else(|| ArrowError::ParseError(format!("Failed to resolve {namespace}.{name}")))
+            .cloned()
+    }
+}
+
+/// Parses a [`AvroDataType`] from the provided [`Schema`] and the given `name` and `namespace`
+///
+/// `name`: is name used to refer to `schema` in its parent
+/// `namespace`: an optional qualifier used as part of a type hierarchy
+///
+/// See [`Resolver`] for more information
+fn make_data_type<'a>(
+    schema: &Schema<'a>,
+    namespace: Option<&'a str>,
+    resolver: &mut Resolver<'a>,
+) -> Result<AvroDataType, ArrowError> {
+    match schema {
+        Schema::TypeName(TypeName::Primitive(p)) => Ok(AvroDataType {
+            nulls: None,
+            metadata: Default::default(),
+            codec: (*p).into(),
+        }),
+        Schema::TypeName(TypeName::Ref(name)) => resolver.resolve(name, namespace),
+        Schema::Union(f) => {
+            // Special case the common case of nullable primitives
+            let null = f
+                .iter()
+                .position(|x| x == &Schema::TypeName(TypeName::Primitive(PrimitiveType::Null)));
+            match (f.len() == 2, null) {
+                (true, Some(0)) => {
+                    let mut field = make_data_type(&f[1], namespace, resolver)?;
+                    field.nulls = Some(Nulls::NullFirst);
+                    Ok(field)
+                }
+                (true, Some(1)) => {
+                    let mut field = make_data_type(&f[0], namespace, resolver)?;
+                    field.nulls = Some(Nulls::NullSecond);
+                    Ok(field)
+                }
+                _ => Err(ArrowError::NotYetImplemented(format!(
+                    "Union of {f:?} not currently supported"
+                ))),
+            }
+        }
+        Schema::Complex(c) => match c {
+            ComplexType::Record(r) => {
+                let namespace = r.namespace.or(namespace);
+                let fields = r
+                    .fields
+                    .iter()
+                    .map(|field| {
+                        Ok(AvroField {
+                            name: field.name.to_string(),
+                            data_type: make_data_type(&field.r#type, namespace, resolver)?,
+                        })
+                    })
+                    .collect::<Result<_, ArrowError>>()?;
+
+                let field = AvroDataType {
+                    nulls: None,
+                    codec: Codec::Struct(fields),
+                    metadata: r.attributes.field_metadata(),
+                };
+                resolver.register(r.name, namespace, field.clone());
+                Ok(field)
+            }
+            ComplexType::Array(a) => {
+                let mut field = make_data_type(a.items.as_ref(), namespace, resolver)?;
+                Ok(AvroDataType {
+                    nulls: None,
+                    metadata: a.attributes.field_metadata(),
+                    codec: Codec::List(Arc::new(field)),
+                })
+            }
+            ComplexType::Fixed(f) => {
+                let size = f.size.try_into().map_err(|e| {
+                    ArrowError::ParseError(format!("Overflow converting size to i32: {e}"))
+                })?;
+
+                let field = AvroDataType {
+                    nulls: None,
+                    metadata: f.attributes.field_metadata(),
+                    codec: Codec::Fixed(size),
+                };
+                resolver.register(f.name, namespace, field.clone());
+                Ok(field)
+            }
+            ComplexType::Enum(e) => Err(ArrowError::NotYetImplemented(format!(
+                "Enum of {e:?} not currently supported"
+            ))),
+            ComplexType::Map(m) => Err(ArrowError::NotYetImplemented(format!(
+                "Map of {m:?} not currently supported"
+            ))),
+        },
+        Schema::Type(t) => {
+            let mut field =
+                make_data_type(&Schema::TypeName(t.r#type.clone()), namespace, resolver)?;
+
+            // https://avro.apache.org/docs/1.11.1/specification/#logical-types
+            match (t.attributes.logical_type, &mut field.codec) {
+                (Some("decimal"), c @ Codec::Fixed(_)) => {
+                    return Err(ArrowError::NotYetImplemented(
+                        "Decimals are not currently supported".to_string(),
+                    ))
+                }
+                (Some("date"), c @ Codec::Int32) => *c = Codec::Date32,
+                (Some("time-millis"), c @ Codec::Int32) => *c = Codec::TimeMillis,
+                (Some("time-micros"), c @ Codec::Int64) => *c = Codec::TimeMicros,
+                (Some("timestamp-millis"), c @ Codec::Int64) => *c = Codec::TimestampMillis(true),
+                (Some("timestamp-micros"), c @ Codec::Int64) => *c = Codec::TimestampMicros(true),
+                (Some("local-timestamp-millis"), c @ Codec::Int64) => {
+                    *c = Codec::TimestampMillis(false)
+                }
+                (Some("local-timestamp-micros"), c @ Codec::Int64) => {
+                    *c = Codec::TimestampMicros(false)
+                }
+                (Some("duration"), c @ Codec::Fixed(12)) => *c = Codec::Duration,
+                (Some(logical), _) => {
+                    // Insert unrecognized logical type into metadata map
+                    field.metadata.insert("logicalType".into(), logical.into());
+                }
+                (None, _) => {}
+            }
+
+            if !t.attributes.additional.is_empty() {
+                for (k, v) in &t.attributes.additional {
+                    field.metadata.insert(k.to_string(), v.to_string());
+                }
+            }
+            Ok(field)
+        }
+    }
+}
diff --git a/arrow-avro/src/compression.rs b/arrow-avro/src/compression.rs
new file mode 100644
index 000000000000..c5c7a6dabc33
--- /dev/null
+++ b/arrow-avro/src/compression.rs
@@ -0,0 +1,83 @@
+// 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.
+
+use arrow_schema::ArrowError;
+use flate2::read;
+use std::io;
+use std::io::Read;
+
+/// The metadata key used for storing the JSON encoded [`CompressionCodec`]
+pub const CODEC_METADATA_KEY: &str = "avro.codec";
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum CompressionCodec {
+    Deflate,
+    Snappy,
+    ZStandard,
+}
+
+impl CompressionCodec {
+    pub(crate) fn decompress(&self, block: &[u8]) -> Result<Vec<u8>, ArrowError> {
+        match self {
+            #[cfg(feature = "deflate")]
+            CompressionCodec::Deflate => {
+                let mut decoder = read::DeflateDecoder::new(block);
+                let mut out = Vec::new();
+                decoder.read_to_end(&mut out)?;
+                Ok(out)
+            }
+            #[cfg(not(feature = "deflate"))]
+            CompressionCodec::Deflate => Err(ArrowError::ParseError(
+                "Deflate codec requires deflate feature".to_string(),
+            )),
+            #[cfg(feature = "snappy")]
+            CompressionCodec::Snappy => {
+                // Each compressed block is followed by the 4-byte, big-endian CRC32
+                // checksum of the uncompressed data in the block.
+                let crc = &block[block.len() - 4..];
+                let block = &block[..block.len() - 4];
+
+                let mut decoder = snap::raw::Decoder::new();
+                let decoded = decoder
+                    .decompress_vec(block)
+                    .map_err(|e| ArrowError::ExternalError(Box::new(e)))?;
+
+                let checksum = crc::Crc::<u32>::new(&crc::CRC_32_ISO_HDLC).checksum(&decoded);
+                if checksum != u32::from_be_bytes(crc.try_into().unwrap()) {
+                    return Err(ArrowError::ParseError("Snappy CRC mismatch".to_string()));
+                }
+                Ok(decoded)
+            }
+            #[cfg(not(feature = "snappy"))]
+            CompressionCodec::Snappy => Err(ArrowError::ParseError(
+                "Snappy codec requires snappy feature".to_string(),
+            )),
+
+            #[cfg(feature = "zstd")]
+            CompressionCodec::ZStandard => {
+                let mut decoder = zstd::Decoder::new(block)?;
+                let mut out = Vec::new();
+                decoder.read_to_end(&mut out)?;
+                Ok(out)
+            }
+            #[cfg(not(feature = "zstd"))]
+            CompressionCodec::ZStandard => Err(ArrowError::ParseError(
+                "ZStandard codec requires zstd feature".to_string(),
+            )),
+        }
+    }
+}
diff --git a/arrow-avro/src/lib.rs b/arrow-avro/src/lib.rs
new file mode 100644
index 000000000000..f74edd7e9260
--- /dev/null
+++ b/arrow-avro/src/lib.rs
@@ -0,0 +1,40 @@
+// 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.
+
+//! Convert data to / from the [Apache Arrow] memory format and [Apache Avro]
+//!
+//! [Apache Arrow]: https://arrow.apache.org
+//! [Apache Avro]: https://avro.apache.org/
+
+#![allow(unused)] // Temporary
+
+pub mod reader;
+mod schema;
+
+mod compression;
+
+mod codec;
+
+#[cfg(test)]
+mod test_util {
+    pub fn arrow_test_data(path: &str) -> String {
+        match std::env::var("ARROW_TEST_DATA") {
+            Ok(dir) => format!("{dir}/{path}"),
+            Err(_) => format!("../testing/data/{path}"),
+        }
+    }
+}
diff --git a/arrow-avro/src/reader/block.rs b/arrow-avro/src/reader/block.rs
new file mode 100644
index 000000000000..479f0ef90909
--- /dev/null
+++ b/arrow-avro/src/reader/block.rs
@@ -0,0 +1,141 @@
+// 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.
+
+//! Decoder for [`Block`]
+
+use crate::reader::vlq::VLQDecoder;
+use arrow_schema::ArrowError;
+
+/// A file data block
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#object-container-files>
+#[derive(Debug, Default)]
+pub struct Block {
+    /// The number of objects in this block
+    pub count: usize,
+    /// The serialized objects within this block
+    pub data: Vec<u8>,
+    /// The sync marker
+    pub sync: [u8; 16],
+}
+
+/// A decoder for [`Block`]
+#[derive(Debug)]
+pub struct BlockDecoder {
+    state: BlockDecoderState,
+    in_progress: Block,
+    vlq_decoder: VLQDecoder,
+    bytes_remaining: usize,
+}
+
+#[derive(Debug)]
+enum BlockDecoderState {
+    Count,
+    Size,
+    Data,
+    Sync,
+    Finished,
+}
+
+impl Default for BlockDecoder {
+    fn default() -> Self {
+        Self {
+            state: BlockDecoderState::Count,
+            in_progress: Default::default(),
+            vlq_decoder: Default::default(),
+            bytes_remaining: 0,
+        }
+    }
+}
+
+impl BlockDecoder {
+    /// Parse [`Block`] from `buf`, returning the number of bytes read
+    ///
+    /// This method can be called multiple times with consecutive chunks of data, allowing
+    /// integration with chunked IO systems like [`BufRead::fill_buf`]
+    ///
+    /// All errors should be considered fatal, and decoding aborted
+    ///
+    /// Once an entire [`Block`] has been decoded this method will not read any further
+    /// input bytes, until [`Self::flush`] is called. Afterwards [`Self::decode`]
+    /// can then be used again to read the next block, if any
+    ///
+    /// [`BufRead::fill_buf`]: std::io::BufRead::fill_buf
+    pub fn decode(&mut self, mut buf: &[u8]) -> Result<usize, ArrowError> {
+        let max_read = buf.len();
+        while !buf.is_empty() {
+            match self.state {
+                BlockDecoderState::Count => {
+                    if let Some(c) = self.vlq_decoder.long(&mut buf) {
+                        self.in_progress.count = c.try_into().map_err(|_| {
+                            ArrowError::ParseError(format!(
+                                "Block count cannot be negative, got {c}"
+                            ))
+                        })?;
+
+                        self.state = BlockDecoderState::Size;
+                    }
+                }
+                BlockDecoderState::Size => {
+                    if let Some(c) = self.vlq_decoder.long(&mut buf) {
+                        self.bytes_remaining = c.try_into().map_err(|_| {
+                            ArrowError::ParseError(format!(
+                                "Block size cannot be negative, got {c}"
+                            ))
+                        })?;
+
+                        self.in_progress.data.reserve(self.bytes_remaining);
+                        self.state = BlockDecoderState::Data;
+                    }
+                }
+                BlockDecoderState::Data => {
+                    let to_read = self.bytes_remaining.min(buf.len());
+                    self.in_progress.data.extend_from_slice(&buf[..to_read]);
+                    buf = &buf[to_read..];
+                    self.bytes_remaining -= to_read;
+                    if self.bytes_remaining == 0 {
+                        self.bytes_remaining = 16;
+                        self.state = BlockDecoderState::Sync;
+                    }
+                }
+                BlockDecoderState::Sync => {
+                    let to_decode = buf.len().min(self.bytes_remaining);
+                    let write = &mut self.in_progress.sync[16 - to_decode..];
+                    write[..to_decode].copy_from_slice(&buf[..to_decode]);
+                    self.bytes_remaining -= to_decode;
+                    buf = &buf[to_decode..];
+                    if self.bytes_remaining == 0 {
+                        self.state = BlockDecoderState::Finished;
+                    }
+                }
+                BlockDecoderState::Finished => return Ok(max_read - buf.len()),
+            }
+        }
+        Ok(max_read)
+    }
+
+    /// Flush this decoder returning the parsed [`Block`] if any
+    pub fn flush(&mut self) -> Option<Block> {
+        match self.state {
+            BlockDecoderState::Finished => {
+                self.state = BlockDecoderState::Count;
+                Some(std::mem::take(&mut self.in_progress))
+            }
+            _ => None,
+        }
+    }
+}
diff --git a/arrow-avro/src/reader/header.rs b/arrow-avro/src/reader/header.rs
new file mode 100644
index 000000000000..19d48d1f89a1
--- /dev/null
+++ b/arrow-avro/src/reader/header.rs
@@ -0,0 +1,345 @@
+// 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.
+
+//! Decoder for [`Header`]
+
+use crate::compression::{CompressionCodec, CODEC_METADATA_KEY};
+use crate::reader::vlq::VLQDecoder;
+use crate::schema::Schema;
+use arrow_schema::ArrowError;
+
+#[derive(Debug)]
+enum HeaderDecoderState {
+    /// Decoding the [`MAGIC`] prefix
+    Magic,
+    /// Decoding a block count
+    BlockCount,
+    /// Decoding a block byte length
+    BlockLen,
+    /// Decoding a key length
+    KeyLen,
+    /// Decoding a key string
+    Key,
+    /// Decoding a value length
+    ValueLen,
+    /// Decoding a value payload
+    Value,
+    /// Decoding sync marker
+    Sync,
+    /// Finished decoding
+    Finished,
+}
+
+/// A decoded header for an [Object Container File](https://avro.apache.org/docs/1.11.1/specification/#object-container-files)
+#[derive(Debug, Clone)]
+pub struct Header {
+    meta_offsets: Vec<usize>,
+    meta_buf: Vec<u8>,
+    sync: [u8; 16],
+}
+
+impl Header {
+    /// Returns an iterator over the meta keys in this header
+    pub fn metadata(&self) -> impl Iterator<Item = (&[u8], &[u8])> {
+        let mut last = 0;
+        self.meta_offsets.chunks_exact(2).map(move |w| {
+            let start = last;
+            last = w[1];
+            (&self.meta_buf[start..w[0]], &self.meta_buf[w[0]..w[1]])
+        })
+    }
+
+    /// Returns the value for a given metadata key if present
+    pub fn get(&self, key: impl AsRef<[u8]>) -> Option<&[u8]> {
+        self.metadata()
+            .find_map(|(k, v)| (k == key.as_ref()).then_some(v))
+    }
+
+    /// Returns the sync token for this file
+    pub fn sync(&self) -> [u8; 16] {
+        self.sync
+    }
+
+    /// Returns the [`CompressionCodec`] if any
+    pub fn compression(&self) -> Result<Option<CompressionCodec>, ArrowError> {
+        let v = self.get(CODEC_METADATA_KEY);
+
+        match v {
+            None | Some(b"null") => Ok(None),
+            Some(b"deflate") => Ok(Some(CompressionCodec::Deflate)),
+            Some(b"snappy") => Ok(Some(CompressionCodec::Snappy)),
+            Some(b"zstandard") => Ok(Some(CompressionCodec::ZStandard)),
+            Some(v) => Err(ArrowError::ParseError(format!(
+                "Unrecognized compression codec \'{}\'",
+                String::from_utf8_lossy(v)
+            ))),
+        }
+    }
+}
+
+/// A decoder for [`Header`]
+///
+/// The avro file format does not encode the length of the header, and so it
+/// is necessary to provide a push-based decoder that can be used with streams
+#[derive(Debug)]
+pub struct HeaderDecoder {
+    state: HeaderDecoderState,
+    vlq_decoder: VLQDecoder,
+
+    /// The end offsets of strings in `meta_buf`
+    meta_offsets: Vec<usize>,
+    /// The raw binary data of the metadata map
+    meta_buf: Vec<u8>,
+
+    /// The decoded sync marker
+    sync_marker: [u8; 16],
+
+    /// The number of remaining tuples in the current block
+    tuples_remaining: usize,
+    /// The number of bytes remaining in the current string/bytes payload
+    bytes_remaining: usize,
+}
+
+impl Default for HeaderDecoder {
+    fn default() -> Self {
+        Self {
+            state: HeaderDecoderState::Magic,
+            meta_offsets: vec![],
+            meta_buf: vec![],
+            sync_marker: [0; 16],
+            vlq_decoder: Default::default(),
+            tuples_remaining: 0,
+            bytes_remaining: MAGIC.len(),
+        }
+    }
+}
+
+const MAGIC: &[u8; 4] = b"Obj\x01";
+
+impl HeaderDecoder {
+    /// Parse [`Header`] from `buf`, returning the number of bytes read
+    ///
+    /// This method can be called multiple times with consecutive chunks of data, allowing
+    /// integration with chunked IO systems like [`BufRead::fill_buf`]
+    ///
+    /// All errors should be considered fatal, and decoding aborted
+    ///
+    /// Once the entire [`Header`] has been decoded this method will not read any further
+    /// input bytes, and the header can be obtained with [`Self::flush`]
+    ///
+    /// [`BufRead::fill_buf`]: std::io::BufRead::fill_buf
+    pub fn decode(&mut self, mut buf: &[u8]) -> Result<usize, ArrowError> {
+        let max_read = buf.len();
+        while !buf.is_empty() {
+            match self.state {
+                HeaderDecoderState::Magic => {
+                    let remaining = &MAGIC[MAGIC.len() - self.bytes_remaining..];
+                    let to_decode = buf.len().min(remaining.len());
+                    if !buf.starts_with(&remaining[..to_decode]) {
+                        return Err(ArrowError::ParseError("Incorrect avro magic".to_string()));
+                    }
+                    self.bytes_remaining -= to_decode;
+                    buf = &buf[to_decode..];
+                    if self.bytes_remaining == 0 {
+                        self.state = HeaderDecoderState::BlockCount;
+                    }
+                }
+                HeaderDecoderState::BlockCount => {
+                    if let Some(block_count) = self.vlq_decoder.long(&mut buf) {
+                        match block_count.try_into() {
+                            Ok(0) => {
+                                self.state = HeaderDecoderState::Sync;
+                                self.bytes_remaining = 16;
+                            }
+                            Ok(remaining) => {
+                                self.tuples_remaining = remaining;
+                                self.state = HeaderDecoderState::KeyLen;
+                            }
+                            Err(_) => {
+                                self.tuples_remaining = block_count.unsigned_abs() as _;
+                                self.state = HeaderDecoderState::BlockLen;
+                            }
+                        }
+                    }
+                }
+                HeaderDecoderState::BlockLen => {
+                    if self.vlq_decoder.long(&mut buf).is_some() {
+                        self.state = HeaderDecoderState::KeyLen
+                    }
+                }
+                HeaderDecoderState::Key => {
+                    let to_read = self.bytes_remaining.min(buf.len());
+                    self.meta_buf.extend_from_slice(&buf[..to_read]);
+                    self.bytes_remaining -= to_read;
+                    buf = &buf[to_read..];
+                    if self.bytes_remaining == 0 {
+                        self.meta_offsets.push(self.meta_buf.len());
+                        self.state = HeaderDecoderState::ValueLen;
+                    }
+                }
+                HeaderDecoderState::Value => {
+                    let to_read = self.bytes_remaining.min(buf.len());
+                    self.meta_buf.extend_from_slice(&buf[..to_read]);
+                    self.bytes_remaining -= to_read;
+                    buf = &buf[to_read..];
+                    if self.bytes_remaining == 0 {
+                        self.meta_offsets.push(self.meta_buf.len());
+
+                        self.tuples_remaining -= 1;
+                        match self.tuples_remaining {
+                            0 => self.state = HeaderDecoderState::BlockCount,
+                            _ => self.state = HeaderDecoderState::KeyLen,
+                        }
+                    }
+                }
+                HeaderDecoderState::KeyLen => {
+                    if let Some(len) = self.vlq_decoder.long(&mut buf) {
+                        self.bytes_remaining = len as _;
+                        self.state = HeaderDecoderState::Key;
+                    }
+                }
+                HeaderDecoderState::ValueLen => {
+                    if let Some(len) = self.vlq_decoder.long(&mut buf) {
+                        self.bytes_remaining = len as _;
+                        self.state = HeaderDecoderState::Value;
+                    }
+                }
+                HeaderDecoderState::Sync => {
+                    let to_decode = buf.len().min(self.bytes_remaining);
+                    let write = &mut self.sync_marker[16 - to_decode..];
+                    write[..to_decode].copy_from_slice(&buf[..to_decode]);
+                    self.bytes_remaining -= to_decode;
+                    buf = &buf[to_decode..];
+                    if self.bytes_remaining == 0 {
+                        self.state = HeaderDecoderState::Finished;
+                    }
+                }
+                HeaderDecoderState::Finished => return Ok(max_read - buf.len()),
+            }
+        }
+        Ok(max_read)
+    }
+
+    /// Flush this decoder returning the parsed [`Header`] if any
+    pub fn flush(&mut self) -> Option<Header> {
+        match self.state {
+            HeaderDecoderState::Finished => {
+                self.state = HeaderDecoderState::Magic;
+                Some(Header {
+                    meta_offsets: std::mem::take(&mut self.meta_offsets),
+                    meta_buf: std::mem::take(&mut self.meta_buf),
+                    sync: self.sync_marker,
+                })
+            }
+            _ => None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::codec::{AvroDataType, AvroField};
+    use crate::reader::read_header;
+    use crate::schema::SCHEMA_METADATA_KEY;
+    use crate::test_util::arrow_test_data;
+    use arrow_schema::{DataType, Field, Fields, TimeUnit};
+    use std::fs::File;
+    use std::io::{BufRead, BufReader};
+
+    #[test]
+    fn test_header_decode() {
+        let mut decoder = HeaderDecoder::default();
+        for m in MAGIC {
+            decoder.decode(std::slice::from_ref(m)).unwrap();
+        }
+
+        let mut decoder = HeaderDecoder::default();
+        assert_eq!(decoder.decode(MAGIC).unwrap(), 4);
+
+        let mut decoder = HeaderDecoder::default();
+        decoder.decode(b"Ob").unwrap();
+        let err = decoder.decode(b"s").unwrap_err().to_string();
+        assert_eq!(err, "Parser error: Incorrect avro magic");
+    }
+
+    fn decode_file(file: &str) -> Header {
+        let file = File::open(file).unwrap();
+        read_header(BufReader::with_capacity(100, file)).unwrap()
+    }
+
+    #[test]
+    fn test_header() {
+        let header = decode_file(&arrow_test_data("avro/alltypes_plain.avro"));
+        let schema_json = header.get(SCHEMA_METADATA_KEY).unwrap();
+        let expected = br#"{"type":"record","name":"topLevelRecord","fields":[{"name":"id","type":["int","null"]},{"name":"bool_col","type":["boolean","null"]},{"name":"tinyint_col","type":["int","null"]},{"name":"smallint_col","type":["int","null"]},{"name":"int_col","type":["int","null"]},{"name":"bigint_col","type":["long","null"]},{"name":"float_col","type":["float","null"]},{"name":"double_col","type":["double","null"]},{"name":"date_string_col","type":["bytes","null"]},{"name":"string_col","type":["bytes","null"]},{"name":"timestamp_col","type":[{"type":"long","logicalType":"timestamp-micros"},"null"]}]}"#;
+        assert_eq!(schema_json, expected);
+        let schema: Schema<'_> = serde_json::from_slice(schema_json).unwrap();
+        let field = AvroField::try_from(&schema).unwrap();
+
+        assert_eq!(
+            field.field(),
+            Field::new(
+                "topLevelRecord",
+                DataType::Struct(Fields::from(vec![
+                    Field::new("id", DataType::Int32, true),
+                    Field::new("bool_col", DataType::Boolean, true),
+                    Field::new("tinyint_col", DataType::Int32, true),
+                    Field::new("smallint_col", DataType::Int32, true),
+                    Field::new("int_col", DataType::Int32, true),
+                    Field::new("bigint_col", DataType::Int64, true),
+                    Field::new("float_col", DataType::Float32, true),
+                    Field::new("double_col", DataType::Float64, true),
+                    Field::new("date_string_col", DataType::Binary, true),
+                    Field::new("string_col", DataType::Binary, true),
+                    Field::new(
+                        "timestamp_col",
+                        DataType::Timestamp(TimeUnit::Microsecond, Some("+00:00".into())),
+                        true
+                    ),
+                ])),
+                false
+            )
+        );
+
+        assert_eq!(
+            u128::from_le_bytes(header.sync()),
+            226966037233754408753420635932530907102
+        );
+
+        let header = decode_file(&arrow_test_data("avro/fixed_length_decimal.avro"));
+
+        let meta: Vec<_> = header
+            .metadata()
+            .map(|(k, _)| std::str::from_utf8(k).unwrap())
+            .collect();
+
+        assert_eq!(
+            meta,
+            &["avro.schema", "org.apache.spark.version", "avro.codec"]
+        );
+
+        let schema_json = header.get(SCHEMA_METADATA_KEY).unwrap();
+        let expected = br#"{"type":"record","name":"topLevelRecord","fields":[{"name":"value","type":[{"type":"fixed","name":"fixed","namespace":"topLevelRecord.value","size":11,"logicalType":"decimal","precision":25,"scale":2},"null"]}]}"#;
+        assert_eq!(schema_json, expected);
+        let _schema: Schema<'_> = serde_json::from_slice(schema_json).unwrap();
+        assert_eq!(
+            u128::from_le_bytes(header.sync()),
+            325166208089902833952788552656412487328
+        );
+    }
+}
diff --git a/arrow-avro/src/reader/mod.rs b/arrow-avro/src/reader/mod.rs
new file mode 100644
index 000000000000..0151db7f855a
--- /dev/null
+++ b/arrow-avro/src/reader/mod.rs
@@ -0,0 +1,107 @@
+// 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.
+
+//! Read Avro data to Arrow
+
+use crate::reader::block::{Block, BlockDecoder};
+use crate::reader::header::{Header, HeaderDecoder};
+use arrow_schema::ArrowError;
+use std::io::BufRead;
+
+mod header;
+
+mod block;
+
+mod vlq;
+
+/// Read a [`Header`] from the provided [`BufRead`]
+fn read_header<R: BufRead>(mut reader: R) -> Result<Header, ArrowError> {
+    let mut decoder = HeaderDecoder::default();
+    loop {
+        let buf = reader.fill_buf()?;
+        if buf.is_empty() {
+            break;
+        }
+        let read = buf.len();
+        let decoded = decoder.decode(buf)?;
+        reader.consume(decoded);
+        if decoded != read {
+            break;
+        }
+    }
+
+    decoder
+        .flush()
+        .ok_or_else(|| ArrowError::ParseError("Unexpected EOF".to_string()))
+}
+
+/// Return an iterator of [`Block`] from the provided [`BufRead`]
+fn read_blocks<R: BufRead>(mut reader: R) -> impl Iterator<Item = Result<Block, ArrowError>> {
+    let mut decoder = BlockDecoder::default();
+
+    let mut try_next = move || {
+        loop {
+            let buf = reader.fill_buf()?;
+            if buf.is_empty() {
+                break;
+            }
+            let read = buf.len();
+            let decoded = decoder.decode(buf)?;
+            reader.consume(decoded);
+            if decoded != read {
+                break;
+            }
+        }
+        Ok(decoder.flush())
+    };
+    std::iter::from_fn(move || try_next().transpose())
+}
+
+#[cfg(test)]
+mod test {
+    use crate::compression::CompressionCodec;
+    use crate::reader::{read_blocks, read_header};
+    use crate::test_util::arrow_test_data;
+    use std::fs::File;
+    use std::io::BufReader;
+
+    #[test]
+    fn test_mux() {
+        let files = [
+            "avro/alltypes_plain.avro",
+            "avro/alltypes_plain.snappy.avro",
+            "avro/alltypes_plain.zstandard.avro",
+            "avro/alltypes_nulls_plain.avro",
+        ];
+
+        for file in files {
+            println!("file: {file}");
+            let file = File::open(arrow_test_data(file)).unwrap();
+            let mut reader = BufReader::new(file);
+            let header = read_header(&mut reader).unwrap();
+            let compression = header.compression().unwrap();
+            println!("compression: {compression:?}");
+            for result in read_blocks(reader) {
+                let block = result.unwrap();
+                assert_eq!(block.sync, header.sync());
+                if let Some(c) = compression {
+                    c.decompress(&block.data).unwrap();
+                }
+            }
+        }
+    }
+}
diff --git a/arrow-avro/src/reader/vlq.rs b/arrow-avro/src/reader/vlq.rs
new file mode 100644
index 000000000000..80f1c60eec7d
--- /dev/null
+++ b/arrow-avro/src/reader/vlq.rs
@@ -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.
+
+/// Decoder for zig-zag encoded variable length (VLW) integers
+///
+/// See also:
+/// <https://avro.apache.org/docs/1.11.1/specification/#primitive-types-1>
+/// <https://protobuf.dev/programming-guides/encoding/#varints>
+#[derive(Debug, Default)]
+pub struct VLQDecoder {
+    /// Scratch space for decoding VLQ integers
+    in_progress: u64,
+    shift: u32,
+}
+
+impl VLQDecoder {
+    /// Decode a signed long from `buf`
+    pub fn long(&mut self, buf: &mut &[u8]) -> Option<i64> {
+        while let Some(byte) = buf.first().copied() {
+            *buf = &buf[1..];
+            self.in_progress |= ((byte & 0x7F) as u64) << self.shift;
+            self.shift += 7;
+            if byte & 0x80 == 0 {
+                let val = self.in_progress;
+                self.in_progress = 0;
+                self.shift = 0;
+                return Some((val >> 1) as i64 ^ -((val & 1) as i64));
+            }
+        }
+        None
+    }
+}
diff --git a/arrow-avro/src/schema.rs b/arrow-avro/src/schema.rs
new file mode 100644
index 000000000000..6707f8137c9b
--- /dev/null
+++ b/arrow-avro/src/schema.rs
@@ -0,0 +1,512 @@
+// 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.
+
+use serde::{Deserialize, Serialize};
+use std::collections::HashMap;
+
+/// The metadata key used for storing the JSON encoded [`Schema`]
+pub const SCHEMA_METADATA_KEY: &str = "avro.schema";
+
+/// Either a [`PrimitiveType`] or a reference to a previously defined named type
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#names>
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum TypeName<'a> {
+    Primitive(PrimitiveType),
+    Ref(&'a str),
+}
+
+/// A primitive type
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#primitive-types>
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub enum PrimitiveType {
+    Null,
+    Boolean,
+    Int,
+    Long,
+    Float,
+    Double,
+    Bytes,
+    String,
+}
+
+/// Additional attributes within a [`Schema`]
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#schema-declaration>
+#[derive(Debug, Clone, PartialEq, Eq, Default, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Attributes<'a> {
+    /// A logical type name
+    ///
+    /// <https://avro.apache.org/docs/1.11.1/specification/#logical-types>
+    #[serde(default)]
+    pub logical_type: Option<&'a str>,
+
+    /// Additional JSON attributes
+    #[serde(flatten)]
+    pub additional: HashMap<&'a str, serde_json::Value>,
+}
+
+impl<'a> Attributes<'a> {
+    /// Returns the field metadata for this [`Attributes`]
+    pub(crate) fn field_metadata(&self) -> HashMap<String, String> {
+        self.additional
+            .iter()
+            .map(|(k, v)| (k.to_string(), v.to_string()))
+            .collect()
+    }
+}
+
+/// A type definition that is not a variant of [`ComplexType`]
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Type<'a> {
+    #[serde(borrow)]
+    pub r#type: TypeName<'a>,
+    #[serde(flatten)]
+    pub attributes: Attributes<'a>,
+}
+
+/// An Avro schema
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum Schema<'a> {
+    #[serde(borrow)]
+    TypeName(TypeName<'a>),
+    #[serde(borrow)]
+    Union(Vec<Schema<'a>>),
+    #[serde(borrow)]
+    Complex(ComplexType<'a>),
+    #[serde(borrow)]
+    Type(Type<'a>),
+}
+
+/// A complex type
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#complex-types>
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "camelCase")]
+pub enum ComplexType<'a> {
+    #[serde(borrow)]
+    Record(Record<'a>),
+    #[serde(borrow)]
+    Enum(Enum<'a>),
+    #[serde(borrow)]
+    Array(Array<'a>),
+    #[serde(borrow)]
+    Map(Map<'a>),
+    #[serde(borrow)]
+    Fixed(Fixed<'a>),
+}
+
+/// A record
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#schema-record>
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Record<'a> {
+    #[serde(borrow)]
+    pub name: &'a str,
+    #[serde(borrow, default)]
+    pub namespace: Option<&'a str>,
+    #[serde(borrow, default)]
+    pub doc: Option<&'a str>,
+    #[serde(borrow, default)]
+    pub aliases: Vec<&'a str>,
+    #[serde(borrow)]
+    pub fields: Vec<Field<'a>>,
+    #[serde(flatten)]
+    pub attributes: Attributes<'a>,
+}
+
+/// A field within a [`Record`]
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Field<'a> {
+    #[serde(borrow)]
+    pub name: &'a str,
+    #[serde(borrow, default)]
+    pub doc: Option<&'a str>,
+    #[serde(borrow)]
+    pub r#type: Schema<'a>,
+    #[serde(borrow, default)]
+    pub default: Option<&'a str>,
+}
+
+/// An enumeration
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#enums>
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Enum<'a> {
+    #[serde(borrow)]
+    pub name: &'a str,
+    #[serde(borrow, default)]
+    pub namespace: Option<&'a str>,
+    #[serde(borrow, default)]
+    pub doc: Option<&'a str>,
+    #[serde(borrow, default)]
+    pub aliases: Vec<&'a str>,
+    #[serde(borrow)]
+    pub symbols: Vec<&'a str>,
+    #[serde(borrow, default)]
+    pub default: Option<&'a str>,
+    #[serde(flatten)]
+    pub attributes: Attributes<'a>,
+}
+
+/// An array
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#arrays>
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Array<'a> {
+    #[serde(borrow)]
+    pub items: Box<Schema<'a>>,
+    #[serde(flatten)]
+    pub attributes: Attributes<'a>,
+}
+
+/// A map
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#maps>
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Map<'a> {
+    #[serde(borrow)]
+    pub values: Box<Schema<'a>>,
+    #[serde(flatten)]
+    pub attributes: Attributes<'a>,
+}
+
+/// A fixed length binary array
+///
+/// <https://avro.apache.org/docs/1.11.1/specification/#fixed>
+#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
+pub struct Fixed<'a> {
+    #[serde(borrow)]
+    pub name: &'a str,
+    #[serde(borrow, default)]
+    pub namespace: Option<&'a str>,
+    #[serde(borrow, default)]
+    pub aliases: Vec<&'a str>,
+    pub size: usize,
+    #[serde(flatten)]
+    pub attributes: Attributes<'a>,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::codec::{AvroDataType, AvroField};
+    use arrow_schema::{DataType, Fields, TimeUnit};
+    use serde_json::json;
+
+    #[test]
+    fn test_deserialize() {
+        let t: Schema = serde_json::from_str("\"string\"").unwrap();
+        assert_eq!(
+            t,
+            Schema::TypeName(TypeName::Primitive(PrimitiveType::String))
+        );
+
+        let t: Schema = serde_json::from_str("[\"int\", \"null\"]").unwrap();
+        assert_eq!(
+            t,
+            Schema::Union(vec![
+                Schema::TypeName(TypeName::Primitive(PrimitiveType::Int)),
+                Schema::TypeName(TypeName::Primitive(PrimitiveType::Null)),
+            ])
+        );
+
+        let t: Type = serde_json::from_str(
+            r#"{
+                   "type":"long",
+                   "logicalType":"timestamp-micros"
+                }"#,
+        )
+        .unwrap();
+
+        let timestamp = Type {
+            r#type: TypeName::Primitive(PrimitiveType::Long),
+            attributes: Attributes {
+                logical_type: Some("timestamp-micros"),
+                additional: Default::default(),
+            },
+        };
+
+        assert_eq!(t, timestamp);
+
+        let t: ComplexType = serde_json::from_str(
+            r#"{
+                   "type":"fixed",
+                   "name":"fixed",
+                   "namespace":"topLevelRecord.value",
+                   "size":11,
+                   "logicalType":"decimal",
+                   "precision":25,
+                   "scale":2
+                }"#,
+        )
+        .unwrap();
+
+        let decimal = ComplexType::Fixed(Fixed {
+            name: "fixed",
+            namespace: Some("topLevelRecord.value"),
+            aliases: vec![],
+            size: 11,
+            attributes: Attributes {
+                logical_type: Some("decimal"),
+                additional: vec![("precision", json!(25)), ("scale", json!(2))]
+                    .into_iter()
+                    .collect(),
+            },
+        });
+
+        assert_eq!(t, decimal);
+
+        let schema: Schema = serde_json::from_str(
+            r#"{
+               "type":"record",
+               "name":"topLevelRecord",
+               "fields":[
+                  {
+                     "name":"value",
+                     "type":[
+                        {
+                           "type":"fixed",
+                           "name":"fixed",
+                           "namespace":"topLevelRecord.value",
+                           "size":11,
+                           "logicalType":"decimal",
+                           "precision":25,
+                           "scale":2
+                        },
+                        "null"
+                     ]
+                  }
+               ]
+            }"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            schema,
+            Schema::Complex(ComplexType::Record(Record {
+                name: "topLevelRecord",
+                namespace: None,
+                doc: None,
+                aliases: vec![],
+                fields: vec![Field {
+                    name: "value",
+                    doc: None,
+                    r#type: Schema::Union(vec![
+                        Schema::Complex(decimal),
+                        Schema::TypeName(TypeName::Primitive(PrimitiveType::Null)),
+                    ]),
+                    default: None,
+                },],
+                attributes: Default::default(),
+            }))
+        );
+
+        let schema: Schema = serde_json::from_str(
+            r#"{
+                  "type": "record",
+                  "name": "LongList",
+                  "aliases": ["LinkedLongs"],
+                  "fields" : [
+                    {"name": "value", "type": "long"},
+                    {"name": "next", "type": ["null", "LongList"]}
+                  ]
+                }"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            schema,
+            Schema::Complex(ComplexType::Record(Record {
+                name: "LongList",
+                namespace: None,
+                doc: None,
+                aliases: vec!["LinkedLongs"],
+                fields: vec![
+                    Field {
+                        name: "value",
+                        doc: None,
+                        r#type: Schema::TypeName(TypeName::Primitive(PrimitiveType::Long)),
+                        default: None,
+                    },
+                    Field {
+                        name: "next",
+                        doc: None,
+                        r#type: Schema::Union(vec![
+                            Schema::TypeName(TypeName::Primitive(PrimitiveType::Null)),
+                            Schema::TypeName(TypeName::Ref("LongList")),
+                        ]),
+                        default: None,
+                    }
+                ],
+                attributes: Attributes::default(),
+            }))
+        );
+
+        // Recursive schema are not supported
+        let err = AvroField::try_from(&schema).unwrap_err().to_string();
+        assert_eq!(err, "Parser error: Failed to resolve .LongList");
+
+        let schema: Schema = serde_json::from_str(
+            r#"{
+               "type":"record",
+               "name":"topLevelRecord",
+               "fields":[
+                  {
+                     "name":"id",
+                     "type":[
+                        "int",
+                        "null"
+                     ]
+                  },
+                  {
+                     "name":"timestamp_col",
+                     "type":[
+                        {
+                           "type":"long",
+                           "logicalType":"timestamp-micros"
+                        },
+                        "null"
+                     ]
+                  }
+               ]
+            }"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            schema,
+            Schema::Complex(ComplexType::Record(Record {
+                name: "topLevelRecord",
+                namespace: None,
+                doc: None,
+                aliases: vec![],
+                fields: vec![
+                    Field {
+                        name: "id",
+                        doc: None,
+                        r#type: Schema::Union(vec![
+                            Schema::TypeName(TypeName::Primitive(PrimitiveType::Int)),
+                            Schema::TypeName(TypeName::Primitive(PrimitiveType::Null)),
+                        ]),
+                        default: None,
+                    },
+                    Field {
+                        name: "timestamp_col",
+                        doc: None,
+                        r#type: Schema::Union(vec![
+                            Schema::Type(timestamp),
+                            Schema::TypeName(TypeName::Primitive(PrimitiveType::Null)),
+                        ]),
+                        default: None,
+                    }
+                ],
+                attributes: Default::default(),
+            }))
+        );
+        let codec = AvroField::try_from(&schema).unwrap();
+        assert_eq!(
+            codec.field(),
+            arrow_schema::Field::new(
+                "topLevelRecord",
+                DataType::Struct(Fields::from(vec![
+                    arrow_schema::Field::new("id", DataType::Int32, true),
+                    arrow_schema::Field::new(
+                        "timestamp_col",
+                        DataType::Timestamp(TimeUnit::Microsecond, Some("+00:00".into())),
+                        true
+                    ),
+                ])),
+                false
+            )
+        );
+
+        let schema: Schema = serde_json::from_str(
+            r#"{
+                  "type": "record",
+                  "name": "HandshakeRequest", "namespace":"org.apache.avro.ipc",
+                  "fields": [
+                    {"name": "clientHash", "type": {"type": "fixed", "name": "MD5", "size": 16}},
+                    {"name": "clientProtocol", "type": ["null", "string"]},
+                    {"name": "serverHash", "type": "MD5"},
+                    {"name": "meta", "type": ["null", {"type": "map", "values": "bytes"}]}
+                  ]
+            }"#,
+        )
+        .unwrap();
+
+        assert_eq!(
+            schema,
+            Schema::Complex(ComplexType::Record(Record {
+                name: "HandshakeRequest",
+                namespace: Some("org.apache.avro.ipc"),
+                doc: None,
+                aliases: vec![],
+                fields: vec![
+                    Field {
+                        name: "clientHash",
+                        doc: None,
+                        r#type: Schema::Complex(ComplexType::Fixed(Fixed {
+                            name: "MD5",
+                            namespace: None,
+                            aliases: vec![],
+                            size: 16,
+                            attributes: Default::default(),
+                        })),
+                        default: None,
+                    },
+                    Field {
+                        name: "clientProtocol",
+                        doc: None,
+                        r#type: Schema::Union(vec![
+                            Schema::TypeName(TypeName::Primitive(PrimitiveType::Null)),
+                            Schema::TypeName(TypeName::Primitive(PrimitiveType::String)),
+                        ]),
+                        default: None,
+                    },
+                    Field {
+                        name: "serverHash",
+                        doc: None,
+                        r#type: Schema::TypeName(TypeName::Ref("MD5")),
+                        default: None,
+                    },
+                    Field {
+                        name: "meta",
+                        doc: None,
+                        r#type: Schema::Union(vec![
+                            Schema::TypeName(TypeName::Primitive(PrimitiveType::Null)),
+                            Schema::Complex(ComplexType::Map(Map {
+                                values: Box::new(Schema::TypeName(TypeName::Primitive(
+                                    PrimitiveType::Bytes
+                                ))),
+                                attributes: Default::default(),
+                            })),
+                        ]),
+                        default: None,
+                    }
+                ],
+                attributes: Default::default(),
+            }))
+        );
+    }
+}
diff --git a/arrow-buffer/Cargo.toml b/arrow-buffer/Cargo.toml
new file mode 100644
index 000000000000..746045cc8dde
--- /dev/null
+++ b/arrow-buffer/Cargo.toml
@@ -0,0 +1,49 @@
+# 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]
+name = "arrow-buffer"
+version = { workspace = true }
+description = "Buffer abstractions for Apache Arrow"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_buffer"
+path = "src/lib.rs"
+bench = false
+
+[dependencies]
+bytes = { version = "1.4" }
+num = { version = "0.4", default-features = false, features = ["std"] }
+half = { version = "2.1", default-features = false }
+
+[dev-dependencies]
+criterion = { version = "0.5", default-features = false }
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
+
+[build-dependencies]
+
+[[bench]]
+name = "i256"
+harness = false
\ No newline at end of file
diff --git a/arrow-buffer/benches/i256.rs b/arrow-buffer/benches/i256.rs
new file mode 100644
index 000000000000..ebb45e793bd0
--- /dev/null
+++ b/arrow-buffer/benches/i256.rs
@@ -0,0 +1,86 @@
+// 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.
+
+use arrow_buffer::i256;
+use criterion::*;
+use rand::rngs::StdRng;
+use rand::{Rng, SeedableRng};
+use std::str::FromStr;
+
+const SIZE: usize = 1024;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let numbers = vec![
+        i256::ZERO,
+        i256::ONE,
+        i256::MINUS_ONE,
+        i256::from_i128(1233456789),
+        i256::from_i128(-1233456789),
+        i256::from_i128(i128::MAX),
+        i256::from_i128(i128::MIN),
+        i256::MIN,
+        i256::MAX,
+    ];
+
+    for number in numbers {
+        let t = black_box(number.to_string());
+        c.bench_function(&format!("i256_parse({t})"), |b| {
+            b.iter(|| i256::from_str(&t).unwrap());
+        });
+    }
+
+    let mut rng = StdRng::seed_from_u64(42);
+
+    let numerators: Vec<_> = (0..SIZE)
+        .map(|_| {
+            let high = rng.gen_range(1000..i128::MAX);
+            let low = rng.gen();
+            i256::from_parts(low, high)
+        })
+        .collect();
+
+    let divisors: Vec<_> = numerators
+        .iter()
+        .map(|n| {
+            let quotient = rng.gen_range(1..100_i32);
+            n.wrapping_div(i256::from(quotient))
+        })
+        .collect();
+
+    c.bench_function("i256_div_rem small quotient", |b| {
+        b.iter(|| {
+            for (n, d) in numerators.iter().zip(&divisors) {
+                black_box(n.wrapping_div(*d));
+            }
+        });
+    });
+
+    let divisors: Vec<_> = (0..SIZE)
+        .map(|_| i256::from(rng.gen_range(1..100_i32)))
+        .collect();
+
+    c.bench_function("i256_div_rem small divisor", |b| {
+        b.iter(|| {
+            for (n, d) in numerators.iter().zip(&divisors) {
+                black_box(n.wrapping_div(*d));
+            }
+        });
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow/src/alloc/alignment.rs b/arrow-buffer/src/alloc/alignment.rs
similarity index 97%
rename from arrow/src/alloc/alignment.rs
rename to arrow-buffer/src/alloc/alignment.rs
index 1bd15c54b990..b3979e1d6a06 100644
--- a/arrow/src/alloc/alignment.rs
+++ b/arrow-buffer/src/alloc/alignment.rs
@@ -18,7 +18,7 @@
 // NOTE: Below code is written for spatial/temporal prefetcher optimizations. Memory allocation
 // should align well with usage pattern of cache access and block sizes on layers of storage levels from
 // registers to non-volatile memory. These alignments are all cache aware alignments incorporated
-// from [cuneiform](https://crates.io/crates/cuneiform) crate. This approach mimicks Intel TBB's
+// from [cuneiform](https://crates.io/crates/cuneiform) crate. This approach mimics Intel TBB's
 // cache_aligned_allocator which exploits cache locality and minimizes prefetch signals
 // resulting in less round trip time between the layers of storage.
 // For further info: https://software.intel.com/en-us/node/506094
@@ -117,3 +117,7 @@ pub const ALIGNMENT: usize = 1 << 7;
 /// Cache and allocation multiple alignment size
 #[cfg(target_arch = "aarch64")]
 pub const ALIGNMENT: usize = 1 << 6;
+
+/// Cache and allocation multiple alignment size
+#[cfg(target_arch = "loongarch64")]
+pub const ALIGNMENT: usize = 1 << 6;
diff --git a/arrow-buffer/src/alloc/mod.rs b/arrow-buffer/src/alloc/mod.rs
new file mode 100644
index 000000000000..d7108d2969bb
--- /dev/null
+++ b/arrow-buffer/src/alloc/mod.rs
@@ -0,0 +1,70 @@
+// 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.
+
+//! Defines the low-level [`Allocation`] API for shared memory regions
+
+use std::alloc::Layout;
+use std::fmt::{Debug, Formatter};
+use std::panic::RefUnwindSafe;
+use std::sync::Arc;
+
+mod alignment;
+
+pub use alignment::ALIGNMENT;
+
+/// The owner of an allocation.
+/// The trait implementation is responsible for dropping the allocations once no more references exist.
+pub trait Allocation: RefUnwindSafe + Send + Sync {}
+
+impl<T: RefUnwindSafe + Send + Sync> Allocation for T {}
+
+/// Mode of deallocating memory regions
+pub(crate) enum Deallocation {
+    /// An allocation using [`std::alloc`]
+    Standard(Layout),
+    /// An allocation from an external source like the FFI interface
+    /// Deallocation will happen on `Allocation::drop`
+    /// The size of the allocation is tracked here separately only
+    /// for memory usage reporting via `Array::get_buffer_memory_size`
+    Custom(Arc<dyn Allocation>, usize),
+}
+
+impl Debug for Deallocation {
+    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
+        match self {
+            Deallocation::Standard(layout) => {
+                write!(f, "Deallocation::Standard {layout:?}")
+            }
+            Deallocation::Custom(_, size) => {
+                write!(f, "Deallocation::Custom {{ capacity: {size} }}")
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::alloc::Deallocation;
+
+    #[test]
+    fn test_size_of_deallocation() {
+        assert_eq!(
+            std::mem::size_of::<Deallocation>(),
+            3 * std::mem::size_of::<usize>()
+        );
+    }
+}
diff --git a/arrow-buffer/src/bigint/div.rs b/arrow-buffer/src/bigint/div.rs
new file mode 100644
index 000000000000..8a75dad0ffd8
--- /dev/null
+++ b/arrow-buffer/src/bigint/div.rs
@@ -0,0 +1,302 @@
+// 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.
+
+//! N-digit division
+//!
+//! Implementation heavily inspired by [uint]
+//!
+//! [uint]: https://github.com/paritytech/parity-common/blob/d3a9327124a66e52ca1114bb8640c02c18c134b8/uint/src/uint.rs#L844
+
+/// Unsigned, little-endian, n-digit division with remainder
+///
+/// # Panics
+///
+/// Panics if divisor is zero
+pub fn div_rem<const N: usize>(numerator: &[u64; N], divisor: &[u64; N]) -> ([u64; N], [u64; N]) {
+    let numerator_bits = bits(numerator);
+    let divisor_bits = bits(divisor);
+    assert_ne!(divisor_bits, 0, "division by zero");
+
+    if numerator_bits < divisor_bits {
+        return ([0; N], *numerator);
+    }
+
+    if divisor_bits <= 64 {
+        return div_rem_small(numerator, divisor[0]);
+    }
+
+    let numerator_words = (numerator_bits + 63) / 64;
+    let divisor_words = (divisor_bits + 63) / 64;
+    let n = divisor_words;
+    let m = numerator_words - divisor_words;
+
+    div_rem_knuth(numerator, divisor, n, m)
+}
+
+/// Return the least number of bits needed to represent the number
+fn bits(arr: &[u64]) -> usize {
+    for (idx, v) in arr.iter().enumerate().rev() {
+        if *v > 0 {
+            return 64 - v.leading_zeros() as usize + 64 * idx;
+        }
+    }
+    0
+}
+
+/// Division of numerator by a u64 divisor
+fn div_rem_small<const N: usize>(numerator: &[u64; N], divisor: u64) -> ([u64; N], [u64; N]) {
+    let mut rem = 0u64;
+    let mut numerator = *numerator;
+    numerator.iter_mut().rev().for_each(|d| {
+        let (q, r) = div_rem_word(rem, *d, divisor);
+        *d = q;
+        rem = r;
+    });
+
+    let mut rem_padded = [0; N];
+    rem_padded[0] = rem;
+    (numerator, rem_padded)
+}
+
+/// Use Knuth Algorithm D to compute `numerator / divisor` returning the
+/// quotient and remainder
+///
+/// `n` is the number of non-zero 64-bit words in `divisor`
+/// `m` is the number of non-zero 64-bit words present in `numerator` beyond `divisor`, and
+/// therefore the number of words in the quotient
+///
+/// A good explanation of the algorithm can be found [here](https://ridiculousfish.com/blog/posts/labor-of-division-episode-iv.html)
+fn div_rem_knuth<const N: usize>(
+    numerator: &[u64; N],
+    divisor: &[u64; N],
+    n: usize,
+    m: usize,
+) -> ([u64; N], [u64; N]) {
+    assert!(n + m <= N);
+
+    // The algorithm works by incrementally generating guesses `q_hat`, for the next digit
+    // of the quotient, starting from the most significant digit.
+    //
+    // This relies on the property that for any `q_hat` where
+    //
+    //      (q_hat << (j * 64)) * divisor <= numerator`
+    //
+    // We can set
+    //
+    //      q += q_hat << (j * 64)
+    //      numerator -= (q_hat << (j * 64)) * divisor
+    //
+    // And then iterate until `numerator < divisor`
+
+    // We normalize the divisor so that the highest bit in the highest digit of the
+    // divisor is set, this ensures our initial guess of `q_hat` is at most 2 off from
+    // the correct value for q[j]
+    let shift = divisor[n - 1].leading_zeros();
+    // As the shift is computed based on leading zeros, don't need to perform full_shl
+    let divisor = shl_word(divisor, shift);
+    // numerator may have fewer leading zeros than divisor, so must add another digit
+    let mut numerator = full_shl(numerator, shift);
+
+    // The two most significant digits of the divisor
+    let b0 = divisor[n - 1];
+    let b1 = divisor[n - 2];
+
+    let mut q = [0; N];
+
+    for j in (0..=m).rev() {
+        let a0 = numerator[j + n];
+        let a1 = numerator[j + n - 1];
+
+        let mut q_hat = if a0 < b0 {
+            // The first estimate is [a1, a0] / b0, it may be too large by at most 2
+            let (mut q_hat, mut r_hat) = div_rem_word(a0, a1, b0);
+
+            // r_hat = [a1, a0] - q_hat * b0
+            //
+            // Now we want to compute a more precise estimate [a2,a1,a0] / [b1,b0]
+            // which can only be less or equal to the current q_hat
+            //
+            // q_hat is too large if:
+            // [a2,a1,a0] < q_hat * [b1,b0]
+            // [a2,r_hat] < q_hat * b1
+            let a2 = numerator[j + n - 2];
+            loop {
+                let r = u128::from(q_hat) * u128::from(b1);
+                let (lo, hi) = (r as u64, (r >> 64) as u64);
+                if (hi, lo) <= (r_hat, a2) {
+                    break;
+                }
+
+                q_hat -= 1;
+                let (new_r_hat, overflow) = r_hat.overflowing_add(b0);
+                r_hat = new_r_hat;
+
+                if overflow {
+                    break;
+                }
+            }
+            q_hat
+        } else {
+            u64::MAX
+        };
+
+        // q_hat is now either the correct quotient digit, or in rare cases 1 too large
+
+        // Compute numerator -= (q_hat * divisor) << (j * 64)
+        let q_hat_v = full_mul_u64(&divisor, q_hat);
+        let c = sub_assign(&mut numerator[j..], &q_hat_v[..n + 1]);
+
+        // If underflow, q_hat was too large by 1
+        if c {
+            // Reduce q_hat by 1
+            q_hat -= 1;
+
+            // Add back one multiple of divisor
+            let c = add_assign(&mut numerator[j..], &divisor[..n]);
+            numerator[j + n] = numerator[j + n].wrapping_add(u64::from(c));
+        }
+
+        // q_hat is the correct value for q[j]
+        q[j] = q_hat;
+    }
+
+    // The remainder is what is left in numerator, with the initial normalization shl reversed
+    let remainder = full_shr(&numerator, shift);
+    (q, remainder)
+}
+
+/// Perform narrowing division of a u128 by a u64 divisor, returning the quotient and remainder
+///
+/// This method may trap or panic if hi >= divisor, i.e. the quotient would not fit
+/// into a 64-bit integer
+fn div_rem_word(hi: u64, lo: u64, divisor: u64) -> (u64, u64) {
+    debug_assert!(hi < divisor);
+    debug_assert_ne!(divisor, 0);
+
+    // LLVM fails to use the div instruction as it is not able to prove
+    // that hi < divisor, and therefore the result will fit into 64-bits
+    #[cfg(all(target_arch = "x86_64", not(miri)))]
+    unsafe {
+        let mut quot = lo;
+        let mut rem = hi;
+        std::arch::asm!(
+            "div {divisor}",
+            divisor = in(reg) divisor,
+            inout("rax") quot,
+            inout("rdx") rem,
+            options(pure, nomem, nostack)
+        );
+        (quot, rem)
+    }
+    #[cfg(any(not(target_arch = "x86_64"), miri))]
+    {
+        let x = (u128::from(hi) << 64) + u128::from(lo);
+        let y = u128::from(divisor);
+        ((x / y) as u64, (x % y) as u64)
+    }
+}
+
+/// Perform `a += b`
+fn add_assign(a: &mut [u64], b: &[u64]) -> bool {
+    binop_slice(a, b, u64::overflowing_add)
+}
+
+/// Perform `a -= b`
+fn sub_assign(a: &mut [u64], b: &[u64]) -> bool {
+    binop_slice(a, b, u64::overflowing_sub)
+}
+
+/// Converts an overflowing binary operation on scalars to one on slices
+fn binop_slice(a: &mut [u64], b: &[u64], binop: impl Fn(u64, u64) -> (u64, bool) + Copy) -> bool {
+    let mut c = false;
+    a.iter_mut().zip(b.iter()).for_each(|(x, y)| {
+        let (res1, overflow1) = y.overflowing_add(u64::from(c));
+        let (res2, overflow2) = binop(*x, res1);
+        *x = res2;
+        c = overflow1 || overflow2;
+    });
+    c
+}
+
+/// Widening multiplication of an N-digit array with a u64
+fn full_mul_u64<const N: usize>(a: &[u64; N], b: u64) -> ArrayPlusOne<u64, N> {
+    let mut carry = 0;
+    let mut out = [0; N];
+    out.iter_mut().zip(a).for_each(|(o, v)| {
+        let r = *v as u128 * b as u128 + carry as u128;
+        *o = r as u64;
+        carry = (r >> 64) as u64;
+    });
+    ArrayPlusOne(out, carry)
+}
+
+/// Left shift of an N-digit array by at most 63 bits
+fn shl_word<const N: usize>(v: &[u64; N], shift: u32) -> [u64; N] {
+    full_shl(v, shift).0
+}
+
+/// Widening left shift of an N-digit array by at most 63 bits
+fn full_shl<const N: usize>(v: &[u64; N], shift: u32) -> ArrayPlusOne<u64, N> {
+    debug_assert!(shift < 64);
+    if shift == 0 {
+        return ArrayPlusOne(*v, 0);
+    }
+    let mut out = [0u64; N];
+    out[0] = v[0] << shift;
+    for i in 1..N {
+        out[i] = v[i - 1] >> (64 - shift) | v[i] << shift
+    }
+    let carry = v[N - 1] >> (64 - shift);
+    ArrayPlusOne(out, carry)
+}
+
+/// Narrowing right shift of an (N+1)-digit array by at most 63 bits
+fn full_shr<const N: usize>(a: &ArrayPlusOne<u64, N>, shift: u32) -> [u64; N] {
+    debug_assert!(shift < 64);
+    if shift == 0 {
+        return a.0;
+    }
+    let mut out = [0; N];
+    for i in 0..N - 1 {
+        out[i] = a[i] >> shift | a[i + 1] << (64 - shift)
+    }
+    out[N - 1] = a[N - 1] >> shift;
+    out
+}
+
+/// An array of N + 1 elements
+///
+/// This is a hack around lack of support for const arithmetic
+#[repr(C)]
+struct ArrayPlusOne<T, const N: usize>([T; N], T);
+
+impl<T, const N: usize> std::ops::Deref for ArrayPlusOne<T, N> {
+    type Target = [T];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        let x = self as *const Self;
+        unsafe { std::slice::from_raw_parts(x as *const T, N + 1) }
+    }
+}
+
+impl<T, const N: usize> std::ops::DerefMut for ArrayPlusOne<T, N> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        let x = self as *mut Self;
+        unsafe { std::slice::from_raw_parts_mut(x as *mut T, N + 1) }
+    }
+}
diff --git a/arrow-buffer/src/bigint/mod.rs b/arrow-buffer/src/bigint/mod.rs
new file mode 100644
index 000000000000..afbb3a31df12
--- /dev/null
+++ b/arrow-buffer/src/bigint/mod.rs
@@ -0,0 +1,1267 @@
+// 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.
+
+use crate::bigint::div::div_rem;
+use num::cast::AsPrimitive;
+use num::{BigInt, FromPrimitive, ToPrimitive};
+use std::cmp::Ordering;
+use std::num::ParseIntError;
+use std::ops::{BitAnd, BitOr, BitXor, Neg, Shl, Shr};
+use std::str::FromStr;
+
+mod div;
+
+/// An opaque error similar to [`std::num::ParseIntError`]
+#[derive(Debug)]
+pub struct ParseI256Error {}
+
+impl From<ParseIntError> for ParseI256Error {
+    fn from(_: ParseIntError) -> Self {
+        Self {}
+    }
+}
+
+impl std::fmt::Display for ParseI256Error {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "Failed to parse as i256")
+    }
+}
+impl std::error::Error for ParseI256Error {}
+
+/// Error returned by i256::DivRem
+enum DivRemError {
+    /// Division by zero
+    DivideByZero,
+    /// Division overflow
+    DivideOverflow,
+}
+
+/// A signed 256-bit integer
+#[allow(non_camel_case_types)]
+#[derive(Copy, Clone, Default, Eq, PartialEq, Hash)]
+pub struct i256 {
+    low: u128,
+    high: i128,
+}
+
+impl std::fmt::Debug for i256 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{self}")
+    }
+}
+
+impl std::fmt::Display for i256 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", BigInt::from_signed_bytes_le(&self.to_le_bytes()))
+    }
+}
+
+impl FromStr for i256 {
+    type Err = ParseI256Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        // i128 can store up to 38 decimal digits
+        if s.len() <= 38 {
+            return Ok(Self::from_i128(i128::from_str(s)?));
+        }
+
+        let (negative, s) = match s.as_bytes()[0] {
+            b'-' => (true, &s[1..]),
+            b'+' => (false, &s[1..]),
+            _ => (false, s),
+        };
+
+        // Trim leading 0s
+        let s = s.trim_start_matches('0');
+        if s.is_empty() {
+            return Ok(i256::ZERO);
+        }
+
+        if !s.as_bytes()[0].is_ascii_digit() {
+            // Ensures no duplicate sign
+            return Err(ParseI256Error {});
+        }
+
+        parse_impl(s, negative)
+    }
+}
+
+impl From<i8> for i256 {
+    fn from(value: i8) -> Self {
+        Self::from_i128(value.into())
+    }
+}
+
+impl From<i16> for i256 {
+    fn from(value: i16) -> Self {
+        Self::from_i128(value.into())
+    }
+}
+
+impl From<i32> for i256 {
+    fn from(value: i32) -> Self {
+        Self::from_i128(value.into())
+    }
+}
+
+impl From<i64> for i256 {
+    fn from(value: i64) -> Self {
+        Self::from_i128(value.into())
+    }
+}
+
+/// Parse `s` with any sign and leading 0s removed
+fn parse_impl(s: &str, negative: bool) -> Result<i256, ParseI256Error> {
+    if s.len() <= 38 {
+        let low = i128::from_str(s)?;
+        return Ok(match negative {
+            true => i256::from_parts(low.neg() as _, -1),
+            false => i256::from_parts(low as _, 0),
+        });
+    }
+
+    let split = s.len() - 38;
+    if !s.as_bytes()[split].is_ascii_digit() {
+        // Ensures not splitting codepoint and no sign
+        return Err(ParseI256Error {});
+    }
+    let (hs, ls) = s.split_at(split);
+
+    let mut low = i128::from_str(ls)?;
+    let high = parse_impl(hs, negative)?;
+
+    if negative {
+        low = -low;
+    }
+
+    let low = i256::from_i128(low);
+
+    high.checked_mul(i256::from_i128(10_i128.pow(38)))
+        .and_then(|high| high.checked_add(low))
+        .ok_or(ParseI256Error {})
+}
+
+impl PartialOrd for i256 {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for i256 {
+    fn cmp(&self, other: &Self) -> Ordering {
+        // This is 25x faster than using a variable length encoding such
+        // as BigInt as it avoids allocation and branching
+        self.high.cmp(&other.high).then(self.low.cmp(&other.low))
+    }
+}
+
+impl i256 {
+    /// The additive identity for this integer type, i.e. `0`.
+    pub const ZERO: Self = i256 { low: 0, high: 0 };
+
+    /// The multiplicative identity for this integer type, i.e. `1`.
+    pub const ONE: Self = i256 { low: 1, high: 0 };
+
+    /// The multiplicative inverse for this integer type, i.e. `-1`.
+    pub const MINUS_ONE: Self = i256 {
+        low: u128::MAX,
+        high: -1,
+    };
+
+    /// The maximum value that can be represented by this integer type
+    pub const MAX: Self = i256 {
+        low: u128::MAX,
+        high: i128::MAX,
+    };
+
+    /// The minimum value that can be represented by this integer type
+    pub const MIN: Self = i256 {
+        low: u128::MIN,
+        high: i128::MIN,
+    };
+
+    /// Create an integer value from its representation as a byte array in little-endian.
+    #[inline]
+    pub const fn from_le_bytes(b: [u8; 32]) -> Self {
+        let (low, high) = split_array(b);
+        Self {
+            high: i128::from_le_bytes(high),
+            low: u128::from_le_bytes(low),
+        }
+    }
+
+    /// Create an integer value from its representation as a byte array in big-endian.
+    #[inline]
+    pub const fn from_be_bytes(b: [u8; 32]) -> Self {
+        let (high, low) = split_array(b);
+        Self {
+            high: i128::from_be_bytes(high),
+            low: u128::from_be_bytes(low),
+        }
+    }
+
+    pub const fn from_i128(v: i128) -> Self {
+        Self::from_parts(v as u128, v >> 127)
+    }
+
+    /// Create an integer value from its representation as string.
+    #[inline]
+    pub fn from_string(value_str: &str) -> Option<Self> {
+        value_str.parse().ok()
+    }
+
+    /// Create an optional i256 from the provided `f64`. Returning `None`
+    /// if overflow occurred
+    pub fn from_f64(v: f64) -> Option<Self> {
+        BigInt::from_f64(v).and_then(|i| {
+            let (integer, overflow) = i256::from_bigint_with_overflow(i);
+            if overflow {
+                None
+            } else {
+                Some(integer)
+            }
+        })
+    }
+
+    /// Create an i256 from the provided low u128 and high i128
+    #[inline]
+    pub const fn from_parts(low: u128, high: i128) -> Self {
+        Self { low, high }
+    }
+
+    /// Returns this `i256` as a low u128 and high i128
+    pub const fn to_parts(self) -> (u128, i128) {
+        (self.low, self.high)
+    }
+
+    /// Converts this `i256` into an `i128` returning `None` if this would result
+    /// in truncation/overflow
+    pub fn to_i128(self) -> Option<i128> {
+        let as_i128 = self.low as i128;
+
+        let high_negative = self.high < 0;
+        let low_negative = as_i128 < 0;
+        let high_valid = self.high == -1 || self.high == 0;
+
+        (high_negative == low_negative && high_valid).then_some(self.low as i128)
+    }
+
+    /// Wraps this `i256` into an `i128`
+    pub fn as_i128(self) -> i128 {
+        self.low as i128
+    }
+
+    /// Return the memory representation of this integer as a byte array in little-endian byte order.
+    #[inline]
+    pub const fn to_le_bytes(self) -> [u8; 32] {
+        let low = self.low.to_le_bytes();
+        let high = self.high.to_le_bytes();
+        let mut t = [0; 32];
+        let mut i = 0;
+        while i != 16 {
+            t[i] = low[i];
+            t[i + 16] = high[i];
+            i += 1;
+        }
+        t
+    }
+
+    /// Return the memory representation of this integer as a byte array in big-endian byte order.
+    #[inline]
+    pub const fn to_be_bytes(self) -> [u8; 32] {
+        let low = self.low.to_be_bytes();
+        let high = self.high.to_be_bytes();
+        let mut t = [0; 32];
+        let mut i = 0;
+        while i != 16 {
+            t[i] = high[i];
+            t[i + 16] = low[i];
+            i += 1;
+        }
+        t
+    }
+
+    /// Create an i256 from the provided [`BigInt`] returning a bool indicating
+    /// if overflow occurred
+    fn from_bigint_with_overflow(v: BigInt) -> (Self, bool) {
+        let v_bytes = v.to_signed_bytes_le();
+        match v_bytes.len().cmp(&32) {
+            Ordering::Less => {
+                let mut bytes = if num::Signed::is_negative(&v) {
+                    [255_u8; 32]
+                } else {
+                    [0; 32]
+                };
+                bytes[0..v_bytes.len()].copy_from_slice(&v_bytes[..v_bytes.len()]);
+                (Self::from_le_bytes(bytes), false)
+            }
+            Ordering::Equal => (Self::from_le_bytes(v_bytes.try_into().unwrap()), false),
+            Ordering::Greater => (Self::from_le_bytes(v_bytes[..32].try_into().unwrap()), true),
+        }
+    }
+
+    /// Computes the absolute value of this i256
+    #[inline]
+    pub fn wrapping_abs(self) -> Self {
+        // -1 if negative, otherwise 0
+        let sa = self.high >> 127;
+        let sa = Self::from_parts(sa as u128, sa);
+
+        // Inverted if negative
+        Self::from_parts(self.low ^ sa.low, self.high ^ sa.high).wrapping_sub(sa)
+    }
+
+    /// Computes the absolute value of this i256 returning `None` if `Self == Self::MIN`
+    #[inline]
+    pub fn checked_abs(self) -> Option<Self> {
+        (self != Self::MIN).then(|| self.wrapping_abs())
+    }
+
+    /// Negates this i256
+    #[inline]
+    pub fn wrapping_neg(self) -> Self {
+        Self::from_parts(!self.low, !self.high).wrapping_add(i256::ONE)
+    }
+
+    /// Negates this i256 returning `None` if `Self == Self::MIN`
+    #[inline]
+    pub fn checked_neg(self) -> Option<Self> {
+        (self != Self::MIN).then(|| self.wrapping_neg())
+    }
+
+    /// Performs wrapping addition
+    #[inline]
+    pub fn wrapping_add(self, other: Self) -> Self {
+        let (low, carry) = self.low.overflowing_add(other.low);
+        let high = self.high.wrapping_add(other.high).wrapping_add(carry as _);
+        Self { low, high }
+    }
+
+    /// Performs checked addition
+    #[inline]
+    pub fn checked_add(self, other: Self) -> Option<Self> {
+        let r = self.wrapping_add(other);
+        ((other.is_negative() && r < self) || (!other.is_negative() && r >= self)).then_some(r)
+    }
+
+    /// Performs wrapping subtraction
+    #[inline]
+    pub fn wrapping_sub(self, other: Self) -> Self {
+        let (low, carry) = self.low.overflowing_sub(other.low);
+        let high = self.high.wrapping_sub(other.high).wrapping_sub(carry as _);
+        Self { low, high }
+    }
+
+    /// Performs checked subtraction
+    #[inline]
+    pub fn checked_sub(self, other: Self) -> Option<Self> {
+        let r = self.wrapping_sub(other);
+        ((other.is_negative() && r > self) || (!other.is_negative() && r <= self)).then_some(r)
+    }
+
+    /// Performs wrapping multiplication
+    #[inline]
+    pub fn wrapping_mul(self, other: Self) -> Self {
+        let (low, high) = mulx(self.low, other.low);
+
+        // Compute the high multiples, only impacting the high 128-bits
+        let hl = self.high.wrapping_mul(other.low as i128);
+        let lh = (self.low as i128).wrapping_mul(other.high);
+
+        Self {
+            low,
+            high: (high as i128).wrapping_add(hl).wrapping_add(lh),
+        }
+    }
+
+    /// Performs checked multiplication
+    #[inline]
+    pub fn checked_mul(self, other: Self) -> Option<Self> {
+        if self == i256::ZERO || other == i256::ZERO {
+            return Some(i256::ZERO);
+        }
+
+        // Shift sign bit down to construct mask of all set bits if negative
+        let l_sa = self.high >> 127;
+        let r_sa = other.high >> 127;
+        let out_sa = (l_sa ^ r_sa) as u128;
+
+        // Compute absolute values
+        let l_abs = self.wrapping_abs();
+        let r_abs = other.wrapping_abs();
+
+        // Overflow if both high parts are non-zero
+        if l_abs.high != 0 && r_abs.high != 0 {
+            return None;
+        }
+
+        // Perform checked multiplication on absolute values
+        let (low, high) = mulx(l_abs.low, r_abs.low);
+
+        // Compute the high multiples, only impacting the high 128-bits
+        let hl = (l_abs.high as u128).checked_mul(r_abs.low)?;
+        let lh = l_abs.low.checked_mul(r_abs.high as u128)?;
+
+        let high = high.checked_add(hl)?.checked_add(lh)?;
+
+        // Reverse absolute value, if necessary
+        let (low, c) = (low ^ out_sa).overflowing_sub(out_sa);
+        let high = (high ^ out_sa).wrapping_sub(out_sa).wrapping_sub(c as u128) as i128;
+
+        // Check for overflow in final conversion
+        (high.is_negative() == (self.is_negative() ^ other.is_negative()))
+            .then_some(Self { low, high })
+    }
+
+    /// Division operation, returns (quotient, remainder).
+    /// This basically implements [Long division]: `<https://en.wikipedia.org/wiki/Division_algorithm>`
+    #[inline]
+    fn div_rem(self, other: Self) -> Result<(Self, Self), DivRemError> {
+        if other == Self::ZERO {
+            return Err(DivRemError::DivideByZero);
+        }
+        if other == Self::MINUS_ONE && self == Self::MIN {
+            return Err(DivRemError::DivideOverflow);
+        }
+
+        let a = self.wrapping_abs();
+        let b = other.wrapping_abs();
+
+        let (div, rem) = div_rem(&a.as_digits(), &b.as_digits());
+        let div = Self::from_digits(div);
+        let rem = Self::from_digits(rem);
+
+        Ok((
+            if self.is_negative() == other.is_negative() {
+                div
+            } else {
+                div.wrapping_neg()
+            },
+            if self.is_negative() {
+                rem.wrapping_neg()
+            } else {
+                rem
+            },
+        ))
+    }
+
+    /// Interpret this [`i256`] as 4 `u64` digits, least significant first
+    fn as_digits(self) -> [u64; 4] {
+        [
+            self.low as u64,
+            (self.low >> 64) as u64,
+            self.high as u64,
+            (self.high as u128 >> 64) as u64,
+        ]
+    }
+
+    /// Interpret 4 `u64` digits, least significant first, as a [`i256`]
+    fn from_digits(digits: [u64; 4]) -> Self {
+        Self::from_parts(
+            digits[0] as u128 | (digits[1] as u128) << 64,
+            digits[2] as i128 | (digits[3] as i128) << 64,
+        )
+    }
+
+    /// Performs wrapping division
+    #[inline]
+    pub fn wrapping_div(self, other: Self) -> Self {
+        match self.div_rem(other) {
+            Ok((v, _)) => v,
+            Err(DivRemError::DivideByZero) => panic!("attempt to divide by zero"),
+            Err(_) => Self::MIN,
+        }
+    }
+
+    /// Performs checked division
+    #[inline]
+    pub fn checked_div(self, other: Self) -> Option<Self> {
+        self.div_rem(other).map(|(v, _)| v).ok()
+    }
+
+    /// Performs wrapping remainder
+    #[inline]
+    pub fn wrapping_rem(self, other: Self) -> Self {
+        match self.div_rem(other) {
+            Ok((_, v)) => v,
+            Err(DivRemError::DivideByZero) => panic!("attempt to divide by zero"),
+            Err(_) => Self::ZERO,
+        }
+    }
+
+    /// Performs checked remainder
+    #[inline]
+    pub fn checked_rem(self, other: Self) -> Option<Self> {
+        self.div_rem(other).map(|(_, v)| v).ok()
+    }
+
+    /// Performs checked exponentiation
+    #[inline]
+    pub fn checked_pow(self, mut exp: u32) -> Option<Self> {
+        if exp == 0 {
+            return Some(i256::from_i128(1));
+        }
+
+        let mut base = self;
+        let mut acc: Self = i256::from_i128(1);
+
+        while exp > 1 {
+            if (exp & 1) == 1 {
+                acc = acc.checked_mul(base)?;
+            }
+            exp /= 2;
+            base = base.checked_mul(base)?;
+        }
+        // since exp!=0, finally the exp must be 1.
+        // Deal with the final bit of the exponent separately, since
+        // squaring the base afterwards is not necessary and may cause a
+        // needless overflow.
+        acc.checked_mul(base)
+    }
+
+    /// Performs wrapping exponentiation
+    #[inline]
+    pub fn wrapping_pow(self, mut exp: u32) -> Self {
+        if exp == 0 {
+            return i256::from_i128(1);
+        }
+
+        let mut base = self;
+        let mut acc: Self = i256::from_i128(1);
+
+        while exp > 1 {
+            if (exp & 1) == 1 {
+                acc = acc.wrapping_mul(base);
+            }
+            exp /= 2;
+            base = base.wrapping_mul(base);
+        }
+
+        // since exp!=0, finally the exp must be 1.
+        // Deal with the final bit of the exponent separately, since
+        // squaring the base afterwards is not necessary and may cause a
+        // needless overflow.
+        acc.wrapping_mul(base)
+    }
+
+    /// Returns a number [`i256`] representing sign of this [`i256`].
+    ///
+    /// 0 if the number is zero
+    /// 1 if the number is positive
+    /// -1 if the number is negative
+    pub const fn signum(self) -> Self {
+        if self.is_positive() {
+            i256::ONE
+        } else if self.is_negative() {
+            i256::MINUS_ONE
+        } else {
+            i256::ZERO
+        }
+    }
+
+    /// Returns `true` if this [`i256`] is negative
+    #[inline]
+    pub const fn is_negative(self) -> bool {
+        self.high.is_negative()
+    }
+
+    /// Returns `true` if this [`i256`] is positive
+    pub const fn is_positive(self) -> bool {
+        self.high.is_positive() || self.high == 0 && self.low != 0
+    }
+}
+
+/// Temporary workaround due to lack of stable const array slicing
+/// See <https://github.com/rust-lang/rust/issues/90091>
+const fn split_array<const N: usize, const M: usize>(vals: [u8; N]) -> ([u8; M], [u8; M]) {
+    let mut a = [0; M];
+    let mut b = [0; M];
+    let mut i = 0;
+    while i != M {
+        a[i] = vals[i];
+        b[i] = vals[i + M];
+        i += 1;
+    }
+    (a, b)
+}
+
+/// Performs an unsigned multiplication of `a * b` returning a tuple of
+/// `(low, high)` where `low` contains the lower 128-bits of the result
+/// and `high` the higher 128-bits
+///
+/// This mirrors the x86 mulx instruction but for 128-bit types
+#[inline]
+fn mulx(a: u128, b: u128) -> (u128, u128) {
+    let split = |a: u128| (a & (u64::MAX as u128), a >> 64);
+
+    const MASK: u128 = u64::MAX as _;
+
+    let (a_low, a_high) = split(a);
+    let (b_low, b_high) = split(b);
+
+    // Carry stores the upper 64-bits of low and lower 64-bits of high
+    let (mut low, mut carry) = split(a_low * b_low);
+    carry += a_high * b_low;
+
+    // Update low and high with corresponding parts of carry
+    low += carry << 64;
+    let mut high = carry >> 64;
+
+    // Update carry with overflow from low
+    carry = low >> 64;
+    low &= MASK;
+
+    // Perform multiply including overflow from low
+    carry += b_high * a_low;
+
+    // Update low and high with values from carry
+    low += carry << 64;
+    high += carry >> 64;
+
+    // Perform 4th multiplication
+    high += a_high * b_high;
+
+    (low, high)
+}
+
+macro_rules! derive_op {
+    ($t:ident, $op:ident, $wrapping:ident, $checked:ident) => {
+        impl std::ops::$t for i256 {
+            type Output = i256;
+
+            #[cfg(debug_assertions)]
+            fn $op(self, rhs: Self) -> Self::Output {
+                self.$checked(rhs).expect("i256 overflow")
+            }
+
+            #[cfg(not(debug_assertions))]
+            fn $op(self, rhs: Self) -> Self::Output {
+                self.$wrapping(rhs)
+            }
+        }
+
+        impl<'a> std::ops::$t<i256> for &'a i256 {
+            type Output = i256;
+
+            fn $op(self, rhs: i256) -> Self::Output {
+                (*self).$op(rhs)
+            }
+        }
+
+        impl<'a> std::ops::$t<&'a i256> for i256 {
+            type Output = i256;
+
+            fn $op(self, rhs: &'a i256) -> Self::Output {
+                self.$op(*rhs)
+            }
+        }
+
+        impl<'a, 'b> std::ops::$t<&'b i256> for &'a i256 {
+            type Output = i256;
+
+            fn $op(self, rhs: &'b i256) -> Self::Output {
+                (*self).$op(*rhs)
+            }
+        }
+    };
+}
+
+derive_op!(Add, add, wrapping_add, checked_add);
+derive_op!(Sub, sub, wrapping_sub, checked_sub);
+derive_op!(Mul, mul, wrapping_mul, checked_mul);
+derive_op!(Div, div, wrapping_div, checked_div);
+derive_op!(Rem, rem, wrapping_rem, checked_rem);
+
+impl std::ops::Neg for i256 {
+    type Output = i256;
+
+    #[cfg(debug_assertions)]
+    fn neg(self) -> Self::Output {
+        self.checked_neg().expect("i256 overflow")
+    }
+
+    #[cfg(not(debug_assertions))]
+    fn neg(self) -> Self::Output {
+        self.wrapping_neg()
+    }
+}
+
+impl BitAnd for i256 {
+    type Output = i256;
+
+    #[inline]
+    fn bitand(self, rhs: Self) -> Self::Output {
+        Self {
+            low: self.low & rhs.low,
+            high: self.high & rhs.high,
+        }
+    }
+}
+
+impl BitOr for i256 {
+    type Output = i256;
+
+    #[inline]
+    fn bitor(self, rhs: Self) -> Self::Output {
+        Self {
+            low: self.low | rhs.low,
+            high: self.high | rhs.high,
+        }
+    }
+}
+
+impl BitXor for i256 {
+    type Output = i256;
+
+    #[inline]
+    fn bitxor(self, rhs: Self) -> Self::Output {
+        Self {
+            low: self.low ^ rhs.low,
+            high: self.high ^ rhs.high,
+        }
+    }
+}
+
+impl Shl<u8> for i256 {
+    type Output = i256;
+
+    #[inline]
+    fn shl(self, rhs: u8) -> Self::Output {
+        if rhs == 0 {
+            self
+        } else if rhs < 128 {
+            Self {
+                high: self.high << rhs | (self.low >> (128 - rhs)) as i128,
+                low: self.low << rhs,
+            }
+        } else {
+            Self {
+                high: (self.low << (rhs - 128)) as i128,
+                low: 0,
+            }
+        }
+    }
+}
+
+impl Shr<u8> for i256 {
+    type Output = i256;
+
+    #[inline]
+    fn shr(self, rhs: u8) -> Self::Output {
+        if rhs == 0 {
+            self
+        } else if rhs < 128 {
+            Self {
+                high: self.high >> rhs,
+                low: self.low >> rhs | ((self.high as u128) << (128 - rhs)),
+            }
+        } else {
+            Self {
+                high: self.high >> 127,
+                low: (self.high >> (rhs - 128)) as u128,
+            }
+        }
+    }
+}
+
+macro_rules! define_as_primitive {
+    ($native_ty:ty) => {
+        impl AsPrimitive<i256> for $native_ty {
+            fn as_(self) -> i256 {
+                i256::from_i128(self as i128)
+            }
+        }
+    };
+}
+
+define_as_primitive!(i8);
+define_as_primitive!(i16);
+define_as_primitive!(i32);
+define_as_primitive!(i64);
+define_as_primitive!(u8);
+define_as_primitive!(u16);
+define_as_primitive!(u32);
+define_as_primitive!(u64);
+
+impl ToPrimitive for i256 {
+    fn to_i64(&self) -> Option<i64> {
+        let as_i128 = self.low as i128;
+
+        let high_negative = self.high < 0;
+        let low_negative = as_i128 < 0;
+        let high_valid = self.high == -1 || self.high == 0;
+
+        if high_negative == low_negative && high_valid {
+            let (low_bytes, high_bytes) = split_array(u128::to_le_bytes(self.low));
+            let high = i64::from_le_bytes(high_bytes);
+            let low = i64::from_le_bytes(low_bytes);
+
+            let high_negative = high < 0;
+            let low_negative = low < 0;
+            let high_valid = self.high == -1 || self.high == 0;
+
+            (high_negative == low_negative && high_valid).then_some(low)
+        } else {
+            None
+        }
+    }
+
+    fn to_u64(&self) -> Option<u64> {
+        let as_i128 = self.low as i128;
+
+        let high_negative = self.high < 0;
+        let low_negative = as_i128 < 0;
+        let high_valid = self.high == -1 || self.high == 0;
+
+        if high_negative == low_negative && high_valid {
+            self.low.to_u64()
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(all(test, not(miri)))] // llvm.x86.subborrow.64 not supported by MIRI
+mod tests {
+    use super::*;
+    use num::{BigInt, FromPrimitive, Signed, ToPrimitive};
+    use rand::{thread_rng, Rng};
+    use std::ops::Neg;
+
+    #[test]
+    fn test_signed_cmp() {
+        let a = i256::from_parts(i128::MAX as u128, 12);
+        let b = i256::from_parts(i128::MIN as u128, 12);
+        assert!(a < b);
+
+        let a = i256::from_parts(i128::MAX as u128, 12);
+        let b = i256::from_parts(i128::MIN as u128, -12);
+        assert!(a > b);
+    }
+
+    #[test]
+    fn test_to_i128() {
+        let vals = [
+            BigInt::from_i128(-1).unwrap(),
+            BigInt::from_i128(i128::MAX).unwrap(),
+            BigInt::from_i128(i128::MIN).unwrap(),
+            BigInt::from_u128(u128::MIN).unwrap(),
+            BigInt::from_u128(u128::MAX).unwrap(),
+        ];
+
+        for v in vals {
+            let (t, overflow) = i256::from_bigint_with_overflow(v.clone());
+            assert!(!overflow);
+            assert_eq!(t.to_i128(), v.to_i128(), "{v} vs {t}");
+        }
+    }
+
+    /// Tests operations against the two provided [`i256`]
+    fn test_ops(il: i256, ir: i256) {
+        let bl = BigInt::from_signed_bytes_le(&il.to_le_bytes());
+        let br = BigInt::from_signed_bytes_le(&ir.to_le_bytes());
+
+        // Comparison
+        assert_eq!(il.cmp(&ir), bl.cmp(&br), "{bl} cmp {br}");
+
+        // Conversions
+        assert_eq!(i256::from_le_bytes(il.to_le_bytes()), il);
+        assert_eq!(i256::from_be_bytes(il.to_be_bytes()), il);
+        assert_eq!(i256::from_le_bytes(ir.to_le_bytes()), ir);
+        assert_eq!(i256::from_be_bytes(ir.to_be_bytes()), ir);
+
+        // To i128
+        assert_eq!(il.to_i128(), bl.to_i128(), "{bl}");
+        assert_eq!(ir.to_i128(), br.to_i128(), "{br}");
+
+        // Absolute value
+        let (abs, overflow) = i256::from_bigint_with_overflow(bl.abs());
+        assert_eq!(il.wrapping_abs(), abs);
+        assert_eq!(il.checked_abs().is_none(), overflow);
+
+        let (abs, overflow) = i256::from_bigint_with_overflow(br.abs());
+        assert_eq!(ir.wrapping_abs(), abs);
+        assert_eq!(ir.checked_abs().is_none(), overflow);
+
+        // Negation
+        let (neg, overflow) = i256::from_bigint_with_overflow(bl.clone().neg());
+        assert_eq!(il.wrapping_neg(), neg);
+        assert_eq!(il.checked_neg().is_none(), overflow);
+
+        // Negation
+        let (neg, overflow) = i256::from_bigint_with_overflow(br.clone().neg());
+        assert_eq!(ir.wrapping_neg(), neg);
+        assert_eq!(ir.checked_neg().is_none(), overflow);
+
+        // Addition
+        let actual = il.wrapping_add(ir);
+        let (expected, overflow) = i256::from_bigint_with_overflow(bl.clone() + br.clone());
+        assert_eq!(actual, expected);
+
+        let checked = il.checked_add(ir);
+        match overflow {
+            true => assert!(checked.is_none()),
+            false => assert_eq!(checked, Some(actual)),
+        }
+
+        // Subtraction
+        let actual = il.wrapping_sub(ir);
+        let (expected, overflow) = i256::from_bigint_with_overflow(bl.clone() - br.clone());
+        assert_eq!(actual.to_string(), expected.to_string());
+
+        let checked = il.checked_sub(ir);
+        match overflow {
+            true => assert!(checked.is_none()),
+            false => assert_eq!(checked, Some(actual), "{bl} - {br} = {expected}"),
+        }
+
+        // Multiplication
+        let actual = il.wrapping_mul(ir);
+        let (expected, overflow) = i256::from_bigint_with_overflow(bl.clone() * br.clone());
+        assert_eq!(actual.to_string(), expected.to_string());
+
+        let checked = il.checked_mul(ir);
+        match overflow {
+            true => assert!(
+                checked.is_none(),
+                "{il} * {ir} = {actual} vs {bl} * {br} = {expected}"
+            ),
+            false => assert_eq!(
+                checked,
+                Some(actual),
+                "{il} * {ir} = {actual} vs {bl} * {br} = {expected}"
+            ),
+        }
+
+        // Division
+        if ir != i256::ZERO {
+            let actual = il.wrapping_div(ir);
+            let expected = bl.clone() / br.clone();
+            let checked = il.checked_div(ir);
+
+            if ir == i256::MINUS_ONE && il == i256::MIN {
+                // BigInt produces an integer over i256::MAX
+                assert_eq!(actual, i256::MIN);
+                assert!(checked.is_none());
+            } else {
+                assert_eq!(actual.to_string(), expected.to_string());
+                assert_eq!(checked.unwrap().to_string(), expected.to_string());
+            }
+        } else {
+            // `wrapping_div` panics on division by zero
+            assert!(il.checked_div(ir).is_none());
+        }
+
+        // Remainder
+        if ir != i256::ZERO {
+            let actual = il.wrapping_rem(ir);
+            let expected = bl.clone() % br.clone();
+            let checked = il.checked_rem(ir);
+
+            assert_eq!(actual.to_string(), expected.to_string(), "{il} % {ir}");
+
+            if ir == i256::MINUS_ONE && il == i256::MIN {
+                assert!(checked.is_none());
+            } else {
+                assert_eq!(checked.unwrap().to_string(), expected.to_string());
+            }
+        } else {
+            // `wrapping_rem` panics on division by zero
+            assert!(il.checked_rem(ir).is_none());
+        }
+
+        // Exponentiation
+        for exp in vec![0, 1, 2, 3, 8, 100].into_iter() {
+            let actual = il.wrapping_pow(exp);
+            let (expected, overflow) = i256::from_bigint_with_overflow(bl.clone().pow(exp));
+            assert_eq!(actual.to_string(), expected.to_string());
+
+            let checked = il.checked_pow(exp);
+            match overflow {
+                true => assert!(
+                    checked.is_none(),
+                    "{il} ^ {exp} = {actual} vs {bl} * {exp} = {expected}"
+                ),
+                false => assert_eq!(
+                    checked,
+                    Some(actual),
+                    "{il} ^ {exp} = {actual} vs {bl} ^ {exp} = {expected}"
+                ),
+            }
+        }
+
+        // Bit operations
+        let actual = il & ir;
+        let (expected, _) = i256::from_bigint_with_overflow(bl.clone() & br.clone());
+        assert_eq!(actual.to_string(), expected.to_string());
+
+        let actual = il | ir;
+        let (expected, _) = i256::from_bigint_with_overflow(bl.clone() | br.clone());
+        assert_eq!(actual.to_string(), expected.to_string());
+
+        let actual = il ^ ir;
+        let (expected, _) = i256::from_bigint_with_overflow(bl.clone() ^ br);
+        assert_eq!(actual.to_string(), expected.to_string());
+
+        for shift in [0_u8, 1, 4, 126, 128, 129, 254, 255] {
+            let actual = il << shift;
+            let (expected, _) = i256::from_bigint_with_overflow(bl.clone() << shift);
+            assert_eq!(actual.to_string(), expected.to_string());
+
+            let actual = il >> shift;
+            let (expected, _) = i256::from_bigint_with_overflow(bl.clone() >> shift);
+            assert_eq!(actual.to_string(), expected.to_string());
+        }
+    }
+
+    #[test]
+    fn test_i256() {
+        let candidates = [
+            i256::ZERO,
+            i256::ONE,
+            i256::MINUS_ONE,
+            i256::from_i128(2),
+            i256::from_i128(-2),
+            i256::from_parts(u128::MAX, 1),
+            i256::from_parts(u128::MAX, -1),
+            i256::from_parts(0, 1),
+            i256::from_parts(0, -1),
+            i256::from_parts(1, -1),
+            i256::from_parts(1, 1),
+            i256::from_parts(0, i128::MAX),
+            i256::from_parts(0, i128::MIN),
+            i256::from_parts(1, i128::MAX),
+            i256::from_parts(1, i128::MIN),
+            i256::from_parts(u128::MAX, i128::MIN),
+            i256::from_parts(100, 32),
+            i256::MIN,
+            i256::MAX,
+            i256::MIN >> 1,
+            i256::MAX >> 1,
+            i256::ONE << 127,
+            i256::ONE << 128,
+            i256::ONE << 129,
+            i256::MINUS_ONE << 127,
+            i256::MINUS_ONE << 128,
+            i256::MINUS_ONE << 129,
+        ];
+
+        for il in candidates {
+            for ir in candidates {
+                test_ops(il, ir)
+            }
+        }
+    }
+
+    #[test]
+    fn test_signed_ops() {
+        // signum
+        assert_eq!(i256::from_i128(1).signum(), i256::ONE);
+        assert_eq!(i256::from_i128(0).signum(), i256::ZERO);
+        assert_eq!(i256::from_i128(-0).signum(), i256::ZERO);
+        assert_eq!(i256::from_i128(-1).signum(), i256::MINUS_ONE);
+
+        // is_positive
+        assert!(i256::from_i128(1).is_positive());
+        assert!(!i256::from_i128(0).is_positive());
+        assert!(!i256::from_i128(-0).is_positive());
+        assert!(!i256::from_i128(-1).is_positive());
+
+        // is_negative
+        assert!(!i256::from_i128(1).is_negative());
+        assert!(!i256::from_i128(0).is_negative());
+        assert!(!i256::from_i128(-0).is_negative());
+        assert!(i256::from_i128(-1).is_negative());
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn test_i256_fuzz() {
+        let mut rng = thread_rng();
+
+        for _ in 0..1000 {
+            let mut l = [0_u8; 32];
+            let len = rng.gen_range(0..32);
+            l.iter_mut().take(len).for_each(|x| *x = rng.gen());
+
+            let mut r = [0_u8; 32];
+            let len = rng.gen_range(0..32);
+            r.iter_mut().take(len).for_each(|x| *x = rng.gen());
+
+            test_ops(i256::from_le_bytes(l), i256::from_le_bytes(r))
+        }
+    }
+
+    #[test]
+    fn test_i256_to_primitive() {
+        let a = i256::MAX;
+        assert!(a.to_i64().is_none());
+        assert!(a.to_u64().is_none());
+
+        let a = i256::from_i128(i128::MAX);
+        assert!(a.to_i64().is_none());
+        assert!(a.to_u64().is_none());
+
+        let a = i256::from_i128(i64::MAX as i128);
+        assert_eq!(a.to_i64().unwrap(), i64::MAX);
+        assert_eq!(a.to_u64().unwrap(), i64::MAX as u64);
+
+        let a = i256::from_i128(i64::MAX as i128 + 1);
+        assert!(a.to_i64().is_none());
+        assert_eq!(a.to_u64().unwrap(), i64::MAX as u64 + 1);
+
+        let a = i256::MIN;
+        assert!(a.to_i64().is_none());
+        assert!(a.to_u64().is_none());
+
+        let a = i256::from_i128(i128::MIN);
+        assert!(a.to_i64().is_none());
+        assert!(a.to_u64().is_none());
+
+        let a = i256::from_i128(i64::MIN as i128);
+        assert_eq!(a.to_i64().unwrap(), i64::MIN);
+        assert!(a.to_u64().is_none());
+
+        let a = i256::from_i128(i64::MIN as i128 - 1);
+        assert!(a.to_i64().is_none());
+        assert!(a.to_u64().is_none());
+    }
+
+    #[test]
+    fn test_i256_as_i128() {
+        let a = i256::from_i128(i128::MAX).wrapping_add(i256::from_i128(1));
+        let i128 = a.as_i128();
+        assert_eq!(i128, i128::MIN);
+
+        let a = i256::from_i128(i128::MAX).wrapping_add(i256::from_i128(2));
+        let i128 = a.as_i128();
+        assert_eq!(i128, i128::MIN + 1);
+
+        let a = i256::from_i128(i128::MIN).wrapping_sub(i256::from_i128(1));
+        let i128 = a.as_i128();
+        assert_eq!(i128, i128::MAX);
+
+        let a = i256::from_i128(i128::MIN).wrapping_sub(i256::from_i128(2));
+        let i128 = a.as_i128();
+        assert_eq!(i128, i128::MAX - 1);
+    }
+
+    #[test]
+    fn test_string_roundtrip() {
+        let roundtrip_cases = [
+            i256::ZERO,
+            i256::ONE,
+            i256::MINUS_ONE,
+            i256::from_i128(123456789),
+            i256::from_i128(-123456789),
+            i256::from_i128(i128::MIN),
+            i256::from_i128(i128::MAX),
+            i256::MIN,
+            i256::MAX,
+        ];
+        for case in roundtrip_cases {
+            let formatted = case.to_string();
+            let back: i256 = formatted.parse().unwrap();
+            assert_eq!(case, back);
+        }
+    }
+
+    #[test]
+    fn test_from_string() {
+        let cases = [
+            (
+                "000000000000000000000000000000000000000011",
+                Some(i256::from_i128(11)),
+            ),
+            (
+                "-000000000000000000000000000000000000000011",
+                Some(i256::from_i128(-11)),
+            ),
+            (
+                "-0000000000000000000000000000000000000000123456789",
+                Some(i256::from_i128(-123456789)),
+            ),
+            ("-", None),
+            ("+", None),
+            ("--1", None),
+            ("-+1", None),
+            ("000000000000000000000000000000000000000", Some(i256::ZERO)),
+            ("0000000000000000000000000000000000000000-11", None),
+            ("11-1111111111111111111111111111111111111", None),
+            (
+                "115792089237316195423570985008687907853269984665640564039457584007913129639936",
+                None,
+            ),
+        ];
+        for (case, expected) in cases {
+            assert_eq!(i256::from_string(case), expected)
+        }
+    }
+
+    #[allow(clippy::op_ref)]
+    fn test_reference_op(il: i256, ir: i256) {
+        let r1 = il + ir;
+        let r2 = &il + ir;
+        let r3 = il + &ir;
+        let r4 = &il + &ir;
+        assert_eq!(r1, r2);
+        assert_eq!(r1, r3);
+        assert_eq!(r1, r4);
+
+        let r1 = il - ir;
+        let r2 = &il - ir;
+        let r3 = il - &ir;
+        let r4 = &il - &ir;
+        assert_eq!(r1, r2);
+        assert_eq!(r1, r3);
+        assert_eq!(r1, r4);
+
+        let r1 = il * ir;
+        let r2 = &il * ir;
+        let r3 = il * &ir;
+        let r4 = &il * &ir;
+        assert_eq!(r1, r2);
+        assert_eq!(r1, r3);
+        assert_eq!(r1, r4);
+
+        let r1 = il / ir;
+        let r2 = &il / ir;
+        let r3 = il / &ir;
+        let r4 = &il / &ir;
+        assert_eq!(r1, r2);
+        assert_eq!(r1, r3);
+        assert_eq!(r1, r4);
+    }
+
+    #[test]
+    fn test_i256_reference_op() {
+        let candidates = [
+            i256::ONE,
+            i256::MINUS_ONE,
+            i256::from_i128(2),
+            i256::from_i128(-2),
+            i256::from_i128(3),
+            i256::from_i128(-3),
+        ];
+
+        for il in candidates {
+            for ir in candidates {
+                test_reference_op(il, ir)
+            }
+        }
+    }
+}
diff --git a/arrow-buffer/src/buffer/boolean.rs b/arrow-buffer/src/buffer/boolean.rs
new file mode 100644
index 000000000000..1589cc5b102b
--- /dev/null
+++ b/arrow-buffer/src/buffer/boolean.rs
@@ -0,0 +1,417 @@
+// 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.
+
+use crate::bit_chunk_iterator::BitChunks;
+use crate::bit_iterator::{BitIndexIterator, BitIterator, BitSliceIterator};
+use crate::{
+    bit_util, buffer_bin_and, buffer_bin_or, buffer_bin_xor, buffer_unary_not,
+    BooleanBufferBuilder, Buffer, MutableBuffer,
+};
+use std::ops::{BitAnd, BitOr, BitXor, Not};
+
+/// A slice-able [`Buffer`] containing bit-packed booleans
+#[derive(Debug, Clone, Eq)]
+pub struct BooleanBuffer {
+    buffer: Buffer,
+    offset: usize,
+    len: usize,
+}
+
+impl PartialEq for BooleanBuffer {
+    fn eq(&self, other: &Self) -> bool {
+        if self.len != other.len {
+            return false;
+        }
+
+        let lhs = self.bit_chunks().iter_padded();
+        let rhs = other.bit_chunks().iter_padded();
+        lhs.zip(rhs).all(|(a, b)| a == b)
+    }
+}
+
+impl BooleanBuffer {
+    /// Create a new [`BooleanBuffer`] from a [`Buffer`], an `offset` and `length` in bits
+    ///
+    /// # Panics
+    ///
+    /// This method will panic if `buffer` is not large enough
+    pub fn new(buffer: Buffer, offset: usize, len: usize) -> Self {
+        let total_len = offset.saturating_add(len);
+        let bit_len = buffer.len().saturating_mul(8);
+        assert!(total_len <= bit_len);
+        Self {
+            buffer,
+            offset,
+            len,
+        }
+    }
+
+    /// Create a new [`BooleanBuffer`] of `length` where all values are `true`
+    pub fn new_set(length: usize) -> Self {
+        let mut builder = BooleanBufferBuilder::new(length);
+        builder.append_n(length, true);
+        builder.finish()
+    }
+
+    /// Create a new [`BooleanBuffer`] of `length` where all values are `false`
+    pub fn new_unset(length: usize) -> Self {
+        let buffer = MutableBuffer::new_null(length).into_buffer();
+        Self {
+            buffer,
+            offset: 0,
+            len: length,
+        }
+    }
+
+    /// Invokes `f` with indexes `0..len` collecting the boolean results into a new `BooleanBuffer`
+    pub fn collect_bool<F: FnMut(usize) -> bool>(len: usize, f: F) -> Self {
+        let buffer = MutableBuffer::collect_bool(len, f);
+        Self::new(buffer.into(), 0, len)
+    }
+
+    /// Returns the number of set bits in this buffer
+    pub fn count_set_bits(&self) -> usize {
+        self.buffer.count_set_bits_offset(self.offset, self.len)
+    }
+
+    /// Returns a `BitChunks` instance which can be used to iterate over
+    /// this buffer's bits in `u64` chunks
+    #[inline]
+    pub fn bit_chunks(&self) -> BitChunks {
+        BitChunks::new(self.values(), self.offset, self.len)
+    }
+
+    /// Returns `true` if the bit at index `i` is set
+    ///
+    /// # Panics
+    ///
+    /// Panics if `i >= self.len()`
+    #[inline]
+    #[deprecated(note = "use BooleanBuffer::value")]
+    pub fn is_set(&self, i: usize) -> bool {
+        self.value(i)
+    }
+
+    /// Returns the offset of this [`BooleanBuffer`] in bits
+    #[inline]
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
+
+    /// Returns the length of this [`BooleanBuffer`] in bits
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns true if this [`BooleanBuffer`] is empty
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// Returns the boolean value at index `i`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `i >= self.len()`
+    #[inline]
+    pub fn value(&self, idx: usize) -> bool {
+        assert!(idx < self.len);
+        unsafe { self.value_unchecked(idx) }
+    }
+
+    /// Returns the boolean value at index `i`.
+    ///
+    /// # Safety
+    /// This doesn't check bounds, the caller must ensure that index < self.len()
+    #[inline]
+    pub unsafe fn value_unchecked(&self, i: usize) -> bool {
+        unsafe { bit_util::get_bit_raw(self.buffer.as_ptr(), i + self.offset) }
+    }
+
+    /// Returns the packed values of this [`BooleanBuffer`] not including any offset
+    #[inline]
+    pub fn values(&self) -> &[u8] {
+        &self.buffer
+    }
+
+    /// Slices this [`BooleanBuffer`] by the provided `offset` and `length`
+    pub fn slice(&self, offset: usize, len: usize) -> Self {
+        assert!(
+            offset.saturating_add(len) <= self.len,
+            "the length + offset of the sliced BooleanBuffer cannot exceed the existing length"
+        );
+        Self {
+            buffer: self.buffer.clone(),
+            offset: self.offset + offset,
+            len,
+        }
+    }
+
+    /// Returns a [`Buffer`] containing the sliced contents of this [`BooleanBuffer`]
+    ///
+    /// Equivalent to `self.buffer.bit_slice(self.offset, self.len)`
+    pub fn sliced(&self) -> Buffer {
+        self.buffer.bit_slice(self.offset, self.len)
+    }
+
+    /// Returns true if this [`BooleanBuffer`] is equal to `other`, using pointer comparisons
+    /// to determine buffer equality. This is cheaper than `PartialEq::eq` but may
+    /// return false when the arrays are logically equal
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        self.buffer.as_ptr() == other.buffer.as_ptr()
+            && self.offset == other.offset
+            && self.len == other.len
+    }
+
+    /// Returns the inner [`Buffer`]
+    #[inline]
+    pub fn inner(&self) -> &Buffer {
+        &self.buffer
+    }
+
+    /// Returns the inner [`Buffer`], consuming self
+    pub fn into_inner(self) -> Buffer {
+        self.buffer
+    }
+
+    /// Returns an iterator over the bits in this [`BooleanBuffer`]
+    pub fn iter(&self) -> BitIterator<'_> {
+        self.into_iter()
+    }
+
+    /// Returns an iterator over the set bit positions in this [`BooleanBuffer`]
+    pub fn set_indices(&self) -> BitIndexIterator<'_> {
+        BitIndexIterator::new(self.values(), self.offset, self.len)
+    }
+
+    /// Returns a [`BitSliceIterator`] yielding contiguous ranges of set bits
+    pub fn set_slices(&self) -> BitSliceIterator<'_> {
+        BitSliceIterator::new(self.values(), self.offset, self.len)
+    }
+}
+
+impl Not for &BooleanBuffer {
+    type Output = BooleanBuffer;
+
+    fn not(self) -> Self::Output {
+        BooleanBuffer {
+            buffer: buffer_unary_not(&self.buffer, self.offset, self.len),
+            offset: 0,
+            len: self.len,
+        }
+    }
+}
+
+impl BitAnd<&BooleanBuffer> for &BooleanBuffer {
+    type Output = BooleanBuffer;
+
+    fn bitand(self, rhs: &BooleanBuffer) -> Self::Output {
+        assert_eq!(self.len, rhs.len);
+        BooleanBuffer {
+            buffer: buffer_bin_and(&self.buffer, self.offset, &rhs.buffer, rhs.offset, self.len),
+            offset: 0,
+            len: self.len,
+        }
+    }
+}
+
+impl BitOr<&BooleanBuffer> for &BooleanBuffer {
+    type Output = BooleanBuffer;
+
+    fn bitor(self, rhs: &BooleanBuffer) -> Self::Output {
+        assert_eq!(self.len, rhs.len);
+        BooleanBuffer {
+            buffer: buffer_bin_or(&self.buffer, self.offset, &rhs.buffer, rhs.offset, self.len),
+            offset: 0,
+            len: self.len,
+        }
+    }
+}
+
+impl BitXor<&BooleanBuffer> for &BooleanBuffer {
+    type Output = BooleanBuffer;
+
+    fn bitxor(self, rhs: &BooleanBuffer) -> Self::Output {
+        assert_eq!(self.len, rhs.len);
+        BooleanBuffer {
+            buffer: buffer_bin_xor(&self.buffer, self.offset, &rhs.buffer, rhs.offset, self.len),
+            offset: 0,
+            len: self.len,
+        }
+    }
+}
+
+impl<'a> IntoIterator for &'a BooleanBuffer {
+    type Item = bool;
+    type IntoIter = BitIterator<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        BitIterator::new(self.values(), self.offset, self.len)
+    }
+}
+
+impl From<&[bool]> for BooleanBuffer {
+    fn from(value: &[bool]) -> Self {
+        let mut builder = BooleanBufferBuilder::new(value.len());
+        builder.append_slice(value);
+        builder.finish()
+    }
+}
+
+impl From<Vec<bool>> for BooleanBuffer {
+    fn from(value: Vec<bool>) -> Self {
+        value.as_slice().into()
+    }
+}
+
+impl FromIterator<bool> for BooleanBuffer {
+    fn from_iter<T: IntoIterator<Item = bool>>(iter: T) -> Self {
+        let iter = iter.into_iter();
+        let (hint, _) = iter.size_hint();
+        let mut builder = BooleanBufferBuilder::new(hint);
+        iter.for_each(|b| builder.append(b));
+        builder.finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_boolean_new() {
+        let bytes = &[0, 1, 2, 3, 4];
+        let buf = Buffer::from(bytes);
+        let offset = 0;
+        let len = 24;
+
+        let boolean_buf = BooleanBuffer::new(buf.clone(), offset, len);
+        assert_eq!(bytes, boolean_buf.values());
+        assert_eq!(offset, boolean_buf.offset());
+        assert_eq!(len, boolean_buf.len());
+
+        assert_eq!(2, boolean_buf.count_set_bits());
+        assert_eq!(&buf, boolean_buf.inner());
+        assert_eq!(buf, boolean_buf.clone().into_inner());
+
+        assert!(!boolean_buf.is_empty())
+    }
+
+    #[test]
+    fn test_boolean_data_equality() {
+        let boolean_buf1 = BooleanBuffer::new(Buffer::from(&[0, 1, 4, 3, 5]), 0, 32);
+        let boolean_buf2 = BooleanBuffer::new(Buffer::from(&[0, 1, 4, 3, 5]), 0, 32);
+        assert_eq!(boolean_buf1, boolean_buf2);
+
+        // slice with same offset and same length should still preserve equality
+        let boolean_buf3 = boolean_buf1.slice(8, 16);
+        assert_ne!(boolean_buf1, boolean_buf3);
+        let boolean_buf4 = boolean_buf1.slice(0, 32);
+        assert_eq!(boolean_buf1, boolean_buf4);
+
+        // unequal because of different elements
+        let boolean_buf2 = BooleanBuffer::new(Buffer::from(&[0, 0, 2, 3, 4]), 0, 32);
+        assert_ne!(boolean_buf1, boolean_buf2);
+
+        // unequal because of different length
+        let boolean_buf2 = BooleanBuffer::new(Buffer::from(&[0, 1, 4, 3, 5]), 0, 24);
+        assert_ne!(boolean_buf1, boolean_buf2);
+
+        // ptr_eq
+        assert!(boolean_buf1.ptr_eq(&boolean_buf1));
+        assert!(boolean_buf2.ptr_eq(&boolean_buf2));
+        assert!(!boolean_buf1.ptr_eq(&boolean_buf2));
+    }
+
+    #[test]
+    fn test_boolean_slice() {
+        let bytes = &[0, 3, 2, 6, 2];
+        let boolean_buf1 = BooleanBuffer::new(Buffer::from(bytes), 0, 32);
+        let boolean_buf2 = BooleanBuffer::new(Buffer::from(bytes), 0, 32);
+
+        let boolean_slice1 = boolean_buf1.slice(16, 16);
+        let boolean_slice2 = boolean_buf2.slice(0, 16);
+        assert_eq!(boolean_slice1.values(), boolean_slice2.values());
+
+        assert_eq!(bytes, boolean_slice1.values());
+        assert_eq!(16, boolean_slice1.offset);
+        assert_eq!(16, boolean_slice1.len);
+
+        assert_eq!(bytes, boolean_slice2.values());
+        assert_eq!(0, boolean_slice2.offset);
+        assert_eq!(16, boolean_slice2.len);
+    }
+
+    #[test]
+    fn test_boolean_bitand() {
+        let offset = 0;
+        let len = 40;
+
+        let buf1 = Buffer::from(&[0, 1, 1, 0, 0]);
+        let boolean_buf1 = &BooleanBuffer::new(buf1, offset, len);
+
+        let buf2 = Buffer::from(&[0, 1, 1, 1, 0]);
+        let boolean_buf2 = &BooleanBuffer::new(buf2, offset, len);
+
+        let expected = BooleanBuffer::new(Buffer::from(&[0, 1, 1, 0, 0]), offset, len);
+        assert_eq!(boolean_buf1 & boolean_buf2, expected);
+    }
+
+    #[test]
+    fn test_boolean_bitor() {
+        let offset = 0;
+        let len = 40;
+
+        let buf1 = Buffer::from(&[0, 1, 1, 0, 0]);
+        let boolean_buf1 = &BooleanBuffer::new(buf1, offset, len);
+
+        let buf2 = Buffer::from(&[0, 1, 1, 1, 0]);
+        let boolean_buf2 = &BooleanBuffer::new(buf2, offset, len);
+
+        let expected = BooleanBuffer::new(Buffer::from(&[0, 1, 1, 1, 0]), offset, len);
+        assert_eq!(boolean_buf1 | boolean_buf2, expected);
+    }
+
+    #[test]
+    fn test_boolean_bitxor() {
+        let offset = 0;
+        let len = 40;
+
+        let buf1 = Buffer::from(&[0, 1, 1, 0, 0]);
+        let boolean_buf1 = &BooleanBuffer::new(buf1, offset, len);
+
+        let buf2 = Buffer::from(&[0, 1, 1, 1, 0]);
+        let boolean_buf2 = &BooleanBuffer::new(buf2, offset, len);
+
+        let expected = BooleanBuffer::new(Buffer::from(&[0, 0, 0, 1, 0]), offset, len);
+        assert_eq!(boolean_buf1 ^ boolean_buf2, expected);
+    }
+
+    #[test]
+    fn test_boolean_not() {
+        let offset = 0;
+        let len = 40;
+
+        let buf = Buffer::from(&[0, 1, 1, 0, 0]);
+        let boolean_buf = &BooleanBuffer::new(buf, offset, len);
+
+        let expected = BooleanBuffer::new(Buffer::from(&[255, 254, 254, 255, 255]), offset, len);
+        assert_eq!(!boolean_buf, expected);
+    }
+}
diff --git a/arrow/src/buffer/immutable.rs b/arrow-buffer/src/buffer/immutable.rs
similarity index 59%
rename from arrow/src/buffer/immutable.rs
rename to arrow-buffer/src/buffer/immutable.rs
index 8ec5a4554208..ca3ee6260ba7 100644
--- a/arrow/src/buffer/immutable.rs
+++ b/arrow-buffer/src/buffer/immutable.rs
@@ -15,50 +15,79 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::alloc::Layout;
 use std::fmt::Debug;
 use std::iter::FromIterator;
 use std::ptr::NonNull;
 use std::sync::Arc;
-use std::{convert::AsRef, usize};
 
-use crate::alloc::{Allocation, Deallocation};
+use crate::alloc::{Allocation, Deallocation, ALIGNMENT};
 use crate::util::bit_chunk_iterator::{BitChunks, UnalignedBitChunk};
-use crate::{bytes::Bytes, datatypes::ArrowNativeType};
+use crate::BufferBuilder;
+use crate::{bytes::Bytes, native::ArrowNativeType};
 
 use super::ops::bitwise_unary_op_helper;
 use super::MutableBuffer;
 
 /// Buffer represents a contiguous memory region that can be shared with other buffers and across
 /// thread boundaries.
-#[derive(Clone, PartialEq, Debug)]
+#[derive(Clone, Debug)]
 pub struct Buffer {
     /// the internal byte buffer.
     data: Arc<Bytes>,
 
-    /// The offset into the buffer.
-    offset: usize,
+    /// Pointer into `data` valid
+    ///
+    /// We store a pointer instead of an offset to avoid pointer arithmetic
+    /// which causes LLVM to fail to vectorise code correctly
+    ptr: *const u8,
+
+    /// Byte length of the buffer.
+    ///
+    /// Must be less than or equal to `data.len()`
+    length: usize,
+}
+
+impl PartialEq for Buffer {
+    fn eq(&self, other: &Self) -> bool {
+        self.as_slice().eq(other.as_slice())
+    }
 }
 
+impl Eq for Buffer {}
+
+unsafe impl Send for Buffer where Bytes: Send {}
+unsafe impl Sync for Buffer where Bytes: Sync {}
+
 impl Buffer {
     /// Auxiliary method to create a new Buffer
     #[inline]
     pub fn from_bytes(bytes: Bytes) -> Self {
+        let length = bytes.len();
+        let ptr = bytes.as_ptr();
         Buffer {
             data: Arc::new(bytes),
-            offset: 0,
+            ptr,
+            length,
         }
     }
 
+    /// Create a [`Buffer`] from the provided [`Vec`] without copying
+    #[inline]
+    pub fn from_vec<T: ArrowNativeType>(vec: Vec<T>) -> Self {
+        MutableBuffer::from(vec).into()
+    }
+
     /// Initializes a [Buffer] from a slice of items.
-    pub fn from_slice_ref<U: ArrowNativeType, T: AsRef<[U]>>(items: &T) -> Self {
+    pub fn from_slice_ref<U: ArrowNativeType, T: AsRef<[U]>>(items: T) -> Self {
         let slice = items.as_ref();
-        let capacity = slice.len() * std::mem::size_of::<U>();
+        let capacity = std::mem::size_of_val(slice);
         let mut buffer = MutableBuffer::with_capacity(capacity);
         buffer.extend_from_slice(slice);
         buffer.into()
     }
 
-    /// Creates a buffer from an existing memory region (must already be byte-aligned), this
+    /// Creates a buffer from an existing aligned memory region (must already be byte-aligned), this
     /// `Buffer` will free this piece of memory when dropped.
     ///
     /// # Arguments
@@ -71,9 +100,11 @@ impl Buffer {
     ///
     /// This function is unsafe as there is no guarantee that the given pointer is valid for `len`
     /// bytes. If the `ptr` and `capacity` come from a `Buffer`, then this is guaranteed.
+    #[deprecated(note = "Use Buffer::from_vec")]
     pub unsafe fn from_raw_parts(ptr: NonNull<u8>, len: usize, capacity: usize) -> Self {
         assert!(len <= capacity);
-        Buffer::build_with_arguments(ptr, len, Deallocation::Arrow(capacity))
+        let layout = Layout::from_size_align(capacity, ALIGNMENT).unwrap();
+        Buffer::build_with_arguments(ptr, len, Deallocation::Standard(layout))
     }
 
     /// Creates a buffer from an existing memory region. Ownership of the memory is tracked via reference counting
@@ -93,7 +124,7 @@ impl Buffer {
         len: usize,
         owner: Arc<dyn Allocation>,
     ) -> Self {
-        Buffer::build_with_arguments(ptr, len, Deallocation::Custom(owner))
+        Buffer::build_with_arguments(ptr, len, Deallocation::Custom(owner, len))
     }
 
     /// Auxiliary method to create a new Buffer
@@ -103,31 +134,40 @@ impl Buffer {
         deallocation: Deallocation,
     ) -> Self {
         let bytes = Bytes::new(ptr, len, deallocation);
+        let ptr = bytes.as_ptr();
         Buffer {
+            ptr,
             data: Arc::new(bytes),
-            offset: 0,
+            length: len,
         }
     }
 
     /// Returns the number of bytes in the buffer
+    #[inline]
     pub fn len(&self) -> usize {
-        self.data.len() - self.offset
+        self.length
     }
 
     /// Returns the capacity of this buffer.
     /// For externally owned buffers, this returns zero
+    #[inline]
     pub fn capacity(&self) -> usize {
         self.data.capacity()
     }
 
     /// Returns whether the buffer is empty.
+    #[inline]
     pub fn is_empty(&self) -> bool {
-        self.data.len() - self.offset == 0
+        self.length == 0
     }
 
     /// Returns the byte slice stored in this buffer
     pub fn as_slice(&self) -> &[u8] {
-        &self.data[self.offset..]
+        unsafe { std::slice::from_raw_parts(self.ptr, self.length) }
+    }
+
+    pub(crate) fn deallocation(&self) -> &Deallocation {
+        self.data.deallocation()
     }
 
     /// Returns a new [Buffer] that is a slice of this buffer starting at `offset`.
@@ -136,12 +176,38 @@ impl Buffer {
     /// Panics iff `offset` is larger than `len`.
     pub fn slice(&self, offset: usize) -> Self {
         assert!(
-            offset <= self.len(),
+            offset <= self.length,
+            "the offset of the new Buffer cannot exceed the existing length"
+        );
+        // Safety:
+        // This cannot overflow as
+        // `self.offset + self.length < self.data.len()`
+        // `offset < self.length`
+        let ptr = unsafe { self.ptr.add(offset) };
+        Self {
+            data: self.data.clone(),
+            length: self.length - offset,
+            ptr,
+        }
+    }
+
+    /// Returns a new [Buffer] that is a slice of this buffer starting at `offset`,
+    /// with `length` bytes.
+    /// Doing so allows the same memory region to be shared between buffers.
+    /// # Panics
+    /// Panics iff `(offset + length)` is larger than the existing length.
+    pub fn slice_with_length(&self, offset: usize, length: usize) -> Self {
+        assert!(
+            offset.saturating_add(length) <= self.length,
             "the offset of the new Buffer cannot exceed the existing length"
         );
+        // Safety:
+        // offset + length <= self.length
+        let ptr = unsafe { self.ptr.add(offset) };
         Self {
             data: self.data.clone(),
-            offset: self.offset + offset,
+            ptr,
+            length,
         }
     }
 
@@ -151,10 +217,10 @@ impl Buffer {
     /// stored anywhere, to avoid dangling pointers.
     #[inline]
     pub fn as_ptr(&self) -> *const u8 {
-        unsafe { self.data.ptr().as_ptr().add(self.offset) }
+        self.ptr
     }
 
-    /// View buffer as typed slice.
+    /// View buffer as a slice of a specific type.
     ///
     /// # Panics
     ///
@@ -188,6 +254,7 @@ impl Buffer {
     }
 
     /// Returns the number of 1-bits in this buffer.
+    #[deprecated(note = "use count_set_bits_offset instead")]
     pub fn count_set_bits(&self) -> usize {
         let len_in_bits = self.len() * 8;
         // self.offset is already taken into consideration by the bit_chunks implementation
@@ -199,6 +266,72 @@ impl Buffer {
     pub fn count_set_bits_offset(&self, offset: usize, len: usize) -> usize {
         UnalignedBitChunk::new(self.as_slice(), offset, len).count_ones()
     }
+
+    /// Returns `MutableBuffer` for mutating the buffer if this buffer is not shared.
+    /// Returns `Err` if this is shared or its allocation is from an external source or
+    /// it is not allocated with alignment [`ALIGNMENT`]
+    pub fn into_mutable(self) -> Result<MutableBuffer, Self> {
+        let ptr = self.ptr;
+        let length = self.length;
+        Arc::try_unwrap(self.data)
+            .and_then(|bytes| {
+                // The pointer of underlying buffer should not be offset.
+                assert_eq!(ptr, bytes.ptr().as_ptr());
+                MutableBuffer::from_bytes(bytes).map_err(Arc::new)
+            })
+            .map_err(|bytes| Buffer {
+                data: bytes,
+                ptr,
+                length,
+            })
+    }
+
+    /// Returns `Vec` for mutating the buffer
+    ///
+    /// Returns `Err(self)` if this buffer does not have the same [`Layout`] as
+    /// the destination Vec or contains a non-zero offset
+    pub fn into_vec<T: ArrowNativeType>(self) -> Result<Vec<T>, Self> {
+        let layout = match self.data.deallocation() {
+            Deallocation::Standard(l) => l,
+            _ => return Err(self), // Custom allocation
+        };
+
+        if self.ptr != self.data.as_ptr() {
+            return Err(self); // Data is offset
+        }
+
+        let v_capacity = layout.size() / std::mem::size_of::<T>();
+        match Layout::array::<T>(v_capacity) {
+            Ok(expected) if layout == &expected => {}
+            _ => return Err(self), // Incorrect layout
+        }
+
+        let length = self.length;
+        let ptr = self.ptr;
+        let v_len = self.length / std::mem::size_of::<T>();
+
+        Arc::try_unwrap(self.data)
+            .map(|bytes| unsafe {
+                let ptr = bytes.ptr().as_ptr() as _;
+                std::mem::forget(bytes);
+                // Safety
+                // Verified that bytes layout matches that of Vec
+                Vec::from_raw_parts(ptr, v_len, v_capacity)
+            })
+            .map_err(|bytes| Buffer {
+                data: bytes,
+                ptr,
+                length,
+            })
+    }
+
+    /// Returns true if this [`Buffer`] is equal to `other`, using pointer comparisons
+    /// to determine buffer equality. This is cheaper than `PartialEq::eq` but may
+    /// return false when the arrays are logically equal
+    #[inline]
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        self.ptr == other.ptr && self.length == other.length
+    }
 }
 
 /// Creating a `Buffer` instance by copying the memory from a `AsRef<[u8]>` into a newly
@@ -215,7 +348,7 @@ impl<T: AsRef<[u8]>> From<T> for Buffer {
 }
 
 /// Creating a `Buffer` instance by storing the boolean values into the buffer
-impl std::iter::FromIterator<bool> for Buffer {
+impl FromIterator<bool> for Buffer {
     fn from_iter<I>(iter: I) -> Self
     where
         I: IntoIterator<Item = bool>,
@@ -239,12 +372,18 @@ impl From<MutableBuffer> for Buffer {
     }
 }
 
+impl<T: ArrowNativeType> From<BufferBuilder<T>> for Buffer {
+    fn from(mut value: BufferBuilder<T>) -> Self {
+        value.finish()
+    }
+}
+
 impl Buffer {
     /// Creates a [`Buffer`] from an [`Iterator`] with a trusted (upper) length.
     /// Prefer this to `collect` whenever possible, as it is ~60% faster.
     /// # Example
     /// ```
-    /// # use arrow::buffer::Buffer;
+    /// # use arrow_buffer::buffer::Buffer;
     /// let v = vec![1u32];
     /// let iter = v.iter().map(|x| x * 2);
     /// let buffer = unsafe { Buffer::from_trusted_len_iter(iter) };
@@ -274,10 +413,10 @@ impl Buffer {
     pub unsafe fn try_from_trusted_len_iter<
         E,
         T: ArrowNativeType,
-        I: Iterator<Item = std::result::Result<T, E>>,
+        I: Iterator<Item = Result<T, E>>,
     >(
         iterator: I,
-    ) -> std::result::Result<Self, E> {
+    ) -> Result<Self, E> {
         Ok(MutableBuffer::try_from_trusted_len_iter(iterator)?.into())
     }
 }
@@ -292,7 +431,7 @@ impl<T: ArrowNativeType> FromIterator<T> for Buffer {
             None => MutableBuffer::new(0),
             Some(element) => {
                 let (lower, _) = iterator.size_hint();
-                let mut buffer = MutableBuffer::new(lower.saturating_add(1) * size);
+                let mut buffer = MutableBuffer::new(lower.saturating_add(1).saturating_mul(size));
                 unsafe {
                     std::ptr::write(buffer.as_mut_ptr() as *mut T, element);
                     buffer.set_len(size);
@@ -308,6 +447,7 @@ impl<T: ArrowNativeType> FromIterator<T> for Buffer {
 
 #[cfg(test)]
 mod tests {
+    use crate::i256;
     use std::panic::{RefUnwindSafe, UnwindSafe};
     use std::thread;
 
@@ -319,10 +459,10 @@ mod tests {
         let buf2 = Buffer::from(&[0, 1, 2, 3, 4]);
         assert_eq!(buf1, buf2);
 
-        // slice with same offset should still preserve equality
+        // slice with same offset and same length should still preserve equality
         let buf3 = buf1.slice(2);
         assert_ne!(buf1, buf3);
-        let buf4 = buf2.slice(2);
+        let buf4 = buf2.slice_with_length(2, 3);
         assert_eq!(buf3, buf4);
 
         // Different capacities should still preserve equality
@@ -376,7 +516,7 @@ mod tests {
         assert_eq!(3, buf2.len());
         assert_eq!(unsafe { buf.as_ptr().offset(2) }, buf2.as_ptr());
 
-        let buf3 = buf2.slice(1);
+        let buf3 = buf2.slice_with_length(1, 2);
         assert_eq!([8, 10], buf3.as_slice());
         assert_eq!(2, buf3.len());
         assert_eq!(unsafe { buf.as_ptr().offset(3) }, buf3.as_ptr());
@@ -386,13 +526,11 @@ mod tests {
         assert_eq!(empty_slice, buf4.as_slice());
         assert_eq!(0, buf4.len());
         assert!(buf4.is_empty());
-        assert_eq!(buf2.slice(2).as_slice(), &[10]);
+        assert_eq!(buf2.slice_with_length(2, 1).as_slice(), &[10]);
     }
 
     #[test]
-    #[should_panic(
-        expected = "the offset of the new Buffer cannot exceed the existing length"
-    )]
+    #[should_panic(expected = "the offset of the new Buffer cannot exceed the existing length")]
     fn test_slice_offset_out_of_bound() {
         let buf = Buffer::from(&[2, 4, 6, 8, 10]);
         buf.slice(6);
@@ -439,11 +577,17 @@ mod tests {
 
     #[test]
     fn test_count_bits() {
-        assert_eq!(0, Buffer::from(&[0b00000000]).count_set_bits());
-        assert_eq!(8, Buffer::from(&[0b11111111]).count_set_bits());
-        assert_eq!(3, Buffer::from(&[0b00001101]).count_set_bits());
-        assert_eq!(6, Buffer::from(&[0b01001001, 0b01010010]).count_set_bits());
-        assert_eq!(16, Buffer::from(&[0b11111111, 0b11111111]).count_set_bits());
+        assert_eq!(0, Buffer::from(&[0b00000000]).count_set_bits_offset(0, 8));
+        assert_eq!(8, Buffer::from(&[0b11111111]).count_set_bits_offset(0, 8));
+        assert_eq!(3, Buffer::from(&[0b00001101]).count_set_bits_offset(0, 8));
+        assert_eq!(
+            6,
+            Buffer::from(&[0b01001001, 0b01010010]).count_set_bits_offset(0, 16)
+        );
+        assert_eq!(
+            16,
+            Buffer::from(&[0b11111111, 0b11111111]).count_set_bits_offset(0, 16)
+        );
     }
 
     #[test]
@@ -452,31 +596,31 @@ mod tests {
             0,
             Buffer::from(&[0b11111111, 0b00000000])
                 .slice(1)
-                .count_set_bits()
+                .count_set_bits_offset(0, 8)
         );
         assert_eq!(
             8,
             Buffer::from(&[0b11111111, 0b11111111])
-                .slice(1)
-                .count_set_bits()
+                .slice_with_length(1, 1)
+                .count_set_bits_offset(0, 8)
         );
         assert_eq!(
             3,
             Buffer::from(&[0b11111111, 0b11111111, 0b00001101])
                 .slice(2)
-                .count_set_bits()
+                .count_set_bits_offset(0, 8)
         );
         assert_eq!(
             6,
             Buffer::from(&[0b11111111, 0b01001001, 0b01010010])
-                .slice(1)
-                .count_set_bits()
+                .slice_with_length(1, 2)
+                .count_set_bits_offset(0, 16)
         );
         assert_eq!(
             16,
             Buffer::from(&[0b11111111, 0b11111111, 0b11111111, 0b11111111])
                 .slice(2)
-                .count_set_bits()
+                .count_set_bits_offset(0, 16)
         );
     }
 
@@ -547,4 +691,140 @@ mod tests {
         let slice = buffer.typed_data::<i32>();
         assert_eq!(slice, &[2, 3, 4, 5]);
     }
+
+    #[test]
+    #[should_panic(expected = "the offset of the new Buffer cannot exceed the existing length")]
+    fn slice_overflow() {
+        let buffer = Buffer::from(MutableBuffer::from_len_zeroed(12));
+        buffer.slice_with_length(2, usize::MAX);
+    }
+
+    #[test]
+    fn test_vec_interop() {
+        // Test empty vec
+        let a: Vec<i128> = Vec::new();
+        let b = Buffer::from_vec(a);
+        b.into_vec::<i128>().unwrap();
+
+        // Test vec with capacity
+        let a: Vec<i128> = Vec::with_capacity(20);
+        let b = Buffer::from_vec(a);
+        let back = b.into_vec::<i128>().unwrap();
+        assert_eq!(back.len(), 0);
+        assert_eq!(back.capacity(), 20);
+
+        // Test vec with values
+        let mut a: Vec<i128> = Vec::with_capacity(3);
+        a.extend_from_slice(&[1, 2, 3]);
+        let b = Buffer::from_vec(a);
+        let back = b.into_vec::<i128>().unwrap();
+        assert_eq!(back.len(), 3);
+        assert_eq!(back.capacity(), 3);
+
+        // Test vec with values and spare capacity
+        let mut a: Vec<i128> = Vec::with_capacity(20);
+        a.extend_from_slice(&[1, 4, 7, 8, 9, 3, 6]);
+        let b = Buffer::from_vec(a);
+        let back = b.into_vec::<i128>().unwrap();
+        assert_eq!(back.len(), 7);
+        assert_eq!(back.capacity(), 20);
+
+        // Test incorrect alignment
+        let a: Vec<i128> = Vec::new();
+        let b = Buffer::from_vec(a);
+        let b = b.into_vec::<i32>().unwrap_err();
+        b.into_vec::<i8>().unwrap_err();
+
+        // Test convert between types with same alignment
+        // This is an implementation quirk, but isn't harmful
+        // as ArrowNativeType are trivially transmutable
+        let a: Vec<i64> = vec![1, 2, 3, 4];
+        let b = Buffer::from_vec(a);
+        let back = b.into_vec::<u64>().unwrap();
+        assert_eq!(back.len(), 4);
+        assert_eq!(back.capacity(), 4);
+
+        // i256 has the same layout as i128 so this is valid
+        let mut b: Vec<i128> = Vec::with_capacity(4);
+        b.extend_from_slice(&[1, 2, 3, 4]);
+        let b = Buffer::from_vec(b);
+        let back = b.into_vec::<i256>().unwrap();
+        assert_eq!(back.len(), 2);
+        assert_eq!(back.capacity(), 2);
+
+        // Invalid layout
+        let b: Vec<i128> = vec![1, 2, 3];
+        let b = Buffer::from_vec(b);
+        b.into_vec::<i256>().unwrap_err();
+
+        // Invalid layout
+        let mut b: Vec<i128> = Vec::with_capacity(5);
+        b.extend_from_slice(&[1, 2, 3, 4]);
+        let b = Buffer::from_vec(b);
+        b.into_vec::<i256>().unwrap_err();
+
+        // Truncates length
+        // This is an implementation quirk, but isn't harmful
+        let mut b: Vec<i128> = Vec::with_capacity(4);
+        b.extend_from_slice(&[1, 2, 3]);
+        let b = Buffer::from_vec(b);
+        let back = b.into_vec::<i256>().unwrap();
+        assert_eq!(back.len(), 1);
+        assert_eq!(back.capacity(), 2);
+
+        // Cannot use aligned allocation
+        let b = Buffer::from(MutableBuffer::new(10));
+        let b = b.into_vec::<u8>().unwrap_err();
+        b.into_vec::<u64>().unwrap_err();
+
+        // Test slicing
+        let mut a: Vec<i128> = Vec::with_capacity(20);
+        a.extend_from_slice(&[1, 4, 7, 8, 9, 3, 6]);
+        let b = Buffer::from_vec(a);
+        let slice = b.slice_with_length(0, 64);
+
+        // Shared reference fails
+        let slice = slice.into_vec::<i128>().unwrap_err();
+        drop(b);
+
+        // Succeeds as no outstanding shared reference
+        let back = slice.into_vec::<i128>().unwrap();
+        assert_eq!(&back, &[1, 4, 7, 8]);
+        assert_eq!(back.capacity(), 20);
+
+        // Slicing by non-multiple length truncates
+        let mut a: Vec<i128> = Vec::with_capacity(8);
+        a.extend_from_slice(&[1, 4, 7, 3]);
+
+        let b = Buffer::from_vec(a);
+        let slice = b.slice_with_length(0, 34);
+        drop(b);
+
+        let back = slice.into_vec::<i128>().unwrap();
+        assert_eq!(&back, &[1, 4]);
+        assert_eq!(back.capacity(), 8);
+
+        // Offset prevents conversion
+        let a: Vec<u32> = vec![1, 3, 4, 6];
+        let b = Buffer::from_vec(a).slice(2);
+        b.into_vec::<u32>().unwrap_err();
+
+        let b = MutableBuffer::new(16).into_buffer();
+        let b = b.into_vec::<u8>().unwrap_err(); // Invalid layout
+        let b = b.into_vec::<u32>().unwrap_err(); // Invalid layout
+        b.into_mutable().unwrap();
+
+        let b = Buffer::from_vec(vec![1_u32, 3, 5]);
+        let b = b.into_mutable().unwrap();
+        let b = Buffer::from(b);
+        let b = b.into_vec::<u32>().unwrap();
+        assert_eq!(b, &[1, 3, 5]);
+    }
+
+    #[test]
+    #[should_panic(expected = "failed to round to next highest power of 2")]
+    fn test_from_iter_overflow() {
+        let iter_len = usize::MAX / std::mem::size_of::<u64>() + 1;
+        let _ = Buffer::from_iter(std::iter::repeat(0_u64).take(iter_len));
+    }
 }
diff --git a/arrow-buffer/src/buffer/mod.rs b/arrow-buffer/src/buffer/mod.rs
new file mode 100644
index 000000000000..d33e68795e4e
--- /dev/null
+++ b/arrow-buffer/src/buffer/mod.rs
@@ -0,0 +1,35 @@
+// 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.
+
+//! Types of shared memory region
+
+mod offset;
+pub use offset::*;
+mod immutable;
+pub use immutable::*;
+mod mutable;
+pub use mutable::*;
+mod ops;
+pub use ops::*;
+mod scalar;
+pub use scalar::*;
+mod boolean;
+pub use boolean::*;
+mod null;
+pub use null::*;
+mod run;
+pub use run::*;
diff --git a/arrow/src/buffer/mutable.rs b/arrow-buffer/src/buffer/mutable.rs
similarity index 70%
rename from arrow/src/buffer/mutable.rs
rename to arrow-buffer/src/buffer/mutable.rs
index 1c662ec23eef..e08d9c1906b3 100644
--- a/arrow/src/buffer/mutable.rs
+++ b/arrow-buffer/src/buffer/mutable.rs
@@ -15,28 +15,35 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use super::Buffer;
-use crate::alloc::Deallocation;
+use std::alloc::{handle_alloc_error, Layout};
+use std::mem;
+use std::ptr::NonNull;
+
+use crate::alloc::{Deallocation, ALIGNMENT};
 use crate::{
-    alloc,
     bytes::Bytes,
-    datatypes::{ArrowNativeType, ToByteSlice},
+    native::{ArrowNativeType, ToByteSlice},
     util::bit_util,
 };
-use std::ptr::NonNull;
+
+use super::Buffer;
 
 /// A [`MutableBuffer`] is Arrow's interface to build a [`Buffer`] out of items or slices of items.
+///
 /// [`Buffer`]s created from [`MutableBuffer`] (via `into`) are guaranteed to have its pointer aligned
 /// along cache lines and in multiple of 64 bytes.
+///
 /// Use [MutableBuffer::push] to insert an item, [MutableBuffer::extend_from_slice]
 /// to insert many items, and `into` to convert it to [`Buffer`].
 ///
-/// For a safe, strongly typed API consider using [`crate::array::BufferBuilder`]
+/// For a safe, strongly typed API consider using [`Vec`] and [`ScalarBuffer`](crate::ScalarBuffer)
+///
+/// Note: this may be deprecated in a future release ([#1176](https://github.com/apache/arrow-rs/issues/1176))
 ///
 /// # Example
 ///
 /// ```
-/// # use arrow::buffer::{Buffer, MutableBuffer};
+/// # use arrow_buffer::buffer::{Buffer, MutableBuffer};
 /// let mut buffer = MutableBuffer::new(0);
 /// buffer.push(256u32);
 /// buffer.extend_from_slice(&[1u32]);
@@ -49,25 +56,41 @@ pub struct MutableBuffer {
     data: NonNull<u8>,
     // invariant: len <= capacity
     len: usize,
-    capacity: usize,
+    layout: Layout,
 }
 
 impl MutableBuffer {
     /// Allocate a new [MutableBuffer] with initial capacity to be at least `capacity`.
+    ///
+    /// See [`MutableBuffer::with_capacity`].
     #[inline]
     pub fn new(capacity: usize) -> Self {
         Self::with_capacity(capacity)
     }
 
     /// Allocate a new [MutableBuffer] with initial capacity to be at least `capacity`.
+    ///
+    /// # Panics
+    ///
+    /// If `capacity`, when rounded up to the nearest multiple of [`ALIGNMENT`], is greater
+    /// then `isize::MAX`, then this function will panic.
     #[inline]
     pub fn with_capacity(capacity: usize) -> Self {
         let capacity = bit_util::round_upto_multiple_of_64(capacity);
-        let ptr = alloc::allocate_aligned(capacity);
+        let layout = Layout::from_size_align(capacity, ALIGNMENT)
+            .expect("failed to create layout for MutableBuffer");
+        let data = match layout.size() {
+            0 => dangling_ptr(),
+            _ => {
+                // Safety: Verified size != 0
+                let raw_ptr = unsafe { std::alloc::alloc(layout) };
+                NonNull::new(raw_ptr).unwrap_or_else(|| handle_alloc_error(layout))
+            }
+        };
         Self {
-            data: ptr,
+            data,
             len: 0,
-            capacity,
+            layout,
         }
     }
 
@@ -75,7 +98,7 @@ impl MutableBuffer {
     /// all bytes are guaranteed to be `0u8`.
     /// # Example
     /// ```
-    /// # use arrow::buffer::{Buffer, MutableBuffer};
+    /// # use arrow_buffer::buffer::{Buffer, MutableBuffer};
     /// let mut buffer = MutableBuffer::from_len_zeroed(127);
     /// assert_eq!(buffer.len(), 127);
     /// assert!(buffer.capacity() >= 127);
@@ -83,13 +106,37 @@ impl MutableBuffer {
     /// assert_eq!(data[126], 0u8);
     /// ```
     pub fn from_len_zeroed(len: usize) -> Self {
-        let new_capacity = bit_util::round_upto_multiple_of_64(len);
-        let ptr = alloc::allocate_aligned_zeroed(new_capacity);
-        Self {
-            data: ptr,
-            len,
-            capacity: new_capacity,
-        }
+        let layout = Layout::from_size_align(len, ALIGNMENT).unwrap();
+        let data = match layout.size() {
+            0 => dangling_ptr(),
+            _ => {
+                // Safety: Verified size != 0
+                let raw_ptr = unsafe { std::alloc::alloc_zeroed(layout) };
+                NonNull::new(raw_ptr).unwrap_or_else(|| handle_alloc_error(layout))
+            }
+        };
+        Self { data, len, layout }
+    }
+
+    /// Create a [`MutableBuffer`] from the provided [`Vec`] without copying
+    #[inline]
+    #[deprecated(note = "Use From<Vec<T>>")]
+    pub fn from_vec<T: ArrowNativeType>(vec: Vec<T>) -> Self {
+        Self::from(vec)
+    }
+
+    /// Allocates a new [MutableBuffer] from given `Bytes`.
+    pub(crate) fn from_bytes(bytes: Bytes) -> Result<Self, Bytes> {
+        let layout = match bytes.deallocation() {
+            Deallocation::Standard(layout) => *layout,
+            _ => return Err(bytes),
+        };
+
+        let len = bytes.len();
+        let data = bytes.ptr();
+        mem::forget(bytes);
+
+        Ok(Self { data, len, layout })
     }
 
     /// creates a new [MutableBuffer] with capacity and length capable of holding `len` bits.
@@ -106,7 +153,7 @@ impl MutableBuffer {
     /// the buffer directly (e.g., modifying the buffer by holding a mutable reference
     /// from `data_mut()`).
     pub fn with_bitset(mut self, end: usize, val: bool) -> Self {
-        assert!(end <= self.capacity);
+        assert!(end <= self.layout.size());
         let v = if val { 255 } else { 0 };
         unsafe {
             std::ptr::write_bytes(self.data.as_ptr(), v, end);
@@ -121,7 +168,14 @@ impl MutableBuffer {
     /// `len` of the buffer and so can be used to initialize the memory region from
     /// `len` to `capacity`.
     pub fn set_null_bits(&mut self, start: usize, count: usize) {
-        assert!(start + count <= self.capacity);
+        assert!(
+            start.saturating_add(count) <= self.layout.size(),
+            "range start index {start} and count {count} out of bounds for \
+            buffer of length {}",
+            self.layout.size(),
+        );
+
+        // Safety: `self.data[start..][..count]` is in-bounds and well-aligned for `u8`
         unsafe {
             std::ptr::write_bytes(self.data.as_ptr().add(start), 0, count);
         }
@@ -131,7 +185,7 @@ impl MutableBuffer {
     /// `self.len + additional > capacity`.
     /// # Example
     /// ```
-    /// # use arrow::buffer::{Buffer, MutableBuffer};
+    /// # use arrow_buffer::buffer::{Buffer, MutableBuffer};
     /// let mut buffer = MutableBuffer::new(0);
     /// buffer.reserve(253); // allocates for the first time
     /// (0..253u8).for_each(|i| buffer.push(i)); // no reallocation
@@ -143,19 +197,35 @@ impl MutableBuffer {
     #[inline(always)]
     pub fn reserve(&mut self, additional: usize) {
         let required_cap = self.len + additional;
-        if required_cap > self.capacity {
-            // JUSTIFICATION
-            //  Benefit
-            //      necessity
-            //  Soundness
-            //      `self.data` is valid for `self.capacity`.
-            let (ptr, new_capacity) =
-                unsafe { reallocate(self.data, self.capacity, required_cap) };
-            self.data = ptr;
-            self.capacity = new_capacity;
+        if required_cap > self.layout.size() {
+            let new_capacity = bit_util::round_upto_multiple_of_64(required_cap);
+            let new_capacity = std::cmp::max(new_capacity, self.layout.size() * 2);
+            self.reallocate(new_capacity)
         }
     }
 
+    #[cold]
+    fn reallocate(&mut self, capacity: usize) {
+        let new_layout = Layout::from_size_align(capacity, self.layout.align()).unwrap();
+        if new_layout.size() == 0 {
+            if self.layout.size() != 0 {
+                // Safety: data was allocated with layout
+                unsafe { std::alloc::dealloc(self.as_mut_ptr(), self.layout) };
+                self.layout = new_layout
+            }
+            return;
+        }
+
+        let data = match self.layout.size() {
+            // Safety: new_layout is not empty
+            0 => unsafe { std::alloc::alloc(new_layout) },
+            // Safety: verified new layout is valid and not empty
+            _ => unsafe { std::alloc::realloc(self.as_mut_ptr(), self.layout, capacity) },
+        };
+        self.data = NonNull::new(data).unwrap_or_else(|| handle_alloc_error(new_layout));
+        self.layout = new_layout;
+    }
+
     /// Truncates this buffer to `len` bytes
     ///
     /// If `len` is greater than the buffer's current length, this has no effect
@@ -171,7 +241,7 @@ impl MutableBuffer {
     /// growing it (potentially reallocating it) and writing `value` in the newly available bytes.
     /// # Example
     /// ```
-    /// # use arrow::buffer::{Buffer, MutableBuffer};
+    /// # use arrow_buffer::buffer::{Buffer, MutableBuffer};
     /// let mut buffer = MutableBuffer::new(0);
     /// buffer.resize(253, 2); // allocates for the first time
     /// assert_eq!(buffer.as_slice()[252], 2u8);
@@ -195,7 +265,7 @@ impl MutableBuffer {
     ///
     /// # Example
     /// ```
-    /// # use arrow::buffer::{Buffer, MutableBuffer};
+    /// # use arrow_buffer::buffer::{Buffer, MutableBuffer};
     /// // 2 cache lines
     /// let mut buffer = MutableBuffer::new(128);
     /// assert_eq!(buffer.capacity(), 128);
@@ -207,17 +277,8 @@ impl MutableBuffer {
     /// ```
     pub fn shrink_to_fit(&mut self) {
         let new_capacity = bit_util::round_upto_multiple_of_64(self.len);
-        if new_capacity < self.capacity {
-            // JUSTIFICATION
-            //  Benefit
-            //      necessity
-            //  Soundness
-            //      `self.data` is valid for `self.capacity`.
-            let ptr =
-                unsafe { alloc::reallocate(self.data, self.capacity, new_capacity) };
-
-            self.data = ptr;
-            self.capacity = new_capacity;
+        if new_capacity < self.layout.size() {
+            self.reallocate(new_capacity)
         }
     }
 
@@ -238,7 +299,7 @@ impl MutableBuffer {
     /// The invariant `buffer.len() <= buffer.capacity()` is always upheld.
     #[inline]
     pub const fn capacity(&self) -> usize {
-        self.capacity
+        self.layout.size()
     }
 
     /// Clear all existing data from this buffer.
@@ -281,14 +342,12 @@ impl MutableBuffer {
 
     #[inline]
     pub(super) fn into_buffer(self) -> Buffer {
-        let bytes = unsafe {
-            Bytes::new(self.data, self.len, Deallocation::Arrow(self.capacity))
-        };
+        let bytes = unsafe { Bytes::new(self.data, self.len, Deallocation::Standard(self.layout)) };
         std::mem::forget(self);
         Buffer::from_bytes(bytes)
     }
 
-    /// View this buffer as a slice of a specific type.
+    /// View this buffer as a mutable slice of a specific type.
     ///
     /// # Panics
     ///
@@ -298,8 +357,22 @@ impl MutableBuffer {
         // SAFETY
         // ArrowNativeType is trivially transmutable, is sealed to prevent potentially incorrect
         // implementation outside this crate, and this method checks alignment
-        let (prefix, offsets, suffix) =
-            unsafe { self.as_slice_mut().align_to_mut::<T>() };
+        let (prefix, offsets, suffix) = unsafe { self.as_slice_mut().align_to_mut::<T>() };
+        assert!(prefix.is_empty() && suffix.is_empty());
+        offsets
+    }
+
+    /// View buffer as a immutable slice of a specific type.
+    ///
+    /// # Panics
+    ///
+    /// This function panics if the underlying buffer is not aligned
+    /// correctly for type `T`.
+    pub fn typed_data<T: ArrowNativeType>(&self) -> &[T] {
+        // SAFETY
+        // ArrowNativeType is trivially transmutable, is sealed to prevent potentially incorrect
+        // implementation outside this crate, and this method checks alignment
+        let (prefix, offsets, suffix) = unsafe { self.as_slice().align_to::<T>() };
         assert!(prefix.is_empty() && suffix.is_empty());
         offsets
     }
@@ -307,15 +380,14 @@ impl MutableBuffer {
     /// Extends this buffer from a slice of items that can be represented in bytes, increasing its capacity if needed.
     /// # Example
     /// ```
-    /// # use arrow::buffer::MutableBuffer;
+    /// # use arrow_buffer::buffer::MutableBuffer;
     /// let mut buffer = MutableBuffer::new(0);
     /// buffer.extend_from_slice(&[2u32, 0]);
     /// assert_eq!(buffer.len(), 8) // u32 has 4 bytes
     /// ```
     #[inline]
     pub fn extend_from_slice<T: ArrowNativeType>(&mut self, items: &[T]) {
-        let len = items.len();
-        let additional = len * std::mem::size_of::<T>();
+        let additional = mem::size_of_val(items);
         self.reserve(additional);
         unsafe {
             // this assumes that `[ToByteSlice]` can be copied directly
@@ -331,7 +403,7 @@ impl MutableBuffer {
     /// Extends the buffer with a new item, increasing its capacity if needed.
     /// # Example
     /// ```
-    /// # use arrow::buffer::MutableBuffer;
+    /// # use arrow_buffer::buffer::MutableBuffer;
     /// let mut buffer = MutableBuffer::new(0);
     /// buffer.push(256u32);
     /// assert_eq!(buffer.len(), 4) // u32 has 4 bytes
@@ -350,7 +422,7 @@ impl MutableBuffer {
 
     /// Extends the buffer with a new item, without checking for sufficient capacity
     /// # Safety
-    /// Caller must ensure that the capacity()-len()>=size_of<T>()
+    /// Caller must ensure that the capacity()-len()>=`size_of<T>`()
     #[inline]
     pub unsafe fn push_unchecked<T: ToByteSlice>(&mut self, item: T) {
         let additional = std::mem::size_of::<T>();
@@ -369,24 +441,62 @@ impl MutableBuffer {
     /// # Safety
     /// The caller must ensure that the buffer was properly initialized up to `len`.
     #[inline]
-    pub(crate) unsafe fn set_len(&mut self, len: usize) {
+    pub unsafe fn set_len(&mut self, len: usize) {
         assert!(len <= self.capacity());
         self.len = len;
     }
+
+    /// Invokes `f` with values `0..len` collecting the boolean results into a new `MutableBuffer`
+    ///
+    /// This is similar to `from_trusted_len_iter_bool`, however, can be significantly faster
+    /// as it eliminates the conditional `Iterator::next`
+    #[inline]
+    pub fn collect_bool<F: FnMut(usize) -> bool>(len: usize, mut f: F) -> Self {
+        let mut buffer = Self::new(bit_util::ceil(len, 64) * 8);
+
+        let chunks = len / 64;
+        let remainder = len % 64;
+        for chunk in 0..chunks {
+            let mut packed = 0;
+            for bit_idx in 0..64 {
+                let i = bit_idx + chunk * 64;
+                packed |= (f(i) as u64) << bit_idx;
+            }
+
+            // SAFETY: Already allocated sufficient capacity
+            unsafe { buffer.push_unchecked(packed) }
+        }
+
+        if remainder != 0 {
+            let mut packed = 0;
+            for bit_idx in 0..remainder {
+                let i = bit_idx + chunks * 64;
+                packed |= (f(i) as u64) << bit_idx;
+            }
+
+            // SAFETY: Already allocated sufficient capacity
+            unsafe { buffer.push_unchecked(packed) }
+        }
+
+        buffer.truncate(bit_util::ceil(len, 8));
+        buffer
+    }
 }
 
-/// # Safety
-/// `ptr` must be allocated for `old_capacity`.
-#[cold]
-unsafe fn reallocate(
-    ptr: NonNull<u8>,
-    old_capacity: usize,
-    new_capacity: usize,
-) -> (NonNull<u8>, usize) {
-    let new_capacity = bit_util::round_upto_multiple_of_64(new_capacity);
-    let new_capacity = std::cmp::max(new_capacity, old_capacity * 2);
-    let ptr = alloc::reallocate(ptr, old_capacity, new_capacity);
-    (ptr, new_capacity)
+#[inline]
+fn dangling_ptr() -> NonNull<u8> {
+    // SAFETY: ALIGNMENT is a non-zero usize which is then casted
+    // to a *mut T. Therefore, `ptr` is not null and the conditions for
+    // calling new_unchecked() are respected.
+    #[cfg(miri)]
+    {
+        // Since miri implies a nightly rust version we can use the unstable strict_provenance feature
+        unsafe { NonNull::new_unchecked(std::ptr::without_provenance_mut(ALIGNMENT)) }
+    }
+    #[cfg(not(miri))]
+    {
+        unsafe { NonNull::new_unchecked(ALIGNMENT as *mut u8) }
+    }
 }
 
 impl<A: ArrowNativeType> Extend<A> for MutableBuffer {
@@ -397,6 +507,21 @@ impl<A: ArrowNativeType> Extend<A> for MutableBuffer {
     }
 }
 
+impl<T: ArrowNativeType> From<Vec<T>> for MutableBuffer {
+    fn from(value: Vec<T>) -> Self {
+        // Safety
+        // Vec::as_ptr guaranteed to not be null and ArrowNativeType are trivially transmutable
+        let data = unsafe { NonNull::new_unchecked(value.as_ptr() as _) };
+        let len = value.len() * mem::size_of::<T>();
+        // Safety
+        // Vec guaranteed to have a valid layout matching that of `Layout::array`
+        // This is based on `RawVec::current_memory`
+        let layout = unsafe { Layout::array::<T>(value.capacity()).unwrap_unchecked() };
+        mem::forget(value);
+        Self { data, len, layout }
+    }
+}
+
 impl MutableBuffer {
     #[inline]
     pub(super) fn extend_from_iter<T: ArrowNativeType, I: Iterator<Item = T>>(
@@ -411,7 +536,7 @@ impl MutableBuffer {
         // this is necessary because of https://github.com/rust-lang/rust/issues/32155
         let mut len = SetLenOnDrop::new(&mut self.len);
         let mut dst = unsafe { self.data.as_ptr().add(len.local_len) };
-        let capacity = self.capacity;
+        let capacity = self.layout.size();
 
         while len.local_len + item_size <= capacity {
             if let Some(item) = iterator.next() {
@@ -434,7 +559,7 @@ impl MutableBuffer {
     /// Prefer this to `collect` whenever possible, as it is faster ~60% faster.
     /// # Example
     /// ```
-    /// # use arrow::buffer::MutableBuffer;
+    /// # use arrow_buffer::buffer::MutableBuffer;
     /// let v = vec![1u32];
     /// let iter = v.iter().map(|x| x * 2);
     /// let buffer = unsafe { MutableBuffer::from_trusted_len_iter(iter) };
@@ -475,10 +600,10 @@ impl MutableBuffer {
     }
 
     /// Creates a [`MutableBuffer`] from a boolean [`Iterator`] with a trusted (upper) length.
-    /// # use arrow::buffer::MutableBuffer;
+    /// # use arrow_buffer::buffer::MutableBuffer;
     /// # Example
     /// ```
-    /// # use arrow::buffer::MutableBuffer;
+    /// # use arrow_buffer::buffer::MutableBuffer;
     /// let v = vec![false, true, false];
     /// let iter = v.iter().map(|x| *x || true);
     /// let buffer = unsafe { MutableBuffer::from_trusted_len_iter_bool(iter) };
@@ -492,42 +617,11 @@ impl MutableBuffer {
     //    we can't specialize `extend` for `TrustedLen` like `Vec` does.
     // 2. `from_trusted_len_iter_bool` is faster.
     #[inline]
-    pub unsafe fn from_trusted_len_iter_bool<I: Iterator<Item = bool>>(
-        mut iterator: I,
-    ) -> Self {
+    pub unsafe fn from_trusted_len_iter_bool<I: Iterator<Item = bool>>(mut iterator: I) -> Self {
         let (_, upper) = iterator.size_hint();
-        let upper = upper.expect("from_trusted_len_iter requires an upper limit");
-
-        let mut result = {
-            let byte_capacity: usize = upper.saturating_add(7) / 8;
-            MutableBuffer::new(byte_capacity)
-        };
-
-        'a: loop {
-            let mut byte_accum: u8 = 0;
-            let mut mask: u8 = 1;
-
-            //collect (up to) 8 bits into a byte
-            while mask != 0 {
-                if let Some(value) = iterator.next() {
-                    byte_accum |= match value {
-                        true => mask,
-                        false => 0,
-                    };
-                    mask <<= 1;
-                } else {
-                    if mask != 1 {
-                        // Add last byte
-                        result.push_unchecked(byte_accum);
-                    }
-                    break 'a;
-                }
-            }
+        let len = upper.expect("from_trusted_len_iter requires an upper limit");
 
-            // Soundness: from_trusted_len
-            result.push_unchecked(byte_accum);
-        }
-        result
+        Self::collect_bool(len, |_| iterator.next().unwrap())
     }
 
     /// Creates a [`MutableBuffer`] from an [`Iterator`] with a trusted (upper) length or errors
@@ -540,10 +634,10 @@ impl MutableBuffer {
     pub unsafe fn try_from_trusted_len_iter<
         E,
         T: ArrowNativeType,
-        I: Iterator<Item = std::result::Result<T, E>>,
+        I: Iterator<Item = Result<T, E>>,
     >(
         iterator: I,
-    ) -> std::result::Result<Self, E> {
+    ) -> Result<Self, E> {
         let item_size = std::mem::size_of::<T>();
         let (_, upper) = iterator.size_hint();
         let upper = upper.expect("try_from_trusted_len_iter requires an upper limit");
@@ -574,6 +668,12 @@ impl MutableBuffer {
     }
 }
 
+impl Default for MutableBuffer {
+    fn default() -> Self {
+        Self::with_capacity(0)
+    }
+}
+
 impl std::ops::Deref for MutableBuffer {
     type Target = [u8];
 
@@ -590,7 +690,10 @@ impl std::ops::DerefMut for MutableBuffer {
 
 impl Drop for MutableBuffer {
     fn drop(&mut self) {
-        unsafe { alloc::free_aligned(self.data, self.capacity) };
+        if self.layout.size() != 0 {
+            // Safety: data was allocated with standard allocator with given layout
+            unsafe { std::alloc::dealloc(self.data.as_ptr() as _, self.layout) };
+        }
     }
 }
 
@@ -599,7 +702,7 @@ impl PartialEq for MutableBuffer {
         if self.len != other.len {
             return false;
         }
-        if self.capacity != other.capacity {
+        if self.layout != other.layout {
             return false;
         }
         self.as_slice() == other.as_slice()
@@ -686,6 +789,14 @@ impl std::iter::FromIterator<bool> for MutableBuffer {
     }
 }
 
+impl<T: ArrowNativeType> std::iter::FromIterator<T> for MutableBuffer {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let mut buffer = Self::default();
+        buffer.extend_from_iter(iter.into_iter());
+        buffer
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -698,6 +809,19 @@ mod tests {
         assert!(buf.is_empty());
     }
 
+    #[test]
+    fn test_mutable_default() {
+        let buf = MutableBuffer::default();
+        assert_eq!(0, buf.capacity());
+        assert_eq!(0, buf.len());
+        assert!(buf.is_empty());
+
+        let mut buf = MutableBuffer::default();
+        buf.extend_from_slice(b"hello");
+        assert_eq!(5, buf.len());
+        assert_eq!(b"hello", buf.as_slice());
+    }
+
     #[test]
     fn test_mutable_extend_from_slice() {
         let mut buf = MutableBuffer::new(100);
@@ -860,4 +984,45 @@ mod tests {
         buffer.shrink_to_fit();
         assert!(buffer.capacity() >= 64 && buffer.capacity() < 128);
     }
+
+    #[test]
+    fn test_mutable_set_null_bits() {
+        let mut buffer = MutableBuffer::new(8).with_bitset(8, true);
+
+        for i in 0..=buffer.capacity() {
+            buffer.set_null_bits(i, 0);
+            assert_eq!(buffer[..8], [255; 8][..]);
+        }
+
+        buffer.set_null_bits(1, 4);
+        assert_eq!(buffer[..8], [255, 0, 0, 0, 0, 255, 255, 255][..]);
+    }
+
+    #[test]
+    #[should_panic = "out of bounds for buffer of length"]
+    fn test_mutable_set_null_bits_oob() {
+        let mut buffer = MutableBuffer::new(64);
+        buffer.set_null_bits(1, buffer.capacity());
+    }
+
+    #[test]
+    #[should_panic = "out of bounds for buffer of length"]
+    fn test_mutable_set_null_bits_oob_by_overflow() {
+        let mut buffer = MutableBuffer::new(0);
+        buffer.set_null_bits(1, usize::MAX);
+    }
+
+    #[test]
+    fn from_iter() {
+        let buffer = [1u16, 2, 3, 4].into_iter().collect::<MutableBuffer>();
+        assert_eq!(buffer.len(), 4 * mem::size_of::<u16>());
+        assert_eq!(buffer.as_slice(), &[1, 0, 2, 0, 3, 0, 4, 0]);
+    }
+
+    #[test]
+    #[should_panic(expected = "failed to create layout for MutableBuffer: LayoutError")]
+    fn test_with_capacity_panics_above_max_capacity() {
+        let max_capacity = isize::MAX as usize - (isize::MAX as usize % ALIGNMENT);
+        let _ = MutableBuffer::with_capacity(max_capacity + 1);
+    }
 }
diff --git a/arrow-buffer/src/buffer/null.rs b/arrow-buffer/src/buffer/null.rs
new file mode 100644
index 000000000000..c79aef398059
--- /dev/null
+++ b/arrow-buffer/src/buffer/null.rs
@@ -0,0 +1,261 @@
+// 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.
+
+use crate::bit_iterator::{BitIndexIterator, BitIterator, BitSliceIterator};
+use crate::buffer::BooleanBuffer;
+use crate::{Buffer, MutableBuffer};
+
+/// A [`BooleanBuffer`] used to encode validity for arrow arrays
+///
+/// As per the [Arrow specification], array validity is encoded in a packed bitmask with a
+/// `true` value indicating the corresponding slot is not null, and `false` indicating
+/// that it is null.
+///
+/// [Arrow specification]: https://arrow.apache.org/docs/format/Columnar.html#validity-bitmaps
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct NullBuffer {
+    buffer: BooleanBuffer,
+    null_count: usize,
+}
+
+impl NullBuffer {
+    /// Create a new [`NullBuffer`] computing the null count
+    pub fn new(buffer: BooleanBuffer) -> Self {
+        let null_count = buffer.len() - buffer.count_set_bits();
+        Self { buffer, null_count }
+    }
+
+    /// Create a new [`NullBuffer`] of length `len` where all values are null
+    pub fn new_null(len: usize) -> Self {
+        Self {
+            buffer: BooleanBuffer::new_unset(len),
+            null_count: len,
+        }
+    }
+
+    /// Create a new [`NullBuffer`] of length `len` where all values are valid
+    ///
+    /// Note: it is more efficient to not set the null buffer if it is known to be all valid
+    pub fn new_valid(len: usize) -> Self {
+        Self {
+            buffer: BooleanBuffer::new_set(len),
+            null_count: 0,
+        }
+    }
+
+    /// Create a new [`NullBuffer`] with the provided `buffer` and `null_count`
+    ///
+    /// # Safety
+    ///
+    /// `buffer` must contain `null_count` `0` bits
+    pub unsafe fn new_unchecked(buffer: BooleanBuffer, null_count: usize) -> Self {
+        Self { buffer, null_count }
+    }
+
+    /// Computes the union of the nulls in two optional [`NullBuffer`]
+    ///
+    /// This is commonly used by binary operations where the result is NULL if either
+    /// of the input values is NULL. Handling the null mask separately in this way
+    /// can yield significant performance improvements over an iterator approach
+    pub fn union(lhs: Option<&NullBuffer>, rhs: Option<&NullBuffer>) -> Option<NullBuffer> {
+        match (lhs, rhs) {
+            (Some(lhs), Some(rhs)) => Some(Self::new(lhs.inner() & rhs.inner())),
+            (Some(n), None) | (None, Some(n)) => Some(n.clone()),
+            (None, None) => None,
+        }
+    }
+
+    /// Returns true if all nulls in `other` also exist in self
+    pub fn contains(&self, other: &NullBuffer) -> bool {
+        if other.null_count == 0 {
+            return true;
+        }
+        let lhs = self.inner().bit_chunks().iter_padded();
+        let rhs = other.inner().bit_chunks().iter_padded();
+        lhs.zip(rhs).all(|(l, r)| (l & !r) == 0)
+    }
+
+    /// Returns a new [`NullBuffer`] where each bit in the current null buffer
+    /// is repeated `count` times. This is useful for masking the nulls of
+    /// the child of a FixedSizeListArray based on its parent
+    pub fn expand(&self, count: usize) -> Self {
+        let capacity = self.buffer.len().checked_mul(count).unwrap();
+        let mut buffer = MutableBuffer::new_null(capacity);
+
+        // Expand each bit within `null_mask` into `element_len`
+        // bits, constructing the implicit mask of the child elements
+        for i in 0..self.buffer.len() {
+            if self.is_null(i) {
+                continue;
+            }
+            for j in 0..count {
+                crate::bit_util::set_bit(buffer.as_mut(), i * count + j)
+            }
+        }
+        Self {
+            buffer: BooleanBuffer::new(buffer.into(), 0, capacity),
+            null_count: self.null_count * count,
+        }
+    }
+
+    /// Returns the length of this [`NullBuffer`]
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.buffer.len()
+    }
+
+    /// Returns the offset of this [`NullBuffer`] in bits
+    #[inline]
+    pub fn offset(&self) -> usize {
+        self.buffer.offset()
+    }
+
+    /// Returns true if this [`NullBuffer`] is empty
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.buffer.is_empty()
+    }
+
+    /// Returns the null count for this [`NullBuffer`]
+    #[inline]
+    pub fn null_count(&self) -> usize {
+        self.null_count
+    }
+
+    /// Returns `true` if the value at `idx` is not null
+    #[inline]
+    pub fn is_valid(&self, idx: usize) -> bool {
+        self.buffer.value(idx)
+    }
+
+    /// Returns `true` if the value at `idx` is null
+    #[inline]
+    pub fn is_null(&self, idx: usize) -> bool {
+        !self.is_valid(idx)
+    }
+
+    /// Returns the packed validity of this [`NullBuffer`] not including any offset
+    #[inline]
+    pub fn validity(&self) -> &[u8] {
+        self.buffer.values()
+    }
+
+    /// Slices this [`NullBuffer`] by the provided `offset` and `length`
+    pub fn slice(&self, offset: usize, len: usize) -> Self {
+        Self::new(self.buffer.slice(offset, len))
+    }
+
+    /// Returns an iterator over the bits in this [`NullBuffer`]
+    ///
+    /// * `true` indicates that the corresponding value is not NULL
+    /// * `false` indicates that the corresponding value is NULL
+    ///
+    /// Note: [`Self::valid_indices`] will be significantly faster for most use-cases
+    pub fn iter(&self) -> BitIterator<'_> {
+        self.buffer.iter()
+    }
+
+    /// Returns a [`BitIndexIterator`] over the valid indices in this [`NullBuffer`]
+    ///
+    /// Valid indices indicate the corresponding value is not NULL
+    pub fn valid_indices(&self) -> BitIndexIterator<'_> {
+        self.buffer.set_indices()
+    }
+
+    /// Returns a [`BitSliceIterator`] yielding contiguous ranges of valid indices
+    ///
+    /// Valid indices indicate the corresponding value is not NULL
+    pub fn valid_slices(&self) -> BitSliceIterator<'_> {
+        self.buffer.set_slices()
+    }
+
+    /// Calls the provided closure for each index in this null mask that is set
+    #[inline]
+    pub fn try_for_each_valid_idx<E, F: FnMut(usize) -> Result<(), E>>(
+        &self,
+        f: F,
+    ) -> Result<(), E> {
+        if self.null_count == self.len() {
+            return Ok(());
+        }
+        self.valid_indices().try_for_each(f)
+    }
+
+    /// Returns the inner [`BooleanBuffer`]
+    #[inline]
+    pub fn inner(&self) -> &BooleanBuffer {
+        &self.buffer
+    }
+
+    /// Returns the inner [`BooleanBuffer`]
+    #[inline]
+    pub fn into_inner(self) -> BooleanBuffer {
+        self.buffer
+    }
+
+    /// Returns the underlying [`Buffer`]
+    #[inline]
+    pub fn buffer(&self) -> &Buffer {
+        self.buffer.inner()
+    }
+}
+
+impl<'a> IntoIterator for &'a NullBuffer {
+    type Item = bool;
+    type IntoIter = BitIterator<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.buffer.iter()
+    }
+}
+
+impl From<BooleanBuffer> for NullBuffer {
+    fn from(value: BooleanBuffer) -> Self {
+        Self::new(value)
+    }
+}
+
+impl From<&[bool]> for NullBuffer {
+    fn from(value: &[bool]) -> Self {
+        BooleanBuffer::from(value).into()
+    }
+}
+
+impl From<Vec<bool>> for NullBuffer {
+    fn from(value: Vec<bool>) -> Self {
+        BooleanBuffer::from(value).into()
+    }
+}
+
+impl FromIterator<bool> for NullBuffer {
+    fn from_iter<T: IntoIterator<Item = bool>>(iter: T) -> Self {
+        BooleanBuffer::from_iter(iter).into()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    #[test]
+    fn test_size() {
+        // This tests that the niche optimisation eliminates the overhead of an option
+        assert_eq!(
+            std::mem::size_of::<NullBuffer>(),
+            std::mem::size_of::<Option<NullBuffer>>()
+        );
+    }
+}
diff --git a/arrow-buffer/src/buffer/offset.rs b/arrow-buffer/src/buffer/offset.rs
new file mode 100644
index 000000000000..652d30c3b0ab
--- /dev/null
+++ b/arrow-buffer/src/buffer/offset.rs
@@ -0,0 +1,237 @@
+// 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.
+
+use crate::buffer::ScalarBuffer;
+use crate::{ArrowNativeType, MutableBuffer};
+use std::ops::Deref;
+
+/// A non-empty buffer of monotonically increasing, positive integers.
+///
+/// [`OffsetBuffer`] are used to represent ranges of offsets. An
+/// `OffsetBuffer` of `N+1` items contains `N` such ranges. The start
+/// offset for element `i` is `offsets[i]` and the end offset is
+/// `offsets[i+1]`. Equal offsets represent an empty range.
+///
+/// # Example
+///
+/// This example shows how 5 distinct ranges, are represented using a
+/// 6 entry `OffsetBuffer`. The first entry `(0, 3)` represents the
+/// three offsets `0, 1, 2`. The entry `(3,3)` represent no offsets
+/// (e.g. an empty list).
+///
+/// ```text
+///   ┌───────┐                ┌───┐
+///   │ (0,3) │                │ 0 │
+///   ├───────┤                ├───┤
+///   │ (3,3) │                │ 3 │
+///   ├───────┤                ├───┤
+///   │ (3,4) │                │ 3 │
+///   ├───────┤                ├───┤
+///   │ (4,5) │                │ 4 │
+///   ├───────┤                ├───┤
+///   │ (5,7) │                │ 5 │
+///   └───────┘                ├───┤
+///                            │ 7 │
+///                            └───┘
+///
+///                        Offsets Buffer
+///    Logical
+///    Offsets
+///
+///  (offsets[i],
+///   offsets[i+1])
+/// ```
+
+#[derive(Debug, Clone)]
+pub struct OffsetBuffer<O: ArrowNativeType>(ScalarBuffer<O>);
+
+impl<O: ArrowNativeType> OffsetBuffer<O> {
+    /// Create a new [`OffsetBuffer`] from the provided [`ScalarBuffer`]
+    ///
+    /// # Panics
+    ///
+    /// Panics if `buffer` is not a non-empty buffer containing
+    /// monotonically increasing values greater than or equal to zero
+    pub fn new(buffer: ScalarBuffer<O>) -> Self {
+        assert!(!buffer.is_empty(), "offsets cannot be empty");
+        assert!(
+            buffer[0] >= O::usize_as(0),
+            "offsets must be greater than 0"
+        );
+        assert!(
+            buffer.windows(2).all(|w| w[0] <= w[1]),
+            "offsets must be monotonically increasing"
+        );
+        Self(buffer)
+    }
+
+    /// Create a new [`OffsetBuffer`] from the provided [`ScalarBuffer`]
+    ///
+    /// # Safety
+    ///
+    /// `buffer` must be a non-empty buffer containing monotonically increasing
+    /// values greater than or equal to zero
+    pub unsafe fn new_unchecked(buffer: ScalarBuffer<O>) -> Self {
+        Self(buffer)
+    }
+
+    /// Create a new [`OffsetBuffer`] containing a single 0 value
+    pub fn new_empty() -> Self {
+        let buffer = MutableBuffer::from_len_zeroed(std::mem::size_of::<O>());
+        Self(buffer.into_buffer().into())
+    }
+
+    /// Create a new [`OffsetBuffer`] containing `len + 1` `0` values
+    pub fn new_zeroed(len: usize) -> Self {
+        let len_bytes = len
+            .checked_add(1)
+            .and_then(|o| o.checked_mul(std::mem::size_of::<O>()))
+            .expect("overflow");
+        let buffer = MutableBuffer::from_len_zeroed(len_bytes);
+        Self(buffer.into_buffer().into())
+    }
+
+    /// Create a new [`OffsetBuffer`] from the iterator of slice lengths
+    ///
+    /// ```
+    /// # use arrow_buffer::OffsetBuffer;
+    /// let offsets = OffsetBuffer::<i32>::from_lengths([1, 3, 5]);
+    /// assert_eq!(offsets.as_ref(), &[0, 1, 4, 9]);
+    /// ```
+    ///
+    /// # Panics
+    ///
+    /// Panics on overflow
+    pub fn from_lengths<I>(lengths: I) -> Self
+    where
+        I: IntoIterator<Item = usize>,
+    {
+        let iter = lengths.into_iter();
+        let mut out = Vec::with_capacity(iter.size_hint().0 + 1);
+        out.push(O::usize_as(0));
+
+        let mut acc = 0_usize;
+        for length in iter {
+            acc = acc.checked_add(length).expect("usize overflow");
+            out.push(O::usize_as(acc))
+        }
+        // Check for overflow
+        O::from_usize(acc).expect("offset overflow");
+        Self(out.into())
+    }
+
+    /// Returns the inner [`ScalarBuffer`]
+    pub fn inner(&self) -> &ScalarBuffer<O> {
+        &self.0
+    }
+
+    /// Returns the inner [`ScalarBuffer`], consuming self
+    pub fn into_inner(self) -> ScalarBuffer<O> {
+        self.0
+    }
+
+    /// Returns a zero-copy slice of this buffer with length `len` and starting at `offset`
+    pub fn slice(&self, offset: usize, len: usize) -> Self {
+        Self(self.0.slice(offset, len.saturating_add(1)))
+    }
+
+    /// Returns true if this [`OffsetBuffer`] is equal to `other`, using pointer comparisons
+    /// to determine buffer equality. This is cheaper than `PartialEq::eq` but may
+    /// return false when the arrays are logically equal
+    #[inline]
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        self.0.ptr_eq(&other.0)
+    }
+}
+
+impl<T: ArrowNativeType> Deref for OffsetBuffer<T> {
+    type Target = [T];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl<T: ArrowNativeType> AsRef<[T]> for OffsetBuffer<T> {
+    #[inline]
+    fn as_ref(&self) -> &[T] {
+        self
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    #[should_panic(expected = "offsets cannot be empty")]
+    fn empty_offsets() {
+        OffsetBuffer::new(Vec::<i32>::new().into());
+    }
+
+    #[test]
+    #[should_panic(expected = "offsets must be greater than 0")]
+    fn negative_offsets() {
+        OffsetBuffer::new(vec![-1, 0, 1].into());
+    }
+
+    #[test]
+    fn offsets() {
+        OffsetBuffer::new(vec![0, 1, 2, 3].into());
+
+        let offsets = OffsetBuffer::<i32>::new_zeroed(3);
+        assert_eq!(offsets.as_ref(), &[0; 4]);
+
+        let offsets = OffsetBuffer::<i32>::new_zeroed(0);
+        assert_eq!(offsets.as_ref(), &[0; 1]);
+    }
+
+    #[test]
+    #[should_panic(expected = "overflow")]
+    fn offsets_new_zeroed_overflow() {
+        OffsetBuffer::<i32>::new_zeroed(usize::MAX);
+    }
+
+    #[test]
+    #[should_panic(expected = "offsets must be monotonically increasing")]
+    fn non_monotonic_offsets() {
+        OffsetBuffer::new(vec![1, 2, 0].into());
+    }
+
+    #[test]
+    fn from_lengths() {
+        let buffer = OffsetBuffer::<i32>::from_lengths([2, 6, 3, 7, 2]);
+        assert_eq!(buffer.as_ref(), &[0, 2, 8, 11, 18, 20]);
+
+        let half_max = i32::MAX / 2;
+        let buffer = OffsetBuffer::<i32>::from_lengths([half_max as usize, half_max as usize]);
+        assert_eq!(buffer.as_ref(), &[0, half_max, half_max * 2]);
+    }
+
+    #[test]
+    #[should_panic(expected = "offset overflow")]
+    fn from_lengths_offset_overflow() {
+        OffsetBuffer::<i32>::from_lengths([i32::MAX as usize, 1]);
+    }
+
+    #[test]
+    #[should_panic(expected = "usize overflow")]
+    fn from_lengths_usize_overflow() {
+        OffsetBuffer::<i32>::from_lengths([usize::MAX, 1]);
+    }
+}
diff --git a/arrow/src/buffer/ops.rs b/arrow-buffer/src/buffer/ops.rs
similarity index 55%
rename from arrow/src/buffer/ops.rs
rename to arrow-buffer/src/buffer/ops.rs
index ea155c8d78e4..c69e5c6deb10 100644
--- a/arrow/src/buffer/ops.rs
+++ b/arrow-buffer/src/buffer/ops.rs
@@ -18,6 +18,46 @@
 use super::{Buffer, MutableBuffer};
 use crate::util::bit_util::ceil;
 
+/// Apply a bitwise operation `op` to four inputs and return the result as a Buffer.
+/// The inputs are treated as bitmaps, meaning that offsets and length are specified in number of bits.
+pub fn bitwise_quaternary_op_helper<F>(
+    buffers: [&Buffer; 4],
+    offsets: [usize; 4],
+    len_in_bits: usize,
+    op: F,
+) -> Buffer
+where
+    F: Fn(u64, u64, u64, u64) -> u64,
+{
+    let first_chunks = buffers[0].bit_chunks(offsets[0], len_in_bits);
+    let second_chunks = buffers[1].bit_chunks(offsets[1], len_in_bits);
+    let third_chunks = buffers[2].bit_chunks(offsets[2], len_in_bits);
+    let fourth_chunks = buffers[3].bit_chunks(offsets[3], len_in_bits);
+
+    let chunks = first_chunks
+        .iter()
+        .zip(second_chunks.iter())
+        .zip(third_chunks.iter())
+        .zip(fourth_chunks.iter())
+        .map(|(((first, second), third), fourth)| op(first, second, third, fourth));
+    // Soundness: `BitChunks` is a `BitChunks` iterator which
+    // correctly reports its upper bound
+    let mut buffer = unsafe { MutableBuffer::from_trusted_len_iter(chunks) };
+
+    let remainder_bytes = ceil(first_chunks.remainder_len(), 8);
+    let rem = op(
+        first_chunks.remainder_bits(),
+        second_chunks.remainder_bits(),
+        third_chunks.remainder_bits(),
+        fourth_chunks.remainder_bits(),
+    );
+    // we are counting its starting from the least significant bit, to to_le_bytes should be correct
+    let rem = &rem.to_le_bytes()[0..remainder_bytes];
+    buffer.extend_from_slice(rem);
+
+    buffer.into()
+}
+
 /// Apply a bitwise operation `op` to two inputs and return the result as a Buffer.
 /// The inputs are treated as bitmaps, meaning that offsets and length are specified in number of bits.
 pub fn bitwise_bin_op_helper<F>(
@@ -26,10 +66,10 @@ pub fn bitwise_bin_op_helper<F>(
     right: &Buffer,
     right_offset_in_bits: usize,
     len_in_bits: usize,
-    op: F,
+    mut op: F,
 ) -> Buffer
 where
-    F: Fn(u64, u64) -> u64,
+    F: FnMut(u64, u64) -> u64,
 {
     let left_chunks = left.bit_chunks(left_offset_in_bits, len_in_bits);
     let right_chunks = right.bit_chunks(right_offset_in_bits, len_in_bits);
@@ -57,10 +97,10 @@ pub fn bitwise_unary_op_helper<F>(
     left: &Buffer,
     offset_in_bits: usize,
     len_in_bits: usize,
-    op: F,
+    mut op: F,
 ) -> Buffer
 where
-    F: Fn(u64) -> u64,
+    F: FnMut(u64) -> u64,
 {
     // reserve capacity and set length so we can get a typed view of u64 chunks
     let mut result =
@@ -85,6 +125,8 @@ where
     result.into()
 }
 
+/// Apply a bitwise and to two inputs and return the result as a Buffer.
+/// The inputs are treated as bitmaps, meaning that offsets and length are specified in number of bits.
 pub fn buffer_bin_and(
     left: &Buffer,
     left_offset_in_bits: usize,
@@ -102,6 +144,8 @@ pub fn buffer_bin_and(
     )
 }
 
+/// Apply a bitwise or to two inputs and return the result as a Buffer.
+/// The inputs are treated as bitmaps, meaning that offsets and length are specified in number of bits.
 pub fn buffer_bin_or(
     left: &Buffer,
     left_offset_in_bits: usize,
@@ -119,10 +163,46 @@ pub fn buffer_bin_or(
     )
 }
 
-pub fn buffer_unary_not(
+/// Apply a bitwise xor to two inputs and return the result as a Buffer.
+/// The inputs are treated as bitmaps, meaning that offsets and length are specified in number of bits.
+pub fn buffer_bin_xor(
     left: &Buffer,
-    offset_in_bits: usize,
+    left_offset_in_bits: usize,
+    right: &Buffer,
+    right_offset_in_bits: usize,
     len_in_bits: usize,
 ) -> Buffer {
+    bitwise_bin_op_helper(
+        left,
+        left_offset_in_bits,
+        right,
+        right_offset_in_bits,
+        len_in_bits,
+        |a, b| a ^ b,
+    )
+}
+
+/// Apply a bitwise and_not to two inputs and return the result as a Buffer.
+/// The inputs are treated as bitmaps, meaning that offsets and length are specified in number of bits.
+pub fn buffer_bin_and_not(
+    left: &Buffer,
+    left_offset_in_bits: usize,
+    right: &Buffer,
+    right_offset_in_bits: usize,
+    len_in_bits: usize,
+) -> Buffer {
+    bitwise_bin_op_helper(
+        left,
+        left_offset_in_bits,
+        right,
+        right_offset_in_bits,
+        len_in_bits,
+        |a, b| a & !b,
+    )
+}
+
+/// Apply a bitwise not to one input and return the result as a Buffer.
+/// The input is treated as a bitmap, meaning that offset and length are specified in number of bits.
+pub fn buffer_unary_not(left: &Buffer, offset_in_bits: usize, len_in_bits: usize) -> Buffer {
     bitwise_unary_op_helper(left, offset_in_bits, len_in_bits, |a| !a)
 }
diff --git a/arrow-buffer/src/buffer/run.rs b/arrow-buffer/src/buffer/run.rs
new file mode 100644
index 000000000000..3dbbe344a025
--- /dev/null
+++ b/arrow-buffer/src/buffer/run.rs
@@ -0,0 +1,230 @@
+// 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.
+
+use crate::buffer::ScalarBuffer;
+use crate::ArrowNativeType;
+
+/// A slice-able buffer of monotonically increasing, positive integers used to store run-ends
+///
+/// # Logical vs Physical
+///
+/// A [`RunEndBuffer`] is used to encode runs of the same value, the index of each run is
+/// called the physical index. The logical index is then the corresponding index in the logical
+/// run-encoded array, i.e. a single run of length `3`, would have the logical indices `0..3`.
+///
+/// Each value in [`RunEndBuffer::values`] is the cumulative length of all runs in the
+/// logical array, up to that physical index.
+///
+/// Consider a [`RunEndBuffer`] containing `[3, 4, 6]`. The maximum physical index is `2`,
+/// as there are `3` values, and the maximum logical index is `5`, as the maximum run end
+/// is `6`. The physical indices are therefore `[0, 0, 0, 1, 2, 2]`
+///
+/// ```text
+///     ┌─────────┐        ┌─────────┐           ┌─────────┐
+///     │    3    │        │    0    │ ─┬──────▶ │    0    │
+///     ├─────────┤        ├─────────┤  │        ├─────────┤
+///     │    4    │        │    1    │ ─┤ ┌────▶ │    1    │
+///     ├─────────┤        ├─────────┤  │ │      ├─────────┤
+///     │    6    │        │    2    │ ─┘ │ ┌──▶ │    2    │
+///     └─────────┘        ├─────────┤    │ │    └─────────┘
+///      run ends          │    3    │ ───┘ │  physical indices
+///                        ├─────────┤      │
+///                        │    4    │ ─────┤
+///                        ├─────────┤      │
+///                        │    5    │ ─────┘
+///                        └─────────┘
+///                      logical indices
+/// ```
+///
+/// # Slicing
+///
+/// In order to provide zero-copy slicing, this container stores a separate offset and length
+///
+/// For example, a [`RunEndBuffer`] containing values `[3, 6, 8]` with offset and length `4` would
+/// describe the physical indices `1, 1, 2, 2`
+///
+/// For example, a [`RunEndBuffer`] containing values `[6, 8, 9]` with offset `2` and length `5`
+/// would describe the physical indices `0, 0, 0, 0, 1`
+///
+/// [Run-End encoded layout]: https://arrow.apache.org/docs/format/Columnar.html#run-end-encoded-layout
+#[derive(Debug, Clone)]
+pub struct RunEndBuffer<E: ArrowNativeType> {
+    run_ends: ScalarBuffer<E>,
+    len: usize,
+    offset: usize,
+}
+
+impl<E> RunEndBuffer<E>
+where
+    E: ArrowNativeType,
+{
+    /// Create a new [`RunEndBuffer`] from a [`ScalarBuffer`], an `offset` and `len`
+    ///
+    /// # Panics
+    ///
+    /// - `buffer` does not contain strictly increasing values greater than zero
+    /// - the last value of `buffer` is less than `offset + len`
+    pub fn new(run_ends: ScalarBuffer<E>, offset: usize, len: usize) -> Self {
+        assert!(
+            run_ends.windows(2).all(|w| w[0] < w[1]),
+            "run-ends not strictly increasing"
+        );
+
+        if len != 0 {
+            assert!(!run_ends.is_empty(), "non-empty slice but empty run-ends");
+            let end = E::from_usize(offset.saturating_add(len)).unwrap();
+            assert!(
+                *run_ends.first().unwrap() > E::usize_as(0),
+                "run-ends not greater than 0"
+            );
+            assert!(
+                *run_ends.last().unwrap() >= end,
+                "slice beyond bounds of run-ends"
+            );
+        }
+
+        Self {
+            run_ends,
+            offset,
+            len,
+        }
+    }
+
+    /// Create a new [`RunEndBuffer`] from an [`ScalarBuffer`], an `offset` and `len`
+    ///
+    /// # Safety
+    ///
+    /// - `buffer` must contain strictly increasing values greater than zero
+    /// - The last value of `buffer` must be greater than or equal to `offset + len`
+    pub unsafe fn new_unchecked(run_ends: ScalarBuffer<E>, offset: usize, len: usize) -> Self {
+        Self {
+            run_ends,
+            offset,
+            len,
+        }
+    }
+
+    /// Returns the logical offset into the run-ends stored by this buffer
+    #[inline]
+    pub fn offset(&self) -> usize {
+        self.offset
+    }
+
+    /// Returns the logical length of the run-ends stored by this buffer
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns true if this buffer is empty
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// Returns the values of this [`RunEndBuffer`] not including any offset
+    #[inline]
+    pub fn values(&self) -> &[E] {
+        &self.run_ends
+    }
+
+    /// Returns the maximum run-end encoded in the underlying buffer
+    #[inline]
+    pub fn max_value(&self) -> usize {
+        self.values().last().copied().unwrap_or_default().as_usize()
+    }
+
+    /// Performs a binary search to find the physical index for the given logical index
+    ///
+    /// The result is arbitrary if `logical_index >= self.len()`
+    pub fn get_physical_index(&self, logical_index: usize) -> usize {
+        let logical_index = E::usize_as(self.offset + logical_index);
+        let cmp = |p: &E| p.partial_cmp(&logical_index).unwrap();
+
+        match self.run_ends.binary_search_by(cmp) {
+            Ok(idx) => idx + 1,
+            Err(idx) => idx,
+        }
+    }
+
+    /// Returns the physical index at which the logical array starts
+    pub fn get_start_physical_index(&self) -> usize {
+        if self.offset == 0 || self.len == 0 {
+            return 0;
+        }
+        // Fallback to binary search
+        self.get_physical_index(0)
+    }
+
+    /// Returns the physical index at which the logical array ends
+    pub fn get_end_physical_index(&self) -> usize {
+        if self.len == 0 {
+            return 0;
+        }
+        if self.max_value() == self.offset + self.len {
+            return self.values().len() - 1;
+        }
+        // Fallback to binary search
+        self.get_physical_index(self.len - 1)
+    }
+
+    /// Slices this [`RunEndBuffer`] by the provided `offset` and `length`
+    pub fn slice(&self, offset: usize, len: usize) -> Self {
+        assert!(
+            offset.saturating_add(len) <= self.len,
+            "the length + offset of the sliced RunEndBuffer cannot exceed the existing length"
+        );
+        Self {
+            run_ends: self.run_ends.clone(),
+            offset: self.offset + offset,
+            len,
+        }
+    }
+
+    /// Returns the inner [`ScalarBuffer`]
+    pub fn inner(&self) -> &ScalarBuffer<E> {
+        &self.run_ends
+    }
+
+    /// Returns the inner [`ScalarBuffer`], consuming self
+    pub fn into_inner(self) -> ScalarBuffer<E> {
+        self.run_ends
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::buffer::RunEndBuffer;
+
+    #[test]
+    fn test_zero_length_slice() {
+        let buffer = RunEndBuffer::new(vec![1_i32, 4_i32].into(), 0, 4);
+        assert_eq!(buffer.get_start_physical_index(), 0);
+        assert_eq!(buffer.get_end_physical_index(), 1);
+        assert_eq!(buffer.get_physical_index(3), 1);
+
+        for offset in 0..4 {
+            let sliced = buffer.slice(offset, 0);
+            assert_eq!(sliced.get_start_physical_index(), 0);
+            assert_eq!(sliced.get_end_physical_index(), 0);
+        }
+
+        let buffer = RunEndBuffer::new(Vec::<i32>::new().into(), 0, 0);
+        assert_eq!(buffer.get_start_physical_index(), 0);
+        assert_eq!(buffer.get_end_physical_index(), 0);
+    }
+}
diff --git a/arrow-buffer/src/buffer/scalar.rs b/arrow-buffer/src/buffer/scalar.rs
new file mode 100644
index 000000000000..3826d74e43bd
--- /dev/null
+++ b/arrow-buffer/src/buffer/scalar.rs
@@ -0,0 +1,287 @@
+// 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.
+
+use crate::alloc::Deallocation;
+use crate::buffer::Buffer;
+use crate::native::ArrowNativeType;
+use crate::{BufferBuilder, MutableBuffer, OffsetBuffer};
+use std::fmt::Formatter;
+use std::marker::PhantomData;
+use std::ops::Deref;
+
+/// A strongly-typed [`Buffer`] supporting zero-copy cloning and slicing
+///
+/// The easiest way to think about `ScalarBuffer<T>` is being equivalent to a `Arc<Vec<T>>`,
+/// with the following differences:
+///
+/// - slicing and cloning is O(1).
+/// - it supports external allocated memory
+///
+/// ```
+/// # use arrow_buffer::ScalarBuffer;
+/// // Zero-copy conversion from Vec
+/// let buffer = ScalarBuffer::from(vec![1, 2, 3]);
+/// assert_eq!(&buffer, &[1, 2, 3]);
+///
+/// // Zero-copy slicing
+/// let sliced = buffer.slice(1, 2);
+/// assert_eq!(&sliced, &[2, 3]);
+/// ```
+#[derive(Clone)]
+pub struct ScalarBuffer<T: ArrowNativeType> {
+    /// Underlying data buffer
+    buffer: Buffer,
+    phantom: PhantomData<T>,
+}
+
+impl<T: ArrowNativeType> std::fmt::Debug for ScalarBuffer<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("ScalarBuffer").field(&self.as_ref()).finish()
+    }
+}
+
+impl<T: ArrowNativeType> ScalarBuffer<T> {
+    /// Create a new [`ScalarBuffer`] from a [`Buffer`], and an `offset`
+    /// and `length` in units of `T`
+    ///
+    /// # Panics
+    ///
+    /// This method will panic if
+    ///
+    /// * `offset` or `len` would result in overflow
+    /// * `buffer` is not aligned to a multiple of `std::mem::size_of::<T>`
+    /// * `bytes` is not large enough for the requested slice
+    pub fn new(buffer: Buffer, offset: usize, len: usize) -> Self {
+        let size = std::mem::size_of::<T>();
+        let byte_offset = offset.checked_mul(size).expect("offset overflow");
+        let byte_len = len.checked_mul(size).expect("length overflow");
+        buffer.slice_with_length(byte_offset, byte_len).into()
+    }
+
+    /// Returns a zero-copy slice of this buffer with length `len` and starting at `offset`
+    pub fn slice(&self, offset: usize, len: usize) -> Self {
+        Self::new(self.buffer.clone(), offset, len)
+    }
+
+    /// Returns the inner [`Buffer`]
+    pub fn inner(&self) -> &Buffer {
+        &self.buffer
+    }
+
+    /// Returns the inner [`Buffer`], consuming self
+    pub fn into_inner(self) -> Buffer {
+        self.buffer
+    }
+
+    /// Returns true if this [`ScalarBuffer`] is equal to `other`, using pointer comparisons
+    /// to determine buffer equality. This is cheaper than `PartialEq::eq` but may
+    /// return false when the arrays are logically equal
+    #[inline]
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        self.buffer.ptr_eq(&other.buffer)
+    }
+}
+
+impl<T: ArrowNativeType> Deref for ScalarBuffer<T> {
+    type Target = [T];
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        // SAFETY: Verified alignment in From<Buffer>
+        unsafe {
+            std::slice::from_raw_parts(
+                self.buffer.as_ptr() as *const T,
+                self.buffer.len() / std::mem::size_of::<T>(),
+            )
+        }
+    }
+}
+
+impl<T: ArrowNativeType> AsRef<[T]> for ScalarBuffer<T> {
+    #[inline]
+    fn as_ref(&self) -> &[T] {
+        self
+    }
+}
+
+impl<T: ArrowNativeType> From<MutableBuffer> for ScalarBuffer<T> {
+    fn from(value: MutableBuffer) -> Self {
+        Buffer::from(value).into()
+    }
+}
+
+impl<T: ArrowNativeType> From<Buffer> for ScalarBuffer<T> {
+    fn from(buffer: Buffer) -> Self {
+        let align = std::mem::align_of::<T>();
+        let is_aligned = buffer.as_ptr().align_offset(align) == 0;
+
+        match buffer.deallocation() {
+            Deallocation::Standard(_) => assert!(
+                is_aligned,
+                "Memory pointer is not aligned with the specified scalar type"
+            ),
+            Deallocation::Custom(_, _) =>
+                assert!(is_aligned, "Memory pointer from external source (e.g, FFI) is not aligned with the specified scalar type. Before importing buffer through FFI, please make sure the allocation is aligned."),
+        }
+
+        Self {
+            buffer,
+            phantom: Default::default(),
+        }
+    }
+}
+
+impl<T: ArrowNativeType> From<OffsetBuffer<T>> for ScalarBuffer<T> {
+    fn from(value: OffsetBuffer<T>) -> Self {
+        value.into_inner()
+    }
+}
+
+impl<T: ArrowNativeType> From<Vec<T>> for ScalarBuffer<T> {
+    fn from(value: Vec<T>) -> Self {
+        Self {
+            buffer: Buffer::from_vec(value),
+            phantom: Default::default(),
+        }
+    }
+}
+
+impl<T: ArrowNativeType> From<BufferBuilder<T>> for ScalarBuffer<T> {
+    fn from(mut value: BufferBuilder<T>) -> Self {
+        let len = value.len();
+        Self::new(value.finish(), 0, len)
+    }
+}
+
+impl<T: ArrowNativeType> FromIterator<T> for ScalarBuffer<T> {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        iter.into_iter().collect::<Vec<_>>().into()
+    }
+}
+
+impl<'a, T: ArrowNativeType> IntoIterator for &'a ScalarBuffer<T> {
+    type Item = &'a T;
+    type IntoIter = std::slice::Iter<'a, T>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.as_ref().iter()
+    }
+}
+
+impl<T: ArrowNativeType, S: AsRef<[T]> + ?Sized> PartialEq<S> for ScalarBuffer<T> {
+    fn eq(&self, other: &S) -> bool {
+        self.as_ref().eq(other.as_ref())
+    }
+}
+
+impl<T: ArrowNativeType, const N: usize> PartialEq<ScalarBuffer<T>> for [T; N] {
+    fn eq(&self, other: &ScalarBuffer<T>) -> bool {
+        self.as_ref().eq(other.as_ref())
+    }
+}
+
+impl<T: ArrowNativeType> PartialEq<ScalarBuffer<T>> for [T] {
+    fn eq(&self, other: &ScalarBuffer<T>) -> bool {
+        self.as_ref().eq(other.as_ref())
+    }
+}
+
+impl<T: ArrowNativeType> PartialEq<ScalarBuffer<T>> for Vec<T> {
+    fn eq(&self, other: &ScalarBuffer<T>) -> bool {
+        self.as_slice().eq(other.as_ref())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_basic() {
+        let expected = [0_i32, 1, 2];
+        let buffer = Buffer::from_iter(expected.iter().cloned());
+        let typed = ScalarBuffer::<i32>::new(buffer.clone(), 0, 3);
+        assert_eq!(*typed, expected);
+
+        let typed = ScalarBuffer::<i32>::new(buffer.clone(), 1, 2);
+        assert_eq!(*typed, expected[1..]);
+
+        let typed = ScalarBuffer::<i32>::new(buffer.clone(), 1, 0);
+        assert!(typed.is_empty());
+
+        let typed = ScalarBuffer::<i32>::new(buffer, 3, 0);
+        assert!(typed.is_empty());
+    }
+
+    #[test]
+    fn test_debug() {
+        let buffer = ScalarBuffer::from(vec![1, 2, 3]);
+        assert_eq!(format!("{buffer:?}"), "ScalarBuffer([1, 2, 3])");
+    }
+
+    #[test]
+    #[should_panic(expected = "Memory pointer is not aligned with the specified scalar type")]
+    fn test_unaligned() {
+        let expected = [0_i32, 1, 2];
+        let buffer = Buffer::from_iter(expected.iter().cloned());
+        let buffer = buffer.slice(1);
+        ScalarBuffer::<i32>::new(buffer, 0, 2);
+    }
+
+    #[test]
+    #[should_panic(expected = "the offset of the new Buffer cannot exceed the existing length")]
+    fn test_length_out_of_bounds() {
+        let buffer = Buffer::from_iter([0_i32, 1, 2]);
+        ScalarBuffer::<i32>::new(buffer, 1, 3);
+    }
+
+    #[test]
+    #[should_panic(expected = "the offset of the new Buffer cannot exceed the existing length")]
+    fn test_offset_out_of_bounds() {
+        let buffer = Buffer::from_iter([0_i32, 1, 2]);
+        ScalarBuffer::<i32>::new(buffer, 4, 0);
+    }
+
+    #[test]
+    #[should_panic(expected = "offset overflow")]
+    fn test_length_overflow() {
+        let buffer = Buffer::from_iter([0_i32, 1, 2]);
+        ScalarBuffer::<i32>::new(buffer, usize::MAX, 1);
+    }
+
+    #[test]
+    #[should_panic(expected = "offset overflow")]
+    fn test_start_overflow() {
+        let buffer = Buffer::from_iter([0_i32, 1, 2]);
+        ScalarBuffer::<i32>::new(buffer, usize::MAX / 4 + 1, 0);
+    }
+
+    #[test]
+    #[should_panic(expected = "length overflow")]
+    fn test_end_overflow() {
+        let buffer = Buffer::from_iter([0_i32, 1, 2]);
+        ScalarBuffer::<i32>::new(buffer, 0, usize::MAX / 4 + 1);
+    }
+
+    #[test]
+    fn convert_from_buffer_builder() {
+        let input = vec![1, 2, 3, 4];
+        let buffer_builder = BufferBuilder::from(input.clone());
+        let scalar_buffer = ScalarBuffer::from(buffer_builder);
+        assert_eq!(scalar_buffer.as_ref(), input);
+    }
+}
diff --git a/arrow/src/array/builder/boolean_buffer_builder.rs b/arrow-buffer/src/builder/boolean.rs
similarity index 65%
rename from arrow/src/array/builder/boolean_buffer_builder.rs
rename to arrow-buffer/src/builder/boolean.rs
index 5b6d1ce48478..ca178ae5ce4e 100644
--- a/arrow/src/array/builder/boolean_buffer_builder.rs
+++ b/arrow-buffer/src/builder/boolean.rs
@@ -15,12 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::buffer::{Buffer, MutableBuffer};
-
-use super::Range;
-
-use crate::util::bit_util;
+use crate::{bit_mask, bit_util, BooleanBuffer, Buffer, MutableBuffer};
+use std::ops::Range;
 
+/// Builder for [`BooleanBuffer`]
 #[derive(Debug)]
 pub struct BooleanBufferBuilder {
     buffer: MutableBuffer,
@@ -28,6 +26,7 @@ pub struct BooleanBufferBuilder {
 }
 
 impl BooleanBufferBuilder {
+    /// Creates a new `BooleanBufferBuilder`
     #[inline]
     pub fn new(capacity: usize) -> Self {
         let byte_capacity = bit_util::ceil(capacity, 8);
@@ -35,11 +34,24 @@ impl BooleanBufferBuilder {
         Self { buffer, len: 0 }
     }
 
+    /// Creates a new `BooleanBufferBuilder` from [`MutableBuffer`] of `len`
+    pub fn new_from_buffer(buffer: MutableBuffer, len: usize) -> Self {
+        assert!(len <= buffer.len() * 8);
+        let mut s = Self {
+            len: buffer.len() * 8,
+            buffer,
+        };
+        s.truncate(len);
+        s
+    }
+
+    /// Returns the length of the buffer
     #[inline]
     pub fn len(&self) -> usize {
         self.len
     }
 
+    /// Sets a bit in the buffer at `index`
     #[inline]
     pub fn set_bit(&mut self, index: usize, v: bool) {
         if v {
@@ -49,21 +61,25 @@ impl BooleanBufferBuilder {
         }
     }
 
+    /// Gets a bit in the buffer at `index`
     #[inline]
     pub fn get_bit(&self, index: usize) -> bool {
         bit_util::get_bit(self.buffer.as_slice(), index)
     }
 
+    /// Returns true if empty
     #[inline]
     pub fn is_empty(&self) -> bool {
         self.len == 0
     }
 
+    /// Returns the capacity of the buffer
     #[inline]
     pub fn capacity(&self) -> usize {
         self.buffer.capacity() * 8
     }
 
+    /// Advances the buffer by `additional` bits
     #[inline]
     pub fn advance(&mut self, additional: usize) {
         let new_len = self.len + additional;
@@ -74,6 +90,26 @@ impl BooleanBufferBuilder {
         self.len = new_len;
     }
 
+    /// Truncates the builder to the given length
+    ///
+    /// If `len` is greater than the buffer's current length, this has no effect
+    #[inline]
+    pub fn truncate(&mut self, len: usize) {
+        if len > self.len {
+            return;
+        }
+
+        let new_len_bytes = bit_util::ceil(len, 8);
+        self.buffer.truncate(new_len_bytes);
+        self.len = len;
+
+        let remainder = self.len % 8;
+        if remainder != 0 {
+            let mask = (1_u8 << remainder).wrapping_sub(1);
+            *self.buffer.as_mut().last_mut().unwrap() &= mask;
+        }
+    }
+
     /// Reserve space to at least `additional` new bits.
     /// Capacity will be `>= self.len() + additional`.
     /// New bytes are uninitialized and reading them is undefined behavior.
@@ -91,11 +127,13 @@ impl BooleanBufferBuilder {
     /// growing it (potentially reallocating it) and writing `false` in the newly available bits.
     #[inline]
     pub fn resize(&mut self, len: usize) {
-        let len_bytes = bit_util::ceil(len, 8);
-        self.buffer.resize(len_bytes, 0);
-        self.len = len;
+        match len.checked_sub(self.len) {
+            Some(delta) => self.advance(delta),
+            None => self.truncate(len),
+        }
     }
 
+    /// Appends a boolean `v` into the buffer
     #[inline]
     pub fn append(&mut self, v: bool) {
         self.advance(1);
@@ -104,17 +142,32 @@ impl BooleanBufferBuilder {
         }
     }
 
+    /// Appends n `additional` bits of value `v` into the buffer
     #[inline]
     pub fn append_n(&mut self, additional: usize, v: bool) {
-        self.advance(additional);
-        if additional > 0 && v {
-            let offset = self.len() - additional;
-            (0..additional).for_each(|i| unsafe {
-                bit_util::set_bit_raw(self.buffer.as_mut_ptr(), offset + i)
-            })
+        match v {
+            true => {
+                let new_len = self.len + additional;
+                let new_len_bytes = bit_util::ceil(new_len, 8);
+                let cur_remainder = self.len % 8;
+                let new_remainder = new_len % 8;
+
+                if cur_remainder != 0 {
+                    // Pad last byte with 1s
+                    *self.buffer.as_slice_mut().last_mut().unwrap() |= !((1 << cur_remainder) - 1)
+                }
+                self.buffer.resize(new_len_bytes, 0xFF);
+                if new_remainder != 0 {
+                    // Clear remaining bits
+                    *self.buffer.as_slice_mut().last_mut().unwrap() &= (1 << new_remainder) - 1
+                }
+                self.len = new_len;
+            }
+            false => self.advance(additional),
         }
     }
 
+    /// Appends a slice of booleans into the buffer
     #[inline]
     pub fn append_slice(&mut self, slice: &[bool]) {
         let additional = slice.len();
@@ -139,7 +192,7 @@ impl BooleanBufferBuilder {
         let offset_write = self.len;
         let len = range.end - range.start;
         self.advance(len);
-        crate::util::bit_mask::set_bits(
+        bit_mask::set_bits(
             self.buffer.as_slice_mut(),
             to_set,
             offset_write,
@@ -148,16 +201,33 @@ impl BooleanBufferBuilder {
         );
     }
 
+    /// Append [`BooleanBuffer`] to this [`BooleanBufferBuilder`]
+    pub fn append_buffer(&mut self, buffer: &BooleanBuffer) {
+        let range = buffer.offset()..buffer.offset() + buffer.len();
+        self.append_packed_range(range, buffer.values())
+    }
+
     /// Returns the packed bits
     pub fn as_slice(&self) -> &[u8] {
         self.buffer.as_slice()
     }
 
+    /// Returns the packed bits
+    pub fn as_slice_mut(&mut self) -> &mut [u8] {
+        self.buffer.as_slice_mut()
+    }
+
+    /// Creates a [`BooleanBuffer`]
     #[inline]
-    pub fn finish(&mut self) -> Buffer {
+    pub fn finish(&mut self) -> BooleanBuffer {
         let buf = std::mem::replace(&mut self.buffer, MutableBuffer::new(0));
-        self.len = 0;
-        buf.into()
+        let len = std::mem::replace(&mut self.len, 0);
+        BooleanBuffer::new(buf.into(), 0, len)
+    }
+
+    /// Builds the [BooleanBuffer] without resetting the builder.
+    pub fn finish_cloned(&self) -> BooleanBuffer {
+        BooleanBuffer::new(Buffer::from_slice_ref(self.as_slice()), 0, self.len)
     }
 }
 
@@ -168,6 +238,13 @@ impl From<BooleanBufferBuilder> for Buffer {
     }
 }
 
+impl From<BooleanBufferBuilder> for BooleanBuffer {
+    #[inline]
+    fn from(builder: BooleanBufferBuilder) -> Self {
+        BooleanBuffer::new(builder.buffer.into(), 0, builder.len)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -182,7 +259,7 @@ mod tests {
         assert_eq!(4, b.len());
         assert_eq!(512, b.capacity());
         let buffer = b.finish();
-        assert_eq!(1, buffer.len());
+        assert_eq!(4, buffer.len());
 
         // Overallocate capacity
         let mut b = BooleanBufferBuilder::new(8);
@@ -190,7 +267,7 @@ mod tests {
         assert_eq!(4, b.len());
         assert_eq!(512, b.capacity());
         let buffer = b.finish();
-        assert_eq!(1, buffer.len());
+        assert_eq!(4, buffer.len());
     }
 
     #[test]
@@ -202,7 +279,7 @@ mod tests {
         buffer.append(true);
         buffer.set_bit(0, false);
         assert_eq!(buffer.len(), 4);
-        assert_eq!(buffer.finish().as_slice(), &[0b1010_u8]);
+        assert_eq!(buffer.finish().values(), &[0b1010_u8]);
     }
 
     #[test]
@@ -214,7 +291,7 @@ mod tests {
         buffer.append(true);
         buffer.set_bit(3, false);
         assert_eq!(buffer.len(), 4);
-        assert_eq!(buffer.finish().as_slice(), &[0b0011_u8]);
+        assert_eq!(buffer.finish().values(), &[0b0011_u8]);
     }
 
     #[test]
@@ -226,7 +303,7 @@ mod tests {
         buffer.append(true);
         buffer.set_bit(1, false);
         assert_eq!(buffer.len(), 4);
-        assert_eq!(buffer.finish().as_slice(), &[0b1001_u8]);
+        assert_eq!(buffer.finish().values(), &[0b1001_u8]);
     }
 
     #[test]
@@ -240,7 +317,7 @@ mod tests {
         buffer.set_bit(1, false);
         buffer.set_bit(2, false);
         assert_eq!(buffer.len(), 5);
-        assert_eq!(buffer.finish().as_slice(), &[0b10001_u8]);
+        assert_eq!(buffer.finish().values(), &[0b10001_u8]);
     }
 
     #[test]
@@ -251,7 +328,7 @@ mod tests {
         buffer.set_bit(3, false);
         buffer.set_bit(9, false);
         assert_eq!(buffer.len(), 10);
-        assert_eq!(buffer.finish().as_slice(), &[0b11110110_u8, 0b01_u8]);
+        assert_eq!(buffer.finish().values(), &[0b11110110_u8, 0b01_u8]);
     }
 
     #[test]
@@ -267,7 +344,7 @@ mod tests {
         buffer.set_bit(14, true);
         buffer.set_bit(13, false);
         assert_eq!(buffer.len(), 15);
-        assert_eq!(buffer.finish().as_slice(), &[0b01010110_u8, 0b1011100_u8]);
+        assert_eq!(buffer.finish().values(), &[0b01010110_u8, 0b1011100_u8]);
     }
 
     #[test]
@@ -332,7 +409,7 @@ mod tests {
             let start = a.min(b);
             let end = a.max(b);
 
-            buffer.append_packed_range(start..end, compacted_src.as_slice());
+            buffer.append_packed_range(start..end, compacted_src.values());
             all_bools.extend_from_slice(&src[start..end]);
         }
 
@@ -362,6 +439,45 @@ mod tests {
         assert_eq!(builder.as_slice(), &[0b11101111, 0b00000001]);
     }
 
+    #[test]
+    fn test_truncate() {
+        let b = MutableBuffer::from_iter([true, true, true, true]);
+        let mut builder = BooleanBufferBuilder::new_from_buffer(b, 2);
+        builder.advance(2);
+        let finished = builder.finish();
+        assert_eq!(finished.values(), &[0b00000011]);
+
+        let mut builder = BooleanBufferBuilder::new(10);
+        builder.append_n(5, true);
+        builder.resize(3);
+        builder.advance(2);
+        let finished = builder.finish();
+        assert_eq!(finished.values(), &[0b00000111]);
+
+        let mut builder = BooleanBufferBuilder::new(10);
+        builder.append_n(16, true);
+        assert_eq!(builder.as_slice(), &[0xFF, 0xFF]);
+        builder.truncate(20);
+        assert_eq!(builder.as_slice(), &[0xFF, 0xFF]);
+        builder.truncate(14);
+        assert_eq!(builder.as_slice(), &[0xFF, 0b00111111]);
+        builder.append(false);
+        builder.append(true);
+        assert_eq!(builder.as_slice(), &[0xFF, 0b10111111]);
+        builder.append_packed_range(0..3, &[0xFF]);
+        assert_eq!(builder.as_slice(), &[0xFF, 0b10111111, 0b00000111]);
+        builder.truncate(17);
+        assert_eq!(builder.as_slice(), &[0xFF, 0b10111111, 0b00000001]);
+        builder.append_packed_range(0..2, &[2]);
+        assert_eq!(builder.as_slice(), &[0xFF, 0b10111111, 0b0000101]);
+        builder.truncate(8);
+        assert_eq!(builder.as_slice(), &[0xFF]);
+        builder.resize(14);
+        assert_eq!(builder.as_slice(), &[0xFF, 0x00]);
+        builder.truncate(0);
+        assert_eq!(builder.as_slice(), &[]);
+    }
+
     #[test]
     fn test_boolean_builder_increases_buffer_len() {
         // 00000010 01001000
@@ -377,7 +493,7 @@ mod tests {
         }
         let buf2 = builder.finish();
 
-        assert_eq!(buf.len(), buf2.len());
-        assert_eq!(buf.as_slice(), buf2.as_slice());
+        assert_eq!(buf.len(), buf2.inner().len());
+        assert_eq!(buf.as_slice(), buf2.values());
     }
 }
diff --git a/arrow/src/array/builder/buffer_builder.rs b/arrow-buffer/src/builder/mod.rs
similarity index 58%
rename from arrow/src/array/builder/buffer_builder.rs
rename to arrow-buffer/src/builder/mod.rs
index dd116f035af3..d5d5a7d3f18d 100644
--- a/arrow/src/array/builder/buffer_builder.rs
+++ b/arrow-buffer/src/builder/mod.rs
@@ -15,35 +15,34 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::mem;
+//! Buffer builders
 
-use crate::buffer::{Buffer, MutableBuffer};
-use crate::datatypes::ArrowNativeType;
+mod boolean;
+pub use boolean::*;
+mod null;
+pub use null::*;
 
-use super::PhantomData;
+use crate::{ArrowNativeType, Buffer, MutableBuffer};
+use std::{iter, marker::PhantomData};
 
-/// Builder for creating a [`Buffer`](crate::buffer::Buffer) object.
+/// Builder for creating a [Buffer] object.
 ///
-/// A [`Buffer`](crate::buffer::Buffer) is the underlying data
-/// structure of Arrow's [`Arrays`](crate::array::Array).
+/// A [Buffer] is the underlying data structure of Arrow's Arrays.
 ///
 /// For all supported types, there are type definitions for the
-/// generic version of `BufferBuilder<T>`, e.g. `UInt8BufferBuilder`.
+/// generic version of `BufferBuilder<T>`, e.g. `BufferBuilder`.
 ///
 /// # Example:
 ///
 /// ```
-/// use arrow::array::UInt8BufferBuilder;
+/// # use arrow_buffer::builder::BufferBuilder;
 ///
-/// # fn main() -> arrow::error::Result<()> {
-/// let mut builder = UInt8BufferBuilder::new(100);
+/// let mut builder = BufferBuilder::<u8>::new(100);
 /// builder.append_slice(&[42, 43, 44]);
 /// builder.append(45);
 /// let buffer = builder.finish();
 ///
 /// assert_eq!(unsafe { buffer.typed_data::<u8>() }, &[42, 43, 44, 45]);
-/// # Ok(())
-/// # }
 /// ```
 #[derive(Debug)]
 pub struct BufferBuilder<T: ArrowNativeType> {
@@ -67,15 +66,15 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt8BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt8BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u8>::new(10);
     ///
     /// assert!(builder.capacity() >= 10);
     /// ```
     #[inline]
     pub fn new(capacity: usize) -> Self {
-        let buffer = MutableBuffer::new(capacity * mem::size_of::<T>());
+        let buffer = MutableBuffer::new(capacity * std::mem::size_of::<T>());
 
         Self {
             buffer,
@@ -84,14 +83,24 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
         }
     }
 
+    /// Creates a new builder from a [`MutableBuffer`]
+    pub fn new_from_buffer(buffer: MutableBuffer) -> Self {
+        let buffer_len = buffer.len();
+        Self {
+            buffer,
+            len: buffer_len / std::mem::size_of::<T>(),
+            _marker: PhantomData,
+        }
+    }
+
     /// Returns the current number of array elements in the internal buffer.
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt8BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt8BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u8>::new(10);
     /// builder.append(42);
     ///
     /// assert_eq!(builder.len(), 1);
@@ -105,9 +114,9 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt8BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt8BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u8>::new(10);
     /// builder.append(42);
     ///
     /// assert_eq!(builder.is_empty(), false);
@@ -136,16 +145,16 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt8BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt8BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u8>::new(10);
     /// builder.advance(2);
     ///
     /// assert_eq!(builder.len(), 2);
     /// ```
     #[inline]
     pub fn advance(&mut self, i: usize) {
-        self.buffer.extend_zeros(i * mem::size_of::<T>());
+        self.buffer.extend_zeros(i * std::mem::size_of::<T>());
         self.len += i;
     }
 
@@ -154,16 +163,16 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt8BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt8BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u8>::new(10);
     /// builder.reserve(10);
     ///
     /// assert!(builder.capacity() >= 20);
     /// ```
     #[inline]
     pub fn reserve(&mut self, n: usize) {
-        self.buffer.reserve(n * mem::size_of::<T>());
+        self.buffer.reserve(n * std::mem::size_of::<T>());
     }
 
     /// Appends a value of type `T` into the builder,
@@ -172,9 +181,9 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt8BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt8BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u8>::new(10);
     /// builder.append(42);
     ///
     /// assert_eq!(builder.len(), 1);
@@ -192,9 +201,9 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt8BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt8BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u8>::new(10);
     /// builder.append_n(10, 42);
     ///
     /// assert_eq!(builder.len(), 10);
@@ -202,10 +211,7 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     #[inline]
     pub fn append_n(&mut self, n: usize, v: T) {
         self.reserve(n);
-        for _ in 0..n {
-            self.buffer.push(v);
-        }
-        self.len += n;
+        self.extend(iter::repeat(v).take(n))
     }
 
     /// Appends `n`, zero-initialized values
@@ -213,16 +219,16 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt32BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt32BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u32>::new(10);
     /// builder.append_n_zeroed(3);
     ///
     /// assert_eq!(builder.len(), 3);
     /// assert_eq!(builder.as_slice(), &[0, 0, 0])
     #[inline]
     pub fn append_n_zeroed(&mut self, n: usize) {
-        self.buffer.extend_zeros(n * mem::size_of::<T>());
+        self.buffer.extend_zeros(n * std::mem::size_of::<T>());
         self.len += n;
     }
 
@@ -231,9 +237,9 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt8BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt8BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u8>::new(10);
     /// builder.append_slice(&[42, 44, 46]);
     ///
     /// assert_eq!(builder.len(), 3);
@@ -247,9 +253,9 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// View the contents of this buffer as a slice
     ///
     /// ```
-    /// use arrow::array::Float64BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = Float64BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<f64>::new(10);
     /// builder.append(1.3);
     /// builder.append_n(2, 2.3);
     ///
@@ -270,9 +276,9 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::Float32BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = Float32BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<f32>::new(10);
     ///
     /// builder.append_slice(&[1., 2., 3.4]);
     /// assert_eq!(builder.as_slice(), &[1., 2., 3.4]);
@@ -297,9 +303,9 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt16BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt16BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u16>::new(10);
     ///
     /// builder.append_slice(&[42, 44, 46]);
     /// assert_eq!(builder.as_slice(), &[42, 44, 46]);
@@ -312,7 +318,7 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// ```
     #[inline]
     pub fn truncate(&mut self, len: usize) {
-        self.buffer.truncate(len * mem::size_of::<T>());
+        self.buffer.truncate(len * std::mem::size_of::<T>());
         self.len = len;
     }
 
@@ -327,20 +333,17 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
             .1
             .expect("append_trusted_len_iter expects upper bound");
         self.reserve(len);
-        for v in iter {
-            self.buffer.push(v)
-        }
-        self.len += len;
+        self.extend(iter);
     }
 
-    /// Resets this builder and returns an immutable [`Buffer`](crate::buffer::Buffer).
+    /// Resets this builder and returns an immutable [Buffer].
     ///
     /// # Example:
     ///
     /// ```
-    /// use arrow::array::UInt8BufferBuilder;
+    /// # use arrow_buffer::builder::BufferBuilder;
     ///
-    /// let mut builder = UInt8BufferBuilder::new(10);
+    /// let mut builder = BufferBuilder::<u8>::new(10);
     /// builder.append_slice(&[42, 44, 46]);
     ///
     /// let buffer = builder.finish();
@@ -349,133 +352,67 @@ impl<T: ArrowNativeType> BufferBuilder<T> {
     /// ```
     #[inline]
     pub fn finish(&mut self) -> Buffer {
-        let buf = std::mem::replace(&mut self.buffer, MutableBuffer::new(0));
+        let buf = std::mem::take(&mut self.buffer);
         self.len = 0;
         buf.into()
     }
 }
 
-#[cfg(test)]
-mod tests {
-    use crate::array::array::Array;
-    use crate::array::builder::ArrayBuilder;
-    use crate::array::Int32BufferBuilder;
-    use crate::array::Int8Builder;
-    use crate::array::UInt8BufferBuilder;
-
-    #[test]
-    fn test_builder_i32_empty() {
-        let mut b = Int32BufferBuilder::new(5);
-        assert_eq!(0, b.len());
-        assert_eq!(16, b.capacity());
-        let a = b.finish();
-        assert_eq!(0, a.len());
+impl<T: ArrowNativeType> Default for BufferBuilder<T> {
+    fn default() -> Self {
+        Self::new(0)
     }
+}
 
-    #[test]
-    fn test_builder_i32_alloc_zero_bytes() {
-        let mut b = Int32BufferBuilder::new(0);
-        b.append(123);
-        let a = b.finish();
-        assert_eq!(4, a.len());
+impl<T: ArrowNativeType> Extend<T> for BufferBuilder<T> {
+    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
+        self.buffer.extend(iter.into_iter().inspect(|_| {
+            self.len += 1;
+        }))
     }
+}
 
-    #[test]
-    fn test_builder_i32() {
-        let mut b = Int32BufferBuilder::new(5);
-        for i in 0..5 {
-            b.append(i);
-        }
-        assert_eq!(16, b.capacity());
-        let a = b.finish();
-        assert_eq!(20, a.len());
+impl<T: ArrowNativeType> From<Vec<T>> for BufferBuilder<T> {
+    fn from(value: Vec<T>) -> Self {
+        Self::new_from_buffer(MutableBuffer::from(value))
     }
+}
 
-    #[test]
-    fn test_builder_i32_grow_buffer() {
-        let mut b = Int32BufferBuilder::new(2);
-        assert_eq!(16, b.capacity());
-        for i in 0..20 {
-            b.append(i);
-        }
-        assert_eq!(32, b.capacity());
-        let a = b.finish();
-        assert_eq!(80, a.len());
+impl<T: ArrowNativeType> FromIterator<T> for BufferBuilder<T> {
+    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
+        let mut builder = Self::default();
+        builder.extend(iter);
+        builder
     }
+}
 
-    #[test]
-    fn test_builder_finish() {
-        let mut b = Int32BufferBuilder::new(5);
-        assert_eq!(16, b.capacity());
-        for i in 0..10 {
-            b.append(i);
-        }
-        let mut a = b.finish();
-        assert_eq!(40, a.len());
-        assert_eq!(0, b.len());
-        assert_eq!(0, b.capacity());
-
-        // Try build another buffer after cleaning up.
-        for i in 0..20 {
-            b.append(i)
-        }
-        assert_eq!(32, b.capacity());
-        a = b.finish();
-        assert_eq!(80, a.len());
-    }
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::mem;
 
     #[test]
-    fn test_reserve() {
-        let mut b = UInt8BufferBuilder::new(2);
-        assert_eq!(64, b.capacity());
-        b.reserve(64);
-        assert_eq!(64, b.capacity());
-        b.reserve(65);
-        assert_eq!(128, b.capacity());
-
-        let mut b = Int32BufferBuilder::new(2);
-        assert_eq!(16, b.capacity());
-        b.reserve(16);
-        assert_eq!(16, b.capacity());
-        b.reserve(17);
-        assert_eq!(32, b.capacity());
+    fn default() {
+        let builder = BufferBuilder::<u32>::default();
+        assert!(builder.is_empty());
+        assert!(builder.buffer.is_empty());
+        assert_eq!(builder.buffer.capacity(), 0);
     }
 
     #[test]
-    fn test_append_slice() {
-        let mut b = UInt8BufferBuilder::new(0);
-        b.append_slice(b"Hello, ");
-        b.append_slice(b"World!");
-        let buffer = b.finish();
-        assert_eq!(13, buffer.len());
-
-        let mut b = Int32BufferBuilder::new(0);
-        b.append_slice(&[32, 54]);
-        let buffer = b.finish();
-        assert_eq!(8, buffer.len());
+    fn from_iter() {
+        let input = [1u16, 2, 3, 4];
+        let builder = input.into_iter().collect::<BufferBuilder<_>>();
+        assert_eq!(builder.len(), 4);
+        assert_eq!(builder.buffer.len(), 4 * mem::size_of::<u16>());
     }
 
     #[test]
-    fn test_append_values() {
-        let mut a = Int8Builder::new(0);
-        a.append_value(1);
-        a.append_null();
-        a.append_value(-2);
-        assert_eq!(a.len(), 3);
-
-        // append values
-        let values = &[1, 2, 3, 4];
-        let is_valid = &[true, true, false, true];
-        a.append_values(values, is_valid);
-
-        assert_eq!(a.len(), 7);
-        let array = a.finish();
-        assert_eq!(array.value(0), 1);
-        assert!(array.is_null(1));
-        assert_eq!(array.value(2), -2);
-        assert_eq!(array.value(3), 1);
-        assert_eq!(array.value(4), 2);
-        assert!(array.is_null(5));
-        assert_eq!(array.value(6), 4);
+    fn extend() {
+        let input = [1, 2];
+        let mut builder = input.into_iter().collect::<BufferBuilder<_>>();
+        assert_eq!(builder.len(), 2);
+        builder.extend([3, 4]);
+        assert_eq!(builder.len(), 4);
     }
 }
diff --git a/arrow/src/array/builder/null_buffer_builder.rs b/arrow-buffer/src/builder/null.rs
similarity index 79%
rename from arrow/src/array/builder/null_buffer_builder.rs
rename to arrow-buffer/src/builder/null.rs
index ef2e4c50ab9c..d805b79f09e6 100644
--- a/arrow/src/array/builder/null_buffer_builder.rs
+++ b/arrow-buffer/src/builder/null.rs
@@ -15,9 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::buffer::Buffer;
-
-use super::BooleanBufferBuilder;
+use crate::{BooleanBufferBuilder, MutableBuffer, NullBuffer};
 
 /// Builder for creating the null bit buffer.
 /// This builder only materializes the buffer when we append `false`.
@@ -25,7 +23,7 @@ use super::BooleanBufferBuilder;
 /// `None` when calling [`finish`](#method.finish).
 /// This optimization is **very** important for the performance.
 #[derive(Debug)]
-pub(super) struct NullBufferBuilder {
+pub struct NullBufferBuilder {
     bitmap_builder: Option<BooleanBufferBuilder>,
     /// Store the length of the buffer before materializing.
     len: usize,
@@ -43,6 +41,29 @@ impl NullBufferBuilder {
         }
     }
 
+    /// Creates a new builder with given length.
+    pub fn new_with_len(len: usize) -> Self {
+        Self {
+            bitmap_builder: None,
+            len,
+            capacity: len,
+        }
+    }
+
+    /// Creates a new builder from a `MutableBuffer`.
+    pub fn new_from_buffer(buffer: MutableBuffer, len: usize) -> Self {
+        let capacity = buffer.len() * 8;
+
+        assert!(len < capacity);
+
+        let bitmap_builder = Some(BooleanBufferBuilder::new_from_buffer(buffer, len));
+        Self {
+            bitmap_builder,
+            len,
+            capacity,
+        }
+    }
+
     /// Appends `n` `true`s into the builder
     /// to indicate that these `n` items are not nulls.
     #[inline]
@@ -106,14 +127,22 @@ impl NullBufferBuilder {
 
     /// Builds the null buffer and resets the builder.
     /// Returns `None` if the builder only contains `true`s.
-    pub fn finish(&mut self) -> Option<Buffer> {
-        let buf = self.bitmap_builder.as_mut().map(|b| b.finish());
-        self.bitmap_builder = None;
+    pub fn finish(&mut self) -> Option<NullBuffer> {
         self.len = 0;
-        buf
+        Some(NullBuffer::new(self.bitmap_builder.take()?.finish()))
+    }
+
+    /// Builds the [NullBuffer] without resetting the builder.
+    pub fn finish_cloned(&self) -> Option<NullBuffer> {
+        let buffer = self.bitmap_builder.as_ref()?.finish_cloned();
+        Some(NullBuffer::new(buffer))
+    }
+
+    /// Returns the inner bitmap builder as slice
+    pub fn as_slice(&self) -> Option<&[u8]> {
+        Some(self.bitmap_builder.as_ref()?.as_slice())
     }
 
-    #[inline]
     fn materialize_if_needed(&mut self) {
         if self.bitmap_builder.is_none() {
             self.materialize()
@@ -128,6 +157,10 @@ impl NullBufferBuilder {
             self.bitmap_builder = Some(b);
         }
     }
+
+    pub fn as_slice_mut(&mut self) -> Option<&mut [u8]> {
+        self.bitmap_builder.as_mut().map(|b| b.as_slice_mut())
+    }
 }
 
 impl NullBufferBuilder {
@@ -158,7 +191,7 @@ mod tests {
         assert_eq!(6, builder.len());
 
         let buf = builder.finish().unwrap();
-        assert_eq!(Buffer::from(&[0b110010_u8]), buf);
+        assert_eq!(&[0b110010_u8], buf.validity());
     }
 
     #[test]
@@ -170,7 +203,7 @@ mod tests {
         assert_eq!(6, builder.len());
 
         let buf = builder.finish().unwrap();
-        assert_eq!(Buffer::from(&[0b0_u8]), buf);
+        assert_eq!(&[0b0_u8], buf.validity());
     }
 
     #[test]
@@ -199,6 +232,6 @@ mod tests {
         builder.append_slice(&[true, true, false, true]);
 
         let buf = builder.finish().unwrap();
-        assert_eq!(Buffer::from(&[0b1011_u8]), buf);
+        assert_eq!(&[0b1011_u8], buf.validity());
     }
 }
diff --git a/arrow/src/bytes.rs b/arrow-buffer/src/bytes.rs
similarity index 71%
rename from arrow/src/bytes.rs
rename to arrow-buffer/src/bytes.rs
index 75137a55295b..ba61342d8e39 100644
--- a/arrow/src/bytes.rs
+++ b/arrow-buffer/src/bytes.rs
@@ -23,15 +23,15 @@ use core::slice;
 use std::ptr::NonNull;
 use std::{fmt::Debug, fmt::Formatter};
 
-use crate::alloc;
 use crate::alloc::Deallocation;
 
 /// A continuous, fixed-size, immutable memory region that knows how to de-allocate itself.
+///
 /// This structs' API is inspired by the `bytes::Bytes`, but it is not limited to using rust's
 /// global allocator nor u8 alignment.
 ///
-/// In the most common case, this buffer is allocated using [`allocate_aligned`](crate::alloc::allocate_aligned)
-/// and deallocated accordingly [`free_aligned`](crate::alloc::free_aligned).
+/// In the most common case, this buffer is allocated using [`alloc`](std::alloc::alloc)
+/// with an alignment of [`ALIGNMENT`](crate::alloc::ALIGNMENT)
 ///
 /// When the region is allocated by a different allocator, [Deallocation::Custom], this calls the
 /// custom deallocator to deallocate the region when it is no longer needed.
@@ -53,18 +53,14 @@ impl Bytes {
     ///
     /// * `ptr` - Pointer to raw parts
     /// * `len` - Length of raw parts in **bytes**
-    /// * `capacity` - Total allocated memory for the pointer `ptr`, in **bytes**
+    /// * `deallocation` - Type of allocation
     ///
     /// # Safety
     ///
     /// This function is unsafe as there is no guarantee that the given pointer is valid for `len`
     /// bytes. If the `ptr` and `capacity` come from a `Buffer`, then this is guaranteed.
     #[inline]
-    pub(crate) unsafe fn new(
-        ptr: std::ptr::NonNull<u8>,
-        len: usize,
-        deallocation: Deallocation,
-    ) -> Bytes {
+    pub(crate) unsafe fn new(ptr: NonNull<u8>, len: usize, deallocation: Deallocation) -> Bytes {
         Bytes {
             ptr,
             len,
@@ -93,12 +89,17 @@ impl Bytes {
 
     pub fn capacity(&self) -> usize {
         match self.deallocation {
-            Deallocation::Arrow(capacity) => capacity,
-            // we cannot determine this in general,
-            // and thus we state that this is externally-owned memory
-            Deallocation::Custom(_) => 0,
+            Deallocation::Standard(layout) => layout.size(),
+            // we only know the size of the custom allocation
+            // its underlying capacity might be larger
+            Deallocation::Custom(_, size) => size,
         }
     }
+
+    #[inline]
+    pub(crate) fn deallocation(&self) -> &Deallocation {
+        &self.deallocation
+    }
 }
 
 // Deallocation is Send + Sync, repeating the bound here makes that refactoring safe
@@ -110,11 +111,12 @@ impl Drop for Bytes {
     #[inline]
     fn drop(&mut self) {
         match &self.deallocation {
-            Deallocation::Arrow(capacity) => {
-                unsafe { alloc::free_aligned::<u8>(self.ptr, *capacity) };
-            }
+            Deallocation::Standard(layout) => match layout.size() {
+                0 => {} // Nothing to do
+                _ => unsafe { std::alloc::dealloc(self.ptr.as_ptr(), *layout) },
+            },
             // The automatic drop implementation will free the memory once the reference count reaches zero
-            Deallocation::Custom(_allocation) => (),
+            Deallocation::Custom(_allocation, _size) => (),
         }
     }
 }
@@ -142,3 +144,32 @@ impl Debug for Bytes {
         write!(f, " }}")
     }
 }
+
+impl From<bytes::Bytes> for Bytes {
+    fn from(value: bytes::Bytes) -> Self {
+        let len = value.len();
+        Self {
+            len,
+            ptr: NonNull::new(value.as_ptr() as _).unwrap(),
+            deallocation: Deallocation::Custom(std::sync::Arc::new(value), len),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_from_bytes() {
+        let bytes = bytes::Bytes::from(vec![1, 2, 3, 4]);
+        let arrow_bytes: Bytes = bytes.clone().into();
+
+        assert_eq!(bytes.as_ptr(), arrow_bytes.as_ptr());
+
+        drop(bytes);
+        drop(arrow_bytes);
+
+        let _ = Bytes::from(bytes::Bytes::new());
+    }
+}
diff --git a/arrow-buffer/src/lib.rs b/arrow-buffer/src/lib.rs
new file mode 100644
index 000000000000..612897af9bed
--- /dev/null
+++ b/arrow-buffer/src/lib.rs
@@ -0,0 +1,37 @@
+// 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.
+
+//! Low-level buffer abstractions for [Apache Arrow Rust](https://docs.rs/arrow)
+
+// used by [`buffer::mutable::dangling_ptr`]
+#![cfg_attr(miri, feature(strict_provenance))]
+
+pub mod alloc;
+pub mod buffer;
+pub use buffer::*;
+
+pub mod builder;
+pub use builder::*;
+
+mod bigint;
+mod bytes;
+mod native;
+pub use bigint::i256;
+
+pub use native::*;
+mod util;
+pub use util::*;
diff --git a/arrow-buffer/src/native.rs b/arrow-buffer/src/native.rs
new file mode 100644
index 000000000000..38074a8dc26c
--- /dev/null
+++ b/arrow-buffer/src/native.rs
@@ -0,0 +1,259 @@
+// 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.
+
+use crate::i256;
+use half::f16;
+
+mod private {
+    pub trait Sealed {}
+}
+
+/// Trait expressing a Rust type that has the same in-memory representation
+/// as Arrow. This includes `i16`, `f32`, but excludes `bool` (which in arrow is represented in bits).
+///
+/// In little endian machines, types that implement [`ArrowNativeType`] can be memcopied to arrow buffers
+/// as is.
+///
+/// # Transmute Safety
+///
+/// A type T implementing this trait means that any arbitrary slice of bytes of length and
+/// alignment `size_of::<T>()` can be safely interpreted as a value of that type without
+/// being unsound, i.e. potentially resulting in undefined behaviour.
+///
+/// Note: in the case of floating point numbers this transmutation can result in a signalling
+/// NaN, which, whilst sound, can be unwieldy. In general, whilst it is perfectly sound to
+/// reinterpret bytes as different types using this trait, it is likely unwise. For more information
+/// see [f32::from_bits] and [f64::from_bits].
+///
+/// Note: `bool` is restricted to `0` or `1`, and so `bool: !ArrowNativeType`
+///
+/// # Sealed
+///
+/// Due to the above restrictions, this trait is sealed to prevent accidental misuse
+pub trait ArrowNativeType:
+    std::fmt::Debug + Send + Sync + Copy + PartialOrd + Default + private::Sealed + 'static
+{
+    /// Convert native integer type from usize
+    ///
+    /// Returns `None` if [`Self`] is not an integer or conversion would result
+    /// in truncation/overflow
+    fn from_usize(_: usize) -> Option<Self>;
+
+    /// Convert to usize according to the [`as`] operator
+    ///
+    /// [`as`]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#numeric-cast
+    fn as_usize(self) -> usize;
+
+    /// Convert from usize according to the [`as`] operator
+    ///
+    /// [`as`]: https://doc.rust-lang.org/reference/expressions/operator-expr.html#numeric-cast
+    fn usize_as(i: usize) -> Self;
+
+    /// Convert native type to usize.
+    ///
+    /// Returns `None` if [`Self`] is not an integer or conversion would result
+    /// in truncation/overflow
+    fn to_usize(self) -> Option<usize>;
+
+    /// Convert native type to isize.
+    ///
+    /// Returns `None` if [`Self`] is not an integer or conversion would result
+    /// in truncation/overflow
+    fn to_isize(self) -> Option<isize>;
+
+    /// Convert native type from i32.
+    ///
+    /// Returns `None` if [`Self`] is not `i32`
+    #[deprecated(note = "please use `Option::Some` instead")]
+    fn from_i32(_: i32) -> Option<Self> {
+        None
+    }
+
+    /// Convert native type from i64.
+    ///
+    /// Returns `None` if [`Self`] is not `i64`
+    #[deprecated(note = "please use `Option::Some` instead")]
+    fn from_i64(_: i64) -> Option<Self> {
+        None
+    }
+
+    /// Convert native type from i128.
+    ///
+    /// Returns `None` if [`Self`] is not `i128`
+    #[deprecated(note = "please use `Option::Some` instead")]
+    fn from_i128(_: i128) -> Option<Self> {
+        None
+    }
+}
+
+macro_rules! native_integer {
+    ($t: ty $(, $from:ident)*) => {
+        impl private::Sealed for $t {}
+        impl ArrowNativeType for $t {
+            #[inline]
+            fn from_usize(v: usize) -> Option<Self> {
+                v.try_into().ok()
+            }
+
+            #[inline]
+            fn to_usize(self) -> Option<usize> {
+                self.try_into().ok()
+            }
+
+            #[inline]
+            fn to_isize(self) -> Option<isize> {
+                self.try_into().ok()
+            }
+
+            #[inline]
+            fn as_usize(self) -> usize {
+                self as _
+            }
+
+            #[inline]
+            fn usize_as(i: usize) -> Self {
+                i as _
+            }
+
+
+            $(
+                #[inline]
+                fn $from(v: $t) -> Option<Self> {
+                    Some(v)
+                }
+            )*
+        }
+    };
+}
+
+native_integer!(i8);
+native_integer!(i16);
+native_integer!(i32, from_i32);
+native_integer!(i64, from_i64);
+native_integer!(i128, from_i128);
+native_integer!(u8);
+native_integer!(u16);
+native_integer!(u32);
+native_integer!(u64);
+
+macro_rules! native_float {
+    ($t:ty, $s:ident, $as_usize: expr, $i:ident, $usize_as: expr) => {
+        impl private::Sealed for $t {}
+        impl ArrowNativeType for $t {
+            #[inline]
+            fn from_usize(_: usize) -> Option<Self> {
+                None
+            }
+
+            #[inline]
+            fn to_usize(self) -> Option<usize> {
+                None
+            }
+
+            #[inline]
+            fn to_isize(self) -> Option<isize> {
+                None
+            }
+
+            #[inline]
+            fn as_usize($s) -> usize {
+                $as_usize
+            }
+
+            #[inline]
+            fn usize_as($i: usize) -> Self {
+                $usize_as
+            }
+        }
+    };
+}
+
+native_float!(f16, self, self.to_f32() as _, i, f16::from_f32(i as _));
+native_float!(f32, self, self as _, i, i as _);
+native_float!(f64, self, self as _, i, i as _);
+
+impl private::Sealed for i256 {}
+impl ArrowNativeType for i256 {
+    fn from_usize(u: usize) -> Option<Self> {
+        Some(Self::from_parts(u as u128, 0))
+    }
+
+    fn as_usize(self) -> usize {
+        self.to_parts().0 as usize
+    }
+
+    fn usize_as(i: usize) -> Self {
+        Self::from_parts(i as u128, 0)
+    }
+
+    fn to_usize(self) -> Option<usize> {
+        let (low, high) = self.to_parts();
+        if high != 0 {
+            return None;
+        }
+        low.try_into().ok()
+    }
+
+    fn to_isize(self) -> Option<isize> {
+        self.to_i128()?.try_into().ok()
+    }
+}
+
+/// Allows conversion from supported Arrow types to a byte slice.
+pub trait ToByteSlice {
+    /// Converts this instance into a byte slice
+    fn to_byte_slice(&self) -> &[u8];
+}
+
+impl<T: ArrowNativeType> ToByteSlice for [T] {
+    #[inline]
+    fn to_byte_slice(&self) -> &[u8] {
+        let raw_ptr = self.as_ptr() as *const u8;
+        unsafe { std::slice::from_raw_parts(raw_ptr, std::mem::size_of_val(self)) }
+    }
+}
+
+impl<T: ArrowNativeType> ToByteSlice for T {
+    #[inline]
+    fn to_byte_slice(&self) -> &[u8] {
+        let raw_ptr = self as *const T as *const u8;
+        unsafe { std::slice::from_raw_parts(raw_ptr, std::mem::size_of::<T>()) }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_i256() {
+        let a = i256::from_parts(0, 0);
+        assert_eq!(a.as_usize(), 0);
+        assert_eq!(a.to_usize().unwrap(), 0);
+        assert_eq!(a.to_isize().unwrap(), 0);
+
+        let a = i256::from_parts(0, -1);
+        assert_eq!(a.as_usize(), 0);
+        assert!(a.to_usize().is_none());
+        assert!(a.to_usize().is_none());
+
+        let a = i256::from_parts(u128::MAX, -1);
+        assert_eq!(a.as_usize(), usize::MAX);
+        assert!(a.to_usize().is_none());
+        assert_eq!(a.to_isize().unwrap(), -1);
+    }
+}
diff --git a/arrow/src/util/bit_chunk_iterator.rs b/arrow-buffer/src/util/bit_chunk_iterator.rs
similarity index 94%
rename from arrow/src/util/bit_chunk_iterator.rs
rename to arrow-buffer/src/util/bit_chunk_iterator.rs
index f0127ed2267f..9e4fb8268dff 100644
--- a/arrow/src/util/bit_chunk_iterator.rs
+++ b/arrow-buffer/src/util/bit_chunk_iterator.rs
@@ -60,8 +60,7 @@ impl<'a> UnalignedBitChunk<'a> {
 
         // If less than 8 bytes, read into prefix
         if buffer.len() <= 8 {
-            let (suffix_mask, trailing_padding) =
-                compute_suffix_mask(len, offset_padding);
+            let (suffix_mask, trailing_padding) = compute_suffix_mask(len, offset_padding);
             let prefix = read_u64(buffer) & suffix_mask & prefix_mask;
 
             return Self {
@@ -75,8 +74,7 @@ impl<'a> UnalignedBitChunk<'a> {
 
         // If less than 16 bytes, read into prefix and suffix
         if buffer.len() <= 16 {
-            let (suffix_mask, trailing_padding) =
-                compute_suffix_mask(len, offset_padding);
+            let (suffix_mask, trailing_padding) = compute_suffix_mask(len, offset_padding);
             let prefix = read_u64(&buffer[..8]) & prefix_mask;
             let suffix = read_u64(&buffer[8..]) & suffix_mask;
 
@@ -153,11 +151,11 @@ impl<'a> UnalignedBitChunk<'a> {
         self.chunks
     }
 
-    pub(crate) fn iter(&self) -> UnalignedBitChunkIterator<'a> {
+    pub fn iter(&self) -> UnalignedBitChunkIterator<'a> {
         self.prefix
             .into_iter()
             .chain(self.chunks.iter().cloned())
-            .chain(self.suffix.into_iter())
+            .chain(self.suffix)
     }
 
     /// Counts the number of ones
@@ -166,11 +164,8 @@ impl<'a> UnalignedBitChunk<'a> {
     }
 }
 
-pub(crate) type UnalignedBitChunkIterator<'a> = std::iter::Chain<
-    std::iter::Chain<
-        std::option::IntoIter<u64>,
-        std::iter::Cloned<std::slice::Iter<'a, u64>>,
-    >,
+pub type UnalignedBitChunkIterator<'a> = std::iter::Chain<
+    std::iter::Chain<std::option::IntoIter<u64>, std::iter::Cloned<std::slice::Iter<'a, u64>>>,
     std::option::IntoIter<u64>,
 >;
 
@@ -178,7 +173,7 @@ pub(crate) type UnalignedBitChunkIterator<'a> = std::iter::Chain<
 fn read_u64(input: &[u8]) -> u64 {
     let len = input.len().min(8);
     let mut buf = [0_u8; 8];
-    (&mut buf[..len]).copy_from_slice(input);
+    buf[..len].copy_from_slice(input);
     u64::from_le_bytes(buf)
 }
 
@@ -296,6 +291,12 @@ impl<'a> BitChunks<'a> {
             index: 0,
         }
     }
+
+    /// Returns an iterator over chunks of 64 bits, with the remaining bits zero padded to 64-bits
+    #[inline]
+    pub fn iter_padded(&self) -> impl Iterator<Item = u64> + 'a {
+        self.iter().chain(std::iter::once(self.remainder_bits()))
+    }
 }
 
 impl<'a> IntoIterator for BitChunks<'a> {
@@ -332,9 +333,8 @@ impl Iterator for BitChunkIterator<'_> {
         } else {
             // the constructor ensures that bit_offset is in 0..8
             // that means we need to read at most one additional byte to fill in the high bits
-            let next = unsafe {
-                std::ptr::read_unaligned(raw_data.add(index + 1) as *const u8) as u64
-            };
+            let next =
+                unsafe { std::ptr::read_unaligned(raw_data.add(index + 1) as *const u8) as u64 };
 
             (current >> bit_offset) | (next << (64 - bit_offset))
         };
@@ -381,8 +381,8 @@ mod tests {
     #[test]
     fn test_iter_unaligned() {
         let input: &[u8] = &[
-            0b00000000, 0b00000001, 0b00000010, 0b00000100, 0b00001000, 0b00010000,
-            0b00100000, 0b01000000, 0b11111111,
+            0b00000000, 0b00000001, 0b00000010, 0b00000100, 0b00001000, 0b00010000, 0b00100000,
+            0b01000000, 0b11111111,
         ];
         let buffer: Buffer = Buffer::from(input);
 
@@ -402,8 +402,8 @@ mod tests {
     #[test]
     fn test_iter_unaligned_remainder_1_byte() {
         let input: &[u8] = &[
-            0b00000000, 0b00000001, 0b00000010, 0b00000100, 0b00001000, 0b00010000,
-            0b00100000, 0b01000000, 0b11111111,
+            0b00000000, 0b00000001, 0b00000010, 0b00000100, 0b00001000, 0b00010000, 0b00100000,
+            0b01000000, 0b11111111,
         ];
         let buffer: Buffer = Buffer::from(input);
 
@@ -436,8 +436,8 @@ mod tests {
     #[test]
     fn test_iter_unaligned_remainder_bits_large() {
         let input: &[u8] = &[
-            0b11111111, 0b00000000, 0b11111111, 0b00000000, 0b11111111, 0b00000000,
-            0b11111111, 0b00000000, 0b11111111,
+            0b11111111, 0b00000000, 0b11111111, 0b00000000, 0b11111111, 0b00000000, 0b11111111,
+            0b00000000, 0b11111111,
         ];
         let buffer: Buffer = Buffer::from(input);
 
@@ -631,11 +631,8 @@ mod tests {
             let max_truncate = 128.min(mask_len - offset);
             let truncate = rng.gen::<usize>().checked_rem(max_truncate).unwrap_or(0);
 
-            let unaligned = UnalignedBitChunk::new(
-                buffer.as_slice(),
-                offset,
-                mask_len - offset - truncate,
-            );
+            let unaligned =
+                UnalignedBitChunk::new(buffer.as_slice(), offset, mask_len - offset - truncate);
 
             let bool_slice = &bools[offset..mask_len - truncate];
 
diff --git a/arrow/src/util/bit_iterator.rs b/arrow-buffer/src/util/bit_iterator.rs
similarity index 53%
rename from arrow/src/util/bit_iterator.rs
rename to arrow-buffer/src/util/bit_iterator.rs
index bba9dac60a4b..df40a8fbaccb 100644
--- a/arrow/src/util/bit_iterator.rs
+++ b/arrow-buffer/src/util/bit_iterator.rs
@@ -15,7 +15,73 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::util::bit_chunk_iterator::{UnalignedBitChunk, UnalignedBitChunkIterator};
+//! Types for iterating over packed bitmasks
+
+use crate::bit_chunk_iterator::{UnalignedBitChunk, UnalignedBitChunkIterator};
+use crate::bit_util::{ceil, get_bit_raw};
+
+/// Iterator over the bits within a packed bitmask
+///
+/// To efficiently iterate over just the set bits see [`BitIndexIterator`] and [`BitSliceIterator`]
+pub struct BitIterator<'a> {
+    buffer: &'a [u8],
+    current_offset: usize,
+    end_offset: usize,
+}
+
+impl<'a> BitIterator<'a> {
+    /// Create a new [`BitIterator`] from the provided `buffer`,
+    /// and `offset` and `len` in bits
+    ///
+    /// # Panic
+    ///
+    /// Panics if `buffer` is too short for the provided offset and length
+    pub fn new(buffer: &'a [u8], offset: usize, len: usize) -> Self {
+        let end_offset = offset.checked_add(len).unwrap();
+        let required_len = ceil(end_offset, 8);
+        assert!(
+            buffer.len() >= required_len,
+            "BitIterator buffer too small, expected {required_len} got {}",
+            buffer.len()
+        );
+
+        Self {
+            buffer,
+            current_offset: offset,
+            end_offset,
+        }
+    }
+}
+
+impl<'a> Iterator for BitIterator<'a> {
+    type Item = bool;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.current_offset == self.end_offset {
+            return None;
+        }
+        // Safety:
+        // offsets in bounds
+        let v = unsafe { get_bit_raw(self.buffer.as_ptr(), self.current_offset) };
+        self.current_offset += 1;
+        Some(v)
+    }
+}
+
+impl<'a> ExactSizeIterator for BitIterator<'a> {}
+
+impl<'a> DoubleEndedIterator for BitIterator<'a> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.current_offset == self.end_offset {
+            return None;
+        }
+        self.end_offset -= 1;
+        // Safety:
+        // offsets in bounds
+        let v = unsafe { get_bit_raw(self.buffer.as_ptr(), self.end_offset) };
+        Some(v)
+    }
+}
 
 /// Iterator of contiguous ranges of set bits within a provided packed bitmask
 ///
@@ -31,7 +97,7 @@ pub struct BitSliceIterator<'a> {
 }
 
 impl<'a> BitSliceIterator<'a> {
-    /// Create a new [`BitSliceIterator`] from the provide `buffer`,
+    /// Create a new [`BitSliceIterator`] from the provided `buffer`,
     /// and `offset` and `len` in bits
     pub fn new(buffer: &'a [u8], offset: usize, len: usize) -> Self {
         let chunk = UnalignedBitChunk::new(buffer, offset, len);
@@ -157,4 +223,72 @@ impl<'a> Iterator for BitIndexIterator<'a> {
     }
 }
 
-// Note: tests located in filter module
+/// Calls the provided closure for each index in the provided null mask that is set,
+/// using an adaptive strategy based on the null count
+///
+/// Ideally this would be encapsulated in an [`Iterator`] that would determine the optimal
+/// strategy up front, and then yield indexes based on this.
+///
+/// Unfortunately, external iteration based on the resulting [`Iterator`] would match the strategy
+/// variant on each call to [`Iterator::next`], and LLVM generally cannot eliminate this.
+///
+/// One solution to this might be internal iteration, e.g. [`Iterator::try_fold`], however,
+/// it is currently [not possible] to override this for custom iterators in stable Rust.
+///
+/// As such this is the next best option
+///
+/// [not possible]: https://github.com/rust-lang/rust/issues/69595
+#[inline]
+pub fn try_for_each_valid_idx<E, F: FnMut(usize) -> Result<(), E>>(
+    len: usize,
+    offset: usize,
+    null_count: usize,
+    nulls: Option<&[u8]>,
+    f: F,
+) -> Result<(), E> {
+    let valid_count = len - null_count;
+
+    if valid_count == len {
+        (0..len).try_for_each(f)
+    } else if null_count != len {
+        BitIndexIterator::new(nulls.unwrap(), offset, len).try_for_each(f)
+    } else {
+        Ok(())
+    }
+}
+
+// Note: further tests located in arrow_select::filter module
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_bit_iterator() {
+        let mask = &[0b00010010, 0b00100011, 0b00000101, 0b00010001, 0b10010011];
+        let actual: Vec<_> = BitIterator::new(mask, 0, 5).collect();
+        assert_eq!(actual, &[false, true, false, false, true]);
+
+        let actual: Vec<_> = BitIterator::new(mask, 4, 5).collect();
+        assert_eq!(actual, &[true, false, false, false, true]);
+
+        let actual: Vec<_> = BitIterator::new(mask, 12, 14).collect();
+        assert_eq!(
+            actual,
+            &[
+                false, true, false, false, true, false, true, false, false, false, false, false,
+                true, false
+            ]
+        );
+
+        assert_eq!(BitIterator::new(mask, 0, 0).count(), 0);
+        assert_eq!(BitIterator::new(mask, 40, 0).count(), 0);
+    }
+
+    #[test]
+    #[should_panic(expected = "BitIterator buffer too small, expected 3 got 2")]
+    fn test_bit_iterator_bounds() {
+        let mask = &[223, 23];
+        BitIterator::new(mask, 17, 0);
+    }
+}
diff --git a/arrow/src/util/bit_mask.rs b/arrow-buffer/src/util/bit_mask.rs
similarity index 85%
rename from arrow/src/util/bit_mask.rs
rename to arrow-buffer/src/util/bit_mask.rs
index da542a2bb1f9..8f81cb7d0469 100644
--- a/arrow/src/util/bit_mask.rs
+++ b/arrow-buffer/src/util/bit_mask.rs
@@ -17,8 +17,8 @@
 
 //! Utils for working with packed bit masks
 
-use crate::util::bit_chunk_iterator::BitChunks;
-use crate::util::bit_util::{ceil, get_bit, set_bit};
+use crate::bit_chunk_iterator::BitChunks;
+use crate::bit_util::{ceil, get_bit, set_bit};
 
 /// Sets all bits on `write_data` in the range `[offset_write..offset_write+len]` to be equal to the
 /// bits in `data` in the range `[offset_read..offset_read+len]`
@@ -42,8 +42,7 @@ pub fn set_bits(
     let chunks = BitChunks::new(data, offset_read + bits_to_align, len - bits_to_align);
     chunks.iter().for_each(|chunk| {
         null_count += chunk.count_zeros();
-        write_data[write_byte_index..write_byte_index + 8]
-            .copy_from_slice(&chunk.to_le_bytes());
+        write_data[write_byte_index..write_byte_index + 8].copy_from_slice(&chunk.to_le_bytes());
         write_byte_index += 8;
     });
 
@@ -70,8 +69,8 @@ mod tests {
     fn test_set_bits_aligned() {
         let mut destination: Vec<u8> = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
         let source: &[u8] = &[
-            0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011,
-            0b11100111, 0b10100101,
+            0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011, 0b11100111,
+            0b10100101,
         ];
 
         let destination_offset = 8;
@@ -80,8 +79,8 @@ mod tests {
         let len = 64;
 
         let expected_data: &[u8] = &[
-            0, 0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011,
-            0b11100111, 0b10100101, 0,
+            0, 0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011, 0b11100111,
+            0b10100101, 0,
         ];
         let expected_null_count = 24;
         let result = set_bits(
@@ -100,8 +99,8 @@ mod tests {
     fn test_set_bits_unaligned_destination_start() {
         let mut destination: Vec<u8> = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
         let source: &[u8] = &[
-            0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011,
-            0b11100111, 0b10100101,
+            0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011, 0b11100111,
+            0b10100101,
         ];
 
         let destination_offset = 3;
@@ -110,8 +109,8 @@ mod tests {
         let len = 64;
 
         let expected_data: &[u8] = &[
-            0b00111000, 0b00101111, 0b11001101, 0b11011100, 0b01011110, 0b00011111,
-            0b00111110, 0b00101111, 0b00000101, 0b00000000,
+            0b00111000, 0b00101111, 0b11001101, 0b11011100, 0b01011110, 0b00011111, 0b00111110,
+            0b00101111, 0b00000101, 0b00000000,
         ];
         let expected_null_count = 24;
         let result = set_bits(
@@ -130,8 +129,8 @@ mod tests {
     fn test_set_bits_unaligned_destination_end() {
         let mut destination: Vec<u8> = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
         let source: &[u8] = &[
-            0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011,
-            0b11100111, 0b10100101,
+            0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011, 0b11100111,
+            0b10100101,
         ];
 
         let destination_offset = 8;
@@ -140,8 +139,8 @@ mod tests {
         let len = 62;
 
         let expected_data: &[u8] = &[
-            0, 0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011,
-            0b11100111, 0b00100101, 0,
+            0, 0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011, 0b11100111,
+            0b00100101, 0,
         ];
         let expected_null_count = 23;
         let result = set_bits(
@@ -160,9 +159,9 @@ mod tests {
     fn test_set_bits_unaligned() {
         let mut destination: Vec<u8> = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
         let source: &[u8] = &[
-            0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011,
-            0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011,
-            0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011,
+            0b11100111, 0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011, 0b11100111,
+            0b10100101, 0b10011001, 0b11011011, 0b11101011, 0b11000011, 0b11100111, 0b10100101,
+            0b10011001, 0b11011011, 0b11101011, 0b11000011,
         ];
 
         let destination_offset = 3;
@@ -171,9 +170,8 @@ mod tests {
         let len = 95;
 
         let expected_data: &[u8] = &[
-            0b01111000, 0b01101001, 0b11100110, 0b11110110, 0b11111010, 0b11110000,
-            0b01111001, 0b01101001, 0b11100110, 0b11110110, 0b11111010, 0b11110000,
-            0b00000001,
+            0b01111000, 0b01101001, 0b11100110, 0b11110110, 0b11111010, 0b11110000, 0b01111001,
+            0b01101001, 0b11100110, 0b11110110, 0b11111010, 0b11110000, 0b00000001,
         ];
         let expected_null_count = 35;
         let result = set_bits(
diff --git a/arrow/src/util/bit_util.rs b/arrow-buffer/src/util/bit_util.rs
similarity index 82%
rename from arrow/src/util/bit_util.rs
rename to arrow-buffer/src/util/bit_util.rs
index 5752c5df972e..f4aaf571b5d6 100644
--- a/arrow/src/util/bit_util.rs
+++ b/arrow-buffer/src/util/bit_util.rs
@@ -17,10 +17,6 @@
 
 //! Utils for working with bits
 
-use num::Integer;
-#[cfg(feature = "simd")]
-use packed_simd::u8x64;
-
 const BIT_MASK: [u8; 8] = [1, 2, 4, 8, 16, 32, 64, 128];
 const UNSET_BIT_MASK: [u8; 8] = [
     255 - 1,
@@ -43,7 +39,9 @@ pub fn round_upto_multiple_of_64(num: usize) -> usize {
 /// be a power of 2.
 pub fn round_upto_power_of_2(num: usize, factor: usize) -> usize {
     debug_assert!(factor > 0 && (factor & (factor - 1)) == 0);
-    (num + (factor - 1)) & !(factor - 1)
+    num.checked_add(factor - 1)
+        .expect("failed to round to next highest power of 2")
+        & !(factor - 1)
 }
 
 /// Returns whether bit at position `i` in `data` is set or not
@@ -102,34 +100,16 @@ pub unsafe fn unset_bit_raw(data: *mut u8, i: usize) {
 pub fn ceil(value: usize, divisor: usize) -> usize {
     // Rewrite as `value.div_ceil(&divisor)` after
     // https://github.com/rust-lang/rust/issues/88581 is merged.
-    Integer::div_ceil(&value, &divisor)
-}
-
-/// Performs SIMD bitwise binary operations.
-///
-/// # Safety
-///
-/// Note that each slice should be 64 bytes and it is the callers responsibility to ensure
-/// that this is the case.  If passed slices larger than 64 bytes the operation will only
-/// be performed on the first 64 bytes.  Slices less than 64 bytes will panic.
-#[cfg(feature = "simd")]
-pub unsafe fn bitwise_bin_op_simd<F>(left: &[u8], right: &[u8], result: &mut [u8], op: F)
-where
-    F: Fn(u8x64, u8x64) -> u8x64,
-{
-    let left_simd = u8x64::from_slice_unaligned_unchecked(left);
-    let right_simd = u8x64::from_slice_unaligned_unchecked(right);
-    let simd_result = op(left_simd, right_simd);
-    simd_result.write_to_slice_unaligned_unchecked(result);
+    value / divisor + (0 != value % divisor) as usize
 }
 
-#[cfg(all(test, feature = "test_utils"))]
+#[cfg(test)]
 mod tests {
     use std::collections::HashSet;
 
     use super::*;
-    use crate::util::test_util::seedable_rng;
-    use rand::Rng;
+    use rand::rngs::StdRng;
+    use rand::{Rng, SeedableRng};
 
     #[test]
     fn test_round_upto_multiple_of_64() {
@@ -141,6 +121,12 @@ mod tests {
         assert_eq!(192, round_upto_multiple_of_64(129));
     }
 
+    #[test]
+    #[should_panic(expected = "failed to round to next highest power of 2")]
+    fn test_round_upto_panic() {
+        let _ = round_upto_power_of_2(usize::MAX, 2);
+    }
+
     #[test]
     fn test_get_bit() {
         // 00001101
@@ -168,10 +154,14 @@ mod tests {
         assert!(!get_bit(&[0b01001001, 0b01010010], 15));
     }
 
+    pub fn seedable_rng() -> StdRng {
+        StdRng::seed_from_u64(42)
+    }
+
     #[test]
     fn test_get_bit_raw() {
         const NUM_BYTE: usize = 10;
-        let mut buf = vec![0; NUM_BYTE];
+        let mut buf = [0; NUM_BYTE];
         let mut expected = vec![];
         let mut rng = seedable_rng();
         for i in 0..8 * NUM_BYTE {
@@ -279,7 +269,6 @@ mod tests {
     }
 
     #[test]
-    #[cfg(all(any(target_arch = "x86", target_arch = "x86_64")))]
     fn test_ceil() {
         assert_eq!(ceil(0, 1), 0);
         assert_eq!(ceil(1, 1), 1);
@@ -293,28 +282,4 @@ mod tests {
         assert_eq!(ceil(10, 10000000000), 1);
         assert_eq!(ceil(10000000000, 1000000000), 10);
     }
-
-    #[test]
-    #[cfg(feature = "simd")]
-    fn test_bitwise_and_simd() {
-        let buf1 = [0b00110011u8; 64];
-        let buf2 = [0b11110000u8; 64];
-        let mut buf3 = [0b00000000; 64];
-        unsafe { bitwise_bin_op_simd(&buf1, &buf2, &mut buf3, |a, b| a & b) };
-        for i in buf3.iter() {
-            assert_eq!(&0b00110000u8, i);
-        }
-    }
-
-    #[test]
-    #[cfg(feature = "simd")]
-    fn test_bitwise_or_simd() {
-        let buf1 = [0b00110011u8; 64];
-        let buf2 = [0b11110000u8; 64];
-        let mut buf3 = [0b00000000; 64];
-        unsafe { bitwise_bin_op_simd(&buf1, &buf2, &mut buf3, |a, b| a | b) };
-        for i in buf3.iter() {
-            assert_eq!(&0b11110011u8, i);
-        }
-    }
 }
diff --git a/arrow-buffer/src/util/mod.rs b/arrow-buffer/src/util/mod.rs
new file mode 100644
index 000000000000..9023fe4a035d
--- /dev/null
+++ b/arrow-buffer/src/util/mod.rs
@@ -0,0 +1,21 @@
+// 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.
+
+pub mod bit_chunk_iterator;
+pub mod bit_iterator;
+pub mod bit_mask;
+pub mod bit_util;
diff --git a/arrow-cast/Cargo.toml b/arrow-cast/Cargo.toml
new file mode 100644
index 000000000000..2d8a57aba5f5
--- /dev/null
+++ b/arrow-cast/Cargo.toml
@@ -0,0 +1,78 @@
+# 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]
+name = "arrow-cast"
+version = { workspace = true }
+description = "Cast kernel and utilities for Apache Arrow"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_cast"
+path = "src/lib.rs"
+bench = false
+
+[package.metadata.docs.rs]
+features = ["prettyprint"]
+
+[features]
+prettyprint = ["comfy-table"]
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-data = { workspace = true }
+arrow-schema = { workspace = true }
+arrow-select = { workspace = true }
+chrono = { workspace = true }
+half = { version = "2.1", default-features = false }
+num = { version = "0.4", default-features = false, features = ["std"] }
+lexical-core = { version = "^0.8", default-features = false, features = ["write-integers", "write-floats", "parse-integers", "parse-floats"] }
+atoi = "2.0.0"
+comfy-table = { version = "7.0", optional = true, default-features = false }
+base64 = "0.21"
+ryu = "1.0.16"
+
+[dev-dependencies]
+criterion = { version = "0.5", default-features = false }
+half = { version = "2.1", default-features = false }
+rand = "0.8"
+
+[build-dependencies]
+
+[[bench]]
+name = "parse_timestamp"
+harness = false
+
+[[bench]]
+name = "parse_time"
+harness = false
+
+[[bench]]
+name = "parse_date"
+harness = false
+
+[[bench]]
+name = "parse_decimal"
+harness = false
diff --git a/arrow-cast/benches/parse_date.rs b/arrow-cast/benches/parse_date.rs
new file mode 100644
index 000000000000..e05d38d2f853
--- /dev/null
+++ b/arrow-cast/benches/parse_date.rs
@@ -0,0 +1,34 @@
+// 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.
+
+use arrow_array::types::Date32Type;
+use arrow_cast::parse::Parser;
+use criterion::*;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let timestamps = ["2020-09-08", "2020-9-8", "2020-09-8", "2020-9-08"];
+
+    for timestamp in timestamps {
+        let t = black_box(timestamp);
+        c.bench_function(t, |b| {
+            b.iter(|| Date32Type::parse(t).unwrap());
+        });
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow-cast/benches/parse_decimal.rs b/arrow-cast/benches/parse_decimal.rs
new file mode 100644
index 000000000000..5682859dd25a
--- /dev/null
+++ b/arrow-cast/benches/parse_decimal.rs
@@ -0,0 +1,56 @@
+// 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.
+
+use arrow_array::types::Decimal256Type;
+use arrow_cast::parse::parse_decimal;
+use criterion::*;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let decimals = [
+        "123.123",
+        "123.1234",
+        "123.1",
+        "123",
+        "-123.123",
+        "-123.1234",
+        "-123.1",
+        "-123",
+        "0.0000123",
+        "12.",
+        "-12.",
+        "00.1",
+        "-00.1",
+        "12345678912345678.1234",
+        "-12345678912345678.1234",
+        "99999999999999999.999",
+        "-99999999999999999.999",
+        ".123",
+        "-.123",
+        "123.",
+        "-123.",
+    ];
+
+    for decimal in decimals {
+        let d = black_box(decimal);
+        c.bench_function(d, |b| {
+            b.iter(|| parse_decimal::<Decimal256Type>(d, 20, 3).unwrap());
+        });
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow-cast/benches/parse_time.rs b/arrow-cast/benches/parse_time.rs
new file mode 100644
index 000000000000..d28b9c7c613d
--- /dev/null
+++ b/arrow-cast/benches/parse_time.rs
@@ -0,0 +1,42 @@
+// 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.
+
+use arrow_cast::parse::string_to_time_nanoseconds;
+use criterion::*;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let timestamps = [
+        "9:50",
+        "09:50",
+        "09:50 PM",
+        "9:50:12 AM",
+        "09:50:12 PM",
+        "09:50:12.123456789",
+        "9:50:12.123456789",
+        "09:50:12.123456789 PM",
+    ];
+
+    for timestamp in timestamps {
+        let t = black_box(timestamp);
+        c.bench_function(t, |b| {
+            b.iter(|| string_to_time_nanoseconds(t).unwrap());
+        });
+    }
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow/src/util/serialization.rs b/arrow-cast/benches/parse_timestamp.rs
similarity index 51%
rename from arrow/src/util/serialization.rs
rename to arrow-cast/benches/parse_timestamp.rs
index 14d67ca117c4..d3ab41863e70 100644
--- a/arrow/src/util/serialization.rs
+++ b/arrow-cast/benches/parse_timestamp.rs
@@ -15,19 +15,30 @@
 // specific language governing permissions and limitations
 // under the License.
 
-/// Converts numeric type to a `String`
-pub fn lexical_to_string<N: lexical_core::ToLexical>(n: N) -> String {
-    let mut buf = Vec::<u8>::with_capacity(N::FORMATTED_SIZE_DECIMAL);
-    unsafe {
-        // JUSTIFICATION
-        //  Benefit
-        //      Allows using the faster serializer lexical core and convert to string
-        //  Soundness
-        //      Length of buf is set as written length afterwards. lexical_core
-        //      creates a valid string, so doesn't need to be checked.
-        let slice = std::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.capacity());
-        let len = lexical_core::write(n, slice).len();
-        buf.set_len(len);
-        String::from_utf8_unchecked(buf)
+use arrow_cast::parse::string_to_timestamp_nanos;
+use criterion::*;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let timestamps = [
+        "2020-09-08",
+        "2020-09-08T13:42:29",
+        "2020-09-08T13:42:29.190",
+        "2020-09-08T13:42:29.190855",
+        "2020-09-08T13:42:29.190855999",
+        "2020-09-08T13:42:29+00:00",
+        "2020-09-08T13:42:29.190+00:00",
+        "2020-09-08T13:42:29.190855+00:00",
+        "2020-09-08T13:42:29.190855999-05:00",
+        "2020-09-08T13:42:29.190855Z",
+    ];
+
+    for timestamp in timestamps {
+        let t = black_box(timestamp);
+        c.bench_function(t, |b| {
+            b.iter(|| string_to_timestamp_nanos(t).unwrap());
+        });
     }
 }
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow-cast/src/base64.rs b/arrow-cast/src/base64.rs
new file mode 100644
index 000000000000..e109c8112480
--- /dev/null
+++ b/arrow-cast/src/base64.rs
@@ -0,0 +1,117 @@
+// 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.
+
+//! Functions for Base64 encoding/decoding
+
+use arrow_array::{Array, GenericBinaryArray, GenericStringArray, OffsetSizeTrait};
+use arrow_buffer::OffsetBuffer;
+use arrow_schema::ArrowError;
+use base64::encoded_len;
+use base64::engine::Config;
+
+pub use base64::prelude::*;
+
+/// Bas64 encode each element of `array` with the provided `engine`
+pub fn b64_encode<E: Engine, O: OffsetSizeTrait>(
+    engine: &E,
+    array: &GenericBinaryArray<O>,
+) -> GenericStringArray<O> {
+    let lengths = array.offsets().windows(2).map(|w| {
+        let len = w[1].as_usize() - w[0].as_usize();
+        encoded_len(len, engine.config().encode_padding()).unwrap()
+    });
+    let offsets = OffsetBuffer::<O>::from_lengths(lengths);
+    let buffer_len = offsets.last().unwrap().as_usize();
+    let mut buffer = vec![0_u8; buffer_len];
+    let mut offset = 0;
+
+    for i in 0..array.len() {
+        let len = engine
+            .encode_slice(array.value(i), &mut buffer[offset..])
+            .unwrap();
+        offset += len;
+    }
+    assert_eq!(offset, buffer_len);
+
+    // Safety: Base64 is valid UTF-8
+    unsafe { GenericStringArray::new_unchecked(offsets, buffer.into(), array.nulls().cloned()) }
+}
+
+/// Base64 decode each element of `array` with the provided `engine`
+pub fn b64_decode<E: Engine, O: OffsetSizeTrait>(
+    engine: &E,
+    array: &GenericBinaryArray<O>,
+) -> Result<GenericBinaryArray<O>, ArrowError> {
+    let estimated_len = array.values().len(); // This is an overestimate
+    let mut buffer = vec![0; estimated_len];
+
+    let mut offsets = Vec::with_capacity(array.len() + 1);
+    offsets.push(O::usize_as(0));
+    let mut offset = 0;
+
+    for v in array.iter() {
+        if let Some(v) = v {
+            let len = engine.decode_slice(v, &mut buffer[offset..]).unwrap();
+            // This cannot overflow as `len` is less than `v.len()` and `a` is valid
+            offset += len;
+        }
+        offsets.push(O::usize_as(offset));
+    }
+
+    // Safety: offsets monotonically increasing by construction
+    let offsets = unsafe { OffsetBuffer::new_unchecked(offsets.into()) };
+
+    Ok(GenericBinaryArray::new(
+        offsets,
+        buffer.into(),
+        array.nulls().cloned(),
+    ))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::BinaryArray;
+    use base64::prelude::{BASE64_STANDARD, BASE64_STANDARD_NO_PAD};
+    use rand::{thread_rng, Rng};
+
+    fn test_engine<E: Engine>(e: &E, a: &BinaryArray) {
+        let encoded = b64_encode(e, a);
+        encoded.to_data().validate_full().unwrap();
+
+        let to_decode = encoded.into();
+        let decoded = b64_decode(e, &to_decode).unwrap();
+        decoded.to_data().validate_full().unwrap();
+
+        assert_eq!(&decoded, a);
+    }
+
+    #[test]
+    fn test_b64() {
+        let mut rng = thread_rng();
+        let len = rng.gen_range(1024..1050);
+        let data: BinaryArray = (0..len)
+            .map(|_| {
+                let len = rng.gen_range(0..16);
+                Some((0..len).map(|_| rng.gen()).collect::<Vec<u8>>())
+            })
+            .collect();
+
+        test_engine(&BASE64_STANDARD, &data);
+        test_engine(&BASE64_STANDARD_NO_PAD, &data);
+    }
+}
diff --git a/arrow-cast/src/cast.rs b/arrow-cast/src/cast.rs
new file mode 100644
index 000000000000..7868946532c4
--- /dev/null
+++ b/arrow-cast/src/cast.rs
@@ -0,0 +1,9742 @@
+// 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.
+
+//! Defines cast kernels for `ArrayRef`, to convert `Array`s between
+//! supported datatypes.
+//!
+//! Example:
+//!
+//! ```
+//! use arrow_array::*;
+//! use arrow_cast::cast;
+//! use arrow_schema::DataType;
+//! use std::sync::Arc;
+//! use arrow_array::types::Float64Type;
+//! use arrow_array::cast::AsArray;
+//!
+//! let a = Int32Array::from(vec![5, 6, 7]);
+//! let array = Arc::new(a) as ArrayRef;
+//! let b = cast(&array, &DataType::Float64).unwrap();
+//! let c = b.as_primitive::<Float64Type>();
+//! assert_eq!(5.0, c.value(0));
+//! assert_eq!(6.0, c.value(1));
+//! assert_eq!(7.0, c.value(2));
+//! ```
+
+use chrono::{NaiveTime, Offset, TimeZone, Utc};
+use std::cmp::Ordering;
+use std::sync::Arc;
+
+use crate::display::{ArrayFormatter, FormatOptions};
+use crate::parse::{
+    parse_interval_day_time, parse_interval_month_day_nano, parse_interval_year_month,
+    string_to_datetime, Parser,
+};
+use arrow_array::{builder::*, cast::*, temporal_conversions::*, timezone::Tz, types::*, *};
+use arrow_buffer::{i256, ArrowNativeType, OffsetBuffer};
+use arrow_data::transform::MutableArrayData;
+use arrow_data::ArrayData;
+use arrow_schema::*;
+use arrow_select::take::take;
+use num::cast::AsPrimitive;
+use num::{NumCast, ToPrimitive};
+
+/// CastOptions provides a way to override the default cast behaviors
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct CastOptions<'a> {
+    /// how to handle cast failures, either return NULL (safe=true) or return ERR (safe=false)
+    pub safe: bool,
+    /// Formatting options when casting from temporal types to string
+    pub format_options: FormatOptions<'a>,
+}
+
+impl<'a> Default for CastOptions<'a> {
+    fn default() -> Self {
+        Self {
+            safe: true,
+            format_options: FormatOptions::default(),
+        }
+    }
+}
+
+/// Return true if a value of type `from_type` can be cast into a value of `to_type`.
+///
+/// See [`cast_with_options`] for more information
+pub fn can_cast_types(from_type: &DataType, to_type: &DataType) -> bool {
+    use self::DataType::*;
+    use self::IntervalUnit::*;
+    use self::TimeUnit::*;
+    if from_type == to_type {
+        return true;
+    }
+
+    match (from_type, to_type) {
+        (
+            Null,
+            Boolean
+            | Int8
+            | UInt8
+            | Int16
+            | UInt16
+            | Int32
+            | UInt32
+            | Float32
+            | Date32
+            | Time32(_)
+            | Int64
+            | UInt64
+            | Float64
+            | Date64
+            | Timestamp(_, _)
+            | Time64(_)
+            | Duration(_)
+            | Interval(_)
+            | FixedSizeBinary(_)
+            | Binary
+            | Utf8
+            | LargeBinary
+            | LargeUtf8
+            | List(_)
+            | LargeList(_)
+            | FixedSizeList(_, _)
+            | Struct(_)
+            | Map(_, _)
+            | Dictionary(_, _),
+        ) => true,
+        // Dictionary/List conditions should be put in front of others
+        (Dictionary(_, from_value_type), Dictionary(_, to_value_type)) => {
+            can_cast_types(from_value_type, to_value_type)
+        }
+        (Dictionary(_, value_type), _) => can_cast_types(value_type, to_type),
+        (_, Dictionary(_, value_type)) => can_cast_types(from_type, value_type),
+        (List(list_from) | LargeList(list_from), List(list_to) | LargeList(list_to)) => {
+            can_cast_types(list_from.data_type(), list_to.data_type())
+        }
+        (List(list_from) | LargeList(list_from), Utf8 | LargeUtf8) => {
+            can_cast_types(list_from.data_type(), to_type)
+        }
+        (List(list_from) | LargeList(list_from), FixedSizeList(list_to, _)) => {
+            can_cast_types(list_from.data_type(), list_to.data_type())
+        }
+        (List(_), _) => false,
+        (FixedSizeList(list_from,_), List(list_to)) |
+        (FixedSizeList(list_from,_), LargeList(list_to)) => {
+            can_cast_types(list_from.data_type(), list_to.data_type())
+        }
+        (FixedSizeList(inner, size), FixedSizeList(inner_to, size_to)) if size == size_to => {
+            can_cast_types(inner.data_type(), inner_to.data_type())
+        }
+        (_, List(list_to)) => can_cast_types(from_type, list_to.data_type()),
+        (_, LargeList(list_to)) => can_cast_types(from_type, list_to.data_type()),
+        (_, FixedSizeList(list_to,size)) if *size == 1 => {
+            can_cast_types(from_type, list_to.data_type())},
+        // cast one decimal type to another decimal type
+        (Decimal128(_, _), Decimal128(_, _)) => true,
+        (Decimal256(_, _), Decimal256(_, _)) => true,
+        (Decimal128(_, _), Decimal256(_, _)) => true,
+        (Decimal256(_, _), Decimal128(_, _)) => true,
+        // unsigned integer to decimal
+        (UInt8 | UInt16 | UInt32 | UInt64, Decimal128(_, _)) |
+        (UInt8 | UInt16 | UInt32 | UInt64, Decimal256(_, _)) |
+        // signed numeric to decimal
+        (Null | Int8 | Int16 | Int32 | Int64 | Float32 | Float64, Decimal128(_, _)) |
+        (Null | Int8 | Int16 | Int32 | Int64 | Float32 | Float64, Decimal256(_, _)) |
+        // decimal to unsigned numeric
+        (Decimal128(_, _) | Decimal256(_, _), UInt8 | UInt16 | UInt32 | UInt64) |
+        // decimal to signed numeric
+        (Decimal128(_, _) | Decimal256(_, _), Null | Int8 | Int16 | Int32 | Int64 | Float32 | Float64) => true,
+        // decimal to Utf8
+        (Decimal128(_, _) | Decimal256(_, _), Utf8 | LargeUtf8) => true,
+        // Utf8 to decimal
+        (Utf8 | LargeUtf8, Decimal128(_, _) | Decimal256(_, _)) => true,
+        (Struct(from_fields), Struct(to_fields)) => {
+            from_fields.len() == to_fields.len() &&
+                from_fields.iter().zip(to_fields.iter()).all(|(f1, f2)| {
+                    // Assume that nullability between two structs are compatible, if not,
+                    // cast kernel will return error.
+                    can_cast_types(f1.data_type(), f2.data_type())
+                })
+		}
+        (Struct(_), _) => false,
+        (_, Struct(_)) => false,
+        (_, Boolean) => {
+            DataType::is_integer(from_type) ||
+                DataType::is_floating(from_type)
+                || from_type == &Utf8
+                || from_type == &LargeUtf8
+        }
+        (Boolean, _) => {
+            DataType::is_integer(to_type) || DataType::is_floating(to_type) || to_type == &Utf8 || to_type == &LargeUtf8
+        }
+
+        (Binary, LargeBinary | Utf8 | LargeUtf8 | FixedSizeBinary(_)) => true,
+        (LargeBinary, Binary | Utf8 | LargeUtf8 | FixedSizeBinary(_)) => true,
+        (FixedSizeBinary(_), Binary | LargeBinary) => true,
+        (
+            Utf8 | LargeUtf8,
+            Binary
+            | LargeBinary
+            | Utf8
+            | LargeUtf8
+            | Date32
+            | Date64
+            | Time32(Second)
+            | Time32(Millisecond)
+            | Time64(Microsecond)
+            | Time64(Nanosecond)
+            | Timestamp(Second, _)
+            | Timestamp(Millisecond, _)
+            | Timestamp(Microsecond, _)
+            | Timestamp(Nanosecond, _)
+            | Interval(_),
+        ) => true,
+        (Utf8 | LargeUtf8, _) => to_type.is_numeric() && to_type != &Float16,
+        (_, Utf8 | LargeUtf8) => from_type.is_primitive(),
+
+        (_, Binary | LargeBinary) => from_type.is_integer(),
+
+        // start numeric casts
+        (
+            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float16 | Float32 | Float64,
+            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float16 | Float32 | Float64,
+        ) => true,
+        // end numeric casts
+
+        // temporal casts
+        (Int32, Date32 | Date64 | Time32(_)) => true,
+        (Date32, Int32 | Int64) => true,
+        (Time32(_), Int32) => true,
+        (Int64, Date64 | Date32 | Time64(_)) => true,
+        (Date64, Int64 | Int32) => true,
+        (Time64(_), Int64) => true,
+        (Date32 | Date64, Date32 | Date64) => true,
+        // time casts
+        (Time32(_), Time32(_)) => true,
+        (Time32(_), Time64(_)) => true,
+        (Time64(_), Time64(_)) => true,
+        (Time64(_), Time32(to_unit)) => {
+            matches!(to_unit, Second | Millisecond)
+        }
+        (Timestamp(_, _), _) if to_type.is_numeric() => true,
+        (_, Timestamp(_, _)) if from_type.is_numeric() => true,
+        (Date64, Timestamp(_, None)) => true,
+        (Date32, Timestamp(_, None)) => true,
+        (
+            Timestamp(_, _),
+            Timestamp(_, _)
+            | Date32
+            | Date64
+            | Time32(Second)
+            | Time32(Millisecond)
+            | Time64(Microsecond)
+            | Time64(Nanosecond),
+        ) => true,
+        (Int64, Duration(_)) => true,
+        (Duration(_), Int64) => true,
+        (Interval(from_type), Int64) => {
+            match from_type {
+                YearMonth => true,
+                DayTime => true,
+                MonthDayNano => false, // Native type is i128
+            }
+        }
+        (Int32, Interval(to_type)) => match to_type {
+            YearMonth => true,
+            DayTime => false,
+            MonthDayNano => false,
+        },
+        (Int64, Interval(to_type)) => match to_type {
+            YearMonth => false,
+            DayTime => true,
+            MonthDayNano => false,
+        },
+        (Duration(_), Interval(MonthDayNano)) => true,
+        (Interval(MonthDayNano), Duration(_)) => true,
+        (Interval(YearMonth), Interval(MonthDayNano)) => true,
+        (Interval(DayTime), Interval(MonthDayNano)) => true,
+        (_, _) => false,
+    }
+}
+
+/// Cast `array` to the provided data type and return a new Array with type `to_type`, if possible.
+///
+/// See [`cast_with_options`] for more information
+pub fn cast(array: &dyn Array, to_type: &DataType) -> Result<ArrayRef, ArrowError> {
+    cast_with_options(array, to_type, &CastOptions::default())
+}
+
+fn cast_integer_to_decimal<
+    T: ArrowPrimitiveType,
+    D: DecimalType + ArrowPrimitiveType<Native = M>,
+    M,
+>(
+    array: &PrimitiveArray<T>,
+    precision: u8,
+    scale: i8,
+    base: M,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    <T as ArrowPrimitiveType>::Native: AsPrimitive<M>,
+    M: ArrowNativeTypeOp,
+{
+    let scale_factor = base.pow_checked(scale.unsigned_abs() as u32).map_err(|_| {
+        ArrowError::CastError(format!(
+            "Cannot cast to {:?}({}, {}). The scale causes overflow.",
+            D::PREFIX,
+            precision,
+            scale,
+        ))
+    })?;
+
+    let array = if scale < 0 {
+        match cast_options.safe {
+            true => array.unary_opt::<_, D>(|v| {
+                v.as_().div_checked(scale_factor).ok().and_then(|v| {
+                    (D::validate_decimal_precision(v, precision).is_ok()).then_some(v)
+                })
+            }),
+            false => array.try_unary::<_, D, _>(|v| {
+                v.as_()
+                    .div_checked(scale_factor)
+                    .and_then(|v| D::validate_decimal_precision(v, precision).map(|_| v))
+            })?,
+        }
+    } else {
+        match cast_options.safe {
+            true => array.unary_opt::<_, D>(|v| {
+                v.as_().mul_checked(scale_factor).ok().and_then(|v| {
+                    (D::validate_decimal_precision(v, precision).is_ok()).then_some(v)
+                })
+            }),
+            false => array.try_unary::<_, D, _>(|v| {
+                v.as_()
+                    .mul_checked(scale_factor)
+                    .and_then(|v| D::validate_decimal_precision(v, precision).map(|_| v))
+            })?,
+        }
+    };
+
+    Ok(Arc::new(array.with_precision_and_scale(precision, scale)?))
+}
+
+fn cast_floating_point_to_decimal128<T: ArrowPrimitiveType>(
+    array: &PrimitiveArray<T>,
+    precision: u8,
+    scale: i8,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    <T as ArrowPrimitiveType>::Native: AsPrimitive<f64>,
+{
+    let mul = 10_f64.powi(scale as i32);
+
+    if cast_options.safe {
+        array
+            .unary_opt::<_, Decimal128Type>(|v| {
+                (mul * v.as_())
+                    .round()
+                    .to_i128()
+                    .filter(|v| Decimal128Type::validate_decimal_precision(*v, precision).is_ok())
+            })
+            .with_precision_and_scale(precision, scale)
+            .map(|a| Arc::new(a) as ArrayRef)
+    } else {
+        array
+            .try_unary::<_, Decimal128Type, _>(|v| {
+                (mul * v.as_())
+                    .round()
+                    .to_i128()
+                    .ok_or_else(|| {
+                        ArrowError::CastError(format!(
+                            "Cannot cast to {}({}, {}). Overflowing on {:?}",
+                            Decimal128Type::PREFIX,
+                            precision,
+                            scale,
+                            v
+                        ))
+                    })
+                    .and_then(|v| {
+                        Decimal128Type::validate_decimal_precision(v, precision).map(|_| v)
+                    })
+            })?
+            .with_precision_and_scale(precision, scale)
+            .map(|a| Arc::new(a) as ArrayRef)
+    }
+}
+
+fn cast_floating_point_to_decimal256<T: ArrowPrimitiveType>(
+    array: &PrimitiveArray<T>,
+    precision: u8,
+    scale: i8,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    <T as ArrowPrimitiveType>::Native: AsPrimitive<f64>,
+{
+    let mul = 10_f64.powi(scale as i32);
+
+    if cast_options.safe {
+        array
+            .unary_opt::<_, Decimal256Type>(|v| {
+                i256::from_f64((v.as_() * mul).round())
+                    .filter(|v| Decimal256Type::validate_decimal_precision(*v, precision).is_ok())
+            })
+            .with_precision_and_scale(precision, scale)
+            .map(|a| Arc::new(a) as ArrayRef)
+    } else {
+        array
+            .try_unary::<_, Decimal256Type, _>(|v| {
+                i256::from_f64((v.as_() * mul).round())
+                    .ok_or_else(|| {
+                        ArrowError::CastError(format!(
+                            "Cannot cast to {}({}, {}). Overflowing on {:?}",
+                            Decimal256Type::PREFIX,
+                            precision,
+                            scale,
+                            v
+                        ))
+                    })
+                    .and_then(|v| {
+                        Decimal256Type::validate_decimal_precision(v, precision).map(|_| v)
+                    })
+            })?
+            .with_precision_and_scale(precision, scale)
+            .map(|a| Arc::new(a) as ArrayRef)
+    }
+}
+
+/// Cast the array from interval year month to month day nano
+fn cast_interval_year_month_to_interval_month_day_nano(
+    array: &dyn Array,
+    _cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let array = array.as_primitive::<IntervalYearMonthType>();
+
+    Ok(Arc::new(array.unary::<_, IntervalMonthDayNanoType>(|v| {
+        let months = IntervalYearMonthType::to_months(v);
+        IntervalMonthDayNanoType::make_value(months, 0, 0)
+    })))
+}
+
+/// Cast the array from interval day time to month day nano
+fn cast_interval_day_time_to_interval_month_day_nano(
+    array: &dyn Array,
+    _cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let array = array.as_primitive::<IntervalDayTimeType>();
+    let mul = 1_000_000;
+
+    Ok(Arc::new(array.unary::<_, IntervalMonthDayNanoType>(|v| {
+        let (days, ms) = IntervalDayTimeType::to_parts(v);
+        IntervalMonthDayNanoType::make_value(0, days, ms as i64 * mul)
+    })))
+}
+
+/// Cast the array from interval to duration
+fn cast_month_day_nano_to_duration<D: ArrowTemporalType<Native = i64>>(
+    array: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let array = array.as_primitive::<IntervalMonthDayNanoType>();
+    let scale = match D::DATA_TYPE {
+        DataType::Duration(TimeUnit::Second) => 1_000_000_000,
+        DataType::Duration(TimeUnit::Millisecond) => 1_000_000,
+        DataType::Duration(TimeUnit::Microsecond) => 1_000,
+        DataType::Duration(TimeUnit::Nanosecond) => 1,
+        _ => unreachable!(),
+    };
+
+    if cast_options.safe {
+        let iter = array
+            .iter()
+            .map(|v| v.and_then(|v| (v >> 64 == 0).then_some((v as i64) / scale)));
+        Ok(Arc::new(unsafe {
+            PrimitiveArray::<D>::from_trusted_len_iter(iter)
+        }))
+    } else {
+        let vec = array
+            .iter()
+            .map(|v| {
+                v.map(|v| match v >> 64 {
+                    0 => Ok((v as i64) / scale),
+                    _ => Err(ArrowError::ComputeError(
+                        "Cannot convert interval containing non-zero months or days to duration"
+                            .to_string(),
+                    )),
+                })
+                .transpose()
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(Arc::new(unsafe {
+            PrimitiveArray::<D>::from_trusted_len_iter(vec.iter())
+        }))
+    }
+}
+
+/// Cast the array from duration and interval
+fn cast_duration_to_interval<D: ArrowTemporalType<Native = i64>>(
+    array: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let array = array
+        .as_any()
+        .downcast_ref::<PrimitiveArray<D>>()
+        .ok_or_else(|| {
+            ArrowError::ComputeError(
+                "Internal Error: Cannot cast duration to DurationArray of expected type"
+                    .to_string(),
+            )
+        })?;
+
+    let scale = match array.data_type() {
+        DataType::Duration(TimeUnit::Second) => 1_000_000_000,
+        DataType::Duration(TimeUnit::Millisecond) => 1_000_000,
+        DataType::Duration(TimeUnit::Microsecond) => 1_000,
+        DataType::Duration(TimeUnit::Nanosecond) => 1,
+        _ => unreachable!(),
+    };
+
+    if cast_options.safe {
+        let iter = array
+            .iter()
+            .map(|v| v.and_then(|v| v.checked_mul(scale).map(|v| v as i128)));
+        Ok(Arc::new(unsafe {
+            PrimitiveArray::<IntervalMonthDayNanoType>::from_trusted_len_iter(iter)
+        }))
+    } else {
+        let vec = array
+            .iter()
+            .map(|v| {
+                v.map(|v| {
+                    if let Ok(v) = v.mul_checked(scale) {
+                        Ok(v as i128)
+                    } else {
+                        Err(ArrowError::ComputeError(format!(
+                            "Cannot cast to {:?}. Overflowing on {:?}",
+                            IntervalMonthDayNanoType::DATA_TYPE,
+                            v
+                        )))
+                    }
+                })
+                .transpose()
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(Arc::new(unsafe {
+            PrimitiveArray::<IntervalMonthDayNanoType>::from_trusted_len_iter(vec.iter())
+        }))
+    }
+}
+
+/// Cast the primitive array using [`PrimitiveArray::reinterpret_cast`]
+fn cast_reinterpret_arrays<I: ArrowPrimitiveType, O: ArrowPrimitiveType<Native = I::Native>>(
+    array: &dyn Array,
+) -> Result<ArrayRef, ArrowError> {
+    Ok(Arc::new(array.as_primitive::<I>().reinterpret_cast::<O>()))
+}
+
+fn cast_decimal_to_integer<D, T>(
+    array: &dyn Array,
+    base: D::Native,
+    scale: i8,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    T: ArrowPrimitiveType,
+    <T as ArrowPrimitiveType>::Native: NumCast,
+    D: DecimalType + ArrowPrimitiveType,
+    <D as ArrowPrimitiveType>::Native: ArrowNativeTypeOp + ToPrimitive,
+{
+    let array = array.as_primitive::<D>();
+
+    let div: D::Native = base.pow_checked(scale as u32).map_err(|_| {
+        ArrowError::CastError(format!(
+            "Cannot cast to {:?}. The scale {} causes overflow.",
+            D::PREFIX,
+            scale,
+        ))
+    })?;
+
+    let mut value_builder = PrimitiveBuilder::<T>::with_capacity(array.len());
+
+    if cast_options.safe {
+        for i in 0..array.len() {
+            if array.is_null(i) {
+                value_builder.append_null();
+            } else {
+                let v = array
+                    .value(i)
+                    .div_checked(div)
+                    .ok()
+                    .and_then(<T::Native as NumCast>::from::<D::Native>);
+
+                value_builder.append_option(v);
+            }
+        }
+    } else {
+        for i in 0..array.len() {
+            if array.is_null(i) {
+                value_builder.append_null();
+            } else {
+                let v = array.value(i).div_checked(div)?;
+
+                let value = <T::Native as NumCast>::from::<D::Native>(v).ok_or_else(|| {
+                    ArrowError::CastError(format!(
+                        "value of {:?} is out of range {}",
+                        v,
+                        T::DATA_TYPE
+                    ))
+                })?;
+
+                value_builder.append_value(value);
+            }
+        }
+    }
+    Ok(Arc::new(value_builder.finish()))
+}
+
+// cast the decimal array to floating-point array
+fn cast_decimal_to_float<D: DecimalType, T: ArrowPrimitiveType, F>(
+    array: &dyn Array,
+    op: F,
+) -> Result<ArrayRef, ArrowError>
+where
+    F: Fn(D::Native) -> T::Native,
+{
+    let array = array.as_primitive::<D>();
+    let array = array.unary::<_, T>(op);
+    Ok(Arc::new(array))
+}
+
+fn make_timestamp_array(
+    array: &PrimitiveArray<Int64Type>,
+    unit: TimeUnit,
+    tz: Option<Arc<str>>,
+) -> ArrayRef {
+    match unit {
+        TimeUnit::Second => Arc::new(
+            array
+                .reinterpret_cast::<TimestampSecondType>()
+                .with_timezone_opt(tz),
+        ),
+        TimeUnit::Millisecond => Arc::new(
+            array
+                .reinterpret_cast::<TimestampMillisecondType>()
+                .with_timezone_opt(tz),
+        ),
+        TimeUnit::Microsecond => Arc::new(
+            array
+                .reinterpret_cast::<TimestampMicrosecondType>()
+                .with_timezone_opt(tz),
+        ),
+        TimeUnit::Nanosecond => Arc::new(
+            array
+                .reinterpret_cast::<TimestampNanosecondType>()
+                .with_timezone_opt(tz),
+        ),
+    }
+}
+
+fn as_time_res_with_timezone<T: ArrowPrimitiveType>(
+    v: i64,
+    tz: Option<Tz>,
+) -> Result<NaiveTime, ArrowError> {
+    let time = match tz {
+        Some(tz) => as_datetime_with_timezone::<T>(v, tz).map(|d| d.time()),
+        None => as_datetime::<T>(v).map(|d| d.time()),
+    };
+
+    time.ok_or_else(|| {
+        ArrowError::CastError(format!(
+            "Failed to create naive time with {} {}",
+            std::any::type_name::<T>(),
+            v
+        ))
+    })
+}
+
+/// Cast `array` to the provided data type and return a new Array with type `to_type`, if possible.
+///
+/// Accepts [`CastOptions`] to specify cast behavior.
+///
+/// ## Behavior
+/// * Boolean to Utf8: `true` => '1', `false` => `0`
+/// * Utf8 to boolean: `true`, `yes`, `on`, `1` => `true`, `false`, `no`, `off`, `0` => `false`,
+///   short variants are accepted, other strings return null or error
+/// * Utf8 to numeric: strings that can't be parsed to numbers return null, float strings
+///   in integer casts return null
+/// * Numeric to boolean: 0 returns `false`, any other value returns `true`
+/// * List to List: the underlying data type is cast
+/// * List to FixedSizeList: the underlying data type is cast. If safe is true and a list element
+/// has the wrong length it will be replaced with NULL, otherwise an error will be returned
+/// * Primitive to List: a list array with 1 value per slot is created
+/// * Date32 and Date64: precision lost when going to higher interval
+/// * Time32 and Time64: precision lost when going to higher interval
+/// * Timestamp and Date{32|64}: precision lost when going to higher interval
+/// * Temporal to/from backing primitive: zero-copy with data type change
+/// * Casting from `float32/float64` to `Decimal(precision, scale)` rounds to the `scale` decimals
+///   (i.e. casting `6.4999` to Decimal(10, 1) becomes `6.5`). Prior to  version `26.0.0`,
+///   casting would truncate instead (i.e. outputs `6.4` instead)
+///
+/// Unsupported Casts
+/// * To or from `StructArray`
+/// * List to primitive
+/// * Interval and duration
+pub fn cast_with_options(
+    array: &dyn Array,
+    to_type: &DataType,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    use DataType::*;
+    let from_type = array.data_type();
+    // clone array if types are the same
+    if from_type == to_type {
+        return Ok(make_array(array.to_data()));
+    }
+    match (from_type, to_type) {
+        (
+            Null,
+            Boolean
+            | Int8
+            | UInt8
+            | Int16
+            | UInt16
+            | Int32
+            | UInt32
+            | Float32
+            | Date32
+            | Time32(_)
+            | Int64
+            | UInt64
+            | Float64
+            | Date64
+            | Timestamp(_, _)
+            | Time64(_)
+            | Duration(_)
+            | Interval(_)
+            | FixedSizeBinary(_)
+            | Binary
+            | Utf8
+            | LargeBinary
+            | LargeUtf8
+            | List(_)
+            | LargeList(_)
+            | FixedSizeList(_, _)
+            | Struct(_)
+            | Map(_, _)
+            | Dictionary(_, _),
+        ) => Ok(new_null_array(to_type, array.len())),
+        (Dictionary(index_type, _), _) => match **index_type {
+            Int8 => dictionary_cast::<Int8Type>(array, to_type, cast_options),
+            Int16 => dictionary_cast::<Int16Type>(array, to_type, cast_options),
+            Int32 => dictionary_cast::<Int32Type>(array, to_type, cast_options),
+            Int64 => dictionary_cast::<Int64Type>(array, to_type, cast_options),
+            UInt8 => dictionary_cast::<UInt8Type>(array, to_type, cast_options),
+            UInt16 => dictionary_cast::<UInt16Type>(array, to_type, cast_options),
+            UInt32 => dictionary_cast::<UInt32Type>(array, to_type, cast_options),
+            UInt64 => dictionary_cast::<UInt64Type>(array, to_type, cast_options),
+            _ => Err(ArrowError::CastError(format!(
+                "Casting from dictionary type {from_type:?} to {to_type:?} not supported",
+            ))),
+        },
+        (_, Dictionary(index_type, value_type)) => match **index_type {
+            Int8 => cast_to_dictionary::<Int8Type>(array, value_type, cast_options),
+            Int16 => cast_to_dictionary::<Int16Type>(array, value_type, cast_options),
+            Int32 => cast_to_dictionary::<Int32Type>(array, value_type, cast_options),
+            Int64 => cast_to_dictionary::<Int64Type>(array, value_type, cast_options),
+            UInt8 => cast_to_dictionary::<UInt8Type>(array, value_type, cast_options),
+            UInt16 => cast_to_dictionary::<UInt16Type>(array, value_type, cast_options),
+            UInt32 => cast_to_dictionary::<UInt32Type>(array, value_type, cast_options),
+            UInt64 => cast_to_dictionary::<UInt64Type>(array, value_type, cast_options),
+            _ => Err(ArrowError::CastError(format!(
+                "Casting from type {from_type:?} to dictionary type {to_type:?} not supported",
+            ))),
+        },
+        (List(_), List(to)) => cast_list_values::<i32>(array, to, cast_options),
+        (LargeList(_), LargeList(to)) => cast_list_values::<i64>(array, to, cast_options),
+        (List(_), LargeList(list_to)) => cast_list::<i32, i64>(array, list_to, cast_options),
+        (LargeList(_), List(list_to)) => cast_list::<i64, i32>(array, list_to, cast_options),
+        (List(_), FixedSizeList(field, size)) => {
+            let array = array.as_list::<i32>();
+            cast_list_to_fixed_size_list::<i32>(array, field, *size, cast_options)
+        }
+        (LargeList(_), FixedSizeList(field, size)) => {
+            let array = array.as_list::<i64>();
+            cast_list_to_fixed_size_list::<i64>(array, field, *size, cast_options)
+        }
+        (List(_) | LargeList(_), _) => match to_type {
+            Utf8 => value_to_string::<i32>(array, cast_options),
+            LargeUtf8 => value_to_string::<i64>(array, cast_options),
+            _ => Err(ArrowError::CastError(
+                "Cannot cast list to non-list data types".to_string(),
+            )),
+        },
+        (FixedSizeList(list_from, size), List(list_to)) => {
+            if list_to.data_type() != list_from.data_type() {
+                // To transform inner type, can first cast to FSL with new inner type.
+                let fsl_to = DataType::FixedSizeList(list_to.clone(), *size);
+                let array = cast_with_options(array, &fsl_to, cast_options)?;
+                cast_fixed_size_list_to_list::<i32>(array.as_ref())
+            } else {
+                cast_fixed_size_list_to_list::<i32>(array)
+            }
+        }
+        (FixedSizeList(list_from, size), LargeList(list_to)) => {
+            if list_to.data_type() != list_from.data_type() {
+                // To transform inner type, can first cast to FSL with new inner type.
+                let fsl_to = DataType::FixedSizeList(list_to.clone(), *size);
+                let array = cast_with_options(array, &fsl_to, cast_options)?;
+                cast_fixed_size_list_to_list::<i64>(array.as_ref())
+            } else {
+                cast_fixed_size_list_to_list::<i64>(array)
+            }
+        }
+        (FixedSizeList(_, size_from), FixedSizeList(list_to, size_to)) => {
+            if size_from != size_to {
+                return Err(ArrowError::CastError(
+                    "cannot cast fixed-size-list to fixed-size-list with different size".into(),
+                ));
+            }
+            let array = array.as_any().downcast_ref::<FixedSizeListArray>().unwrap();
+            let values = cast_with_options(array.values(), list_to.data_type(), cast_options)?;
+            Ok(Arc::new(FixedSizeListArray::try_new(
+                list_to.clone(),
+                *size_from,
+                values,
+                array.nulls().cloned(),
+            )?))
+        }
+        (_, List(ref to)) => cast_values_to_list::<i32>(array, to, cast_options),
+        (_, LargeList(ref to)) => cast_values_to_list::<i64>(array, to, cast_options),
+        (_, FixedSizeList(ref to, size)) if *size == 1 => {
+            cast_values_to_fixed_size_list(array, to, *size, cast_options)
+        }
+        (Decimal128(_, s1), Decimal128(p2, s2)) => {
+            cast_decimal_to_decimal_same_type::<Decimal128Type>(
+                array.as_primitive(),
+                *s1,
+                *p2,
+                *s2,
+                cast_options,
+            )
+        }
+        (Decimal256(_, s1), Decimal256(p2, s2)) => {
+            cast_decimal_to_decimal_same_type::<Decimal256Type>(
+                array.as_primitive(),
+                *s1,
+                *p2,
+                *s2,
+                cast_options,
+            )
+        }
+        (Decimal128(_, s1), Decimal256(p2, s2)) => {
+            cast_decimal_to_decimal::<Decimal128Type, Decimal256Type>(
+                array.as_primitive(),
+                *s1,
+                *p2,
+                *s2,
+                cast_options,
+            )
+        }
+        (Decimal256(_, s1), Decimal128(p2, s2)) => {
+            cast_decimal_to_decimal::<Decimal256Type, Decimal128Type>(
+                array.as_primitive(),
+                *s1,
+                *p2,
+                *s2,
+                cast_options,
+            )
+        }
+        (Decimal128(_, scale), _) if !to_type.is_temporal() => {
+            // cast decimal to other type
+            match to_type {
+                UInt8 => cast_decimal_to_integer::<Decimal128Type, UInt8Type>(
+                    array,
+                    10_i128,
+                    *scale,
+                    cast_options,
+                ),
+                UInt16 => cast_decimal_to_integer::<Decimal128Type, UInt16Type>(
+                    array,
+                    10_i128,
+                    *scale,
+                    cast_options,
+                ),
+                UInt32 => cast_decimal_to_integer::<Decimal128Type, UInt32Type>(
+                    array,
+                    10_i128,
+                    *scale,
+                    cast_options,
+                ),
+                UInt64 => cast_decimal_to_integer::<Decimal128Type, UInt64Type>(
+                    array,
+                    10_i128,
+                    *scale,
+                    cast_options,
+                ),
+                Int8 => cast_decimal_to_integer::<Decimal128Type, Int8Type>(
+                    array,
+                    10_i128,
+                    *scale,
+                    cast_options,
+                ),
+                Int16 => cast_decimal_to_integer::<Decimal128Type, Int16Type>(
+                    array,
+                    10_i128,
+                    *scale,
+                    cast_options,
+                ),
+                Int32 => cast_decimal_to_integer::<Decimal128Type, Int32Type>(
+                    array,
+                    10_i128,
+                    *scale,
+                    cast_options,
+                ),
+                Int64 => cast_decimal_to_integer::<Decimal128Type, Int64Type>(
+                    array,
+                    10_i128,
+                    *scale,
+                    cast_options,
+                ),
+                Float32 => cast_decimal_to_float::<Decimal128Type, Float32Type, _>(array, |x| {
+                    (x as f64 / 10_f64.powi(*scale as i32)) as f32
+                }),
+                Float64 => cast_decimal_to_float::<Decimal128Type, Float64Type, _>(array, |x| {
+                    x as f64 / 10_f64.powi(*scale as i32)
+                }),
+                Utf8 => value_to_string::<i32>(array, cast_options),
+                LargeUtf8 => value_to_string::<i64>(array, cast_options),
+                Null => Ok(new_null_array(to_type, array.len())),
+                _ => Err(ArrowError::CastError(format!(
+                    "Casting from {from_type:?} to {to_type:?} not supported"
+                ))),
+            }
+        }
+        (Decimal256(_, scale), _) if !to_type.is_temporal() => {
+            // cast decimal to other type
+            match to_type {
+                UInt8 => cast_decimal_to_integer::<Decimal256Type, UInt8Type>(
+                    array,
+                    i256::from_i128(10_i128),
+                    *scale,
+                    cast_options,
+                ),
+                UInt16 => cast_decimal_to_integer::<Decimal256Type, UInt16Type>(
+                    array,
+                    i256::from_i128(10_i128),
+                    *scale,
+                    cast_options,
+                ),
+                UInt32 => cast_decimal_to_integer::<Decimal256Type, UInt32Type>(
+                    array,
+                    i256::from_i128(10_i128),
+                    *scale,
+                    cast_options,
+                ),
+                UInt64 => cast_decimal_to_integer::<Decimal256Type, UInt64Type>(
+                    array,
+                    i256::from_i128(10_i128),
+                    *scale,
+                    cast_options,
+                ),
+                Int8 => cast_decimal_to_integer::<Decimal256Type, Int8Type>(
+                    array,
+                    i256::from_i128(10_i128),
+                    *scale,
+                    cast_options,
+                ),
+                Int16 => cast_decimal_to_integer::<Decimal256Type, Int16Type>(
+                    array,
+                    i256::from_i128(10_i128),
+                    *scale,
+                    cast_options,
+                ),
+                Int32 => cast_decimal_to_integer::<Decimal256Type, Int32Type>(
+                    array,
+                    i256::from_i128(10_i128),
+                    *scale,
+                    cast_options,
+                ),
+                Int64 => cast_decimal_to_integer::<Decimal256Type, Int64Type>(
+                    array,
+                    i256::from_i128(10_i128),
+                    *scale,
+                    cast_options,
+                ),
+                Float32 => cast_decimal_to_float::<Decimal256Type, Float32Type, _>(array, |x| {
+                    (x.to_f64().unwrap() / 10_f64.powi(*scale as i32)) as f32
+                }),
+                Float64 => cast_decimal_to_float::<Decimal256Type, Float64Type, _>(array, |x| {
+                    x.to_f64().unwrap() / 10_f64.powi(*scale as i32)
+                }),
+                Utf8 => value_to_string::<i32>(array, cast_options),
+                LargeUtf8 => value_to_string::<i64>(array, cast_options),
+                Null => Ok(new_null_array(to_type, array.len())),
+                _ => Err(ArrowError::CastError(format!(
+                    "Casting from {from_type:?} to {to_type:?} not supported"
+                ))),
+            }
+        }
+        (_, Decimal128(precision, scale)) if !from_type.is_temporal() => {
+            // cast data to decimal
+            match from_type {
+                UInt8 => cast_integer_to_decimal::<_, Decimal128Type, _>(
+                    array.as_primitive::<UInt8Type>(),
+                    *precision,
+                    *scale,
+                    10_i128,
+                    cast_options,
+                ),
+                UInt16 => cast_integer_to_decimal::<_, Decimal128Type, _>(
+                    array.as_primitive::<UInt16Type>(),
+                    *precision,
+                    *scale,
+                    10_i128,
+                    cast_options,
+                ),
+                UInt32 => cast_integer_to_decimal::<_, Decimal128Type, _>(
+                    array.as_primitive::<UInt32Type>(),
+                    *precision,
+                    *scale,
+                    10_i128,
+                    cast_options,
+                ),
+                UInt64 => cast_integer_to_decimal::<_, Decimal128Type, _>(
+                    array.as_primitive::<UInt64Type>(),
+                    *precision,
+                    *scale,
+                    10_i128,
+                    cast_options,
+                ),
+                Int8 => cast_integer_to_decimal::<_, Decimal128Type, _>(
+                    array.as_primitive::<Int8Type>(),
+                    *precision,
+                    *scale,
+                    10_i128,
+                    cast_options,
+                ),
+                Int16 => cast_integer_to_decimal::<_, Decimal128Type, _>(
+                    array.as_primitive::<Int16Type>(),
+                    *precision,
+                    *scale,
+                    10_i128,
+                    cast_options,
+                ),
+                Int32 => cast_integer_to_decimal::<_, Decimal128Type, _>(
+                    array.as_primitive::<Int32Type>(),
+                    *precision,
+                    *scale,
+                    10_i128,
+                    cast_options,
+                ),
+                Int64 => cast_integer_to_decimal::<_, Decimal128Type, _>(
+                    array.as_primitive::<Int64Type>(),
+                    *precision,
+                    *scale,
+                    10_i128,
+                    cast_options,
+                ),
+                Float32 => cast_floating_point_to_decimal128(
+                    array.as_primitive::<Float32Type>(),
+                    *precision,
+                    *scale,
+                    cast_options,
+                ),
+                Float64 => cast_floating_point_to_decimal128(
+                    array.as_primitive::<Float64Type>(),
+                    *precision,
+                    *scale,
+                    cast_options,
+                ),
+                Utf8 => cast_string_to_decimal::<Decimal128Type, i32>(
+                    array,
+                    *precision,
+                    *scale,
+                    cast_options,
+                ),
+                LargeUtf8 => cast_string_to_decimal::<Decimal128Type, i64>(
+                    array,
+                    *precision,
+                    *scale,
+                    cast_options,
+                ),
+                Null => Ok(new_null_array(to_type, array.len())),
+                _ => Err(ArrowError::CastError(format!(
+                    "Casting from {from_type:?} to {to_type:?} not supported"
+                ))),
+            }
+        }
+        (_, Decimal256(precision, scale)) if !from_type.is_temporal() => {
+            // cast data to decimal
+            match from_type {
+                UInt8 => cast_integer_to_decimal::<_, Decimal256Type, _>(
+                    array.as_primitive::<UInt8Type>(),
+                    *precision,
+                    *scale,
+                    i256::from_i128(10_i128),
+                    cast_options,
+                ),
+                UInt16 => cast_integer_to_decimal::<_, Decimal256Type, _>(
+                    array.as_primitive::<UInt16Type>(),
+                    *precision,
+                    *scale,
+                    i256::from_i128(10_i128),
+                    cast_options,
+                ),
+                UInt32 => cast_integer_to_decimal::<_, Decimal256Type, _>(
+                    array.as_primitive::<UInt32Type>(),
+                    *precision,
+                    *scale,
+                    i256::from_i128(10_i128),
+                    cast_options,
+                ),
+                UInt64 => cast_integer_to_decimal::<_, Decimal256Type, _>(
+                    array.as_primitive::<UInt64Type>(),
+                    *precision,
+                    *scale,
+                    i256::from_i128(10_i128),
+                    cast_options,
+                ),
+                Int8 => cast_integer_to_decimal::<_, Decimal256Type, _>(
+                    array.as_primitive::<Int8Type>(),
+                    *precision,
+                    *scale,
+                    i256::from_i128(10_i128),
+                    cast_options,
+                ),
+                Int16 => cast_integer_to_decimal::<_, Decimal256Type, _>(
+                    array.as_primitive::<Int16Type>(),
+                    *precision,
+                    *scale,
+                    i256::from_i128(10_i128),
+                    cast_options,
+                ),
+                Int32 => cast_integer_to_decimal::<_, Decimal256Type, _>(
+                    array.as_primitive::<Int32Type>(),
+                    *precision,
+                    *scale,
+                    i256::from_i128(10_i128),
+                    cast_options,
+                ),
+                Int64 => cast_integer_to_decimal::<_, Decimal256Type, _>(
+                    array.as_primitive::<Int64Type>(),
+                    *precision,
+                    *scale,
+                    i256::from_i128(10_i128),
+                    cast_options,
+                ),
+                Float32 => cast_floating_point_to_decimal256(
+                    array.as_primitive::<Float32Type>(),
+                    *precision,
+                    *scale,
+                    cast_options,
+                ),
+                Float64 => cast_floating_point_to_decimal256(
+                    array.as_primitive::<Float64Type>(),
+                    *precision,
+                    *scale,
+                    cast_options,
+                ),
+                Utf8 => cast_string_to_decimal::<Decimal256Type, i32>(
+                    array,
+                    *precision,
+                    *scale,
+                    cast_options,
+                ),
+                LargeUtf8 => cast_string_to_decimal::<Decimal256Type, i64>(
+                    array,
+                    *precision,
+                    *scale,
+                    cast_options,
+                ),
+                Null => Ok(new_null_array(to_type, array.len())),
+                _ => Err(ArrowError::CastError(format!(
+                    "Casting from {from_type:?} to {to_type:?} not supported"
+                ))),
+            }
+        }
+        (Struct(_), Struct(to_fields)) => {
+            let array = array.as_struct();
+            let fields = array
+                .columns()
+                .iter()
+                .zip(to_fields.iter())
+                .map(|(l, field)| cast_with_options(l, field.data_type(), cast_options))
+                .collect::<Result<Vec<ArrayRef>, ArrowError>>()?;
+            let array = StructArray::try_new(to_fields.clone(), fields, array.nulls().cloned())?;
+            Ok(Arc::new(array) as ArrayRef)
+        }
+        (Struct(_), _) => Err(ArrowError::CastError(
+            "Cannot cast from struct to other types except struct".to_string(),
+        )),
+        (_, Struct(_)) => Err(ArrowError::CastError(
+            "Cannot cast to struct from other types except struct".to_string(),
+        )),
+        (_, Boolean) => match from_type {
+            UInt8 => cast_numeric_to_bool::<UInt8Type>(array),
+            UInt16 => cast_numeric_to_bool::<UInt16Type>(array),
+            UInt32 => cast_numeric_to_bool::<UInt32Type>(array),
+            UInt64 => cast_numeric_to_bool::<UInt64Type>(array),
+            Int8 => cast_numeric_to_bool::<Int8Type>(array),
+            Int16 => cast_numeric_to_bool::<Int16Type>(array),
+            Int32 => cast_numeric_to_bool::<Int32Type>(array),
+            Int64 => cast_numeric_to_bool::<Int64Type>(array),
+            Float16 => cast_numeric_to_bool::<Float16Type>(array),
+            Float32 => cast_numeric_to_bool::<Float32Type>(array),
+            Float64 => cast_numeric_to_bool::<Float64Type>(array),
+            Utf8 => cast_utf8_to_boolean::<i32>(array, cast_options),
+            LargeUtf8 => cast_utf8_to_boolean::<i64>(array, cast_options),
+            _ => Err(ArrowError::CastError(format!(
+                "Casting from {from_type:?} to {to_type:?} not supported",
+            ))),
+        },
+        (Boolean, _) => match to_type {
+            UInt8 => cast_bool_to_numeric::<UInt8Type>(array, cast_options),
+            UInt16 => cast_bool_to_numeric::<UInt16Type>(array, cast_options),
+            UInt32 => cast_bool_to_numeric::<UInt32Type>(array, cast_options),
+            UInt64 => cast_bool_to_numeric::<UInt64Type>(array, cast_options),
+            Int8 => cast_bool_to_numeric::<Int8Type>(array, cast_options),
+            Int16 => cast_bool_to_numeric::<Int16Type>(array, cast_options),
+            Int32 => cast_bool_to_numeric::<Int32Type>(array, cast_options),
+            Int64 => cast_bool_to_numeric::<Int64Type>(array, cast_options),
+            Float16 => cast_bool_to_numeric::<Float16Type>(array, cast_options),
+            Float32 => cast_bool_to_numeric::<Float32Type>(array, cast_options),
+            Float64 => cast_bool_to_numeric::<Float64Type>(array, cast_options),
+            Utf8 => value_to_string::<i32>(array, cast_options),
+            LargeUtf8 => value_to_string::<i64>(array, cast_options),
+            _ => Err(ArrowError::CastError(format!(
+                "Casting from {from_type:?} to {to_type:?} not supported",
+            ))),
+        },
+        (Utf8, _) => match to_type {
+            UInt8 => parse_string::<UInt8Type, i32>(array, cast_options),
+            UInt16 => parse_string::<UInt16Type, i32>(array, cast_options),
+            UInt32 => parse_string::<UInt32Type, i32>(array, cast_options),
+            UInt64 => parse_string::<UInt64Type, i32>(array, cast_options),
+            Int8 => parse_string::<Int8Type, i32>(array, cast_options),
+            Int16 => parse_string::<Int16Type, i32>(array, cast_options),
+            Int32 => parse_string::<Int32Type, i32>(array, cast_options),
+            Int64 => parse_string::<Int64Type, i32>(array, cast_options),
+            Float32 => parse_string::<Float32Type, i32>(array, cast_options),
+            Float64 => parse_string::<Float64Type, i32>(array, cast_options),
+            Date32 => parse_string::<Date32Type, i32>(array, cast_options),
+            Date64 => parse_string::<Date64Type, i32>(array, cast_options),
+            Binary => Ok(Arc::new(BinaryArray::from(
+                array.as_string::<i32>().clone(),
+            ))),
+            LargeBinary => {
+                let binary = BinaryArray::from(array.as_string::<i32>().clone());
+                cast_byte_container::<BinaryType, LargeBinaryType>(&binary)
+            }
+            LargeUtf8 => cast_byte_container::<Utf8Type, LargeUtf8Type>(array),
+            Time32(TimeUnit::Second) => parse_string::<Time32SecondType, i32>(array, cast_options),
+            Time32(TimeUnit::Millisecond) => {
+                parse_string::<Time32MillisecondType, i32>(array, cast_options)
+            }
+            Time64(TimeUnit::Microsecond) => {
+                parse_string::<Time64MicrosecondType, i32>(array, cast_options)
+            }
+            Time64(TimeUnit::Nanosecond) => {
+                parse_string::<Time64NanosecondType, i32>(array, cast_options)
+            }
+            Timestamp(TimeUnit::Second, to_tz) => {
+                cast_string_to_timestamp::<i32, TimestampSecondType>(array, to_tz, cast_options)
+            }
+            Timestamp(TimeUnit::Millisecond, to_tz) => cast_string_to_timestamp::<
+                i32,
+                TimestampMillisecondType,
+            >(array, to_tz, cast_options),
+            Timestamp(TimeUnit::Microsecond, to_tz) => cast_string_to_timestamp::<
+                i32,
+                TimestampMicrosecondType,
+            >(array, to_tz, cast_options),
+            Timestamp(TimeUnit::Nanosecond, to_tz) => {
+                cast_string_to_timestamp::<i32, TimestampNanosecondType>(array, to_tz, cast_options)
+            }
+            Interval(IntervalUnit::YearMonth) => {
+                cast_string_to_year_month_interval::<i32>(array, cast_options)
+            }
+            Interval(IntervalUnit::DayTime) => {
+                cast_string_to_day_time_interval::<i32>(array, cast_options)
+            }
+            Interval(IntervalUnit::MonthDayNano) => {
+                cast_string_to_month_day_nano_interval::<i32>(array, cast_options)
+            }
+            _ => Err(ArrowError::CastError(format!(
+                "Casting from {from_type:?} to {to_type:?} not supported",
+            ))),
+        },
+        (LargeUtf8, _) => match to_type {
+            UInt8 => parse_string::<UInt8Type, i64>(array, cast_options),
+            UInt16 => parse_string::<UInt16Type, i64>(array, cast_options),
+            UInt32 => parse_string::<UInt32Type, i64>(array, cast_options),
+            UInt64 => parse_string::<UInt64Type, i64>(array, cast_options),
+            Int8 => parse_string::<Int8Type, i64>(array, cast_options),
+            Int16 => parse_string::<Int16Type, i64>(array, cast_options),
+            Int32 => parse_string::<Int32Type, i64>(array, cast_options),
+            Int64 => parse_string::<Int64Type, i64>(array, cast_options),
+            Float32 => parse_string::<Float32Type, i64>(array, cast_options),
+            Float64 => parse_string::<Float64Type, i64>(array, cast_options),
+            Date32 => parse_string::<Date32Type, i64>(array, cast_options),
+            Date64 => parse_string::<Date64Type, i64>(array, cast_options),
+            Utf8 => cast_byte_container::<LargeUtf8Type, Utf8Type>(array),
+            Binary => {
+                let large_binary = LargeBinaryArray::from(array.as_string::<i64>().clone());
+                cast_byte_container::<LargeBinaryType, BinaryType>(&large_binary)
+            }
+            LargeBinary => Ok(Arc::new(LargeBinaryArray::from(
+                array.as_string::<i64>().clone(),
+            ))),
+            Time32(TimeUnit::Second) => parse_string::<Time32SecondType, i64>(array, cast_options),
+            Time32(TimeUnit::Millisecond) => {
+                parse_string::<Time32MillisecondType, i64>(array, cast_options)
+            }
+            Time64(TimeUnit::Microsecond) => {
+                parse_string::<Time64MicrosecondType, i64>(array, cast_options)
+            }
+            Time64(TimeUnit::Nanosecond) => {
+                parse_string::<Time64NanosecondType, i64>(array, cast_options)
+            }
+            Timestamp(TimeUnit::Second, to_tz) => {
+                cast_string_to_timestamp::<i64, TimestampSecondType>(array, to_tz, cast_options)
+            }
+            Timestamp(TimeUnit::Millisecond, to_tz) => cast_string_to_timestamp::<
+                i64,
+                TimestampMillisecondType,
+            >(array, to_tz, cast_options),
+            Timestamp(TimeUnit::Microsecond, to_tz) => cast_string_to_timestamp::<
+                i64,
+                TimestampMicrosecondType,
+            >(array, to_tz, cast_options),
+            Timestamp(TimeUnit::Nanosecond, to_tz) => {
+                cast_string_to_timestamp::<i64, TimestampNanosecondType>(array, to_tz, cast_options)
+            }
+            Interval(IntervalUnit::YearMonth) => {
+                cast_string_to_year_month_interval::<i64>(array, cast_options)
+            }
+            Interval(IntervalUnit::DayTime) => {
+                cast_string_to_day_time_interval::<i64>(array, cast_options)
+            }
+            Interval(IntervalUnit::MonthDayNano) => {
+                cast_string_to_month_day_nano_interval::<i64>(array, cast_options)
+            }
+            _ => Err(ArrowError::CastError(format!(
+                "Casting from {from_type:?} to {to_type:?} not supported",
+            ))),
+        },
+        (Binary, _) => match to_type {
+            Utf8 => cast_binary_to_string::<i32>(array, cast_options),
+            LargeUtf8 => {
+                let array = cast_binary_to_string::<i32>(array, cast_options)?;
+                cast_byte_container::<Utf8Type, LargeUtf8Type>(array.as_ref())
+            }
+            LargeBinary => cast_byte_container::<BinaryType, LargeBinaryType>(array),
+            FixedSizeBinary(size) => {
+                cast_binary_to_fixed_size_binary::<i32>(array, *size, cast_options)
+            }
+            _ => Err(ArrowError::CastError(format!(
+                "Casting from {from_type:?} to {to_type:?} not supported",
+            ))),
+        },
+        (LargeBinary, _) => match to_type {
+            Utf8 => {
+                let array = cast_binary_to_string::<i64>(array, cast_options)?;
+                cast_byte_container::<LargeUtf8Type, Utf8Type>(array.as_ref())
+            }
+            LargeUtf8 => cast_binary_to_string::<i64>(array, cast_options),
+            Binary => cast_byte_container::<LargeBinaryType, BinaryType>(array),
+            FixedSizeBinary(size) => {
+                cast_binary_to_fixed_size_binary::<i64>(array, *size, cast_options)
+            }
+            _ => Err(ArrowError::CastError(format!(
+                "Casting from {from_type:?} to {to_type:?} not supported",
+            ))),
+        },
+        (FixedSizeBinary(size), _) => match to_type {
+            Binary => cast_fixed_size_binary_to_binary::<i32>(array, *size),
+            LargeBinary => cast_fixed_size_binary_to_binary::<i64>(array, *size),
+            _ => Err(ArrowError::CastError(format!(
+                "Casting from {from_type:?} to {to_type:?} not supported",
+            ))),
+        },
+        (from_type, LargeUtf8) if from_type.is_primitive() => {
+            value_to_string::<i64>(array, cast_options)
+        }
+        (from_type, Utf8) if from_type.is_primitive() => {
+            value_to_string::<i32>(array, cast_options)
+        }
+        (from_type, Binary) if from_type.is_integer() => match from_type {
+            UInt8 => cast_numeric_to_binary::<UInt8Type, i32>(array),
+            UInt16 => cast_numeric_to_binary::<UInt16Type, i32>(array),
+            UInt32 => cast_numeric_to_binary::<UInt32Type, i32>(array),
+            UInt64 => cast_numeric_to_binary::<UInt64Type, i32>(array),
+            Int8 => cast_numeric_to_binary::<Int8Type, i32>(array),
+            Int16 => cast_numeric_to_binary::<Int16Type, i32>(array),
+            Int32 => cast_numeric_to_binary::<Int32Type, i32>(array),
+            Int64 => cast_numeric_to_binary::<Int64Type, i32>(array),
+            _ => unreachable!(),
+        },
+        (from_type, LargeBinary) if from_type.is_integer() => match from_type {
+            UInt8 => cast_numeric_to_binary::<UInt8Type, i64>(array),
+            UInt16 => cast_numeric_to_binary::<UInt16Type, i64>(array),
+            UInt32 => cast_numeric_to_binary::<UInt32Type, i64>(array),
+            UInt64 => cast_numeric_to_binary::<UInt64Type, i64>(array),
+            Int8 => cast_numeric_to_binary::<Int8Type, i64>(array),
+            Int16 => cast_numeric_to_binary::<Int16Type, i64>(array),
+            Int32 => cast_numeric_to_binary::<Int32Type, i64>(array),
+            Int64 => cast_numeric_to_binary::<Int64Type, i64>(array),
+            _ => unreachable!(),
+        },
+        // start numeric casts
+        (UInt8, UInt16) => cast_numeric_arrays::<UInt8Type, UInt16Type>(array, cast_options),
+        (UInt8, UInt32) => cast_numeric_arrays::<UInt8Type, UInt32Type>(array, cast_options),
+        (UInt8, UInt64) => cast_numeric_arrays::<UInt8Type, UInt64Type>(array, cast_options),
+        (UInt8, Int8) => cast_numeric_arrays::<UInt8Type, Int8Type>(array, cast_options),
+        (UInt8, Int16) => cast_numeric_arrays::<UInt8Type, Int16Type>(array, cast_options),
+        (UInt8, Int32) => cast_numeric_arrays::<UInt8Type, Int32Type>(array, cast_options),
+        (UInt8, Int64) => cast_numeric_arrays::<UInt8Type, Int64Type>(array, cast_options),
+        (UInt8, Float16) => cast_numeric_arrays::<UInt8Type, Float16Type>(array, cast_options),
+        (UInt8, Float32) => cast_numeric_arrays::<UInt8Type, Float32Type>(array, cast_options),
+        (UInt8, Float64) => cast_numeric_arrays::<UInt8Type, Float64Type>(array, cast_options),
+
+        (UInt16, UInt8) => cast_numeric_arrays::<UInt16Type, UInt8Type>(array, cast_options),
+        (UInt16, UInt32) => cast_numeric_arrays::<UInt16Type, UInt32Type>(array, cast_options),
+        (UInt16, UInt64) => cast_numeric_arrays::<UInt16Type, UInt64Type>(array, cast_options),
+        (UInt16, Int8) => cast_numeric_arrays::<UInt16Type, Int8Type>(array, cast_options),
+        (UInt16, Int16) => cast_numeric_arrays::<UInt16Type, Int16Type>(array, cast_options),
+        (UInt16, Int32) => cast_numeric_arrays::<UInt16Type, Int32Type>(array, cast_options),
+        (UInt16, Int64) => cast_numeric_arrays::<UInt16Type, Int64Type>(array, cast_options),
+        (UInt16, Float16) => cast_numeric_arrays::<UInt16Type, Float16Type>(array, cast_options),
+        (UInt16, Float32) => cast_numeric_arrays::<UInt16Type, Float32Type>(array, cast_options),
+        (UInt16, Float64) => cast_numeric_arrays::<UInt16Type, Float64Type>(array, cast_options),
+
+        (UInt32, UInt8) => cast_numeric_arrays::<UInt32Type, UInt8Type>(array, cast_options),
+        (UInt32, UInt16) => cast_numeric_arrays::<UInt32Type, UInt16Type>(array, cast_options),
+        (UInt32, UInt64) => cast_numeric_arrays::<UInt32Type, UInt64Type>(array, cast_options),
+        (UInt32, Int8) => cast_numeric_arrays::<UInt32Type, Int8Type>(array, cast_options),
+        (UInt32, Int16) => cast_numeric_arrays::<UInt32Type, Int16Type>(array, cast_options),
+        (UInt32, Int32) => cast_numeric_arrays::<UInt32Type, Int32Type>(array, cast_options),
+        (UInt32, Int64) => cast_numeric_arrays::<UInt32Type, Int64Type>(array, cast_options),
+        (UInt32, Float16) => cast_numeric_arrays::<UInt32Type, Float16Type>(array, cast_options),
+        (UInt32, Float32) => cast_numeric_arrays::<UInt32Type, Float32Type>(array, cast_options),
+        (UInt32, Float64) => cast_numeric_arrays::<UInt32Type, Float64Type>(array, cast_options),
+
+        (UInt64, UInt8) => cast_numeric_arrays::<UInt64Type, UInt8Type>(array, cast_options),
+        (UInt64, UInt16) => cast_numeric_arrays::<UInt64Type, UInt16Type>(array, cast_options),
+        (UInt64, UInt32) => cast_numeric_arrays::<UInt64Type, UInt32Type>(array, cast_options),
+        (UInt64, Int8) => cast_numeric_arrays::<UInt64Type, Int8Type>(array, cast_options),
+        (UInt64, Int16) => cast_numeric_arrays::<UInt64Type, Int16Type>(array, cast_options),
+        (UInt64, Int32) => cast_numeric_arrays::<UInt64Type, Int32Type>(array, cast_options),
+        (UInt64, Int64) => cast_numeric_arrays::<UInt64Type, Int64Type>(array, cast_options),
+        (UInt64, Float16) => cast_numeric_arrays::<UInt64Type, Float16Type>(array, cast_options),
+        (UInt64, Float32) => cast_numeric_arrays::<UInt64Type, Float32Type>(array, cast_options),
+        (UInt64, Float64) => cast_numeric_arrays::<UInt64Type, Float64Type>(array, cast_options),
+
+        (Int8, UInt8) => cast_numeric_arrays::<Int8Type, UInt8Type>(array, cast_options),
+        (Int8, UInt16) => cast_numeric_arrays::<Int8Type, UInt16Type>(array, cast_options),
+        (Int8, UInt32) => cast_numeric_arrays::<Int8Type, UInt32Type>(array, cast_options),
+        (Int8, UInt64) => cast_numeric_arrays::<Int8Type, UInt64Type>(array, cast_options),
+        (Int8, Int16) => cast_numeric_arrays::<Int8Type, Int16Type>(array, cast_options),
+        (Int8, Int32) => cast_numeric_arrays::<Int8Type, Int32Type>(array, cast_options),
+        (Int8, Int64) => cast_numeric_arrays::<Int8Type, Int64Type>(array, cast_options),
+        (Int8, Float16) => cast_numeric_arrays::<Int8Type, Float16Type>(array, cast_options),
+        (Int8, Float32) => cast_numeric_arrays::<Int8Type, Float32Type>(array, cast_options),
+        (Int8, Float64) => cast_numeric_arrays::<Int8Type, Float64Type>(array, cast_options),
+
+        (Int16, UInt8) => cast_numeric_arrays::<Int16Type, UInt8Type>(array, cast_options),
+        (Int16, UInt16) => cast_numeric_arrays::<Int16Type, UInt16Type>(array, cast_options),
+        (Int16, UInt32) => cast_numeric_arrays::<Int16Type, UInt32Type>(array, cast_options),
+        (Int16, UInt64) => cast_numeric_arrays::<Int16Type, UInt64Type>(array, cast_options),
+        (Int16, Int8) => cast_numeric_arrays::<Int16Type, Int8Type>(array, cast_options),
+        (Int16, Int32) => cast_numeric_arrays::<Int16Type, Int32Type>(array, cast_options),
+        (Int16, Int64) => cast_numeric_arrays::<Int16Type, Int64Type>(array, cast_options),
+        (Int16, Float16) => cast_numeric_arrays::<Int16Type, Float16Type>(array, cast_options),
+        (Int16, Float32) => cast_numeric_arrays::<Int16Type, Float32Type>(array, cast_options),
+        (Int16, Float64) => cast_numeric_arrays::<Int16Type, Float64Type>(array, cast_options),
+
+        (Int32, UInt8) => cast_numeric_arrays::<Int32Type, UInt8Type>(array, cast_options),
+        (Int32, UInt16) => cast_numeric_arrays::<Int32Type, UInt16Type>(array, cast_options),
+        (Int32, UInt32) => cast_numeric_arrays::<Int32Type, UInt32Type>(array, cast_options),
+        (Int32, UInt64) => cast_numeric_arrays::<Int32Type, UInt64Type>(array, cast_options),
+        (Int32, Int8) => cast_numeric_arrays::<Int32Type, Int8Type>(array, cast_options),
+        (Int32, Int16) => cast_numeric_arrays::<Int32Type, Int16Type>(array, cast_options),
+        (Int32, Int64) => cast_numeric_arrays::<Int32Type, Int64Type>(array, cast_options),
+        (Int32, Float16) => cast_numeric_arrays::<Int32Type, Float16Type>(array, cast_options),
+        (Int32, Float32) => cast_numeric_arrays::<Int32Type, Float32Type>(array, cast_options),
+        (Int32, Float64) => cast_numeric_arrays::<Int32Type, Float64Type>(array, cast_options),
+
+        (Int64, UInt8) => cast_numeric_arrays::<Int64Type, UInt8Type>(array, cast_options),
+        (Int64, UInt16) => cast_numeric_arrays::<Int64Type, UInt16Type>(array, cast_options),
+        (Int64, UInt32) => cast_numeric_arrays::<Int64Type, UInt32Type>(array, cast_options),
+        (Int64, UInt64) => cast_numeric_arrays::<Int64Type, UInt64Type>(array, cast_options),
+        (Int64, Int8) => cast_numeric_arrays::<Int64Type, Int8Type>(array, cast_options),
+        (Int64, Int16) => cast_numeric_arrays::<Int64Type, Int16Type>(array, cast_options),
+        (Int64, Int32) => cast_numeric_arrays::<Int64Type, Int32Type>(array, cast_options),
+        (Int64, Float16) => cast_numeric_arrays::<Int64Type, Float16Type>(array, cast_options),
+        (Int64, Float32) => cast_numeric_arrays::<Int64Type, Float32Type>(array, cast_options),
+        (Int64, Float64) => cast_numeric_arrays::<Int64Type, Float64Type>(array, cast_options),
+
+        (Float16, UInt8) => cast_numeric_arrays::<Float16Type, UInt8Type>(array, cast_options),
+        (Float16, UInt16) => cast_numeric_arrays::<Float16Type, UInt16Type>(array, cast_options),
+        (Float16, UInt32) => cast_numeric_arrays::<Float16Type, UInt32Type>(array, cast_options),
+        (Float16, UInt64) => cast_numeric_arrays::<Float16Type, UInt64Type>(array, cast_options),
+        (Float16, Int8) => cast_numeric_arrays::<Float16Type, Int8Type>(array, cast_options),
+        (Float16, Int16) => cast_numeric_arrays::<Float16Type, Int16Type>(array, cast_options),
+        (Float16, Int32) => cast_numeric_arrays::<Float16Type, Int32Type>(array, cast_options),
+        (Float16, Int64) => cast_numeric_arrays::<Float16Type, Int64Type>(array, cast_options),
+        (Float16, Float32) => cast_numeric_arrays::<Float16Type, Float32Type>(array, cast_options),
+        (Float16, Float64) => cast_numeric_arrays::<Float16Type, Float64Type>(array, cast_options),
+
+        (Float32, UInt8) => cast_numeric_arrays::<Float32Type, UInt8Type>(array, cast_options),
+        (Float32, UInt16) => cast_numeric_arrays::<Float32Type, UInt16Type>(array, cast_options),
+        (Float32, UInt32) => cast_numeric_arrays::<Float32Type, UInt32Type>(array, cast_options),
+        (Float32, UInt64) => cast_numeric_arrays::<Float32Type, UInt64Type>(array, cast_options),
+        (Float32, Int8) => cast_numeric_arrays::<Float32Type, Int8Type>(array, cast_options),
+        (Float32, Int16) => cast_numeric_arrays::<Float32Type, Int16Type>(array, cast_options),
+        (Float32, Int32) => cast_numeric_arrays::<Float32Type, Int32Type>(array, cast_options),
+        (Float32, Int64) => cast_numeric_arrays::<Float32Type, Int64Type>(array, cast_options),
+        (Float32, Float16) => cast_numeric_arrays::<Float32Type, Float16Type>(array, cast_options),
+        (Float32, Float64) => cast_numeric_arrays::<Float32Type, Float64Type>(array, cast_options),
+
+        (Float64, UInt8) => cast_numeric_arrays::<Float64Type, UInt8Type>(array, cast_options),
+        (Float64, UInt16) => cast_numeric_arrays::<Float64Type, UInt16Type>(array, cast_options),
+        (Float64, UInt32) => cast_numeric_arrays::<Float64Type, UInt32Type>(array, cast_options),
+        (Float64, UInt64) => cast_numeric_arrays::<Float64Type, UInt64Type>(array, cast_options),
+        (Float64, Int8) => cast_numeric_arrays::<Float64Type, Int8Type>(array, cast_options),
+        (Float64, Int16) => cast_numeric_arrays::<Float64Type, Int16Type>(array, cast_options),
+        (Float64, Int32) => cast_numeric_arrays::<Float64Type, Int32Type>(array, cast_options),
+        (Float64, Int64) => cast_numeric_arrays::<Float64Type, Int64Type>(array, cast_options),
+        (Float64, Float16) => cast_numeric_arrays::<Float64Type, Float16Type>(array, cast_options),
+        (Float64, Float32) => cast_numeric_arrays::<Float64Type, Float32Type>(array, cast_options),
+        // end numeric casts
+
+        // temporal casts
+        (Int32, Date32) => cast_reinterpret_arrays::<Int32Type, Date32Type>(array),
+        (Int32, Date64) => cast_with_options(
+            &cast_with_options(array, &Date32, cast_options)?,
+            &Date64,
+            cast_options,
+        ),
+        (Int32, Time32(TimeUnit::Second)) => {
+            cast_reinterpret_arrays::<Int32Type, Time32SecondType>(array)
+        }
+        (Int32, Time32(TimeUnit::Millisecond)) => {
+            cast_reinterpret_arrays::<Int32Type, Time32MillisecondType>(array)
+        }
+        // No support for microsecond/nanosecond with i32
+        (Date32, Int32) => cast_reinterpret_arrays::<Date32Type, Int32Type>(array),
+        (Date32, Int64) => cast_with_options(
+            &cast_with_options(array, &Int32, cast_options)?,
+            &Int64,
+            cast_options,
+        ),
+        (Time32(TimeUnit::Second), Int32) => {
+            cast_reinterpret_arrays::<Time32SecondType, Int32Type>(array)
+        }
+        (Time32(TimeUnit::Millisecond), Int32) => {
+            cast_reinterpret_arrays::<Time32MillisecondType, Int32Type>(array)
+        }
+        (Int64, Date64) => cast_reinterpret_arrays::<Int64Type, Date64Type>(array),
+        (Int64, Date32) => cast_with_options(
+            &cast_with_options(array, &Int32, cast_options)?,
+            &Date32,
+            cast_options,
+        ),
+        // No support for second/milliseconds with i64
+        (Int64, Time64(TimeUnit::Microsecond)) => {
+            cast_reinterpret_arrays::<Int64Type, Time64MicrosecondType>(array)
+        }
+        (Int64, Time64(TimeUnit::Nanosecond)) => {
+            cast_reinterpret_arrays::<Int64Type, Time64NanosecondType>(array)
+        }
+
+        (Date64, Int64) => cast_reinterpret_arrays::<Date64Type, Int64Type>(array),
+        (Date64, Int32) => cast_with_options(
+            &cast_with_options(array, &Int64, cast_options)?,
+            &Int32,
+            cast_options,
+        ),
+        (Time64(TimeUnit::Microsecond), Int64) => {
+            cast_reinterpret_arrays::<Time64MicrosecondType, Int64Type>(array)
+        }
+        (Time64(TimeUnit::Nanosecond), Int64) => {
+            cast_reinterpret_arrays::<Time64NanosecondType, Int64Type>(array)
+        }
+        (Date32, Date64) => Ok(Arc::new(
+            array
+                .as_primitive::<Date32Type>()
+                .unary::<_, Date64Type>(|x| x as i64 * MILLISECONDS_IN_DAY),
+        )),
+        (Date64, Date32) => Ok(Arc::new(
+            array
+                .as_primitive::<Date64Type>()
+                .unary::<_, Date32Type>(|x| (x / MILLISECONDS_IN_DAY) as i32),
+        )),
+
+        (Time32(TimeUnit::Second), Time32(TimeUnit::Millisecond)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time32SecondType>()
+                .unary::<_, Time32MillisecondType>(|x| x * MILLISECONDS as i32),
+        )),
+        (Time32(TimeUnit::Second), Time64(TimeUnit::Microsecond)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time32SecondType>()
+                .unary::<_, Time64MicrosecondType>(|x| x as i64 * MICROSECONDS),
+        )),
+        (Time32(TimeUnit::Second), Time64(TimeUnit::Nanosecond)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time32SecondType>()
+                .unary::<_, Time64NanosecondType>(|x| x as i64 * NANOSECONDS),
+        )),
+
+        (Time32(TimeUnit::Millisecond), Time32(TimeUnit::Second)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time32MillisecondType>()
+                .unary::<_, Time32SecondType>(|x| x / MILLISECONDS as i32),
+        )),
+        (Time32(TimeUnit::Millisecond), Time64(TimeUnit::Microsecond)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time32MillisecondType>()
+                .unary::<_, Time64MicrosecondType>(|x| x as i64 * (MICROSECONDS / MILLISECONDS)),
+        )),
+        (Time32(TimeUnit::Millisecond), Time64(TimeUnit::Nanosecond)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time32MillisecondType>()
+                .unary::<_, Time64NanosecondType>(|x| x as i64 * (MICROSECONDS / NANOSECONDS)),
+        )),
+
+        (Time64(TimeUnit::Microsecond), Time32(TimeUnit::Second)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time64MicrosecondType>()
+                .unary::<_, Time32SecondType>(|x| (x / MICROSECONDS) as i32),
+        )),
+        (Time64(TimeUnit::Microsecond), Time32(TimeUnit::Millisecond)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time64MicrosecondType>()
+                .unary::<_, Time32MillisecondType>(|x| (x / (MICROSECONDS / MILLISECONDS)) as i32),
+        )),
+        (Time64(TimeUnit::Microsecond), Time64(TimeUnit::Nanosecond)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time64MicrosecondType>()
+                .unary::<_, Time64NanosecondType>(|x| x * (NANOSECONDS / MICROSECONDS)),
+        )),
+
+        (Time64(TimeUnit::Nanosecond), Time32(TimeUnit::Second)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time64NanosecondType>()
+                .unary::<_, Time32SecondType>(|x| (x / NANOSECONDS) as i32),
+        )),
+        (Time64(TimeUnit::Nanosecond), Time32(TimeUnit::Millisecond)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time64NanosecondType>()
+                .unary::<_, Time32MillisecondType>(|x| (x / (NANOSECONDS / MILLISECONDS)) as i32),
+        )),
+        (Time64(TimeUnit::Nanosecond), Time64(TimeUnit::Microsecond)) => Ok(Arc::new(
+            array
+                .as_primitive::<Time64NanosecondType>()
+                .unary::<_, Time64MicrosecondType>(|x| x / (NANOSECONDS / MICROSECONDS)),
+        )),
+
+        // Timestamp to integer/floating/decimals
+        (Timestamp(TimeUnit::Second, _), _) if to_type.is_numeric() => {
+            let array = cast_reinterpret_arrays::<TimestampSecondType, Int64Type>(array)?;
+            cast_with_options(&array, to_type, cast_options)
+        }
+        (Timestamp(TimeUnit::Millisecond, _), _) if to_type.is_numeric() => {
+            let array = cast_reinterpret_arrays::<TimestampMillisecondType, Int64Type>(array)?;
+            cast_with_options(&array, to_type, cast_options)
+        }
+        (Timestamp(TimeUnit::Microsecond, _), _) if to_type.is_numeric() => {
+            let array = cast_reinterpret_arrays::<TimestampMicrosecondType, Int64Type>(array)?;
+            cast_with_options(&array, to_type, cast_options)
+        }
+        (Timestamp(TimeUnit::Nanosecond, _), _) if to_type.is_numeric() => {
+            let array = cast_reinterpret_arrays::<TimestampNanosecondType, Int64Type>(array)?;
+            cast_with_options(&array, to_type, cast_options)
+        }
+
+        (_, Timestamp(unit, tz)) if from_type.is_numeric() => {
+            let array = cast_with_options(array, &Int64, cast_options)?;
+            Ok(make_timestamp_array(
+                array.as_primitive(),
+                unit.clone(),
+                tz.clone(),
+            ))
+        }
+
+        (Timestamp(from_unit, from_tz), Timestamp(to_unit, to_tz)) => {
+            let array = cast_with_options(array, &Int64, cast_options)?;
+            let time_array = array.as_primitive::<Int64Type>();
+            let from_size = time_unit_multiple(from_unit);
+            let to_size = time_unit_multiple(to_unit);
+            // we either divide or multiply, depending on size of each unit
+            // units are never the same when the types are the same
+            let converted = match from_size.cmp(&to_size) {
+                Ordering::Greater => {
+                    let divisor = from_size / to_size;
+                    time_array.unary::<_, Int64Type>(|o| o / divisor)
+                }
+                Ordering::Equal => time_array.clone(),
+                Ordering::Less => {
+                    let mul = to_size / from_size;
+                    if cast_options.safe {
+                        time_array.unary_opt::<_, Int64Type>(|o| o.checked_mul(mul))
+                    } else {
+                        time_array.try_unary::<_, Int64Type, _>(|o| o.mul_checked(mul))?
+                    }
+                }
+            };
+            // Normalize timezone
+            let adjusted = match (from_tz, to_tz) {
+                // Only this case needs to be adjusted because we're casting from
+                // unknown time offset to some time offset, we want the time to be
+                // unchanged.
+                //
+                // i.e. Timestamp('2001-01-01T00:00', None) -> Timestamp('2001-01-01T00:00', '+0700')
+                (None, Some(to_tz)) => {
+                    let to_tz: Tz = to_tz.parse()?;
+                    match to_unit {
+                        TimeUnit::Second => adjust_timestamp_to_timezone::<TimestampSecondType>(
+                            converted,
+                            &to_tz,
+                            cast_options,
+                        )?,
+                        TimeUnit::Millisecond => adjust_timestamp_to_timezone::<
+                            TimestampMillisecondType,
+                        >(
+                            converted, &to_tz, cast_options
+                        )?,
+                        TimeUnit::Microsecond => adjust_timestamp_to_timezone::<
+                            TimestampMicrosecondType,
+                        >(
+                            converted, &to_tz, cast_options
+                        )?,
+                        TimeUnit::Nanosecond => adjust_timestamp_to_timezone::<
+                            TimestampNanosecondType,
+                        >(
+                            converted, &to_tz, cast_options
+                        )?,
+                    }
+                }
+                _ => converted,
+            };
+            Ok(make_timestamp_array(
+                &adjusted,
+                to_unit.clone(),
+                to_tz.clone(),
+            ))
+        }
+        (Timestamp(from_unit, _), Date32) => {
+            let array = cast_with_options(array, &Int64, cast_options)?;
+            let time_array = array.as_primitive::<Int64Type>();
+            let from_size = time_unit_multiple(from_unit) * SECONDS_IN_DAY;
+
+            let mut b = Date32Builder::with_capacity(array.len());
+
+            for i in 0..array.len() {
+                if time_array.is_null(i) {
+                    b.append_null();
+                } else {
+                    b.append_value(
+                        num::integer::div_floor::<i64>(time_array.value(i), from_size) as i32,
+                    );
+                }
+            }
+
+            Ok(Arc::new(b.finish()) as ArrayRef)
+        }
+        (Timestamp(TimeUnit::Second, _), Date64) => Ok(Arc::new(match cast_options.safe {
+            true => {
+                // change error to None
+                array
+                    .as_primitive::<TimestampSecondType>()
+                    .unary_opt::<_, Date64Type>(|x| x.checked_mul(MILLISECONDS))
+            }
+            false => array
+                .as_primitive::<TimestampSecondType>()
+                .try_unary::<_, Date64Type, _>(|x| x.mul_checked(MILLISECONDS))?,
+        })),
+        (Timestamp(TimeUnit::Millisecond, _), Date64) => {
+            cast_reinterpret_arrays::<TimestampMillisecondType, Date64Type>(array)
+        }
+        (Timestamp(TimeUnit::Microsecond, _), Date64) => Ok(Arc::new(
+            array
+                .as_primitive::<TimestampMicrosecondType>()
+                .unary::<_, Date64Type>(|x| x / (MICROSECONDS / MILLISECONDS)),
+        )),
+        (Timestamp(TimeUnit::Nanosecond, _), Date64) => Ok(Arc::new(
+            array
+                .as_primitive::<TimestampNanosecondType>()
+                .unary::<_, Date64Type>(|x| x / (NANOSECONDS / MILLISECONDS)),
+        )),
+        (Timestamp(TimeUnit::Second, tz), Time64(TimeUnit::Microsecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampSecondType>()
+                    .try_unary::<_, Time64MicrosecondType, ArrowError>(|x| {
+                        Ok(time_to_time64us(as_time_res_with_timezone::<
+                            TimestampSecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Second, tz), Time64(TimeUnit::Nanosecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampSecondType>()
+                    .try_unary::<_, Time64NanosecondType, ArrowError>(|x| {
+                        Ok(time_to_time64ns(as_time_res_with_timezone::<
+                            TimestampSecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Millisecond, tz), Time64(TimeUnit::Microsecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampMillisecondType>()
+                    .try_unary::<_, Time64MicrosecondType, ArrowError>(|x| {
+                        Ok(time_to_time64us(as_time_res_with_timezone::<
+                            TimestampMillisecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Millisecond, tz), Time64(TimeUnit::Nanosecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampMillisecondType>()
+                    .try_unary::<_, Time64NanosecondType, ArrowError>(|x| {
+                        Ok(time_to_time64ns(as_time_res_with_timezone::<
+                            TimestampMillisecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Microsecond, tz), Time64(TimeUnit::Microsecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampMicrosecondType>()
+                    .try_unary::<_, Time64MicrosecondType, ArrowError>(|x| {
+                        Ok(time_to_time64us(as_time_res_with_timezone::<
+                            TimestampMicrosecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Microsecond, tz), Time64(TimeUnit::Nanosecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampMicrosecondType>()
+                    .try_unary::<_, Time64NanosecondType, ArrowError>(|x| {
+                        Ok(time_to_time64ns(as_time_res_with_timezone::<
+                            TimestampMicrosecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Nanosecond, tz), Time64(TimeUnit::Microsecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampNanosecondType>()
+                    .try_unary::<_, Time64MicrosecondType, ArrowError>(|x| {
+                        Ok(time_to_time64us(as_time_res_with_timezone::<
+                            TimestampNanosecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Nanosecond, tz), Time64(TimeUnit::Nanosecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampNanosecondType>()
+                    .try_unary::<_, Time64NanosecondType, ArrowError>(|x| {
+                        Ok(time_to_time64ns(as_time_res_with_timezone::<
+                            TimestampNanosecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Second, tz), Time32(TimeUnit::Second)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampSecondType>()
+                    .try_unary::<_, Time32SecondType, ArrowError>(|x| {
+                        Ok(time_to_time32s(as_time_res_with_timezone::<
+                            TimestampSecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Second, tz), Time32(TimeUnit::Millisecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampSecondType>()
+                    .try_unary::<_, Time32MillisecondType, ArrowError>(|x| {
+                        Ok(time_to_time32ms(as_time_res_with_timezone::<
+                            TimestampSecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Millisecond, tz), Time32(TimeUnit::Second)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampMillisecondType>()
+                    .try_unary::<_, Time32SecondType, ArrowError>(|x| {
+                        Ok(time_to_time32s(as_time_res_with_timezone::<
+                            TimestampMillisecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Millisecond, tz), Time32(TimeUnit::Millisecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampMillisecondType>()
+                    .try_unary::<_, Time32MillisecondType, ArrowError>(|x| {
+                        Ok(time_to_time32ms(as_time_res_with_timezone::<
+                            TimestampMillisecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Microsecond, tz), Time32(TimeUnit::Second)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampMicrosecondType>()
+                    .try_unary::<_, Time32SecondType, ArrowError>(|x| {
+                        Ok(time_to_time32s(as_time_res_with_timezone::<
+                            TimestampMicrosecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Microsecond, tz), Time32(TimeUnit::Millisecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampMicrosecondType>()
+                    .try_unary::<_, Time32MillisecondType, ArrowError>(|x| {
+                        Ok(time_to_time32ms(as_time_res_with_timezone::<
+                            TimestampMicrosecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Nanosecond, tz), Time32(TimeUnit::Second)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampNanosecondType>()
+                    .try_unary::<_, Time32SecondType, ArrowError>(|x| {
+                        Ok(time_to_time32s(as_time_res_with_timezone::<
+                            TimestampNanosecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+        (Timestamp(TimeUnit::Nanosecond, tz), Time32(TimeUnit::Millisecond)) => {
+            let tz = tz.as_ref().map(|tz| tz.parse()).transpose()?;
+            Ok(Arc::new(
+                array
+                    .as_primitive::<TimestampNanosecondType>()
+                    .try_unary::<_, Time32MillisecondType, ArrowError>(|x| {
+                        Ok(time_to_time32ms(as_time_res_with_timezone::<
+                            TimestampNanosecondType,
+                        >(x, tz)?))
+                    })?,
+            ))
+        }
+
+        (Date64, Timestamp(TimeUnit::Second, None)) => Ok(Arc::new(
+            array
+                .as_primitive::<Date64Type>()
+                .unary::<_, TimestampSecondType>(|x| x / MILLISECONDS),
+        )),
+        (Date64, Timestamp(TimeUnit::Millisecond, None)) => {
+            cast_reinterpret_arrays::<Date64Type, TimestampMillisecondType>(array)
+        }
+        (Date64, Timestamp(TimeUnit::Microsecond, None)) => Ok(Arc::new(
+            array
+                .as_primitive::<Date64Type>()
+                .unary::<_, TimestampMicrosecondType>(|x| x * (MICROSECONDS / MILLISECONDS)),
+        )),
+        (Date64, Timestamp(TimeUnit::Nanosecond, None)) => Ok(Arc::new(
+            array
+                .as_primitive::<Date64Type>()
+                .unary::<_, TimestampNanosecondType>(|x| x * (NANOSECONDS / MILLISECONDS)),
+        )),
+        (Date32, Timestamp(TimeUnit::Second, None)) => Ok(Arc::new(
+            array
+                .as_primitive::<Date32Type>()
+                .unary::<_, TimestampSecondType>(|x| (x as i64) * SECONDS_IN_DAY),
+        )),
+        (Date32, Timestamp(TimeUnit::Millisecond, None)) => Ok(Arc::new(
+            array
+                .as_primitive::<Date32Type>()
+                .unary::<_, TimestampMillisecondType>(|x| (x as i64) * MILLISECONDS_IN_DAY),
+        )),
+        (Date32, Timestamp(TimeUnit::Microsecond, None)) => Ok(Arc::new(
+            array
+                .as_primitive::<Date32Type>()
+                .unary::<_, TimestampMicrosecondType>(|x| (x as i64) * MICROSECONDS_IN_DAY),
+        )),
+        (Date32, Timestamp(TimeUnit::Nanosecond, None)) => Ok(Arc::new(
+            array
+                .as_primitive::<Date32Type>()
+                .unary::<_, TimestampNanosecondType>(|x| (x as i64) * NANOSECONDS_IN_DAY),
+        )),
+        (Int64, Duration(TimeUnit::Second)) => {
+            cast_reinterpret_arrays::<Int64Type, DurationSecondType>(array)
+        }
+        (Int64, Duration(TimeUnit::Millisecond)) => {
+            cast_reinterpret_arrays::<Int64Type, DurationMillisecondType>(array)
+        }
+        (Int64, Duration(TimeUnit::Microsecond)) => {
+            cast_reinterpret_arrays::<Int64Type, DurationMicrosecondType>(array)
+        }
+        (Int64, Duration(TimeUnit::Nanosecond)) => {
+            cast_reinterpret_arrays::<Int64Type, DurationNanosecondType>(array)
+        }
+
+        (Duration(TimeUnit::Second), Int64) => {
+            cast_reinterpret_arrays::<DurationSecondType, Int64Type>(array)
+        }
+        (Duration(TimeUnit::Millisecond), Int64) => {
+            cast_reinterpret_arrays::<DurationMillisecondType, Int64Type>(array)
+        }
+        (Duration(TimeUnit::Microsecond), Int64) => {
+            cast_reinterpret_arrays::<DurationMicrosecondType, Int64Type>(array)
+        }
+        (Duration(TimeUnit::Nanosecond), Int64) => {
+            cast_reinterpret_arrays::<DurationNanosecondType, Int64Type>(array)
+        }
+        (Duration(TimeUnit::Second), Interval(IntervalUnit::MonthDayNano)) => {
+            cast_duration_to_interval::<DurationSecondType>(array, cast_options)
+        }
+        (Duration(TimeUnit::Millisecond), Interval(IntervalUnit::MonthDayNano)) => {
+            cast_duration_to_interval::<DurationMillisecondType>(array, cast_options)
+        }
+        (Duration(TimeUnit::Microsecond), Interval(IntervalUnit::MonthDayNano)) => {
+            cast_duration_to_interval::<DurationMicrosecondType>(array, cast_options)
+        }
+        (Duration(TimeUnit::Nanosecond), Interval(IntervalUnit::MonthDayNano)) => {
+            cast_duration_to_interval::<DurationNanosecondType>(array, cast_options)
+        }
+        (Interval(IntervalUnit::MonthDayNano), Duration(TimeUnit::Second)) => {
+            cast_month_day_nano_to_duration::<DurationSecondType>(array, cast_options)
+        }
+        (Interval(IntervalUnit::MonthDayNano), Duration(TimeUnit::Millisecond)) => {
+            cast_month_day_nano_to_duration::<DurationMillisecondType>(array, cast_options)
+        }
+        (Interval(IntervalUnit::MonthDayNano), Duration(TimeUnit::Microsecond)) => {
+            cast_month_day_nano_to_duration::<DurationMicrosecondType>(array, cast_options)
+        }
+        (Interval(IntervalUnit::MonthDayNano), Duration(TimeUnit::Nanosecond)) => {
+            cast_month_day_nano_to_duration::<DurationNanosecondType>(array, cast_options)
+        }
+        (Interval(IntervalUnit::YearMonth), Interval(IntervalUnit::MonthDayNano)) => {
+            cast_interval_year_month_to_interval_month_day_nano(array, cast_options)
+        }
+        (Interval(IntervalUnit::DayTime), Interval(IntervalUnit::MonthDayNano)) => {
+            cast_interval_day_time_to_interval_month_day_nano(array, cast_options)
+        }
+        (Interval(IntervalUnit::YearMonth), Int64) => {
+            cast_numeric_arrays::<IntervalYearMonthType, Int64Type>(array, cast_options)
+        }
+        (Interval(IntervalUnit::DayTime), Int64) => {
+            cast_reinterpret_arrays::<IntervalDayTimeType, Int64Type>(array)
+        }
+        (Int32, Interval(IntervalUnit::YearMonth)) => {
+            cast_reinterpret_arrays::<Int32Type, IntervalYearMonthType>(array)
+        }
+        (Int64, Interval(IntervalUnit::DayTime)) => {
+            cast_reinterpret_arrays::<Int64Type, IntervalDayTimeType>(array)
+        }
+        (_, _) => Err(ArrowError::CastError(format!(
+            "Casting from {from_type:?} to {to_type:?} not supported",
+        ))),
+    }
+}
+
+/// Get the time unit as a multiple of a second
+const fn time_unit_multiple(unit: &TimeUnit) -> i64 {
+    match unit {
+        TimeUnit::Second => 1,
+        TimeUnit::Millisecond => MILLISECONDS,
+        TimeUnit::Microsecond => MICROSECONDS,
+        TimeUnit::Nanosecond => NANOSECONDS,
+    }
+}
+
+/// A utility trait that provides checked conversions between
+/// decimal types inspired by [`NumCast`]
+trait DecimalCast: Sized {
+    fn to_i128(self) -> Option<i128>;
+
+    fn to_i256(self) -> Option<i256>;
+
+    fn from_decimal<T: DecimalCast>(n: T) -> Option<Self>;
+}
+
+impl DecimalCast for i128 {
+    fn to_i128(self) -> Option<i128> {
+        Some(self)
+    }
+
+    fn to_i256(self) -> Option<i256> {
+        Some(i256::from_i128(self))
+    }
+
+    fn from_decimal<T: DecimalCast>(n: T) -> Option<Self> {
+        n.to_i128()
+    }
+}
+
+impl DecimalCast for i256 {
+    fn to_i128(self) -> Option<i128> {
+        self.to_i128()
+    }
+
+    fn to_i256(self) -> Option<i256> {
+        Some(self)
+    }
+
+    fn from_decimal<T: DecimalCast>(n: T) -> Option<Self> {
+        n.to_i256()
+    }
+}
+
+fn cast_decimal_to_decimal_error<I, O>(
+    output_precision: u8,
+    output_scale: i8,
+) -> impl Fn(<I as ArrowPrimitiveType>::Native) -> ArrowError
+where
+    I: DecimalType,
+    O: DecimalType,
+    I::Native: DecimalCast + ArrowNativeTypeOp,
+    O::Native: DecimalCast + ArrowNativeTypeOp,
+{
+    move |x: I::Native| {
+        ArrowError::CastError(format!(
+            "Cannot cast to {}({}, {}). Overflowing on {:?}",
+            O::PREFIX,
+            output_precision,
+            output_scale,
+            x
+        ))
+    }
+}
+
+fn convert_to_smaller_scale_decimal<I, O>(
+    array: &PrimitiveArray<I>,
+    input_scale: i8,
+    output_precision: u8,
+    output_scale: i8,
+    cast_options: &CastOptions,
+) -> Result<PrimitiveArray<O>, ArrowError>
+where
+    I: DecimalType,
+    O: DecimalType,
+    I::Native: DecimalCast + ArrowNativeTypeOp,
+    O::Native: DecimalCast + ArrowNativeTypeOp,
+{
+    let error = cast_decimal_to_decimal_error::<I, O>(output_precision, output_scale);
+    let div = I::Native::from_decimal(10_i128)
+        .unwrap()
+        .pow_checked((input_scale - output_scale) as u32)?;
+
+    let half = div.div_wrapping(I::Native::from_usize(2).unwrap());
+    let half_neg = half.neg_wrapping();
+
+    let f = |x: I::Native| {
+        // div is >= 10 and so this cannot overflow
+        let d = x.div_wrapping(div);
+        let r = x.mod_wrapping(div);
+
+        // Round result
+        let adjusted = match x >= I::Native::ZERO {
+            true if r >= half => d.add_wrapping(I::Native::ONE),
+            false if r <= half_neg => d.sub_wrapping(I::Native::ONE),
+            _ => d,
+        };
+        O::Native::from_decimal(adjusted)
+    };
+
+    Ok(match cast_options.safe {
+        true => array.unary_opt(f),
+        false => array.try_unary(|x| f(x).ok_or_else(|| error(x)))?,
+    })
+}
+
+fn convert_to_bigger_or_equal_scale_decimal<I, O>(
+    array: &PrimitiveArray<I>,
+    input_scale: i8,
+    output_precision: u8,
+    output_scale: i8,
+    cast_options: &CastOptions,
+) -> Result<PrimitiveArray<O>, ArrowError>
+where
+    I: DecimalType,
+    O: DecimalType,
+    I::Native: DecimalCast + ArrowNativeTypeOp,
+    O::Native: DecimalCast + ArrowNativeTypeOp,
+{
+    let error = cast_decimal_to_decimal_error::<I, O>(output_precision, output_scale);
+    let mul = O::Native::from_decimal(10_i128)
+        .unwrap()
+        .pow_checked((output_scale - input_scale) as u32)?;
+
+    let f = |x| O::Native::from_decimal(x).and_then(|x| x.mul_checked(mul).ok());
+
+    Ok(match cast_options.safe {
+        true => array.unary_opt(f),
+        false => array.try_unary(|x| f(x).ok_or_else(|| error(x)))?,
+    })
+}
+
+// Only support one type of decimal cast operations
+fn cast_decimal_to_decimal_same_type<T>(
+    array: &PrimitiveArray<T>,
+    input_scale: i8,
+    output_precision: u8,
+    output_scale: i8,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    T: DecimalType,
+    T::Native: DecimalCast + ArrowNativeTypeOp,
+{
+    let array: PrimitiveArray<T> = match input_scale.cmp(&output_scale) {
+        Ordering::Equal => {
+            // the scale doesn't change, the native value don't need to be changed
+            array.clone()
+        }
+        Ordering::Greater => convert_to_smaller_scale_decimal::<T, T>(
+            array,
+            input_scale,
+            output_precision,
+            output_scale,
+            cast_options,
+        )?,
+        Ordering::Less => {
+            // input_scale < output_scale
+            convert_to_bigger_or_equal_scale_decimal::<T, T>(
+                array,
+                input_scale,
+                output_precision,
+                output_scale,
+                cast_options,
+            )?
+        }
+    };
+
+    Ok(Arc::new(array.with_precision_and_scale(
+        output_precision,
+        output_scale,
+    )?))
+}
+
+// Support two different types of decimal cast operations
+fn cast_decimal_to_decimal<I, O>(
+    array: &PrimitiveArray<I>,
+    input_scale: i8,
+    output_precision: u8,
+    output_scale: i8,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    I: DecimalType,
+    O: DecimalType,
+    I::Native: DecimalCast + ArrowNativeTypeOp,
+    O::Native: DecimalCast + ArrowNativeTypeOp,
+{
+    let array: PrimitiveArray<O> = if input_scale > output_scale {
+        convert_to_smaller_scale_decimal::<I, O>(
+            array,
+            input_scale,
+            output_precision,
+            output_scale,
+            cast_options,
+        )?
+    } else {
+        convert_to_bigger_or_equal_scale_decimal::<I, O>(
+            array,
+            input_scale,
+            output_precision,
+            output_scale,
+            cast_options,
+        )?
+    };
+
+    Ok(Arc::new(array.with_precision_and_scale(
+        output_precision,
+        output_scale,
+    )?))
+}
+
+/// Convert Array into a PrimitiveArray of type, and apply numeric cast
+fn cast_numeric_arrays<FROM, TO>(
+    from: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    FROM: ArrowPrimitiveType,
+    TO: ArrowPrimitiveType,
+    FROM::Native: NumCast,
+    TO::Native: NumCast,
+{
+    if cast_options.safe {
+        // If the value can't be casted to the `TO::Native`, return null
+        Ok(Arc::new(numeric_cast::<FROM, TO>(
+            from.as_primitive::<FROM>(),
+        )))
+    } else {
+        // If the value can't be casted to the `TO::Native`, return error
+        Ok(Arc::new(try_numeric_cast::<FROM, TO>(
+            from.as_primitive::<FROM>(),
+        )?))
+    }
+}
+
+// Natural cast between numeric types
+// If the value of T can't be casted to R, will throw error
+fn try_numeric_cast<T, R>(from: &PrimitiveArray<T>) -> Result<PrimitiveArray<R>, ArrowError>
+where
+    T: ArrowPrimitiveType,
+    R: ArrowPrimitiveType,
+    T::Native: NumCast,
+    R::Native: NumCast,
+{
+    from.try_unary(|value| {
+        num::cast::cast::<T::Native, R::Native>(value).ok_or_else(|| {
+            ArrowError::CastError(format!(
+                "Can't cast value {:?} to type {}",
+                value,
+                R::DATA_TYPE
+            ))
+        })
+    })
+}
+
+// Natural cast between numeric types
+// If the value of T can't be casted to R, it will be converted to null
+fn numeric_cast<T, R>(from: &PrimitiveArray<T>) -> PrimitiveArray<R>
+where
+    T: ArrowPrimitiveType,
+    R: ArrowPrimitiveType,
+    T::Native: NumCast,
+    R::Native: NumCast,
+{
+    from.unary_opt::<_, R>(num::cast::cast::<T::Native, R::Native>)
+}
+
+fn value_to_string<O: OffsetSizeTrait>(
+    array: &dyn Array,
+    options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let mut builder = GenericStringBuilder::<O>::new();
+    let formatter = ArrayFormatter::try_new(array, &options.format_options)?;
+    let nulls = array.nulls();
+    for i in 0..array.len() {
+        match nulls.map(|x| x.is_null(i)).unwrap_or_default() {
+            true => builder.append_null(),
+            false => {
+                formatter.value(i).write(&mut builder)?;
+                // tell the builder the row is finished
+                builder.append_value("");
+            }
+        }
+    }
+    Ok(Arc::new(builder.finish()))
+}
+
+fn cast_numeric_to_binary<FROM: ArrowPrimitiveType, O: OffsetSizeTrait>(
+    array: &dyn Array,
+) -> Result<ArrayRef, ArrowError> {
+    let array = array.as_primitive::<FROM>();
+    let size = std::mem::size_of::<FROM::Native>();
+    let offsets = OffsetBuffer::from_lengths(std::iter::repeat(size).take(array.len()));
+    Ok(Arc::new(GenericBinaryArray::<O>::new(
+        offsets,
+        array.values().inner().clone(),
+        array.nulls().cloned(),
+    )))
+}
+
+/// Parse UTF-8
+fn parse_string<P: Parser, O: OffsetSizeTrait>(
+    array: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let string_array = array.as_string::<O>();
+    let array = if cast_options.safe {
+        let iter = string_array.iter().map(|x| x.and_then(P::parse));
+
+        // Benefit:
+        //     20% performance improvement
+        // Soundness:
+        //     The iterator is trustedLen because it comes from an `StringArray`.
+        unsafe { PrimitiveArray::<P>::from_trusted_len_iter(iter) }
+    } else {
+        let v = string_array
+            .iter()
+            .map(|x| match x {
+                Some(v) => P::parse(v).ok_or_else(|| {
+                    ArrowError::CastError(format!(
+                        "Cannot cast string '{}' to value of {:?} type",
+                        v,
+                        P::DATA_TYPE
+                    ))
+                }),
+                None => Ok(P::Native::default()),
+            })
+            .collect::<Result<Vec<_>, ArrowError>>()?;
+        PrimitiveArray::new(v.into(), string_array.nulls().cloned())
+    };
+
+    Ok(Arc::new(array) as ArrayRef)
+}
+
+/// Casts generic string arrays to an ArrowTimestampType (TimeStampNanosecondArray, etc.)
+fn cast_string_to_timestamp<O: OffsetSizeTrait, T: ArrowTimestampType>(
+    array: &dyn Array,
+    to_tz: &Option<Arc<str>>,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let array = array.as_string::<O>();
+    let out: PrimitiveArray<T> = match to_tz {
+        Some(tz) => {
+            let tz: Tz = tz.as_ref().parse()?;
+            cast_string_to_timestamp_impl(array, &tz, cast_options)?
+        }
+        None => cast_string_to_timestamp_impl(array, &Utc, cast_options)?,
+    };
+    Ok(Arc::new(out.with_timezone_opt(to_tz.clone())))
+}
+
+fn cast_string_to_timestamp_impl<O: OffsetSizeTrait, T: ArrowTimestampType, Tz: TimeZone>(
+    array: &GenericStringArray<O>,
+    tz: &Tz,
+    cast_options: &CastOptions,
+) -> Result<PrimitiveArray<T>, ArrowError> {
+    if cast_options.safe {
+        let iter = array.iter().map(|v| {
+            v.and_then(|v| {
+                let naive = string_to_datetime(tz, v).ok()?.naive_utc();
+                T::make_value(naive)
+            })
+        });
+        // Benefit:
+        //     20% performance improvement
+        // Soundness:
+        //     The iterator is trustedLen because it comes from an `StringArray`.
+
+        Ok(unsafe { PrimitiveArray::from_trusted_len_iter(iter) })
+    } else {
+        let vec = array
+            .iter()
+            .map(|v| {
+                v.map(|v| {
+                    let naive = string_to_datetime(tz, v)?.naive_utc();
+                    T::make_value(naive).ok_or_else(|| {
+                        ArrowError::CastError(format!(
+                            "Overflow converting {naive} to {:?}",
+                            T::UNIT
+                        ))
+                    })
+                })
+                .transpose()
+            })
+            .collect::<Result<Vec<Option<i64>>, _>>()?;
+
+        // Benefit:
+        //     20% performance improvement
+        // Soundness:
+        //     The iterator is trustedLen because it comes from an `StringArray`.
+        Ok(unsafe { PrimitiveArray::from_trusted_len_iter(vec.iter()) })
+    }
+}
+
+fn cast_string_to_interval<Offset, F, ArrowType>(
+    array: &dyn Array,
+    cast_options: &CastOptions,
+    parse_function: F,
+) -> Result<ArrayRef, ArrowError>
+where
+    Offset: OffsetSizeTrait,
+    ArrowType: ArrowPrimitiveType,
+    F: Fn(&str) -> Result<ArrowType::Native, ArrowError> + Copy,
+{
+    let string_array = array
+        .as_any()
+        .downcast_ref::<GenericStringArray<Offset>>()
+        .unwrap();
+    let interval_array = if cast_options.safe {
+        let iter = string_array
+            .iter()
+            .map(|v| v.and_then(|v| parse_function(v).ok()));
+
+        // Benefit:
+        //     20% performance improvement
+        // Soundness:
+        //     The iterator is trustedLen because it comes from an `StringArray`.
+        unsafe { PrimitiveArray::<ArrowType>::from_trusted_len_iter(iter) }
+    } else {
+        let vec = string_array
+            .iter()
+            .map(|v| v.map(parse_function).transpose())
+            .collect::<Result<Vec<_>, ArrowError>>()?;
+
+        // Benefit:
+        //     20% performance improvement
+        // Soundness:
+        //     The iterator is trustedLen because it comes from an `StringArray`.
+        unsafe { PrimitiveArray::<ArrowType>::from_trusted_len_iter(vec) }
+    };
+    Ok(Arc::new(interval_array) as ArrayRef)
+}
+
+fn cast_string_to_year_month_interval<Offset: OffsetSizeTrait>(
+    array: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    cast_string_to_interval::<Offset, _, IntervalYearMonthType>(
+        array,
+        cast_options,
+        parse_interval_year_month,
+    )
+}
+
+fn cast_string_to_day_time_interval<Offset: OffsetSizeTrait>(
+    array: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    cast_string_to_interval::<Offset, _, IntervalDayTimeType>(
+        array,
+        cast_options,
+        parse_interval_day_time,
+    )
+}
+
+fn cast_string_to_month_day_nano_interval<Offset: OffsetSizeTrait>(
+    array: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    cast_string_to_interval::<Offset, _, IntervalMonthDayNanoType>(
+        array,
+        cast_options,
+        parse_interval_month_day_nano,
+    )
+}
+
+fn adjust_timestamp_to_timezone<T: ArrowTimestampType>(
+    array: PrimitiveArray<Int64Type>,
+    to_tz: &Tz,
+    cast_options: &CastOptions,
+) -> Result<PrimitiveArray<Int64Type>, ArrowError> {
+    let adjust = |o| {
+        let local = as_datetime::<T>(o)?;
+        let offset = to_tz.offset_from_local_datetime(&local).single()?;
+        T::make_value(local - offset.fix())
+    };
+    let adjusted = if cast_options.safe {
+        array.unary_opt::<_, Int64Type>(adjust)
+    } else {
+        array.try_unary::<_, Int64Type, _>(|o| {
+            adjust(o).ok_or_else(|| {
+                ArrowError::CastError("Cannot cast timezone to different timezone".to_string())
+            })
+        })?
+    };
+    Ok(adjusted)
+}
+
+/// Casts Utf8 to Boolean
+fn cast_utf8_to_boolean<OffsetSize>(
+    from: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    OffsetSize: OffsetSizeTrait,
+{
+    let array = from
+        .as_any()
+        .downcast_ref::<GenericStringArray<OffsetSize>>()
+        .unwrap();
+
+    let output_array = array
+        .iter()
+        .map(|value| match value {
+            Some(value) => match value.to_ascii_lowercase().trim() {
+                "t" | "tr" | "tru" | "true" | "y" | "ye" | "yes" | "on" | "1" => Ok(Some(true)),
+                "f" | "fa" | "fal" | "fals" | "false" | "n" | "no" | "of" | "off" | "0" => {
+                    Ok(Some(false))
+                }
+                invalid_value => match cast_options.safe {
+                    true => Ok(None),
+                    false => Err(ArrowError::CastError(format!(
+                        "Cannot cast value '{invalid_value}' to value of Boolean type",
+                    ))),
+                },
+            },
+            None => Ok(None),
+        })
+        .collect::<Result<BooleanArray, _>>()?;
+
+    Ok(Arc::new(output_array))
+}
+
+/// Parses given string to specified decimal native (i128/i256) based on given
+/// scale. Returns an `Err` if it cannot parse given string.
+fn parse_string_to_decimal_native<T: DecimalType>(
+    value_str: &str,
+    scale: usize,
+) -> Result<T::Native, ArrowError>
+where
+    T::Native: DecimalCast + ArrowNativeTypeOp,
+{
+    let value_str = value_str.trim();
+    let parts: Vec<&str> = value_str.split('.').collect();
+    if parts.len() > 2 {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "Invalid decimal format: {value_str:?}"
+        )));
+    }
+
+    let (negative, first_part) = if parts[0].is_empty() {
+        (false, parts[0])
+    } else {
+        match parts[0].as_bytes()[0] {
+            b'-' => (true, &parts[0][1..]),
+            b'+' => (false, &parts[0][1..]),
+            _ => (false, parts[0]),
+        }
+    };
+
+    let integers = first_part.trim_start_matches('0');
+    let decimals = if parts.len() == 2 { parts[1] } else { "" };
+
+    if !integers.is_empty() && !integers.as_bytes()[0].is_ascii_digit() {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "Invalid decimal format: {value_str:?}"
+        )));
+    }
+
+    if !decimals.is_empty() && !decimals.as_bytes()[0].is_ascii_digit() {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "Invalid decimal format: {value_str:?}"
+        )));
+    }
+
+    // Adjust decimal based on scale
+    let mut number_decimals = if decimals.len() > scale {
+        let decimal_number = i256::from_string(decimals).ok_or_else(|| {
+            ArrowError::InvalidArgumentError(format!("Cannot parse decimal format: {value_str}"))
+        })?;
+
+        let div = i256::from_i128(10_i128).pow_checked((decimals.len() - scale) as u32)?;
+
+        let half = div.div_wrapping(i256::from_i128(2));
+        let half_neg = half.neg_wrapping();
+
+        let d = decimal_number.div_wrapping(div);
+        let r = decimal_number.mod_wrapping(div);
+
+        // Round result
+        let adjusted = match decimal_number >= i256::ZERO {
+            true if r >= half => d.add_wrapping(i256::ONE),
+            false if r <= half_neg => d.sub_wrapping(i256::ONE),
+            _ => d,
+        };
+
+        let integers = if !integers.is_empty() {
+            i256::from_string(integers)
+                .ok_or_else(|| {
+                    ArrowError::InvalidArgumentError(format!(
+                        "Cannot parse decimal format: {value_str}"
+                    ))
+                })
+                .map(|v| v.mul_wrapping(i256::from_i128(10_i128).pow_wrapping(scale as u32)))?
+        } else {
+            i256::ZERO
+        };
+
+        format!("{}", integers.add_wrapping(adjusted))
+    } else {
+        let padding = if scale > decimals.len() { scale } else { 0 };
+
+        let decimals = format!("{decimals:0<padding$}");
+        format!("{integers}{decimals}")
+    };
+
+    if negative {
+        number_decimals.insert(0, '-');
+    }
+
+    let value = i256::from_string(number_decimals.as_str()).ok_or_else(|| {
+        ArrowError::InvalidArgumentError(format!(
+            "Cannot convert {} to {}: Overflow",
+            value_str,
+            T::PREFIX
+        ))
+    })?;
+
+    T::Native::from_decimal(value).ok_or_else(|| {
+        ArrowError::InvalidArgumentError(format!("Cannot convert {} to {}", value_str, T::PREFIX))
+    })
+}
+
+fn string_to_decimal_cast<T, Offset: OffsetSizeTrait>(
+    from: &GenericStringArray<Offset>,
+    precision: u8,
+    scale: i8,
+    cast_options: &CastOptions,
+) -> Result<PrimitiveArray<T>, ArrowError>
+where
+    T: DecimalType,
+    T::Native: DecimalCast + ArrowNativeTypeOp,
+{
+    if cast_options.safe {
+        let iter = from.iter().map(|v| {
+            v.and_then(|v| parse_string_to_decimal_native::<T>(v, scale as usize).ok())
+                .and_then(|v| {
+                    T::validate_decimal_precision(v, precision)
+                        .is_ok()
+                        .then_some(v)
+                })
+        });
+        // Benefit:
+        //     20% performance improvement
+        // Soundness:
+        //     The iterator is trustedLen because it comes from an `StringArray`.
+        Ok(unsafe {
+            PrimitiveArray::<T>::from_trusted_len_iter(iter)
+                .with_precision_and_scale(precision, scale)?
+        })
+    } else {
+        let vec = from
+            .iter()
+            .map(|v| {
+                v.map(|v| {
+                    parse_string_to_decimal_native::<T>(v, scale as usize)
+                        .map_err(|_| {
+                            ArrowError::CastError(format!(
+                                "Cannot cast string '{}' to value of {:?} type",
+                                v,
+                                T::DATA_TYPE,
+                            ))
+                        })
+                        .and_then(|v| T::validate_decimal_precision(v, precision).map(|_| v))
+                })
+                .transpose()
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        // Benefit:
+        //     20% performance improvement
+        // Soundness:
+        //     The iterator is trustedLen because it comes from an `StringArray`.
+        Ok(unsafe {
+            PrimitiveArray::<T>::from_trusted_len_iter(vec.iter())
+                .with_precision_and_scale(precision, scale)?
+        })
+    }
+}
+
+/// Cast Utf8 to decimal
+fn cast_string_to_decimal<T, Offset: OffsetSizeTrait>(
+    from: &dyn Array,
+    precision: u8,
+    scale: i8,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    T: DecimalType,
+    T::Native: DecimalCast + ArrowNativeTypeOp,
+{
+    if scale < 0 {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "Cannot cast string to decimal with negative scale {scale}"
+        )));
+    }
+
+    if scale > T::MAX_SCALE {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "Cannot cast string to decimal greater than maximum scale {}",
+            T::MAX_SCALE
+        )));
+    }
+
+    Ok(Arc::new(string_to_decimal_cast::<T, Offset>(
+        from.as_any()
+            .downcast_ref::<GenericStringArray<Offset>>()
+            .unwrap(),
+        precision,
+        scale,
+        cast_options,
+    )?))
+}
+
+/// Cast numeric types to Boolean
+///
+/// Any zero value returns `false` while non-zero returns `true`
+fn cast_numeric_to_bool<FROM>(from: &dyn Array) -> Result<ArrayRef, ArrowError>
+where
+    FROM: ArrowPrimitiveType,
+{
+    numeric_to_bool_cast::<FROM>(from.as_primitive::<FROM>()).map(|to| Arc::new(to) as ArrayRef)
+}
+
+fn numeric_to_bool_cast<T>(from: &PrimitiveArray<T>) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowPrimitiveType + ArrowPrimitiveType,
+{
+    let mut b = BooleanBuilder::with_capacity(from.len());
+
+    for i in 0..from.len() {
+        if from.is_null(i) {
+            b.append_null();
+        } else if from.value(i) != T::default_value() {
+            b.append_value(true);
+        } else {
+            b.append_value(false);
+        }
+    }
+
+    Ok(b.finish())
+}
+
+/// Cast Boolean types to numeric
+///
+/// `false` returns 0 while `true` returns 1
+fn cast_bool_to_numeric<TO>(
+    from: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    TO: ArrowPrimitiveType,
+    TO::Native: num::cast::NumCast,
+{
+    Ok(Arc::new(bool_to_numeric_cast::<TO>(
+        from.as_any().downcast_ref::<BooleanArray>().unwrap(),
+        cast_options,
+    )))
+}
+
+fn bool_to_numeric_cast<T>(from: &BooleanArray, _cast_options: &CastOptions) -> PrimitiveArray<T>
+where
+    T: ArrowPrimitiveType,
+    T::Native: num::NumCast,
+{
+    let iter = (0..from.len()).map(|i| {
+        if from.is_null(i) {
+            None
+        } else if from.value(i) {
+            // a workaround to cast a primitive to T::Native, infallible
+            num::cast::cast(1)
+        } else {
+            Some(T::default_value())
+        }
+    });
+    // Benefit:
+    //     20% performance improvement
+    // Soundness:
+    //     The iterator is trustedLen because it comes from a Range
+    unsafe { PrimitiveArray::<T>::from_trusted_len_iter(iter) }
+}
+
+/// Attempts to cast an `ArrayDictionary` with index type K into
+/// `to_type` for supported types.
+///
+/// K is the key type
+fn dictionary_cast<K: ArrowDictionaryKeyType>(
+    array: &dyn Array,
+    to_type: &DataType,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    use DataType::*;
+
+    match to_type {
+        Dictionary(to_index_type, to_value_type) => {
+            let dict_array = array
+                .as_any()
+                .downcast_ref::<DictionaryArray<K>>()
+                .ok_or_else(|| {
+                    ArrowError::ComputeError(
+                        "Internal Error: Cannot cast dictionary to DictionaryArray of expected type".to_string(),
+                    )
+                })?;
+
+            let keys_array: ArrayRef =
+                Arc::new(PrimitiveArray::<K>::from(dict_array.keys().to_data()));
+            let values_array = dict_array.values();
+            let cast_keys = cast_with_options(&keys_array, to_index_type, cast_options)?;
+            let cast_values = cast_with_options(values_array, to_value_type, cast_options)?;
+
+            // Failure to cast keys (because they don't fit in the
+            // target type) results in NULL values;
+            if cast_keys.null_count() > keys_array.null_count() {
+                return Err(ArrowError::ComputeError(format!(
+                    "Could not convert {} dictionary indexes from {:?} to {:?}",
+                    cast_keys.null_count() - keys_array.null_count(),
+                    keys_array.data_type(),
+                    to_index_type
+                )));
+            }
+
+            let data = cast_keys.into_data();
+            let builder = data
+                .into_builder()
+                .data_type(to_type.clone())
+                .child_data(vec![cast_values.into_data()]);
+
+            // Safety
+            // Cast keys are still valid
+            let data = unsafe { builder.build_unchecked() };
+
+            // create the appropriate array type
+            let new_array: ArrayRef = match **to_index_type {
+                Int8 => Arc::new(DictionaryArray::<Int8Type>::from(data)),
+                Int16 => Arc::new(DictionaryArray::<Int16Type>::from(data)),
+                Int32 => Arc::new(DictionaryArray::<Int32Type>::from(data)),
+                Int64 => Arc::new(DictionaryArray::<Int64Type>::from(data)),
+                UInt8 => Arc::new(DictionaryArray::<UInt8Type>::from(data)),
+                UInt16 => Arc::new(DictionaryArray::<UInt16Type>::from(data)),
+                UInt32 => Arc::new(DictionaryArray::<UInt32Type>::from(data)),
+                UInt64 => Arc::new(DictionaryArray::<UInt64Type>::from(data)),
+                _ => {
+                    return Err(ArrowError::CastError(format!(
+                        "Unsupported type {to_index_type:?} for dictionary index"
+                    )));
+                }
+            };
+
+            Ok(new_array)
+        }
+        _ => unpack_dictionary::<K>(array, to_type, cast_options),
+    }
+}
+
+// Unpack a dictionary where the keys are of type <K> into a flattened array of type to_type
+fn unpack_dictionary<K>(
+    array: &dyn Array,
+    to_type: &DataType,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    K: ArrowDictionaryKeyType,
+{
+    let dict_array = array.as_dictionary::<K>();
+    let cast_dict_values = cast_with_options(dict_array.values(), to_type, cast_options)?;
+    take(cast_dict_values.as_ref(), dict_array.keys(), None)
+}
+
+/// Attempts to encode an array into an `ArrayDictionary` with index
+/// type K and value (dictionary) type value_type
+///
+/// K is the key type
+fn cast_to_dictionary<K: ArrowDictionaryKeyType>(
+    array: &dyn Array,
+    dict_value_type: &DataType,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    use DataType::*;
+
+    match *dict_value_type {
+        Int8 => pack_numeric_to_dictionary::<K, Int8Type>(array, dict_value_type, cast_options),
+        Int16 => pack_numeric_to_dictionary::<K, Int16Type>(array, dict_value_type, cast_options),
+        Int32 => pack_numeric_to_dictionary::<K, Int32Type>(array, dict_value_type, cast_options),
+        Int64 => pack_numeric_to_dictionary::<K, Int64Type>(array, dict_value_type, cast_options),
+        UInt8 => pack_numeric_to_dictionary::<K, UInt8Type>(array, dict_value_type, cast_options),
+        UInt16 => pack_numeric_to_dictionary::<K, UInt16Type>(array, dict_value_type, cast_options),
+        UInt32 => pack_numeric_to_dictionary::<K, UInt32Type>(array, dict_value_type, cast_options),
+        UInt64 => pack_numeric_to_dictionary::<K, UInt64Type>(array, dict_value_type, cast_options),
+        Decimal128(_, _) => {
+            pack_numeric_to_dictionary::<K, Decimal128Type>(array, dict_value_type, cast_options)
+        }
+        Decimal256(_, _) => {
+            pack_numeric_to_dictionary::<K, Decimal256Type>(array, dict_value_type, cast_options)
+        }
+        Utf8 => pack_byte_to_dictionary::<K, GenericStringType<i32>>(array, cast_options),
+        LargeUtf8 => pack_byte_to_dictionary::<K, GenericStringType<i64>>(array, cast_options),
+        Binary => pack_byte_to_dictionary::<K, GenericBinaryType<i32>>(array, cast_options),
+        LargeBinary => pack_byte_to_dictionary::<K, GenericBinaryType<i64>>(array, cast_options),
+        _ => Err(ArrowError::CastError(format!(
+            "Unsupported output type for dictionary packing: {dict_value_type:?}"
+        ))),
+    }
+}
+
+// Packs the data from the primitive array of type <V> to a
+// DictionaryArray with keys of type K and values of value_type V
+fn pack_numeric_to_dictionary<K, V>(
+    array: &dyn Array,
+    dict_value_type: &DataType,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    K: ArrowDictionaryKeyType,
+    V: ArrowPrimitiveType,
+{
+    // attempt to cast the source array values to the target value type (the dictionary values type)
+    let cast_values = cast_with_options(array, dict_value_type, cast_options)?;
+    let values = cast_values.as_primitive::<V>();
+
+    let mut b = PrimitiveDictionaryBuilder::<K, V>::with_capacity(values.len(), values.len());
+
+    // copy each element one at a time
+    for i in 0..values.len() {
+        if values.is_null(i) {
+            b.append_null();
+        } else {
+            b.append(values.value(i))?;
+        }
+    }
+    Ok(Arc::new(b.finish()))
+}
+
+// Packs the data as a GenericByteDictionaryBuilder, if possible, with the
+// key types of K
+fn pack_byte_to_dictionary<K, T>(
+    array: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    K: ArrowDictionaryKeyType,
+    T: ByteArrayType,
+{
+    let cast_values = cast_with_options(array, &T::DATA_TYPE, cast_options)?;
+    let values = cast_values
+        .as_any()
+        .downcast_ref::<GenericByteArray<T>>()
+        .unwrap();
+    let mut b = GenericByteDictionaryBuilder::<K, T>::with_capacity(values.len(), 1024, 1024);
+
+    // copy each element one at a time
+    for i in 0..values.len() {
+        if values.is_null(i) {
+            b.append_null();
+        } else {
+            b.append(values.value(i))?;
+        }
+    }
+    Ok(Arc::new(b.finish()))
+}
+
+/// Helper function that takes a primitive array and casts to a (generic) list array.
+fn cast_values_to_list<O: OffsetSizeTrait>(
+    array: &dyn Array,
+    to: &FieldRef,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let values = cast_with_options(array, to.data_type(), cast_options)?;
+    let offsets = OffsetBuffer::from_lengths(std::iter::repeat(1).take(values.len()));
+    let list = GenericListArray::<O>::new(to.clone(), offsets, values, None);
+    Ok(Arc::new(list))
+}
+
+/// Helper function that takes a primitive array and casts to a fixed size list array.
+fn cast_values_to_fixed_size_list(
+    array: &dyn Array,
+    to: &FieldRef,
+    size: i32,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let values = cast_with_options(array, to.data_type(), cast_options)?;
+    let list = FixedSizeListArray::new(to.clone(), size, values, None);
+    Ok(Arc::new(list))
+}
+
+/// A specified helper to cast from `GenericBinaryArray` to `GenericStringArray` when they have same
+/// offset size so re-encoding offset is unnecessary.
+fn cast_binary_to_string<O: OffsetSizeTrait>(
+    array: &dyn Array,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let array = array
+        .as_any()
+        .downcast_ref::<GenericByteArray<GenericBinaryType<O>>>()
+        .unwrap();
+
+    match GenericStringArray::<O>::try_from_binary(array.clone()) {
+        Ok(a) => Ok(Arc::new(a)),
+        Err(e) => match cast_options.safe {
+            true => {
+                // Fallback to slow method to convert invalid sequences to nulls
+                let mut builder =
+                    GenericStringBuilder::<O>::with_capacity(array.len(), array.value_data().len());
+
+                let iter = array
+                    .iter()
+                    .map(|v| v.and_then(|v| std::str::from_utf8(v).ok()));
+
+                builder.extend(iter);
+                Ok(Arc::new(builder.finish()))
+            }
+            false => Err(e),
+        },
+    }
+}
+
+/// Helper function to cast from one `BinaryArray` or 'LargeBinaryArray' to 'FixedSizeBinaryArray'.
+fn cast_binary_to_fixed_size_binary<O: OffsetSizeTrait>(
+    array: &dyn Array,
+    byte_width: i32,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let array = array.as_binary::<O>();
+    let mut builder = FixedSizeBinaryBuilder::with_capacity(array.len(), byte_width);
+
+    for i in 0..array.len() {
+        if array.is_null(i) {
+            builder.append_null();
+        } else {
+            match builder.append_value(array.value(i)) {
+                Ok(_) => {}
+                Err(e) => match cast_options.safe {
+                    true => builder.append_null(),
+                    false => return Err(e),
+                },
+            }
+        }
+    }
+
+    Ok(Arc::new(builder.finish()))
+}
+
+/// Helper function to cast from 'FixedSizeBinaryArray' to one `BinaryArray` or 'LargeBinaryArray'.
+/// If the target one is too large for the source array it will return an Error.
+fn cast_fixed_size_binary_to_binary<O: OffsetSizeTrait>(
+    array: &dyn Array,
+    byte_width: i32,
+) -> Result<ArrayRef, ArrowError> {
+    let array = array
+        .as_any()
+        .downcast_ref::<FixedSizeBinaryArray>()
+        .unwrap();
+
+    let offsets: i128 = byte_width as i128 * array.len() as i128;
+
+    let is_binary = matches!(GenericBinaryType::<O>::DATA_TYPE, DataType::Binary);
+    if is_binary && offsets > i32::MAX as i128 {
+        return Err(ArrowError::ComputeError(
+            "FixedSizeBinary array too large to cast to Binary array".to_string(),
+        ));
+    } else if !is_binary && offsets > i64::MAX as i128 {
+        return Err(ArrowError::ComputeError(
+            "FixedSizeBinary array too large to cast to LargeBinary array".to_string(),
+        ));
+    }
+
+    let mut builder = GenericBinaryBuilder::<O>::with_capacity(array.len(), array.len());
+
+    for i in 0..array.len() {
+        if array.is_null(i) {
+            builder.append_null();
+        } else {
+            builder.append_value(array.value(i));
+        }
+    }
+
+    Ok(Arc::new(builder.finish()))
+}
+
+/// Helper function to cast from one `ByteArrayType` to another and vice versa.
+/// If the target one (e.g., `LargeUtf8`) is too large for the source array it will return an Error.
+fn cast_byte_container<FROM, TO>(array: &dyn Array) -> Result<ArrayRef, ArrowError>
+where
+    FROM: ByteArrayType,
+    TO: ByteArrayType<Native = FROM::Native>,
+    FROM::Offset: OffsetSizeTrait + ToPrimitive,
+    TO::Offset: OffsetSizeTrait + NumCast,
+{
+    let data = array.to_data();
+    assert_eq!(data.data_type(), &FROM::DATA_TYPE);
+    let str_values_buf = data.buffers()[1].clone();
+    let offsets = data.buffers()[0].typed_data::<FROM::Offset>();
+
+    let mut offset_builder = BufferBuilder::<TO::Offset>::new(offsets.len());
+    offsets
+        .iter()
+        .try_for_each::<_, Result<_, ArrowError>>(|offset| {
+            let offset =
+                <<TO as ByteArrayType>::Offset as NumCast>::from(*offset).ok_or_else(|| {
+                    ArrowError::ComputeError(format!(
+                        "{}{} array too large to cast to {}{} array",
+                        FROM::Offset::PREFIX,
+                        FROM::PREFIX,
+                        TO::Offset::PREFIX,
+                        TO::PREFIX
+                    ))
+                })?;
+            offset_builder.append(offset);
+            Ok(())
+        })?;
+
+    let offset_buffer = offset_builder.finish();
+
+    let dtype = TO::DATA_TYPE;
+
+    let builder = ArrayData::builder(dtype)
+        .offset(array.offset())
+        .len(array.len())
+        .add_buffer(offset_buffer)
+        .add_buffer(str_values_buf)
+        .nulls(data.nulls().cloned());
+
+    let array_data = unsafe { builder.build_unchecked() };
+
+    Ok(Arc::new(GenericByteArray::<TO>::from(array_data)))
+}
+
+fn cast_fixed_size_list_to_list<OffsetSize>(array: &dyn Array) -> Result<ArrayRef, ArrowError>
+where
+    OffsetSize: OffsetSizeTrait,
+{
+    let fixed_size_list: &FixedSizeListArray = array.as_fixed_size_list();
+    let list: GenericListArray<OffsetSize> = fixed_size_list.clone().into();
+    Ok(Arc::new(list))
+}
+
+fn cast_list_to_fixed_size_list<OffsetSize>(
+    array: &GenericListArray<OffsetSize>,
+    field: &FieldRef,
+    size: i32,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError>
+where
+    OffsetSize: OffsetSizeTrait,
+{
+    let cap = array.len() * size as usize;
+
+    let mut nulls = (cast_options.safe || array.null_count() != 0).then(|| {
+        let mut buffer = BooleanBufferBuilder::new(array.len());
+        match array.nulls() {
+            Some(n) => buffer.append_buffer(n.inner()),
+            None => buffer.append_n(array.len(), true),
+        }
+        buffer
+    });
+
+    // Nulls in FixedSizeListArray take up space and so we must pad the values
+    let values = array.values().to_data();
+    let mut mutable = MutableArrayData::new(vec![&values], cast_options.safe, cap);
+    // The end position in values of the last incorrectly-sized list slice
+    let mut last_pos = 0;
+    for (idx, w) in array.offsets().windows(2).enumerate() {
+        let start_pos = w[0].as_usize();
+        let end_pos = w[1].as_usize();
+        let len = end_pos - start_pos;
+
+        if len != size as usize {
+            if cast_options.safe || array.is_null(idx) {
+                if last_pos != start_pos {
+                    // Extend with valid slices
+                    mutable.extend(0, last_pos, start_pos);
+                }
+                // Pad this slice with nulls
+                mutable.extend_nulls(size as _);
+                nulls.as_mut().unwrap().set_bit(idx, false);
+                // Set last_pos to the end of this slice's values
+                last_pos = end_pos
+            } else {
+                return Err(ArrowError::CastError(format!(
+                    "Cannot cast to FixedSizeList({size}): value at index {idx} has length {len}",
+                )));
+            }
+        }
+    }
+
+    let values = match last_pos {
+        0 => array.values().slice(0, cap), // All slices were the correct length
+        _ => {
+            if mutable.len() != cap {
+                // Remaining slices were all correct length
+                let remaining = cap - mutable.len();
+                mutable.extend(0, last_pos, last_pos + remaining)
+            }
+            make_array(mutable.freeze())
+        }
+    };
+
+    // Cast the inner values if necessary
+    let values = cast_with_options(values.as_ref(), field.data_type(), cast_options)?;
+
+    // Construct the FixedSizeListArray
+    let nulls = nulls.map(|mut x| x.finish().into());
+    let array = FixedSizeListArray::new(field.clone(), size, values, nulls);
+    Ok(Arc::new(array))
+}
+
+/// Helper function that takes an Generic list container and casts the inner datatype.
+fn cast_list_values<O: OffsetSizeTrait>(
+    array: &dyn Array,
+    to: &FieldRef,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let list = array.as_list::<O>();
+    let values = cast_with_options(list.values(), to.data_type(), cast_options)?;
+    Ok(Arc::new(GenericListArray::<O>::new(
+        to.clone(),
+        list.offsets().clone(),
+        values,
+        list.nulls().cloned(),
+    )))
+}
+
+/// Cast the container type of List/Largelist array along with the inner datatype
+fn cast_list<I: OffsetSizeTrait, O: OffsetSizeTrait>(
+    array: &dyn Array,
+    field: &FieldRef,
+    cast_options: &CastOptions,
+) -> Result<ArrayRef, ArrowError> {
+    let list = array.as_list::<I>();
+    let values = list.values();
+    let offsets = list.offsets();
+    let nulls = list.nulls().cloned();
+
+    if !O::IS_LARGE && values.len() > i32::MAX as usize {
+        return Err(ArrowError::ComputeError(
+            "LargeList too large to cast to List".into(),
+        ));
+    }
+
+    // Recursively cast values
+    let values = cast_with_options(values, field.data_type(), cast_options)?;
+    let offsets: Vec<_> = offsets.iter().map(|x| O::usize_as(x.as_usize())).collect();
+
+    // Safety: valid offsets and checked for overflow
+    let offsets = unsafe { OffsetBuffer::new_unchecked(offsets.into()) };
+
+    Ok(Arc::new(GenericListArray::<O>::new(
+        field.clone(),
+        offsets,
+        values,
+        nulls,
+    )))
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow_buffer::{Buffer, NullBuffer};
+    use half::f16;
+
+    use super::*;
+
+    macro_rules! generate_cast_test_case {
+        ($INPUT_ARRAY: expr, $OUTPUT_TYPE_ARRAY: ident, $OUTPUT_TYPE: expr, $OUTPUT_VALUES: expr) => {
+            let output =
+                $OUTPUT_TYPE_ARRAY::from($OUTPUT_VALUES).with_data_type($OUTPUT_TYPE.clone());
+
+            // assert cast type
+            let input_array_type = $INPUT_ARRAY.data_type();
+            assert!(can_cast_types(input_array_type, $OUTPUT_TYPE));
+            let result = cast($INPUT_ARRAY, $OUTPUT_TYPE).unwrap();
+            assert_eq!($OUTPUT_TYPE, result.data_type());
+            assert_eq!(result.as_ref(), &output);
+
+            let cast_option = CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            };
+            let result = cast_with_options($INPUT_ARRAY, $OUTPUT_TYPE, &cast_option).unwrap();
+            assert_eq!($OUTPUT_TYPE, result.data_type());
+            assert_eq!(result.as_ref(), &output);
+        };
+    }
+
+    fn create_decimal_array(
+        array: Vec<Option<i128>>,
+        precision: u8,
+        scale: i8,
+    ) -> Result<Decimal128Array, ArrowError> {
+        array
+            .into_iter()
+            .collect::<Decimal128Array>()
+            .with_precision_and_scale(precision, scale)
+    }
+
+    fn create_decimal256_array(
+        array: Vec<Option<i256>>,
+        precision: u8,
+        scale: i8,
+    ) -> Result<Decimal256Array, ArrowError> {
+        array
+            .into_iter()
+            .collect::<Decimal256Array>()
+            .with_precision_and_scale(precision, scale)
+    }
+
+    #[test]
+    #[cfg(not(feature = "force_validate"))]
+    #[should_panic(
+        expected = "Cannot cast to Decimal128(20, 3). Overflowing on 57896044618658097711785492504343953926634992332820282019728792003956564819967"
+    )]
+    fn test_cast_decimal_to_decimal_round_with_error() {
+        // decimal256 to decimal128 overflow
+        let array = vec![
+            Some(i256::from_i128(1123454)),
+            Some(i256::from_i128(2123456)),
+            Some(i256::from_i128(-3123453)),
+            Some(i256::from_i128(-3123456)),
+            None,
+            Some(i256::MAX),
+            Some(i256::MIN),
+        ];
+        let input_decimal_array = create_decimal256_array(array, 76, 4).unwrap();
+        let array = Arc::new(input_decimal_array) as ArrayRef;
+        let input_type = DataType::Decimal256(76, 4);
+        let output_type = DataType::Decimal128(20, 3);
+        assert!(can_cast_types(&input_type, &output_type));
+        generate_cast_test_case!(
+            &array,
+            Decimal128Array,
+            &output_type,
+            vec![
+                Some(112345_i128),
+                Some(212346_i128),
+                Some(-312345_i128),
+                Some(-312346_i128),
+                None,
+                None,
+                None,
+            ]
+        );
+    }
+
+    #[test]
+    #[cfg(not(feature = "force_validate"))]
+    fn test_cast_decimal_to_decimal_round() {
+        let array = vec![
+            Some(1123454),
+            Some(2123456),
+            Some(-3123453),
+            Some(-3123456),
+            None,
+        ];
+        let array = create_decimal_array(array, 20, 4).unwrap();
+        // decimal128 to decimal128
+        let input_type = DataType::Decimal128(20, 4);
+        let output_type = DataType::Decimal128(20, 3);
+        assert!(can_cast_types(&input_type, &output_type));
+        generate_cast_test_case!(
+            &array,
+            Decimal128Array,
+            &output_type,
+            vec![
+                Some(112345_i128),
+                Some(212346_i128),
+                Some(-312345_i128),
+                Some(-312346_i128),
+                None
+            ]
+        );
+
+        // decimal128 to decimal256
+        let input_type = DataType::Decimal128(20, 4);
+        let output_type = DataType::Decimal256(20, 3);
+        assert!(can_cast_types(&input_type, &output_type));
+        generate_cast_test_case!(
+            &array,
+            Decimal256Array,
+            &output_type,
+            vec![
+                Some(i256::from_i128(112345_i128)),
+                Some(i256::from_i128(212346_i128)),
+                Some(i256::from_i128(-312345_i128)),
+                Some(i256::from_i128(-312346_i128)),
+                None
+            ]
+        );
+
+        // decimal256
+        let array = vec![
+            Some(i256::from_i128(1123454)),
+            Some(i256::from_i128(2123456)),
+            Some(i256::from_i128(-3123453)),
+            Some(i256::from_i128(-3123456)),
+            None,
+        ];
+        let array = create_decimal256_array(array, 20, 4).unwrap();
+
+        // decimal256 to decimal256
+        let input_type = DataType::Decimal256(20, 4);
+        let output_type = DataType::Decimal256(20, 3);
+        assert!(can_cast_types(&input_type, &output_type));
+        generate_cast_test_case!(
+            &array,
+            Decimal256Array,
+            &output_type,
+            vec![
+                Some(i256::from_i128(112345_i128)),
+                Some(i256::from_i128(212346_i128)),
+                Some(i256::from_i128(-312345_i128)),
+                Some(i256::from_i128(-312346_i128)),
+                None
+            ]
+        );
+        // decimal256 to decimal128
+        let input_type = DataType::Decimal256(20, 4);
+        let output_type = DataType::Decimal128(20, 3);
+        assert!(can_cast_types(&input_type, &output_type));
+        generate_cast_test_case!(
+            &array,
+            Decimal128Array,
+            &output_type,
+            vec![
+                Some(112345_i128),
+                Some(212346_i128),
+                Some(-312345_i128),
+                Some(-312346_i128),
+                None
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_decimal128_to_decimal128() {
+        let input_type = DataType::Decimal128(20, 3);
+        let output_type = DataType::Decimal128(20, 4);
+        assert!(can_cast_types(&input_type, &output_type));
+        let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
+        let array = create_decimal_array(array, 20, 3).unwrap();
+        generate_cast_test_case!(
+            &array,
+            Decimal128Array,
+            &output_type,
+            vec![
+                Some(11234560_i128),
+                Some(21234560_i128),
+                Some(31234560_i128),
+                None
+            ]
+        );
+        // negative test
+        let array = vec![Some(123456), None];
+        let array = create_decimal_array(array, 10, 0).unwrap();
+        let result = cast(&array, &DataType::Decimal128(2, 2));
+        assert!(result.is_ok());
+        let array = result.unwrap();
+        let array: &Decimal128Array = array.as_primitive();
+        let err = array.validate_decimal_precision(2);
+        assert_eq!("Invalid argument error: 12345600 is too large to store in a Decimal128 of precision 2. Max is 99",
+                   err.unwrap_err().to_string());
+    }
+
+    #[test]
+    fn test_cast_decimal128_to_decimal128_overflow() {
+        let input_type = DataType::Decimal128(38, 3);
+        let output_type = DataType::Decimal128(38, 38);
+        assert!(can_cast_types(&input_type, &output_type));
+
+        let array = vec![Some(i128::MAX)];
+        let array = create_decimal_array(array, 38, 3).unwrap();
+        let result = cast_with_options(
+            &array,
+            &output_type,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!("Cast error: Cannot cast to Decimal128(38, 38). Overflowing on 170141183460469231731687303715884105727",
+                   result.unwrap_err().to_string());
+    }
+
+    #[test]
+    fn test_cast_decimal128_to_decimal256_overflow() {
+        let input_type = DataType::Decimal128(38, 3);
+        let output_type = DataType::Decimal256(76, 76);
+        assert!(can_cast_types(&input_type, &output_type));
+
+        let array = vec![Some(i128::MAX)];
+        let array = create_decimal_array(array, 38, 3).unwrap();
+        let result = cast_with_options(
+            &array,
+            &output_type,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!("Cast error: Cannot cast to Decimal256(76, 76). Overflowing on 170141183460469231731687303715884105727",
+                   result.unwrap_err().to_string());
+    }
+
+    #[test]
+    fn test_cast_decimal128_to_decimal256() {
+        let input_type = DataType::Decimal128(20, 3);
+        let output_type = DataType::Decimal256(20, 4);
+        assert!(can_cast_types(&input_type, &output_type));
+        let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
+        let array = create_decimal_array(array, 20, 3).unwrap();
+        generate_cast_test_case!(
+            &array,
+            Decimal256Array,
+            &output_type,
+            vec![
+                Some(i256::from_i128(11234560_i128)),
+                Some(i256::from_i128(21234560_i128)),
+                Some(i256::from_i128(31234560_i128)),
+                None
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_decimal256_to_decimal128_overflow() {
+        let input_type = DataType::Decimal256(76, 5);
+        let output_type = DataType::Decimal128(38, 7);
+        assert!(can_cast_types(&input_type, &output_type));
+        let array = vec![Some(i256::from_i128(i128::MAX))];
+        let array = create_decimal256_array(array, 76, 5).unwrap();
+        let result = cast_with_options(
+            &array,
+            &output_type,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!("Cast error: Cannot cast to Decimal128(38, 7). Overflowing on 170141183460469231731687303715884105727",
+                   result.unwrap_err().to_string());
+    }
+
+    #[test]
+    fn test_cast_decimal256_to_decimal256_overflow() {
+        let input_type = DataType::Decimal256(76, 5);
+        let output_type = DataType::Decimal256(76, 55);
+        assert!(can_cast_types(&input_type, &output_type));
+        let array = vec![Some(i256::from_i128(i128::MAX))];
+        let array = create_decimal256_array(array, 76, 5).unwrap();
+        let result = cast_with_options(
+            &array,
+            &output_type,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!("Cast error: Cannot cast to Decimal256(76, 55). Overflowing on 170141183460469231731687303715884105727",
+                   result.unwrap_err().to_string());
+    }
+
+    #[test]
+    fn test_cast_decimal256_to_decimal128() {
+        let input_type = DataType::Decimal256(20, 3);
+        let output_type = DataType::Decimal128(20, 4);
+        assert!(can_cast_types(&input_type, &output_type));
+        let array = vec![
+            Some(i256::from_i128(1123456)),
+            Some(i256::from_i128(2123456)),
+            Some(i256::from_i128(3123456)),
+            None,
+        ];
+        let array = create_decimal256_array(array, 20, 3).unwrap();
+        generate_cast_test_case!(
+            &array,
+            Decimal128Array,
+            &output_type,
+            vec![
+                Some(11234560_i128),
+                Some(21234560_i128),
+                Some(31234560_i128),
+                None
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_decimal256_to_decimal256() {
+        let input_type = DataType::Decimal256(20, 3);
+        let output_type = DataType::Decimal256(20, 4);
+        assert!(can_cast_types(&input_type, &output_type));
+        let array = vec![
+            Some(i256::from_i128(1123456)),
+            Some(i256::from_i128(2123456)),
+            Some(i256::from_i128(3123456)),
+            None,
+        ];
+        let array = create_decimal256_array(array, 20, 3).unwrap();
+        generate_cast_test_case!(
+            &array,
+            Decimal256Array,
+            &output_type,
+            vec![
+                Some(i256::from_i128(11234560_i128)),
+                Some(i256::from_i128(21234560_i128)),
+                Some(i256::from_i128(31234560_i128)),
+                None
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_decimal_to_numeric() {
+        let value_array: Vec<Option<i128>> = vec![Some(125), Some(225), Some(325), None, Some(525)];
+        let array = create_decimal_array(value_array, 38, 2).unwrap();
+        // u8
+        generate_cast_test_case!(
+            &array,
+            UInt8Array,
+            &DataType::UInt8,
+            vec![Some(1_u8), Some(2_u8), Some(3_u8), None, Some(5_u8)]
+        );
+        // u16
+        generate_cast_test_case!(
+            &array,
+            UInt16Array,
+            &DataType::UInt16,
+            vec![Some(1_u16), Some(2_u16), Some(3_u16), None, Some(5_u16)]
+        );
+        // u32
+        generate_cast_test_case!(
+            &array,
+            UInt32Array,
+            &DataType::UInt32,
+            vec![Some(1_u32), Some(2_u32), Some(3_u32), None, Some(5_u32)]
+        );
+        // u64
+        generate_cast_test_case!(
+            &array,
+            UInt64Array,
+            &DataType::UInt64,
+            vec![Some(1_u64), Some(2_u64), Some(3_u64), None, Some(5_u64)]
+        );
+        // i8
+        generate_cast_test_case!(
+            &array,
+            Int8Array,
+            &DataType::Int8,
+            vec![Some(1_i8), Some(2_i8), Some(3_i8), None, Some(5_i8)]
+        );
+        // i16
+        generate_cast_test_case!(
+            &array,
+            Int16Array,
+            &DataType::Int16,
+            vec![Some(1_i16), Some(2_i16), Some(3_i16), None, Some(5_i16)]
+        );
+        // i32
+        generate_cast_test_case!(
+            &array,
+            Int32Array,
+            &DataType::Int32,
+            vec![Some(1_i32), Some(2_i32), Some(3_i32), None, Some(5_i32)]
+        );
+        // i64
+        generate_cast_test_case!(
+            &array,
+            Int64Array,
+            &DataType::Int64,
+            vec![Some(1_i64), Some(2_i64), Some(3_i64), None, Some(5_i64)]
+        );
+        // f32
+        generate_cast_test_case!(
+            &array,
+            Float32Array,
+            &DataType::Float32,
+            vec![
+                Some(1.25_f32),
+                Some(2.25_f32),
+                Some(3.25_f32),
+                None,
+                Some(5.25_f32)
+            ]
+        );
+        // f64
+        generate_cast_test_case!(
+            &array,
+            Float64Array,
+            &DataType::Float64,
+            vec![
+                Some(1.25_f64),
+                Some(2.25_f64),
+                Some(3.25_f64),
+                None,
+                Some(5.25_f64)
+            ]
+        );
+
+        // overflow test: out of range of max u8
+        let value_array: Vec<Option<i128>> = vec![Some(51300)];
+        let array = create_decimal_array(value_array, 38, 2).unwrap();
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::UInt8,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!(
+            "Cast error: value of 513 is out of range UInt8".to_string(),
+            casted_array.unwrap_err().to_string()
+        );
+
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::UInt8,
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        // overflow test: out of range of max i8
+        let value_array: Vec<Option<i128>> = vec![Some(24400)];
+        let array = create_decimal_array(value_array, 38, 2).unwrap();
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Int8,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!(
+            "Cast error: value of 244 is out of range Int8".to_string(),
+            casted_array.unwrap_err().to_string()
+        );
+
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Int8,
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        // loss the precision: convert decimal to f32、f64
+        // f32
+        // 112345678_f32 and 112345679_f32 are same, so the 112345679_f32 will lose precision.
+        let value_array: Vec<Option<i128>> = vec![
+            Some(125),
+            Some(225),
+            Some(325),
+            None,
+            Some(525),
+            Some(112345678),
+            Some(112345679),
+        ];
+        let array = create_decimal_array(value_array, 38, 2).unwrap();
+        generate_cast_test_case!(
+            &array,
+            Float32Array,
+            &DataType::Float32,
+            vec![
+                Some(1.25_f32),
+                Some(2.25_f32),
+                Some(3.25_f32),
+                None,
+                Some(5.25_f32),
+                Some(1_123_456.7_f32),
+                Some(1_123_456.7_f32)
+            ]
+        );
+
+        // f64
+        // 112345678901234568_f64 and 112345678901234560_f64 are same, so the 112345678901234568_f64 will lose precision.
+        let value_array: Vec<Option<i128>> = vec![
+            Some(125),
+            Some(225),
+            Some(325),
+            None,
+            Some(525),
+            Some(112345678901234568),
+            Some(112345678901234560),
+        ];
+        let array = create_decimal_array(value_array, 38, 2).unwrap();
+        generate_cast_test_case!(
+            &array,
+            Float64Array,
+            &DataType::Float64,
+            vec![
+                Some(1.25_f64),
+                Some(2.25_f64),
+                Some(3.25_f64),
+                None,
+                Some(5.25_f64),
+                Some(1_123_456_789_012_345.6_f64),
+                Some(1_123_456_789_012_345.6_f64),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_decimal256_to_numeric() {
+        let value_array: Vec<Option<i256>> = vec![
+            Some(i256::from_i128(125)),
+            Some(i256::from_i128(225)),
+            Some(i256::from_i128(325)),
+            None,
+            Some(i256::from_i128(525)),
+        ];
+        let array = create_decimal256_array(value_array, 38, 2).unwrap();
+        // u8
+        generate_cast_test_case!(
+            &array,
+            UInt8Array,
+            &DataType::UInt8,
+            vec![Some(1_u8), Some(2_u8), Some(3_u8), None, Some(5_u8)]
+        );
+        // u16
+        generate_cast_test_case!(
+            &array,
+            UInt16Array,
+            &DataType::UInt16,
+            vec![Some(1_u16), Some(2_u16), Some(3_u16), None, Some(5_u16)]
+        );
+        // u32
+        generate_cast_test_case!(
+            &array,
+            UInt32Array,
+            &DataType::UInt32,
+            vec![Some(1_u32), Some(2_u32), Some(3_u32), None, Some(5_u32)]
+        );
+        // u64
+        generate_cast_test_case!(
+            &array,
+            UInt64Array,
+            &DataType::UInt64,
+            vec![Some(1_u64), Some(2_u64), Some(3_u64), None, Some(5_u64)]
+        );
+        // i8
+        generate_cast_test_case!(
+            &array,
+            Int8Array,
+            &DataType::Int8,
+            vec![Some(1_i8), Some(2_i8), Some(3_i8), None, Some(5_i8)]
+        );
+        // i16
+        generate_cast_test_case!(
+            &array,
+            Int16Array,
+            &DataType::Int16,
+            vec![Some(1_i16), Some(2_i16), Some(3_i16), None, Some(5_i16)]
+        );
+        // i32
+        generate_cast_test_case!(
+            &array,
+            Int32Array,
+            &DataType::Int32,
+            vec![Some(1_i32), Some(2_i32), Some(3_i32), None, Some(5_i32)]
+        );
+        // i64
+        generate_cast_test_case!(
+            &array,
+            Int64Array,
+            &DataType::Int64,
+            vec![Some(1_i64), Some(2_i64), Some(3_i64), None, Some(5_i64)]
+        );
+        // f32
+        generate_cast_test_case!(
+            &array,
+            Float32Array,
+            &DataType::Float32,
+            vec![
+                Some(1.25_f32),
+                Some(2.25_f32),
+                Some(3.25_f32),
+                None,
+                Some(5.25_f32)
+            ]
+        );
+        // f64
+        generate_cast_test_case!(
+            &array,
+            Float64Array,
+            &DataType::Float64,
+            vec![
+                Some(1.25_f64),
+                Some(2.25_f64),
+                Some(3.25_f64),
+                None,
+                Some(5.25_f64)
+            ]
+        );
+
+        // overflow test: out of range of max i8
+        let value_array: Vec<Option<i256>> = vec![Some(i256::from_i128(24400))];
+        let array = create_decimal256_array(value_array, 38, 2).unwrap();
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Int8,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!(
+            "Cast error: value of 244 is out of range Int8".to_string(),
+            casted_array.unwrap_err().to_string()
+        );
+
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Int8,
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        // loss the precision: convert decimal to f32、f64
+        // f32
+        // 112345678_f32 and 112345679_f32 are same, so the 112345679_f32 will lose precision.
+        let value_array: Vec<Option<i256>> = vec![
+            Some(i256::from_i128(125)),
+            Some(i256::from_i128(225)),
+            Some(i256::from_i128(325)),
+            None,
+            Some(i256::from_i128(525)),
+            Some(i256::from_i128(112345678)),
+            Some(i256::from_i128(112345679)),
+        ];
+        let array = create_decimal256_array(value_array, 76, 2).unwrap();
+        generate_cast_test_case!(
+            &array,
+            Float32Array,
+            &DataType::Float32,
+            vec![
+                Some(1.25_f32),
+                Some(2.25_f32),
+                Some(3.25_f32),
+                None,
+                Some(5.25_f32),
+                Some(1_123_456.7_f32),
+                Some(1_123_456.7_f32)
+            ]
+        );
+
+        // f64
+        // 112345678901234568_f64 and 112345678901234560_f64 are same, so the 112345678901234568_f64 will lose precision.
+        let value_array: Vec<Option<i256>> = vec![
+            Some(i256::from_i128(125)),
+            Some(i256::from_i128(225)),
+            Some(i256::from_i128(325)),
+            None,
+            Some(i256::from_i128(525)),
+            Some(i256::from_i128(112345678901234568)),
+            Some(i256::from_i128(112345678901234560)),
+        ];
+        let array = create_decimal256_array(value_array, 76, 2).unwrap();
+        generate_cast_test_case!(
+            &array,
+            Float64Array,
+            &DataType::Float64,
+            vec![
+                Some(1.25_f64),
+                Some(2.25_f64),
+                Some(3.25_f64),
+                None,
+                Some(5.25_f64),
+                Some(1_123_456_789_012_345.6_f64),
+                Some(1_123_456_789_012_345.6_f64),
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_numeric_to_decimal128() {
+        let decimal_type = DataType::Decimal128(38, 6);
+        // u8, u16, u32, u64
+        let input_datas = vec![
+            Arc::new(UInt8Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // u8
+            Arc::new(UInt16Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // u16
+            Arc::new(UInt32Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // u32
+            Arc::new(UInt64Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // u64
+        ];
+
+        for array in input_datas {
+            generate_cast_test_case!(
+                &array,
+                Decimal128Array,
+                &decimal_type,
+                vec![
+                    Some(1000000_i128),
+                    Some(2000000_i128),
+                    Some(3000000_i128),
+                    None,
+                    Some(5000000_i128)
+                ]
+            );
+        }
+
+        // i8, i16, i32, i64
+        let input_datas = vec![
+            Arc::new(Int8Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // i8
+            Arc::new(Int16Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // i16
+            Arc::new(Int32Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // i32
+            Arc::new(Int64Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // i64
+        ];
+        for array in input_datas {
+            generate_cast_test_case!(
+                &array,
+                Decimal128Array,
+                &decimal_type,
+                vec![
+                    Some(1000000_i128),
+                    Some(2000000_i128),
+                    Some(3000000_i128),
+                    None,
+                    Some(5000000_i128)
+                ]
+            );
+        }
+
+        // test u8 to decimal type with overflow the result type
+        // the 100 will be converted to 1000_i128, but it is out of range for max value in the precision 3.
+        let array = UInt8Array::from(vec![1, 2, 3, 4, 100]);
+        let casted_array = cast(&array, &DataType::Decimal128(3, 1));
+        assert!(casted_array.is_ok());
+        let array = casted_array.unwrap();
+        let array: &Decimal128Array = array.as_primitive();
+        assert!(array.is_null(4));
+
+        // test i8 to decimal type with overflow the result type
+        // the 100 will be converted to 1000_i128, but it is out of range for max value in the precision 3.
+        let array = Int8Array::from(vec![1, 2, 3, 4, 100]);
+        let casted_array = cast(&array, &DataType::Decimal128(3, 1));
+        assert!(casted_array.is_ok());
+        let array = casted_array.unwrap();
+        let array: &Decimal128Array = array.as_primitive();
+        assert!(array.is_null(4));
+
+        // test f32 to decimal type
+        let array = Float32Array::from(vec![
+            Some(1.1),
+            Some(2.2),
+            Some(4.4),
+            None,
+            Some(1.123_456_4), // round down
+            Some(1.123_456_7), // round up
+        ]);
+        let array = Arc::new(array) as ArrayRef;
+        generate_cast_test_case!(
+            &array,
+            Decimal128Array,
+            &decimal_type,
+            vec![
+                Some(1100000_i128),
+                Some(2200000_i128),
+                Some(4400000_i128),
+                None,
+                Some(1123456_i128), // round down
+                Some(1123457_i128), // round up
+            ]
+        );
+
+        // test f64 to decimal type
+        let array = Float64Array::from(vec![
+            Some(1.1),
+            Some(2.2),
+            Some(4.4),
+            None,
+            Some(1.123_456_489_123_4),     // round up
+            Some(1.123_456_789_123_4),     // round up
+            Some(1.123_456_489_012_345_6), // round down
+            Some(1.123_456_789_012_345_6), // round up
+        ]);
+        generate_cast_test_case!(
+            &array,
+            Decimal128Array,
+            &decimal_type,
+            vec![
+                Some(1100000_i128),
+                Some(2200000_i128),
+                Some(4400000_i128),
+                None,
+                Some(1123456_i128), // round down
+                Some(1123457_i128), // round up
+                Some(1123456_i128), // round down
+                Some(1123457_i128), // round up
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_numeric_to_decimal256() {
+        let decimal_type = DataType::Decimal256(76, 6);
+        // u8, u16, u32, u64
+        let input_datas = vec![
+            Arc::new(UInt8Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // u8
+            Arc::new(UInt16Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // u16
+            Arc::new(UInt32Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // u32
+            Arc::new(UInt64Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // u64
+        ];
+
+        for array in input_datas {
+            generate_cast_test_case!(
+                &array,
+                Decimal256Array,
+                &decimal_type,
+                vec![
+                    Some(i256::from_i128(1000000_i128)),
+                    Some(i256::from_i128(2000000_i128)),
+                    Some(i256::from_i128(3000000_i128)),
+                    None,
+                    Some(i256::from_i128(5000000_i128))
+                ]
+            );
+        }
+
+        // i8, i16, i32, i64
+        let input_datas = vec![
+            Arc::new(Int8Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // i8
+            Arc::new(Int16Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // i16
+            Arc::new(Int32Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // i32
+            Arc::new(Int64Array::from(vec![
+                Some(1),
+                Some(2),
+                Some(3),
+                None,
+                Some(5),
+            ])) as ArrayRef, // i64
+        ];
+        for array in input_datas {
+            generate_cast_test_case!(
+                &array,
+                Decimal256Array,
+                &decimal_type,
+                vec![
+                    Some(i256::from_i128(1000000_i128)),
+                    Some(i256::from_i128(2000000_i128)),
+                    Some(i256::from_i128(3000000_i128)),
+                    None,
+                    Some(i256::from_i128(5000000_i128))
+                ]
+            );
+        }
+
+        // test i8 to decimal type with overflow the result type
+        // the 100 will be converted to 1000_i128, but it is out of range for max value in the precision 3.
+        let array = Int8Array::from(vec![1, 2, 3, 4, 100]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast(&array, &DataType::Decimal256(3, 1));
+        assert!(casted_array.is_ok());
+        let array = casted_array.unwrap();
+        let array: &Decimal256Array = array.as_primitive();
+        assert!(array.is_null(4));
+
+        // test f32 to decimal type
+        let array = Float32Array::from(vec![
+            Some(1.1),
+            Some(2.2),
+            Some(4.4),
+            None,
+            Some(1.123_456_4), // round down
+            Some(1.123_456_7), // round up
+        ]);
+        generate_cast_test_case!(
+            &array,
+            Decimal256Array,
+            &decimal_type,
+            vec![
+                Some(i256::from_i128(1100000_i128)),
+                Some(i256::from_i128(2200000_i128)),
+                Some(i256::from_i128(4400000_i128)),
+                None,
+                Some(i256::from_i128(1123456_i128)), // round down
+                Some(i256::from_i128(1123457_i128)), // round up
+            ]
+        );
+
+        // test f64 to decimal type
+        let array = Float64Array::from(vec![
+            Some(1.1),
+            Some(2.2),
+            Some(4.4),
+            None,
+            Some(1.123_456_489_123_4),     // round down
+            Some(1.123_456_789_123_4),     // round up
+            Some(1.123_456_489_012_345_6), // round down
+            Some(1.123_456_789_012_345_6), // round up
+        ]);
+        generate_cast_test_case!(
+            &array,
+            Decimal256Array,
+            &decimal_type,
+            vec![
+                Some(i256::from_i128(1100000_i128)),
+                Some(i256::from_i128(2200000_i128)),
+                Some(i256::from_i128(4400000_i128)),
+                None,
+                Some(i256::from_i128(1123456_i128)), // round down
+                Some(i256::from_i128(1123457_i128)), // round up
+                Some(i256::from_i128(1123456_i128)), // round down
+                Some(i256::from_i128(1123457_i128)), // round up
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_i32_to_f64() {
+        let array = Int32Array::from(vec![5, 6, 7, 8, 9]);
+        let b = cast(&array, &DataType::Float64).unwrap();
+        let c = b.as_primitive::<Float64Type>();
+        assert_eq!(5.0, c.value(0));
+        assert_eq!(6.0, c.value(1));
+        assert_eq!(7.0, c.value(2));
+        assert_eq!(8.0, c.value(3));
+        assert_eq!(9.0, c.value(4));
+    }
+
+    #[test]
+    fn test_cast_i32_to_u8() {
+        let array = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
+        let b = cast(&array, &DataType::UInt8).unwrap();
+        let c = b.as_primitive::<UInt8Type>();
+        assert!(!c.is_valid(0));
+        assert_eq!(6, c.value(1));
+        assert!(!c.is_valid(2));
+        assert_eq!(8, c.value(3));
+        // overflows return None
+        assert!(!c.is_valid(4));
+    }
+
+    #[test]
+    #[should_panic(expected = "Can't cast value -5 to type UInt8")]
+    fn test_cast_int32_to_u8_with_error() {
+        let array = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
+        // overflow with the error
+        let cast_option = CastOptions {
+            safe: false,
+            format_options: FormatOptions::default(),
+        };
+        let result = cast_with_options(&array, &DataType::UInt8, &cast_option);
+        assert!(result.is_err());
+        result.unwrap();
+    }
+
+    #[test]
+    fn test_cast_i32_to_u8_sliced() {
+        let array = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
+        assert_eq!(0, array.offset());
+        let array = array.slice(2, 3);
+        let b = cast(&array, &DataType::UInt8).unwrap();
+        assert_eq!(3, b.len());
+        let c = b.as_primitive::<UInt8Type>();
+        assert!(!c.is_valid(0));
+        assert_eq!(8, c.value(1));
+        // overflows return None
+        assert!(!c.is_valid(2));
+    }
+
+    #[test]
+    fn test_cast_i32_to_i32() {
+        let array = Int32Array::from(vec![5, 6, 7, 8, 9]);
+        let b = cast(&array, &DataType::Int32).unwrap();
+        let c = b.as_primitive::<Int32Type>();
+        assert_eq!(5, c.value(0));
+        assert_eq!(6, c.value(1));
+        assert_eq!(7, c.value(2));
+        assert_eq!(8, c.value(3));
+        assert_eq!(9, c.value(4));
+    }
+
+    #[test]
+    fn test_cast_i32_to_list_i32() {
+        let array = Int32Array::from(vec![5, 6, 7, 8, 9]);
+        let b = cast(
+            &array,
+            &DataType::List(Arc::new(Field::new("item", DataType::Int32, true))),
+        )
+        .unwrap();
+        assert_eq!(5, b.len());
+        let arr = b.as_list::<i32>();
+        assert_eq!(&[0, 1, 2, 3, 4, 5], arr.value_offsets());
+        assert_eq!(1, arr.value_length(0));
+        assert_eq!(1, arr.value_length(1));
+        assert_eq!(1, arr.value_length(2));
+        assert_eq!(1, arr.value_length(3));
+        assert_eq!(1, arr.value_length(4));
+        let c = arr.values().as_primitive::<Int32Type>();
+        assert_eq!(5, c.value(0));
+        assert_eq!(6, c.value(1));
+        assert_eq!(7, c.value(2));
+        assert_eq!(8, c.value(3));
+        assert_eq!(9, c.value(4));
+    }
+
+    #[test]
+    fn test_cast_i32_to_list_i32_nullable() {
+        let array = Int32Array::from(vec![Some(5), None, Some(7), Some(8), Some(9)]);
+        let b = cast(
+            &array,
+            &DataType::List(Arc::new(Field::new("item", DataType::Int32, true))),
+        )
+        .unwrap();
+        assert_eq!(5, b.len());
+        assert_eq!(0, b.null_count());
+        let arr = b.as_list::<i32>();
+        assert_eq!(&[0, 1, 2, 3, 4, 5], arr.value_offsets());
+        assert_eq!(1, arr.value_length(0));
+        assert_eq!(1, arr.value_length(1));
+        assert_eq!(1, arr.value_length(2));
+        assert_eq!(1, arr.value_length(3));
+        assert_eq!(1, arr.value_length(4));
+
+        let c = arr.values().as_primitive::<Int32Type>();
+        assert_eq!(1, c.null_count());
+        assert_eq!(5, c.value(0));
+        assert!(!c.is_valid(1));
+        assert_eq!(7, c.value(2));
+        assert_eq!(8, c.value(3));
+        assert_eq!(9, c.value(4));
+    }
+
+    #[test]
+    fn test_cast_i32_to_list_f64_nullable_sliced() {
+        let array = Int32Array::from(vec![Some(5), None, Some(7), Some(8), None, Some(10)]);
+        let array = array.slice(2, 4);
+        let b = cast(
+            &array,
+            &DataType::List(Arc::new(Field::new("item", DataType::Float64, true))),
+        )
+        .unwrap();
+        assert_eq!(4, b.len());
+        assert_eq!(0, b.null_count());
+        let arr = b.as_list::<i32>();
+        assert_eq!(&[0, 1, 2, 3, 4], arr.value_offsets());
+        assert_eq!(1, arr.value_length(0));
+        assert_eq!(1, arr.value_length(1));
+        assert_eq!(1, arr.value_length(2));
+        assert_eq!(1, arr.value_length(3));
+        let c = arr.values().as_primitive::<Float64Type>();
+        assert_eq!(1, c.null_count());
+        assert_eq!(7.0, c.value(0));
+        assert_eq!(8.0, c.value(1));
+        assert!(!c.is_valid(2));
+        assert_eq!(10.0, c.value(3));
+    }
+
+    #[test]
+    fn test_cast_utf8_to_i32() {
+        let array = StringArray::from(vec!["5", "6", "seven", "8", "9.1"]);
+        let b = cast(&array, &DataType::Int32).unwrap();
+        let c = b.as_primitive::<Int32Type>();
+        assert_eq!(5, c.value(0));
+        assert_eq!(6, c.value(1));
+        assert!(!c.is_valid(2));
+        assert_eq!(8, c.value(3));
+        assert!(!c.is_valid(4));
+    }
+
+    #[test]
+    fn test_cast_with_options_utf8_to_i32() {
+        let array = StringArray::from(vec!["5", "6", "seven", "8", "9.1"]);
+        let result = cast_with_options(
+            &array,
+            &DataType::Int32,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        match result {
+            Ok(_) => panic!("expected error"),
+            Err(e) => {
+                assert!(
+                    e.to_string()
+                        .contains("Cast error: Cannot cast string 'seven' to value of Int32 type",),
+                    "Error: {e}"
+                )
+            }
+        }
+    }
+
+    #[test]
+    fn test_cast_utf8_to_bool() {
+        let strings = StringArray::from(vec!["true", "false", "invalid", " Y ", ""]);
+        let casted = cast(&strings, &DataType::Boolean).unwrap();
+        let expected = BooleanArray::from(vec![Some(true), Some(false), None, Some(true), None]);
+        assert_eq!(*as_boolean_array(&casted), expected);
+    }
+
+    #[test]
+    fn test_cast_with_options_utf8_to_bool() {
+        let strings = StringArray::from(vec!["true", "false", "invalid", " Y ", ""]);
+        let casted = cast_with_options(
+            &strings,
+            &DataType::Boolean,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        match casted {
+            Ok(_) => panic!("expected error"),
+            Err(e) => {
+                assert!(e
+                    .to_string()
+                    .contains("Cast error: Cannot cast value 'invalid' to value of Boolean type"))
+            }
+        }
+    }
+
+    #[test]
+    fn test_cast_bool_to_i32() {
+        let array = BooleanArray::from(vec![Some(true), Some(false), None]);
+        let b = cast(&array, &DataType::Int32).unwrap();
+        let c = b.as_primitive::<Int32Type>();
+        assert_eq!(1, c.value(0));
+        assert_eq!(0, c.value(1));
+        assert!(!c.is_valid(2));
+    }
+
+    #[test]
+    fn test_cast_bool_to_utf8() {
+        let array = BooleanArray::from(vec![Some(true), Some(false), None]);
+        let b = cast(&array, &DataType::Utf8).unwrap();
+        let c = b.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!("true", c.value(0));
+        assert_eq!("false", c.value(1));
+        assert!(!c.is_valid(2));
+    }
+
+    #[test]
+    fn test_cast_bool_to_large_utf8() {
+        let array = BooleanArray::from(vec![Some(true), Some(false), None]);
+        let b = cast(&array, &DataType::LargeUtf8).unwrap();
+        let c = b.as_any().downcast_ref::<LargeStringArray>().unwrap();
+        assert_eq!("true", c.value(0));
+        assert_eq!("false", c.value(1));
+        assert!(!c.is_valid(2));
+    }
+
+    #[test]
+    fn test_cast_bool_to_f64() {
+        let array = BooleanArray::from(vec![Some(true), Some(false), None]);
+        let b = cast(&array, &DataType::Float64).unwrap();
+        let c = b.as_primitive::<Float64Type>();
+        assert_eq!(1.0, c.value(0));
+        assert_eq!(0.0, c.value(1));
+        assert!(!c.is_valid(2));
+    }
+
+    #[test]
+    fn test_cast_integer_to_timestamp() {
+        let array = Int64Array::from(vec![Some(2), Some(10), None]);
+        let expected = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        let array = Int8Array::from(vec![Some(2), Some(10), None]);
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+
+        let array = Int16Array::from(vec![Some(2), Some(10), None]);
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+
+        let array = Int32Array::from(vec![Some(2), Some(10), None]);
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+
+        let array = UInt8Array::from(vec![Some(2), Some(10), None]);
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+
+        let array = UInt16Array::from(vec![Some(2), Some(10), None]);
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+
+        let array = UInt32Array::from(vec![Some(2), Some(10), None]);
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+
+        let array = UInt64Array::from(vec![Some(2), Some(10), None]);
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+    }
+
+    #[test]
+    fn test_cast_timestamp_to_integer() {
+        let array = TimestampMillisecondArray::from(vec![Some(5), Some(1), None])
+            .with_timezone("UTC".to_string());
+        let expected = cast(&array, &DataType::Int64).unwrap();
+
+        let actual = cast(&cast(&array, &DataType::Int8).unwrap(), &DataType::Int64).unwrap();
+        assert_eq!(&actual, &expected);
+
+        let actual = cast(&cast(&array, &DataType::Int16).unwrap(), &DataType::Int64).unwrap();
+        assert_eq!(&actual, &expected);
+
+        let actual = cast(&cast(&array, &DataType::Int32).unwrap(), &DataType::Int64).unwrap();
+        assert_eq!(&actual, &expected);
+
+        let actual = cast(&cast(&array, &DataType::UInt8).unwrap(), &DataType::Int64).unwrap();
+        assert_eq!(&actual, &expected);
+
+        let actual = cast(&cast(&array, &DataType::UInt16).unwrap(), &DataType::Int64).unwrap();
+        assert_eq!(&actual, &expected);
+
+        let actual = cast(&cast(&array, &DataType::UInt32).unwrap(), &DataType::Int64).unwrap();
+        assert_eq!(&actual, &expected);
+
+        let actual = cast(&cast(&array, &DataType::UInt64).unwrap(), &DataType::Int64).unwrap();
+        assert_eq!(&actual, &expected);
+    }
+
+    #[test]
+    fn test_cast_floating_to_timestamp() {
+        let array = Int64Array::from(vec![Some(2), Some(10), None]);
+        let expected = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        let array = Float16Array::from(vec![
+            Some(f16::from_f32(2.0)),
+            Some(f16::from_f32(10.6)),
+            None,
+        ]);
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+
+        let array = Float32Array::from(vec![Some(2.0), Some(10.6), None]);
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+
+        let array = Float64Array::from(vec![Some(2.1), Some(10.2), None]);
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+    }
+
+    #[test]
+    fn test_cast_timestamp_to_floating() {
+        let array = TimestampMillisecondArray::from(vec![Some(5), Some(1), None])
+            .with_timezone("UTC".to_string());
+        let expected = cast(&array, &DataType::Int64).unwrap();
+
+        let actual = cast(&cast(&array, &DataType::Float16).unwrap(), &DataType::Int64).unwrap();
+        assert_eq!(&actual, &expected);
+
+        let actual = cast(&cast(&array, &DataType::Float32).unwrap(), &DataType::Int64).unwrap();
+        assert_eq!(&actual, &expected);
+
+        let actual = cast(&cast(&array, &DataType::Float64).unwrap(), &DataType::Int64).unwrap();
+        assert_eq!(&actual, &expected);
+    }
+
+    #[test]
+    fn test_cast_decimal_to_timestamp() {
+        let array = Int64Array::from(vec![Some(2), Some(10), None]);
+        let expected = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        let array = Decimal128Array::from(vec![Some(200), Some(1000), None])
+            .with_precision_and_scale(4, 2)
+            .unwrap();
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+
+        let array = Decimal256Array::from(vec![
+            Some(i256::from_i128(2000)),
+            Some(i256::from_i128(10000)),
+            None,
+        ])
+        .with_precision_and_scale(5, 3)
+        .unwrap();
+        let actual = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+
+        assert_eq!(&actual, &expected);
+    }
+
+    #[test]
+    fn test_cast_timestamp_to_decimal() {
+        let array = TimestampMillisecondArray::from(vec![Some(5), Some(1), None])
+            .with_timezone("UTC".to_string());
+        let expected = cast(&array, &DataType::Int64).unwrap();
+
+        let actual = cast(
+            &cast(&array, &DataType::Decimal128(5, 2)).unwrap(),
+            &DataType::Int64,
+        )
+        .unwrap();
+        assert_eq!(&actual, &expected);
+
+        let actual = cast(
+            &cast(&array, &DataType::Decimal256(10, 5)).unwrap(),
+            &DataType::Int64,
+        )
+        .unwrap();
+        assert_eq!(&actual, &expected);
+    }
+
+    #[test]
+    fn test_cast_list_i32_to_list_u16() {
+        let value_data = Int32Array::from(vec![0, 0, 0, -1, -2, -1, 2, 100000000]).into_data();
+
+        let value_offsets = Buffer::from_slice_ref([0, 3, 6, 8]);
+
+        // Construct a list array from the above two
+        // [[0,0,0], [-1, -2, -1], [2, 100000000]]
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, true)));
+        let list_data = ArrayData::builder(list_data_type)
+            .len(3)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data)
+            .build()
+            .unwrap();
+        let list_array = ListArray::from(list_data);
+
+        let cast_array = cast(
+            &list_array,
+            &DataType::List(Arc::new(Field::new("item", DataType::UInt16, true))),
+        )
+        .unwrap();
+
+        // For the ListArray itself, there are no null values (as there were no nulls when they went in)
+        //
+        // 3 negative values should get lost when casting to unsigned,
+        // 1 value should overflow
+        assert_eq!(0, cast_array.null_count());
+
+        // offsets should be the same
+        let array = cast_array.as_list::<i32>();
+        assert_eq!(list_array.value_offsets(), array.value_offsets());
+
+        assert_eq!(DataType::UInt16, array.value_type());
+        assert_eq!(3, array.value_length(0));
+        assert_eq!(3, array.value_length(1));
+        assert_eq!(2, array.value_length(2));
+
+        // expect 4 nulls: negative numbers and overflow
+        let u16arr = array.values().as_primitive::<UInt16Type>();
+        assert_eq!(4, u16arr.null_count());
+
+        // expect 4 nulls: negative numbers and overflow
+        let expected: UInt16Array =
+            vec![Some(0), Some(0), Some(0), None, None, None, Some(2), None]
+                .into_iter()
+                .collect();
+
+        assert_eq!(u16arr, &expected);
+    }
+
+    #[test]
+    fn test_cast_list_i32_to_list_timestamp() {
+        // Construct a value array
+        let value_data = Int32Array::from(vec![0, 0, 0, -1, -2, -1, 2, 8, 100000000]).into_data();
+
+        let value_offsets = Buffer::from_slice_ref([0, 3, 6, 9]);
+
+        // Construct a list array from the above two
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, true)));
+        let list_data = ArrayData::builder(list_data_type)
+            .len(3)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data)
+            .build()
+            .unwrap();
+        let list_array = Arc::new(ListArray::from(list_data)) as ArrayRef;
+
+        let actual = cast(
+            &list_array,
+            &DataType::List(Arc::new(Field::new(
+                "item",
+                DataType::Timestamp(TimeUnit::Microsecond, None),
+                true,
+            ))),
+        )
+        .unwrap();
+
+        let expected = cast(
+            &cast(
+                &list_array,
+                &DataType::List(Arc::new(Field::new("item", DataType::Int64, true))),
+            )
+            .unwrap(),
+            &DataType::List(Arc::new(Field::new(
+                "item",
+                DataType::Timestamp(TimeUnit::Microsecond, None),
+                true,
+            ))),
+        )
+        .unwrap();
+
+        assert_eq!(&actual, &expected);
+    }
+
+    #[test]
+    fn test_cast_date32_to_date64() {
+        let a = Date32Array::from(vec![10000, 17890]);
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Date64).unwrap();
+        let c = b.as_primitive::<Date64Type>();
+        assert_eq!(864000000000, c.value(0));
+        assert_eq!(1545696000000, c.value(1));
+    }
+
+    #[test]
+    fn test_cast_date64_to_date32() {
+        let a = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Date32).unwrap();
+        let c = b.as_primitive::<Date32Type>();
+        assert_eq!(10000, c.value(0));
+        assert_eq!(17890, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_string_to_integral_overflow() {
+        let str = Arc::new(StringArray::from(vec![
+            Some("123"),
+            Some("-123"),
+            Some("86374"),
+            None,
+        ])) as ArrayRef;
+
+        let options = CastOptions {
+            safe: true,
+            format_options: FormatOptions::default(),
+        };
+        let res = cast_with_options(&str, &DataType::Int16, &options).expect("should cast to i16");
+        let expected =
+            Arc::new(Int16Array::from(vec![Some(123), Some(-123), None, None])) as ArrayRef;
+        assert_eq!(&res, &expected);
+    }
+
+    #[test]
+    fn test_cast_string_to_timestamp() {
+        let a1 = Arc::new(StringArray::from(vec![
+            Some("2020-09-08T12:00:00.123456789+00:00"),
+            Some("Not a valid date"),
+            None,
+        ])) as ArrayRef;
+        let a2 = Arc::new(LargeStringArray::from(vec![
+            Some("2020-09-08T12:00:00.123456789+00:00"),
+            Some("Not a valid date"),
+            None,
+        ])) as ArrayRef;
+        for array in &[a1, a2] {
+            for time_unit in &[
+                TimeUnit::Second,
+                TimeUnit::Millisecond,
+                TimeUnit::Microsecond,
+                TimeUnit::Nanosecond,
+            ] {
+                let to_type = DataType::Timestamp(time_unit.clone(), None);
+                let b = cast(array, &to_type).unwrap();
+
+                match time_unit {
+                    TimeUnit::Second => {
+                        let c = b.as_primitive::<TimestampSecondType>();
+                        assert_eq!(1599566400, c.value(0));
+                        assert!(c.is_null(1));
+                        assert!(c.is_null(2));
+                    }
+                    TimeUnit::Millisecond => {
+                        let c = b
+                            .as_any()
+                            .downcast_ref::<TimestampMillisecondArray>()
+                            .unwrap();
+                        assert_eq!(1599566400123, c.value(0));
+                        assert!(c.is_null(1));
+                        assert!(c.is_null(2));
+                    }
+                    TimeUnit::Microsecond => {
+                        let c = b
+                            .as_any()
+                            .downcast_ref::<TimestampMicrosecondArray>()
+                            .unwrap();
+                        assert_eq!(1599566400123456, c.value(0));
+                        assert!(c.is_null(1));
+                        assert!(c.is_null(2));
+                    }
+                    TimeUnit::Nanosecond => {
+                        let c = b
+                            .as_any()
+                            .downcast_ref::<TimestampNanosecondArray>()
+                            .unwrap();
+                        assert_eq!(1599566400123456789, c.value(0));
+                        assert!(c.is_null(1));
+                        assert!(c.is_null(2));
+                    }
+                }
+
+                let options = CastOptions {
+                    safe: false,
+                    format_options: FormatOptions::default(),
+                };
+                let err = cast_with_options(array, &to_type, &options).unwrap_err();
+                assert_eq!(
+                    err.to_string(),
+                    "Parser error: Error parsing timestamp from 'Not a valid date': error parsing date"
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn test_cast_string_to_timestamp_overflow() {
+        let array = StringArray::from(vec!["9800-09-08T12:00:00.123456789"]);
+        let result = cast(&array, &DataType::Timestamp(TimeUnit::Second, None)).unwrap();
+        let result = result.as_primitive::<TimestampSecondType>();
+        assert_eq!(result.values(), &[247112596800]);
+    }
+
+    #[test]
+    fn test_cast_string_to_date32() {
+        let a1 = Arc::new(StringArray::from(vec![
+            Some("2018-12-25"),
+            Some("Not a valid date"),
+            None,
+        ])) as ArrayRef;
+        let a2 = Arc::new(LargeStringArray::from(vec![
+            Some("2018-12-25"),
+            Some("Not a valid date"),
+            None,
+        ])) as ArrayRef;
+        for array in &[a1, a2] {
+            let to_type = DataType::Date32;
+            let b = cast(array, &to_type).unwrap();
+            let c = b.as_primitive::<Date32Type>();
+            assert_eq!(17890, c.value(0));
+            assert!(c.is_null(1));
+            assert!(c.is_null(2));
+
+            let options = CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            };
+            let err = cast_with_options(array, &to_type, &options).unwrap_err();
+            assert_eq!(
+                err.to_string(),
+                "Cast error: Cannot cast string 'Not a valid date' to value of Date32 type"
+            );
+        }
+    }
+
+    #[test]
+    fn test_cast_string_format_yyyymmdd_to_date32() {
+        let a = Arc::new(StringArray::from(vec![
+            Some("2020-12-25"),
+            Some("20201117"),
+        ])) as ArrayRef;
+
+        let to_type = DataType::Date32;
+        let options = CastOptions {
+            safe: false,
+            format_options: FormatOptions::default(),
+        };
+        let result = cast_with_options(&a, &to_type, &options).unwrap();
+        let c = result.as_primitive::<Date32Type>();
+        assert_eq!(
+            chrono::NaiveDate::from_ymd_opt(2020, 12, 25),
+            c.value_as_date(0)
+        );
+        assert_eq!(
+            chrono::NaiveDate::from_ymd_opt(2020, 11, 17),
+            c.value_as_date(1)
+        );
+    }
+
+    #[test]
+    fn test_cast_string_to_time32second() {
+        let a1 = Arc::new(StringArray::from(vec![
+            Some("08:08:35.091323414"),
+            Some("08:08:60.091323414"), // leap second
+            Some("08:08:61.091323414"), // not valid
+            Some("Not a valid time"),
+            None,
+        ])) as ArrayRef;
+        let a2 = Arc::new(LargeStringArray::from(vec![
+            Some("08:08:35.091323414"),
+            Some("08:08:60.091323414"), // leap second
+            Some("08:08:61.091323414"), // not valid
+            Some("Not a valid time"),
+            None,
+        ])) as ArrayRef;
+        for array in &[a1, a2] {
+            let to_type = DataType::Time32(TimeUnit::Second);
+            let b = cast(array, &to_type).unwrap();
+            let c = b.as_primitive::<Time32SecondType>();
+            assert_eq!(29315, c.value(0));
+            assert_eq!(29340, c.value(1));
+            assert!(c.is_null(2));
+            assert!(c.is_null(3));
+            assert!(c.is_null(4));
+
+            let options = CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            };
+            let err = cast_with_options(array, &to_type, &options).unwrap_err();
+            assert_eq!(err.to_string(), "Cast error: Cannot cast string '08:08:61.091323414' to value of Time32(Second) type");
+        }
+    }
+
+    #[test]
+    fn test_cast_string_to_time32millisecond() {
+        let a1 = Arc::new(StringArray::from(vec![
+            Some("08:08:35.091323414"),
+            Some("08:08:60.091323414"), // leap second
+            Some("08:08:61.091323414"), // not valid
+            Some("Not a valid time"),
+            None,
+        ])) as ArrayRef;
+        let a2 = Arc::new(LargeStringArray::from(vec![
+            Some("08:08:35.091323414"),
+            Some("08:08:60.091323414"), // leap second
+            Some("08:08:61.091323414"), // not valid
+            Some("Not a valid time"),
+            None,
+        ])) as ArrayRef;
+        for array in &[a1, a2] {
+            let to_type = DataType::Time32(TimeUnit::Millisecond);
+            let b = cast(array, &to_type).unwrap();
+            let c = b.as_primitive::<Time32MillisecondType>();
+            assert_eq!(29315091, c.value(0));
+            assert_eq!(29340091, c.value(1));
+            assert!(c.is_null(2));
+            assert!(c.is_null(3));
+            assert!(c.is_null(4));
+
+            let options = CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            };
+            let err = cast_with_options(array, &to_type, &options).unwrap_err();
+            assert_eq!(err.to_string(), "Cast error: Cannot cast string '08:08:61.091323414' to value of Time32(Millisecond) type");
+        }
+    }
+
+    #[test]
+    fn test_cast_string_to_time64microsecond() {
+        let a1 = Arc::new(StringArray::from(vec![
+            Some("08:08:35.091323414"),
+            Some("Not a valid time"),
+            None,
+        ])) as ArrayRef;
+        let a2 = Arc::new(LargeStringArray::from(vec![
+            Some("08:08:35.091323414"),
+            Some("Not a valid time"),
+            None,
+        ])) as ArrayRef;
+        for array in &[a1, a2] {
+            let to_type = DataType::Time64(TimeUnit::Microsecond);
+            let b = cast(array, &to_type).unwrap();
+            let c = b.as_primitive::<Time64MicrosecondType>();
+            assert_eq!(29315091323, c.value(0));
+            assert!(c.is_null(1));
+            assert!(c.is_null(2));
+
+            let options = CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            };
+            let err = cast_with_options(array, &to_type, &options).unwrap_err();
+            assert_eq!(err.to_string(), "Cast error: Cannot cast string 'Not a valid time' to value of Time64(Microsecond) type");
+        }
+    }
+
+    #[test]
+    fn test_cast_string_to_time64nanosecond() {
+        let a1 = Arc::new(StringArray::from(vec![
+            Some("08:08:35.091323414"),
+            Some("Not a valid time"),
+            None,
+        ])) as ArrayRef;
+        let a2 = Arc::new(LargeStringArray::from(vec![
+            Some("08:08:35.091323414"),
+            Some("Not a valid time"),
+            None,
+        ])) as ArrayRef;
+        for array in &[a1, a2] {
+            let to_type = DataType::Time64(TimeUnit::Nanosecond);
+            let b = cast(array, &to_type).unwrap();
+            let c = b.as_primitive::<Time64NanosecondType>();
+            assert_eq!(29315091323414, c.value(0));
+            assert!(c.is_null(1));
+            assert!(c.is_null(2));
+
+            let options = CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            };
+            let err = cast_with_options(array, &to_type, &options).unwrap_err();
+            assert_eq!(err.to_string(), "Cast error: Cannot cast string 'Not a valid time' to value of Time64(Nanosecond) type");
+        }
+    }
+
+    #[test]
+    fn test_cast_string_to_date64() {
+        let a1 = Arc::new(StringArray::from(vec![
+            Some("2020-09-08T12:00:00"),
+            Some("Not a valid date"),
+            None,
+        ])) as ArrayRef;
+        let a2 = Arc::new(LargeStringArray::from(vec![
+            Some("2020-09-08T12:00:00"),
+            Some("Not a valid date"),
+            None,
+        ])) as ArrayRef;
+        for array in &[a1, a2] {
+            let to_type = DataType::Date64;
+            let b = cast(array, &to_type).unwrap();
+            let c = b.as_primitive::<Date64Type>();
+            assert_eq!(1599566400000, c.value(0));
+            assert!(c.is_null(1));
+            assert!(c.is_null(2));
+
+            let options = CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            };
+            let err = cast_with_options(array, &to_type, &options).unwrap_err();
+            assert_eq!(
+                err.to_string(),
+                "Cast error: Cannot cast string 'Not a valid date' to value of Date64 type"
+            );
+        }
+    }
+
+    macro_rules! test_safe_string_to_interval {
+        ($data_vec:expr, $interval_unit:expr, $array_ty:ty, $expect_vec:expr) => {
+            let source_string_array = Arc::new(StringArray::from($data_vec.clone())) as ArrayRef;
+
+            let options = CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            };
+
+            let target_interval_array = cast_with_options(
+                &source_string_array.clone(),
+                &DataType::Interval($interval_unit),
+                &options,
+            )
+            .unwrap()
+            .as_any()
+            .downcast_ref::<$array_ty>()
+            .unwrap()
+            .clone() as $array_ty;
+
+            let target_string_array =
+                cast_with_options(&target_interval_array, &DataType::Utf8, &options)
+                    .unwrap()
+                    .as_any()
+                    .downcast_ref::<StringArray>()
+                    .unwrap()
+                    .clone();
+
+            let expect_string_array = StringArray::from($expect_vec);
+
+            assert_eq!(target_string_array, expect_string_array);
+
+            let target_large_string_array =
+                cast_with_options(&target_interval_array, &DataType::LargeUtf8, &options)
+                    .unwrap()
+                    .as_any()
+                    .downcast_ref::<LargeStringArray>()
+                    .unwrap()
+                    .clone();
+
+            let expect_large_string_array = LargeStringArray::from($expect_vec);
+
+            assert_eq!(target_large_string_array, expect_large_string_array);
+        };
+    }
+
+    #[test]
+    fn test_cast_string_to_interval_year_month() {
+        test_safe_string_to_interval!(
+            vec![
+                Some("1 year 1 month"),
+                Some("1.5 years 13 month"),
+                Some("30 days"),
+                Some("31 days"),
+                Some("2 months 31 days"),
+                Some("2 months 31 days 1 second"),
+                Some("foobar"),
+            ],
+            IntervalUnit::YearMonth,
+            IntervalYearMonthArray,
+            vec![
+                Some("1 years 1 mons 0 days 0 hours 0 mins 0.00 secs"),
+                Some("2 years 7 mons 0 days 0 hours 0 mins 0.00 secs"),
+                None,
+                None,
+                None,
+                None,
+                None,
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_string_to_interval_day_time() {
+        test_safe_string_to_interval!(
+            vec![
+                Some("1 year 1 month"),
+                Some("1.5 years 13 month"),
+                Some("30 days"),
+                Some("1 day 2 second 3.5 milliseconds"),
+                Some("foobar"),
+            ],
+            IntervalUnit::DayTime,
+            IntervalDayTimeArray,
+            vec![
+                Some("0 years 0 mons 390 days 0 hours 0 mins 0.000 secs"),
+                Some("0 years 0 mons 930 days 0 hours 0 mins 0.000 secs"),
+                Some("0 years 0 mons 30 days 0 hours 0 mins 0.000 secs"),
+                None,
+                None,
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_string_to_interval_month_day_nano() {
+        test_safe_string_to_interval!(
+            vec![
+                Some("1 year 1 month 1 day"),
+                None,
+                Some("1.5 years 13 month 35 days 1.4 milliseconds"),
+                Some("3 days"),
+                Some("8 seconds"),
+                None,
+                Some("1 day 29800 milliseconds"),
+                Some("3 months 1 second"),
+                Some("6 minutes 120 second"),
+                Some("2 years 39 months 9 days 19 hours 1 minute 83 seconds 399222 milliseconds"),
+                Some("foobar"),
+            ],
+            IntervalUnit::MonthDayNano,
+            IntervalMonthDayNanoArray,
+            vec![
+                Some("0 years 13 mons 1 days 0 hours 0 mins 0.000000000 secs"),
+                None,
+                Some("0 years 31 mons 35 days 0 hours 0 mins 0.001400000 secs"),
+                Some("0 years 0 mons 3 days 0 hours 0 mins 0.000000000 secs"),
+                Some("0 years 0 mons 0 days 0 hours 0 mins 8.000000000 secs"),
+                None,
+                Some("0 years 0 mons 1 days 0 hours 0 mins 29.800000000 secs"),
+                Some("0 years 3 mons 0 days 0 hours 0 mins 1.000000000 secs"),
+                Some("0 years 0 mons 0 days 0 hours 8 mins 0.000000000 secs"),
+                Some("0 years 63 mons 9 days 19 hours 9 mins 2.222000000 secs"),
+                None,
+            ]
+        );
+    }
+
+    macro_rules! test_unsafe_string_to_interval_err {
+        ($data_vec:expr, $interval_unit:expr, $error_msg:expr) => {
+            let string_array = Arc::new(StringArray::from($data_vec.clone())) as ArrayRef;
+            let options = CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            };
+            let arrow_err = cast_with_options(
+                &string_array.clone(),
+                &DataType::Interval($interval_unit),
+                &options,
+            )
+            .unwrap_err();
+            assert_eq!($error_msg, arrow_err.to_string());
+        };
+    }
+
+    #[test]
+    fn test_cast_string_to_interval_err() {
+        test_unsafe_string_to_interval_err!(
+            vec![Some("foobar")],
+            IntervalUnit::YearMonth,
+            r#"Not yet implemented: Unsupported Interval Expression with value "foobar""#
+        );
+        test_unsafe_string_to_interval_err!(
+            vec![Some("foobar")],
+            IntervalUnit::DayTime,
+            r#"Not yet implemented: Unsupported Interval Expression with value "foobar""#
+        );
+        test_unsafe_string_to_interval_err!(
+            vec![Some("foobar")],
+            IntervalUnit::MonthDayNano,
+            r#"Not yet implemented: Unsupported Interval Expression with value "foobar""#
+        );
+        test_unsafe_string_to_interval_err!(
+            vec![Some("2 months 31 days 1 second")],
+            IntervalUnit::YearMonth,
+            r#"Cast error: Cannot cast 2 months 31 days 1 second to IntervalYearMonth. Only year and month fields are allowed."#
+        );
+        test_unsafe_string_to_interval_err!(
+            vec![Some("1 day 1.5 milliseconds")],
+            IntervalUnit::DayTime,
+            r#"Cast error: Cannot cast 1 day 1.5 milliseconds to IntervalDayTime because the nanos part isn't multiple of milliseconds"#
+        );
+
+        // overflow
+        test_unsafe_string_to_interval_err!(
+            vec![Some(format!(
+                "{} century {} year {} month",
+                i64::MAX - 2,
+                i64::MAX - 2,
+                i64::MAX - 2
+            ))],
+            IntervalUnit::DayTime,
+            format!(
+                "Compute error: Overflow happened on: {} * 100",
+                i64::MAX - 2
+            )
+        );
+        test_unsafe_string_to_interval_err!(
+            vec![Some(format!(
+                "{} year {} month {} day",
+                i64::MAX - 2,
+                i64::MAX - 2,
+                i64::MAX - 2
+            ))],
+            IntervalUnit::MonthDayNano,
+            format!("Compute error: Overflow happened on: {} * 12", i64::MAX - 2)
+        );
+    }
+
+    #[test]
+    fn test_cast_binary_to_fixed_size_binary() {
+        let bytes_1 = "Hiiii".as_bytes();
+        let bytes_2 = "Hello".as_bytes();
+
+        let binary_data = vec![Some(bytes_1), Some(bytes_2), None];
+        let a1 = Arc::new(BinaryArray::from(binary_data.clone())) as ArrayRef;
+        let a2 = Arc::new(LargeBinaryArray::from(binary_data)) as ArrayRef;
+
+        let array_ref = cast(&a1, &DataType::FixedSizeBinary(5)).unwrap();
+        let down_cast = array_ref
+            .as_any()
+            .downcast_ref::<FixedSizeBinaryArray>()
+            .unwrap();
+        assert_eq!(bytes_1, down_cast.value(0));
+        assert_eq!(bytes_2, down_cast.value(1));
+        assert!(down_cast.is_null(2));
+
+        let array_ref = cast(&a2, &DataType::FixedSizeBinary(5)).unwrap();
+        let down_cast = array_ref
+            .as_any()
+            .downcast_ref::<FixedSizeBinaryArray>()
+            .unwrap();
+        assert_eq!(bytes_1, down_cast.value(0));
+        assert_eq!(bytes_2, down_cast.value(1));
+        assert!(down_cast.is_null(2));
+
+        // test error cases when the length of binary are not same
+        let bytes_1 = "Hi".as_bytes();
+        let bytes_2 = "Hello".as_bytes();
+
+        let binary_data = vec![Some(bytes_1), Some(bytes_2), None];
+        let a1 = Arc::new(BinaryArray::from(binary_data.clone())) as ArrayRef;
+        let a2 = Arc::new(LargeBinaryArray::from(binary_data)) as ArrayRef;
+
+        let array_ref = cast_with_options(
+            &a1,
+            &DataType::FixedSizeBinary(5),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(array_ref.is_err());
+
+        let array_ref = cast_with_options(
+            &a2,
+            &DataType::FixedSizeBinary(5),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(array_ref.is_err());
+    }
+
+    #[test]
+    fn test_fixed_size_binary_to_binary() {
+        let bytes_1 = "Hiiii".as_bytes();
+        let bytes_2 = "Hello".as_bytes();
+
+        let binary_data = vec![Some(bytes_1), Some(bytes_2), None];
+        let a1 = Arc::new(FixedSizeBinaryArray::from(binary_data.clone())) as ArrayRef;
+
+        let array_ref = cast(&a1, &DataType::Binary).unwrap();
+        let down_cast = array_ref.as_binary::<i32>();
+        assert_eq!(bytes_1, down_cast.value(0));
+        assert_eq!(bytes_2, down_cast.value(1));
+        assert!(down_cast.is_null(2));
+
+        let array_ref = cast(&a1, &DataType::LargeBinary).unwrap();
+        let down_cast = array_ref.as_binary::<i64>();
+        assert_eq!(bytes_1, down_cast.value(0));
+        assert_eq!(bytes_2, down_cast.value(1));
+        assert!(down_cast.is_null(2));
+    }
+
+    #[test]
+    fn test_numeric_to_binary() {
+        let a = Int16Array::from(vec![Some(1), Some(511), None]);
+
+        let array_ref = cast(&a, &DataType::Binary).unwrap();
+        let down_cast = array_ref.as_binary::<i32>();
+        assert_eq!(&1_i16.to_le_bytes(), down_cast.value(0));
+        assert_eq!(&511_i16.to_le_bytes(), down_cast.value(1));
+        assert!(down_cast.is_null(2));
+
+        let a = Int64Array::from(vec![Some(-1), Some(123456789), None]);
+
+        let array_ref = cast(&a, &DataType::Binary).unwrap();
+        let down_cast = array_ref.as_binary::<i32>();
+        assert_eq!(&(-1_i64).to_le_bytes(), down_cast.value(0));
+        assert_eq!(&123456789_i64.to_le_bytes(), down_cast.value(1));
+        assert!(down_cast.is_null(2));
+    }
+
+    #[test]
+    fn test_numeric_to_large_binary() {
+        let a = Int16Array::from(vec![Some(1), Some(511), None]);
+
+        let array_ref = cast(&a, &DataType::LargeBinary).unwrap();
+        let down_cast = array_ref.as_binary::<i64>();
+        assert_eq!(&1_i16.to_le_bytes(), down_cast.value(0));
+        assert_eq!(&511_i16.to_le_bytes(), down_cast.value(1));
+        assert!(down_cast.is_null(2));
+
+        let a = Int64Array::from(vec![Some(-1), Some(123456789), None]);
+
+        let array_ref = cast(&a, &DataType::LargeBinary).unwrap();
+        let down_cast = array_ref.as_binary::<i64>();
+        assert_eq!(&(-1_i64).to_le_bytes(), down_cast.value(0));
+        assert_eq!(&123456789_i64.to_le_bytes(), down_cast.value(1));
+        assert!(down_cast.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_date32_to_int32() {
+        let array = Date32Array::from(vec![10000, 17890]);
+        let b = cast(&array, &DataType::Int32).unwrap();
+        let c = b.as_primitive::<Int32Type>();
+        assert_eq!(10000, c.value(0));
+        assert_eq!(17890, c.value(1));
+    }
+
+    #[test]
+    fn test_cast_int32_to_date32() {
+        let array = Int32Array::from(vec![10000, 17890]);
+        let b = cast(&array, &DataType::Date32).unwrap();
+        let c = b.as_primitive::<Date32Type>();
+        assert_eq!(10000, c.value(0));
+        assert_eq!(17890, c.value(1));
+    }
+
+    #[test]
+    fn test_cast_timestamp_to_date32() {
+        let array =
+            TimestampMillisecondArray::from(vec![Some(864000000005), Some(1545696000001), None])
+                .with_timezone("UTC".to_string());
+        let b = cast(&array, &DataType::Date32).unwrap();
+        let c = b.as_primitive::<Date32Type>();
+        assert_eq!(10000, c.value(0));
+        assert_eq!(17890, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_timestamp_to_date64() {
+        let array =
+            TimestampMillisecondArray::from(vec![Some(864000000005), Some(1545696000001), None]);
+        let b = cast(&array, &DataType::Date64).unwrap();
+        let c = b.as_primitive::<Date64Type>();
+        assert_eq!(864000000005, c.value(0));
+        assert_eq!(1545696000001, c.value(1));
+        assert!(c.is_null(2));
+
+        let array = TimestampSecondArray::from(vec![Some(864000000005), Some(1545696000001)]);
+        let b = cast(&array, &DataType::Date64).unwrap();
+        let c = b.as_primitive::<Date64Type>();
+        assert_eq!(864000000005000, c.value(0));
+        assert_eq!(1545696000001000, c.value(1));
+
+        // test overflow, safe cast
+        let array = TimestampSecondArray::from(vec![Some(i64::MAX)]);
+        let b = cast(&array, &DataType::Date64).unwrap();
+        assert!(b.is_null(0));
+        // test overflow, unsafe cast
+        let array = TimestampSecondArray::from(vec![Some(i64::MAX)]);
+        let options = CastOptions {
+            safe: false,
+            format_options: FormatOptions::default(),
+        };
+        let b = cast_with_options(&array, &DataType::Date64, &options);
+        assert!(b.is_err());
+    }
+
+    #[test]
+    fn test_cast_timestamp_to_time64() {
+        // test timestamp secs
+        let array = TimestampSecondArray::from(vec![Some(86405), Some(1), None])
+            .with_timezone("+01:00".to_string());
+        let b = cast(&array, &DataType::Time64(TimeUnit::Microsecond)).unwrap();
+        let c = b.as_primitive::<Time64MicrosecondType>();
+        assert_eq!(3605000000, c.value(0));
+        assert_eq!(3601000000, c.value(1));
+        assert!(c.is_null(2));
+        let b = cast(&array, &DataType::Time64(TimeUnit::Nanosecond)).unwrap();
+        let c = b.as_primitive::<Time64NanosecondType>();
+        assert_eq!(3605000000000, c.value(0));
+        assert_eq!(3601000000000, c.value(1));
+        assert!(c.is_null(2));
+
+        // test timestamp milliseconds
+        let a = TimestampMillisecondArray::from(vec![Some(86405000), Some(1000), None])
+            .with_timezone("+01:00".to_string());
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Time64(TimeUnit::Microsecond)).unwrap();
+        let c = b.as_primitive::<Time64MicrosecondType>();
+        assert_eq!(3605000000, c.value(0));
+        assert_eq!(3601000000, c.value(1));
+        assert!(c.is_null(2));
+        let b = cast(&array, &DataType::Time64(TimeUnit::Nanosecond)).unwrap();
+        let c = b.as_primitive::<Time64NanosecondType>();
+        assert_eq!(3605000000000, c.value(0));
+        assert_eq!(3601000000000, c.value(1));
+        assert!(c.is_null(2));
+
+        // test timestamp microseconds
+        let a = TimestampMicrosecondArray::from(vec![Some(86405000000), Some(1000000), None])
+            .with_timezone("+01:00".to_string());
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Time64(TimeUnit::Microsecond)).unwrap();
+        let c = b.as_primitive::<Time64MicrosecondType>();
+        assert_eq!(3605000000, c.value(0));
+        assert_eq!(3601000000, c.value(1));
+        assert!(c.is_null(2));
+        let b = cast(&array, &DataType::Time64(TimeUnit::Nanosecond)).unwrap();
+        let c = b.as_primitive::<Time64NanosecondType>();
+        assert_eq!(3605000000000, c.value(0));
+        assert_eq!(3601000000000, c.value(1));
+        assert!(c.is_null(2));
+
+        // test timestamp nanoseconds
+        let a = TimestampNanosecondArray::from(vec![Some(86405000000000), Some(1000000000), None])
+            .with_timezone("+01:00".to_string());
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Time64(TimeUnit::Microsecond)).unwrap();
+        let c = b.as_primitive::<Time64MicrosecondType>();
+        assert_eq!(3605000000, c.value(0));
+        assert_eq!(3601000000, c.value(1));
+        assert!(c.is_null(2));
+        let b = cast(&array, &DataType::Time64(TimeUnit::Nanosecond)).unwrap();
+        let c = b.as_primitive::<Time64NanosecondType>();
+        assert_eq!(3605000000000, c.value(0));
+        assert_eq!(3601000000000, c.value(1));
+        assert!(c.is_null(2));
+
+        // test overflow
+        let a =
+            TimestampSecondArray::from(vec![Some(i64::MAX)]).with_timezone("+01:00".to_string());
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Time64(TimeUnit::Microsecond));
+        assert!(b.is_err());
+        let b = cast(&array, &DataType::Time64(TimeUnit::Nanosecond));
+        assert!(b.is_err());
+        let b = cast(&array, &DataType::Time64(TimeUnit::Millisecond));
+        assert!(b.is_err());
+    }
+
+    #[test]
+    fn test_cast_timestamp_to_time32() {
+        // test timestamp secs
+        let a = TimestampSecondArray::from(vec![Some(86405), Some(1), None])
+            .with_timezone("+01:00".to_string());
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Time32(TimeUnit::Second)).unwrap();
+        let c = b.as_primitive::<Time32SecondType>();
+        assert_eq!(3605, c.value(0));
+        assert_eq!(3601, c.value(1));
+        assert!(c.is_null(2));
+        let b = cast(&array, &DataType::Time32(TimeUnit::Millisecond)).unwrap();
+        let c = b.as_primitive::<Time32MillisecondType>();
+        assert_eq!(3605000, c.value(0));
+        assert_eq!(3601000, c.value(1));
+        assert!(c.is_null(2));
+
+        // test timestamp milliseconds
+        let a = TimestampMillisecondArray::from(vec![Some(86405000), Some(1000), None])
+            .with_timezone("+01:00".to_string());
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Time32(TimeUnit::Second)).unwrap();
+        let c = b.as_primitive::<Time32SecondType>();
+        assert_eq!(3605, c.value(0));
+        assert_eq!(3601, c.value(1));
+        assert!(c.is_null(2));
+        let b = cast(&array, &DataType::Time32(TimeUnit::Millisecond)).unwrap();
+        let c = b.as_primitive::<Time32MillisecondType>();
+        assert_eq!(3605000, c.value(0));
+        assert_eq!(3601000, c.value(1));
+        assert!(c.is_null(2));
+
+        // test timestamp microseconds
+        let a = TimestampMicrosecondArray::from(vec![Some(86405000000), Some(1000000), None])
+            .with_timezone("+01:00".to_string());
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Time32(TimeUnit::Second)).unwrap();
+        let c = b.as_primitive::<Time32SecondType>();
+        assert_eq!(3605, c.value(0));
+        assert_eq!(3601, c.value(1));
+        assert!(c.is_null(2));
+        let b = cast(&array, &DataType::Time32(TimeUnit::Millisecond)).unwrap();
+        let c = b.as_primitive::<Time32MillisecondType>();
+        assert_eq!(3605000, c.value(0));
+        assert_eq!(3601000, c.value(1));
+        assert!(c.is_null(2));
+
+        // test timestamp nanoseconds
+        let a = TimestampNanosecondArray::from(vec![Some(86405000000000), Some(1000000000), None])
+            .with_timezone("+01:00".to_string());
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Time32(TimeUnit::Second)).unwrap();
+        let c = b.as_primitive::<Time32SecondType>();
+        assert_eq!(3605, c.value(0));
+        assert_eq!(3601, c.value(1));
+        assert!(c.is_null(2));
+        let b = cast(&array, &DataType::Time32(TimeUnit::Millisecond)).unwrap();
+        let c = b.as_primitive::<Time32MillisecondType>();
+        assert_eq!(3605000, c.value(0));
+        assert_eq!(3601000, c.value(1));
+        assert!(c.is_null(2));
+
+        // test overflow
+        let a =
+            TimestampSecondArray::from(vec![Some(i64::MAX)]).with_timezone("+01:00".to_string());
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Time32(TimeUnit::Second));
+        assert!(b.is_err());
+        let b = cast(&array, &DataType::Time32(TimeUnit::Millisecond));
+        assert!(b.is_err());
+    }
+
+    // Cast Timestamp(_, None) -> Timestamp(_, Some(timezone))
+    #[test]
+    fn test_cast_timestamp_with_timezone_1() {
+        let string_array: Arc<dyn Array> = Arc::new(StringArray::from(vec![
+            Some("2000-01-01T00:00:00.123456789"),
+            Some("2010-01-01T00:00:00.123456789"),
+            None,
+        ]));
+        let to_type = DataType::Timestamp(TimeUnit::Nanosecond, None);
+        let timestamp_array = cast(&string_array, &to_type).unwrap();
+
+        let to_type = DataType::Timestamp(TimeUnit::Microsecond, Some("+0700".into()));
+        let timestamp_array = cast(&timestamp_array, &to_type).unwrap();
+
+        let string_array = cast(&timestamp_array, &DataType::Utf8).unwrap();
+        let result = string_array.as_string::<i32>();
+        assert_eq!("2000-01-01T00:00:00.123456+07:00", result.value(0));
+        assert_eq!("2010-01-01T00:00:00.123456+07:00", result.value(1));
+        assert!(result.is_null(2));
+    }
+
+    // Cast Timestamp(_, Some(timezone)) -> Timestamp(_, None)
+    #[test]
+    fn test_cast_timestamp_with_timezone_2() {
+        let string_array: Arc<dyn Array> = Arc::new(StringArray::from(vec![
+            Some("2000-01-01T07:00:00.123456789"),
+            Some("2010-01-01T07:00:00.123456789"),
+            None,
+        ]));
+        let to_type = DataType::Timestamp(TimeUnit::Millisecond, Some("+0700".into()));
+        let timestamp_array = cast(&string_array, &to_type).unwrap();
+
+        // Check intermediate representation is correct
+        let string_array = cast(&timestamp_array, &DataType::Utf8).unwrap();
+        let result = string_array.as_string::<i32>();
+        assert_eq!("2000-01-01T07:00:00.123+07:00", result.value(0));
+        assert_eq!("2010-01-01T07:00:00.123+07:00", result.value(1));
+        assert!(result.is_null(2));
+
+        let to_type = DataType::Timestamp(TimeUnit::Nanosecond, None);
+        let timestamp_array = cast(&timestamp_array, &to_type).unwrap();
+
+        let string_array = cast(&timestamp_array, &DataType::Utf8).unwrap();
+        let result = string_array.as_string::<i32>();
+        assert_eq!("2000-01-01T00:00:00.123", result.value(0));
+        assert_eq!("2010-01-01T00:00:00.123", result.value(1));
+        assert!(result.is_null(2));
+    }
+
+    // Cast Timestamp(_, Some(timezone)) -> Timestamp(_, Some(timezone))
+    #[test]
+    fn test_cast_timestamp_with_timezone_3() {
+        let string_array: Arc<dyn Array> = Arc::new(StringArray::from(vec![
+            Some("2000-01-01T07:00:00.123456789"),
+            Some("2010-01-01T07:00:00.123456789"),
+            None,
+        ]));
+        let to_type = DataType::Timestamp(TimeUnit::Microsecond, Some("+0700".into()));
+        let timestamp_array = cast(&string_array, &to_type).unwrap();
+
+        // Check intermediate representation is correct
+        let string_array = cast(&timestamp_array, &DataType::Utf8).unwrap();
+        let result = string_array.as_string::<i32>();
+        assert_eq!("2000-01-01T07:00:00.123456+07:00", result.value(0));
+        assert_eq!("2010-01-01T07:00:00.123456+07:00", result.value(1));
+        assert!(result.is_null(2));
+
+        let to_type = DataType::Timestamp(TimeUnit::Second, Some("-08:00".into()));
+        let timestamp_array = cast(&timestamp_array, &to_type).unwrap();
+
+        let string_array = cast(&timestamp_array, &DataType::Utf8).unwrap();
+        let result = string_array.as_string::<i32>();
+        assert_eq!("1999-12-31T16:00:00-08:00", result.value(0));
+        assert_eq!("2009-12-31T16:00:00-08:00", result.value(1));
+        assert!(result.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_date64_to_timestamp() {
+        let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
+        let b = cast(&array, &DataType::Timestamp(TimeUnit::Second, None)).unwrap();
+        let c = b.as_primitive::<TimestampSecondType>();
+        assert_eq!(864000000, c.value(0));
+        assert_eq!(1545696000, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_date64_to_timestamp_ms() {
+        let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
+        let b = cast(&array, &DataType::Timestamp(TimeUnit::Millisecond, None)).unwrap();
+        let c = b
+            .as_any()
+            .downcast_ref::<TimestampMillisecondArray>()
+            .unwrap();
+        assert_eq!(864000000005, c.value(0));
+        assert_eq!(1545696000001, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_date64_to_timestamp_us() {
+        let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
+        let b = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+        let c = b
+            .as_any()
+            .downcast_ref::<TimestampMicrosecondArray>()
+            .unwrap();
+        assert_eq!(864000000005000, c.value(0));
+        assert_eq!(1545696000001000, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_date64_to_timestamp_ns() {
+        let array = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
+        let b = cast(&array, &DataType::Timestamp(TimeUnit::Nanosecond, None)).unwrap();
+        let c = b
+            .as_any()
+            .downcast_ref::<TimestampNanosecondArray>()
+            .unwrap();
+        assert_eq!(864000000005000000, c.value(0));
+        assert_eq!(1545696000001000000, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_timestamp_to_i64() {
+        let array =
+            TimestampMillisecondArray::from(vec![Some(864000000005), Some(1545696000001), None])
+                .with_timezone("UTC".to_string());
+        let b = cast(&array, &DataType::Int64).unwrap();
+        let c = b.as_primitive::<Int64Type>();
+        assert_eq!(&DataType::Int64, c.data_type());
+        assert_eq!(864000000005, c.value(0));
+        assert_eq!(1545696000001, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_date32_to_string() {
+        let array = Date32Array::from(vec![10000, 17890]);
+        let b = cast(&array, &DataType::Utf8).unwrap();
+        let c = b.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(&DataType::Utf8, c.data_type());
+        assert_eq!("1997-05-19", c.value(0));
+        assert_eq!("2018-12-25", c.value(1));
+    }
+
+    #[test]
+    fn test_cast_date64_to_string() {
+        let array = Date64Array::from(vec![10000 * 86400000, 17890 * 86400000]);
+        let b = cast(&array, &DataType::Utf8).unwrap();
+        let c = b.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(&DataType::Utf8, c.data_type());
+        assert_eq!("1997-05-19T00:00:00", c.value(0));
+        assert_eq!("2018-12-25T00:00:00", c.value(1));
+    }
+
+    #[test]
+    fn test_cast_timestamp_to_strings() {
+        // "2018-12-25T00:00:02.001", "1997-05-19T00:00:03.005", None
+        let array =
+            TimestampMillisecondArray::from(vec![Some(864000003005), Some(1545696002001), None]);
+        let out = cast(&array, &DataType::Utf8).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap()
+            .into_iter()
+            .collect::<Vec<_>>();
+        assert_eq!(
+            out,
+            vec![
+                Some("1997-05-19T00:00:03.005"),
+                Some("2018-12-25T00:00:02.001"),
+                None
+            ]
+        );
+        let out = cast(&array, &DataType::LargeUtf8).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<LargeStringArray>()
+            .unwrap()
+            .into_iter()
+            .collect::<Vec<_>>();
+        assert_eq!(
+            out,
+            vec![
+                Some("1997-05-19T00:00:03.005"),
+                Some("2018-12-25T00:00:02.001"),
+                None
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_timestamp_to_strings_opt() {
+        let ts_format = "%Y-%m-%d %H:%M:%S%.6f";
+        let tz = "+0545"; // UTC + 0545 is Asia/Kathmandu
+        let cast_options = CastOptions {
+            safe: true,
+            format_options: FormatOptions::default()
+                .with_timestamp_format(Some(ts_format))
+                .with_timestamp_tz_format(Some(ts_format)),
+        };
+        // "2018-12-25T00:00:02.001", "1997-05-19T00:00:03.005", None
+        let array_without_tz =
+            TimestampMillisecondArray::from(vec![Some(864000003005), Some(1545696002001), None]);
+        let out = cast_with_options(&array_without_tz, &DataType::Utf8, &cast_options).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap()
+            .into_iter()
+            .collect::<Vec<_>>();
+        assert_eq!(
+            out,
+            vec![
+                Some("1997-05-19 00:00:03.005000"),
+                Some("2018-12-25 00:00:02.001000"),
+                None
+            ]
+        );
+        let out =
+            cast_with_options(&array_without_tz, &DataType::LargeUtf8, &cast_options).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<LargeStringArray>()
+            .unwrap()
+            .into_iter()
+            .collect::<Vec<_>>();
+        assert_eq!(
+            out,
+            vec![
+                Some("1997-05-19 00:00:03.005000"),
+                Some("2018-12-25 00:00:02.001000"),
+                None
+            ]
+        );
+
+        let array_with_tz =
+            TimestampMillisecondArray::from(vec![Some(864000003005), Some(1545696002001), None])
+                .with_timezone(tz.to_string());
+        let out = cast_with_options(&array_with_tz, &DataType::Utf8, &cast_options).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap()
+            .into_iter()
+            .collect::<Vec<_>>();
+        assert_eq!(
+            out,
+            vec![
+                Some("1997-05-19 05:45:03.005000"),
+                Some("2018-12-25 05:45:02.001000"),
+                None
+            ]
+        );
+        let out = cast_with_options(&array_with_tz, &DataType::LargeUtf8, &cast_options).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<LargeStringArray>()
+            .unwrap()
+            .into_iter()
+            .collect::<Vec<_>>();
+        assert_eq!(
+            out,
+            vec![
+                Some("1997-05-19 05:45:03.005000"),
+                Some("2018-12-25 05:45:02.001000"),
+                None
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_between_timestamps() {
+        let array =
+            TimestampMillisecondArray::from(vec![Some(864000003005), Some(1545696002001), None]);
+        let b = cast(&array, &DataType::Timestamp(TimeUnit::Second, None)).unwrap();
+        let c = b.as_primitive::<TimestampSecondType>();
+        assert_eq!(864000003, c.value(0));
+        assert_eq!(1545696002, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_duration_to_i64() {
+        let base = vec![5, 6, 7, 8, 100000000];
+
+        let duration_arrays = vec![
+            Arc::new(DurationNanosecondArray::from(base.clone())) as ArrayRef,
+            Arc::new(DurationMicrosecondArray::from(base.clone())) as ArrayRef,
+            Arc::new(DurationMillisecondArray::from(base.clone())) as ArrayRef,
+            Arc::new(DurationSecondArray::from(base.clone())) as ArrayRef,
+        ];
+
+        for arr in duration_arrays {
+            assert!(can_cast_types(arr.data_type(), &DataType::Int64));
+            let result = cast(&arr, &DataType::Int64).unwrap();
+            let result = result.as_primitive::<Int64Type>();
+            assert_eq!(base.as_slice(), result.values());
+        }
+    }
+
+    #[test]
+    fn test_cast_interval_to_i64() {
+        let base = vec![5, 6, 7, 8];
+
+        let interval_arrays = vec![
+            Arc::new(IntervalDayTimeArray::from(base.clone())) as ArrayRef,
+            Arc::new(IntervalYearMonthArray::from(
+                base.iter().map(|x| *x as i32).collect::<Vec<i32>>(),
+            )) as ArrayRef,
+        ];
+
+        for arr in interval_arrays {
+            assert!(can_cast_types(arr.data_type(), &DataType::Int64));
+            let result = cast(&arr, &DataType::Int64).unwrap();
+            let result = result.as_primitive::<Int64Type>();
+            assert_eq!(base.as_slice(), result.values());
+        }
+    }
+
+    #[test]
+    fn test_cast_to_strings() {
+        let a = Int32Array::from(vec![1, 2, 3]);
+        let out = cast(&a, &DataType::Utf8).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap()
+            .into_iter()
+            .collect::<Vec<_>>();
+        assert_eq!(out, vec![Some("1"), Some("2"), Some("3")]);
+        let out = cast(&a, &DataType::LargeUtf8).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<LargeStringArray>()
+            .unwrap()
+            .into_iter()
+            .collect::<Vec<_>>();
+        assert_eq!(out, vec![Some("1"), Some("2"), Some("3")]);
+    }
+
+    #[test]
+    fn test_str_to_str_casts() {
+        for data in [
+            vec![Some("foo"), Some("bar"), Some("ham")],
+            vec![Some("foo"), None, Some("bar")],
+        ] {
+            let a = LargeStringArray::from(data.clone());
+            let to = cast(&a, &DataType::Utf8).unwrap();
+            let expect = a
+                .as_any()
+                .downcast_ref::<LargeStringArray>()
+                .unwrap()
+                .into_iter()
+                .collect::<Vec<_>>();
+            let out = to
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap()
+                .into_iter()
+                .collect::<Vec<_>>();
+            assert_eq!(expect, out);
+
+            let a = StringArray::from(data);
+            let to = cast(&a, &DataType::LargeUtf8).unwrap();
+            let expect = a
+                .as_any()
+                .downcast_ref::<StringArray>()
+                .unwrap()
+                .into_iter()
+                .collect::<Vec<_>>();
+            let out = to
+                .as_any()
+                .downcast_ref::<LargeStringArray>()
+                .unwrap()
+                .into_iter()
+                .collect::<Vec<_>>();
+            assert_eq!(expect, out);
+        }
+    }
+
+    #[test]
+    fn test_cast_from_f64() {
+        let f64_values: Vec<f64> = vec![
+            i64::MIN as f64,
+            i32::MIN as f64,
+            i16::MIN as f64,
+            i8::MIN as f64,
+            0_f64,
+            u8::MAX as f64,
+            u16::MAX as f64,
+            u32::MAX as f64,
+            u64::MAX as f64,
+        ];
+        let f64_array: ArrayRef = Arc::new(Float64Array::from(f64_values));
+
+        let f64_expected = vec![
+            -9223372036854776000.0,
+            -2147483648.0,
+            -32768.0,
+            -128.0,
+            0.0,
+            255.0,
+            65535.0,
+            4294967295.0,
+            18446744073709552000.0,
+        ];
+        assert_eq!(
+            f64_expected,
+            get_cast_values::<Float64Type>(&f64_array, &DataType::Float64)
+                .iter()
+                .map(|i| i.parse::<f64>().unwrap())
+                .collect::<Vec<f64>>()
+        );
+
+        let f32_expected = vec![
+            -9223372000000000000.0,
+            -2147483600.0,
+            -32768.0,
+            -128.0,
+            0.0,
+            255.0,
+            65535.0,
+            4294967300.0,
+            18446744000000000000.0,
+        ];
+        assert_eq!(
+            f32_expected,
+            get_cast_values::<Float32Type>(&f64_array, &DataType::Float32)
+                .iter()
+                .map(|i| i.parse::<f32>().unwrap())
+                .collect::<Vec<f32>>()
+        );
+
+        let f16_expected = vec![
+            f16::from_f64(-9223372000000000000.0),
+            f16::from_f64(-2147483600.0),
+            f16::from_f64(-32768.0),
+            f16::from_f64(-128.0),
+            f16::from_f64(0.0),
+            f16::from_f64(255.0),
+            f16::from_f64(65535.0),
+            f16::from_f64(4294967300.0),
+            f16::from_f64(18446744000000000000.0),
+        ];
+        assert_eq!(
+            f16_expected,
+            get_cast_values::<Float16Type>(&f64_array, &DataType::Float16)
+                .iter()
+                .map(|i| i.parse::<f16>().unwrap())
+                .collect::<Vec<f16>>()
+        );
+
+        let i64_expected = vec![
+            "-9223372036854775808",
+            "-2147483648",
+            "-32768",
+            "-128",
+            "0",
+            "255",
+            "65535",
+            "4294967295",
+            "null",
+        ];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Int64Type>(&f64_array, &DataType::Int64)
+        );
+
+        let i32_expected = vec![
+            "null",
+            "-2147483648",
+            "-32768",
+            "-128",
+            "0",
+            "255",
+            "65535",
+            "null",
+            "null",
+        ];
+        assert_eq!(
+            i32_expected,
+            get_cast_values::<Int32Type>(&f64_array, &DataType::Int32)
+        );
+
+        let i16_expected = vec![
+            "null", "null", "-32768", "-128", "0", "255", "null", "null", "null",
+        ];
+        assert_eq!(
+            i16_expected,
+            get_cast_values::<Int16Type>(&f64_array, &DataType::Int16)
+        );
+
+        let i8_expected = vec![
+            "null", "null", "null", "-128", "0", "null", "null", "null", "null",
+        ];
+        assert_eq!(
+            i8_expected,
+            get_cast_values::<Int8Type>(&f64_array, &DataType::Int8)
+        );
+
+        let u64_expected = vec![
+            "null",
+            "null",
+            "null",
+            "null",
+            "0",
+            "255",
+            "65535",
+            "4294967295",
+            "null",
+        ];
+        assert_eq!(
+            u64_expected,
+            get_cast_values::<UInt64Type>(&f64_array, &DataType::UInt64)
+        );
+
+        let u32_expected = vec![
+            "null",
+            "null",
+            "null",
+            "null",
+            "0",
+            "255",
+            "65535",
+            "4294967295",
+            "null",
+        ];
+        assert_eq!(
+            u32_expected,
+            get_cast_values::<UInt32Type>(&f64_array, &DataType::UInt32)
+        );
+
+        let u16_expected = vec![
+            "null", "null", "null", "null", "0", "255", "65535", "null", "null",
+        ];
+        assert_eq!(
+            u16_expected,
+            get_cast_values::<UInt16Type>(&f64_array, &DataType::UInt16)
+        );
+
+        let u8_expected = vec![
+            "null", "null", "null", "null", "0", "255", "null", "null", "null",
+        ];
+        assert_eq!(
+            u8_expected,
+            get_cast_values::<UInt8Type>(&f64_array, &DataType::UInt8)
+        );
+    }
+
+    #[test]
+    fn test_cast_from_f32() {
+        let f32_values: Vec<f32> = vec![
+            i32::MIN as f32,
+            i32::MIN as f32,
+            i16::MIN as f32,
+            i8::MIN as f32,
+            0_f32,
+            u8::MAX as f32,
+            u16::MAX as f32,
+            u32::MAX as f32,
+            u32::MAX as f32,
+        ];
+        let f32_array: ArrayRef = Arc::new(Float32Array::from(f32_values));
+
+        let f64_expected = vec![
+            "-2147483648.0",
+            "-2147483648.0",
+            "-32768.0",
+            "-128.0",
+            "0.0",
+            "255.0",
+            "65535.0",
+            "4294967296.0",
+            "4294967296.0",
+        ];
+        assert_eq!(
+            f64_expected,
+            get_cast_values::<Float64Type>(&f32_array, &DataType::Float64)
+        );
+
+        let f32_expected = vec![
+            "-2147483600.0",
+            "-2147483600.0",
+            "-32768.0",
+            "-128.0",
+            "0.0",
+            "255.0",
+            "65535.0",
+            "4294967300.0",
+            "4294967300.0",
+        ];
+        assert_eq!(
+            f32_expected,
+            get_cast_values::<Float32Type>(&f32_array, &DataType::Float32)
+        );
+
+        let f16_expected = vec![
+            "-inf", "-inf", "-32768.0", "-128.0", "0.0", "255.0", "inf", "inf", "inf",
+        ];
+        assert_eq!(
+            f16_expected,
+            get_cast_values::<Float16Type>(&f32_array, &DataType::Float16)
+        );
+
+        let i64_expected = vec![
+            "-2147483648",
+            "-2147483648",
+            "-32768",
+            "-128",
+            "0",
+            "255",
+            "65535",
+            "4294967296",
+            "4294967296",
+        ];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Int64Type>(&f32_array, &DataType::Int64)
+        );
+
+        let i32_expected = vec![
+            "-2147483648",
+            "-2147483648",
+            "-32768",
+            "-128",
+            "0",
+            "255",
+            "65535",
+            "null",
+            "null",
+        ];
+        assert_eq!(
+            i32_expected,
+            get_cast_values::<Int32Type>(&f32_array, &DataType::Int32)
+        );
+
+        let i16_expected = vec![
+            "null", "null", "-32768", "-128", "0", "255", "null", "null", "null",
+        ];
+        assert_eq!(
+            i16_expected,
+            get_cast_values::<Int16Type>(&f32_array, &DataType::Int16)
+        );
+
+        let i8_expected = vec![
+            "null", "null", "null", "-128", "0", "null", "null", "null", "null",
+        ];
+        assert_eq!(
+            i8_expected,
+            get_cast_values::<Int8Type>(&f32_array, &DataType::Int8)
+        );
+
+        let u64_expected = vec![
+            "null",
+            "null",
+            "null",
+            "null",
+            "0",
+            "255",
+            "65535",
+            "4294967296",
+            "4294967296",
+        ];
+        assert_eq!(
+            u64_expected,
+            get_cast_values::<UInt64Type>(&f32_array, &DataType::UInt64)
+        );
+
+        let u32_expected = vec![
+            "null", "null", "null", "null", "0", "255", "65535", "null", "null",
+        ];
+        assert_eq!(
+            u32_expected,
+            get_cast_values::<UInt32Type>(&f32_array, &DataType::UInt32)
+        );
+
+        let u16_expected = vec![
+            "null", "null", "null", "null", "0", "255", "65535", "null", "null",
+        ];
+        assert_eq!(
+            u16_expected,
+            get_cast_values::<UInt16Type>(&f32_array, &DataType::UInt16)
+        );
+
+        let u8_expected = vec![
+            "null", "null", "null", "null", "0", "255", "null", "null", "null",
+        ];
+        assert_eq!(
+            u8_expected,
+            get_cast_values::<UInt8Type>(&f32_array, &DataType::UInt8)
+        );
+    }
+
+    #[test]
+    fn test_cast_from_uint64() {
+        let u64_values: Vec<u64> = vec![
+            0,
+            u8::MAX as u64,
+            u16::MAX as u64,
+            u32::MAX as u64,
+            u64::MAX,
+        ];
+        let u64_array: ArrayRef = Arc::new(UInt64Array::from(u64_values));
+
+        let f64_expected = vec![0.0, 255.0, 65535.0, 4294967295.0, 18446744073709552000.0];
+        assert_eq!(
+            f64_expected,
+            get_cast_values::<Float64Type>(&u64_array, &DataType::Float64)
+                .iter()
+                .map(|i| i.parse::<f64>().unwrap())
+                .collect::<Vec<f64>>()
+        );
+
+        let f32_expected = vec![0.0, 255.0, 65535.0, 4294967300.0, 18446744000000000000.0];
+        assert_eq!(
+            f32_expected,
+            get_cast_values::<Float32Type>(&u64_array, &DataType::Float32)
+                .iter()
+                .map(|i| i.parse::<f32>().unwrap())
+                .collect::<Vec<f32>>()
+        );
+
+        let f16_expected = vec![
+            f16::from_f64(0.0),
+            f16::from_f64(255.0),
+            f16::from_f64(65535.0),
+            f16::from_f64(4294967300.0),
+            f16::from_f64(18446744000000000000.0),
+        ];
+        assert_eq!(
+            f16_expected,
+            get_cast_values::<Float16Type>(&u64_array, &DataType::Float16)
+                .iter()
+                .map(|i| i.parse::<f16>().unwrap())
+                .collect::<Vec<f16>>()
+        );
+
+        let i64_expected = vec!["0", "255", "65535", "4294967295", "null"];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Int64Type>(&u64_array, &DataType::Int64)
+        );
+
+        let i32_expected = vec!["0", "255", "65535", "null", "null"];
+        assert_eq!(
+            i32_expected,
+            get_cast_values::<Int32Type>(&u64_array, &DataType::Int32)
+        );
+
+        let i16_expected = vec!["0", "255", "null", "null", "null"];
+        assert_eq!(
+            i16_expected,
+            get_cast_values::<Int16Type>(&u64_array, &DataType::Int16)
+        );
+
+        let i8_expected = vec!["0", "null", "null", "null", "null"];
+        assert_eq!(
+            i8_expected,
+            get_cast_values::<Int8Type>(&u64_array, &DataType::Int8)
+        );
+
+        let u64_expected = vec!["0", "255", "65535", "4294967295", "18446744073709551615"];
+        assert_eq!(
+            u64_expected,
+            get_cast_values::<UInt64Type>(&u64_array, &DataType::UInt64)
+        );
+
+        let u32_expected = vec!["0", "255", "65535", "4294967295", "null"];
+        assert_eq!(
+            u32_expected,
+            get_cast_values::<UInt32Type>(&u64_array, &DataType::UInt32)
+        );
+
+        let u16_expected = vec!["0", "255", "65535", "null", "null"];
+        assert_eq!(
+            u16_expected,
+            get_cast_values::<UInt16Type>(&u64_array, &DataType::UInt16)
+        );
+
+        let u8_expected = vec!["0", "255", "null", "null", "null"];
+        assert_eq!(
+            u8_expected,
+            get_cast_values::<UInt8Type>(&u64_array, &DataType::UInt8)
+        );
+    }
+
+    #[test]
+    fn test_cast_from_uint32() {
+        let u32_values: Vec<u32> = vec![0, u8::MAX as u32, u16::MAX as u32, u32::MAX];
+        let u32_array: ArrayRef = Arc::new(UInt32Array::from(u32_values));
+
+        let f64_expected = vec!["0.0", "255.0", "65535.0", "4294967295.0"];
+        assert_eq!(
+            f64_expected,
+            get_cast_values::<Float64Type>(&u32_array, &DataType::Float64)
+        );
+
+        let f32_expected = vec!["0.0", "255.0", "65535.0", "4294967300.0"];
+        assert_eq!(
+            f32_expected,
+            get_cast_values::<Float32Type>(&u32_array, &DataType::Float32)
+        );
+
+        let f16_expected = vec!["0.0", "255.0", "inf", "inf"];
+        assert_eq!(
+            f16_expected,
+            get_cast_values::<Float16Type>(&u32_array, &DataType::Float16)
+        );
+
+        let i64_expected = vec!["0", "255", "65535", "4294967295"];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Int64Type>(&u32_array, &DataType::Int64)
+        );
+
+        let i32_expected = vec!["0", "255", "65535", "null"];
+        assert_eq!(
+            i32_expected,
+            get_cast_values::<Int32Type>(&u32_array, &DataType::Int32)
+        );
+
+        let i16_expected = vec!["0", "255", "null", "null"];
+        assert_eq!(
+            i16_expected,
+            get_cast_values::<Int16Type>(&u32_array, &DataType::Int16)
+        );
+
+        let i8_expected = vec!["0", "null", "null", "null"];
+        assert_eq!(
+            i8_expected,
+            get_cast_values::<Int8Type>(&u32_array, &DataType::Int8)
+        );
+
+        let u64_expected = vec!["0", "255", "65535", "4294967295"];
+        assert_eq!(
+            u64_expected,
+            get_cast_values::<UInt64Type>(&u32_array, &DataType::UInt64)
+        );
+
+        let u32_expected = vec!["0", "255", "65535", "4294967295"];
+        assert_eq!(
+            u32_expected,
+            get_cast_values::<UInt32Type>(&u32_array, &DataType::UInt32)
+        );
+
+        let u16_expected = vec!["0", "255", "65535", "null"];
+        assert_eq!(
+            u16_expected,
+            get_cast_values::<UInt16Type>(&u32_array, &DataType::UInt16)
+        );
+
+        let u8_expected = vec!["0", "255", "null", "null"];
+        assert_eq!(
+            u8_expected,
+            get_cast_values::<UInt8Type>(&u32_array, &DataType::UInt8)
+        );
+    }
+
+    #[test]
+    fn test_cast_from_uint16() {
+        let u16_values: Vec<u16> = vec![0, u8::MAX as u16, u16::MAX];
+        let u16_array: ArrayRef = Arc::new(UInt16Array::from(u16_values));
+
+        let f64_expected = vec!["0.0", "255.0", "65535.0"];
+        assert_eq!(
+            f64_expected,
+            get_cast_values::<Float64Type>(&u16_array, &DataType::Float64)
+        );
+
+        let f32_expected = vec!["0.0", "255.0", "65535.0"];
+        assert_eq!(
+            f32_expected,
+            get_cast_values::<Float32Type>(&u16_array, &DataType::Float32)
+        );
+
+        let f16_expected = vec!["0.0", "255.0", "inf"];
+        assert_eq!(
+            f16_expected,
+            get_cast_values::<Float16Type>(&u16_array, &DataType::Float16)
+        );
+
+        let i64_expected = vec!["0", "255", "65535"];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Int64Type>(&u16_array, &DataType::Int64)
+        );
+
+        let i32_expected = vec!["0", "255", "65535"];
+        assert_eq!(
+            i32_expected,
+            get_cast_values::<Int32Type>(&u16_array, &DataType::Int32)
+        );
+
+        let i16_expected = vec!["0", "255", "null"];
+        assert_eq!(
+            i16_expected,
+            get_cast_values::<Int16Type>(&u16_array, &DataType::Int16)
+        );
+
+        let i8_expected = vec!["0", "null", "null"];
+        assert_eq!(
+            i8_expected,
+            get_cast_values::<Int8Type>(&u16_array, &DataType::Int8)
+        );
+
+        let u64_expected = vec!["0", "255", "65535"];
+        assert_eq!(
+            u64_expected,
+            get_cast_values::<UInt64Type>(&u16_array, &DataType::UInt64)
+        );
+
+        let u32_expected = vec!["0", "255", "65535"];
+        assert_eq!(
+            u32_expected,
+            get_cast_values::<UInt32Type>(&u16_array, &DataType::UInt32)
+        );
+
+        let u16_expected = vec!["0", "255", "65535"];
+        assert_eq!(
+            u16_expected,
+            get_cast_values::<UInt16Type>(&u16_array, &DataType::UInt16)
+        );
+
+        let u8_expected = vec!["0", "255", "null"];
+        assert_eq!(
+            u8_expected,
+            get_cast_values::<UInt8Type>(&u16_array, &DataType::UInt8)
+        );
+    }
+
+    #[test]
+    fn test_cast_from_uint8() {
+        let u8_values: Vec<u8> = vec![0, u8::MAX];
+        let u8_array: ArrayRef = Arc::new(UInt8Array::from(u8_values));
+
+        let f64_expected = vec!["0.0", "255.0"];
+        assert_eq!(
+            f64_expected,
+            get_cast_values::<Float64Type>(&u8_array, &DataType::Float64)
+        );
+
+        let f32_expected = vec!["0.0", "255.0"];
+        assert_eq!(
+            f32_expected,
+            get_cast_values::<Float32Type>(&u8_array, &DataType::Float32)
+        );
+
+        let f16_expected = vec!["0.0", "255.0"];
+        assert_eq!(
+            f16_expected,
+            get_cast_values::<Float16Type>(&u8_array, &DataType::Float16)
+        );
+
+        let i64_expected = vec!["0", "255"];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Int64Type>(&u8_array, &DataType::Int64)
+        );
+
+        let i32_expected = vec!["0", "255"];
+        assert_eq!(
+            i32_expected,
+            get_cast_values::<Int32Type>(&u8_array, &DataType::Int32)
+        );
+
+        let i16_expected = vec!["0", "255"];
+        assert_eq!(
+            i16_expected,
+            get_cast_values::<Int16Type>(&u8_array, &DataType::Int16)
+        );
+
+        let i8_expected = vec!["0", "null"];
+        assert_eq!(
+            i8_expected,
+            get_cast_values::<Int8Type>(&u8_array, &DataType::Int8)
+        );
+
+        let u64_expected = vec!["0", "255"];
+        assert_eq!(
+            u64_expected,
+            get_cast_values::<UInt64Type>(&u8_array, &DataType::UInt64)
+        );
+
+        let u32_expected = vec!["0", "255"];
+        assert_eq!(
+            u32_expected,
+            get_cast_values::<UInt32Type>(&u8_array, &DataType::UInt32)
+        );
+
+        let u16_expected = vec!["0", "255"];
+        assert_eq!(
+            u16_expected,
+            get_cast_values::<UInt16Type>(&u8_array, &DataType::UInt16)
+        );
+
+        let u8_expected = vec!["0", "255"];
+        assert_eq!(
+            u8_expected,
+            get_cast_values::<UInt8Type>(&u8_array, &DataType::UInt8)
+        );
+    }
+
+    #[test]
+    fn test_cast_from_int64() {
+        let i64_values: Vec<i64> = vec![
+            i64::MIN,
+            i32::MIN as i64,
+            i16::MIN as i64,
+            i8::MIN as i64,
+            0,
+            i8::MAX as i64,
+            i16::MAX as i64,
+            i32::MAX as i64,
+            i64::MAX,
+        ];
+        let i64_array: ArrayRef = Arc::new(Int64Array::from(i64_values));
+
+        let f64_expected = vec![
+            -9223372036854776000.0,
+            -2147483648.0,
+            -32768.0,
+            -128.0,
+            0.0,
+            127.0,
+            32767.0,
+            2147483647.0,
+            9223372036854776000.0,
+        ];
+        assert_eq!(
+            f64_expected,
+            get_cast_values::<Float64Type>(&i64_array, &DataType::Float64)
+                .iter()
+                .map(|i| i.parse::<f64>().unwrap())
+                .collect::<Vec<f64>>()
+        );
+
+        let f32_expected = vec![
+            -9223372000000000000.0,
+            -2147483600.0,
+            -32768.0,
+            -128.0,
+            0.0,
+            127.0,
+            32767.0,
+            2147483600.0,
+            9223372000000000000.0,
+        ];
+        assert_eq!(
+            f32_expected,
+            get_cast_values::<Float32Type>(&i64_array, &DataType::Float32)
+                .iter()
+                .map(|i| i.parse::<f32>().unwrap())
+                .collect::<Vec<f32>>()
+        );
+
+        let f16_expected = vec![
+            f16::from_f64(-9223372000000000000.0),
+            f16::from_f64(-2147483600.0),
+            f16::from_f64(-32768.0),
+            f16::from_f64(-128.0),
+            f16::from_f64(0.0),
+            f16::from_f64(127.0),
+            f16::from_f64(32767.0),
+            f16::from_f64(2147483600.0),
+            f16::from_f64(9223372000000000000.0),
+        ];
+        assert_eq!(
+            f16_expected,
+            get_cast_values::<Float16Type>(&i64_array, &DataType::Float16)
+                .iter()
+                .map(|i| i.parse::<f16>().unwrap())
+                .collect::<Vec<f16>>()
+        );
+
+        let i64_expected = vec![
+            "-9223372036854775808",
+            "-2147483648",
+            "-32768",
+            "-128",
+            "0",
+            "127",
+            "32767",
+            "2147483647",
+            "9223372036854775807",
+        ];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Int64Type>(&i64_array, &DataType::Int64)
+        );
+
+        let i32_expected = vec![
+            "null",
+            "-2147483648",
+            "-32768",
+            "-128",
+            "0",
+            "127",
+            "32767",
+            "2147483647",
+            "null",
+        ];
+        assert_eq!(
+            i32_expected,
+            get_cast_values::<Int32Type>(&i64_array, &DataType::Int32)
+        );
+
+        assert_eq!(
+            i32_expected,
+            get_cast_values::<Date32Type>(&i64_array, &DataType::Date32)
+        );
+
+        let i16_expected = vec![
+            "null", "null", "-32768", "-128", "0", "127", "32767", "null", "null",
+        ];
+        assert_eq!(
+            i16_expected,
+            get_cast_values::<Int16Type>(&i64_array, &DataType::Int16)
+        );
+
+        let i8_expected = vec![
+            "null", "null", "null", "-128", "0", "127", "null", "null", "null",
+        ];
+        assert_eq!(
+            i8_expected,
+            get_cast_values::<Int8Type>(&i64_array, &DataType::Int8)
+        );
+
+        let u64_expected = vec![
+            "null",
+            "null",
+            "null",
+            "null",
+            "0",
+            "127",
+            "32767",
+            "2147483647",
+            "9223372036854775807",
+        ];
+        assert_eq!(
+            u64_expected,
+            get_cast_values::<UInt64Type>(&i64_array, &DataType::UInt64)
+        );
+
+        let u32_expected = vec![
+            "null",
+            "null",
+            "null",
+            "null",
+            "0",
+            "127",
+            "32767",
+            "2147483647",
+            "null",
+        ];
+        assert_eq!(
+            u32_expected,
+            get_cast_values::<UInt32Type>(&i64_array, &DataType::UInt32)
+        );
+
+        let u16_expected = vec![
+            "null", "null", "null", "null", "0", "127", "32767", "null", "null",
+        ];
+        assert_eq!(
+            u16_expected,
+            get_cast_values::<UInt16Type>(&i64_array, &DataType::UInt16)
+        );
+
+        let u8_expected = vec![
+            "null", "null", "null", "null", "0", "127", "null", "null", "null",
+        ];
+        assert_eq!(
+            u8_expected,
+            get_cast_values::<UInt8Type>(&i64_array, &DataType::UInt8)
+        );
+    }
+
+    #[test]
+    fn test_cast_from_int32() {
+        let i32_values: Vec<i32> = vec![
+            i32::MIN,
+            i16::MIN as i32,
+            i8::MIN as i32,
+            0,
+            i8::MAX as i32,
+            i16::MAX as i32,
+            i32::MAX,
+        ];
+        let i32_array: ArrayRef = Arc::new(Int32Array::from(i32_values));
+
+        let f64_expected = vec![
+            "-2147483648.0",
+            "-32768.0",
+            "-128.0",
+            "0.0",
+            "127.0",
+            "32767.0",
+            "2147483647.0",
+        ];
+        assert_eq!(
+            f64_expected,
+            get_cast_values::<Float64Type>(&i32_array, &DataType::Float64)
+        );
+
+        let f32_expected = vec![
+            "-2147483600.0",
+            "-32768.0",
+            "-128.0",
+            "0.0",
+            "127.0",
+            "32767.0",
+            "2147483600.0",
+        ];
+        assert_eq!(
+            f32_expected,
+            get_cast_values::<Float32Type>(&i32_array, &DataType::Float32)
+        );
+
+        let f16_expected = vec![
+            f16::from_f64(-2147483600.0),
+            f16::from_f64(-32768.0),
+            f16::from_f64(-128.0),
+            f16::from_f64(0.0),
+            f16::from_f64(127.0),
+            f16::from_f64(32767.0),
+            f16::from_f64(2147483600.0),
+        ];
+        assert_eq!(
+            f16_expected,
+            get_cast_values::<Float16Type>(&i32_array, &DataType::Float16)
+                .iter()
+                .map(|i| i.parse::<f16>().unwrap())
+                .collect::<Vec<f16>>()
+        );
+
+        let i16_expected = vec!["null", "-32768", "-128", "0", "127", "32767", "null"];
+        assert_eq!(
+            i16_expected,
+            get_cast_values::<Int16Type>(&i32_array, &DataType::Int16)
+        );
+
+        let i8_expected = vec!["null", "null", "-128", "0", "127", "null", "null"];
+        assert_eq!(
+            i8_expected,
+            get_cast_values::<Int8Type>(&i32_array, &DataType::Int8)
+        );
+
+        let u64_expected = vec!["null", "null", "null", "0", "127", "32767", "2147483647"];
+        assert_eq!(
+            u64_expected,
+            get_cast_values::<UInt64Type>(&i32_array, &DataType::UInt64)
+        );
+
+        let u32_expected = vec!["null", "null", "null", "0", "127", "32767", "2147483647"];
+        assert_eq!(
+            u32_expected,
+            get_cast_values::<UInt32Type>(&i32_array, &DataType::UInt32)
+        );
+
+        let u16_expected = vec!["null", "null", "null", "0", "127", "32767", "null"];
+        assert_eq!(
+            u16_expected,
+            get_cast_values::<UInt16Type>(&i32_array, &DataType::UInt16)
+        );
+
+        let u8_expected = vec!["null", "null", "null", "0", "127", "null", "null"];
+        assert_eq!(
+            u8_expected,
+            get_cast_values::<UInt8Type>(&i32_array, &DataType::UInt8)
+        );
+
+        // The date32 to date64 cast increases the numerical values in order to keep the same dates.
+        let i64_expected = vec![
+            "-185542587187200000",
+            "-2831155200000",
+            "-11059200000",
+            "0",
+            "10972800000",
+            "2831068800000",
+            "185542587100800000",
+        ];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Date64Type>(&i32_array, &DataType::Date64)
+        );
+    }
+
+    #[test]
+    fn test_cast_from_int16() {
+        let i16_values: Vec<i16> = vec![i16::MIN, i8::MIN as i16, 0, i8::MAX as i16, i16::MAX];
+        let i16_array: ArrayRef = Arc::new(Int16Array::from(i16_values));
+
+        let f64_expected = vec!["-32768.0", "-128.0", "0.0", "127.0", "32767.0"];
+        assert_eq!(
+            f64_expected,
+            get_cast_values::<Float64Type>(&i16_array, &DataType::Float64)
+        );
+
+        let f32_expected = vec!["-32768.0", "-128.0", "0.0", "127.0", "32767.0"];
+        assert_eq!(
+            f32_expected,
+            get_cast_values::<Float32Type>(&i16_array, &DataType::Float32)
+        );
+
+        let f16_expected = vec![
+            f16::from_f64(-32768.0),
+            f16::from_f64(-128.0),
+            f16::from_f64(0.0),
+            f16::from_f64(127.0),
+            f16::from_f64(32767.0),
+        ];
+        assert_eq!(
+            f16_expected,
+            get_cast_values::<Float16Type>(&i16_array, &DataType::Float16)
+                .iter()
+                .map(|i| i.parse::<f16>().unwrap())
+                .collect::<Vec<f16>>()
+        );
+
+        let i64_expected = vec!["-32768", "-128", "0", "127", "32767"];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Int64Type>(&i16_array, &DataType::Int64)
+        );
+
+        let i32_expected = vec!["-32768", "-128", "0", "127", "32767"];
+        assert_eq!(
+            i32_expected,
+            get_cast_values::<Int32Type>(&i16_array, &DataType::Int32)
+        );
+
+        let i16_expected = vec!["-32768", "-128", "0", "127", "32767"];
+        assert_eq!(
+            i16_expected,
+            get_cast_values::<Int16Type>(&i16_array, &DataType::Int16)
+        );
+
+        let i8_expected = vec!["null", "-128", "0", "127", "null"];
+        assert_eq!(
+            i8_expected,
+            get_cast_values::<Int8Type>(&i16_array, &DataType::Int8)
+        );
+
+        let u64_expected = vec!["null", "null", "0", "127", "32767"];
+        assert_eq!(
+            u64_expected,
+            get_cast_values::<UInt64Type>(&i16_array, &DataType::UInt64)
+        );
+
+        let u32_expected = vec!["null", "null", "0", "127", "32767"];
+        assert_eq!(
+            u32_expected,
+            get_cast_values::<UInt32Type>(&i16_array, &DataType::UInt32)
+        );
+
+        let u16_expected = vec!["null", "null", "0", "127", "32767"];
+        assert_eq!(
+            u16_expected,
+            get_cast_values::<UInt16Type>(&i16_array, &DataType::UInt16)
+        );
+
+        let u8_expected = vec!["null", "null", "0", "127", "null"];
+        assert_eq!(
+            u8_expected,
+            get_cast_values::<UInt8Type>(&i16_array, &DataType::UInt8)
+        );
+    }
+
+    #[test]
+    fn test_cast_from_date32() {
+        let i32_values: Vec<i32> = vec![
+            i32::MIN,
+            i16::MIN as i32,
+            i8::MIN as i32,
+            0,
+            i8::MAX as i32,
+            i16::MAX as i32,
+            i32::MAX,
+        ];
+        let date32_array: ArrayRef = Arc::new(Date32Array::from(i32_values));
+
+        let i64_expected = vec![
+            "-2147483648",
+            "-32768",
+            "-128",
+            "0",
+            "127",
+            "32767",
+            "2147483647",
+        ];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Int64Type>(&date32_array, &DataType::Int64)
+        );
+    }
+
+    #[test]
+    fn test_cast_from_int8() {
+        let i8_values: Vec<i8> = vec![i8::MIN, 0, i8::MAX];
+        let i8_array = Int8Array::from(i8_values);
+
+        let f64_expected = vec!["-128.0", "0.0", "127.0"];
+        assert_eq!(
+            f64_expected,
+            get_cast_values::<Float64Type>(&i8_array, &DataType::Float64)
+        );
+
+        let f32_expected = vec!["-128.0", "0.0", "127.0"];
+        assert_eq!(
+            f32_expected,
+            get_cast_values::<Float32Type>(&i8_array, &DataType::Float32)
+        );
+
+        let f16_expected = vec!["-128.0", "0.0", "127.0"];
+        assert_eq!(
+            f16_expected,
+            get_cast_values::<Float16Type>(&i8_array, &DataType::Float16)
+        );
+
+        let i64_expected = vec!["-128", "0", "127"];
+        assert_eq!(
+            i64_expected,
+            get_cast_values::<Int64Type>(&i8_array, &DataType::Int64)
+        );
+
+        let i32_expected = vec!["-128", "0", "127"];
+        assert_eq!(
+            i32_expected,
+            get_cast_values::<Int32Type>(&i8_array, &DataType::Int32)
+        );
+
+        let i16_expected = vec!["-128", "0", "127"];
+        assert_eq!(
+            i16_expected,
+            get_cast_values::<Int16Type>(&i8_array, &DataType::Int16)
+        );
+
+        let i8_expected = vec!["-128", "0", "127"];
+        assert_eq!(
+            i8_expected,
+            get_cast_values::<Int8Type>(&i8_array, &DataType::Int8)
+        );
+
+        let u64_expected = vec!["null", "0", "127"];
+        assert_eq!(
+            u64_expected,
+            get_cast_values::<UInt64Type>(&i8_array, &DataType::UInt64)
+        );
+
+        let u32_expected = vec!["null", "0", "127"];
+        assert_eq!(
+            u32_expected,
+            get_cast_values::<UInt32Type>(&i8_array, &DataType::UInt32)
+        );
+
+        let u16_expected = vec!["null", "0", "127"];
+        assert_eq!(
+            u16_expected,
+            get_cast_values::<UInt16Type>(&i8_array, &DataType::UInt16)
+        );
+
+        let u8_expected = vec!["null", "0", "127"];
+        assert_eq!(
+            u8_expected,
+            get_cast_values::<UInt8Type>(&i8_array, &DataType::UInt8)
+        );
+    }
+
+    /// Convert `array` into a vector of strings by casting to data type dt
+    fn get_cast_values<T>(array: &dyn Array, dt: &DataType) -> Vec<String>
+    where
+        T: ArrowPrimitiveType,
+    {
+        let c = cast(array, dt).unwrap();
+        let a = c.as_primitive::<T>();
+        let mut v: Vec<String> = vec![];
+        for i in 0..array.len() {
+            if a.is_null(i) {
+                v.push("null".to_string())
+            } else {
+                v.push(format!("{:?}", a.value(i)));
+            }
+        }
+        v
+    }
+
+    #[test]
+    fn test_cast_utf8_dict() {
+        // FROM a dictionary with of Utf8 values
+        use DataType::*;
+
+        let mut builder = StringDictionaryBuilder::<Int8Type>::new();
+        builder.append("one").unwrap();
+        builder.append_null();
+        builder.append("three").unwrap();
+        let array: ArrayRef = Arc::new(builder.finish());
+
+        let expected = vec!["one", "null", "three"];
+
+        // Test casting TO StringArray
+        let cast_type = Utf8;
+        let cast_array = cast(&array, &cast_type).expect("cast to UTF-8 failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+
+        // Test casting TO Dictionary (with different index sizes)
+
+        let cast_type = Dictionary(Box::new(Int16), Box::new(Utf8));
+        let cast_array = cast(&array, &cast_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+
+        let cast_type = Dictionary(Box::new(Int32), Box::new(Utf8));
+        let cast_array = cast(&array, &cast_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+
+        let cast_type = Dictionary(Box::new(Int64), Box::new(Utf8));
+        let cast_array = cast(&array, &cast_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+
+        let cast_type = Dictionary(Box::new(UInt8), Box::new(Utf8));
+        let cast_array = cast(&array, &cast_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+
+        let cast_type = Dictionary(Box::new(UInt16), Box::new(Utf8));
+        let cast_array = cast(&array, &cast_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+
+        let cast_type = Dictionary(Box::new(UInt32), Box::new(Utf8));
+        let cast_array = cast(&array, &cast_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+
+        let cast_type = Dictionary(Box::new(UInt64), Box::new(Utf8));
+        let cast_array = cast(&array, &cast_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+    }
+
+    #[test]
+    fn test_cast_dict_to_dict_bad_index_value_primitive() {
+        use DataType::*;
+        // test converting from an array that has indexes of a type
+        // that are out of bounds for a particular other kind of
+        // index.
+
+        let mut builder = PrimitiveDictionaryBuilder::<Int32Type, Int64Type>::new();
+
+        // add 200 distinct values (which can be stored by a
+        // dictionary indexed by int32, but not a dictionary indexed
+        // with int8)
+        for i in 0..200 {
+            builder.append(i).unwrap();
+        }
+        let array: ArrayRef = Arc::new(builder.finish());
+
+        let cast_type = Dictionary(Box::new(Int8), Box::new(Utf8));
+        let res = cast(&array, &cast_type);
+        assert!(res.is_err());
+        let actual_error = format!("{res:?}");
+        let expected_error = "Could not convert 72 dictionary indexes from Int32 to Int8";
+        assert!(
+            actual_error.contains(expected_error),
+            "did not find expected error '{actual_error}' in actual error '{expected_error}'"
+        );
+    }
+
+    #[test]
+    fn test_cast_dict_to_dict_bad_index_value_utf8() {
+        use DataType::*;
+        // Same test as test_cast_dict_to_dict_bad_index_value but use
+        // string values (and encode the expected behavior here);
+
+        let mut builder = StringDictionaryBuilder::<Int32Type>::new();
+
+        // add 200 distinct values (which can be stored by a
+        // dictionary indexed by int32, but not a dictionary indexed
+        // with int8)
+        for i in 0..200 {
+            let val = format!("val{i}");
+            builder.append(&val).unwrap();
+        }
+        let array = builder.finish();
+
+        let cast_type = Dictionary(Box::new(Int8), Box::new(Utf8));
+        let res = cast(&array, &cast_type);
+        assert!(res.is_err());
+        let actual_error = format!("{res:?}");
+        let expected_error = "Could not convert 72 dictionary indexes from Int32 to Int8";
+        assert!(
+            actual_error.contains(expected_error),
+            "did not find expected error '{actual_error}' in actual error '{expected_error}'"
+        );
+    }
+
+    #[test]
+    fn test_cast_primitive_dict() {
+        // FROM a dictionary with of INT32 values
+        use DataType::*;
+
+        let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::new();
+        builder.append(1).unwrap();
+        builder.append_null();
+        builder.append(3).unwrap();
+        let array: ArrayRef = Arc::new(builder.finish());
+
+        let expected = vec!["1", "null", "3"];
+
+        // Test casting TO PrimitiveArray, different dictionary type
+        let cast_array = cast(&array, &Utf8).expect("cast to UTF-8 failed");
+        assert_eq!(array_to_strings(&cast_array), expected);
+        assert_eq!(cast_array.data_type(), &Utf8);
+
+        let cast_array = cast(&array, &Int64).expect("cast to int64 failed");
+        assert_eq!(array_to_strings(&cast_array), expected);
+        assert_eq!(cast_array.data_type(), &Int64);
+    }
+
+    #[test]
+    fn test_cast_primitive_array_to_dict() {
+        use DataType::*;
+
+        let mut builder = PrimitiveBuilder::<Int32Type>::new();
+        builder.append_value(1);
+        builder.append_null();
+        builder.append_value(3);
+        let array: ArrayRef = Arc::new(builder.finish());
+
+        let expected = vec!["1", "null", "3"];
+
+        // Cast to a dictionary (same value type, Int32)
+        let cast_type = Dictionary(Box::new(UInt8), Box::new(Int32));
+        let cast_array = cast(&array, &cast_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+
+        // Cast to a dictionary (different value type, Int8)
+        let cast_type = Dictionary(Box::new(UInt8), Box::new(Int8));
+        let cast_array = cast(&array, &cast_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+    }
+
+    #[test]
+    fn test_cast_string_array_to_dict() {
+        use DataType::*;
+
+        let array = Arc::new(StringArray::from(vec![Some("one"), None, Some("three")])) as ArrayRef;
+
+        let expected = vec!["one", "null", "three"];
+
+        // Cast to a dictionary (same value type, Utf8)
+        let cast_type = Dictionary(Box::new(UInt8), Box::new(Utf8));
+        let cast_array = cast(&array, &cast_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &cast_type);
+        assert_eq!(array_to_strings(&cast_array), expected);
+    }
+
+    #[test]
+    fn test_cast_null_array_to_from_decimal_array() {
+        let data_type = DataType::Decimal128(12, 4);
+        let array = new_null_array(&DataType::Null, 4);
+        assert_eq!(array.data_type(), &DataType::Null);
+        let cast_array = cast(&array, &data_type).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &data_type);
+        for i in 0..4 {
+            assert!(cast_array.is_null(i));
+        }
+
+        let array = new_null_array(&data_type, 4);
+        assert_eq!(array.data_type(), &data_type);
+        let cast_array = cast(&array, &DataType::Null).expect("cast failed");
+        assert_eq!(cast_array.data_type(), &DataType::Null);
+        assert_eq!(cast_array.len(), 4);
+        assert_eq!(cast_array.logical_nulls().unwrap().null_count(), 4);
+    }
+
+    #[test]
+    fn test_cast_null_array_from_and_to_primitive_array() {
+        macro_rules! typed_test {
+            ($ARR_TYPE:ident, $DATATYPE:ident, $TYPE:tt) => {{
+                {
+                    let array = Arc::new(NullArray::new(6)) as ArrayRef;
+                    let expected = $ARR_TYPE::from(vec![None; 6]);
+                    let cast_type = DataType::$DATATYPE;
+                    let cast_array = cast(&array, &cast_type).expect("cast failed");
+                    let cast_array = cast_array.as_primitive::<$TYPE>();
+                    assert_eq!(cast_array.data_type(), &cast_type);
+                    assert_eq!(cast_array, &expected);
+                }
+            }};
+        }
+
+        typed_test!(Int16Array, Int16, Int16Type);
+        typed_test!(Int32Array, Int32, Int32Type);
+        typed_test!(Int64Array, Int64, Int64Type);
+
+        typed_test!(UInt16Array, UInt16, UInt16Type);
+        typed_test!(UInt32Array, UInt32, UInt32Type);
+        typed_test!(UInt64Array, UInt64, UInt64Type);
+
+        typed_test!(Float32Array, Float32, Float32Type);
+        typed_test!(Float64Array, Float64, Float64Type);
+
+        typed_test!(Date32Array, Date32, Date32Type);
+        typed_test!(Date64Array, Date64, Date64Type);
+    }
+
+    fn cast_from_null_to_other(data_type: &DataType) {
+        // Cast from null to data_type
+        {
+            let array = new_null_array(&DataType::Null, 4);
+            assert_eq!(array.data_type(), &DataType::Null);
+            let cast_array = cast(&array, data_type).expect("cast failed");
+            assert_eq!(cast_array.data_type(), data_type);
+            for i in 0..4 {
+                assert!(cast_array.is_null(i));
+            }
+        }
+    }
+
+    #[test]
+    fn test_cast_null_from_and_to_variable_sized() {
+        cast_from_null_to_other(&DataType::Utf8);
+        cast_from_null_to_other(&DataType::LargeUtf8);
+        cast_from_null_to_other(&DataType::Binary);
+        cast_from_null_to_other(&DataType::LargeBinary);
+    }
+
+    #[test]
+    fn test_cast_null_from_and_to_nested_type() {
+        // Cast null from and to map
+        let data_type = DataType::Map(
+            Arc::new(Field::new_struct(
+                "entry",
+                vec![
+                    Field::new("key", DataType::Utf8, false),
+                    Field::new("value", DataType::Int32, true),
+                ],
+                false,
+            )),
+            false,
+        );
+        cast_from_null_to_other(&data_type);
+
+        // Cast null from and to list
+        let data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, true)));
+        cast_from_null_to_other(&data_type);
+        let data_type = DataType::LargeList(Arc::new(Field::new("item", DataType::Int32, true)));
+        cast_from_null_to_other(&data_type);
+        let data_type =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, true)), 4);
+        cast_from_null_to_other(&data_type);
+
+        // Cast null from and to dictionary
+        let values = vec![None, None, None, None] as Vec<Option<&str>>;
+        let array: DictionaryArray<Int8Type> = values.into_iter().collect();
+        let array = Arc::new(array) as ArrayRef;
+        let data_type = array.data_type().to_owned();
+        cast_from_null_to_other(&data_type);
+
+        // Cast null from and to struct
+        let data_type = DataType::Struct(vec![Field::new("data", DataType::Int64, false)].into());
+        cast_from_null_to_other(&data_type);
+    }
+
+    /// Print the `DictionaryArray` `array` as a vector of strings
+    fn array_to_strings(array: &ArrayRef) -> Vec<String> {
+        let options = FormatOptions::new().with_null("null");
+        let formatter = ArrayFormatter::try_new(array.as_ref(), &options).unwrap();
+        (0..array.len())
+            .map(|i| formatter.value(i).to_string())
+            .collect()
+    }
+
+    #[test]
+    fn test_cast_utf8_to_date32() {
+        use chrono::NaiveDate;
+        let from_ymd = chrono::NaiveDate::from_ymd_opt;
+        let since = chrono::NaiveDate::signed_duration_since;
+
+        let a = StringArray::from(vec![
+            "2000-01-01",          // valid date with leading 0s
+            "2000-01-01T12:00:00", // valid datetime, will throw away the time part
+            "2000-2-2",            // valid date without leading 0s
+            "2000-00-00",          // invalid month and day
+            "2000",                // just a year is invalid
+        ]);
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Date32).unwrap();
+        let c = b.as_primitive::<Date32Type>();
+
+        // test valid inputs
+        let date_value = since(
+            NaiveDate::from_ymd_opt(2000, 1, 1).unwrap(),
+            from_ymd(1970, 1, 1).unwrap(),
+        )
+        .num_days() as i32;
+        assert!(c.is_valid(0)); // "2000-01-01"
+        assert_eq!(date_value, c.value(0));
+
+        assert!(c.is_valid(1)); // "2000-01-01T12:00:00"
+        assert_eq!(date_value, c.value(1));
+
+        let date_value = since(
+            NaiveDate::from_ymd_opt(2000, 2, 2).unwrap(),
+            from_ymd(1970, 1, 1).unwrap(),
+        )
+        .num_days() as i32;
+        assert!(c.is_valid(2)); // "2000-2-2"
+        assert_eq!(date_value, c.value(2));
+
+        // test invalid inputs
+        assert!(!c.is_valid(3)); // "2000-00-00"
+        assert!(!c.is_valid(4)); // "2000"
+    }
+
+    #[test]
+    fn test_cast_utf8_to_date64() {
+        let a = StringArray::from(vec![
+            "2000-01-01T12:00:00", // date + time valid
+            "2020-12-15T12:34:56", // date + time valid
+            "2020-2-2T12:34:56",   // valid date time without leading 0s
+            "2000-00-00T12:00:00", // invalid month and day
+            "2000-01-01 12:00:00", // missing the 'T'
+            "2000-01-01",          // just a date is invalid
+        ]);
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Date64).unwrap();
+        let c = b.as_primitive::<Date64Type>();
+
+        // test valid inputs
+        assert!(c.is_valid(0)); // "2000-01-01T12:00:00"
+        assert_eq!(946728000000, c.value(0));
+        assert!(c.is_valid(1)); // "2020-12-15T12:34:56"
+        assert_eq!(1608035696000, c.value(1));
+        assert!(!c.is_valid(2)); // "2020-2-2T12:34:56"
+
+        assert!(!c.is_valid(3)); // "2000-00-00T12:00:00"
+        assert!(c.is_valid(4)); // "2000-01-01 12:00:00"
+        assert_eq!(946728000000, c.value(4));
+        assert!(c.is_valid(5)); // "2000-01-01"
+        assert_eq!(946684800000, c.value(5));
+    }
+
+    #[test]
+    fn test_can_cast_fsl_to_fsl() {
+        let from_array = Arc::new(
+            FixedSizeListArray::from_iter_primitive::<Float32Type, _, _>(
+                [Some([Some(1.0), Some(2.0)]), None],
+                2,
+            ),
+        ) as ArrayRef;
+        let to_array = Arc::new(
+            FixedSizeListArray::from_iter_primitive::<Float16Type, _, _>(
+                [
+                    Some([Some(f16::from_f32(1.0)), Some(f16::from_f32(2.0))]),
+                    None,
+                ],
+                2,
+            ),
+        ) as ArrayRef;
+
+        assert!(can_cast_types(from_array.data_type(), to_array.data_type()));
+        let actual = cast(&from_array, to_array.data_type()).unwrap();
+        assert_eq!(actual.data_type(), to_array.data_type());
+
+        let invalid_target =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Binary, true)), 2);
+        assert!(!can_cast_types(from_array.data_type(), &invalid_target));
+
+        let invalid_size =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Float16, true)), 5);
+        assert!(!can_cast_types(from_array.data_type(), &invalid_size));
+    }
+
+    #[test]
+    fn test_can_cast_types_fixed_size_list_to_list() {
+        // DataType::List
+        let array1 = Arc::new(make_fixed_size_list_array()) as ArrayRef;
+        assert!(can_cast_types(
+            array1.data_type(),
+            &DataType::List(Arc::new(Field::new("", DataType::Int32, false)))
+        ));
+
+        // DataType::LargeList
+        let array2 = Arc::new(make_fixed_size_list_array_for_large_list()) as ArrayRef;
+        assert!(can_cast_types(
+            array2.data_type(),
+            &DataType::LargeList(Arc::new(Field::new("", DataType::Int64, false)))
+        ));
+    }
+
+    #[test]
+    fn test_cast_fixed_size_list_to_list() {
+        // Important cases:
+        // 1. With/without nulls
+        // 2. LargeList and List
+        // 3. With and without inner casts
+
+        let cases = [
+            // fixed_size_list<i32, 2> => list<i32>
+            (
+                Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+                    [[1, 1].map(Some), [2, 2].map(Some)].map(Some),
+                    2,
+                )) as ArrayRef,
+                Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>([
+                    Some([Some(1), Some(1)]),
+                    Some([Some(2), Some(2)]),
+                ])) as ArrayRef,
+            ),
+            // fixed_size_list<i32, 2> => list<i32> (nullable)
+            (
+                Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+                    [None, Some([Some(2), Some(2)])],
+                    2,
+                )) as ArrayRef,
+                Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>([
+                    None,
+                    Some([Some(2), Some(2)]),
+                ])) as ArrayRef,
+            ),
+            // fixed_size_list<i32, 2> => large_list<i64>
+            (
+                Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+                    [[1, 1].map(Some), [2, 2].map(Some)].map(Some),
+                    2,
+                )) as ArrayRef,
+                Arc::new(LargeListArray::from_iter_primitive::<Int64Type, _, _>([
+                    Some([Some(1), Some(1)]),
+                    Some([Some(2), Some(2)]),
+                ])) as ArrayRef,
+            ),
+            // fixed_size_list<i32, 2> => large_list<i64> (nullable)
+            (
+                Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+                    [None, Some([Some(2), Some(2)])],
+                    2,
+                )) as ArrayRef,
+                Arc::new(LargeListArray::from_iter_primitive::<Int64Type, _, _>([
+                    None,
+                    Some([Some(2), Some(2)]),
+                ])) as ArrayRef,
+            ),
+        ];
+
+        for (array, expected) in cases {
+            let array = Arc::new(array) as ArrayRef;
+
+            assert!(
+                can_cast_types(array.data_type(), expected.data_type()),
+                "can_cast_types claims we cannot cast {:?} to {:?}",
+                array.data_type(),
+                expected.data_type()
+            );
+
+            let list_array = cast(&array, expected.data_type())
+                .unwrap_or_else(|_| panic!("Failed to cast {:?} to {:?}", array, expected));
+            assert_eq!(
+                list_array.as_ref(),
+                &expected,
+                "Incorrect result from casting {:?} to {:?}",
+                array,
+                expected
+            );
+        }
+    }
+
+    #[test]
+    fn test_cast_utf8_to_list() {
+        // DataType::List
+        let array = Arc::new(StringArray::from(vec!["5"])) as ArrayRef;
+        let field = Arc::new(Field::new("", DataType::Int32, false));
+        let list_array = cast(&array, &DataType::List(field.clone())).unwrap();
+        let actual = list_array.as_list_opt::<i32>().unwrap();
+        let expect = ListArray::from_iter_primitive::<Int32Type, _, _>([Some([Some(5)])]);
+        assert_eq!(&expect.value(0), &actual.value(0));
+
+        // DataType::LargeList
+        let list_array = cast(&array, &DataType::LargeList(field.clone())).unwrap();
+        let actual = list_array.as_list_opt::<i64>().unwrap();
+        let expect = LargeListArray::from_iter_primitive::<Int32Type, _, _>([Some([Some(5)])]);
+        assert_eq!(&expect.value(0), &actual.value(0));
+
+        // DataType::FixedSizeList
+        let list_array = cast(&array, &DataType::FixedSizeList(field.clone(), 1)).unwrap();
+        let actual = list_array.as_fixed_size_list_opt().unwrap();
+        let expect =
+            FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>([Some([Some(5)])], 1);
+        assert_eq!(&expect.value(0), &actual.value(0));
+    }
+
+    #[test]
+    fn test_cast_list_containers() {
+        // large-list to list
+        let array = Arc::new(make_large_list_array()) as ArrayRef;
+        let list_array = cast(
+            &array,
+            &DataType::List(Arc::new(Field::new("", DataType::Int32, false))),
+        )
+        .unwrap();
+        let actual = list_array.as_any().downcast_ref::<ListArray>().unwrap();
+        let expected = array.as_any().downcast_ref::<LargeListArray>().unwrap();
+
+        assert_eq!(&expected.value(0), &actual.value(0));
+        assert_eq!(&expected.value(1), &actual.value(1));
+        assert_eq!(&expected.value(2), &actual.value(2));
+
+        // list to large-list
+        let array = Arc::new(make_list_array()) as ArrayRef;
+        let large_list_array = cast(
+            &array,
+            &DataType::LargeList(Arc::new(Field::new("", DataType::Int32, false))),
+        )
+        .unwrap();
+        let actual = large_list_array
+            .as_any()
+            .downcast_ref::<LargeListArray>()
+            .unwrap();
+        let expected = array.as_any().downcast_ref::<ListArray>().unwrap();
+
+        assert_eq!(&expected.value(0), &actual.value(0));
+        assert_eq!(&expected.value(1), &actual.value(1));
+        assert_eq!(&expected.value(2), &actual.value(2));
+    }
+
+    #[test]
+    fn test_cast_list_to_fsl() {
+        // There four noteworthy cases we should handle:
+        // 1. No nulls
+        // 2. Nulls that are always empty
+        // 3. Nulls that have varying lengths
+        // 4. Nulls that are correctly sized (same as target list size)
+
+        // Non-null case
+        let field = Arc::new(Field::new("item", DataType::Int32, true));
+        let values = vec![
+            Some(vec![Some(1), Some(2), Some(3)]),
+            Some(vec![Some(4), Some(5), Some(6)]),
+        ];
+        let array = Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(
+            values.clone(),
+        )) as ArrayRef;
+        let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+            values, 3,
+        )) as ArrayRef;
+        let actual = cast(array.as_ref(), &DataType::FixedSizeList(field.clone(), 3)).unwrap();
+        assert_eq!(expected.as_ref(), actual.as_ref());
+
+        // Null cases
+        // Array is [[1, 2, 3], null, [4, 5, 6], null]
+        let cases = [
+            (
+                // Zero-length nulls
+                vec![1, 2, 3, 4, 5, 6],
+                vec![3, 0, 3, 0],
+            ),
+            (
+                // Varying-length nulls
+                vec![1, 2, 3, 0, 0, 4, 5, 6, 0],
+                vec![3, 2, 3, 1],
+            ),
+            (
+                // Correctly-sized nulls
+                vec![1, 2, 3, 0, 0, 0, 4, 5, 6, 0, 0, 0],
+                vec![3, 3, 3, 3],
+            ),
+            (
+                // Mixed nulls
+                vec![1, 2, 3, 4, 5, 6, 0, 0, 0],
+                vec![3, 0, 3, 3],
+            ),
+        ];
+        let null_buffer = NullBuffer::from(vec![true, false, true, false]);
+
+        let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+            vec![
+                Some(vec![Some(1), Some(2), Some(3)]),
+                None,
+                Some(vec![Some(4), Some(5), Some(6)]),
+                None,
+            ],
+            3,
+        )) as ArrayRef;
+
+        for (values, lengths) in cases.iter() {
+            let array = Arc::new(ListArray::new(
+                field.clone(),
+                OffsetBuffer::from_lengths(lengths.clone()),
+                Arc::new(Int32Array::from(values.clone())),
+                Some(null_buffer.clone()),
+            )) as ArrayRef;
+            let actual = cast(array.as_ref(), &DataType::FixedSizeList(field.clone(), 3)).unwrap();
+            assert_eq!(expected.as_ref(), actual.as_ref());
+        }
+    }
+
+    #[test]
+    fn test_cast_list_to_fsl_safety() {
+        let values = vec![
+            Some(vec![Some(1), Some(2), Some(3)]),
+            Some(vec![Some(4), Some(5)]),
+            Some(vec![Some(6), Some(7), Some(8), Some(9)]),
+            Some(vec![Some(3), Some(4), Some(5)]),
+        ];
+        let array = Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(
+            values.clone(),
+        )) as ArrayRef;
+
+        let res = cast_with_options(
+            array.as_ref(),
+            &DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, true)), 3),
+            &CastOptions {
+                safe: false,
+                ..Default::default()
+            },
+        );
+        assert!(res.is_err());
+        assert!(format!("{:?}", res)
+            .contains("Cannot cast to FixedSizeList(3): value at index 1 has length 2"));
+
+        // When safe=true (default), the cast will fill nulls for lists that are
+        // too short and truncate lists that are too long.
+        let res = cast(
+            array.as_ref(),
+            &DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, true)), 3),
+        )
+        .unwrap();
+        let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+            vec![
+                Some(vec![Some(1), Some(2), Some(3)]),
+                None, // Too short -> replaced with null
+                None, // Too long -> replaced with null
+                Some(vec![Some(3), Some(4), Some(5)]),
+            ],
+            3,
+        )) as ArrayRef;
+        assert_eq!(expected.as_ref(), res.as_ref());
+    }
+
+    #[test]
+    fn test_cast_large_list_to_fsl() {
+        let values = vec![Some(vec![Some(1), Some(2)]), Some(vec![Some(3), Some(4)])];
+        let array = Arc::new(LargeListArray::from_iter_primitive::<Int32Type, _, _>(
+            values.clone(),
+        )) as ArrayRef;
+        let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+            values, 2,
+        )) as ArrayRef;
+        let actual = cast(
+            array.as_ref(),
+            &DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, true)), 2),
+        )
+        .unwrap();
+        assert_eq!(expected.as_ref(), actual.as_ref());
+    }
+
+    #[test]
+    fn test_cast_list_to_fsl_subcast() {
+        let array = Arc::new(LargeListArray::from_iter_primitive::<Int32Type, _, _>(
+            vec![
+                Some(vec![Some(1), Some(2)]),
+                Some(vec![Some(3), Some(i32::MAX)]),
+            ],
+        )) as ArrayRef;
+        let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<Int64Type, _, _>(
+            vec![
+                Some(vec![Some(1), Some(2)]),
+                Some(vec![Some(3), Some(i32::MAX as i64)]),
+            ],
+            2,
+        )) as ArrayRef;
+        let actual = cast(
+            array.as_ref(),
+            &DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int64, true)), 2),
+        )
+        .unwrap();
+        assert_eq!(expected.as_ref(), actual.as_ref());
+
+        let res = cast_with_options(
+            array.as_ref(),
+            &DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int16, true)), 2),
+            &CastOptions {
+                safe: false,
+                ..Default::default()
+            },
+        );
+        assert!(res.is_err());
+        assert!(format!("{:?}", res).contains("Can't cast value 2147483647 to type Int16"));
+    }
+
+    #[test]
+    fn test_cast_list_to_fsl_empty() {
+        let field = Arc::new(Field::new("item", DataType::Int32, true));
+        let array = new_empty_array(&DataType::List(field.clone()));
+
+        let target_type = DataType::FixedSizeList(field.clone(), 3);
+        let expected = new_empty_array(&target_type);
+
+        let actual = cast(array.as_ref(), &target_type).unwrap();
+        assert_eq!(expected.as_ref(), actual.as_ref());
+    }
+
+    fn make_list_array() -> ListArray {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(8)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+        let value_offsets = Buffer::from_slice_ref([0, 3, 6, 8]);
+
+        // Construct a list array from the above two
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, true)));
+        let list_data = ArrayData::builder(list_data_type)
+            .len(3)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data)
+            .build()
+            .unwrap();
+        ListArray::from(list_data)
+    }
+
+    fn make_large_list_array() -> LargeListArray {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(8)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+            .build()
+            .unwrap();
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+        let value_offsets = Buffer::from_slice_ref([0i64, 3, 6, 8]);
+
+        // Construct a list array from the above two
+        let list_data_type =
+            DataType::LargeList(Arc::new(Field::new("item", DataType::Int32, true)));
+        let list_data = ArrayData::builder(list_data_type)
+            .len(3)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data)
+            .build()
+            .unwrap();
+        LargeListArray::from(list_data)
+    }
+
+    fn make_fixed_size_list_array() -> FixedSizeListArray {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(8)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+            .build()
+            .unwrap();
+
+        let list_data_type =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, true)), 4);
+        let list_data = ArrayData::builder(list_data_type)
+            .len(2)
+            .add_child_data(value_data)
+            .build()
+            .unwrap();
+        FixedSizeListArray::from(list_data)
+    }
+
+    fn make_fixed_size_list_array_for_large_list() -> FixedSizeListArray {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int64)
+            .len(8)
+            .add_buffer(Buffer::from_slice_ref([0i64, 1, 2, 3, 4, 5, 6, 7]))
+            .build()
+            .unwrap();
+
+        let list_data_type =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int64, true)), 4);
+        let list_data = ArrayData::builder(list_data_type)
+            .len(2)
+            .add_child_data(value_data)
+            .build()
+            .unwrap();
+        FixedSizeListArray::from(list_data)
+    }
+
+    #[test]
+    fn test_utf8_cast_offsets() {
+        // test if offset of the array is taken into account during cast
+        let str_array = StringArray::from(vec!["a", "b", "c"]);
+        let str_array = str_array.slice(1, 2);
+
+        let out = cast(&str_array, &DataType::LargeUtf8).unwrap();
+
+        let large_str_array = out.as_any().downcast_ref::<LargeStringArray>().unwrap();
+        let strs = large_str_array.into_iter().flatten().collect::<Vec<_>>();
+        assert_eq!(strs, &["b", "c"])
+    }
+
+    #[test]
+    fn test_list_cast_offsets() {
+        // test if offset of the array is taken into account during cast
+        let array1 = make_list_array().slice(1, 2);
+        let array2 = Arc::new(make_list_array()) as ArrayRef;
+
+        let dt = DataType::LargeList(Arc::new(Field::new("item", DataType::Int32, true)));
+        let out1 = cast(&array1, &dt).unwrap();
+        let out2 = cast(&array2, &dt).unwrap();
+
+        assert_eq!(&out1, &out2.slice(1, 2))
+    }
+
+    #[test]
+    fn test_list_to_string() {
+        let str_array = StringArray::from(vec!["a", "b", "c", "d", "e", "f", "g", "h"]);
+        let value_offsets = Buffer::from_slice_ref([0, 3, 6, 8]);
+        let value_data = str_array.into_data();
+
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Utf8, true)));
+        let list_data = ArrayData::builder(list_data_type)
+            .len(3)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data)
+            .build()
+            .unwrap();
+        let array = Arc::new(ListArray::from(list_data)) as ArrayRef;
+
+        let out = cast(&array, &DataType::Utf8).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap()
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+        assert_eq!(&out, &vec!["[a, b, c]", "[d, e, f]", "[g, h]"]);
+
+        let out = cast(&array, &DataType::LargeUtf8).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<LargeStringArray>()
+            .unwrap()
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+        assert_eq!(&out, &vec!["[a, b, c]", "[d, e, f]", "[g, h]"]);
+
+        let array = Arc::new(make_list_array()) as ArrayRef;
+        let out = cast(&array, &DataType::Utf8).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap()
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+        assert_eq!(&out, &vec!["[0, 1, 2]", "[3, 4, 5]", "[6, 7]"]);
+
+        let array = Arc::new(make_large_list_array()) as ArrayRef;
+        let out = cast(&array, &DataType::LargeUtf8).unwrap();
+        let out = out
+            .as_any()
+            .downcast_ref::<LargeStringArray>()
+            .unwrap()
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+        assert_eq!(&out, &vec!["[0, 1, 2]", "[3, 4, 5]", "[6, 7]"]);
+    }
+
+    #[test]
+    fn test_cast_f64_to_decimal128() {
+        // to reproduce https://github.com/apache/arrow-rs/issues/2997
+
+        let decimal_type = DataType::Decimal128(18, 2);
+        let array = Float64Array::from(vec![
+            Some(0.0699999999),
+            Some(0.0659999999),
+            Some(0.0650000000),
+            Some(0.0649999999),
+        ]);
+        let array = Arc::new(array) as ArrayRef;
+        generate_cast_test_case!(
+            &array,
+            Decimal128Array,
+            &decimal_type,
+            vec![
+                Some(7_i128), // round up
+                Some(7_i128), // round up
+                Some(7_i128), // round up
+                Some(6_i128), // round down
+            ]
+        );
+
+        let decimal_type = DataType::Decimal128(18, 3);
+        let array = Float64Array::from(vec![
+            Some(0.0699999999),
+            Some(0.0659999999),
+            Some(0.0650000000),
+            Some(0.0649999999),
+        ]);
+        let array = Arc::new(array) as ArrayRef;
+        generate_cast_test_case!(
+            &array,
+            Decimal128Array,
+            &decimal_type,
+            vec![
+                Some(70_i128), // round up
+                Some(66_i128), // round up
+                Some(65_i128), // round down
+                Some(65_i128), // round up
+            ]
+        );
+    }
+
+    #[test]
+    fn test_cast_numeric_to_decimal128_overflow() {
+        let array = Int64Array::from(vec![i64::MAX]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal128(38, 30),
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal128(38, 30),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_err());
+    }
+
+    #[test]
+    fn test_cast_numeric_to_decimal256_overflow() {
+        let array = Int64Array::from(vec![i64::MAX]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal256(76, 76),
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal256(76, 76),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_err());
+    }
+
+    #[test]
+    fn test_cast_floating_point_to_decimal128_precision_overflow() {
+        let array = Float64Array::from(vec![1.1]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal128(2, 2),
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal128(2, 2),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        let err = casted_array.unwrap_err().to_string();
+        let expected_error = "Invalid argument error: 110 is too large to store in a Decimal128 of precision 2. Max is 99";
+        assert!(
+            err.contains(expected_error),
+            "did not find expected error '{expected_error}' in actual error '{err}'"
+        );
+    }
+
+    #[test]
+    fn test_cast_floating_point_to_decimal256_precision_overflow() {
+        let array = Float64Array::from(vec![1.1]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal256(2, 2),
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal256(2, 2),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        let err = casted_array.unwrap_err().to_string();
+        let expected_error = "Invalid argument error: 110 is too large to store in a Decimal256 of precision 2. Max is 99";
+        assert!(
+            err.contains(expected_error),
+            "did not find expected error '{expected_error}' in actual error '{err}'"
+        );
+    }
+
+    #[test]
+    fn test_cast_floating_point_to_decimal128_overflow() {
+        let array = Float64Array::from(vec![f64::MAX]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal128(38, 30),
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal128(38, 30),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        let err = casted_array.unwrap_err().to_string();
+        let expected_error = "Cast error: Cannot cast to Decimal128(38, 30)";
+        assert!(
+            err.contains(expected_error),
+            "did not find expected error '{expected_error}' in actual error '{err}'"
+        );
+    }
+
+    #[test]
+    fn test_cast_floating_point_to_decimal256_overflow() {
+        let array = Float64Array::from(vec![f64::MAX]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal256(76, 50),
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal256(76, 50),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        let err = casted_array.unwrap_err().to_string();
+        let expected_error = "Cast error: Cannot cast to Decimal256(76, 50)";
+        assert!(
+            err.contains(expected_error),
+            "did not find expected error '{expected_error}' in actual error '{err}'"
+        );
+    }
+
+    #[test]
+    fn test_cast_decimal128_to_decimal128_negative_scale() {
+        let input_type = DataType::Decimal128(20, 0);
+        let output_type = DataType::Decimal128(20, -1);
+        assert!(can_cast_types(&input_type, &output_type));
+        let array = vec![Some(1123450), Some(2123455), Some(3123456), None];
+        let input_decimal_array = create_decimal_array(array, 20, 0).unwrap();
+        let array = Arc::new(input_decimal_array) as ArrayRef;
+        generate_cast_test_case!(
+            &array,
+            Decimal128Array,
+            &output_type,
+            vec![
+                Some(112345_i128),
+                Some(212346_i128),
+                Some(312346_i128),
+                None
+            ]
+        );
+
+        let casted_array = cast(&array, &output_type).unwrap();
+        let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
+
+        assert_eq!("1123450", decimal_arr.value_as_string(0));
+        assert_eq!("2123460", decimal_arr.value_as_string(1));
+        assert_eq!("3123460", decimal_arr.value_as_string(2));
+    }
+
+    #[test]
+    fn test_cast_numeric_to_decimal128_negative() {
+        let decimal_type = DataType::Decimal128(38, -1);
+        let array = Arc::new(Int32Array::from(vec![
+            Some(1123456),
+            Some(2123456),
+            Some(3123456),
+        ])) as ArrayRef;
+
+        let casted_array = cast(&array, &decimal_type).unwrap();
+        let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
+
+        assert_eq!("1123450", decimal_arr.value_as_string(0));
+        assert_eq!("2123450", decimal_arr.value_as_string(1));
+        assert_eq!("3123450", decimal_arr.value_as_string(2));
+
+        let array = Arc::new(Float32Array::from(vec![
+            Some(1123.456),
+            Some(2123.456),
+            Some(3123.456),
+        ])) as ArrayRef;
+
+        let casted_array = cast(&array, &decimal_type).unwrap();
+        let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
+
+        assert_eq!("1120", decimal_arr.value_as_string(0));
+        assert_eq!("2120", decimal_arr.value_as_string(1));
+        assert_eq!("3120", decimal_arr.value_as_string(2));
+    }
+
+    #[test]
+    fn test_cast_decimal128_to_decimal128_negative() {
+        let input_type = DataType::Decimal128(10, -1);
+        let output_type = DataType::Decimal128(10, -2);
+        assert!(can_cast_types(&input_type, &output_type));
+        let array = vec![Some(123)];
+        let input_decimal_array = create_decimal_array(array, 10, -1).unwrap();
+        let array = Arc::new(input_decimal_array) as ArrayRef;
+        generate_cast_test_case!(&array, Decimal128Array, &output_type, vec![Some(12_i128),]);
+
+        let casted_array = cast(&array, &output_type).unwrap();
+        let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
+
+        assert_eq!("1200", decimal_arr.value_as_string(0));
+
+        let array = vec![Some(125)];
+        let input_decimal_array = create_decimal_array(array, 10, -1).unwrap();
+        let array = Arc::new(input_decimal_array) as ArrayRef;
+        generate_cast_test_case!(&array, Decimal128Array, &output_type, vec![Some(13_i128),]);
+
+        let casted_array = cast(&array, &output_type).unwrap();
+        let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
+
+        assert_eq!("1300", decimal_arr.value_as_string(0));
+    }
+
+    #[test]
+    fn test_cast_decimal128_to_decimal256_negative() {
+        let input_type = DataType::Decimal128(10, 3);
+        let output_type = DataType::Decimal256(10, 5);
+        assert!(can_cast_types(&input_type, &output_type));
+        let array = vec![Some(i128::MAX), Some(i128::MIN)];
+        let input_decimal_array = create_decimal_array(array, 10, 3).unwrap();
+        let array = Arc::new(input_decimal_array) as ArrayRef;
+
+        let hundred = i256::from_i128(100);
+        generate_cast_test_case!(
+            &array,
+            Decimal256Array,
+            &output_type,
+            vec![
+                Some(i256::from_i128(i128::MAX).mul_wrapping(hundred)),
+                Some(i256::from_i128(i128::MIN).mul_wrapping(hundred))
+            ]
+        );
+    }
+
+    #[test]
+    fn test_parse_string_to_decimal() {
+        assert_eq!(
+            Decimal128Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal128Type>("123.45", 2).unwrap(),
+                38,
+                2,
+            ),
+            "123.45"
+        );
+        assert_eq!(
+            Decimal128Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal128Type>("12345", 2).unwrap(),
+                38,
+                2,
+            ),
+            "12345.00"
+        );
+        assert_eq!(
+            Decimal128Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal128Type>("0.12345", 2).unwrap(),
+                38,
+                2,
+            ),
+            "0.12"
+        );
+        assert_eq!(
+            Decimal128Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal128Type>(".12345", 2).unwrap(),
+                38,
+                2,
+            ),
+            "0.12"
+        );
+        assert_eq!(
+            Decimal128Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal128Type>(".1265", 2).unwrap(),
+                38,
+                2,
+            ),
+            "0.13"
+        );
+        assert_eq!(
+            Decimal128Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal128Type>(".1265", 2).unwrap(),
+                38,
+                2,
+            ),
+            "0.13"
+        );
+
+        assert_eq!(
+            Decimal256Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal256Type>("123.45", 3).unwrap(),
+                38,
+                3,
+            ),
+            "123.450"
+        );
+        assert_eq!(
+            Decimal256Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal256Type>("12345", 3).unwrap(),
+                38,
+                3,
+            ),
+            "12345.000"
+        );
+        assert_eq!(
+            Decimal256Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal256Type>("0.12345", 3).unwrap(),
+                38,
+                3,
+            ),
+            "0.123"
+        );
+        assert_eq!(
+            Decimal256Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal256Type>(".12345", 3).unwrap(),
+                38,
+                3,
+            ),
+            "0.123"
+        );
+        assert_eq!(
+            Decimal256Type::format_decimal(
+                parse_string_to_decimal_native::<Decimal256Type>(".1265", 3).unwrap(),
+                38,
+                3,
+            ),
+            "0.127"
+        );
+    }
+
+    fn test_cast_string_to_decimal(array: ArrayRef) {
+        // Decimal128
+        let output_type = DataType::Decimal128(38, 2);
+        assert!(can_cast_types(array.data_type(), &output_type));
+
+        let casted_array = cast(&array, &output_type).unwrap();
+        let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
+
+        assert_eq!("123.45", decimal_arr.value_as_string(0));
+        assert_eq!("1.23", decimal_arr.value_as_string(1));
+        assert_eq!("0.12", decimal_arr.value_as_string(2));
+        assert_eq!("0.13", decimal_arr.value_as_string(3));
+        assert_eq!("1.26", decimal_arr.value_as_string(4));
+        assert_eq!("12345.00", decimal_arr.value_as_string(5));
+        assert_eq!("12345.00", decimal_arr.value_as_string(6));
+        assert_eq!("0.12", decimal_arr.value_as_string(7));
+        assert_eq!("12.23", decimal_arr.value_as_string(8));
+        assert!(decimal_arr.is_null(9));
+        assert_eq!("0.00", decimal_arr.value_as_string(10));
+        assert_eq!("0.00", decimal_arr.value_as_string(11));
+        assert!(decimal_arr.is_null(12));
+        assert_eq!("-1.23", decimal_arr.value_as_string(13));
+        assert_eq!("-1.24", decimal_arr.value_as_string(14));
+        assert_eq!("0.00", decimal_arr.value_as_string(15));
+        assert_eq!("-123.00", decimal_arr.value_as_string(16));
+        assert_eq!("-123.23", decimal_arr.value_as_string(17));
+        assert_eq!("-0.12", decimal_arr.value_as_string(18));
+        assert_eq!("1.23", decimal_arr.value_as_string(19));
+        assert_eq!("1.24", decimal_arr.value_as_string(20));
+        assert_eq!("0.00", decimal_arr.value_as_string(21));
+        assert_eq!("123.00", decimal_arr.value_as_string(22));
+        assert_eq!("123.23", decimal_arr.value_as_string(23));
+        assert_eq!("0.12", decimal_arr.value_as_string(24));
+        assert!(decimal_arr.is_null(25));
+        assert!(decimal_arr.is_null(26));
+        assert!(decimal_arr.is_null(27));
+
+        // Decimal256
+        let output_type = DataType::Decimal256(76, 3);
+        assert!(can_cast_types(array.data_type(), &output_type));
+
+        let casted_array = cast(&array, &output_type).unwrap();
+        let decimal_arr = casted_array.as_primitive::<Decimal256Type>();
+
+        assert_eq!("123.450", decimal_arr.value_as_string(0));
+        assert_eq!("1.235", decimal_arr.value_as_string(1));
+        assert_eq!("0.123", decimal_arr.value_as_string(2));
+        assert_eq!("0.127", decimal_arr.value_as_string(3));
+        assert_eq!("1.263", decimal_arr.value_as_string(4));
+        assert_eq!("12345.000", decimal_arr.value_as_string(5));
+        assert_eq!("12345.000", decimal_arr.value_as_string(6));
+        assert_eq!("0.123", decimal_arr.value_as_string(7));
+        assert_eq!("12.234", decimal_arr.value_as_string(8));
+        assert!(decimal_arr.is_null(9));
+        assert_eq!("0.000", decimal_arr.value_as_string(10));
+        assert_eq!("0.000", decimal_arr.value_as_string(11));
+        assert!(decimal_arr.is_null(12));
+        assert_eq!("-1.235", decimal_arr.value_as_string(13));
+        assert_eq!("-1.236", decimal_arr.value_as_string(14));
+        assert_eq!("0.000", decimal_arr.value_as_string(15));
+        assert_eq!("-123.000", decimal_arr.value_as_string(16));
+        assert_eq!("-123.234", decimal_arr.value_as_string(17));
+        assert_eq!("-0.123", decimal_arr.value_as_string(18));
+        assert_eq!("1.235", decimal_arr.value_as_string(19));
+        assert_eq!("1.236", decimal_arr.value_as_string(20));
+        assert_eq!("0.000", decimal_arr.value_as_string(21));
+        assert_eq!("123.000", decimal_arr.value_as_string(22));
+        assert_eq!("123.234", decimal_arr.value_as_string(23));
+        assert_eq!("0.123", decimal_arr.value_as_string(24));
+        assert!(decimal_arr.is_null(25));
+        assert!(decimal_arr.is_null(26));
+        assert!(decimal_arr.is_null(27));
+    }
+
+    #[test]
+    fn test_cast_utf8_to_decimal() {
+        let str_array = StringArray::from(vec![
+            Some("123.45"),
+            Some("1.2345"),
+            Some("0.12345"),
+            Some("0.1267"),
+            Some("1.263"),
+            Some("12345.0"),
+            Some("12345"),
+            Some("000.123"),
+            Some("12.234000"),
+            None,
+            Some(""),
+            Some(" "),
+            None,
+            Some("-1.23499999"),
+            Some("-1.23599999"),
+            Some("-0.00001"),
+            Some("-123"),
+            Some("-123.234000"),
+            Some("-000.123"),
+            Some("+1.23499999"),
+            Some("+1.23599999"),
+            Some("+0.00001"),
+            Some("+123"),
+            Some("+123.234000"),
+            Some("+000.123"),
+            Some("1.-23499999"),
+            Some("-1.-23499999"),
+            Some("--1.23499999"),
+        ]);
+        let array = Arc::new(str_array) as ArrayRef;
+
+        test_cast_string_to_decimal(array);
+    }
+
+    #[test]
+    fn test_cast_large_utf8_to_decimal() {
+        let str_array = LargeStringArray::from(vec![
+            Some("123.45"),
+            Some("1.2345"),
+            Some("0.12345"),
+            Some("0.1267"),
+            Some("1.263"),
+            Some("12345.0"),
+            Some("12345"),
+            Some("000.123"),
+            Some("12.234000"),
+            None,
+            Some(""),
+            Some(" "),
+            None,
+            Some("-1.23499999"),
+            Some("-1.23599999"),
+            Some("-0.00001"),
+            Some("-123"),
+            Some("-123.234000"),
+            Some("-000.123"),
+            Some("+1.23499999"),
+            Some("+1.23599999"),
+            Some("+0.00001"),
+            Some("+123"),
+            Some("+123.234000"),
+            Some("+000.123"),
+            Some("1.-23499999"),
+            Some("-1.-23499999"),
+            Some("--1.23499999"),
+        ]);
+        let array = Arc::new(str_array) as ArrayRef;
+
+        test_cast_string_to_decimal(array);
+    }
+
+    #[test]
+    fn test_cast_invalid_utf8_to_decimal() {
+        let str_array = StringArray::from(vec!["4.4.5", ". 0.123"]);
+        let array = Arc::new(str_array) as ArrayRef;
+
+        // Safe cast
+        let output_type = DataType::Decimal128(38, 2);
+        let casted_array = cast(&array, &output_type).unwrap();
+        assert!(casted_array.is_null(0));
+        assert!(casted_array.is_null(1));
+
+        let output_type = DataType::Decimal256(76, 2);
+        let casted_array = cast(&array, &output_type).unwrap();
+        assert!(casted_array.is_null(0));
+        assert!(casted_array.is_null(1));
+
+        // Non-safe cast
+        let output_type = DataType::Decimal128(38, 2);
+        let str_array = StringArray::from(vec!["4.4.5"]);
+        let array = Arc::new(str_array) as ArrayRef;
+        let option = CastOptions {
+            safe: false,
+            format_options: FormatOptions::default(),
+        };
+        let casted_err = cast_with_options(&array, &output_type, &option).unwrap_err();
+        assert!(casted_err
+            .to_string()
+            .contains("Cannot cast string '4.4.5' to value of Decimal128(38, 10) type"));
+
+        let str_array = StringArray::from(vec![". 0.123"]);
+        let array = Arc::new(str_array) as ArrayRef;
+        let casted_err = cast_with_options(&array, &output_type, &option).unwrap_err();
+        assert!(casted_err
+            .to_string()
+            .contains("Cannot cast string '. 0.123' to value of Decimal128(38, 10) type"));
+    }
+
+    fn test_cast_string_to_decimal128_overflow(overflow_array: ArrayRef) {
+        let output_type = DataType::Decimal128(38, 2);
+        let casted_array = cast(&overflow_array, &output_type).unwrap();
+        let decimal_arr = casted_array.as_primitive::<Decimal128Type>();
+
+        assert!(decimal_arr.is_null(0));
+        assert!(decimal_arr.is_null(1));
+        assert!(decimal_arr.is_null(2));
+        assert_eq!(
+            "999999999999999999999999999999999999.99",
+            decimal_arr.value_as_string(3)
+        );
+        assert_eq!(
+            "100000000000000000000000000000000000.00",
+            decimal_arr.value_as_string(4)
+        );
+    }
+
+    #[test]
+    fn test_cast_string_to_decimal128_precision_overflow() {
+        let array = StringArray::from(vec!["1000".to_string()]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal128(10, 8),
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        let err = cast_with_options(
+            &array,
+            &DataType::Decimal128(10, 8),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!("Invalid argument error: 100000000000 is too large to store in a Decimal128 of precision 10. Max is 9999999999", err.unwrap_err().to_string());
+    }
+
+    #[test]
+    fn test_cast_utf8_to_decimal128_overflow() {
+        let overflow_str_array = StringArray::from(vec![
+            i128::MAX.to_string(),
+            i128::MIN.to_string(),
+            "99999999999999999999999999999999999999".to_string(),
+            "999999999999999999999999999999999999.99".to_string(),
+            "99999999999999999999999999999999999.999".to_string(),
+        ]);
+        let overflow_array = Arc::new(overflow_str_array) as ArrayRef;
+
+        test_cast_string_to_decimal128_overflow(overflow_array);
+    }
+
+    #[test]
+    fn test_cast_large_utf8_to_decimal128_overflow() {
+        let overflow_str_array = LargeStringArray::from(vec![
+            i128::MAX.to_string(),
+            i128::MIN.to_string(),
+            "99999999999999999999999999999999999999".to_string(),
+            "999999999999999999999999999999999999.99".to_string(),
+            "99999999999999999999999999999999999.999".to_string(),
+        ]);
+        let overflow_array = Arc::new(overflow_str_array) as ArrayRef;
+
+        test_cast_string_to_decimal128_overflow(overflow_array);
+    }
+
+    fn test_cast_string_to_decimal256_overflow(overflow_array: ArrayRef) {
+        let output_type = DataType::Decimal256(76, 2);
+        let casted_array = cast(&overflow_array, &output_type).unwrap();
+        let decimal_arr = casted_array.as_primitive::<Decimal256Type>();
+
+        assert_eq!(
+            "170141183460469231731687303715884105727.00",
+            decimal_arr.value_as_string(0)
+        );
+        assert_eq!(
+            "-170141183460469231731687303715884105728.00",
+            decimal_arr.value_as_string(1)
+        );
+        assert_eq!(
+            "99999999999999999999999999999999999999.00",
+            decimal_arr.value_as_string(2)
+        );
+        assert_eq!(
+            "999999999999999999999999999999999999.99",
+            decimal_arr.value_as_string(3)
+        );
+        assert_eq!(
+            "100000000000000000000000000000000000.00",
+            decimal_arr.value_as_string(4)
+        );
+        assert!(decimal_arr.is_null(5));
+        assert!(decimal_arr.is_null(6));
+    }
+
+    #[test]
+    fn test_cast_string_to_decimal256_precision_overflow() {
+        let array = StringArray::from(vec!["1000".to_string()]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal256(10, 8),
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        let err = cast_with_options(
+            &array,
+            &DataType::Decimal256(10, 8),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!("Invalid argument error: 100000000000 is too large to store in a Decimal256 of precision 10. Max is 9999999999", err.unwrap_err().to_string());
+    }
+
+    #[test]
+    fn test_cast_utf8_to_decimal256_overflow() {
+        let overflow_str_array = StringArray::from(vec![
+            i128::MAX.to_string(),
+            i128::MIN.to_string(),
+            "99999999999999999999999999999999999999".to_string(),
+            "999999999999999999999999999999999999.99".to_string(),
+            "99999999999999999999999999999999999.999".to_string(),
+            i256::MAX.to_string(),
+            i256::MIN.to_string(),
+        ]);
+        let overflow_array = Arc::new(overflow_str_array) as ArrayRef;
+
+        test_cast_string_to_decimal256_overflow(overflow_array);
+    }
+
+    #[test]
+    fn test_cast_large_utf8_to_decimal256_overflow() {
+        let overflow_str_array = LargeStringArray::from(vec![
+            i128::MAX.to_string(),
+            i128::MIN.to_string(),
+            "99999999999999999999999999999999999999".to_string(),
+            "999999999999999999999999999999999999.99".to_string(),
+            "99999999999999999999999999999999999.999".to_string(),
+            i256::MAX.to_string(),
+            i256::MIN.to_string(),
+        ]);
+        let overflow_array = Arc::new(overflow_str_array) as ArrayRef;
+
+        test_cast_string_to_decimal256_overflow(overflow_array);
+    }
+
+    #[test]
+    fn test_cast_date32_to_timestamp() {
+        let a = Date32Array::from(vec![Some(18628), Some(18993), None]); // 2021-1-1, 2022-1-1
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Timestamp(TimeUnit::Second, None)).unwrap();
+        let c = b.as_primitive::<TimestampSecondType>();
+        assert_eq!(1609459200, c.value(0));
+        assert_eq!(1640995200, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_date32_to_timestamp_ms() {
+        let a = Date32Array::from(vec![Some(18628), Some(18993), None]); // 2021-1-1, 2022-1-1
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Timestamp(TimeUnit::Millisecond, None)).unwrap();
+        let c = b
+            .as_any()
+            .downcast_ref::<TimestampMillisecondArray>()
+            .unwrap();
+        assert_eq!(1609459200000, c.value(0));
+        assert_eq!(1640995200000, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_date32_to_timestamp_us() {
+        let a = Date32Array::from(vec![Some(18628), Some(18993), None]); // 2021-1-1, 2022-1-1
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
+        let c = b
+            .as_any()
+            .downcast_ref::<TimestampMicrosecondArray>()
+            .unwrap();
+        assert_eq!(1609459200000000, c.value(0));
+        assert_eq!(1640995200000000, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_cast_date32_to_timestamp_ns() {
+        let a = Date32Array::from(vec![Some(18628), Some(18993), None]); // 2021-1-1, 2022-1-1
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Timestamp(TimeUnit::Nanosecond, None)).unwrap();
+        let c = b
+            .as_any()
+            .downcast_ref::<TimestampNanosecondArray>()
+            .unwrap();
+        assert_eq!(1609459200000000000, c.value(0));
+        assert_eq!(1640995200000000000, c.value(1));
+        assert!(c.is_null(2));
+    }
+
+    #[test]
+    fn test_timezone_cast() {
+        let a = StringArray::from(vec![
+            "2000-01-01T12:00:00", // date + time valid
+            "2020-12-15T12:34:56", // date + time valid
+        ]);
+        let array = Arc::new(a) as ArrayRef;
+        let b = cast(&array, &DataType::Timestamp(TimeUnit::Nanosecond, None)).unwrap();
+        let v = b.as_primitive::<TimestampNanosecondType>();
+
+        assert_eq!(v.value(0), 946728000000000000);
+        assert_eq!(v.value(1), 1608035696000000000);
+
+        let b = cast(
+            &b,
+            &DataType::Timestamp(TimeUnit::Nanosecond, Some("+00:00".into())),
+        )
+        .unwrap();
+        let v = b.as_primitive::<TimestampNanosecondType>();
+
+        assert_eq!(v.value(0), 946728000000000000);
+        assert_eq!(v.value(1), 1608035696000000000);
+
+        let b = cast(
+            &b,
+            &DataType::Timestamp(TimeUnit::Millisecond, Some("+02:00".into())),
+        )
+        .unwrap();
+        let v = b.as_primitive::<TimestampMillisecondType>();
+
+        assert_eq!(v.value(0), 946728000000);
+        assert_eq!(v.value(1), 1608035696000);
+    }
+
+    #[test]
+    fn test_cast_utf8_to_timestamp() {
+        fn test_tz(tz: Arc<str>) {
+            let valid = StringArray::from(vec![
+                "2023-01-01 04:05:06.789000-08:00",
+                "2023-01-01 04:05:06.789000-07:00",
+                "2023-01-01 04:05:06.789 -0800",
+                "2023-01-01 04:05:06.789 -08:00",
+                "2023-01-01 040506 +0730",
+                "2023-01-01 040506 +07:30",
+                "2023-01-01 04:05:06.789",
+                "2023-01-01 04:05:06",
+                "2023-01-01",
+            ]);
+
+            let array = Arc::new(valid) as ArrayRef;
+            let b = cast_with_options(
+                &array,
+                &DataType::Timestamp(TimeUnit::Nanosecond, Some(tz.clone())),
+                &CastOptions {
+                    safe: false,
+                    format_options: FormatOptions::default(),
+                },
+            )
+            .unwrap();
+
+            let tz = tz.as_ref().parse().unwrap();
+
+            let as_tz =
+                |v: i64| as_datetime_with_timezone::<TimestampNanosecondType>(v, tz).unwrap();
+
+            let as_utc = |v: &i64| as_tz(*v).naive_utc().to_string();
+            let as_local = |v: &i64| as_tz(*v).naive_local().to_string();
+
+            let values = b.as_primitive::<TimestampNanosecondType>().values();
+            let utc_results: Vec<_> = values.iter().map(as_utc).collect();
+            let local_results: Vec<_> = values.iter().map(as_local).collect();
+
+            // Absolute timestamps should be parsed preserving the same UTC instant
+            assert_eq!(
+                &utc_results[..6],
+                &[
+                    "2023-01-01 12:05:06.789".to_string(),
+                    "2023-01-01 11:05:06.789".to_string(),
+                    "2023-01-01 12:05:06.789".to_string(),
+                    "2023-01-01 12:05:06.789".to_string(),
+                    "2022-12-31 20:35:06".to_string(),
+                    "2022-12-31 20:35:06".to_string(),
+                ]
+            );
+            // Non-absolute timestamps should be parsed preserving the same local instant
+            assert_eq!(
+                &local_results[6..],
+                &[
+                    "2023-01-01 04:05:06.789".to_string(),
+                    "2023-01-01 04:05:06".to_string(),
+                    "2023-01-01 00:00:00".to_string()
+                ]
+            )
+        }
+
+        test_tz("+00:00".into());
+        test_tz("+02:00".into());
+    }
+
+    #[test]
+    fn test_cast_invalid_utf8() {
+        let v1: &[u8] = b"\xFF invalid";
+        let v2: &[u8] = b"\x00 Foo";
+        let s = BinaryArray::from(vec![v1, v2]);
+        let options = CastOptions {
+            safe: true,
+            format_options: FormatOptions::default(),
+        };
+        let array = cast_with_options(&s, &DataType::Utf8, &options).unwrap();
+        let a = array.as_string::<i32>();
+        a.to_data().validate_full().unwrap();
+
+        assert_eq!(a.null_count(), 1);
+        assert_eq!(a.len(), 2);
+        assert!(a.is_null(0));
+        assert_eq!(a.value(0), "");
+        assert_eq!(a.value(1), "\x00 Foo");
+    }
+
+    #[test]
+    fn test_cast_utf8_to_timestamptz() {
+        let valid = StringArray::from(vec!["2023-01-01"]);
+
+        let array = Arc::new(valid) as ArrayRef;
+        let b = cast(
+            &array,
+            &DataType::Timestamp(TimeUnit::Nanosecond, Some("+00:00".into())),
+        )
+        .unwrap();
+
+        let expect = DataType::Timestamp(TimeUnit::Nanosecond, Some("+00:00".into()));
+
+        assert_eq!(b.data_type(), &expect);
+        let c = b
+            .as_any()
+            .downcast_ref::<TimestampNanosecondArray>()
+            .unwrap();
+        assert_eq!(1672531200000000000, c.value(0));
+    }
+
+    #[test]
+    fn test_cast_decimal_to_utf8() {
+        fn test_decimal_to_string<IN: ArrowPrimitiveType, OffsetSize: OffsetSizeTrait>(
+            output_type: DataType,
+            array: PrimitiveArray<IN>,
+        ) {
+            let b = cast(&array, &output_type).unwrap();
+
+            assert_eq!(b.data_type(), &output_type);
+            let c = b.as_string::<OffsetSize>();
+
+            assert_eq!("1123.454", c.value(0));
+            assert_eq!("2123.456", c.value(1));
+            assert_eq!("-3123.453", c.value(2));
+            assert_eq!("-3123.456", c.value(3));
+            assert_eq!("0.000", c.value(4));
+            assert_eq!("0.123", c.value(5));
+            assert_eq!("1234.567", c.value(6));
+            assert_eq!("-1234.567", c.value(7));
+            assert!(c.is_null(8));
+        }
+        let array128: Vec<Option<i128>> = vec![
+            Some(1123454),
+            Some(2123456),
+            Some(-3123453),
+            Some(-3123456),
+            Some(0),
+            Some(123),
+            Some(123456789),
+            Some(-123456789),
+            None,
+        ];
+
+        let array256: Vec<Option<i256>> = array128.iter().map(|v| v.map(i256::from_i128)).collect();
+
+        test_decimal_to_string::<arrow_array::types::Decimal128Type, i32>(
+            DataType::Utf8,
+            create_decimal_array(array128.clone(), 7, 3).unwrap(),
+        );
+        test_decimal_to_string::<arrow_array::types::Decimal128Type, i64>(
+            DataType::LargeUtf8,
+            create_decimal_array(array128, 7, 3).unwrap(),
+        );
+        test_decimal_to_string::<arrow_array::types::Decimal256Type, i32>(
+            DataType::Utf8,
+            create_decimal256_array(array256.clone(), 7, 3).unwrap(),
+        );
+        test_decimal_to_string::<arrow_array::types::Decimal256Type, i64>(
+            DataType::LargeUtf8,
+            create_decimal256_array(array256, 7, 3).unwrap(),
+        );
+    }
+
+    #[test]
+    fn test_cast_numeric_to_decimal128_precision_overflow() {
+        let array = Int64Array::from(vec![1234567]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal128(7, 3),
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        let err = cast_with_options(
+            &array,
+            &DataType::Decimal128(7, 3),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!("Invalid argument error: 1234567000 is too large to store in a Decimal128 of precision 7. Max is 9999999", err.unwrap_err().to_string());
+    }
+
+    #[test]
+    fn test_cast_numeric_to_decimal256_precision_overflow() {
+        let array = Int64Array::from(vec![1234567]);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Decimal256(7, 3),
+            &CastOptions {
+                safe: true,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_ok());
+        assert!(casted_array.unwrap().is_null(0));
+
+        let err = cast_with_options(
+            &array,
+            &DataType::Decimal256(7, 3),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert_eq!("Invalid argument error: 1234567000 is too large to store in a Decimal256 of precision 7. Max is 9999999", err.unwrap_err().to_string());
+    }
+
+    /// helper function to test casting from duration to interval
+    fn cast_from_duration_to_interval<T: ArrowTemporalType<Native = i64>>(
+        array: Vec<i64>,
+        cast_options: &CastOptions,
+    ) -> Result<PrimitiveArray<IntervalMonthDayNanoType>, ArrowError> {
+        let array = PrimitiveArray::<T>::new(array.into(), None);
+        let array = Arc::new(array) as ArrayRef;
+        let interval = DataType::Interval(IntervalUnit::MonthDayNano);
+        let out = cast_with_options(&array, &interval, cast_options)?;
+        let out = out.as_primitive::<IntervalMonthDayNanoType>().clone();
+        Ok(out)
+    }
+
+    #[test]
+    fn test_cast_from_duration_to_interval() {
+        // from duration second to interval month day nano
+        let array = vec![1234567];
+        let casted_array =
+            cast_from_duration_to_interval::<DurationSecondType>(array, &CastOptions::default())
+                .unwrap();
+        assert_eq!(
+            casted_array.data_type(),
+            &DataType::Interval(IntervalUnit::MonthDayNano)
+        );
+        assert_eq!(casted_array.value(0), 1234567000000000);
+
+        let array = vec![i64::MAX];
+        let casted_array = cast_from_duration_to_interval::<DurationSecondType>(
+            array.clone(),
+            &CastOptions::default(),
+        )
+        .unwrap();
+        assert!(!casted_array.is_valid(0));
+
+        let casted_array = cast_from_duration_to_interval::<DurationSecondType>(
+            array,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_err());
+
+        // from duration millisecond to interval month day nano
+        let array = vec![1234567];
+        let casted_array = cast_from_duration_to_interval::<DurationMillisecondType>(
+            array,
+            &CastOptions::default(),
+        )
+        .unwrap();
+        assert_eq!(
+            casted_array.data_type(),
+            &DataType::Interval(IntervalUnit::MonthDayNano)
+        );
+        assert_eq!(casted_array.value(0), 1234567000000);
+
+        let array = vec![i64::MAX];
+        let casted_array = cast_from_duration_to_interval::<DurationMillisecondType>(
+            array.clone(),
+            &CastOptions::default(),
+        )
+        .unwrap();
+        assert!(!casted_array.is_valid(0));
+
+        let casted_array = cast_from_duration_to_interval::<DurationMillisecondType>(
+            array,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_err());
+
+        // from duration microsecond to interval month day nano
+        let array = vec![1234567];
+        let casted_array = cast_from_duration_to_interval::<DurationMicrosecondType>(
+            array,
+            &CastOptions::default(),
+        )
+        .unwrap();
+        assert_eq!(
+            casted_array.data_type(),
+            &DataType::Interval(IntervalUnit::MonthDayNano)
+        );
+        assert_eq!(casted_array.value(0), 1234567000);
+
+        let array = vec![i64::MAX];
+        let casted_array = cast_from_duration_to_interval::<DurationMicrosecondType>(
+            array.clone(),
+            &CastOptions::default(),
+        )
+        .unwrap();
+        assert!(!casted_array.is_valid(0));
+
+        let casted_array = cast_from_duration_to_interval::<DurationMicrosecondType>(
+            array,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        );
+        assert!(casted_array.is_err());
+
+        // from duration nanosecond to interval month day nano
+        let array = vec![1234567];
+        let casted_array = cast_from_duration_to_interval::<DurationNanosecondType>(
+            array,
+            &CastOptions::default(),
+        )
+        .unwrap();
+        assert_eq!(
+            casted_array.data_type(),
+            &DataType::Interval(IntervalUnit::MonthDayNano)
+        );
+        assert_eq!(casted_array.value(0), 1234567);
+
+        let array = vec![i64::MAX];
+        let casted_array = cast_from_duration_to_interval::<DurationNanosecondType>(
+            array,
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        )
+        .unwrap();
+        assert_eq!(casted_array.value(0), 9223372036854775807);
+    }
+
+    /// helper function to test casting from interval to duration
+    fn cast_from_interval_to_duration<T: ArrowTemporalType>(
+        array: &IntervalMonthDayNanoArray,
+        cast_options: &CastOptions,
+    ) -> Result<PrimitiveArray<T>, ArrowError> {
+        let casted_array = cast_with_options(&array, &T::DATA_TYPE, cast_options)?;
+        casted_array
+            .as_any()
+            .downcast_ref::<PrimitiveArray<T>>()
+            .ok_or_else(|| {
+                ArrowError::ComputeError(format!("Failed to downcast to {}", T::DATA_TYPE))
+            })
+            .cloned()
+    }
+
+    #[test]
+    fn test_cast_from_interval_to_duration() {
+        let nullable = CastOptions::default();
+        let fallible = CastOptions {
+            safe: false,
+            format_options: FormatOptions::default(),
+        };
+
+        // from interval month day nano to duration second
+        let array = vec![1234567].into();
+        let casted_array: DurationSecondArray =
+            cast_from_interval_to_duration(&array, &nullable).unwrap();
+        assert_eq!(casted_array.value(0), 0);
+
+        let array = vec![i128::MAX].into();
+        let casted_array: DurationSecondArray =
+            cast_from_interval_to_duration(&array, &nullable).unwrap();
+        assert!(!casted_array.is_valid(0));
+
+        let res = cast_from_interval_to_duration::<DurationSecondType>(&array, &fallible);
+        assert!(res.is_err());
+
+        // from interval month day nano to duration millisecond
+        let array = vec![1234567].into();
+        let casted_array: DurationMillisecondArray =
+            cast_from_interval_to_duration(&array, &nullable).unwrap();
+        assert_eq!(casted_array.value(0), 1);
+
+        let array = vec![i128::MAX].into();
+        let casted_array: DurationMillisecondArray =
+            cast_from_interval_to_duration(&array, &nullable).unwrap();
+        assert!(!casted_array.is_valid(0));
+
+        let res = cast_from_interval_to_duration::<DurationMillisecondType>(&array, &fallible);
+        assert!(res.is_err());
+
+        // from interval month day nano to duration microsecond
+        let array = vec![1234567].into();
+        let casted_array: DurationMicrosecondArray =
+            cast_from_interval_to_duration(&array, &nullable).unwrap();
+        assert_eq!(casted_array.value(0), 1234);
+
+        let array = vec![i128::MAX].into();
+        let casted_array =
+            cast_from_interval_to_duration::<DurationMicrosecondType>(&array, &nullable).unwrap();
+        assert!(!casted_array.is_valid(0));
+
+        let casted_array =
+            cast_from_interval_to_duration::<DurationMicrosecondType>(&array, &fallible);
+        assert!(casted_array.is_err());
+
+        // from interval month day nano to duration nanosecond
+        let array = vec![1234567].into();
+        let casted_array: DurationNanosecondArray =
+            cast_from_interval_to_duration(&array, &nullable).unwrap();
+        assert_eq!(casted_array.value(0), 1234567);
+
+        let array = vec![i128::MAX].into();
+        let casted_array: DurationNanosecondArray =
+            cast_from_interval_to_duration(&array, &nullable).unwrap();
+        assert!(!casted_array.is_valid(0));
+
+        let casted_array =
+            cast_from_interval_to_duration::<DurationNanosecondType>(&array, &fallible);
+        assert!(casted_array.is_err());
+
+        let array = vec![
+            IntervalMonthDayNanoType::make_value(0, 1, 0),
+            IntervalMonthDayNanoType::make_value(-1, 0, 0),
+            IntervalMonthDayNanoType::make_value(1, 1, 0),
+            IntervalMonthDayNanoType::make_value(1, 0, 1),
+            IntervalMonthDayNanoType::make_value(0, 0, -1),
+        ]
+        .into();
+        let casted_array =
+            cast_from_interval_to_duration::<DurationNanosecondType>(&array, &nullable).unwrap();
+        assert!(!casted_array.is_valid(0));
+        assert!(!casted_array.is_valid(1));
+        assert!(!casted_array.is_valid(2));
+        assert!(!casted_array.is_valid(3));
+        assert!(casted_array.is_valid(4));
+        assert_eq!(casted_array.value(4), -1);
+    }
+
+    /// helper function to test casting from interval year month to interval month day nano
+    fn cast_from_interval_year_month_to_interval_month_day_nano(
+        array: Vec<i32>,
+        cast_options: &CastOptions,
+    ) -> Result<PrimitiveArray<IntervalMonthDayNanoType>, ArrowError> {
+        let array = PrimitiveArray::<IntervalYearMonthType>::from(array);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Interval(IntervalUnit::MonthDayNano),
+            cast_options,
+        )?;
+        casted_array
+            .as_any()
+            .downcast_ref::<IntervalMonthDayNanoArray>()
+            .ok_or_else(|| {
+                ArrowError::ComputeError(
+                    "Failed to downcast to IntervalMonthDayNanoArray".to_string(),
+                )
+            })
+            .cloned()
+    }
+
+    #[test]
+    fn test_cast_from_interval_year_month_to_interval_month_day_nano() {
+        // from interval year month to interval month day nano
+        let array = vec![1234567];
+        let casted_array = cast_from_interval_year_month_to_interval_month_day_nano(
+            array,
+            &CastOptions::default(),
+        )
+        .unwrap();
+        assert_eq!(
+            casted_array.data_type(),
+            &DataType::Interval(IntervalUnit::MonthDayNano)
+        );
+        assert_eq!(casted_array.value(0), 97812474910747780469848774134464512);
+    }
+
+    /// helper function to test casting from interval day time to interval month day nano
+    fn cast_from_interval_day_time_to_interval_month_day_nano(
+        array: Vec<i64>,
+        cast_options: &CastOptions,
+    ) -> Result<PrimitiveArray<IntervalMonthDayNanoType>, ArrowError> {
+        let array = PrimitiveArray::<IntervalDayTimeType>::from(array);
+        let array = Arc::new(array) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Interval(IntervalUnit::MonthDayNano),
+            cast_options,
+        )?;
+        Ok(casted_array
+            .as_primitive::<IntervalMonthDayNanoType>()
+            .clone())
+    }
+
+    #[test]
+    fn test_cast_from_interval_day_time_to_interval_month_day_nano() {
+        // from interval day time to interval month day nano
+        let array = vec![123];
+        let casted_array =
+            cast_from_interval_day_time_to_interval_month_day_nano(array, &CastOptions::default())
+                .unwrap();
+        assert_eq!(
+            casted_array.data_type(),
+            &DataType::Interval(IntervalUnit::MonthDayNano)
+        );
+        assert_eq!(casted_array.value(0), 123000000);
+    }
+
+    #[test]
+    fn test_cast_below_unixtimestamp() {
+        let valid = StringArray::from(vec![
+            "1900-01-03 23:59:59",
+            "1969-12-31 00:00:01",
+            "1989-12-31 00:00:01",
+        ]);
+
+        let array = Arc::new(valid) as ArrayRef;
+        let casted_array = cast_with_options(
+            &array,
+            &DataType::Timestamp(TimeUnit::Nanosecond, Some("+00:00".into())),
+            &CastOptions {
+                safe: false,
+                format_options: FormatOptions::default(),
+            },
+        )
+        .unwrap();
+
+        let ts_array = casted_array
+            .as_primitive::<TimestampNanosecondType>()
+            .values()
+            .iter()
+            .map(|ts| ts / 1_000_000)
+            .collect::<Vec<_>>();
+
+        let array = TimestampMillisecondArray::from(ts_array).with_timezone("UTC".to_string());
+        let casted_array = cast(&array, &DataType::Date32).unwrap();
+        let date_array = casted_array.as_primitive::<Date32Type>();
+        let casted_array = cast(&date_array, &DataType::Utf8).unwrap();
+        let string_array = casted_array.as_string::<i32>();
+        assert_eq!("1900-01-03", string_array.value(0));
+        assert_eq!("1969-12-31", string_array.value(1));
+        assert_eq!("1989-12-31", string_array.value(2));
+    }
+
+    #[test]
+    fn test_nested_list() {
+        let mut list = ListBuilder::new(Int32Builder::new());
+        list.append_value([Some(1), Some(2), Some(3)]);
+        list.append_value([Some(4), None, Some(6)]);
+        let list = list.finish();
+
+        let to_field = Field::new("nested", list.data_type().clone(), false);
+        let to = DataType::List(Arc::new(to_field));
+        let out = cast(&list, &to).unwrap();
+        let opts = FormatOptions::default().with_null("null");
+        let formatted = ArrayFormatter::try_new(out.as_ref(), &opts).unwrap();
+
+        assert_eq!(formatted.value(0).to_string(), "[[1], [2], [3]]");
+        assert_eq!(formatted.value(1).to_string(), "[[4], [null], [6]]");
+    }
+
+    #[test]
+    fn test_nested_list_cast() {
+        let mut builder = ListBuilder::new(ListBuilder::new(Int32Builder::new()));
+        builder.append_value([Some([Some(1), Some(2), None]), None]);
+        builder.append_value([None, Some([]), None]);
+        builder.append_null();
+        builder.append_value([Some([Some(2), Some(3)])]);
+        let start = builder.finish();
+
+        let mut builder = LargeListBuilder::new(LargeListBuilder::new(Int8Builder::new()));
+        builder.append_value([Some([Some(1), Some(2), None]), None]);
+        builder.append_value([None, Some([]), None]);
+        builder.append_null();
+        builder.append_value([Some([Some(2), Some(3)])]);
+        let expected = builder.finish();
+
+        let actual = cast(&start, expected.data_type()).unwrap();
+        assert_eq!(actual.as_ref(), &expected);
+    }
+
+    const CAST_OPTIONS: CastOptions<'static> = CastOptions {
+        safe: true,
+        format_options: FormatOptions::new(),
+    };
+
+    #[test]
+    #[allow(clippy::assertions_on_constants)]
+    fn test_const_options() {
+        assert!(CAST_OPTIONS.safe)
+    }
+
+    #[test]
+    fn test_list_format_options() {
+        let options = CastOptions {
+            safe: false,
+            format_options: FormatOptions::default().with_null("null"),
+        };
+        let array = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+            Some(vec![Some(0), Some(1), Some(2)]),
+            Some(vec![Some(0), None, Some(2)]),
+        ]);
+        let a = cast_with_options(&array, &DataType::Utf8, &options).unwrap();
+        let r: Vec<_> = a.as_string::<i32>().iter().map(|x| x.unwrap()).collect();
+        assert_eq!(r, &["[0, 1, 2]", "[0, null, 2]"]);
+    }
+    #[test]
+    fn test_cast_string_to_timestamp_invalid_tz() {
+        // content after Z should be ignored
+        let bad_timestamp = "2023-12-05T21:58:10.45ZZTOP";
+        let array = StringArray::from(vec![Some(bad_timestamp)]);
+
+        let data_types = [
+            DataType::Timestamp(TimeUnit::Second, None),
+            DataType::Timestamp(TimeUnit::Millisecond, None),
+            DataType::Timestamp(TimeUnit::Microsecond, None),
+            DataType::Timestamp(TimeUnit::Nanosecond, None),
+        ];
+
+        let cast_options = CastOptions {
+            safe: false,
+            ..Default::default()
+        };
+
+        for dt in data_types {
+            assert_eq!(
+                cast_with_options(&array, &dt, &cast_options).unwrap_err().to_string(),
+                "Parser error: Invalid timezone \"ZZTOP\": only offset based timezones supported without chrono-tz feature"
+            );
+        }
+    }
+    #[test]
+    fn test_cast_struct_to_struct() {
+        let struct_type = DataType::Struct(
+            vec![
+                Field::new("a", DataType::Boolean, false),
+                Field::new("b", DataType::Int32, false),
+            ]
+            .into(),
+        );
+        let to_type = DataType::Struct(
+            vec![
+                Field::new("a", DataType::Utf8, false),
+                Field::new("b", DataType::Utf8, false),
+            ]
+            .into(),
+        );
+        let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
+        let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
+        let struct_array = StructArray::from(vec![
+            (
+                Arc::new(Field::new("b", DataType::Boolean, false)),
+                boolean.clone() as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new("c", DataType::Int32, false)),
+                int.clone() as ArrayRef,
+            ),
+        ]);
+        let casted_array = cast(&struct_array, &to_type).unwrap();
+        let casted_array = casted_array.as_struct();
+        assert_eq!(casted_array.data_type(), &to_type);
+        let casted_boolean_array = casted_array
+            .column(0)
+            .as_string::<i32>()
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+        let casted_int_array = casted_array
+            .column(1)
+            .as_string::<i32>()
+            .into_iter()
+            .flatten()
+            .collect::<Vec<_>>();
+        assert_eq!(casted_boolean_array, vec!["false", "false", "true", "true"]);
+        assert_eq!(casted_int_array, vec!["42", "28", "19", "31"]);
+
+        // test for can't cast
+        let to_type = DataType::Struct(
+            vec![
+                Field::new("a", DataType::Date32, false),
+                Field::new("b", DataType::Utf8, false),
+            ]
+            .into(),
+        );
+        assert!(!can_cast_types(&struct_type, &to_type));
+        let result = cast(&struct_array, &to_type);
+        assert_eq!(
+            "Cast error: Casting from Boolean to Date32 not supported",
+            result.unwrap_err().to_string()
+        );
+    }
+
+    #[test]
+    fn test_cast_struct_to_struct_nullability() {
+        let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
+        let int = Arc::new(Int32Array::from(vec![Some(42), None, Some(19), None]));
+        let struct_array = StructArray::from(vec![
+            (
+                Arc::new(Field::new("b", DataType::Boolean, false)),
+                boolean.clone() as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new("c", DataType::Int32, true)),
+                int.clone() as ArrayRef,
+            ),
+        ]);
+
+        // okay: nullable to nullable
+        let to_type = DataType::Struct(
+            vec![
+                Field::new("a", DataType::Utf8, false),
+                Field::new("b", DataType::Utf8, true),
+            ]
+            .into(),
+        );
+        cast(&struct_array, &to_type).expect("Cast nullable to nullable struct field should work");
+
+        // error: nullable to non-nullable
+        let to_type = DataType::Struct(
+            vec![
+                Field::new("a", DataType::Utf8, false),
+                Field::new("b", DataType::Utf8, false),
+            ]
+            .into(),
+        );
+        cast(&struct_array, &to_type)
+            .expect_err("Cast nullable to non-nullable struct field should fail");
+
+        let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
+        let int = Arc::new(Int32Array::from(vec![i32::MAX, 25, 1, 100]));
+        let struct_array = StructArray::from(vec![
+            (
+                Arc::new(Field::new("b", DataType::Boolean, false)),
+                boolean.clone() as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new("c", DataType::Int32, false)),
+                int.clone() as ArrayRef,
+            ),
+        ]);
+
+        // okay: non-nullable to non-nullable
+        let to_type = DataType::Struct(
+            vec![
+                Field::new("a", DataType::Utf8, false),
+                Field::new("b", DataType::Utf8, false),
+            ]
+            .into(),
+        );
+        cast(&struct_array, &to_type)
+            .expect("Cast non-nullable to non-nullable struct field should work");
+
+        // err: non-nullable to non-nullable but overflowing return null during casting
+        let to_type = DataType::Struct(
+            vec![
+                Field::new("a", DataType::Utf8, false),
+                Field::new("b", DataType::Int8, false),
+            ]
+            .into(),
+        );
+        cast(&struct_array, &to_type).expect_err(
+            "Cast non-nullable to non-nullable struct field returning null should fail",
+        );
+    }
+}
diff --git a/arrow-cast/src/display.rs b/arrow-cast/src/display.rs
new file mode 100644
index 000000000000..9ec12f6e63d2
--- /dev/null
+++ b/arrow-cast/src/display.rs
@@ -0,0 +1,1132 @@
+// 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.
+
+//! Functions for printing array values, as strings, for debugging
+//! purposes. See the `pretty` crate for additional functions for
+//! record batch pretty printing.
+
+use std::fmt::{Display, Formatter, Write};
+use std::ops::Range;
+
+use arrow_array::cast::*;
+use arrow_array::temporal_conversions::*;
+use arrow_array::timezone::Tz;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::ArrowNativeType;
+use arrow_schema::*;
+use chrono::{NaiveDate, NaiveDateTime, SecondsFormat, TimeZone, Utc};
+use lexical_core::FormattedSize;
+
+type TimeFormat<'a> = Option<&'a str>;
+
+/// Format for displaying durations
+#[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
+#[non_exhaustive]
+pub enum DurationFormat {
+    /// ISO 8601 - `P198DT72932.972880S`
+    ISO8601,
+    /// A human readable representation - `198 days 16 hours 34 mins 15.407810000 secs`
+    Pretty,
+}
+
+/// Options for formatting arrays
+///
+/// By default nulls are formatted as `""` and temporal types formatted
+/// according to RFC3339
+///
+#[derive(Debug, Clone, PartialEq, Eq, Hash)]
+pub struct FormatOptions<'a> {
+    /// If set to `true` any formatting errors will be written to the output
+    /// instead of being converted into a [`std::fmt::Error`]
+    safe: bool,
+    /// Format string for nulls
+    null: &'a str,
+    /// Date format for date arrays
+    date_format: TimeFormat<'a>,
+    /// Format for DateTime arrays
+    datetime_format: TimeFormat<'a>,
+    /// Timestamp format for timestamp arrays
+    timestamp_format: TimeFormat<'a>,
+    /// Timestamp format for timestamp with timezone arrays
+    timestamp_tz_format: TimeFormat<'a>,
+    /// Time format for time arrays
+    time_format: TimeFormat<'a>,
+    /// Duration format
+    duration_format: DurationFormat,
+}
+
+impl<'a> Default for FormatOptions<'a> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<'a> FormatOptions<'a> {
+    pub const fn new() -> Self {
+        Self {
+            safe: true,
+            null: "",
+            date_format: None,
+            datetime_format: None,
+            timestamp_format: None,
+            timestamp_tz_format: None,
+            time_format: None,
+            duration_format: DurationFormat::ISO8601,
+        }
+    }
+
+    /// If set to `true` any formatting errors will be written to the output
+    /// instead of being converted into a [`std::fmt::Error`]
+    pub const fn with_display_error(mut self, safe: bool) -> Self {
+        self.safe = safe;
+        self
+    }
+
+    /// Overrides the string used to represent a null
+    ///
+    /// Defaults to `""`
+    pub const fn with_null(self, null: &'a str) -> Self {
+        Self { null, ..self }
+    }
+
+    /// Overrides the format used for [`DataType::Date32`] columns
+    pub const fn with_date_format(self, date_format: Option<&'a str>) -> Self {
+        Self {
+            date_format,
+            ..self
+        }
+    }
+
+    /// Overrides the format used for [`DataType::Date64`] columns
+    pub const fn with_datetime_format(self, datetime_format: Option<&'a str>) -> Self {
+        Self {
+            datetime_format,
+            ..self
+        }
+    }
+
+    /// Overrides the format used for [`DataType::Timestamp`] columns without a timezone
+    pub const fn with_timestamp_format(self, timestamp_format: Option<&'a str>) -> Self {
+        Self {
+            timestamp_format,
+            ..self
+        }
+    }
+
+    /// Overrides the format used for [`DataType::Timestamp`] columns with a timezone
+    pub const fn with_timestamp_tz_format(self, timestamp_tz_format: Option<&'a str>) -> Self {
+        Self {
+            timestamp_tz_format,
+            ..self
+        }
+    }
+
+    /// Overrides the format used for [`DataType::Time32`] and [`DataType::Time64`] columns
+    pub const fn with_time_format(self, time_format: Option<&'a str>) -> Self {
+        Self {
+            time_format,
+            ..self
+        }
+    }
+
+    /// Overrides the format used for duration columns
+    ///
+    /// Defaults to [`DurationFormat::ISO8601`]
+    pub const fn with_duration_format(self, duration_format: DurationFormat) -> Self {
+        Self {
+            duration_format,
+            ..self
+        }
+    }
+}
+
+/// Implements [`Display`] for a specific array value
+pub struct ValueFormatter<'a> {
+    idx: usize,
+    formatter: &'a ArrayFormatter<'a>,
+}
+
+impl<'a> ValueFormatter<'a> {
+    /// Writes this value to the provided [`Write`]
+    ///
+    /// Note: this ignores [`FormatOptions::with_display_error`] and
+    /// will return an error on formatting issue
+    pub fn write(&self, s: &mut dyn Write) -> Result<(), ArrowError> {
+        match self.formatter.format.write(self.idx, s) {
+            Ok(_) => Ok(()),
+            Err(FormatError::Arrow(e)) => Err(e),
+            Err(FormatError::Format(_)) => Err(ArrowError::CastError("Format error".to_string())),
+        }
+    }
+
+    /// Fallibly converts this to a string
+    pub fn try_to_string(&self) -> Result<String, ArrowError> {
+        let mut s = String::new();
+        self.write(&mut s)?;
+        Ok(s)
+    }
+}
+
+impl<'a> Display for ValueFormatter<'a> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self.formatter.format.write(self.idx, f) {
+            Ok(()) => Ok(()),
+            Err(FormatError::Arrow(e)) if self.formatter.safe => {
+                write!(f, "ERROR: {e}")
+            }
+            Err(_) => Err(std::fmt::Error),
+        }
+    }
+}
+
+/// A string formatter for an [`Array`]
+///
+/// This can be used with [`std::write`] to write type-erased `dyn Array`
+///
+/// ```
+/// # use std::fmt::{Display, Formatter, Write};
+/// # use arrow_array::{Array, ArrayRef, Int32Array};
+/// # use arrow_cast::display::{ArrayFormatter, FormatOptions};
+/// # use arrow_schema::ArrowError;
+/// struct MyContainer {
+///     values: ArrayRef,
+/// }
+///
+/// impl Display for MyContainer {
+///     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+///         let options = FormatOptions::default();
+///         let formatter = ArrayFormatter::try_new(self.values.as_ref(), &options)
+///             .map_err(|_| std::fmt::Error)?;
+///
+///         let mut iter = 0..self.values.len();
+///         if let Some(idx) = iter.next() {
+///             write!(f, "{}", formatter.value(idx))?;
+///         }
+///         for idx in iter {
+///             write!(f, ", {}", formatter.value(idx))?;
+///         }
+///         Ok(())
+///     }
+/// }
+/// ```
+///
+/// [`ValueFormatter::write`] can also be used to get a semantic error, instead of the
+/// opaque [`std::fmt::Error`]
+///
+/// ```
+/// # use std::fmt::Write;
+/// # use arrow_array::Array;
+/// # use arrow_cast::display::{ArrayFormatter, FormatOptions};
+/// # use arrow_schema::ArrowError;
+/// fn format_array(
+///     f: &mut dyn Write,
+///     array: &dyn Array,
+///     options: &FormatOptions,
+/// ) -> Result<(), ArrowError> {
+///     let formatter = ArrayFormatter::try_new(array, options)?;
+///     for i in 0..array.len() {
+///         formatter.value(i).write(f)?
+///     }
+///     Ok(())
+/// }
+/// ```
+///
+pub struct ArrayFormatter<'a> {
+    format: Box<dyn DisplayIndex + 'a>,
+    safe: bool,
+}
+
+impl<'a> ArrayFormatter<'a> {
+    /// Returns an [`ArrayFormatter`] that can be used to format `array`
+    ///
+    /// This returns an error if an array of the given data type cannot be formatted
+    pub fn try_new(array: &'a dyn Array, options: &FormatOptions<'a>) -> Result<Self, ArrowError> {
+        Ok(Self {
+            format: make_formatter(array, options)?,
+            safe: options.safe,
+        })
+    }
+
+    /// Returns a [`ValueFormatter`] that implements [`Display`] for
+    /// the value of the array at `idx`
+    pub fn value(&self, idx: usize) -> ValueFormatter<'_> {
+        ValueFormatter {
+            formatter: self,
+            idx,
+        }
+    }
+}
+
+fn make_formatter<'a>(
+    array: &'a dyn Array,
+    options: &FormatOptions<'a>,
+) -> Result<Box<dyn DisplayIndex + 'a>, ArrowError> {
+    downcast_primitive_array! {
+        array => array_format(array, options),
+        DataType::Null => array_format(as_null_array(array), options),
+        DataType::Boolean => array_format(as_boolean_array(array), options),
+        DataType::Utf8 => array_format(array.as_string::<i32>(), options),
+        DataType::LargeUtf8 => array_format(array.as_string::<i64>(), options),
+        DataType::Binary => array_format(array.as_binary::<i32>(), options),
+        DataType::LargeBinary => array_format(array.as_binary::<i64>(), options),
+        DataType::FixedSizeBinary(_) => {
+            let a = array.as_any().downcast_ref::<FixedSizeBinaryArray>().unwrap();
+            array_format(a, options)
+        }
+        DataType::Dictionary(_, _) => downcast_dictionary_array! {
+            array => array_format(array, options),
+            _ => unreachable!()
+        }
+        DataType::List(_) => array_format(as_generic_list_array::<i32>(array), options),
+        DataType::LargeList(_) => array_format(as_generic_list_array::<i64>(array), options),
+        DataType::FixedSizeList(_, _) => {
+            let a = array.as_any().downcast_ref::<FixedSizeListArray>().unwrap();
+            array_format(a, options)
+        }
+        DataType::Struct(_) => array_format(as_struct_array(array), options),
+        DataType::Map(_, _) => array_format(as_map_array(array), options),
+        DataType::Union(_, _) => array_format(as_union_array(array), options),
+        DataType::RunEndEncoded(_, _) => downcast_run_array! {
+            array => array_format(array, options),
+            _ => unreachable!()
+        },
+        d => Err(ArrowError::NotYetImplemented(format!("formatting {d} is not yet supported"))),
+    }
+}
+
+/// Either an [`ArrowError`] or [`std::fmt::Error`]
+enum FormatError {
+    Format(std::fmt::Error),
+    Arrow(ArrowError),
+}
+
+type FormatResult = Result<(), FormatError>;
+
+impl From<std::fmt::Error> for FormatError {
+    fn from(value: std::fmt::Error) -> Self {
+        Self::Format(value)
+    }
+}
+
+impl From<ArrowError> for FormatError {
+    fn from(value: ArrowError) -> Self {
+        Self::Arrow(value)
+    }
+}
+
+/// [`Display`] but accepting an index
+trait DisplayIndex {
+    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult;
+}
+
+/// [`DisplayIndex`] with additional state
+trait DisplayIndexState<'a> {
+    type State;
+
+    fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError>;
+
+    fn write(&self, state: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult;
+}
+
+impl<'a, T: DisplayIndex> DisplayIndexState<'a> for T {
+    type State = ();
+
+    fn prepare(&self, _options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+        Ok(())
+    }
+
+    fn write(&self, _: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+        DisplayIndex::write(self, idx, f)
+    }
+}
+
+struct ArrayFormat<'a, F: DisplayIndexState<'a>> {
+    state: F::State,
+    array: F,
+    null: &'a str,
+}
+
+fn array_format<'a, F>(
+    array: F,
+    options: &FormatOptions<'a>,
+) -> Result<Box<dyn DisplayIndex + 'a>, ArrowError>
+where
+    F: DisplayIndexState<'a> + Array + 'a,
+{
+    let state = array.prepare(options)?;
+    Ok(Box::new(ArrayFormat {
+        state,
+        array,
+        null: options.null,
+    }))
+}
+
+impl<'a, F: DisplayIndexState<'a> + Array> DisplayIndex for ArrayFormat<'a, F> {
+    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+        if self.array.is_null(idx) {
+            if !self.null.is_empty() {
+                f.write_str(self.null)?
+            }
+            return Ok(());
+        }
+        DisplayIndexState::write(&self.array, &self.state, idx, f)
+    }
+}
+
+impl<'a> DisplayIndex for &'a BooleanArray {
+    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+        write!(f, "{}", self.value(idx))?;
+        Ok(())
+    }
+}
+
+impl<'a> DisplayIndexState<'a> for &'a NullArray {
+    type State = &'a str;
+
+    fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+        Ok(options.null)
+    }
+
+    fn write(&self, state: &Self::State, _idx: usize, f: &mut dyn Write) -> FormatResult {
+        f.write_str(state)?;
+        Ok(())
+    }
+}
+
+macro_rules! primitive_display {
+    ($($t:ty),+) => {
+        $(impl<'a> DisplayIndex for &'a PrimitiveArray<$t>
+        {
+            fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+                let value = self.value(idx);
+                let mut buffer = [0u8; <$t as ArrowPrimitiveType>::Native::FORMATTED_SIZE];
+                // SAFETY:
+                // buffer is T::FORMATTED_SIZE
+                let b = unsafe { lexical_core::write_unchecked(value, &mut buffer) };
+                // Lexical core produces valid UTF-8
+                let s = unsafe { std::str::from_utf8_unchecked(b) };
+                f.write_str(s)?;
+                Ok(())
+            }
+        })+
+    };
+}
+
+macro_rules! primitive_display_float {
+    ($($t:ty),+) => {
+        $(impl<'a> DisplayIndex for &'a PrimitiveArray<$t>
+        {
+            fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+                let value = self.value(idx);
+                let mut buffer = ryu::Buffer::new();
+                f.write_str(buffer.format(value))?;
+                Ok(())
+            }
+        })+
+    };
+}
+
+primitive_display!(Int8Type, Int16Type, Int32Type, Int64Type);
+primitive_display!(UInt8Type, UInt16Type, UInt32Type, UInt64Type);
+primitive_display_float!(Float32Type, Float64Type);
+
+impl<'a> DisplayIndex for &'a PrimitiveArray<Float16Type> {
+    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+        write!(f, "{}", self.value(idx))?;
+        Ok(())
+    }
+}
+
+macro_rules! decimal_display {
+    ($($t:ty),+) => {
+        $(impl<'a> DisplayIndexState<'a> for &'a PrimitiveArray<$t> {
+            type State = (u8, i8);
+
+            fn prepare(&self, _options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+                Ok((self.precision(), self.scale()))
+            }
+
+            fn write(&self, s: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+                write!(f, "{}", <$t>::format_decimal(self.values()[idx], s.0, s.1))?;
+                Ok(())
+            }
+        })+
+    };
+}
+
+decimal_display!(Decimal128Type, Decimal256Type);
+
+fn write_timestamp(
+    f: &mut dyn Write,
+    naive: NaiveDateTime,
+    timezone: Option<Tz>,
+    format: Option<&str>,
+) -> FormatResult {
+    match timezone {
+        Some(tz) => {
+            let date = Utc.from_utc_datetime(&naive).with_timezone(&tz);
+            match format {
+                Some(s) => write!(f, "{}", date.format(s))?,
+                None => write!(f, "{}", date.to_rfc3339_opts(SecondsFormat::AutoSi, true))?,
+            }
+        }
+        None => match format {
+            Some(s) => write!(f, "{}", naive.format(s))?,
+            None => write!(f, "{naive:?}")?,
+        },
+    }
+    Ok(())
+}
+
+macro_rules! timestamp_display {
+    ($($t:ty),+) => {
+        $(impl<'a> DisplayIndexState<'a> for &'a PrimitiveArray<$t> {
+            type State = (Option<Tz>, TimeFormat<'a>);
+
+            fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+                match self.data_type() {
+                    DataType::Timestamp(_, Some(tz)) => Ok((Some(tz.parse()?), options.timestamp_tz_format)),
+                    DataType::Timestamp(_, None) => Ok((None, options.timestamp_format)),
+                    _ => unreachable!(),
+                }
+            }
+
+            fn write(&self, s: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+                let value = self.value(idx);
+                let naive = as_datetime::<$t>(value).ok_or_else(|| {
+                    ArrowError::CastError(format!(
+                        "Failed to convert {} to datetime for {}",
+                        value,
+                        self.data_type()
+                    ))
+                })?;
+
+                write_timestamp(f, naive, s.0, s.1.clone())
+            }
+        })+
+    };
+}
+
+timestamp_display!(
+    TimestampSecondType,
+    TimestampMillisecondType,
+    TimestampMicrosecondType,
+    TimestampNanosecondType
+);
+
+macro_rules! temporal_display {
+    ($convert:ident, $format:ident, $t:ty) => {
+        impl<'a> DisplayIndexState<'a> for &'a PrimitiveArray<$t> {
+            type State = TimeFormat<'a>;
+
+            fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+                Ok(options.$format)
+            }
+
+            fn write(&self, fmt: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+                let value = self.value(idx);
+                let naive = $convert(value as _).ok_or_else(|| {
+                    ArrowError::CastError(format!(
+                        "Failed to convert {} to temporal for {}",
+                        value,
+                        self.data_type()
+                    ))
+                })?;
+
+                match fmt {
+                    Some(s) => write!(f, "{}", naive.format(s))?,
+                    None => write!(f, "{naive:?}")?,
+                }
+                Ok(())
+            }
+        }
+    };
+}
+
+#[inline]
+fn date32_to_date(value: i32) -> Option<NaiveDate> {
+    Some(date32_to_datetime(value)?.date())
+}
+
+temporal_display!(date32_to_date, date_format, Date32Type);
+temporal_display!(date64_to_datetime, datetime_format, Date64Type);
+temporal_display!(time32s_to_time, time_format, Time32SecondType);
+temporal_display!(time32ms_to_time, time_format, Time32MillisecondType);
+temporal_display!(time64us_to_time, time_format, Time64MicrosecondType);
+temporal_display!(time64ns_to_time, time_format, Time64NanosecondType);
+
+macro_rules! duration_display {
+    ($convert:ident, $t:ty, $scale:tt) => {
+        impl<'a> DisplayIndexState<'a> for &'a PrimitiveArray<$t> {
+            type State = DurationFormat;
+
+            fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+                Ok(options.duration_format)
+            }
+
+            fn write(&self, fmt: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+                let v = self.value(idx);
+                match fmt {
+                    DurationFormat::ISO8601 => write!(f, "{}", $convert(v))?,
+                    DurationFormat::Pretty => duration_fmt!(f, v, $scale)?,
+                }
+                Ok(())
+            }
+        }
+    };
+}
+
+macro_rules! duration_fmt {
+    ($f:ident, $v:expr, 0) => {{
+        let secs = $v;
+        let mins = secs / 60;
+        let hours = mins / 60;
+        let days = hours / 24;
+
+        let secs = secs - (mins * 60);
+        let mins = mins - (hours * 60);
+        let hours = hours - (days * 24);
+        write!($f, "{days} days {hours} hours {mins} mins {secs} secs")
+    }};
+    ($f:ident, $v:expr, $scale:tt) => {{
+        let subsec = $v;
+        let secs = subsec / 10_i64.pow($scale);
+        let mins = secs / 60;
+        let hours = mins / 60;
+        let days = hours / 24;
+
+        let subsec = subsec - (secs * 10_i64.pow($scale));
+        let secs = secs - (mins * 60);
+        let mins = mins - (hours * 60);
+        let hours = hours - (days * 24);
+        match subsec.is_negative() {
+            true => {
+                write!(
+                    $f,
+                    concat!("{} days {} hours {} mins -{}.{:0", $scale, "} secs"),
+                    days,
+                    hours,
+                    mins,
+                    secs.abs(),
+                    subsec.abs()
+                )
+            }
+            false => {
+                write!(
+                    $f,
+                    concat!("{} days {} hours {} mins {}.{:0", $scale, "} secs"),
+                    days, hours, mins, secs, subsec
+                )
+            }
+        }
+    }};
+}
+
+duration_display!(duration_s_to_duration, DurationSecondType, 0);
+duration_display!(duration_ms_to_duration, DurationMillisecondType, 3);
+duration_display!(duration_us_to_duration, DurationMicrosecondType, 6);
+duration_display!(duration_ns_to_duration, DurationNanosecondType, 9);
+
+impl<'a> DisplayIndex for &'a PrimitiveArray<IntervalYearMonthType> {
+    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let interval = self.value(idx) as f64;
+        let years = (interval / 12_f64).floor();
+        let month = interval - (years * 12_f64);
+
+        write!(
+            f,
+            "{years} years {month} mons 0 days 0 hours 0 mins 0.00 secs",
+        )?;
+        Ok(())
+    }
+}
+
+impl<'a> DisplayIndex for &'a PrimitiveArray<IntervalDayTimeType> {
+    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let value: u64 = self.value(idx) as u64;
+
+        let days_parts: i32 = ((value & 0xFFFFFFFF00000000) >> 32) as i32;
+        let milliseconds_part: i32 = (value & 0xFFFFFFFF) as i32;
+
+        let secs = milliseconds_part / 1_000;
+        let mins = secs / 60;
+        let hours = mins / 60;
+
+        let secs = secs - (mins * 60);
+        let mins = mins - (hours * 60);
+
+        let milliseconds = milliseconds_part % 1_000;
+
+        let secs_sign = if secs < 0 || milliseconds < 0 {
+            "-"
+        } else {
+            ""
+        };
+
+        write!(
+            f,
+            "0 years 0 mons {} days {} hours {} mins {}{}.{:03} secs",
+            days_parts,
+            hours,
+            mins,
+            secs_sign,
+            secs.abs(),
+            milliseconds.abs(),
+        )?;
+        Ok(())
+    }
+}
+
+impl<'a> DisplayIndex for &'a PrimitiveArray<IntervalMonthDayNanoType> {
+    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let value: u128 = self.value(idx) as u128;
+
+        let months_part: i32 = ((value & 0xFFFFFFFF000000000000000000000000) >> 96) as i32;
+        let days_part: i32 = ((value & 0xFFFFFFFF0000000000000000) >> 64) as i32;
+        let nanoseconds_part: i64 = (value & 0xFFFFFFFFFFFFFFFF) as i64;
+
+        let secs = nanoseconds_part / 1_000_000_000;
+        let mins = secs / 60;
+        let hours = mins / 60;
+
+        let secs = secs - (mins * 60);
+        let mins = mins - (hours * 60);
+
+        let nanoseconds = nanoseconds_part % 1_000_000_000;
+
+        let secs_sign = if secs < 0 || nanoseconds < 0 { "-" } else { "" };
+
+        write!(
+            f,
+            "0 years {} mons {} days {} hours {} mins {}{}.{:09} secs",
+            months_part,
+            days_part,
+            hours,
+            mins,
+            secs_sign,
+            secs.abs(),
+            nanoseconds.abs(),
+        )?;
+        Ok(())
+    }
+}
+
+impl<'a, O: OffsetSizeTrait> DisplayIndex for &'a GenericStringArray<O> {
+    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+        write!(f, "{}", self.value(idx))?;
+        Ok(())
+    }
+}
+
+impl<'a, O: OffsetSizeTrait> DisplayIndex for &'a GenericBinaryArray<O> {
+    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let v = self.value(idx);
+        for byte in v {
+            write!(f, "{byte:02x}")?;
+        }
+        Ok(())
+    }
+}
+
+impl<'a> DisplayIndex for &'a FixedSizeBinaryArray {
+    fn write(&self, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let v = self.value(idx);
+        for byte in v {
+            write!(f, "{byte:02x}")?;
+        }
+        Ok(())
+    }
+}
+
+impl<'a, K: ArrowDictionaryKeyType> DisplayIndexState<'a> for &'a DictionaryArray<K> {
+    type State = Box<dyn DisplayIndex + 'a>;
+
+    fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+        make_formatter(self.values().as_ref(), options)
+    }
+
+    fn write(&self, s: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let value_idx = self.keys().values()[idx].as_usize();
+        s.as_ref().write(value_idx, f)
+    }
+}
+
+impl<'a, K: RunEndIndexType> DisplayIndexState<'a> for &'a RunArray<K> {
+    type State = Box<dyn DisplayIndex + 'a>;
+
+    fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+        make_formatter(self.values().as_ref(), options)
+    }
+
+    fn write(&self, s: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let value_idx = self.get_physical_index(idx);
+        s.as_ref().write(value_idx, f)
+    }
+}
+
+fn write_list(
+    f: &mut dyn Write,
+    mut range: Range<usize>,
+    values: &dyn DisplayIndex,
+) -> FormatResult {
+    f.write_char('[')?;
+    if let Some(idx) = range.next() {
+        values.write(idx, f)?;
+    }
+    for idx in range {
+        write!(f, ", ")?;
+        values.write(idx, f)?;
+    }
+    f.write_char(']')?;
+    Ok(())
+}
+
+impl<'a, O: OffsetSizeTrait> DisplayIndexState<'a> for &'a GenericListArray<O> {
+    type State = Box<dyn DisplayIndex + 'a>;
+
+    fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+        make_formatter(self.values().as_ref(), options)
+    }
+
+    fn write(&self, s: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let offsets = self.value_offsets();
+        let end = offsets[idx + 1].as_usize();
+        let start = offsets[idx].as_usize();
+        write_list(f, start..end, s.as_ref())
+    }
+}
+
+impl<'a> DisplayIndexState<'a> for &'a FixedSizeListArray {
+    type State = (usize, Box<dyn DisplayIndex + 'a>);
+
+    fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+        let values = make_formatter(self.values().as_ref(), options)?;
+        let length = self.value_length();
+        Ok((length as usize, values))
+    }
+
+    fn write(&self, s: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let start = idx * s.0;
+        let end = start + s.0;
+        write_list(f, start..end, s.1.as_ref())
+    }
+}
+
+/// Pairs a boxed [`DisplayIndex`] with its field name
+type FieldDisplay<'a> = (&'a str, Box<dyn DisplayIndex + 'a>);
+
+impl<'a> DisplayIndexState<'a> for &'a StructArray {
+    type State = Vec<FieldDisplay<'a>>;
+
+    fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+        let fields = match (*self).data_type() {
+            DataType::Struct(f) => f,
+            _ => unreachable!(),
+        };
+
+        self.columns()
+            .iter()
+            .zip(fields)
+            .map(|(a, f)| {
+                let format = make_formatter(a.as_ref(), options)?;
+                Ok((f.name().as_str(), format))
+            })
+            .collect()
+    }
+
+    fn write(&self, s: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let mut iter = s.iter();
+        f.write_char('{')?;
+        if let Some((name, display)) = iter.next() {
+            write!(f, "{name}: ")?;
+            display.as_ref().write(idx, f)?;
+        }
+        for (name, display) in iter {
+            write!(f, ", {name}: ")?;
+            display.as_ref().write(idx, f)?;
+        }
+        f.write_char('}')?;
+        Ok(())
+    }
+}
+
+impl<'a> DisplayIndexState<'a> for &'a MapArray {
+    type State = (Box<dyn DisplayIndex + 'a>, Box<dyn DisplayIndex + 'a>);
+
+    fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+        let keys = make_formatter(self.keys().as_ref(), options)?;
+        let values = make_formatter(self.values().as_ref(), options)?;
+        Ok((keys, values))
+    }
+
+    fn write(&self, s: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let offsets = self.value_offsets();
+        let end = offsets[idx + 1].as_usize();
+        let start = offsets[idx].as_usize();
+        let mut iter = start..end;
+
+        f.write_char('{')?;
+        if let Some(idx) = iter.next() {
+            s.0.write(idx, f)?;
+            write!(f, ": ")?;
+            s.1.write(idx, f)?;
+        }
+
+        for idx in iter {
+            write!(f, ", ")?;
+            s.0.write(idx, f)?;
+            write!(f, ": ")?;
+            s.1.write(idx, f)?;
+        }
+
+        f.write_char('}')?;
+        Ok(())
+    }
+}
+
+impl<'a> DisplayIndexState<'a> for &'a UnionArray {
+    type State = (
+        Vec<Option<(&'a str, Box<dyn DisplayIndex + 'a>)>>,
+        UnionMode,
+    );
+
+    fn prepare(&self, options: &FormatOptions<'a>) -> Result<Self::State, ArrowError> {
+        let (fields, mode) = match (*self).data_type() {
+            DataType::Union(fields, mode) => (fields, mode),
+            _ => unreachable!(),
+        };
+
+        let max_id = fields.iter().map(|(id, _)| id).max().unwrap_or_default() as usize;
+        let mut out: Vec<Option<FieldDisplay>> = (0..max_id + 1).map(|_| None).collect();
+        for (i, field) in fields.iter() {
+            let formatter = make_formatter(self.child(i).as_ref(), options)?;
+            out[i as usize] = Some((field.name().as_str(), formatter))
+        }
+        Ok((out, *mode))
+    }
+
+    fn write(&self, s: &Self::State, idx: usize, f: &mut dyn Write) -> FormatResult {
+        let id = self.type_id(idx);
+        let idx = match s.1 {
+            UnionMode::Dense => self.value_offset(idx),
+            UnionMode::Sparse => idx,
+        };
+        let (name, field) = s.0[id as usize].as_ref().unwrap();
+
+        write!(f, "{{{name}=")?;
+        field.write(idx, f)?;
+        f.write_char('}')?;
+        Ok(())
+    }
+}
+
+/// Get the value at the given row in an array as a String.
+///
+/// Note this function is quite inefficient and is unlikely to be
+/// suitable for converting large arrays or record batches.
+///
+/// Please see [`ArrayFormatter`] for a more performant interface
+pub fn array_value_to_string(column: &dyn Array, row: usize) -> Result<String, ArrowError> {
+    let options = FormatOptions::default().with_display_error(true);
+    let formatter = ArrayFormatter::try_new(column, &options)?;
+    Ok(formatter.value(row).to_string())
+}
+
+/// Converts numeric type to a `String`
+pub fn lexical_to_string<N: lexical_core::ToLexical>(n: N) -> String {
+    let mut buf = Vec::<u8>::with_capacity(N::FORMATTED_SIZE_DECIMAL);
+    unsafe {
+        // JUSTIFICATION
+        //  Benefit
+        //      Allows using the faster serializer lexical core and convert to string
+        //  Soundness
+        //      Length of buf is set as written length afterwards. lexical_core
+        //      creates a valid string, so doesn't need to be checked.
+        let slice = std::slice::from_raw_parts_mut(buf.as_mut_ptr(), buf.capacity());
+        let len = lexical_core::write(n, slice).len();
+        buf.set_len(len);
+        String::from_utf8_unchecked(buf)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow_array::builder::StringRunBuilder;
+
+    use super::*;
+
+    /// Test to verify options can be constant. See #4580
+    const TEST_CONST_OPTIONS: FormatOptions<'static> = FormatOptions::new()
+        .with_date_format(Some("foo"))
+        .with_timestamp_format(Some("404"));
+
+    #[test]
+    fn test_const_options() {
+        assert_eq!(TEST_CONST_OPTIONS.date_format, Some("foo"));
+    }
+
+    #[test]
+    fn test_map_array_to_string() {
+        let keys = vec!["a", "b", "c", "d", "e", "f", "g", "h"];
+        let values_data = UInt32Array::from(vec![0u32, 10, 20, 30, 40, 50, 60, 70]);
+
+        // Construct a buffer for value offsets, for the nested array:
+        //  [[a, b, c], [d, e, f], [g, h]]
+        let entry_offsets = [0, 3, 6, 8];
+
+        let map_array =
+            MapArray::new_from_strings(keys.clone().into_iter(), &values_data, &entry_offsets)
+                .unwrap();
+        assert_eq!(
+            "{d: 30, e: 40, f: 50}",
+            array_value_to_string(&map_array, 1).unwrap()
+        );
+    }
+
+    fn format_array(array: &dyn Array, fmt: &FormatOptions) -> Vec<String> {
+        let fmt = ArrayFormatter::try_new(array, fmt).unwrap();
+        (0..array.len()).map(|x| fmt.value(x).to_string()).collect()
+    }
+
+    #[test]
+    fn test_array_value_to_string_duration() {
+        let iso_fmt = FormatOptions::new();
+        let pretty_fmt = FormatOptions::new().with_duration_format(DurationFormat::Pretty);
+
+        let array = DurationNanosecondArray::from(vec![
+            1,
+            -1,
+            1000,
+            -1000,
+            (45 * 60 * 60 * 24 + 14 * 60 * 60 + 2 * 60 + 34) * 1_000_000_000 + 123456789,
+            -(45 * 60 * 60 * 24 + 14 * 60 * 60 + 2 * 60 + 34) * 1_000_000_000 - 123456789,
+        ]);
+        let iso = format_array(&array, &iso_fmt);
+        let pretty = format_array(&array, &pretty_fmt);
+
+        assert_eq!(iso[0], "PT0.000000001S");
+        assert_eq!(pretty[0], "0 days 0 hours 0 mins 0.000000001 secs");
+        assert_eq!(iso[1], "-PT0.000000001S");
+        assert_eq!(pretty[1], "0 days 0 hours 0 mins -0.000000001 secs");
+        assert_eq!(iso[2], "PT0.000001S");
+        assert_eq!(pretty[2], "0 days 0 hours 0 mins 0.000001000 secs");
+        assert_eq!(iso[3], "-PT0.000001S");
+        assert_eq!(pretty[3], "0 days 0 hours 0 mins -0.000001000 secs");
+        assert_eq!(iso[4], "PT3938554.123456789S");
+        assert_eq!(pretty[4], "45 days 14 hours 2 mins 34.123456789 secs");
+        assert_eq!(iso[5], "-PT3938554.123456789S");
+        assert_eq!(pretty[5], "-45 days -14 hours -2 mins -34.123456789 secs");
+
+        let array = DurationMicrosecondArray::from(vec![
+            1,
+            -1,
+            1000,
+            -1000,
+            (45 * 60 * 60 * 24 + 14 * 60 * 60 + 2 * 60 + 34) * 1_000_000 + 123456,
+            -(45 * 60 * 60 * 24 + 14 * 60 * 60 + 2 * 60 + 34) * 1_000_000 - 123456,
+        ]);
+        let iso = format_array(&array, &iso_fmt);
+        let pretty = format_array(&array, &pretty_fmt);
+
+        assert_eq!(iso[0], "PT0.000001S");
+        assert_eq!(pretty[0], "0 days 0 hours 0 mins 0.000001 secs");
+        assert_eq!(iso[1], "-PT0.000001S");
+        assert_eq!(pretty[1], "0 days 0 hours 0 mins -0.000001 secs");
+        assert_eq!(iso[2], "PT0.001S");
+        assert_eq!(pretty[2], "0 days 0 hours 0 mins 0.001000 secs");
+        assert_eq!(iso[3], "-PT0.001S");
+        assert_eq!(pretty[3], "0 days 0 hours 0 mins -0.001000 secs");
+        assert_eq!(iso[4], "PT3938554.123456S");
+        assert_eq!(pretty[4], "45 days 14 hours 2 mins 34.123456 secs");
+        assert_eq!(iso[5], "-PT3938554.123456S");
+        assert_eq!(pretty[5], "-45 days -14 hours -2 mins -34.123456 secs");
+
+        let array = DurationMillisecondArray::from(vec![
+            1,
+            -1,
+            1000,
+            -1000,
+            (45 * 60 * 60 * 24 + 14 * 60 * 60 + 2 * 60 + 34) * 1_000 + 123,
+            -(45 * 60 * 60 * 24 + 14 * 60 * 60 + 2 * 60 + 34) * 1_000 - 123,
+        ]);
+        let iso = format_array(&array, &iso_fmt);
+        let pretty = format_array(&array, &pretty_fmt);
+
+        assert_eq!(iso[0], "PT0.001S");
+        assert_eq!(pretty[0], "0 days 0 hours 0 mins 0.001 secs");
+        assert_eq!(iso[1], "-PT0.001S");
+        assert_eq!(pretty[1], "0 days 0 hours 0 mins -0.001 secs");
+        assert_eq!(iso[2], "PT1S");
+        assert_eq!(pretty[2], "0 days 0 hours 0 mins 1.000 secs");
+        assert_eq!(iso[3], "-PT1S");
+        assert_eq!(pretty[3], "0 days 0 hours 0 mins -1.000 secs");
+        assert_eq!(iso[4], "PT3938554.123S");
+        assert_eq!(pretty[4], "45 days 14 hours 2 mins 34.123 secs");
+        assert_eq!(iso[5], "-PT3938554.123S");
+        assert_eq!(pretty[5], "-45 days -14 hours -2 mins -34.123 secs");
+
+        let array = DurationSecondArray::from(vec![
+            1,
+            -1,
+            1000,
+            -1000,
+            45 * 60 * 60 * 24 + 14 * 60 * 60 + 2 * 60 + 34,
+            -45 * 60 * 60 * 24 - 14 * 60 * 60 - 2 * 60 - 34,
+        ]);
+        let iso = format_array(&array, &iso_fmt);
+        let pretty = format_array(&array, &pretty_fmt);
+
+        assert_eq!(iso[0], "PT1S");
+        assert_eq!(pretty[0], "0 days 0 hours 0 mins 1 secs");
+        assert_eq!(iso[1], "-PT1S");
+        assert_eq!(pretty[1], "0 days 0 hours 0 mins -1 secs");
+        assert_eq!(iso[2], "PT1000S");
+        assert_eq!(pretty[2], "0 days 0 hours 16 mins 40 secs");
+        assert_eq!(iso[3], "-PT1000S");
+        assert_eq!(pretty[3], "0 days 0 hours -16 mins -40 secs");
+        assert_eq!(iso[4], "PT3938554S");
+        assert_eq!(pretty[4], "45 days 14 hours 2 mins 34 secs");
+        assert_eq!(iso[5], "-PT3938554S");
+        assert_eq!(pretty[5], "-45 days -14 hours -2 mins -34 secs");
+    }
+
+    #[test]
+    fn test_null() {
+        let array = NullArray::new(2);
+        let options = FormatOptions::new().with_null("NULL");
+        let formatted = format_array(&array, &options);
+        assert_eq!(formatted, &["NULL".to_string(), "NULL".to_string()])
+    }
+
+    #[test]
+    fn test_string_run_arry_to_string() {
+        let mut builder = StringRunBuilder::<Int32Type>::new();
+
+        builder.append_value("input_value");
+        builder.append_value("input_value");
+        builder.append_value("input_value");
+        builder.append_value("input_value1");
+
+        let map_array = builder.finish();
+        assert_eq!("input_value", array_value_to_string(&map_array, 1).unwrap());
+        assert_eq!(
+            "input_value1",
+            array_value_to_string(&map_array, 3).unwrap()
+        );
+    }
+}
diff --git a/arrow-cast/src/lib.rs b/arrow-cast/src/lib.rs
new file mode 100644
index 000000000000..71ebe6c0ed8b
--- /dev/null
+++ b/arrow-cast/src/lib.rs
@@ -0,0 +1,27 @@
+// 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.
+
+//! Cast kernel for [Apache Arrow](https://docs.rs/arrow)
+
+pub mod cast;
+pub use cast::*;
+pub mod display;
+pub mod parse;
+#[cfg(feature = "prettyprint")]
+pub mod pretty;
+
+pub mod base64;
diff --git a/arrow-cast/src/parse.rs b/arrow-cast/src/parse.rs
new file mode 100644
index 000000000000..72942af8394a
--- /dev/null
+++ b/arrow-cast/src/parse.rs
@@ -0,0 +1,2304 @@
+// 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.
+
+use arrow_array::timezone::Tz;
+use arrow_array::types::*;
+use arrow_array::{ArrowNativeTypeOp, ArrowPrimitiveType};
+use arrow_buffer::ArrowNativeType;
+use arrow_schema::ArrowError;
+use chrono::prelude::*;
+use half::f16;
+use std::str::FromStr;
+
+/// Parse nanoseconds from the first `N` values in digits, subtracting the offset `O`
+#[inline]
+fn parse_nanos<const N: usize, const O: u8>(digits: &[u8]) -> u32 {
+    digits[..N]
+        .iter()
+        .fold(0_u32, |acc, v| acc * 10 + v.wrapping_sub(O) as u32)
+        * 10_u32.pow((9 - N) as _)
+}
+
+/// Helper for parsing RFC3339 timestamps
+struct TimestampParser {
+    /// The timestamp bytes to parse minus `b'0'`
+    ///
+    /// This makes interpretation as an integer inexpensive
+    digits: [u8; 32],
+    /// A mask containing a `1` bit where the corresponding byte is a valid ASCII digit
+    mask: u32,
+}
+
+impl TimestampParser {
+    fn new(bytes: &[u8]) -> Self {
+        let mut digits = [0; 32];
+        let mut mask = 0;
+
+        // Treating all bytes the same way, helps LLVM vectorise this correctly
+        for (idx, (o, i)) in digits.iter_mut().zip(bytes).enumerate() {
+            *o = i.wrapping_sub(b'0');
+            mask |= ((*o < 10) as u32) << idx
+        }
+
+        Self { digits, mask }
+    }
+
+    /// Returns true if the byte at `idx` in the original string equals `b`
+    fn test(&self, idx: usize, b: u8) -> bool {
+        self.digits[idx] == b.wrapping_sub(b'0')
+    }
+
+    /// Parses a date of the form `1997-01-31`
+    fn date(&self) -> Option<NaiveDate> {
+        if self.mask & 0b1111111111 != 0b1101101111 || !self.test(4, b'-') || !self.test(7, b'-') {
+            return None;
+        }
+
+        let year = self.digits[0] as u16 * 1000
+            + self.digits[1] as u16 * 100
+            + self.digits[2] as u16 * 10
+            + self.digits[3] as u16;
+
+        let month = self.digits[5] * 10 + self.digits[6];
+        let day = self.digits[8] * 10 + self.digits[9];
+
+        NaiveDate::from_ymd_opt(year as _, month as _, day as _)
+    }
+
+    /// Parses a time of any of forms
+    /// - `09:26:56`
+    /// - `09:26:56.123`
+    /// - `09:26:56.123456`
+    /// - `09:26:56.123456789`
+    /// - `092656`
+    ///
+    /// Returning the end byte offset
+    fn time(&self) -> Option<(NaiveTime, usize)> {
+        // Make a NaiveTime handling leap seconds
+        let time = |hour, min, sec, nano| match sec {
+            60 => {
+                let nano = 1_000_000_000 + nano;
+                NaiveTime::from_hms_nano_opt(hour as _, min as _, 59, nano)
+            }
+            _ => NaiveTime::from_hms_nano_opt(hour as _, min as _, sec as _, nano),
+        };
+
+        match (self.mask >> 11) & 0b11111111 {
+            // 09:26:56
+            0b11011011 if self.test(13, b':') && self.test(16, b':') => {
+                let hour = self.digits[11] * 10 + self.digits[12];
+                let minute = self.digits[14] * 10 + self.digits[15];
+                let second = self.digits[17] * 10 + self.digits[18];
+
+                match self.test(19, b'.') {
+                    true => {
+                        let digits = (self.mask >> 20).trailing_ones();
+                        let nanos = match digits {
+                            0 => return None,
+                            1 => parse_nanos::<1, 0>(&self.digits[20..21]),
+                            2 => parse_nanos::<2, 0>(&self.digits[20..22]),
+                            3 => parse_nanos::<3, 0>(&self.digits[20..23]),
+                            4 => parse_nanos::<4, 0>(&self.digits[20..24]),
+                            5 => parse_nanos::<5, 0>(&self.digits[20..25]),
+                            6 => parse_nanos::<6, 0>(&self.digits[20..26]),
+                            7 => parse_nanos::<7, 0>(&self.digits[20..27]),
+                            8 => parse_nanos::<8, 0>(&self.digits[20..28]),
+                            _ => parse_nanos::<9, 0>(&self.digits[20..29]),
+                        };
+                        Some((time(hour, minute, second, nanos)?, 20 + digits as usize))
+                    }
+                    false => Some((time(hour, minute, second, 0)?, 19)),
+                }
+            }
+            // 092656
+            0b111111 => {
+                let hour = self.digits[11] * 10 + self.digits[12];
+                let minute = self.digits[13] * 10 + self.digits[14];
+                let second = self.digits[15] * 10 + self.digits[16];
+                let time = time(hour, minute, second, 0)?;
+                Some((time, 17))
+            }
+            _ => None,
+        }
+    }
+}
+
+/// Accepts a string and parses it relative to the provided `timezone`
+///
+/// In addition to RFC3339 / ISO8601 standard timestamps, it also
+/// accepts strings that use a space ` ` to separate the date and time
+/// as well as strings that have no explicit timezone offset.
+///
+/// Examples of accepted inputs:
+/// * `1997-01-31T09:26:56.123Z`        # RCF3339
+/// * `1997-01-31T09:26:56.123-05:00`   # RCF3339
+/// * `1997-01-31 09:26:56.123-05:00`   # close to RCF3339 but with a space rather than T
+/// * `2023-01-01 04:05:06.789 -08`     # close to RCF3339, no fractional seconds or time separator
+/// * `1997-01-31T09:26:56.123`         # close to RCF3339 but no timezone offset specified
+/// * `1997-01-31 09:26:56.123`         # close to RCF3339 but uses a space and no timezone offset
+/// * `1997-01-31 09:26:56`             # close to RCF3339, no fractional seconds
+/// * `1997-01-31 092656`               # close to RCF3339, no fractional seconds
+/// * `1997-01-31 092656+04:00`         # close to RCF3339, no fractional seconds or time separator
+/// * `1997-01-31`                      # close to RCF3339, only date no time
+///
+/// [IANA timezones] are only supported if the `arrow-array/chrono-tz` feature is enabled
+///
+/// * `2023-01-01 040506 America/Los_Angeles`
+///
+/// If a timestamp is ambiguous, for example as a result of daylight-savings time, an error
+/// will be returned
+///
+/// Some formats supported by PostgresSql <https://www.postgresql.org/docs/current/datatype-datetime.html#DATATYPE-DATETIME-TIME-TABLE>
+/// are not supported, like
+///
+/// * "2023-01-01 04:05:06.789 +07:30:00",
+/// * "2023-01-01 040506 +07:30:00",
+/// * "2023-01-01 04:05:06.789 PST",
+///
+/// [IANA timezones]: https://www.iana.org/time-zones
+pub fn string_to_datetime<T: TimeZone>(timezone: &T, s: &str) -> Result<DateTime<T>, ArrowError> {
+    let err =
+        |ctx: &str| ArrowError::ParseError(format!("Error parsing timestamp from '{s}': {ctx}"));
+
+    let bytes = s.as_bytes();
+    if bytes.len() < 10 {
+        return Err(err("timestamp must contain at least 10 characters"));
+    }
+
+    let parser = TimestampParser::new(bytes);
+    let date = parser.date().ok_or_else(|| err("error parsing date"))?;
+    if bytes.len() == 10 {
+        let datetime = date.and_time(NaiveTime::from_hms_opt(0, 0, 0).unwrap());
+        return timezone
+            .from_local_datetime(&datetime)
+            .single()
+            .ok_or_else(|| err("error computing timezone offset"));
+    }
+
+    if !parser.test(10, b'T') && !parser.test(10, b't') && !parser.test(10, b' ') {
+        return Err(err("invalid timestamp separator"));
+    }
+
+    let (time, mut tz_offset) = parser.time().ok_or_else(|| err("error parsing time"))?;
+    let datetime = date.and_time(time);
+
+    if tz_offset == 32 {
+        // Decimal overrun
+        while tz_offset < bytes.len() && bytes[tz_offset].is_ascii_digit() {
+            tz_offset += 1;
+        }
+    }
+
+    if bytes.len() <= tz_offset {
+        return timezone
+            .from_local_datetime(&datetime)
+            .single()
+            .ok_or_else(|| err("error computing timezone offset"));
+    }
+
+    if (bytes[tz_offset] == b'z' || bytes[tz_offset] == b'Z') && tz_offset == bytes.len() - 1 {
+        return Ok(timezone.from_utc_datetime(&datetime));
+    }
+
+    // Parse remainder of string as timezone
+    let parsed_tz: Tz = s[tz_offset..].trim_start().parse()?;
+    let parsed = parsed_tz
+        .from_local_datetime(&datetime)
+        .single()
+        .ok_or_else(|| err("error computing timezone offset"))?;
+
+    Ok(parsed.with_timezone(timezone))
+}
+
+/// Accepts a string in RFC3339 / ISO8601 standard format and some
+/// variants and converts it to a nanosecond precision timestamp.
+///
+/// See [`string_to_datetime`] for the full set of supported formats
+///
+/// Implements the `to_timestamp` function to convert a string to a
+/// timestamp, following the model of spark SQL’s to_`timestamp`.
+///
+/// Internally, this function uses the `chrono` library for the
+/// datetime parsing
+///
+/// We hope to extend this function in the future with a second
+/// parameter to specifying the format string.
+///
+/// ## Timestamp Precision
+///
+/// Function uses the maximum precision timestamps supported by
+/// Arrow (nanoseconds stored as a 64-bit integer) timestamps. This
+/// means the range of dates that timestamps can represent is ~1677 AD
+/// to 2262 AM
+///
+/// ## Timezone / Offset Handling
+///
+/// Numerical values of timestamps are stored compared to offset UTC.
+///
+/// This function interprets string without an explicit time zone as timestamps
+/// relative to UTC, see [`string_to_datetime`] for alternative semantics
+///
+/// In particular:
+///
+/// ```
+/// # use arrow_cast::parse::string_to_timestamp_nanos;
+/// // Note all three of these timestamps are parsed as the same value
+/// let a = string_to_timestamp_nanos("1997-01-31 09:26:56.123Z").unwrap();
+/// let b = string_to_timestamp_nanos("1997-01-31T09:26:56.123").unwrap();
+/// let c = string_to_timestamp_nanos("1997-01-31T14:26:56.123+05:00").unwrap();
+///
+/// assert_eq!(a, b);
+/// assert_eq!(b, c);
+/// ```
+///
+#[inline]
+pub fn string_to_timestamp_nanos(s: &str) -> Result<i64, ArrowError> {
+    to_timestamp_nanos(string_to_datetime(&Utc, s)?.naive_utc())
+}
+
+/// Fallible conversion of [`NaiveDateTime`] to `i64` nanoseconds
+#[inline]
+fn to_timestamp_nanos(dt: NaiveDateTime) -> Result<i64, ArrowError> {
+    dt.timestamp_nanos_opt()
+        .ok_or_else(|| ArrowError::ParseError(ERR_NANOSECONDS_NOT_SUPPORTED.to_string()))
+}
+
+/// Accepts a string in ISO8601 standard format and some
+/// variants and converts it to nanoseconds since midnight.
+///
+/// Examples of accepted inputs:
+/// * `09:26:56.123 AM`
+/// * `23:59:59`
+/// * `6:00 pm`
+//
+/// Internally, this function uses the `chrono` library for the
+/// time parsing
+///
+/// ## Timezone / Offset Handling
+///
+/// This function does not support parsing strings with a timezone
+/// or offset specified, as it considers only time since midnight.
+pub fn string_to_time_nanoseconds(s: &str) -> Result<i64, ArrowError> {
+    let nt = string_to_time(s)
+        .ok_or_else(|| ArrowError::ParseError(format!("Failed to parse \'{s}\' as time")))?;
+    Ok(nt.num_seconds_from_midnight() as i64 * 1_000_000_000 + nt.nanosecond() as i64)
+}
+
+fn string_to_time(s: &str) -> Option<NaiveTime> {
+    let bytes = s.as_bytes();
+    if bytes.len() < 4 {
+        return None;
+    }
+
+    let (am, bytes) = match bytes.get(bytes.len() - 3..) {
+        Some(b" AM" | b" am" | b" Am" | b" aM") => (Some(true), &bytes[..bytes.len() - 3]),
+        Some(b" PM" | b" pm" | b" pM" | b" Pm") => (Some(false), &bytes[..bytes.len() - 3]),
+        _ => (None, bytes),
+    };
+
+    if bytes.len() < 4 {
+        return None;
+    }
+
+    let mut digits = [b'0'; 6];
+
+    // Extract hour
+    let bytes = match (bytes[1], bytes[2]) {
+        (b':', _) => {
+            digits[1] = bytes[0];
+            &bytes[2..]
+        }
+        (_, b':') => {
+            digits[0] = bytes[0];
+            digits[1] = bytes[1];
+            &bytes[3..]
+        }
+        _ => return None,
+    };
+
+    if bytes.len() < 2 {
+        return None; // Minutes required
+    }
+
+    // Extract minutes
+    digits[2] = bytes[0];
+    digits[3] = bytes[1];
+
+    let nanoseconds = match bytes.get(2) {
+        Some(b':') => {
+            if bytes.len() < 5 {
+                return None;
+            }
+
+            // Extract seconds
+            digits[4] = bytes[3];
+            digits[5] = bytes[4];
+
+            // Extract sub-seconds if any
+            match bytes.get(5) {
+                Some(b'.') => {
+                    let decimal = &bytes[6..];
+                    if decimal.iter().any(|x| !x.is_ascii_digit()) {
+                        return None;
+                    }
+                    match decimal.len() {
+                        0 => return None,
+                        1 => parse_nanos::<1, b'0'>(decimal),
+                        2 => parse_nanos::<2, b'0'>(decimal),
+                        3 => parse_nanos::<3, b'0'>(decimal),
+                        4 => parse_nanos::<4, b'0'>(decimal),
+                        5 => parse_nanos::<5, b'0'>(decimal),
+                        6 => parse_nanos::<6, b'0'>(decimal),
+                        7 => parse_nanos::<7, b'0'>(decimal),
+                        8 => parse_nanos::<8, b'0'>(decimal),
+                        _ => parse_nanos::<9, b'0'>(decimal),
+                    }
+                }
+                Some(_) => return None,
+                None => 0,
+            }
+        }
+        Some(_) => return None,
+        None => 0,
+    };
+
+    digits.iter_mut().for_each(|x| *x = x.wrapping_sub(b'0'));
+    if digits.iter().any(|x| *x > 9) {
+        return None;
+    }
+
+    let hour = match (digits[0] * 10 + digits[1], am) {
+        (12, Some(true)) => 0,               // 12:00 AM -> 00:00
+        (h @ 1..=11, Some(true)) => h,       // 1:00 AM -> 01:00
+        (12, Some(false)) => 12,             // 12:00 PM -> 12:00
+        (h @ 1..=11, Some(false)) => h + 12, // 1:00 PM -> 13:00
+        (_, Some(_)) => return None,
+        (h, None) => h,
+    };
+
+    // Handle leap second
+    let (second, nanoseconds) = match digits[4] * 10 + digits[5] {
+        60 => (59, nanoseconds + 1_000_000_000),
+        s => (s, nanoseconds),
+    };
+
+    NaiveTime::from_hms_nano_opt(
+        hour as _,
+        (digits[2] * 10 + digits[3]) as _,
+        second as _,
+        nanoseconds,
+    )
+}
+
+/// Specialized parsing implementations
+/// used by csv and json reader
+pub trait Parser: ArrowPrimitiveType {
+    fn parse(string: &str) -> Option<Self::Native>;
+
+    fn parse_formatted(string: &str, _format: &str) -> Option<Self::Native> {
+        Self::parse(string)
+    }
+}
+
+impl Parser for Float16Type {
+    fn parse(string: &str) -> Option<f16> {
+        lexical_core::parse(string.as_bytes())
+            .ok()
+            .map(f16::from_f32)
+    }
+}
+
+impl Parser for Float32Type {
+    fn parse(string: &str) -> Option<f32> {
+        lexical_core::parse(string.as_bytes()).ok()
+    }
+}
+
+impl Parser for Float64Type {
+    fn parse(string: &str) -> Option<f64> {
+        lexical_core::parse(string.as_bytes()).ok()
+    }
+}
+
+macro_rules! parser_primitive {
+    ($t:ty) => {
+        impl Parser for $t {
+            fn parse(string: &str) -> Option<Self::Native> {
+                match atoi::FromRadix10SignedChecked::from_radix_10_signed_checked(
+                    string.as_bytes(),
+                ) {
+                    (Some(n), x) if x == string.len() => Some(n),
+                    _ => None,
+                }
+            }
+        }
+    };
+}
+parser_primitive!(UInt64Type);
+parser_primitive!(UInt32Type);
+parser_primitive!(UInt16Type);
+parser_primitive!(UInt8Type);
+parser_primitive!(Int64Type);
+parser_primitive!(Int32Type);
+parser_primitive!(Int16Type);
+parser_primitive!(Int8Type);
+
+impl Parser for TimestampNanosecondType {
+    fn parse(string: &str) -> Option<i64> {
+        string_to_timestamp_nanos(string).ok()
+    }
+}
+
+impl Parser for TimestampMicrosecondType {
+    fn parse(string: &str) -> Option<i64> {
+        let nanos = string_to_timestamp_nanos(string).ok();
+        nanos.map(|x| x / 1000)
+    }
+}
+
+impl Parser for TimestampMillisecondType {
+    fn parse(string: &str) -> Option<i64> {
+        let nanos = string_to_timestamp_nanos(string).ok();
+        nanos.map(|x| x / 1_000_000)
+    }
+}
+
+impl Parser for TimestampSecondType {
+    fn parse(string: &str) -> Option<i64> {
+        let nanos = string_to_timestamp_nanos(string).ok();
+        nanos.map(|x| x / 1_000_000_000)
+    }
+}
+
+impl Parser for Time64NanosecondType {
+    // Will truncate any fractions of a nanosecond
+    fn parse(string: &str) -> Option<Self::Native> {
+        string_to_time_nanoseconds(string)
+            .ok()
+            .or_else(|| string.parse::<Self::Native>().ok())
+    }
+
+    fn parse_formatted(string: &str, format: &str) -> Option<Self::Native> {
+        let nt = NaiveTime::parse_from_str(string, format).ok()?;
+        Some(nt.num_seconds_from_midnight() as i64 * 1_000_000_000 + nt.nanosecond() as i64)
+    }
+}
+
+impl Parser for Time64MicrosecondType {
+    // Will truncate any fractions of a microsecond
+    fn parse(string: &str) -> Option<Self::Native> {
+        string_to_time_nanoseconds(string)
+            .ok()
+            .map(|nanos| nanos / 1_000)
+            .or_else(|| string.parse::<Self::Native>().ok())
+    }
+
+    fn parse_formatted(string: &str, format: &str) -> Option<Self::Native> {
+        let nt = NaiveTime::parse_from_str(string, format).ok()?;
+        Some(nt.num_seconds_from_midnight() as i64 * 1_000_000 + nt.nanosecond() as i64 / 1_000)
+    }
+}
+
+impl Parser for Time32MillisecondType {
+    // Will truncate any fractions of a millisecond
+    fn parse(string: &str) -> Option<Self::Native> {
+        string_to_time_nanoseconds(string)
+            .ok()
+            .map(|nanos| (nanos / 1_000_000) as i32)
+            .or_else(|| string.parse::<Self::Native>().ok())
+    }
+
+    fn parse_formatted(string: &str, format: &str) -> Option<Self::Native> {
+        let nt = NaiveTime::parse_from_str(string, format).ok()?;
+        Some(nt.num_seconds_from_midnight() as i32 * 1_000 + nt.nanosecond() as i32 / 1_000_000)
+    }
+}
+
+impl Parser for Time32SecondType {
+    // Will truncate any fractions of a second
+    fn parse(string: &str) -> Option<Self::Native> {
+        string_to_time_nanoseconds(string)
+            .ok()
+            .map(|nanos| (nanos / 1_000_000_000) as i32)
+            .or_else(|| string.parse::<Self::Native>().ok())
+    }
+
+    fn parse_formatted(string: &str, format: &str) -> Option<Self::Native> {
+        let nt = NaiveTime::parse_from_str(string, format).ok()?;
+        Some(nt.num_seconds_from_midnight() as i32 + nt.nanosecond() as i32 / 1_000_000_000)
+    }
+}
+
+/// Number of days between 0001-01-01 and 1970-01-01
+const EPOCH_DAYS_FROM_CE: i32 = 719_163;
+
+/// Error message if nanosecond conversion request beyond supported interval
+const ERR_NANOSECONDS_NOT_SUPPORTED: &str = "The dates that can be represented as nanoseconds have to be between 1677-09-21T00:12:44.0 and 2262-04-11T23:47:16.854775804";
+
+fn parse_date(string: &str) -> Option<NaiveDate> {
+    if string.len() > 10 {
+        // Try to parse as datetime and return just the date part
+        return string_to_datetime(&Utc, string)
+            .map(|dt| dt.date_naive())
+            .ok();
+    };
+    let mut digits = [0; 10];
+    let mut mask = 0;
+
+    // Treating all bytes the same way, helps LLVM vectorise this correctly
+    for (idx, (o, i)) in digits.iter_mut().zip(string.bytes()).enumerate() {
+        *o = i.wrapping_sub(b'0');
+        mask |= ((*o < 10) as u16) << idx
+    }
+
+    const HYPHEN: u8 = b'-'.wrapping_sub(b'0');
+
+    //  refer to https://www.rfc-editor.org/rfc/rfc3339#section-3
+    if digits[4] != HYPHEN {
+        let (year, month, day) = match (mask, string.len()) {
+            (0b11111111, 8) => (
+                digits[0] as u16 * 1000
+                    + digits[1] as u16 * 100
+                    + digits[2] as u16 * 10
+                    + digits[3] as u16,
+                digits[4] * 10 + digits[5],
+                digits[6] * 10 + digits[7],
+            ),
+            _ => return None,
+        };
+        return NaiveDate::from_ymd_opt(year as _, month as _, day as _);
+    }
+
+    let (month, day) = match mask {
+        0b1101101111 => {
+            if digits[7] != HYPHEN {
+                return None;
+            }
+            (digits[5] * 10 + digits[6], digits[8] * 10 + digits[9])
+        }
+        0b101101111 => {
+            if digits[7] != HYPHEN {
+                return None;
+            }
+            (digits[5] * 10 + digits[6], digits[8])
+        }
+        0b110101111 => {
+            if digits[6] != HYPHEN {
+                return None;
+            }
+            (digits[5], digits[7] * 10 + digits[8])
+        }
+        0b10101111 => {
+            if digits[6] != HYPHEN {
+                return None;
+            }
+            (digits[5], digits[7])
+        }
+        _ => return None,
+    };
+
+    let year =
+        digits[0] as u16 * 1000 + digits[1] as u16 * 100 + digits[2] as u16 * 10 + digits[3] as u16;
+
+    NaiveDate::from_ymd_opt(year as _, month as _, day as _)
+}
+
+impl Parser for Date32Type {
+    fn parse(string: &str) -> Option<i32> {
+        let date = parse_date(string)?;
+        Some(date.num_days_from_ce() - EPOCH_DAYS_FROM_CE)
+    }
+
+    fn parse_formatted(string: &str, format: &str) -> Option<i32> {
+        let date = NaiveDate::parse_from_str(string, format).ok()?;
+        Some(date.num_days_from_ce() - EPOCH_DAYS_FROM_CE)
+    }
+}
+
+impl Parser for Date64Type {
+    fn parse(string: &str) -> Option<i64> {
+        if string.len() <= 10 {
+            let date = parse_date(string)?;
+            Some(NaiveDateTime::new(date, NaiveTime::default()).timestamp_millis())
+        } else {
+            let date_time = string_to_datetime(&Utc, string).ok()?;
+            Some(date_time.timestamp_millis())
+        }
+    }
+
+    fn parse_formatted(string: &str, format: &str) -> Option<i64> {
+        use chrono::format::Fixed;
+        use chrono::format::StrftimeItems;
+        let fmt = StrftimeItems::new(format);
+        let has_zone = fmt.into_iter().any(|item| match item {
+            chrono::format::Item::Fixed(fixed_item) => matches!(
+                fixed_item,
+                Fixed::RFC2822
+                    | Fixed::RFC3339
+                    | Fixed::TimezoneName
+                    | Fixed::TimezoneOffsetColon
+                    | Fixed::TimezoneOffsetColonZ
+                    | Fixed::TimezoneOffset
+                    | Fixed::TimezoneOffsetZ
+            ),
+            _ => false,
+        });
+        if has_zone {
+            let date_time = chrono::DateTime::parse_from_str(string, format).ok()?;
+            Some(date_time.timestamp_millis())
+        } else {
+            let date_time = NaiveDateTime::parse_from_str(string, format).ok()?;
+            Some(date_time.timestamp_millis())
+        }
+    }
+}
+
+/// Parse the string format decimal value to i128/i256 format and checking the precision and scale.
+/// The result value can't be out of bounds.
+pub fn parse_decimal<T: DecimalType>(
+    s: &str,
+    precision: u8,
+    scale: i8,
+) -> Result<T::Native, ArrowError> {
+    let mut result = T::Native::usize_as(0);
+    let mut fractionals = 0;
+    let mut digits = 0;
+    let base = T::Native::usize_as(10);
+
+    let bs = s.as_bytes();
+    let (bs, negative) = match bs.first() {
+        Some(b'-') => (&bs[1..], true),
+        Some(b'+') => (&bs[1..], false),
+        _ => (bs, false),
+    };
+
+    if bs.is_empty() {
+        return Err(ArrowError::ParseError(format!(
+            "can't parse the string value {s} to decimal"
+        )));
+    }
+
+    let mut bs = bs.iter();
+    // Overflow checks are not required if 10^(precision - 1) <= T::MAX holds.
+    // Thus, if we validate the precision correctly, we can skip overflow checks.
+    while let Some(b) = bs.next() {
+        match b {
+            b'0'..=b'9' => {
+                if digits == 0 && *b == b'0' {
+                    // Ignore leading zeros.
+                    continue;
+                }
+                digits += 1;
+                result = result.mul_wrapping(base);
+                result = result.add_wrapping(T::Native::usize_as((b - b'0') as usize));
+            }
+            b'.' => {
+                for b in bs.by_ref() {
+                    if !b.is_ascii_digit() {
+                        return Err(ArrowError::ParseError(format!(
+                            "can't parse the string value {s} to decimal"
+                        )));
+                    }
+                    if fractionals == scale {
+                        // We have processed all the digits that we need. All that
+                        // is left is to validate that the rest of the string contains
+                        // valid digits.
+                        continue;
+                    }
+                    fractionals += 1;
+                    digits += 1;
+                    result = result.mul_wrapping(base);
+                    result = result.add_wrapping(T::Native::usize_as((b - b'0') as usize));
+                }
+
+                // Fail on "."
+                if digits == 0 {
+                    return Err(ArrowError::ParseError(format!(
+                        "can't parse the string value {s} to decimal"
+                    )));
+                }
+            }
+            _ => {
+                return Err(ArrowError::ParseError(format!(
+                    "can't parse the string value {s} to decimal"
+                )));
+            }
+        }
+    }
+
+    if fractionals < scale {
+        let exp = scale - fractionals;
+        if exp as u8 + digits > precision {
+            return Err(ArrowError::ParseError("parse decimal overflow".to_string()));
+        }
+        let mul = base.pow_wrapping(exp as _);
+        result = result.mul_wrapping(mul);
+    } else if digits > precision {
+        return Err(ArrowError::ParseError("parse decimal overflow".to_string()));
+    }
+
+    Ok(if negative {
+        result.neg_wrapping()
+    } else {
+        result
+    })
+}
+
+pub fn parse_interval_year_month(
+    value: &str,
+) -> Result<<IntervalYearMonthType as ArrowPrimitiveType>::Native, ArrowError> {
+    let config = IntervalParseConfig::new(IntervalUnit::Year);
+    let interval = Interval::parse(value, &config)?;
+
+    let months = interval.to_year_months().map_err(|_| {
+        ArrowError::CastError(format!(
+            "Cannot cast {value} to IntervalYearMonth. Only year and month fields are allowed."
+        ))
+    })?;
+
+    Ok(IntervalYearMonthType::make_value(0, months))
+}
+
+pub fn parse_interval_day_time(
+    value: &str,
+) -> Result<<IntervalDayTimeType as ArrowPrimitiveType>::Native, ArrowError> {
+    let config = IntervalParseConfig::new(IntervalUnit::Day);
+    let interval = Interval::parse(value, &config)?;
+
+    let (days, millis) = interval.to_day_time().map_err(|_| ArrowError::CastError(format!(
+        "Cannot cast {value} to IntervalDayTime because the nanos part isn't multiple of milliseconds"
+    )))?;
+
+    Ok(IntervalDayTimeType::make_value(days, millis))
+}
+
+pub fn parse_interval_month_day_nano(
+    value: &str,
+) -> Result<<IntervalMonthDayNanoType as ArrowPrimitiveType>::Native, ArrowError> {
+    let config = IntervalParseConfig::new(IntervalUnit::Month);
+    let interval = Interval::parse(value, &config)?;
+
+    let (months, days, nanos) = interval.to_month_day_nanos();
+
+    Ok(IntervalMonthDayNanoType::make_value(months, days, nanos))
+}
+
+const NANOS_PER_MILLIS: i64 = 1_000_000;
+const NANOS_PER_SECOND: i64 = 1_000 * NANOS_PER_MILLIS;
+const NANOS_PER_MINUTE: i64 = 60 * NANOS_PER_SECOND;
+const NANOS_PER_HOUR: i64 = 60 * NANOS_PER_MINUTE;
+#[cfg(test)]
+const NANOS_PER_DAY: i64 = 24 * NANOS_PER_HOUR;
+
+#[rustfmt::skip]
+#[derive(Clone, Copy)]
+#[repr(u16)]
+enum IntervalUnit {
+    Century     = 0b_0000_0000_0001,
+    Decade      = 0b_0000_0000_0010,
+    Year        = 0b_0000_0000_0100,
+    Month       = 0b_0000_0000_1000,
+    Week        = 0b_0000_0001_0000,
+    Day         = 0b_0000_0010_0000,
+    Hour        = 0b_0000_0100_0000,
+    Minute      = 0b_0000_1000_0000,
+    Second      = 0b_0001_0000_0000,
+    Millisecond = 0b_0010_0000_0000,
+    Microsecond = 0b_0100_0000_0000,
+    Nanosecond  = 0b_1000_0000_0000,
+}
+
+impl FromStr for IntervalUnit {
+    type Err = ArrowError;
+
+    fn from_str(s: &str) -> Result<Self, ArrowError> {
+        match s.to_lowercase().as_str() {
+            "century" | "centuries" => Ok(Self::Century),
+            "decade" | "decades" => Ok(Self::Decade),
+            "year" | "years" => Ok(Self::Year),
+            "month" | "months" => Ok(Self::Month),
+            "week" | "weeks" => Ok(Self::Week),
+            "day" | "days" => Ok(Self::Day),
+            "hour" | "hours" => Ok(Self::Hour),
+            "minute" | "minutes" => Ok(Self::Minute),
+            "second" | "seconds" => Ok(Self::Second),
+            "millisecond" | "milliseconds" => Ok(Self::Millisecond),
+            "microsecond" | "microseconds" => Ok(Self::Microsecond),
+            "nanosecond" | "nanoseconds" => Ok(Self::Nanosecond),
+            _ => Err(ArrowError::NotYetImplemented(format!(
+                "Unknown interval type: {s}"
+            ))),
+        }
+    }
+}
+
+pub type MonthDayNano = (i32, i32, i64);
+
+/// Chosen based on the number of decimal digits in 1 week in nanoseconds
+const INTERVAL_PRECISION: u32 = 15;
+
+#[derive(Clone, Copy, Debug, PartialEq)]
+struct IntervalAmount {
+    /// The integer component of the interval amount
+    integer: i64,
+    /// The fractional component multiplied by 10^INTERVAL_PRECISION
+    frac: i64,
+}
+
+#[cfg(test)]
+impl IntervalAmount {
+    fn new(integer: i64, frac: i64) -> Self {
+        Self { integer, frac }
+    }
+}
+
+impl FromStr for IntervalAmount {
+    type Err = ArrowError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.split_once('.') {
+            Some((integer, frac))
+                if frac.len() <= INTERVAL_PRECISION as usize
+                    && !frac.is_empty()
+                    && !frac.starts_with('-') =>
+            {
+                // integer will be "" for values like ".5"
+                // and "-" for values like "-.5"
+                let explicit_neg = integer.starts_with('-');
+                let integer = if integer.is_empty() || integer == "-" {
+                    Ok(0)
+                } else {
+                    integer.parse::<i64>().map_err(|_| {
+                        ArrowError::ParseError(format!("Failed to parse {s} as interval amount"))
+                    })
+                }?;
+
+                let frac_unscaled = frac.parse::<i64>().map_err(|_| {
+                    ArrowError::ParseError(format!("Failed to parse {s} as interval amount"))
+                })?;
+
+                // scale fractional part by interval precision
+                let frac = frac_unscaled * 10_i64.pow(INTERVAL_PRECISION - frac.len() as u32);
+
+                // propagate the sign of the integer part to the fractional part
+                let frac = if integer < 0 || explicit_neg {
+                    -frac
+                } else {
+                    frac
+                };
+
+                let result = Self { integer, frac };
+
+                Ok(result)
+            }
+            Some((_, frac)) if frac.starts_with('-') => Err(ArrowError::ParseError(format!(
+                "Failed to parse {s} as interval amount"
+            ))),
+            Some((_, frac)) if frac.len() > INTERVAL_PRECISION as usize => {
+                Err(ArrowError::ParseError(format!(
+                    "{s} exceeds the precision available for interval amount"
+                )))
+            }
+            Some(_) | None => {
+                let integer = s.parse::<i64>().map_err(|_| {
+                    ArrowError::ParseError(format!("Failed to parse {s} as interval amount"))
+                })?;
+
+                let result = Self { integer, frac: 0 };
+                Ok(result)
+            }
+        }
+    }
+}
+
+#[derive(Debug, Default, PartialEq)]
+struct Interval {
+    months: i32,
+    days: i32,
+    nanos: i64,
+}
+
+impl Interval {
+    fn new(months: i32, days: i32, nanos: i64) -> Self {
+        Self {
+            months,
+            days,
+            nanos,
+        }
+    }
+
+    fn to_year_months(&self) -> Result<i32, ArrowError> {
+        match (self.months, self.days, self.nanos) {
+            (months, days, nanos) if days == 0 && nanos == 0 => Ok(months),
+            _ => Err(ArrowError::InvalidArgumentError(format!(
+                "Unable to represent interval with days and nanos as year-months: {:?}",
+                self
+            ))),
+        }
+    }
+
+    fn to_day_time(&self) -> Result<(i32, i32), ArrowError> {
+        let days = self.months.mul_checked(30)?.add_checked(self.days)?;
+
+        match self.nanos {
+            nanos if nanos % NANOS_PER_MILLIS == 0 => {
+                let millis = (self.nanos / 1_000_000).try_into().map_err(|_| {
+                    ArrowError::InvalidArgumentError(format!(
+                        "Unable to represent {} nanos as milliseconds in a signed 32-bit integer",
+                        self.nanos
+                    ))
+                })?;
+
+                Ok((days, millis))
+            }
+            nanos => Err(ArrowError::InvalidArgumentError(format!(
+                "Unable to represent {nanos} as milliseconds"
+            ))),
+        }
+    }
+
+    fn to_month_day_nanos(&self) -> (i32, i32, i64) {
+        (self.months, self.days, self.nanos)
+    }
+
+    /// Parse string value in traditional Postgres format such as
+    /// `1 year 2 months 3 days 4 hours 5 minutes 6 seconds`
+    fn parse(value: &str, config: &IntervalParseConfig) -> Result<Self, ArrowError> {
+        let components = parse_interval_components(value, config)?;
+
+        components
+            .into_iter()
+            .try_fold(Self::default(), |result, (amount, unit)| {
+                result.add(amount, unit)
+            })
+    }
+
+    /// Interval addition following Postgres behavior. Fractional units will be spilled into smaller units.
+    /// When the interval unit is larger than months, the result is rounded to total months and not spilled to days/nanos.
+    /// Fractional parts of weeks and days are represented using days and nanoseconds.
+    /// e.g. INTERVAL '0.5 MONTH' = 15 days, INTERVAL '1.5 MONTH' = 1 month 15 days
+    /// e.g. INTERVAL '0.5 DAY' = 12 hours, INTERVAL '1.5 DAY' = 1 day 12 hours
+    /// [Postgres reference](https://www.postgresql.org/docs/15/datatype-datetime.html#DATATYPE-INTERVAL-INPUT:~:text=Field%20values%20can,fractional%20on%20output.)
+    fn add(&self, amount: IntervalAmount, unit: IntervalUnit) -> Result<Self, ArrowError> {
+        let result = match unit {
+            IntervalUnit::Century => {
+                let months_int = amount.integer.mul_checked(100)?.mul_checked(12)?;
+                let month_frac = amount.frac * 12 / 10_i64.pow(INTERVAL_PRECISION - 2);
+                let months = months_int
+                    .add_checked(month_frac)?
+                    .try_into()
+                    .map_err(|_| {
+                        ArrowError::ParseError(format!(
+                            "Unable to represent {} centuries as months in a signed 32-bit integer",
+                            &amount.integer
+                        ))
+                    })?;
+
+                Self::new(self.months.add_checked(months)?, self.days, self.nanos)
+            }
+            IntervalUnit::Decade => {
+                let months_int = amount.integer.mul_checked(10)?.mul_checked(12)?;
+
+                let month_frac = amount.frac * 12 / 10_i64.pow(INTERVAL_PRECISION - 1);
+                let months = months_int
+                    .add_checked(month_frac)?
+                    .try_into()
+                    .map_err(|_| {
+                        ArrowError::ParseError(format!(
+                            "Unable to represent {} decades as months in a signed 32-bit integer",
+                            &amount.integer
+                        ))
+                    })?;
+
+                Self::new(self.months.add_checked(months)?, self.days, self.nanos)
+            }
+            IntervalUnit::Year => {
+                let months_int = amount.integer.mul_checked(12)?;
+                let month_frac = amount.frac * 12 / 10_i64.pow(INTERVAL_PRECISION);
+                let months = months_int
+                    .add_checked(month_frac)?
+                    .try_into()
+                    .map_err(|_| {
+                        ArrowError::ParseError(format!(
+                            "Unable to represent {} years as months in a signed 32-bit integer",
+                            &amount.integer
+                        ))
+                    })?;
+
+                Self::new(self.months.add_checked(months)?, self.days, self.nanos)
+            }
+            IntervalUnit::Month => {
+                let months = amount.integer.try_into().map_err(|_| {
+                    ArrowError::ParseError(format!(
+                        "Unable to represent {} months in a signed 32-bit integer",
+                        &amount.integer
+                    ))
+                })?;
+
+                let days = amount.frac * 3 / 10_i64.pow(INTERVAL_PRECISION - 1);
+                let days = days.try_into().map_err(|_| {
+                    ArrowError::ParseError(format!(
+                        "Unable to represent {} months as days in a signed 32-bit integer",
+                        amount.frac / 10_i64.pow(INTERVAL_PRECISION)
+                    ))
+                })?;
+
+                Self::new(
+                    self.months.add_checked(months)?,
+                    self.days.add_checked(days)?,
+                    self.nanos,
+                )
+            }
+            IntervalUnit::Week => {
+                let days = amount.integer.mul_checked(7)?.try_into().map_err(|_| {
+                    ArrowError::ParseError(format!(
+                        "Unable to represent {} weeks as days in a signed 32-bit integer",
+                        &amount.integer
+                    ))
+                })?;
+
+                let nanos = amount.frac * 7 * 24 * 6 * 6 / 10_i64.pow(INTERVAL_PRECISION - 11);
+
+                Self::new(
+                    self.months,
+                    self.days.add_checked(days)?,
+                    self.nanos.add_checked(nanos)?,
+                )
+            }
+            IntervalUnit::Day => {
+                let days = amount.integer.try_into().map_err(|_| {
+                    ArrowError::InvalidArgumentError(format!(
+                        "Unable to represent {} days in a signed 32-bit integer",
+                        amount.integer
+                    ))
+                })?;
+
+                let nanos = amount.frac * 24 * 6 * 6 / 10_i64.pow(INTERVAL_PRECISION - 11);
+
+                Self::new(
+                    self.months,
+                    self.days.add_checked(days)?,
+                    self.nanos.add_checked(nanos)?,
+                )
+            }
+            IntervalUnit::Hour => {
+                let nanos_int = amount.integer.mul_checked(NANOS_PER_HOUR)?;
+                let nanos_frac = amount.frac * 6 * 6 / 10_i64.pow(INTERVAL_PRECISION - 11);
+                let nanos = nanos_int.add_checked(nanos_frac)?;
+
+                Interval::new(self.months, self.days, self.nanos.add_checked(nanos)?)
+            }
+            IntervalUnit::Minute => {
+                let nanos_int = amount.integer.mul_checked(NANOS_PER_MINUTE)?;
+                let nanos_frac = amount.frac * 6 / 10_i64.pow(INTERVAL_PRECISION - 10);
+
+                let nanos = nanos_int.add_checked(nanos_frac)?;
+
+                Interval::new(self.months, self.days, self.nanos.add_checked(nanos)?)
+            }
+            IntervalUnit::Second => {
+                let nanos_int = amount.integer.mul_checked(NANOS_PER_SECOND)?;
+                let nanos_frac = amount.frac / 10_i64.pow(INTERVAL_PRECISION - 9);
+                let nanos = nanos_int.add_checked(nanos_frac)?;
+
+                Interval::new(self.months, self.days, self.nanos.add_checked(nanos)?)
+            }
+            IntervalUnit::Millisecond => {
+                let nanos_int = amount.integer.mul_checked(NANOS_PER_MILLIS)?;
+                let nanos_frac = amount.frac / 10_i64.pow(INTERVAL_PRECISION - 6);
+                let nanos = nanos_int.add_checked(nanos_frac)?;
+
+                Interval::new(self.months, self.days, self.nanos.add_checked(nanos)?)
+            }
+            IntervalUnit::Microsecond => {
+                let nanos_int = amount.integer.mul_checked(1_000)?;
+                let nanos_frac = amount.frac / 10_i64.pow(INTERVAL_PRECISION - 3);
+                let nanos = nanos_int.add_checked(nanos_frac)?;
+
+                Interval::new(self.months, self.days, self.nanos.add_checked(nanos)?)
+            }
+            IntervalUnit::Nanosecond => {
+                let nanos_int = amount.integer;
+                let nanos_frac = amount.frac / 10_i64.pow(INTERVAL_PRECISION);
+                let nanos = nanos_int.add_checked(nanos_frac)?;
+
+                Interval::new(self.months, self.days, self.nanos.add_checked(nanos)?)
+            }
+        };
+
+        Ok(result)
+    }
+}
+
+struct IntervalParseConfig {
+    /// The default unit to use if none is specified
+    /// e.g. `INTERVAL 1` represents `INTERVAL 1 SECOND` when default_unit = IntervalType::Second
+    default_unit: IntervalUnit,
+}
+
+impl IntervalParseConfig {
+    fn new(default_unit: IntervalUnit) -> Self {
+        Self { default_unit }
+    }
+}
+
+/// parse the string into a vector of interval components i.e. (amount, unit) tuples
+fn parse_interval_components(
+    value: &str,
+    config: &IntervalParseConfig,
+) -> Result<Vec<(IntervalAmount, IntervalUnit)>, ArrowError> {
+    let parts = value.split_whitespace();
+
+    let raw_amounts = parts.clone().step_by(2);
+    let raw_units = parts.skip(1).step_by(2);
+
+    // parse amounts
+    let (amounts, invalid_amounts) = raw_amounts
+        .map(IntervalAmount::from_str)
+        .partition::<Vec<_>, _>(Result::is_ok);
+
+    // invalid amounts?
+    if !invalid_amounts.is_empty() {
+        return Err(ArrowError::NotYetImplemented(format!(
+            "Unsupported Interval Expression with value {value:?}"
+        )));
+    }
+
+    // parse units
+    let (units, invalid_units): (Vec<_>, Vec<_>) = raw_units
+        .clone()
+        .map(IntervalUnit::from_str)
+        .partition(Result::is_ok);
+
+    // invalid units?
+    if !invalid_units.is_empty() {
+        return Err(ArrowError::ParseError(format!(
+            "Invalid input syntax for type interval: {value:?}"
+        )));
+    }
+
+    // collect parsed results
+    let amounts = amounts.into_iter().map(Result::unwrap).collect::<Vec<_>>();
+    let units = units.into_iter().map(Result::unwrap).collect::<Vec<_>>();
+
+    // if only an amount is specified, use the default unit
+    if amounts.len() == 1 && units.is_empty() {
+        return Ok(vec![(amounts[0], config.default_unit)]);
+    };
+
+    // duplicate units?
+    let mut observed_interval_types = 0;
+    for (unit, raw_unit) in units.iter().zip(raw_units) {
+        if observed_interval_types & (*unit as u16) != 0 {
+            return Err(ArrowError::ParseError(format!(
+                "Invalid input syntax for type interval: {value:?}. Repeated type '{raw_unit}'",
+            )));
+        }
+
+        observed_interval_types |= *unit as u16;
+    }
+
+    let result = amounts.iter().copied().zip(units.iter().copied());
+
+    Ok(result.collect::<Vec<_>>())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::temporal_conversions::date32_to_datetime;
+    use arrow_array::timezone::Tz;
+    use arrow_buffer::i256;
+
+    #[test]
+    fn test_parse_nanos() {
+        assert_eq!(parse_nanos::<3, 0>(&[1, 2, 3]), 123_000_000);
+        assert_eq!(parse_nanos::<5, 0>(&[1, 2, 3, 4, 5]), 123_450_000);
+        assert_eq!(parse_nanos::<6, b'0'>(b"123456"), 123_456_000);
+    }
+
+    #[test]
+    fn string_to_timestamp_timezone() {
+        // Explicit timezone
+        assert_eq!(
+            1599572549190855000,
+            parse_timestamp("2020-09-08T13:42:29.190855+00:00").unwrap()
+        );
+        assert_eq!(
+            1599572549190855000,
+            parse_timestamp("2020-09-08T13:42:29.190855Z").unwrap()
+        );
+        assert_eq!(
+            1599572549000000000,
+            parse_timestamp("2020-09-08T13:42:29Z").unwrap()
+        ); // no fractional part
+        assert_eq!(
+            1599590549190855000,
+            parse_timestamp("2020-09-08T13:42:29.190855-05:00").unwrap()
+        );
+    }
+
+    #[test]
+    fn string_to_timestamp_timezone_space() {
+        // Ensure space rather than T between time and date is accepted
+        assert_eq!(
+            1599572549190855000,
+            parse_timestamp("2020-09-08 13:42:29.190855+00:00").unwrap()
+        );
+        assert_eq!(
+            1599572549190855000,
+            parse_timestamp("2020-09-08 13:42:29.190855Z").unwrap()
+        );
+        assert_eq!(
+            1599572549000000000,
+            parse_timestamp("2020-09-08 13:42:29Z").unwrap()
+        ); // no fractional part
+        assert_eq!(
+            1599590549190855000,
+            parse_timestamp("2020-09-08 13:42:29.190855-05:00").unwrap()
+        );
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)] // unsupported operation: can't call foreign function: mktime
+    fn string_to_timestamp_no_timezone() {
+        // This test is designed to succeed in regardless of the local
+        // timezone the test machine is running. Thus it is still
+        // somewhat susceptible to bugs in the use of chrono
+        let naive_datetime = NaiveDateTime::new(
+            NaiveDate::from_ymd_opt(2020, 9, 8).unwrap(),
+            NaiveTime::from_hms_nano_opt(13, 42, 29, 190855000).unwrap(),
+        );
+
+        // Ensure both T and ' ' variants work
+        assert_eq!(
+            naive_datetime.timestamp_nanos_opt().unwrap(),
+            parse_timestamp("2020-09-08T13:42:29.190855").unwrap()
+        );
+
+        assert_eq!(
+            naive_datetime.timestamp_nanos_opt().unwrap(),
+            parse_timestamp("2020-09-08 13:42:29.190855").unwrap()
+        );
+
+        // Also ensure that parsing timestamps with no fractional
+        // second part works as well
+        let naive_datetime_whole_secs = NaiveDateTime::new(
+            NaiveDate::from_ymd_opt(2020, 9, 8).unwrap(),
+            NaiveTime::from_hms_opt(13, 42, 29).unwrap(),
+        );
+
+        // Ensure both T and ' ' variants work
+        assert_eq!(
+            naive_datetime_whole_secs.timestamp_nanos_opt().unwrap(),
+            parse_timestamp("2020-09-08T13:42:29").unwrap()
+        );
+
+        assert_eq!(
+            naive_datetime_whole_secs.timestamp_nanos_opt().unwrap(),
+            parse_timestamp("2020-09-08 13:42:29").unwrap()
+        );
+
+        // ensure without time work
+        // no time, should be the nano second at
+        // 2020-09-08 0:0:0
+        let naive_datetime_no_time = NaiveDateTime::new(
+            NaiveDate::from_ymd_opt(2020, 9, 8).unwrap(),
+            NaiveTime::from_hms_opt(0, 0, 0).unwrap(),
+        );
+
+        assert_eq!(
+            naive_datetime_no_time.timestamp_nanos_opt().unwrap(),
+            parse_timestamp("2020-09-08").unwrap()
+        )
+    }
+
+    #[test]
+    fn string_to_timestamp_chrono() {
+        let cases = [
+            "2020-09-08T13:42:29Z",
+            "1969-01-01T00:00:00.1Z",
+            "2020-09-08T12:00:12.12345678+00:00",
+            "2020-09-08T12:00:12+00:00",
+            "2020-09-08T12:00:12.1+00:00",
+            "2020-09-08T12:00:12.12+00:00",
+            "2020-09-08T12:00:12.123+00:00",
+            "2020-09-08T12:00:12.1234+00:00",
+            "2020-09-08T12:00:12.12345+00:00",
+            "2020-09-08T12:00:12.123456+00:00",
+            "2020-09-08T12:00:12.1234567+00:00",
+            "2020-09-08T12:00:12.12345678+00:00",
+            "2020-09-08T12:00:12.123456789+00:00",
+            "2020-09-08T12:00:12.12345678912z",
+            "2020-09-08T12:00:12.123456789123Z",
+            "2020-09-08T12:00:12.123456789123+02:00",
+            "2020-09-08T12:00:12.12345678912345Z",
+            "2020-09-08T12:00:12.1234567891234567+02:00",
+            "2020-09-08T12:00:60Z",
+            "2020-09-08T12:00:60.123Z",
+            "2020-09-08T12:00:60.123456+02:00",
+            "2020-09-08T12:00:60.1234567891234567+02:00",
+            "2020-09-08T12:00:60.999999999+02:00",
+            "2020-09-08t12:00:12.12345678+00:00",
+            "2020-09-08t12:00:12+00:00",
+            "2020-09-08t12:00:12Z",
+        ];
+
+        for case in cases {
+            let chrono = DateTime::parse_from_rfc3339(case).unwrap();
+            let chrono_utc = chrono.with_timezone(&Utc);
+
+            let custom = string_to_datetime(&Utc, case).unwrap();
+            assert_eq!(chrono_utc, custom)
+        }
+    }
+
+    #[test]
+    fn string_to_timestamp_naive() {
+        let cases = [
+            "2018-11-13T17:11:10.011375885995",
+            "2030-12-04T17:11:10.123",
+            "2030-12-04T17:11:10.1234",
+            "2030-12-04T17:11:10.123456",
+        ];
+        for case in cases {
+            let chrono = NaiveDateTime::parse_from_str(case, "%Y-%m-%dT%H:%M:%S%.f").unwrap();
+            let custom = string_to_datetime(&Utc, case).unwrap();
+            assert_eq!(chrono, custom.naive_utc())
+        }
+    }
+
+    #[test]
+    fn string_to_timestamp_invalid() {
+        // Test parsing invalid formats
+        let cases = [
+            ("", "timestamp must contain at least 10 characters"),
+            ("SS", "timestamp must contain at least 10 characters"),
+            ("Wed, 18 Feb 2015 23:16:09 GMT", "error parsing date"),
+            ("1997-01-31H09:26:56.123Z", "invalid timestamp separator"),
+            ("1997-01-31  09:26:56.123Z", "error parsing time"),
+            ("1997:01:31T09:26:56.123Z", "error parsing date"),
+            ("1997:1:31T09:26:56.123Z", "error parsing date"),
+            ("1997-01-32T09:26:56.123Z", "error parsing date"),
+            ("1997-13-32T09:26:56.123Z", "error parsing date"),
+            ("1997-02-29T09:26:56.123Z", "error parsing date"),
+            ("2015-02-30T17:35:20-08:00", "error parsing date"),
+            ("1997-01-10T9:26:56.123Z", "error parsing time"),
+            ("2015-01-20T25:35:20-08:00", "error parsing time"),
+            ("1997-01-10T09:61:56.123Z", "error parsing time"),
+            ("1997-01-10T09:61:90.123Z", "error parsing time"),
+            ("1997-01-10T12:00:6.123Z", "error parsing time"),
+            ("1997-01-31T092656.123Z", "error parsing time"),
+            ("1997-01-10T12:00:06.", "error parsing time"),
+            ("1997-01-10T12:00:06. ", "error parsing time"),
+        ];
+
+        for (s, ctx) in cases {
+            let expected = format!("Parser error: Error parsing timestamp from '{s}': {ctx}");
+            let actual = string_to_datetime(&Utc, s).unwrap_err().to_string();
+            assert_eq!(actual, expected)
+        }
+    }
+
+    // Parse a timestamp to timestamp int with a useful human readable error message
+    fn parse_timestamp(s: &str) -> Result<i64, ArrowError> {
+        let result = string_to_timestamp_nanos(s);
+        if let Err(e) = &result {
+            eprintln!("Error parsing timestamp '{s}': {e:?}");
+        }
+        result
+    }
+
+    #[test]
+    fn string_without_timezone_to_timestamp() {
+        // string without timezone should always output the same regardless the local or session timezone
+
+        let naive_datetime = NaiveDateTime::new(
+            NaiveDate::from_ymd_opt(2020, 9, 8).unwrap(),
+            NaiveTime::from_hms_nano_opt(13, 42, 29, 190855000).unwrap(),
+        );
+
+        // Ensure both T and ' ' variants work
+        assert_eq!(
+            naive_datetime.timestamp_nanos_opt().unwrap(),
+            parse_timestamp("2020-09-08T13:42:29.190855").unwrap()
+        );
+
+        assert_eq!(
+            naive_datetime.timestamp_nanos_opt().unwrap(),
+            parse_timestamp("2020-09-08 13:42:29.190855").unwrap()
+        );
+
+        let naive_datetime = NaiveDateTime::new(
+            NaiveDate::from_ymd_opt(2020, 9, 8).unwrap(),
+            NaiveTime::from_hms_nano_opt(13, 42, 29, 0).unwrap(),
+        );
+
+        // Ensure both T and ' ' variants work
+        assert_eq!(
+            naive_datetime.timestamp_nanos_opt().unwrap(),
+            parse_timestamp("2020-09-08T13:42:29").unwrap()
+        );
+
+        assert_eq!(
+            naive_datetime.timestamp_nanos_opt().unwrap(),
+            parse_timestamp("2020-09-08 13:42:29").unwrap()
+        );
+
+        let tz: Tz = "+02:00".parse().unwrap();
+        let date = string_to_datetime(&tz, "2020-09-08 13:42:29").unwrap();
+        let utc = date.naive_utc().to_string();
+        assert_eq!(utc, "2020-09-08 11:42:29");
+        let local = date.naive_local().to_string();
+        assert_eq!(local, "2020-09-08 13:42:29");
+
+        let date = string_to_datetime(&tz, "2020-09-08 13:42:29Z").unwrap();
+        let utc = date.naive_utc().to_string();
+        assert_eq!(utc, "2020-09-08 13:42:29");
+        let local = date.naive_local().to_string();
+        assert_eq!(local, "2020-09-08 15:42:29");
+
+        let dt =
+            NaiveDateTime::parse_from_str("2020-09-08T13:42:29Z", "%Y-%m-%dT%H:%M:%SZ").unwrap();
+        let local: Tz = "+08:00".parse().unwrap();
+
+        // Parsed as offset from UTC
+        let date = string_to_datetime(&local, "2020-09-08T13:42:29Z").unwrap();
+        assert_eq!(dt, date.naive_utc());
+        assert_ne!(dt, date.naive_local());
+
+        // Parsed as offset from local
+        let date = string_to_datetime(&local, "2020-09-08 13:42:29").unwrap();
+        assert_eq!(dt, date.naive_local());
+        assert_ne!(dt, date.naive_utc());
+    }
+
+    #[test]
+    fn parse_date32() {
+        let cases = [
+            "2020-09-08",
+            "2020-9-8",
+            "2020-09-8",
+            "2020-9-08",
+            "2020-12-1",
+            "1690-2-5",
+            "2020-09-08 01:02:03",
+        ];
+        for case in cases {
+            let v = date32_to_datetime(Date32Type::parse(case).unwrap()).unwrap();
+            let expected = NaiveDate::parse_from_str(case, "%Y-%m-%d")
+                .or(NaiveDate::parse_from_str(case, "%Y-%m-%d %H:%M:%S"))
+                .unwrap();
+            assert_eq!(v.date(), expected);
+        }
+
+        let err_cases = [
+            "",
+            "80-01-01",
+            "342",
+            "Foo",
+            "2020-09-08-03",
+            "2020--04-03",
+            "2020--",
+            "2020-09-08 01",
+            "2020-09-08 01:02",
+            "2020-09-08 01-02-03",
+            "2020-9-8 01:02:03",
+            "2020-09-08 1:2:3",
+        ];
+        for case in err_cases {
+            assert_eq!(Date32Type::parse(case), None);
+        }
+    }
+
+    #[test]
+    fn parse_time64_nanos() {
+        assert_eq!(
+            Time64NanosecondType::parse("02:10:01.1234567899999999"),
+            Some(7_801_123_456_789)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("02:10:01.1234567"),
+            Some(7_801_123_456_700)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("2:10:01.1234567"),
+            Some(7_801_123_456_700)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("12:10:01.123456789 AM"),
+            Some(601_123_456_789)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("12:10:01.123456789 am"),
+            Some(601_123_456_789)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("2:10:01.12345678 PM"),
+            Some(51_001_123_456_780)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("2:10:01.12345678 pm"),
+            Some(51_001_123_456_780)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("02:10:01"),
+            Some(7_801_000_000_000)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("2:10:01"),
+            Some(7_801_000_000_000)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("12:10:01 AM"),
+            Some(601_000_000_000)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("12:10:01 am"),
+            Some(601_000_000_000)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("2:10:01 PM"),
+            Some(51_001_000_000_000)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("2:10:01 pm"),
+            Some(51_001_000_000_000)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("02:10"),
+            Some(7_800_000_000_000)
+        );
+        assert_eq!(Time64NanosecondType::parse("2:10"), Some(7_800_000_000_000));
+        assert_eq!(
+            Time64NanosecondType::parse("12:10 AM"),
+            Some(600_000_000_000)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("12:10 am"),
+            Some(600_000_000_000)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("2:10 PM"),
+            Some(51_000_000_000_000)
+        );
+        assert_eq!(
+            Time64NanosecondType::parse("2:10 pm"),
+            Some(51_000_000_000_000)
+        );
+
+        // parse directly as nanoseconds
+        assert_eq!(Time64NanosecondType::parse("1"), Some(1));
+
+        // leap second
+        assert_eq!(
+            Time64NanosecondType::parse("23:59:60"),
+            Some(86_400_000_000_000)
+        );
+
+        // custom format
+        assert_eq!(
+            Time64NanosecondType::parse_formatted("02 - 10 - 01 - .1234567", "%H - %M - %S - %.f"),
+            Some(7_801_123_456_700)
+        );
+    }
+
+    #[test]
+    fn parse_time64_micros() {
+        // expected formats
+        assert_eq!(
+            Time64MicrosecondType::parse("02:10:01.1234"),
+            Some(7_801_123_400)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("2:10:01.1234"),
+            Some(7_801_123_400)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("12:10:01.123456 AM"),
+            Some(601_123_456)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("12:10:01.123456 am"),
+            Some(601_123_456)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("2:10:01.12345 PM"),
+            Some(51_001_123_450)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("2:10:01.12345 pm"),
+            Some(51_001_123_450)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("02:10:01"),
+            Some(7_801_000_000)
+        );
+        assert_eq!(Time64MicrosecondType::parse("2:10:01"), Some(7_801_000_000));
+        assert_eq!(
+            Time64MicrosecondType::parse("12:10:01 AM"),
+            Some(601_000_000)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("12:10:01 am"),
+            Some(601_000_000)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("2:10:01 PM"),
+            Some(51_001_000_000)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("2:10:01 pm"),
+            Some(51_001_000_000)
+        );
+        assert_eq!(Time64MicrosecondType::parse("02:10"), Some(7_800_000_000));
+        assert_eq!(Time64MicrosecondType::parse("2:10"), Some(7_800_000_000));
+        assert_eq!(Time64MicrosecondType::parse("12:10 AM"), Some(600_000_000));
+        assert_eq!(Time64MicrosecondType::parse("12:10 am"), Some(600_000_000));
+        assert_eq!(
+            Time64MicrosecondType::parse("2:10 PM"),
+            Some(51_000_000_000)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("2:10 pm"),
+            Some(51_000_000_000)
+        );
+
+        // parse directly as microseconds
+        assert_eq!(Time64MicrosecondType::parse("1"), Some(1));
+
+        // leap second
+        assert_eq!(
+            Time64MicrosecondType::parse("23:59:60"),
+            Some(86_400_000_000)
+        );
+
+        // custom format
+        assert_eq!(
+            Time64MicrosecondType::parse_formatted("02 - 10 - 01 - .1234", "%H - %M - %S - %.f"),
+            Some(7_801_123_400)
+        );
+    }
+
+    #[test]
+    fn parse_time32_millis() {
+        // expected formats
+        assert_eq!(Time32MillisecondType::parse("02:10:01.1"), Some(7_801_100));
+        assert_eq!(Time32MillisecondType::parse("2:10:01.1"), Some(7_801_100));
+        assert_eq!(
+            Time32MillisecondType::parse("12:10:01.123 AM"),
+            Some(601_123)
+        );
+        assert_eq!(
+            Time32MillisecondType::parse("12:10:01.123 am"),
+            Some(601_123)
+        );
+        assert_eq!(
+            Time32MillisecondType::parse("2:10:01.12 PM"),
+            Some(51_001_120)
+        );
+        assert_eq!(
+            Time32MillisecondType::parse("2:10:01.12 pm"),
+            Some(51_001_120)
+        );
+        assert_eq!(Time32MillisecondType::parse("02:10:01"), Some(7_801_000));
+        assert_eq!(Time32MillisecondType::parse("2:10:01"), Some(7_801_000));
+        assert_eq!(Time32MillisecondType::parse("12:10:01 AM"), Some(601_000));
+        assert_eq!(Time32MillisecondType::parse("12:10:01 am"), Some(601_000));
+        assert_eq!(Time32MillisecondType::parse("2:10:01 PM"), Some(51_001_000));
+        assert_eq!(Time32MillisecondType::parse("2:10:01 pm"), Some(51_001_000));
+        assert_eq!(Time32MillisecondType::parse("02:10"), Some(7_800_000));
+        assert_eq!(Time32MillisecondType::parse("2:10"), Some(7_800_000));
+        assert_eq!(Time32MillisecondType::parse("12:10 AM"), Some(600_000));
+        assert_eq!(Time32MillisecondType::parse("12:10 am"), Some(600_000));
+        assert_eq!(Time32MillisecondType::parse("2:10 PM"), Some(51_000_000));
+        assert_eq!(Time32MillisecondType::parse("2:10 pm"), Some(51_000_000));
+
+        // parse directly as milliseconds
+        assert_eq!(Time32MillisecondType::parse("1"), Some(1));
+
+        // leap second
+        assert_eq!(Time32MillisecondType::parse("23:59:60"), Some(86_400_000));
+
+        // custom format
+        assert_eq!(
+            Time32MillisecondType::parse_formatted("02 - 10 - 01 - .1", "%H - %M - %S - %.f"),
+            Some(7_801_100)
+        );
+    }
+
+    #[test]
+    fn parse_time32_secs() {
+        // expected formats
+        assert_eq!(Time32SecondType::parse("02:10:01.1"), Some(7_801));
+        assert_eq!(Time32SecondType::parse("02:10:01"), Some(7_801));
+        assert_eq!(Time32SecondType::parse("2:10:01"), Some(7_801));
+        assert_eq!(Time32SecondType::parse("12:10:01 AM"), Some(601));
+        assert_eq!(Time32SecondType::parse("12:10:01 am"), Some(601));
+        assert_eq!(Time32SecondType::parse("2:10:01 PM"), Some(51_001));
+        assert_eq!(Time32SecondType::parse("2:10:01 pm"), Some(51_001));
+        assert_eq!(Time32SecondType::parse("02:10"), Some(7_800));
+        assert_eq!(Time32SecondType::parse("2:10"), Some(7_800));
+        assert_eq!(Time32SecondType::parse("12:10 AM"), Some(600));
+        assert_eq!(Time32SecondType::parse("12:10 am"), Some(600));
+        assert_eq!(Time32SecondType::parse("2:10 PM"), Some(51_000));
+        assert_eq!(Time32SecondType::parse("2:10 pm"), Some(51_000));
+
+        // parse directly as seconds
+        assert_eq!(Time32SecondType::parse("1"), Some(1));
+
+        // leap second
+        assert_eq!(Time32SecondType::parse("23:59:60"), Some(86400));
+
+        // custom format
+        assert_eq!(
+            Time32SecondType::parse_formatted("02 - 10 - 01", "%H - %M - %S"),
+            Some(7_801)
+        );
+    }
+
+    #[test]
+    fn test_string_to_time_invalid() {
+        let cases = [
+            "25:00",
+            "9:00:",
+            "009:00",
+            "09:0:00",
+            "25:00:00",
+            "13:00 AM",
+            "13:00 PM",
+            "12:00. AM",
+            "09:0:00",
+            "09:01:0",
+            "09:01:1",
+            "9:1:0",
+            "09:01:0",
+            "1:00.123",
+            "1:00:00.123f",
+            " 9:00:00",
+            ":09:00",
+            "T9:00:00",
+            "AM",
+        ];
+        for case in cases {
+            assert!(string_to_time(case).is_none(), "{case}");
+        }
+    }
+
+    #[test]
+    fn test_string_to_time_chrono() {
+        let cases = [
+            ("1:00", "%H:%M"),
+            ("12:00", "%H:%M"),
+            ("13:00", "%H:%M"),
+            ("24:00", "%H:%M"),
+            ("1:00:00", "%H:%M:%S"),
+            ("12:00:30", "%H:%M:%S"),
+            ("13:00:59", "%H:%M:%S"),
+            ("24:00:60", "%H:%M:%S"),
+            ("09:00:00", "%H:%M:%S%.f"),
+            ("0:00:30.123456", "%H:%M:%S%.f"),
+            ("0:00 AM", "%I:%M %P"),
+            ("1:00 AM", "%I:%M %P"),
+            ("12:00 AM", "%I:%M %P"),
+            ("13:00 AM", "%I:%M %P"),
+            ("0:00 PM", "%I:%M %P"),
+            ("1:00 PM", "%I:%M %P"),
+            ("12:00 PM", "%I:%M %P"),
+            ("13:00 PM", "%I:%M %P"),
+            ("1:00 pM", "%I:%M %P"),
+            ("1:00 Pm", "%I:%M %P"),
+            ("1:00 aM", "%I:%M %P"),
+            ("1:00 Am", "%I:%M %P"),
+            ("1:00:30.123456 PM", "%I:%M:%S%.f %P"),
+            ("1:00:30.123456789 PM", "%I:%M:%S%.f %P"),
+            ("1:00:30.123456789123 PM", "%I:%M:%S%.f %P"),
+            ("1:00:30.1234 PM", "%I:%M:%S%.f %P"),
+            ("1:00:30.123456 PM", "%I:%M:%S%.f %P"),
+            ("1:00:30.123456789123456789 PM", "%I:%M:%S%.f %P"),
+            ("1:00:30.12F456 PM", "%I:%M:%S%.f %P"),
+        ];
+        for (s, format) in cases {
+            let chrono = NaiveTime::parse_from_str(s, format).ok();
+            let custom = string_to_time(s);
+            assert_eq!(chrono, custom, "{s}");
+        }
+    }
+
+    #[test]
+    fn test_parse_interval() {
+        let config = IntervalParseConfig::new(IntervalUnit::Month);
+
+        assert_eq!(
+            Interval::new(1i32, 0i32, 0i64),
+            Interval::parse("1 month", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(2i32, 0i32, 0i64),
+            Interval::parse("2 month", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(-1i32, -18i32, -(NANOS_PER_DAY / 5)),
+            Interval::parse("-1.5 months -3.2 days", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(0i32, 15i32, 0),
+            Interval::parse("0.5 months", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(0i32, 15i32, 0),
+            Interval::parse(".5 months", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(0i32, -15i32, 0),
+            Interval::parse("-0.5 months", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(0i32, -15i32, 0),
+            Interval::parse("-.5 months", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(2i32, 10i32, 9 * NANOS_PER_HOUR),
+            Interval::parse("2.1 months 7.25 days 3 hours", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::parse("1 centurys 1 month", &config)
+                .unwrap_err()
+                .to_string(),
+            r#"Parser error: Invalid input syntax for type interval: "1 centurys 1 month""#
+        );
+
+        assert_eq!(
+            Interval::new(37i32, 0i32, 0i64),
+            Interval::parse("3 year 1 month", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(35i32, 0i32, 0i64),
+            Interval::parse("3 year -1 month", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(-37i32, 0i32, 0i64),
+            Interval::parse("-3 year -1 month", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(-35i32, 0i32, 0i64),
+            Interval::parse("-3 year 1 month", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(0i32, 5i32, 0i64),
+            Interval::parse("5 days", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(0i32, 7i32, 3 * NANOS_PER_HOUR),
+            Interval::parse("7 days 3 hours", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(0i32, 7i32, 5 * NANOS_PER_MINUTE),
+            Interval::parse("7 days 5 minutes", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(0i32, 7i32, -5 * NANOS_PER_MINUTE),
+            Interval::parse("7 days -5 minutes", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(0i32, -7i32, 5 * NANOS_PER_HOUR),
+            Interval::parse("-7 days 5 hours", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(
+                0i32,
+                -7i32,
+                -5 * NANOS_PER_HOUR - 5 * NANOS_PER_MINUTE - 5 * NANOS_PER_SECOND
+            ),
+            Interval::parse("-7 days -5 hours -5 minutes -5 seconds", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(12i32, 0i32, 25 * NANOS_PER_MILLIS),
+            Interval::parse("1 year 25 millisecond", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(
+                12i32,
+                1i32,
+                (NANOS_PER_SECOND as f64 * 0.000000001_f64) as i64
+            ),
+            Interval::parse("1 year 1 day 0.000000001 seconds", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(12i32, 1i32, NANOS_PER_MILLIS / 10),
+            Interval::parse("1 year 1 day 0.1 milliseconds", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(12i32, 1i32, 1000i64),
+            Interval::parse("1 year 1 day 1 microsecond", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(12i32, 1i32, 1i64),
+            Interval::parse("1 year 1 day 1 nanoseconds", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(1i32, 0i32, -NANOS_PER_SECOND),
+            Interval::parse("1 month -1 second", &config).unwrap(),
+        );
+
+        assert_eq!(
+            Interval::new(
+                -13i32,
+                -8i32,
+                -NANOS_PER_HOUR
+                    - NANOS_PER_MINUTE
+                    - NANOS_PER_SECOND
+                    - (1.11_f64 * NANOS_PER_MILLIS as f64) as i64
+            ),
+            Interval::parse(
+                "-1 year -1 month -1 week -1 day -1 hour -1 minute -1 second -1.11 millisecond",
+                &config
+            )
+            .unwrap(),
+        );
+    }
+
+    #[test]
+    fn test_duplicate_interval_type() {
+        let config = IntervalParseConfig::new(IntervalUnit::Month);
+
+        let err = Interval::parse("1 month 1 second 1 second", &config)
+            .expect_err("parsing interval should have failed");
+        assert_eq!(
+            r#"ParseError("Invalid input syntax for type interval: \"1 month 1 second 1 second\". Repeated type 'second'")"#,
+            format!("{err:?}")
+        );
+
+        // test with singular and plural forms
+        let err = Interval::parse("1 century 2 centuries", &config)
+            .expect_err("parsing interval should have failed");
+        assert_eq!(
+            r#"ParseError("Invalid input syntax for type interval: \"1 century 2 centuries\". Repeated type 'centuries'")"#,
+            format!("{err:?}")
+        );
+    }
+
+    #[test]
+    fn test_interval_amount_parsing() {
+        // integer
+        let result = IntervalAmount::from_str("123").unwrap();
+        let expected = IntervalAmount::new(123, 0);
+
+        assert_eq!(result, expected);
+
+        // positive w/ fractional
+        let result = IntervalAmount::from_str("0.3").unwrap();
+        let expected = IntervalAmount::new(0, 3 * 10_i64.pow(INTERVAL_PRECISION - 1));
+
+        assert_eq!(result, expected);
+
+        // negative w/ fractional
+        let result = IntervalAmount::from_str("-3.5").unwrap();
+        let expected = IntervalAmount::new(-3, -5 * 10_i64.pow(INTERVAL_PRECISION - 1));
+
+        assert_eq!(result, expected);
+
+        // invalid: missing fractional
+        let result = IntervalAmount::from_str("3.");
+        assert!(result.is_err());
+
+        // invalid: sign in fractional
+        let result = IntervalAmount::from_str("3.-5");
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_interval_precision() {
+        let config = IntervalParseConfig::new(IntervalUnit::Month);
+
+        let result = Interval::parse("100000.1 days", &config).unwrap();
+        let expected = Interval::new(0_i32, 100_000_i32, NANOS_PER_DAY / 10);
+
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn test_interval_addition() {
+        // add 4.1 centuries
+        let start = Interval::new(1, 2, 3);
+        let expected = Interval::new(4921, 2, 3);
+
+        let result = start
+            .add(
+                IntervalAmount::new(4, 10_i64.pow(INTERVAL_PRECISION - 1)),
+                IntervalUnit::Century,
+            )
+            .unwrap();
+
+        assert_eq!(result, expected);
+
+        // add 10.25 decades
+        let start = Interval::new(1, 2, 3);
+        let expected = Interval::new(1231, 2, 3);
+
+        let result = start
+            .add(
+                IntervalAmount::new(10, 25 * 10_i64.pow(INTERVAL_PRECISION - 2)),
+                IntervalUnit::Decade,
+            )
+            .unwrap();
+
+        assert_eq!(result, expected);
+
+        // add 30.3 years (reminder: Postgres logic does not spill to days/nanos when interval is larger than a month)
+        let start = Interval::new(1, 2, 3);
+        let expected = Interval::new(364, 2, 3);
+
+        let result = start
+            .add(
+                IntervalAmount::new(30, 3 * 10_i64.pow(INTERVAL_PRECISION - 1)),
+                IntervalUnit::Year,
+            )
+            .unwrap();
+
+        assert_eq!(result, expected);
+
+        // add 1.5 months
+        let start = Interval::new(1, 2, 3);
+        let expected = Interval::new(2, 17, 3);
+
+        let result = start
+            .add(
+                IntervalAmount::new(1, 5 * 10_i64.pow(INTERVAL_PRECISION - 1)),
+                IntervalUnit::Month,
+            )
+            .unwrap();
+
+        assert_eq!(result, expected);
+
+        // add -2 weeks
+        let start = Interval::new(1, 25, 3);
+        let expected = Interval::new(1, 11, 3);
+
+        let result = start
+            .add(IntervalAmount::new(-2, 0), IntervalUnit::Week)
+            .unwrap();
+
+        assert_eq!(result, expected);
+
+        // add 2.2 days
+        let start = Interval::new(12, 15, 3);
+        let expected = Interval::new(12, 17, 3 + 17_280 * NANOS_PER_SECOND);
+
+        let result = start
+            .add(
+                IntervalAmount::new(2, 2 * 10_i64.pow(INTERVAL_PRECISION - 1)),
+                IntervalUnit::Day,
+            )
+            .unwrap();
+
+        assert_eq!(result, expected);
+
+        // add 12.5 hours
+        let start = Interval::new(1, 2, 3);
+        let expected = Interval::new(1, 2, 3 + 45_000 * NANOS_PER_SECOND);
+
+        let result = start
+            .add(
+                IntervalAmount::new(12, 5 * 10_i64.pow(INTERVAL_PRECISION - 1)),
+                IntervalUnit::Hour,
+            )
+            .unwrap();
+
+        assert_eq!(result, expected);
+
+        // add -1.5 minutes
+        let start = Interval::new(0, 0, -3);
+        let expected = Interval::new(0, 0, -90_000_000_000 - 3);
+
+        let result = start
+            .add(
+                IntervalAmount::new(-1, -5 * 10_i64.pow(INTERVAL_PRECISION - 1)),
+                IntervalUnit::Minute,
+            )
+            .unwrap();
+
+        assert_eq!(result, expected);
+    }
+
+    #[test]
+    fn string_to_timestamp_old() {
+        parse_timestamp("1677-06-14T07:29:01.256")
+            .map_err(|e| assert!(e.to_string().ends_with(ERR_NANOSECONDS_NOT_SUPPORTED)))
+            .unwrap_err();
+    }
+
+    #[test]
+    fn test_parse_decimal_with_parameter() {
+        let tests = [
+            ("0", 0i128),
+            ("123.123", 123123i128),
+            ("123.1234", 123123i128),
+            ("123.1", 123100i128),
+            ("123", 123000i128),
+            ("-123.123", -123123i128),
+            ("-123.1234", -123123i128),
+            ("-123.1", -123100i128),
+            ("-123", -123000i128),
+            ("0.0000123", 0i128),
+            ("12.", 12000i128),
+            ("-12.", -12000i128),
+            ("00.1", 100i128),
+            ("-00.1", -100i128),
+            ("12345678912345678.1234", 12345678912345678123i128),
+            ("-12345678912345678.1234", -12345678912345678123i128),
+            ("99999999999999999.999", 99999999999999999999i128),
+            ("-99999999999999999.999", -99999999999999999999i128),
+            (".123", 123i128),
+            ("-.123", -123i128),
+            ("123.", 123000i128),
+            ("-123.", -123000i128),
+        ];
+        for (s, i) in tests {
+            let result_128 = parse_decimal::<Decimal128Type>(s, 20, 3);
+            assert_eq!(i, result_128.unwrap());
+            let result_256 = parse_decimal::<Decimal256Type>(s, 20, 3);
+            assert_eq!(i256::from_i128(i), result_256.unwrap());
+        }
+        let can_not_parse_tests = ["123,123", ".", "123.123.123", "", "+", "-"];
+        for s in can_not_parse_tests {
+            let result_128 = parse_decimal::<Decimal128Type>(s, 20, 3);
+            assert_eq!(
+                format!("Parser error: can't parse the string value {s} to decimal"),
+                result_128.unwrap_err().to_string()
+            );
+            let result_256 = parse_decimal::<Decimal256Type>(s, 20, 3);
+            assert_eq!(
+                format!("Parser error: can't parse the string value {s} to decimal"),
+                result_256.unwrap_err().to_string()
+            );
+        }
+        let overflow_parse_tests = ["12345678", "12345678.9", "99999999.99"];
+        for s in overflow_parse_tests {
+            let result_128 = parse_decimal::<Decimal128Type>(s, 10, 3);
+            let expected_128 = "Parser error: parse decimal overflow";
+            let actual_128 = result_128.unwrap_err().to_string();
+
+            assert!(
+                actual_128.contains(expected_128),
+                "actual: '{actual_128}', expected: '{expected_128}'"
+            );
+
+            let result_256 = parse_decimal::<Decimal256Type>(s, 10, 3);
+            let expected_256 = "Parser error: parse decimal overflow";
+            let actual_256 = result_256.unwrap_err().to_string();
+
+            assert!(
+                actual_256.contains(expected_256),
+                "actual: '{actual_256}', expected: '{expected_256}'"
+            );
+        }
+
+        let edge_tests_128 = [
+            (
+                "99999999999999999999999999999999999999",
+                99999999999999999999999999999999999999i128,
+                0,
+            ),
+            (
+                "999999999999999999999999999999999999.99",
+                99999999999999999999999999999999999999i128,
+                2,
+            ),
+            (
+                "9999999999999999999999999.9999999999999",
+                99999999999999999999999999999999999999i128,
+                13,
+            ),
+            (
+                "9999999999999999999999999",
+                99999999999999999999999990000000000000i128,
+                13,
+            ),
+            (
+                "0.99999999999999999999999999999999999999",
+                99999999999999999999999999999999999999i128,
+                38,
+            ),
+        ];
+        for (s, i, scale) in edge_tests_128 {
+            let result_128 = parse_decimal::<Decimal128Type>(s, 38, scale);
+            assert_eq!(i, result_128.unwrap());
+        }
+        let edge_tests_256 = [
+            (
+                "9999999999999999999999999999999999999999999999999999999999999999999999999999",
+                i256::from_string(
+                    "9999999999999999999999999999999999999999999999999999999999999999999999999999",
+                )
+                .unwrap(),
+                0,
+            ),
+            (
+                "999999999999999999999999999999999999999999999999999999999999999999999999.9999",
+                i256::from_string(
+                    "9999999999999999999999999999999999999999999999999999999999999999999999999999",
+                )
+                .unwrap(),
+                4,
+            ),
+            (
+                "99999999999999999999999999999999999999999999999999.99999999999999999999999999",
+                i256::from_string(
+                    "9999999999999999999999999999999999999999999999999999999999999999999999999999",
+                )
+                .unwrap(),
+                26,
+            ),
+            (
+                "99999999999999999999999999999999999999999999999999",
+                i256::from_string(
+                    "9999999999999999999999999999999999999999999999999900000000000000000000000000",
+                )
+                .unwrap(),
+                26,
+            ),
+        ];
+        for (s, i, scale) in edge_tests_256 {
+            let result = parse_decimal::<Decimal256Type>(s, 76, scale);
+            assert_eq!(i, result.unwrap());
+        }
+    }
+}
diff --git a/arrow/src/util/pretty.rs b/arrow-cast/src/pretty.rs
similarity index 55%
rename from arrow/src/util/pretty.rs
rename to arrow-cast/src/pretty.rs
index 6f4d9e34a99b..550afa9f739d 100644
--- a/arrow/src/util/pretty.rs
+++ b/arrow-cast/src/pretty.rs
@@ -15,44 +15,60 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Utilities for printing record batches. Note this module is not
+//! Utilities for pretty printing record batches. Note this module is not
 //! available unless `feature = "prettyprint"` is enabled.
 
-use crate::{array::ArrayRef, record_batch::RecordBatch};
+use crate::display::{ArrayFormatter, FormatOptions};
+use arrow_array::{Array, ArrayRef, RecordBatch};
+use arrow_schema::ArrowError;
 use comfy_table::{Cell, Table};
 use std::fmt::Display;
 
-use crate::error::Result;
-
-use super::display::array_value_to_string;
+/// Create a visual representation of record batches
+pub fn pretty_format_batches(results: &[RecordBatch]) -> Result<impl Display, ArrowError> {
+    let options = FormatOptions::default().with_display_error(true);
+    pretty_format_batches_with_options(results, &options)
+}
 
-///! Create a visual representation of record batches
-pub fn pretty_format_batches(results: &[RecordBatch]) -> Result<impl Display> {
-    create_table(results)
+/// Create a visual representation of record batches
+pub fn pretty_format_batches_with_options(
+    results: &[RecordBatch],
+    options: &FormatOptions,
+) -> Result<impl Display, ArrowError> {
+    create_table(results, options)
 }
 
-///! Create a visual representation of columns
+/// Create a visual representation of columns
 pub fn pretty_format_columns(
     col_name: &str,
     results: &[ArrayRef],
-) -> Result<impl Display> {
-    create_column(col_name, results)
+) -> Result<impl Display, ArrowError> {
+    let options = FormatOptions::default().with_display_error(true);
+    pretty_format_columns_with_options(col_name, results, &options)
+}
+
+pub fn pretty_format_columns_with_options(
+    col_name: &str,
+    results: &[ArrayRef],
+    options: &FormatOptions,
+) -> Result<impl Display, ArrowError> {
+    create_column(col_name, results, options)
 }
 
-///! Prints a visual representation of record batches to stdout
-pub fn print_batches(results: &[RecordBatch]) -> Result<()> {
-    println!("{}", create_table(results)?);
+/// Prints a visual representation of record batches to stdout
+pub fn print_batches(results: &[RecordBatch]) -> Result<(), ArrowError> {
+    println!("{}", pretty_format_batches(results)?);
     Ok(())
 }
 
-///! Prints a visual representation of a list of column to stdout
-pub fn print_columns(col_name: &str, results: &[ArrayRef]) -> Result<()> {
-    println!("{}", create_column(col_name, results)?);
+/// Prints a visual representation of a list of column to stdout
+pub fn print_columns(col_name: &str, results: &[ArrayRef]) -> Result<(), ArrowError> {
+    println!("{}", pretty_format_columns(col_name, results)?);
     Ok(())
 }
 
-///! Convert a series of record batches into a table
-fn create_table(results: &[RecordBatch]) -> Result<Table> {
+/// Convert a series of record batches into a table
+fn create_table(results: &[RecordBatch], options: &FormatOptions) -> Result<Table, ArrowError> {
     let mut table = Table::new();
     table.load_preset("||--+-++|    ++++++");
 
@@ -64,16 +80,21 @@ fn create_table(results: &[RecordBatch]) -> Result<Table> {
 
     let mut header = Vec::new();
     for field in schema.fields() {
-        header.push(Cell::new(&field.name()));
+        header.push(Cell::new(field.name()));
     }
     table.set_header(header);
 
     for batch in results {
+        let formatters = batch
+            .columns()
+            .iter()
+            .map(|c| ArrayFormatter::try_new(c.as_ref(), options))
+            .collect::<Result<Vec<_>, ArrowError>>()?;
+
         for row in 0..batch.num_rows() {
             let mut cells = Vec::new();
-            for col in 0..batch.num_columns() {
-                let column = batch.column(col);
-                cells.push(Cell::new(&array_value_to_string(column, row)?));
+            for formatter in &formatters {
+                cells.push(Cell::new(formatter.value(row)));
             }
             table.add_row(cells);
         }
@@ -82,7 +103,11 @@ fn create_table(results: &[RecordBatch]) -> Result<Table> {
     Ok(table)
 }
 
-fn create_column(field: &str, columns: &[ArrayRef]) -> Result<Table> {
+fn create_column(
+    field: &str,
+    columns: &[ArrayRef],
+    options: &FormatOptions,
+) -> Result<Table, ArrowError> {
     let mut table = Table::new();
     table.load_preset("||--+-++|    ++++++");
 
@@ -94,8 +119,9 @@ fn create_column(field: &str, columns: &[ArrayRef]) -> Result<Table> {
     table.set_header(header);
 
     for col in columns {
+        let formatter = ArrayFormatter::try_new(col.as_ref(), options)?;
         for row in 0..col.len() {
-            let cells = vec![Cell::new(&array_value_to_string(col, row)?)];
+            let cells = vec![Cell::new(formatter.value(row))];
             table.add_row(cells);
         }
     }
@@ -105,28 +131,20 @@ fn create_column(field: &str, columns: &[ArrayRef]) -> Result<Table> {
 
 #[cfg(test)]
 mod tests {
-    use crate::{
-        array::{
-            self, new_null_array, Array, Date32Array, Date64Array,
-            FixedSizeBinaryBuilder, Float16Array, Int32Array, PrimitiveBuilder,
-            StringArray, StringBuilder, StringDictionaryBuilder, StructArray,
-            Time32MillisecondArray, Time32SecondArray, Time64MicrosecondArray,
-            Time64NanosecondArray, TimestampMicrosecondArray, TimestampMillisecondArray,
-            TimestampNanosecondArray, TimestampSecondArray, UnionArray, UnionBuilder,
-        },
-        buffer::Buffer,
-        datatypes::{DataType, Field, Float64Type, Int32Type, Schema, UnionMode},
-    };
 
     use super::*;
-    use crate::array::{Decimal128Array, FixedSizeListBuilder};
+    use crate::display::array_value_to_string;
+    use arrow_array::builder::*;
+    use arrow_array::types::*;
+    use arrow_array::*;
+    use arrow_buffer::Buffer;
+    use arrow_schema::*;
+    use half::f16;
     use std::fmt::Write;
     use std::sync::Arc;
 
-    use half::f16;
-
     #[test]
-    fn test_pretty_format_batches() -> Result<()> {
+    fn test_pretty_format_batches() {
         // define a schema.
         let schema = Arc::new(Schema::new(vec![
             Field::new("a", DataType::Utf8, true),
@@ -150,9 +168,10 @@ mod tests {
                     Some(100),
                 ])),
             ],
-        )?;
+        )
+        .unwrap();
 
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
 
         let expected = vec![
             "+---+-----+",
@@ -167,13 +186,11 @@ mod tests {
 
         let actual: Vec<&str> = table.lines().collect();
 
-        assert_eq!(expected, actual, "Actual result:\n{}", table);
-
-        Ok(())
+        assert_eq!(expected, actual, "Actual result:\n{table}");
     }
 
     #[test]
-    fn test_pretty_format_columns() -> Result<()> {
+    fn test_pretty_format_columns() {
         let columns = vec![
             Arc::new(array::StringArray::from(vec![
                 Some("a"),
@@ -184,18 +201,16 @@ mod tests {
             Arc::new(array::StringArray::from(vec![Some("e"), None, Some("g")])),
         ];
 
-        let table = pretty_format_columns("a", &columns)?.to_string();
+        let table = pretty_format_columns("a", &columns).unwrap().to_string();
 
         let expected = vec![
-            "+---+", "| a |", "+---+", "| a |", "| b |", "|   |", "| d |", "| e |",
-            "|   |", "| g |", "+---+",
+            "+---+", "| a |", "+---+", "| a |", "| b |", "|   |", "| d |", "| e |", "|   |",
+            "| g |", "+---+",
         ];
 
         let actual: Vec<&str> = table.lines().collect();
 
-        assert_eq!(expected, actual, "Actual result:\n{}", table);
-
-        Ok(())
+        assert_eq!(expected, actual, "Actual result:\n{table}");
     }
 
     #[test]
@@ -231,28 +246,25 @@ mod tests {
 
         let actual: Vec<&str> = table.lines().collect();
 
-        assert_eq!(expected, actual, "Actual result:\n{:#?}", table);
+        assert_eq!(expected, actual, "Actual result:\n{table:#?}");
     }
 
     #[test]
-    fn test_pretty_format_dictionary() -> Result<()> {
+    fn test_pretty_format_dictionary() {
         // define a schema.
-        let field_type =
-            DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8));
-        let schema = Arc::new(Schema::new(vec![Field::new("d1", field_type, true)]));
+        let field = Field::new_dictionary("d1", DataType::Int32, DataType::Utf8, true);
+        let schema = Arc::new(Schema::new(vec![field]));
 
-        let keys_builder = PrimitiveBuilder::<Int32Type>::new(10);
-        let values_builder = StringBuilder::new(10);
-        let mut builder = StringDictionaryBuilder::new(keys_builder, values_builder);
+        let mut builder = StringDictionaryBuilder::<Int32Type>::new();
 
-        builder.append("one")?;
+        builder.append_value("one");
         builder.append_null();
-        builder.append("three")?;
+        builder.append_value("three");
         let array = Arc::new(builder.finish());
 
-        let batch = RecordBatch::try_new(schema, vec![array])?;
+        let batch = RecordBatch::try_new(schema, vec![array]).unwrap();
 
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
 
         let expected = vec![
             "+-------+",
@@ -266,18 +278,14 @@ mod tests {
 
         let actual: Vec<&str> = table.lines().collect();
 
-        assert_eq!(expected, actual, "Actual result:\n{}", table);
-
-        Ok(())
+        assert_eq!(expected, actual, "Actual result:\n{table}");
     }
 
     #[test]
-    fn test_pretty_format_fixed_size_list() -> Result<()> {
+    fn test_pretty_format_fixed_size_list() {
         // define a schema.
-        let field_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::Int32, true)),
-            3,
-        );
+        let field_type =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, true)), 3);
         let schema = Arc::new(Schema::new(vec![Field::new("d1", field_type, true)]));
 
         let keys_builder = Int32Array::builder(3);
@@ -292,8 +300,8 @@ mod tests {
 
         let array = Arc::new(builder.finish());
 
-        let batch = RecordBatch::try_new(schema, vec![array])?;
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let batch = RecordBatch::try_new(schema, vec![array]).unwrap();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
         let expected = vec![
             "+-----------+",
             "| d1        |",
@@ -306,27 +314,25 @@ mod tests {
 
         let actual: Vec<&str> = table.lines().collect();
 
-        assert_eq!(expected, actual, "Actual result:\n{}", table);
-
-        Ok(())
+        assert_eq!(expected, actual, "Actual result:\n{table}");
     }
 
     #[test]
-    fn test_pretty_format_fixed_size_binary() -> Result<()> {
+    fn test_pretty_format_fixed_size_binary() {
         // define a schema.
         let field_type = DataType::FixedSizeBinary(3);
         let schema = Arc::new(Schema::new(vec![Field::new("d1", field_type, true)]));
 
-        let mut builder = FixedSizeBinaryBuilder::new(3, 3);
+        let mut builder = FixedSizeBinaryBuilder::with_capacity(3, 3);
 
-        builder.append_value(&[1, 2, 3]).unwrap();
+        builder.append_value([1, 2, 3]).unwrap();
         builder.append_null();
-        builder.append_value(&[7, 8, 9]).unwrap();
+        builder.append_value([7, 8, 9]).unwrap();
 
         let array = Arc::new(builder.finish());
 
-        let batch = RecordBatch::try_new(schema, vec![array])?;
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let batch = RecordBatch::try_new(schema, vec![array]).unwrap();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
         let expected = vec![
             "+--------+",
             "| d1     |",
@@ -339,9 +345,7 @@ mod tests {
 
         let actual: Vec<&str> = table.lines().collect();
 
-        assert_eq!(expected, actual, "Actual result:\n{}", table);
-
-        Ok(())
+        assert_eq!(expected, actual, "Actual result:\n{table}");
     }
 
     /// Generate an array with type $ARRAYTYPE with a numeric value of
@@ -368,17 +372,49 @@ mod tests {
             let expected = $EXPECTED_RESULT;
             let actual: Vec<&str> = table.lines().collect();
 
-            assert_eq!(expected, actual, "Actual result:\n\n{:#?}\n\n", actual);
+            assert_eq!(expected, actual, "Actual result:\n\n{actual:#?}\n\n");
         };
     }
 
+    fn timestamp_batch<T: ArrowTimestampType>(timezone: &str, value: T::Native) -> RecordBatch {
+        let mut builder = PrimitiveBuilder::<T>::with_capacity(10);
+        builder.append_value(value);
+        builder.append_null();
+        let array = builder.finish();
+        let array = array.with_timezone(timezone);
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "f",
+            array.data_type().clone(),
+            true,
+        )]));
+        RecordBatch::try_new(schema, vec![Arc::new(array)]).unwrap()
+    }
+
+    #[test]
+    fn test_pretty_format_timestamp_second_with_fixed_offset_timezone() {
+        let batch = timestamp_batch::<TimestampSecondType>("+08:00", 11111111);
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
+
+        let expected = vec![
+            "+---------------------------+",
+            "| f                         |",
+            "+---------------------------+",
+            "| 1970-05-09T22:25:11+08:00 |",
+            "|                           |",
+            "+---------------------------+",
+        ];
+        let actual: Vec<&str> = table.lines().collect();
+        assert_eq!(expected, actual, "Actual result:\n\n{actual:#?}\n\n");
+    }
+
     #[test]
     fn test_pretty_format_timestamp_second() {
         let expected = vec![
             "+---------------------+",
             "| f                   |",
             "+---------------------+",
-            "| 1970-05-09 14:25:11 |",
+            "| 1970-05-09T14:25:11 |",
             "|                     |",
             "+---------------------+",
         ];
@@ -391,7 +427,7 @@ mod tests {
             "+-------------------------+",
             "| f                       |",
             "+-------------------------+",
-            "| 1970-01-01 03:05:11.111 |",
+            "| 1970-01-01T03:05:11.111 |",
             "|                         |",
             "+-------------------------+",
         ];
@@ -404,7 +440,7 @@ mod tests {
             "+----------------------------+",
             "| f                          |",
             "+----------------------------+",
-            "| 1970-01-01 00:00:11.111111 |",
+            "| 1970-01-01T00:00:11.111111 |",
             "|                            |",
             "+----------------------------+",
         ];
@@ -417,7 +453,7 @@ mod tests {
             "+-------------------------------+",
             "| f                             |",
             "+-------------------------------+",
-            "| 1970-01-01 00:00:00.011111111 |",
+            "| 1970-01-01T00:00:00.011111111 |",
             "|                               |",
             "+-------------------------------+",
         ];
@@ -440,12 +476,12 @@ mod tests {
     #[test]
     fn test_pretty_format_date_64() {
         let expected = vec![
-            "+------------+",
-            "| f          |",
-            "+------------+",
-            "| 2005-03-18 |",
-            "|            |",
-            "+------------+",
+            "+---------------------+",
+            "| f                   |",
+            "+---------------------+",
+            "| 2005-03-18T01:58:20 |",
+            "|                     |",
+            "+---------------------+",
         ];
         check_datetime!(Date64Array, 1111111100000, expected);
     }
@@ -503,7 +539,7 @@ mod tests {
     }
 
     #[test]
-    fn test_int_display() -> Result<()> {
+    fn test_int_display() {
         let array = Arc::new(Int32Array::from(vec![6, 3])) as ArrayRef;
         let actual_one = array_value_to_string(&array, 0).unwrap();
         let expected_one = "6";
@@ -512,11 +548,10 @@ mod tests {
         let expected_two = "3";
         assert_eq!(actual_one, expected_one);
         assert_eq!(actual_two, expected_two);
-        Ok(())
     }
 
     #[test]
-    fn test_decimal_display() -> Result<()> {
+    fn test_decimal_display() {
         let precision = 10;
         let scale = 2;
 
@@ -534,9 +569,9 @@ mod tests {
             true,
         )]));
 
-        let batch = RecordBatch::try_new(schema, vec![dm])?;
+        let batch = RecordBatch::try_new(schema, vec![dm]).unwrap();
 
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
 
         let expected = vec![
             "+-------+",
@@ -550,13 +585,11 @@ mod tests {
         ];
 
         let actual: Vec<&str> = table.lines().collect();
-        assert_eq!(expected, actual, "Actual result:\n{}", table);
-
-        Ok(())
+        assert_eq!(expected, actual, "Actual result:\n{table}");
     }
 
     #[test]
-    fn test_decimal_display_zero_scale() -> Result<()> {
+    fn test_decimal_display_zero_scale() {
         let precision = 5;
         let scale = 0;
 
@@ -574,33 +607,31 @@ mod tests {
             true,
         )]));
 
-        let batch = RecordBatch::try_new(schema, vec![dm])?;
+        let batch = RecordBatch::try_new(schema, vec![dm]).unwrap();
 
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
         let expected = vec![
-            "+------+", "| f    |", "+------+", "| 101  |", "|      |", "| 200  |",
-            "| 3040 |", "+------+",
+            "+------+", "| f    |", "+------+", "| 101  |", "|      |", "| 200  |", "| 3040 |",
+            "+------+",
         ];
 
         let actual: Vec<&str> = table.lines().collect();
-        assert_eq!(expected, actual, "Actual result:\n{}", table);
-
-        Ok(())
+        assert_eq!(expected, actual, "Actual result:\n{table}");
     }
 
     #[test]
-    fn test_pretty_format_struct() -> Result<()> {
+    fn test_pretty_format_struct() {
         let schema = Schema::new(vec![
-            Field::new(
+            Field::new_struct(
                 "c1",
-                DataType::Struct(vec![
-                    Field::new("c11", DataType::Int32, false),
-                    Field::new(
+                vec![
+                    Field::new("c11", DataType::Int32, true),
+                    Field::new_struct(
                         "c12",
-                        DataType::Struct(vec![Field::new("c121", DataType::Utf8, false)]),
+                        vec![Field::new("c121", DataType::Utf8, false)],
                         false,
                     ),
-                ]),
+                ],
                 false,
             ),
             Field::new("c2", DataType::Utf8, false),
@@ -608,70 +639,62 @@ mod tests {
 
         let c1 = StructArray::from(vec![
             (
-                Field::new("c11", DataType::Int32, false),
+                Arc::new(Field::new("c11", DataType::Int32, true)),
                 Arc::new(Int32Array::from(vec![Some(1), None, Some(5)])) as ArrayRef,
             ),
             (
-                Field::new(
+                Arc::new(Field::new_struct(
                     "c12",
-                    DataType::Struct(vec![Field::new("c121", DataType::Utf8, false)]),
+                    vec![Field::new("c121", DataType::Utf8, false)],
                     false,
-                ),
+                )),
                 Arc::new(StructArray::from(vec![(
-                    Field::new("c121", DataType::Utf8, false),
-                    Arc::new(StringArray::from(vec![Some("e"), Some("f"), Some("g")]))
-                        as ArrayRef,
+                    Arc::new(Field::new("c121", DataType::Utf8, false)),
+                    Arc::new(StringArray::from(vec![Some("e"), Some("f"), Some("g")])) as ArrayRef,
                 )])) as ArrayRef,
             ),
         ]);
         let c2 = StringArray::from(vec![Some("a"), Some("b"), Some("c")]);
 
         let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)])
-                .unwrap();
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)]).unwrap();
 
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
         let expected = vec![
-            r#"+-------------------------------------+----+"#,
-            r#"| c1                                  | c2 |"#,
-            r#"+-------------------------------------+----+"#,
-            r#"| {"c11": 1, "c12": {"c121": "e"}}    | a  |"#,
-            r#"| {"c11": null, "c12": {"c121": "f"}} | b  |"#,
-            r#"| {"c11": 5, "c12": {"c121": "g"}}    | c  |"#,
-            r#"+-------------------------------------+----+"#,
+            "+--------------------------+----+",
+            "| c1                       | c2 |",
+            "+--------------------------+----+",
+            "| {c11: 1, c12: {c121: e}} | a  |",
+            "| {c11: , c12: {c121: f}}  | b  |",
+            "| {c11: 5, c12: {c121: g}} | c  |",
+            "+--------------------------+----+",
         ];
 
         let actual: Vec<&str> = table.lines().collect();
-        assert_eq!(expected, actual, "Actual result:\n{}", table);
-
-        Ok(())
+        assert_eq!(expected, actual, "Actual result:\n{table}");
     }
 
     #[test]
-    fn test_pretty_format_dense_union() -> Result<()> {
-        let mut builder = UnionBuilder::new_dense(4);
+    fn test_pretty_format_dense_union() {
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append::<Float64Type>("b", 3.2234).unwrap();
         builder.append_null::<Float64Type>("b").unwrap();
         builder.append_null::<Int32Type>("a").unwrap();
         let union = builder.build().unwrap();
 
-        let schema = Schema::new(vec![Field::new(
+        let schema = Schema::new(vec![Field::new_union(
             "Teamsters",
-            DataType::Union(
-                vec![
-                    Field::new("a", DataType::Int32, false),
-                    Field::new("b", DataType::Float64, false),
-                ],
-                vec![0, 1],
-                UnionMode::Dense,
-            ),
-            false,
+            vec![0, 1],
+            vec![
+                Field::new("a", DataType::Int32, false),
+                Field::new("b", DataType::Float64, false),
+            ],
+            UnionMode::Dense,
         )]);
 
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(union)]).unwrap();
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(union)]).unwrap();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
         let actual: Vec<&str> = table.lines().collect();
         let expected = vec![
             "+------------+",
@@ -685,34 +708,29 @@ mod tests {
         ];
 
         assert_eq!(expected, actual);
-        Ok(())
     }
 
     #[test]
-    fn test_pretty_format_sparse_union() -> Result<()> {
-        let mut builder = UnionBuilder::new_sparse(4);
+    fn test_pretty_format_sparse_union() {
+        let mut builder = UnionBuilder::new_sparse();
         builder.append::<Int32Type>("a", 1).unwrap();
         builder.append::<Float64Type>("b", 3.2234).unwrap();
         builder.append_null::<Float64Type>("b").unwrap();
         builder.append_null::<Int32Type>("a").unwrap();
         let union = builder.build().unwrap();
 
-        let schema = Schema::new(vec![Field::new(
+        let schema = Schema::new(vec![Field::new_union(
             "Teamsters",
-            DataType::Union(
-                vec![
-                    Field::new("a", DataType::Int32, false),
-                    Field::new("b", DataType::Float64, false),
-                ],
-                vec![0, 1],
-                UnionMode::Sparse,
-            ),
-            false,
+            vec![0, 1],
+            vec![
+                Field::new("a", DataType::Int32, false),
+                Field::new("b", DataType::Float64, false),
+            ],
+            UnionMode::Sparse,
         )]);
 
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(union)]).unwrap();
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(union)]).unwrap();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
         let actual: Vec<&str> = table.lines().collect();
         let expected = vec![
             "+------------+",
@@ -726,13 +744,12 @@ mod tests {
         ];
 
         assert_eq!(expected, actual);
-        Ok(())
     }
 
     #[test]
-    fn test_pretty_format_nested_union() -> Result<()> {
+    fn test_pretty_format_nested_union() {
         //Inner UnionArray
-        let mut builder = UnionBuilder::new_dense(5);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("b", 1).unwrap();
         builder.append::<Float64Type>("c", 3.2234).unwrap();
         builder.append_null::<Float64Type>("c").unwrap();
@@ -740,22 +757,19 @@ mod tests {
         builder.append_null::<Float64Type>("c").unwrap();
         let inner = builder.build().unwrap();
 
-        let inner_field = Field::new(
+        let inner_field = Field::new_union(
             "European Union",
-            DataType::Union(
-                vec![
-                    Field::new("b", DataType::Int32, false),
-                    Field::new("c", DataType::Float64, false),
-                ],
-                vec![0, 1],
-                UnionMode::Dense,
-            ),
-            false,
+            vec![0, 1],
+            vec![
+                Field::new("b", DataType::Int32, false),
+                Field::new("c", DataType::Float64, false),
+            ],
+            UnionMode::Dense,
         );
 
         // Can't use UnionBuilder with non-primitive types, so manually build outer UnionArray
         let a_array = Int32Array::from(vec![None, None, None, Some(1234), Some(23)]);
-        let type_ids = Buffer::from_slice_ref(&[1_i8, 1, 0, 0, 1]);
+        let type_ids = Buffer::from_slice_ref([1_i8, 1, 0, 0, 1]);
 
         let children: Vec<(Field, Arc<dyn Array>)> = vec![
             (Field::new("a", DataType::Int32, true), Arc::new(a_array)),
@@ -764,19 +778,15 @@ mod tests {
 
         let outer = UnionArray::try_new(&[0, 1], type_ids, None, children).unwrap();
 
-        let schema = Schema::new(vec![Field::new(
+        let schema = Schema::new(vec![Field::new_union(
             "Teamsters",
-            DataType::Union(
-                vec![Field::new("a", DataType::Int32, true), inner_field],
-                vec![0, 1],
-                UnionMode::Sparse,
-            ),
-            false,
+            vec![0, 1],
+            vec![Field::new("a", DataType::Int32, true), inner_field],
+            UnionMode::Sparse,
         )]);
 
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(outer)]).unwrap();
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(outer)]).unwrap();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
         let actual: Vec<&str> = table.lines().collect();
         let expected = vec![
             "+-----------------------------+",
@@ -790,11 +800,10 @@ mod tests {
             "+-----------------------------+",
         ];
         assert_eq!(expected, actual);
-        Ok(())
     }
 
     #[test]
-    fn test_writing_formatted_batches() -> Result<()> {
+    fn test_writing_formatted_batches() {
         // define a schema.
         let schema = Arc::new(Schema::new(vec![
             Field::new("a", DataType::Utf8, true),
@@ -818,12 +827,13 @@ mod tests {
                     Some(100),
                 ])),
             ],
-        )?;
+        )
+        .unwrap();
 
         let mut buf = String::new();
-        write!(&mut buf, "{}", pretty_format_batches(&[batch])?).unwrap();
+        write!(&mut buf, "{}", pretty_format_batches(&[batch]).unwrap()).unwrap();
 
-        let s = vec![
+        let s = [
             "+---+-----+",
             "| a | b   |",
             "+---+-----+",
@@ -835,12 +845,10 @@ mod tests {
         ];
         let expected = s.join("\n");
         assert_eq!(expected, buf);
-
-        Ok(())
     }
 
     #[test]
-    fn test_float16_display() -> Result<()> {
+    fn test_float16_display() {
         let values = vec![
             Some(f16::from_f32(f32::NAN)),
             Some(f16::from_f32(4.0)),
@@ -854,18 +862,144 @@ mod tests {
             true,
         )]));
 
-        let batch = RecordBatch::try_new(schema, vec![array])?;
+        let batch = RecordBatch::try_new(schema, vec![array]).unwrap();
 
-        let table = pretty_format_batches(&[batch])?.to_string();
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
 
         let expected = vec![
-            "+------+", "| f16  |", "+------+", "| NaN  |", "| 4    |", "| -inf |",
-            "+------+",
+            "+------+", "| f16  |", "+------+", "| NaN  |", "| 4    |", "| -inf |", "+------+",
         ];
 
         let actual: Vec<&str> = table.lines().collect();
-        assert_eq!(expected, actual, "Actual result:\n{}", table);
+        assert_eq!(expected, actual, "Actual result:\n{table}");
+    }
+
+    #[test]
+    fn test_pretty_format_interval_day_time() {
+        let arr = Arc::new(arrow_array::IntervalDayTimeArray::from(vec![
+            Some(-600000),
+            Some(4294966295),
+            Some(4294967295),
+            Some(1),
+            Some(10),
+            Some(100),
+        ]));
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "IntervalDayTime",
+            arr.data_type().clone(),
+            true,
+        )]));
+
+        let batch = RecordBatch::try_new(schema, vec![arr]).unwrap();
+
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
+
+        let expected = vec![
+            "+----------------------------------------------------+",
+            "| IntervalDayTime                                    |",
+            "+----------------------------------------------------+",
+            "| 0 years 0 mons -1 days 0 hours -10 mins 0.000 secs |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins -1.001 secs   |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins -0.001 secs   |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.001 secs    |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.010 secs    |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.100 secs    |",
+            "+----------------------------------------------------+",
+        ];
+
+        let actual: Vec<&str> = table.lines().collect();
+
+        assert_eq!(expected, actual, "Actual result:\n{table}");
+    }
+
+    #[test]
+    fn test_pretty_format_interval_month_day_nano_array() {
+        let arr = Arc::new(arrow_array::IntervalMonthDayNanoArray::from(vec![
+            Some(-600000000000),
+            Some(18446744072709551615),
+            Some(18446744073709551615),
+            Some(1),
+            Some(10),
+            Some(100),
+            Some(1_000),
+            Some(10_000),
+            Some(100_000),
+            Some(1_000_000),
+            Some(10_000_000),
+            Some(100_000_000),
+            Some(1_000_000_000),
+        ]));
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "IntervalMonthDayNano",
+            arr.data_type().clone(),
+            true,
+        )]));
+
+        let batch = RecordBatch::try_new(schema, vec![arr]).unwrap();
+
+        let table = pretty_format_batches(&[batch]).unwrap().to_string();
+
+        let expected = vec![
+            "+-----------------------------------------------------------+",
+            "| IntervalMonthDayNano                                      |",
+            "+-----------------------------------------------------------+",
+            "| 0 years -1 mons -1 days 0 hours -10 mins 0.000000000 secs |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins -1.000000001 secs    |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins -0.000000001 secs    |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.000000001 secs     |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.000000010 secs     |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.000000100 secs     |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.000001000 secs     |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.000010000 secs     |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.000100000 secs     |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.001000000 secs     |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.010000000 secs     |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 0.100000000 secs     |",
+            "| 0 years 0 mons 0 days 0 hours 0 mins 1.000000000 secs     |",
+            "+-----------------------------------------------------------+",
+        ];
+
+        let actual: Vec<&str> = table.lines().collect();
+
+        assert_eq!(expected, actual, "Actual result:\n{table}");
+    }
+
+    #[test]
+    fn test_format_options() {
+        let options = FormatOptions::default().with_null("null");
+        let array = Int32Array::from(vec![Some(1), Some(2), None, Some(3), Some(4)]);
+        let batch = RecordBatch::try_from_iter([("my_column_name", Arc::new(array) as _)]).unwrap();
+
+        let column = pretty_format_columns_with_options(
+            "my_column_name",
+            &[batch.column(0).clone()],
+            &options,
+        )
+        .unwrap()
+        .to_string();
+
+        let batch = pretty_format_batches_with_options(&[batch], &options)
+            .unwrap()
+            .to_string();
+
+        let expected = vec![
+            "+----------------+",
+            "| my_column_name |",
+            "+----------------+",
+            "| 1              |",
+            "| 2              |",
+            "| null           |",
+            "| 3              |",
+            "| 4              |",
+            "+----------------+",
+        ];
+
+        let actual: Vec<&str> = column.lines().collect();
+        assert_eq!(expected, actual, "Actual result:\n{column}");
 
-        Ok(())
+        let actual: Vec<&str> = batch.lines().collect();
+        assert_eq!(expected, actual, "Actual result:\n{batch}");
     }
 }
diff --git a/arrow-csv/Cargo.toml b/arrow-csv/Cargo.toml
new file mode 100644
index 000000000000..d29c85c56cfd
--- /dev/null
+++ b/arrow-csv/Cargo.toml
@@ -0,0 +1,53 @@
+# 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]
+name = "arrow-csv"
+version = { workspace = true }
+description = "Support for parsing CSV format to and from the Arrow format"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_csv"
+path = "src/lib.rs"
+bench = false
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-cast = { workspace = true }
+arrow-data = { workspace = true }
+arrow-schema = { workspace = true }
+chrono = { workspace = true }
+csv = { version = "1.1", default-features = false }
+csv-core = { version = "0.1" }
+lazy_static = { version = "1.4", default-features = false }
+lexical-core = { version = "^0.8", default-features = false }
+regex = { version = "1.7.0", default-features = false, features = ["std", "unicode", "perf"] }
+
+[dev-dependencies]
+tempfile = "3.3"
+futures = "0.3"
+tokio = { version = "1.27", default-features = false, features = ["io-util"] }
+bytes = "1.4"
diff --git a/arrow-csv/examples/README.md b/arrow-csv/examples/README.md
new file mode 100644
index 000000000000..340413e76d94
--- /dev/null
+++ b/arrow-csv/examples/README.md
@@ -0,0 +1,21 @@
+<!---
+  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.
+-->
+
+# Examples
+- [`csv_calculation.rs`](csv_calculation.rs): performs a simple calculation using the CSV reader
\ No newline at end of file
diff --git a/arrow-csv/examples/csv_calculation.rs b/arrow-csv/examples/csv_calculation.rs
new file mode 100644
index 000000000000..6ce963e2b012
--- /dev/null
+++ b/arrow-csv/examples/csv_calculation.rs
@@ -0,0 +1,56 @@
+// 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.
+
+use arrow_array::cast::AsArray;
+use arrow_array::types::Int16Type;
+use arrow_csv::ReaderBuilder;
+
+use arrow_schema::{DataType, Field, Schema};
+use std::fs::File;
+use std::sync::Arc;
+
+fn main() {
+    // read csv from file
+    let file = File::open("arrow-csv/test/data/example.csv").unwrap();
+    let csv_schema = Schema::new(vec![
+        Field::new("c1", DataType::Int16, true),
+        Field::new("c2", DataType::Float32, true),
+        Field::new("c3", DataType::Utf8, true),
+        Field::new("c4", DataType::Boolean, true),
+    ]);
+    let mut reader = ReaderBuilder::new(Arc::new(csv_schema))
+        .with_header(true)
+        .build(file)
+        .unwrap();
+
+    match reader.next() {
+        Some(r) => match r {
+            Ok(r) => {
+                // get the column(0) max value
+                let col = r.column(0).as_primitive::<Int16Type>();
+                let max = col.iter().max().flatten();
+                println!("max value column(0): {max:?}")
+            }
+            Err(e) => {
+                println!("{e:?}");
+            }
+        },
+        None => {
+            println!("csv is empty");
+        }
+    }
+}
diff --git a/arrow-csv/src/lib.rs b/arrow-csv/src/lib.rs
new file mode 100644
index 000000000000..e6dc69935199
--- /dev/null
+++ b/arrow-csv/src/lib.rs
@@ -0,0 +1,44 @@
+// 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.
+
+//! Transfer data between the Arrow memory format and CSV (comma-separated values).
+
+pub mod reader;
+pub mod writer;
+
+pub use self::reader::infer_schema_from_files;
+pub use self::reader::Reader;
+pub use self::reader::ReaderBuilder;
+pub use self::writer::Writer;
+pub use self::writer::WriterBuilder;
+use arrow_schema::ArrowError;
+
+fn map_csv_error(error: csv::Error) -> ArrowError {
+    match error.kind() {
+        csv::ErrorKind::Io(error) => ArrowError::CsvError(error.to_string()),
+        csv::ErrorKind::Utf8 { pos: _, err } => ArrowError::CsvError(format!(
+            "Encountered UTF-8 error while reading CSV file: {err}"
+        )),
+        csv::ErrorKind::UnequalLengths {
+            expected_len, len, ..
+        } => ArrowError::CsvError(format!(
+            "Encountered unequal lengths between records on CSV file. Expected {len} \
+                 records, found {expected_len} records"
+        )),
+        _ => ArrowError::CsvError("Error reading CSV file".to_string()),
+    }
+}
diff --git a/arrow-csv/src/reader/mod.rs b/arrow-csv/src/reader/mod.rs
new file mode 100644
index 000000000000..83c8965fdf8a
--- /dev/null
+++ b/arrow-csv/src/reader/mod.rs
@@ -0,0 +1,2359 @@
+// 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.
+
+//! CSV Reader
+//!
+//! # Basic Usage
+//!
+//! This CSV reader allows CSV files to be read into the Arrow memory model. Records are
+//! loaded in batches and are then converted from row-based data to columnar data.
+//!
+//! Example:
+//!
+//! ```
+//! # use arrow_schema::*;
+//! # use arrow_csv::{Reader, ReaderBuilder};
+//! # use std::fs::File;
+//! # use std::sync::Arc;
+//!
+//! let schema = Schema::new(vec![
+//!     Field::new("city", DataType::Utf8, false),
+//!     Field::new("lat", DataType::Float64, false),
+//!     Field::new("lng", DataType::Float64, false),
+//! ]);
+//!
+//! let file = File::open("test/data/uk_cities.csv").unwrap();
+//!
+//! let mut csv = ReaderBuilder::new(Arc::new(schema)).build(file).unwrap();
+//! let batch = csv.next().unwrap().unwrap();
+//! ```
+//!
+//! # Async Usage
+//!
+//! The lower-level [`Decoder`] can be integrated with various forms of async data streams,
+//! and is designed to be agnostic to the various different kinds of async IO primitives found
+//! within the Rust ecosystem.
+//!
+//! For example, see below for how it can be used with an arbitrary `Stream` of `Bytes`
+//!
+//! ```
+//! # use std::task::{Poll, ready};
+//! # use bytes::{Buf, Bytes};
+//! # use arrow_schema::ArrowError;
+//! # use futures::stream::{Stream, StreamExt};
+//! # use arrow_array::RecordBatch;
+//! # use arrow_csv::reader::Decoder;
+//! #
+//! fn decode_stream<S: Stream<Item = Bytes> + Unpin>(
+//!     mut decoder: Decoder,
+//!     mut input: S,
+//! ) -> impl Stream<Item = Result<RecordBatch, ArrowError>> {
+//!     let mut buffered = Bytes::new();
+//!     futures::stream::poll_fn(move |cx| {
+//!         loop {
+//!             if buffered.is_empty() {
+//!                 if let Some(b) = ready!(input.poll_next_unpin(cx)) {
+//!                     buffered = b;
+//!                 }
+//!                 // Note: don't break on `None` as the decoder needs
+//!                 // to be called with an empty array to delimit the
+//!                 // final record
+//!             }
+//!             let decoded = match decoder.decode(buffered.as_ref()) {
+//!                 Ok(0) => break,
+//!                 Ok(decoded) => decoded,
+//!                 Err(e) => return Poll::Ready(Some(Err(e))),
+//!             };
+//!             buffered.advance(decoded);
+//!         }
+//!
+//!         Poll::Ready(decoder.flush().transpose())
+//!     })
+//! }
+//!
+//! ```
+//!
+//! In a similar vein, it can also be used with tokio-based IO primitives
+//!
+//! ```
+//! # use std::pin::Pin;
+//! # use std::task::{Poll, ready};
+//! # use futures::Stream;
+//! # use tokio::io::AsyncBufRead;
+//! # use arrow_array::RecordBatch;
+//! # use arrow_csv::reader::Decoder;
+//! # use arrow_schema::ArrowError;
+//! fn decode_stream<R: AsyncBufRead + Unpin>(
+//!     mut decoder: Decoder,
+//!     mut reader: R,
+//! ) -> impl Stream<Item = Result<RecordBatch, ArrowError>> {
+//!     futures::stream::poll_fn(move |cx| {
+//!         loop {
+//!             let b = match ready!(Pin::new(&mut reader).poll_fill_buf(cx)) {
+//!                 Ok(b) => b,
+//!                 Err(e) => return Poll::Ready(Some(Err(e.into()))),
+//!             };
+//!             let decoded = match decoder.decode(b) {
+//!                 // Note: the decoder needs to be called with an empty
+//!                 // array to delimit the final record
+//!                 Ok(0) => break,
+//!                 Ok(decoded) => decoded,
+//!                 Err(e) => return Poll::Ready(Some(Err(e))),
+//!             };
+//!             Pin::new(&mut reader).consume(decoded);
+//!         }
+//!
+//!         Poll::Ready(decoder.flush().transpose())
+//!     })
+//! }
+//! ```
+//!
+
+mod records;
+
+use arrow_array::builder::PrimitiveBuilder;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_cast::parse::{parse_decimal, string_to_datetime, Parser};
+use arrow_schema::*;
+use chrono::{TimeZone, Utc};
+use csv::StringRecord;
+use lazy_static::lazy_static;
+use regex::{Regex, RegexSet};
+use std::fmt::{self, Debug};
+use std::fs::File;
+use std::io::{BufRead, BufReader as StdBufReader, Read, Seek, SeekFrom};
+use std::sync::Arc;
+
+use crate::map_csv_error;
+use crate::reader::records::{RecordDecoder, StringRecords};
+use arrow_array::timezone::Tz;
+
+lazy_static! {
+    /// Order should match [`InferredDataType`]
+    static ref REGEX_SET: RegexSet = RegexSet::new([
+        r"(?i)^(true)$|^(false)$(?-i)", //BOOLEAN
+        r"^-?(\d+)$", //INTEGER
+        r"^-?((\d*\.\d+|\d+\.\d*)([eE]-?\d+)?|\d+([eE]-?\d+))$", //DECIMAL
+        r"^\d{4}-\d\d-\d\d$", //DATE32
+        r"^\d{4}-\d\d-\d\d[T ]\d\d:\d\d:\d\d(?:[^\d\.].*)?$", //Timestamp(Second)
+        r"^\d{4}-\d\d-\d\d[T ]\d\d:\d\d:\d\d\.\d{1,3}(?:[^\d].*)?$", //Timestamp(Millisecond)
+        r"^\d{4}-\d\d-\d\d[T ]\d\d:\d\d:\d\d\.\d{1,6}(?:[^\d].*)?$", //Timestamp(Microsecond)
+        r"^\d{4}-\d\d-\d\d[T ]\d\d:\d\d:\d\d\.\d{1,9}(?:[^\d].*)?$", //Timestamp(Nanosecond)
+    ]).unwrap();
+}
+
+/// A wrapper over `Option<Regex>` to check if the value is `NULL`.
+#[derive(Debug, Clone, Default)]
+struct NullRegex(Option<Regex>);
+
+impl NullRegex {
+    /// Returns true if the value should be considered as `NULL` according to
+    /// the provided regular expression.
+    #[inline]
+    fn is_null(&self, s: &str) -> bool {
+        match &self.0 {
+            Some(r) => r.is_match(s),
+            None => s.is_empty(),
+        }
+    }
+}
+
+#[derive(Default, Copy, Clone)]
+struct InferredDataType {
+    /// Packed booleans indicating type
+    ///
+    /// 0 - Boolean
+    /// 1 - Integer
+    /// 2 - Float64
+    /// 3 - Date32
+    /// 4 - Timestamp(Second)
+    /// 5 - Timestamp(Millisecond)
+    /// 6 - Timestamp(Microsecond)
+    /// 7 - Timestamp(Nanosecond)
+    /// 8 - Utf8
+    packed: u16,
+}
+
+impl InferredDataType {
+    /// Returns the inferred data type
+    fn get(&self) -> DataType {
+        match self.packed {
+            0 => DataType::Null,
+            1 => DataType::Boolean,
+            2 => DataType::Int64,
+            4 | 6 => DataType::Float64, // Promote Int64 to Float64
+            b if b != 0 && (b & !0b11111000) == 0 => match b.leading_zeros() {
+                // Promote to highest precision temporal type
+                8 => DataType::Timestamp(TimeUnit::Nanosecond, None),
+                9 => DataType::Timestamp(TimeUnit::Microsecond, None),
+                10 => DataType::Timestamp(TimeUnit::Millisecond, None),
+                11 => DataType::Timestamp(TimeUnit::Second, None),
+                12 => DataType::Date32,
+                _ => unreachable!(),
+            },
+            _ => DataType::Utf8,
+        }
+    }
+
+    /// Updates the [`InferredDataType`] with the given string
+    fn update(&mut self, string: &str) {
+        self.packed |= if string.starts_with('"') {
+            1 << 8 // Utf8
+        } else if let Some(m) = REGEX_SET.matches(string).into_iter().next() {
+            1 << m
+        } else {
+            1 << 8 // Utf8
+        }
+    }
+}
+
+/// The format specification for the CSV file
+#[derive(Debug, Clone, Default)]
+pub struct Format {
+    header: bool,
+    delimiter: Option<u8>,
+    escape: Option<u8>,
+    quote: Option<u8>,
+    terminator: Option<u8>,
+    null_regex: NullRegex,
+}
+
+impl Format {
+    pub fn with_header(mut self, has_header: bool) -> Self {
+        self.header = has_header;
+        self
+    }
+
+    pub fn with_delimiter(mut self, delimiter: u8) -> Self {
+        self.delimiter = Some(delimiter);
+        self
+    }
+
+    pub fn with_escape(mut self, escape: u8) -> Self {
+        self.escape = Some(escape);
+        self
+    }
+
+    pub fn with_quote(mut self, quote: u8) -> Self {
+        self.quote = Some(quote);
+        self
+    }
+
+    pub fn with_terminator(mut self, terminator: u8) -> Self {
+        self.terminator = Some(terminator);
+        self
+    }
+
+    /// Provide a regex to match null values, defaults to `^$`
+    pub fn with_null_regex(mut self, null_regex: Regex) -> Self {
+        self.null_regex = NullRegex(Some(null_regex));
+        self
+    }
+
+    /// Infer schema of CSV records from the provided `reader`
+    ///
+    /// If `max_records` is `None`, all records will be read, otherwise up to `max_records`
+    /// records are read to infer the schema
+    ///
+    /// Returns inferred schema and number of records read
+    pub fn infer_schema<R: Read>(
+        &self,
+        reader: R,
+        max_records: Option<usize>,
+    ) -> Result<(Schema, usize), ArrowError> {
+        let mut csv_reader = self.build_reader(reader);
+
+        // get or create header names
+        // when has_header is false, creates default column names with column_ prefix
+        let headers: Vec<String> = if self.header {
+            let headers = &csv_reader.headers().map_err(map_csv_error)?.clone();
+            headers.iter().map(|s| s.to_string()).collect()
+        } else {
+            let first_record_count = &csv_reader.headers().map_err(map_csv_error)?.len();
+            (0..*first_record_count)
+                .map(|i| format!("column_{}", i + 1))
+                .collect()
+        };
+
+        let header_length = headers.len();
+        // keep track of inferred field types
+        let mut column_types: Vec<InferredDataType> = vec![Default::default(); header_length];
+
+        let mut records_count = 0;
+
+        let mut record = StringRecord::new();
+        let max_records = max_records.unwrap_or(usize::MAX);
+        while records_count < max_records {
+            if !csv_reader.read_record(&mut record).map_err(map_csv_error)? {
+                break;
+            }
+            records_count += 1;
+
+            // Note since we may be looking at a sample of the data, we make the safe assumption that
+            // they could be nullable
+            for (i, column_type) in column_types.iter_mut().enumerate().take(header_length) {
+                if let Some(string) = record.get(i) {
+                    if !self.null_regex.is_null(string) {
+                        column_type.update(string)
+                    }
+                }
+            }
+        }
+
+        // build schema from inference results
+        let fields: Fields = column_types
+            .iter()
+            .zip(&headers)
+            .map(|(inferred, field_name)| Field::new(field_name, inferred.get(), true))
+            .collect();
+
+        Ok((Schema::new(fields), records_count))
+    }
+
+    /// Build a [`csv::Reader`] for this [`Format`]
+    fn build_reader<R: Read>(&self, reader: R) -> csv::Reader<R> {
+        let mut builder = csv::ReaderBuilder::new();
+        builder.has_headers(self.header);
+
+        if let Some(c) = self.delimiter {
+            builder.delimiter(c);
+        }
+        builder.escape(self.escape);
+        if let Some(c) = self.quote {
+            builder.quote(c);
+        }
+        if let Some(t) = self.terminator {
+            builder.terminator(csv::Terminator::Any(t));
+        }
+        builder.from_reader(reader)
+    }
+
+    /// Build a [`csv_core::Reader`] for this [`Format`]
+    fn build_parser(&self) -> csv_core::Reader {
+        let mut builder = csv_core::ReaderBuilder::new();
+        builder.escape(self.escape);
+
+        if let Some(c) = self.delimiter {
+            builder.delimiter(c);
+        }
+        if let Some(c) = self.quote {
+            builder.quote(c);
+        }
+        if let Some(t) = self.terminator {
+            builder.terminator(csv_core::Terminator::Any(t));
+        }
+        builder.build()
+    }
+}
+
+/// Infer the schema of a CSV file by reading through the first n records of the file,
+/// with `max_read_records` controlling the maximum number of records to read.
+///
+/// If `max_read_records` is not set, the whole file is read to infer its schema.
+///
+/// Return inferred schema and number of records used for inference. This function does not change
+/// reader cursor offset.
+///
+/// The inferred schema will always have each field set as nullable.
+#[deprecated(note = "Use Format::infer_schema")]
+#[allow(deprecated)]
+pub fn infer_file_schema<R: Read + Seek>(
+    mut reader: R,
+    delimiter: u8,
+    max_read_records: Option<usize>,
+    has_header: bool,
+) -> Result<(Schema, usize), ArrowError> {
+    let saved_offset = reader.stream_position()?;
+    let r = infer_reader_schema(&mut reader, delimiter, max_read_records, has_header)?;
+    // return the reader seek back to the start
+    reader.seek(SeekFrom::Start(saved_offset))?;
+    Ok(r)
+}
+
+/// Infer schema of CSV records provided by struct that implements `Read` trait.
+///
+/// `max_read_records` controlling the maximum number of records to read. If `max_read_records` is
+/// not set, all records are read to infer the schema.
+///
+/// Return inferred schema and number of records used for inference.
+#[deprecated(note = "Use Format::infer_schema")]
+pub fn infer_reader_schema<R: Read>(
+    reader: R,
+    delimiter: u8,
+    max_read_records: Option<usize>,
+    has_header: bool,
+) -> Result<(Schema, usize), ArrowError> {
+    let format = Format {
+        delimiter: Some(delimiter),
+        header: has_header,
+        ..Default::default()
+    };
+    format.infer_schema(reader, max_read_records)
+}
+
+/// Infer schema from a list of CSV files by reading through first n records
+/// with `max_read_records` controlling the maximum number of records to read.
+///
+/// Files will be read in the given order until n records have been reached.
+///
+/// If `max_read_records` is not set, all files will be read fully to infer the schema.
+pub fn infer_schema_from_files(
+    files: &[String],
+    delimiter: u8,
+    max_read_records: Option<usize>,
+    has_header: bool,
+) -> Result<Schema, ArrowError> {
+    let mut schemas = vec![];
+    let mut records_to_read = max_read_records.unwrap_or(usize::MAX);
+    let format = Format {
+        delimiter: Some(delimiter),
+        header: has_header,
+        ..Default::default()
+    };
+
+    for fname in files.iter() {
+        let f = File::open(fname)?;
+        let (schema, records_read) = format.infer_schema(f, Some(records_to_read))?;
+        if records_read == 0 {
+            continue;
+        }
+        schemas.push(schema.clone());
+        records_to_read -= records_read;
+        if records_to_read == 0 {
+            break;
+        }
+    }
+
+    Schema::try_merge(schemas)
+}
+
+// optional bounds of the reader, of the form (min line, max line).
+type Bounds = Option<(usize, usize)>;
+
+/// CSV file reader using [`std::io::BufReader`]
+pub type Reader<R> = BufReader<StdBufReader<R>>;
+
+/// CSV file reader
+pub struct BufReader<R> {
+    /// File reader
+    reader: R,
+
+    /// The decoder
+    decoder: Decoder,
+}
+
+impl<R> fmt::Debug for BufReader<R>
+where
+    R: BufRead,
+{
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("Reader")
+            .field("decoder", &self.decoder)
+            .finish()
+    }
+}
+
+impl<R: Read> Reader<R> {
+    /// Returns the schema of the reader, useful for getting the schema without reading
+    /// record batches
+    pub fn schema(&self) -> SchemaRef {
+        match &self.decoder.projection {
+            Some(projection) => {
+                let fields = self.decoder.schema.fields();
+                let projected = projection.iter().map(|i| fields[*i].clone());
+                Arc::new(Schema::new(projected.collect::<Fields>()))
+            }
+            None => self.decoder.schema.clone(),
+        }
+    }
+}
+
+impl<R: BufRead> BufReader<R> {
+    fn read(&mut self) -> Result<Option<RecordBatch>, ArrowError> {
+        loop {
+            let buf = self.reader.fill_buf()?;
+            let decoded = self.decoder.decode(buf)?;
+            self.reader.consume(decoded);
+            // Yield if decoded no bytes or the decoder is full
+            //
+            // The capacity check avoids looping around and potentially
+            // blocking reading data in fill_buf that isn't needed
+            // to flush the next batch
+            if decoded == 0 || self.decoder.capacity() == 0 {
+                break;
+            }
+        }
+
+        self.decoder.flush()
+    }
+}
+
+impl<R: BufRead> Iterator for BufReader<R> {
+    type Item = Result<RecordBatch, ArrowError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.read().transpose()
+    }
+}
+
+impl<R: BufRead> RecordBatchReader for BufReader<R> {
+    fn schema(&self) -> SchemaRef {
+        self.decoder.schema.clone()
+    }
+}
+
+/// A push-based interface for decoding CSV data from an arbitrary byte stream
+///
+/// See [`Reader`] for a higher-level interface for interface with [`Read`]
+///
+/// The push-based interface facilitates integration with sources that yield arbitrarily
+/// delimited bytes ranges, such as [`BufRead`], or a chunked byte stream received from
+/// object storage
+///
+/// ```
+/// # use std::io::BufRead;
+/// # use arrow_array::RecordBatch;
+/// # use arrow_csv::ReaderBuilder;
+/// # use arrow_schema::{ArrowError, SchemaRef};
+/// #
+/// fn read_from_csv<R: BufRead>(
+///     mut reader: R,
+///     schema: SchemaRef,
+///     batch_size: usize,
+/// ) -> Result<impl Iterator<Item = Result<RecordBatch, ArrowError>>, ArrowError> {
+///     let mut decoder = ReaderBuilder::new(schema)
+///         .with_batch_size(batch_size)
+///         .build_decoder();
+///
+///     let mut next = move || {
+///         loop {
+///             let buf = reader.fill_buf()?;
+///             let decoded = decoder.decode(buf)?;
+///             if decoded == 0 {
+///                 break;
+///             }
+///
+///             // Consume the number of bytes read
+///             reader.consume(decoded);
+///         }
+///         decoder.flush()
+///     };
+///     Ok(std::iter::from_fn(move || next().transpose()))
+/// }
+/// ```
+#[derive(Debug)]
+pub struct Decoder {
+    /// Explicit schema for the CSV file
+    schema: SchemaRef,
+
+    /// Optional projection for which columns to load (zero-based column indices)
+    projection: Option<Vec<usize>>,
+
+    /// Number of records per batch
+    batch_size: usize,
+
+    /// Rows to skip
+    to_skip: usize,
+
+    /// Current line number
+    line_number: usize,
+
+    /// End line number
+    end: usize,
+
+    /// A decoder for [`StringRecords`]
+    record_decoder: RecordDecoder,
+
+    /// Check if the string matches this pattern for `NULL`.
+    null_regex: NullRegex,
+}
+
+impl Decoder {
+    /// Decode records from `buf` returning the number of bytes read
+    ///
+    /// This method returns once `batch_size` objects have been parsed since the
+    /// last call to [`Self::flush`], or `buf` is exhausted. Any remaining bytes
+    /// should be included in the next call to [`Self::decode`]
+    ///
+    /// There is no requirement that `buf` contains a whole number of records, facilitating
+    /// integration with arbitrary byte streams, such as that yielded by [`BufRead`] or
+    /// network sources such as object storage
+    pub fn decode(&mut self, buf: &[u8]) -> Result<usize, ArrowError> {
+        if self.to_skip != 0 {
+            // Skip in units of `to_read` to avoid over-allocating buffers
+            let to_skip = self.to_skip.min(self.batch_size);
+            let (skipped, bytes) = self.record_decoder.decode(buf, to_skip)?;
+            self.to_skip -= skipped;
+            self.record_decoder.clear();
+            return Ok(bytes);
+        }
+
+        let to_read = self.batch_size.min(self.end - self.line_number) - self.record_decoder.len();
+        let (_, bytes) = self.record_decoder.decode(buf, to_read)?;
+        Ok(bytes)
+    }
+
+    /// Flushes the currently buffered data to a [`RecordBatch`]
+    ///
+    /// This should only be called after [`Self::decode`] has returned `Ok(0)`,
+    /// otherwise may return an error if part way through decoding a record
+    ///
+    /// Returns `Ok(None)` if no buffered data
+    pub fn flush(&mut self) -> Result<Option<RecordBatch>, ArrowError> {
+        if self.record_decoder.is_empty() {
+            return Ok(None);
+        }
+
+        let rows = self.record_decoder.flush()?;
+        let batch = parse(
+            &rows,
+            self.schema.fields(),
+            Some(self.schema.metadata.clone()),
+            self.projection.as_ref(),
+            self.line_number,
+            &self.null_regex,
+        )?;
+        self.line_number += rows.len();
+        Ok(Some(batch))
+    }
+
+    /// Returns the number of records that can be read before requiring a call to [`Self::flush`]
+    pub fn capacity(&self) -> usize {
+        self.batch_size - self.record_decoder.len()
+    }
+}
+
+/// Parses a slice of [`StringRecords`] into a [RecordBatch]
+fn parse(
+    rows: &StringRecords<'_>,
+    fields: &Fields,
+    metadata: Option<std::collections::HashMap<String, String>>,
+    projection: Option<&Vec<usize>>,
+    line_number: usize,
+    null_regex: &NullRegex,
+) -> Result<RecordBatch, ArrowError> {
+    let projection: Vec<usize> = match projection {
+        Some(v) => v.clone(),
+        None => fields.iter().enumerate().map(|(i, _)| i).collect(),
+    };
+
+    let arrays: Result<Vec<ArrayRef>, _> = projection
+        .iter()
+        .map(|i| {
+            let i = *i;
+            let field = &fields[i];
+            match field.data_type() {
+                DataType::Boolean => build_boolean_array(line_number, rows, i, null_regex),
+                DataType::Decimal128(precision, scale) => build_decimal_array::<Decimal128Type>(
+                    line_number,
+                    rows,
+                    i,
+                    *precision,
+                    *scale,
+                    null_regex,
+                ),
+                DataType::Decimal256(precision, scale) => build_decimal_array::<Decimal256Type>(
+                    line_number,
+                    rows,
+                    i,
+                    *precision,
+                    *scale,
+                    null_regex,
+                ),
+                DataType::Int8 => {
+                    build_primitive_array::<Int8Type>(line_number, rows, i, null_regex)
+                }
+                DataType::Int16 => {
+                    build_primitive_array::<Int16Type>(line_number, rows, i, null_regex)
+                }
+                DataType::Int32 => {
+                    build_primitive_array::<Int32Type>(line_number, rows, i, null_regex)
+                }
+                DataType::Int64 => {
+                    build_primitive_array::<Int64Type>(line_number, rows, i, null_regex)
+                }
+                DataType::UInt8 => {
+                    build_primitive_array::<UInt8Type>(line_number, rows, i, null_regex)
+                }
+                DataType::UInt16 => {
+                    build_primitive_array::<UInt16Type>(line_number, rows, i, null_regex)
+                }
+                DataType::UInt32 => {
+                    build_primitive_array::<UInt32Type>(line_number, rows, i, null_regex)
+                }
+                DataType::UInt64 => {
+                    build_primitive_array::<UInt64Type>(line_number, rows, i, null_regex)
+                }
+                DataType::Float32 => {
+                    build_primitive_array::<Float32Type>(line_number, rows, i, null_regex)
+                }
+                DataType::Float64 => {
+                    build_primitive_array::<Float64Type>(line_number, rows, i, null_regex)
+                }
+                DataType::Date32 => {
+                    build_primitive_array::<Date32Type>(line_number, rows, i, null_regex)
+                }
+                DataType::Date64 => {
+                    build_primitive_array::<Date64Type>(line_number, rows, i, null_regex)
+                }
+                DataType::Time32(TimeUnit::Second) => {
+                    build_primitive_array::<Time32SecondType>(line_number, rows, i, null_regex)
+                }
+                DataType::Time32(TimeUnit::Millisecond) => {
+                    build_primitive_array::<Time32MillisecondType>(line_number, rows, i, null_regex)
+                }
+                DataType::Time64(TimeUnit::Microsecond) => {
+                    build_primitive_array::<Time64MicrosecondType>(line_number, rows, i, null_regex)
+                }
+                DataType::Time64(TimeUnit::Nanosecond) => {
+                    build_primitive_array::<Time64NanosecondType>(line_number, rows, i, null_regex)
+                }
+                DataType::Timestamp(TimeUnit::Second, tz) => {
+                    build_timestamp_array::<TimestampSecondType>(
+                        line_number,
+                        rows,
+                        i,
+                        tz.as_deref(),
+                        null_regex,
+                    )
+                }
+                DataType::Timestamp(TimeUnit::Millisecond, tz) => {
+                    build_timestamp_array::<TimestampMillisecondType>(
+                        line_number,
+                        rows,
+                        i,
+                        tz.as_deref(),
+                        null_regex,
+                    )
+                }
+                DataType::Timestamp(TimeUnit::Microsecond, tz) => {
+                    build_timestamp_array::<TimestampMicrosecondType>(
+                        line_number,
+                        rows,
+                        i,
+                        tz.as_deref(),
+                        null_regex,
+                    )
+                }
+                DataType::Timestamp(TimeUnit::Nanosecond, tz) => {
+                    build_timestamp_array::<TimestampNanosecondType>(
+                        line_number,
+                        rows,
+                        i,
+                        tz.as_deref(),
+                        null_regex,
+                    )
+                }
+                DataType::Null => Ok(Arc::new(NullArray::builder(rows.len()).finish()) as ArrayRef),
+                DataType::Utf8 => Ok(Arc::new(
+                    rows.iter()
+                        .map(|row| {
+                            let s = row.get(i);
+                            (!null_regex.is_null(s)).then_some(s)
+                        })
+                        .collect::<StringArray>(),
+                ) as ArrayRef),
+                DataType::Dictionary(key_type, value_type)
+                    if value_type.as_ref() == &DataType::Utf8 =>
+                {
+                    match key_type.as_ref() {
+                        DataType::Int8 => Ok(Arc::new(
+                            rows.iter()
+                                .map(|row| row.get(i))
+                                .collect::<DictionaryArray<Int8Type>>(),
+                        ) as ArrayRef),
+                        DataType::Int16 => Ok(Arc::new(
+                            rows.iter()
+                                .map(|row| row.get(i))
+                                .collect::<DictionaryArray<Int16Type>>(),
+                        ) as ArrayRef),
+                        DataType::Int32 => Ok(Arc::new(
+                            rows.iter()
+                                .map(|row| row.get(i))
+                                .collect::<DictionaryArray<Int32Type>>(),
+                        ) as ArrayRef),
+                        DataType::Int64 => Ok(Arc::new(
+                            rows.iter()
+                                .map(|row| row.get(i))
+                                .collect::<DictionaryArray<Int64Type>>(),
+                        ) as ArrayRef),
+                        DataType::UInt8 => Ok(Arc::new(
+                            rows.iter()
+                                .map(|row| row.get(i))
+                                .collect::<DictionaryArray<UInt8Type>>(),
+                        ) as ArrayRef),
+                        DataType::UInt16 => Ok(Arc::new(
+                            rows.iter()
+                                .map(|row| row.get(i))
+                                .collect::<DictionaryArray<UInt16Type>>(),
+                        ) as ArrayRef),
+                        DataType::UInt32 => Ok(Arc::new(
+                            rows.iter()
+                                .map(|row| row.get(i))
+                                .collect::<DictionaryArray<UInt32Type>>(),
+                        ) as ArrayRef),
+                        DataType::UInt64 => Ok(Arc::new(
+                            rows.iter()
+                                .map(|row| row.get(i))
+                                .collect::<DictionaryArray<UInt64Type>>(),
+                        ) as ArrayRef),
+                        _ => Err(ArrowError::ParseError(format!(
+                            "Unsupported dictionary key type {key_type:?}"
+                        ))),
+                    }
+                }
+                other => Err(ArrowError::ParseError(format!(
+                    "Unsupported data type {other:?}"
+                ))),
+            }
+        })
+        .collect();
+
+    let projected_fields: Fields = projection.iter().map(|i| fields[*i].clone()).collect();
+
+    let projected_schema = Arc::new(match metadata {
+        None => Schema::new(projected_fields),
+        Some(metadata) => Schema::new_with_metadata(projected_fields, metadata),
+    });
+
+    arrays.and_then(|arr| {
+        RecordBatch::try_new_with_options(
+            projected_schema,
+            arr,
+            &RecordBatchOptions::new()
+                .with_match_field_names(true)
+                .with_row_count(Some(rows.len())),
+        )
+    })
+}
+
+fn parse_bool(string: &str) -> Option<bool> {
+    if string.eq_ignore_ascii_case("false") {
+        Some(false)
+    } else if string.eq_ignore_ascii_case("true") {
+        Some(true)
+    } else {
+        None
+    }
+}
+
+// parse the column string to an Arrow Array
+fn build_decimal_array<T: DecimalType>(
+    _line_number: usize,
+    rows: &StringRecords<'_>,
+    col_idx: usize,
+    precision: u8,
+    scale: i8,
+    null_regex: &NullRegex,
+) -> Result<ArrayRef, ArrowError> {
+    let mut decimal_builder = PrimitiveBuilder::<T>::with_capacity(rows.len());
+    for row in rows.iter() {
+        let s = row.get(col_idx);
+        if null_regex.is_null(s) {
+            // append null
+            decimal_builder.append_null();
+        } else {
+            let decimal_value: Result<T::Native, _> = parse_decimal::<T>(s, precision, scale);
+            match decimal_value {
+                Ok(v) => {
+                    decimal_builder.append_value(v);
+                }
+                Err(e) => {
+                    return Err(e);
+                }
+            }
+        }
+    }
+    Ok(Arc::new(
+        decimal_builder
+            .finish()
+            .with_precision_and_scale(precision, scale)?,
+    ))
+}
+
+// parses a specific column (col_idx) into an Arrow Array.
+fn build_primitive_array<T: ArrowPrimitiveType + Parser>(
+    line_number: usize,
+    rows: &StringRecords<'_>,
+    col_idx: usize,
+    null_regex: &NullRegex,
+) -> Result<ArrayRef, ArrowError> {
+    rows.iter()
+        .enumerate()
+        .map(|(row_index, row)| {
+            let s = row.get(col_idx);
+            if null_regex.is_null(s) {
+                return Ok(None);
+            }
+
+            match T::parse(s) {
+                Some(e) => Ok(Some(e)),
+                None => Err(ArrowError::ParseError(format!(
+                    // TODO: we should surface the underlying error here.
+                    "Error while parsing value {} for column {} at line {}",
+                    s,
+                    col_idx,
+                    line_number + row_index
+                ))),
+            }
+        })
+        .collect::<Result<PrimitiveArray<T>, ArrowError>>()
+        .map(|e| Arc::new(e) as ArrayRef)
+}
+
+fn build_timestamp_array<T: ArrowTimestampType>(
+    line_number: usize,
+    rows: &StringRecords<'_>,
+    col_idx: usize,
+    timezone: Option<&str>,
+    null_regex: &NullRegex,
+) -> Result<ArrayRef, ArrowError> {
+    Ok(Arc::new(match timezone {
+        Some(timezone) => {
+            let tz: Tz = timezone.parse()?;
+            build_timestamp_array_impl::<T, _>(line_number, rows, col_idx, &tz, null_regex)?
+                .with_timezone(timezone)
+        }
+        None => build_timestamp_array_impl::<T, _>(line_number, rows, col_idx, &Utc, null_regex)?,
+    }))
+}
+
+fn build_timestamp_array_impl<T: ArrowTimestampType, Tz: TimeZone>(
+    line_number: usize,
+    rows: &StringRecords<'_>,
+    col_idx: usize,
+    timezone: &Tz,
+    null_regex: &NullRegex,
+) -> Result<PrimitiveArray<T>, ArrowError> {
+    rows.iter()
+        .enumerate()
+        .map(|(row_index, row)| {
+            let s = row.get(col_idx);
+            if null_regex.is_null(s) {
+                return Ok(None);
+            }
+
+            let date = string_to_datetime(timezone, s)
+                .and_then(|date| match T::UNIT {
+                    TimeUnit::Second => Ok(date.timestamp()),
+                    TimeUnit::Millisecond => Ok(date.timestamp_millis()),
+                    TimeUnit::Microsecond => Ok(date.timestamp_micros()),
+                    TimeUnit::Nanosecond => date.timestamp_nanos_opt().ok_or_else(|| {
+                        ArrowError::ParseError(format!(
+                            "{} would overflow 64-bit signed nanoseconds",
+                            date.to_rfc3339(),
+                        ))
+                    }),
+                })
+                .map_err(|e| {
+                    ArrowError::ParseError(format!(
+                        "Error parsing column {col_idx} at line {}: {}",
+                        line_number + row_index,
+                        e
+                    ))
+                })?;
+            Ok(Some(date))
+        })
+        .collect()
+}
+
+// parses a specific column (col_idx) into an Arrow Array.
+fn build_boolean_array(
+    line_number: usize,
+    rows: &StringRecords<'_>,
+    col_idx: usize,
+    null_regex: &NullRegex,
+) -> Result<ArrayRef, ArrowError> {
+    rows.iter()
+        .enumerate()
+        .map(|(row_index, row)| {
+            let s = row.get(col_idx);
+            if null_regex.is_null(s) {
+                return Ok(None);
+            }
+            let parsed = parse_bool(s);
+            match parsed {
+                Some(e) => Ok(Some(e)),
+                None => Err(ArrowError::ParseError(format!(
+                    // TODO: we should surface the underlying error here.
+                    "Error while parsing value {} for column {} at line {}",
+                    s,
+                    col_idx,
+                    line_number + row_index
+                ))),
+            }
+        })
+        .collect::<Result<BooleanArray, _>>()
+        .map(|e| Arc::new(e) as ArrayRef)
+}
+
+/// CSV file reader builder
+#[derive(Debug)]
+pub struct ReaderBuilder {
+    /// Schema of the CSV file
+    schema: SchemaRef,
+    /// Format of the CSV file
+    format: Format,
+    /// Batch size (number of records to load each time)
+    ///
+    /// The default batch size when using the `ReaderBuilder` is 1024 records
+    batch_size: usize,
+    /// The bounds over which to scan the reader. `None` starts from 0 and runs until EOF.
+    bounds: Bounds,
+    /// Optional projection for which columns to load (zero-based column indices)
+    projection: Option<Vec<usize>>,
+}
+
+impl ReaderBuilder {
+    /// Create a new builder for configuring CSV parsing options.
+    ///
+    /// To convert a builder into a reader, call `ReaderBuilder::build`
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use arrow_csv::{Reader, ReaderBuilder};
+    /// # use std::fs::File;
+    /// # use std::io::Seek;
+    /// # use std::sync::Arc;
+    /// # use arrow_csv::reader::Format;
+    /// #
+    /// let mut file = File::open("test/data/uk_cities_with_headers.csv").unwrap();
+    /// // Infer the schema with the first 100 records
+    /// let (schema, _) = Format::default().infer_schema(&mut file, Some(100)).unwrap();
+    /// file.rewind().unwrap();
+    ///
+    /// // create a builder
+    /// ReaderBuilder::new(Arc::new(schema)).build(file).unwrap();
+    /// ```
+    pub fn new(schema: SchemaRef) -> ReaderBuilder {
+        Self {
+            schema,
+            format: Format::default(),
+            batch_size: 1024,
+            bounds: None,
+            projection: None,
+        }
+    }
+
+    /// Set whether the CSV file has headers
+    #[deprecated(note = "Use with_header")]
+    #[doc(hidden)]
+    pub fn has_header(mut self, has_header: bool) -> Self {
+        self.format.header = has_header;
+        self
+    }
+
+    /// Set whether the CSV file has a header
+    pub fn with_header(mut self, has_header: bool) -> Self {
+        self.format.header = has_header;
+        self
+    }
+
+    /// Overrides the [`Format`] of this [`ReaderBuilder]
+    pub fn with_format(mut self, format: Format) -> Self {
+        self.format = format;
+        self
+    }
+
+    /// Set the CSV file's column delimiter as a byte character
+    pub fn with_delimiter(mut self, delimiter: u8) -> Self {
+        self.format.delimiter = Some(delimiter);
+        self
+    }
+
+    pub fn with_escape(mut self, escape: u8) -> Self {
+        self.format.escape = Some(escape);
+        self
+    }
+
+    pub fn with_quote(mut self, quote: u8) -> Self {
+        self.format.quote = Some(quote);
+        self
+    }
+
+    pub fn with_terminator(mut self, terminator: u8) -> Self {
+        self.format.terminator = Some(terminator);
+        self
+    }
+
+    /// Provide a regex to match null values, defaults to `^$`
+    pub fn with_null_regex(mut self, null_regex: Regex) -> Self {
+        self.format.null_regex = NullRegex(Some(null_regex));
+        self
+    }
+
+    /// Set the batch size (number of records to load at one time)
+    pub fn with_batch_size(mut self, batch_size: usize) -> Self {
+        self.batch_size = batch_size;
+        self
+    }
+
+    /// Set the bounds over which to scan the reader.
+    /// `start` and `end` are line numbers.
+    pub fn with_bounds(mut self, start: usize, end: usize) -> Self {
+        self.bounds = Some((start, end));
+        self
+    }
+
+    /// Set the reader's column projection
+    pub fn with_projection(mut self, projection: Vec<usize>) -> Self {
+        self.projection = Some(projection);
+        self
+    }
+
+    /// Create a new `Reader` from a non-buffered reader
+    ///
+    /// If `R: BufRead` consider using [`Self::build_buffered`] to avoid unnecessary additional
+    /// buffering, as internally this method wraps `reader` in [`std::io::BufReader`]
+    pub fn build<R: Read>(self, reader: R) -> Result<Reader<R>, ArrowError> {
+        self.build_buffered(StdBufReader::new(reader))
+    }
+
+    /// Create a new `BufReader` from a buffered reader
+    pub fn build_buffered<R: BufRead>(self, reader: R) -> Result<BufReader<R>, ArrowError> {
+        Ok(BufReader {
+            reader,
+            decoder: self.build_decoder(),
+        })
+    }
+
+    /// Builds a decoder that can be used to decode CSV from an arbitrary byte stream
+    pub fn build_decoder(self) -> Decoder {
+        let delimiter = self.format.build_parser();
+        let record_decoder = RecordDecoder::new(delimiter, self.schema.fields().len());
+
+        let header = self.format.header as usize;
+
+        let (start, end) = match self.bounds {
+            Some((start, end)) => (start + header, end + header),
+            None => (header, usize::MAX),
+        };
+
+        Decoder {
+            schema: self.schema,
+            to_skip: start,
+            record_decoder,
+            line_number: start,
+            end,
+            projection: self.projection,
+            batch_size: self.batch_size,
+            null_regex: self.format.null_regex,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::io::{Cursor, Write};
+    use tempfile::NamedTempFile;
+
+    use arrow_array::cast::AsArray;
+
+    #[test]
+    fn test_csv() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("city", DataType::Utf8, false),
+            Field::new("lat", DataType::Float64, false),
+            Field::new("lng", DataType::Float64, false),
+        ]));
+
+        let file = File::open("test/data/uk_cities.csv").unwrap();
+        let mut csv = ReaderBuilder::new(schema.clone()).build(file).unwrap();
+        assert_eq!(schema, csv.schema());
+        let batch = csv.next().unwrap().unwrap();
+        assert_eq!(37, batch.num_rows());
+        assert_eq!(3, batch.num_columns());
+
+        // access data from a primitive array
+        let lat = batch.column(1).as_primitive::<Float64Type>();
+        assert_eq!(57.653484, lat.value(0));
+
+        // access data from a string array (ListArray<u8>)
+        let city = batch.column(0).as_string::<i32>();
+
+        assert_eq!("Aberdeen, Aberdeen City, UK", city.value(13));
+    }
+
+    #[test]
+    fn test_csv_schema_metadata() {
+        let mut metadata = std::collections::HashMap::new();
+        metadata.insert("foo".to_owned(), "bar".to_owned());
+        let schema = Arc::new(Schema::new_with_metadata(
+            vec![
+                Field::new("city", DataType::Utf8, false),
+                Field::new("lat", DataType::Float64, false),
+                Field::new("lng", DataType::Float64, false),
+            ],
+            metadata.clone(),
+        ));
+
+        let file = File::open("test/data/uk_cities.csv").unwrap();
+
+        let mut csv = ReaderBuilder::new(schema.clone()).build(file).unwrap();
+        assert_eq!(schema, csv.schema());
+        let batch = csv.next().unwrap().unwrap();
+        assert_eq!(37, batch.num_rows());
+        assert_eq!(3, batch.num_columns());
+
+        assert_eq!(&metadata, batch.schema().metadata());
+    }
+
+    #[test]
+    fn test_csv_reader_with_decimal() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("city", DataType::Utf8, false),
+            Field::new("lat", DataType::Decimal128(38, 6), false),
+            Field::new("lng", DataType::Decimal256(76, 6), false),
+        ]));
+
+        let file = File::open("test/data/decimal_test.csv").unwrap();
+
+        let mut csv = ReaderBuilder::new(schema).build(file).unwrap();
+        let batch = csv.next().unwrap().unwrap();
+        // access data from a primitive array
+        let lat = batch
+            .column(1)
+            .as_any()
+            .downcast_ref::<Decimal128Array>()
+            .unwrap();
+
+        assert_eq!("57.653484", lat.value_as_string(0));
+        assert_eq!("53.002666", lat.value_as_string(1));
+        assert_eq!("52.412811", lat.value_as_string(2));
+        assert_eq!("51.481583", lat.value_as_string(3));
+        assert_eq!("12.123456", lat.value_as_string(4));
+        assert_eq!("50.760000", lat.value_as_string(5));
+        assert_eq!("0.123000", lat.value_as_string(6));
+        assert_eq!("123.000000", lat.value_as_string(7));
+        assert_eq!("123.000000", lat.value_as_string(8));
+        assert_eq!("-50.760000", lat.value_as_string(9));
+
+        let lng = batch
+            .column(2)
+            .as_any()
+            .downcast_ref::<Decimal256Array>()
+            .unwrap();
+
+        assert_eq!("-3.335724", lng.value_as_string(0));
+        assert_eq!("-2.179404", lng.value_as_string(1));
+        assert_eq!("-1.778197", lng.value_as_string(2));
+        assert_eq!("-3.179090", lng.value_as_string(3));
+        assert_eq!("-3.179090", lng.value_as_string(4));
+        assert_eq!("0.290472", lng.value_as_string(5));
+        assert_eq!("0.290472", lng.value_as_string(6));
+        assert_eq!("0.290472", lng.value_as_string(7));
+        assert_eq!("0.290472", lng.value_as_string(8));
+        assert_eq!("0.290472", lng.value_as_string(9));
+    }
+
+    #[test]
+    fn test_csv_from_buf_reader() {
+        let schema = Schema::new(vec![
+            Field::new("city", DataType::Utf8, false),
+            Field::new("lat", DataType::Float64, false),
+            Field::new("lng", DataType::Float64, false),
+        ]);
+
+        let file_with_headers = File::open("test/data/uk_cities_with_headers.csv").unwrap();
+        let file_without_headers = File::open("test/data/uk_cities.csv").unwrap();
+        let both_files = file_with_headers
+            .chain(Cursor::new("\n".to_string()))
+            .chain(file_without_headers);
+        let mut csv = ReaderBuilder::new(Arc::new(schema))
+            .with_header(true)
+            .build(both_files)
+            .unwrap();
+        let batch = csv.next().unwrap().unwrap();
+        assert_eq!(74, batch.num_rows());
+        assert_eq!(3, batch.num_columns());
+    }
+
+    #[test]
+    fn test_csv_with_schema_inference() {
+        let mut file = File::open("test/data/uk_cities_with_headers.csv").unwrap();
+
+        let (schema, _) = Format::default()
+            .with_header(true)
+            .infer_schema(&mut file, None)
+            .unwrap();
+
+        file.rewind().unwrap();
+        let builder = ReaderBuilder::new(Arc::new(schema)).with_header(true);
+
+        let mut csv = builder.build(file).unwrap();
+        let expected_schema = Schema::new(vec![
+            Field::new("city", DataType::Utf8, true),
+            Field::new("lat", DataType::Float64, true),
+            Field::new("lng", DataType::Float64, true),
+        ]);
+        assert_eq!(Arc::new(expected_schema), csv.schema());
+        let batch = csv.next().unwrap().unwrap();
+        assert_eq!(37, batch.num_rows());
+        assert_eq!(3, batch.num_columns());
+
+        // access data from a primitive array
+        let lat = batch
+            .column(1)
+            .as_any()
+            .downcast_ref::<Float64Array>()
+            .unwrap();
+        assert_eq!(57.653484, lat.value(0));
+
+        // access data from a string array (ListArray<u8>)
+        let city = batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+
+        assert_eq!("Aberdeen, Aberdeen City, UK", city.value(13));
+    }
+
+    #[test]
+    fn test_csv_with_schema_inference_no_headers() {
+        let mut file = File::open("test/data/uk_cities.csv").unwrap();
+
+        let (schema, _) = Format::default().infer_schema(&mut file, None).unwrap();
+        file.rewind().unwrap();
+
+        let mut csv = ReaderBuilder::new(Arc::new(schema)).build(file).unwrap();
+
+        // csv field names should be 'column_{number}'
+        let schema = csv.schema();
+        assert_eq!("column_1", schema.field(0).name());
+        assert_eq!("column_2", schema.field(1).name());
+        assert_eq!("column_3", schema.field(2).name());
+        let batch = csv.next().unwrap().unwrap();
+        let batch_schema = batch.schema();
+
+        assert_eq!(schema, batch_schema);
+        assert_eq!(37, batch.num_rows());
+        assert_eq!(3, batch.num_columns());
+
+        // access data from a primitive array
+        let lat = batch
+            .column(1)
+            .as_any()
+            .downcast_ref::<Float64Array>()
+            .unwrap();
+        assert_eq!(57.653484, lat.value(0));
+
+        // access data from a string array (ListArray<u8>)
+        let city = batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+
+        assert_eq!("Aberdeen, Aberdeen City, UK", city.value(13));
+    }
+
+    #[test]
+    fn test_csv_builder_with_bounds() {
+        let mut file = File::open("test/data/uk_cities.csv").unwrap();
+
+        // Set the bounds to the lines 0, 1 and 2.
+        let (schema, _) = Format::default().infer_schema(&mut file, None).unwrap();
+        file.rewind().unwrap();
+        let mut csv = ReaderBuilder::new(Arc::new(schema))
+            .with_bounds(0, 2)
+            .build(file)
+            .unwrap();
+        let batch = csv.next().unwrap().unwrap();
+
+        // access data from a string array (ListArray<u8>)
+        let city = batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .unwrap();
+
+        // The value on line 0 is within the bounds
+        assert_eq!("Elgin, Scotland, the UK", city.value(0));
+
+        // The value on line 13 is outside of the bounds. Therefore
+        // the call to .value() will panic.
+        let result = std::panic::catch_unwind(|| city.value(13));
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_csv_with_projection() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("city", DataType::Utf8, false),
+            Field::new("lat", DataType::Float64, false),
+            Field::new("lng", DataType::Float64, false),
+        ]));
+
+        let file = File::open("test/data/uk_cities.csv").unwrap();
+
+        let mut csv = ReaderBuilder::new(schema)
+            .with_projection(vec![0, 1])
+            .build(file)
+            .unwrap();
+
+        let projected_schema = Arc::new(Schema::new(vec![
+            Field::new("city", DataType::Utf8, false),
+            Field::new("lat", DataType::Float64, false),
+        ]));
+        assert_eq!(projected_schema, csv.schema());
+        let batch = csv.next().unwrap().unwrap();
+        assert_eq!(projected_schema, batch.schema());
+        assert_eq!(37, batch.num_rows());
+        assert_eq!(2, batch.num_columns());
+    }
+
+    #[test]
+    fn test_csv_with_dictionary() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new_dictionary("city", DataType::Int32, DataType::Utf8, false),
+            Field::new("lat", DataType::Float64, false),
+            Field::new("lng", DataType::Float64, false),
+        ]));
+
+        let file = File::open("test/data/uk_cities.csv").unwrap();
+
+        let mut csv = ReaderBuilder::new(schema)
+            .with_projection(vec![0, 1])
+            .build(file)
+            .unwrap();
+
+        let projected_schema = Arc::new(Schema::new(vec![
+            Field::new_dictionary("city", DataType::Int32, DataType::Utf8, false),
+            Field::new("lat", DataType::Float64, false),
+        ]));
+        assert_eq!(projected_schema, csv.schema());
+        let batch = csv.next().unwrap().unwrap();
+        assert_eq!(projected_schema, batch.schema());
+        assert_eq!(37, batch.num_rows());
+        assert_eq!(2, batch.num_columns());
+
+        let strings = arrow_cast::cast(batch.column(0), &DataType::Utf8).unwrap();
+        let strings = strings.as_string::<i32>();
+
+        assert_eq!(strings.value(0), "Elgin, Scotland, the UK");
+        assert_eq!(strings.value(4), "Eastbourne, East Sussex, UK");
+        assert_eq!(strings.value(29), "Uckfield, East Sussex, UK");
+    }
+
+    #[test]
+    fn test_nulls() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("c_int", DataType::UInt64, false),
+            Field::new("c_float", DataType::Float32, true),
+            Field::new("c_string", DataType::Utf8, true),
+            Field::new("c_bool", DataType::Boolean, false),
+        ]));
+
+        let file = File::open("test/data/null_test.csv").unwrap();
+
+        let mut csv = ReaderBuilder::new(schema)
+            .with_header(true)
+            .build(file)
+            .unwrap();
+
+        let batch = csv.next().unwrap().unwrap();
+
+        assert!(!batch.column(1).is_null(0));
+        assert!(!batch.column(1).is_null(1));
+        assert!(batch.column(1).is_null(2));
+        assert!(!batch.column(1).is_null(3));
+        assert!(!batch.column(1).is_null(4));
+    }
+
+    #[test]
+    fn test_init_nulls() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("c_int", DataType::UInt64, true),
+            Field::new("c_float", DataType::Float32, true),
+            Field::new("c_string", DataType::Utf8, true),
+            Field::new("c_bool", DataType::Boolean, true),
+            Field::new("c_null", DataType::Null, true),
+        ]));
+        let file = File::open("test/data/init_null_test.csv").unwrap();
+
+        let mut csv = ReaderBuilder::new(schema)
+            .with_header(true)
+            .build(file)
+            .unwrap();
+
+        let batch = csv.next().unwrap().unwrap();
+
+        assert!(batch.column(1).is_null(0));
+        assert!(!batch.column(1).is_null(1));
+        assert!(batch.column(1).is_null(2));
+        assert!(!batch.column(1).is_null(3));
+        assert!(!batch.column(1).is_null(4));
+    }
+
+    #[test]
+    fn test_init_nulls_with_inference() {
+        let format = Format::default().with_header(true).with_delimiter(b',');
+
+        let mut file = File::open("test/data/init_null_test.csv").unwrap();
+        let (schema, _) = format.infer_schema(&mut file, None).unwrap();
+        file.rewind().unwrap();
+
+        let expected_schema = Schema::new(vec![
+            Field::new("c_int", DataType::Int64, true),
+            Field::new("c_float", DataType::Float64, true),
+            Field::new("c_string", DataType::Utf8, true),
+            Field::new("c_bool", DataType::Boolean, true),
+            Field::new("c_null", DataType::Null, true),
+        ]);
+        assert_eq!(schema, expected_schema);
+
+        let mut csv = ReaderBuilder::new(Arc::new(schema))
+            .with_format(format)
+            .build(file)
+            .unwrap();
+
+        let batch = csv.next().unwrap().unwrap();
+
+        assert!(batch.column(1).is_null(0));
+        assert!(!batch.column(1).is_null(1));
+        assert!(batch.column(1).is_null(2));
+        assert!(!batch.column(1).is_null(3));
+        assert!(!batch.column(1).is_null(4));
+    }
+
+    #[test]
+    fn test_custom_nulls() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("c_int", DataType::UInt64, true),
+            Field::new("c_float", DataType::Float32, true),
+            Field::new("c_string", DataType::Utf8, true),
+            Field::new("c_bool", DataType::Boolean, true),
+        ]));
+
+        let file = File::open("test/data/custom_null_test.csv").unwrap();
+
+        let null_regex = Regex::new("^nil$").unwrap();
+
+        let mut csv = ReaderBuilder::new(schema)
+            .with_header(true)
+            .with_null_regex(null_regex)
+            .build(file)
+            .unwrap();
+
+        let batch = csv.next().unwrap().unwrap();
+
+        // "nil"s should be NULL
+        assert!(batch.column(0).is_null(1));
+        assert!(batch.column(1).is_null(2));
+        assert!(batch.column(3).is_null(4));
+        assert!(batch.column(2).is_null(3));
+        assert!(!batch.column(2).is_null(4));
+    }
+
+    #[test]
+    fn test_nulls_with_inference() {
+        let mut file = File::open("test/data/various_types.csv").unwrap();
+        let format = Format::default().with_header(true).with_delimiter(b'|');
+
+        let (schema, _) = format.infer_schema(&mut file, None).unwrap();
+        file.rewind().unwrap();
+
+        let builder = ReaderBuilder::new(Arc::new(schema))
+            .with_format(format)
+            .with_batch_size(512)
+            .with_projection(vec![0, 1, 2, 3, 4, 5]);
+
+        let mut csv = builder.build(file).unwrap();
+        let batch = csv.next().unwrap().unwrap();
+
+        assert_eq!(7, batch.num_rows());
+        assert_eq!(6, batch.num_columns());
+
+        let schema = batch.schema();
+
+        assert_eq!(&DataType::Int64, schema.field(0).data_type());
+        assert_eq!(&DataType::Float64, schema.field(1).data_type());
+        assert_eq!(&DataType::Float64, schema.field(2).data_type());
+        assert_eq!(&DataType::Boolean, schema.field(3).data_type());
+        assert_eq!(&DataType::Date32, schema.field(4).data_type());
+        assert_eq!(
+            &DataType::Timestamp(TimeUnit::Second, None),
+            schema.field(5).data_type()
+        );
+
+        let names: Vec<&str> = schema.fields().iter().map(|x| x.name().as_str()).collect();
+        assert_eq!(
+            names,
+            vec![
+                "c_int",
+                "c_float",
+                "c_string",
+                "c_bool",
+                "c_date",
+                "c_datetime"
+            ]
+        );
+
+        assert!(schema.field(0).is_nullable());
+        assert!(schema.field(1).is_nullable());
+        assert!(schema.field(2).is_nullable());
+        assert!(schema.field(3).is_nullable());
+        assert!(schema.field(4).is_nullable());
+        assert!(schema.field(5).is_nullable());
+
+        assert!(!batch.column(1).is_null(0));
+        assert!(!batch.column(1).is_null(1));
+        assert!(batch.column(1).is_null(2));
+        assert!(!batch.column(1).is_null(3));
+        assert!(!batch.column(1).is_null(4));
+    }
+
+    #[test]
+    fn test_custom_nulls_with_inference() {
+        let mut file = File::open("test/data/custom_null_test.csv").unwrap();
+
+        let null_regex = Regex::new("^nil$").unwrap();
+
+        let format = Format::default()
+            .with_header(true)
+            .with_null_regex(null_regex);
+
+        let (schema, _) = format.infer_schema(&mut file, None).unwrap();
+        file.rewind().unwrap();
+
+        let expected_schema = Schema::new(vec![
+            Field::new("c_int", DataType::Int64, true),
+            Field::new("c_float", DataType::Float64, true),
+            Field::new("c_string", DataType::Utf8, true),
+            Field::new("c_bool", DataType::Boolean, true),
+        ]);
+
+        assert_eq!(schema, expected_schema);
+
+        let builder = ReaderBuilder::new(Arc::new(schema))
+            .with_format(format)
+            .with_batch_size(512)
+            .with_projection(vec![0, 1, 2, 3]);
+
+        let mut csv = builder.build(file).unwrap();
+        let batch = csv.next().unwrap().unwrap();
+
+        assert_eq!(5, batch.num_rows());
+        assert_eq!(4, batch.num_columns());
+
+        assert_eq!(batch.schema().as_ref(), &expected_schema);
+    }
+
+    #[test]
+    fn test_parse_invalid_csv() {
+        let file = File::open("test/data/various_types_invalid.csv").unwrap();
+
+        let schema = Schema::new(vec![
+            Field::new("c_int", DataType::UInt64, false),
+            Field::new("c_float", DataType::Float32, false),
+            Field::new("c_string", DataType::Utf8, false),
+            Field::new("c_bool", DataType::Boolean, false),
+        ]);
+
+        let builder = ReaderBuilder::new(Arc::new(schema))
+            .with_header(true)
+            .with_delimiter(b'|')
+            .with_batch_size(512)
+            .with_projection(vec![0, 1, 2, 3]);
+
+        let mut csv = builder.build(file).unwrap();
+        match csv.next() {
+            Some(e) => match e {
+                Err(e) => assert_eq!(
+                    "ParseError(\"Error while parsing value 4.x4 for column 1 at line 4\")",
+                    format!("{e:?}")
+                ),
+                Ok(_) => panic!("should have failed"),
+            },
+            None => panic!("should have failed"),
+        }
+    }
+
+    /// Infer the data type of a record
+    fn infer_field_schema(string: &str) -> DataType {
+        let mut v = InferredDataType::default();
+        v.update(string);
+        v.get()
+    }
+
+    #[test]
+    fn test_infer_field_schema() {
+        assert_eq!(infer_field_schema("A"), DataType::Utf8);
+        assert_eq!(infer_field_schema("\"123\""), DataType::Utf8);
+        assert_eq!(infer_field_schema("10"), DataType::Int64);
+        assert_eq!(infer_field_schema("10.2"), DataType::Float64);
+        assert_eq!(infer_field_schema(".2"), DataType::Float64);
+        assert_eq!(infer_field_schema("2."), DataType::Float64);
+        assert_eq!(infer_field_schema("true"), DataType::Boolean);
+        assert_eq!(infer_field_schema("trUe"), DataType::Boolean);
+        assert_eq!(infer_field_schema("false"), DataType::Boolean);
+        assert_eq!(infer_field_schema("2020-11-08"), DataType::Date32);
+        assert_eq!(
+            infer_field_schema("2020-11-08T14:20:01"),
+            DataType::Timestamp(TimeUnit::Second, None)
+        );
+        assert_eq!(
+            infer_field_schema("2020-11-08 14:20:01"),
+            DataType::Timestamp(TimeUnit::Second, None)
+        );
+        assert_eq!(
+            infer_field_schema("2020-11-08 14:20:01"),
+            DataType::Timestamp(TimeUnit::Second, None)
+        );
+        assert_eq!(infer_field_schema("-5.13"), DataType::Float64);
+        assert_eq!(infer_field_schema("0.1300"), DataType::Float64);
+        assert_eq!(
+            infer_field_schema("2021-12-19 13:12:30.921"),
+            DataType::Timestamp(TimeUnit::Millisecond, None)
+        );
+        assert_eq!(
+            infer_field_schema("2021-12-19T13:12:30.123456789"),
+            DataType::Timestamp(TimeUnit::Nanosecond, None)
+        );
+    }
+
+    #[test]
+    fn parse_date32() {
+        assert_eq!(Date32Type::parse("1970-01-01").unwrap(), 0);
+        assert_eq!(Date32Type::parse("2020-03-15").unwrap(), 18336);
+        assert_eq!(Date32Type::parse("1945-05-08").unwrap(), -9004);
+    }
+
+    #[test]
+    fn parse_time() {
+        assert_eq!(
+            Time64NanosecondType::parse("12:10:01.123456789 AM"),
+            Some(601_123_456_789)
+        );
+        assert_eq!(
+            Time64MicrosecondType::parse("12:10:01.123456 am"),
+            Some(601_123_456)
+        );
+        assert_eq!(
+            Time32MillisecondType::parse("2:10:01.12 PM"),
+            Some(51_001_120)
+        );
+        assert_eq!(Time32SecondType::parse("2:10:01 pm"), Some(51_001));
+    }
+
+    #[test]
+    fn parse_date64() {
+        assert_eq!(Date64Type::parse("1970-01-01T00:00:00").unwrap(), 0);
+        assert_eq!(
+            Date64Type::parse("2018-11-13T17:11:10").unwrap(),
+            1542129070000
+        );
+        assert_eq!(
+            Date64Type::parse("2018-11-13T17:11:10.011").unwrap(),
+            1542129070011
+        );
+        assert_eq!(
+            Date64Type::parse("1900-02-28T12:34:56").unwrap(),
+            -2203932304000
+        );
+        assert_eq!(
+            Date64Type::parse_formatted("1900-02-28 12:34:56", "%Y-%m-%d %H:%M:%S").unwrap(),
+            -2203932304000
+        );
+        assert_eq!(
+            Date64Type::parse_formatted("1900-02-28 12:34:56+0030", "%Y-%m-%d %H:%M:%S%z").unwrap(),
+            -2203932304000 - (30 * 60 * 1000)
+        );
+    }
+
+    fn test_parse_timestamp_impl<T: ArrowTimestampType>(
+        timezone: Option<Arc<str>>,
+        expected: &[i64],
+    ) {
+        let csv = [
+            "1970-01-01T00:00:00",
+            "1970-01-01T00:00:00Z",
+            "1970-01-01T00:00:00+02:00",
+        ]
+        .join("\n");
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "field",
+            DataType::Timestamp(T::UNIT, timezone.clone()),
+            true,
+        )]));
+
+        let mut decoder = ReaderBuilder::new(schema).build_decoder();
+
+        let decoded = decoder.decode(csv.as_bytes()).unwrap();
+        assert_eq!(decoded, csv.len());
+        decoder.decode(&[]).unwrap();
+
+        let batch = decoder.flush().unwrap().unwrap();
+        assert_eq!(batch.num_columns(), 1);
+        assert_eq!(batch.num_rows(), 3);
+        let col = batch.column(0).as_primitive::<T>();
+        assert_eq!(col.values(), expected);
+        assert_eq!(col.data_type(), &DataType::Timestamp(T::UNIT, timezone));
+    }
+
+    #[test]
+    fn test_parse_timestamp() {
+        test_parse_timestamp_impl::<TimestampNanosecondType>(None, &[0, 0, -7_200_000_000_000]);
+        test_parse_timestamp_impl::<TimestampNanosecondType>(
+            Some("+00:00".into()),
+            &[0, 0, -7_200_000_000_000],
+        );
+        test_parse_timestamp_impl::<TimestampNanosecondType>(
+            Some("-05:00".into()),
+            &[18_000_000_000_000, 0, -7_200_000_000_000],
+        );
+        test_parse_timestamp_impl::<TimestampMicrosecondType>(
+            Some("-03".into()),
+            &[10_800_000_000, 0, -7_200_000_000],
+        );
+        test_parse_timestamp_impl::<TimestampMillisecondType>(
+            Some("-03".into()),
+            &[10_800_000, 0, -7_200_000],
+        );
+        test_parse_timestamp_impl::<TimestampSecondType>(Some("-03".into()), &[10_800, 0, -7_200]);
+    }
+
+    #[test]
+    fn test_infer_schema_from_multiple_files() {
+        let mut csv1 = NamedTempFile::new().unwrap();
+        let mut csv2 = NamedTempFile::new().unwrap();
+        let csv3 = NamedTempFile::new().unwrap(); // empty csv file should be skipped
+        let mut csv4 = NamedTempFile::new().unwrap();
+        writeln!(csv1, "c1,c2,c3").unwrap();
+        writeln!(csv1, "1,\"foo\",0.5").unwrap();
+        writeln!(csv1, "3,\"bar\",1").unwrap();
+        writeln!(csv1, "3,\"bar\",2e-06").unwrap();
+        // reading csv2 will set c2 to optional
+        writeln!(csv2, "c1,c2,c3,c4").unwrap();
+        writeln!(csv2, "10,,3.14,true").unwrap();
+        // reading csv4 will set c3 to optional
+        writeln!(csv4, "c1,c2,c3").unwrap();
+        writeln!(csv4, "10,\"foo\",").unwrap();
+
+        let schema = infer_schema_from_files(
+            &[
+                csv3.path().to_str().unwrap().to_string(),
+                csv1.path().to_str().unwrap().to_string(),
+                csv2.path().to_str().unwrap().to_string(),
+                csv4.path().to_str().unwrap().to_string(),
+            ],
+            b',',
+            Some(4), // only csv1 and csv2 should be read
+            true,
+        )
+        .unwrap();
+
+        assert_eq!(schema.fields().len(), 4);
+        assert!(schema.field(0).is_nullable());
+        assert!(schema.field(1).is_nullable());
+        assert!(schema.field(2).is_nullable());
+        assert!(schema.field(3).is_nullable());
+
+        assert_eq!(&DataType::Int64, schema.field(0).data_type());
+        assert_eq!(&DataType::Utf8, schema.field(1).data_type());
+        assert_eq!(&DataType::Float64, schema.field(2).data_type());
+        assert_eq!(&DataType::Boolean, schema.field(3).data_type());
+    }
+
+    #[test]
+    fn test_bounded() {
+        let schema = Schema::new(vec![Field::new("int", DataType::UInt32, false)]);
+        let data = vec![
+            vec!["0"],
+            vec!["1"],
+            vec!["2"],
+            vec!["3"],
+            vec!["4"],
+            vec!["5"],
+            vec!["6"],
+        ];
+
+        let data = data
+            .iter()
+            .map(|x| x.join(","))
+            .collect::<Vec<_>>()
+            .join("\n");
+        let data = data.as_bytes();
+
+        let reader = std::io::Cursor::new(data);
+
+        let mut csv = ReaderBuilder::new(Arc::new(schema))
+            .with_batch_size(2)
+            .with_projection(vec![0])
+            .with_bounds(2, 6)
+            .build_buffered(reader)
+            .unwrap();
+
+        let batch = csv.next().unwrap().unwrap();
+        let a = batch.column(0);
+        let a = a.as_any().downcast_ref::<UInt32Array>().unwrap();
+        assert_eq!(a, &UInt32Array::from(vec![2, 3]));
+
+        let batch = csv.next().unwrap().unwrap();
+        let a = batch.column(0);
+        let a = a.as_any().downcast_ref::<UInt32Array>().unwrap();
+        assert_eq!(a, &UInt32Array::from(vec![4, 5]));
+
+        assert!(csv.next().is_none());
+    }
+
+    #[test]
+    fn test_empty_projection() {
+        let schema = Schema::new(vec![Field::new("int", DataType::UInt32, false)]);
+        let data = vec![vec!["0"], vec!["1"]];
+
+        let data = data
+            .iter()
+            .map(|x| x.join(","))
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        let mut csv = ReaderBuilder::new(Arc::new(schema))
+            .with_batch_size(2)
+            .with_projection(vec![])
+            .build_buffered(Cursor::new(data.as_bytes()))
+            .unwrap();
+
+        let batch = csv.next().unwrap().unwrap();
+        assert_eq!(batch.columns().len(), 0);
+        assert_eq!(batch.num_rows(), 2);
+
+        assert!(csv.next().is_none());
+    }
+
+    #[test]
+    fn test_parsing_bool() {
+        // Encode the expected behavior of boolean parsing
+        assert_eq!(Some(true), parse_bool("true"));
+        assert_eq!(Some(true), parse_bool("tRUe"));
+        assert_eq!(Some(true), parse_bool("True"));
+        assert_eq!(Some(true), parse_bool("TRUE"));
+        assert_eq!(None, parse_bool("t"));
+        assert_eq!(None, parse_bool("T"));
+        assert_eq!(None, parse_bool(""));
+
+        assert_eq!(Some(false), parse_bool("false"));
+        assert_eq!(Some(false), parse_bool("fALse"));
+        assert_eq!(Some(false), parse_bool("False"));
+        assert_eq!(Some(false), parse_bool("FALSE"));
+        assert_eq!(None, parse_bool("f"));
+        assert_eq!(None, parse_bool("F"));
+        assert_eq!(None, parse_bool(""));
+    }
+
+    #[test]
+    fn test_parsing_float() {
+        assert_eq!(Some(12.34), Float64Type::parse("12.34"));
+        assert_eq!(Some(-12.34), Float64Type::parse("-12.34"));
+        assert_eq!(Some(12.0), Float64Type::parse("12"));
+        assert_eq!(Some(0.0), Float64Type::parse("0"));
+        assert_eq!(Some(2.0), Float64Type::parse("2."));
+        assert_eq!(Some(0.2), Float64Type::parse(".2"));
+        assert!(Float64Type::parse("nan").unwrap().is_nan());
+        assert!(Float64Type::parse("NaN").unwrap().is_nan());
+        assert!(Float64Type::parse("inf").unwrap().is_infinite());
+        assert!(Float64Type::parse("inf").unwrap().is_sign_positive());
+        assert!(Float64Type::parse("-inf").unwrap().is_infinite());
+        assert!(Float64Type::parse("-inf").unwrap().is_sign_negative());
+        assert_eq!(None, Float64Type::parse(""));
+        assert_eq!(None, Float64Type::parse("dd"));
+        assert_eq!(None, Float64Type::parse("12.34.56"));
+    }
+
+    #[test]
+    fn test_non_std_quote() {
+        let schema = Schema::new(vec![
+            Field::new("text1", DataType::Utf8, false),
+            Field::new("text2", DataType::Utf8, false),
+        ]);
+        let builder = ReaderBuilder::new(Arc::new(schema))
+            .with_header(false)
+            .with_quote(b'~'); // default is ", change to ~
+
+        let mut csv_text = Vec::new();
+        let mut csv_writer = std::io::Cursor::new(&mut csv_text);
+        for index in 0..10 {
+            let text1 = format!("id{index:}");
+            let text2 = format!("value{index:}");
+            csv_writer
+                .write_fmt(format_args!("~{text1}~,~{text2}~\r\n"))
+                .unwrap();
+        }
+        let mut csv_reader = std::io::Cursor::new(&csv_text);
+        let mut reader = builder.build(&mut csv_reader).unwrap();
+        let batch = reader.next().unwrap().unwrap();
+        let col0 = batch.column(0);
+        assert_eq!(col0.len(), 10);
+        let col0_arr = col0.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(col0_arr.value(0), "id0");
+        let col1 = batch.column(1);
+        assert_eq!(col1.len(), 10);
+        let col1_arr = col1.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(col1_arr.value(5), "value5");
+    }
+
+    #[test]
+    fn test_non_std_escape() {
+        let schema = Schema::new(vec![
+            Field::new("text1", DataType::Utf8, false),
+            Field::new("text2", DataType::Utf8, false),
+        ]);
+        let builder = ReaderBuilder::new(Arc::new(schema))
+            .with_header(false)
+            .with_escape(b'\\'); // default is None, change to \
+
+        let mut csv_text = Vec::new();
+        let mut csv_writer = std::io::Cursor::new(&mut csv_text);
+        for index in 0..10 {
+            let text1 = format!("id{index:}");
+            let text2 = format!("value\\\"{index:}");
+            csv_writer
+                .write_fmt(format_args!("\"{text1}\",\"{text2}\"\r\n"))
+                .unwrap();
+        }
+        let mut csv_reader = std::io::Cursor::new(&csv_text);
+        let mut reader = builder.build(&mut csv_reader).unwrap();
+        let batch = reader.next().unwrap().unwrap();
+        let col0 = batch.column(0);
+        assert_eq!(col0.len(), 10);
+        let col0_arr = col0.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(col0_arr.value(0), "id0");
+        let col1 = batch.column(1);
+        assert_eq!(col1.len(), 10);
+        let col1_arr = col1.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(col1_arr.value(5), "value\"5");
+    }
+
+    #[test]
+    fn test_non_std_terminator() {
+        let schema = Schema::new(vec![
+            Field::new("text1", DataType::Utf8, false),
+            Field::new("text2", DataType::Utf8, false),
+        ]);
+        let builder = ReaderBuilder::new(Arc::new(schema))
+            .with_header(false)
+            .with_terminator(b'\n'); // default is CRLF, change to LF
+
+        let mut csv_text = Vec::new();
+        let mut csv_writer = std::io::Cursor::new(&mut csv_text);
+        for index in 0..10 {
+            let text1 = format!("id{index:}");
+            let text2 = format!("value{index:}");
+            csv_writer
+                .write_fmt(format_args!("\"{text1}\",\"{text2}\"\n"))
+                .unwrap();
+        }
+        let mut csv_reader = std::io::Cursor::new(&csv_text);
+        let mut reader = builder.build(&mut csv_reader).unwrap();
+        let batch = reader.next().unwrap().unwrap();
+        let col0 = batch.column(0);
+        assert_eq!(col0.len(), 10);
+        let col0_arr = col0.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(col0_arr.value(0), "id0");
+        let col1 = batch.column(1);
+        assert_eq!(col1.len(), 10);
+        let col1_arr = col1.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(col1_arr.value(5), "value5");
+    }
+
+    #[test]
+    fn test_header_bounds() {
+        let csv = "a,b\na,b\na,b\na,b\na,b\n";
+        let tests = [
+            (None, false, 5),
+            (None, true, 4),
+            (Some((0, 4)), false, 4),
+            (Some((1, 4)), false, 3),
+            (Some((0, 4)), true, 4),
+            (Some((1, 4)), true, 3),
+        ];
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Utf8, false),
+            Field::new("a", DataType::Utf8, false),
+        ]));
+
+        for (idx, (bounds, has_header, expected)) in tests.into_iter().enumerate() {
+            let mut reader = ReaderBuilder::new(schema.clone()).with_header(has_header);
+            if let Some((start, end)) = bounds {
+                reader = reader.with_bounds(start, end);
+            }
+            let b = reader
+                .build_buffered(Cursor::new(csv.as_bytes()))
+                .unwrap()
+                .next()
+                .unwrap()
+                .unwrap();
+            assert_eq!(b.num_rows(), expected, "{idx}");
+        }
+    }
+
+    #[test]
+    fn test_null_boolean() {
+        let csv = "true,false\nFalse,True\n,True\nFalse,";
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Boolean, true),
+            Field::new("a", DataType::Boolean, true),
+        ]));
+
+        let b = ReaderBuilder::new(schema)
+            .build_buffered(Cursor::new(csv.as_bytes()))
+            .unwrap()
+            .next()
+            .unwrap()
+            .unwrap();
+
+        assert_eq!(b.num_rows(), 4);
+        assert_eq!(b.num_columns(), 2);
+
+        let c = b.column(0).as_boolean();
+        assert_eq!(c.null_count(), 1);
+        assert!(c.value(0));
+        assert!(!c.value(1));
+        assert!(c.is_null(2));
+        assert!(!c.value(3));
+
+        let c = b.column(1).as_boolean();
+        assert_eq!(c.null_count(), 1);
+        assert!(!c.value(0));
+        assert!(c.value(1));
+        assert!(c.value(2));
+        assert!(c.is_null(3));
+    }
+
+    #[test]
+    fn test_buffered() {
+        let tests = [
+            ("test/data/uk_cities.csv", false, 37),
+            ("test/data/various_types.csv", true, 7),
+            ("test/data/decimal_test.csv", false, 10),
+        ];
+
+        for (path, has_header, expected_rows) in tests {
+            let (schema, _) = Format::default()
+                .infer_schema(File::open(path).unwrap(), None)
+                .unwrap();
+            let schema = Arc::new(schema);
+
+            for batch_size in [1, 4] {
+                for capacity in [1, 3, 7, 100] {
+                    let reader = ReaderBuilder::new(schema.clone())
+                        .with_batch_size(batch_size)
+                        .with_header(has_header)
+                        .build(File::open(path).unwrap())
+                        .unwrap();
+
+                    let expected = reader.collect::<Result<Vec<_>, _>>().unwrap();
+
+                    assert_eq!(
+                        expected.iter().map(|x| x.num_rows()).sum::<usize>(),
+                        expected_rows
+                    );
+
+                    let buffered =
+                        std::io::BufReader::with_capacity(capacity, File::open(path).unwrap());
+
+                    let reader = ReaderBuilder::new(schema.clone())
+                        .with_batch_size(batch_size)
+                        .with_header(has_header)
+                        .build_buffered(buffered)
+                        .unwrap();
+
+                    let actual = reader.collect::<Result<Vec<_>, _>>().unwrap();
+                    assert_eq!(expected, actual)
+                }
+            }
+        }
+    }
+
+    fn err_test(csv: &[u8], expected: &str) {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("text1", DataType::Utf8, true),
+            Field::new("text2", DataType::Utf8, true),
+        ]));
+        let buffer = std::io::BufReader::with_capacity(2, Cursor::new(csv));
+        let b = ReaderBuilder::new(schema)
+            .with_batch_size(2)
+            .build_buffered(buffer)
+            .unwrap();
+        let err = b.collect::<Result<Vec<_>, _>>().unwrap_err().to_string();
+        assert_eq!(err, expected)
+    }
+
+    #[test]
+    fn test_invalid_utf8() {
+        err_test(
+            b"sdf,dsfg\ndfd,hgh\xFFue\n,sds\nFalhghse,",
+            "Csv error: Encountered invalid UTF-8 data for line 2 and field 2",
+        );
+
+        err_test(
+            b"sdf,dsfg\ndksdk,jf\nd\xFFfd,hghue\n,sds\nFalhghse,",
+            "Csv error: Encountered invalid UTF-8 data for line 3 and field 1",
+        );
+
+        err_test(
+            b"sdf,dsfg\ndksdk,jf\ndsdsfd,hghue\n,sds\nFalhghse,\xFF",
+            "Csv error: Encountered invalid UTF-8 data for line 5 and field 2",
+        );
+
+        err_test(
+            b"\xFFsdf,dsfg\ndksdk,jf\ndsdsfd,hghue\n,sds\nFalhghse,\xFF",
+            "Csv error: Encountered invalid UTF-8 data for line 1 and field 1",
+        );
+    }
+
+    struct InstrumentedRead<R> {
+        r: R,
+        fill_count: usize,
+        fill_sizes: Vec<usize>,
+    }
+
+    impl<R> InstrumentedRead<R> {
+        fn new(r: R) -> Self {
+            Self {
+                r,
+                fill_count: 0,
+                fill_sizes: vec![],
+            }
+        }
+    }
+
+    impl<R: Seek> Seek for InstrumentedRead<R> {
+        fn seek(&mut self, pos: SeekFrom) -> std::io::Result<u64> {
+            self.r.seek(pos)
+        }
+    }
+
+    impl<R: BufRead> Read for InstrumentedRead<R> {
+        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+            self.r.read(buf)
+        }
+    }
+
+    impl<R: BufRead> BufRead for InstrumentedRead<R> {
+        fn fill_buf(&mut self) -> std::io::Result<&[u8]> {
+            self.fill_count += 1;
+            let buf = self.r.fill_buf()?;
+            self.fill_sizes.push(buf.len());
+            Ok(buf)
+        }
+
+        fn consume(&mut self, amt: usize) {
+            self.r.consume(amt)
+        }
+    }
+
+    #[test]
+    fn test_io() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Utf8, false),
+            Field::new("b", DataType::Utf8, false),
+        ]));
+        let csv = "foo,bar\nbaz,foo\na,b\nc,d";
+        let mut read = InstrumentedRead::new(Cursor::new(csv.as_bytes()));
+        let reader = ReaderBuilder::new(schema)
+            .with_batch_size(3)
+            .build_buffered(&mut read)
+            .unwrap();
+
+        let batches = reader.collect::<Result<Vec<_>, _>>().unwrap();
+        assert_eq!(batches.len(), 2);
+        assert_eq!(batches[0].num_rows(), 3);
+        assert_eq!(batches[1].num_rows(), 1);
+
+        // Expect 4 calls to fill_buf
+        // 1. Read first 3 rows
+        // 2. Read final row
+        // 3. Delimit and flush final row
+        // 4. Iterator finished
+        assert_eq!(&read.fill_sizes, &[23, 3, 0, 0]);
+        assert_eq!(read.fill_count, 4);
+    }
+
+    #[test]
+    fn test_inference() {
+        let cases: &[(&[&str], DataType)] = &[
+            (&[], DataType::Null),
+            (&["false", "12"], DataType::Utf8),
+            (&["12", "cupcakes"], DataType::Utf8),
+            (&["12", "12.4"], DataType::Float64),
+            (&["14050", "24332"], DataType::Int64),
+            (&["14050.0", "true"], DataType::Utf8),
+            (&["14050", "2020-03-19 00:00:00"], DataType::Utf8),
+            (&["14050", "2340.0", "2020-03-19 00:00:00"], DataType::Utf8),
+            (
+                &["2020-03-19 02:00:00", "2020-03-19 00:00:00"],
+                DataType::Timestamp(TimeUnit::Second, None),
+            ),
+            (&["2020-03-19", "2020-03-20"], DataType::Date32),
+            (
+                &["2020-03-19", "2020-03-19 02:00:00", "2020-03-19 00:00:00"],
+                DataType::Timestamp(TimeUnit::Second, None),
+            ),
+            (
+                &[
+                    "2020-03-19",
+                    "2020-03-19 02:00:00",
+                    "2020-03-19 00:00:00.000",
+                ],
+                DataType::Timestamp(TimeUnit::Millisecond, None),
+            ),
+            (
+                &[
+                    "2020-03-19",
+                    "2020-03-19 02:00:00",
+                    "2020-03-19 00:00:00.000000",
+                ],
+                DataType::Timestamp(TimeUnit::Microsecond, None),
+            ),
+            (
+                &["2020-03-19 02:00:00+02:00", "2020-03-19 02:00:00Z"],
+                DataType::Timestamp(TimeUnit::Second, None),
+            ),
+            (
+                &[
+                    "2020-03-19",
+                    "2020-03-19 02:00:00+02:00",
+                    "2020-03-19 02:00:00Z",
+                    "2020-03-19 02:00:00.12Z",
+                ],
+                DataType::Timestamp(TimeUnit::Millisecond, None),
+            ),
+            (
+                &[
+                    "2020-03-19",
+                    "2020-03-19 02:00:00.000000000",
+                    "2020-03-19 00:00:00.000000",
+                ],
+                DataType::Timestamp(TimeUnit::Nanosecond, None),
+            ),
+        ];
+
+        for (values, expected) in cases {
+            let mut t = InferredDataType::default();
+            for v in *values {
+                t.update(v)
+            }
+            assert_eq!(&t.get(), expected, "{values:?}")
+        }
+    }
+}
diff --git a/arrow-csv/src/reader/records.rs b/arrow-csv/src/reader/records.rs
new file mode 100644
index 000000000000..877cfb3ee653
--- /dev/null
+++ b/arrow-csv/src/reader/records.rs
@@ -0,0 +1,362 @@
+// 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.
+
+use arrow_schema::ArrowError;
+use csv_core::{ReadRecordResult, Reader};
+
+/// The estimated length of a field in bytes
+const AVERAGE_FIELD_SIZE: usize = 8;
+
+/// The minimum amount of data in a single read
+const MIN_CAPACITY: usize = 1024;
+
+/// [`RecordDecoder`] provides a push-based interface to decoder [`StringRecords`]
+#[derive(Debug)]
+pub struct RecordDecoder {
+    delimiter: Reader,
+
+    /// The expected number of fields per row
+    num_columns: usize,
+
+    /// The current line number
+    line_number: usize,
+
+    /// Offsets delimiting field start positions
+    offsets: Vec<usize>,
+
+    /// The current offset into `self.offsets`
+    ///
+    /// We track this independently of Vec to avoid re-zeroing memory
+    offsets_len: usize,
+
+    /// The number of fields read for the current record
+    current_field: usize,
+
+    /// The number of rows buffered
+    num_rows: usize,
+
+    /// Decoded field data
+    data: Vec<u8>,
+
+    /// Offsets into data
+    ///
+    /// We track this independently of Vec to avoid re-zeroing memory
+    data_len: usize,
+}
+
+impl RecordDecoder {
+    pub fn new(delimiter: Reader, num_columns: usize) -> Self {
+        Self {
+            delimiter,
+            num_columns,
+            line_number: 1,
+            offsets: vec![],
+            offsets_len: 1, // The first offset is always 0
+            current_field: 0,
+            data_len: 0,
+            data: vec![],
+            num_rows: 0,
+        }
+    }
+
+    /// Decodes records from `input` returning the number of records and bytes read
+    ///
+    /// Note: this expects to be called with an empty `input` to signal EOF
+    pub fn decode(&mut self, input: &[u8], to_read: usize) -> Result<(usize, usize), ArrowError> {
+        if to_read == 0 {
+            return Ok((0, 0));
+        }
+
+        // Reserve sufficient capacity in offsets
+        self.offsets
+            .resize(self.offsets_len + to_read * self.num_columns, 0);
+
+        // The current offset into `input`
+        let mut input_offset = 0;
+
+        // The number of rows decoded in this pass
+        let mut read = 0;
+
+        loop {
+            // Reserve necessary space in output data based on best estimate
+            let remaining_rows = to_read - read;
+            let capacity = remaining_rows * self.num_columns * AVERAGE_FIELD_SIZE;
+            let estimated_data = capacity.max(MIN_CAPACITY);
+            self.data.resize(self.data_len + estimated_data, 0);
+
+            // Try to read a record
+            loop {
+                let (result, bytes_read, bytes_written, end_positions) =
+                    self.delimiter.read_record(
+                        &input[input_offset..],
+                        &mut self.data[self.data_len..],
+                        &mut self.offsets[self.offsets_len..],
+                    );
+
+                self.current_field += end_positions;
+                self.offsets_len += end_positions;
+                input_offset += bytes_read;
+                self.data_len += bytes_written;
+
+                match result {
+                    ReadRecordResult::End | ReadRecordResult::InputEmpty => {
+                        // Reached end of input
+                        return Ok((read, input_offset));
+                    }
+                    // Need to allocate more capacity
+                    ReadRecordResult::OutputFull => break,
+                    ReadRecordResult::OutputEndsFull => {
+                        return Err(ArrowError::CsvError(format!(
+                            "incorrect number of fields for line {}, expected {} got more than {}",
+                            self.line_number, self.num_columns, self.current_field
+                        )));
+                    }
+                    ReadRecordResult::Record => {
+                        if self.current_field != self.num_columns {
+                            return Err(ArrowError::CsvError(format!(
+                                "incorrect number of fields for line {}, expected {} got {}",
+                                self.line_number, self.num_columns, self.current_field
+                            )));
+                        }
+                        read += 1;
+                        self.current_field = 0;
+                        self.line_number += 1;
+                        self.num_rows += 1;
+
+                        if read == to_read {
+                            // Read sufficient rows
+                            return Ok((read, input_offset));
+                        }
+
+                        if input.len() == input_offset {
+                            // Input exhausted, need to read more
+                            // Without this read_record will interpret the empty input
+                            // byte array as indicating the end of the file
+                            return Ok((read, input_offset));
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// Returns the current number of buffered records
+    pub fn len(&self) -> usize {
+        self.num_rows
+    }
+
+    /// Returns true if the decoder is empty
+    pub fn is_empty(&self) -> bool {
+        self.num_rows == 0
+    }
+
+    /// Clears the current contents of the decoder
+    pub fn clear(&mut self) {
+        // This does not reset current_field to allow clearing part way through a record
+        self.offsets_len = 1;
+        self.data_len = 0;
+        self.num_rows = 0;
+    }
+
+    /// Flushes the current contents of the reader
+    pub fn flush(&mut self) -> Result<StringRecords<'_>, ArrowError> {
+        if self.current_field != 0 {
+            return Err(ArrowError::CsvError(
+                "Cannot flush part way through record".to_string(),
+            ));
+        }
+
+        // csv_core::Reader writes end offsets relative to the start of the row
+        // Therefore scan through and offset these based on the cumulative row offsets
+        let mut row_offset = 0;
+        self.offsets[1..self.offsets_len]
+            .chunks_exact_mut(self.num_columns)
+            .for_each(|row| {
+                let offset = row_offset;
+                row.iter_mut().for_each(|x| {
+                    *x += offset;
+                    row_offset = *x;
+                });
+            });
+
+        // Need to truncate data t1o the actual amount of data read
+        let data = std::str::from_utf8(&self.data[..self.data_len]).map_err(|e| {
+            let valid_up_to = e.valid_up_to();
+
+            // We can't use binary search because of empty fields
+            let idx = self.offsets[..self.offsets_len]
+                .iter()
+                .rposition(|x| *x <= valid_up_to)
+                .unwrap();
+
+            let field = idx % self.num_columns + 1;
+            let line_offset = self.line_number - self.num_rows;
+            let line = line_offset + idx / self.num_columns;
+
+            ArrowError::CsvError(format!(
+                "Encountered invalid UTF-8 data for line {line} and field {field}"
+            ))
+        })?;
+
+        let offsets = &self.offsets[..self.offsets_len];
+        let num_rows = self.num_rows;
+
+        // Reset state
+        self.offsets_len = 1;
+        self.data_len = 0;
+        self.num_rows = 0;
+
+        Ok(StringRecords {
+            num_rows,
+            num_columns: self.num_columns,
+            offsets,
+            data,
+        })
+    }
+}
+
+/// A collection of parsed, UTF-8 CSV records
+#[derive(Debug)]
+pub struct StringRecords<'a> {
+    num_columns: usize,
+    num_rows: usize,
+    offsets: &'a [usize],
+    data: &'a str,
+}
+
+impl<'a> StringRecords<'a> {
+    fn get(&self, index: usize) -> StringRecord<'a> {
+        let field_idx = index * self.num_columns;
+        StringRecord {
+            data: self.data,
+            offsets: &self.offsets[field_idx..field_idx + self.num_columns + 1],
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.num_rows
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = StringRecord<'a>> + '_ {
+        (0..self.num_rows).map(|x| self.get(x))
+    }
+}
+
+/// A single parsed, UTF-8 CSV record
+#[derive(Debug, Clone, Copy)]
+pub struct StringRecord<'a> {
+    data: &'a str,
+    offsets: &'a [usize],
+}
+
+impl<'a> StringRecord<'a> {
+    pub fn get(&self, index: usize) -> &'a str {
+        let end = self.offsets[index + 1];
+        let start = self.offsets[index];
+
+        // SAFETY:
+        // Parsing produces offsets at valid byte boundaries
+        unsafe { self.data.get_unchecked(start..end) }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::reader::records::RecordDecoder;
+    use csv_core::Reader;
+    use std::io::{BufRead, BufReader, Cursor};
+
+    #[test]
+    fn test_basic() {
+        let csv = [
+            "foo,bar,baz",
+            "a,b,c",
+            "12,3,5",
+            "\"asda\"\"asas\",\"sdffsnsd\", as",
+        ]
+        .join("\n");
+
+        let mut expected = vec![
+            vec!["foo", "bar", "baz"],
+            vec!["a", "b", "c"],
+            vec!["12", "3", "5"],
+            vec!["asda\"asas", "sdffsnsd", " as"],
+        ]
+        .into_iter();
+
+        let mut reader = BufReader::with_capacity(3, Cursor::new(csv.as_bytes()));
+        let mut decoder = RecordDecoder::new(Reader::new(), 3);
+
+        loop {
+            let to_read = 3;
+            let mut read = 0;
+            loop {
+                let buf = reader.fill_buf().unwrap();
+                let (records, bytes) = decoder.decode(buf, to_read - read).unwrap();
+
+                reader.consume(bytes);
+                read += records;
+
+                if read == to_read || bytes == 0 {
+                    break;
+                }
+            }
+            if read == 0 {
+                break;
+            }
+
+            let b = decoder.flush().unwrap();
+            b.iter().zip(&mut expected).for_each(|(record, expected)| {
+                let actual = (0..3)
+                    .map(|field_idx| record.get(field_idx))
+                    .collect::<Vec<_>>();
+                assert_eq!(actual, expected)
+            });
+        }
+        assert!(expected.next().is_none());
+    }
+
+    #[test]
+    fn test_invalid_fields() {
+        let csv = "a,b\nb,c\na\n";
+        let mut decoder = RecordDecoder::new(Reader::new(), 2);
+        let err = decoder.decode(csv.as_bytes(), 4).unwrap_err().to_string();
+
+        let expected = "Csv error: incorrect number of fields for line 3, expected 2 got 1";
+
+        assert_eq!(err, expected);
+
+        // Test with initial skip
+        let mut decoder = RecordDecoder::new(Reader::new(), 2);
+        let (skipped, bytes) = decoder.decode(csv.as_bytes(), 1).unwrap();
+        assert_eq!(skipped, 1);
+        decoder.clear();
+
+        let remaining = &csv.as_bytes()[bytes..];
+        let err = decoder.decode(remaining, 3).unwrap_err().to_string();
+        assert_eq!(err, expected);
+    }
+
+    #[test]
+    fn test_skip_insufficient_rows() {
+        let csv = "a\nv\n";
+        let mut decoder = RecordDecoder::new(Reader::new(), 1);
+        let (read, bytes) = decoder.decode(csv.as_bytes(), 3).unwrap();
+        assert_eq!(read, 2);
+        assert_eq!(bytes, csv.len());
+    }
+}
diff --git a/arrow-csv/src/writer.rs b/arrow-csv/src/writer.rs
new file mode 100644
index 000000000000..a31a1d5e8c13
--- /dev/null
+++ b/arrow-csv/src/writer.rs
@@ -0,0 +1,762 @@
+// 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.
+
+//! CSV Writer
+//!
+//! This CSV writer allows Arrow data (in record batches) to be written as CSV files.
+//! The writer does not support writing `ListArray` and `StructArray`.
+//!
+//! Example:
+//!
+//! ```
+//! # use arrow_array::*;
+//! # use arrow_array::types::*;
+//! # use arrow_csv::Writer;
+//! # use arrow_schema::*;
+//! # use std::sync::Arc;
+//!
+//! let schema = Schema::new(vec![
+//!     Field::new("c1", DataType::Utf8, false),
+//!     Field::new("c2", DataType::Float64, true),
+//!     Field::new("c3", DataType::UInt32, false),
+//!     Field::new("c4", DataType::Boolean, true),
+//! ]);
+//! let c1 = StringArray::from(vec![
+//!     "Lorem ipsum dolor sit amet",
+//!     "consectetur adipiscing elit",
+//!     "sed do eiusmod tempor",
+//! ]);
+//! let c2 = PrimitiveArray::<Float64Type>::from(vec![
+//!     Some(123.564532),
+//!     None,
+//!     Some(-556132.25),
+//! ]);
+//! let c3 = PrimitiveArray::<UInt32Type>::from(vec![3, 2, 1]);
+//! let c4 = BooleanArray::from(vec![Some(true), Some(false), None]);
+//!
+//! let batch = RecordBatch::try_new(
+//!     Arc::new(schema),
+//!     vec![Arc::new(c1), Arc::new(c2), Arc::new(c3), Arc::new(c4)],
+//! )
+//! .unwrap();
+//!
+//! let mut output = Vec::with_capacity(1024);
+//!
+//! let mut writer = Writer::new(&mut output);
+//! let batches = vec![&batch, &batch];
+//! for batch in batches {
+//!     writer.write(batch).unwrap();
+//! }
+//! ```
+
+use arrow_array::*;
+use arrow_cast::display::*;
+use arrow_schema::*;
+use csv::ByteRecord;
+use std::io::Write;
+
+use crate::map_csv_error;
+const DEFAULT_NULL_VALUE: &str = "";
+
+/// A CSV writer
+#[derive(Debug)]
+pub struct Writer<W: Write> {
+    /// The object to write to
+    writer: csv::Writer<W>,
+    /// Whether file should be written with headers, defaults to `true`
+    has_headers: bool,
+    /// The date format for date arrays, defaults to RFC3339
+    date_format: Option<String>,
+    /// The datetime format for datetime arrays, defaults to RFC3339
+    datetime_format: Option<String>,
+    /// The timestamp format for timestamp arrays, defaults to RFC3339
+    timestamp_format: Option<String>,
+    /// The timestamp format for timestamp (with timezone) arrays, defaults to RFC3339
+    timestamp_tz_format: Option<String>,
+    /// The time format for time arrays, defaults to RFC3339
+    time_format: Option<String>,
+    /// Is the beginning-of-writer
+    beginning: bool,
+    /// The value to represent null entries, defaults to [`DEFAULT_NULL_VALUE`]
+    null_value: Option<String>,
+}
+
+impl<W: Write> Writer<W> {
+    /// Create a new CsvWriter from a writable object, with default options
+    pub fn new(writer: W) -> Self {
+        let delimiter = b',';
+        WriterBuilder::new().with_delimiter(delimiter).build(writer)
+    }
+
+    /// Write a vector of record batches to a writable object
+    pub fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError> {
+        let num_columns = batch.num_columns();
+        if self.beginning {
+            if self.has_headers {
+                let mut headers: Vec<String> = Vec::with_capacity(num_columns);
+                batch
+                    .schema()
+                    .fields()
+                    .iter()
+                    .for_each(|field| headers.push(field.name().to_string()));
+                self.writer
+                    .write_record(&headers[..])
+                    .map_err(map_csv_error)?;
+            }
+            self.beginning = false;
+        }
+
+        let options = FormatOptions::default()
+            .with_null(self.null_value.as_deref().unwrap_or(DEFAULT_NULL_VALUE))
+            .with_date_format(self.date_format.as_deref())
+            .with_datetime_format(self.datetime_format.as_deref())
+            .with_timestamp_format(self.timestamp_format.as_deref())
+            .with_timestamp_tz_format(self.timestamp_tz_format.as_deref())
+            .with_time_format(self.time_format.as_deref());
+
+        let converters = batch
+            .columns()
+            .iter()
+            .map(|a| match a.data_type() {
+                d if d.is_nested() => Err(ArrowError::CsvError(format!(
+                    "Nested type {} is not supported in CSV",
+                    a.data_type()
+                ))),
+                DataType::Binary | DataType::LargeBinary => Err(ArrowError::CsvError(
+                    "Binary data cannot be written to CSV".to_string(),
+                )),
+                _ => ArrayFormatter::try_new(a.as_ref(), &options),
+            })
+            .collect::<Result<Vec<_>, ArrowError>>()?;
+
+        let mut buffer = String::with_capacity(1024);
+        let mut byte_record = ByteRecord::with_capacity(1024, converters.len());
+
+        for row_idx in 0..batch.num_rows() {
+            byte_record.clear();
+            for (col_idx, converter) in converters.iter().enumerate() {
+                buffer.clear();
+                converter.value(row_idx).write(&mut buffer).map_err(|e| {
+                    ArrowError::CsvError(format!(
+                        "Error processing row {}, col {}: {e}",
+                        row_idx + 1,
+                        col_idx + 1
+                    ))
+                })?;
+                byte_record.push_field(buffer.as_bytes());
+            }
+
+            self.writer
+                .write_byte_record(&byte_record)
+                .map_err(map_csv_error)?;
+        }
+        self.writer.flush()?;
+
+        Ok(())
+    }
+
+    /// Unwraps this `Writer<W>`, returning the underlying writer.
+    pub fn into_inner(self) -> W {
+        // Safe to call `unwrap` since `write` always flushes the writer.
+        self.writer.into_inner().unwrap()
+    }
+}
+
+impl<W: Write> RecordBatchWriter for Writer<W> {
+    fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError> {
+        self.write(batch)
+    }
+
+    fn close(self) -> Result<(), ArrowError> {
+        Ok(())
+    }
+}
+
+/// A CSV writer builder
+#[derive(Clone, Debug)]
+pub struct WriterBuilder {
+    /// Optional column delimiter. Defaults to `b','`
+    delimiter: u8,
+    /// Whether to write column names as file headers. Defaults to `true`
+    has_header: bool,
+    /// Optional quote character. Defaults to `b'"'`
+    quote: u8,
+    /// Optional escape character. Defaults to `b'\\'`
+    escape: u8,
+    /// Enable double quote escapes. Defaults to `true`
+    double_quote: bool,
+    /// Optional date format for date arrays
+    date_format: Option<String>,
+    /// Optional datetime format for datetime arrays
+    datetime_format: Option<String>,
+    /// Optional timestamp format for timestamp arrays
+    timestamp_format: Option<String>,
+    /// Optional timestamp format for timestamp with timezone arrays
+    timestamp_tz_format: Option<String>,
+    /// Optional time format for time arrays
+    time_format: Option<String>,
+    /// Optional value to represent null
+    null_value: Option<String>,
+}
+
+impl Default for WriterBuilder {
+    fn default() -> Self {
+        WriterBuilder {
+            delimiter: b',',
+            has_header: true,
+            quote: b'"',
+            escape: b'\\',
+            double_quote: true,
+            date_format: None,
+            datetime_format: None,
+            timestamp_format: None,
+            timestamp_tz_format: None,
+            time_format: None,
+            null_value: None,
+        }
+    }
+}
+
+impl WriterBuilder {
+    /// Create a new builder for configuring CSV writing options.
+    ///
+    /// To convert a builder into a writer, call `WriterBuilder::build`
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use arrow_csv::{Writer, WriterBuilder};
+    /// # use std::fs::File;
+    ///
+    /// fn example() -> Writer<File> {
+    ///     let file = File::create("target/out.csv").unwrap();
+    ///
+    ///     // create a builder that doesn't write headers
+    ///     let builder = WriterBuilder::new().with_header(false);
+    ///     let writer = builder.build(file);
+    ///
+    ///     writer
+    /// }
+    /// ```
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set whether to write headers
+    #[deprecated(note = "Use Self::with_header")]
+    #[doc(hidden)]
+    pub fn has_headers(mut self, has_headers: bool) -> Self {
+        self.has_header = has_headers;
+        self
+    }
+
+    /// Set whether to write the CSV file with a header
+    pub fn with_header(mut self, header: bool) -> Self {
+        self.has_header = header;
+        self
+    }
+
+    /// Returns `true` if this writer is configured to write a header
+    pub fn header(&self) -> bool {
+        self.has_header
+    }
+
+    /// Set the CSV file's column delimiter as a byte character
+    pub fn with_delimiter(mut self, delimiter: u8) -> Self {
+        self.delimiter = delimiter;
+        self
+    }
+
+    /// Get the CSV file's column delimiter as a byte character
+    pub fn delimiter(&self) -> u8 {
+        self.delimiter
+    }
+
+    /// Set the CSV file's quote character as a byte character
+    pub fn with_quote(mut self, quote: u8) -> Self {
+        self.quote = quote;
+        self
+    }
+
+    /// Get the CSV file's quote character as a byte character
+    pub fn quote(&self) -> u8 {
+        self.quote
+    }
+
+    /// Set the CSV file's escape character as a byte character
+    ///
+    /// In some variants of CSV, quotes are escaped using a special escape
+    /// character like `\` (instead of escaping quotes by doubling them).
+    ///
+    /// By default, writing these idiosyncratic escapes is disabled, and is
+    /// only used when `double_quote` is disabled.
+    pub fn with_escape(mut self, escape: u8) -> Self {
+        self.escape = escape;
+        self
+    }
+
+    /// Get the CSV file's escape character as a byte character
+    pub fn escape(&self) -> u8 {
+        self.escape
+    }
+
+    /// Set whether to enable double quote escapes
+    ///
+    /// When enabled (which is the default), quotes are escaped by doubling
+    /// them. e.g., `"` escapes to `""`.
+    ///
+    /// When disabled, quotes are escaped with the escape character (which
+    /// is `\\` by default).
+    pub fn with_double_quote(mut self, double_quote: bool) -> Self {
+        self.double_quote = double_quote;
+        self
+    }
+
+    /// Get whether double quote escapes are enabled
+    pub fn double_quote(&self) -> bool {
+        self.double_quote
+    }
+
+    /// Set the CSV file's date format
+    pub fn with_date_format(mut self, format: String) -> Self {
+        self.date_format = Some(format);
+        self
+    }
+
+    /// Get the CSV file's date format if set, defaults to RFC3339
+    pub fn date_format(&self) -> Option<&str> {
+        self.date_format.as_deref()
+    }
+
+    /// Set the CSV file's datetime format
+    pub fn with_datetime_format(mut self, format: String) -> Self {
+        self.datetime_format = Some(format);
+        self
+    }
+
+    /// Get the CSV file's datetime format if set, defaults to RFC3339
+    pub fn datetime_format(&self) -> Option<&str> {
+        self.datetime_format.as_deref()
+    }
+
+    /// Set the CSV file's time format
+    pub fn with_time_format(mut self, format: String) -> Self {
+        self.time_format = Some(format);
+        self
+    }
+
+    /// Get the CSV file's datetime time if set, defaults to RFC3339
+    pub fn time_format(&self) -> Option<&str> {
+        self.time_format.as_deref()
+    }
+
+    /// Set the CSV file's timestamp format
+    pub fn with_timestamp_format(mut self, format: String) -> Self {
+        self.timestamp_format = Some(format);
+        self
+    }
+
+    /// Get the CSV file's timestamp format if set, defaults to RFC3339
+    pub fn timestamp_format(&self) -> Option<&str> {
+        self.timestamp_format.as_deref()
+    }
+
+    /// Set the value to represent null in output
+    pub fn with_null(mut self, null_value: String) -> Self {
+        self.null_value = Some(null_value);
+        self
+    }
+
+    /// Get the value to represent null in output
+    pub fn null(&self) -> &str {
+        self.null_value.as_deref().unwrap_or(DEFAULT_NULL_VALUE)
+    }
+
+    /// Use RFC3339 format for date/time/timestamps (default)
+    #[deprecated(note = "Use WriterBuilder::default()")]
+    pub fn with_rfc3339(mut self) -> Self {
+        self.date_format = None;
+        self.datetime_format = None;
+        self.time_format = None;
+        self.timestamp_format = None;
+        self.timestamp_tz_format = None;
+        self
+    }
+
+    /// Create a new `Writer`
+    pub fn build<W: Write>(self, writer: W) -> Writer<W> {
+        let mut builder = csv::WriterBuilder::new();
+        let writer = builder
+            .delimiter(self.delimiter)
+            .quote(self.quote)
+            .double_quote(self.double_quote)
+            .escape(self.escape)
+            .from_writer(writer);
+        Writer {
+            writer,
+            beginning: true,
+            has_headers: self.has_header,
+            date_format: self.date_format,
+            datetime_format: self.datetime_format,
+            time_format: self.time_format,
+            timestamp_format: self.timestamp_format,
+            timestamp_tz_format: self.timestamp_tz_format,
+            null_value: self.null_value,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use crate::ReaderBuilder;
+    use arrow_array::builder::{Decimal128Builder, Decimal256Builder};
+    use arrow_array::types::*;
+    use arrow_buffer::i256;
+    use std::io::{Cursor, Read, Seek};
+    use std::sync::Arc;
+
+    #[test]
+    fn test_write_csv() {
+        let schema = Schema::new(vec![
+            Field::new("c1", DataType::Utf8, false),
+            Field::new("c2", DataType::Float64, true),
+            Field::new("c3", DataType::UInt32, false),
+            Field::new("c4", DataType::Boolean, true),
+            Field::new("c5", DataType::Timestamp(TimeUnit::Millisecond, None), true),
+            Field::new("c6", DataType::Time32(TimeUnit::Second), false),
+            Field::new_dictionary("c7", DataType::Int32, DataType::Utf8, false),
+        ]);
+
+        let c1 = StringArray::from(vec![
+            "Lorem ipsum dolor sit amet",
+            "consectetur adipiscing elit",
+            "sed do eiusmod tempor",
+        ]);
+        let c2 =
+            PrimitiveArray::<Float64Type>::from(vec![Some(123.564532), None, Some(-556132.25)]);
+        let c3 = PrimitiveArray::<UInt32Type>::from(vec![3, 2, 1]);
+        let c4 = BooleanArray::from(vec![Some(true), Some(false), None]);
+        let c5 =
+            TimestampMillisecondArray::from(vec![None, Some(1555584887378), Some(1555555555555)]);
+        let c6 = Time32SecondArray::from(vec![1234, 24680, 85563]);
+        let c7: DictionaryArray<Int32Type> =
+            vec!["cupcakes", "cupcakes", "foo"].into_iter().collect();
+
+        let batch = RecordBatch::try_new(
+            Arc::new(schema),
+            vec![
+                Arc::new(c1),
+                Arc::new(c2),
+                Arc::new(c3),
+                Arc::new(c4),
+                Arc::new(c5),
+                Arc::new(c6),
+                Arc::new(c7),
+            ],
+        )
+        .unwrap();
+
+        let mut file = tempfile::tempfile().unwrap();
+
+        let mut writer = Writer::new(&mut file);
+        let batches = vec![&batch, &batch];
+        for batch in batches {
+            writer.write(batch).unwrap();
+        }
+        drop(writer);
+
+        // check that file was written successfully
+        file.rewind().unwrap();
+        let mut buffer: Vec<u8> = vec![];
+        file.read_to_end(&mut buffer).unwrap();
+
+        let expected = r#"c1,c2,c3,c4,c5,c6,c7
+Lorem ipsum dolor sit amet,123.564532,3,true,,00:20:34,cupcakes
+consectetur adipiscing elit,,2,false,2019-04-18T10:54:47.378,06:51:20,cupcakes
+sed do eiusmod tempor,-556132.25,1,,2019-04-18T02:45:55.555,23:46:03,foo
+Lorem ipsum dolor sit amet,123.564532,3,true,,00:20:34,cupcakes
+consectetur adipiscing elit,,2,false,2019-04-18T10:54:47.378,06:51:20,cupcakes
+sed do eiusmod tempor,-556132.25,1,,2019-04-18T02:45:55.555,23:46:03,foo
+"#;
+        assert_eq!(expected.to_string(), String::from_utf8(buffer).unwrap());
+    }
+
+    #[test]
+    fn test_write_csv_decimal() {
+        let schema = Schema::new(vec![
+            Field::new("c1", DataType::Decimal128(38, 6), true),
+            Field::new("c2", DataType::Decimal256(76, 6), true),
+        ]);
+
+        let mut c1_builder = Decimal128Builder::new().with_data_type(DataType::Decimal128(38, 6));
+        c1_builder.extend(vec![Some(-3335724), Some(2179404), None, Some(290472)]);
+        let c1 = c1_builder.finish();
+
+        let mut c2_builder = Decimal256Builder::new().with_data_type(DataType::Decimal256(76, 6));
+        c2_builder.extend(vec![
+            Some(i256::from_i128(-3335724)),
+            Some(i256::from_i128(2179404)),
+            None,
+            Some(i256::from_i128(290472)),
+        ]);
+        let c2 = c2_builder.finish();
+
+        let batch =
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)]).unwrap();
+
+        let mut file = tempfile::tempfile().unwrap();
+
+        let mut writer = Writer::new(&mut file);
+        let batches = vec![&batch, &batch];
+        for batch in batches {
+            writer.write(batch).unwrap();
+        }
+        drop(writer);
+
+        // check that file was written successfully
+        file.rewind().unwrap();
+        let mut buffer: Vec<u8> = vec![];
+        file.read_to_end(&mut buffer).unwrap();
+
+        let expected = r#"c1,c2
+-3.335724,-3.335724
+2.179404,2.179404
+,
+0.290472,0.290472
+-3.335724,-3.335724
+2.179404,2.179404
+,
+0.290472,0.290472
+"#;
+        assert_eq!(expected.to_string(), String::from_utf8(buffer).unwrap());
+    }
+
+    #[test]
+    fn test_write_csv_custom_options() {
+        let schema = Schema::new(vec![
+            Field::new("c1", DataType::Utf8, false),
+            Field::new("c2", DataType::Float64, true),
+            Field::new("c3", DataType::UInt32, false),
+            Field::new("c4", DataType::Boolean, true),
+            Field::new("c6", DataType::Time32(TimeUnit::Second), false),
+        ]);
+
+        let c1 = StringArray::from(vec![
+            "Lorem ipsum \ndolor sit amet",
+            "consectetur \"adipiscing\" elit",
+            "sed do eiusmod tempor",
+        ]);
+        let c2 =
+            PrimitiveArray::<Float64Type>::from(vec![Some(123.564532), None, Some(-556132.25)]);
+        let c3 = PrimitiveArray::<UInt32Type>::from(vec![3, 2, 1]);
+        let c4 = BooleanArray::from(vec![Some(true), Some(false), None]);
+        let c6 = Time32SecondArray::from(vec![1234, 24680, 85563]);
+
+        let batch = RecordBatch::try_new(
+            Arc::new(schema),
+            vec![
+                Arc::new(c1),
+                Arc::new(c2),
+                Arc::new(c3),
+                Arc::new(c4),
+                Arc::new(c6),
+            ],
+        )
+        .unwrap();
+
+        let mut file = tempfile::tempfile().unwrap();
+
+        let builder = WriterBuilder::new()
+            .with_header(false)
+            .with_delimiter(b'|')
+            .with_quote(b'\'')
+            .with_null("NULL".to_string())
+            .with_time_format("%r".to_string());
+        let mut writer = builder.build(&mut file);
+        let batches = vec![&batch];
+        for batch in batches {
+            writer.write(batch).unwrap();
+        }
+        drop(writer);
+
+        // check that file was written successfully
+        file.rewind().unwrap();
+        let mut buffer: Vec<u8> = vec![];
+        file.read_to_end(&mut buffer).unwrap();
+
+        assert_eq!(
+            "'Lorem ipsum \ndolor sit amet'|123.564532|3|true|12:20:34 AM\nconsectetur \"adipiscing\" elit|NULL|2|false|06:51:20 AM\nsed do eiusmod tempor|-556132.25|1|NULL|11:46:03 PM\n"
+            .to_string(),
+            String::from_utf8(buffer).unwrap()
+        );
+
+        let mut file = tempfile::tempfile().unwrap();
+
+        let builder = WriterBuilder::new()
+            .with_header(true)
+            .with_double_quote(false)
+            .with_escape(b'$');
+        let mut writer = builder.build(&mut file);
+        let batches = vec![&batch];
+        for batch in batches {
+            writer.write(batch).unwrap();
+        }
+        drop(writer);
+
+        file.rewind().unwrap();
+        let mut buffer: Vec<u8> = vec![];
+        file.read_to_end(&mut buffer).unwrap();
+
+        assert_eq!(
+			"c1,c2,c3,c4,c6\n\"Lorem ipsum \ndolor sit amet\",123.564532,3,true,00:20:34\n\"consectetur $\"adipiscing$\" elit\",,2,false,06:51:20\nsed do eiusmod tempor,-556132.25,1,,23:46:03\n"
+			.to_string(),
+			String::from_utf8(buffer).unwrap()
+		);
+    }
+
+    #[test]
+    fn test_conversion_consistency() {
+        // test if we can serialize and deserialize whilst retaining the same type information/ precision
+
+        let schema = Schema::new(vec![
+            Field::new("c1", DataType::Date32, false),
+            Field::new("c2", DataType::Date64, false),
+            Field::new("c3", DataType::Timestamp(TimeUnit::Nanosecond, None), false),
+        ]);
+
+        let nanoseconds = vec![
+            1599566300000000000,
+            1599566200000000000,
+            1599566100000000000,
+        ];
+        let c1 = Date32Array::from(vec![3, 2, 1]);
+        let c2 = Date64Array::from(vec![3, 2, 1]);
+        let c3 = TimestampNanosecondArray::from(nanoseconds.clone());
+
+        let batch = RecordBatch::try_new(
+            Arc::new(schema.clone()),
+            vec![Arc::new(c1), Arc::new(c2), Arc::new(c3)],
+        )
+        .unwrap();
+
+        let builder = WriterBuilder::new().with_header(false);
+
+        let mut buf: Cursor<Vec<u8>> = Default::default();
+        // drop the writer early to release the borrow.
+        {
+            let mut writer = builder.build(&mut buf);
+            writer.write(&batch).unwrap();
+        }
+        buf.set_position(0);
+
+        let mut reader = ReaderBuilder::new(Arc::new(schema))
+            .with_batch_size(3)
+            .build_buffered(buf)
+            .unwrap();
+
+        let rb = reader.next().unwrap().unwrap();
+        let c1 = rb.column(0).as_any().downcast_ref::<Date32Array>().unwrap();
+        let c2 = rb.column(1).as_any().downcast_ref::<Date64Array>().unwrap();
+        let c3 = rb
+            .column(2)
+            .as_any()
+            .downcast_ref::<TimestampNanosecondArray>()
+            .unwrap();
+
+        let actual = c1.into_iter().collect::<Vec<_>>();
+        let expected = vec![Some(3), Some(2), Some(1)];
+        assert_eq!(actual, expected);
+        let actual = c2.into_iter().collect::<Vec<_>>();
+        let expected = vec![Some(3), Some(2), Some(1)];
+        assert_eq!(actual, expected);
+        let actual = c3.into_iter().collect::<Vec<_>>();
+        let expected = nanoseconds.into_iter().map(Some).collect::<Vec<_>>();
+        assert_eq!(actual, expected);
+    }
+
+    #[test]
+    fn test_write_csv_invalid_cast() {
+        let schema = Schema::new(vec![
+            Field::new("c0", DataType::UInt32, false),
+            Field::new("c1", DataType::Date64, false),
+        ]);
+
+        let c0 = UInt32Array::from(vec![Some(123), Some(234)]);
+        let c1 = Date64Array::from(vec![Some(1926632005177), Some(1926632005177685347)]);
+        let batch =
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c0), Arc::new(c1)]).unwrap();
+
+        let mut file = tempfile::tempfile().unwrap();
+        let mut writer = Writer::new(&mut file);
+        let batches = vec![&batch, &batch];
+
+        for batch in batches {
+            let err = writer.write(batch).unwrap_err().to_string();
+            assert_eq!(err, "Csv error: Error processing row 2, col 2: Cast error: Failed to convert 1926632005177685347 to temporal for Date64")
+        }
+        drop(writer);
+    }
+
+    #[test]
+    fn test_write_csv_using_rfc3339() {
+        let schema = Schema::new(vec![
+            Field::new(
+                "c1",
+                DataType::Timestamp(TimeUnit::Millisecond, Some("+00:00".into())),
+                true,
+            ),
+            Field::new("c2", DataType::Timestamp(TimeUnit::Millisecond, None), true),
+            Field::new("c3", DataType::Date32, false),
+            Field::new("c4", DataType::Time32(TimeUnit::Second), false),
+        ]);
+
+        let c1 = TimestampMillisecondArray::from(vec![Some(1555584887378), Some(1635577147000)])
+            .with_timezone("+00:00".to_string());
+        let c2 = TimestampMillisecondArray::from(vec![Some(1555584887378), Some(1635577147000)]);
+        let c3 = Date32Array::from(vec![3, 2]);
+        let c4 = Time32SecondArray::from(vec![1234, 24680]);
+
+        let batch = RecordBatch::try_new(
+            Arc::new(schema),
+            vec![Arc::new(c1), Arc::new(c2), Arc::new(c3), Arc::new(c4)],
+        )
+        .unwrap();
+
+        let mut file = tempfile::tempfile().unwrap();
+
+        let builder = WriterBuilder::new();
+        let mut writer = builder.build(&mut file);
+        let batches = vec![&batch];
+        for batch in batches {
+            writer.write(batch).unwrap();
+        }
+        drop(writer);
+
+        file.rewind().unwrap();
+        let mut buffer: Vec<u8> = vec![];
+        file.read_to_end(&mut buffer).unwrap();
+
+        assert_eq!(
+            "c1,c2,c3,c4
+2019-04-18T10:54:47.378Z,2019-04-18T10:54:47.378,1970-01-04,00:20:34
+2021-10-30T06:59:07Z,2021-10-30T06:59:07,1970-01-03,06:51:20\n",
+            String::from_utf8(buffer).unwrap()
+        );
+    }
+}
diff --git a/arrow-csv/test/data/custom_null_test.csv b/arrow-csv/test/data/custom_null_test.csv
new file mode 100644
index 000000000000..39f9fc4b3eff
--- /dev/null
+++ b/arrow-csv/test/data/custom_null_test.csv
@@ -0,0 +1,6 @@
+c_int,c_float,c_string,c_bool
+1,1.1,"1.11",True
+nil,2.2,"2.22",TRUE
+3,nil,"3.33",true
+4,4.4,nil,False
+5,6.6,"",nil
diff --git a/arrow/test/data/decimal_test.csv b/arrow-csv/test/data/decimal_test.csv
similarity index 100%
rename from arrow/test/data/decimal_test.csv
rename to arrow-csv/test/data/decimal_test.csv
diff --git a/arrow-csv/test/data/example.csv b/arrow-csv/test/data/example.csv
new file mode 100644
index 000000000000..0c03cee84528
--- /dev/null
+++ b/arrow-csv/test/data/example.csv
@@ -0,0 +1,4 @@
+c1,c2,c3,c4
+1,1.1,"hong kong",true
+3,323.12,"XiAn",false
+10,131323.12,"cheng du",false
\ No newline at end of file
diff --git a/arrow-csv/test/data/init_null_test.csv b/arrow-csv/test/data/init_null_test.csv
new file mode 100644
index 000000000000..f7d8a299645d
--- /dev/null
+++ b/arrow-csv/test/data/init_null_test.csv
@@ -0,0 +1,6 @@
+c_int,c_float,c_string,c_bool,c_null
+,,,,
+2,2.2,"a",TRUE,
+3,,"b",true,
+4,4.4,,False,
+5,6.6,"",FALSE,
\ No newline at end of file
diff --git a/arrow/test/data/null_test.csv b/arrow-csv/test/data/null_test.csv
similarity index 100%
rename from arrow/test/data/null_test.csv
rename to arrow-csv/test/data/null_test.csv
diff --git a/arrow/test/data/uk_cities.csv b/arrow-csv/test/data/uk_cities.csv
similarity index 100%
rename from arrow/test/data/uk_cities.csv
rename to arrow-csv/test/data/uk_cities.csv
diff --git a/arrow/test/data/uk_cities_with_headers.csv b/arrow-csv/test/data/uk_cities_with_headers.csv
similarity index 100%
rename from arrow/test/data/uk_cities_with_headers.csv
rename to arrow-csv/test/data/uk_cities_with_headers.csv
diff --git a/arrow/test/data/various_types.csv b/arrow-csv/test/data/various_types.csv
similarity index 100%
rename from arrow/test/data/various_types.csv
rename to arrow-csv/test/data/various_types.csv
diff --git a/arrow/test/data/various_types_invalid.csv b/arrow-csv/test/data/various_types_invalid.csv
similarity index 100%
rename from arrow/test/data/various_types_invalid.csv
rename to arrow-csv/test/data/various_types_invalid.csv
diff --git a/arrow-data/Cargo.toml b/arrow-data/Cargo.toml
new file mode 100644
index 000000000000..c83f867523d5
--- /dev/null
+++ b/arrow-data/Cargo.toml
@@ -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.
+
+[package]
+name = "arrow-data"
+version = { workspace = true }
+description = "Array data abstractions for Apache Arrow"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_data"
+path = "src/lib.rs"
+bench = false
+
+[features]
+# force_validate runs full data validation for all arrays that are created
+# this is not enabled by default as it is too computationally expensive
+# but is run as part of our CI checks
+force_validate = []
+# Enable ffi support
+ffi = ["arrow-schema/ffi"]
+
+[package.metadata.docs.rs]
+features = ["ffi"]
+
+[dependencies]
+
+arrow-buffer = { workspace = true }
+arrow-schema = { workspace = true }
+
+num = { version = "0.4", default-features = false, features = ["std"] }
+half = { version = "2.1", default-features = false }
+
+[dev-dependencies]
+
+[build-dependencies]
diff --git a/arrow-data/src/data.rs b/arrow-data/src/data.rs
new file mode 100644
index 000000000000..10c53c549e2b
--- /dev/null
+++ b/arrow-data/src/data.rs
@@ -0,0 +1,2122 @@
+// 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.
+
+//! Contains [`ArrayData`], a generic representation of Arrow array data which encapsulates
+//! common attributes and operations for Arrow array.
+
+use crate::bit_iterator::BitSliceIterator;
+use arrow_buffer::buffer::{BooleanBuffer, NullBuffer};
+use arrow_buffer::{bit_util, i256, ArrowNativeType, Buffer, MutableBuffer};
+use arrow_schema::{ArrowError, DataType, UnionMode};
+use std::convert::TryInto;
+use std::mem;
+use std::ops::Range;
+use std::sync::Arc;
+
+use crate::equal;
+
+/// A collection of [`Buffer`]
+#[doc(hidden)]
+#[deprecated(note = "Use [Buffer]")]
+pub type Buffers<'a> = &'a [Buffer];
+
+#[inline]
+pub(crate) fn contains_nulls(
+    null_bit_buffer: Option<&NullBuffer>,
+    offset: usize,
+    len: usize,
+) -> bool {
+    match null_bit_buffer {
+        Some(buffer) => {
+            match BitSliceIterator::new(buffer.validity(), buffer.offset() + offset, len).next() {
+                Some((start, end)) => start != 0 || end != len,
+                None => len != 0, // No non-null values
+            }
+        }
+        None => false, // No null buffer
+    }
+}
+
+#[inline]
+pub(crate) fn count_nulls(
+    null_bit_buffer: Option<&NullBuffer>,
+    offset: usize,
+    len: usize,
+) -> usize {
+    if let Some(buf) = null_bit_buffer {
+        let buffer = buf.buffer();
+        len - buffer.count_set_bits_offset(offset + buf.offset(), len)
+    } else {
+        0
+    }
+}
+
+/// creates 2 [`MutableBuffer`]s with a given `capacity` (in slots).
+#[inline]
+pub(crate) fn new_buffers(data_type: &DataType, capacity: usize) -> [MutableBuffer; 2] {
+    let empty_buffer = MutableBuffer::new(0);
+    match data_type {
+        DataType::Null => [empty_buffer, MutableBuffer::new(0)],
+        DataType::Boolean => {
+            let bytes = bit_util::ceil(capacity, 8);
+            let buffer = MutableBuffer::new(bytes);
+            [buffer, empty_buffer]
+        }
+        DataType::UInt8
+        | DataType::UInt16
+        | DataType::UInt32
+        | DataType::UInt64
+        | DataType::Int8
+        | DataType::Int16
+        | DataType::Int32
+        | DataType::Int64
+        | DataType::Float16
+        | DataType::Float32
+        | DataType::Float64
+        | DataType::Date32
+        | DataType::Time32(_)
+        | DataType::Date64
+        | DataType::Time64(_)
+        | DataType::Duration(_)
+        | DataType::Timestamp(_, _)
+        | DataType::Interval(_) => [
+            MutableBuffer::new(capacity * data_type.primitive_width().unwrap()),
+            empty_buffer,
+        ],
+        DataType::Utf8 | DataType::Binary => {
+            let mut buffer = MutableBuffer::new((1 + capacity) * mem::size_of::<i32>());
+            // safety: `unsafe` code assumes that this buffer is initialized with one element
+            buffer.push(0i32);
+            [buffer, MutableBuffer::new(capacity * mem::size_of::<u8>())]
+        }
+        DataType::LargeUtf8 | DataType::LargeBinary => {
+            let mut buffer = MutableBuffer::new((1 + capacity) * mem::size_of::<i64>());
+            // safety: `unsafe` code assumes that this buffer is initialized with one element
+            buffer.push(0i64);
+            [buffer, MutableBuffer::new(capacity * mem::size_of::<u8>())]
+        }
+        DataType::List(_) | DataType::Map(_, _) => {
+            // offset buffer always starts with a zero
+            let mut buffer = MutableBuffer::new((1 + capacity) * mem::size_of::<i32>());
+            buffer.push(0i32);
+            [buffer, empty_buffer]
+        }
+        DataType::LargeList(_) => {
+            // offset buffer always starts with a zero
+            let mut buffer = MutableBuffer::new((1 + capacity) * mem::size_of::<i64>());
+            buffer.push(0i64);
+            [buffer, empty_buffer]
+        }
+        DataType::FixedSizeBinary(size) => {
+            [MutableBuffer::new(capacity * *size as usize), empty_buffer]
+        }
+        DataType::Dictionary(k, _) => [
+            MutableBuffer::new(capacity * k.primitive_width().unwrap()),
+            empty_buffer,
+        ],
+        DataType::FixedSizeList(_, _) | DataType::Struct(_) | DataType::RunEndEncoded(_, _) => {
+            [empty_buffer, MutableBuffer::new(0)]
+        }
+        DataType::Decimal128(_, _) | DataType::Decimal256(_, _) => [
+            MutableBuffer::new(capacity * mem::size_of::<u8>()),
+            empty_buffer,
+        ],
+        DataType::Union(_, mode) => {
+            let type_ids = MutableBuffer::new(capacity * mem::size_of::<i8>());
+            match mode {
+                UnionMode::Sparse => [type_ids, empty_buffer],
+                UnionMode::Dense => {
+                    let offsets = MutableBuffer::new(capacity * mem::size_of::<i32>());
+                    [type_ids, offsets]
+                }
+            }
+        }
+    }
+}
+
+/// Maps 2 [`MutableBuffer`]s into a vector of [Buffer]s whose size depends on `data_type`.
+#[inline]
+pub(crate) fn into_buffers(
+    data_type: &DataType,
+    buffer1: MutableBuffer,
+    buffer2: MutableBuffer,
+) -> Vec<Buffer> {
+    match data_type {
+        DataType::Null | DataType::Struct(_) | DataType::FixedSizeList(_, _) => vec![],
+        DataType::Utf8 | DataType::Binary | DataType::LargeUtf8 | DataType::LargeBinary => {
+            vec![buffer1.into(), buffer2.into()]
+        }
+        DataType::Union(_, mode) => {
+            match mode {
+                // Based on Union's DataTypeLayout
+                UnionMode::Sparse => vec![buffer1.into()],
+                UnionMode::Dense => vec![buffer1.into(), buffer2.into()],
+            }
+        }
+        _ => vec![buffer1.into()],
+    }
+}
+
+/// A generic representation of Arrow array data which encapsulates common attributes and
+/// operations for Arrow array. Specific operations for different arrays types (e.g.,
+/// primitive, list, struct) are implemented in `Array`.
+///
+/// # Memory Layout
+///
+/// `ArrayData` has references to one or more underlying data buffers
+/// and optional child ArrayData, depending on type as illustrated
+/// below. Bitmaps are not shown for simplicity but they are stored
+/// similarly to the buffers.
+///
+/// ```text
+///                        offset
+///                       points to
+/// ┌───────────────────┐ start of  ┌───────┐       Different
+/// │                   │   data    │       │     ArrayData may
+/// │ArrayData {        │           │....   │     also refers to
+/// │  data_type: ...   │   ─ ─ ─ ─▶│1234   │  ┌ ─  the same
+/// │  offset: ... ─ ─ ─│─ ┘        │4372   │      underlying
+/// │  len: ...    ─ ─ ─│─ ┐        │4888   │  │     buffer with different offset/len
+/// │  buffers: [       │           │5882   │◀─
+/// │    ...            │  │        │4323   │
+/// │  ]                │   ─ ─ ─ ─▶│4859   │
+/// │  child_data: [    │           │....   │
+/// │    ...            │           │       │
+/// │  ]                │           └───────┘
+/// │}                  │
+/// │                   │            Shared Buffer uses
+/// │               │   │            bytes::Bytes to hold
+/// └───────────────────┘            actual data values
+///           ┌ ─ ─ ┘
+///
+///           ▼
+/// ┌───────────────────┐
+/// │ArrayData {        │
+/// │  ...              │
+/// │}                  │
+/// │                   │
+/// └───────────────────┘
+///
+/// Child ArrayData may also have its own buffers and children
+/// ```
+
+#[derive(Debug, Clone)]
+pub struct ArrayData {
+    /// The data type for this array data
+    data_type: DataType,
+
+    /// The number of elements in this array data
+    len: usize,
+
+    /// The offset into this array data, in number of items
+    offset: usize,
+
+    /// The buffers for this array data. Note that depending on the array types, this
+    /// could hold different kinds of buffers (e.g., value buffer, value offset buffer)
+    /// at different positions.
+    buffers: Vec<Buffer>,
+
+    /// The child(ren) of this array. Only non-empty for nested types, currently
+    /// `ListArray` and `StructArray`.
+    child_data: Vec<ArrayData>,
+
+    /// The null bitmap. A `None` value for this indicates all values are non-null in
+    /// this array.
+    nulls: Option<NullBuffer>,
+}
+
+pub type ArrayDataRef = Arc<ArrayData>;
+
+impl ArrayData {
+    /// Create a new ArrayData instance;
+    ///
+    /// If `null_count` is not specified, the number of nulls in
+    /// null_bit_buffer is calculated.
+    ///
+    /// If the number of nulls is 0 then the null_bit_buffer
+    /// is set to `None`.
+    ///
+    /// # Safety
+    ///
+    /// The input values *must* form a valid Arrow array for
+    /// `data_type`, or undefined behavior can result.
+    ///
+    /// Note: This is a low level API and most users of the arrow
+    /// crate should create arrays using the methods in the `array`
+    /// module.
+    pub unsafe fn new_unchecked(
+        data_type: DataType,
+        len: usize,
+        null_count: Option<usize>,
+        null_bit_buffer: Option<Buffer>,
+        offset: usize,
+        buffers: Vec<Buffer>,
+        child_data: Vec<ArrayData>,
+    ) -> Self {
+        ArrayDataBuilder {
+            data_type,
+            len,
+            null_count,
+            null_bit_buffer,
+            nulls: None,
+            offset,
+            buffers,
+            child_data,
+        }
+        .build_unchecked()
+    }
+
+    /// Create a new ArrayData, validating that the provided buffers form a valid
+    /// Arrow array of the specified data type.
+    ///
+    /// If the number of nulls in `null_bit_buffer` is 0 then the null_bit_buffer
+    /// is set to `None`.
+    ///
+    /// Internally this calls through to [`Self::validate_data`]
+    ///
+    /// Note: This is a low level API and most users of the arrow crate should create
+    /// arrays using the builders found in [arrow_array](https://docs.rs/arrow-array)
+    pub fn try_new(
+        data_type: DataType,
+        len: usize,
+        null_bit_buffer: Option<Buffer>,
+        offset: usize,
+        buffers: Vec<Buffer>,
+        child_data: Vec<ArrayData>,
+    ) -> Result<Self, ArrowError> {
+        // we must check the length of `null_bit_buffer` first
+        // because we use this buffer to calculate `null_count`
+        // in `Self::new_unchecked`.
+        if let Some(null_bit_buffer) = null_bit_buffer.as_ref() {
+            let needed_len = bit_util::ceil(len + offset, 8);
+            if null_bit_buffer.len() < needed_len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "null_bit_buffer size too small. got {} needed {}",
+                    null_bit_buffer.len(),
+                    needed_len
+                )));
+            }
+        }
+        // Safety justification: `validate_full` is called below
+        let new_self = unsafe {
+            Self::new_unchecked(
+                data_type,
+                len,
+                None,
+                null_bit_buffer,
+                offset,
+                buffers,
+                child_data,
+            )
+        };
+
+        // As the data is not trusted, do a full validation of its contents
+        // We don't need to validate children as we can assume that the
+        // [`ArrayData`] in `child_data` have already been validated through
+        // a call to `ArrayData::try_new` or created using unsafe
+        new_self.validate_data()?;
+        Ok(new_self)
+    }
+
+    /// Returns a builder to construct a [`ArrayData`] instance of the same [`DataType`]
+    #[inline]
+    pub const fn builder(data_type: DataType) -> ArrayDataBuilder {
+        ArrayDataBuilder::new(data_type)
+    }
+
+    /// Returns a reference to the [`DataType`] of this [`ArrayData`]
+    #[inline]
+    pub const fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    /// Returns the [`Buffer`] storing data for this [`ArrayData`]
+    pub fn buffers(&self) -> &[Buffer] {
+        &self.buffers
+    }
+
+    /// Returns a slice of children [`ArrayData`]. This will be non
+    /// empty for type such as lists and structs.
+    pub fn child_data(&self) -> &[ArrayData] {
+        &self.child_data[..]
+    }
+
+    /// Returns whether the element at index `i` is null
+    #[inline]
+    pub fn is_null(&self, i: usize) -> bool {
+        match &self.nulls {
+            Some(v) => v.is_null(i),
+            None => false,
+        }
+    }
+
+    /// Returns a reference to the null buffer of this [`ArrayData`] if any
+    ///
+    /// Note: [`ArrayData::offset`] does NOT apply to the returned [`NullBuffer`]
+    #[inline]
+    pub fn nulls(&self) -> Option<&NullBuffer> {
+        self.nulls.as_ref()
+    }
+
+    /// Returns whether the element at index `i` is not null
+    #[inline]
+    pub fn is_valid(&self, i: usize) -> bool {
+        !self.is_null(i)
+    }
+
+    /// Returns the length (i.e., number of elements) of this [`ArrayData`].
+    #[inline]
+    pub const fn len(&self) -> usize {
+        self.len
+    }
+
+    /// Returns whether this [`ArrayData`] is empty
+    #[inline]
+    pub const fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    /// Returns the offset of this [`ArrayData`]
+    #[inline]
+    pub const fn offset(&self) -> usize {
+        self.offset
+    }
+
+    /// Returns the total number of nulls in this array
+    #[inline]
+    pub fn null_count(&self) -> usize {
+        self.nulls
+            .as_ref()
+            .map(|x| x.null_count())
+            .unwrap_or_default()
+    }
+
+    /// Returns the total number of bytes of memory occupied by the
+    /// buffers owned by this [`ArrayData`] and all of its
+    /// children. (See also diagram on [`ArrayData`]).
+    ///
+    /// Note that this [`ArrayData`] may only refer to a subset of the
+    /// data in the underlying [`Buffer`]s (due to `offset` and
+    /// `length`), but the size returned includes the entire size of
+    /// the buffers.
+    ///
+    /// If multiple [`ArrayData`]s refer to the same underlying
+    /// [`Buffer`]s they will both report the same size.
+    pub fn get_buffer_memory_size(&self) -> usize {
+        let mut size = 0;
+        for buffer in &self.buffers {
+            size += buffer.capacity();
+        }
+        if let Some(bitmap) = &self.nulls {
+            size += bitmap.buffer().capacity()
+        }
+        for child in &self.child_data {
+            size += child.get_buffer_memory_size();
+        }
+        size
+    }
+
+    /// Returns the total number of the bytes of memory occupied by
+    /// the buffers by this slice of [`ArrayData`] (See also diagram on [`ArrayData`]).
+    ///
+    /// This is approximately the number of bytes if a new
+    /// [`ArrayData`] was formed by creating new [`Buffer`]s with
+    /// exactly the data needed.
+    ///
+    /// For example, a [`DataType::Int64`] with `100` elements,
+    /// [`Self::get_slice_memory_size`] would return `100 * 8 = 800`. If
+    /// the [`ArrayData`] was then [`Self::slice`]ed to refer to its
+    /// first `20` elements, then [`Self::get_slice_memory_size`] on the
+    /// sliced [`ArrayData`] would return `20 * 8 = 160`.
+    pub fn get_slice_memory_size(&self) -> Result<usize, ArrowError> {
+        let mut result: usize = 0;
+        let layout = layout(&self.data_type);
+
+        for spec in layout.buffers.iter() {
+            match spec {
+                BufferSpec::FixedWidth { byte_width, .. } => {
+                    let buffer_size = self.len.checked_mul(*byte_width).ok_or_else(|| {
+                        ArrowError::ComputeError(
+                            "Integer overflow computing buffer size".to_string(),
+                        )
+                    })?;
+                    result += buffer_size;
+                }
+                BufferSpec::VariableWidth => {
+                    let buffer_len: usize;
+                    match self.data_type {
+                        DataType::Utf8 | DataType::Binary => {
+                            let offsets = self.typed_offsets::<i32>()?;
+                            buffer_len = (offsets[self.len] - offsets[0] ) as usize;
+                        }
+                        DataType::LargeUtf8 | DataType::LargeBinary => {
+                            let offsets = self.typed_offsets::<i64>()?;
+                            buffer_len = (offsets[self.len] - offsets[0]) as usize;
+                        }
+                        _ => {
+                            return Err(ArrowError::NotYetImplemented(format!(
+                            "Invalid data type for VariableWidth buffer. Expected Utf8, LargeUtf8, Binary or LargeBinary. Got {}",
+                            self.data_type
+                            )))
+                        }
+                    };
+                    result += buffer_len;
+                }
+                BufferSpec::BitMap => {
+                    let buffer_size = bit_util::ceil(self.len, 8);
+                    result += buffer_size;
+                }
+                BufferSpec::AlwaysNull => {
+                    // Nothing to do
+                }
+            }
+        }
+
+        if self.nulls().is_some() {
+            result += bit_util::ceil(self.len, 8);
+        }
+
+        for child in &self.child_data {
+            result += child.get_slice_memory_size()?;
+        }
+        Ok(result)
+    }
+
+    /// Returns the total number of bytes of memory occupied
+    /// physically by this [`ArrayData`] and all its [`Buffer`]s and
+    /// children. (See also diagram on [`ArrayData`]).
+    ///
+    /// Equivalent to:
+    ///  `size_of_val(self)` +
+    ///  [`Self::get_buffer_memory_size`] +
+    ///  `size_of_val(child)` for all children
+    pub fn get_array_memory_size(&self) -> usize {
+        let mut size = mem::size_of_val(self);
+
+        // Calculate rest of the fields top down which contain actual data
+        for buffer in &self.buffers {
+            size += mem::size_of::<Buffer>();
+            size += buffer.capacity();
+        }
+        if let Some(nulls) = &self.nulls {
+            size += nulls.buffer().capacity();
+        }
+        for child in &self.child_data {
+            size += child.get_array_memory_size();
+        }
+
+        size
+    }
+
+    /// Creates a zero-copy slice of itself. This creates a new
+    /// [`ArrayData`] pointing at the same underlying [`Buffer`]s with a
+    /// different offset and len
+    ///
+    /// # Panics
+    ///
+    /// Panics if `offset + length > self.len()`.
+    pub fn slice(&self, offset: usize, length: usize) -> ArrayData {
+        assert!((offset + length) <= self.len());
+
+        if let DataType::Struct(_) = self.data_type() {
+            // Slice into children
+            let new_offset = self.offset + offset;
+            let new_data = ArrayData {
+                data_type: self.data_type().clone(),
+                len: length,
+                offset: new_offset,
+                buffers: self.buffers.clone(),
+                // Slice child data, to propagate offsets down to them
+                child_data: self
+                    .child_data()
+                    .iter()
+                    .map(|data| data.slice(offset, length))
+                    .collect(),
+                nulls: self.nulls.as_ref().map(|x| x.slice(offset, length)),
+            };
+
+            new_data
+        } else {
+            let mut new_data = self.clone();
+
+            new_data.len = length;
+            new_data.offset = offset + self.offset;
+            new_data.nulls = self.nulls.as_ref().map(|x| x.slice(offset, length));
+
+            new_data
+        }
+    }
+
+    /// Returns the `buffer` as a slice of type `T` starting at self.offset
+    /// # Panics
+    /// This function panics if:
+    /// * the buffer is not byte-aligned with type T, or
+    /// * the datatype is `Boolean` (it corresponds to a bit-packed buffer where the offset is not applicable)
+    pub fn buffer<T: ArrowNativeType>(&self, buffer: usize) -> &[T] {
+        &self.buffers()[buffer].typed_data()[self.offset..]
+    }
+
+    /// Returns a new [`ArrayData`] valid for `data_type` containing `len` null values
+    pub fn new_null(data_type: &DataType, len: usize) -> Self {
+        let bit_len = bit_util::ceil(len, 8);
+        let zeroed = |len: usize| Buffer::from(MutableBuffer::from_len_zeroed(len));
+
+        let (buffers, child_data, has_nulls) = match data_type.primitive_width() {
+            Some(width) => (vec![zeroed(width * len)], vec![], true),
+            None => match data_type {
+                DataType::Null => (vec![], vec![], false),
+                DataType::Boolean => (vec![zeroed(bit_len)], vec![], true),
+                DataType::Binary | DataType::Utf8 => {
+                    (vec![zeroed((len + 1) * 4), zeroed(0)], vec![], true)
+                }
+                DataType::LargeBinary | DataType::LargeUtf8 => {
+                    (vec![zeroed((len + 1) * 8), zeroed(0)], vec![], true)
+                }
+                DataType::FixedSizeBinary(i) => (vec![zeroed(*i as usize * len)], vec![], true),
+                DataType::List(f) | DataType::Map(f, _) => (
+                    vec![zeroed((len + 1) * 4)],
+                    vec![ArrayData::new_empty(f.data_type())],
+                    true,
+                ),
+                DataType::LargeList(f) => (
+                    vec![zeroed((len + 1) * 8)],
+                    vec![ArrayData::new_empty(f.data_type())],
+                    true,
+                ),
+                DataType::FixedSizeList(f, list_len) => (
+                    vec![],
+                    vec![ArrayData::new_null(f.data_type(), *list_len as usize * len)],
+                    true,
+                ),
+                DataType::Struct(fields) => (
+                    vec![],
+                    fields
+                        .iter()
+                        .map(|f| Self::new_null(f.data_type(), len))
+                        .collect(),
+                    true,
+                ),
+                DataType::Dictionary(k, v) => (
+                    vec![zeroed(k.primitive_width().unwrap() * len)],
+                    vec![ArrayData::new_empty(v.as_ref())],
+                    true,
+                ),
+                DataType::Union(f, mode) => {
+                    let (id, _) = f.iter().next().unwrap();
+                    let ids = Buffer::from_iter(std::iter::repeat(id).take(len));
+                    let buffers = match mode {
+                        UnionMode::Sparse => vec![ids],
+                        UnionMode::Dense => {
+                            let end_offset = i32::from_usize(len).unwrap();
+                            vec![ids, Buffer::from_iter(0_i32..end_offset)]
+                        }
+                    };
+
+                    let children = f
+                        .iter()
+                        .enumerate()
+                        .map(|(idx, (_, f))| {
+                            if idx == 0 || *mode == UnionMode::Sparse {
+                                Self::new_null(f.data_type(), len)
+                            } else {
+                                Self::new_empty(f.data_type())
+                            }
+                        })
+                        .collect();
+
+                    (buffers, children, false)
+                }
+                DataType::RunEndEncoded(r, v) => {
+                    let runs = match r.data_type() {
+                        DataType::Int16 => {
+                            let i = i16::from_usize(len).expect("run overflow");
+                            Buffer::from_slice_ref([i])
+                        }
+                        DataType::Int32 => {
+                            let i = i32::from_usize(len).expect("run overflow");
+                            Buffer::from_slice_ref([i])
+                        }
+                        DataType::Int64 => {
+                            let i = i64::from_usize(len).expect("run overflow");
+                            Buffer::from_slice_ref([i])
+                        }
+                        dt => unreachable!("Invalid run ends data type {dt}"),
+                    };
+
+                    let builder = ArrayData::builder(r.data_type().clone())
+                        .len(1)
+                        .buffers(vec![runs]);
+
+                    // SAFETY:
+                    // Valid by construction
+                    let runs = unsafe { builder.build_unchecked() };
+                    (
+                        vec![],
+                        vec![runs, ArrayData::new_null(v.data_type(), 1)],
+                        false,
+                    )
+                }
+                d => unreachable!("{d}"),
+            },
+        };
+
+        let mut builder = ArrayDataBuilder::new(data_type.clone())
+            .len(len)
+            .buffers(buffers)
+            .child_data(child_data);
+
+        if has_nulls {
+            builder = builder.nulls(Some(NullBuffer::new_null(len)))
+        }
+
+        // SAFETY:
+        // Data valid by construction
+        unsafe { builder.build_unchecked() }
+    }
+
+    /// Returns a new empty [ArrayData] valid for `data_type`.
+    pub fn new_empty(data_type: &DataType) -> Self {
+        Self::new_null(data_type, 0)
+    }
+
+    /// Verifies that the buffers meet the minimum alignment requirements for the data type
+    ///
+    /// Buffers that are not adequately aligned will be copied to a new aligned allocation
+    ///
+    /// This can be useful for when interacting with data sent over IPC or FFI, that may
+    /// not meet the minimum alignment requirements
+    pub fn align_buffers(&mut self) {
+        let layout = layout(&self.data_type);
+        for (buffer, spec) in self.buffers.iter_mut().zip(&layout.buffers) {
+            if let BufferSpec::FixedWidth { alignment, .. } = spec {
+                if buffer.as_ptr().align_offset(*alignment) != 0 {
+                    *buffer = Buffer::from_slice_ref(buffer.as_ref())
+                }
+            }
+        }
+    }
+
+    /// "cheap" validation of an `ArrayData`. Ensures buffers are
+    /// sufficiently sized to store `len` + `offset` total elements of
+    /// `data_type` and performs other inexpensive consistency checks.
+    ///
+    /// This check is "cheap" in the sense that it does not validate the
+    /// contents of the buffers (e.g. that all offsets for UTF8 arrays
+    /// are within the bounds of the values buffer).
+    ///
+    /// See [ArrayData::validate_data] to validate fully the offset content
+    /// and the validity of utf8 data
+    pub fn validate(&self) -> Result<(), ArrowError> {
+        // Need at least this mich space in each buffer
+        let len_plus_offset = self.len + self.offset;
+
+        // Check that the data layout conforms to the spec
+        let layout = layout(&self.data_type);
+
+        if !layout.can_contain_null_mask && self.nulls.is_some() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Arrays of type {:?} cannot contain a null bitmask",
+                self.data_type,
+            )));
+        }
+
+        if self.buffers.len() != layout.buffers.len() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Expected {} buffers in array of type {:?}, got {}",
+                layout.buffers.len(),
+                self.data_type,
+                self.buffers.len(),
+            )));
+        }
+
+        for (i, (buffer, spec)) in self.buffers.iter().zip(layout.buffers.iter()).enumerate() {
+            match spec {
+                BufferSpec::FixedWidth {
+                    byte_width,
+                    alignment,
+                } => {
+                    let min_buffer_size = len_plus_offset.saturating_mul(*byte_width);
+
+                    if buffer.len() < min_buffer_size {
+                        return Err(ArrowError::InvalidArgumentError(format!(
+                            "Need at least {} bytes in buffers[{}] in array of type {:?}, but got {}",
+                            min_buffer_size, i, self.data_type, buffer.len()
+                        )));
+                    }
+
+                    let align_offset = buffer.as_ptr().align_offset(*alignment);
+                    if align_offset != 0 {
+                        return Err(ArrowError::InvalidArgumentError(format!(
+                            "Misaligned buffers[{i}] in array of type {:?}, offset from expected alignment of {alignment} by {}",
+                            self.data_type, align_offset.min(alignment - align_offset)
+                        )));
+                    }
+                }
+                BufferSpec::VariableWidth => {
+                    // not cheap to validate (need to look at the
+                    // data). Partially checked in validate_offsets
+                    // called below. Can check with `validate_full`
+                }
+                BufferSpec::BitMap => {
+                    let min_buffer_size = bit_util::ceil(len_plus_offset, 8);
+                    if buffer.len() < min_buffer_size {
+                        return Err(ArrowError::InvalidArgumentError(format!(
+                            "Need at least {} bytes for bitmap in buffers[{}] in array of type {:?}, but got {}",
+                            min_buffer_size, i, self.data_type, buffer.len()
+                        )));
+                    }
+                }
+                BufferSpec::AlwaysNull => {
+                    // Nothing to validate
+                }
+            }
+        }
+
+        // check null bit buffer size
+        if let Some(nulls) = self.nulls() {
+            if nulls.null_count() > self.len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "null_count {} for an array exceeds length of {} elements",
+                    nulls.null_count(),
+                    self.len
+                )));
+            }
+
+            let actual_len = nulls.validity().len();
+            let needed_len = bit_util::ceil(len_plus_offset, 8);
+            if actual_len < needed_len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "null_bit_buffer size too small. got {actual_len} needed {needed_len}",
+                )));
+            }
+
+            if nulls.len() != self.len {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "null buffer incorrect size. got {} expected {}",
+                    nulls.len(),
+                    self.len
+                )));
+            }
+        }
+
+        self.validate_child_data()?;
+
+        // Additional Type specific checks
+        match &self.data_type {
+            DataType::Utf8 | DataType::Binary => {
+                self.validate_offsets::<i32>(self.buffers[1].len())?;
+            }
+            DataType::LargeUtf8 | DataType::LargeBinary => {
+                self.validate_offsets::<i64>(self.buffers[1].len())?;
+            }
+            DataType::Dictionary(key_type, _value_type) => {
+                // At the moment, constructing a DictionaryArray will also check this
+                if !DataType::is_dictionary_key_type(key_type) {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "Dictionary key type must be integer, but was {key_type}"
+                    )));
+                }
+            }
+            DataType::RunEndEncoded(run_ends_type, _) => {
+                if run_ends_type.is_nullable() {
+                    return Err(ArrowError::InvalidArgumentError(
+                        "The nullable should be set to false for the field defining run_ends array.".to_string()
+                    ));
+                }
+                if !DataType::is_run_ends_type(run_ends_type.data_type()) {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "RunArray run_ends types must be Int16, Int32 or Int64, but was {}",
+                        run_ends_type.data_type()
+                    )));
+                }
+            }
+            _ => {}
+        };
+
+        Ok(())
+    }
+
+    /// Returns a reference to the data in `buffer` as a typed slice
+    /// (typically `&[i32]` or `&[i64]`) after validating. The
+    /// returned slice is guaranteed to have at least `self.len + 1`
+    /// entries.
+    ///
+    /// For an empty array, the `buffer` can also be empty.
+    fn typed_offsets<T: ArrowNativeType + num::Num>(&self) -> Result<&[T], ArrowError> {
+        // An empty list-like array can have 0 offsets
+        if self.len == 0 && self.buffers[0].is_empty() {
+            return Ok(&[]);
+        }
+
+        self.typed_buffer(0, self.len + 1)
+    }
+
+    /// Returns a reference to the data in `buffers[idx]` as a typed slice after validating
+    fn typed_buffer<T: ArrowNativeType + num::Num>(
+        &self,
+        idx: usize,
+        len: usize,
+    ) -> Result<&[T], ArrowError> {
+        let buffer = &self.buffers[idx];
+
+        let required_len = (len + self.offset) * mem::size_of::<T>();
+
+        if buffer.len() < required_len {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Buffer {} of {} isn't large enough. Expected {} bytes got {}",
+                idx,
+                self.data_type,
+                required_len,
+                buffer.len()
+            )));
+        }
+
+        Ok(&buffer.typed_data::<T>()[self.offset..self.offset + len])
+    }
+
+    /// Does a cheap sanity check that the `self.len` values in `buffer` are valid
+    /// offsets (of type T) into some other buffer of `values_length` bytes long
+    fn validate_offsets<T: ArrowNativeType + num::Num + std::fmt::Display>(
+        &self,
+        values_length: usize,
+    ) -> Result<(), ArrowError> {
+        // Justification: buffer size was validated above
+        let offsets = self.typed_offsets::<T>()?;
+        if offsets.is_empty() {
+            return Ok(());
+        }
+
+        let first_offset = offsets[0].to_usize().ok_or_else(|| {
+            ArrowError::InvalidArgumentError(format!(
+                "Error converting offset[0] ({}) to usize for {}",
+                offsets[0], self.data_type
+            ))
+        })?;
+
+        let last_offset = offsets[self.len].to_usize().ok_or_else(|| {
+            ArrowError::InvalidArgumentError(format!(
+                "Error converting offset[{}] ({}) to usize for {}",
+                self.len, offsets[self.len], self.data_type
+            ))
+        })?;
+
+        if first_offset > values_length {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "First offset {} of {} is larger than values length {}",
+                first_offset, self.data_type, values_length,
+            )));
+        }
+
+        if last_offset > values_length {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Last offset {} of {} is larger than values length {}",
+                last_offset, self.data_type, values_length,
+            )));
+        }
+
+        if first_offset > last_offset {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "First offset {} in {} is smaller than last offset {}",
+                first_offset, self.data_type, last_offset,
+            )));
+        }
+
+        Ok(())
+    }
+
+    /// Validates the layout of `child_data` ArrayData structures
+    fn validate_child_data(&self) -> Result<(), ArrowError> {
+        match &self.data_type {
+            DataType::List(field) | DataType::Map(field, _) => {
+                let values_data = self.get_single_valid_child_data(field.data_type())?;
+                self.validate_offsets::<i32>(values_data.len)?;
+                Ok(())
+            }
+            DataType::LargeList(field) => {
+                let values_data = self.get_single_valid_child_data(field.data_type())?;
+                self.validate_offsets::<i64>(values_data.len)?;
+                Ok(())
+            }
+            DataType::FixedSizeList(field, list_size) => {
+                let values_data = self.get_single_valid_child_data(field.data_type())?;
+
+                let list_size: usize = (*list_size).try_into().map_err(|_| {
+                    ArrowError::InvalidArgumentError(format!(
+                        "{} has a negative list_size {}",
+                        self.data_type, list_size
+                    ))
+                })?;
+
+                let expected_values_len = self.len
+                    .checked_mul(list_size)
+                    .expect("integer overflow computing expected number of expected values in FixedListSize");
+
+                if values_data.len < expected_values_len {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "Values length {} is less than the length ({}) multiplied by the value size ({}) for {}",
+                        values_data.len, list_size, list_size, self.data_type
+                    )));
+                }
+
+                Ok(())
+            }
+            DataType::Struct(fields) => {
+                self.validate_num_child_data(fields.len())?;
+                for (i, field) in fields.iter().enumerate() {
+                    let field_data = self.get_valid_child_data(i, field.data_type())?;
+
+                    // Ensure child field has sufficient size
+                    if field_data.len < self.len {
+                        return Err(ArrowError::InvalidArgumentError(format!(
+                            "{} child array #{} for field {} has length smaller than expected for struct array ({} < {})",
+                            self.data_type, i, field.name(), field_data.len, self.len
+                        )));
+                    }
+                }
+                Ok(())
+            }
+            DataType::RunEndEncoded(run_ends_field, values_field) => {
+                self.validate_num_child_data(2)?;
+                let run_ends_data = self.get_valid_child_data(0, run_ends_field.data_type())?;
+                let values_data = self.get_valid_child_data(1, values_field.data_type())?;
+                if run_ends_data.len != values_data.len {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "The run_ends array length should be the same as values array length. Run_ends array length is {}, values array length is {}",
+                        run_ends_data.len, values_data.len
+                    )));
+                }
+                if run_ends_data.nulls.is_some() {
+                    return Err(ArrowError::InvalidArgumentError(
+                        "Found null values in run_ends array. The run_ends array should not have null values.".to_string(),
+                    ));
+                }
+                Ok(())
+            }
+            DataType::Union(fields, mode) => {
+                self.validate_num_child_data(fields.len())?;
+
+                for (i, (_, field)) in fields.iter().enumerate() {
+                    let field_data = self.get_valid_child_data(i, field.data_type())?;
+
+                    if mode == &UnionMode::Sparse && field_data.len < (self.len + self.offset) {
+                        return Err(ArrowError::InvalidArgumentError(format!(
+                            "Sparse union child array #{} has length smaller than expected for union array ({} < {})",
+                            i, field_data.len, self.len + self.offset
+                        )));
+                    }
+                }
+                Ok(())
+            }
+            DataType::Dictionary(_key_type, value_type) => {
+                self.get_single_valid_child_data(value_type)?;
+                Ok(())
+            }
+            _ => {
+                // other types do not have child data
+                if !self.child_data.is_empty() {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "Expected no child arrays for type {} but got {}",
+                        self.data_type,
+                        self.child_data.len()
+                    )));
+                }
+                Ok(())
+            }
+        }
+    }
+
+    /// Ensures that this array data has a single child_data with the
+    /// expected type, and calls `validate()` on it. Returns a
+    /// reference to that child_data
+    fn get_single_valid_child_data(
+        &self,
+        expected_type: &DataType,
+    ) -> Result<&ArrayData, ArrowError> {
+        self.validate_num_child_data(1)?;
+        self.get_valid_child_data(0, expected_type)
+    }
+
+    /// Returns `Err` if self.child_data does not have exactly `expected_len` elements
+    fn validate_num_child_data(&self, expected_len: usize) -> Result<(), ArrowError> {
+        if self.child_data.len() != expected_len {
+            Err(ArrowError::InvalidArgumentError(format!(
+                "Value data for {} should contain {} child data array(s), had {}",
+                self.data_type,
+                expected_len,
+                self.child_data.len()
+            )))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// Ensures that `child_data[i]` has the expected type, calls
+    /// `validate()` on it, and returns a reference to that child_data
+    fn get_valid_child_data(
+        &self,
+        i: usize,
+        expected_type: &DataType,
+    ) -> Result<&ArrayData, ArrowError> {
+        let values_data = self.child_data.get(i).ok_or_else(|| {
+            ArrowError::InvalidArgumentError(format!(
+                "{} did not have enough child arrays. Expected at least {} but had only {}",
+                self.data_type,
+                i + 1,
+                self.child_data.len()
+            ))
+        })?;
+
+        if expected_type != &values_data.data_type {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Child type mismatch for {}. Expected {} but child data had {}",
+                self.data_type, expected_type, values_data.data_type
+            )));
+        }
+
+        values_data.validate()?;
+        Ok(values_data)
+    }
+
+    /// Validate that the data contained within this [`ArrayData`] is valid
+    ///
+    /// 1. Null count is correct
+    /// 2. All offsets are valid
+    /// 3. All String data is valid UTF-8
+    /// 4. All dictionary offsets are valid
+    ///
+    /// Internally this calls:
+    ///
+    /// * [`Self::validate`]
+    /// * [`Self::validate_nulls`]
+    /// * [`Self::validate_values`]
+    ///
+    /// Note: this does not recurse into children, for a recursive variant
+    /// see [`Self::validate_full`]
+    pub fn validate_data(&self) -> Result<(), ArrowError> {
+        self.validate()?;
+
+        self.validate_nulls()?;
+        self.validate_values()?;
+        Ok(())
+    }
+
+    /// Performs a full recursive validation of this [`ArrayData`] and all its children
+    ///
+    /// This is equivalent to calling [`Self::validate_data`] on this [`ArrayData`]
+    /// and all its children recursively
+    pub fn validate_full(&self) -> Result<(), ArrowError> {
+        self.validate_data()?;
+        // validate all children recursively
+        self.child_data
+            .iter()
+            .enumerate()
+            .try_for_each(|(i, child_data)| {
+                child_data.validate_full().map_err(|e| {
+                    ArrowError::InvalidArgumentError(format!(
+                        "{} child #{} invalid: {}",
+                        self.data_type, i, e
+                    ))
+                })
+            })?;
+        Ok(())
+    }
+
+    /// Validates the values stored within this [`ArrayData`] are valid
+    /// without recursing into child [`ArrayData`]
+    ///
+    /// Does not (yet) check
+    /// 1. Union type_ids are valid see [#85](https://github.com/apache/arrow-rs/issues/85)
+    /// Validates the the null count is correct and that any
+    /// nullability requirements of its children are correct
+    pub fn validate_nulls(&self) -> Result<(), ArrowError> {
+        if let Some(nulls) = &self.nulls {
+            let actual = nulls.len() - nulls.inner().count_set_bits();
+            if actual != nulls.null_count() {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "null_count value ({}) doesn't match actual number of nulls in array ({})",
+                    nulls.null_count(),
+                    actual
+                )));
+            }
+        }
+
+        // In general non-nullable children should not contain nulls, however, for certain
+        // types, such as StructArray and FixedSizeList, nulls in the parent take up
+        // space in the child. As such we permit nulls in the children in the corresponding
+        // positions for such types
+        match &self.data_type {
+            DataType::List(f) | DataType::LargeList(f) | DataType::Map(f, _) => {
+                if !f.is_nullable() {
+                    self.validate_non_nullable(None, &self.child_data[0])?
+                }
+            }
+            DataType::FixedSizeList(field, len) => {
+                let child = &self.child_data[0];
+                if !field.is_nullable() {
+                    match &self.nulls {
+                        Some(nulls) => {
+                            let element_len = *len as usize;
+                            let expanded = nulls.expand(element_len);
+                            self.validate_non_nullable(Some(&expanded), child)?;
+                        }
+                        None => self.validate_non_nullable(None, child)?,
+                    }
+                }
+            }
+            DataType::Struct(fields) => {
+                for (field, child) in fields.iter().zip(&self.child_data) {
+                    if !field.is_nullable() {
+                        self.validate_non_nullable(self.nulls(), child)?
+                    }
+                }
+            }
+            _ => {}
+        }
+
+        Ok(())
+    }
+
+    /// Verifies that `child` contains no nulls not present in `mask`
+    fn validate_non_nullable(
+        &self,
+        mask: Option<&NullBuffer>,
+        child: &ArrayData,
+    ) -> Result<(), ArrowError> {
+        let mask = match mask {
+            Some(mask) => mask,
+            None => {
+                return match child.null_count() {
+                    0 => Ok(()),
+                    _ => Err(ArrowError::InvalidArgumentError(format!(
+                        "non-nullable child of type {} contains nulls not present in parent {}",
+                        child.data_type, self.data_type
+                    ))),
+                }
+            }
+        };
+
+        match child.nulls() {
+            Some(nulls) if !mask.contains(nulls) => Err(ArrowError::InvalidArgumentError(format!(
+                "non-nullable child of type {} contains nulls not present in parent",
+                child.data_type
+            ))),
+            _ => Ok(()),
+        }
+    }
+
+    /// Validates the values stored within this [`ArrayData`] are valid
+    /// without recursing into child [`ArrayData`]
+    ///
+    /// Does not (yet) check
+    /// 1. Union type_ids are valid see [#85](https://github.com/apache/arrow-rs/issues/85)
+    pub fn validate_values(&self) -> Result<(), ArrowError> {
+        match &self.data_type {
+            DataType::Utf8 => self.validate_utf8::<i32>(),
+            DataType::LargeUtf8 => self.validate_utf8::<i64>(),
+            DataType::Binary => self.validate_offsets_full::<i32>(self.buffers[1].len()),
+            DataType::LargeBinary => self.validate_offsets_full::<i64>(self.buffers[1].len()),
+            DataType::List(_) | DataType::Map(_, _) => {
+                let child = &self.child_data[0];
+                self.validate_offsets_full::<i32>(child.len)
+            }
+            DataType::LargeList(_) => {
+                let child = &self.child_data[0];
+                self.validate_offsets_full::<i64>(child.len)
+            }
+            DataType::Union(_, _) => {
+                // Validate Union Array as part of implementing new Union semantics
+                // See comments in `ArrayData::validate()`
+                // https://github.com/apache/arrow-rs/issues/85
+                //
+                // TODO file follow on ticket for full union validation
+                Ok(())
+            }
+            DataType::Dictionary(key_type, _value_type) => {
+                let dictionary_length: i64 = self.child_data[0].len.try_into().unwrap();
+                let max_value = dictionary_length - 1;
+                match key_type.as_ref() {
+                    DataType::UInt8 => self.check_bounds::<u8>(max_value),
+                    DataType::UInt16 => self.check_bounds::<u16>(max_value),
+                    DataType::UInt32 => self.check_bounds::<u32>(max_value),
+                    DataType::UInt64 => self.check_bounds::<u64>(max_value),
+                    DataType::Int8 => self.check_bounds::<i8>(max_value),
+                    DataType::Int16 => self.check_bounds::<i16>(max_value),
+                    DataType::Int32 => self.check_bounds::<i32>(max_value),
+                    DataType::Int64 => self.check_bounds::<i64>(max_value),
+                    _ => unreachable!(),
+                }
+            }
+            DataType::RunEndEncoded(run_ends, _values) => {
+                let run_ends_data = self.child_data()[0].clone();
+                match run_ends.data_type() {
+                    DataType::Int16 => run_ends_data.check_run_ends::<i16>(),
+                    DataType::Int32 => run_ends_data.check_run_ends::<i32>(),
+                    DataType::Int64 => run_ends_data.check_run_ends::<i64>(),
+                    _ => unreachable!(),
+                }
+            }
+            _ => {
+                // No extra validation check required for other types
+                Ok(())
+            }
+        }
+    }
+
+    /// Calls the `validate(item_index, range)` function for each of
+    /// the ranges specified in the arrow offsets buffer of type
+    /// `T`. Also validates that each offset is smaller than
+    /// `offset_limit`
+    ///
+    /// For an empty array, the offsets buffer can either be empty
+    /// or contain a single `0`.
+    ///
+    /// For example, the offsets buffer contained `[1, 2, 4]`, this
+    /// function would call `validate([1,2])`, and `validate([2,4])`
+    fn validate_each_offset<T, V>(&self, offset_limit: usize, validate: V) -> Result<(), ArrowError>
+    where
+        T: ArrowNativeType + TryInto<usize> + num::Num + std::fmt::Display,
+        V: Fn(usize, Range<usize>) -> Result<(), ArrowError>,
+    {
+        self.typed_offsets::<T>()?
+            .iter()
+            .enumerate()
+            .map(|(i, x)| {
+                // check if the offset can be converted to usize
+                let r = x.to_usize().ok_or_else(|| {
+                    ArrowError::InvalidArgumentError(format!(
+                        "Offset invariant failure: Could not convert offset {x} to usize at position {i}"))}
+                    );
+                // check if the offset exceeds the limit
+                match r {
+                    Ok(n) if n <= offset_limit => Ok((i, n)),
+                    Ok(_) => Err(ArrowError::InvalidArgumentError(format!(
+                        "Offset invariant failure: offset at position {i} out of bounds: {x} > {offset_limit}"))
+                    ),
+                    Err(e) => Err(e),
+                }
+            })
+            .scan(0_usize, |start, end| {
+                // check offsets are monotonically increasing
+                match end {
+                    Ok((i, end)) if *start <= end => {
+                        let range = Some(Ok((i, *start..end)));
+                        *start = end;
+                        range
+                    }
+                    Ok((i, end)) => Some(Err(ArrowError::InvalidArgumentError(format!(
+                        "Offset invariant failure: non-monotonic offset at slot {}: {} > {}",
+                        i - 1, start, end))
+                    )),
+                    Err(err) => Some(Err(err)),
+                }
+            })
+            .skip(1) // the first element is meaningless
+            .try_for_each(|res: Result<(usize, Range<usize>), ArrowError>| {
+                let (item_index, range) = res?;
+                validate(item_index-1, range)
+            })
+    }
+
+    /// Ensures that all strings formed by the offsets in `buffers[0]`
+    /// into `buffers[1]` are valid utf8 sequences
+    fn validate_utf8<T>(&self) -> Result<(), ArrowError>
+    where
+        T: ArrowNativeType + TryInto<usize> + num::Num + std::fmt::Display,
+    {
+        let values_buffer = &self.buffers[1].as_slice();
+        if let Ok(values_str) = std::str::from_utf8(values_buffer) {
+            // Validate Offsets are correct
+            self.validate_each_offset::<T, _>(values_buffer.len(), |string_index, range| {
+                if !values_str.is_char_boundary(range.start)
+                    || !values_str.is_char_boundary(range.end)
+                {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "incomplete utf-8 byte sequence from index {string_index}"
+                    )));
+                }
+                Ok(())
+            })
+        } else {
+            // find specific offset that failed utf8 validation
+            self.validate_each_offset::<T, _>(values_buffer.len(), |string_index, range| {
+                std::str::from_utf8(&values_buffer[range.clone()]).map_err(|e| {
+                    ArrowError::InvalidArgumentError(format!(
+                        "Invalid UTF8 sequence at string index {string_index} ({range:?}): {e}"
+                    ))
+                })?;
+                Ok(())
+            })
+        }
+    }
+
+    /// Ensures that all offsets in `buffers[0]` into `buffers[1]` are
+    /// between `0` and `offset_limit`
+    fn validate_offsets_full<T>(&self, offset_limit: usize) -> Result<(), ArrowError>
+    where
+        T: ArrowNativeType + TryInto<usize> + num::Num + std::fmt::Display,
+    {
+        self.validate_each_offset::<T, _>(offset_limit, |_string_index, _range| {
+            // No validation applied to each value, but the iteration
+            // itself applies bounds checking to each range
+            Ok(())
+        })
+    }
+
+    /// Validates that each value in self.buffers (typed as T)
+    /// is within the range [0, max_value], inclusive
+    fn check_bounds<T>(&self, max_value: i64) -> Result<(), ArrowError>
+    where
+        T: ArrowNativeType + TryInto<i64> + num::Num + std::fmt::Display,
+    {
+        let required_len = self.len + self.offset;
+        let buffer = &self.buffers[0];
+
+        // This should have been checked as part of `validate()` prior
+        // to calling `validate_full()` but double check to be sure
+        assert!(buffer.len() / mem::size_of::<T>() >= required_len);
+
+        // Justification: buffer size was validated above
+        let indexes: &[T] = &buffer.typed_data::<T>()[self.offset..self.offset + self.len];
+
+        indexes.iter().enumerate().try_for_each(|(i, &dict_index)| {
+            // Do not check the value is null (value can be arbitrary)
+            if self.is_null(i) {
+                return Ok(());
+            }
+            let dict_index: i64 = dict_index.try_into().map_err(|_| {
+                ArrowError::InvalidArgumentError(format!(
+                    "Value at position {i} out of bounds: {dict_index} (can not convert to i64)"
+                ))
+            })?;
+
+            if dict_index < 0 || dict_index > max_value {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "Value at position {i} out of bounds: {dict_index} (should be in [0, {max_value}])"
+                )));
+            }
+            Ok(())
+        })
+    }
+
+    /// Validates that each value in run_ends array is positive and strictly increasing.
+    fn check_run_ends<T>(&self) -> Result<(), ArrowError>
+    where
+        T: ArrowNativeType + TryInto<i64> + num::Num + std::fmt::Display,
+    {
+        let values = self.typed_buffer::<T>(0, self.len)?;
+        let mut prev_value: i64 = 0_i64;
+        values.iter().enumerate().try_for_each(|(ix, &inp_value)| {
+            let value: i64 = inp_value.try_into().map_err(|_| {
+                ArrowError::InvalidArgumentError(format!(
+                    "Value at position {ix} out of bounds: {inp_value} (can not convert to i64)"
+                ))
+            })?;
+            if value <= 0_i64 {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "The values in run_ends array should be strictly positive. Found value {value} at index {ix} that does not match the criteria."
+                )));
+            }
+            if ix > 0 && value <= prev_value {
+                return Err(ArrowError::InvalidArgumentError(format!(
+                    "The values in run_ends array should be strictly increasing. Found value {value} at index {ix} with previous value {prev_value} that does not match the criteria."
+                )));
+            }
+
+            prev_value = value;
+            Ok(())
+        })?;
+
+        if prev_value.as_usize() < (self.offset + self.len) {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "The offset + length of array should be less or equal to last value in the run_ends array. The last value of run_ends array is {prev_value} and offset + length of array is {}.",
+                self.offset + self.len
+            )));
+        }
+        Ok(())
+    }
+
+    /// Returns true if this `ArrayData` is equal to `other`, using pointer comparisons
+    /// to determine buffer equality. This is cheaper than `PartialEq::eq` but may
+    /// return false when the arrays are logically equal
+    pub fn ptr_eq(&self, other: &Self) -> bool {
+        if self.offset != other.offset
+            || self.len != other.len
+            || self.data_type != other.data_type
+            || self.buffers.len() != other.buffers.len()
+            || self.child_data.len() != other.child_data.len()
+        {
+            return false;
+        }
+
+        match (&self.nulls, &other.nulls) {
+            (Some(a), Some(b)) if !a.inner().ptr_eq(b.inner()) => return false,
+            (Some(_), None) | (None, Some(_)) => return false,
+            _ => {}
+        };
+
+        if !self
+            .buffers
+            .iter()
+            .zip(other.buffers.iter())
+            .all(|(a, b)| a.as_ptr() == b.as_ptr())
+        {
+            return false;
+        }
+
+        self.child_data
+            .iter()
+            .zip(other.child_data.iter())
+            .all(|(a, b)| a.ptr_eq(b))
+    }
+
+    /// Converts this [`ArrayData`] into an [`ArrayDataBuilder`]
+    pub fn into_builder(self) -> ArrayDataBuilder {
+        self.into()
+    }
+}
+
+/// Return the expected [`DataTypeLayout`] Arrays of this data
+/// type are expected to have
+pub fn layout(data_type: &DataType) -> DataTypeLayout {
+    // based on C/C++ implementation in
+    // https://github.com/apache/arrow/blob/661c7d749150905a63dd3b52e0a04dac39030d95/cpp/src/arrow/type.h (and .cc)
+    use arrow_schema::IntervalUnit::*;
+
+    match data_type {
+        DataType::Null => DataTypeLayout {
+            buffers: vec![],
+            can_contain_null_mask: false,
+        },
+        DataType::Boolean => DataTypeLayout {
+            buffers: vec![BufferSpec::BitMap],
+            can_contain_null_mask: true,
+        },
+        DataType::Int8 => DataTypeLayout::new_fixed_width::<i8>(),
+        DataType::Int16 => DataTypeLayout::new_fixed_width::<i16>(),
+        DataType::Int32 => DataTypeLayout::new_fixed_width::<i32>(),
+        DataType::Int64 => DataTypeLayout::new_fixed_width::<i64>(),
+        DataType::UInt8 => DataTypeLayout::new_fixed_width::<u8>(),
+        DataType::UInt16 => DataTypeLayout::new_fixed_width::<u16>(),
+        DataType::UInt32 => DataTypeLayout::new_fixed_width::<u32>(),
+        DataType::UInt64 => DataTypeLayout::new_fixed_width::<u64>(),
+        DataType::Float16 => DataTypeLayout::new_fixed_width::<half::f16>(),
+        DataType::Float32 => DataTypeLayout::new_fixed_width::<f32>(),
+        DataType::Float64 => DataTypeLayout::new_fixed_width::<f64>(),
+        DataType::Timestamp(_, _) => DataTypeLayout::new_fixed_width::<i64>(),
+        DataType::Date32 => DataTypeLayout::new_fixed_width::<i32>(),
+        DataType::Date64 => DataTypeLayout::new_fixed_width::<i64>(),
+        DataType::Time32(_) => DataTypeLayout::new_fixed_width::<i32>(),
+        DataType::Time64(_) => DataTypeLayout::new_fixed_width::<i64>(),
+        DataType::Interval(YearMonth) => DataTypeLayout::new_fixed_width::<i32>(),
+        DataType::Interval(DayTime) => DataTypeLayout::new_fixed_width::<i64>(),
+        DataType::Interval(MonthDayNano) => DataTypeLayout::new_fixed_width::<i128>(),
+        DataType::Duration(_) => DataTypeLayout::new_fixed_width::<i64>(),
+        DataType::Decimal128(_, _) => DataTypeLayout::new_fixed_width::<i128>(),
+        DataType::Decimal256(_, _) => DataTypeLayout::new_fixed_width::<i256>(),
+        DataType::FixedSizeBinary(size) => {
+            let spec = BufferSpec::FixedWidth {
+                byte_width: (*size).try_into().unwrap(),
+                alignment: mem::align_of::<u8>(),
+            };
+            DataTypeLayout {
+                buffers: vec![spec],
+                can_contain_null_mask: true,
+            }
+        }
+        DataType::Binary => DataTypeLayout::new_binary::<i32>(),
+        DataType::LargeBinary => DataTypeLayout::new_binary::<i64>(),
+        DataType::Utf8 => DataTypeLayout::new_binary::<i32>(),
+        DataType::LargeUtf8 => DataTypeLayout::new_binary::<i64>(),
+        DataType::FixedSizeList(_, _) => DataTypeLayout::new_empty(), // all in child data
+        DataType::List(_) => DataTypeLayout::new_fixed_width::<i32>(),
+        DataType::LargeList(_) => DataTypeLayout::new_fixed_width::<i64>(),
+        DataType::Map(_, _) => DataTypeLayout::new_fixed_width::<i32>(),
+        DataType::Struct(_) => DataTypeLayout::new_empty(), // all in child data,
+        DataType::RunEndEncoded(_, _) => DataTypeLayout::new_empty(), // all in child data,
+        DataType::Union(_, mode) => {
+            let type_ids = BufferSpec::FixedWidth {
+                byte_width: mem::size_of::<i8>(),
+                alignment: mem::align_of::<i8>(),
+            };
+
+            DataTypeLayout {
+                buffers: match mode {
+                    UnionMode::Sparse => {
+                        vec![type_ids]
+                    }
+                    UnionMode::Dense => {
+                        vec![
+                            type_ids,
+                            BufferSpec::FixedWidth {
+                                byte_width: mem::size_of::<i32>(),
+                                alignment: mem::align_of::<i32>(),
+                            },
+                        ]
+                    }
+                },
+                can_contain_null_mask: false,
+            }
+        }
+        DataType::Dictionary(key_type, _value_type) => layout(key_type),
+    }
+}
+
+/// Layout specification for a data type
+#[derive(Debug, PartialEq, Eq)]
+// Note: Follows structure from C++: https://github.com/apache/arrow/blob/master/cpp/src/arrow/type.h#L91
+pub struct DataTypeLayout {
+    /// A vector of buffer layout specifications, one for each expected buffer
+    pub buffers: Vec<BufferSpec>,
+
+    /// Can contain a null bitmask
+    pub can_contain_null_mask: bool,
+}
+
+impl DataTypeLayout {
+    /// Describes a basic numeric array where each element has type `T`
+    pub fn new_fixed_width<T>() -> Self {
+        Self {
+            buffers: vec![BufferSpec::FixedWidth {
+                byte_width: mem::size_of::<T>(),
+                alignment: mem::align_of::<T>(),
+            }],
+            can_contain_null_mask: true,
+        }
+    }
+
+    /// Describes arrays which have no data of their own
+    /// (e.g. FixedSizeList). Note such arrays may still have a Null
+    /// Bitmap
+    pub fn new_empty() -> Self {
+        Self {
+            buffers: vec![],
+            can_contain_null_mask: true,
+        }
+    }
+
+    /// Describes a basic numeric array where each element has a fixed
+    /// with offset buffer of type `T`, followed by a
+    /// variable width data buffer
+    pub fn new_binary<T>() -> Self {
+        Self {
+            buffers: vec![
+                // offsets
+                BufferSpec::FixedWidth {
+                    byte_width: mem::size_of::<T>(),
+                    alignment: mem::align_of::<T>(),
+                },
+                // values
+                BufferSpec::VariableWidth,
+            ],
+            can_contain_null_mask: true,
+        }
+    }
+}
+
+/// Layout specification for a single data type buffer
+#[derive(Debug, PartialEq, Eq)]
+pub enum BufferSpec {
+    /// Each element is a fixed width primitive, with the given `byte_width` and `alignment`
+    ///
+    /// `alignment` is the alignment required by Rust for an array of the corresponding primitive,
+    /// see [`Layout::array`](std::alloc::Layout::array) and [`std::mem::align_of`].
+    ///
+    /// Arrow-rs requires that all buffers have at least this alignment, to allow for
+    /// [slice](std::slice) based APIs. Alignment in excess of this is not required to allow
+    /// for array slicing and interoperability with `Vec`, which cannot be over-aligned.
+    ///
+    /// Note that these alignment requirements will vary between architectures
+    FixedWidth { byte_width: usize, alignment: usize },
+    /// Variable width, such as string data for utf8 data
+    VariableWidth,
+    /// Buffer holds a bitmap.
+    ///
+    /// Note: Unlike the C++ implementation, the null/validity buffer
+    /// is handled specially rather than as another of the buffers in
+    /// the spec, so this variant is only used for the Boolean type.
+    BitMap,
+    /// Buffer is always null. Unused currently in Rust implementation,
+    /// (used in C++ for Union type)
+    #[allow(dead_code)]
+    AlwaysNull,
+}
+
+impl PartialEq for ArrayData {
+    fn eq(&self, other: &Self) -> bool {
+        equal::equal(self, other)
+    }
+}
+
+/// Builder for `ArrayData` type
+#[derive(Debug)]
+pub struct ArrayDataBuilder {
+    data_type: DataType,
+    len: usize,
+    null_count: Option<usize>,
+    null_bit_buffer: Option<Buffer>,
+    nulls: Option<NullBuffer>,
+    offset: usize,
+    buffers: Vec<Buffer>,
+    child_data: Vec<ArrayData>,
+}
+
+impl ArrayDataBuilder {
+    #[inline]
+    pub const fn new(data_type: DataType) -> Self {
+        Self {
+            data_type,
+            len: 0,
+            null_count: None,
+            null_bit_buffer: None,
+            nulls: None,
+            offset: 0,
+            buffers: vec![],
+            child_data: vec![],
+        }
+    }
+
+    pub fn data_type(self, data_type: DataType) -> Self {
+        Self { data_type, ..self }
+    }
+
+    #[inline]
+    #[allow(clippy::len_without_is_empty)]
+    pub const fn len(mut self, n: usize) -> Self {
+        self.len = n;
+        self
+    }
+
+    pub fn nulls(mut self, nulls: Option<NullBuffer>) -> Self {
+        self.nulls = nulls;
+        self.null_count = None;
+        self.null_bit_buffer = None;
+        self
+    }
+
+    pub fn null_count(mut self, null_count: usize) -> Self {
+        self.null_count = Some(null_count);
+        self
+    }
+
+    pub fn null_bit_buffer(mut self, buf: Option<Buffer>) -> Self {
+        self.nulls = None;
+        self.null_bit_buffer = buf;
+        self
+    }
+
+    #[inline]
+    pub const fn offset(mut self, n: usize) -> Self {
+        self.offset = n;
+        self
+    }
+
+    pub fn buffers(mut self, v: Vec<Buffer>) -> Self {
+        self.buffers = v;
+        self
+    }
+
+    pub fn add_buffer(mut self, b: Buffer) -> Self {
+        self.buffers.push(b);
+        self
+    }
+
+    pub fn child_data(mut self, v: Vec<ArrayData>) -> Self {
+        self.child_data = v;
+        self
+    }
+
+    pub fn add_child_data(mut self, r: ArrayData) -> Self {
+        self.child_data.push(r);
+        self
+    }
+
+    /// Creates an array data, without any validation
+    ///
+    /// # Safety
+    ///
+    /// The same caveats as [`ArrayData::new_unchecked`]
+    /// apply.
+    #[allow(clippy::let_and_return)]
+    pub unsafe fn build_unchecked(self) -> ArrayData {
+        let data = self.build_impl();
+        // Provide a force_validate mode
+        #[cfg(feature = "force_validate")]
+        data.validate_data().unwrap();
+        data
+    }
+
+    /// Same as [`Self::build_unchecked`] but ignoring `force_validate` feature flag
+    unsafe fn build_impl(self) -> ArrayData {
+        let nulls = self.nulls.or_else(|| {
+            let buffer = self.null_bit_buffer?;
+            let buffer = BooleanBuffer::new(buffer, self.offset, self.len);
+            Some(match self.null_count {
+                Some(n) => NullBuffer::new_unchecked(buffer, n),
+                None => NullBuffer::new(buffer),
+            })
+        });
+
+        ArrayData {
+            data_type: self.data_type,
+            len: self.len,
+            offset: self.offset,
+            buffers: self.buffers,
+            child_data: self.child_data,
+            nulls: nulls.filter(|b| b.null_count() != 0),
+        }
+    }
+
+    /// Creates an array data, validating all inputs
+    pub fn build(self) -> Result<ArrayData, ArrowError> {
+        let data = unsafe { self.build_impl() };
+        data.validate_data()?;
+        Ok(data)
+    }
+
+    /// Creates an array data, validating all inputs, and aligning any buffers
+    ///
+    /// Rust requires that arrays are aligned to their corresponding primitive,
+    /// see [`Layout::array`](std::alloc::Layout::array) and [`std::mem::align_of`].
+    ///
+    /// [`ArrayData`] therefore requires that all buffers have at least this alignment,
+    /// to allow for [slice](std::slice) based APIs. See [`BufferSpec::FixedWidth`].
+    ///
+    /// As this alignment is architecture specific, and not guaranteed by all arrow implementations,
+    /// this method is provided to automatically copy buffers to a new correctly aligned allocation
+    /// when necessary, making it useful when interacting with buffers produced by other systems,
+    /// e.g. IPC or FFI.
+    ///
+    /// This is unlike `[Self::build`] which will instead return an error on encountering
+    /// insufficiently aligned buffers.
+    pub fn build_aligned(self) -> Result<ArrayData, ArrowError> {
+        let mut data = unsafe { self.build_impl() };
+        data.align_buffers();
+        data.validate_data()?;
+        Ok(data)
+    }
+}
+
+impl From<ArrayData> for ArrayDataBuilder {
+    fn from(d: ArrayData) -> Self {
+        Self {
+            data_type: d.data_type,
+            len: d.len,
+            offset: d.offset,
+            buffers: d.buffers,
+            child_data: d.child_data,
+            nulls: d.nulls,
+            null_bit_buffer: None,
+            null_count: None,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_schema::{Field, UnionFields};
+
+    // See arrow/tests/array_data_validation.rs for test of array validation
+
+    /// returns a buffer initialized with some constant value for tests
+    fn make_i32_buffer(n: usize) -> Buffer {
+        Buffer::from_slice_ref(vec![42i32; n])
+    }
+
+    /// returns a buffer initialized with some constant value for tests
+    fn make_f32_buffer(n: usize) -> Buffer {
+        Buffer::from_slice_ref(vec![42f32; n])
+    }
+
+    #[test]
+    fn test_builder() {
+        // Buffer needs to be at least 25 long
+        let v = (0..25).collect::<Vec<i32>>();
+        let b1 = Buffer::from_slice_ref(&v);
+        let arr_data = ArrayData::builder(DataType::Int32)
+            .len(20)
+            .offset(5)
+            .add_buffer(b1)
+            .null_bit_buffer(Some(Buffer::from(vec![
+                0b01011111, 0b10110101, 0b01100011, 0b00011110,
+            ])))
+            .build()
+            .unwrap();
+
+        assert_eq!(20, arr_data.len());
+        assert_eq!(10, arr_data.null_count());
+        assert_eq!(5, arr_data.offset());
+        assert_eq!(1, arr_data.buffers().len());
+        assert_eq!(
+            Buffer::from_slice_ref(&v).as_slice(),
+            arr_data.buffers()[0].as_slice()
+        );
+    }
+
+    #[test]
+    fn test_builder_with_child_data() {
+        let child_arr_data = ArrayData::try_new(
+            DataType::Int32,
+            5,
+            None,
+            0,
+            vec![Buffer::from_slice_ref([1i32, 2, 3, 4, 5])],
+            vec![],
+        )
+        .unwrap();
+
+        let field = Arc::new(Field::new("x", DataType::Int32, true));
+        let data_type = DataType::Struct(vec![field].into());
+
+        let arr_data = ArrayData::builder(data_type)
+            .len(5)
+            .offset(0)
+            .add_child_data(child_arr_data.clone())
+            .build()
+            .unwrap();
+
+        assert_eq!(5, arr_data.len());
+        assert_eq!(1, arr_data.child_data().len());
+        assert_eq!(child_arr_data, arr_data.child_data()[0]);
+    }
+
+    #[test]
+    fn test_null_count() {
+        let mut bit_v: [u8; 2] = [0; 2];
+        bit_util::set_bit(&mut bit_v, 0);
+        bit_util::set_bit(&mut bit_v, 3);
+        bit_util::set_bit(&mut bit_v, 10);
+        let arr_data = ArrayData::builder(DataType::Int32)
+            .len(16)
+            .add_buffer(make_i32_buffer(16))
+            .null_bit_buffer(Some(Buffer::from(bit_v)))
+            .build()
+            .unwrap();
+        assert_eq!(13, arr_data.null_count());
+
+        // Test with offset
+        let mut bit_v: [u8; 2] = [0; 2];
+        bit_util::set_bit(&mut bit_v, 0);
+        bit_util::set_bit(&mut bit_v, 3);
+        bit_util::set_bit(&mut bit_v, 10);
+        let arr_data = ArrayData::builder(DataType::Int32)
+            .len(12)
+            .offset(2)
+            .add_buffer(make_i32_buffer(14)) // requires at least 14 bytes of space,
+            .null_bit_buffer(Some(Buffer::from(bit_v)))
+            .build()
+            .unwrap();
+        assert_eq!(10, arr_data.null_count());
+    }
+
+    #[test]
+    fn test_null_buffer_ref() {
+        let mut bit_v: [u8; 2] = [0; 2];
+        bit_util::set_bit(&mut bit_v, 0);
+        bit_util::set_bit(&mut bit_v, 3);
+        bit_util::set_bit(&mut bit_v, 10);
+        let arr_data = ArrayData::builder(DataType::Int32)
+            .len(16)
+            .add_buffer(make_i32_buffer(16))
+            .null_bit_buffer(Some(Buffer::from(bit_v)))
+            .build()
+            .unwrap();
+        assert!(arr_data.nulls().is_some());
+        assert_eq!(&bit_v, arr_data.nulls().unwrap().validity());
+    }
+
+    #[test]
+    fn test_slice() {
+        let mut bit_v: [u8; 2] = [0; 2];
+        bit_util::set_bit(&mut bit_v, 0);
+        bit_util::set_bit(&mut bit_v, 3);
+        bit_util::set_bit(&mut bit_v, 10);
+        let data = ArrayData::builder(DataType::Int32)
+            .len(16)
+            .add_buffer(make_i32_buffer(16))
+            .null_bit_buffer(Some(Buffer::from(bit_v)))
+            .build()
+            .unwrap();
+        let new_data = data.slice(1, 15);
+        assert_eq!(data.len() - 1, new_data.len());
+        assert_eq!(1, new_data.offset());
+        assert_eq!(data.null_count(), new_data.null_count());
+
+        // slice of a slice (removes one null)
+        let new_data = new_data.slice(1, 14);
+        assert_eq!(data.len() - 2, new_data.len());
+        assert_eq!(2, new_data.offset());
+        assert_eq!(data.null_count() - 1, new_data.null_count());
+    }
+
+    #[test]
+    fn test_equality() {
+        let int_data = ArrayData::builder(DataType::Int32)
+            .len(1)
+            .add_buffer(make_i32_buffer(1))
+            .build()
+            .unwrap();
+
+        let float_data = ArrayData::builder(DataType::Float32)
+            .len(1)
+            .add_buffer(make_f32_buffer(1))
+            .build()
+            .unwrap();
+        assert_ne!(int_data, float_data);
+        assert!(!int_data.ptr_eq(&float_data));
+        assert!(int_data.ptr_eq(&int_data));
+
+        #[allow(clippy::redundant_clone)]
+        let int_data_clone = int_data.clone();
+        assert_eq!(int_data, int_data_clone);
+        assert!(int_data.ptr_eq(&int_data_clone));
+        assert!(int_data_clone.ptr_eq(&int_data));
+
+        let int_data_slice = int_data_clone.slice(1, 0);
+        assert!(int_data_slice.ptr_eq(&int_data_slice));
+        assert!(!int_data.ptr_eq(&int_data_slice));
+        assert!(!int_data_slice.ptr_eq(&int_data));
+
+        let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+        let offsets_buffer = Buffer::from_slice_ref([0_i32, 2_i32, 2_i32, 5_i32]);
+        let string_data = ArrayData::try_new(
+            DataType::Utf8,
+            3,
+            Some(Buffer::from_iter(vec![true, false, true])),
+            0,
+            vec![offsets_buffer, data_buffer],
+            vec![],
+        )
+        .unwrap();
+
+        assert_ne!(float_data, string_data);
+        assert!(!float_data.ptr_eq(&string_data));
+
+        assert!(string_data.ptr_eq(&string_data));
+
+        #[allow(clippy::redundant_clone)]
+        let string_data_cloned = string_data.clone();
+        assert!(string_data_cloned.ptr_eq(&string_data));
+        assert!(string_data.ptr_eq(&string_data_cloned));
+
+        let string_data_slice = string_data.slice(1, 2);
+        assert!(string_data_slice.ptr_eq(&string_data_slice));
+        assert!(!string_data_slice.ptr_eq(&string_data))
+    }
+
+    #[test]
+    fn test_slice_memory_size() {
+        let mut bit_v: [u8; 2] = [0; 2];
+        bit_util::set_bit(&mut bit_v, 0);
+        bit_util::set_bit(&mut bit_v, 3);
+        bit_util::set_bit(&mut bit_v, 10);
+        let data = ArrayData::builder(DataType::Int32)
+            .len(16)
+            .add_buffer(make_i32_buffer(16))
+            .null_bit_buffer(Some(Buffer::from(bit_v)))
+            .build()
+            .unwrap();
+        let new_data = data.slice(1, 14);
+        assert_eq!(
+            data.get_slice_memory_size().unwrap() - 8,
+            new_data.get_slice_memory_size().unwrap()
+        );
+        let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+        let offsets_buffer = Buffer::from_slice_ref([0_i32, 2_i32, 2_i32, 5_i32]);
+        let string_data = ArrayData::try_new(
+            DataType::Utf8,
+            3,
+            Some(Buffer::from_iter(vec![true, false, true])),
+            0,
+            vec![offsets_buffer, data_buffer],
+            vec![],
+        )
+        .unwrap();
+        let string_data_slice = string_data.slice(1, 2);
+        //4 bytes of offset and 2 bytes of data reduced by slicing.
+        assert_eq!(
+            string_data.get_slice_memory_size().unwrap() - 6,
+            string_data_slice.get_slice_memory_size().unwrap()
+        );
+    }
+
+    #[test]
+    fn test_count_nulls() {
+        let buffer = Buffer::from(vec![0b00010110, 0b10011111]);
+        let buffer = NullBuffer::new(BooleanBuffer::new(buffer, 0, 16));
+        let count = count_nulls(Some(&buffer), 0, 16);
+        assert_eq!(count, 7);
+
+        let count = count_nulls(Some(&buffer), 4, 8);
+        assert_eq!(count, 3);
+    }
+
+    #[test]
+    fn test_contains_nulls() {
+        let buffer: Buffer =
+            MutableBuffer::from_iter([false, false, false, true, true, false]).into();
+        let buffer = NullBuffer::new(BooleanBuffer::new(buffer, 0, 6));
+        assert!(contains_nulls(Some(&buffer), 0, 6));
+        assert!(contains_nulls(Some(&buffer), 0, 3));
+        assert!(!contains_nulls(Some(&buffer), 3, 2));
+        assert!(!contains_nulls(Some(&buffer), 0, 0));
+    }
+
+    #[test]
+    fn test_into_buffers() {
+        let data_types = vec![
+            DataType::Union(UnionFields::empty(), UnionMode::Dense),
+            DataType::Union(UnionFields::empty(), UnionMode::Sparse),
+        ];
+
+        for data_type in data_types {
+            let buffers = new_buffers(&data_type, 0);
+            let [buffer1, buffer2] = buffers;
+            let buffers = into_buffers(&data_type, buffer1, buffer2);
+
+            let layout = layout(&data_type);
+            assert_eq!(buffers.len(), layout.buffers.len());
+        }
+    }
+
+    #[test]
+    fn test_alignment() {
+        let buffer = Buffer::from_vec(vec![1_i32, 2_i32, 3_i32]);
+        let sliced = buffer.slice(1);
+
+        let mut data = ArrayData {
+            data_type: DataType::Int32,
+            len: 0,
+            offset: 0,
+            buffers: vec![buffer],
+            child_data: vec![],
+            nulls: None,
+        };
+        data.validate_full().unwrap();
+
+        data.buffers[0] = sliced;
+        let err = data.validate().unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Misaligned buffers[0] in array of type Int32, offset from expected alignment of 4 by 1"
+        );
+
+        data.align_buffers();
+        data.validate_full().unwrap();
+    }
+}
diff --git a/arrow-data/src/decimal.rs b/arrow-data/src/decimal.rs
new file mode 100644
index 000000000000..74279bfb9af1
--- /dev/null
+++ b/arrow-data/src/decimal.rs
@@ -0,0 +1,781 @@
+// 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.
+
+use arrow_buffer::i256;
+use arrow_schema::ArrowError;
+
+pub use arrow_schema::{
+    DECIMAL128_MAX_PRECISION, DECIMAL128_MAX_SCALE, DECIMAL256_MAX_PRECISION, DECIMAL256_MAX_SCALE,
+    DECIMAL_DEFAULT_SCALE,
+};
+
+// MAX decimal256 value of little-endian format for each precision.
+// Each element is the max value of signed 256-bit integer for the specified precision which
+// is encoded to the 32-byte width format of little-endian.
+pub(crate) const MAX_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION: [i256; 76] = [
+    i256::from_le_bytes([
+        9, 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,
+    ]),
+    i256::from_le_bytes([
+        99, 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,
+    ]),
+    i256::from_le_bytes([
+        231, 3, 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,
+    ]),
+    i256::from_le_bytes([
+        15, 39, 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,
+    ]),
+    i256::from_le_bytes([
+        159, 134, 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,
+    ]),
+    i256::from_le_bytes([
+        63, 66, 15, 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,
+    ]),
+    i256::from_le_bytes([
+        127, 150, 152, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 224, 245, 5, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 201, 154, 59, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 227, 11, 84, 2, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 231, 118, 72, 23, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 15, 165, 212, 232, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 159, 114, 78, 24, 9, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 63, 122, 16, 243, 90, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 127, 198, 164, 126, 141, 3, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 192, 111, 242, 134, 35, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 137, 93, 120, 69, 99, 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,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 99, 167, 179, 182, 224, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 231, 137, 4, 35, 199, 138, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 15, 99, 45, 94, 199, 107, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 159, 222, 197, 173, 201, 53, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 63, 178, 186, 201, 224, 25, 30, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 127, 246, 74, 225, 199, 2, 45, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 160, 237, 204, 206, 27, 194, 211, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 73, 72, 1, 20, 22, 149, 69, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 227, 210, 12, 200, 220, 210, 183, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 231, 60, 128, 208, 159, 60, 46, 59, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 15, 97, 2, 37, 62, 94, 206, 79, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 159, 202, 23, 114, 109, 174, 15, 30, 67, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 63, 234, 237, 116, 70, 208, 156, 44, 159, 12, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 127, 38, 75, 145, 192, 34, 32, 190, 55, 126, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 128, 239, 172, 133, 91, 65, 109, 45, 238, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 9, 91, 193, 56, 147, 141, 68, 198, 77, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 99, 142, 141, 55, 192, 135, 173, 190, 9, 237, 1, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 231, 143, 135, 43, 130, 77, 199, 114, 97, 66, 19, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 15, 159, 75, 179, 21, 7, 201, 123, 206, 151, 192, 0, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 159, 54, 244, 0, 217, 70, 218, 213, 16, 238, 133, 7, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 63, 34, 138, 9, 122, 196, 134, 90, 168, 76, 59, 75, 0, 0, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 127, 86, 101, 95, 196, 172, 67, 137, 147, 254, 80, 240, 2, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 96, 245, 185, 171, 191, 164, 92, 195, 241, 41, 99, 29, 0, 0, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 201, 149, 67, 181, 124, 111, 158, 161, 113, 163, 223, 37, 1, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 227, 217, 163, 20, 223, 90, 48, 80, 112, 98, 188, 122, 11, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 231, 130, 102, 206, 182, 140, 227, 33, 99, 216, 91, 203, 114, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 15, 29, 1, 16, 36, 127, 227, 82, 223, 115, 150, 241, 123, 4, 0, 0,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 159, 34, 11, 160, 104, 247, 226, 60, 185, 134, 224, 111, 215, 44,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 63, 90, 111, 64, 22, 170, 221, 96, 60, 67, 197, 94, 106, 192, 1,
+        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 127, 134, 89, 132, 222, 164, 168, 200, 91, 160, 180, 179, 39, 132,
+        17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 64, 127, 43, 177, 112, 150, 214, 149, 67, 14, 5, 141, 41,
+        175, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 137, 248, 178, 235, 102, 224, 97, 218, 163, 142, 50, 130,
+        159, 215, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 99, 181, 253, 52, 5, 196, 210, 135, 102, 146, 249, 21, 59,
+        108, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 231, 21, 233, 17, 52, 168, 59, 78, 1, 184, 191, 219, 78, 58,
+        172, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 15, 219, 26, 179, 8, 146, 84, 14, 13, 48, 125, 149, 20, 71,
+        186, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 159, 142, 12, 255, 86, 180, 77, 143, 130, 224, 227, 214, 205,
+        198, 70, 11, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 63, 146, 125, 246, 101, 11, 9, 153, 25, 197, 230, 100, 10,
+        196, 195, 112, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 127, 182, 231, 160, 251, 113, 90, 250, 255, 178, 3, 241, 103,
+        168, 165, 103, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 32, 13, 73, 212, 115, 136, 199, 255, 253, 36, 106, 15,
+        148, 120, 12, 20, 4, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 73, 131, 218, 74, 134, 84, 203, 253, 235, 113, 37, 154,
+        200, 181, 124, 200, 40, 0, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 227, 32, 137, 236, 62, 77, 241, 233, 55, 115, 118, 5,
+        214, 25, 223, 212, 151, 1, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 231, 72, 91, 61, 117, 4, 109, 35, 47, 128, 160, 54, 92,
+        2, 183, 80, 238, 15, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 15, 217, 144, 101, 148, 44, 66, 98, 215, 1, 69, 34, 154,
+        23, 38, 39, 79, 159, 0, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 159, 122, 168, 247, 203, 189, 149, 214, 105, 18, 178,
+        86, 5, 236, 124, 135, 23, 57, 6, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 63, 202, 148, 172, 247, 105, 217, 97, 34, 184, 244, 98,
+        53, 56, 225, 74, 235, 58, 62, 0, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 127, 230, 207, 189, 172, 35, 126, 210, 87, 49, 143, 221,
+        21, 50, 204, 236, 48, 77, 110, 2, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 0, 31, 106, 191, 100, 237, 56, 110, 237, 151, 167,
+        218, 244, 249, 63, 233, 3, 79, 24, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 9, 54, 37, 122, 239, 69, 57, 78, 70, 239, 139, 138,
+        144, 195, 127, 28, 39, 22, 243, 0, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 99, 28, 116, 197, 90, 187, 60, 14, 191, 88, 119,
+        105, 165, 163, 253, 28, 135, 221, 126, 9, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 231, 27, 137, 182, 139, 81, 95, 142, 118, 119, 169,
+        30, 118, 100, 232, 33, 71, 167, 244, 94, 0, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 15, 23, 91, 33, 117, 47, 185, 143, 161, 170, 158,
+        50, 157, 236, 19, 83, 199, 136, 142, 181, 3, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 159, 230, 142, 77, 147, 218, 59, 157, 79, 170, 50,
+        250, 35, 62, 199, 62, 201, 87, 145, 23, 37, 0, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 63, 2, 149, 7, 193, 137, 86, 36, 28, 167, 250, 197,
+        103, 109, 200, 115, 220, 109, 173, 235, 114, 1, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 127, 22, 210, 75, 138, 97, 97, 107, 25, 135, 202,
+        187, 13, 70, 212, 133, 156, 74, 198, 52, 125, 14, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 224, 52, 246, 102, 207, 205, 49, 254, 70, 233,
+        85, 137, 188, 74, 58, 29, 234, 190, 15, 228, 144, 0, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 201, 16, 158, 5, 26, 10, 242, 237, 197, 28,
+        91, 93, 93, 235, 70, 36, 37, 117, 157, 232, 168, 5, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 227, 167, 44, 56, 4, 101, 116, 75, 187, 31,
+        143, 165, 165, 49, 197, 106, 115, 147, 38, 22, 153, 56, 0,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 231, 142, 190, 49, 42, 242, 139, 242, 80, 61,
+        151, 119, 120, 240, 179, 43, 130, 194, 129, 221, 250, 53, 2,
+    ]),
+    i256::from_le_bytes([
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 15, 149, 113, 241, 165, 117, 119, 121, 41,
+        101, 232, 171, 180, 100, 7, 181, 21, 153, 17, 167, 204, 27, 22,
+    ]),
+];
+
+// MIN decimal256 value of little-endian format for each precision.
+// Each element is the min value of signed 256-bit integer for the specified precision which
+// is encoded to the 76-byte width format of little-endian.
+pub(crate) const MIN_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION: [i256; 76] = [
+    i256::from_le_bytes([
+        247, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        157, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        25, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        241, 216, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        97, 121, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        193, 189, 240, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        129, 105, 103, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 31, 10, 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 54, 101, 196, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 28, 244, 171, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 24, 137, 183, 232, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 240, 90, 43, 23, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 96, 141, 177, 231, 246, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 192, 133, 239, 12, 165, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 128, 57, 91, 129, 114, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 63, 144, 13, 121, 220, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 118, 162, 135, 186, 156, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 156, 88, 76, 73, 31, 242, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 24, 118, 251, 220, 56, 117, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 240, 156, 210, 161, 56, 148, 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 96, 33, 58, 82, 54, 202, 201, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 192, 77, 69, 54, 31, 230, 225, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 128, 9, 181, 30, 56, 253, 210, 234, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 95, 18, 51, 49, 228, 61, 44, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 182, 183, 254, 235, 233, 106, 186, 247, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 28, 45, 243, 55, 35, 45, 72, 173, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 24, 195, 127, 47, 96, 195, 209, 196, 252, 255, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 240, 158, 253, 218, 193, 161, 49, 176, 223, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 96, 53, 232, 141, 146, 81, 240, 225, 188, 254, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 192, 21, 18, 139, 185, 47, 99, 211, 96, 243, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 128, 217, 180, 110, 63, 221, 223, 65, 200, 129, 255, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 127, 16, 83, 122, 164, 190, 146, 210, 17, 251, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 246, 164, 62, 199, 108, 114, 187, 57, 178, 206, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 156, 113, 114, 200, 63, 120, 82, 65, 246, 18, 254, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 24, 112, 120, 212, 125, 178, 56, 141, 158, 189, 236, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 240, 96, 180, 76, 234, 248, 54, 132, 49, 104, 63, 255, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 96, 201, 11, 255, 38, 185, 37, 42, 239, 17, 122, 248, 255, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 192, 221, 117, 246, 133, 59, 121, 165, 87, 179, 196, 180, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 128, 169, 154, 160, 59, 83, 188, 118, 108, 1, 175, 15, 253, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 159, 10, 70, 84, 64, 91, 163, 60, 14, 214, 156, 226, 255, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 54, 106, 188, 74, 131, 144, 97, 94, 142, 92, 32, 218, 254, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 28, 38, 92, 235, 32, 165, 207, 175, 143, 157, 67, 133, 244, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 24, 125, 153, 49, 73, 115, 28, 222, 156, 39, 164, 52, 141, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 240, 226, 254, 239, 219, 128, 28, 173, 32, 140, 105, 14, 132, 251, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 96, 221, 244, 95, 151, 8, 29, 195, 70, 121, 31, 144, 40, 211, 255, 255, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 192, 165, 144, 191, 233, 85, 34, 159, 195, 188, 58, 161, 149, 63, 254, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 128, 121, 166, 123, 33, 91, 87, 55, 164, 95, 75, 76, 216, 123, 238, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 191, 128, 212, 78, 143, 105, 41, 106, 188, 241, 250, 114, 214, 80, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 118, 7, 77, 20, 153, 31, 158, 37, 92, 113, 205, 125, 96, 40, 249, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 156, 74, 2, 203, 250, 59, 45, 120, 153, 109, 6, 234, 196, 147, 187, 255,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 24, 234, 22, 238, 203, 87, 196, 177, 254, 71, 64, 36, 177, 197, 83, 253,
+        255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 240, 36, 229, 76, 247, 109, 171, 241, 242, 207, 130, 106, 235, 184, 69,
+        229, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 96, 113, 243, 0, 169, 75, 178, 112, 125, 31, 28, 41, 50, 57, 185, 244,
+        254, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 192, 109, 130, 9, 154, 244, 246, 102, 230, 58, 25, 155, 245, 59, 60, 143,
+        245, 255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 128, 73, 24, 95, 4, 142, 165, 5, 0, 77, 252, 14, 152, 87, 90, 152, 151,
+        255, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 223, 242, 182, 43, 140, 119, 56, 0, 2, 219, 149, 240, 107, 135, 243,
+        235, 251, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 182, 124, 37, 181, 121, 171, 52, 2, 20, 142, 218, 101, 55, 74, 131,
+        55, 215, 255, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 28, 223, 118, 19, 193, 178, 14, 22, 200, 140, 137, 250, 41, 230, 32,
+        43, 104, 254, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 24, 183, 164, 194, 138, 251, 146, 220, 208, 127, 95, 201, 163, 253,
+        72, 175, 17, 240, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 240, 38, 111, 154, 107, 211, 189, 157, 40, 254, 186, 221, 101, 232,
+        217, 216, 176, 96, 255, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 96, 133, 87, 8, 52, 66, 106, 41, 150, 237, 77, 169, 250, 19, 131, 120,
+        232, 198, 249, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 192, 53, 107, 83, 8, 150, 38, 158, 221, 71, 11, 157, 202, 199, 30,
+        181, 20, 197, 193, 255, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 128, 25, 48, 66, 83, 220, 129, 45, 168, 206, 112, 34, 234, 205, 51,
+        19, 207, 178, 145, 253, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 255, 224, 149, 64, 155, 18, 199, 145, 18, 104, 88, 37, 11, 6, 192,
+        22, 252, 176, 231, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 246, 201, 218, 133, 16, 186, 198, 177, 185, 16, 116, 117, 111, 60,
+        128, 227, 216, 233, 12, 255, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 156, 227, 139, 58, 165, 68, 195, 241, 64, 167, 136, 150, 90, 92, 2,
+        227, 120, 34, 129, 246, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 24, 228, 118, 73, 116, 174, 160, 113, 137, 136, 86, 225, 137, 155,
+        23, 222, 184, 88, 11, 161, 255, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 240, 232, 164, 222, 138, 208, 70, 112, 94, 85, 97, 205, 98, 19,
+        236, 172, 56, 119, 113, 74, 252, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 96, 25, 113, 178, 108, 37, 196, 98, 176, 85, 205, 5, 220, 193, 56,
+        193, 54, 168, 110, 232, 218, 255, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 192, 253, 106, 248, 62, 118, 169, 219, 227, 88, 5, 58, 152, 146,
+        55, 140, 35, 146, 82, 20, 141, 254, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 128, 233, 45, 180, 117, 158, 158, 148, 230, 120, 53, 68, 242, 185,
+        43, 122, 99, 181, 57, 203, 130, 241, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 31, 203, 9, 153, 48, 50, 206, 1, 185, 22, 170, 118, 67, 181,
+        197, 226, 21, 65, 240, 27, 111, 255, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 54, 239, 97, 250, 229, 245, 13, 18, 58, 227, 164, 162, 162, 20,
+        185, 219, 218, 138, 98, 23, 87, 250, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 28, 88, 211, 199, 251, 154, 139, 180, 68, 224, 112, 90, 90, 206,
+        58, 149, 140, 108, 217, 233, 102, 199, 255,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 24, 113, 65, 206, 213, 13, 116, 13, 175, 194, 104, 136, 135, 15,
+        76, 212, 125, 61, 126, 34, 5, 202, 253,
+    ]),
+    i256::from_le_bytes([
+        1, 0, 0, 0, 0, 0, 0, 0, 0, 240, 106, 142, 14, 90, 138, 136, 134, 214, 154, 23, 84, 75, 155,
+        248, 74, 234, 102, 238, 88, 51, 228, 233,
+    ]),
+];
+
+/// `MAX_DECIMAL_FOR_EACH_PRECISION[p]` holds the maximum `i128` value that can
+/// be stored in [arrow_schema::DataType::Decimal128] value of precision `p`
+pub const MAX_DECIMAL_FOR_EACH_PRECISION: [i128; 38] = [
+    9,
+    99,
+    999,
+    9999,
+    99999,
+    999999,
+    9999999,
+    99999999,
+    999999999,
+    9999999999,
+    99999999999,
+    999999999999,
+    9999999999999,
+    99999999999999,
+    999999999999999,
+    9999999999999999,
+    99999999999999999,
+    999999999999999999,
+    9999999999999999999,
+    99999999999999999999,
+    999999999999999999999,
+    9999999999999999999999,
+    99999999999999999999999,
+    999999999999999999999999,
+    9999999999999999999999999,
+    99999999999999999999999999,
+    999999999999999999999999999,
+    9999999999999999999999999999,
+    99999999999999999999999999999,
+    999999999999999999999999999999,
+    9999999999999999999999999999999,
+    99999999999999999999999999999999,
+    999999999999999999999999999999999,
+    9999999999999999999999999999999999,
+    99999999999999999999999999999999999,
+    999999999999999999999999999999999999,
+    9999999999999999999999999999999999999,
+    99999999999999999999999999999999999999,
+];
+
+/// `MIN_DECIMAL_FOR_EACH_PRECISION[p]` holds the minimum `i128` value that can
+/// be stored in a [arrow_schema::DataType::Decimal128] value of precision `p`
+pub const MIN_DECIMAL_FOR_EACH_PRECISION: [i128; 38] = [
+    -9,
+    -99,
+    -999,
+    -9999,
+    -99999,
+    -999999,
+    -9999999,
+    -99999999,
+    -999999999,
+    -9999999999,
+    -99999999999,
+    -999999999999,
+    -9999999999999,
+    -99999999999999,
+    -999999999999999,
+    -9999999999999999,
+    -99999999999999999,
+    -999999999999999999,
+    -9999999999999999999,
+    -99999999999999999999,
+    -999999999999999999999,
+    -9999999999999999999999,
+    -99999999999999999999999,
+    -999999999999999999999999,
+    -9999999999999999999999999,
+    -99999999999999999999999999,
+    -999999999999999999999999999,
+    -9999999999999999999999999999,
+    -99999999999999999999999999999,
+    -999999999999999999999999999999,
+    -9999999999999999999999999999999,
+    -99999999999999999999999999999999,
+    -999999999999999999999999999999999,
+    -9999999999999999999999999999999999,
+    -99999999999999999999999999999999999,
+    -999999999999999999999999999999999999,
+    -9999999999999999999999999999999999999,
+    -99999999999999999999999999999999999999,
+];
+
+/// Validates that the specified `i128` value can be properly
+/// interpreted as a Decimal number with precision `precision`
+#[inline]
+pub fn validate_decimal_precision(value: i128, precision: u8) -> Result<(), ArrowError> {
+    if precision > DECIMAL128_MAX_PRECISION {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "Max precision of a Decimal128 is {DECIMAL128_MAX_PRECISION}, but got {precision}",
+        )));
+    }
+
+    let max = MAX_DECIMAL_FOR_EACH_PRECISION[usize::from(precision) - 1];
+    let min = MIN_DECIMAL_FOR_EACH_PRECISION[usize::from(precision) - 1];
+
+    if value > max {
+        Err(ArrowError::InvalidArgumentError(format!(
+            "{value} is too large to store in a Decimal128 of precision {precision}. Max is {max}"
+        )))
+    } else if value < min {
+        Err(ArrowError::InvalidArgumentError(format!(
+            "{value} is too small to store in a Decimal128 of precision {precision}. Min is {min}"
+        )))
+    } else {
+        Ok(())
+    }
+}
+
+/// Validates that the specified `i256` of value can be properly
+/// interpreted as a Decimal256 number with precision `precision`
+#[inline]
+pub fn validate_decimal256_precision(value: i256, precision: u8) -> Result<(), ArrowError> {
+    if precision > DECIMAL256_MAX_PRECISION {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "Max precision of a Decimal256 is {DECIMAL256_MAX_PRECISION}, but got {precision}",
+        )));
+    }
+    let max = MAX_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION[usize::from(precision) - 1];
+    let min = MIN_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION[usize::from(precision) - 1];
+
+    if value > max {
+        Err(ArrowError::InvalidArgumentError(format!(
+            "{value:?} is too large to store in a Decimal256 of precision {precision}. Max is {max:?}"
+        )))
+    } else if value < min {
+        Err(ArrowError::InvalidArgumentError(format!(
+            "{value:?} is too small to store in a Decimal256 of precision {precision}. Min is {min:?}"
+        )))
+    } else {
+        Ok(())
+    }
+}
diff --git a/arrow/src/array/equal/boolean.rs b/arrow-data/src/equal/boolean.rs
similarity index 65%
rename from arrow/src/array/equal/boolean.rs
rename to arrow-data/src/equal/boolean.rs
index fddf21b963ad..addae936f118 100644
--- a/arrow/src/array/equal/boolean.rs
+++ b/arrow-data/src/equal/boolean.rs
@@ -15,9 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::{data::contains_nulls, ArrayData};
-use crate::util::bit_iterator::BitIndexIterator;
-use crate::util::bit_util::get_bit;
+use crate::bit_iterator::BitIndexIterator;
+use crate::data::{contains_nulls, ArrayData};
+use arrow_buffer::bit_util::get_bit;
 
 use super::utils::{equal_bits, equal_len};
 
@@ -33,7 +33,7 @@ pub(super) fn boolean_equal(
     let lhs_values = lhs.buffers()[0].as_slice();
     let rhs_values = rhs.buffers()[0].as_slice();
 
-    let contains_nulls = contains_nulls(lhs.null_buffer(), lhs_start + lhs.offset(), len);
+    let contains_nulls = contains_nulls(lhs.nulls(), lhs_start, len);
 
     if !contains_nulls {
         // Optimize performance for starting offset at u8 boundary.
@@ -76,42 +76,12 @@ pub(super) fn boolean_equal(
         )
     } else {
         // get a ref of the null buffer bytes, to use in testing for nullness
-        let lhs_null_bytes = lhs.null_buffer().as_ref().unwrap().as_slice();
+        let lhs_nulls = lhs.nulls().unwrap();
 
-        let lhs_start = lhs.offset() + lhs_start;
-        let rhs_start = rhs.offset() + rhs_start;
-
-        BitIndexIterator::new(lhs_null_bytes, lhs_start, len).all(|i| {
-            let lhs_pos = lhs_start + i;
-            let rhs_pos = rhs_start + i;
+        BitIndexIterator::new(lhs_nulls.validity(), lhs_start + lhs_nulls.offset(), len).all(|i| {
+            let lhs_pos = lhs_start + lhs.offset() + i;
+            let rhs_pos = rhs_start + rhs.offset() + i;
             get_bit(lhs_values, lhs_pos) == get_bit(rhs_values, rhs_pos)
         })
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::array::{Array, BooleanArray};
-
-    #[test]
-    fn test_boolean_slice() {
-        let array = BooleanArray::from(vec![true; 32]);
-        let slice = array.slice(4, 12);
-        assert_eq!(slice.data(), slice.data());
-
-        let slice = array.slice(8, 12);
-        assert_eq!(slice.data(), slice.data());
-
-        let slice = array.slice(8, 24);
-        assert_eq!(slice.data(), slice.data());
-    }
-
-    #[test]
-    fn test_sliced_nullable_boolean_array() {
-        let a = BooleanArray::from(vec![None; 32]);
-        let b = BooleanArray::from(vec![true; 32]);
-        let slice_a = a.slice(1, 12);
-        let slice_b = b.slice(1, 12);
-        assert_ne!(slice_a.data(), slice_b.data());
-    }
-}
diff --git a/arrow/src/array/equal/dictionary.rs b/arrow-data/src/equal/dictionary.rs
similarity index 75%
rename from arrow/src/array/equal/dictionary.rs
rename to arrow-data/src/equal/dictionary.rs
index 4c9bcf798760..1d9c4b8d964f 100644
--- a/arrow/src/array/equal/dictionary.rs
+++ b/arrow-data/src/equal/dictionary.rs
@@ -15,9 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::{data::count_nulls, ArrayData};
-use crate::datatypes::ArrowNativeType;
-use crate::util::bit_util::get_bit;
+use crate::data::{contains_nulls, ArrayData};
+use arrow_buffer::ArrowNativeType;
 
 use super::equal_range;
 
@@ -34,10 +33,9 @@ pub(super) fn dictionary_equal<T: ArrowNativeType>(
     let lhs_values = &lhs.child_data()[0];
     let rhs_values = &rhs.child_data()[0];
 
-    let lhs_null_count = count_nulls(lhs.null_buffer(), lhs_start + lhs.offset(), len);
-    let rhs_null_count = count_nulls(rhs.null_buffer(), rhs_start + rhs.offset(), len);
-
-    if lhs_null_count == 0 && rhs_null_count == 0 {
+    // Only checking one null mask here because by the time the control flow reaches
+    // this point, the equality of the two masks would have already been verified.
+    if !contains_nulls(lhs.nulls(), lhs_start, len) {
         (0..len).all(|i| {
             let lhs_pos = lhs_start + i;
             let rhs_pos = rhs_start + i;
@@ -52,14 +50,14 @@ pub(super) fn dictionary_equal<T: ArrowNativeType>(
         })
     } else {
         // get a ref of the null buffer bytes, to use in testing for nullness
-        let lhs_null_bytes = lhs.null_buffer().as_ref().unwrap().as_slice();
-        let rhs_null_bytes = rhs.null_buffer().as_ref().unwrap().as_slice();
+        let lhs_nulls = lhs.nulls().unwrap();
+        let rhs_nulls = rhs.nulls().unwrap();
         (0..len).all(|i| {
             let lhs_pos = lhs_start + i;
             let rhs_pos = rhs_start + i;
 
-            let lhs_is_null = !get_bit(lhs_null_bytes, lhs_pos + lhs.offset());
-            let rhs_is_null = !get_bit(rhs_null_bytes, rhs_pos + rhs.offset());
+            let lhs_is_null = lhs_nulls.is_null(lhs_pos);
+            let rhs_is_null = rhs_nulls.is_null(rhs_pos);
 
             lhs_is_null
                 || (lhs_is_null == rhs_is_null)
diff --git a/arrow-data/src/equal/fixed_binary.rs b/arrow-data/src/equal/fixed_binary.rs
new file mode 100644
index 000000000000..0778d77e2fdd
--- /dev/null
+++ b/arrow-data/src/equal/fixed_binary.rs
@@ -0,0 +1,99 @@
+// 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.
+
+use crate::bit_iterator::BitSliceIterator;
+use crate::contains_nulls;
+use crate::data::ArrayData;
+use crate::equal::primitive::NULL_SLICES_SELECTIVITY_THRESHOLD;
+use arrow_schema::DataType;
+
+use super::utils::equal_len;
+
+pub(super) fn fixed_binary_equal(
+    lhs: &ArrayData,
+    rhs: &ArrayData,
+    lhs_start: usize,
+    rhs_start: usize,
+    len: usize,
+) -> bool {
+    let size = match lhs.data_type() {
+        DataType::FixedSizeBinary(i) => *i as usize,
+        _ => unreachable!(),
+    };
+
+    let lhs_values = &lhs.buffers()[0].as_slice()[lhs.offset() * size..];
+    let rhs_values = &rhs.buffers()[0].as_slice()[rhs.offset() * size..];
+
+    // Only checking one null mask here because by the time the control flow reaches
+    // this point, the equality of the two masks would have already been verified.
+    if !contains_nulls(lhs.nulls(), lhs_start, len) {
+        equal_len(
+            lhs_values,
+            rhs_values,
+            size * lhs_start,
+            size * rhs_start,
+            size * len,
+        )
+    } else {
+        let selectivity_frac = lhs.null_count() as f64 / lhs.len() as f64;
+
+        if selectivity_frac >= NULL_SLICES_SELECTIVITY_THRESHOLD {
+            // get a ref of the null buffer bytes, to use in testing for nullness
+            let lhs_nulls = lhs.nulls().unwrap();
+            let rhs_nulls = rhs.nulls().unwrap();
+            // with nulls, we need to compare item by item whenever it is not null
+            (0..len).all(|i| {
+                let lhs_pos = lhs_start + i;
+                let rhs_pos = rhs_start + i;
+
+                let lhs_is_null = lhs_nulls.is_null(lhs_pos);
+                let rhs_is_null = rhs_nulls.is_null(rhs_pos);
+
+                lhs_is_null
+                    || (lhs_is_null == rhs_is_null)
+                        && equal_len(
+                            lhs_values,
+                            rhs_values,
+                            lhs_pos * size,
+                            rhs_pos * size,
+                            size, // 1 * size since we are comparing a single entry
+                        )
+            })
+        } else {
+            let lhs_nulls = lhs.nulls().unwrap();
+            let lhs_slices_iter =
+                BitSliceIterator::new(lhs_nulls.validity(), lhs_start + lhs_nulls.offset(), len);
+            let rhs_nulls = rhs.nulls().unwrap();
+            let rhs_slices_iter =
+                BitSliceIterator::new(rhs_nulls.validity(), rhs_start + rhs_nulls.offset(), len);
+
+            lhs_slices_iter
+                .zip(rhs_slices_iter)
+                .all(|((l_start, l_end), (r_start, r_end))| {
+                    l_start == r_start
+                        && l_end == r_end
+                        && equal_len(
+                            lhs_values,
+                            rhs_values,
+                            (lhs_start + l_start) * size,
+                            (rhs_start + r_start) * size,
+                            (l_end - l_start) * size,
+                        )
+                })
+        }
+    }
+}
diff --git a/arrow/src/array/equal/fixed_list.rs b/arrow-data/src/equal/fixed_list.rs
similarity index 75%
rename from arrow/src/array/equal/fixed_list.rs
rename to arrow-data/src/equal/fixed_list.rs
index 82a347c86574..4b79e5c33fab 100644
--- a/arrow/src/array/equal/fixed_list.rs
+++ b/arrow-data/src/equal/fixed_list.rs
@@ -15,9 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::{data::count_nulls, ArrayData};
-use crate::datatypes::DataType;
-use crate::util::bit_util::get_bit;
+use crate::data::{contains_nulls, ArrayData};
+use arrow_schema::DataType;
 
 use super::equal_range;
 
@@ -36,10 +35,9 @@ pub(super) fn fixed_list_equal(
     let lhs_values = &lhs.child_data()[0];
     let rhs_values = &rhs.child_data()[0];
 
-    let lhs_null_count = count_nulls(lhs.null_buffer(), lhs_start + lhs.offset(), len);
-    let rhs_null_count = count_nulls(rhs.null_buffer(), rhs_start + rhs.offset(), len);
-
-    if lhs_null_count == 0 && rhs_null_count == 0 {
+    // Only checking one null mask here because by the time the control flow reaches
+    // this point, the equality of the two masks would have already been verified.
+    if !contains_nulls(lhs.nulls(), lhs_start, len) {
         equal_range(
             lhs_values,
             rhs_values,
@@ -49,15 +47,15 @@ pub(super) fn fixed_list_equal(
         )
     } else {
         // get a ref of the null buffer bytes, to use in testing for nullness
-        let lhs_null_bytes = lhs.null_buffer().as_ref().unwrap().as_slice();
-        let rhs_null_bytes = rhs.null_buffer().as_ref().unwrap().as_slice();
+        let lhs_nulls = lhs.nulls().unwrap();
+        let rhs_nulls = rhs.nulls().unwrap();
         // with nulls, we need to compare item by item whenever it is not null
         (0..len).all(|i| {
             let lhs_pos = lhs_start + i;
             let rhs_pos = rhs_start + i;
 
-            let lhs_is_null = !get_bit(lhs_null_bytes, lhs_pos + lhs.offset());
-            let rhs_is_null = !get_bit(rhs_null_bytes, rhs_pos + rhs.offset());
+            let lhs_is_null = lhs_nulls.is_null(lhs_pos);
+            let rhs_is_null = rhs_nulls.is_null(rhs_pos);
 
             lhs_is_null
                 || (lhs_is_null == rhs_is_null)
diff --git a/arrow/src/array/equal/list.rs b/arrow-data/src/equal/list.rs
similarity index 69%
rename from arrow/src/array/equal/list.rs
rename to arrow-data/src/equal/list.rs
index d032b1f04b5d..cc4ba3cacf9f 100644
--- a/arrow/src/array/equal/list.rs
+++ b/arrow-data/src/equal/list.rs
@@ -15,15 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{
-    array::ArrayData,
-    array::{data::count_nulls, OffsetSizeTrait},
-    util::bit_util::get_bit,
-};
+use crate::data::{count_nulls, ArrayData};
+use arrow_buffer::ArrowNativeType;
+use num::Integer;
 
 use super::equal_range;
 
-fn lengths_equal<T: OffsetSizeTrait>(lhs: &[T], rhs: &[T]) -> bool {
+fn lengths_equal<T: ArrowNativeType + Integer>(lhs: &[T], rhs: &[T]) -> bool {
     // invariant from `base_equal`
     debug_assert_eq!(lhs.len(), rhs.len());
 
@@ -45,7 +43,7 @@ fn lengths_equal<T: OffsetSizeTrait>(lhs: &[T], rhs: &[T]) -> bool {
         })
 }
 
-pub(super) fn list_equal<T: OffsetSizeTrait>(
+pub(super) fn list_equal<T: ArrowNativeType + Integer>(
     lhs: &ArrayData,
     rhs: &ArrayData,
     lhs_start: usize,
@@ -91,8 +89,8 @@ pub(super) fn list_equal<T: OffsetSizeTrait>(
     let lhs_values = &lhs.child_data()[0];
     let rhs_values = &rhs.child_data()[0];
 
-    let lhs_null_count = count_nulls(lhs.null_buffer(), lhs_start + lhs.offset(), len);
-    let rhs_null_count = count_nulls(rhs.null_buffer(), rhs_start + rhs.offset(), len);
+    let lhs_null_count = count_nulls(lhs.nulls(), lhs_start, len);
+    let rhs_null_count = count_nulls(rhs.nulls(), rhs_start, len);
 
     if lhs_null_count != rhs_null_count {
         return false;
@@ -113,8 +111,8 @@ pub(super) fn list_equal<T: OffsetSizeTrait>(
             )
     } else {
         // get a ref of the parent null buffer bytes, to use in testing for nullness
-        let lhs_null_bytes = lhs.null_buffer().unwrap().as_slice();
-        let rhs_null_bytes = rhs.null_buffer().unwrap().as_slice();
+        let lhs_nulls = lhs.nulls().unwrap();
+        let rhs_nulls = rhs.nulls().unwrap();
 
         // with nulls, we need to compare item by item whenever it is not null
         // TODO: Could potentially compare runs of not NULL values
@@ -122,8 +120,8 @@ pub(super) fn list_equal<T: OffsetSizeTrait>(
             let lhs_pos = lhs_start + i;
             let rhs_pos = rhs_start + i;
 
-            let lhs_is_null = !get_bit(lhs_null_bytes, lhs_pos + lhs.offset());
-            let rhs_is_null = !get_bit(rhs_null_bytes, rhs_pos + rhs.offset());
+            let lhs_is_null = lhs_nulls.is_null(lhs_pos);
+            let rhs_is_null = rhs_nulls.is_null(rhs_pos);
 
             if lhs_is_null != rhs_is_null {
                 return false;
@@ -149,52 +147,3 @@ pub(super) fn list_equal<T: OffsetSizeTrait>(
         })
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        array::{Array, Int64Builder, ListArray, ListBuilder},
-        datatypes::Int32Type,
-    };
-
-    #[test]
-    fn list_array_non_zero_nulls() {
-        // Tests handling of list arrays with non-empty null ranges
-        let mut builder = ListBuilder::new(Int64Builder::new(10));
-        builder.values().append_value(1);
-        builder.values().append_value(2);
-        builder.values().append_value(3);
-        builder.append(true);
-        builder.append(false);
-        let array1 = builder.finish();
-
-        let mut builder = ListBuilder::new(Int64Builder::new(10));
-        builder.values().append_value(1);
-        builder.values().append_value(2);
-        builder.values().append_value(3);
-        builder.append(true);
-        builder.values().append_null();
-        builder.values().append_null();
-        builder.append(false);
-        let array2 = builder.finish();
-
-        assert_eq!(array1, array2);
-    }
-
-    #[test]
-    fn test_list_different_offsets() {
-        let a = ListArray::from_iter_primitive::<Int32Type, _, _>([
-            Some([Some(0), Some(0)]),
-            Some([Some(1), Some(2)]),
-            Some([None, None]),
-        ]);
-        let b = ListArray::from_iter_primitive::<Int32Type, _, _>([
-            Some([Some(1), Some(2)]),
-            Some([None, None]),
-            Some([None, None]),
-        ]);
-        let a_slice = a.slice(1, 2);
-        let b_slice = b.slice(0, 2);
-        assert_eq!(&a_slice, &b_slice);
-    }
-}
diff --git a/arrow-data/src/equal/mod.rs b/arrow-data/src/equal/mod.rs
new file mode 100644
index 000000000000..b279546474a0
--- /dev/null
+++ b/arrow-data/src/equal/mod.rs
@@ -0,0 +1,151 @@
+// 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.
+
+//! Module containing functionality to compute array equality.
+//! This module uses [ArrayData] and does not
+//! depend on dynamic casting of `Array`.
+
+use crate::data::ArrayData;
+use arrow_buffer::i256;
+use arrow_schema::{DataType, IntervalUnit};
+use half::f16;
+
+mod boolean;
+mod dictionary;
+mod fixed_binary;
+mod fixed_list;
+mod list;
+mod null;
+mod primitive;
+mod run;
+mod structure;
+mod union;
+mod utils;
+mod variable_size;
+
+// these methods assume the same type, len and null count.
+// For this reason, they are not exposed and are instead used
+// to build the generic functions below (`equal_range` and `equal`).
+use boolean::boolean_equal;
+use dictionary::dictionary_equal;
+use fixed_binary::fixed_binary_equal;
+use fixed_list::fixed_list_equal;
+use list::list_equal;
+use null::null_equal;
+use primitive::primitive_equal;
+use structure::struct_equal;
+use union::union_equal;
+use variable_size::variable_sized_equal;
+
+use self::run::run_equal;
+
+/// Compares the values of two [ArrayData] starting at `lhs_start` and `rhs_start` respectively
+/// for `len` slots.
+#[inline]
+fn equal_values(
+    lhs: &ArrayData,
+    rhs: &ArrayData,
+    lhs_start: usize,
+    rhs_start: usize,
+    len: usize,
+) -> bool {
+    match lhs.data_type() {
+        DataType::Null => null_equal(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Boolean => boolean_equal(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::UInt8 => primitive_equal::<u8>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::UInt16 => primitive_equal::<u16>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::UInt32 => primitive_equal::<u32>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::UInt64 => primitive_equal::<u64>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Int8 => primitive_equal::<i8>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Int16 => primitive_equal::<i16>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Int32 => primitive_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Int64 => primitive_equal::<i64>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Float32 => primitive_equal::<f32>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Float64 => primitive_equal::<f64>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Decimal128(_, _) => primitive_equal::<i128>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Decimal256(_, _) => primitive_equal::<i256>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Date32 | DataType::Time32(_) | DataType::Interval(IntervalUnit::YearMonth) => {
+            primitive_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len)
+        }
+        DataType::Date64
+        | DataType::Interval(IntervalUnit::DayTime)
+        | DataType::Time64(_)
+        | DataType::Timestamp(_, _)
+        | DataType::Duration(_) => primitive_equal::<i64>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Interval(IntervalUnit::MonthDayNano) => {
+            primitive_equal::<i128>(lhs, rhs, lhs_start, rhs_start, len)
+        }
+        DataType::Utf8 | DataType::Binary => {
+            variable_sized_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len)
+        }
+        DataType::LargeUtf8 | DataType::LargeBinary => {
+            variable_sized_equal::<i64>(lhs, rhs, lhs_start, rhs_start, len)
+        }
+        DataType::FixedSizeBinary(_) => fixed_binary_equal(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::List(_) => list_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::LargeList(_) => list_equal::<i64>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::FixedSizeList(_, _) => fixed_list_equal(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Struct(_) => struct_equal(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Union(_, _) => union_equal(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Dictionary(data_type, _) => match data_type.as_ref() {
+            DataType::Int8 => dictionary_equal::<i8>(lhs, rhs, lhs_start, rhs_start, len),
+            DataType::Int16 => dictionary_equal::<i16>(lhs, rhs, lhs_start, rhs_start, len),
+            DataType::Int32 => dictionary_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len),
+            DataType::Int64 => dictionary_equal::<i64>(lhs, rhs, lhs_start, rhs_start, len),
+            DataType::UInt8 => dictionary_equal::<u8>(lhs, rhs, lhs_start, rhs_start, len),
+            DataType::UInt16 => dictionary_equal::<u16>(lhs, rhs, lhs_start, rhs_start, len),
+            DataType::UInt32 => dictionary_equal::<u32>(lhs, rhs, lhs_start, rhs_start, len),
+            DataType::UInt64 => dictionary_equal::<u64>(lhs, rhs, lhs_start, rhs_start, len),
+            _ => unreachable!(),
+        },
+        DataType::Float16 => primitive_equal::<f16>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::Map(_, _) => list_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len),
+        DataType::RunEndEncoded(_, _) => run_equal(lhs, rhs, lhs_start, rhs_start, len),
+    }
+}
+
+fn equal_range(
+    lhs: &ArrayData,
+    rhs: &ArrayData,
+    lhs_start: usize,
+    rhs_start: usize,
+    len: usize,
+) -> bool {
+    utils::equal_nulls(lhs, rhs, lhs_start, rhs_start, len)
+        && equal_values(lhs, rhs, lhs_start, rhs_start, len)
+}
+
+/// Logically compares two [ArrayData].
+/// Two arrays are logically equal if and only if:
+/// * their data types are equal
+/// * their lengths are equal
+/// * their null counts are equal
+/// * their null bitmaps are equal
+/// * each of their items are equal
+/// two items are equal when their in-memory representation is physically equal (i.e. same bit content).
+/// The physical comparison depend on the data type.
+/// # Panics
+/// This function may panic whenever any of the [ArrayData] does not follow the Arrow specification.
+/// (e.g. wrong number of buffers, buffer `len` does not correspond to the declared `len`)
+pub fn equal(lhs: &ArrayData, rhs: &ArrayData) -> bool {
+    utils::base_equal(lhs, rhs)
+        && lhs.null_count() == rhs.null_count()
+        && utils::equal_nulls(lhs, rhs, 0, 0, lhs.len())
+        && equal_values(lhs, rhs, 0, 0, lhs.len())
+}
+
+// See arrow/tests/array_equal.rs for tests
diff --git a/arrow/src/array/equal/null.rs b/arrow-data/src/equal/null.rs
similarity index 97%
rename from arrow/src/array/equal/null.rs
rename to arrow-data/src/equal/null.rs
index f287a382507a..1478e448cec2 100644
--- a/arrow/src/array/equal/null.rs
+++ b/arrow-data/src/equal/null.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::ArrayData;
+use crate::data::ArrayData;
 
 #[inline]
 pub(super) fn null_equal(
diff --git a/arrow-data/src/equal/primitive.rs b/arrow-data/src/equal/primitive.rs
new file mode 100644
index 000000000000..e92fdd2ba23b
--- /dev/null
+++ b/arrow-data/src/equal/primitive.rs
@@ -0,0 +1,97 @@
+// 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.
+
+use crate::bit_iterator::BitSliceIterator;
+use crate::contains_nulls;
+use std::mem::size_of;
+
+use crate::data::ArrayData;
+
+use super::utils::equal_len;
+
+pub(crate) const NULL_SLICES_SELECTIVITY_THRESHOLD: f64 = 0.4;
+
+pub(super) fn primitive_equal<T>(
+    lhs: &ArrayData,
+    rhs: &ArrayData,
+    lhs_start: usize,
+    rhs_start: usize,
+    len: usize,
+) -> bool {
+    let byte_width = size_of::<T>();
+    let lhs_values = &lhs.buffers()[0].as_slice()[lhs.offset() * byte_width..];
+    let rhs_values = &rhs.buffers()[0].as_slice()[rhs.offset() * byte_width..];
+
+    // Only checking one null mask here because by the time the control flow reaches
+    // this point, the equality of the two masks would have already been verified.
+    if !contains_nulls(lhs.nulls(), lhs_start, len) {
+        // without nulls, we just need to compare slices
+        equal_len(
+            lhs_values,
+            rhs_values,
+            lhs_start * byte_width,
+            rhs_start * byte_width,
+            len * byte_width,
+        )
+    } else {
+        let selectivity_frac = lhs.null_count() as f64 / lhs.len() as f64;
+
+        if selectivity_frac >= NULL_SLICES_SELECTIVITY_THRESHOLD {
+            // get a ref of the null buffer bytes, to use in testing for nullness
+            let lhs_nulls = lhs.nulls().unwrap();
+            let rhs_nulls = rhs.nulls().unwrap();
+            // with nulls, we need to compare item by item whenever it is not null
+            (0..len).all(|i| {
+                let lhs_pos = lhs_start + i;
+                let rhs_pos = rhs_start + i;
+                let lhs_is_null = lhs_nulls.is_null(lhs_pos);
+                let rhs_is_null = rhs_nulls.is_null(rhs_pos);
+
+                lhs_is_null
+                    || (lhs_is_null == rhs_is_null)
+                        && equal_len(
+                            lhs_values,
+                            rhs_values,
+                            lhs_pos * byte_width,
+                            rhs_pos * byte_width,
+                            byte_width, // 1 * byte_width since we are comparing a single entry
+                        )
+            })
+        } else {
+            let lhs_nulls = lhs.nulls().unwrap();
+            let lhs_slices_iter =
+                BitSliceIterator::new(lhs_nulls.validity(), lhs_start + lhs_nulls.offset(), len);
+            let rhs_nulls = rhs.nulls().unwrap();
+            let rhs_slices_iter =
+                BitSliceIterator::new(rhs_nulls.validity(), rhs_start + rhs_nulls.offset(), len);
+
+            lhs_slices_iter
+                .zip(rhs_slices_iter)
+                .all(|((l_start, l_end), (r_start, r_end))| {
+                    l_start == r_start
+                        && l_end == r_end
+                        && equal_len(
+                            lhs_values,
+                            rhs_values,
+                            (lhs_start + l_start) * byte_width,
+                            (rhs_start + r_start) * byte_width,
+                            (l_end - l_start) * byte_width,
+                        )
+                })
+        }
+    }
+}
diff --git a/arrow-data/src/equal/run.rs b/arrow-data/src/equal/run.rs
new file mode 100644
index 000000000000..6c9393ecd8d3
--- /dev/null
+++ b/arrow-data/src/equal/run.rs
@@ -0,0 +1,86 @@
+// 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.
+
+use crate::data::ArrayData;
+
+use super::equal_range;
+
+/// The current implementation of comparison of run array support physical comparison.
+/// Comparing run encoded array based on logical indices (`lhs_start`, `rhs_start`) will
+/// be time consuming as converting from logical index to physical index cannot be done
+/// in constant time. The current comparison compares the underlying physical arrays.
+pub(super) fn run_equal(
+    lhs: &ArrayData,
+    rhs: &ArrayData,
+    lhs_start: usize,
+    rhs_start: usize,
+    len: usize,
+) -> bool {
+    if lhs_start != 0
+        || rhs_start != 0
+        || (lhs.len() != len && rhs.len() != len)
+        || lhs.offset() > 0
+        || rhs.offset() > 0
+    {
+        unimplemented!("Logical comparison for run array not supported.")
+    }
+
+    if lhs.len() != rhs.len() {
+        return false;
+    }
+
+    let lhs_child_data = lhs.child_data();
+    let lhs_run_ends_array = &lhs_child_data[0];
+    let lhs_values_array = &lhs_child_data[1];
+
+    let rhs_child_data = rhs.child_data();
+    let rhs_run_ends_array = &rhs_child_data[0];
+    let rhs_values_array = &rhs_child_data[1];
+
+    if lhs_run_ends_array.len() != rhs_run_ends_array.len() {
+        return false;
+    }
+
+    if lhs_values_array.len() != rhs_values_array.len() {
+        return false;
+    }
+
+    // check run ends array are equal. The length of the physical array
+    // is used to validate the child arrays.
+    let run_ends_equal = equal_range(
+        lhs_run_ends_array,
+        rhs_run_ends_array,
+        lhs_start,
+        rhs_start,
+        lhs_run_ends_array.len(),
+    );
+
+    // if run ends array are not the same return early without validating
+    // values array.
+    if !run_ends_equal {
+        return false;
+    }
+
+    // check values array are equal
+    equal_range(
+        lhs_values_array,
+        rhs_values_array,
+        lhs_start,
+        rhs_start,
+        rhs_values_array.len(),
+    )
+}
diff --git a/arrow/src/array/equal/structure.rs b/arrow-data/src/equal/structure.rs
similarity index 74%
rename from arrow/src/array/equal/structure.rs
rename to arrow-data/src/equal/structure.rs
index 0f943e40cac6..e4751c26f489 100644
--- a/arrow/src/array/equal/structure.rs
+++ b/arrow-data/src/equal/structure.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{array::data::count_nulls, array::ArrayData, util::bit_util::get_bit};
+use crate::data::{contains_nulls, ArrayData};
 
 use super::equal_range;
 
@@ -43,23 +43,21 @@ pub(super) fn struct_equal(
     rhs_start: usize,
     len: usize,
 ) -> bool {
-    // we have to recalculate null counts from the null buffers
-    let lhs_null_count = count_nulls(lhs.null_buffer(), lhs_start + lhs.offset(), len);
-    let rhs_null_count = count_nulls(rhs.null_buffer(), rhs_start + rhs.offset(), len);
-
-    if lhs_null_count == 0 && rhs_null_count == 0 {
+    // Only checking one null mask here because by the time the control flow reaches
+    // this point, the equality of the two masks would have already been verified.
+    if !contains_nulls(lhs.nulls(), lhs_start, len) {
         equal_child_values(lhs, rhs, lhs_start, rhs_start, len)
     } else {
         // get a ref of the null buffer bytes, to use in testing for nullness
-        let lhs_null_bytes = lhs.null_buffer().as_ref().unwrap().as_slice();
-        let rhs_null_bytes = rhs.null_buffer().as_ref().unwrap().as_slice();
+        let lhs_nulls = lhs.nulls().unwrap();
+        let rhs_nulls = rhs.nulls().unwrap();
         // with nulls, we need to compare item by item whenever it is not null
         (0..len).all(|i| {
             let lhs_pos = lhs_start + i;
             let rhs_pos = rhs_start + i;
             // if both struct and child had no null buffers,
-            let lhs_is_null = !get_bit(lhs_null_bytes, lhs_pos + lhs.offset());
-            let rhs_is_null = !get_bit(rhs_null_bytes, rhs_pos + rhs.offset());
+            let lhs_is_null = lhs_nulls.is_null(lhs_pos);
+            let rhs_is_null = rhs_nulls.is_null(rhs_pos);
 
             if lhs_is_null != rhs_is_null {
                 return false;
diff --git a/arrow/src/array/equal/union.rs b/arrow-data/src/equal/union.rs
similarity index 79%
rename from arrow/src/array/equal/union.rs
rename to arrow-data/src/equal/union.rs
index e8b9d27b6f0f..62de276e507f 100644
--- a/arrow/src/array/equal/union.rs
+++ b/arrow-data/src/equal/union.rs
@@ -15,7 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{array::ArrayData, datatypes::DataType, datatypes::UnionMode};
+use crate::data::ArrayData;
+use arrow_schema::{DataType, UnionFields, UnionMode};
 
 use super::equal_range;
 
@@ -27,8 +28,8 @@ fn equal_dense(
     rhs_type_ids: &[i8],
     lhs_offsets: &[i32],
     rhs_offsets: &[i32],
-    lhs_field_type_ids: &[i8],
-    rhs_field_type_ids: &[i8],
+    lhs_fields: &UnionFields,
+    rhs_fields: &UnionFields,
 ) -> bool {
     let offsets = lhs_offsets.iter().zip(rhs_offsets.iter());
 
@@ -37,13 +38,13 @@ fn equal_dense(
         .zip(rhs_type_ids.iter())
         .zip(offsets)
         .all(|((l_type_id, r_type_id), (l_offset, r_offset))| {
-            let lhs_child_index = lhs_field_type_ids
+            let lhs_child_index = lhs_fields
                 .iter()
-                .position(|r| r == l_type_id)
+                .position(|(r, _)| r == *l_type_id)
                 .unwrap();
-            let rhs_child_index = rhs_field_type_ids
+            let rhs_child_index = rhs_fields
                 .iter()
-                .position(|r| r == r_type_id)
+                .position(|(r, _)| r == *r_type_id)
                 .unwrap();
             let lhs_values = &lhs.child_data()[lhs_child_index];
             let rhs_values = &rhs.child_data()[rhs_child_index];
@@ -69,7 +70,13 @@ fn equal_sparse(
         .iter()
         .zip(rhs.child_data())
         .all(|(lhs_values, rhs_values)| {
-            equal_range(lhs_values, rhs_values, lhs_start, rhs_start, len)
+            equal_range(
+                lhs_values,
+                rhs_values,
+                lhs_start + lhs.offset(),
+                rhs_start + rhs.offset(),
+                len,
+            )
         })
 }
 
@@ -88,8 +95,8 @@ pub(super) fn union_equal(
 
     match (lhs.data_type(), rhs.data_type()) {
         (
-            DataType::Union(_, lhs_type_ids, UnionMode::Dense),
-            DataType::Union(_, rhs_type_ids, UnionMode::Dense),
+            DataType::Union(lhs_fields, UnionMode::Dense),
+            DataType::Union(rhs_fields, UnionMode::Dense),
         ) => {
             let lhs_offsets = lhs.buffer::<i32>(1);
             let rhs_offsets = rhs.buffer::<i32>(1);
@@ -105,14 +112,11 @@ pub(super) fn union_equal(
                     rhs_type_id_range,
                     lhs_offsets_range,
                     rhs_offsets_range,
-                    lhs_type_ids,
-                    rhs_type_ids,
+                    lhs_fields,
+                    rhs_fields,
                 )
         }
-        (
-            DataType::Union(_, _, UnionMode::Sparse),
-            DataType::Union(_, _, UnionMode::Sparse),
-        ) => {
+        (DataType::Union(_, UnionMode::Sparse), DataType::Union(_, UnionMode::Sparse)) => {
             lhs_type_id_range == rhs_type_id_range
                 && equal_sparse(lhs, rhs, lhs_start, rhs_start, len)
         }
diff --git a/arrow/src/array/equal/utils.rs b/arrow-data/src/equal/utils.rs
similarity index 69%
rename from arrow/src/array/equal/utils.rs
rename to arrow-data/src/equal/utils.rs
index 449055d366ec..f1f4be44730e 100644
--- a/arrow/src/array/equal/utils.rs
+++ b/arrow-data/src/equal/utils.rs
@@ -15,10 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::data::contains_nulls;
-use crate::array::ArrayData;
-use crate::datatypes::DataType;
-use crate::util::bit_chunk_iterator::BitChunks;
+use crate::data::{contains_nulls, ArrayData};
+use arrow_buffer::bit_chunk_iterator::BitChunks;
+use arrow_schema::DataType;
 
 // whether bits along the positions are equal
 // `lhs_start`, `rhs_start` and `len` are _measured in bits_.
@@ -30,16 +29,9 @@ pub(super) fn equal_bits(
     rhs_start: usize,
     len: usize,
 ) -> bool {
-    let lhs = BitChunks::new(lhs_values, lhs_start, len);
-    let rhs = BitChunks::new(rhs_values, rhs_start, len);
-
-    for (a, b) in lhs.iter().zip(rhs.iter()) {
-        if a != b {
-            return false;
-        }
-    }
-
-    lhs.remainder_bits() == rhs.remainder_bits()
+    let lhs = BitChunks::new(lhs_values, lhs_start, len).iter_padded();
+    let rhs = BitChunks::new(rhs_values, rhs_start, len).iter_padded();
+    lhs.zip(rhs).all(|(a, b)| a == b)
 }
 
 #[inline]
@@ -50,15 +42,16 @@ pub(super) fn equal_nulls(
     rhs_start: usize,
     len: usize,
 ) -> bool {
-    let lhs_offset = lhs_start + lhs.offset();
-    let rhs_offset = rhs_start + rhs.offset();
-
-    match (lhs.null_buffer(), rhs.null_buffer()) {
-        (Some(lhs), Some(rhs)) => {
-            equal_bits(lhs.as_slice(), rhs.as_slice(), lhs_offset, rhs_offset, len)
-        }
-        (Some(lhs), None) => !contains_nulls(Some(lhs), lhs_offset, len),
-        (None, Some(rhs)) => !contains_nulls(Some(rhs), rhs_offset, len),
+    match (lhs.nulls(), rhs.nulls()) {
+        (Some(lhs), Some(rhs)) => equal_bits(
+            lhs.validity(),
+            rhs.validity(),
+            lhs.offset() + lhs_start,
+            rhs.offset() + rhs_start,
+            len,
+        ),
+        (Some(lhs), None) => !contains_nulls(Some(lhs), lhs_start, len),
+        (None, Some(rhs)) => !contains_nulls(Some(rhs), rhs_start, len),
         (None, None) => true,
     }
 }
@@ -66,7 +59,7 @@ pub(super) fn equal_nulls(
 #[inline]
 pub(super) fn base_equal(lhs: &ArrayData, rhs: &ArrayData) -> bool {
     let equal_type = match (lhs.data_type(), rhs.data_type()) {
-        (DataType::Union(l_fields, _, l_mode), DataType::Union(r_fields, _, r_mode)) => {
+        (DataType::Union(l_fields, l_mode), DataType::Union(r_fields, r_mode)) => {
             l_fields == r_fields && l_mode == r_mode
         }
         (DataType::Map(l_field, l_sorted), DataType::Map(r_field, r_sorted)) => {
@@ -74,17 +67,15 @@ pub(super) fn base_equal(lhs: &ArrayData, rhs: &ArrayData) -> bool {
                 (DataType::Struct(l_fields), DataType::Struct(r_fields))
                     if l_fields.len() == 2 && r_fields.len() == 2 =>
                 {
-                    let l_key_field = l_fields.get(0).unwrap();
-                    let r_key_field = r_fields.get(0).unwrap();
-                    let l_value_field = l_fields.get(1).unwrap();
-                    let r_value_field = r_fields.get(1).unwrap();
+                    let l_key_field = &l_fields[0];
+                    let r_key_field = &r_fields[0];
+                    let l_value_field = &l_fields[1];
+                    let r_value_field = &r_fields[1];
 
                     // We don't enforce the equality of field names
-                    let data_type_equal = l_key_field.data_type()
-                        == r_key_field.data_type()
+                    let data_type_equal = l_key_field.data_type() == r_key_field.data_type()
                         && l_value_field.data_type() == r_value_field.data_type();
-                    let nullability_equal = l_key_field.is_nullable()
-                        == r_key_field.is_nullable()
+                    let nullability_equal = l_key_field.is_nullable() == r_key_field.is_nullable()
                         && l_value_field.is_nullable() == r_value_field.is_nullable();
                     let metadata_equal = l_key_field.metadata() == r_key_field.metadata()
                         && l_value_field.metadata() == r_value_field.metadata();
diff --git a/arrow/src/array/equal/variable_size.rs b/arrow-data/src/equal/variable_size.rs
similarity index 71%
rename from arrow/src/array/equal/variable_size.rs
rename to arrow-data/src/equal/variable_size.rs
index f40f79e404ac..92f00818b4a0 100644
--- a/arrow/src/array/equal/variable_size.rs
+++ b/arrow-data/src/equal/variable_size.rs
@@ -15,15 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::util::bit_util::get_bit;
-use crate::{
-    array::data::count_nulls,
-    array::{ArrayData, OffsetSizeTrait},
-};
+use crate::data::{contains_nulls, ArrayData};
+use arrow_buffer::ArrowNativeType;
+use num::Integer;
 
 use super::utils::equal_len;
 
-fn offset_value_equal<T: OffsetSizeTrait>(
+fn offset_value_equal<T: ArrowNativeType + Integer>(
     lhs_values: &[u8],
     rhs_values: &[u8],
     lhs_offsets: &[T],
@@ -32,8 +30,8 @@ fn offset_value_equal<T: OffsetSizeTrait>(
     rhs_pos: usize,
     len: usize,
 ) -> bool {
-    let lhs_start = lhs_offsets[lhs_pos].to_usize().unwrap();
-    let rhs_start = rhs_offsets[rhs_pos].to_usize().unwrap();
+    let lhs_start = lhs_offsets[lhs_pos].as_usize();
+    let rhs_start = rhs_offsets[rhs_pos].as_usize();
     let lhs_len = lhs_offsets[lhs_pos + len] - lhs_offsets[lhs_pos];
     let rhs_len = rhs_offsets[rhs_pos + len] - rhs_offsets[rhs_pos];
 
@@ -47,7 +45,7 @@ fn offset_value_equal<T: OffsetSizeTrait>(
         )
 }
 
-pub(super) fn variable_sized_equal<T: OffsetSizeTrait>(
+pub(super) fn variable_sized_equal<T: ArrowNativeType + Integer>(
     lhs: &ArrayData,
     rhs: &ArrayData,
     lhs_start: usize,
@@ -61,14 +59,9 @@ pub(super) fn variable_sized_equal<T: OffsetSizeTrait>(
     let lhs_values = lhs.buffers()[1].as_slice();
     let rhs_values = rhs.buffers()[1].as_slice();
 
-    let lhs_null_count = count_nulls(lhs.null_buffer(), lhs_start + lhs.offset(), len);
-    let rhs_null_count = count_nulls(rhs.null_buffer(), rhs_start + rhs.offset(), len);
-
-    if lhs_null_count == 0
-        && rhs_null_count == 0
-        && !lhs_values.is_empty()
-        && !rhs_values.is_empty()
-    {
+    // Only checking one null mask here because by the time the control flow reaches
+    // this point, the equality of the two masks would have already been verified.
+    if !contains_nulls(lhs.nulls(), lhs_start, len) {
         offset_value_equal(
             lhs_values,
             rhs_values,
@@ -84,15 +77,8 @@ pub(super) fn variable_sized_equal<T: OffsetSizeTrait>(
             let rhs_pos = rhs_start + i;
 
             // the null bits can still be `None`, indicating that the value is valid.
-            let lhs_is_null = !lhs
-                .null_buffer()
-                .map(|v| get_bit(v.as_slice(), lhs.offset() + lhs_pos))
-                .unwrap_or(true);
-
-            let rhs_is_null = !rhs
-                .null_buffer()
-                .map(|v| get_bit(v.as_slice(), rhs.offset() + rhs_pos))
-                .unwrap_or(true);
+            let lhs_is_null = lhs.nulls().map(|v| v.is_null(lhs_pos)).unwrap_or_default();
+            let rhs_is_null = rhs.nulls().map(|v| v.is_null(rhs_pos)).unwrap_or_default();
 
             lhs_is_null
                 || (lhs_is_null == rhs_is_null)
diff --git a/arrow-data/src/ffi.rs b/arrow-data/src/ffi.rs
new file mode 100644
index 000000000000..589f7dac6d19
--- /dev/null
+++ b/arrow-data/src/ffi.rs
@@ -0,0 +1,329 @@
+// 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.
+
+//! Contains declarations to bind to the [C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html).
+
+use crate::bit_mask::set_bits;
+use crate::{layout, ArrayData};
+use arrow_buffer::buffer::NullBuffer;
+use arrow_buffer::{Buffer, MutableBuffer};
+use arrow_schema::DataType;
+use std::ffi::c_void;
+
+/// ABI-compatible struct for ArrowArray from C Data Interface
+/// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
+///
+/// ```
+/// # use arrow_data::ArrayData;
+/// # use arrow_data::ffi::FFI_ArrowArray;
+/// fn export_array(array: &ArrayData) -> FFI_ArrowArray {
+///     FFI_ArrowArray::new(array)
+/// }
+/// ```
+#[repr(C)]
+#[derive(Debug)]
+pub struct FFI_ArrowArray {
+    length: i64,
+    null_count: i64,
+    offset: i64,
+    n_buffers: i64,
+    n_children: i64,
+    buffers: *mut *const c_void,
+    children: *mut *mut FFI_ArrowArray,
+    dictionary: *mut FFI_ArrowArray,
+    release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>,
+    // When exported, this MUST contain everything that is owned by this array.
+    // for example, any buffer pointed to in `buffers` must be here, as well
+    // as the `buffers` pointer itself.
+    // In other words, everything in [FFI_ArrowArray] must be owned by
+    // `private_data` and can assume that they do not outlive `private_data`.
+    private_data: *mut c_void,
+}
+
+impl Drop for FFI_ArrowArray {
+    fn drop(&mut self) {
+        match self.release {
+            None => (),
+            Some(release) => unsafe { release(self) },
+        };
+    }
+}
+
+unsafe impl Send for FFI_ArrowArray {}
+unsafe impl Sync for FFI_ArrowArray {}
+
+// callback used to drop [FFI_ArrowArray] when it is exported
+unsafe extern "C" fn release_array(array: *mut FFI_ArrowArray) {
+    if array.is_null() {
+        return;
+    }
+    let array = &mut *array;
+
+    // take ownership of `private_data`, therefore dropping it`
+    let private = Box::from_raw(array.private_data as *mut ArrayPrivateData);
+    for child in private.children.iter() {
+        let _ = Box::from_raw(*child);
+    }
+    if !private.dictionary.is_null() {
+        let _ = Box::from_raw(private.dictionary);
+    }
+
+    array.release = None;
+}
+
+/// Aligns the provided `nulls` to the provided `data_offset`
+///
+/// This is a temporary measure until offset is removed from ArrayData (#1799)
+fn align_nulls(data_offset: usize, nulls: Option<&NullBuffer>) -> Option<Buffer> {
+    let nulls = nulls?;
+    if data_offset == nulls.offset() {
+        // Underlying buffer is already aligned
+        return Some(nulls.buffer().clone());
+    }
+    if data_offset == 0 {
+        return Some(nulls.inner().sliced());
+    }
+    let mut builder = MutableBuffer::new_null(data_offset + nulls.len());
+    set_bits(
+        builder.as_slice_mut(),
+        nulls.validity(),
+        data_offset,
+        nulls.offset(),
+        nulls.len(),
+    );
+    Some(builder.into())
+}
+
+struct ArrayPrivateData {
+    #[allow(dead_code)]
+    buffers: Vec<Option<Buffer>>,
+    buffers_ptr: Box<[*const c_void]>,
+    children: Box<[*mut FFI_ArrowArray]>,
+    dictionary: *mut FFI_ArrowArray,
+}
+
+impl FFI_ArrowArray {
+    /// creates a new `FFI_ArrowArray` from existing data.
+    pub fn new(data: &ArrayData) -> Self {
+        let data_layout = layout(data.data_type());
+
+        let buffers = if data_layout.can_contain_null_mask {
+            // * insert the null buffer at the start
+            // * make all others `Option<Buffer>`.
+            std::iter::once(align_nulls(data.offset(), data.nulls()))
+                .chain(data.buffers().iter().map(|b| Some(b.clone())))
+                .collect::<Vec<_>>()
+        } else {
+            data.buffers().iter().map(|b| Some(b.clone())).collect()
+        };
+
+        // `n_buffers` is the number of buffers by the spec.
+        let n_buffers = {
+            data_layout.buffers.len() + {
+                // If the layout has a null buffer by Arrow spec.
+                // Note that even the array doesn't have a null buffer because it has
+                // no null value, we still need to count 1 here to follow the spec.
+                usize::from(data_layout.can_contain_null_mask)
+            }
+        } as i64;
+
+        let buffers_ptr = buffers
+            .iter()
+            .flat_map(|maybe_buffer| match maybe_buffer {
+                // note that `raw_data` takes into account the buffer's offset
+                Some(b) => Some(b.as_ptr() as *const c_void),
+                // This is for null buffer. We only put a null pointer for
+                // null buffer if by spec it can contain null mask.
+                None if data_layout.can_contain_null_mask => Some(std::ptr::null()),
+                None => None,
+            })
+            .collect::<Box<[_]>>();
+
+        let empty = vec![];
+        let (child_data, dictionary) = match data.data_type() {
+            DataType::Dictionary(_, _) => (
+                empty.as_slice(),
+                Box::into_raw(Box::new(FFI_ArrowArray::new(&data.child_data()[0]))),
+            ),
+            _ => (data.child_data(), std::ptr::null_mut()),
+        };
+
+        let children = child_data
+            .iter()
+            .map(|child| Box::into_raw(Box::new(FFI_ArrowArray::new(child))))
+            .collect::<Box<_>>();
+        let n_children = children.len() as i64;
+
+        // As in the IPC format, emit null_count = length for Null type
+        let null_count = match data.data_type() {
+            DataType::Null => data.len(),
+            _ => data.null_count(),
+        };
+
+        // create the private data owning everything.
+        // any other data must be added here, e.g. via a struct, to track lifetime.
+        let mut private_data = Box::new(ArrayPrivateData {
+            buffers,
+            buffers_ptr,
+            children,
+            dictionary,
+        });
+
+        Self {
+            length: data.len() as i64,
+            null_count: null_count as i64,
+            offset: data.offset() as i64,
+            n_buffers,
+            n_children,
+            buffers: private_data.buffers_ptr.as_mut_ptr(),
+            children: private_data.children.as_mut_ptr(),
+            dictionary,
+            release: Some(release_array),
+            private_data: Box::into_raw(private_data) as *mut c_void,
+        }
+    }
+
+    /// Takes ownership of the pointed to [`FFI_ArrowArray`]
+    ///
+    /// This acts to [move] the data out of `array`, setting the release callback to NULL
+    ///
+    /// # Safety
+    ///
+    /// * `array` must be [valid] for reads and writes
+    /// * `array` must be properly aligned
+    /// * `array` must point to a properly initialized value of [`FFI_ArrowArray`]
+    ///
+    /// [move]: https://arrow.apache.org/docs/format/CDataInterface.html#moving-an-array
+    /// [valid]: https://doc.rust-lang.org/std/ptr/index.html#safety
+    pub unsafe fn from_raw(array: *mut FFI_ArrowArray) -> Self {
+        std::ptr::replace(array, Self::empty())
+    }
+
+    /// create an empty `FFI_ArrowArray`, which can be used to import data into
+    pub fn empty() -> Self {
+        Self {
+            length: 0,
+            null_count: 0,
+            offset: 0,
+            n_buffers: 0,
+            n_children: 0,
+            buffers: std::ptr::null_mut(),
+            children: std::ptr::null_mut(),
+            dictionary: std::ptr::null_mut(),
+            release: None,
+            private_data: std::ptr::null_mut(),
+        }
+    }
+
+    /// the length of the array
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.length as usize
+    }
+
+    /// whether the array is empty
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.length == 0
+    }
+
+    /// Whether the array has been released
+    #[inline]
+    pub fn is_released(&self) -> bool {
+        self.release.is_none()
+    }
+
+    /// the offset of the array
+    #[inline]
+    pub fn offset(&self) -> usize {
+        self.offset as usize
+    }
+
+    /// the null count of the array
+    #[inline]
+    pub fn null_count(&self) -> usize {
+        self.null_count as usize
+    }
+
+    /// Returns the buffer at the provided index
+    ///
+    /// # Panic
+    /// Panics if index exceeds the number of buffers or the buffer is not correctly aligned
+    #[inline]
+    pub fn buffer(&self, index: usize) -> *const u8 {
+        assert!(!self.buffers.is_null());
+        assert!(index < self.num_buffers());
+        // SAFETY:
+        // If buffers is not null must be valid for reads up to num_buffers
+        unsafe { std::ptr::read_unaligned((self.buffers as *mut *const u8).add(index)) }
+    }
+
+    /// Returns the number of buffers
+    #[inline]
+    pub fn num_buffers(&self) -> usize {
+        self.n_buffers as _
+    }
+
+    /// Returns the child at the provided index
+    #[inline]
+    pub fn child(&self, index: usize) -> &FFI_ArrowArray {
+        assert!(!self.children.is_null());
+        assert!(index < self.num_children());
+        // Safety:
+        // If children is not null must be valid for reads up to num_children
+        unsafe {
+            let child = std::ptr::read_unaligned(self.children.add(index));
+            child.as_ref().unwrap()
+        }
+    }
+
+    /// Returns the number of children
+    #[inline]
+    pub fn num_children(&self) -> usize {
+        self.n_children as _
+    }
+
+    /// Returns the dictionary if any
+    #[inline]
+    pub fn dictionary(&self) -> Option<&Self> {
+        // Safety:
+        // If dictionary is not null should be valid for reads of `Self`
+        unsafe { self.dictionary.as_ref() }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // More tests located in top-level arrow crate
+
+    #[test]
+    fn null_array_n_buffers() {
+        let data = ArrayData::new_null(&DataType::Null, 10);
+
+        let ffi_array = FFI_ArrowArray::new(&data);
+        assert_eq!(0, ffi_array.n_buffers);
+
+        let private_data =
+            unsafe { Box::from_raw(ffi_array.private_data as *mut ArrayPrivateData) };
+
+        assert_eq!(0, private_data.buffers_ptr.len());
+
+        Box::into_raw(private_data);
+    }
+}
diff --git a/arrow/src/json/mod.rs b/arrow-data/src/lib.rs
similarity index 69%
rename from arrow/src/json/mod.rs
rename to arrow-data/src/lib.rs
index 6b3df188a476..cfa0dba66c35 100644
--- a/arrow/src/json/mod.rs
+++ b/arrow-data/src/lib.rs
@@ -15,13 +15,18 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Transfer data between the Arrow memory format and JSON
-//! line-delimited records. See the module level documentation for the
-//! [`reader`] and [`writer`] for usage examples.
+//! Low-level array data abstractions for [Apache Arrow Rust](https://docs.rs/arrow)
+//!
+//! For a higher-level, strongly-typed interface see [arrow_array](https://docs.rs/arrow_array)
 
-pub mod reader;
-pub mod writer;
+mod data;
+pub use data::*;
 
-pub use self::reader::Reader;
-pub use self::reader::ReaderBuilder;
-pub use self::writer::{ArrayWriter, LineDelimitedWriter, Writer};
+mod equal;
+pub mod transform;
+
+pub use arrow_buffer::{bit_iterator, bit_mask};
+pub mod decimal;
+
+#[cfg(feature = "ffi")]
+pub mod ffi;
diff --git a/arrow/src/array/transform/boolean.rs b/arrow-data/src/transform/boolean.rs
similarity index 95%
rename from arrow/src/array/transform/boolean.rs
rename to arrow-data/src/transform/boolean.rs
index e0b6231a226e..d93fa15a4e0f 100644
--- a/arrow/src/array/transform/boolean.rs
+++ b/arrow-data/src/transform/boolean.rs
@@ -16,8 +16,8 @@
 // under the License.
 
 use super::{Extend, _MutableArrayData, utils::resize_for_bits};
-use crate::array::ArrayData;
-use crate::util::bit_mask::set_bits;
+use crate::bit_mask::set_bits;
+use crate::ArrayData;
 
 pub(super) fn build_extend(array: &ArrayData) -> Extend {
     let values = array.buffers()[0].as_slice();
diff --git a/arrow/src/array/transform/fixed_binary.rs b/arrow-data/src/transform/fixed_binary.rs
similarity index 54%
rename from arrow/src/array/transform/fixed_binary.rs
rename to arrow-data/src/transform/fixed_binary.rs
index 6d6262ca3c4e..44c6f46ebf7e 100644
--- a/arrow/src/array/transform/fixed_binary.rs
+++ b/arrow-data/src/transform/fixed_binary.rs
@@ -15,50 +15,28 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{array::ArrayData, datatypes::DataType};
-
 use super::{Extend, _MutableArrayData};
+use crate::ArrayData;
+use arrow_schema::DataType;
 
 pub(super) fn build_extend(array: &ArrayData) -> Extend {
     let size = match array.data_type() {
         DataType::FixedSizeBinary(i) => *i as usize,
-        DataType::Decimal256(_, _) => 32,
         _ => unreachable!(),
     };
 
     let values = &array.buffers()[0].as_slice()[array.offset() * size..];
-    if array.null_count() == 0 {
-        // fast case where we can copy regions without null issues
-        Box::new(
-            move |mutable: &mut _MutableArrayData, _, start: usize, len: usize| {
-                let buffer = &mut mutable.buffer1;
-                buffer.extend_from_slice(&values[start * size..(start + len) * size]);
-            },
-        )
-    } else {
-        Box::new(
-            move |mutable: &mut _MutableArrayData, _, start: usize, len: usize| {
-                // nulls present: append item by item, ignoring null entries
-                let values_buffer = &mut mutable.buffer1;
-
-                (start..start + len).for_each(|i| {
-                    if array.is_valid(i) {
-                        // append value
-                        let bytes = &values[i * size..(i + 1) * size];
-                        values_buffer.extend_from_slice(bytes);
-                    } else {
-                        values_buffer.extend_zeros(size);
-                    }
-                })
-            },
-        )
-    }
+    Box::new(
+        move |mutable: &mut _MutableArrayData, _, start: usize, len: usize| {
+            let buffer = &mut mutable.buffer1;
+            buffer.extend_from_slice(&values[start * size..(start + len) * size]);
+        },
+    )
 }
 
 pub(super) fn extend_nulls(mutable: &mut _MutableArrayData, len: usize) {
     let size = match mutable.data_type {
         DataType::FixedSizeBinary(i) => i as usize,
-        DataType::Decimal256(_, _) => 32,
         _ => unreachable!(),
     };
 
diff --git a/arrow/src/array/transform/fixed_size_list.rs b/arrow-data/src/transform/fixed_size_list.rs
similarity index 53%
rename from arrow/src/array/transform/fixed_size_list.rs
rename to arrow-data/src/transform/fixed_size_list.rs
index 77912a7026fd..8eef7bce9bb3 100644
--- a/arrow/src/array/transform/fixed_size_list.rs
+++ b/arrow-data/src/transform/fixed_size_list.rs
@@ -15,8 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::ArrayData;
-use crate::datatypes::DataType;
+use crate::ArrayData;
+use arrow_schema::DataType;
 
 use super::{Extend, _MutableArrayData};
 
@@ -26,38 +26,14 @@ pub(super) fn build_extend(array: &ArrayData) -> Extend {
         _ => unreachable!(),
     };
 
-    if array.null_count() == 0 {
-        Box::new(
-            move |mutable: &mut _MutableArrayData,
-                  index: usize,
-                  start: usize,
-                  len: usize| {
-                mutable.child_data.iter_mut().for_each(|child| {
-                    child.extend(index, start * size, (start + len) * size)
-                })
-            },
-        )
-    } else {
-        Box::new(
-            move |mutable: &mut _MutableArrayData,
-                  index: usize,
-                  start: usize,
-                  len: usize| {
-                (start..start + len).for_each(|i| {
-                    if array.is_valid(i) {
-                        mutable.child_data.iter_mut().for_each(|child| {
-                            child.extend(index, i * size, (i + 1) * size)
-                        })
-                    } else {
-                        mutable
-                            .child_data
-                            .iter_mut()
-                            .for_each(|child| child.extend_nulls(size))
-                    }
-                })
-            },
-        )
-    }
+    Box::new(
+        move |mutable: &mut _MutableArrayData, index: usize, start: usize, len: usize| {
+            mutable
+                .child_data
+                .iter_mut()
+                .for_each(|child| child.extend(index, start * size, (start + len) * size))
+        },
+    )
 }
 
 pub(super) fn extend_nulls(mutable: &mut _MutableArrayData, len: usize) {
diff --git a/arrow-data/src/transform/list.rs b/arrow-data/src/transform/list.rs
new file mode 100644
index 000000000000..d9a1c62a8e8e
--- /dev/null
+++ b/arrow-data/src/transform/list.rs
@@ -0,0 +1,54 @@
+// 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.
+
+use super::{
+    Extend, _MutableArrayData,
+    utils::{extend_offsets, get_last_offset},
+};
+use crate::ArrayData;
+use arrow_buffer::ArrowNativeType;
+use num::{CheckedAdd, Integer};
+
+pub(super) fn build_extend<T: ArrowNativeType + Integer + CheckedAdd>(array: &ArrayData) -> Extend {
+    let offsets = array.buffer::<T>(0);
+    Box::new(
+        move |mutable: &mut _MutableArrayData, index: usize, start: usize, len: usize| {
+            let offset_buffer = &mut mutable.buffer1;
+
+            // this is safe due to how offset is built. See details on `get_last_offset`
+            let last_offset: T = unsafe { get_last_offset(offset_buffer) };
+
+            // offsets
+            extend_offsets::<T>(offset_buffer, last_offset, &offsets[start..start + len + 1]);
+
+            mutable.child_data[0].extend(
+                index,
+                offsets[start].as_usize(),
+                offsets[start + len].as_usize(),
+            )
+        },
+    )
+}
+
+pub(super) fn extend_nulls<T: ArrowNativeType>(mutable: &mut _MutableArrayData, len: usize) {
+    let offset_buffer = &mut mutable.buffer1;
+
+    // this is safe due to how offset is built. See details on `get_last_offset`
+    let last_offset: T = unsafe { get_last_offset(offset_buffer) };
+
+    (0..len).for_each(|_| offset_buffer.push(last_offset))
+}
diff --git a/arrow-data/src/transform/mod.rs b/arrow-data/src/transform/mod.rs
new file mode 100644
index 000000000000..268cf10f2326
--- /dev/null
+++ b/arrow-data/src/transform/mod.rs
@@ -0,0 +1,694 @@
+// 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.
+
+use super::{
+    data::{into_buffers, new_buffers},
+    ArrayData, ArrayDataBuilder,
+};
+use crate::bit_mask::set_bits;
+use arrow_buffer::buffer::{BooleanBuffer, NullBuffer};
+use arrow_buffer::{bit_util, i256, ArrowNativeType, MutableBuffer};
+use arrow_schema::{ArrowError, DataType, IntervalUnit, UnionMode};
+use half::f16;
+use num::Integer;
+use std::mem;
+
+mod boolean;
+mod fixed_binary;
+mod fixed_size_list;
+mod list;
+mod null;
+mod primitive;
+mod structure;
+mod union;
+mod utils;
+mod variable_size;
+
+type ExtendNullBits<'a> = Box<dyn Fn(&mut _MutableArrayData, usize, usize) + 'a>;
+// function that extends `[start..start+len]` to the mutable array.
+// this is dynamic because different data_types influence how buffers and children are extended.
+type Extend<'a> = Box<dyn Fn(&mut _MutableArrayData, usize, usize, usize) + 'a>;
+
+type ExtendNulls = Box<dyn Fn(&mut _MutableArrayData, usize)>;
+
+/// A mutable [ArrayData] that knows how to freeze itself into an [ArrayData].
+/// This is just a data container.
+#[derive(Debug)]
+struct _MutableArrayData<'a> {
+    pub data_type: DataType,
+    pub null_count: usize,
+
+    pub len: usize,
+    pub null_buffer: Option<MutableBuffer>,
+
+    // arrow specification only allows up to 3 buffers (2 ignoring the nulls above).
+    // Thus, we place them in the stack to avoid bound checks and greater data locality.
+    pub buffer1: MutableBuffer,
+    pub buffer2: MutableBuffer,
+    pub child_data: Vec<MutableArrayData<'a>>,
+}
+
+impl<'a> _MutableArrayData<'a> {
+    fn null_buffer(&mut self) -> &mut MutableBuffer {
+        self.null_buffer
+            .as_mut()
+            .expect("MutableArrayData not nullable")
+    }
+
+    fn freeze(self, dictionary: Option<ArrayData>) -> ArrayDataBuilder {
+        let buffers = into_buffers(&self.data_type, self.buffer1, self.buffer2);
+
+        let child_data = match self.data_type {
+            DataType::Dictionary(_, _) => vec![dictionary.unwrap()],
+            _ => {
+                let mut child_data = Vec::with_capacity(self.child_data.len());
+                for child in self.child_data {
+                    child_data.push(child.freeze());
+                }
+                child_data
+            }
+        };
+
+        let nulls = self
+            .null_buffer
+            .map(|nulls| {
+                let bools = BooleanBuffer::new(nulls.into(), 0, self.len);
+                unsafe { NullBuffer::new_unchecked(bools, self.null_count) }
+            })
+            .filter(|n| n.null_count() > 0);
+
+        ArrayDataBuilder::new(self.data_type)
+            .offset(0)
+            .len(self.len)
+            .nulls(nulls)
+            .buffers(buffers)
+            .child_data(child_data)
+    }
+}
+
+fn build_extend_null_bits(array: &ArrayData, use_nulls: bool) -> ExtendNullBits {
+    if let Some(nulls) = array.nulls() {
+        let bytes = nulls.validity();
+        Box::new(move |mutable, start, len| {
+            let mutable_len = mutable.len;
+            let out = mutable.null_buffer();
+            utils::resize_for_bits(out, mutable_len + len);
+            mutable.null_count += set_bits(
+                out.as_slice_mut(),
+                bytes,
+                mutable_len,
+                nulls.offset() + start,
+                len,
+            );
+        })
+    } else if use_nulls {
+        Box::new(|mutable, _, len| {
+            let mutable_len = mutable.len;
+            let out = mutable.null_buffer();
+            utils::resize_for_bits(out, mutable_len + len);
+            let write_data = out.as_slice_mut();
+            (0..len).for_each(|i| {
+                bit_util::set_bit(write_data, mutable_len + i);
+            });
+        })
+    } else {
+        Box::new(|_, _, _| {})
+    }
+}
+
+/// Struct to efficiently and interactively create an [ArrayData] from an existing [ArrayData] by
+/// copying chunks.
+///
+/// The main use case of this struct is to perform unary operations to arrays of arbitrary types,
+/// such as `filter` and `take`.
+pub struct MutableArrayData<'a> {
+    #[allow(dead_code)]
+    arrays: Vec<&'a ArrayData>,
+    // The attributes in [_MutableArrayData] cannot be in [MutableArrayData] due to
+    // mutability invariants (interior mutability):
+    // [MutableArrayData] contains a function that can only mutate [_MutableArrayData], not
+    // [MutableArrayData] itself
+    data: _MutableArrayData<'a>,
+
+    // the child data of the `Array` in Dictionary arrays.
+    // This is not stored in `MutableArrayData` because these values constant and only needed
+    // at the end, when freezing [_MutableArrayData].
+    dictionary: Option<ArrayData>,
+
+    // function used to extend values from arrays. This function's lifetime is bound to the array
+    // because it reads values from it.
+    extend_values: Vec<Extend<'a>>,
+    // function used to extend nulls from arrays. This function's lifetime is bound to the array
+    // because it reads nulls from it.
+    extend_null_bits: Vec<ExtendNullBits<'a>>,
+
+    // function used to extend nulls.
+    // this is independent of the arrays and therefore has no lifetime.
+    extend_nulls: ExtendNulls,
+}
+
+impl<'a> std::fmt::Debug for MutableArrayData<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        // ignores the closures.
+        f.debug_struct("MutableArrayData")
+            .field("data", &self.data)
+            .finish()
+    }
+}
+
+/// Builds an extend that adds `offset` to the source primitive
+/// Additionally validates that `max` fits into the
+/// the underlying primitive returning None if not
+fn build_extend_dictionary(array: &ArrayData, offset: usize, max: usize) -> Option<Extend> {
+    macro_rules! validate_and_build {
+        ($dt: ty) => {{
+            let _: $dt = max.try_into().ok()?;
+            let offset: $dt = offset.try_into().ok()?;
+            Some(primitive::build_extend_with_offset(array, offset))
+        }};
+    }
+    match array.data_type() {
+        DataType::Dictionary(child_data_type, _) => match child_data_type.as_ref() {
+            DataType::UInt8 => validate_and_build!(u8),
+            DataType::UInt16 => validate_and_build!(u16),
+            DataType::UInt32 => validate_and_build!(u32),
+            DataType::UInt64 => validate_and_build!(u64),
+            DataType::Int8 => validate_and_build!(i8),
+            DataType::Int16 => validate_and_build!(i16),
+            DataType::Int32 => validate_and_build!(i32),
+            DataType::Int64 => validate_and_build!(i64),
+            _ => unreachable!(),
+        },
+        _ => None,
+    }
+}
+
+fn build_extend(array: &ArrayData) -> Extend {
+    match array.data_type() {
+        DataType::Null => null::build_extend(array),
+        DataType::Boolean => boolean::build_extend(array),
+        DataType::UInt8 => primitive::build_extend::<u8>(array),
+        DataType::UInt16 => primitive::build_extend::<u16>(array),
+        DataType::UInt32 => primitive::build_extend::<u32>(array),
+        DataType::UInt64 => primitive::build_extend::<u64>(array),
+        DataType::Int8 => primitive::build_extend::<i8>(array),
+        DataType::Int16 => primitive::build_extend::<i16>(array),
+        DataType::Int32 => primitive::build_extend::<i32>(array),
+        DataType::Int64 => primitive::build_extend::<i64>(array),
+        DataType::Float32 => primitive::build_extend::<f32>(array),
+        DataType::Float64 => primitive::build_extend::<f64>(array),
+        DataType::Date32 | DataType::Time32(_) | DataType::Interval(IntervalUnit::YearMonth) => {
+            primitive::build_extend::<i32>(array)
+        }
+        DataType::Date64
+        | DataType::Time64(_)
+        | DataType::Timestamp(_, _)
+        | DataType::Duration(_)
+        | DataType::Interval(IntervalUnit::DayTime) => primitive::build_extend::<i64>(array),
+        DataType::Interval(IntervalUnit::MonthDayNano) => primitive::build_extend::<i128>(array),
+        DataType::Decimal128(_, _) => primitive::build_extend::<i128>(array),
+        DataType::Decimal256(_, _) => primitive::build_extend::<i256>(array),
+        DataType::Utf8 | DataType::Binary => variable_size::build_extend::<i32>(array),
+        DataType::LargeUtf8 | DataType::LargeBinary => variable_size::build_extend::<i64>(array),
+        DataType::Map(_, _) | DataType::List(_) => list::build_extend::<i32>(array),
+        DataType::LargeList(_) => list::build_extend::<i64>(array),
+        DataType::Dictionary(_, _) => unreachable!("should use build_extend_dictionary"),
+        DataType::Struct(_) => structure::build_extend(array),
+        DataType::FixedSizeBinary(_) => fixed_binary::build_extend(array),
+        DataType::Float16 => primitive::build_extend::<f16>(array),
+        DataType::FixedSizeList(_, _) => fixed_size_list::build_extend(array),
+        DataType::Union(_, mode) => match mode {
+            UnionMode::Sparse => union::build_extend_sparse(array),
+            UnionMode::Dense => union::build_extend_dense(array),
+        },
+        DataType::RunEndEncoded(_, _) => todo!(),
+    }
+}
+
+fn build_extend_nulls(data_type: &DataType) -> ExtendNulls {
+    Box::new(match data_type {
+        DataType::Null => null::extend_nulls,
+        DataType::Boolean => boolean::extend_nulls,
+        DataType::UInt8 => primitive::extend_nulls::<u8>,
+        DataType::UInt16 => primitive::extend_nulls::<u16>,
+        DataType::UInt32 => primitive::extend_nulls::<u32>,
+        DataType::UInt64 => primitive::extend_nulls::<u64>,
+        DataType::Int8 => primitive::extend_nulls::<i8>,
+        DataType::Int16 => primitive::extend_nulls::<i16>,
+        DataType::Int32 => primitive::extend_nulls::<i32>,
+        DataType::Int64 => primitive::extend_nulls::<i64>,
+        DataType::Float32 => primitive::extend_nulls::<f32>,
+        DataType::Float64 => primitive::extend_nulls::<f64>,
+        DataType::Date32 | DataType::Time32(_) | DataType::Interval(IntervalUnit::YearMonth) => {
+            primitive::extend_nulls::<i32>
+        }
+        DataType::Date64
+        | DataType::Time64(_)
+        | DataType::Timestamp(_, _)
+        | DataType::Duration(_)
+        | DataType::Interval(IntervalUnit::DayTime) => primitive::extend_nulls::<i64>,
+        DataType::Interval(IntervalUnit::MonthDayNano) => primitive::extend_nulls::<i128>,
+        DataType::Decimal128(_, _) => primitive::extend_nulls::<i128>,
+        DataType::Decimal256(_, _) => primitive::extend_nulls::<i256>,
+        DataType::Utf8 | DataType::Binary => variable_size::extend_nulls::<i32>,
+        DataType::LargeUtf8 | DataType::LargeBinary => variable_size::extend_nulls::<i64>,
+        DataType::Map(_, _) | DataType::List(_) => list::extend_nulls::<i32>,
+        DataType::LargeList(_) => list::extend_nulls::<i64>,
+        DataType::Dictionary(child_data_type, _) => match child_data_type.as_ref() {
+            DataType::UInt8 => primitive::extend_nulls::<u8>,
+            DataType::UInt16 => primitive::extend_nulls::<u16>,
+            DataType::UInt32 => primitive::extend_nulls::<u32>,
+            DataType::UInt64 => primitive::extend_nulls::<u64>,
+            DataType::Int8 => primitive::extend_nulls::<i8>,
+            DataType::Int16 => primitive::extend_nulls::<i16>,
+            DataType::Int32 => primitive::extend_nulls::<i32>,
+            DataType::Int64 => primitive::extend_nulls::<i64>,
+            _ => unreachable!(),
+        },
+        DataType::Struct(_) => structure::extend_nulls,
+        DataType::FixedSizeBinary(_) => fixed_binary::extend_nulls,
+        DataType::Float16 => primitive::extend_nulls::<f16>,
+        DataType::FixedSizeList(_, _) => fixed_size_list::extend_nulls,
+        DataType::Union(_, mode) => match mode {
+            UnionMode::Sparse => union::extend_nulls_sparse,
+            UnionMode::Dense => union::extend_nulls_dense,
+        },
+        DataType::RunEndEncoded(_, _) => todo!(),
+    })
+}
+
+fn preallocate_offset_and_binary_buffer<Offset: ArrowNativeType + Integer>(
+    capacity: usize,
+    binary_size: usize,
+) -> [MutableBuffer; 2] {
+    // offsets
+    let mut buffer = MutableBuffer::new((1 + capacity) * mem::size_of::<Offset>());
+    // safety: `unsafe` code assumes that this buffer is initialized with one element
+    buffer.push(Offset::zero());
+
+    [
+        buffer,
+        MutableBuffer::new(binary_size * mem::size_of::<u8>()),
+    ]
+}
+
+/// Define capacities of child data or data buffers.
+#[derive(Debug, Clone)]
+pub enum Capacities {
+    /// Binary, Utf8 and LargeUtf8 data types
+    /// Define
+    /// * the capacity of the array offsets
+    /// * the capacity of the binary/ str buffer
+    Binary(usize, Option<usize>),
+    /// List and LargeList data types
+    /// Define
+    /// * the capacity of the array offsets
+    /// * the capacity of the child data
+    List(usize, Option<Box<Capacities>>),
+    /// Struct type
+    /// * the capacity of the array
+    /// * the capacities of the fields
+    Struct(usize, Option<Vec<Capacities>>),
+    /// Dictionary type
+    /// * the capacity of the array/keys
+    /// * the capacity of the values
+    Dictionary(usize, Option<Box<Capacities>>),
+    /// Don't preallocate inner buffers and rely on array growth strategy
+    Array(usize),
+}
+impl<'a> MutableArrayData<'a> {
+    /// returns a new [MutableArrayData] with capacity to `capacity` slots and specialized to create an
+    /// [ArrayData] from multiple `arrays`.
+    ///
+    /// `use_nulls` is a flag used to optimize insertions. It should be `false` if the only source of nulls
+    /// are the arrays themselves and `true` if the user plans to call [MutableArrayData::extend_nulls].
+    /// In other words, if `use_nulls` is `false`, calling [MutableArrayData::extend_nulls] should not be used.
+    pub fn new(arrays: Vec<&'a ArrayData>, use_nulls: bool, capacity: usize) -> Self {
+        Self::with_capacities(arrays, use_nulls, Capacities::Array(capacity))
+    }
+
+    /// Similar to [MutableArrayData::new], but lets users define the preallocated capacities of the array.
+    /// See also [MutableArrayData::new] for more information on the arguments.
+    ///
+    /// # Panic
+    /// This function panics if the given `capacities` don't match the data type of `arrays`. Or when
+    /// a [Capacities] variant is not yet supported.
+    pub fn with_capacities(
+        arrays: Vec<&'a ArrayData>,
+        use_nulls: bool,
+        capacities: Capacities,
+    ) -> Self {
+        let data_type = arrays[0].data_type();
+
+        for a in arrays.iter().skip(1) {
+            assert_eq!(
+                data_type,
+                a.data_type(),
+                "Arrays with inconsistent types passed to MutableArrayData"
+            )
+        }
+
+        // if any of the arrays has nulls, insertions from any array requires setting bits
+        // as there is at least one array with nulls.
+        let use_nulls = use_nulls | arrays.iter().any(|array| array.null_count() > 0);
+
+        let mut array_capacity;
+
+        let [buffer1, buffer2] = match (data_type, &capacities) {
+            (
+                DataType::LargeUtf8 | DataType::LargeBinary,
+                Capacities::Binary(capacity, Some(value_cap)),
+            ) => {
+                array_capacity = *capacity;
+                preallocate_offset_and_binary_buffer::<i64>(*capacity, *value_cap)
+            }
+            (DataType::Utf8 | DataType::Binary, Capacities::Binary(capacity, Some(value_cap))) => {
+                array_capacity = *capacity;
+                preallocate_offset_and_binary_buffer::<i32>(*capacity, *value_cap)
+            }
+            (_, Capacities::Array(capacity)) => {
+                array_capacity = *capacity;
+                new_buffers(data_type, *capacity)
+            }
+            (DataType::List(_) | DataType::LargeList(_), Capacities::List(capacity, _)) => {
+                array_capacity = *capacity;
+                new_buffers(data_type, *capacity)
+            }
+            _ => panic!("Capacities: {capacities:?} not yet supported"),
+        };
+
+        let child_data = match &data_type {
+            DataType::Decimal128(_, _)
+            | DataType::Decimal256(_, _)
+            | DataType::Null
+            | DataType::Boolean
+            | DataType::UInt8
+            | DataType::UInt16
+            | DataType::UInt32
+            | DataType::UInt64
+            | DataType::Int8
+            | DataType::Int16
+            | DataType::Int32
+            | DataType::Int64
+            | DataType::Float16
+            | DataType::Float32
+            | DataType::Float64
+            | DataType::Date32
+            | DataType::Date64
+            | DataType::Time32(_)
+            | DataType::Time64(_)
+            | DataType::Duration(_)
+            | DataType::Timestamp(_, _)
+            | DataType::Utf8
+            | DataType::Binary
+            | DataType::LargeUtf8
+            | DataType::LargeBinary
+            | DataType::Interval(_)
+            | DataType::FixedSizeBinary(_) => vec![],
+            DataType::Map(_, _) | DataType::List(_) | DataType::LargeList(_) => {
+                let children = arrays
+                    .iter()
+                    .map(|array| &array.child_data()[0])
+                    .collect::<Vec<_>>();
+
+                let capacities =
+                    if let Capacities::List(capacity, ref child_capacities) = capacities {
+                        child_capacities
+                            .clone()
+                            .map(|c| *c)
+                            .unwrap_or(Capacities::Array(capacity))
+                    } else {
+                        Capacities::Array(array_capacity)
+                    };
+
+                vec![MutableArrayData::with_capacities(
+                    children, use_nulls, capacities,
+                )]
+            }
+            // the dictionary type just appends keys and clones the values.
+            DataType::Dictionary(_, _) => vec![],
+            DataType::Struct(fields) => match capacities {
+                Capacities::Struct(capacity, Some(ref child_capacities)) => {
+                    array_capacity = capacity;
+                    (0..fields.len())
+                        .zip(child_capacities)
+                        .map(|(i, child_cap)| {
+                            let child_arrays = arrays
+                                .iter()
+                                .map(|array| &array.child_data()[i])
+                                .collect::<Vec<_>>();
+                            MutableArrayData::with_capacities(
+                                child_arrays,
+                                use_nulls,
+                                child_cap.clone(),
+                            )
+                        })
+                        .collect::<Vec<_>>()
+                }
+                Capacities::Struct(capacity, None) => {
+                    array_capacity = capacity;
+                    (0..fields.len())
+                        .map(|i| {
+                            let child_arrays = arrays
+                                .iter()
+                                .map(|array| &array.child_data()[i])
+                                .collect::<Vec<_>>();
+                            MutableArrayData::new(child_arrays, use_nulls, capacity)
+                        })
+                        .collect::<Vec<_>>()
+                }
+                _ => (0..fields.len())
+                    .map(|i| {
+                        let child_arrays = arrays
+                            .iter()
+                            .map(|array| &array.child_data()[i])
+                            .collect::<Vec<_>>();
+                        MutableArrayData::new(child_arrays, use_nulls, array_capacity)
+                    })
+                    .collect::<Vec<_>>(),
+            },
+            DataType::RunEndEncoded(_, _) => {
+                let run_ends_child = arrays
+                    .iter()
+                    .map(|array| &array.child_data()[0])
+                    .collect::<Vec<_>>();
+                let value_child = arrays
+                    .iter()
+                    .map(|array| &array.child_data()[1])
+                    .collect::<Vec<_>>();
+                vec![
+                    MutableArrayData::new(run_ends_child, false, array_capacity),
+                    MutableArrayData::new(value_child, use_nulls, array_capacity),
+                ]
+            }
+            DataType::FixedSizeList(_, _) => {
+                let children = arrays
+                    .iter()
+                    .map(|array| &array.child_data()[0])
+                    .collect::<Vec<_>>();
+                vec![MutableArrayData::new(children, use_nulls, array_capacity)]
+            }
+            DataType::Union(fields, _) => (0..fields.len())
+                .map(|i| {
+                    let child_arrays = arrays
+                        .iter()
+                        .map(|array| &array.child_data()[i])
+                        .collect::<Vec<_>>();
+                    MutableArrayData::new(child_arrays, use_nulls, array_capacity)
+                })
+                .collect::<Vec<_>>(),
+        };
+
+        // Get the dictionary if any, and if it is a concatenation of multiple
+        let (dictionary, dict_concat) = match &data_type {
+            DataType::Dictionary(_, _) => {
+                // If more than one dictionary, concatenate dictionaries together
+                let dict_concat = !arrays
+                    .windows(2)
+                    .all(|a| a[0].child_data()[0].ptr_eq(&a[1].child_data()[0]));
+
+                match dict_concat {
+                    false => (Some(arrays[0].child_data()[0].clone()), false),
+                    true => {
+                        if let Capacities::Dictionary(_, _) = capacities {
+                            panic!("dictionary capacity not yet supported")
+                        }
+                        let dictionaries: Vec<_> =
+                            arrays.iter().map(|array| &array.child_data()[0]).collect();
+                        let lengths: Vec<_> = dictionaries
+                            .iter()
+                            .map(|dictionary| dictionary.len())
+                            .collect();
+                        let capacity = lengths.iter().sum();
+
+                        let mut mutable = MutableArrayData::new(dictionaries, false, capacity);
+
+                        for (i, len) in lengths.iter().enumerate() {
+                            mutable.extend(i, 0, *len)
+                        }
+
+                        (Some(mutable.freeze()), true)
+                    }
+                }
+            }
+            _ => (None, false),
+        };
+
+        let extend_nulls = build_extend_nulls(data_type);
+
+        let extend_null_bits = arrays
+            .iter()
+            .map(|array| build_extend_null_bits(array, use_nulls))
+            .collect();
+
+        let null_buffer = use_nulls.then(|| {
+            let null_bytes = bit_util::ceil(array_capacity, 8);
+            MutableBuffer::from_len_zeroed(null_bytes)
+        });
+
+        let extend_values = match &data_type {
+            DataType::Dictionary(_, _) => {
+                let mut next_offset = 0;
+                let extend_values: Result<Vec<_>, _> = arrays
+                    .iter()
+                    .map(|array| {
+                        let offset = next_offset;
+                        let dict_len = array.child_data()[0].len();
+
+                        if dict_concat {
+                            next_offset += dict_len;
+                        }
+
+                        build_extend_dictionary(array, offset, offset + dict_len)
+                            .ok_or(ArrowError::DictionaryKeyOverflowError)
+                    })
+                    .collect();
+
+                extend_values.expect("MutableArrayData::new is infallible")
+            }
+            _ => arrays.iter().map(|array| build_extend(array)).collect(),
+        };
+
+        let data = _MutableArrayData {
+            data_type: data_type.clone(),
+            len: 0,
+            null_count: 0,
+            null_buffer,
+            buffer1,
+            buffer2,
+            child_data,
+        };
+        Self {
+            arrays,
+            data,
+            dictionary,
+            extend_values,
+            extend_null_bits,
+            extend_nulls,
+        }
+    }
+
+    /// Extends this array with a chunk of its source arrays
+    ///
+    /// # Arguments
+    /// * `index` - the index of array that you what to copy values from
+    /// * `start` - the start index of the chunk (inclusive)
+    /// * `end` - the end index of the chunk (exclusive)
+    ///
+    /// # Panic
+    /// This function panics if there is an invalid index,
+    /// i.e. `index` >= the number of source arrays
+    /// or `end` > the length of the `index`th array
+    pub fn extend(&mut self, index: usize, start: usize, end: usize) {
+        let len = end - start;
+        (self.extend_null_bits[index])(&mut self.data, start, len);
+        (self.extend_values[index])(&mut self.data, index, start, len);
+        self.data.len += len;
+    }
+
+    /// Extends this [MutableArrayData] with null elements, disregarding the bound arrays
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`MutableArrayData`] not created with `use_nulls` or nullable source arrays
+    ///
+    pub fn extend_nulls(&mut self, len: usize) {
+        self.data.len += len;
+        let bit_len = bit_util::ceil(self.data.len, 8);
+        let nulls = self.data.null_buffer();
+        nulls.resize(bit_len, 0);
+        self.data.null_count += len;
+        (self.extend_nulls)(&mut self.data, len);
+    }
+
+    /// Returns the current length
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.data.len
+    }
+
+    /// Returns true if len is 0
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.data.len == 0
+    }
+
+    /// Returns the current null count
+    #[inline]
+    pub fn null_count(&self) -> usize {
+        self.data.null_count
+    }
+
+    /// Creates a [ArrayData] from the pushed regions up to this point, consuming `self`.
+    pub fn freeze(self) -> ArrayData {
+        unsafe { self.data.freeze(self.dictionary).build_unchecked() }
+    }
+
+    /// Creates a [ArrayDataBuilder] from the pushed regions up to this point, consuming `self`.
+    /// This is useful for extending the default behavior of MutableArrayData.
+    pub fn into_builder(self) -> ArrayDataBuilder {
+        self.data.freeze(self.dictionary)
+    }
+}
+
+// See arrow/tests/array_transform.rs for tests of transform functionality
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use arrow_schema::Field;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_list_append_with_capacities() {
+        let array = ArrayData::new_empty(&DataType::List(Arc::new(Field::new(
+            "element",
+            DataType::Int64,
+            false,
+        ))));
+
+        let mutable = MutableArrayData::with_capacities(
+            vec![&array],
+            false,
+            Capacities::List(6, Some(Box::new(Capacities::Array(17)))),
+        );
+
+        // capacities are rounded up to multiples of 64 by MutableBuffer
+        assert_eq!(mutable.data.buffer1.capacity(), 64);
+        assert_eq!(mutable.data.child_data[0].data.buffer1.capacity(), 192);
+    }
+}
diff --git a/arrow/src/array/transform/null.rs b/arrow-data/src/transform/null.rs
similarity index 97%
rename from arrow/src/array/transform/null.rs
rename to arrow-data/src/transform/null.rs
index e1335e179713..5d1535564d9e 100644
--- a/arrow/src/array/transform/null.rs
+++ b/arrow-data/src/transform/null.rs
@@ -15,9 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::ArrayData;
-
 use super::{Extend, _MutableArrayData};
+use crate::ArrayData;
 
 pub(super) fn build_extend(_: &ArrayData) -> Extend {
     Box::new(move |_, _, _, _| {})
diff --git a/arrow/src/array/transform/primitive.rs b/arrow-data/src/transform/primitive.rs
similarity index 91%
rename from arrow/src/array/transform/primitive.rs
rename to arrow-data/src/transform/primitive.rs
index 4c765c0c0d95..627dc00de1df 100644
--- a/arrow/src/array/transform/primitive.rs
+++ b/arrow-data/src/transform/primitive.rs
@@ -15,11 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use crate::ArrayData;
+use arrow_buffer::ArrowNativeType;
 use std::mem::size_of;
 use std::ops::Add;
 
-use crate::{array::ArrayData, datatypes::ArrowNativeType};
-
 use super::{Extend, _MutableArrayData};
 
 pub(super) fn build_extend<T: ArrowNativeType>(array: &ArrayData) -> Extend {
@@ -47,9 +47,6 @@ where
     )
 }
 
-pub(super) fn extend_nulls<T: ArrowNativeType>(
-    mutable: &mut _MutableArrayData,
-    len: usize,
-) {
+pub(super) fn extend_nulls<T: ArrowNativeType>(mutable: &mut _MutableArrayData, len: usize) {
     mutable.buffer1.extend_zeros(len * size_of::<T>());
 }
diff --git a/arrow-data/src/transform/structure.rs b/arrow-data/src/transform/structure.rs
new file mode 100644
index 000000000000..7330dcaa3705
--- /dev/null
+++ b/arrow-data/src/transform/structure.rs
@@ -0,0 +1,37 @@
+// 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.
+
+use super::{Extend, _MutableArrayData};
+use crate::ArrayData;
+
+pub(super) fn build_extend(_: &ArrayData) -> Extend {
+    Box::new(
+        move |mutable: &mut _MutableArrayData, index: usize, start: usize, len: usize| {
+            mutable
+                .child_data
+                .iter_mut()
+                .for_each(|child| child.extend(index, start, start + len))
+        },
+    )
+}
+
+pub(super) fn extend_nulls(mutable: &mut _MutableArrayData, len: usize) {
+    mutable
+        .child_data
+        .iter_mut()
+        .for_each(|child| child.extend_nulls(len))
+}
diff --git a/arrow/src/array/transform/union.rs b/arrow-data/src/transform/union.rs
similarity index 82%
rename from arrow/src/array/transform/union.rs
rename to arrow-data/src/transform/union.rs
index bbea508219d0..d7083588d782 100644
--- a/arrow/src/array/transform/union.rs
+++ b/arrow-data/src/transform/union.rs
@@ -15,9 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::ArrayData;
-
 use super::{Extend, _MutableArrayData};
+use crate::ArrayData;
 
 pub(super) fn build_extend_sparse(array: &ArrayData) -> Extend {
     let type_ids = array.buffer::<i8>(0);
@@ -40,6 +39,9 @@ pub(super) fn build_extend_sparse(array: &ArrayData) -> Extend {
 pub(super) fn build_extend_dense(array: &ArrayData) -> Extend {
     let type_ids = array.buffer::<i8>(0);
     let offsets = array.buffer::<i32>(1);
+    let arrow_schema::DataType::Union(src_fields, _) = array.data_type() else {
+        unreachable!();
+    };
 
     Box::new(
         move |mutable: &mut _MutableArrayData, index: usize, start: usize, len: usize| {
@@ -49,14 +51,18 @@ pub(super) fn build_extend_dense(array: &ArrayData) -> Extend {
                 .extend_from_slice(&type_ids[start..start + len]);
 
             (start..start + len).for_each(|i| {
-                let type_id = type_ids[i] as usize;
+                let type_id = type_ids[i];
+                let child_index = src_fields
+                    .iter()
+                    .position(|(r, _)| r == type_id)
+                    .expect("invalid union type ID");
                 let src_offset = offsets[i] as usize;
-                let child_data = &mut mutable.child_data[type_id];
+                let child_data = &mut mutable.child_data[child_index];
                 let dst_offset = child_data.len();
 
                 // Extend offsets
                 mutable.buffer2.push(dst_offset as i32);
-                mutable.child_data[type_id].extend(index, src_offset, src_offset + 1)
+                mutable.child_data[child_index].extend(index, src_offset, src_offset + 1)
             })
         },
     )
diff --git a/arrow/src/array/transform/utils.rs b/arrow-data/src/transform/utils.rs
similarity index 66%
rename from arrow/src/array/transform/utils.rs
rename to arrow-data/src/transform/utils.rs
index 68aee79c41bb..5407f68e0d0c 100644
--- a/arrow/src/array/transform/utils.rs
+++ b/arrow-data/src/transform/utils.rs
@@ -15,7 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{array::OffsetSizeTrait, buffer::MutableBuffer, util::bit_util};
+use arrow_buffer::{bit_util, ArrowNativeType, MutableBuffer};
+use num::{CheckedAdd, Integer};
 
 /// extends the `buffer` to be able to hold `len` bits, setting all bits of the new size to zero.
 #[inline]
@@ -26,24 +27,25 @@ pub(super) fn resize_for_bits(buffer: &mut MutableBuffer, len: usize) {
     }
 }
 
-pub(super) fn extend_offsets<T: OffsetSizeTrait>(
+pub(super) fn extend_offsets<T: ArrowNativeType + Integer + CheckedAdd>(
     buffer: &mut MutableBuffer,
     mut last_offset: T,
     offsets: &[T],
 ) {
-    buffer.reserve(offsets.len() * std::mem::size_of::<T>());
+    buffer.reserve(std::mem::size_of_val(offsets));
     offsets.windows(2).for_each(|offsets| {
         // compute the new offset
         let length = offsets[1] - offsets[0];
-        last_offset += length;
+        // if you hit this appending to a StringArray / BinaryArray it is because you
+        // are trying to add more data than can fit into that type. Try breaking your data into
+        // smaller batches or using LargeStringArray / LargeBinaryArray
+        last_offset = last_offset.checked_add(&length).expect("offset overflow");
         buffer.push(last_offset);
     });
 }
 
 #[inline]
-pub(super) unsafe fn get_last_offset<T: OffsetSizeTrait>(
-    offset_buffer: &MutableBuffer,
-) -> T {
+pub(super) unsafe fn get_last_offset<T: ArrowNativeType>(offset_buffer: &MutableBuffer) -> T {
     // JUSTIFICATION
     //  Benefit
     //      20% performance improvement extend of variable sized arrays (see bench `mutable_array`)
@@ -54,3 +56,16 @@ pub(super) unsafe fn get_last_offset<T: OffsetSizeTrait>(
     debug_assert!(prefix.is_empty() && suffix.is_empty());
     *offsets.get_unchecked(offsets.len() - 1)
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::transform::utils::extend_offsets;
+    use arrow_buffer::MutableBuffer;
+
+    #[test]
+    #[should_panic(expected = "offset overflow")]
+    fn test_overflow() {
+        let mut buffer = MutableBuffer::new(10);
+        extend_offsets(&mut buffer, i32::MAX - 4, &[0, 5]);
+    }
+}
diff --git a/arrow-data/src/transform/variable_size.rs b/arrow-data/src/transform/variable_size.rs
new file mode 100644
index 000000000000..fa1592d973ed
--- /dev/null
+++ b/arrow-data/src/transform/variable_size.rs
@@ -0,0 +1,69 @@
+// 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.
+
+use crate::ArrayData;
+use arrow_buffer::{ArrowNativeType, MutableBuffer};
+use num::traits::AsPrimitive;
+use num::{CheckedAdd, Integer};
+
+use super::{
+    Extend, _MutableArrayData,
+    utils::{extend_offsets, get_last_offset},
+};
+
+#[inline]
+fn extend_offset_values<T: ArrowNativeType + AsPrimitive<usize>>(
+    buffer: &mut MutableBuffer,
+    offsets: &[T],
+    values: &[u8],
+    start: usize,
+    len: usize,
+) {
+    let start_values = offsets[start].as_();
+    let end_values = offsets[start + len].as_();
+    let new_values = &values[start_values..end_values];
+    buffer.extend_from_slice(new_values);
+}
+
+pub(super) fn build_extend<T: ArrowNativeType + Integer + CheckedAdd + AsPrimitive<usize>>(
+    array: &ArrayData,
+) -> Extend {
+    let offsets = array.buffer::<T>(0);
+    let values = array.buffers()[1].as_slice();
+    Box::new(
+        move |mutable: &mut _MutableArrayData, _, start: usize, len: usize| {
+            let offset_buffer = &mut mutable.buffer1;
+            let values_buffer = &mut mutable.buffer2;
+
+            // this is safe due to how offset is built. See details on `get_last_offset`
+            let last_offset = unsafe { get_last_offset(offset_buffer) };
+
+            extend_offsets::<T>(offset_buffer, last_offset, &offsets[start..start + len + 1]);
+            // values
+            extend_offset_values::<T>(values_buffer, offsets, values, start, len);
+        },
+    )
+}
+
+pub(super) fn extend_nulls<T: ArrowNativeType>(mutable: &mut _MutableArrayData, len: usize) {
+    let offset_buffer = &mut mutable.buffer1;
+
+    // this is safe due to how offset is built. See details on `get_last_offset`
+    let last_offset: T = unsafe { get_last_offset(offset_buffer) };
+
+    (0..len).for_each(|_| offset_buffer.push(last_offset))
+}
diff --git a/arrow-flight/CONTRIBUTING.md b/arrow-flight/CONTRIBUTING.md
new file mode 100644
index 000000000000..156a0b9caaed
--- /dev/null
+++ b/arrow-flight/CONTRIBUTING.md
@@ -0,0 +1,41 @@
+<!---
+  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.
+-->
+
+# Flight
+
+## Generated Code
+
+The prost/tonic code can be generated by running, which in turn invokes the Rust binary located in [gen](./gen)
+
+This is necessary after modifying the protobuf definitions or altering the dependencies of [gen](./gen), and requires a
+valid installation of [protoc](https://github.com/protocolbuffers/protobuf#protocol-compiler-installation).
+
+```bash
+./regen.sh
+```
+
+### Why Vendor
+
+The standard approach to integrating `prost-build` / `tonic-build` is to use a `build.rs` script that automatically generates the code as part of the standard build process.
+
+Unfortunately this caused a lot of friction for users:
+
+- Requires all users to have a protoc install in order to compile the crate - [#2616](https://github.com/apache/arrow-rs/issues/2616)
+- Some distributions have very old versions of protoc that don't support required functionality - [#1574](https://github.com/apache/arrow-rs/issues/1574)
+- Inconsistent support within IDEs for code completion of automatically generated code
diff --git a/arrow-flight/Cargo.toml b/arrow-flight/Cargo.toml
index 92c6aac3d082..1e7255baa748 100644
--- a/arrow-flight/Cargo.toml
+++ b/arrow-flight/Cargo.toml
@@ -18,37 +18,74 @@
 [package]
 name = "arrow-flight"
 description = "Apache Arrow Flight"
-version = "20.0.0"
-edition = "2021"
-rust-version = "1.62"
-authors = ["Apache Arrow <dev@arrow.apache.org>"]
-homepage = "https://github.com/apache/arrow-rs"
-repository = "https://github.com/apache/arrow-rs"
-license = "Apache-2.0"
+version = { workspace = true }
+edition = { workspace = true }
+rust-version = "1.70.0"
+authors = { workspace = true }
+homepage = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
 
 [dependencies]
-arrow = { path = "../arrow", version = "20.0.0", default-features = false, features = ["ipc"] }
-base64 = { version = "0.13", default-features = false }
-tonic = { version = "0.8", default-features = false, features = ["transport", "codegen", "prost"] }
+arrow-arith = { workspace = true, optional = true }
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+# Cast is needed to work around https://github.com/apache/arrow-rs/issues/3389
+arrow-cast = { workspace = true }
+arrow-data = { workspace = true, optional = true }
+arrow-ipc = { workspace = true }
+arrow-ord = { workspace = true, optional = true }
+arrow-row = { workspace = true, optional = true }
+arrow-select = { workspace = true, optional = true }
+arrow-schema = { workspace = true }
+arrow-string = { workspace = true, optional = true }
+base64 = { version = "0.21", default-features = false, features = ["std"] }
 bytes = { version = "1", default-features = false }
-prost = { version = "0.11", default-features = false }
-prost-types = { version = "0.11.0", default-features = false, optional = true }
-prost-derive = { version = "0.11", default-features = false }
+futures = { version = "0.3", default-features = false, features = ["alloc"] }
+once_cell = { version = "1", optional = true }
+paste = { version = "1.0" }
+prost = { version = "0.12.3", default-features = false, features = ["prost-derive"] }
+# For Timestamp type
+prost-types = { version = "0.12.3", default-features = false }
 tokio = { version = "1.0", default-features = false, features = ["macros", "rt", "rt-multi-thread"] }
-futures = { version = "0.3", default-features = false, features = ["alloc"]}
+tonic = { version = "0.11.0", default-features = false, features = ["transport", "codegen", "prost"] }
+
+# CLI-related dependencies
+anyhow = { version = "1.0", optional = true }
+clap = { version = "4.4.6", default-features = false, features = ["std", "derive", "env", "help", "error-context", "usage", "wrap_help", "color", "suggestions"], optional = true }
+tracing-log = { version = "0.2", optional = true }
+tracing-subscriber = { version = "0.3.1", default-features = false, features = ["ansi", "env-filter", "fmt"], optional = true }
+
+[package.metadata.docs.rs]
+all-features = true
 
 [features]
 default = []
-flight-sql-experimental = ["prost-types"]
+flight-sql-experimental = ["arrow-arith", "arrow-data", "arrow-ord", "arrow-row", "arrow-select", "arrow-string", "once_cell"]
+tls = ["tonic/tls"]
 
-[dev-dependencies]
+# Enable CLI tools
+cli = ["anyhow", "arrow-cast/prettyprint", "clap", "tracing-log", "tracing-subscriber", "tonic/tls-webpki-roots"]
 
-[build-dependencies]
-tonic-build = { version = "0.8", default-features = false, features = ["transport", "prost"] }
-# Pin specific version of the tonic-build dependencies to avoid auto-generated
-# (and checked in) arrow.flight.protocol.rs from changing
-proc-macro2 = { version = ">1.0.30", default-features = false }
+[dev-dependencies]
+arrow-cast = { workspace = true, features = ["prettyprint"] }
+assert_cmd = "2.0.8"
+http = "0.2.9"
+http-body = "0.4.5"
+pin-project-lite = "0.2"
+tempfile = "3.3"
+tokio-stream = { version = "0.1", features = ["net"] }
+tower = "0.4.13"
 
 [[example]]
 name = "flight_sql_server"
-required-features = ["flight-sql-experimental"]
+required-features = ["flight-sql-experimental", "tls"]
+
+[[bin]]
+name = "flight_sql_client"
+required-features = ["cli", "flight-sql-experimental", "tls"]
+
+[[test]]
+name = "flight_sql_client_cli"
+path = "tests/flight_sql_client_cli.rs"
+required-features = ["cli", "flight-sql-experimental", "tls"]
diff --git a/arrow-flight/README.md b/arrow-flight/README.md
index db9b75377d29..b80772ac927e 100644
--- a/arrow-flight/README.md
+++ b/arrow-flight/README.md
@@ -21,15 +21,56 @@
 
 [![Crates.io](https://img.shields.io/crates/v/arrow-flight.svg)](https://crates.io/crates/arrow-flight)
 
+See the [API documentation](https://docs.rs/arrow_flight/latest) for examples and the full API.
+
+The API documentation for most recent, unreleased code is available [here](https://arrow.apache.org/rust/arrow_flight/index.html).
+
 ## Usage
 
 Add this to your Cargo.toml:
 
 ```toml
 [dependencies]
-arrow-flight = "20.0.0"
+arrow-flight = "39.0.0"
 ```
 
 Apache Arrow Flight is a gRPC based protocol for exchanging Arrow data between processes. See the blog post [Introducing Apache Arrow Flight: A Framework for Fast Data Transport](https://arrow.apache.org/blog/2019/10/13/introducing-arrow-flight/) for more information.
 
-This crate provides a Rust implementation of the [Flight.proto](../../format/Flight.proto) gRPC protocol and provides an example that demonstrates how to build a Flight server implemented with Tonic.
+This crate provides a Rust implementation of the
+[Flight.proto](../format/Flight.proto) gRPC protocol and
+[examples](https://github.com/apache/arrow-rs/tree/master/arrow-flight/examples)
+that demonstrate how to build a Flight server implemented with [tonic](https://docs.rs/crate/tonic/latest).
+
+## Feature Flags
+
+- `flight-sql-experimental`: Enables experimental support for
+  [Apache Arrow FlightSQL], a protocol for interacting with SQL databases.
+
+## CLI
+
+This crates offers a basic [Apache Arrow FlightSQL] command line interface.
+
+The client can be installed from the repository:
+
+```console
+$ cargo install --features=cli,flight-sql-experimental,tls --bin=flight_sql_client --path=. --locked
+```
+
+The client comes with extensive help text:
+
+```console
+$ flight_sql_client help
+```
+
+A query can be executed using:
+
+```console
+$ flight_sql_client --host example.com statement-query "SELECT 1;"
++----------+
+| Int64(1) |
++----------+
+| 1        |
++----------+
+```
+
+[apache arrow flightsql]: https://arrow.apache.org/docs/format/FlightSql.html
diff --git a/arrow-flight/build.rs b/arrow-flight/build.rs
deleted file mode 100644
index 25f034ac191b..000000000000
--- a/arrow-flight/build.rs
+++ /dev/null
@@ -1,100 +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.
-
-use std::{
-    env,
-    fs::OpenOptions,
-    io::{Read, Write},
-    path::Path,
-};
-
-fn main() -> Result<(), Box<dyn std::error::Error>> {
-    // override the build location, in order to check in the changes to proto files
-    env::set_var("OUT_DIR", "src");
-
-    // The current working directory can vary depending on how the project is being
-    // built or released so we build an absolute path to the proto file
-    let path = Path::new("../format/Flight.proto");
-    if path.exists() {
-        // avoid rerunning build if the file has not changed
-        println!("cargo:rerun-if-changed=../format/Flight.proto");
-
-        let proto_dir = Path::new("../format");
-        let proto_path = Path::new("../format/Flight.proto");
-
-        tonic_build::configure()
-            // protoc in unbuntu builder needs this option
-            .protoc_arg("--experimental_allow_proto3_optional")
-            .compile(&[proto_path], &[proto_dir])?;
-
-        // read file contents to string
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open("src/arrow.flight.protocol.rs")?;
-        let mut buffer = String::new();
-        file.read_to_string(&mut buffer)?;
-        // append warning that file was auto-generate
-        let mut file = OpenOptions::new()
-            .write(true)
-            .truncate(true)
-            .open("src/arrow.flight.protocol.rs")?;
-        file.write_all("// This file was automatically generated through the build.rs script, and should not be edited.\n\n".as_bytes())?;
-        file.write_all(buffer.as_bytes())?;
-    }
-
-    // override the build location, in order to check in the changes to proto files
-    env::set_var("OUT_DIR", "src/sql");
-    // The current working directory can vary depending on how the project is being
-    // built or released so we build an absolute path to the proto file
-    let path = Path::new("../format/FlightSql.proto");
-    if path.exists() {
-        // avoid rerunning build if the file has not changed
-        println!("cargo:rerun-if-changed=../format/FlightSql.proto");
-
-        let proto_dir = Path::new("../format");
-        let proto_path = Path::new("../format/FlightSql.proto");
-
-        tonic_build::configure()
-            // protoc in unbuntu builder needs this option
-            .protoc_arg("--experimental_allow_proto3_optional")
-            .compile(&[proto_path], &[proto_dir])?;
-
-        // read file contents to string
-        let mut file = OpenOptions::new()
-            .read(true)
-            .open("src/sql/arrow.flight.protocol.sql.rs")?;
-        let mut buffer = String::new();
-        file.read_to_string(&mut buffer)?;
-        // append warning that file was auto-generate
-        let mut file = OpenOptions::new()
-            .write(true)
-            .truncate(true)
-            .open("src/sql/arrow.flight.protocol.sql.rs")?;
-        file.write_all("// This file was automatically generated through the build.rs script, and should not be edited.\n\n".as_bytes())?;
-        file.write_all(buffer.as_bytes())?;
-    }
-
-    // Prost currently generates an empty file, this was fixed but then reverted
-    // https://github.com/tokio-rs/prost/pull/639
-    let google_protobuf_rs = Path::new("src/sql/google.protobuf.rs");
-    if google_protobuf_rs.exists() && google_protobuf_rs.metadata().unwrap().len() == 0 {
-        std::fs::remove_file(google_protobuf_rs).unwrap();
-    }
-
-    // As the proto file is checked in, the build should not fail if the file is not found
-    Ok(())
-}
diff --git a/arrow-flight/examples/data/ca.pem b/arrow-flight/examples/data/ca.pem
new file mode 100644
index 000000000000..d81956096677
--- /dev/null
+++ b/arrow-flight/examples/data/ca.pem
@@ -0,0 +1,28 @@
+-----BEGIN CERTIFICATE-----
+MIIE3DCCA0SgAwIBAgIRAObeYbJFiVQSGR8yk44dsOYwDQYJKoZIhvcNAQELBQAw
+gYUxHjAcBgNVBAoTFW1rY2VydCBkZXZlbG9wbWVudCBDQTEtMCsGA1UECwwkbHVj
+aW9ATHVjaW9zLVdvcmstTUJQIChMdWNpbyBGcmFuY28pMTQwMgYDVQQDDCtta2Nl
+cnQgbHVjaW9ATHVjaW9zLVdvcmstTUJQIChMdWNpbyBGcmFuY28pMB4XDTE5MDky
+OTIzMzUzM1oXDTI5MDkyOTIzMzUzM1owgYUxHjAcBgNVBAoTFW1rY2VydCBkZXZl
+bG9wbWVudCBDQTEtMCsGA1UECwwkbHVjaW9ATHVjaW9zLVdvcmstTUJQIChMdWNp
+byBGcmFuY28pMTQwMgYDVQQDDCtta2NlcnQgbHVjaW9ATHVjaW9zLVdvcmstTUJQ
+IChMdWNpbyBGcmFuY28pMIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIBigKCAYEA
+y/vE61ItbN/1qMYt13LMf+le1svwfkCCOPsygk7nWeRXmomgUpymqn1LnWiuB0+e
+4IdVH2f5E9DknWEpPhKIDMRTCbz4jTwQfHrxCb8EGj3I8oO73pJO5S/xCedM9OrZ
+qWcYWwN0GQ8cO/ogazaoZf1uTrRNHyzRyQsKyb412kDBTNEeldJZ2ljKgXXvh4HO
+2ZIk9K/ZAaAf6VN8K/89rlJ9/KPgRVNsyAapE+Pb8XXKtpzeFiEcUfuXVYWtkoW+
+xyn/Zu8A1L2CXMQ1sARh7P/42BTMKr5pfraYgcBGxKXLrxoySpxCO9KqeVveKy1q
+fPm5FCwFsXDr0koFLrCiR58mcIO/04Q9DKKTV4Z2a+LoqDJRY37KfBSc8sDMPhw5
+k7g3WPoa6QwXRjZTCA5fHWVgLOtcwLsnju5tBE4LDxwF6s+1wPF8NI5yUfufcEjJ
+Z6JBwgoWYosVj27Lx7KBNLU/57PX9ryee691zmtswt0tP0WVBAgalhYWg99RXoa3
+AgMBAAGjRTBDMA4GA1UdDwEB/wQEAwICBDASBgNVHRMBAf8ECDAGAQH/AgEAMB0G
+A1UdDgQWBBQdvlE4Bdcsjc9oaxjDCRu5FiuZkzANBgkqhkiG9w0BAQsFAAOCAYEA
+BP/6o1kPINksMJZSSXgNCPZskDLyGw7auUZBnQ0ocDT3W6gXQvT/27LM1Hxoj9Eh
+qU1TYdEt7ppecLQSGvzQ02MExG7H75art75oLiB+A5agDira937YbK4MCjqW481d
+bDhw6ixJnY1jIvwjEZxyH6g94YyL927aSPch51fys0kSnjkFzC2RmuzDADScc4XH
+5P1+/3dnIm3M5yfpeUzoaOrTXNmhn8p0RDIGrZ5kA5eISIGGD3Mm8FDssUNKndtO
+g4ojHUsxb14icnAYGeye1NOhGiqN6TEFcgr6MPd0XdFNZ5c0HUaBCfN6bc+JxDV5
+MKZVJdNeJsYYwilgJNHAyZgCi30JC20xeYVtTF7CEEsMrFDGJ70Kz7o/FnRiFsA1
+ZSwVVWhhkHG2VkT4vlo0O3fYeZpenYicvy+wZNTbGK83gzHWqxxNC1z3Etg5+HRJ
+F9qeMWPyfA3IHYXygiMcviyLcyNGG/SJ0EhUpYBN/Gg7wI5yFkcsxUDPPzd23O0M
+-----END CERTIFICATE-----
diff --git a/arrow-flight/examples/data/client1.key b/arrow-flight/examples/data/client1.key
new file mode 100644
index 000000000000..f4d8da2758ac
--- /dev/null
+++ b/arrow-flight/examples/data/client1.key
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQCiiWrmzpENsI+c
+Cz4aBpG+Pl8WOsrByfZx/ZnJdCZHO3MTYE6sCLhYssf0ygAEEGxvmkd4cxmfCfgf
+xuT8u+D7Y5zQSoymkbWdU6/9jbNY6Ovtc+a96I1LGXOKROQw6KR3PuqLpUqEOJiB
+l03qK+HMU0g56G1n31Od7HkJsDRvtePqy3I3LgpdcRps23sk46tCzZzhyfqIQ7Qf
+J5qZx93tA+pfy+Xtb9XIUTIWKIp1/uyfh8Fp8HA0c9zJCSZzJOX2j3GH1TYqkVgP
+egI2lhmdXhP5Q8vdhwy0UJaL28RJXA6UAg0tPZeWJe6pux9JiA81sI6My+Krrw8D
+yibkGTTbAgMBAAECggEANCQhRym9HsclSsnQgkjZOE6J8nep08EWbjsMurOoE/He
+WLjshAPIH6w6uSyUFLmwD51OkDVcYsiv8IG9s9YRtpOeGrPPqx/TQ0U1kAGFJ2CR
+Tvt/aizQJudjSVgQXCBFontsgp/j58bAJdKEDDtHlGSjJvCJKGlcSa0ypwj/yVXt
+frjROJNYzw9gMM7fN/IKF/cysdXSeLl/Q9RnHVIfC3jOFJutsILCK8+PC51dM8Fl
+IOjmPmiZ080yV8RBcMRECwl53vLOE3OOpR3ZijfNCY1KU8zWi1oELJ1o6f4+cBye
+7WPgFEoBew5XHXZ+ke8rh8cc0wth7ZTcC+xC/456AQKBgQDQr2EzBwXxYLF8qsN1
+R4zlzXILLdZN8a4bKfrS507/Gi1gDBHzfvbE7HfljeqrAkbKMdKNkbz3iS85SguH
+jsM047xUGJg0PAcwBLHUedlSn1xDDcDHW6X8ginpA2Zz1+WAlhNz6XurA1wnjZmS
+VcPxopH7QsuFCclqtt14MbBQ6QKBgQDHY3jcAVfQF+yhQ0YyM6GPLN342aTplgyJ
+yz4uWVMeXacU4QzqGbf2L2hc9M2L28Xb37RWC3Q/by0vUefiC6qxRt+GJdRsOuQj
+2F1uUibeWtAWp249fcfvxjLib276J+Eit18LI0s0mNR3ekK4GcjSe4NwSq5IrU8e
+pBreet3dIwKBgQCxVuil4WkGd+I8jC0v5A7zVsR8hYZhlGkdgm45fgHevdMjlP5I
+S3PPYxh8hj6O9o9L0k0Yq2nHfdgYujjUCNkQgBuR55iogv6kqsioRKgPE4fnH6/c
+eqCy1bZh4tbUyPqqbF65mQfUCzXsEuQXvDSYiku+F0Q2mVuGCUJpmug3yQKBgEd3
+LeCdUp4xlQ0QEd74hpXM3RrO178pmwDgqj7uoU4m/zYKnBhkc3137I406F+SvE5c
+1kRpApeh/64QS27IA7xazM9GS+cnDJKUgJiENY5JOoCELo03wiv8/EwQ6NQc6yMI
+WrahRdlqVe0lEzjtdP+MacYb3nAKPmubIk5P96nFAoGAFAyrKpFTyXbNYBTw9Rab
+TG6q7qkn+YTHN3+k4mo9NGGwZ3pXvmrKMYCIRhLMbqzsmTbFqCPPIxKsrmf8QYLh
+xHYQjrCkbZ0wZdcdeV6yFSDsF218nF/12ZPE7CBOQMfZTCKFNWGL97uIVcmR6K5G
+ojTkOvaUnwQtSFhNuzyr23I=
+-----END PRIVATE KEY-----
diff --git a/arrow-flight/examples/data/client1.pem b/arrow-flight/examples/data/client1.pem
new file mode 100644
index 000000000000..bb3b82c40c5a
--- /dev/null
+++ b/arrow-flight/examples/data/client1.pem
@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDCTCCAfGgAwIBAgIQYbE9d1Rft5h4ku7FSAvWdzANBgkqhkiG9w0BAQsFADAn
+MSUwIwYDVQQDExxUb25pYyBFeGFtcGxlIENsaWVudCBSb290IENBMB4XDTE5MTAx
+NDEyMzkzNloXDTI0MTAxMjEyMzkzNlowEjEQMA4GA1UEAxMHY2xpZW50MTCCASIw
+DQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKKJaubOkQ2wj5wLPhoGkb4+XxY6
+ysHJ9nH9mcl0Jkc7cxNgTqwIuFiyx/TKAAQQbG+aR3hzGZ8J+B/G5Py74PtjnNBK
+jKaRtZ1Tr/2Ns1jo6+1z5r3ojUsZc4pE5DDopHc+6oulSoQ4mIGXTeor4cxTSDno
+bWffU53seQmwNG+14+rLcjcuCl1xGmzbeyTjq0LNnOHJ+ohDtB8nmpnH3e0D6l/L
+5e1v1chRMhYoinX+7J+HwWnwcDRz3MkJJnMk5faPcYfVNiqRWA96AjaWGZ1eE/lD
+y92HDLRQlovbxElcDpQCDS09l5Yl7qm7H0mIDzWwjozL4quvDwPKJuQZNNsCAwEA
+AaNGMEQwEwYDVR0lBAwwCgYIKwYBBQUHAwIwDAYDVR0TAQH/BAIwADAfBgNVHSME
+GDAWgBQV1YOR+Jpl1fbujvWLSBEoRvsDhTANBgkqhkiG9w0BAQsFAAOCAQEAfTPu
+KeHXmyVTSCUrYQ1X5Mu7VzfZlRbhoytHOw7bYGgwaFwQj+ZhlPt8nFC22/bEk4IV
+AoCOli0WyPIB7Lx52dZ+v9JmYOK6ca2Aa/Dkw8Q+M3XA024FQWq3nZ6qANKC32/9
+Nk+xOcb1Qd/11stpTkRf2Oj7F7K4GnlFbY6iMyNW+RFXGKEbL5QAJDTDPIT8vw1x
+oYeNPwmC042uEboCZPNXmuctiK9Wt1TAxjZT/cwdIBGGJ+xrW72abfJGs7bUcJfc
+O4r9V0xVv+X0iKWTW0fwd9qjNfiEP1tFCcZb2XsNQPe/DlQZ+h98P073tZEsWI/G
+KJrFspGX8vOuSdIeqw==
+-----END CERTIFICATE-----
diff --git a/arrow-flight/examples/data/client_ca.pem b/arrow-flight/examples/data/client_ca.pem
new file mode 100644
index 000000000000..aa483b931056
--- /dev/null
+++ b/arrow-flight/examples/data/client_ca.pem
@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDGzCCAgOgAwIBAgIRAMNWpWRu6Q1txEYUyrkyXKEwDQYJKoZIhvcNAQELBQAw
+JzElMCMGA1UEAxMcVG9uaWMgRXhhbXBsZSBDbGllbnQgUm9vdCBDQTAeFw0xOTEw
+MTQxMjM5MzZaFw0yOTEwMTExMjM5MzZaMCcxJTAjBgNVBAMTHFRvbmljIEV4YW1w
+bGUgQ2xpZW50IFJvb3QgQ0EwggEiMA0GCSqGSIb3DQEBAQUAA4IBDwAwggEKAoIB
+AQCv8Nj4XJbMI0wWUvLbmCf7IEvJFnomodGnDurh8Y5AGMPJ8cGdZC1yo2Lgah+D
+IhXdsd72Wp7MhdntJAyPrMCDBfDrFiuj6YHDgt3OhPQSYl7EWG7QjFK3B2sp1K5D
+h16G5zfwUKDj9Jp3xuPGuqNFQHL02nwbhtDilqHvaTfOJKVjsFCoU8Z77mfwXSwn
+sPXpPB7oOO4mWfAtcwU11rTMiHFSGFlFhgbHULU/y90DcpfRQEpEiBoiK13gkyoP
+zHT9WAg3Pelwb6K7c7kJ7mp4axhbf7MkwFhDQIjbBWqus2Eu3b0mf86ALfDbAaNC
+wBi8xbNH2vWaDjiwLDY5uMZDAgMBAAGjQjBAMA4GA1UdDwEB/wQEAwICBDAPBgNV
+HRMBAf8EBTADAQH/MB0GA1UdDgQWBBQV1YOR+Jpl1fbujvWLSBEoRvsDhTANBgkq
+hkiG9w0BAQsFAAOCAQEAaXmM29TYkFUzZUsV7TSonAK560BjxDmbg0GJSUgLEFUJ
+wpKqa9UKOSapG45LEeR2wwAmVWDJomJplkuvTD/KOabAbZKyPEfp+VMCaBUnILQF
+Cxv5m7kQ3wmPS/rEL8FD809UGowW9cYqnZzUy5i/r263rx0k3OPjkkZN66Mh6+3H
+ibNdaxf7ITO0JVb/Ohq9vLC9qf7ujiB1atMdJwkOWsZrLJXLygpx/D0/UhBT4fFH
+OlyVOmuR27qaMbPgOs2l8DznkJY/QUfnET8iOQhFgb0Dt/Os4PYFhSDRIrgl5dJ7
+L/zZVQfZYpdxlBHJlDC1/NzVQl/1MgDnSgPGStZKPQ==
+-----END CERTIFICATE-----
diff --git a/arrow-flight/examples/data/server.key b/arrow-flight/examples/data/server.key
new file mode 100644
index 000000000000..80984ef9000d
--- /dev/null
+++ b/arrow-flight/examples/data/server.key
@@ -0,0 +1,28 @@
+-----BEGIN PRIVATE KEY-----
+MIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQDyptbMyYWztgta
+t1MXLMzIkaQdeeVbs1Y/qCpAdwZe/Y5ZpbzjGIjCxbB6vNRSnEbYKpytKHPzYfM7
+8d8K8bPvpnqXIiTXFT0JQlw1OHLC1fr4e598GJumAmpMYFrtqv0fbmUFTuQGbHxe
+OH2vji0bvr3NKZubMfkEZP3X4sNXXoXIuW2LaS8OMGKoJaeCBvdbszEiSGj/v9Bj
+pM0yLTH89NNMX1T+FtTKnuXag5g7pr6lzJj83+MzAGy4nOjseSuUimuiyG90/C5t
+A5wC0Qh5RbDnkFYhC44Kxof/i6+jnfateIPNiIIwQV+2f6G/aK1hgjekT10m/eoR
+YDTf+e5ZAgMBAAECggEACODt7yRYjhDVLYaTtb9f5t7dYG67Y7WWLFIc6arxQryI
+XuNfm/ej2WyeXn9WTYeGWBaHERbv1zH4UnMxNBdP/C7dQXZwXqZaS2JwOUpNeK+X
+tUvgtAu6dkKUXSMRcKzXAjVp4N3YHhwOGOx8PNY49FDwZPdmyDD16aFAYIvdle6/
+PSMrj38rB1sbQQdmRob2FjJBSDZ44nsr+/nilrcOFNfNnWv7tQIWYVXNcLfdK/WJ
+ZCDFhA8lr/Yon6MEq6ApTj2ZYRRGXPd6UeASJkmTZEUIUbeDcje/MO8cHkREpuRH
+wm3pCjR7OdO4vc+/d/QmEvu5ns6wbTauelYnL616YQKBgQD414gJtpCHauNEUlFB
+v/R3DzPI5NGp9PAqovOD8nCbI49Mw61gP/ExTIPKiR5uUX/5EL04uspaNkuohXk+
+ys0G5At0NfV7W39lzhvALEaSfleybvYxppbBrc20/q8Gvi/i30NY+1LM3RdtMiEw
+hKHjU0SnFhJq0InFg3AO/iCeTQKBgQD5obkbzpOidSsa55aNsUlO2qjiUY9leq9b
+irAohIZ8YnuuixYvkOeSeSz1eIrA4tECeAFSgTZxYe1Iz+USru2Xg/0xNte11dJD
+rBoH/yMn2gDvBK7xQ6uFMPTeYtKG0vfvpXZYSWZzGntyrHTwFk6UV+xdrt9MBdd1
+XdSn7bwOPQKBgC9VQAko8uDvUf+C8PXiv2uONrl13PPJJY3WpR9qFEVOREnDxszS
+HNzVwxPZdTJiykbkCjoqPadfQJDzopZxGQLAifU29lTamKcSx3CMe3gOFDxaovXa
+zD5XAxP0hfJwZsdu1G6uj5dsTrJ0oJ+L+wc0pZBqwGIU/L/XOo9/g1DZAoGAUebL
+kuH98ik7EUK2VJq8EJERI9/ailLsQb6I+WIxtZGiPqwHhWencpkrNQZtj8dbB9JT
+rLwUHrMgZOlAoRafgTyez4zMzS3wJJ/Mkp8U67hM4h7JPwMSvUpIrMYDiJSjIA9L
+er/qSw1/Pypx22uWMHmAZWRAgvLPtAQrB0Wqk4kCgYEAr2H1PvfbwZwkSvlMt5o8
+WLnBbxcM3AKglLRbkShxxgiZYdEP71/uOtRMiL26du5XX8evItITN0DsvmXL/kcd
+h29LK7LM5uLw7efz0Qxs03G6kEyIHVkacowHi5I5Ul1qI61SoV3yMB1TjIU+bXZt
+0ZjC07totO0fqPOLQxonjQg=
+-----END PRIVATE KEY-----
diff --git a/arrow-flight/examples/data/server.pem b/arrow-flight/examples/data/server.pem
new file mode 100644
index 000000000000..4cc97bcf4b6d
--- /dev/null
+++ b/arrow-flight/examples/data/server.pem
@@ -0,0 +1,27 @@
+-----BEGIN CERTIFICATE-----
+MIIEmDCCAwCgAwIBAgIQVEJFCgU/CZk9JEwTucWPpzANBgkqhkiG9w0BAQsFADCB
+hTEeMBwGA1UEChMVbWtjZXJ0IGRldmVsb3BtZW50IENBMS0wKwYDVQQLDCRsdWNp
+b0BMdWNpb3MtV29yay1NQlAgKEx1Y2lvIEZyYW5jbykxNDAyBgNVBAMMK21rY2Vy
+dCBsdWNpb0BMdWNpb3MtV29yay1NQlAgKEx1Y2lvIEZyYW5jbykwHhcNMTkwNjAx
+MDAwMDAwWhcNMjkwOTI5MjMzNTM0WjBYMScwJQYDVQQKEx5ta2NlcnQgZGV2ZWxv
+cG1lbnQgY2VydGlmaWNhdGUxLTArBgNVBAsMJGx1Y2lvQEx1Y2lvcy1Xb3JrLU1C
+UCAoTHVjaW8gRnJhbmNvKTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEB
+APKm1szJhbO2C1q3UxcszMiRpB155VuzVj+oKkB3Bl79jlmlvOMYiMLFsHq81FKc
+RtgqnK0oc/Nh8zvx3wrxs++mepciJNcVPQlCXDU4csLV+vh7n3wYm6YCakxgWu2q
+/R9uZQVO5AZsfF44fa+OLRu+vc0pm5sx+QRk/dfiw1dehci5bYtpLw4wYqglp4IG
+91uzMSJIaP+/0GOkzTItMfz000xfVP4W1Mqe5dqDmDumvqXMmPzf4zMAbLic6Ox5
+K5SKa6LIb3T8Lm0DnALRCHlFsOeQViELjgrGh/+Lr6Od9q14g82IgjBBX7Z/ob9o
+rWGCN6RPXSb96hFgNN/57lkCAwEAAaOBrzCBrDAOBgNVHQ8BAf8EBAMCBaAwEwYD
+VR0lBAwwCgYIKwYBBQUHAwEwDAYDVR0TAQH/BAIwADAfBgNVHSMEGDAWgBQdvlE4
+Bdcsjc9oaxjDCRu5FiuZkzBWBgNVHREETzBNggtleGFtcGxlLmNvbYINKi5leGFt
+cGxlLmNvbYIMZXhhbXBsZS50ZXN0gglsb2NhbGhvc3SHBH8AAAGHEAAAAAAAAAAA
+AAAAAAAAAAEwDQYJKoZIhvcNAQELBQADggGBAKb2TJ8l+e1eraNwZWizLw5fccAf
+y59J1JAWdLxZyAI/bkiTlVO3DQoPZpw7XwLhefCvILkwKAL4TtIGGVC9yTb5Q5eg
+rqGO3FC0yg1fn65Kf1VpVxxUVyoiM5PQ4pFJb4AicAv88rCOLD9FFuE0PKOKU/dm
+Tw0WgPStoh9wsJ1RXUuTJYZs1nd1kMBlfv9NbLilnL+cR2sLktS54X5XagsBYVlf
+oapRb0JtABOoQhX3U8QMq8UF8yzceRHNTN9yfLOUrW26s9nKtlWVniNhw1uPxZw9
+RHM7w9/4+a9LXtEDYg4IP/1mm0ywBoUqy1O6hA73uId+Yi/kFBks/GyYaGjKgYcO
+23B75tkPGYEdGuGZYLzZNHbXg4V0UxFQG3KA1pUiSnD3bN2Rxs+CMpzORnOeK3xi
+EooKgAPYsehItoQOMPpccI2xHdSAMWtwUgOKrefUQujkx2Op+KFlspF0+WJ6AZEe
+2D4hyWaEZsvvILXapwqHDCuN3/jSUlTIqUoE1w==
+-----END CERTIFICATE-----
diff --git a/arrow-flight/examples/flight_sql_server.rs b/arrow-flight/examples/flight_sql_server.rs
index aa0d407113d7..85f5c7499346 100644
--- a/arrow-flight/examples/flight_sql_server.rs
+++ b/arrow-flight/examples/flight_sql_server.rs
@@ -15,31 +15,129 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow_flight::sql::{ActionCreatePreparedStatementResult, SqlInfo};
-use arrow_flight::{Action, FlightData, HandshakeRequest, HandshakeResponse, Ticket};
-use futures::Stream;
+use arrow_flight::sql::server::PeekableFlightDataStream;
+use base64::prelude::BASE64_STANDARD;
+use base64::Engine;
+use futures::{stream, Stream, TryStreamExt};
+use once_cell::sync::Lazy;
+use prost::Message;
+use std::collections::HashSet;
 use std::pin::Pin;
+use std::sync::Arc;
 use tonic::transport::Server;
+use tonic::transport::{Certificate, Identity, ServerTlsConfig};
 use tonic::{Request, Response, Status, Streaming};
 
+use arrow_array::builder::StringBuilder;
+use arrow_array::{ArrayRef, RecordBatch};
+use arrow_flight::encode::FlightDataEncoderBuilder;
+use arrow_flight::sql::metadata::{
+    SqlInfoData, SqlInfoDataBuilder, XdbcTypeInfo, XdbcTypeInfoData, XdbcTypeInfoDataBuilder,
+};
+use arrow_flight::sql::{
+    server::FlightSqlService, ActionBeginSavepointRequest, ActionBeginSavepointResult,
+    ActionBeginTransactionRequest, ActionBeginTransactionResult, ActionCancelQueryRequest,
+    ActionCancelQueryResult, ActionClosePreparedStatementRequest,
+    ActionCreatePreparedStatementRequest, ActionCreatePreparedStatementResult,
+    ActionCreatePreparedSubstraitPlanRequest, ActionEndSavepointRequest,
+    ActionEndTransactionRequest, Any, CommandGetCatalogs, CommandGetCrossReference,
+    CommandGetDbSchemas, CommandGetExportedKeys, CommandGetImportedKeys, CommandGetPrimaryKeys,
+    CommandGetSqlInfo, CommandGetTableTypes, CommandGetTables, CommandGetXdbcTypeInfo,
+    CommandPreparedStatementQuery, CommandPreparedStatementUpdate, CommandStatementQuery,
+    CommandStatementSubstraitPlan, CommandStatementUpdate, Nullable, ProstMessageExt, Searchable,
+    SqlInfo, TicketStatementQuery, XdbcDataType,
+};
+use arrow_flight::utils::batches_to_flight_data;
 use arrow_flight::{
-    flight_service_server::FlightService,
-    flight_service_server::FlightServiceServer,
-    sql::{
-        server::FlightSqlService, ActionClosePreparedStatementRequest,
-        ActionCreatePreparedStatementRequest, CommandGetCatalogs,
-        CommandGetCrossReference, CommandGetDbSchemas, CommandGetExportedKeys,
-        CommandGetImportedKeys, CommandGetPrimaryKeys, CommandGetSqlInfo,
-        CommandGetTableTypes, CommandGetTables, CommandPreparedStatementQuery,
-        CommandPreparedStatementUpdate, CommandStatementQuery, CommandStatementUpdate,
-        TicketStatementQuery,
-    },
-    FlightDescriptor, FlightInfo,
+    flight_service_server::FlightService, flight_service_server::FlightServiceServer, Action,
+    FlightData, FlightDescriptor, FlightEndpoint, FlightInfo, HandshakeRequest, HandshakeResponse,
+    IpcMessage, Location, SchemaAsIpc, Ticket,
 };
+use arrow_ipc::writer::IpcWriteOptions;
+use arrow_schema::{ArrowError, DataType, Field, Schema};
+
+macro_rules! status {
+    ($desc:expr, $err:expr) => {
+        Status::internal(format!("{}: {} at {}:{}", $desc, $err, file!(), line!()))
+    };
+}
+
+const FAKE_TOKEN: &str = "uuid_token";
+const FAKE_HANDLE: &str = "uuid_handle";
+const FAKE_UPDATE_RESULT: i64 = 1;
+
+static INSTANCE_SQL_DATA: Lazy<SqlInfoData> = Lazy::new(|| {
+    let mut builder = SqlInfoDataBuilder::new();
+    // Server information
+    builder.append(SqlInfo::FlightSqlServerName, "Example Flight SQL Server");
+    builder.append(SqlInfo::FlightSqlServerVersion, "1");
+    // 1.3 comes from https://github.com/apache/arrow/blob/f9324b79bf4fc1ec7e97b32e3cce16e75ef0f5e3/format/Schema.fbs#L24
+    builder.append(SqlInfo::FlightSqlServerArrowVersion, "1.3");
+    builder.build().unwrap()
+});
+
+static INSTANCE_XBDC_DATA: Lazy<XdbcTypeInfoData> = Lazy::new(|| {
+    let mut builder = XdbcTypeInfoDataBuilder::new();
+    builder.append(XdbcTypeInfo {
+        type_name: "INTEGER".into(),
+        data_type: XdbcDataType::XdbcInteger,
+        column_size: Some(32),
+        literal_prefix: None,
+        literal_suffix: None,
+        create_params: None,
+        nullable: Nullable::NullabilityNullable,
+        case_sensitive: false,
+        searchable: Searchable::Full,
+        unsigned_attribute: Some(false),
+        fixed_prec_scale: false,
+        auto_increment: Some(false),
+        local_type_name: Some("INTEGER".into()),
+        minimum_scale: None,
+        maximum_scale: None,
+        sql_data_type: XdbcDataType::XdbcInteger,
+        datetime_subcode: None,
+        num_prec_radix: Some(2),
+        interval_precision: None,
+    });
+    builder.build().unwrap()
+});
+
+static TABLES: Lazy<Vec<&'static str>> = Lazy::new(|| vec!["flight_sql.example.table"]);
 
 #[derive(Clone)]
 pub struct FlightSqlServiceImpl {}
 
+impl FlightSqlServiceImpl {
+    fn check_token<T>(&self, req: &Request<T>) -> Result<(), Status> {
+        let metadata = req.metadata();
+        let auth = metadata.get("authorization").ok_or_else(|| {
+            Status::internal(format!("No authorization header! metadata = {metadata:?}"))
+        })?;
+        let str = auth
+            .to_str()
+            .map_err(|e| Status::internal(format!("Error parsing header: {e}")))?;
+        let authorization = str.to_string();
+        let bearer = "Bearer ";
+        if !authorization.starts_with(bearer) {
+            Err(Status::internal("Invalid auth header!"))?;
+        }
+        let token = authorization[bearer.len()..].to_string();
+        if token == FAKE_TOKEN {
+            Ok(())
+        } else {
+            Err(Status::unauthenticated("invalid token "))
+        }
+    }
+
+    fn fake_result() -> Result<RecordBatch, ArrowError> {
+        let schema = Schema::new(vec![Field::new("salutation", DataType::Utf8, false)]);
+        let mut builder = StringBuilder::new();
+        builder.append_value("Hello, FlightSQL!");
+        let cols = vec![Arc::new(builder.finish()) as ArrayRef];
+        RecordBatch::try_new(Arc::new(schema), cols)
+    }
+}
+
 #[tonic::async_trait]
 impl FlightSqlService for FlightSqlServiceImpl {
     type FlightService = FlightSqlServiceImpl;
@@ -55,41 +153,59 @@ impl FlightSqlService for FlightSqlServiceImpl {
         let authorization = request
             .metadata()
             .get("authorization")
-            .ok_or(Status::invalid_argument("authorization field not present"))?
+            .ok_or_else(|| Status::invalid_argument("authorization field not present"))?
             .to_str()
-            .map_err(|_| Status::invalid_argument("authorization not parsable"))?;
+            .map_err(|e| status!("authorization not parsable", e))?;
         if !authorization.starts_with(basic) {
             Err(Status::invalid_argument(format!(
-                "Auth type not implemented: {}",
-                authorization
+                "Auth type not implemented: {authorization}"
             )))?;
         }
         let base64 = &authorization[basic.len()..];
-        let bytes = base64::decode(base64)
-            .map_err(|_| Status::invalid_argument("authorization not parsable"))?;
-        let str = String::from_utf8(bytes)
-            .map_err(|_| Status::invalid_argument("authorization not parsable"))?;
-        let parts: Vec<_> = str.split(":").collect();
-        if parts.len() != 2 {
-            Err(Status::invalid_argument(format!(
-                "Invalid authorization header"
-            )))?;
-        }
-        let user = parts[0];
-        let pass = parts[1];
-        if user != "admin" || pass != "password" {
+        let bytes = BASE64_STANDARD
+            .decode(base64)
+            .map_err(|e| status!("authorization not decodable", e))?;
+        let str = String::from_utf8(bytes).map_err(|e| status!("authorization not parsable", e))?;
+        let parts: Vec<_> = str.split(':').collect();
+        let (user, pass) = match parts.as_slice() {
+            [user, pass] => (user, pass),
+            _ => Err(Status::invalid_argument(
+                "Invalid authorization header".to_string(),
+            ))?,
+        };
+        if user != &"admin" || pass != &"password" {
             Err(Status::unauthenticated("Invalid credentials!"))?
         }
+
         let result = HandshakeResponse {
             protocol_version: 0,
-            payload: "random_uuid_token".as_bytes().to_vec(),
+            payload: FAKE_TOKEN.into(),
         };
         let result = Ok(result);
         let output = futures::stream::iter(vec![result]);
         return Ok(Response::new(Box::pin(output)));
     }
 
-    // get_flight_info
+    async fn do_get_fallback(
+        &self,
+        request: Request<Ticket>,
+        _message: Any,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        self.check_token(&request)?;
+        let batch = Self::fake_result().map_err(|e| status!("Could not fake a result", e))?;
+        let schema = batch.schema();
+        let batches = vec![batch];
+        let flight_data = batches_to_flight_data(schema.as_ref(), batches)
+            .map_err(|e| status!("Could not convert batches", e))?
+            .into_iter()
+            .map(Ok);
+
+        let stream: Pin<Box<dyn Stream<Item = Result<FlightData, Status>> + Send>> =
+            Box::pin(stream::iter(flight_data));
+        let resp = Response::new(stream);
+        Ok(resp)
+    }
+
     async fn get_flight_info_statement(
         &self,
         _query: CommandStatementQuery,
@@ -100,44 +216,113 @@ impl FlightSqlService for FlightSqlServiceImpl {
         ))
     }
 
-    async fn get_flight_info_prepared_statement(
+    async fn get_flight_info_substrait_plan(
         &self,
-        _query: CommandPreparedStatementQuery,
+        _query: CommandStatementSubstraitPlan,
         _request: Request<FlightDescriptor>,
     ) -> Result<Response<FlightInfo>, Status> {
         Err(Status::unimplemented(
-            "get_flight_info_prepared_statement not implemented",
+            "get_flight_info_substrait_plan not implemented",
         ))
     }
 
+    async fn get_flight_info_prepared_statement(
+        &self,
+        cmd: CommandPreparedStatementQuery,
+        request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        self.check_token(&request)?;
+        let handle = std::str::from_utf8(&cmd.prepared_statement_handle)
+            .map_err(|e| status!("Unable to parse handle", e))?;
+        let batch = Self::fake_result().map_err(|e| status!("Could not fake a result", e))?;
+        let schema = (*batch.schema()).clone();
+        let num_rows = batch.num_rows();
+        let num_bytes = batch.get_array_memory_size();
+        let loc = Location {
+            uri: "grpc+tcp://127.0.0.1".to_string(),
+        };
+        let fetch = FetchResults {
+            handle: handle.to_string(),
+        };
+        let buf = fetch.as_any().encode_to_vec().into();
+        let ticket = Ticket { ticket: buf };
+        let endpoint = FlightEndpoint {
+            ticket: Some(ticket),
+            location: vec![loc],
+            expiration_time: None,
+            app_metadata: vec![].into(),
+        };
+        let info = FlightInfo::new()
+            .try_with_schema(&schema)
+            .map_err(|e| status!("Unable to serialize schema", e))?
+            .with_descriptor(FlightDescriptor::new_cmd(vec![]))
+            .with_endpoint(endpoint)
+            .with_total_records(num_rows as i64)
+            .with_total_bytes(num_bytes as i64)
+            .with_ordered(false);
+
+        let resp = Response::new(info);
+        Ok(resp)
+    }
+
     async fn get_flight_info_catalogs(
         &self,
-        _query: CommandGetCatalogs,
-        _request: Request<FlightDescriptor>,
+        query: CommandGetCatalogs,
+        request: Request<FlightDescriptor>,
     ) -> Result<Response<FlightInfo>, Status> {
-        Err(Status::unimplemented(
-            "get_flight_info_catalogs not implemented",
-        ))
+        let flight_descriptor = request.into_inner();
+        let ticket = Ticket {
+            ticket: query.encode_to_vec().into(),
+        };
+        let endpoint = FlightEndpoint::new().with_ticket(ticket);
+
+        let flight_info = FlightInfo::new()
+            .try_with_schema(&query.into_builder().schema())
+            .map_err(|e| status!("Unable to encode schema", e))?
+            .with_endpoint(endpoint)
+            .with_descriptor(flight_descriptor);
+
+        Ok(tonic::Response::new(flight_info))
     }
 
     async fn get_flight_info_schemas(
         &self,
-        _query: CommandGetDbSchemas,
-        _request: Request<FlightDescriptor>,
+        query: CommandGetDbSchemas,
+        request: Request<FlightDescriptor>,
     ) -> Result<Response<FlightInfo>, Status> {
-        Err(Status::unimplemented(
-            "get_flight_info_schemas not implemented",
-        ))
+        let flight_descriptor = request.into_inner();
+        let ticket = Ticket {
+            ticket: query.encode_to_vec().into(),
+        };
+        let endpoint = FlightEndpoint::new().with_ticket(ticket);
+
+        let flight_info = FlightInfo::new()
+            .try_with_schema(&query.into_builder().schema())
+            .map_err(|e| status!("Unable to encode schema", e))?
+            .with_endpoint(endpoint)
+            .with_descriptor(flight_descriptor);
+
+        Ok(tonic::Response::new(flight_info))
     }
 
     async fn get_flight_info_tables(
         &self,
-        _query: CommandGetTables,
-        _request: Request<FlightDescriptor>,
+        query: CommandGetTables,
+        request: Request<FlightDescriptor>,
     ) -> Result<Response<FlightInfo>, Status> {
-        Err(Status::unimplemented(
-            "get_flight_info_tables not implemented",
-        ))
+        let flight_descriptor = request.into_inner();
+        let ticket = Ticket {
+            ticket: query.encode_to_vec().into(),
+        };
+        let endpoint = FlightEndpoint::new().with_ticket(ticket);
+
+        let flight_info = FlightInfo::new()
+            .try_with_schema(&query.into_builder().schema())
+            .map_err(|e| status!("Unable to encode schema", e))?
+            .with_endpoint(endpoint)
+            .with_descriptor(flight_descriptor);
+
+        Ok(tonic::Response::new(flight_info))
     }
 
     async fn get_flight_info_table_types(
@@ -152,12 +337,20 @@ impl FlightSqlService for FlightSqlServiceImpl {
 
     async fn get_flight_info_sql_info(
         &self,
-        _query: CommandGetSqlInfo,
-        _request: Request<FlightDescriptor>,
+        query: CommandGetSqlInfo,
+        request: Request<FlightDescriptor>,
     ) -> Result<Response<FlightInfo>, Status> {
-        Err(Status::unimplemented(
-            "get_flight_info_sql_info not implemented",
-        ))
+        let flight_descriptor = request.into_inner();
+        let ticket = Ticket::new(query.encode_to_vec());
+        let endpoint = FlightEndpoint::new().with_ticket(ticket);
+
+        let flight_info = FlightInfo::new()
+            .try_with_schema(query.into_builder(&INSTANCE_SQL_DATA).schema().as_ref())
+            .map_err(|e| status!("Unable to encode schema", e))?
+            .with_endpoint(endpoint)
+            .with_descriptor(flight_descriptor);
+
+        Ok(tonic::Response::new(flight_info))
     }
 
     async fn get_flight_info_primary_keys(
@@ -200,6 +393,24 @@ impl FlightSqlService for FlightSqlServiceImpl {
         ))
     }
 
+    async fn get_flight_info_xdbc_type_info(
+        &self,
+        query: CommandGetXdbcTypeInfo,
+        request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        let flight_descriptor = request.into_inner();
+        let ticket = Ticket::new(query.encode_to_vec());
+        let endpoint = FlightEndpoint::new().with_ticket(ticket);
+
+        let flight_info = FlightInfo::new()
+            .try_with_schema(query.into_builder(&INSTANCE_XBDC_DATA).schema().as_ref())
+            .map_err(|e| status!("Unable to encode schema", e))?
+            .with_endpoint(endpoint)
+            .with_descriptor(flight_descriptor);
+
+        Ok(tonic::Response::new(flight_info))
+    }
+
     // do_get
     async fn do_get_statement(
         &self,
@@ -221,26 +432,91 @@ impl FlightSqlService for FlightSqlServiceImpl {
 
     async fn do_get_catalogs(
         &self,
-        _query: CommandGetCatalogs,
+        query: CommandGetCatalogs,
         _request: Request<Ticket>,
     ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
-        Err(Status::unimplemented("do_get_catalogs not implemented"))
+        let catalog_names = TABLES
+            .iter()
+            .map(|full_name| full_name.split('.').collect::<Vec<_>>()[0].to_string())
+            .collect::<HashSet<_>>();
+        let mut builder = query.into_builder();
+        for catalog_name in catalog_names {
+            builder.append(catalog_name);
+        }
+        let schema = builder.schema();
+        let batch = builder.build();
+        let stream = FlightDataEncoderBuilder::new()
+            .with_schema(schema)
+            .build(futures::stream::once(async { batch }))
+            .map_err(Status::from);
+        Ok(Response::new(Box::pin(stream)))
     }
 
     async fn do_get_schemas(
         &self,
-        _query: CommandGetDbSchemas,
+        query: CommandGetDbSchemas,
         _request: Request<Ticket>,
     ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
-        Err(Status::unimplemented("do_get_schemas not implemented"))
+        let schemas = TABLES
+            .iter()
+            .map(|full_name| {
+                let parts = full_name.split('.').collect::<Vec<_>>();
+                (parts[0].to_string(), parts[1].to_string())
+            })
+            .collect::<HashSet<_>>();
+
+        let mut builder = query.into_builder();
+        for (catalog_name, schema_name) in schemas {
+            builder.append(catalog_name, schema_name);
+        }
+
+        let schema = builder.schema();
+        let batch = builder.build();
+        let stream = FlightDataEncoderBuilder::new()
+            .with_schema(schema)
+            .build(futures::stream::once(async { batch }))
+            .map_err(Status::from);
+        Ok(Response::new(Box::pin(stream)))
     }
 
     async fn do_get_tables(
         &self,
-        _query: CommandGetTables,
+        query: CommandGetTables,
         _request: Request<Ticket>,
     ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
-        Err(Status::unimplemented("do_get_tables not implemented"))
+        let tables = TABLES
+            .iter()
+            .map(|full_name| {
+                let parts = full_name.split('.').collect::<Vec<_>>();
+                (
+                    parts[0].to_string(),
+                    parts[1].to_string(),
+                    parts[2].to_string(),
+                )
+            })
+            .collect::<HashSet<_>>();
+
+        let dummy_schema = Schema::empty();
+        let mut builder = query.into_builder();
+        for (catalog_name, schema_name, table_name) in tables {
+            builder
+                .append(
+                    catalog_name,
+                    schema_name,
+                    table_name,
+                    "TABLE",
+                    &dummy_schema,
+                )
+                .map_err(Status::from)?;
+        }
+
+        let schema = builder.schema();
+        let batch = builder.build();
+        let stream = FlightDataEncoderBuilder::new()
+            .with_schema(schema)
+            .build(futures::stream::once(async { batch }))
+            .map_err(Status::from);
+        Ok(Response::new(Box::pin(stream)))
     }
 
     async fn do_get_table_types(
@@ -253,10 +529,17 @@ impl FlightSqlService for FlightSqlServiceImpl {
 
     async fn do_get_sql_info(
         &self,
-        _query: CommandGetSqlInfo,
+        query: CommandGetSqlInfo,
         _request: Request<Ticket>,
     ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
-        Err(Status::unimplemented("do_get_sql_info not implemented"))
+        let builder = query.into_builder(&INSTANCE_SQL_DATA);
+        let schema = builder.schema();
+        let batch = builder.build();
+        let stream = FlightDataEncoderBuilder::new()
+            .with_schema(schema)
+            .build(futures::stream::once(async { batch }))
+            .map_err(Status::from);
+        Ok(Response::new(Box::pin(stream)))
     }
 
     async fn do_get_primary_keys(
@@ -297,21 +580,45 @@ impl FlightSqlService for FlightSqlServiceImpl {
         ))
     }
 
+    async fn do_get_xdbc_type_info(
+        &self,
+        query: CommandGetXdbcTypeInfo,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        // create a builder with pre-defined Xdbc data:
+        let builder = query.into_builder(&INSTANCE_XBDC_DATA);
+        let schema = builder.schema();
+        let batch = builder.build();
+        let stream = FlightDataEncoderBuilder::new()
+            .with_schema(schema)
+            .build(futures::stream::once(async { batch }))
+            .map_err(Status::from);
+        Ok(Response::new(Box::pin(stream)))
+    }
+
     // do_put
     async fn do_put_statement_update(
         &self,
         _ticket: CommandStatementUpdate,
-        _request: Request<Streaming<FlightData>>,
+        _request: Request<PeekableFlightDataStream>,
+    ) -> Result<i64, Status> {
+        Ok(FAKE_UPDATE_RESULT)
+    }
+
+    async fn do_put_substrait_plan(
+        &self,
+        _ticket: CommandStatementSubstraitPlan,
+        _request: Request<PeekableFlightDataStream>,
     ) -> Result<i64, Status> {
         Err(Status::unimplemented(
-            "do_put_statement_update not implemented",
+            "do_put_substrait_plan not implemented",
         ))
     }
 
     async fn do_put_prepared_statement_query(
         &self,
         _query: CommandPreparedStatementQuery,
-        _request: Request<Streaming<FlightData>>,
+        _request: Request<PeekableFlightDataStream>,
     ) -> Result<Response<<Self as FlightService>::DoPutStream>, Status> {
         Err(Status::unimplemented(
             "do_put_prepared_statement_query not implemented",
@@ -321,27 +628,94 @@ impl FlightSqlService for FlightSqlServiceImpl {
     async fn do_put_prepared_statement_update(
         &self,
         _query: CommandPreparedStatementUpdate,
-        _request: Request<Streaming<FlightData>>,
+        _request: Request<PeekableFlightDataStream>,
     ) -> Result<i64, Status> {
         Err(Status::unimplemented(
             "do_put_prepared_statement_update not implemented",
         ))
     }
 
-    // do_action
     async fn do_action_create_prepared_statement(
         &self,
         _query: ActionCreatePreparedStatementRequest,
-        _request: Request<Action>,
+        request: Request<Action>,
     ) -> Result<ActionCreatePreparedStatementResult, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        self.check_token(&request)?;
+        let schema = Self::fake_result()
+            .map_err(|e| status!("Error getting result schema", e))?
+            .schema();
+        let message = SchemaAsIpc::new(&schema, &IpcWriteOptions::default())
+            .try_into()
+            .map_err(|e| status!("Unable to serialize schema", e))?;
+        let IpcMessage(schema_bytes) = message;
+        let res = ActionCreatePreparedStatementResult {
+            prepared_statement_handle: FAKE_HANDLE.into(),
+            dataset_schema: schema_bytes,
+            parameter_schema: Default::default(), // TODO: parameters
+        };
+        Ok(res)
     }
+
     async fn do_action_close_prepared_statement(
         &self,
         _query: ActionClosePreparedStatementRequest,
         _request: Request<Action>,
-    ) {
-        unimplemented!("Not yet implemented")
+    ) -> Result<(), Status> {
+        Err(Status::unimplemented(
+            "Implement do_action_close_prepared_statement",
+        ))
+    }
+
+    async fn do_action_create_prepared_substrait_plan(
+        &self,
+        _query: ActionCreatePreparedSubstraitPlanRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionCreatePreparedStatementResult, Status> {
+        Err(Status::unimplemented(
+            "Implement do_action_create_prepared_substrait_plan",
+        ))
+    }
+
+    async fn do_action_begin_transaction(
+        &self,
+        _query: ActionBeginTransactionRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionBeginTransactionResult, Status> {
+        Err(Status::unimplemented(
+            "Implement do_action_begin_transaction",
+        ))
+    }
+
+    async fn do_action_end_transaction(
+        &self,
+        _query: ActionEndTransactionRequest,
+        _request: Request<Action>,
+    ) -> Result<(), Status> {
+        Err(Status::unimplemented("Implement do_action_end_transaction"))
+    }
+
+    async fn do_action_begin_savepoint(
+        &self,
+        _query: ActionBeginSavepointRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionBeginSavepointResult, Status> {
+        Err(Status::unimplemented("Implement do_action_begin_savepoint"))
+    }
+
+    async fn do_action_end_savepoint(
+        &self,
+        _query: ActionEndSavepointRequest,
+        _request: Request<Action>,
+    ) -> Result<(), Status> {
+        Err(Status::unimplemented("Implement do_action_end_savepoint"))
+    }
+
+    async fn do_action_cancel_query(
+        &self,
+        _query: ActionCancelQueryRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionCancelQueryResult, Status> {
+        Err(Status::unimplemented("Implement do_action_cancel_query"))
     }
 
     async fn register_sql_info(&self, _id: i32, _result: &SqlInfo) {}
@@ -356,7 +730,293 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     println!("Listening on {:?}", addr);
 
-    Server::builder().add_service(svc).serve(addr).await?;
+    if std::env::var("USE_TLS").ok().is_some() {
+        let cert = std::fs::read_to_string("arrow-flight/examples/data/server.pem")?;
+        let key = std::fs::read_to_string("arrow-flight/examples/data/server.key")?;
+        let client_ca = std::fs::read_to_string("arrow-flight/examples/data/client_ca.pem")?;
+
+        let tls_config = ServerTlsConfig::new()
+            .identity(Identity::from_pem(&cert, &key))
+            .client_ca_root(Certificate::from_pem(&client_ca));
+
+        Server::builder()
+            .tls_config(tls_config)?
+            .add_service(svc)
+            .serve(addr)
+            .await?;
+    } else {
+        Server::builder().add_service(svc).serve(addr).await?;
+    }
 
     Ok(())
 }
+
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FetchResults {
+    #[prost(string, tag = "1")]
+    pub handle: ::prost::alloc::string::String,
+}
+
+impl ProstMessageExt for FetchResults {
+    fn type_url() -> &'static str {
+        "type.googleapis.com/arrow.flight.protocol.sql.FetchResults"
+    }
+
+    fn as_any(&self) -> Any {
+        Any {
+            type_url: FetchResults::type_url().to_string(),
+            value: ::prost::Message::encode_to_vec(self).into(),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use futures::TryStreamExt;
+    use std::fs;
+    use std::future::Future;
+    use std::net::SocketAddr;
+    use std::time::Duration;
+    use tempfile::NamedTempFile;
+    use tokio::net::{TcpListener, UnixListener, UnixStream};
+    use tokio_stream::wrappers::UnixListenerStream;
+    use tonic::transport::{Channel, ClientTlsConfig};
+
+    use arrow_cast::pretty::pretty_format_batches;
+    use arrow_flight::sql::client::FlightSqlServiceClient;
+    use tonic::transport::server::TcpIncoming;
+    use tonic::transport::{Certificate, Endpoint};
+    use tower::service_fn;
+
+    async fn bind_tcp() -> (TcpIncoming, SocketAddr) {
+        let listener = TcpListener::bind("0.0.0.0:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+        let incoming = TcpIncoming::from_listener(listener, true, None).unwrap();
+        (incoming, addr)
+    }
+
+    fn endpoint(uri: String) -> Result<Endpoint, ArrowError> {
+        let endpoint = Endpoint::new(uri)
+            .map_err(|_| ArrowError::IpcError("Cannot create endpoint".to_string()))?
+            .connect_timeout(Duration::from_secs(20))
+            .timeout(Duration::from_secs(20))
+            .tcp_nodelay(true) // Disable Nagle's Algorithm since we don't want packets to wait
+            .tcp_keepalive(Option::Some(Duration::from_secs(3600)))
+            .http2_keep_alive_interval(Duration::from_secs(300))
+            .keep_alive_timeout(Duration::from_secs(20))
+            .keep_alive_while_idle(true);
+
+        Ok(endpoint)
+    }
+
+    async fn auth_client(client: &mut FlightSqlServiceClient<Channel>) {
+        let token = client.handshake("admin", "password").await.unwrap();
+        client.set_token(String::from_utf8(token.to_vec()).unwrap());
+    }
+
+    async fn test_uds_client<F, C>(f: F)
+    where
+        F: FnOnce(FlightSqlServiceClient<Channel>) -> C,
+        C: Future<Output = ()>,
+    {
+        let file = NamedTempFile::new().unwrap();
+        let path = file.into_temp_path().to_str().unwrap().to_string();
+        let _ = fs::remove_file(path.clone());
+
+        let uds = UnixListener::bind(path.clone()).unwrap();
+        let stream = UnixListenerStream::new(uds);
+
+        let service = FlightSqlServiceImpl {};
+        let serve_future = Server::builder()
+            .add_service(FlightServiceServer::new(service))
+            .serve_with_incoming(stream);
+
+        let request_future = async {
+            let connector = service_fn(move |_| UnixStream::connect(path.clone()));
+            let channel = Endpoint::try_from("http://example.com")
+                .unwrap()
+                .connect_with_connector(connector)
+                .await
+                .unwrap();
+            let client = FlightSqlServiceClient::new(channel);
+            f(client).await
+        };
+
+        tokio::select! {
+            _ = serve_future => panic!("server returned first"),
+            _ = request_future => println!("Client finished!"),
+        }
+    }
+
+    async fn test_http_client<F, C>(f: F)
+    where
+        F: FnOnce(FlightSqlServiceClient<Channel>) -> C,
+        C: Future<Output = ()>,
+    {
+        let (incoming, addr) = bind_tcp().await;
+        let uri = format!("http://{}:{}", addr.ip(), addr.port());
+
+        let service = FlightSqlServiceImpl {};
+        let serve_future = Server::builder()
+            .add_service(FlightServiceServer::new(service))
+            .serve_with_incoming(incoming);
+
+        let request_future = async {
+            let endpoint = endpoint(uri).unwrap();
+            let channel = endpoint.connect().await.unwrap();
+            let client = FlightSqlServiceClient::new(channel);
+            f(client).await
+        };
+
+        tokio::select! {
+            _ = serve_future => panic!("server returned first"),
+            _ = request_future => println!("Client finished!"),
+        }
+    }
+
+    async fn test_https_client<F, C>(f: F)
+    where
+        F: FnOnce(FlightSqlServiceClient<Channel>) -> C,
+        C: Future<Output = ()>,
+    {
+        let cert = std::fs::read_to_string("examples/data/server.pem").unwrap();
+        let key = std::fs::read_to_string("examples/data/server.key").unwrap();
+        let client_ca = std::fs::read_to_string("examples/data/client_ca.pem").unwrap();
+
+        let tls_config = ServerTlsConfig::new()
+            .identity(Identity::from_pem(&cert, &key))
+            .client_ca_root(Certificate::from_pem(&client_ca));
+
+        let (incoming, addr) = bind_tcp().await;
+        let uri = format!("https://{}:{}", addr.ip(), addr.port());
+
+        let svc = FlightServiceServer::new(FlightSqlServiceImpl {});
+
+        let serve_future = Server::builder()
+            .tls_config(tls_config)
+            .unwrap()
+            .add_service(svc)
+            .serve_with_incoming(incoming);
+
+        let request_future = async {
+            let cert = std::fs::read_to_string("examples/data/client1.pem").unwrap();
+            let key = std::fs::read_to_string("examples/data/client1.key").unwrap();
+            let server_ca = std::fs::read_to_string("examples/data/ca.pem").unwrap();
+
+            let tls_config = ClientTlsConfig::new()
+                .domain_name("localhost")
+                .ca_certificate(Certificate::from_pem(&server_ca))
+                .identity(Identity::from_pem(cert, key));
+
+            let endpoint = endpoint(uri).unwrap().tls_config(tls_config).unwrap();
+            let channel = endpoint.connect().await.unwrap();
+            let client = FlightSqlServiceClient::new(channel);
+            f(client).await
+        };
+
+        tokio::select! {
+            _ = serve_future => panic!("server returned first"),
+            _ = request_future => println!("Client finished!"),
+        }
+    }
+
+    async fn test_all_clients<F, C>(task: F)
+    where
+        F: FnOnce(FlightSqlServiceClient<Channel>) -> C + Copy,
+        C: Future<Output = ()>,
+    {
+        println!("testing uds client");
+        test_uds_client(task).await;
+        println!("=======");
+
+        println!("testing http client");
+        test_http_client(task).await;
+        println!("=======");
+
+        println!("testing https client");
+        test_https_client(task).await;
+        println!("=======");
+    }
+
+    #[tokio::test]
+    async fn test_select() {
+        test_all_clients(|mut client| async move {
+            auth_client(&mut client).await;
+
+            let mut stmt = client.prepare("select 1;".to_string(), None).await.unwrap();
+
+            let flight_info = stmt.execute().await.unwrap();
+
+            let ticket = flight_info.endpoint[0].ticket.as_ref().unwrap().clone();
+            let flight_data = client.do_get(ticket).await.unwrap();
+            let batches: Vec<_> = flight_data.try_collect().await.unwrap();
+
+            let res = pretty_format_batches(batches.as_slice()).unwrap();
+            let expected = r#"
++-------------------+
+| salutation        |
++-------------------+
+| Hello, FlightSQL! |
++-------------------+"#
+                .trim()
+                .to_string();
+            assert_eq!(res.to_string(), expected);
+        })
+        .await
+    }
+
+    #[tokio::test]
+    async fn test_execute_update() {
+        test_all_clients(|mut client| async move {
+            auth_client(&mut client).await;
+            let res = client
+                .execute_update("creat table test(a int);".to_string(), None)
+                .await
+                .unwrap();
+            assert_eq!(res, FAKE_UPDATE_RESULT);
+        })
+        .await
+    }
+
+    #[tokio::test]
+    async fn test_auth() {
+        test_all_clients(|mut client| async move {
+            // no handshake
+            assert!(client
+                .prepare("select 1;".to_string(), None)
+                .await
+                .unwrap_err()
+                .to_string()
+                .contains("No authorization header"));
+
+            // Invalid credentials
+            assert!(client
+                .handshake("admin", "password2")
+                .await
+                .unwrap_err()
+                .to_string()
+                .contains("Invalid credentials"));
+
+            // forget to set_token
+            client.handshake("admin", "password").await.unwrap();
+            assert!(client
+                .prepare("select 1;".to_string(), None)
+                .await
+                .unwrap_err()
+                .to_string()
+                .contains("No authorization header"));
+
+            // Invalid Tokens
+            client.handshake("admin", "password").await.unwrap();
+            client.set_token("wrong token".to_string());
+            assert!(client
+                .prepare("select 1;".to_string(), None)
+                .await
+                .unwrap_err()
+                .to_string()
+                .contains("invalid token"));
+        })
+        .await
+    }
+}
diff --git a/arrow-flight/examples/server.rs b/arrow-flight/examples/server.rs
index 75d05378710f..8c766b075957 100644
--- a/arrow-flight/examples/server.rs
+++ b/arrow-flight/examples/server.rs
@@ -15,16 +15,14 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::pin::Pin;
-
-use futures::Stream;
+use futures::stream::BoxStream;
 use tonic::transport::Server;
 use tonic::{Request, Response, Status, Streaming};
 
 use arrow_flight::{
-    flight_service_server::FlightService, flight_service_server::FlightServiceServer,
-    Action, ActionType, Criteria, Empty, FlightData, FlightDescriptor, FlightInfo,
-    HandshakeRequest, HandshakeResponse, PutResult, SchemaResult, Ticket,
+    flight_service_server::FlightService, flight_service_server::FlightServiceServer, Action,
+    ActionType, Criteria, Empty, FlightData, FlightDescriptor, FlightInfo, HandshakeRequest,
+    HandshakeResponse, PollInfo, PutResult, SchemaResult, Ticket,
 };
 
 #[derive(Clone)]
@@ -32,89 +30,82 @@ pub struct FlightServiceImpl {}
 
 #[tonic::async_trait]
 impl FlightService for FlightServiceImpl {
-    type HandshakeStream = Pin<
-        Box<dyn Stream<Item = Result<HandshakeResponse, Status>> + Send + Sync + 'static>,
-    >;
-    type ListFlightsStream =
-        Pin<Box<dyn Stream<Item = Result<FlightInfo, Status>> + Send + Sync + 'static>>;
-    type DoGetStream =
-        Pin<Box<dyn Stream<Item = Result<FlightData, Status>> + Send + Sync + 'static>>;
-    type DoPutStream =
-        Pin<Box<dyn Stream<Item = Result<PutResult, Status>> + Send + Sync + 'static>>;
-    type DoActionStream = Pin<
-        Box<
-            dyn Stream<Item = Result<arrow_flight::Result, Status>>
-                + Send
-                + Sync
-                + 'static,
-        >,
-    >;
-    type ListActionsStream =
-        Pin<Box<dyn Stream<Item = Result<ActionType, Status>> + Send + Sync + 'static>>;
-    type DoExchangeStream =
-        Pin<Box<dyn Stream<Item = Result<FlightData, Status>> + Send + Sync + 'static>>;
+    type HandshakeStream = BoxStream<'static, Result<HandshakeResponse, Status>>;
+    type ListFlightsStream = BoxStream<'static, Result<FlightInfo, Status>>;
+    type DoGetStream = BoxStream<'static, Result<FlightData, Status>>;
+    type DoPutStream = BoxStream<'static, Result<PutResult, Status>>;
+    type DoActionStream = BoxStream<'static, Result<arrow_flight::Result, Status>>;
+    type ListActionsStream = BoxStream<'static, Result<ActionType, Status>>;
+    type DoExchangeStream = BoxStream<'static, Result<FlightData, Status>>;
 
     async fn handshake(
         &self,
         _request: Request<Streaming<HandshakeRequest>>,
     ) -> Result<Response<Self::HandshakeStream>, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        Err(Status::unimplemented("Implement handshake"))
     }
 
     async fn list_flights(
         &self,
         _request: Request<Criteria>,
     ) -> Result<Response<Self::ListFlightsStream>, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        Err(Status::unimplemented("Implement list_flights"))
     }
 
     async fn get_flight_info(
         &self,
         _request: Request<FlightDescriptor>,
     ) -> Result<Response<FlightInfo>, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        Err(Status::unimplemented("Implement get_flight_info"))
+    }
+
+    async fn poll_flight_info(
+        &self,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<PollInfo>, Status> {
+        Err(Status::unimplemented("Implement poll_flight_info"))
     }
 
     async fn get_schema(
         &self,
         _request: Request<FlightDescriptor>,
     ) -> Result<Response<SchemaResult>, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        Err(Status::unimplemented("Implement get_schema"))
     }
 
     async fn do_get(
         &self,
         _request: Request<Ticket>,
     ) -> Result<Response<Self::DoGetStream>, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        Err(Status::unimplemented("Implement do_get"))
     }
 
     async fn do_put(
         &self,
         _request: Request<Streaming<FlightData>>,
     ) -> Result<Response<Self::DoPutStream>, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        Err(Status::unimplemented("Implement do_put"))
     }
 
     async fn do_action(
         &self,
         _request: Request<Action>,
     ) -> Result<Response<Self::DoActionStream>, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        Err(Status::unimplemented("Implement do_action"))
     }
 
     async fn list_actions(
         &self,
         _request: Request<Empty>,
     ) -> Result<Response<Self::ListActionsStream>, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        Err(Status::unimplemented("Implement list_actions"))
     }
 
     async fn do_exchange(
         &self,
         _request: Request<Streaming<FlightData>>,
     ) -> Result<Response<Self::DoExchangeStream>, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        Err(Status::unimplemented("Implement do_exchange"))
     }
 }
 
diff --git a/arrow-flight/gen/Cargo.toml b/arrow-flight/gen/Cargo.toml
new file mode 100644
index 000000000000..2902b215c845
--- /dev/null
+++ b/arrow-flight/gen/Cargo.toml
@@ -0,0 +1,37 @@
+# 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]
+name = "gen"
+description = "Code generation for arrow-flight"
+version = "0.1.0"
+edition = { workspace = true }
+rust-version = { workspace = true }
+authors = { workspace = true }
+homepage = { workspace = true }
+repository = { workspace = true }
+license = { workspace = true }
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+# Pin specific version of the tonic-build dependencies to avoid auto-generated
+# (and checked in) arrow.flight.protocol.rs from changing
+proc-macro2 = { version = "=1.0.78", default-features = false }
+prost-build = { version = "=0.12.3", default-features = false }
+tonic-build = { version = "=0.11.0", default-features = false, features = ["transport", "prost"] }
diff --git a/arrow-flight/gen/src/main.rs b/arrow-flight/gen/src/main.rs
new file mode 100644
index 000000000000..a3541c63b173
--- /dev/null
+++ b/arrow-flight/gen/src/main.rs
@@ -0,0 +1,86 @@
+// 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.
+
+use std::{
+    fs::OpenOptions,
+    io::{Read, Write},
+    path::Path,
+};
+
+fn main() -> Result<(), Box<dyn std::error::Error>> {
+    let proto_dir = Path::new("../format");
+    let proto_path = Path::new("../format/Flight.proto");
+
+    tonic_build::configure()
+        // protoc in unbuntu builder needs this option
+        .protoc_arg("--experimental_allow_proto3_optional")
+        .out_dir("src")
+        .compile_with_config(prost_config(), &[proto_path], &[proto_dir])?;
+
+    // read file contents to string
+    let mut file = OpenOptions::new()
+        .read(true)
+        .open("src/arrow.flight.protocol.rs")?;
+    let mut buffer = String::new();
+    file.read_to_string(&mut buffer)?;
+    // append warning that file was auto-generate
+    let mut file = OpenOptions::new()
+        .write(true)
+        .truncate(true)
+        .open("src/arrow.flight.protocol.rs")?;
+    file.write_all("// This file was automatically generated through the build.rs script, and should not be edited.\n\n".as_bytes())?;
+    file.write_all(buffer.as_bytes())?;
+
+    let proto_dir = Path::new("../format");
+    let proto_path = Path::new("../format/FlightSql.proto");
+
+    tonic_build::configure()
+        // protoc in ubuntu builder needs this option
+        .protoc_arg("--experimental_allow_proto3_optional")
+        .out_dir("src/sql")
+        .compile_with_config(prost_config(), &[proto_path], &[proto_dir])?;
+
+    // read file contents to string
+    let mut file = OpenOptions::new()
+        .read(true)
+        .open("src/sql/arrow.flight.protocol.sql.rs")?;
+    let mut buffer = String::new();
+    file.read_to_string(&mut buffer)?;
+    // append warning that file was auto-generate
+    let mut file = OpenOptions::new()
+        .write(true)
+        .truncate(true)
+        .open("src/sql/arrow.flight.protocol.sql.rs")?;
+    file.write_all("// This file was automatically generated through the build.rs script, and should not be edited.\n\n".as_bytes())?;
+    file.write_all(buffer.as_bytes())?;
+
+    // Prost currently generates an empty file, this was fixed but then reverted
+    // https://github.com/tokio-rs/prost/pull/639
+    let google_protobuf_rs = Path::new("src/sql/google.protobuf.rs");
+    if google_protobuf_rs.exists() && google_protobuf_rs.metadata().unwrap().len() == 0 {
+        std::fs::remove_file(google_protobuf_rs).unwrap();
+    }
+
+    // As the proto file is checked in, the build should not fail if the file is not found
+    Ok(())
+}
+
+fn prost_config() -> prost_build::Config {
+    let mut config = prost_build::Config::new();
+    config.bytes([".arrow"]);
+    config
+}
diff --git a/arrow-flight/regen.sh b/arrow-flight/regen.sh
new file mode 100755
index 000000000000..d83f9d580e8d
--- /dev/null
+++ b/arrow-flight/regen.sh
@@ -0,0 +1,21 @@
+#!/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.
+
+SCRIPT_DIR=$( cd -- "$( dirname -- "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )
+cd $SCRIPT_DIR && cargo run --manifest-path gen/Cargo.toml
diff --git a/arrow-flight/src/arrow.flight.protocol.rs b/arrow-flight/src/arrow.flight.protocol.rs
index 2b085d6d1f6b..67265e781786 100644
--- a/arrow-flight/src/arrow.flight.protocol.rs
+++ b/arrow-flight/src/arrow.flight.protocol.rs
@@ -1,117 +1,169 @@
 // This file was automatically generated through the build.rs script, and should not be edited.
 
 ///
-///  The request that a client provides to a server on handshake.
+/// The request that a client provides to a server on handshake.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct HandshakeRequest {
     ///
-    ///  A defined protocol version
-    #[prost(uint64, tag="1")]
+    /// A defined protocol version
+    #[prost(uint64, tag = "1")]
     pub protocol_version: u64,
     ///
-    ///  Arbitrary auth/handshake info.
-    #[prost(bytes="vec", tag="2")]
-    pub payload: ::prost::alloc::vec::Vec<u8>,
+    /// Arbitrary auth/handshake info.
+    #[prost(bytes = "bytes", tag = "2")]
+    pub payload: ::prost::bytes::Bytes,
 }
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct HandshakeResponse {
     ///
-    ///  A defined protocol version
-    #[prost(uint64, tag="1")]
+    /// A defined protocol version
+    #[prost(uint64, tag = "1")]
     pub protocol_version: u64,
     ///
-    ///  Arbitrary auth/handshake info.
-    #[prost(bytes="vec", tag="2")]
-    pub payload: ::prost::alloc::vec::Vec<u8>,
+    /// Arbitrary auth/handshake info.
+    #[prost(bytes = "bytes", tag = "2")]
+    pub payload: ::prost::bytes::Bytes,
 }
 ///
-///  A message for doing simple auth.
+/// A message for doing simple auth.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct BasicAuth {
-    #[prost(string, tag="2")]
+    #[prost(string, tag = "2")]
     pub username: ::prost::alloc::string::String,
-    #[prost(string, tag="3")]
+    #[prost(string, tag = "3")]
     pub password: ::prost::alloc::string::String,
 }
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct Empty {
-}
+pub struct Empty {}
 ///
-///  Describes an available action, including both the name used for execution
-///  along with a short description of the purpose of the action.
+/// Describes an available action, including both the name used for execution
+/// along with a short description of the purpose of the action.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ActionType {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub r#type: ::prost::alloc::string::String,
-    #[prost(string, tag="2")]
+    #[prost(string, tag = "2")]
     pub description: ::prost::alloc::string::String,
 }
 ///
-///  A service specific expression that can be used to return a limited set
-///  of available Arrow Flight streams.
+/// A service specific expression that can be used to return a limited set
+/// of available Arrow Flight streams.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Criteria {
-    #[prost(bytes="vec", tag="1")]
-    pub expression: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "1")]
+    pub expression: ::prost::bytes::Bytes,
 }
 ///
-///  An opaque action specific for the service.
+/// An opaque action specific for the service.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Action {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub r#type: ::prost::alloc::string::String,
-    #[prost(bytes="vec", tag="2")]
-    pub body: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "2")]
+    pub body: ::prost::bytes::Bytes,
+}
+///
+/// The request of the CancelFlightInfo action.
+///
+/// The request should be stored in Action.body.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CancelFlightInfoRequest {
+    #[prost(message, optional, tag = "1")]
+    pub info: ::core::option::Option<FlightInfo>,
+}
+///
+/// The request of the RenewFlightEndpoint action.
+///
+/// The request should be stored in Action.body.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct RenewFlightEndpointRequest {
+    #[prost(message, optional, tag = "1")]
+    pub endpoint: ::core::option::Option<FlightEndpoint>,
 }
 ///
-///  An opaque result returned after executing an action.
+/// An opaque result returned after executing an action.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Result {
-    #[prost(bytes="vec", tag="1")]
-    pub body: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "1")]
+    pub body: ::prost::bytes::Bytes,
 }
 ///
-///  Wrap the result of a getSchema call
+/// The result of the CancelFlightInfo action.
+///
+/// The result should be stored in Result.body.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CancelFlightInfoResult {
+    #[prost(enumeration = "CancelStatus", tag = "1")]
+    pub status: i32,
+}
+///
+/// Wrap the result of a getSchema call
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct SchemaResult {
-    ///  schema of the dataset as described in Schema.fbs::Schema.
-    #[prost(bytes="vec", tag="1")]
-    pub schema: ::prost::alloc::vec::Vec<u8>,
+    /// The schema of the dataset in its IPC form:
+    ///    4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+    ///    4 bytes - the byte length of the payload
+    ///    a flatbuffer Message whose header is the Schema
+    #[prost(bytes = "bytes", tag = "1")]
+    pub schema: ::prost::bytes::Bytes,
 }
 ///
-///  The name or tag for a Flight. May be used as a way to retrieve or generate
-///  a flight or be used to expose a set of previously defined flights.
+/// The name or tag for a Flight. May be used as a way to retrieve or generate
+/// a flight or be used to expose a set of previously defined flights.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FlightDescriptor {
-    #[prost(enumeration="flight_descriptor::DescriptorType", tag="1")]
+    #[prost(enumeration = "flight_descriptor::DescriptorType", tag = "1")]
     pub r#type: i32,
     ///
-    ///  Opaque value used to express a command. Should only be defined when
-    ///  type = CMD.
-    #[prost(bytes="vec", tag="2")]
-    pub cmd: ::prost::alloc::vec::Vec<u8>,
+    /// Opaque value used to express a command. Should only be defined when
+    /// type = CMD.
+    #[prost(bytes = "bytes", tag = "2")]
+    pub cmd: ::prost::bytes::Bytes,
     ///
-    ///  List of strings identifying a particular dataset. Should only be defined
-    ///  when type = PATH.
-    #[prost(string, repeated, tag="3")]
+    /// List of strings identifying a particular dataset. Should only be defined
+    /// when type = PATH.
+    #[prost(string, repeated, tag = "3")]
     pub path: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
 }
 /// Nested message and enum types in `FlightDescriptor`.
 pub mod flight_descriptor {
     ///
-    ///  Describes what type of descriptor is defined.
-    #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+    /// Describes what type of descriptor is defined.
+    #[derive(
+        Clone,
+        Copy,
+        Debug,
+        PartialEq,
+        Eq,
+        Hash,
+        PartialOrd,
+        Ord,
+        ::prost::Enumeration
+    )]
     #[repr(i32)]
     pub enum DescriptorType {
-        ///  Protobuf pattern, not used.
+        /// Protobuf pattern, not used.
         Unknown = 0,
         ///
-        ///  A named path that identifies a dataset. A path is composed of a string
-        ///  or list of strings describing a particular dataset. This is conceptually
+        /// A named path that identifies a dataset. A path is composed of a string
+        /// or list of strings describing a particular dataset. This is conceptually
         ///   similar to a path inside a filesystem.
         Path = 1,
         ///
-        ///  An opaque command to generate a dataset.
+        /// An opaque command to generate a dataset.
         Cmd = 2,
     }
     impl DescriptorType {
@@ -126,93 +178,261 @@ pub mod flight_descriptor {
                 DescriptorType::Cmd => "CMD",
             }
         }
+        /// Creates an enum from field names used in the ProtoBuf definition.
+        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+            match value {
+                "UNKNOWN" => Some(Self::Unknown),
+                "PATH" => Some(Self::Path),
+                "CMD" => Some(Self::Cmd),
+                _ => None,
+            }
+        }
     }
 }
 ///
-///  The access coordinates for retrieval of a dataset. With a FlightInfo, a
-///  consumer is able to determine how to retrieve a dataset.
+/// The access coordinates for retrieval of a dataset. With a FlightInfo, a
+/// consumer is able to determine how to retrieve a dataset.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FlightInfo {
-    ///  schema of the dataset as described in Schema.fbs::Schema.
-    #[prost(bytes="vec", tag="1")]
-    pub schema: ::prost::alloc::vec::Vec<u8>,
+    /// The schema of the dataset in its IPC form:
+    ///    4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+    ///    4 bytes - the byte length of the payload
+    ///    a flatbuffer Message whose header is the Schema
+    #[prost(bytes = "bytes", tag = "1")]
+    pub schema: ::prost::bytes::Bytes,
     ///
-    ///  The descriptor associated with this info.
-    #[prost(message, optional, tag="2")]
+    /// The descriptor associated with this info.
+    #[prost(message, optional, tag = "2")]
     pub flight_descriptor: ::core::option::Option<FlightDescriptor>,
     ///
-    ///  A list of endpoints associated with the flight. To consume the whole
-    ///  flight, all endpoints must be consumed.
-    #[prost(message, repeated, tag="3")]
+    /// A list of endpoints associated with the flight. To consume the
+    /// whole flight, all endpoints (and hence all Tickets) must be
+    /// consumed. Endpoints can be consumed in any order.
+    ///
+    /// In other words, an application can use multiple endpoints to
+    /// represent partitioned data.
+    ///
+    /// If the returned data has an ordering, an application can use
+    /// "FlightInfo.ordered = true" or should return the all data in a
+    /// single endpoint. Otherwise, there is no ordering defined on
+    /// endpoints or the data within.
+    ///
+    /// A client can read ordered data by reading data from returned
+    /// endpoints, in order, from front to back.
+    ///
+    /// Note that a client may ignore "FlightInfo.ordered = true". If an
+    /// ordering is important for an application, an application must
+    /// choose one of them:
+    ///
+    /// * An application requires that all clients must read data in
+    ///    returned endpoints order.
+    /// * An application must return the all data in a single endpoint.
+    #[prost(message, repeated, tag = "3")]
     pub endpoint: ::prost::alloc::vec::Vec<FlightEndpoint>,
-    ///  Set these to -1 if unknown.
-    #[prost(int64, tag="4")]
+    /// Set these to -1 if unknown.
+    #[prost(int64, tag = "4")]
     pub total_records: i64,
-    #[prost(int64, tag="5")]
+    #[prost(int64, tag = "5")]
     pub total_bytes: i64,
+    ///
+    /// FlightEndpoints are in the same order as the data.
+    #[prost(bool, tag = "6")]
+    pub ordered: bool,
+    ///
+    /// Application-defined metadata.
+    ///
+    /// There is no inherent or required relationship between this
+    /// and the app_metadata fields in the FlightEndpoints or resulting
+    /// FlightData messages. Since this metadata is application-defined,
+    /// a given application could define there to be a relationship,
+    /// but there is none required by the spec.
+    #[prost(bytes = "bytes", tag = "7")]
+    pub app_metadata: ::prost::bytes::Bytes,
+}
+///
+/// The information to process a long-running query.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct PollInfo {
+    ///
+    /// The currently available results.
+    ///
+    /// If "flight_descriptor" is not specified, the query is complete
+    /// and "info" specifies all results. Otherwise, "info" contains
+    /// partial query results.
+    ///
+    /// Note that each PollInfo response contains a complete
+    /// FlightInfo (not just the delta between the previous and current
+    /// FlightInfo).
+    ///
+    /// Subsequent PollInfo responses may only append new endpoints to
+    /// info.
+    ///
+    /// Clients can begin fetching results via DoGet(Ticket) with the
+    /// ticket in the info before the query is
+    /// completed. FlightInfo.ordered is also valid.
+    #[prost(message, optional, tag = "1")]
+    pub info: ::core::option::Option<FlightInfo>,
+    ///
+    /// The descriptor the client should use on the next try.
+    /// If unset, the query is complete.
+    #[prost(message, optional, tag = "2")]
+    pub flight_descriptor: ::core::option::Option<FlightDescriptor>,
+    ///
+    /// Query progress. If known, must be in \[0.0, 1.0\] but need not be
+    /// monotonic or nondecreasing. If unknown, do not set.
+    #[prost(double, optional, tag = "3")]
+    pub progress: ::core::option::Option<f64>,
+    ///
+    /// Expiration time for this request. After this passes, the server
+    /// might not accept the retry descriptor anymore (and the query may
+    /// be cancelled). This may be updated on a call to PollFlightInfo.
+    #[prost(message, optional, tag = "4")]
+    pub expiration_time: ::core::option::Option<::prost_types::Timestamp>,
 }
 ///
-///  A particular stream or split associated with a flight.
+/// A particular stream or split associated with a flight.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FlightEndpoint {
     ///
-    ///  Token used to retrieve this stream.
-    #[prost(message, optional, tag="1")]
+    /// Token used to retrieve this stream.
+    #[prost(message, optional, tag = "1")]
     pub ticket: ::core::option::Option<Ticket>,
     ///
-    ///  A list of URIs where this ticket can be redeemed. If the list is
-    ///  empty, the expectation is that the ticket can only be redeemed on the
-    ///  current service where the ticket was generated.
-    #[prost(message, repeated, tag="2")]
+    /// A list of URIs where this ticket can be redeemed via DoGet().
+    ///
+    /// If the list is empty, the expectation is that the ticket can only
+    /// be redeemed on the current service where the ticket was
+    /// generated.
+    ///
+    /// If the list is not empty, the expectation is that the ticket can
+    /// be redeemed at any of the locations, and that the data returned
+    /// will be equivalent. In this case, the ticket may only be redeemed
+    /// at one of the given locations, and not (necessarily) on the
+    /// current service.
+    ///
+    /// In other words, an application can use multiple locations to
+    /// represent redundant and/or load balanced services.
+    #[prost(message, repeated, tag = "2")]
     pub location: ::prost::alloc::vec::Vec<Location>,
+    ///
+    /// Expiration time of this stream. If present, clients may assume
+    /// they can retry DoGet requests. Otherwise, it is
+    /// application-defined whether DoGet requests may be retried.
+    #[prost(message, optional, tag = "3")]
+    pub expiration_time: ::core::option::Option<::prost_types::Timestamp>,
+    ///
+    /// Application-defined metadata.
+    ///
+    /// There is no inherent or required relationship between this
+    /// and the app_metadata fields in the FlightInfo or resulting
+    /// FlightData messages. Since this metadata is application-defined,
+    /// a given application could define there to be a relationship,
+    /// but there is none required by the spec.
+    #[prost(bytes = "bytes", tag = "4")]
+    pub app_metadata: ::prost::bytes::Bytes,
 }
 ///
-///  A location where a Flight service will accept retrieval of a particular
-///  stream given a ticket.
+/// A location where a Flight service will accept retrieval of a particular
+/// stream given a ticket.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Location {
-    #[prost(string, tag="1")]
+    #[prost(string, tag = "1")]
     pub uri: ::prost::alloc::string::String,
 }
 ///
-///  An opaque identifier that the service can use to retrieve a particular
-///  portion of a stream.
+/// An opaque identifier that the service can use to retrieve a particular
+/// portion of a stream.
+///
+/// Tickets are meant to be single use. It is an error/application-defined
+/// behavior to reuse a ticket.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct Ticket {
-    #[prost(bytes="vec", tag="1")]
-    pub ticket: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "1")]
+    pub ticket: ::prost::bytes::Bytes,
 }
 ///
-///  A batch of Arrow data as part of a stream of batches.
+/// A batch of Arrow data as part of a stream of batches.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct FlightData {
     ///
-    ///  The descriptor of the data. This is only relevant when a client is
-    ///  starting a new DoPut stream.
-    #[prost(message, optional, tag="1")]
+    /// The descriptor of the data. This is only relevant when a client is
+    /// starting a new DoPut stream.
+    #[prost(message, optional, tag = "1")]
     pub flight_descriptor: ::core::option::Option<FlightDescriptor>,
     ///
-    ///  Header for message data as described in Message.fbs::Message.
-    #[prost(bytes="vec", tag="2")]
-    pub data_header: ::prost::alloc::vec::Vec<u8>,
+    /// Header for message data as described in Message.fbs::Message.
+    #[prost(bytes = "bytes", tag = "2")]
+    pub data_header: ::prost::bytes::Bytes,
     ///
-    ///  Application-defined metadata.
-    #[prost(bytes="vec", tag="3")]
-    pub app_metadata: ::prost::alloc::vec::Vec<u8>,
+    /// Application-defined metadata.
+    #[prost(bytes = "bytes", tag = "3")]
+    pub app_metadata: ::prost::bytes::Bytes,
     ///
-    ///  The actual batch of Arrow data. Preferably handled with minimal-copies
-    ///  coming last in the definition to help with sidecar patterns (it is
-    ///  expected that some implementations will fetch this field off the wire
-    ///  with specialized code to avoid extra memory copies).
-    #[prost(bytes="vec", tag="1000")]
-    pub data_body: ::prost::alloc::vec::Vec<u8>,
+    /// The actual batch of Arrow data. Preferably handled with minimal-copies
+    /// coming last in the definition to help with sidecar patterns (it is
+    /// expected that some implementations will fetch this field off the wire
+    /// with specialized code to avoid extra memory copies).
+    #[prost(bytes = "bytes", tag = "1000")]
+    pub data_body: ::prost::bytes::Bytes,
 }
 /// *
-///  The response message associated with the submission of a DoPut.
+/// The response message associated with the submission of a DoPut.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct PutResult {
-    #[prost(bytes="vec", tag="1")]
-    pub app_metadata: ::prost::alloc::vec::Vec<u8>,
+    #[prost(bytes = "bytes", tag = "1")]
+    pub app_metadata: ::prost::bytes::Bytes,
+}
+///
+/// The result of a cancel operation.
+///
+/// This is used by CancelFlightInfoResult.status.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum CancelStatus {
+    /// The cancellation status is unknown. Servers should avoid using
+    /// this value (send a NOT_FOUND error if the requested query is
+    /// not known). Clients can retry the request.
+    Unspecified = 0,
+    /// The cancellation request is complete. Subsequent requests with
+    /// the same payload may return CANCELLED or a NOT_FOUND error.
+    Cancelled = 1,
+    /// The cancellation request is in progress. The client may retry
+    /// the cancellation request.
+    Cancelling = 2,
+    /// The query is not cancellable. The client should not retry the
+    /// cancellation request.
+    NotCancellable = 3,
+}
+impl CancelStatus {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            CancelStatus::Unspecified => "CANCEL_STATUS_UNSPECIFIED",
+            CancelStatus::Cancelled => "CANCEL_STATUS_CANCELLED",
+            CancelStatus::Cancelling => "CANCEL_STATUS_CANCELLING",
+            CancelStatus::NotCancellable => "CANCEL_STATUS_NOT_CANCELLABLE",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "CANCEL_STATUS_UNSPECIFIED" => Some(Self::Unspecified),
+            "CANCEL_STATUS_CANCELLED" => Some(Self::Cancelled),
+            "CANCEL_STATUS_CANCELLING" => Some(Self::Cancelling),
+            "CANCEL_STATUS_NOT_CANCELLABLE" => Some(Self::NotCancellable),
+            _ => None,
+        }
+    }
 }
 /// Generated client implementations.
 pub mod flight_service_client {
@@ -232,7 +452,7 @@ pub mod flight_service_client {
         /// Attempt to create a new client by connecting to a given endpoint.
         pub async fn connect<D>(dst: D) -> Result<Self, tonic::transport::Error>
         where
-            D: std::convert::TryInto<tonic::transport::Endpoint>,
+            D: TryInto<tonic::transport::Endpoint>,
             D::Error: Into<StdError>,
         {
             let conn = tonic::transport::Endpoint::new(dst)?.connect().await?;
@@ -288,6 +508,22 @@ pub mod flight_service_client {
             self.inner = self.inner.accept_compressed(encoding);
             self
         }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_decoding_message_size(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.inner = self.inner.max_encoding_message_size(limit);
+            self
+        }
         ///
         /// Handshake between client and server. Depending on the server, the
         /// handshake may be required to determine the token that should be used for
@@ -296,7 +532,7 @@ pub mod flight_service_client {
         pub async fn handshake(
             &mut self,
             request: impl tonic::IntoStreamingRequest<Message = super::HandshakeRequest>,
-        ) -> Result<
+        ) -> std::result::Result<
             tonic::Response<tonic::codec::Streaming<super::HandshakeResponse>>,
             tonic::Status,
         > {
@@ -313,7 +549,12 @@ pub mod flight_service_client {
             let path = http::uri::PathAndQuery::from_static(
                 "/arrow.flight.protocol.FlightService/Handshake",
             );
-            self.inner.streaming(request.into_streaming_request(), path, codec).await
+            let mut req = request.into_streaming_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("arrow.flight.protocol.FlightService", "Handshake"),
+                );
+            self.inner.streaming(req, path, codec).await
         }
         ///
         /// Get a list of available streams given a particular criteria. Most flight
@@ -325,7 +566,7 @@ pub mod flight_service_client {
         pub async fn list_flights(
             &mut self,
             request: impl tonic::IntoRequest<super::Criteria>,
-        ) -> Result<
+        ) -> std::result::Result<
             tonic::Response<tonic::codec::Streaming<super::FlightInfo>>,
             tonic::Status,
         > {
@@ -342,7 +583,12 @@ pub mod flight_service_client {
             let path = http::uri::PathAndQuery::from_static(
                 "/arrow.flight.protocol.FlightService/ListFlights",
             );
-            self.inner.server_streaming(request.into_request(), path, codec).await
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("arrow.flight.protocol.FlightService", "ListFlights"),
+                );
+            self.inner.server_streaming(req, path, codec).await
         }
         ///
         /// For a given FlightDescriptor, get information about how the flight can be
@@ -358,7 +604,7 @@ pub mod flight_service_client {
         pub async fn get_flight_info(
             &mut self,
             request: impl tonic::IntoRequest<super::FlightDescriptor>,
-        ) -> Result<tonic::Response<super::FlightInfo>, tonic::Status> {
+        ) -> std::result::Result<tonic::Response<super::FlightInfo>, tonic::Status> {
             self.inner
                 .ready()
                 .await
@@ -372,7 +618,65 @@ pub mod flight_service_client {
             let path = http::uri::PathAndQuery::from_static(
                 "/arrow.flight.protocol.FlightService/GetFlightInfo",
             );
-            self.inner.unary(request.into_request(), path, codec).await
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "arrow.flight.protocol.FlightService",
+                        "GetFlightInfo",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
+        }
+        ///
+        /// For a given FlightDescriptor, start a query and get information
+        /// to poll its execution status. This is a useful interface if the
+        /// query may be a long-running query. The first PollFlightInfo call
+        /// should return as quickly as possible. (GetFlightInfo doesn't
+        /// return until the query is complete.)
+        ///
+        /// A client can consume any available results before
+        /// the query is completed. See PollInfo.info for details.
+        ///
+        /// A client can poll the updated query status by calling
+        /// PollFlightInfo() with PollInfo.flight_descriptor. A server
+        /// should not respond until the result would be different from last
+        /// time. That way, the client can "long poll" for updates
+        /// without constantly making requests. Clients can set a short timeout
+        /// to avoid blocking calls if desired.
+        ///
+        /// A client can't use PollInfo.flight_descriptor after
+        /// PollInfo.expiration_time passes. A server might not accept the
+        /// retry descriptor anymore and the query may be cancelled.
+        ///
+        /// A client may use the CancelFlightInfo action with
+        /// PollInfo.info to cancel the running query.
+        pub async fn poll_flight_info(
+            &mut self,
+            request: impl tonic::IntoRequest<super::FlightDescriptor>,
+        ) -> std::result::Result<tonic::Response<super::PollInfo>, tonic::Status> {
+            self.inner
+                .ready()
+                .await
+                .map_err(|e| {
+                    tonic::Status::new(
+                        tonic::Code::Unknown,
+                        format!("Service was not ready: {}", e.into()),
+                    )
+                })?;
+            let codec = tonic::codec::ProstCodec::default();
+            let path = http::uri::PathAndQuery::from_static(
+                "/arrow.flight.protocol.FlightService/PollFlightInfo",
+            );
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new(
+                        "arrow.flight.protocol.FlightService",
+                        "PollFlightInfo",
+                    ),
+                );
+            self.inner.unary(req, path, codec).await
         }
         ///
         /// For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
@@ -382,7 +686,7 @@ pub mod flight_service_client {
         pub async fn get_schema(
             &mut self,
             request: impl tonic::IntoRequest<super::FlightDescriptor>,
-        ) -> Result<tonic::Response<super::SchemaResult>, tonic::Status> {
+        ) -> std::result::Result<tonic::Response<super::SchemaResult>, tonic::Status> {
             self.inner
                 .ready()
                 .await
@@ -396,7 +700,12 @@ pub mod flight_service_client {
             let path = http::uri::PathAndQuery::from_static(
                 "/arrow.flight.protocol.FlightService/GetSchema",
             );
-            self.inner.unary(request.into_request(), path, codec).await
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("arrow.flight.protocol.FlightService", "GetSchema"),
+                );
+            self.inner.unary(req, path, codec).await
         }
         ///
         /// Retrieve a single stream associated with a particular descriptor
@@ -406,7 +715,7 @@ pub mod flight_service_client {
         pub async fn do_get(
             &mut self,
             request: impl tonic::IntoRequest<super::Ticket>,
-        ) -> Result<
+        ) -> std::result::Result<
             tonic::Response<tonic::codec::Streaming<super::FlightData>>,
             tonic::Status,
         > {
@@ -423,7 +732,10 @@ pub mod flight_service_client {
             let path = http::uri::PathAndQuery::from_static(
                 "/arrow.flight.protocol.FlightService/DoGet",
             );
-            self.inner.server_streaming(request.into_request(), path, codec).await
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("arrow.flight.protocol.FlightService", "DoGet"));
+            self.inner.server_streaming(req, path, codec).await
         }
         ///
         /// Push a stream to the flight service associated with a particular
@@ -435,7 +747,7 @@ pub mod flight_service_client {
         pub async fn do_put(
             &mut self,
             request: impl tonic::IntoStreamingRequest<Message = super::FlightData>,
-        ) -> Result<
+        ) -> std::result::Result<
             tonic::Response<tonic::codec::Streaming<super::PutResult>>,
             tonic::Status,
         > {
@@ -452,7 +764,10 @@ pub mod flight_service_client {
             let path = http::uri::PathAndQuery::from_static(
                 "/arrow.flight.protocol.FlightService/DoPut",
             );
-            self.inner.streaming(request.into_streaming_request(), path, codec).await
+            let mut req = request.into_streaming_request();
+            req.extensions_mut()
+                .insert(GrpcMethod::new("arrow.flight.protocol.FlightService", "DoPut"));
+            self.inner.streaming(req, path, codec).await
         }
         ///
         /// Open a bidirectional data channel for a given descriptor. This
@@ -463,7 +778,7 @@ pub mod flight_service_client {
         pub async fn do_exchange(
             &mut self,
             request: impl tonic::IntoStreamingRequest<Message = super::FlightData>,
-        ) -> Result<
+        ) -> std::result::Result<
             tonic::Response<tonic::codec::Streaming<super::FlightData>>,
             tonic::Status,
         > {
@@ -480,7 +795,12 @@ pub mod flight_service_client {
             let path = http::uri::PathAndQuery::from_static(
                 "/arrow.flight.protocol.FlightService/DoExchange",
             );
-            self.inner.streaming(request.into_streaming_request(), path, codec).await
+            let mut req = request.into_streaming_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("arrow.flight.protocol.FlightService", "DoExchange"),
+                );
+            self.inner.streaming(req, path, codec).await
         }
         ///
         /// Flight services can support an arbitrary number of simple actions in
@@ -492,7 +812,7 @@ pub mod flight_service_client {
         pub async fn do_action(
             &mut self,
             request: impl tonic::IntoRequest<super::Action>,
-        ) -> Result<
+        ) -> std::result::Result<
             tonic::Response<tonic::codec::Streaming<super::Result>>,
             tonic::Status,
         > {
@@ -509,7 +829,12 @@ pub mod flight_service_client {
             let path = http::uri::PathAndQuery::from_static(
                 "/arrow.flight.protocol.FlightService/DoAction",
             );
-            self.inner.server_streaming(request.into_request(), path, codec).await
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("arrow.flight.protocol.FlightService", "DoAction"),
+                );
+            self.inner.server_streaming(req, path, codec).await
         }
         ///
         /// A flight service exposes all of the available action types that it has
@@ -518,7 +843,7 @@ pub mod flight_service_client {
         pub async fn list_actions(
             &mut self,
             request: impl tonic::IntoRequest<super::Empty>,
-        ) -> Result<
+        ) -> std::result::Result<
             tonic::Response<tonic::codec::Streaming<super::ActionType>>,
             tonic::Status,
         > {
@@ -535,7 +860,12 @@ pub mod flight_service_client {
             let path = http::uri::PathAndQuery::from_static(
                 "/arrow.flight.protocol.FlightService/ListActions",
             );
-            self.inner.server_streaming(request.into_request(), path, codec).await
+            let mut req = request.into_request();
+            req.extensions_mut()
+                .insert(
+                    GrpcMethod::new("arrow.flight.protocol.FlightService", "ListActions"),
+                );
+            self.inner.server_streaming(req, path, codec).await
         }
     }
 }
@@ -543,12 +873,12 @@ pub mod flight_service_client {
 pub mod flight_service_server {
     #![allow(unused_variables, dead_code, missing_docs, clippy::let_unit_value)]
     use tonic::codegen::*;
-    ///Generated trait containing gRPC methods that should be implemented for use with FlightServiceServer.
+    /// Generated trait containing gRPC methods that should be implemented for use with FlightServiceServer.
     #[async_trait]
     pub trait FlightService: Send + Sync + 'static {
-        ///Server streaming response type for the Handshake method.
-        type HandshakeStream: futures_core::Stream<
-                Item = Result<super::HandshakeResponse, tonic::Status>,
+        /// Server streaming response type for the Handshake method.
+        type HandshakeStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::HandshakeResponse, tonic::Status>,
             >
             + Send
             + 'static;
@@ -560,10 +890,10 @@ pub mod flight_service_server {
         async fn handshake(
             &self,
             request: tonic::Request<tonic::Streaming<super::HandshakeRequest>>,
-        ) -> Result<tonic::Response<Self::HandshakeStream>, tonic::Status>;
-        ///Server streaming response type for the ListFlights method.
-        type ListFlightsStream: futures_core::Stream<
-                Item = Result<super::FlightInfo, tonic::Status>,
+        ) -> std::result::Result<tonic::Response<Self::HandshakeStream>, tonic::Status>;
+        /// Server streaming response type for the ListFlights method.
+        type ListFlightsStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::FlightInfo, tonic::Status>,
             >
             + Send
             + 'static;
@@ -577,7 +907,10 @@ pub mod flight_service_server {
         async fn list_flights(
             &self,
             request: tonic::Request<super::Criteria>,
-        ) -> Result<tonic::Response<Self::ListFlightsStream>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<Self::ListFlightsStream>,
+            tonic::Status,
+        >;
         ///
         /// For a given FlightDescriptor, get information about how the flight can be
         /// consumed. This is a useful interface if the consumer of the interface
@@ -592,7 +925,34 @@ pub mod flight_service_server {
         async fn get_flight_info(
             &self,
             request: tonic::Request<super::FlightDescriptor>,
-        ) -> Result<tonic::Response<super::FlightInfo>, tonic::Status>;
+        ) -> std::result::Result<tonic::Response<super::FlightInfo>, tonic::Status>;
+        ///
+        /// For a given FlightDescriptor, start a query and get information
+        /// to poll its execution status. This is a useful interface if the
+        /// query may be a long-running query. The first PollFlightInfo call
+        /// should return as quickly as possible. (GetFlightInfo doesn't
+        /// return until the query is complete.)
+        ///
+        /// A client can consume any available results before
+        /// the query is completed. See PollInfo.info for details.
+        ///
+        /// A client can poll the updated query status by calling
+        /// PollFlightInfo() with PollInfo.flight_descriptor. A server
+        /// should not respond until the result would be different from last
+        /// time. That way, the client can "long poll" for updates
+        /// without constantly making requests. Clients can set a short timeout
+        /// to avoid blocking calls if desired.
+        ///
+        /// A client can't use PollInfo.flight_descriptor after
+        /// PollInfo.expiration_time passes. A server might not accept the
+        /// retry descriptor anymore and the query may be cancelled.
+        ///
+        /// A client may use the CancelFlightInfo action with
+        /// PollInfo.info to cancel the running query.
+        async fn poll_flight_info(
+            &self,
+            request: tonic::Request<super::FlightDescriptor>,
+        ) -> std::result::Result<tonic::Response<super::PollInfo>, tonic::Status>;
         ///
         /// For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
         /// This is used when a consumer needs the Schema of flight stream. Similar to
@@ -601,10 +961,10 @@ pub mod flight_service_server {
         async fn get_schema(
             &self,
             request: tonic::Request<super::FlightDescriptor>,
-        ) -> Result<tonic::Response<super::SchemaResult>, tonic::Status>;
-        ///Server streaming response type for the DoGet method.
-        type DoGetStream: futures_core::Stream<
-                Item = Result<super::FlightData, tonic::Status>,
+        ) -> std::result::Result<tonic::Response<super::SchemaResult>, tonic::Status>;
+        /// Server streaming response type for the DoGet method.
+        type DoGetStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::FlightData, tonic::Status>,
             >
             + Send
             + 'static;
@@ -616,10 +976,10 @@ pub mod flight_service_server {
         async fn do_get(
             &self,
             request: tonic::Request<super::Ticket>,
-        ) -> Result<tonic::Response<Self::DoGetStream>, tonic::Status>;
-        ///Server streaming response type for the DoPut method.
-        type DoPutStream: futures_core::Stream<
-                Item = Result<super::PutResult, tonic::Status>,
+        ) -> std::result::Result<tonic::Response<Self::DoGetStream>, tonic::Status>;
+        /// Server streaming response type for the DoPut method.
+        type DoPutStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::PutResult, tonic::Status>,
             >
             + Send
             + 'static;
@@ -633,10 +993,10 @@ pub mod flight_service_server {
         async fn do_put(
             &self,
             request: tonic::Request<tonic::Streaming<super::FlightData>>,
-        ) -> Result<tonic::Response<Self::DoPutStream>, tonic::Status>;
-        ///Server streaming response type for the DoExchange method.
-        type DoExchangeStream: futures_core::Stream<
-                Item = Result<super::FlightData, tonic::Status>,
+        ) -> std::result::Result<tonic::Response<Self::DoPutStream>, tonic::Status>;
+        /// Server streaming response type for the DoExchange method.
+        type DoExchangeStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::FlightData, tonic::Status>,
             >
             + Send
             + 'static;
@@ -649,10 +1009,10 @@ pub mod flight_service_server {
         async fn do_exchange(
             &self,
             request: tonic::Request<tonic::Streaming<super::FlightData>>,
-        ) -> Result<tonic::Response<Self::DoExchangeStream>, tonic::Status>;
-        ///Server streaming response type for the DoAction method.
-        type DoActionStream: futures_core::Stream<
-                Item = Result<super::Result, tonic::Status>,
+        ) -> std::result::Result<tonic::Response<Self::DoExchangeStream>, tonic::Status>;
+        /// Server streaming response type for the DoAction method.
+        type DoActionStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::Result, tonic::Status>,
             >
             + Send
             + 'static;
@@ -666,10 +1026,10 @@ pub mod flight_service_server {
         async fn do_action(
             &self,
             request: tonic::Request<super::Action>,
-        ) -> Result<tonic::Response<Self::DoActionStream>, tonic::Status>;
-        ///Server streaming response type for the ListActions method.
-        type ListActionsStream: futures_core::Stream<
-                Item = Result<super::ActionType, tonic::Status>,
+        ) -> std::result::Result<tonic::Response<Self::DoActionStream>, tonic::Status>;
+        /// Server streaming response type for the ListActions method.
+        type ListActionsStream: tonic::codegen::tokio_stream::Stream<
+                Item = std::result::Result<super::ActionType, tonic::Status>,
             >
             + Send
             + 'static;
@@ -680,7 +1040,10 @@ pub mod flight_service_server {
         async fn list_actions(
             &self,
             request: tonic::Request<super::Empty>,
-        ) -> Result<tonic::Response<Self::ListActionsStream>, tonic::Status>;
+        ) -> std::result::Result<
+            tonic::Response<Self::ListActionsStream>,
+            tonic::Status,
+        >;
     }
     ///
     /// A flight service is an endpoint for retrieving or storing Arrow data. A
@@ -692,6 +1055,8 @@ pub mod flight_service_server {
         inner: _Inner<T>,
         accept_compression_encodings: EnabledCompressionEncodings,
         send_compression_encodings: EnabledCompressionEncodings,
+        max_decoding_message_size: Option<usize>,
+        max_encoding_message_size: Option<usize>,
     }
     struct _Inner<T>(Arc<T>);
     impl<T: FlightService> FlightServiceServer<T> {
@@ -704,6 +1069,8 @@ pub mod flight_service_server {
                 inner,
                 accept_compression_encodings: Default::default(),
                 send_compression_encodings: Default::default(),
+                max_decoding_message_size: None,
+                max_encoding_message_size: None,
             }
         }
         pub fn with_interceptor<F>(
@@ -727,6 +1094,22 @@ pub mod flight_service_server {
             self.send_compression_encodings.enable(encoding);
             self
         }
+        /// Limits the maximum size of a decoded message.
+        ///
+        /// Default: `4MB`
+        #[must_use]
+        pub fn max_decoding_message_size(mut self, limit: usize) -> Self {
+            self.max_decoding_message_size = Some(limit);
+            self
+        }
+        /// Limits the maximum size of an encoded message.
+        ///
+        /// Default: `usize::MAX`
+        #[must_use]
+        pub fn max_encoding_message_size(mut self, limit: usize) -> Self {
+            self.max_encoding_message_size = Some(limit);
+            self
+        }
     }
     impl<T, B> tonic::codegen::Service<http::Request<B>> for FlightServiceServer<T>
     where
@@ -740,7 +1123,7 @@ pub mod flight_service_server {
         fn poll_ready(
             &mut self,
             _cx: &mut Context<'_>,
-        ) -> Poll<Result<(), Self::Error>> {
+        ) -> Poll<std::result::Result<(), Self::Error>> {
             Poll::Ready(Ok(()))
         }
         fn call(&mut self, req: http::Request<B>) -> Self::Future {
@@ -765,13 +1148,17 @@ pub mod flight_service_server {
                                 tonic::Streaming<super::HandshakeRequest>,
                             >,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
-                            let fut = async move { (*inner).handshake(request).await };
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as FlightService>::handshake(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
                         let inner = inner.0;
@@ -781,6 +1168,10 @@ pub mod flight_service_server {
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
                         let res = grpc.streaming(method, req).await;
                         Ok(res)
@@ -804,15 +1195,17 @@ pub mod flight_service_server {
                             &mut self,
                             request: tonic::Request<super::Criteria>,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
+                            let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                (*inner).list_flights(request).await
+                                <T as FlightService>::list_flights(&inner, request).await
                             };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
                         let inner = inner.0;
@@ -822,6 +1215,10 @@ pub mod flight_service_server {
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
                         let res = grpc.server_streaming(method, req).await;
                         Ok(res)
@@ -844,15 +1241,17 @@ pub mod flight_service_server {
                             &mut self,
                             request: tonic::Request<super::FlightDescriptor>,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
+                            let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                (*inner).get_flight_info(request).await
+                                <T as FlightService>::get_flight_info(&inner, request).await
                             };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
                         let inner = inner.0;
@@ -862,6 +1261,57 @@ pub mod flight_service_server {
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
+                            );
+                        let res = grpc.unary(method, req).await;
+                        Ok(res)
+                    };
+                    Box::pin(fut)
+                }
+                "/arrow.flight.protocol.FlightService/PollFlightInfo" => {
+                    #[allow(non_camel_case_types)]
+                    struct PollFlightInfoSvc<T: FlightService>(pub Arc<T>);
+                    impl<
+                        T: FlightService,
+                    > tonic::server::UnaryService<super::FlightDescriptor>
+                    for PollFlightInfoSvc<T> {
+                        type Response = super::PollInfo;
+                        type Future = BoxFuture<
+                            tonic::Response<Self::Response>,
+                            tonic::Status,
+                        >;
+                        fn call(
+                            &mut self,
+                            request: tonic::Request<super::FlightDescriptor>,
+                        ) -> Self::Future {
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as FlightService>::poll_flight_info(&inner, request)
+                                    .await
+                            };
+                            Box::pin(fut)
+                        }
+                    }
+                    let accept_compression_encodings = self.accept_compression_encodings;
+                    let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
+                    let inner = self.inner.clone();
+                    let fut = async move {
+                        let inner = inner.0;
+                        let method = PollFlightInfoSvc(inner);
+                        let codec = tonic::codec::ProstCodec::default();
+                        let mut grpc = tonic::server::Grpc::new(codec)
+                            .apply_compression_config(
+                                accept_compression_encodings,
+                                send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
                         let res = grpc.unary(method, req).await;
                         Ok(res)
@@ -884,13 +1334,17 @@ pub mod flight_service_server {
                             &mut self,
                             request: tonic::Request<super::FlightDescriptor>,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
-                            let fut = async move { (*inner).get_schema(request).await };
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as FlightService>::get_schema(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
                         let inner = inner.0;
@@ -900,6 +1354,10 @@ pub mod flight_service_server {
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
                         let res = grpc.unary(method, req).await;
                         Ok(res)
@@ -923,13 +1381,17 @@ pub mod flight_service_server {
                             &mut self,
                             request: tonic::Request<super::Ticket>,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
-                            let fut = async move { (*inner).do_get(request).await };
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as FlightService>::do_get(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
                         let inner = inner.0;
@@ -939,6 +1401,10 @@ pub mod flight_service_server {
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
                         let res = grpc.server_streaming(method, req).await;
                         Ok(res)
@@ -962,13 +1428,17 @@ pub mod flight_service_server {
                             &mut self,
                             request: tonic::Request<tonic::Streaming<super::FlightData>>,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
-                            let fut = async move { (*inner).do_put(request).await };
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as FlightService>::do_put(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
                         let inner = inner.0;
@@ -978,6 +1448,10 @@ pub mod flight_service_server {
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
                         let res = grpc.streaming(method, req).await;
                         Ok(res)
@@ -1001,13 +1475,17 @@ pub mod flight_service_server {
                             &mut self,
                             request: tonic::Request<tonic::Streaming<super::FlightData>>,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
-                            let fut = async move { (*inner).do_exchange(request).await };
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as FlightService>::do_exchange(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
                         let inner = inner.0;
@@ -1017,6 +1495,10 @@ pub mod flight_service_server {
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
                         let res = grpc.streaming(method, req).await;
                         Ok(res)
@@ -1040,13 +1522,17 @@ pub mod flight_service_server {
                             &mut self,
                             request: tonic::Request<super::Action>,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
-                            let fut = async move { (*inner).do_action(request).await };
+                            let inner = Arc::clone(&self.0);
+                            let fut = async move {
+                                <T as FlightService>::do_action(&inner, request).await
+                            };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
                         let inner = inner.0;
@@ -1056,6 +1542,10 @@ pub mod flight_service_server {
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
                         let res = grpc.server_streaming(method, req).await;
                         Ok(res)
@@ -1079,15 +1569,17 @@ pub mod flight_service_server {
                             &mut self,
                             request: tonic::Request<super::Empty>,
                         ) -> Self::Future {
-                            let inner = self.0.clone();
+                            let inner = Arc::clone(&self.0);
                             let fut = async move {
-                                (*inner).list_actions(request).await
+                                <T as FlightService>::list_actions(&inner, request).await
                             };
                             Box::pin(fut)
                         }
                     }
                     let accept_compression_encodings = self.accept_compression_encodings;
                     let send_compression_encodings = self.send_compression_encodings;
+                    let max_decoding_message_size = self.max_decoding_message_size;
+                    let max_encoding_message_size = self.max_encoding_message_size;
                     let inner = self.inner.clone();
                     let fut = async move {
                         let inner = inner.0;
@@ -1097,6 +1589,10 @@ pub mod flight_service_server {
                             .apply_compression_config(
                                 accept_compression_encodings,
                                 send_compression_encodings,
+                            )
+                            .apply_max_message_size_config(
+                                max_decoding_message_size,
+                                max_encoding_message_size,
                             );
                         let res = grpc.server_streaming(method, req).await;
                         Ok(res)
@@ -1125,12 +1621,14 @@ pub mod flight_service_server {
                 inner,
                 accept_compression_encodings: self.accept_compression_encodings,
                 send_compression_encodings: self.send_compression_encodings,
+                max_decoding_message_size: self.max_decoding_message_size,
+                max_encoding_message_size: self.max_encoding_message_size,
             }
         }
     }
     impl<T: FlightService> Clone for _Inner<T> {
         fn clone(&self) -> Self {
-            Self(self.0.clone())
+            Self(Arc::clone(&self.0))
         }
     }
     impl<T: std::fmt::Debug> std::fmt::Debug for _Inner<T> {
diff --git a/arrow-flight/src/bin/flight_sql_client.rs b/arrow-flight/src/bin/flight_sql_client.rs
new file mode 100644
index 000000000000..296efc1c308e
--- /dev/null
+++ b/arrow-flight/src/bin/flight_sql_client.rs
@@ -0,0 +1,351 @@
+// 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.
+
+use std::{sync::Arc, time::Duration};
+
+use anyhow::{bail, Context, Result};
+use arrow_array::{ArrayRef, Datum, RecordBatch, StringArray};
+use arrow_cast::{cast_with_options, pretty::pretty_format_batches, CastOptions};
+use arrow_flight::{sql::client::FlightSqlServiceClient, FlightInfo};
+use arrow_schema::Schema;
+use clap::{Parser, Subcommand};
+use futures::TryStreamExt;
+use tonic::{
+    metadata::MetadataMap,
+    transport::{Channel, ClientTlsConfig, Endpoint},
+};
+use tracing_log::log::info;
+
+/// Logging CLI config.
+#[derive(Debug, Parser)]
+pub struct LoggingArgs {
+    /// Log verbosity.
+    ///
+    /// Defaults to "warn".
+    ///
+    /// Use `-v` for "info", `-vv` for "debug", `-vvv` for "trace".
+    ///
+    /// Note you can also set logging level using `RUST_LOG` environment variable:
+    /// `RUST_LOG=debug`.
+    #[clap(
+        short = 'v',
+        long = "verbose",
+        action = clap::ArgAction::Count,
+    )]
+    log_verbose_count: u8,
+}
+
+#[derive(Debug, Parser)]
+struct ClientArgs {
+    /// Additional headers.
+    ///
+    /// Can be given multiple times. Headers and values are separated by '='.
+    ///
+    /// Example: `-H foo=bar -H baz=42`
+    #[clap(long = "header", short = 'H', value_parser = parse_key_val)]
+    headers: Vec<(String, String)>,
+
+    /// Username.
+    ///
+    /// Optional. If given, `password` must also be set.
+    #[clap(long, requires = "password")]
+    username: Option<String>,
+
+    /// Password.
+    ///
+    /// Optional. If given, `username` must also be set.
+    #[clap(long, requires = "username")]
+    password: Option<String>,
+
+    /// Auth token.
+    #[clap(long)]
+    token: Option<String>,
+
+    /// Use TLS.
+    ///
+    /// If not provided, use cleartext connection.
+    #[clap(long)]
+    tls: bool,
+
+    /// Server host.
+    ///
+    /// Required.
+    #[clap(long)]
+    host: String,
+
+    /// Server port.
+    ///
+    /// Defaults to `443` if `tls` is set, otherwise defaults to `80`.
+    #[clap(long)]
+    port: Option<u16>,
+}
+
+#[derive(Debug, Parser)]
+struct Args {
+    /// Logging args.
+    #[clap(flatten)]
+    logging_args: LoggingArgs,
+
+    /// Client args.
+    #[clap(flatten)]
+    client_args: ClientArgs,
+
+    #[clap(subcommand)]
+    cmd: Command,
+}
+
+/// Different available commands.
+#[derive(Debug, Subcommand)]
+enum Command {
+    /// Execute given statement.
+    StatementQuery {
+        /// SQL query.
+        ///
+        /// Required.
+        query: String,
+    },
+
+    /// Prepare given statement and then execute it.
+    PreparedStatementQuery {
+        /// SQL query.
+        ///
+        /// Required.
+        ///
+        /// Can contains placeholders like `$1`.
+        ///
+        /// Example: `SELECT * FROM t WHERE x = $1`
+        query: String,
+
+        /// Additional parameters.
+        ///
+        /// Can be given multiple times. Names and values are separated by '='. Values will be
+        /// converted to the type that the server reported for the prepared statement.
+        ///
+        /// Example: `-p $1=42`
+        #[clap(short, value_parser = parse_key_val)]
+        params: Vec<(String, String)>,
+    },
+}
+
+#[tokio::main]
+async fn main() -> Result<()> {
+    let args = Args::parse();
+    setup_logging(args.logging_args)?;
+    let mut client = setup_client(args.client_args)
+        .await
+        .context("setup client")?;
+
+    let flight_info = match args.cmd {
+        Command::StatementQuery { query } => client
+            .execute(query, None)
+            .await
+            .context("execute statement")?,
+        Command::PreparedStatementQuery { query, params } => {
+            let mut prepared_stmt = client
+                .prepare(query, None)
+                .await
+                .context("prepare statement")?;
+
+            if !params.is_empty() {
+                prepared_stmt
+                    .set_parameters(
+                        construct_record_batch_from_params(
+                            &params,
+                            prepared_stmt
+                                .parameter_schema()
+                                .context("get parameter schema")?,
+                        )
+                        .context("construct parameters")?,
+                    )
+                    .context("bind parameters")?;
+            }
+
+            prepared_stmt
+                .execute()
+                .await
+                .context("execute prepared statement")?
+        }
+    };
+
+    let batches = execute_flight(&mut client, flight_info)
+        .await
+        .context("read flight data")?;
+
+    let res = pretty_format_batches(batches.as_slice()).context("format results")?;
+    println!("{res}");
+
+    Ok(())
+}
+
+async fn execute_flight(
+    client: &mut FlightSqlServiceClient<Channel>,
+    info: FlightInfo,
+) -> Result<Vec<RecordBatch>> {
+    let schema = Arc::new(Schema::try_from(info.clone()).context("valid schema")?);
+    let mut batches = Vec::with_capacity(info.endpoint.len() + 1);
+    batches.push(RecordBatch::new_empty(schema));
+    info!("decoded schema");
+
+    for endpoint in info.endpoint {
+        let Some(ticket) = &endpoint.ticket else {
+            bail!("did not get ticket");
+        };
+
+        let mut flight_data = client.do_get(ticket.clone()).await.context("do get")?;
+        log_metadata(flight_data.headers(), "header");
+
+        let mut endpoint_batches: Vec<_> = (&mut flight_data)
+            .try_collect()
+            .await
+            .context("collect data stream")?;
+        batches.append(&mut endpoint_batches);
+
+        if let Some(trailers) = flight_data.trailers() {
+            log_metadata(&trailers, "trailer");
+        }
+    }
+    info!("received data");
+
+    Ok(batches)
+}
+
+fn construct_record_batch_from_params(
+    params: &[(String, String)],
+    parameter_schema: &Schema,
+) -> Result<RecordBatch> {
+    let mut items = Vec::<(&String, ArrayRef)>::new();
+
+    for (name, value) in params {
+        let field = parameter_schema.field_with_name(name)?;
+        let value_as_array = StringArray::new_scalar(value);
+        let casted = cast_with_options(
+            value_as_array.get().0,
+            field.data_type(),
+            &CastOptions::default(),
+        )?;
+        items.push((name, casted))
+    }
+
+    Ok(RecordBatch::try_from_iter(items)?)
+}
+
+fn setup_logging(args: LoggingArgs) -> Result<()> {
+    use tracing_subscriber::{util::SubscriberInitExt, EnvFilter, FmtSubscriber};
+
+    tracing_log::LogTracer::init().context("tracing log init")?;
+
+    let filter = match args.log_verbose_count {
+        0 => "warn",
+        1 => "info",
+        2 => "debug",
+        _ => "trace",
+    };
+    let filter = EnvFilter::try_new(filter).context("set up log env filter")?;
+
+    let subscriber = FmtSubscriber::builder().with_env_filter(filter).finish();
+    subscriber.try_init().context("init logging subscriber")?;
+
+    Ok(())
+}
+
+async fn setup_client(args: ClientArgs) -> Result<FlightSqlServiceClient<Channel>> {
+    let port = args.port.unwrap_or(if args.tls { 443 } else { 80 });
+
+    let protocol = if args.tls { "https" } else { "http" };
+
+    let mut endpoint = Endpoint::new(format!("{}://{}:{}", protocol, args.host, port))
+        .context("create endpoint")?
+        .connect_timeout(Duration::from_secs(20))
+        .timeout(Duration::from_secs(20))
+        .tcp_nodelay(true) // Disable Nagle's Algorithm since we don't want packets to wait
+        .tcp_keepalive(Option::Some(Duration::from_secs(3600)))
+        .http2_keep_alive_interval(Duration::from_secs(300))
+        .keep_alive_timeout(Duration::from_secs(20))
+        .keep_alive_while_idle(true);
+
+    if args.tls {
+        let tls_config = ClientTlsConfig::new();
+        endpoint = endpoint
+            .tls_config(tls_config)
+            .context("create TLS endpoint")?;
+    }
+
+    let channel = endpoint.connect().await.context("connect to endpoint")?;
+
+    let mut client = FlightSqlServiceClient::new(channel);
+    info!("connected");
+
+    for (k, v) in args.headers {
+        client.set_header(k, v);
+    }
+
+    if let Some(token) = args.token {
+        client.set_token(token);
+        info!("token set");
+    }
+
+    match (args.username, args.password) {
+        (None, None) => {}
+        (Some(username), Some(password)) => {
+            client
+                .handshake(&username, &password)
+                .await
+                .context("handshake")?;
+            info!("performed handshake");
+        }
+        (Some(_), None) => {
+            bail!("when username is set, you also need to set a password")
+        }
+        (None, Some(_)) => {
+            bail!("when password is set, you also need to set a username")
+        }
+    }
+
+    Ok(client)
+}
+
+/// Parse a single key-value pair
+fn parse_key_val(s: &str) -> Result<(String, String), String> {
+    let pos = s
+        .find('=')
+        .ok_or_else(|| format!("invalid KEY=value: no `=` found in `{s}`"))?;
+    Ok((s[..pos].to_owned(), s[pos + 1..].to_owned()))
+}
+
+/// Log headers/trailers.
+fn log_metadata(map: &MetadataMap, what: &'static str) {
+    for k_v in map.iter() {
+        match k_v {
+            tonic::metadata::KeyAndValueRef::Ascii(k, v) => {
+                info!(
+                    "{}: {}={}",
+                    what,
+                    k.as_str(),
+                    v.to_str().unwrap_or("<invalid>"),
+                );
+            }
+            tonic::metadata::KeyAndValueRef::Binary(k, v) => {
+                info!(
+                    "{}: {}={}",
+                    what,
+                    k.as_str(),
+                    String::from_utf8_lossy(v.as_ref()),
+                );
+            }
+        }
+    }
+}
diff --git a/arrow-flight/src/client.rs b/arrow-flight/src/client.rs
new file mode 100644
index 000000000000..b2abfb0c17b2
--- /dev/null
+++ b/arrow-flight/src/client.rs
@@ -0,0 +1,688 @@
+// 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.
+
+use std::task::Poll;
+
+use crate::{
+    decode::FlightRecordBatchStream,
+    flight_service_client::FlightServiceClient,
+    gen::{CancelFlightInfoRequest, CancelFlightInfoResult, RenewFlightEndpointRequest},
+    trailers::extract_lazy_trailers,
+    Action, ActionType, Criteria, Empty, FlightData, FlightDescriptor, FlightEndpoint, FlightInfo,
+    HandshakeRequest, PollInfo, PutResult, Ticket,
+};
+use arrow_schema::Schema;
+use bytes::Bytes;
+use futures::{
+    future::ready,
+    ready,
+    stream::{self, BoxStream},
+    FutureExt, Stream, StreamExt, TryStreamExt,
+};
+use prost::Message;
+use tonic::{metadata::MetadataMap, transport::Channel};
+
+use crate::error::{FlightError, Result};
+
+/// A "Mid level" [Apache Arrow Flight](https://arrow.apache.org/docs/format/Flight.html) client.
+///
+/// [`FlightClient`] is intended as a convenience for interactions
+/// with Arrow Flight servers. For more direct control, such as access
+/// to the response headers, use  [`FlightServiceClient`] directly
+/// via methods such as [`Self::inner`] or [`Self::into_inner`].
+///
+/// # Example:
+/// ```no_run
+/// # async fn run() {
+/// # use arrow_flight::FlightClient;
+/// # use bytes::Bytes;
+/// use tonic::transport::Channel;
+/// let channel = Channel::from_static("http://localhost:1234")
+///   .connect()
+///   .await
+///   .expect("error connecting");
+///
+/// let mut client = FlightClient::new(channel);
+///
+/// // Send 'Hi' bytes as the handshake request to the server
+/// let response = client
+///   .handshake(Bytes::from("Hi"))
+///   .await
+///   .expect("error handshaking");
+///
+/// // Expect the server responded with 'Ho'
+/// assert_eq!(response, Bytes::from("Ho"));
+/// # }
+/// ```
+#[derive(Debug)]
+pub struct FlightClient {
+    /// Optional grpc header metadata to include with each request
+    metadata: MetadataMap,
+
+    /// The inner client
+    inner: FlightServiceClient<Channel>,
+}
+
+impl FlightClient {
+    /// Creates a client client with the provided [`Channel`]
+    pub fn new(channel: Channel) -> Self {
+        Self::new_from_inner(FlightServiceClient::new(channel))
+    }
+
+    /// Creates a new higher level client with the provided lower level client
+    pub fn new_from_inner(inner: FlightServiceClient<Channel>) -> Self {
+        Self {
+            metadata: MetadataMap::new(),
+            inner,
+        }
+    }
+
+    /// Return a reference to gRPC metadata included with each request
+    pub fn metadata(&self) -> &MetadataMap {
+        &self.metadata
+    }
+
+    /// Return a reference to gRPC metadata included with each request
+    ///
+    /// These headers can be used, for example, to include
+    /// authorization or other application specific headers.
+    pub fn metadata_mut(&mut self) -> &mut MetadataMap {
+        &mut self.metadata
+    }
+
+    /// Add the specified header with value to all subsequent
+    /// requests. See [`Self::metadata_mut`] for fine grained control.
+    pub fn add_header(&mut self, key: &str, value: &str) -> Result<()> {
+        let key = tonic::metadata::MetadataKey::<_>::from_bytes(key.as_bytes())
+            .map_err(|e| FlightError::ExternalError(Box::new(e)))?;
+
+        let value = value
+            .parse()
+            .map_err(|e| FlightError::ExternalError(Box::new(e)))?;
+
+        // ignore previous value
+        self.metadata.insert(key, value);
+
+        Ok(())
+    }
+
+    /// Return a reference to the underlying tonic
+    /// [`FlightServiceClient`]
+    pub fn inner(&self) -> &FlightServiceClient<Channel> {
+        &self.inner
+    }
+
+    /// Return a mutable reference to the underlying tonic
+    /// [`FlightServiceClient`]
+    pub fn inner_mut(&mut self) -> &mut FlightServiceClient<Channel> {
+        &mut self.inner
+    }
+
+    /// Consume this client and return the underlying tonic
+    /// [`FlightServiceClient`]
+    pub fn into_inner(self) -> FlightServiceClient<Channel> {
+        self.inner
+    }
+
+    /// Perform an Arrow Flight handshake with the server, sending
+    /// `payload` as the [`HandshakeRequest`] payload and returning
+    /// the [`HandshakeResponse`](crate::HandshakeResponse)
+    /// bytes returned from the server
+    ///
+    /// See [`FlightClient`] docs for an example.
+    pub async fn handshake(&mut self, payload: impl Into<Bytes>) -> Result<Bytes> {
+        let request = HandshakeRequest {
+            protocol_version: 0,
+            payload: payload.into(),
+        };
+
+        // apply headers, etc
+        let request = self.make_request(stream::once(ready(request)));
+
+        let mut response_stream = self.inner.handshake(request).await?.into_inner();
+
+        if let Some(response) = response_stream.next().await.transpose()? {
+            // check if there is another response
+            if response_stream.next().await.is_some() {
+                return Err(FlightError::protocol(
+                    "Got unexpected second response from handshake",
+                ));
+            }
+
+            Ok(response.payload)
+        } else {
+            Err(FlightError::protocol("No response from handshake"))
+        }
+    }
+
+    /// Make a `DoGet` call to the server with the provided ticket,
+    /// returning a [`FlightRecordBatchStream`] for reading
+    /// [`RecordBatch`](arrow_array::RecordBatch)es.
+    ///
+    /// # Note
+    ///
+    /// To access the returned [`FlightData`] use
+    /// [`FlightRecordBatchStream::into_inner()`]
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use bytes::Bytes;
+    /// # use arrow_flight::FlightClient;
+    /// # use arrow_flight::Ticket;
+    /// # use arrow_array::RecordBatch;
+    /// # use futures::stream::TryStreamExt;
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// # let ticket = Ticket { ticket: Bytes::from("foo") };
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// // Invoke a do_get request on the server with a previously
+    /// // received Ticket
+    ///
+    /// let response = client
+    ///    .do_get(ticket)
+    ///    .await
+    ///    .expect("error invoking do_get");
+    ///
+    /// // Use try_collect to get the RecordBatches from the server
+    /// let batches: Vec<RecordBatch> = response
+    ///    .try_collect()
+    ///    .await
+    ///    .expect("no stream errors");
+    /// # }
+    /// ```
+    pub async fn do_get(&mut self, ticket: Ticket) -> Result<FlightRecordBatchStream> {
+        let request = self.make_request(ticket);
+
+        let (md, response_stream, _ext) = self.inner.do_get(request).await?.into_parts();
+        let (response_stream, trailers) = extract_lazy_trailers(response_stream);
+
+        Ok(FlightRecordBatchStream::new_from_flight_data(
+            response_stream.map_err(FlightError::Tonic),
+        )
+        .with_headers(md)
+        .with_trailers(trailers))
+    }
+
+    /// Make a `GetFlightInfo` call to the server with the provided
+    /// [`FlightDescriptor`] and return the [`FlightInfo`] from the
+    /// server. The [`FlightInfo`] can be used with [`Self::do_get`]
+    /// to retrieve the requested batches.
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use arrow_flight::FlightClient;
+    /// # use arrow_flight::FlightDescriptor;
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// // Send a 'CMD' request to the server
+    /// let request = FlightDescriptor::new_cmd(b"MOAR DATA".to_vec());
+    /// let flight_info = client
+    ///   .get_flight_info(request)
+    ///   .await
+    ///   .expect("error handshaking");
+    ///
+    /// // retrieve the first endpoint from the returned flight info
+    /// let ticket = flight_info
+    ///   .endpoint[0]
+    ///   // Extract the ticket
+    ///   .ticket
+    ///   .clone()
+    ///   .expect("expected ticket");
+    ///
+    /// // Retrieve the corresponding RecordBatch stream with do_get
+    /// let data = client
+    ///   .do_get(ticket)
+    ///   .await
+    ///   .expect("error fetching data");
+    /// # }
+    /// ```
+    pub async fn get_flight_info(&mut self, descriptor: FlightDescriptor) -> Result<FlightInfo> {
+        let request = self.make_request(descriptor);
+
+        let response = self.inner.get_flight_info(request).await?.into_inner();
+        Ok(response)
+    }
+
+    /// Make a `PollFlightInfo` call to the server with the provided
+    /// [`FlightDescriptor`] and return the [`PollInfo`] from the
+    /// server.
+    ///
+    /// The `info` field of the [`PollInfo`] can be used with
+    /// [`Self::do_get`] to retrieve the requested batches.
+    ///
+    /// If the `flight_descriptor` field of the [`PollInfo`] is
+    /// `None` then the `info` field represents the complete results.
+    ///
+    /// If the `flight_descriptor` field is some [`FlightDescriptor`]
+    /// then the `info` field has incomplete results, and the client
+    /// should call this method again with the new `flight_descriptor`
+    /// to get the updated status.
+    ///
+    /// The `expiration_time`, if set, represents the expiration time
+    /// of the `flight_descriptor`, after which the server may not accept
+    /// this retry descriptor and may cancel the query.
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use arrow_flight::FlightClient;
+    /// # use arrow_flight::FlightDescriptor;
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// // Send a 'CMD' request to the server
+    /// let request = FlightDescriptor::new_cmd(b"MOAR DATA".to_vec());
+    /// let poll_info = client
+    ///   .poll_flight_info(request)
+    ///   .await
+    ///   .expect("error handshaking");
+    ///
+    /// // retrieve the first endpoint from the returned poll info
+    /// let ticket = poll_info
+    ///   .info
+    ///   .expect("expected flight info")
+    ///   .endpoint[0]
+    ///   // Extract the ticket
+    ///   .ticket
+    ///   .clone()
+    ///   .expect("expected ticket");
+    ///
+    /// // Retrieve the corresponding RecordBatch stream with do_get
+    /// let data = client
+    ///   .do_get(ticket)
+    ///   .await
+    ///   .expect("error fetching data");
+    /// # }
+    /// ```
+    pub async fn poll_flight_info(&mut self, descriptor: FlightDescriptor) -> Result<PollInfo> {
+        let request = self.make_request(descriptor);
+
+        let response = self.inner.poll_flight_info(request).await?.into_inner();
+        Ok(response)
+    }
+
+    /// Make a `DoPut` call to the server with the provided
+    /// [`Stream`] of [`FlightData`] and returning a
+    /// stream of [`PutResult`].
+    ///
+    /// # Note
+    ///
+    /// The input stream is [`Result`] so that this can be connected
+    /// to a streaming data source, such as [`FlightDataEncoder`](crate::encode::FlightDataEncoder),
+    /// without having to buffer. If the input stream returns an error
+    /// that error will not be sent to the server, instead it will be
+    /// placed into the result stream and the server connection
+    /// terminated.
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use futures::{TryStreamExt, StreamExt};
+    /// # use std::sync::Arc;
+    /// # use arrow_array::UInt64Array;
+    /// # use arrow_array::RecordBatch;
+    /// # use arrow_flight::{FlightClient, FlightDescriptor, PutResult};
+    /// # use arrow_flight::encode::FlightDataEncoderBuilder;
+    /// # let batch = RecordBatch::try_from_iter(vec![
+    /// #  ("col2", Arc::new(UInt64Array::from_iter([10, 23, 33])) as _)
+    /// # ]).unwrap();
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// // encode the batch as a stream of `FlightData`
+    /// let flight_data_stream = FlightDataEncoderBuilder::new()
+    ///   .build(futures::stream::iter(vec![Ok(batch)]));
+    ///
+    /// // send the stream and get the results as `PutResult`
+    /// let response: Vec<PutResult>= client
+    ///   .do_put(flight_data_stream)
+    ///   .await
+    ///   .unwrap()
+    ///   .try_collect() // use TryStreamExt to collect stream
+    ///   .await
+    ///   .expect("error calling do_put");
+    /// # }
+    /// ```
+    pub async fn do_put<S: Stream<Item = Result<FlightData>> + Send + 'static>(
+        &mut self,
+        request: S,
+    ) -> Result<BoxStream<'static, Result<PutResult>>> {
+        let (sender, mut receiver) = futures::channel::oneshot::channel();
+
+        // Intercepts client errors and sends them to the oneshot channel above
+        let mut request = Box::pin(request); // Pin to heap
+        let mut sender = Some(sender); // Wrap into Option so can be taken
+        let request_stream = futures::stream::poll_fn(move |cx| {
+            Poll::Ready(match ready!(request.poll_next_unpin(cx)) {
+                Some(Ok(data)) => Some(data),
+                Some(Err(e)) => {
+                    let _ = sender.take().unwrap().send(e);
+                    None
+                }
+                None => None,
+            })
+        });
+
+        let request = self.make_request(request_stream);
+        let mut response_stream = self.inner.do_put(request).await?.into_inner();
+
+        // Forwards errors from the error oneshot with priority over responses from server
+        let error_stream = futures::stream::poll_fn(move |cx| {
+            if let Poll::Ready(Ok(err)) = receiver.poll_unpin(cx) {
+                return Poll::Ready(Some(Err(err)));
+            }
+            let next = ready!(response_stream.poll_next_unpin(cx));
+            Poll::Ready(next.map(|x| x.map_err(FlightError::Tonic)))
+        });
+
+        // combine the response from the server and any error from the client
+        Ok(error_stream.boxed())
+    }
+
+    /// Make a `DoExchange` call to the server with the provided
+    /// [`Stream`] of [`FlightData`] and returning a
+    /// stream of [`FlightData`].
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use futures::{TryStreamExt, StreamExt};
+    /// # use std::sync::Arc;
+    /// # use arrow_array::UInt64Array;
+    /// # use arrow_array::RecordBatch;
+    /// # use arrow_flight::{FlightClient, FlightDescriptor, PutResult};
+    /// # use arrow_flight::encode::FlightDataEncoderBuilder;
+    /// # let batch = RecordBatch::try_from_iter(vec![
+    /// #  ("col2", Arc::new(UInt64Array::from_iter([10, 23, 33])) as _)
+    /// # ]).unwrap();
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// // encode the batch as a stream of `FlightData`
+    /// let flight_data_stream = FlightDataEncoderBuilder::new()
+    ///   .build(futures::stream::iter(vec![Ok(batch)]))
+    ///   // data encoder return Results, but do_exchange requires FlightData
+    ///   .map(|batch|batch.unwrap());
+    ///
+    /// // send the stream and get the results as `RecordBatches`
+    /// let response: Vec<RecordBatch> = client
+    ///   .do_exchange(flight_data_stream)
+    ///   .await
+    ///   .unwrap()
+    ///   .try_collect() // use TryStreamExt to collect stream
+    ///   .await
+    ///   .expect("error calling do_exchange");
+    /// # }
+    /// ```
+    pub async fn do_exchange<S: Stream<Item = FlightData> + Send + 'static>(
+        &mut self,
+        request: S,
+    ) -> Result<FlightRecordBatchStream> {
+        let request = self.make_request(request);
+
+        let response = self
+            .inner
+            .do_exchange(request)
+            .await?
+            .into_inner()
+            .map_err(FlightError::Tonic);
+
+        Ok(FlightRecordBatchStream::new_from_flight_data(response))
+    }
+
+    /// Make a `ListFlights` call to the server with the provided
+    /// criteria and returning a [`Stream`] of [`FlightInfo`].
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use futures::TryStreamExt;
+    /// # use bytes::Bytes;
+    /// # use arrow_flight::{FlightInfo, FlightClient};
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// // Send 'Name=Foo' bytes as the "expression" to the server
+    /// // and gather the returned FlightInfo
+    /// let responses: Vec<FlightInfo> = client
+    ///   .list_flights(Bytes::from("Name=Foo"))
+    ///   .await
+    ///   .expect("error listing flights")
+    ///   .try_collect() // use TryStreamExt to collect stream
+    ///   .await
+    ///   .expect("error gathering flights");
+    /// # }
+    /// ```
+    pub async fn list_flights(
+        &mut self,
+        expression: impl Into<Bytes>,
+    ) -> Result<BoxStream<'static, Result<FlightInfo>>> {
+        let request = Criteria {
+            expression: expression.into(),
+        };
+
+        let request = self.make_request(request);
+
+        let response = self
+            .inner
+            .list_flights(request)
+            .await?
+            .into_inner()
+            .map_err(FlightError::Tonic);
+
+        Ok(response.boxed())
+    }
+
+    /// Make a `GetSchema` call to the server with the provided
+    /// [`FlightDescriptor`] and returning the associated [`Schema`].
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use bytes::Bytes;
+    /// # use arrow_flight::{FlightDescriptor, FlightClient};
+    /// # use arrow_schema::Schema;
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// // Request the schema result of a 'CMD' request to the server
+    /// let request = FlightDescriptor::new_cmd(b"MOAR DATA".to_vec());
+    ///
+    /// let schema: Schema = client
+    ///   .get_schema(request)
+    ///   .await
+    ///   .expect("error making request");
+    /// # }
+    /// ```
+    pub async fn get_schema(&mut self, flight_descriptor: FlightDescriptor) -> Result<Schema> {
+        let request = self.make_request(flight_descriptor);
+
+        let schema_result = self.inner.get_schema(request).await?.into_inner();
+
+        // attempt decode from IPC
+        let schema: Schema = schema_result.try_into()?;
+
+        Ok(schema)
+    }
+
+    /// Make a `ListActions` call to the server and returning a
+    /// [`Stream`] of [`ActionType`].
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use futures::TryStreamExt;
+    /// # use arrow_flight::{ActionType, FlightClient};
+    /// # use arrow_schema::Schema;
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// // List available actions on the server:
+    /// let actions: Vec<ActionType> = client
+    ///   .list_actions()
+    ///   .await
+    ///   .expect("error listing actions")
+    ///   .try_collect() // use TryStreamExt to collect stream
+    ///   .await
+    ///   .expect("error gathering actions");
+    /// # }
+    /// ```
+    pub async fn list_actions(&mut self) -> Result<BoxStream<'static, Result<ActionType>>> {
+        let request = self.make_request(Empty {});
+
+        let action_stream = self
+            .inner
+            .list_actions(request)
+            .await?
+            .into_inner()
+            .map_err(FlightError::Tonic);
+
+        Ok(action_stream.boxed())
+    }
+
+    /// Make a `DoAction` call to the server and returning a
+    /// [`Stream`] of opaque [`Bytes`].
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use bytes::Bytes;
+    /// # use futures::TryStreamExt;
+    /// # use arrow_flight::{Action, FlightClient};
+    /// # use arrow_schema::Schema;
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// let request = Action::new("my_action", "the body");
+    ///
+    /// // Make a request to run the action on the server
+    /// let results: Vec<Bytes> = client
+    ///   .do_action(request)
+    ///   .await
+    ///   .expect("error executing acton")
+    ///   .try_collect() // use TryStreamExt to collect stream
+    ///   .await
+    ///   .expect("error gathering action results");
+    /// # }
+    /// ```
+    pub async fn do_action(&mut self, action: Action) -> Result<BoxStream<'static, Result<Bytes>>> {
+        let request = self.make_request(action);
+
+        let result_stream = self
+            .inner
+            .do_action(request)
+            .await?
+            .into_inner()
+            .map_err(FlightError::Tonic)
+            .map(|r| {
+                r.map(|r| {
+                    // unwrap inner bytes
+                    let crate::Result { body } = r;
+                    body
+                })
+            });
+
+        Ok(result_stream.boxed())
+    }
+
+    /// Make a `CancelFlightInfo` call to the server and return
+    /// a [`CancelFlightInfoResult`].
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use arrow_flight::{CancelFlightInfoRequest, FlightClient, FlightDescriptor};
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// // Send a 'CMD' request to the server
+    /// let request = FlightDescriptor::new_cmd(b"MOAR DATA".to_vec());
+    /// let flight_info = client
+    ///   .get_flight_info(request)
+    ///   .await
+    ///   .expect("error handshaking");
+    ///
+    /// // Cancel the query
+    /// let request = CancelFlightInfoRequest::new(flight_info);
+    /// let result = client
+    ///   .cancel_flight_info(request)
+    ///   .await
+    ///   .expect("error cancelling");
+    /// # }
+    /// ```
+    pub async fn cancel_flight_info(
+        &mut self,
+        request: CancelFlightInfoRequest,
+    ) -> Result<CancelFlightInfoResult> {
+        let action = Action::new("CancelFlightInfo", request.encode_to_vec());
+        let response = self.do_action(action).await?.try_next().await?;
+        let response = response.ok_or(FlightError::protocol(
+            "Received no response for cancel_flight_info call",
+        ))?;
+        CancelFlightInfoResult::decode(response)
+            .map_err(|e| FlightError::DecodeError(e.to_string()))
+    }
+
+    /// Make a `RenewFlightEndpoint` call to the server and return
+    /// the renewed [`FlightEndpoint`].
+    ///
+    /// # Example:
+    /// ```no_run
+    /// # async fn run() {
+    /// # use arrow_flight::{FlightClient, FlightDescriptor, RenewFlightEndpointRequest};
+    /// # let channel: tonic::transport::Channel = unimplemented!();
+    /// let mut client = FlightClient::new(channel);
+    ///
+    /// // Send a 'CMD' request to the server
+    /// let request = FlightDescriptor::new_cmd(b"MOAR DATA".to_vec());
+    /// let flight_endpoint = client
+    ///   .get_flight_info(request)
+    ///   .await
+    ///   .expect("error handshaking")
+    ///   .endpoint[0];
+    ///
+    /// // Renew the endpoint
+    /// let request = RenewFlightEndpointRequest::new(flight_endpoint);
+    /// let flight_endpoint = client
+    ///   .renew_flight_endpoint(request)
+    ///   .await
+    ///   .expect("error renewing");
+    /// # }
+    /// ```
+    pub async fn renew_flight_endpoint(
+        &mut self,
+        request: RenewFlightEndpointRequest,
+    ) -> Result<FlightEndpoint> {
+        let action = Action::new("RenewFlightEndpoint", request.encode_to_vec());
+        let response = self.do_action(action).await?.try_next().await?;
+        let response = response.ok_or(FlightError::protocol(
+            "Received no response for renew_flight_endpoint call",
+        ))?;
+        FlightEndpoint::decode(response).map_err(|e| FlightError::DecodeError(e.to_string()))
+    }
+
+    /// return a Request, adding any configured metadata
+    fn make_request<T>(&self, t: T) -> tonic::Request<T> {
+        // Pass along metadata
+        let mut request = tonic::Request::new(t);
+        *request.metadata_mut() = self.metadata.clone();
+        request
+    }
+}
diff --git a/arrow-flight/src/decode.rs b/arrow-flight/src/decode.rs
new file mode 100644
index 000000000000..95bbe2b46bb2
--- /dev/null
+++ b/arrow-flight/src/decode.rs
@@ -0,0 +1,434 @@
+// 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.
+
+use crate::{trailers::LazyTrailers, utils::flight_data_to_arrow_batch, FlightData};
+use arrow_array::{ArrayRef, RecordBatch};
+use arrow_buffer::Buffer;
+use arrow_schema::{Schema, SchemaRef};
+use bytes::Bytes;
+use futures::{ready, stream::BoxStream, Stream, StreamExt};
+use std::{collections::HashMap, convert::TryFrom, fmt::Debug, pin::Pin, sync::Arc, task::Poll};
+use tonic::metadata::MetadataMap;
+
+use crate::error::{FlightError, Result};
+
+/// Decodes a [Stream] of [`FlightData`] back into
+/// [`RecordBatch`]es. This can be used to decode the response from an
+/// Arrow Flight server
+///
+/// # Note
+/// To access the lower level Flight messages (e.g. to access
+/// [`FlightData::app_metadata`]), you can call [`Self::into_inner`]
+/// and use the [`FlightDataDecoder`] directly.
+///
+/// # Example:
+/// ```no_run
+/// # async fn f() -> Result<(), arrow_flight::error::FlightError>{
+/// # use bytes::Bytes;
+/// // make a do_get request
+/// use arrow_flight::{
+///   error::Result,
+///   decode::FlightRecordBatchStream,
+///   Ticket,
+///   flight_service_client::FlightServiceClient
+/// };
+/// use tonic::transport::Channel;
+/// use futures::stream::{StreamExt, TryStreamExt};
+///
+/// let client: FlightServiceClient<Channel> = // make client..
+/// # unimplemented!();
+///
+/// let request = tonic::Request::new(
+///   Ticket { ticket: Bytes::new() }
+/// );
+///
+/// // Get a stream of FlightData;
+/// let flight_data_stream = client
+///   .do_get(request)
+///   .await?
+///   .into_inner();
+///
+/// // Decode stream of FlightData to RecordBatches
+/// let record_batch_stream = FlightRecordBatchStream::new_from_flight_data(
+///   // convert tonic::Status to FlightError
+///   flight_data_stream.map_err(|e| e.into())
+/// );
+///
+/// // Read back RecordBatches
+/// while let Some(batch) = record_batch_stream.next().await {
+///   match batch {
+///     Ok(batch) => { /* process batch */ },
+///     Err(e) => { /* handle error */ },
+///   };
+/// }
+///
+/// # Ok(())
+/// # }
+/// ```
+#[derive(Debug)]
+pub struct FlightRecordBatchStream {
+    /// Optional grpc header metadata.
+    headers: MetadataMap,
+
+    /// Optional grpc trailer metadata.
+    trailers: Option<LazyTrailers>,
+
+    inner: FlightDataDecoder,
+}
+
+impl FlightRecordBatchStream {
+    /// Create a new [`FlightRecordBatchStream`] from a decoded stream
+    pub fn new(inner: FlightDataDecoder) -> Self {
+        Self {
+            inner,
+            headers: MetadataMap::default(),
+            trailers: None,
+        }
+    }
+
+    /// Create a new [`FlightRecordBatchStream`] from a stream of [`FlightData`]
+    pub fn new_from_flight_data<S>(inner: S) -> Self
+    where
+        S: Stream<Item = Result<FlightData>> + Send + 'static,
+    {
+        Self {
+            inner: FlightDataDecoder::new(inner),
+            headers: MetadataMap::default(),
+            trailers: None,
+        }
+    }
+
+    /// Record response headers.
+    pub fn with_headers(self, headers: MetadataMap) -> Self {
+        Self { headers, ..self }
+    }
+
+    /// Record response trailers.
+    pub fn with_trailers(self, trailers: LazyTrailers) -> Self {
+        Self {
+            trailers: Some(trailers),
+            ..self
+        }
+    }
+
+    /// Headers attached to this stream.
+    pub fn headers(&self) -> &MetadataMap {
+        &self.headers
+    }
+
+    /// Trailers attached to this stream.
+    ///
+    /// Note that this will return `None` until the entire stream is consumed.
+    /// Only after calling `next()` returns `None`, might any available trailers be returned.
+    pub fn trailers(&self) -> Option<MetadataMap> {
+        self.trailers.as_ref().and_then(|trailers| trailers.get())
+    }
+
+    /// Has a message defining the schema been received yet?
+    #[deprecated = "use schema().is_some() instead"]
+    pub fn got_schema(&self) -> bool {
+        self.schema().is_some()
+    }
+
+    /// Return schema for the stream, if it has been received
+    pub fn schema(&self) -> Option<&SchemaRef> {
+        self.inner.schema()
+    }
+
+    /// Consume self and return the wrapped [`FlightDataDecoder`]
+    pub fn into_inner(self) -> FlightDataDecoder {
+        self.inner
+    }
+}
+
+impl futures::Stream for FlightRecordBatchStream {
+    type Item = Result<RecordBatch>;
+
+    /// Returns the next [`RecordBatch`] available in this stream, or `None` if
+    /// there are no further results available.
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Result<RecordBatch>>> {
+        loop {
+            let had_schema = self.schema().is_some();
+            let res = ready!(self.inner.poll_next_unpin(cx));
+            match res {
+                // Inner exhausted
+                None => {
+                    return Poll::Ready(None);
+                }
+                Some(Err(e)) => {
+                    return Poll::Ready(Some(Err(e)));
+                }
+                // translate data
+                Some(Ok(data)) => match data.payload {
+                    DecodedPayload::Schema(_) if had_schema => {
+                        return Poll::Ready(Some(Err(FlightError::protocol(
+                            "Unexpectedly saw multiple Schema messages in FlightData stream",
+                        ))));
+                    }
+                    DecodedPayload::Schema(_) => {
+                        // Need next message, poll inner again
+                    }
+                    DecodedPayload::RecordBatch(batch) => {
+                        return Poll::Ready(Some(Ok(batch)));
+                    }
+                    DecodedPayload::None => {
+                        // Need next message
+                    }
+                },
+            }
+        }
+    }
+}
+
+/// Wrapper around a stream of [`FlightData`] that handles the details
+/// of decoding low level Flight messages into [`Schema`] and
+/// [`RecordBatch`]es, including details such as dictionaries.
+///
+/// # Protocol Details
+///
+/// The client handles flight messages as followes:
+///
+/// - **None:** This message has no effect. This is useful to
+///   transmit metadata without any actual payload.
+///
+/// - **Schema:** The schema is (re-)set. Dictionaries are cleared and
+///   the decoded schema is returned.
+///
+/// - **Dictionary Batch:** A new dictionary for a given column is registered. An existing
+///   dictionary for the same column will be overwritten. This
+///   message is NOT visible.
+///
+/// - **Record Batch:** Record batch is created based on the current
+///   schema and dictionaries. This fails if no schema was transmitted
+///   yet.
+///
+/// All other message types (at the time of writing: e.g. tensor and
+/// sparse tensor) lead to an error.
+///
+/// Example usecases
+///
+/// 1. Using this low level stream it is possible to receive a steam
+/// of RecordBatches in FlightData that have different schemas by
+/// handling multiple schema messages separately.
+pub struct FlightDataDecoder {
+    /// Underlying data stream
+    response: BoxStream<'static, Result<FlightData>>,
+    /// Decoding state
+    state: Option<FlightStreamState>,
+    /// Seen the end of the inner stream?
+    done: bool,
+}
+
+impl Debug for FlightDataDecoder {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("FlightDataDecoder")
+            .field("response", &"<stream>")
+            .field("state", &self.state)
+            .field("done", &self.done)
+            .finish()
+    }
+}
+
+impl FlightDataDecoder {
+    /// Create a new wrapper around the stream of [`FlightData`]
+    pub fn new<S>(response: S) -> Self
+    where
+        S: Stream<Item = Result<FlightData>> + Send + 'static,
+    {
+        Self {
+            state: None,
+            response: response.boxed(),
+            done: false,
+        }
+    }
+
+    /// Returns the current schema for this stream
+    pub fn schema(&self) -> Option<&SchemaRef> {
+        self.state.as_ref().map(|state| &state.schema)
+    }
+
+    /// Extracts flight data from the next message, updating decoding
+    /// state as necessary.
+    fn extract_message(&mut self, data: FlightData) -> Result<Option<DecodedFlightData>> {
+        use arrow_ipc::MessageHeader;
+        let message = arrow_ipc::root_as_message(&data.data_header[..])
+            .map_err(|e| FlightError::DecodeError(format!("Error decoding root message: {e}")))?;
+
+        match message.header_type() {
+            MessageHeader::NONE => Ok(Some(DecodedFlightData::new_none(data))),
+            MessageHeader::Schema => {
+                let schema = Schema::try_from(&data)
+                    .map_err(|e| FlightError::DecodeError(format!("Error decoding schema: {e}")))?;
+
+                let schema = Arc::new(schema);
+                let dictionaries_by_field = HashMap::new();
+
+                self.state = Some(FlightStreamState {
+                    schema: Arc::clone(&schema),
+                    dictionaries_by_field,
+                });
+                Ok(Some(DecodedFlightData::new_schema(data, schema)))
+            }
+            MessageHeader::DictionaryBatch => {
+                let state = if let Some(state) = self.state.as_mut() {
+                    state
+                } else {
+                    return Err(FlightError::protocol(
+                        "Received DictionaryBatch prior to Schema",
+                    ));
+                };
+
+                let buffer = Buffer::from_bytes(data.data_body.into());
+                let dictionary_batch = message.header_as_dictionary_batch().ok_or_else(|| {
+                    FlightError::protocol(
+                        "Could not get dictionary batch from DictionaryBatch message",
+                    )
+                })?;
+
+                arrow_ipc::reader::read_dictionary(
+                    &buffer,
+                    dictionary_batch,
+                    &state.schema,
+                    &mut state.dictionaries_by_field,
+                    &message.version(),
+                )
+                .map_err(|e| {
+                    FlightError::DecodeError(format!("Error decoding ipc dictionary: {e}"))
+                })?;
+
+                // Updated internal state, but no decoded message
+                Ok(None)
+            }
+            MessageHeader::RecordBatch => {
+                let state = if let Some(state) = self.state.as_ref() {
+                    state
+                } else {
+                    return Err(FlightError::protocol(
+                        "Received RecordBatch prior to Schema",
+                    ));
+                };
+
+                let batch = flight_data_to_arrow_batch(
+                    &data,
+                    Arc::clone(&state.schema),
+                    &state.dictionaries_by_field,
+                )
+                .map_err(|e| {
+                    FlightError::DecodeError(format!("Error decoding ipc RecordBatch: {e}"))
+                })?;
+
+                Ok(Some(DecodedFlightData::new_record_batch(data, batch)))
+            }
+            other => {
+                let name = other.variant_name().unwrap_or("UNKNOWN");
+                Err(FlightError::protocol(format!("Unexpected message: {name}")))
+            }
+        }
+    }
+}
+
+impl futures::Stream for FlightDataDecoder {
+    type Item = Result<DecodedFlightData>;
+    /// Returns the result of decoding the next [`FlightData`] message
+    /// from the server, or `None` if there are no further results
+    /// available.
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        if self.done {
+            return Poll::Ready(None);
+        }
+        loop {
+            let res = ready!(self.response.poll_next_unpin(cx));
+
+            return Poll::Ready(match res {
+                None => {
+                    self.done = true;
+                    None // inner is exhausted
+                }
+                Some(data) => Some(match data {
+                    Err(e) => Err(e),
+                    Ok(data) => match self.extract_message(data) {
+                        Ok(Some(extracted)) => Ok(extracted),
+                        Ok(None) => continue, // Need next input message
+                        Err(e) => Err(e),
+                    },
+                }),
+            });
+        }
+    }
+}
+
+/// tracks the state needed to reconstruct [`RecordBatch`]es from a
+/// streaming flight response.
+#[derive(Debug)]
+struct FlightStreamState {
+    schema: SchemaRef,
+    dictionaries_by_field: HashMap<i64, ArrayRef>,
+}
+
+/// FlightData and the decoded payload (Schema, RecordBatch), if any
+#[derive(Debug)]
+pub struct DecodedFlightData {
+    pub inner: FlightData,
+    pub payload: DecodedPayload,
+}
+
+impl DecodedFlightData {
+    pub fn new_none(inner: FlightData) -> Self {
+        Self {
+            inner,
+            payload: DecodedPayload::None,
+        }
+    }
+
+    pub fn new_schema(inner: FlightData, schema: SchemaRef) -> Self {
+        Self {
+            inner,
+            payload: DecodedPayload::Schema(schema),
+        }
+    }
+
+    pub fn new_record_batch(inner: FlightData, batch: RecordBatch) -> Self {
+        Self {
+            inner,
+            payload: DecodedPayload::RecordBatch(batch),
+        }
+    }
+
+    /// return the metadata field of the inner flight data
+    pub fn app_metadata(&self) -> Bytes {
+        self.inner.app_metadata.clone()
+    }
+}
+
+/// The result of decoding [`FlightData`]
+#[derive(Debug)]
+pub enum DecodedPayload {
+    /// None (no data was sent in the corresponding FlightData)
+    None,
+
+    /// A decoded Schema message
+    Schema(SchemaRef),
+
+    /// A decoded Record batch.
+    RecordBatch(RecordBatch),
+}
diff --git a/arrow-flight/src/encode.rs b/arrow-flight/src/encode.rs
new file mode 100644
index 000000000000..e6ef9994d487
--- /dev/null
+++ b/arrow-flight/src/encode.rs
@@ -0,0 +1,987 @@
+// 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.
+
+use std::{collections::VecDeque, fmt::Debug, pin::Pin, sync::Arc, task::Poll};
+
+use crate::{error::Result, FlightData, FlightDescriptor, SchemaAsIpc};
+use arrow_array::{ArrayRef, RecordBatch, RecordBatchOptions};
+use arrow_ipc::writer::{DictionaryTracker, IpcDataGenerator, IpcWriteOptions};
+use arrow_schema::{DataType, Field, Fields, Schema, SchemaRef};
+use bytes::Bytes;
+use futures::{ready, stream::BoxStream, Stream, StreamExt};
+
+/// Creates a [`Stream`] of [`FlightData`]s from a
+/// `Stream` of [`Result`]<[`RecordBatch`], [`FlightError`]>.
+///
+/// This can be used to implement [`FlightService::do_get`] in an
+/// Arrow Flight implementation;
+///
+/// This structure encodes a stream of `Result`s rather than `RecordBatch`es  to
+/// propagate errors from streaming execution, where the generation of the
+/// `RecordBatch`es is incremental, and an error may occur even after
+/// several have already been successfully produced.
+///
+/// # Caveats
+///   1. When [`DictionaryHandling`] is [`DictionaryHandling::Hydrate`], [`DictionaryArray`](arrow_array::array::DictionaryArray)s
+///   are converted to their underlying types prior to transport.
+///   When [`DictionaryHandling`] is [`DictionaryHandling::Resend`], Dictionary [`FlightData`] is sent with every
+///   [`RecordBatch`] that contains a [`DictionaryArray`](arrow_array::array::DictionaryArray).
+///   See <https://github.com/apache/arrow-rs/issues/3389>.
+///
+/// # Example
+/// ```no_run
+/// # use std::sync::Arc;
+/// # use arrow_array::{ArrayRef, RecordBatch, UInt32Array};
+/// # async fn f() {
+/// # let c1 = UInt32Array::from(vec![1, 2, 3, 4, 5, 6]);
+/// # let batch = RecordBatch::try_from_iter(vec![
+/// #      ("a", Arc::new(c1) as ArrayRef)
+/// #   ])
+/// #   .expect("cannot create record batch");
+/// use arrow_flight::encode::FlightDataEncoderBuilder;
+///
+/// // Get an input stream of Result<RecordBatch, FlightError>
+/// let input_stream = futures::stream::iter(vec![Ok(batch)]);
+///
+/// // Build a stream of `Result<FlightData>` (e.g. to return for do_get)
+/// let flight_data_stream = FlightDataEncoderBuilder::new()
+///  .build(input_stream);
+///
+/// // Create a tonic `Response` that can be returned from a Flight server
+/// let response = tonic::Response::new(flight_data_stream);
+/// # }
+/// ```
+///
+/// # Example: Sending `Vec<RecordBatch>`
+///
+/// You can create a [`Stream`] to pass to [`Self::build`] from an existing
+/// `Vec` of `RecordBatch`es like this:
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::{ArrayRef, RecordBatch, UInt32Array};
+/// # async fn f() {
+/// # fn make_batches() -> Vec<RecordBatch> {
+/// #   let c1 = UInt32Array::from(vec![1, 2, 3, 4, 5, 6]);
+/// #   let batch = RecordBatch::try_from_iter(vec![
+/// #      ("a", Arc::new(c1) as ArrayRef)
+/// #   ])
+/// #   .expect("cannot create record batch");
+/// #   vec![batch.clone(), batch.clone()]
+/// # }
+/// use arrow_flight::encode::FlightDataEncoderBuilder;
+///
+/// // Get batches that you want to send via Flight
+/// let batches: Vec<RecordBatch> = make_batches();
+///
+/// // Create an input stream of Result<RecordBatch, FlightError>
+/// let input_stream = futures::stream::iter(
+///   batches.into_iter().map(Ok)
+/// );
+///
+/// // Build a stream of `Result<FlightData>` (e.g. to return for do_get)
+/// let flight_data_stream = FlightDataEncoderBuilder::new()
+///  .build(input_stream);
+/// # }
+/// ```
+///
+/// [`FlightService::do_get`]: crate::flight_service_server::FlightService::do_get
+/// [`FlightError`]: crate::error::FlightError
+#[derive(Debug)]
+pub struct FlightDataEncoderBuilder {
+    /// The maximum approximate target message size in bytes
+    /// (see details on [`Self::with_max_flight_data_size`]).
+    max_flight_data_size: usize,
+    /// Ipc writer options
+    options: IpcWriteOptions,
+    /// Metadata to add to the schema message
+    app_metadata: Bytes,
+    /// Optional schema, if known before data.
+    schema: Option<SchemaRef>,
+    /// Optional flight descriptor, if known before data.
+    descriptor: Option<FlightDescriptor>,
+    /// Deterimines how `DictionaryArray`s are encoded for transport.
+    /// See [`DictionaryHandling`] for more information.
+    dictionary_handling: DictionaryHandling,
+}
+
+/// Default target size for encoded [`FlightData`].
+///
+/// Note this value would normally be 4MB, but the size calculation is
+/// somewhat inexact, so we set it to 2MB.
+pub const GRPC_TARGET_MAX_FLIGHT_SIZE_BYTES: usize = 2097152;
+
+impl Default for FlightDataEncoderBuilder {
+    fn default() -> Self {
+        Self {
+            max_flight_data_size: GRPC_TARGET_MAX_FLIGHT_SIZE_BYTES,
+            options: IpcWriteOptions::default(),
+            app_metadata: Bytes::new(),
+            schema: None,
+            descriptor: None,
+            dictionary_handling: DictionaryHandling::Hydrate,
+        }
+    }
+}
+
+impl FlightDataEncoderBuilder {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Set the (approximate) maximum size, in bytes, of the
+    /// [`FlightData`] produced by this encoder. Defaults to 2MB.
+    ///
+    /// Since there is often a maximum message size for gRPC messages
+    /// (typically around 4MB), this encoder splits up [`RecordBatch`]s
+    /// (preserving order) into multiple [`FlightData`] objects to
+    /// limit the size individual messages sent via gRPC.
+    ///
+    /// The size is approximate because of the additional encoding
+    /// overhead on top of the underlying data buffers themselves.
+    pub fn with_max_flight_data_size(mut self, max_flight_data_size: usize) -> Self {
+        self.max_flight_data_size = max_flight_data_size;
+        self
+    }
+
+    /// Set [`DictionaryHandling`] for encoder
+    pub fn with_dictionary_handling(mut self, dictionary_handling: DictionaryHandling) -> Self {
+        self.dictionary_handling = dictionary_handling;
+        self
+    }
+
+    /// Specify application specific metadata included in the
+    /// [`FlightData::app_metadata`] field of the the first Schema
+    /// message
+    pub fn with_metadata(mut self, app_metadata: Bytes) -> Self {
+        self.app_metadata = app_metadata;
+        self
+    }
+
+    /// Set the [`IpcWriteOptions`] used to encode the [`RecordBatch`]es for transport.
+    pub fn with_options(mut self, options: IpcWriteOptions) -> Self {
+        self.options = options;
+        self
+    }
+
+    /// Specify a schema for the RecordBatches being sent. If a schema
+    /// is not specified, an encoded Schema message will be sent when
+    /// the first [`RecordBatch`], if any, is encoded. Some clients
+    /// expect a Schema message even if there is no data sent.
+    pub fn with_schema(mut self, schema: SchemaRef) -> Self {
+        self.schema = Some(schema);
+        self
+    }
+
+    /// Specify a flight descriptor in the first FlightData message.
+    pub fn with_flight_descriptor(mut self, descriptor: Option<FlightDescriptor>) -> Self {
+        self.descriptor = descriptor;
+        self
+    }
+
+    /// Takes a [`Stream`] of [`Result<RecordBatch>`] and returns a [`Stream`]
+    /// of [`FlightData`], consuming self.
+    ///
+    /// See example on [`Self`] and [`FlightDataEncoder`] for more details
+    pub fn build<S>(self, input: S) -> FlightDataEncoder
+    where
+        S: Stream<Item = Result<RecordBatch>> + Send + 'static,
+    {
+        let Self {
+            max_flight_data_size,
+            options,
+            app_metadata,
+            schema,
+            descriptor,
+            dictionary_handling,
+        } = self;
+
+        FlightDataEncoder::new(
+            input.boxed(),
+            schema,
+            max_flight_data_size,
+            options,
+            app_metadata,
+            descriptor,
+            dictionary_handling,
+        )
+    }
+}
+
+/// Stream that encodes a stream of record batches to flight data.
+///
+/// See [`FlightDataEncoderBuilder`] for details and example.
+pub struct FlightDataEncoder {
+    /// Input stream
+    inner: BoxStream<'static, Result<RecordBatch>>,
+    /// schema, set after the first batch
+    schema: Option<SchemaRef>,
+    /// Target maximum size of flight data
+    /// (see details on [`FlightDataEncoderBuilder::with_max_flight_data_size`]).
+    max_flight_data_size: usize,
+    /// do the encoding / tracking of dictionaries
+    encoder: FlightIpcEncoder,
+    /// optional metadata to add to schema FlightData
+    app_metadata: Option<Bytes>,
+    /// data queued up to send but not yet sent
+    queue: VecDeque<FlightData>,
+    /// Is this stream done (inner is empty or errored)
+    done: bool,
+    /// cleared after the first FlightData message is sent
+    descriptor: Option<FlightDescriptor>,
+    /// Deterimines how `DictionaryArray`s are encoded for transport.
+    /// See [`DictionaryHandling`] for more information.
+    dictionary_handling: DictionaryHandling,
+}
+
+impl FlightDataEncoder {
+    fn new(
+        inner: BoxStream<'static, Result<RecordBatch>>,
+        schema: Option<SchemaRef>,
+        max_flight_data_size: usize,
+        options: IpcWriteOptions,
+        app_metadata: Bytes,
+        descriptor: Option<FlightDescriptor>,
+        dictionary_handling: DictionaryHandling,
+    ) -> Self {
+        let mut encoder = Self {
+            inner,
+            schema: None,
+            max_flight_data_size,
+            encoder: FlightIpcEncoder::new(
+                options,
+                dictionary_handling != DictionaryHandling::Resend,
+            ),
+            app_metadata: Some(app_metadata),
+            queue: VecDeque::new(),
+            done: false,
+            descriptor,
+            dictionary_handling,
+        };
+
+        // If schema is known up front, enqueue it immediately
+        if let Some(schema) = schema {
+            encoder.encode_schema(&schema);
+        }
+
+        encoder
+    }
+
+    /// Place the `FlightData` in the queue to send
+    fn queue_message(&mut self, mut data: FlightData) {
+        if let Some(descriptor) = self.descriptor.take() {
+            data.flight_descriptor = Some(descriptor);
+        }
+        self.queue.push_back(data);
+    }
+
+    /// Place the `FlightData` in the queue to send
+    fn queue_messages(&mut self, datas: impl IntoIterator<Item = FlightData>) {
+        for data in datas {
+            self.queue_message(data)
+        }
+    }
+
+    /// Encodes schema as a [`FlightData`] in self.queue.
+    /// Updates `self.schema` and returns the new schema
+    fn encode_schema(&mut self, schema: &SchemaRef) -> SchemaRef {
+        // The first message is the schema message, and all
+        // batches have the same schema
+        let send_dictionaries = self.dictionary_handling == DictionaryHandling::Resend;
+        let schema = Arc::new(prepare_schema_for_flight(schema, send_dictionaries));
+        let mut schema_flight_data = self.encoder.encode_schema(&schema);
+
+        // attach any metadata requested
+        if let Some(app_metadata) = self.app_metadata.take() {
+            schema_flight_data.app_metadata = app_metadata;
+        }
+        self.queue_message(schema_flight_data);
+        // remember schema
+        self.schema = Some(schema.clone());
+        schema
+    }
+
+    /// Encodes batch into one or more `FlightData` messages in self.queue
+    fn encode_batch(&mut self, batch: RecordBatch) -> Result<()> {
+        let schema = match &self.schema {
+            Some(schema) => schema.clone(),
+            // encode the schema if this is the first time we have seen it
+            None => self.encode_schema(&batch.schema()),
+        };
+
+        // encode the batch
+        let send_dictionaries = self.dictionary_handling == DictionaryHandling::Resend;
+        let batch = prepare_batch_for_flight(&batch, schema, send_dictionaries)?;
+
+        for batch in split_batch_for_grpc_response(batch, self.max_flight_data_size) {
+            let (flight_dictionaries, flight_batch) = self.encoder.encode_batch(&batch)?;
+
+            self.queue_messages(flight_dictionaries);
+            self.queue_message(flight_batch);
+        }
+
+        Ok(())
+    }
+}
+
+impl Stream for FlightDataEncoder {
+    type Item = Result<FlightData>;
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Option<Self::Item>> {
+        loop {
+            if self.done && self.queue.is_empty() {
+                return Poll::Ready(None);
+            }
+
+            // Any messages queued to send?
+            if let Some(data) = self.queue.pop_front() {
+                return Poll::Ready(Some(Ok(data)));
+            }
+
+            // Get next batch
+            let batch = ready!(self.inner.poll_next_unpin(cx));
+
+            match batch {
+                None => {
+                    // inner is done
+                    self.done = true;
+                    // queue must also be empty so we are done
+                    assert!(self.queue.is_empty());
+                    return Poll::Ready(None);
+                }
+                Some(Err(e)) => {
+                    // error from inner
+                    self.done = true;
+                    self.queue.clear();
+                    return Poll::Ready(Some(Err(e)));
+                }
+                Some(Ok(batch)) => {
+                    // had data, encode into the queue
+                    if let Err(e) = self.encode_batch(batch) {
+                        self.done = true;
+                        self.queue.clear();
+                        return Poll::Ready(Some(Err(e)));
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// Defines how a [`FlightDataEncoder`] encodes [`DictionaryArray`]s
+///
+/// [`DictionaryArray`]: arrow_array::DictionaryArray
+#[derive(Debug, PartialEq)]
+pub enum DictionaryHandling {
+    /// Expands to the underlying type (default). This likely sends more data
+    /// over the network but requires less memory (dictionaries are not tracked)
+    /// and is more compatible with other arrow flight client implementations
+    /// that may not support `DictionaryEncoding`
+    ///
+    /// An IPC response, streaming or otherwise, defines its schema up front
+    /// which defines the mapping from dictionary IDs. It then sends these
+    /// dictionaries over the wire.
+    ///
+    /// This requires identifying the different dictionaries in use, assigning
+    /// them IDs, and sending new dictionaries, delta or otherwise, when needed
+    ///
+    /// See also:
+    /// * <https://github.com/apache/arrow-rs/issues/1206>
+    Hydrate,
+    /// Send dictionary FlightData with every RecordBatch that contains a
+    /// [`DictionaryArray`]. See [`Self::Hydrate`] for more tradeoffs. No
+    /// attempt is made to skip sending the same (logical) dictionary values
+    /// twice.
+    ///
+    /// [`DictionaryArray`]: arrow_array::DictionaryArray
+    Resend,
+}
+
+/// Prepare an arrow Schema for transport over the Arrow Flight protocol
+///
+/// Convert dictionary types to underlying types
+///
+/// See hydrate_dictionary for more information
+fn prepare_schema_for_flight(schema: &Schema, send_dictionaries: bool) -> Schema {
+    let fields: Fields = schema
+        .fields()
+        .iter()
+        .map(|field| match field.data_type() {
+            DataType::Dictionary(_, value_type) if !send_dictionaries => Field::new(
+                field.name(),
+                value_type.as_ref().clone(),
+                field.is_nullable(),
+            )
+            .with_metadata(field.metadata().clone()),
+            _ => field.as_ref().clone(),
+        })
+        .collect();
+
+    Schema::new(fields).with_metadata(schema.metadata().clone())
+}
+
+/// Split [`RecordBatch`] so it hopefully fits into a gRPC response.
+///
+/// Data is zero-copy sliced into batches.
+///
+/// Note: this method does not take into account already sliced
+/// arrays: <https://github.com/apache/arrow-rs/issues/3407>
+fn split_batch_for_grpc_response(
+    batch: RecordBatch,
+    max_flight_data_size: usize,
+) -> Vec<RecordBatch> {
+    let size = batch
+        .columns()
+        .iter()
+        .map(|col| col.get_buffer_memory_size())
+        .sum::<usize>();
+
+    let n_batches =
+        (size / max_flight_data_size + usize::from(size % max_flight_data_size != 0)).max(1);
+    let rows_per_batch = (batch.num_rows() / n_batches).max(1);
+    let mut out = Vec::with_capacity(n_batches + 1);
+
+    let mut offset = 0;
+    while offset < batch.num_rows() {
+        let length = (rows_per_batch).min(batch.num_rows() - offset);
+        out.push(batch.slice(offset, length));
+
+        offset += length;
+    }
+
+    out
+}
+
+/// The data needed to encode a stream of flight data, holding on to
+/// shared Dictionaries.
+///
+/// TODO: at allow dictionaries to be flushed / avoid building them
+///
+/// TODO limit on the number of dictionaries???
+struct FlightIpcEncoder {
+    options: IpcWriteOptions,
+    data_gen: IpcDataGenerator,
+    dictionary_tracker: DictionaryTracker,
+}
+
+impl FlightIpcEncoder {
+    fn new(options: IpcWriteOptions, error_on_replacement: bool) -> Self {
+        Self {
+            options,
+            data_gen: IpcDataGenerator::default(),
+            dictionary_tracker: DictionaryTracker::new(error_on_replacement),
+        }
+    }
+
+    /// Encode a schema as a FlightData
+    fn encode_schema(&self, schema: &Schema) -> FlightData {
+        SchemaAsIpc::new(schema, &self.options).into()
+    }
+
+    /// Convert a `RecordBatch` to a Vec of `FlightData` representing
+    /// dictionaries and a `FlightData` representing the batch
+    fn encode_batch(&mut self, batch: &RecordBatch) -> Result<(Vec<FlightData>, FlightData)> {
+        let (encoded_dictionaries, encoded_batch) =
+            self.data_gen
+                .encoded_batch(batch, &mut self.dictionary_tracker, &self.options)?;
+
+        let flight_dictionaries = encoded_dictionaries.into_iter().map(Into::into).collect();
+        let flight_batch = encoded_batch.into();
+
+        Ok((flight_dictionaries, flight_batch))
+    }
+}
+
+/// Prepares a RecordBatch for transport over the Arrow Flight protocol
+///
+/// This means:
+///
+/// 1. Hydrates any dictionaries to its underlying type. See
+/// hydrate_dictionary for more information.
+///
+fn prepare_batch_for_flight(
+    batch: &RecordBatch,
+    schema: SchemaRef,
+    send_dictionaries: bool,
+) -> Result<RecordBatch> {
+    let columns = batch
+        .columns()
+        .iter()
+        .map(|c| hydrate_dictionary(c, send_dictionaries))
+        .collect::<Result<Vec<_>>>()?;
+
+    let options = RecordBatchOptions::new().with_row_count(Some(batch.num_rows()));
+
+    Ok(RecordBatch::try_new_with_options(
+        schema, columns, &options,
+    )?)
+}
+
+/// Hydrates a dictionary to its underlying type if send_dictionaries is false. If send_dictionaries
+/// is true, dictionaries are sent with every batch which is not as optimal as described in [DictionaryHandling::Hydrate] above,
+/// but does enable sending DictionaryArray's via Flight.
+fn hydrate_dictionary(array: &ArrayRef, send_dictionaries: bool) -> Result<ArrayRef> {
+    let arr = match array.data_type() {
+        DataType::Dictionary(_, value) if !send_dictionaries => arrow_cast::cast(array, value)?,
+        _ => Arc::clone(array),
+    };
+    Ok(arr)
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow_array::*;
+    use arrow_array::{cast::downcast_array, types::*};
+    use arrow_cast::pretty::pretty_format_batches;
+    use std::collections::HashMap;
+
+    use crate::decode::{DecodedPayload, FlightDataDecoder};
+
+    use super::*;
+
+    #[test]
+    /// ensure only the batch's used data (not the allocated data) is sent
+    /// <https://github.com/apache/arrow-rs/issues/208>
+    fn test_encode_flight_data() {
+        let options = IpcWriteOptions::default();
+        let c1 = UInt32Array::from(vec![1, 2, 3, 4, 5, 6]);
+
+        let batch = RecordBatch::try_from_iter(vec![("a", Arc::new(c1) as ArrayRef)])
+            .expect("cannot create record batch");
+        let schema = batch.schema();
+
+        let (_, baseline_flight_batch) = make_flight_data(&batch, &options);
+
+        let big_batch = batch.slice(0, batch.num_rows() - 1);
+        let optimized_big_batch = prepare_batch_for_flight(&big_batch, Arc::clone(&schema), false)
+            .expect("failed to optimize");
+        let (_, optimized_big_flight_batch) = make_flight_data(&optimized_big_batch, &options);
+
+        assert_eq!(
+            baseline_flight_batch.data_body.len(),
+            optimized_big_flight_batch.data_body.len()
+        );
+
+        let small_batch = batch.slice(0, 1);
+        let optimized_small_batch =
+            prepare_batch_for_flight(&small_batch, Arc::clone(&schema), false)
+                .expect("failed to optimize");
+        let (_, optimized_small_flight_batch) = make_flight_data(&optimized_small_batch, &options);
+
+        assert!(
+            baseline_flight_batch.data_body.len() > optimized_small_flight_batch.data_body.len()
+        );
+    }
+
+    #[tokio::test]
+    async fn test_dictionary_hydration() {
+        let arr: DictionaryArray<UInt16Type> = vec!["a", "a", "b"].into_iter().collect();
+        let schema = Arc::new(Schema::new(vec![Field::new_dictionary(
+            "dict",
+            DataType::UInt16,
+            DataType::Utf8,
+            false,
+        )]));
+        let batch = RecordBatch::try_new(schema, vec![Arc::new(arr)]).unwrap();
+        let encoder =
+            FlightDataEncoderBuilder::default().build(futures::stream::once(async { Ok(batch) }));
+        let mut decoder = FlightDataDecoder::new(encoder);
+        let expected_schema = Schema::new(vec![Field::new("dict", DataType::Utf8, false)]);
+        let expected_schema = Arc::new(expected_schema);
+        while let Some(decoded) = decoder.next().await {
+            let decoded = decoded.unwrap();
+            match decoded.payload {
+                DecodedPayload::None => {}
+                DecodedPayload::Schema(s) => assert_eq!(s, expected_schema),
+                DecodedPayload::RecordBatch(b) => {
+                    assert_eq!(b.schema(), expected_schema);
+                    let expected_array = StringArray::from(vec!["a", "a", "b"]);
+                    let actual_array = b.column_by_name("dict").unwrap();
+                    let actual_array = downcast_array::<StringArray>(actual_array);
+
+                    assert_eq!(actual_array, expected_array);
+                }
+            }
+        }
+    }
+
+    #[tokio::test]
+    async fn test_send_dictionaries() {
+        let schema = Arc::new(Schema::new(vec![Field::new_dictionary(
+            "dict",
+            DataType::UInt16,
+            DataType::Utf8,
+            false,
+        )]));
+
+        let arr_one: Arc<DictionaryArray<UInt16Type>> =
+            Arc::new(vec!["a", "a", "b"].into_iter().collect());
+        let arr_two: Arc<DictionaryArray<UInt16Type>> =
+            Arc::new(vec!["b", "a", "c"].into_iter().collect());
+        let batch_one = RecordBatch::try_new(schema.clone(), vec![arr_one.clone()]).unwrap();
+        let batch_two = RecordBatch::try_new(schema.clone(), vec![arr_two.clone()]).unwrap();
+
+        let encoder = FlightDataEncoderBuilder::default()
+            .with_dictionary_handling(DictionaryHandling::Resend)
+            .build(futures::stream::iter(vec![Ok(batch_one), Ok(batch_two)]));
+
+        let mut decoder = FlightDataDecoder::new(encoder);
+        let mut expected_array = arr_one;
+        while let Some(decoded) = decoder.next().await {
+            let decoded = decoded.unwrap();
+            match decoded.payload {
+                DecodedPayload::None => {}
+                DecodedPayload::Schema(s) => assert_eq!(s, schema),
+                DecodedPayload::RecordBatch(b) => {
+                    assert_eq!(b.schema(), schema);
+
+                    let actual_array = Arc::new(downcast_array::<DictionaryArray<UInt16Type>>(
+                        b.column_by_name("dict").unwrap(),
+                    ));
+
+                    assert_eq!(actual_array, expected_array);
+
+                    expected_array = arr_two.clone();
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn test_schema_metadata_encoded() {
+        let schema = Schema::new(vec![Field::new("data", DataType::Int32, false)]).with_metadata(
+            HashMap::from([("some_key".to_owned(), "some_value".to_owned())]),
+        );
+
+        let got = prepare_schema_for_flight(&schema, false);
+        assert!(got.metadata().contains_key("some_key"));
+    }
+
+    #[test]
+    fn test_encode_no_column_batch() {
+        let batch = RecordBatch::try_new_with_options(
+            Arc::new(Schema::empty()),
+            vec![],
+            &RecordBatchOptions::new().with_row_count(Some(10)),
+        )
+        .expect("cannot create record batch");
+
+        prepare_batch_for_flight(&batch, batch.schema(), false).expect("failed to optimize");
+    }
+
+    pub fn make_flight_data(
+        batch: &RecordBatch,
+        options: &IpcWriteOptions,
+    ) -> (Vec<FlightData>, FlightData) {
+        let data_gen = IpcDataGenerator::default();
+        let mut dictionary_tracker = DictionaryTracker::new(false);
+
+        let (encoded_dictionaries, encoded_batch) = data_gen
+            .encoded_batch(batch, &mut dictionary_tracker, options)
+            .expect("DictionaryTracker configured above to not error on replacement");
+
+        let flight_dictionaries = encoded_dictionaries.into_iter().map(Into::into).collect();
+        let flight_batch = encoded_batch.into();
+
+        (flight_dictionaries, flight_batch)
+    }
+
+    #[test]
+    fn test_split_batch_for_grpc_response() {
+        let max_flight_data_size = 1024;
+
+        // no split
+        let c = UInt32Array::from(vec![1, 2, 3, 4, 5, 6]);
+        let batch = RecordBatch::try_from_iter(vec![("a", Arc::new(c) as ArrayRef)])
+            .expect("cannot create record batch");
+        let split = split_batch_for_grpc_response(batch.clone(), max_flight_data_size);
+        assert_eq!(split.len(), 1);
+        assert_eq!(batch, split[0]);
+
+        // split once
+        let n_rows = max_flight_data_size + 1;
+        assert!(n_rows % 2 == 1, "should be an odd number");
+        let c = UInt8Array::from((0..n_rows).map(|i| (i % 256) as u8).collect::<Vec<_>>());
+        let batch = RecordBatch::try_from_iter(vec![("a", Arc::new(c) as ArrayRef)])
+            .expect("cannot create record batch");
+        let split = split_batch_for_grpc_response(batch.clone(), max_flight_data_size);
+        assert_eq!(split.len(), 3);
+        assert_eq!(
+            split.iter().map(|batch| batch.num_rows()).sum::<usize>(),
+            n_rows
+        );
+        let a = pretty_format_batches(&split).unwrap().to_string();
+        let b = pretty_format_batches(&[batch]).unwrap().to_string();
+        assert_eq!(a, b);
+    }
+
+    #[test]
+    fn test_split_batch_for_grpc_response_sizes() {
+        // 2000 8 byte entries into 2k pieces: 8 chunks of 250 rows
+        verify_split(2000, 2 * 1024, vec![250, 250, 250, 250, 250, 250, 250, 250]);
+
+        // 2000 8 byte entries into 4k pieces: 4 chunks of 500 rows
+        verify_split(2000, 4 * 1024, vec![500, 500, 500, 500]);
+
+        // 2023 8 byte entries into 3k pieces does not divide evenly
+        verify_split(2023, 3 * 1024, vec![337, 337, 337, 337, 337, 337, 1]);
+
+        // 10 8 byte entries into 1 byte pieces means each rows gets its own
+        verify_split(10, 1, vec![1, 1, 1, 1, 1, 1, 1, 1, 1, 1]);
+
+        // 10 8 byte entries into 1k byte pieces means one piece
+        verify_split(10, 1024, vec![10]);
+    }
+
+    /// Creates a UInt64Array of 8 byte integers with input_rows rows
+    /// `max_flight_data_size_bytes` pieces and verifies the row counts in
+    /// those pieces
+    fn verify_split(
+        num_input_rows: u64,
+        max_flight_data_size_bytes: usize,
+        expected_sizes: Vec<usize>,
+    ) {
+        let array: UInt64Array = (0..num_input_rows).collect();
+
+        let batch = RecordBatch::try_from_iter(vec![("a", Arc::new(array) as ArrayRef)])
+            .expect("cannot create record batch");
+
+        let input_rows = batch.num_rows();
+
+        let split = split_batch_for_grpc_response(batch.clone(), max_flight_data_size_bytes);
+        let sizes: Vec<_> = split.iter().map(|batch| batch.num_rows()).collect();
+        let output_rows: usize = sizes.iter().sum();
+
+        assert_eq!(sizes, expected_sizes, "mismatch for {batch:?}");
+        assert_eq!(input_rows, output_rows, "mismatch for {batch:?}");
+    }
+
+    // test sending record batches
+    // test sending record batches with multiple different dictionaries
+
+    #[tokio::test]
+    async fn flight_data_size_even() {
+        let s1 = StringArray::from_iter_values(std::iter::repeat(".10 bytes.").take(1024));
+        let i1 = Int16Array::from_iter_values(0..1024);
+        let s2 = StringArray::from_iter_values(std::iter::repeat("6bytes").take(1024));
+        let i2 = Int64Array::from_iter_values(0..1024);
+
+        let batch = RecordBatch::try_from_iter(vec![
+            ("s1", Arc::new(s1) as _),
+            ("i1", Arc::new(i1) as _),
+            ("s2", Arc::new(s2) as _),
+            ("i2", Arc::new(i2) as _),
+        ])
+        .unwrap();
+
+        verify_encoded_split(batch, 112).await;
+    }
+
+    #[tokio::test]
+    async fn flight_data_size_uneven_variable_lengths() {
+        // each row has a longer string than the last with increasing lengths 0 --> 1024
+        let array = StringArray::from_iter_values((0..1024).map(|i| "*".repeat(i)));
+        let batch = RecordBatch::try_from_iter(vec![("data", Arc::new(array) as _)]).unwrap();
+
+        // overage is much higher than ideal
+        // https://github.com/apache/arrow-rs/issues/3478
+        verify_encoded_split(batch, 4304).await;
+    }
+
+    #[tokio::test]
+    async fn flight_data_size_large_row() {
+        // batch with individual that can each exceed the batch size
+        let array1 = StringArray::from_iter_values(vec![
+            "*".repeat(500),
+            "*".repeat(500),
+            "*".repeat(500),
+            "*".repeat(500),
+        ]);
+        let array2 = StringArray::from_iter_values(vec![
+            "*".to_string(),
+            "*".repeat(1000),
+            "*".repeat(2000),
+            "*".repeat(4000),
+        ]);
+
+        let array3 = StringArray::from_iter_values(vec![
+            "*".to_string(),
+            "*".to_string(),
+            "*".repeat(1000),
+            "*".repeat(2000),
+        ]);
+
+        let batch = RecordBatch::try_from_iter(vec![
+            ("a1", Arc::new(array1) as _),
+            ("a2", Arc::new(array2) as _),
+            ("a3", Arc::new(array3) as _),
+        ])
+        .unwrap();
+
+        // 5k over limit (which is 2x larger than limit of 5k)
+        // overage is much higher than ideal
+        // https://github.com/apache/arrow-rs/issues/3478
+        verify_encoded_split(batch, 5800).await;
+    }
+
+    #[tokio::test]
+    async fn flight_data_size_string_dictionary() {
+        // Small dictionary (only 2 distinct values ==> 2 entries in dictionary)
+        let array: DictionaryArray<Int32Type> = (1..1024)
+            .map(|i| match i % 3 {
+                0 => Some("value0"),
+                1 => Some("value1"),
+                _ => None,
+            })
+            .collect();
+
+        let batch = RecordBatch::try_from_iter(vec![("a1", Arc::new(array) as _)]).unwrap();
+
+        verify_encoded_split(batch, 160).await;
+    }
+
+    #[tokio::test]
+    async fn flight_data_size_large_dictionary() {
+        // large dictionary (all distinct values ==> 1024 entries in dictionary)
+        let values: Vec<_> = (1..1024).map(|i| "**".repeat(i)).collect();
+
+        let array: DictionaryArray<Int32Type> = values.iter().map(|s| Some(s.as_str())).collect();
+
+        let batch = RecordBatch::try_from_iter(vec![("a1", Arc::new(array) as _)]).unwrap();
+
+        // overage is much higher than ideal
+        // https://github.com/apache/arrow-rs/issues/3478
+        verify_encoded_split(batch, 3328).await;
+    }
+
+    #[tokio::test]
+    async fn flight_data_size_large_dictionary_repeated_non_uniform() {
+        // large dictionary (1024 distinct values) that are used throughout the array
+        let values = StringArray::from_iter_values((0..1024).map(|i| "******".repeat(i)));
+        let keys = Int32Array::from_iter_values((0..3000).map(|i| (3000 - i) % 1024));
+        let array = DictionaryArray::new(keys, Arc::new(values));
+
+        let batch = RecordBatch::try_from_iter(vec![("a1", Arc::new(array) as _)]).unwrap();
+
+        // overage is much higher than ideal
+        // https://github.com/apache/arrow-rs/issues/3478
+        verify_encoded_split(batch, 5280).await;
+    }
+
+    #[tokio::test]
+    async fn flight_data_size_multiple_dictionaries() {
+        // high cardinality
+        let values1: Vec<_> = (1..1024).map(|i| "**".repeat(i)).collect();
+        // highish cardinality
+        let values2: Vec<_> = (1..1024).map(|i| "**".repeat(i % 10)).collect();
+        // medium cardinality
+        let values3: Vec<_> = (1..1024).map(|i| "**".repeat(i % 100)).collect();
+
+        let array1: DictionaryArray<Int32Type> = values1.iter().map(|s| Some(s.as_str())).collect();
+        let array2: DictionaryArray<Int32Type> = values2.iter().map(|s| Some(s.as_str())).collect();
+        let array3: DictionaryArray<Int32Type> = values3.iter().map(|s| Some(s.as_str())).collect();
+
+        let batch = RecordBatch::try_from_iter(vec![
+            ("a1", Arc::new(array1) as _),
+            ("a2", Arc::new(array2) as _),
+            ("a3", Arc::new(array3) as _),
+        ])
+        .unwrap();
+
+        // overage is much higher than ideal
+        // https://github.com/apache/arrow-rs/issues/3478
+        verify_encoded_split(batch, 4128).await;
+    }
+
+    /// Return size, in memory of flight data
+    fn flight_data_size(d: &FlightData) -> usize {
+        let flight_descriptor_size = d
+            .flight_descriptor
+            .as_ref()
+            .map(|descriptor| {
+                let path_len: usize = descriptor.path.iter().map(|p| p.as_bytes().len()).sum();
+
+                std::mem::size_of_val(descriptor) + descriptor.cmd.len() + path_len
+            })
+            .unwrap_or(0);
+
+        flight_descriptor_size + d.app_metadata.len() + d.data_body.len() + d.data_header.len()
+    }
+
+    /// Coverage for <https://github.com/apache/arrow-rs/issues/3478>
+    ///
+    /// Encodes the specified batch using several values of
+    /// `max_flight_data_size` between 1K to 5K and ensures that the
+    /// resulting size of the flight data stays within the limit
+    /// + `allowed_overage`
+    ///
+    /// `allowed_overage` is how far off the actual data encoding is
+    /// from the target limit that was set. It is an improvement when
+    /// the allowed_overage decreses.
+    ///
+    /// Note this overhead will likely always be greater than zero to
+    /// account for encoding overhead such as IPC headers and padding.
+    ///
+    ///
+    async fn verify_encoded_split(batch: RecordBatch, allowed_overage: usize) {
+        let num_rows = batch.num_rows();
+
+        // Track the overall required maximum overage
+        let mut max_overage_seen = 0;
+
+        for max_flight_data_size in [1024, 2021, 5000] {
+            println!("Encoding {num_rows} with a maximum size of {max_flight_data_size}");
+
+            let mut stream = FlightDataEncoderBuilder::new()
+                .with_max_flight_data_size(max_flight_data_size)
+                .build(futures::stream::iter([Ok(batch.clone())]));
+
+            let mut i = 0;
+            while let Some(data) = stream.next().await.transpose().unwrap() {
+                let actual_data_size = flight_data_size(&data);
+
+                let actual_overage = if actual_data_size > max_flight_data_size {
+                    actual_data_size - max_flight_data_size
+                } else {
+                    0
+                };
+
+                assert!(
+                    actual_overage <= allowed_overage,
+                    "encoded data[{i}]: actual size {actual_data_size}, \
+                         actual_overage: {actual_overage} \
+                         allowed_overage: {allowed_overage}"
+                );
+
+                i += 1;
+
+                max_overage_seen = max_overage_seen.max(actual_overage)
+            }
+        }
+
+        // ensure that the specified overage is exactly the maxmium so
+        // that when the splitting logic improves, the tests must be
+        // updated to reflect the better logic
+        assert_eq!(
+            allowed_overage, max_overage_seen,
+            "Specified overage was too high"
+        );
+    }
+}
diff --git a/arrow-flight/src/error.rs b/arrow-flight/src/error.rs
new file mode 100644
index 000000000000..e054883e965d
--- /dev/null
+++ b/arrow-flight/src/error.rs
@@ -0,0 +1,141 @@
+// 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.
+
+use std::error::Error;
+
+use arrow_schema::ArrowError;
+
+/// Errors for the Apache Arrow Flight crate
+#[derive(Debug)]
+pub enum FlightError {
+    /// Underlying arrow error
+    Arrow(ArrowError),
+    /// Returned when functionality is not yet available.
+    NotYetImplemented(String),
+    /// Error from the underlying tonic library
+    Tonic(tonic::Status),
+    /// Some unexpected message was received
+    ProtocolError(String),
+    /// An error occurred during decoding
+    DecodeError(String),
+    /// External error that can provide source of error by calling `Error::source`.
+    ExternalError(Box<dyn Error + Send + Sync>),
+}
+
+impl FlightError {
+    pub fn protocol(message: impl Into<String>) -> Self {
+        Self::ProtocolError(message.into())
+    }
+
+    /// Wraps an external error in an `ArrowError`.
+    pub fn from_external_error(error: Box<dyn Error + Send + Sync>) -> Self {
+        Self::ExternalError(error)
+    }
+}
+
+impl std::fmt::Display for FlightError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // TODO better format / error
+        write!(f, "{self:?}")
+    }
+}
+
+impl Error for FlightError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        if let Self::ExternalError(e) = self {
+            Some(e.as_ref())
+        } else {
+            None
+        }
+    }
+}
+
+impl From<tonic::Status> for FlightError {
+    fn from(status: tonic::Status) -> Self {
+        Self::Tonic(status)
+    }
+}
+
+impl From<ArrowError> for FlightError {
+    fn from(value: ArrowError) -> Self {
+        Self::Arrow(value)
+    }
+}
+
+// default conversion from FlightError to tonic treats everything
+// other than `Status` as an internal error
+impl From<FlightError> for tonic::Status {
+    fn from(value: FlightError) -> Self {
+        match value {
+            FlightError::Arrow(e) => tonic::Status::internal(e.to_string()),
+            FlightError::NotYetImplemented(e) => tonic::Status::internal(e),
+            FlightError::Tonic(status) => status,
+            FlightError::ProtocolError(e) => tonic::Status::internal(e),
+            FlightError::DecodeError(e) => tonic::Status::internal(e),
+            FlightError::ExternalError(e) => tonic::Status::internal(e.to_string()),
+        }
+    }
+}
+
+pub type Result<T> = std::result::Result<T, FlightError>;
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn error_source() {
+        let e1 = FlightError::DecodeError("foo".into());
+        assert!(e1.source().is_none());
+
+        // one level of wrapping
+        let e2 = FlightError::ExternalError(Box::new(e1));
+        let source = e2.source().unwrap().downcast_ref::<FlightError>().unwrap();
+        assert!(matches!(source, FlightError::DecodeError(_)));
+
+        let e3 = FlightError::ExternalError(Box::new(e2));
+        let source = e3
+            .source()
+            .unwrap()
+            .downcast_ref::<FlightError>()
+            .unwrap()
+            .source()
+            .unwrap()
+            .downcast_ref::<FlightError>()
+            .unwrap();
+
+        assert!(matches!(source, FlightError::DecodeError(_)));
+    }
+
+    #[test]
+    fn error_through_arrow() {
+        // flight error that wraps an arrow error that wraps a flight error
+        let e1 = FlightError::DecodeError("foo".into());
+        let e2 = ArrowError::ExternalError(Box::new(e1));
+        let e3 = FlightError::ExternalError(Box::new(e2));
+
+        // ensure we can find the lowest level error by following source()
+        let mut root_error: &dyn Error = &e3;
+        while let Some(source) = root_error.source() {
+            // walk the next level
+            root_error = source;
+        }
+
+        let source = root_error.downcast_ref::<FlightError>().unwrap();
+        assert!(matches!(source, FlightError::DecodeError(_)));
+    }
+}
diff --git a/arrow-flight/src/lib.rs b/arrow-flight/src/lib.rs
index 3f4f09855353..434d19ce76fe 100644
--- a/arrow-flight/src/lib.rs
+++ b/arrow-flight/src/lib.rs
@@ -15,43 +15,92 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::datatypes::Schema;
-use arrow::error::{ArrowError, Result as ArrowResult};
-use arrow::ipc::{
-    convert, size_prefixed_root_as_message, writer, writer::EncodedData,
-    writer::IpcWriteOptions,
-};
-
+//! A native Rust implementation of [Apache Arrow Flight](https://arrow.apache.org/docs/format/Flight.html)
+//! for exchanging [Arrow](https://arrow.apache.org) data between processes.
+//!
+//! Please see the [arrow-flight crates.io](https://crates.io/crates/arrow-flight)
+//! page for feature flags and more information.
+//!
+//! # Overview
+//!
+//! This crate contains:
+//!
+//! 1. Low level [prost] generated structs
+//!  for Flight gRPC protobuf messages, such as [`FlightData`], [`FlightInfo`],
+//!  [`Location`] and [`Ticket`].
+//!
+//! 2. Low level [tonic] generated [`flight_service_client`] and
+//! [`flight_service_server`].
+//!
+//! 3. Experimental support for [Flight SQL] in [`sql`]. Requires the
+//! `flight-sql-experimental` feature of this crate to be activated.
+//!
+//! [Flight SQL]: https://arrow.apache.org/docs/format/FlightSql.html
+#![allow(rustdoc::invalid_html_tags)]
+
+use arrow_ipc::{convert, writer, writer::EncodedData, writer::IpcWriteOptions};
+use arrow_schema::{ArrowError, Schema};
+
+use arrow_ipc::convert::try_schema_from_ipc_buffer;
+use base64::prelude::BASE64_STANDARD;
+use base64::Engine;
+use bytes::Bytes;
+use prost_types::Timestamp;
 use std::{
     convert::{TryFrom, TryInto},
     fmt,
     ops::Deref,
 };
 
+type ArrowResult<T> = std::result::Result<T, ArrowError>;
+
 #[allow(clippy::derive_partial_eq_without_eq)]
+
 mod gen {
     include!("arrow.flight.protocol.rs");
 }
 
+/// Defines a `Flight` for generation or retrieval.
 pub mod flight_descriptor {
     use super::gen;
     pub use gen::flight_descriptor::DescriptorType;
 }
 
+/// Low Level [tonic] [`FlightServiceClient`](gen::flight_service_client::FlightServiceClient).
 pub mod flight_service_client {
     use super::gen;
     pub use gen::flight_service_client::FlightServiceClient;
 }
 
+/// Low Level [tonic] [`FlightServiceServer`](gen::flight_service_server::FlightServiceServer)
+/// and [`FlightService`](gen::flight_service_server::FlightService).
 pub mod flight_service_server {
     use super::gen;
     pub use gen::flight_service_server::FlightService;
     pub use gen::flight_service_server::FlightServiceServer;
 }
 
+/// Mid Level [`FlightClient`]
+pub mod client;
+pub use client::FlightClient;
+
+/// Decoder to create [`RecordBatch`](arrow_array::RecordBatch) streams from [`FlightData`] streams.
+/// See [`FlightRecordBatchStream`](decode::FlightRecordBatchStream).
+pub mod decode;
+
+/// Encoder to create [`FlightData`] streams from [`RecordBatch`](arrow_array::RecordBatch) streams.
+/// See [`FlightDataEncoderBuilder`](encode::FlightDataEncoderBuilder).
+pub mod encode;
+
+/// Common error types
+pub mod error;
+
 pub use gen::Action;
 pub use gen::ActionType;
 pub use gen::BasicAuth;
+pub use gen::CancelFlightInfoRequest;
+pub use gen::CancelFlightInfoResult;
+pub use gen::CancelStatus;
 pub use gen::Criteria;
 pub use gen::Empty;
 pub use gen::FlightData;
@@ -61,11 +110,16 @@ pub use gen::FlightInfo;
 pub use gen::HandshakeRequest;
 pub use gen::HandshakeResponse;
 pub use gen::Location;
+pub use gen::PollInfo;
 pub use gen::PutResult;
+pub use gen::RenewFlightEndpointRequest;
 pub use gen::Result;
 pub use gen::SchemaResult;
 pub use gen::Ticket;
 
+/// Helper to extract HTTP/gRPC trailers from a tonic stream.
+mod trailers;
+
 pub mod utils;
 
 #[cfg(feature = "flight-sql-experimental")]
@@ -81,21 +135,18 @@ pub struct SchemaAsIpc<'a> {
 /// IpcMessage represents a `Schema` in the format expected in
 /// `FlightInfo.schema`
 #[derive(Debug)]
-pub struct IpcMessage(pub Vec<u8>);
+pub struct IpcMessage(pub Bytes);
 
 // Useful conversion functions
 
-fn flight_schema_as_encoded_data(
-    arrow_schema: &Schema,
-    options: &IpcWriteOptions,
-) -> EncodedData {
+fn flight_schema_as_encoded_data(arrow_schema: &Schema, options: &IpcWriteOptions) -> EncodedData {
     let data_gen = writer::IpcDataGenerator::default();
     data_gen.schema_to_bytes(arrow_schema, options)
 }
 
 fn flight_schema_as_flatbuffer(schema: &Schema, options: &IpcWriteOptions) -> IpcMessage {
     let encoded_data = flight_schema_as_encoded_data(schema, options);
-    IpcMessage(encoded_data.ipc_message)
+    IpcMessage(encoded_data.ipc_message.into())
 }
 
 // Implement a bunch of useful traits for various conversions, displays,
@@ -104,7 +155,7 @@ fn flight_schema_as_flatbuffer(schema: &Schema, options: &IpcWriteOptions) -> Ip
 // Deref
 
 impl Deref for IpcMessage {
-    type Target = Vec<u8>;
+    type Target = [u8];
 
     fn deref(&self) -> &Self::Target {
         &self.0
@@ -135,7 +186,7 @@ impl fmt::Display for FlightData {
         write!(f, "FlightData {{")?;
         write!(f, " descriptor: ")?;
         match &self.flight_descriptor {
-            Some(d) => write!(f, "{}", d)?,
+            Some(d) => write!(f, "{d}")?,
             None => write!(f, "None")?,
         };
         write!(f, ", header: ")?;
@@ -161,7 +212,7 @@ impl fmt::Display for FlightDescriptor {
                 write!(f, "path: [")?;
                 let mut sep = "";
                 for element in &self.path {
-                    write!(f, "{}{}", sep, element)?;
+                    write!(f, "{sep}{element}")?;
                     sep = ", ";
                 }
                 write!(f, "]")?;
@@ -179,16 +230,23 @@ impl fmt::Display for FlightEndpoint {
         write!(f, "FlightEndpoint {{")?;
         write!(f, " ticket: ")?;
         match &self.ticket {
-            Some(value) => write!(f, "{}", value),
-            None => write!(f, " none"),
+            Some(value) => write!(f, "{value}"),
+            None => write!(f, " None"),
         }?;
         write!(f, ", location: [")?;
         let mut sep = "";
         for location in &self.location {
-            write!(f, "{}{}", sep, location)?;
+            write!(f, "{sep}{location}")?;
             sep = ", ";
         }
         write!(f, "]")?;
+        write!(f, ", expiration_time:")?;
+        match &self.expiration_time {
+            Some(value) => write!(f, " {value}"),
+            None => write!(f, " None"),
+        }?;
+        write!(f, ", app_metadata: ")?;
+        limited_fmt(f, &self.app_metadata, 8)?;
         write!(f, " }}")
     }
 }
@@ -198,20 +256,82 @@ impl fmt::Display for FlightInfo {
         let ipc_message = IpcMessage(self.schema.clone());
         let schema: Schema = ipc_message.try_into().map_err(|_err| fmt::Error)?;
         write!(f, "FlightInfo {{")?;
-        write!(f, " schema: {}", schema)?;
+        write!(f, " schema: {schema}")?;
         write!(f, ", descriptor:")?;
         match &self.flight_descriptor {
-            Some(d) => write!(f, " {}", d),
+            Some(d) => write!(f, " {d}"),
             None => write!(f, " None"),
         }?;
         write!(f, ", endpoint: [")?;
         let mut sep = "";
         for endpoint in &self.endpoint {
-            write!(f, "{}{}", sep, endpoint)?;
+            write!(f, "{sep}{endpoint}")?;
             sep = ", ";
         }
         write!(f, "], total_records: {}", self.total_records)?;
         write!(f, ", total_bytes: {}", self.total_bytes)?;
+        write!(f, ", ordered: {}", self.ordered)?;
+        write!(f, ", app_metadata: ")?;
+        limited_fmt(f, &self.app_metadata, 8)?;
+        write!(f, " }}")
+    }
+}
+
+impl fmt::Display for PollInfo {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "PollInfo {{")?;
+        write!(f, " info:")?;
+        match &self.info {
+            Some(value) => write!(f, " {value}"),
+            None => write!(f, " None"),
+        }?;
+        write!(f, ", descriptor:")?;
+        match &self.flight_descriptor {
+            Some(d) => write!(f, " {d}"),
+            None => write!(f, " None"),
+        }?;
+        write!(f, ", progress:")?;
+        match &self.progress {
+            Some(value) => write!(f, " {value}"),
+            None => write!(f, " None"),
+        }?;
+        write!(f, ", expiration_time:")?;
+        match &self.expiration_time {
+            Some(value) => write!(f, " {value}"),
+            None => write!(f, " None"),
+        }?;
+        write!(f, " }}")
+    }
+}
+
+impl fmt::Display for CancelFlightInfoRequest {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "CancelFlightInfoRequest {{")?;
+        write!(f, " info: ")?;
+        match &self.info {
+            Some(value) => write!(f, "{value}")?,
+            None => write!(f, "None")?,
+        };
+        write!(f, " }}")
+    }
+}
+
+impl fmt::Display for CancelFlightInfoResult {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "CancelFlightInfoResult {{")?;
+        write!(f, " status: {}", self.status().as_str_name())?;
+        write!(f, " }}")
+    }
+}
+
+impl fmt::Display for RenewFlightEndpointRequest {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "RenewFlightEndpointRequest {{")?;
+        write!(f, " endpoint: ")?;
+        match &self.endpoint {
+            Some(value) => write!(f, "{value}")?,
+            None => write!(f, "None")?,
+        };
         write!(f, " }}")
     }
 }
@@ -228,7 +348,7 @@ impl fmt::Display for Ticket {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(f, "Ticket {{")?;
         write!(f, " ticket: ")?;
-        write!(f, "{}", base64::encode(&self.ticket))
+        write!(f, "{}", BASE64_STANDARD.encode(&self.ticket))
     }
 }
 
@@ -237,8 +357,8 @@ impl fmt::Display for Ticket {
 impl From<EncodedData> for FlightData {
     fn from(data: EncodedData) -> Self {
         FlightData {
-            data_header: data.ipc_message,
-            data_body: data.arrow_data,
+            data_header: data.ipc_message.into(),
+            data_body: data.arrow_data.into(),
             ..Default::default()
         }
     }
@@ -254,20 +374,17 @@ impl From<SchemaAsIpc<'_>> for FlightData {
     }
 }
 
-impl From<SchemaAsIpc<'_>> for SchemaResult {
-    fn from(schema_ipc: SchemaAsIpc) -> Self {
-        let IpcMessage(vals) = flight_schema_as_flatbuffer(schema_ipc.0, schema_ipc.1);
-        SchemaResult { schema: vals }
-    }
-}
-
-// TryFrom...
-
-impl TryFrom<i32> for DescriptorType {
+impl TryFrom<SchemaAsIpc<'_>> for SchemaResult {
     type Error = ArrowError;
 
-    fn try_from(value: i32) -> ArrowResult<Self> {
-        value.try_into()
+    fn try_from(schema_ipc: SchemaAsIpc) -> ArrowResult<Self> {
+        // According to the definition from `Flight.proto`
+        // The schema of the dataset in its IPC form:
+        //   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+        //   4 bytes - the byte length of the payload
+        //   a flatbuffer Message whose header is the Schema
+        let IpcMessage(vals) = schema_to_ipc_format(schema_ipc)?;
+        Ok(SchemaResult { schema: vals })
     }
 }
 
@@ -275,22 +392,25 @@ impl TryFrom<SchemaAsIpc<'_>> for IpcMessage {
     type Error = ArrowError;
 
     fn try_from(schema_ipc: SchemaAsIpc) -> ArrowResult<Self> {
-        let pair = *schema_ipc;
-        let encoded_data = flight_schema_as_encoded_data(pair.0, pair.1);
-
-        let mut schema = vec![];
-        arrow::ipc::writer::write_message(&mut schema, encoded_data, pair.1)?;
-        Ok(IpcMessage(schema))
+        schema_to_ipc_format(schema_ipc)
     }
 }
 
+fn schema_to_ipc_format(schema_ipc: SchemaAsIpc) -> ArrowResult<IpcMessage> {
+    let pair = *schema_ipc;
+    let encoded_data = flight_schema_as_encoded_data(pair.0, pair.1);
+
+    let mut schema = vec![];
+    writer::write_message(&mut schema, encoded_data, pair.1)?;
+    Ok(IpcMessage(schema.into()))
+}
+
 impl TryFrom<&FlightData> for Schema {
     type Error = ArrowError;
     fn try_from(data: &FlightData) -> ArrowResult<Self> {
-        convert::schema_from_bytes(&data.data_header[..]).map_err(|err| {
+        convert::try_schema_from_flatbuffer_bytes(&data.data_header[..]).map_err(|err| {
             ArrowError::ParseError(format!(
-                "Unable to convert flight data to Arrow schema: {}",
-                err
+                "Unable to convert flight data to Arrow schema: {err}"
             ))
         })
     }
@@ -300,8 +420,7 @@ impl TryFrom<FlightInfo> for Schema {
     type Error = ArrowError;
 
     fn try_from(value: FlightInfo) -> ArrowResult<Self> {
-        let msg = IpcMessage(value.schema);
-        msg.try_into()
+        value.try_decode_schema()
     }
 }
 
@@ -309,63 +428,97 @@ impl TryFrom<IpcMessage> for Schema {
     type Error = ArrowError;
 
     fn try_from(value: IpcMessage) -> ArrowResult<Self> {
-        // CONTINUATION TAKES 4 BYTES
-        // SIZE TAKES 4 BYTES (so read msg as size prefixed)
-        let msg = size_prefixed_root_as_message(&value.0[4..]).map_err(|err| {
-            ArrowError::ParseError(format!(
-                "Unable to convert flight info to a message: {}",
-                err
-            ))
-        })?;
-        let ipc_schema = msg.header_as_schema().ok_or_else(|| {
-            ArrowError::ParseError(
-                "Unable to convert flight info to a schema".to_string(),
-            )
-        })?;
-        Ok(convert::fb_to_schema(ipc_schema))
+        try_schema_from_ipc_buffer(&value)
     }
 }
 
 impl TryFrom<&SchemaResult> for Schema {
     type Error = ArrowError;
     fn try_from(data: &SchemaResult) -> ArrowResult<Self> {
-        convert::schema_from_bytes(&data.schema[..]).map_err(|err| {
-            ArrowError::ParseError(format!(
-                "Unable to convert schema result to Arrow schema: {}",
-                err
-            ))
-        })
+        try_schema_from_ipc_buffer(&data.schema)
+    }
+}
+
+impl TryFrom<SchemaResult> for Schema {
+    type Error = ArrowError;
+    fn try_from(data: SchemaResult) -> ArrowResult<Self> {
+        (&data).try_into()
     }
 }
 
 // FlightData, FlightDescriptor, etc..
 
 impl FlightData {
-    pub fn new(
-        flight_descriptor: Option<FlightDescriptor>,
-        message: IpcMessage,
-        app_metadata: Vec<u8>,
-        data_body: Vec<u8>,
-    ) -> Self {
-        let IpcMessage(vals) = message;
-        FlightData {
-            flight_descriptor,
-            data_header: vals,
-            app_metadata,
-            data_body,
-        }
+    /// Create a new [`FlightData`].
+    ///
+    /// # See Also
+    ///
+    /// See [`FlightDataEncoderBuilder`] for a higher level API to
+    /// convert a stream of [`RecordBatch`]es to [`FlightData`]s
+    ///
+    /// # Example:
+    ///
+    /// ```
+    /// # use bytes::Bytes;
+    /// # use arrow_flight::{FlightData, FlightDescriptor};
+    /// # fn encode_data() -> Bytes { Bytes::new() } // dummy data
+    /// // Get encoded Arrow IPC data:
+    /// let data_body: Bytes = encode_data();
+    /// // Create the FlightData message
+    /// let flight_data = FlightData::new()
+    ///   .with_descriptor(FlightDescriptor::new_cmd("the command"))
+    ///   .with_app_metadata("My apps metadata")
+    ///   .with_data_body(data_body);
+    /// ```
+    ///
+    /// [`FlightDataEncoderBuilder`]: crate::encode::FlightDataEncoderBuilder
+    /// [`RecordBatch`]: arrow_array::RecordBatch
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Add a [`FlightDescriptor`] describing the data
+    pub fn with_descriptor(mut self, flight_descriptor: FlightDescriptor) -> Self {
+        self.flight_descriptor = Some(flight_descriptor);
+        self
+    }
+
+    /// Add a data header
+    pub fn with_data_header(mut self, data_header: impl Into<Bytes>) -> Self {
+        self.data_header = data_header.into();
+        self
+    }
+
+    /// Add a data body. See [`IpcDataGenerator`] to create this data.
+    ///
+    /// [`IpcDataGenerator`]: arrow_ipc::writer::IpcDataGenerator
+    pub fn with_data_body(mut self, data_body: impl Into<Bytes>) -> Self {
+        self.data_body = data_body.into();
+        self
+    }
+
+    /// Add optional application specific metadata to the message
+    pub fn with_app_metadata(mut self, app_metadata: impl Into<Bytes>) -> Self {
+        self.app_metadata = app_metadata.into();
+        self
     }
 }
 
 impl FlightDescriptor {
-    pub fn new_cmd(cmd: Vec<u8>) -> Self {
+    /// Create a new opaque command [`CMD`] `FlightDescriptor` to generate a dataset.
+    ///
+    /// [`CMD`]: https://github.com/apache/arrow/blob/6bd31f37ae66bd35594b077cb2f830be57e08acd/format/Flight.proto#L224-L227
+    pub fn new_cmd(cmd: impl Into<Bytes>) -> Self {
         FlightDescriptor {
             r#type: DescriptorType::Cmd.into(),
-            cmd,
+            cmd: cmd.into(),
             ..Default::default()
         }
     }
 
+    /// Create a new named path [`PATH`] `FlightDescriptor` that identifies a dataset
+    ///
+    /// [`PATH`]: https://github.com/apache/arrow/blob/6bd31f37ae66bd35594b077cb2f830be57e08acd/format/Flight.proto#L217-L222
     pub fn new_path(path: Vec<String>) -> Self {
         FlightDescriptor {
             r#type: DescriptorType::Path.into(),
@@ -376,22 +529,160 @@ impl FlightDescriptor {
 }
 
 impl FlightInfo {
-    pub fn new(
-        message: IpcMessage,
-        flight_descriptor: Option<FlightDescriptor>,
-        endpoint: Vec<FlightEndpoint>,
-        total_records: i64,
-        total_bytes: i64,
-    ) -> Self {
-        let IpcMessage(vals) = message;
+    /// Create a new, empty `FlightInfo`, describing where to fetch flight data
+    ///
+    ///
+    /// # Example:
+    /// ```
+    /// # use arrow_flight::{FlightInfo, Ticket, FlightDescriptor, FlightEndpoint};
+    /// # use arrow_schema::{Schema, Field, DataType};
+    /// # fn get_schema() -> Schema {
+    /// #   Schema::new(vec![
+    /// #     Field::new("a", DataType::Utf8, false),
+    /// #   ])
+    /// # }
+    /// #
+    /// // Create a new FlightInfo
+    /// let flight_info = FlightInfo::new()
+    ///   // Encode the Arrow schema
+    ///   .try_with_schema(&get_schema())
+    ///   .expect("encoding failed")
+    ///   .with_endpoint(
+    ///      FlightEndpoint::new()
+    ///        .with_ticket(Ticket::new("ticket contents")
+    ///      )
+    ///    )
+    ///   .with_descriptor(FlightDescriptor::new_cmd("RUN QUERY"));
+    /// ```
+    pub fn new() -> FlightInfo {
         FlightInfo {
-            schema: vals,
-            flight_descriptor,
-            endpoint,
-            total_records,
-            total_bytes,
+            schema: Bytes::new(),
+            flight_descriptor: None,
+            endpoint: vec![],
+            ordered: false,
+            // Flight says "Set these to -1 if unknown."
+            //
+            // https://github.com/apache/arrow-rs/blob/17ca4d51d0490f9c65f5adde144f677dbc8300e7/format/Flight.proto#L287-L289
+            total_records: -1,
+            total_bytes: -1,
+            app_metadata: Bytes::new(),
         }
     }
+
+    /// Try and convert the data in this  `FlightInfo` into a [`Schema`]
+    pub fn try_decode_schema(self) -> ArrowResult<Schema> {
+        let msg = IpcMessage(self.schema);
+        msg.try_into()
+    }
+
+    /// Specify the schema for the response.
+    ///
+    /// Note this takes the arrow [`Schema`] (not the IPC schema) and
+    /// encodes it using the default IPC options.
+    ///
+    /// Returns an error if `schema` can not be encoded into IPC form.
+    pub fn try_with_schema(mut self, schema: &Schema) -> ArrowResult<Self> {
+        let options = IpcWriteOptions::default();
+        let IpcMessage(schema) = SchemaAsIpc::new(schema, &options).try_into()?;
+        self.schema = schema;
+        Ok(self)
+    }
+
+    /// Add specific a endpoint for fetching the data
+    pub fn with_endpoint(mut self, endpoint: FlightEndpoint) -> Self {
+        self.endpoint.push(endpoint);
+        self
+    }
+
+    /// Add a [`FlightDescriptor`] describing what this data is
+    pub fn with_descriptor(mut self, flight_descriptor: FlightDescriptor) -> Self {
+        self.flight_descriptor = Some(flight_descriptor);
+        self
+    }
+
+    /// Set the number of records in the result, if known
+    pub fn with_total_records(mut self, total_records: i64) -> Self {
+        self.total_records = total_records;
+        self
+    }
+
+    /// Set the number of bytes in the result, if known
+    pub fn with_total_bytes(mut self, total_bytes: i64) -> Self {
+        self.total_bytes = total_bytes;
+        self
+    }
+
+    /// Specify if the response is [ordered] across endpoints
+    ///
+    /// [ordered]: https://github.com/apache/arrow-rs/blob/17ca4d51d0490f9c65f5adde144f677dbc8300e7/format/Flight.proto#L269-L275
+    pub fn with_ordered(mut self, ordered: bool) -> Self {
+        self.ordered = ordered;
+        self
+    }
+
+    /// Add optional application specific metadata to the message
+    pub fn with_app_metadata(mut self, app_metadata: impl Into<Bytes>) -> Self {
+        self.app_metadata = app_metadata.into();
+        self
+    }
+}
+
+impl PollInfo {
+    /// Create a new, empty [`PollInfo`], providing information for a long-running query
+    ///
+    /// # Example:
+    /// ```
+    /// # use arrow_flight::{FlightInfo, PollInfo, FlightDescriptor};
+    /// # use prost_types::Timestamp;
+    /// // Create a new PollInfo
+    /// let poll_info = PollInfo::new()
+    ///   .with_info(FlightInfo::new())
+    ///   .with_descriptor(FlightDescriptor::new_cmd("RUN QUERY"))
+    ///   .try_with_progress(0.5)
+    ///   .expect("progress should've been valid")
+    ///   .with_expiration_time(
+    ///     "1970-01-01".parse().expect("invalid timestamp")
+    ///   );
+    /// ```
+    pub fn new() -> Self {
+        Self {
+            info: None,
+            flight_descriptor: None,
+            progress: None,
+            expiration_time: None,
+        }
+    }
+
+    /// Add the current available results for the poll call as a [`FlightInfo`]
+    pub fn with_info(mut self, info: FlightInfo) -> Self {
+        self.info = Some(info);
+        self
+    }
+
+    /// Add a [`FlightDescriptor`] that the client should use for the next poll call,
+    /// if the query is not yet complete
+    pub fn with_descriptor(mut self, flight_descriptor: FlightDescriptor) -> Self {
+        self.flight_descriptor = Some(flight_descriptor);
+        self
+    }
+
+    /// Set the query progress if known. Must be in the range [0.0, 1.0] else this will
+    /// return an error
+    pub fn try_with_progress(mut self, progress: f64) -> ArrowResult<Self> {
+        if !(0.0..=1.0).contains(&progress) {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "PollInfo progress must be in the range [0.0, 1.0], got {progress}"
+            )));
+        }
+        self.progress = Some(progress);
+        Ok(self)
+    }
+
+    /// Specify expiration time for this request
+    pub fn with_expiration_time(mut self, expiration_time: Timestamp) -> Self {
+        self.expiration_time = Some(expiration_time);
+        self
+    }
 }
 
 impl<'a> SchemaAsIpc<'a> {
@@ -402,9 +693,129 @@ impl<'a> SchemaAsIpc<'a> {
     }
 }
 
+impl CancelFlightInfoRequest {
+    /// Create a new [`CancelFlightInfoRequest`], providing the [`FlightInfo`]
+    /// of the query to cancel.
+    pub fn new(info: FlightInfo) -> Self {
+        Self { info: Some(info) }
+    }
+}
+
+impl CancelFlightInfoResult {
+    /// Create a new [`CancelFlightInfoResult`] from the provided [`CancelStatus`].
+    pub fn new(status: CancelStatus) -> Self {
+        Self {
+            status: status as i32,
+        }
+    }
+}
+
+impl RenewFlightEndpointRequest {
+    /// Create a new [`RenewFlightEndpointRequest`], providing the [`FlightEndpoint`]
+    /// for which is being requested an extension of its expiration.
+    pub fn new(endpoint: FlightEndpoint) -> Self {
+        Self {
+            endpoint: Some(endpoint),
+        }
+    }
+}
+
+impl Action {
+    /// Create a new Action with type and body
+    pub fn new(action_type: impl Into<String>, body: impl Into<Bytes>) -> Self {
+        Self {
+            r#type: action_type.into(),
+            body: body.into(),
+        }
+    }
+}
+
+impl Result {
+    /// Create a new Result with the specified body
+    pub fn new(body: impl Into<Bytes>) -> Self {
+        Self { body: body.into() }
+    }
+}
+
+impl Ticket {
+    /// Create a new `Ticket`
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use arrow_flight::Ticket;
+    /// let ticket = Ticket::new("SELECT * from FOO");
+    /// ```
+    pub fn new(ticket: impl Into<Bytes>) -> Self {
+        Self {
+            ticket: ticket.into(),
+        }
+    }
+}
+
+impl FlightEndpoint {
+    /// Create a new, empty `FlightEndpoint` that represents a location
+    /// to retrieve Flight results.
+    ///
+    /// # Example
+    /// ```
+    /// # use arrow_flight::{FlightEndpoint, Ticket};
+    /// #
+    /// // Specify the client should fetch results from this server
+    /// let endpoint = FlightEndpoint::new()
+    ///   .with_ticket(Ticket::new("the ticket"));
+    ///
+    /// // Specify the client should fetch results from either
+    /// // `http://example.com` or `https://example.com`
+    /// let endpoint = FlightEndpoint::new()
+    ///   .with_ticket(Ticket::new("the ticket"))
+    ///   .with_location("http://example.com")
+    ///   .with_location("https://example.com");
+    /// ```
+    pub fn new() -> FlightEndpoint {
+        Default::default()
+    }
+
+    /// Set the [`Ticket`] used to retrieve data from the endpoint
+    pub fn with_ticket(mut self, ticket: Ticket) -> Self {
+        self.ticket = Some(ticket);
+        self
+    }
+
+    /// Add a location `uri` to this endpoint. Note each endpoint can
+    /// have multiple locations.
+    ///
+    /// If no `uri` is specified, the [Flight Spec] says:
+    ///
+    /// ```text
+    /// * If the list is empty, the expectation is that the ticket can only
+    /// * be redeemed on the current service where the ticket was
+    /// * generated.
+    /// ```
+    /// [Flight Spec]: https://github.com/apache/arrow-rs/blob/17ca4d51d0490f9c65f5adde144f677dbc8300e7/format/Flight.proto#L307C2-L312
+    pub fn with_location(mut self, uri: impl Into<String>) -> Self {
+        self.location.push(Location { uri: uri.into() });
+        self
+    }
+
+    /// Specify expiration time for this stream
+    pub fn with_expiration_time(mut self, expiration_time: Timestamp) -> Self {
+        self.expiration_time = Some(expiration_time);
+        self
+    }
+
+    /// Add optional application specific metadata to the message
+    pub fn with_app_metadata(mut self, app_metadata: impl Into<Bytes>) -> Self {
+        self.app_metadata = app_metadata.into();
+        self
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
+    use arrow_ipc::MetadataVersion;
+    use arrow_schema::{DataType, Field, TimeUnit};
 
     struct TestVector(Vec<u8>, usize);
 
@@ -426,7 +837,7 @@ mod tests {
     fn it_accepts_equal_output() {
         let input = TestVector(vec![91; 10], 10);
 
-        let actual = format!("{}", input);
+        let actual = format!("{input}");
         let expected = format!("{:?}", vec![91; 10]);
         assert_eq!(actual, expected);
     }
@@ -435,7 +846,7 @@ mod tests {
     fn it_accepts_short_output() {
         let input = TestVector(vec![91; 6], 10);
 
-        let actual = format!("{}", input);
+        let actual = format!("{input}");
         let expected = format!("{:?}", vec![91; 6]);
         assert_eq!(actual, expected);
     }
@@ -444,8 +855,35 @@ mod tests {
     fn it_accepts_long_output() {
         let input = TestVector(vec![91; 10], 9);
 
-        let actual = format!("{}", input);
+        let actual = format!("{input}");
         let expected = format!("{:?}", vec![91; 9]);
         assert_eq!(actual, expected);
     }
+
+    #[test]
+    fn ser_deser_schema_result() {
+        let schema = Schema::new(vec![
+            Field::new("c1", DataType::Utf8, false),
+            Field::new("c2", DataType::Float64, true),
+            Field::new("c3", DataType::UInt32, false),
+            Field::new("c4", DataType::Boolean, true),
+            Field::new("c5", DataType::Timestamp(TimeUnit::Millisecond, None), true),
+            Field::new("c6", DataType::Time32(TimeUnit::Second), false),
+        ]);
+        // V5 with write_legacy_ipc_format = false
+        // this will write the continuation marker
+        let option = IpcWriteOptions::default();
+        let schema_ipc = SchemaAsIpc::new(&schema, &option);
+        let result: SchemaResult = schema_ipc.try_into().unwrap();
+        let des_schema: Schema = (&result).try_into().unwrap();
+        assert_eq!(schema, des_schema);
+
+        // V4 with write_legacy_ipc_format = true
+        // this will not write the continuation marker
+        let option = IpcWriteOptions::try_new(8, true, MetadataVersion::V4).unwrap();
+        let schema_ipc = SchemaAsIpc::new(&schema, &option);
+        let result: SchemaResult = schema_ipc.try_into().unwrap();
+        let des_schema: Schema = (&result).try_into().unwrap();
+        assert_eq!(schema, des_schema);
+    }
 }
diff --git a/arrow-flight/src/sql/arrow.flight.protocol.sql.rs b/arrow-flight/src/sql/arrow.flight.protocol.sql.rs
index 77221dd1a489..2b2f4af7ac90 100644
--- a/arrow-flight/src/sql/arrow.flight.protocol.sql.rs
+++ b/arrow-flight/src/sql/arrow.flight.protocol.sql.rs
@@ -1,13 +1,13 @@
 // This file was automatically generated through the build.rs script, and should not be edited.
 
 ///
-///  Represents a metadata request. Used in the command member of FlightDescriptor
-///  for the following RPC calls:
+/// Represents a metadata request. Used in the command member of FlightDescriptor
+/// for the following RPC calls:
 ///   - GetSchema: return the Arrow schema of the query.
 ///   - GetFlightInfo: execute the metadata request.
 ///
-///  The returned Arrow schema will be:
-///  <
+/// The returned Arrow schema will be:
+/// <
 ///   info_name: uint32 not null,
 ///   value: dense_union<
 ///               string_value: utf8,
@@ -16,185 +16,267 @@
 ///               int32_bitmask: int32,
 ///               string_list: list<string_data: utf8>
 ///               int32_to_int32_list_map: map<key: int32, value: list<$data$: int32>>
-///  >
-///  where there is one row per requested piece of metadata information.
+/// >
+/// where there is one row per requested piece of metadata information.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandGetSqlInfo {
     ///
-    ///  Values are modelled after ODBC's SQLGetInfo() function. This information is intended to provide
-    ///  Flight SQL clients with basic, SQL syntax and SQL functions related information.
-    ///  More information types can be added in future releases.
-    ///  E.g. more SQL syntax support types, scalar functions support, type conversion support etc.
+    /// Values are modelled after ODBC's SQLGetInfo() function. This information is intended to provide
+    /// Flight SQL clients with basic, SQL syntax and SQL functions related information.
+    /// More information types can be added in future releases.
+    /// E.g. more SQL syntax support types, scalar functions support, type conversion support etc.
     ///
-    ///  Note that the set of metadata may expand.
+    /// Note that the set of metadata may expand.
     ///
-    ///  Initially, Flight SQL will support the following information types:
-    ///  - Server Information - Range [0-500)
-    ///  - Syntax Information - Range [500-1000)
-    ///  Range [0-10,000) is reserved for defaults (see SqlInfo enum for default options). 
-    ///  Custom options should start at 10,000.
+    /// Initially, Flight SQL will support the following information types:
+    /// - Server Information - Range [0-500)
+    /// - Syntax Information - Range [500-1000)
+    /// Range [0-10,000) is reserved for defaults (see SqlInfo enum for default options).
+    /// Custom options should start at 10,000.
     ///
-    ///  If omitted, then all metadata will be retrieved.
-    ///  Flight SQL Servers may choose to include additional metadata above and beyond the specified set, however they must
-    ///  at least return the specified set. IDs ranging from 0 to 10,000 (exclusive) are reserved for future use.
-    ///  If additional metadata is included, the metadata IDs should start from 10,000.
-    #[prost(uint32, repeated, tag="1")]
+    /// If omitted, then all metadata will be retrieved.
+    /// Flight SQL Servers may choose to include additional metadata above and beyond the specified set, however they must
+    /// at least return the specified set. IDs ranging from 0 to 10,000 (exclusive) are reserved for future use.
+    /// If additional metadata is included, the metadata IDs should start from 10,000.
+    #[prost(uint32, repeated, tag = "1")]
     pub info: ::prost::alloc::vec::Vec<u32>,
 }
 ///
-///  Represents a request to retrieve the list of catalogs on a Flight SQL enabled backend.
-///  The definition of a catalog depends on vendor/implementation. It is usually the database itself
-///  Used in the command member of FlightDescriptor for the following RPC calls:
+/// Represents a request to retrieve information about data type supported on a Flight SQL enabled backend.
+/// Used in the command member of FlightDescriptor for the following RPC calls:
+///   - GetSchema: return the schema of the query.
+///   - GetFlightInfo: execute the catalog metadata request.
+///
+/// The returned schema will be:
+/// <
+///    type_name: utf8 not null (The name of the data type, for example: VARCHAR, INTEGER, etc),
+///    data_type: int32 not null (The SQL data type),
+///    column_size: int32 (The maximum size supported by that column.
+///                        In case of exact numeric types, this represents the maximum precision.
+///                        In case of string types, this represents the character length.
+///                        In case of datetime data types, this represents the length in characters of the string representation.
+///                        NULL is returned for data types where column size is not applicable.),
+///    literal_prefix: utf8 (Character or characters used to prefix a literal, NULL is returned for
+///                          data types where a literal prefix is not applicable.),
+///    literal_suffix: utf8 (Character or characters used to terminate a literal,
+///                          NULL is returned for data types where a literal suffix is not applicable.),
+///    create_params: list<utf8 not null>
+///                         (A list of keywords corresponding to which parameters can be used when creating
+///                          a column for that specific type.
+///                          NULL is returned if there are no parameters for the data type definition.),
+///    nullable: int32 not null (Shows if the data type accepts a NULL value. The possible values can be seen in the
+///                              Nullable enum.),
+///    case_sensitive: bool not null (Shows if a character data type is case-sensitive in collations and comparisons),
+///    searchable: int32 not null (Shows how the data type is used in a WHERE clause. The possible values can be seen in the
+///                                Searchable enum.),
+///    unsigned_attribute: bool (Shows if the data type is unsigned. NULL is returned if the attribute is
+///                              not applicable to the data type or the data type is not numeric.),
+///    fixed_prec_scale: bool not null (Shows if the data type has predefined fixed precision and scale.),
+///    auto_increment: bool (Shows if the data type is auto incremental. NULL is returned if the attribute
+///                          is not applicable to the data type or the data type is not numeric.),
+///    local_type_name: utf8 (Localized version of the data source-dependent name of the data type. NULL
+///                           is returned if a localized name is not supported by the data source),
+///    minimum_scale: int32 (The minimum scale of the data type on the data source.
+///                          If a data type has a fixed scale, the MINIMUM_SCALE and MAXIMUM_SCALE
+///                          columns both contain this value. NULL is returned if scale is not applicable.),
+///    maximum_scale: int32 (The maximum scale of the data type on the data source.
+///                          NULL is returned if scale is not applicable.),
+///    sql_data_type: int32 not null (The value of the SQL DATA TYPE which has the same values
+///                                   as data_type value. Except for interval and datetime, which
+///                                   uses generic values. More info about those types can be
+///                                   obtained through datetime_subcode. The possible values can be seen
+///                                   in the XdbcDataType enum.),
+///    datetime_subcode: int32 (Only used when the SQL DATA TYPE is interval or datetime. It contains
+///                             its sub types. For type different from interval and datetime, this value
+///                             is NULL. The possible values can be seen in the XdbcDatetimeSubcode enum.),
+///    num_prec_radix: int32 (If the data type is an approximate numeric type, this column contains
+///                           the value 2 to indicate that COLUMN_SIZE specifies a number of bits. For
+///                           exact numeric types, this column contains the value 10 to indicate that
+///                           column size specifies a number of decimal digits. Otherwise, this column is NULL.),
+///    interval_precision: int32 (If the data type is an interval data type, then this column contains the value
+///                               of the interval leading precision. Otherwise, this column is NULL. This fields
+///                               is only relevant to be used by ODBC).
+/// >
+/// The returned data should be ordered by data_type and then by type_name.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CommandGetXdbcTypeInfo {
+    ///
+    /// Specifies the data type to search for the info.
+    #[prost(int32, optional, tag = "1")]
+    pub data_type: ::core::option::Option<i32>,
+}
+///
+/// Represents a request to retrieve the list of catalogs on a Flight SQL enabled backend.
+/// The definition of a catalog depends on vendor/implementation. It is usually the database itself
+/// Used in the command member of FlightDescriptor for the following RPC calls:
 ///   - GetSchema: return the Arrow schema of the query.
 ///   - GetFlightInfo: execute the catalog metadata request.
 ///
-///  The returned Arrow schema will be:
-///  <
+/// The returned Arrow schema will be:
+/// <
 ///   catalog_name: utf8 not null
-///  >
-///  The returned data should be ordered by catalog_name.
+/// >
+/// The returned data should be ordered by catalog_name.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CommandGetCatalogs {
-}
+pub struct CommandGetCatalogs {}
 ///
-///  Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend.
-///  The definition of a database schema depends on vendor/implementation. It is usually a collection of tables.
-///  Used in the command member of FlightDescriptor for the following RPC calls:
+/// Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend.
+/// The definition of a database schema depends on vendor/implementation. It is usually a collection of tables.
+/// Used in the command member of FlightDescriptor for the following RPC calls:
 ///   - GetSchema: return the Arrow schema of the query.
 ///   - GetFlightInfo: execute the catalog metadata request.
 ///
-///  The returned Arrow schema will be:
-///  <
+/// The returned Arrow schema will be:
+/// <
 ///   catalog_name: utf8,
 ///   db_schema_name: utf8 not null
-///  >
-///  The returned data should be ordered by catalog_name, then db_schema_name.
+/// >
+/// The returned data should be ordered by catalog_name, then db_schema_name.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandGetDbSchemas {
     ///
-    ///  Specifies the Catalog to search for the tables.
-    ///  An empty string retrieves those without a catalog.
-    ///  If omitted the catalog name should not be used to narrow the search.
-    #[prost(string, optional, tag="1")]
+    /// Specifies the Catalog to search for the tables.
+    /// An empty string retrieves those without a catalog.
+    /// If omitted the catalog name should not be used to narrow the search.
+    #[prost(string, optional, tag = "1")]
     pub catalog: ::core::option::Option<::prost::alloc::string::String>,
     ///
-    ///  Specifies a filter pattern for schemas to search for.
-    ///  When no db_schema_filter_pattern is provided, the pattern will not be used to narrow the search.
-    ///  In the pattern string, two special characters can be used to denote matching rules:
+    /// Specifies a filter pattern for schemas to search for.
+    /// When no db_schema_filter_pattern is provided, the pattern will not be used to narrow the search.
+    /// In the pattern string, two special characters can be used to denote matching rules:
     ///     - "%" means to match any substring with 0 or more characters.
     ///     - "_" means to match any one character.
-    #[prost(string, optional, tag="2")]
+    #[prost(string, optional, tag = "2")]
     pub db_schema_filter_pattern: ::core::option::Option<::prost::alloc::string::String>,
 }
 ///
-///  Represents a request to retrieve the list of tables, and optionally their schemas, on a Flight SQL enabled backend.
-///  Used in the command member of FlightDescriptor for the following RPC calls:
+/// Represents a request to retrieve the list of tables, and optionally their schemas, on a Flight SQL enabled backend.
+/// Used in the command member of FlightDescriptor for the following RPC calls:
 ///   - GetSchema: return the Arrow schema of the query.
 ///   - GetFlightInfo: execute the catalog metadata request.
 ///
-///  The returned Arrow schema will be:
-///  <
+/// The returned Arrow schema will be:
+/// <
 ///   catalog_name: utf8,
 ///   db_schema_name: utf8,
 ///   table_name: utf8 not null,
 ///   table_type: utf8 not null,
 ///   \[optional\] table_schema: bytes not null (schema of the table as described in Schema.fbs::Schema,
 ///                                            it is serialized as an IPC message.)
-///  >
-///  The returned data should be ordered by catalog_name, db_schema_name, table_name, then table_type, followed by table_schema if requested.
+/// >
+/// Fields on table_schema may contain the following metadata:
+///   - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+///   - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+///   - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+///   - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+///   - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+///   - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+///   - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+///   - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+///   - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+///   - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+/// The returned data should be ordered by catalog_name, db_schema_name, table_name, then table_type, followed by table_schema if requested.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandGetTables {
     ///
-    ///  Specifies the Catalog to search for the tables.
-    ///  An empty string retrieves those without a catalog.
-    ///  If omitted the catalog name should not be used to narrow the search.
-    #[prost(string, optional, tag="1")]
+    /// Specifies the Catalog to search for the tables.
+    /// An empty string retrieves those without a catalog.
+    /// If omitted the catalog name should not be used to narrow the search.
+    #[prost(string, optional, tag = "1")]
     pub catalog: ::core::option::Option<::prost::alloc::string::String>,
     ///
-    ///  Specifies a filter pattern for schemas to search for.
-    ///  When no db_schema_filter_pattern is provided, all schemas matching other filters are searched.
-    ///  In the pattern string, two special characters can be used to denote matching rules:
+    /// Specifies a filter pattern for schemas to search for.
+    /// When no db_schema_filter_pattern is provided, all schemas matching other filters are searched.
+    /// In the pattern string, two special characters can be used to denote matching rules:
     ///     - "%" means to match any substring with 0 or more characters.
     ///     - "_" means to match any one character.
-    #[prost(string, optional, tag="2")]
+    #[prost(string, optional, tag = "2")]
     pub db_schema_filter_pattern: ::core::option::Option<::prost::alloc::string::String>,
     ///
-    ///  Specifies a filter pattern for tables to search for.
-    ///  When no table_name_filter_pattern is provided, all tables matching other filters are searched.
-    ///  In the pattern string, two special characters can be used to denote matching rules:
+    /// Specifies a filter pattern for tables to search for.
+    /// When no table_name_filter_pattern is provided, all tables matching other filters are searched.
+    /// In the pattern string, two special characters can be used to denote matching rules:
     ///     - "%" means to match any substring with 0 or more characters.
     ///     - "_" means to match any one character.
-    #[prost(string, optional, tag="3")]
-    pub table_name_filter_pattern: ::core::option::Option<::prost::alloc::string::String>,
-    ///
-    ///  Specifies a filter of table types which must match.
-    ///  The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
-    ///  TABLE, VIEW, and SYSTEM TABLE are commonly supported.
-    #[prost(string, repeated, tag="4")]
+    #[prost(string, optional, tag = "3")]
+    pub table_name_filter_pattern: ::core::option::Option<
+        ::prost::alloc::string::String,
+    >,
+    ///
+    /// Specifies a filter of table types which must match.
+    /// The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
+    /// TABLE, VIEW, and SYSTEM TABLE are commonly supported.
+    #[prost(string, repeated, tag = "4")]
     pub table_types: ::prost::alloc::vec::Vec<::prost::alloc::string::String>,
-    ///  Specifies if the Arrow schema should be returned for found tables.
-    #[prost(bool, tag="5")]
+    /// Specifies if the Arrow schema should be returned for found tables.
+    #[prost(bool, tag = "5")]
     pub include_schema: bool,
 }
 ///
-///  Represents a request to retrieve the list of table types on a Flight SQL enabled backend.
-///  The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
-///  TABLE, VIEW, and SYSTEM TABLE are commonly supported.
-///  Used in the command member of FlightDescriptor for the following RPC calls:
+/// Represents a request to retrieve the list of table types on a Flight SQL enabled backend.
+/// The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
+/// TABLE, VIEW, and SYSTEM TABLE are commonly supported.
+/// Used in the command member of FlightDescriptor for the following RPC calls:
 ///   - GetSchema: return the Arrow schema of the query.
 ///   - GetFlightInfo: execute the catalog metadata request.
 ///
-///  The returned Arrow schema will be:
-///  <
+/// The returned Arrow schema will be:
+/// <
 ///   table_type: utf8 not null
-///  >
-///  The returned data should be ordered by table_type.
+/// >
+/// The returned data should be ordered by table_type.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
-pub struct CommandGetTableTypes {
-}
+pub struct CommandGetTableTypes {}
 ///
-///  Represents a request to retrieve the primary keys of a table on a Flight SQL enabled backend.
-///  Used in the command member of FlightDescriptor for the following RPC calls:
+/// Represents a request to retrieve the primary keys of a table on a Flight SQL enabled backend.
+/// Used in the command member of FlightDescriptor for the following RPC calls:
 ///   - GetSchema: return the Arrow schema of the query.
 ///   - GetFlightInfo: execute the catalog metadata request.
 ///
-///  The returned Arrow schema will be:
-///  <
+/// The returned Arrow schema will be:
+/// <
 ///   catalog_name: utf8,
 ///   db_schema_name: utf8,
 ///   table_name: utf8 not null,
 ///   column_name: utf8 not null,
 ///   key_name: utf8,
-///   key_sequence: int not null
-///  >
-///  The returned data should be ordered by catalog_name, db_schema_name, table_name, key_name, then key_sequence.
+///   key_sequence: int32 not null
+/// >
+/// The returned data should be ordered by catalog_name, db_schema_name, table_name, key_name, then key_sequence.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandGetPrimaryKeys {
     ///
-    ///  Specifies the catalog to search for the table.
-    ///  An empty string retrieves those without a catalog.
-    ///  If omitted the catalog name should not be used to narrow the search.
-    #[prost(string, optional, tag="1")]
+    /// Specifies the catalog to search for the table.
+    /// An empty string retrieves those without a catalog.
+    /// If omitted the catalog name should not be used to narrow the search.
+    #[prost(string, optional, tag = "1")]
     pub catalog: ::core::option::Option<::prost::alloc::string::String>,
     ///
-    ///  Specifies the schema to search for the table.
-    ///  An empty string retrieves those without a schema.
-    ///  If omitted the schema name should not be used to narrow the search.
-    #[prost(string, optional, tag="2")]
+    /// Specifies the schema to search for the table.
+    /// An empty string retrieves those without a schema.
+    /// If omitted the schema name should not be used to narrow the search.
+    #[prost(string, optional, tag = "2")]
     pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
-    ///  Specifies the table to get the primary keys for.
-    #[prost(string, tag="3")]
+    /// Specifies the table to get the primary keys for.
+    #[prost(string, tag = "3")]
     pub table: ::prost::alloc::string::String,
 }
 ///
-///  Represents a request to retrieve a description of the foreign key columns that reference the given table's
-///  primary key columns (the foreign keys exported by a table) of a table on a Flight SQL enabled backend.
-///  Used in the command member of FlightDescriptor for the following RPC calls:
+/// Represents a request to retrieve a description of the foreign key columns that reference the given table's
+/// primary key columns (the foreign keys exported by a table) of a table on a Flight SQL enabled backend.
+/// Used in the command member of FlightDescriptor for the following RPC calls:
 ///   - GetSchema: return the Arrow schema of the query.
 ///   - GetFlightInfo: execute the catalog metadata request.
 ///
-///  The returned Arrow schema will be:
-///  <
+/// The returned Arrow schema will be:
+/// <
 ///   pk_catalog_name: utf8,
 ///   pk_db_schema_name: utf8,
 ///   pk_table_name: utf8 not null,
@@ -203,40 +285,41 @@ pub struct CommandGetPrimaryKeys {
 ///   fk_db_schema_name: utf8,
 ///   fk_table_name: utf8 not null,
 ///   fk_column_name: utf8 not null,
-///   key_sequence: int not null,
+///   key_sequence: int32 not null,
 ///   fk_key_name: utf8,
 ///   pk_key_name: utf8,
-///   update_rule: uint1 not null,
-///   delete_rule: uint1 not null
-///  >
-///  The returned data should be ordered by fk_catalog_name, fk_db_schema_name, fk_table_name, fk_key_name, then key_sequence.
-///  update_rule and delete_rule returns a byte that is equivalent to actions declared on UpdateDeleteRules enum.
+///   update_rule: uint8 not null,
+///   delete_rule: uint8 not null
+/// >
+/// The returned data should be ordered by fk_catalog_name, fk_db_schema_name, fk_table_name, fk_key_name, then key_sequence.
+/// update_rule and delete_rule returns a byte that is equivalent to actions declared on UpdateDeleteRules enum.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandGetExportedKeys {
     ///
-    ///  Specifies the catalog to search for the foreign key table.
-    ///  An empty string retrieves those without a catalog.
-    ///  If omitted the catalog name should not be used to narrow the search.
-    #[prost(string, optional, tag="1")]
+    /// Specifies the catalog to search for the foreign key table.
+    /// An empty string retrieves those without a catalog.
+    /// If omitted the catalog name should not be used to narrow the search.
+    #[prost(string, optional, tag = "1")]
     pub catalog: ::core::option::Option<::prost::alloc::string::String>,
     ///
-    ///  Specifies the schema to search for the foreign key table.
-    ///  An empty string retrieves those without a schema.
-    ///  If omitted the schema name should not be used to narrow the search.
-    #[prost(string, optional, tag="2")]
+    /// Specifies the schema to search for the foreign key table.
+    /// An empty string retrieves those without a schema.
+    /// If omitted the schema name should not be used to narrow the search.
+    #[prost(string, optional, tag = "2")]
     pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
-    ///  Specifies the foreign key table to get the foreign keys for.
-    #[prost(string, tag="3")]
+    /// Specifies the foreign key table to get the foreign keys for.
+    #[prost(string, tag = "3")]
     pub table: ::prost::alloc::string::String,
 }
 ///
-///  Represents a request to retrieve the foreign keys of a table on a Flight SQL enabled backend.
-///  Used in the command member of FlightDescriptor for the following RPC calls:
+/// Represents a request to retrieve the foreign keys of a table on a Flight SQL enabled backend.
+/// Used in the command member of FlightDescriptor for the following RPC calls:
 ///   - GetSchema: return the Arrow schema of the query.
 ///   - GetFlightInfo: execute the catalog metadata request.
 ///
-///  The returned Arrow schema will be:
-///  <
+/// The returned Arrow schema will be:
+/// <
 ///   pk_catalog_name: utf8,
 ///   pk_db_schema_name: utf8,
 ///   pk_table_name: utf8 not null,
@@ -245,47 +328,48 @@ pub struct CommandGetExportedKeys {
 ///   fk_db_schema_name: utf8,
 ///   fk_table_name: utf8 not null,
 ///   fk_column_name: utf8 not null,
-///   key_sequence: int not null,
+///   key_sequence: int32 not null,
 ///   fk_key_name: utf8,
 ///   pk_key_name: utf8,
-///   update_rule: uint1 not null,
-///   delete_rule: uint1 not null
-///  >
-///  The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
-///  update_rule and delete_rule returns a byte that is equivalent to actions:
+///   update_rule: uint8 not null,
+///   delete_rule: uint8 not null
+/// >
+/// The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
+/// update_rule and delete_rule returns a byte that is equivalent to actions:
 ///     - 0 = CASCADE
 ///     - 1 = RESTRICT
 ///     - 2 = SET NULL
 ///     - 3 = NO ACTION
 ///     - 4 = SET DEFAULT
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandGetImportedKeys {
     ///
-    ///  Specifies the catalog to search for the primary key table.
-    ///  An empty string retrieves those without a catalog.
-    ///  If omitted the catalog name should not be used to narrow the search.
-    #[prost(string, optional, tag="1")]
+    /// Specifies the catalog to search for the primary key table.
+    /// An empty string retrieves those without a catalog.
+    /// If omitted the catalog name should not be used to narrow the search.
+    #[prost(string, optional, tag = "1")]
     pub catalog: ::core::option::Option<::prost::alloc::string::String>,
     ///
-    ///  Specifies the schema to search for the primary key table.
-    ///  An empty string retrieves those without a schema.
-    ///  If omitted the schema name should not be used to narrow the search.
-    #[prost(string, optional, tag="2")]
+    /// Specifies the schema to search for the primary key table.
+    /// An empty string retrieves those without a schema.
+    /// If omitted the schema name should not be used to narrow the search.
+    #[prost(string, optional, tag = "2")]
     pub db_schema: ::core::option::Option<::prost::alloc::string::String>,
-    ///  Specifies the primary key table to get the foreign keys for.
-    #[prost(string, tag="3")]
+    /// Specifies the primary key table to get the foreign keys for.
+    #[prost(string, tag = "3")]
     pub table: ::prost::alloc::string::String,
 }
 ///
-///  Represents a request to retrieve a description of the foreign key columns in the given foreign key table that
-///  reference the primary key or the columns representing a unique constraint of the parent table (could be the same
-///  or a different table) on a Flight SQL enabled backend.
-///  Used in the command member of FlightDescriptor for the following RPC calls:
+/// Represents a request to retrieve a description of the foreign key columns in the given foreign key table that
+/// reference the primary key or the columns representing a unique constraint of the parent table (could be the same
+/// or a different table) on a Flight SQL enabled backend.
+/// Used in the command member of FlightDescriptor for the following RPC calls:
 ///   - GetSchema: return the Arrow schema of the query.
 ///   - GetFlightInfo: execute the catalog metadata request.
 ///
-///  The returned Arrow schema will be:
-///  <
+/// The returned Arrow schema will be:
+/// <
 ///   pk_catalog_name: utf8,
 ///   pk_db_schema_name: utf8,
 ///   pk_table_name: utf8 not null,
@@ -294,713 +378,1127 @@ pub struct CommandGetImportedKeys {
 ///   fk_db_schema_name: utf8,
 ///   fk_table_name: utf8 not null,
 ///   fk_column_name: utf8 not null,
-///   key_sequence: int not null,
+///   key_sequence: int32 not null,
 ///   fk_key_name: utf8,
 ///   pk_key_name: utf8,
-///   update_rule: uint1 not null,
-///   delete_rule: uint1 not null
-///  >
-///  The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
-///  update_rule and delete_rule returns a byte that is equivalent to actions:
+///   update_rule: uint8 not null,
+///   delete_rule: uint8 not null
+/// >
+/// The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
+/// update_rule and delete_rule returns a byte that is equivalent to actions:
 ///     - 0 = CASCADE
 ///     - 1 = RESTRICT
 ///     - 2 = SET NULL
 ///     - 3 = NO ACTION
 ///     - 4 = SET DEFAULT
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandGetCrossReference {
     /// *
-    ///  The catalog name where the parent table is.
-    ///  An empty string retrieves those without a catalog.
-    ///  If omitted the catalog name should not be used to narrow the search.
-    #[prost(string, optional, tag="1")]
+    /// The catalog name where the parent table is.
+    /// An empty string retrieves those without a catalog.
+    /// If omitted the catalog name should not be used to narrow the search.
+    #[prost(string, optional, tag = "1")]
     pub pk_catalog: ::core::option::Option<::prost::alloc::string::String>,
     /// *
-    ///  The Schema name where the parent table is.
-    ///  An empty string retrieves those without a schema.
-    ///  If omitted the schema name should not be used to narrow the search.
-    #[prost(string, optional, tag="2")]
+    /// The Schema name where the parent table is.
+    /// An empty string retrieves those without a schema.
+    /// If omitted the schema name should not be used to narrow the search.
+    #[prost(string, optional, tag = "2")]
     pub pk_db_schema: ::core::option::Option<::prost::alloc::string::String>,
     /// *
-    ///  The parent table name. It cannot be null.
-    #[prost(string, tag="3")]
+    /// The parent table name. It cannot be null.
+    #[prost(string, tag = "3")]
     pub pk_table: ::prost::alloc::string::String,
     /// *
-    ///  The catalog name where the foreign table is.
-    ///  An empty string retrieves those without a catalog.
-    ///  If omitted the catalog name should not be used to narrow the search.
-    #[prost(string, optional, tag="4")]
+    /// The catalog name where the foreign table is.
+    /// An empty string retrieves those without a catalog.
+    /// If omitted the catalog name should not be used to narrow the search.
+    #[prost(string, optional, tag = "4")]
     pub fk_catalog: ::core::option::Option<::prost::alloc::string::String>,
     /// *
-    ///  The schema name where the foreign table is.
-    ///  An empty string retrieves those without a schema.
-    ///  If omitted the schema name should not be used to narrow the search.
-    #[prost(string, optional, tag="5")]
+    /// The schema name where the foreign table is.
+    /// An empty string retrieves those without a schema.
+    /// If omitted the schema name should not be used to narrow the search.
+    #[prost(string, optional, tag = "5")]
     pub fk_db_schema: ::core::option::Option<::prost::alloc::string::String>,
     /// *
-    ///  The foreign table name. It cannot be null.
-    #[prost(string, tag="6")]
+    /// The foreign table name. It cannot be null.
+    #[prost(string, tag = "6")]
     pub fk_table: ::prost::alloc::string::String,
 }
-//  SQL Execution Action Messages
-
 ///
-///  Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
+/// Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ActionCreatePreparedStatementRequest {
-    ///  The valid SQL string to create a prepared statement for.
-    #[prost(string, tag="1")]
+    /// The valid SQL string to create a prepared statement for.
+    #[prost(string, tag = "1")]
     pub query: ::prost::alloc::string::String,
+    /// Create/execute the prepared statement as part of this transaction (if
+    /// unset, executions of the prepared statement will be auto-committed).
+    #[prost(bytes = "bytes", optional, tag = "2")]
+    pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
 }
 ///
-///  Wrap the result of a "GetPreparedStatement" action.
+/// An embedded message describing a Substrait plan to execute.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct SubstraitPlan {
+    /// The serialized substrait.Plan to create a prepared statement for.
+    /// XXX(ARROW-16902): this is bytes instead of an embedded message
+    /// because Protobuf does not really support one DLL using Protobuf
+    /// definitions from another DLL.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub plan: ::prost::bytes::Bytes,
+    /// The Substrait release, e.g. "0.12.0". This information is not
+    /// tracked in the plan itself, so this is the only way for consumers
+    /// to potentially know if they can handle the plan.
+    #[prost(string, tag = "2")]
+    pub version: ::prost::alloc::string::String,
+}
 ///
-///  The resultant PreparedStatement can be closed either:
-///  - Manually, through the "ClosePreparedStatement" action;
-///  - Automatically, by a server timeout.
+/// Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ActionCreatePreparedSubstraitPlanRequest {
+    /// The serialized substrait.Plan to create a prepared statement for.
+    #[prost(message, optional, tag = "1")]
+    pub plan: ::core::option::Option<SubstraitPlan>,
+    /// Create/execute the prepared statement as part of this transaction (if
+    /// unset, executions of the prepared statement will be auto-committed).
+    #[prost(bytes = "bytes", optional, tag = "2")]
+    pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
+}
+///
+/// Wrap the result of a "CreatePreparedStatement" or "CreatePreparedSubstraitPlan" action.
+///
+/// The resultant PreparedStatement can be closed either:
+/// - Manually, through the "ClosePreparedStatement" action;
+/// - Automatically, by a server timeout.
+///
+/// The result should be wrapped in a google.protobuf.Any message.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ActionCreatePreparedStatementResult {
-    ///  Opaque handle for the prepared statement on the server.
-    #[prost(bytes="vec", tag="1")]
-    pub prepared_statement_handle: ::prost::alloc::vec::Vec<u8>,
-    ///  If a result set generating query was provided, dataset_schema contains the 
-    ///  schema of the dataset as described in Schema.fbs::Schema, it is serialized as an IPC message.
-    #[prost(bytes="vec", tag="2")]
-    pub dataset_schema: ::prost::alloc::vec::Vec<u8>,
-    ///  If the query provided contained parameters, parameter_schema contains the 
-    ///  schema of the expected parameters as described in Schema.fbs::Schema, it is serialized as an IPC message.
-    #[prost(bytes="vec", tag="3")]
-    pub parameter_schema: ::prost::alloc::vec::Vec<u8>,
+    /// Opaque handle for the prepared statement on the server.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub prepared_statement_handle: ::prost::bytes::Bytes,
+    /// If a result set generating query was provided, dataset_schema contains the
+    /// schema of the result set.  It should be an IPC-encapsulated Schema, as described in Schema.fbs.
+    /// For some queries, the schema of the results may depend on the schema of the parameters.  The server
+    /// should provide its best guess as to the schema at this point.  Clients must not assume that this
+    /// schema, if provided, will be accurate.
+    #[prost(bytes = "bytes", tag = "2")]
+    pub dataset_schema: ::prost::bytes::Bytes,
+    /// If the query provided contained parameters, parameter_schema contains the
+    /// schema of the expected parameters.  It should be an IPC-encapsulated Schema, as described in Schema.fbs.
+    #[prost(bytes = "bytes", tag = "3")]
+    pub parameter_schema: ::prost::bytes::Bytes,
 }
 ///
-///  Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
-///  Closes server resources associated with the prepared statement handle.
+/// Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
+/// Closes server resources associated with the prepared statement handle.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct ActionClosePreparedStatementRequest {
-    ///  Opaque handle for the prepared statement on the server.
-    #[prost(bytes="vec", tag="1")]
-    pub prepared_statement_handle: ::prost::alloc::vec::Vec<u8>,
+    /// Opaque handle for the prepared statement on the server.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub prepared_statement_handle: ::prost::bytes::Bytes,
 }
-//  SQL Execution Messages.
-
 ///
-///  Represents a SQL query. Used in the command member of FlightDescriptor
-///  for the following RPC calls:
+/// Request message for the "BeginTransaction" action.
+/// Begins a transaction.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ActionBeginTransactionRequest {}
+///
+/// Request message for the "BeginSavepoint" action.
+/// Creates a savepoint within a transaction.
+///
+/// Only supported if FLIGHT_SQL_TRANSACTION is
+/// FLIGHT_SQL_TRANSACTION_SUPPORT_SAVEPOINT.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ActionBeginSavepointRequest {
+    /// The transaction to which a savepoint belongs.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub transaction_id: ::prost::bytes::Bytes,
+    /// Name for the savepoint.
+    #[prost(string, tag = "2")]
+    pub name: ::prost::alloc::string::String,
+}
+///
+/// The result of a "BeginTransaction" action.
+///
+/// The transaction can be manipulated with the "EndTransaction" action, or
+/// automatically via server timeout. If the transaction times out, then it is
+/// automatically rolled back.
+///
+/// The result should be wrapped in a google.protobuf.Any message.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ActionBeginTransactionResult {
+    /// Opaque handle for the transaction on the server.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub transaction_id: ::prost::bytes::Bytes,
+}
+///
+/// The result of a "BeginSavepoint" action.
+///
+/// The transaction can be manipulated with the "EndSavepoint" action.
+/// If the associated transaction is committed, rolled back, or times
+/// out, then the savepoint is also invalidated.
+///
+/// The result should be wrapped in a google.protobuf.Any message.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ActionBeginSavepointResult {
+    /// Opaque handle for the savepoint on the server.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub savepoint_id: ::prost::bytes::Bytes,
+}
+///
+/// Request message for the "EndTransaction" action.
+///
+/// Commit (COMMIT) or rollback (ROLLBACK) the transaction.
+///
+/// If the action completes successfully, the transaction handle is
+/// invalidated, as are all associated savepoints.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ActionEndTransactionRequest {
+    /// Opaque handle for the transaction on the server.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub transaction_id: ::prost::bytes::Bytes,
+    /// Whether to commit/rollback the given transaction.
+    #[prost(enumeration = "action_end_transaction_request::EndTransaction", tag = "2")]
+    pub action: i32,
+}
+/// Nested message and enum types in `ActionEndTransactionRequest`.
+pub mod action_end_transaction_request {
+    #[derive(
+        Clone,
+        Copy,
+        Debug,
+        PartialEq,
+        Eq,
+        Hash,
+        PartialOrd,
+        Ord,
+        ::prost::Enumeration
+    )]
+    #[repr(i32)]
+    pub enum EndTransaction {
+        Unspecified = 0,
+        /// Commit the transaction.
+        Commit = 1,
+        /// Roll back the transaction.
+        Rollback = 2,
+    }
+    impl EndTransaction {
+        /// String value of the enum field names used in the ProtoBuf definition.
+        ///
+        /// The values are not transformed in any way and thus are considered stable
+        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+        pub fn as_str_name(&self) -> &'static str {
+            match self {
+                EndTransaction::Unspecified => "END_TRANSACTION_UNSPECIFIED",
+                EndTransaction::Commit => "END_TRANSACTION_COMMIT",
+                EndTransaction::Rollback => "END_TRANSACTION_ROLLBACK",
+            }
+        }
+        /// Creates an enum from field names used in the ProtoBuf definition.
+        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+            match value {
+                "END_TRANSACTION_UNSPECIFIED" => Some(Self::Unspecified),
+                "END_TRANSACTION_COMMIT" => Some(Self::Commit),
+                "END_TRANSACTION_ROLLBACK" => Some(Self::Rollback),
+                _ => None,
+            }
+        }
+    }
+}
+///
+/// Request message for the "EndSavepoint" action.
+///
+/// Release (RELEASE) the savepoint or rollback (ROLLBACK) to the
+/// savepoint.
+///
+/// Releasing a savepoint invalidates that savepoint.  Rolling back to
+/// a savepoint does not invalidate the savepoint, but invalidates all
+/// savepoints created after the current savepoint.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ActionEndSavepointRequest {
+    /// Opaque handle for the savepoint on the server.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub savepoint_id: ::prost::bytes::Bytes,
+    /// Whether to rollback/release the given savepoint.
+    #[prost(enumeration = "action_end_savepoint_request::EndSavepoint", tag = "2")]
+    pub action: i32,
+}
+/// Nested message and enum types in `ActionEndSavepointRequest`.
+pub mod action_end_savepoint_request {
+    #[derive(
+        Clone,
+        Copy,
+        Debug,
+        PartialEq,
+        Eq,
+        Hash,
+        PartialOrd,
+        Ord,
+        ::prost::Enumeration
+    )]
+    #[repr(i32)]
+    pub enum EndSavepoint {
+        Unspecified = 0,
+        /// Release the savepoint.
+        Release = 1,
+        /// Roll back to a savepoint.
+        Rollback = 2,
+    }
+    impl EndSavepoint {
+        /// String value of the enum field names used in the ProtoBuf definition.
+        ///
+        /// The values are not transformed in any way and thus are considered stable
+        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+        pub fn as_str_name(&self) -> &'static str {
+            match self {
+                EndSavepoint::Unspecified => "END_SAVEPOINT_UNSPECIFIED",
+                EndSavepoint::Release => "END_SAVEPOINT_RELEASE",
+                EndSavepoint::Rollback => "END_SAVEPOINT_ROLLBACK",
+            }
+        }
+        /// Creates an enum from field names used in the ProtoBuf definition.
+        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+            match value {
+                "END_SAVEPOINT_UNSPECIFIED" => Some(Self::Unspecified),
+                "END_SAVEPOINT_RELEASE" => Some(Self::Release),
+                "END_SAVEPOINT_ROLLBACK" => Some(Self::Rollback),
+                _ => None,
+            }
+        }
+    }
+}
+///
+/// Represents a SQL query. Used in the command member of FlightDescriptor
+/// for the following RPC calls:
 ///   - GetSchema: return the Arrow schema of the query.
+///     Fields on this schema may contain the following metadata:
+///     - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+///     - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+///     - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+///     - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+///     - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+///     - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+///     - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+///     - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+///     - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+///     - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
 ///   - GetFlightInfo: execute the query.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandStatementQuery {
-    ///  The SQL syntax.
-    #[prost(string, tag="1")]
+    /// The SQL syntax.
+    #[prost(string, tag = "1")]
     pub query: ::prost::alloc::string::String,
+    /// Include the query as part of this transaction (if unset, the query is auto-committed).
+    #[prost(bytes = "bytes", optional, tag = "2")]
+    pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
+}
+///
+/// Represents a Substrait plan. Used in the command member of FlightDescriptor
+/// for the following RPC calls:
+///   - GetSchema: return the Arrow schema of the query.
+///     Fields on this schema may contain the following metadata:
+///     - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+///     - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+///     - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+///     - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+///     - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+///     - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+///     - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+///     - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+///     - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+///     - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+///   - GetFlightInfo: execute the query.
+///   - DoPut: execute the query.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct CommandStatementSubstraitPlan {
+    /// A serialized substrait.Plan
+    #[prost(message, optional, tag = "1")]
+    pub plan: ::core::option::Option<SubstraitPlan>,
+    /// Include the query as part of this transaction (if unset, the query is auto-committed).
+    #[prost(bytes = "bytes", optional, tag = "2")]
+    pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
 }
 /// *
-///  Represents a ticket resulting from GetFlightInfo with a CommandStatementQuery.
-///  This should be used only once and treated as an opaque value, that is, clients should not attempt to parse this.
+/// Represents a ticket resulting from GetFlightInfo with a CommandStatementQuery.
+/// This should be used only once and treated as an opaque value, that is, clients should not attempt to parse this.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct TicketStatementQuery {
-    ///  Unique identifier for the instance of the statement to execute.
-    #[prost(bytes="vec", tag="1")]
-    pub statement_handle: ::prost::alloc::vec::Vec<u8>,
+    /// Unique identifier for the instance of the statement to execute.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub statement_handle: ::prost::bytes::Bytes,
 }
 ///
-///  Represents an instance of executing a prepared statement. Used in the command member of FlightDescriptor for
-///  the following RPC calls:
+/// Represents an instance of executing a prepared statement. Used in the command member of FlightDescriptor for
+/// the following RPC calls:
+///   - GetSchema: return the Arrow schema of the query.
+///     Fields on this schema may contain the following metadata:
+///     - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+///     - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+///     - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+///     - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+///     - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+///     - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+///     - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+///     - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+///     - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+///     - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+///
+///     If the schema is retrieved after parameter values have been bound with DoPut, then the server should account
+///     for the parameters when determining the schema.
 ///   - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
 ///   - GetFlightInfo: execute the prepared statement instance.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandPreparedStatementQuery {
-    ///  Opaque handle for the prepared statement on the server.
-    #[prost(bytes="vec", tag="1")]
-    pub prepared_statement_handle: ::prost::alloc::vec::Vec<u8>,
+    /// Opaque handle for the prepared statement on the server.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub prepared_statement_handle: ::prost::bytes::Bytes,
 }
 ///
-///  Represents a SQL update query. Used in the command member of FlightDescriptor
-///  for the the RPC call DoPut to cause the server to execute the included SQL update.
+/// Represents a SQL update query. Used in the command member of FlightDescriptor
+/// for the RPC call DoPut to cause the server to execute the included SQL update.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandStatementUpdate {
-    ///  The SQL syntax.
-    #[prost(string, tag="1")]
+    /// The SQL syntax.
+    #[prost(string, tag = "1")]
     pub query: ::prost::alloc::string::String,
+    /// Include the query as part of this transaction (if unset, the query is auto-committed).
+    #[prost(bytes = "bytes", optional, tag = "2")]
+    pub transaction_id: ::core::option::Option<::prost::bytes::Bytes>,
 }
 ///
-///  Represents a SQL update query. Used in the command member of FlightDescriptor
-///  for the the RPC call DoPut to cause the server to execute the included 
-///  prepared statement handle as an update.
+/// Represents a SQL update query. Used in the command member of FlightDescriptor
+/// for the RPC call DoPut to cause the server to execute the included
+/// prepared statement handle as an update.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct CommandPreparedStatementUpdate {
-    ///  Opaque handle for the prepared statement on the server.
-    #[prost(bytes="vec", tag="1")]
-    pub prepared_statement_handle: ::prost::alloc::vec::Vec<u8>,
+    /// Opaque handle for the prepared statement on the server.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub prepared_statement_handle: ::prost::bytes::Bytes,
 }
 ///
-///  Returned from the RPC call DoPut when a CommandStatementUpdate
-///  CommandPreparedStatementUpdate was in the request, containing
-///  results from the update. 
+/// Returned from the RPC call DoPut when a CommandStatementUpdate
+/// CommandPreparedStatementUpdate was in the request, containing
+/// results from the update.
+#[allow(clippy::derive_partial_eq_without_eq)]
 #[derive(Clone, PartialEq, ::prost::Message)]
 pub struct DoPutUpdateResult {
-    ///  The number of records updated. A return value of -1 represents 
-    ///  an unknown updated record count.
-    #[prost(int64, tag="1")]
+    /// The number of records updated. A return value of -1 represents
+    /// an unknown updated record count.
+    #[prost(int64, tag = "1")]
     pub record_count: i64,
 }
-///  Options for CommandGetSqlInfo.
+///
+/// Request message for the "CancelQuery" action.
+///
+/// Explicitly cancel a running query.
+///
+/// This lets a single client explicitly cancel work, no matter how many clients
+/// are involved/whether the query is distributed or not, given server support.
+/// The transaction/statement is not rolled back; it is the application's job to
+/// commit or rollback as appropriate. This only indicates the client no longer
+/// wishes to read the remainder of the query results or continue submitting
+/// data.
+///
+/// This command is idempotent.
+///
+/// This command is deprecated since 13.0.0. Use the "CancelFlightInfo"
+/// action with DoAction instead.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ActionCancelQueryRequest {
+    /// The result of the GetFlightInfo RPC that initiated the query.
+    /// XXX(ARROW-16902): this must be a serialized FlightInfo, but is
+    /// rendered as bytes because Protobuf does not really support one
+    /// DLL using Protobuf definitions from another DLL.
+    #[prost(bytes = "bytes", tag = "1")]
+    pub info: ::prost::bytes::Bytes,
+}
+///
+/// The result of cancelling a query.
+///
+/// The result should be wrapped in a google.protobuf.Any message.
+///
+/// This command is deprecated since 13.0.0. Use the "CancelFlightInfo"
+/// action with DoAction instead.
+#[allow(clippy::derive_partial_eq_without_eq)]
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct ActionCancelQueryResult {
+    #[prost(enumeration = "action_cancel_query_result::CancelResult", tag = "1")]
+    pub result: i32,
+}
+/// Nested message and enum types in `ActionCancelQueryResult`.
+pub mod action_cancel_query_result {
+    #[derive(
+        Clone,
+        Copy,
+        Debug,
+        PartialEq,
+        Eq,
+        Hash,
+        PartialOrd,
+        Ord,
+        ::prost::Enumeration
+    )]
+    #[repr(i32)]
+    pub enum CancelResult {
+        /// The cancellation status is unknown. Servers should avoid using
+        /// this value (send a NOT_FOUND error if the requested query is
+        /// not known). Clients can retry the request.
+        Unspecified = 0,
+        /// The cancellation request is complete. Subsequent requests with
+        /// the same payload may return CANCELLED or a NOT_FOUND error.
+        Cancelled = 1,
+        /// The cancellation request is in progress. The client may retry
+        /// the cancellation request.
+        Cancelling = 2,
+        /// The query is not cancellable. The client should not retry the
+        /// cancellation request.
+        NotCancellable = 3,
+    }
+    impl CancelResult {
+        /// String value of the enum field names used in the ProtoBuf definition.
+        ///
+        /// The values are not transformed in any way and thus are considered stable
+        /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+        pub fn as_str_name(&self) -> &'static str {
+            match self {
+                CancelResult::Unspecified => "CANCEL_RESULT_UNSPECIFIED",
+                CancelResult::Cancelled => "CANCEL_RESULT_CANCELLED",
+                CancelResult::Cancelling => "CANCEL_RESULT_CANCELLING",
+                CancelResult::NotCancellable => "CANCEL_RESULT_NOT_CANCELLABLE",
+            }
+        }
+        /// Creates an enum from field names used in the ProtoBuf definition.
+        pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+            match value {
+                "CANCEL_RESULT_UNSPECIFIED" => Some(Self::Unspecified),
+                "CANCEL_RESULT_CANCELLED" => Some(Self::Cancelled),
+                "CANCEL_RESULT_CANCELLING" => Some(Self::Cancelling),
+                "CANCEL_RESULT_NOT_CANCELLABLE" => Some(Self::NotCancellable),
+                _ => None,
+            }
+        }
+    }
+}
+/// Options for CommandGetSqlInfo.
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
 pub enum SqlInfo {
-    //  Server Information [0-500): Provides basic information about the Flight SQL Server.
-
-    ///  Retrieves a UTF-8 string with the name of the Flight SQL Server.
+    /// Retrieves a UTF-8 string with the name of the Flight SQL Server.
     FlightSqlServerName = 0,
-    ///  Retrieves a UTF-8 string with the native version of the Flight SQL Server.
+    /// Retrieves a UTF-8 string with the native version of the Flight SQL Server.
     FlightSqlServerVersion = 1,
-    ///  Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server.
+    /// Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server.
     FlightSqlServerArrowVersion = 2,
-    ///  
-    ///  Retrieves a boolean value indicating whether the Flight SQL Server is read only.
     ///
-    ///  Returns:
-    ///  - false: if read-write
-    ///  - true: if read only
+    /// Retrieves a boolean value indicating whether the Flight SQL Server is read only.
+    ///
+    /// Returns:
+    /// - false: if read-write
+    /// - true: if read only
     FlightSqlServerReadOnly = 3,
-    //  SQL Syntax Information [500-1000): provides information about SQL syntax supported by the Flight SQL Server.
-
     ///
-    ///  Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of catalogs.
+    /// Retrieves a boolean value indicating whether the Flight SQL Server supports executing
+    /// SQL queries.
+    ///
+    /// Note that the absence of this info (as opposed to a false value) does not necessarily
+    /// mean that SQL is not supported, as this property was not originally defined.
+    FlightSqlServerSql = 4,
+    ///
+    /// Retrieves a boolean value indicating whether the Flight SQL Server supports executing
+    /// Substrait plans.
+    FlightSqlServerSubstrait = 5,
+    ///
+    /// Retrieves a string value indicating the minimum supported Substrait version, or null
+    /// if Substrait is not supported.
+    FlightSqlServerSubstraitMinVersion = 6,
+    ///
+    /// Retrieves a string value indicating the maximum supported Substrait version, or null
+    /// if Substrait is not supported.
+    FlightSqlServerSubstraitMaxVersion = 7,
+    ///
+    /// Retrieves an int32 indicating whether the Flight SQL Server supports the
+    /// BeginTransaction/EndTransaction/BeginSavepoint/EndSavepoint actions.
+    ///
+    /// Even if this is not supported, the database may still support explicit "BEGIN
+    /// TRANSACTION"/"COMMIT" SQL statements (see SQL_TRANSACTIONS_SUPPORTED); this property
+    /// is only about whether the server implements the Flight SQL API endpoints.
+    ///
+    /// The possible values are listed in `SqlSupportedTransaction`.
+    FlightSqlServerTransaction = 8,
+    ///
+    /// Retrieves a boolean value indicating whether the Flight SQL Server supports explicit
+    /// query cancellation (the CancelQuery action).
+    FlightSqlServerCancel = 9,
+    ///
+    /// Retrieves an int32 indicating the timeout (in milliseconds) for prepared statement handles.
+    ///
+    /// If 0, there is no timeout.  Servers should reset the timeout when the handle is used in a command.
+    FlightSqlServerStatementTimeout = 100,
+    ///
+    /// Retrieves an int32 indicating the timeout (in milliseconds) for transactions, since transactions are not tied to a connection.
     ///
-    ///  Returns:
-    ///  - false: if it doesn't support CREATE and DROP of catalogs.
-    ///  - true: if it supports CREATE and DROP of catalogs.
+    /// If 0, there is no timeout.  Servers should reset the timeout when the handle is used in a command.
+    FlightSqlServerTransactionTimeout = 101,
+    ///
+    /// Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of catalogs.
+    ///
+    /// Returns:
+    /// - false: if it doesn't support CREATE and DROP of catalogs.
+    /// - true: if it supports CREATE and DROP of catalogs.
     SqlDdlCatalog = 500,
     ///
-    ///  Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of schemas.
+    /// Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of schemas.
     ///
-    ///  Returns:
-    ///  - false: if it doesn't support CREATE and DROP of schemas.
-    ///  - true: if it supports CREATE and DROP of schemas.
+    /// Returns:
+    /// - false: if it doesn't support CREATE and DROP of schemas.
+    /// - true: if it supports CREATE and DROP of schemas.
     SqlDdlSchema = 501,
     ///
-    ///  Indicates whether the Flight SQL Server supports CREATE and DROP of tables.
+    /// Indicates whether the Flight SQL Server supports CREATE and DROP of tables.
     ///
-    ///  Returns:
-    ///  - false: if it doesn't support CREATE and DROP of tables.
-    ///  - true: if it supports CREATE and DROP of tables.
+    /// Returns:
+    /// - false: if it doesn't support CREATE and DROP of tables.
+    /// - true: if it supports CREATE and DROP of tables.
     SqlDdlTable = 502,
     ///
-    ///  Retrieves a uint32 value representing the enu uint32 ordinal for the case sensitivity of catalog, table, schema and table names.
+    /// Retrieves a int32 ordinal representing the case sensitivity of catalog, table, schema and table names.
     ///
-    ///  The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
+    /// The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
     SqlIdentifierCase = 503,
-    ///  Retrieves a UTF-8 string with the supported character(s) used to surround a delimited identifier.
+    /// Retrieves a UTF-8 string with the supported character(s) used to surround a delimited identifier.
     SqlIdentifierQuoteChar = 504,
     ///
-    ///  Retrieves a uint32 value representing the enu uint32 ordinal for the case sensitivity of quoted identifiers.
+    /// Retrieves a int32 describing the case sensitivity of quoted identifiers.
     ///
-    ///  The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
+    /// The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
     SqlQuotedIdentifierCase = 505,
     ///
-    ///  Retrieves a boolean value indicating whether all tables are selectable.
+    /// Retrieves a boolean value indicating whether all tables are selectable.
     ///
-    ///  Returns:
-    ///  - false: if not all tables are selectable or if none are;
-    ///  - true: if all tables are selectable.
+    /// Returns:
+    /// - false: if not all tables are selectable or if none are;
+    /// - true: if all tables are selectable.
     SqlAllTablesAreSelectable = 506,
     ///
-    ///  Retrieves the null ordering.
+    /// Retrieves the null ordering.
     ///
-    ///  Returns a uint32 ordinal for the null ordering being used, as described in
-    ///  `arrow.flight.protocol.sql.SqlNullOrdering`.
+    /// Returns a int32 ordinal for the null ordering being used, as described in
+    /// `arrow.flight.protocol.sql.SqlNullOrdering`.
     SqlNullOrdering = 507,
-    ///  Retrieves a UTF-8 string list with values of the supported keywords.
+    /// Retrieves a UTF-8 string list with values of the supported keywords.
     SqlKeywords = 508,
-    ///  Retrieves a UTF-8 string list with values of the supported numeric functions.
+    /// Retrieves a UTF-8 string list with values of the supported numeric functions.
     SqlNumericFunctions = 509,
-    ///  Retrieves a UTF-8 string list with values of the supported string functions.
+    /// Retrieves a UTF-8 string list with values of the supported string functions.
     SqlStringFunctions = 510,
-    ///  Retrieves a UTF-8 string list with values of the supported system functions.
+    /// Retrieves a UTF-8 string list with values of the supported system functions.
     SqlSystemFunctions = 511,
-    ///  Retrieves a UTF-8 string list with values of the supported datetime functions.
+    /// Retrieves a UTF-8 string list with values of the supported datetime functions.
     SqlDatetimeFunctions = 512,
     ///
-    ///  Retrieves the UTF-8 string that can be used to escape wildcard characters.
-    ///  This is the string that can be used to escape '_' or '%' in the catalog search parameters that are a pattern
-    ///  (and therefore use one of the wildcard characters).
-    ///  The '_' character represents any single character; the '%' character represents any sequence of zero or more
-    ///  characters.
+    /// Retrieves the UTF-8 string that can be used to escape wildcard characters.
+    /// This is the string that can be used to escape '_' or '%' in the catalog search parameters that are a pattern
+    /// (and therefore use one of the wildcard characters).
+    /// The '_' character represents any single character; the '%' character represents any sequence of zero or more
+    /// characters.
     SqlSearchStringEscape = 513,
     ///
-    ///  Retrieves a UTF-8 string with all the "extra" characters that can be used in unquoted identifier names
-    ///  (those beyond a-z, A-Z, 0-9 and _).
+    /// Retrieves a UTF-8 string with all the "extra" characters that can be used in unquoted identifier names
+    /// (those beyond a-z, A-Z, 0-9 and _).
     SqlExtraNameCharacters = 514,
     ///
-    ///  Retrieves a boolean value indicating whether column aliasing is supported.
-    ///  If so, the SQL AS clause can be used to provide names for computed columns or to provide alias names for columns
-    ///  as required.
+    /// Retrieves a boolean value indicating whether column aliasing is supported.
+    /// If so, the SQL AS clause can be used to provide names for computed columns or to provide alias names for columns
+    /// as required.
     ///
-    ///  Returns:
-    ///  - false: if column aliasing is unsupported;
-    ///  - true: if column aliasing is supported.
+    /// Returns:
+    /// - false: if column aliasing is unsupported;
+    /// - true: if column aliasing is supported.
     SqlSupportsColumnAliasing = 515,
     ///
-    ///  Retrieves a boolean value indicating whether concatenations between null and non-null values being
-    ///  null are supported.
+    /// Retrieves a boolean value indicating whether concatenations between null and non-null values being
+    /// null are supported.
     ///
-    ///  - Returns:
-    ///  - false: if concatenations between null and non-null values being null are unsupported;
-    ///  - true: if concatenations between null and non-null values being null are supported.
+    /// - Returns:
+    /// - false: if concatenations between null and non-null values being null are unsupported;
+    /// - true: if concatenations between null and non-null values being null are supported.
     SqlNullPlusNullIsNull = 516,
     ///
-    ///  Retrieves a map where the key is the type to convert from and the value is a list with the types to convert to,
-    ///  indicating the supported conversions. Each key and each item on the list value is a value to a predefined type on
-    ///  SqlSupportsConvert enum.
-    ///  The returned map will be:  map<int32, list<int32>>
+    /// Retrieves a map where the key is the type to convert from and the value is a list with the types to convert to,
+    /// indicating the supported conversions. Each key and each item on the list value is a value to a predefined type on
+    /// SqlSupportsConvert enum.
+    /// The returned map will be:  map<int32, list<int32>>
     SqlSupportsConvert = 517,
     ///
-    ///  Retrieves a boolean value indicating whether, when table correlation names are supported,
-    ///  they are restricted to being different from the names of the tables.
+    /// Retrieves a boolean value indicating whether, when table correlation names are supported,
+    /// they are restricted to being different from the names of the tables.
     ///
-    ///  Returns:
-    ///  - false: if table correlation names are unsupported;
-    ///  - true: if table correlation names are supported.
+    /// Returns:
+    /// - false: if table correlation names are unsupported;
+    /// - true: if table correlation names are supported.
     SqlSupportsTableCorrelationNames = 518,
     ///
-    ///  Retrieves a boolean value indicating whether, when table correlation names are supported,
-    ///  they are restricted to being different from the names of the tables.
+    /// Retrieves a boolean value indicating whether, when table correlation names are supported,
+    /// they are restricted to being different from the names of the tables.
     ///
-    ///  Returns:
-    ///  - false: if different table correlation names are unsupported;
-    ///  - true: if different table correlation names are supported
+    /// Returns:
+    /// - false: if different table correlation names are unsupported;
+    /// - true: if different table correlation names are supported
     SqlSupportsDifferentTableCorrelationNames = 519,
     ///
-    ///  Retrieves a boolean value indicating whether expressions in ORDER BY lists are supported.
+    /// Retrieves a boolean value indicating whether expressions in ORDER BY lists are supported.
     ///
-    ///  Returns:
-    ///  - false: if expressions in ORDER BY are unsupported;
-    ///  - true: if expressions in ORDER BY are supported;
+    /// Returns:
+    /// - false: if expressions in ORDER BY are unsupported;
+    /// - true: if expressions in ORDER BY are supported;
     SqlSupportsExpressionsInOrderBy = 520,
     ///
-    ///  Retrieves a boolean value indicating whether using a column that is not in the SELECT statement in a GROUP BY
-    ///  clause is supported.
+    /// Retrieves a boolean value indicating whether using a column that is not in the SELECT statement in a GROUP BY
+    /// clause is supported.
     ///
-    ///  Returns:
-    ///  - false: if using a column that is not in the SELECT statement in a GROUP BY clause is unsupported;
-    ///  - true: if using a column that is not in the SELECT statement in a GROUP BY clause is supported.
+    /// Returns:
+    /// - false: if using a column that is not in the SELECT statement in a GROUP BY clause is unsupported;
+    /// - true: if using a column that is not in the SELECT statement in a GROUP BY clause is supported.
     SqlSupportsOrderByUnrelated = 521,
     ///
-    ///  Retrieves the supported GROUP BY commands;
+    /// Retrieves the supported GROUP BY commands;
     ///
-    ///  Returns an int32 bitmask value representing the supported commands.
-    ///  The returned bitmask should be parsed in order to retrieve the supported commands.
+    /// Returns an int32 bitmask value representing the supported commands.
+    /// The returned bitmask should be parsed in order to retrieve the supported commands.
     ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (GROUP BY is unsupported);
-    ///  - return 1 (\b1)   => \[SQL_GROUP_BY_UNRELATED\];
-    ///  - return 2 (\b10)  => \[SQL_GROUP_BY_BEYOND_SELECT\];
-    ///  - return 3 (\b11)  => [SQL_GROUP_BY_UNRELATED, SQL_GROUP_BY_BEYOND_SELECT].
-    ///  Valid GROUP BY types are described under `arrow.flight.protocol.sql.SqlSupportedGroupBy`.
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (GROUP BY is unsupported);
+    /// - return 1 (\b1)   => \[SQL_GROUP_BY_UNRELATED\];
+    /// - return 2 (\b10)  => \[SQL_GROUP_BY_BEYOND_SELECT\];
+    /// - return 3 (\b11)  => \[SQL_GROUP_BY_UNRELATED, SQL_GROUP_BY_BEYOND_SELECT\].
+    /// Valid GROUP BY types are described under `arrow.flight.protocol.sql.SqlSupportedGroupBy`.
     SqlSupportedGroupBy = 522,
     ///
-    ///  Retrieves a boolean value indicating whether specifying a LIKE escape clause is supported.
+    /// Retrieves a boolean value indicating whether specifying a LIKE escape clause is supported.
     ///
-    ///  Returns:
-    ///  - false: if specifying a LIKE escape clause is unsupported;
-    ///  - true: if specifying a LIKE escape clause is supported.
+    /// Returns:
+    /// - false: if specifying a LIKE escape clause is unsupported;
+    /// - true: if specifying a LIKE escape clause is supported.
     SqlSupportsLikeEscapeClause = 523,
     ///
-    ///  Retrieves a boolean value indicating whether columns may be defined as non-nullable.
+    /// Retrieves a boolean value indicating whether columns may be defined as non-nullable.
     ///
-    ///  Returns:
-    ///  - false: if columns cannot be defined as non-nullable;
-    ///  - true: if columns may be defined as non-nullable.
+    /// Returns:
+    /// - false: if columns cannot be defined as non-nullable;
+    /// - true: if columns may be defined as non-nullable.
     SqlSupportsNonNullableColumns = 524,
     ///
-    ///  Retrieves the supported SQL grammar level as per the ODBC specification.
-    ///
-    ///  Returns an int32 bitmask value representing the supported SQL grammar level.
-    ///  The returned bitmask should be parsed in order to retrieve the supported grammar levels.
-    ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (SQL grammar is unsupported);
-    ///  - return 1 (\b1)   => \[SQL_MINIMUM_GRAMMAR\];
-    ///  - return 2 (\b10)  => \[SQL_CORE_GRAMMAR\];
-    ///  - return 3 (\b11)  => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR];
-    ///  - return 4 (\b100) => \[SQL_EXTENDED_GRAMMAR\];
-    ///  - return 5 (\b101) => [SQL_MINIMUM_GRAMMAR, SQL_EXTENDED_GRAMMAR];
-    ///  - return 6 (\b110) => [SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR];
-    ///  - return 7 (\b111) => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR].
-    ///  Valid SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedSqlGrammar`.
+    /// Retrieves the supported SQL grammar level as per the ODBC specification.
+    ///
+    /// Returns an int32 bitmask value representing the supported SQL grammar level.
+    /// The returned bitmask should be parsed in order to retrieve the supported grammar levels.
+    ///
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (SQL grammar is unsupported);
+    /// - return 1 (\b1)   => \[SQL_MINIMUM_GRAMMAR\];
+    /// - return 2 (\b10)  => \[SQL_CORE_GRAMMAR\];
+    /// - return 3 (\b11)  => \[SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR\];
+    /// - return 4 (\b100) => \[SQL_EXTENDED_GRAMMAR\];
+    /// - return 5 (\b101) => \[SQL_MINIMUM_GRAMMAR, SQL_EXTENDED_GRAMMAR\];
+    /// - return 6 (\b110) => \[SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR\];
+    /// - return 7 (\b111) => \[SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR\].
+    /// Valid SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedSqlGrammar`.
     SqlSupportedGrammar = 525,
     ///
-    ///  Retrieves the supported ANSI92 SQL grammar level.
-    ///
-    ///  Returns an int32 bitmask value representing the supported ANSI92 SQL grammar level.
-    ///  The returned bitmask should be parsed in order to retrieve the supported commands.
-    ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (ANSI92 SQL grammar is unsupported);
-    ///  - return 1 (\b1)   => \[ANSI92_ENTRY_SQL\];
-    ///  - return 2 (\b10)  => \[ANSI92_INTERMEDIATE_SQL\];
-    ///  - return 3 (\b11)  => [ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL];
-    ///  - return 4 (\b100) => \[ANSI92_FULL_SQL\];
-    ///  - return 5 (\b101) => [ANSI92_ENTRY_SQL, ANSI92_FULL_SQL];
-    ///  - return 6 (\b110) => [ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL];
-    ///  - return 7 (\b111) => [ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL].
-    ///  Valid ANSI92 SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedAnsi92SqlGrammarLevel`.
+    /// Retrieves the supported ANSI92 SQL grammar level.
+    ///
+    /// Returns an int32 bitmask value representing the supported ANSI92 SQL grammar level.
+    /// The returned bitmask should be parsed in order to retrieve the supported commands.
+    ///
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (ANSI92 SQL grammar is unsupported);
+    /// - return 1 (\b1)   => \[ANSI92_ENTRY_SQL\];
+    /// - return 2 (\b10)  => \[ANSI92_INTERMEDIATE_SQL\];
+    /// - return 3 (\b11)  => \[ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL\];
+    /// - return 4 (\b100) => \[ANSI92_FULL_SQL\];
+    /// - return 5 (\b101) => \[ANSI92_ENTRY_SQL, ANSI92_FULL_SQL\];
+    /// - return 6 (\b110) => \[ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL\];
+    /// - return 7 (\b111) => \[ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL\].
+    /// Valid ANSI92 SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedAnsi92SqlGrammarLevel`.
     SqlAnsi92SupportedLevel = 526,
     ///
-    ///  Retrieves a boolean value indicating whether the SQL Integrity Enhancement Facility is supported.
+    /// Retrieves a boolean value indicating whether the SQL Integrity Enhancement Facility is supported.
     ///
-    ///  Returns:
-    ///  - false: if the SQL Integrity Enhancement Facility is supported;
-    ///  - true: if the SQL Integrity Enhancement Facility is supported.
+    /// Returns:
+    /// - false: if the SQL Integrity Enhancement Facility is supported;
+    /// - true: if the SQL Integrity Enhancement Facility is supported.
     SqlSupportsIntegrityEnhancementFacility = 527,
     ///
-    ///  Retrieves the support level for SQL OUTER JOINs.
+    /// Retrieves the support level for SQL OUTER JOINs.
     ///
-    ///  Returns a uint3 uint32 ordinal for the SQL ordering being used, as described in
-    ///  `arrow.flight.protocol.sql.SqlOuterJoinsSupportLevel`.
+    /// Returns a int32 ordinal for the SQL ordering being used, as described in
+    /// `arrow.flight.protocol.sql.SqlOuterJoinsSupportLevel`.
     SqlOuterJoinsSupportLevel = 528,
-    ///  Retrieves a UTF-8 string with the preferred term for "schema".
+    /// Retrieves a UTF-8 string with the preferred term for "schema".
     SqlSchemaTerm = 529,
-    ///  Retrieves a UTF-8 string with the preferred term for "procedure".
+    /// Retrieves a UTF-8 string with the preferred term for "procedure".
     SqlProcedureTerm = 530,
-    ///  Retrieves a UTF-8 string with the preferred term for "catalog".
+    ///
+    /// Retrieves a UTF-8 string with the preferred term for "catalog".
+    /// If a empty string is returned its assumed that the server does NOT supports catalogs.
     SqlCatalogTerm = 531,
     ///
-    ///  Retrieves a boolean value indicating whether a catalog appears at the start of a fully qualified table name.
+    /// Retrieves a boolean value indicating whether a catalog appears at the start of a fully qualified table name.
     ///
-    ///  - false: if a catalog does not appear at the start of a fully qualified table name;
-    ///  - true: if a catalog appears at the start of a fully qualified table name.
+    /// - false: if a catalog does not appear at the start of a fully qualified table name;
+    /// - true: if a catalog appears at the start of a fully qualified table name.
     SqlCatalogAtStart = 532,
     ///
-    ///  Retrieves the supported actions for a SQL schema.
-    ///
-    ///  Returns an int32 bitmask value representing the supported actions for a SQL schema.
-    ///  The returned bitmask should be parsed in order to retrieve the supported actions for a SQL schema.
-    ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (no supported actions for SQL schema);
-    ///  - return 1 (\b1)   => \[SQL_ELEMENT_IN_PROCEDURE_CALLS\];
-    ///  - return 2 (\b10)  => \[SQL_ELEMENT_IN_INDEX_DEFINITIONS\];
-    ///  - return 3 (\b11)  => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS];
-    ///  - return 4 (\b100) => \[SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
-    ///  - return 5 (\b101) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
-    ///  - return 6 (\b110) => [SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
-    ///  - return 7 (\b111) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS].
-    ///  Valid actions for a SQL schema described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
+    /// Retrieves the supported actions for a SQL schema.
+    ///
+    /// Returns an int32 bitmask value representing the supported actions for a SQL schema.
+    /// The returned bitmask should be parsed in order to retrieve the supported actions for a SQL schema.
+    ///
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (no supported actions for SQL schema);
+    /// - return 1 (\b1)   => \[SQL_ELEMENT_IN_PROCEDURE_CALLS\];
+    /// - return 2 (\b10)  => \[SQL_ELEMENT_IN_INDEX_DEFINITIONS\];
+    /// - return 3 (\b11)  => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS\];
+    /// - return 4 (\b100) => \[SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
+    /// - return 5 (\b101) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
+    /// - return 6 (\b110) => \[SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
+    /// - return 7 (\b111) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\].
+    /// Valid actions for a SQL schema described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
     SqlSchemasSupportedActions = 533,
     ///
-    ///  Retrieves the supported actions for a SQL schema.
-    ///
-    ///  Returns an int32 bitmask value representing the supported actions for a SQL catalog.
-    ///  The returned bitmask should be parsed in order to retrieve the supported actions for a SQL catalog.
-    ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (no supported actions for SQL catalog);
-    ///  - return 1 (\b1)   => \[SQL_ELEMENT_IN_PROCEDURE_CALLS\];
-    ///  - return 2 (\b10)  => \[SQL_ELEMENT_IN_INDEX_DEFINITIONS\];
-    ///  - return 3 (\b11)  => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS];
-    ///  - return 4 (\b100) => \[SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
-    ///  - return 5 (\b101) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
-    ///  - return 6 (\b110) => [SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
-    ///  - return 7 (\b111) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS].
-    ///  Valid actions for a SQL catalog are described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
+    /// Retrieves the supported actions for a SQL schema.
+    ///
+    /// Returns an int32 bitmask value representing the supported actions for a SQL catalog.
+    /// The returned bitmask should be parsed in order to retrieve the supported actions for a SQL catalog.
+    ///
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (no supported actions for SQL catalog);
+    /// - return 1 (\b1)   => \[SQL_ELEMENT_IN_PROCEDURE_CALLS\];
+    /// - return 2 (\b10)  => \[SQL_ELEMENT_IN_INDEX_DEFINITIONS\];
+    /// - return 3 (\b11)  => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS\];
+    /// - return 4 (\b100) => \[SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
+    /// - return 5 (\b101) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
+    /// - return 6 (\b110) => \[SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\];
+    /// - return 7 (\b111) => \[SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS\].
+    /// Valid actions for a SQL catalog are described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
     SqlCatalogsSupportedActions = 534,
     ///
-    ///  Retrieves the supported SQL positioned commands.
+    /// Retrieves the supported SQL positioned commands.
     ///
-    ///  Returns an int32 bitmask value representing the supported SQL positioned commands.
-    ///  The returned bitmask should be parsed in order to retrieve the supported SQL positioned commands.
+    /// Returns an int32 bitmask value representing the supported SQL positioned commands.
+    /// The returned bitmask should be parsed in order to retrieve the supported SQL positioned commands.
     ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (no supported SQL positioned commands);
-    ///  - return 1 (\b1)   => \[SQL_POSITIONED_DELETE\];
-    ///  - return 2 (\b10)  => \[SQL_POSITIONED_UPDATE\];
-    ///  - return 3 (\b11)  => [SQL_POSITIONED_DELETE, SQL_POSITIONED_UPDATE].
-    ///  Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedPositionedCommands`.
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (no supported SQL positioned commands);
+    /// - return 1 (\b1)   => \[SQL_POSITIONED_DELETE\];
+    /// - return 2 (\b10)  => \[SQL_POSITIONED_UPDATE\];
+    /// - return 3 (\b11)  => \[SQL_POSITIONED_DELETE, SQL_POSITIONED_UPDATE\].
+    /// Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedPositionedCommands`.
     SqlSupportedPositionedCommands = 535,
     ///
-    ///  Retrieves a boolean value indicating whether SELECT FOR UPDATE statements are supported.
+    /// Retrieves a boolean value indicating whether SELECT FOR UPDATE statements are supported.
     ///
-    ///  Returns:
-    ///  - false: if SELECT FOR UPDATE statements are unsupported;
-    ///  - true: if SELECT FOR UPDATE statements are supported.
+    /// Returns:
+    /// - false: if SELECT FOR UPDATE statements are unsupported;
+    /// - true: if SELECT FOR UPDATE statements are supported.
     SqlSelectForUpdateSupported = 536,
     ///
-    ///  Retrieves a boolean value indicating whether stored procedure calls that use the stored procedure escape syntax
-    ///  are supported.
+    /// Retrieves a boolean value indicating whether stored procedure calls that use the stored procedure escape syntax
+    /// are supported.
     ///
-    ///  Returns:
-    ///  - false: if stored procedure calls that use the stored procedure escape syntax are unsupported;
-    ///  - true: if stored procedure calls that use the stored procedure escape syntax are supported.
+    /// Returns:
+    /// - false: if stored procedure calls that use the stored procedure escape syntax are unsupported;
+    /// - true: if stored procedure calls that use the stored procedure escape syntax are supported.
     SqlStoredProceduresSupported = 537,
     ///
-    ///  Retrieves the supported SQL subqueries.
-    ///
-    ///  Returns an int32 bitmask value representing the supported SQL subqueries.
-    ///  The returned bitmask should be parsed in order to retrieve the supported SQL subqueries.
-    ///
-    ///  For instance:
-    ///  - return 0   (\b0)     => [] (no supported SQL subqueries);
-    ///  - return 1   (\b1)     => \[SQL_SUBQUERIES_IN_COMPARISONS\];
-    ///  - return 2   (\b10)    => \[SQL_SUBQUERIES_IN_EXISTS\];
-    ///  - return 3   (\b11)    => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS];
-    ///  - return 4   (\b100)   => \[SQL_SUBQUERIES_IN_INS\];
-    ///  - return 5   (\b101)   => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS];
-    ///  - return 6   (\b110)   => [SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_EXISTS];
-    ///  - return 7   (\b111)   => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS];
-    ///  - return 8   (\b1000)  => \[SQL_SUBQUERIES_IN_QUANTIFIEDS\];
-    ///  - return 9   (\b1001)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-    ///  - return 10  (\b1010)  => [SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-    ///  - return 11  (\b1011)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-    ///  - return 12  (\b1100)  => [SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-    ///  - return 13  (\b1101)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-    ///  - return 14  (\b1110)  => [SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-    ///  - return 15  (\b1111)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-    ///  - ...
-    ///  Valid SQL subqueries are described under `arrow.flight.protocol.sql.SqlSupportedSubqueries`.
+    /// Retrieves the supported SQL subqueries.
+    ///
+    /// Returns an int32 bitmask value representing the supported SQL subqueries.
+    /// The returned bitmask should be parsed in order to retrieve the supported SQL subqueries.
+    ///
+    /// For instance:
+    /// - return 0   (\b0)     => \[\] (no supported SQL subqueries);
+    /// - return 1   (\b1)     => \[SQL_SUBQUERIES_IN_COMPARISONS\];
+    /// - return 2   (\b10)    => \[SQL_SUBQUERIES_IN_EXISTS\];
+    /// - return 3   (\b11)    => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS\];
+    /// - return 4   (\b100)   => \[SQL_SUBQUERIES_IN_INS\];
+    /// - return 5   (\b101)   => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS\];
+    /// - return 6   (\b110)   => \[SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_EXISTS\];
+    /// - return 7   (\b111)   => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS\];
+    /// - return 8   (\b1000)  => \[SQL_SUBQUERIES_IN_QUANTIFIEDS\];
+    /// - return 9   (\b1001)  => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
+    /// - return 10  (\b1010)  => \[SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
+    /// - return 11  (\b1011)  => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
+    /// - return 12  (\b1100)  => \[SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
+    /// - return 13  (\b1101)  => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
+    /// - return 14  (\b1110)  => \[SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
+    /// - return 15  (\b1111)  => \[SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS\];
+    /// - ...
+    /// Valid SQL subqueries are described under `arrow.flight.protocol.sql.SqlSupportedSubqueries`.
     SqlSupportedSubqueries = 538,
     ///
-    ///  Retrieves a boolean value indicating whether correlated subqueries are supported.
+    /// Retrieves a boolean value indicating whether correlated subqueries are supported.
     ///
-    ///  Returns:
-    ///  - false: if correlated subqueries are unsupported;
-    ///  - true: if correlated subqueries are supported.
+    /// Returns:
+    /// - false: if correlated subqueries are unsupported;
+    /// - true: if correlated subqueries are supported.
     SqlCorrelatedSubqueriesSupported = 539,
     ///
-    ///  Retrieves the supported SQL UNIONs.
+    /// Retrieves the supported SQL UNIONs.
     ///
-    ///  Returns an int32 bitmask value representing the supported SQL UNIONs.
-    ///  The returned bitmask should be parsed in order to retrieve the supported SQL UNIONs.
+    /// Returns an int32 bitmask value representing the supported SQL UNIONs.
+    /// The returned bitmask should be parsed in order to retrieve the supported SQL UNIONs.
     ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (no supported SQL positioned commands);
-    ///  - return 1 (\b1)   => \[SQL_UNION\];
-    ///  - return 2 (\b10)  => \[SQL_UNION_ALL\];
-    ///  - return 3 (\b11)  => [SQL_UNION, SQL_UNION_ALL].
-    ///  Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedUnions`.
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (no supported SQL positioned commands);
+    /// - return 1 (\b1)   => \[SQL_UNION\];
+    /// - return 2 (\b10)  => \[SQL_UNION_ALL\];
+    /// - return 3 (\b11)  => \[SQL_UNION, SQL_UNION_ALL\].
+    /// Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedUnions`.
     SqlSupportedUnions = 540,
-    ///  Retrieves a uint32 value representing the maximum number of hex characters allowed in an inline binary literal.
+    /// Retrieves a int64 value representing the maximum number of hex characters allowed in an inline binary literal.
     SqlMaxBinaryLiteralLength = 541,
-    ///  Retrieves a uint32 value representing the maximum number of characters allowed for a character literal.
+    /// Retrieves a int64 value representing the maximum number of characters allowed for a character literal.
     SqlMaxCharLiteralLength = 542,
-    ///  Retrieves a uint32 value representing the maximum number of characters allowed for a column name.
+    /// Retrieves a int64 value representing the maximum number of characters allowed for a column name.
     SqlMaxColumnNameLength = 543,
-    ///  Retrieves a uint32 value representing the the maximum number of columns allowed in a GROUP BY clause.
+    /// Retrieves a int64 value representing the maximum number of columns allowed in a GROUP BY clause.
     SqlMaxColumnsInGroupBy = 544,
-    ///  Retrieves a uint32 value representing the maximum number of columns allowed in an index.
+    /// Retrieves a int64 value representing the maximum number of columns allowed in an index.
     SqlMaxColumnsInIndex = 545,
-    ///  Retrieves a uint32 value representing the maximum number of columns allowed in an ORDER BY clause.
+    /// Retrieves a int64 value representing the maximum number of columns allowed in an ORDER BY clause.
     SqlMaxColumnsInOrderBy = 546,
-    ///  Retrieves a uint32 value representing the maximum number of columns allowed in a SELECT list.
+    /// Retrieves a int64 value representing the maximum number of columns allowed in a SELECT list.
     SqlMaxColumnsInSelect = 547,
-    ///  Retrieves a uint32 value representing the maximum number of columns allowed in a table.
+    /// Retrieves a int64 value representing the maximum number of columns allowed in a table.
     SqlMaxColumnsInTable = 548,
-    ///  Retrieves a uint32 value representing the maximum number of concurrent connections possible.
+    /// Retrieves a int64 value representing the maximum number of concurrent connections possible.
     SqlMaxConnections = 549,
-    ///  Retrieves a uint32 value the maximum number of characters allowed in a cursor name.
+    /// Retrieves a int64 value the maximum number of characters allowed in a cursor name.
     SqlMaxCursorNameLength = 550,
     ///
-    ///  Retrieves a uint32 value representing the maximum number of bytes allowed for an index,
-    ///  including all of the parts of the index.
+    /// Retrieves a int64 value representing the maximum number of bytes allowed for an index,
+    /// including all of the parts of the index.
     SqlMaxIndexLength = 551,
-    ///  Retrieves a uint32 value representing the maximum number of characters allowed in a schema name.
+    /// Retrieves a int64 value representing the maximum number of characters allowed in a schema name.
     SqlDbSchemaNameLength = 552,
-    ///  Retrieves a uint32 value representing the maximum number of characters allowed in a procedure name.
+    /// Retrieves a int64 value representing the maximum number of characters allowed in a procedure name.
     SqlMaxProcedureNameLength = 553,
-    ///  Retrieves a uint32 value representing the maximum number of characters allowed in a catalog name.
+    /// Retrieves a int64 value representing the maximum number of characters allowed in a catalog name.
     SqlMaxCatalogNameLength = 554,
-    ///  Retrieves a uint32 value representing the maximum number of bytes allowed in a single row.
+    /// Retrieves a int64 value representing the maximum number of bytes allowed in a single row.
     SqlMaxRowSize = 555,
     ///
-    ///  Retrieves a boolean indicating whether the return value for the JDBC method getMaxRowSize includes the SQL
-    ///  data types LONGVARCHAR and LONGVARBINARY.
+    /// Retrieves a boolean indicating whether the return value for the JDBC method getMaxRowSize includes the SQL
+    /// data types LONGVARCHAR and LONGVARBINARY.
     ///
-    ///  Returns:
-    ///  - false: if return value for the JDBC method getMaxRowSize does
+    /// Returns:
+    /// - false: if return value for the JDBC method getMaxRowSize does
     ///           not include the SQL data types LONGVARCHAR and LONGVARBINARY;
-    ///  - true: if return value for the JDBC method getMaxRowSize includes
+    /// - true: if return value for the JDBC method getMaxRowSize includes
     ///          the SQL data types LONGVARCHAR and LONGVARBINARY.
     SqlMaxRowSizeIncludesBlobs = 556,
     ///
-    ///  Retrieves a uint32 value representing the maximum number of characters allowed for an SQL statement;
-    ///  a result of 0 (zero) means that there is no limit or the limit is not known.
+    /// Retrieves a int64 value representing the maximum number of characters allowed for an SQL statement;
+    /// a result of 0 (zero) means that there is no limit or the limit is not known.
     SqlMaxStatementLength = 557,
-    ///  Retrieves a uint32 value representing the maximum number of active statements that can be open at the same time.
+    /// Retrieves a int64 value representing the maximum number of active statements that can be open at the same time.
     SqlMaxStatements = 558,
-    ///  Retrieves a uint32 value representing the maximum number of characters allowed in a table name.
+    /// Retrieves a int64 value representing the maximum number of characters allowed in a table name.
     SqlMaxTableNameLength = 559,
-    ///  Retrieves a uint32 value representing the maximum number of tables allowed in a SELECT statement.
+    /// Retrieves a int64 value representing the maximum number of tables allowed in a SELECT statement.
     SqlMaxTablesInSelect = 560,
-    ///  Retrieves a uint32 value representing the maximum number of characters allowed in a user name.
+    /// Retrieves a int64 value representing the maximum number of characters allowed in a user name.
     SqlMaxUsernameLength = 561,
     ///
-    ///  Retrieves this database's default transaction isolation level as described in
-    ///  `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
+    /// Retrieves this database's default transaction isolation level as described in
+    /// `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
     ///
-    ///  Returns a uint32 ordinal for the SQL transaction isolation level.
+    /// Returns a int32 ordinal for the SQL transaction isolation level.
     SqlDefaultTransactionIsolation = 562,
     ///
-    ///  Retrieves a boolean value indicating whether transactions are supported. If not, invoking the method commit is a
-    ///  noop, and the isolation level is `arrow.flight.protocol.sql.SqlTransactionIsolationLevel.TRANSACTION_NONE`.
+    /// Retrieves a boolean value indicating whether transactions are supported. If not, invoking the method commit is a
+    /// noop, and the isolation level is `arrow.flight.protocol.sql.SqlTransactionIsolationLevel.TRANSACTION_NONE`.
     ///
-    ///  Returns:
-    ///  - false: if transactions are unsupported;
-    ///  - true: if transactions are supported.
+    /// Returns:
+    /// - false: if transactions are unsupported;
+    /// - true: if transactions are supported.
     SqlTransactionsSupported = 563,
     ///
-    ///  Retrieves the supported transactions isolation levels.
-    ///
-    ///  Returns an int32 bitmask value representing the supported transactions isolation levels.
-    ///  The returned bitmask should be parsed in order to retrieve the supported transactions isolation levels.
-    ///
-    ///  For instance:
-    ///  - return 0   (\b0)     => [] (no supported SQL transactions isolation levels);
-    ///  - return 1   (\b1)     => \[SQL_TRANSACTION_NONE\];
-    ///  - return 2   (\b10)    => \[SQL_TRANSACTION_READ_UNCOMMITTED\];
-    ///  - return 3   (\b11)    => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED];
-    ///  - return 4   (\b100)   => \[SQL_TRANSACTION_REPEATABLE_READ\];
-    ///  - return 5   (\b101)   => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ];
-    ///  - return 6   (\b110)   => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
-    ///  - return 7   (\b111)   => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
-    ///  - return 8   (\b1000)  => \[SQL_TRANSACTION_REPEATABLE_READ\];
-    ///  - return 9   (\b1001)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ];
-    ///  - return 10  (\b1010)  => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
-    ///  - return 11  (\b1011)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
-    ///  - return 12  (\b1100)  => [SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
-    ///  - return 13  (\b1101)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
-    ///  - return 14  (\b1110)  => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
-    ///  - return 15  (\b1111)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
-    ///  - return 16  (\b10000) => \[SQL_TRANSACTION_SERIALIZABLE\];
-    ///  - ...
-    ///  Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
+    /// Retrieves the supported transactions isolation levels.
+    ///
+    /// Returns an int32 bitmask value representing the supported transactions isolation levels.
+    /// The returned bitmask should be parsed in order to retrieve the supported transactions isolation levels.
+    ///
+    /// For instance:
+    /// - return 0   (\b0)     => \[\] (no supported SQL transactions isolation levels);
+    /// - return 1   (\b1)     => \[SQL_TRANSACTION_NONE\];
+    /// - return 2   (\b10)    => \[SQL_TRANSACTION_READ_UNCOMMITTED\];
+    /// - return 3   (\b11)    => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED\];
+    /// - return 4   (\b100)   => \[SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 5   (\b101)   => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 6   (\b110)   => \[SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 7   (\b111)   => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 8   (\b1000)  => \[SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 9   (\b1001)  => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 10  (\b1010)  => \[SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 11  (\b1011)  => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 12  (\b1100)  => \[SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 13  (\b1101)  => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 14  (\b1110)  => \[SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 15  (\b1111)  => \[SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ\];
+    /// - return 16  (\b10000) => \[SQL_TRANSACTION_SERIALIZABLE\];
+    /// - ...
+    /// Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
     SqlSupportedTransactionsIsolationLevels = 564,
     ///
-    ///  Retrieves a boolean value indicating whether a data definition statement within a transaction forces
-    ///  the transaction to commit.
+    /// Retrieves a boolean value indicating whether a data definition statement within a transaction forces
+    /// the transaction to commit.
     ///
-    ///  Returns:
-    ///  - false: if a data definition statement within a transaction does not force the transaction to commit;
-    ///  - true: if a data definition statement within a transaction forces the transaction to commit.
+    /// Returns:
+    /// - false: if a data definition statement within a transaction does not force the transaction to commit;
+    /// - true: if a data definition statement within a transaction forces the transaction to commit.
     SqlDataDefinitionCausesTransactionCommit = 565,
     ///
-    ///  Retrieves a boolean value indicating whether a data definition statement within a transaction is ignored.
+    /// Retrieves a boolean value indicating whether a data definition statement within a transaction is ignored.
     ///
-    ///  Returns:
-    ///  - false: if a data definition statement within a transaction is taken into account;
-    ///  - true: a data definition statement within a transaction is ignored.
+    /// Returns:
+    /// - false: if a data definition statement within a transaction is taken into account;
+    /// - true: a data definition statement within a transaction is ignored.
     SqlDataDefinitionsInTransactionsIgnored = 566,
     ///
-    ///  Retrieves an int32 bitmask value representing the supported result set types.
-    ///  The returned bitmask should be parsed in order to retrieve the supported result set types.
-    ///
-    ///  For instance:
-    ///  - return 0   (\b0)     => [] (no supported result set types);
-    ///  - return 1   (\b1)     => \[SQL_RESULT_SET_TYPE_UNSPECIFIED\];
-    ///  - return 2   (\b10)    => \[SQL_RESULT_SET_TYPE_FORWARD_ONLY\];
-    ///  - return 3   (\b11)    => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY];
-    ///  - return 4   (\b100)   => \[SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE\];
-    ///  - return 5   (\b101)   => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
-    ///  - return 6   (\b110)   => [SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
-    ///  - return 7   (\b111)   => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
-    ///  - return 8   (\b1000)  => \[SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE\];
-    ///  - ...
-    ///  Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetType`.
+    /// Retrieves an int32 bitmask value representing the supported result set types.
+    /// The returned bitmask should be parsed in order to retrieve the supported result set types.
+    ///
+    /// For instance:
+    /// - return 0   (\b0)     => \[\] (no supported result set types);
+    /// - return 1   (\b1)     => \[SQL_RESULT_SET_TYPE_UNSPECIFIED\];
+    /// - return 2   (\b10)    => \[SQL_RESULT_SET_TYPE_FORWARD_ONLY\];
+    /// - return 3   (\b11)    => \[SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY\];
+    /// - return 4   (\b100)   => \[SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE\];
+    /// - return 5   (\b101)   => \[SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE\];
+    /// - return 6   (\b110)   => \[SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE\];
+    /// - return 7   (\b111)   => \[SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE\];
+    /// - return 8   (\b1000)  => \[SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE\];
+    /// - ...
+    /// Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetType`.
     SqlSupportedResultSetTypes = 567,
     ///
-    ///  Returns an int32 bitmask value concurrency types supported for
-    ///  `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_UNSPECIFIED`.
-    ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
-    ///  - return 1 (\b1)   => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
-    ///  - return 2 (\b10)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
-    ///  - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-    ///  - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
-    ///  - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+    /// Returns an int32 bitmask value concurrency types supported for
+    /// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_UNSPECIFIED`.
+    ///
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (no supported concurrency types for this result set type)
+    /// - return 1 (\b1)   => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
+    /// - return 2 (\b10)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
+    /// - return 3 (\b11)  => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
+    /// - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 5 (\b101) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 6 (\b110)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 7 (\b111)  => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
     SqlSupportedConcurrenciesForResultSetUnspecified = 568,
     ///
-    ///  Returns an int32 bitmask value concurrency types supported for
-    ///  `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_FORWARD_ONLY`.
-    ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
-    ///  - return 1 (\b1)   => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
-    ///  - return 2 (\b10)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
-    ///  - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-    ///  - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
-    ///  - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+    /// Returns an int32 bitmask value concurrency types supported for
+    /// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_FORWARD_ONLY`.
+    ///
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (no supported concurrency types for this result set type)
+    /// - return 1 (\b1)   => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
+    /// - return 2 (\b10)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
+    /// - return 3 (\b11)  => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
+    /// - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 5 (\b101) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 6 (\b110)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 7 (\b111)  => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
     SqlSupportedConcurrenciesForResultSetForwardOnly = 569,
     ///
-    ///  Returns an int32 bitmask value concurrency types supported for
-    ///  `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE`.
-    ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
-    ///  - return 1 (\b1)   => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
-    ///  - return 2 (\b10)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
-    ///  - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-    ///  - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
-    ///  - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+    /// Returns an int32 bitmask value concurrency types supported for
+    /// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE`.
+    ///
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (no supported concurrency types for this result set type)
+    /// - return 1 (\b1)   => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
+    /// - return 2 (\b10)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
+    /// - return 3 (\b11)  => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
+    /// - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 5 (\b101) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 6 (\b110)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 7 (\b111)  => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
     SqlSupportedConcurrenciesForResultSetScrollSensitive = 570,
     ///
-    ///  Returns an int32 bitmask value concurrency types supported for
-    ///  `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE`.
-    ///
-    ///  For instance:
-    ///  - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
-    ///  - return 1 (\b1)   => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
-    ///  - return 2 (\b10)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
-    ///  - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-    ///  - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
-    ///  - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-    ///  Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+    /// Returns an int32 bitmask value concurrency types supported for
+    /// `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE`.
+    ///
+    /// For instance:
+    /// - return 0 (\b0)   => \[\] (no supported concurrency types for this result set type)
+    /// - return 1 (\b1)   => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED\]
+    /// - return 2 (\b10)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
+    /// - return 3 (\b11)  => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY\]
+    /// - return 4 (\b100) => \[SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 5 (\b101) => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 6 (\b110)  => \[SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// - return 7 (\b111)  => \[SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE\]
+    /// Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
     SqlSupportedConcurrenciesForResultSetScrollInsensitive = 571,
     ///
-    ///  Retrieves a boolean value indicating whether this database supports batch updates.
+    /// Retrieves a boolean value indicating whether this database supports batch updates.
     ///
-    ///  - false: if this database does not support batch updates;
-    ///  - true: if this database supports batch updates.
+    /// - false: if this database does not support batch updates;
+    /// - true: if this database supports batch updates.
     SqlBatchUpdatesSupported = 572,
     ///
-    ///  Retrieves a boolean value indicating whether this database supports savepoints.
+    /// Retrieves a boolean value indicating whether this database supports savepoints.
     ///
-    ///  Returns:
-    ///  - false: if this database does not support savepoints;
-    ///  - true: if this database supports savepoints.
+    /// Returns:
+    /// - false: if this database does not support savepoints;
+    /// - true: if this database supports savepoints.
     SqlSavepointsSupported = 573,
     ///
-    ///  Retrieves a boolean value indicating whether named parameters are supported in callable statements.
+    /// Retrieves a boolean value indicating whether named parameters are supported in callable statements.
     ///
-    ///  Returns:
-    ///  - false: if named parameters in callable statements are unsupported;
-    ///  - true: if named parameters in callable statements are supported.
+    /// Returns:
+    /// - false: if named parameters in callable statements are unsupported;
+    /// - true: if named parameters in callable statements are supported.
     SqlNamedParametersSupported = 574,
     ///
-    ///  Retrieves a boolean value indicating whether updates made to a LOB are made on a copy or directly to the LOB.
+    /// Retrieves a boolean value indicating whether updates made to a LOB are made on a copy or directly to the LOB.
     ///
-    ///  Returns:
-    ///  - false: if updates made to a LOB are made directly to the LOB;
-    ///  - true: if updates made to a LOB are made on a copy.
+    /// Returns:
+    /// - false: if updates made to a LOB are made directly to the LOB;
+    /// - true: if updates made to a LOB are made on a copy.
     SqlLocatorsUpdateCopy = 575,
     ///
-    ///  Retrieves a boolean value indicating whether invoking user-defined or vendor functions
-    ///  using the stored procedure escape syntax is supported.
+    /// Retrieves a boolean value indicating whether invoking user-defined or vendor functions
+    /// using the stored procedure escape syntax is supported.
     ///
-    ///  Returns:
-    ///  - false: if invoking user-defined or vendor functions using the stored procedure escape syntax is unsupported;
-    ///  - true: if invoking user-defined or vendor functions using the stored procedure escape syntax is supported.
+    /// Returns:
+    /// - false: if invoking user-defined or vendor functions using the stored procedure escape syntax is unsupported;
+    /// - true: if invoking user-defined or vendor functions using the stored procedure escape syntax is supported.
     SqlStoredFunctionsUsingCallSyntaxSupported = 576,
 }
 impl SqlInfo {
@@ -1014,6 +1512,22 @@ impl SqlInfo {
             SqlInfo::FlightSqlServerVersion => "FLIGHT_SQL_SERVER_VERSION",
             SqlInfo::FlightSqlServerArrowVersion => "FLIGHT_SQL_SERVER_ARROW_VERSION",
             SqlInfo::FlightSqlServerReadOnly => "FLIGHT_SQL_SERVER_READ_ONLY",
+            SqlInfo::FlightSqlServerSql => "FLIGHT_SQL_SERVER_SQL",
+            SqlInfo::FlightSqlServerSubstrait => "FLIGHT_SQL_SERVER_SUBSTRAIT",
+            SqlInfo::FlightSqlServerSubstraitMinVersion => {
+                "FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION"
+            }
+            SqlInfo::FlightSqlServerSubstraitMaxVersion => {
+                "FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION"
+            }
+            SqlInfo::FlightSqlServerTransaction => "FLIGHT_SQL_SERVER_TRANSACTION",
+            SqlInfo::FlightSqlServerCancel => "FLIGHT_SQL_SERVER_CANCEL",
+            SqlInfo::FlightSqlServerStatementTimeout => {
+                "FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT"
+            }
+            SqlInfo::FlightSqlServerTransactionTimeout => {
+                "FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT"
+            }
             SqlInfo::SqlDdlCatalog => "SQL_DDL_CATALOG",
             SqlInfo::SqlDdlSchema => "SQL_DDL_SCHEMA",
             SqlInfo::SqlDdlTable => "SQL_DDL_TABLE",
@@ -1032,16 +1546,24 @@ impl SqlInfo {
             SqlInfo::SqlSupportsColumnAliasing => "SQL_SUPPORTS_COLUMN_ALIASING",
             SqlInfo::SqlNullPlusNullIsNull => "SQL_NULL_PLUS_NULL_IS_NULL",
             SqlInfo::SqlSupportsConvert => "SQL_SUPPORTS_CONVERT",
-            SqlInfo::SqlSupportsTableCorrelationNames => "SQL_SUPPORTS_TABLE_CORRELATION_NAMES",
-            SqlInfo::SqlSupportsDifferentTableCorrelationNames => "SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES",
-            SqlInfo::SqlSupportsExpressionsInOrderBy => "SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY",
+            SqlInfo::SqlSupportsTableCorrelationNames => {
+                "SQL_SUPPORTS_TABLE_CORRELATION_NAMES"
+            }
+            SqlInfo::SqlSupportsDifferentTableCorrelationNames => {
+                "SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES"
+            }
+            SqlInfo::SqlSupportsExpressionsInOrderBy => {
+                "SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY"
+            }
             SqlInfo::SqlSupportsOrderByUnrelated => "SQL_SUPPORTS_ORDER_BY_UNRELATED",
             SqlInfo::SqlSupportedGroupBy => "SQL_SUPPORTED_GROUP_BY",
             SqlInfo::SqlSupportsLikeEscapeClause => "SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE",
             SqlInfo::SqlSupportsNonNullableColumns => "SQL_SUPPORTS_NON_NULLABLE_COLUMNS",
             SqlInfo::SqlSupportedGrammar => "SQL_SUPPORTED_GRAMMAR",
             SqlInfo::SqlAnsi92SupportedLevel => "SQL_ANSI92_SUPPORTED_LEVEL",
-            SqlInfo::SqlSupportsIntegrityEnhancementFacility => "SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY",
+            SqlInfo::SqlSupportsIntegrityEnhancementFacility => {
+                "SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY"
+            }
             SqlInfo::SqlOuterJoinsSupportLevel => "SQL_OUTER_JOINS_SUPPORT_LEVEL",
             SqlInfo::SqlSchemaTerm => "SQL_SCHEMA_TERM",
             SqlInfo::SqlProcedureTerm => "SQL_PROCEDURE_TERM",
@@ -1049,11 +1571,15 @@ impl SqlInfo {
             SqlInfo::SqlCatalogAtStart => "SQL_CATALOG_AT_START",
             SqlInfo::SqlSchemasSupportedActions => "SQL_SCHEMAS_SUPPORTED_ACTIONS",
             SqlInfo::SqlCatalogsSupportedActions => "SQL_CATALOGS_SUPPORTED_ACTIONS",
-            SqlInfo::SqlSupportedPositionedCommands => "SQL_SUPPORTED_POSITIONED_COMMANDS",
+            SqlInfo::SqlSupportedPositionedCommands => {
+                "SQL_SUPPORTED_POSITIONED_COMMANDS"
+            }
             SqlInfo::SqlSelectForUpdateSupported => "SQL_SELECT_FOR_UPDATE_SUPPORTED",
             SqlInfo::SqlStoredProceduresSupported => "SQL_STORED_PROCEDURES_SUPPORTED",
             SqlInfo::SqlSupportedSubqueries => "SQL_SUPPORTED_SUBQUERIES",
-            SqlInfo::SqlCorrelatedSubqueriesSupported => "SQL_CORRELATED_SUBQUERIES_SUPPORTED",
+            SqlInfo::SqlCorrelatedSubqueriesSupported => {
+                "SQL_CORRELATED_SUBQUERIES_SUPPORTED"
+            }
             SqlInfo::SqlSupportedUnions => "SQL_SUPPORTED_UNIONS",
             SqlInfo::SqlMaxBinaryLiteralLength => "SQL_MAX_BINARY_LITERAL_LENGTH",
             SqlInfo::SqlMaxCharLiteralLength => "SQL_MAX_CHAR_LITERAL_LENGTH",
@@ -1076,21 +1602,211 @@ impl SqlInfo {
             SqlInfo::SqlMaxTableNameLength => "SQL_MAX_TABLE_NAME_LENGTH",
             SqlInfo::SqlMaxTablesInSelect => "SQL_MAX_TABLES_IN_SELECT",
             SqlInfo::SqlMaxUsernameLength => "SQL_MAX_USERNAME_LENGTH",
-            SqlInfo::SqlDefaultTransactionIsolation => "SQL_DEFAULT_TRANSACTION_ISOLATION",
+            SqlInfo::SqlDefaultTransactionIsolation => {
+                "SQL_DEFAULT_TRANSACTION_ISOLATION"
+            }
             SqlInfo::SqlTransactionsSupported => "SQL_TRANSACTIONS_SUPPORTED",
-            SqlInfo::SqlSupportedTransactionsIsolationLevels => "SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS",
-            SqlInfo::SqlDataDefinitionCausesTransactionCommit => "SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT",
-            SqlInfo::SqlDataDefinitionsInTransactionsIgnored => "SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED",
+            SqlInfo::SqlSupportedTransactionsIsolationLevels => {
+                "SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS"
+            }
+            SqlInfo::SqlDataDefinitionCausesTransactionCommit => {
+                "SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT"
+            }
+            SqlInfo::SqlDataDefinitionsInTransactionsIgnored => {
+                "SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED"
+            }
             SqlInfo::SqlSupportedResultSetTypes => "SQL_SUPPORTED_RESULT_SET_TYPES",
-            SqlInfo::SqlSupportedConcurrenciesForResultSetUnspecified => "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED",
-            SqlInfo::SqlSupportedConcurrenciesForResultSetForwardOnly => "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY",
-            SqlInfo::SqlSupportedConcurrenciesForResultSetScrollSensitive => "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE",
-            SqlInfo::SqlSupportedConcurrenciesForResultSetScrollInsensitive => "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE",
+            SqlInfo::SqlSupportedConcurrenciesForResultSetUnspecified => {
+                "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED"
+            }
+            SqlInfo::SqlSupportedConcurrenciesForResultSetForwardOnly => {
+                "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY"
+            }
+            SqlInfo::SqlSupportedConcurrenciesForResultSetScrollSensitive => {
+                "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE"
+            }
+            SqlInfo::SqlSupportedConcurrenciesForResultSetScrollInsensitive => {
+                "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE"
+            }
             SqlInfo::SqlBatchUpdatesSupported => "SQL_BATCH_UPDATES_SUPPORTED",
             SqlInfo::SqlSavepointsSupported => "SQL_SAVEPOINTS_SUPPORTED",
             SqlInfo::SqlNamedParametersSupported => "SQL_NAMED_PARAMETERS_SUPPORTED",
             SqlInfo::SqlLocatorsUpdateCopy => "SQL_LOCATORS_UPDATE_COPY",
-            SqlInfo::SqlStoredFunctionsUsingCallSyntaxSupported => "SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED",
+            SqlInfo::SqlStoredFunctionsUsingCallSyntaxSupported => {
+                "SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED"
+            }
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "FLIGHT_SQL_SERVER_NAME" => Some(Self::FlightSqlServerName),
+            "FLIGHT_SQL_SERVER_VERSION" => Some(Self::FlightSqlServerVersion),
+            "FLIGHT_SQL_SERVER_ARROW_VERSION" => Some(Self::FlightSqlServerArrowVersion),
+            "FLIGHT_SQL_SERVER_READ_ONLY" => Some(Self::FlightSqlServerReadOnly),
+            "FLIGHT_SQL_SERVER_SQL" => Some(Self::FlightSqlServerSql),
+            "FLIGHT_SQL_SERVER_SUBSTRAIT" => Some(Self::FlightSqlServerSubstrait),
+            "FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION" => {
+                Some(Self::FlightSqlServerSubstraitMinVersion)
+            }
+            "FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION" => {
+                Some(Self::FlightSqlServerSubstraitMaxVersion)
+            }
+            "FLIGHT_SQL_SERVER_TRANSACTION" => Some(Self::FlightSqlServerTransaction),
+            "FLIGHT_SQL_SERVER_CANCEL" => Some(Self::FlightSqlServerCancel),
+            "FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT" => {
+                Some(Self::FlightSqlServerStatementTimeout)
+            }
+            "FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT" => {
+                Some(Self::FlightSqlServerTransactionTimeout)
+            }
+            "SQL_DDL_CATALOG" => Some(Self::SqlDdlCatalog),
+            "SQL_DDL_SCHEMA" => Some(Self::SqlDdlSchema),
+            "SQL_DDL_TABLE" => Some(Self::SqlDdlTable),
+            "SQL_IDENTIFIER_CASE" => Some(Self::SqlIdentifierCase),
+            "SQL_IDENTIFIER_QUOTE_CHAR" => Some(Self::SqlIdentifierQuoteChar),
+            "SQL_QUOTED_IDENTIFIER_CASE" => Some(Self::SqlQuotedIdentifierCase),
+            "SQL_ALL_TABLES_ARE_SELECTABLE" => Some(Self::SqlAllTablesAreSelectable),
+            "SQL_NULL_ORDERING" => Some(Self::SqlNullOrdering),
+            "SQL_KEYWORDS" => Some(Self::SqlKeywords),
+            "SQL_NUMERIC_FUNCTIONS" => Some(Self::SqlNumericFunctions),
+            "SQL_STRING_FUNCTIONS" => Some(Self::SqlStringFunctions),
+            "SQL_SYSTEM_FUNCTIONS" => Some(Self::SqlSystemFunctions),
+            "SQL_DATETIME_FUNCTIONS" => Some(Self::SqlDatetimeFunctions),
+            "SQL_SEARCH_STRING_ESCAPE" => Some(Self::SqlSearchStringEscape),
+            "SQL_EXTRA_NAME_CHARACTERS" => Some(Self::SqlExtraNameCharacters),
+            "SQL_SUPPORTS_COLUMN_ALIASING" => Some(Self::SqlSupportsColumnAliasing),
+            "SQL_NULL_PLUS_NULL_IS_NULL" => Some(Self::SqlNullPlusNullIsNull),
+            "SQL_SUPPORTS_CONVERT" => Some(Self::SqlSupportsConvert),
+            "SQL_SUPPORTS_TABLE_CORRELATION_NAMES" => {
+                Some(Self::SqlSupportsTableCorrelationNames)
+            }
+            "SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES" => {
+                Some(Self::SqlSupportsDifferentTableCorrelationNames)
+            }
+            "SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY" => {
+                Some(Self::SqlSupportsExpressionsInOrderBy)
+            }
+            "SQL_SUPPORTS_ORDER_BY_UNRELATED" => Some(Self::SqlSupportsOrderByUnrelated),
+            "SQL_SUPPORTED_GROUP_BY" => Some(Self::SqlSupportedGroupBy),
+            "SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE" => Some(Self::SqlSupportsLikeEscapeClause),
+            "SQL_SUPPORTS_NON_NULLABLE_COLUMNS" => {
+                Some(Self::SqlSupportsNonNullableColumns)
+            }
+            "SQL_SUPPORTED_GRAMMAR" => Some(Self::SqlSupportedGrammar),
+            "SQL_ANSI92_SUPPORTED_LEVEL" => Some(Self::SqlAnsi92SupportedLevel),
+            "SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY" => {
+                Some(Self::SqlSupportsIntegrityEnhancementFacility)
+            }
+            "SQL_OUTER_JOINS_SUPPORT_LEVEL" => Some(Self::SqlOuterJoinsSupportLevel),
+            "SQL_SCHEMA_TERM" => Some(Self::SqlSchemaTerm),
+            "SQL_PROCEDURE_TERM" => Some(Self::SqlProcedureTerm),
+            "SQL_CATALOG_TERM" => Some(Self::SqlCatalogTerm),
+            "SQL_CATALOG_AT_START" => Some(Self::SqlCatalogAtStart),
+            "SQL_SCHEMAS_SUPPORTED_ACTIONS" => Some(Self::SqlSchemasSupportedActions),
+            "SQL_CATALOGS_SUPPORTED_ACTIONS" => Some(Self::SqlCatalogsSupportedActions),
+            "SQL_SUPPORTED_POSITIONED_COMMANDS" => {
+                Some(Self::SqlSupportedPositionedCommands)
+            }
+            "SQL_SELECT_FOR_UPDATE_SUPPORTED" => Some(Self::SqlSelectForUpdateSupported),
+            "SQL_STORED_PROCEDURES_SUPPORTED" => Some(Self::SqlStoredProceduresSupported),
+            "SQL_SUPPORTED_SUBQUERIES" => Some(Self::SqlSupportedSubqueries),
+            "SQL_CORRELATED_SUBQUERIES_SUPPORTED" => {
+                Some(Self::SqlCorrelatedSubqueriesSupported)
+            }
+            "SQL_SUPPORTED_UNIONS" => Some(Self::SqlSupportedUnions),
+            "SQL_MAX_BINARY_LITERAL_LENGTH" => Some(Self::SqlMaxBinaryLiteralLength),
+            "SQL_MAX_CHAR_LITERAL_LENGTH" => Some(Self::SqlMaxCharLiteralLength),
+            "SQL_MAX_COLUMN_NAME_LENGTH" => Some(Self::SqlMaxColumnNameLength),
+            "SQL_MAX_COLUMNS_IN_GROUP_BY" => Some(Self::SqlMaxColumnsInGroupBy),
+            "SQL_MAX_COLUMNS_IN_INDEX" => Some(Self::SqlMaxColumnsInIndex),
+            "SQL_MAX_COLUMNS_IN_ORDER_BY" => Some(Self::SqlMaxColumnsInOrderBy),
+            "SQL_MAX_COLUMNS_IN_SELECT" => Some(Self::SqlMaxColumnsInSelect),
+            "SQL_MAX_COLUMNS_IN_TABLE" => Some(Self::SqlMaxColumnsInTable),
+            "SQL_MAX_CONNECTIONS" => Some(Self::SqlMaxConnections),
+            "SQL_MAX_CURSOR_NAME_LENGTH" => Some(Self::SqlMaxCursorNameLength),
+            "SQL_MAX_INDEX_LENGTH" => Some(Self::SqlMaxIndexLength),
+            "SQL_DB_SCHEMA_NAME_LENGTH" => Some(Self::SqlDbSchemaNameLength),
+            "SQL_MAX_PROCEDURE_NAME_LENGTH" => Some(Self::SqlMaxProcedureNameLength),
+            "SQL_MAX_CATALOG_NAME_LENGTH" => Some(Self::SqlMaxCatalogNameLength),
+            "SQL_MAX_ROW_SIZE" => Some(Self::SqlMaxRowSize),
+            "SQL_MAX_ROW_SIZE_INCLUDES_BLOBS" => Some(Self::SqlMaxRowSizeIncludesBlobs),
+            "SQL_MAX_STATEMENT_LENGTH" => Some(Self::SqlMaxStatementLength),
+            "SQL_MAX_STATEMENTS" => Some(Self::SqlMaxStatements),
+            "SQL_MAX_TABLE_NAME_LENGTH" => Some(Self::SqlMaxTableNameLength),
+            "SQL_MAX_TABLES_IN_SELECT" => Some(Self::SqlMaxTablesInSelect),
+            "SQL_MAX_USERNAME_LENGTH" => Some(Self::SqlMaxUsernameLength),
+            "SQL_DEFAULT_TRANSACTION_ISOLATION" => {
+                Some(Self::SqlDefaultTransactionIsolation)
+            }
+            "SQL_TRANSACTIONS_SUPPORTED" => Some(Self::SqlTransactionsSupported),
+            "SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS" => {
+                Some(Self::SqlSupportedTransactionsIsolationLevels)
+            }
+            "SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT" => {
+                Some(Self::SqlDataDefinitionCausesTransactionCommit)
+            }
+            "SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED" => {
+                Some(Self::SqlDataDefinitionsInTransactionsIgnored)
+            }
+            "SQL_SUPPORTED_RESULT_SET_TYPES" => Some(Self::SqlSupportedResultSetTypes),
+            "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED" => {
+                Some(Self::SqlSupportedConcurrenciesForResultSetUnspecified)
+            }
+            "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY" => {
+                Some(Self::SqlSupportedConcurrenciesForResultSetForwardOnly)
+            }
+            "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE" => {
+                Some(Self::SqlSupportedConcurrenciesForResultSetScrollSensitive)
+            }
+            "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE" => {
+                Some(Self::SqlSupportedConcurrenciesForResultSetScrollInsensitive)
+            }
+            "SQL_BATCH_UPDATES_SUPPORTED" => Some(Self::SqlBatchUpdatesSupported),
+            "SQL_SAVEPOINTS_SUPPORTED" => Some(Self::SqlSavepointsSupported),
+            "SQL_NAMED_PARAMETERS_SUPPORTED" => Some(Self::SqlNamedParametersSupported),
+            "SQL_LOCATORS_UPDATE_COPY" => Some(Self::SqlLocatorsUpdateCopy),
+            "SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED" => {
+                Some(Self::SqlStoredFunctionsUsingCallSyntaxSupported)
+            }
+            _ => None,
+        }
+    }
+}
+/// The level of support for Flight SQL transaction RPCs.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum SqlSupportedTransaction {
+    /// Unknown/not indicated/no support
+    None = 0,
+    /// Transactions, but not savepoints.
+    /// A savepoint is a mark within a transaction that can be individually
+    /// rolled back to. Not all databases support savepoints.
+    Transaction = 1,
+    /// Transactions and savepoints
+    Savepoint = 2,
+}
+impl SqlSupportedTransaction {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            SqlSupportedTransaction::None => "SQL_SUPPORTED_TRANSACTION_NONE",
+            SqlSupportedTransaction::Transaction => {
+                "SQL_SUPPORTED_TRANSACTION_TRANSACTION"
+            }
+            SqlSupportedTransaction::Savepoint => "SQL_SUPPORTED_TRANSACTION_SAVEPOINT",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_SUPPORTED_TRANSACTION_NONE" => Some(Self::None),
+            "SQL_SUPPORTED_TRANSACTION_TRANSACTION" => Some(Self::Transaction),
+            "SQL_SUPPORTED_TRANSACTION_SAVEPOINT" => Some(Self::Savepoint),
+            _ => None,
         }
     }
 }
@@ -1109,10 +1825,30 @@ impl SqlSupportedCaseSensitivity {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedCaseSensitivity::SqlCaseSensitivityUnknown => "SQL_CASE_SENSITIVITY_UNKNOWN",
-            SqlSupportedCaseSensitivity::SqlCaseSensitivityCaseInsensitive => "SQL_CASE_SENSITIVITY_CASE_INSENSITIVE",
-            SqlSupportedCaseSensitivity::SqlCaseSensitivityUppercase => "SQL_CASE_SENSITIVITY_UPPERCASE",
-            SqlSupportedCaseSensitivity::SqlCaseSensitivityLowercase => "SQL_CASE_SENSITIVITY_LOWERCASE",
+            SqlSupportedCaseSensitivity::SqlCaseSensitivityUnknown => {
+                "SQL_CASE_SENSITIVITY_UNKNOWN"
+            }
+            SqlSupportedCaseSensitivity::SqlCaseSensitivityCaseInsensitive => {
+                "SQL_CASE_SENSITIVITY_CASE_INSENSITIVE"
+            }
+            SqlSupportedCaseSensitivity::SqlCaseSensitivityUppercase => {
+                "SQL_CASE_SENSITIVITY_UPPERCASE"
+            }
+            SqlSupportedCaseSensitivity::SqlCaseSensitivityLowercase => {
+                "SQL_CASE_SENSITIVITY_LOWERCASE"
+            }
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_CASE_SENSITIVITY_UNKNOWN" => Some(Self::SqlCaseSensitivityUnknown),
+            "SQL_CASE_SENSITIVITY_CASE_INSENSITIVE" => {
+                Some(Self::SqlCaseSensitivityCaseInsensitive)
+            }
+            "SQL_CASE_SENSITIVITY_UPPERCASE" => Some(Self::SqlCaseSensitivityUppercase),
+            "SQL_CASE_SENSITIVITY_LOWERCASE" => Some(Self::SqlCaseSensitivityLowercase),
+            _ => None,
         }
     }
 }
@@ -1137,6 +1873,16 @@ impl SqlNullOrdering {
             SqlNullOrdering::SqlNullsSortedAtEnd => "SQL_NULLS_SORTED_AT_END",
         }
     }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_NULLS_SORTED_HIGH" => Some(Self::SqlNullsSortedHigh),
+            "SQL_NULLS_SORTED_LOW" => Some(Self::SqlNullsSortedLow),
+            "SQL_NULLS_SORTED_AT_START" => Some(Self::SqlNullsSortedAtStart),
+            "SQL_NULLS_SORTED_AT_END" => Some(Self::SqlNullsSortedAtEnd),
+            _ => None,
+        }
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
@@ -1157,6 +1903,15 @@ impl SupportedSqlGrammar {
             SupportedSqlGrammar::SqlExtendedGrammar => "SQL_EXTENDED_GRAMMAR",
         }
     }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_MINIMUM_GRAMMAR" => Some(Self::SqlMinimumGrammar),
+            "SQL_CORE_GRAMMAR" => Some(Self::SqlCoreGrammar),
+            "SQL_EXTENDED_GRAMMAR" => Some(Self::SqlExtendedGrammar),
+            _ => None,
+        }
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
@@ -1173,10 +1928,21 @@ impl SupportedAnsi92SqlGrammarLevel {
     pub fn as_str_name(&self) -> &'static str {
         match self {
             SupportedAnsi92SqlGrammarLevel::Ansi92EntrySql => "ANSI92_ENTRY_SQL",
-            SupportedAnsi92SqlGrammarLevel::Ansi92IntermediateSql => "ANSI92_INTERMEDIATE_SQL",
+            SupportedAnsi92SqlGrammarLevel::Ansi92IntermediateSql => {
+                "ANSI92_INTERMEDIATE_SQL"
+            }
             SupportedAnsi92SqlGrammarLevel::Ansi92FullSql => "ANSI92_FULL_SQL",
         }
     }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "ANSI92_ENTRY_SQL" => Some(Self::Ansi92EntrySql),
+            "ANSI92_INTERMEDIATE_SQL" => Some(Self::Ansi92IntermediateSql),
+            "ANSI92_FULL_SQL" => Some(Self::Ansi92FullSql),
+            _ => None,
+        }
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
@@ -1197,6 +1963,15 @@ impl SqlOuterJoinsSupportLevel {
             SqlOuterJoinsSupportLevel::SqlFullOuterJoins => "SQL_FULL_OUTER_JOINS",
         }
     }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_JOINS_UNSUPPORTED" => Some(Self::SqlJoinsUnsupported),
+            "SQL_LIMITED_OUTER_JOINS" => Some(Self::SqlLimitedOuterJoins),
+            "SQL_FULL_OUTER_JOINS" => Some(Self::SqlFullOuterJoins),
+            _ => None,
+        }
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
@@ -1215,6 +1990,14 @@ impl SqlSupportedGroupBy {
             SqlSupportedGroupBy::SqlGroupByBeyondSelect => "SQL_GROUP_BY_BEYOND_SELECT",
         }
     }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_GROUP_BY_UNRELATED" => Some(Self::SqlGroupByUnrelated),
+            "SQL_GROUP_BY_BEYOND_SELECT" => Some(Self::SqlGroupByBeyondSelect),
+            _ => None,
+        }
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
@@ -1230,9 +2013,28 @@ impl SqlSupportedElementActions {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedElementActions::SqlElementInProcedureCalls => "SQL_ELEMENT_IN_PROCEDURE_CALLS",
-            SqlSupportedElementActions::SqlElementInIndexDefinitions => "SQL_ELEMENT_IN_INDEX_DEFINITIONS",
-            SqlSupportedElementActions::SqlElementInPrivilegeDefinitions => "SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS",
+            SqlSupportedElementActions::SqlElementInProcedureCalls => {
+                "SQL_ELEMENT_IN_PROCEDURE_CALLS"
+            }
+            SqlSupportedElementActions::SqlElementInIndexDefinitions => {
+                "SQL_ELEMENT_IN_INDEX_DEFINITIONS"
+            }
+            SqlSupportedElementActions::SqlElementInPrivilegeDefinitions => {
+                "SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS"
+            }
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_ELEMENT_IN_PROCEDURE_CALLS" => Some(Self::SqlElementInProcedureCalls),
+            "SQL_ELEMENT_IN_INDEX_DEFINITIONS" => {
+                Some(Self::SqlElementInIndexDefinitions)
+            }
+            "SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS" => {
+                Some(Self::SqlElementInPrivilegeDefinitions)
+            }
+            _ => None,
         }
     }
 }
@@ -1249,8 +2051,20 @@ impl SqlSupportedPositionedCommands {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedPositionedCommands::SqlPositionedDelete => "SQL_POSITIONED_DELETE",
-            SqlSupportedPositionedCommands::SqlPositionedUpdate => "SQL_POSITIONED_UPDATE",
+            SqlSupportedPositionedCommands::SqlPositionedDelete => {
+                "SQL_POSITIONED_DELETE"
+            }
+            SqlSupportedPositionedCommands::SqlPositionedUpdate => {
+                "SQL_POSITIONED_UPDATE"
+            }
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_POSITIONED_DELETE" => Some(Self::SqlPositionedDelete),
+            "SQL_POSITIONED_UPDATE" => Some(Self::SqlPositionedUpdate),
+            _ => None,
         }
     }
 }
@@ -1269,10 +2083,24 @@ impl SqlSupportedSubqueries {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedSubqueries::SqlSubqueriesInComparisons => "SQL_SUBQUERIES_IN_COMPARISONS",
+            SqlSupportedSubqueries::SqlSubqueriesInComparisons => {
+                "SQL_SUBQUERIES_IN_COMPARISONS"
+            }
             SqlSupportedSubqueries::SqlSubqueriesInExists => "SQL_SUBQUERIES_IN_EXISTS",
             SqlSupportedSubqueries::SqlSubqueriesInIns => "SQL_SUBQUERIES_IN_INS",
-            SqlSupportedSubqueries::SqlSubqueriesInQuantifieds => "SQL_SUBQUERIES_IN_QUANTIFIEDS",
+            SqlSupportedSubqueries::SqlSubqueriesInQuantifieds => {
+                "SQL_SUBQUERIES_IN_QUANTIFIEDS"
+            }
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_SUBQUERIES_IN_COMPARISONS" => Some(Self::SqlSubqueriesInComparisons),
+            "SQL_SUBQUERIES_IN_EXISTS" => Some(Self::SqlSubqueriesInExists),
+            "SQL_SUBQUERIES_IN_INS" => Some(Self::SqlSubqueriesInIns),
+            "SQL_SUBQUERIES_IN_QUANTIFIEDS" => Some(Self::SqlSubqueriesInQuantifieds),
+            _ => None,
         }
     }
 }
@@ -1293,6 +2121,14 @@ impl SqlSupportedUnions {
             SqlSupportedUnions::SqlUnionAll => "SQL_UNION_ALL",
         }
     }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_UNION" => Some(Self::SqlUnion),
+            "SQL_UNION_ALL" => Some(Self::SqlUnionAll),
+            _ => None,
+        }
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
@@ -1311,10 +2147,31 @@ impl SqlTransactionIsolationLevel {
     pub fn as_str_name(&self) -> &'static str {
         match self {
             SqlTransactionIsolationLevel::SqlTransactionNone => "SQL_TRANSACTION_NONE",
-            SqlTransactionIsolationLevel::SqlTransactionReadUncommitted => "SQL_TRANSACTION_READ_UNCOMMITTED",
-            SqlTransactionIsolationLevel::SqlTransactionReadCommitted => "SQL_TRANSACTION_READ_COMMITTED",
-            SqlTransactionIsolationLevel::SqlTransactionRepeatableRead => "SQL_TRANSACTION_REPEATABLE_READ",
-            SqlTransactionIsolationLevel::SqlTransactionSerializable => "SQL_TRANSACTION_SERIALIZABLE",
+            SqlTransactionIsolationLevel::SqlTransactionReadUncommitted => {
+                "SQL_TRANSACTION_READ_UNCOMMITTED"
+            }
+            SqlTransactionIsolationLevel::SqlTransactionReadCommitted => {
+                "SQL_TRANSACTION_READ_COMMITTED"
+            }
+            SqlTransactionIsolationLevel::SqlTransactionRepeatableRead => {
+                "SQL_TRANSACTION_REPEATABLE_READ"
+            }
+            SqlTransactionIsolationLevel::SqlTransactionSerializable => {
+                "SQL_TRANSACTION_SERIALIZABLE"
+            }
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_TRANSACTION_NONE" => Some(Self::SqlTransactionNone),
+            "SQL_TRANSACTION_READ_UNCOMMITTED" => {
+                Some(Self::SqlTransactionReadUncommitted)
+            }
+            "SQL_TRANSACTION_READ_COMMITTED" => Some(Self::SqlTransactionReadCommitted),
+            "SQL_TRANSACTION_REPEATABLE_READ" => Some(Self::SqlTransactionRepeatableRead),
+            "SQL_TRANSACTION_SERIALIZABLE" => Some(Self::SqlTransactionSerializable),
+            _ => None,
         }
     }
 }
@@ -1332,9 +2189,28 @@ impl SqlSupportedTransactions {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedTransactions::SqlTransactionUnspecified => "SQL_TRANSACTION_UNSPECIFIED",
-            SqlSupportedTransactions::SqlDataDefinitionTransactions => "SQL_DATA_DEFINITION_TRANSACTIONS",
-            SqlSupportedTransactions::SqlDataManipulationTransactions => "SQL_DATA_MANIPULATION_TRANSACTIONS",
+            SqlSupportedTransactions::SqlTransactionUnspecified => {
+                "SQL_TRANSACTION_UNSPECIFIED"
+            }
+            SqlSupportedTransactions::SqlDataDefinitionTransactions => {
+                "SQL_DATA_DEFINITION_TRANSACTIONS"
+            }
+            SqlSupportedTransactions::SqlDataManipulationTransactions => {
+                "SQL_DATA_MANIPULATION_TRANSACTIONS"
+            }
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_TRANSACTION_UNSPECIFIED" => Some(Self::SqlTransactionUnspecified),
+            "SQL_DATA_DEFINITION_TRANSACTIONS" => {
+                Some(Self::SqlDataDefinitionTransactions)
+            }
+            "SQL_DATA_MANIPULATION_TRANSACTIONS" => {
+                Some(Self::SqlDataManipulationTransactions)
+            }
+            _ => None,
         }
     }
 }
@@ -1353,10 +2229,32 @@ impl SqlSupportedResultSetType {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedResultSetType::SqlResultSetTypeUnspecified => "SQL_RESULT_SET_TYPE_UNSPECIFIED",
-            SqlSupportedResultSetType::SqlResultSetTypeForwardOnly => "SQL_RESULT_SET_TYPE_FORWARD_ONLY",
-            SqlSupportedResultSetType::SqlResultSetTypeScrollInsensitive => "SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE",
-            SqlSupportedResultSetType::SqlResultSetTypeScrollSensitive => "SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE",
+            SqlSupportedResultSetType::SqlResultSetTypeUnspecified => {
+                "SQL_RESULT_SET_TYPE_UNSPECIFIED"
+            }
+            SqlSupportedResultSetType::SqlResultSetTypeForwardOnly => {
+                "SQL_RESULT_SET_TYPE_FORWARD_ONLY"
+            }
+            SqlSupportedResultSetType::SqlResultSetTypeScrollInsensitive => {
+                "SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE"
+            }
+            SqlSupportedResultSetType::SqlResultSetTypeScrollSensitive => {
+                "SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE"
+            }
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_RESULT_SET_TYPE_UNSPECIFIED" => Some(Self::SqlResultSetTypeUnspecified),
+            "SQL_RESULT_SET_TYPE_FORWARD_ONLY" => Some(Self::SqlResultSetTypeForwardOnly),
+            "SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE" => {
+                Some(Self::SqlResultSetTypeScrollInsensitive)
+            }
+            "SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE" => {
+                Some(Self::SqlResultSetTypeScrollSensitive)
+            }
+            _ => None,
         }
     }
 }
@@ -1374,9 +2272,30 @@ impl SqlSupportedResultSetConcurrency {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyUnspecified => "SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED",
-            SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyReadOnly => "SQL_RESULT_SET_CONCURRENCY_READ_ONLY",
-            SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyUpdatable => "SQL_RESULT_SET_CONCURRENCY_UPDATABLE",
+            SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyUnspecified => {
+                "SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED"
+            }
+            SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyReadOnly => {
+                "SQL_RESULT_SET_CONCURRENCY_READ_ONLY"
+            }
+            SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyUpdatable => {
+                "SQL_RESULT_SET_CONCURRENCY_UPDATABLE"
+            }
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED" => {
+                Some(Self::SqlResultSetConcurrencyUnspecified)
+            }
+            "SQL_RESULT_SET_CONCURRENCY_READ_ONLY" => {
+                Some(Self::SqlResultSetConcurrencyReadOnly)
+            }
+            "SQL_RESULT_SET_CONCURRENCY_UPDATABLE" => {
+                Some(Self::SqlResultSetConcurrencyUpdatable)
+            }
+            _ => None,
         }
     }
 }
@@ -1419,8 +2338,12 @@ impl SqlSupportsConvert {
             SqlSupportsConvert::SqlConvertDecimal => "SQL_CONVERT_DECIMAL",
             SqlSupportsConvert::SqlConvertFloat => "SQL_CONVERT_FLOAT",
             SqlSupportsConvert::SqlConvertInteger => "SQL_CONVERT_INTEGER",
-            SqlSupportsConvert::SqlConvertIntervalDayTime => "SQL_CONVERT_INTERVAL_DAY_TIME",
-            SqlSupportsConvert::SqlConvertIntervalYearMonth => "SQL_CONVERT_INTERVAL_YEAR_MONTH",
+            SqlSupportsConvert::SqlConvertIntervalDayTime => {
+                "SQL_CONVERT_INTERVAL_DAY_TIME"
+            }
+            SqlSupportsConvert::SqlConvertIntervalYearMonth => {
+                "SQL_CONVERT_INTERVAL_YEAR_MONTH"
+            }
             SqlSupportsConvert::SqlConvertLongvarbinary => "SQL_CONVERT_LONGVARBINARY",
             SqlSupportsConvert::SqlConvertLongvarchar => "SQL_CONVERT_LONGVARCHAR",
             SqlSupportsConvert::SqlConvertNumeric => "SQL_CONVERT_NUMERIC",
@@ -1433,6 +2356,352 @@ impl SqlSupportsConvert {
             SqlSupportsConvert::SqlConvertVarchar => "SQL_CONVERT_VARCHAR",
         }
     }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SQL_CONVERT_BIGINT" => Some(Self::SqlConvertBigint),
+            "SQL_CONVERT_BINARY" => Some(Self::SqlConvertBinary),
+            "SQL_CONVERT_BIT" => Some(Self::SqlConvertBit),
+            "SQL_CONVERT_CHAR" => Some(Self::SqlConvertChar),
+            "SQL_CONVERT_DATE" => Some(Self::SqlConvertDate),
+            "SQL_CONVERT_DECIMAL" => Some(Self::SqlConvertDecimal),
+            "SQL_CONVERT_FLOAT" => Some(Self::SqlConvertFloat),
+            "SQL_CONVERT_INTEGER" => Some(Self::SqlConvertInteger),
+            "SQL_CONVERT_INTERVAL_DAY_TIME" => Some(Self::SqlConvertIntervalDayTime),
+            "SQL_CONVERT_INTERVAL_YEAR_MONTH" => Some(Self::SqlConvertIntervalYearMonth),
+            "SQL_CONVERT_LONGVARBINARY" => Some(Self::SqlConvertLongvarbinary),
+            "SQL_CONVERT_LONGVARCHAR" => Some(Self::SqlConvertLongvarchar),
+            "SQL_CONVERT_NUMERIC" => Some(Self::SqlConvertNumeric),
+            "SQL_CONVERT_REAL" => Some(Self::SqlConvertReal),
+            "SQL_CONVERT_SMALLINT" => Some(Self::SqlConvertSmallint),
+            "SQL_CONVERT_TIME" => Some(Self::SqlConvertTime),
+            "SQL_CONVERT_TIMESTAMP" => Some(Self::SqlConvertTimestamp),
+            "SQL_CONVERT_TINYINT" => Some(Self::SqlConvertTinyint),
+            "SQL_CONVERT_VARBINARY" => Some(Self::SqlConvertVarbinary),
+            "SQL_CONVERT_VARCHAR" => Some(Self::SqlConvertVarchar),
+            _ => None,
+        }
+    }
+}
+/// *
+/// The JDBC/ODBC-defined type of any object.
+/// All the values here are the same as in the JDBC and ODBC specs.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum XdbcDataType {
+    XdbcUnknownType = 0,
+    XdbcChar = 1,
+    XdbcNumeric = 2,
+    XdbcDecimal = 3,
+    XdbcInteger = 4,
+    XdbcSmallint = 5,
+    XdbcFloat = 6,
+    XdbcReal = 7,
+    XdbcDouble = 8,
+    XdbcDatetime = 9,
+    XdbcInterval = 10,
+    XdbcVarchar = 12,
+    XdbcDate = 91,
+    XdbcTime = 92,
+    XdbcTimestamp = 93,
+    XdbcLongvarchar = -1,
+    XdbcBinary = -2,
+    XdbcVarbinary = -3,
+    XdbcLongvarbinary = -4,
+    XdbcBigint = -5,
+    XdbcTinyint = -6,
+    XdbcBit = -7,
+    XdbcWchar = -8,
+    XdbcWvarchar = -9,
+}
+impl XdbcDataType {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            XdbcDataType::XdbcUnknownType => "XDBC_UNKNOWN_TYPE",
+            XdbcDataType::XdbcChar => "XDBC_CHAR",
+            XdbcDataType::XdbcNumeric => "XDBC_NUMERIC",
+            XdbcDataType::XdbcDecimal => "XDBC_DECIMAL",
+            XdbcDataType::XdbcInteger => "XDBC_INTEGER",
+            XdbcDataType::XdbcSmallint => "XDBC_SMALLINT",
+            XdbcDataType::XdbcFloat => "XDBC_FLOAT",
+            XdbcDataType::XdbcReal => "XDBC_REAL",
+            XdbcDataType::XdbcDouble => "XDBC_DOUBLE",
+            XdbcDataType::XdbcDatetime => "XDBC_DATETIME",
+            XdbcDataType::XdbcInterval => "XDBC_INTERVAL",
+            XdbcDataType::XdbcVarchar => "XDBC_VARCHAR",
+            XdbcDataType::XdbcDate => "XDBC_DATE",
+            XdbcDataType::XdbcTime => "XDBC_TIME",
+            XdbcDataType::XdbcTimestamp => "XDBC_TIMESTAMP",
+            XdbcDataType::XdbcLongvarchar => "XDBC_LONGVARCHAR",
+            XdbcDataType::XdbcBinary => "XDBC_BINARY",
+            XdbcDataType::XdbcVarbinary => "XDBC_VARBINARY",
+            XdbcDataType::XdbcLongvarbinary => "XDBC_LONGVARBINARY",
+            XdbcDataType::XdbcBigint => "XDBC_BIGINT",
+            XdbcDataType::XdbcTinyint => "XDBC_TINYINT",
+            XdbcDataType::XdbcBit => "XDBC_BIT",
+            XdbcDataType::XdbcWchar => "XDBC_WCHAR",
+            XdbcDataType::XdbcWvarchar => "XDBC_WVARCHAR",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "XDBC_UNKNOWN_TYPE" => Some(Self::XdbcUnknownType),
+            "XDBC_CHAR" => Some(Self::XdbcChar),
+            "XDBC_NUMERIC" => Some(Self::XdbcNumeric),
+            "XDBC_DECIMAL" => Some(Self::XdbcDecimal),
+            "XDBC_INTEGER" => Some(Self::XdbcInteger),
+            "XDBC_SMALLINT" => Some(Self::XdbcSmallint),
+            "XDBC_FLOAT" => Some(Self::XdbcFloat),
+            "XDBC_REAL" => Some(Self::XdbcReal),
+            "XDBC_DOUBLE" => Some(Self::XdbcDouble),
+            "XDBC_DATETIME" => Some(Self::XdbcDatetime),
+            "XDBC_INTERVAL" => Some(Self::XdbcInterval),
+            "XDBC_VARCHAR" => Some(Self::XdbcVarchar),
+            "XDBC_DATE" => Some(Self::XdbcDate),
+            "XDBC_TIME" => Some(Self::XdbcTime),
+            "XDBC_TIMESTAMP" => Some(Self::XdbcTimestamp),
+            "XDBC_LONGVARCHAR" => Some(Self::XdbcLongvarchar),
+            "XDBC_BINARY" => Some(Self::XdbcBinary),
+            "XDBC_VARBINARY" => Some(Self::XdbcVarbinary),
+            "XDBC_LONGVARBINARY" => Some(Self::XdbcLongvarbinary),
+            "XDBC_BIGINT" => Some(Self::XdbcBigint),
+            "XDBC_TINYINT" => Some(Self::XdbcTinyint),
+            "XDBC_BIT" => Some(Self::XdbcBit),
+            "XDBC_WCHAR" => Some(Self::XdbcWchar),
+            "XDBC_WVARCHAR" => Some(Self::XdbcWvarchar),
+            _ => None,
+        }
+    }
+}
+/// *
+/// Detailed subtype information for XDBC_TYPE_DATETIME and XDBC_TYPE_INTERVAL.
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum XdbcDatetimeSubcode {
+    XdbcSubcodeUnknown = 0,
+    XdbcSubcodeYear = 1,
+    XdbcSubcodeTime = 2,
+    XdbcSubcodeTimestamp = 3,
+    XdbcSubcodeTimeWithTimezone = 4,
+    XdbcSubcodeTimestampWithTimezone = 5,
+    XdbcSubcodeSecond = 6,
+    XdbcSubcodeYearToMonth = 7,
+    XdbcSubcodeDayToHour = 8,
+    XdbcSubcodeDayToMinute = 9,
+    XdbcSubcodeDayToSecond = 10,
+    XdbcSubcodeHourToMinute = 11,
+    XdbcSubcodeHourToSecond = 12,
+    XdbcSubcodeMinuteToSecond = 13,
+    XdbcSubcodeIntervalYear = 101,
+    XdbcSubcodeIntervalMonth = 102,
+    XdbcSubcodeIntervalDay = 103,
+    XdbcSubcodeIntervalHour = 104,
+    XdbcSubcodeIntervalMinute = 105,
+    XdbcSubcodeIntervalSecond = 106,
+    XdbcSubcodeIntervalYearToMonth = 107,
+    XdbcSubcodeIntervalDayToHour = 108,
+    XdbcSubcodeIntervalDayToMinute = 109,
+    XdbcSubcodeIntervalDayToSecond = 110,
+    XdbcSubcodeIntervalHourToMinute = 111,
+    XdbcSubcodeIntervalHourToSecond = 112,
+    XdbcSubcodeIntervalMinuteToSecond = 113,
+}
+impl XdbcDatetimeSubcode {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            XdbcDatetimeSubcode::XdbcSubcodeUnknown => "XDBC_SUBCODE_UNKNOWN",
+            XdbcDatetimeSubcode::XdbcSubcodeYear => "XDBC_SUBCODE_YEAR",
+            XdbcDatetimeSubcode::XdbcSubcodeTime => "XDBC_SUBCODE_TIME",
+            XdbcDatetimeSubcode::XdbcSubcodeTimestamp => "XDBC_SUBCODE_TIMESTAMP",
+            XdbcDatetimeSubcode::XdbcSubcodeTimeWithTimezone => {
+                "XDBC_SUBCODE_TIME_WITH_TIMEZONE"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeTimestampWithTimezone => {
+                "XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeSecond => "XDBC_SUBCODE_SECOND",
+            XdbcDatetimeSubcode::XdbcSubcodeYearToMonth => "XDBC_SUBCODE_YEAR_TO_MONTH",
+            XdbcDatetimeSubcode::XdbcSubcodeDayToHour => "XDBC_SUBCODE_DAY_TO_HOUR",
+            XdbcDatetimeSubcode::XdbcSubcodeDayToMinute => "XDBC_SUBCODE_DAY_TO_MINUTE",
+            XdbcDatetimeSubcode::XdbcSubcodeDayToSecond => "XDBC_SUBCODE_DAY_TO_SECOND",
+            XdbcDatetimeSubcode::XdbcSubcodeHourToMinute => "XDBC_SUBCODE_HOUR_TO_MINUTE",
+            XdbcDatetimeSubcode::XdbcSubcodeHourToSecond => "XDBC_SUBCODE_HOUR_TO_SECOND",
+            XdbcDatetimeSubcode::XdbcSubcodeMinuteToSecond => {
+                "XDBC_SUBCODE_MINUTE_TO_SECOND"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalYear => "XDBC_SUBCODE_INTERVAL_YEAR",
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalMonth => {
+                "XDBC_SUBCODE_INTERVAL_MONTH"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalDay => "XDBC_SUBCODE_INTERVAL_DAY",
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalHour => "XDBC_SUBCODE_INTERVAL_HOUR",
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalMinute => {
+                "XDBC_SUBCODE_INTERVAL_MINUTE"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalSecond => {
+                "XDBC_SUBCODE_INTERVAL_SECOND"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalYearToMonth => {
+                "XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToHour => {
+                "XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToMinute => {
+                "XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToSecond => {
+                "XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalHourToMinute => {
+                "XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalHourToSecond => {
+                "XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND"
+            }
+            XdbcDatetimeSubcode::XdbcSubcodeIntervalMinuteToSecond => {
+                "XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND"
+            }
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "XDBC_SUBCODE_UNKNOWN" => Some(Self::XdbcSubcodeUnknown),
+            "XDBC_SUBCODE_YEAR" => Some(Self::XdbcSubcodeYear),
+            "XDBC_SUBCODE_TIME" => Some(Self::XdbcSubcodeTime),
+            "XDBC_SUBCODE_TIMESTAMP" => Some(Self::XdbcSubcodeTimestamp),
+            "XDBC_SUBCODE_TIME_WITH_TIMEZONE" => Some(Self::XdbcSubcodeTimeWithTimezone),
+            "XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE" => {
+                Some(Self::XdbcSubcodeTimestampWithTimezone)
+            }
+            "XDBC_SUBCODE_SECOND" => Some(Self::XdbcSubcodeSecond),
+            "XDBC_SUBCODE_YEAR_TO_MONTH" => Some(Self::XdbcSubcodeYearToMonth),
+            "XDBC_SUBCODE_DAY_TO_HOUR" => Some(Self::XdbcSubcodeDayToHour),
+            "XDBC_SUBCODE_DAY_TO_MINUTE" => Some(Self::XdbcSubcodeDayToMinute),
+            "XDBC_SUBCODE_DAY_TO_SECOND" => Some(Self::XdbcSubcodeDayToSecond),
+            "XDBC_SUBCODE_HOUR_TO_MINUTE" => Some(Self::XdbcSubcodeHourToMinute),
+            "XDBC_SUBCODE_HOUR_TO_SECOND" => Some(Self::XdbcSubcodeHourToSecond),
+            "XDBC_SUBCODE_MINUTE_TO_SECOND" => Some(Self::XdbcSubcodeMinuteToSecond),
+            "XDBC_SUBCODE_INTERVAL_YEAR" => Some(Self::XdbcSubcodeIntervalYear),
+            "XDBC_SUBCODE_INTERVAL_MONTH" => Some(Self::XdbcSubcodeIntervalMonth),
+            "XDBC_SUBCODE_INTERVAL_DAY" => Some(Self::XdbcSubcodeIntervalDay),
+            "XDBC_SUBCODE_INTERVAL_HOUR" => Some(Self::XdbcSubcodeIntervalHour),
+            "XDBC_SUBCODE_INTERVAL_MINUTE" => Some(Self::XdbcSubcodeIntervalMinute),
+            "XDBC_SUBCODE_INTERVAL_SECOND" => Some(Self::XdbcSubcodeIntervalSecond),
+            "XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH" => {
+                Some(Self::XdbcSubcodeIntervalYearToMonth)
+            }
+            "XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR" => {
+                Some(Self::XdbcSubcodeIntervalDayToHour)
+            }
+            "XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE" => {
+                Some(Self::XdbcSubcodeIntervalDayToMinute)
+            }
+            "XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND" => {
+                Some(Self::XdbcSubcodeIntervalDayToSecond)
+            }
+            "XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE" => {
+                Some(Self::XdbcSubcodeIntervalHourToMinute)
+            }
+            "XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND" => {
+                Some(Self::XdbcSubcodeIntervalHourToSecond)
+            }
+            "XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND" => {
+                Some(Self::XdbcSubcodeIntervalMinuteToSecond)
+            }
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum Nullable {
+    /// *
+    /// Indicates that the fields does not allow the use of null values.
+    NullabilityNoNulls = 0,
+    /// *
+    /// Indicates that the fields allow the use of null values.
+    NullabilityNullable = 1,
+    /// *
+    /// Indicates that nullability of the fields cannot be determined.
+    NullabilityUnknown = 2,
+}
+impl Nullable {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            Nullable::NullabilityNoNulls => "NULLABILITY_NO_NULLS",
+            Nullable::NullabilityNullable => "NULLABILITY_NULLABLE",
+            Nullable::NullabilityUnknown => "NULLABILITY_UNKNOWN",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "NULLABILITY_NO_NULLS" => Some(Self::NullabilityNoNulls),
+            "NULLABILITY_NULLABLE" => Some(Self::NullabilityNullable),
+            "NULLABILITY_UNKNOWN" => Some(Self::NullabilityUnknown),
+            _ => None,
+        }
+    }
+}
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
+#[repr(i32)]
+pub enum Searchable {
+    /// *
+    /// Indicates that column cannot be used in a WHERE clause.
+    None = 0,
+    /// *
+    /// Indicates that the column can be used in a WHERE clause if it is using a
+    /// LIKE operator.
+    Char = 1,
+    /// *
+    /// Indicates that the column can be used In a WHERE clause with any
+    /// operator other than LIKE.
+    ///
+    /// - Allowed operators: comparison, quantified comparison, BETWEEN,
+    ///                       DISTINCT, IN, MATCH, and UNIQUE.
+    Basic = 2,
+    /// *
+    /// Indicates that the column can be used in a WHERE clause using any operator.
+    Full = 3,
+}
+impl Searchable {
+    /// String value of the enum field names used in the ProtoBuf definition.
+    ///
+    /// The values are not transformed in any way and thus are considered stable
+    /// (if the ProtoBuf definition does not change) and safe for programmatic use.
+    pub fn as_str_name(&self) -> &'static str {
+        match self {
+            Searchable::None => "SEARCHABLE_NONE",
+            Searchable::Char => "SEARCHABLE_CHAR",
+            Searchable::Basic => "SEARCHABLE_BASIC",
+            Searchable::Full => "SEARCHABLE_FULL",
+        }
+    }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "SEARCHABLE_NONE" => Some(Self::None),
+            "SEARCHABLE_CHAR" => Some(Self::Char),
+            "SEARCHABLE_BASIC" => Some(Self::Basic),
+            "SEARCHABLE_FULL" => Some(Self::Full),
+            _ => None,
+        }
+    }
 }
 #[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord, ::prost::Enumeration)]
 #[repr(i32)]
@@ -1457,4 +2726,15 @@ impl UpdateDeleteRules {
             UpdateDeleteRules::SetDefault => "SET_DEFAULT",
         }
     }
+    /// Creates an enum from field names used in the ProtoBuf definition.
+    pub fn from_str_name(value: &str) -> ::core::option::Option<Self> {
+        match value {
+            "CASCADE" => Some(Self::Cascade),
+            "RESTRICT" => Some(Self::Restrict),
+            "SET_NULL" => Some(Self::SetNull),
+            "NO_ACTION" => Some(Self::NoAction),
+            "SET_DEFAULT" => Some(Self::SetDefault),
+            _ => None,
+        }
+    }
 }
diff --git a/arrow-flight/src/sql/client.rs b/arrow-flight/src/sql/client.rs
new file mode 100644
index 000000000000..a014137f6fa9
--- /dev/null
+++ b/arrow-flight/src/sql/client.rs
@@ -0,0 +1,641 @@
+// 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.
+
+//! A FlightSQL Client [`FlightSqlServiceClient`]
+
+use base64::prelude::BASE64_STANDARD;
+use base64::Engine;
+use bytes::Bytes;
+use std::collections::HashMap;
+use std::str::FromStr;
+use tonic::metadata::AsciiMetadataKey;
+
+use crate::decode::FlightRecordBatchStream;
+use crate::encode::FlightDataEncoderBuilder;
+use crate::error::FlightError;
+use crate::flight_service_client::FlightServiceClient;
+use crate::sql::server::{CLOSE_PREPARED_STATEMENT, CREATE_PREPARED_STATEMENT};
+use crate::sql::{
+    ActionClosePreparedStatementRequest, ActionCreatePreparedStatementRequest,
+    ActionCreatePreparedStatementResult, Any, CommandGetCatalogs, CommandGetCrossReference,
+    CommandGetDbSchemas, CommandGetExportedKeys, CommandGetImportedKeys, CommandGetPrimaryKeys,
+    CommandGetSqlInfo, CommandGetTableTypes, CommandGetTables, CommandGetXdbcTypeInfo,
+    CommandPreparedStatementQuery, CommandPreparedStatementUpdate, CommandStatementQuery,
+    CommandStatementUpdate, DoPutUpdateResult, ProstMessageExt, SqlInfo,
+};
+use crate::trailers::extract_lazy_trailers;
+use crate::{
+    Action, FlightData, FlightDescriptor, FlightInfo, HandshakeRequest, HandshakeResponse,
+    IpcMessage, PutResult, Ticket,
+};
+use arrow_array::RecordBatch;
+use arrow_buffer::Buffer;
+use arrow_ipc::convert::fb_to_schema;
+use arrow_ipc::reader::read_record_batch;
+use arrow_ipc::{root_as_message, MessageHeader};
+use arrow_schema::{ArrowError, Schema, SchemaRef};
+use futures::{stream, TryStreamExt};
+use prost::Message;
+use tonic::transport::Channel;
+use tonic::{IntoRequest, Streaming};
+
+/// A FlightSQLServiceClient is an endpoint for retrieving or storing Arrow data
+/// by FlightSQL protocol.
+#[derive(Debug, Clone)]
+pub struct FlightSqlServiceClient<T> {
+    token: Option<String>,
+    headers: HashMap<String, String>,
+    flight_client: FlightServiceClient<T>,
+}
+
+/// A FlightSql protocol client that can run queries against FlightSql servers
+/// This client is in the "experimental" stage. It is not guaranteed to follow the spec in all instances.
+/// Github issues are welcomed.
+impl FlightSqlServiceClient<Channel> {
+    /// Creates a new FlightSql client that connects to a server over an arbitrary tonic `Channel`
+    pub fn new(channel: Channel) -> Self {
+        let flight_client = FlightServiceClient::new(channel);
+        FlightSqlServiceClient {
+            token: None,
+            flight_client,
+            headers: HashMap::default(),
+        }
+    }
+
+    /// Return a reference to the underlying [`FlightServiceClient`]
+    pub fn inner(&self) -> &FlightServiceClient<Channel> {
+        &self.flight_client
+    }
+
+    /// Return a mutable reference to the underlying [`FlightServiceClient`]
+    pub fn inner_mut(&mut self) -> &mut FlightServiceClient<Channel> {
+        &mut self.flight_client
+    }
+
+    /// Consume this client and return the underlying [`FlightServiceClient`]
+    pub fn into_inner(self) -> FlightServiceClient<Channel> {
+        self.flight_client
+    }
+
+    /// Set auth token to the given value.
+    pub fn set_token(&mut self, token: String) {
+        self.token = Some(token);
+    }
+
+    /// Set header value.
+    pub fn set_header(&mut self, key: impl Into<String>, value: impl Into<String>) {
+        let key: String = key.into();
+        let value: String = value.into();
+        self.headers.insert(key, value);
+    }
+
+    async fn get_flight_info_for_command<M: ProstMessageExt>(
+        &mut self,
+        cmd: M,
+    ) -> Result<FlightInfo, ArrowError> {
+        let descriptor = FlightDescriptor::new_cmd(cmd.as_any().encode_to_vec());
+        let req = self.set_request_headers(descriptor.into_request())?;
+        let fi = self
+            .flight_client
+            .get_flight_info(req)
+            .await
+            .map_err(status_to_arrow_error)?
+            .into_inner();
+        Ok(fi)
+    }
+
+    /// Execute a query on the server.
+    pub async fn execute(
+        &mut self,
+        query: String,
+        transaction_id: Option<Bytes>,
+    ) -> Result<FlightInfo, ArrowError> {
+        let cmd = CommandStatementQuery {
+            query,
+            transaction_id,
+        };
+        self.get_flight_info_for_command(cmd).await
+    }
+
+    /// Perform a `handshake` with the server, passing credentials and establishing a session.
+    ///
+    /// If the server returns an "authorization" header, it is automatically parsed and set as
+    /// a token for future requests. Any other data returned by the server in the handshake
+    /// response is returned as a binary blob.
+    pub async fn handshake(&mut self, username: &str, password: &str) -> Result<Bytes, ArrowError> {
+        let cmd = HandshakeRequest {
+            protocol_version: 0,
+            payload: Default::default(),
+        };
+        let mut req = tonic::Request::new(stream::iter(vec![cmd]));
+        let val = BASE64_STANDARD.encode(format!("{username}:{password}"));
+        let val = format!("Basic {val}")
+            .parse()
+            .map_err(|_| ArrowError::ParseError("Cannot parse header".to_string()))?;
+        req.metadata_mut().insert("authorization", val);
+        let req = self.set_request_headers(req)?;
+        let resp = self
+            .flight_client
+            .handshake(req)
+            .await
+            .map_err(|e| ArrowError::IpcError(format!("Can't handshake {e}")))?;
+        if let Some(auth) = resp.metadata().get("authorization") {
+            let auth = auth
+                .to_str()
+                .map_err(|_| ArrowError::ParseError("Can't read auth header".to_string()))?;
+            let bearer = "Bearer ";
+            if !auth.starts_with(bearer) {
+                Err(ArrowError::ParseError("Invalid auth header!".to_string()))?;
+            }
+            let auth = auth[bearer.len()..].to_string();
+            self.token = Some(auth);
+        }
+        let responses: Vec<HandshakeResponse> = resp
+            .into_inner()
+            .try_collect()
+            .await
+            .map_err(|_| ArrowError::ParseError("Can't collect responses".to_string()))?;
+        let resp = match responses.as_slice() {
+            [resp] => resp.payload.clone(),
+            [] => Bytes::new(),
+            _ => Err(ArrowError::ParseError(
+                "Multiple handshake responses".to_string(),
+            ))?,
+        };
+        Ok(resp)
+    }
+
+    /// Execute a update query on the server, and return the number of records affected
+    pub async fn execute_update(
+        &mut self,
+        query: String,
+        transaction_id: Option<Bytes>,
+    ) -> Result<i64, ArrowError> {
+        let cmd = CommandStatementUpdate {
+            query,
+            transaction_id,
+        };
+        let descriptor = FlightDescriptor::new_cmd(cmd.as_any().encode_to_vec());
+        let req = self.set_request_headers(
+            stream::iter(vec![FlightData {
+                flight_descriptor: Some(descriptor),
+                ..Default::default()
+            }])
+            .into_request(),
+        )?;
+        let mut result = self
+            .flight_client
+            .do_put(req)
+            .await
+            .map_err(status_to_arrow_error)?
+            .into_inner();
+        let result = result
+            .message()
+            .await
+            .map_err(status_to_arrow_error)?
+            .unwrap();
+        let any = Any::decode(&*result.app_metadata).map_err(decode_error_to_arrow_error)?;
+        let result: DoPutUpdateResult = any.unpack()?.unwrap();
+        Ok(result.record_count)
+    }
+
+    /// Request a list of catalogs as tabular FlightInfo results
+    pub async fn get_catalogs(&mut self) -> Result<FlightInfo, ArrowError> {
+        self.get_flight_info_for_command(CommandGetCatalogs {})
+            .await
+    }
+
+    /// Request a list of database schemas as tabular FlightInfo results
+    pub async fn get_db_schemas(
+        &mut self,
+        request: CommandGetDbSchemas,
+    ) -> Result<FlightInfo, ArrowError> {
+        self.get_flight_info_for_command(request).await
+    }
+
+    /// Given a flight ticket, request to be sent the stream. Returns record batch stream reader
+    pub async fn do_get(
+        &mut self,
+        ticket: impl IntoRequest<Ticket>,
+    ) -> Result<FlightRecordBatchStream, ArrowError> {
+        let req = self.set_request_headers(ticket.into_request())?;
+
+        let (md, response_stream, _ext) = self
+            .flight_client
+            .do_get(req)
+            .await
+            .map_err(status_to_arrow_error)?
+            .into_parts();
+        let (response_stream, trailers) = extract_lazy_trailers(response_stream);
+
+        Ok(FlightRecordBatchStream::new_from_flight_data(
+            response_stream.map_err(FlightError::Tonic),
+        )
+        .with_headers(md)
+        .with_trailers(trailers))
+    }
+
+    /// Push a stream to the flight service associated with a particular flight stream.
+    pub async fn do_put(
+        &mut self,
+        request: impl tonic::IntoStreamingRequest<Message = FlightData>,
+    ) -> Result<Streaming<PutResult>, ArrowError> {
+        let req = self.set_request_headers(request.into_streaming_request())?;
+        Ok(self
+            .flight_client
+            .do_put(req)
+            .await
+            .map_err(status_to_arrow_error)?
+            .into_inner())
+    }
+
+    /// DoAction allows a flight client to do a specific action against a flight service
+    pub async fn do_action(
+        &mut self,
+        request: impl IntoRequest<Action>,
+    ) -> Result<Streaming<crate::Result>, ArrowError> {
+        let req = self.set_request_headers(request.into_request())?;
+        Ok(self
+            .flight_client
+            .do_action(req)
+            .await
+            .map_err(status_to_arrow_error)?
+            .into_inner())
+    }
+
+    /// Request a list of tables.
+    pub async fn get_tables(
+        &mut self,
+        request: CommandGetTables,
+    ) -> Result<FlightInfo, ArrowError> {
+        self.get_flight_info_for_command(request).await
+    }
+
+    /// Request the primary keys for a table.
+    pub async fn get_primary_keys(
+        &mut self,
+        request: CommandGetPrimaryKeys,
+    ) -> Result<FlightInfo, ArrowError> {
+        self.get_flight_info_for_command(request).await
+    }
+
+    /// Retrieves a description about the foreign key columns that reference the
+    /// primary key columns of the given table.
+    pub async fn get_exported_keys(
+        &mut self,
+        request: CommandGetExportedKeys,
+    ) -> Result<FlightInfo, ArrowError> {
+        self.get_flight_info_for_command(request).await
+    }
+
+    /// Retrieves the foreign key columns for the given table.
+    pub async fn get_imported_keys(
+        &mut self,
+        request: CommandGetImportedKeys,
+    ) -> Result<FlightInfo, ArrowError> {
+        self.get_flight_info_for_command(request).await
+    }
+
+    /// Retrieves a description of the foreign key columns in the given foreign key
+    /// table that reference the primary key or the columns representing a unique
+    /// constraint of the parent table (could be the same or a different table).
+    pub async fn get_cross_reference(
+        &mut self,
+        request: CommandGetCrossReference,
+    ) -> Result<FlightInfo, ArrowError> {
+        self.get_flight_info_for_command(request).await
+    }
+
+    /// Request a list of table types.
+    pub async fn get_table_types(&mut self) -> Result<FlightInfo, ArrowError> {
+        self.get_flight_info_for_command(CommandGetTableTypes {})
+            .await
+    }
+
+    /// Request a list of SQL information.
+    pub async fn get_sql_info(
+        &mut self,
+        sql_infos: Vec<SqlInfo>,
+    ) -> Result<FlightInfo, ArrowError> {
+        let request = CommandGetSqlInfo {
+            info: sql_infos.iter().map(|sql_info| *sql_info as u32).collect(),
+        };
+        self.get_flight_info_for_command(request).await
+    }
+
+    /// Request XDBC SQL information.
+    pub async fn get_xdbc_type_info(
+        &mut self,
+        request: CommandGetXdbcTypeInfo,
+    ) -> Result<FlightInfo, ArrowError> {
+        self.get_flight_info_for_command(request).await
+    }
+
+    /// Create a prepared statement object.
+    pub async fn prepare(
+        &mut self,
+        query: String,
+        transaction_id: Option<Bytes>,
+    ) -> Result<PreparedStatement<Channel>, ArrowError> {
+        let cmd = ActionCreatePreparedStatementRequest {
+            query,
+            transaction_id,
+        };
+        let action = Action {
+            r#type: CREATE_PREPARED_STATEMENT.to_string(),
+            body: cmd.as_any().encode_to_vec().into(),
+        };
+        let req = self.set_request_headers(action.into_request())?;
+        let mut result = self
+            .flight_client
+            .do_action(req)
+            .await
+            .map_err(status_to_arrow_error)?
+            .into_inner();
+        let result = result
+            .message()
+            .await
+            .map_err(status_to_arrow_error)?
+            .unwrap();
+        let any = Any::decode(&*result.body).map_err(decode_error_to_arrow_error)?;
+        let prepared_result: ActionCreatePreparedStatementResult = any.unpack()?.unwrap();
+        let dataset_schema = match prepared_result.dataset_schema.len() {
+            0 => Schema::empty(),
+            _ => Schema::try_from(IpcMessage(prepared_result.dataset_schema))?,
+        };
+        let parameter_schema = match prepared_result.parameter_schema.len() {
+            0 => Schema::empty(),
+            _ => Schema::try_from(IpcMessage(prepared_result.parameter_schema))?,
+        };
+        Ok(PreparedStatement::new(
+            self.clone(),
+            prepared_result.prepared_statement_handle,
+            dataset_schema,
+            parameter_schema,
+        ))
+    }
+
+    /// Explicitly shut down and clean up the client.
+    pub async fn close(&mut self) -> Result<(), ArrowError> {
+        // TODO: consume self instead of &mut self to explicitly prevent reuse?
+        Ok(())
+    }
+
+    fn set_request_headers<T>(
+        &self,
+        mut req: tonic::Request<T>,
+    ) -> Result<tonic::Request<T>, ArrowError> {
+        for (k, v) in &self.headers {
+            let k = AsciiMetadataKey::from_str(k.as_str()).map_err(|e| {
+                ArrowError::ParseError(format!("Cannot convert header key \"{k}\": {e}"))
+            })?;
+            let v = v.parse().map_err(|e| {
+                ArrowError::ParseError(format!("Cannot convert header value \"{v}\": {e}"))
+            })?;
+            req.metadata_mut().insert(k, v);
+        }
+        if let Some(token) = &self.token {
+            let val = format!("Bearer {token}").parse().map_err(|e| {
+                ArrowError::ParseError(format!("Cannot convert token to header value: {e}"))
+            })?;
+            req.metadata_mut().insert("authorization", val);
+        }
+        Ok(req)
+    }
+}
+
+/// A PreparedStatement
+#[derive(Debug, Clone)]
+pub struct PreparedStatement<T> {
+    flight_sql_client: FlightSqlServiceClient<T>,
+    parameter_binding: Option<RecordBatch>,
+    handle: Bytes,
+    dataset_schema: Schema,
+    parameter_schema: Schema,
+}
+
+impl PreparedStatement<Channel> {
+    pub(crate) fn new(
+        flight_client: FlightSqlServiceClient<Channel>,
+        handle: impl Into<Bytes>,
+        dataset_schema: Schema,
+        parameter_schema: Schema,
+    ) -> Self {
+        PreparedStatement {
+            flight_sql_client: flight_client,
+            parameter_binding: None,
+            handle: handle.into(),
+            dataset_schema,
+            parameter_schema,
+        }
+    }
+
+    /// Executes the prepared statement query on the server.
+    pub async fn execute(&mut self) -> Result<FlightInfo, ArrowError> {
+        self.write_bind_params().await?;
+
+        let cmd = CommandPreparedStatementQuery {
+            prepared_statement_handle: self.handle.clone(),
+        };
+
+        let result = self
+            .flight_sql_client
+            .get_flight_info_for_command(cmd)
+            .await?;
+        Ok(result)
+    }
+
+    /// Executes the prepared statement update query on the server.
+    pub async fn execute_update(&mut self) -> Result<i64, ArrowError> {
+        self.write_bind_params().await?;
+
+        let cmd = CommandPreparedStatementUpdate {
+            prepared_statement_handle: self.handle.clone(),
+        };
+        let descriptor = FlightDescriptor::new_cmd(cmd.as_any().encode_to_vec());
+        let mut result = self
+            .flight_sql_client
+            .do_put(stream::iter(vec![FlightData {
+                flight_descriptor: Some(descriptor),
+                ..Default::default()
+            }]))
+            .await?;
+        let result = result
+            .message()
+            .await
+            .map_err(status_to_arrow_error)?
+            .unwrap();
+        let any = Any::decode(&*result.app_metadata).map_err(decode_error_to_arrow_error)?;
+        let result: DoPutUpdateResult = any.unpack()?.unwrap();
+        Ok(result.record_count)
+    }
+
+    /// Retrieve the parameter schema from the query.
+    pub fn parameter_schema(&self) -> Result<&Schema, ArrowError> {
+        Ok(&self.parameter_schema)
+    }
+
+    /// Retrieve the ResultSet schema from the query.
+    pub fn dataset_schema(&self) -> Result<&Schema, ArrowError> {
+        Ok(&self.dataset_schema)
+    }
+
+    /// Set a RecordBatch that contains the parameters that will be bind.
+    pub fn set_parameters(&mut self, parameter_binding: RecordBatch) -> Result<(), ArrowError> {
+        self.parameter_binding = Some(parameter_binding);
+        Ok(())
+    }
+
+    /// Submit parameters to the server, if any have been set on this prepared statement instance
+    async fn write_bind_params(&mut self) -> Result<(), ArrowError> {
+        if let Some(ref params_batch) = self.parameter_binding {
+            let cmd = CommandPreparedStatementQuery {
+                prepared_statement_handle: self.handle.clone(),
+            };
+
+            let descriptor = FlightDescriptor::new_cmd(cmd.as_any().encode_to_vec());
+            let flight_stream_builder = FlightDataEncoderBuilder::new()
+                .with_flight_descriptor(Some(descriptor))
+                .with_schema(params_batch.schema());
+            let flight_data = flight_stream_builder
+                .build(futures::stream::iter(
+                    self.parameter_binding.clone().map(Ok),
+                ))
+                .try_collect::<Vec<_>>()
+                .await
+                .map_err(flight_error_to_arrow_error)?;
+
+            self.flight_sql_client
+                .do_put(stream::iter(flight_data))
+                .await?
+                .try_collect::<Vec<_>>()
+                .await
+                .map_err(status_to_arrow_error)?;
+        }
+
+        Ok(())
+    }
+
+    /// Close the prepared statement, so that this PreparedStatement can not used
+    /// anymore and server can free up any resources.
+    pub async fn close(mut self) -> Result<(), ArrowError> {
+        let cmd = ActionClosePreparedStatementRequest {
+            prepared_statement_handle: self.handle.clone(),
+        };
+        let action = Action {
+            r#type: CLOSE_PREPARED_STATEMENT.to_string(),
+            body: cmd.as_any().encode_to_vec().into(),
+        };
+        let _ = self.flight_sql_client.do_action(action).await?;
+        Ok(())
+    }
+}
+
+fn decode_error_to_arrow_error(err: prost::DecodeError) -> ArrowError {
+    ArrowError::IpcError(err.to_string())
+}
+
+fn status_to_arrow_error(status: tonic::Status) -> ArrowError {
+    ArrowError::IpcError(format!("{status:?}"))
+}
+
+fn flight_error_to_arrow_error(err: FlightError) -> ArrowError {
+    match err {
+        FlightError::Arrow(e) => e,
+        e => ArrowError::ExternalError(Box::new(e)),
+    }
+}
+
+// A polymorphic structure to natively represent different types of data contained in `FlightData`
+pub enum ArrowFlightData {
+    RecordBatch(RecordBatch),
+    Schema(Schema),
+}
+
+/// Extract `Schema` or `RecordBatch`es from the `FlightData` wire representation
+pub fn arrow_data_from_flight_data(
+    flight_data: FlightData,
+    arrow_schema_ref: &SchemaRef,
+) -> Result<ArrowFlightData, ArrowError> {
+    let ipc_message = root_as_message(&flight_data.data_header[..])
+        .map_err(|err| ArrowError::ParseError(format!("Unable to get root as message: {err:?}")))?;
+
+    match ipc_message.header_type() {
+        MessageHeader::RecordBatch => {
+            let ipc_record_batch = ipc_message.header_as_record_batch().ok_or_else(|| {
+                ArrowError::ComputeError(
+                    "Unable to convert flight data header to a record batch".to_string(),
+                )
+            })?;
+
+            let dictionaries_by_field = HashMap::new();
+            let record_batch = read_record_batch(
+                &Buffer::from_bytes(flight_data.data_body.into()),
+                ipc_record_batch,
+                arrow_schema_ref.clone(),
+                &dictionaries_by_field,
+                None,
+                &ipc_message.version(),
+            )?;
+            Ok(ArrowFlightData::RecordBatch(record_batch))
+        }
+        MessageHeader::Schema => {
+            let ipc_schema = ipc_message.header_as_schema().ok_or_else(|| {
+                ArrowError::ComputeError(
+                    "Unable to convert flight data header to a schema".to_string(),
+                )
+            })?;
+
+            let arrow_schema = fb_to_schema(ipc_schema);
+            Ok(ArrowFlightData::Schema(arrow_schema))
+        }
+        MessageHeader::DictionaryBatch => {
+            let _ = ipc_message.header_as_dictionary_batch().ok_or_else(|| {
+                ArrowError::ComputeError(
+                    "Unable to convert flight data header to a dictionary batch".to_string(),
+                )
+            })?;
+            Err(ArrowError::NotYetImplemented(
+                "no idea on how to convert an ipc dictionary batch to an arrow type".to_string(),
+            ))
+        }
+        MessageHeader::Tensor => {
+            let _ = ipc_message.header_as_tensor().ok_or_else(|| {
+                ArrowError::ComputeError(
+                    "Unable to convert flight data header to a tensor".to_string(),
+                )
+            })?;
+            Err(ArrowError::NotYetImplemented(
+                "no idea on how to convert an ipc tensor to an arrow type".to_string(),
+            ))
+        }
+        MessageHeader::SparseTensor => {
+            let _ = ipc_message.header_as_sparse_tensor().ok_or_else(|| {
+                ArrowError::ComputeError(
+                    "Unable to convert flight data header to a sparse tensor".to_string(),
+                )
+            })?;
+            Err(ArrowError::NotYetImplemented(
+                "no idea on how to convert an ipc sparse tensor to an arrow type".to_string(),
+            ))
+        }
+        _ => Err(ArrowError::ComputeError(format!(
+            "Unable to convert message with header_type: '{:?}' to arrow data",
+            ipc_message.header_type()
+        ))),
+    }
+}
diff --git a/arrow-flight/src/sql/metadata/catalogs.rs b/arrow-flight/src/sql/metadata/catalogs.rs
new file mode 100644
index 000000000000..327fed81077b
--- /dev/null
+++ b/arrow-flight/src/sql/metadata/catalogs.rs
@@ -0,0 +1,100 @@
+// 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.
+
+use std::sync::Arc;
+
+use arrow_array::{RecordBatch, StringArray};
+use arrow_schema::{DataType, Field, Schema, SchemaRef};
+use once_cell::sync::Lazy;
+
+use crate::error::Result;
+use crate::sql::CommandGetCatalogs;
+
+/// A builder for a [`CommandGetCatalogs`] response.
+///
+/// Builds rows like this:
+///
+/// * catalog_name: utf8,
+pub struct GetCatalogsBuilder {
+    catalogs: Vec<String>,
+}
+
+impl CommandGetCatalogs {
+    /// Create a builder suitable for constructing a response
+    pub fn into_builder(self) -> GetCatalogsBuilder {
+        self.into()
+    }
+}
+
+impl From<CommandGetCatalogs> for GetCatalogsBuilder {
+    fn from(_: CommandGetCatalogs) -> Self {
+        Self::new()
+    }
+}
+
+impl Default for GetCatalogsBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl GetCatalogsBuilder {
+    /// Create a new instance of [`GetCatalogsBuilder`]
+    pub fn new() -> Self {
+        Self {
+            catalogs: Vec::new(),
+        }
+    }
+
+    /// Append a row
+    pub fn append(&mut self, catalog_name: impl Into<String>) {
+        self.catalogs.push(catalog_name.into());
+    }
+
+    /// builds a `RecordBatch` with the correct schema for a
+    /// [`CommandGetCatalogs`] response
+    pub fn build(self) -> Result<RecordBatch> {
+        let Self { catalogs } = self;
+
+        let batch = RecordBatch::try_new(
+            Arc::clone(&GET_CATALOG_SCHEMA),
+            vec![Arc::new(StringArray::from_iter_values(catalogs)) as _],
+        )?;
+
+        Ok(batch)
+    }
+
+    /// Returns the schema that will result from [`CommandGetCatalogs`]
+    ///
+    /// [`CommandGetCatalogs`]: crate::sql::CommandGetCatalogs
+    pub fn schema(&self) -> SchemaRef {
+        get_catalogs_schema()
+    }
+}
+
+fn get_catalogs_schema() -> SchemaRef {
+    Arc::clone(&GET_CATALOG_SCHEMA)
+}
+
+/// The schema for GetCatalogs
+static GET_CATALOG_SCHEMA: Lazy<SchemaRef> = Lazy::new(|| {
+    Arc::new(Schema::new(vec![Field::new(
+        "catalog_name",
+        DataType::Utf8,
+        false,
+    )]))
+});
diff --git a/arrow-flight/src/sql/metadata/db_schemas.rs b/arrow-flight/src/sql/metadata/db_schemas.rs
new file mode 100644
index 000000000000..303d11cd74ca
--- /dev/null
+++ b/arrow-flight/src/sql/metadata/db_schemas.rs
@@ -0,0 +1,286 @@
+// 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.
+
+//! [`GetDbSchemasBuilder`] for building responses to [`CommandGetDbSchemas`] queries.
+//!
+//! [`CommandGetDbSchemas`]: crate::sql::CommandGetDbSchemas
+
+use std::sync::Arc;
+
+use arrow_arith::boolean::and;
+use arrow_array::{builder::StringBuilder, ArrayRef, RecordBatch, StringArray};
+use arrow_ord::cmp::eq;
+use arrow_schema::{DataType, Field, Schema, SchemaRef};
+use arrow_select::{filter::filter_record_batch, take::take};
+use arrow_string::like::like;
+use once_cell::sync::Lazy;
+
+use super::lexsort_to_indices;
+use crate::error::*;
+use crate::sql::CommandGetDbSchemas;
+
+/// A builder for a [`CommandGetDbSchemas`] response.
+///
+/// Builds rows like this:
+///
+/// * catalog_name: utf8,
+/// * db_schema_name: utf8,
+pub struct GetDbSchemasBuilder {
+    // Specifies the Catalog to search for the tables.
+    // - An empty string retrieves those without a catalog.
+    // - If omitted the catalog name is not used to narrow the search.
+    catalog_filter: Option<String>,
+    // Optional filters to apply
+    db_schema_filter_pattern: Option<String>,
+    // array builder for catalog names
+    catalog_name: StringBuilder,
+    // array builder for schema names
+    db_schema_name: StringBuilder,
+}
+
+impl CommandGetDbSchemas {
+    /// Create a builder suitable for constructing a response
+    pub fn into_builder(self) -> GetDbSchemasBuilder {
+        self.into()
+    }
+}
+
+impl From<CommandGetDbSchemas> for GetDbSchemasBuilder {
+    fn from(value: CommandGetDbSchemas) -> Self {
+        Self::new(value.catalog, value.db_schema_filter_pattern)
+    }
+}
+
+impl GetDbSchemasBuilder {
+    /// Create a new instance of [`GetDbSchemasBuilder`]
+    ///
+    /// # Parameters
+    ///
+    /// - `catalog`:  Specifies the Catalog to search for the tables.
+    ///   - An empty string retrieves those without a catalog.
+    ///   - If omitted the catalog name is not used to narrow the search.
+    /// - `db_schema_filter_pattern`: Specifies a filter pattern for schemas to search for.
+    ///   When no pattern is provided, the pattern will not be used to narrow the search.
+    ///   In the pattern string, two special characters can be used to denote matching rules:
+    ///     - "%" means to match any substring with 0 or more characters.
+    ///     - "_" means to match any one character.
+    ///
+    /// [`CommandGetDbSchemas`]: crate::sql::CommandGetDbSchemas
+    pub fn new(
+        catalog: Option<impl Into<String>>,
+        db_schema_filter_pattern: Option<impl Into<String>>,
+    ) -> Self {
+        Self {
+            catalog_filter: catalog.map(|v| v.into()),
+            db_schema_filter_pattern: db_schema_filter_pattern.map(|v| v.into()),
+            catalog_name: StringBuilder::new(),
+            db_schema_name: StringBuilder::new(),
+        }
+    }
+
+    /// Append a row
+    ///
+    /// In case the catalog should be considered as empty, pass in an empty string '""'.
+    pub fn append(&mut self, catalog_name: impl AsRef<str>, schema_name: impl AsRef<str>) {
+        self.catalog_name.append_value(catalog_name);
+        self.db_schema_name.append_value(schema_name);
+    }
+
+    /// builds a `RecordBatch` with the correct schema for a `CommandGetDbSchemas` response
+    pub fn build(self) -> Result<RecordBatch> {
+        let schema = self.schema();
+        let Self {
+            catalog_filter,
+            db_schema_filter_pattern,
+            mut catalog_name,
+            mut db_schema_name,
+        } = self;
+
+        // Make the arrays
+        let catalog_name = catalog_name.finish();
+        let db_schema_name = db_schema_name.finish();
+
+        let mut filters = vec![];
+
+        if let Some(db_schema_filter_pattern) = db_schema_filter_pattern {
+            // use like kernel to get wildcard matching
+            let scalar = StringArray::new_scalar(db_schema_filter_pattern);
+            filters.push(like(&db_schema_name, &scalar)?)
+        }
+
+        if let Some(catalog_filter_name) = catalog_filter {
+            let scalar = StringArray::new_scalar(catalog_filter_name);
+            filters.push(eq(&catalog_name, &scalar)?);
+        }
+
+        // `AND` any filters together
+        let mut total_filter = None;
+        while let Some(filter) = filters.pop() {
+            let new_filter = match total_filter {
+                Some(total_filter) => and(&total_filter, &filter)?,
+                None => filter,
+            };
+            total_filter = Some(new_filter);
+        }
+
+        let batch = RecordBatch::try_new(
+            schema,
+            vec![
+                Arc::new(catalog_name) as ArrayRef,
+                Arc::new(db_schema_name) as ArrayRef,
+            ],
+        )?;
+
+        // Apply the filters if needed
+        let filtered_batch = if let Some(filter) = total_filter {
+            filter_record_batch(&batch, &filter)?
+        } else {
+            batch
+        };
+
+        // Order filtered results by catalog_name, then db_schema_name
+        let indices = lexsort_to_indices(filtered_batch.columns());
+        let columns = filtered_batch
+            .columns()
+            .iter()
+            .map(|c| take(c, &indices, None))
+            .collect::<std::result::Result<Vec<_>, _>>()?;
+
+        Ok(RecordBatch::try_new(filtered_batch.schema(), columns)?)
+    }
+
+    /// Return the schema of the RecordBatch that will be returned
+    /// from [`CommandGetDbSchemas`]
+    pub fn schema(&self) -> SchemaRef {
+        get_db_schemas_schema()
+    }
+}
+
+fn get_db_schemas_schema() -> SchemaRef {
+    Arc::clone(&GET_DB_SCHEMAS_SCHEMA)
+}
+
+/// The schema for GetDbSchemas
+static GET_DB_SCHEMAS_SCHEMA: Lazy<SchemaRef> = Lazy::new(|| {
+    Arc::new(Schema::new(vec![
+        Field::new("catalog_name", DataType::Utf8, false),
+        Field::new("db_schema_name", DataType::Utf8, false),
+    ]))
+});
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::{StringArray, UInt32Array};
+
+    fn get_ref_batch() -> RecordBatch {
+        RecordBatch::try_new(
+            get_db_schemas_schema(),
+            vec![
+                Arc::new(StringArray::from(vec![
+                    "a_catalog",
+                    "a_catalog",
+                    "b_catalog",
+                    "b_catalog",
+                ])) as ArrayRef,
+                Arc::new(StringArray::from(vec![
+                    "a_schema", "b_schema", "a_schema", "b_schema",
+                ])) as ArrayRef,
+            ],
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn test_schemas_are_filtered() {
+        let ref_batch = get_ref_batch();
+
+        let mut builder = GetDbSchemasBuilder::new(None::<String>, None::<String>);
+        builder.append("a_catalog", "a_schema");
+        builder.append("a_catalog", "b_schema");
+        builder.append("b_catalog", "a_schema");
+        builder.append("b_catalog", "b_schema");
+        let schema_batch = builder.build().unwrap();
+
+        assert_eq!(schema_batch, ref_batch);
+
+        let mut builder = GetDbSchemasBuilder::new(None::<String>, Some("a%"));
+        builder.append("a_catalog", "a_schema");
+        builder.append("a_catalog", "b_schema");
+        builder.append("b_catalog", "a_schema");
+        builder.append("b_catalog", "b_schema");
+        let schema_batch = builder.build().unwrap();
+
+        let indices = UInt32Array::from(vec![0, 2]);
+        let ref_filtered = RecordBatch::try_new(
+            get_db_schemas_schema(),
+            ref_batch
+                .columns()
+                .iter()
+                .map(|c| take(c, &indices, None))
+                .collect::<std::result::Result<Vec<_>, _>>()
+                .unwrap(),
+        )
+        .unwrap();
+
+        assert_eq!(schema_batch, ref_filtered);
+    }
+
+    #[test]
+    fn test_schemas_are_sorted() {
+        let ref_batch = get_ref_batch();
+
+        let mut builder = GetDbSchemasBuilder::new(None::<String>, None::<String>);
+        builder.append("a_catalog", "b_schema");
+        builder.append("b_catalog", "a_schema");
+        builder.append("a_catalog", "a_schema");
+        builder.append("b_catalog", "b_schema");
+        let schema_batch = builder.build().unwrap();
+
+        assert_eq!(schema_batch, ref_batch)
+    }
+
+    #[test]
+    fn test_builder_from_query() {
+        let ref_batch = get_ref_batch();
+        let query = CommandGetDbSchemas {
+            catalog: Some("a_catalog".into()),
+            db_schema_filter_pattern: Some("b%".into()),
+        };
+
+        let mut builder = query.into_builder();
+        builder.append("a_catalog", "a_schema");
+        builder.append("a_catalog", "b_schema");
+        builder.append("b_catalog", "a_schema");
+        builder.append("b_catalog", "b_schema");
+        let schema_batch = builder.build().unwrap();
+
+        let indices = UInt32Array::from(vec![1]);
+        let ref_filtered = RecordBatch::try_new(
+            get_db_schemas_schema(),
+            ref_batch
+                .columns()
+                .iter()
+                .map(|c| take(c, &indices, None))
+                .collect::<std::result::Result<Vec<_>, _>>()
+                .unwrap(),
+        )
+        .unwrap();
+
+        assert_eq!(schema_batch, ref_filtered);
+    }
+}
diff --git a/arrow-flight/src/sql/metadata/mod.rs b/arrow-flight/src/sql/metadata/mod.rs
new file mode 100644
index 000000000000..1e9881ffa70e
--- /dev/null
+++ b/arrow-flight/src/sql/metadata/mod.rs
@@ -0,0 +1,76 @@
+// 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.
+
+//! Builders and function for building responses to FlightSQL metadata
+//! / information schema requests.
+//!
+//! - [`GetCatalogsBuilder`] for building responses to [`CommandGetCatalogs`] queries.
+//! - [`GetDbSchemasBuilder`] for building responses to [`CommandGetDbSchemas`] queries.
+//! - [`GetTablesBuilder`]for building responses to [`CommandGetTables`] queries.
+//! - [`SqlInfoDataBuilder`]for building responses to [`CommandGetSqlInfo`] queries.
+//! - [`XdbcTypeInfoDataBuilder`]for building responses to [`CommandGetXdbcTypeInfo`] queries.
+//!
+//! [`CommandGetCatalogs`]: crate::sql::CommandGetCatalogs
+//! [`CommandGetDbSchemas`]: crate::sql::CommandGetDbSchemas
+//! [`CommandGetTables`]: crate::sql::CommandGetTables
+//! [`CommandGetSqlInfo`]: crate::sql::CommandGetSqlInfo
+//! [`CommandGetXdbcTypeInfo`]: crate::sql::CommandGetXdbcTypeInfo
+
+mod catalogs;
+mod db_schemas;
+mod sql_info;
+mod tables;
+mod xdbc_info;
+
+pub use catalogs::GetCatalogsBuilder;
+pub use db_schemas::GetDbSchemasBuilder;
+pub use sql_info::{SqlInfoData, SqlInfoDataBuilder};
+pub use tables::GetTablesBuilder;
+pub use xdbc_info::{XdbcTypeInfo, XdbcTypeInfoData, XdbcTypeInfoDataBuilder};
+
+use arrow_array::ArrayRef;
+use arrow_array::UInt32Array;
+use arrow_row::RowConverter;
+use arrow_row::SortField;
+
+/// Helper function to sort all the columns in an array
+fn lexsort_to_indices(arrays: &[ArrayRef]) -> UInt32Array {
+    let fields = arrays
+        .iter()
+        .map(|a| SortField::new(a.data_type().clone()))
+        .collect();
+    let converter = RowConverter::new(fields).unwrap();
+    let rows = converter.convert_columns(arrays).unwrap();
+    let mut sort: Vec<_> = rows.iter().enumerate().collect();
+    sort.sort_unstable_by(|(_, a), (_, b)| a.cmp(b));
+    UInt32Array::from_iter_values(sort.iter().map(|(i, _)| *i as u32))
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow_array::RecordBatch;
+    use arrow_cast::pretty::pretty_format_batches;
+    pub fn assert_batches_eq(batches: &[RecordBatch], expected_lines: &[&str]) {
+        let formatted = pretty_format_batches(batches).unwrap().to_string();
+        let actual_lines: Vec<_> = formatted.trim().lines().collect();
+        assert_eq!(
+            &actual_lines, expected_lines,
+            "\n\nexpected:\n\n{:#?}\nactual:\n\n{:#?}\n\n",
+            expected_lines, actual_lines
+        );
+    }
+}
diff --git a/arrow-flight/src/sql/metadata/sql_info.rs b/arrow-flight/src/sql/metadata/sql_info.rs
new file mode 100644
index 000000000000..d4584f4a6827
--- /dev/null
+++ b/arrow-flight/src/sql/metadata/sql_info.rs
@@ -0,0 +1,561 @@
+// 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.
+
+//! Helpers for building responses to [`CommandGetSqlInfo`] metadata requests.
+//!
+//! - [`SqlInfoDataBuilder`] - a builder for collecting sql infos
+//!   and building a conformant `RecordBatch` with sql info server metadata.
+//! - [`SqlInfoData`] - a helper type wrapping a `RecordBatch`
+//!   used for storing sql info server metadata.
+//! - [`GetSqlInfoBuilder`] - a builder for consructing [`CommandGetSqlInfo`] responses.
+//!
+
+use std::collections::{BTreeMap, HashMap};
+use std::sync::Arc;
+
+use arrow_arith::boolean::or;
+use arrow_array::array::{Array, UInt32Array, UnionArray};
+use arrow_array::builder::{
+    ArrayBuilder, BooleanBuilder, Int32Builder, Int64Builder, Int8Builder, ListBuilder, MapBuilder,
+    StringBuilder, UInt32Builder,
+};
+use arrow_array::{RecordBatch, Scalar};
+use arrow_data::ArrayData;
+use arrow_ord::cmp::eq;
+use arrow_schema::{DataType, Field, Fields, Schema, SchemaRef, UnionFields, UnionMode};
+use arrow_select::filter::filter_record_batch;
+use once_cell::sync::Lazy;
+
+use crate::error::Result;
+use crate::sql::{CommandGetSqlInfo, SqlInfo};
+
+/// Represents a dynamic value
+#[derive(Debug, Clone, PartialEq)]
+pub enum SqlInfoValue {
+    String(String),
+    Bool(bool),
+    BigInt(i64),
+    Bitmask(i32),
+    StringList(Vec<String>),
+    ListMap(BTreeMap<i32, Vec<i32>>),
+}
+
+impl From<&str> for SqlInfoValue {
+    fn from(value: &str) -> Self {
+        Self::String(value.to_string())
+    }
+}
+
+impl From<bool> for SqlInfoValue {
+    fn from(value: bool) -> Self {
+        Self::Bool(value)
+    }
+}
+
+impl From<i32> for SqlInfoValue {
+    fn from(value: i32) -> Self {
+        Self::Bitmask(value)
+    }
+}
+
+impl From<i64> for SqlInfoValue {
+    fn from(value: i64) -> Self {
+        Self::BigInt(value)
+    }
+}
+
+impl From<&[&str]> for SqlInfoValue {
+    fn from(values: &[&str]) -> Self {
+        let values = values.iter().map(|s| s.to_string()).collect();
+        Self::StringList(values)
+    }
+}
+
+impl From<Vec<String>> for SqlInfoValue {
+    fn from(values: Vec<String>) -> Self {
+        Self::StringList(values)
+    }
+}
+
+impl From<BTreeMap<i32, Vec<i32>>> for SqlInfoValue {
+    fn from(value: BTreeMap<i32, Vec<i32>>) -> Self {
+        Self::ListMap(value)
+    }
+}
+
+impl From<HashMap<i32, Vec<i32>>> for SqlInfoValue {
+    fn from(value: HashMap<i32, Vec<i32>>) -> Self {
+        Self::ListMap(value.into_iter().collect())
+    }
+}
+
+impl From<&HashMap<i32, Vec<i32>>> for SqlInfoValue {
+    fn from(value: &HashMap<i32, Vec<i32>>) -> Self {
+        Self::ListMap(
+            value
+                .iter()
+                .map(|(k, v)| (k.to_owned(), v.to_owned()))
+                .collect(),
+        )
+    }
+}
+
+/// Something that can be converted into u32 (the represenation of a [`SqlInfo`] name)
+pub trait SqlInfoName {
+    fn as_u32(&self) -> u32;
+}
+
+impl SqlInfoName for SqlInfo {
+    fn as_u32(&self) -> u32 {
+        // SqlInfos are u32 in the flight spec, but for some reason
+        // SqlInfo repr is an i32, so convert between them
+        u32::try_from(i32::from(*self)).expect("SqlInfo fit into u32")
+    }
+}
+
+// Allow passing u32 directly into to with_sql_info
+impl SqlInfoName for u32 {
+    fn as_u32(&self) -> u32 {
+        *self
+    }
+}
+
+/// Handles creating the dense [`UnionArray`] described by [flightsql]
+///
+/// incrementally build types/offset of the dense union. See [Union Spec] for details.
+///
+/// ```text
+/// *  value: dense_union<
+/// *              string_value: utf8,
+/// *              bool_value: bool,
+/// *              bigint_value: int64,
+/// *              int32_bitmask: int32,
+/// *              string_list: list<string_data: utf8>
+/// *              int32_to_int32_list_map: map<key: int32, value: list<$data$: int32>>
+/// * >
+/// ```
+///[flightsql]: (https://github.com/apache/arrow/blob/f9324b79bf4fc1ec7e97b32e3cce16e75ef0f5e3/format/FlightSql.proto#L32-L43
+///[Union Spec]: https://arrow.apache.org/docs/format/Columnar.html#dense-union
+struct SqlInfoUnionBuilder {
+    // Values for each child type
+    string_values: StringBuilder,
+    bool_values: BooleanBuilder,
+    bigint_values: Int64Builder,
+    int32_bitmask_values: Int32Builder,
+    string_list_values: ListBuilder<StringBuilder>,
+    int32_to_int32_list_map_values: MapBuilder<Int32Builder, ListBuilder<Int32Builder>>,
+    type_ids: Int8Builder,
+    offsets: Int32Builder,
+}
+
+/// [`DataType`] for the output union array
+static UNION_TYPE: Lazy<DataType> = Lazy::new(|| {
+    let fields = vec![
+        Field::new("string_value", DataType::Utf8, false),
+        Field::new("bool_value", DataType::Boolean, false),
+        Field::new("bigint_value", DataType::Int64, false),
+        Field::new("int32_bitmask", DataType::Int32, false),
+        // treat list as nullable b/c that is what the builders make
+        Field::new(
+            "string_list",
+            DataType::List(Arc::new(Field::new("item", DataType::Utf8, true))),
+            true,
+        ),
+        Field::new(
+            "int32_to_int32_list_map",
+            DataType::Map(
+                Arc::new(Field::new(
+                    "entries",
+                    DataType::Struct(Fields::from(vec![
+                        Field::new("keys", DataType::Int32, false),
+                        Field::new(
+                            "values",
+                            DataType::List(Arc::new(Field::new("item", DataType::Int32, true))),
+                            true,
+                        ),
+                    ])),
+                    false,
+                )),
+                false,
+            ),
+            true,
+        ),
+    ];
+
+    // create "type ids", one for each type, assume they go from 0 .. num_fields
+    let type_ids: Vec<i8> = (0..fields.len()).map(|v| v as i8).collect();
+
+    DataType::Union(UnionFields::new(type_ids, fields), UnionMode::Dense)
+});
+
+impl SqlInfoUnionBuilder {
+    pub fn new() -> Self {
+        Self {
+            string_values: StringBuilder::new(),
+            bool_values: BooleanBuilder::new(),
+            bigint_values: Int64Builder::new(),
+            int32_bitmask_values: Int32Builder::new(),
+            string_list_values: ListBuilder::new(StringBuilder::new()),
+            int32_to_int32_list_map_values: MapBuilder::new(
+                None,
+                Int32Builder::new(),
+                ListBuilder::new(Int32Builder::new()),
+            ),
+            type_ids: Int8Builder::new(),
+            offsets: Int32Builder::new(),
+        }
+    }
+
+    /// Returns the DataType created by this builder
+    pub fn schema() -> &'static DataType {
+        &UNION_TYPE
+    }
+
+    /// Append the specified value to this builder
+    pub fn append_value(&mut self, v: &SqlInfoValue) -> Result<()> {
+        // typeid is which child and len is the child array's length
+        // *after* adding the value
+        let (type_id, len) = match v {
+            SqlInfoValue::String(v) => {
+                self.string_values.append_value(v);
+                (0, self.string_values.len())
+            }
+            SqlInfoValue::Bool(v) => {
+                self.bool_values.append_value(*v);
+                (1, self.bool_values.len())
+            }
+            SqlInfoValue::BigInt(v) => {
+                self.bigint_values.append_value(*v);
+                (2, self.bigint_values.len())
+            }
+            SqlInfoValue::Bitmask(v) => {
+                self.int32_bitmask_values.append_value(*v);
+                (3, self.int32_bitmask_values.len())
+            }
+            SqlInfoValue::StringList(values) => {
+                // build list
+                for v in values {
+                    self.string_list_values.values().append_value(v);
+                }
+                // complete the list
+                self.string_list_values.append(true);
+                (4, self.string_list_values.len())
+            }
+            SqlInfoValue::ListMap(values) => {
+                // build map
+                for (k, v) in values.clone() {
+                    self.int32_to_int32_list_map_values.keys().append_value(k);
+                    self.int32_to_int32_list_map_values
+                        .values()
+                        .append_value(v.into_iter().map(Some));
+                }
+                // complete the list
+                self.int32_to_int32_list_map_values.append(true)?;
+                (5, self.int32_to_int32_list_map_values.len())
+            }
+        };
+
+        self.type_ids.append_value(type_id);
+        let len = i32::try_from(len).expect("offset fit in i32");
+        self.offsets.append_value(len - 1);
+        Ok(())
+    }
+
+    /// Complete the construction and build the [`UnionArray`]
+    pub fn finish(self) -> UnionArray {
+        let Self {
+            mut string_values,
+            mut bool_values,
+            mut bigint_values,
+            mut int32_bitmask_values,
+            mut string_list_values,
+            mut int32_to_int32_list_map_values,
+            mut type_ids,
+            mut offsets,
+        } = self;
+        let type_ids = type_ids.finish();
+        let offsets = offsets.finish();
+
+        // form the correct ArrayData
+
+        let len = offsets.len();
+        let null_bit_buffer = None;
+        let offset = 0;
+
+        let buffers = vec![
+            type_ids.into_data().buffers()[0].clone(),
+            offsets.into_data().buffers()[0].clone(),
+        ];
+
+        let child_data = vec![
+            string_values.finish().into_data(),
+            bool_values.finish().into_data(),
+            bigint_values.finish().into_data(),
+            int32_bitmask_values.finish().into_data(),
+            string_list_values.finish().into_data(),
+            int32_to_int32_list_map_values.finish().into_data(),
+        ];
+
+        let data = ArrayData::try_new(
+            UNION_TYPE.clone(),
+            len,
+            null_bit_buffer,
+            offset,
+            buffers,
+            child_data,
+        )
+        .expect("Correctly created UnionArray");
+
+        UnionArray::from(data)
+    }
+}
+
+/// Helper to create [`CommandGetSqlInfo`] responses.
+///
+/// [`CommandGetSqlInfo`] are metadata requests used by a Flight SQL
+/// server to communicate supported capabilities to Flight SQL clients.
+///
+/// Servers constuct - usually static - [`SqlInfoData`] via the [`SqlInfoDataBuilder`],
+/// and build responses using [`CommandGetSqlInfo::into_builder`]
+#[derive(Debug, Clone, PartialEq)]
+pub struct SqlInfoDataBuilder {
+    /// Use BTreeMap to ensure the values are sorted by value as
+    /// to make output consistent
+    ///
+    /// Use u32 to support "custom" sql info values that are not
+    /// part of the SqlInfo enum
+    infos: BTreeMap<u32, SqlInfoValue>,
+}
+
+impl Default for SqlInfoDataBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl SqlInfoDataBuilder {
+    pub fn new() -> Self {
+        Self {
+            infos: BTreeMap::new(),
+        }
+    }
+
+    /// register the specific sql metadata item
+    pub fn append(&mut self, name: impl SqlInfoName, value: impl Into<SqlInfoValue>) {
+        self.infos.insert(name.as_u32(), value.into());
+    }
+
+    /// Encode the contents of this list according to the [FlightSQL spec]
+    ///
+    /// [FlightSQL spec]: (https://github.com/apache/arrow/blob/f9324b79bf4fc1ec7e97b32e3cce16e75ef0f5e3/format/FlightSql.proto#L32-L43
+    pub fn build(self) -> Result<SqlInfoData> {
+        let mut name_builder = UInt32Builder::new();
+        let mut value_builder = SqlInfoUnionBuilder::new();
+
+        let mut names: Vec<_> = self.infos.keys().cloned().collect();
+        names.sort_unstable();
+
+        for key in names {
+            let (name, value) = self.infos.get_key_value(&key).unwrap();
+            name_builder.append_value(*name);
+            value_builder.append_value(value)?
+        }
+
+        let batch = RecordBatch::try_from_iter(vec![
+            ("info_name", Arc::new(name_builder.finish()) as _),
+            ("value", Arc::new(value_builder.finish()) as _),
+        ])?;
+
+        Ok(SqlInfoData { batch })
+    }
+
+    /// Return the [`Schema`] for a GetSchema RPC call with [`crate::sql::CommandGetSqlInfo`]
+    pub fn schema() -> &'static Schema {
+        // It is always the same
+        &SQL_INFO_SCHEMA
+    }
+}
+
+/// A builder for [`SqlInfoData`] which is used to create [`CommandGetSqlInfo`] responses.
+///
+/// # Example
+/// ```
+/// # use arrow_flight::sql::{metadata::SqlInfoDataBuilder, SqlInfo, SqlSupportedTransaction};
+/// // Create the list of metadata describing the server
+/// let mut builder = SqlInfoDataBuilder::new();
+/// builder.append(SqlInfo::FlightSqlServerName, "server name");
+///     // ... add other SqlInfo here ..
+/// builder.append(
+///     SqlInfo::FlightSqlServerTransaction,
+///     SqlSupportedTransaction::Transaction as i32,
+/// );
+///
+/// // Create the batch to send back to the client
+/// let info_data = builder.build().unwrap();
+/// ```
+///
+/// [protos]: https://github.com/apache/arrow/blob/6d3d2fca2c9693231fa1e52c142ceef563fc23f9/format/FlightSql.proto#L71-L820
+pub struct SqlInfoData {
+    batch: RecordBatch,
+}
+
+impl SqlInfoData {
+    /// Return a  [`RecordBatch`] containing only the requested `u32`, if any
+    /// from [`CommandGetSqlInfo`]
+    pub fn record_batch(&self, info: impl IntoIterator<Item = u32>) -> Result<RecordBatch> {
+        let arr = self.batch.column(0);
+        let type_filter = info
+            .into_iter()
+            .map(|tt| {
+                let s = UInt32Array::from(vec![tt]);
+                eq(arr, &Scalar::new(&s))
+            })
+            .collect::<std::result::Result<Vec<_>, _>>()?
+            .into_iter()
+            // We know the arrays are of same length as they are produced from the same root array
+            .reduce(|filter, arr| or(&filter, &arr).unwrap());
+        if let Some(filter) = type_filter {
+            Ok(filter_record_batch(&self.batch, &filter)?)
+        } else {
+            Ok(self.batch.clone())
+        }
+    }
+
+    /// Return the schema of the RecordBatch that will be returned
+    /// from [`CommandGetSqlInfo`]
+    pub fn schema(&self) -> SchemaRef {
+        self.batch.schema()
+    }
+}
+
+/// A builder for a [`CommandGetSqlInfo`] response.
+pub struct GetSqlInfoBuilder<'a> {
+    /// requested `SqlInfo`s. If empty means return all infos.
+    info: Vec<u32>,
+    infos: &'a SqlInfoData,
+}
+
+impl CommandGetSqlInfo {
+    /// Create a builder suitable for constructing a response
+    pub fn into_builder(self, infos: &SqlInfoData) -> GetSqlInfoBuilder {
+        GetSqlInfoBuilder {
+            info: self.info,
+            infos,
+        }
+    }
+}
+
+impl GetSqlInfoBuilder<'_> {
+    /// Builds a `RecordBatch` with the correct schema for a [`CommandGetSqlInfo`] response
+    pub fn build(self) -> Result<RecordBatch> {
+        self.infos.record_batch(self.info)
+    }
+
+    /// Return the schema of the RecordBatch that will be returned
+    /// from [`CommandGetSqlInfo`]
+    pub fn schema(&self) -> SchemaRef {
+        self.infos.schema()
+    }
+}
+
+// The schema produced by [`SqlInfoData`]
+static SQL_INFO_SCHEMA: Lazy<Schema> = Lazy::new(|| {
+    Schema::new(vec![
+        Field::new("info_name", DataType::UInt32, false),
+        Field::new("value", SqlInfoUnionBuilder::schema().clone(), false),
+    ])
+});
+
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+
+    use super::SqlInfoDataBuilder;
+    use crate::sql::metadata::tests::assert_batches_eq;
+    use crate::sql::{SqlInfo, SqlNullOrdering, SqlSupportedTransaction, SqlSupportsConvert};
+
+    #[test]
+    fn test_sql_infos() {
+        let mut convert: HashMap<i32, Vec<i32>> = HashMap::new();
+        convert.insert(
+            SqlSupportsConvert::SqlConvertInteger as i32,
+            vec![
+                SqlSupportsConvert::SqlConvertFloat as i32,
+                SqlSupportsConvert::SqlConvertReal as i32,
+            ],
+        );
+
+        let mut builder = SqlInfoDataBuilder::new();
+        // str
+        builder.append(SqlInfo::SqlIdentifierQuoteChar, r#"""#);
+        // bool
+        builder.append(SqlInfo::SqlDdlCatalog, false);
+        // i32
+        builder.append(
+            SqlInfo::SqlNullOrdering,
+            SqlNullOrdering::SqlNullsSortedHigh as i32,
+        );
+        // i64
+        builder.append(SqlInfo::SqlMaxBinaryLiteralLength, i32::MAX as i64);
+        // [str]
+        builder.append(SqlInfo::SqlKeywords, &["SELECT", "DELETE"] as &[&str]);
+        builder.append(SqlInfo::SqlSupportsConvert, &convert);
+
+        let batch = builder.build().unwrap().record_batch(None).unwrap();
+
+        let expected = vec![
+            "+-----------+----------------------------------------+",
+            "| info_name | value                                  |",
+            "+-----------+----------------------------------------+",
+            "| 500       | {bool_value=false}                     |",
+            "| 504       | {string_value=\"}                       |",
+            "| 507       | {int32_bitmask=0}                      |",
+            "| 508       | {string_list=[SELECT, DELETE]}         |",
+            "| 517       | {int32_to_int32_list_map={7: [6, 13]}} |",
+            "| 541       | {bigint_value=2147483647}              |",
+            "+-----------+----------------------------------------+",
+        ];
+
+        assert_batches_eq(&[batch], &expected);
+    }
+
+    #[test]
+    fn test_filter_sql_infos() {
+        let mut builder = SqlInfoDataBuilder::new();
+        builder.append(SqlInfo::FlightSqlServerName, "server name");
+        builder.append(
+            SqlInfo::FlightSqlServerTransaction,
+            SqlSupportedTransaction::Transaction as i32,
+        );
+        let data = builder.build().unwrap();
+
+        let batch = data.record_batch(None).unwrap();
+        assert_eq!(batch.num_rows(), 2);
+
+        let batch = data
+            .record_batch([SqlInfo::FlightSqlServerTransaction as u32])
+            .unwrap();
+        let mut ref_builder = SqlInfoDataBuilder::new();
+        ref_builder.append(
+            SqlInfo::FlightSqlServerTransaction,
+            SqlSupportedTransaction::Transaction as i32,
+        );
+        let ref_batch = ref_builder.build().unwrap().record_batch(None).unwrap();
+
+        assert_eq!(batch, ref_batch);
+    }
+}
diff --git a/arrow-flight/src/sql/metadata/tables.rs b/arrow-flight/src/sql/metadata/tables.rs
new file mode 100644
index 000000000000..7ffb76fa1d5f
--- /dev/null
+++ b/arrow-flight/src/sql/metadata/tables.rs
@@ -0,0 +1,476 @@
+// 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.
+
+//! [`GetTablesBuilder`] for building responses to [`CommandGetTables`] queries.
+//!
+//! [`CommandGetTables`]: crate::sql::CommandGetTables
+
+use std::sync::Arc;
+
+use arrow_arith::boolean::{and, or};
+use arrow_array::builder::{BinaryBuilder, StringBuilder};
+use arrow_array::{ArrayRef, RecordBatch, StringArray};
+use arrow_ord::cmp::eq;
+use arrow_schema::{DataType, Field, Schema, SchemaRef};
+use arrow_select::{filter::filter_record_batch, take::take};
+use arrow_string::like::like;
+use once_cell::sync::Lazy;
+
+use super::lexsort_to_indices;
+use crate::error::*;
+use crate::sql::CommandGetTables;
+use crate::{IpcMessage, IpcWriteOptions, SchemaAsIpc};
+
+/// A builder for a [`CommandGetTables`] response.
+///
+/// Builds rows like this:
+///
+/// * catalog_name: utf8,
+/// * db_schema_name: utf8,
+/// * table_name: utf8 not null,
+/// * table_type: utf8 not null,
+/// * (optional) table_schema: bytes not null (schema of the table as described
+///   in Schema.fbs::Schema it is serialized as an IPC message.)
+pub struct GetTablesBuilder {
+    catalog_filter: Option<String>,
+    table_types_filter: Vec<String>,
+    // Optional filters to apply to schemas
+    db_schema_filter_pattern: Option<String>,
+    // Optional filters to apply to tables
+    table_name_filter_pattern: Option<String>,
+    // array builder for catalog names
+    catalog_name: StringBuilder,
+    // array builder for db schema names
+    db_schema_name: StringBuilder,
+    // array builder for tables names
+    table_name: StringBuilder,
+    // array builder for table types
+    table_type: StringBuilder,
+    // array builder for table schemas
+    table_schema: Option<BinaryBuilder>,
+}
+
+impl CommandGetTables {
+    /// Create a builder suitable for constructing a response
+    pub fn into_builder(self) -> GetTablesBuilder {
+        self.into()
+    }
+}
+
+impl From<CommandGetTables> for GetTablesBuilder {
+    fn from(value: CommandGetTables) -> Self {
+        Self::new(
+            value.catalog,
+            value.db_schema_filter_pattern,
+            value.table_name_filter_pattern,
+            value.table_types,
+            value.include_schema,
+        )
+    }
+}
+
+impl GetTablesBuilder {
+    /// Create a new instance of [`GetTablesBuilder`]
+    ///
+    /// # Parameters
+    ///
+    /// - `catalog`:  Specifies the Catalog to search for the tables.
+    ///   - An empty string retrieves those without a catalog.
+    ///   - If omitted the catalog name is not used to narrow the search.
+    /// - `db_schema_filter_pattern`: Specifies a filter pattern for schemas to search for.
+    ///   When no pattern is provided, the pattern will not be used to narrow the search.
+    ///   In the pattern string, two special characters can be used to denote matching rules:
+    ///     - "%" means to match any substring with 0 or more characters.
+    ///     - "_" means to match any one character.
+    /// - `table_name_filter_pattern`: Specifies a filter pattern for tables to search for.
+    ///   When no pattern is provided, all tables matching other filters are searched.
+    ///   In the pattern string, two special characters can be used to denote matching rules:
+    ///     - "%" means to match any substring with 0 or more characters.
+    ///     - "_" means to match any one character.
+    /// - `table_types`:  Specifies a filter of table types which must match.
+    ///   An empy Vec matches all table types.
+    /// - `include_schema`: Specifies if the Arrow schema should be returned for found tables.
+    ///
+    /// [`CommandGetTables`]: crate::sql::CommandGetTables
+    pub fn new(
+        catalog: Option<impl Into<String>>,
+        db_schema_filter_pattern: Option<impl Into<String>>,
+        table_name_filter_pattern: Option<impl Into<String>>,
+        table_types: impl IntoIterator<Item = impl Into<String>>,
+        include_schema: bool,
+    ) -> Self {
+        let table_schema = if include_schema {
+            Some(BinaryBuilder::new())
+        } else {
+            None
+        };
+        Self {
+            catalog_filter: catalog.map(|s| s.into()),
+            table_types_filter: table_types.into_iter().map(|tt| tt.into()).collect(),
+            db_schema_filter_pattern: db_schema_filter_pattern.map(|s| s.into()),
+            table_name_filter_pattern: table_name_filter_pattern.map(|t| t.into()),
+            catalog_name: StringBuilder::new(),
+            db_schema_name: StringBuilder::new(),
+            table_name: StringBuilder::new(),
+            table_type: StringBuilder::new(),
+            table_schema,
+        }
+    }
+
+    /// Append a row
+    pub fn append(
+        &mut self,
+        catalog_name: impl AsRef<str>,
+        schema_name: impl AsRef<str>,
+        table_name: impl AsRef<str>,
+        table_type: impl AsRef<str>,
+        table_schema: &Schema,
+    ) -> Result<()> {
+        self.catalog_name.append_value(catalog_name);
+        self.db_schema_name.append_value(schema_name);
+        self.table_name.append_value(table_name);
+        self.table_type.append_value(table_type);
+        if let Some(self_table_schema) = self.table_schema.as_mut() {
+            let options = IpcWriteOptions::default();
+            // encode the schema into the correct form
+            let message: std::result::Result<IpcMessage, _> =
+                SchemaAsIpc::new(table_schema, &options).try_into();
+            let IpcMessage(schema) = message?;
+            self_table_schema.append_value(schema);
+        }
+
+        Ok(())
+    }
+
+    /// builds a `RecordBatch` for `CommandGetTables`
+    pub fn build(self) -> Result<RecordBatch> {
+        let schema = self.schema();
+        let Self {
+            catalog_filter,
+            table_types_filter,
+            db_schema_filter_pattern,
+            table_name_filter_pattern,
+
+            mut catalog_name,
+            mut db_schema_name,
+            mut table_name,
+            mut table_type,
+            table_schema,
+        } = self;
+
+        // Make the arrays
+        let catalog_name = catalog_name.finish();
+        let db_schema_name = db_schema_name.finish();
+        let table_name = table_name.finish();
+        let table_type = table_type.finish();
+        let table_schema = table_schema.map(|mut table_schema| table_schema.finish());
+
+        // apply any filters, getting a BooleanArray that represents
+        // the rows that passed the filter
+        let mut filters = vec![];
+
+        if let Some(catalog_filter_name) = catalog_filter {
+            let scalar = StringArray::new_scalar(catalog_filter_name);
+            filters.push(eq(&catalog_name, &scalar)?);
+        }
+
+        let tt_filter = table_types_filter
+            .into_iter()
+            .map(|tt| eq(&table_type, &StringArray::new_scalar(tt)))
+            .collect::<std::result::Result<Vec<_>, _>>()?
+            .into_iter()
+            // We know the arrays are of same length as they are produced fromn the same root array
+            .reduce(|filter, arr| or(&filter, &arr).unwrap());
+        if let Some(filter) = tt_filter {
+            filters.push(filter);
+        }
+
+        if let Some(db_schema_filter_pattern) = db_schema_filter_pattern {
+            // use like kernel to get wildcard matching
+            let scalar = StringArray::new_scalar(db_schema_filter_pattern);
+            filters.push(like(&db_schema_name, &scalar)?)
+        }
+
+        if let Some(table_name_filter_pattern) = table_name_filter_pattern {
+            // use like kernel to get wildcard matching
+            let scalar = StringArray::new_scalar(table_name_filter_pattern);
+            filters.push(like(&table_name, &scalar)?)
+        }
+
+        let batch = if let Some(table_schema) = table_schema {
+            RecordBatch::try_new(
+                schema,
+                vec![
+                    Arc::new(catalog_name) as ArrayRef,
+                    Arc::new(db_schema_name) as ArrayRef,
+                    Arc::new(table_name) as ArrayRef,
+                    Arc::new(table_type) as ArrayRef,
+                    Arc::new(table_schema) as ArrayRef,
+                ],
+            )
+        } else {
+            RecordBatch::try_new(
+                // schema is different if table_schema is none
+                schema,
+                vec![
+                    Arc::new(catalog_name) as ArrayRef,
+                    Arc::new(db_schema_name) as ArrayRef,
+                    Arc::new(table_name) as ArrayRef,
+                    Arc::new(table_type) as ArrayRef,
+                ],
+            )
+        }?;
+
+        // `AND` any filters together
+        let mut total_filter = None;
+        while let Some(filter) = filters.pop() {
+            let new_filter = match total_filter {
+                Some(total_filter) => and(&total_filter, &filter)?,
+                None => filter,
+            };
+            total_filter = Some(new_filter);
+        }
+
+        // Apply the filters if needed
+        let filtered_batch = if let Some(total_filter) = total_filter {
+            filter_record_batch(&batch, &total_filter)?
+        } else {
+            batch
+        };
+
+        // Order filtered results by catalog_name, then db_schema_name, then table_name, then table_type
+        // https://github.com/apache/arrow/blob/130f9e981aa98c25de5f5bfe55185db270cec313/format/FlightSql.proto#LL1202C1-L1202C1
+        let sort_cols = filtered_batch.project(&[0, 1, 2, 3])?;
+        let indices = lexsort_to_indices(sort_cols.columns());
+        let columns = filtered_batch
+            .columns()
+            .iter()
+            .map(|c| take(c, &indices, None))
+            .collect::<std::result::Result<Vec<_>, _>>()?;
+
+        Ok(RecordBatch::try_new(filtered_batch.schema(), columns)?)
+    }
+
+    /// Return the schema of the RecordBatch that will be returned from [`CommandGetTables`]
+    ///
+    /// Note the schema differs based on the values of `include_schema
+    ///
+    /// [`CommandGetTables`]: crate::sql::CommandGetTables
+    pub fn schema(&self) -> SchemaRef {
+        get_tables_schema(self.include_schema())
+    }
+
+    /// Should the "schema" column be included
+    pub fn include_schema(&self) -> bool {
+        self.table_schema.is_some()
+    }
+}
+
+fn get_tables_schema(include_schema: bool) -> SchemaRef {
+    if include_schema {
+        Arc::clone(&GET_TABLES_SCHEMA_WITH_TABLE_SCHEMA)
+    } else {
+        Arc::clone(&GET_TABLES_SCHEMA_WITHOUT_TABLE_SCHEMA)
+    }
+}
+
+/// The schema for GetTables without `table_schema` column
+static GET_TABLES_SCHEMA_WITHOUT_TABLE_SCHEMA: Lazy<SchemaRef> = Lazy::new(|| {
+    Arc::new(Schema::new(vec![
+        Field::new("catalog_name", DataType::Utf8, false),
+        Field::new("db_schema_name", DataType::Utf8, false),
+        Field::new("table_name", DataType::Utf8, false),
+        Field::new("table_type", DataType::Utf8, false),
+    ]))
+});
+
+/// The schema for GetTables with `table_schema` column
+static GET_TABLES_SCHEMA_WITH_TABLE_SCHEMA: Lazy<SchemaRef> = Lazy::new(|| {
+    Arc::new(Schema::new(vec![
+        Field::new("catalog_name", DataType::Utf8, false),
+        Field::new("db_schema_name", DataType::Utf8, false),
+        Field::new("table_name", DataType::Utf8, false),
+        Field::new("table_type", DataType::Utf8, false),
+        Field::new("table_schema", DataType::Binary, false),
+    ]))
+});
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::{StringArray, UInt32Array};
+
+    fn get_ref_batch() -> RecordBatch {
+        RecordBatch::try_new(
+            get_tables_schema(false),
+            vec![
+                Arc::new(StringArray::from(vec![
+                    "a_catalog",
+                    "a_catalog",
+                    "a_catalog",
+                    "a_catalog",
+                    "b_catalog",
+                    "b_catalog",
+                    "b_catalog",
+                    "b_catalog",
+                ])) as ArrayRef,
+                Arc::new(StringArray::from(vec![
+                    "a_schema", "a_schema", "b_schema", "b_schema", "a_schema", "a_schema",
+                    "b_schema", "b_schema",
+                ])) as ArrayRef,
+                Arc::new(StringArray::from(vec![
+                    "a_table", "b_table", "a_table", "b_table", "a_table", "a_table", "b_table",
+                    "b_table",
+                ])) as ArrayRef,
+                Arc::new(StringArray::from(vec![
+                    "TABLE", "TABLE", "TABLE", "TABLE", "TABLE", "VIEW", "TABLE", "VIEW",
+                ])) as ArrayRef,
+            ],
+        )
+        .unwrap()
+    }
+
+    fn get_ref_builder(
+        catalog: Option<&str>,
+        db_schema_filter_pattern: Option<&str>,
+        table_name_filter_pattern: Option<&str>,
+        table_types: Vec<&str>,
+        include_schema: bool,
+    ) -> GetTablesBuilder {
+        let dummy_schema = Schema::empty();
+        let tables = [
+            ("a_catalog", "a_schema", "a_table", "TABLE"),
+            ("a_catalog", "a_schema", "b_table", "TABLE"),
+            ("a_catalog", "b_schema", "a_table", "TABLE"),
+            ("a_catalog", "b_schema", "b_table", "TABLE"),
+            ("b_catalog", "a_schema", "a_table", "TABLE"),
+            ("b_catalog", "a_schema", "a_table", "VIEW"),
+            ("b_catalog", "b_schema", "b_table", "TABLE"),
+            ("b_catalog", "b_schema", "b_table", "VIEW"),
+        ];
+        let mut builder = GetTablesBuilder::new(
+            catalog,
+            db_schema_filter_pattern,
+            table_name_filter_pattern,
+            table_types,
+            include_schema,
+        );
+        for (catalog_name, schema_name, table_name, table_type) in tables {
+            builder
+                .append(
+                    catalog_name,
+                    schema_name,
+                    table_name,
+                    table_type,
+                    &dummy_schema,
+                )
+                .unwrap();
+        }
+        builder
+    }
+
+    #[test]
+    fn test_tables_are_filtered() {
+        let ref_batch = get_ref_batch();
+
+        let builder = get_ref_builder(None, None, None, Vec::new(), false);
+        let table_batch = builder.build().unwrap();
+        assert_eq!(table_batch, ref_batch);
+
+        let builder = get_ref_builder(None, Some("a%"), Some("a%"), Vec::new(), false);
+        let table_batch = builder.build().unwrap();
+        let indices = UInt32Array::from(vec![0, 4, 5]);
+        let ref_filtered = RecordBatch::try_new(
+            get_tables_schema(false),
+            ref_batch
+                .columns()
+                .iter()
+                .map(|c| take(c, &indices, None))
+                .collect::<std::result::Result<Vec<_>, _>>()
+                .unwrap(),
+        )
+        .unwrap();
+        assert_eq!(table_batch, ref_filtered);
+
+        let builder = get_ref_builder(Some("a_catalog"), None, None, Vec::new(), false);
+        let table_batch = builder.build().unwrap();
+        let indices = UInt32Array::from(vec![0, 1, 2, 3]);
+        let ref_filtered = RecordBatch::try_new(
+            get_tables_schema(false),
+            ref_batch
+                .columns()
+                .iter()
+                .map(|c| take(c, &indices, None))
+                .collect::<std::result::Result<Vec<_>, _>>()
+                .unwrap(),
+        )
+        .unwrap();
+        assert_eq!(table_batch, ref_filtered);
+
+        let builder = get_ref_builder(None, None, None, vec!["VIEW"], false);
+        let table_batch = builder.build().unwrap();
+        let indices = UInt32Array::from(vec![5, 7]);
+        let ref_filtered = RecordBatch::try_new(
+            get_tables_schema(false),
+            ref_batch
+                .columns()
+                .iter()
+                .map(|c| take(c, &indices, None))
+                .collect::<std::result::Result<Vec<_>, _>>()
+                .unwrap(),
+        )
+        .unwrap();
+        assert_eq!(table_batch, ref_filtered);
+    }
+
+    #[test]
+    fn test_tables_are_sorted() {
+        let ref_batch = get_ref_batch();
+        let dummy_schema = Schema::empty();
+
+        let tables = [
+            ("b_catalog", "a_schema", "a_table", "TABLE"),
+            ("b_catalog", "b_schema", "b_table", "TABLE"),
+            ("b_catalog", "b_schema", "b_table", "VIEW"),
+            ("b_catalog", "a_schema", "a_table", "VIEW"),
+            ("a_catalog", "a_schema", "a_table", "TABLE"),
+            ("a_catalog", "b_schema", "a_table", "TABLE"),
+            ("a_catalog", "b_schema", "b_table", "TABLE"),
+            ("a_catalog", "a_schema", "b_table", "TABLE"),
+        ];
+        let mut builder = GetTablesBuilder::new(
+            None::<String>,
+            None::<String>,
+            None::<String>,
+            None::<String>,
+            false,
+        );
+        for (catalog_name, schema_name, table_name, table_type) in tables {
+            builder
+                .append(
+                    catalog_name,
+                    schema_name,
+                    table_name,
+                    table_type,
+                    &dummy_schema,
+                )
+                .unwrap();
+        }
+        let table_batch = builder.build().unwrap();
+        assert_eq!(table_batch, ref_batch);
+    }
+}
diff --git a/arrow-flight/src/sql/metadata/xdbc_info.rs b/arrow-flight/src/sql/metadata/xdbc_info.rs
new file mode 100644
index 000000000000..2e635d3037bc
--- /dev/null
+++ b/arrow-flight/src/sql/metadata/xdbc_info.rs
@@ -0,0 +1,428 @@
+// 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.
+
+//! Helpers for [`CommandGetXdbcTypeInfo`] metadata requests.
+//!
+//! - [`XdbcTypeInfo`] - a typed struct that holds the xdbc info corresponding to expected schema.
+//! - [`XdbcTypeInfoDataBuilder`] - a builder for collecting type infos
+//!   and building a conformant `RecordBatch`.
+//! - [`XdbcTypeInfoData`] - a helper type wrapping a `RecordBatch`
+//!   used for storing xdbc server metadata.
+//! - [`GetXdbcTypeInfoBuilder`] - a builder for consructing [`CommandGetXdbcTypeInfo`] responses.
+//!
+use std::sync::Arc;
+
+use arrow_array::builder::{BooleanBuilder, Int32Builder, ListBuilder, StringBuilder};
+use arrow_array::{ArrayRef, Int32Array, ListArray, RecordBatch, Scalar};
+use arrow_ord::cmp::eq;
+use arrow_schema::{DataType, Field, Schema, SchemaRef};
+use arrow_select::filter::filter_record_batch;
+use arrow_select::take::take;
+use once_cell::sync::Lazy;
+
+use super::lexsort_to_indices;
+use crate::error::*;
+use crate::sql::{CommandGetXdbcTypeInfo, Nullable, Searchable, XdbcDataType, XdbcDatetimeSubcode};
+
+/// Data structure representing type information for xdbc types.
+#[derive(Debug, Clone, Default)]
+pub struct XdbcTypeInfo {
+    pub type_name: String,
+    pub data_type: XdbcDataType,
+    pub column_size: Option<i32>,
+    pub literal_prefix: Option<String>,
+    pub literal_suffix: Option<String>,
+    pub create_params: Option<Vec<String>>,
+    pub nullable: Nullable,
+    pub case_sensitive: bool,
+    pub searchable: Searchable,
+    pub unsigned_attribute: Option<bool>,
+    pub fixed_prec_scale: bool,
+    pub auto_increment: Option<bool>,
+    pub local_type_name: Option<String>,
+    pub minimum_scale: Option<i32>,
+    pub maximum_scale: Option<i32>,
+    pub sql_data_type: XdbcDataType,
+    pub datetime_subcode: Option<XdbcDatetimeSubcode>,
+    pub num_prec_radix: Option<i32>,
+    pub interval_precision: Option<i32>,
+}
+
+/// Helper to create [`CommandGetXdbcTypeInfo`] responses.
+///
+/// [`CommandGetXdbcTypeInfo`] are metadata requests used by a Flight SQL
+/// server to communicate supported capabilities to Flight SQL clients.
+///
+/// Servers constuct - usually static - [`XdbcTypeInfoData`] via the [`XdbcTypeInfoDataBuilder`],
+/// and build responses using [`CommandGetXdbcTypeInfo::into_builder`].
+pub struct XdbcTypeInfoData {
+    batch: RecordBatch,
+}
+
+impl XdbcTypeInfoData {
+    /// Return the raw (not encoded) RecordBatch that will be returned
+    /// from [`CommandGetXdbcTypeInfo`]
+    pub fn record_batch(&self, data_type: impl Into<Option<i32>>) -> Result<RecordBatch> {
+        if let Some(dt) = data_type.into() {
+            let scalar = Int32Array::from(vec![dt]);
+            let filter = eq(self.batch.column(1), &Scalar::new(&scalar))?;
+            Ok(filter_record_batch(&self.batch, &filter)?)
+        } else {
+            Ok(self.batch.clone())
+        }
+    }
+
+    /// Return the schema of the RecordBatch that will be returned
+    /// from [`CommandGetXdbcTypeInfo`]
+    pub fn schema(&self) -> SchemaRef {
+        self.batch.schema()
+    }
+}
+
+pub struct XdbcTypeInfoDataBuilder {
+    infos: Vec<XdbcTypeInfo>,
+}
+
+impl Default for XdbcTypeInfoDataBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+/// A builder for [`XdbcTypeInfoData`] which is used to create [`CommandGetXdbcTypeInfo`] responses.
+///
+/// # Example
+/// ```
+/// use arrow_flight::sql::{Nullable, Searchable, XdbcDataType};
+/// use arrow_flight::sql::metadata::{XdbcTypeInfo, XdbcTypeInfoDataBuilder};
+/// // Create the list of metadata describing the server. Since this would not change at
+/// // runtime, using once_cell::Lazy or similar patterns to constuct the list is a common approach.
+/// let mut builder = XdbcTypeInfoDataBuilder::new();
+/// builder.append(XdbcTypeInfo {
+///     type_name: "INTEGER".into(),
+///     data_type: XdbcDataType::XdbcInteger,
+///     column_size: Some(32),
+///     literal_prefix: None,
+///     literal_suffix: None,
+///     create_params: None,
+///     nullable: Nullable::NullabilityNullable,
+///     case_sensitive: false,
+///     searchable: Searchable::Full,
+///     unsigned_attribute: Some(false),
+///     fixed_prec_scale: false,
+///     auto_increment: Some(false),
+///     local_type_name: Some("INTEGER".into()),
+///     minimum_scale: None,
+///     maximum_scale: None,
+///     sql_data_type: XdbcDataType::XdbcInteger,
+///     datetime_subcode: None,
+///     num_prec_radix: Some(2),
+///     interval_precision: None,
+/// });
+/// let info_list = builder.build().unwrap();
+///
+/// // to access the underlying record batch
+/// let batch = info_list.record_batch(None);
+/// ```
+impl XdbcTypeInfoDataBuilder {
+    /// Create a new instance of [`XdbcTypeInfoDataBuilder`].
+    pub fn new() -> Self {
+        Self { infos: Vec::new() }
+    }
+
+    /// Append a new row
+    pub fn append(&mut self, info: XdbcTypeInfo) {
+        self.infos.push(info);
+    }
+
+    /// Create helper structure for handling xdbc metadata requests.
+    pub fn build(self) -> Result<XdbcTypeInfoData> {
+        let mut type_name_builder = StringBuilder::new();
+        let mut data_type_builder = Int32Builder::new();
+        let mut column_size_builder = Int32Builder::new();
+        let mut literal_prefix_builder = StringBuilder::new();
+        let mut literal_suffix_builder = StringBuilder::new();
+        let mut create_params_builder = ListBuilder::new(StringBuilder::new());
+        let mut nullable_builder = Int32Builder::new();
+        let mut case_sensitive_builder = BooleanBuilder::new();
+        let mut searchable_builder = Int32Builder::new();
+        let mut unsigned_attribute_builder = BooleanBuilder::new();
+        let mut fixed_prec_scale_builder = BooleanBuilder::new();
+        let mut auto_increment_builder = BooleanBuilder::new();
+        let mut local_type_name_builder = StringBuilder::new();
+        let mut minimum_scale_builder = Int32Builder::new();
+        let mut maximum_scale_builder = Int32Builder::new();
+        let mut sql_data_type_builder = Int32Builder::new();
+        let mut datetime_subcode_builder = Int32Builder::new();
+        let mut num_prec_radix_builder = Int32Builder::new();
+        let mut interval_precision_builder = Int32Builder::new();
+
+        self.infos.into_iter().for_each(|info| {
+            type_name_builder.append_value(info.type_name);
+            data_type_builder.append_value(info.data_type as i32);
+            column_size_builder.append_option(info.column_size);
+            literal_prefix_builder.append_option(info.literal_prefix);
+            literal_suffix_builder.append_option(info.literal_suffix);
+            if let Some(params) = info.create_params {
+                if !params.is_empty() {
+                    for param in params {
+                        create_params_builder.values().append_value(param);
+                    }
+                    create_params_builder.append(true);
+                } else {
+                    create_params_builder.append_null();
+                }
+            } else {
+                create_params_builder.append_null();
+            }
+            nullable_builder.append_value(info.nullable as i32);
+            case_sensitive_builder.append_value(info.case_sensitive);
+            searchable_builder.append_value(info.searchable as i32);
+            unsigned_attribute_builder.append_option(info.unsigned_attribute);
+            fixed_prec_scale_builder.append_value(info.fixed_prec_scale);
+            auto_increment_builder.append_option(info.auto_increment);
+            local_type_name_builder.append_option(info.local_type_name);
+            minimum_scale_builder.append_option(info.minimum_scale);
+            maximum_scale_builder.append_option(info.maximum_scale);
+            sql_data_type_builder.append_value(info.sql_data_type as i32);
+            datetime_subcode_builder.append_option(info.datetime_subcode.map(|code| code as i32));
+            num_prec_radix_builder.append_option(info.num_prec_radix);
+            interval_precision_builder.append_option(info.interval_precision);
+        });
+
+        let type_name = Arc::new(type_name_builder.finish());
+        let data_type = Arc::new(data_type_builder.finish());
+        let column_size = Arc::new(column_size_builder.finish());
+        let literal_prefix = Arc::new(literal_prefix_builder.finish());
+        let literal_suffix = Arc::new(literal_suffix_builder.finish());
+        let (field, offsets, values, nulls) = create_params_builder.finish().into_parts();
+        // Re-defined the field to be non-nullable
+        let new_field = Arc::new(field.as_ref().clone().with_nullable(false));
+        let create_params = Arc::new(ListArray::new(new_field, offsets, values, nulls)) as ArrayRef;
+        let nullable = Arc::new(nullable_builder.finish());
+        let case_sensitive = Arc::new(case_sensitive_builder.finish());
+        let searchable = Arc::new(searchable_builder.finish());
+        let unsigned_attribute = Arc::new(unsigned_attribute_builder.finish());
+        let fixed_prec_scale = Arc::new(fixed_prec_scale_builder.finish());
+        let auto_increment = Arc::new(auto_increment_builder.finish());
+        let local_type_name = Arc::new(local_type_name_builder.finish());
+        let minimum_scale = Arc::new(minimum_scale_builder.finish());
+        let maximum_scale = Arc::new(maximum_scale_builder.finish());
+        let sql_data_type = Arc::new(sql_data_type_builder.finish());
+        let datetime_subcode = Arc::new(datetime_subcode_builder.finish());
+        let num_prec_radix = Arc::new(num_prec_radix_builder.finish());
+        let interval_precision = Arc::new(interval_precision_builder.finish());
+
+        let batch = RecordBatch::try_new(
+            Arc::clone(&GET_XDBC_INFO_SCHEMA),
+            vec![
+                type_name,
+                data_type,
+                column_size,
+                literal_prefix,
+                literal_suffix,
+                create_params,
+                nullable,
+                case_sensitive,
+                searchable,
+                unsigned_attribute,
+                fixed_prec_scale,
+                auto_increment,
+                local_type_name,
+                minimum_scale,
+                maximum_scale,
+                sql_data_type,
+                datetime_subcode,
+                num_prec_radix,
+                interval_precision,
+            ],
+        )?;
+
+        // Order batch by data_type and then by type_name
+        let sort_cols = batch.project(&[1, 0])?;
+        let indices = lexsort_to_indices(sort_cols.columns());
+        let columns = batch
+            .columns()
+            .iter()
+            .map(|c| take(c, &indices, None))
+            .collect::<std::result::Result<Vec<_>, _>>()?;
+
+        Ok(XdbcTypeInfoData {
+            batch: RecordBatch::try_new(batch.schema(), columns)?,
+        })
+    }
+
+    /// Return the [`Schema`] for a GetSchema RPC call with [`CommandGetXdbcTypeInfo`]
+    pub fn schema(&self) -> SchemaRef {
+        Arc::clone(&GET_XDBC_INFO_SCHEMA)
+    }
+}
+
+/// A builder for a [`CommandGetXdbcTypeInfo`] response.
+pub struct GetXdbcTypeInfoBuilder<'a> {
+    data_type: Option<i32>,
+    infos: &'a XdbcTypeInfoData,
+}
+
+impl CommandGetXdbcTypeInfo {
+    /// Create a builder suitable for constructing a response
+    pub fn into_builder(self, infos: &XdbcTypeInfoData) -> GetXdbcTypeInfoBuilder {
+        GetXdbcTypeInfoBuilder {
+            data_type: self.data_type,
+            infos,
+        }
+    }
+}
+
+impl GetXdbcTypeInfoBuilder<'_> {
+    /// Builds a `RecordBatch` with the correct schema for a [`CommandGetXdbcTypeInfo`] response
+    pub fn build(self) -> Result<RecordBatch> {
+        self.infos.record_batch(self.data_type)
+    }
+
+    /// Return the schema of the RecordBatch that will be returned
+    /// from [`CommandGetXdbcTypeInfo`]
+    pub fn schema(&self) -> SchemaRef {
+        self.infos.schema()
+    }
+}
+
+/// The schema for GetXdbcTypeInfo
+static GET_XDBC_INFO_SCHEMA: Lazy<SchemaRef> = Lazy::new(|| {
+    Arc::new(Schema::new(vec![
+        Field::new("type_name", DataType::Utf8, false),
+        Field::new("data_type", DataType::Int32, false),
+        Field::new("column_size", DataType::Int32, true),
+        Field::new("literal_prefix", DataType::Utf8, true),
+        Field::new("literal_suffix", DataType::Utf8, true),
+        Field::new(
+            "create_params",
+            DataType::List(Arc::new(Field::new("item", DataType::Utf8, false))),
+            true,
+        ),
+        Field::new("nullable", DataType::Int32, false),
+        Field::new("case_sensitive", DataType::Boolean, false),
+        Field::new("searchable", DataType::Int32, false),
+        Field::new("unsigned_attribute", DataType::Boolean, true),
+        Field::new("fixed_prec_scale", DataType::Boolean, false),
+        Field::new("auto_increment", DataType::Boolean, true),
+        Field::new("local_type_name", DataType::Utf8, true),
+        Field::new("minimum_scale", DataType::Int32, true),
+        Field::new("maximum_scale", DataType::Int32, true),
+        Field::new("sql_data_type", DataType::Int32, false),
+        Field::new("datetime_subcode", DataType::Int32, true),
+        Field::new("num_prec_radix", DataType::Int32, true),
+        Field::new("interval_precision", DataType::Int32, true),
+    ]))
+});
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::sql::metadata::tests::assert_batches_eq;
+
+    #[test]
+    fn test_create_batch() {
+        let mut builder = XdbcTypeInfoDataBuilder::new();
+        builder.append(XdbcTypeInfo {
+            type_name: "VARCHAR".into(),
+            data_type: XdbcDataType::XdbcVarchar,
+            column_size: Some(i32::MAX),
+            literal_prefix: Some("'".into()),
+            literal_suffix: Some("'".into()),
+            create_params: Some(vec!["length".into()]),
+            nullable: Nullable::NullabilityNullable,
+            case_sensitive: true,
+            searchable: Searchable::Full,
+            unsigned_attribute: None,
+            fixed_prec_scale: false,
+            auto_increment: None,
+            local_type_name: Some("VARCHAR".into()),
+            minimum_scale: None,
+            maximum_scale: None,
+            sql_data_type: XdbcDataType::XdbcVarchar,
+            datetime_subcode: None,
+            num_prec_radix: None,
+            interval_precision: None,
+        });
+        builder.append(XdbcTypeInfo {
+            type_name: "INTEGER".into(),
+            data_type: XdbcDataType::XdbcInteger,
+            column_size: Some(32),
+            literal_prefix: None,
+            literal_suffix: None,
+            create_params: None,
+            nullable: Nullable::NullabilityNullable,
+            case_sensitive: false,
+            searchable: Searchable::Full,
+            unsigned_attribute: Some(false),
+            fixed_prec_scale: false,
+            auto_increment: Some(false),
+            local_type_name: Some("INTEGER".into()),
+            minimum_scale: None,
+            maximum_scale: None,
+            sql_data_type: XdbcDataType::XdbcInteger,
+            datetime_subcode: None,
+            num_prec_radix: Some(2),
+            interval_precision: None,
+        });
+        builder.append(XdbcTypeInfo {
+            type_name: "INTERVAL".into(),
+            data_type: XdbcDataType::XdbcInterval,
+            column_size: Some(i32::MAX),
+            literal_prefix: Some("'".into()),
+            literal_suffix: Some("'".into()),
+            create_params: None,
+            nullable: Nullable::NullabilityNullable,
+            case_sensitive: false,
+            searchable: Searchable::Full,
+            unsigned_attribute: None,
+            fixed_prec_scale: false,
+            auto_increment: None,
+            local_type_name: Some("INTERVAL".into()),
+            minimum_scale: None,
+            maximum_scale: None,
+            sql_data_type: XdbcDataType::XdbcInterval,
+            datetime_subcode: Some(XdbcDatetimeSubcode::XdbcSubcodeUnknown),
+            num_prec_radix: None,
+            interval_precision: None,
+        });
+        let infos = builder.build().unwrap();
+
+        let batch = infos.record_batch(None).unwrap();
+        let expected = vec![
+            "+-----------+-----------+-------------+----------------+----------------+---------------+----------+----------------+------------+--------------------+------------------+----------------+-----------------+---------------+---------------+---------------+------------------+----------------+--------------------+",
+            "| type_name | data_type | column_size | literal_prefix | literal_suffix | create_params | nullable | case_sensitive | searchable | unsigned_attribute | fixed_prec_scale | auto_increment | local_type_name | minimum_scale | maximum_scale | sql_data_type | datetime_subcode | num_prec_radix | interval_precision |",
+            "+-----------+-----------+-------------+----------------+----------------+---------------+----------+----------------+------------+--------------------+------------------+----------------+-----------------+---------------+---------------+---------------+------------------+----------------+--------------------+",
+            "| INTEGER   | 4         | 32          |                |                |               | 1        | false          | 3          | false              | false            | false          | INTEGER         |               |               | 4             |                  | 2              |                    |",
+            "| INTERVAL  | 10        | 2147483647  | '              | '              |               | 1        | false          | 3          |                    | false            |                | INTERVAL        |               |               | 10            | 0                |                |                    |",
+            "| VARCHAR   | 12        | 2147483647  | '              | '              | [length]      | 1        | true           | 3          |                    | false            |                | VARCHAR         |               |               | 12            |                  |                |                    |",
+            "+-----------+-----------+-------------+----------------+----------------+---------------+----------+----------------+------------+--------------------+------------------+----------------+-----------------+---------------+---------------+---------------+------------------+----------------+--------------------+",
+        ];
+        assert_batches_eq(&[batch], &expected);
+
+        let batch = infos.record_batch(Some(10)).unwrap();
+        let expected = vec![
+            "+-----------+-----------+-------------+----------------+----------------+---------------+----------+----------------+------------+--------------------+------------------+----------------+-----------------+---------------+---------------+---------------+------------------+----------------+--------------------+",
+            "| type_name | data_type | column_size | literal_prefix | literal_suffix | create_params | nullable | case_sensitive | searchable | unsigned_attribute | fixed_prec_scale | auto_increment | local_type_name | minimum_scale | maximum_scale | sql_data_type | datetime_subcode | num_prec_radix | interval_precision |",
+            "+-----------+-----------+-------------+----------------+----------------+---------------+----------+----------------+------------+--------------------+------------------+----------------+-----------------+---------------+---------------+---------------+------------------+----------------+--------------------+",
+            "| INTERVAL  | 10        | 2147483647  | '              | '              |               | 1        | false          | 3          |                    | false            |                | INTERVAL        |               |               | 10            | 0                |                |                    |",
+            "+-----------+-----------+-------------+----------------+----------------+---------------+----------+----------------+------------+--------------------+------------------+----------------+-----------------+---------------+---------------+---------------+------------------+----------------+--------------------+",
+        ];
+        assert_batches_eq(&[batch], &expected);
+    }
+}
diff --git a/arrow-flight/src/sql/mod.rs b/arrow-flight/src/sql/mod.rs
index cd198a1401d1..97645ae7840d 100644
--- a/arrow-flight/src/sql/mod.rs
+++ b/arrow-flight/src/sql/mod.rs
@@ -15,7 +15,32 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::error::{ArrowError, Result as ArrowResult};
+//! Support for execute SQL queries using [Apache Arrow] [Flight SQL].
+//!
+//! [Flight SQL] is built on top of Arrow Flight RPC framework, by
+//! defining specific messages, encoded using the protobuf format,
+//! sent in the[`FlightDescriptor::cmd`] field to [`FlightService`]
+//! endpoints such as[`get_flight_info`] and [`do_get`].
+//!
+//! This module contains:
+//! 1. [prost] generated structs for FlightSQL messages such as [`CommandStatementQuery`]
+//! 2. Helpers for encoding and decoding FlightSQL messages: [`Any`] and [`Command`]
+//! 3. A [`FlightSqlServiceClient`] for interacting with FlightSQL servers.
+//! 4. A [`FlightSqlService`] to help building FlightSQL servers from [`FlightService`].
+//! 5. Helpers to build responses for FlightSQL metadata APIs: [`metadata`]
+//!
+//! [Flight SQL]: https://arrow.apache.org/docs/format/FlightSql.html
+//! [Apache Arrow]: https://arrow.apache.org
+//! [`FlightDescriptor::cmd`]: crate::FlightDescriptor::cmd
+//! [`FlightService`]: crate::flight_service_server::FlightService
+//! [`get_flight_info`]: crate::flight_service_server::FlightService::get_flight_info
+//! [`do_get`]: crate::flight_service_server::FlightService::do_get
+//! [`FlightSqlServiceClient`]: client::FlightSqlServiceClient
+//! [`FlightSqlService`]: server::FlightSqlService
+//! [`metadata`]: crate::sql::metadata
+use arrow_schema::ArrowError;
+use bytes::Bytes;
+use paste::paste;
 use prost::Message;
 
 mod gen {
@@ -23,9 +48,18 @@ mod gen {
     include!("arrow.flight.protocol.sql.rs");
 }
 
+pub use gen::ActionBeginSavepointRequest;
+pub use gen::ActionBeginSavepointResult;
+pub use gen::ActionBeginTransactionRequest;
+pub use gen::ActionBeginTransactionResult;
+pub use gen::ActionCancelQueryRequest;
+pub use gen::ActionCancelQueryResult;
 pub use gen::ActionClosePreparedStatementRequest;
 pub use gen::ActionCreatePreparedStatementRequest;
 pub use gen::ActionCreatePreparedStatementResult;
+pub use gen::ActionCreatePreparedSubstraitPlanRequest;
+pub use gen::ActionEndSavepointRequest;
+pub use gen::ActionEndTransactionRequest;
 pub use gen::CommandGetCatalogs;
 pub use gen::CommandGetCrossReference;
 pub use gen::CommandGetDbSchemas;
@@ -35,11 +69,15 @@ pub use gen::CommandGetPrimaryKeys;
 pub use gen::CommandGetSqlInfo;
 pub use gen::CommandGetTableTypes;
 pub use gen::CommandGetTables;
+pub use gen::CommandGetXdbcTypeInfo;
 pub use gen::CommandPreparedStatementQuery;
 pub use gen::CommandPreparedStatementUpdate;
 pub use gen::CommandStatementQuery;
+pub use gen::CommandStatementSubstraitPlan;
 pub use gen::CommandStatementUpdate;
 pub use gen::DoPutUpdateResult;
+pub use gen::Nullable;
+pub use gen::Searchable;
 pub use gen::SqlInfo;
 pub use gen::SqlNullOrdering;
 pub use gen::SqlOuterJoinsSupportLevel;
@@ -50,14 +88,20 @@ pub use gen::SqlSupportedPositionedCommands;
 pub use gen::SqlSupportedResultSetConcurrency;
 pub use gen::SqlSupportedResultSetType;
 pub use gen::SqlSupportedSubqueries;
+pub use gen::SqlSupportedTransaction;
 pub use gen::SqlSupportedTransactions;
 pub use gen::SqlSupportedUnions;
 pub use gen::SqlSupportsConvert;
 pub use gen::SqlTransactionIsolationLevel;
+pub use gen::SubstraitPlan;
 pub use gen::SupportedSqlGrammar;
 pub use gen::TicketStatementQuery;
 pub use gen::UpdateDeleteRules;
+pub use gen::XdbcDataType;
+pub use gen::XdbcDatetimeSubcode;
 
+pub mod client;
+pub mod metadata;
 pub mod server;
 
 /// ProstMessageExt are useful utility methods for prost::Message types
@@ -65,34 +109,132 @@ pub trait ProstMessageExt: prost::Message + Default {
     /// type_url for this Message
     fn type_url() -> &'static str;
 
-    /// Convert this Message to prost_types::Any
-    fn as_any(&self) -> prost_types::Any;
+    /// Convert this Message to [`Any`]
+    fn as_any(&self) -> Any;
+}
+
+/// Macro to coerce a token to an item, specifically
+/// to build the `Commands` enum.
+///
+/// See: <https://danielkeep.github.io/tlborm/book/blk-ast-coercion.html>
+macro_rules! as_item {
+    ($i:item) => {
+        $i
+    };
 }
 
 macro_rules! prost_message_ext {
-    ($($name:ty,)*) => {
-        $(
-            impl ProstMessageExt for $name {
-                fn type_url() -> &'static str {
-                    concat!("type.googleapis.com/arrow.flight.protocol.sql.", stringify!($name))
+    ($($name:tt,)*) => {
+        paste! {
+            $(
+            const [<$name:snake:upper _TYPE_URL>]: &'static str = concat!("type.googleapis.com/arrow.flight.protocol.sql.", stringify!($name));
+            )*
+
+                as_item! {
+                /// Helper to convert to/from protobuf [`Any`] message
+                /// to a specific FlightSQL command message.
+                ///
+                /// # Example
+                /// ```rust
+                /// # use arrow_flight::sql::{Any, CommandStatementQuery, Command};
+                /// let flightsql_message = CommandStatementQuery {
+                ///   query: "SELECT * FROM foo".to_string(),
+                ///   transaction_id: None,
+                /// };
+                ///
+                /// // Given a packed FlightSQL Any message
+                /// let any_message = Any::pack(&flightsql_message).unwrap();
+                ///
+                /// // decode it to Command:
+                /// match Command::try_from(any_message).unwrap() {
+                ///   Command::CommandStatementQuery(decoded) => {
+                ///    assert_eq!(flightsql_message, decoded);
+                ///   }
+                ///   _ => panic!("Unexpected decoded message"),
+                /// }
+                /// ```
+                #[derive(Clone, Debug, PartialEq)]
+                pub enum Command {
+                    $($name($name),)*
+
+                    /// Any message that is not any FlightSQL command.
+                    Unknown(Any),
+                }
+            }
+
+            impl Command {
+                /// Convert the command to [`Any`].
+                pub fn into_any(self) -> Any {
+                    match self {
+                        $(
+                        Self::$name(cmd) => cmd.as_any(),
+                        )*
+                        Self::Unknown(any) => any,
+                    }
+                }
+
+                /// Get the URL for the command.
+                pub fn type_url(&self) -> &str {
+                    match self {
+                        $(
+                        Self::$name(_) => [<$name:snake:upper _TYPE_URL>],
+                        )*
+                        Self::Unknown(any) => any.type_url.as_str(),
+                    }
                 }
+            }
+
+            impl TryFrom<Any> for Command {
+                type Error = ArrowError;
 
-                fn as_any(&self) -> prost_types::Any {
-                    prost_types::Any {
-                        type_url: <$name>::type_url().to_string(),
-                        value: self.encode_to_vec(),
+                fn try_from(any: Any) -> Result<Self, Self::Error> {
+                    match any.type_url.as_str() {
+                        $(
+                        [<$name:snake:upper _TYPE_URL>]
+                            => {
+                                let m: $name = Message::decode(&*any.value).map_err(|err| {
+                                    ArrowError::ParseError(format!("Unable to decode Any value: {err}"))
+                                })?;
+                                Ok(Self::$name(m))
+                            }
+                        )*
+                        _ => Ok(Self::Unknown(any)),
                     }
                 }
             }
-        )*
+
+            $(
+                impl ProstMessageExt for $name {
+                    fn type_url() -> &'static str {
+                        [<$name:snake:upper _TYPE_URL>]
+                    }
+
+                    fn as_any(&self) -> Any {
+                        Any {
+                            type_url: <$name>::type_url().to_string(),
+                            value: self.encode_to_vec().into(),
+                        }
+                    }
+                }
+            )*
+        }
     };
 }
 
 // Implement ProstMessageExt for all structs defined in FlightSql.proto
 prost_message_ext!(
+    ActionBeginSavepointRequest,
+    ActionBeginSavepointResult,
+    ActionBeginTransactionRequest,
+    ActionBeginTransactionResult,
+    ActionCancelQueryRequest,
+    ActionCancelQueryResult,
     ActionClosePreparedStatementRequest,
     ActionCreatePreparedStatementRequest,
     ActionCreatePreparedStatementResult,
+    ActionCreatePreparedSubstraitPlanRequest,
+    ActionEndSavepointRequest,
+    ActionEndTransactionRequest,
     CommandGetCatalogs,
     CommandGetCrossReference,
     CommandGetDbSchemas,
@@ -102,48 +244,63 @@ prost_message_ext!(
     CommandGetSqlInfo,
     CommandGetTableTypes,
     CommandGetTables,
+    CommandGetXdbcTypeInfo,
     CommandPreparedStatementQuery,
     CommandPreparedStatementUpdate,
     CommandStatementQuery,
+    CommandStatementSubstraitPlan,
     CommandStatementUpdate,
     DoPutUpdateResult,
     TicketStatementQuery,
 );
 
-/// ProstAnyExt are useful utility methods for prost_types::Any
-/// The API design is inspired by [rust-protobuf](https://github.com/stepancheg/rust-protobuf/blob/master/protobuf/src/well_known_types_util/any.rs)
-pub trait ProstAnyExt {
-    /// Check if `Any` contains a message of given type.
-    fn is<M: ProstMessageExt>(&self) -> bool;
-
-    /// Extract a message from this `Any`.
-    ///
-    /// # Returns
-    ///
-    /// * `Ok(None)` when message type mismatch
-    /// * `Err` when parse failed
-    fn unpack<M: ProstMessageExt>(&self) -> ArrowResult<Option<M>>;
-
-    /// Pack any message into `prost_types::Any` value.
-    fn pack<M: ProstMessageExt>(message: &M) -> ArrowResult<prost_types::Any>;
+/// An implementation of the protobuf [`Any`] message type
+///
+/// Encoded protobuf messages are not self-describing, nor contain any information
+/// on the schema of the encoded payload. Consequently to decode a protobuf a client
+/// must know the exact schema of the message.
+///
+/// This presents a problem for loosely typed APIs, where the exact message payloads
+/// are not enumerable, and therefore cannot be enumerated as variants in a [oneof].
+///
+/// One solution is [`Any`] where the encoded payload is paired with a `type_url`
+/// identifying the type of encoded message, and the resulting combination encoded.
+///
+/// Clients can then decode the outer [`Any`], inspect the `type_url` and if it is
+/// a type they recognise, proceed to decode the embedded message `value`
+///
+/// [`Any`]: https://developers.google.com/protocol-buffers/docs/proto3#any
+/// [oneof]: https://developers.google.com/protocol-buffers/docs/proto3#oneof
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct Any {
+    /// A URL/resource name that uniquely identifies the type of the serialized
+    /// protocol buffer message. This string must contain at least
+    /// one "/" character. The last segment of the URL's path must represent
+    /// the fully qualified name of the type (as in
+    /// `path/google.protobuf.Duration`). The name should be in a canonical form
+    /// (e.g., leading "." is not accepted).
+    #[prost(string, tag = "1")]
+    pub type_url: String,
+    /// Must be a valid serialized protocol buffer of the above specified type.
+    #[prost(bytes = "bytes", tag = "2")]
+    pub value: Bytes,
 }
 
-impl ProstAnyExt for prost_types::Any {
-    fn is<M: ProstMessageExt>(&self) -> bool {
+impl Any {
+    pub fn is<M: ProstMessageExt>(&self) -> bool {
         M::type_url() == self.type_url
     }
 
-    fn unpack<M: ProstMessageExt>(&self) -> ArrowResult<Option<M>> {
+    pub fn unpack<M: ProstMessageExt>(&self) -> Result<Option<M>, ArrowError> {
         if !self.is::<M>() {
             return Ok(None);
         }
-        let m = prost::Message::decode(&*self.value).map_err(|err| {
-            ArrowError::ParseError(format!("Unable to decode Any value: {}", err))
-        })?;
+        let m = Message::decode(&*self.value)
+            .map_err(|err| ArrowError::ParseError(format!("Unable to decode Any value: {err}")))?;
         Ok(Some(m))
     }
 
-    fn pack<M: ProstMessageExt>(message: &M) -> ArrowResult<prost_types::Any> {
+    pub fn pack<M: ProstMessageExt>(message: &M) -> Result<Any, ArrowError> {
         Ok(message.as_any())
     }
 }
@@ -165,14 +322,38 @@ mod tests {
     }
 
     #[test]
-    fn test_prost_any_pack_unpack() -> ArrowResult<()> {
+    fn test_prost_any_pack_unpack() {
         let query = CommandStatementQuery {
             query: "select 1".to_string(),
+            transaction_id: None,
         };
-        let any = prost_types::Any::pack(&query)?;
+        let any = Any::pack(&query).unwrap();
         assert!(any.is::<CommandStatementQuery>());
-        let unpack_query: CommandStatementQuery = any.unpack()?.unwrap();
+        let unpack_query: CommandStatementQuery = any.unpack().unwrap().unwrap();
         assert_eq!(query, unpack_query);
-        Ok(())
+    }
+
+    #[test]
+    fn test_command() {
+        let query = CommandStatementQuery {
+            query: "select 1".to_string(),
+            transaction_id: None,
+        };
+        let any = Any::pack(&query).unwrap();
+        let cmd: Command = any.try_into().unwrap();
+
+        assert!(matches!(cmd, Command::CommandStatementQuery(_)));
+        assert_eq!(cmd.type_url(), COMMAND_STATEMENT_QUERY_TYPE_URL);
+
+        // Unknown variant
+
+        let any = Any {
+            type_url: "fake_url".to_string(),
+            value: Default::default(),
+        };
+
+        let cmd: Command = any.try_into().unwrap();
+        assert!(matches!(cmd, Command::Unknown(_)));
+        assert_eq!(cmd.type_url(), "fake_url");
     }
 }
diff --git a/arrow-flight/src/sql/server.rs b/arrow-flight/src/sql/server.rs
index 6e8f104dc5b8..0431e58111a4 100644
--- a/arrow-flight/src/sql/server.rs
+++ b/arrow-flight/src/sql/server.rs
@@ -15,35 +15,44 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Helper trait [`FlightSqlService`] for implementing a [`FlightService`] that implements FlightSQL.
+
 use std::pin::Pin;
 
-use futures::Stream;
+use futures::{stream::Peekable, Stream, StreamExt};
 use prost::Message;
 use tonic::{Request, Response, Status, Streaming};
 
 use super::{
-    super::{
-        flight_service_server::FlightService, Action, ActionType, Criteria, Empty,
-        FlightData, FlightDescriptor, FlightInfo, HandshakeRequest, HandshakeResponse,
-        PutResult, SchemaResult, Ticket,
-    },
+    ActionBeginSavepointRequest, ActionBeginSavepointResult, ActionBeginTransactionRequest,
+    ActionBeginTransactionResult, ActionCancelQueryRequest, ActionCancelQueryResult,
     ActionClosePreparedStatementRequest, ActionCreatePreparedStatementRequest,
-    ActionCreatePreparedStatementResult, CommandGetCatalogs, CommandGetCrossReference,
-    CommandGetDbSchemas, CommandGetExportedKeys, CommandGetImportedKeys,
+    ActionCreatePreparedStatementResult, ActionCreatePreparedSubstraitPlanRequest,
+    ActionEndSavepointRequest, ActionEndTransactionRequest, Any, Command, CommandGetCatalogs,
+    CommandGetCrossReference, CommandGetDbSchemas, CommandGetExportedKeys, CommandGetImportedKeys,
     CommandGetPrimaryKeys, CommandGetSqlInfo, CommandGetTableTypes, CommandGetTables,
-    CommandPreparedStatementQuery, CommandPreparedStatementUpdate, CommandStatementQuery,
-    CommandStatementUpdate, DoPutUpdateResult, ProstAnyExt, ProstMessageExt, SqlInfo,
-    TicketStatementQuery,
+    CommandGetXdbcTypeInfo, CommandPreparedStatementQuery, CommandPreparedStatementUpdate,
+    CommandStatementQuery, CommandStatementSubstraitPlan, CommandStatementUpdate,
+    DoPutUpdateResult, ProstMessageExt, SqlInfo, TicketStatementQuery,
+};
+use crate::{
+    flight_service_server::FlightService, gen::PollInfo, Action, ActionType, Criteria, Empty,
+    FlightData, FlightDescriptor, FlightInfo, HandshakeRequest, HandshakeResponse, PutResult,
+    SchemaResult, Ticket,
 };
 
-static CREATE_PREPARED_STATEMENT: &str = "CreatePreparedStatement";
-static CLOSE_PREPARED_STATEMENT: &str = "ClosePreparedStatement";
+pub(crate) static CREATE_PREPARED_STATEMENT: &str = "CreatePreparedStatement";
+pub(crate) static CLOSE_PREPARED_STATEMENT: &str = "ClosePreparedStatement";
+pub(crate) static CREATE_PREPARED_SUBSTRAIT_PLAN: &str = "CreatePreparedSubstraitPlan";
+pub(crate) static BEGIN_TRANSACTION: &str = "BeginTransaction";
+pub(crate) static END_TRANSACTION: &str = "EndTransaction";
+pub(crate) static BEGIN_SAVEPOINT: &str = "BeginSavepoint";
+pub(crate) static END_SAVEPOINT: &str = "EndSavepoint";
+pub(crate) static CANCEL_QUERY: &str = "CancelQuery";
 
 /// Implements FlightSqlService to handle the flight sql protocol
 #[tonic::async_trait]
-pub trait FlightSqlService:
-    std::marker::Sync + std::marker::Send + std::marker::Sized + 'static
-{
+pub trait FlightSqlService: Sync + Send + Sized + 'static {
     /// When impl FlightSqlService, you can always set FlightService to Self
     type FlightService: FlightService;
 
@@ -61,200 +70,480 @@ pub trait FlightSqlService:
         ))
     }
 
+    /// Implementors may override to handle additional calls to do_get()
+    async fn do_get_fallback(
+        &self,
+        _request: Request<Ticket>,
+        message: Any,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(format!(
+            "do_get: The defined request is invalid: {}",
+            message.type_url
+        )))
+    }
+
     /// Get a FlightInfo for executing a SQL query.
     async fn get_flight_info_statement(
         &self,
-        query: CommandStatementQuery,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandStatementQuery,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_statement has no default implementation",
+        ))
+    }
+
+    /// Get a FlightInfo for executing a substrait plan.
+    async fn get_flight_info_substrait_plan(
+        &self,
+        _query: CommandStatementSubstraitPlan,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_substrait_plan has no default implementation",
+        ))
+    }
 
     /// Get a FlightInfo for executing an already created prepared statement.
     async fn get_flight_info_prepared_statement(
         &self,
-        query: CommandPreparedStatementQuery,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandPreparedStatementQuery,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_prepared_statement has no default implementation",
+        ))
+    }
 
     /// Get a FlightInfo for listing catalogs.
     async fn get_flight_info_catalogs(
         &self,
-        query: CommandGetCatalogs,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandGetCatalogs,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_catalogs has no default implementation",
+        ))
+    }
 
     /// Get a FlightInfo for listing schemas.
     async fn get_flight_info_schemas(
         &self,
-        query: CommandGetDbSchemas,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandGetDbSchemas,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_schemas has no default implementation",
+        ))
+    }
 
     /// Get a FlightInfo for listing tables.
     async fn get_flight_info_tables(
         &self,
-        query: CommandGetTables,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandGetTables,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_tables has no default implementation",
+        ))
+    }
 
     /// Get a FlightInfo to extract information about the table types.
     async fn get_flight_info_table_types(
         &self,
-        query: CommandGetTableTypes,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandGetTableTypes,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_table_types has no default implementation",
+        ))
+    }
 
     /// Get a FlightInfo for retrieving other information (See SqlInfo).
     async fn get_flight_info_sql_info(
         &self,
-        query: CommandGetSqlInfo,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandGetSqlInfo,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_sql_info has no default implementation",
+        ))
+    }
 
     /// Get a FlightInfo to extract information about primary and foreign keys.
     async fn get_flight_info_primary_keys(
         &self,
-        query: CommandGetPrimaryKeys,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandGetPrimaryKeys,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_primary_keys has no default implementation",
+        ))
+    }
 
     /// Get a FlightInfo to extract information about exported keys.
     async fn get_flight_info_exported_keys(
         &self,
-        query: CommandGetExportedKeys,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandGetExportedKeys,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_exported_keys has no default implementation",
+        ))
+    }
 
     /// Get a FlightInfo to extract information about imported keys.
     async fn get_flight_info_imported_keys(
         &self,
-        query: CommandGetImportedKeys,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandGetImportedKeys,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_imported_keys has no default implementation",
+        ))
+    }
 
     /// Get a FlightInfo to extract information about cross reference.
     async fn get_flight_info_cross_reference(
         &self,
-        query: CommandGetCrossReference,
-        request: Request<FlightDescriptor>,
-    ) -> Result<Response<FlightInfo>, Status>;
+        _query: CommandGetCrossReference,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_cross_reference has no default implementation",
+        ))
+    }
+
+    /// Get a FlightInfo to extract information about the supported XDBC types.
+    async fn get_flight_info_xdbc_type_info(
+        &self,
+        _query: CommandGetXdbcTypeInfo,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_xdbc_type_info has no default implementation",
+        ))
+    }
+
+    /// Implementors may override to handle additional calls to get_flight_info()
+    async fn get_flight_info_fallback(
+        &self,
+        cmd: Command,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(format!(
+            "get_flight_info: The defined request is invalid: {}",
+            cmd.type_url()
+        )))
+    }
 
     // do_get
 
     /// Get a FlightDataStream containing the query results.
     async fn do_get_statement(
         &self,
-        ticket: TicketStatementQuery,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _ticket: TicketStatementQuery,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_statement has no default implementation",
+        ))
+    }
 
     /// Get a FlightDataStream containing the prepared statement query results.
     async fn do_get_prepared_statement(
         &self,
-        query: CommandPreparedStatementQuery,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _query: CommandPreparedStatementQuery,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_prepared_statement has no default implementation",
+        ))
+    }
 
     /// Get a FlightDataStream containing the list of catalogs.
     async fn do_get_catalogs(
         &self,
-        query: CommandGetCatalogs,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _query: CommandGetCatalogs,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_catalogs has no default implementation",
+        ))
+    }
 
     /// Get a FlightDataStream containing the list of schemas.
     async fn do_get_schemas(
         &self,
-        query: CommandGetDbSchemas,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _query: CommandGetDbSchemas,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_schemas has no default implementation",
+        ))
+    }
 
     /// Get a FlightDataStream containing the list of tables.
     async fn do_get_tables(
         &self,
-        query: CommandGetTables,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _query: CommandGetTables,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_tables has no default implementation",
+        ))
+    }
 
     /// Get a FlightDataStream containing the data related to the table types.
     async fn do_get_table_types(
         &self,
-        query: CommandGetTableTypes,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _query: CommandGetTableTypes,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_table_types has no default implementation",
+        ))
+    }
 
     /// Get a FlightDataStream containing the list of SqlInfo results.
     async fn do_get_sql_info(
         &self,
-        query: CommandGetSqlInfo,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _query: CommandGetSqlInfo,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_sql_info has no default implementation",
+        ))
+    }
 
     /// Get a FlightDataStream containing the data related to the primary and foreign keys.
     async fn do_get_primary_keys(
         &self,
-        query: CommandGetPrimaryKeys,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _query: CommandGetPrimaryKeys,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_primary_keys has no default implementation",
+        ))
+    }
 
     /// Get a FlightDataStream containing the data related to the exported keys.
     async fn do_get_exported_keys(
         &self,
-        query: CommandGetExportedKeys,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _query: CommandGetExportedKeys,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_exported_keys has no default implementation",
+        ))
+    }
 
     /// Get a FlightDataStream containing the data related to the imported keys.
     async fn do_get_imported_keys(
         &self,
-        query: CommandGetImportedKeys,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _query: CommandGetImportedKeys,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_imported_keys has no default implementation",
+        ))
+    }
 
     /// Get a FlightDataStream containing the data related to the cross reference.
     async fn do_get_cross_reference(
         &self,
-        query: CommandGetCrossReference,
-        request: Request<Ticket>,
-    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status>;
+        _query: CommandGetCrossReference,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_cross_reference has no default implementation",
+        ))
+    }
+
+    /// Get a FlightDataStream containing the data related to the supported XDBC types.
+    async fn do_get_xdbc_type_info(
+        &self,
+        _query: CommandGetXdbcTypeInfo,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_xdbc_type_info has no default implementation",
+        ))
+    }
 
     // do_put
 
+    /// Implementors may override to handle additional calls to do_put()
+    async fn do_put_fallback(
+        &self,
+        _request: Request<PeekableFlightDataStream>,
+        message: Any,
+    ) -> Result<Response<<Self as FlightService>::DoPutStream>, Status> {
+        Err(Status::unimplemented(format!(
+            "do_put: The defined request is invalid: {}",
+            message.type_url
+        )))
+    }
+
     /// Execute an update SQL statement.
     async fn do_put_statement_update(
         &self,
-        ticket: CommandStatementUpdate,
-        request: Request<Streaming<FlightData>>,
-    ) -> Result<i64, Status>;
+        _ticket: CommandStatementUpdate,
+        _request: Request<PeekableFlightDataStream>,
+    ) -> Result<i64, Status> {
+        Err(Status::unimplemented(
+            "do_put_statement_update has no default implementation",
+        ))
+    }
 
     /// Bind parameters to given prepared statement.
     async fn do_put_prepared_statement_query(
         &self,
-        query: CommandPreparedStatementQuery,
-        request: Request<Streaming<FlightData>>,
-    ) -> Result<Response<<Self as FlightService>::DoPutStream>, Status>;
+        _query: CommandPreparedStatementQuery,
+        _request: Request<PeekableFlightDataStream>,
+    ) -> Result<Response<<Self as FlightService>::DoPutStream>, Status> {
+        Err(Status::unimplemented(
+            "do_put_prepared_statement_query has no default implementation",
+        ))
+    }
 
     /// Execute an update SQL prepared statement.
     async fn do_put_prepared_statement_update(
         &self,
-        query: CommandPreparedStatementUpdate,
-        request: Request<Streaming<FlightData>>,
-    ) -> Result<i64, Status>;
+        _query: CommandPreparedStatementUpdate,
+        _request: Request<PeekableFlightDataStream>,
+    ) -> Result<i64, Status> {
+        Err(Status::unimplemented(
+            "do_put_prepared_statement_update has no default implementation",
+        ))
+    }
+
+    /// Execute a substrait plan
+    async fn do_put_substrait_plan(
+        &self,
+        _query: CommandStatementSubstraitPlan,
+        _request: Request<PeekableFlightDataStream>,
+    ) -> Result<i64, Status> {
+        Err(Status::unimplemented(
+            "do_put_substrait_plan has no default implementation",
+        ))
+    }
 
     // do_action
 
+    /// Implementors may override to handle additional calls to do_action()
+    async fn do_action_fallback(
+        &self,
+        request: Request<Action>,
+    ) -> Result<Response<<Self as FlightService>::DoActionStream>, Status> {
+        Err(Status::invalid_argument(format!(
+            "do_action: The defined request is invalid: {:?}",
+            request.get_ref().r#type
+        )))
+    }
+
+    /// Add custom actions to list_actions() result
+    async fn list_custom_actions(&self) -> Option<Vec<Result<ActionType, Status>>> {
+        None
+    }
+
     /// Create a prepared statement from given SQL statement.
     async fn do_action_create_prepared_statement(
         &self,
-        query: ActionCreatePreparedStatementRequest,
-        request: Request<Action>,
-    ) -> Result<ActionCreatePreparedStatementResult, Status>;
+        _query: ActionCreatePreparedStatementRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionCreatePreparedStatementResult, Status> {
+        Err(Status::unimplemented(
+            "do_action_create_prepared_statement has no default implementation",
+        ))
+    }
 
     /// Close a prepared statement.
     async fn do_action_close_prepared_statement(
         &self,
-        query: ActionClosePreparedStatementRequest,
-        request: Request<Action>,
-    );
+        _query: ActionClosePreparedStatementRequest,
+        _request: Request<Action>,
+    ) -> Result<(), Status> {
+        Err(Status::unimplemented(
+            "do_action_close_prepared_statement has no default implementation",
+        ))
+    }
+
+    /// Create a prepared substrait plan.
+    async fn do_action_create_prepared_substrait_plan(
+        &self,
+        _query: ActionCreatePreparedSubstraitPlanRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionCreatePreparedStatementResult, Status> {
+        Err(Status::unimplemented(
+            "do_action_create_prepared_substrait_plan has no default implementation",
+        ))
+    }
+
+    /// Begin a transaction
+    async fn do_action_begin_transaction(
+        &self,
+        _query: ActionBeginTransactionRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionBeginTransactionResult, Status> {
+        Err(Status::unimplemented(
+            "do_action_begin_transaction has no default implementation",
+        ))
+    }
+
+    /// End a transaction
+    async fn do_action_end_transaction(
+        &self,
+        _query: ActionEndTransactionRequest,
+        _request: Request<Action>,
+    ) -> Result<(), Status> {
+        Err(Status::unimplemented(
+            "do_action_end_transaction has no default implementation",
+        ))
+    }
+
+    /// Begin a savepoint
+    async fn do_action_begin_savepoint(
+        &self,
+        _query: ActionBeginSavepointRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionBeginSavepointResult, Status> {
+        Err(Status::unimplemented(
+            "do_action_begin_savepoint has no default implementation",
+        ))
+    }
+
+    /// End a savepoint
+    async fn do_action_end_savepoint(
+        &self,
+        _query: ActionEndSavepointRequest,
+        _request: Request<Action>,
+    ) -> Result<(), Status> {
+        Err(Status::unimplemented(
+            "do_action_end_savepoint has no default implementation",
+        ))
+    }
+
+    /// Cancel a query
+    async fn do_action_cancel_query(
+        &self,
+        _query: ActionCancelQueryRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionCancelQueryResult, Status> {
+        Err(Status::unimplemented(
+            "do_action_cancel_query has no default implementation",
+        ))
+    }
+
+    /// do_exchange
+
+    /// Implementors may override to handle additional calls to do_exchange()
+    async fn do_exchange_fallback(
+        &self,
+        _request: Request<Streaming<FlightData>>,
+    ) -> Result<Response<<Self as FlightService>::DoExchangeStream>, Status> {
+        Err(Status::unimplemented("Not yet implemented"))
+    }
 
     /// Register a new SqlInfo result, making it available when calling GetSqlInfo.
     async fn register_sql_info(&self, id: i32, result: &SqlInfo);
@@ -264,19 +553,16 @@ pub trait FlightSqlService:
 #[tonic::async_trait]
 impl<T: 'static> FlightService for T
 where
-    T: FlightSqlService + std::marker::Send,
+    T: FlightSqlService + Send,
 {
     type HandshakeStream =
         Pin<Box<dyn Stream<Item = Result<HandshakeResponse, Status>> + Send + 'static>>;
     type ListFlightsStream =
         Pin<Box<dyn Stream<Item = Result<FlightInfo, Status>> + Send + 'static>>;
-    type DoGetStream =
-        Pin<Box<dyn Stream<Item = Result<FlightData, Status>> + Send + 'static>>;
-    type DoPutStream =
-        Pin<Box<dyn Stream<Item = Result<PutResult, Status>> + Send + 'static>>;
-    type DoActionStream = Pin<
-        Box<dyn Stream<Item = Result<super::super::Result, Status>> + Send + 'static>,
-    >;
+    type DoGetStream = Pin<Box<dyn Stream<Item = Result<FlightData, Status>> + Send + 'static>>;
+    type DoPutStream = Pin<Box<dyn Stream<Item = Result<PutResult, Status>> + Send + 'static>>;
+    type DoActionStream =
+        Pin<Box<dyn Stream<Item = Result<super::super::Result, Status>> + Send + 'static>>;
     type ListActionsStream =
         Pin<Box<dyn Stream<Item = Result<ActionType, Status>> + Send + 'static>>;
     type DoExchangeStream =
@@ -301,93 +587,56 @@ where
         &self,
         request: Request<FlightDescriptor>,
     ) -> Result<Response<FlightInfo>, Status> {
-        let any: prost_types::Any =
-            Message::decode(&*request.get_ref().cmd).map_err(decode_error_to_status)?;
+        let message = Any::decode(&*request.get_ref().cmd).map_err(decode_error_to_status)?;
 
-        if any.is::<CommandStatementQuery>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.get_flight_info_statement(token, request).await;
-        }
-        if any.is::<CommandPreparedStatementQuery>() {
-            let handle = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self
-                .get_flight_info_prepared_statement(handle, request)
-                .await;
-        }
-        if any.is::<CommandGetCatalogs>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.get_flight_info_catalogs(token, request).await;
-        }
-        if any.is::<CommandGetDbSchemas>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.get_flight_info_schemas(token, request).await;
-        }
-        if any.is::<CommandGetTables>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.get_flight_info_tables(token, request).await;
-        }
-        if any.is::<CommandGetTableTypes>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.get_flight_info_table_types(token, request).await;
-        }
-        if any.is::<CommandGetSqlInfo>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.get_flight_info_sql_info(token, request).await;
-        }
-        if any.is::<CommandGetPrimaryKeys>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.get_flight_info_primary_keys(token, request).await;
-        }
-        if any.is::<CommandGetExportedKeys>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.get_flight_info_exported_keys(token, request).await;
-        }
-        if any.is::<CommandGetImportedKeys>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.get_flight_info_imported_keys(token, request).await;
-        }
-        if any.is::<CommandGetCrossReference>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.get_flight_info_cross_reference(token, request).await;
+        match Command::try_from(message).map_err(arrow_error_to_status)? {
+            Command::CommandStatementQuery(token) => {
+                self.get_flight_info_statement(token, request).await
+            }
+            Command::CommandPreparedStatementQuery(handle) => {
+                self.get_flight_info_prepared_statement(handle, request)
+                    .await
+            }
+            Command::CommandStatementSubstraitPlan(handle) => {
+                self.get_flight_info_substrait_plan(handle, request).await
+            }
+            Command::CommandGetCatalogs(token) => {
+                self.get_flight_info_catalogs(token, request).await
+            }
+            Command::CommandGetDbSchemas(token) => {
+                return self.get_flight_info_schemas(token, request).await
+            }
+            Command::CommandGetTables(token) => self.get_flight_info_tables(token, request).await,
+            Command::CommandGetTableTypes(token) => {
+                self.get_flight_info_table_types(token, request).await
+            }
+            Command::CommandGetSqlInfo(token) => {
+                self.get_flight_info_sql_info(token, request).await
+            }
+            Command::CommandGetPrimaryKeys(token) => {
+                self.get_flight_info_primary_keys(token, request).await
+            }
+            Command::CommandGetExportedKeys(token) => {
+                self.get_flight_info_exported_keys(token, request).await
+            }
+            Command::CommandGetImportedKeys(token) => {
+                self.get_flight_info_imported_keys(token, request).await
+            }
+            Command::CommandGetCrossReference(token) => {
+                self.get_flight_info_cross_reference(token, request).await
+            }
+            Command::CommandGetXdbcTypeInfo(token) => {
+                self.get_flight_info_xdbc_type_info(token, request).await
+            }
+            cmd => self.get_flight_info_fallback(cmd, request).await,
         }
+    }
 
-        Err(Status::unimplemented(format!(
-            "get_flight_info: The defined request is invalid: {:?}",
-            String::from_utf8(any.encode_to_vec()).unwrap()
-        )))
+    async fn poll_flight_info(
+        &self,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<PollInfo>, Status> {
+        Err(Status::unimplemented("Not yet implemented"))
     }
 
     async fn get_schema(
@@ -401,139 +650,87 @@ where
         &self,
         request: Request<Ticket>,
     ) -> Result<Response<Self::DoGetStream>, Status> {
-        let any: prost_types::Any = prost::Message::decode(&*request.get_ref().ticket)
-            .map_err(decode_error_to_status)?;
+        let msg: Any =
+            Message::decode(&*request.get_ref().ticket).map_err(decode_error_to_status)?;
 
-        if any.is::<TicketStatementQuery>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_statement(token, request).await;
-        }
-        if any.is::<CommandPreparedStatementQuery>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_prepared_statement(token, request).await;
-        }
-        if any.is::<CommandGetCatalogs>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_catalogs(token, request).await;
-        }
-        if any.is::<CommandGetDbSchemas>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_schemas(token, request).await;
-        }
-        if any.is::<CommandGetTables>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_tables(token, request).await;
-        }
-        if any.is::<CommandGetTableTypes>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_table_types(token, request).await;
-        }
-        if any.is::<CommandGetSqlInfo>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_sql_info(token, request).await;
-        }
-        if any.is::<CommandGetPrimaryKeys>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_primary_keys(token, request).await;
-        }
-        if any.is::<CommandGetExportedKeys>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_exported_keys(token, request).await;
-        }
-        if any.is::<CommandGetImportedKeys>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_imported_keys(token, request).await;
+        match Command::try_from(msg).map_err(arrow_error_to_status)? {
+            Command::TicketStatementQuery(command) => self.do_get_statement(command, request).await,
+            Command::CommandPreparedStatementQuery(command) => {
+                self.do_get_prepared_statement(command, request).await
+            }
+            Command::CommandGetCatalogs(command) => self.do_get_catalogs(command, request).await,
+            Command::CommandGetDbSchemas(command) => self.do_get_schemas(command, request).await,
+            Command::CommandGetTables(command) => self.do_get_tables(command, request).await,
+            Command::CommandGetTableTypes(command) => {
+                self.do_get_table_types(command, request).await
+            }
+            Command::CommandGetSqlInfo(command) => self.do_get_sql_info(command, request).await,
+            Command::CommandGetPrimaryKeys(command) => {
+                self.do_get_primary_keys(command, request).await
+            }
+            Command::CommandGetExportedKeys(command) => {
+                self.do_get_exported_keys(command, request).await
+            }
+            Command::CommandGetImportedKeys(command) => {
+                self.do_get_imported_keys(command, request).await
+            }
+            Command::CommandGetCrossReference(command) => {
+                self.do_get_cross_reference(command, request).await
+            }
+            Command::CommandGetXdbcTypeInfo(command) => {
+                self.do_get_xdbc_type_info(command, request).await
+            }
+            cmd => self.do_get_fallback(request, cmd.into_any()).await,
         }
-        if any.is::<CommandGetCrossReference>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_get_cross_reference(token, request).await;
-        }
-
-        Err(Status::unimplemented(format!(
-            "do_get: The defined request is invalid: {:?}",
-            String::from_utf8(request.get_ref().ticket.clone()).unwrap()
-        )))
     }
 
     async fn do_put(
         &self,
-        mut request: Request<Streaming<FlightData>>,
+        request: Request<Streaming<FlightData>>,
     ) -> Result<Response<Self::DoPutStream>, Status> {
-        let cmd = request.get_mut().message().await?.unwrap();
-        let any: prost_types::Any =
-            prost::Message::decode(&*cmd.flight_descriptor.unwrap().cmd)
-                .map_err(decode_error_to_status)?;
-        if any.is::<CommandStatementUpdate>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            let record_count = self.do_put_statement_update(token, request).await?;
-            let result = DoPutUpdateResult { record_count };
-            let output = futures::stream::iter(vec![Ok(super::super::gen::PutResult {
-                app_metadata: result.encode_to_vec(),
-            })]);
-            return Ok(Response::new(Box::pin(output)));
-        }
-        if any.is::<CommandPreparedStatementQuery>() {
-            let token = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            return self.do_put_prepared_statement_query(token, request).await;
-        }
-        if any.is::<CommandPreparedStatementUpdate>() {
-            let handle = any
-                .unpack()
-                .map_err(arrow_error_to_status)?
-                .expect("unreachable");
-            let record_count = self
-                .do_put_prepared_statement_update(handle, request)
-                .await?;
-            let result = DoPutUpdateResult { record_count };
-            let output = futures::stream::iter(vec![Ok(super::super::gen::PutResult {
-                app_metadata: result.encode_to_vec(),
-            })]);
-            return Ok(Response::new(Box::pin(output)));
-        }
+        // See issue #4658: https://github.com/apache/arrow-rs/issues/4658
+        // To dispatch to the correct `do_put` method, we cannot discard the first message,
+        // as it may contain the Arrow schema, which the `do_put` handler may need.
+        // To allow the first message to be reused by the `do_put` handler,
+        // we wrap this stream in a `Peekable` one, which allows us to peek at
+        // the first message without discarding it.
+        let mut request = request.map(PeekableFlightDataStream::new);
+        let cmd = Pin::new(request.get_mut()).peek().await.unwrap().clone()?;
 
-        Err(Status::invalid_argument(format!(
-            "do_put: The defined request is invalid: {:?}",
-            String::from_utf8(any.encode_to_vec()).unwrap()
-        )))
+        let message =
+            Any::decode(&*cmd.flight_descriptor.unwrap().cmd).map_err(decode_error_to_status)?;
+        match Command::try_from(message).map_err(arrow_error_to_status)? {
+            Command::CommandStatementUpdate(command) => {
+                let record_count = self.do_put_statement_update(command, request).await?;
+                let result = DoPutUpdateResult { record_count };
+                let output = futures::stream::iter(vec![Ok(PutResult {
+                    app_metadata: result.as_any().encode_to_vec().into(),
+                })]);
+                Ok(Response::new(Box::pin(output)))
+            }
+            Command::CommandPreparedStatementQuery(command) => {
+                self.do_put_prepared_statement_query(command, request).await
+            }
+            Command::CommandStatementSubstraitPlan(command) => {
+                let record_count = self.do_put_substrait_plan(command, request).await?;
+                let result = DoPutUpdateResult { record_count };
+                let output = futures::stream::iter(vec![Ok(PutResult {
+                    app_metadata: result.as_any().encode_to_vec().into(),
+                })]);
+                Ok(Response::new(Box::pin(output)))
+            }
+            Command::CommandPreparedStatementUpdate(command) => {
+                let record_count = self
+                    .do_put_prepared_statement_update(command, request)
+                    .await?;
+                let result = DoPutUpdateResult { record_count };
+                let output = futures::stream::iter(vec![Ok(PutResult {
+                    app_metadata: result.as_any().encode_to_vec().into(),
+                })]);
+                Ok(Response::new(Box::pin(output)))
+            }
+            cmd => self.do_put_fallback(request, cmd.into_any()).await,
+        }
     }
 
     async fn list_actions(
@@ -554,10 +751,63 @@ where
                 Response Message: N/A"
                 .into(),
         };
-        let actions: Vec<Result<ActionType, Status>> = vec![
+        let create_prepared_substrait_plan_action_type = ActionType {
+            r#type: CREATE_PREPARED_SUBSTRAIT_PLAN.to_string(),
+            description: "Creates a reusable prepared substrait plan resource on the server.\n
+                Request Message: ActionCreatePreparedSubstraitPlanRequest\n
+                Response Message: ActionCreatePreparedStatementResult"
+                .into(),
+        };
+        let begin_transaction_action_type = ActionType {
+            r#type: BEGIN_TRANSACTION.to_string(),
+            description: "Begins a transaction.\n
+                Request Message: ActionBeginTransactionRequest\n
+                Response Message: ActionBeginTransactionResult"
+                .into(),
+        };
+        let end_transaction_action_type = ActionType {
+            r#type: END_TRANSACTION.to_string(),
+            description: "Ends a transaction\n
+                Request Message: ActionEndTransactionRequest\n
+                Response Message: N/A"
+                .into(),
+        };
+        let begin_savepoint_action_type = ActionType {
+            r#type: BEGIN_SAVEPOINT.to_string(),
+            description: "Begins a savepoint.\n
+                Request Message: ActionBeginSavepointRequest\n
+                Response Message: ActionBeginSavepointResult"
+                .into(),
+        };
+        let end_savepoint_action_type = ActionType {
+            r#type: END_SAVEPOINT.to_string(),
+            description: "Ends a savepoint\n
+                Request Message: ActionEndSavepointRequest\n
+                Response Message: N/A"
+                .into(),
+        };
+        let cancel_query_action_type = ActionType {
+            r#type: CANCEL_QUERY.to_string(),
+            description: "Cancels a query\n
+                Request Message: ActionCancelQueryRequest\n
+                Response Message: ActionCancelQueryResult"
+                .into(),
+        };
+        let mut actions: Vec<Result<ActionType, Status>> = vec![
             Ok(create_prepared_statement_action_type),
             Ok(close_prepared_statement_action_type),
+            Ok(create_prepared_substrait_plan_action_type),
+            Ok(begin_transaction_action_type),
+            Ok(end_transaction_action_type),
+            Ok(begin_savepoint_action_type),
+            Ok(end_savepoint_action_type),
+            Ok(cancel_query_action_type),
         ];
+
+        if let Some(mut custom_actions) = self.list_custom_actions().await {
+            actions.append(&mut custom_actions);
+        }
+
         let output = futures::stream::iter(actions);
         Ok(Response::new(Box::pin(output) as Self::ListActionsStream))
     }
@@ -567,8 +817,7 @@ where
         request: Request<Action>,
     ) -> Result<Response<Self::DoActionStream>, Status> {
         if request.get_ref().r#type == CREATE_PREPARED_STATEMENT {
-            let any: prost_types::Any = Message::decode(&*request.get_ref().body)
-                .map_err(decode_error_to_status)?;
+            let any = Any::decode(&*request.get_ref().body).map_err(decode_error_to_status)?;
 
             let cmd: ActionCreatePreparedStatementRequest = any
                 .unpack()
@@ -582,13 +831,11 @@ where
                 .do_action_create_prepared_statement(cmd, request)
                 .await?;
             let output = futures::stream::iter(vec![Ok(super::super::gen::Result {
-                body: stmt.as_any().encode_to_vec(),
+                body: stmt.as_any().encode_to_vec().into(),
             })]);
             return Ok(Response::new(Box::pin(output)));
-        }
-        if request.get_ref().r#type == CLOSE_PREPARED_STATEMENT {
-            let any: prost_types::Any = Message::decode(&*request.get_ref().body)
-                .map_err(decode_error_to_status)?;
+        } else if request.get_ref().r#type == CLOSE_PREPARED_STATEMENT {
+            let any = Any::decode(&*request.get_ref().body).map_err(decode_error_to_status)?;
 
             let cmd: ActionClosePreparedStatementRequest = any
                 .unpack()
@@ -598,28 +845,190 @@ where
                         "Unable to unpack ActionClosePreparedStatementRequest.",
                     )
                 })?;
-            self.do_action_close_prepared_statement(cmd, request).await;
+            self.do_action_close_prepared_statement(cmd, request)
+                .await?;
             return Ok(Response::new(Box::pin(futures::stream::empty())));
+        } else if request.get_ref().r#type == CREATE_PREPARED_SUBSTRAIT_PLAN {
+            let any = Any::decode(&*request.get_ref().body).map_err(decode_error_to_status)?;
+
+            let cmd: ActionCreatePreparedSubstraitPlanRequest = any
+                .unpack()
+                .map_err(arrow_error_to_status)?
+                .ok_or_else(|| {
+                    Status::invalid_argument(
+                        "Unable to unpack ActionCreatePreparedSubstraitPlanRequest.",
+                    )
+                })?;
+            self.do_action_create_prepared_substrait_plan(cmd, request)
+                .await?;
+            return Ok(Response::new(Box::pin(futures::stream::empty())));
+        } else if request.get_ref().r#type == BEGIN_TRANSACTION {
+            let any = Any::decode(&*request.get_ref().body).map_err(decode_error_to_status)?;
+
+            let cmd: ActionBeginTransactionRequest = any
+                .unpack()
+                .map_err(arrow_error_to_status)?
+                .ok_or_else(|| {
+                Status::invalid_argument("Unable to unpack ActionBeginTransactionRequest.")
+            })?;
+            let stmt = self.do_action_begin_transaction(cmd, request).await?;
+            let output = futures::stream::iter(vec![Ok(super::super::gen::Result {
+                body: stmt.as_any().encode_to_vec().into(),
+            })]);
+            return Ok(Response::new(Box::pin(output)));
+        } else if request.get_ref().r#type == END_TRANSACTION {
+            let any = Any::decode(&*request.get_ref().body).map_err(decode_error_to_status)?;
+
+            let cmd: ActionEndTransactionRequest = any
+                .unpack()
+                .map_err(arrow_error_to_status)?
+                .ok_or_else(|| {
+                    Status::invalid_argument("Unable to unpack ActionEndTransactionRequest.")
+                })?;
+            self.do_action_end_transaction(cmd, request).await?;
+            return Ok(Response::new(Box::pin(futures::stream::empty())));
+        } else if request.get_ref().r#type == BEGIN_SAVEPOINT {
+            let any = Any::decode(&*request.get_ref().body).map_err(decode_error_to_status)?;
+
+            let cmd: ActionBeginSavepointRequest = any
+                .unpack()
+                .map_err(arrow_error_to_status)?
+                .ok_or_else(|| {
+                    Status::invalid_argument("Unable to unpack ActionBeginSavepointRequest.")
+                })?;
+            let stmt = self.do_action_begin_savepoint(cmd, request).await?;
+            let output = futures::stream::iter(vec![Ok(super::super::gen::Result {
+                body: stmt.as_any().encode_to_vec().into(),
+            })]);
+            return Ok(Response::new(Box::pin(output)));
+        } else if request.get_ref().r#type == END_SAVEPOINT {
+            let any = Any::decode(&*request.get_ref().body).map_err(decode_error_to_status)?;
+
+            let cmd: ActionEndSavepointRequest = any
+                .unpack()
+                .map_err(arrow_error_to_status)?
+                .ok_or_else(|| {
+                    Status::invalid_argument("Unable to unpack ActionEndSavepointRequest.")
+                })?;
+            self.do_action_end_savepoint(cmd, request).await?;
+            return Ok(Response::new(Box::pin(futures::stream::empty())));
+        } else if request.get_ref().r#type == CANCEL_QUERY {
+            let any = Any::decode(&*request.get_ref().body).map_err(decode_error_to_status)?;
+
+            let cmd: ActionCancelQueryRequest = any
+                .unpack()
+                .map_err(arrow_error_to_status)?
+                .ok_or_else(|| {
+                    Status::invalid_argument("Unable to unpack ActionCancelQueryRequest.")
+                })?;
+            let stmt = self.do_action_cancel_query(cmd, request).await?;
+            let output = futures::stream::iter(vec![Ok(super::super::gen::Result {
+                body: stmt.as_any().encode_to_vec().into(),
+            })]);
+            return Ok(Response::new(Box::pin(output)));
         }
 
-        Err(Status::invalid_argument(format!(
-            "do_action: The defined request is invalid: {:?}",
-            request.get_ref().r#type
-        )))
+        self.do_action_fallback(request).await
     }
 
     async fn do_exchange(
         &self,
-        _request: Request<Streaming<FlightData>>,
+        request: Request<Streaming<FlightData>>,
     ) -> Result<Response<Self::DoExchangeStream>, Status> {
-        Err(Status::unimplemented("Not yet implemented"))
+        self.do_exchange_fallback(request).await
     }
 }
 
-fn decode_error_to_status(err: prost::DecodeError) -> tonic::Status {
-    tonic::Status::invalid_argument(format!("{:?}", err))
+fn decode_error_to_status(err: prost::DecodeError) -> Status {
+    Status::invalid_argument(format!("{err:?}"))
+}
+
+fn arrow_error_to_status(err: arrow_schema::ArrowError) -> Status {
+    Status::internal(format!("{err:?}"))
+}
+
+/// A wrapper around [`Streaming<FlightData>`] that allows "peeking" at the
+/// message at the front of the stream without consuming it.
+/// This is needed because sometimes the first message in the stream will contain
+/// a [`FlightDescriptor`] in addition to potentially any data, and the dispatch logic
+/// must inspect this information.
+///
+/// # Example
+///
+/// [`PeekableFlightDataStream::peek`] can be used to peek at the first message without
+/// discarding it; otherwise, `PeekableFlightDataStream` can be used as a regular stream.
+/// See the following example:
+///
+/// ```no_run
+/// use arrow_array::RecordBatch;
+/// use arrow_flight::decode::FlightRecordBatchStream;
+/// use arrow_flight::FlightDescriptor;
+/// use arrow_flight::error::FlightError;
+/// use arrow_flight::sql::server::PeekableFlightDataStream;
+/// use tonic::{Request, Status};
+/// use futures::TryStreamExt;
+///
+/// #[tokio::main]
+/// async fn main() -> Result<(), Status> {
+///     let request: Request<PeekableFlightDataStream> = todo!();
+///     let stream: PeekableFlightDataStream = request.into_inner();
+///
+///     // The first message contains the flight descriptor and the schema.
+///     // Read the flight descriptor without discarding the schema:
+///     let flight_descriptor: FlightDescriptor = stream
+///         .peek()
+///         .await
+///         .cloned()
+///         .transpose()?
+///         .and_then(|data| data.flight_descriptor)
+///         .expect("first message should contain flight descriptor");
+///
+///     // Pass the stream through a decoder
+///     let batches: Vec<RecordBatch> = FlightRecordBatchStream::new_from_flight_data(
+///         request.into_inner().map_err(|e| e.into()),
+///     )
+///     .try_collect()
+///     .await?;
+/// }
+/// ```
+pub struct PeekableFlightDataStream {
+    inner: Peekable<Streaming<FlightData>>,
 }
 
-fn arrow_error_to_status(err: arrow::error::ArrowError) -> tonic::Status {
-    tonic::Status::internal(format!("{:?}", err))
+impl PeekableFlightDataStream {
+    fn new(stream: Streaming<FlightData>) -> Self {
+        Self {
+            inner: stream.peekable(),
+        }
+    }
+
+    /// Convert this stream into a `Streaming<FlightData>`.
+    /// Any messages observed through [`Self::peek`] will be lost
+    /// after the conversion.
+    pub fn into_inner(self) -> Streaming<FlightData> {
+        self.inner.into_inner()
+    }
+
+    /// Convert this stream into a `Peekable<Streaming<FlightData>>`.
+    /// Preserves the state of the stream, so that calls to [`Self::peek`]
+    /// and [`Self::poll_next`] are the same.
+    pub fn into_peekable(self) -> Peekable<Streaming<FlightData>> {
+        self.inner
+    }
+
+    /// Peek at the head of this stream without advancing it.
+    pub async fn peek(&mut self) -> Option<&Result<FlightData, Status>> {
+        Pin::new(&mut self.inner).peek().await
+    }
+}
+
+impl Stream for PeekableFlightDataStream {
+    type Item = Result<FlightData, Status>;
+
+    fn poll_next(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> std::task::Poll<Option<Self::Item>> {
+        self.inner.poll_next_unpin(cx)
+    }
 }
diff --git a/arrow-flight/src/trailers.rs b/arrow-flight/src/trailers.rs
new file mode 100644
index 000000000000..73136379d69f
--- /dev/null
+++ b/arrow-flight/src/trailers.rs
@@ -0,0 +1,92 @@
+// 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.
+
+use std::{
+    pin::Pin,
+    sync::{Arc, Mutex},
+    task::{Context, Poll},
+};
+
+use futures::{ready, FutureExt, Stream, StreamExt};
+use tonic::{metadata::MetadataMap, Status, Streaming};
+
+/// Extract [`LazyTrailers`] from [`Streaming`] [tonic] response.
+///
+/// Note that [`LazyTrailers`] has inner mutability and will only hold actual data after [`ExtractTrailersStream`] is
+/// fully consumed (dropping it is not required though).
+pub fn extract_lazy_trailers<T>(s: Streaming<T>) -> (ExtractTrailersStream<T>, LazyTrailers) {
+    let trailers: SharedTrailers = Default::default();
+    let stream = ExtractTrailersStream {
+        inner: s,
+        trailers: Arc::clone(&trailers),
+    };
+    let lazy_trailers = LazyTrailers { trailers };
+    (stream, lazy_trailers)
+}
+
+type SharedTrailers = Arc<Mutex<Option<MetadataMap>>>;
+
+/// [Stream] that stores the gRPC trailers into [`LazyTrailers`].
+///
+/// See [`extract_lazy_trailers`] for construction.
+#[derive(Debug)]
+pub struct ExtractTrailersStream<T> {
+    inner: Streaming<T>,
+    trailers: SharedTrailers,
+}
+
+impl<T> Stream for ExtractTrailersStream<T> {
+    type Item = Result<T, Status>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        let res = ready!(self.inner.poll_next_unpin(cx));
+
+        if res.is_none() {
+            // stream exhausted => trailers should available
+            if let Some(trailers) = self
+                .inner
+                .trailers()
+                .now_or_never()
+                .and_then(|res| res.ok())
+                .flatten()
+            {
+                *self.trailers.lock().expect("poisoned") = Some(trailers);
+            }
+        }
+
+        Poll::Ready(res)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+/// gRPC trailers that are extracted by [`ExtractTrailersStream`].
+///
+/// See [`extract_lazy_trailers`] for construction.
+#[derive(Debug)]
+pub struct LazyTrailers {
+    trailers: SharedTrailers,
+}
+
+impl LazyTrailers {
+    /// gRPC trailers that are known at the end of a stream.
+    pub fn get(&self) -> Option<MetadataMap> {
+        self.trailers.lock().expect("poisoned").clone()
+    }
+}
diff --git a/arrow-flight/src/utils.rs b/arrow-flight/src/utils.rs
index dda3fc7fe3db..32716a52eb0d 100644
--- a/arrow-flight/src/utils.rs
+++ b/arrow-flight/src/utils.rs
@@ -18,17 +18,22 @@
 //! Utilities to assist with reading and writing Arrow data as Flight messages
 
 use crate::{FlightData, IpcMessage, SchemaAsIpc, SchemaResult};
+use bytes::Bytes;
 use std::collections::HashMap;
+use std::sync::Arc;
 
-use arrow::array::ArrayRef;
-use arrow::datatypes::{Schema, SchemaRef};
-use arrow::error::{ArrowError, Result};
-use arrow::ipc::{reader, writer, writer::IpcWriteOptions};
-use arrow::record_batch::RecordBatch;
-use std::convert::TryInto;
+use arrow_array::{ArrayRef, RecordBatch};
+use arrow_buffer::Buffer;
+use arrow_ipc::convert::fb_to_schema;
+use arrow_ipc::{reader, root_as_message, writer, writer::IpcWriteOptions};
+use arrow_schema::{ArrowError, Schema, SchemaRef};
 
 /// Convert a `RecordBatch` to a vector of `FlightData` representing the bytes of the dictionaries
 /// and a `FlightData` representing the bytes of the batch's values
+#[deprecated(
+    since = "30.0.0",
+    note = "Use IpcDataGenerator directly with DictionaryTracker to avoid re-sending dictionaries"
+)]
 pub fn flight_data_from_arrow_batch(
     batch: &RecordBatch,
     options: &IpcWriteOptions,
@@ -46,16 +51,38 @@ pub fn flight_data_from_arrow_batch(
     (flight_dictionaries, flight_batch)
 }
 
+/// Convert a slice of wire protocol `FlightData`s into a vector of `RecordBatch`es
+pub fn flight_data_to_batches(flight_data: &[FlightData]) -> Result<Vec<RecordBatch>, ArrowError> {
+    let schema = flight_data.first().ok_or_else(|| {
+        ArrowError::CastError("Need at least one FlightData for schema".to_string())
+    })?;
+    let message = root_as_message(&schema.data_header[..])
+        .map_err(|_| ArrowError::CastError("Cannot get root as message".to_string()))?;
+
+    let ipc_schema: arrow_ipc::Schema = message
+        .header_as_schema()
+        .ok_or_else(|| ArrowError::CastError("Cannot get header as Schema".to_string()))?;
+    let schema = fb_to_schema(ipc_schema);
+    let schema = Arc::new(schema);
+
+    let mut batches = vec![];
+    let dictionaries_by_id = HashMap::new();
+    for datum in flight_data[1..].iter() {
+        let batch = flight_data_to_arrow_batch(datum, schema.clone(), &dictionaries_by_id)?;
+        batches.push(batch);
+    }
+    Ok(batches)
+}
+
 /// Convert `FlightData` (with supplied schema and dictionaries) to an arrow `RecordBatch`.
 pub fn flight_data_to_arrow_batch(
     data: &FlightData,
     schema: SchemaRef,
     dictionaries_by_id: &HashMap<i64, ArrayRef>,
-) -> Result<RecordBatch> {
+) -> Result<RecordBatch, ArrowError> {
     // check that the data_header is a record batch message
-    let message = arrow::ipc::root_as_message(&data.data_header[..]).map_err(|err| {
-        ArrowError::ParseError(format!("Unable to get root as message: {:?}", err))
-    })?;
+    let message = arrow_ipc::root_as_message(&data.data_header[..])
+        .map_err(|err| ArrowError::ParseError(format!("Unable to get root as message: {err:?}")))?;
 
     message
         .header_as_record_batch()
@@ -66,7 +93,7 @@ pub fn flight_data_to_arrow_batch(
         })
         .map(|batch| {
             reader::read_record_batch(
-                &data.data_body,
+                &Buffer::from(&data.data_body),
                 batch,
                 schema,
                 dictionaries_by_id,
@@ -79,13 +106,13 @@ pub fn flight_data_to_arrow_batch(
 /// Convert a `Schema` to `SchemaResult` by converting to an IPC message
 #[deprecated(
     since = "4.4.0",
-    note = "Use From trait, e.g.: SchemaAsIpc::new(schema, options).into()"
+    note = "Use From trait, e.g.: SchemaAsIpc::new(schema, options).try_into()"
 )]
 pub fn flight_schema_from_arrow_schema(
     schema: &Schema,
     options: &IpcWriteOptions,
-) -> SchemaResult {
-    SchemaAsIpc::new(schema, options).into()
+) -> Result<SchemaResult, ArrowError> {
+    SchemaAsIpc::new(schema, options).try_into()
 }
 
 /// Convert a `Schema` to `FlightData` by converting to an IPC message
@@ -93,10 +120,7 @@ pub fn flight_schema_from_arrow_schema(
     since = "4.4.0",
     note = "Use From trait, e.g.: SchemaAsIpc::new(schema, options).into()"
 )]
-pub fn flight_data_from_arrow_schema(
-    schema: &Schema,
-    options: &IpcWriteOptions,
-) -> FlightData {
+pub fn flight_data_from_arrow_schema(schema: &Schema, options: &IpcWriteOptions) -> FlightData {
     SchemaAsIpc::new(schema, options).into()
 }
 
@@ -108,8 +132,35 @@ pub fn flight_data_from_arrow_schema(
 pub fn ipc_message_from_arrow_schema(
     schema: &Schema,
     options: &IpcWriteOptions,
-) -> Result<Vec<u8>> {
+) -> Result<Bytes, ArrowError> {
     let message = SchemaAsIpc::new(schema, options).try_into()?;
     let IpcMessage(vals) = message;
     Ok(vals)
 }
+
+/// Convert `RecordBatch`es to wire protocol `FlightData`s
+pub fn batches_to_flight_data(
+    schema: &Schema,
+    batches: Vec<RecordBatch>,
+) -> Result<Vec<FlightData>, ArrowError> {
+    let options = IpcWriteOptions::default();
+    let schema_flight_data: FlightData = SchemaAsIpc::new(schema, &options).into();
+    let mut dictionaries = vec![];
+    let mut flight_data = vec![];
+
+    let data_gen = writer::IpcDataGenerator::default();
+    let mut dictionary_tracker = writer::DictionaryTracker::new(false);
+
+    for batch in batches.iter() {
+        let (encoded_dictionaries, encoded_batch) =
+            data_gen.encoded_batch(batch, &mut dictionary_tracker, &options)?;
+
+        dictionaries.extend(encoded_dictionaries.into_iter().map(Into::into));
+        flight_data.push(encoded_batch.into());
+    }
+    let mut stream = vec![schema_flight_data];
+    stream.extend(dictionaries);
+    stream.extend(flight_data);
+    let flight_data: Vec<_> = stream.into_iter().collect();
+    Ok(flight_data)
+}
diff --git a/arrow-flight/tests/client.rs b/arrow-flight/tests/client.rs
new file mode 100644
index 000000000000..9e19bce92338
--- /dev/null
+++ b/arrow-flight/tests/client.rs
@@ -0,0 +1,1154 @@
+// 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.
+
+//! Integration test for "mid level" Client
+
+mod common {
+    pub mod server;
+    pub mod trailers_layer;
+}
+use arrow_array::{RecordBatch, UInt64Array};
+use arrow_flight::{
+    decode::FlightRecordBatchStream, encode::FlightDataEncoderBuilder, error::FlightError, Action,
+    ActionType, CancelFlightInfoRequest, CancelFlightInfoResult, CancelStatus, Criteria, Empty,
+    FlightClient, FlightData, FlightDescriptor, FlightEndpoint, FlightInfo, HandshakeRequest,
+    HandshakeResponse, PollInfo, PutResult, RenewFlightEndpointRequest, Ticket,
+};
+use arrow_schema::{DataType, Field, Schema};
+use bytes::Bytes;
+use common::{server::TestFlightServer, trailers_layer::TrailersLayer};
+use futures::{Future, StreamExt, TryStreamExt};
+use prost::Message;
+use tokio::{net::TcpListener, task::JoinHandle};
+use tonic::{
+    transport::{Channel, Uri},
+    Status,
+};
+
+use std::{net::SocketAddr, sync::Arc, time::Duration};
+
+const DEFAULT_TIMEOUT_SECONDS: u64 = 30;
+
+#[tokio::test]
+async fn test_handshake() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+        let request_payload = Bytes::from("foo-request-payload");
+        let response_payload = Bytes::from("bar-response-payload");
+
+        let request = HandshakeRequest {
+            payload: request_payload.clone(),
+            protocol_version: 0,
+        };
+
+        let response = HandshakeResponse {
+            payload: response_payload.clone(),
+            protocol_version: 0,
+        };
+
+        test_server.set_handshake_response(Ok(response));
+        let response = client.handshake(request_payload).await.unwrap();
+        assert_eq!(response, response_payload);
+        assert_eq!(test_server.take_handshake_request(), Some(request));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_handshake_error() {
+    do_test(|test_server, mut client| async move {
+        let request_payload = "foo-request-payload".to_string().into_bytes();
+        let e = Status::unauthenticated("DENIED");
+        test_server.set_handshake_response(Err(e.clone()));
+
+        let response = client.handshake(request_payload).await.unwrap_err();
+        expect_status(response, e);
+    })
+    .await;
+}
+
+/// Verifies that all headers sent from the the client are in the request_metadata
+fn ensure_metadata(client: &FlightClient, test_server: &TestFlightServer) {
+    let client_metadata = client.metadata().clone().into_headers();
+    assert!(!client_metadata.is_empty());
+    let metadata = test_server
+        .take_last_request_metadata()
+        .expect("No headers in server")
+        .into_headers();
+
+    for (k, v) in &client_metadata {
+        assert_eq!(
+            metadata.get(k).as_ref(),
+            Some(&v),
+            "Missing / Mismatched metadata {k:?} sent {client_metadata:?} got {metadata:?}"
+        );
+    }
+}
+
+fn test_flight_info(request: &FlightDescriptor) -> FlightInfo {
+    FlightInfo {
+        schema: Bytes::new(),
+        endpoint: vec![],
+        flight_descriptor: Some(request.clone()),
+        total_bytes: 123,
+        total_records: 456,
+        ordered: false,
+        app_metadata: Bytes::new(),
+    }
+}
+
+#[tokio::test]
+async fn test_get_flight_info() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+        let request = FlightDescriptor::new_cmd(b"My Command".to_vec());
+
+        let expected_response = test_flight_info(&request);
+        test_server.set_get_flight_info_response(Ok(expected_response.clone()));
+
+        let response = client.get_flight_info(request.clone()).await.unwrap();
+
+        assert_eq!(response, expected_response);
+        assert_eq!(test_server.take_get_flight_info_request(), Some(request));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_get_flight_info_error() {
+    do_test(|test_server, mut client| async move {
+        let request = FlightDescriptor::new_cmd(b"My Command".to_vec());
+
+        let e = Status::unauthenticated("DENIED");
+        test_server.set_get_flight_info_response(Err(e.clone()));
+
+        let response = client.get_flight_info(request.clone()).await.unwrap_err();
+        expect_status(response, e);
+    })
+    .await;
+}
+
+fn test_poll_info(request: &FlightDescriptor) -> PollInfo {
+    PollInfo {
+        info: Some(test_flight_info(request)),
+        flight_descriptor: None,
+        progress: Some(1.0),
+        expiration_time: None,
+    }
+}
+
+#[tokio::test]
+async fn test_poll_flight_info() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+        let request = FlightDescriptor::new_cmd(b"My Command".to_vec());
+
+        let expected_response = test_poll_info(&request);
+        test_server.set_poll_flight_info_response(Ok(expected_response.clone()));
+
+        let response = client.poll_flight_info(request.clone()).await.unwrap();
+
+        assert_eq!(response, expected_response);
+        assert_eq!(test_server.take_poll_flight_info_request(), Some(request));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_poll_flight_info_error() {
+    do_test(|test_server, mut client| async move {
+        let request = FlightDescriptor::new_cmd(b"My Command".to_vec());
+
+        let e = Status::unauthenticated("DENIED");
+        test_server.set_poll_flight_info_response(Err(e.clone()));
+
+        let response = client.poll_flight_info(request.clone()).await.unwrap_err();
+        expect_status(response, e);
+    })
+    .await;
+}
+
+// TODO more negative  tests (like if there are endpoints defined, etc)
+
+#[tokio::test]
+async fn test_do_get() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+        let ticket = Ticket {
+            ticket: Bytes::from("my awesome flight ticket"),
+        };
+
+        let batch = RecordBatch::try_from_iter(vec![(
+            "col",
+            Arc::new(UInt64Array::from_iter([1, 2, 3, 4])) as _,
+        )])
+        .unwrap();
+
+        let response = vec![Ok(batch.clone())];
+        test_server.set_do_get_response(response);
+        let mut response_stream = client
+            .do_get(ticket.clone())
+            .await
+            .expect("error making request");
+
+        assert_eq!(
+            response_stream
+                .headers()
+                .get("test-resp-header")
+                .expect("header exists")
+                .to_str()
+                .unwrap(),
+            "some_val",
+        );
+
+        // trailers are not available before stream exhaustion
+        assert!(response_stream.trailers().is_none());
+
+        let expected_response = vec![batch];
+        let response: Vec<_> = (&mut response_stream)
+            .try_collect()
+            .await
+            .expect("Error streaming data");
+        assert_eq!(response, expected_response);
+
+        assert_eq!(
+            response_stream
+                .trailers()
+                .expect("stream exhausted")
+                .get("test-trailer")
+                .expect("trailer exists")
+                .to_str()
+                .unwrap(),
+            "trailer_val",
+        );
+
+        assert_eq!(test_server.take_do_get_request(), Some(ticket));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_get_error() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+        let ticket = Ticket {
+            ticket: Bytes::from("my awesome flight ticket"),
+        };
+
+        let response = client.do_get(ticket.clone()).await.unwrap_err();
+
+        let e = Status::internal("No do_get response configured");
+        expect_status(response, e);
+        // server still got the request
+        assert_eq!(test_server.take_do_get_request(), Some(ticket));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_get_error_in_record_batch_stream() {
+    do_test(|test_server, mut client| async move {
+        let ticket = Ticket {
+            ticket: Bytes::from("my awesome flight ticket"),
+        };
+
+        let batch = RecordBatch::try_from_iter(vec![(
+            "col",
+            Arc::new(UInt64Array::from_iter([1, 2, 3, 4])) as _,
+        )])
+        .unwrap();
+
+        let e = Status::data_loss("she's dead jim");
+
+        let expected_response = vec![Ok(batch), Err(e.clone())];
+
+        test_server.set_do_get_response(expected_response);
+
+        let response_stream = client
+            .do_get(ticket.clone())
+            .await
+            .expect("error making request");
+
+        let response: Result<Vec<_>, FlightError> = response_stream.try_collect().await;
+
+        let response = response.unwrap_err();
+        expect_status(response, e);
+        // server still got the request
+        assert_eq!(test_server.take_do_get_request(), Some(ticket));
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_put() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        // encode the batch as a stream of FlightData
+        let input_flight_data = test_flight_data().await;
+
+        let expected_response = vec![
+            PutResult {
+                app_metadata: Bytes::from("foo-metadata1"),
+            },
+            PutResult {
+                app_metadata: Bytes::from("bar-metadata2"),
+            },
+        ];
+
+        test_server.set_do_put_response(expected_response.clone().into_iter().map(Ok).collect());
+
+        let input_stream = futures::stream::iter(input_flight_data.clone()).map(Ok);
+
+        let response_stream = client
+            .do_put(input_stream)
+            .await
+            .expect("error making request");
+
+        let response: Vec<_> = response_stream
+            .try_collect()
+            .await
+            .expect("Error streaming data");
+
+        assert_eq!(response, expected_response);
+        assert_eq!(test_server.take_do_put_request(), Some(input_flight_data));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_put_error_server() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let input_flight_data = test_flight_data().await;
+
+        let input_stream = futures::stream::iter(input_flight_data.clone()).map(Ok);
+
+        let response = client.do_put(input_stream).await;
+        let response = match response {
+            Ok(_) => panic!("unexpected success"),
+            Err(e) => e,
+        };
+
+        let e = Status::internal("No do_put response configured");
+        expect_status(response, e);
+        // server still got the request
+        assert_eq!(test_server.take_do_put_request(), Some(input_flight_data));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_put_error_stream_server() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let input_flight_data = test_flight_data().await;
+
+        let e = Status::invalid_argument("bad arg");
+
+        let response = vec![
+            Ok(PutResult {
+                app_metadata: Bytes::from("foo-metadata"),
+            }),
+            Err(e.clone()),
+        ];
+
+        test_server.set_do_put_response(response);
+
+        let input_stream = futures::stream::iter(input_flight_data.clone()).map(Ok);
+
+        let response_stream = client
+            .do_put(input_stream)
+            .await
+            .expect("error making request");
+
+        let response: Result<Vec<_>, _> = response_stream.try_collect().await;
+        let response = match response {
+            Ok(_) => panic!("unexpected success"),
+            Err(e) => e,
+        };
+
+        expect_status(response, e);
+        // server still got the request
+        assert_eq!(test_server.take_do_put_request(), Some(input_flight_data));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_put_error_client() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let e = Status::invalid_argument("bad arg: client");
+
+        // input stream to client sends good FlightData followed by an error
+        let input_flight_data = test_flight_data().await;
+        let input_stream = futures::stream::iter(input_flight_data.clone())
+            .map(Ok)
+            .chain(futures::stream::iter(vec![Err(FlightError::from(
+                e.clone(),
+            ))]));
+
+        // server responds with one good message
+        let response = vec![Ok(PutResult {
+            app_metadata: Bytes::from("foo-metadata"),
+        })];
+        test_server.set_do_put_response(response);
+
+        let response_stream = client
+            .do_put(input_stream)
+            .await
+            .expect("error making request");
+
+        let response: Result<Vec<_>, _> = response_stream.try_collect().await;
+        let response = match response {
+            Ok(_) => panic!("unexpected success"),
+            Err(e) => e,
+        };
+
+        // expect to the error made from the client
+        expect_status(response, e);
+        // server still got the request messages until the client sent the error
+        assert_eq!(test_server.take_do_put_request(), Some(input_flight_data));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_put_error_client_and_server() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let e_client = Status::invalid_argument("bad arg: client");
+        let e_server = Status::invalid_argument("bad arg: server");
+
+        // input stream to client sends good FlightData followed by an error
+        let input_flight_data = test_flight_data().await;
+        let input_stream = futures::stream::iter(input_flight_data.clone())
+            .map(Ok)
+            .chain(futures::stream::iter(vec![Err(FlightError::from(
+                e_client.clone(),
+            ))]));
+
+        // server responds with an error (e.g. because it got truncated data)
+        let response = vec![Err(e_server)];
+        test_server.set_do_put_response(response);
+
+        let response_stream = client
+            .do_put(input_stream)
+            .await
+            .expect("error making request");
+
+        let response: Result<Vec<_>, _> = response_stream.try_collect().await;
+        let response = match response {
+            Ok(_) => panic!("unexpected success"),
+            Err(e) => e,
+        };
+
+        // expect to the error made from the client (not the server)
+        expect_status(response, e_client);
+        // server still got the request messages until the client sent the error
+        assert_eq!(test_server.take_do_put_request(), Some(input_flight_data));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_exchange() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        // encode the batch as a stream of FlightData
+        let input_flight_data = test_flight_data().await;
+        let output_flight_data = test_flight_data2().await;
+
+        test_server
+            .set_do_exchange_response(output_flight_data.clone().into_iter().map(Ok).collect());
+
+        let response_stream = client
+            .do_exchange(futures::stream::iter(input_flight_data.clone()))
+            .await
+            .expect("error making request");
+
+        let response: Vec<_> = response_stream
+            .try_collect()
+            .await
+            .expect("Error streaming data");
+
+        let expected_stream = futures::stream::iter(output_flight_data).map(Ok);
+
+        let expected_batches: Vec<_> =
+            FlightRecordBatchStream::new_from_flight_data(expected_stream)
+                .try_collect()
+                .await
+                .unwrap();
+
+        assert_eq!(response, expected_batches);
+        assert_eq!(
+            test_server.take_do_exchange_request(),
+            Some(input_flight_data)
+        );
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_exchange_error() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let input_flight_data = test_flight_data().await;
+
+        let response = client
+            .do_exchange(futures::stream::iter(input_flight_data.clone()))
+            .await;
+        let response = match response {
+            Ok(_) => panic!("unexpected success"),
+            Err(e) => e,
+        };
+
+        let e = Status::internal("No do_exchange response configured");
+        expect_status(response, e);
+        // server still got the request
+        assert_eq!(
+            test_server.take_do_exchange_request(),
+            Some(input_flight_data)
+        );
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_exchange_error_stream() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let input_flight_data = test_flight_data().await;
+
+        let e = Status::invalid_argument("the error");
+        let response = test_flight_data2()
+            .await
+            .into_iter()
+            .enumerate()
+            .map(|(i, m)| {
+                if i == 0 {
+                    Ok(m)
+                } else {
+                    // make all messages after the first an error
+                    Err(e.clone())
+                }
+            })
+            .collect();
+
+        test_server.set_do_exchange_response(response);
+
+        let response_stream = client
+            .do_exchange(futures::stream::iter(input_flight_data.clone()))
+            .await
+            .expect("error making request");
+
+        let response: Result<Vec<_>, _> = response_stream.try_collect().await;
+        let response = match response {
+            Ok(_) => panic!("unexpected success"),
+            Err(e) => e,
+        };
+
+        expect_status(response, e);
+        // server still got the request
+        assert_eq!(
+            test_server.take_do_exchange_request(),
+            Some(input_flight_data)
+        );
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_get_schema() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let schema = Schema::new(vec![Field::new("foo", DataType::Int64, true)]);
+
+        let request = FlightDescriptor::new_cmd("my command");
+        test_server.set_get_schema_response(Ok(schema.clone()));
+
+        let response = client
+            .get_schema(request.clone())
+            .await
+            .expect("error making request");
+
+        let expected_schema = schema;
+        let expected_request = request;
+
+        assert_eq!(response, expected_schema);
+        assert_eq!(
+            test_server.take_get_schema_request(),
+            Some(expected_request)
+        );
+
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_get_schema_error() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+        let request = FlightDescriptor::new_cmd("my command");
+
+        let e = Status::unauthenticated("DENIED");
+        test_server.set_get_schema_response(Err(e.clone()));
+
+        let response = client.get_schema(request).await.unwrap_err();
+        expect_status(response, e);
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_list_flights() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let infos = vec![
+            test_flight_info(&FlightDescriptor::new_cmd("foo")),
+            test_flight_info(&FlightDescriptor::new_cmd("bar")),
+        ];
+
+        let response = infos.iter().map(|i| Ok(i.clone())).collect();
+        test_server.set_list_flights_response(response);
+
+        let response_stream = client
+            .list_flights("query")
+            .await
+            .expect("error making request");
+
+        let expected_response = infos;
+        let response: Vec<_> = response_stream
+            .try_collect()
+            .await
+            .expect("Error streaming data");
+
+        let expected_request = Some(Criteria {
+            expression: "query".into(),
+        });
+
+        assert_eq!(response, expected_response);
+        assert_eq!(test_server.take_list_flights_request(), expected_request);
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_list_flights_error() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let response = client.list_flights("query").await;
+        let response = match response {
+            Ok(_) => panic!("unexpected success"),
+            Err(e) => e,
+        };
+
+        let e = Status::internal("No list_flights response configured");
+        expect_status(response, e);
+        // server still got the request
+        let expected_request = Some(Criteria {
+            expression: "query".into(),
+        });
+        assert_eq!(test_server.take_list_flights_request(), expected_request);
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_list_flights_error_in_stream() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let e = Status::data_loss("she's dead jim");
+
+        let response = vec![
+            Ok(test_flight_info(&FlightDescriptor::new_cmd("foo"))),
+            Err(e.clone()),
+        ];
+        test_server.set_list_flights_response(response);
+
+        let response_stream = client
+            .list_flights("other query")
+            .await
+            .expect("error making request");
+
+        let response: Result<Vec<_>, FlightError> = response_stream.try_collect().await;
+
+        let response = response.unwrap_err();
+        expect_status(response, e);
+        // server still got the request
+        let expected_request = Some(Criteria {
+            expression: "other query".into(),
+        });
+        assert_eq!(test_server.take_list_flights_request(), expected_request);
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_list_actions() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let actions = vec![
+            ActionType {
+                r#type: "type 1".into(),
+                description: "awesomeness".into(),
+            },
+            ActionType {
+                r#type: "type 2".into(),
+                description: "more awesomeness".into(),
+            },
+        ];
+
+        let response = actions.iter().map(|i| Ok(i.clone())).collect();
+        test_server.set_list_actions_response(response);
+
+        let response_stream = client.list_actions().await.expect("error making request");
+
+        let expected_response = actions;
+        let response: Vec<_> = response_stream
+            .try_collect()
+            .await
+            .expect("Error streaming data");
+
+        assert_eq!(response, expected_response);
+        assert_eq!(test_server.take_list_actions_request(), Some(Empty {}));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_list_actions_error() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let response = client.list_actions().await;
+        let response = match response {
+            Ok(_) => panic!("unexpected success"),
+            Err(e) => e,
+        };
+
+        let e = Status::internal("No list_actions response configured");
+        expect_status(response, e);
+        // server still got the request
+        assert_eq!(test_server.take_list_actions_request(), Some(Empty {}));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_list_actions_error_in_stream() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let e = Status::data_loss("she's dead jim");
+
+        let response = vec![
+            Ok(ActionType {
+                r#type: "type 1".into(),
+                description: "awesomeness".into(),
+            }),
+            Err(e.clone()),
+        ];
+        test_server.set_list_actions_response(response);
+
+        let response_stream = client.list_actions().await.expect("error making request");
+
+        let response: Result<Vec<_>, FlightError> = response_stream.try_collect().await;
+
+        let response = response.unwrap_err();
+        expect_status(response, e);
+        // server still got the request
+        assert_eq!(test_server.take_list_actions_request(), Some(Empty {}));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_action() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let bytes = vec![Bytes::from("foo"), Bytes::from("blarg")];
+
+        let response = bytes
+            .iter()
+            .cloned()
+            .map(arrow_flight::Result::new)
+            .map(Ok)
+            .collect();
+        test_server.set_do_action_response(response);
+
+        let request = Action::new("action type", "action body");
+
+        let response_stream = client
+            .do_action(request.clone())
+            .await
+            .expect("error making request");
+
+        let expected_response = bytes;
+        let response: Vec<_> = response_stream
+            .try_collect()
+            .await
+            .expect("Error streaming data");
+
+        assert_eq!(response, expected_response);
+        assert_eq!(test_server.take_do_action_request(), Some(request));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_action_error() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let request = Action::new("action type", "action body");
+
+        let response = client.do_action(request.clone()).await;
+        let response = match response {
+            Ok(_) => panic!("unexpected success"),
+            Err(e) => e,
+        };
+
+        let e = Status::internal("No do_action response configured");
+        expect_status(response, e);
+        // server still got the request
+        assert_eq!(test_server.take_do_action_request(), Some(request));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_do_action_error_in_stream() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let e = Status::data_loss("she's dead jim");
+
+        let request = Action::new("action type", "action body");
+
+        let response = vec![Ok(arrow_flight::Result::new("foo")), Err(e.clone())];
+        test_server.set_do_action_response(response);
+
+        let response_stream = client
+            .do_action(request.clone())
+            .await
+            .expect("error making request");
+
+        let response: Result<Vec<_>, FlightError> = response_stream.try_collect().await;
+
+        let response = response.unwrap_err();
+        expect_status(response, e);
+        // server still got the request
+        assert_eq!(test_server.take_do_action_request(), Some(request));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_cancel_flight_info() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let expected_response = CancelFlightInfoResult::new(CancelStatus::Cancelled);
+        let response = expected_response.encode_to_vec();
+        let response = Ok(arrow_flight::Result::new(response));
+        test_server.set_do_action_response(vec![response]);
+
+        let request = CancelFlightInfoRequest::new(FlightInfo::new());
+        let actual_response = client
+            .cancel_flight_info(request.clone())
+            .await
+            .expect("error making request");
+
+        let expected_request = Action::new("CancelFlightInfo", request.encode_to_vec());
+        assert_eq!(actual_response, expected_response);
+        assert_eq!(test_server.take_do_action_request(), Some(expected_request));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_cancel_flight_info_error_no_response() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        test_server.set_do_action_response(vec![]);
+
+        let request = CancelFlightInfoRequest::new(FlightInfo::new());
+        let err = client
+            .cancel_flight_info(request.clone())
+            .await
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "ProtocolError(\"Received no response for cancel_flight_info call\")"
+        );
+        // server still got the request
+        let expected_request = Action::new("CancelFlightInfo", request.encode_to_vec());
+        assert_eq!(test_server.take_do_action_request(), Some(expected_request));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_renew_flight_endpoint() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        let expected_response = FlightEndpoint::new().with_app_metadata(vec![1]);
+        let response = expected_response.encode_to_vec();
+        let response = Ok(arrow_flight::Result::new(response));
+        test_server.set_do_action_response(vec![response]);
+
+        let request =
+            RenewFlightEndpointRequest::new(FlightEndpoint::new().with_app_metadata(vec![0]));
+        let actual_response = client
+            .renew_flight_endpoint(request.clone())
+            .await
+            .expect("error making request");
+
+        let expected_request = Action::new("RenewFlightEndpoint", request.encode_to_vec());
+        assert_eq!(actual_response, expected_response);
+        assert_eq!(test_server.take_do_action_request(), Some(expected_request));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+#[tokio::test]
+async fn test_renew_flight_endpoint_error_no_response() {
+    do_test(|test_server, mut client| async move {
+        client.add_header("foo-header", "bar-header-value").unwrap();
+
+        test_server.set_do_action_response(vec![]);
+
+        let request = RenewFlightEndpointRequest::new(FlightEndpoint::new());
+        let err = client
+            .renew_flight_endpoint(request.clone())
+            .await
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "ProtocolError(\"Received no response for renew_flight_endpoint call\")"
+        );
+        // server still got the request
+        let expected_request = Action::new("RenewFlightEndpoint", request.encode_to_vec());
+        assert_eq!(test_server.take_do_action_request(), Some(expected_request));
+        ensure_metadata(&client, &test_server);
+    })
+    .await;
+}
+
+async fn test_flight_data() -> Vec<FlightData> {
+    let batch = RecordBatch::try_from_iter(vec![(
+        "col",
+        Arc::new(UInt64Array::from_iter([1, 2, 3, 4])) as _,
+    )])
+    .unwrap();
+
+    // encode the batch as a stream of FlightData
+    FlightDataEncoderBuilder::new()
+        .build(futures::stream::iter(vec![Ok(batch)]))
+        .try_collect()
+        .await
+        .unwrap()
+}
+
+async fn test_flight_data2() -> Vec<FlightData> {
+    let batch = RecordBatch::try_from_iter(vec![(
+        "col2",
+        Arc::new(UInt64Array::from_iter([10, 23, 33])) as _,
+    )])
+    .unwrap();
+
+    // encode the batch as a stream of FlightData
+    FlightDataEncoderBuilder::new()
+        .build(futures::stream::iter(vec![Ok(batch)]))
+        .try_collect()
+        .await
+        .unwrap()
+}
+
+/// Runs the future returned by the function,  passing it a test server and client
+async fn do_test<F, Fut>(f: F)
+where
+    F: Fn(TestFlightServer, FlightClient) -> Fut,
+    Fut: Future<Output = ()>,
+{
+    let test_server = TestFlightServer::new();
+    let fixture = TestFixture::new(&test_server).await;
+    let client = FlightClient::new(fixture.channel().await);
+
+    // run the test function
+    f(test_server, client).await;
+
+    // cleanly shutdown the test fixture
+    fixture.shutdown_and_wait().await
+}
+
+fn expect_status(error: FlightError, expected: Status) {
+    let status = if let FlightError::Tonic(status) = error {
+        status
+    } else {
+        panic!("Expected FlightError::Tonic, got: {error:?}");
+    };
+
+    assert_eq!(
+        status.code(),
+        expected.code(),
+        "Got {status:?} want {expected:?}"
+    );
+    assert_eq!(
+        status.message(),
+        expected.message(),
+        "Got {status:?} want {expected:?}"
+    );
+    assert_eq!(
+        status.details(),
+        expected.details(),
+        "Got {status:?} want {expected:?}"
+    );
+}
+
+/// Creates and manages a running TestServer with a background task
+struct TestFixture {
+    /// channel to send shutdown command
+    shutdown: Option<tokio::sync::oneshot::Sender<()>>,
+
+    /// Address the server is listening on
+    addr: SocketAddr,
+
+    // handle for the server task
+    handle: Option<JoinHandle<Result<(), tonic::transport::Error>>>,
+}
+
+impl TestFixture {
+    /// create a new test fixture from the server
+    pub async fn new(test_server: &TestFlightServer) -> Self {
+        // let OS choose a a free port
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+
+        println!("Listening on {addr}");
+
+        // prepare the shutdown channel
+        let (tx, rx) = tokio::sync::oneshot::channel();
+
+        let server_timeout = Duration::from_secs(DEFAULT_TIMEOUT_SECONDS);
+
+        let shutdown_future = async move {
+            rx.await.ok();
+        };
+
+        let serve_future = tonic::transport::Server::builder()
+            .timeout(server_timeout)
+            .layer(TrailersLayer)
+            .add_service(test_server.service())
+            .serve_with_incoming_shutdown(
+                tokio_stream::wrappers::TcpListenerStream::new(listener),
+                shutdown_future,
+            );
+
+        // Run the server in its own background task
+        let handle = tokio::task::spawn(serve_future);
+
+        Self {
+            shutdown: Some(tx),
+            addr,
+            handle: Some(handle),
+        }
+    }
+
+    /// Return a [`Channel`] connected to the TestServer
+    pub async fn channel(&self) -> Channel {
+        let url = format!("http://{}", self.addr);
+        let uri: Uri = url.parse().expect("Valid URI");
+        Channel::builder(uri)
+            .timeout(Duration::from_secs(DEFAULT_TIMEOUT_SECONDS))
+            .connect()
+            .await
+            .expect("error connecting to server")
+    }
+
+    /// Stops the test server and waits for the server to shutdown
+    pub async fn shutdown_and_wait(mut self) {
+        if let Some(shutdown) = self.shutdown.take() {
+            shutdown.send(()).expect("server quit early");
+        }
+        if let Some(handle) = self.handle.take() {
+            println!("Waiting on server to finish");
+            handle
+                .await
+                .expect("task join error (panic?)")
+                .expect("Server Error found at shutdown");
+        }
+    }
+}
+
+impl Drop for TestFixture {
+    fn drop(&mut self) {
+        if let Some(shutdown) = self.shutdown.take() {
+            shutdown.send(()).ok();
+        }
+        if self.handle.is_some() {
+            // tests should properly clean up TestFixture
+            println!("TestFixture::Drop called prior to `shutdown_and_wait`");
+        }
+    }
+}
diff --git a/arrow-flight/tests/common/server.rs b/arrow-flight/tests/common/server.rs
new file mode 100644
index 000000000000..a75590a13334
--- /dev/null
+++ b/arrow-flight/tests/common/server.rs
@@ -0,0 +1,479 @@
+// 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.
+
+use std::sync::{Arc, Mutex};
+
+use arrow_array::RecordBatch;
+use arrow_schema::Schema;
+use futures::{stream::BoxStream, StreamExt, TryStreamExt};
+use tonic::{metadata::MetadataMap, Request, Response, Status, Streaming};
+
+use arrow_flight::{
+    encode::FlightDataEncoderBuilder,
+    flight_service_server::{FlightService, FlightServiceServer},
+    Action, ActionType, Criteria, Empty, FlightData, FlightDescriptor, FlightInfo,
+    HandshakeRequest, HandshakeResponse, PollInfo, PutResult, SchemaAsIpc, SchemaResult, Ticket,
+};
+
+#[derive(Debug, Clone)]
+/// Flight server for testing, with configurable responses
+pub struct TestFlightServer {
+    /// Shared state to configure responses
+    state: Arc<Mutex<State>>,
+}
+
+impl TestFlightServer {
+    /// Create a `TestFlightServer`
+    pub fn new() -> Self {
+        Self {
+            state: Arc::new(Mutex::new(State::new())),
+        }
+    }
+
+    /// Return an [`FlightServiceServer`] that can be used with a
+    /// [`Server`](tonic::transport::Server)
+    pub fn service(&self) -> FlightServiceServer<TestFlightServer> {
+        // wrap up tonic goop
+        FlightServiceServer::new(self.clone())
+    }
+
+    /// Specify the response returned from the next call to handshake
+    pub fn set_handshake_response(&self, response: Result<HandshakeResponse, Status>) {
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.handshake_response.replace(response);
+    }
+
+    /// Take and return last handshake request sent to the server,
+    pub fn take_handshake_request(&self) -> Option<HandshakeRequest> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .handshake_request
+            .take()
+    }
+
+    /// Specify the response returned from the next call to get_flight_info
+    pub fn set_get_flight_info_response(&self, response: Result<FlightInfo, Status>) {
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.get_flight_info_response.replace(response);
+    }
+
+    /// Take and return last get_flight_info request sent to the server,
+    pub fn take_get_flight_info_request(&self) -> Option<FlightDescriptor> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .get_flight_info_request
+            .take()
+    }
+
+    /// Specify the response returned from the next call to poll_flight_info
+    pub fn set_poll_flight_info_response(&self, response: Result<PollInfo, Status>) {
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.poll_flight_info_response.replace(response);
+    }
+
+    /// Take and return last poll_flight_info request sent to the server,
+    pub fn take_poll_flight_info_request(&self) -> Option<FlightDescriptor> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .poll_flight_info_request
+            .take()
+    }
+
+    /// Specify the response returned from the next call to `do_get`
+    pub fn set_do_get_response(&self, response: Vec<Result<RecordBatch, Status>>) {
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.do_get_response.replace(response);
+    }
+
+    /// Take and return last do_get request send to the server,
+    pub fn take_do_get_request(&self) -> Option<Ticket> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .do_get_request
+            .take()
+    }
+
+    /// Specify the response returned from the next call to `do_put`
+    pub fn set_do_put_response(&self, response: Vec<Result<PutResult, Status>>) {
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.do_put_response.replace(response);
+    }
+
+    /// Take and return last do_put request sent to the server,
+    pub fn take_do_put_request(&self) -> Option<Vec<FlightData>> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .do_put_request
+            .take()
+    }
+
+    /// Specify the response returned from the next call to `do_exchange`
+    pub fn set_do_exchange_response(&self, response: Vec<Result<FlightData, Status>>) {
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.do_exchange_response.replace(response);
+    }
+
+    /// Take and return last do_exchange request send to the server,
+    pub fn take_do_exchange_request(&self) -> Option<Vec<FlightData>> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .do_exchange_request
+            .take()
+    }
+
+    /// Specify the response returned from the next call to `list_flights`
+    pub fn set_list_flights_response(&self, response: Vec<Result<FlightInfo, Status>>) {
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.list_flights_response.replace(response);
+    }
+
+    /// Take and return last list_flights request send to the server,
+    pub fn take_list_flights_request(&self) -> Option<Criteria> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .list_flights_request
+            .take()
+    }
+
+    /// Specify the response returned from the next call to `get_schema`
+    pub fn set_get_schema_response(&self, response: Result<Schema, Status>) {
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.get_schema_response.replace(response);
+    }
+
+    /// Take and return last get_schema request send to the server,
+    pub fn take_get_schema_request(&self) -> Option<FlightDescriptor> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .get_schema_request
+            .take()
+    }
+
+    /// Specify the response returned from the next call to `list_actions`
+    pub fn set_list_actions_response(&self, response: Vec<Result<ActionType, Status>>) {
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.list_actions_response.replace(response);
+    }
+
+    /// Take and return last list_actions request send to the server,
+    pub fn take_list_actions_request(&self) -> Option<Empty> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .list_actions_request
+            .take()
+    }
+
+    /// Specify the response returned from the next call to `do_action`
+    pub fn set_do_action_response(&self, response: Vec<Result<arrow_flight::Result, Status>>) {
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.do_action_response.replace(response);
+    }
+
+    /// Take and return last do_action request send to the server,
+    pub fn take_do_action_request(&self) -> Option<Action> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .do_action_request
+            .take()
+    }
+
+    /// Returns the last metadata from a request received by the server
+    pub fn take_last_request_metadata(&self) -> Option<MetadataMap> {
+        self.state
+            .lock()
+            .expect("mutex not poisoned")
+            .last_request_metadata
+            .take()
+    }
+
+    /// Save the last request's metadatacom
+    fn save_metadata<T>(&self, request: &Request<T>) {
+        let metadata = request.metadata().clone();
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.last_request_metadata = Some(metadata);
+    }
+}
+
+/// mutable state for the TestFlightServer, captures requests and provides responses
+#[derive(Debug, Default)]
+struct State {
+    /// The last handshake request that was received
+    pub handshake_request: Option<HandshakeRequest>,
+    /// The next response to return from `handshake()`
+    pub handshake_response: Option<Result<HandshakeResponse, Status>>,
+    /// The last `get_flight_info` request received
+    pub get_flight_info_request: Option<FlightDescriptor>,
+    /// The next response to return from `get_flight_info`
+    pub get_flight_info_response: Option<Result<FlightInfo, Status>>,
+    /// The last `poll_flight_info` request received
+    pub poll_flight_info_request: Option<FlightDescriptor>,
+    /// The next response to return from `poll_flight_info`
+    pub poll_flight_info_response: Option<Result<PollInfo, Status>>,
+    /// The last do_get request received
+    pub do_get_request: Option<Ticket>,
+    /// The next response returned from `do_get`
+    pub do_get_response: Option<Vec<Result<RecordBatch, Status>>>,
+    /// The last do_put request received
+    pub do_put_request: Option<Vec<FlightData>>,
+    /// The next response returned from `do_put`
+    pub do_put_response: Option<Vec<Result<PutResult, Status>>>,
+    /// The last do_exchange request received
+    pub do_exchange_request: Option<Vec<FlightData>>,
+    /// The next response returned from `do_exchange`
+    pub do_exchange_response: Option<Vec<Result<FlightData, Status>>>,
+    /// The last list_flights request received
+    pub list_flights_request: Option<Criteria>,
+    /// The next response returned from `list_flights`
+    pub list_flights_response: Option<Vec<Result<FlightInfo, Status>>>,
+    /// The last get_schema request received
+    pub get_schema_request: Option<FlightDescriptor>,
+    /// The next response returned from `get_schema`
+    pub get_schema_response: Option<Result<Schema, Status>>,
+    /// The last list_actions request received
+    pub list_actions_request: Option<Empty>,
+    /// The next response returned from `list_actions`
+    pub list_actions_response: Option<Vec<Result<ActionType, Status>>>,
+    /// The last do_action request received
+    pub do_action_request: Option<Action>,
+    /// The next response returned from `do_action`
+    pub do_action_response: Option<Vec<Result<arrow_flight::Result, Status>>>,
+    /// The last request headers received
+    pub last_request_metadata: Option<MetadataMap>,
+}
+
+impl State {
+    fn new() -> Self {
+        Default::default()
+    }
+}
+
+/// Implement the FlightService trait
+#[tonic::async_trait]
+impl FlightService for TestFlightServer {
+    type HandshakeStream = BoxStream<'static, Result<HandshakeResponse, Status>>;
+    type ListFlightsStream = BoxStream<'static, Result<FlightInfo, Status>>;
+    type DoGetStream = BoxStream<'static, Result<FlightData, Status>>;
+    type DoPutStream = BoxStream<'static, Result<PutResult, Status>>;
+    type DoActionStream = BoxStream<'static, Result<arrow_flight::Result, Status>>;
+    type ListActionsStream = BoxStream<'static, Result<ActionType, Status>>;
+    type DoExchangeStream = BoxStream<'static, Result<FlightData, Status>>;
+
+    async fn handshake(
+        &self,
+        request: Request<Streaming<HandshakeRequest>>,
+    ) -> Result<Response<Self::HandshakeStream>, Status> {
+        self.save_metadata(&request);
+        let handshake_request = request.into_inner().message().await?.unwrap();
+
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.handshake_request = Some(handshake_request);
+
+        let response = state
+            .handshake_response
+            .take()
+            .unwrap_or_else(|| Err(Status::internal("No handshake response configured")))?;
+
+        // turn into a streaming response
+        let output = futures::stream::iter(std::iter::once(Ok(response)));
+        Ok(Response::new(output.boxed()))
+    }
+
+    async fn list_flights(
+        &self,
+        request: Request<Criteria>,
+    ) -> Result<Response<Self::ListFlightsStream>, Status> {
+        self.save_metadata(&request);
+        let mut state = self.state.lock().expect("mutex not poisoned");
+
+        state.list_flights_request = Some(request.into_inner());
+
+        let flights: Vec<_> = state
+            .list_flights_response
+            .take()
+            .ok_or_else(|| Status::internal("No list_flights response configured"))?;
+
+        let flights_stream = futures::stream::iter(flights);
+
+        Ok(Response::new(flights_stream.boxed()))
+    }
+
+    async fn get_flight_info(
+        &self,
+        request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        self.save_metadata(&request);
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.get_flight_info_request = Some(request.into_inner());
+        let response = state
+            .get_flight_info_response
+            .take()
+            .unwrap_or_else(|| Err(Status::internal("No get_flight_info response configured")))?;
+        Ok(Response::new(response))
+    }
+
+    async fn poll_flight_info(
+        &self,
+        request: Request<FlightDescriptor>,
+    ) -> Result<Response<PollInfo>, Status> {
+        self.save_metadata(&request);
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.poll_flight_info_request = Some(request.into_inner());
+        let response = state
+            .poll_flight_info_response
+            .take()
+            .unwrap_or_else(|| Err(Status::internal("No poll_flight_info response configured")))?;
+        Ok(Response::new(response))
+    }
+
+    async fn get_schema(
+        &self,
+        request: Request<FlightDescriptor>,
+    ) -> Result<Response<SchemaResult>, Status> {
+        self.save_metadata(&request);
+        let mut state = self.state.lock().expect("mutex not poisoned");
+        state.get_schema_request = Some(request.into_inner());
+        let schema = state
+            .get_schema_response
+            .take()
+            .unwrap_or_else(|| Err(Status::internal("No get_schema response configured")))?;
+
+        // encode the schema
+        let options = arrow_ipc::writer::IpcWriteOptions::default();
+        let response: SchemaResult = SchemaAsIpc::new(&schema, &options)
+            .try_into()
+            .expect("Error encoding schema");
+
+        Ok(Response::new(response))
+    }
+
+    async fn do_get(
+        &self,
+        request: Request<Ticket>,
+    ) -> Result<Response<Self::DoGetStream>, Status> {
+        self.save_metadata(&request);
+        let mut state = self.state.lock().expect("mutex not poisoned");
+
+        state.do_get_request = Some(request.into_inner());
+
+        let batches: Vec<_> = state
+            .do_get_response
+            .take()
+            .ok_or_else(|| Status::internal("No do_get response configured"))?;
+
+        let batch_stream = futures::stream::iter(batches).map_err(Into::into);
+
+        let stream = FlightDataEncoderBuilder::new()
+            .build(batch_stream)
+            .map_err(Into::into);
+
+        let mut resp = Response::new(stream.boxed());
+        resp.metadata_mut()
+            .insert("test-resp-header", "some_val".parse().unwrap());
+
+        Ok(resp)
+    }
+
+    async fn do_put(
+        &self,
+        request: Request<Streaming<FlightData>>,
+    ) -> Result<Response<Self::DoPutStream>, Status> {
+        self.save_metadata(&request);
+        let do_put_request: Vec<_> = request.into_inner().try_collect().await?;
+
+        let mut state = self.state.lock().expect("mutex not poisoned");
+
+        state.do_put_request = Some(do_put_request);
+
+        let response = state
+            .do_put_response
+            .take()
+            .ok_or_else(|| Status::internal("No do_put response configured"))?;
+
+        let stream = futures::stream::iter(response).map_err(Into::into);
+
+        Ok(Response::new(stream.boxed()))
+    }
+
+    async fn do_action(
+        &self,
+        request: Request<Action>,
+    ) -> Result<Response<Self::DoActionStream>, Status> {
+        self.save_metadata(&request);
+        let mut state = self.state.lock().expect("mutex not poisoned");
+
+        state.do_action_request = Some(request.into_inner());
+
+        let results: Vec<_> = state
+            .do_action_response
+            .take()
+            .ok_or_else(|| Status::internal("No do_action response configured"))?;
+
+        let results_stream = futures::stream::iter(results);
+
+        Ok(Response::new(results_stream.boxed()))
+    }
+
+    async fn list_actions(
+        &self,
+        request: Request<Empty>,
+    ) -> Result<Response<Self::ListActionsStream>, Status> {
+        self.save_metadata(&request);
+        let mut state = self.state.lock().expect("mutex not poisoned");
+
+        state.list_actions_request = Some(request.into_inner());
+
+        let actions: Vec<_> = state
+            .list_actions_response
+            .take()
+            .ok_or_else(|| Status::internal("No list_actions response configured"))?;
+
+        let action_stream = futures::stream::iter(actions);
+
+        Ok(Response::new(action_stream.boxed()))
+    }
+
+    async fn do_exchange(
+        &self,
+        request: Request<Streaming<FlightData>>,
+    ) -> Result<Response<Self::DoExchangeStream>, Status> {
+        self.save_metadata(&request);
+        let do_exchange_request: Vec<_> = request.into_inner().try_collect().await?;
+
+        let mut state = self.state.lock().expect("mutex not poisoned");
+
+        state.do_exchange_request = Some(do_exchange_request);
+
+        let response = state
+            .do_exchange_response
+            .take()
+            .ok_or_else(|| Status::internal("No do_exchange response configured"))?;
+
+        let stream = futures::stream::iter(response).map_err(Into::into);
+
+        Ok(Response::new(stream.boxed()))
+    }
+}
diff --git a/arrow-flight/tests/common/trailers_layer.rs b/arrow-flight/tests/common/trailers_layer.rs
new file mode 100644
index 000000000000..b2ab74f7d925
--- /dev/null
+++ b/arrow-flight/tests/common/trailers_layer.rs
@@ -0,0 +1,136 @@
+// 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.
+
+use std::future::Future;
+use std::pin::Pin;
+use std::task::{Context, Poll};
+
+use futures::ready;
+use http::{HeaderValue, Request, Response};
+use http_body::SizeHint;
+use pin_project_lite::pin_project;
+use tower::{Layer, Service};
+
+#[derive(Debug, Copy, Clone, Default)]
+pub struct TrailersLayer;
+
+impl<S> Layer<S> for TrailersLayer {
+    type Service = TrailersService<S>;
+
+    fn layer(&self, service: S) -> Self::Service {
+        TrailersService { service }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct TrailersService<S> {
+    service: S,
+}
+
+impl<S, ReqBody, ResBody> Service<Request<ReqBody>> for TrailersService<S>
+where
+    S: Service<Request<ReqBody>, Response = Response<ResBody>>,
+    ResBody: http_body::Body,
+{
+    type Response = Response<WrappedBody<ResBody>>;
+    type Error = S::Error;
+    type Future = WrappedFuture<S::Future>;
+
+    fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>> {
+        self.service.poll_ready(cx)
+    }
+
+    fn call(&mut self, request: Request<ReqBody>) -> Self::Future {
+        WrappedFuture {
+            inner: self.service.call(request),
+        }
+    }
+}
+
+pin_project! {
+    #[derive(Debug)]
+    pub struct WrappedFuture<F> {
+        #[pin]
+        inner: F,
+    }
+}
+
+impl<F, ResBody, Error> Future for WrappedFuture<F>
+where
+    F: Future<Output = Result<Response<ResBody>, Error>>,
+    ResBody: http_body::Body,
+{
+    type Output = Result<Response<WrappedBody<ResBody>>, Error>;
+
+    fn poll(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output> {
+        let result: Result<Response<ResBody>, Error> =
+            ready!(self.as_mut().project().inner.poll(cx));
+
+        match result {
+            Ok(response) => Poll::Ready(Ok(response.map(|body| WrappedBody { inner: body }))),
+            Err(e) => Poll::Ready(Err(e)),
+        }
+    }
+}
+
+pin_project! {
+    #[derive(Debug)]
+    pub struct WrappedBody<B> {
+        #[pin]
+        inner: B,
+    }
+}
+
+impl<B: http_body::Body> http_body::Body for WrappedBody<B> {
+    type Data = B::Data;
+    type Error = B::Error;
+
+    fn poll_data(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Option<Result<Self::Data, Self::Error>>> {
+        self.as_mut().project().inner.poll_data(cx)
+    }
+
+    fn poll_trailers(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+    ) -> Poll<Result<Option<http::header::HeaderMap>, Self::Error>> {
+        let result: Result<Option<http::header::HeaderMap>, Self::Error> =
+            ready!(self.as_mut().project().inner.poll_trailers(cx));
+
+        let mut trailers = http::header::HeaderMap::new();
+        trailers.insert("test-trailer", HeaderValue::from_static("trailer_val"));
+
+        match result {
+            Ok(Some(mut existing)) => {
+                existing.extend(trailers.iter().map(|(k, v)| (k.clone(), v.clone())));
+                Poll::Ready(Ok(Some(existing)))
+            }
+            Ok(None) => Poll::Ready(Ok(Some(trailers))),
+            Err(e) => Poll::Ready(Err(e)),
+        }
+    }
+
+    fn is_end_stream(&self) -> bool {
+        self.inner.is_end_stream()
+    }
+
+    fn size_hint(&self) -> SizeHint {
+        self.inner.size_hint()
+    }
+}
diff --git a/arrow-flight/tests/encode_decode.rs b/arrow-flight/tests/encode_decode.rs
new file mode 100644
index 000000000000..f4741d743e57
--- /dev/null
+++ b/arrow-flight/tests/encode_decode.rs
@@ -0,0 +1,539 @@
+// 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.
+
+//! Tests for round trip encoding / decoding
+
+use std::{collections::HashMap, sync::Arc};
+
+use arrow_array::types::Int32Type;
+use arrow_array::{ArrayRef, DictionaryArray, Float64Array, RecordBatch, UInt8Array};
+use arrow_cast::pretty::pretty_format_batches;
+use arrow_flight::flight_descriptor::DescriptorType;
+use arrow_flight::FlightDescriptor;
+use arrow_flight::{
+    decode::{DecodedPayload, FlightDataDecoder, FlightRecordBatchStream},
+    encode::FlightDataEncoderBuilder,
+    error::FlightError,
+};
+use arrow_schema::{DataType, Field, Fields, Schema, SchemaRef};
+use bytes::Bytes;
+use futures::{StreamExt, TryStreamExt};
+
+#[tokio::test]
+async fn test_empty() {
+    roundtrip(vec![]).await;
+}
+
+#[tokio::test]
+async fn test_empty_batch() {
+    let batch = make_primitive_batch(5);
+    let empty = RecordBatch::new_empty(batch.schema());
+    roundtrip(vec![empty]).await;
+}
+
+#[tokio::test]
+async fn test_error() {
+    let input_batch_stream =
+        futures::stream::iter(vec![Err(FlightError::NotYetImplemented("foo".into()))]);
+
+    let encoder = FlightDataEncoderBuilder::default();
+    let encode_stream = encoder.build(input_batch_stream);
+
+    let decode_stream = FlightRecordBatchStream::new_from_flight_data(encode_stream);
+    let result: Result<Vec<_>, _> = decode_stream.try_collect().await;
+
+    let result = result.unwrap_err();
+    assert_eq!(result.to_string(), r#"NotYetImplemented("foo")"#);
+}
+
+#[tokio::test]
+async fn test_primitive_one() {
+    roundtrip(vec![make_primitive_batch(5)]).await;
+}
+
+#[tokio::test]
+async fn test_schema_metadata() {
+    let batch = make_primitive_batch(5);
+    let metadata = HashMap::from([("some_key".to_owned(), "some_value".to_owned())]);
+
+    // create a batch that has schema level metadata
+    let schema = Arc::new(batch.schema().as_ref().clone().with_metadata(metadata));
+    let batch = RecordBatch::try_new(schema, batch.columns().to_vec()).unwrap();
+
+    roundtrip(vec![batch]).await;
+}
+
+#[tokio::test]
+async fn test_primitive_many() {
+    roundtrip(vec![
+        make_primitive_batch(1),
+        make_primitive_batch(7),
+        make_primitive_batch(32),
+    ])
+    .await;
+}
+
+#[tokio::test]
+async fn test_primitive_empty() {
+    let batch = make_primitive_batch(5);
+    let empty = RecordBatch::new_empty(batch.schema());
+
+    roundtrip(vec![batch, empty]).await;
+}
+
+#[tokio::test]
+async fn test_dictionary_one() {
+    roundtrip_dictionary(vec![make_dictionary_batch(5)]).await;
+}
+
+#[tokio::test]
+async fn test_dictionary_many() {
+    roundtrip_dictionary(vec![
+        make_dictionary_batch(5),
+        make_dictionary_batch(9),
+        make_dictionary_batch(5),
+        make_dictionary_batch(5),
+    ])
+    .await;
+}
+
+#[tokio::test]
+async fn test_zero_batches_no_schema() {
+    let stream = FlightDataEncoderBuilder::default().build(futures::stream::iter(vec![]));
+
+    let mut decoder = FlightRecordBatchStream::new_from_flight_data(stream);
+    assert!(decoder.schema().is_none());
+    // No batches come out
+    assert!(decoder.next().await.is_none());
+    // schema has not been received
+    assert!(decoder.schema().is_none());
+}
+
+#[tokio::test]
+async fn test_zero_batches_schema_specified() {
+    let schema = Arc::new(Schema::new(vec![Field::new("a", DataType::Int64, false)]));
+    let stream = FlightDataEncoderBuilder::default()
+        .with_schema(schema.clone())
+        .build(futures::stream::iter(vec![]));
+
+    let mut decoder = FlightRecordBatchStream::new_from_flight_data(stream);
+    assert!(decoder.schema().is_none());
+    // No batches come out
+    assert!(decoder.next().await.is_none());
+    // But schema has been received correctly
+    assert_eq!(decoder.schema(), Some(&schema));
+}
+
+#[tokio::test]
+async fn test_with_flight_descriptor() {
+    let stream = futures::stream::iter(vec![Ok(make_dictionary_batch(5))]);
+    let schema = Arc::new(Schema::new(vec![Field::new("a", DataType::Utf8, true)]));
+
+    let descriptor = Some(FlightDescriptor {
+        r#type: DescriptorType::Path.into(),
+        path: vec!["table_name".to_string()],
+        cmd: Bytes::default(),
+    });
+
+    let encoder = FlightDataEncoderBuilder::default()
+        .with_schema(schema.clone())
+        .with_flight_descriptor(descriptor.clone());
+
+    let mut encoder = encoder.build(stream);
+
+    // First batch should be the schema
+    let first_batch = encoder.next().await.unwrap().unwrap();
+
+    assert_eq!(first_batch.flight_descriptor, descriptor);
+}
+
+#[tokio::test]
+async fn test_zero_batches_dictionary_schema_specified() {
+    let schema = Arc::new(Schema::new(vec![
+        Field::new("a", DataType::Int64, false),
+        Field::new_dictionary("b", DataType::Int32, DataType::Utf8, false),
+    ]));
+
+    // Expect dictionary to be hydrated in output (#3389)
+    let expected_schema = Arc::new(Schema::new(vec![
+        Field::new("a", DataType::Int64, false),
+        Field::new("b", DataType::Utf8, false),
+    ]));
+    let stream = FlightDataEncoderBuilder::default()
+        .with_schema(schema.clone())
+        .build(futures::stream::iter(vec![]));
+
+    let mut decoder = FlightRecordBatchStream::new_from_flight_data(stream);
+    assert!(decoder.schema().is_none());
+    // No batches come out
+    assert!(decoder.next().await.is_none());
+    // But schema has been received correctly
+    assert_eq!(decoder.schema(), Some(&expected_schema));
+}
+
+#[tokio::test]
+async fn test_app_metadata() {
+    let input_batch_stream = futures::stream::iter(vec![Ok(make_primitive_batch(78))]);
+
+    let app_metadata = Bytes::from("My Metadata");
+    let encoder = FlightDataEncoderBuilder::default().with_metadata(app_metadata.clone());
+
+    let encode_stream = encoder.build(input_batch_stream);
+
+    // use lower level stream to get access to app metadata
+    let decode_stream = FlightRecordBatchStream::new_from_flight_data(encode_stream).into_inner();
+
+    let mut messages: Vec<_> = decode_stream.try_collect().await.expect("encode fails");
+
+    println!("{messages:#?}");
+
+    // expect that the app metadata made it through on the schema message
+    assert_eq!(messages.len(), 2);
+    let message2 = messages.pop().unwrap();
+    let message1 = messages.pop().unwrap();
+
+    assert_eq!(message1.app_metadata(), app_metadata);
+    assert!(matches!(message1.payload, DecodedPayload::Schema(_)));
+
+    // but not on the data
+    assert_eq!(message2.app_metadata(), Bytes::new());
+    assert!(matches!(message2.payload, DecodedPayload::RecordBatch(_)));
+}
+
+#[tokio::test]
+async fn test_max_message_size() {
+    let input_batch_stream = futures::stream::iter(vec![Ok(make_primitive_batch(5))]);
+
+    // 5 input rows, with a very small limit should result in 5 batch messages
+    let encoder = FlightDataEncoderBuilder::default().with_max_flight_data_size(1);
+
+    let encode_stream = encoder.build(input_batch_stream);
+
+    // use lower level stream to get access to app metadata
+    let decode_stream = FlightRecordBatchStream::new_from_flight_data(encode_stream).into_inner();
+
+    let messages: Vec<_> = decode_stream.try_collect().await.expect("encode fails");
+
+    println!("{messages:#?}");
+
+    assert_eq!(messages.len(), 6);
+    assert!(matches!(messages[0].payload, DecodedPayload::Schema(_)));
+    for message in messages.iter().skip(1) {
+        assert!(matches!(message.payload, DecodedPayload::RecordBatch(_)));
+    }
+}
+
+#[tokio::test]
+async fn test_max_message_size_fuzz() {
+    // send through batches of varying sizes with various max
+    // batch sizes and ensure the data gets through ok
+    let input = vec![
+        make_primitive_batch(123),
+        make_primitive_batch(17),
+        make_primitive_batch(201),
+        make_primitive_batch(2),
+        make_primitive_batch(1),
+        make_primitive_batch(11),
+        make_primitive_batch(127),
+    ];
+
+    for max_message_size_bytes in [10, 1024, 2048, 6400, 3211212] {
+        let encoder =
+            FlightDataEncoderBuilder::default().with_max_flight_data_size(max_message_size_bytes);
+
+        let input_batch_stream = futures::stream::iter(input.clone()).map(Ok);
+
+        let encode_stream = encoder.build(input_batch_stream);
+
+        let decode_stream = FlightRecordBatchStream::new_from_flight_data(encode_stream);
+        let output: Vec<_> = decode_stream.try_collect().await.expect("encode / decode");
+
+        for b in &output {
+            assert_eq!(b.schema(), input[0].schema());
+        }
+
+        let a = pretty_format_batches(&input).unwrap().to_string();
+        let b = pretty_format_batches(&output).unwrap().to_string();
+        assert_eq!(a, b);
+    }
+}
+
+#[tokio::test]
+async fn test_mismatched_record_batch_schema() {
+    // send 2 batches with different schemas
+    let input_batch_stream = futures::stream::iter(vec![
+        Ok(make_primitive_batch(5)),
+        Ok(make_dictionary_batch(3)),
+    ]);
+
+    let encoder = FlightDataEncoderBuilder::default();
+    let encode_stream = encoder.build(input_batch_stream);
+
+    let result: Result<Vec<_>, FlightError> = encode_stream.try_collect().await;
+    let err = result.unwrap_err();
+    assert_eq!(
+        err.to_string(),
+        "Arrow(InvalidArgumentError(\"number of columns(1) must match number of fields(2) in schema\"))"
+    );
+}
+
+#[tokio::test]
+async fn test_chained_streams_batch_decoder() {
+    let batch1 = make_primitive_batch(5);
+    let batch2 = make_dictionary_batch(3);
+
+    // Model sending two flight streams back to back, with different schemas
+    let encode_stream1 =
+        FlightDataEncoderBuilder::default().build(futures::stream::iter(vec![Ok(batch1.clone())]));
+    let encode_stream2 =
+        FlightDataEncoderBuilder::default().build(futures::stream::iter(vec![Ok(batch2.clone())]));
+
+    // append the two streams (so they will have two different schema messages)
+    let encode_stream = encode_stream1.chain(encode_stream2);
+
+    // FlightRecordBatchStream errors if the schema changes
+    let decode_stream = FlightRecordBatchStream::new_from_flight_data(encode_stream);
+    let result: Result<Vec<_>, FlightError> = decode_stream.try_collect().await;
+
+    let err = result.unwrap_err();
+    assert_eq!(
+        err.to_string(),
+        "ProtocolError(\"Unexpectedly saw multiple Schema messages in FlightData stream\")"
+    );
+}
+
+#[tokio::test]
+async fn test_chained_streams_data_decoder() {
+    let batch1 = make_primitive_batch(5);
+    let batch2 = make_dictionary_batch(3);
+
+    // Model sending two flight streams back to back, with different schemas
+    let encode_stream1 =
+        FlightDataEncoderBuilder::default().build(futures::stream::iter(vec![Ok(batch1.clone())]));
+    let encode_stream2 =
+        FlightDataEncoderBuilder::default().build(futures::stream::iter(vec![Ok(batch2.clone())]));
+
+    // append the two streams (so they will have two different schema messages)
+    let encode_stream = encode_stream1.chain(encode_stream2);
+
+    // lower level decode stream can handle multiple schema messages
+    let decode_stream = FlightDataDecoder::new(encode_stream);
+
+    let decoded_data: Vec<_> = decode_stream.try_collect().await.expect("encode / decode");
+
+    println!("decoded data: {decoded_data:#?}");
+
+    // expect two schema messages with the data
+    assert_eq!(decoded_data.len(), 4);
+    assert!(matches!(decoded_data[0].payload, DecodedPayload::Schema(_)));
+    assert!(matches!(
+        decoded_data[1].payload,
+        DecodedPayload::RecordBatch(_)
+    ));
+    assert!(matches!(decoded_data[2].payload, DecodedPayload::Schema(_)));
+    assert!(matches!(
+        decoded_data[3].payload,
+        DecodedPayload::RecordBatch(_)
+    ));
+}
+
+#[tokio::test]
+async fn test_mismatched_schema_message() {
+    // Model sending schema that is mismatched with the data
+    // and expect an error
+    async fn do_test(batch1: RecordBatch, batch2: RecordBatch, expected: &str) {
+        let encode_stream1 = FlightDataEncoderBuilder::default()
+            .build(futures::stream::iter(vec![Ok(batch1.clone())]))
+            // take only schema message from first stream
+            .take(1);
+        let encode_stream2 = FlightDataEncoderBuilder::default()
+            .build(futures::stream::iter(vec![Ok(batch2.clone())]))
+            // take only data message from second
+            .skip(1);
+
+        // append the two streams
+        let encode_stream = encode_stream1.chain(encode_stream2);
+
+        // FlightRecordBatchStream errors if the schema changes
+        let decode_stream = FlightRecordBatchStream::new_from_flight_data(encode_stream);
+        let result: Result<Vec<_>, FlightError> = decode_stream.try_collect().await;
+
+        let err = result.unwrap_err().to_string();
+        assert!(
+            err.contains(expected),
+            "could not find '{expected}' in '{err}'"
+        );
+    }
+
+    // primitive batch first (has more columns)
+    do_test(
+        make_primitive_batch(5),
+        make_dictionary_batch(3),
+        "Error decoding ipc RecordBatch: Schema error: Invalid data for schema",
+    )
+    .await;
+
+    // dictionary batch first
+    do_test(
+        make_dictionary_batch(3),
+        make_primitive_batch(5),
+        "Error decoding ipc RecordBatch: Invalid argument error",
+    )
+    .await;
+}
+
+/// Make a primitive batch for testing
+///
+/// Example:
+/// i: 0, 1, None, 3, 4
+/// f: 5.0, 4.0, None, 2.0, 1.0
+fn make_primitive_batch(num_rows: usize) -> RecordBatch {
+    let i: UInt8Array = (0..num_rows)
+        .map(|i| {
+            if i == num_rows / 2 {
+                None
+            } else {
+                Some(i.try_into().unwrap())
+            }
+        })
+        .collect();
+
+    let f: Float64Array = (0..num_rows)
+        .map(|i| {
+            if i == num_rows / 2 {
+                None
+            } else {
+                Some((num_rows - i) as f64)
+            }
+        })
+        .collect();
+
+    RecordBatch::try_from_iter(vec![("i", Arc::new(i) as ArrayRef), ("f", Arc::new(f))]).unwrap()
+}
+
+/// Make a dictionary batch for testing
+///
+/// Example:
+/// a: value0, value1, value2, None, value1, value2
+fn make_dictionary_batch(num_rows: usize) -> RecordBatch {
+    let values: Vec<_> = (0..num_rows)
+        .map(|i| {
+            if i == num_rows / 2 {
+                None
+            } else {
+                // repeat some values for low cardinality
+                let v = i / 3;
+                Some(format!("value{v}"))
+            }
+        })
+        .collect();
+
+    let a: DictionaryArray<Int32Type> = values
+        .iter()
+        .map(|s| s.as_ref().map(|s| s.as_str()))
+        .collect();
+
+    RecordBatch::try_from_iter(vec![("a", Arc::new(a) as ArrayRef)]).unwrap()
+}
+
+/// Encodes input as a FlightData stream, and then decodes it using
+/// FlightRecordBatchStream and valides the decoded record batches
+/// match the input.
+async fn roundtrip(input: Vec<RecordBatch>) {
+    let expected_output = input.clone();
+    roundtrip_with_encoder(FlightDataEncoderBuilder::default(), input, expected_output).await
+}
+
+/// Encodes input as a FlightData stream, and then decodes it using
+/// FlightRecordBatchStream and valides the decoded record batches
+/// match the expected input.
+///
+/// When <https://github.com/apache/arrow-rs/issues/3389> is resolved,
+/// it should be possible to use `roundtrip`
+async fn roundtrip_dictionary(input: Vec<RecordBatch>) {
+    let schema = Arc::new(prepare_schema_for_flight(&input[0].schema()));
+    let expected_output: Vec<_> = input
+        .iter()
+        .map(|batch| prepare_batch_for_flight(batch, schema.clone()).unwrap())
+        .collect();
+    roundtrip_with_encoder(FlightDataEncoderBuilder::default(), input, expected_output).await
+}
+
+async fn roundtrip_with_encoder(
+    encoder: FlightDataEncoderBuilder,
+    input_batches: Vec<RecordBatch>,
+    expected_batches: Vec<RecordBatch>,
+) {
+    println!("Round tripping with encoder:\n{encoder:#?}");
+
+    let input_batch_stream = futures::stream::iter(input_batches.clone()).map(Ok);
+
+    let encode_stream = encoder.build(input_batch_stream);
+
+    let decode_stream = FlightRecordBatchStream::new_from_flight_data(encode_stream);
+    let output_batches: Vec<_> = decode_stream.try_collect().await.expect("encode / decode");
+
+    // remove any empty batches from input as they are not transmitted
+    let expected_batches: Vec<_> = expected_batches
+        .into_iter()
+        .filter(|b| b.num_rows() > 0)
+        .collect();
+
+    assert_eq!(expected_batches, output_batches);
+}
+
+/// Workaround for https://github.com/apache/arrow-rs/issues/1206
+fn prepare_schema_for_flight(schema: &Schema) -> Schema {
+    let fields: Fields = schema
+        .fields()
+        .iter()
+        .map(|field| match field.data_type() {
+            DataType::Dictionary(_, value_type) => Field::new(
+                field.name(),
+                value_type.as_ref().clone(),
+                field.is_nullable(),
+            )
+            .with_metadata(field.metadata().clone()),
+            _ => field.as_ref().clone(),
+        })
+        .collect();
+
+    Schema::new(fields)
+}
+
+/// Workaround for https://github.com/apache/arrow-rs/issues/1206
+fn prepare_batch_for_flight(
+    batch: &RecordBatch,
+    schema: SchemaRef,
+) -> Result<RecordBatch, FlightError> {
+    let columns = batch
+        .columns()
+        .iter()
+        .map(hydrate_dictionary)
+        .collect::<Result<Vec<_>, _>>()?;
+
+    Ok(RecordBatch::try_new(schema, columns)?)
+}
+
+fn hydrate_dictionary(array: &ArrayRef) -> Result<ArrayRef, FlightError> {
+    let arr = if let DataType::Dictionary(_, value) = array.data_type() {
+        arrow_cast::cast(array, value)?
+    } else {
+        Arc::clone(array)
+    };
+    Ok(arr)
+}
diff --git a/arrow-flight/tests/flight_sql_client_cli.rs b/arrow-flight/tests/flight_sql_client_cli.rs
new file mode 100644
index 000000000000..a28080450bc2
--- /dev/null
+++ b/arrow-flight/tests/flight_sql_client_cli.rs
@@ -0,0 +1,722 @@
+// 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.
+
+use std::{net::SocketAddr, pin::Pin, sync::Arc, time::Duration};
+
+use arrow_array::{ArrayRef, Int64Array, RecordBatch, StringArray};
+use arrow_flight::{
+    decode::FlightRecordBatchStream,
+    flight_service_server::{FlightService, FlightServiceServer},
+    sql::{
+        server::{FlightSqlService, PeekableFlightDataStream},
+        ActionBeginSavepointRequest, ActionBeginSavepointResult, ActionBeginTransactionRequest,
+        ActionBeginTransactionResult, ActionCancelQueryRequest, ActionCancelQueryResult,
+        ActionClosePreparedStatementRequest, ActionCreatePreparedStatementRequest,
+        ActionCreatePreparedStatementResult, ActionCreatePreparedSubstraitPlanRequest,
+        ActionEndSavepointRequest, ActionEndTransactionRequest, Any, CommandGetCatalogs,
+        CommandGetCrossReference, CommandGetDbSchemas, CommandGetExportedKeys,
+        CommandGetImportedKeys, CommandGetPrimaryKeys, CommandGetSqlInfo, CommandGetTableTypes,
+        CommandGetTables, CommandGetXdbcTypeInfo, CommandPreparedStatementQuery,
+        CommandPreparedStatementUpdate, CommandStatementQuery, CommandStatementSubstraitPlan,
+        CommandStatementUpdate, ProstMessageExt, SqlInfo, TicketStatementQuery,
+    },
+    utils::batches_to_flight_data,
+    Action, FlightData, FlightDescriptor, FlightEndpoint, FlightInfo, HandshakeRequest,
+    HandshakeResponse, IpcMessage, PutResult, SchemaAsIpc, Ticket,
+};
+use arrow_ipc::writer::IpcWriteOptions;
+use arrow_schema::{ArrowError, DataType, Field, Schema};
+use assert_cmd::Command;
+use bytes::Bytes;
+use futures::{Stream, StreamExt, TryStreamExt};
+use prost::Message;
+use tokio::{net::TcpListener, task::JoinHandle};
+use tonic::{Request, Response, Status, Streaming};
+
+const QUERY: &str = "SELECT * FROM table;";
+
+#[tokio::test]
+async fn test_simple() {
+    let test_server = FlightSqlServiceImpl {};
+    let fixture = TestFixture::new(&test_server).await;
+    let addr = fixture.addr;
+
+    let stdout = tokio::task::spawn_blocking(move || {
+        Command::cargo_bin("flight_sql_client")
+            .unwrap()
+            .env_clear()
+            .env("RUST_BACKTRACE", "1")
+            .env("RUST_LOG", "warn")
+            .arg("--host")
+            .arg(addr.ip().to_string())
+            .arg("--port")
+            .arg(addr.port().to_string())
+            .arg("statement-query")
+            .arg(QUERY)
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone()
+    })
+    .await
+    .unwrap();
+
+    fixture.shutdown_and_wait().await;
+
+    assert_eq!(
+        std::str::from_utf8(&stdout).unwrap().trim(),
+        "+--------------+-----------+\
+        \n| field_string | field_int |\
+        \n+--------------+-----------+\
+        \n| Hello        | 42        |\
+        \n| lovely       |           |\
+        \n| FlightSQL!   | 1337      |\
+        \n+--------------+-----------+",
+    );
+}
+
+const PREPARED_QUERY: &str = "SELECT * FROM table WHERE field = $1";
+const PREPARED_STATEMENT_HANDLE: &str = "prepared_statement_handle";
+
+#[tokio::test]
+async fn test_do_put_prepared_statement() {
+    let test_server = FlightSqlServiceImpl {};
+    let fixture = TestFixture::new(&test_server).await;
+    let addr = fixture.addr;
+
+    let stdout = tokio::task::spawn_blocking(move || {
+        Command::cargo_bin("flight_sql_client")
+            .unwrap()
+            .env_clear()
+            .env("RUST_BACKTRACE", "1")
+            .env("RUST_LOG", "warn")
+            .arg("--host")
+            .arg(addr.ip().to_string())
+            .arg("--port")
+            .arg(addr.port().to_string())
+            .arg("prepared-statement-query")
+            .arg(PREPARED_QUERY)
+            .args(["-p", "$1=string"])
+            .args(["-p", "$2=64"])
+            .assert()
+            .success()
+            .get_output()
+            .stdout
+            .clone()
+    })
+    .await
+    .unwrap();
+
+    fixture.shutdown_and_wait().await;
+
+    assert_eq!(
+        std::str::from_utf8(&stdout).unwrap().trim(),
+        "+--------------+-----------+\
+        \n| field_string | field_int |\
+        \n+--------------+-----------+\
+        \n| Hello        | 42        |\
+        \n| lovely       |           |\
+        \n| FlightSQL!   | 1337      |\
+        \n+--------------+-----------+",
+    );
+}
+
+/// All tests must complete within this many seconds or else the test server is shutdown
+const DEFAULT_TIMEOUT_SECONDS: u64 = 30;
+
+#[derive(Clone, Default)]
+pub struct FlightSqlServiceImpl {}
+
+impl FlightSqlServiceImpl {
+    /// Return an [`FlightServiceServer`] that can be used with a
+    /// [`Server`](tonic::transport::Server)
+    pub fn service(&self) -> FlightServiceServer<Self> {
+        // wrap up tonic goop
+        FlightServiceServer::new(self.clone())
+    }
+
+    fn fake_result() -> Result<RecordBatch, ArrowError> {
+        let schema = Schema::new(vec![
+            Field::new("field_string", DataType::Utf8, false),
+            Field::new("field_int", DataType::Int64, true),
+        ]);
+
+        let string_array = StringArray::from(vec!["Hello", "lovely", "FlightSQL!"]);
+        let int_array = Int64Array::from(vec![Some(42), None, Some(1337)]);
+
+        let cols = vec![
+            Arc::new(string_array) as ArrayRef,
+            Arc::new(int_array) as ArrayRef,
+        ];
+        RecordBatch::try_new(Arc::new(schema), cols)
+    }
+
+    fn create_fake_prepared_stmt() -> Result<ActionCreatePreparedStatementResult, ArrowError> {
+        let handle = PREPARED_STATEMENT_HANDLE.to_string();
+        let schema = Schema::new(vec![
+            Field::new("field_string", DataType::Utf8, false),
+            Field::new("field_int", DataType::Int64, true),
+        ]);
+
+        let parameter_schema = Schema::new(vec![
+            Field::new("$1", DataType::Utf8, false),
+            Field::new("$2", DataType::Int64, true),
+        ]);
+
+        Ok(ActionCreatePreparedStatementResult {
+            prepared_statement_handle: handle.into(),
+            dataset_schema: serialize_schema(&schema)?,
+            parameter_schema: serialize_schema(&parameter_schema)?,
+        })
+    }
+
+    fn fake_flight_info(&self) -> Result<FlightInfo, ArrowError> {
+        let batch = Self::fake_result()?;
+
+        Ok(FlightInfo::new()
+            .try_with_schema(&batch.schema())
+            .expect("encoding schema")
+            .with_endpoint(
+                FlightEndpoint::new().with_ticket(Ticket::new(
+                    FetchResults {
+                        handle: String::from("part_1"),
+                    }
+                    .as_any()
+                    .encode_to_vec(),
+                )),
+            )
+            .with_endpoint(
+                FlightEndpoint::new().with_ticket(Ticket::new(
+                    FetchResults {
+                        handle: String::from("part_2"),
+                    }
+                    .as_any()
+                    .encode_to_vec(),
+                )),
+            )
+            .with_total_records(batch.num_rows() as i64)
+            .with_total_bytes(batch.get_array_memory_size() as i64)
+            .with_ordered(false))
+    }
+}
+
+fn serialize_schema(schema: &Schema) -> Result<Bytes, ArrowError> {
+    Ok(IpcMessage::try_from(SchemaAsIpc::new(schema, &IpcWriteOptions::default()))?.0)
+}
+
+#[tonic::async_trait]
+impl FlightSqlService for FlightSqlServiceImpl {
+    type FlightService = FlightSqlServiceImpl;
+
+    async fn do_handshake(
+        &self,
+        _request: Request<Streaming<HandshakeRequest>>,
+    ) -> Result<
+        Response<Pin<Box<dyn Stream<Item = Result<HandshakeResponse, Status>> + Send>>>,
+        Status,
+    > {
+        Err(Status::unimplemented("do_handshake not implemented"))
+    }
+
+    async fn do_get_fallback(
+        &self,
+        _request: Request<Ticket>,
+        message: Any,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        let part = message.unpack::<FetchResults>().unwrap().unwrap().handle;
+        let batch = Self::fake_result().unwrap();
+        let batch = match part.as_str() {
+            "part_1" => batch.slice(0, 2),
+            "part_2" => batch.slice(2, 1),
+            ticket => panic!("Invalid ticket: {ticket:?}"),
+        };
+        let schema = batch.schema();
+        let batches = vec![batch];
+        let flight_data = batches_to_flight_data(schema.as_ref(), batches)
+            .unwrap()
+            .into_iter()
+            .map(Ok);
+
+        let stream: Pin<Box<dyn Stream<Item = Result<FlightData, Status>> + Send>> =
+            Box::pin(futures::stream::iter(flight_data));
+        let resp = Response::new(stream);
+        Ok(resp)
+    }
+
+    async fn get_flight_info_statement(
+        &self,
+        query: CommandStatementQuery,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        assert_eq!(query.query, QUERY);
+
+        let resp = Response::new(self.fake_flight_info().unwrap());
+        Ok(resp)
+    }
+
+    async fn get_flight_info_prepared_statement(
+        &self,
+        cmd: CommandPreparedStatementQuery,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        assert_eq!(
+            cmd.prepared_statement_handle,
+            PREPARED_STATEMENT_HANDLE.as_bytes()
+        );
+        let resp = Response::new(self.fake_flight_info().unwrap());
+        Ok(resp)
+    }
+
+    async fn get_flight_info_substrait_plan(
+        &self,
+        _query: CommandStatementSubstraitPlan,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_substrait_plan not implemented",
+        ))
+    }
+
+    async fn get_flight_info_catalogs(
+        &self,
+        _query: CommandGetCatalogs,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_catalogs not implemented",
+        ))
+    }
+
+    async fn get_flight_info_schemas(
+        &self,
+        _query: CommandGetDbSchemas,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_schemas not implemented",
+        ))
+    }
+
+    async fn get_flight_info_tables(
+        &self,
+        _query: CommandGetTables,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_tables not implemented",
+        ))
+    }
+
+    async fn get_flight_info_table_types(
+        &self,
+        _query: CommandGetTableTypes,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_table_types not implemented",
+        ))
+    }
+
+    async fn get_flight_info_sql_info(
+        &self,
+        _query: CommandGetSqlInfo,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_sql_info not implemented",
+        ))
+    }
+
+    async fn get_flight_info_primary_keys(
+        &self,
+        _query: CommandGetPrimaryKeys,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_primary_keys not implemented",
+        ))
+    }
+
+    async fn get_flight_info_exported_keys(
+        &self,
+        _query: CommandGetExportedKeys,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_exported_keys not implemented",
+        ))
+    }
+
+    async fn get_flight_info_imported_keys(
+        &self,
+        _query: CommandGetImportedKeys,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_imported_keys not implemented",
+        ))
+    }
+
+    async fn get_flight_info_cross_reference(
+        &self,
+        _query: CommandGetCrossReference,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_imported_keys not implemented",
+        ))
+    }
+
+    async fn get_flight_info_xdbc_type_info(
+        &self,
+        _query: CommandGetXdbcTypeInfo,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<FlightInfo>, Status> {
+        Err(Status::unimplemented(
+            "get_flight_info_xdbc_type_info not implemented",
+        ))
+    }
+
+    // do_get
+    async fn do_get_statement(
+        &self,
+        _ticket: TicketStatementQuery,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented("do_get_statement not implemented"))
+    }
+
+    async fn do_get_prepared_statement(
+        &self,
+        _query: CommandPreparedStatementQuery,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_prepared_statement not implemented",
+        ))
+    }
+
+    async fn do_get_catalogs(
+        &self,
+        _query: CommandGetCatalogs,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented("do_get_catalogs not implemented"))
+    }
+
+    async fn do_get_schemas(
+        &self,
+        _query: CommandGetDbSchemas,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented("do_get_schemas not implemented"))
+    }
+
+    async fn do_get_tables(
+        &self,
+        _query: CommandGetTables,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented("do_get_tables not implemented"))
+    }
+
+    async fn do_get_table_types(
+        &self,
+        _query: CommandGetTableTypes,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented("do_get_table_types not implemented"))
+    }
+
+    async fn do_get_sql_info(
+        &self,
+        _query: CommandGetSqlInfo,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented("do_get_sql_info not implemented"))
+    }
+
+    async fn do_get_primary_keys(
+        &self,
+        _query: CommandGetPrimaryKeys,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented("do_get_primary_keys not implemented"))
+    }
+
+    async fn do_get_exported_keys(
+        &self,
+        _query: CommandGetExportedKeys,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_exported_keys not implemented",
+        ))
+    }
+
+    async fn do_get_imported_keys(
+        &self,
+        _query: CommandGetImportedKeys,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_imported_keys not implemented",
+        ))
+    }
+
+    async fn do_get_cross_reference(
+        &self,
+        _query: CommandGetCrossReference,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_cross_reference not implemented",
+        ))
+    }
+
+    async fn do_get_xdbc_type_info(
+        &self,
+        _query: CommandGetXdbcTypeInfo,
+        _request: Request<Ticket>,
+    ) -> Result<Response<<Self as FlightService>::DoGetStream>, Status> {
+        Err(Status::unimplemented(
+            "do_get_xdbc_type_info not implemented",
+        ))
+    }
+
+    // do_put
+    async fn do_put_statement_update(
+        &self,
+        _ticket: CommandStatementUpdate,
+        _request: Request<PeekableFlightDataStream>,
+    ) -> Result<i64, Status> {
+        Err(Status::unimplemented(
+            "do_put_statement_update not implemented",
+        ))
+    }
+
+    async fn do_put_substrait_plan(
+        &self,
+        _ticket: CommandStatementSubstraitPlan,
+        _request: Request<PeekableFlightDataStream>,
+    ) -> Result<i64, Status> {
+        Err(Status::unimplemented(
+            "do_put_substrait_plan not implemented",
+        ))
+    }
+
+    async fn do_put_prepared_statement_query(
+        &self,
+        _query: CommandPreparedStatementQuery,
+        request: Request<PeekableFlightDataStream>,
+    ) -> Result<Response<<Self as FlightService>::DoPutStream>, Status> {
+        // just make sure decoding the parameters works
+        let parameters = FlightRecordBatchStream::new_from_flight_data(
+            request.into_inner().map_err(|e| e.into()),
+        )
+        .try_collect::<Vec<_>>()
+        .await?;
+
+        for (left, right) in parameters[0].schema().all_fields().iter().zip(vec![
+            Field::new("$1", DataType::Utf8, false),
+            Field::new("$2", DataType::Int64, true),
+        ]) {
+            if left.name() != right.name() || left.data_type() != right.data_type() {
+                return Err(Status::invalid_argument(format!(
+                    "Parameters did not match parameter schema\ngot {}",
+                    parameters[0].schema(),
+                )));
+            }
+        }
+
+        Ok(Response::new(
+            futures::stream::once(async { Ok(PutResult::default()) }).boxed(),
+        ))
+    }
+
+    async fn do_put_prepared_statement_update(
+        &self,
+        _query: CommandPreparedStatementUpdate,
+        _request: Request<PeekableFlightDataStream>,
+    ) -> Result<i64, Status> {
+        Err(Status::unimplemented(
+            "do_put_prepared_statement_update not implemented",
+        ))
+    }
+
+    async fn do_action_create_prepared_statement(
+        &self,
+        _query: ActionCreatePreparedStatementRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionCreatePreparedStatementResult, Status> {
+        Self::create_fake_prepared_stmt()
+            .map_err(|e| Status::internal(format!("Unable to serialize schema: {e}")))
+    }
+
+    async fn do_action_close_prepared_statement(
+        &self,
+        _query: ActionClosePreparedStatementRequest,
+        _request: Request<Action>,
+    ) -> Result<(), Status> {
+        unimplemented!("Implement do_action_close_prepared_statement")
+    }
+
+    async fn do_action_create_prepared_substrait_plan(
+        &self,
+        _query: ActionCreatePreparedSubstraitPlanRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionCreatePreparedStatementResult, Status> {
+        unimplemented!("Implement do_action_create_prepared_substrait_plan")
+    }
+
+    async fn do_action_begin_transaction(
+        &self,
+        _query: ActionBeginTransactionRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionBeginTransactionResult, Status> {
+        unimplemented!("Implement do_action_begin_transaction")
+    }
+
+    async fn do_action_end_transaction(
+        &self,
+        _query: ActionEndTransactionRequest,
+        _request: Request<Action>,
+    ) -> Result<(), Status> {
+        unimplemented!("Implement do_action_end_transaction")
+    }
+
+    async fn do_action_begin_savepoint(
+        &self,
+        _query: ActionBeginSavepointRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionBeginSavepointResult, Status> {
+        unimplemented!("Implement do_action_begin_savepoint")
+    }
+
+    async fn do_action_end_savepoint(
+        &self,
+        _query: ActionEndSavepointRequest,
+        _request: Request<Action>,
+    ) -> Result<(), Status> {
+        unimplemented!("Implement do_action_end_savepoint")
+    }
+
+    async fn do_action_cancel_query(
+        &self,
+        _query: ActionCancelQueryRequest,
+        _request: Request<Action>,
+    ) -> Result<ActionCancelQueryResult, Status> {
+        unimplemented!("Implement do_action_cancel_query")
+    }
+
+    async fn register_sql_info(&self, _id: i32, _result: &SqlInfo) {}
+}
+
+/// Creates and manages a running TestServer with a background task
+struct TestFixture {
+    /// channel to send shutdown command
+    shutdown: Option<tokio::sync::oneshot::Sender<()>>,
+
+    /// Address the server is listening on
+    addr: SocketAddr,
+
+    // handle for the server task
+    handle: Option<JoinHandle<Result<(), tonic::transport::Error>>>,
+}
+
+impl TestFixture {
+    /// create a new test fixture from the server
+    pub async fn new(test_server: &FlightSqlServiceImpl) -> Self {
+        // let OS choose a a free port
+        let listener = TcpListener::bind("127.0.0.1:0").await.unwrap();
+        let addr = listener.local_addr().unwrap();
+
+        println!("Listening on {addr}");
+
+        // prepare the shutdown channel
+        let (tx, rx) = tokio::sync::oneshot::channel();
+
+        let server_timeout = Duration::from_secs(DEFAULT_TIMEOUT_SECONDS);
+
+        let shutdown_future = async move {
+            rx.await.ok();
+        };
+
+        let serve_future = tonic::transport::Server::builder()
+            .timeout(server_timeout)
+            .add_service(test_server.service())
+            .serve_with_incoming_shutdown(
+                tokio_stream::wrappers::TcpListenerStream::new(listener),
+                shutdown_future,
+            );
+
+        // Run the server in its own background task
+        let handle = tokio::task::spawn(serve_future);
+
+        Self {
+            shutdown: Some(tx),
+            addr,
+            handle: Some(handle),
+        }
+    }
+
+    /// Stops the test server and waits for the server to shutdown
+    pub async fn shutdown_and_wait(mut self) {
+        if let Some(shutdown) = self.shutdown.take() {
+            shutdown.send(()).expect("server quit early");
+        }
+        if let Some(handle) = self.handle.take() {
+            println!("Waiting on server to finish");
+            handle
+                .await
+                .expect("task join error (panic?)")
+                .expect("Server Error found at shutdown");
+        }
+    }
+}
+
+impl Drop for TestFixture {
+    fn drop(&mut self) {
+        if let Some(shutdown) = self.shutdown.take() {
+            shutdown.send(()).ok();
+        }
+        if self.handle.is_some() {
+            // tests should properly clean up TestFixture
+            println!("TestFixture::Drop called prior to `shutdown_and_wait`");
+        }
+    }
+}
+
+#[derive(Clone, PartialEq, ::prost::Message)]
+pub struct FetchResults {
+    #[prost(string, tag = "1")]
+    pub handle: ::prost::alloc::string::String,
+}
+
+impl ProstMessageExt for FetchResults {
+    fn type_url() -> &'static str {
+        "type.googleapis.com/arrow.flight.protocol.sql.FetchResults"
+    }
+
+    fn as_any(&self) -> Any {
+        Any {
+            type_url: FetchResults::type_url().to_string(),
+            value: ::prost::Message::encode_to_vec(self).into(),
+        }
+    }
+}
diff --git a/arrow-integration-test/Cargo.toml b/arrow-integration-test/Cargo.toml
new file mode 100644
index 000000000000..8afbfacff7c3
--- /dev/null
+++ b/arrow-integration-test/Cargo.toml
@@ -0,0 +1,44 @@
+# 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]
+name = "arrow-integration-test"
+version = { workspace = true }
+description = "Support for the Apache Arrow JSON test data format"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_integration_test"
+path = "src/lib.rs"
+bench = false
+
+[dependencies]
+arrow = { workspace = true }
+arrow-buffer = { workspace = true }
+hex = { version = "0.4", default-features = false, features = ["std"] }
+serde = { version = "1.0", default-features = false, features = ["rc", "derive"] }
+serde_json = { version = "1.0", default-features = false, features = ["std"] }
+num = { version = "0.4", default-features = false, features = ["std"] }
+
+[build-dependencies]
diff --git a/arrow/test/data/integration.json b/arrow-integration-test/data/integration.json
similarity index 100%
rename from arrow/test/data/integration.json
rename to arrow-integration-test/data/integration.json
diff --git a/arrow-integration-test/src/datatype.rs b/arrow-integration-test/src/datatype.rs
new file mode 100644
index 000000000000..42ac71fbbd7e
--- /dev/null
+++ b/arrow-integration-test/src/datatype.rs
@@ -0,0 +1,367 @@
+// 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.
+
+use arrow::datatypes::{DataType, Field, Fields, IntervalUnit, TimeUnit, UnionMode};
+use arrow::error::{ArrowError, Result};
+use std::sync::Arc;
+
+/// Parse a data type from a JSON representation.
+pub fn data_type_from_json(json: &serde_json::Value) -> Result<DataType> {
+    use serde_json::Value;
+    let default_field = Arc::new(Field::new("", DataType::Boolean, true));
+    match *json {
+        Value::Object(ref map) => match map.get("name") {
+            Some(s) if s == "null" => Ok(DataType::Null),
+            Some(s) if s == "bool" => Ok(DataType::Boolean),
+            Some(s) if s == "binary" => Ok(DataType::Binary),
+            Some(s) if s == "largebinary" => Ok(DataType::LargeBinary),
+            Some(s) if s == "utf8" => Ok(DataType::Utf8),
+            Some(s) if s == "largeutf8" => Ok(DataType::LargeUtf8),
+            Some(s) if s == "fixedsizebinary" => {
+                // return a list with any type as its child isn't defined in the map
+                if let Some(Value::Number(size)) = map.get("byteWidth") {
+                    Ok(DataType::FixedSizeBinary(size.as_i64().unwrap() as i32))
+                } else {
+                    Err(ArrowError::ParseError(
+                        "Expecting a byteWidth for fixedsizebinary".to_string(),
+                    ))
+                }
+            }
+            Some(s) if s == "decimal" => {
+                // return a list with any type as its child isn't defined in the map
+                let precision = match map.get("precision") {
+                    Some(p) => Ok(p.as_u64().unwrap().try_into().unwrap()),
+                    None => Err(ArrowError::ParseError(
+                        "Expecting a precision for decimal".to_string(),
+                    )),
+                }?;
+                let scale = match map.get("scale") {
+                    Some(s) => Ok(s.as_u64().unwrap().try_into().unwrap()),
+                    _ => Err(ArrowError::ParseError(
+                        "Expecting a scale for decimal".to_string(),
+                    )),
+                }?;
+                let bit_width: usize = match map.get("bitWidth") {
+                    Some(b) => b.as_u64().unwrap() as usize,
+                    _ => 128, // Default bit width
+                };
+
+                if bit_width == 128 {
+                    Ok(DataType::Decimal128(precision, scale))
+                } else if bit_width == 256 {
+                    Ok(DataType::Decimal256(precision, scale))
+                } else {
+                    Err(ArrowError::ParseError(
+                        "Decimal bit_width invalid".to_string(),
+                    ))
+                }
+            }
+            Some(s) if s == "floatingpoint" => match map.get("precision") {
+                Some(p) if p == "HALF" => Ok(DataType::Float16),
+                Some(p) if p == "SINGLE" => Ok(DataType::Float32),
+                Some(p) if p == "DOUBLE" => Ok(DataType::Float64),
+                _ => Err(ArrowError::ParseError(
+                    "floatingpoint precision missing or invalid".to_string(),
+                )),
+            },
+            Some(s) if s == "timestamp" => {
+                let unit = match map.get("unit") {
+                    Some(p) if p == "SECOND" => Ok(TimeUnit::Second),
+                    Some(p) if p == "MILLISECOND" => Ok(TimeUnit::Millisecond),
+                    Some(p) if p == "MICROSECOND" => Ok(TimeUnit::Microsecond),
+                    Some(p) if p == "NANOSECOND" => Ok(TimeUnit::Nanosecond),
+                    _ => Err(ArrowError::ParseError(
+                        "timestamp unit missing or invalid".to_string(),
+                    )),
+                };
+                let tz = match map.get("timezone") {
+                    None => Ok(None),
+                    Some(Value::String(tz)) => Ok(Some(tz.as_str().into())),
+                    _ => Err(ArrowError::ParseError(
+                        "timezone must be a string".to_string(),
+                    )),
+                };
+                Ok(DataType::Timestamp(unit?, tz?))
+            }
+            Some(s) if s == "date" => match map.get("unit") {
+                Some(p) if p == "DAY" => Ok(DataType::Date32),
+                Some(p) if p == "MILLISECOND" => Ok(DataType::Date64),
+                _ => Err(ArrowError::ParseError(
+                    "date unit missing or invalid".to_string(),
+                )),
+            },
+            Some(s) if s == "time" => {
+                let unit = match map.get("unit") {
+                    Some(p) if p == "SECOND" => Ok(TimeUnit::Second),
+                    Some(p) if p == "MILLISECOND" => Ok(TimeUnit::Millisecond),
+                    Some(p) if p == "MICROSECOND" => Ok(TimeUnit::Microsecond),
+                    Some(p) if p == "NANOSECOND" => Ok(TimeUnit::Nanosecond),
+                    _ => Err(ArrowError::ParseError(
+                        "time unit missing or invalid".to_string(),
+                    )),
+                };
+                match map.get("bitWidth") {
+                    Some(p) if p == 32 => Ok(DataType::Time32(unit?)),
+                    Some(p) if p == 64 => Ok(DataType::Time64(unit?)),
+                    _ => Err(ArrowError::ParseError(
+                        "time bitWidth missing or invalid".to_string(),
+                    )),
+                }
+            }
+            Some(s) if s == "duration" => match map.get("unit") {
+                Some(p) if p == "SECOND" => Ok(DataType::Duration(TimeUnit::Second)),
+                Some(p) if p == "MILLISECOND" => Ok(DataType::Duration(TimeUnit::Millisecond)),
+                Some(p) if p == "MICROSECOND" => Ok(DataType::Duration(TimeUnit::Microsecond)),
+                Some(p) if p == "NANOSECOND" => Ok(DataType::Duration(TimeUnit::Nanosecond)),
+                _ => Err(ArrowError::ParseError(
+                    "time unit missing or invalid".to_string(),
+                )),
+            },
+            Some(s) if s == "interval" => match map.get("unit") {
+                Some(p) if p == "DAY_TIME" => Ok(DataType::Interval(IntervalUnit::DayTime)),
+                Some(p) if p == "YEAR_MONTH" => Ok(DataType::Interval(IntervalUnit::YearMonth)),
+                Some(p) if p == "MONTH_DAY_NANO" => {
+                    Ok(DataType::Interval(IntervalUnit::MonthDayNano))
+                }
+                _ => Err(ArrowError::ParseError(
+                    "interval unit missing or invalid".to_string(),
+                )),
+            },
+            Some(s) if s == "int" => match map.get("isSigned") {
+                Some(&Value::Bool(true)) => match map.get("bitWidth") {
+                    Some(Value::Number(n)) => match n.as_u64() {
+                        Some(8) => Ok(DataType::Int8),
+                        Some(16) => Ok(DataType::Int16),
+                        Some(32) => Ok(DataType::Int32),
+                        Some(64) => Ok(DataType::Int64),
+                        _ => Err(ArrowError::ParseError(
+                            "int bitWidth missing or invalid".to_string(),
+                        )),
+                    },
+                    _ => Err(ArrowError::ParseError(
+                        "int bitWidth missing or invalid".to_string(),
+                    )),
+                },
+                Some(&Value::Bool(false)) => match map.get("bitWidth") {
+                    Some(Value::Number(n)) => match n.as_u64() {
+                        Some(8) => Ok(DataType::UInt8),
+                        Some(16) => Ok(DataType::UInt16),
+                        Some(32) => Ok(DataType::UInt32),
+                        Some(64) => Ok(DataType::UInt64),
+                        _ => Err(ArrowError::ParseError(
+                            "int bitWidth missing or invalid".to_string(),
+                        )),
+                    },
+                    _ => Err(ArrowError::ParseError(
+                        "int bitWidth missing or invalid".to_string(),
+                    )),
+                },
+                _ => Err(ArrowError::ParseError(
+                    "int signed missing or invalid".to_string(),
+                )),
+            },
+            Some(s) if s == "list" => {
+                // return a list with any type as its child isn't defined in the map
+                Ok(DataType::List(default_field))
+            }
+            Some(s) if s == "largelist" => {
+                // return a largelist with any type as its child isn't defined in the map
+                Ok(DataType::LargeList(default_field))
+            }
+            Some(s) if s == "fixedsizelist" => {
+                // return a list with any type as its child isn't defined in the map
+                if let Some(Value::Number(size)) = map.get("listSize") {
+                    Ok(DataType::FixedSizeList(
+                        default_field,
+                        size.as_i64().unwrap() as i32,
+                    ))
+                } else {
+                    Err(ArrowError::ParseError(
+                        "Expecting a listSize for fixedsizelist".to_string(),
+                    ))
+                }
+            }
+            Some(s) if s == "struct" => {
+                // return an empty `struct` type as its children aren't defined in the map
+                Ok(DataType::Struct(Fields::empty()))
+            }
+            Some(s) if s == "map" => {
+                if let Some(Value::Bool(keys_sorted)) = map.get("keysSorted") {
+                    // Return a map with an empty type as its children aren't defined in the map
+                    Ok(DataType::Map(default_field, *keys_sorted))
+                } else {
+                    Err(ArrowError::ParseError(
+                        "Expecting a keysSorted for map".to_string(),
+                    ))
+                }
+            }
+            Some(s) if s == "union" => {
+                if let Some(Value::String(mode)) = map.get("mode") {
+                    let union_mode = if mode == "SPARSE" {
+                        UnionMode::Sparse
+                    } else if mode == "DENSE" {
+                        UnionMode::Dense
+                    } else {
+                        return Err(ArrowError::ParseError(format!(
+                            "Unknown union mode {mode:?} for union"
+                        )));
+                    };
+                    if let Some(values) = map.get("typeIds") {
+                        let values = values.as_array().unwrap();
+                        let fields = values
+                            .iter()
+                            .map(|t| (t.as_i64().unwrap() as i8, default_field.clone()))
+                            .collect();
+
+                        Ok(DataType::Union(fields, union_mode))
+                    } else {
+                        Err(ArrowError::ParseError(
+                            "Expecting a typeIds for union ".to_string(),
+                        ))
+                    }
+                } else {
+                    Err(ArrowError::ParseError(
+                        "Expecting a mode for union".to_string(),
+                    ))
+                }
+            }
+            Some(other) => Err(ArrowError::ParseError(format!(
+                "invalid or unsupported type name: {other} in {json:?}"
+            ))),
+            None => Err(ArrowError::ParseError("type name missing".to_string())),
+        },
+        _ => Err(ArrowError::ParseError(
+            "invalid json value type".to_string(),
+        )),
+    }
+}
+
+/// Generate a JSON representation of the data type.
+pub fn data_type_to_json(data_type: &DataType) -> serde_json::Value {
+    use serde_json::json;
+    match data_type {
+        DataType::Null => json!({"name": "null"}),
+        DataType::Boolean => json!({"name": "bool"}),
+        DataType::Int8 => json!({"name": "int", "bitWidth": 8, "isSigned": true}),
+        DataType::Int16 => json!({"name": "int", "bitWidth": 16, "isSigned": true}),
+        DataType::Int32 => json!({"name": "int", "bitWidth": 32, "isSigned": true}),
+        DataType::Int64 => json!({"name": "int", "bitWidth": 64, "isSigned": true}),
+        DataType::UInt8 => json!({"name": "int", "bitWidth": 8, "isSigned": false}),
+        DataType::UInt16 => json!({"name": "int", "bitWidth": 16, "isSigned": false}),
+        DataType::UInt32 => json!({"name": "int", "bitWidth": 32, "isSigned": false}),
+        DataType::UInt64 => json!({"name": "int", "bitWidth": 64, "isSigned": false}),
+        DataType::Float16 => json!({"name": "floatingpoint", "precision": "HALF"}),
+        DataType::Float32 => json!({"name": "floatingpoint", "precision": "SINGLE"}),
+        DataType::Float64 => json!({"name": "floatingpoint", "precision": "DOUBLE"}),
+        DataType::Utf8 => json!({"name": "utf8"}),
+        DataType::LargeUtf8 => json!({"name": "largeutf8"}),
+        DataType::Binary => json!({"name": "binary"}),
+        DataType::LargeBinary => json!({"name": "largebinary"}),
+        DataType::FixedSizeBinary(byte_width) => {
+            json!({"name": "fixedsizebinary", "byteWidth": byte_width})
+        }
+        DataType::Struct(_) => json!({"name": "struct"}),
+        DataType::Union(_, _) => json!({"name": "union"}),
+        DataType::List(_) => json!({ "name": "list"}),
+        DataType::LargeList(_) => json!({ "name": "largelist"}),
+        DataType::FixedSizeList(_, length) => {
+            json!({"name":"fixedsizelist", "listSize": length})
+        }
+        DataType::Time32(unit) => {
+            json!({"name": "time", "bitWidth": 32, "unit": match unit {
+                TimeUnit::Second => "SECOND",
+                TimeUnit::Millisecond => "MILLISECOND",
+                TimeUnit::Microsecond => "MICROSECOND",
+                TimeUnit::Nanosecond => "NANOSECOND",
+            }})
+        }
+        DataType::Time64(unit) => {
+            json!({"name": "time", "bitWidth": 64, "unit": match unit {
+                TimeUnit::Second => "SECOND",
+                TimeUnit::Millisecond => "MILLISECOND",
+                TimeUnit::Microsecond => "MICROSECOND",
+                TimeUnit::Nanosecond => "NANOSECOND",
+            }})
+        }
+        DataType::Date32 => {
+            json!({"name": "date", "unit": "DAY"})
+        }
+        DataType::Date64 => {
+            json!({"name": "date", "unit": "MILLISECOND"})
+        }
+        DataType::Timestamp(unit, None) => {
+            json!({"name": "timestamp", "unit": match unit {
+                TimeUnit::Second => "SECOND",
+                TimeUnit::Millisecond => "MILLISECOND",
+                TimeUnit::Microsecond => "MICROSECOND",
+                TimeUnit::Nanosecond => "NANOSECOND",
+            }})
+        }
+        DataType::Timestamp(unit, Some(tz)) => {
+            json!({"name": "timestamp", "unit": match unit {
+                    TimeUnit::Second => "SECOND",
+                    TimeUnit::Millisecond => "MILLISECOND",
+                    TimeUnit::Microsecond => "MICROSECOND",
+                    TimeUnit::Nanosecond => "NANOSECOND",
+                }, "timezone": tz})
+        }
+        DataType::Interval(unit) => json!({"name": "interval", "unit": match unit {
+            IntervalUnit::YearMonth => "YEAR_MONTH",
+            IntervalUnit::DayTime => "DAY_TIME",
+            IntervalUnit::MonthDayNano => "MONTH_DAY_NANO",
+        }}),
+        DataType::Duration(unit) => json!({"name": "duration", "unit": match unit {
+            TimeUnit::Second => "SECOND",
+            TimeUnit::Millisecond => "MILLISECOND",
+            TimeUnit::Microsecond => "MICROSECOND",
+            TimeUnit::Nanosecond => "NANOSECOND",
+        }}),
+        DataType::Dictionary(_, _) => json!({ "name": "dictionary"}),
+        DataType::Decimal128(precision, scale) => {
+            json!({"name": "decimal", "precision": precision, "scale": scale, "bitWidth": 128})
+        }
+        DataType::Decimal256(precision, scale) => {
+            json!({"name": "decimal", "precision": precision, "scale": scale, "bitWidth": 256})
+        }
+        DataType::Map(_, keys_sorted) => {
+            json!({"name": "map", "keysSorted": keys_sorted})
+        }
+        DataType::RunEndEncoded(_, _) => todo!(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use serde_json::Value;
+
+    #[test]
+    fn parse_utf8_from_json() {
+        let json = "{\"name\":\"utf8\"}";
+        let value: Value = serde_json::from_str(json).unwrap();
+        let dt = data_type_from_json(&value).unwrap();
+        assert_eq!(DataType::Utf8, dt);
+    }
+
+    #[test]
+    fn parse_int32_from_json() {
+        let json = "{\"name\": \"int\", \"isSigned\": true, \"bitWidth\": 32}";
+        let value: Value = serde_json::from_str(json).unwrap();
+        let dt = data_type_from_json(&value).unwrap();
+        assert_eq!(DataType::Int32, dt);
+    }
+}
diff --git a/arrow-integration-test/src/field.rs b/arrow-integration-test/src/field.rs
new file mode 100644
index 000000000000..32edc4165938
--- /dev/null
+++ b/arrow-integration-test/src/field.rs
@@ -0,0 +1,568 @@
+// 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.
+
+use crate::{data_type_from_json, data_type_to_json};
+use arrow::datatypes::{DataType, Field};
+use arrow::error::{ArrowError, Result};
+use std::collections::HashMap;
+use std::sync::Arc;
+
+/// Parse a `Field` definition from a JSON representation.
+pub fn field_from_json(json: &serde_json::Value) -> Result<Field> {
+    use serde_json::Value;
+    match *json {
+        Value::Object(ref map) => {
+            let name = match map.get("name") {
+                Some(Value::String(name)) => name.to_string(),
+                _ => {
+                    return Err(ArrowError::ParseError(
+                        "Field missing 'name' attribute".to_string(),
+                    ));
+                }
+            };
+            let nullable = match map.get("nullable") {
+                Some(&Value::Bool(b)) => b,
+                _ => {
+                    return Err(ArrowError::ParseError(
+                        "Field missing 'nullable' attribute".to_string(),
+                    ));
+                }
+            };
+            let data_type = match map.get("type") {
+                Some(t) => data_type_from_json(t)?,
+                _ => {
+                    return Err(ArrowError::ParseError(
+                        "Field missing 'type' attribute".to_string(),
+                    ));
+                }
+            };
+
+            // Referenced example file: testing/data/arrow-ipc-stream/integration/1.0.0-littleendian/generated_custom_metadata.json.gz
+            let metadata = match map.get("metadata") {
+                Some(Value::Array(values)) => {
+                    let mut res: HashMap<String, String> = HashMap::default();
+                    for value in values {
+                        match value.as_object() {
+                            Some(map) => {
+                                if map.len() != 2 {
+                                    return Err(ArrowError::ParseError(
+                                        "Field 'metadata' must have exact two entries for each key-value map".to_string(),
+                                    ));
+                                }
+                                if let (Some(k), Some(v)) = (map.get("key"), map.get("value")) {
+                                    if let (Some(k_str), Some(v_str)) = (k.as_str(), v.as_str()) {
+                                        res.insert(
+                                            k_str.to_string().clone(),
+                                            v_str.to_string().clone(),
+                                        );
+                                    } else {
+                                        return Err(ArrowError::ParseError(
+                                            "Field 'metadata' must have map value of string type"
+                                                .to_string(),
+                                        ));
+                                    }
+                                } else {
+                                    return Err(ArrowError::ParseError("Field 'metadata' lacks map keys named \"key\" or \"value\"".to_string()));
+                                }
+                            }
+                            _ => {
+                                return Err(ArrowError::ParseError(
+                                    "Field 'metadata' contains non-object key-value pair"
+                                        .to_string(),
+                                ));
+                            }
+                        }
+                    }
+                    res
+                }
+                // We also support map format, because Schema's metadata supports this.
+                // See https://github.com/apache/arrow/pull/5907
+                Some(Value::Object(values)) => {
+                    let mut res: HashMap<String, String> = HashMap::default();
+                    for (k, v) in values {
+                        if let Some(str_value) = v.as_str() {
+                            res.insert(k.clone(), str_value.to_string().clone());
+                        } else {
+                            return Err(ArrowError::ParseError(format!(
+                                "Field 'metadata' contains non-string value for key {k}"
+                            )));
+                        }
+                    }
+                    res
+                }
+                Some(_) => {
+                    return Err(ArrowError::ParseError(
+                        "Field `metadata` is not json array".to_string(),
+                    ));
+                }
+                _ => HashMap::default(),
+            };
+
+            // if data_type is a struct or list, get its children
+            let data_type = match data_type {
+                DataType::List(_) | DataType::LargeList(_) | DataType::FixedSizeList(_, _) => {
+                    match map.get("children") {
+                        Some(Value::Array(values)) => {
+                            if values.len() != 1 {
+                                return Err(ArrowError::ParseError(
+                                    "Field 'children' must have one element for a list data type"
+                                        .to_string(),
+                                ));
+                            }
+                            match data_type {
+                                DataType::List(_) => {
+                                    DataType::List(Arc::new(field_from_json(&values[0])?))
+                                }
+                                DataType::LargeList(_) => {
+                                    DataType::LargeList(Arc::new(field_from_json(&values[0])?))
+                                }
+                                DataType::FixedSizeList(_, int) => DataType::FixedSizeList(
+                                    Arc::new(field_from_json(&values[0])?),
+                                    int,
+                                ),
+                                _ => unreachable!(
+                                    "Data type should be a list, largelist or fixedsizelist"
+                                ),
+                            }
+                        }
+                        Some(_) => {
+                            return Err(ArrowError::ParseError(
+                                "Field 'children' must be an array".to_string(),
+                            ))
+                        }
+                        None => {
+                            return Err(ArrowError::ParseError(
+                                "Field missing 'children' attribute".to_string(),
+                            ));
+                        }
+                    }
+                }
+                DataType::Struct(_) => match map.get("children") {
+                    Some(Value::Array(values)) => {
+                        DataType::Struct(values.iter().map(field_from_json).collect::<Result<_>>()?)
+                    }
+                    Some(_) => {
+                        return Err(ArrowError::ParseError(
+                            "Field 'children' must be an array".to_string(),
+                        ))
+                    }
+                    None => {
+                        return Err(ArrowError::ParseError(
+                            "Field missing 'children' attribute".to_string(),
+                        ));
+                    }
+                },
+                DataType::Map(_, keys_sorted) => {
+                    match map.get("children") {
+                        Some(Value::Array(values)) if values.len() == 1 => {
+                            let child = field_from_json(&values[0])?;
+                            // child must be a struct
+                            match child.data_type() {
+                                DataType::Struct(map_fields) if map_fields.len() == 2 => {
+                                    DataType::Map(Arc::new(child), keys_sorted)
+                                }
+                                t => {
+                                    return Err(ArrowError::ParseError(format!(
+                                    "Map children should be a struct with 2 fields, found {t:?}"
+                                )))
+                                }
+                            }
+                        }
+                        Some(_) => {
+                            return Err(ArrowError::ParseError(
+                                "Field 'children' must be an array with 1 element".to_string(),
+                            ))
+                        }
+                        None => {
+                            return Err(ArrowError::ParseError(
+                                "Field missing 'children' attribute".to_string(),
+                            ));
+                        }
+                    }
+                }
+                DataType::Union(fields, mode) => match map.get("children") {
+                    Some(Value::Array(values)) => {
+                        let fields = fields
+                            .iter()
+                            .zip(values)
+                            .map(|((id, _), value)| Ok((id, Arc::new(field_from_json(value)?))))
+                            .collect::<Result<_>>()?;
+
+                        DataType::Union(fields, mode)
+                    }
+                    Some(_) => {
+                        return Err(ArrowError::ParseError(
+                            "Field 'children' must be an array".to_string(),
+                        ))
+                    }
+                    None => {
+                        return Err(ArrowError::ParseError(
+                            "Field missing 'children' attribute".to_string(),
+                        ));
+                    }
+                },
+                _ => data_type,
+            };
+
+            let mut dict_id = 0;
+            let mut dict_is_ordered = false;
+
+            let data_type = match map.get("dictionary") {
+                Some(dictionary) => {
+                    let index_type = match dictionary.get("indexType") {
+                        Some(t) => data_type_from_json(t)?,
+                        _ => {
+                            return Err(ArrowError::ParseError(
+                                "Field missing 'indexType' attribute".to_string(),
+                            ));
+                        }
+                    };
+                    dict_id = match dictionary.get("id") {
+                        Some(Value::Number(n)) => n.as_i64().unwrap(),
+                        _ => {
+                            return Err(ArrowError::ParseError(
+                                "Field missing 'id' attribute".to_string(),
+                            ));
+                        }
+                    };
+                    dict_is_ordered = match dictionary.get("isOrdered") {
+                        Some(&Value::Bool(n)) => n,
+                        _ => {
+                            return Err(ArrowError::ParseError(
+                                "Field missing 'isOrdered' attribute".to_string(),
+                            ));
+                        }
+                    };
+                    DataType::Dictionary(Box::new(index_type), Box::new(data_type))
+                }
+                _ => data_type,
+            };
+
+            let mut field = Field::new_dict(name, data_type, nullable, dict_id, dict_is_ordered);
+            field.set_metadata(metadata);
+            Ok(field)
+        }
+        _ => Err(ArrowError::ParseError(
+            "Invalid json value type for field".to_string(),
+        )),
+    }
+}
+
+/// Generate a JSON representation of the `Field`.
+pub fn field_to_json(field: &Field) -> serde_json::Value {
+    let children: Vec<serde_json::Value> = match field.data_type() {
+        DataType::Struct(fields) => fields.iter().map(|x| field_to_json(x.as_ref())).collect(),
+        DataType::List(field)
+        | DataType::LargeList(field)
+        | DataType::FixedSizeList(field, _)
+        | DataType::Map(field, _) => vec![field_to_json(field)],
+        _ => vec![],
+    };
+
+    match field.data_type() {
+        DataType::Dictionary(ref index_type, ref value_type) => serde_json::json!({
+            "name": field.name(),
+            "nullable": field.is_nullable(),
+            "type": data_type_to_json(value_type),
+            "children": children,
+            "dictionary": {
+                "id": field.dict_id().unwrap(),
+                "indexType": data_type_to_json(index_type),
+                "isOrdered": field.dict_is_ordered().unwrap(),
+            }
+        }),
+        _ => serde_json::json!({
+            "name": field.name(),
+            "nullable": field.is_nullable(),
+            "type": data_type_to_json(field.data_type()),
+            "children": children
+        }),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow::datatypes::UnionMode;
+    use serde_json::Value;
+
+    #[test]
+    fn struct_field_to_json() {
+        let f = Field::new_struct(
+            "address",
+            vec![
+                Field::new("street", DataType::Utf8, false),
+                Field::new("zip", DataType::UInt16, false),
+            ],
+            false,
+        );
+        let value: Value = serde_json::from_str(
+            r#"{
+                "name": "address",
+                "nullable": false,
+                "type": {
+                    "name": "struct"
+                },
+                "children": [
+                    {
+                        "name": "street",
+                        "nullable": false,
+                        "type": {
+                            "name": "utf8"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "zip",
+                        "nullable": false,
+                        "type": {
+                            "name": "int",
+                            "bitWidth": 16,
+                            "isSigned": false
+                        },
+                        "children": []
+                    }
+                ]
+            }"#,
+        )
+        .unwrap();
+        assert_eq!(value, field_to_json(&f));
+    }
+
+    #[test]
+    fn map_field_to_json() {
+        let f = Field::new_map(
+            "my_map",
+            "my_entries",
+            Field::new("my_keys", DataType::Utf8, false),
+            Field::new("my_values", DataType::UInt16, true),
+            true,
+            false,
+        );
+        let value: Value = serde_json::from_str(
+            r#"{
+                "name": "my_map",
+                "nullable": false,
+                "type": {
+                    "name": "map",
+                    "keysSorted": true
+                },
+                "children": [
+                    {
+                        "name": "my_entries",
+                        "nullable": false,
+                        "type": {
+                            "name": "struct"
+                        },
+                        "children": [
+                            {
+                                "name": "my_keys",
+                                "nullable": false,
+                                "type": {
+                                    "name": "utf8"
+                                },
+                                "children": []
+                            },
+                            {
+                                "name": "my_values",
+                                "nullable": true,
+                                "type": {
+                                    "name": "int",
+                                    "bitWidth": 16,
+                                    "isSigned": false
+                                },
+                                "children": []
+                            }
+                        ]
+                    }
+                ]
+            }"#,
+        )
+        .unwrap();
+        assert_eq!(value, field_to_json(&f));
+    }
+
+    #[test]
+    fn primitive_field_to_json() {
+        let f = Field::new("first_name", DataType::Utf8, false);
+        let value: Value = serde_json::from_str(
+            r#"{
+                "name": "first_name",
+                "nullable": false,
+                "type": {
+                    "name": "utf8"
+                },
+                "children": []
+            }"#,
+        )
+        .unwrap();
+        assert_eq!(value, field_to_json(&f));
+    }
+    #[test]
+    fn parse_struct_from_json() {
+        let json = r#"
+        {
+            "name": "address",
+            "type": {
+                "name": "struct"
+            },
+            "nullable": false,
+            "children": [
+                {
+                    "name": "street",
+                    "type": {
+                    "name": "utf8"
+                    },
+                    "nullable": false,
+                    "children": []
+                },
+                {
+                    "name": "zip",
+                    "type": {
+                    "name": "int",
+                    "isSigned": false,
+                    "bitWidth": 16
+                    },
+                    "nullable": false,
+                    "children": []
+                }
+            ]
+        }
+        "#;
+        let value: Value = serde_json::from_str(json).unwrap();
+        let dt = field_from_json(&value).unwrap();
+
+        let expected = Field::new_struct(
+            "address",
+            vec![
+                Field::new("street", DataType::Utf8, false),
+                Field::new("zip", DataType::UInt16, false),
+            ],
+            false,
+        );
+
+        assert_eq!(expected, dt);
+    }
+
+    #[test]
+    fn parse_map_from_json() {
+        let json = r#"
+        {
+            "name": "my_map",
+            "nullable": false,
+            "type": {
+                "name": "map",
+                "keysSorted": true
+            },
+            "children": [
+                {
+                    "name": "my_entries",
+                    "nullable": false,
+                    "type": {
+                        "name": "struct"
+                    },
+                    "children": [
+                        {
+                            "name": "my_keys",
+                            "nullable": false,
+                            "type": {
+                                "name": "utf8"
+                            },
+                            "children": []
+                        },
+                        {
+                            "name": "my_values",
+                            "nullable": true,
+                            "type": {
+                                "name": "int",
+                                "bitWidth": 16,
+                                "isSigned": false
+                            },
+                            "children": []
+                        }
+                    ]
+                }
+            ]
+        }
+        "#;
+        let value: Value = serde_json::from_str(json).unwrap();
+        let dt = field_from_json(&value).unwrap();
+
+        let expected = Field::new_map(
+            "my_map",
+            "my_entries",
+            Field::new("my_keys", DataType::Utf8, false),
+            Field::new("my_values", DataType::UInt16, true),
+            true,
+            false,
+        );
+
+        assert_eq!(expected, dt);
+    }
+
+    #[test]
+    fn parse_union_from_json() {
+        let json = r#"
+        {
+            "name": "my_union",
+            "nullable": false,
+            "type": {
+                "name": "union",
+                "mode": "SPARSE",
+                "typeIds": [
+                    5,
+                    7
+                ]
+            },
+            "children": [
+                {
+                    "name": "f1",
+                    "type": {
+                        "name": "int",
+                        "isSigned": true,
+                        "bitWidth": 32
+                    },
+                    "nullable": true,
+                    "children": []
+                },
+                {
+                    "name": "f2",
+                    "type": {
+                        "name": "utf8"
+                    },
+                    "nullable": true,
+                    "children": []
+                }
+            ]
+        }
+        "#;
+        let value: Value = serde_json::from_str(json).unwrap();
+        let dt = field_from_json(&value).unwrap();
+
+        let expected = Field::new_union(
+            "my_union",
+            vec![5, 7],
+            vec![
+                Field::new("f1", DataType::Int32, true),
+                Field::new("f2", DataType::Utf8, true),
+            ],
+            UnionMode::Sparse,
+        );
+
+        assert_eq!(expected, dt);
+    }
+}
diff --git a/arrow/src/util/integration_util.rs b/arrow-integration-test/src/lib.rs
similarity index 74%
rename from arrow/src/util/integration_util.rs
rename to arrow-integration-test/src/lib.rs
index ee5c947a2fff..a312148dc91a 100644
--- a/arrow/src/util/integration_util.rs
+++ b/arrow-integration-test/src/lib.rs
@@ -15,28 +15,40 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Utils for JSON integration testing
+//! Support for the [Apache Arrow JSON test data format](https://github.com/apache/arrow/blob/master/docs/source/format/Integration.rst#json-test-data-format)
 //!
 //! These utilities define structs that read the integration JSON format for integration testing purposes.
+//!
+//! This is not a canonical format, but provides a human-readable way of verifying language implementations
 
 use hex::decode;
 use num::BigInt;
 use num::Signed;
-use serde_derive::{Deserialize, Serialize};
+use serde::{Deserialize, Serialize};
 use serde_json::{Map as SJMap, Value};
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use crate::array::*;
-use crate::buffer::{Buffer, MutableBuffer};
-use crate::compute;
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-use crate::record_batch::{RecordBatch, RecordBatchReader};
-use crate::util::bit_util;
-use crate::util::decimal::Decimal256;
+use arrow::array::*;
+use arrow::buffer::{Buffer, MutableBuffer};
+use arrow::compute;
+use arrow::datatypes::*;
+use arrow::error::{ArrowError, Result};
+use arrow::record_batch::{RecordBatch, RecordBatchReader};
+use arrow::util::bit_util;
+use arrow_buffer::i256;
+
+mod datatype;
+mod field;
+mod schema;
+
+pub use datatype::*;
+pub use field::*;
+pub use schema::*;
 
 /// A struct that represents an Arrow file with a schema and record batches
+///
+/// See <https://github.com/apache/arrow/blob/master/docs/source/format/Integration.rst#json-test-data-format>
 #[derive(Deserialize, Serialize, Debug)]
 pub struct ArrowJson {
     pub schema: ArrowJsonSchema,
@@ -69,12 +81,18 @@ pub struct ArrowJsonField {
     pub metadata: Option<Value>,
 }
 
+impl From<&FieldRef> for ArrowJsonField {
+    fn from(value: &FieldRef) -> Self {
+        Self::from(value.as_ref())
+    }
+}
+
 impl From<&Field> for ArrowJsonField {
     fn from(field: &Field) -> Self {
-        let metadata_value = match field.metadata() {
-            Some(kv_list) => {
+        let metadata_value = match field.metadata().is_empty() {
+            false => {
                 let mut array = Vec::new();
-                for (k, v) in kv_list {
+                for (k, v) in field.metadata() {
                     let mut kv_map = SJMap::new();
                     kv_map.insert(k.clone(), Value::String(v.clone()));
                     array.push(Value::Object(kv_map));
@@ -90,7 +108,7 @@ impl From<&Field> for ArrowJsonField {
 
         Self {
             name: field.name().to_string(),
-            field_type: field.data_type().to_json(),
+            field_type: data_type_to_json(field.data_type()),
             nullable: field.is_nullable(),
             children: vec![],
             dictionary: None, // TODO: not enough info
@@ -160,12 +178,13 @@ impl ArrowJson {
             match batch {
                 Some(Ok(batch)) => {
                     if json_batch != batch {
-                        println!("json: {:?}", json_batch);
-                        println!("batch: {:?}", batch);
+                        println!("json: {json_batch:?}");
+                        println!("batch: {batch:?}");
                         return Ok(false);
                     }
                 }
-                _ => return Ok(false),
+                Some(Err(e)) => return Err(e),
+                None => return Ok(false),
             }
         }
 
@@ -242,10 +261,7 @@ impl ArrowJsonField {
                 true
             }
             Err(e) => {
-                eprintln!(
-                    "Encountered error while converting JSON field to Arrow field: {:?}",
-                    e
-                );
+                eprintln!("Encountered error while converting JSON field to Arrow field: {e:?}");
                 false
             }
         }
@@ -255,8 +271,9 @@ impl ArrowJsonField {
     /// TODO: convert to use an Into
     fn to_arrow_field(&self) -> Result<Field> {
         // a bit regressive, but we have to convert the field to JSON in order to convert it
-        let field = serde_json::to_value(self)?;
-        Field::from(&field)
+        let field =
+            serde_json::to_value(self).map_err(|error| ArrowError::JsonError(error.to_string()))?;
+        field_from_json(&field)
     }
 }
 
@@ -284,7 +301,7 @@ pub fn array_from_json(
     match field.data_type() {
         DataType::Null => Ok(Arc::new(NullArray::new(json_col.count))),
         DataType::Boolean => {
-            let mut b = BooleanBuilder::new(json_col.count);
+            let mut b = BooleanBuilder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -300,7 +317,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::Int8 => {
-            let mut b = Int8Builder::new(json_col.count);
+            let mut b = Int8Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -310,10 +327,7 @@ pub fn array_from_json(
             {
                 match is_valid {
                     1 => b.append_value(value.as_i64().ok_or_else(|| {
-                        ArrowError::JsonError(format!(
-                            "Unable to get {:?} as int64",
-                            value
-                        ))
+                        ArrowError::JsonError(format!("Unable to get {value:?} as int64"))
                     })? as i8),
                     _ => b.append_null(),
                 };
@@ -321,7 +335,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::Int16 => {
-            let mut b = Int16Builder::new(json_col.count);
+            let mut b = Int16Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -340,7 +354,7 @@ pub fn array_from_json(
         | DataType::Date32
         | DataType::Time32(_)
         | DataType::Interval(IntervalUnit::YearMonth) => {
-            let mut b = Int32Builder::new(json_col.count);
+            let mut b = Int32Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -362,7 +376,7 @@ pub fn array_from_json(
         | DataType::Timestamp(_, _)
         | DataType::Duration(_)
         | DataType::Interval(IntervalUnit::DayTime) => {
-            let mut b = Int64Builder::new(json_col.count);
+            let mut b = Int64Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -373,12 +387,9 @@ pub fn array_from_json(
                 match is_valid {
                     1 => b.append_value(match value {
                         Value::Number(n) => n.as_i64().unwrap(),
-                        Value::String(s) => {
-                            s.parse().expect("Unable to parse string as i64")
-                        }
+                        Value::String(s) => s.parse().expect("Unable to parse string as i64"),
                         Value::Object(ref map)
-                            if map.contains_key("days")
-                                && map.contains_key("milliseconds") =>
+                            if map.contains_key("days") && map.contains_key("milliseconds") =>
                         {
                             match field.data_type() {
                                 DataType::Interval(IntervalUnit::DayTime) => {
@@ -388,28 +399,22 @@ pub fn array_from_json(
                                     match (days, milliseconds) {
                                         (Value::Number(d), Value::Number(m)) => {
                                             let mut bytes = [0_u8; 8];
-                                            let m = (m.as_i64().unwrap() as i32)
-                                                .to_le_bytes();
-                                            let d = (d.as_i64().unwrap() as i32)
-                                                .to_le_bytes();
+                                            let m = (m.as_i64().unwrap() as i32).to_le_bytes();
+                                            let d = (d.as_i64().unwrap() as i32).to_le_bytes();
 
                                             let c = [d, m].concat();
                                             bytes.copy_from_slice(c.as_slice());
                                             i64::from_le_bytes(bytes)
                                         }
-                                        _ => panic!(
-                                            "Unable to parse {:?} as interval daytime",
-                                            value
-                                        ),
+                                        _ => {
+                                            panic!("Unable to parse {value:?} as interval daytime")
+                                        }
                                     }
                                 }
-                                _ => panic!(
-                                    "Unable to parse {:?} as interval daytime",
-                                    value
-                                ),
+                                _ => panic!("Unable to parse {value:?} as interval daytime"),
                             }
                         }
-                        _ => panic!("Unable to parse {:?} as number", value),
+                        _ => panic!("Unable to parse {value:?} as number"),
                     }),
                     _ => b.append_null(),
                 };
@@ -418,7 +423,7 @@ pub fn array_from_json(
             compute::cast(&array, field.data_type())
         }
         DataType::UInt8 => {
-            let mut b = UInt8Builder::new(json_col.count);
+            let mut b = UInt8Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -434,7 +439,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::UInt16 => {
-            let mut b = UInt16Builder::new(json_col.count);
+            let mut b = UInt16Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -450,7 +455,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::UInt32 => {
-            let mut b = UInt32Builder::new(json_col.count);
+            let mut b = UInt32Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -466,7 +471,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::UInt64 => {
-            let mut b = UInt64Builder::new(json_col.count);
+            let mut b = UInt64Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -485,11 +490,9 @@ pub fn array_from_json(
                                     .expect("Unable to parse string as u64"),
                             )
                         } else if value.is_number() {
-                            b.append_value(
-                                value.as_u64().expect("Unable to read number as u64"),
-                            )
+                            b.append_value(value.as_u64().expect("Unable to read number as u64"))
                         } else {
-                            panic!("Unable to parse value {:?} as u64", value)
+                            panic!("Unable to parse value {value:?} as u64")
                         }
                     }
                     _ => b.append_null(),
@@ -498,7 +501,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::Interval(IntervalUnit::MonthDayNano) => {
-            let mut b = IntervalMonthDayNanoBuilder::new(json_col.count);
+            let mut b = IntervalMonthDayNanoBuilder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -521,19 +524,18 @@ pub fn array_from_json(
                                     let months = months.as_i64().unwrap() as i32;
                                     let days = days.as_i64().unwrap() as i32;
                                     let nanoseconds = nanoseconds.as_i64().unwrap();
-                                    let months_days_ns: i128 = ((nanoseconds as i128)
-                                        & 0xFFFFFFFFFFFFFFFF)
-                                        << 64
-                                        | ((days as i128) & 0xFFFFFFFF) << 32
-                                        | ((months as i128) & 0xFFFFFFFF);
+                                    let months_days_ns: i128 =
+                                        ((nanoseconds as i128) & 0xFFFFFFFFFFFFFFFF) << 64
+                                            | ((days as i128) & 0xFFFFFFFF) << 32
+                                            | ((months as i128) & 0xFFFFFFFF);
                                     months_days_ns
                                 }
                                 (_, _, _) => {
-                                    panic!("Unable to parse {:?} as MonthDayNano", v)
+                                    panic!("Unable to parse {v:?} as MonthDayNano")
                                 }
                             }
                         }
-                        _ => panic!("Unable to parse {:?} as MonthDayNano", value),
+                        _ => panic!("Unable to parse {value:?} as MonthDayNano"),
                     }),
                     _ => b.append_null(),
                 };
@@ -541,7 +543,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::Float32 => {
-            let mut b = Float32Builder::new(json_col.count);
+            let mut b = Float32Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -557,7 +559,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::Float64 => {
-            let mut b = Float64Builder::new(json_col.count);
+            let mut b = Float64Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -573,7 +575,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::Binary => {
-            let mut b = BinaryBuilder::new(json_col.count);
+            let mut b = BinaryBuilder::with_capacity(json_col.count, 1024);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -592,7 +594,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::LargeBinary => {
-            let mut b = LargeBinaryBuilder::new(json_col.count);
+            let mut b = LargeBinaryBuilder::with_capacity(json_col.count, 1024);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -611,7 +613,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::Utf8 => {
-            let mut b = StringBuilder::new(json_col.count);
+            let mut b = StringBuilder::with_capacity(json_col.count, 1024);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -627,7 +629,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::LargeUtf8 => {
-            let mut b = LargeStringBuilder::new(json_col.count);
+            let mut b = LargeStringBuilder::with_capacity(json_col.count, 1024);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -643,7 +645,7 @@ pub fn array_from_json(
             Ok(Arc::new(b.finish()))
         }
         DataType::FixedSizeBinary(len) => {
-            let mut b = FixedSizeBinaryBuilder::new(json_col.count, *len);
+            let mut b = FixedSizeBinaryBuilder::with_capacity(json_col.count, *len);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -664,11 +666,7 @@ pub fn array_from_json(
         DataType::List(child_field) => {
             let null_buf = create_null_buf(&json_col);
             let children = json_col.children.clone().unwrap();
-            let child_array = array_from_json(
-                child_field,
-                children.get(0).unwrap().clone(),
-                dictionaries,
-            )?;
+            let child_array = array_from_json(child_field, children[0].clone(), dictionaries)?;
             let offsets: Vec<i32> = json_col
                 .offset
                 .unwrap()
@@ -688,11 +686,7 @@ pub fn array_from_json(
         DataType::LargeList(child_field) => {
             let null_buf = create_null_buf(&json_col);
             let children = json_col.children.clone().unwrap();
-            let child_array = array_from_json(
-                child_field,
-                children.get(0).unwrap().clone(),
-                dictionaries,
-            )?;
+            let child_array = array_from_json(child_field, children[0].clone(), dictionaries)?;
             let offsets: Vec<i64> = json_col
                 .offset
                 .unwrap()
@@ -715,11 +709,7 @@ pub fn array_from_json(
         }
         DataType::FixedSizeList(child_field, _) => {
             let children = json_col.children.clone().unwrap();
-            let child_array = array_from_json(
-                child_field,
-                children.get(0).unwrap().clone(),
-                dictionaries,
-            )?;
+            let child_array = array_from_json(child_field, children[0].clone(), dictionaries)?;
             let null_buf = create_null_buf(&json_col);
             let list_data = ArrayData::builder(field.data_type().clone())
                 .len(json_col.count)
@@ -746,17 +736,13 @@ pub fn array_from_json(
         }
         DataType::Dictionary(key_type, value_type) => {
             let dict_id = field.dict_id().ok_or_else(|| {
-                ArrowError::JsonError(format!(
-                    "Unable to find dict_id for field {:?}",
-                    field
-                ))
+                ArrowError::JsonError(format!("Unable to find dict_id for field {field:?}"))
             })?;
             // find dictionary
             let dictionary = dictionaries
                 .ok_or_else(|| {
                     ArrowError::JsonError(format!(
-                        "Unable to find any dictionaries for field {:?}",
-                        field
+                        "Unable to find any dictionaries for field {field:?}"
                     ))
                 })?
                 .get(&dict_id);
@@ -770,17 +756,12 @@ pub fn array_from_json(
                     dictionaries,
                 ),
                 None => Err(ArrowError::JsonError(format!(
-                    "Unable to find dictionary for field {:?}",
-                    field
+                    "Unable to find dictionary for field {field:?}"
                 ))),
             }
         }
         DataType::Decimal128(precision, scale) => {
-            let mut b = Decimal128Builder::new(json_col.count, *precision, *scale);
-            // C++ interop tests involve incompatible decimal values
-            unsafe {
-                b.disable_value_validation();
-            }
+            let mut b = Decimal128Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -789,20 +770,16 @@ pub fn array_from_json(
                 .zip(json_col.data.unwrap())
             {
                 match is_valid {
-                    1 => {
-                        b.append_value(value.as_str().unwrap().parse::<i128>().unwrap())?
-                    }
+                    1 => b.append_value(value.as_str().unwrap().parse::<i128>().unwrap()),
                     _ => b.append_null(),
                 };
             }
-            Ok(Arc::new(b.finish()))
+            Ok(Arc::new(
+                b.finish().with_precision_and_scale(*precision, *scale)?,
+            ))
         }
         DataType::Decimal256(precision, scale) => {
-            let mut b = Decimal256Builder::new(json_col.count, *precision, *scale);
-            // C++ interop tests involve incompatible decimal values
-            unsafe {
-                b.disable_value_validation();
-            }
+            let mut b = Decimal256Builder::with_capacity(json_col.count);
             for (is_valid, value) in json_col
                 .validity
                 .as_ref()
@@ -820,26 +797,20 @@ pub fn array_from_json(
                         } else {
                             [255_u8; 32]
                         };
-                        bytes[0..integer_bytes.len()]
-                            .copy_from_slice(integer_bytes.as_slice());
-                        let decimal =
-                            Decimal256::try_new_from_bytes(*precision, *scale, &bytes)
-                                .unwrap();
-                        b.append_value(&decimal)?;
+                        bytes[0..integer_bytes.len()].copy_from_slice(integer_bytes.as_slice());
+                        b.append_value(i256::from_le_bytes(bytes));
                     }
                     _ => b.append_null(),
                 }
             }
-            Ok(Arc::new(b.finish()))
+            Ok(Arc::new(
+                b.finish().with_precision_and_scale(*precision, *scale)?,
+            ))
         }
         DataType::Map(child_field, _) => {
             let null_buf = create_null_buf(&json_col);
             let children = json_col.children.clone().unwrap();
-            let child_array = array_from_json(
-                child_field,
-                children.get(0).unwrap().clone(),
-                dictionaries,
-            )?;
+            let child_array = array_from_json(child_field, children[0].clone(), dictionaries)?;
             let offsets: Vec<i32> = json_col
                 .offset
                 .unwrap()
@@ -857,7 +828,7 @@ pub fn array_from_json(
             let array = MapArray::from(array_data);
             Ok(Arc::new(array))
         }
-        DataType::Union(fields, field_type_ids, _) => {
+        DataType::Union(fields, _) => {
             let type_ids = if let Some(type_id) = json_col.type_id {
                 type_id
             } else {
@@ -873,13 +844,14 @@ pub fn array_from_json(
             });
 
             let mut children: Vec<(Field, Arc<dyn Array>)> = vec![];
-            for (field, col) in fields.iter().zip(json_col.children.unwrap()) {
+            for ((_, field), col) in fields.iter().zip(json_col.children.unwrap()) {
                 let array = array_from_json(field, col, dictionaries)?;
-                children.push((field.clone(), array));
+                children.push((field.as_ref().clone(), array));
             }
 
+            let field_type_ids = fields.iter().map(|(id, _)| id).collect::<Vec<_>>();
             let array = UnionArray::try_new(
-                field_type_ids,
+                &field_type_ids,
                 Buffer::from(&type_ids.to_byte_slice()),
                 offset,
                 children,
@@ -888,8 +860,7 @@ pub fn array_from_json(
             Ok(Arc::new(array))
         }
         t => Err(ArrowError::JsonError(format!(
-            "data type {:?} not supported",
-            t
+            "data type {t:?} not supported"
         ))),
     }
 }
@@ -937,16 +908,14 @@ pub fn dictionary_array_from_json(
             // convert key and value to dictionary data
             let dict_data = ArrayData::builder(field.data_type().clone())
                 .len(keys.len())
-                .add_buffer(keys.data().buffers()[0].clone())
+                .add_buffer(keys.to_data().buffers()[0].clone())
                 .null_bit_buffer(Some(null_buf))
                 .add_child_data(values.into_data())
                 .build()
                 .unwrap();
 
             let array = match dict_key {
-                DataType::Int8 => {
-                    Arc::new(Int8DictionaryArray::from(dict_data)) as ArrayRef
-                }
+                DataType::Int8 => Arc::new(Int8DictionaryArray::from(dict_data)) as ArrayRef,
                 DataType::Int16 => Arc::new(Int16DictionaryArray::from(dict_data)),
                 DataType::Int32 => Arc::new(Int32DictionaryArray::from(dict_data)),
                 DataType::Int64 => Arc::new(Int64DictionaryArray::from(dict_data)),
@@ -959,13 +928,12 @@ pub fn dictionary_array_from_json(
             Ok(array)
         }
         _ => Err(ArrowError::JsonError(format!(
-            "Dictionary key type {:?} not supported",
-            dict_key
+            "Dictionary key type {dict_key:?} not supported"
         ))),
     }
 }
 
-/// A helper to create a null buffer from a Vec<bool>
+/// A helper to create a null buffer from a `Vec<bool>`
 fn create_null_buf(json_col: &ArrowJsonColumn) -> Buffer {
     let num_bytes = bit_util::ceil(json_col.count, 8);
     let mut null_buf = MutableBuffer::new(num_bytes).with_bitset(num_bytes, false);
@@ -1045,7 +1013,7 @@ mod tests {
     use std::io::Read;
     use std::sync::Arc;
 
-    use crate::buffer::Buffer;
+    use arrow::buffer::Buffer;
 
     #[test]
     fn test_schema_equality() {
@@ -1098,11 +1066,7 @@ mod tests {
             Field::new("c3", DataType::Utf8, true),
             Field::new(
                 "c4",
-                DataType::List(Box::new(Field::new(
-                    "custom_item",
-                    DataType::Int32,
-                    false,
-                ))),
+                DataType::List(Arc::new(Field::new("custom_item", DataType::Int32, false))),
                 true,
             ),
         ]);
@@ -1110,102 +1074,96 @@ mod tests {
     }
 
     #[test]
-    #[cfg_attr(miri, ignore)] // running forever
     fn test_arrow_data_equality() {
-        let secs_tz = Some("Europe/Budapest".to_string());
-        let millis_tz = Some("America/New_York".to_string());
-        let micros_tz = Some("UTC".to_string());
-        let nanos_tz = Some("Africa/Johannesburg".to_string());
-
-        let schema =
-            Schema::new(vec![
-                Field::new("bools-with-metadata-map", DataType::Boolean, true)
-                    .with_metadata(Some(
-                        [("k".to_string(), "v".to_string())]
-                            .iter()
-                            .cloned()
-                            .collect(),
-                    )),
-                Field::new("bools-with-metadata-vec", DataType::Boolean, true)
-                    .with_metadata(Some(
-                        [("k2".to_string(), "v2".to_string())]
-                            .iter()
-                            .cloned()
-                            .collect(),
-                    )),
-                Field::new("bools", DataType::Boolean, true),
-                Field::new("int8s", DataType::Int8, true),
-                Field::new("int16s", DataType::Int16, true),
-                Field::new("int32s", DataType::Int32, true),
-                Field::new("int64s", DataType::Int64, true),
-                Field::new("uint8s", DataType::UInt8, true),
-                Field::new("uint16s", DataType::UInt16, true),
-                Field::new("uint32s", DataType::UInt32, true),
-                Field::new("uint64s", DataType::UInt64, true),
-                Field::new("float32s", DataType::Float32, true),
-                Field::new("float64s", DataType::Float64, true),
-                Field::new("date_days", DataType::Date32, true),
-                Field::new("date_millis", DataType::Date64, true),
-                Field::new("time_secs", DataType::Time32(TimeUnit::Second), true),
-                Field::new("time_millis", DataType::Time32(TimeUnit::Millisecond), true),
-                Field::new("time_micros", DataType::Time64(TimeUnit::Microsecond), true),
-                Field::new("time_nanos", DataType::Time64(TimeUnit::Nanosecond), true),
-                Field::new("ts_secs", DataType::Timestamp(TimeUnit::Second, None), true),
-                Field::new(
-                    "ts_millis",
-                    DataType::Timestamp(TimeUnit::Millisecond, None),
-                    true,
-                ),
-                Field::new(
-                    "ts_micros",
-                    DataType::Timestamp(TimeUnit::Microsecond, None),
-                    true,
-                ),
-                Field::new(
-                    "ts_nanos",
-                    DataType::Timestamp(TimeUnit::Nanosecond, None),
-                    true,
-                ),
-                Field::new(
-                    "ts_secs_tz",
-                    DataType::Timestamp(TimeUnit::Second, secs_tz.clone()),
-                    true,
-                ),
-                Field::new(
-                    "ts_millis_tz",
-                    DataType::Timestamp(TimeUnit::Millisecond, millis_tz.clone()),
-                    true,
-                ),
-                Field::new(
-                    "ts_micros_tz",
-                    DataType::Timestamp(TimeUnit::Microsecond, micros_tz.clone()),
-                    true,
-                ),
-                Field::new(
-                    "ts_nanos_tz",
-                    DataType::Timestamp(TimeUnit::Nanosecond, nanos_tz.clone()),
-                    true,
-                ),
-                Field::new("utf8s", DataType::Utf8, true),
-                Field::new(
-                    "lists",
-                    DataType::List(Box::new(Field::new("item", DataType::Int32, true))),
-                    true,
-                ),
-                Field::new(
-                    "structs",
-                    DataType::Struct(vec![
-                        Field::new("int32s", DataType::Int32, true),
-                        Field::new("utf8s", DataType::Utf8, true),
-                    ]),
-                    true,
-                ),
-            ]);
+        let secs_tz = Some("Europe/Budapest".into());
+        let millis_tz = Some("America/New_York".into());
+        let micros_tz = Some("UTC".into());
+        let nanos_tz = Some("Africa/Johannesburg".into());
 
-        let bools_with_metadata_map =
-            BooleanArray::from(vec![Some(true), None, Some(false)]);
-        let bools_with_metadata_vec =
-            BooleanArray::from(vec![Some(true), None, Some(false)]);
+        let schema = Schema::new(vec![
+            Field::new("bools-with-metadata-map", DataType::Boolean, true).with_metadata(
+                [("k".to_string(), "v".to_string())]
+                    .iter()
+                    .cloned()
+                    .collect(),
+            ),
+            Field::new("bools-with-metadata-vec", DataType::Boolean, true).with_metadata(
+                [("k2".to_string(), "v2".to_string())]
+                    .iter()
+                    .cloned()
+                    .collect(),
+            ),
+            Field::new("bools", DataType::Boolean, true),
+            Field::new("int8s", DataType::Int8, true),
+            Field::new("int16s", DataType::Int16, true),
+            Field::new("int32s", DataType::Int32, true),
+            Field::new("int64s", DataType::Int64, true),
+            Field::new("uint8s", DataType::UInt8, true),
+            Field::new("uint16s", DataType::UInt16, true),
+            Field::new("uint32s", DataType::UInt32, true),
+            Field::new("uint64s", DataType::UInt64, true),
+            Field::new("float32s", DataType::Float32, true),
+            Field::new("float64s", DataType::Float64, true),
+            Field::new("date_days", DataType::Date32, true),
+            Field::new("date_millis", DataType::Date64, true),
+            Field::new("time_secs", DataType::Time32(TimeUnit::Second), true),
+            Field::new("time_millis", DataType::Time32(TimeUnit::Millisecond), true),
+            Field::new("time_micros", DataType::Time64(TimeUnit::Microsecond), true),
+            Field::new("time_nanos", DataType::Time64(TimeUnit::Nanosecond), true),
+            Field::new("ts_secs", DataType::Timestamp(TimeUnit::Second, None), true),
+            Field::new(
+                "ts_millis",
+                DataType::Timestamp(TimeUnit::Millisecond, None),
+                true,
+            ),
+            Field::new(
+                "ts_micros",
+                DataType::Timestamp(TimeUnit::Microsecond, None),
+                true,
+            ),
+            Field::new(
+                "ts_nanos",
+                DataType::Timestamp(TimeUnit::Nanosecond, None),
+                true,
+            ),
+            Field::new(
+                "ts_secs_tz",
+                DataType::Timestamp(TimeUnit::Second, secs_tz.clone()),
+                true,
+            ),
+            Field::new(
+                "ts_millis_tz",
+                DataType::Timestamp(TimeUnit::Millisecond, millis_tz.clone()),
+                true,
+            ),
+            Field::new(
+                "ts_micros_tz",
+                DataType::Timestamp(TimeUnit::Microsecond, micros_tz.clone()),
+                true,
+            ),
+            Field::new(
+                "ts_nanos_tz",
+                DataType::Timestamp(TimeUnit::Nanosecond, nanos_tz.clone()),
+                true,
+            ),
+            Field::new("utf8s", DataType::Utf8, true),
+            Field::new(
+                "lists",
+                DataType::List(Arc::new(Field::new("item", DataType::Int32, true))),
+                true,
+            ),
+            Field::new(
+                "structs",
+                DataType::Struct(Fields::from(vec![
+                    Field::new("int32s", DataType::Int32, true),
+                    Field::new("utf8s", DataType::Utf8, true),
+                ])),
+                true,
+            ),
+        ]);
+
+        let bools_with_metadata_map = BooleanArray::from(vec![Some(true), None, Some(false)]);
+        let bools_with_metadata_vec = BooleanArray::from(vec![Some(true), None, Some(false)]);
         let bools = BooleanArray::from(vec![Some(true), None, Some(false)]);
         let int8s = Int8Array::from(vec![Some(1), None, Some(3)]);
         let int16s = Int16Array::from(vec![Some(1), None, Some(3)]);
@@ -1223,54 +1181,32 @@ mod tests {
             Some(29923997007884),
             Some(30612271819236),
         ]);
-        let time_secs =
-            Time32SecondArray::from(vec![Some(27974), Some(78592), Some(43207)]);
-        let time_millis = Time32MillisecondArray::from(vec![
-            Some(6613125),
-            Some(74667230),
-            Some(52260079),
-        ]);
-        let time_micros =
-            Time64MicrosecondArray::from(vec![Some(62522958593), None, None]);
-        let time_nanos = Time64NanosecondArray::from(vec![
-            Some(73380123595985),
-            None,
-            Some(16584393546415),
-        ]);
-        let ts_secs = TimestampSecondArray::from_opt_vec(
-            vec![None, Some(193438817552), None],
-            None,
-        );
-        let ts_millis = TimestampMillisecondArray::from_opt_vec(
-            vec![None, Some(38606916383008), Some(58113709376587)],
-            None,
-        );
-        let ts_micros =
-            TimestampMicrosecondArray::from_opt_vec(vec![None, None, None], None);
-        let ts_nanos = TimestampNanosecondArray::from_opt_vec(
-            vec![None, None, Some(-6473623571954960143)],
-            None,
-        );
-        let ts_secs_tz = TimestampSecondArray::from_opt_vec(
-            vec![None, Some(193438817552), None],
-            secs_tz,
-        );
-        let ts_millis_tz = TimestampMillisecondArray::from_opt_vec(
-            vec![None, Some(38606916383008), Some(58113709376587)],
-            millis_tz,
-        );
+        let time_secs = Time32SecondArray::from(vec![Some(27974), Some(78592), Some(43207)]);
+        let time_millis =
+            Time32MillisecondArray::from(vec![Some(6613125), Some(74667230), Some(52260079)]);
+        let time_micros = Time64MicrosecondArray::from(vec![Some(62522958593), None, None]);
+        let time_nanos =
+            Time64NanosecondArray::from(vec![Some(73380123595985), None, Some(16584393546415)]);
+        let ts_secs = TimestampSecondArray::from(vec![None, Some(193438817552), None]);
+        let ts_millis =
+            TimestampMillisecondArray::from(vec![None, Some(38606916383008), Some(58113709376587)]);
+        let ts_micros = TimestampMicrosecondArray::from(vec![None, None, None]);
+        let ts_nanos = TimestampNanosecondArray::from(vec![None, None, Some(-6473623571954960143)]);
+        let ts_secs_tz = TimestampSecondArray::from(vec![None, Some(193438817552), None])
+            .with_timezone_opt(secs_tz);
+        let ts_millis_tz =
+            TimestampMillisecondArray::from(vec![None, Some(38606916383008), Some(58113709376587)])
+                .with_timezone_opt(millis_tz);
         let ts_micros_tz =
-            TimestampMicrosecondArray::from_opt_vec(vec![None, None, None], micros_tz);
-        let ts_nanos_tz = TimestampNanosecondArray::from_opt_vec(
-            vec![None, None, Some(-6473623571954960143)],
-            nanos_tz,
-        );
+            TimestampMicrosecondArray::from(vec![None, None, None]).with_timezone_opt(micros_tz);
+        let ts_nanos_tz =
+            TimestampNanosecondArray::from(vec![None, None, Some(-6473623571954960143)])
+                .with_timezone_opt(nanos_tz);
         let utf8s = StringArray::from(vec![Some("aa"), None, Some("bbb")]);
 
         let value_data = Int32Array::from(vec![None, Some(2), None, None]);
-        let value_offsets = Buffer::from_slice_ref(&[0, 3, 4, 4]);
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, true)));
+        let value_offsets = Buffer::from_slice_ref([0, 3, 4, 4]);
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, true)));
         let list_data = ArrayData::builder(list_data_type)
             .len(3)
             .add_buffer(value_offsets)
@@ -1282,14 +1218,14 @@ mod tests {
 
         let structs_int32s = Int32Array::from(vec![None, Some(-2), None]);
         let structs_utf8s = StringArray::from(vec![None, None, Some("aaaaaa")]);
-        let struct_data_type = DataType::Struct(vec![
+        let struct_data_type = DataType::Struct(Fields::from(vec![
             Field::new("int32s", DataType::Int32, true),
             Field::new("utf8s", DataType::Utf8, true),
-        ]);
+        ]));
         let struct_data = ArrayData::builder(struct_data_type)
             .len(3)
-            .add_child_data(structs_int32s.data().clone())
-            .add_child_data(structs_utf8s.data().clone())
+            .add_child_data(structs_int32s.into_data())
+            .add_child_data(structs_utf8s.into_data())
             .null_bit_buffer(Some(Buffer::from([0b00000011])))
             .build()
             .unwrap();
@@ -1331,7 +1267,7 @@ mod tests {
             ],
         )
         .unwrap();
-        let mut file = File::open("test/data/integration.json").unwrap();
+        let mut file = File::open("data/integration.json").unwrap();
         let mut json = String::new();
         file.read_to_string(&mut json).unwrap();
         let arrow_json: ArrowJson = serde_json::from_str(&json).unwrap();
diff --git a/arrow-integration-test/src/schema.rs b/arrow-integration-test/src/schema.rs
new file mode 100644
index 000000000000..b5f6c5e86b38
--- /dev/null
+++ b/arrow-integration-test/src/schema.rs
@@ -0,0 +1,728 @@
+// 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.
+
+use crate::{field_from_json, field_to_json};
+use arrow::datatypes::{Fields, Schema};
+use arrow::error::{ArrowError, Result};
+use std::collections::HashMap;
+
+/// Generate a JSON representation of the `Schema`.
+pub fn schema_to_json(schema: &Schema) -> serde_json::Value {
+    serde_json::json!({
+        "fields": schema.fields().iter().map(|f| field_to_json(f.as_ref())).collect::<Vec<_>>(),
+        "metadata": serde_json::to_value(schema.metadata()).unwrap()
+    })
+}
+
+/// Parse a `Schema` definition from a JSON representation.
+pub fn schema_from_json(json: &serde_json::Value) -> Result<Schema> {
+    use serde_json::Value;
+    match *json {
+        Value::Object(ref schema) => {
+            let fields: Fields = match schema.get("fields") {
+                Some(Value::Array(fields)) => {
+                    fields.iter().map(field_from_json).collect::<Result<_>>()?
+                }
+                _ => {
+                    return Err(ArrowError::ParseError(
+                        "Schema fields should be an array".to_string(),
+                    ))
+                }
+            };
+
+            let metadata = if let Some(value) = schema.get("metadata") {
+                from_metadata(value)?
+            } else {
+                HashMap::default()
+            };
+
+            Ok(Schema::new_with_metadata(fields, metadata))
+        }
+        _ => Err(ArrowError::ParseError(
+            "Invalid json value type for schema".to_string(),
+        )),
+    }
+}
+
+/// Parse a `metadata` definition from a JSON representation.
+/// The JSON can either be an Object or an Array of Objects.
+fn from_metadata(json: &serde_json::Value) -> Result<HashMap<String, String>> {
+    use serde_json::Value;
+    match json {
+        Value::Array(_) => {
+            let mut hashmap = HashMap::new();
+            let values: Vec<MetadataKeyValue> =
+                serde_json::from_value(json.clone()).map_err(|_| {
+                    ArrowError::JsonError("Unable to parse object into key-value pair".to_string())
+                })?;
+            for meta in values {
+                hashmap.insert(meta.key.clone(), meta.value);
+            }
+            Ok(hashmap)
+        }
+        Value::Object(md) => md
+            .iter()
+            .map(|(k, v)| {
+                if let Value::String(v) = v {
+                    Ok((k.to_string(), v.to_string()))
+                } else {
+                    Err(ArrowError::ParseError(
+                        "metadata `value` field must be a string".to_string(),
+                    ))
+                }
+            })
+            .collect::<Result<_>>(),
+        _ => Err(ArrowError::ParseError(
+            "`metadata` field must be an object".to_string(),
+        )),
+    }
+}
+
+#[derive(serde::Deserialize)]
+struct MetadataKeyValue {
+    key: String,
+    value: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow::datatypes::{DataType, Field, Fields, IntervalUnit, TimeUnit};
+    use serde_json::Value;
+    use std::sync::Arc;
+
+    #[test]
+    fn schema_json() {
+        // Add some custom metadata
+        let metadata: HashMap<String, String> = [("Key".to_string(), "Value".to_string())]
+            .iter()
+            .cloned()
+            .collect();
+
+        let schema = Schema::new_with_metadata(
+            vec![
+                Field::new("c1", DataType::Utf8, false),
+                Field::new("c2", DataType::Binary, false),
+                Field::new("c3", DataType::FixedSizeBinary(3), false),
+                Field::new("c4", DataType::Boolean, false),
+                Field::new("c5", DataType::Date32, false),
+                Field::new("c6", DataType::Date64, false),
+                Field::new("c7", DataType::Time32(TimeUnit::Second), false),
+                Field::new("c8", DataType::Time32(TimeUnit::Millisecond), false),
+                Field::new("c9", DataType::Time32(TimeUnit::Microsecond), false),
+                Field::new("c10", DataType::Time32(TimeUnit::Nanosecond), false),
+                Field::new("c11", DataType::Time64(TimeUnit::Second), false),
+                Field::new("c12", DataType::Time64(TimeUnit::Millisecond), false),
+                Field::new("c13", DataType::Time64(TimeUnit::Microsecond), false),
+                Field::new("c14", DataType::Time64(TimeUnit::Nanosecond), false),
+                Field::new("c15", DataType::Timestamp(TimeUnit::Second, None), false),
+                Field::new(
+                    "c16",
+                    DataType::Timestamp(TimeUnit::Millisecond, Some("UTC".into())),
+                    false,
+                ),
+                Field::new(
+                    "c17",
+                    DataType::Timestamp(TimeUnit::Microsecond, Some("Africa/Johannesburg".into())),
+                    false,
+                ),
+                Field::new(
+                    "c18",
+                    DataType::Timestamp(TimeUnit::Nanosecond, None),
+                    false,
+                ),
+                Field::new("c19", DataType::Interval(IntervalUnit::DayTime), false),
+                Field::new("c20", DataType::Interval(IntervalUnit::YearMonth), false),
+                Field::new("c21", DataType::Interval(IntervalUnit::MonthDayNano), false),
+                Field::new(
+                    "c22",
+                    DataType::List(Arc::new(Field::new("item", DataType::Boolean, true))),
+                    false,
+                ),
+                Field::new(
+                    "c23",
+                    DataType::FixedSizeList(
+                        Arc::new(Field::new("bools", DataType::Boolean, false)),
+                        5,
+                    ),
+                    false,
+                ),
+                Field::new(
+                    "c24",
+                    DataType::List(Arc::new(Field::new(
+                        "inner_list",
+                        DataType::List(Arc::new(Field::new(
+                            "struct",
+                            DataType::Struct(Fields::empty()),
+                            true,
+                        ))),
+                        false,
+                    ))),
+                    true,
+                ),
+                Field::new(
+                    "c25",
+                    DataType::Struct(Fields::from(vec![
+                        Field::new("a", DataType::Utf8, false),
+                        Field::new("b", DataType::UInt16, false),
+                    ])),
+                    false,
+                ),
+                Field::new("c26", DataType::Interval(IntervalUnit::YearMonth), true),
+                Field::new("c27", DataType::Interval(IntervalUnit::DayTime), true),
+                Field::new("c28", DataType::Interval(IntervalUnit::MonthDayNano), true),
+                Field::new("c29", DataType::Duration(TimeUnit::Second), false),
+                Field::new("c30", DataType::Duration(TimeUnit::Millisecond), false),
+                Field::new("c31", DataType::Duration(TimeUnit::Microsecond), false),
+                Field::new("c32", DataType::Duration(TimeUnit::Nanosecond), false),
+                Field::new_dict(
+                    "c33",
+                    DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
+                    true,
+                    123,
+                    true,
+                ),
+                Field::new("c34", DataType::LargeBinary, true),
+                Field::new("c35", DataType::LargeUtf8, true),
+                Field::new(
+                    "c36",
+                    DataType::LargeList(Arc::new(Field::new(
+                        "inner_large_list",
+                        DataType::LargeList(Arc::new(Field::new(
+                            "struct",
+                            DataType::Struct(Fields::empty()),
+                            false,
+                        ))),
+                        true,
+                    ))),
+                    true,
+                ),
+                Field::new(
+                    "c37",
+                    DataType::Map(
+                        Arc::new(Field::new(
+                            "my_entries",
+                            DataType::Struct(Fields::from(vec![
+                                Field::new("my_keys", DataType::Utf8, false),
+                                Field::new("my_values", DataType::UInt16, true),
+                            ])),
+                            false,
+                        )),
+                        true,
+                    ),
+                    false,
+                ),
+            ],
+            metadata,
+        );
+
+        let expected = schema_to_json(&schema);
+        let json = r#"{
+                "fields": [
+                    {
+                        "name": "c1",
+                        "nullable": false,
+                        "type": {
+                            "name": "utf8"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c2",
+                        "nullable": false,
+                        "type": {
+                            "name": "binary"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c3",
+                        "nullable": false,
+                        "type": {
+                            "name": "fixedsizebinary",
+                            "byteWidth": 3
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c4",
+                        "nullable": false,
+                        "type": {
+                            "name": "bool"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c5",
+                        "nullable": false,
+                        "type": {
+                            "name": "date",
+                            "unit": "DAY"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c6",
+                        "nullable": false,
+                        "type": {
+                            "name": "date",
+                            "unit": "MILLISECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c7",
+                        "nullable": false,
+                        "type": {
+                            "name": "time",
+                            "bitWidth": 32,
+                            "unit": "SECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c8",
+                        "nullable": false,
+                        "type": {
+                            "name": "time",
+                            "bitWidth": 32,
+                            "unit": "MILLISECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c9",
+                        "nullable": false,
+                        "type": {
+                            "name": "time",
+                            "bitWidth": 32,
+                            "unit": "MICROSECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c10",
+                        "nullable": false,
+                        "type": {
+                            "name": "time",
+                            "bitWidth": 32,
+                            "unit": "NANOSECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c11",
+                        "nullable": false,
+                        "type": {
+                            "name": "time",
+                            "bitWidth": 64,
+                            "unit": "SECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c12",
+                        "nullable": false,
+                        "type": {
+                            "name": "time",
+                            "bitWidth": 64,
+                            "unit": "MILLISECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c13",
+                        "nullable": false,
+                        "type": {
+                            "name": "time",
+                            "bitWidth": 64,
+                            "unit": "MICROSECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c14",
+                        "nullable": false,
+                        "type": {
+                            "name": "time",
+                            "bitWidth": 64,
+                            "unit": "NANOSECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c15",
+                        "nullable": false,
+                        "type": {
+                            "name": "timestamp",
+                            "unit": "SECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c16",
+                        "nullable": false,
+                        "type": {
+                            "name": "timestamp",
+                            "unit": "MILLISECOND",
+                            "timezone": "UTC"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c17",
+                        "nullable": false,
+                        "type": {
+                            "name": "timestamp",
+                            "unit": "MICROSECOND",
+                            "timezone": "Africa/Johannesburg"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c18",
+                        "nullable": false,
+                        "type": {
+                            "name": "timestamp",
+                            "unit": "NANOSECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c19",
+                        "nullable": false,
+                        "type": {
+                            "name": "interval",
+                            "unit": "DAY_TIME"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c20",
+                        "nullable": false,
+                        "type": {
+                            "name": "interval",
+                            "unit": "YEAR_MONTH"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c21",
+                        "nullable": false,
+                        "type": {
+                            "name": "interval",
+                            "unit": "MONTH_DAY_NANO"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c22",
+                        "nullable": false,
+                        "type": {
+                            "name": "list"
+                        },
+                        "children": [
+                            {
+                                "name": "item",
+                                "nullable": true,
+                                "type": {
+                                    "name": "bool"
+                                },
+                                "children": []
+                            }
+                        ]
+                    },
+                    {
+                        "name": "c23",
+                        "nullable": false,
+                        "type": {
+                            "name": "fixedsizelist",
+                            "listSize": 5
+                        },
+                        "children": [
+                            {
+                                "name": "bools",
+                                "nullable": false,
+                                "type": {
+                                    "name": "bool"
+                                },
+                                "children": []
+                            }
+                        ]
+                    },
+                    {
+                        "name": "c24",
+                        "nullable": true,
+                        "type": {
+                            "name": "list"
+                        },
+                        "children": [
+                            {
+                                "name": "inner_list",
+                                "nullable": false,
+                                "type": {
+                                    "name": "list"
+                                },
+                                "children": [
+                                    {
+                                        "name": "struct",
+                                        "nullable": true,
+                                        "type": {
+                                            "name": "struct"
+                                        },
+                                        "children": []
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                    {
+                        "name": "c25",
+                        "nullable": false,
+                        "type": {
+                            "name": "struct"
+                        },
+                        "children": [
+                            {
+                                "name": "a",
+                                "nullable": false,
+                                "type": {
+                                    "name": "utf8"
+                                },
+                                "children": []
+                            },
+                            {
+                                "name": "b",
+                                "nullable": false,
+                                "type": {
+                                    "name": "int",
+                                    "bitWidth": 16,
+                                    "isSigned": false
+                                },
+                                "children": []
+                            }
+                        ]
+                    },
+                    {
+                        "name": "c26",
+                        "nullable": true,
+                        "type": {
+                            "name": "interval",
+                            "unit": "YEAR_MONTH"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c27",
+                        "nullable": true,
+                        "type": {
+                            "name": "interval",
+                            "unit": "DAY_TIME"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c28",
+                        "nullable": true,
+                        "type": {
+                            "name": "interval",
+                            "unit": "MONTH_DAY_NANO"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c29",
+                        "nullable": false,
+                        "type": {
+                            "name": "duration",
+                            "unit": "SECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c30",
+                        "nullable": false,
+                        "type": {
+                            "name": "duration",
+                            "unit": "MILLISECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c31",
+                        "nullable": false,
+                        "type": {
+                            "name": "duration",
+                            "unit": "MICROSECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c32",
+                        "nullable": false,
+                        "type": {
+                            "name": "duration",
+                            "unit": "NANOSECOND"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c33",
+                        "nullable": true,
+                        "children": [],
+                        "type": {
+                          "name": "utf8"
+                        },
+                        "dictionary": {
+                          "id": 123,
+                          "indexType": {
+                            "name": "int",
+                            "bitWidth": 32,
+                            "isSigned": true
+                          },
+                          "isOrdered": true
+                        }
+                    },
+                    {
+                        "name": "c34",
+                        "nullable": true,
+                        "type": {
+                          "name": "largebinary"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c35",
+                        "nullable": true,
+                        "type": {
+                          "name": "largeutf8"
+                        },
+                        "children": []
+                    },
+                    {
+                        "name": "c36",
+                        "nullable": true,
+                        "type": {
+                          "name": "largelist"
+                        },
+                        "children": [
+                            {
+                                "name": "inner_large_list",
+                                "nullable": true,
+                                "type": {
+                                    "name": "largelist"
+                                },
+                                "children": [
+                                    {
+                                        "name": "struct",
+                                        "nullable": false,
+                                        "type": {
+                                            "name": "struct"
+                                        },
+                                        "children": []
+                                    }
+                                ]
+                            }
+                        ]
+                    },
+                    {
+                        "name": "c37",
+                        "nullable": false,
+                        "type": {
+                            "name": "map",
+                            "keysSorted": true
+                        },
+                        "children": [
+                            {
+                                "name": "my_entries",
+                                "nullable": false,
+                                "type": {
+                                    "name": "struct"
+                                },
+                                "children": [
+                                    {
+                                        "name": "my_keys",
+                                        "nullable": false,
+                                        "type": {
+                                            "name": "utf8"
+                                        },
+                                        "children": []
+                                    },
+                                    {
+                                        "name": "my_values",
+                                        "nullable": true,
+                                        "type": {
+                                            "name": "int",
+                                            "bitWidth": 16,
+                                            "isSigned": false
+                                        },
+                                        "children": []
+                                    }
+                                ]
+                            }
+                        ]
+                    }
+                ],
+                "metadata" : {
+                    "Key": "Value"
+                }
+            }"#;
+        let value: Value = serde_json::from_str(json).unwrap();
+        assert_eq!(expected, value);
+
+        // convert back to a schema
+        let value: Value = serde_json::from_str(json).unwrap();
+        let schema2 = schema_from_json(&value).unwrap();
+
+        assert_eq!(schema, schema2);
+
+        // Check that empty metadata produces empty value in JSON and can be parsed
+        let json = r#"{
+                "fields": [
+                    {
+                        "name": "c1",
+                        "nullable": false,
+                        "type": {
+                            "name": "utf8"
+                        },
+                        "children": []
+                    }
+                ],
+                "metadata": {}
+            }"#;
+        let value: Value = serde_json::from_str(json).unwrap();
+        let schema = schema_from_json(&value).unwrap();
+        assert!(schema.metadata.is_empty());
+
+        // Check that metadata field is not required in the JSON.
+        let json = r#"{
+                "fields": [
+                    {
+                        "name": "c1",
+                        "nullable": false,
+                        "type": {
+                            "name": "utf8"
+                        },
+                        "children": []
+                    }
+                ]
+            }"#;
+        let value: Value = serde_json::from_str(json).unwrap();
+        let schema = schema_from_json(&value).unwrap();
+        assert!(schema.metadata.is_empty());
+    }
+}
diff --git a/integration-testing/Cargo.toml b/arrow-integration-testing/Cargo.toml
similarity index 59%
rename from integration-testing/Cargo.toml
rename to arrow-integration-testing/Cargo.toml
index 12892badcd27..032b99f4fbbb 100644
--- a/integration-testing/Cargo.toml
+++ b/arrow-integration-testing/Cargo.toml
@@ -17,31 +17,39 @@
 
 [package]
 name = "arrow-integration-testing"
-description = "Binaries used in the Arrow integration tests"
-version = "20.0.0"
-homepage = "https://github.com/apache/arrow-rs"
-repository = "https://github.com/apache/arrow-rs"
-authors = ["Apache Arrow <dev@arrow.apache.org>"]
-license = "Apache-2.0"
-edition = "2021"
+description = "Binaries used in the Arrow integration tests (NOT PUBLISHED TO crates.io)"
+version = { workspace = true }
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+edition = { workspace = true }
 publish = false
-rust-version = "1.62"
+rust-version = { workspace = true }
+
+[lib]
+crate-type = ["lib", "cdylib"]
 
 [features]
 logging = ["tracing-subscriber"]
 
 [dependencies]
-arrow = { path = "../arrow", default-features = false, features = [ "test_utils" ] }
+arrow = { path = "../arrow", default-features = false, features = ["test_utils", "ipc", "ipc_compression", "json", "ffi"] }
 arrow-flight = { path = "../arrow-flight", default-features = false }
+arrow-buffer = { path = "../arrow-buffer", default-features = false }
+arrow-integration-test = { path = "../arrow-integration-test", default-features = false }
 async-trait = { version = "0.1.41", default-features = false }
-clap = { version = "3", default-features = false, features = ["std", "derive"] }
+clap = { version = "4", default-features = false, features = ["std", "derive", "help", "error-context", "usage"] }
 futures = { version = "0.3", default-features = false }
-hex = { version = "0.4", default-features = false }
-prost = { version = "0.11", default-features = false }
-serde = { version = "1.0", default-features = false, features = ["rc"] }
-serde_derive = { version = "1.0", default-features = false }
+hex = { version = "0.4", default-features = false, features = ["std"] }
+prost = { version = "0.12", default-features = false }
+serde = { version = "1.0", default-features = false, features = ["rc", "derive"] }
 serde_json = { version = "1.0", default-features = false, features = ["std"] }
 tokio = { version = "1.0", default-features = false }
-tonic = { version = "0.8", default-features = false }
+tonic = { version = "0.11", default-features = false }
 tracing-subscriber = { version = "0.3.1", default-features = false, features = ["fmt"], optional = true }
 num = { version = "0.4", default-features = false, features = ["std"] }
+flate2 = { version = "1", default-features = false, features = ["rust_backend"] }
+
+[dev-dependencies]
+tempfile = { version = "3", default-features = false }
diff --git a/integration-testing/README.md b/arrow-integration-testing/README.md
similarity index 99%
rename from integration-testing/README.md
rename to arrow-integration-testing/README.md
index e82591e6b139..dcf39c27fbc5 100644
--- a/integration-testing/README.md
+++ b/arrow-integration-testing/README.md
@@ -48,7 +48,7 @@ ln -s <path_to_arrow_rs> arrow/rust
 
 ```shell
 cd arrow
-pip install -e dev/archery[docker]
+pip install -e dev/archery[integration]
 ```
 
 ### Build the C++ binaries:
diff --git a/integration-testing/src/bin/arrow-file-to-stream.rs b/arrow-integration-testing/src/bin/arrow-file-to-stream.rs
similarity index 97%
rename from integration-testing/src/bin/arrow-file-to-stream.rs
rename to arrow-integration-testing/src/bin/arrow-file-to-stream.rs
index e939fe4f0bf7..3e027faef91f 100644
--- a/integration-testing/src/bin/arrow-file-to-stream.rs
+++ b/arrow-integration-testing/src/bin/arrow-file-to-stream.rs
@@ -30,7 +30,7 @@ struct Args {
 
 fn main() -> Result<()> {
     let args = Args::parse();
-    let f = File::open(&args.file_name)?;
+    let f = File::open(args.file_name)?;
     let reader = BufReader::new(f);
     let mut reader = FileReader::try_new(reader, None)?;
     let schema = reader.schema();
diff --git a/integration-testing/src/bin/arrow-json-integration-test.rs b/arrow-integration-testing/src/bin/arrow-json-integration-test.rs
similarity index 66%
rename from integration-testing/src/bin/arrow-json-integration-test.rs
rename to arrow-integration-testing/src/bin/arrow-json-integration-test.rs
index b442e8b5ed30..9f1abb16a668 100644
--- a/integration-testing/src/bin/arrow-json-integration-test.rs
+++ b/arrow-integration-testing/src/bin/arrow-json-integration-test.rs
@@ -15,17 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::datatypes::Schema;
-use arrow::datatypes::{DataType, Field};
 use arrow::error::{ArrowError, Result};
 use arrow::ipc::reader::FileReader;
 use arrow::ipc::writer::FileWriter;
-use arrow::util::integration_util::*;
-use arrow_integration_testing::read_json_file;
+use arrow_integration_test::*;
+use arrow_integration_testing::{canonicalize_schema, open_json_file};
 use clap::Parser;
 use std::fs::File;
 
-#[derive(clap::ArgEnum, Debug, Clone)]
+#[derive(clap::ValueEnum, Debug, Clone)]
 #[clap(rename_all = "SCREAMING_SNAKE_CASE")]
 enum Mode {
     ArrowToJson,
@@ -42,7 +40,7 @@ struct Args {
     arrow: String,
     #[clap(short, long, help("Path to JSON file"))]
     json: String,
-    #[clap(arg_enum, short, long, default_value_t = Mode::Validate, help="Mode of integration testing tool")]
+    #[clap(value_enum, short, long, default_value_t = Mode::Validate, help="Mode of integration testing tool")]
     mode: Mode,
     #[clap(short, long)]
     verbose: bool,
@@ -62,15 +60,15 @@ fn main() -> Result<()> {
 
 fn json_to_arrow(json_name: &str, arrow_name: &str, verbose: bool) -> Result<()> {
     if verbose {
-        eprintln!("Converting {} to {}", json_name, arrow_name);
+        eprintln!("Converting {json_name} to {arrow_name}");
     }
 
-    let json_file = read_json_file(json_name)?;
+    let json_file = open_json_file(json_name)?;
 
     let arrow_file = File::create(arrow_name)?;
     let mut writer = FileWriter::try_new(arrow_file, &json_file.schema)?;
 
-    for b in json_file.batches {
+    for b in json_file.read_batches()? {
         writer.write(&b)?;
     }
 
@@ -81,7 +79,7 @@ fn json_to_arrow(json_name: &str, arrow_name: &str, verbose: bool) -> Result<()>
 
 fn arrow_to_json(arrow_name: &str, json_name: &str, verbose: bool) -> Result<()> {
     if verbose {
-        eprintln!("Converting {} to {}", arrow_name, json_name);
+        eprintln!("Converting {arrow_name} to {json_name}");
     }
 
     let arrow_file = File::open(arrow_name)?;
@@ -112,54 +110,13 @@ fn arrow_to_json(arrow_name: &str, json_name: &str, verbose: bool) -> Result<()>
     Ok(())
 }
 
-fn canonicalize_schema(schema: &Schema) -> Schema {
-    let fields = schema
-        .fields()
-        .iter()
-        .map(|field| match field.data_type() {
-            DataType::Map(child_field, sorted) => match child_field.data_type() {
-                DataType::Struct(fields) if fields.len() == 2 => {
-                    let first_field = fields.get(0).unwrap();
-                    let key_field = Field::new(
-                        "key",
-                        first_field.data_type().clone(),
-                        first_field.is_nullable(),
-                    );
-                    let second_field = fields.get(1).unwrap();
-                    let value_field = Field::new(
-                        "value",
-                        second_field.data_type().clone(),
-                        second_field.is_nullable(),
-                    );
-
-                    let struct_type = DataType::Struct(vec![key_field, value_field]);
-                    let child_field =
-                        Field::new("entries", struct_type, child_field.is_nullable());
-
-                    Field::new(
-                        field.name().as_str(),
-                        DataType::Map(Box::new(child_field), *sorted),
-                        field.is_nullable(),
-                    )
-                }
-                _ => panic!(
-                    "The child field of Map type should be Struct type with 2 fields."
-                ),
-            },
-            _ => field.clone(),
-        })
-        .collect::<Vec<_>>();
-
-    Schema::new(fields).with_metadata(schema.metadata().clone())
-}
-
 fn validate(arrow_name: &str, json_name: &str, verbose: bool) -> Result<()> {
     if verbose {
-        eprintln!("Validating {} and {}", arrow_name, json_name);
+        eprintln!("Validating {arrow_name} and {json_name}");
     }
 
     // open JSON file
-    let json_file = read_json_file(json_name)?;
+    let json_file = open_json_file(json_name)?;
 
     // open Arrow file
     let arrow_file = File::open(arrow_name)?;
@@ -174,7 +131,7 @@ fn validate(arrow_name: &str, json_name: &str, verbose: bool) -> Result<()> {
         )));
     }
 
-    let json_batches = &json_file.batches;
+    let json_batches = json_file.read_batches()?;
 
     // compare number of batches
     assert!(
@@ -198,8 +155,8 @@ fn validate(arrow_name: &str, json_name: &str, verbose: bool) -> Result<()> {
 
             for i in 0..num_columns {
                 assert_eq!(
-                    arrow_batch.column(i).data(),
-                    json_batch.column(i).data(),
+                    arrow_batch.column(i).as_ref(),
+                    json_batch.column(i).as_ref(),
                     "Arrow and JSON batch columns not the same"
                 );
             }
diff --git a/integration-testing/src/bin/arrow-stream-to-file.rs b/arrow-integration-testing/src/bin/arrow-stream-to-file.rs
similarity index 100%
rename from integration-testing/src/bin/arrow-stream-to-file.rs
rename to arrow-integration-testing/src/bin/arrow-stream-to-file.rs
diff --git a/integration-testing/src/bin/flight-test-integration-client.rs b/arrow-integration-testing/src/bin/flight-test-integration-client.rs
similarity index 95%
rename from integration-testing/src/bin/flight-test-integration-client.rs
rename to arrow-integration-testing/src/bin/flight-test-integration-client.rs
index fa99b424e378..b8bbb952837b 100644
--- a/integration-testing/src/bin/flight-test-integration-client.rs
+++ b/arrow-integration-testing/src/bin/flight-test-integration-client.rs
@@ -20,7 +20,7 @@ use clap::Parser;
 type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 type Result<T = (), E = Error> = std::result::Result<T, E>;
 
-#[derive(clap::ArgEnum, Debug, Clone)]
+#[derive(clap::ValueEnum, Debug, Clone)]
 enum Scenario {
     Middleware,
     #[clap(name = "auth:basic_proto")]
@@ -40,7 +40,7 @@ struct Args {
         help = "path to the descriptor file, only used when scenario is not provided. See https://arrow.apache.org/docs/format/Integration.html#json-test-data-format"
     )]
     path: Option<String>,
-    #[clap(long, arg_enum)]
+    #[clap(long, value_enum)]
     scenario: Option<Scenario>,
 }
 
@@ -62,8 +62,7 @@ async fn main() -> Result {
         }
         None => {
             let path = args.path.expect("No path is given");
-            flight_client_scenarios::integration_test::run_scenario(&host, port, &path)
-                .await?;
+            flight_client_scenarios::integration_test::run_scenario(&host, port, &path).await?;
         }
     }
 
diff --git a/integration-testing/src/bin/flight-test-integration-server.rs b/arrow-integration-testing/src/bin/flight-test-integration-server.rs
similarity index 96%
rename from integration-testing/src/bin/flight-test-integration-server.rs
rename to arrow-integration-testing/src/bin/flight-test-integration-server.rs
index 6ed22ad81d90..5310d07d4f8e 100644
--- a/integration-testing/src/bin/flight-test-integration-server.rs
+++ b/arrow-integration-testing/src/bin/flight-test-integration-server.rs
@@ -21,7 +21,7 @@ use clap::Parser;
 type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 type Result<T = (), E = Error> = std::result::Result<T, E>;
 
-#[derive(clap::ArgEnum, Debug, Clone)]
+#[derive(clap::ValueEnum, Debug, Clone)]
 enum Scenario {
     Middleware,
     #[clap(name = "auth:basic_proto")]
@@ -33,7 +33,7 @@ enum Scenario {
 struct Args {
     #[clap(long)]
     port: u16,
-    #[clap(long, arg_enum)]
+    #[clap(long, value_enum)]
     scenario: Option<Scenario>,
 }
 
diff --git a/integration-testing/src/flight_client_scenarios.rs b/arrow-integration-testing/src/flight_client_scenarios.rs
similarity index 100%
rename from integration-testing/src/flight_client_scenarios.rs
rename to arrow-integration-testing/src/flight_client_scenarios.rs
diff --git a/integration-testing/src/flight_client_scenarios/auth_basic_proto.rs b/arrow-integration-testing/src/flight_client_scenarios/auth_basic_proto.rs
similarity index 84%
rename from integration-testing/src/flight_client_scenarios/auth_basic_proto.rs
rename to arrow-integration-testing/src/flight_client_scenarios/auth_basic_proto.rs
index ab398d3d2e7b..376e31e15553 100644
--- a/integration-testing/src/flight_client_scenarios/auth_basic_proto.rs
+++ b/arrow-integration-testing/src/flight_client_scenarios/auth_basic_proto.rs
@@ -17,9 +17,7 @@
 
 use crate::{AUTH_PASSWORD, AUTH_USERNAME};
 
-use arrow_flight::{
-    flight_service_client::FlightServiceClient, BasicAuth, HandshakeRequest,
-};
+use arrow_flight::{flight_service_client::FlightServiceClient, BasicAuth, HandshakeRequest};
 use futures::{stream, StreamExt};
 use prost::Message;
 use tonic::{metadata::MetadataValue, Request, Status};
@@ -30,7 +28,7 @@ type Result<T = (), E = Error> = std::result::Result<T, E>;
 type Client = FlightServiceClient<tonic::transport::Channel>;
 
 pub async fn run_scenario(host: &str, port: u16) -> Result {
-    let url = format!("http://{}:{}", host, port);
+    let url = format!("http://{host}:{port}");
     let mut client = FlightServiceClient::connect(url).await?;
 
     let action = arrow_flight::Action::default();
@@ -41,15 +39,13 @@ pub async fn run_scenario(host: &str, port: u16) -> Result {
         Err(e) => {
             if e.code() != tonic::Code::Unauthenticated {
                 return Err(Box::new(Status::internal(format!(
-                    "Expected UNAUTHENTICATED but got {:?}",
-                    e
+                    "Expected UNAUTHENTICATED but got {e:?}"
                 ))));
             }
         }
         Ok(other) => {
             return Err(Box::new(Status::internal(format!(
-                "Expected UNAUTHENTICATED but got {:?}",
-                other
+                "Expected UNAUTHENTICATED but got {other:?}"
             ))));
         }
     }
@@ -74,17 +70,13 @@ pub async fn run_scenario(host: &str, port: u16) -> Result {
         .expect("No response received")
         .expect("Invalid response received");
 
-    let body = String::from_utf8(r.body).unwrap();
+    let body = std::str::from_utf8(&r.body).unwrap();
     assert_eq!(body, AUTH_USERNAME);
 
     Ok(())
 }
 
-async fn authenticate(
-    client: &mut Client,
-    username: &str,
-    password: &str,
-) -> Result<String> {
+async fn authenticate(client: &mut Client, username: &str, password: &str) -> Result<String> {
     let auth = BasicAuth {
         username: username.into(),
         password: password.into(),
@@ -94,7 +86,7 @@ async fn authenticate(
 
     let req = stream::once(async {
         HandshakeRequest {
-            payload,
+            payload: payload.into(),
             ..HandshakeRequest::default()
         }
     });
@@ -105,5 +97,5 @@ async fn authenticate(
     let r = rx.next().await.expect("must respond from handshake")?;
     assert!(rx.next().await.is_none(), "must not respond a second time");
 
-    Ok(String::from_utf8(r.payload).unwrap())
+    Ok(std::str::from_utf8(&r.payload).unwrap().into())
 }
diff --git a/integration-testing/src/flight_client_scenarios/integration_test.rs b/arrow-integration-testing/src/flight_client_scenarios/integration_test.rs
similarity index 80%
rename from integration-testing/src/flight_client_scenarios/integration_test.rs
rename to arrow-integration-testing/src/flight_client_scenarios/integration_test.rs
index 62fe2b85d262..c6b5a72ca6e2 100644
--- a/integration-testing/src/flight_client_scenarios/integration_test.rs
+++ b/arrow-integration-testing/src/flight_client_scenarios/integration_test.rs
@@ -15,19 +15,19 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::{read_json_file, ArrowFile};
+use crate::open_json_file;
 use std::collections::HashMap;
 
 use arrow::{
     array::ArrayRef,
+    buffer::Buffer,
     datatypes::SchemaRef,
     ipc::{self, reader, writer},
     record_batch::RecordBatch,
 };
 use arrow_flight::{
     flight_descriptor::DescriptorType, flight_service_client::FlightServiceClient,
-    utils::flight_data_to_arrow_batch, FlightData, FlightDescriptor, Location,
-    SchemaAsIpc, Ticket,
+    utils::flight_data_to_arrow_batch, FlightData, FlightDescriptor, Location, SchemaAsIpc, Ticket,
 };
 use futures::{channel::mpsc, sink::SinkExt, stream, StreamExt};
 use tonic::{Request, Streaming};
@@ -41,27 +41,20 @@ type Result<T = (), E = Error> = std::result::Result<T, E>;
 type Client = FlightServiceClient<tonic::transport::Channel>;
 
 pub async fn run_scenario(host: &str, port: u16, path: &str) -> Result {
-    let url = format!("http://{}:{}", host, port);
+    let url = format!("http://{host}:{port}");
 
     let client = FlightServiceClient::connect(url).await?;
 
-    let ArrowFile {
-        schema, batches, ..
-    } = read_json_file(path)?;
+    let json_file = open_json_file(path)?;
 
-    let schema = Arc::new(schema);
+    let batches = json_file.read_batches()?;
+    let schema = Arc::new(json_file.schema);
 
     let mut descriptor = FlightDescriptor::default();
     descriptor.set_type(DescriptorType::Path);
     descriptor.path = vec![path.to_string()];
 
-    upload_data(
-        client.clone(),
-        schema.clone(),
-        descriptor.clone(),
-        batches.clone(),
-    )
-    .await?;
+    upload_data(client.clone(), schema, descriptor.clone(), batches.clone()).await?;
     verify_data(client, descriptor, &batches).await?;
 
     Ok(())
@@ -129,15 +122,23 @@ async fn send_batch(
     batch: &RecordBatch,
     options: &writer::IpcWriteOptions,
 ) -> Result {
-    let (dictionary_flight_data, mut batch_flight_data) =
-        arrow_flight::utils::flight_data_from_arrow_batch(batch, options);
+    let data_gen = writer::IpcDataGenerator::default();
+    let mut dictionary_tracker = writer::DictionaryTracker::new(false);
+
+    let (encoded_dictionaries, encoded_batch) = data_gen
+        .encoded_batch(batch, &mut dictionary_tracker, options)
+        .expect("DictionaryTracker configured above to not error on replacement");
+
+    let dictionary_flight_data: Vec<FlightData> =
+        encoded_dictionaries.into_iter().map(Into::into).collect();
+    let mut batch_flight_data: FlightData = encoded_batch.into();
 
     upload_tx
         .send_all(&mut stream::iter(dictionary_flight_data).map(Ok))
         .await?;
 
     // Only the record batch's FlightData gets app_metadata
-    batch_flight_data.app_metadata = metadata.to_vec();
+    batch_flight_data.app_metadata = metadata.to_vec().into();
     upload_tx.send(batch_flight_data).await?;
     Ok(())
 }
@@ -194,19 +195,16 @@ async fn consume_flight_location(
     let mut dictionaries_by_id = HashMap::new();
 
     for (counter, expected_batch) in expected_data.iter().enumerate() {
-        let data = receive_batch_flight_data(
-            &mut resp,
-            actual_schema.clone(),
-            &mut dictionaries_by_id,
-        )
-        .await
-        .unwrap_or_else(|| {
-            panic!(
-                "Got fewer batches than expected, received so far: {} expected: {}",
-                counter,
-                expected_data.len(),
-            )
-        });
+        let data =
+            receive_batch_flight_data(&mut resp, actual_schema.clone(), &mut dictionaries_by_id)
+                .await
+                .unwrap_or_else(|| {
+                    panic!(
+                        "Got fewer batches than expected, received so far: {} expected: {}",
+                        counter,
+                        expected_data.len(),
+                    )
+                });
 
         let metadata = counter.to_string().into_bytes();
         assert_eq!(metadata, data.app_metadata);
@@ -223,10 +221,10 @@ async fn consume_flight_location(
             let field = schema.field(i);
             let field_name = field.name();
 
-            let expected_data = expected_batch.column(i).data();
-            let actual_data = actual_batch.column(i).data();
+            let expected_data = expected_batch.column(i).as_ref();
+            let actual_data = actual_batch.column(i).as_ref();
 
-            assert_eq!(expected_data, actual_data, "Data for field {}", field_name);
+            assert_eq!(expected_data, actual_data, "Data for field {field_name}");
         }
     }
 
@@ -241,8 +239,8 @@ async fn consume_flight_location(
 
 async fn receive_schema_flight_data(resp: &mut Streaming<FlightData>) -> Option<Schema> {
     let data = resp.next().await?.ok()?;
-    let message = arrow::ipc::root_as_message(&data.data_header[..])
-        .expect("Error parsing message");
+    let message =
+        arrow::ipc::root_as_message(&data.data_header[..]).expect("Error parsing message");
 
     // message header is a Schema, so read it
     let ipc_schema: ipc::Schema = message
@@ -259,12 +257,12 @@ async fn receive_batch_flight_data(
     dictionaries_by_id: &mut HashMap<i64, ArrayRef>,
 ) -> Option<FlightData> {
     let mut data = resp.next().await?.ok()?;
-    let mut message = arrow::ipc::root_as_message(&data.data_header[..])
-        .expect("Error parsing first message");
+    let mut message =
+        arrow::ipc::root_as_message(&data.data_header[..]).expect("Error parsing first message");
 
     while message.header_type() == ipc::MessageHeader::DictionaryBatch {
         reader::read_dictionary(
-            &data.data_body,
+            &Buffer::from(&data.data_body),
             message
                 .header_as_dictionary_batch()
                 .expect("Error parsing dictionary"),
@@ -275,8 +273,8 @@ async fn receive_batch_flight_data(
         .expect("Error reading dictionary");
 
         data = resp.next().await?.ok()?;
-        message = arrow::ipc::root_as_message(&data.data_header[..])
-            .expect("Error parsing message");
+        message =
+            arrow::ipc::root_as_message(&data.data_header[..]).expect("Error parsing message");
     }
 
     Some(data)
diff --git a/integration-testing/src/flight_client_scenarios/middleware.rs b/arrow-integration-testing/src/flight_client_scenarios/middleware.rs
similarity index 90%
rename from integration-testing/src/flight_client_scenarios/middleware.rs
rename to arrow-integration-testing/src/flight_client_scenarios/middleware.rs
index db8c42cc081c..3b71edf446a3 100644
--- a/integration-testing/src/flight_client_scenarios/middleware.rs
+++ b/arrow-integration-testing/src/flight_client_scenarios/middleware.rs
@@ -16,22 +16,22 @@
 // under the License.
 
 use arrow_flight::{
-    flight_descriptor::DescriptorType, flight_service_client::FlightServiceClient,
-    FlightDescriptor,
+    flight_descriptor::DescriptorType, flight_service_client::FlightServiceClient, FlightDescriptor,
 };
+use prost::bytes::Bytes;
 use tonic::{Request, Status};
 
 type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 type Result<T = (), E = Error> = std::result::Result<T, E>;
 
 pub async fn run_scenario(host: &str, port: u16) -> Result {
-    let url = format!("http://{}:{}", host, port);
+    let url = format!("http://{host}:{port}");
     let conn = tonic::transport::Endpoint::new(url)?.connect().await?;
     let mut client = FlightServiceClient::with_interceptor(conn, middleware_interceptor);
 
     let mut descriptor = FlightDescriptor::default();
     descriptor.set_type(DescriptorType::Cmd);
-    descriptor.cmd = b"".to_vec();
+    descriptor.cmd = Bytes::from_static(b"");
 
     // This call is expected to fail.
     match client
@@ -47,8 +47,7 @@ pub async fn run_scenario(host: &str, port: u16) -> Result {
             if value != "expected value" {
                 let msg = format!(
                     "On failing call: Expected to receive header 'x-middleware: expected value', \
-                     but instead got: '{}'",
-                    value
+                     but instead got: '{value}'"
                 );
                 return Err(Box::new(Status::internal(msg)));
             }
@@ -56,7 +55,7 @@ pub async fn run_scenario(host: &str, port: u16) -> Result {
     }
 
     // This call should succeed
-    descriptor.cmd = b"success".to_vec();
+    descriptor.cmd = Bytes::from_static(b"success");
     let resp = client.get_flight_info(Request::new(descriptor)).await?;
 
     let headers = resp.metadata();
@@ -66,8 +65,7 @@ pub async fn run_scenario(host: &str, port: u16) -> Result {
     if value != "expected value" {
         let msg = format!(
             "On success call: Expected to receive header 'x-middleware: expected value', \
-            but instead got: '{}'",
-            value
+            but instead got: '{value}'"
         );
         return Err(Box::new(Status::internal(msg)));
     }
diff --git a/integration-testing/src/flight_server_scenarios.rs b/arrow-integration-testing/src/flight_server_scenarios.rs
similarity index 89%
rename from integration-testing/src/flight_server_scenarios.rs
rename to arrow-integration-testing/src/flight_server_scenarios.rs
index e56252f1dfbf..48d4e6045684 100644
--- a/integration-testing/src/flight_server_scenarios.rs
+++ b/arrow-integration-testing/src/flight_server_scenarios.rs
@@ -28,7 +28,7 @@ type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
 type Result<T = (), E = Error> = std::result::Result<T, E>;
 
 pub async fn listen_on(port: u16) -> Result<SocketAddr> {
-    let addr: SocketAddr = format!("0.0.0.0:{}", port).parse()?;
+    let addr: SocketAddr = format!("0.0.0.0:{port}").parse()?;
 
     let listener = TcpListener::bind(addr).await?;
     let addr = listener.local_addr()?;
@@ -39,10 +39,12 @@ pub async fn listen_on(port: u16) -> Result<SocketAddr> {
 pub fn endpoint(ticket: &str, location_uri: impl Into<String>) -> FlightEndpoint {
     FlightEndpoint {
         ticket: Some(Ticket {
-            ticket: ticket.as_bytes().to_vec(),
+            ticket: ticket.as_bytes().to_vec().into(),
         }),
         location: vec![Location {
             uri: location_uri.into(),
         }],
+        expiration_time: None,
+        app_metadata: vec![].into(),
     }
 }
diff --git a/integration-testing/src/flight_server_scenarios/auth_basic_proto.rs b/arrow-integration-testing/src/flight_server_scenarios/auth_basic_proto.rs
similarity index 88%
rename from integration-testing/src/flight_server_scenarios/auth_basic_proto.rs
rename to arrow-integration-testing/src/flight_server_scenarios/auth_basic_proto.rs
index 68a4a0d3b4ad..20d868953664 100644
--- a/integration-testing/src/flight_server_scenarios/auth_basic_proto.rs
+++ b/arrow-integration-testing/src/flight_server_scenarios/auth_basic_proto.rs
@@ -19,15 +19,13 @@ use std::pin::Pin;
 use std::sync::Arc;
 
 use arrow_flight::{
-    flight_service_server::FlightService, flight_service_server::FlightServiceServer,
-    Action, ActionType, BasicAuth, Criteria, Empty, FlightData, FlightDescriptor,
-    FlightInfo, HandshakeRequest, HandshakeResponse, PutResult, SchemaResult, Ticket,
+    flight_service_server::FlightService, flight_service_server::FlightServiceServer, Action,
+    ActionType, BasicAuth, Criteria, Empty, FlightData, FlightDescriptor, FlightInfo,
+    HandshakeRequest, HandshakeResponse, PollInfo, PutResult, SchemaResult, Ticket,
 };
 use futures::{channel::mpsc, sink::SinkExt, Stream, StreamExt};
 use tokio::sync::Mutex;
-use tonic::{
-    metadata::MetadataMap, transport::Server, Request, Response, Status, Streaming,
-};
+use tonic::{metadata::MetadataMap, transport::Server, Request, Response, Status, Streaming};
 type TonicStream<T> = Pin<Box<dyn Stream<Item = T> + Send + Sync + 'static>>;
 
 type Error = Box<dyn std::error::Error + Send + Sync + 'static>;
@@ -63,10 +61,7 @@ pub struct AuthBasicProtoScenarioImpl {
 }
 
 impl AuthBasicProtoScenarioImpl {
-    async fn check_auth(
-        &self,
-        metadata: &MetadataMap,
-    ) -> Result<GrpcServerCallContext, Status> {
+    async fn check_auth(&self, metadata: &MetadataMap) -> Result<GrpcServerCallContext, Status> {
         let token = metadata
             .get_bin("auth-token-bin")
             .and_then(|v| v.to_bytes().ok())
@@ -74,10 +69,7 @@ impl AuthBasicProtoScenarioImpl {
         self.is_valid(token).await
     }
 
-    async fn is_valid(
-        &self,
-        token: Option<String>,
-    ) -> Result<GrpcServerCallContext, Status> {
+    async fn is_valid(&self, token: Option<String>) -> Result<GrpcServerCallContext, Status> {
         match token {
             Some(t) if t == *self.username => Ok(GrpcServerCallContext {
                 peer_identity: self.username.to_string(),
@@ -142,14 +134,12 @@ impl FlightService for AuthBasicProtoScenarioImpl {
                         let req = req.expect("Error reading handshake request");
                         let HandshakeRequest { payload, .. } = req;
 
-                        let auth = BasicAuth::decode(&*payload)
-                            .expect("Error parsing handshake request");
+                        let auth =
+                            BasicAuth::decode(&*payload).expect("Error parsing handshake request");
 
-                        let resp = if *auth.username == *username
-                            && *auth.password == *password
-                        {
+                        let resp = if *auth.username == *username && *auth.password == *password {
                             Ok(HandshakeResponse {
-                                payload: username.as_bytes().to_vec(),
+                                payload: username.as_bytes().to_vec().into(),
                                 ..HandshakeResponse::default()
                             })
                         } else {
@@ -188,6 +178,14 @@ impl FlightService for AuthBasicProtoScenarioImpl {
         Err(Status::unimplemented("Not yet implemented"))
     }
 
+    async fn poll_flight_info(
+        &self,
+        request: Request<FlightDescriptor>,
+    ) -> Result<Response<PollInfo>, Status> {
+        self.check_auth(request.metadata()).await?;
+        Err(Status::unimplemented("Not yet implemented"))
+    }
+
     async fn do_put(
         &self,
         request: Request<Streaming<FlightData>>,
@@ -203,7 +201,7 @@ impl FlightService for AuthBasicProtoScenarioImpl {
     ) -> Result<Response<Self::DoActionStream>, Status> {
         let flight_context = self.check_auth(request.metadata()).await?;
         // Respond with the authenticated username.
-        let buf = flight_context.peer_identity().as_bytes().to_vec();
+        let buf = flight_context.peer_identity().as_bytes().to_vec().into();
         let result = arrow_flight::Result { body: buf };
         let output = futures::stream::once(async { Ok(result) });
         Ok(Response::new(Box::pin(output) as Self::DoActionStream))
diff --git a/integration-testing/src/flight_server_scenarios/integration_test.rs b/arrow-integration-testing/src/flight_server_scenarios/integration_test.rs
similarity index 81%
rename from integration-testing/src/flight_server_scenarios/integration_test.rs
rename to arrow-integration-testing/src/flight_server_scenarios/integration_test.rs
index 7ad3d18eb5ba..623a240348f4 100644
--- a/integration-testing/src/flight_server_scenarios/integration_test.rs
+++ b/arrow-integration-testing/src/flight_server_scenarios/integration_test.rs
@@ -22,16 +22,17 @@ use std::sync::Arc;
 
 use arrow::{
     array::ArrayRef,
+    buffer::Buffer,
     datatypes::Schema,
     datatypes::SchemaRef,
-    ipc::{self, reader},
+    ipc::{self, reader, writer},
     record_batch::RecordBatch,
 };
 use arrow_flight::{
     flight_descriptor::DescriptorType, flight_service_server::FlightService,
-    flight_service_server::FlightServiceServer, Action, ActionType, Criteria, Empty,
-    FlightData, FlightDescriptor, FlightEndpoint, FlightInfo, HandshakeRequest,
-    HandshakeResponse, IpcMessage, PutResult, SchemaAsIpc, SchemaResult, Ticket,
+    flight_service_server::FlightServiceServer, Action, ActionType, Criteria, Empty, FlightData,
+    FlightDescriptor, FlightEndpoint, FlightInfo, HandshakeRequest, HandshakeResponse, IpcMessage,
+    PollInfo, PutResult, SchemaAsIpc, SchemaResult, Ticket,
 };
 use futures::{channel::mpsc, sink::SinkExt, Stream, StreamExt};
 use std::convert::TryInto;
@@ -47,7 +48,7 @@ pub async fn scenario_setup(port: u16) -> Result {
     let addr = super::listen_on(port).await?;
 
     let service = FlightServiceImpl {
-        server_location: format!("grpc+tcp://{}", addr),
+        server_location: format!("grpc+tcp://{addr}"),
         ..Default::default()
     };
     let svc = FlightServiceServer::new(service);
@@ -102,33 +103,38 @@ impl FlightService for FlightServiceImpl {
         let ticket = request.into_inner();
 
         let key = String::from_utf8(ticket.ticket.to_vec())
-            .map_err(|e| Status::invalid_argument(format!("Invalid ticket: {:?}", e)))?;
+            .map_err(|e| Status::invalid_argument(format!("Invalid ticket: {e:?}")))?;
 
         let uploaded_chunks = self.uploaded_chunks.lock().await;
 
-        let flight = uploaded_chunks.get(&key).ok_or_else(|| {
-            Status::not_found(format!("Could not find flight. {}", key))
-        })?;
+        let flight = uploaded_chunks
+            .get(&key)
+            .ok_or_else(|| Status::not_found(format!("Could not find flight. {key}")))?;
 
         let options = arrow::ipc::writer::IpcWriteOptions::default();
 
-        let schema =
-            std::iter::once(Ok(SchemaAsIpc::new(&flight.schema, &options).into()));
+        let schema = std::iter::once(Ok(SchemaAsIpc::new(&flight.schema, &options).into()));
 
         let batches = flight
             .chunks
             .iter()
             .enumerate()
             .flat_map(|(counter, batch)| {
-                let (dictionary_flight_data, mut batch_flight_data) =
-                    arrow_flight::utils::flight_data_from_arrow_batch(batch, &options);
+                let data_gen = writer::IpcDataGenerator::default();
+                let mut dictionary_tracker = writer::DictionaryTracker::new(false);
+
+                let (encoded_dictionaries, encoded_batch) = data_gen
+                    .encoded_batch(batch, &mut dictionary_tracker, &options)
+                    .expect("DictionaryTracker configured above to not error on replacement");
+
+                let dictionary_flight_data = encoded_dictionaries.into_iter().map(Into::into);
+                let mut batch_flight_data: FlightData = encoded_batch.into();
 
                 // Only the record batch's FlightData gets app_metadata
-                let metadata = counter.to_string().into_bytes();
+                let metadata = counter.to_string().into();
                 batch_flight_data.app_metadata = metadata;
 
                 dictionary_flight_data
-                    .into_iter()
                     .chain(std::iter::once(batch_flight_data))
                     .map(Ok)
             });
@@ -172,8 +178,7 @@ impl FlightService for FlightServiceImpl {
 
                 let endpoint = self.endpoint_from_path(&path[0]);
 
-                let total_records: usize =
-                    flight.chunks.iter().map(|chunk| chunk.num_rows()).sum();
+                let total_records: usize = flight.chunks.iter().map(|chunk| chunk.num_rows()).sum();
 
                 let options = arrow::ipc::writer::IpcWriteOptions::default();
                 let message = SchemaAsIpc::new(&flight.schema, &options)
@@ -190,14 +195,23 @@ impl FlightService for FlightServiceImpl {
                     endpoint: vec![endpoint],
                     total_records: total_records as i64,
                     total_bytes: -1,
+                    ordered: false,
+                    app_metadata: vec![].into(),
                 };
 
                 Ok(Response::new(info))
             }
-            other => Err(Status::unimplemented(format!("Request type: {}", other))),
+            other => Err(Status::unimplemented(format!("Request type: {other}"))),
         }
     }
 
+    async fn poll_flight_info(
+        &self,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<PollInfo>, Status> {
+        Err(Status::unimplemented("Not yet implemented"))
+    }
+
     async fn do_put(
         &self,
         request: Request<Streaming<FlightData>>,
@@ -213,15 +227,14 @@ impl FlightService for FlightServiceImpl {
             .clone()
             .ok_or_else(|| Status::invalid_argument("Must have a descriptor"))?;
 
-        if descriptor.r#type != DescriptorType::Path as i32 || descriptor.path.is_empty()
-        {
+        if descriptor.r#type != DescriptorType::Path as i32 || descriptor.path.is_empty() {
             return Err(Status::invalid_argument("Must specify a path"));
         }
 
         let key = descriptor.path[0].clone();
 
         let schema = Schema::try_from(&flight_data)
-            .map_err(|e| Status::invalid_argument(format!("Invalid schema: {:?}", e)))?;
+            .map_err(|e| Status::invalid_argument(format!("Invalid schema: {e:?}")))?;
         let schema_ref = Arc::new(schema.clone());
 
         let (response_tx, response_rx) = mpsc::channel(10);
@@ -274,21 +287,21 @@ async fn send_app_metadata(
     app_metadata: &[u8],
 ) -> Result<(), Status> {
     tx.send(Ok(PutResult {
-        app_metadata: app_metadata.to_vec(),
+        app_metadata: app_metadata.to_vec().into(),
     }))
     .await
-    .map_err(|e| Status::internal(format!("Could not send PutResult: {:?}", e)))
+    .map_err(|e| Status::internal(format!("Could not send PutResult: {e:?}")))
 }
 
 async fn record_batch_from_message(
     message: ipc::Message<'_>,
-    data_body: &[u8],
+    data_body: &Buffer,
     schema_ref: SchemaRef,
     dictionaries_by_id: &HashMap<i64, ArrayRef>,
 ) -> Result<RecordBatch, Status> {
-    let ipc_batch = message.header_as_record_batch().ok_or_else(|| {
-        Status::internal("Could not parse message header as record batch")
-    })?;
+    let ipc_batch = message
+        .header_as_record_batch()
+        .ok_or_else(|| Status::internal("Could not parse message header as record batch"))?;
 
     let arrow_batch_result = reader::read_record_batch(
         data_body,
@@ -299,20 +312,19 @@ async fn record_batch_from_message(
         &message.version(),
     );
 
-    arrow_batch_result.map_err(|e| {
-        Status::internal(format!("Could not convert to RecordBatch: {:?}", e))
-    })
+    arrow_batch_result
+        .map_err(|e| Status::internal(format!("Could not convert to RecordBatch: {e:?}")))
 }
 
 async fn dictionary_from_message(
     message: ipc::Message<'_>,
-    data_body: &[u8],
+    data_body: &Buffer,
     schema_ref: SchemaRef,
     dictionaries_by_id: &mut HashMap<i64, ArrayRef>,
 ) -> Result<(), Status> {
-    let ipc_batch = message.header_as_dictionary_batch().ok_or_else(|| {
-        Status::internal("Could not parse message header as dictionary batch")
-    })?;
+    let ipc_batch = message
+        .header_as_dictionary_batch()
+        .ok_or_else(|| Status::internal("Could not parse message header as dictionary batch"))?;
 
     let dictionary_batch_result = reader::read_dictionary(
         data_body,
@@ -321,9 +333,8 @@ async fn dictionary_from_message(
         dictionaries_by_id,
         &message.version(),
     );
-    dictionary_batch_result.map_err(|e| {
-        Status::internal(format!("Could not convert to Dictionary: {:?}", e))
-    })
+    dictionary_batch_result
+        .map_err(|e| Status::internal(format!("Could not convert to Dictionary: {e:?}")))
 }
 
 async fn save_uploaded_chunks(
@@ -341,7 +352,7 @@ async fn save_uploaded_chunks(
 
     while let Some(Ok(data)) = input_stream.next().await {
         let message = arrow::ipc::root_as_message(&data.data_header[..])
-            .map_err(|e| Status::internal(format!("Could not parse message: {:?}", e)))?;
+            .map_err(|e| Status::internal(format!("Could not parse message: {e:?}")))?;
 
         match message.header_type() {
             ipc::MessageHeader::Schema => {
@@ -354,7 +365,7 @@ async fn save_uploaded_chunks(
 
                 let batch = record_batch_from_message(
                     message,
-                    &data.data_body,
+                    &Buffer::from(data.data_body),
                     schema_ref.clone(),
                     &dictionaries_by_id,
                 )
@@ -365,7 +376,7 @@ async fn save_uploaded_chunks(
             ipc::MessageHeader::DictionaryBatch => {
                 dictionary_from_message(
                     message,
-                    &data.data_body,
+                    &Buffer::from(data.data_body),
                     schema_ref.clone(),
                     &mut dictionaries_by_id,
                 )
@@ -374,8 +385,7 @@ async fn save_uploaded_chunks(
             t => {
                 return Err(Status::internal(format!(
                     "Reading types other than record batches not yet supported, \
-                                              unable to read {:?}",
-                    t
+                                              unable to read {t:?}"
                 )));
             }
         }
diff --git a/integration-testing/src/flight_server_scenarios/middleware.rs b/arrow-integration-testing/src/flight_server_scenarios/middleware.rs
similarity index 92%
rename from integration-testing/src/flight_server_scenarios/middleware.rs
rename to arrow-integration-testing/src/flight_server_scenarios/middleware.rs
index 5876ac9bfe6d..e8d9c521bb99 100644
--- a/integration-testing/src/flight_server_scenarios/middleware.rs
+++ b/arrow-integration-testing/src/flight_server_scenarios/middleware.rs
@@ -19,9 +19,9 @@ use std::pin::Pin;
 
 use arrow_flight::{
     flight_descriptor::DescriptorType, flight_service_server::FlightService,
-    flight_service_server::FlightServiceServer, Action, ActionType, Criteria, Empty,
-    FlightData, FlightDescriptor, FlightInfo, HandshakeRequest, HandshakeResponse,
-    PutResult, SchemaResult, Ticket,
+    flight_service_server::FlightServiceServer, Action, ActionType, Criteria, Empty, FlightData,
+    FlightDescriptor, FlightInfo, HandshakeRequest, HandshakeResponse, PollInfo, PutResult,
+    SchemaResult, Ticket,
 };
 use futures::Stream;
 use tonic::{transport::Server, Request, Response, Status, Streaming};
@@ -93,7 +93,7 @@ impl FlightService for MiddlewareScenarioImpl {
 
         let descriptor = request.into_inner();
 
-        if descriptor.r#type == DescriptorType::Cmd as i32 && descriptor.cmd == b"success"
+        if descriptor.r#type == DescriptorType::Cmd as i32 && descriptor.cmd.as_ref() == b"success"
         {
             // Return a fake location - the test doesn't read it
             let endpoint = super::endpoint("foo", "grpc+tcp://localhost:10010");
@@ -120,6 +120,13 @@ impl FlightService for MiddlewareScenarioImpl {
         Err(status)
     }
 
+    async fn poll_flight_info(
+        &self,
+        _request: Request<FlightDescriptor>,
+    ) -> Result<Response<PollInfo>, Status> {
+        Err(Status::unimplemented("Not yet implemented"))
+    }
+
     async fn do_put(
         &self,
         _request: Request<Streaming<FlightData>>,
diff --git a/arrow-integration-testing/src/lib.rs b/arrow-integration-testing/src/lib.rs
new file mode 100644
index 000000000000..4ce7b06a1888
--- /dev/null
+++ b/arrow-integration-testing/src/lib.rs
@@ -0,0 +1,302 @@
+// 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.
+
+//! Common code used in the integration test binaries
+
+use serde_json::Value;
+
+use arrow::array::{Array, StructArray};
+use arrow::datatypes::{DataType, Field, Fields, Schema};
+use arrow::error::{ArrowError, Result};
+use arrow::ffi::{from_ffi_and_data_type, FFI_ArrowArray, FFI_ArrowSchema};
+use arrow::record_batch::RecordBatch;
+use arrow::util::test_util::arrow_test_data;
+use arrow_integration_test::*;
+use std::collections::HashMap;
+use std::ffi::{c_int, CStr, CString};
+use std::fs::File;
+use std::io::BufReader;
+use std::iter::zip;
+use std::ptr;
+use std::sync::Arc;
+
+/// The expected username for the basic auth integration test.
+pub const AUTH_USERNAME: &str = "arrow";
+/// The expected password for the basic auth integration test.
+pub const AUTH_PASSWORD: &str = "flight";
+
+pub mod flight_client_scenarios;
+pub mod flight_server_scenarios;
+
+pub struct ArrowFile {
+    pub schema: Schema,
+    // we can evolve this into a concrete Arrow type
+    // this is temporarily not being read from
+    dictionaries: HashMap<i64, ArrowJsonDictionaryBatch>,
+    arrow_json: Value,
+}
+
+impl ArrowFile {
+    pub fn read_batch(&self, batch_num: usize) -> Result<RecordBatch> {
+        let b = self.arrow_json["batches"].get(batch_num).unwrap();
+        let json_batch: ArrowJsonBatch = serde_json::from_value(b.clone()).unwrap();
+        record_batch_from_json(&self.schema, json_batch, Some(&self.dictionaries))
+    }
+
+    pub fn read_batches(&self) -> Result<Vec<RecordBatch>> {
+        self.arrow_json["batches"]
+            .as_array()
+            .unwrap()
+            .iter()
+            .map(|b| {
+                let json_batch: ArrowJsonBatch = serde_json::from_value(b.clone()).unwrap();
+                record_batch_from_json(&self.schema, json_batch, Some(&self.dictionaries))
+            })
+            .collect()
+    }
+}
+
+// Canonicalize the names of map fields in a schema
+pub fn canonicalize_schema(schema: &Schema) -> Schema {
+    let fields = schema
+        .fields()
+        .iter()
+        .map(|field| match field.data_type() {
+            DataType::Map(child_field, sorted) => match child_field.data_type() {
+                DataType::Struct(fields) if fields.len() == 2 => {
+                    let first_field = &fields[0];
+                    let key_field =
+                        Arc::new(Field::new("key", first_field.data_type().clone(), false));
+                    let second_field = &fields[1];
+                    let value_field = Arc::new(Field::new(
+                        "value",
+                        second_field.data_type().clone(),
+                        second_field.is_nullable(),
+                    ));
+
+                    let fields = Fields::from([key_field, value_field]);
+                    let struct_type = DataType::Struct(fields);
+                    let child_field = Field::new("entries", struct_type, false);
+
+                    Arc::new(Field::new(
+                        field.name().as_str(),
+                        DataType::Map(Arc::new(child_field), *sorted),
+                        field.is_nullable(),
+                    ))
+                }
+                _ => panic!("The child field of Map type should be Struct type with 2 fields."),
+            },
+            _ => field.clone(),
+        })
+        .collect::<Fields>();
+
+    Schema::new(fields).with_metadata(schema.metadata().clone())
+}
+
+pub fn open_json_file(json_name: &str) -> Result<ArrowFile> {
+    let json_file = File::open(json_name)?;
+    let reader = BufReader::new(json_file);
+    let arrow_json: Value = serde_json::from_reader(reader).unwrap();
+    let schema = schema_from_json(&arrow_json["schema"])?;
+    // read dictionaries
+    let mut dictionaries = HashMap::new();
+    if let Some(dicts) = arrow_json.get("dictionaries") {
+        for d in dicts
+            .as_array()
+            .expect("Unable to get dictionaries as array")
+        {
+            let json_dict: ArrowJsonDictionaryBatch =
+                serde_json::from_value(d.clone()).expect("Unable to get dictionary from JSON");
+            // TODO: convert to a concrete Arrow type
+            dictionaries.insert(json_dict.id, json_dict);
+        }
+    }
+    Ok(ArrowFile {
+        schema,
+        dictionaries,
+        arrow_json,
+    })
+}
+
+/// Read gzipped JSON test file
+///
+/// For example given the input:
+/// version = `0.17.1`
+/// path = `generated_union`
+///
+/// Returns the contents of
+/// `arrow-ipc-stream/integration/0.17.1/generated_union.json.gz`
+pub fn read_gzip_json(version: &str, path: &str) -> ArrowJson {
+    use flate2::read::GzDecoder;
+    use std::io::Read;
+
+    let testdata = arrow_test_data();
+    let file = File::open(format!(
+        "{testdata}/arrow-ipc-stream/integration/{version}/{path}.json.gz"
+    ))
+    .unwrap();
+    let mut gz = GzDecoder::new(&file);
+    let mut s = String::new();
+    gz.read_to_string(&mut s).unwrap();
+    // convert to Arrow JSON
+    let arrow_json: ArrowJson = serde_json::from_str(&s).unwrap();
+    arrow_json
+}
+
+//
+// C Data Integration entrypoints
+//
+
+fn cdata_integration_export_schema_from_json(
+    c_json_name: *const i8,
+    out: *mut FFI_ArrowSchema,
+) -> Result<()> {
+    let json_name = unsafe { CStr::from_ptr(c_json_name) };
+    let f = open_json_file(json_name.to_str()?)?;
+    let c_schema = FFI_ArrowSchema::try_from(&f.schema)?;
+    // Move exported schema into output struct
+    unsafe { ptr::write(out, c_schema) };
+    Ok(())
+}
+
+fn cdata_integration_export_batch_from_json(
+    c_json_name: *const i8,
+    batch_num: c_int,
+    out: *mut FFI_ArrowArray,
+) -> Result<()> {
+    let json_name = unsafe { CStr::from_ptr(c_json_name) };
+    let b = open_json_file(json_name.to_str()?)?.read_batch(batch_num.try_into().unwrap())?;
+    let a = StructArray::from(b).into_data();
+    let c_array = FFI_ArrowArray::new(&a);
+    // Move exported array into output struct
+    unsafe { ptr::write(out, c_array) };
+    Ok(())
+}
+
+fn cdata_integration_import_schema_and_compare_to_json(
+    c_json_name: *const i8,
+    c_schema: *mut FFI_ArrowSchema,
+) -> Result<()> {
+    let json_name = unsafe { CStr::from_ptr(c_json_name) };
+    let json_schema = open_json_file(json_name.to_str()?)?.schema;
+
+    // The source ArrowSchema will be released when this is dropped
+    let imported_schema = unsafe { FFI_ArrowSchema::from_raw(c_schema) };
+    let imported_schema = Schema::try_from(&imported_schema)?;
+
+    // compare schemas
+    if canonicalize_schema(&json_schema) != canonicalize_schema(&imported_schema) {
+        return Err(ArrowError::ComputeError(format!(
+            "Schemas do not match.\n- JSON: {:?}\n- Imported: {:?}",
+            json_schema, imported_schema
+        )));
+    }
+    Ok(())
+}
+
+fn compare_batches(a: &RecordBatch, b: &RecordBatch) -> Result<()> {
+    if a.num_columns() != b.num_columns() {
+        return Err(ArrowError::InvalidArgumentError(
+            "batches do not have the same number of columns".to_string(),
+        ));
+    }
+    for (a_column, b_column) in zip(a.columns(), b.columns()) {
+        if a_column != b_column {
+            return Err(ArrowError::InvalidArgumentError(
+                "batch columns are not the same".to_string(),
+            ));
+        }
+    }
+    Ok(())
+}
+
+fn cdata_integration_import_batch_and_compare_to_json(
+    c_json_name: *const i8,
+    batch_num: c_int,
+    c_array: *mut FFI_ArrowArray,
+) -> Result<()> {
+    let json_name = unsafe { CStr::from_ptr(c_json_name) };
+    let json_batch =
+        open_json_file(json_name.to_str()?)?.read_batch(batch_num.try_into().unwrap())?;
+    let schema = json_batch.schema();
+
+    let data_type_for_import = DataType::Struct(schema.fields.clone());
+    let imported_array = unsafe { FFI_ArrowArray::from_raw(c_array) };
+    let imported_array = unsafe { from_ffi_and_data_type(imported_array, data_type_for_import) }?;
+    imported_array.validate_full()?;
+    let imported_batch = RecordBatch::from(StructArray::from(imported_array));
+
+    compare_batches(&json_batch, &imported_batch)
+}
+
+// If Result is an error, then export a const char* to its string display, otherwise NULL
+fn result_to_c_error<T, E: std::fmt::Display>(result: &std::result::Result<T, E>) -> *mut i8 {
+    match result {
+        Ok(_) => ptr::null_mut(),
+        Err(e) => CString::new(format!("{}", e)).unwrap().into_raw(),
+    }
+}
+
+/// Release a const char* exported by result_to_c_error()
+///
+/// # Safety
+///
+/// The pointer is assumed to have been obtained using CString::into_raw.
+#[no_mangle]
+pub unsafe extern "C" fn arrow_rs_free_error(c_error: *mut i8) {
+    if !c_error.is_null() {
+        drop(unsafe { CString::from_raw(c_error) });
+    }
+}
+
+#[no_mangle]
+pub extern "C" fn arrow_rs_cdata_integration_export_schema_from_json(
+    c_json_name: *const i8,
+    out: *mut FFI_ArrowSchema,
+) -> *mut i8 {
+    let r = cdata_integration_export_schema_from_json(c_json_name, out);
+    result_to_c_error(&r)
+}
+
+#[no_mangle]
+pub extern "C" fn arrow_rs_cdata_integration_import_schema_and_compare_to_json(
+    c_json_name: *const i8,
+    c_schema: *mut FFI_ArrowSchema,
+) -> *mut i8 {
+    let r = cdata_integration_import_schema_and_compare_to_json(c_json_name, c_schema);
+    result_to_c_error(&r)
+}
+
+#[no_mangle]
+pub extern "C" fn arrow_rs_cdata_integration_export_batch_from_json(
+    c_json_name: *const i8,
+    batch_num: c_int,
+    out: *mut FFI_ArrowArray,
+) -> *mut i8 {
+    let r = cdata_integration_export_batch_from_json(c_json_name, batch_num, out);
+    result_to_c_error(&r)
+}
+
+#[no_mangle]
+pub extern "C" fn arrow_rs_cdata_integration_import_batch_and_compare_to_json(
+    c_json_name: *const i8,
+    batch_num: c_int,
+    c_array: *mut FFI_ArrowArray,
+) -> *mut i8 {
+    let r = cdata_integration_import_batch_and_compare_to_json(c_json_name, batch_num, c_array);
+    result_to_c_error(&r)
+}
diff --git a/arrow-integration-testing/tests/ipc_reader.rs b/arrow-integration-testing/tests/ipc_reader.rs
new file mode 100644
index 000000000000..88cdad64f92f
--- /dev/null
+++ b/arrow-integration-testing/tests/ipc_reader.rs
@@ -0,0 +1,199 @@
+// 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.
+
+//! Tests for reading the content of  [`FileReader`] and [`StreamReader`]
+//! in `testing/arrow-ipc-stream/integration/...`
+
+use arrow::error::ArrowError;
+use arrow::ipc::reader::{FileReader, StreamReader};
+use arrow::util::test_util::arrow_test_data;
+use arrow_integration_testing::read_gzip_json;
+use std::fs::File;
+
+#[test]
+fn read_0_1_4() {
+    let testdata = arrow_test_data();
+    let version = "0.14.1";
+    let paths = [
+        "generated_interval",
+        "generated_datetime",
+        "generated_dictionary",
+        "generated_map",
+        "generated_nested",
+        "generated_primitive_no_batches",
+        "generated_primitive_zerolength",
+        "generated_primitive",
+        "generated_decimal",
+    ];
+    paths.iter().for_each(|path| {
+        verify_arrow_file(&testdata, version, path);
+        verify_arrow_stream(&testdata, version, path);
+    });
+}
+
+#[test]
+fn read_0_1_7() {
+    let testdata = arrow_test_data();
+    let version = "0.17.1";
+    let paths = ["generated_union"];
+    paths.iter().for_each(|path| {
+        verify_arrow_file(&testdata, version, path);
+        verify_arrow_stream(&testdata, version, path);
+    });
+}
+
+#[test]
+fn read_1_0_0_bigendian() {
+    let testdata = arrow_test_data();
+    let paths = [
+        "generated_decimal",
+        "generated_dictionary",
+        "generated_interval",
+        "generated_datetime",
+        "generated_map",
+        "generated_nested",
+        "generated_null_trivial",
+        "generated_null",
+        "generated_primitive_no_batches",
+        "generated_primitive_zerolength",
+        "generated_primitive",
+    ];
+    paths.iter().for_each(|path| {
+        let file = File::open(format!(
+            "{testdata}/arrow-ipc-stream/integration/1.0.0-bigendian/{path}.arrow_file"
+        ))
+        .unwrap();
+
+        let reader = FileReader::try_new(file, None);
+
+        assert!(reader.is_err());
+        let err = reader.err().unwrap();
+        assert!(matches!(err, ArrowError::IpcError(_)));
+        assert_eq!(err.to_string(), "Ipc error: the endianness of the source system does not match the endianness of the target system.");
+    });
+}
+
+#[test]
+fn read_1_0_0_littleendian() {
+    let testdata = arrow_test_data();
+    let version = "1.0.0-littleendian";
+    let paths = vec![
+        "generated_datetime",
+        "generated_custom_metadata",
+        "generated_decimal",
+        "generated_decimal256",
+        "generated_dictionary",
+        "generated_dictionary_unsigned",
+        "generated_duplicate_fieldnames",
+        "generated_extension",
+        "generated_interval",
+        "generated_map",
+        // https://github.com/apache/arrow-rs/issues/3460
+        //"generated_map_non_canonical",
+        "generated_nested",
+        "generated_nested_dictionary",
+        "generated_nested_large_offsets",
+        "generated_null",
+        "generated_null_trivial",
+        "generated_primitive",
+        "generated_primitive_large_offsets",
+        "generated_primitive_no_batches",
+        "generated_primitive_zerolength",
+        "generated_recursive_nested",
+        "generated_union",
+    ];
+    paths.iter().for_each(|path| {
+        verify_arrow_file(&testdata, version, path);
+        verify_arrow_stream(&testdata, version, path);
+    });
+}
+
+#[test]
+fn read_2_0_0_compression() {
+    let testdata = arrow_test_data();
+    let version = "2.0.0-compression";
+
+    // the test is repetitive, thus we can read all supported files at once
+    let paths = ["generated_lz4", "generated_zstd"];
+    paths.iter().for_each(|path| {
+        verify_arrow_file(&testdata, version, path);
+        verify_arrow_stream(&testdata, version, path);
+    });
+}
+
+/// Verifies the arrow file format integration test
+///
+/// Input file:
+/// `arrow-ipc-stream/integration/<version>/<path>.arrow_file
+///
+/// Verification json file
+/// `arrow-ipc-stream/integration/<version>/<path>.json.gz
+fn verify_arrow_file(testdata: &str, version: &str, path: &str) {
+    let filename = format!("{testdata}/arrow-ipc-stream/integration/{version}/{path}.arrow_file");
+    println!("Verifying {filename}");
+
+    // Compare contents to the expected output format in JSON
+    {
+        println!("  verifying content");
+        let file = File::open(&filename).unwrap();
+        let mut reader = FileReader::try_new(file, None).unwrap();
+
+        // read expected JSON output
+        let arrow_json = read_gzip_json(version, path);
+        assert!(arrow_json.equals_reader(&mut reader).unwrap());
+    }
+
+    // Verify that projection works by selecting the first column
+    {
+        println!("  verifying projection");
+        let file = File::open(&filename).unwrap();
+        let reader = FileReader::try_new(file, Some(vec![0])).unwrap();
+        let datatype_0 = reader.schema().fields()[0].data_type().clone();
+        reader.for_each(|batch| {
+            let batch = batch.unwrap();
+            assert_eq!(batch.columns().len(), 1);
+            assert_eq!(datatype_0, batch.schema().fields()[0].data_type().clone());
+        });
+    }
+}
+
+/// Verifies the arrow stream integration test
+///
+/// Input file:
+/// `arrow-ipc-stream/integration/<version>/<path>.stream
+///
+/// Verification json file
+/// `arrow-ipc-stream/integration/<version>/<path>.json.gz
+fn verify_arrow_stream(testdata: &str, version: &str, path: &str) {
+    let filename = format!("{testdata}/arrow-ipc-stream/integration/{version}/{path}.stream");
+    println!("Verifying {filename}");
+
+    // Compare contents to the expected output format in JSON
+    {
+        println!("  verifying content");
+        let file = File::open(&filename).unwrap();
+        let mut reader = StreamReader::try_new(file, None).unwrap();
+
+        // read expected JSON output
+        let arrow_json = read_gzip_json(version, path);
+        assert!(arrow_json.equals_reader(&mut reader).unwrap());
+        // the next batch must be empty
+        assert!(reader.next().is_none());
+        // the stream must indicate that it's finished
+        assert!(reader.is_finished());
+    }
+}
diff --git a/arrow-integration-testing/tests/ipc_writer.rs b/arrow-integration-testing/tests/ipc_writer.rs
new file mode 100644
index 000000000000..d780eb2ee0b5
--- /dev/null
+++ b/arrow-integration-testing/tests/ipc_writer.rs
@@ -0,0 +1,256 @@
+// 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.
+
+use arrow::ipc;
+use arrow::ipc::reader::{FileReader, StreamReader};
+use arrow::ipc::writer::{FileWriter, IpcWriteOptions, StreamWriter};
+use arrow::util::test_util::arrow_test_data;
+use arrow_integration_testing::read_gzip_json;
+use std::fs::File;
+use std::io::Seek;
+
+#[test]
+fn write_0_1_4() {
+    let testdata = arrow_test_data();
+    let version = "0.14.1";
+    let paths = [
+        "generated_interval",
+        "generated_datetime",
+        "generated_dictionary",
+        "generated_map",
+        "generated_nested",
+        "generated_primitive_no_batches",
+        "generated_primitive_zerolength",
+        "generated_primitive",
+        "generated_decimal",
+    ];
+    paths.iter().for_each(|path| {
+        roundtrip_arrow_file(&testdata, version, path);
+        roundtrip_arrow_stream(&testdata, version, path);
+    });
+}
+
+#[test]
+fn write_0_1_7() {
+    let testdata = arrow_test_data();
+    let version = "0.17.1";
+    let paths = ["generated_union"];
+    paths.iter().for_each(|path| {
+        roundtrip_arrow_file(&testdata, version, path);
+        roundtrip_arrow_stream(&testdata, version, path);
+    });
+}
+
+#[test]
+fn write_1_0_0_littleendian() {
+    let testdata = arrow_test_data();
+    let version = "1.0.0-littleendian";
+    let paths = [
+        "generated_datetime",
+        "generated_custom_metadata",
+        "generated_decimal",
+        "generated_decimal256",
+        "generated_dictionary",
+        "generated_dictionary_unsigned",
+        "generated_duplicate_fieldnames",
+        "generated_extension",
+        "generated_interval",
+        "generated_map",
+        // https://github.com/apache/arrow-rs/issues/3460
+        // "generated_map_non_canonical",
+        "generated_nested",
+        "generated_nested_dictionary",
+        "generated_nested_large_offsets",
+        "generated_null",
+        "generated_null_trivial",
+        "generated_primitive",
+        "generated_primitive_large_offsets",
+        "generated_primitive_no_batches",
+        "generated_primitive_zerolength",
+        "generated_recursive_nested",
+        "generated_union",
+    ];
+    paths.iter().for_each(|path| {
+        roundtrip_arrow_file(&testdata, version, path);
+        roundtrip_arrow_stream(&testdata, version, path);
+    });
+}
+
+#[test]
+fn write_2_0_0_compression() {
+    let testdata = arrow_test_data();
+    let version = "2.0.0-compression";
+    let paths = ["generated_lz4", "generated_zstd"];
+
+    // writer options for each compression type
+    let all_options = [
+        IpcWriteOptions::try_new(8, false, ipc::MetadataVersion::V5)
+            .unwrap()
+            .try_with_compression(Some(ipc::CompressionType::LZ4_FRAME))
+            .unwrap(),
+        // write IPC version 5 with zstd
+        IpcWriteOptions::try_new(8, false, ipc::MetadataVersion::V5)
+            .unwrap()
+            .try_with_compression(Some(ipc::CompressionType::ZSTD))
+            .unwrap(),
+    ];
+
+    paths.iter().for_each(|path| {
+        for options in &all_options {
+            println!("Using options {options:?}");
+            roundtrip_arrow_file_with_options(&testdata, version, path, options.clone());
+            roundtrip_arrow_stream_with_options(&testdata, version, path, options.clone());
+        }
+    });
+}
+
+/// Verifies the arrow file writer by reading the contents of an
+/// arrow_file, writing it to a file, and then ensuring the contents
+/// match the expected json contents. It also verifies that
+/// RecordBatches read from the new file matches the original.
+///
+/// Input file:
+/// `arrow-ipc-stream/integration/<version>/<path>.arrow_file
+///
+/// Verification json file
+/// `arrow-ipc-stream/integration/<version>/<path>.json.gz
+fn roundtrip_arrow_file(testdata: &str, version: &str, path: &str) {
+    roundtrip_arrow_file_with_options(testdata, version, path, IpcWriteOptions::default())
+}
+
+fn roundtrip_arrow_file_with_options(
+    testdata: &str,
+    version: &str,
+    path: &str,
+    options: IpcWriteOptions,
+) {
+    let filename = format!("{testdata}/arrow-ipc-stream/integration/{version}/{path}.arrow_file");
+    println!("Verifying {filename}");
+
+    let mut tempfile = tempfile::tempfile().unwrap();
+
+    {
+        println!("  writing to tempfile {tempfile:?}");
+        let file = File::open(&filename).unwrap();
+        let mut reader = FileReader::try_new(file, None).unwrap();
+
+        // read and rewrite the file to a temp location
+        {
+            let mut writer =
+                FileWriter::try_new_with_options(&mut tempfile, &reader.schema(), options).unwrap();
+            while let Some(Ok(batch)) = reader.next() {
+                writer.write(&batch).unwrap();
+            }
+            writer.finish().unwrap();
+        }
+    }
+
+    {
+        println!("  checking rewrite to with json");
+        tempfile.rewind().unwrap();
+        let mut reader = FileReader::try_new(&tempfile, None).unwrap();
+
+        let arrow_json = read_gzip_json(version, path);
+        assert!(arrow_json.equals_reader(&mut reader).unwrap());
+    }
+
+    {
+        println!("  checking rewrite with original");
+        let file = File::open(&filename).unwrap();
+        let reader = FileReader::try_new(file, None).unwrap();
+
+        tempfile.rewind().unwrap();
+        let rewrite_reader = FileReader::try_new(&tempfile, None).unwrap();
+
+        // Compare to original reader
+        reader
+            .into_iter()
+            .zip(rewrite_reader)
+            .for_each(|(batch1, batch2)| {
+                assert_eq!(batch1.unwrap(), batch2.unwrap());
+            });
+    }
+}
+
+/// Verifies the arrow file writer by reading the contents of an
+/// arrow_file, writing it to a file, and then ensuring the contents
+/// match the expected json contents. It also verifies that
+/// RecordBatches read from the new file matches the original.
+///
+/// Input file:
+/// `arrow-ipc-stream/integration/<version>/<path>.stream
+///
+/// Verification json file
+/// `arrow-ipc-stream/integration/<version>/<path>.json.gz
+fn roundtrip_arrow_stream(testdata: &str, version: &str, path: &str) {
+    roundtrip_arrow_stream_with_options(testdata, version, path, IpcWriteOptions::default())
+}
+
+fn roundtrip_arrow_stream_with_options(
+    testdata: &str,
+    version: &str,
+    path: &str,
+    options: IpcWriteOptions,
+) {
+    let filename = format!("{testdata}/arrow-ipc-stream/integration/{version}/{path}.stream");
+    println!("Verifying {filename}");
+
+    let mut tempfile = tempfile::tempfile().unwrap();
+
+    {
+        println!("  writing to tempfile {tempfile:?}");
+        let file = File::open(&filename).unwrap();
+        let mut reader = StreamReader::try_new(file, None).unwrap();
+
+        // read and rewrite the file to a temp location
+        {
+            let mut writer =
+                StreamWriter::try_new_with_options(&mut tempfile, &reader.schema(), options)
+                    .unwrap();
+            while let Some(Ok(batch)) = reader.next() {
+                writer.write(&batch).unwrap();
+            }
+            writer.finish().unwrap();
+        }
+    }
+
+    {
+        println!("  checking rewrite to with json");
+        tempfile.rewind().unwrap();
+        let mut reader = StreamReader::try_new(&tempfile, None).unwrap();
+
+        let arrow_json = read_gzip_json(version, path);
+        assert!(arrow_json.equals_reader(&mut reader).unwrap());
+    }
+
+    {
+        println!("  checking rewrite with original");
+        let file = File::open(&filename).unwrap();
+        let reader = StreamReader::try_new(file, None).unwrap();
+
+        tempfile.rewind().unwrap();
+        let rewrite_reader = StreamReader::try_new(&tempfile, None).unwrap();
+
+        // Compare to original reader
+        reader
+            .into_iter()
+            .zip(rewrite_reader)
+            .for_each(|(batch1, batch2)| {
+                assert_eq!(batch1.unwrap(), batch2.unwrap());
+            });
+    }
+}
diff --git a/arrow-ipc/CONTRIBUTING.md b/arrow-ipc/CONTRIBUTING.md
new file mode 100644
index 000000000000..5e14760f19df
--- /dev/null
+++ b/arrow-ipc/CONTRIBUTING.md
@@ -0,0 +1,37 @@
+<!---
+  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.
+-->
+
+## Developer's guide
+
+# IPC
+
+The expected flatc version is 1.12.0+, built from [flatbuffers](https://github.com/google/flatbuffers)
+master at fixed commit ID, by regen.sh.
+
+The IPC flatbuffer code was generated by running this command from the root of the project:
+
+```bash
+./regen.sh
+```
+
+The above script will run the `flatc` compiler and perform some adjustments to the source code:
+
+- Replace `type__` with `type_`
+- Remove `org::apache::arrow::flatbuffers` namespace
+- Add includes to each generated file
diff --git a/arrow-ipc/Cargo.toml b/arrow-ipc/Cargo.toml
new file mode 100644
index 000000000000..83ad044d25e7
--- /dev/null
+++ b/arrow-ipc/Cargo.toml
@@ -0,0 +1,51 @@
+# 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]
+name = "arrow-ipc"
+version = { workspace = true }
+description = "Support for the Arrow IPC format"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_ipc"
+path = "src/lib.rs"
+bench = false
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-cast = { workspace = true }
+arrow-data = { workspace = true }
+arrow-schema = { workspace = true }
+flatbuffers = { version = "23.1.21", default-features = false }
+lz4_flex = { version = "0.11", default-features = false, features = ["std", "frame"], optional = true }
+zstd = { version = "0.13.0", default-features = false, optional = true }
+
+[features]
+default = []
+lz4 = ["lz4_flex"]
+
+[dev-dependencies]
+tempfile = "3.3"
diff --git a/arrow/regen.sh b/arrow-ipc/regen.sh
similarity index 83%
rename from arrow/regen.sh
rename to arrow-ipc/regen.sh
index 9d384b6b63b6..8d8862ccc7f4 100755
--- a/arrow/regen.sh
+++ b/arrow-ipc/regen.sh
@@ -18,15 +18,13 @@
 
 DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" >/dev/null 2>&1 && pwd )"
 
-# Change to the toplevel Rust directory
-pushd $DIR/../../
+# Change to the toplevel `arrow-rs` directory
+pushd $DIR/../
 
 echo "Build flatc from source ..."
 
 FB_URL="https://github.com/google/flatbuffers"
-# https://github.com/google/flatbuffers/pull/6393
-FB_COMMIT="408cf5802415e1dea65fef7489a6c2f3740fb381"
-FB_DIR="rust/arrow/.flatbuffers"
+FB_DIR="arrow/.flatbuffers"
 FLATC="$FB_DIR/bazel-bin/flatc"
 
 if [ -z $(which bazel) ]; then
@@ -44,28 +42,21 @@ else
     git -C $FB_DIR pull
 fi
 
-echo "hard reset to $FB_COMMIT"
-git -C $FB_DIR reset --hard $FB_COMMIT
-
 pushd $FB_DIR
 echo "run: bazel build :flatc ..."
 bazel build :flatc
 popd
 
-FB_PATCH="rust/arrow/format-0ed34c83.patch"
-echo "Patch flatbuffer files with ${FB_PATCH} for cargo doc"
-echo "NOTE: the patch MAY need update in case of changes in format/*.fbs"
-git apply --check ${FB_PATCH} && git apply ${FB_PATCH}
 
 # Execute the code generation:
-$FLATC --filename-suffix "" --rust -o rust/arrow/src/ipc/gen/ format/*.fbs
+$FLATC --filename-suffix "" --rust -o arrow-ipc/src/gen/ format/*.fbs
 
 # Reset changes to format/
 git checkout -- format
 
 # Now the files are wrongly named so we have to change that.
 popd
-pushd $DIR/src/ipc/gen
+pushd $DIR/src/gen
 
 PREFIX=$(cat <<'HEREDOC'
 // Licensed to the Apache Software Foundation (ASF) under one
@@ -94,9 +85,9 @@ use flatbuffers::EndianScalar;
 HEREDOC
 )
 
-SCHEMA_IMPORT="\nuse crate::ipc::gen::Schema::*;"
-SPARSE_TENSOR_IMPORT="\nuse crate::ipc::gen::SparseTensor::*;"
-TENSOR_IMPORT="\nuse crate::ipc::gen::Tensor::*;"
+SCHEMA_IMPORT="\nuse crate::gen::Schema::*;"
+SPARSE_TENSOR_IMPORT="\nuse crate::gen::SparseTensor::*;"
+TENSOR_IMPORT="\nuse crate::gen::Tensor::*;"
 
 # For flatbuffer(1.12.0+), remove: use crate::${name}::\*;
 names=("File" "Message" "Schema" "SparseTensor" "Tensor")
@@ -119,8 +110,9 @@ for f in `ls *.rs`; do
     sed -i '' '/}  \/\/ pub mod arrow/d' $f
     sed -i '' '/}  \/\/ pub mod apache/d' $f
     sed -i '' '/}  \/\/ pub mod org/d' $f
-    sed -i '' '/use std::mem;/d' $f
-    sed -i '' '/use std::cmp::Ordering;/d' $f
+    sed -i '' '/use core::mem;/d' $f
+    sed -i '' '/use core::cmp::Ordering;/d' $f
+    sed -i '' '/use self::flatbuffers::{EndianScalar, Follow};/d' $f
 
     # required by flatc 1.12.0+
     sed -i '' "/\#\!\[allow(unused_imports, dead_code)\]/d" $f
@@ -150,7 +142,7 @@ done
 
 # Return back to base directory
 popd
-cargo +stable fmt -- src/ipc/gen/*
+cargo +stable fmt -- src/gen/*
 
 echo "DONE!"
 echo "Please run 'cargo doc' and 'cargo test' with nightly and stable, "
diff --git a/arrow-ipc/src/compression.rs b/arrow-ipc/src/compression.rs
new file mode 100644
index 000000000000..0d8b7b4c1bd4
--- /dev/null
+++ b/arrow-ipc/src/compression.rs
@@ -0,0 +1,249 @@
+// 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.
+
+use crate::CompressionType;
+use arrow_buffer::Buffer;
+use arrow_schema::ArrowError;
+
+const LENGTH_NO_COMPRESSED_DATA: i64 = -1;
+const LENGTH_OF_PREFIX_DATA: i64 = 8;
+
+/// Represents compressing a ipc stream using a particular compression algorithm
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CompressionCodec {
+    Lz4Frame,
+    Zstd,
+}
+
+impl TryFrom<CompressionType> for CompressionCodec {
+    type Error = ArrowError;
+
+    fn try_from(compression_type: CompressionType) -> Result<Self, ArrowError> {
+        match compression_type {
+            CompressionType::ZSTD => Ok(CompressionCodec::Zstd),
+            CompressionType::LZ4_FRAME => Ok(CompressionCodec::Lz4Frame),
+            other_type => Err(ArrowError::NotYetImplemented(format!(
+                "compression type {other_type:?} not supported "
+            ))),
+        }
+    }
+}
+
+impl CompressionCodec {
+    /// Compresses the data in `input` to `output` and appends the
+    /// data using the specified compression mechanism.
+    ///
+    /// returns the number of bytes written to the stream
+    ///
+    /// Writes this format to output:
+    /// ```text
+    /// [8 bytes]:         uncompressed length
+    /// [remaining bytes]: compressed data stream
+    /// ```
+    pub(crate) fn compress_to_vec(
+        &self,
+        input: &[u8],
+        output: &mut Vec<u8>,
+    ) -> Result<usize, ArrowError> {
+        let uncompressed_data_len = input.len();
+        let original_output_len = output.len();
+
+        if input.is_empty() {
+            // empty input, nothing to do
+        } else {
+            // write compressed data directly into the output buffer
+            output.extend_from_slice(&uncompressed_data_len.to_le_bytes());
+            self.compress(input, output)?;
+
+            let compression_len = output.len() - original_output_len;
+            if compression_len > uncompressed_data_len {
+                // length of compressed data was larger than
+                // uncompressed data, use the uncompressed data with
+                // length -1 to indicate that we don't compress the
+                // data
+                output.truncate(original_output_len);
+                output.extend_from_slice(&LENGTH_NO_COMPRESSED_DATA.to_le_bytes());
+                output.extend_from_slice(input);
+            }
+        }
+        Ok(output.len() - original_output_len)
+    }
+
+    /// Decompresses the input into a [`Buffer`]
+    ///
+    /// The input should look like:
+    /// ```text
+    /// [8 bytes]:         uncompressed length
+    /// [remaining bytes]: compressed data stream
+    /// ```
+    pub(crate) fn decompress_to_buffer(&self, input: &Buffer) -> Result<Buffer, ArrowError> {
+        // read the first 8 bytes to determine if the data is
+        // compressed
+        let decompressed_length = read_uncompressed_size(input);
+        let buffer = if decompressed_length == 0 {
+            // empty
+            Buffer::from([])
+        } else if decompressed_length == LENGTH_NO_COMPRESSED_DATA {
+            // no compression
+            input.slice(LENGTH_OF_PREFIX_DATA as usize)
+        } else if let Ok(decompressed_length) = usize::try_from(decompressed_length) {
+            // decompress data using the codec
+            let input_data = &input[(LENGTH_OF_PREFIX_DATA as usize)..];
+            self.decompress(input_data, decompressed_length as _)?
+                .into()
+        } else {
+            return Err(ArrowError::IpcError(format!(
+                "Invalid uncompressed length: {decompressed_length}"
+            )));
+        };
+        Ok(buffer)
+    }
+
+    /// Compress the data in input buffer and write to output buffer
+    /// using the specified compression
+    fn compress(&self, input: &[u8], output: &mut Vec<u8>) -> Result<(), ArrowError> {
+        match self {
+            CompressionCodec::Lz4Frame => compress_lz4(input, output),
+            CompressionCodec::Zstd => compress_zstd(input, output),
+        }
+    }
+
+    /// Decompress the data in input buffer and write to output buffer
+    /// using the specified compression
+    fn decompress(&self, input: &[u8], decompressed_size: usize) -> Result<Vec<u8>, ArrowError> {
+        let ret = match self {
+            CompressionCodec::Lz4Frame => decompress_lz4(input, decompressed_size)?,
+            CompressionCodec::Zstd => decompress_zstd(input, decompressed_size)?,
+        };
+        if ret.len() != decompressed_size {
+            return Err(ArrowError::IpcError(format!(
+                "Expected compressed length of {decompressed_size} got {}",
+                ret.len()
+            )));
+        }
+        Ok(ret)
+    }
+}
+
+#[cfg(feature = "lz4")]
+fn compress_lz4(input: &[u8], output: &mut Vec<u8>) -> Result<(), ArrowError> {
+    use std::io::Write;
+    let mut encoder = lz4_flex::frame::FrameEncoder::new(output);
+    encoder.write_all(input)?;
+    encoder
+        .finish()
+        .map_err(|e| ArrowError::ExternalError(Box::new(e)))?;
+    Ok(())
+}
+
+#[cfg(not(feature = "lz4"))]
+#[allow(clippy::ptr_arg)]
+fn compress_lz4(_input: &[u8], _output: &mut Vec<u8>) -> Result<(), ArrowError> {
+    Err(ArrowError::InvalidArgumentError(
+        "lz4 IPC compression requires the lz4 feature".to_string(),
+    ))
+}
+
+#[cfg(feature = "lz4")]
+fn decompress_lz4(input: &[u8], decompressed_size: usize) -> Result<Vec<u8>, ArrowError> {
+    use std::io::Read;
+    let mut output = Vec::with_capacity(decompressed_size);
+    lz4_flex::frame::FrameDecoder::new(input).read_to_end(&mut output)?;
+    Ok(output)
+}
+
+#[cfg(not(feature = "lz4"))]
+#[allow(clippy::ptr_arg)]
+fn decompress_lz4(_input: &[u8], _decompressed_size: usize) -> Result<Vec<u8>, ArrowError> {
+    Err(ArrowError::InvalidArgumentError(
+        "lz4 IPC decompression requires the lz4 feature".to_string(),
+    ))
+}
+
+#[cfg(feature = "zstd")]
+fn compress_zstd(input: &[u8], output: &mut Vec<u8>) -> Result<(), ArrowError> {
+    use std::io::Write;
+    let mut encoder = zstd::Encoder::new(output, 0)?;
+    encoder.write_all(input)?;
+    encoder.finish()?;
+    Ok(())
+}
+
+#[cfg(not(feature = "zstd"))]
+#[allow(clippy::ptr_arg)]
+fn compress_zstd(_input: &[u8], _output: &mut Vec<u8>) -> Result<(), ArrowError> {
+    Err(ArrowError::InvalidArgumentError(
+        "zstd IPC compression requires the zstd feature".to_string(),
+    ))
+}
+
+#[cfg(feature = "zstd")]
+fn decompress_zstd(input: &[u8], decompressed_size: usize) -> Result<Vec<u8>, ArrowError> {
+    use std::io::Read;
+    let mut output = Vec::with_capacity(decompressed_size);
+    zstd::Decoder::with_buffer(input)?.read_to_end(&mut output)?;
+    Ok(output)
+}
+
+#[cfg(not(feature = "zstd"))]
+#[allow(clippy::ptr_arg)]
+fn decompress_zstd(_input: &[u8], _decompressed_size: usize) -> Result<Vec<u8>, ArrowError> {
+    Err(ArrowError::InvalidArgumentError(
+        "zstd IPC decompression requires the zstd feature".to_string(),
+    ))
+}
+
+/// Get the uncompressed length
+/// Notes:
+///   LENGTH_NO_COMPRESSED_DATA: indicate that the data that follows is not compressed
+///    0: indicate that there is no data
+///   positive number: indicate the uncompressed length for the following data
+#[inline]
+fn read_uncompressed_size(buffer: &[u8]) -> i64 {
+    let len_buffer = &buffer[0..8];
+    // 64-bit little-endian signed integer
+    i64::from_le_bytes(len_buffer.try_into().unwrap())
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    #[cfg(feature = "lz4")]
+    fn test_lz4_compression() {
+        let input_bytes = b"hello lz4";
+        let codec = super::CompressionCodec::Lz4Frame;
+        let mut output_bytes: Vec<u8> = Vec::new();
+        codec.compress(input_bytes, &mut output_bytes).unwrap();
+        let result = codec
+            .decompress(output_bytes.as_slice(), input_bytes.len())
+            .unwrap();
+        assert_eq!(input_bytes, result.as_slice());
+    }
+
+    #[test]
+    #[cfg(feature = "zstd")]
+    fn test_zstd_compression() {
+        let input_bytes = b"hello zstd";
+        let codec = super::CompressionCodec::Zstd;
+        let mut output_bytes: Vec<u8> = Vec::new();
+        codec.compress(input_bytes, &mut output_bytes).unwrap();
+        let result = codec
+            .decompress(output_bytes.as_slice(), input_bytes.len())
+            .unwrap();
+        assert_eq!(input_bytes, result.as_slice());
+    }
+}
diff --git a/arrow/src/ipc/convert.rs b/arrow-ipc/src/convert.rs
similarity index 54%
rename from arrow/src/ipc/convert.rs
rename to arrow-ipc/src/convert.rs
index 705bd5cb3012..505541f7d50f 100644
--- a/arrow/src/ipc/convert.rs
+++ b/arrow-ipc/src/convert.rs
@@ -17,15 +17,12 @@
 
 //! Utilities for converting between IPC types and native Arrow types
 
-use crate::datatypes::{DataType, Field, IntervalUnit, Schema, TimeUnit, UnionMode};
-use crate::error::{ArrowError, Result};
-use crate::ipc;
-
-use flatbuffers::{
-    FlatBufferBuilder, ForwardsUOffset, UnionWIPOffset, Vector, WIPOffset,
-};
-use std::collections::{BTreeMap, HashMap};
+use arrow_schema::*;
+use flatbuffers::{FlatBufferBuilder, ForwardsUOffset, UnionWIPOffset, Vector, WIPOffset};
+use std::collections::HashMap;
+use std::sync::Arc;
 
+use crate::{size_prefixed_root_as_message, KeyValue, CONTINUATION_MARKER};
 use DataType::*;
 
 /// Serialize a schema in IPC format
@@ -39,39 +36,50 @@ pub fn schema_to_fb(schema: &Schema) -> FlatBufferBuilder {
     fbb
 }
 
-pub fn schema_to_fb_offset<'a>(
+pub fn metadata_to_fb<'a>(
     fbb: &mut FlatBufferBuilder<'a>,
-    schema: &Schema,
-) -> WIPOffset<ipc::Schema<'a>> {
-    let mut fields = vec![];
-    for field in schema.fields() {
-        let fb_field = build_field(fbb, field);
-        fields.push(fb_field);
-    }
-
-    let mut custom_metadata = vec![];
-    for (k, v) in schema.metadata() {
-        let fb_key_name = fbb.create_string(k.as_str());
-        let fb_val_name = fbb.create_string(v.as_str());
+    metadata: &HashMap<String, String>,
+) -> WIPOffset<Vector<'a, ForwardsUOffset<KeyValue<'a>>>> {
+    let custom_metadata = metadata
+        .iter()
+        .map(|(k, v)| {
+            let fb_key_name = fbb.create_string(k);
+            let fb_val_name = fbb.create_string(v);
 
-        let mut kv_builder = ipc::KeyValueBuilder::new(fbb);
-        kv_builder.add_key(fb_key_name);
-        kv_builder.add_value(fb_val_name);
-        custom_metadata.push(kv_builder.finish());
-    }
+            let mut kv_builder = crate::KeyValueBuilder::new(fbb);
+            kv_builder.add_key(fb_key_name);
+            kv_builder.add_value(fb_val_name);
+            kv_builder.finish()
+        })
+        .collect::<Vec<_>>();
+    fbb.create_vector(&custom_metadata)
+}
 
+pub fn schema_to_fb_offset<'a>(
+    fbb: &mut FlatBufferBuilder<'a>,
+    schema: &Schema,
+) -> WIPOffset<crate::Schema<'a>> {
+    let fields = schema
+        .fields()
+        .iter()
+        .map(|field| build_field(fbb, field))
+        .collect::<Vec<_>>();
     let fb_field_list = fbb.create_vector(&fields);
-    let fb_metadata_list = fbb.create_vector(&custom_metadata);
 
-    let mut builder = ipc::SchemaBuilder::new(fbb);
+    let fb_metadata_list =
+        (!schema.metadata().is_empty()).then(|| metadata_to_fb(fbb, schema.metadata()));
+
+    let mut builder = crate::SchemaBuilder::new(fbb);
     builder.add_fields(fb_field_list);
-    builder.add_custom_metadata(fb_metadata_list);
+    if let Some(fb_metadata_list) = fb_metadata_list {
+        builder.add_custom_metadata(fb_metadata_list);
+    }
     builder.finish()
 }
 
 /// Convert an IPC Field to Arrow Field
-impl<'a> From<ipc::Field<'a>> for Field {
-    fn from(field: ipc::Field) -> Field {
+impl<'a> From<crate::Field<'a>> for Field {
+    fn from(field: crate::Field) -> Field {
         let arrow_field = if let Some(dictionary) = field.dictionary() {
             Field::new_dict(
                 field.name().unwrap(),
@@ -88,30 +96,28 @@ impl<'a> From<ipc::Field<'a>> for Field {
             )
         };
 
-        let mut metadata = None;
+        let mut metadata_map = HashMap::default();
         if let Some(list) = field.custom_metadata() {
-            let mut metadata_map = BTreeMap::default();
             for kv in list {
                 if let (Some(k), Some(v)) = (kv.key(), kv.value()) {
                     metadata_map.insert(k.to_string(), v.to_string());
                 }
             }
-            metadata = Some(metadata_map);
         }
 
-        arrow_field.with_metadata(metadata)
+        arrow_field.with_metadata(metadata_map)
     }
 }
 
-/// Deserialize a Schema table from IPC format to Schema data type
-pub fn fb_to_schema(fb: ipc::Schema) -> Schema {
+/// Deserialize a Schema table from flat buffer format to Schema data type
+pub fn fb_to_schema(fb: crate::Schema) -> Schema {
     let mut fields: Vec<Field> = vec![];
     let c_fields = fb.fields().unwrap();
     let len = c_fields.len();
     for i in 0..len {
-        let c_field: ipc::Field = c_fields.get(i);
+        let c_field: crate::Field = c_fields.get(i);
         match c_field.type_type() {
-            ipc::Type::Decimal if fb.endianness() == ipc::Endianness::Big => {
+            crate::Type::Decimal if fb.endianness() == crate::Endianness::Big => {
                 unimplemented!("Big Endian is not supported for Decimal!")
             }
             _ => (),
@@ -136,25 +142,64 @@ pub fn fb_to_schema(fb: ipc::Schema) -> Schema {
     Schema::new_with_metadata(fields, metadata)
 }
 
-/// Deserialize an IPC message into a schema
-pub fn schema_from_bytes(bytes: &[u8]) -> Result<Schema> {
-    if let Ok(ipc) = ipc::root_as_message(bytes) {
+/// Try deserialize flat buffer format bytes into a schema
+pub fn try_schema_from_flatbuffer_bytes(bytes: &[u8]) -> Result<Schema, ArrowError> {
+    if let Ok(ipc) = crate::root_as_message(bytes) {
         if let Some(schema) = ipc.header_as_schema().map(fb_to_schema) {
             Ok(schema)
         } else {
-            Err(ArrowError::IoError(
+            Err(ArrowError::ParseError(
                 "Unable to get head as schema".to_string(),
             ))
         }
     } else {
-        Err(ArrowError::IoError(
+        Err(ArrowError::ParseError(
             "Unable to get root as message".to_string(),
         ))
     }
 }
 
+/// Try deserialize the IPC format bytes into a schema
+pub fn try_schema_from_ipc_buffer(buffer: &[u8]) -> Result<Schema, ArrowError> {
+    // There are two protocol types: https://issues.apache.org/jira/browse/ARROW-6313
+    // The original protocol is:
+    //   4 bytes - the byte length of the payload
+    //   a flatbuffer Message whose header is the Schema
+    // The latest version of protocol is:
+    // The schema of the dataset in its IPC form:
+    //   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+    //   4 bytes - the byte length of the payload
+    //   a flatbuffer Message whose header is the Schema
+    if buffer.len() >= 4 {
+        // check continuation maker
+        let continuation_maker = &buffer[0..4];
+        let begin_offset: usize = if continuation_maker.eq(&CONTINUATION_MARKER) {
+            // 4 bytes: CONTINUATION_MARKER
+            // 4 bytes: length
+            // buffer
+            4
+        } else {
+            // backward compatibility for buffer without the continuation maker
+            // 4 bytes: length
+            // buffer
+            0
+        };
+        let msg = size_prefixed_root_as_message(&buffer[begin_offset..]).map_err(|err| {
+            ArrowError::ParseError(format!("Unable to convert flight info to a message: {err}"))
+        })?;
+        let ipc_schema = msg.header_as_schema().ok_or_else(|| {
+            ArrowError::ParseError("Unable to convert flight info to a schema".to_string())
+        })?;
+        Ok(fb_to_schema(ipc_schema))
+    } else {
+        Err(ArrowError::ParseError(
+            "The buffer length is less than 4 and missing the continuation maker or length of buffer".to_string()
+        ))
+    }
+}
+
 /// Get the Arrow data type from the flatbuffer Field table
-pub(crate) fn get_data_type(field: ipc::Field, may_be_dictionary: bool) -> DataType {
+pub(crate) fn get_data_type(field: crate::Field, may_be_dictionary: bool) -> DataType {
     if let Some(dictionary) = field.dictionary() {
         if may_be_dictionary {
             let int = dictionary.indexType().unwrap();
@@ -177,9 +222,9 @@ pub(crate) fn get_data_type(field: ipc::Field, may_be_dictionary: bool) -> DataT
     }
 
     match field.type_type() {
-        ipc::Type::Null => DataType::Null,
-        ipc::Type::Bool => DataType::Boolean,
-        ipc::Type::Int => {
+        crate::Type::Null => DataType::Null,
+        crate::Type::Bool => DataType::Boolean,
+        crate::Type::Int => {
             let int = field.type_as_int().unwrap();
             match (int.bitWidth(), int.is_signed()) {
                 (8, true) => DataType::Int8,
@@ -196,196 +241,192 @@ pub(crate) fn get_data_type(field: ipc::Field, may_be_dictionary: bool) -> DataT
                 ),
             }
         }
-        ipc::Type::Binary => DataType::Binary,
-        ipc::Type::LargeBinary => DataType::LargeBinary,
-        ipc::Type::Utf8 => DataType::Utf8,
-        ipc::Type::LargeUtf8 => DataType::LargeUtf8,
-        ipc::Type::FixedSizeBinary => {
+        crate::Type::Binary => DataType::Binary,
+        crate::Type::LargeBinary => DataType::LargeBinary,
+        crate::Type::Utf8 => DataType::Utf8,
+        crate::Type::LargeUtf8 => DataType::LargeUtf8,
+        crate::Type::FixedSizeBinary => {
             let fsb = field.type_as_fixed_size_binary().unwrap();
             DataType::FixedSizeBinary(fsb.byteWidth())
         }
-        ipc::Type::FloatingPoint => {
+        crate::Type::FloatingPoint => {
             let float = field.type_as_floating_point().unwrap();
             match float.precision() {
-                ipc::Precision::HALF => DataType::Float16,
-                ipc::Precision::SINGLE => DataType::Float32,
-                ipc::Precision::DOUBLE => DataType::Float64,
-                z => panic!("FloatingPoint type with precision of {:?} not supported", z),
+                crate::Precision::HALF => DataType::Float16,
+                crate::Precision::SINGLE => DataType::Float32,
+                crate::Precision::DOUBLE => DataType::Float64,
+                z => panic!("FloatingPoint type with precision of {z:?} not supported"),
             }
         }
-        ipc::Type::Date => {
+        crate::Type::Date => {
             let date = field.type_as_date().unwrap();
             match date.unit() {
-                ipc::DateUnit::DAY => DataType::Date32,
-                ipc::DateUnit::MILLISECOND => DataType::Date64,
-                z => panic!("Date type with unit of {:?} not supported", z),
+                crate::DateUnit::DAY => DataType::Date32,
+                crate::DateUnit::MILLISECOND => DataType::Date64,
+                z => panic!("Date type with unit of {z:?} not supported"),
             }
         }
-        ipc::Type::Time => {
+        crate::Type::Time => {
             let time = field.type_as_time().unwrap();
             match (time.bitWidth(), time.unit()) {
-                (32, ipc::TimeUnit::SECOND) => DataType::Time32(TimeUnit::Second),
-                (32, ipc::TimeUnit::MILLISECOND) => {
-                    DataType::Time32(TimeUnit::Millisecond)
-                }
-                (64, ipc::TimeUnit::MICROSECOND) => {
-                    DataType::Time64(TimeUnit::Microsecond)
-                }
-                (64, ipc::TimeUnit::NANOSECOND) => DataType::Time64(TimeUnit::Nanosecond),
+                (32, crate::TimeUnit::SECOND) => DataType::Time32(TimeUnit::Second),
+                (32, crate::TimeUnit::MILLISECOND) => DataType::Time32(TimeUnit::Millisecond),
+                (64, crate::TimeUnit::MICROSECOND) => DataType::Time64(TimeUnit::Microsecond),
+                (64, crate::TimeUnit::NANOSECOND) => DataType::Time64(TimeUnit::Nanosecond),
                 z => panic!(
                     "Time type with bit width of {} and unit of {:?} not supported",
                     z.0, z.1
                 ),
             }
         }
-        ipc::Type::Timestamp => {
+        crate::Type::Timestamp => {
             let timestamp = field.type_as_timestamp().unwrap();
-            let timezone: Option<String> = timestamp.timezone().map(|tz| tz.to_string());
+            let timezone: Option<_> = timestamp.timezone().map(|tz| tz.into());
             match timestamp.unit() {
-                ipc::TimeUnit::SECOND => DataType::Timestamp(TimeUnit::Second, timezone),
-                ipc::TimeUnit::MILLISECOND => {
+                crate::TimeUnit::SECOND => DataType::Timestamp(TimeUnit::Second, timezone),
+                crate::TimeUnit::MILLISECOND => {
                     DataType::Timestamp(TimeUnit::Millisecond, timezone)
                 }
-                ipc::TimeUnit::MICROSECOND => {
+                crate::TimeUnit::MICROSECOND => {
                     DataType::Timestamp(TimeUnit::Microsecond, timezone)
                 }
-                ipc::TimeUnit::NANOSECOND => {
-                    DataType::Timestamp(TimeUnit::Nanosecond, timezone)
-                }
-                z => panic!("Timestamp type with unit of {:?} not supported", z),
+                crate::TimeUnit::NANOSECOND => DataType::Timestamp(TimeUnit::Nanosecond, timezone),
+                z => panic!("Timestamp type with unit of {z:?} not supported"),
             }
         }
-        ipc::Type::Interval => {
+        crate::Type::Interval => {
             let interval = field.type_as_interval().unwrap();
             match interval.unit() {
-                ipc::IntervalUnit::YEAR_MONTH => {
-                    DataType::Interval(IntervalUnit::YearMonth)
-                }
-                ipc::IntervalUnit::DAY_TIME => DataType::Interval(IntervalUnit::DayTime),
-                ipc::IntervalUnit::MONTH_DAY_NANO => {
+                crate::IntervalUnit::YEAR_MONTH => DataType::Interval(IntervalUnit::YearMonth),
+                crate::IntervalUnit::DAY_TIME => DataType::Interval(IntervalUnit::DayTime),
+                crate::IntervalUnit::MONTH_DAY_NANO => {
                     DataType::Interval(IntervalUnit::MonthDayNano)
                 }
-                z => panic!("Interval type with unit of {:?} unsupported", z),
+                z => panic!("Interval type with unit of {z:?} unsupported"),
             }
         }
-        ipc::Type::Duration => {
+        crate::Type::Duration => {
             let duration = field.type_as_duration().unwrap();
             match duration.unit() {
-                ipc::TimeUnit::SECOND => DataType::Duration(TimeUnit::Second),
-                ipc::TimeUnit::MILLISECOND => DataType::Duration(TimeUnit::Millisecond),
-                ipc::TimeUnit::MICROSECOND => DataType::Duration(TimeUnit::Microsecond),
-                ipc::TimeUnit::NANOSECOND => DataType::Duration(TimeUnit::Nanosecond),
-                z => panic!("Duration type with unit of {:?} unsupported", z),
+                crate::TimeUnit::SECOND => DataType::Duration(TimeUnit::Second),
+                crate::TimeUnit::MILLISECOND => DataType::Duration(TimeUnit::Millisecond),
+                crate::TimeUnit::MICROSECOND => DataType::Duration(TimeUnit::Microsecond),
+                crate::TimeUnit::NANOSECOND => DataType::Duration(TimeUnit::Nanosecond),
+                z => panic!("Duration type with unit of {z:?} unsupported"),
             }
         }
-        ipc::Type::List => {
+        crate::Type::List => {
             let children = field.children().unwrap();
             if children.len() != 1 {
                 panic!("expect a list to have one child")
             }
-            DataType::List(Box::new(children.get(0).into()))
+            DataType::List(Arc::new(children.get(0).into()))
         }
-        ipc::Type::LargeList => {
+        crate::Type::LargeList => {
             let children = field.children().unwrap();
             if children.len() != 1 {
                 panic!("expect a large list to have one child")
             }
-            DataType::LargeList(Box::new(children.get(0).into()))
+            DataType::LargeList(Arc::new(children.get(0).into()))
         }
-        ipc::Type::FixedSizeList => {
+        crate::Type::FixedSizeList => {
             let children = field.children().unwrap();
             if children.len() != 1 {
                 panic!("expect a list to have one child")
             }
             let fsl = field.type_as_fixed_size_list().unwrap();
-            DataType::FixedSizeList(Box::new(children.get(0).into()), fsl.listSize())
+            DataType::FixedSizeList(Arc::new(children.get(0).into()), fsl.listSize())
         }
-        ipc::Type::Struct_ => {
-            let mut fields = vec![];
-            if let Some(children) = field.children() {
-                for i in 0..children.len() {
-                    fields.push(children.get(i).into());
-                }
+        crate::Type::Struct_ => {
+            let fields = match field.children() {
+                Some(children) => children.iter().map(Field::from).collect(),
+                None => Fields::empty(),
             };
-
             DataType::Struct(fields)
         }
-        ipc::Type::Map => {
+        crate::Type::RunEndEncoded => {
+            let children = field.children().unwrap();
+            if children.len() != 2 {
+                panic!(
+                    "RunEndEncoded type should have exactly two children. Found {}",
+                    children.len()
+                )
+            }
+            let run_ends_field = children.get(0).into();
+            let values_field = children.get(1).into();
+            DataType::RunEndEncoded(Arc::new(run_ends_field), Arc::new(values_field))
+        }
+        crate::Type::Map => {
             let map = field.type_as_map().unwrap();
             let children = field.children().unwrap();
             if children.len() != 1 {
                 panic!("expect a map to have one child")
             }
-            DataType::Map(Box::new(children.get(0).into()), map.keysSorted())
+            DataType::Map(Arc::new(children.get(0).into()), map.keysSorted())
         }
-        ipc::Type::Decimal => {
+        crate::Type::Decimal => {
             let fsb = field.type_as_decimal().unwrap();
             let bit_width = fsb.bitWidth();
             if bit_width == 128 {
-                DataType::Decimal128(fsb.precision() as usize, fsb.scale() as usize)
+                DataType::Decimal128(
+                    fsb.precision().try_into().unwrap(),
+                    fsb.scale().try_into().unwrap(),
+                )
             } else if bit_width == 256 {
-                DataType::Decimal256(fsb.precision() as usize, fsb.scale() as usize)
+                DataType::Decimal256(
+                    fsb.precision().try_into().unwrap(),
+                    fsb.scale().try_into().unwrap(),
+                )
             } else {
-                panic!("Unexpected decimal bit width {}", bit_width)
+                panic!("Unexpected decimal bit width {bit_width}")
             }
         }
-        ipc::Type::Union => {
+        crate::Type::Union => {
             let union = field.type_as_union().unwrap();
 
             let union_mode = match union.mode() {
-                ipc::UnionMode::Dense => UnionMode::Dense,
-                ipc::UnionMode::Sparse => UnionMode::Sparse,
-                mode => panic!("Unexpected union mode: {:?}", mode),
+                crate::UnionMode::Dense => UnionMode::Dense,
+                crate::UnionMode::Sparse => UnionMode::Sparse,
+                mode => panic!("Unexpected union mode: {mode:?}"),
             };
 
             let mut fields = vec![];
             if let Some(children) = field.children() {
                 for i in 0..children.len() {
-                    fields.push(children.get(i).into());
+                    fields.push(Field::from(children.get(i)));
                 }
             };
 
-            let type_ids: Vec<i8> = match union.typeIds() {
-                None => (0_i8..fields.len() as i8).collect(),
-                Some(ids) => ids.iter().map(|i| i as i8).collect(),
+            let fields = match union.typeIds() {
+                None => UnionFields::new(0_i8..fields.len() as i8, fields),
+                Some(ids) => UnionFields::new(ids.iter().map(|i| i as i8), fields),
             };
 
-            DataType::Union(fields, type_ids, union_mode)
+            DataType::Union(fields, union_mode)
         }
         t => unimplemented!("Type {:?} not supported", t),
     }
 }
 
 pub(crate) struct FBFieldType<'b> {
-    pub(crate) type_type: ipc::Type,
+    pub(crate) type_type: crate::Type,
     pub(crate) type_: WIPOffset<UnionWIPOffset>,
-    pub(crate) children: Option<WIPOffset<Vector<'b, ForwardsUOffset<ipc::Field<'b>>>>>,
+    pub(crate) children: Option<WIPOffset<Vector<'b, ForwardsUOffset<crate::Field<'b>>>>>,
 }
 
 /// Create an IPC Field from an Arrow Field
 pub(crate) fn build_field<'a>(
     fbb: &mut FlatBufferBuilder<'a>,
     field: &Field,
-) -> WIPOffset<ipc::Field<'a>> {
+) -> WIPOffset<crate::Field<'a>> {
     // Optional custom metadata.
     let mut fb_metadata = None;
-    if let Some(metadata) = field.metadata() {
-        if !metadata.is_empty() {
-            let mut kv_vec = vec![];
-            for (k, v) in metadata {
-                let kv_args = ipc::KeyValueArgs {
-                    key: Some(fbb.create_string(k.as_str())),
-                    value: Some(fbb.create_string(v.as_str())),
-                };
-                let kv_offset = ipc::KeyValue::create(fbb, &kv_args);
-                kv_vec.push(kv_offset);
-            }
-            fb_metadata = Some(fbb.create_vector(&kv_vec));
-        }
+    if !field.metadata().is_empty() {
+        fb_metadata = Some(metadata_to_fb(fbb, field.metadata()));
     };
 
     let fb_field_name = fbb.create_string(field.name().as_str());
-    let field_type = get_fb_field_type(field.data_type(), field.is_nullable(), fbb);
+    let field_type = get_fb_field_type(field.data_type(), fbb);
 
     let fb_dictionary = if let Dictionary(index_type, _) = field.data_type() {
         Some(get_fb_dictionary(
@@ -402,7 +443,7 @@ pub(crate) fn build_field<'a>(
         None
     };
 
-    let mut field_builder = ipc::FieldBuilder::new(fbb);
+    let mut field_builder = crate::FieldBuilder::new(fbb);
     field_builder.add_name(fb_field_name);
     if let Some(dictionary) = fb_dictionary {
         field_builder.add_dictionary(dictionary)
@@ -425,26 +466,25 @@ pub(crate) fn build_field<'a>(
 /// Get the IPC type of a data type
 pub(crate) fn get_fb_field_type<'a>(
     data_type: &DataType,
-    is_nullable: bool,
     fbb: &mut FlatBufferBuilder<'a>,
 ) -> FBFieldType<'a> {
     // some IPC implementations expect an empty list for child data, instead of a null value.
     // An empty field list is thus returned for primitive types
-    let empty_fields: Vec<WIPOffset<ipc::Field>> = vec![];
+    let empty_fields: Vec<WIPOffset<crate::Field>> = vec![];
     match data_type {
         Null => FBFieldType {
-            type_type: ipc::Type::Null,
-            type_: ipc::NullBuilder::new(fbb).finish().as_union_value(),
+            type_type: crate::Type::Null,
+            type_: crate::NullBuilder::new(fbb).finish().as_union_value(),
             children: Some(fbb.create_vector(&empty_fields[..])),
         },
         Boolean => FBFieldType {
-            type_type: ipc::Type::Bool,
-            type_: ipc::BoolBuilder::new(fbb).finish().as_union_value(),
+            type_type: crate::Type::Bool,
+            type_: crate::BoolBuilder::new(fbb).finish().as_union_value(),
             children: Some(fbb.create_vector(&empty_fields[..])),
         },
         UInt8 | UInt16 | UInt32 | UInt64 => {
             let children = fbb.create_vector(&empty_fields[..]);
-            let mut builder = ipc::IntBuilder::new(fbb);
+            let mut builder = crate::IntBuilder::new(fbb);
             builder.add_is_signed(false);
             match data_type {
                 UInt8 => builder.add_bitWidth(8),
@@ -454,14 +494,14 @@ pub(crate) fn get_fb_field_type<'a>(
                 _ => {}
             };
             FBFieldType {
-                type_type: ipc::Type::Int,
+                type_type: crate::Type::Int,
                 type_: builder.finish().as_union_value(),
                 children: Some(children),
             }
         }
         Int8 | Int16 | Int32 | Int64 => {
             let children = fbb.create_vector(&empty_fields[..]);
-            let mut builder = ipc::IntBuilder::new(fbb);
+            let mut builder = crate::IntBuilder::new(fbb);
             builder.add_is_signed(true);
             match data_type {
                 Int8 => builder.add_bitWidth(8),
@@ -471,144 +511,146 @@ pub(crate) fn get_fb_field_type<'a>(
                 _ => {}
             };
             FBFieldType {
-                type_type: ipc::Type::Int,
+                type_type: crate::Type::Int,
                 type_: builder.finish().as_union_value(),
                 children: Some(children),
             }
         }
         Float16 | Float32 | Float64 => {
             let children = fbb.create_vector(&empty_fields[..]);
-            let mut builder = ipc::FloatingPointBuilder::new(fbb);
+            let mut builder = crate::FloatingPointBuilder::new(fbb);
             match data_type {
-                Float16 => builder.add_precision(ipc::Precision::HALF),
-                Float32 => builder.add_precision(ipc::Precision::SINGLE),
-                Float64 => builder.add_precision(ipc::Precision::DOUBLE),
+                Float16 => builder.add_precision(crate::Precision::HALF),
+                Float32 => builder.add_precision(crate::Precision::SINGLE),
+                Float64 => builder.add_precision(crate::Precision::DOUBLE),
                 _ => {}
             };
             FBFieldType {
-                type_type: ipc::Type::FloatingPoint,
+                type_type: crate::Type::FloatingPoint,
                 type_: builder.finish().as_union_value(),
                 children: Some(children),
             }
         }
         Binary => FBFieldType {
-            type_type: ipc::Type::Binary,
-            type_: ipc::BinaryBuilder::new(fbb).finish().as_union_value(),
+            type_type: crate::Type::Binary,
+            type_: crate::BinaryBuilder::new(fbb).finish().as_union_value(),
             children: Some(fbb.create_vector(&empty_fields[..])),
         },
         LargeBinary => FBFieldType {
-            type_type: ipc::Type::LargeBinary,
-            type_: ipc::LargeBinaryBuilder::new(fbb).finish().as_union_value(),
+            type_type: crate::Type::LargeBinary,
+            type_: crate::LargeBinaryBuilder::new(fbb)
+                .finish()
+                .as_union_value(),
             children: Some(fbb.create_vector(&empty_fields[..])),
         },
         Utf8 => FBFieldType {
-            type_type: ipc::Type::Utf8,
-            type_: ipc::Utf8Builder::new(fbb).finish().as_union_value(),
+            type_type: crate::Type::Utf8,
+            type_: crate::Utf8Builder::new(fbb).finish().as_union_value(),
             children: Some(fbb.create_vector(&empty_fields[..])),
         },
         LargeUtf8 => FBFieldType {
-            type_type: ipc::Type::LargeUtf8,
-            type_: ipc::LargeUtf8Builder::new(fbb).finish().as_union_value(),
+            type_type: crate::Type::LargeUtf8,
+            type_: crate::LargeUtf8Builder::new(fbb).finish().as_union_value(),
             children: Some(fbb.create_vector(&empty_fields[..])),
         },
         FixedSizeBinary(len) => {
-            let mut builder = ipc::FixedSizeBinaryBuilder::new(fbb);
-            builder.add_byteWidth(*len as i32);
+            let mut builder = crate::FixedSizeBinaryBuilder::new(fbb);
+            builder.add_byteWidth(*len);
             FBFieldType {
-                type_type: ipc::Type::FixedSizeBinary,
+                type_type: crate::Type::FixedSizeBinary,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&empty_fields[..])),
             }
         }
         Date32 => {
-            let mut builder = ipc::DateBuilder::new(fbb);
-            builder.add_unit(ipc::DateUnit::DAY);
+            let mut builder = crate::DateBuilder::new(fbb);
+            builder.add_unit(crate::DateUnit::DAY);
             FBFieldType {
-                type_type: ipc::Type::Date,
+                type_type: crate::Type::Date,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&empty_fields[..])),
             }
         }
         Date64 => {
-            let mut builder = ipc::DateBuilder::new(fbb);
-            builder.add_unit(ipc::DateUnit::MILLISECOND);
+            let mut builder = crate::DateBuilder::new(fbb);
+            builder.add_unit(crate::DateUnit::MILLISECOND);
             FBFieldType {
-                type_type: ipc::Type::Date,
+                type_type: crate::Type::Date,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&empty_fields[..])),
             }
         }
         Time32(unit) | Time64(unit) => {
-            let mut builder = ipc::TimeBuilder::new(fbb);
+            let mut builder = crate::TimeBuilder::new(fbb);
             match unit {
                 TimeUnit::Second => {
                     builder.add_bitWidth(32);
-                    builder.add_unit(ipc::TimeUnit::SECOND);
+                    builder.add_unit(crate::TimeUnit::SECOND);
                 }
                 TimeUnit::Millisecond => {
                     builder.add_bitWidth(32);
-                    builder.add_unit(ipc::TimeUnit::MILLISECOND);
+                    builder.add_unit(crate::TimeUnit::MILLISECOND);
                 }
                 TimeUnit::Microsecond => {
                     builder.add_bitWidth(64);
-                    builder.add_unit(ipc::TimeUnit::MICROSECOND);
+                    builder.add_unit(crate::TimeUnit::MICROSECOND);
                 }
                 TimeUnit::Nanosecond => {
                     builder.add_bitWidth(64);
-                    builder.add_unit(ipc::TimeUnit::NANOSECOND);
+                    builder.add_unit(crate::TimeUnit::NANOSECOND);
                 }
             }
             FBFieldType {
-                type_type: ipc::Type::Time,
+                type_type: crate::Type::Time,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&empty_fields[..])),
             }
         }
         Timestamp(unit, tz) => {
-            let tz = tz.clone().unwrap_or_default();
-            let tz_str = fbb.create_string(tz.as_str());
-            let mut builder = ipc::TimestampBuilder::new(fbb);
+            let tz = tz.as_deref().unwrap_or_default();
+            let tz_str = fbb.create_string(tz);
+            let mut builder = crate::TimestampBuilder::new(fbb);
             let time_unit = match unit {
-                TimeUnit::Second => ipc::TimeUnit::SECOND,
-                TimeUnit::Millisecond => ipc::TimeUnit::MILLISECOND,
-                TimeUnit::Microsecond => ipc::TimeUnit::MICROSECOND,
-                TimeUnit::Nanosecond => ipc::TimeUnit::NANOSECOND,
+                TimeUnit::Second => crate::TimeUnit::SECOND,
+                TimeUnit::Millisecond => crate::TimeUnit::MILLISECOND,
+                TimeUnit::Microsecond => crate::TimeUnit::MICROSECOND,
+                TimeUnit::Nanosecond => crate::TimeUnit::NANOSECOND,
             };
             builder.add_unit(time_unit);
             if !tz.is_empty() {
                 builder.add_timezone(tz_str);
             }
             FBFieldType {
-                type_type: ipc::Type::Timestamp,
+                type_type: crate::Type::Timestamp,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&empty_fields[..])),
             }
         }
         Interval(unit) => {
-            let mut builder = ipc::IntervalBuilder::new(fbb);
+            let mut builder = crate::IntervalBuilder::new(fbb);
             let interval_unit = match unit {
-                IntervalUnit::YearMonth => ipc::IntervalUnit::YEAR_MONTH,
-                IntervalUnit::DayTime => ipc::IntervalUnit::DAY_TIME,
-                IntervalUnit::MonthDayNano => ipc::IntervalUnit::MONTH_DAY_NANO,
+                IntervalUnit::YearMonth => crate::IntervalUnit::YEAR_MONTH,
+                IntervalUnit::DayTime => crate::IntervalUnit::DAY_TIME,
+                IntervalUnit::MonthDayNano => crate::IntervalUnit::MONTH_DAY_NANO,
             };
             builder.add_unit(interval_unit);
             FBFieldType {
-                type_type: ipc::Type::Interval,
+                type_type: crate::Type::Interval,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&empty_fields[..])),
             }
         }
         Duration(unit) => {
-            let mut builder = ipc::DurationBuilder::new(fbb);
+            let mut builder = crate::DurationBuilder::new(fbb);
             let time_unit = match unit {
-                TimeUnit::Second => ipc::TimeUnit::SECOND,
-                TimeUnit::Millisecond => ipc::TimeUnit::MILLISECOND,
-                TimeUnit::Microsecond => ipc::TimeUnit::MICROSECOND,
-                TimeUnit::Nanosecond => ipc::TimeUnit::NANOSECOND,
+                TimeUnit::Second => crate::TimeUnit::SECOND,
+                TimeUnit::Millisecond => crate::TimeUnit::MILLISECOND,
+                TimeUnit::Microsecond => crate::TimeUnit::MICROSECOND,
+                TimeUnit::Nanosecond => crate::TimeUnit::NANOSECOND,
             };
             builder.add_unit(time_unit);
             FBFieldType {
-                type_type: ipc::Type::Duration,
+                type_type: crate::Type::Duration,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&empty_fields[..])),
             }
@@ -616,25 +658,25 @@ pub(crate) fn get_fb_field_type<'a>(
         List(ref list_type) => {
             let child = build_field(fbb, list_type);
             FBFieldType {
-                type_type: ipc::Type::List,
-                type_: ipc::ListBuilder::new(fbb).finish().as_union_value(),
+                type_type: crate::Type::List,
+                type_: crate::ListBuilder::new(fbb).finish().as_union_value(),
                 children: Some(fbb.create_vector(&[child])),
             }
         }
         LargeList(ref list_type) => {
             let child = build_field(fbb, list_type);
             FBFieldType {
-                type_type: ipc::Type::LargeList,
-                type_: ipc::LargeListBuilder::new(fbb).finish().as_union_value(),
+                type_type: crate::Type::LargeList,
+                type_: crate::LargeListBuilder::new(fbb).finish().as_union_value(),
                 children: Some(fbb.create_vector(&[child])),
             }
         }
         FixedSizeList(ref list_type, len) => {
             let child = build_field(fbb, list_type);
-            let mut builder = ipc::FixedSizeListBuilder::new(fbb);
-            builder.add_listSize(*len as i32);
+            let mut builder = crate::FixedSizeListBuilder::new(fbb);
+            builder.add_listSize(*len);
             FBFieldType {
-                type_type: ipc::Type::FixedSizeList,
+                type_type: crate::Type::FixedSizeList,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&[child])),
             }
@@ -646,17 +688,29 @@ pub(crate) fn get_fb_field_type<'a>(
                 children.push(build_field(fbb, field));
             }
             FBFieldType {
-                type_type: ipc::Type::Struct_,
-                type_: ipc::Struct_Builder::new(fbb).finish().as_union_value(),
+                type_type: crate::Type::Struct_,
+                type_: crate::Struct_Builder::new(fbb).finish().as_union_value(),
+                children: Some(fbb.create_vector(&children[..])),
+            }
+        }
+        RunEndEncoded(run_ends, values) => {
+            let run_ends_field = build_field(fbb, run_ends);
+            let values_field = build_field(fbb, values);
+            let children = [run_ends_field, values_field];
+            FBFieldType {
+                type_type: crate::Type::RunEndEncoded,
+                type_: crate::RunEndEncodedBuilder::new(fbb)
+                    .finish()
+                    .as_union_value(),
                 children: Some(fbb.create_vector(&children[..])),
             }
         }
         Map(map_field, keys_sorted) => {
             let child = build_field(fbb, map_field);
-            let mut field_type = ipc::MapBuilder::new(fbb);
+            let mut field_type = crate::MapBuilder::new(fbb);
             field_type.add_keysSorted(*keys_sorted);
             FBFieldType {
-                type_type: ipc::Type::Map,
+                type_type: crate::Type::Map,
                 type_: field_type.finish().as_union_value(),
                 children: Some(fbb.create_vector(&[child])),
             }
@@ -665,49 +719,49 @@ pub(crate) fn get_fb_field_type<'a>(
             // In this library, the dictionary "type" is a logical construct. Here we
             // pass through to the value type, as we've already captured the index
             // type in the DictionaryEncoding metadata in the parent field
-            get_fb_field_type(value_type, is_nullable, fbb)
+            get_fb_field_type(value_type, fbb)
         }
         Decimal128(precision, scale) => {
-            let mut builder = ipc::DecimalBuilder::new(fbb);
+            let mut builder = crate::DecimalBuilder::new(fbb);
             builder.add_precision(*precision as i32);
             builder.add_scale(*scale as i32);
             builder.add_bitWidth(128);
             FBFieldType {
-                type_type: ipc::Type::Decimal,
+                type_type: crate::Type::Decimal,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&empty_fields[..])),
             }
         }
         Decimal256(precision, scale) => {
-            let mut builder = ipc::DecimalBuilder::new(fbb);
+            let mut builder = crate::DecimalBuilder::new(fbb);
             builder.add_precision(*precision as i32);
             builder.add_scale(*scale as i32);
             builder.add_bitWidth(256);
             FBFieldType {
-                type_type: ipc::Type::Decimal,
+                type_type: crate::Type::Decimal,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&empty_fields[..])),
             }
         }
-        Union(fields, type_ids, mode) => {
+        Union(fields, mode) => {
             let mut children = vec![];
-            for field in fields {
+            for (_, field) in fields.iter() {
                 children.push(build_field(fbb, field));
             }
 
             let union_mode = match mode {
-                UnionMode::Sparse => ipc::UnionMode::Sparse,
-                UnionMode::Dense => ipc::UnionMode::Dense,
+                UnionMode::Sparse => crate::UnionMode::Sparse,
+                UnionMode::Dense => crate::UnionMode::Dense,
             };
 
-            let fbb_type_ids = fbb
-                .create_vector(&type_ids.iter().map(|t| *t as i32).collect::<Vec<_>>());
-            let mut builder = ipc::UnionBuilder::new(fbb);
+            let fbb_type_ids =
+                fbb.create_vector(&fields.iter().map(|(t, _)| t as i32).collect::<Vec<_>>());
+            let mut builder = crate::UnionBuilder::new(fbb);
             builder.add_mode(union_mode);
             builder.add_typeIds(fbb_type_ids);
 
             FBFieldType {
-                type_type: ipc::Type::Union,
+                type_type: crate::Type::Union,
                 type_: builder.finish().as_union_value(),
                 children: Some(fbb.create_vector(&children[..])),
             }
@@ -721,10 +775,10 @@ pub(crate) fn get_fb_dictionary<'a>(
     dict_id: i64,
     dict_is_ordered: bool,
     fbb: &mut FlatBufferBuilder<'a>,
-) -> WIPOffset<ipc::DictionaryEncoding<'a>> {
+) -> WIPOffset<crate::DictionaryEncoding<'a>> {
     // We assume that the dictionary index type (as an integer) has already been
     // validated elsewhere, and can safely assume we are dealing with integers
-    let mut index_builder = ipc::IntBuilder::new(fbb);
+    let mut index_builder = crate::IntBuilder::new(fbb);
 
     match *index_type {
         Int8 | Int16 | Int32 | Int64 => index_builder.add_is_signed(true),
@@ -742,7 +796,7 @@ pub(crate) fn get_fb_dictionary<'a>(
 
     let index_builder = index_builder.finish();
 
-    let mut builder = ipc::DictionaryEncodingBuilder::new(fbb);
+    let mut builder = crate::DictionaryEncodingBuilder::new(fbb);
     builder.add_id(dict_id);
     builder.add_indexType(index_builder);
     builder.add_isOrdered(dict_is_ordered);
@@ -753,7 +807,6 @@ pub(crate) fn get_fb_dictionary<'a>(
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::datatypes::{DataType, Field, Schema, UnionMode};
 
     #[test]
     fn convert_schema_round_trip() {
@@ -761,13 +814,13 @@ mod tests {
             .iter()
             .cloned()
             .collect();
-        let field_md: BTreeMap<String, String> = [("k".to_string(), "v".to_string())]
+        let field_md: HashMap<String, String> = [("k".to_string(), "v".to_string())]
             .iter()
             .cloned()
             .collect();
         let schema = Schema::new_with_metadata(
             vec![
-                Field::new("uint8", DataType::UInt8, false).with_metadata(Some(field_md)),
+                Field::new("uint8", DataType::UInt8, false).with_metadata(field_md),
                 Field::new("uint16", DataType::UInt16, true),
                 Field::new("uint32", DataType::UInt32, false),
                 Field::new("uint64", DataType::UInt64, true),
@@ -798,10 +851,7 @@ mod tests {
                 ),
                 Field::new(
                     "timestamp[us]",
-                    DataType::Timestamp(
-                        TimeUnit::Microsecond,
-                        Some("Africa/Johannesburg".to_string()),
-                    ),
+                    DataType::Timestamp(TimeUnit::Microsecond, Some("Africa/Johannesburg".into())),
                     false,
                 ),
                 Field::new(
@@ -826,141 +876,129 @@ mod tests {
                 ),
                 Field::new("utf8", DataType::Utf8, false),
                 Field::new("binary", DataType::Binary, false),
-                Field::new(
-                    "list[u8]",
-                    DataType::List(Box::new(Field::new("item", DataType::UInt8, false))),
+                Field::new_list("list[u8]", Field::new("item", DataType::UInt8, false), true),
+                Field::new_fixed_size_list(
+                    "fixed_size_list[u8]",
+                    Field::new("item", DataType::UInt8, false),
+                    2,
                     true,
                 ),
-                Field::new(
+                Field::new_list(
                     "list[struct<float32, int32, bool>]",
-                    DataType::List(Box::new(Field::new(
+                    Field::new_struct(
                         "struct",
-                        DataType::Struct(vec![
-                            Field::new("float32", DataType::UInt8, false),
-                            Field::new("int32", DataType::Int32, true),
-                            Field::new("bool", DataType::Boolean, true),
-                        ]),
+                        vec![
+                            Field::new("float32", UInt8, false),
+                            Field::new("int32", Int32, true),
+                            Field::new("bool", Boolean, true),
+                        ],
                         true,
-                    ))),
+                    ),
                     false,
                 ),
-                Field::new(
+                Field::new_struct(
                     "struct<dictionary<int32, utf8>>",
-                    DataType::Struct(vec![Field::new(
+                    vec![Field::new(
                         "dictionary<int32, utf8>",
-                        DataType::Dictionary(
-                            Box::new(DataType::Int32),
-                            Box::new(DataType::Utf8),
-                        ),
+                        Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
                         false,
-                    )]),
+                    )],
                     false,
                 ),
-                Field::new(
+                Field::new_struct(
                     "struct<int64, list[struct<date32, list[struct<>]>]>",
-                    DataType::Struct(vec![
+                    vec![
                         Field::new("int64", DataType::Int64, true),
-                        Field::new(
+                        Field::new_list(
                             "list[struct<date32, list[struct<>]>]",
-                            DataType::List(Box::new(Field::new(
+                            Field::new_struct(
                                 "struct",
-                                DataType::Struct(vec![
+                                vec![
                                     Field::new("date32", DataType::Date32, true),
-                                    Field::new(
+                                    Field::new_list(
                                         "list[struct<>]",
-                                        DataType::List(Box::new(Field::new(
+                                        Field::new(
                                             "struct",
-                                            DataType::Struct(vec![]),
+                                            DataType::Struct(Fields::empty()),
                                             false,
-                                        ))),
+                                        ),
                                         false,
                                     ),
-                                ]),
+                                ],
                                 false,
-                            ))),
+                            ),
                             false,
                         ),
-                    ]),
+                    ],
                     false,
                 ),
-                Field::new(
+                Field::new_union(
                     "union<int64, list[union<date32, list[union<>]>]>",
-                    DataType::Union(
-                        vec![
-                            Field::new("int64", DataType::Int64, true),
-                            Field::new(
-                                "list[union<date32, list[union<>]>]",
-                                DataType::List(Box::new(Field::new(
-                                    "union<date32, list[union<>]>",
-                                    DataType::Union(
-                                        vec![
-                                            Field::new("date32", DataType::Date32, true),
-                                            Field::new(
-                                                "list[union<>]",
-                                                DataType::List(Box::new(Field::new(
-                                                    "union",
-                                                    DataType::Union(
-                                                        vec![],
-                                                        vec![],
-                                                        UnionMode::Sparse,
-                                                    ),
-                                                    false,
-                                                ))),
-                                                false,
+                    vec![0, 1],
+                    vec![
+                        Field::new("int64", DataType::Int64, true),
+                        Field::new_list(
+                            "list[union<date32, list[union<>]>]",
+                            Field::new_union(
+                                "union<date32, list[union<>]>",
+                                vec![0, 1],
+                                vec![
+                                    Field::new("date32", DataType::Date32, true),
+                                    Field::new_list(
+                                        "list[union<>]",
+                                        Field::new(
+                                            "union",
+                                            DataType::Union(
+                                                UnionFields::empty(),
+                                                UnionMode::Sparse,
                                             ),
-                                        ],
-                                        vec![0, 1],
-                                        UnionMode::Dense,
+                                            false,
+                                        ),
+                                        false,
                                     ),
-                                    false,
-                                ))),
-                                false,
+                                ],
+                                UnionMode::Dense,
                             ),
-                        ],
-                        vec![0, 1],
-                        UnionMode::Sparse,
-                    ),
-                    false,
+                            false,
+                        ),
+                    ],
+                    UnionMode::Sparse,
                 ),
-                Field::new("struct<>", DataType::Struct(vec![]), true),
+                Field::new("struct<>", DataType::Struct(Fields::empty()), true),
                 Field::new(
                     "union<>",
-                    DataType::Union(vec![], vec![], UnionMode::Dense),
+                    DataType::Union(UnionFields::empty(), UnionMode::Dense),
                     true,
                 ),
                 Field::new(
                     "union<>",
-                    DataType::Union(vec![], vec![], UnionMode::Sparse),
+                    DataType::Union(UnionFields::empty(), UnionMode::Sparse),
                     true,
                 ),
                 Field::new(
                     "union<int32, utf8>",
                     DataType::Union(
-                        vec![
-                            Field::new("int32", DataType::Int32, true),
-                            Field::new("utf8", DataType::Utf8, true),
-                        ],
-                        vec![2, 3], // non-default type ids
+                        UnionFields::new(
+                            vec![2, 3], // non-default type ids
+                            vec![
+                                Field::new("int32", DataType::Int32, true),
+                                Field::new("utf8", DataType::Utf8, true),
+                            ],
+                        ),
                         UnionMode::Dense,
                     ),
                     true,
                 ),
                 Field::new_dict(
                     "dictionary<int32, utf8>",
-                    DataType::Dictionary(
-                        Box::new(DataType::Int32),
-                        Box::new(DataType::Utf8),
-                    ),
+                    DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
                     true,
                     123,
                     true,
                 ),
                 Field::new_dict(
                     "dictionary<uint8, uint32>",
-                    DataType::Dictionary(
-                        Box::new(DataType::UInt8),
-                        Box::new(DataType::UInt32),
-                    ),
+                    DataType::Dictionary(Box::new(DataType::UInt8), Box::new(DataType::UInt32)),
                     true,
                     123,
                     true,
@@ -973,39 +1011,50 @@ mod tests {
         let fb = schema_to_fb(&schema);
 
         // read back fields
-        let ipc = ipc::root_as_schema(fb.finished_data()).unwrap();
+        let ipc = crate::root_as_schema(fb.finished_data()).unwrap();
         let schema2 = fb_to_schema(ipc);
         assert_eq!(schema, schema2);
     }
 
     #[test]
     fn schema_from_bytes() {
-        // bytes of a schema generated from python (0.14.0), saved as an `ipc::Message`.
-        // the schema is: Field("field1", DataType::UInt32, false)
+        // Bytes of a schema generated via following python code, using pyarrow 10.0.1:
+        //
+        // import pyarrow as pa
+        // schema = pa.schema([pa.field('field1', pa.uint32(), nullable=False)])
+        // sink = pa.BufferOutputStream()
+        // with pa.ipc.new_stream(sink, schema) as writer:
+        //     pass
+        // # stripping continuation & length prefix & suffix bytes to get only schema bytes
+        // [x for x in sink.getvalue().to_pybytes()][8:-8]
         let bytes: Vec<u8> = vec![
-            16, 0, 0, 0, 0, 0, 10, 0, 12, 0, 6, 0, 5, 0, 8, 0, 10, 0, 0, 0, 0, 1, 3, 0,
-            12, 0, 0, 0, 8, 0, 8, 0, 0, 0, 4, 0, 8, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 20,
-            0, 0, 0, 16, 0, 20, 0, 8, 0, 0, 0, 7, 0, 12, 0, 0, 0, 16, 0, 16, 0, 0, 0, 0,
-            0, 0, 2, 32, 0, 0, 0, 20, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 8, 0,
-            4, 0, 6, 0, 0, 0, 32, 0, 0, 0, 6, 0, 0, 0, 102, 105, 101, 108, 100, 49, 0, 0,
-            0, 0, 0, 0,
+            16, 0, 0, 0, 0, 0, 10, 0, 12, 0, 6, 0, 5, 0, 8, 0, 10, 0, 0, 0, 0, 1, 4, 0, 12, 0, 0,
+            0, 8, 0, 8, 0, 0, 0, 4, 0, 8, 0, 0, 0, 4, 0, 0, 0, 1, 0, 0, 0, 20, 0, 0, 0, 16, 0, 20,
+            0, 8, 0, 0, 0, 7, 0, 12, 0, 0, 0, 16, 0, 16, 0, 0, 0, 0, 0, 0, 2, 16, 0, 0, 0, 32, 0,
+            0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 102, 105, 101, 108, 100, 49, 0, 0, 0, 0, 6,
+            0, 8, 0, 4, 0, 6, 0, 0, 0, 32, 0, 0, 0,
         ];
-        let ipc = ipc::root_as_message(&bytes[..]).unwrap();
+        let ipc = crate::root_as_message(&bytes).unwrap();
         let schema = ipc.header_as_schema().unwrap();
 
-        // a message generated from Rust, same as the Python one
-        let bytes: Vec<u8> = vec![
-            16, 0, 0, 0, 0, 0, 10, 0, 14, 0, 12, 0, 11, 0, 4, 0, 10, 0, 0, 0, 20, 0, 0,
-            0, 0, 0, 0, 1, 3, 0, 10, 0, 12, 0, 0, 0, 8, 0, 4, 0, 10, 0, 0, 0, 8, 0, 0, 0,
-            8, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 16, 0, 0, 0, 12, 0, 18, 0, 12, 0, 0, 0,
-            11, 0, 4, 0, 12, 0, 0, 0, 20, 0, 0, 0, 0, 0, 0, 2, 20, 0, 0, 0, 0, 0, 6, 0,
-            8, 0, 4, 0, 6, 0, 0, 0, 32, 0, 0, 0, 6, 0, 0, 0, 102, 105, 101, 108, 100, 49,
-            0, 0,
-        ];
-        let ipc2 = ipc::root_as_message(&bytes[..]).unwrap();
-        let schema2 = ipc.header_as_schema().unwrap();
+        // generate same message with Rust
+        let data_gen = crate::writer::IpcDataGenerator::default();
+        let arrow_schema = Schema::new(vec![Field::new("field1", DataType::UInt32, false)]);
+        let bytes = data_gen
+            .schema_to_bytes(&arrow_schema, &crate::writer::IpcWriteOptions::default())
+            .ipc_message;
+
+        let ipc2 = crate::root_as_message(&bytes).unwrap();
+        let schema2 = ipc2.header_as_schema().unwrap();
+
+        // can't compare schema directly as it compares the underlying bytes, which can differ
+        assert!(schema.custom_metadata().is_none());
+        assert!(schema2.custom_metadata().is_none());
+        assert_eq!(schema.endianness(), schema2.endianness());
+        assert!(schema.features().is_none());
+        assert!(schema2.features().is_none());
+        assert_eq!(fb_to_schema(schema), fb_to_schema(schema2));
 
-        assert_eq!(schema, schema2);
         assert_eq!(ipc.version(), ipc2.version());
         assert_eq!(ipc.header_type(), ipc2.header_type());
         assert_eq!(ipc.bodyLength(), ipc2.bodyLength());
diff --git a/arrow/src/ipc/gen/File.rs b/arrow-ipc/src/gen/File.rs
similarity index 69%
rename from arrow/src/ipc/gen/File.rs
rename to arrow-ipc/src/gen/File.rs
index 04cbc6441377..c0c2fb183237 100644
--- a/arrow/src/ipc/gen/File.rs
+++ b/arrow-ipc/src/gen/File.rs
@@ -18,7 +18,7 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
 
-use crate::ipc::gen::Schema::*;
+use crate::gen::Schema::*;
 use flatbuffers::EndianScalar;
 use std::{cmp::Ordering, mem};
 // automatically generated by the FlatBuffers compiler, do not modify
@@ -27,8 +27,13 @@ use std::{cmp::Ordering, mem};
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq)]
 pub struct Block(pub [u8; 24]);
-impl std::fmt::Debug for Block {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl Default for Block {
+    fn default() -> Self {
+        Self([0; 24])
+    }
+}
+impl core::fmt::Debug for Block {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         f.debug_struct("Block")
             .field("offset", &self.offset())
             .field("metaDataLength", &self.metaDataLength())
@@ -38,39 +43,25 @@ impl std::fmt::Debug for Block {
 }
 
 impl flatbuffers::SimpleToVerifyInSlice for Block {}
-impl flatbuffers::SafeSliceAccess for Block {}
 impl<'a> flatbuffers::Follow<'a> for Block {
     type Inner = &'a Block;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         <&'a Block>::follow(buf, loc)
     }
 }
 impl<'a> flatbuffers::Follow<'a> for &'a Block {
     type Inner = &'a Block;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         flatbuffers::follow_cast_ref::<Block>(buf, loc)
     }
 }
 impl<'b> flatbuffers::Push for Block {
     type Output = Block;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        let src = unsafe {
-            ::std::slice::from_raw_parts(self as *const Block as *const u8, Self::size())
-        };
-        dst.copy_from_slice(src);
-    }
-}
-impl<'b> flatbuffers::Push for &'b Block {
-    type Output = Block;
-
-    #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        let src = unsafe {
-            ::std::slice::from_raw_parts(*self as *const Block as *const u8, Self::size())
-        };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        let src = ::core::slice::from_raw_parts(self as *const Block as *const u8, Self::size());
         dst.copy_from_slice(src);
     }
 }
@@ -85,7 +76,8 @@ impl<'a> flatbuffers::Verifiable for Block {
         v.in_buffer::<Self>(pos)
     }
 }
-impl Block {
+
+impl<'a> Block {
     #[allow(clippy::too_many_arguments)]
     pub fn new(offset: i64, metaDataLength: i32, bodyLength: i64) -> Self {
         let mut s = Self([0; 24]);
@@ -97,50 +89,60 @@ impl Block {
 
     /// Index to the start of the RecordBlock (note this is past the Message header)
     pub fn offset(&self) -> i64 {
-        let mut mem = core::mem::MaybeUninit::<i64>::uninit();
-        unsafe {
+        let mut mem = core::mem::MaybeUninit::<<i64 as EndianScalar>::Scalar>::uninit();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
+        EndianScalar::from_little_endian(unsafe {
             core::ptr::copy_nonoverlapping(
                 self.0[0..].as_ptr(),
                 mem.as_mut_ptr() as *mut u8,
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
             mem.assume_init()
-        }
-        .from_little_endian()
+        })
     }
 
     pub fn set_offset(&mut self, x: i64) {
         let x_le = x.to_little_endian();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
         unsafe {
             core::ptr::copy_nonoverlapping(
-                &x_le as *const i64 as *const u8,
+                &x_le as *const _ as *const u8,
                 self.0[0..].as_mut_ptr(),
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
         }
     }
 
     /// Length of the metadata
     pub fn metaDataLength(&self) -> i32 {
-        let mut mem = core::mem::MaybeUninit::<i32>::uninit();
-        unsafe {
+        let mut mem = core::mem::MaybeUninit::<<i32 as EndianScalar>::Scalar>::uninit();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
+        EndianScalar::from_little_endian(unsafe {
             core::ptr::copy_nonoverlapping(
                 self.0[8..].as_ptr(),
                 mem.as_mut_ptr() as *mut u8,
-                core::mem::size_of::<i32>(),
+                core::mem::size_of::<<i32 as EndianScalar>::Scalar>(),
             );
             mem.assume_init()
-        }
-        .from_little_endian()
+        })
     }
 
     pub fn set_metaDataLength(&mut self, x: i32) {
         let x_le = x.to_little_endian();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
         unsafe {
             core::ptr::copy_nonoverlapping(
-                &x_le as *const i32 as *const u8,
+                &x_le as *const _ as *const u8,
                 self.0[8..].as_mut_ptr(),
-                core::mem::size_of::<i32>(),
+                core::mem::size_of::<<i32 as EndianScalar>::Scalar>(),
             );
         }
     }
@@ -148,25 +150,30 @@ impl Block {
     /// Length of the data (this is aligned so there can be a gap between this and
     /// the metadata).
     pub fn bodyLength(&self) -> i64 {
-        let mut mem = core::mem::MaybeUninit::<i64>::uninit();
-        unsafe {
+        let mut mem = core::mem::MaybeUninit::<<i64 as EndianScalar>::Scalar>::uninit();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
+        EndianScalar::from_little_endian(unsafe {
             core::ptr::copy_nonoverlapping(
                 self.0[16..].as_ptr(),
                 mem.as_mut_ptr() as *mut u8,
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
             mem.assume_init()
-        }
-        .from_little_endian()
+        })
     }
 
     pub fn set_bodyLength(&mut self, x: i64) {
         let x_le = x.to_little_endian();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
         unsafe {
             core::ptr::copy_nonoverlapping(
-                &x_le as *const i64 as *const u8,
+                &x_le as *const _ as *const u8,
                 self.0[16..].as_mut_ptr(),
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
         }
     }
@@ -185,16 +192,22 @@ pub struct Footer<'a> {
 impl<'a> flatbuffers::Follow<'a> for Footer<'a> {
     type Inner = Footer<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Footer<'a> {
+    pub const VT_VERSION: flatbuffers::VOffsetT = 4;
+    pub const VT_SCHEMA: flatbuffers::VOffsetT = 6;
+    pub const VT_DICTIONARIES: flatbuffers::VOffsetT = 8;
+    pub const VT_RECORDBATCHES: flatbuffers::VOffsetT = 10;
+    pub const VT_CUSTOM_METADATA: flatbuffers::VOffsetT = 12;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Footer { _tab: table }
     }
     #[allow(unused_mut)]
@@ -219,49 +232,66 @@ impl<'a> Footer<'a> {
         builder.finish()
     }
 
-    pub const VT_VERSION: flatbuffers::VOffsetT = 4;
-    pub const VT_SCHEMA: flatbuffers::VOffsetT = 6;
-    pub const VT_DICTIONARIES: flatbuffers::VOffsetT = 8;
-    pub const VT_RECORDBATCHES: flatbuffers::VOffsetT = 10;
-    pub const VT_CUSTOM_METADATA: flatbuffers::VOffsetT = 12;
-
     #[inline]
     pub fn version(&self) -> MetadataVersion {
-        self._tab
-            .get::<MetadataVersion>(Footer::VT_VERSION, Some(MetadataVersion::V1))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<MetadataVersion>(Footer::VT_VERSION, Some(MetadataVersion::V1))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn schema(&self) -> Option<Schema<'a>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<Schema>>(Footer::VT_SCHEMA, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<Schema>>(Footer::VT_SCHEMA, None)
+        }
     }
     #[inline]
-    pub fn dictionaries(&self) -> Option<&'a [Block]> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Block>>>(
-                Footer::VT_DICTIONARIES,
-                None,
-            )
-            .map(|v| v.safe_slice())
+    pub fn dictionaries(&self) -> Option<flatbuffers::Vector<'a, Block>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Block>>>(
+                    Footer::VT_DICTIONARIES,
+                    None,
+                )
+        }
     }
     #[inline]
-    pub fn recordBatches(&self) -> Option<&'a [Block]> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Block>>>(
-                Footer::VT_RECORDBATCHES,
-                None,
-            )
-            .map(|v| v.safe_slice())
+    pub fn recordBatches(&self) -> Option<flatbuffers::Vector<'a, Block>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Block>>>(
+                    Footer::VT_RECORDBATCHES,
+                    None,
+                )
+        }
     }
     /// User-defined metadata
     #[inline]
     pub fn custom_metadata(
         &self,
     ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>> {
-        self._tab.get::<flatbuffers::ForwardsUOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue>>,
-        >>(Footer::VT_CUSTOM_METADATA, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab.get::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue>>,
+            >>(Footer::VT_CUSTOM_METADATA, None)
+        }
     }
 }
 
@@ -273,25 +303,21 @@ impl flatbuffers::Verifiable for Footer<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<MetadataVersion>(&"version", Self::VT_VERSION, false)?
-            .visit_field::<flatbuffers::ForwardsUOffset<Schema>>(
-                &"schema",
-                Self::VT_SCHEMA,
-                false,
-            )?
+            .visit_field::<MetadataVersion>("version", Self::VT_VERSION, false)?
+            .visit_field::<flatbuffers::ForwardsUOffset<Schema>>("schema", Self::VT_SCHEMA, false)?
             .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Block>>>(
-                &"dictionaries",
+                "dictionaries",
                 Self::VT_DICTIONARIES,
                 false,
             )?
             .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Block>>>(
-                &"recordBatches",
+                "recordBatches",
                 Self::VT_RECORDBATCHES,
                 false,
             )?
             .visit_field::<flatbuffers::ForwardsUOffset<
                 flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>,
-            >>(&"custom_metadata", Self::VT_CUSTOM_METADATA, false)?
+            >>("custom_metadata", Self::VT_CUSTOM_METADATA, false)?
             .finish();
         Ok(())
     }
@@ -302,9 +328,7 @@ pub struct FooterArgs<'a> {
     pub dictionaries: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Block>>>,
     pub recordBatches: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Block>>>,
     pub custom_metadata: Option<
-        flatbuffers::WIPOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>,
-        >,
+        flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>>,
     >,
 }
 impl<'a> Default for FooterArgs<'a> {
@@ -319,6 +343,7 @@ impl<'a> Default for FooterArgs<'a> {
         }
     }
 }
+
 pub struct FooterBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -326,39 +351,29 @@ pub struct FooterBuilder<'a: 'b, 'b> {
 impl<'a: 'b, 'b> FooterBuilder<'a, 'b> {
     #[inline]
     pub fn add_version(&mut self, version: MetadataVersion) {
-        self.fbb_.push_slot::<MetadataVersion>(
-            Footer::VT_VERSION,
-            version,
-            MetadataVersion::V1,
-        );
+        self.fbb_
+            .push_slot::<MetadataVersion>(Footer::VT_VERSION, version, MetadataVersion::V1);
     }
     #[inline]
     pub fn add_schema(&mut self, schema: flatbuffers::WIPOffset<Schema<'b>>) {
         self.fbb_
-            .push_slot_always::<flatbuffers::WIPOffset<Schema>>(
-                Footer::VT_SCHEMA,
-                schema,
-            );
+            .push_slot_always::<flatbuffers::WIPOffset<Schema>>(Footer::VT_SCHEMA, schema);
     }
     #[inline]
     pub fn add_dictionaries(
         &mut self,
         dictionaries: flatbuffers::WIPOffset<flatbuffers::Vector<'b, Block>>,
     ) {
-        self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            Footer::VT_DICTIONARIES,
-            dictionaries,
-        );
+        self.fbb_
+            .push_slot_always::<flatbuffers::WIPOffset<_>>(Footer::VT_DICTIONARIES, dictionaries);
     }
     #[inline]
     pub fn add_recordBatches(
         &mut self,
         recordBatches: flatbuffers::WIPOffset<flatbuffers::Vector<'b, Block>>,
     ) {
-        self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            Footer::VT_RECORDBATCHES,
-            recordBatches,
-        );
+        self.fbb_
+            .push_slot_always::<flatbuffers::WIPOffset<_>>(Footer::VT_RECORDBATCHES, recordBatches);
     }
     #[inline]
     pub fn add_custom_metadata(
@@ -373,9 +388,7 @@ impl<'a: 'b, 'b> FooterBuilder<'a, 'b> {
         );
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> FooterBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> FooterBuilder<'a, 'b> {
         let start = _fbb.start_table();
         FooterBuilder {
             fbb_: _fbb,
@@ -389,8 +402,8 @@ impl<'a: 'b, 'b> FooterBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Footer<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Footer<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Footer");
         ds.field("version", &self.version());
         ds.field("schema", &self.schema());
@@ -400,18 +413,6 @@ impl std::fmt::Debug for Footer<'_> {
         ds.finish()
     }
 }
-#[inline]
-#[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")]
-pub fn get_root_as_footer<'a>(buf: &'a [u8]) -> Footer<'a> {
-    unsafe { flatbuffers::root_unchecked::<Footer<'a>>(buf) }
-}
-
-#[inline]
-#[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")]
-pub fn get_size_prefixed_root_as_footer<'a>(buf: &'a [u8]) -> Footer<'a> {
-    unsafe { flatbuffers::size_prefixed_root_unchecked::<Footer<'a>>(buf) }
-}
-
 #[inline]
 /// Verifies that a buffer of bytes contains a `Footer`
 /// and returns it.
@@ -429,9 +430,7 @@ pub fn root_as_footer(buf: &[u8]) -> Result<Footer, flatbuffers::InvalidFlatbuff
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `size_prefixed_root_as_footer_unchecked`.
-pub fn size_prefixed_root_as_footer(
-    buf: &[u8],
-) -> Result<Footer, flatbuffers::InvalidFlatbuffer> {
+pub fn size_prefixed_root_as_footer(buf: &[u8]) -> Result<Footer, flatbuffers::InvalidFlatbuffer> {
     flatbuffers::size_prefixed_root::<Footer>(buf)
 }
 #[inline]
diff --git a/arrow/src/ipc/gen/Message.rs b/arrow-ipc/src/gen/Message.rs
similarity index 69%
rename from arrow/src/ipc/gen/Message.rs
rename to arrow-ipc/src/gen/Message.rs
index 707c62c0f76e..a546b54d9170 100644
--- a/arrow/src/ipc/gen/Message.rs
+++ b/arrow-ipc/src/gen/Message.rs
@@ -18,9 +18,9 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
 
-use crate::ipc::gen::Schema::*;
-use crate::ipc::gen::SparseTensor::*;
-use crate::ipc::gen::Tensor::*;
+use crate::gen::Schema::*;
+use crate::gen::SparseTensor::*;
+use crate::gen::Tensor::*;
 use flatbuffers::EndianScalar;
 use std::{cmp::Ordering, mem};
 // automatically generated by the FlatBuffers compiler, do not modify
@@ -43,7 +43,7 @@ pub const ENUM_MAX_COMPRESSION_TYPE: i8 = 1;
 pub const ENUM_VALUES_COMPRESSION_TYPE: [CompressionType; 2] =
     [CompressionType::LZ4_FRAME, CompressionType::ZSTD];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct CompressionType(pub i8);
 #[allow(non_upper_case_globals)]
@@ -63,8 +63,8 @@ impl CompressionType {
         }
     }
 }
-impl std::fmt::Debug for CompressionType {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for CompressionType {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -75,8 +75,8 @@ impl std::fmt::Debug for CompressionType {
 impl<'a> flatbuffers::Follow<'a> for CompressionType {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i8>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
         Self(b)
     }
 }
@@ -84,20 +84,21 @@ impl<'a> flatbuffers::Follow<'a> for CompressionType {
 impl flatbuffers::Push for CompressionType {
     type Output = CompressionType;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i8>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i8>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for CompressionType {
+    type Scalar = i8;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i8::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i8 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i8::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i8) -> Self {
+        let b = i8::from_le(v);
         Self(b)
     }
 }
@@ -135,7 +136,7 @@ pub const ENUM_VALUES_BODY_COMPRESSION_METHOD: [BodyCompressionMethod; 1] =
 /// Provided for forward compatibility in case we need to support different
 /// strategies for compressing the IPC message body (like whole-body
 /// compression rather than buffer-level) in the future
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct BodyCompressionMethod(pub i8);
 #[allow(non_upper_case_globals)]
@@ -160,8 +161,8 @@ impl BodyCompressionMethod {
         }
     }
 }
-impl std::fmt::Debug for BodyCompressionMethod {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for BodyCompressionMethod {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -172,8 +173,8 @@ impl std::fmt::Debug for BodyCompressionMethod {
 impl<'a> flatbuffers::Follow<'a> for BodyCompressionMethod {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i8>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i8>(buf, loc);
         Self(b)
     }
 }
@@ -181,20 +182,21 @@ impl<'a> flatbuffers::Follow<'a> for BodyCompressionMethod {
 impl flatbuffers::Push for BodyCompressionMethod {
     type Output = BodyCompressionMethod;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i8>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i8>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for BodyCompressionMethod {
+    type Scalar = i8;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i8::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i8 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i8::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i8) -> Self {
+        let b = i8::from_le(v);
         Self(b)
     }
 }
@@ -243,7 +245,7 @@ pub const ENUM_VALUES_MESSAGE_HEADER: [MessageHeader; 6] = [
 /// Arrow implementations do not need to implement all of the message types,
 /// which may include experimental metadata types. For maximum compatibility,
 /// it is best to send data using RecordBatch
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct MessageHeader(pub u8);
 #[allow(non_upper_case_globals)]
@@ -278,8 +280,8 @@ impl MessageHeader {
         }
     }
 }
-impl std::fmt::Debug for MessageHeader {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for MessageHeader {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -287,12 +289,11 @@ impl std::fmt::Debug for MessageHeader {
         }
     }
 }
-pub struct MessageHeaderUnionTableOffset {}
 impl<'a> flatbuffers::Follow<'a> for MessageHeader {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<u8>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
         Self(b)
     }
 }
@@ -300,20 +301,21 @@ impl<'a> flatbuffers::Follow<'a> for MessageHeader {
 impl flatbuffers::Push for MessageHeader {
     type Output = MessageHeader;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<u8>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<u8>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for MessageHeader {
+    type Scalar = u8;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = u8::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> u8 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = u8::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: u8) -> Self {
+        let b = u8::from_le(v);
         Self(b)
     }
 }
@@ -330,21 +332,28 @@ impl<'a> flatbuffers::Verifiable for MessageHeader {
 }
 
 impl flatbuffers::SimpleToVerifyInSlice for MessageHeader {}
+pub struct MessageHeaderUnionTableOffset {}
+
 /// ----------------------------------------------------------------------
 /// Data structures for describing a table row batch (a collection of
 /// equal-length Arrow arrays)
 /// Metadata about a field at some level of a nested type tree (but not
 /// its children).
 ///
-/// For example, a List<Int16> with values `[[1, 2, 3], null, [4], [5, 6], null]`
+/// For example, a `List<Int16>` with values `[[1, 2, 3], null, [4], [5, 6], null]`
 /// would have {length: 5, null_count: 2} for its List node, and {length: 6,
 /// null_count: 0} for its Int16 node, as separate FieldNode structs
 // struct FieldNode, aligned to 8
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq)]
 pub struct FieldNode(pub [u8; 16]);
-impl std::fmt::Debug for FieldNode {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl Default for FieldNode {
+    fn default() -> Self {
+        Self([0; 16])
+    }
+}
+impl core::fmt::Debug for FieldNode {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         f.debug_struct("FieldNode")
             .field("length", &self.length())
             .field("null_count", &self.null_count())
@@ -353,45 +362,26 @@ impl std::fmt::Debug for FieldNode {
 }
 
 impl flatbuffers::SimpleToVerifyInSlice for FieldNode {}
-impl flatbuffers::SafeSliceAccess for FieldNode {}
 impl<'a> flatbuffers::Follow<'a> for FieldNode {
     type Inner = &'a FieldNode;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         <&'a FieldNode>::follow(buf, loc)
     }
 }
 impl<'a> flatbuffers::Follow<'a> for &'a FieldNode {
     type Inner = &'a FieldNode;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         flatbuffers::follow_cast_ref::<FieldNode>(buf, loc)
     }
 }
 impl<'b> flatbuffers::Push for FieldNode {
     type Output = FieldNode;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        let src = unsafe {
-            ::std::slice::from_raw_parts(
-                self as *const FieldNode as *const u8,
-                Self::size(),
-            )
-        };
-        dst.copy_from_slice(src);
-    }
-}
-impl<'b> flatbuffers::Push for &'b FieldNode {
-    type Output = FieldNode;
-
-    #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        let src = unsafe {
-            ::std::slice::from_raw_parts(
-                *self as *const FieldNode as *const u8,
-                Self::size(),
-            )
-        };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        let src =
+            ::core::slice::from_raw_parts(self as *const FieldNode as *const u8, Self::size());
         dst.copy_from_slice(src);
     }
 }
@@ -406,7 +396,8 @@ impl<'a> flatbuffers::Verifiable for FieldNode {
         v.in_buffer::<Self>(pos)
     }
 }
-impl FieldNode {
+
+impl<'a> FieldNode {
     #[allow(clippy::too_many_arguments)]
     pub fn new(length: i64, null_count: i64) -> Self {
         let mut s = Self([0; 16]);
@@ -418,25 +409,30 @@ impl FieldNode {
     /// The number of value slots in the Arrow array at this level of a nested
     /// tree
     pub fn length(&self) -> i64 {
-        let mut mem = core::mem::MaybeUninit::<i64>::uninit();
-        unsafe {
+        let mut mem = core::mem::MaybeUninit::<<i64 as EndianScalar>::Scalar>::uninit();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
+        EndianScalar::from_little_endian(unsafe {
             core::ptr::copy_nonoverlapping(
                 self.0[0..].as_ptr(),
                 mem.as_mut_ptr() as *mut u8,
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
             mem.assume_init()
-        }
-        .from_little_endian()
+        })
     }
 
     pub fn set_length(&mut self, x: i64) {
         let x_le = x.to_little_endian();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
         unsafe {
             core::ptr::copy_nonoverlapping(
-                &x_le as *const i64 as *const u8,
+                &x_le as *const _ as *const u8,
                 self.0[0..].as_mut_ptr(),
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
         }
     }
@@ -445,25 +441,30 @@ impl FieldNode {
     /// to write their physical validity bitmap out as a materialized buffer,
     /// instead setting the length of the bitmap buffer to 0.
     pub fn null_count(&self) -> i64 {
-        let mut mem = core::mem::MaybeUninit::<i64>::uninit();
-        unsafe {
+        let mut mem = core::mem::MaybeUninit::<<i64 as EndianScalar>::Scalar>::uninit();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
+        EndianScalar::from_little_endian(unsafe {
             core::ptr::copy_nonoverlapping(
                 self.0[8..].as_ptr(),
                 mem.as_mut_ptr() as *mut u8,
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
             mem.assume_init()
-        }
-        .from_little_endian()
+        })
     }
 
     pub fn set_null_count(&mut self, x: i64) {
         let x_le = x.to_little_endian();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
         unsafe {
             core::ptr::copy_nonoverlapping(
-                &x_le as *const i64 as *const u8,
+                &x_le as *const _ as *const u8,
                 self.0[8..].as_mut_ptr(),
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
         }
     }
@@ -482,16 +483,19 @@ pub struct BodyCompression<'a> {
 impl<'a> flatbuffers::Follow<'a> for BodyCompression<'a> {
     type Inner = BodyCompression<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> BodyCompression<'a> {
+    pub const VT_CODEC: flatbuffers::VOffsetT = 4;
+    pub const VT_METHOD: flatbuffers::VOffsetT = 6;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         BodyCompression { _tab: table }
     }
     #[allow(unused_mut)]
@@ -505,28 +509,33 @@ impl<'a> BodyCompression<'a> {
         builder.finish()
     }
 
-    pub const VT_CODEC: flatbuffers::VOffsetT = 4;
-    pub const VT_METHOD: flatbuffers::VOffsetT = 6;
-
-    /// Compressor library
+    /// Compressor library.
+    /// For LZ4_FRAME, each compressed buffer must consist of a single frame.
     #[inline]
     pub fn codec(&self) -> CompressionType {
-        self._tab
-            .get::<CompressionType>(
-                BodyCompression::VT_CODEC,
-                Some(CompressionType::LZ4_FRAME),
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<CompressionType>(BodyCompression::VT_CODEC, Some(CompressionType::LZ4_FRAME))
+                .unwrap()
+        }
     }
     /// Indicates the way the record batch body was compressed
     #[inline]
     pub fn method(&self) -> BodyCompressionMethod {
-        self._tab
-            .get::<BodyCompressionMethod>(
-                BodyCompression::VT_METHOD,
-                Some(BodyCompressionMethod::BUFFER),
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<BodyCompressionMethod>(
+                    BodyCompression::VT_METHOD,
+                    Some(BodyCompressionMethod::BUFFER),
+                )
+                .unwrap()
+        }
     }
 }
 
@@ -538,8 +547,8 @@ impl flatbuffers::Verifiable for BodyCompression<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<CompressionType>(&"codec", Self::VT_CODEC, false)?
-            .visit_field::<BodyCompressionMethod>(&"method", Self::VT_METHOD, false)?
+            .visit_field::<CompressionType>("codec", Self::VT_CODEC, false)?
+            .visit_field::<BodyCompressionMethod>("method", Self::VT_METHOD, false)?
             .finish();
         Ok(())
     }
@@ -557,6 +566,7 @@ impl<'a> Default for BodyCompressionArgs {
         }
     }
 }
+
 pub struct BodyCompressionBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -579,9 +589,7 @@ impl<'a: 'b, 'b> BodyCompressionBuilder<'a, 'b> {
         );
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> BodyCompressionBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> BodyCompressionBuilder<'a, 'b> {
         let start = _fbb.start_table();
         BodyCompressionBuilder {
             fbb_: _fbb,
@@ -595,8 +603,8 @@ impl<'a: 'b, 'b> BodyCompressionBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for BodyCompression<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for BodyCompression<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("BodyCompression");
         ds.field("codec", &self.codec());
         ds.field("method", &self.method());
@@ -616,16 +624,21 @@ pub struct RecordBatch<'a> {
 impl<'a> flatbuffers::Follow<'a> for RecordBatch<'a> {
     type Inner = RecordBatch<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> RecordBatch<'a> {
+    pub const VT_LENGTH: flatbuffers::VOffsetT = 4;
+    pub const VT_NODES: flatbuffers::VOffsetT = 6;
+    pub const VT_BUFFERS: flatbuffers::VOffsetT = 8;
+    pub const VT_COMPRESSION: flatbuffers::VOffsetT = 10;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         RecordBatch { _tab: table }
     }
     #[allow(unused_mut)]
@@ -647,28 +660,32 @@ impl<'a> RecordBatch<'a> {
         builder.finish()
     }
 
-    pub const VT_LENGTH: flatbuffers::VOffsetT = 4;
-    pub const VT_NODES: flatbuffers::VOffsetT = 6;
-    pub const VT_BUFFERS: flatbuffers::VOffsetT = 8;
-    pub const VT_COMPRESSION: flatbuffers::VOffsetT = 10;
-
     /// number of records / rows. The arrays in the batch should all have this
     /// length
     #[inline]
     pub fn length(&self) -> i64 {
-        self._tab
-            .get::<i64>(RecordBatch::VT_LENGTH, Some(0))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<i64>(RecordBatch::VT_LENGTH, Some(0))
+                .unwrap()
+        }
     }
     /// Nodes correspond to the pre-ordered flattened logical schema
     #[inline]
-    pub fn nodes(&self) -> Option<&'a [FieldNode]> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, FieldNode>>>(
-                RecordBatch::VT_NODES,
-                None,
-            )
-            .map(|v| v.safe_slice())
+    pub fn nodes(&self) -> Option<flatbuffers::Vector<'a, FieldNode>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, FieldNode>>>(
+                    RecordBatch::VT_NODES,
+                    None,
+                )
+        }
     }
     /// Buffers correspond to the pre-ordered flattened buffer tree
     ///
@@ -677,22 +694,31 @@ impl<'a> RecordBatch<'a> {
     /// bitmap and 1 for the values. For struct arrays, there will only be a
     /// single buffer for the validity (nulls) bitmap
     #[inline]
-    pub fn buffers(&self) -> Option<&'a [Buffer]> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Buffer>>>(
-                RecordBatch::VT_BUFFERS,
-                None,
-            )
-            .map(|v| v.safe_slice())
+    pub fn buffers(&self) -> Option<flatbuffers::Vector<'a, Buffer>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Buffer>>>(
+                    RecordBatch::VT_BUFFERS,
+                    None,
+                )
+        }
     }
     /// Optional compression of the message body
     #[inline]
     pub fn compression(&self) -> Option<BodyCompression<'a>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<BodyCompression>>(
-                RecordBatch::VT_COMPRESSION,
-                None,
-            )
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<BodyCompression>>(
+                    RecordBatch::VT_COMPRESSION,
+                    None,
+                )
+        }
     }
 }
 
@@ -704,11 +730,23 @@ impl flatbuffers::Verifiable for RecordBatch<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-     .visit_field::<i64>(&"length", Self::VT_LENGTH, false)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, FieldNode>>>(&"nodes", Self::VT_NODES, false)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Buffer>>>(&"buffers", Self::VT_BUFFERS, false)?
-     .visit_field::<flatbuffers::ForwardsUOffset<BodyCompression>>(&"compression", Self::VT_COMPRESSION, false)?
-     .finish();
+            .visit_field::<i64>("length", Self::VT_LENGTH, false)?
+            .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, FieldNode>>>(
+                "nodes",
+                Self::VT_NODES,
+                false,
+            )?
+            .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Buffer>>>(
+                "buffers",
+                Self::VT_BUFFERS,
+                false,
+            )?
+            .visit_field::<flatbuffers::ForwardsUOffset<BodyCompression>>(
+                "compression",
+                Self::VT_COMPRESSION,
+                false,
+            )?
+            .finish();
         Ok(())
     }
 }
@@ -729,6 +767,7 @@ impl<'a> Default for RecordBatchArgs<'a> {
         }
     }
 }
+
 pub struct RecordBatchBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -740,10 +779,7 @@ impl<'a: 'b, 'b> RecordBatchBuilder<'a, 'b> {
             .push_slot::<i64>(RecordBatch::VT_LENGTH, length, 0);
     }
     #[inline]
-    pub fn add_nodes(
-        &mut self,
-        nodes: flatbuffers::WIPOffset<flatbuffers::Vector<'b, FieldNode>>,
-    ) {
+    pub fn add_nodes(&mut self, nodes: flatbuffers::WIPOffset<flatbuffers::Vector<'b, FieldNode>>) {
         self.fbb_
             .push_slot_always::<flatbuffers::WIPOffset<_>>(RecordBatch::VT_NODES, nodes);
     }
@@ -752,16 +788,11 @@ impl<'a: 'b, 'b> RecordBatchBuilder<'a, 'b> {
         &mut self,
         buffers: flatbuffers::WIPOffset<flatbuffers::Vector<'b, Buffer>>,
     ) {
-        self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            RecordBatch::VT_BUFFERS,
-            buffers,
-        );
+        self.fbb_
+            .push_slot_always::<flatbuffers::WIPOffset<_>>(RecordBatch::VT_BUFFERS, buffers);
     }
     #[inline]
-    pub fn add_compression(
-        &mut self,
-        compression: flatbuffers::WIPOffset<BodyCompression<'b>>,
-    ) {
+    pub fn add_compression(&mut self, compression: flatbuffers::WIPOffset<BodyCompression<'b>>) {
         self.fbb_
             .push_slot_always::<flatbuffers::WIPOffset<BodyCompression>>(
                 RecordBatch::VT_COMPRESSION,
@@ -769,9 +800,7 @@ impl<'a: 'b, 'b> RecordBatchBuilder<'a, 'b> {
             );
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> RecordBatchBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> RecordBatchBuilder<'a, 'b> {
         let start = _fbb.start_table();
         RecordBatchBuilder {
             fbb_: _fbb,
@@ -785,8 +814,8 @@ impl<'a: 'b, 'b> RecordBatchBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for RecordBatch<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for RecordBatch<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("RecordBatch");
         ds.field("length", &self.length());
         ds.field("nodes", &self.nodes());
@@ -811,16 +840,20 @@ pub struct DictionaryBatch<'a> {
 impl<'a> flatbuffers::Follow<'a> for DictionaryBatch<'a> {
     type Inner = DictionaryBatch<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> DictionaryBatch<'a> {
+    pub const VT_ID: flatbuffers::VOffsetT = 4;
+    pub const VT_DATA: flatbuffers::VOffsetT = 6;
+    pub const VT_ISDELTA: flatbuffers::VOffsetT = 8;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         DictionaryBatch { _tab: table }
     }
     #[allow(unused_mut)]
@@ -837,31 +870,40 @@ impl<'a> DictionaryBatch<'a> {
         builder.finish()
     }
 
-    pub const VT_ID: flatbuffers::VOffsetT = 4;
-    pub const VT_DATA: flatbuffers::VOffsetT = 6;
-    pub const VT_ISDELTA: flatbuffers::VOffsetT = 8;
-
     #[inline]
     pub fn id(&self) -> i64 {
-        self._tab
-            .get::<i64>(DictionaryBatch::VT_ID, Some(0))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<i64>(DictionaryBatch::VT_ID, Some(0))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn data(&self) -> Option<RecordBatch<'a>> {
-        self._tab.get::<flatbuffers::ForwardsUOffset<RecordBatch>>(
-            DictionaryBatch::VT_DATA,
-            None,
-        )
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<RecordBatch>>(DictionaryBatch::VT_DATA, None)
+        }
     }
     /// If isDelta is true the values in the dictionary are to be appended to a
     /// dictionary with the indicated id. If isDelta is false this dictionary
     /// should replace the existing dictionary.
     #[inline]
     pub fn isDelta(&self) -> bool {
-        self._tab
-            .get::<bool>(DictionaryBatch::VT_ISDELTA, Some(false))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<bool>(DictionaryBatch::VT_ISDELTA, Some(false))
+                .unwrap()
+        }
     }
 }
 
@@ -873,13 +915,9 @@ impl flatbuffers::Verifiable for DictionaryBatch<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<i64>(&"id", Self::VT_ID, false)?
-            .visit_field::<flatbuffers::ForwardsUOffset<RecordBatch>>(
-                &"data",
-                Self::VT_DATA,
-                false,
-            )?
-            .visit_field::<bool>(&"isDelta", Self::VT_ISDELTA, false)?
+            .visit_field::<i64>("id", Self::VT_ID, false)?
+            .visit_field::<flatbuffers::ForwardsUOffset<RecordBatch>>("data", Self::VT_DATA, false)?
+            .visit_field::<bool>("isDelta", Self::VT_ISDELTA, false)?
             .finish();
         Ok(())
     }
@@ -899,6 +937,7 @@ impl<'a> Default for DictionaryBatchArgs<'a> {
         }
     }
 }
+
 pub struct DictionaryBatchBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -922,9 +961,7 @@ impl<'a: 'b, 'b> DictionaryBatchBuilder<'a, 'b> {
             .push_slot::<bool>(DictionaryBatch::VT_ISDELTA, isDelta, false);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> DictionaryBatchBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DictionaryBatchBuilder<'a, 'b> {
         let start = _fbb.start_table();
         DictionaryBatchBuilder {
             fbb_: _fbb,
@@ -938,8 +975,8 @@ impl<'a: 'b, 'b> DictionaryBatchBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for DictionaryBatch<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for DictionaryBatch<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("DictionaryBatch");
         ds.field("id", &self.id());
         ds.field("data", &self.data());
@@ -957,16 +994,22 @@ pub struct Message<'a> {
 impl<'a> flatbuffers::Follow<'a> for Message<'a> {
     type Inner = Message<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Message<'a> {
+    pub const VT_VERSION: flatbuffers::VOffsetT = 4;
+    pub const VT_HEADER_TYPE: flatbuffers::VOffsetT = 6;
+    pub const VT_HEADER: flatbuffers::VOffsetT = 8;
+    pub const VT_BODYLENGTH: flatbuffers::VOffsetT = 10;
+    pub const VT_CUSTOM_METADATA: flatbuffers::VOffsetT = 12;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Message { _tab: table }
     }
     #[allow(unused_mut)]
@@ -987,51 +1030,75 @@ impl<'a> Message<'a> {
         builder.finish()
     }
 
-    pub const VT_VERSION: flatbuffers::VOffsetT = 4;
-    pub const VT_HEADER_TYPE: flatbuffers::VOffsetT = 6;
-    pub const VT_HEADER: flatbuffers::VOffsetT = 8;
-    pub const VT_BODYLENGTH: flatbuffers::VOffsetT = 10;
-    pub const VT_CUSTOM_METADATA: flatbuffers::VOffsetT = 12;
-
     #[inline]
     pub fn version(&self) -> MetadataVersion {
-        self._tab
-            .get::<MetadataVersion>(Message::VT_VERSION, Some(MetadataVersion::V1))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<MetadataVersion>(Message::VT_VERSION, Some(MetadataVersion::V1))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn header_type(&self) -> MessageHeader {
-        self._tab
-            .get::<MessageHeader>(Message::VT_HEADER_TYPE, Some(MessageHeader::NONE))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<MessageHeader>(Message::VT_HEADER_TYPE, Some(MessageHeader::NONE))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn header(&self) -> Option<flatbuffers::Table<'a>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
-                Message::VT_HEADER,
-                None,
-            )
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    Message::VT_HEADER,
+                    None,
+                )
+        }
     }
     #[inline]
     pub fn bodyLength(&self) -> i64 {
-        self._tab
-            .get::<i64>(Message::VT_BODYLENGTH, Some(0))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<i64>(Message::VT_BODYLENGTH, Some(0))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn custom_metadata(
         &self,
     ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>> {
-        self._tab.get::<flatbuffers::ForwardsUOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue>>,
-        >>(Message::VT_CUSTOM_METADATA, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab.get::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue>>,
+            >>(Message::VT_CUSTOM_METADATA, None)
+        }
     }
     #[inline]
     #[allow(non_snake_case)]
     pub fn header_as_schema(&self) -> Option<Schema<'a>> {
         if self.header_type() == MessageHeader::Schema {
-            self.header().map(Schema::init_from_table)
+            self.header().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Schema::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -1041,7 +1108,12 @@ impl<'a> Message<'a> {
     #[allow(non_snake_case)]
     pub fn header_as_dictionary_batch(&self) -> Option<DictionaryBatch<'a>> {
         if self.header_type() == MessageHeader::DictionaryBatch {
-            self.header().map(DictionaryBatch::init_from_table)
+            self.header().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { DictionaryBatch::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -1051,7 +1123,12 @@ impl<'a> Message<'a> {
     #[allow(non_snake_case)]
     pub fn header_as_record_batch(&self) -> Option<RecordBatch<'a>> {
         if self.header_type() == MessageHeader::RecordBatch {
-            self.header().map(RecordBatch::init_from_table)
+            self.header().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { RecordBatch::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -1061,7 +1138,12 @@ impl<'a> Message<'a> {
     #[allow(non_snake_case)]
     pub fn header_as_tensor(&self) -> Option<Tensor<'a>> {
         if self.header_type() == MessageHeader::Tensor {
-            self.header().map(Tensor::init_from_table)
+            self.header().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Tensor::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -1071,7 +1153,12 @@ impl<'a> Message<'a> {
     #[allow(non_snake_case)]
     pub fn header_as_sparse_tensor(&self) -> Option<SparseTensor<'a>> {
         if self.header_type() == MessageHeader::SparseTensor {
-            self.header().map(SparseTensor::init_from_table)
+            self.header().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { SparseTensor::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -1086,20 +1173,47 @@ impl flatbuffers::Verifiable for Message<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-     .visit_field::<MetadataVersion>(&"version", Self::VT_VERSION, false)?
-     .visit_union::<MessageHeader, _>(&"header_type", Self::VT_HEADER_TYPE, &"header", Self::VT_HEADER, false, |key, v, pos| {
-        match key {
-          MessageHeader::Schema => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Schema>>("MessageHeader::Schema", pos),
-          MessageHeader::DictionaryBatch => v.verify_union_variant::<flatbuffers::ForwardsUOffset<DictionaryBatch>>("MessageHeader::DictionaryBatch", pos),
-          MessageHeader::RecordBatch => v.verify_union_variant::<flatbuffers::ForwardsUOffset<RecordBatch>>("MessageHeader::RecordBatch", pos),
-          MessageHeader::Tensor => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Tensor>>("MessageHeader::Tensor", pos),
-          MessageHeader::SparseTensor => v.verify_union_variant::<flatbuffers::ForwardsUOffset<SparseTensor>>("MessageHeader::SparseTensor", pos),
-          _ => Ok(()),
-        }
-     })?
-     .visit_field::<i64>(&"bodyLength", Self::VT_BODYLENGTH, false)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>>>(&"custom_metadata", Self::VT_CUSTOM_METADATA, false)?
-     .finish();
+            .visit_field::<MetadataVersion>("version", Self::VT_VERSION, false)?
+            .visit_union::<MessageHeader, _>(
+                "header_type",
+                Self::VT_HEADER_TYPE,
+                "header",
+                Self::VT_HEADER,
+                false,
+                |key, v, pos| match key {
+                    MessageHeader::Schema => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Schema>>(
+                            "MessageHeader::Schema",
+                            pos,
+                        ),
+                    MessageHeader::DictionaryBatch => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<DictionaryBatch>>(
+                            "MessageHeader::DictionaryBatch",
+                            pos,
+                        ),
+                    MessageHeader::RecordBatch => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<RecordBatch>>(
+                            "MessageHeader::RecordBatch",
+                            pos,
+                        ),
+                    MessageHeader::Tensor => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Tensor>>(
+                            "MessageHeader::Tensor",
+                            pos,
+                        ),
+                    MessageHeader::SparseTensor => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<SparseTensor>>(
+                            "MessageHeader::SparseTensor",
+                            pos,
+                        ),
+                    _ => Ok(()),
+                },
+            )?
+            .visit_field::<i64>("bodyLength", Self::VT_BODYLENGTH, false)?
+            .visit_field::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>,
+            >>("custom_metadata", Self::VT_CUSTOM_METADATA, false)?
+            .finish();
         Ok(())
     }
 }
@@ -1109,9 +1223,7 @@ pub struct MessageArgs<'a> {
     pub header: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
     pub bodyLength: i64,
     pub custom_metadata: Option<
-        flatbuffers::WIPOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>,
-        >,
+        flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>>,
     >,
 }
 impl<'a> Default for MessageArgs<'a> {
@@ -1126,6 +1238,7 @@ impl<'a> Default for MessageArgs<'a> {
         }
     }
 }
+
 pub struct MessageBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -1133,11 +1246,8 @@ pub struct MessageBuilder<'a: 'b, 'b> {
 impl<'a: 'b, 'b> MessageBuilder<'a, 'b> {
     #[inline]
     pub fn add_version(&mut self, version: MetadataVersion) {
-        self.fbb_.push_slot::<MetadataVersion>(
-            Message::VT_VERSION,
-            version,
-            MetadataVersion::V1,
-        );
+        self.fbb_
+            .push_slot::<MetadataVersion>(Message::VT_VERSION, version, MetadataVersion::V1);
     }
     #[inline]
     pub fn add_header_type(&mut self, header_type: MessageHeader) {
@@ -1148,10 +1258,7 @@ impl<'a: 'b, 'b> MessageBuilder<'a, 'b> {
         );
     }
     #[inline]
-    pub fn add_header(
-        &mut self,
-        header: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
-    ) {
+    pub fn add_header(&mut self, header: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>) {
         self.fbb_
             .push_slot_always::<flatbuffers::WIPOffset<_>>(Message::VT_HEADER, header);
     }
@@ -1173,9 +1280,7 @@ impl<'a: 'b, 'b> MessageBuilder<'a, 'b> {
         );
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> MessageBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> MessageBuilder<'a, 'b> {
         let start = _fbb.start_table();
         MessageBuilder {
             fbb_: _fbb,
@@ -1189,8 +1294,8 @@ impl<'a: 'b, 'b> MessageBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Message<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Message<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Message");
         ds.field("version", &self.version());
         ds.field("header_type", &self.header_type());
@@ -1255,18 +1360,6 @@ impl std::fmt::Debug for Message<'_> {
         ds.finish()
     }
 }
-#[inline]
-#[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")]
-pub fn get_root_as_message<'a>(buf: &'a [u8]) -> Message<'a> {
-    unsafe { flatbuffers::root_unchecked::<Message<'a>>(buf) }
-}
-
-#[inline]
-#[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")]
-pub fn get_size_prefixed_root_as_message<'a>(buf: &'a [u8]) -> Message<'a> {
-    unsafe { flatbuffers::size_prefixed_root_unchecked::<Message<'a>>(buf) }
-}
-
 #[inline]
 /// Verifies that a buffer of bytes contains a `Message`
 /// and returns it.
diff --git a/arrow/src/ipc/gen/Schema.rs b/arrow-ipc/src/gen/Schema.rs
similarity index 68%
rename from arrow/src/ipc/gen/Schema.rs
rename to arrow-ipc/src/gen/Schema.rs
index dd204e0704df..0dc5dccd39e7 100644
--- a/arrow/src/ipc/gen/Schema.rs
+++ b/arrow-ipc/src/gen/Schema.rs
@@ -45,7 +45,7 @@ pub const ENUM_VALUES_METADATA_VERSION: [MetadataVersion; 5] = [
     MetadataVersion::V5,
 ];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct MetadataVersion(pub i16);
 #[allow(non_upper_case_globals)]
@@ -69,8 +69,7 @@ impl MetadataVersion {
 
     pub const ENUM_MIN: i16 = 0;
     pub const ENUM_MAX: i16 = 4;
-    pub const ENUM_VALUES: &'static [Self] =
-        &[Self::V1, Self::V2, Self::V3, Self::V4, Self::V5];
+    pub const ENUM_VALUES: &'static [Self] = &[Self::V1, Self::V2, Self::V3, Self::V4, Self::V5];
     /// Returns the variant's name or "" if unknown.
     pub fn variant_name(self) -> Option<&'static str> {
         match self {
@@ -83,8 +82,8 @@ impl MetadataVersion {
         }
     }
 }
-impl std::fmt::Debug for MetadataVersion {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for MetadataVersion {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -95,8 +94,8 @@ impl std::fmt::Debug for MetadataVersion {
 impl<'a> flatbuffers::Follow<'a> for MetadataVersion {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i16>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i16>(buf, loc);
         Self(b)
     }
 }
@@ -104,20 +103,21 @@ impl<'a> flatbuffers::Follow<'a> for MetadataVersion {
 impl flatbuffers::Push for MetadataVersion {
     type Output = MetadataVersion;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i16>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i16>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for MetadataVersion {
+    type Scalar = i16;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i16::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i16 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i16::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i16) -> Self {
+        let b = i16::from_le(v);
         Self(b)
     }
 }
@@ -172,7 +172,7 @@ pub const ENUM_VALUES_FEATURE: [Feature; 3] = [
 /// Enums added to this list should be assigned power-of-two values
 /// to facilitate exchanging and comparing bitmaps for supported
 /// features.
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct Feature(pub i64);
 #[allow(non_upper_case_globals)]
@@ -204,8 +204,8 @@ impl Feature {
         }
     }
 }
-impl std::fmt::Debug for Feature {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for Feature {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -216,8 +216,8 @@ impl std::fmt::Debug for Feature {
 impl<'a> flatbuffers::Follow<'a> for Feature {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i64>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i64>(buf, loc);
         Self(b)
     }
 }
@@ -225,20 +225,21 @@ impl<'a> flatbuffers::Follow<'a> for Feature {
 impl flatbuffers::Push for Feature {
     type Output = Feature;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i64>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i64>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for Feature {
+    type Scalar = i64;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i64::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i64 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i64::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i64) -> Self {
+        let b = i64::from_le(v);
         Self(b)
     }
 }
@@ -272,7 +273,7 @@ pub const ENUM_MAX_UNION_MODE: i16 = 1;
 #[allow(non_camel_case_types)]
 pub const ENUM_VALUES_UNION_MODE: [UnionMode; 2] = [UnionMode::Sparse, UnionMode::Dense];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct UnionMode(pub i16);
 #[allow(non_upper_case_globals)]
@@ -292,8 +293,8 @@ impl UnionMode {
         }
     }
 }
-impl std::fmt::Debug for UnionMode {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for UnionMode {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -304,8 +305,8 @@ impl std::fmt::Debug for UnionMode {
 impl<'a> flatbuffers::Follow<'a> for UnionMode {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i16>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i16>(buf, loc);
         Self(b)
     }
 }
@@ -313,20 +314,21 @@ impl<'a> flatbuffers::Follow<'a> for UnionMode {
 impl flatbuffers::Push for UnionMode {
     type Output = UnionMode;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i16>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i16>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for UnionMode {
+    type Scalar = i16;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i16::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i16 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i16::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i16) -> Self {
+        let b = i16::from_le(v);
         Self(b)
     }
 }
@@ -361,7 +363,7 @@ pub const ENUM_MAX_PRECISION: i16 = 2;
 pub const ENUM_VALUES_PRECISION: [Precision; 3] =
     [Precision::HALF, Precision::SINGLE, Precision::DOUBLE];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct Precision(pub i16);
 #[allow(non_upper_case_globals)]
@@ -383,8 +385,8 @@ impl Precision {
         }
     }
 }
-impl std::fmt::Debug for Precision {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for Precision {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -395,8 +397,8 @@ impl std::fmt::Debug for Precision {
 impl<'a> flatbuffers::Follow<'a> for Precision {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i16>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i16>(buf, loc);
         Self(b)
     }
 }
@@ -404,20 +406,21 @@ impl<'a> flatbuffers::Follow<'a> for Precision {
 impl flatbuffers::Push for Precision {
     type Output = Precision;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i16>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i16>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for Precision {
+    type Scalar = i16;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i16::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i16 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i16::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i16) -> Self {
+        let b = i16::from_le(v);
         Self(b)
     }
 }
@@ -451,7 +454,7 @@ pub const ENUM_MAX_DATE_UNIT: i16 = 1;
 #[allow(non_camel_case_types)]
 pub const ENUM_VALUES_DATE_UNIT: [DateUnit; 2] = [DateUnit::DAY, DateUnit::MILLISECOND];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct DateUnit(pub i16);
 #[allow(non_upper_case_globals)]
@@ -471,8 +474,8 @@ impl DateUnit {
         }
     }
 }
-impl std::fmt::Debug for DateUnit {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for DateUnit {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -483,8 +486,8 @@ impl std::fmt::Debug for DateUnit {
 impl<'a> flatbuffers::Follow<'a> for DateUnit {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i16>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i16>(buf, loc);
         Self(b)
     }
 }
@@ -492,20 +495,21 @@ impl<'a> flatbuffers::Follow<'a> for DateUnit {
 impl flatbuffers::Push for DateUnit {
     type Output = DateUnit;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i16>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i16>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for DateUnit {
+    type Scalar = i16;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i16::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i16 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i16::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i16) -> Self {
+        let b = i16::from_le(v);
         Self(b)
     }
 }
@@ -544,7 +548,7 @@ pub const ENUM_VALUES_TIME_UNIT: [TimeUnit; 4] = [
     TimeUnit::NANOSECOND,
 ];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct TimeUnit(pub i16);
 #[allow(non_upper_case_globals)]
@@ -573,8 +577,8 @@ impl TimeUnit {
         }
     }
 }
-impl std::fmt::Debug for TimeUnit {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for TimeUnit {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -585,8 +589,8 @@ impl std::fmt::Debug for TimeUnit {
 impl<'a> flatbuffers::Follow<'a> for TimeUnit {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i16>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i16>(buf, loc);
         Self(b)
     }
 }
@@ -594,20 +598,21 @@ impl<'a> flatbuffers::Follow<'a> for TimeUnit {
 impl flatbuffers::Push for TimeUnit {
     type Output = TimeUnit;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i16>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i16>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for TimeUnit {
+    type Scalar = i16;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i16::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i16 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i16::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i16) -> Self {
+        let b = i16::from_le(v);
         Self(b)
     }
 }
@@ -633,7 +638,7 @@ pub const ENUM_MIN_INTERVAL_UNIT: i16 = 0;
     since = "2.0.0",
     note = "Use associated constants instead. This will no longer be generated in 2021."
 )]
-pub const ENUM_MAX_INTERVAL_UNIT: i16 = 1;
+pub const ENUM_MAX_INTERVAL_UNIT: i16 = 2;
 #[deprecated(
     since = "2.0.0",
     note = "Use associated constants instead. This will no longer be generated in 2021."
@@ -645,7 +650,7 @@ pub const ENUM_VALUES_INTERVAL_UNIT: [IntervalUnit; 3] = [
     IntervalUnit::MONTH_DAY_NANO,
 ];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct IntervalUnit(pub i16);
 #[allow(non_upper_case_globals)]
@@ -668,8 +673,8 @@ impl IntervalUnit {
         }
     }
 }
-impl std::fmt::Debug for IntervalUnit {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for IntervalUnit {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -680,8 +685,8 @@ impl std::fmt::Debug for IntervalUnit {
 impl<'a> flatbuffers::Follow<'a> for IntervalUnit {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i16>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i16>(buf, loc);
         Self(b)
     }
 }
@@ -689,20 +694,21 @@ impl<'a> flatbuffers::Follow<'a> for IntervalUnit {
 impl flatbuffers::Push for IntervalUnit {
     type Output = IntervalUnit;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i16>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i16>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for IntervalUnit {
+    type Scalar = i16;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i16::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i16 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i16::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i16) -> Self {
+        let b = i16::from_le(v);
         Self(b)
     }
 }
@@ -728,13 +734,13 @@ pub const ENUM_MIN_TYPE: u8 = 0;
     since = "2.0.0",
     note = "Use associated constants instead. This will no longer be generated in 2021."
 )]
-pub const ENUM_MAX_TYPE: u8 = 21;
+pub const ENUM_MAX_TYPE: u8 = 22;
 #[deprecated(
     since = "2.0.0",
     note = "Use associated constants instead. This will no longer be generated in 2021."
 )]
 #[allow(non_camel_case_types)]
-pub const ENUM_VALUES_TYPE: [Type; 22] = [
+pub const ENUM_VALUES_TYPE: [Type; 23] = [
     Type::NONE,
     Type::Null,
     Type::Int,
@@ -757,12 +763,13 @@ pub const ENUM_VALUES_TYPE: [Type; 22] = [
     Type::LargeBinary,
     Type::LargeUtf8,
     Type::LargeList,
+    Type::RunEndEncoded,
 ];
 
 /// ----------------------------------------------------------------------
 /// Top-level Type value, enabling extensible type-specific metadata. We can
 /// add new logical types to Type without breaking backwards compatibility
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct Type(pub u8);
 #[allow(non_upper_case_globals)]
@@ -789,9 +796,10 @@ impl Type {
     pub const LargeBinary: Self = Self(19);
     pub const LargeUtf8: Self = Self(20);
     pub const LargeList: Self = Self(21);
+    pub const RunEndEncoded: Self = Self(22);
 
     pub const ENUM_MIN: u8 = 0;
-    pub const ENUM_MAX: u8 = 21;
+    pub const ENUM_MAX: u8 = 22;
     pub const ENUM_VALUES: &'static [Self] = &[
         Self::NONE,
         Self::Null,
@@ -815,6 +823,7 @@ impl Type {
         Self::LargeBinary,
         Self::LargeUtf8,
         Self::LargeList,
+        Self::RunEndEncoded,
     ];
     /// Returns the variant's name or "" if unknown.
     pub fn variant_name(self) -> Option<&'static str> {
@@ -841,12 +850,13 @@ impl Type {
             Self::LargeBinary => Some("LargeBinary"),
             Self::LargeUtf8 => Some("LargeUtf8"),
             Self::LargeList => Some("LargeList"),
+            Self::RunEndEncoded => Some("RunEndEncoded"),
             _ => None,
         }
     }
 }
-impl std::fmt::Debug for Type {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for Type {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -854,12 +864,11 @@ impl std::fmt::Debug for Type {
         }
     }
 }
-pub struct TypeUnionTableOffset {}
 impl<'a> flatbuffers::Follow<'a> for Type {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<u8>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
         Self(b)
     }
 }
@@ -867,20 +876,21 @@ impl<'a> flatbuffers::Follow<'a> for Type {
 impl flatbuffers::Push for Type {
     type Output = Type;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<u8>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<u8>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for Type {
+    type Scalar = u8;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = u8::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> u8 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = u8::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: u8) -> Self {
+        let b = u8::from_le(v);
         Self(b)
     }
 }
@@ -897,6 +907,8 @@ impl<'a> flatbuffers::Verifiable for Type {
 }
 
 impl flatbuffers::SimpleToVerifyInSlice for Type {}
+pub struct TypeUnionTableOffset {}
+
 #[deprecated(
     since = "2.0.0",
     note = "Use associated constants instead. This will no longer be generated in 2021."
@@ -919,7 +931,7 @@ pub const ENUM_VALUES_DICTIONARY_KIND: [DictionaryKind; 1] = [DictionaryKind::De
 /// Maintained for forwards compatibility, in the future
 /// Dictionaries might be explicit maps between integers and values
 /// allowing for non-contiguous index values
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct DictionaryKind(pub i16);
 #[allow(non_upper_case_globals)]
@@ -937,8 +949,8 @@ impl DictionaryKind {
         }
     }
 }
-impl std::fmt::Debug for DictionaryKind {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for DictionaryKind {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -949,8 +961,8 @@ impl std::fmt::Debug for DictionaryKind {
 impl<'a> flatbuffers::Follow<'a> for DictionaryKind {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i16>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i16>(buf, loc);
         Self(b)
     }
 }
@@ -958,20 +970,21 @@ impl<'a> flatbuffers::Follow<'a> for DictionaryKind {
 impl flatbuffers::Push for DictionaryKind {
     type Output = DictionaryKind;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i16>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i16>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for DictionaryKind {
+    type Scalar = i16;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i16::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i16 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i16::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i16) -> Self {
+        let b = i16::from_le(v);
         Self(b)
     }
 }
@@ -1007,7 +1020,7 @@ pub const ENUM_VALUES_ENDIANNESS: [Endianness; 2] = [Endianness::Little, Endiann
 
 /// ----------------------------------------------------------------------
 /// Endianness of the platform producing the data
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct Endianness(pub i16);
 #[allow(non_upper_case_globals)]
@@ -1026,9 +1039,18 @@ impl Endianness {
             _ => None,
         }
     }
+
+    /// Returns true if the endianness of the source system matches the endianness of the target system.
+    pub fn equals_to_target_endianness(self) -> bool {
+        match self {
+            Self::Little => cfg!(target_endian = "little"),
+            Self::Big => cfg!(target_endian = "big"),
+            _ => false,
+        }
+    }
 }
-impl std::fmt::Debug for Endianness {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for Endianness {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -1039,8 +1061,8 @@ impl std::fmt::Debug for Endianness {
 impl<'a> flatbuffers::Follow<'a> for Endianness {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i16>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i16>(buf, loc);
         Self(b)
     }
 }
@@ -1048,20 +1070,21 @@ impl<'a> flatbuffers::Follow<'a> for Endianness {
 impl flatbuffers::Push for Endianness {
     type Output = Endianness;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i16>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i16>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for Endianness {
+    type Scalar = i16;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i16::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i16 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i16::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i16) -> Self {
+        let b = i16::from_le(v);
         Self(b)
     }
 }
@@ -1084,8 +1107,13 @@ impl flatbuffers::SimpleToVerifyInSlice for Endianness {}
 #[repr(transparent)]
 #[derive(Clone, Copy, PartialEq)]
 pub struct Buffer(pub [u8; 16]);
-impl std::fmt::Debug for Buffer {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl Default for Buffer {
+    fn default() -> Self {
+        Self([0; 16])
+    }
+}
+impl core::fmt::Debug for Buffer {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         f.debug_struct("Buffer")
             .field("offset", &self.offset())
             .field("length", &self.length())
@@ -1094,42 +1122,25 @@ impl std::fmt::Debug for Buffer {
 }
 
 impl flatbuffers::SimpleToVerifyInSlice for Buffer {}
-impl flatbuffers::SafeSliceAccess for Buffer {}
 impl<'a> flatbuffers::Follow<'a> for Buffer {
     type Inner = &'a Buffer;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         <&'a Buffer>::follow(buf, loc)
     }
 }
 impl<'a> flatbuffers::Follow<'a> for &'a Buffer {
     type Inner = &'a Buffer;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         flatbuffers::follow_cast_ref::<Buffer>(buf, loc)
     }
 }
 impl<'b> flatbuffers::Push for Buffer {
     type Output = Buffer;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        let src = unsafe {
-            ::std::slice::from_raw_parts(self as *const Buffer as *const u8, Self::size())
-        };
-        dst.copy_from_slice(src);
-    }
-}
-impl<'b> flatbuffers::Push for &'b Buffer {
-    type Output = Buffer;
-
-    #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        let src = unsafe {
-            ::std::slice::from_raw_parts(
-                *self as *const Buffer as *const u8,
-                Self::size(),
-            )
-        };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        let src = ::core::slice::from_raw_parts(self as *const Buffer as *const u8, Self::size());
         dst.copy_from_slice(src);
     }
 }
@@ -1144,7 +1155,8 @@ impl<'a> flatbuffers::Verifiable for Buffer {
         v.in_buffer::<Self>(pos)
     }
 }
-impl Buffer {
+
+impl<'a> Buffer {
     #[allow(clippy::too_many_arguments)]
     pub fn new(offset: i64, length: i64) -> Self {
         let mut s = Self([0; 16]);
@@ -1156,25 +1168,30 @@ impl Buffer {
     /// The relative offset into the shared memory page where the bytes for this
     /// buffer starts
     pub fn offset(&self) -> i64 {
-        let mut mem = core::mem::MaybeUninit::<i64>::uninit();
-        unsafe {
+        let mut mem = core::mem::MaybeUninit::<<i64 as EndianScalar>::Scalar>::uninit();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
+        EndianScalar::from_little_endian(unsafe {
             core::ptr::copy_nonoverlapping(
                 self.0[0..].as_ptr(),
                 mem.as_mut_ptr() as *mut u8,
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
             mem.assume_init()
-        }
-        .from_little_endian()
+        })
     }
 
     pub fn set_offset(&mut self, x: i64) {
         let x_le = x.to_little_endian();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
         unsafe {
             core::ptr::copy_nonoverlapping(
-                &x_le as *const i64 as *const u8,
+                &x_le as *const _ as *const u8,
                 self.0[0..].as_mut_ptr(),
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
         }
     }
@@ -1185,25 +1202,30 @@ impl Buffer {
     /// after a buffer, but such padding bytes do not need to be accounted for in
     /// the size here.
     pub fn length(&self) -> i64 {
-        let mut mem = core::mem::MaybeUninit::<i64>::uninit();
-        unsafe {
+        let mut mem = core::mem::MaybeUninit::<<i64 as EndianScalar>::Scalar>::uninit();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
+        EndianScalar::from_little_endian(unsafe {
             core::ptr::copy_nonoverlapping(
                 self.0[8..].as_ptr(),
                 mem.as_mut_ptr() as *mut u8,
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
             mem.assume_init()
-        }
-        .from_little_endian()
+        })
     }
 
     pub fn set_length(&mut self, x: i64) {
         let x_le = x.to_little_endian();
+        // Safety:
+        // Created from a valid Table for this object
+        // Which contains a valid value in this slot
         unsafe {
             core::ptr::copy_nonoverlapping(
-                &x_le as *const i64 as *const u8,
+                &x_le as *const _ as *const u8,
                 self.0[8..].as_mut_ptr(),
-                core::mem::size_of::<i64>(),
+                core::mem::size_of::<<i64 as EndianScalar>::Scalar>(),
             );
         }
     }
@@ -1220,16 +1242,16 @@ pub struct Null<'a> {
 impl<'a> flatbuffers::Follow<'a> for Null<'a> {
     type Inner = Null<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Null<'a> {
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Null { _tab: table }
     }
     #[allow(unused_mut)]
@@ -1260,6 +1282,7 @@ impl<'a> Default for NullArgs {
         NullArgs {}
     }
 }
+
 pub struct NullBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -1280,8 +1303,8 @@ impl<'a: 'b, 'b> NullBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Null<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Null<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Null");
         ds.finish()
     }
@@ -1299,16 +1322,16 @@ pub struct Struct_<'a> {
 impl<'a> flatbuffers::Follow<'a> for Struct_<'a> {
     type Inner = Struct_<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Struct_<'a> {
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Struct_ { _tab: table }
     }
     #[allow(unused_mut)]
@@ -1339,15 +1362,14 @@ impl<'a> Default for Struct_Args {
         Struct_Args {}
     }
 }
+
 pub struct Struct_Builder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
 }
 impl<'a: 'b, 'b> Struct_Builder<'a, 'b> {
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> Struct_Builder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> Struct_Builder<'a, 'b> {
         let start = _fbb.start_table();
         Struct_Builder {
             fbb_: _fbb,
@@ -1361,8 +1383,8 @@ impl<'a: 'b, 'b> Struct_Builder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Struct_<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Struct_<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Struct_");
         ds.finish()
     }
@@ -1377,16 +1399,16 @@ pub struct List<'a> {
 impl<'a> flatbuffers::Follow<'a> for List<'a> {
     type Inner = List<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> List<'a> {
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         List { _tab: table }
     }
     #[allow(unused_mut)]
@@ -1417,6 +1439,7 @@ impl<'a> Default for ListArgs {
         ListArgs {}
     }
 }
+
 pub struct ListBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -1437,8 +1460,8 @@ impl<'a: 'b, 'b> ListBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for List<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for List<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("List");
         ds.finish()
     }
@@ -1455,16 +1478,16 @@ pub struct LargeList<'a> {
 impl<'a> flatbuffers::Follow<'a> for LargeList<'a> {
     type Inner = LargeList<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> LargeList<'a> {
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         LargeList { _tab: table }
     }
     #[allow(unused_mut)]
@@ -1495,15 +1518,14 @@ impl<'a> Default for LargeListArgs {
         LargeListArgs {}
     }
 }
+
 pub struct LargeListBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
 }
 impl<'a: 'b, 'b> LargeListBuilder<'a, 'b> {
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> LargeListBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> LargeListBuilder<'a, 'b> {
         let start = _fbb.start_table();
         LargeListBuilder {
             fbb_: _fbb,
@@ -1517,8 +1539,8 @@ impl<'a: 'b, 'b> LargeListBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for LargeList<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for LargeList<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("LargeList");
         ds.finish()
     }
@@ -1533,16 +1555,18 @@ pub struct FixedSizeList<'a> {
 impl<'a> flatbuffers::Follow<'a> for FixedSizeList<'a> {
     type Inner = FixedSizeList<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> FixedSizeList<'a> {
+    pub const VT_LISTSIZE: flatbuffers::VOffsetT = 4;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         FixedSizeList { _tab: table }
     }
     #[allow(unused_mut)]
@@ -1555,14 +1579,17 @@ impl<'a> FixedSizeList<'a> {
         builder.finish()
     }
 
-    pub const VT_LISTSIZE: flatbuffers::VOffsetT = 4;
-
     /// Number of list items per value
     #[inline]
     pub fn listSize(&self) -> i32 {
-        self._tab
-            .get::<i32>(FixedSizeList::VT_LISTSIZE, Some(0))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<i32>(FixedSizeList::VT_LISTSIZE, Some(0))
+                .unwrap()
+        }
     }
 }
 
@@ -1574,7 +1601,7 @@ impl flatbuffers::Verifiable for FixedSizeList<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<i32>(&"listSize", Self::VT_LISTSIZE, false)?
+            .visit_field::<i32>("listSize", Self::VT_LISTSIZE, false)?
             .finish();
         Ok(())
     }
@@ -1588,6 +1615,7 @@ impl<'a> Default for FixedSizeListArgs {
         FixedSizeListArgs { listSize: 0 }
     }
 }
+
 pub struct FixedSizeListBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -1599,9 +1627,7 @@ impl<'a: 'b, 'b> FixedSizeListBuilder<'a, 'b> {
             .push_slot::<i32>(FixedSizeList::VT_LISTSIZE, listSize, 0);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> FixedSizeListBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> FixedSizeListBuilder<'a, 'b> {
         let start = _fbb.start_table();
         FixedSizeListBuilder {
             fbb_: _fbb,
@@ -1615,8 +1641,8 @@ impl<'a: 'b, 'b> FixedSizeListBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for FixedSizeList<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for FixedSizeList<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("FixedSizeList");
         ds.field("listSize", &self.listSize());
         ds.finish()
@@ -1657,16 +1683,18 @@ pub struct Map<'a> {
 impl<'a> flatbuffers::Follow<'a> for Map<'a> {
     type Inner = Map<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Map<'a> {
+    pub const VT_KEYSSORTED: flatbuffers::VOffsetT = 4;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Map { _tab: table }
     }
     #[allow(unused_mut)]
@@ -1679,14 +1707,17 @@ impl<'a> Map<'a> {
         builder.finish()
     }
 
-    pub const VT_KEYSSORTED: flatbuffers::VOffsetT = 4;
-
     /// Set to true if the keys within each value are sorted
     #[inline]
     pub fn keysSorted(&self) -> bool {
-        self._tab
-            .get::<bool>(Map::VT_KEYSSORTED, Some(false))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<bool>(Map::VT_KEYSSORTED, Some(false))
+                .unwrap()
+        }
     }
 }
 
@@ -1698,7 +1729,7 @@ impl flatbuffers::Verifiable for Map<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<bool>(&"keysSorted", Self::VT_KEYSSORTED, false)?
+            .visit_field::<bool>("keysSorted", Self::VT_KEYSSORTED, false)?
             .finish();
         Ok(())
     }
@@ -1712,6 +1743,7 @@ impl<'a> Default for MapArgs {
         MapArgs { keysSorted: false }
     }
 }
+
 pub struct MapBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -1737,8 +1769,8 @@ impl<'a: 'b, 'b> MapBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Map<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Map<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Map");
         ds.field("keysSorted", &self.keysSorted());
         ds.finish()
@@ -1758,16 +1790,19 @@ pub struct Union<'a> {
 impl<'a> flatbuffers::Follow<'a> for Union<'a> {
     type Inner = Union<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Union<'a> {
+    pub const VT_MODE: flatbuffers::VOffsetT = 4;
+    pub const VT_TYPEIDS: flatbuffers::VOffsetT = 6;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Union { _tab: table }
     }
     #[allow(unused_mut)]
@@ -1783,22 +1818,29 @@ impl<'a> Union<'a> {
         builder.finish()
     }
 
-    pub const VT_MODE: flatbuffers::VOffsetT = 4;
-    pub const VT_TYPEIDS: flatbuffers::VOffsetT = 6;
-
     #[inline]
     pub fn mode(&self) -> UnionMode {
-        self._tab
-            .get::<UnionMode>(Union::VT_MODE, Some(UnionMode::Sparse))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<UnionMode>(Union::VT_MODE, Some(UnionMode::Sparse))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn typeIds(&self) -> Option<flatbuffers::Vector<'a, i32>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i32>>>(
-                Union::VT_TYPEIDS,
-                None,
-            )
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i32>>>(
+                    Union::VT_TYPEIDS,
+                    None,
+                )
+        }
     }
 }
 
@@ -1810,9 +1852,9 @@ impl flatbuffers::Verifiable for Union<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<UnionMode>(&"mode", Self::VT_MODE, false)?
+            .visit_field::<UnionMode>("mode", Self::VT_MODE, false)?
             .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, i32>>>(
-                &"typeIds",
+                "typeIds",
                 Self::VT_TYPEIDS,
                 false,
             )?
@@ -1833,6 +1875,7 @@ impl<'a> Default for UnionArgs<'a> {
         }
     }
 }
+
 pub struct UnionBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -1844,10 +1887,7 @@ impl<'a: 'b, 'b> UnionBuilder<'a, 'b> {
             .push_slot::<UnionMode>(Union::VT_MODE, mode, UnionMode::Sparse);
     }
     #[inline]
-    pub fn add_typeIds(
-        &mut self,
-        typeIds: flatbuffers::WIPOffset<flatbuffers::Vector<'b, i32>>,
-    ) {
+    pub fn add_typeIds(&mut self, typeIds: flatbuffers::WIPOffset<flatbuffers::Vector<'b, i32>>) {
         self.fbb_
             .push_slot_always::<flatbuffers::WIPOffset<_>>(Union::VT_TYPEIDS, typeIds);
     }
@@ -1866,8 +1906,8 @@ impl<'a: 'b, 'b> UnionBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Union<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Union<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Union");
         ds.field("mode", &self.mode());
         ds.field("typeIds", &self.typeIds());
@@ -1884,16 +1924,19 @@ pub struct Int<'a> {
 impl<'a> flatbuffers::Follow<'a> for Int<'a> {
     type Inner = Int<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Int<'a> {
+    pub const VT_BITWIDTH: flatbuffers::VOffsetT = 4;
+    pub const VT_IS_SIGNED: flatbuffers::VOffsetT = 6;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Int { _tab: table }
     }
     #[allow(unused_mut)]
@@ -1907,18 +1950,23 @@ impl<'a> Int<'a> {
         builder.finish()
     }
 
-    pub const VT_BITWIDTH: flatbuffers::VOffsetT = 4;
-    pub const VT_IS_SIGNED: flatbuffers::VOffsetT = 6;
-
     #[inline]
     pub fn bitWidth(&self) -> i32 {
-        self._tab.get::<i32>(Int::VT_BITWIDTH, Some(0)).unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<i32>(Int::VT_BITWIDTH, Some(0)).unwrap() }
     }
     #[inline]
     pub fn is_signed(&self) -> bool {
-        self._tab
-            .get::<bool>(Int::VT_IS_SIGNED, Some(false))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<bool>(Int::VT_IS_SIGNED, Some(false))
+                .unwrap()
+        }
     }
 }
 
@@ -1930,8 +1978,8 @@ impl flatbuffers::Verifiable for Int<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<i32>(&"bitWidth", Self::VT_BITWIDTH, false)?
-            .visit_field::<bool>(&"is_signed", Self::VT_IS_SIGNED, false)?
+            .visit_field::<i32>("bitWidth", Self::VT_BITWIDTH, false)?
+            .visit_field::<bool>("is_signed", Self::VT_IS_SIGNED, false)?
             .finish();
         Ok(())
     }
@@ -1949,6 +1997,7 @@ impl<'a> Default for IntArgs {
         }
     }
 }
+
 pub struct IntBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -1978,8 +2027,8 @@ impl<'a: 'b, 'b> IntBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Int<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Int<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Int");
         ds.field("bitWidth", &self.bitWidth());
         ds.field("is_signed", &self.is_signed());
@@ -1996,16 +2045,18 @@ pub struct FloatingPoint<'a> {
 impl<'a> flatbuffers::Follow<'a> for FloatingPoint<'a> {
     type Inner = FloatingPoint<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> FloatingPoint<'a> {
+    pub const VT_PRECISION: flatbuffers::VOffsetT = 4;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         FloatingPoint { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2018,13 +2069,16 @@ impl<'a> FloatingPoint<'a> {
         builder.finish()
     }
 
-    pub const VT_PRECISION: flatbuffers::VOffsetT = 4;
-
     #[inline]
     pub fn precision(&self) -> Precision {
-        self._tab
-            .get::<Precision>(FloatingPoint::VT_PRECISION, Some(Precision::HALF))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<Precision>(FloatingPoint::VT_PRECISION, Some(Precision::HALF))
+                .unwrap()
+        }
     }
 }
 
@@ -2036,7 +2090,7 @@ impl flatbuffers::Verifiable for FloatingPoint<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<Precision>(&"precision", Self::VT_PRECISION, false)?
+            .visit_field::<Precision>("precision", Self::VT_PRECISION, false)?
             .finish();
         Ok(())
     }
@@ -2052,6 +2106,7 @@ impl<'a> Default for FloatingPointArgs {
         }
     }
 }
+
 pub struct FloatingPointBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -2059,16 +2114,11 @@ pub struct FloatingPointBuilder<'a: 'b, 'b> {
 impl<'a: 'b, 'b> FloatingPointBuilder<'a, 'b> {
     #[inline]
     pub fn add_precision(&mut self, precision: Precision) {
-        self.fbb_.push_slot::<Precision>(
-            FloatingPoint::VT_PRECISION,
-            precision,
-            Precision::HALF,
-        );
+        self.fbb_
+            .push_slot::<Precision>(FloatingPoint::VT_PRECISION, precision, Precision::HALF);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> FloatingPointBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> FloatingPointBuilder<'a, 'b> {
         let start = _fbb.start_table();
         FloatingPointBuilder {
             fbb_: _fbb,
@@ -2082,8 +2132,8 @@ impl<'a: 'b, 'b> FloatingPointBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for FloatingPoint<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for FloatingPoint<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("FloatingPoint");
         ds.field("precision", &self.precision());
         ds.finish()
@@ -2100,16 +2150,16 @@ pub struct Utf8<'a> {
 impl<'a> flatbuffers::Follow<'a> for Utf8<'a> {
     type Inner = Utf8<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Utf8<'a> {
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Utf8 { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2140,6 +2190,7 @@ impl<'a> Default for Utf8Args {
         Utf8Args {}
     }
 }
+
 pub struct Utf8Builder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -2160,8 +2211,8 @@ impl<'a: 'b, 'b> Utf8Builder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Utf8<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Utf8<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Utf8");
         ds.finish()
     }
@@ -2177,16 +2228,16 @@ pub struct Binary<'a> {
 impl<'a> flatbuffers::Follow<'a> for Binary<'a> {
     type Inner = Binary<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Binary<'a> {
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Binary { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2217,15 +2268,14 @@ impl<'a> Default for BinaryArgs {
         BinaryArgs {}
     }
 }
+
 pub struct BinaryBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
 }
 impl<'a: 'b, 'b> BinaryBuilder<'a, 'b> {
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> BinaryBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> BinaryBuilder<'a, 'b> {
         let start = _fbb.start_table();
         BinaryBuilder {
             fbb_: _fbb,
@@ -2239,8 +2289,8 @@ impl<'a: 'b, 'b> BinaryBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Binary<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Binary<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Binary");
         ds.finish()
     }
@@ -2257,16 +2307,16 @@ pub struct LargeUtf8<'a> {
 impl<'a> flatbuffers::Follow<'a> for LargeUtf8<'a> {
     type Inner = LargeUtf8<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> LargeUtf8<'a> {
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         LargeUtf8 { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2297,15 +2347,14 @@ impl<'a> Default for LargeUtf8Args {
         LargeUtf8Args {}
     }
 }
+
 pub struct LargeUtf8Builder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
 }
 impl<'a: 'b, 'b> LargeUtf8Builder<'a, 'b> {
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> LargeUtf8Builder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> LargeUtf8Builder<'a, 'b> {
         let start = _fbb.start_table();
         LargeUtf8Builder {
             fbb_: _fbb,
@@ -2319,8 +2368,8 @@ impl<'a: 'b, 'b> LargeUtf8Builder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for LargeUtf8<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for LargeUtf8<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("LargeUtf8");
         ds.finish()
     }
@@ -2337,16 +2386,16 @@ pub struct LargeBinary<'a> {
 impl<'a> flatbuffers::Follow<'a> for LargeBinary<'a> {
     type Inner = LargeBinary<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> LargeBinary<'a> {
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         LargeBinary { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2377,15 +2426,14 @@ impl<'a> Default for LargeBinaryArgs {
         LargeBinaryArgs {}
     }
 }
+
 pub struct LargeBinaryBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
 }
 impl<'a: 'b, 'b> LargeBinaryBuilder<'a, 'b> {
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> LargeBinaryBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> LargeBinaryBuilder<'a, 'b> {
         let start = _fbb.start_table();
         LargeBinaryBuilder {
             fbb_: _fbb,
@@ -2399,8 +2447,8 @@ impl<'a: 'b, 'b> LargeBinaryBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for LargeBinary<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for LargeBinary<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("LargeBinary");
         ds.finish()
     }
@@ -2415,16 +2463,18 @@ pub struct FixedSizeBinary<'a> {
 impl<'a> flatbuffers::Follow<'a> for FixedSizeBinary<'a> {
     type Inner = FixedSizeBinary<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> FixedSizeBinary<'a> {
+    pub const VT_BYTEWIDTH: flatbuffers::VOffsetT = 4;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         FixedSizeBinary { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2437,14 +2487,17 @@ impl<'a> FixedSizeBinary<'a> {
         builder.finish()
     }
 
-    pub const VT_BYTEWIDTH: flatbuffers::VOffsetT = 4;
-
     /// Number of bytes per value
     #[inline]
     pub fn byteWidth(&self) -> i32 {
-        self._tab
-            .get::<i32>(FixedSizeBinary::VT_BYTEWIDTH, Some(0))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<i32>(FixedSizeBinary::VT_BYTEWIDTH, Some(0))
+                .unwrap()
+        }
     }
 }
 
@@ -2456,7 +2509,7 @@ impl flatbuffers::Verifiable for FixedSizeBinary<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<i32>(&"byteWidth", Self::VT_BYTEWIDTH, false)?
+            .visit_field::<i32>("byteWidth", Self::VT_BYTEWIDTH, false)?
             .finish();
         Ok(())
     }
@@ -2470,6 +2523,7 @@ impl<'a> Default for FixedSizeBinaryArgs {
         FixedSizeBinaryArgs { byteWidth: 0 }
     }
 }
+
 pub struct FixedSizeBinaryBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -2481,9 +2535,7 @@ impl<'a: 'b, 'b> FixedSizeBinaryBuilder<'a, 'b> {
             .push_slot::<i32>(FixedSizeBinary::VT_BYTEWIDTH, byteWidth, 0);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> FixedSizeBinaryBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> FixedSizeBinaryBuilder<'a, 'b> {
         let start = _fbb.start_table();
         FixedSizeBinaryBuilder {
             fbb_: _fbb,
@@ -2497,8 +2549,8 @@ impl<'a: 'b, 'b> FixedSizeBinaryBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for FixedSizeBinary<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for FixedSizeBinary<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("FixedSizeBinary");
         ds.field("byteWidth", &self.byteWidth());
         ds.finish()
@@ -2514,16 +2566,16 @@ pub struct Bool<'a> {
 impl<'a> flatbuffers::Follow<'a> for Bool<'a> {
     type Inner = Bool<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Bool<'a> {
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Bool { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2554,6 +2606,7 @@ impl<'a> Default for BoolArgs {
         BoolArgs {}
     }
 }
+
 pub struct BoolBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -2574,12 +2627,94 @@ impl<'a: 'b, 'b> BoolBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Bool<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Bool<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Bool");
         ds.finish()
     }
 }
+pub enum RunEndEncodedOffset {}
+#[derive(Copy, Clone, PartialEq)]
+
+/// Contains two child arrays, run_ends and values.
+/// The run_ends child array must be a 16/32/64-bit integer array
+/// which encodes the indices at which the run with the value in
+/// each corresponding index in the values child array ends.
+/// Like list/struct types, the value array can be of any type.
+pub struct RunEndEncoded<'a> {
+    pub _tab: flatbuffers::Table<'a>,
+}
+
+impl<'a> flatbuffers::Follow<'a> for RunEndEncoded<'a> {
+    type Inner = RunEndEncoded<'a>;
+    #[inline]
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        Self {
+            _tab: flatbuffers::Table::new(buf, loc),
+        }
+    }
+}
+
+impl<'a> RunEndEncoded<'a> {
+    #[inline]
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+        RunEndEncoded { _tab: table }
+    }
+    #[allow(unused_mut)]
+    pub fn create<'bldr: 'args, 'args: 'mut_bldr, 'mut_bldr>(
+        _fbb: &'mut_bldr mut flatbuffers::FlatBufferBuilder<'bldr>,
+        _args: &'args RunEndEncodedArgs,
+    ) -> flatbuffers::WIPOffset<RunEndEncoded<'bldr>> {
+        let mut builder = RunEndEncodedBuilder::new(_fbb);
+        builder.finish()
+    }
+}
+
+impl flatbuffers::Verifiable for RunEndEncoded<'_> {
+    #[inline]
+    fn run_verifier(
+        v: &mut flatbuffers::Verifier,
+        pos: usize,
+    ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
+        use flatbuffers::Verifiable;
+        v.visit_table(pos)?.finish();
+        Ok(())
+    }
+}
+pub struct RunEndEncodedArgs {}
+impl<'a> Default for RunEndEncodedArgs {
+    #[inline]
+    fn default() -> Self {
+        RunEndEncodedArgs {}
+    }
+}
+
+pub struct RunEndEncodedBuilder<'a: 'b, 'b> {
+    fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
+    start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
+}
+impl<'a: 'b, 'b> RunEndEncodedBuilder<'a, 'b> {
+    #[inline]
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> RunEndEncodedBuilder<'a, 'b> {
+        let start = _fbb.start_table();
+        RunEndEncodedBuilder {
+            fbb_: _fbb,
+            start_: start,
+        }
+    }
+    #[inline]
+    pub fn finish(self) -> flatbuffers::WIPOffset<RunEndEncoded<'a>> {
+        let o = self.fbb_.end_table(self.start_);
+        flatbuffers::WIPOffset::new(o.value())
+    }
+}
+
+impl core::fmt::Debug for RunEndEncoded<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        let mut ds = f.debug_struct("RunEndEncoded");
+        ds.finish()
+    }
+}
 pub enum DecimalOffset {}
 #[derive(Copy, Clone, PartialEq)]
 
@@ -2594,16 +2729,20 @@ pub struct Decimal<'a> {
 impl<'a> flatbuffers::Follow<'a> for Decimal<'a> {
     type Inner = Decimal<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Decimal<'a> {
+    pub const VT_PRECISION: flatbuffers::VOffsetT = 4;
+    pub const VT_SCALE: flatbuffers::VOffsetT = 6;
+    pub const VT_BITWIDTH: flatbuffers::VOffsetT = 8;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Decimal { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2618,29 +2757,38 @@ impl<'a> Decimal<'a> {
         builder.finish()
     }
 
-    pub const VT_PRECISION: flatbuffers::VOffsetT = 4;
-    pub const VT_SCALE: flatbuffers::VOffsetT = 6;
-    pub const VT_BITWIDTH: flatbuffers::VOffsetT = 8;
-
     /// Total number of decimal digits
     #[inline]
     pub fn precision(&self) -> i32 {
-        self._tab
-            .get::<i32>(Decimal::VT_PRECISION, Some(0))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<i32>(Decimal::VT_PRECISION, Some(0))
+                .unwrap()
+        }
     }
     /// Number of digits after the decimal point "."
     #[inline]
     pub fn scale(&self) -> i32 {
-        self._tab.get::<i32>(Decimal::VT_SCALE, Some(0)).unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<i32>(Decimal::VT_SCALE, Some(0)).unwrap() }
     }
     /// Number of bits per value. The only accepted widths are 128 and 256.
     /// We use bitWidth for consistency with Int::bitWidth.
     #[inline]
     pub fn bitWidth(&self) -> i32 {
-        self._tab
-            .get::<i32>(Decimal::VT_BITWIDTH, Some(128))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<i32>(Decimal::VT_BITWIDTH, Some(128))
+                .unwrap()
+        }
     }
 }
 
@@ -2652,9 +2800,9 @@ impl flatbuffers::Verifiable for Decimal<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<i32>(&"precision", Self::VT_PRECISION, false)?
-            .visit_field::<i32>(&"scale", Self::VT_SCALE, false)?
-            .visit_field::<i32>(&"bitWidth", Self::VT_BITWIDTH, false)?
+            .visit_field::<i32>("precision", Self::VT_PRECISION, false)?
+            .visit_field::<i32>("scale", Self::VT_SCALE, false)?
+            .visit_field::<i32>("bitWidth", Self::VT_BITWIDTH, false)?
             .finish();
         Ok(())
     }
@@ -2674,6 +2822,7 @@ impl<'a> Default for DecimalArgs {
         }
     }
 }
+
 pub struct DecimalBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -2694,9 +2843,7 @@ impl<'a: 'b, 'b> DecimalBuilder<'a, 'b> {
             .push_slot::<i32>(Decimal::VT_BITWIDTH, bitWidth, 128);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> DecimalBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DecimalBuilder<'a, 'b> {
         let start = _fbb.start_table();
         DecimalBuilder {
             fbb_: _fbb,
@@ -2710,8 +2857,8 @@ impl<'a: 'b, 'b> DecimalBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Decimal<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Decimal<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Decimal");
         ds.field("precision", &self.precision());
         ds.field("scale", &self.scale());
@@ -2722,8 +2869,8 @@ impl std::fmt::Debug for Decimal<'_> {
 pub enum DateOffset {}
 #[derive(Copy, Clone, PartialEq)]
 
-/// Date is either a 32-bit or 64-bit type representing elapsed time since UNIX
-/// epoch (1970-01-01), stored in either of two units:
+/// Date is either a 32-bit or 64-bit signed integer type representing an
+/// elapsed time since UNIX epoch (1970-01-01), stored in either of two units:
 ///
 /// * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no
 ///   leap seconds), where the values are evenly divisible by 86400000
@@ -2735,16 +2882,18 @@ pub struct Date<'a> {
 impl<'a> flatbuffers::Follow<'a> for Date<'a> {
     type Inner = Date<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Date<'a> {
+    pub const VT_UNIT: flatbuffers::VOffsetT = 4;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Date { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2757,13 +2906,16 @@ impl<'a> Date<'a> {
         builder.finish()
     }
 
-    pub const VT_UNIT: flatbuffers::VOffsetT = 4;
-
     #[inline]
     pub fn unit(&self) -> DateUnit {
-        self._tab
-            .get::<DateUnit>(Date::VT_UNIT, Some(DateUnit::MILLISECOND))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<DateUnit>(Date::VT_UNIT, Some(DateUnit::MILLISECOND))
+                .unwrap()
+        }
     }
 }
 
@@ -2775,7 +2927,7 @@ impl flatbuffers::Verifiable for Date<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<DateUnit>(&"unit", Self::VT_UNIT, false)?
+            .visit_field::<DateUnit>("unit", Self::VT_UNIT, false)?
             .finish();
         Ok(())
     }
@@ -2791,6 +2943,7 @@ impl<'a> Default for DateArgs {
         }
     }
 }
+
 pub struct DateBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -2816,8 +2969,8 @@ impl<'a: 'b, 'b> DateBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Date<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Date<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Date");
         ds.field("unit", &self.unit());
         ds.finish()
@@ -2826,9 +2979,20 @@ impl std::fmt::Debug for Date<'_> {
 pub enum TimeOffset {}
 #[derive(Copy, Clone, PartialEq)]
 
-/// Time type. The physical storage type depends on the unit
-/// - SECOND and MILLISECOND: 32 bits
-/// - MICROSECOND and NANOSECOND: 64 bits
+/// Time is either a 32-bit or 64-bit signed integer type representing an
+/// elapsed time since midnight, stored in either of four units: seconds,
+/// milliseconds, microseconds or nanoseconds.
+///
+/// The integer `bitWidth` depends on the `unit` and must be one of the following:
+/// * SECOND and MILLISECOND: 32 bits
+/// * MICROSECOND and NANOSECOND: 64 bits
+///
+/// The allowed values are between 0 (inclusive) and 86400 (=24*60*60) seconds
+/// (exclusive), adjusted for the time unit (for example, up to 86400000
+/// exclusive for the MILLISECOND unit).
+/// This definition doesn't allow for leap seconds. Time values from
+/// measurements with leap seconds will need to be corrected when ingesting
+/// into Arrow (for example by replacing the value 86400 with 86399).
 pub struct Time<'a> {
     pub _tab: flatbuffers::Table<'a>,
 }
@@ -2836,16 +3000,19 @@ pub struct Time<'a> {
 impl<'a> flatbuffers::Follow<'a> for Time<'a> {
     type Inner = Time<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Time<'a> {
+    pub const VT_UNIT: flatbuffers::VOffsetT = 4;
+    pub const VT_BITWIDTH: flatbuffers::VOffsetT = 6;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Time { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2859,18 +3026,23 @@ impl<'a> Time<'a> {
         builder.finish()
     }
 
-    pub const VT_UNIT: flatbuffers::VOffsetT = 4;
-    pub const VT_BITWIDTH: flatbuffers::VOffsetT = 6;
-
     #[inline]
     pub fn unit(&self) -> TimeUnit {
-        self._tab
-            .get::<TimeUnit>(Time::VT_UNIT, Some(TimeUnit::MILLISECOND))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<TimeUnit>(Time::VT_UNIT, Some(TimeUnit::MILLISECOND))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn bitWidth(&self) -> i32 {
-        self._tab.get::<i32>(Time::VT_BITWIDTH, Some(32)).unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<i32>(Time::VT_BITWIDTH, Some(32)).unwrap() }
     }
 }
 
@@ -2882,8 +3054,8 @@ impl flatbuffers::Verifiable for Time<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<TimeUnit>(&"unit", Self::VT_UNIT, false)?
-            .visit_field::<i32>(&"bitWidth", Self::VT_BITWIDTH, false)?
+            .visit_field::<TimeUnit>("unit", Self::VT_UNIT, false)?
+            .visit_field::<i32>("bitWidth", Self::VT_BITWIDTH, false)?
             .finish();
         Ok(())
     }
@@ -2901,6 +3073,7 @@ impl<'a> Default for TimeArgs {
         }
     }
 }
+
 pub struct TimeBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -2930,8 +3103,8 @@ impl<'a: 'b, 'b> TimeBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Time<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Time<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Time");
         ds.field("unit", &self.unit());
         ds.field("bitWidth", &self.bitWidth());
@@ -2941,12 +3114,111 @@ impl std::fmt::Debug for Time<'_> {
 pub enum TimestampOffset {}
 #[derive(Copy, Clone, PartialEq)]
 
-/// Time elapsed from the Unix epoch, 00:00:00.000 on 1 January 1970, excluding
-/// leap seconds, as a 64-bit integer. Note that UNIX time does not include
-/// leap seconds.
+/// Timestamp is a 64-bit signed integer representing an elapsed time since a
+/// fixed epoch, stored in either of four units: seconds, milliseconds,
+/// microseconds or nanoseconds, and is optionally annotated with a timezone.
+///
+/// Timestamp values do not include any leap seconds (in other words, all
+/// days are considered 86400 seconds long).
+///
+/// Timestamps with a non-empty timezone
+/// ------------------------------------
+///
+/// If a Timestamp column has a non-empty timezone value, its epoch is
+/// 1970-01-01 00:00:00 (January 1st 1970, midnight) in the *UTC* timezone
+/// (the Unix epoch), regardless of the Timestamp's own timezone.
+///
+/// Therefore, timestamp values with a non-empty timezone correspond to
+/// physical points in time together with some additional information about
+/// how the data was obtained and/or how to display it (the timezone).
+///
+///   For example, the timestamp value 0 with the timezone string "Europe/Paris"
+///   corresponds to "January 1st 1970, 00h00" in the UTC timezone, but the
+///   application may prefer to display it as "January 1st 1970, 01h00" in
+///   the Europe/Paris timezone (which is the same physical point in time).
+///
+/// One consequence is that timestamp values with a non-empty timezone
+/// can be compared and ordered directly, since they all share the same
+/// well-known point of reference (the Unix epoch).
+///
+/// Timestamps with an unset / empty timezone
+/// -----------------------------------------
+///
+/// If a Timestamp column has no timezone value, its epoch is
+/// 1970-01-01 00:00:00 (January 1st 1970, midnight) in an *unknown* timezone.
+///
+/// Therefore, timestamp values without a timezone cannot be meaningfully
+/// interpreted as physical points in time, but only as calendar / clock
+/// indications ("wall clock time") in an unspecified timezone.
+///
+///   For example, the timestamp value 0 with an empty timezone string
+///   corresponds to "January 1st 1970, 00h00" in an unknown timezone: there
+///   is not enough information to interpret it as a well-defined physical
+///   point in time.
 ///
-/// The Timestamp metadata supports both "time zone naive" and "time zone
-/// aware" timestamps. Read about the timezone attribute for more detail
+/// One consequence is that timestamp values without a timezone cannot
+/// be reliably compared or ordered, since they may have different points of
+/// reference.  In particular, it is *not* possible to interpret an unset
+/// or empty timezone as the same as "UTC".
+///
+/// Conversion between timezones
+/// ----------------------------
+///
+/// If a Timestamp column has a non-empty timezone, changing the timezone
+/// to a different non-empty value is a metadata-only operation:
+/// the timestamp values need not change as their point of reference remains
+/// the same (the Unix epoch).
+///
+/// However, if a Timestamp column has no timezone value, changing it to a
+/// non-empty value requires to think about the desired semantics.
+/// One possibility is to assume that the original timestamp values are
+/// relative to the epoch of the timezone being set; timestamp values should
+/// then adjusted to the Unix epoch (for example, changing the timezone from
+/// empty to "Europe/Paris" would require converting the timestamp values
+/// from "Europe/Paris" to "UTC", which seems counter-intuitive but is
+/// nevertheless correct).
+///
+/// Guidelines for encoding data from external libraries
+/// ----------------------------------------------------
+///
+/// Date & time libraries often have multiple different data types for temporal
+/// data. In order to ease interoperability between different implementations the
+/// Arrow project has some recommendations for encoding these types into a Timestamp
+/// column.
+///
+/// An "instant" represents a physical point in time that has no relevant timezone
+/// (for example, astronomical data). To encode an instant, use a Timestamp with
+/// the timezone string set to "UTC", and make sure the Timestamp values
+/// are relative to the UTC epoch (January 1st 1970, midnight).
+///
+/// A "zoned date-time" represents a physical point in time annotated with an
+/// informative timezone (for example, the timezone in which the data was
+/// recorded).  To encode a zoned date-time, use a Timestamp with the timezone
+/// string set to the name of the timezone, and make sure the Timestamp values
+/// are relative to the UTC epoch (January 1st 1970, midnight).
+///
+///  (There is some ambiguity between an instant and a zoned date-time with the
+///   UTC timezone.  Both of these are stored the same in Arrow.  Typically,
+///   this distinction does not matter.  If it does, then an application should
+///   use custom metadata or an extension type to distinguish between the two cases.)
+///
+/// An "offset date-time" represents a physical point in time combined with an
+/// explicit offset from UTC.  To encode an offset date-time, use a Timestamp
+/// with the timezone string set to the numeric timezone offset string
+/// (e.g. "+03:00"), and make sure the Timestamp values are relative to
+/// the UTC epoch (January 1st 1970, midnight).
+///
+/// A "naive date-time" (also called "local date-time" in some libraries)
+/// represents a wall clock time combined with a calendar date, but with
+/// no indication of how to map this information to a physical point in time.
+/// Naive date-times must be handled with care because of this missing
+/// information, and also because daylight saving time (DST) may make
+/// some values ambiguous or non-existent. A naive date-time may be
+/// stored as a struct with Date and Time fields. However, it may also be
+/// encoded into a Timestamp column with an empty timezone. The timestamp
+/// values should be computed "as if" the timezone of the date-time values
+/// was UTC; for example, the naive date-time "January 1st 1970, 00h00" would
+/// be encoded as timestamp value 0.
 pub struct Timestamp<'a> {
     pub _tab: flatbuffers::Table<'a>,
 }
@@ -2954,16 +3226,19 @@ pub struct Timestamp<'a> {
 impl<'a> flatbuffers::Follow<'a> for Timestamp<'a> {
     type Inner = Timestamp<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Timestamp<'a> {
+    pub const VT_UNIT: flatbuffers::VOffsetT = 4;
+    pub const VT_TIMEZONE: flatbuffers::VOffsetT = 6;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Timestamp { _tab: table }
     }
     #[allow(unused_mut)]
@@ -2979,39 +3254,36 @@ impl<'a> Timestamp<'a> {
         builder.finish()
     }
 
-    pub const VT_UNIT: flatbuffers::VOffsetT = 4;
-    pub const VT_TIMEZONE: flatbuffers::VOffsetT = 6;
-
     #[inline]
     pub fn unit(&self) -> TimeUnit {
-        self._tab
-            .get::<TimeUnit>(Timestamp::VT_UNIT, Some(TimeUnit::SECOND))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<TimeUnit>(Timestamp::VT_UNIT, Some(TimeUnit::SECOND))
+                .unwrap()
+        }
     }
-    /// The time zone is a string indicating the name of a time zone, one of:
+    /// The timezone is an optional string indicating the name of a timezone,
+    /// one of:
     ///
-    /// * As used in the Olson time zone database (the "tz database" or
-    ///   "tzdata"), such as "America/New_York"
-    /// * An absolute time zone offset of the form +XX:XX or -XX:XX, such as +07:30
+    /// * As used in the Olson timezone database (the "tz database" or
+    ///   "tzdata"), such as "America/New_York".
+    /// * An absolute timezone offset of the form "+XX:XX" or "-XX:XX",
+    ///   such as "+07:30".
     ///
     /// Whether a timezone string is present indicates different semantics about
-    /// the data:
-    ///
-    /// * If the time zone is null or equal to an empty string, the data is "time
-    ///   zone naive" and shall be displayed *as is* to the user, not localized
-    ///   to the locale of the user. This data can be though of as UTC but
-    ///   without having "UTC" as the time zone, it is not considered to be
-    ///   localized to any time zone
-    ///
-    /// * If the time zone is set to a valid value, values can be displayed as
-    ///   "localized" to that time zone, even though the underlying 64-bit
-    ///   integers are identical to the same data stored in UTC. Converting
-    ///   between time zones is a metadata-only operation and does not change the
-    ///   underlying values
+    /// the data (see above).
     #[inline]
     pub fn timezone(&self) -> Option<&'a str> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<&str>>(Timestamp::VT_TIMEZONE, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<&str>>(Timestamp::VT_TIMEZONE, None)
+        }
     }
 }
 
@@ -3023,9 +3295,9 @@ impl flatbuffers::Verifiable for Timestamp<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<TimeUnit>(&"unit", Self::VT_UNIT, false)?
+            .visit_field::<TimeUnit>("unit", Self::VT_UNIT, false)?
             .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                &"timezone",
+                "timezone",
                 Self::VT_TIMEZONE,
                 false,
             )?
@@ -3046,6 +3318,7 @@ impl<'a> Default for TimestampArgs<'a> {
         }
     }
 }
+
 pub struct TimestampBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -3058,15 +3331,11 @@ impl<'a: 'b, 'b> TimestampBuilder<'a, 'b> {
     }
     #[inline]
     pub fn add_timezone(&mut self, timezone: flatbuffers::WIPOffset<&'b str>) {
-        self.fbb_.push_slot_always::<flatbuffers::WIPOffset<_>>(
-            Timestamp::VT_TIMEZONE,
-            timezone,
-        );
+        self.fbb_
+            .push_slot_always::<flatbuffers::WIPOffset<_>>(Timestamp::VT_TIMEZONE, timezone);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> TimestampBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TimestampBuilder<'a, 'b> {
         let start = _fbb.start_table();
         TimestampBuilder {
             fbb_: _fbb,
@@ -3080,8 +3349,8 @@ impl<'a: 'b, 'b> TimestampBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Timestamp<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Timestamp<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Timestamp");
         ds.field("unit", &self.unit());
         ds.field("timezone", &self.timezone());
@@ -3098,16 +3367,18 @@ pub struct Interval<'a> {
 impl<'a> flatbuffers::Follow<'a> for Interval<'a> {
     type Inner = Interval<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Interval<'a> {
+    pub const VT_UNIT: flatbuffers::VOffsetT = 4;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Interval { _tab: table }
     }
     #[allow(unused_mut)]
@@ -3120,13 +3391,16 @@ impl<'a> Interval<'a> {
         builder.finish()
     }
 
-    pub const VT_UNIT: flatbuffers::VOffsetT = 4;
-
     #[inline]
     pub fn unit(&self) -> IntervalUnit {
-        self._tab
-            .get::<IntervalUnit>(Interval::VT_UNIT, Some(IntervalUnit::YEAR_MONTH))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<IntervalUnit>(Interval::VT_UNIT, Some(IntervalUnit::YEAR_MONTH))
+                .unwrap()
+        }
     }
 }
 
@@ -3138,7 +3412,7 @@ impl flatbuffers::Verifiable for Interval<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<IntervalUnit>(&"unit", Self::VT_UNIT, false)?
+            .visit_field::<IntervalUnit>("unit", Self::VT_UNIT, false)?
             .finish();
         Ok(())
     }
@@ -3154,6 +3428,7 @@ impl<'a> Default for IntervalArgs {
         }
     }
 }
+
 pub struct IntervalBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -3161,16 +3436,11 @@ pub struct IntervalBuilder<'a: 'b, 'b> {
 impl<'a: 'b, 'b> IntervalBuilder<'a, 'b> {
     #[inline]
     pub fn add_unit(&mut self, unit: IntervalUnit) {
-        self.fbb_.push_slot::<IntervalUnit>(
-            Interval::VT_UNIT,
-            unit,
-            IntervalUnit::YEAR_MONTH,
-        );
+        self.fbb_
+            .push_slot::<IntervalUnit>(Interval::VT_UNIT, unit, IntervalUnit::YEAR_MONTH);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> IntervalBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> IntervalBuilder<'a, 'b> {
         let start = _fbb.start_table();
         IntervalBuilder {
             fbb_: _fbb,
@@ -3184,8 +3454,8 @@ impl<'a: 'b, 'b> IntervalBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Interval<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Interval<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Interval");
         ds.field("unit", &self.unit());
         ds.finish()
@@ -3201,16 +3471,18 @@ pub struct Duration<'a> {
 impl<'a> flatbuffers::Follow<'a> for Duration<'a> {
     type Inner = Duration<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Duration<'a> {
+    pub const VT_UNIT: flatbuffers::VOffsetT = 4;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Duration { _tab: table }
     }
     #[allow(unused_mut)]
@@ -3223,13 +3495,16 @@ impl<'a> Duration<'a> {
         builder.finish()
     }
 
-    pub const VT_UNIT: flatbuffers::VOffsetT = 4;
-
     #[inline]
     pub fn unit(&self) -> TimeUnit {
-        self._tab
-            .get::<TimeUnit>(Duration::VT_UNIT, Some(TimeUnit::MILLISECOND))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<TimeUnit>(Duration::VT_UNIT, Some(TimeUnit::MILLISECOND))
+                .unwrap()
+        }
     }
 }
 
@@ -3241,7 +3516,7 @@ impl flatbuffers::Verifiable for Duration<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<TimeUnit>(&"unit", Self::VT_UNIT, false)?
+            .visit_field::<TimeUnit>("unit", Self::VT_UNIT, false)?
             .finish();
         Ok(())
     }
@@ -3257,6 +3532,7 @@ impl<'a> Default for DurationArgs {
         }
     }
 }
+
 pub struct DurationBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -3268,9 +3544,7 @@ impl<'a: 'b, 'b> DurationBuilder<'a, 'b> {
             .push_slot::<TimeUnit>(Duration::VT_UNIT, unit, TimeUnit::MILLISECOND);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> DurationBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> DurationBuilder<'a, 'b> {
         let start = _fbb.start_table();
         DurationBuilder {
             fbb_: _fbb,
@@ -3284,8 +3558,8 @@ impl<'a: 'b, 'b> DurationBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Duration<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Duration<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Duration");
         ds.field("unit", &self.unit());
         ds.finish()
@@ -3304,16 +3578,19 @@ pub struct KeyValue<'a> {
 impl<'a> flatbuffers::Follow<'a> for KeyValue<'a> {
     type Inner = KeyValue<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> KeyValue<'a> {
+    pub const VT_KEY: flatbuffers::VOffsetT = 4;
+    pub const VT_VALUE: flatbuffers::VOffsetT = 6;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         KeyValue { _tab: table }
     }
     #[allow(unused_mut)]
@@ -3331,18 +3608,25 @@ impl<'a> KeyValue<'a> {
         builder.finish()
     }
 
-    pub const VT_KEY: flatbuffers::VOffsetT = 4;
-    pub const VT_VALUE: flatbuffers::VOffsetT = 6;
-
     #[inline]
     pub fn key(&self) -> Option<&'a str> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<&str>>(KeyValue::VT_KEY, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<&str>>(KeyValue::VT_KEY, None)
+        }
     }
     #[inline]
     pub fn value(&self) -> Option<&'a str> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<&str>>(KeyValue::VT_VALUE, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<&str>>(KeyValue::VT_VALUE, None)
+        }
     }
 }
 
@@ -3354,16 +3638,8 @@ impl flatbuffers::Verifiable for KeyValue<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                &"key",
-                Self::VT_KEY,
-                false,
-            )?
-            .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                &"value",
-                Self::VT_VALUE,
-                false,
-            )?
+            .visit_field::<flatbuffers::ForwardsUOffset<&str>>("key", Self::VT_KEY, false)?
+            .visit_field::<flatbuffers::ForwardsUOffset<&str>>("value", Self::VT_VALUE, false)?
             .finish();
         Ok(())
     }
@@ -3381,6 +3657,7 @@ impl<'a> Default for KeyValueArgs<'a> {
         }
     }
 }
+
 pub struct KeyValueBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -3397,9 +3674,7 @@ impl<'a: 'b, 'b> KeyValueBuilder<'a, 'b> {
             .push_slot_always::<flatbuffers::WIPOffset<_>>(KeyValue::VT_VALUE, value);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> KeyValueBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> KeyValueBuilder<'a, 'b> {
         let start = _fbb.start_table();
         KeyValueBuilder {
             fbb_: _fbb,
@@ -3413,8 +3688,8 @@ impl<'a: 'b, 'b> KeyValueBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for KeyValue<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for KeyValue<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("KeyValue");
         ds.field("key", &self.key());
         ds.field("value", &self.value());
@@ -3431,16 +3706,21 @@ pub struct DictionaryEncoding<'a> {
 impl<'a> flatbuffers::Follow<'a> for DictionaryEncoding<'a> {
     type Inner = DictionaryEncoding<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> DictionaryEncoding<'a> {
+    pub const VT_ID: flatbuffers::VOffsetT = 4;
+    pub const VT_INDEXTYPE: flatbuffers::VOffsetT = 6;
+    pub const VT_ISORDERED: flatbuffers::VOffsetT = 8;
+    pub const VT_DICTIONARYKIND: flatbuffers::VOffsetT = 10;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         DictionaryEncoding { _tab: table }
     }
     #[allow(unused_mut)]
@@ -3458,19 +3738,19 @@ impl<'a> DictionaryEncoding<'a> {
         builder.finish()
     }
 
-    pub const VT_ID: flatbuffers::VOffsetT = 4;
-    pub const VT_INDEXTYPE: flatbuffers::VOffsetT = 6;
-    pub const VT_ISORDERED: flatbuffers::VOffsetT = 8;
-    pub const VT_DICTIONARYKIND: flatbuffers::VOffsetT = 10;
-
     /// The known dictionary id in the application where this data is used. In
     /// the file or streaming formats, the dictionary ids are found in the
     /// DictionaryBatch messages
     #[inline]
     pub fn id(&self) -> i64 {
-        self._tab
-            .get::<i64>(DictionaryEncoding::VT_ID, Some(0))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<i64>(DictionaryEncoding::VT_ID, Some(0))
+                .unwrap()
+        }
     }
     /// The dictionary indices are constrained to be non-negative integers. If
     /// this field is null, the indices must be signed int32. To maximize
@@ -3479,10 +3759,13 @@ impl<'a> DictionaryEncoding<'a> {
     /// and to avoid uint64 indices unless they are required by an application.
     #[inline]
     pub fn indexType(&self) -> Option<Int<'a>> {
-        self._tab.get::<flatbuffers::ForwardsUOffset<Int>>(
-            DictionaryEncoding::VT_INDEXTYPE,
-            None,
-        )
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<Int>>(DictionaryEncoding::VT_INDEXTYPE, None)
+        }
     }
     /// By default, dictionaries are not ordered, or the order does not have
     /// semantic meaning. In some statistical, applications, dictionary-encoding
@@ -3490,18 +3773,28 @@ impl<'a> DictionaryEncoding<'a> {
     /// preserve that metadata here
     #[inline]
     pub fn isOrdered(&self) -> bool {
-        self._tab
-            .get::<bool>(DictionaryEncoding::VT_ISORDERED, Some(false))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<bool>(DictionaryEncoding::VT_ISORDERED, Some(false))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn dictionaryKind(&self) -> DictionaryKind {
-        self._tab
-            .get::<DictionaryKind>(
-                DictionaryEncoding::VT_DICTIONARYKIND,
-                Some(DictionaryKind::DenseArray),
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<DictionaryKind>(
+                    DictionaryEncoding::VT_DICTIONARYKIND,
+                    Some(DictionaryKind::DenseArray),
+                )
+                .unwrap()
+        }
     }
 }
 
@@ -3513,18 +3806,14 @@ impl flatbuffers::Verifiable for DictionaryEncoding<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<i64>(&"id", Self::VT_ID, false)?
+            .visit_field::<i64>("id", Self::VT_ID, false)?
             .visit_field::<flatbuffers::ForwardsUOffset<Int>>(
-                &"indexType",
+                "indexType",
                 Self::VT_INDEXTYPE,
                 false,
             )?
-            .visit_field::<bool>(&"isOrdered", Self::VT_ISORDERED, false)?
-            .visit_field::<DictionaryKind>(
-                &"dictionaryKind",
-                Self::VT_DICTIONARYKIND,
-                false,
-            )?
+            .visit_field::<bool>("isOrdered", Self::VT_ISORDERED, false)?
+            .visit_field::<DictionaryKind>("dictionaryKind", Self::VT_DICTIONARYKIND, false)?
             .finish();
         Ok(())
     }
@@ -3546,6 +3835,7 @@ impl<'a> Default for DictionaryEncodingArgs<'a> {
         }
     }
 }
+
 pub struct DictionaryEncodingBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -3592,8 +3882,8 @@ impl<'a: 'b, 'b> DictionaryEncodingBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for DictionaryEncoding<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for DictionaryEncoding<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("DictionaryEncoding");
         ds.field("id", &self.id());
         ds.field("indexType", &self.indexType());
@@ -3615,16 +3905,24 @@ pub struct Field<'a> {
 impl<'a> flatbuffers::Follow<'a> for Field<'a> {
     type Inner = Field<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Field<'a> {
+    pub const VT_NAME: flatbuffers::VOffsetT = 4;
+    pub const VT_NULLABLE: flatbuffers::VOffsetT = 6;
+    pub const VT_TYPE_TYPE: flatbuffers::VOffsetT = 8;
+    pub const VT_TYPE_: flatbuffers::VOffsetT = 10;
+    pub const VT_DICTIONARY: flatbuffers::VOffsetT = 12;
+    pub const VT_CHILDREN: flatbuffers::VOffsetT = 14;
+    pub const VT_CUSTOM_METADATA: flatbuffers::VOffsetT = 16;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Field { _tab: table }
     }
     #[allow(unused_mut)]
@@ -3653,50 +3951,61 @@ impl<'a> Field<'a> {
         builder.finish()
     }
 
-    pub const VT_NAME: flatbuffers::VOffsetT = 4;
-    pub const VT_NULLABLE: flatbuffers::VOffsetT = 6;
-    pub const VT_TYPE_TYPE: flatbuffers::VOffsetT = 8;
-    pub const VT_TYPE_: flatbuffers::VOffsetT = 10;
-    pub const VT_DICTIONARY: flatbuffers::VOffsetT = 12;
-    pub const VT_CHILDREN: flatbuffers::VOffsetT = 14;
-    pub const VT_CUSTOM_METADATA: flatbuffers::VOffsetT = 16;
-
     /// Name is not required, in i.e. a List
     #[inline]
     pub fn name(&self) -> Option<&'a str> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<&str>>(Field::VT_NAME, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<&str>>(Field::VT_NAME, None)
+        }
     }
     /// Whether or not this field can contain nulls. Should be true in general.
     #[inline]
     pub fn nullable(&self) -> bool {
-        self._tab
-            .get::<bool>(Field::VT_NULLABLE, Some(false))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<bool>(Field::VT_NULLABLE, Some(false))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn type_type(&self) -> Type {
-        self._tab
-            .get::<Type>(Field::VT_TYPE_TYPE, Some(Type::NONE))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<Type>(Field::VT_TYPE_TYPE, Some(Type::NONE))
+                .unwrap()
+        }
     }
     /// This is the type of the decoded value if the field is dictionary encoded.
     #[inline]
     pub fn type_(&self) -> Option<flatbuffers::Table<'a>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
-                Field::VT_TYPE_,
-                None,
-            )
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(Field::VT_TYPE_, None)
+        }
     }
     /// Present only if the field is dictionary encoded.
     #[inline]
     pub fn dictionary(&self) -> Option<DictionaryEncoding<'a>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<DictionaryEncoding>>(
-                Field::VT_DICTIONARY,
-                None,
-            )
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<DictionaryEncoding>>(Field::VT_DICTIONARY, None)
+        }
     }
     /// children apply only to nested data types like Struct, List and Union. For
     /// primitive types children will have length 0.
@@ -3704,24 +4013,39 @@ impl<'a> Field<'a> {
     pub fn children(
         &self,
     ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field<'a>>>> {
-        self._tab.get::<flatbuffers::ForwardsUOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field>>,
-        >>(Field::VT_CHILDREN, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab.get::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field>>,
+            >>(Field::VT_CHILDREN, None)
+        }
     }
     /// User-defined metadata
     #[inline]
     pub fn custom_metadata(
         &self,
     ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>> {
-        self._tab.get::<flatbuffers::ForwardsUOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue>>,
-        >>(Field::VT_CUSTOM_METADATA, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab.get::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue>>,
+            >>(Field::VT_CUSTOM_METADATA, None)
+        }
     }
     #[inline]
     #[allow(non_snake_case)]
     pub fn type_as_null(&self) -> Option<Null<'a>> {
         if self.type_type() == Type::Null {
-            self.type_().map(Null::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Null::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3731,7 +4055,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_int(&self) -> Option<Int<'a>> {
         if self.type_type() == Type::Int {
-            self.type_().map(Int::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Int::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3741,7 +4070,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_floating_point(&self) -> Option<FloatingPoint<'a>> {
         if self.type_type() == Type::FloatingPoint {
-            self.type_().map(FloatingPoint::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { FloatingPoint::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3751,7 +4085,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_binary(&self) -> Option<Binary<'a>> {
         if self.type_type() == Type::Binary {
-            self.type_().map(Binary::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Binary::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3761,7 +4100,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_utf_8(&self) -> Option<Utf8<'a>> {
         if self.type_type() == Type::Utf8 {
-            self.type_().map(Utf8::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Utf8::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3771,7 +4115,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_bool(&self) -> Option<Bool<'a>> {
         if self.type_type() == Type::Bool {
-            self.type_().map(Bool::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Bool::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3781,7 +4130,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_decimal(&self) -> Option<Decimal<'a>> {
         if self.type_type() == Type::Decimal {
-            self.type_().map(Decimal::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Decimal::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3791,7 +4145,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_date(&self) -> Option<Date<'a>> {
         if self.type_type() == Type::Date {
-            self.type_().map(Date::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Date::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3801,7 +4160,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_time(&self) -> Option<Time<'a>> {
         if self.type_type() == Type::Time {
-            self.type_().map(Time::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Time::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3811,7 +4175,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_timestamp(&self) -> Option<Timestamp<'a>> {
         if self.type_type() == Type::Timestamp {
-            self.type_().map(Timestamp::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Timestamp::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3821,7 +4190,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_interval(&self) -> Option<Interval<'a>> {
         if self.type_type() == Type::Interval {
-            self.type_().map(Interval::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Interval::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3831,7 +4205,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_list(&self) -> Option<List<'a>> {
         if self.type_type() == Type::List {
-            self.type_().map(List::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { List::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3841,7 +4220,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_struct_(&self) -> Option<Struct_<'a>> {
         if self.type_type() == Type::Struct_ {
-            self.type_().map(Struct_::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Struct_::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3851,7 +4235,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_union(&self) -> Option<Union<'a>> {
         if self.type_type() == Type::Union {
-            self.type_().map(Union::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Union::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3861,7 +4250,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_fixed_size_binary(&self) -> Option<FixedSizeBinary<'a>> {
         if self.type_type() == Type::FixedSizeBinary {
-            self.type_().map(FixedSizeBinary::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { FixedSizeBinary::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3871,7 +4265,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_fixed_size_list(&self) -> Option<FixedSizeList<'a>> {
         if self.type_type() == Type::FixedSizeList {
-            self.type_().map(FixedSizeList::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { FixedSizeList::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3881,7 +4280,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_map(&self) -> Option<Map<'a>> {
         if self.type_type() == Type::Map {
-            self.type_().map(Map::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Map::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3891,7 +4295,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_duration(&self) -> Option<Duration<'a>> {
         if self.type_type() == Type::Duration {
-            self.type_().map(Duration::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { Duration::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3901,7 +4310,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_large_binary(&self) -> Option<LargeBinary<'a>> {
         if self.type_type() == Type::LargeBinary {
-            self.type_().map(LargeBinary::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { LargeBinary::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3911,7 +4325,12 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_large_utf_8(&self) -> Option<LargeUtf8<'a>> {
         if self.type_type() == Type::LargeUtf8 {
-            self.type_().map(LargeUtf8::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { LargeUtf8::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3921,7 +4340,27 @@ impl<'a> Field<'a> {
     #[allow(non_snake_case)]
     pub fn type_as_large_list(&self) -> Option<LargeList<'a>> {
         if self.type_type() == Type::LargeList {
-            self.type_().map(LargeList::init_from_table)
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { LargeList::init_from_table(t) }
+            })
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[allow(non_snake_case)]
+    pub fn type_as_run_end_encoded(&self) -> Option<RunEndEncoded<'a>> {
+        if self.type_type() == Type::RunEndEncoded {
+            self.type_().map(|t| {
+                // Safety:
+                // Created from a valid Table for this object
+                // Which contains a valid union in this slot
+                unsafe { RunEndEncoded::init_from_table(t) }
+            })
         } else {
             None
         }
@@ -3936,38 +4375,130 @@ impl flatbuffers::Verifiable for Field<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-     .visit_field::<flatbuffers::ForwardsUOffset<&str>>(&"name", Self::VT_NAME, false)?
-     .visit_field::<bool>(&"nullable", Self::VT_NULLABLE, false)?
-     .visit_union::<Type, _>(&"type_type", Self::VT_TYPE_TYPE, &"type_", Self::VT_TYPE_, false, |key, v, pos| {
-        match key {
-          Type::Null => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Null>>("Type::Null", pos),
-          Type::Int => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Int>>("Type::Int", pos),
-          Type::FloatingPoint => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FloatingPoint>>("Type::FloatingPoint", pos),
-          Type::Binary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Binary>>("Type::Binary", pos),
-          Type::Utf8 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Utf8>>("Type::Utf8", pos),
-          Type::Bool => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Bool>>("Type::Bool", pos),
-          Type::Decimal => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Decimal>>("Type::Decimal", pos),
-          Type::Date => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Date>>("Type::Date", pos),
-          Type::Time => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Time>>("Type::Time", pos),
-          Type::Timestamp => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Timestamp>>("Type::Timestamp", pos),
-          Type::Interval => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Interval>>("Type::Interval", pos),
-          Type::List => v.verify_union_variant::<flatbuffers::ForwardsUOffset<List>>("Type::List", pos),
-          Type::Struct_ => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Struct_>>("Type::Struct_", pos),
-          Type::Union => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Union>>("Type::Union", pos),
-          Type::FixedSizeBinary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeBinary>>("Type::FixedSizeBinary", pos),
-          Type::FixedSizeList => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeList>>("Type::FixedSizeList", pos),
-          Type::Map => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Map>>("Type::Map", pos),
-          Type::Duration => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Duration>>("Type::Duration", pos),
-          Type::LargeBinary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<LargeBinary>>("Type::LargeBinary", pos),
-          Type::LargeUtf8 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<LargeUtf8>>("Type::LargeUtf8", pos),
-          Type::LargeList => v.verify_union_variant::<flatbuffers::ForwardsUOffset<LargeList>>("Type::LargeList", pos),
-          _ => Ok(()),
-        }
-     })?
-     .visit_field::<flatbuffers::ForwardsUOffset<DictionaryEncoding>>(&"dictionary", Self::VT_DICTIONARY, false)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Field>>>>(&"children", Self::VT_CHILDREN, false)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>>>(&"custom_metadata", Self::VT_CUSTOM_METADATA, false)?
-     .finish();
+            .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
+            .visit_field::<bool>("nullable", Self::VT_NULLABLE, false)?
+            .visit_union::<Type, _>(
+                "type_type",
+                Self::VT_TYPE_TYPE,
+                "type_",
+                Self::VT_TYPE_,
+                false,
+                |key, v, pos| match key {
+                    Type::Null => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Null>>(
+                        "Type::Null",
+                        pos,
+                    ),
+                    Type::Int => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Int>>(
+                        "Type::Int",
+                        pos,
+                    ),
+                    Type::FloatingPoint => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<FloatingPoint>>(
+                            "Type::FloatingPoint",
+                            pos,
+                        ),
+                    Type::Binary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Binary>>(
+                        "Type::Binary",
+                        pos,
+                    ),
+                    Type::Utf8 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Utf8>>(
+                        "Type::Utf8",
+                        pos,
+                    ),
+                    Type::Bool => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Bool>>(
+                        "Type::Bool",
+                        pos,
+                    ),
+                    Type::Decimal => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Decimal>>(
+                            "Type::Decimal",
+                            pos,
+                        ),
+                    Type::Date => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Date>>(
+                        "Type::Date",
+                        pos,
+                    ),
+                    Type::Time => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Time>>(
+                        "Type::Time",
+                        pos,
+                    ),
+                    Type::Timestamp => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Timestamp>>(
+                            "Type::Timestamp",
+                            pos,
+                        ),
+                    Type::Interval => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Interval>>(
+                            "Type::Interval",
+                            pos,
+                        ),
+                    Type::List => v.verify_union_variant::<flatbuffers::ForwardsUOffset<List>>(
+                        "Type::List",
+                        pos,
+                    ),
+                    Type::Struct_ => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Struct_>>(
+                            "Type::Struct_",
+                            pos,
+                        ),
+                    Type::Union => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Union>>(
+                        "Type::Union",
+                        pos,
+                    ),
+                    Type::FixedSizeBinary => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeBinary>>(
+                            "Type::FixedSizeBinary",
+                            pos,
+                        ),
+                    Type::FixedSizeList => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeList>>(
+                            "Type::FixedSizeList",
+                            pos,
+                        ),
+                    Type::Map => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Map>>(
+                        "Type::Map",
+                        pos,
+                    ),
+                    Type::Duration => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Duration>>(
+                            "Type::Duration",
+                            pos,
+                        ),
+                    Type::LargeBinary => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<LargeBinary>>(
+                            "Type::LargeBinary",
+                            pos,
+                        ),
+                    Type::LargeUtf8 => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<LargeUtf8>>(
+                            "Type::LargeUtf8",
+                            pos,
+                        ),
+                    Type::LargeList => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<LargeList>>(
+                            "Type::LargeList",
+                            pos,
+                        ),
+                    Type::RunEndEncoded => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<RunEndEncoded>>(
+                            "Type::RunEndEncoded",
+                            pos,
+                        ),
+                    _ => Ok(()),
+                },
+            )?
+            .visit_field::<flatbuffers::ForwardsUOffset<DictionaryEncoding>>(
+                "dictionary",
+                Self::VT_DICTIONARY,
+                false,
+            )?
+            .visit_field::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Field>>,
+            >>("children", Self::VT_CHILDREN, false)?
+            .visit_field::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>,
+            >>("custom_metadata", Self::VT_CUSTOM_METADATA, false)?
+            .finish();
         Ok(())
     }
 }
@@ -3978,14 +4509,10 @@ pub struct FieldArgs<'a> {
     pub type_: Option<flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>>,
     pub dictionary: Option<flatbuffers::WIPOffset<DictionaryEncoding<'a>>>,
     pub children: Option<
-        flatbuffers::WIPOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field<'a>>>,
-        >,
+        flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field<'a>>>>,
     >,
     pub custom_metadata: Option<
-        flatbuffers::WIPOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>,
-        >,
+        flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>>,
     >,
 }
 impl<'a> Default for FieldArgs<'a> {
@@ -4002,6 +4529,7 @@ impl<'a> Default for FieldArgs<'a> {
         }
     }
 }
+
 pub struct FieldBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -4023,18 +4551,12 @@ impl<'a: 'b, 'b> FieldBuilder<'a, 'b> {
             .push_slot::<Type>(Field::VT_TYPE_TYPE, type_type, Type::NONE);
     }
     #[inline]
-    pub fn add_type_(
-        &mut self,
-        type_: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
-    ) {
+    pub fn add_type_(&mut self, type_: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>) {
         self.fbb_
             .push_slot_always::<flatbuffers::WIPOffset<_>>(Field::VT_TYPE_, type_);
     }
     #[inline]
-    pub fn add_dictionary(
-        &mut self,
-        dictionary: flatbuffers::WIPOffset<DictionaryEncoding<'b>>,
-    ) {
+    pub fn add_dictionary(&mut self, dictionary: flatbuffers::WIPOffset<DictionaryEncoding<'b>>) {
         self.fbb_
             .push_slot_always::<flatbuffers::WIPOffset<DictionaryEncoding>>(
                 Field::VT_DICTIONARY,
@@ -4078,8 +4600,8 @@ impl<'a: 'b, 'b> FieldBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Field<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Field<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Field");
         ds.field("name", &self.name());
         ds.field("nullable", &self.nullable());
@@ -4295,6 +4817,16 @@ impl std::fmt::Debug for Field<'_> {
                     )
                 }
             }
+            Type::RunEndEncoded => {
+                if let Some(x) = self.type_as_run_end_encoded() {
+                    ds.field("type_", &x)
+                } else {
+                    ds.field(
+                        "type_",
+                        &"InvalidFlatbuffer: Union discriminant does not match value.",
+                    )
+                }
+            }
             _ => {
                 let x: Option<()> = None;
                 ds.field("type_", &x)
@@ -4318,16 +4850,21 @@ pub struct Schema<'a> {
 impl<'a> flatbuffers::Follow<'a> for Schema<'a> {
     type Inner = Schema<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Schema<'a> {
+    pub const VT_ENDIANNESS: flatbuffers::VOffsetT = 4;
+    pub const VT_FIELDS: flatbuffers::VOffsetT = 6;
+    pub const VT_CUSTOM_METADATA: flatbuffers::VOffsetT = 8;
+    pub const VT_FEATURES: flatbuffers::VOffsetT = 10;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Schema { _tab: table }
     }
     #[allow(unused_mut)]
@@ -4349,44 +4886,59 @@ impl<'a> Schema<'a> {
         builder.finish()
     }
 
-    pub const VT_ENDIANNESS: flatbuffers::VOffsetT = 4;
-    pub const VT_FIELDS: flatbuffers::VOffsetT = 6;
-    pub const VT_CUSTOM_METADATA: flatbuffers::VOffsetT = 8;
-    pub const VT_FEATURES: flatbuffers::VOffsetT = 10;
-
     /// endianness of the buffer
     /// it is Little Endian by default
     /// if endianness doesn't match the underlying system then the vectors need to be converted
     #[inline]
     pub fn endianness(&self) -> Endianness {
-        self._tab
-            .get::<Endianness>(Schema::VT_ENDIANNESS, Some(Endianness::Little))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<Endianness>(Schema::VT_ENDIANNESS, Some(Endianness::Little))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn fields(
         &self,
     ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field<'a>>>> {
-        self._tab.get::<flatbuffers::ForwardsUOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field>>,
-        >>(Schema::VT_FIELDS, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab.get::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field>>,
+            >>(Schema::VT_FIELDS, None)
+        }
     }
     #[inline]
     pub fn custom_metadata(
         &self,
     ) -> Option<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>> {
-        self._tab.get::<flatbuffers::ForwardsUOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue>>,
-        >>(Schema::VT_CUSTOM_METADATA, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab.get::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue>>,
+            >>(Schema::VT_CUSTOM_METADATA, None)
+        }
     }
     /// Features used in the stream/file.
     #[inline]
     pub fn features(&self) -> Option<flatbuffers::Vector<'a, Feature>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Feature>>>(
-                Schema::VT_FEATURES,
-                None,
-            )
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Feature>>>(
+                    Schema::VT_FEATURES,
+                    None,
+                )
+        }
     }
 }
 
@@ -4398,25 +4950,29 @@ impl flatbuffers::Verifiable for Schema<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-     .visit_field::<Endianness>(&"endianness", Self::VT_ENDIANNESS, false)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Field>>>>(&"fields", Self::VT_FIELDS, false)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>>>(&"custom_metadata", Self::VT_CUSTOM_METADATA, false)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Feature>>>(&"features", Self::VT_FEATURES, false)?
-     .finish();
+            .visit_field::<Endianness>("endianness", Self::VT_ENDIANNESS, false)?
+            .visit_field::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<Field>>,
+            >>("fields", Self::VT_FIELDS, false)?
+            .visit_field::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<KeyValue>>,
+            >>("custom_metadata", Self::VT_CUSTOM_METADATA, false)?
+            .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Feature>>>(
+                "features",
+                Self::VT_FEATURES,
+                false,
+            )?
+            .finish();
         Ok(())
     }
 }
 pub struct SchemaArgs<'a> {
     pub endianness: Endianness,
     pub fields: Option<
-        flatbuffers::WIPOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field<'a>>>,
-        >,
+        flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<Field<'a>>>>,
     >,
     pub custom_metadata: Option<
-        flatbuffers::WIPOffset<
-            flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>,
-        >,
+        flatbuffers::WIPOffset<flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<KeyValue<'a>>>>,
     >,
     pub features: Option<flatbuffers::WIPOffset<flatbuffers::Vector<'a, Feature>>>,
 }
@@ -4431,6 +4987,7 @@ impl<'a> Default for SchemaArgs<'a> {
         }
     }
 }
+
 pub struct SchemaBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -4438,11 +4995,8 @@ pub struct SchemaBuilder<'a: 'b, 'b> {
 impl<'a: 'b, 'b> SchemaBuilder<'a, 'b> {
     #[inline]
     pub fn add_endianness(&mut self, endianness: Endianness) {
-        self.fbb_.push_slot::<Endianness>(
-            Schema::VT_ENDIANNESS,
-            endianness,
-            Endianness::Little,
-        );
+        self.fbb_
+            .push_slot::<Endianness>(Schema::VT_ENDIANNESS, endianness, Endianness::Little);
     }
     #[inline]
     pub fn add_fields(
@@ -4475,9 +5029,7 @@ impl<'a: 'b, 'b> SchemaBuilder<'a, 'b> {
             .push_slot_always::<flatbuffers::WIPOffset<_>>(Schema::VT_FEATURES, features);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> SchemaBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SchemaBuilder<'a, 'b> {
         let start = _fbb.start_table();
         SchemaBuilder {
             fbb_: _fbb,
@@ -4491,8 +5043,8 @@ impl<'a: 'b, 'b> SchemaBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Schema<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Schema<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Schema");
         ds.field("endianness", &self.endianness());
         ds.field("fields", &self.fields());
@@ -4501,18 +5053,6 @@ impl std::fmt::Debug for Schema<'_> {
         ds.finish()
     }
 }
-#[inline]
-#[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")]
-pub fn get_root_as_schema<'a>(buf: &'a [u8]) -> Schema<'a> {
-    unsafe { flatbuffers::root_unchecked::<Schema<'a>>(buf) }
-}
-
-#[inline]
-#[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")]
-pub fn get_size_prefixed_root_as_schema<'a>(buf: &'a [u8]) -> Schema<'a> {
-    unsafe { flatbuffers::size_prefixed_root_unchecked::<Schema<'a>>(buf) }
-}
-
 #[inline]
 /// Verifies that a buffer of bytes contains a `Schema`
 /// and returns it.
@@ -4530,9 +5070,7 @@ pub fn root_as_schema(buf: &[u8]) -> Result<Schema, flatbuffers::InvalidFlatbuff
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `size_prefixed_root_as_schema_unchecked`.
-pub fn size_prefixed_root_as_schema(
-    buf: &[u8],
-) -> Result<Schema, flatbuffers::InvalidFlatbuffer> {
+pub fn size_prefixed_root_as_schema(buf: &[u8]) -> Result<Schema, flatbuffers::InvalidFlatbuffer> {
     flatbuffers::size_prefixed_root::<Schema>(buf)
 }
 #[inline]
diff --git a/arrow/src/ipc/gen/SparseTensor.rs b/arrow-ipc/src/gen/SparseTensor.rs
similarity index 69%
rename from arrow/src/ipc/gen/SparseTensor.rs
rename to arrow-ipc/src/gen/SparseTensor.rs
index 986d21cda84f..e03510ec0c8d 100644
--- a/arrow/src/ipc/gen/SparseTensor.rs
+++ b/arrow-ipc/src/gen/SparseTensor.rs
@@ -18,8 +18,8 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
 
-use crate::ipc::gen::Schema::*;
-use crate::ipc::gen::Tensor::*;
+use crate::gen::Schema::*;
+use crate::gen::Tensor::*;
 use flatbuffers::EndianScalar;
 use std::{cmp::Ordering, mem};
 // automatically generated by the FlatBuffers compiler, do not modify
@@ -44,7 +44,7 @@ pub const ENUM_VALUES_SPARSE_MATRIX_COMPRESSED_AXIS: [SparseMatrixCompressedAxis
     SparseMatrixCompressedAxis::Column,
 ];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct SparseMatrixCompressedAxis(pub i16);
 #[allow(non_upper_case_globals)]
@@ -64,8 +64,8 @@ impl SparseMatrixCompressedAxis {
         }
     }
 }
-impl std::fmt::Debug for SparseMatrixCompressedAxis {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for SparseMatrixCompressedAxis {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -76,8 +76,8 @@ impl std::fmt::Debug for SparseMatrixCompressedAxis {
 impl<'a> flatbuffers::Follow<'a> for SparseMatrixCompressedAxis {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<i16>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<i16>(buf, loc);
         Self(b)
     }
 }
@@ -85,20 +85,21 @@ impl<'a> flatbuffers::Follow<'a> for SparseMatrixCompressedAxis {
 impl flatbuffers::Push for SparseMatrixCompressedAxis {
     type Output = SparseMatrixCompressedAxis;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<i16>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<i16>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for SparseMatrixCompressedAxis {
+    type Scalar = i16;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = i16::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> i16 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = i16::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: i16) -> Self {
+        let b = i16::from_le(v);
         Self(b)
     }
 }
@@ -137,7 +138,7 @@ pub const ENUM_VALUES_SPARSE_TENSOR_INDEX: [SparseTensorIndex; 4] = [
     SparseTensorIndex::SparseTensorIndexCSF,
 ];
 
-#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
+#[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
 #[repr(transparent)]
 pub struct SparseTensorIndex(pub u8);
 #[allow(non_upper_case_globals)]
@@ -166,8 +167,8 @@ impl SparseTensorIndex {
         }
     }
 }
-impl std::fmt::Debug for SparseTensorIndex {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+impl core::fmt::Debug for SparseTensorIndex {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
         if let Some(name) = self.variant_name() {
             f.write_str(name)
         } else {
@@ -175,12 +176,11 @@ impl std::fmt::Debug for SparseTensorIndex {
         }
     }
 }
-pub struct SparseTensorIndexUnionTableOffset {}
 impl<'a> flatbuffers::Follow<'a> for SparseTensorIndex {
     type Inner = Self;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
-        let b = unsafe { flatbuffers::read_scalar_at::<u8>(buf, loc) };
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+        let b = flatbuffers::read_scalar_at::<u8>(buf, loc);
         Self(b)
     }
 }
@@ -188,20 +188,21 @@ impl<'a> flatbuffers::Follow<'a> for SparseTensorIndex {
 impl flatbuffers::Push for SparseTensorIndex {
     type Output = SparseTensorIndex;
     #[inline]
-    fn push(&self, dst: &mut [u8], _rest: &[u8]) {
-        unsafe { flatbuffers::emplace_scalar::<u8>(dst, self.0) };
+    unsafe fn push(&self, dst: &mut [u8], _written_len: usize) {
+        flatbuffers::emplace_scalar::<u8>(dst, self.0);
     }
 }
 
 impl flatbuffers::EndianScalar for SparseTensorIndex {
+    type Scalar = u8;
     #[inline]
-    fn to_little_endian(self) -> Self {
-        let b = u8::to_le(self.0);
-        Self(b)
+    fn to_little_endian(self) -> u8 {
+        self.0.to_le()
     }
     #[inline]
-    fn from_little_endian(self) -> Self {
-        let b = u8::from_le(self.0);
+    #[allow(clippy::wrong_self_convention)]
+    fn from_little_endian(v: u8) -> Self {
+        let b = u8::from_le(v);
         Self(b)
     }
 }
@@ -218,6 +219,8 @@ impl<'a> flatbuffers::Verifiable for SparseTensorIndex {
 }
 
 impl flatbuffers::SimpleToVerifyInSlice for SparseTensorIndex {}
+pub struct SparseTensorIndexUnionTableOffset {}
+
 pub enum SparseTensorIndexCOOOffset {}
 #[derive(Copy, Clone, PartialEq)]
 
@@ -260,16 +263,21 @@ pub struct SparseTensorIndexCOO<'a> {
 impl<'a> flatbuffers::Follow<'a> for SparseTensorIndexCOO<'a> {
     type Inner = SparseTensorIndexCOO<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> SparseTensorIndexCOO<'a> {
+    pub const VT_INDICESTYPE: flatbuffers::VOffsetT = 4;
+    pub const VT_INDICESSTRIDES: flatbuffers::VOffsetT = 6;
+    pub const VT_INDICESBUFFER: flatbuffers::VOffsetT = 8;
+    pub const VT_ISCANONICAL: flatbuffers::VOffsetT = 10;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         SparseTensorIndexCOO { _tab: table }
     }
     #[allow(unused_mut)]
@@ -291,37 +299,47 @@ impl<'a> SparseTensorIndexCOO<'a> {
         builder.finish()
     }
 
-    pub const VT_INDICESTYPE: flatbuffers::VOffsetT = 4;
-    pub const VT_INDICESSTRIDES: flatbuffers::VOffsetT = 6;
-    pub const VT_INDICESBUFFER: flatbuffers::VOffsetT = 8;
-    pub const VT_ISCANONICAL: flatbuffers::VOffsetT = 10;
-
     /// The type of values in indicesBuffer
     #[inline]
     pub fn indicesType(&self) -> Int<'a> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<Int>>(
-                SparseTensorIndexCOO::VT_INDICESTYPE,
-                None,
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<Int>>(
+                    SparseTensorIndexCOO::VT_INDICESTYPE,
+                    None,
+                )
+                .unwrap()
+        }
     }
     /// Non-negative byte offsets to advance one value cell along each dimension
     /// If omitted, default to row-major order (C-like).
     #[inline]
     pub fn indicesStrides(&self) -> Option<flatbuffers::Vector<'a, i64>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i64>>>(
-                SparseTensorIndexCOO::VT_INDICESSTRIDES,
-                None,
-            )
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i64>>>(
+                    SparseTensorIndexCOO::VT_INDICESSTRIDES,
+                    None,
+                )
+        }
     }
     /// The location and size of the indices matrix's data
     #[inline]
     pub fn indicesBuffer(&self) -> &'a Buffer {
-        self._tab
-            .get::<Buffer>(SparseTensorIndexCOO::VT_INDICESBUFFER, None)
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<Buffer>(SparseTensorIndexCOO::VT_INDICESBUFFER, None)
+                .unwrap()
+        }
     }
     /// This flag is true if and only if the indices matrix is sorted in
     /// row-major order, and does not have duplicated entries.
@@ -330,9 +348,14 @@ impl<'a> SparseTensorIndexCOO<'a> {
     /// (SciPy employs column-major order for its coo_matrix).
     #[inline]
     pub fn isCanonical(&self) -> bool {
-        self._tab
-            .get::<bool>(SparseTensorIndexCOO::VT_ISCANONICAL, Some(false))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<bool>(SparseTensorIndexCOO::VT_ISCANONICAL, Some(false))
+                .unwrap()
+        }
     }
 }
 
@@ -345,17 +368,17 @@ impl flatbuffers::Verifiable for SparseTensorIndexCOO<'_> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
             .visit_field::<flatbuffers::ForwardsUOffset<Int>>(
-                &"indicesType",
+                "indicesType",
                 Self::VT_INDICESTYPE,
                 true,
             )?
             .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, i64>>>(
-                &"indicesStrides",
+                "indicesStrides",
                 Self::VT_INDICESSTRIDES,
                 false,
             )?
-            .visit_field::<Buffer>(&"indicesBuffer", Self::VT_INDICESBUFFER, true)?
-            .visit_field::<bool>(&"isCanonical", Self::VT_ISCANONICAL, false)?
+            .visit_field::<Buffer>("indicesBuffer", Self::VT_INDICESBUFFER, true)?
+            .visit_field::<bool>("isCanonical", Self::VT_ISCANONICAL, false)?
             .finish();
         Ok(())
     }
@@ -377,6 +400,7 @@ impl<'a> Default for SparseTensorIndexCOOArgs<'a> {
         }
     }
 }
+
 pub struct SparseTensorIndexCOOBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -401,18 +425,13 @@ impl<'a: 'b, 'b> SparseTensorIndexCOOBuilder<'a, 'b> {
     }
     #[inline]
     pub fn add_indicesBuffer(&mut self, indicesBuffer: &Buffer) {
-        self.fbb_.push_slot_always::<&Buffer>(
-            SparseTensorIndexCOO::VT_INDICESBUFFER,
-            indicesBuffer,
-        );
+        self.fbb_
+            .push_slot_always::<&Buffer>(SparseTensorIndexCOO::VT_INDICESBUFFER, indicesBuffer);
     }
     #[inline]
     pub fn add_isCanonical(&mut self, isCanonical: bool) {
-        self.fbb_.push_slot::<bool>(
-            SparseTensorIndexCOO::VT_ISCANONICAL,
-            isCanonical,
-            false,
-        );
+        self.fbb_
+            .push_slot::<bool>(SparseTensorIndexCOO::VT_ISCANONICAL, isCanonical, false);
     }
     #[inline]
     pub fn new(
@@ -435,8 +454,8 @@ impl<'a: 'b, 'b> SparseTensorIndexCOOBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for SparseTensorIndexCOO<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for SparseTensorIndexCOO<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("SparseTensorIndexCOO");
         ds.field("indicesType", &self.indicesType());
         ds.field("indicesStrides", &self.indicesStrides());
@@ -456,16 +475,22 @@ pub struct SparseMatrixIndexCSX<'a> {
 impl<'a> flatbuffers::Follow<'a> for SparseMatrixIndexCSX<'a> {
     type Inner = SparseMatrixIndexCSX<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> SparseMatrixIndexCSX<'a> {
+    pub const VT_COMPRESSEDAXIS: flatbuffers::VOffsetT = 4;
+    pub const VT_INDPTRTYPE: flatbuffers::VOffsetT = 6;
+    pub const VT_INDPTRBUFFER: flatbuffers::VOffsetT = 8;
+    pub const VT_INDICESTYPE: flatbuffers::VOffsetT = 10;
+    pub const VT_INDICESBUFFER: flatbuffers::VOffsetT = 12;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         SparseMatrixIndexCSX { _tab: table }
     }
     #[allow(unused_mut)]
@@ -490,31 +515,32 @@ impl<'a> SparseMatrixIndexCSX<'a> {
         builder.finish()
     }
 
-    pub const VT_COMPRESSEDAXIS: flatbuffers::VOffsetT = 4;
-    pub const VT_INDPTRTYPE: flatbuffers::VOffsetT = 6;
-    pub const VT_INDPTRBUFFER: flatbuffers::VOffsetT = 8;
-    pub const VT_INDICESTYPE: flatbuffers::VOffsetT = 10;
-    pub const VT_INDICESBUFFER: flatbuffers::VOffsetT = 12;
-
     /// Which axis, row or column, is compressed
     #[inline]
     pub fn compressedAxis(&self) -> SparseMatrixCompressedAxis {
-        self._tab
-            .get::<SparseMatrixCompressedAxis>(
-                SparseMatrixIndexCSX::VT_COMPRESSEDAXIS,
-                Some(SparseMatrixCompressedAxis::Row),
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<SparseMatrixCompressedAxis>(
+                    SparseMatrixIndexCSX::VT_COMPRESSEDAXIS,
+                    Some(SparseMatrixCompressedAxis::Row),
+                )
+                .unwrap()
+        }
     }
     /// The type of values in indptrBuffer
     #[inline]
     pub fn indptrType(&self) -> Int<'a> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<Int>>(
-                SparseMatrixIndexCSX::VT_INDPTRTYPE,
-                None,
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<Int>>(SparseMatrixIndexCSX::VT_INDPTRTYPE, None)
+                .unwrap()
+        }
     }
     /// indptrBuffer stores the location and size of indptr array that
     /// represents the range of the rows.
@@ -541,19 +567,29 @@ impl<'a> SparseMatrixIndexCSX<'a> {
     /// ```
     #[inline]
     pub fn indptrBuffer(&self) -> &'a Buffer {
-        self._tab
-            .get::<Buffer>(SparseMatrixIndexCSX::VT_INDPTRBUFFER, None)
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<Buffer>(SparseMatrixIndexCSX::VT_INDPTRBUFFER, None)
+                .unwrap()
+        }
     }
     /// The type of values in indicesBuffer
     #[inline]
     pub fn indicesType(&self) -> Int<'a> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<Int>>(
-                SparseMatrixIndexCSX::VT_INDICESTYPE,
-                None,
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<Int>>(
+                    SparseMatrixIndexCSX::VT_INDICESTYPE,
+                    None,
+                )
+                .unwrap()
+        }
     }
     /// indicesBuffer stores the location and size of the array that
     /// contains the column indices of the corresponding non-zero values.
@@ -566,9 +602,14 @@ impl<'a> SparseMatrixIndexCSX<'a> {
     /// Note that the indices are sorted in lexicographical order for each row.
     #[inline]
     pub fn indicesBuffer(&self) -> &'a Buffer {
-        self._tab
-            .get::<Buffer>(SparseMatrixIndexCSX::VT_INDICESBUFFER, None)
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<Buffer>(SparseMatrixIndexCSX::VT_INDICESBUFFER, None)
+                .unwrap()
+        }
     }
 }
 
@@ -581,22 +622,22 @@ impl flatbuffers::Verifiable for SparseMatrixIndexCSX<'_> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
             .visit_field::<SparseMatrixCompressedAxis>(
-                &"compressedAxis",
+                "compressedAxis",
                 Self::VT_COMPRESSEDAXIS,
                 false,
             )?
             .visit_field::<flatbuffers::ForwardsUOffset<Int>>(
-                &"indptrType",
+                "indptrType",
                 Self::VT_INDPTRTYPE,
                 true,
             )?
-            .visit_field::<Buffer>(&"indptrBuffer", Self::VT_INDPTRBUFFER, true)?
+            .visit_field::<Buffer>("indptrBuffer", Self::VT_INDPTRBUFFER, true)?
             .visit_field::<flatbuffers::ForwardsUOffset<Int>>(
-                &"indicesType",
+                "indicesType",
                 Self::VT_INDICESTYPE,
                 true,
             )?
-            .visit_field::<Buffer>(&"indicesBuffer", Self::VT_INDICESBUFFER, true)?
+            .visit_field::<Buffer>("indicesBuffer", Self::VT_INDICESBUFFER, true)?
             .finish();
         Ok(())
     }
@@ -620,6 +661,7 @@ impl<'a> Default for SparseMatrixIndexCSXArgs<'a> {
         }
     }
 }
+
 pub struct SparseMatrixIndexCSXBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -642,10 +684,8 @@ impl<'a: 'b, 'b> SparseMatrixIndexCSXBuilder<'a, 'b> {
     }
     #[inline]
     pub fn add_indptrBuffer(&mut self, indptrBuffer: &Buffer) {
-        self.fbb_.push_slot_always::<&Buffer>(
-            SparseMatrixIndexCSX::VT_INDPTRBUFFER,
-            indptrBuffer,
-        );
+        self.fbb_
+            .push_slot_always::<&Buffer>(SparseMatrixIndexCSX::VT_INDPTRBUFFER, indptrBuffer);
     }
     #[inline]
     pub fn add_indicesType(&mut self, indicesType: flatbuffers::WIPOffset<Int<'b>>) {
@@ -656,10 +696,8 @@ impl<'a: 'b, 'b> SparseMatrixIndexCSXBuilder<'a, 'b> {
     }
     #[inline]
     pub fn add_indicesBuffer(&mut self, indicesBuffer: &Buffer) {
-        self.fbb_.push_slot_always::<&Buffer>(
-            SparseMatrixIndexCSX::VT_INDICESBUFFER,
-            indicesBuffer,
-        );
+        self.fbb_
+            .push_slot_always::<&Buffer>(SparseMatrixIndexCSX::VT_INDICESBUFFER, indicesBuffer);
     }
     #[inline]
     pub fn new(
@@ -686,8 +724,8 @@ impl<'a: 'b, 'b> SparseMatrixIndexCSXBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for SparseMatrixIndexCSX<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for SparseMatrixIndexCSX<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("SparseMatrixIndexCSX");
         ds.field("compressedAxis", &self.compressedAxis());
         ds.field("indptrType", &self.indptrType());
@@ -708,16 +746,22 @@ pub struct SparseTensorIndexCSF<'a> {
 impl<'a> flatbuffers::Follow<'a> for SparseTensorIndexCSF<'a> {
     type Inner = SparseTensorIndexCSF<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> SparseTensorIndexCSF<'a> {
+    pub const VT_INDPTRTYPE: flatbuffers::VOffsetT = 4;
+    pub const VT_INDPTRBUFFERS: flatbuffers::VOffsetT = 6;
+    pub const VT_INDICESTYPE: flatbuffers::VOffsetT = 8;
+    pub const VT_INDICESBUFFERS: flatbuffers::VOffsetT = 10;
+    pub const VT_AXISORDER: flatbuffers::VOffsetT = 12;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         SparseTensorIndexCSF { _tab: table }
     }
     #[allow(unused_mut)]
@@ -744,12 +788,6 @@ impl<'a> SparseTensorIndexCSF<'a> {
         builder.finish()
     }
 
-    pub const VT_INDPTRTYPE: flatbuffers::VOffsetT = 4;
-    pub const VT_INDPTRBUFFERS: flatbuffers::VOffsetT = 6;
-    pub const VT_INDICESTYPE: flatbuffers::VOffsetT = 8;
-    pub const VT_INDICESBUFFERS: flatbuffers::VOffsetT = 10;
-    pub const VT_AXISORDER: flatbuffers::VOffsetT = 12;
-
     /// CSF is a generalization of compressed sparse row (CSR) index.
     /// See [smith2017knl](http://shaden.io/pub-files/smith2017knl.pdf)
     ///
@@ -783,12 +821,14 @@ impl<'a> SparseTensorIndexCSF<'a> {
     /// The type of values in indptrBuffers
     #[inline]
     pub fn indptrType(&self) -> Int<'a> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<Int>>(
-                SparseTensorIndexCSF::VT_INDPTRTYPE,
-                None,
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<Int>>(SparseTensorIndexCSF::VT_INDPTRTYPE, None)
+                .unwrap()
+        }
     }
     /// indptrBuffers stores the sparsity structure.
     /// Each two consecutive dimensions in a tensor correspond to a buffer in
@@ -805,24 +845,33 @@ impl<'a> SparseTensorIndexCSF<'a> {
     ///                     ].
     /// ```
     #[inline]
-    pub fn indptrBuffers(&self) -> &'a [Buffer] {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Buffer>>>(
-                SparseTensorIndexCSF::VT_INDPTRBUFFERS,
-                None,
-            )
-            .map(|v| v.safe_slice())
-            .unwrap()
+    pub fn indptrBuffers(&self) -> flatbuffers::Vector<'a, Buffer> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Buffer>>>(
+                    SparseTensorIndexCSF::VT_INDPTRBUFFERS,
+                    None,
+                )
+                .unwrap()
+        }
     }
     /// The type of values in indicesBuffers
     #[inline]
     pub fn indicesType(&self) -> Int<'a> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<Int>>(
-                SparseTensorIndexCSF::VT_INDICESTYPE,
-                None,
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<Int>>(
+                    SparseTensorIndexCSF::VT_INDICESTYPE,
+                    None,
+                )
+                .unwrap()
+        }
     }
     /// indicesBuffers stores values of nodes.
     /// Each tensor dimension corresponds to a buffer in indicesBuffers.
@@ -836,14 +885,18 @@ impl<'a> SparseTensorIndexCSF<'a> {
     ///                      ].
     /// ```
     #[inline]
-    pub fn indicesBuffers(&self) -> &'a [Buffer] {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Buffer>>>(
-                SparseTensorIndexCSF::VT_INDICESBUFFERS,
-                None,
-            )
-            .map(|v| v.safe_slice())
-            .unwrap()
+    pub fn indicesBuffers(&self) -> flatbuffers::Vector<'a, Buffer> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, Buffer>>>(
+                    SparseTensorIndexCSF::VT_INDICESBUFFERS,
+                    None,
+                )
+                .unwrap()
+        }
     }
     /// axisOrder stores the sequence in which dimensions were traversed to
     /// produce the prefix tree.
@@ -853,12 +906,17 @@ impl<'a> SparseTensorIndexCSF<'a> {
     /// ```
     #[inline]
     pub fn axisOrder(&self) -> flatbuffers::Vector<'a, i32> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i32>>>(
-                SparseTensorIndexCSF::VT_AXISORDER,
-                None,
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i32>>>(
+                    SparseTensorIndexCSF::VT_AXISORDER,
+                    None,
+                )
+                .unwrap()
+        }
     }
 }
 
@@ -871,27 +929,27 @@ impl flatbuffers::Verifiable for SparseTensorIndexCSF<'_> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
             .visit_field::<flatbuffers::ForwardsUOffset<Int>>(
-                &"indptrType",
+                "indptrType",
                 Self::VT_INDPTRTYPE,
                 true,
             )?
             .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Buffer>>>(
-                &"indptrBuffers",
+                "indptrBuffers",
                 Self::VT_INDPTRBUFFERS,
                 true,
             )?
             .visit_field::<flatbuffers::ForwardsUOffset<Int>>(
-                &"indicesType",
+                "indicesType",
                 Self::VT_INDICESTYPE,
                 true,
             )?
             .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, Buffer>>>(
-                &"indicesBuffers",
+                "indicesBuffers",
                 Self::VT_INDICESBUFFERS,
                 true,
             )?
             .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, i32>>>(
-                &"axisOrder",
+                "axisOrder",
                 Self::VT_AXISORDER,
                 true,
             )?
@@ -918,6 +976,7 @@ impl<'a> Default for SparseTensorIndexCSFArgs<'a> {
         }
     }
 }
+
 pub struct SparseTensorIndexCSFBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -994,8 +1053,8 @@ impl<'a: 'b, 'b> SparseTensorIndexCSFBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for SparseTensorIndexCSF<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for SparseTensorIndexCSF<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("SparseTensorIndexCSF");
         ds.field("indptrType", &self.indptrType());
         ds.field("indptrBuffers", &self.indptrBuffers());
@@ -1015,16 +1074,24 @@ pub struct SparseTensor<'a> {
 impl<'a> flatbuffers::Follow<'a> for SparseTensor<'a> {
     type Inner = SparseTensor<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> SparseTensor<'a> {
+    pub const VT_TYPE_TYPE: flatbuffers::VOffsetT = 4;
+    pub const VT_TYPE_: flatbuffers::VOffsetT = 6;
+    pub const VT_SHAPE: flatbuffers::VOffsetT = 8;
+    pub const VT_NON_ZERO_LENGTH: flatbuffers::VOffsetT = 10;
+    pub const VT_SPARSEINDEX_TYPE: flatbuffers::VOffsetT = 12;
+    pub const VT_SPARSEINDEX: flatbuffers::VOffsetT = 14;
+    pub const VT_DATA: flatbuffers::VOffsetT = 16;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         SparseTensor { _tab: table }
     }
     #[allow(unused_mut)]
@@ -1051,82 +1118,110 @@ impl<'a> SparseTensor<'a> {
         builder.finish()
     }
 
-    pub const VT_TYPE_TYPE: flatbuffers::VOffsetT = 4;
-    pub const VT_TYPE_: flatbuffers::VOffsetT = 6;
-    pub const VT_SHAPE: flatbuffers::VOffsetT = 8;
-    pub const VT_NON_ZERO_LENGTH: flatbuffers::VOffsetT = 10;
-    pub const VT_SPARSEINDEX_TYPE: flatbuffers::VOffsetT = 12;
-    pub const VT_SPARSEINDEX: flatbuffers::VOffsetT = 14;
-    pub const VT_DATA: flatbuffers::VOffsetT = 16;
-
     #[inline]
     pub fn type_type(&self) -> Type {
-        self._tab
-            .get::<Type>(SparseTensor::VT_TYPE_TYPE, Some(Type::NONE))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<Type>(SparseTensor::VT_TYPE_TYPE, Some(Type::NONE))
+                .unwrap()
+        }
     }
     /// The type of data contained in a value cell.
     /// Currently only fixed-width value types are supported,
     /// no strings or nested types.
     #[inline]
     pub fn type_(&self) -> flatbuffers::Table<'a> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
-                SparseTensor::VT_TYPE_,
-                None,
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    SparseTensor::VT_TYPE_,
+                    None,
+                )
+                .unwrap()
+        }
     }
     /// The dimensions of the tensor, optionally named.
     #[inline]
-    pub fn shape(
-        &self,
-    ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorDim<'a>>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<
-                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorDim>>,
-            >>(SparseTensor::VT_SHAPE, None)
-            .unwrap()
+    pub fn shape(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorDim<'a>>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<
+                    flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorDim>>,
+                >>(SparseTensor::VT_SHAPE, None)
+                .unwrap()
+        }
     }
     /// The number of non-zero values in a sparse tensor.
     #[inline]
     pub fn non_zero_length(&self) -> i64 {
-        self._tab
-            .get::<i64>(SparseTensor::VT_NON_ZERO_LENGTH, Some(0))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<i64>(SparseTensor::VT_NON_ZERO_LENGTH, Some(0))
+                .unwrap()
+        }
     }
     #[inline]
     pub fn sparseIndex_type(&self) -> SparseTensorIndex {
-        self._tab
-            .get::<SparseTensorIndex>(
-                SparseTensor::VT_SPARSEINDEX_TYPE,
-                Some(SparseTensorIndex::NONE),
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<SparseTensorIndex>(
+                    SparseTensor::VT_SPARSEINDEX_TYPE,
+                    Some(SparseTensorIndex::NONE),
+                )
+                .unwrap()
+        }
     }
     /// Sparse tensor index
     #[inline]
     pub fn sparseIndex(&self) -> flatbuffers::Table<'a> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
-                SparseTensor::VT_SPARSEINDEX,
-                None,
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
+                    SparseTensor::VT_SPARSEINDEX,
+                    None,
+                )
+                .unwrap()
+        }
     }
     /// The location and size of the tensor's data
     #[inline]
     pub fn data(&self) -> &'a Buffer {
-        self._tab
-            .get::<Buffer>(SparseTensor::VT_DATA, None)
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<Buffer>(SparseTensor::VT_DATA, None)
+                .unwrap()
+        }
     }
     #[inline]
     #[allow(non_snake_case)]
     pub fn type_as_null(&self) -> Option<Null<'a>> {
         if self.type_type() == Type::Null {
             let u = self.type_();
-            Some(Null::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Null::init_from_table(u) })
         } else {
             None
         }
@@ -1137,7 +1232,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_int(&self) -> Option<Int<'a>> {
         if self.type_type() == Type::Int {
             let u = self.type_();
-            Some(Int::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Int::init_from_table(u) })
         } else {
             None
         }
@@ -1148,7 +1246,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_floating_point(&self) -> Option<FloatingPoint<'a>> {
         if self.type_type() == Type::FloatingPoint {
             let u = self.type_();
-            Some(FloatingPoint::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { FloatingPoint::init_from_table(u) })
         } else {
             None
         }
@@ -1159,7 +1260,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_binary(&self) -> Option<Binary<'a>> {
         if self.type_type() == Type::Binary {
             let u = self.type_();
-            Some(Binary::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Binary::init_from_table(u) })
         } else {
             None
         }
@@ -1170,7 +1274,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_utf_8(&self) -> Option<Utf8<'a>> {
         if self.type_type() == Type::Utf8 {
             let u = self.type_();
-            Some(Utf8::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Utf8::init_from_table(u) })
         } else {
             None
         }
@@ -1181,7 +1288,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_bool(&self) -> Option<Bool<'a>> {
         if self.type_type() == Type::Bool {
             let u = self.type_();
-            Some(Bool::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Bool::init_from_table(u) })
         } else {
             None
         }
@@ -1192,7 +1302,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_decimal(&self) -> Option<Decimal<'a>> {
         if self.type_type() == Type::Decimal {
             let u = self.type_();
-            Some(Decimal::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Decimal::init_from_table(u) })
         } else {
             None
         }
@@ -1203,7 +1316,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_date(&self) -> Option<Date<'a>> {
         if self.type_type() == Type::Date {
             let u = self.type_();
-            Some(Date::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Date::init_from_table(u) })
         } else {
             None
         }
@@ -1214,7 +1330,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_time(&self) -> Option<Time<'a>> {
         if self.type_type() == Type::Time {
             let u = self.type_();
-            Some(Time::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Time::init_from_table(u) })
         } else {
             None
         }
@@ -1225,7 +1344,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_timestamp(&self) -> Option<Timestamp<'a>> {
         if self.type_type() == Type::Timestamp {
             let u = self.type_();
-            Some(Timestamp::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Timestamp::init_from_table(u) })
         } else {
             None
         }
@@ -1236,7 +1358,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_interval(&self) -> Option<Interval<'a>> {
         if self.type_type() == Type::Interval {
             let u = self.type_();
-            Some(Interval::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Interval::init_from_table(u) })
         } else {
             None
         }
@@ -1247,7 +1372,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_list(&self) -> Option<List<'a>> {
         if self.type_type() == Type::List {
             let u = self.type_();
-            Some(List::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { List::init_from_table(u) })
         } else {
             None
         }
@@ -1258,7 +1386,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_struct_(&self) -> Option<Struct_<'a>> {
         if self.type_type() == Type::Struct_ {
             let u = self.type_();
-            Some(Struct_::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Struct_::init_from_table(u) })
         } else {
             None
         }
@@ -1269,7 +1400,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_union(&self) -> Option<Union<'a>> {
         if self.type_type() == Type::Union {
             let u = self.type_();
-            Some(Union::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Union::init_from_table(u) })
         } else {
             None
         }
@@ -1280,7 +1414,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_fixed_size_binary(&self) -> Option<FixedSizeBinary<'a>> {
         if self.type_type() == Type::FixedSizeBinary {
             let u = self.type_();
-            Some(FixedSizeBinary::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { FixedSizeBinary::init_from_table(u) })
         } else {
             None
         }
@@ -1291,7 +1428,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_fixed_size_list(&self) -> Option<FixedSizeList<'a>> {
         if self.type_type() == Type::FixedSizeList {
             let u = self.type_();
-            Some(FixedSizeList::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { FixedSizeList::init_from_table(u) })
         } else {
             None
         }
@@ -1302,7 +1442,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_map(&self) -> Option<Map<'a>> {
         if self.type_type() == Type::Map {
             let u = self.type_();
-            Some(Map::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Map::init_from_table(u) })
         } else {
             None
         }
@@ -1313,7 +1456,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_duration(&self) -> Option<Duration<'a>> {
         if self.type_type() == Type::Duration {
             let u = self.type_();
-            Some(Duration::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Duration::init_from_table(u) })
         } else {
             None
         }
@@ -1324,7 +1470,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_large_binary(&self) -> Option<LargeBinary<'a>> {
         if self.type_type() == Type::LargeBinary {
             let u = self.type_();
-            Some(LargeBinary::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { LargeBinary::init_from_table(u) })
         } else {
             None
         }
@@ -1335,7 +1484,10 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_large_utf_8(&self) -> Option<LargeUtf8<'a>> {
         if self.type_type() == Type::LargeUtf8 {
             let u = self.type_();
-            Some(LargeUtf8::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { LargeUtf8::init_from_table(u) })
         } else {
             None
         }
@@ -1346,7 +1498,24 @@ impl<'a> SparseTensor<'a> {
     pub fn type_as_large_list(&self) -> Option<LargeList<'a>> {
         if self.type_type() == Type::LargeList {
             let u = self.type_();
-            Some(LargeList::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { LargeList::init_from_table(u) })
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[allow(non_snake_case)]
+    pub fn type_as_run_end_encoded(&self) -> Option<RunEndEncoded<'a>> {
+        if self.type_type() == Type::RunEndEncoded {
+            let u = self.type_();
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { RunEndEncoded::init_from_table(u) })
         } else {
             None
         }
@@ -1354,12 +1523,13 @@ impl<'a> SparseTensor<'a> {
 
     #[inline]
     #[allow(non_snake_case)]
-    pub fn sparseIndex_as_sparse_tensor_index_coo(
-        &self,
-    ) -> Option<SparseTensorIndexCOO<'a>> {
+    pub fn sparseIndex_as_sparse_tensor_index_coo(&self) -> Option<SparseTensorIndexCOO<'a>> {
         if self.sparseIndex_type() == SparseTensorIndex::SparseTensorIndexCOO {
             let u = self.sparseIndex();
-            Some(SparseTensorIndexCOO::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { SparseTensorIndexCOO::init_from_table(u) })
         } else {
             None
         }
@@ -1367,12 +1537,13 @@ impl<'a> SparseTensor<'a> {
 
     #[inline]
     #[allow(non_snake_case)]
-    pub fn sparseIndex_as_sparse_matrix_index_csx(
-        &self,
-    ) -> Option<SparseMatrixIndexCSX<'a>> {
+    pub fn sparseIndex_as_sparse_matrix_index_csx(&self) -> Option<SparseMatrixIndexCSX<'a>> {
         if self.sparseIndex_type() == SparseTensorIndex::SparseMatrixIndexCSX {
             let u = self.sparseIndex();
-            Some(SparseMatrixIndexCSX::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { SparseMatrixIndexCSX::init_from_table(u) })
         } else {
             None
         }
@@ -1380,12 +1551,13 @@ impl<'a> SparseTensor<'a> {
 
     #[inline]
     #[allow(non_snake_case)]
-    pub fn sparseIndex_as_sparse_tensor_index_csf(
-        &self,
-    ) -> Option<SparseTensorIndexCSF<'a>> {
+    pub fn sparseIndex_as_sparse_tensor_index_csf(&self) -> Option<SparseTensorIndexCSF<'a>> {
         if self.sparseIndex_type() == SparseTensorIndex::SparseTensorIndexCSF {
             let u = self.sparseIndex();
-            Some(SparseTensorIndexCSF::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { SparseTensorIndexCSF::init_from_table(u) })
         } else {
             None
         }
@@ -1400,44 +1572,147 @@ impl flatbuffers::Verifiable for SparseTensor<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-     .visit_union::<Type, _>(&"type_type", Self::VT_TYPE_TYPE, &"type_", Self::VT_TYPE_, true, |key, v, pos| {
-        match key {
-          Type::Null => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Null>>("Type::Null", pos),
-          Type::Int => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Int>>("Type::Int", pos),
-          Type::FloatingPoint => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FloatingPoint>>("Type::FloatingPoint", pos),
-          Type::Binary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Binary>>("Type::Binary", pos),
-          Type::Utf8 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Utf8>>("Type::Utf8", pos),
-          Type::Bool => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Bool>>("Type::Bool", pos),
-          Type::Decimal => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Decimal>>("Type::Decimal", pos),
-          Type::Date => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Date>>("Type::Date", pos),
-          Type::Time => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Time>>("Type::Time", pos),
-          Type::Timestamp => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Timestamp>>("Type::Timestamp", pos),
-          Type::Interval => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Interval>>("Type::Interval", pos),
-          Type::List => v.verify_union_variant::<flatbuffers::ForwardsUOffset<List>>("Type::List", pos),
-          Type::Struct_ => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Struct_>>("Type::Struct_", pos),
-          Type::Union => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Union>>("Type::Union", pos),
-          Type::FixedSizeBinary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeBinary>>("Type::FixedSizeBinary", pos),
-          Type::FixedSizeList => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeList>>("Type::FixedSizeList", pos),
-          Type::Map => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Map>>("Type::Map", pos),
-          Type::Duration => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Duration>>("Type::Duration", pos),
-          Type::LargeBinary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<LargeBinary>>("Type::LargeBinary", pos),
-          Type::LargeUtf8 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<LargeUtf8>>("Type::LargeUtf8", pos),
-          Type::LargeList => v.verify_union_variant::<flatbuffers::ForwardsUOffset<LargeList>>("Type::LargeList", pos),
-          _ => Ok(()),
-        }
-     })?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TensorDim>>>>(&"shape", Self::VT_SHAPE, true)?
-     .visit_field::<i64>(&"non_zero_length", Self::VT_NON_ZERO_LENGTH, false)?
-     .visit_union::<SparseTensorIndex, _>(&"sparseIndex_type", Self::VT_SPARSEINDEX_TYPE, &"sparseIndex", Self::VT_SPARSEINDEX, true, |key, v, pos| {
-        match key {
-          SparseTensorIndex::SparseTensorIndexCOO => v.verify_union_variant::<flatbuffers::ForwardsUOffset<SparseTensorIndexCOO>>("SparseTensorIndex::SparseTensorIndexCOO", pos),
-          SparseTensorIndex::SparseMatrixIndexCSX => v.verify_union_variant::<flatbuffers::ForwardsUOffset<SparseMatrixIndexCSX>>("SparseTensorIndex::SparseMatrixIndexCSX", pos),
-          SparseTensorIndex::SparseTensorIndexCSF => v.verify_union_variant::<flatbuffers::ForwardsUOffset<SparseTensorIndexCSF>>("SparseTensorIndex::SparseTensorIndexCSF", pos),
-          _ => Ok(()),
-        }
-     })?
-     .visit_field::<Buffer>(&"data", Self::VT_DATA, true)?
-     .finish();
+            .visit_union::<Type, _>(
+                "type_type",
+                Self::VT_TYPE_TYPE,
+                "type_",
+                Self::VT_TYPE_,
+                true,
+                |key, v, pos| match key {
+                    Type::Null => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Null>>(
+                        "Type::Null",
+                        pos,
+                    ),
+                    Type::Int => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Int>>(
+                        "Type::Int",
+                        pos,
+                    ),
+                    Type::FloatingPoint => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<FloatingPoint>>(
+                            "Type::FloatingPoint",
+                            pos,
+                        ),
+                    Type::Binary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Binary>>(
+                        "Type::Binary",
+                        pos,
+                    ),
+                    Type::Utf8 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Utf8>>(
+                        "Type::Utf8",
+                        pos,
+                    ),
+                    Type::Bool => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Bool>>(
+                        "Type::Bool",
+                        pos,
+                    ),
+                    Type::Decimal => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Decimal>>(
+                            "Type::Decimal",
+                            pos,
+                        ),
+                    Type::Date => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Date>>(
+                        "Type::Date",
+                        pos,
+                    ),
+                    Type::Time => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Time>>(
+                        "Type::Time",
+                        pos,
+                    ),
+                    Type::Timestamp => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Timestamp>>(
+                            "Type::Timestamp",
+                            pos,
+                        ),
+                    Type::Interval => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Interval>>(
+                            "Type::Interval",
+                            pos,
+                        ),
+                    Type::List => v.verify_union_variant::<flatbuffers::ForwardsUOffset<List>>(
+                        "Type::List",
+                        pos,
+                    ),
+                    Type::Struct_ => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Struct_>>(
+                            "Type::Struct_",
+                            pos,
+                        ),
+                    Type::Union => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Union>>(
+                        "Type::Union",
+                        pos,
+                    ),
+                    Type::FixedSizeBinary => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeBinary>>(
+                            "Type::FixedSizeBinary",
+                            pos,
+                        ),
+                    Type::FixedSizeList => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeList>>(
+                            "Type::FixedSizeList",
+                            pos,
+                        ),
+                    Type::Map => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Map>>(
+                        "Type::Map",
+                        pos,
+                    ),
+                    Type::Duration => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Duration>>(
+                            "Type::Duration",
+                            pos,
+                        ),
+                    Type::LargeBinary => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<LargeBinary>>(
+                            "Type::LargeBinary",
+                            pos,
+                        ),
+                    Type::LargeUtf8 => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<LargeUtf8>>(
+                            "Type::LargeUtf8",
+                            pos,
+                        ),
+                    Type::LargeList => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<LargeList>>(
+                            "Type::LargeList",
+                            pos,
+                        ),
+                    Type::RunEndEncoded => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<RunEndEncoded>>(
+                            "Type::RunEndEncoded",
+                            pos,
+                        ),
+                    _ => Ok(()),
+                },
+            )?
+            .visit_field::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TensorDim>>,
+            >>("shape", Self::VT_SHAPE, true)?
+            .visit_field::<i64>("non_zero_length", Self::VT_NON_ZERO_LENGTH, false)?
+            .visit_union::<SparseTensorIndex, _>(
+                "sparseIndex_type",
+                Self::VT_SPARSEINDEX_TYPE,
+                "sparseIndex",
+                Self::VT_SPARSEINDEX,
+                true,
+                |key, v, pos| match key {
+                    SparseTensorIndex::SparseTensorIndexCOO => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<SparseTensorIndexCOO>>(
+                            "SparseTensorIndex::SparseTensorIndexCOO",
+                            pos,
+                        ),
+                    SparseTensorIndex::SparseMatrixIndexCSX => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<SparseMatrixIndexCSX>>(
+                            "SparseTensorIndex::SparseMatrixIndexCSX",
+                            pos,
+                        ),
+                    SparseTensorIndex::SparseTensorIndexCSF => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<SparseTensorIndexCSF>>(
+                            "SparseTensorIndex::SparseTensorIndexCSF",
+                            pos,
+                        ),
+                    _ => Ok(()),
+                },
+            )?
+            .visit_field::<Buffer>("data", Self::VT_DATA, true)?
+            .finish();
         Ok(())
     }
 }
@@ -1468,6 +1743,7 @@ impl<'a> Default for SparseTensorArgs<'a> {
         }
     }
 }
+
 pub struct SparseTensorBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -1479,10 +1755,7 @@ impl<'a: 'b, 'b> SparseTensorBuilder<'a, 'b> {
             .push_slot::<Type>(SparseTensor::VT_TYPE_TYPE, type_type, Type::NONE);
     }
     #[inline]
-    pub fn add_type_(
-        &mut self,
-        type_: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
-    ) {
+    pub fn add_type_(&mut self, type_: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>) {
         self.fbb_
             .push_slot_always::<flatbuffers::WIPOffset<_>>(SparseTensor::VT_TYPE_, type_);
     }
@@ -1525,9 +1798,7 @@ impl<'a: 'b, 'b> SparseTensorBuilder<'a, 'b> {
             .push_slot_always::<&Buffer>(SparseTensor::VT_DATA, data);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> SparseTensorBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> SparseTensorBuilder<'a, 'b> {
         let start = _fbb.start_table();
         SparseTensorBuilder {
             fbb_: _fbb,
@@ -1546,8 +1817,8 @@ impl<'a: 'b, 'b> SparseTensorBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for SparseTensor<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for SparseTensor<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("SparseTensor");
         ds.field("type_type", &self.type_type());
         match self.type_type() {
@@ -1761,6 +2032,16 @@ impl std::fmt::Debug for SparseTensor<'_> {
                     )
                 }
             }
+            Type::RunEndEncoded => {
+                if let Some(x) = self.type_as_run_end_encoded() {
+                    ds.field("type_", &x)
+                } else {
+                    ds.field(
+                        "type_",
+                        &"InvalidFlatbuffer: Union discriminant does not match value.",
+                    )
+                }
+            }
             _ => {
                 let x: Option<()> = None;
                 ds.field("type_", &x)
@@ -1809,18 +2090,6 @@ impl std::fmt::Debug for SparseTensor<'_> {
         ds.finish()
     }
 }
-#[inline]
-#[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")]
-pub fn get_root_as_sparse_tensor<'a>(buf: &'a [u8]) -> SparseTensor<'a> {
-    unsafe { flatbuffers::root_unchecked::<SparseTensor<'a>>(buf) }
-}
-
-#[inline]
-#[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")]
-pub fn get_size_prefixed_root_as_sparse_tensor<'a>(buf: &'a [u8]) -> SparseTensor<'a> {
-    unsafe { flatbuffers::size_prefixed_root_unchecked::<SparseTensor<'a>>(buf) }
-}
-
 #[inline]
 /// Verifies that a buffer of bytes contains a `SparseTensor`
 /// and returns it.
@@ -1828,9 +2097,7 @@ pub fn get_size_prefixed_root_as_sparse_tensor<'a>(buf: &'a [u8]) -> SparseTenso
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `root_as_sparse_tensor_unchecked`.
-pub fn root_as_sparse_tensor(
-    buf: &[u8],
-) -> Result<SparseTensor, flatbuffers::InvalidFlatbuffer> {
+pub fn root_as_sparse_tensor(buf: &[u8]) -> Result<SparseTensor, flatbuffers::InvalidFlatbuffer> {
     flatbuffers::root::<SparseTensor>(buf)
 }
 #[inline]
diff --git a/arrow/src/ipc/gen/Tensor.rs b/arrow-ipc/src/gen/Tensor.rs
similarity index 64%
rename from arrow/src/ipc/gen/Tensor.rs
rename to arrow-ipc/src/gen/Tensor.rs
index 120636eaf1f5..1766d95144c2 100644
--- a/arrow/src/ipc/gen/Tensor.rs
+++ b/arrow-ipc/src/gen/Tensor.rs
@@ -18,7 +18,7 @@
 #![allow(dead_code)]
 #![allow(unused_imports)]
 
-use crate::ipc::gen::Schema::*;
+use crate::gen::Schema::*;
 use flatbuffers::EndianScalar;
 use std::{cmp::Ordering, mem};
 // automatically generated by the FlatBuffers compiler, do not modify
@@ -36,16 +36,19 @@ pub struct TensorDim<'a> {
 impl<'a> flatbuffers::Follow<'a> for TensorDim<'a> {
     type Inner = TensorDim<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> TensorDim<'a> {
+    pub const VT_SIZE_: flatbuffers::VOffsetT = 4;
+    pub const VT_NAME: flatbuffers::VOffsetT = 6;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         TensorDim { _tab: table }
     }
     #[allow(unused_mut)]
@@ -61,19 +64,24 @@ impl<'a> TensorDim<'a> {
         builder.finish()
     }
 
-    pub const VT_SIZE_: flatbuffers::VOffsetT = 4;
-    pub const VT_NAME: flatbuffers::VOffsetT = 6;
-
     /// Length of dimension
     #[inline]
     pub fn size_(&self) -> i64 {
-        self._tab.get::<i64>(TensorDim::VT_SIZE_, Some(0)).unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<i64>(TensorDim::VT_SIZE_, Some(0)).unwrap() }
     }
     /// Name of the dimension, optional
     #[inline]
     pub fn name(&self) -> Option<&'a str> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<&str>>(TensorDim::VT_NAME, None)
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<&str>>(TensorDim::VT_NAME, None)
+        }
     }
 }
 
@@ -85,12 +93,8 @@ impl flatbuffers::Verifiable for TensorDim<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-            .visit_field::<i64>(&"size_", Self::VT_SIZE_, false)?
-            .visit_field::<flatbuffers::ForwardsUOffset<&str>>(
-                &"name",
-                Self::VT_NAME,
-                false,
-            )?
+            .visit_field::<i64>("size_", Self::VT_SIZE_, false)?
+            .visit_field::<flatbuffers::ForwardsUOffset<&str>>("name", Self::VT_NAME, false)?
             .finish();
         Ok(())
     }
@@ -108,6 +112,7 @@ impl<'a> Default for TensorDimArgs<'a> {
         }
     }
 }
+
 pub struct TensorDimBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -123,9 +128,7 @@ impl<'a: 'b, 'b> TensorDimBuilder<'a, 'b> {
             .push_slot_always::<flatbuffers::WIPOffset<_>>(TensorDim::VT_NAME, name);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> TensorDimBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TensorDimBuilder<'a, 'b> {
         let start = _fbb.start_table();
         TensorDimBuilder {
             fbb_: _fbb,
@@ -139,8 +142,8 @@ impl<'a: 'b, 'b> TensorDimBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for TensorDim<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for TensorDim<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("TensorDim");
         ds.field("size_", &self.size_());
         ds.field("name", &self.name());
@@ -157,16 +160,22 @@ pub struct Tensor<'a> {
 impl<'a> flatbuffers::Follow<'a> for Tensor<'a> {
     type Inner = Tensor<'a>;
     #[inline]
-    fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
+    unsafe fn follow(buf: &'a [u8], loc: usize) -> Self::Inner {
         Self {
-            _tab: flatbuffers::Table { buf, loc },
+            _tab: flatbuffers::Table::new(buf, loc),
         }
     }
 }
 
 impl<'a> Tensor<'a> {
+    pub const VT_TYPE_TYPE: flatbuffers::VOffsetT = 4;
+    pub const VT_TYPE_: flatbuffers::VOffsetT = 6;
+    pub const VT_SHAPE: flatbuffers::VOffsetT = 8;
+    pub const VT_STRIDES: flatbuffers::VOffsetT = 10;
+    pub const VT_DATA: flatbuffers::VOffsetT = 12;
+
     #[inline]
-    pub fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
+    pub unsafe fn init_from_table(table: flatbuffers::Table<'a>) -> Self {
         Tensor { _tab: table }
     }
     #[allow(unused_mut)]
@@ -191,61 +200,76 @@ impl<'a> Tensor<'a> {
         builder.finish()
     }
 
-    pub const VT_TYPE_TYPE: flatbuffers::VOffsetT = 4;
-    pub const VT_TYPE_: flatbuffers::VOffsetT = 6;
-    pub const VT_SHAPE: flatbuffers::VOffsetT = 8;
-    pub const VT_STRIDES: flatbuffers::VOffsetT = 10;
-    pub const VT_DATA: flatbuffers::VOffsetT = 12;
-
     #[inline]
     pub fn type_type(&self) -> Type {
-        self._tab
-            .get::<Type>(Tensor::VT_TYPE_TYPE, Some(Type::NONE))
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<Type>(Tensor::VT_TYPE_TYPE, Some(Type::NONE))
+                .unwrap()
+        }
     }
     /// The type of data contained in a value cell. Currently only fixed-width
     /// value types are supported, no strings or nested types
     #[inline]
     pub fn type_(&self) -> flatbuffers::Table<'a> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(
-                Tensor::VT_TYPE_,
-                None,
-            )
-            .unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Table<'a>>>(Tensor::VT_TYPE_, None)
+                .unwrap()
+        }
     }
     /// The dimensions of the tensor, optionally named
     #[inline]
-    pub fn shape(
-        &self,
-    ) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorDim<'a>>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<
-                flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorDim>>,
-            >>(Tensor::VT_SHAPE, None)
-            .unwrap()
+    pub fn shape(&self) -> flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorDim<'a>>> {
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<
+                    flatbuffers::Vector<'a, flatbuffers::ForwardsUOffset<TensorDim>>,
+                >>(Tensor::VT_SHAPE, None)
+                .unwrap()
+        }
     }
     /// Non-negative byte offsets to advance one value cell along each dimension
     /// If omitted, default to row-major order (C-like).
     #[inline]
     pub fn strides(&self) -> Option<flatbuffers::Vector<'a, i64>> {
-        self._tab
-            .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i64>>>(
-                Tensor::VT_STRIDES,
-                None,
-            )
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe {
+            self._tab
+                .get::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'a, i64>>>(
+                    Tensor::VT_STRIDES,
+                    None,
+                )
+        }
     }
     /// The location and size of the tensor's data
     #[inline]
     pub fn data(&self) -> &'a Buffer {
-        self._tab.get::<Buffer>(Tensor::VT_DATA, None).unwrap()
+        // Safety:
+        // Created from valid Table for this object
+        // which contains a valid value in this slot
+        unsafe { self._tab.get::<Buffer>(Tensor::VT_DATA, None).unwrap() }
     }
     #[inline]
     #[allow(non_snake_case)]
     pub fn type_as_null(&self) -> Option<Null<'a>> {
         if self.type_type() == Type::Null {
             let u = self.type_();
-            Some(Null::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Null::init_from_table(u) })
         } else {
             None
         }
@@ -256,7 +280,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_int(&self) -> Option<Int<'a>> {
         if self.type_type() == Type::Int {
             let u = self.type_();
-            Some(Int::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Int::init_from_table(u) })
         } else {
             None
         }
@@ -267,7 +294,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_floating_point(&self) -> Option<FloatingPoint<'a>> {
         if self.type_type() == Type::FloatingPoint {
             let u = self.type_();
-            Some(FloatingPoint::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { FloatingPoint::init_from_table(u) })
         } else {
             None
         }
@@ -278,7 +308,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_binary(&self) -> Option<Binary<'a>> {
         if self.type_type() == Type::Binary {
             let u = self.type_();
-            Some(Binary::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Binary::init_from_table(u) })
         } else {
             None
         }
@@ -289,7 +322,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_utf_8(&self) -> Option<Utf8<'a>> {
         if self.type_type() == Type::Utf8 {
             let u = self.type_();
-            Some(Utf8::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Utf8::init_from_table(u) })
         } else {
             None
         }
@@ -300,7 +336,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_bool(&self) -> Option<Bool<'a>> {
         if self.type_type() == Type::Bool {
             let u = self.type_();
-            Some(Bool::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Bool::init_from_table(u) })
         } else {
             None
         }
@@ -311,7 +350,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_decimal(&self) -> Option<Decimal<'a>> {
         if self.type_type() == Type::Decimal {
             let u = self.type_();
-            Some(Decimal::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Decimal::init_from_table(u) })
         } else {
             None
         }
@@ -322,7 +364,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_date(&self) -> Option<Date<'a>> {
         if self.type_type() == Type::Date {
             let u = self.type_();
-            Some(Date::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Date::init_from_table(u) })
         } else {
             None
         }
@@ -333,7 +378,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_time(&self) -> Option<Time<'a>> {
         if self.type_type() == Type::Time {
             let u = self.type_();
-            Some(Time::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Time::init_from_table(u) })
         } else {
             None
         }
@@ -344,7 +392,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_timestamp(&self) -> Option<Timestamp<'a>> {
         if self.type_type() == Type::Timestamp {
             let u = self.type_();
-            Some(Timestamp::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Timestamp::init_from_table(u) })
         } else {
             None
         }
@@ -355,7 +406,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_interval(&self) -> Option<Interval<'a>> {
         if self.type_type() == Type::Interval {
             let u = self.type_();
-            Some(Interval::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Interval::init_from_table(u) })
         } else {
             None
         }
@@ -366,7 +420,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_list(&self) -> Option<List<'a>> {
         if self.type_type() == Type::List {
             let u = self.type_();
-            Some(List::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { List::init_from_table(u) })
         } else {
             None
         }
@@ -377,7 +434,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_struct_(&self) -> Option<Struct_<'a>> {
         if self.type_type() == Type::Struct_ {
             let u = self.type_();
-            Some(Struct_::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Struct_::init_from_table(u) })
         } else {
             None
         }
@@ -388,7 +448,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_union(&self) -> Option<Union<'a>> {
         if self.type_type() == Type::Union {
             let u = self.type_();
-            Some(Union::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Union::init_from_table(u) })
         } else {
             None
         }
@@ -399,7 +462,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_fixed_size_binary(&self) -> Option<FixedSizeBinary<'a>> {
         if self.type_type() == Type::FixedSizeBinary {
             let u = self.type_();
-            Some(FixedSizeBinary::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { FixedSizeBinary::init_from_table(u) })
         } else {
             None
         }
@@ -410,7 +476,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_fixed_size_list(&self) -> Option<FixedSizeList<'a>> {
         if self.type_type() == Type::FixedSizeList {
             let u = self.type_();
-            Some(FixedSizeList::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { FixedSizeList::init_from_table(u) })
         } else {
             None
         }
@@ -421,7 +490,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_map(&self) -> Option<Map<'a>> {
         if self.type_type() == Type::Map {
             let u = self.type_();
-            Some(Map::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Map::init_from_table(u) })
         } else {
             None
         }
@@ -432,7 +504,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_duration(&self) -> Option<Duration<'a>> {
         if self.type_type() == Type::Duration {
             let u = self.type_();
-            Some(Duration::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { Duration::init_from_table(u) })
         } else {
             None
         }
@@ -443,7 +518,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_large_binary(&self) -> Option<LargeBinary<'a>> {
         if self.type_type() == Type::LargeBinary {
             let u = self.type_();
-            Some(LargeBinary::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { LargeBinary::init_from_table(u) })
         } else {
             None
         }
@@ -454,7 +532,10 @@ impl<'a> Tensor<'a> {
     pub fn type_as_large_utf_8(&self) -> Option<LargeUtf8<'a>> {
         if self.type_type() == Type::LargeUtf8 {
             let u = self.type_();
-            Some(LargeUtf8::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { LargeUtf8::init_from_table(u) })
         } else {
             None
         }
@@ -465,7 +546,24 @@ impl<'a> Tensor<'a> {
     pub fn type_as_large_list(&self) -> Option<LargeList<'a>> {
         if self.type_type() == Type::LargeList {
             let u = self.type_();
-            Some(LargeList::init_from_table(u))
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { LargeList::init_from_table(u) })
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    #[allow(non_snake_case)]
+    pub fn type_as_run_end_encoded(&self) -> Option<RunEndEncoded<'a>> {
+        if self.type_type() == Type::RunEndEncoded {
+            let u = self.type_();
+            // Safety:
+            // Created from a valid Table for this object
+            // Which contains a valid union in this slot
+            Some(unsafe { RunEndEncoded::init_from_table(u) })
         } else {
             None
         }
@@ -480,36 +578,126 @@ impl flatbuffers::Verifiable for Tensor<'_> {
     ) -> Result<(), flatbuffers::InvalidFlatbuffer> {
         use flatbuffers::Verifiable;
         v.visit_table(pos)?
-     .visit_union::<Type, _>(&"type_type", Self::VT_TYPE_TYPE, &"type_", Self::VT_TYPE_, true, |key, v, pos| {
-        match key {
-          Type::Null => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Null>>("Type::Null", pos),
-          Type::Int => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Int>>("Type::Int", pos),
-          Type::FloatingPoint => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FloatingPoint>>("Type::FloatingPoint", pos),
-          Type::Binary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Binary>>("Type::Binary", pos),
-          Type::Utf8 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Utf8>>("Type::Utf8", pos),
-          Type::Bool => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Bool>>("Type::Bool", pos),
-          Type::Decimal => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Decimal>>("Type::Decimal", pos),
-          Type::Date => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Date>>("Type::Date", pos),
-          Type::Time => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Time>>("Type::Time", pos),
-          Type::Timestamp => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Timestamp>>("Type::Timestamp", pos),
-          Type::Interval => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Interval>>("Type::Interval", pos),
-          Type::List => v.verify_union_variant::<flatbuffers::ForwardsUOffset<List>>("Type::List", pos),
-          Type::Struct_ => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Struct_>>("Type::Struct_", pos),
-          Type::Union => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Union>>("Type::Union", pos),
-          Type::FixedSizeBinary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeBinary>>("Type::FixedSizeBinary", pos),
-          Type::FixedSizeList => v.verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeList>>("Type::FixedSizeList", pos),
-          Type::Map => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Map>>("Type::Map", pos),
-          Type::Duration => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Duration>>("Type::Duration", pos),
-          Type::LargeBinary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<LargeBinary>>("Type::LargeBinary", pos),
-          Type::LargeUtf8 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<LargeUtf8>>("Type::LargeUtf8", pos),
-          Type::LargeList => v.verify_union_variant::<flatbuffers::ForwardsUOffset<LargeList>>("Type::LargeList", pos),
-          _ => Ok(()),
-        }
-     })?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TensorDim>>>>(&"shape", Self::VT_SHAPE, true)?
-     .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, i64>>>(&"strides", Self::VT_STRIDES, false)?
-     .visit_field::<Buffer>(&"data", Self::VT_DATA, true)?
-     .finish();
+            .visit_union::<Type, _>(
+                "type_type",
+                Self::VT_TYPE_TYPE,
+                "type_",
+                Self::VT_TYPE_,
+                true,
+                |key, v, pos| match key {
+                    Type::Null => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Null>>(
+                        "Type::Null",
+                        pos,
+                    ),
+                    Type::Int => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Int>>(
+                        "Type::Int",
+                        pos,
+                    ),
+                    Type::FloatingPoint => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<FloatingPoint>>(
+                            "Type::FloatingPoint",
+                            pos,
+                        ),
+                    Type::Binary => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Binary>>(
+                        "Type::Binary",
+                        pos,
+                    ),
+                    Type::Utf8 => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Utf8>>(
+                        "Type::Utf8",
+                        pos,
+                    ),
+                    Type::Bool => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Bool>>(
+                        "Type::Bool",
+                        pos,
+                    ),
+                    Type::Decimal => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Decimal>>(
+                            "Type::Decimal",
+                            pos,
+                        ),
+                    Type::Date => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Date>>(
+                        "Type::Date",
+                        pos,
+                    ),
+                    Type::Time => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Time>>(
+                        "Type::Time",
+                        pos,
+                    ),
+                    Type::Timestamp => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Timestamp>>(
+                            "Type::Timestamp",
+                            pos,
+                        ),
+                    Type::Interval => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Interval>>(
+                            "Type::Interval",
+                            pos,
+                        ),
+                    Type::List => v.verify_union_variant::<flatbuffers::ForwardsUOffset<List>>(
+                        "Type::List",
+                        pos,
+                    ),
+                    Type::Struct_ => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Struct_>>(
+                            "Type::Struct_",
+                            pos,
+                        ),
+                    Type::Union => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Union>>(
+                        "Type::Union",
+                        pos,
+                    ),
+                    Type::FixedSizeBinary => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeBinary>>(
+                            "Type::FixedSizeBinary",
+                            pos,
+                        ),
+                    Type::FixedSizeList => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<FixedSizeList>>(
+                            "Type::FixedSizeList",
+                            pos,
+                        ),
+                    Type::Map => v.verify_union_variant::<flatbuffers::ForwardsUOffset<Map>>(
+                        "Type::Map",
+                        pos,
+                    ),
+                    Type::Duration => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<Duration>>(
+                            "Type::Duration",
+                            pos,
+                        ),
+                    Type::LargeBinary => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<LargeBinary>>(
+                            "Type::LargeBinary",
+                            pos,
+                        ),
+                    Type::LargeUtf8 => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<LargeUtf8>>(
+                            "Type::LargeUtf8",
+                            pos,
+                        ),
+                    Type::LargeList => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<LargeList>>(
+                            "Type::LargeList",
+                            pos,
+                        ),
+                    Type::RunEndEncoded => v
+                        .verify_union_variant::<flatbuffers::ForwardsUOffset<RunEndEncoded>>(
+                            "Type::RunEndEncoded",
+                            pos,
+                        ),
+                    _ => Ok(()),
+                },
+            )?
+            .visit_field::<flatbuffers::ForwardsUOffset<
+                flatbuffers::Vector<'_, flatbuffers::ForwardsUOffset<TensorDim>>,
+            >>("shape", Self::VT_SHAPE, true)?
+            .visit_field::<flatbuffers::ForwardsUOffset<flatbuffers::Vector<'_, i64>>>(
+                "strides",
+                Self::VT_STRIDES,
+                false,
+            )?
+            .visit_field::<Buffer>("data", Self::VT_DATA, true)?
+            .finish();
         Ok(())
     }
 }
@@ -536,6 +724,7 @@ impl<'a> Default for TensorArgs<'a> {
         }
     }
 }
+
 pub struct TensorBuilder<'a: 'b, 'b> {
     fbb_: &'b mut flatbuffers::FlatBufferBuilder<'a>,
     start_: flatbuffers::WIPOffset<flatbuffers::TableUnfinishedWIPOffset>,
@@ -547,10 +736,7 @@ impl<'a: 'b, 'b> TensorBuilder<'a, 'b> {
             .push_slot::<Type>(Tensor::VT_TYPE_TYPE, type_type, Type::NONE);
     }
     #[inline]
-    pub fn add_type_(
-        &mut self,
-        type_: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>,
-    ) {
+    pub fn add_type_(&mut self, type_: flatbuffers::WIPOffset<flatbuffers::UnionWIPOffset>) {
         self.fbb_
             .push_slot_always::<flatbuffers::WIPOffset<_>>(Tensor::VT_TYPE_, type_);
     }
@@ -565,10 +751,7 @@ impl<'a: 'b, 'b> TensorBuilder<'a, 'b> {
             .push_slot_always::<flatbuffers::WIPOffset<_>>(Tensor::VT_SHAPE, shape);
     }
     #[inline]
-    pub fn add_strides(
-        &mut self,
-        strides: flatbuffers::WIPOffset<flatbuffers::Vector<'b, i64>>,
-    ) {
+    pub fn add_strides(&mut self, strides: flatbuffers::WIPOffset<flatbuffers::Vector<'b, i64>>) {
         self.fbb_
             .push_slot_always::<flatbuffers::WIPOffset<_>>(Tensor::VT_STRIDES, strides);
     }
@@ -577,9 +760,7 @@ impl<'a: 'b, 'b> TensorBuilder<'a, 'b> {
         self.fbb_.push_slot_always::<&Buffer>(Tensor::VT_DATA, data);
     }
     #[inline]
-    pub fn new(
-        _fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>,
-    ) -> TensorBuilder<'a, 'b> {
+    pub fn new(_fbb: &'b mut flatbuffers::FlatBufferBuilder<'a>) -> TensorBuilder<'a, 'b> {
         let start = _fbb.start_table();
         TensorBuilder {
             fbb_: _fbb,
@@ -596,8 +777,8 @@ impl<'a: 'b, 'b> TensorBuilder<'a, 'b> {
     }
 }
 
-impl std::fmt::Debug for Tensor<'_> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+impl core::fmt::Debug for Tensor<'_> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
         let mut ds = f.debug_struct("Tensor");
         ds.field("type_type", &self.type_type());
         match self.type_type() {
@@ -811,6 +992,16 @@ impl std::fmt::Debug for Tensor<'_> {
                     )
                 }
             }
+            Type::RunEndEncoded => {
+                if let Some(x) = self.type_as_run_end_encoded() {
+                    ds.field("type_", &x)
+                } else {
+                    ds.field(
+                        "type_",
+                        &"InvalidFlatbuffer: Union discriminant does not match value.",
+                    )
+                }
+            }
             _ => {
                 let x: Option<()> = None;
                 ds.field("type_", &x)
@@ -822,18 +1013,6 @@ impl std::fmt::Debug for Tensor<'_> {
         ds.finish()
     }
 }
-#[inline]
-#[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")]
-pub fn get_root_as_tensor<'a>(buf: &'a [u8]) -> Tensor<'a> {
-    unsafe { flatbuffers::root_unchecked::<Tensor<'a>>(buf) }
-}
-
-#[inline]
-#[deprecated(since = "2.0.0", note = "Deprecated in favor of `root_as...` methods.")]
-pub fn get_size_prefixed_root_as_tensor<'a>(buf: &'a [u8]) -> Tensor<'a> {
-    unsafe { flatbuffers::size_prefixed_root_unchecked::<Tensor<'a>>(buf) }
-}
-
 #[inline]
 /// Verifies that a buffer of bytes contains a `Tensor`
 /// and returns it.
@@ -851,9 +1030,7 @@ pub fn root_as_tensor(buf: &[u8]) -> Result<Tensor, flatbuffers::InvalidFlatbuff
 /// catch every error, or be maximally performant. For the
 /// previous, unchecked, behavior use
 /// `size_prefixed_root_as_tensor_unchecked`.
-pub fn size_prefixed_root_as_tensor(
-    buf: &[u8],
-) -> Result<Tensor, flatbuffers::InvalidFlatbuffer> {
+pub fn size_prefixed_root_as_tensor(buf: &[u8]) -> Result<Tensor, flatbuffers::InvalidFlatbuffer> {
     flatbuffers::size_prefixed_root::<Tensor>(buf)
 }
 #[inline]
diff --git a/arrow/src/ipc/gen/mod.rs b/arrow-ipc/src/gen/mod.rs
similarity index 100%
rename from arrow/src/ipc/gen/mod.rs
rename to arrow-ipc/src/gen/mod.rs
diff --git a/arrow/src/ipc/mod.rs b/arrow-ipc/src/lib.rs
similarity index 88%
rename from arrow/src/ipc/mod.rs
rename to arrow-ipc/src/lib.rs
index d5455b454e7f..4f35ffb60a9f 100644
--- a/arrow/src/ipc/mod.rs
+++ b/arrow-ipc/src/lib.rs
@@ -15,13 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
-// TODO: (vcq): Protobuf codegen is not generating Debug impls.
-#![allow(missing_debug_implementations)]
+//! Support for the [Arrow IPC Format]
+//!
+//! [Arrow IPC Format]: https://arrow.apache.org/docs/format/Columnar.html#serialization-and-interprocess-communication-ipc
 
 pub mod convert;
 pub mod reader;
 pub mod writer;
 
+mod compression;
+
 #[allow(clippy::redundant_closure)]
 #[allow(clippy::needless_lifetimes)]
 #[allow(clippy::extra_unused_lifetimes)]
diff --git a/arrow-ipc/src/reader.rs b/arrow-ipc/src/reader.rs
new file mode 100644
index 000000000000..81b8b530734a
--- /dev/null
+++ b/arrow-ipc/src/reader.rs
@@ -0,0 +1,1858 @@
+// 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.
+
+//! Arrow IPC File and Stream Readers
+//!
+//! The `FileReader` and `StreamReader` have similar interfaces,
+//! however the `FileReader` expects a reader that supports `Seek`ing
+
+use flatbuffers::{VectorIter, VerifierOptions};
+use std::collections::HashMap;
+use std::fmt;
+use std::io::{BufReader, Read, Seek, SeekFrom};
+use std::sync::Arc;
+
+use arrow_array::*;
+use arrow_buffer::{ArrowNativeType, Buffer, MutableBuffer};
+use arrow_data::ArrayData;
+use arrow_schema::*;
+
+use crate::compression::CompressionCodec;
+use crate::{Block, FieldNode, Message, MetadataVersion, CONTINUATION_MARKER};
+use DataType::*;
+
+/// Read a buffer based on offset and length
+/// From <https://github.com/apache/arrow/blob/6a936c4ff5007045e86f65f1a6b6c3c955ad5103/format/Message.fbs#L58>
+/// Each constituent buffer is first compressed with the indicated
+/// compressor, and then written with the uncompressed length in the first 8
+/// bytes as a 64-bit little-endian signed integer followed by the compressed
+/// buffer bytes (and then padding as required by the protocol). The
+/// uncompressed length may be set to -1 to indicate that the data that
+/// follows is not compressed, which can be useful for cases where
+/// compression does not yield appreciable savings.
+fn read_buffer(
+    buf: &crate::Buffer,
+    a_data: &Buffer,
+    compression_codec: Option<CompressionCodec>,
+) -> Result<Buffer, ArrowError> {
+    let start_offset = buf.offset() as usize;
+    let buf_data = a_data.slice_with_length(start_offset, buf.length() as usize);
+    // corner case: empty buffer
+    match (buf_data.is_empty(), compression_codec) {
+        (true, _) | (_, None) => Ok(buf_data),
+        (false, Some(decompressor)) => decompressor.decompress_to_buffer(&buf_data),
+    }
+}
+
+/// Coordinates reading arrays based on data types.
+///
+/// Notes:
+/// * In the IPC format, null buffers are always set, but may be empty. We discard them if an array has 0 nulls
+/// * Numeric values inside list arrays are often stored as 64-bit values regardless of their data type size.
+///   We thus:
+///     - check if the bit width of non-64-bit numbers is 64, and
+///     - read the buffer as 64-bit (signed integer or float), and
+///     - cast the 64-bit array to the appropriate data type
+fn create_array(reader: &mut ArrayReader, field: &Field) -> Result<ArrayRef, ArrowError> {
+    let data_type = field.data_type();
+    match data_type {
+        Utf8 | Binary | LargeBinary | LargeUtf8 => create_primitive_array(
+            reader.next_node(field)?,
+            data_type,
+            &[
+                reader.next_buffer()?,
+                reader.next_buffer()?,
+                reader.next_buffer()?,
+            ],
+        ),
+        FixedSizeBinary(_) => create_primitive_array(
+            reader.next_node(field)?,
+            data_type,
+            &[reader.next_buffer()?, reader.next_buffer()?],
+        ),
+        List(ref list_field) | LargeList(ref list_field) | Map(ref list_field, _) => {
+            let list_node = reader.next_node(field)?;
+            let list_buffers = [reader.next_buffer()?, reader.next_buffer()?];
+            let values = create_array(reader, list_field)?;
+            create_list_array(list_node, data_type, &list_buffers, values)
+        }
+        FixedSizeList(ref list_field, _) => {
+            let list_node = reader.next_node(field)?;
+            let list_buffers = [reader.next_buffer()?];
+            let values = create_array(reader, list_field)?;
+            create_list_array(list_node, data_type, &list_buffers, values)
+        }
+        Struct(struct_fields) => {
+            let struct_node = reader.next_node(field)?;
+            let null_buffer = reader.next_buffer()?;
+
+            // read the arrays for each field
+            let mut struct_arrays = vec![];
+            // TODO investigate whether just knowing the number of buffers could
+            // still work
+            for struct_field in struct_fields {
+                let child = create_array(reader, struct_field)?;
+                struct_arrays.push((struct_field.clone(), child));
+            }
+            let null_count = struct_node.null_count() as usize;
+            let struct_array = if null_count > 0 {
+                // create struct array from fields, arrays and null data
+                StructArray::from((struct_arrays, null_buffer))
+            } else {
+                StructArray::from(struct_arrays)
+            };
+            Ok(Arc::new(struct_array))
+        }
+        RunEndEncoded(run_ends_field, values_field) => {
+            let run_node = reader.next_node(field)?;
+            let run_ends = create_array(reader, run_ends_field)?;
+            let values = create_array(reader, values_field)?;
+
+            let run_array_length = run_node.length() as usize;
+            let data = ArrayData::builder(data_type.clone())
+                .len(run_array_length)
+                .offset(0)
+                .add_child_data(run_ends.into_data())
+                .add_child_data(values.into_data())
+                .build_aligned()?;
+
+            Ok(make_array(data))
+        }
+        // Create dictionary array from RecordBatch
+        Dictionary(_, _) => {
+            let index_node = reader.next_node(field)?;
+            let index_buffers = [reader.next_buffer()?, reader.next_buffer()?];
+
+            let dict_id = field.dict_id().ok_or_else(|| {
+                ArrowError::ParseError(format!("Field {field} does not have dict id"))
+            })?;
+
+            let value_array = reader.dictionaries_by_id.get(&dict_id).ok_or_else(|| {
+                ArrowError::ParseError(format!(
+                    "Cannot find a dictionary batch with dict id: {dict_id}"
+                ))
+            })?;
+
+            create_dictionary_array(index_node, data_type, &index_buffers, value_array.clone())
+        }
+        Union(fields, mode) => {
+            let union_node = reader.next_node(field)?;
+            let len = union_node.length() as usize;
+
+            // In V4, union types has validity bitmap
+            // In V5 and later, union types have no validity bitmap
+            if reader.version < MetadataVersion::V5 {
+                reader.next_buffer()?;
+            }
+
+            let type_ids: Buffer = reader.next_buffer()?[..len].into();
+
+            let value_offsets = match mode {
+                UnionMode::Dense => {
+                    let buffer = reader.next_buffer()?;
+                    Some(buffer[..len * 4].into())
+                }
+                UnionMode::Sparse => None,
+            };
+
+            let mut children = Vec::with_capacity(fields.len());
+            let mut ids = Vec::with_capacity(fields.len());
+
+            for (id, field) in fields.iter() {
+                let child = create_array(reader, field)?;
+                children.push((field.as_ref().clone(), child));
+                ids.push(id);
+            }
+
+            let array = UnionArray::try_new(&ids, type_ids, value_offsets, children)?;
+            Ok(Arc::new(array))
+        }
+        Null => {
+            let node = reader.next_node(field)?;
+            let length = node.length();
+            let null_count = node.null_count();
+
+            if length != null_count {
+                return Err(ArrowError::SchemaError(format!(
+                    "Field {field} of NullArray has unequal null_count {null_count} and len {length}"
+                )));
+            }
+
+            let data = ArrayData::builder(data_type.clone())
+                .len(length as usize)
+                .offset(0)
+                .build_aligned()
+                .unwrap();
+            // no buffer increases
+            Ok(Arc::new(NullArray::from(data)))
+        }
+        _ => create_primitive_array(
+            reader.next_node(field)?,
+            data_type,
+            &[reader.next_buffer()?, reader.next_buffer()?],
+        ),
+    }
+}
+
+/// Reads the correct number of buffers based on data type and null_count, and creates a
+/// primitive array ref
+fn create_primitive_array(
+    field_node: &FieldNode,
+    data_type: &DataType,
+    buffers: &[Buffer],
+) -> Result<ArrayRef, ArrowError> {
+    let length = field_node.length() as usize;
+    let null_buffer = (field_node.null_count() > 0).then_some(buffers[0].clone());
+    let array_data = match data_type {
+        Utf8 | Binary | LargeBinary | LargeUtf8 => {
+            // read 3 buffers: null buffer (optional), offsets buffer and data buffer
+            ArrayData::builder(data_type.clone())
+                .len(length)
+                .buffers(buffers[1..3].to_vec())
+                .null_bit_buffer(null_buffer)
+                .build_aligned()?
+        }
+        _ if data_type.is_primitive() || matches!(data_type, Boolean | FixedSizeBinary(_)) => {
+            // read 2 buffers: null buffer (optional) and data buffer
+            ArrayData::builder(data_type.clone())
+                .len(length)
+                .add_buffer(buffers[1].clone())
+                .null_bit_buffer(null_buffer)
+                .build_aligned()?
+        }
+        t => unreachable!("Data type {:?} either unsupported or not primitive", t),
+    };
+
+    Ok(make_array(array_data))
+}
+
+/// Reads the correct number of buffers based on list type and null_count, and creates a
+/// list array ref
+fn create_list_array(
+    field_node: &FieldNode,
+    data_type: &DataType,
+    buffers: &[Buffer],
+    child_array: ArrayRef,
+) -> Result<ArrayRef, ArrowError> {
+    let null_buffer = (field_node.null_count() > 0).then_some(buffers[0].clone());
+    let length = field_node.length() as usize;
+    let child_data = child_array.into_data();
+    let builder = match data_type {
+        List(_) | LargeList(_) | Map(_, _) => ArrayData::builder(data_type.clone())
+            .len(length)
+            .add_buffer(buffers[1].clone())
+            .add_child_data(child_data)
+            .null_bit_buffer(null_buffer),
+
+        FixedSizeList(_, _) => ArrayData::builder(data_type.clone())
+            .len(length)
+            .add_child_data(child_data)
+            .null_bit_buffer(null_buffer),
+
+        _ => unreachable!("Cannot create list or map array from {:?}", data_type),
+    };
+    Ok(make_array(builder.build_aligned()?))
+}
+
+/// Reads the correct number of buffers based on list type and null_count, and creates a
+/// list array ref
+fn create_dictionary_array(
+    field_node: &FieldNode,
+    data_type: &DataType,
+    buffers: &[Buffer],
+    value_array: ArrayRef,
+) -> Result<ArrayRef, ArrowError> {
+    if let Dictionary(_, _) = *data_type {
+        let null_buffer = (field_node.null_count() > 0).then_some(buffers[0].clone());
+        let builder = ArrayData::builder(data_type.clone())
+            .len(field_node.length() as usize)
+            .add_buffer(buffers[1].clone())
+            .add_child_data(value_array.into_data())
+            .null_bit_buffer(null_buffer);
+
+        Ok(make_array(builder.build_aligned()?))
+    } else {
+        unreachable!("Cannot create dictionary array from {:?}", data_type)
+    }
+}
+
+/// State for decoding arrays from an encoded [`RecordBatch`]
+struct ArrayReader<'a> {
+    /// Decoded dictionaries indexed by dictionary id
+    dictionaries_by_id: &'a HashMap<i64, ArrayRef>,
+    /// Optional compression codec
+    compression: Option<CompressionCodec>,
+    /// The format version
+    version: MetadataVersion,
+    /// The raw data buffer
+    data: &'a Buffer,
+    /// The fields comprising this array
+    nodes: VectorIter<'a, FieldNode>,
+    /// The buffers comprising this array
+    buffers: VectorIter<'a, crate::Buffer>,
+}
+
+impl<'a> ArrayReader<'a> {
+    fn next_buffer(&mut self) -> Result<Buffer, ArrowError> {
+        read_buffer(self.buffers.next().unwrap(), self.data, self.compression)
+    }
+
+    fn skip_buffer(&mut self) {
+        self.buffers.next().unwrap();
+    }
+
+    fn next_node(&mut self, field: &Field) -> Result<&'a FieldNode, ArrowError> {
+        self.nodes.next().ok_or_else(|| {
+            ArrowError::SchemaError(format!(
+                "Invalid data for schema. {} refers to node not found in schema",
+                field
+            ))
+        })
+    }
+
+    fn skip_field(&mut self, field: &Field) -> Result<(), ArrowError> {
+        self.next_node(field)?;
+
+        match field.data_type() {
+            Utf8 | Binary | LargeBinary | LargeUtf8 => {
+                for _ in 0..3 {
+                    self.skip_buffer()
+                }
+            }
+            FixedSizeBinary(_) => {
+                self.skip_buffer();
+                self.skip_buffer();
+            }
+            List(list_field) | LargeList(list_field) | Map(list_field, _) => {
+                self.skip_buffer();
+                self.skip_buffer();
+                self.skip_field(list_field)?;
+            }
+            FixedSizeList(list_field, _) => {
+                self.skip_buffer();
+                self.skip_field(list_field)?;
+            }
+            Struct(struct_fields) => {
+                self.skip_buffer();
+
+                // skip for each field
+                for struct_field in struct_fields {
+                    self.skip_field(struct_field)?
+                }
+            }
+            RunEndEncoded(run_ends_field, values_field) => {
+                self.skip_field(run_ends_field)?;
+                self.skip_field(values_field)?;
+            }
+            Dictionary(_, _) => {
+                self.skip_buffer(); // Nulls
+                self.skip_buffer(); // Indices
+            }
+            Union(fields, mode) => {
+                self.skip_buffer(); // Nulls
+
+                match mode {
+                    UnionMode::Dense => self.skip_buffer(),
+                    UnionMode::Sparse => {}
+                };
+
+                for (_, field) in fields.iter() {
+                    self.skip_field(field)?
+                }
+            }
+            Null => {} // No buffer increases
+            _ => {
+                self.skip_buffer();
+                self.skip_buffer();
+            }
+        };
+        Ok(())
+    }
+}
+
+/// Creates a record batch from binary data using the `crate::RecordBatch` indexes and the `Schema`
+pub fn read_record_batch(
+    buf: &Buffer,
+    batch: crate::RecordBatch,
+    schema: SchemaRef,
+    dictionaries_by_id: &HashMap<i64, ArrayRef>,
+    projection: Option<&[usize]>,
+    metadata: &MetadataVersion,
+) -> Result<RecordBatch, ArrowError> {
+    let buffers = batch.buffers().ok_or_else(|| {
+        ArrowError::IpcError("Unable to get buffers from IPC RecordBatch".to_string())
+    })?;
+    let field_nodes = batch.nodes().ok_or_else(|| {
+        ArrowError::IpcError("Unable to get field nodes from IPC RecordBatch".to_string())
+    })?;
+    let batch_compression = batch.compression();
+    let compression = batch_compression
+        .map(|batch_compression| batch_compression.codec().try_into())
+        .transpose()?;
+
+    let mut reader = ArrayReader {
+        dictionaries_by_id,
+        compression,
+        version: *metadata,
+        data: buf,
+        nodes: field_nodes.iter(),
+        buffers: buffers.iter(),
+    };
+
+    let options = RecordBatchOptions::new().with_row_count(Some(batch.length() as usize));
+
+    if let Some(projection) = projection {
+        let mut arrays = vec![];
+        // project fields
+        for (idx, field) in schema.fields().iter().enumerate() {
+            // Create array for projected field
+            if let Some(proj_idx) = projection.iter().position(|p| p == &idx) {
+                let child = create_array(&mut reader, field)?;
+                arrays.push((proj_idx, child));
+            } else {
+                reader.skip_field(field)?;
+            }
+        }
+        arrays.sort_by_key(|t| t.0);
+        RecordBatch::try_new_with_options(
+            Arc::new(schema.project(projection)?),
+            arrays.into_iter().map(|t| t.1).collect(),
+            &options,
+        )
+    } else {
+        let mut children = vec![];
+        // keep track of index as lists require more than one node
+        for field in schema.fields() {
+            let child = create_array(&mut reader, field)?;
+            children.push(child);
+        }
+        RecordBatch::try_new_with_options(schema, children, &options)
+    }
+}
+
+/// Read the dictionary from the buffer and provided metadata,
+/// updating the `dictionaries_by_id` with the resulting dictionary
+pub fn read_dictionary(
+    buf: &Buffer,
+    batch: crate::DictionaryBatch,
+    schema: &Schema,
+    dictionaries_by_id: &mut HashMap<i64, ArrayRef>,
+    metadata: &MetadataVersion,
+) -> Result<(), ArrowError> {
+    if batch.isDelta() {
+        return Err(ArrowError::InvalidArgumentError(
+            "delta dictionary batches not supported".to_string(),
+        ));
+    }
+
+    let id = batch.id();
+    let fields_using_this_dictionary = schema.fields_with_dict_id(id);
+    let first_field = fields_using_this_dictionary.first().ok_or_else(|| {
+        ArrowError::InvalidArgumentError("dictionary id not found in schema".to_string())
+    })?;
+
+    // As the dictionary batch does not contain the type of the
+    // values array, we need to retrieve this from the schema.
+    // Get an array representing this dictionary's values.
+    let dictionary_values: ArrayRef = match first_field.data_type() {
+        DataType::Dictionary(_, ref value_type) => {
+            // Make a fake schema for the dictionary batch.
+            let value = value_type.as_ref().clone();
+            let schema = Schema::new(vec![Field::new("", value, true)]);
+            // Read a single column
+            let record_batch = read_record_batch(
+                buf,
+                batch.data().unwrap(),
+                Arc::new(schema),
+                dictionaries_by_id,
+                None,
+                metadata,
+            )?;
+            Some(record_batch.column(0).clone())
+        }
+        _ => None,
+    }
+    .ok_or_else(|| {
+        ArrowError::InvalidArgumentError("dictionary id not found in schema".to_string())
+    })?;
+
+    // We don't currently record the isOrdered field. This could be general
+    // attributes of arrays.
+    // Add (possibly multiple) array refs to the dictionaries array.
+    dictionaries_by_id.insert(id, dictionary_values.clone());
+
+    Ok(())
+}
+
+/// Read the data for a given block
+fn read_block<R: Read + Seek>(mut reader: R, block: &Block) -> Result<Buffer, ArrowError> {
+    reader.seek(SeekFrom::Start(block.offset() as u64))?;
+    let body_len = block.bodyLength().to_usize().unwrap();
+    let metadata_len = block.metaDataLength().to_usize().unwrap();
+    let total_len = body_len.checked_add(metadata_len).unwrap();
+
+    let mut buf = MutableBuffer::from_len_zeroed(total_len);
+    reader.read_exact(&mut buf)?;
+    Ok(buf.into())
+}
+
+/// Parse an encapsulated message
+///
+/// <https://arrow.apache.org/docs/format/Columnar.html#encapsulated-message-format>
+fn parse_message(buf: &[u8]) -> Result<Message, ArrowError> {
+    let buf = match buf[..4] == CONTINUATION_MARKER {
+        true => &buf[8..],
+        false => &buf[4..],
+    };
+    crate::root_as_message(buf)
+        .map_err(|err| ArrowError::ParseError(format!("Unable to get root as message: {err:?}")))
+}
+
+/// Read the footer length from the last 10 bytes of an Arrow IPC file
+///
+/// Expects a 4 byte footer length followed by `b"ARROW1"`
+pub fn read_footer_length(buf: [u8; 10]) -> Result<usize, ArrowError> {
+    if buf[4..] != super::ARROW_MAGIC {
+        return Err(ArrowError::ParseError(
+            "Arrow file does not contain correct footer".to_string(),
+        ));
+    }
+
+    // read footer length
+    let footer_len = i32::from_le_bytes(buf[..4].try_into().unwrap());
+    footer_len
+        .try_into()
+        .map_err(|_| ArrowError::ParseError(format!("Invalid footer length: {footer_len}")))
+}
+
+/// A low-level, push-based interface for reading an IPC file
+///
+/// For a higher-level interface see [`FileReader`]
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::*;
+/// # use arrow_array::types::Int32Type;
+/// # use arrow_buffer::Buffer;
+/// # use arrow_ipc::convert::fb_to_schema;
+/// # use arrow_ipc::reader::{FileDecoder, read_footer_length};
+/// # use arrow_ipc::root_as_footer;
+/// # use arrow_ipc::writer::FileWriter;
+/// // Write an IPC file
+///
+/// let batch = RecordBatch::try_from_iter([
+///     ("a", Arc::new(Int32Array::from(vec![1, 2, 3])) as _),
+///     ("b", Arc::new(Int32Array::from(vec![1, 2, 3])) as _),
+///     ("c", Arc::new(DictionaryArray::<Int32Type>::from_iter(["hello", "hello", "world"])) as _),
+/// ]).unwrap();
+///
+/// let schema = batch.schema();
+///
+/// let mut out = Vec::with_capacity(1024);
+/// let mut writer = FileWriter::try_new(&mut out, schema.as_ref()).unwrap();
+/// writer.write(&batch).unwrap();
+/// writer.finish().unwrap();
+///
+/// drop(writer);
+///
+/// // Read IPC file
+///
+/// let buffer = Buffer::from_vec(out);
+/// let trailer_start = buffer.len() - 10;
+/// let footer_len = read_footer_length(buffer[trailer_start..].try_into().unwrap()).unwrap();
+/// let footer = root_as_footer(&buffer[trailer_start - footer_len..trailer_start]).unwrap();
+///
+/// let back = fb_to_schema(footer.schema().unwrap());
+/// assert_eq!(&back, schema.as_ref());
+///
+/// let mut decoder = FileDecoder::new(schema, footer.version());
+///
+/// // Read dictionaries
+/// for block in footer.dictionaries().iter().flatten() {
+///     let block_len = block.bodyLength() as usize + block.metaDataLength() as usize;
+///     let data = buffer.slice_with_length(block.offset() as _, block_len);
+///     decoder.read_dictionary(&block, &data).unwrap();
+/// }
+///
+/// // Read record batch
+/// let batches = footer.recordBatches().unwrap();
+/// assert_eq!(batches.len(), 1); // Only wrote a single batch
+///
+/// let block = batches.get(0);
+/// let block_len = block.bodyLength() as usize + block.metaDataLength() as usize;
+/// let data = buffer.slice_with_length(block.offset() as _, block_len);
+/// let back = decoder.read_record_batch(block, &data).unwrap().unwrap();
+///
+/// assert_eq!(batch, back);
+/// ```
+#[derive(Debug)]
+pub struct FileDecoder {
+    schema: SchemaRef,
+    dictionaries: HashMap<i64, ArrayRef>,
+    version: MetadataVersion,
+    projection: Option<Vec<usize>>,
+}
+
+impl FileDecoder {
+    /// Create a new [`FileDecoder`] with the given schema and version
+    pub fn new(schema: SchemaRef, version: MetadataVersion) -> Self {
+        Self {
+            schema,
+            version,
+            dictionaries: Default::default(),
+            projection: None,
+        }
+    }
+
+    /// Specify a projection
+    pub fn with_projection(mut self, projection: Vec<usize>) -> Self {
+        self.projection = Some(projection);
+        self
+    }
+
+    fn read_message<'a>(&self, buf: &'a [u8]) -> Result<Message<'a>, ArrowError> {
+        let message = parse_message(buf)?;
+
+        // some old test data's footer metadata is not set, so we account for that
+        if self.version != MetadataVersion::V1 && message.version() != self.version {
+            return Err(ArrowError::IpcError(
+                "Could not read IPC message as metadata versions mismatch".to_string(),
+            ));
+        }
+        Ok(message)
+    }
+
+    /// Read the dictionary with the given block and data buffer
+    pub fn read_dictionary(&mut self, block: &Block, buf: &Buffer) -> Result<(), ArrowError> {
+        let message = self.read_message(buf)?;
+        match message.header_type() {
+            crate::MessageHeader::DictionaryBatch => {
+                let batch = message.header_as_dictionary_batch().unwrap();
+                read_dictionary(
+                    &buf.slice(block.metaDataLength() as _),
+                    batch,
+                    &self.schema,
+                    &mut self.dictionaries,
+                    &message.version(),
+                )
+            }
+            t => Err(ArrowError::ParseError(format!(
+                "Expecting DictionaryBatch in dictionary blocks, found {t:?}."
+            ))),
+        }
+    }
+
+    /// Read the RecordBatch with the given block and data buffer
+    pub fn read_record_batch(
+        &self,
+        block: &Block,
+        buf: &Buffer,
+    ) -> Result<Option<RecordBatch>, ArrowError> {
+        let message = self.read_message(buf)?;
+        match message.header_type() {
+            crate::MessageHeader::Schema => Err(ArrowError::IpcError(
+                "Not expecting a schema when messages are read".to_string(),
+            )),
+            crate::MessageHeader::RecordBatch => {
+                let batch = message.header_as_record_batch().ok_or_else(|| {
+                    ArrowError::IpcError("Unable to read IPC message as record batch".to_string())
+                })?;
+                // read the block that makes up the record batch into a buffer
+                read_record_batch(
+                    &buf.slice(block.metaDataLength() as _),
+                    batch,
+                    self.schema.clone(),
+                    &self.dictionaries,
+                    self.projection.as_deref(),
+                    &message.version(),
+                )
+                .map(Some)
+            }
+            crate::MessageHeader::NONE => Ok(None),
+            t => Err(ArrowError::InvalidArgumentError(format!(
+                "Reading types other than record batches not yet supported, unable to read {t:?}"
+            ))),
+        }
+    }
+}
+
+/// Build an Arrow [`FileReader`] with custom options.
+#[derive(Debug)]
+pub struct FileReaderBuilder {
+    /// Optional projection for which columns to load (zero-based column indices)
+    projection: Option<Vec<usize>>,
+    /// Passed through to construct [`VerifierOptions`]
+    max_footer_fb_tables: usize,
+    /// Passed through to construct [`VerifierOptions`]
+    max_footer_fb_depth: usize,
+}
+
+impl Default for FileReaderBuilder {
+    fn default() -> Self {
+        let verifier_options = VerifierOptions::default();
+        Self {
+            max_footer_fb_tables: verifier_options.max_tables,
+            max_footer_fb_depth: verifier_options.max_depth,
+            projection: None,
+        }
+    }
+}
+
+impl FileReaderBuilder {
+    /// Options for creating a new [`FileReader`].
+    ///
+    /// To convert a builder into a reader, call [`FileReaderBuilder::build`].
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Optional projection for which columns to load (zero-based column indices).
+    pub fn with_projection(mut self, projection: Vec<usize>) -> Self {
+        self.projection = Some(projection);
+        self
+    }
+
+    /// Flatbuffers option for parsing the footer. Controls the max number of fields and
+    /// metadata key-value pairs that can be parsed from the schema of the footer.
+    ///
+    /// By default this is set to `1_000_000` which roughly translates to a schema with
+    /// no metadata key-value pairs but 499,999 fields.
+    ///
+    /// This default limit is enforced to protect against malicious files with a massive
+    /// amount of flatbuffer tables which could cause a denial of service attack.
+    ///
+    /// If you need to ingest a trusted file with a massive number of fields and/or
+    /// metadata key-value pairs and are facing the error `"Unable to get root as
+    /// footer: TooManyTables"` then increase this parameter as necessary.
+    pub fn with_max_footer_fb_tables(mut self, max_footer_fb_tables: usize) -> Self {
+        self.max_footer_fb_tables = max_footer_fb_tables;
+        self
+    }
+
+    /// Flatbuffers option for parsing the footer. Controls the max depth for schemas with
+    /// nested fields parsed from the footer.
+    ///
+    /// By default this is set to `64` which roughly translates to a schema with
+    /// a field nested 60 levels down through other struct fields.
+    ///
+    /// This default limit is enforced to protect against malicious files with a extremely
+    /// deep flatbuffer structure which could cause a denial of service attack.
+    ///
+    /// If you need to ingest a trusted file with a deeply nested field and are facing the
+    /// error `"Unable to get root as footer: DepthLimitReached"` then increase this
+    /// parameter as necessary.
+    pub fn with_max_footer_fb_depth(mut self, max_footer_fb_depth: usize) -> Self {
+        self.max_footer_fb_depth = max_footer_fb_depth;
+        self
+    }
+
+    /// Build [`FileReader`] with given reader.
+    pub fn build<R: Read + Seek>(self, mut reader: R) -> Result<FileReader<R>, ArrowError> {
+        // Space for ARROW_MAGIC (6 bytes) and length (4 bytes)
+        let mut buffer = [0; 10];
+        reader.seek(SeekFrom::End(-10))?;
+        reader.read_exact(&mut buffer)?;
+
+        let footer_len = read_footer_length(buffer)?;
+
+        // read footer
+        let mut footer_data = vec![0; footer_len];
+        reader.seek(SeekFrom::End(-10 - footer_len as i64))?;
+        reader.read_exact(&mut footer_data)?;
+
+        let verifier_options = VerifierOptions {
+            max_tables: self.max_footer_fb_tables,
+            max_depth: self.max_footer_fb_depth,
+            ..Default::default()
+        };
+        let footer = crate::root_as_footer_with_opts(&verifier_options, &footer_data[..]).map_err(
+            |err| ArrowError::ParseError(format!("Unable to get root as footer: {err:?}")),
+        )?;
+
+        let blocks = footer.recordBatches().ok_or_else(|| {
+            ArrowError::ParseError("Unable to get record batches from IPC Footer".to_string())
+        })?;
+
+        let total_blocks = blocks.len();
+
+        let ipc_schema = footer.schema().unwrap();
+        if !ipc_schema.endianness().equals_to_target_endianness() {
+            return Err(ArrowError::IpcError(
+                "the endianness of the source system does not match the endianness of the target system.".to_owned()
+            ));
+        }
+
+        let schema = crate::convert::fb_to_schema(ipc_schema);
+
+        let mut custom_metadata = HashMap::new();
+        if let Some(fb_custom_metadata) = footer.custom_metadata() {
+            for kv in fb_custom_metadata.into_iter() {
+                custom_metadata.insert(
+                    kv.key().unwrap().to_string(),
+                    kv.value().unwrap().to_string(),
+                );
+            }
+        }
+
+        let mut decoder = FileDecoder::new(Arc::new(schema), footer.version());
+        if let Some(projection) = self.projection {
+            decoder = decoder.with_projection(projection)
+        }
+
+        // Create an array of optional dictionary value arrays, one per field.
+        if let Some(dictionaries) = footer.dictionaries() {
+            for block in dictionaries {
+                let buf = read_block(&mut reader, block)?;
+                decoder.read_dictionary(block, &buf)?;
+            }
+        }
+
+        Ok(FileReader {
+            reader,
+            blocks: blocks.iter().copied().collect(),
+            current_block: 0,
+            total_blocks,
+            decoder,
+            custom_metadata,
+        })
+    }
+}
+
+/// Arrow File reader
+pub struct FileReader<R: Read + Seek> {
+    /// Buffered file reader that supports reading and seeking
+    reader: R,
+
+    /// The decoder
+    decoder: FileDecoder,
+
+    /// The blocks in the file
+    ///
+    /// A block indicates the regions in the file to read to get data
+    blocks: Vec<Block>,
+
+    /// A counter to keep track of the current block that should be read
+    current_block: usize,
+
+    /// The total number of blocks, which may contain record batches and other types
+    total_blocks: usize,
+
+    /// User defined metadata
+    custom_metadata: HashMap<String, String>,
+}
+
+impl<R: Read + Seek> fmt::Debug for FileReader<R> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> Result<(), fmt::Error> {
+        f.debug_struct("FileReader<R>")
+            .field("decoder", &self.decoder)
+            .field("blocks", &self.blocks)
+            .field("current_block", &self.current_block)
+            .field("total_blocks", &self.total_blocks)
+            .finish_non_exhaustive()
+    }
+}
+
+impl<R: Read + Seek> FileReader<R> {
+    /// Try to create a new file reader
+    ///
+    /// Returns errors if the file does not meet the Arrow Format footer requirements
+    pub fn try_new(reader: R, projection: Option<Vec<usize>>) -> Result<Self, ArrowError> {
+        let builder = FileReaderBuilder {
+            projection,
+            ..Default::default()
+        };
+        builder.build(reader)
+    }
+
+    /// Return user defined customized metadata
+    pub fn custom_metadata(&self) -> &HashMap<String, String> {
+        &self.custom_metadata
+    }
+
+    /// Return the number of batches in the file
+    pub fn num_batches(&self) -> usize {
+        self.total_blocks
+    }
+
+    /// Return the schema of the file
+    pub fn schema(&self) -> SchemaRef {
+        self.decoder.schema.clone()
+    }
+
+    /// Read a specific record batch
+    ///
+    /// Sets the current block to the index, allowing random reads
+    pub fn set_index(&mut self, index: usize) -> Result<(), ArrowError> {
+        if index >= self.total_blocks {
+            Err(ArrowError::InvalidArgumentError(format!(
+                "Cannot set batch to index {} from {} total batches",
+                index, self.total_blocks
+            )))
+        } else {
+            self.current_block = index;
+            Ok(())
+        }
+    }
+
+    fn maybe_next(&mut self) -> Result<Option<RecordBatch>, ArrowError> {
+        let block = &self.blocks[self.current_block];
+        self.current_block += 1;
+
+        // read length
+        let buffer = read_block(&mut self.reader, block)?;
+        self.decoder.read_record_batch(block, &buffer)
+    }
+
+    /// Gets a reference to the underlying reader.
+    ///
+    /// It is inadvisable to directly read from the underlying reader.
+    pub fn get_ref(&self) -> &R {
+        &self.reader
+    }
+
+    /// Gets a mutable reference to the underlying reader.
+    ///
+    /// It is inadvisable to directly read from the underlying reader.
+    pub fn get_mut(&mut self) -> &mut R {
+        &mut self.reader
+    }
+}
+
+impl<R: Read + Seek> Iterator for FileReader<R> {
+    type Item = Result<RecordBatch, ArrowError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        // get current block
+        if self.current_block < self.total_blocks {
+            self.maybe_next().transpose()
+        } else {
+            None
+        }
+    }
+}
+
+impl<R: Read + Seek> RecordBatchReader for FileReader<R> {
+    fn schema(&self) -> SchemaRef {
+        self.schema()
+    }
+}
+
+/// Arrow Stream reader
+pub struct StreamReader<R: Read> {
+    /// Stream reader
+    reader: R,
+
+    /// The schema that is read from the stream's first message
+    schema: SchemaRef,
+
+    /// Optional dictionaries for each schema field.
+    ///
+    /// Dictionaries may be appended to in the streaming format.
+    dictionaries_by_id: HashMap<i64, ArrayRef>,
+
+    /// An indicator of whether the stream is complete.
+    ///
+    /// This value is set to `true` the first time the reader's `next()` returns `None`.
+    finished: bool,
+
+    /// Optional projection
+    projection: Option<(Vec<usize>, Schema)>,
+}
+
+impl<R: Read> fmt::Debug for StreamReader<R> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> std::result::Result<(), fmt::Error> {
+        f.debug_struct("StreamReader<R>")
+            .field("reader", &"BufReader<..>")
+            .field("schema", &self.schema)
+            .field("dictionaries_by_id", &self.dictionaries_by_id)
+            .field("finished", &self.finished)
+            .field("projection", &self.projection)
+            .finish()
+    }
+}
+
+impl<R: Read> StreamReader<BufReader<R>> {
+    /// Try to create a new stream reader with the reader wrapped in a BufReader
+    ///
+    /// The first message in the stream is the schema, the reader will fail if it does not
+    /// encounter a schema.
+    /// To check if the reader is done, use `is_finished(self)`
+    pub fn try_new(reader: R, projection: Option<Vec<usize>>) -> Result<Self, ArrowError> {
+        Self::try_new_unbuffered(BufReader::new(reader), projection)
+    }
+}
+
+impl<R: Read> StreamReader<R> {
+    /// Try to create a new stream reader but do not wrap the reader in a BufReader.
+    ///
+    /// Unless you need the StreamReader to be unbuffered you likely want to use `StreamReader::try_new` instead.
+    pub fn try_new_unbuffered(
+        mut reader: R,
+        projection: Option<Vec<usize>>,
+    ) -> Result<StreamReader<R>, ArrowError> {
+        // determine metadata length
+        let mut meta_size: [u8; 4] = [0; 4];
+        reader.read_exact(&mut meta_size)?;
+        let meta_len = {
+            // If a continuation marker is encountered, skip over it and read
+            // the size from the next four bytes.
+            if meta_size == CONTINUATION_MARKER {
+                reader.read_exact(&mut meta_size)?;
+            }
+            i32::from_le_bytes(meta_size)
+        };
+
+        let mut meta_buffer = vec![0; meta_len as usize];
+        reader.read_exact(&mut meta_buffer)?;
+
+        let message = crate::root_as_message(meta_buffer.as_slice()).map_err(|err| {
+            ArrowError::ParseError(format!("Unable to get root as message: {err:?}"))
+        })?;
+        // message header is a Schema, so read it
+        let ipc_schema: crate::Schema = message.header_as_schema().ok_or_else(|| {
+            ArrowError::ParseError("Unable to read IPC message as schema".to_string())
+        })?;
+        let schema = crate::convert::fb_to_schema(ipc_schema);
+
+        // Create an array of optional dictionary value arrays, one per field.
+        let dictionaries_by_id = HashMap::new();
+
+        let projection = match projection {
+            Some(projection_indices) => {
+                let schema = schema.project(&projection_indices)?;
+                Some((projection_indices, schema))
+            }
+            _ => None,
+        };
+        Ok(Self {
+            reader,
+            schema: Arc::new(schema),
+            finished: false,
+            dictionaries_by_id,
+            projection,
+        })
+    }
+
+    /// Return the schema of the stream
+    pub fn schema(&self) -> SchemaRef {
+        self.schema.clone()
+    }
+
+    /// Check if the stream is finished
+    pub fn is_finished(&self) -> bool {
+        self.finished
+    }
+
+    fn maybe_next(&mut self) -> Result<Option<RecordBatch>, ArrowError> {
+        if self.finished {
+            return Ok(None);
+        }
+        // determine metadata length
+        let mut meta_size: [u8; 4] = [0; 4];
+
+        match self.reader.read_exact(&mut meta_size) {
+            Ok(()) => (),
+            Err(e) => {
+                return if e.kind() == std::io::ErrorKind::UnexpectedEof {
+                    // Handle EOF without the "0xFFFFFFFF 0x00000000"
+                    // valid according to:
+                    // https://arrow.apache.org/docs/format/Columnar.html#ipc-streaming-format
+                    self.finished = true;
+                    Ok(None)
+                } else {
+                    Err(ArrowError::from(e))
+                };
+            }
+        }
+
+        let meta_len = {
+            // If a continuation marker is encountered, skip over it and read
+            // the size from the next four bytes.
+            if meta_size == CONTINUATION_MARKER {
+                self.reader.read_exact(&mut meta_size)?;
+            }
+            i32::from_le_bytes(meta_size)
+        };
+
+        if meta_len == 0 {
+            // the stream has ended, mark the reader as finished
+            self.finished = true;
+            return Ok(None);
+        }
+
+        let mut meta_buffer = vec![0; meta_len as usize];
+        self.reader.read_exact(&mut meta_buffer)?;
+
+        let vecs = &meta_buffer.to_vec();
+        let message = crate::root_as_message(vecs).map_err(|err| {
+            ArrowError::ParseError(format!("Unable to get root as message: {err:?}"))
+        })?;
+
+        match message.header_type() {
+            crate::MessageHeader::Schema => Err(ArrowError::IpcError(
+                "Not expecting a schema when messages are read".to_string(),
+            )),
+            crate::MessageHeader::RecordBatch => {
+                let batch = message.header_as_record_batch().ok_or_else(|| {
+                    ArrowError::IpcError("Unable to read IPC message as record batch".to_string())
+                })?;
+                // read the block that makes up the record batch into a buffer
+                let mut buf = MutableBuffer::from_len_zeroed(message.bodyLength() as usize);
+                self.reader.read_exact(&mut buf)?;
+
+                read_record_batch(
+                    &buf.into(),
+                    batch,
+                    self.schema(),
+                    &self.dictionaries_by_id,
+                    self.projection.as_ref().map(|x| x.0.as_ref()),
+                    &message.version(),
+                )
+                .map(Some)
+            }
+            crate::MessageHeader::DictionaryBatch => {
+                let batch = message.header_as_dictionary_batch().ok_or_else(|| {
+                    ArrowError::IpcError(
+                        "Unable to read IPC message as dictionary batch".to_string(),
+                    )
+                })?;
+                // read the block that makes up the dictionary batch into a buffer
+                let mut buf = MutableBuffer::from_len_zeroed(message.bodyLength() as usize);
+                self.reader.read_exact(&mut buf)?;
+
+                read_dictionary(
+                    &buf.into(),
+                    batch,
+                    &self.schema,
+                    &mut self.dictionaries_by_id,
+                    &message.version(),
+                )?;
+
+                // read the next message until we encounter a RecordBatch
+                self.maybe_next()
+            }
+            crate::MessageHeader::NONE => Ok(None),
+            t => Err(ArrowError::InvalidArgumentError(format!(
+                "Reading types other than record batches not yet supported, unable to read {t:?} "
+            ))),
+        }
+    }
+
+    /// Gets a reference to the underlying reader.
+    ///
+    /// It is inadvisable to directly read from the underlying reader.
+    pub fn get_ref(&self) -> &R {
+        &self.reader
+    }
+
+    /// Gets a mutable reference to the underlying reader.
+    ///
+    /// It is inadvisable to directly read from the underlying reader.
+    pub fn get_mut(&mut self) -> &mut R {
+        &mut self.reader
+    }
+}
+
+impl<R: Read> Iterator for StreamReader<R> {
+    type Item = Result<RecordBatch, ArrowError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.maybe_next().transpose()
+    }
+}
+
+impl<R: Read> RecordBatchReader for StreamReader<R> {
+    fn schema(&self) -> SchemaRef {
+        self.schema.clone()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::writer::{unslice_run_array, DictionaryTracker, IpcDataGenerator};
+
+    use super::*;
+
+    use crate::root_as_message;
+    use arrow_array::builder::{PrimitiveRunBuilder, UnionBuilder};
+    use arrow_array::types::*;
+    use arrow_buffer::ArrowNativeType;
+    use arrow_data::ArrayDataBuilder;
+
+    fn create_test_projection_schema() -> Schema {
+        // define field types
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, true)));
+
+        let fixed_size_list_data_type =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, false)), 3);
+
+        let union_fields = UnionFields::new(
+            vec![0, 1],
+            vec![
+                Field::new("a", DataType::Int32, false),
+                Field::new("b", DataType::Float64, false),
+            ],
+        );
+
+        let union_data_type = DataType::Union(union_fields, UnionMode::Dense);
+
+        let struct_fields = Fields::from(vec![
+            Field::new("id", DataType::Int32, false),
+            Field::new_list("list", Field::new("item", DataType::Int8, true), false),
+        ]);
+        let struct_data_type = DataType::Struct(struct_fields);
+
+        let run_encoded_data_type = DataType::RunEndEncoded(
+            Arc::new(Field::new("run_ends", DataType::Int16, false)),
+            Arc::new(Field::new("values", DataType::Int32, true)),
+        );
+
+        // define schema
+        Schema::new(vec![
+            Field::new("f0", DataType::UInt32, false),
+            Field::new("f1", DataType::Utf8, false),
+            Field::new("f2", DataType::Boolean, false),
+            Field::new("f3", union_data_type, true),
+            Field::new("f4", DataType::Null, true),
+            Field::new("f5", DataType::Float64, true),
+            Field::new("f6", list_data_type, false),
+            Field::new("f7", DataType::FixedSizeBinary(3), true),
+            Field::new("f8", fixed_size_list_data_type, false),
+            Field::new("f9", struct_data_type, false),
+            Field::new("f10", run_encoded_data_type, false),
+            Field::new("f11", DataType::Boolean, false),
+            Field::new_dictionary("f12", DataType::Int8, DataType::Utf8, false),
+            Field::new("f13", DataType::Utf8, false),
+        ])
+    }
+
+    fn create_test_projection_batch_data(schema: &Schema) -> RecordBatch {
+        // set test data for each column
+        let array0 = UInt32Array::from(vec![1, 2, 3]);
+        let array1 = StringArray::from(vec!["foo", "bar", "baz"]);
+        let array2 = BooleanArray::from(vec![true, false, true]);
+
+        let mut union_builder = UnionBuilder::new_dense();
+        union_builder.append::<Int32Type>("a", 1).unwrap();
+        union_builder.append::<Float64Type>("b", 10.1).unwrap();
+        union_builder.append_null::<Float64Type>("b").unwrap();
+        let array3 = union_builder.build().unwrap();
+
+        let array4 = NullArray::new(3);
+        let array5 = Float64Array::from(vec![Some(1.1), None, Some(3.3)]);
+        let array6_values = vec![
+            Some(vec![Some(10), Some(10), Some(10)]),
+            Some(vec![Some(20), Some(20), Some(20)]),
+            Some(vec![Some(30), Some(30)]),
+        ];
+        let array6 = ListArray::from_iter_primitive::<Int32Type, _, _>(array6_values);
+        let array7_values = vec![vec![11, 12, 13], vec![22, 23, 24], vec![33, 34, 35]];
+        let array7 = FixedSizeBinaryArray::try_from_iter(array7_values.into_iter()).unwrap();
+
+        let array8_values = ArrayData::builder(DataType::Int32)
+            .len(9)
+            .add_buffer(Buffer::from_slice_ref([40, 41, 42, 43, 44, 45, 46, 47, 48]))
+            .build()
+            .unwrap();
+        let array8_data = ArrayData::builder(schema.field(8).data_type().clone())
+            .len(3)
+            .add_child_data(array8_values)
+            .build()
+            .unwrap();
+        let array8 = FixedSizeListArray::from(array8_data);
+
+        let array9_id: ArrayRef = Arc::new(Int32Array::from(vec![1001, 1002, 1003]));
+        let array9_list: ArrayRef =
+            Arc::new(ListArray::from_iter_primitive::<Int8Type, _, _>(vec![
+                Some(vec![Some(-10)]),
+                Some(vec![Some(-20), Some(-20), Some(-20)]),
+                Some(vec![Some(-30)]),
+            ]));
+        let array9 = ArrayDataBuilder::new(schema.field(9).data_type().clone())
+            .add_child_data(array9_id.into_data())
+            .add_child_data(array9_list.into_data())
+            .len(3)
+            .build()
+            .unwrap();
+        let array9: ArrayRef = Arc::new(StructArray::from(array9));
+
+        let array10_input = vec![Some(1_i32), None, None];
+        let mut array10_builder = PrimitiveRunBuilder::<Int16Type, Int32Type>::new();
+        array10_builder.extend(array10_input);
+        let array10 = array10_builder.finish();
+
+        let array11 = BooleanArray::from(vec![false, false, true]);
+
+        let array12_values = StringArray::from(vec!["x", "yy", "zzz"]);
+        let array12_keys = Int8Array::from_iter_values([1, 1, 2]);
+        let array12 = DictionaryArray::new(array12_keys, Arc::new(array12_values));
+
+        let array13 = StringArray::from(vec!["a", "bb", "ccc"]);
+
+        // create record batch
+        RecordBatch::try_new(
+            Arc::new(schema.clone()),
+            vec![
+                Arc::new(array0),
+                Arc::new(array1),
+                Arc::new(array2),
+                Arc::new(array3),
+                Arc::new(array4),
+                Arc::new(array5),
+                Arc::new(array6),
+                Arc::new(array7),
+                Arc::new(array8),
+                Arc::new(array9),
+                Arc::new(array10),
+                Arc::new(array11),
+                Arc::new(array12),
+                Arc::new(array13),
+            ],
+        )
+        .unwrap()
+    }
+
+    #[test]
+    fn test_projection_array_values() {
+        // define schema
+        let schema = create_test_projection_schema();
+
+        // create record batch with test data
+        let batch = create_test_projection_batch_data(&schema);
+
+        // write record batch in IPC format
+        let mut buf = Vec::new();
+        {
+            let mut writer = crate::writer::FileWriter::try_new(&mut buf, &schema).unwrap();
+            writer.write(&batch).unwrap();
+            writer.finish().unwrap();
+        }
+
+        // read record batch with projection
+        for index in 0..12 {
+            let projection = vec![index];
+            let reader = FileReader::try_new(std::io::Cursor::new(buf.clone()), Some(projection));
+            let read_batch = reader.unwrap().next().unwrap().unwrap();
+            let projected_column = read_batch.column(0);
+            let expected_column = batch.column(index);
+
+            // check the projected column equals the expected column
+            assert_eq!(projected_column.as_ref(), expected_column.as_ref());
+        }
+
+        {
+            // read record batch with reversed projection
+            let reader =
+                FileReader::try_new(std::io::Cursor::new(buf.clone()), Some(vec![3, 2, 1]));
+            let read_batch = reader.unwrap().next().unwrap().unwrap();
+            let expected_batch = batch.project(&[3, 2, 1]).unwrap();
+            assert_eq!(read_batch, expected_batch);
+        }
+    }
+
+    #[test]
+    fn test_arrow_single_float_row() {
+        let schema = Schema::new(vec![
+            Field::new("a", DataType::Float32, false),
+            Field::new("b", DataType::Float32, false),
+            Field::new("c", DataType::Int32, false),
+            Field::new("d", DataType::Int32, false),
+        ]);
+        let arrays = vec![
+            Arc::new(Float32Array::from(vec![1.23])) as ArrayRef,
+            Arc::new(Float32Array::from(vec![-6.50])) as ArrayRef,
+            Arc::new(Int32Array::from(vec![2])) as ArrayRef,
+            Arc::new(Int32Array::from(vec![1])) as ArrayRef,
+        ];
+        let batch = RecordBatch::try_new(Arc::new(schema.clone()), arrays).unwrap();
+        // create stream writer
+        let mut file = tempfile::tempfile().unwrap();
+        let mut stream_writer = crate::writer::StreamWriter::try_new(&mut file, &schema).unwrap();
+        stream_writer.write(&batch).unwrap();
+        stream_writer.finish().unwrap();
+
+        drop(stream_writer);
+
+        file.rewind().unwrap();
+
+        // read stream back
+        let reader = StreamReader::try_new(&mut file, None).unwrap();
+
+        reader.for_each(|batch| {
+            let batch = batch.unwrap();
+            assert!(
+                batch
+                    .column(0)
+                    .as_any()
+                    .downcast_ref::<Float32Array>()
+                    .unwrap()
+                    .value(0)
+                    != 0.0
+            );
+            assert!(
+                batch
+                    .column(1)
+                    .as_any()
+                    .downcast_ref::<Float32Array>()
+                    .unwrap()
+                    .value(0)
+                    != 0.0
+            );
+        });
+
+        file.rewind().unwrap();
+
+        // Read with projection
+        let reader = StreamReader::try_new(file, Some(vec![0, 3])).unwrap();
+
+        reader.for_each(|batch| {
+            let batch = batch.unwrap();
+            assert_eq!(batch.schema().fields().len(), 2);
+            assert_eq!(batch.schema().fields()[0].data_type(), &DataType::Float32);
+            assert_eq!(batch.schema().fields()[1].data_type(), &DataType::Int32);
+        });
+    }
+
+    fn roundtrip_ipc(rb: &RecordBatch) -> RecordBatch {
+        let mut buf = Vec::new();
+        let mut writer = crate::writer::FileWriter::try_new(&mut buf, &rb.schema()).unwrap();
+        writer.write(rb).unwrap();
+        writer.finish().unwrap();
+        drop(writer);
+
+        let mut reader = FileReader::try_new(std::io::Cursor::new(buf), None).unwrap();
+        reader.next().unwrap().unwrap()
+    }
+
+    fn roundtrip_ipc_stream(rb: &RecordBatch) -> RecordBatch {
+        let mut buf = Vec::new();
+        let mut writer = crate::writer::StreamWriter::try_new(&mut buf, &rb.schema()).unwrap();
+        writer.write(rb).unwrap();
+        writer.finish().unwrap();
+        drop(writer);
+
+        let mut reader =
+            crate::reader::StreamReader::try_new(std::io::Cursor::new(buf), None).unwrap();
+        reader.next().unwrap().unwrap()
+    }
+
+    #[test]
+    fn test_roundtrip_with_custom_metadata() {
+        let schema = Schema::new(vec![Field::new("dummy", DataType::Float64, false)]);
+        let mut buf = Vec::new();
+        let mut writer = crate::writer::FileWriter::try_new(&mut buf, &schema).unwrap();
+        let mut test_metadata = HashMap::new();
+        test_metadata.insert("abc".to_string(), "abc".to_string());
+        test_metadata.insert("def".to_string(), "def".to_string());
+        for (k, v) in &test_metadata {
+            writer.write_metadata(k, v);
+        }
+        writer.finish().unwrap();
+        drop(writer);
+
+        let reader = crate::reader::FileReader::try_new(std::io::Cursor::new(buf), None).unwrap();
+        assert_eq!(reader.custom_metadata(), &test_metadata);
+    }
+
+    #[test]
+    fn test_roundtrip_nested_dict() {
+        let inner: DictionaryArray<Int32Type> = vec!["a", "b", "a"].into_iter().collect();
+
+        let array = Arc::new(inner) as ArrayRef;
+
+        let dctfield = Arc::new(Field::new("dict", array.data_type().clone(), false));
+
+        let s = StructArray::from(vec![(dctfield, array)]);
+        let struct_array = Arc::new(s) as ArrayRef;
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "struct",
+            struct_array.data_type().clone(),
+            false,
+        )]));
+
+        let batch = RecordBatch::try_new(schema, vec![struct_array]).unwrap();
+
+        assert_eq!(batch, roundtrip_ipc(&batch));
+    }
+
+    fn check_union_with_builder(mut builder: UnionBuilder) {
+        builder.append::<Int32Type>("a", 1).unwrap();
+        builder.append_null::<Int32Type>("a").unwrap();
+        builder.append::<Float64Type>("c", 3.0).unwrap();
+        builder.append::<Int32Type>("a", 4).unwrap();
+        builder.append::<Int64Type>("d", 11).unwrap();
+        let union = builder.build().unwrap();
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "union",
+            union.data_type().clone(),
+            false,
+        )]));
+
+        let union_array = Arc::new(union) as ArrayRef;
+
+        let rb = RecordBatch::try_new(schema, vec![union_array]).unwrap();
+        let rb2 = roundtrip_ipc(&rb);
+        // TODO: equality not yet implemented for union, so we check that the length of the array is
+        // the same and that all of the buffers are the same instead.
+        assert_eq!(rb.schema(), rb2.schema());
+        assert_eq!(rb.num_columns(), rb2.num_columns());
+        assert_eq!(rb.num_rows(), rb2.num_rows());
+        let union1 = rb.column(0);
+        let union2 = rb2.column(0);
+
+        assert_eq!(union1, union2);
+    }
+
+    #[test]
+    fn test_roundtrip_dense_union() {
+        check_union_with_builder(UnionBuilder::new_dense());
+    }
+
+    #[test]
+    fn test_roundtrip_sparse_union() {
+        check_union_with_builder(UnionBuilder::new_sparse());
+    }
+
+    #[test]
+    fn test_roundtrip_stream_run_array_sliced() {
+        let run_array_1: Int32RunArray = vec!["a", "a", "a", "b", "b", "c", "c", "c"]
+            .into_iter()
+            .collect();
+        let run_array_1_sliced = run_array_1.slice(2, 5);
+
+        let run_array_2_inupt = vec![Some(1_i32), None, None, Some(2), Some(2)];
+        let mut run_array_2_builder = PrimitiveRunBuilder::<Int16Type, Int32Type>::new();
+        run_array_2_builder.extend(run_array_2_inupt);
+        let run_array_2 = run_array_2_builder.finish();
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new(
+                "run_array_1_sliced",
+                run_array_1_sliced.data_type().clone(),
+                false,
+            ),
+            Field::new("run_array_2", run_array_2.data_type().clone(), false),
+        ]));
+        let input_batch = RecordBatch::try_new(
+            schema,
+            vec![Arc::new(run_array_1_sliced.clone()), Arc::new(run_array_2)],
+        )
+        .unwrap();
+        let output_batch = roundtrip_ipc_stream(&input_batch);
+
+        // As partial comparison not yet supported for run arrays, the sliced run array
+        // has to be unsliced before comparing with the output. the second run array
+        // can be compared as such.
+        assert_eq!(input_batch.column(1), output_batch.column(1));
+
+        let run_array_1_unsliced = unslice_run_array(run_array_1_sliced.into_data()).unwrap();
+        assert_eq!(run_array_1_unsliced, output_batch.column(0).into_data());
+    }
+
+    #[test]
+    fn test_roundtrip_stream_nested_dict() {
+        let xs = vec!["AA", "BB", "AA", "CC", "BB"];
+        let dict = Arc::new(
+            xs.clone()
+                .into_iter()
+                .collect::<DictionaryArray<Int8Type>>(),
+        );
+        let string_array: ArrayRef = Arc::new(StringArray::from(xs.clone()));
+        let struct_array = StructArray::from(vec![
+            (
+                Arc::new(Field::new("f2.1", DataType::Utf8, false)),
+                string_array,
+            ),
+            (
+                Arc::new(Field::new("f2.2_struct", dict.data_type().clone(), false)),
+                dict.clone() as ArrayRef,
+            ),
+        ]);
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("f1_string", DataType::Utf8, false),
+            Field::new("f2_struct", struct_array.data_type().clone(), false),
+        ]));
+        let input_batch = RecordBatch::try_new(
+            schema,
+            vec![
+                Arc::new(StringArray::from(xs.clone())),
+                Arc::new(struct_array),
+            ],
+        )
+        .unwrap();
+        let output_batch = roundtrip_ipc_stream(&input_batch);
+        assert_eq!(input_batch, output_batch);
+    }
+
+    #[test]
+    fn test_roundtrip_stream_nested_dict_of_map_of_dict() {
+        let values = StringArray::from(vec![Some("a"), None, Some("b"), Some("c")]);
+        let values = Arc::new(values) as ArrayRef;
+        let value_dict_keys = Int8Array::from_iter_values([0, 1, 1, 2, 3, 1]);
+        let value_dict_array = DictionaryArray::new(value_dict_keys, values.clone());
+
+        let key_dict_keys = Int8Array::from_iter_values([0, 0, 2, 1, 1, 3]);
+        let key_dict_array = DictionaryArray::new(key_dict_keys, values);
+
+        let keys_field = Arc::new(Field::new_dict(
+            "keys",
+            DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
+            true, // It is technically not legal for this field to be null.
+            1,
+            false,
+        ));
+        let values_field = Arc::new(Field::new_dict(
+            "values",
+            DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
+            true,
+            1,
+            false,
+        ));
+        let entry_struct = StructArray::from(vec![
+            (keys_field, make_array(key_dict_array.into_data())),
+            (values_field, make_array(value_dict_array.into_data())),
+        ]);
+        let map_data_type = DataType::Map(
+            Arc::new(Field::new(
+                "entries",
+                entry_struct.data_type().clone(),
+                false,
+            )),
+            false,
+        );
+
+        let entry_offsets = Buffer::from_slice_ref([0, 2, 4, 6]);
+        let map_data = ArrayData::builder(map_data_type)
+            .len(3)
+            .add_buffer(entry_offsets)
+            .add_child_data(entry_struct.into_data())
+            .build()
+            .unwrap();
+        let map_array = MapArray::from(map_data);
+
+        let dict_keys = Int8Array::from_iter_values([0, 1, 1, 2, 2, 1]);
+        let dict_dict_array = DictionaryArray::new(dict_keys, Arc::new(map_array));
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "f1",
+            dict_dict_array.data_type().clone(),
+            false,
+        )]));
+        let input_batch = RecordBatch::try_new(schema, vec![Arc::new(dict_dict_array)]).unwrap();
+        let output_batch = roundtrip_ipc_stream(&input_batch);
+        assert_eq!(input_batch, output_batch);
+    }
+
+    fn test_roundtrip_stream_dict_of_list_of_dict_impl<
+        OffsetSize: OffsetSizeTrait,
+        U: ArrowNativeType,
+    >(
+        list_data_type: DataType,
+        offsets: &[U; 5],
+    ) {
+        let values = StringArray::from(vec![Some("a"), None, Some("c"), None]);
+        let keys = Int8Array::from_iter_values([0, 0, 1, 2, 0, 1, 3]);
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+        let dict_data = dict_array.to_data();
+
+        let value_offsets = Buffer::from_slice_ref(offsets);
+
+        let list_data = ArrayData::builder(list_data_type)
+            .len(4)
+            .add_buffer(value_offsets)
+            .add_child_data(dict_data)
+            .build()
+            .unwrap();
+        let list_array = GenericListArray::<OffsetSize>::from(list_data);
+
+        let keys_for_dict = Int8Array::from_iter_values([0, 3, 0, 1, 1, 2, 0, 1, 3]);
+        let dict_dict_array = DictionaryArray::new(keys_for_dict, Arc::new(list_array));
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "f1",
+            dict_dict_array.data_type().clone(),
+            false,
+        )]));
+        let input_batch = RecordBatch::try_new(schema, vec![Arc::new(dict_dict_array)]).unwrap();
+        let output_batch = roundtrip_ipc_stream(&input_batch);
+        assert_eq!(input_batch, output_batch);
+    }
+
+    #[test]
+    fn test_roundtrip_stream_dict_of_list_of_dict() {
+        // list
+        let list_data_type = DataType::List(Arc::new(Field::new_dict(
+            "item",
+            DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
+            true,
+            1,
+            false,
+        )));
+        let offsets: &[i32; 5] = &[0, 2, 4, 4, 6];
+        test_roundtrip_stream_dict_of_list_of_dict_impl::<i32, i32>(list_data_type, offsets);
+
+        // large list
+        let list_data_type = DataType::LargeList(Arc::new(Field::new_dict(
+            "item",
+            DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
+            true,
+            1,
+            false,
+        )));
+        let offsets: &[i64; 5] = &[0, 2, 4, 4, 7];
+        test_roundtrip_stream_dict_of_list_of_dict_impl::<i64, i64>(list_data_type, offsets);
+    }
+
+    #[test]
+    fn test_roundtrip_stream_dict_of_fixed_size_list_of_dict() {
+        let values = StringArray::from(vec![Some("a"), None, Some("c"), None]);
+        let keys = Int8Array::from_iter_values([0, 0, 1, 2, 0, 1, 3, 1, 2]);
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+        let dict_data = dict_array.into_data();
+
+        let list_data_type = DataType::FixedSizeList(
+            Arc::new(Field::new_dict(
+                "item",
+                DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
+                true,
+                1,
+                false,
+            )),
+            3,
+        );
+        let list_data = ArrayData::builder(list_data_type)
+            .len(3)
+            .add_child_data(dict_data)
+            .build()
+            .unwrap();
+        let list_array = FixedSizeListArray::from(list_data);
+
+        let keys_for_dict = Int8Array::from_iter_values([0, 1, 0, 1, 1, 2, 0, 1, 2]);
+        let dict_dict_array = DictionaryArray::new(keys_for_dict, Arc::new(list_array));
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "f1",
+            dict_dict_array.data_type().clone(),
+            false,
+        )]));
+        let input_batch = RecordBatch::try_new(schema, vec![Arc::new(dict_dict_array)]).unwrap();
+        let output_batch = roundtrip_ipc_stream(&input_batch);
+        assert_eq!(input_batch, output_batch);
+    }
+
+    #[test]
+    fn test_no_columns_batch() {
+        let schema = Arc::new(Schema::empty());
+        let options = RecordBatchOptions::new()
+            .with_match_field_names(true)
+            .with_row_count(Some(10));
+        let input_batch = RecordBatch::try_new_with_options(schema, vec![], &options).unwrap();
+        let output_batch = roundtrip_ipc_stream(&input_batch);
+        assert_eq!(input_batch, output_batch);
+    }
+
+    #[test]
+    fn test_unaligned() {
+        let batch = RecordBatch::try_from_iter(vec![(
+            "i32",
+            Arc::new(Int32Array::from(vec![1, 2, 3, 4])) as _,
+        )])
+        .unwrap();
+
+        let gen = IpcDataGenerator {};
+        let mut dict_tracker = DictionaryTracker::new(false);
+        let (_, encoded) = gen
+            .encoded_batch(&batch, &mut dict_tracker, &Default::default())
+            .unwrap();
+
+        let message = root_as_message(&encoded.ipc_message).unwrap();
+
+        // Construct an unaligned buffer
+        let mut buffer = MutableBuffer::with_capacity(encoded.arrow_data.len() + 1);
+        buffer.push(0_u8);
+        buffer.extend_from_slice(&encoded.arrow_data);
+        let b = Buffer::from(buffer).slice(1);
+        assert_ne!(b.as_ptr().align_offset(8), 0);
+
+        let ipc_batch = message.header_as_record_batch().unwrap();
+        let roundtrip = read_record_batch(
+            &b,
+            ipc_batch,
+            batch.schema(),
+            &Default::default(),
+            None,
+            &message.version(),
+        )
+        .unwrap();
+        assert_eq!(batch, roundtrip);
+    }
+
+    #[test]
+    fn test_file_with_massive_column_count() {
+        // 499_999 is upper limit for default settings (1_000_000)
+        let limit = 600_000;
+
+        let fields = (0..limit)
+            .map(|i| Field::new(format!("{i}"), DataType::Boolean, false))
+            .collect::<Vec<_>>();
+        let schema = Arc::new(Schema::new(fields));
+        let batch = RecordBatch::new_empty(schema);
+
+        let mut buf = Vec::new();
+        let mut writer = crate::writer::FileWriter::try_new(&mut buf, &batch.schema()).unwrap();
+        writer.write(&batch).unwrap();
+        writer.finish().unwrap();
+        drop(writer);
+
+        let mut reader = FileReaderBuilder::new()
+            .with_max_footer_fb_tables(1_500_000)
+            .build(std::io::Cursor::new(buf))
+            .unwrap();
+        let roundtrip_batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(batch, roundtrip_batch);
+    }
+
+    #[test]
+    fn test_file_with_deeply_nested_columns() {
+        // 60 is upper limit for default settings (64)
+        let limit = 61;
+
+        let fields = (0..limit).fold(
+            vec![Field::new("leaf", DataType::Boolean, false)],
+            |field, index| vec![Field::new_struct(format!("{index}"), field, false)],
+        );
+        let schema = Arc::new(Schema::new(fields));
+        let batch = RecordBatch::new_empty(schema);
+
+        let mut buf = Vec::new();
+        let mut writer = crate::writer::FileWriter::try_new(&mut buf, &batch.schema()).unwrap();
+        writer.write(&batch).unwrap();
+        writer.finish().unwrap();
+        drop(writer);
+
+        let mut reader = FileReaderBuilder::new()
+            .with_max_footer_fb_depth(65)
+            .build(std::io::Cursor::new(buf))
+            .unwrap();
+        let roundtrip_batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(batch, roundtrip_batch);
+    }
+}
diff --git a/arrow-ipc/src/writer.rs b/arrow-ipc/src/writer.rs
new file mode 100644
index 000000000000..1f6bf5f6fa85
--- /dev/null
+++ b/arrow-ipc/src/writer.rs
@@ -0,0 +1,2237 @@
+// 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.
+
+//! Arrow IPC File and Stream Writers
+//!
+//! The `FileWriter` and `StreamWriter` have similar interfaces,
+//! however the `FileWriter` expects a reader that supports `Seek`ing
+
+use std::cmp::min;
+use std::collections::HashMap;
+use std::io::{BufWriter, Write};
+use std::sync::Arc;
+
+use flatbuffers::FlatBufferBuilder;
+
+use arrow_array::builder::BufferBuilder;
+use arrow_array::cast::*;
+use arrow_array::types::{Int16Type, Int32Type, Int64Type, RunEndIndexType};
+use arrow_array::*;
+use arrow_buffer::bit_util;
+use arrow_buffer::{ArrowNativeType, Buffer, MutableBuffer};
+use arrow_data::{layout, ArrayData, ArrayDataBuilder, BufferSpec};
+use arrow_schema::*;
+
+use crate::compression::CompressionCodec;
+use crate::CONTINUATION_MARKER;
+
+/// IPC write options used to control the behaviour of the [`IpcDataGenerator`]
+#[derive(Debug, Clone)]
+pub struct IpcWriteOptions {
+    /// Write padding after memory buffers to this multiple of bytes.
+    /// Generally 8 or 64, defaults to 64
+    alignment: usize,
+    /// The legacy format is for releases before 0.15.0, and uses metadata V4
+    write_legacy_ipc_format: bool,
+    /// The metadata version to write. The Rust IPC writer supports V4+
+    ///
+    /// *Default versions per crate*
+    ///
+    /// When creating the default IpcWriteOptions, the following metadata versions are used:
+    ///
+    /// version 2.0.0: V4, with legacy format enabled
+    /// version 4.0.0: V5
+    metadata_version: crate::MetadataVersion,
+    /// Compression, if desired. Will result in a runtime error
+    /// if the corresponding feature is not enabled
+    batch_compression_type: Option<crate::CompressionType>,
+}
+
+impl IpcWriteOptions {
+    /// Configures compression when writing IPC files.
+    ///
+    /// Will result in a runtime error if the corresponding feature
+    /// is not enabled
+    pub fn try_with_compression(
+        mut self,
+        batch_compression_type: Option<crate::CompressionType>,
+    ) -> Result<Self, ArrowError> {
+        self.batch_compression_type = batch_compression_type;
+
+        if self.batch_compression_type.is_some()
+            && self.metadata_version < crate::MetadataVersion::V5
+        {
+            return Err(ArrowError::InvalidArgumentError(
+                "Compression only supported in metadata v5 and above".to_string(),
+            ));
+        }
+        Ok(self)
+    }
+    /// Try create IpcWriteOptions, checking for incompatible settings
+    pub fn try_new(
+        alignment: usize,
+        write_legacy_ipc_format: bool,
+        metadata_version: crate::MetadataVersion,
+    ) -> Result<Self, ArrowError> {
+        if alignment == 0 || alignment % 8 != 0 {
+            return Err(ArrowError::InvalidArgumentError(
+                "Alignment should be greater than 0 and be a multiple of 8".to_string(),
+            ));
+        }
+        match metadata_version {
+            crate::MetadataVersion::V1
+            | crate::MetadataVersion::V2
+            | crate::MetadataVersion::V3 => Err(ArrowError::InvalidArgumentError(
+                "Writing IPC metadata version 3 and lower not supported".to_string(),
+            )),
+            crate::MetadataVersion::V4 => Ok(Self {
+                alignment,
+                write_legacy_ipc_format,
+                metadata_version,
+                batch_compression_type: None,
+            }),
+            crate::MetadataVersion::V5 => {
+                if write_legacy_ipc_format {
+                    Err(ArrowError::InvalidArgumentError(
+                        "Legacy IPC format only supported on metadata version 4".to_string(),
+                    ))
+                } else {
+                    Ok(Self {
+                        alignment,
+                        write_legacy_ipc_format,
+                        metadata_version,
+                        batch_compression_type: None,
+                    })
+                }
+            }
+            z => Err(ArrowError::InvalidArgumentError(format!(
+                "Unsupported crate::MetadataVersion {z:?}"
+            ))),
+        }
+    }
+}
+
+impl Default for IpcWriteOptions {
+    fn default() -> Self {
+        Self {
+            alignment: 64,
+            write_legacy_ipc_format: false,
+            metadata_version: crate::MetadataVersion::V5,
+            batch_compression_type: None,
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+/// Handles low level details of encoding [`Array`] and [`Schema`] into the
+/// [Arrow IPC Format].
+///
+/// # Example:
+/// ```
+/// # fn run() {
+/// # use std::sync::Arc;
+/// # use arrow_array::UInt64Array;
+/// # use arrow_array::RecordBatch;
+/// # use arrow_ipc::writer::{DictionaryTracker, IpcDataGenerator, IpcWriteOptions};
+///
+/// // Create a record batch
+/// let batch = RecordBatch::try_from_iter(vec![
+///  ("col2", Arc::new(UInt64Array::from_iter([10, 23, 33])) as _)
+/// ]).unwrap();
+///
+/// // Error of dictionary ids are replaced.
+/// let error_on_replacement = true;
+/// let options = IpcWriteOptions::default();
+/// let mut dictionary_tracker = DictionaryTracker::new(error_on_replacement);
+///
+/// // encode the batch into zero or more encoded dictionaries
+/// // and the data for the actual array.
+/// let data_gen = IpcDataGenerator {};
+/// let (encoded_dictionaries, encoded_message) = data_gen
+///   .encoded_batch(&batch, &mut dictionary_tracker, &options)
+///   .unwrap();
+/// # }
+/// ```
+///
+/// [Arrow IPC Format]: https://arrow.apache.org/docs/format/Columnar.html#serialization-and-interprocess-communication-ipc
+
+pub struct IpcDataGenerator {}
+
+impl IpcDataGenerator {
+    pub fn schema_to_bytes(&self, schema: &Schema, write_options: &IpcWriteOptions) -> EncodedData {
+        let mut fbb = FlatBufferBuilder::new();
+        let schema = {
+            let fb = crate::convert::schema_to_fb_offset(&mut fbb, schema);
+            fb.as_union_value()
+        };
+
+        let mut message = crate::MessageBuilder::new(&mut fbb);
+        message.add_version(write_options.metadata_version);
+        message.add_header_type(crate::MessageHeader::Schema);
+        message.add_bodyLength(0);
+        message.add_header(schema);
+        // TODO: custom metadata
+        let data = message.finish();
+        fbb.finish(data, None);
+
+        let data = fbb.finished_data();
+        EncodedData {
+            ipc_message: data.to_vec(),
+            arrow_data: vec![],
+        }
+    }
+
+    fn _encode_dictionaries(
+        &self,
+        column: &ArrayRef,
+        encoded_dictionaries: &mut Vec<EncodedData>,
+        dictionary_tracker: &mut DictionaryTracker,
+        write_options: &IpcWriteOptions,
+    ) -> Result<(), ArrowError> {
+        match column.data_type() {
+            DataType::Struct(fields) => {
+                let s = as_struct_array(column);
+                for (field, column) in fields.iter().zip(s.columns()) {
+                    self.encode_dictionaries(
+                        field,
+                        column,
+                        encoded_dictionaries,
+                        dictionary_tracker,
+                        write_options,
+                    )?;
+                }
+            }
+            DataType::RunEndEncoded(_, values) => {
+                let data = column.to_data();
+                if data.child_data().len() != 2 {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "The run encoded array should have exactly two child arrays. Found {}",
+                        data.child_data().len()
+                    )));
+                }
+                // The run_ends array is not expected to be dictionary encoded. Hence encode dictionaries
+                // only for values array.
+                let values_array = make_array(data.child_data()[1].clone());
+                self.encode_dictionaries(
+                    values,
+                    &values_array,
+                    encoded_dictionaries,
+                    dictionary_tracker,
+                    write_options,
+                )?;
+            }
+            DataType::List(field) => {
+                let list = as_list_array(column);
+                self.encode_dictionaries(
+                    field,
+                    list.values(),
+                    encoded_dictionaries,
+                    dictionary_tracker,
+                    write_options,
+                )?;
+            }
+            DataType::LargeList(field) => {
+                let list = as_large_list_array(column);
+                self.encode_dictionaries(
+                    field,
+                    list.values(),
+                    encoded_dictionaries,
+                    dictionary_tracker,
+                    write_options,
+                )?;
+            }
+            DataType::FixedSizeList(field, _) => {
+                let list = column
+                    .as_any()
+                    .downcast_ref::<FixedSizeListArray>()
+                    .expect("Unable to downcast to fixed size list array");
+                self.encode_dictionaries(
+                    field,
+                    list.values(),
+                    encoded_dictionaries,
+                    dictionary_tracker,
+                    write_options,
+                )?;
+            }
+            DataType::Map(field, _) => {
+                let map_array = as_map_array(column);
+
+                let (keys, values) = match field.data_type() {
+                    DataType::Struct(fields) if fields.len() == 2 => (&fields[0], &fields[1]),
+                    _ => panic!("Incorrect field data type {:?}", field.data_type()),
+                };
+
+                // keys
+                self.encode_dictionaries(
+                    keys,
+                    map_array.keys(),
+                    encoded_dictionaries,
+                    dictionary_tracker,
+                    write_options,
+                )?;
+
+                // values
+                self.encode_dictionaries(
+                    values,
+                    map_array.values(),
+                    encoded_dictionaries,
+                    dictionary_tracker,
+                    write_options,
+                )?;
+            }
+            DataType::Union(fields, _) => {
+                let union = as_union_array(column);
+                for (type_id, field) in fields.iter() {
+                    let column = union.child(type_id);
+                    self.encode_dictionaries(
+                        field,
+                        column,
+                        encoded_dictionaries,
+                        dictionary_tracker,
+                        write_options,
+                    )?;
+                }
+            }
+            _ => (),
+        }
+
+        Ok(())
+    }
+
+    fn encode_dictionaries(
+        &self,
+        field: &Field,
+        column: &ArrayRef,
+        encoded_dictionaries: &mut Vec<EncodedData>,
+        dictionary_tracker: &mut DictionaryTracker,
+        write_options: &IpcWriteOptions,
+    ) -> Result<(), ArrowError> {
+        match column.data_type() {
+            DataType::Dictionary(_key_type, _value_type) => {
+                let dict_id = field
+                    .dict_id()
+                    .expect("All Dictionary types have `dict_id`");
+                let dict_data = column.to_data();
+                let dict_values = &dict_data.child_data()[0];
+
+                let values = make_array(dict_data.child_data()[0].clone());
+
+                self._encode_dictionaries(
+                    &values,
+                    encoded_dictionaries,
+                    dictionary_tracker,
+                    write_options,
+                )?;
+
+                let emit = dictionary_tracker.insert(dict_id, column)?;
+
+                if emit {
+                    encoded_dictionaries.push(self.dictionary_batch_to_bytes(
+                        dict_id,
+                        dict_values,
+                        write_options,
+                    )?);
+                }
+            }
+            _ => self._encode_dictionaries(
+                column,
+                encoded_dictionaries,
+                dictionary_tracker,
+                write_options,
+            )?,
+        }
+
+        Ok(())
+    }
+
+    /// Encodes a batch to a number of [EncodedData] items (dictionary batches + the record batch).
+    /// The [DictionaryTracker] keeps track of dictionaries with new `dict_id`s  (so they are only sent once)
+    /// Make sure the [DictionaryTracker] is initialized at the start of the stream.
+    pub fn encoded_batch(
+        &self,
+        batch: &RecordBatch,
+        dictionary_tracker: &mut DictionaryTracker,
+        write_options: &IpcWriteOptions,
+    ) -> Result<(Vec<EncodedData>, EncodedData), ArrowError> {
+        let schema = batch.schema();
+        let mut encoded_dictionaries = Vec::with_capacity(schema.all_fields().len());
+
+        for (i, field) in schema.fields().iter().enumerate() {
+            let column = batch.column(i);
+            self.encode_dictionaries(
+                field,
+                column,
+                &mut encoded_dictionaries,
+                dictionary_tracker,
+                write_options,
+            )?;
+        }
+
+        let encoded_message = self.record_batch_to_bytes(batch, write_options)?;
+        Ok((encoded_dictionaries, encoded_message))
+    }
+
+    /// Write a `RecordBatch` into two sets of bytes, one for the header (crate::Message) and the
+    /// other for the batch's data
+    fn record_batch_to_bytes(
+        &self,
+        batch: &RecordBatch,
+        write_options: &IpcWriteOptions,
+    ) -> Result<EncodedData, ArrowError> {
+        let mut fbb = FlatBufferBuilder::new();
+
+        let mut nodes: Vec<crate::FieldNode> = vec![];
+        let mut buffers: Vec<crate::Buffer> = vec![];
+        let mut arrow_data: Vec<u8> = vec![];
+        let mut offset = 0;
+
+        // get the type of compression
+        let batch_compression_type = write_options.batch_compression_type;
+
+        let compression = batch_compression_type.map(|batch_compression_type| {
+            let mut c = crate::BodyCompressionBuilder::new(&mut fbb);
+            c.add_method(crate::BodyCompressionMethod::BUFFER);
+            c.add_codec(batch_compression_type);
+            c.finish()
+        });
+
+        let compression_codec: Option<CompressionCodec> =
+            batch_compression_type.map(TryInto::try_into).transpose()?;
+
+        for array in batch.columns() {
+            let array_data = array.to_data();
+            offset = write_array_data(
+                &array_data,
+                &mut buffers,
+                &mut arrow_data,
+                &mut nodes,
+                offset,
+                array.len(),
+                array.null_count(),
+                compression_codec,
+                write_options,
+            )?;
+        }
+        // pad the tail of body data
+        let len = arrow_data.len();
+        let pad_len = pad_to_8(len as u32);
+        arrow_data.extend_from_slice(&vec![0u8; pad_len][..]);
+
+        // write data
+        let buffers = fbb.create_vector(&buffers);
+        let nodes = fbb.create_vector(&nodes);
+        let root = {
+            let mut batch_builder = crate::RecordBatchBuilder::new(&mut fbb);
+            batch_builder.add_length(batch.num_rows() as i64);
+            batch_builder.add_nodes(nodes);
+            batch_builder.add_buffers(buffers);
+            if let Some(c) = compression {
+                batch_builder.add_compression(c);
+            }
+            let b = batch_builder.finish();
+            b.as_union_value()
+        };
+        // create an crate::Message
+        let mut message = crate::MessageBuilder::new(&mut fbb);
+        message.add_version(write_options.metadata_version);
+        message.add_header_type(crate::MessageHeader::RecordBatch);
+        message.add_bodyLength(arrow_data.len() as i64);
+        message.add_header(root);
+        let root = message.finish();
+        fbb.finish(root, None);
+        let finished_data = fbb.finished_data();
+
+        Ok(EncodedData {
+            ipc_message: finished_data.to_vec(),
+            arrow_data,
+        })
+    }
+
+    /// Write dictionary values into two sets of bytes, one for the header (crate::Message) and the
+    /// other for the data
+    fn dictionary_batch_to_bytes(
+        &self,
+        dict_id: i64,
+        array_data: &ArrayData,
+        write_options: &IpcWriteOptions,
+    ) -> Result<EncodedData, ArrowError> {
+        let mut fbb = FlatBufferBuilder::new();
+
+        let mut nodes: Vec<crate::FieldNode> = vec![];
+        let mut buffers: Vec<crate::Buffer> = vec![];
+        let mut arrow_data: Vec<u8> = vec![];
+
+        // get the type of compression
+        let batch_compression_type = write_options.batch_compression_type;
+
+        let compression = batch_compression_type.map(|batch_compression_type| {
+            let mut c = crate::BodyCompressionBuilder::new(&mut fbb);
+            c.add_method(crate::BodyCompressionMethod::BUFFER);
+            c.add_codec(batch_compression_type);
+            c.finish()
+        });
+
+        let compression_codec: Option<CompressionCodec> = batch_compression_type
+            .map(|batch_compression_type| batch_compression_type.try_into())
+            .transpose()?;
+
+        write_array_data(
+            array_data,
+            &mut buffers,
+            &mut arrow_data,
+            &mut nodes,
+            0,
+            array_data.len(),
+            array_data.null_count(),
+            compression_codec,
+            write_options,
+        )?;
+
+        // pad the tail of body data
+        let len = arrow_data.len();
+        let pad_len = pad_to_8(len as u32);
+        arrow_data.extend_from_slice(&vec![0u8; pad_len][..]);
+
+        // write data
+        let buffers = fbb.create_vector(&buffers);
+        let nodes = fbb.create_vector(&nodes);
+
+        let root = {
+            let mut batch_builder = crate::RecordBatchBuilder::new(&mut fbb);
+            batch_builder.add_length(array_data.len() as i64);
+            batch_builder.add_nodes(nodes);
+            batch_builder.add_buffers(buffers);
+            if let Some(c) = compression {
+                batch_builder.add_compression(c);
+            }
+            batch_builder.finish()
+        };
+
+        let root = {
+            let mut batch_builder = crate::DictionaryBatchBuilder::new(&mut fbb);
+            batch_builder.add_id(dict_id);
+            batch_builder.add_data(root);
+            batch_builder.finish().as_union_value()
+        };
+
+        let root = {
+            let mut message_builder = crate::MessageBuilder::new(&mut fbb);
+            message_builder.add_version(write_options.metadata_version);
+            message_builder.add_header_type(crate::MessageHeader::DictionaryBatch);
+            message_builder.add_bodyLength(arrow_data.len() as i64);
+            message_builder.add_header(root);
+            message_builder.finish()
+        };
+
+        fbb.finish(root, None);
+        let finished_data = fbb.finished_data();
+
+        Ok(EncodedData {
+            ipc_message: finished_data.to_vec(),
+            arrow_data,
+        })
+    }
+}
+
+pub(crate) fn unslice_run_array(arr: ArrayData) -> Result<ArrayData, ArrowError> {
+    match arr.data_type() {
+        DataType::RunEndEncoded(k, _) => match k.data_type() {
+            DataType::Int16 => {
+                Ok(into_zero_offset_run_array(RunArray::<Int16Type>::from(arr))?.into_data())
+            }
+            DataType::Int32 => {
+                Ok(into_zero_offset_run_array(RunArray::<Int32Type>::from(arr))?.into_data())
+            }
+            DataType::Int64 => {
+                Ok(into_zero_offset_run_array(RunArray::<Int64Type>::from(arr))?.into_data())
+            }
+            d => unreachable!("Unexpected data type {d}"),
+        },
+        d => Err(ArrowError::InvalidArgumentError(format!(
+            "The given array is not a run array. Data type of given array: {d}"
+        ))),
+    }
+}
+
+// Returns a `RunArray` with zero offset and length matching the last value
+// in run_ends array.
+fn into_zero_offset_run_array<R: RunEndIndexType>(
+    run_array: RunArray<R>,
+) -> Result<RunArray<R>, ArrowError> {
+    let run_ends = run_array.run_ends();
+    if run_ends.offset() == 0 && run_ends.max_value() == run_ends.len() {
+        return Ok(run_array);
+    }
+
+    // The physical index of original run_ends array from which the `ArrayData`is sliced.
+    let start_physical_index = run_ends.get_start_physical_index();
+
+    // The physical index of original run_ends array until which the `ArrayData`is sliced.
+    let end_physical_index = run_ends.get_end_physical_index();
+
+    let physical_length = end_physical_index - start_physical_index + 1;
+
+    // build new run_ends array by subtracting offset from run ends.
+    let offset = R::Native::usize_as(run_ends.offset());
+    let mut builder = BufferBuilder::<R::Native>::new(physical_length);
+    for run_end_value in &run_ends.values()[start_physical_index..end_physical_index] {
+        builder.append(run_end_value.sub_wrapping(offset));
+    }
+    builder.append(R::Native::from_usize(run_array.len()).unwrap());
+    let new_run_ends = unsafe {
+        // Safety:
+        // The function builds a valid run_ends array and hence need not be validated.
+        ArrayDataBuilder::new(R::DATA_TYPE)
+            .len(physical_length)
+            .add_buffer(builder.finish())
+            .build_unchecked()
+    };
+
+    // build new values by slicing physical indices.
+    let new_values = run_array
+        .values()
+        .slice(start_physical_index, physical_length)
+        .into_data();
+
+    let builder = ArrayDataBuilder::new(run_array.data_type().clone())
+        .len(run_array.len())
+        .add_child_data(new_run_ends)
+        .add_child_data(new_values);
+    let array_data = unsafe {
+        // Safety:
+        //  This function builds a valid run array and hence can skip validation.
+        builder.build_unchecked()
+    };
+    Ok(array_data.into())
+}
+
+/// Keeps track of dictionaries that have been written, to avoid emitting the same dictionary
+/// multiple times. Can optionally error if an update to an existing dictionary is attempted, which
+/// isn't allowed in the `FileWriter`.
+pub struct DictionaryTracker {
+    written: HashMap<i64, ArrayData>,
+    error_on_replacement: bool,
+}
+
+impl DictionaryTracker {
+    /// Create a new [`DictionaryTracker`]. If `error_on_replacement`
+    /// is true, an error will be generated if an update to an
+    /// existing dictionary is attempted.
+    pub fn new(error_on_replacement: bool) -> Self {
+        Self {
+            written: HashMap::new(),
+            error_on_replacement,
+        }
+    }
+
+    /// Keep track of the dictionary with the given ID and values. Behavior:
+    ///
+    /// * If this ID has been written already and has the same data, return `Ok(false)` to indicate
+    ///   that the dictionary was not actually inserted (because it's already been seen).
+    /// * If this ID has been written already but with different data, and this tracker is
+    ///   configured to return an error, return an error.
+    /// * If the tracker has not been configured to error on replacement or this dictionary
+    ///   has never been seen before, return `Ok(true)` to indicate that the dictionary was just
+    ///   inserted.
+    pub fn insert(&mut self, dict_id: i64, column: &ArrayRef) -> Result<bool, ArrowError> {
+        let dict_data = column.to_data();
+        let dict_values = &dict_data.child_data()[0];
+
+        // If a dictionary with this id was already emitted, check if it was the same.
+        if let Some(last) = self.written.get(&dict_id) {
+            if ArrayData::ptr_eq(&last.child_data()[0], dict_values) {
+                // Same dictionary values => no need to emit it again
+                return Ok(false);
+            }
+            if self.error_on_replacement {
+                // If error on replacement perform a logical comparison
+                if last.child_data()[0] == *dict_values {
+                    // Same dictionary values => no need to emit it again
+                    return Ok(false);
+                }
+                return Err(ArrowError::InvalidArgumentError(
+                    "Dictionary replacement detected when writing IPC file format. \
+                     Arrow IPC files only support a single dictionary for a given field \
+                     across all batches."
+                        .to_string(),
+                ));
+            }
+        }
+
+        self.written.insert(dict_id, dict_data);
+        Ok(true)
+    }
+}
+
+pub struct FileWriter<W: Write> {
+    /// The object to write to
+    writer: BufWriter<W>,
+    /// IPC write options
+    write_options: IpcWriteOptions,
+    /// A reference to the schema, used in validating record batches
+    schema: SchemaRef,
+    /// The number of bytes between each block of bytes, as an offset for random access
+    block_offsets: usize,
+    /// Dictionary blocks that will be written as part of the IPC footer
+    dictionary_blocks: Vec<crate::Block>,
+    /// Record blocks that will be written as part of the IPC footer
+    record_blocks: Vec<crate::Block>,
+    /// Whether the writer footer has been written, and the writer is finished
+    finished: bool,
+    /// Keeps track of dictionaries that have been written
+    dictionary_tracker: DictionaryTracker,
+    /// User level customized metadata
+    custom_metadata: HashMap<String, String>,
+
+    data_gen: IpcDataGenerator,
+}
+
+impl<W: Write> FileWriter<W> {
+    /// Try create a new writer, with the schema written as part of the header
+    pub fn try_new(writer: W, schema: &Schema) -> Result<Self, ArrowError> {
+        let write_options = IpcWriteOptions::default();
+        Self::try_new_with_options(writer, schema, write_options)
+    }
+
+    /// Try create a new writer with IpcWriteOptions
+    pub fn try_new_with_options(
+        writer: W,
+        schema: &Schema,
+        write_options: IpcWriteOptions,
+    ) -> Result<Self, ArrowError> {
+        let data_gen = IpcDataGenerator::default();
+        let mut writer = BufWriter::new(writer);
+        // write magic to header aligned on 8 byte boundary
+        let header_size = super::ARROW_MAGIC.len() + 2;
+        assert_eq!(header_size, 8);
+        writer.write_all(&super::ARROW_MAGIC[..])?;
+        writer.write_all(&[0, 0])?;
+        // write the schema, set the written bytes to the schema + header
+        let encoded_message = data_gen.schema_to_bytes(schema, &write_options);
+        let (meta, data) = write_message(&mut writer, encoded_message, &write_options)?;
+        Ok(Self {
+            writer,
+            write_options,
+            schema: Arc::new(schema.clone()),
+            block_offsets: meta + data + header_size,
+            dictionary_blocks: vec![],
+            record_blocks: vec![],
+            finished: false,
+            dictionary_tracker: DictionaryTracker::new(true),
+            custom_metadata: HashMap::new(),
+            data_gen,
+        })
+    }
+
+    pub fn write_metadata(&mut self, key: impl Into<String>, value: impl Into<String>) {
+        self.custom_metadata.insert(key.into(), value.into());
+    }
+
+    /// Write a record batch to the file
+    pub fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError> {
+        if self.finished {
+            return Err(ArrowError::IpcError(
+                "Cannot write record batch to file writer as it is closed".to_string(),
+            ));
+        }
+
+        let (encoded_dictionaries, encoded_message) = self.data_gen.encoded_batch(
+            batch,
+            &mut self.dictionary_tracker,
+            &self.write_options,
+        )?;
+
+        for encoded_dictionary in encoded_dictionaries {
+            let (meta, data) =
+                write_message(&mut self.writer, encoded_dictionary, &self.write_options)?;
+
+            let block = crate::Block::new(self.block_offsets as i64, meta as i32, data as i64);
+            self.dictionary_blocks.push(block);
+            self.block_offsets += meta + data;
+        }
+
+        let (meta, data) = write_message(&mut self.writer, encoded_message, &self.write_options)?;
+        // add a record block for the footer
+        let block = crate::Block::new(
+            self.block_offsets as i64,
+            meta as i32, // TODO: is this still applicable?
+            data as i64,
+        );
+        self.record_blocks.push(block);
+        self.block_offsets += meta + data;
+        Ok(())
+    }
+
+    /// Write footer and closing tag, then mark the writer as done
+    pub fn finish(&mut self) -> Result<(), ArrowError> {
+        if self.finished {
+            return Err(ArrowError::IpcError(
+                "Cannot write footer to file writer as it is closed".to_string(),
+            ));
+        }
+
+        // write EOS
+        write_continuation(&mut self.writer, &self.write_options, 0)?;
+
+        let mut fbb = FlatBufferBuilder::new();
+        let dictionaries = fbb.create_vector(&self.dictionary_blocks);
+        let record_batches = fbb.create_vector(&self.record_blocks);
+        let schema = crate::convert::schema_to_fb_offset(&mut fbb, &self.schema);
+        let fb_custom_metadata = (!self.custom_metadata.is_empty())
+            .then(|| crate::convert::metadata_to_fb(&mut fbb, &self.custom_metadata));
+
+        let root = {
+            let mut footer_builder = crate::FooterBuilder::new(&mut fbb);
+            footer_builder.add_version(self.write_options.metadata_version);
+            footer_builder.add_schema(schema);
+            footer_builder.add_dictionaries(dictionaries);
+            footer_builder.add_recordBatches(record_batches);
+            if let Some(fb_custom_metadata) = fb_custom_metadata {
+                footer_builder.add_custom_metadata(fb_custom_metadata);
+            }
+            footer_builder.finish()
+        };
+        fbb.finish(root, None);
+        let footer_data = fbb.finished_data();
+        self.writer.write_all(footer_data)?;
+        self.writer
+            .write_all(&(footer_data.len() as i32).to_le_bytes())?;
+        self.writer.write_all(&super::ARROW_MAGIC)?;
+        self.writer.flush()?;
+        self.finished = true;
+
+        Ok(())
+    }
+
+    /// Returns the arrow [`SchemaRef`] for this arrow file.
+    pub fn schema(&self) -> &SchemaRef {
+        &self.schema
+    }
+
+    /// Gets a reference to the underlying writer.
+    pub fn get_ref(&self) -> &W {
+        self.writer.get_ref()
+    }
+
+    /// Gets a mutable reference to the underlying writer.
+    ///
+    /// It is inadvisable to directly write to the underlying writer.
+    pub fn get_mut(&mut self) -> &mut W {
+        self.writer.get_mut()
+    }
+
+    /// Unwraps the BufWriter housed in FileWriter.writer, returning the underlying
+    /// writer
+    ///
+    /// The buffer is flushed and the FileWriter is finished before returning the
+    /// writer.
+    pub fn into_inner(mut self) -> Result<W, ArrowError> {
+        if !self.finished {
+            self.finish()?;
+        }
+        self.writer.into_inner().map_err(ArrowError::from)
+    }
+}
+
+impl<W: Write> RecordBatchWriter for FileWriter<W> {
+    fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError> {
+        self.write(batch)
+    }
+
+    fn close(mut self) -> Result<(), ArrowError> {
+        self.finish()
+    }
+}
+
+pub struct StreamWriter<W: Write> {
+    /// The object to write to
+    writer: BufWriter<W>,
+    /// IPC write options
+    write_options: IpcWriteOptions,
+    /// Whether the writer footer has been written, and the writer is finished
+    finished: bool,
+    /// Keeps track of dictionaries that have been written
+    dictionary_tracker: DictionaryTracker,
+
+    data_gen: IpcDataGenerator,
+}
+
+impl<W: Write> StreamWriter<W> {
+    /// Try create a new writer, with the schema written as part of the header
+    pub fn try_new(writer: W, schema: &Schema) -> Result<Self, ArrowError> {
+        let write_options = IpcWriteOptions::default();
+        Self::try_new_with_options(writer, schema, write_options)
+    }
+
+    pub fn try_new_with_options(
+        writer: W,
+        schema: &Schema,
+        write_options: IpcWriteOptions,
+    ) -> Result<Self, ArrowError> {
+        let data_gen = IpcDataGenerator::default();
+        let mut writer = BufWriter::new(writer);
+        // write the schema, set the written bytes to the schema
+        let encoded_message = data_gen.schema_to_bytes(schema, &write_options);
+        write_message(&mut writer, encoded_message, &write_options)?;
+        Ok(Self {
+            writer,
+            write_options,
+            finished: false,
+            dictionary_tracker: DictionaryTracker::new(false),
+            data_gen,
+        })
+    }
+
+    /// Write a record batch to the stream
+    pub fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError> {
+        if self.finished {
+            return Err(ArrowError::IpcError(
+                "Cannot write record batch to stream writer as it is closed".to_string(),
+            ));
+        }
+
+        let (encoded_dictionaries, encoded_message) = self
+            .data_gen
+            .encoded_batch(batch, &mut self.dictionary_tracker, &self.write_options)
+            .expect("StreamWriter is configured to not error on dictionary replacement");
+
+        for encoded_dictionary in encoded_dictionaries {
+            write_message(&mut self.writer, encoded_dictionary, &self.write_options)?;
+        }
+
+        write_message(&mut self.writer, encoded_message, &self.write_options)?;
+        Ok(())
+    }
+
+    /// Write continuation bytes, and mark the stream as done
+    pub fn finish(&mut self) -> Result<(), ArrowError> {
+        if self.finished {
+            return Err(ArrowError::IpcError(
+                "Cannot write footer to stream writer as it is closed".to_string(),
+            ));
+        }
+
+        write_continuation(&mut self.writer, &self.write_options, 0)?;
+
+        self.finished = true;
+
+        Ok(())
+    }
+
+    /// Gets a reference to the underlying writer.
+    pub fn get_ref(&self) -> &W {
+        self.writer.get_ref()
+    }
+
+    /// Gets a mutable reference to the underlying writer.
+    ///
+    /// It is inadvisable to directly write to the underlying writer.
+    pub fn get_mut(&mut self) -> &mut W {
+        self.writer.get_mut()
+    }
+
+    /// Unwraps the BufWriter housed in StreamWriter.writer, returning the underlying
+    /// writer
+    ///
+    /// The buffer is flushed and the StreamWriter is finished before returning the
+    /// writer.
+    ///
+    /// # Errors
+    ///
+    /// An ['Err'] may be returned if an error occurs while finishing the StreamWriter
+    /// or while flushing the buffer.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use arrow_ipc::writer::{StreamWriter, IpcWriteOptions};
+    /// # use arrow_ipc::MetadataVersion;
+    /// # use arrow_schema::{ArrowError, Schema};
+    /// # fn main() -> Result<(), ArrowError> {
+    /// // The result we expect from an empty schema
+    /// let expected = vec![
+    ///     255, 255, 255, 255,  48,   0,   0,   0,
+    ///      16,   0,   0,   0,   0,   0,  10,   0,
+    ///      12,   0,  10,   0,   9,   0,   4,   0,
+    ///      10,   0,   0,   0,  16,   0,   0,   0,
+    ///       0,   1,   4,   0,   8,   0,   8,   0,
+    ///       0,   0,   4,   0,   8,   0,   0,   0,
+    ///       4,   0,   0,   0,   0,   0,   0,   0,
+    ///     255, 255, 255, 255,   0,   0,   0,   0
+    /// ];
+    ///
+    /// let schema = Schema::empty();
+    /// let buffer: Vec<u8> = Vec::new();
+    /// let options = IpcWriteOptions::try_new(8, false, MetadataVersion::V5)?;
+    /// let stream_writer = StreamWriter::try_new_with_options(buffer, &schema, options)?;
+    ///
+    /// assert_eq!(stream_writer.into_inner()?, expected);
+    /// # Ok(())
+    /// # }
+    /// ```
+    pub fn into_inner(mut self) -> Result<W, ArrowError> {
+        if !self.finished {
+            self.finish()?;
+        }
+        self.writer.into_inner().map_err(ArrowError::from)
+    }
+}
+
+impl<W: Write> RecordBatchWriter for StreamWriter<W> {
+    fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError> {
+        self.write(batch)
+    }
+
+    fn close(mut self) -> Result<(), ArrowError> {
+        self.finish()
+    }
+}
+
+/// Stores the encoded data, which is an crate::Message, and optional Arrow data
+pub struct EncodedData {
+    /// An encoded crate::Message
+    pub ipc_message: Vec<u8>,
+    /// Arrow buffers to be written, should be an empty vec for schema messages
+    pub arrow_data: Vec<u8>,
+}
+/// Write a message's IPC data and buffers, returning metadata and buffer data lengths written
+pub fn write_message<W: Write>(
+    mut writer: W,
+    encoded: EncodedData,
+    write_options: &IpcWriteOptions,
+) -> Result<(usize, usize), ArrowError> {
+    let arrow_data_len = encoded.arrow_data.len();
+    if arrow_data_len % 8 != 0 {
+        return Err(ArrowError::MemoryError(
+            "Arrow data not aligned".to_string(),
+        ));
+    }
+
+    let a = write_options.alignment - 1;
+    let buffer = encoded.ipc_message;
+    let flatbuf_size = buffer.len();
+    let prefix_size = if write_options.write_legacy_ipc_format {
+        4
+    } else {
+        8
+    };
+    let aligned_size = (flatbuf_size + prefix_size + a) & !a;
+    let padding_bytes = aligned_size - flatbuf_size - prefix_size;
+
+    write_continuation(
+        &mut writer,
+        write_options,
+        (aligned_size - prefix_size) as i32,
+    )?;
+
+    // write the flatbuf
+    if flatbuf_size > 0 {
+        writer.write_all(&buffer)?;
+    }
+    // write padding
+    writer.write_all(&vec![0; padding_bytes])?;
+
+    // write arrow data
+    let body_len = if arrow_data_len > 0 {
+        write_body_buffers(&mut writer, &encoded.arrow_data)?
+    } else {
+        0
+    };
+
+    Ok((aligned_size, body_len))
+}
+
+fn write_body_buffers<W: Write>(mut writer: W, data: &[u8]) -> Result<usize, ArrowError> {
+    let len = data.len() as u32;
+    let pad_len = pad_to_8(len) as u32;
+    let total_len = len + pad_len;
+
+    // write body buffer
+    writer.write_all(data)?;
+    if pad_len > 0 {
+        writer.write_all(&vec![0u8; pad_len as usize][..])?;
+    }
+
+    writer.flush()?;
+    Ok(total_len as usize)
+}
+
+/// Write a record batch to the writer, writing the message size before the message
+/// if the record batch is being written to a stream
+fn write_continuation<W: Write>(
+    mut writer: W,
+    write_options: &IpcWriteOptions,
+    total_len: i32,
+) -> Result<usize, ArrowError> {
+    let mut written = 8;
+
+    // the version of the writer determines whether continuation markers should be added
+    match write_options.metadata_version {
+        crate::MetadataVersion::V1 | crate::MetadataVersion::V2 | crate::MetadataVersion::V3 => {
+            unreachable!("Options with the metadata version cannot be created")
+        }
+        crate::MetadataVersion::V4 => {
+            if !write_options.write_legacy_ipc_format {
+                // v0.15.0 format
+                writer.write_all(&CONTINUATION_MARKER)?;
+                written = 4;
+            }
+            writer.write_all(&total_len.to_le_bytes()[..])?;
+        }
+        crate::MetadataVersion::V5 => {
+            // write continuation marker and message length
+            writer.write_all(&CONTINUATION_MARKER)?;
+            writer.write_all(&total_len.to_le_bytes()[..])?;
+        }
+        z => panic!("Unsupported crate::MetadataVersion {z:?}"),
+    };
+
+    writer.flush()?;
+
+    Ok(written)
+}
+
+/// In V4, null types have no validity bitmap
+/// In V5 and later, null and union types have no validity bitmap
+/// Run end encoded type has no validity bitmap.
+fn has_validity_bitmap(data_type: &DataType, write_options: &IpcWriteOptions) -> bool {
+    if write_options.metadata_version < crate::MetadataVersion::V5 {
+        !matches!(data_type, DataType::Null)
+    } else {
+        !matches!(
+            data_type,
+            DataType::Null | DataType::Union(_, _) | DataType::RunEndEncoded(_, _)
+        )
+    }
+}
+
+/// Whether to truncate the buffer
+#[inline]
+fn buffer_need_truncate(
+    array_offset: usize,
+    buffer: &Buffer,
+    spec: &BufferSpec,
+    min_length: usize,
+) -> bool {
+    spec != &BufferSpec::AlwaysNull && (array_offset != 0 || min_length < buffer.len())
+}
+
+/// Returns byte width for a buffer spec. Only for `BufferSpec::FixedWidth`.
+#[inline]
+fn get_buffer_element_width(spec: &BufferSpec) -> usize {
+    match spec {
+        BufferSpec::FixedWidth { byte_width, .. } => *byte_width,
+        _ => 0,
+    }
+}
+
+/// Common functionality for re-encoding offsets. Returns the new offsets as well as
+/// original start offset and length for use in slicing child data.
+fn reencode_offsets<O: OffsetSizeTrait>(
+    offsets: &Buffer,
+    data: &ArrayData,
+) -> (Buffer, usize, usize) {
+    let offsets_slice: &[O] = offsets.typed_data::<O>();
+    let offset_slice = &offsets_slice[data.offset()..data.offset() + data.len() + 1];
+
+    let start_offset = offset_slice.first().unwrap();
+    let end_offset = offset_slice.last().unwrap();
+
+    let offsets = match start_offset.as_usize() {
+        0 => offsets.clone(),
+        _ => offset_slice.iter().map(|x| *x - *start_offset).collect(),
+    };
+
+    let start_offset = start_offset.as_usize();
+    let end_offset = end_offset.as_usize();
+
+    (offsets, start_offset, end_offset - start_offset)
+}
+
+/// Returns the values and offsets [`Buffer`] for a ByteArray with offset type `O`
+///
+/// In particular, this handles re-encoding the offsets if they don't start at `0`,
+/// slicing the values buffer as appropriate. This helps reduce the encoded
+/// size of sliced arrays, as values that have been sliced away are not encoded
+fn get_byte_array_buffers<O: OffsetSizeTrait>(data: &ArrayData) -> (Buffer, Buffer) {
+    if data.is_empty() {
+        return (MutableBuffer::new(0).into(), MutableBuffer::new(0).into());
+    }
+
+    let (offsets, original_start_offset, len) = reencode_offsets::<O>(&data.buffers()[0], data);
+    let values = data.buffers()[1].slice_with_length(original_start_offset, len);
+    (offsets, values)
+}
+
+/// Similar logic as [`get_byte_array_buffers()`] but slices the child array instead
+/// of a values buffer.
+fn get_list_array_buffers<O: OffsetSizeTrait>(data: &ArrayData) -> (Buffer, ArrayData) {
+    if data.is_empty() {
+        return (
+            MutableBuffer::new(0).into(),
+            data.child_data()[0].slice(0, 0),
+        );
+    }
+
+    let (offsets, original_start_offset, len) = reencode_offsets::<O>(&data.buffers()[0], data);
+    let child_data = data.child_data()[0].slice(original_start_offset, len);
+    (offsets, child_data)
+}
+
+/// Write array data to a vector of bytes
+#[allow(clippy::too_many_arguments)]
+fn write_array_data(
+    array_data: &ArrayData,
+    buffers: &mut Vec<crate::Buffer>,
+    arrow_data: &mut Vec<u8>,
+    nodes: &mut Vec<crate::FieldNode>,
+    offset: i64,
+    num_rows: usize,
+    null_count: usize,
+    compression_codec: Option<CompressionCodec>,
+    write_options: &IpcWriteOptions,
+) -> Result<i64, ArrowError> {
+    let mut offset = offset;
+    if !matches!(array_data.data_type(), DataType::Null) {
+        nodes.push(crate::FieldNode::new(num_rows as i64, null_count as i64));
+    } else {
+        // NullArray's null_count equals to len, but the `null_count` passed in is from ArrayData
+        // where null_count is always 0.
+        nodes.push(crate::FieldNode::new(num_rows as i64, num_rows as i64));
+    }
+    if has_validity_bitmap(array_data.data_type(), write_options) {
+        // write null buffer if exists
+        let null_buffer = match array_data.nulls() {
+            None => {
+                // create a buffer and fill it with valid bits
+                let num_bytes = bit_util::ceil(num_rows, 8);
+                let buffer = MutableBuffer::new(num_bytes);
+                let buffer = buffer.with_bitset(num_bytes, true);
+                buffer.into()
+            }
+            Some(buffer) => buffer.inner().sliced(),
+        };
+
+        offset = write_buffer(
+            null_buffer.as_slice(),
+            buffers,
+            arrow_data,
+            offset,
+            compression_codec,
+        )?;
+    }
+
+    let data_type = array_data.data_type();
+    if matches!(data_type, DataType::Binary | DataType::Utf8) {
+        let (offsets, values) = get_byte_array_buffers::<i32>(array_data);
+        for buffer in [offsets, values] {
+            offset = write_buffer(
+                buffer.as_slice(),
+                buffers,
+                arrow_data,
+                offset,
+                compression_codec,
+            )?;
+        }
+    } else if matches!(data_type, DataType::LargeBinary | DataType::LargeUtf8) {
+        let (offsets, values) = get_byte_array_buffers::<i64>(array_data);
+        for buffer in [offsets, values] {
+            offset = write_buffer(
+                buffer.as_slice(),
+                buffers,
+                arrow_data,
+                offset,
+                compression_codec,
+            )?;
+        }
+    } else if DataType::is_numeric(data_type)
+        || DataType::is_temporal(data_type)
+        || matches!(
+            array_data.data_type(),
+            DataType::FixedSizeBinary(_) | DataType::Dictionary(_, _)
+        )
+    {
+        // Truncate values
+        assert_eq!(array_data.buffers().len(), 1);
+
+        let buffer = &array_data.buffers()[0];
+        let layout = layout(data_type);
+        let spec = &layout.buffers[0];
+
+        let byte_width = get_buffer_element_width(spec);
+        let min_length = array_data.len() * byte_width;
+        let buffer_slice = if buffer_need_truncate(array_data.offset(), buffer, spec, min_length) {
+            let byte_offset = array_data.offset() * byte_width;
+            let buffer_length = min(min_length, buffer.len() - byte_offset);
+            &buffer.as_slice()[byte_offset..(byte_offset + buffer_length)]
+        } else {
+            buffer.as_slice()
+        };
+        offset = write_buffer(buffer_slice, buffers, arrow_data, offset, compression_codec)?;
+    } else if matches!(data_type, DataType::Boolean) {
+        // Bools are special because the payload (= 1 bit) is smaller than the physical container elements (= bytes).
+        // The array data may not start at the physical boundary of the underlying buffer, so we need to shift bits around.
+        assert_eq!(array_data.buffers().len(), 1);
+
+        let buffer = &array_data.buffers()[0];
+        let buffer = buffer.bit_slice(array_data.offset(), array_data.len());
+        offset = write_buffer(&buffer, buffers, arrow_data, offset, compression_codec)?;
+    } else if matches!(
+        data_type,
+        DataType::List(_) | DataType::LargeList(_) | DataType::Map(_, _)
+    ) {
+        assert_eq!(array_data.buffers().len(), 1);
+        assert_eq!(array_data.child_data().len(), 1);
+
+        // Truncate offsets and the child data to avoid writing unnecessary data
+        let (offsets, sliced_child_data) = match data_type {
+            DataType::List(_) => get_list_array_buffers::<i32>(array_data),
+            DataType::Map(_, _) => get_list_array_buffers::<i32>(array_data),
+            DataType::LargeList(_) => get_list_array_buffers::<i64>(array_data),
+            _ => unreachable!(),
+        };
+        offset = write_buffer(
+            offsets.as_slice(),
+            buffers,
+            arrow_data,
+            offset,
+            compression_codec,
+        )?;
+        offset = write_array_data(
+            &sliced_child_data,
+            buffers,
+            arrow_data,
+            nodes,
+            offset,
+            sliced_child_data.len(),
+            sliced_child_data.null_count(),
+            compression_codec,
+            write_options,
+        )?;
+        return Ok(offset);
+    } else {
+        for buffer in array_data.buffers() {
+            offset = write_buffer(buffer, buffers, arrow_data, offset, compression_codec)?;
+        }
+    }
+
+    match array_data.data_type() {
+        DataType::Dictionary(_, _) => {}
+        DataType::RunEndEncoded(_, _) => {
+            // unslice the run encoded array.
+            let arr = unslice_run_array(array_data.clone())?;
+            // recursively write out nested structures
+            for data_ref in arr.child_data() {
+                // write the nested data (e.g list data)
+                offset = write_array_data(
+                    data_ref,
+                    buffers,
+                    arrow_data,
+                    nodes,
+                    offset,
+                    data_ref.len(),
+                    data_ref.null_count(),
+                    compression_codec,
+                    write_options,
+                )?;
+            }
+        }
+        _ => {
+            // recursively write out nested structures
+            for data_ref in array_data.child_data() {
+                // write the nested data (e.g list data)
+                offset = write_array_data(
+                    data_ref,
+                    buffers,
+                    arrow_data,
+                    nodes,
+                    offset,
+                    data_ref.len(),
+                    data_ref.null_count(),
+                    compression_codec,
+                    write_options,
+                )?;
+            }
+        }
+    }
+    Ok(offset)
+}
+
+/// Write a buffer into `arrow_data`, a vector of bytes, and adds its
+/// [`crate::Buffer`] to `buffers`. Returns the new offset in `arrow_data`
+///
+///
+/// From <https://github.com/apache/arrow/blob/6a936c4ff5007045e86f65f1a6b6c3c955ad5103/format/Message.fbs#L58>
+/// Each constituent buffer is first compressed with the indicated
+/// compressor, and then written with the uncompressed length in the first 8
+/// bytes as a 64-bit little-endian signed integer followed by the compressed
+/// buffer bytes (and then padding as required by the protocol). The
+/// uncompressed length may be set to -1 to indicate that the data that
+/// follows is not compressed, which can be useful for cases where
+/// compression does not yield appreciable savings.
+fn write_buffer(
+    buffer: &[u8],                    // input
+    buffers: &mut Vec<crate::Buffer>, // output buffer descriptors
+    arrow_data: &mut Vec<u8>,         // output stream
+    offset: i64,                      // current output stream offset
+    compression_codec: Option<CompressionCodec>,
+) -> Result<i64, ArrowError> {
+    let len: i64 = match compression_codec {
+        Some(compressor) => compressor.compress_to_vec(buffer, arrow_data)?,
+        None => {
+            arrow_data.extend_from_slice(buffer);
+            buffer.len()
+        }
+    }
+    .try_into()
+    .map_err(|e| {
+        ArrowError::InvalidArgumentError(format!("Could not convert compressed size to i64: {e}"))
+    })?;
+
+    // make new index entry
+    buffers.push(crate::Buffer::new(offset, len));
+    // padding and make offset 8 bytes aligned
+    let pad_len = pad_to_8(len as u32) as i64;
+    arrow_data.extend_from_slice(&vec![0u8; pad_len as usize][..]);
+
+    Ok(offset + len + pad_len)
+}
+
+/// Calculate an 8-byte boundary and return the number of bytes needed to pad to 8 bytes
+#[inline]
+fn pad_to_8(len: u32) -> usize {
+    (((len + 7) & !7) - len) as usize
+}
+
+#[cfg(test)]
+mod tests {
+    use std::io::Cursor;
+    use std::io::Seek;
+    use std::sync::Arc;
+
+    use arrow_array::builder::GenericListBuilder;
+    use arrow_array::builder::MapBuilder;
+    use arrow_array::builder::UnionBuilder;
+    use arrow_array::builder::{PrimitiveRunBuilder, UInt32Builder};
+    use arrow_array::types::*;
+    use arrow_schema::DataType;
+
+    use crate::reader::*;
+    use crate::MetadataVersion;
+
+    use super::*;
+
+    fn serialize_file(rb: &RecordBatch) -> Vec<u8> {
+        let mut writer = FileWriter::try_new(vec![], &rb.schema()).unwrap();
+        writer.write(rb).unwrap();
+        writer.finish().unwrap();
+        writer.into_inner().unwrap()
+    }
+
+    fn deserialize_file(bytes: Vec<u8>) -> RecordBatch {
+        let mut reader = FileReader::try_new(Cursor::new(bytes), None).unwrap();
+        reader.next().unwrap().unwrap()
+    }
+
+    fn serialize_stream(record: &RecordBatch) -> Vec<u8> {
+        let mut stream_writer = StreamWriter::try_new(vec![], &record.schema()).unwrap();
+        stream_writer.write(record).unwrap();
+        stream_writer.finish().unwrap();
+        stream_writer.into_inner().unwrap()
+    }
+
+    fn deserialize_stream(bytes: Vec<u8>) -> RecordBatch {
+        let mut stream_reader = StreamReader::try_new(Cursor::new(bytes), None).unwrap();
+        stream_reader.next().unwrap().unwrap()
+    }
+
+    #[test]
+    #[cfg(feature = "lz4")]
+    fn test_write_empty_record_batch_lz4_compression() {
+        let schema = Schema::new(vec![Field::new("field1", DataType::Int32, true)]);
+        let values: Vec<Option<i32>> = vec![];
+        let array = Int32Array::from(values);
+        let record_batch =
+            RecordBatch::try_new(Arc::new(schema.clone()), vec![Arc::new(array)]).unwrap();
+
+        let mut file = tempfile::tempfile().unwrap();
+
+        {
+            let write_option = IpcWriteOptions::try_new(8, false, crate::MetadataVersion::V5)
+                .unwrap()
+                .try_with_compression(Some(crate::CompressionType::LZ4_FRAME))
+                .unwrap();
+
+            let mut writer =
+                FileWriter::try_new_with_options(&mut file, &schema, write_option).unwrap();
+            writer.write(&record_batch).unwrap();
+            writer.finish().unwrap();
+        }
+        file.rewind().unwrap();
+        {
+            // read file
+            let reader = FileReader::try_new(file, None).unwrap();
+            for read_batch in reader {
+                read_batch
+                    .unwrap()
+                    .columns()
+                    .iter()
+                    .zip(record_batch.columns())
+                    .for_each(|(a, b)| {
+                        assert_eq!(a.data_type(), b.data_type());
+                        assert_eq!(a.len(), b.len());
+                        assert_eq!(a.null_count(), b.null_count());
+                    });
+            }
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "lz4")]
+    fn test_write_file_with_lz4_compression() {
+        let schema = Schema::new(vec![Field::new("field1", DataType::Int32, true)]);
+        let values: Vec<Option<i32>> = vec![Some(12), Some(1)];
+        let array = Int32Array::from(values);
+        let record_batch =
+            RecordBatch::try_new(Arc::new(schema.clone()), vec![Arc::new(array)]).unwrap();
+
+        let mut file = tempfile::tempfile().unwrap();
+        {
+            let write_option = IpcWriteOptions::try_new(8, false, crate::MetadataVersion::V5)
+                .unwrap()
+                .try_with_compression(Some(crate::CompressionType::LZ4_FRAME))
+                .unwrap();
+
+            let mut writer =
+                FileWriter::try_new_with_options(&mut file, &schema, write_option).unwrap();
+            writer.write(&record_batch).unwrap();
+            writer.finish().unwrap();
+        }
+        file.rewind().unwrap();
+        {
+            // read file
+            let reader = FileReader::try_new(file, None).unwrap();
+            for read_batch in reader {
+                read_batch
+                    .unwrap()
+                    .columns()
+                    .iter()
+                    .zip(record_batch.columns())
+                    .for_each(|(a, b)| {
+                        assert_eq!(a.data_type(), b.data_type());
+                        assert_eq!(a.len(), b.len());
+                        assert_eq!(a.null_count(), b.null_count());
+                    });
+            }
+        }
+    }
+
+    #[test]
+    #[cfg(feature = "zstd")]
+    fn test_write_file_with_zstd_compression() {
+        let schema = Schema::new(vec![Field::new("field1", DataType::Int32, true)]);
+        let values: Vec<Option<i32>> = vec![Some(12), Some(1)];
+        let array = Int32Array::from(values);
+        let record_batch =
+            RecordBatch::try_new(Arc::new(schema.clone()), vec![Arc::new(array)]).unwrap();
+        let mut file = tempfile::tempfile().unwrap();
+        {
+            let write_option = IpcWriteOptions::try_new(8, false, crate::MetadataVersion::V5)
+                .unwrap()
+                .try_with_compression(Some(crate::CompressionType::ZSTD))
+                .unwrap();
+
+            let mut writer =
+                FileWriter::try_new_with_options(&mut file, &schema, write_option).unwrap();
+            writer.write(&record_batch).unwrap();
+            writer.finish().unwrap();
+        }
+        file.rewind().unwrap();
+        {
+            // read file
+            let reader = FileReader::try_new(file, None).unwrap();
+            for read_batch in reader {
+                read_batch
+                    .unwrap()
+                    .columns()
+                    .iter()
+                    .zip(record_batch.columns())
+                    .for_each(|(a, b)| {
+                        assert_eq!(a.data_type(), b.data_type());
+                        assert_eq!(a.len(), b.len());
+                        assert_eq!(a.null_count(), b.null_count());
+                    });
+            }
+        }
+    }
+
+    #[test]
+    fn test_write_file() {
+        let schema = Schema::new(vec![Field::new("field1", DataType::UInt32, true)]);
+        let values: Vec<Option<u32>> = vec![
+            Some(999),
+            None,
+            Some(235),
+            Some(123),
+            None,
+            None,
+            None,
+            None,
+            None,
+        ];
+        let array1 = UInt32Array::from(values);
+        let batch =
+            RecordBatch::try_new(Arc::new(schema.clone()), vec![Arc::new(array1) as ArrayRef])
+                .unwrap();
+        let mut file = tempfile::tempfile().unwrap();
+        {
+            let mut writer = FileWriter::try_new(&mut file, &schema).unwrap();
+
+            writer.write(&batch).unwrap();
+            writer.finish().unwrap();
+        }
+        file.rewind().unwrap();
+
+        {
+            let mut reader = FileReader::try_new(file, None).unwrap();
+            while let Some(Ok(read_batch)) = reader.next() {
+                read_batch
+                    .columns()
+                    .iter()
+                    .zip(batch.columns())
+                    .for_each(|(a, b)| {
+                        assert_eq!(a.data_type(), b.data_type());
+                        assert_eq!(a.len(), b.len());
+                        assert_eq!(a.null_count(), b.null_count());
+                    });
+            }
+        }
+    }
+
+    fn write_null_file(options: IpcWriteOptions) {
+        let schema = Schema::new(vec![
+            Field::new("nulls", DataType::Null, true),
+            Field::new("int32s", DataType::Int32, false),
+            Field::new("nulls2", DataType::Null, true),
+            Field::new("f64s", DataType::Float64, false),
+        ]);
+        let array1 = NullArray::new(32);
+        let array2 = Int32Array::from(vec![1; 32]);
+        let array3 = NullArray::new(32);
+        let array4 = Float64Array::from(vec![std::f64::NAN; 32]);
+        let batch = RecordBatch::try_new(
+            Arc::new(schema.clone()),
+            vec![
+                Arc::new(array1) as ArrayRef,
+                Arc::new(array2) as ArrayRef,
+                Arc::new(array3) as ArrayRef,
+                Arc::new(array4) as ArrayRef,
+            ],
+        )
+        .unwrap();
+        let mut file = tempfile::tempfile().unwrap();
+        {
+            let mut writer = FileWriter::try_new_with_options(&mut file, &schema, options).unwrap();
+
+            writer.write(&batch).unwrap();
+            writer.finish().unwrap();
+        }
+
+        file.rewind().unwrap();
+
+        {
+            let reader = FileReader::try_new(file, None).unwrap();
+            reader.for_each(|maybe_batch| {
+                maybe_batch
+                    .unwrap()
+                    .columns()
+                    .iter()
+                    .zip(batch.columns())
+                    .for_each(|(a, b)| {
+                        assert_eq!(a.data_type(), b.data_type());
+                        assert_eq!(a.len(), b.len());
+                        assert_eq!(a.null_count(), b.null_count());
+                    });
+            });
+        }
+    }
+    #[test]
+    fn test_write_null_file_v4() {
+        write_null_file(IpcWriteOptions::try_new(8, false, MetadataVersion::V4).unwrap());
+        write_null_file(IpcWriteOptions::try_new(8, true, MetadataVersion::V4).unwrap());
+        write_null_file(IpcWriteOptions::try_new(64, false, MetadataVersion::V4).unwrap());
+        write_null_file(IpcWriteOptions::try_new(64, true, MetadataVersion::V4).unwrap());
+    }
+
+    #[test]
+    fn test_write_null_file_v5() {
+        write_null_file(IpcWriteOptions::try_new(8, false, MetadataVersion::V5).unwrap());
+        write_null_file(IpcWriteOptions::try_new(64, false, MetadataVersion::V5).unwrap());
+    }
+
+    #[test]
+    fn track_union_nested_dict() {
+        let inner: DictionaryArray<Int32Type> = vec!["a", "b", "a"].into_iter().collect();
+
+        let array = Arc::new(inner) as ArrayRef;
+
+        // Dict field with id 2
+        let dctfield = Field::new_dict("dict", array.data_type().clone(), false, 2, false);
+
+        let types = Buffer::from_slice_ref([0_i8, 0, 0]);
+        let offsets = Buffer::from_slice_ref([0_i32, 1, 2]);
+
+        let union =
+            UnionArray::try_new(&[0], types, Some(offsets), vec![(dctfield, array)]).unwrap();
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "union",
+            union.data_type().clone(),
+            false,
+        )]));
+
+        let batch = RecordBatch::try_new(schema, vec![Arc::new(union)]).unwrap();
+
+        let gen = IpcDataGenerator {};
+        let mut dict_tracker = DictionaryTracker::new(false);
+        gen.encoded_batch(&batch, &mut dict_tracker, &Default::default())
+            .unwrap();
+
+        // Dictionary with id 2 should have been written to the dict tracker
+        assert!(dict_tracker.written.contains_key(&2));
+    }
+
+    #[test]
+    fn track_struct_nested_dict() {
+        let inner: DictionaryArray<Int32Type> = vec!["a", "b", "a"].into_iter().collect();
+
+        let array = Arc::new(inner) as ArrayRef;
+
+        // Dict field with id 2
+        let dctfield = Arc::new(Field::new_dict(
+            "dict",
+            array.data_type().clone(),
+            false,
+            2,
+            false,
+        ));
+
+        let s = StructArray::from(vec![(dctfield, array)]);
+        let struct_array = Arc::new(s) as ArrayRef;
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "struct",
+            struct_array.data_type().clone(),
+            false,
+        )]));
+
+        let batch = RecordBatch::try_new(schema, vec![struct_array]).unwrap();
+
+        let gen = IpcDataGenerator {};
+        let mut dict_tracker = DictionaryTracker::new(false);
+        gen.encoded_batch(&batch, &mut dict_tracker, &Default::default())
+            .unwrap();
+
+        // Dictionary with id 2 should have been written to the dict tracker
+        assert!(dict_tracker.written.contains_key(&2));
+    }
+
+    fn write_union_file(options: IpcWriteOptions) {
+        let schema = Schema::new(vec![Field::new_union(
+            "union",
+            vec![0, 1],
+            vec![
+                Field::new("a", DataType::Int32, false),
+                Field::new("c", DataType::Float64, false),
+            ],
+            UnionMode::Sparse,
+        )]);
+        let mut builder = UnionBuilder::with_capacity_sparse(5);
+        builder.append::<Int32Type>("a", 1).unwrap();
+        builder.append_null::<Int32Type>("a").unwrap();
+        builder.append::<Float64Type>("c", 3.0).unwrap();
+        builder.append_null::<Float64Type>("c").unwrap();
+        builder.append::<Int32Type>("a", 4).unwrap();
+        let union = builder.build().unwrap();
+
+        let batch =
+            RecordBatch::try_new(Arc::new(schema.clone()), vec![Arc::new(union) as ArrayRef])
+                .unwrap();
+
+        let mut file = tempfile::tempfile().unwrap();
+        {
+            let mut writer = FileWriter::try_new_with_options(&mut file, &schema, options).unwrap();
+
+            writer.write(&batch).unwrap();
+            writer.finish().unwrap();
+        }
+        file.rewind().unwrap();
+
+        {
+            let reader = FileReader::try_new(file, None).unwrap();
+            reader.for_each(|maybe_batch| {
+                maybe_batch
+                    .unwrap()
+                    .columns()
+                    .iter()
+                    .zip(batch.columns())
+                    .for_each(|(a, b)| {
+                        assert_eq!(a.data_type(), b.data_type());
+                        assert_eq!(a.len(), b.len());
+                        assert_eq!(a.null_count(), b.null_count());
+                    });
+            });
+        }
+    }
+
+    #[test]
+    fn test_write_union_file_v4_v5() {
+        write_union_file(IpcWriteOptions::try_new(8, false, MetadataVersion::V4).unwrap());
+        write_union_file(IpcWriteOptions::try_new(8, false, MetadataVersion::V5).unwrap());
+    }
+
+    #[test]
+    fn truncate_ipc_record_batch() {
+        fn create_batch(rows: usize) -> RecordBatch {
+            let schema = Schema::new(vec![
+                Field::new("a", DataType::Int32, false),
+                Field::new("b", DataType::Utf8, false),
+            ]);
+
+            let a = Int32Array::from_iter_values(0..rows as i32);
+            let b = StringArray::from_iter_values((0..rows).map(|i| i.to_string()));
+
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]).unwrap()
+        }
+
+        let big_record_batch = create_batch(65536);
+
+        let length = 5;
+        let small_record_batch = create_batch(length);
+
+        let offset = 2;
+        let record_batch_slice = big_record_batch.slice(offset, length);
+        assert!(
+            serialize_stream(&big_record_batch).len() > serialize_stream(&small_record_batch).len()
+        );
+        assert_eq!(
+            serialize_stream(&small_record_batch).len(),
+            serialize_stream(&record_batch_slice).len()
+        );
+
+        assert_eq!(
+            deserialize_stream(serialize_stream(&record_batch_slice)),
+            record_batch_slice
+        );
+    }
+
+    #[test]
+    fn truncate_ipc_record_batch_with_nulls() {
+        fn create_batch() -> RecordBatch {
+            let schema = Schema::new(vec![
+                Field::new("a", DataType::Int32, true),
+                Field::new("b", DataType::Utf8, true),
+            ]);
+
+            let a = Int32Array::from(vec![Some(1), None, Some(1), None, Some(1)]);
+            let b = StringArray::from(vec![None, Some("a"), Some("a"), None, Some("a")]);
+
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]).unwrap()
+        }
+
+        let record_batch = create_batch();
+        let record_batch_slice = record_batch.slice(1, 2);
+        let deserialized_batch = deserialize_stream(serialize_stream(&record_batch_slice));
+
+        assert!(
+            serialize_stream(&record_batch).len() > serialize_stream(&record_batch_slice).len()
+        );
+
+        assert!(deserialized_batch.column(0).is_null(0));
+        assert!(deserialized_batch.column(0).is_valid(1));
+        assert!(deserialized_batch.column(1).is_valid(0));
+        assert!(deserialized_batch.column(1).is_valid(1));
+
+        assert_eq!(record_batch_slice, deserialized_batch);
+    }
+
+    #[test]
+    fn truncate_ipc_dictionary_array() {
+        fn create_batch() -> RecordBatch {
+            let values: StringArray = [Some("foo"), Some("bar"), Some("baz")]
+                .into_iter()
+                .collect();
+            let keys: Int32Array = [Some(0), Some(2), None, Some(1)].into_iter().collect();
+
+            let array = DictionaryArray::new(keys, Arc::new(values));
+
+            let schema = Schema::new(vec![Field::new("dict", array.data_type().clone(), true)]);
+
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(array)]).unwrap()
+        }
+
+        let record_batch = create_batch();
+        let record_batch_slice = record_batch.slice(1, 2);
+        let deserialized_batch = deserialize_stream(serialize_stream(&record_batch_slice));
+
+        assert!(
+            serialize_stream(&record_batch).len() > serialize_stream(&record_batch_slice).len()
+        );
+
+        assert!(deserialized_batch.column(0).is_valid(0));
+        assert!(deserialized_batch.column(0).is_null(1));
+
+        assert_eq!(record_batch_slice, deserialized_batch);
+    }
+
+    #[test]
+    fn truncate_ipc_struct_array() {
+        fn create_batch() -> RecordBatch {
+            let strings: StringArray = [Some("foo"), None, Some("bar"), Some("baz")]
+                .into_iter()
+                .collect();
+            let ints: Int32Array = [Some(0), Some(2), None, Some(1)].into_iter().collect();
+
+            let struct_array = StructArray::from(vec![
+                (
+                    Arc::new(Field::new("s", DataType::Utf8, true)),
+                    Arc::new(strings) as ArrayRef,
+                ),
+                (
+                    Arc::new(Field::new("c", DataType::Int32, true)),
+                    Arc::new(ints) as ArrayRef,
+                ),
+            ]);
+
+            let schema = Schema::new(vec![Field::new(
+                "struct_array",
+                struct_array.data_type().clone(),
+                true,
+            )]);
+
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(struct_array)]).unwrap()
+        }
+
+        let record_batch = create_batch();
+        let record_batch_slice = record_batch.slice(1, 2);
+        let deserialized_batch = deserialize_stream(serialize_stream(&record_batch_slice));
+
+        assert!(
+            serialize_stream(&record_batch).len() > serialize_stream(&record_batch_slice).len()
+        );
+
+        let structs = deserialized_batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<StructArray>()
+            .unwrap();
+
+        assert!(structs.column(0).is_null(0));
+        assert!(structs.column(0).is_valid(1));
+        assert!(structs.column(1).is_valid(0));
+        assert!(structs.column(1).is_null(1));
+        assert_eq!(record_batch_slice, deserialized_batch);
+    }
+
+    #[test]
+    fn truncate_ipc_string_array_with_all_empty_string() {
+        fn create_batch() -> RecordBatch {
+            let schema = Schema::new(vec![Field::new("a", DataType::Utf8, true)]);
+            let a = StringArray::from(vec![Some(""), Some(""), Some(""), Some(""), Some("")]);
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap()
+        }
+
+        let record_batch = create_batch();
+        let record_batch_slice = record_batch.slice(0, 1);
+        let deserialized_batch = deserialize_stream(serialize_stream(&record_batch_slice));
+
+        assert!(
+            serialize_stream(&record_batch).len() > serialize_stream(&record_batch_slice).len()
+        );
+        assert_eq!(record_batch_slice, deserialized_batch);
+    }
+
+    #[test]
+    fn test_stream_writer_writes_array_slice() {
+        let array = UInt32Array::from(vec![Some(1), Some(2), Some(3)]);
+        assert_eq!(
+            vec![Some(1), Some(2), Some(3)],
+            array.iter().collect::<Vec<_>>()
+        );
+
+        let sliced = array.slice(1, 2);
+        assert_eq!(vec![Some(2), Some(3)], sliced.iter().collect::<Vec<_>>());
+
+        let batch = RecordBatch::try_new(
+            Arc::new(Schema::new(vec![Field::new("a", DataType::UInt32, true)])),
+            vec![Arc::new(sliced)],
+        )
+        .expect("new batch");
+
+        let mut writer = StreamWriter::try_new(vec![], &batch.schema()).expect("new writer");
+        writer.write(&batch).expect("write");
+        let outbuf = writer.into_inner().expect("inner");
+
+        let mut reader = StreamReader::try_new(&outbuf[..], None).expect("new reader");
+        let read_batch = reader.next().unwrap().expect("read batch");
+
+        let read_array: &UInt32Array = read_batch.column(0).as_primitive();
+        assert_eq!(
+            vec![Some(2), Some(3)],
+            read_array.iter().collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn encode_bools_slice() {
+        // Test case for https://github.com/apache/arrow-rs/issues/3496
+        assert_bool_roundtrip([true, false], 1, 1);
+
+        // slice somewhere in the middle
+        assert_bool_roundtrip(
+            [
+                true, false, true, true, false, false, true, true, true, false, false, false, true,
+                true, true, true, false, false, false, false, true, true, true, true, true, false,
+                false, false, false, false,
+            ],
+            13,
+            17,
+        );
+
+        // start at byte boundary, end in the middle
+        assert_bool_roundtrip(
+            [
+                true, false, true, true, false, false, true, true, true, false, false, false,
+            ],
+            8,
+            2,
+        );
+
+        // start and stop and byte boundary
+        assert_bool_roundtrip(
+            [
+                true, false, true, true, false, false, true, true, true, false, false, false, true,
+                true, true, true, true, false, false, false, false, false,
+            ],
+            8,
+            8,
+        );
+    }
+
+    fn assert_bool_roundtrip<const N: usize>(bools: [bool; N], offset: usize, length: usize) {
+        let val_bool_field = Field::new("val", DataType::Boolean, false);
+
+        let schema = Arc::new(Schema::new(vec![val_bool_field]));
+
+        let bools = BooleanArray::from(bools.to_vec());
+
+        let batch = RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(bools)]).unwrap();
+        let batch = batch.slice(offset, length);
+
+        let data = serialize_stream(&batch);
+        let batch2 = deserialize_stream(data);
+        assert_eq!(batch, batch2);
+    }
+
+    #[test]
+    fn test_run_array_unslice() {
+        let total_len = 80;
+        let vals: Vec<Option<i32>> = vec![Some(1), None, Some(2), Some(3), Some(4), None, Some(5)];
+        let repeats: Vec<usize> = vec![3, 4, 1, 2];
+        let mut input_array: Vec<Option<i32>> = Vec::with_capacity(total_len);
+        for ix in 0_usize..32 {
+            let repeat: usize = repeats[ix % repeats.len()];
+            let val: Option<i32> = vals[ix % vals.len()];
+            input_array.resize(input_array.len() + repeat, val);
+        }
+
+        // Encode the input_array to run array
+        let mut builder =
+            PrimitiveRunBuilder::<Int16Type, Int32Type>::with_capacity(input_array.len());
+        builder.extend(input_array.iter().copied());
+        let run_array = builder.finish();
+
+        // test for all slice lengths.
+        for slice_len in 1..=total_len {
+            // test for offset = 0, slice length = slice_len
+            let sliced_run_array: RunArray<Int16Type> =
+                run_array.slice(0, slice_len).into_data().into();
+
+            // Create unsliced run array.
+            let unsliced_run_array = into_zero_offset_run_array(sliced_run_array).unwrap();
+            let typed = unsliced_run_array
+                .downcast::<PrimitiveArray<Int32Type>>()
+                .unwrap();
+            let expected: Vec<Option<i32>> = input_array.iter().take(slice_len).copied().collect();
+            let actual: Vec<Option<i32>> = typed.into_iter().collect();
+            assert_eq!(expected, actual);
+
+            // test for offset = total_len - slice_len, length = slice_len
+            let sliced_run_array: RunArray<Int16Type> = run_array
+                .slice(total_len - slice_len, slice_len)
+                .into_data()
+                .into();
+
+            // Create unsliced run array.
+            let unsliced_run_array = into_zero_offset_run_array(sliced_run_array).unwrap();
+            let typed = unsliced_run_array
+                .downcast::<PrimitiveArray<Int32Type>>()
+                .unwrap();
+            let expected: Vec<Option<i32>> = input_array
+                .iter()
+                .skip(total_len - slice_len)
+                .copied()
+                .collect();
+            let actual: Vec<Option<i32>> = typed.into_iter().collect();
+            assert_eq!(expected, actual);
+        }
+    }
+
+    fn generate_list_data<O: OffsetSizeTrait>() -> GenericListArray<O> {
+        let mut ls = GenericListBuilder::<O, _>::new(UInt32Builder::new());
+
+        for i in 0..100_000 {
+            for value in [i, i, i] {
+                ls.values().append_value(value);
+            }
+            ls.append(true)
+        }
+
+        ls.finish()
+    }
+
+    fn generate_nested_list_data<O: OffsetSizeTrait>() -> GenericListArray<O> {
+        let mut ls =
+            GenericListBuilder::<O, _>::new(GenericListBuilder::<O, _>::new(UInt32Builder::new()));
+
+        for _i in 0..10_000 {
+            for j in 0..10 {
+                for value in [j, j, j, j] {
+                    ls.values().values().append_value(value);
+                }
+                ls.values().append(true)
+            }
+            ls.append(true);
+        }
+
+        ls.finish()
+    }
+
+    fn generate_map_array_data() -> MapArray {
+        let keys_builder = UInt32Builder::new();
+        let values_builder = UInt32Builder::new();
+
+        let mut builder = MapBuilder::new(None, keys_builder, values_builder);
+
+        for i in 0..100_000 {
+            for _j in 0..3 {
+                builder.keys().append_value(i);
+                builder.values().append_value(i * 2);
+            }
+            builder.append(true).unwrap();
+        }
+
+        builder.finish()
+    }
+
+    /// Ensure when serde full & sliced versions they are equal to original input.
+    /// Also ensure serialized sliced version is significantly smaller than serialized full.
+    fn roundtrip_ensure_sliced_smaller(in_batch: RecordBatch, expected_size_factor: usize) {
+        // test both full and sliced versions
+        let in_sliced = in_batch.slice(999, 1);
+
+        let bytes_batch = serialize_file(&in_batch);
+        let bytes_sliced = serialize_file(&in_sliced);
+
+        // serializing 1 row should be significantly smaller than serializing 100,000
+        assert!(bytes_sliced.len() < (bytes_batch.len() / expected_size_factor));
+
+        // ensure both are still valid and equal to originals
+        let out_batch = deserialize_file(bytes_batch);
+        assert_eq!(in_batch, out_batch);
+
+        let out_sliced = deserialize_file(bytes_sliced);
+        assert_eq!(in_sliced, out_sliced);
+    }
+
+    #[test]
+    fn encode_lists() {
+        let val_inner = Field::new("item", DataType::UInt32, true);
+        let val_list_field = Field::new("val", DataType::List(Arc::new(val_inner)), false);
+        let schema = Arc::new(Schema::new(vec![val_list_field]));
+
+        let values = Arc::new(generate_list_data::<i32>());
+
+        let in_batch = RecordBatch::try_new(schema, vec![values]).unwrap();
+        roundtrip_ensure_sliced_smaller(in_batch, 1000);
+    }
+
+    #[test]
+    fn encode_empty_list() {
+        let val_inner = Field::new("item", DataType::UInt32, true);
+        let val_list_field = Field::new("val", DataType::List(Arc::new(val_inner)), false);
+        let schema = Arc::new(Schema::new(vec![val_list_field]));
+
+        let values = Arc::new(generate_list_data::<i32>());
+
+        let in_batch = RecordBatch::try_new(schema, vec![values])
+            .unwrap()
+            .slice(999, 0);
+        let out_batch = deserialize_file(serialize_file(&in_batch));
+        assert_eq!(in_batch, out_batch);
+    }
+
+    #[test]
+    fn encode_large_lists() {
+        let val_inner = Field::new("item", DataType::UInt32, true);
+        let val_list_field = Field::new("val", DataType::LargeList(Arc::new(val_inner)), false);
+        let schema = Arc::new(Schema::new(vec![val_list_field]));
+
+        let values = Arc::new(generate_list_data::<i64>());
+
+        // ensure when serde full & sliced versions they are equal to original input
+        // also ensure serialized sliced version is significantly smaller than serialized full
+        let in_batch = RecordBatch::try_new(schema, vec![values]).unwrap();
+        roundtrip_ensure_sliced_smaller(in_batch, 1000);
+    }
+
+    #[test]
+    fn encode_nested_lists() {
+        let inner_int = Arc::new(Field::new("item", DataType::UInt32, true));
+        let inner_list_field = Arc::new(Field::new("item", DataType::List(inner_int), true));
+        let list_field = Field::new("val", DataType::List(inner_list_field), true);
+        let schema = Arc::new(Schema::new(vec![list_field]));
+
+        let values = Arc::new(generate_nested_list_data::<i32>());
+
+        let in_batch = RecordBatch::try_new(schema, vec![values]).unwrap();
+        roundtrip_ensure_sliced_smaller(in_batch, 1000);
+    }
+
+    #[test]
+    fn encode_map_array() {
+        let keys = Arc::new(Field::new("keys", DataType::UInt32, false));
+        let values = Arc::new(Field::new("values", DataType::UInt32, true));
+        let map_field = Field::new_map("map", "entries", keys, values, false, true);
+        let schema = Arc::new(Schema::new(vec![map_field]));
+
+        let values = Arc::new(generate_map_array_data());
+
+        let in_batch = RecordBatch::try_new(schema, vec![values]).unwrap();
+        roundtrip_ensure_sliced_smaller(in_batch, 1000);
+    }
+}
diff --git a/arrow-json/Cargo.toml b/arrow-json/Cargo.toml
new file mode 100644
index 000000000000..dd232f197ead
--- /dev/null
+++ b/arrow-json/Cargo.toml
@@ -0,0 +1,63 @@
+# 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]
+name = "arrow-json"
+version = { workspace = true }
+description = "Support for parsing JSON format to and from the Arrow format"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_json"
+path = "src/lib.rs"
+bench = false
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-cast = { workspace = true }
+arrow-data = { workspace = true }
+arrow-schema = { workspace = true }
+half = { version = "2.1", default-features = false }
+indexmap = { version = "2.0", default-features = false, features = ["std"] }
+num = { version = "0.4", default-features = false, features = ["std"] }
+serde = { version = "1.0", default-features = false }
+serde_json = { version = "1.0", default-features = false, features = ["std"] }
+chrono = { workspace = true }
+lexical-core = { version = "0.8", default-features = false }
+
+[dev-dependencies]
+tempfile = "3.3"
+flate2 = { version = "1", default-features = false, features = ["rust_backend"] }
+serde = { version = "1.0", default-features = false, features = ["derive"] }
+futures = "0.3"
+tokio = { version = "1.27", default-features = false, features = ["io-util"] }
+bytes = "1.4"
+criterion = { version = "0.5", default-features = false }
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
+
+[[bench]]
+name = "serde"
+harness = false
+
diff --git a/arrow-json/benches/serde.rs b/arrow-json/benches/serde.rs
new file mode 100644
index 000000000000..7636b9c9dff9
--- /dev/null
+++ b/arrow-json/benches/serde.rs
@@ -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.
+
+use arrow_json::ReaderBuilder;
+use arrow_schema::{DataType, Field, Schema};
+use criterion::*;
+use rand::{thread_rng, Rng};
+use serde::Serialize;
+use std::sync::Arc;
+
+#[allow(deprecated)]
+fn do_bench<R: Serialize>(c: &mut Criterion, name: &str, rows: &[R], schema: &Schema) {
+    let schema = Arc::new(schema.clone());
+    c.bench_function(name, |b| {
+        b.iter(|| {
+            let builder = ReaderBuilder::new(schema.clone()).with_batch_size(64);
+            let mut decoder = builder.build_decoder().unwrap();
+            decoder.serialize(rows)
+        })
+    });
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut rng = thread_rng();
+    let schema = Schema::new(vec![Field::new("i32", DataType::Int32, false)]);
+    let v: Vec<i32> = (0..2048).map(|_| rng.gen_range(0..10000)).collect();
+
+    do_bench(c, "small_i32", &v, &schema);
+    let v: Vec<i32> = (0..2048).map(|_| rng.gen()).collect();
+    do_bench(c, "large_i32", &v, &schema);
+
+    let schema = Schema::new(vec![Field::new("i64", DataType::Int64, false)]);
+    let v: Vec<i64> = (0..2048).map(|_| rng.gen_range(0..10000)).collect();
+    do_bench(c, "small_i64", &v, &schema);
+    let v: Vec<i64> = (0..2048).map(|_| rng.gen_range(0..i32::MAX as _)).collect();
+    do_bench(c, "medium_i64", &v, &schema);
+    let v: Vec<i64> = (0..2048).map(|_| rng.gen()).collect();
+    do_bench(c, "large_i64", &v, &schema);
+
+    let schema = Schema::new(vec![Field::new("f32", DataType::Float32, false)]);
+    let v: Vec<f32> = (0..2048).map(|_| rng.gen_range(0.0..10000.)).collect();
+    do_bench(c, "small_f32", &v, &schema);
+    let v: Vec<f32> = (0..2048).map(|_| rng.gen_range(0.0..f32::MAX)).collect();
+    do_bench(c, "large_f32", &v, &schema);
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow-json/src/lib.rs b/arrow-json/src/lib.rs
new file mode 100644
index 000000000000..e39882e52620
--- /dev/null
+++ b/arrow-json/src/lib.rs
@@ -0,0 +1,174 @@
+// 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.
+
+//! Transfer data between the Arrow memory format and JSON line-delimited records.
+//!
+//! See the module level documentation for the
+//! [`reader`] and [`writer`] for usage examples.
+//!
+//! # Binary Data
+//!
+//! As per [RFC7159] JSON cannot encode arbitrary binary data. A common approach to workaround
+//! this is to use a [binary-to-text encoding] scheme, such as base64, to encode the
+//! input data and then decode it on output.
+//!
+//! ```
+//! # use std::io::Cursor;
+//! # use std::sync::Arc;
+//! # use arrow_array::{BinaryArray, RecordBatch, StringArray};
+//! # use arrow_array::cast::AsArray;
+//! # use arrow_cast::base64::{b64_decode, b64_encode, BASE64_STANDARD};
+//! # use arrow_json::{LineDelimitedWriter, ReaderBuilder};
+//! #
+//! // The data we want to write
+//! let input = BinaryArray::from(vec![b"\xDE\x00\xFF".as_ref()]);
+//!
+//! // Base64 encode it to a string
+//! let encoded: StringArray = b64_encode(&BASE64_STANDARD, &input);
+//!
+//! // Write the StringArray to JSON
+//! let batch = RecordBatch::try_from_iter([("col", Arc::new(encoded) as _)]).unwrap();
+//! let mut buf = Vec::with_capacity(1024);
+//! let mut writer = LineDelimitedWriter::new(&mut buf);
+//! writer.write(&batch).unwrap();
+//! writer.finish().unwrap();
+//!
+//! // Read the JSON data
+//! let cursor = Cursor::new(buf);
+//! let mut reader = ReaderBuilder::new(batch.schema()).build(cursor).unwrap();
+//! let batch = reader.next().unwrap().unwrap();
+//!
+//! // Reverse the base64 encoding
+//! let col: BinaryArray = batch.column(0).as_string::<i32>().clone().into();
+//! let output = b64_decode(&BASE64_STANDARD, &col).unwrap();
+//!
+//! assert_eq!(input, output);
+//! ```
+//!
+//! [RFC7159]: https://datatracker.ietf.org/doc/html/rfc7159#section-8.1
+//! [binary-to-text encoding]: https://en.wikipedia.org/wiki/Binary-to-text_encoding
+//!
+
+#![deny(rustdoc::broken_intra_doc_links)]
+#![warn(missing_docs)]
+
+pub mod reader;
+pub mod writer;
+
+#[doc(hidden)]
+#[deprecated(note = "Use Decoder")]
+pub type RawDecoder = reader::Decoder;
+
+#[doc(hidden)]
+#[deprecated(note = "Use Reader")]
+pub type RawReader<R> = Reader<R>;
+
+#[doc(hidden)]
+#[deprecated(note = "Use ReaderBuilder")]
+pub type RawReaderBuilder = ReaderBuilder;
+
+pub use self::reader::{Reader, ReaderBuilder};
+pub use self::writer::{ArrayWriter, LineDelimitedWriter, Writer, WriterBuilder};
+use half::f16;
+use serde_json::{Number, Value};
+
+/// Trait declaring any type that is serializable to JSON. This includes all primitive types (bool, i32, etc.).
+pub trait JsonSerializable: 'static {
+    /// Converts self into json value if its possible
+    fn into_json_value(self) -> Option<Value>;
+}
+
+macro_rules! json_serializable {
+    ($t:ty) => {
+        impl JsonSerializable for $t {
+            fn into_json_value(self) -> Option<Value> {
+                Some(self.into())
+            }
+        }
+    };
+}
+
+json_serializable!(bool);
+json_serializable!(u8);
+json_serializable!(u16);
+json_serializable!(u32);
+json_serializable!(u64);
+json_serializable!(i8);
+json_serializable!(i16);
+json_serializable!(i32);
+json_serializable!(i64);
+
+impl JsonSerializable for i128 {
+    fn into_json_value(self) -> Option<Value> {
+        // Serialize as string to avoid issues with arbitrary_precision serde_json feature
+        // - https://github.com/serde-rs/json/issues/559
+        // - https://github.com/serde-rs/json/issues/845
+        // - https://github.com/serde-rs/json/issues/846
+        Some(self.to_string().into())
+    }
+}
+
+impl JsonSerializable for f16 {
+    fn into_json_value(self) -> Option<Value> {
+        Number::from_f64(f64::round(f64::from(self) * 1000.0) / 1000.0).map(Value::Number)
+    }
+}
+
+impl JsonSerializable for f32 {
+    fn into_json_value(self) -> Option<Value> {
+        Number::from_f64(f64::round(self as f64 * 1000.0) / 1000.0).map(Value::Number)
+    }
+}
+
+impl JsonSerializable for f64 {
+    fn into_json_value(self) -> Option<Value> {
+        Number::from_f64(self).map(Value::Number)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    use serde_json::{
+        Number,
+        Value::{Bool, Number as VNumber, String as VString},
+    };
+
+    #[test]
+    fn test_arrow_native_type_to_json() {
+        assert_eq!(Some(Bool(true)), true.into_json_value());
+        assert_eq!(Some(VNumber(Number::from(1))), 1i8.into_json_value());
+        assert_eq!(Some(VNumber(Number::from(1))), 1i16.into_json_value());
+        assert_eq!(Some(VNumber(Number::from(1))), 1i32.into_json_value());
+        assert_eq!(Some(VNumber(Number::from(1))), 1i64.into_json_value());
+        assert_eq!(Some(VString("1".to_string())), 1i128.into_json_value());
+        assert_eq!(Some(VNumber(Number::from(1))), 1u8.into_json_value());
+        assert_eq!(Some(VNumber(Number::from(1))), 1u16.into_json_value());
+        assert_eq!(Some(VNumber(Number::from(1))), 1u32.into_json_value());
+        assert_eq!(Some(VNumber(Number::from(1))), 1u64.into_json_value());
+        assert_eq!(
+            Some(VNumber(Number::from_f64(0.01f64).unwrap())),
+            0.01.into_json_value()
+        );
+        assert_eq!(
+            Some(VNumber(Number::from_f64(0.01f64).unwrap())),
+            0.01f64.into_json_value()
+        );
+        assert_eq!(None, f32::NAN.into_json_value());
+    }
+}
diff --git a/arrow-json/src/reader/boolean_array.rs b/arrow-json/src/reader/boolean_array.rs
new file mode 100644
index 000000000000..9094391cd7dd
--- /dev/null
+++ b/arrow-json/src/reader/boolean_array.rs
@@ -0,0 +1,43 @@
+// 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.
+
+use arrow_array::builder::BooleanBuilder;
+use arrow_array::Array;
+use arrow_data::ArrayData;
+use arrow_schema::ArrowError;
+
+use crate::reader::tape::{Tape, TapeElement};
+use crate::reader::ArrayDecoder;
+
+#[derive(Default)]
+pub struct BooleanArrayDecoder {}
+
+impl ArrayDecoder for BooleanArrayDecoder {
+    fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayData, ArrowError> {
+        let mut builder = BooleanBuilder::with_capacity(pos.len());
+        for p in pos {
+            match tape.get(*p) {
+                TapeElement::Null => builder.append_null(),
+                TapeElement::True => builder.append_value(true),
+                TapeElement::False => builder.append_value(false),
+                _ => return Err(tape.error(*p, "boolean")),
+            }
+        }
+
+        Ok(builder.finish().into_data())
+    }
+}
diff --git a/arrow-json/src/reader/decimal_array.rs b/arrow-json/src/reader/decimal_array.rs
new file mode 100644
index 000000000000..fc3c9aaa6b43
--- /dev/null
+++ b/arrow-json/src/reader/decimal_array.rs
@@ -0,0 +1,76 @@
+// 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.
+
+use std::marker::PhantomData;
+
+use arrow_array::builder::PrimitiveBuilder;
+use arrow_array::types::DecimalType;
+use arrow_array::Array;
+use arrow_cast::parse::parse_decimal;
+use arrow_data::ArrayData;
+use arrow_schema::ArrowError;
+
+use crate::reader::tape::{Tape, TapeElement};
+use crate::reader::ArrayDecoder;
+
+pub struct DecimalArrayDecoder<D: DecimalType> {
+    precision: u8,
+    scale: i8,
+    // Invariant and Send
+    phantom: PhantomData<fn(D) -> D>,
+}
+
+impl<D: DecimalType> DecimalArrayDecoder<D> {
+    pub fn new(precision: u8, scale: i8) -> Self {
+        Self {
+            precision,
+            scale,
+            phantom: PhantomData,
+        }
+    }
+}
+
+impl<D> ArrayDecoder for DecimalArrayDecoder<D>
+where
+    D: DecimalType,
+{
+    fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayData, ArrowError> {
+        let mut builder = PrimitiveBuilder::<D>::with_capacity(pos.len());
+
+        for p in pos {
+            match tape.get(*p) {
+                TapeElement::Null => builder.append_null(),
+                TapeElement::String(idx) => {
+                    let s = tape.get_string(idx);
+                    let value = parse_decimal::<D>(s, self.precision, self.scale)?;
+                    builder.append_value(value)
+                }
+                TapeElement::Number(idx) => {
+                    let s = tape.get_string(idx);
+                    let value = parse_decimal::<D>(s, self.precision, self.scale)?;
+                    builder.append_value(value)
+                }
+                _ => return Err(tape.error(*p, "decimal")),
+            }
+        }
+
+        Ok(builder
+            .finish()
+            .with_precision_and_scale(self.precision, self.scale)?
+            .into_data())
+    }
+}
diff --git a/arrow-json/src/reader/list_array.rs b/arrow-json/src/reader/list_array.rs
new file mode 100644
index 000000000000..b6f8c18ea9c3
--- /dev/null
+++ b/arrow-json/src/reader/list_array.rs
@@ -0,0 +1,113 @@
+// 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.
+
+use crate::reader::tape::{Tape, TapeElement};
+use crate::reader::{make_decoder, ArrayDecoder};
+use arrow_array::builder::{BooleanBufferBuilder, BufferBuilder};
+use arrow_array::OffsetSizeTrait;
+use arrow_buffer::buffer::NullBuffer;
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType};
+use std::marker::PhantomData;
+
+pub struct ListArrayDecoder<O> {
+    data_type: DataType,
+    decoder: Box<dyn ArrayDecoder>,
+    phantom: PhantomData<O>,
+    is_nullable: bool,
+}
+
+impl<O: OffsetSizeTrait> ListArrayDecoder<O> {
+    pub fn new(
+        data_type: DataType,
+        coerce_primitive: bool,
+        strict_mode: bool,
+        is_nullable: bool,
+    ) -> Result<Self, ArrowError> {
+        let field = match &data_type {
+            DataType::List(f) if !O::IS_LARGE => f,
+            DataType::LargeList(f) if O::IS_LARGE => f,
+            _ => unreachable!(),
+        };
+        let decoder = make_decoder(
+            field.data_type().clone(),
+            coerce_primitive,
+            strict_mode,
+            field.is_nullable(),
+        )?;
+
+        Ok(Self {
+            data_type,
+            decoder,
+            phantom: Default::default(),
+            is_nullable,
+        })
+    }
+}
+
+impl<O: OffsetSizeTrait> ArrayDecoder for ListArrayDecoder<O> {
+    fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayData, ArrowError> {
+        let mut child_pos = Vec::with_capacity(pos.len());
+        let mut offsets = BufferBuilder::<O>::new(pos.len() + 1);
+        offsets.append(O::from_usize(0).unwrap());
+
+        let mut nulls = self
+            .is_nullable
+            .then(|| BooleanBufferBuilder::new(pos.len()));
+
+        for p in pos {
+            let end_idx = match (tape.get(*p), nulls.as_mut()) {
+                (TapeElement::StartList(end_idx), None) => end_idx,
+                (TapeElement::StartList(end_idx), Some(nulls)) => {
+                    nulls.append(true);
+                    end_idx
+                }
+                (TapeElement::Null, Some(nulls)) => {
+                    nulls.append(false);
+                    *p + 1
+                }
+                _ => return Err(tape.error(*p, "[")),
+            };
+
+            let mut cur_idx = *p + 1;
+            while cur_idx < end_idx {
+                child_pos.push(cur_idx);
+
+                // Advance to next field
+                cur_idx = tape.next(cur_idx, "list value")?;
+            }
+
+            let offset = O::from_usize(child_pos.len()).ok_or_else(|| {
+                ArrowError::JsonError(format!("offset overflow decoding {}", self.data_type))
+            })?;
+            offsets.append(offset)
+        }
+
+        let child_data = self.decoder.decode(tape, &child_pos)?;
+        let nulls = nulls.as_mut().map(|x| NullBuffer::new(x.finish()));
+
+        let data = ArrayDataBuilder::new(self.data_type.clone())
+            .len(pos.len())
+            .nulls(nulls)
+            .add_buffer(offsets.finish())
+            .child_data(vec![child_data]);
+
+        // Safety
+        // Validated lengths above
+        Ok(unsafe { data.build_unchecked() })
+    }
+}
diff --git a/arrow-json/src/reader/map_array.rs b/arrow-json/src/reader/map_array.rs
new file mode 100644
index 000000000000..cd1ca5f71fa9
--- /dev/null
+++ b/arrow-json/src/reader/map_array.rs
@@ -0,0 +1,154 @@
+// 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.
+
+use crate::reader::tape::{Tape, TapeElement};
+use crate::reader::{make_decoder, ArrayDecoder};
+use arrow_array::builder::{BooleanBufferBuilder, BufferBuilder};
+use arrow_buffer::buffer::NullBuffer;
+use arrow_buffer::ArrowNativeType;
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType};
+
+pub struct MapArrayDecoder {
+    data_type: DataType,
+    keys: Box<dyn ArrayDecoder>,
+    values: Box<dyn ArrayDecoder>,
+    is_nullable: bool,
+}
+
+impl MapArrayDecoder {
+    pub fn new(
+        data_type: DataType,
+        coerce_primitive: bool,
+        strict_mode: bool,
+        is_nullable: bool,
+    ) -> Result<Self, ArrowError> {
+        let fields = match &data_type {
+            DataType::Map(_, true) => {
+                return Err(ArrowError::NotYetImplemented(
+                    "Decoding MapArray with sorted fields".to_string(),
+                ))
+            }
+            DataType::Map(f, _) => match f.data_type() {
+                DataType::Struct(fields) if fields.len() == 2 => fields,
+                d => {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "MapArray must contain struct with two fields, got {d}"
+                    )))
+                }
+            },
+            _ => unreachable!(),
+        };
+
+        let keys = make_decoder(
+            fields[0].data_type().clone(),
+            coerce_primitive,
+            strict_mode,
+            fields[0].is_nullable(),
+        )?;
+        let values = make_decoder(
+            fields[1].data_type().clone(),
+            coerce_primitive,
+            strict_mode,
+            fields[1].is_nullable(),
+        )?;
+
+        Ok(Self {
+            data_type,
+            keys,
+            values,
+            is_nullable,
+        })
+    }
+}
+
+impl ArrayDecoder for MapArrayDecoder {
+    fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayData, ArrowError> {
+        let s = match &self.data_type {
+            DataType::Map(f, _) => match f.data_type() {
+                s @ DataType::Struct(_) => s,
+                _ => unreachable!(),
+            },
+            _ => unreachable!(),
+        };
+
+        let mut offsets = BufferBuilder::<i32>::new(pos.len() + 1);
+        offsets.append(0);
+
+        let mut key_pos = Vec::with_capacity(pos.len());
+        let mut value_pos = Vec::with_capacity(pos.len());
+
+        let mut nulls = self
+            .is_nullable
+            .then(|| BooleanBufferBuilder::new(pos.len()));
+
+        for p in pos.iter().copied() {
+            let end_idx = match (tape.get(p), nulls.as_mut()) {
+                (TapeElement::StartObject(end_idx), None) => end_idx,
+                (TapeElement::StartObject(end_idx), Some(nulls)) => {
+                    nulls.append(true);
+                    end_idx
+                }
+                (TapeElement::Null, Some(nulls)) => {
+                    nulls.append(false);
+                    p + 1
+                }
+                _ => return Err(tape.error(p, "{")),
+            };
+
+            let mut cur_idx = p + 1;
+            while cur_idx < end_idx {
+                let key = cur_idx;
+                let value = tape.next(key, "map key")?;
+                cur_idx = tape.next(value, "map value")?;
+
+                key_pos.push(key);
+                value_pos.push(value);
+            }
+
+            let offset = i32::from_usize(key_pos.len()).ok_or_else(|| {
+                ArrowError::JsonError(format!("offset overflow decoding {}", self.data_type))
+            })?;
+            offsets.append(offset)
+        }
+
+        assert_eq!(key_pos.len(), value_pos.len());
+
+        let key_data = self.keys.decode(tape, &key_pos)?;
+        let value_data = self.values.decode(tape, &value_pos)?;
+
+        let struct_data = ArrayDataBuilder::new(s.clone())
+            .len(key_pos.len())
+            .child_data(vec![key_data, value_data]);
+
+        // Safety:
+        // Valid by construction
+        let struct_data = unsafe { struct_data.build_unchecked() };
+
+        let nulls = nulls.as_mut().map(|x| NullBuffer::new(x.finish()));
+
+        let builder = ArrayDataBuilder::new(self.data_type.clone())
+            .len(pos.len())
+            .buffers(vec![offsets.finish()])
+            .nulls(nulls)
+            .child_data(vec![struct_data]);
+
+        // Safety:
+        // Valid by construction
+        Ok(unsafe { builder.build_unchecked() })
+    }
+}
diff --git a/arrow-json/src/reader/mod.rs b/arrow-json/src/reader/mod.rs
new file mode 100644
index 000000000000..5afe0dec279a
--- /dev/null
+++ b/arrow-json/src/reader/mod.rs
@@ -0,0 +1,2303 @@
+// 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.
+
+//! JSON reader
+//!
+//! This JSON reader allows JSON records to be read into the Arrow memory
+//! model. Records are loaded in batches and are then converted from the record-oriented
+//! representation to the columnar arrow data model.
+//!
+//! The reader ignores whitespace between JSON values, including `\n` and `\r`, allowing
+//! parsing of sequences of one or more arbitrarily formatted JSON values, including
+//! but not limited to newline-delimited JSON.
+//!
+//! # Basic Usage
+//!
+//! [`Reader`] can be used directly with synchronous data sources, such as [`std::fs::File`]
+//!
+//! ```
+//! # use arrow_schema::*;
+//! # use std::fs::File;
+//! # use std::io::BufReader;
+//! # use std::sync::Arc;
+//!
+//! let schema = Arc::new(Schema::new(vec![
+//!     Field::new("a", DataType::Float64, false),
+//!     Field::new("b", DataType::Float64, false),
+//!     Field::new("c", DataType::Boolean, true),
+//! ]));
+//!
+//! let file = File::open("test/data/basic.json").unwrap();
+//!
+//! let mut json = arrow_json::ReaderBuilder::new(schema).build(BufReader::new(file)).unwrap();
+//! let batch = json.next().unwrap().unwrap();
+//! ```
+//!
+//! # Async Usage
+//!
+//! The lower-level [`Decoder`] can be integrated with various forms of async data streams,
+//! and is designed to be agnostic to the various different kinds of async IO primitives found
+//! within the Rust ecosystem.
+//!
+//! For example, see below for how it can be used with an arbitrary `Stream` of `Bytes`
+//!
+//! ```
+//! # use std::task::{Poll, ready};
+//! # use bytes::{Buf, Bytes};
+//! # use arrow_schema::ArrowError;
+//! # use futures::stream::{Stream, StreamExt};
+//! # use arrow_array::RecordBatch;
+//! # use arrow_json::reader::Decoder;
+//! #
+//! fn decode_stream<S: Stream<Item = Bytes> + Unpin>(
+//!     mut decoder: Decoder,
+//!     mut input: S,
+//! ) -> impl Stream<Item = Result<RecordBatch, ArrowError>> {
+//!     let mut buffered = Bytes::new();
+//!     futures::stream::poll_fn(move |cx| {
+//!         loop {
+//!             if buffered.is_empty() {
+//!                 buffered = match ready!(input.poll_next_unpin(cx)) {
+//!                     Some(b) => b,
+//!                     None => break,
+//!                 };
+//!             }
+//!             let decoded = match decoder.decode(buffered.as_ref()) {
+//!                 Ok(decoded) => decoded,
+//!                 Err(e) => return Poll::Ready(Some(Err(e))),
+//!             };
+//!             let read = buffered.len();
+//!             buffered.advance(decoded);
+//!             if decoded != read {
+//!                 break
+//!             }
+//!         }
+//!
+//!         Poll::Ready(decoder.flush().transpose())
+//!     })
+//! }
+//!
+//! ```
+//!
+//! In a similar vein, it can also be used with tokio-based IO primitives
+//!
+//! ```
+//! # use std::sync::Arc;
+//! # use arrow_schema::{DataType, Field, Schema};
+//! # use std::pin::Pin;
+//! # use std::task::{Poll, ready};
+//! # use futures::{Stream, TryStreamExt};
+//! # use tokio::io::AsyncBufRead;
+//! # use arrow_array::RecordBatch;
+//! # use arrow_json::reader::Decoder;
+//! # use arrow_schema::ArrowError;
+//! fn decode_stream<R: AsyncBufRead + Unpin>(
+//!     mut decoder: Decoder,
+//!     mut reader: R,
+//! ) -> impl Stream<Item = Result<RecordBatch, ArrowError>> {
+//!     futures::stream::poll_fn(move |cx| {
+//!         loop {
+//!             let b = match ready!(Pin::new(&mut reader).poll_fill_buf(cx)) {
+//!                 Ok(b) if b.is_empty() => break,
+//!                 Ok(b) => b,
+//!                 Err(e) => return Poll::Ready(Some(Err(e.into()))),
+//!             };
+//!             let read = b.len();
+//!             let decoded = match decoder.decode(b) {
+//!                 Ok(decoded) => decoded,
+//!                 Err(e) => return Poll::Ready(Some(Err(e))),
+//!             };
+//!             Pin::new(&mut reader).consume(decoded);
+//!             if decoded != read {
+//!                 break;
+//!             }
+//!         }
+//!
+//!         Poll::Ready(decoder.flush().transpose())
+//!     })
+//! }
+//! ```
+//!
+
+use std::io::BufRead;
+use std::sync::Arc;
+
+use chrono::Utc;
+use serde::Serialize;
+
+use arrow_array::timezone::Tz;
+use arrow_array::types::Float32Type;
+use arrow_array::types::*;
+use arrow_array::{downcast_integer, make_array, RecordBatch, RecordBatchReader, StructArray};
+use arrow_data::ArrayData;
+use arrow_schema::{ArrowError, DataType, FieldRef, Schema, SchemaRef, TimeUnit};
+pub use schema::*;
+
+use crate::reader::boolean_array::BooleanArrayDecoder;
+use crate::reader::decimal_array::DecimalArrayDecoder;
+use crate::reader::list_array::ListArrayDecoder;
+use crate::reader::map_array::MapArrayDecoder;
+use crate::reader::null_array::NullArrayDecoder;
+use crate::reader::primitive_array::PrimitiveArrayDecoder;
+use crate::reader::string_array::StringArrayDecoder;
+use crate::reader::struct_array::StructArrayDecoder;
+use crate::reader::tape::{Tape, TapeDecoder};
+use crate::reader::timestamp_array::TimestampArrayDecoder;
+
+mod boolean_array;
+mod decimal_array;
+mod list_array;
+mod map_array;
+mod null_array;
+mod primitive_array;
+mod schema;
+mod serializer;
+mod string_array;
+mod struct_array;
+mod tape;
+mod timestamp_array;
+
+/// A builder for [`Reader`] and [`Decoder`]
+pub struct ReaderBuilder {
+    batch_size: usize,
+    coerce_primitive: bool,
+    strict_mode: bool,
+    is_field: bool,
+
+    schema: SchemaRef,
+}
+
+impl ReaderBuilder {
+    /// Create a new [`ReaderBuilder`] with the provided [`SchemaRef`]
+    ///
+    /// This could be obtained using [`infer_json_schema`] if not known
+    ///
+    /// Any columns not present in `schema` will be ignored, unless `strict_mode` is set to true.
+    /// In this case, an error is returned when a column is missing from `schema`.
+    ///
+    /// [`infer_json_schema`]: crate::reader::infer_json_schema
+    pub fn new(schema: SchemaRef) -> Self {
+        Self {
+            batch_size: 1024,
+            coerce_primitive: false,
+            strict_mode: false,
+            is_field: false,
+            schema,
+        }
+    }
+
+    /// Create a new [`ReaderBuilder`] that will parse JSON values of `field.data_type()`
+    ///
+    /// Unlike [`ReaderBuilder::new`] this does not require the root of the JSON data
+    /// to be an object, i.e. `{..}`, allowing for parsing of any valid JSON value(s)
+    ///
+    /// ```
+    /// # use std::sync::Arc;
+    /// # use arrow_array::cast::AsArray;
+    /// # use arrow_array::types::Int32Type;
+    /// # use arrow_json::ReaderBuilder;
+    /// # use arrow_schema::{DataType, Field};
+    /// // Root of JSON schema is a numeric type
+    /// let data = "1\n2\n3\n";
+    /// let field = Arc::new(Field::new("int", DataType::Int32, true));
+    /// let mut reader = ReaderBuilder::new_with_field(field.clone()).build(data.as_bytes()).unwrap();
+    /// let b = reader.next().unwrap().unwrap();
+    /// let values = b.column(0).as_primitive::<Int32Type>().values();
+    /// assert_eq!(values, &[1, 2, 3]);
+    ///
+    /// // Root of JSON schema is a list type
+    /// let data = "[1, 2, 3, 4, 5, 6, 7]\n[1, 2, 3]";
+    /// let field = Field::new_list("int", field.clone(), true);
+    /// let mut reader = ReaderBuilder::new_with_field(field).build(data.as_bytes()).unwrap();
+    /// let b = reader.next().unwrap().unwrap();
+    /// let list = b.column(0).as_list::<i32>();
+    ///
+    /// assert_eq!(list.offsets().as_ref(), &[0, 7, 10]);
+    /// let list_values = list.values().as_primitive::<Int32Type>();
+    /// assert_eq!(list_values.values(), &[1, 2, 3, 4, 5, 6, 7, 1, 2, 3]);
+    /// ```
+    pub fn new_with_field(field: impl Into<FieldRef>) -> Self {
+        Self {
+            batch_size: 1024,
+            coerce_primitive: false,
+            strict_mode: false,
+            is_field: true,
+            schema: Arc::new(Schema::new([field.into()])),
+        }
+    }
+
+    /// Sets the batch size in rows to read
+    pub fn with_batch_size(self, batch_size: usize) -> Self {
+        Self { batch_size, ..self }
+    }
+
+    /// Sets if the decoder should coerce primitive values (bool and number) into string
+    /// when the Schema's column is Utf8 or LargeUtf8.
+    #[deprecated(note = "Use with_coerce_primitive")]
+    pub fn coerce_primitive(self, coerce_primitive: bool) -> Self {
+        self.with_coerce_primitive(coerce_primitive)
+    }
+
+    /// Sets if the decoder should coerce primitive values (bool and number) into string
+    /// when the Schema's column is Utf8 or LargeUtf8.
+    pub fn with_coerce_primitive(self, coerce_primitive: bool) -> Self {
+        Self {
+            coerce_primitive,
+            ..self
+        }
+    }
+
+    /// Sets if the decoder should return an error if it encounters a column not present
+    /// in `schema`
+    pub fn with_strict_mode(self, strict_mode: bool) -> Self {
+        Self {
+            strict_mode,
+            ..self
+        }
+    }
+
+    /// Create a [`Reader`] with the provided [`BufRead`]
+    pub fn build<R: BufRead>(self, reader: R) -> Result<Reader<R>, ArrowError> {
+        Ok(Reader {
+            reader,
+            decoder: self.build_decoder()?,
+        })
+    }
+
+    /// Create a [`Decoder`]
+    pub fn build_decoder(self) -> Result<Decoder, ArrowError> {
+        let (data_type, nullable) = match self.is_field {
+            false => (DataType::Struct(self.schema.fields.clone()), false),
+            true => {
+                let field = &self.schema.fields[0];
+                (field.data_type().clone(), field.is_nullable())
+            }
+        };
+
+        let decoder = make_decoder(data_type, self.coerce_primitive, self.strict_mode, nullable)?;
+
+        let num_fields = self.schema.all_fields().len();
+
+        Ok(Decoder {
+            decoder,
+            is_field: self.is_field,
+            tape_decoder: TapeDecoder::new(self.batch_size, num_fields),
+            batch_size: self.batch_size,
+            schema: self.schema,
+        })
+    }
+}
+
+/// Reads JSON data with a known schema directly into arrow [`RecordBatch`]
+///
+/// Lines consisting solely of ASCII whitespace are ignored
+pub struct Reader<R> {
+    reader: R,
+    decoder: Decoder,
+}
+
+impl<R> std::fmt::Debug for Reader<R> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Reader")
+            .field("decoder", &self.decoder)
+            .finish()
+    }
+}
+
+impl<R: BufRead> Reader<R> {
+    /// Reads the next [`RecordBatch`] returning `Ok(None)` if EOF
+    fn read(&mut self) -> Result<Option<RecordBatch>, ArrowError> {
+        loop {
+            let buf = self.reader.fill_buf()?;
+            if buf.is_empty() {
+                break;
+            }
+            let read = buf.len();
+
+            let decoded = self.decoder.decode(buf)?;
+            self.reader.consume(decoded);
+            if decoded != read {
+                break;
+            }
+        }
+        self.decoder.flush()
+    }
+}
+
+impl<R: BufRead> Iterator for Reader<R> {
+    type Item = Result<RecordBatch, ArrowError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.read().transpose()
+    }
+}
+
+impl<R: BufRead> RecordBatchReader for Reader<R> {
+    fn schema(&self) -> SchemaRef {
+        self.decoder.schema.clone()
+    }
+}
+
+/// A low-level interface for reading JSON data from a byte stream
+///
+/// See [`Reader`] for a higher-level interface for interface with [`BufRead`]
+///
+/// The push-based interface facilitates integration with sources that yield arbitrarily
+/// delimited bytes ranges, such as [`BufRead`], or a chunked byte stream received from
+/// object storage
+///
+/// ```
+/// # use std::io::BufRead;
+/// # use arrow_array::RecordBatch;
+/// # use arrow_json::reader::{Decoder, ReaderBuilder};
+/// # use arrow_schema::{ArrowError, SchemaRef};
+/// #
+/// fn read_from_json<R: BufRead>(
+///     mut reader: R,
+///     schema: SchemaRef,
+/// ) -> Result<impl Iterator<Item = Result<RecordBatch, ArrowError>>, ArrowError> {
+///     let mut decoder = ReaderBuilder::new(schema).build_decoder()?;
+///     let mut next = move || {
+///         loop {
+///             // Decoder is agnostic that buf doesn't contain whole records
+///             let buf = reader.fill_buf()?;
+///             if buf.is_empty() {
+///                 break; // Input exhausted
+///             }
+///             let read = buf.len();
+///             let decoded = decoder.decode(buf)?;
+///
+///             // Consume the number of bytes read
+///             reader.consume(decoded);
+///             if decoded != read {
+///                 break; // Read batch size
+///             }
+///         }
+///         decoder.flush()
+///     };
+///     Ok(std::iter::from_fn(move || next().transpose()))
+/// }
+/// ```
+pub struct Decoder {
+    tape_decoder: TapeDecoder,
+    decoder: Box<dyn ArrayDecoder>,
+    batch_size: usize,
+    is_field: bool,
+    schema: SchemaRef,
+}
+
+impl std::fmt::Debug for Decoder {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Decoder")
+            .field("schema", &self.schema)
+            .field("batch_size", &self.batch_size)
+            .finish()
+    }
+}
+
+impl Decoder {
+    /// Read JSON objects from `buf`, returning the number of bytes read
+    ///
+    /// This method returns once `batch_size` objects have been parsed since the
+    /// last call to [`Self::flush`], or `buf` is exhausted. Any remaining bytes
+    /// should be included in the next call to [`Self::decode`]
+    ///
+    /// There is no requirement that `buf` contains a whole number of records, facilitating
+    /// integration with arbitrary byte streams, such as that yielded by [`BufRead`]
+    pub fn decode(&mut self, buf: &[u8]) -> Result<usize, ArrowError> {
+        self.tape_decoder.decode(buf)
+    }
+
+    /// Serialize `rows` to this [`Decoder`]
+    ///
+    /// This provides a simple way to convert [serde]-compatible datastructures into arrow
+    /// [`RecordBatch`].
+    ///
+    /// Custom conversion logic as described in [arrow_array::builder] will likely outperform this,
+    /// especially where the schema is known at compile-time, however, this provides a mechanism
+    /// to get something up and running quickly
+    ///
+    /// It can be used with [`serde_json::Value`]
+    ///
+    /// ```
+    /// # use std::sync::Arc;
+    /// # use serde_json::{Value, json};
+    /// # use arrow_array::cast::AsArray;
+    /// # use arrow_array::types::Float32Type;
+    /// # use arrow_json::ReaderBuilder;
+    /// # use arrow_schema::{DataType, Field, Schema};
+    /// let json = vec![json!({"float": 2.3}), json!({"float": 5.7})];
+    ///
+    /// let schema = Schema::new(vec![Field::new("float", DataType::Float32, true)]);
+    /// let mut decoder = ReaderBuilder::new(Arc::new(schema)).build_decoder().unwrap();
+    ///
+    /// decoder.serialize(&json).unwrap();
+    /// let batch = decoder.flush().unwrap().unwrap();
+    /// assert_eq!(batch.num_rows(), 2);
+    /// assert_eq!(batch.num_columns(), 1);
+    /// let values = batch.column(0).as_primitive::<Float32Type>().values();
+    /// assert_eq!(values, &[2.3, 5.7])
+    /// ```
+    ///
+    /// Or with arbitrary [`Serialize`] types
+    ///
+    /// ```
+    /// # use std::sync::Arc;
+    /// # use arrow_json::ReaderBuilder;
+    /// # use arrow_schema::{DataType, Field, Schema};
+    /// # use serde::Serialize;
+    /// # use arrow_array::cast::AsArray;
+    /// # use arrow_array::types::{Float32Type, Int32Type};
+    /// #
+    /// #[derive(Serialize)]
+    /// struct MyStruct {
+    ///     int32: i32,
+    ///     float: f32,
+    /// }
+    ///
+    /// let schema = Schema::new(vec![
+    ///     Field::new("int32", DataType::Int32, false),
+    ///     Field::new("float", DataType::Float32, false),
+    /// ]);
+    ///
+    /// let rows = vec![
+    ///     MyStruct{ int32: 0, float: 3. },
+    ///     MyStruct{ int32: 4, float: 67.53 },
+    /// ];
+    ///
+    /// let mut decoder = ReaderBuilder::new(Arc::new(schema)).build_decoder().unwrap();
+    /// decoder.serialize(&rows).unwrap();
+    ///
+    /// let batch = decoder.flush().unwrap().unwrap();
+    ///
+    /// // Expect batch containing two columns
+    /// let int32 = batch.column(0).as_primitive::<Int32Type>();
+    /// assert_eq!(int32.values(), &[0, 4]);
+    ///
+    /// let float = batch.column(1).as_primitive::<Float32Type>();
+    /// assert_eq!(float.values(), &[3., 67.53]);
+    /// ```
+    ///
+    /// Or even complex nested types
+    ///
+    /// ```
+    /// # use std::collections::BTreeMap;
+    /// # use std::sync::Arc;
+    /// # use arrow_array::StructArray;
+    /// # use arrow_cast::display::{ArrayFormatter, FormatOptions};
+    /// # use arrow_json::ReaderBuilder;
+    /// # use arrow_schema::{DataType, Field, Fields, Schema};
+    /// # use serde::Serialize;
+    /// #
+    /// #[derive(Serialize)]
+    /// struct MyStruct {
+    ///     int32: i32,
+    ///     list: Vec<f64>,
+    ///     nested: Vec<Option<Nested>>,
+    /// }
+    ///
+    /// impl MyStruct {
+    ///     /// Returns the [`Fields`] for [`MyStruct`]
+    ///     fn fields() -> Fields {
+    ///         let nested = DataType::Struct(Nested::fields());
+    ///         Fields::from([
+    ///             Arc::new(Field::new("int32", DataType::Int32, false)),
+    ///             Arc::new(Field::new_list(
+    ///                 "list",
+    ///                 Field::new("element", DataType::Float64, false),
+    ///                 false,
+    ///             )),
+    ///             Arc::new(Field::new_list(
+    ///                 "nested",
+    ///                 Field::new("element", nested, true),
+    ///                 true,
+    ///             )),
+    ///         ])
+    ///     }
+    /// }
+    ///
+    /// #[derive(Serialize)]
+    /// struct Nested {
+    ///     map: BTreeMap<String, Vec<String>>
+    /// }
+    ///
+    /// impl Nested {
+    ///     /// Returns the [`Fields`] for [`Nested`]
+    ///     fn fields() -> Fields {
+    ///         let element = Field::new("element", DataType::Utf8, false);
+    ///         Fields::from([
+    ///             Arc::new(Field::new_map(
+    ///                 "map",
+    ///                 "entries",
+    ///                 Field::new("key", DataType::Utf8, false),
+    ///                 Field::new_list("value", element, false),
+    ///                 false, // sorted
+    ///                 false, // nullable
+    ///             ))
+    ///         ])
+    ///     }
+    /// }
+    ///
+    /// let data = vec![
+    ///     MyStruct {
+    ///         int32: 34,
+    ///         list: vec![1., 2., 34.],
+    ///         nested: vec![
+    ///             None,
+    ///             Some(Nested {
+    ///                 map: vec![
+    ///                     ("key1".to_string(), vec!["foo".to_string(), "bar".to_string()]),
+    ///                     ("key2".to_string(), vec!["baz".to_string()])
+    ///                 ].into_iter().collect()
+    ///             })
+    ///         ]
+    ///     },
+    ///     MyStruct {
+    ///         int32: 56,
+    ///         list: vec![],
+    ///         nested: vec![]
+    ///     },
+    ///     MyStruct {
+    ///         int32: 24,
+    ///         list: vec![-1., 245.],
+    ///         nested: vec![None]
+    ///     }
+    /// ];
+    ///
+    /// let schema = Schema::new(MyStruct::fields());
+    /// let mut decoder = ReaderBuilder::new(Arc::new(schema)).build_decoder().unwrap();
+    /// decoder.serialize(&data).unwrap();
+    /// let batch = decoder.flush().unwrap().unwrap();
+    /// assert_eq!(batch.num_rows(), 3);
+    /// assert_eq!(batch.num_columns(), 3);
+    ///
+    /// // Convert to StructArray to format
+    /// let s = StructArray::from(batch);
+    /// let options = FormatOptions::default().with_null("null");
+    /// let formatter = ArrayFormatter::try_new(&s, &options).unwrap();
+    ///
+    /// assert_eq!(&formatter.value(0).to_string(), "{int32: 34, list: [1.0, 2.0, 34.0], nested: [null, {map: {key1: [foo, bar], key2: [baz]}}]}");
+    /// assert_eq!(&formatter.value(1).to_string(), "{int32: 56, list: [], nested: []}");
+    /// assert_eq!(&formatter.value(2).to_string(), "{int32: 24, list: [-1.0, 245.0], nested: [null]}");
+    /// ```
+    ///
+    /// Note: this ignores any batch size setting, and always decodes all rows
+    pub fn serialize<S: Serialize>(&mut self, rows: &[S]) -> Result<(), ArrowError> {
+        self.tape_decoder.serialize(rows)
+    }
+
+    /// Flushes the currently buffered data to a [`RecordBatch`]
+    ///
+    /// Returns `Ok(None)` if no buffered data
+    ///
+    /// Note: if called part way through decoding a record, this will return an error
+    pub fn flush(&mut self) -> Result<Option<RecordBatch>, ArrowError> {
+        let tape = self.tape_decoder.finish()?;
+
+        if tape.num_rows() == 0 {
+            return Ok(None);
+        }
+
+        // First offset is null sentinel
+        let mut next_object = 1;
+        let pos: Vec<_> = (0..tape.num_rows())
+            .map(|_| {
+                let next = tape.next(next_object, "row").unwrap();
+                std::mem::replace(&mut next_object, next)
+            })
+            .collect();
+
+        let decoded = self.decoder.decode(&tape, &pos)?;
+        self.tape_decoder.clear();
+
+        let batch = match self.is_field {
+            true => RecordBatch::try_new(self.schema.clone(), vec![make_array(decoded)])?,
+            false => {
+                RecordBatch::from(StructArray::from(decoded)).with_schema(self.schema.clone())?
+            }
+        };
+
+        Ok(Some(batch))
+    }
+}
+
+trait ArrayDecoder: Send {
+    /// Decode elements from `tape` starting at the indexes contained in `pos`
+    fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayData, ArrowError>;
+}
+
+macro_rules! primitive_decoder {
+    ($t:ty, $data_type:expr) => {
+        Ok(Box::new(PrimitiveArrayDecoder::<$t>::new($data_type)))
+    };
+}
+
+fn make_decoder(
+    data_type: DataType,
+    coerce_primitive: bool,
+    strict_mode: bool,
+    is_nullable: bool,
+) -> Result<Box<dyn ArrayDecoder>, ArrowError> {
+    downcast_integer! {
+        data_type => (primitive_decoder, data_type),
+        DataType::Null => Ok(Box::<NullArrayDecoder>::default()),
+        DataType::Float16 => primitive_decoder!(Float16Type, data_type),
+        DataType::Float32 => primitive_decoder!(Float32Type, data_type),
+        DataType::Float64 => primitive_decoder!(Float64Type, data_type),
+        DataType::Timestamp(TimeUnit::Second, None) => {
+            Ok(Box::new(TimestampArrayDecoder::<TimestampSecondType, _>::new(data_type, Utc)))
+        },
+        DataType::Timestamp(TimeUnit::Millisecond, None) => {
+            Ok(Box::new(TimestampArrayDecoder::<TimestampMillisecondType, _>::new(data_type, Utc)))
+        },
+        DataType::Timestamp(TimeUnit::Microsecond, None) => {
+            Ok(Box::new(TimestampArrayDecoder::<TimestampMicrosecondType, _>::new(data_type, Utc)))
+        },
+        DataType::Timestamp(TimeUnit::Nanosecond, None) => {
+            Ok(Box::new(TimestampArrayDecoder::<TimestampNanosecondType, _>::new(data_type, Utc)))
+        },
+        DataType::Timestamp(TimeUnit::Second, Some(ref tz)) => {
+            let tz: Tz = tz.parse()?;
+            Ok(Box::new(TimestampArrayDecoder::<TimestampSecondType, _>::new(data_type, tz)))
+        },
+        DataType::Timestamp(TimeUnit::Millisecond, Some(ref tz)) => {
+            let tz: Tz = tz.parse()?;
+            Ok(Box::new(TimestampArrayDecoder::<TimestampMillisecondType, _>::new(data_type, tz)))
+        },
+        DataType::Timestamp(TimeUnit::Microsecond, Some(ref tz)) => {
+            let tz: Tz = tz.parse()?;
+            Ok(Box::new(TimestampArrayDecoder::<TimestampMicrosecondType, _>::new(data_type, tz)))
+        },
+        DataType::Timestamp(TimeUnit::Nanosecond, Some(ref tz)) => {
+            let tz: Tz = tz.parse()?;
+            Ok(Box::new(TimestampArrayDecoder::<TimestampNanosecondType, _>::new(data_type, tz)))
+        },
+        DataType::Date32 => primitive_decoder!(Date32Type, data_type),
+        DataType::Date64 => primitive_decoder!(Date64Type, data_type),
+        DataType::Time32(TimeUnit::Second) => primitive_decoder!(Time32SecondType, data_type),
+        DataType::Time32(TimeUnit::Millisecond) => primitive_decoder!(Time32MillisecondType, data_type),
+        DataType::Time64(TimeUnit::Microsecond) => primitive_decoder!(Time64MicrosecondType, data_type),
+        DataType::Time64(TimeUnit::Nanosecond) => primitive_decoder!(Time64NanosecondType, data_type),
+        DataType::Decimal128(p, s) => Ok(Box::new(DecimalArrayDecoder::<Decimal128Type>::new(p, s))),
+        DataType::Decimal256(p, s) => Ok(Box::new(DecimalArrayDecoder::<Decimal256Type>::new(p, s))),
+        DataType::Boolean => Ok(Box::<BooleanArrayDecoder>::default()),
+        DataType::Utf8 => Ok(Box::new(StringArrayDecoder::<i32>::new(coerce_primitive))),
+        DataType::LargeUtf8 => Ok(Box::new(StringArrayDecoder::<i64>::new(coerce_primitive))),
+        DataType::List(_) => Ok(Box::new(ListArrayDecoder::<i32>::new(data_type, coerce_primitive, strict_mode, is_nullable)?)),
+        DataType::LargeList(_) => Ok(Box::new(ListArrayDecoder::<i64>::new(data_type, coerce_primitive, strict_mode, is_nullable)?)),
+        DataType::Struct(_) => Ok(Box::new(StructArrayDecoder::new(data_type, coerce_primitive, strict_mode, is_nullable)?)),
+        DataType::Binary | DataType::LargeBinary | DataType::FixedSizeBinary(_) => {
+            Err(ArrowError::JsonError(format!("{data_type} is not supported by JSON")))
+        }
+        DataType::Map(_, _) => Ok(Box::new(MapArrayDecoder::new(data_type, coerce_primitive, strict_mode, is_nullable)?)),
+        d => Err(ArrowError::NotYetImplemented(format!("Support for {d} in JSON reader")))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use serde_json::json;
+    use std::fs::File;
+    use std::io::{BufReader, Cursor, Seek};
+    use std::sync::Arc;
+
+    use arrow_array::cast::AsArray;
+    use arrow_array::types::Int32Type;
+    use arrow_array::{
+        make_array, Array, BooleanArray, Float64Array, ListArray, StringArray, StructArray,
+    };
+    use arrow_buffer::{ArrowNativeType, Buffer};
+    use arrow_cast::display::{ArrayFormatter, FormatOptions};
+    use arrow_data::ArrayDataBuilder;
+    use arrow_schema::{DataType, Field, FieldRef, Schema};
+
+    use crate::reader::infer_json_schema;
+    use crate::ReaderBuilder;
+
+    use super::*;
+
+    fn do_read(
+        buf: &str,
+        batch_size: usize,
+        coerce_primitive: bool,
+        strict_mode: bool,
+        schema: SchemaRef,
+    ) -> Vec<RecordBatch> {
+        let mut unbuffered = vec![];
+
+        // Test with different batch sizes to test for boundary conditions
+        for batch_size in [1, 3, 100, batch_size] {
+            unbuffered = ReaderBuilder::new(schema.clone())
+                .with_batch_size(batch_size)
+                .with_coerce_primitive(coerce_primitive)
+                .build(Cursor::new(buf.as_bytes()))
+                .unwrap()
+                .collect::<Result<Vec<_>, _>>()
+                .unwrap();
+
+            for b in unbuffered.iter().take(unbuffered.len() - 1) {
+                assert_eq!(b.num_rows(), batch_size)
+            }
+
+            // Test with different buffer sizes to test for boundary conditions
+            for b in [1, 3, 5] {
+                let buffered = ReaderBuilder::new(schema.clone())
+                    .with_batch_size(batch_size)
+                    .with_coerce_primitive(coerce_primitive)
+                    .with_strict_mode(strict_mode)
+                    .build(BufReader::with_capacity(b, Cursor::new(buf.as_bytes())))
+                    .unwrap()
+                    .collect::<Result<Vec<_>, _>>()
+                    .unwrap();
+                assert_eq!(unbuffered, buffered);
+            }
+        }
+
+        unbuffered
+    }
+
+    #[test]
+    fn test_basic() {
+        let buf = r#"
+        {"a": 1, "b": 2, "c": true, "d": 1}
+        {"a": 2E0, "b": 4, "c": false, "d": 2, "e": 254}
+
+        {"b": 6, "a": 2.0, "d": 45}
+        {"b": "5", "a": 2}
+        {"b": 4e0}
+        {"b": 7, "a": null}
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Int64, true),
+            Field::new("b", DataType::Int32, true),
+            Field::new("c", DataType::Boolean, true),
+            Field::new("d", DataType::Date32, true),
+            Field::new("e", DataType::Date64, true),
+        ]));
+
+        let batches = do_read(buf, 1024, false, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let col1 = batches[0].column(0).as_primitive::<Int64Type>();
+        assert_eq!(col1.null_count(), 2);
+        assert_eq!(col1.values(), &[1, 2, 2, 2, 0, 0]);
+        assert!(col1.is_null(4));
+        assert!(col1.is_null(5));
+
+        let col2 = batches[0].column(1).as_primitive::<Int32Type>();
+        assert_eq!(col2.null_count(), 0);
+        assert_eq!(col2.values(), &[2, 4, 6, 5, 4, 7]);
+
+        let col3 = batches[0].column(2).as_boolean();
+        assert_eq!(col3.null_count(), 4);
+        assert!(col3.value(0));
+        assert!(!col3.is_null(0));
+        assert!(!col3.value(1));
+        assert!(!col3.is_null(1));
+
+        let col4 = batches[0].column(3).as_primitive::<Date32Type>();
+        assert_eq!(col4.null_count(), 3);
+        assert!(col4.is_null(3));
+        assert_eq!(col4.values(), &[1, 2, 45, 0, 0, 0]);
+
+        let col5 = batches[0].column(4).as_primitive::<Date64Type>();
+        assert_eq!(col5.null_count(), 5);
+        assert!(col5.is_null(0));
+        assert!(col5.is_null(2));
+        assert!(col5.is_null(3));
+        assert_eq!(col5.values(), &[0, 254, 0, 0, 0, 0]);
+    }
+
+    #[test]
+    fn test_string() {
+        let buf = r#"
+        {"a": "1", "b": "2"}
+        {"a": "hello", "b": "shoo"}
+        {"b": "\t😁foo", "a": "\nfoobar\ud83d\ude00\u0061\u0073\u0066\u0067\u00FF"}
+
+        {"b": null}
+        {"b": "", "a": null}
+
+        "#;
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Utf8, true),
+            Field::new("b", DataType::LargeUtf8, true),
+        ]));
+
+        let batches = do_read(buf, 1024, false, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let col1 = batches[0].column(0).as_string::<i32>();
+        assert_eq!(col1.null_count(), 2);
+        assert_eq!(col1.value(0), "1");
+        assert_eq!(col1.value(1), "hello");
+        assert_eq!(col1.value(2), "\nfoobar😀asfgÿ");
+        assert!(col1.is_null(3));
+        assert!(col1.is_null(4));
+
+        let col2 = batches[0].column(1).as_string::<i64>();
+        assert_eq!(col2.null_count(), 1);
+        assert_eq!(col2.value(0), "2");
+        assert_eq!(col2.value(1), "shoo");
+        assert_eq!(col2.value(2), "\t😁foo");
+        assert!(col2.is_null(3));
+        assert_eq!(col2.value(4), "");
+    }
+
+    #[test]
+    fn test_complex() {
+        let buf = r#"
+           {"list": [], "nested": {"a": 1, "b": 2}, "nested_list": {"list2": [{"c": 3}, {"c": 4}]}}
+           {"list": [5, 6], "nested": {"a": 7}, "nested_list": {"list2": []}}
+           {"list": null, "nested": {"a": null}}
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new_list("list", Field::new("element", DataType::Int32, false), true),
+            Field::new_struct(
+                "nested",
+                vec![
+                    Field::new("a", DataType::Int32, true),
+                    Field::new("b", DataType::Int32, true),
+                ],
+                true,
+            ),
+            Field::new_struct(
+                "nested_list",
+                vec![Field::new_list(
+                    "list2",
+                    Field::new_struct(
+                        "element",
+                        vec![Field::new("c", DataType::Int32, false)],
+                        false,
+                    ),
+                    true,
+                )],
+                true,
+            ),
+        ]));
+
+        let batches = do_read(buf, 1024, false, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let list = batches[0].column(0).as_list::<i32>();
+        assert_eq!(list.len(), 3);
+        assert_eq!(list.value_offsets(), &[0, 0, 2, 2]);
+        assert_eq!(list.null_count(), 1);
+        assert!(list.is_null(2));
+        let list_values = list.values().as_primitive::<Int32Type>();
+        assert_eq!(list_values.values(), &[5, 6]);
+
+        let nested = batches[0].column(1).as_struct();
+        let a = nested.column(0).as_primitive::<Int32Type>();
+        assert_eq!(list.null_count(), 1);
+        assert_eq!(a.values(), &[1, 7, 0]);
+        assert!(list.is_null(2));
+
+        let b = nested.column(1).as_primitive::<Int32Type>();
+        assert_eq!(b.null_count(), 2);
+        assert_eq!(b.len(), 3);
+        assert_eq!(b.value(0), 2);
+        assert!(b.is_null(1));
+        assert!(b.is_null(2));
+
+        let nested_list = batches[0].column(2).as_struct();
+        assert_eq!(nested_list.len(), 3);
+        assert_eq!(nested_list.null_count(), 1);
+        assert!(nested_list.is_null(2));
+
+        let list2 = nested_list.column(0).as_list::<i32>();
+        assert_eq!(list2.len(), 3);
+        assert_eq!(list2.null_count(), 1);
+        assert_eq!(list2.value_offsets(), &[0, 2, 2, 2]);
+        assert!(list2.is_null(2));
+
+        let list2_values = list2.values().as_struct();
+
+        let c = list2_values.column(0).as_primitive::<Int32Type>();
+        assert_eq!(c.values(), &[3, 4]);
+    }
+
+    #[test]
+    fn test_projection() {
+        let buf = r#"
+           {"list": [], "nested": {"a": 1, "b": 2}, "nested_list": {"list2": [{"c": 3, "d": 5}, {"c": 4}]}}
+           {"list": [5, 6], "nested": {"a": 7}, "nested_list": {"list2": []}}
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new_struct(
+                "nested",
+                vec![Field::new("a", DataType::Int32, false)],
+                true,
+            ),
+            Field::new_struct(
+                "nested_list",
+                vec![Field::new_list(
+                    "list2",
+                    Field::new_struct(
+                        "element",
+                        vec![Field::new("d", DataType::Int32, true)],
+                        false,
+                    ),
+                    true,
+                )],
+                true,
+            ),
+        ]));
+
+        let batches = do_read(buf, 1024, false, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let nested = batches[0].column(0).as_struct();
+        assert_eq!(nested.num_columns(), 1);
+        let a = nested.column(0).as_primitive::<Int32Type>();
+        assert_eq!(a.null_count(), 0);
+        assert_eq!(a.values(), &[1, 7]);
+
+        let nested_list = batches[0].column(1).as_struct();
+        assert_eq!(nested_list.num_columns(), 1);
+        assert_eq!(nested_list.null_count(), 0);
+
+        let list2 = nested_list.column(0).as_list::<i32>();
+        assert_eq!(list2.value_offsets(), &[0, 2, 2]);
+        assert_eq!(list2.null_count(), 0);
+
+        let child = list2.values().as_struct();
+        assert_eq!(child.num_columns(), 1);
+        assert_eq!(child.len(), 2);
+        assert_eq!(child.null_count(), 0);
+
+        let c = child.column(0).as_primitive::<Int32Type>();
+        assert_eq!(c.values(), &[5, 0]);
+        assert_eq!(c.null_count(), 1);
+        assert!(c.is_null(1));
+    }
+
+    #[test]
+    fn test_map() {
+        let buf = r#"
+           {"map": {"a": ["foo", null]}}
+           {"map": {"a": [null], "b": []}}
+           {"map": {"c": null, "a": ["baz"]}}
+        "#;
+        let map = Field::new_map(
+            "map",
+            "entries",
+            Field::new("key", DataType::Utf8, false),
+            Field::new_list("value", Field::new("element", DataType::Utf8, true), true),
+            false,
+            true,
+        );
+
+        let schema = Arc::new(Schema::new(vec![map]));
+
+        let batches = do_read(buf, 1024, false, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let map = batches[0].column(0).as_map();
+        let map_keys = map.keys().as_string::<i32>();
+        let map_values = map.values().as_list::<i32>();
+        assert_eq!(map.value_offsets(), &[0, 1, 3, 5]);
+
+        let k: Vec<_> = map_keys.iter().map(|x| x.unwrap()).collect();
+        assert_eq!(&k, &["a", "a", "b", "c", "a"]);
+
+        let list_values = map_values.values().as_string::<i32>();
+        let lv: Vec<_> = list_values.iter().collect();
+        assert_eq!(&lv, &[Some("foo"), None, None, Some("baz")]);
+        assert_eq!(map_values.value_offsets(), &[0, 2, 3, 3, 3, 4]);
+        assert_eq!(map_values.null_count(), 1);
+        assert!(map_values.is_null(3));
+
+        let options = FormatOptions::default().with_null("null");
+        let formatter = ArrayFormatter::try_new(map, &options).unwrap();
+        assert_eq!(formatter.value(0).to_string(), "{a: [foo, null]}");
+        assert_eq!(formatter.value(1).to_string(), "{a: [null], b: []}");
+        assert_eq!(formatter.value(2).to_string(), "{c: null, a: [baz]}");
+    }
+
+    #[test]
+    fn test_not_coercing_primitive_into_string_without_flag() {
+        let schema = Arc::new(Schema::new(vec![Field::new("a", DataType::Utf8, true)]));
+
+        let buf = r#"{"a": 1}"#;
+        let err = ReaderBuilder::new(schema.clone())
+            .with_batch_size(1024)
+            .build(Cursor::new(buf.as_bytes()))
+            .unwrap()
+            .read()
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Json error: whilst decoding field 'a': expected string got 1"
+        );
+
+        let buf = r#"{"a": true}"#;
+        let err = ReaderBuilder::new(schema)
+            .with_batch_size(1024)
+            .build(Cursor::new(buf.as_bytes()))
+            .unwrap()
+            .read()
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Json error: whilst decoding field 'a': expected string got true"
+        );
+    }
+
+    #[test]
+    fn test_coercing_primitive_into_string() {
+        let buf = r#"
+        {"a": 1, "b": 2, "c": true}
+        {"a": 2E0, "b": 4, "c": false}
+
+        {"b": 6, "a": 2.0}
+        {"b": "5", "a": 2}
+        {"b": 4e0}
+        {"b": 7, "a": null}
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Utf8, true),
+            Field::new("b", DataType::Utf8, true),
+            Field::new("c", DataType::Utf8, true),
+        ]));
+
+        let batches = do_read(buf, 1024, true, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let col1 = batches[0].column(0).as_string::<i32>();
+        assert_eq!(col1.null_count(), 2);
+        assert_eq!(col1.value(0), "1");
+        assert_eq!(col1.value(1), "2E0");
+        assert_eq!(col1.value(2), "2.0");
+        assert_eq!(col1.value(3), "2");
+        assert!(col1.is_null(4));
+        assert!(col1.is_null(5));
+
+        let col2 = batches[0].column(1).as_string::<i32>();
+        assert_eq!(col2.null_count(), 0);
+        assert_eq!(col2.value(0), "2");
+        assert_eq!(col2.value(1), "4");
+        assert_eq!(col2.value(2), "6");
+        assert_eq!(col2.value(3), "5");
+        assert_eq!(col2.value(4), "4e0");
+        assert_eq!(col2.value(5), "7");
+
+        let col3 = batches[0].column(2).as_string::<i32>();
+        assert_eq!(col3.null_count(), 4);
+        assert_eq!(col3.value(0), "true");
+        assert_eq!(col3.value(1), "false");
+        assert!(col3.is_null(2));
+        assert!(col3.is_null(3));
+        assert!(col3.is_null(4));
+        assert!(col3.is_null(5));
+    }
+
+    fn test_decimal<T: DecimalType>(data_type: DataType) {
+        let buf = r#"
+        {"a": 1, "b": 2, "c": 38.30}
+        {"a": 2, "b": 4, "c": 123.456}
+
+        {"b": 1337, "a": "2.0452"}
+        {"b": "5", "a": "11034.2"}
+        {"b": 40}
+        {"b": 1234, "a": null}
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", data_type.clone(), true),
+            Field::new("b", data_type.clone(), true),
+            Field::new("c", data_type, true),
+        ]));
+
+        let batches = do_read(buf, 1024, true, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let col1 = batches[0].column(0).as_primitive::<T>();
+        assert_eq!(col1.null_count(), 2);
+        assert!(col1.is_null(4));
+        assert!(col1.is_null(5));
+        assert_eq!(
+            col1.values(),
+            &[100, 200, 204, 1103420, 0, 0].map(T::Native::usize_as)
+        );
+
+        let col2 = batches[0].column(1).as_primitive::<T>();
+        assert_eq!(col2.null_count(), 0);
+        assert_eq!(
+            col2.values(),
+            &[200, 400, 133700, 500, 4000, 123400].map(T::Native::usize_as)
+        );
+
+        let col3 = batches[0].column(2).as_primitive::<T>();
+        assert_eq!(col3.null_count(), 4);
+        assert!(!col3.is_null(0));
+        assert!(!col3.is_null(1));
+        assert!(col3.is_null(2));
+        assert!(col3.is_null(3));
+        assert!(col3.is_null(4));
+        assert!(col3.is_null(5));
+        assert_eq!(
+            col3.values(),
+            &[3830, 12345, 0, 0, 0, 0].map(T::Native::usize_as)
+        );
+    }
+
+    #[test]
+    fn test_decimals() {
+        test_decimal::<Decimal128Type>(DataType::Decimal128(10, 2));
+        test_decimal::<Decimal256Type>(DataType::Decimal256(10, 2));
+    }
+
+    fn test_timestamp<T: ArrowTimestampType>() {
+        let buf = r#"
+        {"a": 1, "b": "2020-09-08T13:42:29.190855+00:00", "c": 38.30, "d": "1997-01-31T09:26:56.123"}
+        {"a": 2, "b": "2020-09-08T13:42:29.190855Z", "c": 123.456, "d": 123.456}
+
+        {"b": 1337, "b": "2020-09-08T13:42:29Z", "c": "1997-01-31T09:26:56.123", "d": "1997-01-31T09:26:56.123Z"}
+        {"b": 40, "c": "2020-09-08T13:42:29.190855+00:00", "d": "1997-01-31 09:26:56.123-05:00"}
+        {"b": 1234, "a": null, "c": "1997-01-31 09:26:56.123Z", "d": "1997-01-31 092656"}
+        {"c": "1997-01-31T14:26:56.123-05:00", "d": "1997-01-31"}
+        "#;
+
+        let with_timezone = DataType::Timestamp(T::UNIT, Some("+08:00".into()));
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", T::DATA_TYPE, true),
+            Field::new("b", T::DATA_TYPE, true),
+            Field::new("c", T::DATA_TYPE, true),
+            Field::new("d", with_timezone, true),
+        ]));
+
+        let batches = do_read(buf, 1024, true, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let unit_in_nanos: i64 = match T::UNIT {
+            TimeUnit::Second => 1_000_000_000,
+            TimeUnit::Millisecond => 1_000_000,
+            TimeUnit::Microsecond => 1_000,
+            TimeUnit::Nanosecond => 1,
+        };
+
+        let col1 = batches[0].column(0).as_primitive::<T>();
+        assert_eq!(col1.null_count(), 4);
+        assert!(col1.is_null(2));
+        assert!(col1.is_null(3));
+        assert!(col1.is_null(4));
+        assert!(col1.is_null(5));
+        assert_eq!(col1.values(), &[1, 2, 0, 0, 0, 0].map(T::Native::usize_as));
+
+        let col2 = batches[0].column(1).as_primitive::<T>();
+        assert_eq!(col2.null_count(), 1);
+        assert!(col2.is_null(5));
+        assert_eq!(
+            col2.values(),
+            &[
+                1599572549190855000 / unit_in_nanos,
+                1599572549190855000 / unit_in_nanos,
+                1599572549000000000 / unit_in_nanos,
+                40,
+                1234,
+                0
+            ]
+        );
+
+        let col3 = batches[0].column(2).as_primitive::<T>();
+        assert_eq!(col3.null_count(), 0);
+        assert_eq!(
+            col3.values(),
+            &[
+                38,
+                123,
+                854702816123000000 / unit_in_nanos,
+                1599572549190855000 / unit_in_nanos,
+                854702816123000000 / unit_in_nanos,
+                854738816123000000 / unit_in_nanos
+            ]
+        );
+
+        let col4 = batches[0].column(3).as_primitive::<T>();
+
+        assert_eq!(col4.null_count(), 0);
+        assert_eq!(
+            col4.values(),
+            &[
+                854674016123000000 / unit_in_nanos,
+                123,
+                854702816123000000 / unit_in_nanos,
+                854720816123000000 / unit_in_nanos,
+                854674016000000000 / unit_in_nanos,
+                854640000000000000 / unit_in_nanos
+            ]
+        );
+    }
+
+    #[test]
+    fn test_timestamps() {
+        test_timestamp::<TimestampSecondType>();
+        test_timestamp::<TimestampMillisecondType>();
+        test_timestamp::<TimestampMicrosecondType>();
+        test_timestamp::<TimestampNanosecondType>();
+    }
+
+    fn test_time<T: ArrowTemporalType>() {
+        let buf = r#"
+        {"a": 1, "b": "09:26:56.123 AM", "c": 38.30}
+        {"a": 2, "b": "23:59:59", "c": 123.456}
+
+        {"b": 1337, "b": "6:00 pm", "c": "09:26:56.123"}
+        {"b": 40, "c": "13:42:29.190855"}
+        {"b": 1234, "a": null, "c": "09:26:56.123"}
+        {"c": "14:26:56.123"}
+        "#;
+
+        let unit = match T::DATA_TYPE {
+            DataType::Time32(unit) | DataType::Time64(unit) => unit,
+            _ => unreachable!(),
+        };
+
+        let unit_in_nanos = match unit {
+            TimeUnit::Second => 1_000_000_000,
+            TimeUnit::Millisecond => 1_000_000,
+            TimeUnit::Microsecond => 1_000,
+            TimeUnit::Nanosecond => 1,
+        };
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", T::DATA_TYPE, true),
+            Field::new("b", T::DATA_TYPE, true),
+            Field::new("c", T::DATA_TYPE, true),
+        ]));
+
+        let batches = do_read(buf, 1024, true, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let col1 = batches[0].column(0).as_primitive::<T>();
+        assert_eq!(col1.null_count(), 4);
+        assert!(col1.is_null(2));
+        assert!(col1.is_null(3));
+        assert!(col1.is_null(4));
+        assert!(col1.is_null(5));
+        assert_eq!(col1.values(), &[1, 2, 0, 0, 0, 0].map(T::Native::usize_as));
+
+        let col2 = batches[0].column(1).as_primitive::<T>();
+        assert_eq!(col2.null_count(), 1);
+        assert!(col2.is_null(5));
+        assert_eq!(
+            col2.values(),
+            &[
+                34016123000000 / unit_in_nanos,
+                86399000000000 / unit_in_nanos,
+                64800000000000 / unit_in_nanos,
+                40,
+                1234,
+                0
+            ]
+            .map(T::Native::usize_as)
+        );
+
+        let col3 = batches[0].column(2).as_primitive::<T>();
+        assert_eq!(col3.null_count(), 0);
+        assert_eq!(
+            col3.values(),
+            &[
+                38,
+                123,
+                34016123000000 / unit_in_nanos,
+                49349190855000 / unit_in_nanos,
+                34016123000000 / unit_in_nanos,
+                52016123000000 / unit_in_nanos
+            ]
+            .map(T::Native::usize_as)
+        );
+    }
+
+    #[test]
+    fn test_times() {
+        test_time::<Time32MillisecondType>();
+        test_time::<Time32SecondType>();
+        test_time::<Time64MicrosecondType>();
+        test_time::<Time64NanosecondType>();
+    }
+
+    #[test]
+    fn test_delta_checkpoint() {
+        let json = "{\"protocol\":{\"minReaderVersion\":1,\"minWriterVersion\":2}}";
+        let schema = Arc::new(Schema::new(vec![
+            Field::new_struct(
+                "protocol",
+                vec![
+                    Field::new("minReaderVersion", DataType::Int32, true),
+                    Field::new("minWriterVersion", DataType::Int32, true),
+                ],
+                true,
+            ),
+            Field::new_struct(
+                "add",
+                vec![Field::new_map(
+                    "partitionValues",
+                    "key_value",
+                    Field::new("key", DataType::Utf8, false),
+                    Field::new("value", DataType::Utf8, true),
+                    false,
+                    false,
+                )],
+                true,
+            ),
+        ]));
+
+        let batches = do_read(json, 1024, true, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let s: StructArray = batches.into_iter().next().unwrap().into();
+        let opts = FormatOptions::default().with_null("null");
+        let formatter = ArrayFormatter::try_new(&s, &opts).unwrap();
+        assert_eq!(
+            formatter.value(0).to_string(),
+            "{protocol: {minReaderVersion: 1, minWriterVersion: 2}, add: null}"
+        );
+    }
+
+    #[test]
+    fn struct_nullability() {
+        let do_test = |child: DataType| {
+            // Test correctly enforced nullability
+            let non_null = r#"{"foo": {}}"#;
+            let schema = Arc::new(Schema::new(vec![Field::new_struct(
+                "foo",
+                vec![Field::new("bar", child, false)],
+                true,
+            )]));
+            let mut reader = ReaderBuilder::new(schema.clone())
+                .build(Cursor::new(non_null.as_bytes()))
+                .unwrap();
+            assert!(reader.next().unwrap().is_err()); // Should error as not nullable
+
+            let null = r#"{"foo": {bar: null}}"#;
+            let mut reader = ReaderBuilder::new(schema.clone())
+                .build(Cursor::new(null.as_bytes()))
+                .unwrap();
+            assert!(reader.next().unwrap().is_err()); // Should error as not nullable
+
+            // Test nulls in nullable parent can mask nulls in non-nullable child
+            let null = r#"{"foo": null}"#;
+            let mut reader = ReaderBuilder::new(schema)
+                .build(Cursor::new(null.as_bytes()))
+                .unwrap();
+            let batch = reader.next().unwrap().unwrap();
+            assert_eq!(batch.num_columns(), 1);
+            let foo = batch.column(0).as_struct();
+            assert_eq!(foo.len(), 1);
+            assert!(foo.is_null(0));
+            assert_eq!(foo.num_columns(), 1);
+
+            let bar = foo.column(0);
+            assert_eq!(bar.len(), 1);
+            // Non-nullable child can still contain null as masked by parent
+            assert!(bar.is_null(0));
+        };
+
+        do_test(DataType::Boolean);
+        do_test(DataType::Int32);
+        do_test(DataType::Utf8);
+        do_test(DataType::Decimal128(2, 1));
+        do_test(DataType::Timestamp(
+            TimeUnit::Microsecond,
+            Some("+00:00".into()),
+        ));
+    }
+
+    #[test]
+    fn test_truncation() {
+        let buf = r#"
+        {"i64": 9223372036854775807, "u64": 18446744073709551615 }
+        {"i64": "9223372036854775807", "u64": "18446744073709551615" }
+        {"i64": -9223372036854775808, "u64": 0 }
+        {"i64": "-9223372036854775808", "u64": 0 }
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("i64", DataType::Int64, true),
+            Field::new("u64", DataType::UInt64, true),
+        ]));
+
+        let batches = do_read(buf, 1024, true, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let i64 = batches[0].column(0).as_primitive::<Int64Type>();
+        assert_eq!(i64.values(), &[i64::MAX, i64::MAX, i64::MIN, i64::MIN]);
+
+        let u64 = batches[0].column(1).as_primitive::<UInt64Type>();
+        assert_eq!(u64.values(), &[u64::MAX, u64::MAX, u64::MIN, u64::MIN]);
+    }
+
+    #[test]
+    fn test_timestamp_truncation() {
+        let buf = r#"
+        {"time": 9223372036854775807 }
+        {"time": -9223372036854775808 }
+        {"time": 9e5 }
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "time",
+            DataType::Timestamp(TimeUnit::Nanosecond, None),
+            true,
+        )]));
+
+        let batches = do_read(buf, 1024, true, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let i64 = batches[0]
+            .column(0)
+            .as_primitive::<TimestampNanosecondType>();
+        assert_eq!(i64.values(), &[i64::MAX, i64::MIN, 900000]);
+    }
+
+    #[test]
+    fn test_strict_mode_no_missing_columns_in_schema() {
+        let buf = r#"
+        {"a": 1, "b": "2", "c": true}
+        {"a": 2E0, "b": "4", "c": false}
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Int16, false),
+            Field::new("b", DataType::Utf8, false),
+            Field::new("c", DataType::Boolean, false),
+        ]));
+
+        let batches = do_read(buf, 1024, true, true, schema);
+        assert_eq!(batches.len(), 1);
+
+        let buf = r#"
+        {"a": 1, "b": "2", "c": {"a": true, "b": 1}}
+        {"a": 2E0, "b": "4", "c": {"a": false, "b": 2}}
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Int16, false),
+            Field::new("b", DataType::Utf8, false),
+            Field::new_struct(
+                "c",
+                vec![
+                    Field::new("a", DataType::Boolean, false),
+                    Field::new("b", DataType::Int16, false),
+                ],
+                false,
+            ),
+        ]));
+
+        let batches = do_read(buf, 1024, true, true, schema);
+        assert_eq!(batches.len(), 1);
+    }
+
+    #[test]
+    fn test_strict_mode_missing_columns_in_schema() {
+        let buf = r#"
+        {"a": 1, "b": "2", "c": true}
+        {"a": 2E0, "b": "4", "c": false}
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Int16, true),
+            Field::new("c", DataType::Boolean, true),
+        ]));
+
+        let err = ReaderBuilder::new(schema)
+            .with_batch_size(1024)
+            .with_strict_mode(true)
+            .build(Cursor::new(buf.as_bytes()))
+            .unwrap()
+            .read()
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Json error: column 'b' missing from schema"
+        );
+
+        let buf = r#"
+        {"a": 1, "b": "2", "c": {"a": true, "b": 1}}
+        {"a": 2E0, "b": "4", "c": {"a": false, "b": 2}}
+        "#;
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Int16, false),
+            Field::new("b", DataType::Utf8, false),
+            Field::new_struct("c", vec![Field::new("a", DataType::Boolean, false)], false),
+        ]));
+
+        let err = ReaderBuilder::new(schema)
+            .with_batch_size(1024)
+            .with_strict_mode(true)
+            .build(Cursor::new(buf.as_bytes()))
+            .unwrap()
+            .read()
+            .unwrap_err();
+
+        assert_eq!(
+            err.to_string(),
+            "Json error: whilst decoding field 'c': column 'b' missing from schema"
+        );
+    }
+
+    fn read_file(path: &str, schema: Option<Schema>) -> Reader<BufReader<File>> {
+        let file = File::open(path).unwrap();
+        let mut reader = BufReader::new(file);
+        let schema = schema.unwrap_or_else(|| {
+            let (schema, _) = infer_json_schema(&mut reader, None).unwrap();
+            reader.rewind().unwrap();
+            schema
+        });
+        let builder = ReaderBuilder::new(Arc::new(schema)).with_batch_size(64);
+        builder.build(reader).unwrap()
+    }
+
+    #[test]
+    fn test_json_basic() {
+        let mut reader = read_file("test/data/basic.json", None);
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(8, batch.num_columns());
+        assert_eq!(12, batch.num_rows());
+
+        let schema = reader.schema();
+        let batch_schema = batch.schema();
+        assert_eq!(schema, batch_schema);
+
+        let a = schema.column_with_name("a").unwrap();
+        assert_eq!(0, a.0);
+        assert_eq!(&DataType::Int64, a.1.data_type());
+        let b = schema.column_with_name("b").unwrap();
+        assert_eq!(1, b.0);
+        assert_eq!(&DataType::Float64, b.1.data_type());
+        let c = schema.column_with_name("c").unwrap();
+        assert_eq!(2, c.0);
+        assert_eq!(&DataType::Boolean, c.1.data_type());
+        let d = schema.column_with_name("d").unwrap();
+        assert_eq!(3, d.0);
+        assert_eq!(&DataType::Utf8, d.1.data_type());
+
+        let aa = batch.column(a.0).as_primitive::<Int64Type>();
+        assert_eq!(1, aa.value(0));
+        assert_eq!(-10, aa.value(1));
+        let bb = batch.column(b.0).as_primitive::<Float64Type>();
+        assert_eq!(2.0, bb.value(0));
+        assert_eq!(-3.5, bb.value(1));
+        let cc = batch.column(c.0).as_boolean();
+        assert!(!cc.value(0));
+        assert!(cc.value(10));
+        let dd = batch.column(d.0).as_string::<i32>();
+        assert_eq!("4", dd.value(0));
+        assert_eq!("text", dd.value(8));
+    }
+
+    #[test]
+    fn test_json_empty_projection() {
+        let mut reader = read_file("test/data/basic.json", Some(Schema::empty()));
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(0, batch.num_columns());
+        assert_eq!(12, batch.num_rows());
+    }
+
+    #[test]
+    fn test_json_basic_with_nulls() {
+        let mut reader = read_file("test/data/basic_nulls.json", None);
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(4, batch.num_columns());
+        assert_eq!(12, batch.num_rows());
+
+        let schema = reader.schema();
+        let batch_schema = batch.schema();
+        assert_eq!(schema, batch_schema);
+
+        let a = schema.column_with_name("a").unwrap();
+        assert_eq!(&DataType::Int64, a.1.data_type());
+        let b = schema.column_with_name("b").unwrap();
+        assert_eq!(&DataType::Float64, b.1.data_type());
+        let c = schema.column_with_name("c").unwrap();
+        assert_eq!(&DataType::Boolean, c.1.data_type());
+        let d = schema.column_with_name("d").unwrap();
+        assert_eq!(&DataType::Utf8, d.1.data_type());
+
+        let aa = batch.column(a.0).as_primitive::<Int64Type>();
+        assert!(aa.is_valid(0));
+        assert!(!aa.is_valid(1));
+        assert!(!aa.is_valid(11));
+        let bb = batch.column(b.0).as_primitive::<Float64Type>();
+        assert!(bb.is_valid(0));
+        assert!(!bb.is_valid(2));
+        assert!(!bb.is_valid(11));
+        let cc = batch.column(c.0).as_boolean();
+        assert!(cc.is_valid(0));
+        assert!(!cc.is_valid(4));
+        assert!(!cc.is_valid(11));
+        let dd = batch.column(d.0).as_string::<i32>();
+        assert!(!dd.is_valid(0));
+        assert!(dd.is_valid(1));
+        assert!(!dd.is_valid(4));
+        assert!(!dd.is_valid(11));
+    }
+
+    #[test]
+    fn test_json_basic_schema() {
+        let schema = Schema::new(vec![
+            Field::new("a", DataType::Int64, true),
+            Field::new("b", DataType::Float32, false),
+            Field::new("c", DataType::Boolean, false),
+            Field::new("d", DataType::Utf8, false),
+        ]);
+
+        let mut reader = read_file("test/data/basic.json", Some(schema.clone()));
+        let reader_schema = reader.schema();
+        assert_eq!(reader_schema.as_ref(), &schema);
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(4, batch.num_columns());
+        assert_eq!(12, batch.num_rows());
+
+        let schema = batch.schema();
+
+        let a = schema.column_with_name("a").unwrap();
+        assert_eq!(&DataType::Int64, a.1.data_type());
+        let b = schema.column_with_name("b").unwrap();
+        assert_eq!(&DataType::Float32, b.1.data_type());
+        let c = schema.column_with_name("c").unwrap();
+        assert_eq!(&DataType::Boolean, c.1.data_type());
+        let d = schema.column_with_name("d").unwrap();
+        assert_eq!(&DataType::Utf8, d.1.data_type());
+
+        let aa = batch.column(a.0).as_primitive::<Int64Type>();
+        assert_eq!(1, aa.value(0));
+        assert_eq!(100000000000000, aa.value(11));
+        let bb = batch.column(b.0).as_primitive::<Float32Type>();
+        assert_eq!(2.0, bb.value(0));
+        assert_eq!(-3.5, bb.value(1));
+    }
+
+    #[test]
+    fn test_json_basic_schema_projection() {
+        let schema = Schema::new(vec![
+            Field::new("a", DataType::Int64, true),
+            Field::new("c", DataType::Boolean, false),
+        ]);
+
+        let mut reader = read_file("test/data/basic.json", Some(schema.clone()));
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(2, batch.num_columns());
+        assert_eq!(2, batch.schema().fields().len());
+        assert_eq!(12, batch.num_rows());
+
+        assert_eq!(batch.schema().as_ref(), &schema);
+
+        let a = schema.column_with_name("a").unwrap();
+        assert_eq!(0, a.0);
+        assert_eq!(&DataType::Int64, a.1.data_type());
+        let c = schema.column_with_name("c").unwrap();
+        assert_eq!(1, c.0);
+        assert_eq!(&DataType::Boolean, c.1.data_type());
+    }
+
+    #[test]
+    fn test_json_arrays() {
+        let mut reader = read_file("test/data/arrays.json", None);
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(4, batch.num_columns());
+        assert_eq!(3, batch.num_rows());
+
+        let schema = batch.schema();
+
+        let a = schema.column_with_name("a").unwrap();
+        assert_eq!(&DataType::Int64, a.1.data_type());
+        let b = schema.column_with_name("b").unwrap();
+        assert_eq!(
+            &DataType::List(Arc::new(Field::new("item", DataType::Float64, true))),
+            b.1.data_type()
+        );
+        let c = schema.column_with_name("c").unwrap();
+        assert_eq!(
+            &DataType::List(Arc::new(Field::new("item", DataType::Boolean, true))),
+            c.1.data_type()
+        );
+        let d = schema.column_with_name("d").unwrap();
+        assert_eq!(&DataType::Utf8, d.1.data_type());
+
+        let aa = batch.column(a.0).as_primitive::<Int64Type>();
+        assert_eq!(1, aa.value(0));
+        assert_eq!(-10, aa.value(1));
+        assert_eq!(1627668684594000000, aa.value(2));
+        let bb = batch.column(b.0).as_list::<i32>();
+        let bb = bb.values().as_primitive::<Float64Type>();
+        assert_eq!(9, bb.len());
+        assert_eq!(2.0, bb.value(0));
+        assert_eq!(-6.1, bb.value(5));
+        assert!(!bb.is_valid(7));
+
+        let cc = batch
+            .column(c.0)
+            .as_any()
+            .downcast_ref::<ListArray>()
+            .unwrap();
+        let cc = cc.values().as_boolean();
+        assert_eq!(6, cc.len());
+        assert!(!cc.value(0));
+        assert!(!cc.value(4));
+        assert!(!cc.is_valid(5));
+    }
+
+    #[test]
+    fn test_empty_json_arrays() {
+        let json_content = r#"
+            {"items": []}
+            {"items": null}
+            {}
+            "#;
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "items",
+            DataType::List(FieldRef::new(Field::new("item", DataType::Null, true))),
+            true,
+        )]));
+
+        let batches = do_read(json_content, 1024, false, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let col1 = batches[0].column(0).as_list::<i32>();
+        assert_eq!(col1.null_count(), 2);
+        assert!(col1.value(0).is_empty());
+        assert_eq!(col1.value(0).data_type(), &DataType::Null);
+        assert!(col1.is_null(1));
+        assert!(col1.is_null(2));
+    }
+
+    #[test]
+    fn test_nested_empty_json_arrays() {
+        let json_content = r#"
+            {"items": [[],[]]}
+            {"items": [[null, null],[null]]}
+            "#;
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "items",
+            DataType::List(FieldRef::new(Field::new(
+                "item",
+                DataType::List(FieldRef::new(Field::new("item", DataType::Null, true))),
+                true,
+            ))),
+            true,
+        )]));
+
+        let batches = do_read(json_content, 1024, false, false, schema);
+        assert_eq!(batches.len(), 1);
+
+        let col1 = batches[0].column(0).as_list::<i32>();
+        assert_eq!(col1.null_count(), 0);
+        assert_eq!(col1.value(0).len(), 2);
+        assert!(col1.value(0).as_list::<i32>().value(0).is_empty());
+        assert!(col1.value(0).as_list::<i32>().value(1).is_empty());
+
+        assert_eq!(col1.value(1).len(), 2);
+        assert_eq!(col1.value(1).as_list::<i32>().value(0).len(), 2);
+        assert_eq!(col1.value(1).as_list::<i32>().value(1).len(), 1);
+    }
+
+    #[test]
+    fn test_nested_list_json_arrays() {
+        let c_field = Field::new_struct("c", vec![Field::new("d", DataType::Utf8, true)], true);
+        let a_struct_field = Field::new_struct(
+            "a",
+            vec![Field::new("b", DataType::Boolean, true), c_field.clone()],
+            true,
+        );
+        let a_field = Field::new("a", DataType::List(Arc::new(a_struct_field.clone())), true);
+        let schema = Arc::new(Schema::new(vec![a_field.clone()]));
+        let builder = ReaderBuilder::new(schema).with_batch_size(64);
+        let json_content = r#"
+        {"a": [{"b": true, "c": {"d": "a_text"}}, {"b": false, "c": {"d": "b_text"}}]}
+        {"a": [{"b": false, "c": null}]}
+        {"a": [{"b": true, "c": {"d": "c_text"}}, {"b": null, "c": {"d": "d_text"}}, {"b": true, "c": {"d": null}}]}
+        {"a": null}
+        {"a": []}
+        {"a": [null]}
+        "#;
+        let mut reader = builder.build(Cursor::new(json_content)).unwrap();
+
+        // build expected output
+        let d = StringArray::from(vec![
+            Some("a_text"),
+            Some("b_text"),
+            None,
+            Some("c_text"),
+            Some("d_text"),
+            None,
+            None,
+        ]);
+        let c = ArrayDataBuilder::new(c_field.data_type().clone())
+            .len(7)
+            .add_child_data(d.to_data())
+            .null_bit_buffer(Some(Buffer::from(vec![0b00111011])))
+            .build()
+            .unwrap();
+        let b = BooleanArray::from(vec![
+            Some(true),
+            Some(false),
+            Some(false),
+            Some(true),
+            None,
+            Some(true),
+            None,
+        ]);
+        let a = ArrayDataBuilder::new(a_struct_field.data_type().clone())
+            .len(7)
+            .add_child_data(b.to_data())
+            .add_child_data(c.clone())
+            .null_bit_buffer(Some(Buffer::from(vec![0b00111111])))
+            .build()
+            .unwrap();
+        let a_list = ArrayDataBuilder::new(a_field.data_type().clone())
+            .len(6)
+            .add_buffer(Buffer::from_slice_ref([0i32, 2, 3, 6, 6, 6, 7]))
+            .add_child_data(a)
+            .null_bit_buffer(Some(Buffer::from(vec![0b00110111])))
+            .build()
+            .unwrap();
+        let expected = make_array(a_list);
+
+        // compare `a` with result from json reader
+        let batch = reader.next().unwrap().unwrap();
+        let read = batch.column(0);
+        assert_eq!(read.len(), 6);
+        // compare the arrays the long way around, to better detect differences
+        let read: &ListArray = read.as_list::<i32>();
+        let expected = expected.as_list::<i32>();
+        assert_eq!(read.value_offsets(), &[0, 2, 3, 6, 6, 6, 7]);
+        // compare list null buffers
+        assert_eq!(read.nulls(), expected.nulls());
+        // build struct from list
+        let struct_array = read.values().as_struct();
+        let expected_struct_array = expected.values().as_struct();
+
+        assert_eq!(7, struct_array.len());
+        assert_eq!(1, struct_array.null_count());
+        assert_eq!(7, expected_struct_array.len());
+        assert_eq!(1, expected_struct_array.null_count());
+        // test struct's nulls
+        assert_eq!(struct_array.nulls(), expected_struct_array.nulls());
+        // test struct's fields
+        let read_b = struct_array.column(0);
+        assert_eq!(read_b.as_ref(), &b);
+        let read_c = struct_array.column(1);
+        assert_eq!(read_c.to_data(), c);
+        let read_c = read_c.as_struct();
+        let read_d = read_c.column(0);
+        assert_eq!(read_d.as_ref(), &d);
+
+        assert_eq!(read, expected);
+    }
+
+    #[test]
+    fn test_skip_empty_lines() {
+        let schema = Schema::new(vec![Field::new("a", DataType::Int64, true)]);
+        let builder = ReaderBuilder::new(Arc::new(schema)).with_batch_size(64);
+        let json_content = "
+        {\"a\": 1}
+        {\"a\": 2}
+        {\"a\": 3}";
+        let mut reader = builder.build(Cursor::new(json_content)).unwrap();
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(1, batch.num_columns());
+        assert_eq!(3, batch.num_rows());
+
+        let schema = reader.schema();
+        let c = schema.column_with_name("a").unwrap();
+        assert_eq!(&DataType::Int64, c.1.data_type());
+    }
+
+    #[test]
+    fn test_with_multiple_batches() {
+        let file = File::open("test/data/basic_nulls.json").unwrap();
+        let mut reader = BufReader::new(file);
+        let (schema, _) = infer_json_schema(&mut reader, None).unwrap();
+        reader.rewind().unwrap();
+
+        let builder = ReaderBuilder::new(Arc::new(schema)).with_batch_size(5);
+        let mut reader = builder.build(reader).unwrap();
+
+        let mut num_records = Vec::new();
+        while let Some(rb) = reader.next().transpose().unwrap() {
+            num_records.push(rb.num_rows());
+        }
+
+        assert_eq!(vec![5, 5, 2], num_records);
+    }
+
+    #[test]
+    fn test_timestamp_from_json_seconds() {
+        let schema = Schema::new(vec![Field::new(
+            "a",
+            DataType::Timestamp(TimeUnit::Second, None),
+            true,
+        )]);
+
+        let mut reader = read_file("test/data/basic_nulls.json", Some(schema));
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(1, batch.num_columns());
+        assert_eq!(12, batch.num_rows());
+
+        let schema = reader.schema();
+        let batch_schema = batch.schema();
+        assert_eq!(schema, batch_schema);
+
+        let a = schema.column_with_name("a").unwrap();
+        assert_eq!(
+            &DataType::Timestamp(TimeUnit::Second, None),
+            a.1.data_type()
+        );
+
+        let aa = batch.column(a.0).as_primitive::<TimestampSecondType>();
+        assert!(aa.is_valid(0));
+        assert!(!aa.is_valid(1));
+        assert!(!aa.is_valid(2));
+        assert_eq!(1, aa.value(0));
+        assert_eq!(1, aa.value(3));
+        assert_eq!(5, aa.value(7));
+    }
+
+    #[test]
+    fn test_timestamp_from_json_milliseconds() {
+        let schema = Schema::new(vec![Field::new(
+            "a",
+            DataType::Timestamp(TimeUnit::Millisecond, None),
+            true,
+        )]);
+
+        let mut reader = read_file("test/data/basic_nulls.json", Some(schema));
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(1, batch.num_columns());
+        assert_eq!(12, batch.num_rows());
+
+        let schema = reader.schema();
+        let batch_schema = batch.schema();
+        assert_eq!(schema, batch_schema);
+
+        let a = schema.column_with_name("a").unwrap();
+        assert_eq!(
+            &DataType::Timestamp(TimeUnit::Millisecond, None),
+            a.1.data_type()
+        );
+
+        let aa = batch.column(a.0).as_primitive::<TimestampMillisecondType>();
+        assert!(aa.is_valid(0));
+        assert!(!aa.is_valid(1));
+        assert!(!aa.is_valid(2));
+        assert_eq!(1, aa.value(0));
+        assert_eq!(1, aa.value(3));
+        assert_eq!(5, aa.value(7));
+    }
+
+    #[test]
+    fn test_date_from_json_milliseconds() {
+        let schema = Schema::new(vec![Field::new("a", DataType::Date64, true)]);
+
+        let mut reader = read_file("test/data/basic_nulls.json", Some(schema));
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(1, batch.num_columns());
+        assert_eq!(12, batch.num_rows());
+
+        let schema = reader.schema();
+        let batch_schema = batch.schema();
+        assert_eq!(schema, batch_schema);
+
+        let a = schema.column_with_name("a").unwrap();
+        assert_eq!(&DataType::Date64, a.1.data_type());
+
+        let aa = batch.column(a.0).as_primitive::<Date64Type>();
+        assert!(aa.is_valid(0));
+        assert!(!aa.is_valid(1));
+        assert!(!aa.is_valid(2));
+        assert_eq!(1, aa.value(0));
+        assert_eq!(1, aa.value(3));
+        assert_eq!(5, aa.value(7));
+    }
+
+    #[test]
+    fn test_time_from_json_nanoseconds() {
+        let schema = Schema::new(vec![Field::new(
+            "a",
+            DataType::Time64(TimeUnit::Nanosecond),
+            true,
+        )]);
+
+        let mut reader = read_file("test/data/basic_nulls.json", Some(schema));
+        let batch = reader.next().unwrap().unwrap();
+
+        assert_eq!(1, batch.num_columns());
+        assert_eq!(12, batch.num_rows());
+
+        let schema = reader.schema();
+        let batch_schema = batch.schema();
+        assert_eq!(schema, batch_schema);
+
+        let a = schema.column_with_name("a").unwrap();
+        assert_eq!(&DataType::Time64(TimeUnit::Nanosecond), a.1.data_type());
+
+        let aa = batch.column(a.0).as_primitive::<Time64NanosecondType>();
+        assert!(aa.is_valid(0));
+        assert!(!aa.is_valid(1));
+        assert!(!aa.is_valid(2));
+        assert_eq!(1, aa.value(0));
+        assert_eq!(1, aa.value(3));
+        assert_eq!(5, aa.value(7));
+    }
+
+    #[test]
+    fn test_json_iterator() {
+        let file = File::open("test/data/basic.json").unwrap();
+        let mut reader = BufReader::new(file);
+        let (schema, _) = infer_json_schema(&mut reader, None).unwrap();
+        reader.rewind().unwrap();
+
+        let builder = ReaderBuilder::new(Arc::new(schema)).with_batch_size(5);
+        let reader = builder.build(reader).unwrap();
+        let schema = reader.schema();
+        let (col_a_index, _) = schema.column_with_name("a").unwrap();
+
+        let mut sum_num_rows = 0;
+        let mut num_batches = 0;
+        let mut sum_a = 0;
+        for batch in reader {
+            let batch = batch.unwrap();
+            assert_eq!(8, batch.num_columns());
+            sum_num_rows += batch.num_rows();
+            num_batches += 1;
+            let batch_schema = batch.schema();
+            assert_eq!(schema, batch_schema);
+            let a_array = batch.column(col_a_index).as_primitive::<Int64Type>();
+            sum_a += (0..a_array.len()).map(|i| a_array.value(i)).sum::<i64>();
+        }
+        assert_eq!(12, sum_num_rows);
+        assert_eq!(3, num_batches);
+        assert_eq!(100000000000011, sum_a);
+    }
+
+    #[test]
+    fn test_decoder_error() {
+        let schema = Arc::new(Schema::new(vec![Field::new_struct(
+            "a",
+            vec![Field::new("child", DataType::Int32, false)],
+            true,
+        )]));
+
+        let parse_err = |s: &str| {
+            ReaderBuilder::new(schema.clone())
+                .build(Cursor::new(s.as_bytes()))
+                .unwrap()
+                .next()
+                .unwrap()
+                .unwrap_err()
+                .to_string()
+        };
+
+        let err = parse_err(r#"{"a": 123}"#);
+        assert_eq!(
+            err,
+            "Json error: whilst decoding field 'a': expected { got 123"
+        );
+
+        let err = parse_err(r#"{"a": ["bar"]}"#);
+        assert_eq!(
+            err,
+            r#"Json error: whilst decoding field 'a': expected { got ["bar"]"#
+        );
+
+        let err = parse_err(r#"{"a": []}"#);
+        assert_eq!(
+            err,
+            "Json error: whilst decoding field 'a': expected { got []"
+        );
+
+        let err = parse_err(r#"{"a": [{"child": 234}]}"#);
+        assert_eq!(
+            err,
+            r#"Json error: whilst decoding field 'a': expected { got [{"child": 234}]"#
+        );
+
+        let err = parse_err(r#"{"a": [{"child": {"foo": [{"foo": ["bar"]}]}}]}"#);
+        assert_eq!(
+            err,
+            r#"Json error: whilst decoding field 'a': expected { got [{"child": {"foo": [{"foo": ["bar"]}]}}]"#
+        );
+
+        let err = parse_err(r#"{"a": true}"#);
+        assert_eq!(
+            err,
+            "Json error: whilst decoding field 'a': expected { got true"
+        );
+
+        let err = parse_err(r#"{"a": false}"#);
+        assert_eq!(
+            err,
+            "Json error: whilst decoding field 'a': expected { got false"
+        );
+
+        let err = parse_err(r#"{"a": "foo"}"#);
+        assert_eq!(
+            err,
+            "Json error: whilst decoding field 'a': expected { got \"foo\""
+        );
+
+        let err = parse_err(r#"{"a": {"child": false}}"#);
+        assert_eq!(
+            err,
+            "Json error: whilst decoding field 'a': whilst decoding field 'child': expected primitive got false"
+        );
+
+        let err = parse_err(r#"{"a": {"child": []}}"#);
+        assert_eq!(
+            err,
+            "Json error: whilst decoding field 'a': whilst decoding field 'child': expected primitive got []"
+        );
+
+        let err = parse_err(r#"{"a": {"child": [123]}}"#);
+        assert_eq!(
+            err,
+            "Json error: whilst decoding field 'a': whilst decoding field 'child': expected primitive got [123]"
+        );
+
+        let err = parse_err(r#"{"a": {"child": [123, 3465346]}}"#);
+        assert_eq!(
+            err,
+            "Json error: whilst decoding field 'a': whilst decoding field 'child': expected primitive got [123, 3465346]"
+        );
+    }
+
+    #[test]
+    fn test_serialize_timestamp() {
+        let json = vec![
+            json!({"timestamp": 1681319393}),
+            json!({"timestamp": "1970-01-01T00:00:00+02:00"}),
+        ];
+        let schema = Schema::new(vec![Field::new(
+            "timestamp",
+            DataType::Timestamp(TimeUnit::Second, None),
+            true,
+        )]);
+        let mut decoder = ReaderBuilder::new(Arc::new(schema))
+            .build_decoder()
+            .unwrap();
+        decoder.serialize(&json).unwrap();
+        let batch = decoder.flush().unwrap().unwrap();
+        assert_eq!(batch.num_rows(), 2);
+        assert_eq!(batch.num_columns(), 1);
+        let values = batch.column(0).as_primitive::<TimestampSecondType>();
+        assert_eq!(values.values(), &[1681319393, -7200]);
+    }
+
+    #[test]
+    fn test_serde_field() {
+        let field = Field::new("int", DataType::Int32, true);
+        let mut decoder = ReaderBuilder::new_with_field(field)
+            .build_decoder()
+            .unwrap();
+        decoder.serialize(&[1_i32, 2, 3, 4]).unwrap();
+        let b = decoder.flush().unwrap().unwrap();
+        let values = b.column(0).as_primitive::<Int32Type>().values();
+        assert_eq!(values, &[1, 2, 3, 4]);
+    }
+
+    #[test]
+    fn test_serde_large_numbers() {
+        let field = Field::new("int", DataType::Int64, true);
+        let mut decoder = ReaderBuilder::new_with_field(field)
+            .build_decoder()
+            .unwrap();
+
+        decoder.serialize(&[1699148028689_u64, 2, 3, 4]).unwrap();
+        let b = decoder.flush().unwrap().unwrap();
+        let values = b.column(0).as_primitive::<Int64Type>().values();
+        assert_eq!(values, &[1699148028689, 2, 3, 4]);
+
+        let field = Field::new(
+            "int",
+            DataType::Timestamp(TimeUnit::Microsecond, None),
+            true,
+        );
+        let mut decoder = ReaderBuilder::new_with_field(field)
+            .build_decoder()
+            .unwrap();
+
+        decoder.serialize(&[1699148028689_u64, 2, 3, 4]).unwrap();
+        let b = decoder.flush().unwrap().unwrap();
+        let values = b
+            .column(0)
+            .as_primitive::<TimestampMicrosecondType>()
+            .values();
+        assert_eq!(values, &[1699148028689, 2, 3, 4]);
+    }
+
+    #[test]
+    fn test_coercing_primitive_into_string_decoder() {
+        let buf = &format!(
+            r#"[{{"a": 1, "b": "A", "c": "T"}}, {{"a": 2, "b": "BB", "c": "F"}}, {{"a": {}, "b": 123, "c": false}}, {{"a": {}, "b": 789, "c": true}}]"#,
+            (std::i32::MAX as i64 + 10),
+            std::i64::MAX - 10
+        );
+        let schema = Schema::new(vec![
+            Field::new("a", DataType::Float64, true),
+            Field::new("b", DataType::Utf8, true),
+            Field::new("c", DataType::Utf8, true),
+        ]);
+        let json_array: Vec<serde_json::Value> = serde_json::from_str(buf).unwrap();
+        let schema_ref = Arc::new(schema);
+
+        // read record batches
+        let reader = ReaderBuilder::new(schema_ref.clone()).with_coerce_primitive(true);
+        let mut decoder = reader.build_decoder().unwrap();
+        decoder.serialize(json_array.as_slice()).unwrap();
+        let batch = decoder.flush().unwrap().unwrap();
+        assert_eq!(
+            batch,
+            RecordBatch::try_new(
+                schema_ref,
+                vec![
+                    Arc::new(Float64Array::from(vec![
+                        1.0,
+                        2.0,
+                        (std::i32::MAX as i64 + 10) as f64,
+                        (std::i64::MAX - 10) as f64
+                    ])),
+                    Arc::new(StringArray::from(vec!["A", "BB", "123", "789"])),
+                    Arc::new(StringArray::from(vec!["T", "F", "false", "true"])),
+                ]
+            )
+            .unwrap()
+        );
+    }
+}
diff --git a/arrow-json/src/reader/null_array.rs b/arrow-json/src/reader/null_array.rs
new file mode 100644
index 000000000000..4270045fb3c2
--- /dev/null
+++ b/arrow-json/src/reader/null_array.rs
@@ -0,0 +1,35 @@
+// 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.
+
+use crate::reader::tape::{Tape, TapeElement};
+use crate::reader::ArrayDecoder;
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType};
+
+#[derive(Default)]
+pub struct NullArrayDecoder {}
+
+impl ArrayDecoder for NullArrayDecoder {
+    fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayData, ArrowError> {
+        for p in pos {
+            if !matches!(tape.get(*p), TapeElement::Null) {
+                return Err(tape.error(*p, "null"));
+            }
+        }
+        ArrayDataBuilder::new(DataType::Null).len(pos.len()).build()
+    }
+}
diff --git a/arrow-json/src/reader/primitive_array.rs b/arrow-json/src/reader/primitive_array.rs
new file mode 100644
index 000000000000..1bd1176131ae
--- /dev/null
+++ b/arrow-json/src/reader/primitive_array.rs
@@ -0,0 +1,159 @@
+// 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.
+
+use num::NumCast;
+use std::marker::PhantomData;
+
+use arrow_array::builder::PrimitiveBuilder;
+use arrow_array::{Array, ArrowPrimitiveType};
+use arrow_cast::parse::Parser;
+use arrow_data::ArrayData;
+use arrow_schema::{ArrowError, DataType};
+use half::f16;
+
+use crate::reader::tape::{Tape, TapeElement};
+use crate::reader::ArrayDecoder;
+
+/// A trait for JSON-specific primitive parsing logic
+///
+/// According to the specification unquoted fields should be parsed as a double-precision
+/// floating point numbers, including scientific representation such as `2e3`
+///
+/// In practice, it is common to serialize numbers outside the range of an `f64` and expect
+/// them to round-trip correctly. As such when parsing integers we first parse as the integer
+/// and fallback to parsing as a floating point if this fails
+trait ParseJsonNumber: Sized {
+    fn parse(s: &[u8]) -> Option<Self>;
+}
+
+macro_rules! primitive_parse {
+    ($($t:ty),+) => {
+        $(impl ParseJsonNumber for $t {
+            fn parse(s: &[u8]) -> Option<Self> {
+                match lexical_core::parse::<Self>(s) {
+                    Ok(f) => Some(f),
+                    Err(_) => lexical_core::parse::<f64>(s).ok().and_then(NumCast::from),
+                }
+            }
+        })+
+    };
+}
+
+primitive_parse!(i8, i16, i32, i64, u8, u16, u32, u64);
+
+impl ParseJsonNumber for f16 {
+    fn parse(s: &[u8]) -> Option<Self> {
+        lexical_core::parse::<f32>(s).ok().map(f16::from_f32)
+    }
+}
+
+impl ParseJsonNumber for f32 {
+    fn parse(s: &[u8]) -> Option<Self> {
+        lexical_core::parse::<Self>(s).ok()
+    }
+}
+
+impl ParseJsonNumber for f64 {
+    fn parse(s: &[u8]) -> Option<Self> {
+        lexical_core::parse::<Self>(s).ok()
+    }
+}
+
+pub struct PrimitiveArrayDecoder<P: ArrowPrimitiveType> {
+    data_type: DataType,
+    // Invariant and Send
+    phantom: PhantomData<fn(P) -> P>,
+}
+
+impl<P: ArrowPrimitiveType> PrimitiveArrayDecoder<P> {
+    pub fn new(data_type: DataType) -> Self {
+        Self {
+            data_type,
+            phantom: Default::default(),
+        }
+    }
+}
+
+impl<P> ArrayDecoder for PrimitiveArrayDecoder<P>
+where
+    P: ArrowPrimitiveType + Parser,
+    P::Native: ParseJsonNumber + NumCast,
+{
+    fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayData, ArrowError> {
+        let mut builder =
+            PrimitiveBuilder::<P>::with_capacity(pos.len()).with_data_type(self.data_type.clone());
+        let d = &self.data_type;
+
+        for p in pos {
+            match tape.get(*p) {
+                TapeElement::Null => builder.append_null(),
+                TapeElement::String(idx) => {
+                    let s = tape.get_string(idx);
+                    let value = P::parse(s).ok_or_else(|| {
+                        ArrowError::JsonError(format!("failed to parse \"{s}\" as {d}",))
+                    })?;
+
+                    builder.append_value(value)
+                }
+                TapeElement::Number(idx) => {
+                    let s = tape.get_string(idx);
+                    let value = ParseJsonNumber::parse(s.as_bytes()).ok_or_else(|| {
+                        ArrowError::JsonError(format!("failed to parse {s} as {d}",))
+                    })?;
+
+                    builder.append_value(value)
+                }
+                TapeElement::F32(v) => {
+                    let v = f32::from_bits(v);
+                    let value = NumCast::from(v).ok_or_else(|| {
+                        ArrowError::JsonError(format!("failed to parse {v} as {d}",))
+                    })?;
+                    builder.append_value(value)
+                }
+                TapeElement::I32(v) => {
+                    let value = NumCast::from(v).ok_or_else(|| {
+                        ArrowError::JsonError(format!("failed to parse {v} as {d}",))
+                    })?;
+                    builder.append_value(value)
+                }
+                TapeElement::F64(high) => match tape.get(p + 1) {
+                    TapeElement::F32(low) => {
+                        let v = f64::from_bits((high as u64) << 32 | low as u64);
+                        let value = NumCast::from(v).ok_or_else(|| {
+                            ArrowError::JsonError(format!("failed to parse {v} as {d}",))
+                        })?;
+                        builder.append_value(value)
+                    }
+                    _ => unreachable!(),
+                },
+                TapeElement::I64(high) => match tape.get(p + 1) {
+                    TapeElement::I32(low) => {
+                        let v = (high as i64) << 32 | (low as u32) as i64;
+                        let value = NumCast::from(v).ok_or_else(|| {
+                            ArrowError::JsonError(format!("failed to parse {v} as {d}",))
+                        })?;
+                        builder.append_value(value)
+                    }
+                    _ => unreachable!(),
+                },
+                _ => return Err(tape.error(*p, "primitive")),
+            }
+        }
+
+        Ok(builder.finish().into_data())
+    }
+}
diff --git a/arrow-json/src/reader/schema.rs b/arrow-json/src/reader/schema.rs
new file mode 100644
index 000000000000..ace7b0ea5cb6
--- /dev/null
+++ b/arrow-json/src/reader/schema.rs
@@ -0,0 +1,742 @@
+// 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.
+
+use arrow_schema::{ArrowError, DataType, Field, Fields, Schema};
+use indexmap::map::IndexMap as HashMap;
+use indexmap::set::IndexSet as HashSet;
+use serde_json::Value;
+use std::borrow::Borrow;
+use std::io::{BufRead, Seek};
+use std::sync::Arc;
+
+#[derive(Debug, Clone)]
+enum InferredType {
+    Scalar(HashSet<DataType>),
+    Array(Box<InferredType>),
+    Object(HashMap<String, InferredType>),
+    Any,
+}
+
+impl InferredType {
+    fn merge(&mut self, other: InferredType) -> Result<(), ArrowError> {
+        match (self, other) {
+            (InferredType::Array(s), InferredType::Array(o)) => {
+                s.merge(*o)?;
+            }
+            (InferredType::Scalar(self_hs), InferredType::Scalar(other_hs)) => {
+                other_hs.into_iter().for_each(|v| {
+                    self_hs.insert(v);
+                });
+            }
+            (InferredType::Object(self_map), InferredType::Object(other_map)) => {
+                for (k, v) in other_map {
+                    self_map.entry(k).or_insert(InferredType::Any).merge(v)?;
+                }
+            }
+            (s @ InferredType::Any, v) => {
+                *s = v;
+            }
+            (_, InferredType::Any) => {}
+            // convert a scalar type to a single-item scalar array type.
+            (InferredType::Array(self_inner_type), other_scalar @ InferredType::Scalar(_)) => {
+                self_inner_type.merge(other_scalar)?;
+            }
+            (s @ InferredType::Scalar(_), InferredType::Array(mut other_inner_type)) => {
+                other_inner_type.merge(s.clone())?;
+                *s = InferredType::Array(other_inner_type);
+            }
+            // incompatible types
+            (s, o) => {
+                return Err(ArrowError::JsonError(format!(
+                    "Incompatible type found during schema inference: {s:?} v.s. {o:?}",
+                )));
+            }
+        }
+
+        Ok(())
+    }
+
+    fn is_none_or_any(ty: Option<&Self>) -> bool {
+        matches!(ty, Some(Self::Any) | None)
+    }
+}
+
+/// Shorthand for building list data type of `ty`
+fn list_type_of(ty: DataType) -> DataType {
+    DataType::List(Arc::new(Field::new("item", ty, true)))
+}
+
+/// Coerce data type during inference
+///
+/// * `Int64` and `Float64` should be `Float64`
+/// * Lists and scalars are coerced to a list of a compatible scalar
+/// * All other types are coerced to `Utf8`
+fn coerce_data_type(dt: Vec<&DataType>) -> DataType {
+    let mut dt_iter = dt.into_iter().cloned();
+    let dt_init = dt_iter.next().unwrap_or(DataType::Utf8);
+
+    dt_iter.fold(dt_init, |l, r| match (l, r) {
+        (DataType::Null, o) | (o, DataType::Null) => o,
+        (DataType::Boolean, DataType::Boolean) => DataType::Boolean,
+        (DataType::Int64, DataType::Int64) => DataType::Int64,
+        (DataType::Float64, DataType::Float64)
+        | (DataType::Float64, DataType::Int64)
+        | (DataType::Int64, DataType::Float64) => DataType::Float64,
+        (DataType::List(l), DataType::List(r)) => {
+            list_type_of(coerce_data_type(vec![l.data_type(), r.data_type()]))
+        }
+        // coerce scalar and scalar array into scalar array
+        (DataType::List(e), not_list) | (not_list, DataType::List(e)) => {
+            list_type_of(coerce_data_type(vec![e.data_type(), &not_list]))
+        }
+        _ => DataType::Utf8,
+    })
+}
+
+fn generate_datatype(t: &InferredType) -> Result<DataType, ArrowError> {
+    Ok(match t {
+        InferredType::Scalar(hs) => coerce_data_type(hs.iter().collect()),
+        InferredType::Object(spec) => DataType::Struct(generate_fields(spec)?),
+        InferredType::Array(ele_type) => list_type_of(generate_datatype(ele_type)?),
+        InferredType::Any => DataType::Null,
+    })
+}
+
+fn generate_fields(spec: &HashMap<String, InferredType>) -> Result<Fields, ArrowError> {
+    spec.iter()
+        .map(|(k, types)| Ok(Field::new(k, generate_datatype(types)?, true)))
+        .collect()
+}
+
+/// Generate schema from JSON field names and inferred data types
+fn generate_schema(spec: HashMap<String, InferredType>) -> Result<Schema, ArrowError> {
+    Ok(Schema::new(generate_fields(&spec)?))
+}
+
+/// JSON file reader that produces a serde_json::Value iterator from a Read trait
+///
+/// # Example
+///
+/// ```
+/// use std::fs::File;
+/// use std::io::BufReader;
+/// use arrow_json::reader::ValueIter;
+///
+/// let mut reader =
+///     BufReader::new(File::open("test/data/mixed_arrays.json").unwrap());
+/// let mut value_reader = ValueIter::new(&mut reader, None);
+/// for value in value_reader {
+///     println!("JSON value: {}", value.unwrap());
+/// }
+/// ```
+#[derive(Debug)]
+pub struct ValueIter<R: BufRead> {
+    reader: R,
+    max_read_records: Option<usize>,
+    record_count: usize,
+    // reuse line buffer to avoid allocation on each record
+    line_buf: String,
+}
+
+impl<R: BufRead> ValueIter<R> {
+    /// Creates a new `ValueIter`
+    pub fn new(reader: R, max_read_records: Option<usize>) -> Self {
+        Self {
+            reader,
+            max_read_records,
+            record_count: 0,
+            line_buf: String::new(),
+        }
+    }
+}
+
+impl<R: BufRead> Iterator for ValueIter<R> {
+    type Item = Result<Value, ArrowError>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if let Some(max) = self.max_read_records {
+            if self.record_count >= max {
+                return None;
+            }
+        }
+
+        loop {
+            self.line_buf.truncate(0);
+            match self.reader.read_line(&mut self.line_buf) {
+                Ok(0) => {
+                    // read_line returns 0 when stream reached EOF
+                    return None;
+                }
+                Err(e) => {
+                    return Some(Err(ArrowError::JsonError(format!(
+                        "Failed to read JSON record: {e}"
+                    ))));
+                }
+                _ => {
+                    let trimmed_s = self.line_buf.trim();
+                    if trimmed_s.is_empty() {
+                        // ignore empty lines
+                        continue;
+                    }
+
+                    self.record_count += 1;
+                    return Some(
+                        serde_json::from_str(trimmed_s)
+                            .map_err(|e| ArrowError::JsonError(format!("Not valid JSON: {e}"))),
+                    );
+                }
+            }
+        }
+    }
+}
+
+/// Infer the fields of a JSON file by reading the first n records of the file, with
+/// `max_read_records` controlling the maximum number of records to read.
+///
+/// If `max_read_records` is not set, the whole file is read to infer its field types.
+///
+/// Returns inferred schema and number of records read.
+///
+/// Contrary to [`infer_json_schema`], this function will seek back to the start of the `reader`.
+/// That way, the `reader` can be used immediately afterwards to create a [`Reader`].
+///
+/// # Examples
+/// ```
+/// use std::fs::File;
+/// use std::io::BufReader;
+/// use arrow_json::reader::infer_json_schema_from_seekable;
+///
+/// let file = File::open("test/data/mixed_arrays.json").unwrap();
+/// // file's cursor's offset at 0
+/// let mut reader = BufReader::new(file);
+/// let inferred_schema = infer_json_schema_from_seekable(&mut reader, None).unwrap();
+/// // file's cursor's offset automatically set at 0
+/// ```
+///
+/// [`Reader`]: super::Reader
+pub fn infer_json_schema_from_seekable<R: BufRead + Seek>(
+    mut reader: R,
+    max_read_records: Option<usize>,
+) -> Result<(Schema, usize), ArrowError> {
+    let schema = infer_json_schema(&mut reader, max_read_records);
+    // return the reader seek back to the start
+    reader.rewind()?;
+
+    schema
+}
+
+/// Infer the fields of a JSON file by reading the first n records of the buffer, with
+/// `max_read_records` controlling the maximum number of records to read.
+///
+/// If `max_read_records` is not set, the whole file is read to infer its field types.
+///
+/// Returns inferred schema and number of records read.
+///
+/// This function will not seek back to the start of the `reader`. The user has to manage the
+/// original file's cursor. This function is useful when the `reader`'s cursor is not available
+/// (does not implement [`Seek`]), such is the case for compressed streams decoders.
+///
+/// # Examples
+/// ```
+/// use std::fs::File;
+/// use std::io::{BufReader, SeekFrom, Seek};
+/// use flate2::read::GzDecoder;
+/// use arrow_json::reader::infer_json_schema;
+///
+/// let mut file = File::open("test/data/mixed_arrays.json.gz").unwrap();
+///
+/// // file's cursor's offset at 0
+/// let mut reader = BufReader::new(GzDecoder::new(&file));
+/// let inferred_schema = infer_json_schema(&mut reader, None).unwrap();
+/// // cursor's offset at end of file
+///
+/// // seek back to start so that the original file is usable again
+/// file.seek(SeekFrom::Start(0)).unwrap();
+/// ```
+pub fn infer_json_schema<R: BufRead>(
+    reader: R,
+    max_read_records: Option<usize>,
+) -> Result<(Schema, usize), ArrowError> {
+    let mut values = ValueIter::new(reader, max_read_records);
+    let schema = infer_json_schema_from_iterator(&mut values)?;
+    Ok((schema, values.record_count))
+}
+
+fn set_object_scalar_field_type(
+    field_types: &mut HashMap<String, InferredType>,
+    key: &str,
+    ftype: DataType,
+) -> Result<(), ArrowError> {
+    if InferredType::is_none_or_any(field_types.get(key)) {
+        field_types.insert(key.to_string(), InferredType::Scalar(HashSet::new()));
+    }
+
+    match field_types.get_mut(key).unwrap() {
+        InferredType::Scalar(hs) => {
+            hs.insert(ftype);
+            Ok(())
+        }
+        // in case of column contains both scalar type and scalar array type, we convert type of
+        // this column to scalar array.
+        scalar_array @ InferredType::Array(_) => {
+            let mut hs = HashSet::new();
+            hs.insert(ftype);
+            scalar_array.merge(InferredType::Scalar(hs))?;
+            Ok(())
+        }
+        t => Err(ArrowError::JsonError(format!(
+            "Expected scalar or scalar array JSON type, found: {t:?}",
+        ))),
+    }
+}
+
+fn infer_scalar_array_type(array: &[Value]) -> Result<InferredType, ArrowError> {
+    let mut hs = HashSet::new();
+
+    for v in array {
+        match v {
+            Value::Null => {}
+            Value::Number(n) => {
+                if n.is_i64() {
+                    hs.insert(DataType::Int64);
+                } else {
+                    hs.insert(DataType::Float64);
+                }
+            }
+            Value::Bool(_) => {
+                hs.insert(DataType::Boolean);
+            }
+            Value::String(_) => {
+                hs.insert(DataType::Utf8);
+            }
+            Value::Array(_) | Value::Object(_) => {
+                return Err(ArrowError::JsonError(format!(
+                    "Expected scalar value for scalar array, got: {v:?}"
+                )));
+            }
+        }
+    }
+
+    Ok(InferredType::Scalar(hs))
+}
+
+fn infer_nested_array_type(array: &[Value]) -> Result<InferredType, ArrowError> {
+    let mut inner_ele_type = InferredType::Any;
+
+    for v in array {
+        match v {
+            Value::Array(inner_array) => {
+                inner_ele_type.merge(infer_array_element_type(inner_array)?)?;
+            }
+            x => {
+                return Err(ArrowError::JsonError(format!(
+                    "Got non array element in nested array: {x:?}"
+                )));
+            }
+        }
+    }
+
+    Ok(InferredType::Array(Box::new(inner_ele_type)))
+}
+
+fn infer_struct_array_type(array: &[Value]) -> Result<InferredType, ArrowError> {
+    let mut field_types = HashMap::new();
+
+    for v in array {
+        match v {
+            Value::Object(map) => {
+                collect_field_types_from_object(&mut field_types, map)?;
+            }
+            _ => {
+                return Err(ArrowError::JsonError(format!(
+                    "Expected struct value for struct array, got: {v:?}"
+                )));
+            }
+        }
+    }
+
+    Ok(InferredType::Object(field_types))
+}
+
+fn infer_array_element_type(array: &[Value]) -> Result<InferredType, ArrowError> {
+    match array.iter().take(1).next() {
+        None => Ok(InferredType::Any), // empty array, return any type that can be updated later
+        Some(a) => match a {
+            Value::Array(_) => infer_nested_array_type(array),
+            Value::Object(_) => infer_struct_array_type(array),
+            _ => infer_scalar_array_type(array),
+        },
+    }
+}
+
+fn collect_field_types_from_object(
+    field_types: &mut HashMap<String, InferredType>,
+    map: &serde_json::map::Map<String, Value>,
+) -> Result<(), ArrowError> {
+    for (k, v) in map {
+        match v {
+            Value::Array(array) => {
+                let ele_type = infer_array_element_type(array)?;
+
+                if InferredType::is_none_or_any(field_types.get(k)) {
+                    match ele_type {
+                        InferredType::Scalar(_) => {
+                            field_types.insert(
+                                k.to_string(),
+                                InferredType::Array(Box::new(InferredType::Scalar(HashSet::new()))),
+                            );
+                        }
+                        InferredType::Object(_) => {
+                            field_types.insert(
+                                k.to_string(),
+                                InferredType::Array(Box::new(InferredType::Object(HashMap::new()))),
+                            );
+                        }
+                        InferredType::Any | InferredType::Array(_) => {
+                            // set inner type to any for nested array as well
+                            // so it can be updated properly from subsequent type merges
+                            field_types.insert(
+                                k.to_string(),
+                                InferredType::Array(Box::new(InferredType::Any)),
+                            );
+                        }
+                    }
+                }
+
+                match field_types.get_mut(k).unwrap() {
+                    InferredType::Array(inner_type) => {
+                        inner_type.merge(ele_type)?;
+                    }
+                    // in case of column contains both scalar type and scalar array type, we
+                    // convert type of this column to scalar array.
+                    field_type @ InferredType::Scalar(_) => {
+                        field_type.merge(ele_type)?;
+                        *field_type = InferredType::Array(Box::new(field_type.clone()));
+                    }
+                    t => {
+                        return Err(ArrowError::JsonError(format!(
+                            "Expected array json type, found: {t:?}",
+                        )));
+                    }
+                }
+            }
+            Value::Bool(_) => {
+                set_object_scalar_field_type(field_types, k, DataType::Boolean)?;
+            }
+            Value::Null => {
+                // we treat json as nullable by default when inferring, so just
+                // mark existence of a field if it wasn't known before
+                if !field_types.contains_key(k) {
+                    field_types.insert(k.to_string(), InferredType::Any);
+                }
+            }
+            Value::Number(n) => {
+                if n.is_i64() {
+                    set_object_scalar_field_type(field_types, k, DataType::Int64)?;
+                } else {
+                    set_object_scalar_field_type(field_types, k, DataType::Float64)?;
+                }
+            }
+            Value::String(_) => {
+                set_object_scalar_field_type(field_types, k, DataType::Utf8)?;
+            }
+            Value::Object(inner_map) => {
+                if let InferredType::Any = field_types.get(k).unwrap_or(&InferredType::Any) {
+                    field_types.insert(k.to_string(), InferredType::Object(HashMap::new()));
+                }
+                match field_types.get_mut(k).unwrap() {
+                    InferredType::Object(inner_field_types) => {
+                        collect_field_types_from_object(inner_field_types, inner_map)?;
+                    }
+                    t => {
+                        return Err(ArrowError::JsonError(format!(
+                            "Expected object json type, found: {t:?}",
+                        )));
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(())
+}
+
+/// Infer the fields of a JSON file by reading all items from the JSON Value Iterator.
+///
+/// The following type coercion logic is implemented:
+/// * `Int64` and `Float64` are converted to `Float64`
+/// * Lists and scalars are coerced to a list of a compatible scalar
+/// * All other cases are coerced to `Utf8` (String)
+///
+/// Note that the above coercion logic is different from what Spark has, where it would default to
+/// String type in case of List and Scalar values appeared in the same field.
+///
+/// The reason we diverge here is because we don't have utilities to deal with JSON data once it's
+/// interpreted as Strings. We should match Spark's behavior once we added more JSON parsing
+/// kernels in the future.
+pub fn infer_json_schema_from_iterator<I, V>(value_iter: I) -> Result<Schema, ArrowError>
+where
+    I: Iterator<Item = Result<V, ArrowError>>,
+    V: Borrow<Value>,
+{
+    let mut field_types: HashMap<String, InferredType> = HashMap::new();
+
+    for record in value_iter {
+        match record?.borrow() {
+            Value::Object(map) => {
+                collect_field_types_from_object(&mut field_types, map)?;
+            }
+            value => {
+                return Err(ArrowError::JsonError(format!(
+                    "Expected JSON record to be an object, found {value:?}"
+                )));
+            }
+        };
+    }
+
+    generate_schema(field_types)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use flate2::read::GzDecoder;
+    use std::fs::File;
+    use std::io::{BufReader, Cursor};
+
+    #[test]
+    fn test_json_infer_schema() {
+        let schema = Schema::new(vec![
+            Field::new("a", DataType::Int64, true),
+            Field::new("b", list_type_of(DataType::Float64), true),
+            Field::new("c", list_type_of(DataType::Boolean), true),
+            Field::new("d", list_type_of(DataType::Utf8), true),
+        ]);
+
+        let mut reader = BufReader::new(File::open("test/data/mixed_arrays.json").unwrap());
+        let (inferred_schema, n_rows) = infer_json_schema_from_seekable(&mut reader, None).unwrap();
+
+        assert_eq!(inferred_schema, schema);
+        assert_eq!(n_rows, 4);
+
+        let file = File::open("test/data/mixed_arrays.json.gz").unwrap();
+        let mut reader = BufReader::new(GzDecoder::new(&file));
+        let (inferred_schema, n_rows) = infer_json_schema(&mut reader, None).unwrap();
+
+        assert_eq!(inferred_schema, schema);
+        assert_eq!(n_rows, 4);
+    }
+
+    #[test]
+    fn test_row_limit() {
+        let mut reader = BufReader::new(File::open("test/data/basic.json").unwrap());
+
+        let (_, n_rows) = infer_json_schema_from_seekable(&mut reader, None).unwrap();
+        assert_eq!(n_rows, 12);
+
+        let (_, n_rows) = infer_json_schema_from_seekable(&mut reader, Some(5)).unwrap();
+        assert_eq!(n_rows, 5);
+    }
+
+    #[test]
+    fn test_json_infer_schema_nested_structs() {
+        let schema = Schema::new(vec![
+            Field::new(
+                "c1",
+                DataType::Struct(Fields::from(vec![
+                    Field::new("a", DataType::Boolean, true),
+                    Field::new(
+                        "b",
+                        DataType::Struct(vec![Field::new("c", DataType::Utf8, true)].into()),
+                        true,
+                    ),
+                ])),
+                true,
+            ),
+            Field::new("c2", DataType::Int64, true),
+            Field::new("c3", DataType::Utf8, true),
+        ]);
+
+        let inferred_schema = infer_json_schema_from_iterator(
+            vec![
+                Ok(serde_json::json!({"c1": {"a": true, "b": {"c": "text"}}, "c2": 1})),
+                Ok(serde_json::json!({"c1": {"a": false, "b": null}, "c2": 0})),
+                Ok(serde_json::json!({"c1": {"a": true, "b": {"c": "text"}}, "c3": "ok"})),
+            ]
+            .into_iter(),
+        )
+        .unwrap();
+
+        assert_eq!(inferred_schema, schema);
+    }
+
+    #[test]
+    fn test_json_infer_schema_struct_in_list() {
+        let schema = Schema::new(vec![
+            Field::new(
+                "c1",
+                list_type_of(DataType::Struct(Fields::from(vec![
+                    Field::new("a", DataType::Utf8, true),
+                    Field::new("b", DataType::Int64, true),
+                    Field::new("c", DataType::Boolean, true),
+                ]))),
+                true,
+            ),
+            Field::new("c2", DataType::Float64, true),
+            Field::new(
+                "c3",
+                // empty json array's inner types are inferred as null
+                list_type_of(DataType::Null),
+                true,
+            ),
+        ]);
+
+        let inferred_schema = infer_json_schema_from_iterator(
+            vec![
+                Ok(serde_json::json!({
+                    "c1": [{"a": "foo", "b": 100}], "c2": 1, "c3": [],
+                })),
+                Ok(serde_json::json!({
+                    "c1": [{"a": "bar", "b": 2}, {"a": "foo", "c": true}], "c2": 0, "c3": [],
+                })),
+                Ok(serde_json::json!({"c1": [], "c2": 0.5, "c3": []})),
+            ]
+            .into_iter(),
+        )
+        .unwrap();
+
+        assert_eq!(inferred_schema, schema);
+    }
+
+    #[test]
+    fn test_json_infer_schema_nested_list() {
+        let schema = Schema::new(vec![
+            Field::new("c1", list_type_of(list_type_of(DataType::Utf8)), true),
+            Field::new("c2", DataType::Float64, true),
+        ]);
+
+        let inferred_schema = infer_json_schema_from_iterator(
+            vec![
+                Ok(serde_json::json!({
+                    "c1": [],
+                    "c2": 12,
+                })),
+                Ok(serde_json::json!({
+                    "c1": [["a", "b"], ["c"]],
+                })),
+                Ok(serde_json::json!({
+                    "c1": [["foo"]],
+                    "c2": 0.11,
+                })),
+            ]
+            .into_iter(),
+        )
+        .unwrap();
+
+        assert_eq!(inferred_schema, schema);
+    }
+
+    #[test]
+    fn test_infer_json_schema_bigger_than_i64_max() {
+        let bigger_than_i64_max = (i64::MAX as i128) + 1;
+        let smaller_than_i64_min = (i64::MIN as i128) - 1;
+        let json = format!(
+            "{{ \"bigger_than_i64_max\": {}, \"smaller_than_i64_min\": {} }}",
+            bigger_than_i64_max, smaller_than_i64_min
+        );
+        let mut buf_reader = BufReader::new(json.as_bytes());
+        let (inferred_schema, _) = infer_json_schema(&mut buf_reader, Some(1)).unwrap();
+        let fields = inferred_schema.fields();
+
+        let (_, big_field) = fields.find("bigger_than_i64_max").unwrap();
+        assert_eq!(big_field.data_type(), &DataType::Float64);
+        let (_, small_field) = fields.find("smaller_than_i64_min").unwrap();
+        assert_eq!(small_field.data_type(), &DataType::Float64);
+    }
+
+    #[test]
+    fn test_coercion_scalar_and_list() {
+        assert_eq!(
+            list_type_of(DataType::Float64),
+            coerce_data_type(vec![&DataType::Float64, &list_type_of(DataType::Float64)])
+        );
+        assert_eq!(
+            list_type_of(DataType::Float64),
+            coerce_data_type(vec![&DataType::Float64, &list_type_of(DataType::Int64)])
+        );
+        assert_eq!(
+            list_type_of(DataType::Int64),
+            coerce_data_type(vec![&DataType::Int64, &list_type_of(DataType::Int64)])
+        );
+        // boolean and number are incompatible, return utf8
+        assert_eq!(
+            list_type_of(DataType::Utf8),
+            coerce_data_type(vec![&DataType::Boolean, &list_type_of(DataType::Float64)])
+        );
+    }
+
+    #[test]
+    fn test_invalid_json_infer_schema() {
+        let re = infer_json_schema_from_seekable(Cursor::new(b"}"), None);
+        assert_eq!(
+            re.err().unwrap().to_string(),
+            "Json error: Not valid JSON: expected value at line 1 column 1",
+        );
+    }
+
+    #[test]
+    fn test_null_field_inferred_as_null() {
+        let data = r#"
+            {"in":1,    "ni":null, "ns":null, "sn":"4",  "n":null, "an":[],   "na": null, "nas":null}
+            {"in":null, "ni":2,    "ns":"3",  "sn":null, "n":null, "an":null, "na": [],   "nas":["8"]}
+            {"in":1,    "ni":null, "ns":null, "sn":"4",  "n":null, "an":[],   "na": null, "nas":[]}
+        "#;
+        let (inferred_schema, _) =
+            infer_json_schema_from_seekable(Cursor::new(data), None).expect("infer");
+        let schema = Schema::new(vec![
+            Field::new("an", list_type_of(DataType::Null), true),
+            Field::new("in", DataType::Int64, true),
+            Field::new("n", DataType::Null, true),
+            Field::new("na", list_type_of(DataType::Null), true),
+            Field::new("nas", list_type_of(DataType::Utf8), true),
+            Field::new("ni", DataType::Int64, true),
+            Field::new("ns", DataType::Utf8, true),
+            Field::new("sn", DataType::Utf8, true),
+        ]);
+        assert_eq!(inferred_schema, schema);
+    }
+
+    #[test]
+    fn test_infer_from_null_then_object() {
+        let data = r#"
+            {"obj":null}
+            {"obj":{"foo":1}}
+        "#;
+        let (inferred_schema, _) =
+            infer_json_schema_from_seekable(Cursor::new(data), None).expect("infer");
+        let schema = Schema::new(vec![Field::new(
+            "obj",
+            DataType::Struct(
+                [Field::new("foo", DataType::Int64, true)]
+                    .into_iter()
+                    .collect(),
+            ),
+            true,
+        )]);
+        assert_eq!(inferred_schema, schema);
+    }
+}
diff --git a/arrow-json/src/reader/serializer.rs b/arrow-json/src/reader/serializer.rs
new file mode 100644
index 000000000000..378d77bd9155
--- /dev/null
+++ b/arrow-json/src/reader/serializer.rs
@@ -0,0 +1,424 @@
+// 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.
+
+use crate::reader::tape::TapeElement;
+use lexical_core::FormattedSize;
+use serde::ser::{
+    Impossible, SerializeMap, SerializeSeq, SerializeStruct, SerializeTuple, SerializeTupleStruct,
+};
+use serde::{Serialize, Serializer};
+
+#[derive(Debug)]
+pub struct SerializerError(String);
+
+impl std::error::Error for SerializerError {}
+
+impl std::fmt::Display for SerializerError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+impl serde::ser::Error for SerializerError {
+    fn custom<T>(msg: T) -> Self
+    where
+        T: std::fmt::Display,
+    {
+        Self(msg.to_string())
+    }
+}
+
+/// [`Serializer`] for [`TapeElement`]
+///
+/// Heavily based on <https://serde.rs/impl-serializer.html>
+pub struct TapeSerializer<'a> {
+    elements: &'a mut Vec<TapeElement>,
+
+    /// A buffer of parsed string data
+    bytes: &'a mut Vec<u8>,
+
+    /// Offsets into `data`
+    offsets: &'a mut Vec<usize>,
+}
+
+impl<'a> TapeSerializer<'a> {
+    pub fn new(
+        elements: &'a mut Vec<TapeElement>,
+        bytes: &'a mut Vec<u8>,
+        offsets: &'a mut Vec<usize>,
+    ) -> Self {
+        Self {
+            elements,
+            bytes,
+            offsets,
+        }
+    }
+
+    fn serialize_number(&mut self, v: &[u8]) {
+        self.bytes.extend_from_slice(v);
+        let idx = self.offsets.len() - 1;
+        self.elements.push(TapeElement::Number(idx as _));
+        self.offsets.push(self.bytes.len());
+    }
+}
+
+impl<'a, 'b> Serializer for &'a mut TapeSerializer<'b> {
+    type Ok = ();
+
+    type Error = SerializerError;
+
+    type SerializeSeq = ListSerializer<'a, 'b>;
+    type SerializeTuple = ListSerializer<'a, 'b>;
+    type SerializeTupleStruct = ListSerializer<'a, 'b>;
+    type SerializeTupleVariant = Impossible<(), SerializerError>;
+    type SerializeMap = ObjectSerializer<'a, 'b>;
+    type SerializeStruct = ObjectSerializer<'a, 'b>;
+    type SerializeStructVariant = Impossible<(), SerializerError>;
+
+    fn serialize_bool(self, v: bool) -> Result<(), SerializerError> {
+        self.elements.push(match v {
+            true => TapeElement::True,
+            false => TapeElement::False,
+        });
+        Ok(())
+    }
+
+    fn serialize_i8(self, v: i8) -> Result<(), SerializerError> {
+        self.serialize_i32(v as _)
+    }
+
+    fn serialize_i16(self, v: i16) -> Result<(), SerializerError> {
+        self.serialize_i32(v as _)
+    }
+
+    fn serialize_i32(self, v: i32) -> Result<(), SerializerError> {
+        self.elements.push(TapeElement::I32(v));
+        Ok(())
+    }
+
+    fn serialize_i64(self, v: i64) -> Result<(), SerializerError> {
+        let low = v as i32;
+        let high = (v >> 32) as i32;
+        self.elements.push(TapeElement::I64(high));
+        self.elements.push(TapeElement::I32(low));
+        Ok(())
+    }
+
+    fn serialize_u8(self, v: u8) -> Result<(), SerializerError> {
+        self.serialize_i32(v as _)
+    }
+
+    fn serialize_u16(self, v: u16) -> Result<(), SerializerError> {
+        self.serialize_i32(v as _)
+    }
+
+    fn serialize_u32(self, v: u32) -> Result<(), SerializerError> {
+        match i32::try_from(v) {
+            Ok(v) => self.serialize_i32(v),
+            Err(_) => self.serialize_i64(v as _),
+        }
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<(), SerializerError> {
+        match i64::try_from(v) {
+            Ok(v) => self.serialize_i64(v),
+            Err(_) => {
+                let mut buffer = [0_u8; u64::FORMATTED_SIZE];
+                let s = lexical_core::write(v, &mut buffer);
+                self.serialize_number(s);
+                Ok(())
+            }
+        }
+    }
+
+    fn serialize_f32(self, v: f32) -> Result<(), SerializerError> {
+        self.elements.push(TapeElement::F32(v.to_bits()));
+        Ok(())
+    }
+
+    fn serialize_f64(self, v: f64) -> Result<(), SerializerError> {
+        let bits = v.to_bits();
+        self.elements.push(TapeElement::F64((bits >> 32) as u32));
+        self.elements.push(TapeElement::F32(bits as u32));
+        Ok(())
+    }
+
+    fn serialize_char(self, v: char) -> Result<(), SerializerError> {
+        self.serialize_str(&v.to_string())
+    }
+
+    fn serialize_str(self, v: &str) -> Result<(), SerializerError> {
+        self.serialize_bytes(v.as_bytes())
+    }
+
+    fn serialize_bytes(self, v: &[u8]) -> Result<(), SerializerError> {
+        self.bytes.extend_from_slice(v);
+        let idx = self.offsets.len() - 1;
+        self.elements.push(TapeElement::String(idx as _));
+        self.offsets.push(self.bytes.len());
+        Ok(())
+    }
+
+    fn serialize_none(self) -> Result<(), SerializerError> {
+        self.serialize_unit()
+    }
+
+    fn serialize_some<T>(self, value: &T) -> Result<(), SerializerError>
+    where
+        T: ?Sized + Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_unit(self) -> Result<(), SerializerError> {
+        self.elements.push(TapeElement::Null);
+        Ok(())
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<(), SerializerError> {
+        self.serialize_unit()
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+    ) -> Result<(), SerializerError> {
+        self.serialize_str(variant)
+    }
+
+    fn serialize_newtype_struct<T>(
+        self,
+        _name: &'static str,
+        value: &T,
+    ) -> Result<(), SerializerError>
+    where
+        T: ?Sized + Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_variant<T>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        value: &T,
+    ) -> Result<(), SerializerError>
+    where
+        T: ?Sized + Serialize,
+    {
+        let mut serializer = self.serialize_map(Some(1))?;
+        serializer.serialize_key(variant)?;
+        serializer.serialize_value(value)?;
+        serializer.finish();
+        Ok(())
+    }
+
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, SerializerError> {
+        Ok(ListSerializer::new(self))
+    }
+
+    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, SerializerError> {
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleStruct, SerializerError> {
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant, SerializerError> {
+        Err(SerializerError(format!(
+            "serializing tuple variants is not currently supported: {name}::{variant}"
+        )))
+    }
+
+    // Maps are represented in JSON as `{ K: V, K: V, ... }`.
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, SerializerError> {
+        Ok(ObjectSerializer::new(self))
+    }
+
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeStruct, SerializerError> {
+        self.serialize_map(Some(len))
+    }
+
+    fn serialize_struct_variant(
+        self,
+        name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, SerializerError> {
+        Err(SerializerError(format!(
+            "serializing struct variants is not currently supported: {name}::{variant}"
+        )))
+    }
+}
+
+pub struct ObjectSerializer<'a, 'b> {
+    serializer: &'a mut TapeSerializer<'b>,
+    start: usize,
+}
+
+impl<'a, 'b> ObjectSerializer<'a, 'b> {
+    fn new(serializer: &'a mut TapeSerializer<'b>) -> Self {
+        let start = serializer.elements.len();
+        serializer.elements.push(TapeElement::StartObject(0));
+        Self { serializer, start }
+    }
+
+    fn finish(self) {
+        let end = self.serializer.elements.len() as _;
+        self.serializer.elements[self.start] = TapeElement::StartObject(end);
+
+        let end = TapeElement::EndObject(self.start as _);
+        self.serializer.elements.push(end);
+    }
+}
+
+impl<'a, 'b> SerializeMap for ObjectSerializer<'a, 'b> {
+    type Ok = ();
+    type Error = SerializerError;
+
+    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        key.serialize(&mut *self.serializer)
+    }
+
+    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        value.serialize(&mut *self.serializer)
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        self.finish();
+        Ok(())
+    }
+}
+
+impl<'a, 'b> SerializeStruct for ObjectSerializer<'a, 'b> {
+    type Ok = ();
+    type Error = SerializerError;
+
+    fn serialize_field<T: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        key.serialize(&mut *self.serializer)?;
+        value.serialize(&mut *self.serializer)
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        self.finish();
+        Ok(())
+    }
+}
+
+pub struct ListSerializer<'a, 'b> {
+    serializer: &'a mut TapeSerializer<'b>,
+    start: usize,
+}
+
+impl<'a, 'b> ListSerializer<'a, 'b> {
+    fn new(serializer: &'a mut TapeSerializer<'b>) -> Self {
+        let start = serializer.elements.len();
+        serializer.elements.push(TapeElement::StartList(0));
+        Self { serializer, start }
+    }
+
+    fn finish(self) {
+        let end = self.serializer.elements.len() as _;
+        self.serializer.elements[self.start] = TapeElement::StartList(end);
+
+        let end = TapeElement::EndList(self.start as _);
+        self.serializer.elements.push(end);
+    }
+}
+
+impl<'a, 'b> SerializeSeq for ListSerializer<'a, 'b> {
+    type Ok = ();
+    type Error = SerializerError;
+
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        value.serialize(&mut *self.serializer)
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        self.finish();
+        Ok(())
+    }
+}
+
+impl<'a, 'b> SerializeTuple for ListSerializer<'a, 'b> {
+    type Ok = ();
+    type Error = SerializerError;
+
+    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        value.serialize(&mut *self.serializer)
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        self.finish();
+        Ok(())
+    }
+}
+
+impl<'a, 'b> SerializeTupleStruct for ListSerializer<'a, 'b> {
+    type Ok = ();
+    type Error = SerializerError;
+
+    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        value.serialize(&mut *self.serializer)
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        self.finish();
+        Ok(())
+    }
+}
diff --git a/arrow-json/src/reader/string_array.rs b/arrow-json/src/reader/string_array.rs
new file mode 100644
index 000000000000..5ab4d09d5d63
--- /dev/null
+++ b/arrow-json/src/reader/string_array.rs
@@ -0,0 +1,129 @@
+// 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.
+
+use arrow_array::builder::GenericStringBuilder;
+use arrow_array::{Array, GenericStringArray, OffsetSizeTrait};
+use arrow_data::ArrayData;
+use arrow_schema::ArrowError;
+use std::marker::PhantomData;
+
+use crate::reader::tape::{Tape, TapeElement};
+use crate::reader::ArrayDecoder;
+
+const TRUE: &str = "true";
+const FALSE: &str = "false";
+
+pub struct StringArrayDecoder<O: OffsetSizeTrait> {
+    coerce_primitive: bool,
+    phantom: PhantomData<O>,
+}
+
+impl<O: OffsetSizeTrait> StringArrayDecoder<O> {
+    pub fn new(coerce_primitive: bool) -> Self {
+        Self {
+            coerce_primitive,
+            phantom: Default::default(),
+        }
+    }
+}
+
+impl<O: OffsetSizeTrait> ArrayDecoder for StringArrayDecoder<O> {
+    fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayData, ArrowError> {
+        let coerce_primitive = self.coerce_primitive;
+
+        let mut data_capacity = 0;
+        for p in pos {
+            match tape.get(*p) {
+                TapeElement::String(idx) => {
+                    data_capacity += tape.get_string(idx).len();
+                }
+                TapeElement::Null => {}
+                TapeElement::True if coerce_primitive => {
+                    data_capacity += TRUE.len();
+                }
+                TapeElement::False if coerce_primitive => {
+                    data_capacity += FALSE.len();
+                }
+                TapeElement::Number(idx) if coerce_primitive => {
+                    data_capacity += tape.get_string(idx).len();
+                }
+                TapeElement::I64(_)
+                | TapeElement::I32(_)
+                | TapeElement::F64(_)
+                | TapeElement::F32(_)
+                    if coerce_primitive =>
+                {
+                    // An arbitrary estimate
+                    data_capacity += 10;
+                }
+                _ => {
+                    return Err(tape.error(*p, "string"));
+                }
+            }
+        }
+
+        if O::from_usize(data_capacity).is_none() {
+            return Err(ArrowError::JsonError(format!(
+                "offset overflow decoding {}",
+                GenericStringArray::<O>::DATA_TYPE
+            )));
+        }
+
+        let mut builder = GenericStringBuilder::<O>::with_capacity(pos.len(), data_capacity);
+
+        for p in pos {
+            match tape.get(*p) {
+                TapeElement::String(idx) => {
+                    builder.append_value(tape.get_string(idx));
+                }
+                TapeElement::Null => builder.append_null(),
+                TapeElement::True if coerce_primitive => {
+                    builder.append_value(TRUE);
+                }
+                TapeElement::False if coerce_primitive => {
+                    builder.append_value(FALSE);
+                }
+                TapeElement::Number(idx) if coerce_primitive => {
+                    builder.append_value(tape.get_string(idx));
+                }
+                TapeElement::I64(high) if coerce_primitive => match tape.get(p + 1) {
+                    TapeElement::I32(low) => {
+                        let val = (high as i64) << 32 | (low as u32) as i64;
+                        builder.append_value(val.to_string());
+                    }
+                    _ => unreachable!(),
+                },
+                TapeElement::I32(n) if coerce_primitive => {
+                    builder.append_value(n.to_string());
+                }
+                TapeElement::F32(n) if coerce_primitive => {
+                    builder.append_value(n.to_string());
+                }
+                TapeElement::F64(high) if coerce_primitive => match tape.get(p + 1) {
+                    TapeElement::F32(low) => {
+                        let val = f64::from_bits((high as u64) << 32 | low as u64);
+                        builder.append_value(val.to_string());
+                    }
+                    _ => unreachable!(),
+                },
+                _ => unreachable!(),
+            }
+        }
+
+        Ok(builder.finish().into_data())
+    }
+}
diff --git a/arrow-json/src/reader/struct_array.rs b/arrow-json/src/reader/struct_array.rs
new file mode 100644
index 000000000000..6c805591d390
--- /dev/null
+++ b/arrow-json/src/reader/struct_array.rs
@@ -0,0 +1,161 @@
+// 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.
+
+use crate::reader::tape::{Tape, TapeElement};
+use crate::reader::{make_decoder, ArrayDecoder};
+use arrow_array::builder::BooleanBufferBuilder;
+use arrow_buffer::buffer::NullBuffer;
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType, Fields};
+
+pub struct StructArrayDecoder {
+    data_type: DataType,
+    decoders: Vec<Box<dyn ArrayDecoder>>,
+    strict_mode: bool,
+    is_nullable: bool,
+}
+
+impl StructArrayDecoder {
+    pub fn new(
+        data_type: DataType,
+        coerce_primitive: bool,
+        strict_mode: bool,
+        is_nullable: bool,
+    ) -> Result<Self, ArrowError> {
+        let decoders = struct_fields(&data_type)
+            .iter()
+            .map(|f| {
+                // If this struct nullable, need to permit nullability in child array
+                // StructArrayDecoder::decode verifies that if the child is not nullable
+                // it doesn't contain any nulls not masked by its parent
+                let nullable = f.is_nullable() || is_nullable;
+                make_decoder(
+                    f.data_type().clone(),
+                    coerce_primitive,
+                    strict_mode,
+                    nullable,
+                )
+            })
+            .collect::<Result<Vec<_>, ArrowError>>()?;
+
+        Ok(Self {
+            data_type,
+            decoders,
+            strict_mode,
+            is_nullable,
+        })
+    }
+}
+
+impl ArrayDecoder for StructArrayDecoder {
+    fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayData, ArrowError> {
+        let fields = struct_fields(&self.data_type);
+        let mut child_pos: Vec<_> = (0..fields.len()).map(|_| vec![0; pos.len()]).collect();
+
+        let mut nulls = self
+            .is_nullable
+            .then(|| BooleanBufferBuilder::new(pos.len()));
+
+        for (row, p) in pos.iter().enumerate() {
+            let end_idx = match (tape.get(*p), nulls.as_mut()) {
+                (TapeElement::StartObject(end_idx), None) => end_idx,
+                (TapeElement::StartObject(end_idx), Some(nulls)) => {
+                    nulls.append(true);
+                    end_idx
+                }
+                (TapeElement::Null, Some(nulls)) => {
+                    nulls.append(false);
+                    continue;
+                }
+                _ => return Err(tape.error(*p, "{")),
+            };
+
+            let mut cur_idx = *p + 1;
+            while cur_idx < end_idx {
+                // Read field name
+                let field_name = match tape.get(cur_idx) {
+                    TapeElement::String(s) => tape.get_string(s),
+                    _ => return Err(tape.error(cur_idx, "field name")),
+                };
+
+                // Update child pos if match found
+                match fields.iter().position(|x| x.name() == field_name) {
+                    Some(field_idx) => child_pos[field_idx][row] = cur_idx + 1,
+                    None => {
+                        if self.strict_mode {
+                            return Err(ArrowError::JsonError(format!(
+                                "column '{}' missing from schema",
+                                field_name
+                            )));
+                        }
+                    }
+                }
+
+                // Advance to next field
+                cur_idx = tape.next(cur_idx + 1, "field value")?;
+            }
+        }
+
+        let child_data = self
+            .decoders
+            .iter_mut()
+            .zip(child_pos)
+            .zip(fields)
+            .map(|((d, pos), f)| {
+                d.decode(tape, &pos).map_err(|e| match e {
+                    ArrowError::JsonError(s) => {
+                        ArrowError::JsonError(format!("whilst decoding field '{}': {s}", f.name()))
+                    }
+                    e => e,
+                })
+            })
+            .collect::<Result<Vec<_>, ArrowError>>()?;
+
+        let nulls = nulls.as_mut().map(|x| NullBuffer::new(x.finish()));
+
+        for (c, f) in child_data.iter().zip(fields) {
+            // Sanity check
+            assert_eq!(c.len(), pos.len());
+            if let Some(a) = c.nulls() {
+                let nulls_valid =
+                    f.is_nullable() || nulls.as_ref().map(|n| n.contains(a)).unwrap_or_default();
+
+                if !nulls_valid {
+                    return Err(ArrowError::JsonError(format!(
+                        "Encountered unmasked nulls in non-nullable StructArray child: {f}"
+                    )));
+                }
+            }
+        }
+
+        let data = ArrayDataBuilder::new(self.data_type.clone())
+            .len(pos.len())
+            .nulls(nulls)
+            .child_data(child_data);
+
+        // Safety
+        // Validated lengths above
+        Ok(unsafe { data.build_unchecked() })
+    }
+}
+
+fn struct_fields(data_type: &DataType) -> &Fields {
+    match &data_type {
+        DataType::Struct(f) => f,
+        _ => unreachable!(),
+    }
+}
diff --git a/arrow-json/src/reader/tape.rs b/arrow-json/src/reader/tape.rs
new file mode 100644
index 000000000000..c783f6a51022
--- /dev/null
+++ b/arrow-json/src/reader/tape.rs
@@ -0,0 +1,911 @@
+// 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.
+
+use crate::reader::serializer::TapeSerializer;
+use arrow_schema::ArrowError;
+use serde::Serialize;
+use std::fmt::Write;
+
+/// We decode JSON to a flattened tape representation,
+/// allowing for efficient traversal of the JSON data
+///
+/// This approach is inspired by [simdjson]
+///
+/// Uses `u32` for offsets to ensure `TapeElement` is 64-bits. A future
+/// iteration may increase this to a custom `u56` type.
+///
+/// [simdjson]: https://github.com/simdjson/simdjson/blob/master/doc/tape.md
+#[derive(Debug, Copy, Clone, PartialEq, Eq)]
+pub enum TapeElement {
+    /// The start of an object, i.e. `{`
+    ///
+    /// Contains the offset of the corresponding [`Self::EndObject`]
+    StartObject(u32),
+    /// The end of an object, i.e. `}`
+    ///
+    /// Contains the offset of the corresponding [`Self::StartObject`]
+    EndObject(u32),
+    /// The start of a list , i.e. `[`
+    ///
+    /// Contains the offset of the corresponding [`Self::EndList`]
+    StartList(u32),
+    /// The end of a list , i.e. `]`
+    ///
+    /// Contains the offset of the corresponding [`Self::StartList`]
+    EndList(u32),
+    /// A string value
+    ///
+    /// Contains the offset into the [`Tape`] string data
+    String(u32),
+    /// A numeric value
+    ///
+    /// Contains the offset into the [`Tape`] string data
+    Number(u32),
+
+    /// The high bits of a i64
+    ///
+    /// Followed by [`Self::I32`] containing the low bits
+    I64(i32),
+
+    /// A 32-bit signed integer
+    ///
+    /// May be preceded by [`Self::I64`] containing high bits
+    I32(i32),
+
+    /// The high bits of a 64-bit float
+    ///
+    /// Followed by [`Self::F32`] containing the low bits
+    F64(u32),
+
+    /// A 32-bit float or the low-bits of a 64-bit float if preceded by [`Self::F64`]
+    F32(u32),
+
+    /// A true literal
+    True,
+    /// A false literal
+    False,
+    /// A null literal
+    Null,
+}
+
+/// A decoded JSON tape
+///
+/// String and numeric data is stored alongside an array of [`TapeElement`]
+///
+/// The first element is always [`TapeElement::Null`]
+///
+/// This approach to decoding JSON is inspired by [simdjson]
+///
+/// [simdjson]: https://github.com/simdjson/simdjson/blob/master/doc/tape.md
+#[derive(Debug)]
+pub struct Tape<'a> {
+    elements: &'a [TapeElement],
+    strings: &'a str,
+    string_offsets: &'a [usize],
+    num_rows: usize,
+}
+
+impl<'a> Tape<'a> {
+    /// Returns the string for the given string index
+    #[inline]
+    pub fn get_string(&self, idx: u32) -> &'a str {
+        let end_offset = self.string_offsets[idx as usize + 1];
+        let start_offset = self.string_offsets[idx as usize];
+        // SAFETY:
+        // Verified offsets
+        unsafe { self.strings.get_unchecked(start_offset..end_offset) }
+    }
+
+    /// Returns the tape element at `idx`
+    pub fn get(&self, idx: u32) -> TapeElement {
+        self.elements[idx as usize]
+    }
+
+    /// Returns the index of the next field at the same level as `cur_idx`
+    ///
+    /// Return an error if `cur_idx` is not the start of a field
+    pub fn next(&self, cur_idx: u32, expected: &str) -> Result<u32, ArrowError> {
+        match self.get(cur_idx) {
+            TapeElement::String(_)
+            | TapeElement::Number(_)
+            | TapeElement::True
+            | TapeElement::False
+            | TapeElement::Null
+            | TapeElement::I32(_)
+            | TapeElement::F32(_) => Ok(cur_idx + 1),
+            TapeElement::I64(_) | TapeElement::F64(_) => Ok(cur_idx + 2),
+            TapeElement::StartList(end_idx) => Ok(end_idx + 1),
+            TapeElement::StartObject(end_idx) => Ok(end_idx + 1),
+            TapeElement::EndObject(_) | TapeElement::EndList(_) => {
+                Err(self.error(cur_idx, expected))
+            }
+        }
+    }
+
+    /// Returns the number of rows
+    pub fn num_rows(&self) -> usize {
+        self.num_rows
+    }
+
+    /// Serialize the tape element at index `idx` to `out` returning the next field index
+    fn serialize(&self, out: &mut String, idx: u32) -> u32 {
+        match self.get(idx) {
+            TapeElement::StartObject(end) => {
+                out.push('{');
+                let mut cur_idx = idx + 1;
+                while cur_idx < end {
+                    cur_idx = self.serialize(out, cur_idx);
+                    out.push_str(": ");
+                    cur_idx = self.serialize(out, cur_idx);
+                }
+                out.push('}');
+                return end + 1;
+            }
+            TapeElement::EndObject(_) => out.push('}'),
+            TapeElement::StartList(end) => {
+                out.push('[');
+                let mut cur_idx = idx + 1;
+                while cur_idx < end {
+                    cur_idx = self.serialize(out, cur_idx);
+                    if cur_idx < end {
+                        out.push_str(", ");
+                    }
+                }
+                out.push(']');
+                return end + 1;
+            }
+            TapeElement::EndList(_) => out.push(']'),
+            TapeElement::String(s) => {
+                out.push('"');
+                out.push_str(self.get_string(s));
+                out.push('"')
+            }
+            TapeElement::Number(n) => out.push_str(self.get_string(n)),
+            TapeElement::True => out.push_str("true"),
+            TapeElement::False => out.push_str("false"),
+            TapeElement::Null => out.push_str("null"),
+            TapeElement::I64(high) => match self.get(idx + 1) {
+                TapeElement::I32(low) => {
+                    let val = (high as i64) << 32 | (low as u32) as i64;
+                    let _ = write!(out, "{val}");
+                    return idx + 2;
+                }
+                _ => unreachable!(),
+            },
+            TapeElement::I32(val) => {
+                let _ = write!(out, "{val}");
+            }
+            TapeElement::F64(high) => match self.get(idx + 1) {
+                TapeElement::F32(low) => {
+                    let val = f64::from_bits((high as u64) << 32 | low as u64);
+                    let _ = write!(out, "{val}");
+                    return idx + 2;
+                }
+                _ => unreachable!(),
+            },
+            TapeElement::F32(val) => {
+                let _ = write!(out, "{}", f32::from_bits(val));
+            }
+        }
+        idx + 1
+    }
+
+    /// Returns an error reading index `idx`
+    pub fn error(&self, idx: u32, expected: &str) -> ArrowError {
+        let mut out = String::with_capacity(64);
+        self.serialize(&mut out, idx);
+        ArrowError::JsonError(format!("expected {expected} got {out}"))
+    }
+}
+
+/// States based on <https://www.json.org/json-en.html>
+#[derive(Debug, Copy, Clone)]
+enum DecoderState {
+    /// Decoding an object
+    ///
+    /// Contains index of start [`TapeElement::StartObject`]
+    Object(u32),
+    /// Decoding a list
+    ///
+    /// Contains index of start [`TapeElement::StartList`]
+    List(u32),
+    String,
+    Value,
+    Number,
+    Colon,
+    Escape,
+    /// A unicode escape sequence,
+    ///
+    /// Consists of a `(low surrogate, high surrogate, decoded length)`
+    Unicode(u16, u16, u8),
+    /// A boolean or null literal
+    ///
+    /// Consists of `(literal, decoded length)`
+    Literal(Literal, u8),
+}
+
+impl DecoderState {
+    fn as_str(&self) -> &'static str {
+        match self {
+            DecoderState::Object(_) => "object",
+            DecoderState::List(_) => "list",
+            DecoderState::String => "string",
+            DecoderState::Value => "value",
+            DecoderState::Number => "number",
+            DecoderState::Colon => "colon",
+            DecoderState::Escape => "escape",
+            DecoderState::Unicode(_, _, _) => "unicode literal",
+            DecoderState::Literal(d, _) => d.as_str(),
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone)]
+enum Literal {
+    Null,
+    True,
+    False,
+}
+
+impl Literal {
+    fn element(&self) -> TapeElement {
+        match self {
+            Literal::Null => TapeElement::Null,
+            Literal::True => TapeElement::True,
+            Literal::False => TapeElement::False,
+        }
+    }
+
+    fn as_str(&self) -> &'static str {
+        match self {
+            Literal::Null => "null",
+            Literal::True => "true",
+            Literal::False => "false",
+        }
+    }
+
+    fn bytes(&self) -> &'static [u8] {
+        self.as_str().as_bytes()
+    }
+}
+
+/// Evaluates to the next element in the iterator or breaks the current loop
+macro_rules! next {
+    ($next:ident) => {
+        match $next.next() {
+            Some(b) => b,
+            None => break,
+        }
+    };
+}
+
+/// Implements a state machine for decoding JSON to a tape
+pub struct TapeDecoder {
+    elements: Vec<TapeElement>,
+
+    /// The number of rows decoded, including any in progress if `!stack.is_empty()`
+    cur_row: usize,
+
+    /// Number of rows to read per batch
+    batch_size: usize,
+
+    /// A buffer of parsed string data
+    ///
+    /// Note: if part way through a record, i.e. `stack` is not empty,
+    /// this may contain truncated UTF-8 data
+    bytes: Vec<u8>,
+
+    /// Offsets into `data`
+    offsets: Vec<usize>,
+
+    /// A stack of [`DecoderState`]
+    stack: Vec<DecoderState>,
+}
+
+impl TapeDecoder {
+    /// Create a new [`TapeDecoder`] with the provided batch size
+    /// and an estimated number of fields in each row
+    pub fn new(batch_size: usize, num_fields: usize) -> Self {
+        let tokens_per_row = 2 + num_fields * 2;
+        let mut offsets = Vec::with_capacity(batch_size * (num_fields * 2) + 1);
+        offsets.push(0);
+
+        let mut elements = Vec::with_capacity(batch_size * tokens_per_row);
+        elements.push(TapeElement::Null);
+
+        Self {
+            offsets,
+            elements,
+            batch_size,
+            cur_row: 0,
+            bytes: Vec::with_capacity(num_fields * 2 * 8),
+            stack: Vec::with_capacity(10),
+        }
+    }
+
+    pub fn decode(&mut self, buf: &[u8]) -> Result<usize, ArrowError> {
+        let mut iter = BufIter::new(buf);
+
+        while !iter.is_empty() {
+            let state = match self.stack.last_mut() {
+                Some(l) => l,
+                None => {
+                    iter.skip_whitespace();
+                    if iter.is_empty() || self.cur_row >= self.batch_size {
+                        break;
+                    }
+
+                    // Start of row
+                    self.cur_row += 1;
+                    self.stack.push(DecoderState::Value);
+                    self.stack.last_mut().unwrap()
+                }
+            };
+
+            match state {
+                // Decoding an object
+                DecoderState::Object(start_idx) => {
+                    iter.advance_until(|b| !json_whitespace(b) && b != b',');
+                    match next!(iter) {
+                        b'"' => {
+                            self.stack.push(DecoderState::Value);
+                            self.stack.push(DecoderState::Colon);
+                            self.stack.push(DecoderState::String);
+                        }
+                        b'}' => {
+                            let start_idx = *start_idx;
+                            let end_idx = self.elements.len() as u32;
+                            self.elements[start_idx as usize] = TapeElement::StartObject(end_idx);
+                            self.elements.push(TapeElement::EndObject(start_idx));
+                            self.stack.pop();
+                        }
+                        b => return Err(err(b, "parsing object")),
+                    }
+                }
+                // Decoding a list
+                DecoderState::List(start_idx) => {
+                    iter.advance_until(|b| !json_whitespace(b) && b != b',');
+                    match iter.peek() {
+                        Some(b']') => {
+                            iter.next();
+                            let start_idx = *start_idx;
+                            let end_idx = self.elements.len() as u32;
+                            self.elements[start_idx as usize] = TapeElement::StartList(end_idx);
+                            self.elements.push(TapeElement::EndList(start_idx));
+                            self.stack.pop();
+                        }
+                        Some(_) => self.stack.push(DecoderState::Value),
+                        None => break,
+                    }
+                }
+                // Decoding a string
+                DecoderState::String => {
+                    let s = iter.advance_until(|b| matches!(b, b'\\' | b'"'));
+                    self.bytes.extend_from_slice(s);
+
+                    match next!(iter) {
+                        b'\\' => self.stack.push(DecoderState::Escape),
+                        b'"' => {
+                            let idx = self.offsets.len() - 1;
+                            self.elements.push(TapeElement::String(idx as _));
+                            self.offsets.push(self.bytes.len());
+                            self.stack.pop();
+                        }
+                        b => unreachable!("{}", b),
+                    }
+                }
+                state @ DecoderState::Value => {
+                    iter.skip_whitespace();
+                    *state = match next!(iter) {
+                        b'"' => DecoderState::String,
+                        b @ b'-' | b @ b'0'..=b'9' => {
+                            self.bytes.push(b);
+                            DecoderState::Number
+                        }
+                        b'n' => DecoderState::Literal(Literal::Null, 1),
+                        b'f' => DecoderState::Literal(Literal::False, 1),
+                        b't' => DecoderState::Literal(Literal::True, 1),
+                        b'[' => {
+                            let idx = self.elements.len() as u32;
+                            self.elements.push(TapeElement::StartList(u32::MAX));
+                            DecoderState::List(idx)
+                        }
+                        b'{' => {
+                            let idx = self.elements.len() as u32;
+                            self.elements.push(TapeElement::StartObject(u32::MAX));
+                            DecoderState::Object(idx)
+                        }
+                        b => return Err(err(b, "parsing value")),
+                    };
+                }
+                DecoderState::Number => {
+                    let s = iter.advance_until(|b| {
+                        !matches!(b, b'0'..=b'9' | b'-' | b'+' | b'.' | b'e' | b'E')
+                    });
+                    self.bytes.extend_from_slice(s);
+
+                    if !iter.is_empty() {
+                        self.stack.pop();
+                        let idx = self.offsets.len() - 1;
+                        self.elements.push(TapeElement::Number(idx as _));
+                        self.offsets.push(self.bytes.len());
+                    }
+                }
+                DecoderState::Colon => {
+                    iter.skip_whitespace();
+                    match next!(iter) {
+                        b':' => self.stack.pop(),
+                        b => return Err(err(b, "parsing colon")),
+                    };
+                }
+                DecoderState::Literal(literal, idx) => {
+                    let bytes = literal.bytes();
+                    let expected = bytes.iter().skip(*idx as usize).copied();
+                    for (expected, b) in expected.zip(&mut iter) {
+                        match b == expected {
+                            true => *idx += 1,
+                            false => return Err(err(b, "parsing literal")),
+                        }
+                    }
+                    if *idx == bytes.len() as u8 {
+                        let element = literal.element();
+                        self.stack.pop();
+                        self.elements.push(element);
+                    }
+                }
+                DecoderState::Escape => {
+                    let v = match next!(iter) {
+                        b'u' => {
+                            self.stack.pop();
+                            self.stack.push(DecoderState::Unicode(0, 0, 0));
+                            continue;
+                        }
+                        b'"' => b'"',
+                        b'\\' => b'\\',
+                        b'/' => b'/',
+                        b'b' => 8,  // BS
+                        b'f' => 12, // FF
+                        b'n' => b'\n',
+                        b'r' => b'\r',
+                        b't' => b'\t',
+                        b => return Err(err(b, "parsing escape sequence")),
+                    };
+
+                    self.stack.pop();
+                    self.bytes.push(v);
+                }
+                // Parse a unicode escape sequence
+                DecoderState::Unicode(high, low, idx) => loop {
+                    match *idx {
+                        0..=3 => *high = *high << 4 | parse_hex(next!(iter))? as u16,
+                        4 => {
+                            if let Some(c) = char::from_u32(*high as u32) {
+                                write_char(c, &mut self.bytes);
+                                self.stack.pop();
+                                break;
+                            }
+
+                            match next!(iter) {
+                                b'\\' => {}
+                                b => return Err(err(b, "parsing surrogate pair escape")),
+                            }
+                        }
+                        5 => match next!(iter) {
+                            b'u' => {}
+                            b => return Err(err(b, "parsing surrogate pair unicode")),
+                        },
+                        6..=9 => *low = *low << 4 | parse_hex(next!(iter))? as u16,
+                        _ => {
+                            let c = char_from_surrogate_pair(*low, *high)?;
+                            write_char(c, &mut self.bytes);
+                            self.stack.pop();
+                            break;
+                        }
+                    }
+                    *idx += 1;
+                },
+            }
+        }
+
+        Ok(buf.len() - iter.len())
+    }
+
+    /// Writes any type that implements [`Serialize`] into this [`TapeDecoder`]
+    pub fn serialize<S: Serialize>(&mut self, rows: &[S]) -> Result<(), ArrowError> {
+        if let Some(b) = self.stack.last() {
+            return Err(ArrowError::JsonError(format!(
+                "Cannot serialize to tape containing partial decode state {}",
+                b.as_str()
+            )));
+        }
+
+        let mut serializer =
+            TapeSerializer::new(&mut self.elements, &mut self.bytes, &mut self.offsets);
+
+        rows.iter()
+            .try_for_each(|row| row.serialize(&mut serializer))
+            .map_err(|e| ArrowError::JsonError(e.to_string()))?;
+
+        self.cur_row += rows.len();
+
+        Ok(())
+    }
+
+    /// Finishes the current [`Tape`]
+    pub fn finish(&self) -> Result<Tape<'_>, ArrowError> {
+        if let Some(b) = self.stack.last() {
+            return Err(ArrowError::JsonError(format!(
+                "Truncated record whilst reading {}",
+                b.as_str()
+            )));
+        }
+
+        if self.offsets.len() >= u32::MAX as usize {
+            return Err(ArrowError::JsonError(format!("Encountered more than {} bytes of string data, consider using a smaller batch size", u32::MAX)));
+        }
+
+        if self.offsets.len() >= u32::MAX as usize {
+            return Err(ArrowError::JsonError(format!(
+                "Encountered more than {} JSON elements, consider using a smaller batch size",
+                u32::MAX
+            )));
+        }
+
+        // Sanity check
+        assert_eq!(
+            self.offsets.last().copied().unwrap_or_default(),
+            self.bytes.len()
+        );
+
+        let strings = std::str::from_utf8(&self.bytes)
+            .map_err(|_| ArrowError::JsonError("Encountered non-UTF-8 data".to_string()))?;
+
+        for offset in self.offsets.iter().copied() {
+            if !strings.is_char_boundary(offset) {
+                return Err(ArrowError::JsonError(
+                    "Encountered truncated UTF-8 sequence".to_string(),
+                ));
+            }
+        }
+
+        Ok(Tape {
+            strings,
+            elements: &self.elements,
+            string_offsets: &self.offsets,
+            num_rows: self.cur_row,
+        })
+    }
+
+    /// Clears this [`TapeDecoder`] in preparation to read the next batch
+    pub fn clear(&mut self) {
+        assert!(self.stack.is_empty());
+
+        self.cur_row = 0;
+        self.bytes.clear();
+        self.elements.clear();
+        self.elements.push(TapeElement::Null);
+        self.offsets.clear();
+        self.offsets.push(0);
+    }
+}
+
+/// A wrapper around a slice iterator that provides some helper functionality
+struct BufIter<'a>(std::slice::Iter<'a, u8>);
+
+impl<'a> BufIter<'a> {
+    fn new(buf: &'a [u8]) -> Self {
+        Self(buf.iter())
+    }
+
+    fn as_slice(&self) -> &'a [u8] {
+        self.0.as_slice()
+    }
+
+    fn is_empty(&self) -> bool {
+        self.0.len() == 0
+    }
+
+    fn peek(&self) -> Option<u8> {
+        self.0.as_slice().first().copied()
+    }
+
+    fn advance(&mut self, skip: usize) {
+        for _ in 0..skip {
+            self.0.next();
+        }
+    }
+
+    fn advance_until<F: FnMut(u8) -> bool>(&mut self, f: F) -> &[u8] {
+        let s = self.as_slice();
+        match s.iter().copied().position(f) {
+            Some(x) => {
+                self.advance(x);
+                &s[..x]
+            }
+            None => {
+                self.advance(s.len());
+                s
+            }
+        }
+    }
+
+    fn skip_whitespace(&mut self) {
+        self.advance_until(|b| !json_whitespace(b));
+    }
+}
+
+impl<'a> Iterator for BufIter<'a> {
+    type Item = u8;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.0.next().copied()
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.0.size_hint()
+    }
+}
+
+impl<'a> ExactSizeIterator for BufIter<'a> {}
+
+/// Returns an error for a given byte `b` and context `ctx`
+fn err(b: u8, ctx: &str) -> ArrowError {
+    ArrowError::JsonError(format!(
+        "Encountered unexpected '{}' whilst {ctx}",
+        b as char
+    ))
+}
+
+/// Creates a character from an UTF-16 surrogate pair
+fn char_from_surrogate_pair(low: u16, high: u16) -> Result<char, ArrowError> {
+    let n = (((high - 0xD800) as u32) << 10 | (low - 0xDC00) as u32) + 0x1_0000;
+    char::from_u32(n)
+        .ok_or_else(|| ArrowError::JsonError(format!("Invalid UTF-16 surrogate pair {n}")))
+}
+
+/// Writes `c` as UTF-8 to `out`
+fn write_char(c: char, out: &mut Vec<u8>) {
+    let mut t = [0; 4];
+    out.extend_from_slice(c.encode_utf8(&mut t).as_bytes());
+}
+
+/// Evaluates to true if `b` is a valid JSON whitespace character
+#[inline]
+fn json_whitespace(b: u8) -> bool {
+    matches!(b, b' ' | b'\n' | b'\r' | b'\t')
+}
+
+/// Parse a hex character to `u8`
+fn parse_hex(b: u8) -> Result<u8, ArrowError> {
+    let digit = char::from(b)
+        .to_digit(16)
+        .ok_or_else(|| err(b, "unicode escape"))?;
+    Ok(digit as u8)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_sizes() {
+        assert_eq!(std::mem::size_of::<DecoderState>(), 8);
+        assert_eq!(std::mem::size_of::<TapeElement>(), 8);
+    }
+
+    #[test]
+    fn test_basic() {
+        let a = r#"
+        {"hello": "world", "foo": 2, "bar": 45}
+
+        {"foo": "bar"}
+
+        {"fiz": null}
+
+        {"a": true, "b": false, "c": null}
+
+        {"a": "", "": "a"}
+
+        {"a": "b", "object": {"nested": "hello", "foo": 23}, "b": {}, "c": {"foo": null }}
+
+        {"a": ["", "foo", ["bar", "c"]], "b": {"1": []}, "c": {"2": [1, 2, 3]} }
+        "#;
+        let mut decoder = TapeDecoder::new(16, 2);
+        decoder.decode(a.as_bytes()).unwrap();
+
+        let finished = decoder.finish().unwrap();
+        assert_eq!(
+            finished.elements,
+            &[
+                TapeElement::Null,
+                TapeElement::StartObject(8), // {"hello": "world", "foo": 2, "bar": 45}
+                TapeElement::String(0),      // "hello"
+                TapeElement::String(1),      // "world"
+                TapeElement::String(2),      // "foo"
+                TapeElement::Number(3),      // 2
+                TapeElement::String(4),      // "bar"
+                TapeElement::Number(5),      // 45
+                TapeElement::EndObject(1),
+                TapeElement::StartObject(12), // {"foo": "bar"}
+                TapeElement::String(6),       // "foo"
+                TapeElement::String(7),       // "bar"
+                TapeElement::EndObject(9),
+                TapeElement::StartObject(16), // {"fiz": null}
+                TapeElement::String(8),       // "fiz
+                TapeElement::Null,            // null
+                TapeElement::EndObject(13),
+                TapeElement::StartObject(24), // {"a": true, "b": false, "c": null}
+                TapeElement::String(9),       // "a"
+                TapeElement::True,            // true
+                TapeElement::String(10),      // "b"
+                TapeElement::False,           // false
+                TapeElement::String(11),      // "c"
+                TapeElement::Null,            // null
+                TapeElement::EndObject(17),
+                TapeElement::StartObject(30), // {"a": "", "": "a"}
+                TapeElement::String(12),      // "a"
+                TapeElement::String(13),      // ""
+                TapeElement::String(14),      // ""
+                TapeElement::String(15),      // "a"
+                TapeElement::EndObject(25),
+                TapeElement::StartObject(49), // {"a": "b", "object": {"nested": "hello", "foo": 23}, "b": {}, "c": {"foo": null }}
+                TapeElement::String(16),      // "a"
+                TapeElement::String(17),      // "b"
+                TapeElement::String(18),      // "object"
+                TapeElement::StartObject(40), // {"nested": "hello", "foo": 23}
+                TapeElement::String(19),      // "nested"
+                TapeElement::String(20),      // "hello"
+                TapeElement::String(21),      // "foo"
+                TapeElement::Number(22),      // 23
+                TapeElement::EndObject(35),
+                TapeElement::String(23),      // "b"
+                TapeElement::StartObject(43), // {}
+                TapeElement::EndObject(42),
+                TapeElement::String(24),      // "c"
+                TapeElement::StartObject(48), // {"foo": null }
+                TapeElement::String(25),      // "foo"
+                TapeElement::Null,            // null
+                TapeElement::EndObject(45),
+                TapeElement::EndObject(31),
+                TapeElement::StartObject(75), // {"a": ["", "foo", ["bar", "c"]], "b": {"1": []}, "c": {"2": [1, 2, 3]} }
+                TapeElement::String(26),      // "a"
+                TapeElement::StartList(59),   // ["", "foo", ["bar", "c"]]
+                TapeElement::String(27),      // ""
+                TapeElement::String(28),      // "foo"
+                TapeElement::StartList(58),   // ["bar", "c"]
+                TapeElement::String(29),      // "bar"
+                TapeElement::String(30),      // "c"
+                TapeElement::EndList(55),
+                TapeElement::EndList(52),
+                TapeElement::String(31),      // "b"
+                TapeElement::StartObject(65), // {"1": []}
+                TapeElement::String(32),      // "1"
+                TapeElement::StartList(64),   // []
+                TapeElement::EndList(63),
+                TapeElement::EndObject(61),
+                TapeElement::String(33),      // "c"
+                TapeElement::StartObject(74), // {"2": [1, 2, 3]}
+                TapeElement::String(34),      // "2"
+                TapeElement::StartList(73),   // [1, 2, 3]
+                TapeElement::Number(35),      // 1
+                TapeElement::Number(36),      // 2
+                TapeElement::Number(37),      // 3
+                TapeElement::EndList(69),
+                TapeElement::EndObject(67),
+                TapeElement::EndObject(50)
+            ]
+        );
+
+        assert_eq!(
+            finished.strings,
+            "helloworldfoo2bar45foobarfizabcaaabobjectnestedhellofoo23bcfooafoobarcb1c2123"
+        );
+        assert_eq!(
+            &finished.string_offsets,
+            &[
+                0, 5, 10, 13, 14, 17, 19, 22, 25, 28, 29, 30, 31, 32, 32, 32, 33, 34, 35, 41, 47,
+                52, 55, 57, 58, 59, 62, 63, 63, 66, 69, 70, 71, 72, 73, 74, 75, 76, 77
+            ]
+        )
+    }
+
+    #[test]
+    fn test_invalid() {
+        // Test invalid
+        let mut decoder = TapeDecoder::new(16, 2);
+        let err = decoder.decode(b"hello").unwrap_err().to_string();
+        assert_eq!(
+            err,
+            "Json error: Encountered unexpected 'h' whilst parsing value"
+        );
+
+        let mut decoder = TapeDecoder::new(16, 2);
+        let err = decoder.decode(b"{\"hello\": }").unwrap_err().to_string();
+        assert_eq!(
+            err,
+            "Json error: Encountered unexpected '}' whilst parsing value"
+        );
+
+        let mut decoder = TapeDecoder::new(16, 2);
+        let err = decoder
+            .decode(b"{\"hello\": [ false, tru ]}")
+            .unwrap_err()
+            .to_string();
+        assert_eq!(
+            err,
+            "Json error: Encountered unexpected ' ' whilst parsing literal"
+        );
+
+        let mut decoder = TapeDecoder::new(16, 2);
+        let err = decoder
+            .decode(b"{\"hello\": \"\\ud8\"}")
+            .unwrap_err()
+            .to_string();
+        assert_eq!(
+            err,
+            "Json error: Encountered unexpected '\"' whilst unicode escape"
+        );
+
+        // Missing surrogate pair
+        let mut decoder = TapeDecoder::new(16, 2);
+        let err = decoder
+            .decode(b"{\"hello\": \"\\ud83d\"}")
+            .unwrap_err()
+            .to_string();
+        assert_eq!(
+            err,
+            "Json error: Encountered unexpected '\"' whilst parsing surrogate pair escape"
+        );
+
+        // Test truncation
+        let mut decoder = TapeDecoder::new(16, 2);
+        decoder.decode(b"{\"he").unwrap();
+        let err = decoder.finish().unwrap_err().to_string();
+        assert_eq!(err, "Json error: Truncated record whilst reading string");
+
+        let mut decoder = TapeDecoder::new(16, 2);
+        decoder.decode(b"{\"hello\" : ").unwrap();
+        let err = decoder.finish().unwrap_err().to_string();
+        assert_eq!(err, "Json error: Truncated record whilst reading value");
+
+        let mut decoder = TapeDecoder::new(16, 2);
+        decoder.decode(b"{\"hello\" : [").unwrap();
+        let err = decoder.finish().unwrap_err().to_string();
+        assert_eq!(err, "Json error: Truncated record whilst reading list");
+
+        let mut decoder = TapeDecoder::new(16, 2);
+        decoder.decode(b"{\"hello\" : tru").unwrap();
+        let err = decoder.finish().unwrap_err().to_string();
+        assert_eq!(err, "Json error: Truncated record whilst reading true");
+
+        let mut decoder = TapeDecoder::new(16, 2);
+        decoder.decode(b"{\"hello\" : nu").unwrap();
+        let err = decoder.finish().unwrap_err().to_string();
+        assert_eq!(err, "Json error: Truncated record whilst reading null");
+
+        // Test invalid UTF-8
+        let mut decoder = TapeDecoder::new(16, 2);
+        decoder.decode(b"{\"hello\" : \"world\xFF\"}").unwrap();
+        let err = decoder.finish().unwrap_err().to_string();
+        assert_eq!(err, "Json error: Encountered non-UTF-8 data");
+
+        let mut decoder = TapeDecoder::new(16, 2);
+        decoder.decode(b"{\"\xe2\" : \"\x96\xa1\"}").unwrap();
+        let err = decoder.finish().unwrap_err().to_string();
+        assert_eq!(err, "Json error: Encountered truncated UTF-8 sequence");
+    }
+}
diff --git a/arrow-json/src/reader/timestamp_array.rs b/arrow-json/src/reader/timestamp_array.rs
new file mode 100644
index 000000000000..f68fc3dc3270
--- /dev/null
+++ b/arrow-json/src/reader/timestamp_array.rs
@@ -0,0 +1,110 @@
+// 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.
+
+use chrono::TimeZone;
+use std::marker::PhantomData;
+
+use arrow_array::builder::PrimitiveBuilder;
+use arrow_array::types::ArrowTimestampType;
+use arrow_array::Array;
+use arrow_cast::parse::string_to_datetime;
+use arrow_data::ArrayData;
+use arrow_schema::{ArrowError, DataType, TimeUnit};
+
+use crate::reader::tape::{Tape, TapeElement};
+use crate::reader::ArrayDecoder;
+
+/// A specialized [`ArrayDecoder`] for timestamps
+pub struct TimestampArrayDecoder<P: ArrowTimestampType, Tz: TimeZone> {
+    data_type: DataType,
+    timezone: Tz,
+    // Invariant and Send
+    phantom: PhantomData<fn(P) -> P>,
+}
+
+impl<P: ArrowTimestampType, Tz: TimeZone> TimestampArrayDecoder<P, Tz> {
+    pub fn new(data_type: DataType, timezone: Tz) -> Self {
+        Self {
+            data_type,
+            timezone,
+            phantom: Default::default(),
+        }
+    }
+}
+
+impl<P, Tz> ArrayDecoder for TimestampArrayDecoder<P, Tz>
+where
+    P: ArrowTimestampType,
+    Tz: TimeZone + Send,
+{
+    fn decode(&mut self, tape: &Tape<'_>, pos: &[u32]) -> Result<ArrayData, ArrowError> {
+        let mut builder =
+            PrimitiveBuilder::<P>::with_capacity(pos.len()).with_data_type(self.data_type.clone());
+
+        for p in pos {
+            match tape.get(*p) {
+                TapeElement::Null => builder.append_null(),
+                TapeElement::String(idx) => {
+                    let s = tape.get_string(idx);
+                    let date = string_to_datetime(&self.timezone, s).map_err(|e| {
+                        ArrowError::JsonError(format!(
+                            "failed to parse \"{s}\" as {}: {}",
+                            self.data_type, e
+                        ))
+                    })?;
+
+                    let value = match P::UNIT {
+                        TimeUnit::Second => date.timestamp(),
+                        TimeUnit::Millisecond => date.timestamp_millis(),
+                        TimeUnit::Microsecond => date.timestamp_micros(),
+                        TimeUnit::Nanosecond => date.timestamp_nanos_opt().ok_or_else(|| {
+                            ArrowError::ParseError(format!(
+                                "{} would overflow 64-bit signed nanoseconds",
+                                date.to_rfc3339(),
+                            ))
+                        })?,
+                    };
+                    builder.append_value(value)
+                }
+                TapeElement::Number(idx) => {
+                    let s = tape.get_string(idx);
+                    let b = s.as_bytes();
+                    let value = lexical_core::parse::<i64>(b)
+                        .or_else(|_| lexical_core::parse::<f64>(b).map(|x| x as i64))
+                        .map_err(|_| {
+                            ArrowError::JsonError(format!(
+                                "failed to parse {s} as {}",
+                                self.data_type
+                            ))
+                        })?;
+
+                    builder.append_value(value)
+                }
+                TapeElement::I32(v) => builder.append_value(v as i64),
+                TapeElement::I64(high) => match tape.get(p + 1) {
+                    TapeElement::I32(low) => {
+                        builder.append_value((high as i64) << 32 | (low as u32) as i64)
+                    }
+                    _ => unreachable!(),
+                },
+                _ => return Err(tape.error(*p, "primitive")),
+            }
+        }
+
+        Ok(builder.finish().into_data())
+    }
+}
diff --git a/arrow-json/src/writer.rs b/arrow-json/src/writer.rs
new file mode 100644
index 000000000000..bb494b595064
--- /dev/null
+++ b/arrow-json/src/writer.rs
@@ -0,0 +1,2134 @@
+// 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.
+
+//! # JSON Writer
+//!
+//! This JSON writer converts Arrow [`RecordBatch`]es into arrays of
+//! JSON objects or JSON formatted byte streams.
+//!
+//! ## Writing JSON formatted byte streams
+//!
+//! To serialize [`RecordBatch`]es into line-delimited JSON bytes, use
+//! [`LineDelimitedWriter`]:
+//!
+//! ```
+//! # use std::sync::Arc;
+//! # use arrow_array::{Int32Array, RecordBatch};
+//! # use arrow_schema::{DataType, Field, Schema};
+//!
+//! let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
+//! let a = Int32Array::from(vec![1, 2, 3]);
+//! let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap();
+//!
+//! // Write the record batch out as JSON
+//! let buf = Vec::new();
+//! let mut writer = arrow_json::LineDelimitedWriter::new(buf);
+//! writer.write_batches(&vec![&batch]).unwrap();
+//! writer.finish().unwrap();
+//!
+//! // Get the underlying buffer back,
+//! let buf = writer.into_inner();
+//! assert_eq!(r#"{"a":1}
+//! {"a":2}
+//! {"a":3}
+//!"#, String::from_utf8(buf).unwrap())
+//! ```
+//!
+//! To serialize [`RecordBatch`]es into a well formed JSON array, use
+//! [`ArrayWriter`]:
+//!
+//! ```
+//! # use std::sync::Arc;
+//! # use arrow_array::{Int32Array, RecordBatch};
+//! use arrow_schema::{DataType, Field, Schema};
+//!
+//! let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
+//! let a = Int32Array::from(vec![1, 2, 3]);
+//! let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap();
+//!
+//! // Write the record batch out as a JSON array
+//! let buf = Vec::new();
+//! let mut writer = arrow_json::ArrayWriter::new(buf);
+//! writer.write_batches(&vec![&batch]).unwrap();
+//! writer.finish().unwrap();
+//!
+//! // Get the underlying buffer back,
+//! let buf = writer.into_inner();
+//! assert_eq!(r#"[{"a":1},{"a":2},{"a":3}]"#, String::from_utf8(buf).unwrap())
+//! ```
+//!
+//! [`LineDelimitedWriter`] and [`ArrayWriter`] will omit writing keys with null values.
+//! In order to explicitly write null values for keys, configure a custom [`Writer`] by
+//! using a [`WriterBuilder`] to construct a [`Writer`].
+//!
+//! ## Writing to [serde_json] JSON Objects
+//!
+//! To serialize [`RecordBatch`]es into an array of
+//! [JSON](https://docs.serde.rs/serde_json/) objects you can reparse the resulting JSON string.
+//! Note that this is less efficient than using the `Writer` API.
+//!
+//! ```
+//! # use std::sync::Arc;
+//! # use arrow_array::{Int32Array, RecordBatch};
+//! # use arrow_schema::{DataType, Field, Schema};
+//! let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
+//! let a = Int32Array::from(vec![1, 2, 3]);
+//! let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap();
+//!
+//! // Write the record batch out as json bytes (string)
+//! let buf = Vec::new();
+//! let mut writer = arrow_json::ArrayWriter::new(buf);
+//! writer.write_batches(&vec![&batch]).unwrap();
+//! writer.finish().unwrap();
+//! let json_data = writer.into_inner();
+//!
+//! // Parse the string using serde_json
+//! use serde_json::{Map, Value};
+//! let json_rows: Vec<Map<String, Value>> = serde_json::from_reader(json_data.as_slice()).unwrap();
+//! assert_eq!(
+//!     serde_json::Value::Object(json_rows[1].clone()),
+//!     serde_json::json!({"a": 2}),
+//! );
+//! ```
+mod encoder;
+
+use std::iter;
+use std::{fmt::Debug, io::Write};
+
+use serde_json::map::Map as JsonMap;
+use serde_json::Value;
+
+use crate::JsonSerializable;
+use arrow_array::cast::*;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_schema::*;
+
+use crate::writer::encoder::EncoderOptions;
+use arrow_cast::display::{ArrayFormatter, FormatOptions};
+use encoder::make_encoder;
+
+fn primitive_array_to_json<T>(array: &dyn Array) -> Result<Vec<Value>, ArrowError>
+where
+    T: ArrowPrimitiveType,
+    T::Native: JsonSerializable,
+{
+    Ok(array
+        .as_primitive::<T>()
+        .iter()
+        .map(|maybe_value| match maybe_value {
+            Some(v) => v.into_json_value().unwrap_or(Value::Null),
+            None => Value::Null,
+        })
+        .collect())
+}
+
+fn struct_array_to_jsonmap_array(
+    array: &StructArray,
+    explicit_nulls: bool,
+) -> Result<Vec<Option<JsonMap<String, Value>>>, ArrowError> {
+    let inner_col_names = array.column_names();
+
+    let mut inner_objs = (0..array.len())
+        // Ensure we write nulls for struct arrays as nulls in JSON
+        // Instead of writing a struct with nulls
+        .map(|index| array.is_valid(index).then(JsonMap::new))
+        .collect::<Vec<Option<JsonMap<String, Value>>>>();
+
+    for (j, struct_col) in array.columns().iter().enumerate() {
+        set_column_for_json_rows(
+            &mut inner_objs,
+            struct_col,
+            inner_col_names[j],
+            explicit_nulls,
+        )?
+    }
+    Ok(inner_objs)
+}
+
+/// Converts an arrow [`Array`] into a `Vec` of Serde JSON [`serde_json::Value`]'s
+pub fn array_to_json_array(array: &dyn Array) -> Result<Vec<Value>, ArrowError> {
+    // For backwards compatibility, default to skip nulls
+    array_to_json_array_internal(array, false)
+}
+
+fn array_to_json_array_internal(
+    array: &dyn Array,
+    explicit_nulls: bool,
+) -> Result<Vec<Value>, ArrowError> {
+    match array.data_type() {
+        DataType::Null => Ok(iter::repeat(Value::Null).take(array.len()).collect()),
+        DataType::Boolean => Ok(array
+            .as_boolean()
+            .iter()
+            .map(|maybe_value| match maybe_value {
+                Some(v) => v.into(),
+                None => Value::Null,
+            })
+            .collect()),
+
+        DataType::Utf8 => Ok(array
+            .as_string::<i32>()
+            .iter()
+            .map(|maybe_value| match maybe_value {
+                Some(v) => v.into(),
+                None => Value::Null,
+            })
+            .collect()),
+        DataType::LargeUtf8 => Ok(array
+            .as_string::<i64>()
+            .iter()
+            .map(|maybe_value| match maybe_value {
+                Some(v) => v.into(),
+                None => Value::Null,
+            })
+            .collect()),
+        DataType::Int8 => primitive_array_to_json::<Int8Type>(array),
+        DataType::Int16 => primitive_array_to_json::<Int16Type>(array),
+        DataType::Int32 => primitive_array_to_json::<Int32Type>(array),
+        DataType::Int64 => primitive_array_to_json::<Int64Type>(array),
+        DataType::UInt8 => primitive_array_to_json::<UInt8Type>(array),
+        DataType::UInt16 => primitive_array_to_json::<UInt16Type>(array),
+        DataType::UInt32 => primitive_array_to_json::<UInt32Type>(array),
+        DataType::UInt64 => primitive_array_to_json::<UInt64Type>(array),
+        DataType::Float16 => primitive_array_to_json::<Float16Type>(array),
+        DataType::Float32 => primitive_array_to_json::<Float32Type>(array),
+        DataType::Float64 => primitive_array_to_json::<Float64Type>(array),
+        DataType::List(_) => as_list_array(array)
+            .iter()
+            .map(|maybe_value| match maybe_value {
+                Some(v) => Ok(Value::Array(array_to_json_array_internal(
+                    &v,
+                    explicit_nulls,
+                )?)),
+                None => Ok(Value::Null),
+            })
+            .collect(),
+        DataType::LargeList(_) => as_large_list_array(array)
+            .iter()
+            .map(|maybe_value| match maybe_value {
+                Some(v) => Ok(Value::Array(array_to_json_array_internal(
+                    &v,
+                    explicit_nulls,
+                )?)),
+                None => Ok(Value::Null),
+            })
+            .collect(),
+        DataType::FixedSizeList(_, _) => as_fixed_size_list_array(array)
+            .iter()
+            .map(|maybe_value| match maybe_value {
+                Some(v) => Ok(Value::Array(array_to_json_array_internal(
+                    &v,
+                    explicit_nulls,
+                )?)),
+                None => Ok(Value::Null),
+            })
+            .collect(),
+        DataType::Struct(_) => {
+            let jsonmaps = struct_array_to_jsonmap_array(array.as_struct(), explicit_nulls)?;
+            let json_values = jsonmaps
+                .into_iter()
+                .map(|maybe_map| maybe_map.map(Value::Object).unwrap_or(Value::Null))
+                .collect();
+            Ok(json_values)
+        }
+        DataType::Map(_, _) => as_map_array(array)
+            .iter()
+            .map(|maybe_value| match maybe_value {
+                Some(v) => Ok(Value::Array(array_to_json_array_internal(
+                    &v,
+                    explicit_nulls,
+                )?)),
+                None => Ok(Value::Null),
+            })
+            .collect(),
+        t => Err(ArrowError::JsonError(format!(
+            "data type {t:?} not supported"
+        ))),
+    }
+}
+
+macro_rules! set_column_by_array_type {
+    ($cast_fn:ident, $col_name:ident, $rows:ident, $array:ident, $explicit_nulls:ident) => {
+        let arr = $cast_fn($array);
+        $rows
+            .iter_mut()
+            .zip(arr.iter())
+            .filter_map(|(maybe_row, maybe_value)| maybe_row.as_mut().map(|row| (row, maybe_value)))
+            .for_each(|(row, maybe_value)| {
+                if let Some(j) = maybe_value.map(Into::into) {
+                    row.insert($col_name.to_string(), j);
+                } else if $explicit_nulls {
+                    row.insert($col_name.to_string(), Value::Null);
+                }
+            });
+    };
+}
+
+fn set_column_by_primitive_type<T>(
+    rows: &mut [Option<JsonMap<String, Value>>],
+    array: &ArrayRef,
+    col_name: &str,
+    explicit_nulls: bool,
+) where
+    T: ArrowPrimitiveType,
+    T::Native: JsonSerializable,
+{
+    let primitive_arr = array.as_primitive::<T>();
+
+    rows.iter_mut()
+        .zip(primitive_arr.iter())
+        .filter_map(|(maybe_row, maybe_value)| maybe_row.as_mut().map(|row| (row, maybe_value)))
+        .for_each(|(row, maybe_value)| {
+            if let Some(j) = maybe_value.and_then(|v| v.into_json_value()) {
+                row.insert(col_name.to_string(), j);
+            } else if explicit_nulls {
+                row.insert(col_name.to_string(), Value::Null);
+            }
+        });
+}
+
+fn set_column_for_json_rows(
+    rows: &mut [Option<JsonMap<String, Value>>],
+    array: &ArrayRef,
+    col_name: &str,
+    explicit_nulls: bool,
+) -> Result<(), ArrowError> {
+    match array.data_type() {
+        DataType::Int8 => {
+            set_column_by_primitive_type::<Int8Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::Int16 => {
+            set_column_by_primitive_type::<Int16Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::Int32 => {
+            set_column_by_primitive_type::<Int32Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::Int64 => {
+            set_column_by_primitive_type::<Int64Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::UInt8 => {
+            set_column_by_primitive_type::<UInt8Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::UInt16 => {
+            set_column_by_primitive_type::<UInt16Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::UInt32 => {
+            set_column_by_primitive_type::<UInt32Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::UInt64 => {
+            set_column_by_primitive_type::<UInt64Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::Float16 => {
+            set_column_by_primitive_type::<Float16Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::Float32 => {
+            set_column_by_primitive_type::<Float32Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::Float64 => {
+            set_column_by_primitive_type::<Float64Type>(rows, array, col_name, explicit_nulls);
+        }
+        DataType::Null => {
+            if explicit_nulls {
+                rows.iter_mut()
+                    .filter_map(|maybe_row| maybe_row.as_mut())
+                    .for_each(|row| {
+                        row.insert(col_name.to_string(), Value::Null);
+                    });
+            }
+        }
+        DataType::Boolean => {
+            set_column_by_array_type!(as_boolean_array, col_name, rows, array, explicit_nulls);
+        }
+        DataType::Utf8 => {
+            set_column_by_array_type!(as_string_array, col_name, rows, array, explicit_nulls);
+        }
+        DataType::LargeUtf8 => {
+            set_column_by_array_type!(as_largestring_array, col_name, rows, array, explicit_nulls);
+        }
+        DataType::Date32
+        | DataType::Date64
+        | DataType::Timestamp(_, _)
+        | DataType::Time32(_)
+        | DataType::Time64(_)
+        | DataType::Duration(_) => {
+            let options = FormatOptions::default();
+            let formatter = ArrayFormatter::try_new(array.as_ref(), &options)?;
+            let nulls = array.nulls();
+            rows.iter_mut()
+                .enumerate()
+                .filter_map(|(idx, maybe_row)| maybe_row.as_mut().map(|row| (idx, row)))
+                .for_each(|(idx, row)| {
+                    let maybe_value = nulls
+                        .map(|x| x.is_valid(idx))
+                        .unwrap_or(true)
+                        .then(|| formatter.value(idx).to_string().into());
+                    if let Some(j) = maybe_value {
+                        row.insert(col_name.to_string(), j);
+                    } else if explicit_nulls {
+                        row.insert(col_name.to_string(), Value::Null);
+                    }
+                });
+        }
+        DataType::Struct(_) => {
+            let inner_objs = struct_array_to_jsonmap_array(array.as_struct(), explicit_nulls)?;
+            rows.iter_mut()
+                .zip(inner_objs)
+                .filter_map(|(maybe_row, maybe_obj)| maybe_row.as_mut().map(|row| (row, maybe_obj)))
+                .for_each(|(row, maybe_obj)| {
+                    let json = if let Some(obj) = maybe_obj {
+                        Value::Object(obj)
+                    } else {
+                        Value::Null
+                    };
+                    row.insert(col_name.to_string(), json);
+                });
+        }
+        DataType::List(_) => {
+            let listarr = as_list_array(array);
+            rows.iter_mut()
+                .zip(listarr.iter())
+                .filter_map(|(maybe_row, maybe_value)| {
+                    maybe_row.as_mut().map(|row| (row, maybe_value))
+                })
+                .try_for_each(|(row, maybe_value)| -> Result<(), ArrowError> {
+                    let maybe_value = maybe_value
+                        .map(|v| array_to_json_array_internal(&v, explicit_nulls).map(Value::Array))
+                        .transpose()?;
+                    if let Some(j) = maybe_value {
+                        row.insert(col_name.to_string(), j);
+                    } else if explicit_nulls {
+                        row.insert(col_name.to_string(), Value::Null);
+                    }
+                    Ok(())
+                })?;
+        }
+        DataType::LargeList(_) => {
+            let listarr = as_large_list_array(array);
+            rows.iter_mut()
+                .zip(listarr.iter())
+                .filter_map(|(maybe_row, maybe_value)| {
+                    maybe_row.as_mut().map(|row| (row, maybe_value))
+                })
+                .try_for_each(|(row, maybe_value)| -> Result<(), ArrowError> {
+                    let maybe_value = maybe_value
+                        .map(|v| array_to_json_array_internal(&v, explicit_nulls).map(Value::Array))
+                        .transpose()?;
+                    if let Some(j) = maybe_value {
+                        row.insert(col_name.to_string(), j);
+                    } else if explicit_nulls {
+                        row.insert(col_name.to_string(), Value::Null);
+                    }
+                    Ok(())
+                })?;
+        }
+        DataType::Dictionary(_, value_type) => {
+            let hydrated = arrow_cast::cast::cast(&array, value_type)
+                .expect("cannot cast dictionary to underlying values");
+            set_column_for_json_rows(rows, &hydrated, col_name, explicit_nulls)?;
+        }
+        DataType::Map(_, _) => {
+            let maparr = as_map_array(array);
+
+            let keys = maparr.keys();
+            let values = maparr.values();
+
+            // Keys have to be strings to convert to json.
+            if !matches!(keys.data_type(), DataType::Utf8) {
+                return Err(ArrowError::JsonError(format!(
+                    "data type {:?} not supported in nested map for json writer",
+                    keys.data_type()
+                )));
+            }
+
+            let keys = keys.as_string::<i32>();
+            let values = array_to_json_array_internal(values, explicit_nulls)?;
+
+            let mut kv = keys.iter().zip(values);
+
+            for (i, row) in rows
+                .iter_mut()
+                .enumerate()
+                .filter_map(|(i, maybe_row)| maybe_row.as_mut().map(|row| (i, row)))
+            {
+                if maparr.is_null(i) {
+                    row.insert(col_name.to_string(), serde_json::Value::Null);
+                    continue;
+                }
+
+                let len = maparr.value_length(i) as usize;
+                let mut obj = serde_json::Map::new();
+
+                for (_, (k, v)) in (0..len).zip(&mut kv) {
+                    obj.insert(k.expect("keys in a map should be non-null").to_string(), v);
+                }
+
+                row.insert(col_name.to_string(), serde_json::Value::Object(obj));
+            }
+        }
+        _ => {
+            return Err(ArrowError::JsonError(format!(
+                "data type {:?} not supported in nested map for json writer",
+                array.data_type()
+            )))
+        }
+    }
+    Ok(())
+}
+
+/// Converts an arrow [`RecordBatch`] into a `Vec` of Serde JSON
+/// [`JsonMap`]s (objects)
+#[deprecated(note = "Use Writer")]
+pub fn record_batches_to_json_rows(
+    batches: &[&RecordBatch],
+) -> Result<Vec<JsonMap<String, Value>>, ArrowError> {
+    // For backwards compatibility, default to skip nulls
+    record_batches_to_json_rows_internal(batches, false)
+}
+
+fn record_batches_to_json_rows_internal(
+    batches: &[&RecordBatch],
+    explicit_nulls: bool,
+) -> Result<Vec<JsonMap<String, Value>>, ArrowError> {
+    let mut rows: Vec<Option<JsonMap<String, Value>>> = iter::repeat(Some(JsonMap::new()))
+        .take(batches.iter().map(|b| b.num_rows()).sum())
+        .collect();
+
+    if !rows.is_empty() {
+        let schema = batches[0].schema();
+        let mut base = 0;
+        for batch in batches {
+            let row_count = batch.num_rows();
+            let row_slice = &mut rows[base..base + batch.num_rows()];
+            for (j, col) in batch.columns().iter().enumerate() {
+                let col_name = schema.field(j).name();
+                set_column_for_json_rows(row_slice, col, col_name, explicit_nulls)?
+            }
+            base += row_count;
+        }
+    }
+
+    let rows = rows.into_iter().map(|a| a.unwrap()).collect::<Vec<_>>();
+    Ok(rows)
+}
+
+/// This trait defines how to format a sequence of JSON objects to a
+/// byte stream.
+pub trait JsonFormat: Debug + Default {
+    #[inline]
+    /// write any bytes needed at the start of the file to the writer
+    fn start_stream<W: Write>(&self, _writer: &mut W) -> Result<(), ArrowError> {
+        Ok(())
+    }
+
+    #[inline]
+    /// write any bytes needed for the start of each row
+    fn start_row<W: Write>(&self, _writer: &mut W, _is_first_row: bool) -> Result<(), ArrowError> {
+        Ok(())
+    }
+
+    #[inline]
+    /// write any bytes needed for the end of each row
+    fn end_row<W: Write>(&self, _writer: &mut W) -> Result<(), ArrowError> {
+        Ok(())
+    }
+
+    /// write any bytes needed for the start of each row
+    fn end_stream<W: Write>(&self, _writer: &mut W) -> Result<(), ArrowError> {
+        Ok(())
+    }
+}
+
+/// Produces JSON output with one record per line.
+///
+/// For example:
+///
+/// ```json
+/// {"foo":1}
+/// {"bar":1}
+///
+/// ```
+#[derive(Debug, Default)]
+pub struct LineDelimited {}
+
+impl JsonFormat for LineDelimited {
+    fn end_row<W: Write>(&self, writer: &mut W) -> Result<(), ArrowError> {
+        writer.write_all(b"\n")?;
+        Ok(())
+    }
+}
+
+/// Produces JSON output as a single JSON array.
+///
+/// For example:
+///
+/// ```json
+/// [{"foo":1},{"bar":1}]
+/// ```
+#[derive(Debug, Default)]
+pub struct JsonArray {}
+
+impl JsonFormat for JsonArray {
+    fn start_stream<W: Write>(&self, writer: &mut W) -> Result<(), ArrowError> {
+        writer.write_all(b"[")?;
+        Ok(())
+    }
+
+    fn start_row<W: Write>(&self, writer: &mut W, is_first_row: bool) -> Result<(), ArrowError> {
+        if !is_first_row {
+            writer.write_all(b",")?;
+        }
+        Ok(())
+    }
+
+    fn end_stream<W: Write>(&self, writer: &mut W) -> Result<(), ArrowError> {
+        writer.write_all(b"]")?;
+        Ok(())
+    }
+}
+
+/// A JSON writer which serializes [`RecordBatch`]es to newline delimited JSON objects.
+pub type LineDelimitedWriter<W> = Writer<W, LineDelimited>;
+
+/// A JSON writer which serializes [`RecordBatch`]es to JSON arrays.
+pub type ArrayWriter<W> = Writer<W, JsonArray>;
+
+/// JSON writer builder.
+#[derive(Debug, Clone, Default)]
+pub struct WriterBuilder(EncoderOptions);
+
+impl WriterBuilder {
+    /// Create a new builder for configuring JSON writing options.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use arrow_json::{Writer, WriterBuilder};
+    /// # use arrow_json::writer::LineDelimited;
+    /// # use std::fs::File;
+    ///
+    /// fn example() -> Writer<File, LineDelimited> {
+    ///     let file = File::create("target/out.json").unwrap();
+    ///
+    ///     // create a builder that keeps keys with null values
+    ///     let builder = WriterBuilder::new().with_explicit_nulls(true);
+    ///     let writer = builder.build::<_, LineDelimited>(file);
+    ///
+    ///     writer
+    /// }
+    /// ```
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Returns `true` if this writer is configured to keep keys with null values.
+    pub fn explicit_nulls(&self) -> bool {
+        self.0.explicit_nulls
+    }
+
+    /// Set whether to keep keys with null values, or to omit writing them.
+    ///
+    /// For example, with [`LineDelimited`] format:
+    ///
+    /// Skip nulls (set to `false`):
+    ///
+    /// ```json
+    /// {"foo":1}
+    /// {"foo":1,"bar":2}
+    /// {}
+    /// ```
+    ///
+    /// Keep nulls (set to `true`):
+    ///
+    /// ```json
+    /// {"foo":1,"bar":null}
+    /// {"foo":1,"bar":2}
+    /// {"foo":null,"bar":null}
+    /// ```
+    ///
+    /// Default is to skip nulls (set to `false`).
+    pub fn with_explicit_nulls(mut self, explicit_nulls: bool) -> Self {
+        self.0.explicit_nulls = explicit_nulls;
+        self
+    }
+
+    /// Create a new `Writer` with specified `JsonFormat` and builder options.
+    pub fn build<W, F>(self, writer: W) -> Writer<W, F>
+    where
+        W: Write,
+        F: JsonFormat,
+    {
+        Writer {
+            writer,
+            started: false,
+            finished: false,
+            format: F::default(),
+            options: self.0,
+        }
+    }
+}
+
+/// A JSON writer which serializes [`RecordBatch`]es to a stream of
+/// `u8` encoded JSON objects.
+///
+/// See the module level documentation for detailed usage and examples.
+/// The specific format of the stream is controlled by the [`JsonFormat`]
+/// type parameter.
+///
+/// By default the writer will skip writing keys with null values for
+/// backward compatibility. See [`WriterBuilder`] on how to customize
+/// this behaviour when creating a new writer.
+#[derive(Debug)]
+pub struct Writer<W, F>
+where
+    W: Write,
+    F: JsonFormat,
+{
+    /// Underlying writer to use to write bytes
+    writer: W,
+
+    /// Has the writer output any records yet?
+    started: bool,
+
+    /// Is the writer finished?
+    finished: bool,
+
+    /// Determines how the byte stream is formatted
+    format: F,
+
+    /// Controls how JSON should be encoded, e.g. whether to write explicit nulls or skip them
+    options: EncoderOptions,
+}
+
+impl<W, F> Writer<W, F>
+where
+    W: Write,
+    F: JsonFormat,
+{
+    /// Construct a new writer
+    pub fn new(writer: W) -> Self {
+        Self {
+            writer,
+            started: false,
+            finished: false,
+            format: F::default(),
+            options: EncoderOptions::default(),
+        }
+    }
+
+    /// Write a single JSON row to the output writer
+    #[deprecated(note = "Use Writer::write")]
+    pub fn write_row(&mut self, row: &Value) -> Result<(), ArrowError> {
+        let is_first_row = !self.started;
+        if !self.started {
+            self.format.start_stream(&mut self.writer)?;
+            self.started = true;
+        }
+
+        self.format.start_row(&mut self.writer, is_first_row)?;
+        self.writer.write_all(
+            &serde_json::to_vec(row).map_err(|error| ArrowError::JsonError(error.to_string()))?,
+        )?;
+        self.format.end_row(&mut self.writer)?;
+        Ok(())
+    }
+
+    /// Serialize `batch` to JSON output
+    pub fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError> {
+        if batch.num_rows() == 0 {
+            return Ok(());
+        }
+
+        // BufWriter uses a buffer size of 8KB
+        // We therefore double this and flush once we have more than 8KB
+        let mut buffer = Vec::with_capacity(16 * 1024);
+
+        let mut is_first_row = !self.started;
+        if !self.started {
+            self.format.start_stream(&mut buffer)?;
+            self.started = true;
+        }
+
+        let array = StructArray::from(batch.clone());
+        let mut encoder = make_encoder(&array, &self.options)?;
+
+        for idx in 0..batch.num_rows() {
+            self.format.start_row(&mut buffer, is_first_row)?;
+            is_first_row = false;
+
+            encoder.encode(idx, &mut buffer);
+            if buffer.len() > 8 * 1024 {
+                self.writer.write_all(&buffer)?;
+                buffer.clear();
+            }
+            self.format.end_row(&mut buffer)?;
+        }
+
+        if !buffer.is_empty() {
+            self.writer.write_all(&buffer)?;
+        }
+
+        Ok(())
+    }
+
+    /// Serialize `batches` to JSON output
+    pub fn write_batches(&mut self, batches: &[&RecordBatch]) -> Result<(), ArrowError> {
+        for b in batches {
+            self.write(b)?;
+        }
+        Ok(())
+    }
+
+    /// Finishes the output stream. This function must be called after
+    /// all record batches have been produced. (e.g. producing the final `']'` if writing
+    /// arrays.
+    pub fn finish(&mut self) -> Result<(), ArrowError> {
+        if self.started && !self.finished {
+            self.format.end_stream(&mut self.writer)?;
+            self.finished = true;
+        }
+        Ok(())
+    }
+
+    /// Unwraps this `Writer<W>`, returning the underlying writer
+    pub fn into_inner(self) -> W {
+        self.writer
+    }
+}
+
+impl<W, F> RecordBatchWriter for Writer<W, F>
+where
+    W: Write,
+    F: JsonFormat,
+{
+    fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError> {
+        self.write(batch)
+    }
+
+    fn close(mut self) -> Result<(), ArrowError> {
+        self.finish()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs::{read_to_string, File};
+    use std::io::{BufReader, Seek};
+    use std::sync::Arc;
+
+    use serde_json::json;
+
+    use arrow_array::builder::{Int32Builder, Int64Builder, MapBuilder, StringBuilder};
+    use arrow_buffer::{Buffer, NullBuffer, OffsetBuffer, ToByteSlice};
+    use arrow_data::ArrayData;
+
+    use crate::reader::*;
+
+    use super::*;
+
+    /// Asserts that the NDJSON `input` is semantically identical to `expected`
+    fn assert_json_eq(input: &[u8], expected: &str) {
+        let expected: Vec<Option<Value>> = expected
+            .split('\n')
+            .map(|s| (!s.is_empty()).then(|| serde_json::from_str(s).unwrap()))
+            .collect();
+
+        let actual: Vec<Option<Value>> = input
+            .split(|b| *b == b'\n')
+            .map(|s| (!s.is_empty()).then(|| serde_json::from_slice(s).unwrap()))
+            .collect();
+
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    fn write_simple_rows() {
+        let schema = Schema::new(vec![
+            Field::new("c1", DataType::Int32, true),
+            Field::new("c2", DataType::Utf8, true),
+        ]);
+
+        let a = Int32Array::from(vec![Some(1), Some(2), Some(3), None, Some(5)]);
+        let b = StringArray::from(vec![Some("a"), Some("b"), Some("c"), Some("d"), None]);
+
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"c1":1,"c2":"a"}
+{"c1":2,"c2":"b"}
+{"c1":3,"c2":"c"}
+{"c2":"d"}
+{"c1":5}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_large_utf8() {
+        let schema = Schema::new(vec![
+            Field::new("c1", DataType::Utf8, true),
+            Field::new("c2", DataType::LargeUtf8, true),
+        ]);
+
+        let a = StringArray::from(vec![Some("a"), None, Some("c"), Some("d"), None]);
+        let b = LargeStringArray::from(vec![Some("a"), Some("b"), None, Some("d"), None]);
+
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"c1":"a","c2":"a"}
+{"c2":"b"}
+{"c1":"c"}
+{"c1":"d","c2":"d"}
+{}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_dictionary() {
+        let schema = Schema::new(vec![
+            Field::new_dictionary("c1", DataType::Int32, DataType::Utf8, true),
+            Field::new_dictionary("c2", DataType::Int8, DataType::Utf8, true),
+        ]);
+
+        let a: DictionaryArray<Int32Type> = vec![
+            Some("cupcakes"),
+            Some("foo"),
+            Some("foo"),
+            None,
+            Some("cupcakes"),
+        ]
+        .into_iter()
+        .collect();
+        let b: DictionaryArray<Int8Type> =
+            vec![Some("sdsd"), Some("sdsd"), None, Some("sd"), Some("sdsd")]
+                .into_iter()
+                .collect();
+
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"c1":"cupcakes","c2":"sdsd"}
+{"c1":"foo","c2":"sdsd"}
+{"c1":"foo"}
+{"c2":"sd"}
+{"c1":"cupcakes","c2":"sdsd"}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_list_of_dictionary() {
+        let dict_field = Arc::new(Field::new_dictionary(
+            "item",
+            DataType::Int32,
+            DataType::Utf8,
+            true,
+        ));
+        let schema = Schema::new(vec![Field::new_large_list("l", dict_field.clone(), true)]);
+
+        let dict_array: DictionaryArray<Int32Type> =
+            vec![Some("a"), Some("b"), Some("c"), Some("a"), None, Some("c")]
+                .into_iter()
+                .collect();
+        let list_array = LargeListArray::try_new(
+            dict_field,
+            OffsetBuffer::from_lengths([3_usize, 2, 0, 1]),
+            Arc::new(dict_array),
+            Some(NullBuffer::from_iter([true, true, false, true])),
+        )
+        .unwrap();
+
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(list_array)]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"l":["a","b","c"]}
+{"l":["a",null]}
+{}
+{"l":["c"]}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_list_of_dictionary_large_values() {
+        let dict_field = Arc::new(Field::new_dictionary(
+            "item",
+            DataType::Int32,
+            DataType::LargeUtf8,
+            true,
+        ));
+        let schema = Schema::new(vec![Field::new_large_list("l", dict_field.clone(), true)]);
+
+        let keys = PrimitiveArray::<Int32Type>::from(vec![
+            Some(0),
+            Some(1),
+            Some(2),
+            Some(0),
+            None,
+            Some(2),
+        ]);
+        let values = LargeStringArray::from(vec!["a", "b", "c"]);
+        let dict_array = DictionaryArray::try_new(keys, Arc::new(values)).unwrap();
+
+        let list_array = LargeListArray::try_new(
+            dict_field,
+            OffsetBuffer::from_lengths([3_usize, 2, 0, 1]),
+            Arc::new(dict_array),
+            Some(NullBuffer::from_iter([true, true, false, true])),
+        )
+        .unwrap();
+
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(list_array)]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"l":["a","b","c"]}
+{"l":["a",null]}
+{}
+{"l":["c"]}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_timestamps() {
+        let ts_string = "2018-11-13T17:11:10.011375885995";
+        let ts_nanos = ts_string
+            .parse::<chrono::NaiveDateTime>()
+            .unwrap()
+            .timestamp_nanos_opt()
+            .unwrap();
+        let ts_micros = ts_nanos / 1000;
+        let ts_millis = ts_micros / 1000;
+        let ts_secs = ts_millis / 1000;
+
+        let arr_nanos = TimestampNanosecondArray::from(vec![Some(ts_nanos), None]);
+        let arr_micros = TimestampMicrosecondArray::from(vec![Some(ts_micros), None]);
+        let arr_millis = TimestampMillisecondArray::from(vec![Some(ts_millis), None]);
+        let arr_secs = TimestampSecondArray::from(vec![Some(ts_secs), None]);
+        let arr_names = StringArray::from(vec![Some("a"), Some("b")]);
+
+        let schema = Schema::new(vec![
+            Field::new("nanos", arr_nanos.data_type().clone(), true),
+            Field::new("micros", arr_micros.data_type().clone(), true),
+            Field::new("millis", arr_millis.data_type().clone(), true),
+            Field::new("secs", arr_secs.data_type().clone(), true),
+            Field::new("name", arr_names.data_type().clone(), true),
+        ]);
+        let schema = Arc::new(schema);
+
+        let batch = RecordBatch::try_new(
+            schema,
+            vec![
+                Arc::new(arr_nanos),
+                Arc::new(arr_micros),
+                Arc::new(arr_millis),
+                Arc::new(arr_secs),
+                Arc::new(arr_names),
+            ],
+        )
+        .unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"micros":"2018-11-13T17:11:10.011375","millis":"2018-11-13T17:11:10.011","name":"a","nanos":"2018-11-13T17:11:10.011375885","secs":"2018-11-13T17:11:10"}
+{"name":"b"}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_timestamps_with_tz() {
+        let ts_string = "2018-11-13T17:11:10.011375885995";
+        let ts_nanos = ts_string
+            .parse::<chrono::NaiveDateTime>()
+            .unwrap()
+            .timestamp_nanos_opt()
+            .unwrap();
+        let ts_micros = ts_nanos / 1000;
+        let ts_millis = ts_micros / 1000;
+        let ts_secs = ts_millis / 1000;
+
+        let arr_nanos = TimestampNanosecondArray::from(vec![Some(ts_nanos), None]);
+        let arr_micros = TimestampMicrosecondArray::from(vec![Some(ts_micros), None]);
+        let arr_millis = TimestampMillisecondArray::from(vec![Some(ts_millis), None]);
+        let arr_secs = TimestampSecondArray::from(vec![Some(ts_secs), None]);
+        let arr_names = StringArray::from(vec![Some("a"), Some("b")]);
+
+        let tz = "+00:00";
+
+        let arr_nanos = arr_nanos.with_timezone(tz);
+        let arr_micros = arr_micros.with_timezone(tz);
+        let arr_millis = arr_millis.with_timezone(tz);
+        let arr_secs = arr_secs.with_timezone(tz);
+
+        let schema = Schema::new(vec![
+            Field::new("nanos", arr_nanos.data_type().clone(), true),
+            Field::new("micros", arr_micros.data_type().clone(), true),
+            Field::new("millis", arr_millis.data_type().clone(), true),
+            Field::new("secs", arr_secs.data_type().clone(), true),
+            Field::new("name", arr_names.data_type().clone(), true),
+        ]);
+        let schema = Arc::new(schema);
+
+        let batch = RecordBatch::try_new(
+            schema,
+            vec![
+                Arc::new(arr_nanos),
+                Arc::new(arr_micros),
+                Arc::new(arr_millis),
+                Arc::new(arr_secs),
+                Arc::new(arr_names),
+            ],
+        )
+        .unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"micros":"2018-11-13T17:11:10.011375Z","millis":"2018-11-13T17:11:10.011Z","name":"a","nanos":"2018-11-13T17:11:10.011375885Z","secs":"2018-11-13T17:11:10Z"}
+{"name":"b"}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_dates() {
+        let ts_string = "2018-11-13T17:11:10.011375885995";
+        let ts_millis = ts_string
+            .parse::<chrono::NaiveDateTime>()
+            .unwrap()
+            .timestamp_millis();
+
+        let arr_date32 = Date32Array::from(vec![
+            Some(i32::try_from(ts_millis / 1000 / (60 * 60 * 24)).unwrap()),
+            None,
+        ]);
+        let arr_date64 = Date64Array::from(vec![Some(ts_millis), None]);
+        let arr_names = StringArray::from(vec![Some("a"), Some("b")]);
+
+        let schema = Schema::new(vec![
+            Field::new("date32", arr_date32.data_type().clone(), true),
+            Field::new("date64", arr_date64.data_type().clone(), true),
+            Field::new("name", arr_names.data_type().clone(), false),
+        ]);
+        let schema = Arc::new(schema);
+
+        let batch = RecordBatch::try_new(
+            schema,
+            vec![
+                Arc::new(arr_date32),
+                Arc::new(arr_date64),
+                Arc::new(arr_names),
+            ],
+        )
+        .unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"date32":"2018-11-13","date64":"2018-11-13T17:11:10.011","name":"a"}
+{"name":"b"}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_times() {
+        let arr_time32sec = Time32SecondArray::from(vec![Some(120), None]);
+        let arr_time32msec = Time32MillisecondArray::from(vec![Some(120), None]);
+        let arr_time64usec = Time64MicrosecondArray::from(vec![Some(120), None]);
+        let arr_time64nsec = Time64NanosecondArray::from(vec![Some(120), None]);
+        let arr_names = StringArray::from(vec![Some("a"), Some("b")]);
+
+        let schema = Schema::new(vec![
+            Field::new("time32sec", arr_time32sec.data_type().clone(), true),
+            Field::new("time32msec", arr_time32msec.data_type().clone(), true),
+            Field::new("time64usec", arr_time64usec.data_type().clone(), true),
+            Field::new("time64nsec", arr_time64nsec.data_type().clone(), true),
+            Field::new("name", arr_names.data_type().clone(), true),
+        ]);
+        let schema = Arc::new(schema);
+
+        let batch = RecordBatch::try_new(
+            schema,
+            vec![
+                Arc::new(arr_time32sec),
+                Arc::new(arr_time32msec),
+                Arc::new(arr_time64usec),
+                Arc::new(arr_time64nsec),
+                Arc::new(arr_names),
+            ],
+        )
+        .unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"time32sec":"00:02:00","time32msec":"00:00:00.120","time64usec":"00:00:00.000120","time64nsec":"00:00:00.000000120","name":"a"}
+{"name":"b"}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_durations() {
+        let arr_durationsec = DurationSecondArray::from(vec![Some(120), None]);
+        let arr_durationmsec = DurationMillisecondArray::from(vec![Some(120), None]);
+        let arr_durationusec = DurationMicrosecondArray::from(vec![Some(120), None]);
+        let arr_durationnsec = DurationNanosecondArray::from(vec![Some(120), None]);
+        let arr_names = StringArray::from(vec![Some("a"), Some("b")]);
+
+        let schema = Schema::new(vec![
+            Field::new("duration_sec", arr_durationsec.data_type().clone(), true),
+            Field::new("duration_msec", arr_durationmsec.data_type().clone(), true),
+            Field::new("duration_usec", arr_durationusec.data_type().clone(), true),
+            Field::new("duration_nsec", arr_durationnsec.data_type().clone(), true),
+            Field::new("name", arr_names.data_type().clone(), true),
+        ]);
+        let schema = Arc::new(schema);
+
+        let batch = RecordBatch::try_new(
+            schema,
+            vec![
+                Arc::new(arr_durationsec),
+                Arc::new(arr_durationmsec),
+                Arc::new(arr_durationusec),
+                Arc::new(arr_durationnsec),
+                Arc::new(arr_names),
+            ],
+        )
+        .unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"duration_sec":"PT120S","duration_msec":"PT0.12S","duration_usec":"PT0.00012S","duration_nsec":"PT0.00000012S","name":"a"}
+{"name":"b"}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_nested_structs() {
+        let schema = Schema::new(vec![
+            Field::new(
+                "c1",
+                DataType::Struct(Fields::from(vec![
+                    Field::new("c11", DataType::Int32, true),
+                    Field::new(
+                        "c12",
+                        DataType::Struct(vec![Field::new("c121", DataType::Utf8, false)].into()),
+                        false,
+                    ),
+                ])),
+                false,
+            ),
+            Field::new("c2", DataType::Utf8, false),
+        ]);
+
+        let c1 = StructArray::from(vec![
+            (
+                Arc::new(Field::new("c11", DataType::Int32, true)),
+                Arc::new(Int32Array::from(vec![Some(1), None, Some(5)])) as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new(
+                    "c12",
+                    DataType::Struct(vec![Field::new("c121", DataType::Utf8, false)].into()),
+                    false,
+                )),
+                Arc::new(StructArray::from(vec![(
+                    Arc::new(Field::new("c121", DataType::Utf8, false)),
+                    Arc::new(StringArray::from(vec![Some("e"), Some("f"), Some("g")])) as ArrayRef,
+                )])) as ArrayRef,
+            ),
+        ]);
+        let c2 = StringArray::from(vec![Some("a"), Some("b"), Some("c")]);
+
+        let batch =
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"c1":{"c11":1,"c12":{"c121":"e"}},"c2":"a"}
+{"c1":{"c12":{"c121":"f"}},"c2":"b"}
+{"c1":{"c11":5,"c12":{"c121":"g"}},"c2":"c"}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_struct_with_list_field() {
+        let field_c1 = Field::new(
+            "c1",
+            DataType::List(Arc::new(Field::new("c_list", DataType::Utf8, false))),
+            false,
+        );
+        let field_c2 = Field::new("c2", DataType::Int32, false);
+        let schema = Schema::new(vec![field_c1.clone(), field_c2]);
+
+        let a_values = StringArray::from(vec!["a", "a1", "b", "c", "d", "e"]);
+        // list column rows: ["a", "a1"], ["b"], ["c"], ["d"], ["e"]
+        let a_value_offsets = Buffer::from(&[0, 2, 3, 4, 5, 6].to_byte_slice());
+        let a_list_data = ArrayData::builder(field_c1.data_type().clone())
+            .len(5)
+            .add_buffer(a_value_offsets)
+            .add_child_data(a_values.into_data())
+            .null_bit_buffer(Some(Buffer::from(vec![0b00011111])))
+            .build()
+            .unwrap();
+        let a = ListArray::from(a_list_data);
+
+        let b = Int32Array::from(vec![1, 2, 3, 4, 5]);
+
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"c1":["a","a1"],"c2":1}
+{"c1":["b"],"c2":2}
+{"c1":["c"],"c2":3}
+{"c1":["d"],"c2":4}
+{"c1":["e"],"c2":5}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_nested_list() {
+        let list_inner_type = Field::new(
+            "a",
+            DataType::List(Arc::new(Field::new("b", DataType::Int32, false))),
+            false,
+        );
+        let field_c1 = Field::new(
+            "c1",
+            DataType::List(Arc::new(list_inner_type.clone())),
+            false,
+        );
+        let field_c2 = Field::new("c2", DataType::Utf8, true);
+        let schema = Schema::new(vec![field_c1.clone(), field_c2]);
+
+        // list column rows: [[1, 2], [3]], [], [[4, 5, 6]]
+        let a_values = Int32Array::from(vec![1, 2, 3, 4, 5, 6]);
+
+        let a_value_offsets = Buffer::from(&[0, 2, 3, 6].to_byte_slice());
+        // Construct a list array from the above two
+        let a_list_data = ArrayData::builder(list_inner_type.data_type().clone())
+            .len(3)
+            .add_buffer(a_value_offsets)
+            .null_bit_buffer(Some(Buffer::from(vec![0b00000111])))
+            .add_child_data(a_values.into_data())
+            .build()
+            .unwrap();
+
+        let c1_value_offsets = Buffer::from(&[0, 2, 2, 3].to_byte_slice());
+        let c1_list_data = ArrayData::builder(field_c1.data_type().clone())
+            .len(3)
+            .add_buffer(c1_value_offsets)
+            .add_child_data(a_list_data)
+            .build()
+            .unwrap();
+
+        let c1 = ListArray::from(c1_list_data);
+        let c2 = StringArray::from(vec![Some("foo"), Some("bar"), None]);
+
+        let batch =
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"c1":[[1,2],[3]],"c2":"foo"}
+{"c1":[],"c2":"bar"}
+{"c1":[[4,5,6]]}
+"#,
+        );
+    }
+
+    #[test]
+    fn write_list_of_struct() {
+        let field_c1 = Field::new(
+            "c1",
+            DataType::List(Arc::new(Field::new(
+                "s",
+                DataType::Struct(Fields::from(vec![
+                    Field::new("c11", DataType::Int32, true),
+                    Field::new(
+                        "c12",
+                        DataType::Struct(vec![Field::new("c121", DataType::Utf8, false)].into()),
+                        false,
+                    ),
+                ])),
+                false,
+            ))),
+            true,
+        );
+        let field_c2 = Field::new("c2", DataType::Int32, false);
+        let schema = Schema::new(vec![field_c1.clone(), field_c2]);
+
+        let struct_values = StructArray::from(vec![
+            (
+                Arc::new(Field::new("c11", DataType::Int32, true)),
+                Arc::new(Int32Array::from(vec![Some(1), None, Some(5)])) as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new(
+                    "c12",
+                    DataType::Struct(vec![Field::new("c121", DataType::Utf8, false)].into()),
+                    false,
+                )),
+                Arc::new(StructArray::from(vec![(
+                    Arc::new(Field::new("c121", DataType::Utf8, false)),
+                    Arc::new(StringArray::from(vec![Some("e"), Some("f"), Some("g")])) as ArrayRef,
+                )])) as ArrayRef,
+            ),
+        ]);
+
+        // list column rows (c1):
+        // [{"c11": 1, "c12": {"c121": "e"}}, {"c12": {"c121": "f"}}],
+        // null,
+        // [{"c11": 5, "c12": {"c121": "g"}}]
+        let c1_value_offsets = Buffer::from(&[0, 2, 2, 3].to_byte_slice());
+        let c1_list_data = ArrayData::builder(field_c1.data_type().clone())
+            .len(3)
+            .add_buffer(c1_value_offsets)
+            .add_child_data(struct_values.into_data())
+            .null_bit_buffer(Some(Buffer::from(vec![0b00000101])))
+            .build()
+            .unwrap();
+        let c1 = ListArray::from(c1_list_data);
+
+        let c2 = Int32Array::from(vec![1, 2, 3]);
+
+        let batch =
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"c1":[{"c11":1,"c12":{"c121":"e"}},{"c12":{"c121":"f"}}],"c2":1}
+{"c2":2}
+{"c1":[{"c11":5,"c12":{"c121":"g"}}],"c2":3}
+"#,
+        );
+    }
+
+    fn test_write_for_file(test_file: &str, remove_nulls: bool) {
+        let file = File::open(test_file).unwrap();
+        let mut reader = BufReader::new(file);
+        let (schema, _) = infer_json_schema(&mut reader, None).unwrap();
+        reader.rewind().unwrap();
+
+        let builder = ReaderBuilder::new(Arc::new(schema)).with_batch_size(1024);
+        let mut reader = builder.build(reader).unwrap();
+        let batch = reader.next().unwrap().unwrap();
+
+        let mut buf = Vec::new();
+        {
+            if remove_nulls {
+                let mut writer = LineDelimitedWriter::new(&mut buf);
+                writer.write_batches(&[&batch]).unwrap();
+            } else {
+                let mut writer = WriterBuilder::new()
+                    .with_explicit_nulls(true)
+                    .build::<_, LineDelimited>(&mut buf);
+                writer.write_batches(&[&batch]).unwrap();
+            }
+        }
+
+        let result = String::from_utf8(buf).unwrap();
+        let expected = read_to_string(test_file).unwrap();
+        for (r, e) in result.lines().zip(expected.lines()) {
+            let mut expected_json = serde_json::from_str::<Value>(e).unwrap();
+            if remove_nulls {
+                // remove null value from object to make comparison consistent:
+                if let Value::Object(obj) = expected_json {
+                    expected_json =
+                        Value::Object(obj.into_iter().filter(|(_, v)| *v != Value::Null).collect());
+                }
+            }
+            assert_eq!(serde_json::from_str::<Value>(r).unwrap(), expected_json,);
+        }
+    }
+
+    #[test]
+    fn write_basic_rows() {
+        test_write_for_file("test/data/basic.json", true);
+    }
+
+    #[test]
+    fn write_arrays() {
+        test_write_for_file("test/data/arrays.json", true);
+    }
+
+    #[test]
+    fn write_basic_nulls() {
+        test_write_for_file("test/data/basic_nulls.json", true);
+    }
+
+    #[test]
+    fn write_nested_with_nulls() {
+        test_write_for_file("test/data/nested_with_nulls.json", false);
+    }
+
+    #[test]
+    fn json_writer_empty() {
+        let mut writer = ArrayWriter::new(vec![] as Vec<u8>);
+        writer.finish().unwrap();
+        assert_eq!(String::from_utf8(writer.into_inner()).unwrap(), "");
+    }
+
+    #[test]
+    #[allow(deprecated)]
+    fn json_writer_one_row() {
+        let mut writer = ArrayWriter::new(vec![] as Vec<u8>);
+        let v = json!({ "an": "object" });
+        writer.write_row(&v).unwrap();
+        writer.finish().unwrap();
+        assert_eq!(
+            String::from_utf8(writer.into_inner()).unwrap(),
+            r#"[{"an":"object"}]"#
+        );
+    }
+
+    #[test]
+    #[allow(deprecated)]
+    fn json_writer_two_rows() {
+        let mut writer = ArrayWriter::new(vec![] as Vec<u8>);
+        let v = json!({ "an": "object" });
+        writer.write_row(&v).unwrap();
+        let v = json!({ "another": "object" });
+        writer.write_row(&v).unwrap();
+        writer.finish().unwrap();
+        assert_eq!(
+            String::from_utf8(writer.into_inner()).unwrap(),
+            r#"[{"an":"object"},{"another":"object"}]"#
+        );
+    }
+
+    #[test]
+    #[allow(deprecated)]
+    fn json_list_roundtrip() {
+        let json_content = r#"
+        {"list": [{"ints": 1}]}
+        {"list": [{}]}
+        {"list": []}
+        {"list": null}
+        {"list": [{"ints": null}]}
+        {"list": [null]}
+        "#;
+        let ints_struct = DataType::Struct(vec![Field::new("ints", DataType::Int32, true)].into());
+        let list_type = DataType::List(Arc::new(Field::new("item", ints_struct, true)));
+        let list_field = Field::new("list", list_type, true);
+        let schema = Arc::new(Schema::new(vec![list_field]));
+        let builder = ReaderBuilder::new(schema).with_batch_size(64);
+        let mut reader = builder.build(std::io::Cursor::new(json_content)).unwrap();
+
+        let batch = reader.next().unwrap().unwrap();
+
+        let list_row = batch.column(0).as_list::<i32>();
+        let values = list_row.values();
+        assert_eq!(values.len(), 4);
+        assert_eq!(values.null_count(), 1);
+
+        // write the batch to JSON, and compare output with input
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"list":[{"ints":1}]}
+{"list":[{}]}
+{"list":[]}
+{}
+{"list":[{}]}
+{"list":[null]}
+"#,
+        );
+    }
+
+    #[test]
+    fn json_struct_array_nulls() {
+        let inner = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+            Some(vec![Some(1), Some(2)]),
+            Some(vec![None]),
+            Some(vec![]),
+            Some(vec![Some(3), None]), // masked for a
+            Some(vec![Some(4), Some(5)]),
+            None, // masked for a
+            None,
+        ]);
+
+        let field = Arc::new(Field::new("list", inner.data_type().clone(), true));
+        let array = Arc::new(inner) as ArrayRef;
+        let struct_array_a = StructArray::from((
+            vec![(field.clone(), array.clone())],
+            Buffer::from([0b01010111]),
+        ));
+        let struct_array_b = StructArray::from(vec![(field, array)]);
+
+        let schema = Schema::new(vec![
+            Field::new_struct("a", struct_array_a.fields().clone(), true),
+            Field::new_struct("b", struct_array_b.fields().clone(), true),
+        ]);
+
+        let batch = RecordBatch::try_new(
+            Arc::new(schema),
+            vec![Arc::new(struct_array_a), Arc::new(struct_array_b)],
+        )
+        .unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"a":{"list":[1,2]},"b":{"list":[1,2]}}
+{"a":{"list":[null]},"b":{"list":[null]}}
+{"a":{"list":[]},"b":{"list":[]}}
+{"b":{"list":[3,null]}}
+{"a":{"list":[4,5]},"b":{"list":[4,5]}}
+{"b":{}}
+{"a":{},"b":{}}
+"#,
+        );
+    }
+
+    #[test]
+    fn json_writer_map() {
+        let keys_array = super::StringArray::from(vec!["foo", "bar", "baz", "qux", "quux"]);
+        let values_array = super::Int64Array::from(vec![10, 20, 30, 40, 50]);
+
+        let keys = Arc::new(Field::new("keys", DataType::Utf8, false));
+        let values = Arc::new(Field::new("values", DataType::Int64, false));
+        let entry_struct = StructArray::from(vec![
+            (keys, Arc::new(keys_array) as ArrayRef),
+            (values, Arc::new(values_array) as ArrayRef),
+        ]);
+
+        let map_data_type = DataType::Map(
+            Arc::new(Field::new(
+                "entries",
+                entry_struct.data_type().clone(),
+                false,
+            )),
+            false,
+        );
+
+        // [{"foo": 10}, null, {}, {"bar": 20, "baz": 30, "qux": 40}, {"quux": 50}, {}]
+        let entry_offsets = Buffer::from(&[0, 1, 1, 1, 4, 5, 5].to_byte_slice());
+        let valid_buffer = Buffer::from([0b00111101]);
+
+        let map_data = ArrayData::builder(map_data_type.clone())
+            .len(6)
+            .null_bit_buffer(Some(valid_buffer))
+            .add_buffer(entry_offsets)
+            .add_child_data(entry_struct.into_data())
+            .build()
+            .unwrap();
+
+        let map = MapArray::from(map_data);
+
+        let map_field = Field::new("map", map_data_type, true);
+        let schema = Arc::new(Schema::new(vec![map_field]));
+
+        let batch = RecordBatch::try_new(schema, vec![Arc::new(map)]).unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&[&batch]).unwrap();
+        }
+
+        assert_json_eq(
+            &buf,
+            r#"{"map":{"foo":10}}
+{}
+{"map":{}}
+{"map":{"bar":20,"baz":30,"qux":40}}
+{"map":{"quux":50}}
+{"map":{}}
+"#,
+        );
+    }
+
+    #[test]
+    fn test_write_single_batch() {
+        let test_file = "test/data/basic.json";
+        let file = File::open(test_file).unwrap();
+        let mut reader = BufReader::new(file);
+        let (schema, _) = infer_json_schema(&mut reader, None).unwrap();
+        reader.rewind().unwrap();
+
+        let builder = ReaderBuilder::new(Arc::new(schema)).with_batch_size(1024);
+        let mut reader = builder.build(reader).unwrap();
+        let batch = reader.next().unwrap().unwrap();
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write(&batch).unwrap();
+        }
+
+        let result = String::from_utf8(buf).unwrap();
+        let expected = read_to_string(test_file).unwrap();
+        for (r, e) in result.lines().zip(expected.lines()) {
+            let mut expected_json = serde_json::from_str::<Value>(e).unwrap();
+            // remove null value from object to make comparison consistent:
+            if let Value::Object(obj) = expected_json {
+                expected_json =
+                    Value::Object(obj.into_iter().filter(|(_, v)| *v != Value::Null).collect());
+            }
+            assert_eq!(serde_json::from_str::<Value>(r).unwrap(), expected_json,);
+        }
+    }
+
+    #[test]
+    fn test_write_multi_batches() {
+        let test_file = "test/data/basic.json";
+
+        let schema = SchemaRef::new(Schema::new(vec![
+            Field::new("a", DataType::Int64, true),
+            Field::new("b", DataType::Float64, true),
+            Field::new("c", DataType::Boolean, true),
+            Field::new("d", DataType::Utf8, true),
+            Field::new("e", DataType::Utf8, true),
+            Field::new("f", DataType::Utf8, true),
+            Field::new("g", DataType::Timestamp(TimeUnit::Millisecond, None), true),
+            Field::new("h", DataType::Float16, true),
+        ]));
+
+        let mut reader = ReaderBuilder::new(schema.clone())
+            .build(BufReader::new(File::open(test_file).unwrap()))
+            .unwrap();
+        let batch = reader.next().unwrap().unwrap();
+
+        // test batches = an empty batch + 2 same batches, finally result should be eq to 2 same batches
+        let batches = [&RecordBatch::new_empty(schema), &batch, &batch];
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = LineDelimitedWriter::new(&mut buf);
+            writer.write_batches(&batches).unwrap();
+        }
+
+        let result = String::from_utf8(buf).unwrap();
+        let expected = read_to_string(test_file).unwrap();
+        // result is eq to 2 same batches
+        let expected = format!("{expected}\n{expected}");
+        for (r, e) in result.lines().zip(expected.lines()) {
+            let mut expected_json = serde_json::from_str::<Value>(e).unwrap();
+            // remove null value from object to make comparison consistent:
+            if let Value::Object(obj) = expected_json {
+                expected_json =
+                    Value::Object(obj.into_iter().filter(|(_, v)| *v != Value::Null).collect());
+            }
+            assert_eq!(serde_json::from_str::<Value>(r).unwrap(), expected_json,);
+        }
+    }
+
+    #[test]
+    fn test_array_to_json_array_for_fixed_size_list_array() {
+        let expected_json = vec![
+            json!([0, 1, 2]),
+            json!(null),
+            json!([3, null, 5]),
+            json!([6, 7, 45]),
+        ];
+
+        let data = vec![
+            Some(vec![Some(0), Some(1), Some(2)]),
+            None,
+            Some(vec![Some(3), None, Some(5)]),
+            Some(vec![Some(6), Some(7), Some(45)]),
+        ];
+
+        let list_array = FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(data, 3);
+        let list_array = Arc::new(list_array) as ArrayRef;
+
+        assert_eq!(array_to_json_array(&list_array).unwrap(), expected_json);
+    }
+
+    #[test]
+    fn test_array_to_json_array_for_map_array() {
+        let expected_json = serde_json::from_value::<Vec<Value>>(json!([
+            [
+                {
+                    "keys": "joe",
+                    "values": 1
+                }
+            ],
+            [
+                {
+                    "keys": "blogs",
+                    "values": 2
+                },
+                {
+                    "keys": "foo",
+                    "values": 4
+                }
+            ],
+            [],
+            null
+        ]))
+        .unwrap();
+
+        let string_builder = StringBuilder::new();
+        let int_builder = Int32Builder::with_capacity(4);
+
+        let mut builder = MapBuilder::new(None, string_builder, int_builder);
+
+        builder.keys().append_value("joe");
+        builder.values().append_value(1);
+        builder.append(true).unwrap();
+
+        builder.keys().append_value("blogs");
+        builder.values().append_value(2);
+        builder.keys().append_value("foo");
+        builder.values().append_value(4);
+        builder.append(true).unwrap();
+        builder.append(true).unwrap();
+        builder.append(false).unwrap();
+
+        let array = builder.finish();
+
+        let map_array = Arc::new(array) as ArrayRef;
+
+        assert_eq!(array_to_json_array(&map_array).unwrap(), expected_json);
+    }
+
+    #[test]
+    fn test_writer_explicit_nulls() -> Result<(), ArrowError> {
+        fn nested_list() -> (Arc<ListArray>, Arc<Field>) {
+            let array = Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+                Some(vec![None, None, None]),
+                Some(vec![Some(1), Some(2), Some(3)]),
+                None,
+                Some(vec![None, None, None]),
+            ]));
+            let field = Arc::new(Field::new("list", array.data_type().clone(), true));
+            // [{"list":[null,null,null]},{"list":[1,2,3]},{"list":null},{"list":[null,null,null]}]
+            (array, field)
+        }
+
+        fn nested_dict() -> (Arc<DictionaryArray<Int32Type>>, Arc<Field>) {
+            let array = Arc::new(DictionaryArray::from_iter(vec![
+                Some("cupcakes"),
+                None,
+                Some("bear"),
+                Some("kuma"),
+            ]));
+            let field = Arc::new(Field::new("dict", array.data_type().clone(), true));
+            // [{"dict":"cupcakes"},{"dict":null},{"dict":"bear"},{"dict":"kuma"}]
+            (array, field)
+        }
+
+        fn nested_map() -> (Arc<MapArray>, Arc<Field>) {
+            let string_builder = StringBuilder::new();
+            let int_builder = Int64Builder::new();
+            let mut builder = MapBuilder::new(None, string_builder, int_builder);
+
+            // [{"foo": 10}, null, {}, {"bar": 20, "baz": 30, "qux": 40}]
+            builder.keys().append_value("foo");
+            builder.values().append_value(10);
+            builder.append(true).unwrap();
+
+            builder.append(false).unwrap();
+
+            builder.append(true).unwrap();
+
+            builder.keys().append_value("bar");
+            builder.values().append_value(20);
+            builder.keys().append_value("baz");
+            builder.values().append_value(30);
+            builder.keys().append_value("qux");
+            builder.values().append_value(40);
+            builder.append(true).unwrap();
+
+            let array = Arc::new(builder.finish());
+            let field = Arc::new(Field::new("map", array.data_type().clone(), true));
+            (array, field)
+        }
+
+        fn root_list() -> (Arc<ListArray>, Field) {
+            let struct_array = StructArray::from(vec![
+                (
+                    Arc::new(Field::new("utf8", DataType::Utf8, true)),
+                    Arc::new(StringArray::from(vec![Some("a"), Some("b"), None, None])) as ArrayRef,
+                ),
+                (
+                    Arc::new(Field::new("int32", DataType::Int32, true)),
+                    Arc::new(Int32Array::from(vec![Some(1), None, Some(5), None])) as ArrayRef,
+                ),
+            ]);
+
+            let field = Field::new_list(
+                "list",
+                Field::new("struct", struct_array.data_type().clone(), true),
+                true,
+            );
+
+            // [{"list":[{"int32":1,"utf8":"a"},{"int32":null,"utf8":"b"}]},{"list":null},{"list":[{int32":5,"utf8":null}]},{"list":null}]
+            let entry_offsets = Buffer::from(&[0, 2, 2, 3, 3].to_byte_slice());
+            let data = ArrayData::builder(field.data_type().clone())
+                .len(4)
+                .add_buffer(entry_offsets)
+                .add_child_data(struct_array.into_data())
+                .null_bit_buffer(Some([0b00000101].into()))
+                .build()
+                .unwrap();
+            let array = Arc::new(ListArray::from(data));
+            (array, field)
+        }
+
+        let (nested_list_array, nested_list_field) = nested_list();
+        let (nested_dict_array, nested_dict_field) = nested_dict();
+        let (nested_map_array, nested_map_field) = nested_map();
+        let (root_list_array, root_list_field) = root_list();
+
+        let schema = Schema::new(vec![
+            Field::new("date", DataType::Date32, true),
+            Field::new("null", DataType::Null, true),
+            Field::new_struct(
+                "struct",
+                vec![
+                    Arc::new(Field::new("utf8", DataType::Utf8, true)),
+                    nested_list_field.clone(),
+                    nested_dict_field.clone(),
+                    nested_map_field.clone(),
+                ],
+                true,
+            ),
+            root_list_field,
+        ]);
+
+        let arr_date32 = Date32Array::from(vec![Some(0), None, Some(1), None]);
+        let arr_null = NullArray::new(4);
+        let arr_struct = StructArray::from(vec![
+            // [{"utf8":"a"},{"utf8":null},{"utf8":null},{"utf8":"b"}]
+            (
+                Arc::new(Field::new("utf8", DataType::Utf8, true)),
+                Arc::new(StringArray::from(vec![Some("a"), None, None, Some("b")])) as ArrayRef,
+            ),
+            // [{"list":[null,null,null]},{"list":[1,2,3]},{"list":null},{"list":[null,null,null]}]
+            (nested_list_field, nested_list_array as ArrayRef),
+            // [{"dict":"cupcakes"},{"dict":null},{"dict":"bear"},{"dict":"kuma"}]
+            (nested_dict_field, nested_dict_array as ArrayRef),
+            // [{"foo": 10}, null, {}, {"bar": 20, "baz": 30, "qux": 40}]
+            (nested_map_field, nested_map_array as ArrayRef),
+        ]);
+
+        let batch = RecordBatch::try_new(
+            Arc::new(schema),
+            vec![
+                // [{"date":"1970-01-01"},{"date":null},{"date":"1970-01-02"},{"date":null}]
+                Arc::new(arr_date32),
+                // [{"null":null},{"null":null},{"null":null},{"null":null}]
+                Arc::new(arr_null),
+                Arc::new(arr_struct),
+                // [{"list":[{"int32":1,"utf8":"a"},{"int32":null,"utf8":"b"}]},{"list":null},{"list":[{int32":5,"utf8":null}]},{"list":null}]
+                root_list_array,
+            ],
+        )?;
+
+        let mut buf = Vec::new();
+        {
+            let mut writer = WriterBuilder::new()
+                .with_explicit_nulls(true)
+                .build::<_, JsonArray>(&mut buf);
+            writer.write_batches(&[&batch])?;
+            writer.finish()?;
+        }
+
+        let actual = serde_json::from_slice::<Vec<Value>>(&buf).unwrap();
+        let expected = serde_json::from_value::<Vec<Value>>(json!([
+          {
+            "date": "1970-01-01",
+            "list": [
+              {
+                "int32": 1,
+                "utf8": "a"
+              },
+              {
+                "int32": null,
+                "utf8": "b"
+              }
+            ],
+            "null": null,
+            "struct": {
+              "dict": "cupcakes",
+              "list": [
+                null,
+                null,
+                null
+              ],
+              "map": {
+                "foo": 10
+              },
+              "utf8": "a"
+            }
+          },
+          {
+            "date": null,
+            "list": null,
+            "null": null,
+            "struct": {
+              "dict": null,
+              "list": [
+                1,
+                2,
+                3
+              ],
+              "map": null,
+              "utf8": null
+            }
+          },
+          {
+            "date": "1970-01-02",
+            "list": [
+              {
+                "int32": 5,
+                "utf8": null
+              }
+            ],
+            "null": null,
+            "struct": {
+              "dict": "bear",
+              "list": null,
+              "map": {},
+              "utf8": null
+            }
+          },
+          {
+            "date": null,
+            "list": null,
+            "null": null,
+            "struct": {
+              "dict": "kuma",
+              "list": [
+                null,
+                null,
+                null
+              ],
+              "map": {
+                "bar": 20,
+                "baz": 30,
+                "qux": 40
+              },
+              "utf8": "b"
+            }
+          }
+        ]))
+        .unwrap();
+
+        assert_eq!(actual, expected);
+
+        Ok(())
+    }
+}
diff --git a/arrow-json/src/writer/encoder.rs b/arrow-json/src/writer/encoder.rs
new file mode 100644
index 000000000000..87efcb9f39a0
--- /dev/null
+++ b/arrow-json/src/writer/encoder.rs
@@ -0,0 +1,445 @@
+// 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.
+
+use arrow_array::cast::AsArray;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::{ArrowNativeType, NullBuffer, OffsetBuffer, ScalarBuffer};
+use arrow_cast::display::{ArrayFormatter, FormatOptions};
+use arrow_schema::{ArrowError, DataType, FieldRef};
+use half::f16;
+use lexical_core::FormattedSize;
+use serde::Serializer;
+use std::io::Write;
+
+#[derive(Debug, Clone, Default)]
+pub struct EncoderOptions {
+    pub explicit_nulls: bool,
+}
+
+/// A trait to format array values as JSON values
+///
+/// Nullability is handled by the caller to allow encoding nulls implicitly, i.e. `{}` instead of `{"a": null}`
+pub trait Encoder {
+    /// Encode the non-null value at index `idx` to `out`
+    ///
+    /// The behaviour is unspecified if `idx` corresponds to a null index
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>);
+}
+
+pub fn make_encoder<'a>(
+    array: &'a dyn Array,
+    options: &EncoderOptions,
+) -> Result<Box<dyn Encoder + 'a>, ArrowError> {
+    let (encoder, nulls) = make_encoder_impl(array, options)?;
+    assert!(nulls.is_none(), "root cannot be nullable");
+    Ok(encoder)
+}
+
+fn make_encoder_impl<'a>(
+    array: &'a dyn Array,
+    options: &EncoderOptions,
+) -> Result<(Box<dyn Encoder + 'a>, Option<NullBuffer>), ArrowError> {
+    macro_rules! primitive_helper {
+        ($t:ty) => {{
+            let array = array.as_primitive::<$t>();
+            let nulls = array.nulls().cloned();
+            (Box::new(PrimitiveEncoder::new(array)) as _, nulls)
+        }};
+    }
+
+    Ok(downcast_integer! {
+        array.data_type() => (primitive_helper),
+        DataType::Float16 => primitive_helper!(Float16Type),
+        DataType::Float32 => primitive_helper!(Float32Type),
+        DataType::Float64 => primitive_helper!(Float64Type),
+        DataType::Boolean => {
+            let array = array.as_boolean();
+            (Box::new(BooleanEncoder(array.clone())), array.nulls().cloned())
+        }
+        DataType::Null => (Box::new(NullEncoder), array.logical_nulls()),
+        DataType::Utf8 => {
+            let array = array.as_string::<i32>();
+            (Box::new(StringEncoder(array.clone())) as _, array.nulls().cloned())
+        }
+        DataType::LargeUtf8 => {
+            let array = array.as_string::<i64>();
+            (Box::new(StringEncoder(array.clone())) as _, array.nulls().cloned())
+        }
+        DataType::List(_) => {
+            let array = array.as_list::<i32>();
+            (Box::new(ListEncoder::try_new(array, options)?) as _, array.nulls().cloned())
+        }
+        DataType::LargeList(_) => {
+            let array = array.as_list::<i64>();
+            (Box::new(ListEncoder::try_new(array, options)?) as _, array.nulls().cloned())
+        }
+
+        DataType::Dictionary(_, _) => downcast_dictionary_array! {
+            array => (Box::new(DictionaryEncoder::try_new(array, options)?) as _,  array.logical_nulls()),
+            _ => unreachable!()
+        }
+
+        DataType::Map(_, _) => {
+            let array = array.as_map();
+            (Box::new(MapEncoder::try_new(array, options)?) as _,  array.nulls().cloned())
+        }
+
+        DataType::Struct(fields) => {
+            let array = array.as_struct();
+            let encoders = fields.iter().zip(array.columns()).map(|(field, array)| {
+                let (encoder, nulls) = make_encoder_impl(array, options)?;
+                Ok(FieldEncoder{
+                    field: field.clone(),
+                    encoder, nulls
+                })
+            }).collect::<Result<Vec<_>, ArrowError>>()?;
+
+            let encoder = StructArrayEncoder{
+                encoders,
+                explicit_nulls: options.explicit_nulls,
+            };
+            (Box::new(encoder) as _, array.nulls().cloned())
+        }
+        d => match d.is_temporal() {
+            true => {
+                // Note: the implementation of Encoder for ArrayFormatter assumes it does not produce
+                // characters that would need to be escaped within a JSON string, e.g. `'"'`.
+                // If support for user-provided format specifications is added, this assumption
+                // may need to be revisited
+                let options = FormatOptions::new().with_display_error(true);
+                let formatter = ArrayFormatter::try_new(array, &options)?;
+                (Box::new(formatter) as _, array.nulls().cloned())
+            }
+            false => return Err(ArrowError::InvalidArgumentError(format!("JSON Writer does not support data type: {d}"))),
+        }
+    })
+}
+
+fn encode_string(s: &str, out: &mut Vec<u8>) {
+    let mut serializer = serde_json::Serializer::new(out);
+    serializer.serialize_str(s).unwrap();
+}
+
+struct FieldEncoder<'a> {
+    field: FieldRef,
+    encoder: Box<dyn Encoder + 'a>,
+    nulls: Option<NullBuffer>,
+}
+
+struct StructArrayEncoder<'a> {
+    encoders: Vec<FieldEncoder<'a>>,
+    explicit_nulls: bool,
+}
+
+impl<'a> Encoder for StructArrayEncoder<'a> {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        out.push(b'{');
+        let mut is_first = true;
+        for field_encoder in &mut self.encoders {
+            let is_null = field_encoder.nulls.as_ref().is_some_and(|n| n.is_null(idx));
+            if is_null && !self.explicit_nulls {
+                continue;
+            }
+
+            if !is_first {
+                out.push(b',');
+            }
+            is_first = false;
+
+            encode_string(field_encoder.field.name(), out);
+            out.push(b':');
+
+            match is_null {
+                true => out.extend_from_slice(b"null"),
+                false => field_encoder.encoder.encode(idx, out),
+            }
+        }
+        out.push(b'}');
+    }
+}
+
+trait PrimitiveEncode: ArrowNativeType {
+    type Buffer;
+
+    // Workaround https://github.com/rust-lang/rust/issues/61415
+    fn init_buffer() -> Self::Buffer;
+
+    /// Encode the primitive value as bytes, returning a reference to that slice.
+    ///
+    /// `buf` is temporary space that may be used
+    fn encode(self, buf: &mut Self::Buffer) -> &[u8];
+}
+
+macro_rules! integer_encode {
+    ($($t:ty),*) => {
+        $(
+            impl PrimitiveEncode for $t {
+                type Buffer = [u8; Self::FORMATTED_SIZE];
+
+                fn init_buffer() -> Self::Buffer {
+                    [0; Self::FORMATTED_SIZE]
+                }
+
+                fn encode(self, buf: &mut Self::Buffer) -> &[u8] {
+                    lexical_core::write(self, buf)
+                }
+            }
+        )*
+    };
+}
+integer_encode!(i8, i16, i32, i64, u8, u16, u32, u64);
+
+macro_rules! float_encode {
+    ($($t:ty),*) => {
+        $(
+            impl PrimitiveEncode for $t {
+                type Buffer = [u8; Self::FORMATTED_SIZE];
+
+                fn init_buffer() -> Self::Buffer {
+                    [0; Self::FORMATTED_SIZE]
+                }
+
+                fn encode(self, buf: &mut Self::Buffer) -> &[u8] {
+                    if self.is_infinite() || self.is_nan() {
+                        b"null"
+                    } else {
+                        lexical_core::write(self, buf)
+                    }
+                }
+            }
+        )*
+    };
+}
+float_encode!(f32, f64);
+
+impl PrimitiveEncode for f16 {
+    type Buffer = <f32 as PrimitiveEncode>::Buffer;
+
+    fn init_buffer() -> Self::Buffer {
+        f32::init_buffer()
+    }
+
+    fn encode(self, buf: &mut Self::Buffer) -> &[u8] {
+        self.to_f32().encode(buf)
+    }
+}
+
+struct PrimitiveEncoder<N: PrimitiveEncode> {
+    values: ScalarBuffer<N>,
+    buffer: N::Buffer,
+}
+
+impl<N: PrimitiveEncode> PrimitiveEncoder<N> {
+    fn new<P: ArrowPrimitiveType<Native = N>>(array: &PrimitiveArray<P>) -> Self {
+        Self {
+            values: array.values().clone(),
+            buffer: N::init_buffer(),
+        }
+    }
+}
+
+impl<N: PrimitiveEncode> Encoder for PrimitiveEncoder<N> {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        out.extend_from_slice(self.values[idx].encode(&mut self.buffer));
+    }
+}
+
+struct BooleanEncoder(BooleanArray);
+
+impl Encoder for BooleanEncoder {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        match self.0.value(idx) {
+            true => out.extend_from_slice(b"true"),
+            false => out.extend_from_slice(b"false"),
+        }
+    }
+}
+
+struct StringEncoder<O: OffsetSizeTrait>(GenericStringArray<O>);
+
+impl<O: OffsetSizeTrait> Encoder for StringEncoder<O> {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        encode_string(self.0.value(idx), out);
+    }
+}
+
+struct ListEncoder<'a, O: OffsetSizeTrait> {
+    offsets: OffsetBuffer<O>,
+    nulls: Option<NullBuffer>,
+    encoder: Box<dyn Encoder + 'a>,
+}
+
+impl<'a, O: OffsetSizeTrait> ListEncoder<'a, O> {
+    fn try_new(
+        array: &'a GenericListArray<O>,
+        options: &EncoderOptions,
+    ) -> Result<Self, ArrowError> {
+        let (encoder, nulls) = make_encoder_impl(array.values().as_ref(), options)?;
+        Ok(Self {
+            offsets: array.offsets().clone(),
+            encoder,
+            nulls,
+        })
+    }
+}
+
+impl<'a, O: OffsetSizeTrait> Encoder for ListEncoder<'a, O> {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        let end = self.offsets[idx + 1].as_usize();
+        let start = self.offsets[idx].as_usize();
+        out.push(b'[');
+        match self.nulls.as_ref() {
+            Some(n) => (start..end).for_each(|idx| {
+                if idx != start {
+                    out.push(b',')
+                }
+                match n.is_null(idx) {
+                    true => out.extend_from_slice(b"null"),
+                    false => self.encoder.encode(idx, out),
+                }
+            }),
+            None => (start..end).for_each(|idx| {
+                if idx != start {
+                    out.push(b',')
+                }
+                self.encoder.encode(idx, out);
+            }),
+        }
+        out.push(b']');
+    }
+}
+
+struct DictionaryEncoder<'a, K: ArrowDictionaryKeyType> {
+    keys: ScalarBuffer<K::Native>,
+    encoder: Box<dyn Encoder + 'a>,
+}
+
+impl<'a, K: ArrowDictionaryKeyType> DictionaryEncoder<'a, K> {
+    fn try_new(
+        array: &'a DictionaryArray<K>,
+        options: &EncoderOptions,
+    ) -> Result<Self, ArrowError> {
+        let encoder = make_encoder(array.values().as_ref(), options)?;
+
+        Ok(Self {
+            keys: array.keys().values().clone(),
+            encoder,
+        })
+    }
+}
+
+impl<'a, K: ArrowDictionaryKeyType> Encoder for DictionaryEncoder<'a, K> {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        self.encoder.encode(self.keys[idx].as_usize(), out)
+    }
+}
+
+impl<'a> Encoder for ArrayFormatter<'a> {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        out.push(b'"');
+        // Should be infallible
+        // Note: We are making an assumption that the formatter does not produce characters that require escaping
+        let _ = write!(out, "{}", self.value(idx));
+        out.push(b'"')
+    }
+}
+
+struct NullEncoder;
+
+impl Encoder for NullEncoder {
+    fn encode(&mut self, _idx: usize, _out: &mut Vec<u8>) {
+        unreachable!()
+    }
+}
+
+struct MapEncoder<'a> {
+    offsets: OffsetBuffer<i32>,
+    keys: Box<dyn Encoder + 'a>,
+    values: Box<dyn Encoder + 'a>,
+    value_nulls: Option<NullBuffer>,
+    explicit_nulls: bool,
+}
+
+impl<'a> MapEncoder<'a> {
+    fn try_new(array: &'a MapArray, options: &EncoderOptions) -> Result<Self, ArrowError> {
+        let values = array.values();
+        let keys = array.keys();
+
+        if !matches!(keys.data_type(), DataType::Utf8 | DataType::LargeUtf8) {
+            return Err(ArrowError::JsonError(format!(
+                "Only UTF8 keys supported by JSON MapArray Writer: got {:?}",
+                keys.data_type()
+            )));
+        }
+
+        let (keys, key_nulls) = make_encoder_impl(keys, options)?;
+        let (values, value_nulls) = make_encoder_impl(values, options)?;
+
+        // We sanity check nulls as these are currently not enforced by MapArray (#1697)
+        if key_nulls.is_some_and(|x| x.null_count() != 0) {
+            return Err(ArrowError::InvalidArgumentError(
+                "Encountered nulls in MapArray keys".to_string(),
+            ));
+        }
+
+        if array.entries().nulls().is_some_and(|x| x.null_count() != 0) {
+            return Err(ArrowError::InvalidArgumentError(
+                "Encountered nulls in MapArray entries".to_string(),
+            ));
+        }
+
+        Ok(Self {
+            offsets: array.offsets().clone(),
+            keys,
+            values,
+            value_nulls,
+            explicit_nulls: options.explicit_nulls,
+        })
+    }
+}
+
+impl<'a> Encoder for MapEncoder<'a> {
+    fn encode(&mut self, idx: usize, out: &mut Vec<u8>) {
+        let end = self.offsets[idx + 1].as_usize();
+        let start = self.offsets[idx].as_usize();
+
+        let mut is_first = true;
+
+        out.push(b'{');
+        for idx in start..end {
+            let is_null = self.value_nulls.as_ref().is_some_and(|n| n.is_null(idx));
+            if is_null && !self.explicit_nulls {
+                continue;
+            }
+
+            if !is_first {
+                out.push(b',');
+            }
+            is_first = false;
+
+            self.keys.encode(idx, out);
+            out.push(b':');
+
+            match is_null {
+                true => out.extend_from_slice(b"null"),
+                false => self.values.encode(idx, out),
+            }
+        }
+        out.push(b'}');
+    }
+}
diff --git a/arrow/test/data/arrays.json b/arrow-json/test/data/arrays.json
similarity index 100%
rename from arrow/test/data/arrays.json
rename to arrow-json/test/data/arrays.json
diff --git a/arrow-json/test/data/basic.json b/arrow-json/test/data/basic.json
new file mode 100644
index 000000000000..fdcae9e6557e
--- /dev/null
+++ b/arrow-json/test/data/basic.json
@@ -0,0 +1,12 @@
+{"a":1, "b":2.0, "c":false, "d":"4", "e":"1970-1-2", "f": "1.02", "g": "2012-04-23T18:25:43.511", "h": 1.125}
+{"a":-10, "b":-3.5, "c":true, "d":"4", "e": "1969-12-31", "f": "-0.3", "g": "2016-04-23T18:25:43.511", "h": 3.5}
+{"a":2, "b":0.6, "c":false, "d":"text", "e": "1970-01-02 11:11:11", "f": "1377.223"}
+{"a":1, "b":2.0, "c":false, "d":"4", "f": "1337.009"}
+{"a":7, "b":-3.5, "c":true, "d":"4", "f": "1"}
+{"a":1, "b":0.6, "c":false, "d":"text", "f": "1338", "g": "2018-10-23T18:33:16.481"}
+{"a":1, "b":2.0, "c":false, "d":"4", "f": "12345829100000"}
+{"a":5, "b":-3.5, "c":true, "d":"4", "f": "99999999.99"}
+{"a":1, "b":0.6, "c":false, "d":"text", "f": "1"}
+{"a":1, "b":2.0, "c":false, "d":"4", "f": "1"}
+{"a":1, "b":-3.5, "c":true, "d":"4", "f": "1"}
+{"a":100000000000000, "b":0.6, "c":false, "d":"text", "f": "1"}
\ No newline at end of file
diff --git a/arrow/test/data/basic_nulls.json b/arrow-json/test/data/basic_nulls.json
similarity index 100%
rename from arrow/test/data/basic_nulls.json
rename to arrow-json/test/data/basic_nulls.json
diff --git a/arrow/test/data/list_string_dict_nested.json b/arrow-json/test/data/list_string_dict_nested.json
similarity index 100%
rename from arrow/test/data/list_string_dict_nested.json
rename to arrow-json/test/data/list_string_dict_nested.json
diff --git a/arrow/test/data/list_string_dict_nested_nulls.json b/arrow-json/test/data/list_string_dict_nested_nulls.json
similarity index 100%
rename from arrow/test/data/list_string_dict_nested_nulls.json
rename to arrow-json/test/data/list_string_dict_nested_nulls.json
diff --git a/arrow/test/data/mixed_arrays.json b/arrow-json/test/data/mixed_arrays.json
similarity index 100%
rename from arrow/test/data/mixed_arrays.json
rename to arrow-json/test/data/mixed_arrays.json
diff --git a/arrow/test/data/mixed_arrays.json.gz b/arrow-json/test/data/mixed_arrays.json.gz
similarity index 100%
rename from arrow/test/data/mixed_arrays.json.gz
rename to arrow-json/test/data/mixed_arrays.json.gz
diff --git a/arrow/test/data/nested_structs.json b/arrow-json/test/data/nested_structs.json
similarity index 100%
rename from arrow/test/data/nested_structs.json
rename to arrow-json/test/data/nested_structs.json
diff --git a/arrow-json/test/data/nested_with_nulls.json b/arrow-json/test/data/nested_with_nulls.json
new file mode 100644
index 000000000000..932565d56063
--- /dev/null
+++ b/arrow-json/test/data/nested_with_nulls.json
@@ -0,0 +1,4 @@
+{"a": null, "b": null, "c":  null, "d": {"d1":         null, "d2": [null, 1, 2, null]}}
+{"a": null, "b": -3.5, "c":  true, "d": {"d1":         null, "d2": null}}
+{"a": null, "b": null, "c": false, "d": {"d1": "1970-01-01", "d2": null}}
+{"a":    1, "b":  2.0, "c": false, "d": {"d1":         null, "d2": null}}
diff --git a/arrow-ord/Cargo.toml b/arrow-ord/Cargo.toml
new file mode 100644
index 000000000000..c9c30074fe6e
--- /dev/null
+++ b/arrow-ord/Cargo.toml
@@ -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]
+name = "arrow-ord"
+version = { workspace = true }
+description = "Ordering kernels for arrow arrays"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_ord"
+path = "src/lib.rs"
+bench = false
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-data = { workspace = true }
+arrow-schema = { workspace = true }
+arrow-select = { workspace = true }
+num = { version = "0.4", default-features = false, features = ["std"] }
+half = { version = "2.1", default-features = false, features = ["num-traits"] }
+
+[dev-dependencies]
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
diff --git a/arrow-ord/src/cmp.rs b/arrow-ord/src/cmp.rs
new file mode 100644
index 000000000000..bfb1f64e2eb8
--- /dev/null
+++ b/arrow-ord/src/cmp.rs
@@ -0,0 +1,705 @@
+// 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.
+
+//! Comparison kernels for `Array`s.
+//!
+//! These kernels can leverage SIMD if available on your system.  Currently no runtime
+//! detection is provided, you should enable the specific SIMD intrinsics using
+//! `RUSTFLAGS="-C target-feature=+avx2"` for example.  See the documentation
+//! [here](https://doc.rust-lang.org/stable/core/arch/) for more information.
+//!
+
+use arrow_array::cast::AsArray;
+use arrow_array::types::ByteArrayType;
+use arrow_array::{
+    downcast_primitive_array, AnyDictionaryArray, Array, ArrowNativeTypeOp, BooleanArray, Datum,
+    FixedSizeBinaryArray, GenericByteArray,
+};
+use arrow_buffer::bit_util::ceil;
+use arrow_buffer::{BooleanBuffer, MutableBuffer, NullBuffer};
+use arrow_schema::ArrowError;
+use arrow_select::take::take;
+use std::ops::Not;
+
+#[derive(Debug, Copy, Clone)]
+enum Op {
+    Equal,
+    NotEqual,
+    Less,
+    LessEqual,
+    Greater,
+    GreaterEqual,
+    Distinct,
+    NotDistinct,
+}
+
+impl std::fmt::Display for Op {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Op::Equal => write!(f, "=="),
+            Op::NotEqual => write!(f, "!="),
+            Op::Less => write!(f, "<"),
+            Op::LessEqual => write!(f, "<="),
+            Op::Greater => write!(f, ">"),
+            Op::GreaterEqual => write!(f, ">="),
+            Op::Distinct => write!(f, "IS DISTINCT FROM"),
+            Op::NotDistinct => write!(f, "IS NOT DISTINCT FROM"),
+        }
+    }
+}
+
+/// Perform `left == right` operation on two [`Datum`]
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros as different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+///
+/// Please refer to [`f32::total_cmp`] and [`f64::total_cmp`]
+pub fn eq(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    compare_op(Op::Equal, lhs, rhs)
+}
+
+/// Perform `left != right` operation on two [`Datum`]
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros as different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+///
+/// Please refer to [`f32::total_cmp`] and [`f64::total_cmp`]
+pub fn neq(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    compare_op(Op::NotEqual, lhs, rhs)
+}
+
+/// Perform `left < right` operation on two [`Datum`]
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros as different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+///
+/// Please refer to [`f32::total_cmp`] and [`f64::total_cmp`]
+pub fn lt(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    compare_op(Op::Less, lhs, rhs)
+}
+
+/// Perform `left <= right` operation on two [`Datum`]
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros as different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+///
+/// Please refer to [`f32::total_cmp`] and [`f64::total_cmp`]
+pub fn lt_eq(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    compare_op(Op::LessEqual, lhs, rhs)
+}
+
+/// Perform `left > right` operation on two [`Datum`]
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros as different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+///
+/// Please refer to [`f32::total_cmp`] and [`f64::total_cmp`]
+pub fn gt(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    compare_op(Op::Greater, lhs, rhs)
+}
+
+/// Perform `left >= right` operation on two [`Datum`]
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros as different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+///
+/// Please refer to [`f32::total_cmp`] and [`f64::total_cmp`]
+pub fn gt_eq(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    compare_op(Op::GreaterEqual, lhs, rhs)
+}
+
+/// Perform `left IS DISTINCT FROM right` operation on two [`Datum`]
+///
+/// [`distinct`] is similar to [`neq`], only differing in null handling. In particular, two
+/// operands are considered DISTINCT if they have a different value or if one of them is NULL
+/// and the other isn't. The result of [`distinct`] is never NULL.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros as different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+///
+/// Please refer to [`f32::total_cmp`] and [`f64::total_cmp`]
+pub fn distinct(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    compare_op(Op::Distinct, lhs, rhs)
+}
+
+/// Perform `left IS NOT DISTINCT FROM right` operation on two [`Datum`]
+///
+/// [`not_distinct`] is similar to [`eq`], only differing in null handling. In particular, two
+/// operands are considered `NOT DISTINCT` if they have the same value or if both of them
+/// is NULL. The result of [`not_distinct`] is never NULL.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros as different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+///
+/// Please refer to [`f32::total_cmp`] and [`f64::total_cmp`]
+pub fn not_distinct(lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    compare_op(Op::NotDistinct, lhs, rhs)
+}
+
+/// Perform `op` on the provided `Datum`
+#[inline(never)]
+fn compare_op(op: Op, lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    use arrow_schema::DataType::*;
+    let (l, l_s) = lhs.get();
+    let (r, r_s) = rhs.get();
+
+    let l_len = l.len();
+    let r_len = r.len();
+
+    if l_len != r_len && !l_s && !r_s {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "Cannot compare arrays of different lengths, got {l_len} vs {r_len}"
+        )));
+    }
+
+    let len = match l_s {
+        true => r_len,
+        false => l_len,
+    };
+
+    let l_nulls = l.logical_nulls();
+    let r_nulls = r.logical_nulls();
+
+    let l_v = l.as_any_dictionary_opt();
+    let l = l_v.map(|x| x.values().as_ref()).unwrap_or(l);
+    let l_t = l.data_type();
+
+    let r_v = r.as_any_dictionary_opt();
+    let r = r_v.map(|x| x.values().as_ref()).unwrap_or(r);
+    let r_t = r.data_type();
+
+    if l_t != r_t || l_t.is_nested() {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "Invalid comparison operation: {l_t} {op} {r_t}"
+        )));
+    }
+
+    // Defer computation as may not be necessary
+    let values = || -> BooleanBuffer {
+        let d = downcast_primitive_array! {
+            (l, r) => apply(op, l.values().as_ref(), l_s, l_v, r.values().as_ref(), r_s, r_v),
+            (Boolean, Boolean) => apply(op, l.as_boolean(), l_s, l_v, r.as_boolean(), r_s, r_v),
+            (Utf8, Utf8) => apply(op, l.as_string::<i32>(), l_s, l_v, r.as_string::<i32>(), r_s, r_v),
+            (LargeUtf8, LargeUtf8) => apply(op, l.as_string::<i64>(), l_s, l_v, r.as_string::<i64>(), r_s, r_v),
+            (Binary, Binary) => apply(op, l.as_binary::<i32>(), l_s, l_v, r.as_binary::<i32>(), r_s, r_v),
+            (LargeBinary, LargeBinary) => apply(op, l.as_binary::<i64>(), l_s, l_v, r.as_binary::<i64>(), r_s, r_v),
+            (FixedSizeBinary(_), FixedSizeBinary(_)) => apply(op, l.as_fixed_size_binary(), l_s, l_v, r.as_fixed_size_binary(), r_s, r_v),
+            (Null, Null) => None,
+            _ => unreachable!(),
+        };
+        d.unwrap_or_else(|| BooleanBuffer::new_unset(len))
+    };
+
+    let l_nulls = l_nulls.filter(|n| n.null_count() > 0);
+    let r_nulls = r_nulls.filter(|n| n.null_count() > 0);
+    Ok(match (l_nulls, l_s, r_nulls, r_s) {
+        (Some(l), true, Some(r), true) | (Some(l), false, Some(r), false) => {
+            // Either both sides are scalar or neither side is scalar
+            match op {
+                Op::Distinct => {
+                    let values = values();
+                    let l = l.inner().bit_chunks().iter_padded();
+                    let r = r.inner().bit_chunks().iter_padded();
+                    let ne = values.bit_chunks().iter_padded();
+
+                    let c = |((l, r), n)| ((l ^ r) | (l & r & n));
+                    let buffer = l.zip(r).zip(ne).map(c).collect();
+                    BooleanBuffer::new(buffer, 0, len).into()
+                }
+                Op::NotDistinct => {
+                    let values = values();
+                    let l = l.inner().bit_chunks().iter_padded();
+                    let r = r.inner().bit_chunks().iter_padded();
+                    let e = values.bit_chunks().iter_padded();
+
+                    let c = |((l, r), e)| u64::not(l | r) | (l & r & e);
+                    let buffer = l.zip(r).zip(e).map(c).collect();
+                    BooleanBuffer::new(buffer, 0, len).into()
+                }
+                _ => BooleanArray::new(values(), NullBuffer::union(Some(&l), Some(&r))),
+            }
+        }
+        (Some(_), true, Some(a), false) | (Some(a), false, Some(_), true) => {
+            // Scalar is null, other side is non-scalar and nullable
+            match op {
+                Op::Distinct => a.into_inner().into(),
+                Op::NotDistinct => a.into_inner().not().into(),
+                _ => BooleanArray::new_null(len),
+            }
+        }
+        (Some(nulls), is_scalar, None, _) | (None, _, Some(nulls), is_scalar) => {
+            // Only one side is nullable
+            match is_scalar {
+                true => match op {
+                    // Scalar is null, other side is not nullable
+                    Op::Distinct => BooleanBuffer::new_set(len).into(),
+                    Op::NotDistinct => BooleanBuffer::new_unset(len).into(),
+                    _ => BooleanArray::new_null(len),
+                },
+                false => match op {
+                    Op::Distinct => {
+                        let values = values();
+                        let l = nulls.inner().bit_chunks().iter_padded();
+                        let ne = values.bit_chunks().iter_padded();
+                        let c = |(l, n)| u64::not(l) | n;
+                        let buffer = l.zip(ne).map(c).collect();
+                        BooleanBuffer::new(buffer, 0, len).into()
+                    }
+                    Op::NotDistinct => (nulls.inner() & &values()).into(),
+                    _ => BooleanArray::new(values(), Some(nulls)),
+                },
+            }
+        }
+        // Neither side is nullable
+        (None, _, None, _) => BooleanArray::new(values(), None),
+    })
+}
+
+/// Perform a potentially vectored `op` on the provided `ArrayOrd`
+fn apply<T: ArrayOrd>(
+    op: Op,
+    l: T,
+    l_s: bool,
+    l_v: Option<&dyn AnyDictionaryArray>,
+    r: T,
+    r_s: bool,
+    r_v: Option<&dyn AnyDictionaryArray>,
+) -> Option<BooleanBuffer> {
+    if l.len() == 0 || r.len() == 0 {
+        return None; // Handle empty dictionaries
+    }
+
+    if !l_s && !r_s && (l_v.is_some() || r_v.is_some()) {
+        // Not scalar and at least one side has a dictionary, need to perform vectored comparison
+        let l_v = l_v
+            .map(|x| x.normalized_keys())
+            .unwrap_or_else(|| (0..l.len()).collect());
+
+        let r_v = r_v
+            .map(|x| x.normalized_keys())
+            .unwrap_or_else(|| (0..r.len()).collect());
+
+        assert_eq!(l_v.len(), r_v.len()); // Sanity check
+
+        Some(match op {
+            Op::Equal | Op::NotDistinct => apply_op_vectored(l, &l_v, r, &r_v, false, T::is_eq),
+            Op::NotEqual | Op::Distinct => apply_op_vectored(l, &l_v, r, &r_v, true, T::is_eq),
+            Op::Less => apply_op_vectored(l, &l_v, r, &r_v, false, T::is_lt),
+            Op::LessEqual => apply_op_vectored(r, &r_v, l, &l_v, true, T::is_lt),
+            Op::Greater => apply_op_vectored(r, &r_v, l, &l_v, false, T::is_lt),
+            Op::GreaterEqual => apply_op_vectored(l, &l_v, r, &r_v, true, T::is_lt),
+        })
+    } else {
+        let l_s = l_s.then(|| l_v.map(|x| x.normalized_keys()[0]).unwrap_or_default());
+        let r_s = r_s.then(|| r_v.map(|x| x.normalized_keys()[0]).unwrap_or_default());
+
+        let buffer = match op {
+            Op::Equal | Op::NotDistinct => apply_op(l, l_s, r, r_s, false, T::is_eq),
+            Op::NotEqual | Op::Distinct => apply_op(l, l_s, r, r_s, true, T::is_eq),
+            Op::Less => apply_op(l, l_s, r, r_s, false, T::is_lt),
+            Op::LessEqual => apply_op(r, r_s, l, l_s, true, T::is_lt),
+            Op::Greater => apply_op(r, r_s, l, l_s, false, T::is_lt),
+            Op::GreaterEqual => apply_op(l, l_s, r, r_s, true, T::is_lt),
+        };
+
+        // If a side had a dictionary, and was not scalar, we need to materialize this
+        Some(match (l_v, r_v) {
+            (Some(l_v), _) if l_s.is_none() => take_bits(l_v, buffer),
+            (_, Some(r_v)) if r_s.is_none() => take_bits(r_v, buffer),
+            _ => buffer,
+        })
+    }
+}
+
+/// Perform a take operation on `buffer` with the given dictionary
+fn take_bits(v: &dyn AnyDictionaryArray, buffer: BooleanBuffer) -> BooleanBuffer {
+    let array = take(&BooleanArray::new(buffer, None), v.keys(), None).unwrap();
+    array.as_boolean().values().clone()
+}
+
+/// Invokes `f` with values `0..len` collecting the boolean results into a new `BooleanBuffer`
+///
+/// This is similar to [`MutableBuffer::collect_bool`] but with
+/// the option to efficiently negate the result
+fn collect_bool(len: usize, neg: bool, f: impl Fn(usize) -> bool) -> BooleanBuffer {
+    let mut buffer = MutableBuffer::new(ceil(len, 64) * 8);
+
+    let chunks = len / 64;
+    let remainder = len % 64;
+    for chunk in 0..chunks {
+        let mut packed = 0;
+        for bit_idx in 0..64 {
+            let i = bit_idx + chunk * 64;
+            packed |= (f(i) as u64) << bit_idx;
+        }
+        if neg {
+            packed = !packed
+        }
+
+        // SAFETY: Already allocated sufficient capacity
+        unsafe { buffer.push_unchecked(packed) }
+    }
+
+    if remainder != 0 {
+        let mut packed = 0;
+        for bit_idx in 0..remainder {
+            let i = bit_idx + chunks * 64;
+            packed |= (f(i) as u64) << bit_idx;
+        }
+        if neg {
+            packed = !packed
+        }
+
+        // SAFETY: Already allocated sufficient capacity
+        unsafe { buffer.push_unchecked(packed) }
+    }
+    BooleanBuffer::new(buffer.into(), 0, len)
+}
+
+/// Applies `op` to possibly scalar `ArrayOrd`
+///
+/// If l is scalar `l_s` will be `Some(idx)` where `idx` is the index of the scalar value in `l`
+/// If r is scalar `r_s` will be `Some(idx)` where `idx` is the index of the scalar value in `r`
+///
+/// If `neg` is true the result of `op` will be negated
+fn apply_op<T: ArrayOrd>(
+    l: T,
+    l_s: Option<usize>,
+    r: T,
+    r_s: Option<usize>,
+    neg: bool,
+    op: impl Fn(T::Item, T::Item) -> bool,
+) -> BooleanBuffer {
+    match (l_s, r_s) {
+        (None, None) => {
+            assert_eq!(l.len(), r.len());
+            collect_bool(l.len(), neg, |idx| unsafe {
+                op(l.value_unchecked(idx), r.value_unchecked(idx))
+            })
+        }
+        (Some(l_s), Some(r_s)) => {
+            let a = l.value(l_s);
+            let b = r.value(r_s);
+            std::iter::once(op(a, b) ^ neg).collect()
+        }
+        (Some(l_s), None) => {
+            let v = l.value(l_s);
+            collect_bool(r.len(), neg, |idx| op(v, unsafe { r.value_unchecked(idx) }))
+        }
+        (None, Some(r_s)) => {
+            let v = r.value(r_s);
+            collect_bool(l.len(), neg, |idx| op(unsafe { l.value_unchecked(idx) }, v))
+        }
+    }
+}
+
+/// Applies `op` to possibly scalar `ArrayOrd` with the given indices
+fn apply_op_vectored<T: ArrayOrd>(
+    l: T,
+    l_v: &[usize],
+    r: T,
+    r_v: &[usize],
+    neg: bool,
+    op: impl Fn(T::Item, T::Item) -> bool,
+) -> BooleanBuffer {
+    assert_eq!(l_v.len(), r_v.len());
+    collect_bool(l_v.len(), neg, |idx| unsafe {
+        let l_idx = *l_v.get_unchecked(idx);
+        let r_idx = *r_v.get_unchecked(idx);
+        op(l.value_unchecked(l_idx), r.value_unchecked(r_idx))
+    })
+}
+
+trait ArrayOrd {
+    type Item: Copy + Default;
+
+    fn len(&self) -> usize;
+
+    fn value(&self, idx: usize) -> Self::Item {
+        assert!(idx < self.len());
+        unsafe { self.value_unchecked(idx) }
+    }
+
+    /// # Safety
+    ///
+    /// Safe if `idx < self.len()`
+    unsafe fn value_unchecked(&self, idx: usize) -> Self::Item;
+
+    fn is_eq(l: Self::Item, r: Self::Item) -> bool;
+
+    fn is_lt(l: Self::Item, r: Self::Item) -> bool;
+}
+
+impl<'a> ArrayOrd for &'a BooleanArray {
+    type Item = bool;
+
+    fn len(&self) -> usize {
+        Array::len(self)
+    }
+
+    unsafe fn value_unchecked(&self, idx: usize) -> Self::Item {
+        BooleanArray::value_unchecked(self, idx)
+    }
+
+    fn is_eq(l: Self::Item, r: Self::Item) -> bool {
+        l == r
+    }
+
+    fn is_lt(l: Self::Item, r: Self::Item) -> bool {
+        !l & r
+    }
+}
+
+impl<T: ArrowNativeTypeOp> ArrayOrd for &[T] {
+    type Item = T;
+
+    fn len(&self) -> usize {
+        (*self).len()
+    }
+
+    unsafe fn value_unchecked(&self, idx: usize) -> Self::Item {
+        *self.get_unchecked(idx)
+    }
+
+    fn is_eq(l: Self::Item, r: Self::Item) -> bool {
+        l.is_eq(r)
+    }
+
+    fn is_lt(l: Self::Item, r: Self::Item) -> bool {
+        l.is_lt(r)
+    }
+}
+
+impl<'a, T: ByteArrayType> ArrayOrd for &'a GenericByteArray<T> {
+    type Item = &'a [u8];
+
+    fn len(&self) -> usize {
+        Array::len(self)
+    }
+
+    unsafe fn value_unchecked(&self, idx: usize) -> Self::Item {
+        GenericByteArray::value_unchecked(self, idx).as_ref()
+    }
+
+    fn is_eq(l: Self::Item, r: Self::Item) -> bool {
+        l == r
+    }
+
+    fn is_lt(l: Self::Item, r: Self::Item) -> bool {
+        l < r
+    }
+}
+
+impl<'a> ArrayOrd for &'a FixedSizeBinaryArray {
+    type Item = &'a [u8];
+
+    fn len(&self) -> usize {
+        Array::len(self)
+    }
+
+    unsafe fn value_unchecked(&self, idx: usize) -> Self::Item {
+        FixedSizeBinaryArray::value_unchecked(self, idx)
+    }
+
+    fn is_eq(l: Self::Item, r: Self::Item) -> bool {
+        l == r
+    }
+
+    fn is_lt(l: Self::Item, r: Self::Item) -> bool {
+        l < r
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow_array::{DictionaryArray, Int32Array, Scalar, StringArray};
+
+    use super::*;
+
+    #[test]
+    fn test_null_dict() {
+        let a = DictionaryArray::new(Int32Array::new_null(10), Arc::new(Int32Array::new_null(0)));
+        let r = eq(&a, &a).unwrap();
+        assert_eq!(r.null_count(), 10);
+
+        let a = DictionaryArray::new(
+            Int32Array::from(vec![1, 2, 3, 4, 5, 6]),
+            Arc::new(Int32Array::new_null(10)),
+        );
+        let r = eq(&a, &a).unwrap();
+        assert_eq!(r.null_count(), 6);
+
+        let scalar =
+            DictionaryArray::new(Int32Array::new_null(1), Arc::new(Int32Array::new_null(0)));
+        let r = eq(&a, &Scalar::new(&scalar)).unwrap();
+        assert_eq!(r.null_count(), 6);
+
+        let scalar =
+            DictionaryArray::new(Int32Array::new_null(1), Arc::new(Int32Array::new_null(0)));
+        let r = eq(&Scalar::new(&scalar), &Scalar::new(&scalar)).unwrap();
+        assert_eq!(r.null_count(), 1);
+
+        let a = DictionaryArray::new(
+            Int32Array::from(vec![0, 1, 2]),
+            Arc::new(Int32Array::from(vec![3, 2, 1])),
+        );
+        let r = eq(&a, &Scalar::new(&scalar)).unwrap();
+        assert_eq!(r.null_count(), 3);
+    }
+
+    #[test]
+    fn is_distinct_from_non_nulls() {
+        let left_int_array = Int32Array::from(vec![0, 1, 2, 3, 4]);
+        let right_int_array = Int32Array::from(vec![4, 3, 2, 1, 0]);
+
+        assert_eq!(
+            BooleanArray::from(vec![true, true, false, true, true,]),
+            distinct(&left_int_array, &right_int_array).unwrap()
+        );
+        assert_eq!(
+            BooleanArray::from(vec![false, false, true, false, false,]),
+            not_distinct(&left_int_array, &right_int_array).unwrap()
+        );
+    }
+
+    #[test]
+    fn is_distinct_from_nulls() {
+        // [0, 0, NULL, 0, 0, 0]
+        let left_int_array = Int32Array::new(
+            vec![0, 0, 1, 3, 0, 0].into(),
+            Some(NullBuffer::from(vec![true, true, false, true, true, true])),
+        );
+        // [0, NULL, NULL, NULL, 0, NULL]
+        let right_int_array = Int32Array::new(
+            vec![0; 6].into(),
+            Some(NullBuffer::from(vec![
+                true, false, false, false, true, false,
+            ])),
+        );
+
+        assert_eq!(
+            BooleanArray::from(vec![false, true, false, true, false, true,]),
+            distinct(&left_int_array, &right_int_array).unwrap()
+        );
+
+        assert_eq!(
+            BooleanArray::from(vec![true, false, true, false, true, false,]),
+            not_distinct(&left_int_array, &right_int_array).unwrap()
+        );
+    }
+
+    #[test]
+    fn test_distinct_scalar() {
+        let a = Int32Array::new_scalar(12);
+        let b = Int32Array::new_scalar(12);
+        assert!(!distinct(&a, &b).unwrap().value(0));
+        assert!(not_distinct(&a, &b).unwrap().value(0));
+
+        let a = Int32Array::new_scalar(12);
+        let b = Int32Array::new_null(1);
+        assert!(distinct(&a, &b).unwrap().value(0));
+        assert!(!not_distinct(&a, &b).unwrap().value(0));
+        assert!(distinct(&b, &a).unwrap().value(0));
+        assert!(!not_distinct(&b, &a).unwrap().value(0));
+
+        let b = Scalar::new(b);
+        assert!(distinct(&a, &b).unwrap().value(0));
+        assert!(!not_distinct(&a, &b).unwrap().value(0));
+
+        assert!(!distinct(&b, &b).unwrap().value(0));
+        assert!(not_distinct(&b, &b).unwrap().value(0));
+
+        let a = Int32Array::new(
+            vec![0, 1, 2, 3].into(),
+            Some(vec![false, false, true, true].into()),
+        );
+        let expected = BooleanArray::from(vec![false, false, true, true]);
+        assert_eq!(distinct(&a, &b).unwrap(), expected);
+        assert_eq!(distinct(&b, &a).unwrap(), expected);
+
+        let expected = BooleanArray::from(vec![true, true, false, false]);
+        assert_eq!(not_distinct(&a, &b).unwrap(), expected);
+        assert_eq!(not_distinct(&b, &a).unwrap(), expected);
+
+        let b = Int32Array::new_scalar(1);
+        let expected = BooleanArray::from(vec![true; 4]);
+        assert_eq!(distinct(&a, &b).unwrap(), expected);
+        assert_eq!(distinct(&b, &a).unwrap(), expected);
+        let expected = BooleanArray::from(vec![false; 4]);
+        assert_eq!(not_distinct(&a, &b).unwrap(), expected);
+        assert_eq!(not_distinct(&b, &a).unwrap(), expected);
+
+        let b = Int32Array::new_scalar(3);
+        let expected = BooleanArray::from(vec![true, true, true, false]);
+        assert_eq!(distinct(&a, &b).unwrap(), expected);
+        assert_eq!(distinct(&b, &a).unwrap(), expected);
+        let expected = BooleanArray::from(vec![false, false, false, true]);
+        assert_eq!(not_distinct(&a, &b).unwrap(), expected);
+        assert_eq!(not_distinct(&b, &a).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_scalar_negation() {
+        let a = Int32Array::new_scalar(54);
+        let b = Int32Array::new_scalar(54);
+        let r = eq(&a, &b).unwrap();
+        assert!(r.value(0));
+
+        let r = neq(&a, &b).unwrap();
+        assert!(!r.value(0))
+    }
+
+    #[test]
+    fn test_scalar_empty() {
+        let a = Int32Array::new_null(0);
+        let b = Int32Array::new_scalar(23);
+        let r = eq(&a, &b).unwrap();
+        assert_eq!(r.len(), 0);
+        let r = eq(&b, &a).unwrap();
+        assert_eq!(r.len(), 0);
+    }
+
+    #[test]
+    fn test_dictionary_nulls() {
+        let values = StringArray::from(vec![Some("us-west"), Some("us-east")]);
+        let nulls = NullBuffer::from(vec![false, true, true]);
+
+        let key_values = vec![100i32, 1i32, 0i32].into();
+        let keys = Int32Array::new(key_values, Some(nulls));
+        let col = DictionaryArray::try_new(keys, Arc::new(values)).unwrap();
+
+        neq(&col.slice(0, col.len() - 1), &col.slice(1, col.len() - 1)).unwrap();
+    }
+}
diff --git a/arrow-ord/src/comparison.rs b/arrow-ord/src/comparison.rs
new file mode 100644
index 000000000000..4d552b038a7d
--- /dev/null
+++ b/arrow-ord/src/comparison.rs
@@ -0,0 +1,4630 @@
+// 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.
+
+//! Comparison kernels for `Array`s.
+//!
+//! These kernels can leverage SIMD if available on your system.  Currently no runtime
+//! detection is provided, you should enable the specific SIMD intrinsics using
+//! `RUSTFLAGS="-C target-feature=+avx2"` for example.  See the documentation
+//! [here](https://doc.rust-lang.org/stable/core/arch/) for more information.
+//!
+
+use half::f16;
+use std::sync::Arc;
+
+use arrow_array::cast::*;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::i256;
+use arrow_buffer::{bit_util, BooleanBuffer, MutableBuffer, NullBuffer};
+use arrow_schema::{ArrowError, DataType, IntervalUnit, TimeUnit};
+
+/// Calls $RIGHT.$TY() (e.g. `right.to_i128()`) with a nice error message.
+/// Type of expression is `Result<.., ArrowError>`
+macro_rules! try_to_type {
+    ($RIGHT: expr, $TY: ident) => {
+        try_to_type_result($RIGHT.$TY(), &format!("{:?}", $RIGHT), stringify!($TY))
+    };
+}
+
+// Avoids creating a closure for each combination of `$RIGHT` and `$TY`
+fn try_to_type_result<T>(value: Option<T>, right: &str, ty: &str) -> Result<T, ArrowError> {
+    value.ok_or_else(|| ArrowError::ComputeError(format!("Could not convert {right} with {ty}",)))
+}
+
+fn make_primitive_scalar<T: num::ToPrimitive + std::fmt::Debug>(
+    d: &DataType,
+    scalar: T,
+) -> Result<ArrayRef, ArrowError> {
+    match d {
+        DataType::Int8 => {
+            let right = try_to_type!(scalar, to_i8)?;
+            Ok(Arc::new(PrimitiveArray::<Int8Type>::from(vec![right])))
+        }
+        DataType::Int16 => {
+            let right = try_to_type!(scalar, to_i16)?;
+            Ok(Arc::new(PrimitiveArray::<Int16Type>::from(vec![right])))
+        }
+        DataType::Int32 => {
+            let right = try_to_type!(scalar, to_i32)?;
+            Ok(Arc::new(PrimitiveArray::<Int32Type>::from(vec![right])))
+        }
+        DataType::Int64 => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(PrimitiveArray::<Int64Type>::from(vec![right])))
+        }
+        DataType::UInt8 => {
+            let right = try_to_type!(scalar, to_u8)?;
+            Ok(Arc::new(PrimitiveArray::<UInt8Type>::from(vec![right])))
+        }
+        DataType::UInt16 => {
+            let right = try_to_type!(scalar, to_u16)?;
+            Ok(Arc::new(PrimitiveArray::<UInt16Type>::from(vec![right])))
+        }
+        DataType::UInt32 => {
+            let right = try_to_type!(scalar, to_u32)?;
+            Ok(Arc::new(PrimitiveArray::<UInt32Type>::from(vec![right])))
+        }
+        DataType::UInt64 => {
+            let right = try_to_type!(scalar, to_u64)?;
+            Ok(Arc::new(PrimitiveArray::<UInt64Type>::from(vec![right])))
+        }
+        DataType::Float16 => {
+            let right = try_to_type!(scalar, to_f32)?;
+            Ok(Arc::new(PrimitiveArray::<Float16Type>::from(vec![
+                f16::from_f32(right),
+            ])))
+        }
+        DataType::Float32 => {
+            let right = try_to_type!(scalar, to_f32)?;
+            Ok(Arc::new(PrimitiveArray::<Float32Type>::from(vec![right])))
+        }
+        DataType::Float64 => {
+            let right = try_to_type!(scalar, to_f64)?;
+            Ok(Arc::new(PrimitiveArray::<Float64Type>::from(vec![right])))
+        }
+        DataType::Decimal128(_, _) => {
+            let right = try_to_type!(scalar, to_i128)?;
+            Ok(Arc::new(
+                PrimitiveArray::<Decimal128Type>::from(vec![right]).with_data_type(d.clone()),
+            ))
+        }
+        DataType::Decimal256(_, _) => {
+            let right = try_to_type!(scalar, to_i128)?;
+            Ok(Arc::new(
+                PrimitiveArray::<Decimal256Type>::from(vec![i256::from_i128(right)])
+                    .with_data_type(d.clone()),
+            ))
+        }
+        DataType::Date32 => {
+            let right = try_to_type!(scalar, to_i32)?;
+            Ok(Arc::new(PrimitiveArray::<Date32Type>::from(vec![right])))
+        }
+        DataType::Date64 => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(PrimitiveArray::<Date64Type>::from(vec![right])))
+        }
+        DataType::Timestamp(TimeUnit::Nanosecond, _) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(
+                PrimitiveArray::<TimestampNanosecondType>::from(vec![right])
+                    .with_data_type(d.clone()),
+            ))
+        }
+        DataType::Timestamp(TimeUnit::Microsecond, _) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(
+                PrimitiveArray::<TimestampMicrosecondType>::from(vec![right])
+                    .with_data_type(d.clone()),
+            ))
+        }
+        DataType::Timestamp(TimeUnit::Millisecond, _) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(
+                PrimitiveArray::<TimestampMillisecondType>::from(vec![right])
+                    .with_data_type(d.clone()),
+            ))
+        }
+        DataType::Timestamp(TimeUnit::Second, _) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(
+                PrimitiveArray::<TimestampSecondType>::from(vec![right]).with_data_type(d.clone()),
+            ))
+        }
+        DataType::Time32(TimeUnit::Second) => {
+            let right = try_to_type!(scalar, to_i32)?;
+            Ok(Arc::new(PrimitiveArray::<Time32SecondType>::from(vec![
+                right,
+            ])))
+        }
+        DataType::Time32(TimeUnit::Millisecond) => {
+            let right = try_to_type!(scalar, to_i32)?;
+            Ok(Arc::new(PrimitiveArray::<Time32MillisecondType>::from(
+                vec![right],
+            )))
+        }
+        DataType::Time64(TimeUnit::Microsecond) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(PrimitiveArray::<Time64MicrosecondType>::from(
+                vec![right],
+            )))
+        }
+        DataType::Time64(TimeUnit::Nanosecond) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(PrimitiveArray::<Time64NanosecondType>::from(
+                vec![right],
+            )))
+        }
+        DataType::Interval(IntervalUnit::YearMonth) => {
+            let right = try_to_type!(scalar, to_i32)?;
+            Ok(Arc::new(PrimitiveArray::<IntervalYearMonthType>::from(
+                vec![right],
+            )))
+        }
+        DataType::Interval(IntervalUnit::DayTime) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(PrimitiveArray::<IntervalDayTimeType>::from(vec![
+                right,
+            ])))
+        }
+        DataType::Interval(IntervalUnit::MonthDayNano) => {
+            let right = try_to_type!(scalar, to_i128)?;
+            Ok(Arc::new(PrimitiveArray::<IntervalMonthDayNanoType>::from(
+                vec![right],
+            )))
+        }
+        DataType::Duration(TimeUnit::Second) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(PrimitiveArray::<DurationSecondType>::from(vec![
+                right,
+            ])))
+        }
+        DataType::Duration(TimeUnit::Millisecond) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(PrimitiveArray::<DurationMillisecondType>::from(
+                vec![right],
+            )))
+        }
+        DataType::Duration(TimeUnit::Microsecond) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(PrimitiveArray::<DurationMicrosecondType>::from(
+                vec![right],
+            )))
+        }
+        DataType::Duration(TimeUnit::Nanosecond) => {
+            let right = try_to_type!(scalar, to_i64)?;
+            Ok(Arc::new(PrimitiveArray::<DurationNanosecondType>::from(
+                vec![right],
+            )))
+        }
+        DataType::Dictionary(_, v) => make_primitive_scalar(v.as_ref(), scalar),
+        _ => Err(ArrowError::InvalidArgumentError(format!(
+            "Unsupported primitive scalar data type {d:?}",
+        ))),
+    }
+}
+
+fn make_binary_scalar(d: &DataType, scalar: &[u8]) -> Result<ArrayRef, ArrowError> {
+    match d {
+        DataType::Binary => Ok(Arc::new(BinaryArray::from_iter_values([scalar]))),
+        DataType::FixedSizeBinary(_) => Ok(Arc::new(FixedSizeBinaryArray::try_from_iter(
+            [scalar].into_iter(),
+        )?)),
+        DataType::LargeBinary => Ok(Arc::new(LargeBinaryArray::from_iter_values([scalar]))),
+        DataType::Dictionary(_, v) => make_binary_scalar(v.as_ref(), scalar),
+        _ => Err(ArrowError::InvalidArgumentError(format!(
+            "Unsupported binary scalar data type {d:?}",
+        ))),
+    }
+}
+
+fn make_utf8_scalar(d: &DataType, scalar: &str) -> Result<ArrayRef, ArrowError> {
+    match d {
+        DataType::Utf8 => Ok(Arc::new(StringArray::from_iter_values([scalar]))),
+        DataType::LargeUtf8 => Ok(Arc::new(LargeStringArray::from_iter_values([scalar]))),
+        DataType::Dictionary(_, v) => make_utf8_scalar(v.as_ref(), scalar),
+        _ => Err(ArrowError::InvalidArgumentError(format!(
+            "Unsupported utf8 scalar data type {d:?}",
+        ))),
+    }
+}
+
+/// Perform `left == right` operation on [`StringArray`] / [`LargeStringArray`].
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_utf8<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &GenericStringArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::eq(left, right)
+}
+
+/// Perform `left == right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_utf8_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &str,
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericStringArray::<OffsetSize>::from(vec![right]);
+    crate::cmp::eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left == right` operation on [`BooleanArray`]
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::eq(&left, &right)
+}
+
+/// Perform `left != right` operation on [`BooleanArray`]
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::neq(&left, &right)
+}
+
+/// Perform `left < right` operation on [`BooleanArray`]
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::lt(&left, &right)
+}
+
+/// Perform `left <= right` operation on [`BooleanArray`]
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::lt_eq(&left, &right)
+}
+
+/// Perform `left > right` operation on [`BooleanArray`]
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::gt(&left, &right)
+}
+
+/// Perform `left >= right` operation on [`BooleanArray`]
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::gt_eq(&left, &right)
+}
+
+/// Perform `left == right` operation on [`BooleanArray`] and a scalar
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left < right` operation on [`BooleanArray`] and a scalar
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::lt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left <= right` operation on [`BooleanArray`] and a scalar
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::lt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left > right` operation on [`BooleanArray`] and a scalar
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::gt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left >= right` operation on [`BooleanArray`] and a scalar
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::gt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left != right` operation on [`BooleanArray`] and a scalar
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::neq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left == right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_binary<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &GenericBinaryArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::eq(left, right)
+}
+
+/// Perform `left == right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_binary_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &[u8],
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericBinaryArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::eq(left, &Scalar::new(&right))
+}
+
+/// Perform `left != right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_binary<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &GenericBinaryArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::neq(left, right)
+}
+
+/// Perform `left != right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_binary_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &[u8],
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericBinaryArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::neq(left, &Scalar::new(&right))
+}
+
+/// Perform `left < right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_binary<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &GenericBinaryArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::lt(left, right)
+}
+
+/// Perform `left < right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_binary_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &[u8],
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericBinaryArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::lt(left, &Scalar::new(&right))
+}
+
+/// Perform `left <= right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_binary<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &GenericBinaryArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::lt_eq(left, right)
+}
+
+/// Perform `left <= right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_binary_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &[u8],
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericBinaryArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::lt_eq(left, &Scalar::new(&right))
+}
+
+/// Perform `left > right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_binary<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &GenericBinaryArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::gt(left, right)
+}
+
+/// Perform `left > right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_binary_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &[u8],
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericBinaryArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::gt(left, &Scalar::new(&right))
+}
+
+/// Perform `left >= right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_binary<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &GenericBinaryArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::gt_eq(left, right)
+}
+
+/// Perform `left >= right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_binary_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericBinaryArray<OffsetSize>,
+    right: &[u8],
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericBinaryArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::gt_eq(left, &Scalar::new(&right))
+}
+
+/// Perform `left != right` operation on [`StringArray`] / [`LargeStringArray`].
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_utf8<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &GenericStringArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::neq(left, right)
+}
+
+/// Perform `left != right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_utf8_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &str,
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericStringArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::neq(left, &Scalar::new(&right))
+}
+
+/// Perform `left < right` operation on [`StringArray`] / [`LargeStringArray`].
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_utf8<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &GenericStringArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::lt(left, right)
+}
+
+/// Perform `left < right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_utf8_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &str,
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericStringArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::lt(left, &Scalar::new(&right))
+}
+
+/// Perform `left <= right` operation on [`StringArray`] / [`LargeStringArray`].
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_utf8<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &GenericStringArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::lt_eq(left, right)
+}
+
+/// Perform `left <= right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_utf8_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &str,
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericStringArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::lt_eq(left, &Scalar::new(&right))
+}
+
+/// Perform `left > right` operation on [`StringArray`] / [`LargeStringArray`].
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_utf8<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &GenericStringArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::gt(left, right)
+}
+
+/// Perform `left > right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_utf8_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &str,
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericStringArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::gt(left, &Scalar::new(&right))
+}
+
+/// Perform `left >= right` operation on [`StringArray`] / [`LargeStringArray`].
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_utf8<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &GenericStringArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::gt_eq(left, right)
+}
+
+/// Perform `left >= right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_utf8_scalar<OffsetSize: OffsetSizeTrait>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &str,
+) -> Result<BooleanArray, ArrowError> {
+    let right = GenericStringArray::<OffsetSize>::from_iter_values([right]);
+    crate::cmp::gt_eq(left, &Scalar::new(&right))
+}
+
+/// Perform `left == right` operation on an array and a numeric scalar
+/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray, ArrowError>
+where
+    T: num::ToPrimitive + std::fmt::Debug,
+{
+    let right = make_primitive_scalar(left.data_type(), right)?;
+    crate::cmp::eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left < right` operation on an array and a numeric scalar
+/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray, ArrowError>
+where
+    T: num::ToPrimitive + std::fmt::Debug,
+{
+    let right = make_primitive_scalar(left.data_type(), right)?;
+    crate::cmp::lt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left <= right` operation on an array and a numeric scalar
+/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray, ArrowError>
+where
+    T: num::ToPrimitive + std::fmt::Debug,
+{
+    let right = make_primitive_scalar(left.data_type(), right)?;
+    crate::cmp::lt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left > right` operation on an array and a numeric scalar
+/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray, ArrowError>
+where
+    T: num::ToPrimitive + std::fmt::Debug,
+{
+    let right = make_primitive_scalar(left.data_type(), right)?;
+    crate::cmp::gt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left >= right` operation on an array and a numeric scalar
+/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray, ArrowError>
+where
+    T: num::ToPrimitive + std::fmt::Debug,
+{
+    let right = make_primitive_scalar(left.data_type(), right)?;
+    crate::cmp::gt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left != right` operation on an array and a numeric scalar
+/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray, ArrowError>
+where
+    T: num::ToPrimitive + std::fmt::Debug,
+{
+    let right = make_primitive_scalar(left.data_type(), right)?;
+    crate::cmp::neq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left == right` operation on an array and a numeric scalar
+/// value. Supports BinaryArray and LargeBinaryArray
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray, ArrowError> {
+    let right = make_binary_scalar(left.data_type(), right)?;
+    crate::cmp::eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left != right` operation on an array and a numeric scalar
+/// value. Supports BinaryArray and LargeBinaryArray
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray, ArrowError> {
+    let right = make_binary_scalar(left.data_type(), right)?;
+    crate::cmp::neq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left < right` operation on an array and a numeric scalar
+/// value. Supports BinaryArray and LargeBinaryArray
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray, ArrowError> {
+    let right = make_binary_scalar(left.data_type(), right)?;
+    crate::cmp::lt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left <= right` operation on an array and a numeric scalar
+/// value. Supports BinaryArray and LargeBinaryArray
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray, ArrowError> {
+    let right = make_binary_scalar(left.data_type(), right)?;
+    crate::cmp::lt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left > right` operation on an array and a numeric scalar
+/// value. Supports BinaryArray and LargeBinaryArray
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray, ArrowError> {
+    let right = make_binary_scalar(left.data_type(), right)?;
+    crate::cmp::gt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left >= right` operation on an array and a numeric scalar
+/// value. Supports BinaryArray and LargeBinaryArray
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray, ArrowError> {
+    let right = make_binary_scalar(left.data_type(), right)?;
+    crate::cmp::gt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left == right` operation on an array and a numeric scalar
+/// value. Supports StringArrays, and DictionaryArrays that have string values
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray, ArrowError> {
+    let right = make_utf8_scalar(left.data_type(), right)?;
+    crate::cmp::eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left < right` operation on an array and a numeric scalar
+/// value. Supports StringArrays, and DictionaryArrays that have string values
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray, ArrowError> {
+    let right = make_utf8_scalar(left.data_type(), right)?;
+    crate::cmp::lt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left >= right` operation on an array and a numeric scalar
+/// value. Supports StringArrays, and DictionaryArrays that have string values
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray, ArrowError> {
+    let right = make_utf8_scalar(left.data_type(), right)?;
+    crate::cmp::gt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left <= right` operation on an array and a numeric scalar
+/// value. Supports StringArrays, and DictionaryArrays that have string values
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray, ArrowError> {
+    let right = make_utf8_scalar(left.data_type(), right)?;
+    crate::cmp::lt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left > right` operation on an array and a numeric scalar
+/// value. Supports StringArrays, and DictionaryArrays that have string values
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray, ArrowError> {
+    let right = make_utf8_scalar(left.data_type(), right)?;
+    crate::cmp::gt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left != right` operation on an array and a numeric scalar
+/// value. Supports StringArrays, and DictionaryArrays that have string values
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray, ArrowError> {
+    let right = make_utf8_scalar(left.data_type(), right)?;
+    crate::cmp::neq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left == right` operation on an array and a numeric scalar
+/// value.
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left < right` operation on an array and a numeric scalar
+/// value. Supports BooleanArrays.
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::lt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left > right` operation on an array and a numeric scalar
+/// value. Supports BooleanArrays.
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::gt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left <= right` operation on an array and a numeric scalar
+/// value. Supports BooleanArrays.
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::lt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left >= right` operation on an array and a numeric scalar
+/// value. Supports BooleanArrays.
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::gt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left != right` operation on an array and a numeric scalar
+/// value. Supports BooleanArrays.
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray, ArrowError> {
+    let right = BooleanArray::from(vec![right]);
+    crate::cmp::neq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left == right` operation on two (dynamic) [`Array`]s.
+///
+/// Only when two arrays are of the same type the comparison will happen otherwise it will err
+/// with a casting error.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+///
+/// # Example
+/// ```
+/// use arrow_array::{StringArray, BooleanArray};
+/// use arrow_ord::comparison::eq_dyn;
+/// let array1 = StringArray::from(vec![Some("foo"), None, Some("bar")]);
+/// let array2 = StringArray::from(vec![Some("foo"), None, Some("baz")]);
+/// let result = eq_dyn(&array1, &array2).unwrap();
+/// assert_eq!(BooleanArray::from(vec![Some(true), None, Some(false)]), result);
+/// ```
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::eq(&left, &right)
+}
+
+/// Perform `left != right` operation on two (dynamic) [`Array`]s.
+///
+/// Only when two arrays are of the same type the comparison will happen otherwise it will err
+/// with a casting error.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+///
+/// # Example
+/// ```
+/// use arrow_array::{BinaryArray, BooleanArray};
+/// use arrow_ord::comparison::neq_dyn;
+/// let values1: Vec<Option<&[u8]>> = vec![Some(&[0xfc, 0xa9]), None, Some(&[0x36])];
+/// let values2: Vec<Option<&[u8]>> = vec![Some(&[0xfc, 0xa9]), None, Some(&[0x36, 0x00])];
+/// let array1 = BinaryArray::from(values1);
+/// let array2 = BinaryArray::from(values2);
+/// let result = neq_dyn(&array1, &array2).unwrap();
+/// assert_eq!(BooleanArray::from(vec![Some(false), None, Some(true)]), result);
+/// ```
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::neq(&left, &right)
+}
+
+/// Perform `left < right` operation on two (dynamic) [`Array`]s.
+///
+/// Only when two arrays are of the same type the comparison will happen otherwise it will err
+/// with a casting error.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+///
+/// # Example
+/// ```
+/// use arrow_array::{PrimitiveArray, BooleanArray};
+/// use arrow_array::types::Int32Type;
+/// use arrow_ord::comparison::lt_dyn;
+/// let array1: PrimitiveArray<Int32Type> = PrimitiveArray::from(vec![Some(0), Some(1), Some(2)]);
+/// let array2: PrimitiveArray<Int32Type> = PrimitiveArray::from(vec![Some(1), Some(1), None]);
+/// let result = lt_dyn(&array1, &array2).unwrap();
+/// assert_eq!(BooleanArray::from(vec![Some(true), Some(false), None]), result);
+/// ```
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::lt(&left, &right)
+}
+
+/// Perform `left <= right` operation on two (dynamic) [`Array`]s.
+///
+/// Only when two arrays are of the same type the comparison will happen otherwise it will err
+/// with a casting error.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+///
+/// # Example
+/// ```
+/// use arrow_array::{PrimitiveArray, BooleanArray};
+/// use arrow_array::types::Date32Type;
+/// use arrow_ord::comparison::lt_eq_dyn;
+/// let array1: PrimitiveArray<Date32Type> = vec![Some(12356), Some(13548), Some(-365), Some(365)].into();
+/// let array2: PrimitiveArray<Date32Type> = vec![Some(12355), Some(13548), Some(-364), None].into();
+/// let result = lt_eq_dyn(&array1, &array2).unwrap();
+/// assert_eq!(BooleanArray::from(vec![Some(false), Some(true), Some(true), None]), result);
+/// ```
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::lt_eq(&left, &right)
+}
+
+/// Perform `left > right` operation on two (dynamic) [`Array`]s.
+///
+/// Only when two arrays are of the same type the comparison will happen otherwise it will err
+/// with a casting error.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+///
+/// # Example
+/// ```
+/// use arrow_array::BooleanArray;
+/// use arrow_ord::comparison::gt_dyn;
+/// let array1 = BooleanArray::from(vec![Some(true), Some(false), None]);
+/// let array2 = BooleanArray::from(vec![Some(false), Some(true), None]);
+/// let result = gt_dyn(&array1, &array2).unwrap();
+/// assert_eq!(BooleanArray::from(vec![Some(true), Some(false), None]), result);
+/// ```
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::gt(&left, &right)
+}
+
+/// Perform `left >= right` operation on two (dynamic) [`Array`]s.
+///
+/// Only when two arrays are of the same type the comparison will happen otherwise it will err
+/// with a casting error.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+///
+/// # Example
+/// ```
+/// use arrow_array::{BooleanArray, StringArray};
+/// use arrow_ord::comparison::gt_eq_dyn;
+/// let array1 = StringArray::from(vec![Some(""), Some("aaa"), None]);
+/// let array2 = StringArray::from(vec![Some(" "), Some("aa"), None]);
+/// let result = gt_eq_dyn(&array1, &array2).unwrap();
+/// assert_eq!(BooleanArray::from(vec![Some(false), Some(true), None]), result);
+/// ```
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray, ArrowError> {
+    crate::cmp::gt_eq(&left, &right)
+}
+
+/// Perform `left == right` operation on two [`PrimitiveArray`]s.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    crate::cmp::eq(&left, &right)
+}
+
+/// Perform `left == right` operation on a [`PrimitiveArray`] and a scalar value.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::eq")]
+pub fn eq_scalar<T>(left: &PrimitiveArray<T>, right: T::Native) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    let right = PrimitiveArray::<T>::new(vec![right].into(), None);
+    crate::cmp::eq(&left, &Scalar::new(&right))
+}
+
+/// Applies an unary and infallible comparison function to a primitive array.
+#[deprecated(note = "Use BooleanArray::from_unary")]
+pub fn unary_cmp<T, F>(left: &PrimitiveArray<T>, op: F) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    F: Fn(T::Native) -> bool,
+{
+    Ok(BooleanArray::from_unary(left, op))
+}
+
+/// Perform `left != right` operation on two [`PrimitiveArray`]s.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    crate::cmp::neq(&left, &right)
+}
+
+/// Perform `left != right` operation on a [`PrimitiveArray`] and a scalar value.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::neq")]
+pub fn neq_scalar<T>(left: &PrimitiveArray<T>, right: T::Native) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    let right = PrimitiveArray::<T>::new(vec![right].into(), None);
+    crate::cmp::neq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left < right` operation on two [`PrimitiveArray`]s. Null values are less than non-null
+/// values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    crate::cmp::lt(&left, &right)
+}
+
+/// Perform `left < right` operation on a [`PrimitiveArray`] and a scalar value.
+/// Null values are less than non-null values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::lt")]
+pub fn lt_scalar<T>(left: &PrimitiveArray<T>, right: T::Native) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    let right = PrimitiveArray::<T>::new(vec![right].into(), None);
+    crate::cmp::lt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left <= right` operation on two [`PrimitiveArray`]s. Null values are less than non-null
+/// values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    crate::cmp::lt_eq(&left, &right)
+}
+
+/// Perform `left <= right` operation on a [`PrimitiveArray`] and a scalar value.
+/// Null values are less than non-null values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::lt_eq")]
+pub fn lt_eq_scalar<T>(
+    left: &PrimitiveArray<T>,
+    right: T::Native,
+) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    let right = PrimitiveArray::<T>::new(vec![right].into(), None);
+    crate::cmp::lt_eq(&left, &Scalar::new(&right))
+}
+
+/// Perform `left > right` operation on two [`PrimitiveArray`]s. Non-null values are greater than null
+/// values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    crate::cmp::gt(&left, &right)
+}
+
+/// Perform `left > right` operation on a [`PrimitiveArray`] and a scalar value.
+/// Non-null values are greater than null values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::gt")]
+pub fn gt_scalar<T>(left: &PrimitiveArray<T>, right: T::Native) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    let right = PrimitiveArray::<T>::new(vec![right].into(), None);
+    crate::cmp::gt(&left, &Scalar::new(&right))
+}
+
+/// Perform `left >= right` operation on two [`PrimitiveArray`]s. Non-null values are greater than null
+/// values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq<T>(
+    left: &PrimitiveArray<T>,
+    right: &PrimitiveArray<T>,
+) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    crate::cmp::gt_eq(&left, &right)
+}
+
+/// Perform `left >= right` operation on a [`PrimitiveArray`] and a scalar value.
+/// Non-null values are greater than null values.
+///
+/// For floating values like f32 and f64, this comparison produces an ordering in accordance to
+/// the totalOrder predicate as defined in the IEEE 754 (2008 revision) floating point standard.
+/// Note that totalOrder treats positive and negative zeros are different. If it is necessary
+/// to treat them as equal, please normalize zeros before calling this kernel.
+/// Please refer to `f32::total_cmp` and `f64::total_cmp`.
+#[deprecated(note = "Use arrow_ord::cmp::gt_eq")]
+pub fn gt_eq_scalar<T>(
+    left: &PrimitiveArray<T>,
+    right: T::Native,
+) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    T::Native: ArrowNativeTypeOp,
+{
+    let right = PrimitiveArray::<T>::new(vec![right].into(), None);
+    crate::cmp::gt_eq(&left, &Scalar::new(&right))
+}
+
+/// Checks if a [`GenericListArray`] contains a value in the [`PrimitiveArray`]
+pub fn in_list<T, OffsetSize>(
+    left: &PrimitiveArray<T>,
+    right: &GenericListArray<OffsetSize>,
+) -> Result<BooleanArray, ArrowError>
+where
+    T: ArrowNumericType,
+    OffsetSize: OffsetSizeTrait,
+{
+    let left_len = left.len();
+    if left_len != right.len() {
+        return Err(ArrowError::ComputeError(
+            "Cannot perform comparison operation on arrays of different length".to_string(),
+        ));
+    }
+
+    let num_bytes = bit_util::ceil(left_len, 8);
+
+    let nulls = NullBuffer::union(left.nulls(), right.nulls());
+    let mut bool_buf = MutableBuffer::from_len_zeroed(num_bytes);
+    let bool_slice = bool_buf.as_slice_mut();
+
+    // if both array slots are valid, check if list contains primitive
+    for i in 0..left_len {
+        if nulls.as_ref().map(|n| n.is_valid(i)).unwrap_or(true) {
+            let list = right.value(i);
+            let list = list.as_any().downcast_ref::<PrimitiveArray<T>>().unwrap();
+
+            for j in 0..list.len() {
+                if list.is_valid(j) && (left.value(i) == list.value(j)) {
+                    bit_util::set_bit(bool_slice, i);
+                    continue;
+                }
+            }
+        }
+    }
+
+    let values = BooleanBuffer::new(bool_buf.into(), 0, left_len);
+    Ok(BooleanArray::new(values, None))
+}
+
+/// Checks if a [`GenericListArray`] contains a value in the [`GenericStringArray`]
+pub fn in_list_utf8<OffsetSize>(
+    left: &GenericStringArray<OffsetSize>,
+    right: &ListArray,
+) -> Result<BooleanArray, ArrowError>
+where
+    OffsetSize: OffsetSizeTrait,
+{
+    let left_len = left.len();
+    if left_len != right.len() {
+        return Err(ArrowError::ComputeError(
+            "Cannot perform comparison operation on arrays of different length".to_string(),
+        ));
+    }
+
+    let num_bytes = bit_util::ceil(left_len, 8);
+
+    let nulls = NullBuffer::union(left.nulls(), right.nulls());
+    let mut bool_buf = MutableBuffer::from_len_zeroed(num_bytes);
+    let bool_slice = &mut bool_buf;
+
+    for i in 0..left_len {
+        // contains(null, null) = false
+        if nulls.as_ref().map(|n| n.is_valid(i)).unwrap_or(true) {
+            let list = right.value(i);
+            let list = list.as_string::<OffsetSize>();
+
+            for j in 0..list.len() {
+                if list.is_valid(j) && (left.value(i) == list.value(j)) {
+                    bit_util::set_bit(bool_slice, i);
+                    continue;
+                }
+            }
+        }
+    }
+    let values = BooleanBuffer::new(bool_buf.into(), 0, left_len);
+    Ok(BooleanArray::new(values, None))
+}
+
+// disable wrapping inside literal vectors used for test data and assertions
+#[rustfmt::skip::macros(vec)]
+#[cfg(test)]
+#[allow(deprecated)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow_array::builder::{
+        ListBuilder, PrimitiveDictionaryBuilder, StringBuilder, StringDictionaryBuilder,
+    };
+    use arrow_buffer::{i256, Buffer};
+    use arrow_data::ArrayData;
+    use arrow_schema::Field;
+
+    use super::*;
+
+    /// Evaluate `KERNEL` with two vectors as inputs and assert against the expected output.
+    /// `A_VEC` and `B_VEC` can be of type `Vec<T>` or `Vec<Option<T>>` where `T` is the native
+    /// type of the data type of the Arrow array element.
+    /// `EXPECTED` can be either `Vec<bool>` or `Vec<Option<bool>>`.
+    /// The main reason for this macro is that inputs and outputs align nicely after `cargo fmt`.
+    macro_rules! cmp_vec {
+        ($KERNEL:ident, $DYN_KERNEL:ident, $ARRAY:ident, $A_VEC:expr, $B_VEC:expr, $EXPECTED:expr) => {
+            let a = $ARRAY::from($A_VEC);
+            let b = $ARRAY::from($B_VEC);
+            let c = $KERNEL(&a, &b).unwrap();
+            assert_eq!(BooleanArray::from($EXPECTED), c);
+
+            // slice and test if the dynamic array works
+            let a = a.slice(0, a.len());
+            let b = b.slice(0, b.len());
+            let c = $DYN_KERNEL(&a, &b).unwrap();
+            assert_eq!(BooleanArray::from($EXPECTED), c);
+
+            // test with a larger version of the same data to ensure we cover the chunked part of the comparison
+            let mut a = vec![];
+            let mut b = vec![];
+            let mut e = vec![];
+            for _i in 0..10 {
+                a.extend($A_VEC);
+                b.extend($B_VEC);
+                e.extend($EXPECTED);
+            }
+            let a = $ARRAY::from(a);
+            let b = $ARRAY::from(b);
+            let c = $KERNEL(&a, &b).unwrap();
+            assert_eq!(BooleanArray::from(e), c);
+        };
+    }
+
+    /// Evaluate `KERNEL` with two vectors as inputs and assert against the expected output.
+    /// `A_VEC` and `B_VEC` can be of type `Vec<i64>` or `Vec<Option<i64>>`.
+    /// `EXPECTED` can be either `Vec<bool>` or `Vec<Option<bool>>`.
+    /// The main reason for this macro is that inputs and outputs align nicely after `cargo fmt`.
+    macro_rules! cmp_i64 {
+        ($KERNEL:ident, $DYN_KERNEL:ident, $A_VEC:expr, $B_VEC:expr, $EXPECTED:expr) => {
+            cmp_vec!($KERNEL, $DYN_KERNEL, Int64Array, $A_VEC, $B_VEC, $EXPECTED);
+        };
+    }
+
+    /// Evaluate `KERNEL` with one vectors and one scalar as inputs and assert against the expected output.
+    /// `A_VEC` can be of type `Vec<i64>` or `Vec<Option<i64>>`.
+    /// `EXPECTED` can be either `Vec<bool>` or `Vec<Option<bool>>`.
+    /// The main reason for this macro is that inputs and outputs align nicely after `cargo fmt`.
+    macro_rules! cmp_i64_scalar {
+        ($KERNEL:ident, $A_VEC:expr, $B:literal, $EXPECTED:expr) => {
+            let a = Int64Array::from($A_VEC);
+            let c = $KERNEL(&a, $B).unwrap();
+            assert_eq!(BooleanArray::from($EXPECTED), c);
+
+            // test with a larger version of the same data to ensure we cover the chunked part of the comparison
+            let mut a = vec![];
+            let mut e = vec![];
+            for _i in 0..10 {
+                a.extend($A_VEC);
+                e.extend($EXPECTED);
+            }
+            let a = Int64Array::from(a);
+            let c = $KERNEL(&a, $B).unwrap();
+            assert_eq!(BooleanArray::from(e), c);
+
+        };
+    }
+
+    #[test]
+    fn test_primitive_array_eq() {
+        cmp_i64!(
+            eq,
+            eq_dyn,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![false, false, true, false, false, false, false, true, false, false]
+        );
+
+        cmp_vec!(
+            eq,
+            eq_dyn,
+            TimestampSecondArray,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![false, false, true, false, false, false, false, true, false, false]
+        );
+
+        cmp_vec!(
+            eq,
+            eq_dyn,
+            Time32SecondArray,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![false, false, true, false, false, false, false, true, false, false]
+        );
+
+        cmp_vec!(
+            eq,
+            eq_dyn,
+            Time32MillisecondArray,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![false, false, true, false, false, false, false, true, false, false]
+        );
+
+        cmp_vec!(
+            eq,
+            eq_dyn,
+            Time64MicrosecondArray,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![false, false, true, false, false, false, false, true, false, false]
+        );
+
+        cmp_vec!(
+            eq,
+            eq_dyn,
+            Time64NanosecondArray,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![false, false, true, false, false, false, false, true, false, false]
+        );
+
+        cmp_vec!(
+            eq,
+            eq_dyn,
+            IntervalYearMonthArray,
+            vec![
+                IntervalYearMonthType::make_value(1, 2),
+                IntervalYearMonthType::make_value(2, 1),
+                // 1 year
+                IntervalYearMonthType::make_value(1, 0),
+            ],
+            vec![
+                IntervalYearMonthType::make_value(1, 2),
+                IntervalYearMonthType::make_value(1, 2),
+                // NB 12 months is treated as equal to a year (as the underlying
+                // type stores number of months)
+                IntervalYearMonthType::make_value(0, 12),
+            ],
+            vec![true, false, true]
+        );
+
+        cmp_vec!(
+            eq,
+            eq_dyn,
+            IntervalMonthDayNanoArray,
+            vec![
+                IntervalMonthDayNanoType::make_value(1, 2, 3),
+                IntervalMonthDayNanoType::make_value(3, 2, 1),
+                // 1 month
+                IntervalMonthDayNanoType::make_value(1, 0, 0),
+                IntervalMonthDayNanoType::make_value(1, 0, 0),
+            ],
+            vec![
+                IntervalMonthDayNanoType::make_value(1, 2, 3),
+                IntervalMonthDayNanoType::make_value(1, 2, 3),
+                // 30 days is not treated as a month
+                IntervalMonthDayNanoType::make_value(0, 30, 0),
+                // 100 days
+                IntervalMonthDayNanoType::make_value(0, 100, 0),
+            ],
+            vec![true, false, false, false]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_eq_scalar() {
+        cmp_i64_scalar!(
+            eq_scalar,
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            8,
+            vec![false, false, true, false, false, false, false, true, false, false]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_eq_with_slice() {
+        let a = Int32Array::from(vec![6, 7, 8, 8, 10]);
+        let b = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
+        let b_slice = b.slice(5, 5);
+        let c = b_slice.as_any().downcast_ref().unwrap();
+        let d = eq(c, &a).unwrap();
+        assert!(d.value(0));
+        assert!(d.value(1));
+        assert!(d.value(2));
+        assert!(!d.value(3));
+        assert!(d.value(4));
+    }
+
+    #[test]
+    fn test_primitive_array_eq_scalar_with_slice() {
+        let a = Int32Array::from(vec![Some(1), None, Some(2), Some(3)]);
+        let a = a.slice(1, 3);
+        let a_eq = eq_scalar(&a, 2).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![None, Some(true), Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_neq() {
+        cmp_i64!(
+            neq,
+            neq_dyn,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![true, true, false, true, true, true, true, false, true, true]
+        );
+
+        cmp_vec!(
+            neq,
+            neq_dyn,
+            TimestampMillisecondArray,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![true, true, false, true, true, true, true, false, true, true]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_neq_scalar() {
+        cmp_i64_scalar!(
+            neq_scalar,
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            8,
+            vec![true, true, false, true, true, true, true, false, true, true]
+        );
+    }
+
+    #[test]
+    fn test_boolean_array_eq() {
+        let a: BooleanArray =
+            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
+        let b: BooleanArray =
+            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
+
+        let res: Vec<Option<bool>> = eq_bool(&a, &b).unwrap().iter().collect();
+
+        assert_eq!(
+            res,
+            vec![Some(true), Some(false), Some(true), Some(false), None, None]
+        )
+    }
+
+    #[test]
+    fn test_boolean_array_neq() {
+        let a: BooleanArray =
+            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
+        let b: BooleanArray =
+            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
+
+        let res: Vec<Option<bool>> = neq_bool(&a, &b).unwrap().iter().collect();
+
+        assert_eq!(
+            res,
+            vec![Some(false), Some(true), Some(false), Some(true), None, None]
+        )
+    }
+
+    #[test]
+    fn test_boolean_array_lt() {
+        let a: BooleanArray =
+            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
+        let b: BooleanArray =
+            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
+
+        let res: Vec<Option<bool>> = lt_bool(&a, &b).unwrap().iter().collect();
+
+        assert_eq!(
+            res,
+            vec![Some(false), Some(true), Some(false), Some(false), None, None]
+        )
+    }
+
+    #[test]
+    fn test_boolean_array_lt_eq() {
+        let a: BooleanArray =
+            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
+        let b: BooleanArray =
+            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
+
+        let res: Vec<Option<bool>> = lt_eq_bool(&a, &b).unwrap().iter().collect();
+
+        assert_eq!(
+            res,
+            vec![Some(true), Some(true), Some(true), Some(false), None, None]
+        )
+    }
+
+    #[test]
+    fn test_boolean_array_gt() {
+        let a: BooleanArray =
+            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
+        let b: BooleanArray =
+            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
+
+        let res: Vec<Option<bool>> = gt_bool(&a, &b).unwrap().iter().collect();
+
+        assert_eq!(
+            res,
+            vec![Some(false), Some(false), Some(false), Some(true), None, None]
+        )
+    }
+
+    #[test]
+    fn test_boolean_array_gt_eq() {
+        let a: BooleanArray =
+            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None].into();
+        let b: BooleanArray =
+            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)].into();
+
+        let res: Vec<Option<bool>> = gt_eq_bool(&a, &b).unwrap().iter().collect();
+
+        assert_eq!(
+            res,
+            vec![Some(true), Some(false), Some(true), Some(true), None, None]
+        )
+    }
+
+    #[test]
+    fn test_boolean_array_eq_scalar() {
+        let a: BooleanArray = vec![Some(true), Some(false), None].into();
+
+        let res1: Vec<Option<bool>> = eq_bool_scalar(&a, false).unwrap().iter().collect();
+
+        assert_eq!(res1, vec![Some(false), Some(true), None]);
+
+        let res2: Vec<Option<bool>> = eq_bool_scalar(&a, true).unwrap().iter().collect();
+
+        assert_eq!(res2, vec![Some(true), Some(false), None]);
+    }
+
+    #[test]
+    fn test_boolean_array_neq_scalar() {
+        let a: BooleanArray = vec![Some(true), Some(false), None].into();
+
+        let res1: Vec<Option<bool>> = neq_bool_scalar(&a, false).unwrap().iter().collect();
+
+        assert_eq!(res1, vec![Some(true), Some(false), None]);
+
+        let res2: Vec<Option<bool>> = neq_bool_scalar(&a, true).unwrap().iter().collect();
+
+        assert_eq!(res2, vec![Some(false), Some(true), None]);
+    }
+
+    #[test]
+    fn test_boolean_array_lt_scalar() {
+        let a: BooleanArray = vec![Some(true), Some(false), None].into();
+
+        let res1: Vec<Option<bool>> = lt_bool_scalar(&a, false).unwrap().iter().collect();
+
+        assert_eq!(res1, vec![Some(false), Some(false), None]);
+
+        let res2: Vec<Option<bool>> = lt_bool_scalar(&a, true).unwrap().iter().collect();
+
+        assert_eq!(res2, vec![Some(false), Some(true), None]);
+    }
+
+    #[test]
+    fn test_boolean_array_lt_eq_scalar() {
+        let a: BooleanArray = vec![Some(true), Some(false), None].into();
+
+        let res1: Vec<Option<bool>> = lt_eq_bool_scalar(&a, false).unwrap().iter().collect();
+
+        assert_eq!(res1, vec![Some(false), Some(true), None]);
+
+        let res2: Vec<Option<bool>> = lt_eq_bool_scalar(&a, true).unwrap().iter().collect();
+
+        assert_eq!(res2, vec![Some(true), Some(true), None]);
+    }
+
+    #[test]
+    fn test_boolean_array_gt_scalar() {
+        let a: BooleanArray = vec![Some(true), Some(false), None].into();
+
+        let res1: Vec<Option<bool>> = gt_bool_scalar(&a, false).unwrap().iter().collect();
+
+        assert_eq!(res1, vec![Some(true), Some(false), None]);
+
+        let res2: Vec<Option<bool>> = gt_bool_scalar(&a, true).unwrap().iter().collect();
+
+        assert_eq!(res2, vec![Some(false), Some(false), None]);
+    }
+
+    #[test]
+    fn test_boolean_array_gt_eq_scalar() {
+        let a: BooleanArray = vec![Some(true), Some(false), None].into();
+
+        let res1: Vec<Option<bool>> = gt_eq_bool_scalar(&a, false).unwrap().iter().collect();
+
+        assert_eq!(res1, vec![Some(true), Some(true), None]);
+
+        let res2: Vec<Option<bool>> = gt_eq_bool_scalar(&a, true).unwrap().iter().collect();
+
+        assert_eq!(res2, vec![Some(true), Some(false), None]);
+    }
+
+    #[test]
+    fn test_primitive_array_lt() {
+        cmp_i64!(
+            lt,
+            lt_dyn,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![false, false, false, true, true, false, false, false, true, true]
+        );
+
+        cmp_vec!(
+            lt,
+            lt_dyn,
+            TimestampMillisecondArray,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![false, false, false, true, true, false, false, false, true, true]
+        );
+
+        cmp_vec!(
+            lt,
+            lt_dyn,
+            IntervalDayTimeArray,
+            vec![
+                IntervalDayTimeType::make_value(1, 0),
+                IntervalDayTimeType::make_value(0, 1000),
+                IntervalDayTimeType::make_value(1, 1000),
+                IntervalDayTimeType::make_value(1, 3000),
+                // 90M milliseconds
+                IntervalDayTimeType::make_value(0, 90_000_000),
+            ],
+            vec![
+                IntervalDayTimeType::make_value(0, 1000),
+                IntervalDayTimeType::make_value(1, 0),
+                IntervalDayTimeType::make_value(10, 0),
+                IntervalDayTimeType::make_value(2, 1),
+                // NB even though 1 day is less than 90M milliseconds long,
+                // it compares as greater because the underlying type stores
+                // days and milliseconds as different fields
+                IntervalDayTimeType::make_value(0, 12),
+            ],
+            vec![false, true, true, true ,false]
+        );
+
+        cmp_vec!(
+            lt,
+            lt_dyn,
+            IntervalYearMonthArray,
+            vec![
+                IntervalYearMonthType::make_value(1, 2),
+                IntervalYearMonthType::make_value(2, 1),
+                IntervalYearMonthType::make_value(1, 2),
+                // 1 year
+                IntervalYearMonthType::make_value(1, 0),
+            ],
+            vec![
+                IntervalYearMonthType::make_value(1, 2),
+                IntervalYearMonthType::make_value(1, 2),
+                IntervalYearMonthType::make_value(2, 1),
+                // NB 12 months is treated as equal to a year (as the underlying
+                // type stores number of months)
+                IntervalYearMonthType::make_value(0, 12),
+            ],
+            vec![false, false, true, false]
+        );
+
+        cmp_vec!(
+            lt,
+            lt_dyn,
+            IntervalMonthDayNanoArray,
+            vec![
+                IntervalMonthDayNanoType::make_value(1, 2, 3),
+                IntervalMonthDayNanoType::make_value(3, 2, 1),
+                // 1 month
+                IntervalMonthDayNanoType::make_value(1, 0, 0),
+                IntervalMonthDayNanoType::make_value(1, 2, 0),
+                IntervalMonthDayNanoType::make_value(1, 0, 0),
+            ],
+            vec![
+                IntervalMonthDayNanoType::make_value(1, 2, 3),
+                IntervalMonthDayNanoType::make_value(1, 2, 3),
+                IntervalMonthDayNanoType::make_value(2, 0, 0),
+                // 30 days is not treated as a month
+                IntervalMonthDayNanoType::make_value(0, 30, 0),
+                // 100 days (note is treated as greater than 1 month as the underlying integer representation)
+                IntervalMonthDayNanoType::make_value(0, 100, 0),
+            ],
+            vec![false, false, true, false, false]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_lt_scalar() {
+        cmp_i64_scalar!(
+            lt_scalar,
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            8,
+            vec![true, true, false, false, false, true, true, false, false, false]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_lt_nulls() {
+        cmp_i64!(
+            lt,
+            lt_dyn,
+            vec![None, None, Some(1), Some(1), None, None, Some(2), Some(2),],
+            vec![None, Some(1), None, Some(1), None, Some(3), None, Some(3),],
+            vec![None, None, None, Some(false), None, None, None, Some(true)]
+        );
+
+        cmp_vec!(
+            lt,
+            lt_dyn,
+            TimestampMillisecondArray,
+            vec![None, None, Some(1), Some(1), None, None, Some(2), Some(2),],
+            vec![None, Some(1), None, Some(1), None, Some(3), None, Some(3),],
+            vec![None, None, None, Some(false), None, None, None, Some(true)]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_lt_scalar_nulls() {
+        cmp_i64_scalar!(
+            lt_scalar,
+            vec![None, Some(1), Some(2), Some(3), None, Some(1), Some(2), Some(3), Some(2), None],
+            2,
+            vec![None, Some(true), Some(false), Some(false), None, Some(true), Some(false), Some(false), Some(false), None]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_lt_eq() {
+        cmp_i64!(
+            lt_eq,
+            lt_eq_dyn,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![false, false, true, true, true, false, false, true, true, true]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_lt_eq_scalar() {
+        cmp_i64_scalar!(
+            lt_eq_scalar,
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            8,
+            vec![true, true, true, false, false, true, true, true, false, false]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_lt_eq_nulls() {
+        cmp_i64!(
+            lt_eq,
+            lt_eq_dyn,
+            vec![None, None, Some(1), None, None, Some(1), None, None, Some(1)],
+            vec![None, Some(1), Some(0), None, Some(1), Some(2), None, None, Some(3)],
+            vec![None, None, Some(false), None, None, Some(true), None, None, Some(true)]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_lt_eq_scalar_nulls() {
+        cmp_i64_scalar!(
+            lt_eq_scalar,
+            vec![None, Some(1), Some(2), None, Some(1), Some(2), None, Some(1), Some(2)],
+            1,
+            vec![None, Some(true), Some(false), None, Some(true), Some(false), None, Some(true), Some(false)]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_gt() {
+        cmp_i64!(
+            gt,
+            gt_dyn,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![true, true, false, false, false, true, true, false, false, false]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_gt_scalar() {
+        cmp_i64_scalar!(
+            gt_scalar,
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            8,
+            vec![false, false, false, true, true, false, false, false, true, true]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_gt_nulls() {
+        cmp_i64!(
+            gt,
+            gt_dyn,
+            vec![None, None, Some(1), None, None, Some(2), None, None, Some(3)],
+            vec![None, Some(1), Some(1), None, Some(1), Some(1), None, Some(1), Some(1)],
+            vec![None, None, Some(false), None, None, Some(true), None, None, Some(true)]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_gt_scalar_nulls() {
+        cmp_i64_scalar!(
+            gt_scalar,
+            vec![None, Some(1), Some(2), None, Some(1), Some(2), None, Some(1), Some(2)],
+            1,
+            vec![None, Some(false), Some(true), None, Some(false), Some(true), None, Some(false), Some(true)]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_gt_eq() {
+        cmp_i64!(
+            gt_eq,
+            gt_eq_dyn,
+            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            vec![true, true, true, false, false, true, true, true, false, false]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_gt_eq_scalar() {
+        cmp_i64_scalar!(
+            gt_eq_scalar,
+            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
+            8,
+            vec![false, false, true, true, true, false, false, true, true, true]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_gt_eq_nulls() {
+        cmp_i64!(
+            gt_eq,
+            gt_eq_dyn,
+            vec![None, None, Some(1), None, Some(1), Some(2), None, None, Some(1)],
+            vec![None, Some(1), None, None, Some(1), Some(1), None, Some(2), Some(2)],
+            vec![None, None, None, None, Some(true), Some(true), None, None, Some(false)]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_gt_eq_scalar_nulls() {
+        cmp_i64_scalar!(
+            gt_eq_scalar,
+            vec![None, Some(1), Some(2), None, Some(2), Some(3), None, Some(3), Some(4)],
+            2,
+            vec![None, Some(false), Some(true), None, Some(true), Some(true), None, Some(true), Some(true)]
+        );
+    }
+
+    #[test]
+    fn test_primitive_array_compare_slice() {
+        let a: Int32Array = (0..100).map(Some).collect();
+        let a = a.slice(50, 50);
+        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
+        let b: Int32Array = (100..200).map(Some).collect();
+        let b = b.slice(50, 50);
+        let b = b.as_any().downcast_ref::<Int32Array>().unwrap();
+        let actual = lt(a, b).unwrap();
+        let expected: BooleanArray = (0..50).map(|_| Some(true)).collect();
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    fn test_primitive_array_compare_scalar_slice() {
+        let a: Int32Array = (0..100).map(Some).collect();
+        let a = a.slice(50, 50);
+        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
+        let actual = lt_scalar(a, 200).unwrap();
+        let expected: BooleanArray = (0..50).map(|_| Some(true)).collect();
+        assert_eq!(expected, actual);
+    }
+
+    #[test]
+    fn test_length_of_result_buffer() {
+        // `item_count` is chosen to not be a multiple of the number of SIMD lanes for this
+        // type (`Int8Type`), 64.
+        let item_count = 130;
+
+        let select_mask: BooleanArray = vec![true; item_count].into();
+
+        let array_a: PrimitiveArray<Int8Type> = vec![1; item_count].into();
+        let array_b: PrimitiveArray<Int8Type> = vec![2; item_count].into();
+        let result_mask = gt_eq(&array_a, &array_b).unwrap();
+
+        assert_eq!(result_mask.values().len(), select_mask.values().len());
+    }
+
+    // Expected behaviour:
+    // contains(1, [1, 2, null]) = true
+    // contains(3, [1, 2, null]) = false
+    // contains(null, [1, 2, null]) = false
+    // contains(null, null) = false
+    #[test]
+    fn test_contains() {
+        let value_data = Int32Array::from(vec![
+            Some(0),
+            Some(1),
+            Some(2),
+            Some(3),
+            Some(4),
+            Some(5),
+            Some(6),
+            None,
+            Some(7),
+        ])
+        .into_data();
+        let value_offsets = Buffer::from_slice_ref([0i64, 3, 6, 6, 9]);
+        let list_data_type =
+            DataType::LargeList(Arc::new(Field::new("item", DataType::Int32, true)));
+        let list_data = ArrayData::builder(list_data_type)
+            .len(4)
+            .add_buffer(value_offsets)
+            .add_child_data(value_data)
+            .null_bit_buffer(Some(Buffer::from([0b00001011])))
+            .build()
+            .unwrap();
+
+        //  [[0, 1, 2], [3, 4, 5], null, [6, null, 7]]
+        let list_array = LargeListArray::from(list_data);
+
+        let nulls = Int32Array::from(vec![None, None, None, None]);
+        let nulls_result = in_list(&nulls, &list_array).unwrap();
+        assert_eq!(
+            nulls_result
+                .as_any()
+                .downcast_ref::<BooleanArray>()
+                .unwrap(),
+            &BooleanArray::from(vec![false, false, false, false]),
+        );
+
+        let values = Int32Array::from(vec![Some(0), Some(0), Some(0), Some(0)]);
+        let values_result = in_list(&values, &list_array).unwrap();
+        assert_eq!(
+            values_result
+                .as_any()
+                .downcast_ref::<BooleanArray>()
+                .unwrap(),
+            &BooleanArray::from(vec![true, false, false, false]),
+        );
+    }
+
+    #[test]
+    fn test_interval_array() {
+        let a = IntervalDayTimeArray::from(vec![Some(0), Some(6), Some(834), None, Some(3), None]);
+        let b =
+            IntervalDayTimeArray::from(vec![Some(70), Some(6), Some(833), Some(6), Some(3), None]);
+        let res = eq(&a, &b).unwrap();
+        let res_dyn = eq_dyn(&a, &b).unwrap();
+        assert_eq!(res, res_dyn);
+        assert_eq!(
+            &res_dyn,
+            &BooleanArray::from(vec![Some(false), Some(true), Some(false), None, Some(true), None])
+        );
+
+        let a =
+            IntervalMonthDayNanoArray::from(vec![Some(0), Some(6), Some(834), None, Some(3), None]);
+        let b = IntervalMonthDayNanoArray::from(
+            vec![Some(86), Some(5), Some(8), Some(6), Some(3), None],
+        );
+        let res = lt(&a, &b).unwrap();
+        let res_dyn = lt_dyn(&a, &b).unwrap();
+        assert_eq!(res, res_dyn);
+        assert_eq!(
+            &res_dyn,
+            &BooleanArray::from(
+                vec![Some(true), Some(false), Some(false), None, Some(false), None]
+            )
+        );
+
+        let a =
+            IntervalYearMonthArray::from(vec![Some(0), Some(623), Some(834), None, Some(3), None]);
+        let b = IntervalYearMonthArray::from(
+            vec![Some(86), Some(5), Some(834), Some(6), Some(86), None],
+        );
+        let res = gt_eq(&a, &b).unwrap();
+        let res_dyn = gt_eq_dyn(&a, &b).unwrap();
+        assert_eq!(res, res_dyn);
+        assert_eq!(
+            &res_dyn,
+            &BooleanArray::from(vec![Some(false), Some(true), Some(true), None, Some(false), None])
+        );
+    }
+
+    macro_rules! test_binary {
+        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let expected = BooleanArray::from($expected);
+
+                let left = BinaryArray::from_vec($left);
+                let right = BinaryArray::from_vec($right);
+                let res = $op(&left, &right).unwrap();
+                assert_eq!(res, expected);
+
+                let left = LargeBinaryArray::from_vec($left);
+                let right = LargeBinaryArray::from_vec($right);
+                let res = $op(&left, &right).unwrap();
+                assert_eq!(res, expected);
+            }
+        };
+    }
+
+    #[test]
+    fn test_binary_eq_scalar_on_slice() {
+        let a = BinaryArray::from_opt_vec(vec![Some(b"hi"), None, Some(b"hello"), Some(b"world")]);
+        let a = a.slice(1, 3);
+        let a = as_generic_binary_array::<i32>(&a);
+        let a_eq = eq_binary_scalar(a, b"hello").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![None, Some(true), Some(false)])
+        );
+    }
+
+    macro_rules! test_binary_scalar {
+        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let expected = BooleanArray::from($expected);
+
+                let left = BinaryArray::from_vec($left);
+                let res = $op(&left, $right).unwrap();
+                assert_eq!(res, expected);
+
+                let left = LargeBinaryArray::from_vec($left);
+                let res = $op(&left, $right).unwrap();
+                assert_eq!(res, expected);
+            }
+        };
+    }
+
+    test_binary!(
+        test_binary_array_eq,
+        vec![b"arrow", b"arrow", b"arrow", b"arrow", &[0xff, 0xf8]],
+        vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf8]],
+        eq_binary,
+        vec![true, false, false, false, true]
+    );
+
+    test_binary_scalar!(
+        test_binary_array_eq_scalar,
+        vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf8]],
+        "arrow".as_bytes(),
+        eq_binary_scalar,
+        vec![true, false, false, false, false]
+    );
+
+    test_binary!(
+        test_binary_array_neq,
+        vec![b"arrow", b"arrow", b"arrow", b"arrow", &[0xff, 0xf8]],
+        vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf9]],
+        neq_binary,
+        vec![false, true, true, true, true]
+    );
+    test_binary_scalar!(
+        test_binary_array_neq_scalar,
+        vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf8]],
+        "arrow".as_bytes(),
+        neq_binary_scalar,
+        vec![false, true, true, true, true]
+    );
+
+    test_binary!(
+        test_binary_array_lt,
+        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
+        vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf9]],
+        lt_binary,
+        vec![true, true, false, false, true]
+    );
+    test_binary_scalar!(
+        test_binary_array_lt_scalar,
+        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
+        "flight".as_bytes(),
+        lt_binary_scalar,
+        vec![true, true, false, false, false]
+    );
+
+    test_binary!(
+        test_binary_array_lt_eq,
+        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
+        vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf8, 0xf9]],
+        lt_eq_binary,
+        vec![true, true, true, false, true]
+    );
+    test_binary_scalar!(
+        test_binary_array_lt_eq_scalar,
+        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
+        "flight".as_bytes(),
+        lt_eq_binary_scalar,
+        vec![true, true, true, false, false]
+    );
+
+    test_binary!(
+        test_binary_array_gt,
+        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf9]],
+        vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf8]],
+        gt_binary,
+        vec![false, false, false, true, true]
+    );
+    test_binary_scalar!(
+        test_binary_array_gt_scalar,
+        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
+        "flight".as_bytes(),
+        gt_binary_scalar,
+        vec![false, false, false, true, true]
+    );
+
+    test_binary!(
+        test_binary_array_gt_eq,
+        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
+        vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf8]],
+        gt_eq_binary,
+        vec![false, false, true, true, true]
+    );
+    test_binary_scalar!(
+        test_binary_array_gt_eq_scalar,
+        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
+        "flight".as_bytes(),
+        gt_eq_binary_scalar,
+        vec![false, false, true, true, true]
+    );
+
+    // Expected behaviour:
+    // contains("ab", ["ab", "cd", null]) = true
+    // contains("ef", ["ab", "cd", null]) = false
+    // contains(null, ["ab", "cd", null]) = false
+    // contains(null, null) = false
+    #[test]
+    fn test_contains_utf8() {
+        let values_builder = StringBuilder::new();
+        let mut builder = ListBuilder::new(values_builder);
+
+        builder.values().append_value("Lorem");
+        builder.values().append_value("ipsum");
+        builder.values().append_null();
+        builder.append(true);
+        builder.values().append_value("sit");
+        builder.values().append_value("amet");
+        builder.values().append_value("Lorem");
+        builder.append(true);
+        builder.append(false);
+        builder.values().append_value("ipsum");
+        builder.append(true);
+
+        //  [["Lorem", "ipsum", null], ["sit", "amet", "Lorem"], null, ["ipsum"]]
+        // value_offsets = [0, 3, 6, 6]
+        let list_array = builder.finish();
+
+        let v: Vec<Option<&str>> = vec![None, None, None, None];
+        let nulls = StringArray::from(v);
+        let nulls_result = in_list_utf8(&nulls, &list_array).unwrap();
+        assert_eq!(
+            nulls_result
+                .as_any()
+                .downcast_ref::<BooleanArray>()
+                .unwrap(),
+            &BooleanArray::from(vec![false, false, false, false]),
+        );
+
+        let values = StringArray::from(vec![
+            Some("Lorem"),
+            Some("Lorem"),
+            Some("Lorem"),
+            Some("Lorem"),
+        ]);
+        let values_result = in_list_utf8(&values, &list_array).unwrap();
+        assert_eq!(
+            values_result
+                .as_any()
+                .downcast_ref::<BooleanArray>()
+                .unwrap(),
+            &BooleanArray::from(vec![true, true, false, false]),
+        );
+    }
+
+    macro_rules! test_utf8 {
+        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let left = StringArray::from($left);
+                let right = StringArray::from($right);
+                let res = $op(&left, &right).unwrap();
+                let expected = $expected;
+                assert_eq!(expected.len(), res.len());
+                for i in 0..res.len() {
+                    let v = res.value(i);
+                    assert_eq!(v, expected[i]);
+                }
+            }
+        };
+    }
+
+    #[test]
+    fn test_utf8_eq_scalar_on_slice() {
+        let a = StringArray::from(vec![Some("hi"), None, Some("hello"), Some("world"), Some("")]);
+        let a = a.slice(1, 4);
+        let a_eq = eq_utf8_scalar(&a, "hello").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![None, Some(true), Some(false), Some(false)])
+        );
+
+        let a_eq2 = eq_utf8_scalar(&a, "").unwrap();
+
+        assert_eq!(
+            a_eq2,
+            BooleanArray::from(vec![None, Some(false), Some(false), Some(true)])
+        );
+    }
+
+    macro_rules! test_utf8_scalar {
+        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let left = StringArray::from($left);
+                let res = $op(&left, $right).unwrap();
+                let expected = $expected;
+                assert_eq!(expected.len(), res.len());
+                for i in 0..res.len() {
+                    let v = res.value(i);
+                    assert_eq!(
+                        v,
+                        expected[i],
+                        "unexpected result when comparing {} at position {} to {} ",
+                        left.value(i),
+                        i,
+                        $right
+                    );
+                }
+
+                let left = LargeStringArray::from($left);
+                let res = $op(&left, $right).unwrap();
+                let expected = $expected;
+                assert_eq!(expected.len(), res.len());
+                for i in 0..res.len() {
+                    let v = res.value(i);
+                    assert_eq!(
+                        v,
+                        expected[i],
+                        "unexpected result when comparing {} at position {} to {} ",
+                        left.value(i),
+                        i,
+                        $right
+                    );
+                }
+            }
+        };
+        ($test_name:ident, $test_name_dyn:ident, $left:expr, $right:expr, $op:expr, $op_dyn:expr, $expected:expr) => {
+            test_utf8_scalar!($test_name, $left, $right, $op, $expected);
+            test_utf8_scalar!($test_name_dyn, $left, $right, $op_dyn, $expected);
+        };
+    }
+
+    test_utf8!(
+        test_utf8_array_eq,
+        vec!["arrow", "arrow", "arrow", "arrow"],
+        vec!["arrow", "parquet", "datafusion", "flight"],
+        eq_utf8,
+        [true, false, false, false]
+    );
+    test_utf8_scalar!(
+        test_utf8_array_eq_scalar,
+        vec!["arrow", "parquet", "datafusion", "flight"],
+        "arrow",
+        eq_utf8_scalar,
+        [true, false, false, false]
+    );
+
+    test_utf8!(
+        test_utf8_array_neq,
+        vec!["arrow", "arrow", "arrow", "arrow"],
+        vec!["arrow", "parquet", "datafusion", "flight"],
+        neq_utf8,
+        [false, true, true, true]
+    );
+    test_utf8_scalar!(
+        test_utf8_array_neq_scalar,
+        vec!["arrow", "parquet", "datafusion", "flight"],
+        "arrow",
+        neq_utf8_scalar,
+        [false, true, true, true]
+    );
+
+    test_utf8!(
+        test_utf8_array_lt,
+        vec!["arrow", "datafusion", "flight", "parquet"],
+        vec!["flight", "flight", "flight", "flight"],
+        lt_utf8,
+        [true, true, false, false]
+    );
+    test_utf8_scalar!(
+        test_utf8_array_lt_scalar,
+        vec!["arrow", "datafusion", "flight", "parquet"],
+        "flight",
+        lt_utf8_scalar,
+        [true, true, false, false]
+    );
+
+    test_utf8!(
+        test_utf8_array_lt_eq,
+        vec!["arrow", "datafusion", "flight", "parquet"],
+        vec!["flight", "flight", "flight", "flight"],
+        lt_eq_utf8,
+        [true, true, true, false]
+    );
+    test_utf8_scalar!(
+        test_utf8_array_lt_eq_scalar,
+        vec!["arrow", "datafusion", "flight", "parquet"],
+        "flight",
+        lt_eq_utf8_scalar,
+        [true, true, true, false]
+    );
+
+    test_utf8!(
+        test_utf8_array_gt,
+        vec!["arrow", "datafusion", "flight", "parquet"],
+        vec!["flight", "flight", "flight", "flight"],
+        gt_utf8,
+        [false, false, false, true]
+    );
+    test_utf8_scalar!(
+        test_utf8_array_gt_scalar,
+        vec!["arrow", "datafusion", "flight", "parquet"],
+        "flight",
+        gt_utf8_scalar,
+        [false, false, false, true]
+    );
+
+    test_utf8!(
+        test_utf8_array_gt_eq,
+        vec!["arrow", "datafusion", "flight", "parquet"],
+        vec!["flight", "flight", "flight", "flight"],
+        gt_eq_utf8,
+        [false, false, true, true]
+    );
+    test_utf8_scalar!(
+        test_utf8_array_gt_eq_scalar,
+        vec!["arrow", "datafusion", "flight", "parquet"],
+        "flight",
+        gt_eq_utf8_scalar,
+        [false, false, true, true]
+    );
+
+    #[test]
+    fn test_eq_dyn_scalar() {
+        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
+        let a_eq = eq_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), Some(false), Some(true), Some(true), Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_scalar_with_dict() {
+        let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
+        builder.append(123).unwrap();
+        builder.append_null();
+        builder.append(23).unwrap();
+        let array = builder.finish();
+        let a_eq = eq_dyn_scalar(&array, 123).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), None, Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_scalar_float() {
+        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let expected =
+            BooleanArray::from(vec![Some(false), Some(false), Some(true), Some(true), Some(false)]);
+        assert_eq!(eq_dyn_scalar(&array, 8).unwrap(), expected);
+
+        let array = array.unary::<_, Float64Type>(|x| x as f64);
+        assert_eq!(eq_dyn_scalar(&array, 8).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_lt_dyn_scalar() {
+        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
+        let a_eq = lt_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), Some(true), Some(false), Some(false), Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_lt_dyn_scalar_with_dict() {
+        let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
+        builder.append(123).unwrap();
+        builder.append_null();
+        builder.append(23).unwrap();
+        let array = builder.finish();
+        let a_eq = lt_dyn_scalar(&array, 123).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), None, Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_lt_dyn_scalar_float() {
+        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(true), Some(false), Some(false), Some(false)]);
+        assert_eq!(lt_dyn_scalar(&array, 8).unwrap(), expected);
+
+        let array = array.unary::<_, Float64Type>(|x| x as f64);
+        assert_eq!(lt_dyn_scalar(&array, 8).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_lt_eq_dyn_scalar() {
+        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
+        let a_eq = lt_eq_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(true), Some(false)])
+        );
+    }
+
+    fn test_primitive_dyn_scalar<T: ArrowPrimitiveType>(array: PrimitiveArray<T>) {
+        let a_eq = eq_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), None, Some(true), None, Some(false)])
+        );
+
+        let a_eq = gt_eq_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), None, Some(true), None, Some(true)])
+        );
+
+        let a_eq = gt_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), None, Some(false), None, Some(true)])
+        );
+
+        let a_eq = lt_eq_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), None, Some(true), None, Some(false)])
+        );
+
+        let a_eq = lt_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), None, Some(false), None, Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_timestamp_dyn_scalar() {
+        let array = TimestampSecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+
+        let array = TimestampMicrosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+
+        let array = TimestampMicrosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+
+        let array = TimestampNanosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+    }
+
+    #[test]
+    fn test_date32_dyn_scalar() {
+        let array = Date32Array::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+    }
+
+    #[test]
+    fn test_date64_dyn_scalar() {
+        let array = Date64Array::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+    }
+
+    #[test]
+    fn test_time32_dyn_scalar() {
+        let array = Time32SecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+
+        let array = Time32MillisecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+    }
+
+    #[test]
+    fn test_time64_dyn_scalar() {
+        let array = Time64MicrosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+
+        let array = Time64NanosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+    }
+
+    #[test]
+    fn test_interval_dyn_scalar() {
+        let array = IntervalDayTimeArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+
+        let array = IntervalMonthDayNanoArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+
+        let array = IntervalYearMonthArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+    }
+
+    #[test]
+    fn test_duration_dyn_scalar() {
+        let array = DurationSecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+
+        let array = DurationMicrosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+
+        let array = DurationMillisecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+
+        let array = DurationNanosecondArray::from(vec![Some(1), None, Some(8), None, Some(10)]);
+        test_primitive_dyn_scalar(array);
+    }
+
+    #[test]
+    fn test_lt_eq_dyn_scalar_with_dict() {
+        let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
+        builder.append(123).unwrap();
+        builder.append_null();
+        builder.append(23).unwrap();
+        let array = builder.finish();
+        let a_eq = lt_eq_dyn_scalar(&array, 23).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), None, Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_lt_eq_dyn_scalar_float() {
+        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(true), Some(false)]);
+        assert_eq!(lt_eq_dyn_scalar(&array, 8).unwrap(), expected);
+
+        let array = array.unary::<_, Float64Type>(|x| x as f64);
+        assert_eq!(lt_eq_dyn_scalar(&array, 8).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_gt_dyn_scalar() {
+        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
+        let a_eq = gt_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(
+                vec![Some(false), Some(false), Some(false), Some(false), Some(true)]
+            )
+        );
+    }
+
+    #[test]
+    fn test_gt_dyn_scalar_with_dict() {
+        let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
+        builder.append(123).unwrap();
+        builder.append_null();
+        builder.append(23).unwrap();
+        let array = builder.finish();
+        let a_eq = gt_dyn_scalar(&array, 23).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), None, Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_gt_dyn_scalar_float() {
+        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(true)],
+        );
+        assert_eq!(gt_dyn_scalar(&array, 8).unwrap(), expected);
+
+        let array = array.unary::<_, Float64Type>(|x| x as f64);
+        assert_eq!(gt_dyn_scalar(&array, 8).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_gt_eq_dyn_scalar() {
+        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
+        let a_eq = gt_eq_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), Some(false), Some(true), Some(true), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_gt_eq_dyn_scalar_with_dict() {
+        let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
+        builder.append(22).unwrap();
+        builder.append_null();
+        builder.append(23).unwrap();
+        let array = builder.finish();
+        let a_eq = gt_eq_dyn_scalar(&array, 23).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), None, Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_gt_eq_dyn_scalar_float() {
+        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let expected =
+            BooleanArray::from(vec![Some(false), Some(false), Some(true), Some(true), Some(true)]);
+        assert_eq!(gt_eq_dyn_scalar(&array, 8).unwrap(), expected);
+
+        let array = array.unary::<_, Float64Type>(|x| x as f64);
+        assert_eq!(gt_eq_dyn_scalar(&array, 8).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_neq_dyn_scalar() {
+        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
+        let a_eq = neq_dyn_scalar(&array, 8).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), Some(true), Some(false), Some(false), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_neq_dyn_scalar_with_dict() {
+        let mut builder = PrimitiveDictionaryBuilder::<Int8Type, Int32Type>::with_capacity(3, 2);
+        builder.append(22).unwrap();
+        builder.append_null();
+        builder.append(23).unwrap();
+        let array = builder.finish();
+        let a_eq = neq_dyn_scalar(&array, 23).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), None, Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_neq_dyn_scalar_float() {
+        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(true), Some(false), Some(false), Some(true)]);
+        assert_eq!(neq_dyn_scalar(&array, 8).unwrap(), expected);
+
+        let array = array.unary::<_, Float64Type>(|x| x as f64);
+        assert_eq!(neq_dyn_scalar(&array, 8).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_eq_dyn_binary_scalar() {
+        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
+        let array = BinaryArray::from(data.clone());
+        let large_array = LargeBinaryArray::from(data);
+        let scalar = "flight".as_bytes();
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), Some(false), Some(false), None],
+        );
+
+        assert_eq!(eq_dyn_binary_scalar(&array, scalar).unwrap(), expected);
+        assert_eq!(
+            eq_dyn_binary_scalar(&large_array, scalar).unwrap(),
+            expected
+        );
+
+        let fsb_array = FixedSizeBinaryArray::try_from_iter(
+            vec![vec![0u8], vec![0u8], vec![0u8], vec![1u8]].into_iter(),
+        )
+        .unwrap();
+        let scalar = &[1u8];
+        let expected = BooleanArray::from(vec![Some(false), Some(false), Some(false), Some(true)]);
+        assert_eq!(eq_dyn_binary_scalar(&fsb_array, scalar).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_neq_dyn_binary_scalar() {
+        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
+        let array = BinaryArray::from(data.clone());
+        let large_array = LargeBinaryArray::from(data);
+        let scalar = "flight".as_bytes();
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), Some(true), Some(true), None],
+        );
+
+        assert_eq!(neq_dyn_binary_scalar(&array, scalar).unwrap(), expected);
+        assert_eq!(
+            neq_dyn_binary_scalar(&large_array, scalar).unwrap(),
+            expected
+        );
+
+        let fsb_array = FixedSizeBinaryArray::try_from_iter(
+            vec![vec![0u8], vec![0u8], vec![0u8], vec![1u8]].into_iter(),
+        )
+        .unwrap();
+        let scalar = &[1u8];
+        let expected = BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(false)]);
+        assert_eq!(neq_dyn_binary_scalar(&fsb_array, scalar).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_lt_dyn_binary_scalar() {
+        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
+        let array = BinaryArray::from(data.clone());
+        let large_array = LargeBinaryArray::from(data);
+        let scalar = "flight".as_bytes();
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), Some(false), Some(false), None],
+        );
+
+        assert_eq!(lt_dyn_binary_scalar(&array, scalar).unwrap(), expected);
+        assert_eq!(
+            lt_dyn_binary_scalar(&large_array, scalar).unwrap(),
+            expected
+        );
+    }
+
+    #[test]
+    fn test_lt_eq_dyn_binary_scalar() {
+        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
+        let array = BinaryArray::from(data.clone());
+        let large_array = LargeBinaryArray::from(data);
+        let scalar = "flight".as_bytes();
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(true), Some(false), Some(false), None],
+        );
+
+        assert_eq!(lt_eq_dyn_binary_scalar(&array, scalar).unwrap(), expected);
+        assert_eq!(
+            lt_eq_dyn_binary_scalar(&large_array, scalar).unwrap(),
+            expected
+        );
+    }
+
+    #[test]
+    fn test_gt_dyn_binary_scalar() {
+        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
+        let array = BinaryArray::from(data.clone());
+        let large_array = LargeBinaryArray::from(data);
+        let scalar = "flight".as_bytes();
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(true), Some(true), None],
+        );
+
+        assert_eq!(gt_dyn_binary_scalar(&array, scalar).unwrap(), expected);
+        assert_eq!(
+            gt_dyn_binary_scalar(&large_array, scalar).unwrap(),
+            expected
+        );
+    }
+
+    #[test]
+    fn test_gt_eq_dyn_binary_scalar() {
+        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
+        let array = BinaryArray::from(data.clone());
+        let large_array = LargeBinaryArray::from(data);
+        let scalar = &[0xff, 0xf8];
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(true), None],
+        );
+
+        assert_eq!(gt_eq_dyn_binary_scalar(&array, scalar).unwrap(), expected);
+        assert_eq!(
+            gt_eq_dyn_binary_scalar(&large_array, scalar).unwrap(),
+            expected
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_utf8_scalar() {
+        let array = StringArray::from(vec!["abc", "def", "xyz"]);
+        let a_eq = eq_dyn_utf8_scalar(&array, "xyz").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), Some(false), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_utf8_scalar_with_dict() {
+        let mut builder = StringDictionaryBuilder::<Int8Type>::new();
+        builder.append("abc").unwrap();
+        builder.append_null();
+        builder.append("def").unwrap();
+        builder.append("def").unwrap();
+        builder.append("abc").unwrap();
+        let array = builder.finish();
+        let a_eq = eq_dyn_utf8_scalar(&array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), None, Some(true), Some(true), Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_lt_dyn_utf8_scalar() {
+        let array = StringArray::from(vec!["abc", "def", "xyz"]);
+        let a_eq = lt_dyn_utf8_scalar(&array, "xyz").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), Some(true), Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_lt_dyn_utf8_scalar_with_dict() {
+        let mut builder = StringDictionaryBuilder::<Int8Type>::new();
+        builder.append("abc").unwrap();
+        builder.append_null();
+        builder.append("def").unwrap();
+        builder.append("def").unwrap();
+        builder.append("abc").unwrap();
+        let array = builder.finish();
+        let a_eq = lt_dyn_utf8_scalar(&array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), None, Some(false), Some(false), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_lt_eq_dyn_utf8_scalar() {
+        let array = StringArray::from(vec!["abc", "def", "xyz"]);
+        let a_eq = lt_eq_dyn_utf8_scalar(&array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), Some(true), Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_lt_eq_dyn_utf8_scalar_with_dict() {
+        let mut builder = StringDictionaryBuilder::<Int8Type>::new();
+        builder.append("abc").unwrap();
+        builder.append_null();
+        builder.append("def").unwrap();
+        builder.append("def").unwrap();
+        builder.append("xyz").unwrap();
+        let array = builder.finish();
+        let a_eq = lt_eq_dyn_utf8_scalar(&array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), None, Some(true), Some(true), Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_gt_eq_dyn_utf8_scalar() {
+        let array = StringArray::from(vec!["abc", "def", "xyz"]);
+        let a_eq = gt_eq_dyn_utf8_scalar(&array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), Some(true), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_gt_eq_dyn_utf8_scalar_with_dict() {
+        let mut builder = StringDictionaryBuilder::<Int8Type>::new();
+        builder.append("abc").unwrap();
+        builder.append_null();
+        builder.append("def").unwrap();
+        builder.append("def").unwrap();
+        builder.append("xyz").unwrap();
+        let array = builder.finish();
+        let a_eq = gt_eq_dyn_utf8_scalar(&array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), None, Some(true), Some(true), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_gt_dyn_utf8_scalar() {
+        let array = StringArray::from(vec!["abc", "def", "xyz"]);
+        let a_eq = gt_dyn_utf8_scalar(&array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), Some(false), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_gt_dyn_utf8_scalar_with_dict() {
+        let mut builder = StringDictionaryBuilder::<Int8Type>::new();
+        builder.append("abc").unwrap();
+        builder.append_null();
+        builder.append("def").unwrap();
+        builder.append("def").unwrap();
+        builder.append("xyz").unwrap();
+        let array = builder.finish();
+        let a_eq = gt_dyn_utf8_scalar(&array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), None, Some(false), Some(false), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_neq_dyn_utf8_scalar() {
+        let array = StringArray::from(vec!["abc", "def", "xyz"]);
+        let a_eq = neq_dyn_utf8_scalar(&array, "xyz").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), Some(true), Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_neq_dyn_utf8_scalar_with_dict() {
+        let mut builder = StringDictionaryBuilder::<Int8Type>::new();
+        builder.append("abc").unwrap();
+        builder.append_null();
+        builder.append("def").unwrap();
+        builder.append("def").unwrap();
+        builder.append("abc").unwrap();
+        let array = builder.finish();
+        let a_eq = neq_dyn_utf8_scalar(&array, "def").unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), None, Some(false), Some(false), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_bool_scalar() {
+        let array = BooleanArray::from(vec![true, false, true]);
+        let a_eq = eq_dyn_bool_scalar(&array, false).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), Some(true), Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_lt_dyn_bool_scalar() {
+        let array = BooleanArray::from(vec![Some(true), Some(false), Some(true), None]);
+        let a_eq = lt_dyn_bool_scalar(&array, false).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), Some(false), Some(false), None])
+        );
+    }
+
+    #[test]
+    fn test_gt_dyn_bool_scalar() {
+        let array = BooleanArray::from(vec![true, false, true]);
+        let a_eq = gt_dyn_bool_scalar(&array, false).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), Some(false), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_lt_eq_dyn_bool_scalar() {
+        let array = BooleanArray::from(vec![true, false, true]);
+        let a_eq = lt_eq_dyn_bool_scalar(&array, false).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(false), Some(true), Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_gt_eq_dyn_bool_scalar() {
+        let array = BooleanArray::from(vec![true, false, true]);
+        let a_eq = gt_eq_dyn_bool_scalar(&array, false).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), Some(true), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_neq_dyn_bool_scalar() {
+        let array = BooleanArray::from(vec![true, false, true]);
+        let a_eq = neq_dyn_bool_scalar(&array, false).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), Some(false), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_fixed_size_binary() {
+        let values1: Vec<Option<&[u8]>> = vec![Some(&[0xfc, 0xa9]), None, Some(&[0x36, 0x01])];
+        let values2: Vec<Option<&[u8]>> = vec![Some(&[0xfc, 0xa9]), None, Some(&[0x36, 0x00])];
+
+        let array1 =
+            FixedSizeBinaryArray::try_from_sparse_iter_with_size(values1.into_iter(), 2).unwrap();
+        let array2 =
+            FixedSizeBinaryArray::try_from_sparse_iter_with_size(values2.into_iter(), 2).unwrap();
+
+        let result = eq_dyn(&array1, &array2).unwrap();
+        assert_eq!(
+            BooleanArray::from(vec![Some(true), None, Some(false)]),
+            result
+        );
+
+        let result = neq_dyn(&array1, &array2).unwrap();
+        assert_eq!(
+            BooleanArray::from(vec![Some(false), None, Some(true)]),
+            result
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_i8_array() {
+        // Construct a value array
+        let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
+        let values = Arc::new(values) as ArrayRef;
+
+        let keys1 = Int8Array::from_iter_values([2_i8, 3, 4]);
+        let keys2 = Int8Array::from_iter_values([2_i8, 4, 4]);
+        let dict_array1 = DictionaryArray::new(keys1, values.clone());
+        let dict_array2 = DictionaryArray::new(keys2, values.clone());
+
+        let result = eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
+
+        let result = neq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![false, true, false])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_u64_array() {
+        let values = UInt64Array::from_iter_values([10_u64, 11, 12, 13, 14, 15, 16, 17]);
+        let values = Arc::new(values) as ArrayRef;
+
+        let keys1 = UInt64Array::from_iter_values([1_u64, 3, 4]);
+        let keys2 = UInt64Array::from_iter_values([2_u64, 3, 5]);
+        let dict_array1 = DictionaryArray::new(keys1, values.clone());
+        let dict_array2 = DictionaryArray::new(keys2, values.clone());
+
+        let result = eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![false, true, false])
+        );
+
+        let result = neq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_utf8_array() {
+        let test1 = ["a", "a", "b", "c"];
+        let test2 = ["a", "b", "b", "c"];
+
+        let dict_array1: DictionaryArray<Int8Type> = test1
+            .iter()
+            .map(|&x| if x == "b" { None } else { Some(x) })
+            .collect();
+        let dict_array2: DictionaryArray<Int8Type> = test2
+            .iter()
+            .map(|&x| if x == "b" { None } else { Some(x) })
+            .collect();
+
+        let result = eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(true)])
+        );
+
+        let result = neq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_binary_array() {
+        let values: BinaryArray = ["hello", "", "parquet"]
+            .into_iter()
+            .map(|b| Some(b.as_bytes()))
+            .collect();
+        let values = Arc::new(values) as ArrayRef;
+
+        let keys1 = UInt64Array::from_iter_values([0_u64, 1, 2]);
+        let keys2 = UInt64Array::from_iter_values([0_u64, 2, 1]);
+        let dict_array1 = DictionaryArray::new(keys1, values.clone());
+        let dict_array2 = DictionaryArray::new(keys2, values.clone());
+
+        let result = eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![true, false, false])
+        );
+
+        let result = neq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_interval_array() {
+        let values = IntervalDayTimeArray::from(vec![1, 6, 10, 2, 3, 5]);
+        let values = Arc::new(values) as ArrayRef;
+
+        let keys1 = UInt64Array::from_iter_values([1_u64, 0, 3]);
+        let keys2 = UInt64Array::from_iter_values([2_u64, 0, 3]);
+        let dict_array1 = DictionaryArray::new(keys1, values.clone());
+        let dict_array2 = DictionaryArray::new(keys2, values.clone());
+
+        let result = eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
+
+        let result = neq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![true, false, false])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_date_array() {
+        let values = Date32Array::from(vec![1, 6, 10, 2, 3, 5]);
+        let values = Arc::new(values) as ArrayRef;
+
+        let keys1 = UInt64Array::from_iter_values([1_u64, 0, 3]);
+        let keys2 = UInt64Array::from_iter_values([2_u64, 0, 3]);
+        let dict_array1 = DictionaryArray::new(keys1, values.clone());
+        let dict_array2 = DictionaryArray::new(keys2, values.clone());
+
+        let result = eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
+
+        let result = neq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![true, false, false])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_bool_array() {
+        let values = BooleanArray::from(vec![true, false]);
+        let values = Arc::new(values) as ArrayRef;
+
+        let keys1 = UInt64Array::from_iter_values([1_u64, 1, 1]);
+        let keys2 = UInt64Array::from_iter_values([0_u64, 1, 0]);
+        let dict_array1 = DictionaryArray::new(keys1, values.clone());
+        let dict_array2 = DictionaryArray::new(keys2, values.clone());
+
+        let result = eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![false, true, false])
+        );
+
+        let result = neq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
+    }
+
+    #[test]
+    fn test_lt_dyn_gt_dyn_dictionary_i8_array() {
+        // Construct a value array
+        let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
+        let values = Arc::new(values) as ArrayRef;
+
+        let keys1 = Int8Array::from_iter_values([3_i8, 4, 4]);
+        let keys2 = Int8Array::from_iter_values([4_i8, 3, 4]);
+        let dict_array1 = DictionaryArray::new(keys1, values.clone());
+        let dict_array2 = DictionaryArray::new(keys2, values.clone());
+
+        let result = lt_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![true, false, false])
+        );
+
+        let result = lt_eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
+
+        let result = gt_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![false, true, false])
+        );
+
+        let result = gt_eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
+    }
+
+    #[test]
+    fn test_lt_dyn_gt_dyn_dictionary_bool_array() {
+        let values = BooleanArray::from(vec![true, false]);
+        let values = Arc::new(values) as ArrayRef;
+
+        let keys1 = UInt64Array::from_iter_values([1_u64, 1, 0]);
+        let keys2 = UInt64Array::from_iter_values([0_u64, 1, 1]);
+        let dict_array1 = DictionaryArray::new(keys1, values.clone());
+        let dict_array2 = DictionaryArray::new(keys2, values.clone());
+
+        let result = lt_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![true, false, false])
+        );
+
+        let result = lt_eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(result.unwrap(), BooleanArray::from(vec![true, true, false]));
+
+        let result = gt_dyn(&dict_array1, &dict_array2);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![false, false, true])
+        );
+
+        let result = gt_eq_dyn(&dict_array1, &dict_array2);
+        assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
+    }
+
+    #[test]
+    fn test_unary_cmp() {
+        let a = Int32Array::from(vec![Some(1), None, Some(2), Some(3)]);
+        let values = [1_i32, 3];
+
+        let a_eq = unary_cmp(&a, |a| values.contains(&a)).unwrap();
+        assert_eq!(
+            a_eq,
+            BooleanArray::from(vec![Some(true), None, Some(false), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_i8_i8_array() {
+        let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
+        let keys = Int8Array::from_iter_values([2_i8, 3, 4]);
+
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+
+        let array = Int8Array::from_iter([Some(12_i8), None, Some(14)]);
+
+        let result = eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(true)])
+        );
+
+        let result = eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(true)])
+        );
+
+        let result = neq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(false)])
+        );
+
+        let result = neq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_lt_dyn_lt_eq_dyn_gt_dyn_gt_eq_dyn_dictionary_i8_i8_array() {
+        let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
+        let keys = Int8Array::from_iter_values([2_i8, 3, 4]);
+
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+
+        let array = Int8Array::from_iter([Some(12_i8), None, Some(11)]);
+
+        let result = lt_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(false)])
+        );
+
+        let result = lt_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(true)])
+        );
+
+        let result = lt_eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(false)])
+        );
+
+        let result = lt_eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(true)])
+        );
+
+        let result = gt_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(true)])
+        );
+
+        let result = gt_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(false)])
+        );
+
+        let result = gt_eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(true)])
+        );
+
+        let result = gt_eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(false)])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_float_nan() {
+        let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
+        let array2 = Float16Array::from(
+            vec![f16::NAN, f16::NAN, f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)],
+        );
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(false), Some(true), Some(true), Some(true)]);
+        assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(eq(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(neq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(neq(&array1, &array2).unwrap(), expected);
+
+        let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
+        let array2 = Float32Array::from(vec![f32::NAN, f32::NAN, 8.0, 8.0, 10.0]);
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(false), Some(true), Some(true), Some(true)]);
+        assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(eq(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(neq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(neq(&array1, &array2).unwrap(), expected);
+
+        let array1 = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
+        let array2 = Float64Array::from(vec![f64::NAN, f64::NAN, 8.0, 8.0, 10.0]);
+
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(false), Some(true), Some(true), Some(true)]);
+        assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(eq(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(neq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(neq(&array1, &array2).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_lt_dyn_lt_eq_dyn_float_nan() {
+        let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]);
+        let array2 = Float16Array::from(vec![f16::NAN, f16::NAN, f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0), f16::from_f32(1.0)]);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(lt(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(true), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(lt_eq(&array1, &array2).unwrap(), expected);
+
+        let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 11.0, f32::NAN]);
+        let array2 = Float32Array::from(vec![f32::NAN, f32::NAN, 8.0, 9.0, 10.0, 1.0]);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(lt(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(true), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(lt_eq(&array1, &array2).unwrap(), expected);
+
+        let array1: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 11.0, f64::NAN]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let array2: Float64Array = vec![f64::NAN, f64::NAN, 8.0, 9.0, 10.0, 1.0]
+            .into_iter()
+            .map(Some)
+            .collect();
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(lt(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(true), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(lt_eq(&array1, &array2).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_gt_dyn_gt_eq_dyn_float_nan() {
+        let array1 = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]);
+        let array2 = Float16Array::from(vec![f16::NAN, f16::NAN, f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0), f16::from_f32(1.0)]);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(gt(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(true), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(gt_eq(&array1, &array2).unwrap(), expected);
+
+        let array1 = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 11.0, f32::NAN]);
+        let array2 = Float32Array::from(vec![f32::NAN, f32::NAN, 8.0, 9.0, 10.0, 1.0]);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(gt(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(true), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(gt_eq(&array1, &array2).unwrap(), expected);
+
+        let array1 = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 11.0, f64::NAN]);
+        let array2 = Float64Array::from(vec![f64::NAN, f64::NAN, 8.0, 9.0, 10.0, 1.0]);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(gt(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(true), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        assert_eq!(gt_eq(&array1, &array2).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_eq_dyn_scalar_neq_dyn_scalar_float_nan() {
+        let array = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(eq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+        let expected =
+            BooleanArray::from(vec![Some(false), Some(true), Some(true), Some(true), Some(true)]);
+        assert_eq!(neq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+        let array = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(eq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+        let expected =
+            BooleanArray::from(vec![Some(false), Some(true), Some(true), Some(true), Some(true)]);
+        assert_eq!(neq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+        let array = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(eq_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+
+        let expected =
+            BooleanArray::from(vec![Some(false), Some(true), Some(true), Some(true), Some(true)]);
+        assert_eq!(neq_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_lt_dyn_scalar_lt_eq_dyn_scalar_float_nan() {
+        let array = Float16Array::from(vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]);
+
+        let expected =
+            BooleanArray::from(vec![Some(false), Some(true), Some(true), Some(true), Some(true)]);
+        assert_eq!(lt_dyn_scalar(&array, f16::NAN).unwrap(), expected);
+
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(true), Some(true)]);
+        assert_eq!(lt_eq_dyn_scalar(&array, f16::NAN).unwrap(), expected);
+
+        let array = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
+
+        let expected =
+            BooleanArray::from(vec![Some(false), Some(true), Some(true), Some(true), Some(true)]);
+        assert_eq!(lt_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(true), Some(true)]);
+        assert_eq!(lt_eq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+        let array = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
+        let expected =
+            BooleanArray::from(vec![Some(false), Some(true), Some(true), Some(true), Some(true)]);
+        assert_eq!(lt_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(true), Some(true)]);
+        assert_eq!(lt_eq_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_gt_dyn_scalar_gt_eq_dyn_scalar_float_nan() {
+        let array = Float16Array::from(vec![
+           f16::NAN,
+           f16::from_f32(7.0),
+           f16::from_f32(8.0),
+           f16::from_f32(8.0),
+           f16::from_f32(10.0),
+       ]);
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(gt_dyn_scalar(&array, f16::NAN).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(gt_eq_dyn_scalar(&array, f16::NAN).unwrap(), expected);
+
+        let array = Float32Array::from(vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]);
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(gt_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(gt_eq_dyn_scalar(&array, f32::NAN).unwrap(), expected);
+
+        let array = Float64Array::from(vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]);
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(gt_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(gt_eq_dyn_scalar(&array, f64::NAN).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_to_utf8_array() {
+        let test1 = ["a", "a", "b", "c"];
+        let test2 = ["a", "b", "b", "d"];
+
+        let dict_array: DictionaryArray<Int8Type> = test1
+            .iter()
+            .map(|&x| if x == "b" { None } else { Some(x) })
+            .collect();
+
+        let array: StringArray = test2
+            .iter()
+            .map(|&x| if x == "b" { None } else { Some(x) })
+            .collect();
+
+        let result = eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(false)])
+        );
+
+        let result = eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(false)])
+        );
+
+        let result = neq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(true)])
+        );
+
+        let result = neq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_lt_dyn_lt_eq_dyn_gt_dyn_gt_eq_dyn_dictionary_to_utf8_array() {
+        let test1 = ["abc", "abc", "b", "cde"];
+        let test2 = ["abc", "b", "b", "def"];
+
+        let dict_array: DictionaryArray<Int8Type> = test1
+            .iter()
+            .map(|&x| if x == "b" { None } else { Some(x) })
+            .collect();
+
+        let array: StringArray = test2
+            .iter()
+            .map(|&x| if x == "b" { None } else { Some(x) })
+            .collect();
+
+        let result = lt_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(true)])
+        );
+
+        let result = lt_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(false)])
+        );
+
+        let result = lt_eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(true)])
+        );
+
+        let result = lt_eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(false)])
+        );
+
+        let result = gt_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(false)])
+        );
+
+        let result = gt_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(true)])
+        );
+
+        let result = gt_eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(false)])
+        );
+
+        let result = gt_eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_to_binary_array() {
+        let values: BinaryArray = ["hello", "", "parquet"]
+            .into_iter()
+            .map(|b| Some(b.as_bytes()))
+            .collect();
+
+        let keys = UInt64Array::from(vec![Some(0_u64), None, Some(2), Some(2)]);
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+
+        let array: BinaryArray = ["hello", "", "parquet", "test"]
+            .into_iter()
+            .map(|b| Some(b.as_bytes()))
+            .collect();
+
+        let result = eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(true), Some(false)])
+        );
+
+        let result = eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(true), Some(false)])
+        );
+
+        let result = neq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(false), Some(true)])
+        );
+
+        let result = neq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(false), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_lt_dyn_lt_eq_dyn_gt_dyn_gt_eq_dyn_dictionary_to_binary_array() {
+        let values: BinaryArray = ["hello", "", "parquet"]
+            .into_iter()
+            .map(|b| Some(b.as_bytes()))
+            .collect();
+
+        let keys = UInt64Array::from(vec![Some(0_u64), None, Some(2), Some(2)]);
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+
+        let array: BinaryArray = ["hello", "", "parquet", "test"]
+            .into_iter()
+            .map(|b| Some(b.as_bytes()))
+            .collect();
+
+        let result = lt_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(false), Some(true)])
+        );
+
+        let result = lt_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(false), Some(false)])
+        );
+
+        let result = lt_eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(true), Some(true)])
+        );
+
+        let result = lt_eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(true), Some(false)])
+        );
+
+        let result = gt_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(false), Some(false)])
+        );
+
+        let result = gt_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, Some(false), Some(true)])
+        );
+
+        let result = gt_eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(true), Some(false)])
+        );
+
+        let result = gt_eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, Some(true), Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dict_non_dict_float_nan() {
+        let array1: Float16Array = vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(10.0)]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let values = Float16Array::from(vec![f16::NAN, f16::from_f32(8.0), f16::from_f32(10.0)]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 1, 2]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(false), Some(true), Some(true), Some(true)]);
+        assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(neq_dyn(&array1, &array2).unwrap(), expected);
+
+        let array1: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 10.0]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let values = Float32Array::from(vec![f32::NAN, 8.0, 10.0]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 1, 2]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(false), Some(true), Some(true), Some(true)]);
+        assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(neq_dyn(&array1, &array2).unwrap(), expected);
+
+        let array1: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 10.0]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let values = Float64Array::from(vec![f64::NAN, 8.0, 10.0]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 1, 2]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected =
+            BooleanArray::from(vec![Some(true), Some(false), Some(true), Some(true), Some(true)]);
+        assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(neq_dyn(&array1, &array2).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_lt_dyn_lt_eq_dyn_dict_non_dict_float_nan() {
+        let array1: Float16Array = vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let values = Float16Array::from(vec![f16::NAN, f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0), f16::from_f32(1.0)]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(true), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let array1: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 11.0, f32::NAN]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let values = Float32Array::from(vec![f32::NAN, 8.0, 9.0, 10.0, 1.0]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(true), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let array1: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 11.0, f64::NAN]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let values = Float64Array::from(vec![f64::NAN, 8.0, 9.0, 10.0, 1.0]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(true), Some(false), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(true), Some(true), Some(false), Some(false)],
+        );
+        assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_gt_dyn_gt_eq_dyn_dict_non_dict_float_nan() {
+        let array1: Float16Array = vec![f16::NAN, f16::from_f32(7.0), f16::from_f32(8.0), f16::from_f32(8.0), f16::from_f32(11.0), f16::NAN]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let values = Float16Array::from(vec![f16::NAN, f16::from_f32(8.0), f16::from_f32(9.0), f16::from_f32(10.0), f16::from_f32(1.0)]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(true), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let array1: Float32Array = vec![f32::NAN, 7.0, 8.0, 8.0, 11.0, f32::NAN]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let values = Float32Array::from(vec![f32::NAN, 8.0, 9.0, 10.0, 1.0]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(true), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let array1: Float64Array = vec![f64::NAN, 7.0, 8.0, 8.0, 11.0, f64::NAN]
+            .into_iter()
+            .map(Some)
+            .collect();
+        let values = Float64Array::from(vec![f64::NAN, 8.0, 9.0, 10.0, 1.0]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(false), Some(true), Some(false), Some(true), Some(true)],
+        );
+        assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_eq_dyn_neq_dyn_dictionary_to_boolean_array() {
+        let test1 = vec![Some(true), None, Some(false)];
+        let test2 = vec![Some(true), None, None, Some(true)];
+
+        let values = BooleanArray::from(test1);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2]);
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+
+        let array = BooleanArray::from(test2);
+
+        let result = eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(false)])
+        );
+
+        let result = eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(false)])
+        );
+
+        let result = neq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(true)])
+        );
+
+        let result = neq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_lt_dyn_lt_eq_dyn_gt_dyn_gt_eq_dyn_dictionary_to_boolean_array() {
+        let test1 = vec![Some(true), None, Some(false)];
+        let test2 = vec![Some(true), None, None, Some(true)];
+
+        let values = BooleanArray::from(test1);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2]);
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+
+        let array = BooleanArray::from(test2);
+
+        let result = lt_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(true)])
+        );
+
+        let result = lt_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(false)])
+        );
+
+        let result = lt_eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(true)])
+        );
+
+        let result = lt_eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(false)])
+        );
+
+        let result = gt_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(false)])
+        );
+
+        let result = gt_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(false), None, None, Some(true)])
+        );
+
+        let result = gt_eq_dyn(&dict_array, &array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(false)])
+        );
+
+        let result = gt_eq_dyn(&array, &dict_array);
+        assert_eq!(
+            result.unwrap(),
+            BooleanArray::from(vec![Some(true), None, None, Some(true)])
+        );
+    }
+
+    #[test]
+    fn test_cmp_dict_decimal128() {
+        let values = Decimal128Array::from_iter_values([0, 1, 2, 3, 4, 5]);
+        let keys = Int8Array::from_iter_values([1_i8, 2, 5, 4, 3, 0]);
+        let array1 = DictionaryArray::new(keys, Arc::new(values));
+
+        let values = Decimal128Array::from_iter_values([7, -3, 4, 3, 5]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(true), Some(true), Some(false)],
+        );
+        assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), Some(false), Some(false), Some(true)],
+        );
+        assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), Some(true), Some(true), Some(true)],
+        );
+        assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), Some(true), Some(true), Some(false)],
+        );
+        assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_cmp_dict_non_dict_decimal128() {
+        let array1: Decimal128Array = Decimal128Array::from_iter_values([1, 2, 5, 4, 3, 0]);
+
+        let values = Decimal128Array::from_iter_values([7, -3, 4, 3, 5]);
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(true), Some(true), Some(false)],
+        );
+        assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), Some(false), Some(false), Some(true)],
+        );
+        assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), Some(true), Some(true), Some(true)],
+        );
+        assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), Some(true), Some(true), Some(false)],
+        );
+        assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_cmp_dict_decimal256() {
+        let values =
+            Decimal256Array::from_iter_values([0, 1, 2, 3, 4, 5].into_iter().map(i256::from_i128));
+        let keys = Int8Array::from_iter_values([1_i8, 2, 5, 4, 3, 0]);
+        let array1 = DictionaryArray::new(keys, Arc::new(values));
+
+        let values =
+            Decimal256Array::from_iter_values([7, -3, 4, 3, 5].into_iter().map(i256::from_i128));
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(true), Some(true), Some(false)],
+        );
+        assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), Some(false), Some(false), Some(true)],
+        );
+        assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), Some(true), Some(true), Some(true)],
+        );
+        assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), Some(true), Some(true), Some(false)],
+        );
+        assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_cmp_dict_non_dict_decimal256() {
+        let array1: Decimal256Array =
+            Decimal256Array::from_iter_values([1, 2, 5, 4, 3, 0].into_iter().map(i256::from_i128));
+
+        let values =
+            Decimal256Array::from_iter_values([7, -3, 4, 3, 5].into_iter().map(i256::from_i128));
+        let keys = Int8Array::from_iter_values([0_i8, 0, 1, 2, 3, 4]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(true), Some(true), Some(false)],
+        );
+        assert_eq!(eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), Some(false), Some(false), Some(true)],
+        );
+        assert_eq!(lt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), Some(true), Some(true), Some(true)],
+        );
+        assert_eq!(lt_eq_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), Some(false), Some(false), Some(false)],
+        );
+        assert_eq!(gt_dyn(&array1, &array2).unwrap(), expected);
+
+        let expected = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), Some(true), Some(true), Some(false)],
+        );
+        assert_eq!(gt_eq_dyn(&array1, &array2).unwrap(), expected);
+    }
+
+    #[test]
+    fn test_decimal128() {
+        let a = Decimal128Array::from_iter_values([1, 2, 4, 5]);
+        let b = Decimal128Array::from_iter_values([7, -3, 4, 3]);
+        let e = BooleanArray::from(vec![false, false, true, false]);
+        let r = eq(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let r = eq_dyn(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let e = BooleanArray::from(vec![true, false, false, false]);
+        let r = lt(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let r = lt_dyn(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let e = BooleanArray::from(vec![true, false, true, false]);
+        let r = lt_eq(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let r = lt_eq_dyn(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let e = BooleanArray::from(vec![false, true, false, true]);
+        let r = gt(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let r = gt_dyn(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let e = BooleanArray::from(vec![false, true, true, true]);
+        let r = gt_eq(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let r = gt_eq_dyn(&a, &b).unwrap();
+        assert_eq!(e, r);
+    }
+
+    #[test]
+    fn test_decimal128_scalar() {
+        let a = Decimal128Array::from(vec![Some(1), Some(2), Some(3), None, Some(4), Some(5)]);
+        let b = 3_i128;
+        // array eq scalar
+        let e = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), None, Some(false), Some(false)],
+        );
+        let r = eq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = eq_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+
+        // array neq scalar
+        let e = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), None, Some(true), Some(true)],
+        );
+        let r = neq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = neq_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+
+        // array lt scalar
+        let e = BooleanArray::from(
+            vec![Some(true), Some(true), Some(false), None, Some(false), Some(false)],
+        );
+        let r = lt_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = lt_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+
+        // array lt_eq scalar
+        let e = BooleanArray::from(
+            vec![Some(true), Some(true), Some(true), None, Some(false), Some(false)],
+        );
+        let r = lt_eq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = lt_eq_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+
+        // array gt scalar
+        let e = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), None, Some(true), Some(true)],
+        );
+        let r = gt_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = gt_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+
+        // array gt_eq scalar
+        let e = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), None, Some(true), Some(true)],
+        );
+        let r = gt_eq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = gt_eq_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+    }
+
+    #[test]
+    fn test_decimal256() {
+        let a = Decimal256Array::from_iter_values([1, 2, 4, 5].into_iter().map(i256::from_i128));
+        let b = Decimal256Array::from_iter_values([7, -3, 4, 3].into_iter().map(i256::from_i128));
+        let e = BooleanArray::from(vec![false, false, true, false]);
+        let r = eq(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let r = eq_dyn(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let e = BooleanArray::from(vec![true, false, false, false]);
+        let r = lt(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let r = lt_dyn(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let e = BooleanArray::from(vec![true, false, true, false]);
+        let r = lt_eq(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let r = lt_eq_dyn(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let e = BooleanArray::from(vec![false, true, false, true]);
+        let r = gt(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let r = gt_dyn(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let e = BooleanArray::from(vec![false, true, true, true]);
+        let r = gt_eq(&a, &b).unwrap();
+        assert_eq!(e, r);
+
+        let r = gt_eq_dyn(&a, &b).unwrap();
+        assert_eq!(e, r);
+    }
+
+    #[test]
+    fn test_decimal256_scalar_i128() {
+        let a = Decimal256Array::from_iter_values([1, 2, 3, 4, 5].into_iter().map(i256::from_i128));
+        let b = i256::from_i128(3);
+        // array eq scalar
+        let e = BooleanArray::from(
+            vec![Some(false), Some(false), Some(true), Some(false), Some(false)],
+        );
+        let r = eq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = eq_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+
+        // array neq scalar
+        let e =
+            BooleanArray::from(vec![Some(true), Some(true), Some(false), Some(true), Some(true)]);
+        let r = neq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = neq_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+
+        // array lt scalar
+        let e =
+            BooleanArray::from(vec![Some(true), Some(true), Some(false), Some(false), Some(false)]);
+        let r = lt_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = lt_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+
+        // array lt_eq scalar
+        let e =
+            BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(false), Some(false)]);
+        let r = lt_eq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = lt_eq_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+
+        // array gt scalar
+        let e =
+            BooleanArray::from(vec![Some(false), Some(false), Some(false), Some(true), Some(true)]);
+        let r = gt_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = gt_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+
+        // array gt_eq scalar
+        let e =
+            BooleanArray::from(vec![Some(false), Some(false), Some(true), Some(true), Some(true)]);
+        let r = gt_eq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = gt_eq_dyn_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+    }
+
+    #[test]
+    fn test_decimal256_scalar_i256() {
+        let a = Decimal256Array::from_iter_values([1, 2, 3, 4, 5].into_iter().map(i256::from_i128));
+        let b = i256::MAX;
+        // array eq scalar
+        let e = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+        );
+        let r = eq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = eq_dyn_scalar(&a, b).is_err();
+        assert!(r);
+
+        // array neq scalar
+        let e =
+            BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(true), Some(true)]);
+        let r = neq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = neq_dyn_scalar(&a, b).is_err();
+        assert!(r);
+
+        // array lt scalar
+        let e =
+            BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(true), Some(true)]);
+        let r = lt_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = lt_dyn_scalar(&a, b).is_err();
+        assert!(r);
+
+        // array lt_eq scalar
+        let e =
+            BooleanArray::from(vec![Some(true), Some(true), Some(true), Some(true), Some(true)]);
+        let r = lt_eq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = lt_eq_dyn_scalar(&a, b).is_err();
+        assert!(r);
+
+        // array gt scalar
+        let e = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+        );
+        let r = gt_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = gt_dyn_scalar(&a, b).is_err();
+        assert!(r);
+
+        // array gt_eq scalar
+        let e = BooleanArray::from(
+            vec![Some(false), Some(false), Some(false), Some(false), Some(false)],
+        );
+        let r = gt_eq_scalar(&a, b).unwrap();
+        assert_eq!(e, r);
+        let r = gt_eq_dyn_scalar(&a, b).is_err();
+        assert!(r);
+    }
+
+    #[test]
+    fn test_floating_zeros() {
+        let a = Float32Array::from(vec![0.0_f32, -0.0]);
+        let b = Float32Array::from(vec![-0.0_f32, 0.0]);
+
+        let result = eq_dyn(&a, &b).unwrap();
+        let excepted = BooleanArray::from(vec![false, false]);
+        assert_eq!(excepted, result);
+
+        let result = eq_dyn_scalar(&a, 0.0).unwrap();
+        let excepted = BooleanArray::from(vec![true, false]);
+        assert_eq!(excepted, result);
+
+        let result = eq_dyn_scalar(&a, -0.0).unwrap();
+        let excepted = BooleanArray::from(vec![false, true]);
+        assert_eq!(excepted, result);
+    }
+
+    #[derive(Debug)]
+    struct ToType {}
+
+    impl ToType {
+        fn to_i128(&self) -> Option<i128> {
+            None
+        }
+    }
+
+    #[test]
+    fn test_try_to_type() {
+        let a = ToType {};
+        let to_type = try_to_type!(a, to_i128).unwrap_err();
+        assert!(to_type
+            .to_string()
+            .contains("Could not convert ToType with to_i128"));
+    }
+
+    #[test]
+    fn test_dictionary_nested_nulls() {
+        let keys = Int32Array::from(vec![0, 1, 2]);
+        let v1 = Arc::new(Int32Array::from(vec![Some(0), None, Some(2)]));
+        let a = DictionaryArray::new(keys.clone(), v1);
+        let v2 = Arc::new(Int32Array::from(vec![None, Some(0), Some(2)]));
+        let b = DictionaryArray::new(keys, v2);
+
+        let r = eq_dyn(&a, &b).unwrap();
+        assert_eq!(r.null_count(), 2);
+        assert!(r.is_valid(2));
+    }
+}
diff --git a/arrow-ord/src/lib.rs b/arrow-ord/src/lib.rs
new file mode 100644
index 000000000000..8fe4ecbc05aa
--- /dev/null
+++ b/arrow-ord/src/lib.rs
@@ -0,0 +1,52 @@
+// 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.
+
+//! Arrow ordering kernels
+//!
+//! # Sort RecordBatch
+//!
+//! ```
+//! # use std::sync::Arc;
+//! # use arrow_array::*;
+//! # use arrow_array::cast::AsArray;
+//! # use arrow_array::types::Int32Type;
+//! # use arrow_ord::sort::sort_to_indices;
+//! # use arrow_select::take::take;
+//! #
+//! let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4]));
+//! let b: ArrayRef = Arc::new(StringArray::from(vec!["b", "a", "e", "d"]));
+//! let batch = RecordBatch::try_from_iter(vec![("a", a), ("b", b)]).unwrap();
+//!
+//! // Sort by column 1
+//! let indices = sort_to_indices(batch.column(1), None, None).unwrap();
+//!
+//! // Apply indices to batch columns
+//! let columns = batch.columns().iter().map(|c| take(&*c, &indices, None).unwrap()).collect();
+//! let sorted = RecordBatch::try_new(batch.schema(), columns).unwrap();
+//!
+//! let col1 = sorted.column(0).as_primitive::<Int32Type>();
+//! assert_eq!(col1.values(), &[2, 1, 4, 3]);
+//! ```
+//!
+
+pub mod cmp;
+#[doc(hidden)]
+pub mod comparison;
+pub mod ord;
+pub mod partition;
+pub mod rank;
+pub mod sort;
diff --git a/arrow-ord/src/ord.rs b/arrow-ord/src/ord.rs
new file mode 100644
index 000000000000..f6bd39c9cd5d
--- /dev/null
+++ b/arrow-ord/src/ord.rs
@@ -0,0 +1,502 @@
+// 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.
+
+//! Contains functions and function factories to compare arrays.
+
+use arrow_array::cast::AsArray;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::ArrowNativeType;
+use arrow_schema::ArrowError;
+use std::cmp::Ordering;
+
+/// Compare the values at two arbitrary indices in two arrays.
+pub type DynComparator = Box<dyn Fn(usize, usize) -> Ordering + Send + Sync>;
+
+fn compare_primitive<T: ArrowPrimitiveType>(left: &dyn Array, right: &dyn Array) -> DynComparator
+where
+    T::Native: ArrowNativeTypeOp,
+{
+    let left = left.as_primitive::<T>().clone();
+    let right = right.as_primitive::<T>().clone();
+    Box::new(move |i, j| left.value(i).compare(right.value(j)))
+}
+
+fn compare_boolean(left: &dyn Array, right: &dyn Array) -> DynComparator {
+    let left: BooleanArray = left.as_boolean().clone();
+    let right: BooleanArray = right.as_boolean().clone();
+
+    Box::new(move |i, j| left.value(i).cmp(&right.value(j)))
+}
+
+fn compare_bytes<T: ByteArrayType>(left: &dyn Array, right: &dyn Array) -> DynComparator {
+    let left = left.as_bytes::<T>().clone();
+    let right = right.as_bytes::<T>().clone();
+
+    Box::new(move |i, j| {
+        let l: &[u8] = left.value(i).as_ref();
+        let r: &[u8] = right.value(j).as_ref();
+        l.cmp(r)
+    })
+}
+
+fn compare_dict<K: ArrowDictionaryKeyType>(
+    left: &dyn Array,
+    right: &dyn Array,
+) -> Result<DynComparator, ArrowError> {
+    let left = left.as_dictionary::<K>();
+    let right = right.as_dictionary::<K>();
+
+    let cmp = build_compare(left.values().as_ref(), right.values().as_ref())?;
+    let left_keys = left.keys().clone();
+    let right_keys = right.keys().clone();
+
+    // TODO: Handle value nulls (#2687)
+    Ok(Box::new(move |i, j| {
+        let l = left_keys.value(i).as_usize();
+        let r = right_keys.value(j).as_usize();
+        cmp(l, r)
+    }))
+}
+
+/// returns a comparison function that compares two values at two different positions
+/// between the two arrays.
+/// The arrays' types must be equal.
+/// # Example
+/// ```
+/// use arrow_array::Int32Array;
+/// use arrow_ord::ord::build_compare;
+///
+/// let array1 = Int32Array::from(vec![1, 2]);
+/// let array2 = Int32Array::from(vec![3, 4]);
+///
+/// let cmp = build_compare(&array1, &array2).unwrap();
+///
+/// // 1 (index 0 of array1) is smaller than 4 (index 1 of array2)
+/// assert_eq!(std::cmp::Ordering::Less, cmp(0, 1));
+/// ```
+// This is a factory of comparisons.
+// The lifetime 'a enforces that we cannot use the closure beyond any of the array's lifetime.
+pub fn build_compare(left: &dyn Array, right: &dyn Array) -> Result<DynComparator, ArrowError> {
+    use arrow_schema::DataType::*;
+    macro_rules! primitive_helper {
+        ($t:ty, $left:expr, $right:expr) => {
+            Ok(compare_primitive::<$t>($left, $right))
+        };
+    }
+    downcast_primitive! {
+        left.data_type(), right.data_type() => (primitive_helper, left, right),
+        (Boolean, Boolean) => Ok(compare_boolean(left, right)),
+        (Utf8, Utf8) => Ok(compare_bytes::<Utf8Type>(left, right)),
+        (LargeUtf8, LargeUtf8) => Ok(compare_bytes::<LargeUtf8Type>(left, right)),
+        (Binary, Binary) => Ok(compare_bytes::<BinaryType>(left, right)),
+        (LargeBinary, LargeBinary) => Ok(compare_bytes::<LargeBinaryType>(left, right)),
+        (FixedSizeBinary(_), FixedSizeBinary(_)) => {
+            let left = left.as_fixed_size_binary().clone();
+            let right = right.as_fixed_size_binary().clone();
+            Ok(Box::new(move |i, j| left.value(i).cmp(right.value(j))))
+        },
+        (Dictionary(l_key, _), Dictionary(r_key, _)) => {
+             macro_rules! dict_helper {
+                ($t:ty, $left:expr, $right:expr) => {
+                     compare_dict::<$t>($left, $right)
+                 };
+             }
+            downcast_integer! {
+                 l_key.as_ref(), r_key.as_ref() => (dict_helper, left, right),
+                 _ => unreachable!()
+             }
+        },
+        (lhs, rhs) => Err(ArrowError::InvalidArgumentError(match lhs == rhs {
+            true => format!("The data type type {lhs:?} has no natural order"),
+            false => "Can't compare arrays of different types".to_string(),
+        }))
+    }
+}
+
+#[cfg(test)]
+pub mod tests {
+    use super::*;
+    use arrow_array::{FixedSizeBinaryArray, Float64Array, Int32Array};
+    use arrow_buffer::{i256, OffsetBuffer};
+    use half::f16;
+    use std::cmp::Ordering;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_fixed_size_binary() {
+        let items = vec![vec![1u8], vec![2u8]];
+        let array = FixedSizeBinaryArray::try_from_iter(items.into_iter()).unwrap();
+
+        let cmp = build_compare(&array, &array).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 1));
+    }
+
+    #[test]
+    fn test_fixed_size_binary_fixed_size_binary() {
+        let items = vec![vec![1u8]];
+        let array1 = FixedSizeBinaryArray::try_from_iter(items.into_iter()).unwrap();
+        let items = vec![vec![2u8]];
+        let array2 = FixedSizeBinaryArray::try_from_iter(items.into_iter()).unwrap();
+
+        let cmp = build_compare(&array1, &array2).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 0));
+    }
+
+    #[test]
+    fn test_i32() {
+        let array = Int32Array::from(vec![1, 2]);
+
+        let cmp = build_compare(&array, &array).unwrap();
+
+        assert_eq!(Ordering::Less, (cmp)(0, 1));
+    }
+
+    #[test]
+    fn test_i32_i32() {
+        let array1 = Int32Array::from(vec![1]);
+        let array2 = Int32Array::from(vec![2]);
+
+        let cmp = build_compare(&array1, &array2).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 0));
+    }
+
+    #[test]
+    fn test_f16() {
+        let array = Float16Array::from(vec![f16::from_f32(1.0), f16::from_f32(2.0)]);
+
+        let cmp = build_compare(&array, &array).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 1));
+    }
+
+    #[test]
+    fn test_f64() {
+        let array = Float64Array::from(vec![1.0, 2.0]);
+
+        let cmp = build_compare(&array, &array).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 1));
+    }
+
+    #[test]
+    fn test_f64_nan() {
+        let array = Float64Array::from(vec![1.0, f64::NAN]);
+
+        let cmp = build_compare(&array, &array).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 1));
+        assert_eq!(Ordering::Equal, cmp(1, 1));
+    }
+
+    #[test]
+    fn test_f64_zeros() {
+        let array = Float64Array::from(vec![-0.0, 0.0]);
+
+        let cmp = build_compare(&array, &array).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 1));
+        assert_eq!(Ordering::Greater, cmp(1, 0));
+    }
+
+    #[test]
+    fn test_interval_day_time() {
+        let array = IntervalDayTimeArray::from(vec![
+            // 0 days, 1 second
+            IntervalDayTimeType::make_value(0, 1000),
+            // 1 day, 2 milliseconds
+            IntervalDayTimeType::make_value(1, 2),
+            // 90M milliseconds (which is more than is in 1 day)
+            IntervalDayTimeType::make_value(0, 90_000_000),
+        ]);
+
+        let cmp = build_compare(&array, &array).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 1));
+        assert_eq!(Ordering::Greater, cmp(1, 0));
+
+        // somewhat confusingly, while 90M milliseconds is more than 1 day,
+        // it will compare less as the comparison is done on the underlying
+        // values not field by field
+        assert_eq!(Ordering::Greater, cmp(1, 2));
+        assert_eq!(Ordering::Less, cmp(2, 1));
+    }
+
+    #[test]
+    fn test_interval_year_month() {
+        let array = IntervalYearMonthArray::from(vec![
+            // 1 year, 0 months
+            IntervalYearMonthType::make_value(1, 0),
+            // 0 years, 13 months
+            IntervalYearMonthType::make_value(0, 13),
+            // 1 year, 1 month
+            IntervalYearMonthType::make_value(1, 1),
+        ]);
+
+        let cmp = build_compare(&array, &array).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 1));
+        assert_eq!(Ordering::Greater, cmp(1, 0));
+
+        // the underlying representation is months, so both quantities are the same
+        assert_eq!(Ordering::Equal, cmp(1, 2));
+        assert_eq!(Ordering::Equal, cmp(2, 1));
+    }
+
+    #[test]
+    fn test_interval_month_day_nano() {
+        let array = IntervalMonthDayNanoArray::from(vec![
+            // 100 days
+            IntervalMonthDayNanoType::make_value(0, 100, 0),
+            // 1 month
+            IntervalMonthDayNanoType::make_value(1, 0, 0),
+            // 100 day, 1 nanoseconds
+            IntervalMonthDayNanoType::make_value(0, 100, 2),
+        ]);
+
+        let cmp = build_compare(&array, &array).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 1));
+        assert_eq!(Ordering::Greater, cmp(1, 0));
+
+        // somewhat confusingly, while 100 days is more than 1 month in all cases
+        // it will compare less as the comparison is done on the underlying
+        // values not field by field
+        assert_eq!(Ordering::Greater, cmp(1, 2));
+        assert_eq!(Ordering::Less, cmp(2, 1));
+    }
+
+    #[test]
+    fn test_decimal() {
+        let array = vec![Some(5_i128), Some(2_i128), Some(3_i128)]
+            .into_iter()
+            .collect::<Decimal128Array>()
+            .with_precision_and_scale(23, 6)
+            .unwrap();
+
+        let cmp = build_compare(&array, &array).unwrap();
+        assert_eq!(Ordering::Less, cmp(1, 0));
+        assert_eq!(Ordering::Greater, cmp(0, 2));
+    }
+
+    #[test]
+    fn test_decimali256() {
+        let array = vec![
+            Some(i256::from_i128(5_i128)),
+            Some(i256::from_i128(2_i128)),
+            Some(i256::from_i128(3_i128)),
+        ]
+        .into_iter()
+        .collect::<Decimal256Array>()
+        .with_precision_and_scale(53, 6)
+        .unwrap();
+
+        let cmp = build_compare(&array, &array).unwrap();
+        assert_eq!(Ordering::Less, cmp(1, 0));
+        assert_eq!(Ordering::Greater, cmp(0, 2));
+    }
+
+    #[test]
+    fn test_dict() {
+        let data = vec!["a", "b", "c", "a", "a", "c", "c"];
+        let array = data.into_iter().collect::<DictionaryArray<Int16Type>>();
+
+        let cmp = build_compare(&array, &array).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 1));
+        assert_eq!(Ordering::Equal, cmp(3, 4));
+        assert_eq!(Ordering::Greater, cmp(2, 3));
+    }
+
+    #[test]
+    fn test_multiple_dict() {
+        let d1 = vec!["a", "b", "c", "d"];
+        let a1 = d1.into_iter().collect::<DictionaryArray<Int16Type>>();
+        let d2 = vec!["e", "f", "g", "a"];
+        let a2 = d2.into_iter().collect::<DictionaryArray<Int16Type>>();
+
+        let cmp = build_compare(&a1, &a2).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 0));
+        assert_eq!(Ordering::Equal, cmp(0, 3));
+        assert_eq!(Ordering::Greater, cmp(1, 3));
+    }
+
+    #[test]
+    fn test_primitive_dict() {
+        let values = Int32Array::from(vec![1_i32, 0, 2, 5]);
+        let keys = Int8Array::from_iter_values([0, 0, 1, 3]);
+        let array1 = DictionaryArray::new(keys, Arc::new(values));
+
+        let values = Int32Array::from(vec![2_i32, 3, 4, 5]);
+        let keys = Int8Array::from_iter_values([0, 1, 1, 3]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let cmp = build_compare(&array1, &array2).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 0));
+        assert_eq!(Ordering::Less, cmp(0, 3));
+        assert_eq!(Ordering::Equal, cmp(3, 3));
+        assert_eq!(Ordering::Greater, cmp(3, 1));
+        assert_eq!(Ordering::Greater, cmp(3, 2));
+    }
+
+    #[test]
+    fn test_float_dict() {
+        let values = Float32Array::from(vec![1.0, 0.5, 2.1, 5.5]);
+        let keys = Int8Array::from_iter_values([0, 0, 1, 3]);
+        let array1 = DictionaryArray::try_new(keys, Arc::new(values)).unwrap();
+
+        let values = Float32Array::from(vec![1.2, 3.2, 4.0, 5.5]);
+        let keys = Int8Array::from_iter_values([0, 1, 1, 3]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let cmp = build_compare(&array1, &array2).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 0));
+        assert_eq!(Ordering::Less, cmp(0, 3));
+        assert_eq!(Ordering::Equal, cmp(3, 3));
+        assert_eq!(Ordering::Greater, cmp(3, 1));
+        assert_eq!(Ordering::Greater, cmp(3, 2));
+    }
+
+    #[test]
+    fn test_timestamp_dict() {
+        let values = TimestampSecondArray::from(vec![1, 0, 2, 5]);
+        let keys = Int8Array::from_iter_values([0, 0, 1, 3]);
+        let array1 = DictionaryArray::new(keys, Arc::new(values));
+
+        let values = TimestampSecondArray::from(vec![2, 3, 4, 5]);
+        let keys = Int8Array::from_iter_values([0, 1, 1, 3]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let cmp = build_compare(&array1, &array2).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 0));
+        assert_eq!(Ordering::Less, cmp(0, 3));
+        assert_eq!(Ordering::Equal, cmp(3, 3));
+        assert_eq!(Ordering::Greater, cmp(3, 1));
+        assert_eq!(Ordering::Greater, cmp(3, 2));
+    }
+
+    #[test]
+    fn test_interval_dict() {
+        let values = IntervalDayTimeArray::from(vec![1, 0, 2, 5]);
+        let keys = Int8Array::from_iter_values([0, 0, 1, 3]);
+        let array1 = DictionaryArray::new(keys, Arc::new(values));
+
+        let values = IntervalDayTimeArray::from(vec![2, 3, 4, 5]);
+        let keys = Int8Array::from_iter_values([0, 1, 1, 3]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let cmp = build_compare(&array1, &array2).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 0));
+        assert_eq!(Ordering::Less, cmp(0, 3));
+        assert_eq!(Ordering::Equal, cmp(3, 3));
+        assert_eq!(Ordering::Greater, cmp(3, 1));
+        assert_eq!(Ordering::Greater, cmp(3, 2));
+    }
+
+    #[test]
+    fn test_duration_dict() {
+        let values = DurationSecondArray::from(vec![1, 0, 2, 5]);
+        let keys = Int8Array::from_iter_values([0, 0, 1, 3]);
+        let array1 = DictionaryArray::new(keys, Arc::new(values));
+
+        let values = DurationSecondArray::from(vec![2, 3, 4, 5]);
+        let keys = Int8Array::from_iter_values([0, 1, 1, 3]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let cmp = build_compare(&array1, &array2).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 0));
+        assert_eq!(Ordering::Less, cmp(0, 3));
+        assert_eq!(Ordering::Equal, cmp(3, 3));
+        assert_eq!(Ordering::Greater, cmp(3, 1));
+        assert_eq!(Ordering::Greater, cmp(3, 2));
+    }
+
+    #[test]
+    fn test_decimal_dict() {
+        let values = Decimal128Array::from(vec![1, 0, 2, 5]);
+        let keys = Int8Array::from_iter_values([0, 0, 1, 3]);
+        let array1 = DictionaryArray::new(keys, Arc::new(values));
+
+        let values = Decimal128Array::from(vec![2, 3, 4, 5]);
+        let keys = Int8Array::from_iter_values([0, 1, 1, 3]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let cmp = build_compare(&array1, &array2).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 0));
+        assert_eq!(Ordering::Less, cmp(0, 3));
+        assert_eq!(Ordering::Equal, cmp(3, 3));
+        assert_eq!(Ordering::Greater, cmp(3, 1));
+        assert_eq!(Ordering::Greater, cmp(3, 2));
+    }
+
+    #[test]
+    fn test_decimal256_dict() {
+        let values = Decimal256Array::from(vec![
+            i256::from_i128(1),
+            i256::from_i128(0),
+            i256::from_i128(2),
+            i256::from_i128(5),
+        ]);
+        let keys = Int8Array::from_iter_values([0, 0, 1, 3]);
+        let array1 = DictionaryArray::new(keys, Arc::new(values));
+
+        let values = Decimal256Array::from(vec![
+            i256::from_i128(2),
+            i256::from_i128(3),
+            i256::from_i128(4),
+            i256::from_i128(5),
+        ]);
+        let keys = Int8Array::from_iter_values([0, 1, 1, 3]);
+        let array2 = DictionaryArray::new(keys, Arc::new(values));
+
+        let cmp = build_compare(&array1, &array2).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 0));
+        assert_eq!(Ordering::Less, cmp(0, 3));
+        assert_eq!(Ordering::Equal, cmp(3, 3));
+        assert_eq!(Ordering::Greater, cmp(3, 1));
+        assert_eq!(Ordering::Greater, cmp(3, 2));
+    }
+
+    fn test_bytes_impl<T: ByteArrayType>() {
+        let offsets = OffsetBuffer::from_lengths([3, 3, 1]);
+        let a = GenericByteArray::<T>::new(offsets, b"abcdefa".into(), None);
+        let cmp = build_compare(&a, &a).unwrap();
+
+        assert_eq!(Ordering::Less, cmp(0, 1));
+        assert_eq!(Ordering::Greater, cmp(0, 2));
+        assert_eq!(Ordering::Equal, cmp(1, 1));
+    }
+
+    #[test]
+    fn test_bytes() {
+        test_bytes_impl::<Utf8Type>();
+        test_bytes_impl::<LargeUtf8Type>();
+        test_bytes_impl::<BinaryType>();
+        test_bytes_impl::<LargeBinaryType>();
+    }
+}
diff --git a/arrow-ord/src/partition.rs b/arrow-ord/src/partition.rs
new file mode 100644
index 000000000000..8c87eefadbf0
--- /dev/null
+++ b/arrow-ord/src/partition.rs
@@ -0,0 +1,317 @@
+// 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.
+
+//! Defines partition kernel for `ArrayRef`
+
+use std::ops::Range;
+
+use arrow_array::{Array, ArrayRef};
+use arrow_buffer::BooleanBuffer;
+use arrow_schema::ArrowError;
+
+use crate::cmp::distinct;
+use crate::sort::SortColumn;
+
+/// A computed set of partitions, see [`partition`]
+#[derive(Debug, Clone)]
+pub struct Partitions(Option<BooleanBuffer>);
+
+impl Partitions {
+    /// Returns the range of each partition
+    ///
+    /// Consecutive ranges will be contiguous: i.e [`(a, b)` and `(b, c)`], and
+    /// `start = 0` and `end = self.len()` for the first and last range respectively
+    pub fn ranges(&self) -> Vec<Range<usize>> {
+        let boundaries = match &self.0 {
+            Some(boundaries) => boundaries,
+            None => return vec![],
+        };
+
+        let mut out = vec![];
+        let mut current = 0;
+        for idx in boundaries.set_indices() {
+            let t = current;
+            current = idx + 1;
+            out.push(t..current)
+        }
+        let last = boundaries.len() + 1;
+        if current != last {
+            out.push(current..last)
+        }
+        out
+    }
+
+    /// Returns the number of partitions
+    pub fn len(&self) -> usize {
+        match &self.0 {
+            Some(b) => b.count_set_bits() + 1,
+            None => 0,
+        }
+    }
+
+    /// Returns true if this contains no partitions
+    pub fn is_empty(&self) -> bool {
+        self.0.is_none()
+    }
+}
+
+/// Given a list of lexicographically sorted columns, computes the [`Partitions`],
+/// where a partition consists of the set of consecutive rows with equal values
+///
+/// Returns an error if no columns are specified or all columns do not
+/// have the same number of rows.
+///
+/// # Example:
+///
+/// For example, given columns `x`, `y` and `z`, calling
+/// [`partition`]`(values, (x, y))` will divide the
+/// rows into ranges where the values of `(x, y)` are equal:
+///
+/// ```text
+/// ┌ ─ ┬───┬ ─ ─┌───┐─ ─ ┬───┬ ─ ─ ┐
+///     │ 1 │    │ 1 │    │ A │        Range: 0..1 (x=1, y=1)
+/// ├ ─ ┼───┼ ─ ─├───┤─ ─ ┼───┼ ─ ─ ┤
+///     │ 1 │    │ 2 │    │ B │
+/// │   ├───┤    ├───┤    ├───┤     │
+///     │ 1 │    │ 2 │    │ C │        Range: 1..4 (x=1, y=2)
+/// │   ├───┤    ├───┤    ├───┤     │
+///     │ 1 │    │ 2 │    │ D │
+/// ├ ─ ┼───┼ ─ ─├───┤─ ─ ┼───┼ ─ ─ ┤
+///     │ 2 │    │ 1 │    │ E │        Range: 4..5 (x=2, y=1)
+/// ├ ─ ┼───┼ ─ ─├───┤─ ─ ┼───┼ ─ ─ ┤
+///     │ 3 │    │ 1 │    │ F │        Range: 5..6 (x=3, y=1)
+/// └ ─ ┴───┴ ─ ─└───┘─ ─ ┴───┴ ─ ─ ┘
+///
+///       x        y        z     partition(&[x, y])
+/// ```
+///
+/// # Example Code
+///
+/// ```
+/// # use std::{sync::Arc, ops::Range};
+/// # use arrow_array::{RecordBatch, Int64Array, StringArray, ArrayRef};
+/// # use arrow_ord::sort::{SortColumn, SortOptions};
+/// # use arrow_ord::partition::partition;
+/// let batch = RecordBatch::try_from_iter(vec![
+///     ("x", Arc::new(Int64Array::from(vec![1, 1, 1, 1, 2, 3])) as ArrayRef),
+///     ("y", Arc::new(Int64Array::from(vec![1, 2, 2, 2, 1, 1])) as ArrayRef),
+///     ("z", Arc::new(StringArray::from(vec!["A", "B", "C", "D", "E", "F"])) as ArrayRef),
+/// ]).unwrap();
+///
+/// // Partition on first two columns
+/// let ranges = partition(&batch.columns()[..2]).unwrap().ranges();
+///
+/// let expected = vec![
+///     (0..1),
+///     (1..4),
+///     (4..5),
+///     (5..6),
+/// ];
+///
+/// assert_eq!(ranges, expected);
+/// ```
+pub fn partition(columns: &[ArrayRef]) -> Result<Partitions, ArrowError> {
+    if columns.is_empty() {
+        return Err(ArrowError::InvalidArgumentError(
+            "Partition requires at least one column".to_string(),
+        ));
+    }
+    let num_rows = columns[0].len();
+    if columns.iter().any(|item| item.len() != num_rows) {
+        return Err(ArrowError::InvalidArgumentError(
+            "Partition columns have different row counts".to_string(),
+        ));
+    };
+
+    match num_rows {
+        0 => return Ok(Partitions(None)),
+        1 => return Ok(Partitions(Some(BooleanBuffer::new_unset(0)))),
+        _ => {}
+    }
+
+    let acc = find_boundaries(&columns[0])?;
+    let acc = columns
+        .iter()
+        .skip(1)
+        .try_fold(acc, |acc, c| find_boundaries(c.as_ref()).map(|b| &acc | &b))?;
+
+    Ok(Partitions(Some(acc)))
+}
+
+/// Returns a mask with bits set whenever the value or nullability changes
+fn find_boundaries(v: &dyn Array) -> Result<BooleanBuffer, ArrowError> {
+    let slice_len = v.len() - 1;
+    let v1 = v.slice(0, slice_len);
+    let v2 = v.slice(1, slice_len);
+    Ok(distinct(&v1, &v2)?.values().clone())
+}
+
+/// Use [`partition`] instead. Given a list of already sorted columns, find
+/// partition ranges that would partition lexicographically equal values across
+/// columns.
+///
+/// The returned vec would be of size k where k is cardinality of the sorted values; Consecutive
+/// values will be connected: (a, b) and (b, c), where start = 0 and end = n for the first and last
+/// range.
+#[deprecated(note = "Use partition")]
+pub fn lexicographical_partition_ranges(
+    columns: &[SortColumn],
+) -> Result<impl Iterator<Item = Range<usize>> + '_, ArrowError> {
+    let cols: Vec<_> = columns.iter().map(|x| x.values.clone()).collect();
+    Ok(partition(&cols)?.ranges().into_iter())
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use arrow_array::*;
+    use arrow_schema::DataType;
+
+    use super::*;
+
+    #[test]
+    fn test_partition_empty() {
+        let err = partition(&[]).unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Partition requires at least one column"
+        );
+    }
+
+    #[test]
+    fn test_partition_unaligned_rows() {
+        let input = vec![
+            Arc::new(Int64Array::from(vec![None, Some(-1)])) as _,
+            Arc::new(StringArray::from(vec![Some("foo")])) as _,
+        ];
+        let err = partition(&input).unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Invalid argument error: Partition columns have different row counts"
+        )
+    }
+
+    #[test]
+    fn test_partition_small() {
+        let results = partition(&[
+            Arc::new(Int32Array::new(vec![].into(), None)) as _,
+            Arc::new(Int32Array::new(vec![].into(), None)) as _,
+            Arc::new(Int32Array::new(vec![].into(), None)) as _,
+        ])
+        .unwrap();
+        assert_eq!(results.len(), 0);
+        assert!(results.is_empty());
+
+        let results = partition(&[
+            Arc::new(Int32Array::from(vec![1])) as _,
+            Arc::new(Int32Array::from(vec![1])) as _,
+        ])
+        .unwrap()
+        .ranges();
+        assert_eq!(results.len(), 1);
+        assert_eq!(results[0], 0..1);
+    }
+
+    #[test]
+    fn test_partition_single_column() {
+        let a = Int64Array::from(vec![1, 2, 2, 2, 2, 2, 2, 2, 9]);
+        let input = vec![Arc::new(a) as _];
+        assert_eq!(
+            partition(&input).unwrap().ranges(),
+            vec![(0..1), (1..8), (8..9)],
+        );
+    }
+
+    #[test]
+    fn test_partition_all_equal_values() {
+        let a = Int64Array::from_value(1, 1000);
+        let input = vec![Arc::new(a) as _];
+        assert_eq!(partition(&input).unwrap().ranges(), vec![(0..1000)]);
+    }
+
+    #[test]
+    fn test_partition_all_null_values() {
+        let input = vec![
+            new_null_array(&DataType::Int8, 1000),
+            new_null_array(&DataType::UInt16, 1000),
+        ];
+        assert_eq!(partition(&input).unwrap().ranges(), vec![(0..1000)]);
+    }
+
+    #[test]
+    fn test_partition_unique_column_1() {
+        let input = vec![
+            Arc::new(Int64Array::from(vec![None, Some(-1)])) as _,
+            Arc::new(StringArray::from(vec![Some("foo"), Some("bar")])) as _,
+        ];
+        assert_eq!(partition(&input).unwrap().ranges(), vec![(0..1), (1..2)],);
+    }
+
+    #[test]
+    fn test_partition_unique_column_2() {
+        let input = vec![
+            Arc::new(Int64Array::from(vec![None, Some(-1), Some(-1)])) as _,
+            Arc::new(StringArray::from(vec![
+                Some("foo"),
+                Some("bar"),
+                Some("apple"),
+            ])) as _,
+        ];
+        assert_eq!(
+            partition(&input).unwrap().ranges(),
+            vec![(0..1), (1..2), (2..3),],
+        );
+    }
+
+    #[test]
+    fn test_partition_non_unique_column_1() {
+        let input = vec![
+            Arc::new(Int64Array::from(vec![None, Some(-1), Some(-1), Some(1)])) as _,
+            Arc::new(StringArray::from(vec![
+                Some("foo"),
+                Some("bar"),
+                Some("bar"),
+                Some("bar"),
+            ])) as _,
+        ];
+        assert_eq!(
+            partition(&input).unwrap().ranges(),
+            vec![(0..1), (1..3), (3..4),],
+        );
+    }
+
+    #[test]
+    fn test_partition_masked_nulls() {
+        let input = vec![
+            Arc::new(Int64Array::new(vec![1; 9].into(), None)) as _,
+            Arc::new(Int64Array::new(
+                vec![1, 1, 2, 2, 2, 3, 3, 3, 3].into(),
+                Some(vec![false, true, true, true, true, false, false, true, false].into()),
+            )) as _,
+            Arc::new(Int64Array::new(
+                vec![1, 1, 2, 2, 2, 2, 2, 3, 7].into(),
+                Some(vec![true, true, true, true, false, true, true, true, false].into()),
+            )) as _,
+        ];
+
+        assert_eq!(
+            partition(&input).unwrap().ranges(),
+            vec![(0..1), (1..2), (2..4), (4..5), (5..7), (7..8), (8..9)],
+        );
+    }
+}
diff --git a/arrow-ord/src/rank.rs b/arrow-ord/src/rank.rs
new file mode 100644
index 000000000000..51b0b5b91ba9
--- /dev/null
+++ b/arrow-ord/src/rank.rs
@@ -0,0 +1,189 @@
+// 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.
+
+use arrow_array::cast::AsArray;
+use arrow_array::types::*;
+use arrow_array::{downcast_primitive_array, Array, ArrowNativeTypeOp, GenericByteArray};
+use arrow_buffer::NullBuffer;
+use arrow_schema::{ArrowError, DataType, SortOptions};
+use std::cmp::Ordering;
+
+/// Assigns a rank to each value in `array` based on its position in the sorted order
+///
+/// Where values are equal, they will be assigned the highest of their ranks,
+/// leaving gaps in the overall rank assignment
+///
+/// ```
+/// # use arrow_array::StringArray;
+/// # use arrow_ord::rank::rank;
+/// let array = StringArray::from(vec![Some("foo"), None, Some("foo"), None, Some("bar")]);
+/// let ranks = rank(&array, None).unwrap();
+/// assert_eq!(ranks, &[5, 2, 5, 2, 3]);
+/// ```
+pub fn rank(array: &dyn Array, options: Option<SortOptions>) -> Result<Vec<u32>, ArrowError> {
+    let options = options.unwrap_or_default();
+    let ranks = downcast_primitive_array! {
+        array => primitive_rank(array.values(), array.nulls(), options),
+        DataType::Utf8 => bytes_rank(array.as_bytes::<Utf8Type>(), options),
+        DataType::LargeUtf8 => bytes_rank(array.as_bytes::<LargeUtf8Type>(), options),
+        DataType::Binary => bytes_rank(array.as_bytes::<BinaryType>(), options),
+        DataType::LargeBinary => bytes_rank(array.as_bytes::<LargeBinaryType>(), options),
+        d => return Err(ArrowError::ComputeError(format!("{d:?} not supported in rank")))
+    };
+    Ok(ranks)
+}
+
+#[inline(never)]
+fn primitive_rank<T: ArrowNativeTypeOp>(
+    values: &[T],
+    nulls: Option<&NullBuffer>,
+    options: SortOptions,
+) -> Vec<u32> {
+    let len: u32 = values.len().try_into().unwrap();
+    let to_sort = match nulls.filter(|n| n.null_count() > 0) {
+        Some(n) => n
+            .valid_indices()
+            .map(|idx| (values[idx], idx as u32))
+            .collect(),
+        None => values.iter().copied().zip(0..len).collect(),
+    };
+    rank_impl(values.len(), to_sort, options, T::compare, T::is_eq)
+}
+
+#[inline(never)]
+fn bytes_rank<T: ByteArrayType>(array: &GenericByteArray<T>, options: SortOptions) -> Vec<u32> {
+    let to_sort: Vec<(&[u8], u32)> = match array.nulls().filter(|n| n.null_count() > 0) {
+        Some(n) => n
+            .valid_indices()
+            .map(|idx| (array.value(idx).as_ref(), idx as u32))
+            .collect(),
+        None => (0..array.len())
+            .map(|idx| (array.value(idx).as_ref(), idx as u32))
+            .collect(),
+    };
+    rank_impl(array.len(), to_sort, options, Ord::cmp, PartialEq::eq)
+}
+
+fn rank_impl<T, C, E>(
+    len: usize,
+    mut valid: Vec<(T, u32)>,
+    options: SortOptions,
+    compare: C,
+    eq: E,
+) -> Vec<u32>
+where
+    T: Copy,
+    C: Fn(T, T) -> Ordering,
+    E: Fn(T, T) -> bool,
+{
+    // We can use an unstable sort as we combine equal values later
+    valid.sort_unstable_by(|a, b| compare(a.0, b.0));
+    if options.descending {
+        valid.reverse();
+    }
+
+    let (mut valid_rank, null_rank) = match options.nulls_first {
+        true => (len as u32, (len - valid.len()) as u32),
+        false => (valid.len() as u32, len as u32),
+    };
+
+    let mut out: Vec<_> = vec![null_rank; len];
+    if let Some(v) = valid.last() {
+        out[v.1 as usize] = valid_rank;
+    }
+
+    let mut count = 1; // Number of values in rank
+    for w in valid.windows(2).rev() {
+        match eq(w[0].0, w[1].0) {
+            true => {
+                count += 1;
+                out[w[0].1 as usize] = valid_rank;
+            }
+            false => {
+                valid_rank -= count;
+                count = 1;
+                out[w[0].1 as usize] = valid_rank
+            }
+        }
+    }
+
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::*;
+
+    #[test]
+    fn test_primitive() {
+        let descending = SortOptions {
+            descending: true,
+            nulls_first: true,
+        };
+
+        let nulls_last = SortOptions {
+            descending: false,
+            nulls_first: false,
+        };
+
+        let nulls_last_descending = SortOptions {
+            descending: true,
+            nulls_first: false,
+        };
+
+        let a = Int32Array::from(vec![Some(1), Some(1), None, Some(3), Some(3), Some(4)]);
+        let res = rank(&a, None).unwrap();
+        assert_eq!(res, &[3, 3, 1, 5, 5, 6]);
+
+        let res = rank(&a, Some(descending)).unwrap();
+        assert_eq!(res, &[6, 6, 1, 4, 4, 2]);
+
+        let res = rank(&a, Some(nulls_last)).unwrap();
+        assert_eq!(res, &[2, 2, 6, 4, 4, 5]);
+
+        let res = rank(&a, Some(nulls_last_descending)).unwrap();
+        assert_eq!(res, &[5, 5, 6, 3, 3, 1]);
+
+        // Test with non-zero null values
+        let nulls = NullBuffer::from(vec![true, true, false, true, false, false]);
+        let a = Int32Array::new(vec![1, 4, 3, 4, 5, 5].into(), Some(nulls));
+        let res = rank(&a, None).unwrap();
+        assert_eq!(res, &[4, 6, 3, 6, 3, 3]);
+    }
+
+    #[test]
+    fn test_bytes() {
+        let v = vec!["foo", "fo", "bar", "bar"];
+        let values = StringArray::from(v.clone());
+        let res = rank(&values, None).unwrap();
+        assert_eq!(res, &[4, 3, 2, 2]);
+
+        let values = LargeStringArray::from(v.clone());
+        let res = rank(&values, None).unwrap();
+        assert_eq!(res, &[4, 3, 2, 2]);
+
+        let v: Vec<&[u8]> = vec![&[1, 2], &[0], &[1, 2, 3], &[1, 2]];
+        let values = LargeBinaryArray::from(v.clone());
+        let res = rank(&values, None).unwrap();
+        assert_eq!(res, &[3, 1, 4, 3]);
+
+        let values = BinaryArray::from(v);
+        let res = rank(&values, None).unwrap();
+        assert_eq!(res, &[3, 1, 4, 3]);
+    }
+}
diff --git a/arrow/src/compute/kernels/sort.rs b/arrow-ord/src/sort.rs
similarity index 56%
rename from arrow/src/compute/kernels/sort.rs
rename to arrow-ord/src/sort.rs
index dca09a66a8cf..c25df3a480b3 100644
--- a/arrow/src/compute/kernels/sort.rs
+++ b/arrow-ord/src/sort.rs
@@ -17,13 +17,21 @@
 
 //! Defines sort kernel for `ArrayRef`
 
-use crate::array::*;
-use crate::buffer::MutableBuffer;
-use crate::compute::take;
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
+use crate::ord::{build_compare, DynComparator};
+use arrow_array::builder::BufferBuilder;
+use arrow_array::cast::*;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::BooleanBufferBuilder;
+use arrow_buffer::{ArrowNativeType, NullBuffer};
+use arrow_data::ArrayDataBuilder;
+use arrow_schema::{ArrowError, DataType};
+use arrow_select::take::take;
 use std::cmp::Ordering;
-use TimeUnit::*;
+use std::sync::Arc;
+
+use crate::rank::rank;
+pub use arrow_schema::SortOptions;
 
 /// Sort the `ArrayRef` using `SortOptions`.
 ///
@@ -40,20 +48,81 @@ use TimeUnit::*;
 /// # Example
 /// ```rust
 /// # use std::sync::Arc;
-/// # use arrow::array::{Int32Array, ArrayRef};
-/// # use arrow::error::Result;
-/// # use arrow::compute::kernels::sort::sort;
-/// # fn main() -> Result<()> {
-/// let array: ArrayRef = Arc::new(Int32Array::from(vec![5, 4, 3, 2, 1]));
+/// # use arrow_array::Int32Array;
+/// # use arrow_ord::sort::sort;
+/// let array = Int32Array::from(vec![5, 4, 3, 2, 1]);
 /// let sorted_array = sort(&array, None).unwrap();
-/// let sorted_array = sorted_array.as_any().downcast_ref::<Int32Array>().unwrap();
-/// assert_eq!(sorted_array, &Int32Array::from(vec![1, 2, 3, 4, 5]));
-/// # Ok(())
-/// # }
+/// assert_eq!(sorted_array.as_ref(), &Int32Array::from(vec![1, 2, 3, 4, 5]));
 /// ```
-pub fn sort(values: &ArrayRef, options: Option<SortOptions>) -> Result<ArrayRef> {
-    let indices = sort_to_indices(values, options, None)?;
-    take(values.as_ref(), &indices, None)
+pub fn sort(values: &dyn Array, options: Option<SortOptions>) -> Result<ArrayRef, ArrowError> {
+    downcast_primitive_array!(
+        values => sort_native_type(values, options),
+        DataType::RunEndEncoded(_, _) => sort_run(values, options, None),
+        _ => {
+            let indices = sort_to_indices(values, options, None)?;
+            take(values, &indices, None)
+        }
+    )
+}
+
+fn sort_native_type<T>(
+    primitive_values: &PrimitiveArray<T>,
+    options: Option<SortOptions>,
+) -> Result<ArrayRef, ArrowError>
+where
+    T: ArrowPrimitiveType,
+{
+    let sort_options = options.unwrap_or_default();
+
+    let mut mutable_buffer = vec![T::default_value(); primitive_values.len()];
+    let mutable_slice = &mut mutable_buffer;
+
+    let input_values = primitive_values.values().as_ref();
+
+    let nulls_count = primitive_values.null_count();
+    let valid_count = primitive_values.len() - nulls_count;
+
+    let null_bit_buffer = match nulls_count > 0 {
+        true => {
+            let mut validity_buffer = BooleanBufferBuilder::new(primitive_values.len());
+            if sort_options.nulls_first {
+                validity_buffer.append_n(nulls_count, false);
+                validity_buffer.append_n(valid_count, true);
+            } else {
+                validity_buffer.append_n(valid_count, true);
+                validity_buffer.append_n(nulls_count, false);
+            }
+            Some(validity_buffer.finish().into())
+        }
+        false => None,
+    };
+
+    if let Some(nulls) = primitive_values.nulls().filter(|n| n.null_count() > 0) {
+        let values_slice = match sort_options.nulls_first {
+            true => &mut mutable_slice[nulls_count..],
+            false => &mut mutable_slice[..valid_count],
+        };
+
+        for (write_index, index) in nulls.valid_indices().enumerate() {
+            values_slice[write_index] = primitive_values.value(index);
+        }
+
+        values_slice.sort_unstable_by(|a, b| a.compare(*b));
+        if sort_options.descending {
+            values_slice.reverse();
+        }
+    } else {
+        mutable_slice.copy_from_slice(input_values);
+        mutable_slice.sort_unstable_by(|a, b| a.compare(*b));
+        if sort_options.descending {
+            mutable_slice.reverse();
+        }
+    }
+
+    Ok(Arc::new(
+        PrimitiveArray::<T>::new(mutable_buffer.into(), null_bit_buffer)
+            .with_data_type(primitive_values.data_type().clone()),
+    ))
 }
 
 /// Sort the `ArrayRef` partially.
@@ -68,16 +137,13 @@ pub fn sort(values: &ArrayRef, options: Option<SortOptions>) -> Result<ArrayRef>
 /// # Example
 /// ```rust
 /// # use std::sync::Arc;
-/// # use arrow::array::{Int32Array, ArrayRef};
-/// # use arrow::error::Result;
-/// # use arrow::compute::kernels::sort::{sort_limit, SortOptions};
-/// # fn main() -> Result<()> {
-/// let array: ArrayRef = Arc::new(Int32Array::from(vec![5, 4, 3, 2, 1]));
+/// # use arrow_array::Int32Array;
+/// # use arrow_ord::sort::{sort_limit, SortOptions};
+/// let array = Int32Array::from(vec![5, 4, 3, 2, 1]);
 ///
 /// // Find the the top 2 items
 /// let sorted_array = sort_limit(&array, None, Some(2)).unwrap();
-/// let sorted_array = sorted_array.as_any().downcast_ref::<Int32Array>().unwrap();
-/// assert_eq!(sorted_array, &Int32Array::from(vec![1, 2]));
+/// assert_eq!(sorted_array.as_ref(), &Int32Array::from(vec![1, 2]));
 ///
 /// // Find the bottom top 2 items
 /// let options = Some(SortOptions {
@@ -85,18 +151,18 @@ pub fn sort(values: &ArrayRef, options: Option<SortOptions>) -> Result<ArrayRef>
 ///                  ..Default::default()
 ///               });
 /// let sorted_array = sort_limit(&array, options, Some(2)).unwrap();
-/// let sorted_array = sorted_array.as_any().downcast_ref::<Int32Array>().unwrap();
-/// assert_eq!(sorted_array, &Int32Array::from(vec![5, 4]));
-/// # Ok(())
-/// # }
+/// assert_eq!(sorted_array.as_ref(), &Int32Array::from(vec![5, 4]));
 /// ```
 pub fn sort_limit(
-    values: &ArrayRef,
+    values: &dyn Array,
     options: Option<SortOptions>,
     limit: Option<usize>,
-) -> Result<ArrayRef> {
+) -> Result<ArrayRef, ArrowError> {
+    if let DataType::RunEndEncoded(_, _) = values.data_type() {
+        return sort_run(values, options, limit);
+    }
     let indices = sort_to_indices(values, options, limit)?;
-    take(values.as_ref(), &indices, None)
+    take(values, &indices, None)
 }
 
 /// we can only do this if the T is primitive
@@ -112,15 +178,8 @@ where
     }
 }
 
-fn cmp<T>(l: T, r: T) -> std::cmp::Ordering
-where
-    T: Ord,
-{
-    l.cmp(&r)
-}
-
 // partition indices into valid and null indices
-fn partition_validity(array: &ArrayRef) -> (Vec<u32>, Vec<u32>) {
+fn partition_validity(array: &dyn Array) -> (Vec<u32>, Vec<u32>) {
     match array.null_count() {
         // faster path
         0 => ((0..(array.len() as u32)).collect(), vec![]),
@@ -132,691 +191,396 @@ fn partition_validity(array: &ArrayRef) -> (Vec<u32>, Vec<u32>) {
 }
 
 /// Sort elements from `ArrayRef` into an unsigned integer (`UInt32Array`) of indices.
-/// For floating point arrays any NaN values are considered to be greater than any other non-null value
-/// limit is an option for partial_sort
+/// Floats are sorted using IEEE 754 totalOrder.  `limit` is an option for [partial_sort].
 pub fn sort_to_indices(
-    values: &ArrayRef,
+    array: &dyn Array,
     options: Option<SortOptions>,
     limit: Option<usize>,
-) -> Result<UInt32Array> {
+) -> Result<UInt32Array, ArrowError> {
     let options = options.unwrap_or_default();
 
-    let (v, n) = partition_validity(values);
-
-    Ok(match values.data_type() {
-        DataType::Decimal128(_, _) => sort_decimal(values, v, n, cmp, &options, limit),
-        DataType::Boolean => sort_boolean(values, v, n, &options, limit),
-        DataType::Int8 => {
-            sort_primitive::<Int8Type, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Int16 => {
-            sort_primitive::<Int16Type, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Int32 => {
-            sort_primitive::<Int32Type, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Int64 => {
-            sort_primitive::<Int64Type, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::UInt8 => {
-            sort_primitive::<UInt8Type, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::UInt16 => {
-            sort_primitive::<UInt16Type, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::UInt32 => {
-            sort_primitive::<UInt32Type, _>(values, v, n, cmp, &options, limit)
+    let (v, n) = partition_validity(array);
+
+    Ok(downcast_primitive_array! {
+        array => sort_primitive(array, v, n, options, limit),
+        DataType::Boolean => sort_boolean(array.as_boolean(), v, n, options, limit),
+        DataType::Utf8 => sort_bytes(array.as_string::<i32>(), v, n, options, limit),
+        DataType::LargeUtf8 => sort_bytes(array.as_string::<i64>(), v, n, options, limit),
+        DataType::Binary => sort_bytes(array.as_binary::<i32>(), v, n, options, limit),
+        DataType::LargeBinary => sort_bytes(array.as_binary::<i64>(), v, n, options, limit),
+        DataType::FixedSizeBinary(_) => sort_fixed_size_binary(array.as_fixed_size_binary(), v, n, options, limit),
+        DataType::List(_) => sort_list(array.as_list::<i32>(), v, n, options, limit)?,
+        DataType::LargeList(_) => sort_list(array.as_list::<i64>(), v, n, options, limit)?,
+        DataType::FixedSizeList(_, _) => sort_fixed_size_list(array.as_fixed_size_list(), v, n, options, limit)?,
+        DataType::Dictionary(_, _) => downcast_dictionary_array!{
+            array => sort_dictionary(array, v, n, options, limit)?,
+            _ => unreachable!()
         }
-        DataType::UInt64 => {
-            sort_primitive::<UInt64Type, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Float32 => sort_primitive::<Float32Type, _>(
-            values,
-            v,
-            n,
-            |x, y| x.total_cmp(&y),
-            &options,
-            limit,
-        ),
-        DataType::Float64 => sort_primitive::<Float64Type, _>(
-            values,
-            v,
-            n,
-            |x, y| x.total_cmp(&y),
-            &options,
-            limit,
-        ),
-        DataType::Date32 => {
-            sort_primitive::<Date32Type, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Date64 => {
-            sort_primitive::<Date64Type, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Time32(Second) => {
-            sort_primitive::<Time32SecondType, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Time32(Millisecond) => {
-            sort_primitive::<Time32MillisecondType, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Time64(Microsecond) => {
-            sort_primitive::<Time64MicrosecondType, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Time64(Nanosecond) => {
-            sort_primitive::<Time64NanosecondType, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Timestamp(Second, _) => {
-            sort_primitive::<TimestampSecondType, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Timestamp(Millisecond, _) => {
-            sort_primitive::<TimestampMillisecondType, _>(
-                values, v, n, cmp, &options, limit,
-            )
-        }
-        DataType::Timestamp(Microsecond, _) => {
-            sort_primitive::<TimestampMicrosecondType, _>(
-                values, v, n, cmp, &options, limit,
-            )
-        }
-        DataType::Timestamp(Nanosecond, _) => {
-            sort_primitive::<TimestampNanosecondType, _>(
-                values, v, n, cmp, &options, limit,
-            )
-        }
-        DataType::Interval(IntervalUnit::YearMonth) => {
-            sort_primitive::<IntervalYearMonthType, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Interval(IntervalUnit::DayTime) => {
-            sort_primitive::<IntervalDayTimeType, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Interval(IntervalUnit::MonthDayNano) => {
-            sort_primitive::<IntervalMonthDayNanoType, _>(
-                values, v, n, cmp, &options, limit,
-            )
-        }
-        DataType::Duration(TimeUnit::Second) => {
-            sort_primitive::<DurationSecondType, _>(values, v, n, cmp, &options, limit)
-        }
-        DataType::Duration(TimeUnit::Millisecond) => {
-            sort_primitive::<DurationMillisecondType, _>(
-                values, v, n, cmp, &options, limit,
-            )
-        }
-        DataType::Duration(TimeUnit::Microsecond) => {
-            sort_primitive::<DurationMicrosecondType, _>(
-                values, v, n, cmp, &options, limit,
-            )
-        }
-        DataType::Duration(TimeUnit::Nanosecond) => {
-            sort_primitive::<DurationNanosecondType, _>(
-                values, v, n, cmp, &options, limit,
-            )
-        }
-        DataType::Utf8 => sort_string::<i32>(values, v, n, &options, limit),
-        DataType::LargeUtf8 => sort_string::<i64>(values, v, n, &options, limit),
-        DataType::List(field) | DataType::FixedSizeList(field, _) => match field
-            .data_type()
-        {
-            DataType::Int8 => sort_list::<i32, Int8Type>(values, v, n, &options, limit),
-            DataType::Int16 => sort_list::<i32, Int16Type>(values, v, n, &options, limit),
-            DataType::Int32 => sort_list::<i32, Int32Type>(values, v, n, &options, limit),
-            DataType::Int64 => sort_list::<i32, Int64Type>(values, v, n, &options, limit),
-            DataType::UInt8 => sort_list::<i32, UInt8Type>(values, v, n, &options, limit),
-            DataType::UInt16 => {
-                sort_list::<i32, UInt16Type>(values, v, n, &options, limit)
-            }
-            DataType::UInt32 => {
-                sort_list::<i32, UInt32Type>(values, v, n, &options, limit)
-            }
-            DataType::UInt64 => {
-                sort_list::<i32, UInt64Type>(values, v, n, &options, limit)
-            }
-            DataType::Float32 => {
-                sort_list::<i32, Float32Type>(values, v, n, &options, limit)
-            }
-            DataType::Float64 => {
-                sort_list::<i32, Float64Type>(values, v, n, &options, limit)
-            }
-            t => {
+        DataType::RunEndEncoded(run_ends_field, _) => match run_ends_field.data_type() {
+            DataType::Int16 => sort_run_to_indices::<Int16Type>(array, options, limit),
+            DataType::Int32 => sort_run_to_indices::<Int32Type>(array, options, limit),
+            DataType::Int64 => sort_run_to_indices::<Int64Type>(array, options, limit),
+            dt => {
                 return Err(ArrowError::ComputeError(format!(
-                    "Sort not supported for list type {:?}",
-                    t
-                )));
+                    "Invalid run end data type: {dt}"
+                )))
             }
         },
-        DataType::LargeList(field) => match field.data_type() {
-            DataType::Int8 => sort_list::<i64, Int8Type>(values, v, n, &options, limit),
-            DataType::Int16 => sort_list::<i64, Int16Type>(values, v, n, &options, limit),
-            DataType::Int32 => sort_list::<i64, Int32Type>(values, v, n, &options, limit),
-            DataType::Int64 => sort_list::<i64, Int64Type>(values, v, n, &options, limit),
-            DataType::UInt8 => sort_list::<i64, UInt8Type>(values, v, n, &options, limit),
-            DataType::UInt16 => {
-                sort_list::<i64, UInt16Type>(values, v, n, &options, limit)
-            }
-            DataType::UInt32 => {
-                sort_list::<i64, UInt32Type>(values, v, n, &options, limit)
-            }
-            DataType::UInt64 => {
-                sort_list::<i64, UInt64Type>(values, v, n, &options, limit)
-            }
-            DataType::Float32 => {
-                sort_list::<i64, Float32Type>(values, v, n, &options, limit)
-            }
-            DataType::Float64 => {
-                sort_list::<i64, Float64Type>(values, v, n, &options, limit)
-            }
-            t => {
-                return Err(ArrowError::ComputeError(format!(
-                    "Sort not supported for list type {:?}",
-                    t
-                )));
-            }
-        },
-        DataType::Dictionary(key_type, value_type)
-            if *value_type.as_ref() == DataType::Utf8 =>
-        {
-            match key_type.as_ref() {
-                DataType::Int8 => {
-                    sort_string_dictionary::<Int8Type>(values, v, n, &options, limit)
-                }
-                DataType::Int16 => {
-                    sort_string_dictionary::<Int16Type>(values, v, n, &options, limit)
-                }
-                DataType::Int32 => {
-                    sort_string_dictionary::<Int32Type>(values, v, n, &options, limit)
-                }
-                DataType::Int64 => {
-                    sort_string_dictionary::<Int64Type>(values, v, n, &options, limit)
-                }
-                DataType::UInt8 => {
-                    sort_string_dictionary::<UInt8Type>(values, v, n, &options, limit)
-                }
-                DataType::UInt16 => {
-                    sort_string_dictionary::<UInt16Type>(values, v, n, &options, limit)
-                }
-                DataType::UInt32 => {
-                    sort_string_dictionary::<UInt32Type>(values, v, n, &options, limit)
-                }
-                DataType::UInt64 => {
-                    sort_string_dictionary::<UInt64Type>(values, v, n, &options, limit)
-                }
-                t => {
-                    return Err(ArrowError::ComputeError(format!(
-                        "Sort not supported for dictionary key type {:?}",
-                        t
-                    )));
-                }
-            }
-        }
-        DataType::Binary | DataType::FixedSizeBinary(_) => {
-            sort_binary::<i32>(values, v, n, &options, limit)
-        }
-        DataType::LargeBinary => sort_binary::<i64>(values, v, n, &options, limit),
         t => {
             return Err(ArrowError::ComputeError(format!(
-                "Sort not supported for data type {:?}",
-                t
+                "Sort not supported for data type {t:?}"
             )));
         }
     })
 }
 
-/// Options that define how sort kernels should behave
-#[derive(Clone, Copy, Debug, Eq, PartialEq)]
-pub struct SortOptions {
-    /// Whether to sort in descending order
-    pub descending: bool,
-    /// Whether to sort nulls first
-    pub nulls_first: bool,
-}
-
-impl Default for SortOptions {
-    fn default() -> Self {
-        Self {
-            descending: false,
-            // default to nulls first to match spark's behavior
-            nulls_first: true,
-        }
-    }
-}
-
-/// Sort boolean values
-///
-/// when a limit is present, the sort is pair-comparison based as k-select might be more efficient,
-/// when the limit is absent, binary partition is used to speed up (which is linear).
-///
-/// TODO maybe partition_validity call can be eliminated in this case
-/// and [tri-color sort](https://en.wikipedia.org/wiki/Dutch_national_flag_problem)
-/// can be used instead.
 fn sort_boolean(
-    values: &ArrayRef,
+    values: &BooleanArray,
     value_indices: Vec<u32>,
-    mut null_indices: Vec<u32>,
-    options: &SortOptions,
+    null_indices: Vec<u32>,
+    options: SortOptions,
     limit: Option<usize>,
 ) -> UInt32Array {
-    let values = values
-        .as_any()
-        .downcast_ref::<BooleanArray>()
-        .expect("Unable to downcast to boolean array");
-    let descending = options.descending;
-
-    let valids_len = value_indices.len();
-    let nulls_len = null_indices.len();
-
-    let mut len = values.len();
-    let valids = if let Some(limit) = limit {
-        len = limit.min(len);
-        // create tuples that are used for sorting
-        let mut valids = value_indices
-            .into_iter()
-            .map(|index| (index, values.value(index as usize)))
-            .collect::<Vec<(u32, bool)>>();
-
-        sort_valids(descending, &mut valids, &mut null_indices, len, cmp);
-        valids
-    } else {
-        // when limit is not present, we have a better way than sorting: we can just partition
-        // the vec into [false..., true...] or [true..., false...] when descending
-        // TODO when https://github.com/rust-lang/rust/issues/62543 is merged we can use partition_in_place
-        let (mut a, b): (Vec<_>, Vec<_>) = value_indices
-            .into_iter()
-            .map(|index| (index, values.value(index as usize)))
-            .partition(|(_, value)| *value == descending);
-        a.extend(b);
-        if descending {
-            null_indices.reverse();
-        }
-        a
-    };
-
-    let nulls = null_indices;
-
-    // collect results directly into a buffer instead of a vec to avoid another aligned allocation
-    let result_capacity = len * std::mem::size_of::<u32>();
-    let mut result = MutableBuffer::new(result_capacity);
-    // sets len to capacity so we can access the whole buffer as a typed slice
-    result.resize(result_capacity, 0);
-    let result_slice: &mut [u32] = result.typed_data_mut();
-
-    if options.nulls_first {
-        let size = nulls_len.min(len);
-        result_slice[0..size].copy_from_slice(&nulls[0..size]);
-        if nulls_len < len {
-            insert_valid_values(result_slice, nulls_len, &valids[0..len - size]);
-        }
-    } else {
-        // nulls last
-        let size = valids.len().min(len);
-        insert_valid_values(result_slice, 0, &valids[0..size]);
-        if len > size {
-            result_slice[valids_len..].copy_from_slice(&nulls[0..(len - valids_len)]);
-        }
-    }
-
-    let result_data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::UInt32,
-            len,
-            Some(0),
-            None,
-            0,
-            vec![result.into()],
-            vec![],
-        )
-    };
-
-    UInt32Array::from(result_data)
+    let mut valids = value_indices
+        .into_iter()
+        .map(|index| (index, values.value(index as usize)))
+        .collect::<Vec<(u32, bool)>>();
+    sort_impl(options, &mut valids, &null_indices, limit, |a, b| a.cmp(&b)).into()
 }
 
-/// Sort Decimal array
-fn sort_decimal<F>(
-    decimal_values: &ArrayRef,
+fn sort_primitive<T: ArrowPrimitiveType>(
+    values: &PrimitiveArray<T>,
     value_indices: Vec<u32>,
-    null_indices: Vec<u32>,
-    cmp: F,
-    options: &SortOptions,
+    nulls: Vec<u32>,
+    options: SortOptions,
     limit: Option<usize>,
-) -> UInt32Array
-where
-    F: Fn(i128, i128) -> std::cmp::Ordering,
-{
-    // downcast to decimal array
-    let decimal_array = decimal_values
-        .as_any()
-        .downcast_ref::<Decimal128Array>()
-        .expect("Unable to downcast to decimal array");
-    let valids = value_indices
+) -> UInt32Array {
+    let mut valids = value_indices
         .into_iter()
-        .map(|index| (index, decimal_array.value(index as usize).as_i128()))
-        .collect::<Vec<(u32, i128)>>();
-    sort_primitive_inner(decimal_values, null_indices, cmp, options, limit, valids)
+        .map(|index| (index, values.value(index as usize)))
+        .collect::<Vec<(u32, T::Native)>>();
+    sort_impl(options, &mut valids, &nulls, limit, T::Native::compare).into()
 }
 
-/// Sort primitive values
-fn sort_primitive<T, F>(
-    values: &ArrayRef,
+fn sort_bytes<T: ByteArrayType>(
+    values: &GenericByteArray<T>,
     value_indices: Vec<u32>,
-    null_indices: Vec<u32>,
-    cmp: F,
-    options: &SortOptions,
-    limit: Option<usize>,
-) -> UInt32Array
-where
-    T: ArrowPrimitiveType,
-    T::Native: std::cmp::PartialOrd,
-    F: Fn(T::Native, T::Native) -> std::cmp::Ordering,
-{
-    // create tuples that are used for sorting
-    let valids = {
-        let values = as_primitive_array::<T>(values);
-        value_indices
-            .into_iter()
-            .map(|index| (index, values.value(index as usize)))
-            .collect::<Vec<(u32, T::Native)>>()
-    };
-    sort_primitive_inner(values, null_indices, cmp, options, limit, valids)
-}
-
-// sort is instantiated a lot so we only compile this inner version for each native type
-fn sort_primitive_inner<T, F>(
-    values: &ArrayRef,
-    null_indices: Vec<u32>,
-    cmp: F,
-    options: &SortOptions,
+    nulls: Vec<u32>,
+    options: SortOptions,
     limit: Option<usize>,
-    mut valids: Vec<(u32, T)>,
-) -> UInt32Array
-where
-    T: ArrowNativeType,
-    T: std::cmp::PartialOrd,
-    F: Fn(T, T) -> std::cmp::Ordering,
-{
-    let mut nulls = null_indices;
-
-    let valids_len = valids.len();
-    let nulls_len = nulls.len();
-    let mut len = values.len();
-
-    if let Some(limit) = limit {
-        len = limit.min(len);
-    }
-
-    sort_valids(options.descending, &mut valids, &mut nulls, len, cmp);
-
-    // collect results directly into a buffer instead of a vec to avoid another aligned allocation
-    let result_capacity = len * std::mem::size_of::<u32>();
-    let mut result = MutableBuffer::new(result_capacity);
-    // sets len to capacity so we can access the whole buffer as a typed slice
-    result.resize(result_capacity, 0);
-    let result_slice: &mut [u32] = result.typed_data_mut();
-
-    if options.nulls_first {
-        let size = nulls_len.min(len);
-        result_slice[0..size].copy_from_slice(&nulls[0..size]);
-        if nulls_len < len {
-            insert_valid_values(result_slice, nulls_len, &valids[0..len - size]);
-        }
-    } else {
-        // nulls last
-        let size = valids.len().min(len);
-        insert_valid_values(result_slice, 0, &valids[0..size]);
-        if len > size {
-            result_slice[valids_len..].copy_from_slice(&nulls[0..(len - valids_len)]);
-        }
-    }
-
-    let result_data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::UInt32,
-            len,
-            Some(0),
-            None,
-            0,
-            vec![result.into()],
-            vec![],
-        )
-    };
+) -> UInt32Array {
+    let mut valids = value_indices
+        .into_iter()
+        .map(|index| (index, values.value(index as usize).as_ref()))
+        .collect::<Vec<(u32, &[u8])>>();
 
-    UInt32Array::from(result_data)
+    sort_impl(options, &mut valids, &nulls, limit, Ord::cmp).into()
 }
 
-// insert valid and nan values in the correct order depending on the descending flag
-fn insert_valid_values<T>(result_slice: &mut [u32], offset: usize, valids: &[(u32, T)]) {
-    let valids_len = valids.len();
-    // helper to append the index part of the valid tuples
-    let append_valids = move |dst_slice: &mut [u32]| {
-        debug_assert_eq!(dst_slice.len(), valids_len);
-        dst_slice
-            .iter_mut()
-            .zip(valids.iter())
-            .for_each(|(dst, src)| *dst = src.0)
-    };
-
-    append_valids(&mut result_slice[offset..offset + valids.len()]);
+fn sort_fixed_size_binary(
+    values: &FixedSizeBinaryArray,
+    value_indices: Vec<u32>,
+    nulls: Vec<u32>,
+    options: SortOptions,
+    limit: Option<usize>,
+) -> UInt32Array {
+    let mut valids = value_indices
+        .iter()
+        .copied()
+        .map(|index| (index, values.value(index as usize)))
+        .collect::<Vec<(u32, &[u8])>>();
+    sort_impl(options, &mut valids, &nulls, limit, Ord::cmp).into()
 }
 
-/// Sort strings
-fn sort_string<Offset: OffsetSizeTrait>(
-    values: &ArrayRef,
+fn sort_dictionary<K: ArrowDictionaryKeyType>(
+    dict: &DictionaryArray<K>,
     value_indices: Vec<u32>,
     null_indices: Vec<u32>,
-    options: &SortOptions,
+    options: SortOptions,
     limit: Option<usize>,
-) -> UInt32Array {
-    let values = values
-        .as_any()
-        .downcast_ref::<GenericStringArray<Offset>>()
-        .unwrap();
+) -> Result<UInt32Array, ArrowError> {
+    let keys: &PrimitiveArray<K> = dict.keys();
+    let rank = child_rank(dict.values().as_ref(), options)?;
 
-    sort_string_helper(
-        values,
-        value_indices,
-        null_indices,
-        options,
-        limit,
-        |array, idx| array.value(idx as usize),
-    )
+    // create tuples that are used for sorting
+    let mut valids = value_indices
+        .into_iter()
+        .map(|index| {
+            let key: K::Native = keys.value(index as usize);
+            (index, rank[key.as_usize()])
+        })
+        .collect::<Vec<(u32, u32)>>();
+
+    Ok(sort_impl(options, &mut valids, &null_indices, limit, |a, b| a.cmp(&b)).into())
 }
 
-/// Sort dictionary encoded strings
-fn sort_string_dictionary<T: ArrowDictionaryKeyType>(
-    values: &ArrayRef,
+fn sort_list<O: OffsetSizeTrait>(
+    array: &GenericListArray<O>,
     value_indices: Vec<u32>,
     null_indices: Vec<u32>,
-    options: &SortOptions,
+    options: SortOptions,
     limit: Option<usize>,
-) -> UInt32Array {
-    let values: &DictionaryArray<T> = as_dictionary_array::<T>(values);
-
-    let keys: &PrimitiveArray<T> = values.keys();
-
-    let dict = values.values();
-    let dict: &StringArray = as_string_array(dict);
-
-    sort_string_helper(
-        keys,
-        value_indices,
-        null_indices,
-        options,
-        limit,
-        |array: &PrimitiveArray<T>, idx| -> &str {
-            let key: T::Native = array.value(idx as usize);
-            dict.value(key.to_usize().unwrap())
-        },
-    )
+) -> Result<UInt32Array, ArrowError> {
+    let rank = child_rank(array.values().as_ref(), options)?;
+    let offsets = array.value_offsets();
+    let mut valids = value_indices
+        .into_iter()
+        .map(|index| {
+            let end = offsets[index as usize + 1].as_usize();
+            let start = offsets[index as usize].as_usize();
+            (index, &rank[start..end])
+        })
+        .collect::<Vec<(u32, &[u32])>>();
+    Ok(sort_impl(options, &mut valids, &null_indices, limit, Ord::cmp).into())
 }
 
-/// shared implementation between dictionary encoded and plain string arrays
-#[inline]
-fn sort_string_helper<'a, A: Array, F>(
-    values: &'a A,
+fn sort_fixed_size_list(
+    array: &FixedSizeListArray,
     value_indices: Vec<u32>,
     null_indices: Vec<u32>,
-    options: &SortOptions,
+    options: SortOptions,
     limit: Option<usize>,
-    value_fn: F,
-) -> UInt32Array
-where
-    F: Fn(&'a A, u32) -> &str,
-{
+) -> Result<UInt32Array, ArrowError> {
+    let rank = child_rank(array.values().as_ref(), options)?;
+    let size = array.value_length() as usize;
     let mut valids = value_indices
         .into_iter()
-        .map(|index| (index, value_fn(values, index)))
-        .collect::<Vec<(u32, &str)>>();
-    let mut nulls = null_indices;
-    let descending = options.descending;
-    let mut len = values.len();
+        .map(|index| {
+            let start = index as usize * size;
+            (index, &rank[start..start + size])
+        })
+        .collect::<Vec<(u32, &[u32])>>();
+    Ok(sort_impl(options, &mut valids, &null_indices, limit, Ord::cmp).into())
+}
 
-    if let Some(limit) = limit {
-        len = limit.min(len);
-    }
+#[inline(never)]
+fn sort_impl<T: ?Sized + Copy>(
+    options: SortOptions,
+    valids: &mut [(u32, T)],
+    nulls: &[u32],
+    limit: Option<usize>,
+    mut cmp: impl FnMut(T, T) -> Ordering,
+) -> Vec<u32> {
+    let v_limit = match (limit, options.nulls_first) {
+        (Some(l), true) => l.saturating_sub(nulls.len()).min(valids.len()),
+        _ => valids.len(),
+    };
 
-    sort_valids(descending, &mut valids, &mut nulls, len, cmp);
-    // collect the order of valid tuplies
-    let mut valid_indices: Vec<u32> = valids.iter().map(|tuple| tuple.0).collect();
+    match options.descending {
+        false => sort_unstable_by(valids, v_limit, |a, b| cmp(a.1, b.1)),
+        true => sort_unstable_by(valids, v_limit, |a, b| cmp(a.1, b.1).reverse()),
+    }
 
-    if options.nulls_first {
-        nulls.append(&mut valid_indices);
-        nulls.truncate(len);
-        UInt32Array::from(nulls)
-    } else {
-        // no need to sort nulls as they are in the correct order already
-        valid_indices.append(&mut nulls);
-        valid_indices.truncate(len);
-        UInt32Array::from(valid_indices)
+    let len = valids.len() + nulls.len();
+    let limit = limit.unwrap_or(len).min(len);
+    let mut out = Vec::with_capacity(len);
+    match options.nulls_first {
+        true => {
+            out.extend_from_slice(&nulls[..nulls.len().min(limit)]);
+            let remaining = limit - out.len();
+            out.extend(valids.iter().map(|x| x.0).take(remaining));
+        }
+        false => {
+            out.extend(valids.iter().map(|x| x.0).take(limit));
+            let remaining = limit - out.len();
+            out.extend_from_slice(&nulls[..remaining])
+        }
     }
+    out
 }
 
-fn sort_list<S, T>(
-    values: &ArrayRef,
-    value_indices: Vec<u32>,
-    null_indices: Vec<u32>,
-    options: &SortOptions,
+/// Computes the rank for a set of child values
+fn child_rank(values: &dyn Array, options: SortOptions) -> Result<Vec<u32>, ArrowError> {
+    // If parent sort order is descending we need to invert the value of nulls_first so that
+    // when the parent is sorted based on the produced ranks, nulls are still ordered correctly
+    let value_options = Some(SortOptions {
+        descending: false,
+        nulls_first: options.nulls_first != options.descending,
+    });
+    rank(values, value_options)
+}
+
+// Sort run array and return sorted run array.
+// The output RunArray will be encoded at the same level as input run array.
+// For e.g. an input RunArray { run_ends = [2,4,6,8], values = [1,2,1,2] }
+// will result in output RunArray { run_ends = [2,4,6,8], values = [1,1,2,2] }
+// and not RunArray { run_ends = [4,8], values = [1,2] }
+fn sort_run(
+    values: &dyn Array,
+    options: Option<SortOptions>,
     limit: Option<usize>,
-) -> UInt32Array
-where
-    S: OffsetSizeTrait,
-    T: ArrowPrimitiveType,
-    T::Native: std::cmp::PartialOrd,
-{
-    sort_list_inner::<S>(values, value_indices, null_indices, options, limit)
+) -> Result<ArrayRef, ArrowError> {
+    match values.data_type() {
+        DataType::RunEndEncoded(run_ends_field, _) => match run_ends_field.data_type() {
+            DataType::Int16 => sort_run_downcasted::<Int16Type>(values, options, limit),
+            DataType::Int32 => sort_run_downcasted::<Int32Type>(values, options, limit),
+            DataType::Int64 => sort_run_downcasted::<Int64Type>(values, options, limit),
+            dt => unreachable!("Not valid run ends data type {dt}"),
+        },
+        dt => Err(ArrowError::InvalidArgumentError(format!(
+            "Input is not a run encoded array. Input data type {dt}"
+        ))),
+    }
 }
 
-fn sort_list_inner<S>(
-    values: &ArrayRef,
-    value_indices: Vec<u32>,
-    mut null_indices: Vec<u32>,
-    options: &SortOptions,
+fn sort_run_downcasted<R: RunEndIndexType>(
+    values: &dyn Array,
+    options: Option<SortOptions>,
     limit: Option<usize>,
-) -> UInt32Array
-where
-    S: OffsetSizeTrait,
-{
-    let mut valids: Vec<(u32, ArrayRef)> = values
-        .as_any()
-        .downcast_ref::<FixedSizeListArray>()
-        .map_or_else(
-            || {
-                let values = as_generic_list_array::<S>(values);
-                value_indices
-                    .iter()
-                    .copied()
-                    .map(|index| (index, values.value(index as usize)))
-                    .collect()
-            },
-            |values| {
-                value_indices
-                    .iter()
-                    .copied()
-                    .map(|index| (index, values.value(index as usize)))
-                    .collect()
-            },
-        );
+) -> Result<ArrayRef, ArrowError> {
+    let run_array = values.as_any().downcast_ref::<RunArray<R>>().unwrap();
 
-    let mut len = values.len();
-    let descending = options.descending;
+    // Determine the length of output run array.
+    let output_len = if let Some(limit) = limit {
+        limit.min(run_array.len())
+    } else {
+        run_array.len()
+    };
 
-    if let Some(limit) = limit {
-        len = limit.min(len);
-    }
-    sort_valids_array(descending, &mut valids, &mut null_indices, len);
+    let run_ends = run_array.run_ends();
 
-    let mut valid_indices: Vec<u32> = valids.iter().map(|tuple| tuple.0).collect();
-    if options.nulls_first {
-        null_indices.append(&mut valid_indices);
-        null_indices.truncate(len);
-        UInt32Array::from(null_indices)
-    } else {
-        valid_indices.append(&mut null_indices);
-        valid_indices.truncate(len);
-        UInt32Array::from(valid_indices)
-    }
-}
+    let mut new_run_ends_builder = BufferBuilder::<R::Native>::new(run_ends.len());
+    let mut new_run_end: usize = 0;
+    let mut new_physical_len: usize = 0;
 
-fn sort_binary<S>(
-    values: &ArrayRef,
-    value_indices: Vec<u32>,
-    mut null_indices: Vec<u32>,
-    options: &SortOptions,
-    limit: Option<usize>,
-) -> UInt32Array
-where
-    S: OffsetSizeTrait,
-{
-    let mut valids: Vec<(u32, &[u8])> = values
-        .as_any()
-        .downcast_ref::<FixedSizeBinaryArray>()
-        .map_or_else(
-            || {
-                let values = as_generic_binary_array::<S>(values);
-                value_indices
-                    .iter()
-                    .copied()
-                    .map(|index| (index, values.value(index as usize)))
-                    .collect()
-            },
-            |values| {
-                value_indices
-                    .iter()
-                    .copied()
-                    .map(|index| (index, values.value(index as usize)))
-                    .collect()
-            },
-        );
+    let consume_runs = |run_length, _| {
+        new_run_end += run_length;
+        new_physical_len += 1;
+        new_run_ends_builder.append(R::Native::from_usize(new_run_end).unwrap());
+    };
 
-    let mut len = values.len();
-    let descending = options.descending;
+    let (values_indices, run_values) = sort_run_inner(run_array, options, output_len, consume_runs);
 
-    if let Some(limit) = limit {
-        len = limit.min(len);
-    }
+    let new_run_ends = unsafe {
+        // Safety:
+        // The function builds a valid run_ends array and hence need not be validated.
+        ArrayDataBuilder::new(R::DATA_TYPE)
+            .len(new_physical_len)
+            .add_buffer(new_run_ends_builder.finish())
+            .build_unchecked()
+    };
 
-    sort_valids(descending, &mut valids, &mut null_indices, len, cmp);
+    // slice the sorted value indices based on limit.
+    let new_values_indices: PrimitiveArray<UInt32Type> = values_indices
+        .slice(0, new_run_ends.len())
+        .into_data()
+        .into();
+
+    let new_values = take(&run_values, &new_values_indices, None)?;
+
+    // Build sorted run array
+    let builder = ArrayDataBuilder::new(run_array.data_type().clone())
+        .len(new_run_end)
+        .add_child_data(new_run_ends)
+        .add_child_data(new_values.into_data());
+    let array_data: RunArray<R> = unsafe {
+        // Safety:
+        //  This function builds a valid run array and hence can skip validation.
+        builder.build_unchecked().into()
+    };
+    Ok(Arc::new(array_data))
+}
 
-    let mut valid_indices: Vec<u32> = valids.iter().map(|tuple| tuple.0).collect();
-    if options.nulls_first {
-        null_indices.append(&mut valid_indices);
-        null_indices.truncate(len);
-        UInt32Array::from(null_indices)
+// Sort to indices for run encoded array.
+// This function will be slow for run array as it decodes the physical indices to
+// logical indices and to get the run array back, the logical indices has to be
+// encoded back to run array.
+fn sort_run_to_indices<R: RunEndIndexType>(
+    values: &dyn Array,
+    options: SortOptions,
+    limit: Option<usize>,
+) -> UInt32Array {
+    let run_array = values.as_any().downcast_ref::<RunArray<R>>().unwrap();
+    let output_len = if let Some(limit) = limit {
+        limit.min(run_array.len())
     } else {
-        valid_indices.append(&mut null_indices);
-        valid_indices.truncate(len);
-        UInt32Array::from(valid_indices)
-    }
+        run_array.len()
+    };
+    let mut result: Vec<u32> = Vec::with_capacity(output_len);
+
+    //Add all logical indices belonging to a physical index to the output
+    let consume_runs = |run_length, logical_start| {
+        result.extend(logical_start as u32..(logical_start + run_length) as u32);
+    };
+    sort_run_inner(run_array, Some(options), output_len, consume_runs);
+
+    UInt32Array::from(result)
 }
 
-/// Compare two `Array`s based on the ordering defined in [build_compare]
-fn cmp_array(a: &dyn Array, b: &dyn Array) -> Ordering {
-    let cmp_op = build_compare(a, b).unwrap();
-    let length = a.len().max(b.len());
+fn sort_run_inner<R: RunEndIndexType, F>(
+    run_array: &RunArray<R>,
+    options: Option<SortOptions>,
+    output_len: usize,
+    mut consume_runs: F,
+) -> (PrimitiveArray<UInt32Type>, ArrayRef)
+where
+    F: FnMut(usize, usize),
+{
+    // slice the run_array.values based on offset and length.
+    let start_physical_index = run_array.get_start_physical_index();
+    let end_physical_index = run_array.get_end_physical_index();
+    let physical_len = end_physical_index - start_physical_index + 1;
+    let run_values = run_array.values().slice(start_physical_index, physical_len);
+
+    // All the values have to be sorted irrespective of input limit.
+    let values_indices = sort_to_indices(&run_values, options, None).unwrap();
+
+    let mut remaining_len = output_len;
+
+    let run_ends = run_array.run_ends().values();
+
+    assert_eq!(
+        0,
+        values_indices.null_count(),
+        "The output of sort_to_indices should not have null values. Its values is {}",
+        values_indices.null_count()
+    );
+
+    // Calculate `run length` of sorted value indices.
+    // Find the `logical index` at which the run starts.
+    // Call the consumer using the run length and starting logical index.
+    for physical_index in values_indices.values() {
+        // As the values were sliced with offset = start_physical_index, it has to be added back
+        // before accessing `RunArray::run_ends`
+        let physical_index = *physical_index as usize + start_physical_index;
+
+        // calculate the run length and logical index of sorted values
+        let (run_length, logical_index_start) = unsafe {
+            // Safety:
+            // The index will be within bounds as its in bounds of start_physical_index
+            // and len, both of which are within bounds of run_array
+            if physical_index == start_physical_index {
+                (
+                    run_ends.get_unchecked(physical_index).as_usize() - run_array.offset(),
+                    0,
+                )
+            } else if physical_index == end_physical_index {
+                let prev_run_end = run_ends.get_unchecked(physical_index - 1).as_usize();
+                (
+                    run_array.offset() + run_array.len() - prev_run_end,
+                    prev_run_end - run_array.offset(),
+                )
+            } else {
+                let prev_run_end = run_ends.get_unchecked(physical_index - 1).as_usize();
+                (
+                    run_ends.get_unchecked(physical_index).as_usize() - prev_run_end,
+                    prev_run_end - run_array.offset(),
+                )
+            }
+        };
+        let new_run_length = run_length.min(remaining_len);
+        consume_runs(new_run_length, logical_index_start);
+        remaining_len -= new_run_length;
 
-    for i in 0..length {
-        let result = cmp_op(i, i);
-        if result != Ordering::Equal {
-            return result;
+        if remaining_len == 0 {
+            break;
         }
     }
-    Ordering::Equal
+
+    if remaining_len > 0 {
+        panic!("Remaining length should be zero its values is {remaining_len}")
+    }
+    (values_indices, run_values)
 }
 
 /// One column to be used in lexicographical sort
@@ -836,11 +600,12 @@ pub struct SortColumn {
 /// Example:
 ///
 /// ```
-/// use std::convert::From;
-/// use std::sync::Arc;
-/// use arrow::array::{ArrayRef, StringArray, PrimitiveArray, as_primitive_array};
-/// use arrow::compute::kernels::sort::{SortColumn, SortOptions, lexsort};
-/// use arrow::datatypes::Int64Type;
+/// # use std::convert::From;
+/// # use std::sync::Arc;
+/// # use arrow_array::{ArrayRef, StringArray, PrimitiveArray};
+/// # use arrow_array::types::Int64Type;
+/// # use arrow_array::cast::AsArray;
+/// # use arrow_ord::sort::{SortColumn, SortOptions, lexsort};
 ///
 /// let sorted_columns = lexsort(&vec![
 ///     SortColumn {
@@ -868,10 +633,14 @@ pub struct SortColumn {
 ///     },
 /// ], None).unwrap();
 ///
-/// assert_eq!(as_primitive_array::<Int64Type>(&sorted_columns[0]).value(1), -64);
+/// assert_eq!(sorted_columns[0].as_primitive::<Int64Type>().value(1), -64);
 /// assert!(sorted_columns[0].is_null(0));
 /// ```
-pub fn lexsort(columns: &[SortColumn], limit: Option<usize>) -> Result<Vec<ArrayRef>> {
+///
+/// Note: for multi-column sorts without a limit, using the [row format](https://docs.rs/arrow-row/latest/arrow_row/)
+/// may be significantly faster
+///
+pub fn lexsort(columns: &[SortColumn], limit: Option<usize>) -> Result<Vec<ArrayRef>, ArrowError> {
     let indices = lexsort_to_indices(columns, limit)?;
     columns
         .iter()
@@ -881,10 +650,13 @@ pub fn lexsort(columns: &[SortColumn], limit: Option<usize>) -> Result<Vec<Array
 
 /// Sort elements lexicographically from a list of `ArrayRef` into an unsigned integer
 /// (`UInt32Array`) of indices.
+///
+/// Note: for multi-column sorts without a limit, using the [row format](https://docs.rs/arrow-row/latest/arrow_row/)
+/// may be significantly faster
 pub fn lexsort_to_indices(
     columns: &[SortColumn],
     limit: Option<usize>,
-) -> Result<UInt32Array> {
+) -> Result<UInt32Array, ArrowError> {
     if columns.is_empty() {
         return Err(ArrowError::InvalidArgumentError(
             "Sort requires at least one column".to_string(),
@@ -913,14 +685,11 @@ pub fn lexsort_to_indices(
     let lexicographical_comparator = LexicographicalComparator::try_new(columns)?;
     // uint32 can be sorted unstably
     sort_unstable_by(&mut value_indices, len, |a, b| {
-        lexicographical_comparator.compare(a, b)
+        lexicographical_comparator.compare(*a, *b)
     });
 
-    Ok(UInt32Array::from(
-        (&value_indices)[0..len]
-            .iter()
-            .map(|i| *i as u32)
-            .collect::<Vec<u32>>(),
+    Ok(UInt32Array::from_iter_values(
+        value_indices.iter().take(len).map(|i| *i as u32),
     ))
 }
 
@@ -929,33 +698,36 @@ pub fn partial_sort<T, F>(v: &mut [T], limit: usize, mut is_less: F)
 where
     F: FnMut(&T, &T) -> Ordering,
 {
-    let (before, _mid, _after) = v.select_nth_unstable_by(limit, &mut is_less);
-    before.sort_unstable_by(is_less);
+    if let Some(n) = limit.checked_sub(1) {
+        let (before, _mid, _after) = v.select_nth_unstable_by(n, &mut is_less);
+        before.sort_unstable_by(is_less);
+    }
 }
 
-type LexicographicalCompareItem<'a> = (
-    &'a ArrayData, // data
-    DynComparator, // comparator
-    SortOptions,   // sort_option
+type LexicographicalCompareItem = (
+    Option<NullBuffer>, // nulls
+    DynComparator,      // comparator
+    SortOptions,        // sort_option
 );
 
 /// A lexicographical comparator that wraps given array data (columns) and can lexicographically compare data
 /// at given two indices. The lifetime is the same at the data wrapped.
-pub(super) struct LexicographicalComparator<'a> {
-    compare_items: Vec<LexicographicalCompareItem<'a>>,
+pub struct LexicographicalComparator {
+    compare_items: Vec<LexicographicalCompareItem>,
 }
 
-impl LexicographicalComparator<'_> {
+impl LexicographicalComparator {
     /// lexicographically compare values at the wrapped columns with given indices.
-    pub(super) fn compare<'a, 'b>(
-        &'a self,
-        a_idx: &'b usize,
-        b_idx: &'b usize,
-    ) -> Ordering {
-        for (data, comparator, sort_option) in &self.compare_items {
-            match (data.is_valid(*a_idx), data.is_valid(*b_idx)) {
+    pub fn compare(&self, a_idx: usize, b_idx: usize) -> Ordering {
+        for (nulls, comparator, sort_option) in &self.compare_items {
+            let (lhs_valid, rhs_valid) = match nulls {
+                Some(n) => (n.is_valid(a_idx), n.is_valid(b_idx)),
+                None => (true, true),
+            };
+
+            match (lhs_valid, rhs_valid) {
                 (true, true) => {
-                    match (comparator)(*a_idx, *b_idx) {
+                    match (comparator)(a_idx, b_idx) {
                         // equal, move on to next column
                         Ordering::Equal => continue,
                         order => {
@@ -991,109 +763,98 @@ impl LexicographicalComparator<'_> {
 
     /// Create a new lex comparator that will wrap the given sort columns and give comparison
     /// results with two indices.
-    pub(super) fn try_new(
-        columns: &[SortColumn],
-    ) -> Result<LexicographicalComparator<'_>> {
+    pub fn try_new(columns: &[SortColumn]) -> Result<LexicographicalComparator, ArrowError> {
         let compare_items = columns
             .iter()
             .map(|column| {
                 // flatten and convert build comparators
-                // use ArrayData for is_valid checks later to avoid dynamic call
                 let values = column.values.as_ref();
-                let data = values.data_ref();
                 Ok((
-                    data,
+                    values.logical_nulls(),
                     build_compare(values, values)?,
                     column.options.unwrap_or_default(),
                 ))
             })
-            .collect::<Result<Vec<_>>>()?;
+            .collect::<Result<Vec<_>, ArrowError>>()?;
         Ok(LexicographicalComparator { compare_items })
     }
 }
 
-fn sort_valids<T, U>(
-    descending: bool,
-    valids: &mut [(u32, T)],
-    nulls: &mut [U],
-    len: usize,
-    mut cmp: impl FnMut(T, T) -> Ordering,
-) where
-    T: ?Sized + Copy,
-{
-    let valids_len = valids.len();
-    if !descending {
-        sort_unstable_by(valids, len.min(valids_len), |a, b| cmp(a.1, b.1));
-    } else {
-        sort_unstable_by(valids, len.min(valids_len), |a, b| cmp(a.1, b.1).reverse());
-        // reverse to keep a stable ordering
-        nulls.reverse();
-    }
-}
-
-fn sort_valids_array<T>(
-    descending: bool,
-    valids: &mut [(u32, ArrayRef)],
-    nulls: &mut [T],
-    len: usize,
-) {
-    let valids_len = valids.len();
-    if !descending {
-        sort_unstable_by(valids, len.min(valids_len), |a, b| {
-            cmp_array(a.1.as_ref(), b.1.as_ref())
-        });
-    } else {
-        sort_unstable_by(valids, len.min(valids_len), |a, b| {
-            cmp_array(a.1.as_ref(), b.1.as_ref()).reverse()
-        });
-        // reverse to keep a stable ordering
-        nulls.reverse();
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::compute::util::tests::{
-        build_fixed_size_list_nullable, build_generic_list_nullable,
+    use arrow_array::builder::{
+        FixedSizeListBuilder, Int64Builder, ListBuilder, PrimitiveRunBuilder,
     };
+    use arrow_buffer::i256;
+    use half::f16;
     use rand::rngs::StdRng;
     use rand::{Rng, RngCore, SeedableRng};
-    use std::convert::TryFrom;
     use std::sync::Arc;
 
-    fn create_decimal_array(data: &[Option<i128>]) -> Decimal128Array {
-        data.iter()
+    fn create_decimal128_array(data: Vec<Option<i128>>) -> Decimal128Array {
+        data.into_iter()
             .collect::<Decimal128Array>()
             .with_precision_and_scale(23, 6)
             .unwrap()
     }
 
-    fn test_sort_to_indices_decimal_array(
+    fn create_decimal256_array(data: Vec<Option<i256>>) -> Decimal256Array {
+        data.into_iter()
+            .collect::<Decimal256Array>()
+            .with_precision_and_scale(53, 6)
+            .unwrap()
+    }
+
+    fn test_sort_to_indices_decimal128_array(
         data: Vec<Option<i128>>,
         options: Option<SortOptions>,
         limit: Option<usize>,
         expected_data: Vec<u32>,
     ) {
-        let output = create_decimal_array(&data);
+        let output = create_decimal128_array(data);
+        let expected = UInt32Array::from(expected_data);
+        let output = sort_to_indices(&(Arc::new(output) as ArrayRef), options, limit).unwrap();
+        assert_eq!(output, expected)
+    }
+
+    fn test_sort_to_indices_decimal256_array(
+        data: Vec<Option<i256>>,
+        options: Option<SortOptions>,
+        limit: Option<usize>,
+        expected_data: Vec<u32>,
+    ) {
+        let output = create_decimal256_array(data);
         let expected = UInt32Array::from(expected_data);
-        let output =
-            sort_to_indices(&(Arc::new(output) as ArrayRef), options, limit).unwrap();
+        let output = sort_to_indices(&(Arc::new(output) as ArrayRef), options, limit).unwrap();
         assert_eq!(output, expected)
     }
 
-    fn test_sort_decimal_array(
+    fn test_sort_decimal128_array(
         data: Vec<Option<i128>>,
         options: Option<SortOptions>,
         limit: Option<usize>,
         expected_data: Vec<Option<i128>>,
     ) {
-        let output = create_decimal_array(&data);
-        let expected = Arc::new(create_decimal_array(&expected_data)) as ArrayRef;
+        let output = create_decimal128_array(data);
+        let expected = Arc::new(create_decimal128_array(expected_data)) as ArrayRef;
         let output = match limit {
-            Some(_) => {
-                sort_limit(&(Arc::new(output) as ArrayRef), options, limit).unwrap()
-            }
+            Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options, limit).unwrap(),
+            _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
+        };
+        assert_eq!(&output, &expected)
+    }
+
+    fn test_sort_decimal256_array(
+        data: Vec<Option<i256>>,
+        options: Option<SortOptions>,
+        limit: Option<usize>,
+        expected_data: Vec<Option<i256>>,
+    ) {
+        let output = create_decimal256_array(data);
+        let expected = Arc::new(create_decimal256_array(expected_data)) as ArrayRef;
+        let output = match limit {
+            Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options, limit).unwrap(),
             _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
         };
         assert_eq!(&output, &expected)
@@ -1107,8 +868,7 @@ mod tests {
     ) {
         let output = BooleanArray::from(data);
         let expected = UInt32Array::from(expected_data);
-        let output =
-            sort_to_indices(&(Arc::new(output) as ArrayRef), options, limit).unwrap();
+        let output = sort_to_indices(&(Arc::new(output) as ArrayRef), options, limit).unwrap();
         assert_eq!(output, expected)
     }
 
@@ -1123,8 +883,7 @@ mod tests {
     {
         let output = PrimitiveArray::<T>::from(data);
         let expected = UInt32Array::from(expected_data);
-        let output =
-            sort_to_indices(&(Arc::new(output) as ArrayRef), options, limit).unwrap();
+        let output = sort_to_indices(&(Arc::new(output) as ArrayRef), options, limit).unwrap();
         assert_eq!(output, expected)
     }
 
@@ -1140,9 +899,7 @@ mod tests {
         let output = PrimitiveArray::<T>::from(data);
         let expected = Arc::new(PrimitiveArray::<T>::from(expected_data)) as ArrayRef;
         let output = match limit {
-            Some(_) => {
-                sort_limit(&(Arc::new(output) as ArrayRef), options, limit).unwrap()
-            }
+            Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options, limit).unwrap(),
             _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
         };
         assert_eq!(&output, &expected)
@@ -1156,8 +913,7 @@ mod tests {
     ) {
         let output = StringArray::from(data);
         let expected = UInt32Array::from(expected_data);
-        let output =
-            sort_to_indices(&(Arc::new(output) as ArrayRef), options, limit).unwrap();
+        let output = sort_to_indices(&(Arc::new(output) as ArrayRef), options, limit).unwrap();
         assert_eq!(output, expected)
     }
 
@@ -1171,9 +927,7 @@ mod tests {
         let output = StringArray::from(data.clone());
         let expected = Arc::new(StringArray::from(expected_data.clone())) as ArrayRef;
         let output = match limit {
-            Some(_) => {
-                sort_limit(&(Arc::new(output) as ArrayRef), options, limit).unwrap()
-            }
+            Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options, limit).unwrap(),
             _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
         };
         assert_eq!(&output, &expected);
@@ -1181,9 +935,7 @@ mod tests {
         let output = LargeStringArray::from(data);
         let expected = Arc::new(LargeStringArray::from(expected_data)) as ArrayRef;
         let output = match limit {
-            Some(_) => {
-                sort_limit(&(Arc::new(output) as ArrayRef), options, limit).unwrap()
-            }
+            Some(_) => sort_limit(&(Arc::new(output) as ArrayRef), options, limit).unwrap(),
             _ => sort(&(Arc::new(output) as ArrayRef), options).unwrap(),
         };
         assert_eq!(&output, &expected)
@@ -1197,46 +949,85 @@ mod tests {
     ) {
         let array = data.into_iter().collect::<DictionaryArray<T>>();
         let array_values = array.values().clone();
-        let dict = array_values
-            .as_any()
-            .downcast_ref::<StringArray>()
-            .expect("Unable to get dictionary values");
+        let dict = array_values
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .expect("Unable to get dictionary values");
+
+        let sorted = match limit {
+            Some(_) => sort_limit(&(Arc::new(array) as ArrayRef), options, limit).unwrap(),
+            _ => sort(&(Arc::new(array) as ArrayRef), options).unwrap(),
+        };
+        let sorted = sorted
+            .as_any()
+            .downcast_ref::<DictionaryArray<T>>()
+            .unwrap();
+        let sorted_values = sorted.values();
+        let sorted_dict = sorted_values
+            .as_any()
+            .downcast_ref::<StringArray>()
+            .expect("Unable to get dictionary values");
+        let sorted_keys = sorted.keys();
+
+        assert_eq!(sorted_dict, dict);
+
+        let sorted_strings = StringArray::from_iter((0..sorted.len()).map(|i| {
+            if sorted.is_valid(i) {
+                Some(sorted_dict.value(sorted_keys.value(i).as_usize()))
+            } else {
+                None
+            }
+        }));
+        let expected = StringArray::from(expected_data);
+
+        assert_eq!(sorted_strings, expected)
+    }
+
+    fn test_sort_primitive_dict_arrays<K: ArrowDictionaryKeyType, T: ArrowPrimitiveType>(
+        keys: PrimitiveArray<K>,
+        values: PrimitiveArray<T>,
+        options: Option<SortOptions>,
+        limit: Option<usize>,
+        expected_data: Vec<Option<T::Native>>,
+    ) where
+        PrimitiveArray<T>: From<Vec<Option<T::Native>>>,
+    {
+        let array = DictionaryArray::<K>::new(keys, Arc::new(values));
+        let array_values = array.values().clone();
+        let dict = array_values.as_primitive::<T>();
 
         let sorted = match limit {
-            Some(_) => {
-                sort_limit(&(Arc::new(array) as ArrayRef), options, limit).unwrap()
-            }
+            Some(_) => sort_limit(&(Arc::new(array) as ArrayRef), options, limit).unwrap(),
             _ => sort(&(Arc::new(array) as ArrayRef), options).unwrap(),
         };
         let sorted = sorted
             .as_any()
-            .downcast_ref::<DictionaryArray<T>>()
+            .downcast_ref::<DictionaryArray<K>>()
             .unwrap();
         let sorted_values = sorted.values();
         let sorted_dict = sorted_values
             .as_any()
-            .downcast_ref::<StringArray>()
+            .downcast_ref::<PrimitiveArray<T>>()
             .expect("Unable to get dictionary values");
         let sorted_keys = sorted.keys();
 
         assert_eq!(sorted_dict, dict);
 
-        let sorted_strings = StringArray::try_from(
+        let sorted_values: PrimitiveArray<T> = From::<Vec<Option<T::Native>>>::from(
             (0..sorted.len())
                 .map(|i| {
-                    if sorted.is_valid(i) {
-                        Some(sorted_dict.value(sorted_keys.value(i).to_usize().unwrap()))
+                    let key = sorted_keys.value(i).as_usize();
+                    if sorted.is_valid(i) && sorted_dict.is_valid(key) {
+                        Some(sorted_dict.value(key))
                     } else {
                         None
                     }
                 })
-                .collect::<Vec<Option<&str>>>(),
-        )
-        .expect("Unable to create string array from dictionary");
-        let expected =
-            StringArray::try_from(expected_data).expect("Unable to create string array");
+                .collect::<Vec<Option<T::Native>>>(),
+        );
+        let expected: PrimitiveArray<T> = From::<Vec<Option<T::Native>>>::from(expected_data);
 
-        assert_eq!(sorted_strings, expected)
+        assert_eq!(sorted_values, expected)
     }
 
     fn test_sort_list_arrays<T>(
@@ -1251,12 +1042,15 @@ mod tests {
     {
         // for FixedSizedList
         if let Some(length) = fixed_length {
-            let input = Arc::new(build_fixed_size_list_nullable(data.clone(), length));
+            let input = Arc::new(FixedSizeListArray::from_iter_primitive::<T, _, _>(
+                data.clone(),
+                length,
+            ));
             let sorted = match limit {
                 Some(_) => sort_limit(&(input as ArrayRef), options, limit).unwrap(),
                 _ => sort(&(input as ArrayRef), options).unwrap(),
             };
-            let expected = Arc::new(build_fixed_size_list_nullable(
+            let expected = Arc::new(FixedSizeListArray::from_iter_primitive::<T, _, _>(
                 expected_data.clone(),
                 length,
             )) as ArrayRef;
@@ -1265,25 +1059,26 @@ mod tests {
         }
 
         // for List
-        let input = Arc::new(build_generic_list_nullable::<i32, T>(data.clone()));
+        let input = Arc::new(ListArray::from_iter_primitive::<T, _, _>(data.clone()));
         let sorted = match limit {
             Some(_) => sort_limit(&(input as ArrayRef), options, limit).unwrap(),
             _ => sort(&(input as ArrayRef), options).unwrap(),
         };
-        let expected =
-            Arc::new(build_generic_list_nullable::<i32, T>(expected_data.clone()))
-                as ArrayRef;
+        let expected = Arc::new(ListArray::from_iter_primitive::<T, _, _>(
+            expected_data.clone(),
+        )) as ArrayRef;
 
         assert_eq!(&sorted, &expected);
 
         // for LargeList
-        let input = Arc::new(build_generic_list_nullable::<i64, T>(data));
+        let input = Arc::new(LargeListArray::from_iter_primitive::<T, _, _>(data));
         let sorted = match limit {
             Some(_) => sort_limit(&(input as ArrayRef), options, limit).unwrap(),
             _ => sort(&(input as ArrayRef), options).unwrap(),
         };
-        let expected =
-            Arc::new(build_generic_list_nullable::<i64, T>(expected_data)) as ArrayRef;
+        let expected = Arc::new(LargeListArray::from_iter_primitive::<T, _, _>(
+            expected_data,
+        )) as ArrayRef;
 
         assert_eq!(&sorted, &expected);
     }
@@ -1300,6 +1095,14 @@ mod tests {
         }
     }
 
+    /// slice all arrays in expected_output to offset/length
+    fn slice_arrays(expected_output: Vec<ArrayRef>, offset: usize, length: usize) -> Vec<ArrayRef> {
+        expected_output
+            .into_iter()
+            .map(|array| array.slice(offset, length))
+            .collect()
+    }
+
     fn test_sort_binary_arrays(
         data: Vec<Option<Vec<u8>>>,
         options: Option<SortOptions>,
@@ -1308,17 +1111,21 @@ mod tests {
         fixed_length: Option<i32>,
     ) {
         // Fixed size binary array
-        if fixed_length.is_some() {
+        if let Some(length) = fixed_length {
             let input = Arc::new(
-                FixedSizeBinaryArray::try_from_sparse_iter(data.iter().cloned()).unwrap(),
+                FixedSizeBinaryArray::try_from_sparse_iter_with_size(data.iter().cloned(), length)
+                    .unwrap(),
             );
             let sorted = match limit {
                 Some(_) => sort_limit(&(input as ArrayRef), options, limit).unwrap(),
                 None => sort(&(input as ArrayRef), options).unwrap(),
             };
             let expected = Arc::new(
-                FixedSizeBinaryArray::try_from_sparse_iter(expected_data.iter().cloned())
-                    .unwrap(),
+                FixedSizeBinaryArray::try_from_sparse_iter_with_size(
+                    expected_data.iter().cloned(),
+                    length,
+                )
+                .unwrap(),
             ) as ArrayRef;
 
             assert_eq!(&sorted, &expected);
@@ -1380,6 +1187,19 @@ mod tests {
             None,
             vec![0, 5, 3, 1, 4, 2],
         );
+        test_sort_to_indices_primitive_arrays::<Float16Type>(
+            vec![
+                None,
+                Some(f16::from_f32(-0.05)),
+                Some(f16::from_f32(2.225)),
+                Some(f16::from_f32(-1.01)),
+                Some(f16::from_f32(-0.05)),
+                None,
+            ],
+            None,
+            None,
+            vec![0, 5, 3, 1, 4, 2],
+        );
         test_sort_to_indices_primitive_arrays::<Float32Type>(
             vec![
                 None,
@@ -1415,7 +1235,7 @@ mod tests {
                 nulls_first: false,
             }),
             None,
-            vec![2, 1, 4, 3, 5, 0], // [2, 4, 1, 3, 5, 0]
+            vec![2, 1, 4, 3, 0, 5],
         );
 
         test_sort_to_indices_primitive_arrays::<Int16Type>(
@@ -1425,7 +1245,7 @@ mod tests {
                 nulls_first: false,
             }),
             None,
-            vec![2, 1, 4, 3, 5, 0],
+            vec![2, 1, 4, 3, 0, 5],
         );
 
         test_sort_to_indices_primitive_arrays::<Int32Type>(
@@ -1435,7 +1255,7 @@ mod tests {
                 nulls_first: false,
             }),
             None,
-            vec![2, 1, 4, 3, 5, 0],
+            vec![2, 1, 4, 3, 0, 5],
         );
 
         test_sort_to_indices_primitive_arrays::<Int64Type>(
@@ -1445,7 +1265,24 @@ mod tests {
                 nulls_first: false,
             }),
             None,
-            vec![2, 1, 4, 3, 5, 0],
+            vec![2, 1, 4, 3, 0, 5],
+        );
+
+        test_sort_to_indices_primitive_arrays::<Float16Type>(
+            vec![
+                None,
+                Some(f16::from_f32(0.005)),
+                Some(f16::from_f32(20.22)),
+                Some(f16::from_f32(-10.3)),
+                Some(f16::from_f32(0.005)),
+                None,
+            ],
+            Some(SortOptions {
+                descending: true,
+                nulls_first: false,
+            }),
+            None,
+            vec![2, 1, 4, 3, 0, 5],
         );
 
         test_sort_to_indices_primitive_arrays::<Float32Type>(
@@ -1462,7 +1299,7 @@ mod tests {
                 nulls_first: false,
             }),
             None,
-            vec![2, 1, 4, 3, 5, 0],
+            vec![2, 1, 4, 3, 0, 5],
         );
 
         test_sort_to_indices_primitive_arrays::<Float64Type>(
@@ -1472,7 +1309,7 @@ mod tests {
                 nulls_first: false,
             }),
             None,
-            vec![2, 1, 4, 3, 5, 0],
+            vec![2, 1, 4, 3, 0, 5],
         );
 
         // descending, nulls first
@@ -1483,7 +1320,7 @@ mod tests {
                 nulls_first: true,
             }),
             None,
-            vec![5, 0, 2, 1, 4, 3], // [5, 0, 2, 4, 1, 3]
+            vec![0, 5, 2, 1, 4, 3], // [5, 0, 2, 4, 1, 3]
         );
 
         test_sort_to_indices_primitive_arrays::<Int16Type>(
@@ -1493,7 +1330,7 @@ mod tests {
                 nulls_first: true,
             }),
             None,
-            vec![5, 0, 2, 1, 4, 3], // [5, 0, 2, 4, 1, 3]
+            vec![0, 5, 2, 1, 4, 3], // [5, 0, 2, 4, 1, 3]
         );
 
         test_sort_to_indices_primitive_arrays::<Int32Type>(
@@ -1503,7 +1340,7 @@ mod tests {
                 nulls_first: true,
             }),
             None,
-            vec![5, 0, 2, 1, 4, 3],
+            vec![0, 5, 2, 1, 4, 3],
         );
 
         test_sort_to_indices_primitive_arrays::<Int64Type>(
@@ -1513,7 +1350,24 @@ mod tests {
                 nulls_first: true,
             }),
             None,
-            vec![5, 0, 2, 1, 4, 3],
+            vec![0, 5, 2, 1, 4, 3],
+        );
+
+        test_sort_to_indices_primitive_arrays::<Float16Type>(
+            vec![
+                None,
+                Some(f16::from_f32(0.1)),
+                Some(f16::from_f32(0.2)),
+                Some(f16::from_f32(-1.3)),
+                Some(f16::from_f32(0.01)),
+                None,
+            ],
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            None,
+            vec![0, 5, 2, 1, 4, 3],
         );
 
         test_sort_to_indices_primitive_arrays::<Float32Type>(
@@ -1523,7 +1377,7 @@ mod tests {
                 nulls_first: true,
             }),
             None,
-            vec![5, 0, 2, 1, 4, 3],
+            vec![0, 5, 2, 1, 4, 3],
         );
 
         test_sort_to_indices_primitive_arrays::<Float64Type>(
@@ -1533,7 +1387,7 @@ mod tests {
                 nulls_first: true,
             }),
             None,
-            vec![5, 0, 2, 1, 4, 3],
+            vec![0, 5, 2, 1, 4, 3],
         );
 
         // valid values less than limit with extra nulls
@@ -1610,7 +1464,7 @@ mod tests {
                 nulls_first: false,
             }),
             None,
-            vec![2, 3, 1, 4, 5, 0],
+            vec![2, 3, 1, 4, 0, 5],
         );
 
         // boolean, descending, nulls first
@@ -1621,7 +1475,7 @@ mod tests {
                 nulls_first: true,
             }),
             None,
-            vec![5, 0, 2, 3, 1, 4],
+            vec![0, 5, 2, 3, 1, 4],
         );
 
         // boolean, descending, nulls first, limit
@@ -1632,7 +1486,7 @@ mod tests {
                 nulls_first: true,
             }),
             Some(3),
-            vec![5, 0, 2],
+            vec![0, 5, 2],
         );
 
         // valid values less than limit with extra nulls
@@ -1681,34 +1535,34 @@ mod tests {
     #[test]
     fn test_sort_indices_decimal128() {
         // decimal default
-        test_sort_to_indices_decimal_array(
+        test_sort_to_indices_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             None,
             None,
             vec![0, 6, 4, 2, 3, 5, 1],
         );
         // decimal descending
-        test_sort_to_indices_decimal_array(
+        test_sort_to_indices_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: true,
                 nulls_first: false,
             }),
             None,
-            vec![1, 5, 3, 2, 4, 6, 0],
+            vec![1, 5, 3, 2, 4, 0, 6],
         );
         // decimal null_first and descending
-        test_sort_to_indices_decimal_array(
+        test_sort_to_indices_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: true,
                 nulls_first: true,
             }),
             None,
-            vec![6, 0, 1, 5, 3, 2, 4],
+            vec![0, 6, 1, 5, 3, 2, 4],
         );
         // decimal null_first
-        test_sort_to_indices_decimal_array(
+        test_sort_to_indices_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: false,
@@ -1718,14 +1572,14 @@ mod tests {
             vec![0, 6, 4, 2, 3, 5, 1],
         );
         // limit
-        test_sort_to_indices_decimal_array(
+        test_sort_to_indices_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             None,
             Some(3),
             vec![0, 6, 4],
         );
         // limit descending
-        test_sort_to_indices_decimal_array(
+        test_sort_to_indices_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: true,
@@ -1735,17 +1589,17 @@ mod tests {
             vec![1, 5, 3],
         );
         // limit descending null_first
-        test_sort_to_indices_decimal_array(
+        test_sort_to_indices_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: true,
                 nulls_first: true,
             }),
             Some(3),
-            vec![6, 0, 1],
+            vec![0, 6, 1],
         );
         // limit null_first
-        test_sort_to_indices_decimal_array(
+        test_sort_to_indices_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: false,
@@ -1756,17 +1610,145 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_sort_indices_decimal256() {
+        let data = vec![
+            None,
+            Some(i256::from_i128(5)),
+            Some(i256::from_i128(2)),
+            Some(i256::from_i128(3)),
+            Some(i256::from_i128(1)),
+            Some(i256::from_i128(4)),
+            None,
+        ];
+
+        // decimal default
+        test_sort_to_indices_decimal256_array(data.clone(), None, None, vec![0, 6, 4, 2, 3, 5, 1]);
+        // decimal descending
+        test_sort_to_indices_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: true,
+                nulls_first: false,
+            }),
+            None,
+            vec![1, 5, 3, 2, 4, 0, 6],
+        );
+        // decimal null_first and descending
+        test_sort_to_indices_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            None,
+            vec![0, 6, 1, 5, 3, 2, 4],
+        );
+        // decimal null_first
+        test_sort_to_indices_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: false,
+                nulls_first: true,
+            }),
+            None,
+            vec![0, 6, 4, 2, 3, 5, 1],
+        );
+        // limit
+        test_sort_to_indices_decimal256_array(data.clone(), None, Some(3), vec![0, 6, 4]);
+        // limit descending
+        test_sort_to_indices_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: true,
+                nulls_first: false,
+            }),
+            Some(3),
+            vec![1, 5, 3],
+        );
+        // limit descending null_first
+        test_sort_to_indices_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            Some(3),
+            vec![0, 6, 1],
+        );
+        // limit null_first
+        test_sort_to_indices_decimal256_array(
+            data,
+            Some(SortOptions {
+                descending: false,
+                nulls_first: true,
+            }),
+            Some(3),
+            vec![0, 6, 4],
+        );
+    }
+
+    #[test]
+    fn test_sort_indices_decimal256_max_min() {
+        let data = vec![
+            None,
+            Some(i256::MIN),
+            Some(i256::from_i128(1)),
+            Some(i256::MAX),
+            Some(i256::from_i128(-1)),
+        ];
+        test_sort_to_indices_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: false,
+                nulls_first: true,
+            }),
+            None,
+            vec![0, 1, 4, 2, 3],
+        );
+
+        test_sort_to_indices_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            None,
+            vec![0, 3, 2, 4, 1],
+        );
+
+        test_sort_to_indices_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: false,
+                nulls_first: true,
+            }),
+            Some(4),
+            vec![0, 1, 4, 2],
+        );
+
+        test_sort_to_indices_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            Some(4),
+            vec![0, 3, 2, 4],
+        );
+    }
+
     #[test]
     fn test_sort_decimal128() {
         // decimal default
-        test_sort_decimal_array(
+        test_sort_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             None,
             None,
             vec![None, None, Some(1), Some(2), Some(3), Some(4), Some(5)],
         );
         // decimal descending
-        test_sort_decimal_array(
+        test_sort_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: true,
@@ -1776,7 +1758,7 @@ mod tests {
             vec![Some(5), Some(4), Some(3), Some(2), Some(1), None, None],
         );
         // decimal null_first and descending
-        test_sort_decimal_array(
+        test_sort_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: true,
@@ -1786,7 +1768,7 @@ mod tests {
             vec![None, None, Some(5), Some(4), Some(3), Some(2), Some(1)],
         );
         // decimal null_first
-        test_sort_decimal_array(
+        test_sort_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: false,
@@ -1796,14 +1778,14 @@ mod tests {
             vec![None, None, Some(1), Some(2), Some(3), Some(4), Some(5)],
         );
         // limit
-        test_sort_decimal_array(
+        test_sort_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             None,
             Some(3),
             vec![None, None, Some(1)],
         );
         // limit descending
-        test_sort_decimal_array(
+        test_sort_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: true,
@@ -1813,7 +1795,7 @@ mod tests {
             vec![Some(5), Some(4), Some(3)],
         );
         // limit descending null_first
-        test_sort_decimal_array(
+        test_sort_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: true,
@@ -1823,7 +1805,7 @@ mod tests {
             vec![None, None, Some(5)],
         );
         // limit null_first
-        test_sort_decimal_array(
+        test_sort_decimal128_array(
             vec![None, Some(5), Some(2), Some(3), Some(1), Some(4), None],
             Some(SortOptions {
                 descending: false,
@@ -1834,6 +1816,202 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_sort_decimal256() {
+        let data = vec![
+            None,
+            Some(i256::from_i128(5)),
+            Some(i256::from_i128(2)),
+            Some(i256::from_i128(3)),
+            Some(i256::from_i128(1)),
+            Some(i256::from_i128(4)),
+            None,
+        ];
+        // decimal default
+        test_sort_decimal256_array(
+            data.clone(),
+            None,
+            None,
+            [None, None, Some(1), Some(2), Some(3), Some(4), Some(5)]
+                .iter()
+                .map(|v| v.map(i256::from_i128))
+                .collect(),
+        );
+        // decimal descending
+        test_sort_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: true,
+                nulls_first: false,
+            }),
+            None,
+            [Some(5), Some(4), Some(3), Some(2), Some(1), None, None]
+                .iter()
+                .map(|v| v.map(i256::from_i128))
+                .collect(),
+        );
+        // decimal null_first and descending
+        test_sort_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            None,
+            [None, None, Some(5), Some(4), Some(3), Some(2), Some(1)]
+                .iter()
+                .map(|v| v.map(i256::from_i128))
+                .collect(),
+        );
+        // decimal null_first
+        test_sort_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: false,
+                nulls_first: true,
+            }),
+            None,
+            [None, None, Some(1), Some(2), Some(3), Some(4), Some(5)]
+                .iter()
+                .map(|v| v.map(i256::from_i128))
+                .collect(),
+        );
+        // limit
+        test_sort_decimal256_array(
+            data.clone(),
+            None,
+            Some(3),
+            [None, None, Some(1)]
+                .iter()
+                .map(|v| v.map(i256::from_i128))
+                .collect(),
+        );
+        // limit descending
+        test_sort_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: true,
+                nulls_first: false,
+            }),
+            Some(3),
+            [Some(5), Some(4), Some(3)]
+                .iter()
+                .map(|v| v.map(i256::from_i128))
+                .collect(),
+        );
+        // limit descending null_first
+        test_sort_decimal256_array(
+            data.clone(),
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            Some(3),
+            [None, None, Some(5)]
+                .iter()
+                .map(|v| v.map(i256::from_i128))
+                .collect(),
+        );
+        // limit null_first
+        test_sort_decimal256_array(
+            data,
+            Some(SortOptions {
+                descending: false,
+                nulls_first: true,
+            }),
+            Some(3),
+            [None, None, Some(1)]
+                .iter()
+                .map(|v| v.map(i256::from_i128))
+                .collect(),
+        );
+    }
+
+    #[test]
+    fn test_sort_decimal256_max_min() {
+        test_sort_decimal256_array(
+            vec![
+                None,
+                Some(i256::MIN),
+                Some(i256::from_i128(1)),
+                Some(i256::MAX),
+                Some(i256::from_i128(-1)),
+                None,
+            ],
+            Some(SortOptions {
+                descending: false,
+                nulls_first: true,
+            }),
+            None,
+            vec![
+                None,
+                None,
+                Some(i256::MIN),
+                Some(i256::from_i128(-1)),
+                Some(i256::from_i128(1)),
+                Some(i256::MAX),
+            ],
+        );
+
+        test_sort_decimal256_array(
+            vec![
+                None,
+                Some(i256::MIN),
+                Some(i256::from_i128(1)),
+                Some(i256::MAX),
+                Some(i256::from_i128(-1)),
+                None,
+            ],
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            None,
+            vec![
+                None,
+                None,
+                Some(i256::MAX),
+                Some(i256::from_i128(1)),
+                Some(i256::from_i128(-1)),
+                Some(i256::MIN),
+            ],
+        );
+
+        test_sort_decimal256_array(
+            vec![
+                None,
+                Some(i256::MIN),
+                Some(i256::from_i128(1)),
+                Some(i256::MAX),
+                Some(i256::from_i128(-1)),
+                None,
+            ],
+            Some(SortOptions {
+                descending: false,
+                nulls_first: true,
+            }),
+            Some(4),
+            vec![None, None, Some(i256::MIN), Some(i256::from_i128(-1))],
+        );
+
+        test_sort_decimal256_array(
+            vec![
+                None,
+                Some(i256::MIN),
+                Some(i256::from_i128(1)),
+                Some(i256::MAX),
+                Some(i256::from_i128(-1)),
+                None,
+            ],
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            Some(4),
+            vec![None, None, Some(i256::MAX), Some(i256::from_i128(1))],
+        );
+    }
+
     #[test]
     fn test_sort_primitives() {
         // default case
@@ -1938,14 +2116,38 @@ mod tests {
             vec![None, None, Some(2), Some(0), Some(0), Some(-1)],
         );
 
-        test_sort_primitive_arrays::<Int64Type>(
-            vec![None, Some(0), Some(2), Some(-1), Some(0), None],
+        test_sort_primitive_arrays::<Int64Type>(
+            vec![None, Some(0), Some(2), Some(-1), Some(0), None],
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            Some(3),
+            vec![None, None, Some(2)],
+        );
+
+        test_sort_primitive_arrays::<Float16Type>(
+            vec![
+                None,
+                Some(f16::from_f32(0.0)),
+                Some(f16::from_f32(2.0)),
+                Some(f16::from_f32(-1.0)),
+                Some(f16::from_f32(0.0)),
+                None,
+            ],
             Some(SortOptions {
                 descending: true,
                 nulls_first: true,
             }),
-            Some(3),
-            vec![None, None, Some(2)],
+            None,
+            vec![
+                None,
+                None,
+                Some(f16::from_f32(2.0)),
+                Some(f16::from_f32(0.0)),
+                Some(f16::from_f32(0.0)),
+                Some(f16::from_f32(-1.0)),
+            ],
         );
 
         test_sort_primitive_arrays::<Float32Type>(
@@ -2013,6 +2215,29 @@ mod tests {
             None,
             vec![None, None, Some(-1), Some(0), Some(0), Some(2)],
         );
+        test_sort_primitive_arrays::<Float16Type>(
+            vec![
+                None,
+                Some(f16::from_f32(0.0)),
+                Some(f16::from_f32(2.0)),
+                Some(f16::from_f32(-1.0)),
+                Some(f16::from_f32(0.0)),
+                None,
+            ],
+            Some(SortOptions {
+                descending: false,
+                nulls_first: true,
+            }),
+            None,
+            vec![
+                None,
+                None,
+                Some(f16::from_f32(-1.0)),
+                Some(f16::from_f32(0.0)),
+                Some(f16::from_f32(0.0)),
+                Some(f16::from_f32(2.0)),
+            ],
+        );
         test_sort_primitive_arrays::<Float32Type>(
             vec![None, Some(0.0), Some(2.0), Some(-1.0), Some(0.0), None],
             Some(SortOptions {
@@ -2136,7 +2361,7 @@ mod tests {
                 nulls_first: false,
             }),
             None,
-            vec![2, 4, 1, 5, 3, 0],
+            vec![2, 4, 1, 5, 0, 3],
         );
 
         test_sort_to_indices_string_arrays(
@@ -2170,7 +2395,7 @@ mod tests {
                 nulls_first: true,
             }),
             None,
-            vec![3, 0, 2, 4, 1, 5],
+            vec![0, 3, 2, 4, 1, 5],
         );
 
         test_sort_to_indices_string_arrays(
@@ -2187,7 +2412,7 @@ mod tests {
                 nulls_first: true,
             }),
             Some(3),
-            vec![3, 0, 2],
+            vec![0, 3, 2],
         );
 
         // valid values less than limit with extra nulls
@@ -2388,6 +2613,118 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_sort_run_to_run() {
+        test_sort_run_inner(|array, sort_options, limit| sort_run(array, sort_options, limit));
+    }
+
+    #[test]
+    fn test_sort_run_to_indices() {
+        test_sort_run_inner(|array, sort_options, limit| {
+            let indices = sort_to_indices(array, sort_options, limit).unwrap();
+            take(array, &indices, None)
+        });
+    }
+
+    fn test_sort_run_inner<F>(sort_fn: F)
+    where
+        F: Fn(&dyn Array, Option<SortOptions>, Option<usize>) -> Result<ArrayRef, ArrowError>,
+    {
+        // Create an input array for testing
+        let total_len = 80;
+        let vals: Vec<Option<i32>> = vec![Some(1), None, Some(2), Some(3), Some(4), None, Some(5)];
+        let repeats: Vec<usize> = vec![1, 3, 2, 4];
+        let mut input_array: Vec<Option<i32>> = Vec::with_capacity(total_len);
+        for ix in 0_usize..32 {
+            let repeat: usize = repeats[ix % repeats.len()];
+            let val: Option<i32> = vals[ix % vals.len()];
+            input_array.resize(input_array.len() + repeat, val);
+        }
+
+        // create run array using input_array
+        // Encode the input_array to run array
+        let mut builder =
+            PrimitiveRunBuilder::<Int16Type, Int32Type>::with_capacity(input_array.len());
+        builder.extend(input_array.iter().copied());
+        let run_array = builder.finish();
+
+        // slice lengths that are tested
+        let slice_lens = [
+            1, 2, 3, 4, 5, 6, 7, 37, 38, 39, 40, 41, 42, 43, 74, 75, 76, 77, 78, 79, 80,
+        ];
+        for slice_len in slice_lens {
+            test_sort_run_inner2(
+                input_array.as_slice(),
+                &run_array,
+                0,
+                slice_len,
+                None,
+                &sort_fn,
+            );
+            test_sort_run_inner2(
+                input_array.as_slice(),
+                &run_array,
+                total_len - slice_len,
+                slice_len,
+                None,
+                &sort_fn,
+            );
+            // Test with non zero limit
+            if slice_len > 1 {
+                test_sort_run_inner2(
+                    input_array.as_slice(),
+                    &run_array,
+                    0,
+                    slice_len,
+                    Some(slice_len / 2),
+                    &sort_fn,
+                );
+                test_sort_run_inner2(
+                    input_array.as_slice(),
+                    &run_array,
+                    total_len - slice_len,
+                    slice_len,
+                    Some(slice_len / 2),
+                    &sort_fn,
+                );
+            }
+        }
+    }
+
+    fn test_sort_run_inner2<F>(
+        input_array: &[Option<i32>],
+        run_array: &RunArray<Int16Type>,
+        offset: usize,
+        length: usize,
+        limit: Option<usize>,
+        sort_fn: &F,
+    ) where
+        F: Fn(&dyn Array, Option<SortOptions>, Option<usize>) -> Result<ArrayRef, ArrowError>,
+    {
+        // Run the sort and build actual result
+        let sliced_array = run_array.slice(offset, length);
+        let sorted_sliced_array = sort_fn(&sliced_array, None, limit).unwrap();
+        let sorted_run_array = sorted_sliced_array
+            .as_any()
+            .downcast_ref::<RunArray<Int16Type>>()
+            .unwrap();
+        let typed_run_array = sorted_run_array
+            .downcast::<PrimitiveArray<Int32Type>>()
+            .unwrap();
+        let actual: Vec<Option<i32>> = typed_run_array.into_iter().collect();
+
+        // build expected result.
+        let mut sliced_input = input_array[offset..(offset + length)].to_owned();
+        sliced_input.sort();
+        let expected = if let Some(limit) = limit {
+            sliced_input.iter().take(limit).copied().collect()
+        } else {
+            sliced_input
+        };
+
+        assert_eq!(expected, actual)
+    }
+
     #[test]
     fn test_sort_string_dicts() {
         test_sort_string_dict_arrays::<Int8Type>(
@@ -2566,6 +2903,57 @@ mod tests {
             Some(1),
         );
 
+        test_sort_list_arrays::<Float16Type>(
+            vec![
+                Some(vec![Some(f16::from_f32(1.0)), Some(f16::from_f32(0.0))]),
+                Some(vec![
+                    Some(f16::from_f32(4.0)),
+                    Some(f16::from_f32(3.0)),
+                    Some(f16::from_f32(2.0)),
+                    Some(f16::from_f32(1.0)),
+                ]),
+                Some(vec![
+                    Some(f16::from_f32(2.0)),
+                    Some(f16::from_f32(3.0)),
+                    Some(f16::from_f32(4.0)),
+                ]),
+                Some(vec![
+                    Some(f16::from_f32(3.0)),
+                    Some(f16::from_f32(3.0)),
+                    Some(f16::from_f32(3.0)),
+                    Some(f16::from_f32(3.0)),
+                ]),
+                Some(vec![Some(f16::from_f32(1.0)), Some(f16::from_f32(1.0))]),
+            ],
+            Some(SortOptions {
+                descending: false,
+                nulls_first: false,
+            }),
+            None,
+            vec![
+                Some(vec![Some(f16::from_f32(1.0)), Some(f16::from_f32(0.0))]),
+                Some(vec![Some(f16::from_f32(1.0)), Some(f16::from_f32(1.0))]),
+                Some(vec![
+                    Some(f16::from_f32(2.0)),
+                    Some(f16::from_f32(3.0)),
+                    Some(f16::from_f32(4.0)),
+                ]),
+                Some(vec![
+                    Some(f16::from_f32(3.0)),
+                    Some(f16::from_f32(3.0)),
+                    Some(f16::from_f32(3.0)),
+                    Some(f16::from_f32(3.0)),
+                ]),
+                Some(vec![
+                    Some(f16::from_f32(4.0)),
+                    Some(f16::from_f32(3.0)),
+                    Some(f16::from_f32(2.0)),
+                    Some(f16::from_f32(1.0)),
+                ]),
+            ],
+            None,
+        );
+
         test_sort_list_arrays::<Float32Type>(
             vec![
                 Some(vec![Some(1.0), Some(0.0)]),
@@ -2937,8 +3325,10 @@ mod tests {
             Some(2),
             Some(17),
         ])) as ArrayRef];
-        test_lex_sort_arrays(input.clone(), expected, None);
+        test_lex_sort_arrays(input.clone(), expected.clone(), None);
+        test_lex_sort_arrays(input.clone(), slice_arrays(expected, 0, 2), Some(2));
 
+        // Explicitly test a limit on the sort as a demonstration
         let expected = vec![Arc::new(PrimitiveArray::<Int64Type>::from(vec![
             Some(-1),
             Some(0),
@@ -3017,7 +3407,8 @@ mod tests {
                 Some(-2),
             ])) as ArrayRef,
         ];
-        test_lex_sort_arrays(input, expected, None);
+        test_lex_sort_arrays(input.clone(), expected.clone(), None);
+        test_lex_sort_arrays(input, slice_arrays(expected, 0, 2), Some(2));
 
         // test mix of string and in64 with option
         let input = vec![
@@ -3060,7 +3451,8 @@ mod tests {
                 Some("7"),
             ])) as ArrayRef,
         ];
-        test_lex_sort_arrays(input, expected, None);
+        test_lex_sort_arrays(input.clone(), expected.clone(), None);
+        test_lex_sort_arrays(input, slice_arrays(expected, 0, 3), Some(3));
 
         // test sort with nulls first
         let input = vec![
@@ -3103,7 +3495,8 @@ mod tests {
                 Some("world"),
             ])) as ArrayRef,
         ];
-        test_lex_sort_arrays(input, expected, None);
+        test_lex_sort_arrays(input.clone(), expected.clone(), None);
+        test_lex_sort_arrays(input, slice_arrays(expected, 0, 1), Some(1));
 
         // test sort with nulls last
         let input = vec![
@@ -3146,7 +3539,8 @@ mod tests {
                 None,
             ])) as ArrayRef,
         ];
-        test_lex_sort_arrays(input, expected, None);
+        test_lex_sort_arrays(input.clone(), expected.clone(), None);
+        test_lex_sort_arrays(input, slice_arrays(expected, 0, 2), Some(2));
 
         // test sort with opposite options
         let input = vec![
@@ -3193,7 +3587,11 @@ mod tests {
                 Some("foo"),
             ])) as ArrayRef,
         ];
-        test_lex_sort_arrays(input, expected, None);
+        test_lex_sort_arrays(input.clone(), expected.clone(), None);
+        test_lex_sort_arrays(input.clone(), slice_arrays(expected.clone(), 0, 5), Some(5));
+
+        // Limiting by more rows than present is ok
+        test_lex_sort_arrays(input, slice_arrays(expected, 0, 5), Some(10));
     }
 
     #[test]
@@ -3222,4 +3620,325 @@ mod tests {
         partial_sort(&mut before, last, |a, b| a.cmp(b));
         assert_eq!(&d[0..last], &before[0..last]);
     }
+
+    #[test]
+    fn test_sort_int8_dicts() {
+        let keys = Int8Array::from(vec![Some(1_i8), None, Some(2), None, Some(2), Some(0)]);
+        let values = Int8Array::from(vec![1, 3, 5]);
+        test_sort_primitive_dict_arrays::<Int8Type, Int8Type>(
+            keys,
+            values,
+            None,
+            None,
+            vec![None, None, Some(1), Some(3), Some(5), Some(5)],
+        );
+
+        let keys = Int8Array::from(vec![Some(1_i8), None, Some(2), None, Some(2), Some(0)]);
+        let values = Int8Array::from(vec![1, 3, 5]);
+        test_sort_primitive_dict_arrays::<Int8Type, Int8Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: true,
+                nulls_first: false,
+            }),
+            None,
+            vec![Some(5), Some(5), Some(3), Some(1), None, None],
+        );
+
+        let keys = Int8Array::from(vec![Some(1_i8), None, Some(2), None, Some(2), Some(0)]);
+        let values = Int8Array::from(vec![1, 3, 5]);
+        test_sort_primitive_dict_arrays::<Int8Type, Int8Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: false,
+                nulls_first: false,
+            }),
+            None,
+            vec![Some(1), Some(3), Some(5), Some(5), None, None],
+        );
+
+        let keys = Int8Array::from(vec![Some(1_i8), None, Some(2), None, Some(2), Some(0)]);
+        let values = Int8Array::from(vec![1, 3, 5]);
+        test_sort_primitive_dict_arrays::<Int8Type, Int8Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            Some(3),
+            vec![None, None, Some(5)],
+        );
+
+        // Values have `None`.
+        let keys = Int8Array::from(vec![
+            Some(1_i8),
+            None,
+            Some(3),
+            None,
+            Some(2),
+            Some(3),
+            Some(0),
+        ]);
+        let values = Int8Array::from(vec![Some(1), Some(3), None, Some(5)]);
+        test_sort_primitive_dict_arrays::<Int8Type, Int8Type>(
+            keys,
+            values,
+            None,
+            None,
+            vec![None, None, None, Some(1), Some(3), Some(5), Some(5)],
+        );
+
+        let keys = Int8Array::from(vec![
+            Some(1_i8),
+            None,
+            Some(3),
+            None,
+            Some(2),
+            Some(3),
+            Some(0),
+        ]);
+        let values = Int8Array::from(vec![Some(1), Some(3), None, Some(5)]);
+        test_sort_primitive_dict_arrays::<Int8Type, Int8Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: false,
+                nulls_first: false,
+            }),
+            None,
+            vec![Some(1), Some(3), Some(5), Some(5), None, None, None],
+        );
+
+        let keys = Int8Array::from(vec![
+            Some(1_i8),
+            None,
+            Some(3),
+            None,
+            Some(2),
+            Some(3),
+            Some(0),
+        ]);
+        let values = Int8Array::from(vec![Some(1), Some(3), None, Some(5)]);
+        test_sort_primitive_dict_arrays::<Int8Type, Int8Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: true,
+                nulls_first: false,
+            }),
+            None,
+            vec![Some(5), Some(5), Some(3), Some(1), None, None, None],
+        );
+
+        let keys = Int8Array::from(vec![
+            Some(1_i8),
+            None,
+            Some(3),
+            None,
+            Some(2),
+            Some(3),
+            Some(0),
+        ]);
+        let values = Int8Array::from(vec![Some(1), Some(3), None, Some(5)]);
+        test_sort_primitive_dict_arrays::<Int8Type, Int8Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            None,
+            vec![None, None, None, Some(5), Some(5), Some(3), Some(1)],
+        );
+    }
+
+    #[test]
+    fn test_sort_f32_dicts() {
+        let keys = Int8Array::from(vec![Some(1_i8), None, Some(2), None, Some(2), Some(0)]);
+        let values = Float32Array::from(vec![1.2, 3.0, 5.1]);
+        test_sort_primitive_dict_arrays::<Int8Type, Float32Type>(
+            keys,
+            values,
+            None,
+            None,
+            vec![None, None, Some(1.2), Some(3.0), Some(5.1), Some(5.1)],
+        );
+
+        let keys = Int8Array::from(vec![Some(1_i8), None, Some(2), None, Some(2), Some(0)]);
+        let values = Float32Array::from(vec![1.2, 3.0, 5.1]);
+        test_sort_primitive_dict_arrays::<Int8Type, Float32Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: true,
+                nulls_first: false,
+            }),
+            None,
+            vec![Some(5.1), Some(5.1), Some(3.0), Some(1.2), None, None],
+        );
+
+        let keys = Int8Array::from(vec![Some(1_i8), None, Some(2), None, Some(2), Some(0)]);
+        let values = Float32Array::from(vec![1.2, 3.0, 5.1]);
+        test_sort_primitive_dict_arrays::<Int8Type, Float32Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: false,
+                nulls_first: false,
+            }),
+            None,
+            vec![Some(1.2), Some(3.0), Some(5.1), Some(5.1), None, None],
+        );
+
+        let keys = Int8Array::from(vec![Some(1_i8), None, Some(2), None, Some(2), Some(0)]);
+        let values = Float32Array::from(vec![1.2, 3.0, 5.1]);
+        test_sort_primitive_dict_arrays::<Int8Type, Float32Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            Some(3),
+            vec![None, None, Some(5.1)],
+        );
+
+        // Values have `None`.
+        let keys = Int8Array::from(vec![
+            Some(1_i8),
+            None,
+            Some(3),
+            None,
+            Some(2),
+            Some(3),
+            Some(0),
+        ]);
+        let values = Float32Array::from(vec![Some(1.2), Some(3.0), None, Some(5.1)]);
+        test_sort_primitive_dict_arrays::<Int8Type, Float32Type>(
+            keys,
+            values,
+            None,
+            None,
+            vec![None, None, None, Some(1.2), Some(3.0), Some(5.1), Some(5.1)],
+        );
+
+        let keys = Int8Array::from(vec![
+            Some(1_i8),
+            None,
+            Some(3),
+            None,
+            Some(2),
+            Some(3),
+            Some(0),
+        ]);
+        let values = Float32Array::from(vec![Some(1.2), Some(3.0), None, Some(5.1)]);
+        test_sort_primitive_dict_arrays::<Int8Type, Float32Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: false,
+                nulls_first: false,
+            }),
+            None,
+            vec![Some(1.2), Some(3.0), Some(5.1), Some(5.1), None, None, None],
+        );
+
+        let keys = Int8Array::from(vec![
+            Some(1_i8),
+            None,
+            Some(3),
+            None,
+            Some(2),
+            Some(3),
+            Some(0),
+        ]);
+        let values = Float32Array::from(vec![Some(1.2), Some(3.0), None, Some(5.1)]);
+        test_sort_primitive_dict_arrays::<Int8Type, Float32Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: true,
+                nulls_first: false,
+            }),
+            None,
+            vec![Some(5.1), Some(5.1), Some(3.0), Some(1.2), None, None, None],
+        );
+
+        let keys = Int8Array::from(vec![
+            Some(1_i8),
+            None,
+            Some(3),
+            None,
+            Some(2),
+            Some(3),
+            Some(0),
+        ]);
+        let values = Float32Array::from(vec![Some(1.2), Some(3.0), None, Some(5.1)]);
+        test_sort_primitive_dict_arrays::<Int8Type, Float32Type>(
+            keys,
+            values,
+            Some(SortOptions {
+                descending: true,
+                nulls_first: true,
+            }),
+            None,
+            vec![None, None, None, Some(5.1), Some(5.1), Some(3.0), Some(1.2)],
+        );
+    }
+
+    #[test]
+    fn test_lexicographic_comparator_null_dict_values() {
+        let values = Int32Array::new(
+            vec![1, 2, 3, 4].into(),
+            Some(NullBuffer::from(vec![true, false, false, true])),
+        );
+        let keys = Int32Array::new(
+            vec![0, 1, 53, 3].into(),
+            Some(NullBuffer::from(vec![true, true, false, true])),
+        );
+        // [1, NULL, NULL, 4]
+        let dict = DictionaryArray::new(keys, Arc::new(values));
+
+        let comparator = LexicographicalComparator::try_new(&[SortColumn {
+            values: Arc::new(dict),
+            options: None,
+        }])
+        .unwrap();
+        // 1.cmp(NULL)
+        assert_eq!(comparator.compare(0, 1), Ordering::Greater);
+        // NULL.cmp(NULL)
+        assert_eq!(comparator.compare(2, 1), Ordering::Equal);
+        // NULL.cmp(4)
+        assert_eq!(comparator.compare(2, 3), Ordering::Less);
+    }
+
+    #[test]
+    fn sort_list_equal() {
+        let a = {
+            let mut builder = FixedSizeListBuilder::new(Int64Builder::new(), 2);
+            for value in [[1, 5], [0, 3], [1, 3]] {
+                builder.values().append_slice(&value);
+                builder.append(true);
+            }
+            builder.finish()
+        };
+
+        let sort_indices = sort_to_indices(&a, None, None).unwrap();
+        assert_eq!(sort_indices.values(), &[1, 2, 0]);
+
+        let a = {
+            let mut builder = ListBuilder::new(Int64Builder::new());
+            for value in [[1, 5], [0, 3], [1, 3]] {
+                builder.values().append_slice(&value);
+                builder.append(true);
+            }
+            builder.finish()
+        };
+
+        let sort_indices = sort_to_indices(&a, None, None).unwrap();
+        assert_eq!(sort_indices.values(), &[1, 2, 0]);
+    }
 }
diff --git a/arrow-pyarrow-integration-testing/Cargo.toml b/arrow-pyarrow-integration-testing/Cargo.toml
index 19117ba5f03e..8c60c086c29a 100644
--- a/arrow-pyarrow-integration-testing/Cargo.toml
+++ b/arrow-pyarrow-integration-testing/Cargo.toml
@@ -18,7 +18,7 @@
 [package]
 name = "arrow-pyarrow-integration-testing"
 description = ""
-version = "20.0.0"
+version = "0.1.0"
 homepage = "https://github.com/apache/arrow-rs"
 repository = "https://github.com/apache/arrow-rs"
 authors = ["Apache Arrow <dev@arrow.apache.org>"]
@@ -26,14 +26,12 @@ license = "Apache-2.0"
 keywords = [ "arrow" ]
 edition = "2021"
 rust-version = "1.62"
+publish = false
 
 [lib]
 name = "arrow_pyarrow_integration_testing"
 crate-type = ["cdylib"]
 
 [dependencies]
-arrow = { path = "../arrow", version = "20.0.0", features = ["pyarrow"] }
-pyo3 = { version = "0.16", features = ["extension-module"] }
-
-[package.metadata.maturin]
-requires-dist = ["pyarrow>=1"]
+arrow = { path = "../arrow", features = ["pyarrow"] }
+pyo3 = { version = "0.20", features = ["extension-module"] }
diff --git a/arrow-pyarrow-integration-testing/README.md b/arrow-pyarrow-integration-testing/README.md
index e63953ad7900..5ca2ea76b88c 100644
--- a/arrow-pyarrow-integration-testing/README.md
+++ b/arrow-pyarrow-integration-testing/README.md
@@ -25,6 +25,7 @@ Note that this crate uses two languages and an external ABI:
 * `Rust`
 * `Python`
 * C ABI privately exposed by `Pyarrow`.
+* PyCapsule ABI publicly exposed by `pyarrow`
 
 ## Basic idea
 
@@ -36,6 +37,7 @@ we can use pyarrow's interface to move pointers from and to Rust.
 ## Relevant literature
 
 * [Arrow's CDataInterface](https://arrow.apache.org/docs/format/CDataInterface.html)
+* [Arrow PyCapsule Interface](https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html)
 * [Rust's FFI](https://doc.rust-lang.org/nomicon/ffi.html)
 * [Pyarrow private binds](https://github.com/apache/arrow/blob/ae1d24efcc3f1ac2a876d8d9f544a34eb04ae874/python/pyarrow/array.pxi#L1226)
 * [PyO3](https://docs.rs/pyo3/0.12.1/pyo3/index.html)
diff --git a/arrow-pyarrow-integration-testing/pyproject.toml b/arrow-pyarrow-integration-testing/pyproject.toml
index 27480690e06c..d85db24c2e18 100644
--- a/arrow-pyarrow-integration-testing/pyproject.toml
+++ b/arrow-pyarrow-integration-testing/pyproject.toml
@@ -16,5 +16,7 @@
 # under the License.
 
 [build-system]
-requires = ["maturin"]
+requires = ["maturin>=1.0,<2.0"]
 build-backend = "maturin"
+
+dependencies = ["pyarrow>=1"]
diff --git a/arrow-pyarrow-integration-testing/src/lib.rs b/arrow-pyarrow-integration-testing/src/lib.rs
index 086b21834657..a53447b53c31 100644
--- a/arrow-pyarrow-integration-testing/src/lib.rs
+++ b/arrow-pyarrow-integration-testing/src/lib.rs
@@ -20,32 +20,41 @@
 
 use std::sync::Arc;
 
+use arrow::array::new_empty_array;
+use arrow::record_batch::{RecordBatchIterator, RecordBatchReader};
+use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
 use pyo3::wrap_pyfunction;
 
-use arrow::array::{ArrayData, ArrayRef, Int64Array};
+use arrow::array::{make_array, Array, ArrayData, ArrayRef, Int64Array};
 use arrow::compute::kernels;
 use arrow::datatypes::{DataType, Field, Schema};
 use arrow::error::ArrowError;
 use arrow::ffi_stream::ArrowArrayStreamReader;
-use arrow::pyarrow::PyArrowConvert;
+use arrow::pyarrow::{FromPyArrow, PyArrowException, PyArrowType, ToPyArrow};
 use arrow::record_batch::RecordBatch;
 
+fn to_py_err(err: ArrowError) -> PyErr {
+    PyArrowException::new_err(err.to_string())
+}
+
 /// Returns `array + array` of an int64 array.
 #[pyfunction]
 fn double(array: &PyAny, py: Python) -> PyResult<PyObject> {
     // import
-    let array = ArrayRef::from_pyarrow(array)?;
+    let array = make_array(ArrayData::from_pyarrow(array)?);
 
     // perform some operation
     let array = array
         .as_any()
         .downcast_ref::<Int64Array>()
-        .ok_or(ArrowError::ParseError("Expects an int64".to_string()))?;
-    let array = kernels::arithmetic::add(array, array)?;
+        .ok_or_else(|| ArrowError::ParseError("Expects an int64".to_string()))
+        .map_err(to_py_err)?;
+
+    let array = kernels::numeric::add(array, array).map_err(to_py_err)?;
 
     // export
-    array.to_pyarrow(py)
+    array.to_data().to_pyarrow(py)
 }
 
 /// calls a lambda function that receives and returns an array
@@ -57,72 +66,112 @@ fn double_py(lambda: &PyAny, py: Python) -> PyResult<bool> {
     let expected = Arc::new(Int64Array::from(vec![Some(2), None, Some(6)])) as ArrayRef;
 
     // to py
-    let pyarray = array.to_pyarrow(py)?;
+    let pyarray = array.to_data().to_pyarrow(py)?;
     let pyarray = lambda.call1((pyarray,))?;
-    let array = ArrayRef::from_pyarrow(pyarray)?;
+    let array = make_array(ArrayData::from_pyarrow(pyarray)?);
 
     Ok(array == expected)
 }
 
+#[pyfunction]
+fn make_empty_array(datatype: PyArrowType<DataType>, py: Python) -> PyResult<PyObject> {
+    let array = new_empty_array(&datatype.0);
+
+    array.to_data().to_pyarrow(py)
+}
+
 /// Returns the substring
 #[pyfunction]
-fn substring(array: ArrayData, start: i64) -> PyResult<ArrayData> {
+fn substring(
+    array: PyArrowType<ArrayData>,
+    start: i64,
+) -> PyResult<PyArrowType<ArrayData>> {
     // import
-    let array = ArrayRef::from(array);
+    let array = make_array(array.0);
 
     // substring
-    let array = kernels::substring::substring(array.as_ref(), start, None)?;
+    let array =
+        kernels::substring::substring(array.as_ref(), start, None).map_err(to_py_err)?;
 
-    Ok(array.data().to_owned())
+    Ok(array.to_data().into())
 }
 
 /// Returns the concatenate
 #[pyfunction]
-fn concatenate(array: ArrayData, py: Python) -> PyResult<PyObject> {
-    let array = ArrayRef::from(array);
+fn concatenate(array: PyArrowType<ArrayData>, py: Python) -> PyResult<PyObject> {
+    let array = make_array(array.0);
 
     // concat
-    let array = kernels::concat::concat(&[array.as_ref(), array.as_ref()])?;
+    let array =
+        kernels::concat::concat(&[array.as_ref(), array.as_ref()]).map_err(to_py_err)?;
 
-    array.to_pyarrow(py)
+    array.to_data().to_pyarrow(py)
 }
 
 #[pyfunction]
-fn round_trip_type(obj: DataType) -> PyResult<DataType> {
+fn round_trip_type(obj: PyArrowType<DataType>) -> PyResult<PyArrowType<DataType>> {
     Ok(obj)
 }
 
 #[pyfunction]
-fn round_trip_field(obj: Field) -> PyResult<Field> {
+fn round_trip_field(obj: PyArrowType<Field>) -> PyResult<PyArrowType<Field>> {
     Ok(obj)
 }
 
 #[pyfunction]
-fn round_trip_schema(obj: Schema) -> PyResult<Schema> {
+fn round_trip_schema(obj: PyArrowType<Schema>) -> PyResult<PyArrowType<Schema>> {
     Ok(obj)
 }
 
 #[pyfunction]
-fn round_trip_array(obj: ArrayData) -> PyResult<ArrayData> {
+fn round_trip_array(obj: PyArrowType<ArrayData>) -> PyResult<PyArrowType<ArrayData>> {
     Ok(obj)
 }
 
 #[pyfunction]
-fn round_trip_record_batch(obj: RecordBatch) -> PyResult<RecordBatch> {
+fn round_trip_record_batch(
+    obj: PyArrowType<RecordBatch>,
+) -> PyResult<PyArrowType<RecordBatch>> {
     Ok(obj)
 }
 
 #[pyfunction]
 fn round_trip_record_batch_reader(
-    obj: ArrowArrayStreamReader,
-) -> PyResult<ArrowArrayStreamReader> {
+    obj: PyArrowType<ArrowArrayStreamReader>,
+) -> PyResult<PyArrowType<ArrowArrayStreamReader>> {
     Ok(obj)
 }
 
+#[pyfunction]
+fn reader_return_errors(obj: PyArrowType<ArrowArrayStreamReader>) -> PyResult<()> {
+    // This makes sure we can correctly consume a RBR and return the error,
+    // ensuring the error can live beyond the lifetime of the RBR.
+    let batches = obj.0.collect::<Result<Vec<RecordBatch>, ArrowError>>();
+    match batches {
+        Ok(_) => Ok(()),
+        Err(err) => Err(PyValueError::new_err(err.to_string())),
+    }
+}
+
+#[pyfunction]
+fn boxed_reader_roundtrip(
+    obj: PyArrowType<ArrowArrayStreamReader>,
+) -> PyArrowType<Box<dyn RecordBatchReader + Send>> {
+    let schema = obj.0.schema();
+    let batches = obj
+        .0
+        .collect::<Result<Vec<RecordBatch>, ArrowError>>()
+        .unwrap();
+    let reader = RecordBatchIterator::new(batches.into_iter().map(Ok), schema);
+    let reader: Box<dyn RecordBatchReader + Send> = Box::new(reader);
+    PyArrowType(reader)
+}
+
 #[pymodule]
 fn arrow_pyarrow_integration_testing(_py: Python, m: &PyModule) -> PyResult<()> {
     m.add_wrapped(wrap_pyfunction!(double))?;
     m.add_wrapped(wrap_pyfunction!(double_py))?;
+    m.add_wrapped(wrap_pyfunction!(make_empty_array))?;
     m.add_wrapped(wrap_pyfunction!(substring))?;
     m.add_wrapped(wrap_pyfunction!(concatenate))?;
     m.add_wrapped(wrap_pyfunction!(round_trip_type))?;
@@ -131,5 +180,7 @@ fn arrow_pyarrow_integration_testing(_py: Python, m: &PyModule) -> PyResult<()>
     m.add_wrapped(wrap_pyfunction!(round_trip_array))?;
     m.add_wrapped(wrap_pyfunction!(round_trip_record_batch))?;
     m.add_wrapped(wrap_pyfunction!(round_trip_record_batch_reader))?;
+    m.add_wrapped(wrap_pyfunction!(reader_return_errors))?;
+    m.add_wrapped(wrap_pyfunction!(boxed_reader_roundtrip))?;
     Ok(())
 }
diff --git a/arrow-pyarrow-integration-testing/tests/test_sql.py b/arrow-pyarrow-integration-testing/tests/test_sql.py
index a19edf0ccd03..5320d0a5343e 100644
--- a/arrow-pyarrow-integration-testing/tests/test_sql.py
+++ b/arrow-pyarrow-integration-testing/tests/test_sql.py
@@ -27,6 +27,8 @@
 
 import arrow_pyarrow_integration_testing as rust
 
+PYARROW_PRE_14 = int(pa.__version__.split('.')[0]) < 14
+
 
 @contextlib.contextmanager
 def no_pyarrow_leak():
@@ -63,6 +65,7 @@ def assert_pyarrow_leak():
     pa.float32(),
     pa.float64(),
     pa.decimal128(19, 4),
+    pa.decimal256(76, 38),
     pa.string(),
     pa.binary(),
     pa.binary(10),
@@ -87,10 +90,6 @@ def assert_pyarrow_leak():
     ),
     pa.dictionary(pa.int8(), pa.string()),
     pa.map_(pa.string(), pa.int32()),
-]
-
-_unsupported_pyarrow_types = [
-    pa.decimal256(76, 38),
     pa.union(
         [pa.field("a", pa.binary(10)), pa.field("b", pa.string())],
         mode=pa.lib.UnionMode_DENSE,
@@ -113,6 +112,37 @@ def assert_pyarrow_leak():
     ),
 ]
 
+_unsupported_pyarrow_types = [
+]
+
+# As of pyarrow 14, pyarrow implements the Arrow PyCapsule interface
+# (https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html).
+# This defines that Arrow consumers should allow any object that has specific "dunder"
+# methods, `__arrow_c_*_`. These wrapper classes ensure that arrow-rs is able to handle
+# _any_ class, without pyarrow-specific handling.
+class SchemaWrapper:
+    def __init__(self, schema):
+        self.schema = schema
+
+    def __arrow_c_schema__(self):
+        return self.schema.__arrow_c_schema__()
+
+
+class ArrayWrapper:
+    def __init__(self, array):
+        self.array = array
+
+    def __arrow_c_array__(self):
+        return self.array.__arrow_c_array__()
+
+
+class StreamWrapper:
+    def __init__(self, stream):
+        self.stream = stream
+
+    def __arrow_c_stream__(self):
+        return self.stream.__arrow_c_stream__()
+
 
 @pytest.mark.parametrize("pyarrow_type", _supported_pyarrow_types, ids=str)
 def test_type_roundtrip(pyarrow_type):
@@ -120,6 +150,14 @@ def test_type_roundtrip(pyarrow_type):
     assert restored == pyarrow_type
     assert restored is not pyarrow_type
 
+@pytest.mark.skipif(PYARROW_PRE_14, reason="requires pyarrow 14")
+@pytest.mark.parametrize("pyarrow_type", _supported_pyarrow_types, ids=str)
+def test_type_roundtrip_pycapsule(pyarrow_type):
+    wrapped = SchemaWrapper(pyarrow_type)
+    restored = rust.round_trip_type(wrapped)
+    assert restored == pyarrow_type
+    assert restored is not pyarrow_type
+
 
 @pytest.mark.parametrize("pyarrow_type", _unsupported_pyarrow_types, ids=str)
 def test_type_roundtrip_raises(pyarrow_type):
@@ -138,12 +176,33 @@ def test_field_roundtrip(pyarrow_type):
         field = rust.round_trip_field(pyarrow_field)
         assert field == pyarrow_field
 
+@pytest.mark.skipif(PYARROW_PRE_14, reason="requires pyarrow 14")
+@pytest.mark.parametrize('pyarrow_type', _supported_pyarrow_types, ids=str)
+def test_field_roundtrip_pycapsule(pyarrow_type):
+    pyarrow_field = pa.field("test", pyarrow_type, nullable=True)
+    wrapped = SchemaWrapper(pyarrow_field)
+    field = rust.round_trip_field(wrapped)
+    assert field == wrapped.schema
+
+    if pyarrow_type != pa.null():
+        # A null type field may not be non-nullable
+        pyarrow_field = pa.field("test", pyarrow_type, nullable=False)
+        field = rust.round_trip_field(wrapped)
+        assert field == wrapped.schema
+
+def test_field_metadata_roundtrip():
+    metadata = {"hello": "World! 😊", "x": "2"}
+    pyarrow_field = pa.field("test", pa.int32(), metadata=metadata)
+    field = rust.round_trip_field(pyarrow_field)
+    assert field == pyarrow_field
+    assert field.metadata == pyarrow_field.metadata
 
 def test_schema_roundtrip():
     pyarrow_fields = zip(string.ascii_lowercase, _supported_pyarrow_types)
-    pyarrow_schema = pa.schema(pyarrow_fields)
+    pyarrow_schema = pa.schema(pyarrow_fields, metadata = {b'key1': b'value1'})
     schema = rust.round_trip_schema(pyarrow_schema)
     assert schema == pyarrow_schema
+    assert schema.metadata == pyarrow_schema.metadata
 
 
 def test_primitive_python():
@@ -157,6 +216,17 @@ def test_primitive_python():
     del b
 
 
+@pytest.mark.skipif(PYARROW_PRE_14, reason="requires pyarrow 14")
+def test_primitive_python_pycapsule():
+    """
+    Python -> Rust -> Python
+    """
+    a = pa.array([1, 2, 3])
+    wrapped = ArrayWrapper(a)
+    b = rust.double(wrapped)
+    assert b == pa.array([2, 4, 6])
+
+
 def test_primitive_rust():
     """
     Rust -> Python -> Rust
@@ -193,6 +263,44 @@ def test_time32_python():
     del b
     del expected
 
+
+@pytest.mark.parametrize("datatype", _supported_pyarrow_types, ids=str)
+def test_empty_array_python(datatype):
+    """
+    Python -> Rust -> Python
+    """
+    if datatype == pa.float16():
+        pytest.skip("Float 16 is not implemented in Rust")
+
+    if type(datatype) is pa.lib.DenseUnionType or type(datatype) is pa.lib.SparseUnionType:
+        pytest.skip("Union is not implemented in Python")
+
+    a = pa.array([], datatype)
+    b = rust.round_trip_array(a)
+    b.validate(full=True)
+    assert a.to_pylist() == b.to_pylist()
+    assert a.type == b.type
+    del a
+    del b
+
+
+@pytest.mark.parametrize("datatype", _supported_pyarrow_types, ids=str)
+def test_empty_array_rust(datatype):
+    """
+    Rust -> Python
+    """
+    if type(datatype) is pa.lib.DenseUnionType or type(datatype) is pa.lib.SparseUnionType:
+        pytest.skip("Union is not implemented in Python")
+
+    a = pa.array([], type=datatype)
+    b = rust.make_empty_array(datatype)
+    b.validate(full=True)
+    assert a.to_pylist() == b.to_pylist()
+    assert a.type == b.type
+    del a
+    del b
+
+
 def test_binary_array():
     """
     Python -> Rust -> Python
@@ -320,6 +428,54 @@ def test_dictionary_python():
     del a
     del b
 
+def test_dense_union_python():
+    """
+    Python -> Rust -> Python
+    """
+    xs = pa.array([5, 6, 7])
+    ys = pa.array([False, True])
+    types = pa.array([0, 1, 1, 0, 0], type=pa.int8())
+    offsets = pa.array([0, 0, 1, 1, 2], type=pa.int32())
+    a = pa.UnionArray.from_dense(types, offsets, [xs, ys])
+
+    b = rust.round_trip_array(a)
+    assert a == b
+    del a
+    del b
+
+def test_sparse_union_python():
+    """
+    Python -> Rust -> Python
+    """
+    xs = pa.array([5, 6, 7])
+    ys = pa.array([False, False, True])
+    types = pa.array([0, 1, 1], type=pa.int8())
+    a = pa.UnionArray.from_sparse(types, [xs, ys])
+
+    b = rust.round_trip_array(a)
+    assert a == b
+    del a
+    del b
+
+def test_tensor_array():
+    tensor_type = pa.fixed_shape_tensor(pa.float32(), [2, 3])
+    inner = pa.array([float(x) for x in range(1, 7)] + [None] * 12, pa.float32())
+    storage = pa.FixedSizeListArray.from_arrays(inner, 6)
+    f32_array = pa.ExtensionArray.from_storage(tensor_type, storage)
+
+    # Round-tripping as an array gives back storage type, because arrow-rs has
+    # no notion of extension types.
+    b = rust.round_trip_array(f32_array)
+    assert b == f32_array.storage
+
+    batch = pa.record_batch([f32_array], ["tensor"], metadata={b'key1': b'value1'})
+    b = rust.round_trip_record_batch(batch)
+    assert b == batch
+    assert b.schema == batch.schema
+    assert b.schema.metadata == batch.schema.metadata
+
+    del b
+
 def test_record_batch_reader():
     """
     Python -> Rust -> Python
@@ -333,5 +489,125 @@ def test_record_batch_reader():
     b = rust.round_trip_record_batch_reader(a)
 
     assert b.schema == schema
+    assert b.schema.metadata == schema.metadata
+    got_batches = list(b)
+    assert got_batches == batches
+
+    # Also try the boxed reader variant
+    a = pa.RecordBatchReader.from_batches(schema, batches)
+    b = rust.boxed_reader_roundtrip(a)
+    assert b.schema == schema
+    assert b.schema.metadata == schema.metadata
+    got_batches = list(b)
+    assert got_batches == batches
+
+@pytest.mark.skipif(PYARROW_PRE_14, reason="requires pyarrow 14")
+def test_record_batch_reader_pycapsule():
+    """
+    Python -> Rust -> Python
+    """
+    schema = pa.schema([('ints', pa.list_(pa.int32()))], metadata={b'key1': b'value1'})
+    batches = [
+        pa.record_batch([[[1], [2, 42]]], schema),
+        pa.record_batch([[None, [], [5, 6]]], schema),
+    ]
+    a = pa.RecordBatchReader.from_batches(schema, batches)
+    wrapped = StreamWrapper(a)
+    b = rust.round_trip_record_batch_reader(wrapped)
+
+    assert b.schema == schema
+    assert b.schema.metadata == schema.metadata
+    got_batches = list(b)
+    assert got_batches == batches
+
+    # Also try the boxed reader variant
+    a = pa.RecordBatchReader.from_batches(schema, batches)
+    wrapped = StreamWrapper(a)
+    b = rust.boxed_reader_roundtrip(wrapped)
+    assert b.schema == schema
+    assert b.schema.metadata == schema.metadata
     got_batches = list(b)
     assert got_batches == batches
+
+
+def test_record_batch_reader_error():
+    schema = pa.schema([('ints', pa.list_(pa.int32()))])
+
+    def iter_batches():
+        yield pa.record_batch([[[1], [2, 42]]], schema)
+        raise ValueError("test error")
+
+    reader = pa.RecordBatchReader.from_batches(schema, iter_batches())
+
+    with pytest.raises(ValueError, match="test error"):
+        rust.reader_return_errors(reader)
+
+    # Due to a long-standing oversight, PyArrow allows binary values in schema
+    # metadata that are not valid UTF-8. This is not allowed in Rust, but we
+    # make sure we error and not panic here.
+    schema = schema.with_metadata({"key": b"\xff"})
+    reader = pa.RecordBatchReader.from_batches(schema, iter_batches())
+    with pytest.raises(ValueError, match="invalid utf-8"):
+        rust.round_trip_record_batch_reader(reader)
+
+
+@pytest.mark.skipif(PYARROW_PRE_14, reason="requires pyarrow 14")
+def test_record_batch_pycapsule():
+    """
+    Python -> Rust -> Python
+    """
+    schema = pa.schema([('ints', pa.list_(pa.int32()))], metadata={b'key1': b'value1'})
+    batch = pa.record_batch([[[1], [2, 42]]], schema)
+    wrapped = StreamWrapper(batch)
+    b = rust.round_trip_record_batch_reader(wrapped)
+    new_table = b.read_all()
+    new_batches = new_table.to_batches()
+
+    assert len(new_batches) == 1
+    new_batch = new_batches[0]
+
+    assert batch == new_batch
+    assert batch.schema == new_batch.schema
+
+
+@pytest.mark.skipif(PYARROW_PRE_14, reason="requires pyarrow 14")
+def test_table_pycapsule():
+    """
+    Python -> Rust -> Python
+    """
+    schema = pa.schema([('ints', pa.list_(pa.int32()))], metadata={b'key1': b'value1'})
+    batches = [
+        pa.record_batch([[[1], [2, 42]]], schema),
+        pa.record_batch([[None, [], [5, 6]]], schema),
+    ]
+    table = pa.Table.from_batches(batches)
+    wrapped = StreamWrapper(table)
+    b = rust.round_trip_record_batch_reader(wrapped)
+    new_table = b.read_all()
+
+    assert table.schema == new_table.schema
+    assert table == new_table
+    assert len(table.to_batches()) == len(new_table.to_batches())
+
+
+def test_reject_other_classes():
+    # Arbitrary type that is not a PyArrow type
+    not_pyarrow = ["hello"]
+
+    with pytest.raises(TypeError, match="Expected instance of pyarrow.lib.Array, got builtins.list"):
+        rust.round_trip_array(not_pyarrow)
+
+    with pytest.raises(TypeError, match="Expected instance of pyarrow.lib.Schema, got builtins.list"):
+        rust.round_trip_schema(not_pyarrow)
+
+    with pytest.raises(TypeError, match="Expected instance of pyarrow.lib.Field, got builtins.list"):
+        rust.round_trip_field(not_pyarrow)
+
+    with pytest.raises(TypeError, match="Expected instance of pyarrow.lib.DataType, got builtins.list"):
+        rust.round_trip_type(not_pyarrow)
+
+    with pytest.raises(TypeError, match="Expected instance of pyarrow.lib.RecordBatch, got builtins.list"):
+        rust.round_trip_record_batch(not_pyarrow)
+
+    with pytest.raises(TypeError, match="Expected instance of pyarrow.lib.RecordBatchReader, got builtins.list"):
+        rust.round_trip_record_batch_reader(not_pyarrow)
diff --git a/arrow-row/Cargo.toml b/arrow-row/Cargo.toml
new file mode 100644
index 000000000000..dcf624f8b7d1
--- /dev/null
+++ b/arrow-row/Cargo.toml
@@ -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.
+
+[package]
+name = "arrow-row"
+version = { workspace = true }
+description = "Arrow row format"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_row"
+path = "src/lib.rs"
+bench = false
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+ahash = { version = "0.8", default-features = false, features = ["compile-time-rng"] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+ahash = { version = "0.8", default-features = false, features = ["runtime-rng"] }
+
+[dependencies]
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-data = { workspace = true }
+arrow-schema = { workspace = true }
+
+half = { version = "2.1", default-features = false }
+hashbrown = { version = "0.14", default-features = false }
+
+[dev-dependencies]
+arrow-cast = { workspace = true }
+arrow-ord = { workspace = true }
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
+
+[features]
+
diff --git a/arrow-row/src/fixed.rs b/arrow-row/src/fixed.rs
new file mode 100644
index 000000000000..831105bd5f15
--- /dev/null
+++ b/arrow-row/src/fixed.rs
@@ -0,0 +1,386 @@
+// 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.
+
+use crate::array::PrimitiveArray;
+use crate::null_sentinel;
+use arrow_array::builder::BufferBuilder;
+use arrow_array::{ArrowPrimitiveType, BooleanArray, FixedSizeBinaryArray};
+use arrow_buffer::{bit_util, i256, ArrowNativeType, Buffer, MutableBuffer};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{DataType, SortOptions};
+use half::f16;
+
+pub trait FromSlice {
+    fn from_slice(slice: &[u8], invert: bool) -> Self;
+}
+
+impl<const N: usize> FromSlice for [u8; N] {
+    #[inline]
+    fn from_slice(slice: &[u8], invert: bool) -> Self {
+        let mut t: Self = slice.try_into().unwrap();
+        if invert {
+            t.iter_mut().for_each(|o| *o = !*o);
+        }
+        t
+    }
+}
+
+/// Encodes a value of a particular fixed width type into bytes according to the rules
+/// described on [`super::RowConverter`]
+pub trait FixedLengthEncoding: Copy {
+    const ENCODED_LEN: usize = 1 + std::mem::size_of::<Self::Encoded>();
+
+    type Encoded: Sized + Copy + FromSlice + AsRef<[u8]> + AsMut<[u8]>;
+
+    fn encode(self) -> Self::Encoded;
+
+    fn decode(encoded: Self::Encoded) -> Self;
+}
+
+impl FixedLengthEncoding for bool {
+    type Encoded = [u8; 1];
+
+    fn encode(self) -> [u8; 1] {
+        [self as u8]
+    }
+
+    fn decode(encoded: Self::Encoded) -> Self {
+        encoded[0] != 0
+    }
+}
+
+macro_rules! encode_signed {
+    ($n:expr, $t:ty) => {
+        impl FixedLengthEncoding for $t {
+            type Encoded = [u8; $n];
+
+            fn encode(self) -> [u8; $n] {
+                let mut b = self.to_be_bytes();
+                // Toggle top "sign" bit to ensure consistent sort order
+                b[0] ^= 0x80;
+                b
+            }
+
+            fn decode(mut encoded: Self::Encoded) -> Self {
+                // Toggle top "sign" bit
+                encoded[0] ^= 0x80;
+                Self::from_be_bytes(encoded)
+            }
+        }
+    };
+}
+
+encode_signed!(1, i8);
+encode_signed!(2, i16);
+encode_signed!(4, i32);
+encode_signed!(8, i64);
+encode_signed!(16, i128);
+encode_signed!(32, i256);
+
+macro_rules! encode_unsigned {
+    ($n:expr, $t:ty) => {
+        impl FixedLengthEncoding for $t {
+            type Encoded = [u8; $n];
+
+            fn encode(self) -> [u8; $n] {
+                self.to_be_bytes()
+            }
+
+            fn decode(encoded: Self::Encoded) -> Self {
+                Self::from_be_bytes(encoded)
+            }
+        }
+    };
+}
+
+encode_unsigned!(1, u8);
+encode_unsigned!(2, u16);
+encode_unsigned!(4, u32);
+encode_unsigned!(8, u64);
+
+impl FixedLengthEncoding for f16 {
+    type Encoded = [u8; 2];
+
+    fn encode(self) -> [u8; 2] {
+        // https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
+        let s = self.to_bits() as i16;
+        let val = s ^ (((s >> 15) as u16) >> 1) as i16;
+        val.encode()
+    }
+
+    fn decode(encoded: Self::Encoded) -> Self {
+        let bits = i16::decode(encoded);
+        let val = bits ^ (((bits >> 15) as u16) >> 1) as i16;
+        Self::from_bits(val as u16)
+    }
+}
+
+impl FixedLengthEncoding for f32 {
+    type Encoded = [u8; 4];
+
+    fn encode(self) -> [u8; 4] {
+        // https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
+        let s = self.to_bits() as i32;
+        let val = s ^ (((s >> 31) as u32) >> 1) as i32;
+        val.encode()
+    }
+
+    fn decode(encoded: Self::Encoded) -> Self {
+        let bits = i32::decode(encoded);
+        let val = bits ^ (((bits >> 31) as u32) >> 1) as i32;
+        Self::from_bits(val as u32)
+    }
+}
+
+impl FixedLengthEncoding for f64 {
+    type Encoded = [u8; 8];
+
+    fn encode(self) -> [u8; 8] {
+        // https://github.com/rust-lang/rust/blob/9c20b2a8cc7588decb6de25ac6a7912dcef24d65/library/core/src/num/f32.rs#L1176-L1260
+        let s = self.to_bits() as i64;
+        let val = s ^ (((s >> 63) as u64) >> 1) as i64;
+        val.encode()
+    }
+
+    fn decode(encoded: Self::Encoded) -> Self {
+        let bits = i64::decode(encoded);
+        let val = bits ^ (((bits >> 63) as u64) >> 1) as i64;
+        Self::from_bits(val as u64)
+    }
+}
+
+/// Returns the total encoded length (including null byte) for a value of type `T::Native`
+pub const fn encoded_len<T>(_col: &PrimitiveArray<T>) -> usize
+where
+    T: ArrowPrimitiveType,
+    T::Native: FixedLengthEncoding,
+{
+    T::Native::ENCODED_LEN
+}
+
+/// Fixed width types are encoded as
+///
+/// - 1 byte `0` if null or `1` if valid
+/// - bytes of [`FixedLengthEncoding`]
+pub fn encode<T: FixedLengthEncoding, I: IntoIterator<Item = Option<T>>>(
+    data: &mut [u8],
+    offsets: &mut [usize],
+    i: I,
+    opts: SortOptions,
+) {
+    for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(i) {
+        let end_offset = *offset + T::ENCODED_LEN;
+        if let Some(val) = maybe_val {
+            let to_write = &mut data[*offset..end_offset];
+            to_write[0] = 1;
+            let mut encoded = val.encode();
+            if opts.descending {
+                // Flip bits to reverse order
+                encoded.as_mut().iter_mut().for_each(|v| *v = !*v)
+            }
+            to_write[1..].copy_from_slice(encoded.as_ref())
+        } else {
+            data[*offset] = null_sentinel(opts);
+        }
+        *offset = end_offset;
+    }
+}
+
+pub fn encode_fixed_size_binary(
+    data: &mut [u8],
+    offsets: &mut [usize],
+    array: &FixedSizeBinaryArray,
+    opts: SortOptions,
+) {
+    let len = array.value_length() as usize;
+    for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(array.iter()) {
+        let end_offset = *offset + len + 1;
+        if let Some(val) = maybe_val {
+            let to_write = &mut data[*offset..end_offset];
+            to_write[0] = 1;
+            to_write[1..].copy_from_slice(&val[..len]);
+            if opts.descending {
+                // Flip bits to reverse order
+                to_write[1..1 + len].iter_mut().for_each(|v| *v = !*v)
+            }
+        } else {
+            data[*offset] = null_sentinel(opts);
+        }
+        *offset = end_offset;
+    }
+}
+
+/// Splits `len` bytes from `src`
+#[inline]
+fn split_off<'a>(src: &mut &'a [u8], len: usize) -> &'a [u8] {
+    let v = &src[..len];
+    *src = &src[len..];
+    v
+}
+
+/// Decodes a `BooleanArray` from rows
+pub fn decode_bool(rows: &mut [&[u8]], options: SortOptions) -> BooleanArray {
+    let true_val = match options.descending {
+        true => !1,
+        false => 1,
+    };
+
+    let len = rows.len();
+
+    let mut null_count = 0;
+    let mut nulls = MutableBuffer::new(bit_util::ceil(len, 64) * 8);
+    let mut values = MutableBuffer::new(bit_util::ceil(len, 64) * 8);
+
+    let chunks = len / 64;
+    let remainder = len % 64;
+    for chunk in 0..chunks {
+        let mut null_packed = 0;
+        let mut values_packed = 0;
+
+        for bit_idx in 0..64 {
+            let i = split_off(&mut rows[bit_idx + chunk * 64], 2);
+            let (null, value) = (i[0] == 1, i[1] == true_val);
+            null_count += !null as usize;
+            null_packed |= (null as u64) << bit_idx;
+            values_packed |= (value as u64) << bit_idx;
+        }
+
+        nulls.push(null_packed);
+        values.push(values_packed);
+    }
+
+    if remainder != 0 {
+        let mut null_packed = 0;
+        let mut values_packed = 0;
+
+        for bit_idx in 0..remainder {
+            let i = split_off(&mut rows[bit_idx + chunks * 64], 2);
+            let (null, value) = (i[0] == 1, i[1] == true_val);
+            null_count += !null as usize;
+            null_packed |= (null as u64) << bit_idx;
+            values_packed |= (value as u64) << bit_idx;
+        }
+
+        nulls.push(null_packed);
+        values.push(values_packed);
+    }
+
+    let builder = ArrayDataBuilder::new(DataType::Boolean)
+        .len(rows.len())
+        .null_count(null_count)
+        .add_buffer(values.into())
+        .null_bit_buffer(Some(nulls.into()));
+
+    // SAFETY:
+    // Buffers are the correct length
+    unsafe { BooleanArray::from(builder.build_unchecked()) }
+}
+
+/// Decodes a single byte from each row, interpreting `0x01` as a valid value
+/// and all other values as a null
+///
+/// Returns the null count and null buffer
+pub fn decode_nulls(rows: &[&[u8]]) -> (usize, Buffer) {
+    let mut null_count = 0;
+    let buffer = MutableBuffer::collect_bool(rows.len(), |idx| {
+        let valid = rows[idx][0] == 1;
+        null_count += !valid as usize;
+        valid
+    })
+    .into();
+    (null_count, buffer)
+}
+
+/// Decodes a `ArrayData` from rows based on the provided `FixedLengthEncoding` `T`
+///
+/// # Safety
+///
+/// `data_type` must be appropriate native type for `T`
+unsafe fn decode_fixed<T: FixedLengthEncoding + ArrowNativeType>(
+    rows: &mut [&[u8]],
+    data_type: DataType,
+    options: SortOptions,
+) -> ArrayData {
+    let len = rows.len();
+
+    let mut values = BufferBuilder::<T>::new(len);
+    let (null_count, nulls) = decode_nulls(rows);
+
+    for row in rows {
+        let i = split_off(row, T::ENCODED_LEN);
+        let value = T::Encoded::from_slice(&i[1..], options.descending);
+        values.append(T::decode(value));
+    }
+
+    let builder = ArrayDataBuilder::new(data_type)
+        .len(len)
+        .null_count(null_count)
+        .add_buffer(values.finish())
+        .null_bit_buffer(Some(nulls));
+
+    // SAFETY: Buffers correct length
+    builder.build_unchecked()
+}
+
+/// Decodes a `PrimitiveArray` from rows
+pub fn decode_primitive<T: ArrowPrimitiveType>(
+    rows: &mut [&[u8]],
+    data_type: DataType,
+    options: SortOptions,
+) -> PrimitiveArray<T>
+where
+    T::Native: FixedLengthEncoding,
+{
+    assert!(PrimitiveArray::<T>::is_compatible(&data_type));
+    // SAFETY:
+    // Validated data type above
+    unsafe { decode_fixed::<T::Native>(rows, data_type, options).into() }
+}
+
+/// Decodes a `FixedLengthBinary` from rows
+pub fn decode_fixed_size_binary(
+    rows: &mut [&[u8]],
+    size: i32,
+    options: SortOptions,
+) -> FixedSizeBinaryArray {
+    let len = rows.len();
+
+    let mut values = MutableBuffer::new(size as usize * rows.len());
+    let (null_count, nulls) = decode_nulls(rows);
+
+    let encoded_len = size as usize + 1;
+
+    for row in rows {
+        let i = split_off(row, encoded_len);
+        values.extend_from_slice(&i[1..]);
+    }
+
+    if options.descending {
+        for v in values.as_slice_mut() {
+            *v = !*v;
+        }
+    }
+
+    let builder = ArrayDataBuilder::new(DataType::FixedSizeBinary(size))
+        .len(len)
+        .null_count(null_count)
+        .add_buffer(values.into())
+        .null_bit_buffer(Some(nulls));
+
+    // SAFETY: Buffers correct length
+    unsafe { builder.build_unchecked().into() }
+}
diff --git a/arrow-row/src/lib.rs b/arrow-row/src/lib.rs
new file mode 100644
index 000000000000..6fd92eaf914b
--- /dev/null
+++ b/arrow-row/src/lib.rs
@@ -0,0 +1,2276 @@
+// 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.
+
+//! A comparable row-oriented representation of a collection of [`Array`].
+//!
+//! [`Row`]s are [normalized for sorting], and can therefore be very efficiently [compared],
+//! using [`memcmp`] under the hood, or used in [non-comparison sorts] such as [radix sort].
+//! This makes the row format ideal for implementing efficient multi-column sorting,
+//! grouping, aggregation, windowing and more, as described in more detail
+//! [in this blog post](https://arrow.apache.org/blog/2022/11/07/multi-column-sorts-in-arrow-rust-part-1/).
+//!
+//! For example, given three input [`Array`], [`RowConverter`] creates byte
+//! sequences that [compare] the same as when using [`lexsort`].
+//!
+//! ```text
+//!    ┌─────┐   ┌─────┐   ┌─────┐
+//!    │     │   │     │   │     │
+//!    ├─────┤ ┌ ┼─────┼ ─ ┼─────┼ ┐              ┏━━━━━━━━━━━━━┓
+//!    │     │   │     │   │     │  ─────────────▶┃             ┃
+//!    ├─────┤ └ ┼─────┼ ─ ┼─────┼ ┘              ┗━━━━━━━━━━━━━┛
+//!    │     │   │     │   │     │
+//!    └─────┘   └─────┘   └─────┘
+//!                ...
+//!    ┌─────┐ ┌ ┬─────┬ ─ ┬─────┬ ┐              ┏━━━━━━━━┓
+//!    │     │   │     │   │     │  ─────────────▶┃        ┃
+//!    └─────┘ └ ┴─────┴ ─ ┴─────┴ ┘              ┗━━━━━━━━┛
+//!     UInt64      Utf8     F64
+//!
+//!           Input Arrays                          Row Format
+//!     (Columns)
+//! ```
+//!
+//! _[`Rows`] must be generated by the same [`RowConverter`] for the comparison
+//! to be meaningful._
+//!
+//! # Basic Example
+//! ```
+//! # use std::sync::Arc;
+//! # use arrow_row::{RowConverter, SortField};
+//! # use arrow_array::{ArrayRef, Int32Array, StringArray};
+//! # use arrow_array::cast::{AsArray, as_string_array};
+//! # use arrow_array::types::Int32Type;
+//! # use arrow_schema::DataType;
+//!
+//! let a1 = Arc::new(Int32Array::from_iter_values([-1, -1, 0, 3, 3])) as ArrayRef;
+//! let a2 = Arc::new(StringArray::from_iter_values(["a", "b", "c", "d", "d"])) as ArrayRef;
+//! let arrays = vec![a1, a2];
+//!
+//! // Convert arrays to rows
+//! let converter = RowConverter::new(vec![
+//!     SortField::new(DataType::Int32),
+//!     SortField::new(DataType::Utf8),
+//! ]).unwrap();
+//! let rows = converter.convert_columns(&arrays).unwrap();
+//!
+//! // Compare rows
+//! for i in 0..4 {
+//!     assert!(rows.row(i) <= rows.row(i + 1));
+//! }
+//! assert_eq!(rows.row(3), rows.row(4));
+//!
+//! // Convert rows back to arrays
+//! let converted = converter.convert_rows(&rows).unwrap();
+//! assert_eq!(arrays, converted);
+//!
+//! // Compare rows from different arrays
+//! let a1 = Arc::new(Int32Array::from_iter_values([3, 4])) as ArrayRef;
+//! let a2 = Arc::new(StringArray::from_iter_values(["e", "f"])) as ArrayRef;
+//! let arrays = vec![a1, a2];
+//! let rows2 = converter.convert_columns(&arrays).unwrap();
+//!
+//! assert!(rows.row(4) < rows2.row(0));
+//! assert!(rows.row(4) < rows2.row(1));
+//!
+//! // Convert selection of rows back to arrays
+//! let selection = [rows.row(0), rows2.row(1), rows.row(2), rows2.row(0)];
+//! let converted = converter.convert_rows(selection).unwrap();
+//! let c1 = converted[0].as_primitive::<Int32Type>();
+//! assert_eq!(c1.values(), &[-1, 4, 0, 3]);
+//!
+//! let c2 = converted[1].as_string::<i32>();
+//! let c2_values: Vec<_> = c2.iter().flatten().collect();
+//! assert_eq!(&c2_values, &["a", "f", "c", "e"]);
+//! ```
+//!
+//! # Lexsort
+//!
+//! The row format can also be used to implement a fast multi-column / lexicographic sort
+//!
+//! ```
+//! # use arrow_row::{RowConverter, SortField};
+//! # use arrow_array::{ArrayRef, UInt32Array};
+//! fn lexsort_to_indices(arrays: &[ArrayRef]) -> UInt32Array {
+//!     let fields = arrays
+//!         .iter()
+//!         .map(|a| SortField::new(a.data_type().clone()))
+//!         .collect();
+//!     let converter = RowConverter::new(fields).unwrap();
+//!     let rows = converter.convert_columns(arrays).unwrap();
+//!     let mut sort: Vec<_> = rows.iter().enumerate().collect();
+//!     sort.sort_unstable_by(|(_, a), (_, b)| a.cmp(b));
+//!     UInt32Array::from_iter_values(sort.iter().map(|(i, _)| *i as u32))
+//! }
+//! ```
+//!
+//! [non-comparison sorts]: https://en.wikipedia.org/wiki/Sorting_algorithm#Non-comparison_sorts
+//! [radix sort]: https://en.wikipedia.org/wiki/Radix_sort
+//! [normalized for sorting]: http://wwwlgis.informatik.uni-kl.de/archiv/wwwdvs.informatik.uni-kl.de/courses/DBSREAL/SS2005/Vorlesungsunterlagen/Implementing_Sorting.pdf
+//! [`memcmp`]: https://www.man7.org/linux/man-pages/man3/memcmp.3.html
+//! [`lexsort`]: https://docs.rs/arrow-ord/latest/arrow_ord/sort/fn.lexsort.html
+//! [compared]: PartialOrd
+//! [compare]: PartialOrd
+
+use std::cmp::Ordering;
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
+
+use arrow_array::cast::*;
+use arrow_array::types::ArrowDictionaryKeyType;
+use arrow_array::*;
+use arrow_buffer::ArrowNativeType;
+use arrow_data::ArrayDataBuilder;
+use arrow_schema::*;
+
+use crate::fixed::{decode_bool, decode_fixed_size_binary, decode_primitive};
+use crate::variable::{decode_binary, decode_string};
+
+mod fixed;
+mod list;
+mod variable;
+
+/// Converts [`ArrayRef`] columns into a [row-oriented](self) format.
+///
+/// *Note: The encoding of the row format may change from release to release.*
+///
+/// ## Overview
+///
+/// The row format is a variable length byte sequence created by
+/// concatenating the encoded form of each column. The encoding for
+/// each column depends on its datatype (and sort options).
+///
+/// The encoding is carefully designed in such a way that escaping is
+/// unnecessary: it is never ambiguous as to whether a byte is part of
+/// a sentinel (e.g. null) or a value.
+///
+/// ## Unsigned Integer Encoding
+///
+/// A null integer is encoded as a `0_u8`, followed by a zero-ed number of bytes corresponding
+/// to the integer's length.
+///
+/// A valid integer is encoded as `1_u8`, followed by the big-endian representation of the
+/// integer.
+///
+/// ```text
+///               ┌──┬──┬──┬──┐      ┌──┬──┬──┬──┬──┐
+///    3          │03│00│00│00│      │01│00│00│00│03│
+///               └──┴──┴──┴──┘      └──┴──┴──┴──┴──┘
+///               ┌──┬──┬──┬──┐      ┌──┬──┬──┬──┬──┐
+///   258         │02│01│00│00│      │01│00│00│01│02│
+///               └──┴──┴──┴──┘      └──┴──┴──┴──┴──┘
+///               ┌──┬──┬──┬──┐      ┌──┬──┬──┬──┬──┐
+///  23423        │7F│5B│00│00│      │01│00│00│5B│7F│
+///               └──┴──┴──┴──┘      └──┴──┴──┴──┴──┘
+///               ┌──┬──┬──┬──┐      ┌──┬──┬──┬──┬──┐
+///  NULL         │??│??│??│??│      │00│00│00│00│00│
+///               └──┴──┴──┴──┘      └──┴──┴──┴──┴──┘
+///
+///              32-bit (4 bytes)        Row Format
+///  Value        Little Endian
+/// ```
+///
+/// ## Signed Integer Encoding
+///
+/// Signed integers have their most significant sign bit flipped, and are then encoded in the
+/// same manner as an unsigned integer.
+///
+/// ```text
+///        ┌──┬──┬──┬──┐       ┌──┬──┬──┬──┐       ┌──┬──┬──┬──┬──┐
+///     5  │05│00│00│00│       │05│00│00│80│       │01│80│00│00│05│
+///        └──┴──┴──┴──┘       └──┴──┴──┴──┘       └──┴──┴──┴──┴──┘
+///        ┌──┬──┬──┬──┐       ┌──┬──┬──┬──┐       ┌──┬──┬──┬──┬──┐
+///    -5  │FB│FF│FF│FF│       │FB│FF│FF│7F│       │01│7F│FF│FF│FB│
+///        └──┴──┴──┴──┘       └──┴──┴──┴──┘       └──┴──┴──┴──┴──┘
+///
+///  Value  32-bit (4 bytes)    High bit flipped      Row Format
+///          Little Endian
+/// ```
+///
+/// ## Float Encoding
+///
+/// Floats are converted from IEEE 754 representation to a signed integer representation
+/// by flipping all bar the sign bit if they are negative.
+///
+/// They are then encoded in the same manner as a signed integer.
+///
+/// ## Fixed Length Bytes Encoding
+///
+/// Fixed length bytes are encoded in the same fashion as primitive types above.
+///
+/// For a fixed length array of length `n`:
+///
+/// A null is encoded as `0_u8` null sentinel followed by `n` `0_u8` bytes
+///
+/// A valid value is encoded as `1_u8` followed by the value bytes
+///
+/// ## Variable Length Bytes (including Strings) Encoding
+///
+/// A null is encoded as a `0_u8`.
+///
+/// An empty byte array is encoded as `1_u8`.
+///
+/// A non-null, non-empty byte array is encoded as `2_u8` followed by the byte array
+/// encoded using a block based scheme described below.
+///
+/// The byte array is broken up into fixed-width blocks, each block is written in turn
+/// to the output, followed by `0xFF_u8`. The final block is padded to 32-bytes
+/// with `0_u8` and written to the output, followed by the un-padded length in bytes
+/// of this final block as a `u8`. The first 4 blocks have a length of 8, with subsequent
+/// blocks using a length of 32, this is to reduce space amplification for small strings.
+///
+/// Note the following example encodings use a block size of 4 bytes for brevity:
+///
+/// ```text
+///                       ┌───┬───┬───┬───┬───┬───┐
+///  "MEEP"               │02 │'M'│'E'│'E'│'P'│04 │
+///                       └───┴───┴───┴───┴───┴───┘
+///
+///                       ┌───┐
+///  ""                   │01 |
+///                       └───┘
+///
+///  NULL                 ┌───┐
+///                       │00 │
+///                       └───┘
+///
+/// "Defenestration"      ┌───┬───┬───┬───┬───┬───┐
+///                       │02 │'D'│'e'│'f'│'e'│FF │
+///                       └───┼───┼───┼───┼───┼───┤
+///                           │'n'│'e'│'s'│'t'│FF │
+///                           ├───┼───┼───┼───┼───┤
+///                           │'r'│'a'│'t'│'r'│FF │
+///                           ├───┼───┼───┼───┼───┤
+///                           │'a'│'t'│'i'│'o'│FF │
+///                           ├───┼───┼───┼───┼───┤
+///                           │'n'│00 │00 │00 │01 │
+///                           └───┴───┴───┴───┴───┘
+/// ```
+///
+/// This approach is loosely inspired by [COBS] encoding, and chosen over more traditional
+/// [byte stuffing] as it is more amenable to vectorisation, in particular AVX-256.
+///
+/// ## Dictionary Encoding
+///
+/// Dictionaries are hydrated to their underlying values
+///
+/// ## Struct Encoding
+///
+/// A null is encoded as a `0_u8`.
+///
+/// A valid value is encoded as `1_u8` followed by the row encoding of each child.
+///
+/// This encoding effectively flattens the schema in a depth-first fashion.
+///
+/// For example
+///
+/// ```text
+/// ┌───────┬────────────────────────┬───────┐
+/// │ Int32 │ Struct[Int32, Float32] │ Int32 │
+/// └───────┴────────────────────────┴───────┘
+/// ```
+///
+/// Is encoded as
+///
+/// ```text
+/// ┌───────┬───────────────┬───────┬─────────┬───────┐
+/// │ Int32 │ Null Sentinel │ Int32 │ Float32 │ Int32 │
+/// └───────┴───────────────┴───────┴─────────┴───────┘
+/// ```
+///
+/// ## List Encoding
+///
+/// Lists are encoded by first encoding all child elements to the row format.
+///
+/// A "canonical byte array" is then constructed by concatenating the row
+/// encodings of all their elements into a single binary array, followed
+/// by the lengths of each encoded row, and the number of elements, encoded
+/// as big endian `u32`.
+///
+/// This canonical byte array is then encoded using the variable length byte
+/// encoding described above.
+///
+/// _The lengths are not strictly necessary but greatly simplify decode, they
+/// may be removed in a future iteration_.
+///
+/// For example given:
+///
+/// ```text
+/// [1_u8, 2_u8, 3_u8]
+/// [1_u8, null]
+/// []
+/// null
+/// ```
+///
+/// The elements would be converted to:
+///
+/// ```text
+///     ┌──┬──┐     ┌──┬──┐     ┌──┬──┐     ┌──┬──┐        ┌──┬──┐
+///  1  │01│01│  2  │01│02│  3  │01│03│  1  │01│01│  null  │00│00│
+///     └──┴──┘     └──┴──┘     └──┴──┘     └──┴──┘        └──┴──┘
+///```
+///
+/// Which would be grouped into the following canonical byte arrays:
+///
+/// ```text
+///                         ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┐
+///  [1_u8, 2_u8, 3_u8]     │01│01│01│02│01│03│00│00│00│02│00│00│00│02│00│00│00│02│00│00│00│03│
+///                         └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
+///                          └──── rows ────┘   └───────── row lengths ─────────┘  └─ count ─┘
+///
+///                         ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┐
+///  [1_u8, null]           │01│01│00│00│00│00│00│02│00│00│00│02│00│00│00│02│
+///                         └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘
+///```
+///
+/// With `[]` represented by an empty byte array, and `null` a null byte array.
+///
+/// These byte arrays will then be encoded using the variable length byte encoding
+/// described above.
+///
+/// # Ordering
+///
+/// ## Float Ordering
+///
+/// Floats are totally ordered in accordance to the `totalOrder` predicate as defined
+/// in the IEEE 754 (2008 revision) floating point standard.
+///
+/// The ordering established by this does not always agree with the
+/// [`PartialOrd`] and [`PartialEq`] implementations of `f32`. For example,
+/// they consider negative and positive zero equal, while this does not
+///
+/// ## Null Ordering
+///
+/// The encoding described above will order nulls first, this can be inverted by representing
+/// nulls as `0xFF_u8` instead of `0_u8`
+///
+/// ## Reverse Column Ordering
+///
+/// The order of a given column can be reversed by negating the encoded bytes of non-null values
+///
+/// [COBS]: https://en.wikipedia.org/wiki/Consistent_Overhead_Byte_Stuffing
+/// [byte stuffing]: https://en.wikipedia.org/wiki/High-Level_Data_Link_Control#Asynchronous_framing
+#[derive(Debug)]
+pub struct RowConverter {
+    fields: Arc<[SortField]>,
+    /// State for codecs
+    codecs: Vec<Codec>,
+}
+
+#[derive(Debug)]
+enum Codec {
+    /// No additional codec state is necessary
+    Stateless,
+    /// A row converter for the dictionary values
+    /// and the encoding of a row containing only nulls
+    Dictionary(RowConverter, OwnedRow),
+    /// A row converter for the child fields
+    /// and the encoding of a row containing only nulls
+    Struct(RowConverter, OwnedRow),
+    /// A row converter for the child field
+    List(RowConverter),
+}
+
+impl Codec {
+    fn new(sort_field: &SortField) -> Result<Self, ArrowError> {
+        match &sort_field.data_type {
+            DataType::Dictionary(_, values) => {
+                let sort_field =
+                    SortField::new_with_options(values.as_ref().clone(), sort_field.options);
+
+                let converter = RowConverter::new(vec![sort_field])?;
+                let null_array = new_null_array(values.as_ref(), 1);
+                let nulls = converter.convert_columns(&[null_array])?;
+
+                let owned = OwnedRow {
+                    data: nulls.buffer.into(),
+                    config: nulls.config,
+                };
+                Ok(Self::Dictionary(converter, owned))
+            }
+            d if !d.is_nested() => Ok(Self::Stateless),
+            DataType::List(f) | DataType::LargeList(f) => {
+                // The encoded contents will be inverted if descending is set to true
+                // As such we set `descending` to false and negate nulls first if it
+                // it set to true
+                let options = SortOptions {
+                    descending: false,
+                    nulls_first: sort_field.options.nulls_first != sort_field.options.descending,
+                };
+
+                let field = SortField::new_with_options(f.data_type().clone(), options);
+                let converter = RowConverter::new(vec![field])?;
+                Ok(Self::List(converter))
+            }
+            DataType::Struct(f) => {
+                let sort_fields = f
+                    .iter()
+                    .map(|x| SortField::new_with_options(x.data_type().clone(), sort_field.options))
+                    .collect();
+
+                let converter = RowConverter::new(sort_fields)?;
+                let nulls: Vec<_> = f.iter().map(|x| new_null_array(x.data_type(), 1)).collect();
+
+                let nulls = converter.convert_columns(&nulls)?;
+                let owned = OwnedRow {
+                    data: nulls.buffer.into(),
+                    config: nulls.config,
+                };
+
+                Ok(Self::Struct(converter, owned))
+            }
+            _ => Err(ArrowError::NotYetImplemented(format!(
+                "not yet implemented: {:?}",
+                sort_field.data_type
+            ))),
+        }
+    }
+
+    fn encoder(&self, array: &dyn Array) -> Result<Encoder<'_>, ArrowError> {
+        match self {
+            Codec::Stateless => Ok(Encoder::Stateless),
+            Codec::Dictionary(converter, nulls) => {
+                let values = array.as_any_dictionary().values().clone();
+                let rows = converter.convert_columns(&[values])?;
+                Ok(Encoder::Dictionary(rows, nulls.row()))
+            }
+            Codec::Struct(converter, null) => {
+                let v = as_struct_array(array);
+                let rows = converter.convert_columns(v.columns())?;
+                Ok(Encoder::Struct(rows, null.row()))
+            }
+            Codec::List(converter) => {
+                let values = match array.data_type() {
+                    DataType::List(_) => as_list_array(array).values(),
+                    DataType::LargeList(_) => as_large_list_array(array).values(),
+                    _ => unreachable!(),
+                };
+                let rows = converter.convert_columns(&[values.clone()])?;
+                Ok(Encoder::List(rows))
+            }
+        }
+    }
+
+    fn size(&self) -> usize {
+        match self {
+            Codec::Stateless => 0,
+            Codec::Dictionary(converter, nulls) => converter.size() + nulls.data.len(),
+            Codec::Struct(converter, nulls) => converter.size() + nulls.data.len(),
+            Codec::List(converter) => converter.size(),
+        }
+    }
+}
+
+#[derive(Debug)]
+enum Encoder<'a> {
+    /// No additional encoder state is necessary
+    Stateless,
+    /// The encoding of the child array and the encoding of a null row
+    Dictionary(Rows, Row<'a>),
+    /// The row encoding of the child arrays and the encoding of a null row
+    ///
+    /// It is necessary to encode to a temporary [`Rows`] to avoid serializing
+    /// values that are masked by a null in the parent StructArray, otherwise
+    /// this would establish an ordering between semantically null values
+    Struct(Rows, Row<'a>),
+    /// The row encoding of the child array
+    List(Rows),
+}
+
+/// Configure the data type and sort order for a given column
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SortField {
+    /// Sort options
+    options: SortOptions,
+    /// Data type
+    data_type: DataType,
+}
+
+impl SortField {
+    /// Create a new column with the given data type
+    pub fn new(data_type: DataType) -> Self {
+        Self::new_with_options(data_type, Default::default())
+    }
+
+    /// Create a new column with the given data type and [`SortOptions`]
+    pub fn new_with_options(data_type: DataType, options: SortOptions) -> Self {
+        Self { options, data_type }
+    }
+
+    /// Return size of this instance in bytes.
+    ///
+    /// Includes the size of `Self`.
+    pub fn size(&self) -> usize {
+        self.data_type.size() + std::mem::size_of::<Self>() - std::mem::size_of::<DataType>()
+    }
+}
+
+impl RowConverter {
+    /// Create a new [`RowConverter`] with the provided schema
+    pub fn new(fields: Vec<SortField>) -> Result<Self, ArrowError> {
+        if !Self::supports_fields(&fields) {
+            return Err(ArrowError::NotYetImplemented(format!(
+                "Row format support not yet implemented for: {fields:?}"
+            )));
+        }
+
+        let codecs = fields.iter().map(Codec::new).collect::<Result<_, _>>()?;
+        Ok(Self {
+            fields: fields.into(),
+            codecs,
+        })
+    }
+
+    /// Check if the given fields are supported by the row format.
+    pub fn supports_fields(fields: &[SortField]) -> bool {
+        fields.iter().all(|x| Self::supports_datatype(&x.data_type))
+    }
+
+    fn supports_datatype(d: &DataType) -> bool {
+        match d {
+            _ if !d.is_nested() => true,
+            DataType::List(f) | DataType::LargeList(f) | DataType::Map(f, _) => {
+                Self::supports_datatype(f.data_type())
+            }
+            DataType::Struct(f) => f.iter().all(|x| Self::supports_datatype(x.data_type())),
+            _ => false,
+        }
+    }
+
+    /// Convert [`ArrayRef`] columns into [`Rows`]
+    ///
+    /// See [`Row`] for information on when [`Row`] can be compared
+    ///
+    /// # Panics
+    ///
+    /// Panics if the schema of `columns` does not match that provided to [`RowConverter::new`]
+    pub fn convert_columns(&self, columns: &[ArrayRef]) -> Result<Rows, ArrowError> {
+        let num_rows = columns.first().map(|x| x.len()).unwrap_or(0);
+        let mut rows = self.empty_rows(num_rows, 0);
+        self.append(&mut rows, columns)?;
+        Ok(rows)
+    }
+
+    /// Convert [`ArrayRef`] columns appending to an existing [`Rows`]
+    ///
+    /// See [`Row`] for information on when [`Row`] can be compared
+    ///
+    /// # Panics
+    ///
+    /// Panics if
+    /// * The schema of `columns` does not match that provided to [`RowConverter::new`]
+    /// * The provided [`Rows`] were not created by this [`RowConverter`]
+    ///
+    /// ```
+    /// # use std::sync::Arc;
+    /// # use std::collections::HashSet;
+    /// # use arrow_array::cast::AsArray;
+    /// # use arrow_array::StringArray;
+    /// # use arrow_row::{Row, RowConverter, SortField};
+    /// # use arrow_schema::DataType;
+    /// #
+    /// let converter = RowConverter::new(vec![SortField::new(DataType::Utf8)]).unwrap();
+    /// let a1 = StringArray::from(vec!["hello", "world"]);
+    /// let a2 = StringArray::from(vec!["a", "a", "hello"]);
+    ///
+    /// let mut rows = converter.empty_rows(5, 128);
+    /// converter.append(&mut rows, &[Arc::new(a1)]).unwrap();
+    /// converter.append(&mut rows, &[Arc::new(a2)]).unwrap();
+    ///
+    /// let back = converter.convert_rows(&rows).unwrap();
+    /// let values: Vec<_> = back[0].as_string::<i32>().iter().map(Option::unwrap).collect();
+    /// assert_eq!(&values, &["hello", "world", "a", "a", "hello"]);
+    /// ```
+    pub fn append(&self, rows: &mut Rows, columns: &[ArrayRef]) -> Result<(), ArrowError> {
+        assert!(
+            Arc::ptr_eq(&rows.config.fields, &self.fields),
+            "rows were not produced by this RowConverter"
+        );
+
+        if columns.len() != self.fields.len() {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "Incorrect number of arrays provided to RowConverter, expected {} got {}",
+                self.fields.len(),
+                columns.len()
+            )));
+        }
+
+        let encoders = columns
+            .iter()
+            .zip(&self.codecs)
+            .zip(self.fields.iter())
+            .map(|((column, codec), field)| {
+                if !column.data_type().equals_datatype(&field.data_type) {
+                    return Err(ArrowError::InvalidArgumentError(format!(
+                        "RowConverter column schema mismatch, expected {} got {}",
+                        field.data_type,
+                        column.data_type()
+                    )));
+                }
+                codec.encoder(column.as_ref())
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+
+        let write_offset = rows.num_rows();
+        let lengths = row_lengths(columns, &encoders);
+
+        // We initialize the offsets shifted down by one row index.
+        //
+        // As the rows are appended to the offsets will be incremented to match
+        //
+        // For example, consider the case of 3 rows of length 3, 4, and 6 respectively.
+        // The offsets would be initialized to `0, 0, 3, 7`
+        //
+        // Writing the first row entirely would yield `0, 3, 3, 7`
+        // The second, `0, 3, 7, 7`
+        // The third, `0, 3, 7, 13`
+        //
+        // This would be the final offsets for reading
+        //
+        // In this way offsets tracks the position during writing whilst eventually serving
+        // as identifying the offsets of the written rows
+        rows.offsets.reserve(lengths.len());
+        let mut cur_offset = rows.offsets[write_offset];
+        for l in lengths {
+            rows.offsets.push(cur_offset);
+            cur_offset = cur_offset.checked_add(l).expect("overflow");
+        }
+
+        // Note this will not zero out any trailing data in `rows.buffer`,
+        // e.g. resulting from a call to `Rows::clear`, relying instead on the
+        // encoders not assuming a zero-initialized buffer
+        rows.buffer.resize(cur_offset, 0);
+
+        for ((column, field), encoder) in columns.iter().zip(self.fields.iter()).zip(encoders) {
+            // We encode a column at a time to minimise dispatch overheads
+            encode_column(
+                &mut rows.buffer,
+                &mut rows.offsets[write_offset..],
+                column.as_ref(),
+                field.options,
+                &encoder,
+            )
+        }
+
+        if cfg!(debug_assertions) {
+            assert_eq!(*rows.offsets.last().unwrap(), rows.buffer.len());
+            rows.offsets
+                .windows(2)
+                .for_each(|w| assert!(w[0] <= w[1], "offsets should be monotonic"));
+        }
+
+        Ok(())
+    }
+
+    /// Convert [`Rows`] columns into [`ArrayRef`]
+    ///
+    /// # Panics
+    ///
+    /// Panics if the rows were not produced by this [`RowConverter`]
+    pub fn convert_rows<'a, I>(&self, rows: I) -> Result<Vec<ArrayRef>, ArrowError>
+    where
+        I: IntoIterator<Item = Row<'a>>,
+    {
+        let mut validate_utf8 = false;
+        let mut rows: Vec<_> = rows
+            .into_iter()
+            .map(|row| {
+                assert!(
+                    Arc::ptr_eq(&row.config.fields, &self.fields),
+                    "rows were not produced by this RowConverter"
+                );
+                validate_utf8 |= row.config.validate_utf8;
+                row.data
+            })
+            .collect();
+
+        // SAFETY
+        // We have validated that the rows came from this [`RowConverter`]
+        // and therefore must be valid
+        unsafe { self.convert_raw(&mut rows, validate_utf8) }
+    }
+
+    /// Returns an empty [`Rows`] with capacity for `row_capacity` rows with
+    /// a total length of `data_capacity`
+    ///
+    /// This can be used to buffer a selection of [`Row`]
+    ///
+    /// ```
+    /// # use std::sync::Arc;
+    /// # use std::collections::HashSet;
+    /// # use arrow_array::cast::AsArray;
+    /// # use arrow_array::StringArray;
+    /// # use arrow_row::{Row, RowConverter, SortField};
+    /// # use arrow_schema::DataType;
+    /// #
+    /// let converter = RowConverter::new(vec![SortField::new(DataType::Utf8)]).unwrap();
+    /// let array = StringArray::from(vec!["hello", "world", "a", "a", "hello"]);
+    ///
+    /// // Convert to row format and deduplicate
+    /// let converted = converter.convert_columns(&[Arc::new(array)]).unwrap();
+    /// let mut distinct_rows = converter.empty_rows(3, 100);
+    /// let mut dedup: HashSet<Row> = HashSet::with_capacity(3);
+    /// converted.iter().filter(|row| dedup.insert(*row)).for_each(|row| distinct_rows.push(row));
+    ///
+    /// // Note: we could skip buffering and feed the filtered iterator directly
+    /// // into convert_rows, this is done for demonstration purposes only
+    /// let distinct = converter.convert_rows(&distinct_rows).unwrap();
+    /// let values: Vec<_> = distinct[0].as_string::<i32>().iter().map(Option::unwrap).collect();
+    /// assert_eq!(&values, &["hello", "world", "a"]);
+    /// ```
+    pub fn empty_rows(&self, row_capacity: usize, data_capacity: usize) -> Rows {
+        let mut offsets = Vec::with_capacity(row_capacity.saturating_add(1));
+        offsets.push(0);
+
+        Rows {
+            offsets,
+            buffer: Vec::with_capacity(data_capacity),
+            config: RowConfig {
+                fields: self.fields.clone(),
+                validate_utf8: false,
+            },
+        }
+    }
+
+    /// Convert raw bytes into [`ArrayRef`]
+    ///
+    /// # Safety
+    ///
+    /// `rows` must contain valid data for this [`RowConverter`]
+    unsafe fn convert_raw(
+        &self,
+        rows: &mut [&[u8]],
+        validate_utf8: bool,
+    ) -> Result<Vec<ArrayRef>, ArrowError> {
+        self.fields
+            .iter()
+            .zip(&self.codecs)
+            .map(|(field, codec)| decode_column(field, rows, codec, validate_utf8))
+            .collect()
+    }
+
+    /// Returns a [`RowParser`] that can be used to parse [`Row`] from bytes
+    pub fn parser(&self) -> RowParser {
+        RowParser::new(Arc::clone(&self.fields))
+    }
+
+    /// Returns the size of this instance in bytes
+    ///
+    /// Includes the size of `Self`.
+    pub fn size(&self) -> usize {
+        std::mem::size_of::<Self>()
+            + self.fields.iter().map(|x| x.size()).sum::<usize>()
+            + self.codecs.capacity() * std::mem::size_of::<Codec>()
+            + self.codecs.iter().map(Codec::size).sum::<usize>()
+    }
+}
+
+/// A [`RowParser`] can be created from a [`RowConverter`] and used to parse bytes to [`Row`]
+#[derive(Debug)]
+pub struct RowParser {
+    config: RowConfig,
+}
+
+impl RowParser {
+    fn new(fields: Arc<[SortField]>) -> Self {
+        Self {
+            config: RowConfig {
+                fields,
+                validate_utf8: true,
+            },
+        }
+    }
+
+    /// Creates a [`Row`] from the provided `bytes`.
+    ///
+    /// `bytes` must be a [`Row`] produced by the [`RowConverter`] associated with
+    /// this [`RowParser`], otherwise subsequent operations with the produced [`Row`] may panic
+    pub fn parse<'a>(&'a self, bytes: &'a [u8]) -> Row<'a> {
+        Row {
+            data: bytes,
+            config: &self.config,
+        }
+    }
+}
+
+/// The config of a given set of [`Row`]
+#[derive(Debug, Clone)]
+struct RowConfig {
+    /// The schema for these rows
+    fields: Arc<[SortField]>,
+    /// Whether to run UTF-8 validation when converting to arrow arrays
+    validate_utf8: bool,
+}
+
+/// A row-oriented representation of arrow data, that is normalized for comparison.
+///
+/// See the [module level documentation](self) and [`RowConverter`] for more details.
+#[derive(Debug)]
+pub struct Rows {
+    /// Underlying row bytes
+    buffer: Vec<u8>,
+    /// Row `i` has data `&buffer[offsets[i]..offsets[i+1]]`
+    offsets: Vec<usize>,
+    /// The config for these rows
+    config: RowConfig,
+}
+
+impl Rows {
+    /// Append a [`Row`] to this [`Rows`]
+    pub fn push(&mut self, row: Row<'_>) {
+        assert!(
+            Arc::ptr_eq(&row.config.fields, &self.config.fields),
+            "row was not produced by this RowConverter"
+        );
+        self.config.validate_utf8 |= row.config.validate_utf8;
+        self.buffer.extend_from_slice(row.data);
+        self.offsets.push(self.buffer.len())
+    }
+
+    /// Returns the row at index `row`
+    pub fn row(&self, row: usize) -> Row<'_> {
+        let end = self.offsets[row + 1];
+        let start = self.offsets[row];
+        Row {
+            data: &self.buffer[start..end],
+            config: &self.config,
+        }
+    }
+
+    /// Sets the length of this [`Rows`] to 0
+    pub fn clear(&mut self) {
+        self.offsets.truncate(1);
+        self.buffer.clear();
+    }
+
+    /// Returns the number of [`Row`] in this [`Rows`]
+    pub fn num_rows(&self) -> usize {
+        self.offsets.len() - 1
+    }
+
+    /// Returns an iterator over the [`Row`] in this [`Rows`]
+    pub fn iter(&self) -> RowsIter<'_> {
+        self.into_iter()
+    }
+
+    /// Returns the size of this instance in bytes
+    ///
+    /// Includes the size of `Self`.
+    pub fn size(&self) -> usize {
+        // Size of fields is accounted for as part of RowConverter
+        std::mem::size_of::<Self>()
+            + self.buffer.len()
+            + self.offsets.len() * std::mem::size_of::<usize>()
+    }
+}
+
+impl<'a> IntoIterator for &'a Rows {
+    type Item = Row<'a>;
+    type IntoIter = RowsIter<'a>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        RowsIter {
+            rows: self,
+            start: 0,
+            end: self.num_rows(),
+        }
+    }
+}
+
+/// An iterator over [`Rows`]
+#[derive(Debug)]
+pub struct RowsIter<'a> {
+    rows: &'a Rows,
+    start: usize,
+    end: usize,
+}
+
+impl<'a> Iterator for RowsIter<'a> {
+    type Item = Row<'a>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.end == self.start {
+            return None;
+        }
+        let row = self.rows.row(self.start);
+        self.start += 1;
+        Some(row)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.len();
+        (len, Some(len))
+    }
+}
+
+impl<'a> ExactSizeIterator for RowsIter<'a> {
+    fn len(&self) -> usize {
+        self.end - self.start
+    }
+}
+
+impl<'a> DoubleEndedIterator for RowsIter<'a> {
+    fn next_back(&mut self) -> Option<Self::Item> {
+        if self.end == self.start {
+            return None;
+        }
+        let row = self.rows.row(self.end);
+        self.end -= 1;
+        Some(row)
+    }
+}
+
+/// A comparable representation of a row.
+///
+/// See the [module level documentation](self) for more details.
+///
+/// Two [`Row`] can only be compared if they both belong to [`Rows`]
+/// returned by calls to [`RowConverter::convert_columns`] on the same
+/// [`RowConverter`]. If different [`RowConverter`]s are used, any
+/// ordering established by comparing the [`Row`] is arbitrary.
+#[derive(Debug, Copy, Clone)]
+pub struct Row<'a> {
+    data: &'a [u8],
+    config: &'a RowConfig,
+}
+
+impl<'a> Row<'a> {
+    /// Create owned version of the row to detach it from the shared [`Rows`].
+    pub fn owned(&self) -> OwnedRow {
+        OwnedRow {
+            data: self.data.into(),
+            config: self.config.clone(),
+        }
+    }
+}
+
+// Manually derive these as don't wish to include `fields`
+
+impl<'a> PartialEq for Row<'a> {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.data.eq(other.data)
+    }
+}
+
+impl<'a> Eq for Row<'a> {}
+
+impl<'a> PartialOrd for Row<'a> {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl<'a> Ord for Row<'a> {
+    #[inline]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.data.cmp(other.data)
+    }
+}
+
+impl<'a> Hash for Row<'a> {
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.data.hash(state)
+    }
+}
+
+impl<'a> AsRef<[u8]> for Row<'a> {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        self.data
+    }
+}
+
+/// Owned version of a [`Row`] that can be moved/cloned freely.
+///
+/// This contains the data for the one specific row (not the entire buffer of all rows).
+#[derive(Debug, Clone)]
+pub struct OwnedRow {
+    data: Box<[u8]>,
+    config: RowConfig,
+}
+
+impl OwnedRow {
+    /// Get borrowed [`Row`] from owned version.
+    ///
+    /// This is helpful if you want to compare an [`OwnedRow`] with a [`Row`].
+    pub fn row(&self) -> Row<'_> {
+        Row {
+            data: &self.data,
+            config: &self.config,
+        }
+    }
+}
+
+// Manually derive these as don't wish to include `fields`. Also we just want to use the same `Row` implementations here.
+
+impl PartialEq for OwnedRow {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.row().eq(&other.row())
+    }
+}
+
+impl Eq for OwnedRow {}
+
+impl PartialOrd for OwnedRow {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for OwnedRow {
+    #[inline]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.row().cmp(&other.row())
+    }
+}
+
+impl Hash for OwnedRow {
+    #[inline]
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.row().hash(state)
+    }
+}
+
+impl AsRef<[u8]> for OwnedRow {
+    #[inline]
+    fn as_ref(&self) -> &[u8] {
+        &self.data
+    }
+}
+
+/// Returns the null sentinel, negated if `invert` is true
+#[inline]
+fn null_sentinel(options: SortOptions) -> u8 {
+    match options.nulls_first {
+        true => 0,
+        false => 0xFF,
+    }
+}
+
+/// Computes the length of each encoded [`Rows`] and returns an empty [`Rows`]
+fn row_lengths(cols: &[ArrayRef], encoders: &[Encoder]) -> Vec<usize> {
+    use fixed::FixedLengthEncoding;
+
+    let num_rows = cols.first().map(|x| x.len()).unwrap_or(0);
+    let mut lengths = vec![0; num_rows];
+
+    for (array, encoder) in cols.iter().zip(encoders) {
+        match encoder {
+            Encoder::Stateless => {
+                downcast_primitive_array! {
+                    array => lengths.iter_mut().for_each(|x| *x += fixed::encoded_len(array)),
+                    DataType::Null => {},
+                    DataType::Boolean => lengths.iter_mut().for_each(|x| *x += bool::ENCODED_LEN),
+                    DataType::Binary => as_generic_binary_array::<i32>(array)
+                        .iter()
+                        .zip(lengths.iter_mut())
+                        .for_each(|(slice, length)| *length += variable::encoded_len(slice)),
+                    DataType::LargeBinary => as_generic_binary_array::<i64>(array)
+                        .iter()
+                        .zip(lengths.iter_mut())
+                        .for_each(|(slice, length)| *length += variable::encoded_len(slice)),
+                    DataType::Utf8 => array.as_string::<i32>()
+                        .iter()
+                        .zip(lengths.iter_mut())
+                        .for_each(|(slice, length)| {
+                            *length += variable::encoded_len(slice.map(|x| x.as_bytes()))
+                        }),
+                    DataType::LargeUtf8 => array.as_string::<i64>()
+                        .iter()
+                        .zip(lengths.iter_mut())
+                        .for_each(|(slice, length)| {
+                            *length += variable::encoded_len(slice.map(|x| x.as_bytes()))
+                        }),
+                    DataType::FixedSizeBinary(len) => {
+                        let len = len.to_usize().unwrap();
+                        lengths.iter_mut().for_each(|x| *x += 1 + len)
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            Encoder::Dictionary(values, null) => {
+                downcast_dictionary_array! {
+                    array => {
+                        for (v, length) in array.keys().iter().zip(lengths.iter_mut()) {
+                            *length += match v {
+                                Some(k) => values.row(k.as_usize()).data.len(),
+                                None => null.data.len(),
+                            }
+                        }
+                    }
+                    _ => unreachable!(),
+                }
+            }
+            Encoder::Struct(rows, null) => {
+                let array = as_struct_array(array);
+                lengths.iter_mut().enumerate().for_each(|(idx, length)| {
+                    match array.is_valid(idx) {
+                        true => *length += 1 + rows.row(idx).as_ref().len(),
+                        false => *length += 1 + null.data.len(),
+                    }
+                });
+            }
+            Encoder::List(rows) => match array.data_type() {
+                DataType::List(_) => {
+                    list::compute_lengths(&mut lengths, rows, as_list_array(array))
+                }
+                DataType::LargeList(_) => {
+                    list::compute_lengths(&mut lengths, rows, as_large_list_array(array))
+                }
+                _ => unreachable!(),
+            },
+        }
+    }
+
+    lengths
+}
+
+/// Encodes a column to the provided [`Rows`] incrementing the offsets as it progresses
+fn encode_column(
+    data: &mut [u8],
+    offsets: &mut [usize],
+    column: &dyn Array,
+    opts: SortOptions,
+    encoder: &Encoder<'_>,
+) {
+    match encoder {
+        Encoder::Stateless => {
+            downcast_primitive_array! {
+                column => fixed::encode(data, offsets, column, opts),
+                DataType::Null => {}
+                DataType::Boolean => fixed::encode(data, offsets, column.as_boolean(), opts),
+                DataType::Binary => {
+                    variable::encode(data, offsets, as_generic_binary_array::<i32>(column).iter(), opts)
+                }
+                DataType::LargeBinary => {
+                    variable::encode(data, offsets, as_generic_binary_array::<i64>(column).iter(), opts)
+                }
+                DataType::Utf8 => variable::encode(
+                    data, offsets,
+                    column.as_string::<i32>().iter().map(|x| x.map(|x| x.as_bytes())),
+                    opts,
+                ),
+                DataType::LargeUtf8 => variable::encode(
+                    data, offsets,
+                    column.as_string::<i64>()
+                        .iter()
+                        .map(|x| x.map(|x| x.as_bytes())),
+                    opts,
+                ),
+                DataType::FixedSizeBinary(_) => {
+                    let array = column.as_any().downcast_ref().unwrap();
+                    fixed::encode_fixed_size_binary(data, offsets, array, opts)
+                }
+                _ => unreachable!(),
+            }
+        }
+        Encoder::Dictionary(values, nulls) => {
+            downcast_dictionary_array! {
+                column => encode_dictionary_values(data, offsets, column, values, nulls),
+                _ => unreachable!()
+            }
+        }
+        Encoder::Struct(rows, null) => {
+            let array = as_struct_array(column);
+            let null_sentinel = null_sentinel(opts);
+            offsets
+                .iter_mut()
+                .skip(1)
+                .enumerate()
+                .for_each(|(idx, offset)| {
+                    let (row, sentinel) = match array.is_valid(idx) {
+                        true => (rows.row(idx), 0x01),
+                        false => (*null, null_sentinel),
+                    };
+                    let end_offset = *offset + 1 + row.as_ref().len();
+                    data[*offset] = sentinel;
+                    data[*offset + 1..end_offset].copy_from_slice(row.as_ref());
+                    *offset = end_offset;
+                })
+        }
+        Encoder::List(rows) => match column.data_type() {
+            DataType::List(_) => list::encode(data, offsets, rows, opts, as_list_array(column)),
+            DataType::LargeList(_) => {
+                list::encode(data, offsets, rows, opts, as_large_list_array(column))
+            }
+            _ => unreachable!(),
+        },
+    }
+}
+
+/// Encode dictionary values not preserving the dictionary encoding
+pub fn encode_dictionary_values<K: ArrowDictionaryKeyType>(
+    data: &mut [u8],
+    offsets: &mut [usize],
+    column: &DictionaryArray<K>,
+    values: &Rows,
+    null: &Row<'_>,
+) {
+    for (offset, k) in offsets.iter_mut().skip(1).zip(column.keys()) {
+        let row = match k {
+            Some(k) => values.row(k.as_usize()).data,
+            None => null.data,
+        };
+        let end_offset = *offset + row.len();
+        data[*offset..end_offset].copy_from_slice(row);
+        *offset = end_offset;
+    }
+}
+
+macro_rules! decode_primitive_helper {
+    ($t:ty, $rows:ident, $data_type:ident, $options:ident) => {
+        Arc::new(decode_primitive::<$t>($rows, $data_type, $options))
+    };
+}
+
+/// Decodes a the provided `field` from `rows`
+///
+/// # Safety
+///
+/// Rows must contain valid data for the provided field
+unsafe fn decode_column(
+    field: &SortField,
+    rows: &mut [&[u8]],
+    codec: &Codec,
+    validate_utf8: bool,
+) -> Result<ArrayRef, ArrowError> {
+    let options = field.options;
+
+    let array: ArrayRef = match codec {
+        Codec::Stateless => {
+            let data_type = field.data_type.clone();
+            downcast_primitive! {
+                data_type => (decode_primitive_helper, rows, data_type, options),
+                DataType::Null => Arc::new(NullArray::new(rows.len())),
+                DataType::Boolean => Arc::new(decode_bool(rows, options)),
+                DataType::Binary => Arc::new(decode_binary::<i32>(rows, options)),
+                DataType::LargeBinary => Arc::new(decode_binary::<i64>(rows, options)),
+                DataType::FixedSizeBinary(size) => Arc::new(decode_fixed_size_binary(rows, size, options)),
+                DataType::Utf8 => Arc::new(decode_string::<i32>(rows, options, validate_utf8)),
+                DataType::LargeUtf8 => Arc::new(decode_string::<i64>(rows, options, validate_utf8)),
+                DataType::Dictionary(_, _) => todo!(),
+                _ => unreachable!()
+            }
+        }
+        Codec::Dictionary(converter, _) => {
+            let cols = converter.convert_raw(rows, validate_utf8)?;
+            cols.into_iter().next().unwrap()
+        }
+        Codec::Struct(converter, _) => {
+            let (null_count, nulls) = fixed::decode_nulls(rows);
+            rows.iter_mut().for_each(|row| *row = &row[1..]);
+            let children = converter.convert_raw(rows, validate_utf8)?;
+
+            let child_data = children.iter().map(|c| c.to_data()).collect();
+            let builder = ArrayDataBuilder::new(field.data_type.clone())
+                .len(rows.len())
+                .null_count(null_count)
+                .null_bit_buffer(Some(nulls))
+                .child_data(child_data);
+
+            Arc::new(StructArray::from(builder.build_unchecked()))
+        }
+        Codec::List(converter) => match &field.data_type {
+            DataType::List(_) => {
+                Arc::new(list::decode::<i32>(converter, rows, field, validate_utf8)?)
+            }
+            DataType::LargeList(_) => {
+                Arc::new(list::decode::<i64>(converter, rows, field, validate_utf8)?)
+            }
+            _ => unreachable!(),
+        },
+    };
+    Ok(array)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use rand::distributions::uniform::SampleUniform;
+    use rand::distributions::{Distribution, Standard};
+    use rand::{thread_rng, Rng};
+
+    use arrow_array::builder::*;
+    use arrow_array::types::*;
+    use arrow_array::*;
+    use arrow_buffer::i256;
+    use arrow_buffer::Buffer;
+    use arrow_cast::display::array_value_to_string;
+    use arrow_ord::sort::{LexicographicalComparator, SortColumn, SortOptions};
+
+    use super::*;
+
+    #[test]
+    fn test_fixed_width() {
+        let cols = [
+            Arc::new(Int16Array::from_iter([
+                Some(1),
+                Some(2),
+                None,
+                Some(-5),
+                Some(2),
+                Some(2),
+                Some(0),
+            ])) as ArrayRef,
+            Arc::new(Float32Array::from_iter([
+                Some(1.3),
+                Some(2.5),
+                None,
+                Some(4.),
+                Some(0.1),
+                Some(-4.),
+                Some(-0.),
+            ])) as ArrayRef,
+        ];
+
+        let converter = RowConverter::new(vec![
+            SortField::new(DataType::Int16),
+            SortField::new(DataType::Float32),
+        ])
+        .unwrap();
+        let rows = converter.convert_columns(&cols).unwrap();
+
+        assert_eq!(rows.offsets, &[0, 8, 16, 24, 32, 40, 48, 56]);
+        assert_eq!(
+            rows.buffer,
+            &[
+                1, 128, 1, //
+                1, 191, 166, 102, 102, //
+                1, 128, 2, //
+                1, 192, 32, 0, 0, //
+                0, 0, 0, //
+                0, 0, 0, 0, 0, //
+                1, 127, 251, //
+                1, 192, 128, 0, 0, //
+                1, 128, 2, //
+                1, 189, 204, 204, 205, //
+                1, 128, 2, //
+                1, 63, 127, 255, 255, //
+                1, 128, 0, //
+                1, 127, 255, 255, 255 //
+            ]
+        );
+
+        assert!(rows.row(3) < rows.row(6));
+        assert!(rows.row(0) < rows.row(1));
+        assert!(rows.row(3) < rows.row(0));
+        assert!(rows.row(4) < rows.row(1));
+        assert!(rows.row(5) < rows.row(4));
+
+        let back = converter.convert_rows(&rows).unwrap();
+        for (expected, actual) in cols.iter().zip(&back) {
+            assert_eq!(expected, actual);
+        }
+    }
+
+    #[test]
+    fn test_decimal128() {
+        let converter = RowConverter::new(vec![SortField::new(DataType::Decimal128(
+            DECIMAL128_MAX_PRECISION,
+            7,
+        ))])
+        .unwrap();
+        let col = Arc::new(
+            Decimal128Array::from_iter([
+                None,
+                Some(i128::MIN),
+                Some(-13),
+                Some(46_i128),
+                Some(5456_i128),
+                Some(i128::MAX),
+            ])
+            .with_precision_and_scale(38, 7)
+            .unwrap(),
+        ) as ArrayRef;
+
+        let rows = converter.convert_columns(&[Arc::clone(&col)]).unwrap();
+        for i in 0..rows.num_rows() - 1 {
+            assert!(rows.row(i) < rows.row(i + 1));
+        }
+
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        assert_eq!(col.as_ref(), back[0].as_ref())
+    }
+
+    #[test]
+    fn test_decimal256() {
+        let converter = RowConverter::new(vec![SortField::new(DataType::Decimal256(
+            DECIMAL256_MAX_PRECISION,
+            7,
+        ))])
+        .unwrap();
+        let col = Arc::new(
+            Decimal256Array::from_iter([
+                None,
+                Some(i256::MIN),
+                Some(i256::from_parts(0, -1)),
+                Some(i256::from_parts(u128::MAX, -1)),
+                Some(i256::from_parts(u128::MAX, 0)),
+                Some(i256::from_parts(0, 46_i128)),
+                Some(i256::from_parts(5, 46_i128)),
+                Some(i256::MAX),
+            ])
+            .with_precision_and_scale(DECIMAL256_MAX_PRECISION, 7)
+            .unwrap(),
+        ) as ArrayRef;
+
+        let rows = converter.convert_columns(&[Arc::clone(&col)]).unwrap();
+        for i in 0..rows.num_rows() - 1 {
+            assert!(rows.row(i) < rows.row(i + 1));
+        }
+
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        assert_eq!(col.as_ref(), back[0].as_ref())
+    }
+
+    #[test]
+    fn test_bool() {
+        let converter = RowConverter::new(vec![SortField::new(DataType::Boolean)]).unwrap();
+
+        let col = Arc::new(BooleanArray::from_iter([None, Some(false), Some(true)])) as ArrayRef;
+
+        let rows = converter.convert_columns(&[Arc::clone(&col)]).unwrap();
+        assert!(rows.row(2) > rows.row(1));
+        assert!(rows.row(2) > rows.row(0));
+        assert!(rows.row(1) > rows.row(0));
+
+        let cols = converter.convert_rows(&rows).unwrap();
+        assert_eq!(&cols[0], &col);
+
+        let converter = RowConverter::new(vec![SortField::new_with_options(
+            DataType::Boolean,
+            SortOptions {
+                descending: true,
+                nulls_first: false,
+            },
+        )])
+        .unwrap();
+
+        let rows = converter.convert_columns(&[Arc::clone(&col)]).unwrap();
+        assert!(rows.row(2) < rows.row(1));
+        assert!(rows.row(2) < rows.row(0));
+        assert!(rows.row(1) < rows.row(0));
+        let cols = converter.convert_rows(&rows).unwrap();
+        assert_eq!(&cols[0], &col);
+    }
+
+    #[test]
+    fn test_timezone() {
+        let a =
+            TimestampNanosecondArray::from(vec![1, 2, 3, 4, 5]).with_timezone("+01:00".to_string());
+        let d = a.data_type().clone();
+
+        let converter = RowConverter::new(vec![SortField::new(a.data_type().clone())]).unwrap();
+        let rows = converter.convert_columns(&[Arc::new(a) as _]).unwrap();
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        assert_eq!(back[0].data_type(), &d);
+
+        // Test dictionary
+        let mut a = PrimitiveDictionaryBuilder::<Int32Type, TimestampNanosecondType>::new();
+        a.append(34).unwrap();
+        a.append_null();
+        a.append(345).unwrap();
+
+        // Construct dictionary with a timezone
+        let dict = a.finish();
+        let values = TimestampNanosecondArray::from(dict.values().to_data());
+        let dict_with_tz = dict.with_values(Arc::new(values.with_timezone("+02:00")));
+        let v = DataType::Timestamp(TimeUnit::Nanosecond, Some("+02:00".into()));
+        let d = DataType::Dictionary(Box::new(DataType::Int32), Box::new(v.clone()));
+
+        assert_eq!(dict_with_tz.data_type(), &d);
+        let converter = RowConverter::new(vec![SortField::new(d.clone())]).unwrap();
+        let rows = converter
+            .convert_columns(&[Arc::new(dict_with_tz) as _])
+            .unwrap();
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        assert_eq!(back[0].data_type(), &v);
+    }
+
+    #[test]
+    fn test_null_encoding() {
+        let col = Arc::new(NullArray::new(10));
+        let converter = RowConverter::new(vec![SortField::new(DataType::Null)]).unwrap();
+        let rows = converter.convert_columns(&[col]).unwrap();
+        assert_eq!(rows.num_rows(), 10);
+        assert_eq!(rows.row(1).data.len(), 0);
+    }
+
+    #[test]
+    fn test_variable_width() {
+        let col = Arc::new(StringArray::from_iter([
+            Some("hello"),
+            Some("he"),
+            None,
+            Some("foo"),
+            Some(""),
+        ])) as ArrayRef;
+
+        let converter = RowConverter::new(vec![SortField::new(DataType::Utf8)]).unwrap();
+        let rows = converter.convert_columns(&[Arc::clone(&col)]).unwrap();
+
+        assert!(rows.row(1) < rows.row(0));
+        assert!(rows.row(2) < rows.row(4));
+        assert!(rows.row(3) < rows.row(0));
+        assert!(rows.row(3) < rows.row(1));
+
+        let cols = converter.convert_rows(&rows).unwrap();
+        assert_eq!(&cols[0], &col);
+
+        let col = Arc::new(BinaryArray::from_iter([
+            None,
+            Some(vec![0_u8; 0]),
+            Some(vec![0_u8; 6]),
+            Some(vec![0_u8; variable::MINI_BLOCK_SIZE]),
+            Some(vec![0_u8; variable::MINI_BLOCK_SIZE + 1]),
+            Some(vec![0_u8; variable::BLOCK_SIZE]),
+            Some(vec![0_u8; variable::BLOCK_SIZE + 1]),
+            Some(vec![1_u8; 6]),
+            Some(vec![1_u8; variable::MINI_BLOCK_SIZE]),
+            Some(vec![1_u8; variable::MINI_BLOCK_SIZE + 1]),
+            Some(vec![1_u8; variable::BLOCK_SIZE]),
+            Some(vec![1_u8; variable::BLOCK_SIZE + 1]),
+            Some(vec![0xFF_u8; 6]),
+            Some(vec![0xFF_u8; variable::MINI_BLOCK_SIZE]),
+            Some(vec![0xFF_u8; variable::MINI_BLOCK_SIZE + 1]),
+            Some(vec![0xFF_u8; variable::BLOCK_SIZE]),
+            Some(vec![0xFF_u8; variable::BLOCK_SIZE + 1]),
+        ])) as ArrayRef;
+
+        let converter = RowConverter::new(vec![SortField::new(DataType::Binary)]).unwrap();
+        let rows = converter.convert_columns(&[Arc::clone(&col)]).unwrap();
+
+        for i in 0..rows.num_rows() {
+            for j in i + 1..rows.num_rows() {
+                assert!(
+                    rows.row(i) < rows.row(j),
+                    "{} < {} - {:?} < {:?}",
+                    i,
+                    j,
+                    rows.row(i),
+                    rows.row(j)
+                );
+            }
+        }
+
+        let cols = converter.convert_rows(&rows).unwrap();
+        assert_eq!(&cols[0], &col);
+
+        let converter = RowConverter::new(vec![SortField::new_with_options(
+            DataType::Binary,
+            SortOptions {
+                descending: true,
+                nulls_first: false,
+            },
+        )])
+        .unwrap();
+        let rows = converter.convert_columns(&[Arc::clone(&col)]).unwrap();
+
+        for i in 0..rows.num_rows() {
+            for j in i + 1..rows.num_rows() {
+                assert!(
+                    rows.row(i) > rows.row(j),
+                    "{} > {} - {:?} > {:?}",
+                    i,
+                    j,
+                    rows.row(i),
+                    rows.row(j)
+                );
+            }
+        }
+
+        let cols = converter.convert_rows(&rows).unwrap();
+        assert_eq!(&cols[0], &col);
+    }
+
+    /// If `exact` is false performs a logical comparison between a and dictionary-encoded b
+    fn dictionary_eq(a: &dyn Array, b: &dyn Array) {
+        match b.data_type() {
+            DataType::Dictionary(_, v) => {
+                assert_eq!(a.data_type(), v.as_ref());
+                let b = arrow_cast::cast(b, v).unwrap();
+                assert_eq!(a, b.as_ref())
+            }
+            _ => assert_eq!(a, b),
+        }
+    }
+
+    #[test]
+    fn test_string_dictionary() {
+        let a = Arc::new(DictionaryArray::<Int32Type>::from_iter([
+            Some("foo"),
+            Some("hello"),
+            Some("he"),
+            None,
+            Some("hello"),
+            Some(""),
+            Some("hello"),
+            Some("hello"),
+        ])) as ArrayRef;
+
+        let field = SortField::new(a.data_type().clone());
+        let converter = RowConverter::new(vec![field]).unwrap();
+        let rows_a = converter.convert_columns(&[Arc::clone(&a)]).unwrap();
+
+        assert!(rows_a.row(3) < rows_a.row(5));
+        assert!(rows_a.row(2) < rows_a.row(1));
+        assert!(rows_a.row(0) < rows_a.row(1));
+        assert!(rows_a.row(3) < rows_a.row(0));
+
+        assert_eq!(rows_a.row(1), rows_a.row(4));
+        assert_eq!(rows_a.row(1), rows_a.row(6));
+        assert_eq!(rows_a.row(1), rows_a.row(7));
+
+        let cols = converter.convert_rows(&rows_a).unwrap();
+        dictionary_eq(&cols[0], &a);
+
+        let b = Arc::new(DictionaryArray::<Int32Type>::from_iter([
+            Some("hello"),
+            None,
+            Some("cupcakes"),
+        ])) as ArrayRef;
+
+        let rows_b = converter.convert_columns(&[Arc::clone(&b)]).unwrap();
+        assert_eq!(rows_a.row(1), rows_b.row(0));
+        assert_eq!(rows_a.row(3), rows_b.row(1));
+        assert!(rows_b.row(2) < rows_a.row(0));
+
+        let cols = converter.convert_rows(&rows_b).unwrap();
+        dictionary_eq(&cols[0], &b);
+
+        let converter = RowConverter::new(vec![SortField::new_with_options(
+            a.data_type().clone(),
+            SortOptions {
+                descending: true,
+                nulls_first: false,
+            },
+        )])
+        .unwrap();
+
+        let rows_c = converter.convert_columns(&[Arc::clone(&a)]).unwrap();
+        assert!(rows_c.row(3) > rows_c.row(5));
+        assert!(rows_c.row(2) > rows_c.row(1));
+        assert!(rows_c.row(0) > rows_c.row(1));
+        assert!(rows_c.row(3) > rows_c.row(0));
+
+        let cols = converter.convert_rows(&rows_c).unwrap();
+        dictionary_eq(&cols[0], &a);
+
+        let converter = RowConverter::new(vec![SortField::new_with_options(
+            a.data_type().clone(),
+            SortOptions {
+                descending: true,
+                nulls_first: true,
+            },
+        )])
+        .unwrap();
+
+        let rows_c = converter.convert_columns(&[Arc::clone(&a)]).unwrap();
+        assert!(rows_c.row(3) < rows_c.row(5));
+        assert!(rows_c.row(2) > rows_c.row(1));
+        assert!(rows_c.row(0) > rows_c.row(1));
+        assert!(rows_c.row(3) < rows_c.row(0));
+
+        let cols = converter.convert_rows(&rows_c).unwrap();
+        dictionary_eq(&cols[0], &a);
+    }
+
+    #[test]
+    fn test_struct() {
+        // Test basic
+        let a = Arc::new(Int32Array::from(vec![1, 1, 2, 2])) as ArrayRef;
+        let a_f = Arc::new(Field::new("int", DataType::Int32, false));
+        let u = Arc::new(StringArray::from(vec!["a", "b", "c", "d"])) as ArrayRef;
+        let u_f = Arc::new(Field::new("s", DataType::Utf8, false));
+        let s1 = Arc::new(StructArray::from(vec![(a_f, a), (u_f, u)])) as ArrayRef;
+
+        let sort_fields = vec![SortField::new(s1.data_type().clone())];
+        let converter = RowConverter::new(sort_fields).unwrap();
+        let r1 = converter.convert_columns(&[Arc::clone(&s1)]).unwrap();
+
+        for (a, b) in r1.iter().zip(r1.iter().skip(1)) {
+            assert!(a < b);
+        }
+
+        let back = converter.convert_rows(&r1).unwrap();
+        assert_eq!(back.len(), 1);
+        assert_eq!(&back[0], &s1);
+
+        // Test struct nullability
+        let data = s1
+            .to_data()
+            .into_builder()
+            .null_bit_buffer(Some(Buffer::from_slice_ref([0b00001010])))
+            .null_count(2)
+            .build()
+            .unwrap();
+
+        let s2 = Arc::new(StructArray::from(data)) as ArrayRef;
+        let r2 = converter.convert_columns(&[Arc::clone(&s2)]).unwrap();
+        assert_eq!(r2.row(0), r2.row(2)); // Nulls equal
+        assert!(r2.row(0) < r2.row(1)); // Nulls first
+        assert_ne!(r1.row(0), r2.row(0)); // Value does not equal null
+        assert_eq!(r1.row(1), r2.row(1)); // Values equal
+
+        let back = converter.convert_rows(&r2).unwrap();
+        assert_eq!(back.len(), 1);
+        assert_eq!(&back[0], &s2);
+
+        back[0].to_data().validate_full().unwrap();
+    }
+
+    #[test]
+    fn test_primitive_dictionary() {
+        let mut builder = PrimitiveDictionaryBuilder::<Int32Type, Int32Type>::new();
+        builder.append(2).unwrap();
+        builder.append(3).unwrap();
+        builder.append(0).unwrap();
+        builder.append_null();
+        builder.append(5).unwrap();
+        builder.append(3).unwrap();
+        builder.append(-1).unwrap();
+
+        let a = builder.finish();
+        let data_type = a.data_type().clone();
+        let columns = [Arc::new(a) as ArrayRef];
+
+        let field = SortField::new(data_type.clone());
+        let converter = RowConverter::new(vec![field]).unwrap();
+        let rows = converter.convert_columns(&columns).unwrap();
+        assert!(rows.row(0) < rows.row(1));
+        assert!(rows.row(2) < rows.row(0));
+        assert!(rows.row(3) < rows.row(2));
+        assert!(rows.row(6) < rows.row(2));
+        assert!(rows.row(3) < rows.row(6));
+    }
+
+    #[test]
+    fn test_dictionary_nulls() {
+        let values = Int32Array::from_iter([Some(1), Some(-1), None, Some(4), None]).into_data();
+        let keys =
+            Int32Array::from_iter([Some(0), Some(0), Some(1), Some(2), Some(4), None]).into_data();
+
+        let data_type = DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Int32));
+        let data = keys
+            .into_builder()
+            .data_type(data_type.clone())
+            .child_data(vec![values])
+            .build()
+            .unwrap();
+
+        let columns = [Arc::new(DictionaryArray::<Int32Type>::from(data)) as ArrayRef];
+        let field = SortField::new(data_type.clone());
+        let converter = RowConverter::new(vec![field]).unwrap();
+        let rows = converter.convert_columns(&columns).unwrap();
+
+        assert_eq!(rows.row(0), rows.row(1));
+        assert_eq!(rows.row(3), rows.row(4));
+        assert_eq!(rows.row(4), rows.row(5));
+        assert!(rows.row(3) < rows.row(0));
+    }
+
+    #[test]
+    #[should_panic(expected = "Encountered non UTF-8 data")]
+    fn test_invalid_utf8() {
+        let converter = RowConverter::new(vec![SortField::new(DataType::Binary)]).unwrap();
+        let array = Arc::new(BinaryArray::from_iter_values([&[0xFF]])) as _;
+        let rows = converter.convert_columns(&[array]).unwrap();
+        let binary_row = rows.row(0);
+
+        let converter = RowConverter::new(vec![SortField::new(DataType::Utf8)]).unwrap();
+        let parser = converter.parser();
+        let utf8_row = parser.parse(binary_row.as_ref());
+
+        converter.convert_rows(std::iter::once(utf8_row)).unwrap();
+    }
+
+    #[test]
+    #[should_panic(expected = "rows were not produced by this RowConverter")]
+    fn test_different_converter() {
+        let values = Arc::new(Int32Array::from_iter([Some(1), Some(-1)]));
+        let converter = RowConverter::new(vec![SortField::new(DataType::Int32)]).unwrap();
+        let rows = converter.convert_columns(&[values]).unwrap();
+
+        let converter = RowConverter::new(vec![SortField::new(DataType::Int32)]).unwrap();
+        let _ = converter.convert_rows(&rows);
+    }
+
+    fn test_single_list<O: OffsetSizeTrait>() {
+        let mut builder = GenericListBuilder::<O, _>::new(Int32Builder::new());
+        builder.values().append_value(32);
+        builder.values().append_value(52);
+        builder.values().append_value(32);
+        builder.append(true);
+        builder.values().append_value(32);
+        builder.values().append_value(52);
+        builder.values().append_value(12);
+        builder.append(true);
+        builder.values().append_value(32);
+        builder.values().append_value(52);
+        builder.append(true);
+        builder.values().append_value(32); // MASKED
+        builder.values().append_value(52); // MASKED
+        builder.append(false);
+        builder.values().append_value(32);
+        builder.values().append_null();
+        builder.append(true);
+        builder.append(true);
+
+        let list = Arc::new(builder.finish()) as ArrayRef;
+        let d = list.data_type().clone();
+
+        let converter = RowConverter::new(vec![SortField::new(d.clone())]).unwrap();
+
+        let rows = converter.convert_columns(&[Arc::clone(&list)]).unwrap();
+        assert!(rows.row(0) > rows.row(1)); // [32, 52, 32] > [32, 52, 12]
+        assert!(rows.row(2) < rows.row(1)); // [32, 42] < [32, 52, 12]
+        assert!(rows.row(3) < rows.row(2)); // null < [32, 42]
+        assert!(rows.row(4) < rows.row(2)); // [32, null] < [32, 42]
+        assert!(rows.row(5) < rows.row(2)); // [] < [32, 42]
+        assert!(rows.row(3) < rows.row(5)); // null < []
+
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        back[0].to_data().validate_full().unwrap();
+        assert_eq!(&back[0], &list);
+
+        let options = SortOptions {
+            descending: false,
+            nulls_first: false,
+        };
+        let field = SortField::new_with_options(d.clone(), options);
+        let converter = RowConverter::new(vec![field]).unwrap();
+        let rows = converter.convert_columns(&[Arc::clone(&list)]).unwrap();
+
+        assert!(rows.row(0) > rows.row(1)); // [32, 52, 32] > [32, 52, 12]
+        assert!(rows.row(2) < rows.row(1)); // [32, 42] < [32, 52, 12]
+        assert!(rows.row(3) > rows.row(2)); // null > [32, 42]
+        assert!(rows.row(4) > rows.row(2)); // [32, null] > [32, 42]
+        assert!(rows.row(5) < rows.row(2)); // [] < [32, 42]
+        assert!(rows.row(3) > rows.row(5)); // null > []
+
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        back[0].to_data().validate_full().unwrap();
+        assert_eq!(&back[0], &list);
+
+        let options = SortOptions {
+            descending: true,
+            nulls_first: false,
+        };
+        let field = SortField::new_with_options(d.clone(), options);
+        let converter = RowConverter::new(vec![field]).unwrap();
+        let rows = converter.convert_columns(&[Arc::clone(&list)]).unwrap();
+
+        assert!(rows.row(0) < rows.row(1)); // [32, 52, 32] < [32, 52, 12]
+        assert!(rows.row(2) > rows.row(1)); // [32, 42] > [32, 52, 12]
+        assert!(rows.row(3) > rows.row(2)); // null > [32, 42]
+        assert!(rows.row(4) > rows.row(2)); // [32, null] > [32, 42]
+        assert!(rows.row(5) > rows.row(2)); // [] > [32, 42]
+        assert!(rows.row(3) > rows.row(5)); // null > []
+
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        back[0].to_data().validate_full().unwrap();
+        assert_eq!(&back[0], &list);
+
+        let options = SortOptions {
+            descending: true,
+            nulls_first: true,
+        };
+        let field = SortField::new_with_options(d, options);
+        let converter = RowConverter::new(vec![field]).unwrap();
+        let rows = converter.convert_columns(&[Arc::clone(&list)]).unwrap();
+
+        assert!(rows.row(0) < rows.row(1)); // [32, 52, 32] < [32, 52, 12]
+        assert!(rows.row(2) > rows.row(1)); // [32, 42] > [32, 52, 12]
+        assert!(rows.row(3) < rows.row(2)); // null < [32, 42]
+        assert!(rows.row(4) < rows.row(2)); // [32, null] < [32, 42]
+        assert!(rows.row(5) > rows.row(2)); // [] > [32, 42]
+        assert!(rows.row(3) < rows.row(5)); // null < []
+
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        back[0].to_data().validate_full().unwrap();
+        assert_eq!(&back[0], &list);
+    }
+
+    fn test_nested_list<O: OffsetSizeTrait>() {
+        let mut builder =
+            GenericListBuilder::<O, _>::new(GenericListBuilder::<O, _>::new(Int32Builder::new()));
+
+        builder.values().values().append_value(1);
+        builder.values().values().append_value(2);
+        builder.values().append(true);
+        builder.values().values().append_value(1);
+        builder.values().values().append_null();
+        builder.values().append(true);
+        builder.append(true);
+
+        builder.values().values().append_value(1);
+        builder.values().values().append_null();
+        builder.values().append(true);
+        builder.values().values().append_value(1);
+        builder.values().values().append_null();
+        builder.values().append(true);
+        builder.append(true);
+
+        builder.values().values().append_value(1);
+        builder.values().values().append_null();
+        builder.values().append(true);
+        builder.values().append(false);
+        builder.append(true);
+        builder.append(false);
+
+        builder.values().values().append_value(1);
+        builder.values().values().append_value(2);
+        builder.values().append(true);
+        builder.append(true);
+
+        let list = Arc::new(builder.finish()) as ArrayRef;
+        let d = list.data_type().clone();
+
+        // [
+        //   [[1, 2], [1, null]],
+        //   [[1, null], [1, null]],
+        //   [[1, null], null]
+        //   null
+        //   [[1, 2]]
+        // ]
+        let options = SortOptions {
+            descending: false,
+            nulls_first: true,
+        };
+        let field = SortField::new_with_options(d.clone(), options);
+        let converter = RowConverter::new(vec![field]).unwrap();
+        let rows = converter.convert_columns(&[Arc::clone(&list)]).unwrap();
+
+        assert!(rows.row(0) > rows.row(1));
+        assert!(rows.row(1) > rows.row(2));
+        assert!(rows.row(2) > rows.row(3));
+        assert!(rows.row(4) < rows.row(0));
+        assert!(rows.row(4) > rows.row(1));
+
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        back[0].to_data().validate_full().unwrap();
+        assert_eq!(&back[0], &list);
+
+        let options = SortOptions {
+            descending: true,
+            nulls_first: true,
+        };
+        let field = SortField::new_with_options(d.clone(), options);
+        let converter = RowConverter::new(vec![field]).unwrap();
+        let rows = converter.convert_columns(&[Arc::clone(&list)]).unwrap();
+
+        assert!(rows.row(0) > rows.row(1));
+        assert!(rows.row(1) > rows.row(2));
+        assert!(rows.row(2) > rows.row(3));
+        assert!(rows.row(4) > rows.row(0));
+        assert!(rows.row(4) > rows.row(1));
+
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        back[0].to_data().validate_full().unwrap();
+        assert_eq!(&back[0], &list);
+
+        let options = SortOptions {
+            descending: true,
+            nulls_first: false,
+        };
+        let field = SortField::new_with_options(d, options);
+        let converter = RowConverter::new(vec![field]).unwrap();
+        let rows = converter.convert_columns(&[Arc::clone(&list)]).unwrap();
+
+        assert!(rows.row(0) < rows.row(1));
+        assert!(rows.row(1) < rows.row(2));
+        assert!(rows.row(2) < rows.row(3));
+        assert!(rows.row(4) > rows.row(0));
+        assert!(rows.row(4) < rows.row(1));
+
+        let back = converter.convert_rows(&rows).unwrap();
+        assert_eq!(back.len(), 1);
+        back[0].to_data().validate_full().unwrap();
+        assert_eq!(&back[0], &list);
+    }
+
+    #[test]
+    fn test_list() {
+        test_single_list::<i32>();
+        test_nested_list::<i32>();
+    }
+
+    #[test]
+    fn test_large_list() {
+        test_single_list::<i64>();
+        test_nested_list::<i64>();
+    }
+
+    fn generate_primitive_array<K>(len: usize, valid_percent: f64) -> PrimitiveArray<K>
+    where
+        K: ArrowPrimitiveType,
+        Standard: Distribution<K::Native>,
+    {
+        let mut rng = thread_rng();
+        (0..len)
+            .map(|_| rng.gen_bool(valid_percent).then(|| rng.gen()))
+            .collect()
+    }
+
+    fn generate_strings<O: OffsetSizeTrait>(
+        len: usize,
+        valid_percent: f64,
+    ) -> GenericStringArray<O> {
+        let mut rng = thread_rng();
+        (0..len)
+            .map(|_| {
+                rng.gen_bool(valid_percent).then(|| {
+                    let len = rng.gen_range(0..100);
+                    let bytes = (0..len).map(|_| rng.gen_range(0..128)).collect();
+                    String::from_utf8(bytes).unwrap()
+                })
+            })
+            .collect()
+    }
+
+    fn generate_dictionary<K>(
+        values: ArrayRef,
+        len: usize,
+        valid_percent: f64,
+    ) -> DictionaryArray<K>
+    where
+        K: ArrowDictionaryKeyType,
+        K::Native: SampleUniform,
+    {
+        let mut rng = thread_rng();
+        let min_key = K::Native::from_usize(0).unwrap();
+        let max_key = K::Native::from_usize(values.len()).unwrap();
+        let keys: PrimitiveArray<K> = (0..len)
+            .map(|_| {
+                rng.gen_bool(valid_percent)
+                    .then(|| rng.gen_range(min_key..max_key))
+            })
+            .collect();
+
+        let data_type =
+            DataType::Dictionary(Box::new(K::DATA_TYPE), Box::new(values.data_type().clone()));
+
+        let data = keys
+            .into_data()
+            .into_builder()
+            .data_type(data_type)
+            .add_child_data(values.to_data())
+            .build()
+            .unwrap();
+
+        DictionaryArray::from(data)
+    }
+
+    fn generate_fixed_size_binary(len: usize, valid_percent: f64) -> FixedSizeBinaryArray {
+        let mut rng = thread_rng();
+        let width = rng.gen_range(0..20);
+        let mut builder = FixedSizeBinaryBuilder::new(width);
+
+        let mut b = vec![0; width as usize];
+        for _ in 0..len {
+            match rng.gen_bool(valid_percent) {
+                true => {
+                    b.iter_mut().for_each(|x| *x = rng.gen());
+                    builder.append_value(&b).unwrap();
+                }
+                false => builder.append_null(),
+            }
+        }
+
+        builder.finish()
+    }
+
+    fn generate_column(len: usize) -> ArrayRef {
+        let mut rng = thread_rng();
+        match rng.gen_range(0..10) {
+            0 => Arc::new(generate_primitive_array::<Int32Type>(len, 0.8)),
+            1 => Arc::new(generate_primitive_array::<UInt32Type>(len, 0.8)),
+            2 => Arc::new(generate_primitive_array::<Int64Type>(len, 0.8)),
+            3 => Arc::new(generate_primitive_array::<UInt64Type>(len, 0.8)),
+            4 => Arc::new(generate_primitive_array::<Float32Type>(len, 0.8)),
+            5 => Arc::new(generate_primitive_array::<Float64Type>(len, 0.8)),
+            6 => Arc::new(generate_strings::<i32>(len, 0.8)),
+            7 => Arc::new(generate_dictionary::<Int64Type>(
+                // Cannot test dictionaries containing null values because of #2687
+                Arc::new(generate_strings::<i32>(rng.gen_range(1..len), 1.0)),
+                len,
+                0.8,
+            )),
+            8 => Arc::new(generate_dictionary::<Int64Type>(
+                // Cannot test dictionaries containing null values because of #2687
+                Arc::new(generate_primitive_array::<Int64Type>(
+                    rng.gen_range(1..len),
+                    1.0,
+                )),
+                len,
+                0.8,
+            )),
+            9 => Arc::new(generate_fixed_size_binary(len, 0.8)),
+            _ => unreachable!(),
+        }
+    }
+
+    fn print_row(cols: &[SortColumn], row: usize) -> String {
+        let t: Vec<_> = cols
+            .iter()
+            .map(|x| array_value_to_string(&x.values, row).unwrap())
+            .collect();
+        t.join(",")
+    }
+
+    fn print_col_types(cols: &[SortColumn]) -> String {
+        let t: Vec<_> = cols
+            .iter()
+            .map(|x| x.values.data_type().to_string())
+            .collect();
+        t.join(",")
+    }
+
+    #[test]
+    #[cfg_attr(miri, ignore)]
+    fn fuzz_test() {
+        for _ in 0..100 {
+            let mut rng = thread_rng();
+            let num_columns = rng.gen_range(1..5);
+            let len = rng.gen_range(5..100);
+            let arrays: Vec<_> = (0..num_columns).map(|_| generate_column(len)).collect();
+
+            let options: Vec<_> = (0..num_columns)
+                .map(|_| SortOptions {
+                    descending: rng.gen_bool(0.5),
+                    nulls_first: rng.gen_bool(0.5),
+                })
+                .collect();
+
+            let sort_columns: Vec<_> = options
+                .iter()
+                .zip(&arrays)
+                .map(|(o, c)| SortColumn {
+                    values: Arc::clone(c),
+                    options: Some(*o),
+                })
+                .collect();
+
+            let comparator = LexicographicalComparator::try_new(&sort_columns).unwrap();
+
+            let columns = options
+                .into_iter()
+                .zip(&arrays)
+                .map(|(o, a)| SortField::new_with_options(a.data_type().clone(), o))
+                .collect();
+
+            let converter = RowConverter::new(columns).unwrap();
+            let rows = converter.convert_columns(&arrays).unwrap();
+
+            for i in 0..len {
+                for j in 0..len {
+                    let row_i = rows.row(i);
+                    let row_j = rows.row(j);
+                    let row_cmp = row_i.cmp(&row_j);
+                    let lex_cmp = comparator.compare(i, j);
+                    assert_eq!(
+                        row_cmp,
+                        lex_cmp,
+                        "({:?} vs {:?}) vs ({:?} vs {:?}) for types {}",
+                        print_row(&sort_columns, i),
+                        print_row(&sort_columns, j),
+                        row_i,
+                        row_j,
+                        print_col_types(&sort_columns)
+                    );
+                }
+            }
+
+            let back = converter.convert_rows(&rows).unwrap();
+            for (actual, expected) in back.iter().zip(&arrays) {
+                actual.to_data().validate_full().unwrap();
+                dictionary_eq(actual, expected)
+            }
+        }
+    }
+
+    #[test]
+    fn test_clear() {
+        let converter = RowConverter::new(vec![SortField::new(DataType::Int32)]).unwrap();
+        let mut rows = converter.empty_rows(3, 128);
+
+        let first = Int32Array::from(vec![None, Some(2), Some(4)]);
+        let second = Int32Array::from(vec![Some(2), None, Some(4)]);
+        let arrays = vec![Arc::new(first) as ArrayRef, Arc::new(second) as ArrayRef];
+
+        for array in arrays.iter() {
+            rows.clear();
+            converter.append(&mut rows, &[array.clone()]).unwrap();
+            let back = converter.convert_rows(&rows).unwrap();
+            assert_eq!(&back[0], array);
+        }
+
+        let mut rows_expected = converter.empty_rows(3, 128);
+        converter.append(&mut rows_expected, &arrays[1..]).unwrap();
+
+        for (i, (actual, expected)) in rows.iter().zip(rows_expected.iter()).enumerate() {
+            assert_eq!(
+                actual, expected,
+                "For row {}: expected {:?}, actual: {:?}",
+                i, expected, actual
+            );
+        }
+    }
+
+    #[test]
+    fn test_append_codec_dictionary_binary() {
+        use DataType::*;
+        // Dictionary RowConverter
+        let converter = RowConverter::new(vec![SortField::new(Dictionary(
+            Box::new(Int32),
+            Box::new(Binary),
+        ))])
+        .unwrap();
+        let mut rows = converter.empty_rows(4, 128);
+
+        let keys = Int32Array::from_iter_values([0, 1, 2, 3]);
+        let values = BinaryArray::from(vec![
+            Some("a".as_bytes()),
+            Some(b"b"),
+            Some(b"c"),
+            Some(b"d"),
+        ]);
+        let dict_array = DictionaryArray::new(keys, Arc::new(values));
+
+        rows.clear();
+        let array = Arc::new(dict_array) as ArrayRef;
+        converter.append(&mut rows, &[array.clone()]).unwrap();
+        let back = converter.convert_rows(&rows).unwrap();
+
+        dictionary_eq(&back[0], &array);
+    }
+}
diff --git a/arrow-row/src/list.rs b/arrow-row/src/list.rs
new file mode 100644
index 000000000000..511fb4ffb282
--- /dev/null
+++ b/arrow-row/src/list.rs
@@ -0,0 +1,175 @@
+// 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.
+
+use crate::{RowConverter, Rows, SortField};
+use arrow_array::builder::BufferBuilder;
+use arrow_array::{Array, GenericListArray, OffsetSizeTrait};
+use arrow_data::ArrayDataBuilder;
+use arrow_schema::{ArrowError, SortOptions};
+use std::ops::Range;
+
+pub fn compute_lengths<O: OffsetSizeTrait>(
+    lengths: &mut [usize],
+    rows: &Rows,
+    array: &GenericListArray<O>,
+) {
+    let offsets = array.value_offsets().windows(2);
+    lengths
+        .iter_mut()
+        .zip(offsets)
+        .enumerate()
+        .for_each(|(idx, (length, offsets))| {
+            let start = offsets[0].as_usize();
+            let end = offsets[1].as_usize();
+            let range = array.is_valid(idx).then_some(start..end);
+            *length += encoded_len(rows, range);
+        });
+}
+
+fn encoded_len(rows: &Rows, range: Option<Range<usize>>) -> usize {
+    match range {
+        None => 1,
+        Some(range) if range.start == range.end => 1,
+        Some(range) => {
+            let element_count = range.end - range.start;
+            let row_bytes = range.map(|i| rows.row(i).as_ref().len()).sum::<usize>();
+            let total = (1 + element_count) * std::mem::size_of::<u32>() + row_bytes;
+            super::variable::padded_length(Some(total))
+        }
+    }
+}
+
+/// Encodes the provided `GenericListArray` to `out` with the provided `SortOptions`
+///
+/// `rows` should contain the encoded child elements
+pub fn encode<O: OffsetSizeTrait>(
+    data: &mut [u8],
+    offsets: &mut [usize],
+    rows: &Rows,
+    opts: SortOptions,
+    array: &GenericListArray<O>,
+) {
+    let mut temporary = vec![];
+    offsets
+        .iter_mut()
+        .skip(1)
+        .zip(array.value_offsets().windows(2))
+        .enumerate()
+        .for_each(|(idx, (offset, offsets))| {
+            let start = offsets[0].as_usize();
+            let end = offsets[1].as_usize();
+            let range = array.is_valid(idx).then_some(start..end);
+            let out = &mut data[*offset..];
+            *offset += encode_one(out, &mut temporary, rows, range, opts)
+        });
+}
+
+#[inline]
+fn encode_one(
+    out: &mut [u8],
+    temporary: &mut Vec<u8>,
+    rows: &Rows,
+    range: Option<Range<usize>>,
+    opts: SortOptions,
+) -> usize {
+    temporary.clear();
+
+    match range {
+        None => super::variable::encode_one(out, None, opts),
+        Some(range) if range.start == range.end => {
+            super::variable::encode_one(out, Some(&[]), opts)
+        }
+        Some(range) => {
+            for row in range.clone().map(|i| rows.row(i)) {
+                temporary.extend_from_slice(row.as_ref());
+            }
+            for row in range.clone().map(|i| rows.row(i)) {
+                let len: u32 = row
+                    .as_ref()
+                    .len()
+                    .try_into()
+                    .expect("ListArray or LargeListArray containing a list of more than u32::MAX items is not supported");
+                temporary.extend_from_slice(&len.to_be_bytes());
+            }
+            let row_count: u32 = (range.end - range.start)
+                .try_into()
+                .expect("lists containing more than u32::MAX elements not supported");
+            temporary.extend_from_slice(&row_count.to_be_bytes());
+            super::variable::encode_one(out, Some(temporary), opts)
+        }
+    }
+}
+
+/// Decodes a string array from `rows` with the provided `options`
+///
+/// # Safety
+///
+/// `rows` must contain valid data for the provided `converter`
+pub unsafe fn decode<O: OffsetSizeTrait>(
+    converter: &RowConverter,
+    rows: &mut [&[u8]],
+    field: &SortField,
+    validate_utf8: bool,
+) -> Result<GenericListArray<O>, ArrowError> {
+    let canonical = super::variable::decode_binary::<i64>(rows, field.options);
+
+    let mut offsets = BufferBuilder::<O>::new(rows.len() + 1);
+    offsets.append(O::from_usize(0).unwrap());
+    let mut current_offset = 0;
+
+    let mut child_rows = Vec::with_capacity(rows.len());
+    canonical.value_offsets().windows(2).for_each(|w| {
+        let start = w[0] as usize;
+        let end = w[1] as usize;
+        if start == end {
+            // Null or empty list
+            offsets.append(O::from_usize(current_offset).unwrap());
+            return;
+        }
+
+        let row = &canonical.value_data()[start..end];
+        let element_count_start = row.len() - 4;
+        let element_count =
+            u32::from_be_bytes((&row[element_count_start..]).try_into().unwrap()) as usize;
+
+        let lengths_start = element_count_start - (element_count * 4);
+        let mut row_offset = 0;
+        row[lengths_start..element_count_start]
+            .chunks_exact(4)
+            .for_each(|chunk| {
+                let len = u32::from_be_bytes(chunk.try_into().unwrap());
+                let next_row_offset = row_offset + len as usize;
+                child_rows.push(&row[row_offset..next_row_offset]);
+                row_offset = next_row_offset;
+            });
+
+        current_offset += element_count;
+        offsets.append(O::from_usize(current_offset).unwrap());
+    });
+
+    let child = converter.convert_raw(&mut child_rows, validate_utf8)?;
+    assert_eq!(child.len(), 1);
+    let child_data = child[0].to_data();
+
+    let builder = ArrayDataBuilder::new(field.data_type.clone())
+        .len(rows.len())
+        .nulls(canonical.nulls().cloned())
+        .add_buffer(offsets.finish())
+        .add_child_data(child_data);
+
+    Ok(GenericListArray::from(unsafe { builder.build_unchecked() }))
+}
diff --git a/arrow-row/src/variable.rs b/arrow-row/src/variable.rs
new file mode 100644
index 000000000000..466214e7540e
--- /dev/null
+++ b/arrow-row/src/variable.rs
@@ -0,0 +1,266 @@
+// 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.
+
+use crate::null_sentinel;
+use arrow_array::builder::BufferBuilder;
+use arrow_array::*;
+use arrow_buffer::bit_util::ceil;
+use arrow_buffer::MutableBuffer;
+use arrow_data::ArrayDataBuilder;
+use arrow_schema::{DataType, SortOptions};
+
+/// The block size of the variable length encoding
+pub const BLOCK_SIZE: usize = 32;
+
+/// The first block is split into `MINI_BLOCK_COUNT` mini-blocks
+///
+/// This helps to reduce the space amplification for small strings
+pub const MINI_BLOCK_COUNT: usize = 4;
+
+/// The mini block size
+pub const MINI_BLOCK_SIZE: usize = BLOCK_SIZE / MINI_BLOCK_COUNT;
+
+/// The continuation token
+pub const BLOCK_CONTINUATION: u8 = 0xFF;
+
+/// Indicates an empty string
+pub const EMPTY_SENTINEL: u8 = 1;
+
+/// Indicates a non-empty string
+pub const NON_EMPTY_SENTINEL: u8 = 2;
+
+/// Returns the length of the encoded representation of a byte array, including the null byte
+#[inline]
+pub fn encoded_len(a: Option<&[u8]>) -> usize {
+    padded_length(a.map(|x| x.len()))
+}
+
+/// Returns the padded length of the encoded length of the given length
+#[inline]
+pub fn padded_length(a: Option<usize>) -> usize {
+    match a {
+        Some(a) if a <= BLOCK_SIZE => 1 + ceil(a, MINI_BLOCK_SIZE) * (MINI_BLOCK_SIZE + 1),
+        // Each miniblock ends with a 1 byte continuation, therefore add
+        // `(MINI_BLOCK_COUNT - 1)` additional bytes over non-miniblock size
+        Some(a) => MINI_BLOCK_COUNT + ceil(a, BLOCK_SIZE) * (BLOCK_SIZE + 1),
+        None => 1,
+    }
+}
+
+/// Variable length values are encoded as
+///
+/// - single `0_u8` if null
+/// - single `1_u8` if empty array
+/// - `2_u8` if not empty, followed by one or more blocks
+///
+/// where a block is encoded as
+///
+/// - [`BLOCK_SIZE`] bytes of string data, padded with 0s
+/// - `0xFF_u8` if this is not the last block for this string
+/// - otherwise the length of the block as a `u8`
+pub fn encode<'a, I: Iterator<Item = Option<&'a [u8]>>>(
+    data: &mut [u8],
+    offsets: &mut [usize],
+    i: I,
+    opts: SortOptions,
+) {
+    for (offset, maybe_val) in offsets.iter_mut().skip(1).zip(i) {
+        *offset += encode_one(&mut data[*offset..], maybe_val, opts);
+    }
+}
+
+pub fn encode_one(out: &mut [u8], val: Option<&[u8]>, opts: SortOptions) -> usize {
+    match val {
+        Some([]) => {
+            out[0] = match opts.descending {
+                true => !EMPTY_SENTINEL,
+                false => EMPTY_SENTINEL,
+            };
+            1
+        }
+        Some(val) => {
+            // Write `2_u8` to demarcate as non-empty, non-null string
+            out[0] = NON_EMPTY_SENTINEL;
+
+            let len = if val.len() <= BLOCK_SIZE {
+                1 + encode_blocks::<MINI_BLOCK_SIZE>(&mut out[1..], val)
+            } else {
+                let (initial, rem) = val.split_at(BLOCK_SIZE);
+                let offset = encode_blocks::<MINI_BLOCK_SIZE>(&mut out[1..], initial);
+                out[offset] = BLOCK_CONTINUATION;
+                1 + offset + encode_blocks::<BLOCK_SIZE>(&mut out[1 + offset..], rem)
+            };
+
+            if opts.descending {
+                // Invert bits
+                out[..len].iter_mut().for_each(|v| *v = !*v)
+            }
+            len
+        }
+        None => {
+            out[0] = null_sentinel(opts);
+            1
+        }
+    }
+}
+
+/// Writes `val` in `SIZE` blocks with the appropriate continuation tokens
+#[inline]
+fn encode_blocks<const SIZE: usize>(out: &mut [u8], val: &[u8]) -> usize {
+    let block_count = ceil(val.len(), SIZE);
+    let end_offset = block_count * (SIZE + 1);
+    let to_write = &mut out[..end_offset];
+
+    let chunks = val.chunks_exact(SIZE);
+    let remainder = chunks.remainder();
+    for (input, output) in chunks.clone().zip(to_write.chunks_exact_mut(SIZE + 1)) {
+        let input: &[u8; SIZE] = input.try_into().unwrap();
+        let out_block: &mut [u8; SIZE] = (&mut output[..SIZE]).try_into().unwrap();
+
+        *out_block = *input;
+
+        // Indicate that there are further blocks to follow
+        output[SIZE] = BLOCK_CONTINUATION;
+    }
+
+    if !remainder.is_empty() {
+        let start_offset = (block_count - 1) * (SIZE + 1);
+        to_write[start_offset..start_offset + remainder.len()].copy_from_slice(remainder);
+        *to_write.last_mut().unwrap() = remainder.len() as u8;
+    } else {
+        // We must overwrite the continuation marker written by the loop above
+        *to_write.last_mut().unwrap() = SIZE as u8;
+    }
+    end_offset
+}
+
+fn decode_blocks(row: &[u8], options: SortOptions, mut f: impl FnMut(&[u8])) -> usize {
+    let (non_empty_sentinel, continuation) = match options.descending {
+        true => (!NON_EMPTY_SENTINEL, !BLOCK_CONTINUATION),
+        false => (NON_EMPTY_SENTINEL, BLOCK_CONTINUATION),
+    };
+
+    if row[0] != non_empty_sentinel {
+        // Empty or null string
+        return 1;
+    }
+
+    // Extracts the block length from the sentinel
+    let block_len = |sentinel: u8| match options.descending {
+        true => !sentinel as usize,
+        false => sentinel as usize,
+    };
+
+    let mut idx = 1;
+    for _ in 0..MINI_BLOCK_COUNT {
+        let sentinel = row[idx + MINI_BLOCK_SIZE];
+        if sentinel != continuation {
+            f(&row[idx..idx + block_len(sentinel)]);
+            return idx + MINI_BLOCK_SIZE + 1;
+        }
+        f(&row[idx..idx + MINI_BLOCK_SIZE]);
+        idx += MINI_BLOCK_SIZE + 1;
+    }
+
+    loop {
+        let sentinel = row[idx + BLOCK_SIZE];
+        if sentinel != continuation {
+            f(&row[idx..idx + block_len(sentinel)]);
+            return idx + BLOCK_SIZE + 1;
+        }
+        f(&row[idx..idx + BLOCK_SIZE]);
+        idx += BLOCK_SIZE + 1;
+    }
+}
+
+/// Returns the number of bytes of encoded data
+fn decoded_len(row: &[u8], options: SortOptions) -> usize {
+    let mut len = 0;
+    decode_blocks(row, options, |block| len += block.len());
+    len
+}
+
+/// Decodes a binary array from `rows` with the provided `options`
+pub fn decode_binary<I: OffsetSizeTrait>(
+    rows: &mut [&[u8]],
+    options: SortOptions,
+) -> GenericBinaryArray<I> {
+    let len = rows.len();
+    let mut null_count = 0;
+    let nulls = MutableBuffer::collect_bool(len, |x| {
+        let valid = rows[x][0] != null_sentinel(options);
+        null_count += !valid as usize;
+        valid
+    });
+
+    let values_capacity = rows.iter().map(|row| decoded_len(row, options)).sum();
+    let mut offsets = BufferBuilder::<I>::new(len + 1);
+    offsets.append(I::zero());
+    let mut values = MutableBuffer::new(values_capacity);
+
+    for row in rows {
+        let offset = decode_blocks(row, options, |b| values.extend_from_slice(b));
+        *row = &row[offset..];
+        offsets.append(I::from_usize(values.len()).expect("offset overflow"))
+    }
+
+    if options.descending {
+        values.as_slice_mut().iter_mut().for_each(|o| *o = !*o)
+    }
+
+    let d = match I::IS_LARGE {
+        true => DataType::LargeBinary,
+        false => DataType::Binary,
+    };
+
+    let builder = ArrayDataBuilder::new(d)
+        .len(len)
+        .null_count(null_count)
+        .null_bit_buffer(Some(nulls.into()))
+        .add_buffer(offsets.finish())
+        .add_buffer(values.into());
+
+    // SAFETY:
+    // Valid by construction above
+    unsafe { GenericBinaryArray::from(builder.build_unchecked()) }
+}
+
+/// Decodes a string array from `rows` with the provided `options`
+///
+/// # Safety
+///
+/// The row must contain valid UTF-8 data
+pub unsafe fn decode_string<I: OffsetSizeTrait>(
+    rows: &mut [&[u8]],
+    options: SortOptions,
+    validate_utf8: bool,
+) -> GenericStringArray<I> {
+    let decoded = decode_binary::<I>(rows, options);
+
+    if validate_utf8 {
+        return GenericStringArray::from(decoded);
+    }
+
+    let builder = decoded
+        .into_data()
+        .into_builder()
+        .data_type(GenericStringArray::<I>::DATA_TYPE);
+
+    // SAFETY:
+    // Row data must have come from a valid UTF-8 array
+    GenericStringArray::from(builder.build_unchecked())
+}
diff --git a/arrow-schema/Cargo.toml b/arrow-schema/Cargo.toml
new file mode 100644
index 000000000000..628d4a683cac
--- /dev/null
+++ b/arrow-schema/Cargo.toml
@@ -0,0 +1,49 @@
+# 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]
+name = "arrow-schema"
+version = { workspace = true }
+description = "Defines the logical types for arrow arrays"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_schema"
+path = "src/lib.rs"
+bench = false
+
+[dependencies]
+serde = { version = "1.0", default-features = false, features = ["derive", "std", "rc"], optional = true }
+bitflags = { version = "2.0.0", default-features = false, optional = true }
+
+[features]
+# Enable ffi support
+ffi = ["bitflags"]
+
+[package.metadata.docs.rs]
+features = ["ffi"]
+
+[dev-dependencies]
+serde_json = "1.0"
+bincode = { version = "1.3.3", default-features = false }
diff --git a/arrow-schema/src/datatype.rs b/arrow-schema/src/datatype.rs
new file mode 100644
index 000000000000..079b855ce990
--- /dev/null
+++ b/arrow-schema/src/datatype.rs
@@ -0,0 +1,945 @@
+// 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.
+
+use std::fmt;
+use std::sync::Arc;
+
+use crate::{Field, FieldRef, Fields, UnionFields};
+
+/// The set of datatypes that are supported by this implementation of Apache Arrow.
+///
+/// The Arrow specification on data types includes some more types.
+/// See also [`Schema.fbs`](https://github.com/apache/arrow/blob/main/format/Schema.fbs)
+/// for Arrow's specification.
+///
+/// The variants of this enum include primitive fixed size types as well as parametric or
+/// nested types.
+/// Currently the Rust implementation supports the following nested types:
+///  - `List<T>`
+///  - `LargeList<T>`
+///  - `FixedSizeList<T>`
+///  - `Struct<T, U, V, ...>`
+///  - `Union<T, U, V, ...>`
+///  - `Map<K, V>`
+///
+/// Nested types can themselves be nested within other arrays.
+/// For more information on these types please see
+/// [the physical memory layout of Apache Arrow](https://arrow.apache.org/docs/format/Columnar.html#physical-memory-layout).
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum DataType {
+    /// Null type
+    Null,
+    /// A boolean datatype representing the values `true` and `false`.
+    Boolean,
+    /// A signed 8-bit integer.
+    Int8,
+    /// A signed 16-bit integer.
+    Int16,
+    /// A signed 32-bit integer.
+    Int32,
+    /// A signed 64-bit integer.
+    Int64,
+    /// An unsigned 8-bit integer.
+    UInt8,
+    /// An unsigned 16-bit integer.
+    UInt16,
+    /// An unsigned 32-bit integer.
+    UInt32,
+    /// An unsigned 64-bit integer.
+    UInt64,
+    /// A 16-bit floating point number.
+    Float16,
+    /// A 32-bit floating point number.
+    Float32,
+    /// A 64-bit floating point number.
+    Float64,
+    /// A timestamp with an optional timezone.
+    ///
+    /// Time is measured as a Unix epoch, counting the seconds from
+    /// 00:00:00.000 on 1 January 1970, excluding leap seconds,
+    /// as a signed 64-bit integer.
+    ///
+    /// The time zone is a string indicating the name of a time zone, one of:
+    ///
+    /// * As used in the Olson time zone database (the "tz database" or
+    ///   "tzdata"), such as "America/New_York"
+    /// * An absolute time zone offset of the form +XX:XX or -XX:XX, such as +07:30
+    ///
+    /// Timestamps with a non-empty timezone
+    /// ------------------------------------
+    ///
+    /// If a Timestamp column has a non-empty timezone value, its epoch is
+    /// 1970-01-01 00:00:00 (January 1st 1970, midnight) in the *UTC* timezone
+    /// (the Unix epoch), regardless of the Timestamp's own timezone.
+    ///
+    /// Therefore, timestamp values with a non-empty timezone correspond to
+    /// physical points in time together with some additional information about
+    /// how the data was obtained and/or how to display it (the timezone).
+    ///
+    ///   For example, the timestamp value 0 with the timezone string "Europe/Paris"
+    ///   corresponds to "January 1st 1970, 00h00" in the UTC timezone, but the
+    ///   application may prefer to display it as "January 1st 1970, 01h00" in
+    ///   the Europe/Paris timezone (which is the same physical point in time).
+    ///
+    /// One consequence is that timestamp values with a non-empty timezone
+    /// can be compared and ordered directly, since they all share the same
+    /// well-known point of reference (the Unix epoch).
+    ///
+    /// Timestamps with an unset / empty timezone
+    /// -----------------------------------------
+    ///
+    /// If a Timestamp column has no timezone value, its epoch is
+    /// 1970-01-01 00:00:00 (January 1st 1970, midnight) in an *unknown* timezone.
+    ///
+    /// Therefore, timestamp values without a timezone cannot be meaningfully
+    /// interpreted as physical points in time, but only as calendar / clock
+    /// indications ("wall clock time") in an unspecified timezone.
+    ///
+    ///   For example, the timestamp value 0 with an empty timezone string
+    ///   corresponds to "January 1st 1970, 00h00" in an unknown timezone: there
+    ///   is not enough information to interpret it as a well-defined physical
+    ///   point in time.
+    ///
+    /// One consequence is that timestamp values without a timezone cannot
+    /// be reliably compared or ordered, since they may have different points of
+    /// reference.  In particular, it is *not* possible to interpret an unset
+    /// or empty timezone as the same as "UTC".
+    ///
+    /// Conversion between timezones
+    /// ----------------------------
+    ///
+    /// If a Timestamp column has a non-empty timezone, changing the timezone
+    /// to a different non-empty value is a metadata-only operation:
+    /// the timestamp values need not change as their point of reference remains
+    /// the same (the Unix epoch).
+    ///
+    /// However, if a Timestamp column has no timezone value, changing it to a
+    /// non-empty value requires to think about the desired semantics.
+    /// One possibility is to assume that the original timestamp values are
+    /// relative to the epoch of the timezone being set; timestamp values should
+    /// then adjusted to the Unix epoch (for example, changing the timezone from
+    /// empty to "Europe/Paris" would require converting the timestamp values
+    /// from "Europe/Paris" to "UTC", which seems counter-intuitive but is
+    /// nevertheless correct).
+    ///
+    /// ```
+    /// # use arrow_schema::{DataType, TimeUnit};
+    /// DataType::Timestamp(TimeUnit::Second, None);
+    /// DataType::Timestamp(TimeUnit::Second, Some("literal".into()));
+    /// DataType::Timestamp(TimeUnit::Second, Some("string".to_string().into()));
+    /// ```
+    Timestamp(TimeUnit, Option<Arc<str>>),
+    /// A signed 32-bit date representing the elapsed time since UNIX epoch (1970-01-01)
+    /// in days.
+    Date32,
+    /// A signed 64-bit date representing the elapsed time since UNIX epoch (1970-01-01)
+    /// in milliseconds.
+    ///
+    /// According to the specification (see [Schema.fbs]), this should be treated as the number of
+    /// days, in milliseconds, since the UNIX epoch. Therefore, values must be evenly divisible by
+    /// `86_400_000` (the number of milliseconds in a standard day).
+    ///
+    /// The reason for this is for compatibility with other language's native libraries,
+    /// such as Java, which historically lacked a dedicated date type
+    /// and only supported timestamps.
+    ///
+    /// Practically, validation that values of this type are evenly divisible by `86_400_000` is not enforced
+    /// by this library for performance and usability reasons. Date64 values will be treated similarly to the
+    /// `Timestamp(TimeUnit::Millisecond, None)` type, in that its values will be printed showing the time of
+    /// day if the value does not represent an exact day, and arithmetic can be done at the millisecond
+    /// granularity to change the time represented.
+    ///
+    /// Users should prefer using Date32 to cleanly represent the number of days, or one of the Timestamp
+    /// variants to include time as part of the representation, depending on their use case.
+    ///
+    /// For more details, see [#5288](https://github.com/apache/arrow-rs/issues/5288).
+    ///
+    /// [Schema.fbs]: https://github.com/apache/arrow/blob/main/format/Schema.fbs
+    Date64,
+    /// A signed 32-bit time representing the elapsed time since midnight in the unit of `TimeUnit`.
+    /// Must be either seconds or milliseconds.
+    Time32(TimeUnit),
+    /// A signed 64-bit time representing the elapsed time since midnight in the unit of `TimeUnit`.
+    /// Must be either microseconds or nanoseconds.
+    Time64(TimeUnit),
+    /// Measure of elapsed time in either seconds, milliseconds, microseconds or nanoseconds.
+    Duration(TimeUnit),
+    /// A "calendar" interval which models types that don't necessarily
+    /// have a precise duration without the context of a base timestamp (e.g.
+    /// days can differ in length during day light savings time transitions).
+    Interval(IntervalUnit),
+    /// Opaque binary data of variable length.
+    ///
+    /// A single Binary array can store up to [`i32::MAX`] bytes
+    /// of binary data in total.
+    Binary,
+    /// Opaque binary data of fixed size.
+    /// Enum parameter specifies the number of bytes per value.
+    FixedSizeBinary(i32),
+    /// Opaque binary data of variable length and 64-bit offsets.
+    ///
+    /// A single LargeBinary array can store up to [`i64::MAX`] bytes
+    /// of binary data in total.
+    LargeBinary,
+    /// A variable-length string in Unicode with UTF-8 encoding.
+    ///
+    /// A single Utf8 array can store up to [`i32::MAX`] bytes
+    /// of string data in total.
+    Utf8,
+    /// A variable-length string in Unicode with UFT-8 encoding and 64-bit offsets.
+    ///
+    /// A single LargeUtf8 array can store up to [`i64::MAX`] bytes
+    /// of string data in total.
+    LargeUtf8,
+    /// A list of some logical data type with variable length.
+    ///
+    /// A single List array can store up to [`i32::MAX`] elements in total.
+    List(FieldRef),
+    /// A list of some logical data type with fixed length.
+    FixedSizeList(FieldRef, i32),
+    /// A list of some logical data type with variable length and 64-bit offsets.
+    ///
+    /// A single LargeList array can store up to [`i64::MAX`] elements in total.
+    LargeList(FieldRef),
+    /// A nested datatype that contains a number of sub-fields.
+    Struct(Fields),
+    /// A nested datatype that can represent slots of differing types. Components:
+    ///
+    /// 1. [`UnionFields`]
+    /// 2. The type of union (Sparse or Dense)
+    Union(UnionFields, UnionMode),
+    /// A dictionary encoded array (`key_type`, `value_type`), where
+    /// each array element is an index of `key_type` into an
+    /// associated dictionary of `value_type`.
+    ///
+    /// Dictionary arrays are used to store columns of `value_type`
+    /// that contain many repeated values using less memory, but with
+    /// a higher CPU overhead for some operations.
+    ///
+    /// This type mostly used to represent low cardinality string
+    /// arrays or a limited set of primitive types as integers.
+    Dictionary(Box<DataType>, Box<DataType>),
+    /// Exact 128-bit width decimal value with precision and scale
+    ///
+    /// * precision is the total number of digits
+    /// * scale is the number of digits past the decimal
+    ///
+    /// For example the number 123.45 has precision 5 and scale 2.
+    ///
+    /// In certain situations, scale could be negative number. For
+    /// negative scale, it is the number of padding 0 to the right
+    /// of the digits.
+    ///
+    /// For example the number 12300 could be treated as a decimal
+    /// has precision 3 and scale -2.
+    Decimal128(u8, i8),
+    /// Exact 256-bit width decimal value with precision and scale
+    ///
+    /// * precision is the total number of digits
+    /// * scale is the number of digits past the decimal
+    ///
+    /// For example the number 123.45 has precision 5 and scale 2.
+    ///
+    /// In certain situations, scale could be negative number. For
+    /// negative scale, it is the number of padding 0 to the right
+    /// of the digits.
+    ///
+    /// For example the number 12300 could be treated as a decimal
+    /// has precision 3 and scale -2.
+    Decimal256(u8, i8),
+    /// A Map is a logical nested type that is represented as
+    ///
+    /// `List<entries: Struct<key: K, value: V>>`
+    ///
+    /// The keys and values are each respectively contiguous.
+    /// The key and value types are not constrained, but keys should be
+    /// hashable and unique.
+    /// Whether the keys are sorted can be set in the `bool` after the `Field`.
+    ///
+    /// In a field with Map type, the field has a child Struct field, which then
+    /// has two children: key type and the second the value type. The names of the
+    /// child fields may be respectively "entries", "key", and "value", but this is
+    /// not enforced.
+    Map(FieldRef, bool),
+    /// A run-end encoding (REE) is a variation of run-length encoding (RLE). These
+    /// encodings are well-suited for representing data containing sequences of the
+    /// same value, called runs. Each run is represented as a value and an integer giving
+    /// the index in the array where the run ends.
+    ///
+    /// A run-end encoded array has no buffers by itself, but has two child arrays. The
+    /// first child array, called the run ends array, holds either 16, 32, or 64-bit
+    /// signed integers. The actual values of each run are held in the second child array.
+    ///
+    /// These child arrays are prescribed the standard names of "run_ends" and "values"
+    /// respectively.
+    RunEndEncoded(FieldRef, FieldRef),
+}
+
+/// An absolute length of time in seconds, milliseconds, microseconds or nanoseconds.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum TimeUnit {
+    /// Time in seconds.
+    Second,
+    /// Time in milliseconds.
+    Millisecond,
+    /// Time in microseconds.
+    Microsecond,
+    /// Time in nanoseconds.
+    Nanosecond,
+}
+
+/// YEAR_MONTH, DAY_TIME, MONTH_DAY_NANO interval in SQL style.
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum IntervalUnit {
+    /// Indicates the number of elapsed whole months, stored as 4-byte integers.
+    YearMonth,
+    /// Indicates the number of elapsed days and milliseconds,
+    /// stored as 2 contiguous 32-bit integers (days, milliseconds) (8-bytes in total).
+    DayTime,
+    /// A triple of the number of elapsed months, days, and nanoseconds.
+    /// The values are stored contiguously in 16 byte blocks. Months and
+    /// days are encoded as 32 bit integers and nanoseconds is encoded as a
+    /// 64 bit integer. All integers are signed. Each field is independent
+    /// (e.g. there is no constraint that nanoseconds have the same sign
+    /// as days or that the quantity of nanoseconds represents less
+    /// than a day's worth of time).
+    MonthDayNano,
+}
+
+// Sparse or Dense union layouts
+#[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Copy)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub enum UnionMode {
+    Sparse,
+    Dense,
+}
+
+impl fmt::Display for DataType {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "{self:?}")
+    }
+}
+
+impl DataType {
+    /// Returns true if the type is primitive: (numeric, temporal).
+    #[inline]
+    pub fn is_primitive(&self) -> bool {
+        self.is_numeric() || self.is_temporal()
+    }
+
+    /// Returns true if this type is numeric: (UInt*, Int*, Float*, Decimal*).
+    #[inline]
+    pub fn is_numeric(&self) -> bool {
+        use DataType::*;
+        matches!(
+            self,
+            UInt8
+                | UInt16
+                | UInt32
+                | UInt64
+                | Int8
+                | Int16
+                | Int32
+                | Int64
+                | Float16
+                | Float32
+                | Float64
+                | Decimal128(_, _)
+                | Decimal256(_, _)
+        )
+    }
+
+    /// Returns true if this type is temporal: (Date*, Time*, Duration, or Interval).
+    #[inline]
+    pub fn is_temporal(&self) -> bool {
+        use DataType::*;
+        matches!(
+            self,
+            Date32 | Date64 | Timestamp(_, _) | Time32(_) | Time64(_) | Duration(_) | Interval(_)
+        )
+    }
+
+    /// Returns true if this type is floating: (Float*).
+    #[inline]
+    pub fn is_floating(&self) -> bool {
+        use DataType::*;
+        matches!(self, Float16 | Float32 | Float64)
+    }
+
+    /// Returns true if this type is integer: (Int*, UInt*).
+    #[inline]
+    pub fn is_integer(&self) -> bool {
+        self.is_signed_integer() || self.is_unsigned_integer()
+    }
+
+    /// Returns true if this type is signed integer: (Int*).
+    #[inline]
+    pub fn is_signed_integer(&self) -> bool {
+        use DataType::*;
+        matches!(self, Int8 | Int16 | Int32 | Int64)
+    }
+
+    /// Returns true if this type is unsigned integer: (UInt*).
+    #[inline]
+    pub fn is_unsigned_integer(&self) -> bool {
+        use DataType::*;
+        matches!(self, UInt8 | UInt16 | UInt32 | UInt64)
+    }
+
+    /// Returns true if this type is valid as a dictionary key
+    #[inline]
+    pub fn is_dictionary_key_type(&self) -> bool {
+        self.is_integer()
+    }
+
+    /// Returns true if this type is valid for run-ends array in RunArray
+    #[inline]
+    pub fn is_run_ends_type(&self) -> bool {
+        use DataType::*;
+        matches!(self, Int16 | Int32 | Int64)
+    }
+
+    /// Returns true if this type is nested (List, FixedSizeList, LargeList, Struct, Union,
+    /// or Map), or a dictionary of a nested type
+    #[inline]
+    pub fn is_nested(&self) -> bool {
+        use DataType::*;
+        match self {
+            Dictionary(_, v) => DataType::is_nested(v.as_ref()),
+            List(_) | FixedSizeList(_, _) | LargeList(_) | Struct(_) | Union(_, _) | Map(_, _) => {
+                true
+            }
+            _ => false,
+        }
+    }
+
+    /// Returns true if this type is DataType::Null.
+    #[inline]
+    pub fn is_null(&self) -> bool {
+        use DataType::*;
+        matches!(self, Null)
+    }
+
+    /// Compares the datatype with another, ignoring nested field names
+    /// and metadata.
+    pub fn equals_datatype(&self, other: &DataType) -> bool {
+        match (&self, other) {
+            (DataType::List(a), DataType::List(b))
+            | (DataType::LargeList(a), DataType::LargeList(b)) => {
+                a.is_nullable() == b.is_nullable() && a.data_type().equals_datatype(b.data_type())
+            }
+            (DataType::FixedSizeList(a, a_size), DataType::FixedSizeList(b, b_size)) => {
+                a_size == b_size
+                    && a.is_nullable() == b.is_nullable()
+                    && a.data_type().equals_datatype(b.data_type())
+            }
+            (DataType::Struct(a), DataType::Struct(b)) => {
+                a.len() == b.len()
+                    && a.iter().zip(b).all(|(a, b)| {
+                        a.is_nullable() == b.is_nullable()
+                            && a.data_type().equals_datatype(b.data_type())
+                    })
+            }
+            (DataType::Map(a_field, a_is_sorted), DataType::Map(b_field, b_is_sorted)) => {
+                a_field.is_nullable() == b_field.is_nullable()
+                    && a_field.data_type().equals_datatype(b_field.data_type())
+                    && a_is_sorted == b_is_sorted
+            }
+            (DataType::Dictionary(a_key, a_value), DataType::Dictionary(b_key, b_value)) => {
+                a_key.equals_datatype(b_key) && a_value.equals_datatype(b_value)
+            }
+            (
+                DataType::RunEndEncoded(a_run_ends, a_values),
+                DataType::RunEndEncoded(b_run_ends, b_values),
+            ) => {
+                a_run_ends.is_nullable() == b_run_ends.is_nullable()
+                    && a_run_ends
+                        .data_type()
+                        .equals_datatype(b_run_ends.data_type())
+                    && a_values.is_nullable() == b_values.is_nullable()
+                    && a_values.data_type().equals_datatype(b_values.data_type())
+            }
+            (
+                DataType::Union(a_union_fields, a_union_mode),
+                DataType::Union(b_union_fields, b_union_mode),
+            ) => {
+                a_union_mode == b_union_mode
+                    && a_union_fields.len() == b_union_fields.len()
+                    && a_union_fields.iter().all(|a| {
+                        b_union_fields.iter().any(|b| {
+                            a.0 == b.0
+                                && a.1.is_nullable() == b.1.is_nullable()
+                                && a.1.data_type().equals_datatype(b.1.data_type())
+                        })
+                    })
+            }
+            _ => self == other,
+        }
+    }
+
+    /// Returns the bit width of this type if it is a primitive type
+    ///
+    /// Returns `None` if not a primitive type
+    #[inline]
+    pub fn primitive_width(&self) -> Option<usize> {
+        match self {
+            DataType::Null => None,
+            DataType::Boolean => None,
+            DataType::Int8 | DataType::UInt8 => Some(1),
+            DataType::Int16 | DataType::UInt16 | DataType::Float16 => Some(2),
+            DataType::Int32 | DataType::UInt32 | DataType::Float32 => Some(4),
+            DataType::Int64 | DataType::UInt64 | DataType::Float64 => Some(8),
+            DataType::Timestamp(_, _) => Some(8),
+            DataType::Date32 | DataType::Time32(_) => Some(4),
+            DataType::Date64 | DataType::Time64(_) => Some(8),
+            DataType::Duration(_) => Some(8),
+            DataType::Interval(IntervalUnit::YearMonth) => Some(4),
+            DataType::Interval(IntervalUnit::DayTime) => Some(8),
+            DataType::Interval(IntervalUnit::MonthDayNano) => Some(16),
+            DataType::Decimal128(_, _) => Some(16),
+            DataType::Decimal256(_, _) => Some(32),
+            DataType::Utf8 | DataType::LargeUtf8 => None,
+            DataType::Binary | DataType::LargeBinary => None,
+            DataType::FixedSizeBinary(_) => None,
+            DataType::List(_) | DataType::LargeList(_) | DataType::Map(_, _) => None,
+            DataType::FixedSizeList(_, _) => None,
+            DataType::Struct(_) => None,
+            DataType::Union(_, _) => None,
+            DataType::Dictionary(_, _) => None,
+            DataType::RunEndEncoded(_, _) => None,
+        }
+    }
+
+    /// Return size of this instance in bytes.
+    ///
+    /// Includes the size of `Self`.
+    pub fn size(&self) -> usize {
+        std::mem::size_of_val(self)
+            + match self {
+                DataType::Null
+                | DataType::Boolean
+                | DataType::Int8
+                | DataType::Int16
+                | DataType::Int32
+                | DataType::Int64
+                | DataType::UInt8
+                | DataType::UInt16
+                | DataType::UInt32
+                | DataType::UInt64
+                | DataType::Float16
+                | DataType::Float32
+                | DataType::Float64
+                | DataType::Date32
+                | DataType::Date64
+                | DataType::Time32(_)
+                | DataType::Time64(_)
+                | DataType::Duration(_)
+                | DataType::Interval(_)
+                | DataType::Binary
+                | DataType::FixedSizeBinary(_)
+                | DataType::LargeBinary
+                | DataType::Utf8
+                | DataType::LargeUtf8
+                | DataType::Decimal128(_, _)
+                | DataType::Decimal256(_, _) => 0,
+                DataType::Timestamp(_, s) => s.as_ref().map(|s| s.len()).unwrap_or_default(),
+                DataType::List(field)
+                | DataType::FixedSizeList(field, _)
+                | DataType::LargeList(field)
+                | DataType::Map(field, _) => field.size(),
+                DataType::Struct(fields) => fields.size(),
+                DataType::Union(fields, _) => fields.size(),
+                DataType::Dictionary(dt1, dt2) => dt1.size() + dt2.size(),
+                DataType::RunEndEncoded(run_ends, values) => {
+                    run_ends.size() - std::mem::size_of_val(run_ends) + values.size()
+                        - std::mem::size_of_val(values)
+                }
+            }
+    }
+
+    /// Check to see if `self` is a superset of `other`
+    ///
+    /// If DataType is a nested type, then it will check to see if the nested type is a superset of the other nested type
+    /// else it will check to see if the DataType is equal to the other DataType
+    pub fn contains(&self, other: &DataType) -> bool {
+        match (self, other) {
+            (DataType::List(f1), DataType::List(f2))
+            | (DataType::LargeList(f1), DataType::LargeList(f2)) => f1.contains(f2),
+            (DataType::FixedSizeList(f1, s1), DataType::FixedSizeList(f2, s2)) => {
+                s1 == s2 && f1.contains(f2)
+            }
+            (DataType::Map(f1, s1), DataType::Map(f2, s2)) => s1 == s2 && f1.contains(f2),
+            (DataType::Struct(f1), DataType::Struct(f2)) => f1.contains(f2),
+            (DataType::Union(f1, s1), DataType::Union(f2, s2)) => {
+                s1 == s2
+                    && f1
+                        .iter()
+                        .all(|f1| f2.iter().any(|f2| f1.0 == f2.0 && f1.1.contains(f2.1)))
+            }
+            (DataType::Dictionary(k1, v1), DataType::Dictionary(k2, v2)) => {
+                k1.contains(k2) && v1.contains(v2)
+            }
+            _ => self == other,
+        }
+    }
+
+    /// Create a [`DataType::List`] with elements of the specified type
+    /// and nullability, and conventionally named inner [`Field`] (`"item"`).
+    ///
+    /// To specify field level metadata, construct the inner [`Field`]
+    /// directly via [`Field::new`] or [`Field::new_list_field`].
+    pub fn new_list(data_type: DataType, nullable: bool) -> Self {
+        DataType::List(Arc::new(Field::new_list_field(data_type, nullable)))
+    }
+
+    /// Create a [`DataType::LargeList`] with elements of the specified type
+    /// and nullability, and conventionally named inner [`Field`] (`"item"`).
+    ///
+    /// To specify field level metadata, construct the inner [`Field`]
+    /// directly via [`Field::new`] or [`Field::new_list_field`].
+    pub fn new_large_list(data_type: DataType, nullable: bool) -> Self {
+        DataType::LargeList(Arc::new(Field::new_list_field(data_type, nullable)))
+    }
+
+    /// Create a [`DataType::FixedSizeList`] with elements of the specified type, size
+    /// and nullability, and conventionally named inner [`Field`] (`"item"`).
+    ///
+    /// To specify field level metadata, construct the inner [`Field`]
+    /// directly via [`Field::new`] or [`Field::new_list_field`].
+    pub fn new_fixed_size_list(data_type: DataType, size: i32, nullable: bool) -> Self {
+        DataType::FixedSizeList(Arc::new(Field::new_list_field(data_type, nullable)), size)
+    }
+}
+
+/// The maximum precision for [DataType::Decimal128] values
+pub const DECIMAL128_MAX_PRECISION: u8 = 38;
+
+/// The maximum scale for [DataType::Decimal128] values
+pub const DECIMAL128_MAX_SCALE: i8 = 38;
+
+/// The maximum precision for [DataType::Decimal256] values
+pub const DECIMAL256_MAX_PRECISION: u8 = 76;
+
+/// The maximum scale for [DataType::Decimal256] values
+pub const DECIMAL256_MAX_SCALE: i8 = 76;
+
+/// The default scale for [DataType::Decimal128] and [DataType::Decimal256]
+/// values
+pub const DECIMAL_DEFAULT_SCALE: i8 = 10;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{Field, UnionMode};
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn serde_struct_type() {
+        use std::collections::HashMap;
+
+        let kv_array = [("k".to_string(), "v".to_string())];
+        let field_metadata: HashMap<String, String> = kv_array.iter().cloned().collect();
+
+        // Non-empty map: should be converted as JSON obj { ... }
+        let first_name =
+            Field::new("first_name", DataType::Utf8, false).with_metadata(field_metadata);
+
+        // Empty map: should be omitted.
+        let last_name =
+            Field::new("last_name", DataType::Utf8, false).with_metadata(HashMap::default());
+
+        let person = DataType::Struct(Fields::from(vec![
+            first_name,
+            last_name,
+            Field::new(
+                "address",
+                DataType::Struct(Fields::from(vec![
+                    Field::new("street", DataType::Utf8, false),
+                    Field::new("zip", DataType::UInt16, false),
+                ])),
+                false,
+            ),
+        ]));
+
+        let serialized = serde_json::to_string(&person).unwrap();
+
+        // NOTE that this is testing the default (derived) serialization format, not the
+        // JSON format specified in metadata.md
+
+        assert_eq!(
+            "{\"Struct\":[\
+             {\"name\":\"first_name\",\"data_type\":\"Utf8\",\"nullable\":false,\"dict_id\":0,\"dict_is_ordered\":false,\"metadata\":{\"k\":\"v\"}},\
+             {\"name\":\"last_name\",\"data_type\":\"Utf8\",\"nullable\":false,\"dict_id\":0,\"dict_is_ordered\":false,\"metadata\":{}},\
+             {\"name\":\"address\",\"data_type\":{\"Struct\":\
+             [{\"name\":\"street\",\"data_type\":\"Utf8\",\"nullable\":false,\"dict_id\":0,\"dict_is_ordered\":false,\"metadata\":{}},\
+             {\"name\":\"zip\",\"data_type\":\"UInt16\",\"nullable\":false,\"dict_id\":0,\"dict_is_ordered\":false,\"metadata\":{}}\
+             ]},\"nullable\":false,\"dict_id\":0,\"dict_is_ordered\":false,\"metadata\":{}}]}",
+            serialized
+        );
+
+        let deserialized = serde_json::from_str(&serialized).unwrap();
+
+        assert_eq!(person, deserialized);
+    }
+
+    #[test]
+    fn test_list_datatype_equality() {
+        // tests that list type equality is checked while ignoring list names
+        let list_a = DataType::List(Arc::new(Field::new("item", DataType::Int32, true)));
+        let list_b = DataType::List(Arc::new(Field::new("array", DataType::Int32, true)));
+        let list_c = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
+        let list_d = DataType::List(Arc::new(Field::new("item", DataType::UInt32, true)));
+        assert!(list_a.equals_datatype(&list_b));
+        assert!(!list_a.equals_datatype(&list_c));
+        assert!(!list_b.equals_datatype(&list_c));
+        assert!(!list_a.equals_datatype(&list_d));
+
+        let list_e =
+            DataType::FixedSizeList(Arc::new(Field::new("item", list_a.clone(), false)), 3);
+        let list_f =
+            DataType::FixedSizeList(Arc::new(Field::new("array", list_b.clone(), false)), 3);
+        let list_g = DataType::FixedSizeList(
+            Arc::new(Field::new("item", DataType::FixedSizeBinary(3), true)),
+            3,
+        );
+        assert!(list_e.equals_datatype(&list_f));
+        assert!(!list_e.equals_datatype(&list_g));
+        assert!(!list_f.equals_datatype(&list_g));
+
+        let list_h = DataType::Struct(Fields::from(vec![Field::new("f1", list_e, true)]));
+        let list_i = DataType::Struct(Fields::from(vec![Field::new("f1", list_f.clone(), true)]));
+        let list_j = DataType::Struct(Fields::from(vec![Field::new("f1", list_f.clone(), false)]));
+        let list_k = DataType::Struct(Fields::from(vec![
+            Field::new("f1", list_f.clone(), false),
+            Field::new("f2", list_g.clone(), false),
+            Field::new("f3", DataType::Utf8, true),
+        ]));
+        let list_l = DataType::Struct(Fields::from(vec![
+            Field::new("ff1", list_f.clone(), false),
+            Field::new("ff2", list_g.clone(), false),
+            Field::new("ff3", DataType::LargeUtf8, true),
+        ]));
+        let list_m = DataType::Struct(Fields::from(vec![
+            Field::new("ff1", list_f, false),
+            Field::new("ff2", list_g, false),
+            Field::new("ff3", DataType::Utf8, true),
+        ]));
+        assert!(list_h.equals_datatype(&list_i));
+        assert!(!list_h.equals_datatype(&list_j));
+        assert!(!list_k.equals_datatype(&list_l));
+        assert!(list_k.equals_datatype(&list_m));
+
+        let list_n = DataType::Map(Arc::new(Field::new("f1", list_a.clone(), true)), true);
+        let list_o = DataType::Map(Arc::new(Field::new("f2", list_b.clone(), true)), true);
+        let list_p = DataType::Map(Arc::new(Field::new("f2", list_b.clone(), true)), false);
+        let list_q = DataType::Map(Arc::new(Field::new("f2", list_c.clone(), true)), true);
+        let list_r = DataType::Map(Arc::new(Field::new("f1", list_a.clone(), false)), true);
+
+        assert!(list_n.equals_datatype(&list_o));
+        assert!(!list_n.equals_datatype(&list_p));
+        assert!(!list_n.equals_datatype(&list_q));
+        assert!(!list_n.equals_datatype(&list_r));
+
+        let list_s = DataType::Dictionary(Box::new(DataType::UInt8), Box::new(list_a));
+        let list_t = DataType::Dictionary(Box::new(DataType::UInt8), Box::new(list_b.clone()));
+        let list_u = DataType::Dictionary(Box::new(DataType::Int8), Box::new(list_b));
+        let list_v = DataType::Dictionary(Box::new(DataType::UInt8), Box::new(list_c));
+
+        assert!(list_s.equals_datatype(&list_t));
+        assert!(!list_s.equals_datatype(&list_u));
+        assert!(!list_s.equals_datatype(&list_v));
+
+        let union_a = DataType::Union(
+            UnionFields::new(
+                vec![1, 2],
+                vec![
+                    Field::new("f1", DataType::Utf8, false),
+                    Field::new("f2", DataType::UInt8, false),
+                ],
+            ),
+            UnionMode::Sparse,
+        );
+        let union_b = DataType::Union(
+            UnionFields::new(
+                vec![1, 2],
+                vec![
+                    Field::new("ff1", DataType::Utf8, false),
+                    Field::new("ff2", DataType::UInt8, false),
+                ],
+            ),
+            UnionMode::Sparse,
+        );
+        let union_c = DataType::Union(
+            UnionFields::new(
+                vec![2, 1],
+                vec![
+                    Field::new("fff2", DataType::UInt8, false),
+                    Field::new("fff1", DataType::Utf8, false),
+                ],
+            ),
+            UnionMode::Sparse,
+        );
+        let union_d = DataType::Union(
+            UnionFields::new(
+                vec![2, 1],
+                vec![
+                    Field::new("fff1", DataType::Int8, false),
+                    Field::new("fff2", DataType::UInt8, false),
+                ],
+            ),
+            UnionMode::Sparse,
+        );
+        let union_e = DataType::Union(
+            UnionFields::new(
+                vec![1, 2],
+                vec![
+                    Field::new("f1", DataType::Utf8, true),
+                    Field::new("f2", DataType::UInt8, false),
+                ],
+            ),
+            UnionMode::Sparse,
+        );
+
+        assert!(union_a.equals_datatype(&union_b));
+        assert!(union_a.equals_datatype(&union_c));
+        assert!(!union_a.equals_datatype(&union_d));
+        assert!(!union_a.equals_datatype(&union_e));
+
+        let list_w = DataType::RunEndEncoded(
+            Arc::new(Field::new("f1", DataType::Int64, true)),
+            Arc::new(Field::new("f2", DataType::Utf8, true)),
+        );
+        let list_x = DataType::RunEndEncoded(
+            Arc::new(Field::new("ff1", DataType::Int64, true)),
+            Arc::new(Field::new("ff2", DataType::Utf8, true)),
+        );
+        let list_y = DataType::RunEndEncoded(
+            Arc::new(Field::new("ff1", DataType::UInt16, true)),
+            Arc::new(Field::new("ff2", DataType::Utf8, true)),
+        );
+        let list_z = DataType::RunEndEncoded(
+            Arc::new(Field::new("f1", DataType::Int64, false)),
+            Arc::new(Field::new("f2", DataType::Utf8, true)),
+        );
+
+        assert!(list_w.equals_datatype(&list_x));
+        assert!(!list_w.equals_datatype(&list_y));
+        assert!(!list_w.equals_datatype(&list_z));
+    }
+
+    #[test]
+    fn create_struct_type() {
+        let _person = DataType::Struct(Fields::from(vec![
+            Field::new("first_name", DataType::Utf8, false),
+            Field::new("last_name", DataType::Utf8, false),
+            Field::new(
+                "address",
+                DataType::Struct(Fields::from(vec![
+                    Field::new("street", DataType::Utf8, false),
+                    Field::new("zip", DataType::UInt16, false),
+                ])),
+                false,
+            ),
+        ]));
+    }
+
+    #[test]
+    fn test_nested() {
+        let list = DataType::List(Arc::new(Field::new("foo", DataType::Utf8, true)));
+
+        assert!(!DataType::is_nested(&DataType::Boolean));
+        assert!(!DataType::is_nested(&DataType::Int32));
+        assert!(!DataType::is_nested(&DataType::Utf8));
+        assert!(DataType::is_nested(&list));
+
+        assert!(!DataType::is_nested(&DataType::Dictionary(
+            Box::new(DataType::Int32),
+            Box::new(DataType::Boolean)
+        )));
+        assert!(!DataType::is_nested(&DataType::Dictionary(
+            Box::new(DataType::Int32),
+            Box::new(DataType::Int64)
+        )));
+        assert!(!DataType::is_nested(&DataType::Dictionary(
+            Box::new(DataType::Int32),
+            Box::new(DataType::LargeUtf8)
+        )));
+        assert!(DataType::is_nested(&DataType::Dictionary(
+            Box::new(DataType::Int32),
+            Box::new(list)
+        )));
+    }
+
+    #[test]
+    fn test_integer() {
+        // is_integer
+        assert!(DataType::is_integer(&DataType::Int32));
+        assert!(DataType::is_integer(&DataType::UInt64));
+        assert!(!DataType::is_integer(&DataType::Float16));
+
+        // is_signed_integer
+        assert!(DataType::is_signed_integer(&DataType::Int32));
+        assert!(!DataType::is_signed_integer(&DataType::UInt64));
+        assert!(!DataType::is_signed_integer(&DataType::Float16));
+
+        // is_unsigned_integer
+        assert!(!DataType::is_unsigned_integer(&DataType::Int32));
+        assert!(DataType::is_unsigned_integer(&DataType::UInt64));
+        assert!(!DataType::is_unsigned_integer(&DataType::Float16));
+
+        // is_dictionary_key_type
+        assert!(DataType::is_dictionary_key_type(&DataType::Int32));
+        assert!(DataType::is_dictionary_key_type(&DataType::UInt64));
+        assert!(!DataType::is_dictionary_key_type(&DataType::Float16));
+    }
+
+    #[test]
+    fn test_floating() {
+        assert!(DataType::is_floating(&DataType::Float16));
+        assert!(!DataType::is_floating(&DataType::Int32));
+    }
+
+    #[test]
+    fn test_datatype_is_null() {
+        assert!(DataType::is_null(&DataType::Null));
+        assert!(!DataType::is_null(&DataType::Int32));
+    }
+
+    #[test]
+    fn size_should_not_regress() {
+        assert_eq!(std::mem::size_of::<DataType>(), 24);
+    }
+
+    #[test]
+    #[should_panic(expected = "duplicate type id: 1")]
+    fn test_union_with_duplicated_type_id() {
+        let type_ids = vec![1, 1];
+        let _union = DataType::Union(
+            UnionFields::new(
+                type_ids,
+                vec![
+                    Field::new("f1", DataType::Int32, false),
+                    Field::new("f2", DataType::Utf8, false),
+                ],
+            ),
+            UnionMode::Dense,
+        );
+    }
+}
diff --git a/arrow-schema/src/error.rs b/arrow-schema/src/error.rs
new file mode 100644
index 000000000000..b7bf8d6e12a6
--- /dev/null
+++ b/arrow-schema/src/error.rs
@@ -0,0 +1,153 @@
+// 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.
+
+//! Defines `ArrowError` for representing failures in various Arrow operations.
+use std::fmt::{Debug, Display, Formatter};
+use std::io::Write;
+
+use std::error::Error;
+
+/// Many different operations in the `arrow` crate return this error type.
+#[derive(Debug)]
+pub enum ArrowError {
+    /// Returned when functionality is not yet available.
+    NotYetImplemented(String),
+    ExternalError(Box<dyn Error + Send + Sync>),
+    CastError(String),
+    MemoryError(String),
+    ParseError(String),
+    SchemaError(String),
+    ComputeError(String),
+    DivideByZero,
+    CsvError(String),
+    JsonError(String),
+    IoError(String, std::io::Error),
+    IpcError(String),
+    InvalidArgumentError(String),
+    ParquetError(String),
+    /// Error during import or export to/from the C Data Interface
+    CDataInterface(String),
+    DictionaryKeyOverflowError,
+    RunEndIndexOverflowError,
+}
+
+impl ArrowError {
+    /// Wraps an external error in an `ArrowError`.
+    pub fn from_external_error(error: Box<dyn Error + Send + Sync>) -> Self {
+        Self::ExternalError(error)
+    }
+}
+
+impl From<std::io::Error> for ArrowError {
+    fn from(error: std::io::Error) -> Self {
+        ArrowError::IoError(error.to_string(), error)
+    }
+}
+
+impl From<std::str::Utf8Error> for ArrowError {
+    fn from(error: std::str::Utf8Error) -> Self {
+        ArrowError::ParseError(error.to_string())
+    }
+}
+
+impl From<std::string::FromUtf8Error> for ArrowError {
+    fn from(error: std::string::FromUtf8Error) -> Self {
+        ArrowError::ParseError(error.to_string())
+    }
+}
+
+impl<W: Write> From<std::io::IntoInnerError<W>> for ArrowError {
+    fn from(error: std::io::IntoInnerError<W>) -> Self {
+        ArrowError::IoError(error.to_string(), error.into())
+    }
+}
+
+impl Display for ArrowError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ArrowError::NotYetImplemented(source) => {
+                write!(f, "Not yet implemented: {}", &source)
+            }
+            ArrowError::ExternalError(source) => write!(f, "External error: {}", &source),
+            ArrowError::CastError(desc) => write!(f, "Cast error: {desc}"),
+            ArrowError::MemoryError(desc) => write!(f, "Memory error: {desc}"),
+            ArrowError::ParseError(desc) => write!(f, "Parser error: {desc}"),
+            ArrowError::SchemaError(desc) => write!(f, "Schema error: {desc}"),
+            ArrowError::ComputeError(desc) => write!(f, "Compute error: {desc}"),
+            ArrowError::DivideByZero => write!(f, "Divide by zero error"),
+            ArrowError::CsvError(desc) => write!(f, "Csv error: {desc}"),
+            ArrowError::JsonError(desc) => write!(f, "Json error: {desc}"),
+            ArrowError::IoError(desc, _) => write!(f, "Io error: {desc}"),
+            ArrowError::IpcError(desc) => write!(f, "Ipc error: {desc}"),
+            ArrowError::InvalidArgumentError(desc) => {
+                write!(f, "Invalid argument error: {desc}")
+            }
+            ArrowError::ParquetError(desc) => {
+                write!(f, "Parquet argument error: {desc}")
+            }
+            ArrowError::CDataInterface(desc) => {
+                write!(f, "C Data interface error: {desc}")
+            }
+            ArrowError::DictionaryKeyOverflowError => {
+                write!(f, "Dictionary key bigger than the key type")
+            }
+            ArrowError::RunEndIndexOverflowError => {
+                write!(f, "Run end encoded array index overflow error")
+            }
+        }
+    }
+}
+
+impl Error for ArrowError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        if let Self::ExternalError(e) = self {
+            Some(e.as_ref())
+        } else {
+            None
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn error_source() {
+        let e1 = ArrowError::DivideByZero;
+        assert!(e1.source().is_none());
+
+        // one level of wrapping
+        let e2 = ArrowError::ExternalError(Box::new(e1));
+        let source = e2.source().unwrap().downcast_ref::<ArrowError>().unwrap();
+        assert!(matches!(source, ArrowError::DivideByZero));
+
+        // two levels of wrapping
+        let e3 = ArrowError::ExternalError(Box::new(e2));
+        let source = e3
+            .source()
+            .unwrap()
+            .downcast_ref::<ArrowError>()
+            .unwrap()
+            .source()
+            .unwrap()
+            .downcast_ref::<ArrowError>()
+            .unwrap();
+
+        assert!(matches!(source, ArrowError::DivideByZero));
+    }
+}
diff --git a/arrow-schema/src/ffi.rs b/arrow-schema/src/ffi.rs
new file mode 100644
index 000000000000..8a18c77ea291
--- /dev/null
+++ b/arrow-schema/src/ffi.rs
@@ -0,0 +1,896 @@
+// 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.
+
+//! Contains declarations to bind to the [C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html).
+//!
+//! ```
+//! # use arrow_schema::{DataType, Field, Schema};
+//! # use arrow_schema::ffi::FFI_ArrowSchema;
+//!
+//! // Create from data type
+//! let ffi_data_type = FFI_ArrowSchema::try_from(&DataType::LargeUtf8).unwrap();
+//! let back = DataType::try_from(&ffi_data_type).unwrap();
+//! assert_eq!(back, DataType::LargeUtf8);
+//!
+//! // Create from schema
+//! let schema = Schema::new(vec![Field::new("foo", DataType::Int64, false)]);
+//! let ffi_schema = FFI_ArrowSchema::try_from(&schema).unwrap();
+//! let back = Schema::try_from(&ffi_schema).unwrap();
+//!
+//! assert_eq!(schema, back);
+//! ```
+
+use crate::{
+    ArrowError, DataType, Field, FieldRef, IntervalUnit, Schema, TimeUnit, UnionFields, UnionMode,
+};
+use std::sync::Arc;
+use std::{
+    collections::HashMap,
+    ffi::{c_char, c_void, CStr, CString},
+};
+
+#[allow(clippy::assign_op_pattern)]
+/// Workaround <https://github.com/bitflags/bitflags/issues/356>
+mod flags {
+    use bitflags::bitflags;
+    bitflags! {
+        pub struct Flags: i64 {
+            const DICTIONARY_ORDERED = 0b00000001;
+            const NULLABLE = 0b00000010;
+            const MAP_KEYS_SORTED = 0b00000100;
+        }
+    }
+}
+pub use flags::*;
+
+/// ABI-compatible struct for `ArrowSchema` from C Data Interface
+/// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
+///
+/// ```
+/// # use arrow_schema::DataType;
+/// # use arrow_schema::ffi::FFI_ArrowSchema;
+/// fn array_schema(data_type: &DataType) -> FFI_ArrowSchema {
+///     FFI_ArrowSchema::try_from(data_type).unwrap()
+/// }
+/// ```
+///
+#[repr(C)]
+#[derive(Debug)]
+pub struct FFI_ArrowSchema {
+    format: *const c_char,
+    name: *const c_char,
+    metadata: *const c_char,
+    flags: i64,
+    n_children: i64,
+    children: *mut *mut FFI_ArrowSchema,
+    dictionary: *mut FFI_ArrowSchema,
+    release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowSchema)>,
+    private_data: *mut c_void,
+}
+
+struct SchemaPrivateData {
+    children: Box<[*mut FFI_ArrowSchema]>,
+    dictionary: *mut FFI_ArrowSchema,
+    metadata: Option<Vec<u8>>,
+}
+
+// callback used to drop [FFI_ArrowSchema] when it is exported.
+unsafe extern "C" fn release_schema(schema: *mut FFI_ArrowSchema) {
+    if schema.is_null() {
+        return;
+    }
+    let schema = &mut *schema;
+
+    // take ownership back to release it.
+    drop(CString::from_raw(schema.format as *mut c_char));
+    if !schema.name.is_null() {
+        drop(CString::from_raw(schema.name as *mut c_char));
+    }
+    if !schema.private_data.is_null() {
+        let private_data = Box::from_raw(schema.private_data as *mut SchemaPrivateData);
+        for child in private_data.children.iter() {
+            drop(Box::from_raw(*child))
+        }
+        if !private_data.dictionary.is_null() {
+            drop(Box::from_raw(private_data.dictionary));
+        }
+
+        drop(private_data);
+    }
+
+    schema.release = None;
+}
+
+impl FFI_ArrowSchema {
+    /// create a new [`FFI_ArrowSchema`]. This fails if the fields'
+    /// [`DataType`] is not supported.
+    pub fn try_new(
+        format: &str,
+        children: Vec<FFI_ArrowSchema>,
+        dictionary: Option<FFI_ArrowSchema>,
+    ) -> Result<Self, ArrowError> {
+        let mut this = Self::empty();
+
+        let children_ptr = children
+            .into_iter()
+            .map(Box::new)
+            .map(Box::into_raw)
+            .collect::<Box<_>>();
+
+        this.format = CString::new(format).unwrap().into_raw();
+        this.release = Some(release_schema);
+        this.n_children = children_ptr.len() as i64;
+
+        let dictionary_ptr = dictionary
+            .map(|d| Box::into_raw(Box::new(d)))
+            .unwrap_or(std::ptr::null_mut());
+
+        let mut private_data = Box::new(SchemaPrivateData {
+            children: children_ptr,
+            dictionary: dictionary_ptr,
+            metadata: None,
+        });
+
+        // intentionally set from private_data (see https://github.com/apache/arrow-rs/issues/580)
+        this.children = private_data.children.as_mut_ptr();
+
+        this.dictionary = dictionary_ptr;
+
+        this.private_data = Box::into_raw(private_data) as *mut c_void;
+
+        Ok(this)
+    }
+
+    pub fn with_name(mut self, name: &str) -> Result<Self, ArrowError> {
+        self.name = CString::new(name).unwrap().into_raw();
+        Ok(self)
+    }
+
+    pub fn with_flags(mut self, flags: Flags) -> Result<Self, ArrowError> {
+        self.flags = flags.bits();
+        Ok(self)
+    }
+
+    pub fn with_metadata<I, S>(mut self, metadata: I) -> Result<Self, ArrowError>
+    where
+        I: IntoIterator<Item = (S, S)>,
+        S: AsRef<str>,
+    {
+        let metadata: Vec<(S, S)> = metadata.into_iter().collect();
+        // https://arrow.apache.org/docs/format/CDataInterface.html#c.ArrowSchema.metadata
+        let new_metadata = if !metadata.is_empty() {
+            let mut metadata_serialized: Vec<u8> = Vec::new();
+            let num_entries: i32 = metadata.len().try_into().map_err(|_| {
+                ArrowError::CDataInterface(format!(
+                    "metadata can only have {} entries, but {} were provided",
+                    i32::MAX,
+                    metadata.len()
+                ))
+            })?;
+            metadata_serialized.extend(num_entries.to_ne_bytes());
+
+            for (key, value) in metadata.into_iter() {
+                let key_len: i32 = key.as_ref().len().try_into().map_err(|_| {
+                    ArrowError::CDataInterface(format!(
+                        "metadata key can only have {} bytes, but {} were provided",
+                        i32::MAX,
+                        key.as_ref().len()
+                    ))
+                })?;
+                let value_len: i32 = value.as_ref().len().try_into().map_err(|_| {
+                    ArrowError::CDataInterface(format!(
+                        "metadata value can only have {} bytes, but {} were provided",
+                        i32::MAX,
+                        value.as_ref().len()
+                    ))
+                })?;
+
+                metadata_serialized.extend(key_len.to_ne_bytes());
+                metadata_serialized.extend_from_slice(key.as_ref().as_bytes());
+                metadata_serialized.extend(value_len.to_ne_bytes());
+                metadata_serialized.extend_from_slice(value.as_ref().as_bytes());
+            }
+
+            self.metadata = metadata_serialized.as_ptr() as *const c_char;
+            Some(metadata_serialized)
+        } else {
+            self.metadata = std::ptr::null_mut();
+            None
+        };
+
+        unsafe {
+            let mut private_data = Box::from_raw(self.private_data as *mut SchemaPrivateData);
+            private_data.metadata = new_metadata;
+            self.private_data = Box::into_raw(private_data) as *mut c_void;
+        }
+
+        Ok(self)
+    }
+
+    /// Takes ownership of the pointed to [`FFI_ArrowSchema`]
+    ///
+    /// This acts to [move] the data out of `schema`, setting the release callback to NULL
+    ///
+    /// # Safety
+    ///
+    /// * `schema` must be [valid] for reads and writes
+    /// * `schema` must be properly aligned
+    /// * `schema` must point to a properly initialized value of [`FFI_ArrowSchema`]
+    ///
+    /// [move]: https://arrow.apache.org/docs/format/CDataInterface.html#moving-an-array
+    /// [valid]: https://doc.rust-lang.org/std/ptr/index.html#safety
+    pub unsafe fn from_raw(schema: *mut FFI_ArrowSchema) -> Self {
+        std::ptr::replace(schema, Self::empty())
+    }
+
+    pub fn empty() -> Self {
+        Self {
+            format: std::ptr::null_mut(),
+            name: std::ptr::null_mut(),
+            metadata: std::ptr::null_mut(),
+            flags: 0,
+            n_children: 0,
+            children: std::ptr::null_mut(),
+            dictionary: std::ptr::null_mut(),
+            release: None,
+            private_data: std::ptr::null_mut(),
+        }
+    }
+
+    /// returns the format of this schema.
+    pub fn format(&self) -> &str {
+        assert!(!self.format.is_null());
+        // safe because the lifetime of `self.format` equals `self`
+        unsafe { CStr::from_ptr(self.format) }
+            .to_str()
+            .expect("The external API has a non-utf8 as format")
+    }
+
+    /// returns the name of this schema.
+    pub fn name(&self) -> &str {
+        assert!(!self.name.is_null());
+        // safe because the lifetime of `self.name` equals `self`
+        unsafe { CStr::from_ptr(self.name) }
+            .to_str()
+            .expect("The external API has a non-utf8 as name")
+    }
+
+    pub fn flags(&self) -> Option<Flags> {
+        Flags::from_bits(self.flags)
+    }
+
+    pub fn child(&self, index: usize) -> &Self {
+        assert!(index < self.n_children as usize);
+        unsafe { self.children.add(index).as_ref().unwrap().as_ref().unwrap() }
+    }
+
+    pub fn children(&self) -> impl Iterator<Item = &Self> {
+        (0..self.n_children as usize).map(move |i| self.child(i))
+    }
+
+    pub fn nullable(&self) -> bool {
+        (self.flags / 2) & 1 == 1
+    }
+
+    pub fn dictionary(&self) -> Option<&Self> {
+        unsafe { self.dictionary.as_ref() }
+    }
+
+    pub fn map_keys_sorted(&self) -> bool {
+        self.flags & 0b00000100 != 0
+    }
+
+    pub fn dictionary_ordered(&self) -> bool {
+        self.flags & 0b00000001 != 0
+    }
+
+    pub fn metadata(&self) -> Result<HashMap<String, String>, ArrowError> {
+        if self.metadata.is_null() {
+            Ok(HashMap::new())
+        } else {
+            let mut pos = 0;
+            let buffer: *const u8 = self.metadata as *const u8;
+
+            fn next_four_bytes(buffer: *const u8, pos: &mut isize) -> [u8; 4] {
+                let out = unsafe {
+                    [
+                        *buffer.offset(*pos),
+                        *buffer.offset(*pos + 1),
+                        *buffer.offset(*pos + 2),
+                        *buffer.offset(*pos + 3),
+                    ]
+                };
+                *pos += 4;
+                out
+            }
+
+            fn next_n_bytes(buffer: *const u8, pos: &mut isize, n: i32) -> &[u8] {
+                let out = unsafe {
+                    std::slice::from_raw_parts(buffer.offset(*pos), n.try_into().unwrap())
+                };
+                *pos += isize::try_from(n).unwrap();
+                out
+            }
+
+            let num_entries = i32::from_ne_bytes(next_four_bytes(buffer, &mut pos));
+            if num_entries < 0 {
+                return Err(ArrowError::CDataInterface(
+                    "Negative number of metadata entries".to_string(),
+                ));
+            }
+
+            let mut metadata =
+                HashMap::with_capacity(num_entries.try_into().expect("Too many metadata entries"));
+
+            for _ in 0..num_entries {
+                let key_length = i32::from_ne_bytes(next_four_bytes(buffer, &mut pos));
+                if key_length < 0 {
+                    return Err(ArrowError::CDataInterface(
+                        "Negative key length in metadata".to_string(),
+                    ));
+                }
+                let key = String::from_utf8(next_n_bytes(buffer, &mut pos, key_length).to_vec())?;
+                let value_length = i32::from_ne_bytes(next_four_bytes(buffer, &mut pos));
+                if value_length < 0 {
+                    return Err(ArrowError::CDataInterface(
+                        "Negative value length in metadata".to_string(),
+                    ));
+                }
+                let value =
+                    String::from_utf8(next_n_bytes(buffer, &mut pos, value_length).to_vec())?;
+                metadata.insert(key, value);
+            }
+
+            Ok(metadata)
+        }
+    }
+}
+
+impl Drop for FFI_ArrowSchema {
+    fn drop(&mut self) {
+        match self.release {
+            None => (),
+            Some(release) => unsafe { release(self) },
+        };
+    }
+}
+
+unsafe impl Send for FFI_ArrowSchema {}
+
+impl TryFrom<&FFI_ArrowSchema> for DataType {
+    type Error = ArrowError;
+
+    /// See [CDataInterface docs](https://arrow.apache.org/docs/format/CDataInterface.html#data-type-description-format-strings)
+    fn try_from(c_schema: &FFI_ArrowSchema) -> Result<Self, ArrowError> {
+        let mut dtype = match c_schema.format() {
+            "n" => DataType::Null,
+            "b" => DataType::Boolean,
+            "c" => DataType::Int8,
+            "C" => DataType::UInt8,
+            "s" => DataType::Int16,
+            "S" => DataType::UInt16,
+            "i" => DataType::Int32,
+            "I" => DataType::UInt32,
+            "l" => DataType::Int64,
+            "L" => DataType::UInt64,
+            "e" => DataType::Float16,
+            "f" => DataType::Float32,
+            "g" => DataType::Float64,
+            "z" => DataType::Binary,
+            "Z" => DataType::LargeBinary,
+            "u" => DataType::Utf8,
+            "U" => DataType::LargeUtf8,
+            "tdD" => DataType::Date32,
+            "tdm" => DataType::Date64,
+            "tts" => DataType::Time32(TimeUnit::Second),
+            "ttm" => DataType::Time32(TimeUnit::Millisecond),
+            "ttu" => DataType::Time64(TimeUnit::Microsecond),
+            "ttn" => DataType::Time64(TimeUnit::Nanosecond),
+            "tDs" => DataType::Duration(TimeUnit::Second),
+            "tDm" => DataType::Duration(TimeUnit::Millisecond),
+            "tDu" => DataType::Duration(TimeUnit::Microsecond),
+            "tDn" => DataType::Duration(TimeUnit::Nanosecond),
+            "tiM" => DataType::Interval(IntervalUnit::YearMonth),
+            "tiD" => DataType::Interval(IntervalUnit::DayTime),
+            "tin" => DataType::Interval(IntervalUnit::MonthDayNano),
+            "+l" => {
+                let c_child = c_schema.child(0);
+                DataType::List(Arc::new(Field::try_from(c_child)?))
+            }
+            "+L" => {
+                let c_child = c_schema.child(0);
+                DataType::LargeList(Arc::new(Field::try_from(c_child)?))
+            }
+            "+s" => {
+                let fields = c_schema.children().map(Field::try_from);
+                DataType::Struct(fields.collect::<Result<_, ArrowError>>()?)
+            }
+            "+m" => {
+                let c_child = c_schema.child(0);
+                let map_keys_sorted = c_schema.map_keys_sorted();
+                DataType::Map(Arc::new(Field::try_from(c_child)?), map_keys_sorted)
+            }
+            // Parametrized types, requiring string parse
+            other => {
+                match other.splitn(2, ':').collect::<Vec<&str>>().as_slice() {
+                    // FixedSizeBinary type in format "w:num_bytes"
+                    ["w", num_bytes] => {
+                        let parsed_num_bytes = num_bytes.parse::<i32>().map_err(|_| {
+                            ArrowError::CDataInterface(
+                                "FixedSizeBinary requires an integer parameter representing number of bytes per element".to_string())
+                        })?;
+                        DataType::FixedSizeBinary(parsed_num_bytes)
+                    },
+                    // FixedSizeList type in format "+w:num_elems"
+                    ["+w", num_elems] => {
+                        let c_child = c_schema.child(0);
+                        let parsed_num_elems = num_elems.parse::<i32>().map_err(|_| {
+                            ArrowError::CDataInterface(
+                                "The FixedSizeList type requires an integer parameter representing number of elements per list".to_string())
+                        })?;
+                        DataType::FixedSizeList(Arc::new(Field::try_from(c_child)?), parsed_num_elems)
+                    },
+                    // Decimal types in format "d:precision,scale" or "d:precision,scale,bitWidth"
+                    ["d", extra] => {
+                        match extra.splitn(3, ',').collect::<Vec<&str>>().as_slice() {
+                            [precision, scale] => {
+                                let parsed_precision = precision.parse::<u8>().map_err(|_| {
+                                    ArrowError::CDataInterface(
+                                        "The decimal type requires an integer precision".to_string(),
+                                    )
+                                })?;
+                                let parsed_scale = scale.parse::<i8>().map_err(|_| {
+                                    ArrowError::CDataInterface(
+                                        "The decimal type requires an integer scale".to_string(),
+                                    )
+                                })?;
+                                DataType::Decimal128(parsed_precision, parsed_scale)
+                            },
+                            [precision, scale, bits] => {
+                                if *bits != "128" && *bits != "256" {
+                                    return Err(ArrowError::CDataInterface("Only 128/256 bit wide decimal is supported in the Rust implementation".to_string()));
+                                }
+                                let parsed_precision = precision.parse::<u8>().map_err(|_| {
+                                    ArrowError::CDataInterface(
+                                        "The decimal type requires an integer precision".to_string(),
+                                    )
+                                })?;
+                                let parsed_scale = scale.parse::<i8>().map_err(|_| {
+                                    ArrowError::CDataInterface(
+                                        "The decimal type requires an integer scale".to_string(),
+                                    )
+                                })?;
+                                if *bits == "128" {
+                                    DataType::Decimal128(parsed_precision, parsed_scale)
+                                } else {
+                                    DataType::Decimal256(parsed_precision, parsed_scale)
+                                }
+                            }
+                            _ => {
+                                return Err(ArrowError::CDataInterface(format!(
+                                    "The decimal pattern \"d:{extra:?}\" is not supported in the Rust implementation"
+                                )))
+                            }
+                        }
+                    }
+                    // DenseUnion
+                    ["+ud", extra] => {
+                        let type_ids = extra.split(',').map(|t| t.parse::<i8>().map_err(|_| {
+                            ArrowError::CDataInterface(
+                                "The Union type requires an integer type id".to_string(),
+                            )
+                        })).collect::<Result<Vec<_>, ArrowError>>()?;
+                        let mut fields = Vec::with_capacity(type_ids.len());
+                        for idx in 0..c_schema.n_children {
+                            let c_child = c_schema.child(idx as usize);
+                            let field = Field::try_from(c_child)?;
+                            fields.push(field);
+                        }
+
+                        if fields.len() != type_ids.len() {
+                            return Err(ArrowError::CDataInterface(
+                                "The Union type requires same number of fields and type ids".to_string(),
+                            ));
+                        }
+
+                        DataType::Union(UnionFields::new(type_ids, fields), UnionMode::Dense)
+                    }
+                    // SparseUnion
+                    ["+us", extra] => {
+                        let type_ids = extra.split(',').map(|t| t.parse::<i8>().map_err(|_| {
+                            ArrowError::CDataInterface(
+                                "The Union type requires an integer type id".to_string(),
+                            )
+                        })).collect::<Result<Vec<_>, ArrowError>>()?;
+                        let mut fields = Vec::with_capacity(type_ids.len());
+                        for idx in 0..c_schema.n_children {
+                            let c_child = c_schema.child(idx as usize);
+                            let field = Field::try_from(c_child)?;
+                            fields.push(field);
+                        }
+
+                        if fields.len() != type_ids.len() {
+                            return Err(ArrowError::CDataInterface(
+                                "The Union type requires same number of fields and type ids".to_string(),
+                            ));
+                        }
+
+                        DataType::Union(UnionFields::new(type_ids, fields), UnionMode::Sparse)
+                    }
+
+                    // Timestamps in format "tts:" and "tts:America/New_York" for no timezones and timezones resp.
+                    ["tss", ""] => DataType::Timestamp(TimeUnit::Second, None),
+                    ["tsm", ""] => DataType::Timestamp(TimeUnit::Millisecond, None),
+                    ["tsu", ""] => DataType::Timestamp(TimeUnit::Microsecond, None),
+                    ["tsn", ""] => DataType::Timestamp(TimeUnit::Nanosecond, None),
+                    ["tss", tz] => {
+                        DataType::Timestamp(TimeUnit::Second, Some(Arc::from(*tz)))
+                    }
+                    ["tsm", tz] => {
+                        DataType::Timestamp(TimeUnit::Millisecond, Some(Arc::from(*tz)))
+                    }
+                    ["tsu", tz] => {
+                        DataType::Timestamp(TimeUnit::Microsecond, Some(Arc::from(*tz)))
+                    }
+                    ["tsn", tz] => {
+                        DataType::Timestamp(TimeUnit::Nanosecond, Some(Arc::from(*tz)))
+                    }
+                    _ => {
+                        return Err(ArrowError::CDataInterface(format!(
+                            "The datatype \"{other:?}\" is still not supported in Rust implementation"
+                        )))
+                    }
+                }
+            }
+        };
+
+        if let Some(dict_schema) = c_schema.dictionary() {
+            let value_type = Self::try_from(dict_schema)?;
+            dtype = DataType::Dictionary(Box::new(dtype), Box::new(value_type));
+        }
+
+        Ok(dtype)
+    }
+}
+
+impl TryFrom<&FFI_ArrowSchema> for Field {
+    type Error = ArrowError;
+
+    fn try_from(c_schema: &FFI_ArrowSchema) -> Result<Self, ArrowError> {
+        let dtype = DataType::try_from(c_schema)?;
+        let mut field = Field::new(c_schema.name(), dtype, c_schema.nullable());
+        field.set_metadata(c_schema.metadata()?);
+        Ok(field)
+    }
+}
+
+impl TryFrom<&FFI_ArrowSchema> for Schema {
+    type Error = ArrowError;
+
+    fn try_from(c_schema: &FFI_ArrowSchema) -> Result<Self, ArrowError> {
+        // interpret it as a struct type then extract its fields
+        let dtype = DataType::try_from(c_schema)?;
+        if let DataType::Struct(fields) = dtype {
+            Ok(Schema::new(fields).with_metadata(c_schema.metadata()?))
+        } else {
+            Err(ArrowError::CDataInterface(
+                "Unable to interpret C data struct as a Schema".to_string(),
+            ))
+        }
+    }
+}
+
+impl TryFrom<&DataType> for FFI_ArrowSchema {
+    type Error = ArrowError;
+
+    /// See [CDataInterface docs](https://arrow.apache.org/docs/format/CDataInterface.html#data-type-description-format-strings)
+    fn try_from(dtype: &DataType) -> Result<Self, ArrowError> {
+        let format = get_format_string(dtype)?;
+        // allocate and hold the children
+        let children = match dtype {
+            DataType::List(child)
+            | DataType::LargeList(child)
+            | DataType::FixedSizeList(child, _)
+            | DataType::Map(child, _) => {
+                vec![FFI_ArrowSchema::try_from(child.as_ref())?]
+            }
+            DataType::Union(fields, _) => fields
+                .iter()
+                .map(|(_, f)| f.as_ref().try_into())
+                .collect::<Result<Vec<_>, ArrowError>>()?,
+            DataType::Struct(fields) => fields
+                .iter()
+                .map(FFI_ArrowSchema::try_from)
+                .collect::<Result<Vec<_>, ArrowError>>()?,
+            _ => vec![],
+        };
+        let dictionary = if let DataType::Dictionary(_, value_data_type) = dtype {
+            Some(Self::try_from(value_data_type.as_ref())?)
+        } else {
+            None
+        };
+
+        let flags = match dtype {
+            DataType::Map(_, true) => Flags::MAP_KEYS_SORTED,
+            _ => Flags::empty(),
+        };
+
+        FFI_ArrowSchema::try_new(&format, children, dictionary)?.with_flags(flags)
+    }
+}
+
+fn get_format_string(dtype: &DataType) -> Result<String, ArrowError> {
+    match dtype {
+        DataType::Null => Ok("n".to_string()),
+        DataType::Boolean => Ok("b".to_string()),
+        DataType::Int8 => Ok("c".to_string()),
+        DataType::UInt8 => Ok("C".to_string()),
+        DataType::Int16 => Ok("s".to_string()),
+        DataType::UInt16 => Ok("S".to_string()),
+        DataType::Int32 => Ok("i".to_string()),
+        DataType::UInt32 => Ok("I".to_string()),
+        DataType::Int64 => Ok("l".to_string()),
+        DataType::UInt64 => Ok("L".to_string()),
+        DataType::Float16 => Ok("e".to_string()),
+        DataType::Float32 => Ok("f".to_string()),
+        DataType::Float64 => Ok("g".to_string()),
+        DataType::Binary => Ok("z".to_string()),
+        DataType::LargeBinary => Ok("Z".to_string()),
+        DataType::Utf8 => Ok("u".to_string()),
+        DataType::LargeUtf8 => Ok("U".to_string()),
+        DataType::FixedSizeBinary(num_bytes) => Ok(format!("w:{num_bytes}")),
+        DataType::FixedSizeList(_, num_elems) => Ok(format!("+w:{num_elems}")),
+        DataType::Decimal128(precision, scale) => Ok(format!("d:{precision},{scale}")),
+        DataType::Decimal256(precision, scale) => Ok(format!("d:{precision},{scale},256")),
+        DataType::Date32 => Ok("tdD".to_string()),
+        DataType::Date64 => Ok("tdm".to_string()),
+        DataType::Time32(TimeUnit::Second) => Ok("tts".to_string()),
+        DataType::Time32(TimeUnit::Millisecond) => Ok("ttm".to_string()),
+        DataType::Time64(TimeUnit::Microsecond) => Ok("ttu".to_string()),
+        DataType::Time64(TimeUnit::Nanosecond) => Ok("ttn".to_string()),
+        DataType::Timestamp(TimeUnit::Second, None) => Ok("tss:".to_string()),
+        DataType::Timestamp(TimeUnit::Millisecond, None) => Ok("tsm:".to_string()),
+        DataType::Timestamp(TimeUnit::Microsecond, None) => Ok("tsu:".to_string()),
+        DataType::Timestamp(TimeUnit::Nanosecond, None) => Ok("tsn:".to_string()),
+        DataType::Timestamp(TimeUnit::Second, Some(tz)) => Ok(format!("tss:{tz}")),
+        DataType::Timestamp(TimeUnit::Millisecond, Some(tz)) => Ok(format!("tsm:{tz}")),
+        DataType::Timestamp(TimeUnit::Microsecond, Some(tz)) => Ok(format!("tsu:{tz}")),
+        DataType::Timestamp(TimeUnit::Nanosecond, Some(tz)) => Ok(format!("tsn:{tz}")),
+        DataType::Duration(TimeUnit::Second) => Ok("tDs".to_string()),
+        DataType::Duration(TimeUnit::Millisecond) => Ok("tDm".to_string()),
+        DataType::Duration(TimeUnit::Microsecond) => Ok("tDu".to_string()),
+        DataType::Duration(TimeUnit::Nanosecond) => Ok("tDn".to_string()),
+        DataType::Interval(IntervalUnit::YearMonth) => Ok("tiM".to_string()),
+        DataType::Interval(IntervalUnit::DayTime) => Ok("tiD".to_string()),
+        DataType::Interval(IntervalUnit::MonthDayNano) => Ok("tin".to_string()),
+        DataType::List(_) => Ok("+l".to_string()),
+        DataType::LargeList(_) => Ok("+L".to_string()),
+        DataType::Struct(_) => Ok("+s".to_string()),
+        DataType::Map(_, _) => Ok("+m".to_string()),
+        DataType::Dictionary(key_data_type, _) => get_format_string(key_data_type),
+        DataType::Union(fields, mode) => {
+            let formats = fields
+                .iter()
+                .map(|(t, _)| t.to_string())
+                .collect::<Vec<_>>();
+            match mode {
+                UnionMode::Dense => Ok(format!("{}:{}", "+ud", formats.join(","))),
+                UnionMode::Sparse => Ok(format!("{}:{}", "+us", formats.join(","))),
+            }
+        }
+        other => Err(ArrowError::CDataInterface(format!(
+            "The datatype \"{other:?}\" is still not supported in Rust implementation"
+        ))),
+    }
+}
+
+impl TryFrom<&FieldRef> for FFI_ArrowSchema {
+    type Error = ArrowError;
+
+    fn try_from(value: &FieldRef) -> Result<Self, Self::Error> {
+        value.as_ref().try_into()
+    }
+}
+
+impl TryFrom<&Field> for FFI_ArrowSchema {
+    type Error = ArrowError;
+
+    fn try_from(field: &Field) -> Result<Self, ArrowError> {
+        let mut flags = if field.is_nullable() {
+            Flags::NULLABLE
+        } else {
+            Flags::empty()
+        };
+
+        if let Some(true) = field.dict_is_ordered() {
+            flags |= Flags::DICTIONARY_ORDERED;
+        }
+
+        FFI_ArrowSchema::try_from(field.data_type())?
+            .with_name(field.name())?
+            .with_flags(flags)?
+            .with_metadata(field.metadata())
+    }
+}
+
+impl TryFrom<&Schema> for FFI_ArrowSchema {
+    type Error = ArrowError;
+
+    fn try_from(schema: &Schema) -> Result<Self, ArrowError> {
+        let dtype = DataType::Struct(schema.fields().clone());
+        let c_schema = FFI_ArrowSchema::try_from(&dtype)?.with_metadata(&schema.metadata)?;
+        Ok(c_schema)
+    }
+}
+
+impl TryFrom<DataType> for FFI_ArrowSchema {
+    type Error = ArrowError;
+
+    fn try_from(dtype: DataType) -> Result<Self, ArrowError> {
+        FFI_ArrowSchema::try_from(&dtype)
+    }
+}
+
+impl TryFrom<Field> for FFI_ArrowSchema {
+    type Error = ArrowError;
+
+    fn try_from(field: Field) -> Result<Self, ArrowError> {
+        FFI_ArrowSchema::try_from(&field)
+    }
+}
+
+impl TryFrom<Schema> for FFI_ArrowSchema {
+    type Error = ArrowError;
+
+    fn try_from(schema: Schema) -> Result<Self, ArrowError> {
+        FFI_ArrowSchema::try_from(&schema)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::Fields;
+
+    fn round_trip_type(dtype: DataType) {
+        let c_schema = FFI_ArrowSchema::try_from(&dtype).unwrap();
+        let restored = DataType::try_from(&c_schema).unwrap();
+        assert_eq!(restored, dtype);
+    }
+
+    fn round_trip_field(field: Field) {
+        let c_schema = FFI_ArrowSchema::try_from(&field).unwrap();
+        let restored = Field::try_from(&c_schema).unwrap();
+        assert_eq!(restored, field);
+    }
+
+    fn round_trip_schema(schema: Schema) {
+        let c_schema = FFI_ArrowSchema::try_from(&schema).unwrap();
+        let restored = Schema::try_from(&c_schema).unwrap();
+        assert_eq!(restored, schema);
+    }
+
+    #[test]
+    fn test_type() {
+        round_trip_type(DataType::Int64);
+        round_trip_type(DataType::UInt64);
+        round_trip_type(DataType::Float64);
+        round_trip_type(DataType::Date64);
+        round_trip_type(DataType::Time64(TimeUnit::Nanosecond));
+        round_trip_type(DataType::FixedSizeBinary(12));
+        round_trip_type(DataType::FixedSizeList(
+            Arc::new(Field::new("a", DataType::Int64, false)),
+            5,
+        ));
+        round_trip_type(DataType::Utf8);
+        round_trip_type(DataType::List(Arc::new(Field::new(
+            "a",
+            DataType::Int16,
+            false,
+        ))));
+        round_trip_type(DataType::Struct(Fields::from(vec![Field::new(
+            "a",
+            DataType::Utf8,
+            true,
+        )])));
+    }
+
+    #[test]
+    fn test_field() {
+        let dtype = DataType::Struct(vec![Field::new("a", DataType::Utf8, true)].into());
+        round_trip_field(Field::new("test", dtype, true));
+    }
+
+    #[test]
+    fn test_schema() {
+        let schema = Schema::new(vec![
+            Field::new("name", DataType::Utf8, false),
+            Field::new("address", DataType::Utf8, false),
+            Field::new("priority", DataType::UInt8, false),
+        ])
+        .with_metadata([("hello".to_string(), "world".to_string())].into());
+
+        round_trip_schema(schema);
+
+        // test that we can interpret struct types as schema
+        let dtype = DataType::Struct(Fields::from(vec![
+            Field::new("a", DataType::Utf8, true),
+            Field::new("b", DataType::Int16, false),
+        ]));
+        let c_schema = FFI_ArrowSchema::try_from(&dtype).unwrap();
+        let schema = Schema::try_from(&c_schema).unwrap();
+        assert_eq!(schema.fields().len(), 2);
+
+        // test that we assert the input type
+        let c_schema = FFI_ArrowSchema::try_from(&DataType::Float64).unwrap();
+        let result = Schema::try_from(&c_schema);
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn test_map_keys_sorted() {
+        let keys = Field::new("keys", DataType::Int32, false);
+        let values = Field::new("values", DataType::UInt32, false);
+        let entry_struct = DataType::Struct(vec![keys, values].into());
+
+        // Construct a map array from the above two
+        let map_data_type =
+            DataType::Map(Arc::new(Field::new("entries", entry_struct, false)), true);
+
+        let arrow_schema = FFI_ArrowSchema::try_from(map_data_type).unwrap();
+        assert!(arrow_schema.map_keys_sorted());
+    }
+
+    #[test]
+    fn test_dictionary_ordered() {
+        let schema = Schema::new(vec![Field::new_dict(
+            "dict",
+            DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
+            false,
+            0,
+            true,
+        )]);
+
+        let arrow_schema = FFI_ArrowSchema::try_from(schema).unwrap();
+        assert!(arrow_schema.child(0).dictionary_ordered());
+    }
+
+    #[test]
+    fn test_set_field_metadata() {
+        let metadata_cases: Vec<HashMap<String, String>> = vec![
+            [].into(),
+            [("key".to_string(), "value".to_string())].into(),
+            [
+                ("key".to_string(), "".to_string()),
+                ("ascii123".to_string(), "你好".to_string()),
+                ("".to_string(), "value".to_string()),
+            ]
+            .into(),
+        ];
+
+        let mut schema = FFI_ArrowSchema::try_new("b", vec![], None)
+            .unwrap()
+            .with_name("test")
+            .unwrap();
+
+        for metadata in metadata_cases {
+            schema = schema.with_metadata(&metadata).unwrap();
+            let field = Field::try_from(&schema).unwrap();
+            assert_eq!(field.metadata(), &metadata);
+        }
+    }
+}
diff --git a/arrow-schema/src/field.rs b/arrow-schema/src/field.rs
new file mode 100644
index 000000000000..5cb2399f383c
--- /dev/null
+++ b/arrow-schema/src/field.rs
@@ -0,0 +1,896 @@
+// 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.
+
+use crate::error::ArrowError;
+use std::cmp::Ordering;
+use std::collections::HashMap;
+use std::hash::{Hash, Hasher};
+use std::sync::Arc;
+
+use crate::datatype::DataType;
+use crate::schema::SchemaBuilder;
+use crate::{Fields, UnionFields, UnionMode};
+
+/// A reference counted [`Field`]
+pub type FieldRef = Arc<Field>;
+
+/// Describes a single column in a [`Schema`](super::Schema).
+///
+/// A [`Schema`](super::Schema) is an ordered collection of
+/// [`Field`] objects.
+#[derive(Debug, Clone)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Field {
+    name: String,
+    data_type: DataType,
+    nullable: bool,
+    dict_id: i64,
+    dict_is_ordered: bool,
+    /// A map of key-value pairs containing additional custom meta data.
+    metadata: HashMap<String, String>,
+}
+
+// Auto-derive `PartialEq` traits will pull `dict_id` and `dict_is_ordered`
+// into comparison. However, these properties are only used in IPC context
+// for matching dictionary encoded data. They are not necessary to be same
+// to consider schema equality. For example, in C++ `Field` implementation,
+// it doesn't contain these dictionary properties too.
+impl PartialEq for Field {
+    fn eq(&self, other: &Self) -> bool {
+        self.name == other.name
+            && self.data_type == other.data_type
+            && self.nullable == other.nullable
+            && self.metadata == other.metadata
+    }
+}
+
+impl Eq for Field {}
+
+impl PartialOrd for Field {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Field {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.name
+            .cmp(other.name())
+            .then_with(|| self.data_type.cmp(other.data_type()))
+            .then_with(|| self.nullable.cmp(&other.nullable))
+            .then_with(|| {
+                // ensure deterministic key order
+                let mut keys: Vec<&String> =
+                    self.metadata.keys().chain(other.metadata.keys()).collect();
+                keys.sort();
+                for k in keys {
+                    match (self.metadata.get(k), other.metadata.get(k)) {
+                        (None, None) => {}
+                        (Some(_), None) => {
+                            return Ordering::Less;
+                        }
+                        (None, Some(_)) => {
+                            return Ordering::Greater;
+                        }
+                        (Some(v1), Some(v2)) => match v1.cmp(v2) {
+                            Ordering::Equal => {}
+                            other => {
+                                return other;
+                            }
+                        },
+                    }
+                }
+
+                Ordering::Equal
+            })
+    }
+}
+
+impl Hash for Field {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.name.hash(state);
+        self.data_type.hash(state);
+        self.nullable.hash(state);
+
+        // ensure deterministic key order
+        let mut keys: Vec<&String> = self.metadata.keys().collect();
+        keys.sort();
+        for k in keys {
+            k.hash(state);
+            self.metadata.get(k).expect("key valid").hash(state);
+        }
+    }
+}
+
+impl Field {
+    /// Creates a new field with the given name, type, and nullability
+    pub fn new(name: impl Into<String>, data_type: DataType, nullable: bool) -> Self {
+        Field {
+            name: name.into(),
+            data_type,
+            nullable,
+            dict_id: 0,
+            dict_is_ordered: false,
+            metadata: HashMap::default(),
+        }
+    }
+
+    /// Creates a new `Field`` suitable for [`DataType::List`] and
+    /// [`DataType::LargeList`]
+    ///
+    /// While not required, this method follows the convention of naming the
+    /// `Field` `"item"`.
+    ///
+    /// # Example
+    /// ```
+    /// # use arrow_schema::{Field, DataType};
+    /// assert_eq!(
+    ///   Field::new("item", DataType::Int32, true),
+    ///   Field::new_list_field(DataType::Int32, true)
+    /// );
+    /// ```
+    pub fn new_list_field(data_type: DataType, nullable: bool) -> Self {
+        Self::new("item", data_type, nullable)
+    }
+
+    /// Creates a new field that has additional dictionary information
+    pub fn new_dict(
+        name: impl Into<String>,
+        data_type: DataType,
+        nullable: bool,
+        dict_id: i64,
+        dict_is_ordered: bool,
+    ) -> Self {
+        Field {
+            name: name.into(),
+            data_type,
+            nullable,
+            dict_id,
+            dict_is_ordered,
+            metadata: HashMap::default(),
+        }
+    }
+
+    /// Create a new [`Field`] with [`DataType::Dictionary`]
+    ///
+    /// Use [`Self::new_dict`] for more advanced dictionary options
+    ///
+    /// # Panics
+    ///
+    /// Panics if [`!key.is_dictionary_key_type`][DataType::is_dictionary_key_type]
+    pub fn new_dictionary(
+        name: impl Into<String>,
+        key: DataType,
+        value: DataType,
+        nullable: bool,
+    ) -> Self {
+        assert!(
+            key.is_dictionary_key_type(),
+            "{key} is not a valid dictionary key"
+        );
+        let data_type = DataType::Dictionary(Box::new(key), Box::new(value));
+        Self::new(name, data_type, nullable)
+    }
+
+    /// Create a new [`Field`] with [`DataType::Struct`]
+    ///
+    /// - `name`: the name of the [`DataType::Struct`] field
+    /// - `fields`: the description of each struct element
+    /// - `nullable`: if the [`DataType::Struct`] array is nullable
+    pub fn new_struct(name: impl Into<String>, fields: impl Into<Fields>, nullable: bool) -> Self {
+        Self::new(name, DataType::Struct(fields.into()), nullable)
+    }
+
+    /// Create a new [`Field`] with [`DataType::List`]
+    ///
+    /// - `name`: the name of the [`DataType::List`] field
+    /// - `value`: the description of each list element
+    /// - `nullable`: if the [`DataType::List`] array is nullable
+    pub fn new_list(name: impl Into<String>, value: impl Into<FieldRef>, nullable: bool) -> Self {
+        Self::new(name, DataType::List(value.into()), nullable)
+    }
+
+    /// Create a new [`Field`] with [`DataType::LargeList`]
+    ///
+    /// - `name`: the name of the [`DataType::LargeList`] field
+    /// - `value`: the description of each list element
+    /// - `nullable`: if the [`DataType::LargeList`] array is nullable
+    pub fn new_large_list(
+        name: impl Into<String>,
+        value: impl Into<FieldRef>,
+        nullable: bool,
+    ) -> Self {
+        Self::new(name, DataType::LargeList(value.into()), nullable)
+    }
+
+    /// Create a new [`Field`] with [`DataType::FixedSizeList`]
+    ///
+    /// - `name`: the name of the [`DataType::FixedSizeList`] field
+    /// - `value`: the description of each list element
+    /// - `size`: the size of the fixed size list
+    /// - `nullable`: if the [`DataType::FixedSizeList`] array is nullable
+    pub fn new_fixed_size_list(
+        name: impl Into<String>,
+        value: impl Into<FieldRef>,
+        size: i32,
+        nullable: bool,
+    ) -> Self {
+        Self::new(name, DataType::FixedSizeList(value.into(), size), nullable)
+    }
+
+    /// Create a new [`Field`] with [`DataType::Map`]
+    ///
+    /// - `name`: the name of the [`DataType::Map`] field
+    /// - `entries`: the name of the inner [`DataType::Struct`] field
+    /// - `keys`: the map keys
+    /// - `values`: the map values
+    /// - `sorted`: if the [`DataType::Map`] array is sorted
+    /// - `nullable`: if the [`DataType::Map`] array is nullable
+    pub fn new_map(
+        name: impl Into<String>,
+        entries: impl Into<String>,
+        keys: impl Into<FieldRef>,
+        values: impl Into<FieldRef>,
+        sorted: bool,
+        nullable: bool,
+    ) -> Self {
+        let data_type = DataType::Map(
+            Arc::new(Field::new(
+                entries.into(),
+                DataType::Struct(Fields::from([keys.into(), values.into()])),
+                false, // The inner map field is always non-nullable (#1697),
+            )),
+            sorted,
+        );
+        Self::new(name, data_type, nullable)
+    }
+
+    /// Create a new [`Field`] with [`DataType::Union`]
+    ///
+    /// - `name`: the name of the [`DataType::Union`] field
+    /// - `type_ids`: the union type ids
+    /// - `fields`: the union fields
+    /// - `mode`: the union mode
+    pub fn new_union<S, F, T>(name: S, type_ids: T, fields: F, mode: UnionMode) -> Self
+    where
+        S: Into<String>,
+        F: IntoIterator,
+        F::Item: Into<FieldRef>,
+        T: IntoIterator<Item = i8>,
+    {
+        Self::new(
+            name,
+            DataType::Union(UnionFields::new(type_ids, fields), mode),
+            false, // Unions cannot be nullable
+        )
+    }
+
+    /// Sets the `Field`'s optional custom metadata.
+    #[inline]
+    pub fn set_metadata(&mut self, metadata: HashMap<String, String>) {
+        self.metadata = metadata;
+    }
+
+    /// Sets the metadata of this `Field` to be `metadata` and returns self
+    pub fn with_metadata(mut self, metadata: HashMap<String, String>) -> Self {
+        self.set_metadata(metadata);
+        self
+    }
+
+    /// Returns the immutable reference to the `Field`'s optional custom metadata.
+    #[inline]
+    pub const fn metadata(&self) -> &HashMap<String, String> {
+        &self.metadata
+    }
+
+    /// Returns an immutable reference to the `Field`'s name.
+    #[inline]
+    pub const fn name(&self) -> &String {
+        &self.name
+    }
+
+    /// Set the name of the [`Field`] and returns self.
+    ///
+    /// ```
+    /// # use arrow_schema::*;
+    /// let field = Field::new("c1", DataType::Int64, false)
+    ///    .with_name("c2");
+    ///
+    /// assert_eq!(field.name(), "c2");
+    /// ```
+    pub fn with_name(mut self, name: impl Into<String>) -> Self {
+        self.name = name.into();
+        self
+    }
+
+    /// Returns an immutable reference to the [`Field`]'s  [`DataType`].
+    #[inline]
+    pub const fn data_type(&self) -> &DataType {
+        &self.data_type
+    }
+
+    /// Set [`DataType`] of the [`Field`] and returns self.
+    ///
+    /// ```
+    /// # use arrow_schema::*;
+    /// let field = Field::new("c1", DataType::Int64, false)
+    ///    .with_data_type(DataType::Utf8);
+    ///
+    /// assert_eq!(field.data_type(), &DataType::Utf8);
+    /// ```
+    pub fn with_data_type(mut self, data_type: DataType) -> Self {
+        self.data_type = data_type;
+        self
+    }
+
+    /// Indicates whether this [`Field`] supports null values.
+    #[inline]
+    pub const fn is_nullable(&self) -> bool {
+        self.nullable
+    }
+
+    /// Set `nullable` of the [`Field`] and returns self.
+    ///
+    /// ```
+    /// # use arrow_schema::*;
+    /// let field = Field::new("c1", DataType::Int64, false)
+    ///    .with_nullable(true);
+    ///
+    /// assert_eq!(field.is_nullable(), true);
+    /// ```
+    pub fn with_nullable(mut self, nullable: bool) -> Self {
+        self.nullable = nullable;
+        self
+    }
+
+    /// Returns a (flattened) [`Vec`] containing all child [`Field`]s
+    /// within `self` contained within this field (including `self`)
+    pub(crate) fn fields(&self) -> Vec<&Field> {
+        let mut collected_fields = vec![self];
+        collected_fields.append(&mut Field::_fields(&self.data_type));
+
+        collected_fields
+    }
+
+    fn _fields(dt: &DataType) -> Vec<&Field> {
+        match dt {
+            DataType::Struct(fields) => fields.iter().flat_map(|f| f.fields()).collect(),
+            DataType::Union(fields, _) => fields.iter().flat_map(|(_, f)| f.fields()).collect(),
+            DataType::List(field)
+            | DataType::LargeList(field)
+            | DataType::FixedSizeList(field, _)
+            | DataType::Map(field, _) => field.fields(),
+            DataType::Dictionary(_, value_field) => Field::_fields(value_field.as_ref()),
+            _ => vec![],
+        }
+    }
+
+    /// Returns a vector containing all (potentially nested) `Field` instances selected by the
+    /// dictionary ID they use
+    #[inline]
+    pub(crate) fn fields_with_dict_id(&self, id: i64) -> Vec<&Field> {
+        self.fields()
+            .into_iter()
+            .filter(|&field| {
+                matches!(field.data_type(), DataType::Dictionary(_, _)) && field.dict_id == id
+            })
+            .collect()
+    }
+
+    /// Returns the dictionary ID, if this is a dictionary type.
+    #[inline]
+    pub const fn dict_id(&self) -> Option<i64> {
+        match self.data_type {
+            DataType::Dictionary(_, _) => Some(self.dict_id),
+            _ => None,
+        }
+    }
+
+    /// Returns whether this `Field`'s dictionary is ordered, if this is a dictionary type.
+    #[inline]
+    pub const fn dict_is_ordered(&self) -> Option<bool> {
+        match self.data_type {
+            DataType::Dictionary(_, _) => Some(self.dict_is_ordered),
+            _ => None,
+        }
+    }
+
+    /// Merge this field into self if it is compatible.
+    ///
+    /// Struct fields are merged recursively.
+    ///
+    /// NOTE: `self` may be updated to a partial / unexpected state in case of merge failure.
+    ///
+    /// Example:
+    ///
+    /// ```
+    /// # use arrow_schema::*;
+    /// let mut field = Field::new("c1", DataType::Int64, false);
+    /// assert!(field.try_merge(&Field::new("c1", DataType::Int64, true)).is_ok());
+    /// assert!(field.is_nullable());
+    /// ```
+    pub fn try_merge(&mut self, from: &Field) -> Result<(), ArrowError> {
+        if from.dict_id != self.dict_id {
+            return Err(ArrowError::SchemaError(format!(
+                "Fail to merge schema field '{}' because from dict_id = {} does not match {}",
+                self.name, from.dict_id, self.dict_id
+            )));
+        }
+        if from.dict_is_ordered != self.dict_is_ordered {
+            return Err(ArrowError::SchemaError(format!(
+                "Fail to merge schema field '{}' because from dict_is_ordered = {} does not match {}",
+                self.name, from.dict_is_ordered, self.dict_is_ordered
+            )));
+        }
+        // merge metadata
+        match (self.metadata().is_empty(), from.metadata().is_empty()) {
+            (false, false) => {
+                let mut merged = self.metadata().clone();
+                for (key, from_value) in from.metadata() {
+                    if let Some(self_value) = self.metadata.get(key) {
+                        if self_value != from_value {
+                            return Err(ArrowError::SchemaError(format!(
+                                "Fail to merge field '{}' due to conflicting metadata data value for key {}.
+                                    From value = {} does not match {}", self.name, key, from_value, self_value),
+                            ));
+                        }
+                    } else {
+                        merged.insert(key.clone(), from_value.clone());
+                    }
+                }
+                self.set_metadata(merged);
+            }
+            (true, false) => {
+                self.set_metadata(from.metadata().clone());
+            }
+            _ => {}
+        }
+        match &mut self.data_type {
+            DataType::Struct(nested_fields) => match &from.data_type {
+                DataType::Struct(from_nested_fields) => {
+                    let mut builder = SchemaBuilder::new();
+                    nested_fields.iter().chain(from_nested_fields).try_for_each(|f| builder.try_merge(f))?;
+                    *nested_fields = builder.finish().fields;
+                }
+                _ => {
+                    return Err(ArrowError::SchemaError(
+                        format!("Fail to merge schema field '{}' because the from data_type = {} is not DataType::Struct",
+                            self.name, from.data_type)
+                ))}
+            },
+            DataType::Union(nested_fields, _) => match &from.data_type {
+                DataType::Union(from_nested_fields, _) => {
+                    nested_fields.try_merge(from_nested_fields)?
+                }
+                _ => {
+                    return Err(ArrowError::SchemaError(
+                        format!("Fail to merge schema field '{}' because the from data_type = {} is not DataType::Union",
+                            self.name, from.data_type)
+                    ));
+                }
+            },
+            DataType::Null => {
+                self.nullable = true;
+                self.data_type = from.data_type.clone();
+            }
+            | DataType::Boolean
+            | DataType::Int8
+            | DataType::Int16
+            | DataType::Int32
+            | DataType::Int64
+            | DataType::UInt8
+            | DataType::UInt16
+            | DataType::UInt32
+            | DataType::UInt64
+            | DataType::Float16
+            | DataType::Float32
+            | DataType::Float64
+            | DataType::Timestamp(_, _)
+            | DataType::Date32
+            | DataType::Date64
+            | DataType::Time32(_)
+            | DataType::Time64(_)
+            | DataType::Duration(_)
+            | DataType::Binary
+            | DataType::LargeBinary
+            | DataType::Interval(_)
+            | DataType::LargeList(_)
+            | DataType::List(_)
+            | DataType::Map(_, _)
+            | DataType::Dictionary(_, _)
+            | DataType::RunEndEncoded(_, _)
+            | DataType::FixedSizeList(_, _)
+            | DataType::FixedSizeBinary(_)
+            | DataType::Utf8
+            | DataType::LargeUtf8
+            | DataType::Decimal128(_, _)
+            | DataType::Decimal256(_, _) => {
+                if from.data_type == DataType::Null {
+                    self.nullable = true;
+                } else if self.data_type != from.data_type {
+                    return Err(ArrowError::SchemaError(
+                        format!("Fail to merge schema field '{}' because the from data_type = {} does not equal {}",
+                            self.name, from.data_type, self.data_type)
+                    ));
+                }
+            }
+        }
+        self.nullable |= from.nullable;
+
+        Ok(())
+    }
+
+    /// Check to see if `self` is a superset of `other` field. Superset is defined as:
+    ///
+    /// * if nullability doesn't match, self needs to be nullable
+    /// * self.metadata is a superset of other.metadata
+    /// * all other fields are equal
+    pub fn contains(&self, other: &Field) -> bool {
+        self.name == other.name
+        && self.data_type.contains(&other.data_type)
+        && self.dict_id == other.dict_id
+        && self.dict_is_ordered == other.dict_is_ordered
+        // self need to be nullable or both of them are not nullable
+        && (self.nullable || !other.nullable)
+        // make sure self.metadata is a superset of other.metadata
+        && other.metadata.iter().all(|(k, v1)| {
+            self.metadata.get(k).map(|v2| v1 == v2).unwrap_or_default()
+        })
+    }
+
+    /// Return size of this instance in bytes.
+    ///
+    /// Includes the size of `Self`.
+    pub fn size(&self) -> usize {
+        std::mem::size_of_val(self) - std::mem::size_of_val(&self.data_type)
+            + self.data_type.size()
+            + self.name.capacity()
+            + (std::mem::size_of::<(String, String)>() * self.metadata.capacity())
+            + self
+                .metadata
+                .iter()
+                .map(|(k, v)| k.capacity() + v.capacity())
+                .sum::<usize>()
+    }
+}
+
+// TODO: improve display with crate https://crates.io/crates/derive_more ?
+impl std::fmt::Display for Field {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        write!(f, "{self:?}")
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+    use crate::Fields;
+    use std::collections::hash_map::DefaultHasher;
+    use std::hash::{Hash, Hasher};
+    use std::sync::Arc;
+
+    #[test]
+    fn test_new_with_string() {
+        // Fields should allow owned Strings to support reuse
+        let s = String::from("c1");
+        Field::new(s, DataType::Int64, false);
+    }
+
+    #[test]
+    fn test_new_dict_with_string() {
+        // Fields should allow owned Strings to support reuse
+        let s = String::from("c1");
+        Field::new_dict(s, DataType::Int64, false, 4, false);
+    }
+
+    #[test]
+    fn test_merge_incompatible_types() {
+        let mut field = Field::new("c1", DataType::Int64, false);
+        let result = field
+            .try_merge(&Field::new("c1", DataType::Float32, true))
+            .expect_err("should fail")
+            .to_string();
+        assert_eq!("Schema error: Fail to merge schema field 'c1' because the from data_type = Float32 does not equal Int64", result);
+    }
+
+    #[test]
+    fn test_merge_with_null() {
+        let mut field1 = Field::new("c1", DataType::Null, true);
+        field1
+            .try_merge(&Field::new("c1", DataType::Float32, false))
+            .expect("should widen type to nullable float");
+        assert_eq!(Field::new("c1", DataType::Float32, true), field1);
+
+        let mut field2 = Field::new("c2", DataType::Utf8, false);
+        field2
+            .try_merge(&Field::new("c2", DataType::Null, true))
+            .expect("should widen type to nullable utf8");
+        assert_eq!(Field::new("c2", DataType::Utf8, true), field2);
+    }
+
+    #[test]
+    fn test_fields_with_dict_id() {
+        let dict1 = Field::new_dict(
+            "dict1",
+            DataType::Dictionary(DataType::Utf8.into(), DataType::Int32.into()),
+            false,
+            10,
+            false,
+        );
+        let dict2 = Field::new_dict(
+            "dict2",
+            DataType::Dictionary(DataType::Int32.into(), DataType::Int8.into()),
+            false,
+            20,
+            false,
+        );
+
+        let field = Field::new(
+            "struct<dict1, list[struct<dict2, list[struct<dict1]>]>",
+            DataType::Struct(Fields::from(vec![
+                dict1.clone(),
+                Field::new(
+                    "list[struct<dict1, list[struct<dict2>]>]",
+                    DataType::List(Arc::new(Field::new(
+                        "struct<dict1, list[struct<dict2>]>",
+                        DataType::Struct(Fields::from(vec![
+                            dict1.clone(),
+                            Field::new(
+                                "list[struct<dict2>]",
+                                DataType::List(Arc::new(Field::new(
+                                    "struct<dict2>",
+                                    DataType::Struct(vec![dict2.clone()].into()),
+                                    false,
+                                ))),
+                                false,
+                            ),
+                        ])),
+                        false,
+                    ))),
+                    false,
+                ),
+            ])),
+            false,
+        );
+
+        for field in field.fields_with_dict_id(10) {
+            assert_eq!(dict1, *field);
+        }
+        for field in field.fields_with_dict_id(20) {
+            assert_eq!(dict2, *field);
+        }
+    }
+
+    fn get_field_hash(field: &Field) -> u64 {
+        let mut s = DefaultHasher::new();
+        field.hash(&mut s);
+        s.finish()
+    }
+
+    #[test]
+    fn test_field_comparison_case() {
+        // dictionary-encoding properties not used for field comparison
+        let dict1 = Field::new_dict(
+            "dict1",
+            DataType::Dictionary(DataType::Utf8.into(), DataType::Int32.into()),
+            false,
+            10,
+            false,
+        );
+        let dict2 = Field::new_dict(
+            "dict1",
+            DataType::Dictionary(DataType::Utf8.into(), DataType::Int32.into()),
+            false,
+            20,
+            false,
+        );
+
+        assert_eq!(dict1, dict2);
+        assert_eq!(get_field_hash(&dict1), get_field_hash(&dict2));
+
+        let dict1 = Field::new_dict(
+            "dict0",
+            DataType::Dictionary(DataType::Utf8.into(), DataType::Int32.into()),
+            false,
+            10,
+            false,
+        );
+
+        assert_ne!(dict1, dict2);
+        assert_ne!(get_field_hash(&dict1), get_field_hash(&dict2));
+    }
+
+    #[test]
+    fn test_field_comparison_metadata() {
+        let f1 = Field::new("x", DataType::Binary, false).with_metadata(HashMap::from([
+            (String::from("k1"), String::from("v1")),
+            (String::from("k2"), String::from("v2")),
+        ]));
+        let f2 = Field::new("x", DataType::Binary, false).with_metadata(HashMap::from([
+            (String::from("k1"), String::from("v1")),
+            (String::from("k3"), String::from("v3")),
+        ]));
+        let f3 = Field::new("x", DataType::Binary, false).with_metadata(HashMap::from([
+            (String::from("k1"), String::from("v1")),
+            (String::from("k3"), String::from("v4")),
+        ]));
+
+        assert!(f1.cmp(&f2).is_lt());
+        assert!(f2.cmp(&f3).is_lt());
+        assert!(f1.cmp(&f3).is_lt());
+    }
+
+    #[test]
+    fn test_contains_reflexivity() {
+        let mut field = Field::new("field1", DataType::Float16, false);
+        field.set_metadata(HashMap::from([
+            (String::from("k0"), String::from("v0")),
+            (String::from("k1"), String::from("v1")),
+        ]));
+        assert!(field.contains(&field))
+    }
+
+    #[test]
+    fn test_contains_transitivity() {
+        let child_field = Field::new("child1", DataType::Float16, false);
+
+        let mut field1 = Field::new(
+            "field1",
+            DataType::Struct(Fields::from(vec![child_field])),
+            false,
+        );
+        field1.set_metadata(HashMap::from([(String::from("k1"), String::from("v1"))]));
+
+        let mut field2 = Field::new("field1", DataType::Struct(Fields::default()), true);
+        field2.set_metadata(HashMap::from([(String::from("k2"), String::from("v2"))]));
+        field2.try_merge(&field1).unwrap();
+
+        let mut field3 = Field::new("field1", DataType::Struct(Fields::default()), false);
+        field3.set_metadata(HashMap::from([(String::from("k3"), String::from("v3"))]));
+        field3.try_merge(&field2).unwrap();
+
+        assert!(field2.contains(&field1));
+        assert!(field3.contains(&field2));
+        assert!(field3.contains(&field1));
+
+        assert!(!field1.contains(&field2));
+        assert!(!field1.contains(&field3));
+        assert!(!field2.contains(&field3));
+    }
+
+    #[test]
+    fn test_contains_nullable() {
+        let field1 = Field::new("field1", DataType::Boolean, true);
+        let field2 = Field::new("field1", DataType::Boolean, false);
+        assert!(field1.contains(&field2));
+        assert!(!field2.contains(&field1));
+    }
+
+    #[test]
+    fn test_contains_must_have_same_fields() {
+        let child_field1 = Field::new("child1", DataType::Float16, false);
+        let child_field2 = Field::new("child2", DataType::Float16, false);
+
+        let field1 = Field::new(
+            "field1",
+            DataType::Struct(vec![child_field1.clone()].into()),
+            true,
+        );
+        let field2 = Field::new(
+            "field1",
+            DataType::Struct(vec![child_field1, child_field2].into()),
+            true,
+        );
+
+        assert!(!field1.contains(&field2));
+        assert!(!field2.contains(&field1));
+
+        // UnionFields with different type ID
+        let field1 = Field::new(
+            "field1",
+            DataType::Union(
+                UnionFields::new(
+                    vec![1, 2],
+                    vec![
+                        Field::new("field1", DataType::UInt8, true),
+                        Field::new("field3", DataType::Utf8, false),
+                    ],
+                ),
+                UnionMode::Dense,
+            ),
+            true,
+        );
+        let field2 = Field::new(
+            "field1",
+            DataType::Union(
+                UnionFields::new(
+                    vec![1, 3],
+                    vec![
+                        Field::new("field1", DataType::UInt8, false),
+                        Field::new("field3", DataType::Utf8, false),
+                    ],
+                ),
+                UnionMode::Dense,
+            ),
+            true,
+        );
+        assert!(!field1.contains(&field2));
+
+        // UnionFields with same type ID
+        let field1 = Field::new(
+            "field1",
+            DataType::Union(
+                UnionFields::new(
+                    vec![1, 2],
+                    vec![
+                        Field::new("field1", DataType::UInt8, true),
+                        Field::new("field3", DataType::Utf8, false),
+                    ],
+                ),
+                UnionMode::Dense,
+            ),
+            true,
+        );
+        let field2 = Field::new(
+            "field1",
+            DataType::Union(
+                UnionFields::new(
+                    vec![1, 2],
+                    vec![
+                        Field::new("field1", DataType::UInt8, false),
+                        Field::new("field3", DataType::Utf8, false),
+                    ],
+                ),
+                UnionMode::Dense,
+            ),
+            true,
+        );
+        assert!(field1.contains(&field2));
+    }
+
+    #[cfg(feature = "serde")]
+    fn assert_binary_serde_round_trip(field: Field) {
+        let serialized = bincode::serialize(&field).unwrap();
+        let deserialized: Field = bincode::deserialize(&serialized).unwrap();
+        assert_eq!(field, deserialized)
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_field_without_metadata_serde() {
+        let field = Field::new("name", DataType::Boolean, true);
+        assert_binary_serde_round_trip(field)
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_field_with_empty_metadata_serde() {
+        let field = Field::new("name", DataType::Boolean, false).with_metadata(HashMap::new());
+
+        assert_binary_serde_round_trip(field)
+    }
+
+    #[cfg(feature = "serde")]
+    #[test]
+    fn test_field_with_nonempty_metadata_serde() {
+        let mut metadata = HashMap::new();
+        metadata.insert("hi".to_owned(), "".to_owned());
+        let field = Field::new("name", DataType::Boolean, false).with_metadata(metadata);
+
+        assert_binary_serde_round_trip(field)
+    }
+}
diff --git a/arrow-schema/src/fields.rs b/arrow-schema/src/fields.rs
new file mode 100644
index 000000000000..59b7e76c7823
--- /dev/null
+++ b/arrow-schema/src/fields.rs
@@ -0,0 +1,535 @@
+// 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.
+
+use std::ops::Deref;
+use std::sync::Arc;
+
+use crate::{ArrowError, DataType, Field, FieldRef, SchemaBuilder};
+
+/// A cheaply cloneable, owned slice of [`FieldRef`]
+///
+/// Similar to `Arc<Vec<FieldRef>>` or `Arc<[FieldRef]>`
+///
+/// Can be constructed in a number of ways
+///
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_schema::{DataType, Field, Fields, SchemaBuilder};
+/// // Can be constructed from Vec<Field>
+/// Fields::from(vec![Field::new("a", DataType::Boolean, false)]);
+/// // Can be constructed from Vec<FieldRef>
+/// Fields::from(vec![Arc::new(Field::new("a", DataType::Boolean, false))]);
+/// // Can be constructed from an iterator of Field
+/// std::iter::once(Field::new("a", DataType::Boolean, false)).collect::<Fields>();
+/// // Can be constructed from an iterator of FieldRef
+/// std::iter::once(Arc::new(Field::new("a", DataType::Boolean, false))).collect::<Fields>();
+/// ```
+///
+/// See [`SchemaBuilder`] for mutating or updating [`Fields`]
+///
+/// ```
+/// # use arrow_schema::{DataType, Field, SchemaBuilder};
+/// let mut builder = SchemaBuilder::new();
+/// builder.push(Field::new("a", DataType::Boolean, false));
+/// builder.push(Field::new("b", DataType::Boolean, false));
+/// let fields = builder.finish().fields;
+///
+/// let mut builder = SchemaBuilder::from(&fields);
+/// builder.remove(0);
+/// let new = builder.finish().fields;
+/// ```
+///
+/// [`SchemaBuilder`]: crate::SchemaBuilder
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+pub struct Fields(Arc<[FieldRef]>);
+
+impl std::fmt::Debug for Fields {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.as_ref().fmt(f)
+    }
+}
+
+impl Fields {
+    /// Returns a new empty [`Fields`]
+    pub fn empty() -> Self {
+        Self(Arc::new([]))
+    }
+
+    /// Return size of this instance in bytes.
+    pub fn size(&self) -> usize {
+        self.iter()
+            .map(|field| field.size() + std::mem::size_of::<FieldRef>())
+            .sum()
+    }
+
+    /// Searches for a field by name, returning it along with its index if found
+    pub fn find(&self, name: &str) -> Option<(usize, &FieldRef)> {
+        self.0.iter().enumerate().find(|(_, b)| b.name() == name)
+    }
+
+    /// Check to see if `self` is a superset of `other`
+    ///
+    /// In particular returns true if both have the same number of fields, and [`Field::contains`]
+    /// for each field across self and other
+    ///
+    /// In other words, any record that conforms to `other` should also conform to `self`
+    pub fn contains(&self, other: &Fields) -> bool {
+        if Arc::ptr_eq(&self.0, &other.0) {
+            return true;
+        }
+        self.len() == other.len()
+            && self
+                .iter()
+                .zip(other.iter())
+                .all(|(a, b)| Arc::ptr_eq(a, b) || a.contains(b))
+    }
+
+    /// Returns a copy of this [`Fields`] containing only those [`FieldRef`] passing a predicate
+    ///
+    /// Performs a depth-first scan of [`Fields`] invoking `filter` for each [`FieldRef`]
+    /// containing no child [`FieldRef`], a leaf field, along with a count of the number
+    /// of such leaves encountered so far. Only [`FieldRef`] for which `filter`
+    /// returned `true` will be included in the result.
+    ///
+    /// This can therefore be used to select a subset of fields from nested types
+    /// such as [`DataType::Struct`] or [`DataType::List`].
+    ///
+    /// ```
+    /// # use arrow_schema::{DataType, Field, Fields};
+    /// let fields = Fields::from(vec![
+    ///     Field::new("a", DataType::Int32, true), // Leaf 0
+    ///     Field::new("b", DataType::Struct(Fields::from(vec![
+    ///         Field::new("c", DataType::Float32, false), // Leaf 1
+    ///         Field::new("d", DataType::Float64, false), // Leaf 2
+    ///         Field::new("e", DataType::Struct(Fields::from(vec![
+    ///             Field::new("f", DataType::Int32, false),   // Leaf 3
+    ///             Field::new("g", DataType::Float16, false), // Leaf 4
+    ///         ])), true),
+    ///     ])), false)
+    /// ]);
+    /// let filtered = fields.filter_leaves(|idx, _| [0, 2, 3, 4].contains(&idx));
+    /// let expected = Fields::from(vec![
+    ///     Field::new("a", DataType::Int32, true),
+    ///     Field::new("b", DataType::Struct(Fields::from(vec![
+    ///         Field::new("d", DataType::Float64, false),
+    ///         Field::new("e", DataType::Struct(Fields::from(vec![
+    ///             Field::new("f", DataType::Int32, false),
+    ///             Field::new("g", DataType::Float16, false),
+    ///         ])), true),
+    ///     ])), false)
+    /// ]);
+    /// assert_eq!(filtered, expected);
+    /// ```
+    pub fn filter_leaves<F: FnMut(usize, &FieldRef) -> bool>(&self, mut filter: F) -> Self {
+        fn filter_field<F: FnMut(&FieldRef) -> bool>(
+            f: &FieldRef,
+            filter: &mut F,
+        ) -> Option<FieldRef> {
+            use DataType::*;
+
+            let v = match f.data_type() {
+                Dictionary(_, v) => v.as_ref(),       // Key must be integer
+                RunEndEncoded(_, v) => v.data_type(), // Run-ends must be integer
+                d => d,
+            };
+            let d = match v {
+                List(child) => List(filter_field(child, filter)?),
+                LargeList(child) => LargeList(filter_field(child, filter)?),
+                Map(child, ordered) => Map(filter_field(child, filter)?, *ordered),
+                FixedSizeList(child, size) => FixedSizeList(filter_field(child, filter)?, *size),
+                Struct(fields) => {
+                    let filtered: Fields = fields
+                        .iter()
+                        .filter_map(|f| filter_field(f, filter))
+                        .collect();
+
+                    if filtered.is_empty() {
+                        return None;
+                    }
+
+                    Struct(filtered)
+                }
+                Union(fields, mode) => {
+                    let filtered: UnionFields = fields
+                        .iter()
+                        .filter_map(|(id, f)| Some((id, filter_field(f, filter)?)))
+                        .collect();
+
+                    if filtered.is_empty() {
+                        return None;
+                    }
+
+                    Union(filtered, *mode)
+                }
+                _ => return filter(f).then(|| f.clone()),
+            };
+            let d = match f.data_type() {
+                Dictionary(k, _) => Dictionary(k.clone(), Box::new(d)),
+                RunEndEncoded(v, f) => {
+                    RunEndEncoded(v.clone(), Arc::new(f.as_ref().clone().with_data_type(d)))
+                }
+                _ => d,
+            };
+            Some(Arc::new(f.as_ref().clone().with_data_type(d)))
+        }
+
+        let mut leaf_idx = 0;
+        let mut filter = |f: &FieldRef| {
+            let t = filter(leaf_idx, f);
+            leaf_idx += 1;
+            t
+        };
+
+        self.0
+            .iter()
+            .filter_map(|f| filter_field(f, &mut filter))
+            .collect()
+    }
+
+    /// Remove a field by index and return it.
+    ///
+    /// # Panic
+    ///
+    /// Panics if `index` is out of bounds.
+    ///
+    /// # Example
+    /// ```
+    /// use arrow_schema::{DataType, Field, Fields};
+    /// let mut fields = Fields::from(vec![
+    ///   Field::new("a", DataType::Boolean, false),
+    ///   Field::new("b", DataType::Int8, false),
+    ///   Field::new("c", DataType::Utf8, false),
+    /// ]);
+    /// assert_eq!(fields.len(), 3);
+    /// assert_eq!(fields.remove(1), Field::new("b", DataType::Int8, false).into());
+    /// assert_eq!(fields.len(), 2);
+    /// ```
+    #[deprecated(note = "Use SchemaBuilder::remove")]
+    #[doc(hidden)]
+    pub fn remove(&mut self, index: usize) -> FieldRef {
+        let mut builder = SchemaBuilder::from(Fields::from(&*self.0));
+        let field = builder.remove(index);
+        *self = builder.finish().fields;
+        field
+    }
+}
+
+impl Default for Fields {
+    fn default() -> Self {
+        Self::empty()
+    }
+}
+
+impl FromIterator<Field> for Fields {
+    fn from_iter<T: IntoIterator<Item = Field>>(iter: T) -> Self {
+        iter.into_iter().map(Arc::new).collect()
+    }
+}
+
+impl FromIterator<FieldRef> for Fields {
+    fn from_iter<T: IntoIterator<Item = FieldRef>>(iter: T) -> Self {
+        Self(iter.into_iter().collect())
+    }
+}
+
+impl From<Vec<Field>> for Fields {
+    fn from(value: Vec<Field>) -> Self {
+        value.into_iter().collect()
+    }
+}
+
+impl From<Vec<FieldRef>> for Fields {
+    fn from(value: Vec<FieldRef>) -> Self {
+        Self(value.into())
+    }
+}
+
+impl From<&[FieldRef]> for Fields {
+    fn from(value: &[FieldRef]) -> Self {
+        Self(value.into())
+    }
+}
+
+impl<const N: usize> From<[FieldRef; N]> for Fields {
+    fn from(value: [FieldRef; N]) -> Self {
+        Self(Arc::new(value))
+    }
+}
+
+impl Deref for Fields {
+    type Target = [FieldRef];
+
+    fn deref(&self) -> &Self::Target {
+        self.0.as_ref()
+    }
+}
+
+impl<'a> IntoIterator for &'a Fields {
+    type Item = &'a FieldRef;
+    type IntoIter = std::slice::Iter<'a, FieldRef>;
+
+    fn into_iter(self) -> Self::IntoIter {
+        self.0.iter()
+    }
+}
+
+/// A cheaply cloneable, owned collection of [`FieldRef`] and their corresponding type ids
+#[derive(Clone, Eq, PartialEq, Ord, PartialOrd, Hash)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serde", serde(transparent))]
+pub struct UnionFields(Arc<[(i8, FieldRef)]>);
+
+impl std::fmt::Debug for UnionFields {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.as_ref().fmt(f)
+    }
+}
+
+impl UnionFields {
+    /// Create a new [`UnionFields`] with no fields
+    pub fn empty() -> Self {
+        Self(Arc::from([]))
+    }
+
+    /// Create a new [`UnionFields`] from a [`Fields`] and array of type_ids
+    ///
+    /// See <https://arrow.apache.org/docs/format/Columnar.html#union-layout>
+    ///
+    /// ```
+    /// use arrow_schema::{DataType, Field, UnionFields};
+    /// // Create a new UnionFields with type id mapping
+    /// // 1 -> DataType::UInt8
+    /// // 3 -> DataType::Utf8
+    /// UnionFields::new(
+    ///     vec![1, 3],
+    ///     vec![
+    ///         Field::new("field1", DataType::UInt8, false),
+    ///         Field::new("field3", DataType::Utf8, false),
+    ///     ],
+    /// );
+    /// ```
+    pub fn new<F, T>(type_ids: T, fields: F) -> Self
+    where
+        F: IntoIterator,
+        F::Item: Into<FieldRef>,
+        T: IntoIterator<Item = i8>,
+    {
+        let fields = fields.into_iter().map(Into::into);
+        let mut set = 0_u128;
+        type_ids
+            .into_iter()
+            .map(|idx| {
+                let mask = 1_u128 << idx;
+                if (set & mask) != 0 {
+                    panic!("duplicate type id: {}", idx);
+                } else {
+                    set |= mask;
+                }
+                idx
+            })
+            .zip(fields)
+            .collect()
+    }
+
+    /// Return size of this instance in bytes.
+    pub fn size(&self) -> usize {
+        self.iter()
+            .map(|(_, field)| field.size() + std::mem::size_of::<(i8, FieldRef)>())
+            .sum()
+    }
+
+    /// Returns the number of fields in this [`UnionFields`]
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Returns `true` if this is empty
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Returns an iterator over the fields and type ids in this [`UnionFields`]
+    ///
+    /// Note: the iteration order is not guaranteed
+    pub fn iter(&self) -> impl Iterator<Item = (i8, &FieldRef)> + '_ {
+        self.0.iter().map(|(id, f)| (*id, f))
+    }
+
+    /// Merge this field into self if it is compatible.
+    ///
+    /// See [`Field::try_merge`]
+    pub(crate) fn try_merge(&mut self, other: &Self) -> Result<(), ArrowError> {
+        // TODO: This currently may produce duplicate type IDs (#3982)
+        let mut output: Vec<_> = self.iter().map(|(id, f)| (id, f.clone())).collect();
+        for (field_type_id, from_field) in other.iter() {
+            let mut is_new_field = true;
+            for (self_type_id, self_field) in output.iter_mut() {
+                if from_field == self_field {
+                    // If the nested fields in two unions are the same, they must have same
+                    // type id.
+                    if *self_type_id != field_type_id {
+                        return Err(ArrowError::SchemaError(
+                            format!("Fail to merge schema field '{}' because the self_type_id = {} does not equal field_type_id = {}",
+                                    self_field.name(), self_type_id, field_type_id)
+                        ));
+                    }
+
+                    is_new_field = false;
+                    break;
+                }
+            }
+
+            if is_new_field {
+                output.push((field_type_id, from_field.clone()))
+            }
+        }
+        *self = output.into_iter().collect();
+        Ok(())
+    }
+}
+
+impl FromIterator<(i8, FieldRef)> for UnionFields {
+    fn from_iter<T: IntoIterator<Item = (i8, FieldRef)>>(iter: T) -> Self {
+        // TODO: Should this validate type IDs are unique (#3982)
+        Self(iter.into_iter().collect())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::UnionMode;
+
+    #[test]
+    fn test_filter() {
+        let floats = Fields::from(vec![
+            Field::new("a", DataType::Float32, false),
+            Field::new("b", DataType::Float32, false),
+        ]);
+        let fields = Fields::from(vec![
+            Field::new("a", DataType::Int32, true),
+            Field::new("floats", DataType::Struct(floats.clone()), true),
+            Field::new("b", DataType::Int16, true),
+            Field::new(
+                "c",
+                DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
+                false,
+            ),
+            Field::new(
+                "d",
+                DataType::Dictionary(
+                    Box::new(DataType::Int32),
+                    Box::new(DataType::Struct(floats.clone())),
+                ),
+                false,
+            ),
+            Field::new_list(
+                "e",
+                Field::new("floats", DataType::Struct(floats.clone()), true),
+                true,
+            ),
+            Field::new_fixed_size_list("f", Field::new("item", DataType::Int32, false), 3, false),
+            Field::new_map(
+                "g",
+                "entries",
+                Field::new("keys", DataType::LargeUtf8, false),
+                Field::new("values", DataType::Int32, true),
+                false,
+                false,
+            ),
+            Field::new(
+                "h",
+                DataType::Union(
+                    UnionFields::new(
+                        vec![1, 3],
+                        vec![
+                            Field::new("field1", DataType::UInt8, false),
+                            Field::new("field3", DataType::Utf8, false),
+                        ],
+                    ),
+                    UnionMode::Dense,
+                ),
+                true,
+            ),
+            Field::new(
+                "i",
+                DataType::RunEndEncoded(
+                    Arc::new(Field::new("run_ends", DataType::Int32, false)),
+                    Arc::new(Field::new("values", DataType::Struct(floats.clone()), true)),
+                ),
+                false,
+            ),
+        ]);
+
+        let floats_a = DataType::Struct(vec![floats[0].clone()].into());
+
+        let r = fields.filter_leaves(|idx, _| idx == 0 || idx == 1);
+        assert_eq!(r.len(), 2);
+        assert_eq!(r[0], fields[0]);
+        assert_eq!(r[1].data_type(), &floats_a);
+
+        let r = fields.filter_leaves(|_, f| f.name() == "a");
+        assert_eq!(r.len(), 5);
+        assert_eq!(r[0], fields[0]);
+        assert_eq!(r[1].data_type(), &floats_a);
+        assert_eq!(
+            r[2].data_type(),
+            &DataType::Dictionary(Box::new(DataType::Int32), Box::new(floats_a.clone()))
+        );
+        assert_eq!(
+            r[3].as_ref(),
+            &Field::new_list("e", Field::new("floats", floats_a.clone(), true), true)
+        );
+        assert_eq!(
+            r[4].as_ref(),
+            &Field::new(
+                "i",
+                DataType::RunEndEncoded(
+                    Arc::new(Field::new("run_ends", DataType::Int32, false)),
+                    Arc::new(Field::new("values", floats_a.clone(), true)),
+                ),
+                false,
+            )
+        );
+
+        let r = fields.filter_leaves(|_, f| f.name() == "floats");
+        assert_eq!(r.len(), 0);
+
+        let r = fields.filter_leaves(|idx, _| idx == 9);
+        assert_eq!(r.len(), 1);
+        assert_eq!(r[0], fields[6]);
+
+        let r = fields.filter_leaves(|idx, _| idx == 10 || idx == 11);
+        assert_eq!(r.len(), 1);
+        assert_eq!(r[0], fields[7]);
+
+        let union = DataType::Union(
+            UnionFields::new(vec![1], vec![Field::new("field1", DataType::UInt8, false)]),
+            UnionMode::Dense,
+        );
+
+        let r = fields.filter_leaves(|idx, _| idx == 12);
+        assert_eq!(r.len(), 1);
+        assert_eq!(r[0].data_type(), &union);
+
+        let r = fields.filter_leaves(|idx, _| idx == 14 || idx == 15);
+        assert_eq!(r.len(), 1);
+        assert_eq!(r[0], fields[9]);
+    }
+}
diff --git a/arrow-schema/src/lib.rs b/arrow-schema/src/lib.rs
new file mode 100644
index 000000000000..2d539417f78b
--- /dev/null
+++ b/arrow-schema/src/lib.rs
@@ -0,0 +1,99 @@
+// 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.
+
+//! Arrow logical types
+
+mod datatype;
+pub use datatype::*;
+mod error;
+pub use error::*;
+mod field;
+pub use field::*;
+mod fields;
+pub use fields::*;
+mod schema;
+pub use schema::*;
+use std::ops;
+
+#[cfg(feature = "ffi")]
+pub mod ffi;
+
+/// Options that define the sort order of a given column
+#[derive(Clone, Hash, Copy, Debug, Eq, PartialEq, Ord, PartialOrd)]
+pub struct SortOptions {
+    /// Whether to sort in descending order
+    pub descending: bool,
+    /// Whether to sort nulls first
+    pub nulls_first: bool,
+}
+
+impl Default for SortOptions {
+    fn default() -> Self {
+        Self {
+            descending: false,
+            // default to nulls first to match spark's behavior
+            nulls_first: true,
+        }
+    }
+}
+
+/// `!` operator is overloaded for `SortOptions` to invert boolean
+/// fields of the struct.
+impl ops::Not for SortOptions {
+    type Output = SortOptions;
+
+    fn not(self) -> SortOptions {
+        SortOptions {
+            descending: !self.descending,
+            nulls_first: !self.nulls_first,
+        }
+    }
+}
+
+#[test]
+fn test_overloaded_not_sort_options() {
+    let sort_options_array = [
+        SortOptions {
+            descending: false,
+            nulls_first: false,
+        },
+        SortOptions {
+            descending: false,
+            nulls_first: true,
+        },
+        SortOptions {
+            descending: true,
+            nulls_first: false,
+        },
+        SortOptions {
+            descending: true,
+            nulls_first: true,
+        },
+    ];
+
+    assert!((!sort_options_array[0]).descending);
+    assert!((!sort_options_array[0]).nulls_first);
+
+    assert!((!sort_options_array[1]).descending);
+    assert!(!(!sort_options_array[1]).nulls_first);
+
+    assert!(!(!sort_options_array[2]).descending);
+    assert!((!sort_options_array[2]).nulls_first);
+
+    assert!(!(!sort_options_array[3]).descending);
+    assert!(!(!sort_options_array[3]).nulls_first);
+}
diff --git a/arrow-schema/src/schema.rs b/arrow-schema/src/schema.rs
new file mode 100644
index 000000000000..ede158fcf248
--- /dev/null
+++ b/arrow-schema/src/schema.rs
@@ -0,0 +1,966 @@
+// 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.
+
+use std::collections::HashMap;
+use std::fmt;
+use std::hash::Hash;
+use std::sync::Arc;
+
+use crate::error::ArrowError;
+use crate::field::Field;
+use crate::{FieldRef, Fields};
+
+/// A builder to facilitate building a [`Schema`] from iteratively from [`FieldRef`]
+#[derive(Debug, Default)]
+pub struct SchemaBuilder {
+    fields: Vec<FieldRef>,
+    metadata: HashMap<String, String>,
+}
+
+impl SchemaBuilder {
+    /// Creates a new empty [`SchemaBuilder`]
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Creates a new empty [`SchemaBuilder`] with space for `capacity` fields
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            fields: Vec::with_capacity(capacity),
+            metadata: Default::default(),
+        }
+    }
+
+    /// Appends a [`FieldRef`] to this [`SchemaBuilder`] without checking for collision
+    pub fn push(&mut self, field: impl Into<FieldRef>) {
+        self.fields.push(field.into())
+    }
+
+    /// Removes and returns the [`FieldRef`] as index `idx`
+    ///
+    /// # Panics
+    ///
+    /// Panics if index out of bounds
+    pub fn remove(&mut self, idx: usize) -> FieldRef {
+        self.fields.remove(idx)
+    }
+
+    /// Returns an immutable reference to the [`FieldRef`] at index `idx`
+    ///
+    /// # Panics
+    ///
+    /// Panics if index out of bounds
+    pub fn field(&mut self, idx: usize) -> &FieldRef {
+        &mut self.fields[idx]
+    }
+
+    /// Returns a mutable reference to the [`FieldRef`] at index `idx`
+    ///
+    /// # Panics
+    ///
+    /// Panics if index out of bounds
+    pub fn field_mut(&mut self, idx: usize) -> &mut FieldRef {
+        &mut self.fields[idx]
+    }
+
+    /// Returns an immutable reference to the Map of custom metadata key-value pairs.
+    pub fn metadata(&mut self) -> &HashMap<String, String> {
+        &self.metadata
+    }
+
+    /// Returns a mutable reference to the Map of custom metadata key-value pairs.
+    pub fn metadata_mut(&mut self) -> &mut HashMap<String, String> {
+        &mut self.metadata
+    }
+
+    /// Reverse the fileds
+    pub fn reverse(&mut self) {
+        self.fields.reverse();
+    }
+
+    /// Appends a [`FieldRef`] to this [`SchemaBuilder`] checking for collision
+    ///
+    /// If an existing field exists with the same name, calls [`Field::try_merge`]
+    pub fn try_merge(&mut self, field: &FieldRef) -> Result<(), ArrowError> {
+        // This could potentially be sped up with a HashMap or similar
+        let existing = self.fields.iter_mut().find(|f| f.name() == field.name());
+        match existing {
+            Some(e) if Arc::ptr_eq(e, field) => {} // Nothing to do
+            Some(e) => match Arc::get_mut(e) {
+                Some(e) => e.try_merge(field.as_ref())?,
+                None => {
+                    let mut t = e.as_ref().clone();
+                    t.try_merge(field)?;
+                    *e = Arc::new(t)
+                }
+            },
+            None => self.fields.push(field.clone()),
+        }
+        Ok(())
+    }
+
+    /// Consume this [`SchemaBuilder`] yielding the final [`Schema`]
+    pub fn finish(self) -> Schema {
+        Schema {
+            fields: self.fields.into(),
+            metadata: self.metadata,
+        }
+    }
+}
+
+impl From<&Fields> for SchemaBuilder {
+    fn from(value: &Fields) -> Self {
+        Self {
+            fields: value.to_vec(),
+            metadata: Default::default(),
+        }
+    }
+}
+
+impl From<Fields> for SchemaBuilder {
+    fn from(value: Fields) -> Self {
+        Self {
+            fields: value.to_vec(),
+            metadata: Default::default(),
+        }
+    }
+}
+
+impl From<&Schema> for SchemaBuilder {
+    fn from(value: &Schema) -> Self {
+        Self::from(value.clone())
+    }
+}
+
+impl From<Schema> for SchemaBuilder {
+    fn from(value: Schema) -> Self {
+        Self {
+            fields: value.fields.to_vec(),
+            metadata: value.metadata,
+        }
+    }
+}
+
+impl Extend<FieldRef> for SchemaBuilder {
+    fn extend<T: IntoIterator<Item = FieldRef>>(&mut self, iter: T) {
+        let iter = iter.into_iter();
+        self.fields.reserve(iter.size_hint().0);
+        for f in iter {
+            self.push(f)
+        }
+    }
+}
+
+impl Extend<Field> for SchemaBuilder {
+    fn extend<T: IntoIterator<Item = Field>>(&mut self, iter: T) {
+        let iter = iter.into_iter();
+        self.fields.reserve(iter.size_hint().0);
+        for f in iter {
+            self.push(f)
+        }
+    }
+}
+
+/// A reference-counted reference to a [`Schema`].
+pub type SchemaRef = Arc<Schema>;
+
+/// Describes the meta-data of an ordered sequence of relative types.
+///
+/// Note that this information is only part of the meta-data and not part of the physical
+/// memory layout.
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
+pub struct Schema {
+    pub fields: Fields,
+    /// A map of key-value pairs containing additional meta data.
+    pub metadata: HashMap<String, String>,
+}
+
+impl Schema {
+    /// Creates an empty `Schema`
+    pub fn empty() -> Self {
+        Self {
+            fields: Default::default(),
+            metadata: HashMap::new(),
+        }
+    }
+
+    /// Creates a new [`Schema`] from a sequence of [`Field`] values.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use arrow_schema::*;
+    /// let field_a = Field::new("a", DataType::Int64, false);
+    /// let field_b = Field::new("b", DataType::Boolean, false);
+    ///
+    /// let schema = Schema::new(vec![field_a, field_b]);
+    /// ```
+    pub fn new(fields: impl Into<Fields>) -> Self {
+        Self::new_with_metadata(fields, HashMap::new())
+    }
+
+    /// Creates a new [`Schema`] from a sequence of [`Field`] values
+    /// and adds additional metadata in form of key value pairs.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use arrow_schema::*;
+    /// # use std::collections::HashMap;
+    ///
+    /// let field_a = Field::new("a", DataType::Int64, false);
+    /// let field_b = Field::new("b", DataType::Boolean, false);
+    ///
+    /// let mut metadata: HashMap<String, String> = HashMap::new();
+    /// metadata.insert("row_count".to_string(), "100".to_string());
+    ///
+    /// let schema = Schema::new_with_metadata(vec![field_a, field_b], metadata);
+    /// ```
+    #[inline]
+    pub fn new_with_metadata(fields: impl Into<Fields>, metadata: HashMap<String, String>) -> Self {
+        Self {
+            fields: fields.into(),
+            metadata,
+        }
+    }
+
+    /// Sets the metadata of this `Schema` to be `metadata` and returns self
+    pub fn with_metadata(mut self, metadata: HashMap<String, String>) -> Self {
+        self.metadata = metadata;
+        self
+    }
+
+    /// Returns a new schema with only the specified columns in the new schema
+    /// This carries metadata from the parent schema over as well
+    pub fn project(&self, indices: &[usize]) -> Result<Schema, ArrowError> {
+        let new_fields = indices
+            .iter()
+            .map(|i| {
+                self.fields.get(*i).cloned().ok_or_else(|| {
+                    ArrowError::SchemaError(format!(
+                        "project index {} out of bounds, max field {}",
+                        i,
+                        self.fields().len()
+                    ))
+                })
+            })
+            .collect::<Result<Vec<_>, _>>()?;
+        Ok(Self::new_with_metadata(new_fields, self.metadata.clone()))
+    }
+
+    /// Merge schema into self if it is compatible. Struct fields will be merged recursively.
+    ///
+    /// Example:
+    ///
+    /// ```
+    /// # use arrow_schema::*;
+    ///
+    /// let merged = Schema::try_merge(vec![
+    ///     Schema::new(vec![
+    ///         Field::new("c1", DataType::Int64, false),
+    ///         Field::new("c2", DataType::Utf8, false),
+    ///     ]),
+    ///     Schema::new(vec![
+    ///         Field::new("c1", DataType::Int64, true),
+    ///         Field::new("c2", DataType::Utf8, false),
+    ///         Field::new("c3", DataType::Utf8, false),
+    ///     ]),
+    /// ]).unwrap();
+    ///
+    /// assert_eq!(
+    ///     merged,
+    ///     Schema::new(vec![
+    ///         Field::new("c1", DataType::Int64, true),
+    ///         Field::new("c2", DataType::Utf8, false),
+    ///         Field::new("c3", DataType::Utf8, false),
+    ///     ]),
+    /// );
+    /// ```
+    pub fn try_merge(schemas: impl IntoIterator<Item = Self>) -> Result<Self, ArrowError> {
+        let mut out_meta = HashMap::new();
+        let mut out_fields = SchemaBuilder::new();
+        for schema in schemas {
+            let Schema { metadata, fields } = schema;
+
+            // merge metadata
+            for (key, value) in metadata.into_iter() {
+                if let Some(old_val) = out_meta.get(&key) {
+                    if old_val != &value {
+                        return Err(ArrowError::SchemaError(format!(
+                            "Fail to merge schema due to conflicting metadata. \
+                                         Key '{key}' has different values '{old_val}' and '{value}'"
+                        )));
+                    }
+                }
+                out_meta.insert(key, value);
+            }
+
+            // merge fields
+            fields.iter().try_for_each(|x| out_fields.try_merge(x))?
+        }
+
+        Ok(out_fields.finish().with_metadata(out_meta))
+    }
+
+    /// Returns an immutable reference of the vector of `Field` instances.
+    #[inline]
+    pub const fn fields(&self) -> &Fields {
+        &self.fields
+    }
+
+    /// Returns a vector with references to all fields (including nested fields)
+    #[inline]
+    pub fn all_fields(&self) -> Vec<&Field> {
+        self.fields.iter().flat_map(|f| f.fields()).collect()
+    }
+
+    /// Returns an immutable reference of a specific [`Field`] instance selected using an
+    /// offset within the internal `fields` vector.
+    pub fn field(&self, i: usize) -> &Field {
+        &self.fields[i]
+    }
+
+    /// Returns an immutable reference of a specific [`Field`] instance selected by name.
+    pub fn field_with_name(&self, name: &str) -> Result<&Field, ArrowError> {
+        Ok(&self.fields[self.index_of(name)?])
+    }
+
+    /// Returns a vector of immutable references to all [`Field`] instances selected by
+    /// the dictionary ID they use.
+    pub fn fields_with_dict_id(&self, dict_id: i64) -> Vec<&Field> {
+        self.fields
+            .iter()
+            .flat_map(|f| f.fields_with_dict_id(dict_id))
+            .collect()
+    }
+
+    /// Find the index of the column with the given name.
+    pub fn index_of(&self, name: &str) -> Result<usize, ArrowError> {
+        let (idx, _) = self.fields().find(name).ok_or_else(|| {
+            let valid_fields: Vec<_> = self.fields.iter().map(|f| f.name()).collect();
+            ArrowError::SchemaError(format!(
+                "Unable to get field named \"{name}\". Valid fields: {valid_fields:?}"
+            ))
+        })?;
+        Ok(idx)
+    }
+
+    /// Returns an immutable reference to the Map of custom metadata key-value pairs.
+    #[inline]
+    pub const fn metadata(&self) -> &HashMap<String, String> {
+        &self.metadata
+    }
+
+    /// Look up a column by name and return a immutable reference to the column along with
+    /// its index.
+    pub fn column_with_name(&self, name: &str) -> Option<(usize, &Field)> {
+        let (idx, field) = self.fields.find(name)?;
+        Some((idx, field.as_ref()))
+    }
+
+    /// Check to see if `self` is a superset of `other` schema.
+    ///
+    /// In particular returns true if `self.metadata` is a superset of `other.metadata`
+    /// and [`Fields::contains`] for `self.fields` and `other.fields`
+    ///
+    /// In other words, any record that conforms to `other` should also conform to `self`.
+    pub fn contains(&self, other: &Schema) -> bool {
+        // make sure self.metadata is a superset of other.metadata
+        self.fields.contains(&other.fields)
+            && other
+                .metadata
+                .iter()
+                .all(|(k, v1)| self.metadata.get(k).map(|v2| v1 == v2).unwrap_or_default())
+    }
+
+    /// Remove field by index and return it. Recommend to use [`SchemaBuilder`]
+    /// if you are looking to remove multiple columns, as this will save allocations.
+    ///
+    /// # Panic
+    ///
+    /// Panics if `index` is out of bounds.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// use arrow_schema::{DataType, Field, Schema};
+    /// let mut schema = Schema::new(vec![
+    ///   Field::new("a", DataType::Boolean, false),
+    ///   Field::new("b", DataType::Int8, false),
+    ///   Field::new("c", DataType::Utf8, false),
+    /// ]);
+    /// assert_eq!(schema.fields.len(), 3);
+    /// assert_eq!(schema.remove(1), Field::new("b", DataType::Int8, false).into());
+    /// assert_eq!(schema.fields.len(), 2);
+    /// ```
+    #[deprecated(note = "Use SchemaBuilder::remove")]
+    #[doc(hidden)]
+    #[allow(deprecated)]
+    pub fn remove(&mut self, index: usize) -> FieldRef {
+        self.fields.remove(index)
+    }
+}
+
+impl fmt::Display for Schema {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str(
+            &self
+                .fields
+                .iter()
+                .map(|c| c.to_string())
+                .collect::<Vec<String>>()
+                .join(", "),
+        )
+    }
+}
+
+// need to implement `Hash` manually because `HashMap` implement Eq but no `Hash`
+#[allow(clippy::derived_hash_with_manual_eq)]
+impl Hash for Schema {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.fields.hash(state);
+
+        // ensure deterministic key order
+        let mut keys: Vec<&String> = self.metadata.keys().collect();
+        keys.sort();
+        for k in keys {
+            k.hash(state);
+            self.metadata.get(k).expect("key valid").hash(state);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::datatype::DataType;
+    use crate::{TimeUnit, UnionMode};
+
+    use super::*;
+
+    #[test]
+    #[cfg(feature = "serde")]
+    fn test_ser_de_metadata() {
+        // ser/de with empty metadata
+        let schema = Schema::new(vec![
+            Field::new("name", DataType::Utf8, false),
+            Field::new("address", DataType::Utf8, false),
+            Field::new("priority", DataType::UInt8, false),
+        ]);
+
+        let json = serde_json::to_string(&schema).unwrap();
+        let de_schema = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(schema, de_schema);
+
+        // ser/de with non-empty metadata
+        let schema =
+            schema.with_metadata([("key".to_owned(), "val".to_owned())].into_iter().collect());
+        let json = serde_json::to_string(&schema).unwrap();
+        let de_schema = serde_json::from_str(&json).unwrap();
+
+        assert_eq!(schema, de_schema);
+    }
+
+    #[test]
+    fn test_projection() {
+        let mut metadata = HashMap::new();
+        metadata.insert("meta".to_string(), "data".to_string());
+
+        let schema = Schema::new(vec![
+            Field::new("name", DataType::Utf8, false),
+            Field::new("address", DataType::Utf8, false),
+            Field::new("priority", DataType::UInt8, false),
+        ])
+        .with_metadata(metadata);
+
+        let projected: Schema = schema.project(&[0, 2]).unwrap();
+
+        assert_eq!(projected.fields().len(), 2);
+        assert_eq!(projected.fields()[0].name(), "name");
+        assert_eq!(projected.fields()[1].name(), "priority");
+        assert_eq!(projected.metadata.get("meta").unwrap(), "data")
+    }
+
+    #[test]
+    fn test_oob_projection() {
+        let mut metadata = HashMap::new();
+        metadata.insert("meta".to_string(), "data".to_string());
+
+        let schema = Schema::new(vec![
+            Field::new("name", DataType::Utf8, false),
+            Field::new("address", DataType::Utf8, false),
+            Field::new("priority", DataType::UInt8, false),
+        ])
+        .with_metadata(metadata);
+
+        let projected = schema.project(&[0, 3]);
+
+        assert!(projected.is_err());
+        if let Err(e) = projected {
+            assert_eq!(
+                e.to_string(),
+                "Schema error: project index 3 out of bounds, max field 3".to_string()
+            )
+        }
+    }
+
+    #[test]
+    fn test_schema_contains() {
+        let mut metadata1 = HashMap::new();
+        metadata1.insert("meta".to_string(), "data".to_string());
+
+        let schema1 = Schema::new(vec![
+            Field::new("name", DataType::Utf8, false),
+            Field::new("address", DataType::Utf8, false),
+            Field::new("priority", DataType::UInt8, false),
+        ])
+        .with_metadata(metadata1.clone());
+
+        let mut metadata2 = HashMap::new();
+        metadata2.insert("meta".to_string(), "data".to_string());
+        metadata2.insert("meta2".to_string(), "data".to_string());
+        let schema2 = Schema::new(vec![
+            Field::new("name", DataType::Utf8, false),
+            Field::new("address", DataType::Utf8, false),
+            Field::new("priority", DataType::UInt8, false),
+        ])
+        .with_metadata(metadata2);
+
+        // reflexivity
+        assert!(schema1.contains(&schema1));
+        assert!(schema2.contains(&schema2));
+
+        assert!(!schema1.contains(&schema2));
+        assert!(schema2.contains(&schema1));
+    }
+
+    #[test]
+    fn schema_equality() {
+        let schema1 = Schema::new(vec![
+            Field::new("c1", DataType::Utf8, false),
+            Field::new("c2", DataType::Float64, true),
+            Field::new("c3", DataType::LargeBinary, true),
+        ]);
+        let schema2 = Schema::new(vec![
+            Field::new("c1", DataType::Utf8, false),
+            Field::new("c2", DataType::Float64, true),
+            Field::new("c3", DataType::LargeBinary, true),
+        ]);
+
+        assert_eq!(schema1, schema2);
+
+        let schema3 = Schema::new(vec![
+            Field::new("c1", DataType::Utf8, false),
+            Field::new("c2", DataType::Float32, true),
+        ]);
+        let schema4 = Schema::new(vec![
+            Field::new("C1", DataType::Utf8, false),
+            Field::new("C2", DataType::Float64, true),
+        ]);
+
+        assert_ne!(schema1, schema3);
+        assert_ne!(schema1, schema4);
+        assert_ne!(schema2, schema3);
+        assert_ne!(schema2, schema4);
+        assert_ne!(schema3, schema4);
+
+        let f = Field::new("c1", DataType::Utf8, false).with_metadata(
+            [("foo".to_string(), "bar".to_string())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+        let schema5 = Schema::new(vec![
+            f,
+            Field::new("c2", DataType::Float64, true),
+            Field::new("c3", DataType::LargeBinary, true),
+        ]);
+        assert_ne!(schema1, schema5);
+    }
+
+    #[test]
+    fn create_schema_string() {
+        let schema = person_schema();
+        assert_eq!(schema.to_string(),
+                   "Field { name: \"first_name\", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {\"k\": \"v\"} }, \
+        Field { name: \"last_name\", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, \
+        Field { name: \"address\", data_type: Struct([\
+            Field { name: \"street\", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, \
+            Field { name: \"zip\", data_type: UInt16, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }\
+        ]), nullable: false, dict_id: 0, dict_is_ordered: false, metadata: {} }, \
+        Field { name: \"interests\", data_type: Dictionary(Int32, Utf8), nullable: true, dict_id: 123, dict_is_ordered: true, metadata: {} }")
+    }
+
+    #[test]
+    fn schema_field_accessors() {
+        let schema = person_schema();
+
+        // test schema accessors
+        assert_eq!(schema.fields().len(), 4);
+
+        // test field accessors
+        let first_name = &schema.fields()[0];
+        assert_eq!(first_name.name(), "first_name");
+        assert_eq!(first_name.data_type(), &DataType::Utf8);
+        assert!(!first_name.is_nullable());
+        assert_eq!(first_name.dict_id(), None);
+        assert_eq!(first_name.dict_is_ordered(), None);
+
+        let metadata = first_name.metadata();
+        assert!(!metadata.is_empty());
+        let md = &metadata;
+        assert_eq!(md.len(), 1);
+        let key = md.get("k");
+        assert!(key.is_some());
+        assert_eq!(key.unwrap(), "v");
+
+        let interests = &schema.fields()[3];
+        assert_eq!(interests.name(), "interests");
+        assert_eq!(
+            interests.data_type(),
+            &DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8))
+        );
+        assert_eq!(interests.dict_id(), Some(123));
+        assert_eq!(interests.dict_is_ordered(), Some(true));
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Unable to get field named \\\"nickname\\\". Valid fields: [\\\"first_name\\\", \\\"last_name\\\", \\\"address\\\", \\\"interests\\\"]"
+    )]
+    fn schema_index_of() {
+        let schema = person_schema();
+        assert_eq!(schema.index_of("first_name").unwrap(), 0);
+        assert_eq!(schema.index_of("last_name").unwrap(), 1);
+        schema.index_of("nickname").unwrap();
+    }
+
+    #[test]
+    #[should_panic(
+        expected = "Unable to get field named \\\"nickname\\\". Valid fields: [\\\"first_name\\\", \\\"last_name\\\", \\\"address\\\", \\\"interests\\\"]"
+    )]
+    fn schema_field_with_name() {
+        let schema = person_schema();
+        assert_eq!(
+            schema.field_with_name("first_name").unwrap().name(),
+            "first_name"
+        );
+        assert_eq!(
+            schema.field_with_name("last_name").unwrap().name(),
+            "last_name"
+        );
+        schema.field_with_name("nickname").unwrap();
+    }
+
+    #[test]
+    fn schema_field_with_dict_id() {
+        let schema = person_schema();
+
+        let fields_dict_123: Vec<_> = schema
+            .fields_with_dict_id(123)
+            .iter()
+            .map(|f| f.name())
+            .collect();
+        assert_eq!(fields_dict_123, vec!["interests"]);
+
+        assert!(schema.fields_with_dict_id(456).is_empty());
+    }
+
+    fn person_schema() -> Schema {
+        let kv_array = [("k".to_string(), "v".to_string())];
+        let field_metadata: HashMap<String, String> = kv_array.iter().cloned().collect();
+        let first_name =
+            Field::new("first_name", DataType::Utf8, false).with_metadata(field_metadata);
+
+        Schema::new(vec![
+            first_name,
+            Field::new("last_name", DataType::Utf8, false),
+            Field::new(
+                "address",
+                DataType::Struct(Fields::from(vec![
+                    Field::new("street", DataType::Utf8, false),
+                    Field::new("zip", DataType::UInt16, false),
+                ])),
+                false,
+            ),
+            Field::new_dict(
+                "interests",
+                DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
+                true,
+                123,
+                true,
+            ),
+        ])
+    }
+
+    #[test]
+    fn test_try_merge_field_with_metadata() {
+        // 1. Different values for the same key should cause error.
+        let metadata1: HashMap<String, String> = [("foo".to_string(), "bar".to_string())]
+            .iter()
+            .cloned()
+            .collect();
+        let f1 = Field::new("first_name", DataType::Utf8, false).with_metadata(metadata1);
+
+        let metadata2: HashMap<String, String> = [("foo".to_string(), "baz".to_string())]
+            .iter()
+            .cloned()
+            .collect();
+        let f2 = Field::new("first_name", DataType::Utf8, false).with_metadata(metadata2);
+
+        assert!(Schema::try_merge(vec![Schema::new(vec![f1]), Schema::new(vec![f2])]).is_err());
+
+        // 2. None + Some
+        let mut f1 = Field::new("first_name", DataType::Utf8, false);
+        let metadata2: HashMap<String, String> = [("missing".to_string(), "value".to_string())]
+            .iter()
+            .cloned()
+            .collect();
+        let f2 = Field::new("first_name", DataType::Utf8, false).with_metadata(metadata2);
+
+        assert!(f1.try_merge(&f2).is_ok());
+        assert!(!f1.metadata().is_empty());
+        assert_eq!(f1.metadata(), f2.metadata());
+
+        // 3. Some + Some
+        let mut f1 = Field::new("first_name", DataType::Utf8, false).with_metadata(
+            [("foo".to_string(), "bar".to_string())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+        let f2 = Field::new("first_name", DataType::Utf8, false).with_metadata(
+            [("foo2".to_string(), "bar2".to_string())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+
+        assert!(f1.try_merge(&f2).is_ok());
+        assert!(!f1.metadata().is_empty());
+        assert_eq!(
+            f1.metadata().clone(),
+            [
+                ("foo".to_string(), "bar".to_string()),
+                ("foo2".to_string(), "bar2".to_string())
+            ]
+            .iter()
+            .cloned()
+            .collect()
+        );
+
+        // 4. Some + None.
+        let mut f1 = Field::new("first_name", DataType::Utf8, false).with_metadata(
+            [("foo".to_string(), "bar".to_string())]
+                .iter()
+                .cloned()
+                .collect(),
+        );
+        let f2 = Field::new("first_name", DataType::Utf8, false);
+        assert!(f1.try_merge(&f2).is_ok());
+        assert!(!f1.metadata().is_empty());
+        assert_eq!(
+            f1.metadata().clone(),
+            [("foo".to_string(), "bar".to_string())]
+                .iter()
+                .cloned()
+                .collect()
+        );
+
+        // 5. None + None.
+        let mut f1 = Field::new("first_name", DataType::Utf8, false);
+        let f2 = Field::new("first_name", DataType::Utf8, false);
+        assert!(f1.try_merge(&f2).is_ok());
+        assert!(f1.metadata().is_empty());
+    }
+
+    #[test]
+    fn test_schema_merge() {
+        let merged = Schema::try_merge(vec![
+            Schema::new(vec![
+                Field::new("first_name", DataType::Utf8, false),
+                Field::new("last_name", DataType::Utf8, false),
+                Field::new(
+                    "address",
+                    DataType::Struct(vec![Field::new("zip", DataType::UInt16, false)].into()),
+                    false,
+                ),
+            ]),
+            Schema::new_with_metadata(
+                vec![
+                    // nullable merge
+                    Field::new("last_name", DataType::Utf8, true),
+                    Field::new(
+                        "address",
+                        DataType::Struct(Fields::from(vec![
+                            // add new nested field
+                            Field::new("street", DataType::Utf8, false),
+                            // nullable merge on nested field
+                            Field::new("zip", DataType::UInt16, true),
+                        ])),
+                        false,
+                    ),
+                    // new field
+                    Field::new("number", DataType::Utf8, true),
+                ],
+                [("foo".to_string(), "bar".to_string())]
+                    .iter()
+                    .cloned()
+                    .collect::<HashMap<String, String>>(),
+            ),
+        ])
+        .unwrap();
+
+        assert_eq!(
+            merged,
+            Schema::new_with_metadata(
+                vec![
+                    Field::new("first_name", DataType::Utf8, false),
+                    Field::new("last_name", DataType::Utf8, true),
+                    Field::new(
+                        "address",
+                        DataType::Struct(Fields::from(vec![
+                            Field::new("zip", DataType::UInt16, true),
+                            Field::new("street", DataType::Utf8, false),
+                        ])),
+                        false,
+                    ),
+                    Field::new("number", DataType::Utf8, true),
+                ],
+                [("foo".to_string(), "bar".to_string())]
+                    .iter()
+                    .cloned()
+                    .collect::<HashMap<String, String>>()
+            )
+        );
+
+        // support merge union fields
+        assert_eq!(
+            Schema::try_merge(vec![
+                Schema::new(vec![Field::new_union(
+                    "c1",
+                    vec![0, 1],
+                    vec![
+                        Field::new("c11", DataType::Utf8, true),
+                        Field::new("c12", DataType::Utf8, true),
+                    ],
+                    UnionMode::Dense
+                ),]),
+                Schema::new(vec![Field::new_union(
+                    "c1",
+                    vec![1, 2],
+                    vec![
+                        Field::new("c12", DataType::Utf8, true),
+                        Field::new("c13", DataType::Time64(TimeUnit::Second), true),
+                    ],
+                    UnionMode::Dense
+                ),])
+            ])
+            .unwrap(),
+            Schema::new(vec![Field::new_union(
+                "c1",
+                vec![0, 1, 2],
+                vec![
+                    Field::new("c11", DataType::Utf8, true),
+                    Field::new("c12", DataType::Utf8, true),
+                    Field::new("c13", DataType::Time64(TimeUnit::Second), true),
+                ],
+                UnionMode::Dense
+            ),]),
+        );
+
+        // incompatible field should throw error
+        assert!(Schema::try_merge(vec![
+            Schema::new(vec![
+                Field::new("first_name", DataType::Utf8, false),
+                Field::new("last_name", DataType::Utf8, false),
+            ]),
+            Schema::new(vec![Field::new("last_name", DataType::Int64, false),])
+        ])
+        .is_err());
+
+        // incompatible metadata should throw error
+        let res = Schema::try_merge(vec![
+            Schema::new_with_metadata(
+                vec![Field::new("first_name", DataType::Utf8, false)],
+                [("foo".to_string(), "bar".to_string())]
+                    .iter()
+                    .cloned()
+                    .collect::<HashMap<String, String>>(),
+            ),
+            Schema::new_with_metadata(
+                vec![Field::new("last_name", DataType::Utf8, false)],
+                [("foo".to_string(), "baz".to_string())]
+                    .iter()
+                    .cloned()
+                    .collect::<HashMap<String, String>>(),
+            ),
+        ])
+        .unwrap_err();
+
+        let expected = "Fail to merge schema due to conflicting metadata. Key 'foo' has different values 'bar' and 'baz'";
+        assert!(
+            res.to_string().contains(expected),
+            "Could not find expected string '{expected}' in '{res}'"
+        );
+    }
+
+    #[test]
+    fn test_schema_builder_change_field() {
+        let mut builder = SchemaBuilder::new();
+        builder.push(Field::new("a", DataType::Int32, false));
+        builder.push(Field::new("b", DataType::Utf8, false));
+        *builder.field_mut(1) = Arc::new(Field::new("c", DataType::Int32, false));
+        assert_eq!(
+            builder.fields,
+            vec![
+                Arc::new(Field::new("a", DataType::Int32, false)),
+                Arc::new(Field::new("c", DataType::Int32, false))
+            ]
+        );
+    }
+
+    #[test]
+    fn test_schema_builder_reverse() {
+        let mut builder = SchemaBuilder::new();
+        builder.push(Field::new("a", DataType::Int32, false));
+        builder.push(Field::new("b", DataType::Utf8, true));
+        builder.reverse();
+        assert_eq!(
+            builder.fields,
+            vec![
+                Arc::new(Field::new("b", DataType::Utf8, true)),
+                Arc::new(Field::new("a", DataType::Int32, false))
+            ]
+        );
+    }
+
+    #[test]
+    fn test_schema_builder_metadata() {
+        let mut metadata = HashMap::with_capacity(1);
+        metadata.insert("key".to_string(), "value".to_string());
+
+        let fields = vec![Field::new("test", DataType::Int8, true)];
+        let mut builder: SchemaBuilder = Schema::new(fields).with_metadata(metadata).into();
+        builder.metadata_mut().insert("k".into(), "v".into());
+        let out = builder.finish();
+        assert_eq!(out.metadata.len(), 2);
+        assert_eq!(out.metadata["k"], "v");
+        assert_eq!(out.metadata["key"], "value");
+    }
+}
diff --git a/arrow-select/Cargo.toml b/arrow-select/Cargo.toml
new file mode 100644
index 000000000000..023788799c94
--- /dev/null
+++ b/arrow-select/Cargo.toml
@@ -0,0 +1,48 @@
+# 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]
+name = "arrow-select"
+version = { workspace = true }
+description = "Selection kernels for arrow arrays"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_select"
+path = "src/lib.rs"
+bench = false
+
+[dependencies]
+arrow-buffer = { workspace = true }
+arrow-data = { workspace = true }
+arrow-schema = { workspace = true }
+arrow-array = { workspace = true }
+num = { version = "0.4", default-features = false, features = ["std"] }
+ahash = { version = "0.8", default-features = false}
+
+[features]
+default = []
+
+[dev-dependencies]
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
diff --git a/arrow-select/src/concat.rs b/arrow-select/src/concat.rs
new file mode 100644
index 000000000000..04e3ab2f7424
--- /dev/null
+++ b/arrow-select/src/concat.rs
@@ -0,0 +1,789 @@
+// 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.
+
+//! Defines concat kernel for `ArrayRef`
+//!
+//! Example:
+//!
+//! ```
+//! use arrow_array::{ArrayRef, StringArray};
+//! use arrow_select::concat::concat;
+//!
+//! let arr = concat(&[
+//!     &StringArray::from(vec!["hello", "world"]),
+//!     &StringArray::from(vec!["!"]),
+//! ]).unwrap();
+//! assert_eq!(arr.len(), 3);
+//! ```
+
+use crate::dictionary::{merge_dictionary_values, should_merge_dictionary_values};
+use arrow_array::cast::AsArray;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::{ArrowNativeType, BooleanBufferBuilder, NullBuffer};
+use arrow_data::transform::{Capacities, MutableArrayData};
+use arrow_schema::{ArrowError, DataType, SchemaRef};
+use std::sync::Arc;
+
+fn binary_capacity<T: ByteArrayType>(arrays: &[&dyn Array]) -> Capacities {
+    let mut item_capacity = 0;
+    let mut bytes_capacity = 0;
+    for array in arrays {
+        let a = array.as_bytes::<T>();
+
+        // Guaranteed to always have at least one element
+        let offsets = a.value_offsets();
+        bytes_capacity += offsets[offsets.len() - 1].as_usize() - offsets[0].as_usize();
+        item_capacity += a.len()
+    }
+
+    Capacities::Binary(item_capacity, Some(bytes_capacity))
+}
+
+fn concat_dictionaries<K: ArrowDictionaryKeyType>(
+    arrays: &[&dyn Array],
+) -> Result<ArrayRef, ArrowError> {
+    let mut output_len = 0;
+    let dictionaries: Vec<_> = arrays
+        .iter()
+        .map(|x| x.as_dictionary::<K>())
+        .inspect(|d| output_len += d.len())
+        .collect();
+
+    if !should_merge_dictionary_values::<K>(&dictionaries, output_len) {
+        return concat_fallback(arrays, Capacities::Array(output_len));
+    }
+
+    let merged = merge_dictionary_values(&dictionaries, None)?;
+
+    // Recompute keys
+    let mut key_values = Vec::with_capacity(output_len);
+
+    let mut has_nulls = false;
+    for (d, mapping) in dictionaries.iter().zip(merged.key_mappings) {
+        has_nulls |= d.null_count() != 0;
+        for key in d.keys().values() {
+            // Use get to safely handle nulls
+            key_values.push(mapping.get(key.as_usize()).copied().unwrap_or_default())
+        }
+    }
+
+    let nulls = has_nulls.then(|| {
+        let mut nulls = BooleanBufferBuilder::new(output_len);
+        for d in &dictionaries {
+            match d.nulls() {
+                Some(n) => nulls.append_buffer(n.inner()),
+                None => nulls.append_n(d.len(), true),
+            }
+        }
+        NullBuffer::new(nulls.finish())
+    });
+
+    let keys = PrimitiveArray::<K>::new(key_values.into(), nulls);
+    // Sanity check
+    assert_eq!(keys.len(), output_len);
+
+    let array = unsafe { DictionaryArray::new_unchecked(keys, merged.values) };
+    Ok(Arc::new(array))
+}
+
+macro_rules! dict_helper {
+    ($t:ty, $arrays:expr) => {
+        return Ok(Arc::new(concat_dictionaries::<$t>($arrays)?) as _)
+    };
+}
+
+/// Concatenate multiple [Array] of the same type into a single [ArrayRef].
+pub fn concat(arrays: &[&dyn Array]) -> Result<ArrayRef, ArrowError> {
+    if arrays.is_empty() {
+        return Err(ArrowError::ComputeError(
+            "concat requires input of at least one array".to_string(),
+        ));
+    } else if arrays.len() == 1 {
+        let array = arrays[0];
+        return Ok(array.slice(0, array.len()));
+    }
+
+    let d = arrays[0].data_type();
+    if arrays.iter().skip(1).any(|array| array.data_type() != d) {
+        return Err(ArrowError::InvalidArgumentError(
+            "It is not possible to concatenate arrays of different data types.".to_string(),
+        ));
+    }
+
+    let capacity = match d {
+        DataType::Utf8 => binary_capacity::<Utf8Type>(arrays),
+        DataType::LargeUtf8 => binary_capacity::<LargeUtf8Type>(arrays),
+        DataType::Binary => binary_capacity::<BinaryType>(arrays),
+        DataType::LargeBinary => binary_capacity::<LargeBinaryType>(arrays),
+        DataType::Dictionary(k, _) => downcast_integer! {
+            k.as_ref() => (dict_helper, arrays),
+            _ => unreachable!("illegal dictionary key type {k}")
+        },
+        _ => Capacities::Array(arrays.iter().map(|a| a.len()).sum()),
+    };
+
+    concat_fallback(arrays, capacity)
+}
+
+/// Concatenates arrays using MutableArrayData
+///
+/// This will naively concatenate dictionaries
+fn concat_fallback(arrays: &[&dyn Array], capacity: Capacities) -> Result<ArrayRef, ArrowError> {
+    let array_data: Vec<_> = arrays.iter().map(|a| a.to_data()).collect::<Vec<_>>();
+    let array_data = array_data.iter().collect();
+    let mut mutable = MutableArrayData::with_capacities(array_data, false, capacity);
+
+    for (i, a) in arrays.iter().enumerate() {
+        mutable.extend(i, 0, a.len())
+    }
+
+    Ok(make_array(mutable.freeze()))
+}
+
+/// Concatenates `batches` together into a single [`RecordBatch`].
+///
+/// The output batch has the specified `schemas`; The schema of the
+/// input are ignored.
+///
+/// Returns an error if the types of underlying arrays are different.
+pub fn concat_batches<'a>(
+    schema: &SchemaRef,
+    input_batches: impl IntoIterator<Item = &'a RecordBatch>,
+) -> Result<RecordBatch, ArrowError> {
+    // When schema is empty, sum the number of the rows of all batches
+    if schema.fields().is_empty() {
+        let num_rows: usize = input_batches.into_iter().map(RecordBatch::num_rows).sum();
+        let mut options = RecordBatchOptions::default();
+        options.row_count = Some(num_rows);
+        return RecordBatch::try_new_with_options(schema.clone(), vec![], &options);
+    }
+
+    let batches: Vec<&RecordBatch> = input_batches.into_iter().collect();
+    if batches.is_empty() {
+        return Ok(RecordBatch::new_empty(schema.clone()));
+    }
+    let field_num = schema.fields().len();
+    let mut arrays = Vec::with_capacity(field_num);
+    for i in 0..field_num {
+        let array = concat(
+            &batches
+                .iter()
+                .map(|batch| batch.column(i).as_ref())
+                .collect::<Vec<_>>(),
+        )?;
+        arrays.push(array);
+    }
+    RecordBatch::try_new(schema.clone(), arrays)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::builder::StringDictionaryBuilder;
+    use arrow_array::cast::AsArray;
+    use arrow_schema::{Field, Schema};
+    use std::sync::Arc;
+
+    #[test]
+    fn test_concat_empty_vec() {
+        let re = concat(&[]);
+        assert!(re.is_err());
+    }
+
+    #[test]
+    fn test_concat_batches_no_columns() {
+        // Test concat using empty schema / batches without columns
+        let schema = Arc::new(Schema::empty());
+
+        let mut options = RecordBatchOptions::default();
+        options.row_count = Some(100);
+        let batch = RecordBatch::try_new_with_options(schema.clone(), vec![], &options).unwrap();
+        // put in 2 batches of 100 rows each
+        let re = concat_batches(&schema, &[batch.clone(), batch]).unwrap();
+
+        assert_eq!(re.num_rows(), 200);
+    }
+
+    #[test]
+    fn test_concat_one_element_vec() {
+        let arr = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
+            Some(-1),
+            Some(2),
+            None,
+        ])) as ArrayRef;
+        let result = concat(&[arr.as_ref()]).unwrap();
+        assert_eq!(
+            &arr, &result,
+            "concatenating single element array gives back the same result"
+        );
+    }
+
+    #[test]
+    fn test_concat_incompatible_datatypes() {
+        let re = concat(&[
+            &PrimitiveArray::<Int64Type>::from(vec![Some(-1), Some(2), None]),
+            &StringArray::from(vec![Some("hello"), Some("bar"), Some("world")]),
+        ]);
+        assert!(re.is_err());
+    }
+
+    #[test]
+    fn test_concat_string_arrays() {
+        let arr = concat(&[
+            &StringArray::from(vec!["hello", "world"]),
+            &StringArray::from(vec!["2", "3", "4"]),
+            &StringArray::from(vec![Some("foo"), Some("bar"), None, Some("baz")]),
+        ])
+        .unwrap();
+
+        let expected_output = Arc::new(StringArray::from(vec![
+            Some("hello"),
+            Some("world"),
+            Some("2"),
+            Some("3"),
+            Some("4"),
+            Some("foo"),
+            Some("bar"),
+            None,
+            Some("baz"),
+        ])) as ArrayRef;
+
+        assert_eq!(&arr, &expected_output);
+    }
+
+    #[test]
+    fn test_concat_primitive_arrays() {
+        let arr = concat(&[
+            &PrimitiveArray::<Int64Type>::from(vec![Some(-1), Some(-1), Some(2), None, None]),
+            &PrimitiveArray::<Int64Type>::from(vec![Some(101), Some(102), Some(103), None]),
+            &PrimitiveArray::<Int64Type>::from(vec![Some(256), Some(512), Some(1024)]),
+        ])
+        .unwrap();
+
+        let expected_output = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
+            Some(-1),
+            Some(-1),
+            Some(2),
+            None,
+            None,
+            Some(101),
+            Some(102),
+            Some(103),
+            None,
+            Some(256),
+            Some(512),
+            Some(1024),
+        ])) as ArrayRef;
+
+        assert_eq!(&arr, &expected_output);
+    }
+
+    #[test]
+    fn test_concat_primitive_array_slices() {
+        let input_1 =
+            PrimitiveArray::<Int64Type>::from(vec![Some(-1), Some(-1), Some(2), None, None])
+                .slice(1, 3);
+
+        let input_2 =
+            PrimitiveArray::<Int64Type>::from(vec![Some(101), Some(102), Some(103), None])
+                .slice(1, 3);
+        let arr = concat(&[&input_1, &input_2]).unwrap();
+
+        let expected_output = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
+            Some(-1),
+            Some(2),
+            None,
+            Some(102),
+            Some(103),
+            None,
+        ])) as ArrayRef;
+
+        assert_eq!(&arr, &expected_output);
+    }
+
+    #[test]
+    fn test_concat_boolean_primitive_arrays() {
+        let arr = concat(&[
+            &BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(false),
+                None,
+                None,
+                Some(false),
+            ]),
+            &BooleanArray::from(vec![None, Some(false), Some(true), Some(false)]),
+        ])
+        .unwrap();
+
+        let expected_output = Arc::new(BooleanArray::from(vec![
+            Some(true),
+            Some(true),
+            Some(false),
+            None,
+            None,
+            Some(false),
+            None,
+            Some(false),
+            Some(true),
+            Some(false),
+        ])) as ArrayRef;
+
+        assert_eq!(&arr, &expected_output);
+    }
+
+    #[test]
+    fn test_concat_primitive_list_arrays() {
+        let list1 = vec![
+            Some(vec![Some(-1), Some(-1), Some(2), None, None]),
+            Some(vec![]),
+            None,
+            Some(vec![Some(10)]),
+        ];
+        let list1_array = ListArray::from_iter_primitive::<Int64Type, _, _>(list1.clone());
+
+        let list2 = vec![
+            None,
+            Some(vec![Some(100), None, Some(101)]),
+            Some(vec![Some(102)]),
+        ];
+        let list2_array = ListArray::from_iter_primitive::<Int64Type, _, _>(list2.clone());
+
+        let list3 = vec![Some(vec![Some(1000), Some(1001)])];
+        let list3_array = ListArray::from_iter_primitive::<Int64Type, _, _>(list3.clone());
+
+        let array_result = concat(&[&list1_array, &list2_array, &list3_array]).unwrap();
+
+        let expected = list1.into_iter().chain(list2).chain(list3);
+        let array_expected = ListArray::from_iter_primitive::<Int64Type, _, _>(expected);
+
+        assert_eq!(array_result.as_ref(), &array_expected as &dyn Array);
+    }
+
+    #[test]
+    fn test_concat_struct_arrays() {
+        let field = Arc::new(Field::new("field", DataType::Int64, true));
+        let input_primitive_1: ArrayRef = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
+            Some(-1),
+            Some(-1),
+            Some(2),
+            None,
+            None,
+        ]));
+        let input_struct_1 = StructArray::from(vec![(field.clone(), input_primitive_1)]);
+
+        let input_primitive_2: ArrayRef = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
+            Some(101),
+            Some(102),
+            Some(103),
+            None,
+        ]));
+        let input_struct_2 = StructArray::from(vec![(field.clone(), input_primitive_2)]);
+
+        let input_primitive_3: ArrayRef = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
+            Some(256),
+            Some(512),
+            Some(1024),
+        ]));
+        let input_struct_3 = StructArray::from(vec![(field, input_primitive_3)]);
+
+        let arr = concat(&[&input_struct_1, &input_struct_2, &input_struct_3]).unwrap();
+
+        let expected_primitive_output = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
+            Some(-1),
+            Some(-1),
+            Some(2),
+            None,
+            None,
+            Some(101),
+            Some(102),
+            Some(103),
+            None,
+            Some(256),
+            Some(512),
+            Some(1024),
+        ])) as ArrayRef;
+
+        let actual_primitive = arr
+            .as_any()
+            .downcast_ref::<StructArray>()
+            .unwrap()
+            .column(0);
+        assert_eq!(actual_primitive, &expected_primitive_output);
+    }
+
+    #[test]
+    fn test_concat_struct_array_slices() {
+        let field = Arc::new(Field::new("field", DataType::Int64, true));
+        let input_primitive_1: ArrayRef = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
+            Some(-1),
+            Some(-1),
+            Some(2),
+            None,
+            None,
+        ]));
+        let input_struct_1 = StructArray::from(vec![(field.clone(), input_primitive_1)]);
+
+        let input_primitive_2: ArrayRef = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
+            Some(101),
+            Some(102),
+            Some(103),
+            None,
+        ]));
+        let input_struct_2 = StructArray::from(vec![(field, input_primitive_2)]);
+
+        let arr = concat(&[&input_struct_1.slice(1, 3), &input_struct_2.slice(1, 2)]).unwrap();
+
+        let expected_primitive_output = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
+            Some(-1),
+            Some(2),
+            None,
+            Some(102),
+            Some(103),
+        ])) as ArrayRef;
+
+        let actual_primitive = arr
+            .as_any()
+            .downcast_ref::<StructArray>()
+            .unwrap()
+            .column(0);
+        assert_eq!(actual_primitive, &expected_primitive_output);
+    }
+
+    #[test]
+    fn test_string_array_slices() {
+        let input_1 = StringArray::from(vec!["hello", "A", "B", "C"]);
+        let input_2 = StringArray::from(vec!["world", "D", "E", "Z"]);
+
+        let arr = concat(&[&input_1.slice(1, 3), &input_2.slice(1, 2)]).unwrap();
+
+        let expected_output = StringArray::from(vec!["A", "B", "C", "D", "E"]);
+
+        let actual_output = arr.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(actual_output, &expected_output);
+    }
+
+    #[test]
+    fn test_string_array_with_null_slices() {
+        let input_1 = StringArray::from(vec![Some("hello"), None, Some("A"), Some("C")]);
+        let input_2 = StringArray::from(vec![None, Some("world"), Some("D"), None]);
+
+        let arr = concat(&[&input_1.slice(1, 3), &input_2.slice(1, 2)]).unwrap();
+
+        let expected_output =
+            StringArray::from(vec![None, Some("A"), Some("C"), Some("world"), Some("D")]);
+
+        let actual_output = arr.as_any().downcast_ref::<StringArray>().unwrap();
+        assert_eq!(actual_output, &expected_output);
+    }
+
+    fn collect_string_dictionary(array: &DictionaryArray<Int32Type>) -> Vec<Option<&str>> {
+        let concrete = array.downcast_dict::<StringArray>().unwrap();
+        concrete.into_iter().collect()
+    }
+
+    #[test]
+    fn test_string_dictionary_array() {
+        let input_1: DictionaryArray<Int32Type> = vec!["hello", "A", "B", "hello", "hello", "C"]
+            .into_iter()
+            .collect();
+        let input_2: DictionaryArray<Int32Type> = vec!["hello", "E", "E", "hello", "F", "E"]
+            .into_iter()
+            .collect();
+
+        let expected: Vec<_> = vec![
+            "hello", "A", "B", "hello", "hello", "C", "hello", "E", "E", "hello", "F", "E",
+        ]
+        .into_iter()
+        .map(Some)
+        .collect();
+
+        let concat = concat(&[&input_1 as _, &input_2 as _]).unwrap();
+        let dictionary = concat.as_dictionary::<Int32Type>();
+        let actual = collect_string_dictionary(dictionary);
+        assert_eq!(actual, expected);
+
+        // Should have concatenated inputs together
+        assert_eq!(
+            dictionary.values().len(),
+            input_1.values().len() + input_2.values().len(),
+        )
+    }
+
+    #[test]
+    fn test_string_dictionary_array_nulls() {
+        let input_1: DictionaryArray<Int32Type> = vec![Some("foo"), Some("bar"), None, Some("fiz")]
+            .into_iter()
+            .collect();
+        let input_2: DictionaryArray<Int32Type> = vec![None].into_iter().collect();
+        let expected = vec![Some("foo"), Some("bar"), None, Some("fiz"), None];
+
+        let concat = concat(&[&input_1 as _, &input_2 as _]).unwrap();
+        let dictionary = concat.as_dictionary::<Int32Type>();
+        let actual = collect_string_dictionary(dictionary);
+        assert_eq!(actual, expected);
+
+        // Should have concatenated inputs together
+        assert_eq!(
+            dictionary.values().len(),
+            input_1.values().len() + input_2.values().len(),
+        )
+    }
+
+    #[test]
+    fn test_string_dictionary_merge() {
+        let mut builder = StringDictionaryBuilder::<Int32Type>::new();
+        for i in 0..20 {
+            builder.append(&i.to_string()).unwrap();
+        }
+        let input_1 = builder.finish();
+
+        let mut builder = StringDictionaryBuilder::<Int32Type>::new();
+        for i in 0..30 {
+            builder.append(&i.to_string()).unwrap();
+        }
+        let input_2 = builder.finish();
+
+        let expected: Vec<_> = (0..20).chain(0..30).map(|x| x.to_string()).collect();
+        let expected: Vec<_> = expected.iter().map(|x| Some(x.as_str())).collect();
+
+        let concat = concat(&[&input_1 as _, &input_2 as _]).unwrap();
+        let dictionary = concat.as_dictionary::<Int32Type>();
+        let actual = collect_string_dictionary(dictionary);
+        assert_eq!(actual, expected);
+
+        // Should have merged inputs together
+        // Not 30 as this is done on a best-effort basis
+        assert_eq!(dictionary.values().len(), 33)
+    }
+
+    #[test]
+    fn test_concat_string_sizes() {
+        let a: LargeStringArray = ((0..150).map(|_| Some("foo"))).collect();
+        let b: LargeStringArray = ((0..150).map(|_| Some("foo"))).collect();
+        let c = LargeStringArray::from(vec![Some("foo"), Some("bar"), None, Some("baz")]);
+        // 150 * 3 = 450
+        // 150 * 3 = 450
+        // 3 * 3   = 9
+        // ------------+
+        // 909
+        // closest 64 byte aligned cap = 960
+
+        let arr = concat(&[&a, &b, &c]).unwrap();
+        // this would have been 1280 if we did not precompute the value lengths.
+        assert_eq!(arr.to_data().buffers()[1].capacity(), 960);
+    }
+
+    #[test]
+    fn test_dictionary_concat_reuse() {
+        let array: DictionaryArray<Int8Type> = vec!["a", "a", "b", "c"].into_iter().collect();
+        let copy: DictionaryArray<Int8Type> = array.clone();
+
+        // dictionary is "a", "b", "c"
+        assert_eq!(
+            array.values(),
+            &(Arc::new(StringArray::from(vec!["a", "b", "c"])) as ArrayRef)
+        );
+        assert_eq!(array.keys(), &Int8Array::from(vec![0, 0, 1, 2]));
+
+        // concatenate it with itself
+        let combined = concat(&[&copy as _, &array as _]).unwrap();
+        let combined = combined.as_dictionary::<Int8Type>();
+
+        assert_eq!(
+            combined.values(),
+            &(Arc::new(StringArray::from(vec!["a", "b", "c"])) as ArrayRef),
+            "Actual: {combined:#?}"
+        );
+
+        assert_eq!(
+            combined.keys(),
+            &Int8Array::from(vec![0, 0, 1, 2, 0, 0, 1, 2])
+        );
+
+        // Should have reused the dictionary
+        assert!(array
+            .values()
+            .to_data()
+            .ptr_eq(&combined.values().to_data()));
+        assert!(copy.values().to_data().ptr_eq(&combined.values().to_data()));
+
+        let new: DictionaryArray<Int8Type> = vec!["d"].into_iter().collect();
+        let combined = concat(&[&copy as _, &array as _, &new as _]).unwrap();
+        let com = combined.as_dictionary::<Int8Type>();
+
+        // Should not have reused the dictionary
+        assert!(!array.values().to_data().ptr_eq(&com.values().to_data()));
+        assert!(!copy.values().to_data().ptr_eq(&com.values().to_data()));
+        assert!(!new.values().to_data().ptr_eq(&com.values().to_data()));
+    }
+
+    #[test]
+    fn concat_record_batches() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Int32, false),
+            Field::new("b", DataType::Utf8, false),
+        ]));
+        let batch1 = RecordBatch::try_new(
+            schema.clone(),
+            vec![
+                Arc::new(Int32Array::from(vec![1, 2])),
+                Arc::new(StringArray::from(vec!["a", "b"])),
+            ],
+        )
+        .unwrap();
+        let batch2 = RecordBatch::try_new(
+            schema.clone(),
+            vec![
+                Arc::new(Int32Array::from(vec![3, 4])),
+                Arc::new(StringArray::from(vec!["c", "d"])),
+            ],
+        )
+        .unwrap();
+        let new_batch = concat_batches(&schema, [&batch1, &batch2]).unwrap();
+        assert_eq!(new_batch.schema().as_ref(), schema.as_ref());
+        assert_eq!(2, new_batch.num_columns());
+        assert_eq!(4, new_batch.num_rows());
+        let new_batch_owned = concat_batches(&schema, &[batch1, batch2]).unwrap();
+        assert_eq!(new_batch_owned.schema().as_ref(), schema.as_ref());
+        assert_eq!(2, new_batch_owned.num_columns());
+        assert_eq!(4, new_batch_owned.num_rows());
+    }
+
+    #[test]
+    fn concat_empty_record_batch() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("a", DataType::Int32, false),
+            Field::new("b", DataType::Utf8, false),
+        ]));
+        let batch = concat_batches(&schema, []).unwrap();
+        assert_eq!(batch.schema().as_ref(), schema.as_ref());
+        assert_eq!(0, batch.num_rows());
+    }
+
+    #[test]
+    fn concat_record_batches_of_different_schemas_but_compatible_data() {
+        let schema1 = Arc::new(Schema::new(vec![Field::new("a", DataType::Int32, false)]));
+        // column names differ
+        let schema2 = Arc::new(Schema::new(vec![Field::new("c", DataType::Int32, false)]));
+        let batch1 = RecordBatch::try_new(
+            schema1.clone(),
+            vec![Arc::new(Int32Array::from(vec![1, 2]))],
+        )
+        .unwrap();
+        let batch2 =
+            RecordBatch::try_new(schema2, vec![Arc::new(Int32Array::from(vec![3, 4]))]).unwrap();
+        // concat_batches simply uses the schema provided
+        let batch = concat_batches(&schema1, [&batch1, &batch2]).unwrap();
+        assert_eq!(batch.schema().as_ref(), schema1.as_ref());
+        assert_eq!(4, batch.num_rows());
+    }
+
+    #[test]
+    fn concat_record_batches_of_different_schemas_incompatible_data() {
+        let schema1 = Arc::new(Schema::new(vec![Field::new("a", DataType::Int32, false)]));
+        // column names differ
+        let schema2 = Arc::new(Schema::new(vec![Field::new("a", DataType::Utf8, false)]));
+        let batch1 = RecordBatch::try_new(
+            schema1.clone(),
+            vec![Arc::new(Int32Array::from(vec![1, 2]))],
+        )
+        .unwrap();
+        let batch2 = RecordBatch::try_new(
+            schema2,
+            vec![Arc::new(StringArray::from(vec!["foo", "bar"]))],
+        )
+        .unwrap();
+
+        let error = concat_batches(&schema1, [&batch1, &batch2]).unwrap_err();
+        assert_eq!(error.to_string(), "Invalid argument error: It is not possible to concatenate arrays of different data types.");
+    }
+
+    #[test]
+    fn concat_capacity() {
+        let a = Int32Array::from_iter_values(0..100);
+        let b = Int32Array::from_iter_values(10..20);
+        let a = concat(&[&a, &b]).unwrap();
+        let data = a.to_data();
+        assert_eq!(data.buffers()[0].len(), 440);
+        assert_eq!(data.buffers()[0].capacity(), 448); // Nearest multiple of 64
+
+        let a = concat(&[&a.slice(10, 20), &b]).unwrap();
+        let data = a.to_data();
+        assert_eq!(data.buffers()[0].len(), 120);
+        assert_eq!(data.buffers()[0].capacity(), 128); // Nearest multiple of 64
+
+        let a = StringArray::from_iter_values(std::iter::repeat("foo").take(100));
+        let b = StringArray::from(vec!["bingo", "bongo", "lorem", ""]);
+
+        let a = concat(&[&a, &b]).unwrap();
+        let data = a.to_data();
+        // (100 + 4 + 1) * size_of<i32>()
+        assert_eq!(data.buffers()[0].len(), 420);
+        assert_eq!(data.buffers()[0].capacity(), 448); // Nearest multiple of 64
+
+        // len("foo") * 100 + len("bingo") + len("bongo") + len("lorem")
+        assert_eq!(data.buffers()[1].len(), 315);
+        assert_eq!(data.buffers()[1].capacity(), 320); // Nearest multiple of 64
+
+        let a = concat(&[&a.slice(10, 40), &b]).unwrap();
+        let data = a.to_data();
+        // (40 + 4 + 5) * size_of<i32>()
+        assert_eq!(data.buffers()[0].len(), 180);
+        assert_eq!(data.buffers()[0].capacity(), 192); // Nearest multiple of 64
+
+        // len("foo") * 40 + len("bingo") + len("bongo") + len("lorem")
+        assert_eq!(data.buffers()[1].len(), 135);
+        assert_eq!(data.buffers()[1].capacity(), 192); // Nearest multiple of 64
+
+        let a = LargeBinaryArray::from_iter_values(std::iter::repeat(b"foo").take(100));
+        let b = LargeBinaryArray::from_iter_values(std::iter::repeat(b"cupcakes").take(10));
+
+        let a = concat(&[&a, &b]).unwrap();
+        let data = a.to_data();
+        // (100 + 10 + 1) * size_of<i64>()
+        assert_eq!(data.buffers()[0].len(), 888);
+        assert_eq!(data.buffers()[0].capacity(), 896); // Nearest multiple of 64
+
+        // len("foo") * 100 + len("cupcakes") * 10
+        assert_eq!(data.buffers()[1].len(), 380);
+        assert_eq!(data.buffers()[1].capacity(), 384); // Nearest multiple of 64
+
+        let a = concat(&[&a.slice(10, 40), &b]).unwrap();
+        let data = a.to_data();
+        // (40 + 10 + 1) * size_of<i64>()
+        assert_eq!(data.buffers()[0].len(), 408);
+        assert_eq!(data.buffers()[0].capacity(), 448); // Nearest multiple of 64
+
+        // len("foo") * 40 + len("cupcakes") * 10
+        assert_eq!(data.buffers()[1].len(), 200);
+        assert_eq!(data.buffers()[1].capacity(), 256); // Nearest multiple of 64
+    }
+
+    #[test]
+    fn concat_sparse_nulls() {
+        let values = StringArray::from_iter_values((0..100).map(|x| x.to_string()));
+        let keys = Int32Array::from(vec![1; 10]);
+        let dict_a = DictionaryArray::new(keys, Arc::new(values));
+        let values = StringArray::new_null(0);
+        let keys = Int32Array::new_null(10);
+        let dict_b = DictionaryArray::new(keys, Arc::new(values));
+        let array = concat(&[&dict_a, &dict_b]).unwrap();
+        assert_eq!(array.null_count(), 10);
+    }
+}
diff --git a/arrow-select/src/dictionary.rs b/arrow-select/src/dictionary.rs
new file mode 100644
index 000000000000..d0b6fcfc3ac9
--- /dev/null
+++ b/arrow-select/src/dictionary.rs
@@ -0,0 +1,331 @@
+// 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.
+
+use crate::interleave::interleave;
+use ahash::RandomState;
+use arrow_array::builder::BooleanBufferBuilder;
+use arrow_array::cast::AsArray;
+use arrow_array::types::{
+    ArrowDictionaryKeyType, BinaryType, ByteArrayType, LargeBinaryType, LargeUtf8Type, Utf8Type,
+};
+use arrow_array::{Array, ArrayRef, DictionaryArray, GenericByteArray};
+use arrow_buffer::{ArrowNativeType, BooleanBuffer, ScalarBuffer};
+use arrow_schema::{ArrowError, DataType};
+
+/// A best effort interner that maintains a fixed number of buckets
+/// and interns keys based on their hash value
+///
+/// Hash collisions will result in replacement
+struct Interner<'a, V> {
+    state: RandomState,
+    buckets: Vec<Option<(&'a [u8], V)>>,
+    shift: u32,
+}
+
+impl<'a, V> Interner<'a, V> {
+    /// Capacity controls the number of unique buckets allocated within the Interner
+    ///
+    /// A larger capacity reduces the probability of hash collisions, and should be set
+    /// based on an approximation of the upper bound of unique values
+    fn new(capacity: usize) -> Self {
+        // Add additional buckets to help reduce collisions
+        let shift = (capacity as u64 + 128).leading_zeros();
+        let num_buckets = (u64::MAX >> shift) as usize;
+        let buckets = (0..num_buckets.saturating_add(1)).map(|_| None).collect();
+        Self {
+            // A fixed seed to ensure deterministic behaviour
+            state: RandomState::with_seeds(0, 0, 0, 0),
+            buckets,
+            shift,
+        }
+    }
+
+    fn intern<F: FnOnce() -> Result<V, E>, E>(&mut self, new: &'a [u8], f: F) -> Result<&V, E> {
+        let hash = self.state.hash_one(new);
+        let bucket_idx = hash >> self.shift;
+        Ok(match &mut self.buckets[bucket_idx as usize] {
+            Some((current, v)) => {
+                if *current != new {
+                    *v = f()?;
+                    *current = new;
+                }
+                v
+            }
+            slot => &slot.insert((new, f()?)).1,
+        })
+    }
+}
+
+pub struct MergedDictionaries<K: ArrowDictionaryKeyType> {
+    /// Provides `key_mappings[`array_idx`][`old_key`] -> new_key`
+    pub key_mappings: Vec<Vec<K::Native>>,
+    /// The new values
+    pub values: ArrayRef,
+}
+
+/// Performs a cheap, pointer-based comparison of two byte array
+///
+/// See [`ScalarBuffer::ptr_eq`]
+fn bytes_ptr_eq<T: ByteArrayType>(a: &dyn Array, b: &dyn Array) -> bool {
+    match (a.as_bytes_opt::<T>(), b.as_bytes_opt::<T>()) {
+        (Some(a), Some(b)) => {
+            let values_eq = a.values().ptr_eq(b.values()) && a.offsets().ptr_eq(b.offsets());
+            match (a.nulls(), b.nulls()) {
+                (Some(a), Some(b)) => values_eq && a.inner().ptr_eq(b.inner()),
+                (None, None) => values_eq,
+                _ => false,
+            }
+        }
+        _ => false,
+    }
+}
+
+/// A type-erased function that compares two array for pointer equality
+type PtrEq = dyn Fn(&dyn Array, &dyn Array) -> bool;
+
+/// A weak heuristic of whether to merge dictionary values that aims to only
+/// perform the expensive merge computation when it is likely to yield at least
+/// some return over the naive approach used by MutableArrayData
+///
+/// `len` is the total length of the merged output
+pub fn should_merge_dictionary_values<K: ArrowDictionaryKeyType>(
+    dictionaries: &[&DictionaryArray<K>],
+    len: usize,
+) -> bool {
+    use DataType::*;
+    let first_values = dictionaries[0].values().as_ref();
+    let ptr_eq: Box<PtrEq> = match first_values.data_type() {
+        Utf8 => Box::new(bytes_ptr_eq::<Utf8Type>),
+        LargeUtf8 => Box::new(bytes_ptr_eq::<LargeUtf8Type>),
+        Binary => Box::new(bytes_ptr_eq::<BinaryType>),
+        LargeBinary => Box::new(bytes_ptr_eq::<LargeBinaryType>),
+        _ => return false,
+    };
+
+    let mut single_dictionary = true;
+    let mut total_values = first_values.len();
+    for dict in dictionaries.iter().skip(1) {
+        let values = dict.values().as_ref();
+        total_values += values.len();
+        if single_dictionary {
+            single_dictionary = ptr_eq(first_values, values)
+        }
+    }
+
+    let overflow = K::Native::from_usize(total_values).is_none();
+    let values_exceed_length = total_values >= len;
+
+    !single_dictionary && (overflow || values_exceed_length)
+}
+
+/// Given an array of dictionaries and an optional key mask compute a values array
+/// containing referenced values, along with mappings from the [`DictionaryArray`]
+/// keys to the new keys within this values array. Best-effort will be made to ensure
+/// that the dictionary values are unique
+///
+/// This method is meant to be very fast and the output dictionary values
+/// may not be unique, unlike `GenericByteDictionaryBuilder` which is slower
+/// but produces unique values
+pub fn merge_dictionary_values<K: ArrowDictionaryKeyType>(
+    dictionaries: &[&DictionaryArray<K>],
+    masks: Option<&[BooleanBuffer]>,
+) -> Result<MergedDictionaries<K>, ArrowError> {
+    let mut num_values = 0;
+
+    let mut values_arrays = Vec::with_capacity(dictionaries.len());
+    let mut value_slices = Vec::with_capacity(dictionaries.len());
+
+    for (idx, dictionary) in dictionaries.iter().enumerate() {
+        let mask = masks.and_then(|m| m.get(idx));
+        let key_mask = match (dictionary.logical_nulls(), mask) {
+            (Some(n), None) => Some(n.into_inner()),
+            (None, Some(n)) => Some(n.clone()),
+            (Some(n), Some(m)) => Some(n.inner() & m),
+            (None, None) => None,
+        };
+        let keys = dictionary.keys().values();
+        let values = dictionary.values().as_ref();
+        let values_mask = compute_values_mask(keys, key_mask.as_ref(), values.len());
+
+        let masked_values = get_masked_values(values, &values_mask);
+        num_values += masked_values.len();
+        value_slices.push(masked_values);
+        values_arrays.push(values)
+    }
+
+    // Map from value to new index
+    let mut interner = Interner::new(num_values);
+    // Interleave indices for new values array
+    let mut indices = Vec::with_capacity(num_values);
+
+    // Compute the mapping for each dictionary
+    let key_mappings = dictionaries
+        .iter()
+        .enumerate()
+        .zip(value_slices)
+        .map(|((dictionary_idx, dictionary), values)| {
+            let zero = K::Native::from_usize(0).unwrap();
+            let mut mapping = vec![zero; dictionary.values().len()];
+
+            for (value_idx, value) in values {
+                mapping[value_idx] =
+                    *interner.intern(value, || match K::Native::from_usize(indices.len()) {
+                        Some(idx) => {
+                            indices.push((dictionary_idx, value_idx));
+                            Ok(idx)
+                        }
+                        None => Err(ArrowError::DictionaryKeyOverflowError),
+                    })?;
+            }
+            Ok(mapping)
+        })
+        .collect::<Result<Vec<_>, ArrowError>>()?;
+
+    Ok(MergedDictionaries {
+        key_mappings,
+        values: interleave(&values_arrays, &indices)?,
+    })
+}
+
+/// Return a mask identifying the values that are referenced by keys in `dictionary`
+/// at the positions indicated by `selection`
+fn compute_values_mask<K: ArrowNativeType>(
+    keys: &ScalarBuffer<K>,
+    mask: Option<&BooleanBuffer>,
+    max_key: usize,
+) -> BooleanBuffer {
+    let mut builder = BooleanBufferBuilder::new(max_key);
+    builder.advance(max_key);
+
+    match mask {
+        Some(n) => n
+            .set_indices()
+            .for_each(|idx| builder.set_bit(keys[idx].as_usize(), true)),
+        None => keys
+            .iter()
+            .for_each(|k| builder.set_bit(k.as_usize(), true)),
+    }
+    builder.finish()
+}
+
+/// Return a Vec containing for each set index in `mask`, the index and byte value of that index
+fn get_masked_values<'a>(array: &'a dyn Array, mask: &BooleanBuffer) -> Vec<(usize, &'a [u8])> {
+    match array.data_type() {
+        DataType::Utf8 => masked_bytes(array.as_string::<i32>(), mask),
+        DataType::LargeUtf8 => masked_bytes(array.as_string::<i64>(), mask),
+        DataType::Binary => masked_bytes(array.as_binary::<i32>(), mask),
+        DataType::LargeBinary => masked_bytes(array.as_binary::<i64>(), mask),
+        _ => unimplemented!(),
+    }
+}
+
+/// Compute [`get_masked_values`] for a [`GenericByteArray`]
+///
+/// Note: this does not check the null mask and will return values contained in null slots
+fn masked_bytes<'a, T: ByteArrayType>(
+    array: &'a GenericByteArray<T>,
+    mask: &BooleanBuffer,
+) -> Vec<(usize, &'a [u8])> {
+    let mut out = Vec::with_capacity(mask.count_set_bits());
+    for idx in mask.set_indices() {
+        out.push((idx, array.value(idx).as_ref()))
+    }
+    out
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::dictionary::merge_dictionary_values;
+    use arrow_array::cast::as_string_array;
+    use arrow_array::types::Int32Type;
+    use arrow_array::{DictionaryArray, Int32Array, StringArray};
+    use arrow_buffer::{BooleanBuffer, Buffer, NullBuffer, OffsetBuffer};
+    use std::sync::Arc;
+
+    #[test]
+    fn test_merge_strings() {
+        let a = DictionaryArray::<Int32Type>::from_iter(["a", "b", "a", "b", "d", "c", "e"]);
+        let b = DictionaryArray::<Int32Type>::from_iter(["c", "f", "c", "d", "a", "d"]);
+        let merged = merge_dictionary_values(&[&a, &b], None).unwrap();
+
+        let values = as_string_array(merged.values.as_ref());
+        let actual: Vec<_> = values.iter().map(Option::unwrap).collect();
+        assert_eq!(&actual, &["a", "b", "d", "c", "e", "f"]);
+
+        assert_eq!(merged.key_mappings.len(), 2);
+        assert_eq!(&merged.key_mappings[0], &[0, 1, 2, 3, 4]);
+        assert_eq!(&merged.key_mappings[1], &[3, 5, 2, 0]);
+
+        let a_slice = a.slice(1, 4);
+        let merged = merge_dictionary_values(&[&a_slice, &b], None).unwrap();
+
+        let values = as_string_array(merged.values.as_ref());
+        let actual: Vec<_> = values.iter().map(Option::unwrap).collect();
+        assert_eq!(&actual, &["a", "b", "d", "c", "f"]);
+
+        assert_eq!(merged.key_mappings.len(), 2);
+        assert_eq!(&merged.key_mappings[0], &[0, 1, 2, 0, 0]);
+        assert_eq!(&merged.key_mappings[1], &[3, 4, 2, 0]);
+
+        // Mask out only ["b", "b", "d"] from a
+        let a_mask = BooleanBuffer::from_iter([false, true, false, true, true, false, false]);
+        let b_mask = BooleanBuffer::new_set(b.len());
+        let merged = merge_dictionary_values(&[&a, &b], Some(&[a_mask, b_mask])).unwrap();
+
+        let values = as_string_array(merged.values.as_ref());
+        let actual: Vec<_> = values.iter().map(Option::unwrap).collect();
+        assert_eq!(&actual, &["b", "d", "c", "f", "a"]);
+
+        assert_eq!(merged.key_mappings.len(), 2);
+        assert_eq!(&merged.key_mappings[0], &[0, 0, 1, 0, 0]);
+        assert_eq!(&merged.key_mappings[1], &[2, 3, 1, 4]);
+    }
+
+    #[test]
+    fn test_merge_nulls() {
+        let buffer = Buffer::from("helloworldbingohelloworld");
+        let offsets = OffsetBuffer::from_lengths([5, 5, 5, 5, 5]);
+        let nulls = NullBuffer::from(vec![true, false, true, true, true]);
+        let values = StringArray::new(offsets, buffer, Some(nulls));
+
+        let key_values = vec![1, 2, 3, 1, 8, 2, 3];
+        let key_nulls = NullBuffer::from(vec![true, true, false, true, false, true, true]);
+        let keys = Int32Array::new(key_values.into(), Some(key_nulls));
+        let a = DictionaryArray::new(keys, Arc::new(values));
+        // [NULL, "bingo", NULL, NULL, NULL, "bingo", "hello"]
+
+        let b = DictionaryArray::new(Int32Array::new_null(10), Arc::new(StringArray::new_null(0)));
+
+        let merged = merge_dictionary_values(&[&a, &b], None).unwrap();
+        let expected = StringArray::from(vec!["bingo", "hello"]);
+        assert_eq!(merged.values.as_ref(), &expected);
+        assert_eq!(merged.key_mappings.len(), 2);
+        assert_eq!(&merged.key_mappings[0], &[0, 0, 0, 1, 0]);
+        assert_eq!(&merged.key_mappings[1], &[]);
+    }
+
+    #[test]
+    fn test_merge_keys_smaller() {
+        let values = StringArray::from_iter_values(["a", "b"]);
+        let keys = Int32Array::from_iter_values([1]);
+        let a = DictionaryArray::new(keys, Arc::new(values));
+
+        let merged = merge_dictionary_values(&[&a], None).unwrap();
+        let expected = StringArray::from(vec!["b"]);
+        assert_eq!(merged.values.as_ref(), &expected);
+    }
+}
diff --git a/arrow/src/compute/kernels/filter.rs b/arrow-select/src/filter.rs
similarity index 74%
rename from arrow/src/compute/kernels/filter.rs
rename to arrow-select/src/filter.rs
index 95a1bfa4da46..c365d0b841be 100644
--- a/arrow/src/compute/kernels/filter.rs
+++ b/arrow-select/src/filter.rs
@@ -15,22 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Defines miscellaneous array kernels.
+//! Defines filter kernels
 
-use std::ops::AddAssign;
 use std::sync::Arc;
 
-use num::Zero;
-
-use TimeUnit::*;
-
-use crate::array::*;
-use crate::buffer::{buffer_bin_and, Buffer, MutableBuffer};
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-use crate::record_batch::RecordBatch;
-use crate::util::bit_iterator::{BitIndexIterator, BitSliceIterator};
-use crate::util::bit_util;
+use arrow_array::builder::BooleanBufferBuilder;
+use arrow_array::cast::AsArray;
+use arrow_array::types::{ArrowDictionaryKeyType, ByteArrayType};
+use arrow_array::*;
+use arrow_buffer::{bit_util, BooleanBuffer, NullBuffer};
+use arrow_buffer::{Buffer, MutableBuffer};
+use arrow_data::bit_iterator::{BitIndexIterator, BitSliceIterator};
+use arrow_data::transform::MutableArrayData;
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::*;
 
 /// If the filter selects more than this fraction of rows, use
 /// [`SlicesIterator`] to copy ranges of values. Otherwise iterate
@@ -40,29 +38,8 @@ use crate::util::bit_util;
 ///
 const FILTER_SLICES_SELECTIVITY_THRESHOLD: f64 = 0.8;
 
-macro_rules! downcast_filter {
-    ($type: ty, $values: expr, $filter: expr) => {{
-        let values = $values
-            .as_any()
-            .downcast_ref::<PrimitiveArray<$type>>()
-            .expect("Unable to downcast to a primitive array");
-
-        Ok(Arc::new(filter_primitive::<$type>(&values, $filter)))
-    }};
-}
-
-macro_rules! downcast_dict_filter {
-    ($type: ty, $values: expr, $filter: expr) => {{
-        let values = $values
-            .as_any()
-            .downcast_ref::<DictionaryArray<$type>>()
-            .expect("Unable to downcast to a dictionary array");
-        Ok(Arc::new(filter_dict::<$type>(values, $filter)))
-    }};
-}
-
 /// An iterator of `(usize, usize)` each representing an interval
-/// `[start, end)` whose slots of a [BooleanArray] are true. Each
+/// `[start, end)` whose slots of a bitmap [Buffer] are true. Each
 /// interval corresponds to a contiguous region of memory to be
 /// "taken" from an array to be filtered.
 ///
@@ -76,11 +53,7 @@ pub struct SlicesIterator<'a>(BitSliceIterator<'a>);
 
 impl<'a> SlicesIterator<'a> {
     pub fn new(filter: &'a BooleanArray) -> Self {
-        let values = &filter.data_ref().buffers()[0];
-        let len = filter.len();
-        let offset = filter.offset();
-
-        Self(BitSliceIterator::new(values, offset, len))
+        Self(filter.values().set_slices())
     }
 }
 
@@ -104,8 +77,7 @@ struct IndexIterator<'a> {
 impl<'a> IndexIterator<'a> {
     fn new(filter: &'a BooleanArray, remaining: usize) -> Self {
         assert_eq!(filter.null_count(), 0);
-        let data = filter.data();
-        let iter = BitIndexIterator::new(&data.buffers()[0], data.offset(), data.len());
+        let iter = filter.values().set_indices();
         Self { remaining, iter }
     }
 }
@@ -132,9 +104,7 @@ impl<'a> Iterator for IndexIterator<'a> {
 
 /// Counts the number of set bits in `filter`
 fn filter_count(filter: &BooleanArray) -> usize {
-    filter
-        .values()
-        .count_set_bits_offset(filter.offset(), filter.len())
+    filter.values().count_set_bits()
 }
 
 /// Function that can filter arbitrary arrays
@@ -152,7 +122,7 @@ pub type Filter<'a> = Box<dyn Fn(&ArrayData) -> ArrayData + 'a>;
 /// Deprecated: Use [`FilterBuilder`] instead
 #[deprecated]
 #[allow(deprecated)]
-pub fn build_filter(filter: &BooleanArray) -> Result<Filter> {
+pub fn build_filter(filter: &BooleanArray) -> Result<Filter, ArrowError> {
     let iter = SlicesIterator::new(filter);
     let filter_count = filter_count(filter);
     let chunks = iter.collect::<Vec<_>>();
@@ -175,39 +145,24 @@ pub fn build_filter(filter: &BooleanArray) -> Result<Filter> {
 
 /// Remove null values by do a bitmask AND operation with null bits and the boolean bits.
 pub fn prep_null_mask_filter(filter: &BooleanArray) -> BooleanArray {
-    let array_data = filter.data_ref();
-    let null_bitmap = array_data.null_buffer().unwrap();
-    let mask = filter.values();
-    let offset = filter.offset();
-
-    let new_mask = buffer_bin_and(mask, offset, null_bitmap, offset, filter.len());
-
-    let array_data = ArrayData::builder(DataType::Boolean)
-        .len(filter.len())
-        .add_buffer(new_mask);
-
-    let array_data = unsafe { array_data.build_unchecked() };
-
-    BooleanArray::from(array_data)
+    let nulls = filter.nulls().unwrap();
+    let mask = filter.values() & nulls.inner();
+    BooleanArray::new(mask, None)
 }
 
 /// Filters an [Array], returning elements matching the filter (i.e. where the values are true).
 ///
 /// # Example
 /// ```rust
-/// # use arrow::array::{Int32Array, BooleanArray};
-/// # use arrow::error::Result;
-/// # use arrow::compute::kernels::filter::filter;
-/// # fn main() -> Result<()> {
+/// # use arrow_array::{Int32Array, BooleanArray};
+/// # use arrow_select::filter::filter;
 /// let array = Int32Array::from(vec![5, 6, 7, 8, 9]);
 /// let filter_array = BooleanArray::from(vec![true, false, false, true, false]);
-/// let c = filter(&array, &filter_array)?;
+/// let c = filter(&array, &filter_array).unwrap();
 /// let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
 /// assert_eq!(c, &Int32Array::from(vec![5, 8]));
-/// # Ok(())
-/// # }
 /// ```
-pub fn filter(values: &dyn Array, predicate: &BooleanArray) -> Result<ArrayRef> {
+pub fn filter(values: &dyn Array, predicate: &BooleanArray) -> Result<ArrayRef, ArrowError> {
     let predicate = FilterBuilder::new(predicate).build();
     filter_array(values, &predicate)
 }
@@ -216,7 +171,7 @@ pub fn filter(values: &dyn Array, predicate: &BooleanArray) -> Result<ArrayRef>
 pub fn filter_record_batch(
     record_batch: &RecordBatch,
     predicate: &BooleanArray,
-) -> Result<RecordBatch> {
+) -> Result<RecordBatch, ArrowError> {
     let mut filter_builder = FilterBuilder::new(predicate);
     if record_batch.num_columns() > 1 {
         // Only optimize if filtering more than one column
@@ -228,9 +183,9 @@ pub fn filter_record_batch(
         .columns()
         .iter()
         .map(|a| filter_array(a, &filter))
-        .collect::<Result<Vec<_>>>()?;
-
-    RecordBatch::try_new(record_batch.schema(), filtered_arrays)
+        .collect::<Result<Vec<_>, _>>()?;
+    let options = RecordBatchOptions::default().with_row_count(Some(filter.count()));
+    RecordBatch::try_new_with_options(record_batch.schema(), filtered_arrays, &options)
 }
 
 /// A builder to construct [`FilterPredicate`]
@@ -245,7 +200,7 @@ impl FilterBuilder {
     /// Create a new [`FilterBuilder`] that can be used to construct a [`FilterPredicate`]
     pub fn new(filter: &BooleanArray) -> Self {
         let filter = match filter.null_count() {
-            0 => BooleanArray::from(filter.data().clone()),
+            0 => filter.clone(),
             _ => prep_null_mask_filter(filter),
         };
 
@@ -340,12 +295,17 @@ pub struct FilterPredicate {
 
 impl FilterPredicate {
     /// Selects rows from `values` based on this [`FilterPredicate`]
-    pub fn filter(&self, values: &dyn Array) -> Result<ArrayRef> {
+    pub fn filter(&self, values: &dyn Array) -> Result<ArrayRef, ArrowError> {
         filter_array(values, self)
     }
+
+    /// Number of rows being selected based on this [`FilterPredicate`]
+    pub fn count(&self) -> usize {
+        self.count
+    }
 }
 
-fn filter_array(values: &dyn Array, predicate: &FilterPredicate) -> Result<ArrayRef> {
+fn filter_array(values: &dyn Array, predicate: &FilterPredicate) -> Result<ArrayRef, ArrowError> {
     if predicate.filter.len() > values.len() {
         return Err(ArrowError::InvalidArgumentError(format!(
             "Filter predicate of length {} is larger than target array of length {}",
@@ -356,125 +316,35 @@ fn filter_array(values: &dyn Array, predicate: &FilterPredicate) -> Result<Array
 
     match predicate.strategy {
         IterationStrategy::None => Ok(new_empty_array(values.data_type())),
-        IterationStrategy::All => Ok(make_array(values.data().slice(0, predicate.count))),
+        IterationStrategy::All => Ok(values.slice(0, predicate.count)),
         // actually filter
-        _ => match values.data_type() {
+        _ => downcast_primitive_array! {
+            values => Ok(Arc::new(filter_primitive(values, predicate))),
             DataType::Boolean => {
                 let values = values.as_any().downcast_ref::<BooleanArray>().unwrap();
                 Ok(Arc::new(filter_boolean(values, predicate)))
             }
-            DataType::Int8 => {
-                downcast_filter!(Int8Type, values, predicate)
-            }
-            DataType::Int16 => {
-                downcast_filter!(Int16Type, values, predicate)
-            }
-            DataType::Int32 => {
-                downcast_filter!(Int32Type, values, predicate)
-            }
-            DataType::Int64 => {
-                downcast_filter!(Int64Type, values, predicate)
-            }
-            DataType::UInt8 => {
-                downcast_filter!(UInt8Type, values, predicate)
-            }
-            DataType::UInt16 => {
-                downcast_filter!(UInt16Type, values, predicate)
-            }
-            DataType::UInt32 => {
-                downcast_filter!(UInt32Type, values, predicate)
-            }
-            DataType::UInt64 => {
-                downcast_filter!(UInt64Type, values, predicate)
-            }
-            DataType::Float32 => {
-                downcast_filter!(Float32Type, values, predicate)
-            }
-            DataType::Float64 => {
-                downcast_filter!(Float64Type, values, predicate)
-            }
-            DataType::Date32 => {
-                downcast_filter!(Date32Type, values, predicate)
-            }
-            DataType::Date64 => {
-                downcast_filter!(Date64Type, values, predicate)
-            }
-            DataType::Time32(Second) => {
-                downcast_filter!(Time32SecondType, values, predicate)
-            }
-            DataType::Time32(Millisecond) => {
-                downcast_filter!(Time32MillisecondType, values, predicate)
-            }
-            DataType::Time64(Microsecond) => {
-                downcast_filter!(Time64MicrosecondType, values, predicate)
-            }
-            DataType::Time64(Nanosecond) => {
-                downcast_filter!(Time64NanosecondType, values, predicate)
-            }
-            DataType::Timestamp(Second, _) => {
-                downcast_filter!(TimestampSecondType, values, predicate)
-            }
-            DataType::Timestamp(Millisecond, _) => {
-                downcast_filter!(TimestampMillisecondType, values, predicate)
-            }
-            DataType::Timestamp(Microsecond, _) => {
-                downcast_filter!(TimestampMicrosecondType, values, predicate)
-            }
-            DataType::Timestamp(Nanosecond, _) => {
-                downcast_filter!(TimestampNanosecondType, values, predicate)
-            }
-            DataType::Interval(IntervalUnit::YearMonth) => {
-                downcast_filter!(IntervalYearMonthType, values, predicate)
-            }
-            DataType::Interval(IntervalUnit::DayTime) => {
-                downcast_filter!(IntervalDayTimeType, values, predicate)
-            }
-            DataType::Interval(IntervalUnit::MonthDayNano) => {
-                downcast_filter!(IntervalMonthDayNanoType, values, predicate)
-            }
-            DataType::Duration(TimeUnit::Second) => {
-                downcast_filter!(DurationSecondType, values, predicate)
-            }
-            DataType::Duration(TimeUnit::Millisecond) => {
-                downcast_filter!(DurationMillisecondType, values, predicate)
+            DataType::Utf8 => {
+                Ok(Arc::new(filter_bytes(values.as_string::<i32>(), predicate)))
             }
-            DataType::Duration(TimeUnit::Microsecond) => {
-                downcast_filter!(DurationMicrosecondType, values, predicate)
+            DataType::LargeUtf8 => {
+                Ok(Arc::new(filter_bytes(values.as_string::<i64>(), predicate)))
             }
-            DataType::Duration(TimeUnit::Nanosecond) => {
-                downcast_filter!(DurationNanosecondType, values, predicate)
+            DataType::Binary => {
+                Ok(Arc::new(filter_bytes(values.as_binary::<i32>(), predicate)))
             }
-            DataType::Utf8 => {
-                let values = values
-                    .as_any()
-                    .downcast_ref::<GenericStringArray<i32>>()
-                    .unwrap();
-                Ok(Arc::new(filter_string::<i32>(values, predicate)))
+            DataType::LargeBinary => {
+                Ok(Arc::new(filter_bytes(values.as_binary::<i64>(), predicate)))
             }
-            DataType::LargeUtf8 => {
-                let values = values
-                    .as_any()
-                    .downcast_ref::<GenericStringArray<i64>>()
-                    .unwrap();
-                Ok(Arc::new(filter_string::<i64>(values, predicate)))
+            DataType::Dictionary(_, _) => downcast_dictionary_array! {
+                values => Ok(Arc::new(filter_dict(values, predicate))),
+                t => unimplemented!("Filter not supported for dictionary type {:?}", t)
             }
-            DataType::Dictionary(key_type, _) => match key_type.as_ref() {
-                DataType::Int8 => downcast_dict_filter!(Int8Type, values, predicate),
-                DataType::Int16 => downcast_dict_filter!(Int16Type, values, predicate),
-                DataType::Int32 => downcast_dict_filter!(Int32Type, values, predicate),
-                DataType::Int64 => downcast_dict_filter!(Int64Type, values, predicate),
-                DataType::UInt8 => downcast_dict_filter!(UInt8Type, values, predicate),
-                DataType::UInt16 => downcast_dict_filter!(UInt16Type, values, predicate),
-                DataType::UInt32 => downcast_dict_filter!(UInt32Type, values, predicate),
-                DataType::UInt64 => downcast_dict_filter!(UInt64Type, values, predicate),
-                t => {
-                    unimplemented!("Filter not supported for dictionary key type {:?}", t)
-                }
-            },
             _ => {
+                let data = values.to_data();
                 // fallback to using MutableArrayData
                 let mut mutable = MutableArrayData::new(
-                    vec![values.data_ref()],
+                    vec![&data],
                     false,
                     predicate.count,
                 );
@@ -505,17 +375,18 @@ fn filter_array(values: &dyn Array, predicate: &FilterPredicate) -> Result<Array
 /// in the filtered output, and `null_buffer` is the filtered null buffer
 ///
 fn filter_null_mask(
-    data: &ArrayData,
+    nulls: Option<&NullBuffer>,
     predicate: &FilterPredicate,
 ) -> Option<(usize, Buffer)> {
-    if data.null_count() == 0 {
+    let nulls = nulls?;
+    if nulls.null_count() == 0 {
         return None;
     }
 
-    let nulls = filter_bits(data.null_buffer()?, data.offset(), predicate);
+    let nulls = filter_bits(nulls.inner(), predicate);
     // The filtered `nulls` has a length of `predicate.count` bits and
     // therefore the null count is this minus the number of valid bits
-    let null_count = predicate.count - nulls.count_set_bits();
+    let null_count = predicate.count - nulls.count_set_bits_offset(0, predicate.count);
 
     if null_count == 0 {
         return None;
@@ -525,8 +396,9 @@ fn filter_null_mask(
 }
 
 /// Filter the packed bitmask `buffer`, with `predicate` starting at bit offset `offset`
-fn filter_bits(buffer: &Buffer, offset: usize, predicate: &FilterPredicate) -> Buffer {
-    let src = buffer.as_slice();
+fn filter_bits(buffer: &BooleanBuffer, predicate: &FilterPredicate) -> Buffer {
+    let src = buffer.values();
+    let offset = buffer.offset();
 
     match &predicate.strategy {
         IterationStrategy::IndexIterator => {
@@ -545,38 +417,32 @@ fn filter_bits(buffer: &Buffer, offset: usize, predicate: &FilterPredicate) -> B
             unsafe { MutableBuffer::from_trusted_len_iter_bool(bits).into() }
         }
         IterationStrategy::SlicesIterator => {
-            let mut builder =
-                BooleanBufferBuilder::new(bit_util::ceil(predicate.count, 8));
+            let mut builder = BooleanBufferBuilder::new(bit_util::ceil(predicate.count, 8));
             for (start, end) in SlicesIterator::new(&predicate.filter) {
                 builder.append_packed_range(start + offset..end + offset, src)
             }
-            builder.finish()
+            builder.into()
         }
         IterationStrategy::Slices(slices) => {
-            let mut builder =
-                BooleanBufferBuilder::new(bit_util::ceil(predicate.count, 8));
+            let mut builder = BooleanBufferBuilder::new(bit_util::ceil(predicate.count, 8));
             for (start, end) in slices {
                 builder.append_packed_range(*start + offset..*end + offset, src)
             }
-            builder.finish()
+            builder.into()
         }
         IterationStrategy::All | IterationStrategy::None => unreachable!(),
     }
 }
 
 /// `filter` implementation for boolean buffers
-fn filter_boolean(values: &BooleanArray, predicate: &FilterPredicate) -> BooleanArray {
-    let data = values.data();
-    assert_eq!(data.buffers().len(), 1);
-    assert_eq!(data.child_data().len(), 0);
-
-    let values = filter_bits(&data.buffers()[0], data.offset(), predicate);
+fn filter_boolean(array: &BooleanArray, predicate: &FilterPredicate) -> BooleanArray {
+    let values = filter_bits(array.values(), predicate);
 
     let mut builder = ArrayDataBuilder::new(DataType::Boolean)
         .len(predicate.count)
         .add_buffer(values);
 
-    if let Some((null_count, nulls)) = filter_null_mask(data, predicate) {
+    if let Some((null_count, nulls)) = filter_null_mask(array.nulls(), predicate) {
         builder = builder.null_count(null_count).null_bit_buffer(Some(nulls));
     }
 
@@ -585,40 +451,30 @@ fn filter_boolean(values: &BooleanArray, predicate: &FilterPredicate) -> Boolean
 }
 
 /// `filter` implementation for primitive arrays
-fn filter_primitive<T>(
-    values: &PrimitiveArray<T>,
-    predicate: &FilterPredicate,
-) -> PrimitiveArray<T>
+fn filter_primitive<T>(array: &PrimitiveArray<T>, predicate: &FilterPredicate) -> PrimitiveArray<T>
 where
     T: ArrowPrimitiveType,
 {
-    let data = values.data();
-    assert_eq!(data.buffers().len(), 1);
-    assert_eq!(data.child_data().len(), 0);
-
-    let values = data.buffer::<T::Native>(0);
+    let values = array.values();
     assert!(values.len() >= predicate.filter.len());
 
     let buffer = match &predicate.strategy {
         IterationStrategy::SlicesIterator => {
-            let mut buffer =
-                MutableBuffer::with_capacity(predicate.count * T::get_byte_width());
+            let mut buffer = MutableBuffer::with_capacity(predicate.count * T::get_byte_width());
             for (start, end) in SlicesIterator::new(&predicate.filter) {
                 buffer.extend_from_slice(&values[start..end]);
             }
             buffer
         }
         IterationStrategy::Slices(slices) => {
-            let mut buffer =
-                MutableBuffer::with_capacity(predicate.count * T::get_byte_width());
+            let mut buffer = MutableBuffer::with_capacity(predicate.count * T::get_byte_width());
             for (start, end) in slices {
                 buffer.extend_from_slice(&values[*start..*end]);
             }
             buffer
         }
         IterationStrategy::IndexIterator => {
-            let iter =
-                IndexIterator::new(&predicate.filter, predicate.count).map(|x| values[x]);
+            let iter = IndexIterator::new(&predicate.filter, predicate.count).map(|x| values[x]);
 
             // SAFETY: IndexIterator is trusted length
             unsafe { MutableBuffer::from_trusted_len_iter(iter) }
@@ -632,11 +488,11 @@ where
         IterationStrategy::All | IterationStrategy::None => unreachable!(),
     };
 
-    let mut builder = ArrayDataBuilder::new(data.data_type().clone())
+    let mut builder = ArrayDataBuilder::new(array.data_type().clone())
         .len(predicate.count)
         .add_buffer(buffer.into());
 
-    if let Some((null_count, nulls)) = filter_null_mask(data, predicate) {
+    if let Some((null_count, nulls)) = filter_null_mask(array.nulls(), predicate) {
         builder = builder.null_count(null_count).null_bit_buffer(Some(nulls));
     }
 
@@ -644,11 +500,11 @@ where
     PrimitiveArray::from(data)
 }
 
-/// [`FilterString`] is created from a source [`GenericStringArray`] and can be
-/// used to build a new [`GenericStringArray`] by copying values from the source
+/// [`FilterBytes`] is created from a source [`GenericByteArray`] and can be
+/// used to build a new [`GenericByteArray`] by copying values from the source
 ///
 /// TODO(raphael): Could this be used for the take kernel as well?
-struct FilterString<'a, OffsetSize> {
+struct FilterBytes<'a, OffsetSize> {
     src_offsets: &'a [OffsetSize],
     src_values: &'a [u8],
     dst_offsets: MutableBuffer,
@@ -656,20 +512,23 @@ struct FilterString<'a, OffsetSize> {
     cur_offset: OffsetSize,
 }
 
-impl<'a, OffsetSize> FilterString<'a, OffsetSize>
+impl<'a, OffsetSize> FilterBytes<'a, OffsetSize>
 where
-    OffsetSize: Zero + AddAssign + OffsetSizeTrait,
+    OffsetSize: OffsetSizeTrait,
 {
-    fn new(capacity: usize, array: &'a GenericStringArray<OffsetSize>) -> Self {
+    fn new<T>(capacity: usize, array: &'a GenericByteArray<T>) -> Self
+    where
+        T: ByteArrayType<Offset = OffsetSize>,
+    {
         let num_offsets_bytes = (capacity + 1) * std::mem::size_of::<OffsetSize>();
         let mut dst_offsets = MutableBuffer::new(num_offsets_bytes);
         let dst_values = MutableBuffer::new(0);
-        let cur_offset = OffsetSize::zero();
+        let cur_offset = OffsetSize::from_usize(0).unwrap();
         dst_offsets.push(cur_offset);
 
         Self {
             src_offsets: array.value_offsets(),
-            src_values: &array.data().buffers()[1],
+            src_values: array.value_data(),
             dst_offsets,
             dst_values,
             cur_offset,
@@ -679,7 +538,7 @@ where
     /// Returns the byte offset at `idx`
     #[inline]
     fn get_value_offset(&self, idx: usize) -> usize {
-        self.src_offsets[idx].to_usize().expect("illegal offset")
+        self.src_offsets[idx].as_usize()
     }
 
     /// Returns the start and end of the value at index `idx` along with its length
@@ -721,21 +580,15 @@ where
     }
 }
 
-/// `filter` implementation for string arrays
+/// `filter` implementation for byte arrays
 ///
 /// Note: NULLs with a non-zero slot length in `array` will have the corresponding
 /// data copied across. This allows handling the null mask separately from the data
-fn filter_string<OffsetSize>(
-    array: &GenericStringArray<OffsetSize>,
-    predicate: &FilterPredicate,
-) -> GenericStringArray<OffsetSize>
+fn filter_bytes<T>(array: &GenericByteArray<T>, predicate: &FilterPredicate) -> GenericByteArray<T>
 where
-    OffsetSize: Zero + AddAssign + OffsetSizeTrait,
+    T: ByteArrayType,
 {
-    let data = array.data();
-    assert_eq!(data.buffers().len(), 2);
-    assert_eq!(data.child_data().len(), 0);
-    let mut filter = FilterString::new(predicate.count, array);
+    let mut filter = FilterBytes::new(predicate.count, array);
 
     match &predicate.strategy {
         IterationStrategy::SlicesIterator => {
@@ -749,63 +602,43 @@ where
         IterationStrategy::All | IterationStrategy::None => unreachable!(),
     }
 
-    let mut builder = ArrayDataBuilder::new(data.data_type().clone())
+    let mut builder = ArrayDataBuilder::new(T::DATA_TYPE)
         .len(predicate.count)
         .add_buffer(filter.dst_offsets.into())
         .add_buffer(filter.dst_values.into());
 
-    if let Some((null_count, nulls)) = filter_null_mask(data, predicate) {
+    if let Some((null_count, nulls)) = filter_null_mask(array.nulls(), predicate) {
         builder = builder.null_count(null_count).null_bit_buffer(Some(nulls));
     }
 
     let data = unsafe { builder.build_unchecked() };
-    GenericStringArray::from(data)
+    GenericByteArray::from(data)
 }
 
 /// `filter` implementation for dictionaries
-fn filter_dict<T>(
-    array: &DictionaryArray<T>,
-    predicate: &FilterPredicate,
-) -> DictionaryArray<T>
+fn filter_dict<T>(array: &DictionaryArray<T>, predicate: &FilterPredicate) -> DictionaryArray<T>
 where
-    T: ArrowPrimitiveType,
+    T: ArrowDictionaryKeyType,
     T::Native: num::Num,
 {
-    let filtered_keys = filter_primitive::<T>(array.keys(), predicate);
-    let filtered_data = filtered_keys.data_ref();
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            array.data_type().clone(),
-            filtered_data.len(),
-            Some(filtered_data.null_count()),
-            filtered_data.null_buffer().cloned(),
-            filtered_data.offset(),
-            filtered_data.buffers().to_vec(),
-            array.data().child_data().to_vec(),
-        )
-    };
-
-    unsafe {
-        DictionaryArray::<T>::try_new_unchecked(
-            filtered_keys,
-            array.values().clone(),
-            data,
-        )
-    }
+    let builder = filter_primitive::<T>(array.keys(), predicate)
+        .into_data()
+        .into_builder()
+        .data_type(array.data_type().clone())
+        .child_data(vec![array.values().to_data()]);
+
+    // SAFETY:
+    // Keys were valid before, filtered subset is therefore still valid
+    DictionaryArray::from(unsafe { builder.build_unchecked() })
 }
 
 #[cfg(test)]
 mod tests {
+    use arrow_array::builder::*;
+    use arrow_array::types::*;
     use rand::distributions::{Alphanumeric, Standard};
     use rand::prelude::*;
 
-    use crate::datatypes::Int64Type;
-    use crate::{
-        buffer::Buffer,
-        datatypes::{DataType, Field},
-    };
-
     use super::*;
 
     macro_rules! def_temporal_test {
@@ -876,33 +709,32 @@ mod tests {
     def_temporal_test!(
         test_filter_timestamp_second,
         TimestampSecondArray,
-        TimestampSecondArray::from_vec(vec![1, 2, 3, 4], None)
+        TimestampSecondArray::from(vec![1, 2, 3, 4])
     );
     def_temporal_test!(
         test_filter_timestamp_millisecond,
         TimestampMillisecondArray,
-        TimestampMillisecondArray::from_vec(vec![1, 2, 3, 4], None)
+        TimestampMillisecondArray::from(vec![1, 2, 3, 4])
     );
     def_temporal_test!(
         test_filter_timestamp_microsecond,
         TimestampMicrosecondArray,
-        TimestampMicrosecondArray::from_vec(vec![1, 2, 3, 4], None)
+        TimestampMicrosecondArray::from(vec![1, 2, 3, 4])
     );
     def_temporal_test!(
         test_filter_timestamp_nanosecond,
         TimestampNanosecondArray,
-        TimestampNanosecondArray::from_vec(vec![1, 2, 3, 4], None)
+        TimestampNanosecondArray::from(vec![1, 2, 3, 4])
     );
 
     #[test]
     fn test_filter_array_slice() {
-        let a_slice = Int32Array::from(vec![5, 6, 7, 8, 9]).slice(1, 4);
-        let a = a_slice.as_ref();
+        let a = Int32Array::from(vec![5, 6, 7, 8, 9]).slice(1, 4);
         let b = BooleanArray::from(vec![true, false, false, true]);
         // filtering with sliced filter array is not currently supported
         // let b_slice = BooleanArray::from(vec![true, false, false, true, false]).slice(1, 4);
         // let b = b_slice.as_any().downcast_ref().unwrap();
-        let c = filter(a, &b).unwrap();
+        let c = filter(&a, &b).unwrap();
         let d = c.as_ref().as_any().downcast_ref::<Int32Array>().unwrap();
         assert_eq!(2, d.len());
         assert_eq!(6, d.value(0));
@@ -913,8 +745,7 @@ mod tests {
     fn test_filter_array_low_density() {
         // this test exercises the all 0's branch of the filter algorithm
         let mut data_values = (1..=65).collect::<Vec<i32>>();
-        let mut filter_values =
-            (1..=65).map(|i| matches!(i % 65, 0)).collect::<Vec<bool>>();
+        let mut filter_values = (1..=65).map(|i| matches!(i % 65, 0)).collect::<Vec<bool>>();
         // set up two more values after the batch
         data_values.extend_from_slice(&[66, 67]);
         filter_values.extend_from_slice(&[false, true]);
@@ -1000,14 +831,12 @@ mod tests {
 
     #[test]
     fn test_filter_array_slice_with_null() {
-        let a_slice =
-            Int32Array::from(vec![Some(5), None, Some(7), Some(8), Some(9)]).slice(1, 4);
-        let a = a_slice.as_ref();
+        let a = Int32Array::from(vec![Some(5), None, Some(7), Some(8), Some(9)]).slice(1, 4);
         let b = BooleanArray::from(vec![true, false, false, true]);
         // filtering with sliced filter array is not currently supported
         // let b_slice = BooleanArray::from(vec![true, false, false, true, false]).slice(1, 4);
         // let b = b_slice.as_any().downcast_ref().unwrap();
-        let c = filter(a, &b).unwrap();
+        let c = filter(&a, &b).unwrap();
         let d = c.as_ref().as_any().downcast_ref::<Int32Array>().unwrap();
         assert_eq!(2, d.len());
         assert!(d.is_null(0));
@@ -1017,7 +846,7 @@ mod tests {
 
     #[test]
     fn test_filter_dictionary_array() {
-        let values = vec![Some("hello"), None, Some("world"), Some("!")];
+        let values = [Some("hello"), None, Some("world"), Some("!")];
         let a: Int8DictionaryArray = values.iter().copied().collect();
         let b = BooleanArray::from(vec![false, true, true, false]);
         let c = filter(&a, &b).unwrap();
@@ -1036,36 +865,18 @@ mod tests {
         assert_eq!("world", values.value(d.keys().value(1) as usize));
     }
 
-    #[test]
-    fn test_filter_string_array_with_negated_boolean_array() {
-        let a = StringArray::from(vec!["hello", " ", "world", "!"]);
-        let mut bb = BooleanBuilder::new(2);
-        bb.append_value(false);
-        bb.append_value(true);
-        bb.append_value(false);
-        bb.append_value(true);
-        let b = bb.finish();
-        let b = crate::compute::not(&b).unwrap();
-
-        let c = filter(&a, &b).unwrap();
-        let d = c.as_ref().as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(2, d.len());
-        assert_eq!("hello", d.value(0));
-        assert_eq!("world", d.value(1));
-    }
-
     #[test]
     fn test_filter_list_array() {
         let value_data = ArrayData::builder(DataType::Int32)
             .len(8)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7]))
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
             .build()
             .unwrap();
 
-        let value_offsets = Buffer::from_slice_ref(&[0i64, 3, 6, 8, 8]);
+        let value_offsets = Buffer::from_slice_ref([0i64, 3, 6, 8, 8]);
 
         let list_data_type =
-            DataType::LargeList(Box::new(Field::new("item", DataType::Int32, false)));
+            DataType::LargeList(Arc::new(Field::new("item", DataType::Int32, false)));
         let list_data = ArrayData::builder(list_data_type)
             .len(4)
             .add_buffer(value_offsets)
@@ -1082,14 +893,14 @@ mod tests {
         // expected: [[3, 4, 5], null]
         let value_data = ArrayData::builder(DataType::Int32)
             .len(3)
-            .add_buffer(Buffer::from_slice_ref(&[3, 4, 5]))
+            .add_buffer(Buffer::from_slice_ref([3, 4, 5]))
             .build()
             .unwrap();
 
-        let value_offsets = Buffer::from_slice_ref(&[0i64, 3, 3]);
+        let value_offsets = Buffer::from_slice_ref([0i64, 3, 3]);
 
         let list_data_type =
-            DataType::LargeList(Box::new(Field::new("item", DataType::Int32, false)));
+            DataType::LargeList(Arc::new(Field::new("item", DataType::Int32, false)));
         let expected = ArrayData::builder(list_data_type)
             .len(2)
             .add_buffer(value_offsets)
@@ -1141,36 +952,32 @@ mod tests {
     }
 
     #[test]
-    fn test_null_mask() -> Result<()> {
-        use crate::compute::kernels::comparison;
-        let a: PrimitiveArray<Int64Type> =
-            PrimitiveArray::from(vec![Some(1), Some(2), None]);
-        let mask0 = comparison::eq(&a, &a)?;
-        let out0 = filter(&a, &mask0)?;
-        let out_arr0 = out0
-            .as_any()
-            .downcast_ref::<PrimitiveArray<Int64Type>>()
-            .unwrap();
+    fn test_null_mask() {
+        let a = Int64Array::from(vec![Some(1), Some(2), None]);
 
         let mask1 = BooleanArray::from(vec![Some(true), Some(true), None]);
-        let out1 = filter(&a, &mask1)?;
-        let out_arr1 = out1
-            .as_any()
-            .downcast_ref::<PrimitiveArray<Int64Type>>()
-            .unwrap();
-        assert_eq!(mask0, mask1);
-        assert_eq!(out_arr0, out_arr1);
-        Ok(())
+        let out = filter(&a, &mask1).unwrap();
+        assert_eq!(out.as_ref(), &a.slice(0, 2));
     }
 
     #[test]
-    fn test_fast_path() -> Result<()> {
-        let a: PrimitiveArray<Int64Type> =
-            PrimitiveArray::from(vec![Some(1), Some(2), None]);
+    fn test_filter_record_batch_no_columns() {
+        let pred = BooleanArray::from(vec![Some(true), Some(true), None]);
+        let options = RecordBatchOptions::default().with_row_count(Some(100));
+        let record_batch =
+            RecordBatch::try_new_with_options(Arc::new(Schema::empty()), vec![], &options).unwrap();
+        let out = filter_record_batch(&record_batch, &pred).unwrap();
+
+        assert_eq!(out.num_rows(), 2);
+    }
+
+    #[test]
+    fn test_fast_path() {
+        let a: PrimitiveArray<Int64Type> = PrimitiveArray::from(vec![Some(1), Some(2), None]);
 
         // all true
         let mask = BooleanArray::from(vec![true, true, true]);
-        let out = filter(&a, &mask)?;
+        let out = filter(&a, &mask).unwrap();
         let b = out
             .as_any()
             .downcast_ref::<PrimitiveArray<Int64Type>>()
@@ -1179,10 +986,9 @@ mod tests {
 
         // all false
         let mask = BooleanArray::from(vec![false, false, false]);
-        let out = filter(&a, &mask)?;
+        let out = filter(&a, &mask).unwrap();
         assert_eq!(out.len(), 0);
         assert_eq!(out.data_type(), &DataType::Int64);
-        Ok(())
     }
 
     #[test]
@@ -1316,9 +1122,7 @@ mod tests {
     }
 
     /// Returns an iterator that calls `Option::as_deref` on each item
-    fn as_deref<T: std::ops::Deref>(
-        src: &[Option<T>],
-    ) -> impl Iterator<Item = Option<&T::Target>> {
+    fn as_deref<T: std::ops::Deref>(src: &[Option<T>]) -> impl Iterator<Item = Option<&T::Target>> {
         src.iter().map(|x| x.as_deref())
     }
 
@@ -1416,7 +1220,7 @@ mod tests {
     #[test]
     fn test_filter_map() {
         let mut builder =
-            MapBuilder::new(None, StringBuilder::new(16), Int64Builder::new(4));
+            MapBuilder::new(None, StringBuilder::new(), Int64Builder::with_capacity(4));
         // [{"key1": 1}, {"key2": 2, "key3": 3}, null, {"key1": 1}
         builder.keys().append_value("key1");
         builder.values().append_value(1);
@@ -1438,7 +1242,7 @@ mod tests {
         let got = filter(&maparray, &indices).unwrap();
 
         let mut builder =
-            MapBuilder::new(None, StringBuilder::new(8), Int64Builder::new(2));
+            MapBuilder::new(None, StringBuilder::new(), Int64Builder::with_capacity(2));
         builder.keys().append_value("key1");
         builder.values().append_value(1);
         builder.append(true).unwrap();
@@ -1454,13 +1258,10 @@ mod tests {
     fn test_filter_fixed_size_list_arrays() {
         let value_data = ArrayData::builder(DataType::Int32)
             .len(9)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8]))
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7, 8]))
             .build()
             .unwrap();
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::Int32, false)),
-            3,
-        );
+        let list_data_type = DataType::new_fixed_size_list(DataType::Int32, 3, false);
         let list_data = ArrayData::builder(list_data_type)
             .len(3)
             .add_child_data(value_data)
@@ -1504,7 +1305,7 @@ mod tests {
     fn test_filter_fixed_size_list_arrays_with_null() {
         let value_data = ArrayData::builder(DataType::Int32)
             .len(10)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
             .build()
             .unwrap();
 
@@ -1516,10 +1317,7 @@ mod tests {
         bit_util::set_bit(&mut null_bits, 3);
         bit_util::set_bit(&mut null_bits, 4);
 
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::Int32, false)),
-            2,
-        );
+        let list_data_type = DataType::new_fixed_size_list(DataType::Int32, 2, false);
         let list_data = ArrayData::builder(list_data_type)
             .len(5)
             .add_child_data(value_data)
@@ -1553,7 +1351,7 @@ mod tests {
         let c = filter(&array, &filter_array).unwrap();
         let filtered = c.as_any().downcast_ref::<UnionArray>().unwrap();
 
-        let mut builder = UnionBuilder::new_dense(1);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("A", 1).unwrap();
         let expected_array = builder.build().unwrap();
 
@@ -1563,7 +1361,7 @@ mod tests {
         let c = filter(&array, &filter_array).unwrap();
         let filtered = c.as_any().downcast_ref::<UnionArray>().unwrap();
 
-        let mut builder = UnionBuilder::new_dense(2);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append::<Int32Type>("A", 34).unwrap();
         let expected_array = builder.build().unwrap();
@@ -1574,7 +1372,7 @@ mod tests {
         let c = filter(&array, &filter_array).unwrap();
         let filtered = c.as_any().downcast_ref::<UnionArray>().unwrap();
 
-        let mut builder = UnionBuilder::new_dense(2);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append::<Float64Type>("B", 3.2).unwrap();
         let expected_array = builder.build().unwrap();
@@ -1584,7 +1382,7 @@ mod tests {
 
     #[test]
     fn test_filter_union_array_dense() {
-        let mut builder = UnionBuilder::new_dense(3);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append::<Float64Type>("B", 3.2).unwrap();
         builder.append::<Int32Type>("A", 34).unwrap();
@@ -1595,7 +1393,7 @@ mod tests {
 
     #[test]
     fn test_filter_run_union_array_dense() {
-        let mut builder = UnionBuilder::new_dense(3);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append::<Int32Type>("A", 3).unwrap();
         builder.append::<Int32Type>("A", 34).unwrap();
@@ -1605,17 +1403,17 @@ mod tests {
         let c = filter(&array, &filter_array).unwrap();
         let filtered = c.as_any().downcast_ref::<UnionArray>().unwrap();
 
-        let mut builder = UnionBuilder::new_dense(3);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append::<Int32Type>("A", 3).unwrap();
         let expected = builder.build().unwrap();
 
-        assert_eq!(filtered.data(), expected.data());
+        assert_eq!(filtered.to_data(), expected.to_data());
     }
 
     #[test]
     fn test_filter_union_array_dense_with_nulls() {
-        let mut builder = UnionBuilder::new_dense(4);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append::<Float64Type>("B", 3.2).unwrap();
         builder.append_null::<Float64Type>("B").unwrap();
@@ -1626,7 +1424,7 @@ mod tests {
         let c = filter(&array, &filter_array).unwrap();
         let filtered = c.as_any().downcast_ref::<UnionArray>().unwrap();
 
-        let mut builder = UnionBuilder::new_dense(2);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append::<Float64Type>("B", 3.2).unwrap();
         let expected_array = builder.build().unwrap();
@@ -1637,7 +1435,7 @@ mod tests {
         let c = filter(&array, &filter_array).unwrap();
         let filtered = c.as_any().downcast_ref::<UnionArray>().unwrap();
 
-        let mut builder = UnionBuilder::new_dense(2);
+        let mut builder = UnionBuilder::new_dense();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append_null::<Float64Type>("B").unwrap();
         let expected_array = builder.build().unwrap();
@@ -1647,7 +1445,7 @@ mod tests {
 
     #[test]
     fn test_filter_union_array_sparse() {
-        let mut builder = UnionBuilder::new_sparse(3);
+        let mut builder = UnionBuilder::new_sparse();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append::<Float64Type>("B", 3.2).unwrap();
         builder.append::<Int32Type>("A", 34).unwrap();
@@ -1658,7 +1456,7 @@ mod tests {
 
     #[test]
     fn test_filter_union_array_sparse_with_nulls() {
-        let mut builder = UnionBuilder::new_sparse(4);
+        let mut builder = UnionBuilder::new_sparse();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append::<Float64Type>("B", 3.2).unwrap();
         builder.append_null::<Float64Type>("B").unwrap();
@@ -1669,7 +1467,7 @@ mod tests {
         let c = filter(&array, &filter_array).unwrap();
         let filtered = c.as_any().downcast_ref::<UnionArray>().unwrap();
 
-        let mut builder = UnionBuilder::new_sparse(2);
+        let mut builder = UnionBuilder::new_sparse();
         builder.append::<Int32Type>("A", 1).unwrap();
         builder.append_null::<Float64Type>("B").unwrap();
         let expected_array = builder.build().unwrap();
@@ -1701,13 +1499,11 @@ mod tests {
                         assert_eq!(value1, value2);
                     }
                     1 => {
-                        let slot1 =
-                            slot1.as_any().downcast_ref::<Float64Array>().unwrap();
+                        let slot1 = slot1.as_any().downcast_ref::<Float64Array>().unwrap();
                         assert_eq!(slot1.len(), 1);
                         let value1 = slot1.value(0);
 
-                        let slot2 =
-                            slot2.as_any().downcast_ref::<Float64Array>().unwrap();
+                        let slot2 = slot2.as_any().downcast_ref::<Float64Array>().unwrap();
                         assert_eq!(slot2.len(), 1);
                         let value2 = slot2.value(0);
                         assert_eq!(value1, value2);
diff --git a/arrow-select/src/interleave.rs b/arrow-select/src/interleave.rs
new file mode 100644
index 000000000000..8229a8f3fe09
--- /dev/null
+++ b/arrow-select/src/interleave.rs
@@ -0,0 +1,405 @@
+// 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.
+
+use crate::dictionary::{merge_dictionary_values, should_merge_dictionary_values};
+use arrow_array::builder::{BooleanBufferBuilder, BufferBuilder, PrimitiveBuilder};
+use arrow_array::cast::AsArray;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::{ArrowNativeType, MutableBuffer, NullBuffer, NullBufferBuilder, OffsetBuffer};
+use arrow_data::transform::MutableArrayData;
+use arrow_schema::{ArrowError, DataType};
+use std::sync::Arc;
+
+macro_rules! primitive_helper {
+    ($t:ty, $values:ident, $indices:ident, $data_type:ident) => {
+        interleave_primitive::<$t>($values, $indices, $data_type)
+    };
+}
+
+macro_rules! dict_helper {
+    ($t:ty, $values:expr, $indices:expr) => {
+        Ok(Arc::new(interleave_dictionaries::<$t>($values, $indices)?) as _)
+    };
+}
+
+///
+/// Takes elements by index from a list of [`Array`], creating a new [`Array`] from those values.
+///
+/// Each element in `indices` is a pair of `usize` with the first identifying the index
+/// of the [`Array`] in `values`, and the second the index of the value within that [`Array`]
+///
+/// ```text
+/// ┌─────────────────┐      ┌─────────┐                                  ┌─────────────────┐
+/// │        A        │      │ (0, 0)  │        interleave(               │        A        │
+/// ├─────────────────┤      ├─────────┤          [values0, values1],     ├─────────────────┤
+/// │        D        │      │ (1, 0)  │          indices                 │        B        │
+/// └─────────────────┘      ├─────────┤        )                         ├─────────────────┤
+///   values array 0         │ (1, 1)  │      ─────────────────────────▶  │        C        │
+///                          ├─────────┤                                  ├─────────────────┤
+///                          │ (0, 1)  │                                  │        D        │
+///                          └─────────┘                                  └─────────────────┘
+/// ┌─────────────────┐       indices
+/// │        B        │        array
+/// ├─────────────────┤                                                    result
+/// │        C        │
+/// ├─────────────────┤
+/// │        E        │
+/// └─────────────────┘
+///   values array 1
+/// ```
+///
+/// For selecting values by index from a single array see [`crate::interleave`]
+pub fn interleave(
+    values: &[&dyn Array],
+    indices: &[(usize, usize)],
+) -> Result<ArrayRef, ArrowError> {
+    if values.is_empty() {
+        return Err(ArrowError::InvalidArgumentError(
+            "interleave requires input of at least one array".to_string(),
+        ));
+    }
+    let data_type = values[0].data_type();
+
+    for array in values.iter().skip(1) {
+        if array.data_type() != data_type {
+            return Err(ArrowError::InvalidArgumentError(format!(
+                "It is not possible to interleave arrays of different data types ({} and {})",
+                data_type,
+                array.data_type()
+            )));
+        }
+    }
+
+    if indices.is_empty() {
+        return Ok(new_empty_array(data_type));
+    }
+
+    downcast_primitive! {
+        data_type => (primitive_helper, values, indices, data_type),
+        DataType::Utf8 => interleave_bytes::<Utf8Type>(values, indices),
+        DataType::LargeUtf8 => interleave_bytes::<LargeUtf8Type>(values, indices),
+        DataType::Binary => interleave_bytes::<BinaryType>(values, indices),
+        DataType::LargeBinary => interleave_bytes::<LargeBinaryType>(values, indices),
+        DataType::Dictionary(k, _) => downcast_integer! {
+            k.as_ref() => (dict_helper, values, indices),
+            _ => unreachable!("illegal dictionary key type {k}")
+        },
+        _ => interleave_fallback(values, indices)
+    }
+}
+
+/// Common functionality for interleaving arrays
+///
+/// T is the concrete Array type
+struct Interleave<'a, T> {
+    /// The input arrays downcast to T
+    arrays: Vec<&'a T>,
+    /// The null buffer of the interleaved output
+    nulls: Option<NullBuffer>,
+}
+
+impl<'a, T: Array + 'static> Interleave<'a, T> {
+    fn new(values: &[&'a dyn Array], indices: &'a [(usize, usize)]) -> Self {
+        let mut has_nulls = false;
+        let arrays: Vec<&T> = values
+            .iter()
+            .map(|x| {
+                has_nulls = has_nulls || x.null_count() != 0;
+                x.as_any().downcast_ref().unwrap()
+            })
+            .collect();
+
+        let nulls = match has_nulls {
+            true => {
+                let mut builder = NullBufferBuilder::new(indices.len());
+                for (a, b) in indices {
+                    let v = arrays[*a].is_valid(*b);
+                    builder.append(v)
+                }
+                builder.finish()
+            }
+            false => None,
+        };
+
+        Self { arrays, nulls }
+    }
+}
+
+fn interleave_primitive<T: ArrowPrimitiveType>(
+    values: &[&dyn Array],
+    indices: &[(usize, usize)],
+    data_type: &DataType,
+) -> Result<ArrayRef, ArrowError> {
+    let interleaved = Interleave::<'_, PrimitiveArray<T>>::new(values, indices);
+
+    let mut values = Vec::with_capacity(indices.len());
+    for (a, b) in indices {
+        let v = interleaved.arrays[*a].value(*b);
+        values.push(v)
+    }
+
+    let array = PrimitiveArray::<T>::new(values.into(), interleaved.nulls);
+    Ok(Arc::new(array.with_data_type(data_type.clone())))
+}
+
+fn interleave_bytes<T: ByteArrayType>(
+    values: &[&dyn Array],
+    indices: &[(usize, usize)],
+) -> Result<ArrayRef, ArrowError> {
+    let interleaved = Interleave::<'_, GenericByteArray<T>>::new(values, indices);
+
+    let mut capacity = 0;
+    let mut offsets = BufferBuilder::<T::Offset>::new(indices.len() + 1);
+    offsets.append(T::Offset::from_usize(0).unwrap());
+    for (a, b) in indices {
+        let o = interleaved.arrays[*a].value_offsets();
+        let element_len = o[*b + 1].as_usize() - o[*b].as_usize();
+        capacity += element_len;
+        offsets.append(T::Offset::from_usize(capacity).expect("overflow"));
+    }
+
+    let mut values = MutableBuffer::new(capacity);
+    for (a, b) in indices {
+        values.extend_from_slice(interleaved.arrays[*a].value(*b).as_ref());
+    }
+
+    // Safety: safe by construction
+    let array = unsafe {
+        let offsets = OffsetBuffer::new_unchecked(offsets.finish().into());
+        GenericByteArray::<T>::new_unchecked(offsets, values.into(), interleaved.nulls)
+    };
+    Ok(Arc::new(array))
+}
+
+fn interleave_dictionaries<K: ArrowDictionaryKeyType>(
+    arrays: &[&dyn Array],
+    indices: &[(usize, usize)],
+) -> Result<ArrayRef, ArrowError> {
+    let dictionaries: Vec<_> = arrays.iter().map(|x| x.as_dictionary::<K>()).collect();
+    if !should_merge_dictionary_values::<K>(&dictionaries, indices.len()) {
+        return interleave_fallback(arrays, indices);
+    }
+
+    let masks: Vec<_> = dictionaries
+        .iter()
+        .enumerate()
+        .map(|(a_idx, dictionary)| {
+            let mut key_mask = BooleanBufferBuilder::new_from_buffer(
+                MutableBuffer::new_null(dictionary.len()),
+                dictionary.len(),
+            );
+
+            for (_, key_idx) in indices.iter().filter(|(a, _)| *a == a_idx) {
+                key_mask.set_bit(*key_idx, true);
+            }
+            key_mask.finish()
+        })
+        .collect();
+
+    let merged = merge_dictionary_values(&dictionaries, Some(&masks))?;
+
+    // Recompute keys
+    let mut keys = PrimitiveBuilder::<K>::with_capacity(indices.len());
+    for (a, b) in indices {
+        let old_keys: &PrimitiveArray<K> = dictionaries[*a].keys();
+        match old_keys.is_valid(*b) {
+            true => {
+                let old_key = old_keys.values()[*b];
+                keys.append_value(merged.key_mappings[*a][old_key.as_usize()])
+            }
+            false => keys.append_null(),
+        }
+    }
+    let array = unsafe { DictionaryArray::new_unchecked(keys.finish(), merged.values) };
+    Ok(Arc::new(array))
+}
+
+/// Fallback implementation of interleave using [`MutableArrayData`]
+fn interleave_fallback(
+    values: &[&dyn Array],
+    indices: &[(usize, usize)],
+) -> Result<ArrayRef, ArrowError> {
+    let arrays: Vec<_> = values.iter().map(|x| x.to_data()).collect();
+    let arrays: Vec<_> = arrays.iter().collect();
+    let mut array_data = MutableArrayData::new(arrays, false, indices.len());
+
+    let mut cur_array = indices[0].0;
+    let mut start_row_idx = indices[0].1;
+    let mut end_row_idx = start_row_idx + 1;
+
+    for (array, row) in indices.iter().skip(1).copied() {
+        if array == cur_array && row == end_row_idx {
+            // subsequent row in same batch
+            end_row_idx += 1;
+            continue;
+        }
+
+        // emit current batch of rows for current buffer
+        array_data.extend(cur_array, start_row_idx, end_row_idx);
+
+        // start new batch of rows
+        cur_array = array;
+        start_row_idx = row;
+        end_row_idx = start_row_idx + 1;
+    }
+
+    // emit final batch of rows
+    array_data.extend(cur_array, start_row_idx, end_row_idx);
+    Ok(make_array(array_data.freeze()))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::builder::{Int32Builder, ListBuilder};
+    use arrow_array::cast::AsArray;
+    use arrow_array::types::Int32Type;
+    use arrow_array::{Int32Array, ListArray, StringArray};
+    use arrow_schema::DataType;
+
+    #[test]
+    fn test_primitive() {
+        let a = Int32Array::from_iter_values([1, 2, 3, 4]);
+        let b = Int32Array::from_iter_values([5, 6, 7]);
+        let c = Int32Array::from_iter_values([8, 9, 10]);
+        let values = interleave(&[&a, &b, &c], &[(0, 3), (0, 3), (2, 2), (2, 0), (1, 1)]).unwrap();
+        let v = values.as_primitive::<Int32Type>();
+        assert_eq!(v.values(), &[4, 4, 10, 8, 6]);
+    }
+
+    #[test]
+    fn test_primitive_nulls() {
+        let a = Int32Array::from_iter_values([1, 2, 3, 4]);
+        let b = Int32Array::from_iter([Some(1), Some(4), None]);
+        let values = interleave(&[&a, &b], &[(0, 1), (1, 2), (1, 2), (0, 3), (0, 2)]).unwrap();
+        let v: Vec<_> = values.as_primitive::<Int32Type>().into_iter().collect();
+        assert_eq!(&v, &[Some(2), None, None, Some(4), Some(3)])
+    }
+
+    #[test]
+    fn test_primitive_empty() {
+        let a = Int32Array::from_iter_values([1, 2, 3, 4]);
+        let v = interleave(&[&a], &[]).unwrap();
+        assert!(v.is_empty());
+        assert_eq!(v.data_type(), &DataType::Int32);
+    }
+
+    #[test]
+    fn test_strings() {
+        let a = StringArray::from_iter_values(["a", "b", "c"]);
+        let b = StringArray::from_iter_values(["hello", "world", "foo"]);
+        let values = interleave(&[&a, &b], &[(0, 2), (0, 2), (1, 0), (1, 1), (0, 1)]).unwrap();
+        let v = values.as_string::<i32>();
+        let values: Vec<_> = v.into_iter().collect();
+        assert_eq!(
+            &values,
+            &[
+                Some("c"),
+                Some("c"),
+                Some("hello"),
+                Some("world"),
+                Some("b")
+            ]
+        )
+    }
+
+    #[test]
+    fn test_interleave_dictionary() {
+        let a = DictionaryArray::<Int32Type>::from_iter(["a", "b", "c", "a", "b"]);
+        let b = DictionaryArray::<Int32Type>::from_iter(["a", "c", "a", "c", "a"]);
+
+        // Should not recompute dictionary
+        let values =
+            interleave(&[&a, &b], &[(0, 2), (0, 2), (0, 2), (1, 0), (1, 1), (0, 1)]).unwrap();
+        let v = values.as_dictionary::<Int32Type>();
+        assert_eq!(v.values().len(), 5);
+
+        let vc = v.downcast_dict::<StringArray>().unwrap();
+        let collected: Vec<_> = vc.into_iter().map(Option::unwrap).collect();
+        assert_eq!(&collected, &["c", "c", "c", "a", "c", "b"]);
+
+        // Should recompute dictionary
+        let values = interleave(&[&a, &b], &[(0, 2), (0, 2), (1, 1)]).unwrap();
+        let v = values.as_dictionary::<Int32Type>();
+        assert_eq!(v.values().len(), 1);
+
+        let vc = v.downcast_dict::<StringArray>().unwrap();
+        let collected: Vec<_> = vc.into_iter().map(Option::unwrap).collect();
+        assert_eq!(&collected, &["c", "c", "c"]);
+    }
+
+    #[test]
+    fn test_lists() {
+        // [[1, 2], null, [3]]
+        let mut a = ListBuilder::new(Int32Builder::new());
+        a.values().append_value(1);
+        a.values().append_value(2);
+        a.append(true);
+        a.append(false);
+        a.values().append_value(3);
+        a.append(true);
+        let a = a.finish();
+
+        // [[4], null, [5, 6, null]]
+        let mut b = ListBuilder::new(Int32Builder::new());
+        b.values().append_value(4);
+        b.append(true);
+        b.append(false);
+        b.values().append_value(5);
+        b.values().append_value(6);
+        b.values().append_null();
+        b.append(true);
+        let b = b.finish();
+
+        let values = interleave(&[&a, &b], &[(0, 2), (0, 1), (1, 0), (1, 2), (1, 1)]).unwrap();
+        let v = values.as_any().downcast_ref::<ListArray>().unwrap();
+
+        // [[3], null, [4], [5, 6, null], null]
+        let mut expected = ListBuilder::new(Int32Builder::new());
+        expected.values().append_value(3);
+        expected.append(true);
+        expected.append(false);
+        expected.values().append_value(4);
+        expected.append(true);
+        expected.values().append_value(5);
+        expected.values().append_value(6);
+        expected.values().append_null();
+        expected.append(true);
+        expected.append(false);
+        let expected = expected.finish();
+
+        assert_eq!(v, &expected);
+    }
+
+    #[test]
+    fn interleave_sparse_nulls() {
+        let values = StringArray::from_iter_values((0..100).map(|x| x.to_string()));
+        let keys = Int32Array::from_iter_values(0..10);
+        let dict_a = DictionaryArray::new(keys, Arc::new(values));
+        let values = StringArray::new_null(0);
+        let keys = Int32Array::new_null(10);
+        let dict_b = DictionaryArray::new(keys, Arc::new(values));
+
+        let indices = &[(0, 0), (0, 1), (0, 2), (1, 0)];
+        let array = interleave(&[&dict_a, &dict_b], indices).unwrap();
+
+        let expected =
+            DictionaryArray::<Int32Type>::from_iter(vec![Some("0"), Some("1"), Some("2"), None]);
+        assert_eq!(array.as_ref(), &expected)
+    }
+}
diff --git a/arrow-select/src/lib.rs b/arrow-select/src/lib.rs
new file mode 100644
index 000000000000..82f57a6af42b
--- /dev/null
+++ b/arrow-select/src/lib.rs
@@ -0,0 +1,27 @@
+// 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.
+
+//! Arrow selection kernels
+
+pub mod concat;
+mod dictionary;
+pub mod filter;
+pub mod interleave;
+pub mod nullif;
+pub mod take;
+pub mod window;
+pub mod zip;
diff --git a/arrow-select/src/nullif.rs b/arrow-select/src/nullif.rs
new file mode 100644
index 000000000000..4025a5bacf80
--- /dev/null
+++ b/arrow-select/src/nullif.rs
@@ -0,0 +1,510 @@
+// 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.
+
+use arrow_array::{make_array, Array, ArrayRef, BooleanArray};
+use arrow_buffer::buffer::{bitwise_bin_op_helper, bitwise_unary_op_helper};
+use arrow_buffer::{BooleanBuffer, NullBuffer};
+use arrow_schema::{ArrowError, DataType};
+
+/// Copies original array, setting validity bit to false if a secondary comparison
+/// boolean array is set to true
+///
+/// Typically used to implement NULLIF.
+pub fn nullif(left: &dyn Array, right: &BooleanArray) -> Result<ArrayRef, ArrowError> {
+    let left_data = left.to_data();
+
+    if left_data.len() != right.len() {
+        return Err(ArrowError::ComputeError(
+            "Cannot perform comparison operation on arrays of different length".to_string(),
+        ));
+    }
+    let len = left_data.len();
+
+    if len == 0 || left_data.data_type() == &DataType::Null {
+        return Ok(make_array(left_data));
+    }
+
+    // left=0 (null)   right=null       output bitmap=null
+    // left=0          right=1          output bitmap=null
+    // left=1 (set)    right=null       output bitmap=set   (passthrough)
+    // left=1          right=1 & comp=true    output bitmap=null
+    // left=1          right=1 & comp=false   output bitmap=set
+    //
+    // Thus: result = left null bitmap & (!right_values | !right_bitmap)
+    //              OR left null bitmap & !(right_values & right_bitmap)
+
+    // Compute right_values & right_bitmap
+    let right = match right.nulls() {
+        Some(nulls) => right.values() & nulls.inner(),
+        None => right.values().clone(),
+    };
+
+    // Compute left null bitmap & !right
+
+    let (combined, null_count) = match left_data.nulls() {
+        Some(left) => {
+            let mut valid_count = 0;
+            let b = bitwise_bin_op_helper(
+                left.buffer(),
+                left.offset(),
+                right.inner(),
+                right.offset(),
+                len,
+                |l, r| {
+                    let t = l & !r;
+                    valid_count += t.count_ones() as usize;
+                    t
+                },
+            );
+            (b, len - valid_count)
+        }
+        None => {
+            let mut null_count = 0;
+            let buffer = bitwise_unary_op_helper(right.inner(), right.offset(), len, |b| {
+                let t = !b;
+                null_count += t.count_zeros() as usize;
+                t
+            });
+            (buffer, null_count)
+        }
+    };
+
+    let combined = BooleanBuffer::new(combined, 0, len);
+    // Safety:
+    // Counted nulls whilst computing
+    let nulls = unsafe { NullBuffer::new_unchecked(combined, null_count) };
+    let data = left_data.into_builder().nulls(Some(nulls));
+
+    // SAFETY:
+    // Only altered null mask
+    Ok(make_array(unsafe { data.build_unchecked() }))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::builder::{BooleanBuilder, Int32Builder, StructBuilder};
+    use arrow_array::cast::AsArray;
+    use arrow_array::types::Int32Type;
+    use arrow_array::{Int32Array, NullArray, StringArray, StructArray};
+    use arrow_data::ArrayData;
+    use arrow_schema::{DataType, Field, Fields};
+    use rand::{thread_rng, Rng};
+
+    #[test]
+    fn test_nullif_int_array() {
+        let a = Int32Array::from(vec![Some(15), None, Some(8), Some(1), Some(9)]);
+        let comp = BooleanArray::from(vec![Some(false), None, Some(true), Some(false), None]);
+        let res = nullif(&a, &comp).unwrap();
+
+        let expected = Int32Array::from(vec![
+            Some(15),
+            None,
+            None, // comp true, slot 2 turned into null
+            Some(1),
+            // Even though comp array / right is null, should still pass through original value
+            // comp true, slot 2 turned into null
+            Some(9),
+        ]);
+
+        let res = res.as_primitive::<Int32Type>();
+        assert_eq!(&expected, res);
+    }
+
+    #[test]
+    fn test_nullif_null_array() {
+        assert_eq!(
+            nullif(&NullArray::new(0), &BooleanArray::new_null(0))
+                .unwrap()
+                .as_ref(),
+            &NullArray::new(0)
+        );
+
+        assert_eq!(
+            nullif(
+                &NullArray::new(3),
+                &BooleanArray::from(vec![Some(false), Some(true), None]),
+            )
+            .unwrap()
+            .as_ref(),
+            &NullArray::new(3)
+        );
+    }
+
+    #[test]
+    fn test_nullif_int_array_offset() {
+        let a = Int32Array::from(vec![None, Some(15), Some(8), Some(1), Some(9)]);
+        let a = a.slice(1, 3); // Some(15), Some(8), Some(1)
+        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
+        let comp = BooleanArray::from(vec![
+            Some(false),
+            Some(false),
+            Some(false),
+            None,
+            Some(true),
+            Some(false),
+            None,
+        ]);
+        let comp = comp.slice(2, 3); // Some(false), None, Some(true)
+        let comp = comp.as_any().downcast_ref::<BooleanArray>().unwrap();
+        let res = nullif(a, comp).unwrap();
+
+        let expected = Int32Array::from(vec![
+            Some(15), // False => keep it
+            Some(8),  // None => keep it
+            None,     // true => None
+        ]);
+        let res = res.as_primitive::<Int32Type>();
+        assert_eq!(&expected, res)
+    }
+
+    #[test]
+    fn test_nullif_string() {
+        let s = StringArray::from_iter([
+            Some("hello"),
+            None,
+            Some("world"),
+            Some("a"),
+            Some("b"),
+            None,
+            None,
+        ]);
+        let select = BooleanArray::from_iter([
+            Some(true),
+            Some(true),
+            Some(false),
+            Some(true),
+            Some(false),
+            Some(false),
+            None,
+        ]);
+
+        let a = nullif(&s, &select).unwrap();
+        let r: Vec<_> = a.as_string::<i32>().iter().collect();
+        assert_eq!(
+            r,
+            vec![None, None, Some("world"), None, Some("b"), None, None]
+        );
+
+        let s = s.slice(2, 3);
+        let select = select.slice(1, 3);
+        let a = nullif(&s, &select).unwrap();
+        let r: Vec<_> = a.as_string::<i32>().iter().collect();
+        assert_eq!(r, vec![None, Some("a"), None]);
+    }
+
+    #[test]
+    fn test_nullif_int_large_left_offset() {
+        let a = Int32Array::from(vec![
+            Some(-1), // 0
+            Some(-1),
+            Some(-1),
+            Some(-1),
+            Some(-1),
+            Some(-1),
+            Some(-1),
+            Some(-1),
+            Some(-1), // 8
+            Some(-1),
+            Some(-1),
+            Some(-1),
+            Some(-1),
+            Some(-1),
+            Some(-1),
+            Some(-1),
+            None,     // 16
+            Some(15), // 17
+            Some(8),
+            Some(1),
+            Some(9),
+        ]);
+        let a = a.slice(17, 3); // Some(15), Some(8), Some(1)
+
+        let comp = BooleanArray::from(vec![
+            Some(false),
+            Some(false),
+            Some(false),
+            None,
+            Some(true),
+            Some(false),
+            None,
+        ]);
+        let comp = comp.slice(2, 3); // Some(false), None, Some(true)
+        let comp = comp.as_any().downcast_ref::<BooleanArray>().unwrap();
+        let res = nullif(&a, comp).unwrap();
+        let res = res.as_any().downcast_ref::<Int32Array>().unwrap();
+
+        let expected = Int32Array::from(vec![
+            Some(15), // False => keep it
+            Some(8),  // None => keep it
+            None,     // true => None
+        ]);
+        assert_eq!(&expected, res)
+    }
+
+    #[test]
+    fn test_nullif_int_large_right_offset() {
+        let a = Int32Array::from(vec![
+            None,     // 0
+            Some(15), // 1
+            Some(8),
+            Some(1),
+            Some(9),
+        ]);
+        let a = a.slice(1, 3); // Some(15), Some(8), Some(1)
+
+        let comp = BooleanArray::from(vec![
+            Some(false), // 0
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false), // 8
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false),
+            Some(false), // 16
+            Some(false), // 17
+            Some(false), // 18
+            None,
+            Some(true),
+            Some(false),
+            None,
+        ]);
+        let comp = comp.slice(18, 3); // Some(false), None, Some(true)
+        let comp = comp.as_any().downcast_ref::<BooleanArray>().unwrap();
+        let res = nullif(&a, comp).unwrap();
+        let res = res.as_any().downcast_ref::<Int32Array>().unwrap();
+
+        let expected = Int32Array::from(vec![
+            Some(15), // False => keep it
+            Some(8),  // None => keep it
+            None,     // true => None
+        ]);
+        assert_eq!(&expected, res)
+    }
+
+    #[test]
+    fn test_nullif_boolean_offset() {
+        let a = BooleanArray::from(vec![
+            None,       // 0
+            Some(true), // 1
+            Some(false),
+            Some(true),
+            Some(true),
+        ]);
+        let a = a.slice(1, 3); // Some(true), Some(false), Some(true)
+
+        let comp = BooleanArray::from(vec![
+            Some(false), // 0
+            Some(false), // 1
+            Some(false), // 2
+            None,
+            Some(true),
+            Some(false),
+            None,
+        ]);
+        let comp = comp.slice(2, 3); // Some(false), None, Some(true)
+        let comp = comp.as_any().downcast_ref::<BooleanArray>().unwrap();
+        let res = nullif(&a, comp).unwrap();
+        let res = res.as_any().downcast_ref::<BooleanArray>().unwrap();
+
+        let expected = BooleanArray::from(vec![
+            Some(true),  // False => keep it
+            Some(false), // None => keep it
+            None,        // true => None
+        ]);
+        assert_eq!(&expected, res)
+    }
+
+    struct Foo {
+        a: Option<i32>,
+        b: Option<bool>,
+        /// Whether the entry should be valid.
+        is_valid: bool,
+    }
+
+    impl Foo {
+        fn new_valid(a: i32, b: bool) -> Foo {
+            Self {
+                a: Some(a),
+                b: Some(b),
+                is_valid: true,
+            }
+        }
+
+        fn new_null() -> Foo {
+            Self {
+                a: None,
+                b: None,
+                is_valid: false,
+            }
+        }
+    }
+
+    /// Struct Array equality is a bit weird -- we need to have the *child values*
+    /// correct even if the enclosing struct indicates it is null. But we
+    /// also need the top level is_valid bits to be correct.
+    fn create_foo_struct(values: Vec<Foo>) -> StructArray {
+        let mut struct_array = StructBuilder::new(
+            Fields::from(vec![
+                Field::new("a", DataType::Int32, true),
+                Field::new("b", DataType::Boolean, true),
+            ]),
+            vec![
+                Box::new(Int32Builder::with_capacity(values.len())),
+                Box::new(BooleanBuilder::with_capacity(values.len())),
+            ],
+        );
+
+        for value in values {
+            struct_array
+                .field_builder::<Int32Builder>(0)
+                .unwrap()
+                .append_option(value.a);
+            struct_array
+                .field_builder::<BooleanBuilder>(1)
+                .unwrap()
+                .append_option(value.b);
+            struct_array.append(value.is_valid);
+        }
+
+        struct_array.finish()
+    }
+
+    #[test]
+    fn test_nullif_struct_slices() {
+        let struct_array = create_foo_struct(vec![
+            Foo::new_valid(7, true),
+            Foo::new_valid(15, false),
+            Foo::new_valid(8, true),
+            Foo::new_valid(12, false),
+            Foo::new_null(),
+            Foo::new_null(),
+            Foo::new_valid(42, true),
+        ]);
+
+        // Some({a: 15, b: false}), Some({a: 8, b: true}), Some({a: 12, b: false}),
+        // None, None
+        let struct_array = struct_array.slice(1, 5);
+        let comp = BooleanArray::from(vec![
+            Some(false), // 0
+            Some(false), // 1
+            Some(false), // 2
+            None,
+            Some(true),
+            Some(false),
+            None,
+        ]);
+        let comp = comp.slice(2, 5); // Some(false), None, Some(true), Some(false), None
+        let comp = comp.as_any().downcast_ref::<BooleanArray>().unwrap();
+        let res = nullif(&struct_array, comp).unwrap();
+        let res = res.as_any().downcast_ref::<StructArray>().unwrap();
+
+        let expected = create_foo_struct(vec![
+            // Some(false) -> keep
+            Foo::new_valid(15, false),
+            // None -> keep
+            Foo::new_valid(8, true),
+            // Some(true) -> null out. But child values are still there.
+            Foo {
+                a: Some(12),
+                b: Some(false),
+                is_valid: false,
+            },
+            // Some(false) -> keep, but was null
+            Foo::new_null(),
+            // None -> keep, but was null
+            Foo::new_null(),
+        ]);
+
+        assert_eq!(&expected, res);
+    }
+
+    #[test]
+    fn test_nullif_no_nulls() {
+        let a = Int32Array::from(vec![Some(15), Some(7), Some(8), Some(1), Some(9)]);
+        let comp = BooleanArray::from(vec![Some(false), None, Some(true), Some(false), None]);
+        let res = nullif(&a, &comp).unwrap();
+        let res = res.as_primitive::<Int32Type>();
+
+        let expected = Int32Array::from(vec![Some(15), Some(7), None, Some(1), Some(9)]);
+        assert_eq!(res, &expected);
+    }
+
+    #[test]
+    fn nullif_empty() {
+        let a = Int32Array::from(ArrayData::new_empty(&DataType::Int32));
+        let mask = BooleanArray::from(ArrayData::new_empty(&DataType::Boolean));
+        let res = nullif(&a, &mask).unwrap();
+        assert_eq!(res.as_ref(), &a);
+    }
+
+    fn test_nullif(values: &Int32Array, filter: &BooleanArray) {
+        let expected: Int32Array = values
+            .iter()
+            .zip(filter.iter())
+            .map(|(a, b)| match b {
+                Some(true) => None,
+                Some(false) | None => a,
+            })
+            .collect();
+
+        let r = nullif(values, filter).unwrap();
+        let r_data = r.to_data();
+        r_data.validate().unwrap();
+
+        assert_eq!(r.as_ref(), &expected);
+    }
+
+    #[test]
+    fn nullif_fuzz() {
+        let mut rng = thread_rng();
+
+        let arrays = [
+            Int32Array::from(vec![0; 128]),
+            (0..128).map(|_| rng.gen_bool(0.5).then_some(0)).collect(),
+        ];
+
+        for a in arrays {
+            let a_slices = [(0, 128), (64, 64), (0, 64), (32, 32), (0, 0), (32, 0)];
+
+            for (a_offset, a_length) in a_slices {
+                let a = a.slice(a_offset, a_length);
+
+                for i in 1..65 {
+                    let b_start_offset = rng.gen_range(0..i);
+                    let b_end_offset = rng.gen_range(0..i);
+
+                    let b: BooleanArray = (0..a_length + b_start_offset + b_end_offset)
+                        .map(|_| rng.gen_bool(0.5).then(|| rng.gen_bool(0.5)))
+                        .collect();
+                    let b = b.slice(b_start_offset, a_length);
+
+                    test_nullif(&a, &b);
+                }
+            }
+        }
+    }
+}
diff --git a/arrow/src/compute/kernels/take.rs b/arrow-select/src/take.rs
similarity index 59%
rename from arrow/src/compute/kernels/take.rs
rename to arrow-select/src/take.rs
index fb8f75651882..d9a639da8066 100644
--- a/arrow/src/compute/kernels/take.rs
+++ b/arrow-select/src/take.rs
@@ -17,39 +17,19 @@
 
 //! Defines take kernel for [Array]
 
-use std::{ops::AddAssign, sync::Arc};
-
-use crate::buffer::{Buffer, MutableBuffer};
-use crate::compute::util::{
-    take_value_indices_from_fixed_size_list, take_value_indices_from_list,
+use std::sync::Arc;
+
+use arrow_array::builder::{BufferBuilder, UInt32Builder};
+use arrow_array::cast::AsArray;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::{
+    bit_util, ArrowNativeType, BooleanBuffer, Buffer, MutableBuffer, NullBuffer, ScalarBuffer,
 };
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-use crate::util::bit_util;
-use crate::{array::*, buffer::buffer_bin_and};
-
-use num::{ToPrimitive, Zero};
-use TimeUnit::*;
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType, FieldRef, UnionMode};
 
-macro_rules! downcast_take {
-    ($type: ty, $values: expr, $indices: expr) => {{
-        let values = $values
-            .as_any()
-            .downcast_ref::<PrimitiveArray<$type>>()
-            .expect("Unable to downcast to a primitive array");
-        Ok(Arc::new(take_primitive::<$type, _>(&values, $indices)?))
-    }};
-}
-
-macro_rules! downcast_dict_take {
-    ($type: ty, $values: expr, $indices: expr) => {{
-        let values = $values
-            .as_any()
-            .downcast_ref::<DictionaryArray<$type>>()
-            .expect("Unable to downcast to a dictionary array");
-        Ok(Arc::new(take_dict::<$type, _>(values, $indices)?))
-    }};
-}
+use num::{One, Zero};
 
 /// Take elements by index from [Array], creating a new [Array] from those indexes.
 ///
@@ -58,181 +38,116 @@ macro_rules! downcast_dict_take {
 /// │        A        │      │    0    │                              │        A        │
 /// ├─────────────────┤      ├─────────┤                              ├─────────────────┤
 /// │        D        │      │    2    │                              │        B        │
-/// ├─────────────────┤      ├─────────┤   take(values, indicies)     ├─────────────────┤
+/// ├─────────────────┤      ├─────────┤   take(values, indices)      ├─────────────────┤
 /// │        B        │      │    3    │ ─────────────────────────▶   │        C        │
 /// ├─────────────────┤      ├─────────┤                              ├─────────────────┤
 /// │        C        │      │    1    │                              │        D        │
 /// ├─────────────────┤      └─────────┘                              └─────────────────┘
 /// │        E        │
 /// └─────────────────┘
-///    values array            indicies array                              result
+///    values array          indices array                              result
 /// ```
 ///
+/// For selecting values by index from multiple arrays see [`crate::interleave`]
+///
 /// # Errors
 /// This function errors whenever:
 /// * An index cannot be casted to `usize` (typically 32 bit architectures)
 /// * An index is out of bounds and `options` is set to check bounds.
+///
 /// # Safety
-/// When `options` is not set to check bounds (default), taking indexes after `len` is undefined behavior.
+///
+/// When `options` is not set to check bounds, taking indexes after `len` will panic.
+///
 /// # Examples
 /// ```
-/// use arrow::array::{StringArray, UInt32Array};
-/// use arrow::error::Result;
-/// use arrow::compute::take;
-/// # fn main() -> Result<()> {
+/// # use arrow_array::{StringArray, UInt32Array, cast::AsArray};
+/// # use arrow_select::take::take;
 /// let values = StringArray::from(vec!["zero", "one", "two"]);
 ///
 /// // Take items at index 2, and 1:
 /// let indices = UInt32Array::from(vec![2, 1]);
-/// let taken = take(&values, &indices, None)?;
-/// let taken = taken.as_any().downcast_ref::<StringArray>().unwrap();
+/// let taken = take(&values, &indices, None).unwrap();
+/// let taken = taken.as_string::<i32>();
 ///
 /// assert_eq!(*taken, StringArray::from(vec!["two", "one"]));
-/// # Ok(())
-/// # }
 /// ```
-pub fn take<IndexType>(
+pub fn take(
     values: &dyn Array,
-    indices: &PrimitiveArray<IndexType>,
+    indices: &dyn Array,
     options: Option<TakeOptions>,
-) -> Result<ArrayRef>
-where
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-{
-    take_impl(values, indices, options)
+) -> Result<ArrayRef, ArrowError> {
+    let options = options.unwrap_or_default();
+    macro_rules! helper {
+        ($t:ty, $values:expr, $indices:expr, $options:expr) => {{
+            let indices = indices.as_primitive::<$t>();
+            if $options.check_bounds {
+                check_bounds($values.len(), indices)?;
+            }
+            let indices = indices.to_indices();
+            take_impl($values, &indices)
+        }};
+    }
+    downcast_integer! {
+        indices.data_type() => (helper, values, indices, options),
+        d => Err(ArrowError::InvalidArgumentError(format!("Take only supported for integers, got {d:?}")))
+    }
 }
 
-fn take_impl<IndexType>(
+/// Verifies that the non-null values of `indices` are all `< len`
+fn check_bounds<T: ArrowPrimitiveType>(
+    len: usize,
+    indices: &PrimitiveArray<T>,
+) -> Result<(), ArrowError> {
+    if indices.null_count() > 0 {
+        indices.iter().flatten().try_for_each(|index| {
+            let ix = index
+                .to_usize()
+                .ok_or_else(|| ArrowError::ComputeError("Cast to usize failed".to_string()))?;
+            if ix >= len {
+                return Err(ArrowError::ComputeError(format!(
+                    "Array index out of bounds, cannot get item at index {ix} from {len} entries"
+                )));
+            }
+            Ok(())
+        })
+    } else {
+        indices.values().iter().try_for_each(|index| {
+            let ix = index
+                .to_usize()
+                .ok_or_else(|| ArrowError::ComputeError("Cast to usize failed".to_string()))?;
+            if ix >= len {
+                return Err(ArrowError::ComputeError(format!(
+                    "Array index out of bounds, cannot get item at index {ix} from {len} entries"
+                )));
+            }
+            Ok(())
+        })
+    }
+}
+
+#[inline(never)]
+fn take_impl<IndexType: ArrowPrimitiveType>(
     values: &dyn Array,
     indices: &PrimitiveArray<IndexType>,
-    options: Option<TakeOptions>,
-) -> Result<ArrayRef>
-where
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-{
-    let options = options.unwrap_or_default();
-    if options.check_bounds {
-        let len = values.len();
-        if indices.null_count() > 0 {
-            indices.iter().flatten().try_for_each(|index| {
-                let ix = ToPrimitive::to_usize(&index).ok_or_else(|| {
-                    ArrowError::ComputeError("Cast to usize failed".to_string())
-                })?;
-                if ix >= len {
-                    return Err(ArrowError::ComputeError(
-                        format!("Array index out of bounds, cannot get item at index {} from {} entries", ix, len))
-                    );
-                }
-                Ok(())
-            })?;
-        } else {
-            indices.values().iter().try_for_each(|index| {
-                let ix = ToPrimitive::to_usize(index).ok_or_else(|| {
-                    ArrowError::ComputeError("Cast to usize failed".to_string())
-                })?;
-                if ix >= len {
-                    return Err(ArrowError::ComputeError(
-                        format!("Array index out of bounds, cannot get item at index {} from {} entries", ix, len))
-                    );
-                }
-                Ok(())
-            })?
-        }
-    }
-    match values.data_type() {
+) -> Result<ArrayRef, ArrowError> {
+    downcast_primitive_array! {
+        values => Ok(Arc::new(take_primitive(values, indices)?)),
         DataType::Boolean => {
             let values = values.as_any().downcast_ref::<BooleanArray>().unwrap();
-            Ok(Arc::new(take_boolean(values, indices)?))
-        }
-        DataType::Decimal128(_, _) => {
-            let decimal_values =
-                values.as_any().downcast_ref::<Decimal128Array>().unwrap();
-            Ok(Arc::new(take_decimal128(decimal_values, indices)?))
-        }
-        DataType::Int8 => downcast_take!(Int8Type, values, indices),
-        DataType::Int16 => downcast_take!(Int16Type, values, indices),
-        DataType::Int32 => downcast_take!(Int32Type, values, indices),
-        DataType::Int64 => downcast_take!(Int64Type, values, indices),
-        DataType::UInt8 => downcast_take!(UInt8Type, values, indices),
-        DataType::UInt16 => downcast_take!(UInt16Type, values, indices),
-        DataType::UInt32 => downcast_take!(UInt32Type, values, indices),
-        DataType::UInt64 => downcast_take!(UInt64Type, values, indices),
-        DataType::Float32 => downcast_take!(Float32Type, values, indices),
-        DataType::Float64 => downcast_take!(Float64Type, values, indices),
-        DataType::Date32 => downcast_take!(Date32Type, values, indices),
-        DataType::Date64 => downcast_take!(Date64Type, values, indices),
-        DataType::Time32(Second) => downcast_take!(Time32SecondType, values, indices),
-        DataType::Time32(Millisecond) => {
-            downcast_take!(Time32MillisecondType, values, indices)
-        }
-        DataType::Time64(Microsecond) => {
-            downcast_take!(Time64MicrosecondType, values, indices)
-        }
-        DataType::Time64(Nanosecond) => {
-            downcast_take!(Time64NanosecondType, values, indices)
-        }
-        DataType::Timestamp(Second, _) => {
-            downcast_take!(TimestampSecondType, values, indices)
-        }
-        DataType::Timestamp(Millisecond, _) => {
-            downcast_take!(TimestampMillisecondType, values, indices)
-        }
-        DataType::Timestamp(Microsecond, _) => {
-            downcast_take!(TimestampMicrosecondType, values, indices)
-        }
-        DataType::Timestamp(Nanosecond, _) => {
-            downcast_take!(TimestampNanosecondType, values, indices)
-        }
-        DataType::Interval(IntervalUnit::YearMonth) => {
-            downcast_take!(IntervalYearMonthType, values, indices)
-        }
-        DataType::Interval(IntervalUnit::DayTime) => {
-            downcast_take!(IntervalDayTimeType, values, indices)
-        }
-        DataType::Interval(IntervalUnit::MonthDayNano) => {
-            downcast_take!(IntervalMonthDayNanoType, values, indices)
-        }
-        DataType::Duration(TimeUnit::Second) => {
-            downcast_take!(DurationSecondType, values, indices)
-        }
-        DataType::Duration(TimeUnit::Millisecond) => {
-            downcast_take!(DurationMillisecondType, values, indices)
-        }
-        DataType::Duration(TimeUnit::Microsecond) => {
-            downcast_take!(DurationMicrosecondType, values, indices)
-        }
-        DataType::Duration(TimeUnit::Nanosecond) => {
-            downcast_take!(DurationNanosecondType, values, indices)
+            Ok(Arc::new(take_boolean(values, indices)))
         }
         DataType::Utf8 => {
-            let values = values
-                .as_any()
-                .downcast_ref::<GenericStringArray<i32>>()
-                .unwrap();
-            Ok(Arc::new(take_string::<i32, _>(values, indices)?))
+            Ok(Arc::new(take_bytes(values.as_string::<i32>(), indices)?))
         }
         DataType::LargeUtf8 => {
-            let values = values
-                .as_any()
-                .downcast_ref::<GenericStringArray<i64>>()
-                .unwrap();
-            Ok(Arc::new(take_string::<i64, _>(values, indices)?))
+            Ok(Arc::new(take_bytes(values.as_string::<i64>(), indices)?))
         }
         DataType::List(_) => {
-            let values = values
-                .as_any()
-                .downcast_ref::<GenericListArray<i32>>()
-                .unwrap();
-            Ok(Arc::new(take_list::<_, Int32Type>(values, indices)?))
+            Ok(Arc::new(take_list::<_, Int32Type>(values.as_list(), indices)?))
         }
         DataType::LargeList(_) => {
-            let values = values
-                .as_any()
-                .downcast_ref::<GenericListArray<i64>>()
-                .unwrap();
-            Ok(Arc::new(take_list::<_, Int64Type>(values, indices)?))
+            Ok(Arc::new(take_list::<_, Int64Type>(values.as_list(), indices)?))
         }
         DataType::FixedSizeList(_, length) => {
             let values = values
@@ -245,24 +160,28 @@ where
                 *length as u32,
             )?))
         }
+        DataType::Map(_, _) => {
+            let list_arr = ListArray::from(values.as_map().clone());
+            let list_data = take_list::<_, Int32Type>(&list_arr, indices)?;
+            let builder = list_data.into_data().into_builder().data_type(values.data_type().clone());
+            Ok(Arc::new(MapArray::from(unsafe { builder.build_unchecked() })))
+        }
         DataType::Struct(fields) => {
-            let struct_: &StructArray =
-                values.as_any().downcast_ref::<StructArray>().unwrap();
-            let arrays: Result<Vec<ArrayRef>> = struct_
+            let array: &StructArray = values.as_struct();
+            let arrays  = array
                 .columns()
                 .iter()
-                .map(|a| take_impl(a.as_ref(), indices, Some(options.clone())))
-                .collect();
-            let arrays = arrays?;
-            let fields: Vec<(Field, ArrayRef)> =
-                fields.clone().into_iter().zip(arrays).collect();
+                .map(|a| take_impl(a.as_ref(), indices))
+                .collect::<Result<Vec<ArrayRef>, _>>()?;
+            let fields: Vec<(FieldRef, ArrayRef)> =
+                fields.iter().cloned().zip(arrays).collect();
 
             // Create the null bit buffer.
             let is_valid: Buffer = indices
                 .iter()
                 .map(|index| {
                     if let Some(index) = index {
-                        struct_.is_valid(ArrowNativeType::to_usize(&index).unwrap())
+                        array.is_valid(index.to_usize().unwrap())
                     } else {
                         false
                     }
@@ -271,37 +190,26 @@ where
 
             Ok(Arc::new(StructArray::from((fields, is_valid))) as ArrayRef)
         }
-        DataType::Dictionary(key_type, _) => match key_type.as_ref() {
-            DataType::Int8 => downcast_dict_take!(Int8Type, values, indices),
-            DataType::Int16 => downcast_dict_take!(Int16Type, values, indices),
-            DataType::Int32 => downcast_dict_take!(Int32Type, values, indices),
-            DataType::Int64 => downcast_dict_take!(Int64Type, values, indices),
-            DataType::UInt8 => downcast_dict_take!(UInt8Type, values, indices),
-            DataType::UInt16 => downcast_dict_take!(UInt16Type, values, indices),
-            DataType::UInt32 => downcast_dict_take!(UInt32Type, values, indices),
-            DataType::UInt64 => downcast_dict_take!(UInt64Type, values, indices),
-            t => unimplemented!("Take not supported for dictionary key type {:?}", t),
-        },
+        DataType::Dictionary(_, _) => downcast_dictionary_array! {
+            values => Ok(Arc::new(take_dict(values, indices)?)),
+            t => unimplemented!("Take not supported for dictionary type {:?}", t)
+        }
+        DataType::RunEndEncoded(_, _) => downcast_run_array! {
+            values => Ok(Arc::new(take_run(values, indices)?)),
+            t => unimplemented!("Take not supported for run type {:?}", t)
+        }
         DataType::Binary => {
-            let values = values
-                .as_any()
-                .downcast_ref::<GenericBinaryArray<i32>>()
-                .unwrap();
-            Ok(Arc::new(take_binary(values, indices)?))
+            Ok(Arc::new(take_bytes(values.as_binary::<i32>(), indices)?))
         }
         DataType::LargeBinary => {
-            let values = values
-                .as_any()
-                .downcast_ref::<GenericBinaryArray<i64>>()
-                .unwrap();
-            Ok(Arc::new(take_binary(values, indices)?))
+            Ok(Arc::new(take_bytes(values.as_binary::<i64>(), indices)?))
         }
-        DataType::FixedSizeBinary(_) => {
+        DataType::FixedSizeBinary(size) => {
             let values = values
                 .as_any()
                 .downcast_ref::<FixedSizeBinaryArray>()
                 .unwrap();
-            Ok(Arc::new(take_fixed_size_binary(values, indices)?))
+            Ok(Arc::new(take_fixed_size_binary(values, indices, *size)?))
         }
         DataType::Null => {
             // Take applied to a null array produces a null array.
@@ -314,7 +222,22 @@ where
                 Ok(new_null_array(&DataType::Null, indices.len()))
             }
         }
-        t => unimplemented!("Take not supported for data type {:?}", t),
+        DataType::Union(fields, UnionMode::Sparse) => {
+            let mut field_type_ids = Vec::with_capacity(fields.len());
+            let mut children = Vec::with_capacity(fields.len());
+            let values = values.as_any().downcast_ref::<UnionArray>().unwrap();
+            let type_ids = take_native(values.type_ids(), indices).into_inner();
+            for (type_id, field) in fields.iter() {
+                let values = values.child(type_id);
+                let values = take_impl(values, indices)?;
+                let field = (**field).clone();
+                children.push((field, values));
+                field_type_ids.push(type_id);
+            }
+            let array = UnionArray::try_new(field_type_ids.as_slice(), type_ids, None, children)?;
+            Ok(Arc::new(array))
+        }
+        t => unimplemented!("Take not supported for data type {:?}", t)
     }
 }
 
@@ -328,216 +251,12 @@ pub struct TakeOptions {
 }
 
 #[inline(always)]
-fn maybe_usize<I: ArrowNativeType>(index: I) -> Result<usize> {
+fn maybe_usize<I: ArrowNativeType>(index: I) -> Result<usize, ArrowError> {
     index
         .to_usize()
         .ok_or_else(|| ArrowError::ComputeError("Cast to usize failed".to_string()))
 }
 
-// take implementation when neither values nor indices contain nulls
-fn take_no_nulls<T, I>(values: &[T], indices: &[I]) -> Result<(Buffer, Option<Buffer>)>
-where
-    T: ArrowNativeType,
-    I: ArrowNativeType,
-{
-    let values = indices
-        .iter()
-        .map(|index| Result::Ok(values[maybe_usize::<I>(*index)?]));
-    // Soundness: `slice.map` is `TrustedLen`.
-    let buffer = unsafe { Buffer::try_from_trusted_len_iter(values)? };
-
-    Ok((buffer, None))
-}
-
-// take implementation when only values contain nulls
-fn take_values_nulls<T, I>(
-    values: &PrimitiveArray<T>,
-    indices: &[I],
-) -> Result<(Buffer, Option<Buffer>)>
-where
-    T: ArrowPrimitiveType,
-    I: ArrowNativeType,
-{
-    take_values_nulls_inner(values.data(), values.values(), indices)
-}
-
-fn take_values_nulls_inner<T, I>(
-    values_data: &ArrayData,
-    values: &[T],
-    indices: &[I],
-) -> Result<(Buffer, Option<Buffer>)>
-where
-    T: ArrowNativeType,
-    I: ArrowNativeType,
-{
-    let num_bytes = bit_util::ceil(indices.len(), 8);
-    let mut nulls = MutableBuffer::new(num_bytes).with_bitset(num_bytes, true);
-    let null_slice = nulls.as_slice_mut();
-    let mut null_count = 0;
-
-    let values = indices.iter().enumerate().map(|(i, index)| {
-        let index = maybe_usize::<I>(*index)?;
-        if values_data.is_null(index) {
-            null_count += 1;
-            bit_util::unset_bit(null_slice, i);
-        }
-        Result::Ok(values[index])
-    });
-    // Soundness: `slice.map` is `TrustedLen`.
-    let buffer = unsafe { Buffer::try_from_trusted_len_iter(values)? };
-
-    let nulls = if null_count == 0 {
-        // if only non-null values were taken
-        None
-    } else {
-        Some(nulls.into())
-    };
-
-    Ok((buffer, nulls))
-}
-
-// take implementation when only indices contain nulls
-fn take_indices_nulls<T, I>(
-    values: &[T],
-    indices: &PrimitiveArray<I>,
-) -> Result<(Buffer, Option<Buffer>)>
-where
-    T: ArrowNativeType,
-    I: ArrowNumericType,
-    I::Native: ToPrimitive,
-{
-    take_indices_nulls_inner(values, indices.values(), indices.data())
-}
-
-fn take_indices_nulls_inner<T, I>(
-    values: &[T],
-    indices: &[I],
-    indices_data: &ArrayData,
-) -> Result<(Buffer, Option<Buffer>)>
-where
-    T: ArrowNativeType,
-    I: ArrowNativeType,
-{
-    let values = indices.iter().map(|index| {
-        let index = maybe_usize::<I>(*index)?;
-        Result::Ok(match values.get(index) {
-            Some(value) => *value,
-            None => {
-                if indices_data.is_null(index) {
-                    T::default()
-                } else {
-                    panic!("Out-of-bounds index {}", index)
-                }
-            }
-        })
-    });
-
-    // Soundness: `slice.map` is `TrustedLen`.
-    let buffer = unsafe { Buffer::try_from_trusted_len_iter(values)? };
-
-    Ok((
-        buffer,
-        indices_data
-            .null_buffer()
-            .map(|b| b.bit_slice(indices_data.offset(), indices.len())),
-    ))
-}
-
-// take implementation when both values and indices contain nulls
-fn take_values_indices_nulls<T, I>(
-    values: &PrimitiveArray<T>,
-    indices: &PrimitiveArray<I>,
-) -> Result<(Buffer, Option<Buffer>)>
-where
-    T: ArrowPrimitiveType,
-    I: ArrowNumericType,
-    I::Native: ToPrimitive,
-{
-    take_values_indices_nulls_inner(
-        values.values(),
-        values.data(),
-        indices.values(),
-        indices.data(),
-    )
-}
-
-fn take_values_indices_nulls_inner<T, I>(
-    values: &[T],
-    values_data: &ArrayData,
-    indices: &[I],
-    indices_data: &ArrayData,
-) -> Result<(Buffer, Option<Buffer>)>
-where
-    T: ArrowNativeType,
-    I: ArrowNativeType,
-{
-    let num_bytes = bit_util::ceil(indices.len(), 8);
-    let mut nulls = MutableBuffer::new(num_bytes).with_bitset(num_bytes, true);
-    let null_slice = nulls.as_slice_mut();
-    let mut null_count = 0;
-
-    let values = indices.iter().enumerate().map(|(i, &index)| {
-        if indices_data.is_null(i) {
-            null_count += 1;
-            bit_util::unset_bit(null_slice, i);
-            Ok(T::default())
-        } else {
-            let index = maybe_usize::<I>(index)?;
-            if values_data.is_null(index) {
-                null_count += 1;
-                bit_util::unset_bit(null_slice, i);
-            }
-            Result::Ok(values[index])
-        }
-    });
-    // Soundness: `slice.map` is `TrustedLen`.
-    let buffer = unsafe { Buffer::try_from_trusted_len_iter(values)? };
-
-    let nulls = if null_count == 0 {
-        // if only non-null values were taken
-        None
-    } else {
-        Some(nulls.into())
-    };
-
-    Ok((buffer, nulls))
-}
-
-/// `take` implementation for decimal arrays
-fn take_decimal128<IndexType>(
-    decimal_values: &Decimal128Array,
-    indices: &PrimitiveArray<IndexType>,
-) -> Result<Decimal128Array>
-where
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-{
-    indices
-        .iter()
-        .map(|index| {
-            // Use type annotations below for readability (was blowing
-            // my mind otherwise)
-            let t: Option<Result<Option<_>>> = index.map(|index| {
-                let index = ToPrimitive::to_usize(&index).ok_or_else(|| {
-                    ArrowError::ComputeError("Cast to usize failed".to_string())
-                })?;
-
-                if decimal_values.is_null(index) {
-                    Ok(None)
-                } else {
-                    Ok(Some(decimal_values.value(index).as_i128()))
-                }
-            });
-            let t: Result<Option<Option<_>>> = t.transpose();
-            let t: Result<Option<_>> = t.map(|t| t.flatten());
-            t
-        })
-        .collect::<Result<Decimal128Array>>()?
-        // PERF: we could avoid re-validating that the data in
-        // Decimal128Array was in range as we know it came from a valid Decimal128Array
-        .with_precision_and_scale(decimal_values.precision(), decimal_values.scale())
-}
-
 /// `take` implementation for all primitive arrays
 ///
 /// This checks if an `indices` slot is populated, and gets the value from `values`
@@ -550,252 +269,172 @@ where
 fn take_primitive<T, I>(
     values: &PrimitiveArray<T>,
     indices: &PrimitiveArray<I>,
-) -> Result<PrimitiveArray<T>>
+) -> Result<PrimitiveArray<T>, ArrowError>
 where
     T: ArrowPrimitiveType,
-    I: ArrowNumericType,
-    I::Native: ToPrimitive,
+    I: ArrowPrimitiveType,
 {
-    let indices_has_nulls = indices.null_count() > 0;
-    let values_has_nulls = values.null_count() > 0;
-    // note: this function should only panic when "an index is not null and out of bounds".
-    // if the index is null, its value is undefined and therefore we should not read from it.
-
-    let (buffer, nulls) = match (values_has_nulls, indices_has_nulls) {
-        (false, false) => {
-            // * no nulls
-            // * all `indices.values()` are valid
-            take_no_nulls::<T::Native, I::Native>(values.values(), indices.values())?
-        }
-        (true, false) => {
-            // * nulls come from `values` alone
-            // * all `indices.values()` are valid
-            take_values_nulls::<T, I::Native>(values, indices.values())?
-        }
-        (false, true) => {
-            // in this branch it is unsound to read and use `index.values()`,
-            // as doing so is UB when they come from a null slot.
-            take_indices_nulls::<T::Native, I>(values.values(), indices)?
-        }
-        (true, true) => {
-            // in this branch it is unsound to read and use `index.values()`,
-            // as doing so is UB when they come from a null slot.
-            take_values_indices_nulls::<T, I>(values, indices)?
+    let values_buf = take_native(values.values(), indices);
+    let nulls = take_nulls(values.nulls(), indices);
+    Ok(PrimitiveArray::new(values_buf, nulls).with_data_type(values.data_type().clone()))
+}
+
+#[inline(never)]
+fn take_nulls<I: ArrowPrimitiveType>(
+    values: Option<&NullBuffer>,
+    indices: &PrimitiveArray<I>,
+) -> Option<NullBuffer> {
+    match values.filter(|n| n.null_count() > 0) {
+        Some(n) => {
+            let buffer = take_bits(n.inner(), indices);
+            Some(NullBuffer::new(buffer)).filter(|n| n.null_count() > 0)
         }
-    };
+        None => indices.nulls().cloned(),
+    }
+}
 
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            values.data_type().clone(),
-            indices.len(),
-            None,
-            nulls,
-            0,
-            vec![buffer],
-            vec![],
-        )
-    };
-    Ok(PrimitiveArray::<T>::from(data))
+#[inline(never)]
+fn take_native<T: ArrowNativeType, I: ArrowPrimitiveType>(
+    values: &[T],
+    indices: &PrimitiveArray<I>,
+) -> ScalarBuffer<T> {
+    match indices.nulls().filter(|n| n.null_count() > 0) {
+        Some(n) => indices
+            .values()
+            .iter()
+            .enumerate()
+            .map(|(idx, index)| match values.get(index.as_usize()) {
+                Some(v) => *v,
+                None => match n.is_null(idx) {
+                    true => T::default(),
+                    false => panic!("Out-of-bounds index {index:?}"),
+                },
+            })
+            .collect(),
+        None => indices
+            .values()
+            .iter()
+            .map(|index| values[index.as_usize()])
+            .collect(),
+    }
 }
 
-fn take_bits<IndexType>(
-    values: &Buffer,
-    values_offset: usize,
-    indices: &PrimitiveArray<IndexType>,
-) -> Result<Buffer>
-where
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-{
+#[inline(never)]
+fn take_bits<I: ArrowPrimitiveType>(
+    values: &BooleanBuffer,
+    indices: &PrimitiveArray<I>,
+) -> BooleanBuffer {
     let len = indices.len();
-    let values_slice = values.as_slice();
     let mut output_buffer = MutableBuffer::new_null(len);
     let output_slice = output_buffer.as_slice_mut();
 
-    let indices_has_nulls = indices.null_count() > 0;
-
-    if indices_has_nulls {
-        indices
-            .iter()
-            .enumerate()
-            .try_for_each::<_, Result<()>>(|(i, index)| {
-                if let Some(index) = index {
-                    let index = ToPrimitive::to_usize(&index).ok_or_else(|| {
-                        ArrowError::ComputeError("Cast to usize failed".to_string())
-                    })?;
-
-                    if bit_util::get_bit(values_slice, values_offset + index) {
-                        bit_util::set_bit(output_slice, i);
-                    }
-                }
-
-                Ok(())
-            })?;
-    } else {
-        indices
-            .values()
-            .iter()
-            .enumerate()
-            .try_for_each::<_, Result<()>>(|(i, index)| {
-                let index = ToPrimitive::to_usize(index).ok_or_else(|| {
-                    ArrowError::ComputeError("Cast to usize failed".to_string())
-                })?;
-
-                if bit_util::get_bit(values_slice, values_offset + index) {
-                    bit_util::set_bit(output_slice, i);
-                }
-                Ok(())
-            })?;
-    }
-    Ok(output_buffer.into())
+    match indices.nulls().filter(|n| n.null_count() > 0) {
+        Some(nulls) => nulls.valid_indices().for_each(|idx| {
+            if values.value(indices.value(idx).as_usize()) {
+                bit_util::set_bit(output_slice, idx);
+            }
+        }),
+        None => indices.values().iter().enumerate().for_each(|(i, index)| {
+            if values.value(index.as_usize()) {
+                bit_util::set_bit(output_slice, i);
+            }
+        }),
+    }
+    BooleanBuffer::new(output_buffer.into(), 0, indices.len())
 }
 
 /// `take` implementation for boolean arrays
-fn take_boolean<IndexType>(
+fn take_boolean<IndexType: ArrowPrimitiveType>(
     values: &BooleanArray,
     indices: &PrimitiveArray<IndexType>,
-) -> Result<BooleanArray>
-where
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-{
-    let val_buf = take_bits(values.values(), values.offset(), indices)?;
-    let null_buf = match values.data().null_buffer() {
-        Some(buf) if values.null_count() > 0 => {
-            Some(take_bits(buf, values.offset(), indices)?)
-        }
-        _ => indices
-            .data()
-            .null_buffer()
-            .map(|b| b.bit_slice(indices.offset(), indices.len())),
-    };
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            indices.len(),
-            None,
-            null_buf,
-            0,
-            vec![val_buf],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
+) -> BooleanArray {
+    let val_buf = take_bits(values.values(), indices);
+    let null_buf = take_nulls(values.nulls(), indices);
+    BooleanArray::new(val_buf, null_buf)
 }
 
 /// `take` implementation for string arrays
-fn take_string<OffsetSize, IndexType>(
-    array: &GenericStringArray<OffsetSize>,
+fn take_bytes<T: ByteArrayType, IndexType: ArrowPrimitiveType>(
+    array: &GenericByteArray<T>,
     indices: &PrimitiveArray<IndexType>,
-) -> Result<GenericStringArray<OffsetSize>>
-where
-    OffsetSize: Zero + AddAssign + OffsetSizeTrait,
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-{
+) -> Result<GenericByteArray<T>, ArrowError> {
     let data_len = indices.len();
 
-    let bytes_offset = (data_len + 1) * std::mem::size_of::<OffsetSize>();
-    let mut offsets_buffer = MutableBuffer::from_len_zeroed(bytes_offset);
+    let bytes_offset = (data_len + 1) * std::mem::size_of::<T::Offset>();
+    let mut offsets = MutableBuffer::new(bytes_offset);
+    offsets.push(T::Offset::default());
 
-    let offsets = offsets_buffer.typed_data_mut();
     let mut values = MutableBuffer::new(0);
-    let mut length_so_far = OffsetSize::zero();
-    offsets[0] = length_so_far;
 
     let nulls;
     if array.null_count() == 0 && indices.null_count() == 0 {
-        for (i, offset) in offsets.iter_mut().skip(1).enumerate() {
-            let index = ToPrimitive::to_usize(&indices.value(i)).ok_or_else(|| {
-                ArrowError::ComputeError("Cast to usize failed".to_string())
-            })?;
-
-            let s = array.value(index);
-
-            length_so_far += OffsetSize::from_usize(s.len()).unwrap();
-            values.extend_from_slice(s.as_bytes());
-            *offset = length_so_far;
-        }
+        offsets.extend(indices.values().iter().map(|index| {
+            let s: &[u8] = array.value(index.as_usize()).as_ref();
+            values.extend_from_slice(s);
+            T::Offset::usize_as(values.len())
+        }));
         nulls = None
     } else if indices.null_count() == 0 {
         let num_bytes = bit_util::ceil(data_len, 8);
 
         let mut null_buf = MutableBuffer::new(num_bytes).with_bitset(num_bytes, true);
         let null_slice = null_buf.as_slice_mut();
-
-        for (i, offset) in offsets.iter_mut().skip(1).enumerate() {
-            let index = ToPrimitive::to_usize(&indices.value(i)).ok_or_else(|| {
-                ArrowError::ComputeError("Cast to usize failed".to_string())
-            })?;
-
+        offsets.extend(indices.values().iter().enumerate().map(|(i, index)| {
+            let index = index.as_usize();
             if array.is_valid(index) {
-                let s = array.value(index);
-
-                length_so_far += OffsetSize::from_usize(s.len()).unwrap();
-                values.extend_from_slice(s.as_bytes());
+                let s: &[u8] = array.value(index).as_ref();
+                values.extend_from_slice(s.as_ref());
             } else {
                 bit_util::unset_bit(null_slice, i);
             }
-            *offset = length_so_far;
-        }
+            T::Offset::usize_as(values.len())
+        }));
         nulls = Some(null_buf.into());
     } else if array.null_count() == 0 {
-        for (i, offset) in offsets.iter_mut().skip(1).enumerate() {
+        offsets.extend(indices.values().iter().enumerate().map(|(i, index)| {
             if indices.is_valid(i) {
-                let index =
-                    ToPrimitive::to_usize(&indices.value(i)).ok_or_else(|| {
-                        ArrowError::ComputeError("Cast to usize failed".to_string())
-                    })?;
-
-                let s = array.value(index);
-
-                length_so_far += OffsetSize::from_usize(s.len()).unwrap();
-                values.extend_from_slice(s.as_bytes());
+                let s: &[u8] = array.value(index.as_usize()).as_ref();
+                values.extend_from_slice(s);
             }
-            *offset = length_so_far;
-        }
-        nulls = indices.data_ref().null_buffer().cloned();
+            T::Offset::usize_as(values.len())
+        }));
+        nulls = indices.nulls().map(|b| b.inner().sliced());
     } else {
         let num_bytes = bit_util::ceil(data_len, 8);
 
         let mut null_buf = MutableBuffer::new(num_bytes).with_bitset(num_bytes, true);
         let null_slice = null_buf.as_slice_mut();
-
-        for (i, offset) in offsets.iter_mut().skip(1).enumerate() {
-            let index = ToPrimitive::to_usize(&indices.value(i)).ok_or_else(|| {
-                ArrowError::ComputeError("Cast to usize failed".to_string())
-            })?;
-
-            if array.is_valid(index) && indices.is_valid(i) {
-                let s = array.value(index);
-
-                length_so_far += OffsetSize::from_usize(s.len()).unwrap();
-                values.extend_from_slice(s.as_bytes());
+        offsets.extend(indices.values().iter().enumerate().map(|(i, index)| {
+            // check index is valid before using index. The value in
+            // NULL index slots may not be within bounds of array
+            let index = index.as_usize();
+            if indices.is_valid(i) && array.is_valid(index) {
+                let s: &[u8] = array.value(index).as_ref();
+                values.extend_from_slice(s);
             } else {
                 // set null bit
                 bit_util::unset_bit(null_slice, i);
             }
-            *offset = length_so_far;
-        }
-
-        nulls = match indices.data_ref().null_buffer() {
-            Some(buffer) => {
-                Some(buffer_bin_and(buffer, 0, &null_buf.into(), 0, data_len))
-            }
-            None => Some(null_buf.into()),
-        };
+            T::Offset::usize_as(values.len())
+        }));
+        nulls = Some(null_buf.into())
     }
 
-    let array_data = ArrayData::builder(GenericStringArray::<OffsetSize>::DATA_TYPE)
+    T::Offset::from_usize(values.len()).ok_or(ArrowError::ComputeError(format!(
+        "Offset overflow for {}BinaryArray: {}",
+        T::Offset::PREFIX,
+        values.len()
+    )))?;
+
+    let array_data = ArrayData::builder(T::DATA_TYPE)
         .len(data_len)
-        .add_buffer(offsets_buffer.into())
+        .add_buffer(offsets.into())
         .add_buffer(values.into())
         .null_bit_buffer(nulls);
 
     let array_data = unsafe { array_data.build_unchecked() };
 
-    Ok(GenericStringArray::<OffsetSize>::from(array_data))
+    Ok(GenericByteArray::from(array_data))
 }
 
 /// `take` implementation for list arrays
@@ -806,37 +445,20 @@ where
 fn take_list<IndexType, OffsetType>(
     values: &GenericListArray<OffsetType::Native>,
     indices: &PrimitiveArray<IndexType>,
-) -> Result<GenericListArray<OffsetType::Native>>
+) -> Result<GenericListArray<OffsetType::Native>, ArrowError>
 where
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-    OffsetType: ArrowNumericType,
-    OffsetType::Native: ToPrimitive + OffsetSizeTrait,
-    PrimitiveArray<OffsetType>: From<Vec<Option<OffsetType::Native>>>,
+    IndexType: ArrowPrimitiveType,
+    OffsetType: ArrowPrimitiveType,
+    OffsetType::Native: OffsetSizeTrait,
+    PrimitiveArray<OffsetType>: From<Vec<OffsetType::Native>>,
 {
     // TODO: Some optimizations can be done here such as if it is
     // taking the whole list or a contiguous sublist
-    let (list_indices, offsets) =
+    let (list_indices, offsets, null_buf) =
         take_value_indices_from_list::<IndexType, OffsetType>(values, indices)?;
 
-    let taken = take_impl::<OffsetType>(values.values().as_ref(), &list_indices, None)?;
-    // determine null count and null buffer, which are a function of `values` and `indices`
-    let mut null_count = 0;
-    let num_bytes = bit_util::ceil(indices.len(), 8);
-    let mut null_buf = MutableBuffer::new(num_bytes).with_bitset(num_bytes, true);
-    {
-        let null_slice = null_buf.as_slice_mut();
-        offsets[..].windows(2).enumerate().for_each(
-            |(i, window): (usize, &[OffsetType::Native])| {
-                if window[0] == window[1] {
-                    // offsets are equal, slot is null
-                    bit_util::unset_bit(null_slice, i);
-                    null_count += 1;
-                }
-            },
-        );
-    }
-    let value_offsets = Buffer::from_slice_ref(&offsets);
+    let taken = take_impl::<OffsetType>(values.values().as_ref(), &list_indices)?;
+    let value_offsets = Buffer::from_vec(offsets);
     // create a new list with taken data and computed null information
     let list_data = ArrayDataBuilder::new(values.data_type().clone())
         .len(indices.len())
@@ -855,17 +477,13 @@ where
 /// Calculates the index and indexed offset for the inner array,
 /// applying `take` on the inner array, then reconstructing a list array
 /// with the indexed offsets
-fn take_fixed_size_list<IndexType>(
+fn take_fixed_size_list<IndexType: ArrowPrimitiveType>(
     values: &FixedSizeListArray,
     indices: &PrimitiveArray<IndexType>,
     length: <UInt32Type as ArrowPrimitiveType>::Native,
-) -> Result<FixedSizeListArray>
-where
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-{
+) -> Result<FixedSizeListArray, ArrowError> {
     let list_indices = take_value_indices_from_fixed_size_list(values, indices, length)?;
-    let taken = take_impl::<UInt32Type>(values.values().as_ref(), &list_indices, None)?;
+    let taken = take_impl::<UInt32Type>(values.values().as_ref(), &list_indices)?;
 
     // determine null count and null buffer, which are a function of `values` and `indices`
     let num_bytes = bit_util::ceil(indices.len(), 8);
@@ -873,9 +491,10 @@ where
     let null_slice = null_buf.as_slice_mut();
 
     for i in 0..indices.len() {
-        let index = ToPrimitive::to_usize(&indices.value(i)).ok_or_else(|| {
-            ArrowError::ComputeError("Cast to usize failed".to_string())
-        })?;
+        let index = indices
+            .value(i)
+            .to_usize()
+            .ok_or_else(|| ArrowError::ComputeError("Cast to usize failed".to_string()))?;
         if !indices.is_valid(i) || values.is_null(index) {
             bit_util::unset_bit(null_slice, i);
         }
@@ -892,104 +511,333 @@ where
     Ok(FixedSizeListArray::from(list_data))
 }
 
-fn take_binary<IndexType, OffsetType>(
-    values: &GenericBinaryArray<OffsetType>,
-    indices: &PrimitiveArray<IndexType>,
-) -> Result<GenericBinaryArray<OffsetType>>
-where
-    OffsetType: OffsetSizeTrait,
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-{
-    let data_ref = values.data_ref();
-    let array_iter = indices
-        .values()
-        .iter()
-        .map(|idx| {
-            let idx = maybe_usize::<IndexType::Native>(*idx)?;
-            if data_ref.is_valid(idx) {
-                Ok(Some(values.value(idx)))
-            } else {
-                Ok(None)
-            }
-        })
-        .collect::<Result<Vec<_>>>()?
-        .into_iter();
-
-    Ok(array_iter.collect::<GenericBinaryArray<OffsetType>>())
-}
-
-fn take_fixed_size_binary<IndexType>(
+fn take_fixed_size_binary<IndexType: ArrowPrimitiveType>(
     values: &FixedSizeBinaryArray,
     indices: &PrimitiveArray<IndexType>,
-) -> Result<FixedSizeBinaryArray>
-where
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-{
-    let data_ref = values.data_ref();
+    size: i32,
+) -> Result<FixedSizeBinaryArray, ArrowError> {
+    let nulls = values.nulls();
     let array_iter = indices
         .values()
         .iter()
         .map(|idx| {
             let idx = maybe_usize::<IndexType::Native>(*idx)?;
-            if data_ref.is_valid(idx) {
+            if nulls.map(|n| n.is_valid(idx)).unwrap_or(true) {
                 Ok(Some(values.value(idx)))
             } else {
                 Ok(None)
             }
         })
-        .collect::<Result<Vec<_>>>()?
+        .collect::<Result<Vec<_>, ArrowError>>()?
         .into_iter();
 
-    FixedSizeBinaryArray::try_from_sparse_iter(array_iter)
+    FixedSizeBinaryArray::try_from_sparse_iter_with_size(array_iter, size)
 }
 
 /// `take` implementation for dictionary arrays
 ///
 /// applies `take` to the keys of the dictionary array and returns a new dictionary array
 /// with the same dictionary values and reordered keys
-fn take_dict<T, I>(
+fn take_dict<T: ArrowDictionaryKeyType, I: ArrowPrimitiveType>(
     values: &DictionaryArray<T>,
     indices: &PrimitiveArray<I>,
-) -> Result<DictionaryArray<T>>
+) -> Result<DictionaryArray<T>, ArrowError> {
+    let new_keys = take_primitive(values.keys(), indices)?;
+    Ok(unsafe { DictionaryArray::new_unchecked(new_keys, values.values().clone()) })
+}
+
+/// `take` implementation for run arrays
+///
+/// Finds physical indices for the given logical indices and builds output run array
+/// by taking values in the input run_array.values at the physical indices.
+/// The output run array will be run encoded on the physical indices and not on output values.
+/// For e.g. an input `RunArray{ run_ends = [2,4,6,8], values=[1,2,1,2] }` and `logical_indices=[2,3,6,7]`
+/// would be converted to `physical_indices=[1,1,3,3]` which will be used to build
+/// output `RunArray{ run_ends=[2,4], values=[2,2] }`.
+fn take_run<T: RunEndIndexType, I: ArrowPrimitiveType>(
+    run_array: &RunArray<T>,
+    logical_indices: &PrimitiveArray<I>,
+) -> Result<RunArray<T>, ArrowError> {
+    // get physical indices for the input logical indices
+    let physical_indices = run_array.get_physical_indices(logical_indices.values())?;
+
+    // Run encode the physical indices into new_run_ends_builder
+    // Keep track of the physical indices to take in take_value_indices
+    // `unwrap` is used in this function because the unwrapped values are bounded by the corresponding `::Native`.
+    let mut new_run_ends_builder = BufferBuilder::<T::Native>::new(1);
+    let mut take_value_indices = BufferBuilder::<I::Native>::new(1);
+    let mut new_physical_len = 1;
+    for ix in 1..physical_indices.len() {
+        if physical_indices[ix] != physical_indices[ix - 1] {
+            take_value_indices.append(I::Native::from_usize(physical_indices[ix - 1]).unwrap());
+            new_run_ends_builder.append(T::Native::from_usize(ix).unwrap());
+            new_physical_len += 1;
+        }
+    }
+    take_value_indices
+        .append(I::Native::from_usize(physical_indices[physical_indices.len() - 1]).unwrap());
+    new_run_ends_builder.append(T::Native::from_usize(physical_indices.len()).unwrap());
+    let new_run_ends = unsafe {
+        // Safety:
+        // The function builds a valid run_ends array and hence need not be validated.
+        ArrayDataBuilder::new(T::DATA_TYPE)
+            .len(new_physical_len)
+            .null_count(0)
+            .add_buffer(new_run_ends_builder.finish())
+            .build_unchecked()
+    };
+
+    let take_value_indices: PrimitiveArray<I> = unsafe {
+        // Safety:
+        // The function builds a valid take_value_indices array and hence need not be validated.
+        ArrayDataBuilder::new(I::DATA_TYPE)
+            .len(new_physical_len)
+            .null_count(0)
+            .add_buffer(take_value_indices.finish())
+            .build_unchecked()
+            .into()
+    };
+
+    let new_values = take(run_array.values(), &take_value_indices, None)?;
+
+    let builder = ArrayDataBuilder::new(run_array.data_type().clone())
+        .len(physical_indices.len())
+        .add_child_data(new_run_ends)
+        .add_child_data(new_values.into_data());
+    let array_data = unsafe {
+        // Safety:
+        //  This function builds a valid run array and hence can skip validation.
+        builder.build_unchecked()
+    };
+    Ok(array_data.into())
+}
+
+/// Takes/filters a list array's inner data using the offsets of the list array.
+///
+/// Where a list array has indices `[0,2,5,10]`, taking indices of `[2,0]` returns
+/// an array of the indices `[5..10, 0..2]` and offsets `[0,5,7]` (5 elements and 2
+/// elements)
+#[allow(clippy::type_complexity)]
+fn take_value_indices_from_list<IndexType, OffsetType>(
+    list: &GenericListArray<OffsetType::Native>,
+    indices: &PrimitiveArray<IndexType>,
+) -> Result<
+    (
+        PrimitiveArray<OffsetType>,
+        Vec<OffsetType::Native>,
+        MutableBuffer,
+    ),
+    ArrowError,
+>
 where
-    T: ArrowPrimitiveType,
-    T::Native: num::Num,
-    I: ArrowNumericType,
-    I::Native: ToPrimitive,
+    IndexType: ArrowPrimitiveType,
+    OffsetType: ArrowPrimitiveType,
+    OffsetType::Native: OffsetSizeTrait + std::ops::Add + Zero + One,
+    PrimitiveArray<OffsetType>: From<Vec<OffsetType::Native>>,
 {
-    let new_keys = take_primitive::<T, I>(values.keys(), indices)?;
-    let new_keys_data = new_keys.data_ref();
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            values.data_type().clone(),
-            new_keys.len(),
-            Some(new_keys_data.null_count()),
-            new_keys_data.null_buffer().cloned(),
-            0,
-            new_keys_data.buffers().to_vec(),
-            values.data().child_data().to_vec(),
-        )
+    // TODO: benchmark this function, there might be a faster unsafe alternative
+    let offsets: &[OffsetType::Native] = list.value_offsets();
+
+    let mut new_offsets = Vec::with_capacity(indices.len());
+    let mut values = Vec::new();
+    let mut current_offset = OffsetType::Native::zero();
+    // add first offset
+    new_offsets.push(OffsetType::Native::zero());
+
+    // Initialize null buffer
+    let num_bytes = bit_util::ceil(indices.len(), 8);
+    let mut null_buf = MutableBuffer::new(num_bytes).with_bitset(num_bytes, true);
+    let null_slice = null_buf.as_slice_mut();
+
+    // compute the value indices, and set offsets accordingly
+    for i in 0..indices.len() {
+        if indices.is_valid(i) {
+            let ix = indices
+                .value(i)
+                .to_usize()
+                .ok_or_else(|| ArrowError::ComputeError("Cast to usize failed".to_string()))?;
+            let start = offsets[ix];
+            let end = offsets[ix + 1];
+            current_offset += end - start;
+            new_offsets.push(current_offset);
+
+            let mut curr = start;
+
+            // if start == end, this slot is empty
+            while curr < end {
+                values.push(curr);
+                curr += One::one();
+            }
+            if !list.is_valid(ix) {
+                bit_util::unset_bit(null_slice, i);
+            }
+        } else {
+            bit_util::unset_bit(null_slice, i);
+            new_offsets.push(current_offset);
+        }
+    }
+
+    Ok((
+        PrimitiveArray::<OffsetType>::from(values),
+        new_offsets,
+        null_buf,
+    ))
+}
+
+/// Takes/filters a fixed size list array's inner data using the offsets of the list array.
+fn take_value_indices_from_fixed_size_list<IndexType>(
+    list: &FixedSizeListArray,
+    indices: &PrimitiveArray<IndexType>,
+    length: <UInt32Type as ArrowPrimitiveType>::Native,
+) -> Result<PrimitiveArray<UInt32Type>, ArrowError>
+where
+    IndexType: ArrowPrimitiveType,
+{
+    let mut values = UInt32Builder::with_capacity(length as usize * indices.len());
+
+    for i in 0..indices.len() {
+        if indices.is_valid(i) {
+            let index = indices
+                .value(i)
+                .to_usize()
+                .ok_or_else(|| ArrowError::ComputeError("Cast to usize failed".to_string()))?;
+            let start = list.value_offset(index) as <UInt32Type as ArrowPrimitiveType>::Native;
+
+            // Safety: Range always has known length.
+            unsafe {
+                values.append_trusted_len_iter(start..start + length);
+            }
+        } else {
+            values.append_nulls(length as usize);
+        }
+    }
+
+    Ok(values.finish())
+}
+
+/// To avoid generating take implementations for every index type, instead we
+/// only generate for UInt32 and UInt64 and coerce inputs to these types
+trait ToIndices {
+    type T: ArrowPrimitiveType;
+
+    fn to_indices(&self) -> PrimitiveArray<Self::T>;
+}
+
+macro_rules! to_indices_reinterpret {
+    ($t:ty, $o:ty) => {
+        impl ToIndices for PrimitiveArray<$t> {
+            type T = $o;
+
+            fn to_indices(&self) -> PrimitiveArray<$o> {
+                let cast = ScalarBuffer::new(self.values().inner().clone(), 0, self.len());
+                PrimitiveArray::new(cast, self.nulls().cloned())
+            }
+        }
+    };
+}
+
+macro_rules! to_indices_identity {
+    ($t:ty) => {
+        impl ToIndices for PrimitiveArray<$t> {
+            type T = $t;
+
+            fn to_indices(&self) -> PrimitiveArray<$t> {
+                self.clone()
+            }
+        }
+    };
+}
+
+macro_rules! to_indices_widening {
+    ($t:ty, $o:ty) => {
+        impl ToIndices for PrimitiveArray<$t> {
+            type T = UInt32Type;
+
+            fn to_indices(&self) -> PrimitiveArray<$o> {
+                let cast = self.values().iter().copied().map(|x| x as _).collect();
+                PrimitiveArray::new(cast, self.nulls().cloned())
+            }
+        }
     };
+}
+
+to_indices_widening!(UInt8Type, UInt32Type);
+to_indices_widening!(Int8Type, UInt32Type);
+
+to_indices_widening!(UInt16Type, UInt32Type);
+to_indices_widening!(Int16Type, UInt32Type);
+
+to_indices_identity!(UInt32Type);
+to_indices_reinterpret!(Int32Type, UInt32Type);
 
-    Ok(DictionaryArray::<T>::from(data))
+to_indices_identity!(UInt64Type);
+to_indices_reinterpret!(Int64Type, UInt64Type);
+
+/// Take rows by index from [`RecordBatch`] and returns a new [`RecordBatch`] from those indexes.
+///
+/// This function will call [`take`] on each array of the [`RecordBatch`] and assemble a new [`RecordBatch`].
+///
+/// # Example
+/// ```
+/// # use std::sync::Arc;
+/// # use arrow_array::{StringArray, Int32Array, UInt32Array, RecordBatch};
+/// # use arrow_schema::{DataType, Field, Schema};
+/// # use arrow_select::take::take_record_batch;
+///
+/// let schema = Arc::new(Schema::new(vec![
+///     Field::new("a", DataType::Int32, true),
+///     Field::new("b", DataType::Utf8, true),
+/// ]));
+/// let batch = RecordBatch::try_new(
+///     schema.clone(),
+///     vec![
+///         Arc::new(Int32Array::from_iter_values(0..20)),
+///         Arc::new(StringArray::from_iter_values(
+///             (0..20).map(|i| format!("str-{}", i)),
+///         )),
+///     ],
+/// )
+/// .unwrap();
+///
+/// let indices = UInt32Array::from(vec![1, 5, 10]);
+/// let taken = take_record_batch(&batch, &indices).unwrap();
+///
+/// let expected = RecordBatch::try_new(
+///     schema,
+///     vec![
+///         Arc::new(Int32Array::from(vec![1, 5, 10])),
+///         Arc::new(StringArray::from(vec!["str-1", "str-5", "str-10"])),
+///     ],
+/// )
+/// .unwrap();
+/// assert_eq!(taken, expected);
+/// ```
+pub fn take_record_batch(
+    record_batch: &RecordBatch,
+    indices: &dyn Array,
+) -> Result<RecordBatch, ArrowError> {
+    let columns = record_batch
+        .columns()
+        .iter()
+        .map(|c| take(c, indices, None))
+        .collect::<Result<Vec<_>, _>>()?;
+    RecordBatch::try_new(record_batch.schema(), columns)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::compute::util::tests::build_fixed_size_list_nullable;
+    use arrow_array::builder::*;
+    use arrow_schema::{Field, Fields, TimeUnit};
 
     fn test_take_decimal_arrays(
         data: Vec<Option<i128>>,
         index: &UInt32Array,
         options: Option<TakeOptions>,
         expected_data: Vec<Option<i128>>,
-        precision: &usize,
-        scale: &usize,
-    ) -> Result<()> {
+        precision: &u8,
+        scale: &i8,
+    ) -> Result<(), ArrowError> {
         let output = data
             .into_iter()
             .collect::<Decimal128Array>()
@@ -1025,7 +873,7 @@ mod tests {
         index: &UInt32Array,
         options: Option<TakeOptions>,
         expected_data: Vec<Option<T::Native>>,
-    ) -> Result<()>
+    ) -> Result<(), ArrowError>
     where
         T: ArrowPrimitiveType,
         PrimitiveArray<T>: From<Vec<Option<T::Native>>>,
@@ -1042,7 +890,7 @@ mod tests {
         index: &UInt32Array,
         options: Option<TakeOptions>,
         expected_data: Vec<Option<T::Native>>,
-    ) -> Result<()>
+    ) -> Result<(), ArrowError>
     where
         T: ArrowPrimitiveType,
         PrimitiveArray<T>: From<Vec<T::Native>>,
@@ -1063,28 +911,25 @@ mod tests {
     ) where
         T: ArrowPrimitiveType,
         PrimitiveArray<T>: From<Vec<Option<T::Native>>>,
-        I: ArrowNumericType,
-        I::Native: ToPrimitive,
+        I: ArrowPrimitiveType,
     {
         let output = PrimitiveArray::<T>::from(data);
         let expected = PrimitiveArray::<T>::from(expected_data);
-        let output = take_impl(&output, index, options).unwrap();
+        let output = take(&output, index, options).unwrap();
         let output = output.as_any().downcast_ref::<PrimitiveArray<T>>().unwrap();
         assert_eq!(output, &expected)
     }
 
     // create a simple struct for testing purposes
-    fn create_test_struct(
-        values: Vec<Option<(Option<bool>, Option<i32>)>>,
-    ) -> StructArray {
+    fn create_test_struct(values: Vec<Option<(Option<bool>, Option<i32>)>>) -> StructArray {
         let mut struct_builder = StructBuilder::new(
-            vec![
+            Fields::from(vec![
                 Field::new("a", DataType::Boolean, true),
                 Field::new("b", DataType::Int32, true),
-            ],
+            ]),
             vec![
-                Box::new(BooleanBuilder::new(values.len())),
-                Box::new(Int32Builder::new(values.len())),
+                Box::new(BooleanBuilder::with_capacity(values.len())),
+                Box::new(Int32Builder::with_capacity(values.len())),
             ],
         );
 
@@ -1105,8 +950,8 @@ mod tests {
     #[test]
     fn test_take_decimal128_non_null_indices() {
         let index = UInt32Array::from(vec![0, 5, 3, 1, 4, 2]);
-        let precision: usize = 10;
-        let scale: usize = 5;
+        let precision: u8 = 10;
+        let scale: i8 = 5;
         test_take_decimal_arrays(
             vec![None, Some(3), Some(5), Some(2), Some(3), None],
             &index,
@@ -1121,8 +966,8 @@ mod tests {
     #[test]
     fn test_take_decimal128() {
         let index = UInt32Array::from(vec![Some(3), None, Some(1), Some(3), Some(2)]);
-        let precision: usize = 10;
-        let scale: usize = 5;
+        let precision: u8 = 10;
+        let scale: i8 = 5;
         test_take_decimal_arrays(
             vec![Some(0), Some(1), Some(2), Some(3), Some(4)],
             &index,
@@ -1172,8 +1017,7 @@ mod tests {
 
     #[test]
     fn test_take_primitive_nullable_indices_non_null_values_with_offset() {
-        let index =
-            UInt32Array::from(vec![Some(0), Some(1), Some(2), Some(3), None, None]);
+        let index = UInt32Array::from(vec![Some(0), Some(1), Some(2), Some(3), None, None]);
         let index = index.slice(2, 4);
         let index = index.as_any().downcast_ref::<UInt32Array>().unwrap();
 
@@ -1193,8 +1037,7 @@ mod tests {
 
     #[test]
     fn test_take_primitive_nullable_indices_nullable_values_with_offset() {
-        let index =
-            UInt32Array::from(vec![Some(0), Some(1), Some(2), Some(3), None, None]);
+        let index = UInt32Array::from(vec![Some(0), Some(1), Some(2), Some(3), None, None]);
         let index = index.slice(2, 4);
         let index = index.as_any().downcast_ref::<UInt32Array>().unwrap();
 
@@ -1374,14 +1217,15 @@ mod tests {
     fn test_take_preserve_timezone() {
         let index = Int64Array::from(vec![Some(0), None]);
 
-        let input = TimestampNanosecondArray::from_vec(
-            vec![1_639_715_368_000_000_000, 1_639_715_368_000_000_000],
-            Some("UTC".to_owned()),
-        );
-        let result = take_impl(&input, &index, None).unwrap();
+        let input = TimestampNanosecondArray::from(vec![
+            1_639_715_368_000_000_000,
+            1_639_715_368_000_000_000,
+        ])
+        .with_timezone("UTC".to_string());
+        let result = take(&input, &index, None).unwrap();
         match result.data_type() {
             DataType::Timestamp(TimeUnit::Nanosecond, tz) => {
-                assert_eq!(tz.clone(), Some("UTC".to_owned()))
+                assert_eq!(tz.clone(), Some("UTC".into()))
             }
             _ => panic!(),
         }
@@ -1477,7 +1321,7 @@ mod tests {
     fn test_take_bool_nullable_index() {
         // indices where the masked invalid elements would be out of bounds
         let index_data = ArrayData::try_new(
-            DataType::Int32,
+            DataType::UInt32,
             6,
             Some(Buffer::from_iter(vec![
                 false, true, false, true, false, true,
@@ -1500,7 +1344,7 @@ mod tests {
     fn test_take_bool_nullable_index_nonnull_values() {
         // indices where the masked invalid elements would be out of bounds
         let index_data = ArrayData::try_new(
-            DataType::Int32,
+            DataType::UInt32,
             6,
             Some(Buffer::from_iter(vec![
                 false, true, false, true, false, true,
@@ -1521,8 +1365,7 @@ mod tests {
 
     #[test]
     fn test_take_bool_with_offset() {
-        let index =
-            UInt32Array::from(vec![Some(3), None, Some(1), Some(3), Some(2), None]);
+        let index = UInt32Array::from(vec![Some(3), None, Some(1), Some(3), Some(2), None]);
         let index = index.slice(2, 4);
         let index = index
             .as_any()
@@ -1556,8 +1399,7 @@ mod tests {
 
         let actual = actual.as_any().downcast_ref::<K>().unwrap();
 
-        let expected =
-            K::from(vec![Some("four"), None, None, Some("four"), Some("five")]);
+        let expected = K::from(vec![Some("four"), None, None, Some("four"), Some("five")]);
 
         assert_eq!(actual, &expected);
     }
@@ -1572,60 +1414,61 @@ mod tests {
         _test_take_string::<LargeStringArray>()
     }
 
+    #[test]
+    fn test_take_slice_string() {
+        let strings = StringArray::from(vec![Some("hello"), None, Some("world"), None, Some("hi")]);
+        let indices = Int32Array::from(vec![Some(0), Some(1), None, Some(0), Some(2)]);
+        let indices_slice = indices.slice(1, 4);
+        let expected = StringArray::from(vec![None, None, Some("hello"), Some("world")]);
+        let result = take(&strings, &indices_slice, None).unwrap();
+        assert_eq!(result.as_ref(), &expected);
+    }
+
     macro_rules! test_take_list {
         ($offset_type:ty, $list_data_type:ident, $list_array_type:ident) => {{
-            // Construct a value array, [[0,0,0], [-1,-2,-1], [2,3]]
-            let value_data = Int32Array::from(vec![0, 0, 0, -1, -2, -1, 2, 3])
-                .data()
-                .clone();
+            // Construct a value array, [[0,0,0], [-1,-2,-1], [], [2,3]]
+            let value_data = Int32Array::from(vec![0, 0, 0, -1, -2, -1, 2, 3]).into_data();
             // Construct offsets
-            let value_offsets: [$offset_type; 4] = [0, 3, 6, 8];
+            let value_offsets: [$offset_type; 5] = [0, 3, 6, 6, 8];
             let value_offsets = Buffer::from_slice_ref(&value_offsets);
             // Construct a list array from the above two
-            let list_data_type = DataType::$list_data_type(Box::new(Field::new(
-                "item",
-                DataType::Int32,
-                false,
-            )));
+            let list_data_type =
+                DataType::$list_data_type(Arc::new(Field::new("item", DataType::Int32, false)));
             let list_data = ArrayData::builder(list_data_type.clone())
-                .len(3)
+                .len(4)
                 .add_buffer(value_offsets)
                 .add_child_data(value_data)
                 .build()
                 .unwrap();
             let list_array = $list_array_type::from(list_data);
 
-            // index returns: [[2,3], null, [-1,-2,-1], [2,3], [0,0,0]]
-            let index = UInt32Array::from(vec![Some(2), None, Some(1), Some(2), Some(0)]);
+            // index returns: [[2,3], null, [-1,-2,-1], [], [0,0,0]]
+            let index = UInt32Array::from(vec![Some(3), None, Some(1), Some(2), Some(0)]);
 
             let a = take(&list_array, &index, None).unwrap();
-            let a: &$list_array_type =
-                a.as_any().downcast_ref::<$list_array_type>().unwrap();
+            let a: &$list_array_type = a.as_any().downcast_ref::<$list_array_type>().unwrap();
 
             // construct a value array with expected results:
-            // [[2,3], null, [-1,-2,-1], [2,3], [0,0,0]]
+            // [[2,3], null, [-1,-2,-1], [], [0,0,0]]
             let expected_data = Int32Array::from(vec![
                 Some(2),
                 Some(3),
                 Some(-1),
                 Some(-2),
                 Some(-1),
-                Some(2),
-                Some(3),
                 Some(0),
                 Some(0),
                 Some(0),
             ])
-            .data()
-            .clone();
+            .into_data();
             // construct offsets
-            let expected_offsets: [$offset_type; 6] = [0, 2, 2, 5, 7, 10];
+            let expected_offsets: [$offset_type; 6] = [0, 2, 2, 5, 5, 8];
             let expected_offsets = Buffer::from_slice_ref(&expected_offsets);
             // construct list array from the two
             let expected_list_data = ArrayData::builder(list_data_type)
                 .len(5)
                 // null buffer remains the same as only the indices have nulls
-                .null_bit_buffer(index.data().null_buffer().cloned())
+                .nulls(index.nulls().cloned())
                 .add_buffer(expected_offsets)
                 .add_child_data(expected_data)
                 .build()
@@ -1650,21 +1493,17 @@ mod tests {
                 Some(5),
                 None,
             ])
-            .data()
-            .clone();
+            .into_data();
             // Construct offsets
             let value_offsets: [$offset_type; 5] = [0, 3, 6, 7, 9];
             let value_offsets = Buffer::from_slice_ref(&value_offsets);
             // Construct a list array from the above two
-            let list_data_type = DataType::$list_data_type(Box::new(Field::new(
-                "item",
-                DataType::Int32,
-                false,
-            )));
+            let list_data_type =
+                DataType::$list_data_type(Arc::new(Field::new("item", DataType::Int32, true)));
             let list_data = ArrayData::builder(list_data_type.clone())
                 .len(4)
                 .add_buffer(value_offsets)
-                .null_bit_buffer(Some(Buffer::from([0b10111101, 0b00000000])))
+                .null_bit_buffer(Some(Buffer::from([0b11111111])))
                 .add_child_data(value_data)
                 .build()
                 .unwrap();
@@ -1674,8 +1513,7 @@ mod tests {
             let index = UInt32Array::from(vec![Some(2), None, Some(1), Some(3), Some(0)]);
 
             let a = take(&list_array, &index, None).unwrap();
-            let a: &$list_array_type =
-                a.as_any().downcast_ref::<$list_array_type>().unwrap();
+            let a: &$list_array_type = a.as_any().downcast_ref::<$list_array_type>().unwrap();
 
             // construct a value array with expected results:
             // [[null], null, [-1,-2,3], [5,null], [0,null,0]]
@@ -1690,8 +1528,7 @@ mod tests {
                 None,
                 Some(0),
             ])
-            .data()
-            .clone();
+            .into_data();
             // construct offsets
             let expected_offsets: [$offset_type; 6] = [0, 1, 1, 4, 6, 9];
             let expected_offsets = Buffer::from_slice_ref(&expected_offsets);
@@ -1699,7 +1536,7 @@ mod tests {
             let expected_list_data = ArrayData::builder(list_data_type)
                 .len(5)
                 // null buffer remains the same as only the indices have nulls
-                .null_bit_buffer(index.data().null_buffer().cloned())
+                .nulls(index.nulls().cloned())
                 .add_buffer(expected_offsets)
                 .add_child_data(expected_data)
                 .build()
@@ -1723,21 +1560,17 @@ mod tests {
                 Some(5),
                 None,
             ])
-            .data()
-            .clone();
+            .into_data();
             // Construct offsets
             let value_offsets: [$offset_type; 5] = [0, 3, 6, 6, 8];
             let value_offsets = Buffer::from_slice_ref(&value_offsets);
             // Construct a list array from the above two
-            let list_data_type = DataType::$list_data_type(Box::new(Field::new(
-                "item",
-                DataType::Int32,
-                false,
-            )));
+            let list_data_type =
+                DataType::$list_data_type(Arc::new(Field::new("item", DataType::Int32, true)));
             let list_data = ArrayData::builder(list_data_type.clone())
                 .len(4)
                 .add_buffer(value_offsets)
-                .null_bit_buffer(Some(Buffer::from([0b01111101])))
+                .null_bit_buffer(Some(Buffer::from([0b11111011])))
                 .add_child_data(value_data)
                 .build()
                 .unwrap();
@@ -1747,8 +1580,7 @@ mod tests {
             let index = UInt32Array::from(vec![Some(2), None, Some(1), Some(3), Some(0)]);
 
             let a = take(&list_array, &index, None).unwrap();
-            let a: &$list_array_type =
-                a.as_any().downcast_ref::<$list_array_type>().unwrap();
+            let a: &$list_array_type = a.as_any().downcast_ref::<$list_array_type>().unwrap();
 
             // construct a value array with expected results:
             // [null, null, [-1,-2,3], [5,null], [0,null,0]]
@@ -1762,8 +1594,7 @@ mod tests {
                 None,
                 Some(0),
             ])
-            .data()
-            .clone();
+            .into_data();
             // construct offsets
             let expected_offsets: [$offset_type; 6] = [0, 0, 0, 3, 5, 8];
             let expected_offsets = Buffer::from_slice_ref(&expected_offsets);
@@ -1797,11 +1628,11 @@ mod tests {
     {
         let indices = UInt32Array::from(indices);
 
-        let input_array = build_fixed_size_list_nullable::<T>(input_data, length);
+        let input_array = FixedSizeListArray::from_iter_primitive::<T, _, _>(input_data, length);
 
         let output = take_fixed_size_list(&input_array, &indices, length as u32).unwrap();
 
-        let expected = build_fixed_size_list_nullable::<T>(expected_data, length);
+        let expected = FixedSizeListArray::from_iter_primitive::<T, _, _>(expected_data, length);
 
         assert_eq!(&output, &expected)
     }
@@ -1896,14 +1727,11 @@ mod tests {
     #[should_panic(expected = "index out of bounds: the len is 4 but the index is 1000")]
     fn test_take_list_out_of_bounds() {
         // Construct a value array, [[0,0,0], [-1,-2,-1], [2,3]]
-        let value_data = Int32Array::from(vec![0, 0, 0, -1, -2, -1, 2, 3])
-            .data()
-            .clone();
+        let value_data = Int32Array::from(vec![0, 0, 0, -1, -2, -1, 2, 3]).into_data();
         // Construct offsets
-        let value_offsets = Buffer::from_slice_ref(&[0, 3, 6, 8]);
+        let value_offsets = Buffer::from_slice_ref([0, 3, 6, 8]);
         // Construct a list array from the above two
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
+        let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
         let list_data = ArrayData::builder(list_data_type)
             .len(3)
             .add_buffer(value_offsets)
@@ -1919,6 +1747,27 @@ mod tests {
         take(&list_array, &index, None).unwrap();
     }
 
+    #[test]
+    fn test_take_map() {
+        let values = Int32Array::from(vec![1, 2, 3, 4]);
+        let array =
+            MapArray::new_from_strings(vec!["a", "b", "c", "a"].into_iter(), &values, &[0, 3, 4])
+                .unwrap();
+
+        let index = UInt32Array::from(vec![0]);
+
+        let result = take(&array, &index, None).unwrap();
+        let expected: ArrayRef = Arc::new(
+            MapArray::new_from_strings(
+                vec!["a", "b", "c"].into_iter(),
+                &values.slice(0, 3),
+                &[0, 3],
+            )
+            .unwrap(),
+        );
+        assert_eq!(&expected, &result);
+    }
+
     #[test]
     fn test_take_struct() {
         let array = create_test_struct(vec![
@@ -1957,8 +1806,7 @@ mod tests {
             None,
         ]);
 
-        let index =
-            UInt32Array::from(vec![None, Some(3), Some(1), None, Some(0), Some(4)]);
+        let index = UInt32Array::from(vec![None, Some(3), Some(1), None, Some(0), Some(4)]);
         let actual = take(&array, &index, None).unwrap();
         let actual: &StructArray = actual.as_any().downcast_ref::<StructArray>().unwrap();
         assert_eq!(index.len(), actual.len());
@@ -2039,10 +1887,7 @@ mod tests {
 
     #[test]
     fn test_take_dict() {
-        let keys_builder = Int16Builder::new(8);
-        let values_builder = StringBuilder::new(4);
-
-        let mut dict_builder = StringDictionaryBuilder::new(keys_builder, values_builder);
+        let mut dict_builder = StringDictionaryBuilder::<Int16Type>::new();
 
         dict_builder.append("foo").unwrap();
         dict_builder.append("bar").unwrap();
@@ -2073,7 +1918,7 @@ mod tests {
             .downcast_ref::<DictionaryArray<Int16Type>>()
             .unwrap();
 
-        let result_values: StringArray = result.values().data().clone().into();
+        let result_values: StringArray = result.values().to_data().into();
 
         // dictionary values should stay the same
         let expected_values = StringArray::from(vec!["foo", "bar", ""]);
@@ -2091,4 +1936,177 @@ mod tests {
         ]);
         assert_eq!(result.keys(), &expected_keys);
     }
+
+    fn build_generic_list<S, T>(data: Vec<Option<Vec<T::Native>>>) -> GenericListArray<S>
+    where
+        S: OffsetSizeTrait + 'static,
+        T: ArrowPrimitiveType,
+        PrimitiveArray<T>: From<Vec<Option<T::Native>>>,
+    {
+        GenericListArray::from_iter_primitive::<T, _, _>(
+            data.iter()
+                .map(|x| x.as_ref().map(|x| x.iter().map(|x| Some(*x)))),
+        )
+    }
+
+    #[test]
+    fn test_take_value_index_from_list() {
+        let list = build_generic_list::<i32, Int32Type>(vec![
+            Some(vec![0, 1]),
+            Some(vec![2, 3, 4]),
+            Some(vec![5, 6, 7, 8, 9]),
+        ]);
+        let indices = UInt32Array::from(vec![2, 0]);
+
+        let (indexed, offsets, null_buf) = take_value_indices_from_list(&list, &indices).unwrap();
+
+        assert_eq!(indexed, Int32Array::from(vec![5, 6, 7, 8, 9, 0, 1]));
+        assert_eq!(offsets, vec![0, 5, 7]);
+        assert_eq!(null_buf.as_slice(), &[0b11111111]);
+    }
+
+    #[test]
+    fn test_take_value_index_from_large_list() {
+        let list = build_generic_list::<i64, Int32Type>(vec![
+            Some(vec![0, 1]),
+            Some(vec![2, 3, 4]),
+            Some(vec![5, 6, 7, 8, 9]),
+        ]);
+        let indices = UInt32Array::from(vec![2, 0]);
+
+        let (indexed, offsets, null_buf) =
+            take_value_indices_from_list::<_, Int64Type>(&list, &indices).unwrap();
+
+        assert_eq!(indexed, Int64Array::from(vec![5, 6, 7, 8, 9, 0, 1]));
+        assert_eq!(offsets, vec![0, 5, 7]);
+        assert_eq!(null_buf.as_slice(), &[0b11111111]);
+    }
+
+    #[test]
+    fn test_take_runs() {
+        let logical_array: Vec<i32> = vec![1_i32, 1, 2, 2, 1, 1, 1, 2, 2, 1, 1, 2, 2];
+
+        let mut builder = PrimitiveRunBuilder::<Int32Type, Int32Type>::new();
+        builder.extend(logical_array.into_iter().map(Some));
+        let run_array = builder.finish();
+
+        let take_indices: PrimitiveArray<Int32Type> =
+            vec![7, 2, 3, 7, 11, 4, 6].into_iter().collect();
+
+        let take_out = take_run(&run_array, &take_indices).unwrap();
+
+        assert_eq!(take_out.len(), 7);
+        assert_eq!(take_out.run_ends().len(), 7);
+        assert_eq!(take_out.run_ends().values(), &[1_i32, 3, 4, 5, 7]);
+
+        let take_out_values = take_out.values().as_primitive::<Int32Type>();
+        assert_eq!(take_out_values.values(), &[2, 2, 2, 2, 1]);
+    }
+
+    #[test]
+    fn test_take_value_index_from_fixed_list() {
+        let list = FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+            vec![
+                Some(vec![Some(1), Some(2), None]),
+                Some(vec![Some(4), None, Some(6)]),
+                None,
+                Some(vec![None, Some(8), Some(9)]),
+            ],
+            3,
+        );
+
+        let indices = UInt32Array::from(vec![2, 1, 0]);
+        let indexed = take_value_indices_from_fixed_size_list(&list, &indices, 3).unwrap();
+
+        assert_eq!(indexed, UInt32Array::from(vec![6, 7, 8, 3, 4, 5, 0, 1, 2]));
+
+        let indices = UInt32Array::from(vec![3, 2, 1, 2, 0]);
+        let indexed = take_value_indices_from_fixed_size_list(&list, &indices, 3).unwrap();
+
+        assert_eq!(
+            indexed,
+            UInt32Array::from(vec![9, 10, 11, 6, 7, 8, 3, 4, 5, 6, 7, 8, 0, 1, 2])
+        );
+    }
+
+    #[test]
+    fn test_take_null_indices() {
+        // Build indices with values that are out of bounds, but masked by null mask
+        let indices = Int32Array::new(
+            vec![1, 2, 400, 400].into(),
+            Some(NullBuffer::from(vec![true, true, false, false])),
+        );
+        let values = Int32Array::from(vec![1, 23, 4, 5]);
+        let r = take(&values, &indices, None).unwrap();
+        let values = r
+            .as_primitive::<Int32Type>()
+            .into_iter()
+            .collect::<Vec<_>>();
+        assert_eq!(&values, &[Some(23), Some(4), None, None])
+    }
+
+    #[test]
+    fn test_take_fixed_size_list_null_indices() {
+        let indices = Int32Array::from_iter([Some(0), None]);
+        let values = Arc::new(Int32Array::from(vec![0, 1, 2, 3]));
+        let arr_field = Arc::new(Field::new("item", values.data_type().clone(), true));
+        let values = FixedSizeListArray::try_new(arr_field, 2, values, None).unwrap();
+
+        let r = take(&values, &indices, None).unwrap();
+        let values = r
+            .as_fixed_size_list()
+            .values()
+            .as_primitive::<Int32Type>()
+            .into_iter()
+            .collect::<Vec<_>>();
+        assert_eq!(values, &[Some(0), Some(1), None, None])
+    }
+
+    #[test]
+    fn test_take_bytes_null_indices() {
+        let indices = Int32Array::new(
+            vec![0, 1, 400, 400].into(),
+            Some(NullBuffer::from_iter(vec![true, true, false, false])),
+        );
+        let values = StringArray::from(vec![Some("foo"), None]);
+        let r = take(&values, &indices, None).unwrap();
+        let values = r.as_string::<i32>().iter().collect::<Vec<_>>();
+        assert_eq!(&values, &[Some("foo"), None, None, None])
+    }
+
+    #[test]
+    fn test_take_union() {
+        let structs = create_test_struct(vec![
+            Some((Some(true), Some(42))),
+            Some((Some(false), Some(28))),
+            Some((Some(false), Some(19))),
+            Some((Some(true), Some(31))),
+            None,
+        ]);
+        let strings = StringArray::from(vec![Some("a"), None, Some("c"), None, Some("d")]);
+        let type_ids = Buffer::from_slice_ref(vec![1i8; 5]);
+
+        let children: Vec<(Field, Arc<dyn Array>)> = vec![
+            (
+                Field::new("f1", structs.data_type().clone(), true),
+                Arc::new(structs),
+            ),
+            (
+                Field::new("f2", strings.data_type().clone(), true),
+                Arc::new(strings),
+            ),
+        ];
+        let array = UnionArray::try_new(&[0, 1], type_ids, None, children).unwrap();
+
+        let indices = vec![0, 3, 1, 0, 2, 4];
+        let index = UInt32Array::from(indices.clone());
+        let actual = take(&array, &index, None).unwrap();
+        let actual = actual.as_any().downcast_ref::<UnionArray>().unwrap();
+        let strings = actual.child(1);
+        let strings = strings.as_any().downcast_ref::<StringArray>().unwrap();
+
+        let actual = strings.iter().collect::<Vec<_>>();
+        let expected = vec![Some("a"), None, None, Some("a"), Some("c"), Some("d")];
+        assert_eq!(expected, actual);
+    }
 }
diff --git a/arrow/src/compute/kernels/window.rs b/arrow-select/src/window.rs
similarity index 93%
rename from arrow/src/compute/kernels/window.rs
rename to arrow-select/src/window.rs
index 54b11c3b2747..2ad51561c69b 100644
--- a/arrow/src/compute/kernels/window.rs
+++ b/arrow-select/src/window.rs
@@ -17,12 +17,9 @@
 
 //! Defines windowing functions, like `shift`ing
 
-use crate::array::{Array, ArrayRef};
-use crate::error::Result;
-use crate::{
-    array::{make_array, new_null_array},
-    compute::concat,
-};
+use crate::concat::concat;
+use arrow_array::{make_array, new_null_array, Array, ArrayRef};
+use arrow_schema::ArrowError;
 use num::abs;
 
 /// Shifts array by defined number of items (to left or right)
@@ -30,9 +27,8 @@ use num::abs;
 /// a negative value shifts the array to the left.
 /// # Examples
 /// ```
-/// use arrow::array::Int32Array;
-/// use arrow::error::Result;
-/// use arrow::compute::shift;
+/// # use arrow_array::Int32Array;
+/// # use arrow_select::window::shift;
 ///
 /// let a: Int32Array = vec![Some(1), None, Some(4)].into();
 ///
@@ -56,10 +52,10 @@ use num::abs;
 /// let expected: Int32Array = vec![None, None, None].into();
 /// assert_eq!(res.as_ref(), &expected);
 /// ```
-pub fn shift(array: &dyn Array, offset: i64) -> Result<ArrayRef> {
+pub fn shift(array: &dyn Array, offset: i64) -> Result<ArrayRef, ArrowError> {
     let value_len = array.len() as i64;
     if offset == 0 {
-        Ok(make_array(array.data_ref().clone()))
+        Ok(make_array(array.to_data()))
     } else if offset == i64::MIN || abs(offset) >= value_len {
         Ok(new_null_array(array.data_type(), array.len()))
     } else {
@@ -86,7 +82,7 @@ pub fn shift(array: &dyn Array, offset: i64) -> Result<ArrayRef> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::array::{Float64Array, Int32Array, Int32DictionaryArray};
+    use arrow_array::{Float64Array, Int32Array, Int32DictionaryArray};
 
     #[test]
     fn test_shift_neg() {
diff --git a/arrow-select/src/zip.rs b/arrow-select/src/zip.rs
new file mode 100644
index 000000000000..ff2380ef2420
--- /dev/null
+++ b/arrow-select/src/zip.rs
@@ -0,0 +1,228 @@
+// 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.
+
+use crate::filter::SlicesIterator;
+use arrow_array::*;
+use arrow_data::transform::MutableArrayData;
+use arrow_schema::ArrowError;
+
+/// Zip two arrays by some boolean mask. Where the mask evaluates `true` values of `truthy`
+/// are taken, where the mask evaluates `false` values of `falsy` are taken.
+///
+/// # Arguments
+/// * `mask` - Boolean values used to determine from which array to take the values.
+/// * `truthy` - Values of this array are taken if mask evaluates `true`
+/// * `falsy` - Values of this array are taken if mask evaluates `false`
+pub fn zip(
+    mask: &BooleanArray,
+    truthy: &dyn Datum,
+    falsy: &dyn Datum,
+) -> Result<ArrayRef, ArrowError> {
+    let (truthy, truthy_is_scalar) = truthy.get();
+    let (falsy, falsy_is_scalar) = falsy.get();
+
+    if truthy.data_type() != falsy.data_type() {
+        return Err(ArrowError::InvalidArgumentError(
+            "arguments need to have the same data type".into(),
+        ));
+    }
+
+    if truthy_is_scalar && truthy.len() != 1 {
+        return Err(ArrowError::InvalidArgumentError(
+            "scalar arrays must have 1 element".into(),
+        ));
+    }
+    if !truthy_is_scalar && truthy.len() != mask.len() {
+        return Err(ArrowError::InvalidArgumentError(
+            "all arrays should have the same length".into(),
+        ));
+    }
+    if truthy_is_scalar && truthy.len() != 1 {
+        return Err(ArrowError::InvalidArgumentError(
+            "scalar arrays must have 1 element".into(),
+        ));
+    }
+    if !falsy_is_scalar && falsy.len() != mask.len() {
+        return Err(ArrowError::InvalidArgumentError(
+            "all arrays should have the same length".into(),
+        ));
+    }
+
+    let falsy = falsy.to_data();
+    let truthy = truthy.to_data();
+
+    let mut mutable = MutableArrayData::new(vec![&truthy, &falsy], false, truthy.len());
+
+    // the SlicesIterator slices only the true values. So the gaps left by this iterator we need to
+    // fill with falsy values
+
+    // keep track of how much is filled
+    let mut filled = 0;
+
+    SlicesIterator::new(mask).for_each(|(start, end)| {
+        // the gap needs to be filled with falsy values
+        if start > filled {
+            if falsy_is_scalar {
+                for _ in filled..start {
+                    // Copy the first item from the 'falsy' array into the output buffer.
+                    mutable.extend(1, 0, 1);
+                }
+            } else {
+                mutable.extend(1, filled, start);
+            }
+        }
+        // fill with truthy values
+        if truthy_is_scalar {
+            for _ in start..end {
+                // Copy the first item from the 'truthy' array into the output buffer.
+                mutable.extend(0, 0, 1);
+            }
+        } else {
+            mutable.extend(0, start, end);
+        }
+        filled = end;
+    });
+    // the remaining part is falsy
+    if filled < mask.len() {
+        if falsy_is_scalar {
+            for _ in filled..mask.len() {
+                // Copy the first item from the 'falsy' array into the output buffer.
+                mutable.extend(1, 0, 1);
+            }
+        } else {
+            mutable.extend(1, filled, mask.len());
+        }
+    }
+
+    let data = mutable.freeze();
+    Ok(make_array(data))
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn test_zip_kernel_one() {
+        let a = Int32Array::from(vec![Some(5), None, Some(7), None, Some(1)]);
+        let b = Int32Array::from(vec![None, Some(3), Some(6), Some(7), Some(3)]);
+        let mask = BooleanArray::from(vec![true, true, false, false, true]);
+        let out = zip(&mask, &a, &b).unwrap();
+        let actual = out.as_any().downcast_ref::<Int32Array>().unwrap();
+        let expected = Int32Array::from(vec![Some(5), None, Some(6), Some(7), Some(1)]);
+        assert_eq!(actual, &expected);
+    }
+
+    #[test]
+    fn test_zip_kernel_two() {
+        let a = Int32Array::from(vec![Some(5), None, Some(7), None, Some(1)]);
+        let b = Int32Array::from(vec![None, Some(3), Some(6), Some(7), Some(3)]);
+        let mask = BooleanArray::from(vec![false, false, true, true, false]);
+        let out = zip(&mask, &a, &b).unwrap();
+        let actual = out.as_any().downcast_ref::<Int32Array>().unwrap();
+        let expected = Int32Array::from(vec![None, Some(3), Some(7), None, Some(3)]);
+        assert_eq!(actual, &expected);
+    }
+
+    #[test]
+    fn test_zip_kernel_scalar_falsy_1() {
+        let a = Int32Array::from(vec![Some(5), None, Some(7), None, Some(1)]);
+
+        let fallback = Scalar::new(Int32Array::from_value(42, 1));
+
+        let mask = BooleanArray::from(vec![true, true, false, false, true]);
+        let out = zip(&mask, &a, &fallback).unwrap();
+        let actual = out.as_any().downcast_ref::<Int32Array>().unwrap();
+        let expected = Int32Array::from(vec![Some(5), None, Some(42), Some(42), Some(1)]);
+        assert_eq!(actual, &expected);
+    }
+
+    #[test]
+    fn test_zip_kernel_scalar_falsy_2() {
+        let a = Int32Array::from(vec![Some(5), None, Some(7), None, Some(1)]);
+
+        let fallback = Scalar::new(Int32Array::from_value(42, 1));
+
+        let mask = BooleanArray::from(vec![false, false, true, true, false]);
+        let out = zip(&mask, &a, &fallback).unwrap();
+        let actual = out.as_any().downcast_ref::<Int32Array>().unwrap();
+        let expected = Int32Array::from(vec![Some(42), Some(42), Some(7), None, Some(42)]);
+        assert_eq!(actual, &expected);
+    }
+
+    #[test]
+    fn test_zip_kernel_scalar_truthy_1() {
+        let a = Int32Array::from(vec![Some(5), None, Some(7), None, Some(1)]);
+
+        let fallback = Scalar::new(Int32Array::from_value(42, 1));
+
+        let mask = BooleanArray::from(vec![true, true, false, false, true]);
+        let out = zip(&mask, &fallback, &a).unwrap();
+        let actual = out.as_any().downcast_ref::<Int32Array>().unwrap();
+        let expected = Int32Array::from(vec![Some(42), Some(42), Some(7), None, Some(42)]);
+        assert_eq!(actual, &expected);
+    }
+
+    #[test]
+    fn test_zip_kernel_scalar_truthy_2() {
+        let a = Int32Array::from(vec![Some(5), None, Some(7), None, Some(1)]);
+
+        let fallback = Scalar::new(Int32Array::from_value(42, 1));
+
+        let mask = BooleanArray::from(vec![false, false, true, true, false]);
+        let out = zip(&mask, &fallback, &a).unwrap();
+        let actual = out.as_any().downcast_ref::<Int32Array>().unwrap();
+        let expected = Int32Array::from(vec![Some(5), None, Some(42), Some(42), Some(1)]);
+        assert_eq!(actual, &expected);
+    }
+
+    #[test]
+    fn test_zip_kernel_scalar_both() {
+        let scalar_truthy = Scalar::new(Int32Array::from_value(42, 1));
+        let scalar_falsy = Scalar::new(Int32Array::from_value(123, 1));
+
+        let mask = BooleanArray::from(vec![true, true, false, false, true]);
+        let out = zip(&mask, &scalar_truthy, &scalar_falsy).unwrap();
+        let actual = out.as_any().downcast_ref::<Int32Array>().unwrap();
+        let expected = Int32Array::from(vec![Some(42), Some(42), Some(123), Some(123), Some(42)]);
+        assert_eq!(actual, &expected);
+    }
+
+    #[test]
+    fn test_zip_kernel_scalar_none_1() {
+        let scalar_truthy = Scalar::new(Int32Array::from_value(42, 1));
+        let scalar_falsy = Scalar::new(Int32Array::new_null(1));
+
+        let mask = BooleanArray::from(vec![true, true, false, false, true]);
+        let out = zip(&mask, &scalar_truthy, &scalar_falsy).unwrap();
+        let actual = out.as_any().downcast_ref::<Int32Array>().unwrap();
+        let expected = Int32Array::from(vec![Some(42), Some(42), None, None, Some(42)]);
+        assert_eq!(actual, &expected);
+    }
+
+    #[test]
+    fn test_zip_kernel_scalar_none_2() {
+        let scalar_truthy = Scalar::new(Int32Array::from_value(42, 1));
+        let scalar_falsy = Scalar::new(Int32Array::new_null(1));
+
+        let mask = BooleanArray::from(vec![false, false, true, true, false]);
+        let out = zip(&mask, &scalar_truthy, &scalar_falsy).unwrap();
+        let actual = out.as_any().downcast_ref::<Int32Array>().unwrap();
+        let expected = Int32Array::from(vec![None, None, Some(42), Some(42), None]);
+        assert_eq!(actual, &expected);
+    }
+}
diff --git a/arrow-string/Cargo.toml b/arrow-string/Cargo.toml
new file mode 100644
index 000000000000..bdfa681113b4
--- /dev/null
+++ b/arrow-string/Cargo.toml
@@ -0,0 +1,45 @@
+# 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]
+name = "arrow-string"
+version = { workspace = true }
+description = "String kernels for arrow arrays"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
+keywords = { workspace = true }
+include = { workspace = true }
+edition = { workspace = true }
+rust-version = { workspace = true }
+
+[lib]
+name = "arrow_string"
+path = "src/lib.rs"
+bench = false
+
+[dependencies]
+arrow-buffer = { workspace = true }
+arrow-data = { workspace = true }
+arrow-schema = { workspace = true }
+arrow-array = { workspace = true }
+arrow-select = { workspace = true }
+regex = { version = "1.7.0", default-features = false, features = ["std", "unicode", "perf"] }
+regex-syntax = { version = "0.8.0", default-features = false, features = ["unicode"] }
+num = { version = "0.4", default-features = false, features = ["std"] }
+memchr = "2.7.1"
diff --git a/arrow/src/compute/kernels/concat_elements.rs b/arrow-string/src/concat_elements.rs
similarity index 56%
rename from arrow/src/compute/kernels/concat_elements.rs
rename to arrow-string/src/concat_elements.rs
index ac365a0968ec..66ecd34868a5 100644
--- a/arrow/src/compute/kernels/concat_elements.rs
+++ b/arrow-string/src/concat_elements.rs
@@ -15,28 +15,20 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::array::*;
-use crate::compute::util::combine_option_bitmap;
-use crate::error::{ArrowError, Result};
-
-/// Returns the elementwise concatenation of a [`StringArray`].
-///
-/// An index of the resulting [`StringArray`] is null if any of
-/// `StringArray` are null at that location.
-///
-/// ```text
-/// e.g:
-///
-///   ["Hello"] + ["World"] = ["HelloWorld"]
-///
-///   ["a", "b"] + [None, "c"] = [None, "bc"]
-/// ```
-///
-/// An error will be returned if `left` and `right` have different lengths
-pub fn concat_elements_utf8<Offset: OffsetSizeTrait>(
-    left: &GenericStringArray<Offset>,
-    right: &GenericStringArray<Offset>,
-) -> Result<GenericStringArray<Offset>> {
+use std::sync::Arc;
+
+use arrow_array::builder::BufferBuilder;
+use arrow_array::types::ByteArrayType;
+use arrow_array::*;
+use arrow_buffer::{ArrowNativeType, NullBuffer};
+use arrow_data::ArrayDataBuilder;
+use arrow_schema::{ArrowError, DataType};
+
+/// Returns the elementwise concatenation of a [`GenericByteArray`].
+pub fn concat_elements_bytes<T: ByteArrayType>(
+    left: &GenericByteArray<T>,
+    right: &GenericByteArray<T>,
+) -> Result<GenericByteArray<T>, ArrowError> {
     if left.len() != right.len() {
         return Err(ArrowError::ComputeError(format!(
             "Arrays must have the same length: {} != {}",
@@ -45,46 +37,67 @@ pub fn concat_elements_utf8<Offset: OffsetSizeTrait>(
         )));
     }
 
-    let output_bitmap = combine_option_bitmap(&[left.data(), right.data()], left.len())?;
+    let nulls = NullBuffer::union(left.nulls(), right.nulls());
 
     let left_offsets = left.value_offsets();
     let right_offsets = right.value_offsets();
 
-    let left_buffer = left.value_data();
-    let right_buffer = right.value_data();
-    let left_values = left_buffer.as_slice();
-    let right_values = right_buffer.as_slice();
+    let left_values = left.value_data();
+    let right_values = right.value_data();
 
     let mut output_values = BufferBuilder::<u8>::new(
         left_values.len() + right_values.len()
-            - left_offsets[0].to_usize().unwrap()
-            - right_offsets[0].to_usize().unwrap(),
+            - left_offsets[0].as_usize()
+            - right_offsets[0].as_usize(),
     );
 
-    let mut output_offsets = BufferBuilder::<Offset>::new(left_offsets.len());
-    output_offsets.append(Offset::zero());
+    let mut output_offsets = BufferBuilder::<T::Offset>::new(left_offsets.len());
+    output_offsets.append(T::Offset::usize_as(0));
     for (left_idx, right_idx) in left_offsets.windows(2).zip(right_offsets.windows(2)) {
-        output_values.append_slice(
-            &left_values
-                [left_idx[0].to_usize().unwrap()..left_idx[1].to_usize().unwrap()],
-        );
-        output_values.append_slice(
-            &right_values
-                [right_idx[0].to_usize().unwrap()..right_idx[1].to_usize().unwrap()],
-        );
-        output_offsets.append(Offset::from_usize(output_values.len()).unwrap());
+        output_values.append_slice(&left_values[left_idx[0].as_usize()..left_idx[1].as_usize()]);
+        output_values.append_slice(&right_values[right_idx[0].as_usize()..right_idx[1].as_usize()]);
+        output_offsets.append(T::Offset::from_usize(output_values.len()).unwrap());
     }
 
-    let builder = ArrayDataBuilder::new(GenericStringArray::<Offset>::DATA_TYPE)
+    let builder = ArrayDataBuilder::new(T::DATA_TYPE)
         .len(left.len())
         .add_buffer(output_offsets.finish())
         .add_buffer(output_values.finish())
-        .null_bit_buffer(output_bitmap);
+        .nulls(nulls);
 
     // SAFETY - offsets valid by construction
     Ok(unsafe { builder.build_unchecked() }.into())
 }
 
+/// Returns the elementwise concatenation of a [`GenericStringArray`].
+///
+/// An index of the resulting [`GenericStringArray`] is null if any of
+/// `StringArray` are null at that location.
+///
+/// ```text
+/// e.g:
+///
+///   ["Hello"] + ["World"] = ["HelloWorld"]
+///
+///   ["a", "b"] + [None, "c"] = [None, "bc"]
+/// ```
+///
+/// An error will be returned if `left` and `right` have different lengths
+pub fn concat_elements_utf8<Offset: OffsetSizeTrait>(
+    left: &GenericStringArray<Offset>,
+    right: &GenericStringArray<Offset>,
+) -> Result<GenericStringArray<Offset>, ArrowError> {
+    concat_elements_bytes(left, right)
+}
+
+/// Returns the elementwise concatenation of a [`GenericBinaryArray`].
+pub fn concat_element_binary<Offset: OffsetSizeTrait>(
+    left: &GenericBinaryArray<Offset>,
+    right: &GenericBinaryArray<Offset>,
+) -> Result<GenericBinaryArray<Offset>, ArrowError> {
+    concat_elements_bytes(left, right)
+}
+
 /// Returns the elementwise concatenation of [`StringArray`].
 /// ```text
 /// e.g:
@@ -94,7 +107,7 @@ pub fn concat_elements_utf8<Offset: OffsetSizeTrait>(
 /// An error will be returned if the [`StringArray`] are of different lengths
 pub fn concat_elements_utf8_many<Offset: OffsetSizeTrait>(
     arrays: &[&GenericStringArray<Offset>],
-) -> Result<GenericStringArray<Offset>> {
+) -> Result<GenericStringArray<Offset>, ArrowError> {
     if arrays.is_empty() {
         return Err(ArrowError::ComputeError(
             "concat requires input of at least one array".to_string(),
@@ -104,28 +117,17 @@ pub fn concat_elements_utf8_many<Offset: OffsetSizeTrait>(
     let size = arrays[0].len();
     if !arrays.iter().all(|array| array.len() == size) {
         return Err(ArrowError::ComputeError(format!(
-            "Arrays must have the same length of {}",
-            size,
+            "Arrays must have the same length of {size}",
         )));
     }
 
-    let output_bitmap = combine_option_bitmap(
-        arrays
-            .iter()
-            .map(|a| a.data())
-            .collect::<Vec<_>>()
-            .as_slice(),
-        size,
-    )?;
-
-    let data_buffers = arrays
+    let nulls = arrays
         .iter()
-        .map(|array| array.value_data())
-        .collect::<Vec<_>>();
+        .fold(None, |acc, a| NullBuffer::union(acc.as_ref(), a.nulls()));
 
-    let data_values = data_buffers
+    let data_values = arrays
         .iter()
-        .map(|buffer| buffer.as_slice())
+        .map(|array| array.value_data())
         .collect::<Vec<_>>();
 
     let mut offsets = arrays
@@ -137,7 +139,7 @@ pub fn concat_elements_utf8_many<Offset: OffsetSizeTrait>(
         data_values
             .iter()
             .zip(offsets.iter_mut())
-            .map(|(data, offset)| data.len() - offset.peek().unwrap().to_usize().unwrap())
+            .map(|(data, offset)| data.len() - offset.peek().unwrap().as_usize())
             .sum(),
     );
 
@@ -148,8 +150,8 @@ pub fn concat_elements_utf8_many<Offset: OffsetSizeTrait>(
             .iter()
             .zip(offsets.iter_mut())
             .for_each(|(values, offset)| {
-                let index_start = offset.next().unwrap().to_usize().unwrap();
-                let index_end = offset.peek().unwrap().to_usize().unwrap();
+                let index_start = offset.next().unwrap().as_usize();
+                let index_end = offset.peek().unwrap().as_usize();
                 output_values.append_slice(&values[index_start..index_end]);
             });
         output_offsets.append(Offset::from_usize(output_values.len()).unwrap());
@@ -159,15 +161,53 @@ pub fn concat_elements_utf8_many<Offset: OffsetSizeTrait>(
         .len(size)
         .add_buffer(output_offsets.finish())
         .add_buffer(output_values.finish())
-        .null_bit_buffer(output_bitmap);
+        .nulls(nulls);
 
     // SAFETY - offsets valid by construction
     Ok(unsafe { builder.build_unchecked() }.into())
 }
 
+pub fn concat_elements_dyn(left: &dyn Array, right: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    if left.data_type() != right.data_type() {
+        return Err(ArrowError::ComputeError(format!(
+            "Cannot concat arrays of different types: {} != {}",
+            left.data_type(),
+            right.data_type()
+        )));
+    }
+    match (left.data_type(), right.data_type()) {
+        (DataType::Utf8, DataType::Utf8) => {
+            let left = left.as_any().downcast_ref::<StringArray>().unwrap();
+            let right = right.as_any().downcast_ref::<StringArray>().unwrap();
+            Ok(Arc::new(concat_elements_utf8(left, right).unwrap()))
+        }
+        (DataType::LargeUtf8, DataType::LargeUtf8) => {
+            let left = left.as_any().downcast_ref::<LargeStringArray>().unwrap();
+            let right = right.as_any().downcast_ref::<LargeStringArray>().unwrap();
+            Ok(Arc::new(concat_elements_utf8(left, right).unwrap()))
+        }
+        (DataType::Binary, DataType::Binary) => {
+            let left = left.as_any().downcast_ref::<BinaryArray>().unwrap();
+            let right = right.as_any().downcast_ref::<BinaryArray>().unwrap();
+            Ok(Arc::new(concat_element_binary(left, right).unwrap()))
+        }
+        (DataType::LargeBinary, DataType::LargeBinary) => {
+            let left = left.as_any().downcast_ref::<LargeBinaryArray>().unwrap();
+            let right = right.as_any().downcast_ref::<LargeBinaryArray>().unwrap();
+            Ok(Arc::new(concat_element_binary(left, right).unwrap()))
+        }
+        // unimplemented
+        _ => Err(ArrowError::NotYetImplemented(format!(
+            "concat not supported for {}",
+            left.data_type()
+        ))),
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
+    use arrow_array::StringArray;
     #[test]
     fn test_string_concat() {
         let left = [Some("foo"), Some("bar"), None]
@@ -309,4 +349,61 @@ mod tests {
 
         assert_eq!(output, expected);
     }
+
+    #[test]
+    fn test_concat_dyn_same_type() {
+        // test for StringArray
+        let left = StringArray::from(vec![Some("foo"), Some("bar"), None]);
+        let right = StringArray::from(vec![None, Some("yyy"), Some("zzz")]);
+
+        let output: StringArray = concat_elements_dyn(&left, &right)
+            .unwrap()
+            .into_data()
+            .into();
+        let expected = StringArray::from(vec![None, Some("baryyy"), None]);
+        assert_eq!(output, expected);
+
+        // test for LargeStringArray
+        let left = LargeStringArray::from(vec![Some("foo"), Some("bar"), None]);
+        let right = LargeStringArray::from(vec![None, Some("yyy"), Some("zzz")]);
+
+        let output: LargeStringArray = concat_elements_dyn(&left, &right)
+            .unwrap()
+            .into_data()
+            .into();
+        let expected = LargeStringArray::from(vec![None, Some("baryyy"), None]);
+        assert_eq!(output, expected);
+
+        // test for BinaryArray
+        let left = BinaryArray::from_opt_vec(vec![Some(b"foo"), Some(b"bar"), None]);
+        let right = BinaryArray::from_opt_vec(vec![None, Some(b"yyy"), Some(b"zzz")]);
+        let output: BinaryArray = concat_elements_dyn(&left, &right)
+            .unwrap()
+            .into_data()
+            .into();
+        let expected = BinaryArray::from_opt_vec(vec![None, Some(b"baryyy"), None]);
+        assert_eq!(output, expected);
+
+        // test for LargeBinaryArray
+        let left = LargeBinaryArray::from_opt_vec(vec![Some(b"foo"), Some(b"bar"), None]);
+        let right = LargeBinaryArray::from_opt_vec(vec![None, Some(b"yyy"), Some(b"zzz")]);
+        let output: LargeBinaryArray = concat_elements_dyn(&left, &right)
+            .unwrap()
+            .into_data()
+            .into();
+        let expected = LargeBinaryArray::from_opt_vec(vec![None, Some(b"baryyy"), None]);
+        assert_eq!(output, expected);
+    }
+
+    #[test]
+    fn test_concat_dyn_different_type() {
+        let left = StringArray::from(vec![Some("foo"), Some("bar"), None]);
+        let right = LargeStringArray::from(vec![None, Some("1"), Some("2")]);
+
+        let output = concat_elements_dyn(&left, &right);
+        assert_eq!(
+            output.unwrap_err().to_string(),
+            "Compute error: Cannot concat arrays of different types: Utf8 != LargeUtf8".to_string()
+        );
+    }
 }
diff --git a/arrow/src/compute/kernels/length.rs b/arrow-string/src/length.rs
similarity index 56%
rename from arrow/src/compute/kernels/length.rs
rename to arrow-string/src/length.rs
index a68aa2bde4eb..1dd5933ce0e5 100644
--- a/arrow/src/compute/kernels/length.rs
+++ b/arrow-string/src/length.rs
@@ -17,168 +17,76 @@
 
 //! Defines kernel for length of string arrays and binary arrays
 
-use crate::{array::*, buffer::Buffer, datatypes::ArrowPrimitiveType};
-use crate::{
-    datatypes::*,
-    error::{ArrowError, Result},
-};
-
+use arrow_array::*;
+use arrow_array::{cast::AsArray, types::*};
+use arrow_buffer::{ArrowNativeType, NullBuffer, OffsetBuffer};
+use arrow_schema::{ArrowError, DataType};
 use std::sync::Arc;
 
-macro_rules! unary_offsets {
-    ($array: expr, $data_type: expr, $op: expr) => {{
-        let slice = $array.value_offsets();
-
-        let lengths = slice.windows(2).map(|offset| $op(offset[1] - offset[0]));
-
-        // JUSTIFICATION
-        //  Benefit
-        //      ~60% speedup
-        //  Soundness
-        //      `values` come from a slice iterator with a known size.
-        let buffer = unsafe { Buffer::from_trusted_len_iter(lengths) };
-
-        let null_bit_buffer = $array
-            .data_ref()
-            .null_buffer()
-            .map(|b| b.bit_slice($array.offset(), $array.len()));
-
-        let data = unsafe {
-            ArrayData::new_unchecked(
-                $data_type,
-                $array.len(),
-                None,
-                null_bit_buffer,
-                0,
-                vec![buffer],
-                vec![],
-            )
-        };
-        make_array(data)
-    }};
-}
-
-macro_rules! kernel_dict {
-    ($array: ident, $kernel: expr, $kt: ident, $($t: ident: $gt: ident), *) => {
-        match $kt.as_ref() {
-            $(&DataType::$t => {
-                let dict = $array
-                    .as_any()
-                    .downcast_ref::<DictionaryArray<$gt>>()
-                    .unwrap_or_else(|| {
-                        panic!("Expect 'DictionaryArray<{}>' but got array of data type {:?}",
-                            stringify!($gt), $array.data_type())
-                    });
-                let values = $kernel(dict.values())?;
-                let result = DictionaryArray::try_new(dict.keys(), &values)?;
-                    Ok(Arc::new(result))
-                },
-            )*
-            t => panic!("Unsupported dictionary key type: {}", t)
-        }
-    }
-}
-
-fn length_list<O, T>(array: &dyn Array) -> ArrayRef
-where
-    O: OffsetSizeTrait,
-    T: ArrowPrimitiveType,
-    T::Native: OffsetSizeTrait,
-{
-    let array = array
-        .as_any()
-        .downcast_ref::<GenericListArray<O>>()
-        .unwrap();
-    unary_offsets!(array, T::DATA_TYPE, |x| x)
-}
-
-fn length_binary<O, T>(array: &dyn Array) -> ArrayRef
-where
-    O: OffsetSizeTrait,
-    T: ArrowPrimitiveType,
-    T::Native: OffsetSizeTrait,
-{
-    let array = array
-        .as_any()
-        .downcast_ref::<GenericBinaryArray<O>>()
-        .unwrap();
-    unary_offsets!(array, T::DATA_TYPE, |x| x)
+fn length_impl<P: ArrowPrimitiveType>(
+    offsets: &OffsetBuffer<P::Native>,
+    nulls: Option<&NullBuffer>,
+) -> ArrayRef {
+    let v: Vec<_> = offsets
+        .windows(2)
+        .map(|w| w[1].sub_wrapping(w[0]))
+        .collect();
+    Arc::new(PrimitiveArray::<P>::new(v.into(), nulls.cloned()))
 }
 
-fn length_string<O, T>(array: &dyn Array) -> ArrayRef
-where
-    O: OffsetSizeTrait,
-    T: ArrowPrimitiveType,
-    T::Native: OffsetSizeTrait,
-{
-    let array = array
-        .as_any()
-        .downcast_ref::<GenericStringArray<O>>()
-        .unwrap();
-    unary_offsets!(array, T::DATA_TYPE, |x| x)
-}
-
-fn bit_length_binary<O, T>(array: &dyn Array) -> ArrayRef
-where
-    O: OffsetSizeTrait,
-    T: ArrowPrimitiveType,
-    T::Native: OffsetSizeTrait,
-{
-    let array = array
-        .as_any()
-        .downcast_ref::<GenericBinaryArray<O>>()
-        .unwrap();
-    let bits_in_bytes = O::from_usize(8).unwrap();
-    unary_offsets!(array, T::DATA_TYPE, |x| x * bits_in_bytes)
-}
-
-fn bit_length_string<O, T>(array: &dyn Array) -> ArrayRef
-where
-    O: OffsetSizeTrait,
-    T: ArrowPrimitiveType,
-    T::Native: OffsetSizeTrait,
-{
-    let array = array
-        .as_any()
-        .downcast_ref::<GenericStringArray<O>>()
-        .unwrap();
-    let bits_in_bytes = O::from_usize(8).unwrap();
-    unary_offsets!(array, T::DATA_TYPE, |x| x * bits_in_bytes)
+fn bit_length_impl<P: ArrowPrimitiveType>(
+    offsets: &OffsetBuffer<P::Native>,
+    nulls: Option<&NullBuffer>,
+) -> ArrayRef {
+    let bits = P::Native::usize_as(8);
+    let c = |w: &[P::Native]| w[1].sub_wrapping(w[0]).mul_wrapping(bits);
+    let v: Vec<_> = offsets.windows(2).map(c).collect();
+    Arc::new(PrimitiveArray::<P>::new(v.into(), nulls.cloned()))
 }
 
 /// Returns an array of Int32/Int64 denoting the length of each value in the array.
 /// For list array, length is the number of elements in each list.
 /// For string array and binary array, length is the number of bytes of each value.
 ///
-/// * this only accepts ListArray/LargeListArray, StringArray/LargeStringArray and BinaryArray/LargeBinaryArray,
+/// * this only accepts ListArray/LargeListArray, StringArray/LargeStringArray, BinaryArray/LargeBinaryArray, and FixedSizeListArray,
 ///   or DictionaryArray with above Arrays as values
 /// * length of null is null.
-pub fn length(array: &dyn Array) -> Result<ArrayRef> {
+pub fn length(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    if let Some(d) = array.as_any_dictionary_opt() {
+        let lengths = length(d.values().as_ref())?;
+        return Ok(d.with_values(lengths));
+    }
+
     match array.data_type() {
-        DataType::Dictionary(kt, _) => {
-            kernel_dict!(
-                array,
-                |a| { length(a) },
-                kt,
-                Int8: Int8Type,
-                Int16: Int16Type,
-                Int32: Int32Type,
-                Int64: Int64Type,
-                UInt8: UInt8Type,
-                UInt16: UInt16Type,
-                UInt32: UInt32Type,
-                UInt64: UInt64Type
-            )
+        DataType::List(_) => {
+            let list = array.as_list::<i32>();
+            Ok(length_impl::<Int32Type>(list.offsets(), list.nulls()))
+        }
+        DataType::LargeList(_) => {
+            let list = array.as_list::<i64>();
+            Ok(length_impl::<Int64Type>(list.offsets(), list.nulls()))
+        }
+        DataType::Utf8 => {
+            let list = array.as_string::<i32>();
+            Ok(length_impl::<Int32Type>(list.offsets(), list.nulls()))
+        }
+        DataType::LargeUtf8 => {
+            let list = array.as_string::<i64>();
+            Ok(length_impl::<Int64Type>(list.offsets(), list.nulls()))
         }
-        DataType::List(_) => Ok(length_list::<i32, Int32Type>(array)),
-        DataType::LargeList(_) => Ok(length_list::<i64, Int64Type>(array)),
-        DataType::Utf8 => Ok(length_string::<i32, Int32Type>(array)),
-        DataType::LargeUtf8 => Ok(length_string::<i64, Int64Type>(array)),
-        DataType::Binary => Ok(length_binary::<i32, Int32Type>(array)),
-        DataType::LargeBinary => Ok(length_binary::<i64, Int64Type>(array)),
+        DataType::Binary => {
+            let list = array.as_binary::<i32>();
+            Ok(length_impl::<Int32Type>(list.offsets(), list.nulls()))
+        }
+        DataType::LargeBinary => {
+            let list = array.as_binary::<i64>();
+            Ok(length_impl::<Int64Type>(list.offsets(), list.nulls()))
+        }
+        DataType::FixedSizeBinary(len) | DataType::FixedSizeList(_, len) => Ok(Arc::new(
+            Int32Array::new(vec![*len; array.len()].into(), array.nulls().cloned()),
+        )),
         other => Err(ArrowError::ComputeError(format!(
-            "length not supported for {:?}",
-            other
+            "length not supported for {other:?}"
         ))),
     }
 }
@@ -189,30 +97,43 @@ pub fn length(array: &dyn Array) -> Result<ArrayRef> {
 ///   or DictionaryArray with above Arrays as values
 /// * bit_length of null is null.
 /// * bit_length is in number of bits
-pub fn bit_length(array: &dyn Array) -> Result<ArrayRef> {
+pub fn bit_length(array: &dyn Array) -> Result<ArrayRef, ArrowError> {
+    if let Some(d) = array.as_any_dictionary_opt() {
+        let lengths = bit_length(d.values().as_ref())?;
+        return Ok(d.with_values(lengths));
+    }
+
     match array.data_type() {
-        DataType::Dictionary(kt, _) => {
-            kernel_dict!(
-                array,
-                |a| { bit_length(a) },
-                kt,
-                Int8: Int8Type,
-                Int16: Int16Type,
-                Int32: Int32Type,
-                Int64: Int64Type,
-                UInt8: UInt8Type,
-                UInt16: UInt16Type,
-                UInt32: UInt32Type,
-                UInt64: UInt64Type
-            )
+        DataType::List(_) => {
+            let list = array.as_list::<i32>();
+            Ok(bit_length_impl::<Int32Type>(list.offsets(), list.nulls()))
+        }
+        DataType::LargeList(_) => {
+            let list = array.as_list::<i64>();
+            Ok(bit_length_impl::<Int64Type>(list.offsets(), list.nulls()))
         }
-        DataType::Utf8 => Ok(bit_length_string::<i32, Int32Type>(array)),
-        DataType::LargeUtf8 => Ok(bit_length_string::<i64, Int64Type>(array)),
-        DataType::Binary => Ok(bit_length_binary::<i32, Int32Type>(array)),
-        DataType::LargeBinary => Ok(bit_length_binary::<i64, Int64Type>(array)),
+        DataType::Utf8 => {
+            let list = array.as_string::<i32>();
+            Ok(bit_length_impl::<Int32Type>(list.offsets(), list.nulls()))
+        }
+        DataType::LargeUtf8 => {
+            let list = array.as_string::<i64>();
+            Ok(bit_length_impl::<Int64Type>(list.offsets(), list.nulls()))
+        }
+        DataType::Binary => {
+            let list = array.as_binary::<i32>();
+            Ok(bit_length_impl::<Int32Type>(list.offsets(), list.nulls()))
+        }
+        DataType::LargeBinary => {
+            let list = array.as_binary::<i64>();
+            Ok(bit_length_impl::<Int64Type>(list.offsets(), list.nulls()))
+        }
+        DataType::FixedSizeBinary(len) => Ok(Arc::new(Int32Array::new(
+            vec![*len * 8; array.len()].into(),
+            array.nulls().cloned(),
+        ))),
         other => Err(ArrowError::ComputeError(format!(
-            "bit_length not supported for {:?}",
-            other
+            "bit_length not supported for {other:?}"
         ))),
     }
 }
@@ -220,19 +141,16 @@ pub fn bit_length(array: &dyn Array) -> Result<ArrayRef> {
 #[cfg(test)]
 mod tests {
     use super::*;
-
-    fn double_vec<T: Clone>(v: Vec<T>) -> Vec<T> {
-        [&v[..], &v[..]].concat()
-    }
+    use arrow_array::cast::AsArray;
+    use arrow_buffer::{Buffer, NullBuffer};
+    use arrow_data::ArrayData;
+    use arrow_schema::Field;
 
     fn length_cases_string() -> Vec<(Vec<&'static str>, usize, Vec<i32>)> {
         // a large array
-        let mut values = vec!["one", "on", "o", ""];
-        let mut expected = vec![3, 2, 1, 0];
-        for _ in 0..10 {
-            values = double_vec(values);
-            expected = double_vec(expected);
-        }
+        let values = ["one", "on", "o", ""];
+        let values = values.into_iter().cycle().take(4096).collect();
+        let expected = [3, 2, 1, 0].into_iter().cycle().take(4096).collect();
 
         vec![
             (vec!["hello", " ", "world"], 3, vec![5, 1, 5]),
@@ -245,78 +163,70 @@ mod tests {
     macro_rules! length_binary_helper {
         ($offset_ty: ty, $result_ty: ty, $kernel: ident, $value: expr, $expected: expr) => {{
             let array = GenericBinaryArray::<$offset_ty>::from($value);
-            let result = $kernel(&array)?;
+            let result = $kernel(&array).unwrap();
             let result = result.as_any().downcast_ref::<$result_ty>().unwrap();
             let expected: $result_ty = $expected.into();
-            assert_eq!(expected.data(), result.data());
-            Ok(())
+            assert_eq!(&expected, result);
         }};
     }
 
     macro_rules! length_list_helper {
         ($offset_ty: ty, $result_ty: ty, $element_ty: ty, $value: expr, $expected: expr) => {{
             let array =
-                GenericListArray::<$offset_ty>::from_iter_primitive::<$element_ty, _, _>(
-                    $value,
-                );
-            let result = length(&array)?;
+                GenericListArray::<$offset_ty>::from_iter_primitive::<$element_ty, _, _>($value);
+            let result = length(&array).unwrap();
             let result = result.as_any().downcast_ref::<$result_ty>().unwrap();
             let expected: $result_ty = $expected.into();
-            assert_eq!(expected.data(), result.data());
-            Ok(())
+            assert_eq!(&expected, result);
         }};
     }
 
     #[test]
-    #[cfg_attr(miri, ignore)] // running forever
-    fn length_test_string() -> Result<()> {
+    fn length_test_string() {
         length_cases_string()
             .into_iter()
-            .try_for_each(|(input, len, expected)| {
+            .for_each(|(input, len, expected)| {
                 let array = StringArray::from(input);
-                let result = length(&array)?;
+                let result = length(&array).unwrap();
                 assert_eq!(len, result.len());
                 let result = result.as_any().downcast_ref::<Int32Array>().unwrap();
                 expected.iter().enumerate().for_each(|(i, value)| {
                     assert_eq!(*value, result.value(i));
                 });
-                Ok(())
             })
     }
 
     #[test]
-    #[cfg_attr(miri, ignore)] // running forever
-    fn length_test_large_string() -> Result<()> {
+    fn length_test_large_string() {
         length_cases_string()
             .into_iter()
-            .try_for_each(|(input, len, expected)| {
+            .for_each(|(input, len, expected)| {
                 let array = LargeStringArray::from(input);
-                let result = length(&array)?;
+                let result = length(&array).unwrap();
                 assert_eq!(len, result.len());
                 let result = result.as_any().downcast_ref::<Int64Array>().unwrap();
                 expected.iter().enumerate().for_each(|(i, value)| {
                     assert_eq!(*value as i64, result.value(i));
                 });
-                Ok(())
             })
     }
 
     #[test]
-    fn length_test_binary() -> Result<()> {
+    fn length_test_binary() {
         let value: Vec<&[u8]> = vec![b"zero", b"one", &[0xff, 0xf8]];
         let result: Vec<i32> = vec![4, 3, 2];
         length_binary_helper!(i32, Int32Array, length, value, result)
     }
 
     #[test]
-    fn length_test_large_binary() -> Result<()> {
+    fn length_test_large_binary() {
         let value: Vec<&[u8]> = vec![b"zero", &[0xff, 0xf8], b"two"];
         let result: Vec<i64> = vec![4, 2, 3];
         length_binary_helper!(i64, Int64Array, length, value, result)
     }
 
     #[test]
-    fn length_test_list() -> Result<()> {
+    fn length_test_list() {
         let value = vec![
             Some(vec![]),
             Some(vec![Some(1), Some(2), Some(4)]),
@@ -327,7 +237,7 @@ mod tests {
     }
 
     #[test]
-    fn length_test_large_list() -> Result<()> {
+    fn length_test_large_list() {
         let value = vec![
             Some(vec![]),
             Some(vec![Some(1.1), Some(2.2), Some(3.3)]),
@@ -348,28 +258,27 @@ mod tests {
     }
 
     #[test]
-    fn length_null_string() -> Result<()> {
+    fn length_null_string() {
         length_null_cases_string()
             .into_iter()
-            .try_for_each(|(input, len, expected)| {
+            .for_each(|(input, len, expected)| {
                 let array = StringArray::from(input);
-                let result = length(&array)?;
+                let result = length(&array).unwrap();
                 assert_eq!(len, result.len());
                 let result = result.as_any().downcast_ref::<Int32Array>().unwrap();
 
                 let expected: Int32Array = expected.into();
-                assert_eq!(expected.data(), result.data());
-                Ok(())
+                assert_eq!(&expected, result);
             })
     }
 
     #[test]
-    fn length_null_large_string() -> Result<()> {
+    fn length_null_large_string() {
         length_null_cases_string()
             .into_iter()
-            .try_for_each(|(input, len, expected)| {
+            .for_each(|(input, len, expected)| {
                 let array = LargeStringArray::from(input);
-                let result = length(&array)?;
+                let result = length(&array).unwrap();
                 assert_eq!(len, result.len());
                 let result = result.as_any().downcast_ref::<Int64Array>().unwrap();
 
@@ -379,13 +288,12 @@ mod tests {
                     .map(|e| e.map(|e| e as i64))
                     .collect::<Vec<_>>()
                     .into();
-                assert_eq!(expected.data(), result.data());
-                Ok(())
+                assert_eq!(&expected, result);
             })
     }
 
     #[test]
-    fn length_null_binary() -> Result<()> {
+    fn length_null_binary() {
         let value: Vec<Option<&[u8]>> =
             vec![Some(b"zero"), None, Some(&[0xff, 0xf8]), Some(b"three")];
         let result: Vec<Option<i32>> = vec![Some(4), None, Some(2), Some(5)];
@@ -393,7 +301,7 @@ mod tests {
     }
 
     #[test]
-    fn length_null_large_binary() -> Result<()> {
+    fn length_null_large_binary() {
         let value: Vec<Option<&[u8]>> =
             vec![Some(&[0xff, 0xf8]), None, Some(b"two"), Some(b"three")];
         let result: Vec<Option<i64>> = vec![Some(2), None, Some(3), Some(5)];
@@ -401,7 +309,7 @@ mod tests {
     }
 
     #[test]
-    fn length_null_list() -> Result<()> {
+    fn length_null_list() {
         let value = vec![
             Some(vec![]),
             None,
@@ -413,7 +321,7 @@ mod tests {
     }
 
     #[test]
-    fn length_null_large_list() -> Result<()> {
+    fn length_null_large_list() {
         let value = vec![
             Some(vec![]),
             None,
@@ -434,41 +342,33 @@ mod tests {
 
     /// Tests with an offset
     #[test]
-    fn length_offsets_string() -> Result<()> {
+    fn length_offsets_string() {
         let a = StringArray::from(vec![Some("hello"), Some(" "), Some("world"), None]);
         let b = a.slice(1, 3);
-        let result = length(b.as_ref())?;
-        let result: &Int32Array = as_primitive_array(&result);
+        let result = length(&b).unwrap();
+        let result: &Int32Array = result.as_primitive();
 
         let expected = Int32Array::from(vec![Some(1), Some(5), None]);
         assert_eq!(&expected, result);
-
-        Ok(())
     }
 
     #[test]
-    fn length_offsets_binary() -> Result<()> {
-        let value: Vec<Option<&[u8]>> =
-            vec![Some(b"hello"), Some(b" "), Some(&[0xff, 0xf8]), None];
+    fn length_offsets_binary() {
+        let value: Vec<Option<&[u8]>> = vec![Some(b"hello"), Some(b" "), Some(&[0xff, 0xf8]), None];
         let a = BinaryArray::from(value);
         let b = a.slice(1, 3);
-        let result = length(b.as_ref())?;
-        let result: &Int32Array = as_primitive_array(&result);
+        let result = length(&b).unwrap();
+        let result: &Int32Array = result.as_primitive();
 
         let expected = Int32Array::from(vec![Some(1), Some(2), None]);
         assert_eq!(&expected, result);
-
-        Ok(())
     }
 
     fn bit_length_cases() -> Vec<(Vec<&'static str>, usize, Vec<i32>)> {
         // a large array
-        let mut values = vec!["one", "on", "o", ""];
-        let mut expected = vec![24, 16, 8, 0];
-        for _ in 0..10 {
-            values = double_vec(values);
-            expected = double_vec(expected);
-        }
+        let values = ["one", "on", "o", ""];
+        let values = values.into_iter().cycle().take(4096).collect();
+        let expected = [24, 16, 8, 0].into_iter().cycle().take(4096).collect();
 
         vec![
             (vec!["hello", " ", "world", "!"], 4, vec![40, 8, 40, 8]),
@@ -479,48 +379,44 @@ mod tests {
     }
 
     #[test]
-    #[cfg_attr(miri, ignore)] // error: this test uses too much memory to run on CI
-    fn bit_length_test_string() -> Result<()> {
+    fn bit_length_test_string() {
         bit_length_cases()
             .into_iter()
-            .try_for_each(|(input, len, expected)| {
+            .for_each(|(input, len, expected)| {
                 let array = StringArray::from(input);
-                let result = bit_length(&array)?;
+                let result = bit_length(&array).unwrap();
                 assert_eq!(len, result.len());
                 let result = result.as_any().downcast_ref::<Int32Array>().unwrap();
                 expected.iter().enumerate().for_each(|(i, value)| {
                     assert_eq!(*value, result.value(i));
                 });
-                Ok(())
             })
     }
 
     #[test]
-    #[cfg_attr(miri, ignore)] // error: this test uses too much memory to run on CI
-    fn bit_length_test_large_string() -> Result<()> {
+    fn bit_length_test_large_string() {
         bit_length_cases()
             .into_iter()
-            .try_for_each(|(input, len, expected)| {
+            .for_each(|(input, len, expected)| {
                 let array = LargeStringArray::from(input);
-                let result = bit_length(&array)?;
+                let result = bit_length(&array).unwrap();
                 assert_eq!(len, result.len());
                 let result = result.as_any().downcast_ref::<Int64Array>().unwrap();
                 expected.iter().enumerate().for_each(|(i, value)| {
                     assert_eq!(*value as i64, result.value(i));
                 });
-                Ok(())
             })
     }
 
     #[test]
-    fn bit_length_binary() -> Result<()> {
+    fn bit_length_binary() {
         let value: Vec<&[u8]> = vec![b"one", &[0xff, 0xf8], b"three"];
         let expected: Vec<i32> = vec![24, 16, 40];
         length_binary_helper!(i32, Int32Array, bit_length, value, expected)
     }
 
     #[test]
-    fn bit_length_large_binary() -> Result<()> {
+    fn bit_length_large_binary() {
         let value: Vec<&[u8]> = vec![b"zero", b" ", &[0xff, 0xf8]];
         let expected: Vec<i64> = vec![32, 8, 16];
         length_binary_helper!(i64, Int64Array, bit_length, value, expected)
@@ -535,28 +431,27 @@ mod tests {
     }
 
     #[test]
-    fn bit_length_null_string() -> Result<()> {
+    fn bit_length_null_string() {
         bit_length_null_cases()
             .into_iter()
-            .try_for_each(|(input, len, expected)| {
+            .for_each(|(input, len, expected)| {
                 let array = StringArray::from(input);
-                let result = bit_length(&array)?;
+                let result = bit_length(&array).unwrap();
                 assert_eq!(len, result.len());
                 let result = result.as_any().downcast_ref::<Int32Array>().unwrap();
 
                 let expected: Int32Array = expected.into();
-                assert_eq!(expected.data(), result.data());
-                Ok(())
+                assert_eq!(&expected, result);
             })
     }
 
     #[test]
-    fn bit_length_null_large_string() -> Result<()> {
+    fn bit_length_null_large_string() {
         bit_length_null_cases()
             .into_iter()
-            .try_for_each(|(input, len, expected)| {
+            .for_each(|(input, len, expected)| {
                 let array = LargeStringArray::from(input);
-                let result = bit_length(&array)?;
+                let result = bit_length(&array).unwrap();
                 assert_eq!(len, result.len());
                 let result = result.as_any().downcast_ref::<Int64Array>().unwrap();
 
@@ -566,13 +461,12 @@ mod tests {
                     .map(|e| e.map(|e| e as i64))
                     .collect::<Vec<_>>()
                     .into();
-                assert_eq!(expected.data(), result.data());
-                Ok(())
+                assert_eq!(&expected, result);
             })
     }
 
     #[test]
-    fn bit_length_null_binary() -> Result<()> {
+    fn bit_length_null_binary() {
         let value: Vec<Option<&[u8]>> =
             vec![Some(b"one"), None, Some(b"three"), Some(&[0xff, 0xf8])];
         let expected: Vec<Option<i32>> = vec![Some(24), None, Some(40), Some(16)];
@@ -580,7 +474,7 @@ mod tests {
     }
 
     #[test]
-    fn bit_length_null_large_binary() -> Result<()> {
+    fn bit_length_null_large_binary() {
         let value: Vec<Option<&[u8]>> =
             vec![Some(b"one"), None, Some(&[0xff, 0xf8]), Some(b"four")];
         let expected: Vec<Option<i64>> = vec![Some(24), None, Some(16), Some(32)];
@@ -597,47 +491,41 @@ mod tests {
 
     /// Tests with an offset
     #[test]
-    fn bit_length_offsets_string() -> Result<()> {
+    fn bit_length_offsets_string() {
         let a = StringArray::from(vec![Some("hello"), Some(" "), Some("world"), None]);
         let b = a.slice(1, 3);
-        let result = bit_length(b.as_ref())?;
-        let result: &Int32Array = as_primitive_array(&result);
+        let result = bit_length(&b).unwrap();
+        let result: &Int32Array = result.as_primitive();
 
         let expected = Int32Array::from(vec![Some(8), Some(40), None]);
         assert_eq!(&expected, result);
-
-        Ok(())
     }
 
     #[test]
-    fn bit_length_offsets_binary() -> Result<()> {
-        let value: Vec<Option<&[u8]>> =
-            vec![Some(b"hello"), Some(&[]), Some(b"world"), None];
+    fn bit_length_offsets_binary() {
+        let value: Vec<Option<&[u8]>> = vec![Some(b"hello"), Some(&[]), Some(b"world"), None];
         let a = BinaryArray::from(value);
         let b = a.slice(1, 3);
-        let result = bit_length(b.as_ref())?;
-        let result: &Int32Array = as_primitive_array(&result);
+        let result = bit_length(&b).unwrap();
+        let result: &Int32Array = result.as_primitive();
 
         let expected = Int32Array::from(vec![Some(0), Some(40), None]);
         assert_eq!(&expected, result);
-
-        Ok(())
     }
 
     #[test]
-    fn length_dictionary() -> Result<()> {
-        _length_dictionary::<Int8Type>()?;
-        _length_dictionary::<Int16Type>()?;
-        _length_dictionary::<Int32Type>()?;
-        _length_dictionary::<Int64Type>()?;
-        _length_dictionary::<UInt8Type>()?;
-        _length_dictionary::<UInt16Type>()?;
-        _length_dictionary::<UInt32Type>()?;
-        _length_dictionary::<UInt64Type>()?;
-        Ok(())
-    }
-
-    fn _length_dictionary<K: ArrowDictionaryKeyType>() -> Result<()> {
+    fn length_dictionary() {
+        _length_dictionary::<Int8Type>();
+        _length_dictionary::<Int16Type>();
+        _length_dictionary::<Int32Type>();
+        _length_dictionary::<Int64Type>();
+        _length_dictionary::<UInt8Type>();
+        _length_dictionary::<UInt16Type>();
+        _length_dictionary::<UInt32Type>();
+        _length_dictionary::<UInt64Type>();
+    }
+
+    fn _length_dictionary<K: ArrowDictionaryKeyType>() {
         const TOTAL: i32 = 100;
 
         let v = ["aaaa", "bb", "ccccc", "ddd", "eeeeee"];
@@ -657,7 +545,7 @@ mod tests {
         let expected: Vec<Option<i32>> =
             data.iter().map(|opt| opt.map(|s| s.len() as i32)).collect();
 
-        let res = length(&dict_array)?;
+        let res = length(&dict_array).unwrap();
         let actual = res.as_any().downcast_ref::<DictionaryArray<K>>().unwrap();
         let actual: Vec<Option<i32>> = actual
             .values()
@@ -670,24 +558,21 @@ mod tests {
         for i in 0..TOTAL as usize {
             assert_eq!(expected[i], actual[i],);
         }
-
-        Ok(())
     }
 
     #[test]
-    fn bit_length_dictionary() -> Result<()> {
-        _bit_length_dictionary::<Int8Type>()?;
-        _bit_length_dictionary::<Int16Type>()?;
-        _bit_length_dictionary::<Int32Type>()?;
-        _bit_length_dictionary::<Int64Type>()?;
-        _bit_length_dictionary::<UInt8Type>()?;
-        _bit_length_dictionary::<UInt16Type>()?;
-        _bit_length_dictionary::<UInt32Type>()?;
-        _bit_length_dictionary::<UInt64Type>()?;
-        Ok(())
-    }
-
-    fn _bit_length_dictionary<K: ArrowDictionaryKeyType>() -> Result<()> {
+    fn bit_length_dictionary() {
+        _bit_length_dictionary::<Int8Type>();
+        _bit_length_dictionary::<Int16Type>();
+        _bit_length_dictionary::<Int32Type>();
+        _bit_length_dictionary::<Int64Type>();
+        _bit_length_dictionary::<UInt8Type>();
+        _bit_length_dictionary::<UInt16Type>();
+        _bit_length_dictionary::<UInt32Type>();
+        _bit_length_dictionary::<UInt64Type>();
+    }
+
+    fn _bit_length_dictionary<K: ArrowDictionaryKeyType>() {
         const TOTAL: i32 = 100;
 
         let v = ["aaaa", "bb", "ccccc", "ddd", "eeeeee"];
@@ -709,7 +594,7 @@ mod tests {
             .map(|opt| opt.map(|s| (s.chars().count() * 8) as i32))
             .collect();
 
-        let res = bit_length(&dict_array)?;
+        let res = bit_length(&dict_array).unwrap();
         let actual = res.as_any().downcast_ref::<DictionaryArray<K>>().unwrap();
         let actual: Vec<Option<i32>> = actual
             .values()
@@ -722,7 +607,43 @@ mod tests {
         for i in 0..TOTAL as usize {
             assert_eq!(expected[i], actual[i],);
         }
+    }
+
+    #[test]
+    fn test_fixed_size_list_length() {
+        // Construct a value array
+        let value_data = ArrayData::builder(DataType::Int32)
+            .len(9)
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7, 8]))
+            .build()
+            .unwrap();
+        let list_data_type =
+            DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, false)), 3);
+        let nulls = NullBuffer::from(vec![true, false, true]);
+        let list_data = ArrayData::builder(list_data_type)
+            .len(3)
+            .add_child_data(value_data)
+            .nulls(Some(nulls))
+            .build()
+            .unwrap();
+        let list_array = FixedSizeListArray::from(list_data);
+
+        let lengths = length(&list_array).unwrap();
+        let lengths = lengths.as_primitive::<Int32Type>();
+
+        assert_eq!(lengths.len(), 3);
+        assert_eq!(lengths.value(0), 3);
+        assert!(lengths.is_null(1));
+        assert_eq!(lengths.value(2), 3);
+    }
+
+    #[test]
+    fn test_fixed_size_binary() {
+        let array = FixedSizeBinaryArray::new(4, [0; 16].into(), None);
+        let result = length(&array).unwrap();
+        assert_eq!(result.as_ref(), &Int32Array::from(vec![4; 4]));
 
-        Ok(())
+        let result = bit_length(&array).unwrap();
+        assert_eq!(result.as_ref(), &Int32Array::from(vec![32; 4]));
     }
 }
diff --git a/arrow-string/src/lib.rs b/arrow-string/src/lib.rs
new file mode 100644
index 000000000000..4444b37a7742
--- /dev/null
+++ b/arrow-string/src/lib.rs
@@ -0,0 +1,25 @@
+// 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.
+
+//! Arrow string kernels
+
+pub mod concat_elements;
+pub mod length;
+pub mod like;
+mod predicate;
+pub mod regexp;
+pub mod substring;
diff --git a/arrow-string/src/like.rs b/arrow-string/src/like.rs
new file mode 100644
index 000000000000..6f6dfe03133d
--- /dev/null
+++ b/arrow-string/src/like.rs
@@ -0,0 +1,1555 @@
+// 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.
+
+use crate::predicate::Predicate;
+use arrow_array::cast::AsArray;
+use arrow_array::*;
+use arrow_schema::*;
+use arrow_select::take::take;
+use std::sync::Arc;
+
+#[derive(Debug)]
+enum Op {
+    Like(bool),
+    ILike(bool),
+    Contains,
+    StartsWith,
+    EndsWith,
+}
+
+impl std::fmt::Display for Op {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Op::Like(false) => write!(f, "LIKE"),
+            Op::Like(true) => write!(f, "NLIKE"),
+            Op::ILike(false) => write!(f, "ILIKE"),
+            Op::ILike(true) => write!(f, "NILIKE"),
+            Op::Contains => write!(f, "CONTAINS"),
+            Op::StartsWith => write!(f, "STARTS_WITH"),
+            Op::EndsWith => write!(f, "ENDS_WITH"),
+        }
+    }
+}
+
+/// Perform SQL `left LIKE right`
+///
+/// There are two wildcards supported with the LIKE operator:
+///
+/// 1. `%` - The percent sign represents zero, one, or multiple characters
+/// 2. `_` - The underscore represents a single character
+///
+/// For example:
+/// ```
+/// # use arrow_array::{StringArray, BooleanArray};
+/// # use arrow_string::like::like;
+/// #
+/// let strings = StringArray::from(vec!["Arrow", "Arrow", "Arrow", "Ar"]);
+/// let patterns = StringArray::from(vec!["A%", "B%", "A.", "A_"]);
+///
+/// let result = like(&strings, &patterns).unwrap();
+/// assert_eq!(result, BooleanArray::from(vec![true, false, false, true]));
+/// ```
+pub fn like(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    like_op(Op::Like(false), left, right)
+}
+
+/// Perform SQL `left ILIKE right`
+///
+/// This is a case-insensitive version of [`like`]
+///
+/// Note: this only implements loose matching as defined by the Unicode standard. For example,
+/// the `ff` ligature is not equivalent to `FF` and `ß` is not equivalent to `SS`
+pub fn ilike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    like_op(Op::ILike(false), left, right)
+}
+
+/// Perform SQL `left NOT LIKE right`
+///
+/// See the documentation on [`like`] for more details
+pub fn nlike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    like_op(Op::Like(true), left, right)
+}
+
+/// Perform SQL `left NOT ILIKE right`
+///
+/// See the documentation on [`ilike`] for more details
+pub fn nilike(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    like_op(Op::ILike(true), left, right)
+}
+
+/// Perform SQL `STARTSWITH(left, right)`
+pub fn starts_with(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    like_op(Op::StartsWith, left, right)
+}
+
+/// Perform SQL `ENDSWITH(left, right)`
+pub fn ends_with(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    like_op(Op::EndsWith, left, right)
+}
+
+/// Perform SQL `CONTAINS(left, right)`
+pub fn contains(left: &dyn Datum, right: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    like_op(Op::Contains, left, right)
+}
+
+fn like_op(op: Op, lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, ArrowError> {
+    use arrow_schema::DataType::*;
+    let (l, l_s) = lhs.get();
+    let (r, r_s) = rhs.get();
+
+    if l.len() != r.len() && !l_s && !r_s {
+        return Err(ArrowError::InvalidArgumentError(format!(
+            "Cannot compare arrays of different lengths, got {} vs {}",
+            l.len(),
+            r.len()
+        )));
+    }
+
+    let l_v = l.as_any_dictionary_opt();
+    let l = l_v.map(|x| x.values().as_ref()).unwrap_or(l);
+
+    let r_v = r.as_any_dictionary_opt();
+    let r = r_v.map(|x| x.values().as_ref()).unwrap_or(r);
+
+    match (l.data_type(), r.data_type()) {
+        (Utf8, Utf8) => apply::<i32>(op, l.as_string(), l_s, l_v, r.as_string(), r_s, r_v),
+        (LargeUtf8, LargeUtf8) => {
+            apply::<i64>(op, l.as_string(), l_s, l_v, r.as_string(), r_s, r_v)
+        }
+        (l_t, r_t) => Err(ArrowError::InvalidArgumentError(format!(
+            "Invalid string operation: {l_t} {op} {r_t}"
+        ))),
+    }
+}
+
+fn apply<O: OffsetSizeTrait>(
+    op: Op,
+    l: &GenericStringArray<O>,
+    l_s: bool,
+    l_v: Option<&dyn AnyDictionaryArray>,
+    r: &GenericStringArray<O>,
+    r_s: bool,
+    r_v: Option<&dyn AnyDictionaryArray>,
+) -> Result<BooleanArray, ArrowError> {
+    let l_len = l_v.map(|l| l.len()).unwrap_or(l.len());
+    if r_s {
+        let idx = match r_v {
+            Some(dict) if dict.null_count() != 0 => return Ok(BooleanArray::new_null(l_len)),
+            Some(dict) => dict.normalized_keys()[0],
+            None => 0,
+        };
+        if r.is_null(idx) {
+            return Ok(BooleanArray::new_null(l_len));
+        }
+        op_scalar(op, l, l_v, r.value(idx))
+    } else {
+        match (l_s, l_v, r_v) {
+            (true, None, None) => {
+                let v = l.is_valid(0).then(|| l.value(0));
+                op_binary(op, std::iter::repeat(v), r.iter())
+            }
+            (true, Some(l_v), None) => {
+                let idx = l_v.is_valid(0).then(|| l_v.normalized_keys()[0]);
+                let v = idx.and_then(|idx| l.is_valid(idx).then(|| l.value(idx)));
+                op_binary(op, std::iter::repeat(v), r.iter())
+            }
+            (true, None, Some(r_v)) => {
+                let v = l.is_valid(0).then(|| l.value(0));
+                op_binary(op, std::iter::repeat(v), vectored_iter(r, r_v))
+            }
+            (true, Some(l_v), Some(r_v)) => {
+                let idx = l_v.is_valid(0).then(|| l_v.normalized_keys()[0]);
+                let v = idx.and_then(|idx| l.is_valid(idx).then(|| l.value(idx)));
+                op_binary(op, std::iter::repeat(v), vectored_iter(r, r_v))
+            }
+            (false, None, None) => op_binary(op, l.iter(), r.iter()),
+            (false, Some(l_v), None) => op_binary(op, vectored_iter(l, l_v), r.iter()),
+            (false, None, Some(r_v)) => op_binary(op, l.iter(), vectored_iter(r, r_v)),
+            (false, Some(l_v), Some(r_v)) => {
+                op_binary(op, vectored_iter(l, l_v), vectored_iter(r, r_v))
+            }
+        }
+    }
+}
+
+#[inline(never)]
+fn op_scalar<O: OffsetSizeTrait>(
+    op: Op,
+    l: &GenericStringArray<O>,
+    l_v: Option<&dyn AnyDictionaryArray>,
+    r: &str,
+) -> Result<BooleanArray, ArrowError> {
+    let r = match op {
+        Op::Like(neg) => Predicate::like(r)?.evaluate_array(l, neg),
+        Op::ILike(neg) => Predicate::ilike(r, l.is_ascii())?.evaluate_array(l, neg),
+        Op::Contains => Predicate::Contains(r).evaluate_array(l, false),
+        Op::StartsWith => Predicate::StartsWith(r).evaluate_array(l, false),
+        Op::EndsWith => Predicate::EndsWith(r).evaluate_array(l, false),
+    };
+
+    Ok(match l_v {
+        Some(v) => take(&r, v.keys(), None)?.as_boolean().clone(),
+        None => r,
+    })
+}
+
+fn vectored_iter<'a, O: OffsetSizeTrait>(
+    a: &'a GenericStringArray<O>,
+    a_v: &'a dyn AnyDictionaryArray,
+) -> impl Iterator<Item = Option<&'a str>> + 'a {
+    let nulls = a_v.nulls();
+    let keys = a_v.normalized_keys();
+    keys.into_iter().enumerate().map(move |(idx, key)| {
+        if nulls.map(|n| n.is_null(idx)).unwrap_or_default() || a.is_null(key) {
+            return None;
+        }
+        Some(a.value(key))
+    })
+}
+
+#[inline(never)]
+fn op_binary<'a>(
+    op: Op,
+    l: impl Iterator<Item = Option<&'a str>>,
+    r: impl Iterator<Item = Option<&'a str>>,
+) -> Result<BooleanArray, ArrowError> {
+    match op {
+        Op::Like(neg) => binary_predicate(l, r, neg, Predicate::like),
+        Op::ILike(neg) => binary_predicate(l, r, neg, |s| Predicate::ilike(s, false)),
+        Op::Contains => Ok(l.zip(r).map(|(l, r)| Some(l?.contains(r?))).collect()),
+        Op::StartsWith => Ok(l.zip(r).map(|(l, r)| Some(l?.starts_with(r?))).collect()),
+        Op::EndsWith => Ok(l.zip(r).map(|(l, r)| Some(l?.ends_with(r?))).collect()),
+    }
+}
+
+fn binary_predicate<'a>(
+    l: impl Iterator<Item = Option<&'a str>>,
+    r: impl Iterator<Item = Option<&'a str>>,
+    neg: bool,
+    f: impl Fn(&'a str) -> Result<Predicate<'a>, ArrowError>,
+) -> Result<BooleanArray, ArrowError> {
+    let mut previous = None;
+    l.zip(r)
+        .map(|(l, r)| match (l, r) {
+            (Some(l), Some(r)) => {
+                let p: &Predicate = match previous {
+                    Some((expr, ref predicate)) if expr == r => predicate,
+                    _ => &previous.insert((r, f(r)?)).1,
+                };
+                Ok(Some(p.evaluate(l) != neg))
+            }
+            _ => Ok(None),
+        })
+        .collect()
+}
+
+// Deprecated kernels
+
+fn make_scalar(data_type: &DataType, scalar: &str) -> Result<ArrayRef, ArrowError> {
+    match data_type {
+        DataType::Utf8 => Ok(Arc::new(StringArray::from_iter_values([scalar]))),
+        DataType::LargeUtf8 => Ok(Arc::new(LargeStringArray::from_iter_values([scalar]))),
+        DataType::Dictionary(_, v) => make_scalar(v.as_ref(), scalar),
+        d => Err(ArrowError::InvalidArgumentError(format!(
+            "Unsupported string scalar data type {d:?}",
+        ))),
+    }
+}
+
+macro_rules! legacy_kernels {
+    ($fn_datum:ident, $fn_array:ident, $fn_scalar:ident, $fn_array_dyn:ident, $fn_scalar_dyn:ident, $deprecation:expr) => {
+        #[doc(hidden)]
+        #[deprecated(note = $deprecation)]
+        pub fn $fn_array<O: OffsetSizeTrait>(
+            left: &GenericStringArray<O>,
+            right: &GenericStringArray<O>,
+        ) -> Result<BooleanArray, ArrowError> {
+            $fn_datum(left, right)
+        }
+
+        #[doc(hidden)]
+        #[deprecated(note = $deprecation)]
+        pub fn $fn_scalar<O: OffsetSizeTrait>(
+            left: &GenericStringArray<O>,
+            right: &str,
+        ) -> Result<BooleanArray, ArrowError> {
+            let scalar = GenericStringArray::<O>::from_iter_values([right]);
+            $fn_datum(left, &Scalar::new(&scalar))
+        }
+
+        #[doc(hidden)]
+        #[deprecated(note = $deprecation)]
+        pub fn $fn_array_dyn(
+            left: &dyn Array,
+            right: &dyn Array,
+        ) -> Result<BooleanArray, ArrowError> {
+            $fn_datum(&left, &right)
+        }
+
+        #[doc(hidden)]
+        #[deprecated(note = $deprecation)]
+        pub fn $fn_scalar_dyn(left: &dyn Array, right: &str) -> Result<BooleanArray, ArrowError> {
+            let scalar = make_scalar(left.data_type(), right)?;
+            $fn_datum(&left, &Scalar::new(&scalar))
+        }
+    };
+}
+
+legacy_kernels!(
+    like,
+    like_utf8,
+    like_utf8_scalar,
+    like_dyn,
+    like_utf8_scalar_dyn,
+    "Use arrow_string::like::like"
+);
+legacy_kernels!(
+    ilike,
+    ilike_utf8,
+    ilike_utf8_scalar,
+    ilike_dyn,
+    ilike_utf8_scalar_dyn,
+    "Use arrow_string::like::ilike"
+);
+legacy_kernels!(
+    nlike,
+    nlike_utf8,
+    nlike_utf8_scalar,
+    nlike_dyn,
+    nlike_utf8_scalar_dyn,
+    "Use arrow_string::like::nlike"
+);
+legacy_kernels!(
+    nilike,
+    nilike_utf8,
+    nilike_utf8_scalar,
+    nilike_dyn,
+    nilike_utf8_scalar_dyn,
+    "Use arrow_string::like::nilike"
+);
+legacy_kernels!(
+    contains,
+    contains_utf8,
+    contains_utf8_scalar,
+    contains_dyn,
+    contains_utf8_scalar_dyn,
+    "Use arrow_string::like::contains"
+);
+legacy_kernels!(
+    starts_with,
+    starts_with_utf8,
+    starts_with_utf8_scalar,
+    starts_with_dyn,
+    starts_with_utf8_scalar_dyn,
+    "Use arrow_string::like::starts_with"
+);
+
+legacy_kernels!(
+    ends_with,
+    ends_with_utf8,
+    ends_with_utf8_scalar,
+    ends_with_dyn,
+    ends_with_utf8_scalar_dyn,
+    "Use arrow_string::like::ends_with"
+);
+
+#[cfg(test)]
+#[allow(deprecated)]
+mod tests {
+    use super::*;
+    use arrow_array::types::Int8Type;
+
+    macro_rules! test_utf8 {
+        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let expected = BooleanArray::from($expected);
+                let left = StringArray::from($left);
+                let right = StringArray::from($right);
+                let res = $op(&left, &right).unwrap();
+                assert_eq!(res, expected);
+            }
+        };
+    }
+
+    macro_rules! test_dict_utf8 {
+        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let expected = BooleanArray::from($expected);
+                let left: DictionaryArray<Int8Type> = $left.into_iter().collect();
+                let right: DictionaryArray<Int8Type> = $right.into_iter().collect();
+                let res = $op(&left, &right).unwrap();
+                assert_eq!(res, expected);
+            }
+        };
+    }
+
+    macro_rules! test_utf8_scalar {
+        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let expected = BooleanArray::from($expected);
+
+                let left = StringArray::from($left);
+                let res = $op(&left, $right).unwrap();
+                assert_eq!(res, expected);
+
+                let left = LargeStringArray::from($left);
+                let res = $op(&left, $right).unwrap();
+                assert_eq!(res, expected);
+            }
+        };
+        ($test_name:ident, $test_name_dyn:ident, $left:expr, $right:expr, $op:expr, $op_dyn:expr, $expected:expr) => {
+            test_utf8_scalar!($test_name, $left, $right, $op, $expected);
+            test_utf8_scalar!($test_name_dyn, $left, $right, $op_dyn, $expected);
+        };
+    }
+
+    test_utf8!(
+        test_utf8_array_like,
+        vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrows", "arrow", "arrow"],
+        vec!["arrow", "ar%", "%ro%", "foo", "arr", "arrow_", "arrow_", ".*"],
+        like_utf8,
+        vec![true, true, true, false, false, true, false, false]
+    );
+
+    test_dict_utf8!(
+        test_utf8_array_like_dict,
+        vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrows", "arrow", "arrow"],
+        vec!["arrow", "ar%", "%ro%", "foo", "arr", "arrow_", "arrow_", ".*"],
+        like_dyn,
+        vec![true, true, true, false, false, true, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_like_scalar_escape_testing,
+        test_utf8_array_like_scalar_dyn_escape_testing,
+        vec!["varchar(255)", "int(255)", "varchar", "int"],
+        "%(%)%",
+        like_utf8_scalar,
+        like_utf8_scalar_dyn,
+        vec![true, true, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_like_scalar_escape_regex,
+        test_utf8_array_like_scalar_dyn_escape_regex,
+        vec![".*", "a", "*"],
+        ".*",
+        like_utf8_scalar,
+        like_utf8_scalar_dyn,
+        vec![true, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_like_scalar_escape_regex_dot,
+        test_utf8_array_like_scalar_dyn_escape_regex_dot,
+        vec![".", "a", "*"],
+        ".",
+        like_utf8_scalar,
+        like_utf8_scalar_dyn,
+        vec![true, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_like_scalar,
+        test_utf8_array_like_scalar_dyn,
+        vec!["arrow", "parquet", "datafusion", "flight"],
+        "%ar%",
+        like_utf8_scalar,
+        like_utf8_scalar_dyn,
+        vec![true, true, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_like_scalar_start,
+        test_utf8_array_like_scalar_dyn_start,
+        vec!["arrow", "parrow", "arrows", "arr"],
+        "arrow%",
+        like_utf8_scalar,
+        like_utf8_scalar_dyn,
+        vec![true, false, true, false]
+    );
+
+    // Replicates `test_utf8_array_like_scalar_start` `test_utf8_array_like_scalar_dyn_start` to
+    // demonstrate that `SQL STARTSWITH` works as expected.
+    test_utf8_scalar!(
+        test_utf8_array_starts_with_scalar_start,
+        test_utf8_array_starts_with_scalar_dyn_start,
+        vec!["arrow", "parrow", "arrows", "arr"],
+        "arrow",
+        starts_with_utf8_scalar,
+        starts_with_utf8_scalar_dyn,
+        vec![true, false, true, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_like_scalar_end,
+        test_utf8_array_like_scalar_dyn_end,
+        vec!["arrow", "parrow", "arrows", "arr"],
+        "%arrow",
+        like_utf8_scalar,
+        like_utf8_scalar_dyn,
+        vec![true, true, false, false]
+    );
+
+    // Replicates `test_utf8_array_like_scalar_end` `test_utf8_array_like_scalar_dyn_end` to
+    // demonstrate that `SQL ENDSWITH` works as expected.
+    test_utf8_scalar!(
+        test_utf8_array_ends_with_scalar_end,
+        test_utf8_array_ends_with_scalar_dyn_end,
+        vec!["arrow", "parrow", "arrows", "arr"],
+        "arrow",
+        ends_with_utf8_scalar,
+        ends_with_utf8_scalar_dyn,
+        vec![true, true, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_like_scalar_equals,
+        test_utf8_array_like_scalar_dyn_equals,
+        vec!["arrow", "parrow", "arrows", "arr"],
+        "arrow",
+        like_utf8_scalar,
+        like_utf8_scalar_dyn,
+        vec![true, false, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_like_scalar_one,
+        test_utf8_array_like_scalar_dyn_one,
+        vec!["arrow", "arrows", "parrow", "arr"],
+        "arrow_",
+        like_utf8_scalar,
+        like_utf8_scalar_dyn,
+        vec![false, true, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_scalar_like_escape,
+        test_utf8_scalar_like_dyn_escape,
+        vec!["a%", "a\\x"],
+        "a\\%",
+        like_utf8_scalar,
+        like_utf8_scalar_dyn,
+        vec![true, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_scalar_like_escape_contains,
+        test_utf8_scalar_like_dyn_escape_contains,
+        vec!["ba%", "ba\\x"],
+        "%a\\%",
+        like_utf8_scalar,
+        like_utf8_scalar_dyn,
+        vec![true, false]
+    );
+
+    test_utf8!(
+        test_utf8_scalar_ilike_regex,
+        vec!["%%%"],
+        vec![r"\%_\%"],
+        ilike_utf8,
+        vec![true]
+    );
+
+    test_dict_utf8!(
+        test_utf8_scalar_ilike_regex_dict,
+        vec!["%%%"],
+        vec![r"\%_\%"],
+        ilike_dyn,
+        vec![true]
+    );
+
+    test_utf8!(
+        test_utf8_array_nlike,
+        vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrows", "arrow"],
+        vec!["arrow", "ar%", "%ro%", "foo", "arr", "arrow_", "arrow_"],
+        nlike_utf8,
+        vec![false, false, false, true, true, false, true]
+    );
+
+    test_dict_utf8!(
+        test_utf8_array_nlike_dict,
+        vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrows", "arrow"],
+        vec!["arrow", "ar%", "%ro%", "foo", "arr", "arrow_", "arrow_"],
+        nlike_dyn,
+        vec![false, false, false, true, true, false, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nlike_escape_testing,
+        test_utf8_array_nlike_escape_dyn_testing_dyn,
+        vec!["varchar(255)", "int(255)", "varchar", "int"],
+        "%(%)%",
+        nlike_utf8_scalar,
+        nlike_utf8_scalar_dyn,
+        vec![false, false, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nlike_scalar_escape_regex,
+        test_utf8_array_nlike_scalar_dyn_escape_regex,
+        vec![".*", "a", "*"],
+        ".*",
+        nlike_utf8_scalar,
+        nlike_utf8_scalar_dyn,
+        vec![false, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nlike_scalar_escape_regex_dot,
+        test_utf8_array_nlike_scalar_dyn_escape_regex_dot,
+        vec![".", "a", "*"],
+        ".",
+        nlike_utf8_scalar,
+        nlike_utf8_scalar_dyn,
+        vec![false, true, true]
+    );
+    test_utf8_scalar!(
+        test_utf8_array_nlike_scalar,
+        test_utf8_array_nlike_scalar_dyn,
+        vec!["arrow", "parquet", "datafusion", "flight"],
+        "%ar%",
+        nlike_utf8_scalar,
+        nlike_utf8_scalar_dyn,
+        vec![false, false, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nlike_scalar_start,
+        test_utf8_array_nlike_scalar_dyn_start,
+        vec!["arrow", "parrow", "arrows", "arr"],
+        "arrow%",
+        nlike_utf8_scalar,
+        nlike_utf8_scalar_dyn,
+        vec![false, true, false, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nlike_scalar_end,
+        test_utf8_array_nlike_scalar_dyn_end,
+        vec!["arrow", "parrow", "arrows", "arr"],
+        "%arrow",
+        nlike_utf8_scalar,
+        nlike_utf8_scalar_dyn,
+        vec![false, false, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nlike_scalar_equals,
+        test_utf8_array_nlike_scalar_dyn_equals,
+        vec!["arrow", "parrow", "arrows", "arr"],
+        "arrow",
+        nlike_utf8_scalar,
+        nlike_utf8_scalar_dyn,
+        vec![false, true, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nlike_scalar_one,
+        test_utf8_array_nlike_scalar_dyn_one,
+        vec!["arrow", "arrows", "parrow", "arr"],
+        "arrow_",
+        nlike_utf8_scalar,
+        nlike_utf8_scalar_dyn,
+        vec![true, false, true, true]
+    );
+
+    test_utf8!(
+        test_utf8_array_ilike,
+        vec!["arrow", "arrow", "ARROW", "arrow", "ARROW", "ARROWS", "arROw"],
+        vec!["arrow", "ar%", "%ro%", "foo", "ar%r", "arrow_", "arrow_"],
+        ilike_utf8,
+        vec![true, true, true, false, false, true, false]
+    );
+
+    test_dict_utf8!(
+        test_utf8_array_ilike_dict,
+        vec!["arrow", "arrow", "ARROW", "arrow", "ARROW", "ARROWS", "arROw"],
+        vec!["arrow", "ar%", "%ro%", "foo", "ar%r", "arrow_", "arrow_"],
+        ilike_dyn,
+        vec![true, true, true, false, false, true, false]
+    );
+
+    test_utf8_scalar!(
+        ilike_utf8_scalar_escape_testing,
+        ilike_utf8_scalar_escape_dyn_testing,
+        vec!["varchar(255)", "int(255)", "varchar", "int"],
+        "%(%)%",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![true, true, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_ilike_scalar,
+        test_utf8_array_ilike_dyn_scalar,
+        vec!["arrow", "parquet", "datafusion", "flight"],
+        "%AR%",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![true, true, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_ilike_scalar_start,
+        test_utf8_array_ilike_scalar_dyn_start,
+        vec!["arrow", "parrow", "arrows", "ARR"],
+        "aRRow%",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![true, false, true, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_ilike_scalar_end,
+        test_utf8_array_ilike_scalar_dyn_end,
+        vec!["ArroW", "parrow", "ARRowS", "arr"],
+        "%arrow",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![true, true, false, false]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_ilike_scalar_equals,
+        test_utf8_array_ilike_scalar_dyn_equals,
+        vec!["arrow", "parrow", "arrows", "arr"],
+        "Arrow",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![true, false, false, false]
+    );
+
+    // We only implement loose matching
+    test_utf8_scalar!(
+        test_utf8_array_ilike_unicode,
+        test_utf8_array_ilike_unicode_dyn,
+        vec!["FFkoß", "FFkoSS", "FFkoss", "FFkoS", "FFkos", "ffkoSS", "ffkoß", "FFKoSS"],
+        "FFkoSS",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![false, true, true, false, false, false, false, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_ilike_unicode_starts,
+        test_utf8_array_ilike_unicode_start_dyn,
+        vec![
+            "FFkoßsdlkdf",
+            "FFkoSSsdlkdf",
+            "FFkosssdlkdf",
+            "FFkoS",
+            "FFkos",
+            "ffkoSS",
+            "ffkoß",
+            "FfkosSsdfd",
+            "FFKoSS",
+        ],
+        "FFkoSS%",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![false, true, true, false, false, false, false, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_ilike_unicode_ends,
+        test_utf8_array_ilike_unicode_ends_dyn,
+        vec![
+            "sdlkdfFFkoß",
+            "sdlkdfFFkoSS",
+            "sdlkdfFFkoss",
+            "FFkoS",
+            "FFkos",
+            "ffkoSS",
+            "ffkoß",
+            "h😃klFfkosS",
+            "FFKoSS",
+        ],
+        "%FFkoSS",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![false, true, true, false, false, false, false, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_ilike_unicode_contains,
+        test_utf8_array_ilike_unicode_contains_dyn,
+        vec![
+            "sdlkdfFkoßsdfs",
+            "sdlkdfFkoSSdggs",
+            "sdlkdfFkosssdsd",
+            "FkoS",
+            "Fkos",
+            "ffkoSS",
+            "ffkoß",
+            "😃sadlksffkosSsh😃klF",
+            "😱slgffkosSsh😃klF",
+            "FFKoSS",
+        ],
+        "%FFkoSS%",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![false, true, true, false, false, false, false, true, true, true]
+    );
+
+    // Replicates `test_utf8_array_ilike_unicode_contains` and
+    // `test_utf8_array_ilike_unicode_contains_dyn` to
+    // demonstrate that `SQL CONTAINS` works as expected.
+    //
+    // NOTE: 5 of the values were changed because the original used a case insensitive `ilike`.
+    test_utf8_scalar!(
+        test_utf8_array_contains_unicode_contains,
+        test_utf8_array_contains_unicode_contains_dyn,
+        vec![
+            "sdlkdfFkoßsdfs",
+            "sdlkdFFkoSSdggs", // Original was case insensitive "sdlkdfFkoSSdggs"
+            "sdlkdFFkoSSsdsd", // Original was case insensitive "sdlkdfFkosssdsd"
+            "FkoS",
+            "Fkos",
+            "ffkoSS",
+            "ffkoß",
+            "😃sadlksFFkoSSsh😃klF", // Original was case insensitive "😃sadlksffkosSsh😃klF"
+            "😱slgFFkoSSsh😃klF",    // Original was case insensitive "😱slgffkosSsh😃klF"
+            "FFkoSS",                // "FFKoSS"
+        ],
+        "FFkoSS",
+        contains_utf8_scalar,
+        contains_utf8_scalar_dyn,
+        vec![false, true, true, false, false, false, false, true, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_ilike_unicode_complex,
+        test_utf8_array_ilike_unicode_complex_dyn,
+        vec![
+            "sdlkdfFooßsdfs",
+            "sdlkdfFooSSdggs",
+            "sdlkdfFoosssdsd",
+            "FooS",
+            "Foos",
+            "ffooSS",
+            "ffooß",
+            "😃sadlksffofsSsh😃klF",
+            "😱slgffoesSsh😃klF",
+            "FFKoSS",
+        ],
+        "%FF__SS%",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![false, true, true, false, false, false, false, true, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_ilike_scalar_one,
+        test_utf8_array_ilike_scalar_dyn_one,
+        vec!["arrow", "arrows", "parrow", "arr"],
+        "arrow_",
+        ilike_utf8_scalar,
+        ilike_utf8_scalar_dyn,
+        vec![false, true, false, false]
+    );
+
+    test_utf8!(
+        test_utf8_array_nilike,
+        vec!["arrow", "arrow", "ARROW", "arrow", "ARROW", "ARROWS", "arROw"],
+        vec!["arrow", "ar%", "%ro%", "foo", "ar%r", "arrow_", "arrow_"],
+        nilike_utf8,
+        vec![false, false, false, true, true, false, true]
+    );
+
+    test_dict_utf8!(
+        test_utf8_array_nilike_dict,
+        vec!["arrow", "arrow", "ARROW", "arrow", "ARROW", "ARROWS", "arROw"],
+        vec!["arrow", "ar%", "%ro%", "foo", "ar%r", "arrow_", "arrow_"],
+        nilike_dyn,
+        vec![false, false, false, true, true, false, true]
+    );
+
+    test_utf8_scalar!(
+        nilike_utf8_scalar_escape_testing,
+        nilike_utf8_scalar_escape_dyn_testing,
+        vec!["varchar(255)", "int(255)", "varchar", "int"],
+        "%(%)%",
+        nilike_utf8_scalar,
+        nilike_utf8_scalar_dyn,
+        vec![false, false, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nilike_scalar,
+        test_utf8_array_nilike_dyn_scalar,
+        vec!["arrow", "parquet", "datafusion", "flight"],
+        "%AR%",
+        nilike_utf8_scalar,
+        nilike_utf8_scalar_dyn,
+        vec![false, false, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nilike_scalar_start,
+        test_utf8_array_nilike_scalar_dyn_start,
+        vec!["arrow", "parrow", "arrows", "ARR"],
+        "aRRow%",
+        nilike_utf8_scalar,
+        nilike_utf8_scalar_dyn,
+        vec![false, true, false, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nilike_scalar_end,
+        test_utf8_array_nilike_scalar_dyn_end,
+        vec!["ArroW", "parrow", "ARRowS", "arr"],
+        "%arrow",
+        nilike_utf8_scalar,
+        nilike_utf8_scalar_dyn,
+        vec![false, false, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nilike_scalar_equals,
+        test_utf8_array_nilike_scalar_dyn_equals,
+        vec!["arRow", "parrow", "arrows", "arr"],
+        "Arrow",
+        nilike_utf8_scalar,
+        nilike_utf8_scalar_dyn,
+        vec![false, true, true, true]
+    );
+
+    test_utf8_scalar!(
+        test_utf8_array_nilike_scalar_one,
+        test_utf8_array_nilike_scalar_dyn_one,
+        vec!["arrow", "arrows", "parrow", "arr"],
+        "arrow_",
+        nilike_utf8_scalar,
+        nilike_utf8_scalar_dyn,
+        vec![true, false, true, true]
+    );
+
+    #[test]
+    fn test_dict_like_kernels() {
+        let data = vec![
+            Some("Earth"),
+            Some("Fire"),
+            Some("Water"),
+            Some("Air"),
+            None,
+            Some("Air"),
+            Some("bbbbb\nAir"),
+        ];
+
+        let dict_array: DictionaryArray<Int8Type> = data.into_iter().collect();
+
+        assert_eq!(
+            like_utf8_scalar_dyn(&dict_array, "Air").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            like_utf8_scalar_dyn(&dict_array, "Air").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            like_utf8_scalar_dyn(&dict_array, "Wa%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            like_utf8_scalar_dyn(&dict_array, "Wa%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            like_utf8_scalar_dyn(&dict_array, "%r").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(true),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            like_utf8_scalar_dyn(&dict_array, "%r").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(true),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            like_utf8_scalar_dyn(&dict_array, "%i%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(true),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            like_utf8_scalar_dyn(&dict_array, "%i%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(true),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            like_utf8_scalar_dyn(&dict_array, "%a%r%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(false),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            like_utf8_scalar_dyn(&dict_array, "%a%r%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(false),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+    }
+
+    #[test]
+    fn test_dict_nlike_kernels() {
+        let data = vec![
+            Some("Earth"),
+            Some("Fire"),
+            Some("Water"),
+            Some("Air"),
+            None,
+            Some("Air"),
+            Some("bbbbb\nAir"),
+        ];
+
+        let dict_array: DictionaryArray<Int8Type> = data.into_iter().collect();
+
+        assert_eq!(
+            nlike_utf8_scalar_dyn(&dict_array, "Air").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            nlike_utf8_scalar_dyn(&dict_array, "Air").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            nlike_utf8_scalar_dyn(&dict_array, "Wa%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            nlike_utf8_scalar_dyn(&dict_array, "Wa%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            nlike_utf8_scalar_dyn(&dict_array, "%r").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(false),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            nlike_utf8_scalar_dyn(&dict_array, "%r").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(false),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            nlike_utf8_scalar_dyn(&dict_array, "%i%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(false),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            nlike_utf8_scalar_dyn(&dict_array, "%i%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(false),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            nlike_utf8_scalar_dyn(&dict_array, "%a%r%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(true),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            nlike_utf8_scalar_dyn(&dict_array, "%a%r%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(true),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+    }
+
+    #[test]
+    fn test_dict_ilike_kernels() {
+        let data = vec![
+            Some("Earth"),
+            Some("Fire"),
+            Some("Water"),
+            Some("Air"),
+            None,
+            Some("Air"),
+            Some("bbbbb\nAir"),
+        ];
+
+        let dict_array: DictionaryArray<Int8Type> = data.into_iter().collect();
+
+        assert_eq!(
+            ilike_utf8_scalar_dyn(&dict_array, "air").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            ilike_utf8_scalar_dyn(&dict_array, "air").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            ilike_utf8_scalar_dyn(&dict_array, "wa%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            ilike_utf8_scalar_dyn(&dict_array, "wa%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            ilike_utf8_scalar_dyn(&dict_array, "%R").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(true),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            ilike_utf8_scalar_dyn(&dict_array, "%R").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(false),
+                Some(true),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            ilike_utf8_scalar_dyn(&dict_array, "%I%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(true),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            ilike_utf8_scalar_dyn(&dict_array, "%I%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(true),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            ilike_utf8_scalar_dyn(&dict_array, "%A%r%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(false),
+                Some(true),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            ilike_utf8_scalar_dyn(&dict_array, "%A%r%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(false),
+                Some(true),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+    }
+
+    #[test]
+    fn test_dict_nilike_kernels() {
+        let data = vec![
+            Some("Earth"),
+            Some("Fire"),
+            Some("Water"),
+            Some("Air"),
+            None,
+            Some("Air"),
+            Some("bbbbb\nAir"),
+        ];
+
+        let dict_array: DictionaryArray<Int8Type> = data.into_iter().collect();
+
+        assert_eq!(
+            nilike_utf8_scalar_dyn(&dict_array, "air").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            nilike_utf8_scalar_dyn(&dict_array, "air").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            nilike_utf8_scalar_dyn(&dict_array, "wa%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            nilike_utf8_scalar_dyn(&dict_array, "wa%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(false),
+                Some(true),
+                None,
+                Some(true),
+                Some(true),
+            ]),
+        );
+
+        assert_eq!(
+            nilike_utf8_scalar_dyn(&dict_array, "%R").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(false),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            nilike_utf8_scalar_dyn(&dict_array, "%R").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(true),
+                Some(false),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            nilike_utf8_scalar_dyn(&dict_array, "%I%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(false),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            nilike_utf8_scalar_dyn(&dict_array, "%I%").unwrap(),
+            BooleanArray::from(vec![
+                Some(true),
+                Some(false),
+                Some(true),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            nilike_utf8_scalar_dyn(&dict_array, "%A%r%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(true),
+                Some(false),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+
+        assert_eq!(
+            nilike_utf8_scalar_dyn(&dict_array, "%A%r%").unwrap(),
+            BooleanArray::from(vec![
+                Some(false),
+                Some(true),
+                Some(false),
+                Some(false),
+                None,
+                Some(false),
+                Some(false),
+            ]),
+        );
+    }
+
+    #[test]
+    fn like_scalar_null() {
+        let a = StringArray::new_scalar("a");
+        let b = Scalar::new(StringArray::new_null(1));
+        let r = like(&a, &b).unwrap();
+        assert_eq!(r.len(), 1);
+        assert_eq!(r.null_count(), 1);
+        assert!(r.is_null(0));
+
+        let a = StringArray::from_iter_values(["a"]);
+        let b = Scalar::new(StringArray::new_null(1));
+        let r = like(&a, &b).unwrap();
+        assert_eq!(r.len(), 1);
+        assert_eq!(r.null_count(), 1);
+        assert!(r.is_null(0));
+
+        let a = StringArray::from_iter_values(["a"]);
+        let b = StringArray::new_null(1);
+        let r = like(&a, &b).unwrap();
+        assert_eq!(r.len(), 1);
+        assert_eq!(r.null_count(), 1);
+        assert!(r.is_null(0));
+
+        let a = StringArray::new_scalar("a");
+        let b = StringArray::new_null(1);
+        let r = like(&a, &b).unwrap();
+        assert_eq!(r.len(), 1);
+        assert_eq!(r.null_count(), 1);
+        assert!(r.is_null(0));
+    }
+}
diff --git a/arrow-string/src/predicate.rs b/arrow-string/src/predicate.rs
new file mode 100644
index 000000000000..54ecf42e3684
--- /dev/null
+++ b/arrow-string/src/predicate.rs
@@ -0,0 +1,231 @@
+// 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.
+
+use arrow_array::{BooleanArray, GenericStringArray, OffsetSizeTrait};
+use arrow_schema::ArrowError;
+use memchr::memchr2;
+use regex::{Regex, RegexBuilder};
+
+/// A string based predicate
+pub enum Predicate<'a> {
+    Eq(&'a str),
+    Contains(&'a str),
+    StartsWith(&'a str),
+    EndsWith(&'a str),
+
+    /// Equality ignoring ASCII case
+    IEqAscii(&'a str),
+    /// Starts with ignoring ASCII case
+    IStartsWithAscii(&'a str),
+    /// Ends with ignoring ASCII case
+    IEndsWithAscii(&'a str),
+
+    Regex(Regex),
+}
+
+impl<'a> Predicate<'a> {
+    /// Create a predicate for the given like pattern
+    pub fn like(pattern: &'a str) -> Result<Self, ArrowError> {
+        if !contains_like_pattern(pattern) {
+            Ok(Self::Eq(pattern))
+        } else if pattern.ends_with('%')
+            && !pattern.ends_with("\\%")
+            && !contains_like_pattern(&pattern[..pattern.len() - 1])
+        {
+            Ok(Self::StartsWith(&pattern[..pattern.len() - 1]))
+        } else if pattern.starts_with('%') && !contains_like_pattern(&pattern[1..]) {
+            Ok(Self::EndsWith(&pattern[1..]))
+        } else if pattern.starts_with('%')
+            && pattern.ends_with('%')
+            && !pattern.ends_with("\\%")
+            && !contains_like_pattern(&pattern[1..pattern.len() - 1])
+        {
+            Ok(Self::Contains(&pattern[1..pattern.len() - 1]))
+        } else {
+            Ok(Self::Regex(regex_like(pattern, false)?))
+        }
+    }
+
+    /// Create a predicate for the given ilike pattern
+    pub fn ilike(pattern: &'a str, is_ascii: bool) -> Result<Self, ArrowError> {
+        if is_ascii && pattern.is_ascii() {
+            if !contains_like_pattern(pattern) {
+                return Ok(Self::IEqAscii(pattern));
+            } else if pattern.ends_with('%')
+                && !pattern.ends_with("\\%")
+                && !contains_like_pattern(&pattern[..pattern.len() - 1])
+            {
+                return Ok(Self::IStartsWithAscii(&pattern[..pattern.len() - 1]));
+            } else if pattern.starts_with('%') && !contains_like_pattern(&pattern[1..]) {
+                return Ok(Self::IEndsWithAscii(&pattern[1..]));
+            }
+        }
+        Ok(Self::Regex(regex_like(pattern, true)?))
+    }
+
+    /// Evaluate this predicate against the given haystack
+    pub fn evaluate(&self, haystack: &str) -> bool {
+        match self {
+            Predicate::Eq(v) => *v == haystack,
+            Predicate::IEqAscii(v) => haystack.eq_ignore_ascii_case(v),
+            Predicate::Contains(v) => haystack.contains(v),
+            Predicate::StartsWith(v) => haystack.starts_with(v),
+            Predicate::IStartsWithAscii(v) => starts_with_ignore_ascii_case(haystack, v),
+            Predicate::EndsWith(v) => haystack.ends_with(v),
+            Predicate::IEndsWithAscii(v) => ends_with_ignore_ascii_case(haystack, v),
+            Predicate::Regex(v) => v.is_match(haystack),
+        }
+    }
+
+    /// Evaluate this predicate against the elements of `array`
+    ///
+    /// If `negate` is true the result of the predicate will be negated
+    #[inline(never)]
+    pub fn evaluate_array<O: OffsetSizeTrait>(
+        &self,
+        array: &GenericStringArray<O>,
+        negate: bool,
+    ) -> BooleanArray {
+        match self {
+            Predicate::Eq(v) => BooleanArray::from_unary(array, |haystack| {
+                (haystack.len() == v.len() && haystack == *v) != negate
+            }),
+            Predicate::IEqAscii(v) => BooleanArray::from_unary(array, |haystack| {
+                haystack.eq_ignore_ascii_case(v) != negate
+            }),
+            Predicate::Contains(v) => {
+                BooleanArray::from_unary(array, |haystack| haystack.contains(v) != negate)
+            }
+            Predicate::StartsWith(v) => {
+                BooleanArray::from_unary(array, |haystack| haystack.starts_with(v) != negate)
+            }
+            Predicate::IStartsWithAscii(v) => BooleanArray::from_unary(array, |haystack| {
+                starts_with_ignore_ascii_case(haystack, v) != negate
+            }),
+            Predicate::EndsWith(v) => {
+                BooleanArray::from_unary(array, |haystack| haystack.ends_with(v) != negate)
+            }
+            Predicate::IEndsWithAscii(v) => BooleanArray::from_unary(array, |haystack| {
+                ends_with_ignore_ascii_case(haystack, v) != negate
+            }),
+            Predicate::Regex(v) => {
+                BooleanArray::from_unary(array, |haystack| v.is_match(haystack) != negate)
+            }
+        }
+    }
+}
+
+fn starts_with_ignore_ascii_case(haystack: &str, needle: &str) -> bool {
+    let end = haystack.len().min(needle.len());
+    haystack.is_char_boundary(end) && needle.eq_ignore_ascii_case(&haystack[..end])
+}
+
+fn ends_with_ignore_ascii_case(haystack: &str, needle: &str) -> bool {
+    let start = haystack.len().saturating_sub(needle.len());
+    haystack.is_char_boundary(start) && needle.eq_ignore_ascii_case(&haystack[start..])
+}
+
+/// Transforms a like `pattern` to a regex compatible pattern. To achieve that, it does:
+///
+/// 1. Replace like wildcards for regex expressions as the pattern will be evaluated using regex match: `%` => `.*` and `_` => `.`
+/// 2. Escape regex meta characters to match them and not be evaluated as regex special chars. For example: `.` => `\\.`
+/// 3. Replace escaped like wildcards removing the escape characters to be able to match it as a regex. For example: `\\%` => `%`
+fn regex_like(pattern: &str, case_insensitive: bool) -> Result<Regex, ArrowError> {
+    let mut result = String::with_capacity(pattern.len() * 2);
+    result.push('^');
+    let mut chars_iter = pattern.chars().peekable();
+    while let Some(c) = chars_iter.next() {
+        if c == '\\' {
+            let next = chars_iter.peek();
+            match next {
+                Some(next) if is_like_pattern(*next) => {
+                    result.push(*next);
+                    // Skipping the next char as it is already appended
+                    chars_iter.next();
+                }
+                _ => {
+                    result.push('\\');
+                    result.push('\\');
+                }
+            }
+        } else if regex_syntax::is_meta_character(c) {
+            result.push('\\');
+            result.push(c);
+        } else if c == '%' {
+            result.push_str(".*");
+        } else if c == '_' {
+            result.push('.');
+        } else {
+            result.push(c);
+        }
+    }
+    result.push('$');
+    RegexBuilder::new(&result)
+        .case_insensitive(case_insensitive)
+        .dot_matches_new_line(true)
+        .build()
+        .map_err(|e| {
+            ArrowError::InvalidArgumentError(format!(
+                "Unable to build regex from LIKE pattern: {e}"
+            ))
+        })
+}
+
+fn is_like_pattern(c: char) -> bool {
+    c == '%' || c == '_'
+}
+
+fn contains_like_pattern(pattern: &str) -> bool {
+    memchr2(b'%', b'_', pattern.as_bytes()).is_some()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_replace_like_wildcards() {
+        let a_eq = "_%";
+        let expected = "^..*$";
+        let r = regex_like(a_eq, false).unwrap();
+        assert_eq!(r.to_string(), expected);
+    }
+
+    #[test]
+    fn test_replace_like_wildcards_leave_like_meta_chars() {
+        let a_eq = "\\%\\_";
+        let expected = "^%_$";
+        let r = regex_like(a_eq, false).unwrap();
+        assert_eq!(r.to_string(), expected);
+    }
+
+    #[test]
+    fn test_replace_like_wildcards_with_multiple_escape_chars() {
+        let a_eq = "\\\\%";
+        let expected = "^\\\\%$";
+        let r = regex_like(a_eq, false).unwrap();
+        assert_eq!(r.to_string(), expected);
+    }
+
+    #[test]
+    fn test_replace_like_wildcards_escape_regex_meta_char() {
+        let a_eq = ".";
+        let expected = "^\\.$";
+        let r = regex_like(a_eq, false).unwrap();
+        assert_eq!(r.to_string(), expected);
+    }
+}
diff --git a/arrow-string/src/regexp.rs b/arrow-string/src/regexp.rs
new file mode 100644
index 000000000000..5e539b91b492
--- /dev/null
+++ b/arrow-string/src/regexp.rs
@@ -0,0 +1,631 @@
+// 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.
+
+//! Defines kernel to extract substrings based on a regular
+//! expression of a \[Large\]StringArray
+
+use arrow_array::builder::{BooleanBufferBuilder, GenericStringBuilder, ListBuilder};
+use arrow_array::cast::AsArray;
+use arrow_array::*;
+use arrow_buffer::NullBuffer;
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{ArrowError, DataType, Field};
+use regex::Regex;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+/// Perform SQL `array ~ regex_array` operation on [`StringArray`] / [`LargeStringArray`].
+/// If `regex_array` element has an empty value, the corresponding result value is always true.
+///
+/// `flags_array` are optional [`StringArray`] / [`LargeStringArray`] flag, which allow
+/// special search modes, such as case insensitive and multi-line mode.
+/// See the documentation [here](https://docs.rs/regex/1.5.4/regex/#grouping-and-flags)
+/// for more information.
+pub fn regexp_is_match_utf8<OffsetSize: OffsetSizeTrait>(
+    array: &GenericStringArray<OffsetSize>,
+    regex_array: &GenericStringArray<OffsetSize>,
+    flags_array: Option<&GenericStringArray<OffsetSize>>,
+) -> Result<BooleanArray, ArrowError> {
+    if array.len() != regex_array.len() {
+        return Err(ArrowError::ComputeError(
+            "Cannot perform comparison operation on arrays of different length".to_string(),
+        ));
+    }
+    let nulls = NullBuffer::union(array.nulls(), regex_array.nulls());
+
+    let mut patterns: HashMap<String, Regex> = HashMap::new();
+    let mut result = BooleanBufferBuilder::new(array.len());
+
+    let complete_pattern = match flags_array {
+        Some(flags) => Box::new(
+            regex_array
+                .iter()
+                .zip(flags.iter())
+                .map(|(pattern, flags)| {
+                    pattern.map(|pattern| match flags {
+                        Some(flag) => format!("(?{flag}){pattern}"),
+                        None => pattern.to_string(),
+                    })
+                }),
+        ) as Box<dyn Iterator<Item = Option<String>>>,
+        None => Box::new(
+            regex_array
+                .iter()
+                .map(|pattern| pattern.map(|pattern| pattern.to_string())),
+        ),
+    };
+
+    array
+        .iter()
+        .zip(complete_pattern)
+        .map(|(value, pattern)| {
+            match (value, pattern) {
+                // Required for Postgres compatibility:
+                // SELECT 'foobarbequebaz' ~ ''); = true
+                (Some(_), Some(pattern)) if pattern == *"" => {
+                    result.append(true);
+                }
+                (Some(value), Some(pattern)) => {
+                    let existing_pattern = patterns.get(&pattern);
+                    let re = match existing_pattern {
+                        Some(re) => re,
+                        None => {
+                            let re = Regex::new(pattern.as_str()).map_err(|e| {
+                                ArrowError::ComputeError(format!(
+                                    "Regular expression did not compile: {e:?}"
+                                ))
+                            })?;
+                            patterns.entry(pattern).or_insert(re)
+                        }
+                    };
+                    result.append(re.is_match(value));
+                }
+                _ => result.append(false),
+            }
+            Ok(())
+        })
+        .collect::<Result<Vec<()>, ArrowError>>()?;
+
+    let data = unsafe {
+        ArrayDataBuilder::new(DataType::Boolean)
+            .len(array.len())
+            .buffers(vec![result.into()])
+            .nulls(nulls)
+            .build_unchecked()
+    };
+    Ok(BooleanArray::from(data))
+}
+
+/// Perform SQL `array ~ regex_array` operation on [`StringArray`] /
+/// [`LargeStringArray`] and a scalar.
+///
+/// See the documentation on [`regexp_is_match_utf8`] for more details.
+pub fn regexp_is_match_utf8_scalar<OffsetSize: OffsetSizeTrait>(
+    array: &GenericStringArray<OffsetSize>,
+    regex: &str,
+    flag: Option<&str>,
+) -> Result<BooleanArray, ArrowError> {
+    let null_bit_buffer = array.nulls().map(|x| x.inner().sliced());
+    let mut result = BooleanBufferBuilder::new(array.len());
+
+    let pattern = match flag {
+        Some(flag) => format!("(?{flag}){regex}"),
+        None => regex.to_string(),
+    };
+    if pattern.is_empty() {
+        result.append_n(array.len(), true);
+    } else {
+        let re = Regex::new(pattern.as_str()).map_err(|e| {
+            ArrowError::ComputeError(format!("Regular expression did not compile: {e:?}"))
+        })?;
+        for i in 0..array.len() {
+            let value = array.value(i);
+            result.append(re.is_match(value));
+        }
+    }
+
+    let buffer = result.into();
+    let data = unsafe {
+        ArrayData::new_unchecked(
+            DataType::Boolean,
+            array.len(),
+            None,
+            null_bit_buffer,
+            0,
+            vec![buffer],
+            vec![],
+        )
+    };
+    Ok(BooleanArray::from(data))
+}
+
+fn regexp_array_match<OffsetSize: OffsetSizeTrait>(
+    array: &GenericStringArray<OffsetSize>,
+    regex_array: &GenericStringArray<OffsetSize>,
+    flags_array: Option<&GenericStringArray<OffsetSize>>,
+) -> Result<ArrayRef, ArrowError> {
+    let mut patterns: HashMap<String, Regex> = HashMap::new();
+    let builder: GenericStringBuilder<OffsetSize> = GenericStringBuilder::with_capacity(0, 0);
+    let mut list_builder = ListBuilder::new(builder);
+
+    let complete_pattern = match flags_array {
+        Some(flags) => Box::new(
+            regex_array
+                .iter()
+                .zip(flags.iter())
+                .map(|(pattern, flags)| {
+                    pattern.map(|pattern| match flags {
+                        Some(value) => format!("(?{value}){pattern}"),
+                        None => pattern.to_string(),
+                    })
+                }),
+        ) as Box<dyn Iterator<Item = Option<String>>>,
+        None => Box::new(
+            regex_array
+                .iter()
+                .map(|pattern| pattern.map(|pattern| pattern.to_string())),
+        ),
+    };
+
+    array
+        .iter()
+        .zip(complete_pattern)
+        .map(|(value, pattern)| {
+            match (value, pattern) {
+                // Required for Postgres compatibility:
+                // SELECT regexp_match('foobarbequebaz', ''); = {""}
+                (Some(_), Some(pattern)) if pattern == *"" => {
+                    list_builder.values().append_value("");
+                    list_builder.append(true);
+                }
+                (Some(value), Some(pattern)) => {
+                    let existing_pattern = patterns.get(&pattern);
+                    let re = match existing_pattern {
+                        Some(re) => re,
+                        None => {
+                            let re = Regex::new(pattern.as_str()).map_err(|e| {
+                                ArrowError::ComputeError(format!(
+                                    "Regular expression did not compile: {e:?}"
+                                ))
+                            })?;
+                            patterns.entry(pattern).or_insert(re)
+                        }
+                    };
+                    match re.captures(value) {
+                        Some(caps) => {
+                            let mut iter = caps.iter();
+                            if caps.len() > 1 {
+                                iter.next();
+                            }
+                            for m in iter.flatten() {
+                                list_builder.values().append_value(m.as_str());
+                            }
+
+                            list_builder.append(true);
+                        }
+                        None => list_builder.append(false),
+                    }
+                }
+                _ => list_builder.append(false),
+            }
+            Ok(())
+        })
+        .collect::<Result<Vec<()>, ArrowError>>()?;
+    Ok(Arc::new(list_builder.finish()))
+}
+
+fn get_scalar_pattern_flag<'a, OffsetSize: OffsetSizeTrait>(
+    regex_array: &'a dyn Array,
+    flag_array: Option<&'a dyn Array>,
+) -> (Option<&'a str>, Option<&'a str>) {
+    let regex = regex_array.as_string::<OffsetSize>();
+    let regex = regex.is_valid(0).then(|| regex.value(0));
+
+    if let Some(flag_array) = flag_array {
+        let flag = flag_array.as_string::<OffsetSize>();
+        (regex, flag.is_valid(0).then(|| flag.value(0)))
+    } else {
+        (regex, None)
+    }
+}
+
+fn regexp_scalar_match<OffsetSize: OffsetSizeTrait>(
+    array: &GenericStringArray<OffsetSize>,
+    regex: &Regex,
+) -> Result<ArrayRef, ArrowError> {
+    let builder: GenericStringBuilder<OffsetSize> = GenericStringBuilder::with_capacity(0, 0);
+    let mut list_builder = ListBuilder::new(builder);
+
+    array
+        .iter()
+        .map(|value| {
+            match value {
+                // Required for Postgres compatibility:
+                // SELECT regexp_match('foobarbequebaz', ''); = {""}
+                Some(_) if regex.as_str() == "" => {
+                    list_builder.values().append_value("");
+                    list_builder.append(true);
+                }
+                Some(value) => match regex.captures(value) {
+                    Some(caps) => {
+                        let mut iter = caps.iter();
+                        if caps.len() > 1 {
+                            iter.next();
+                        }
+                        for m in iter.flatten() {
+                            list_builder.values().append_value(m.as_str());
+                        }
+
+                        list_builder.append(true);
+                    }
+                    None => list_builder.append(false),
+                },
+                _ => list_builder.append(false),
+            }
+            Ok(())
+        })
+        .collect::<Result<Vec<()>, ArrowError>>()?;
+
+    Ok(Arc::new(list_builder.finish()))
+}
+
+/// Extract all groups matched by a regular expression for a given String array.
+///
+/// Modelled after the Postgres [regexp_match].
+///
+/// Returns a ListArray of [`GenericStringArray`] with each element containing the leftmost-first
+/// match of the corresponding index in `regex_array` to string in `array`
+///
+/// If there is no match, the list element is NULL.
+///
+/// If a match is found, and the pattern contains no capturing parenthesized subexpressions,
+/// then the list element is a single-element [`GenericStringArray`] containing the substring
+/// matching the whole pattern.
+///
+/// If a match is found, and the pattern contains capturing parenthesized subexpressions, then the
+/// list element is a [`GenericStringArray`] whose n'th element is the substring matching
+/// the n'th capturing parenthesized subexpression of the pattern.
+///
+/// The flags parameter is an optional text string containing zero or more single-letter flags
+/// that change the function's behavior.
+///
+/// [regexp_match]: https://www.postgresql.org/docs/current/functions-matching.html#FUNCTIONS-POSIX-REGEXP
+pub fn regexp_match(
+    array: &dyn Array,
+    regex_array: &dyn Datum,
+    flags_array: Option<&dyn Datum>,
+) -> Result<ArrayRef, ArrowError> {
+    let (rhs, is_rhs_scalar) = regex_array.get();
+
+    if array.data_type() != rhs.data_type() {
+        return Err(ArrowError::ComputeError(
+            "regexp_match() requires both array and pattern to be either Utf8 or LargeUtf8"
+                .to_string(),
+        ));
+    }
+
+    let (flags, is_flags_scalar) = match flags_array {
+        Some(flags) => {
+            let (flags, is_flags_scalar) = flags.get();
+            (Some(flags), Some(is_flags_scalar))
+        }
+        None => (None, None),
+    };
+
+    if is_flags_scalar.is_some() && is_rhs_scalar != is_flags_scalar.unwrap() {
+        return Err(ArrowError::ComputeError(
+            "regexp_match() requires both pattern and flags to be either scalar or array"
+                .to_string(),
+        ));
+    }
+
+    if flags_array.is_some() && rhs.data_type() != flags.unwrap().data_type() {
+        return Err(ArrowError::ComputeError(
+            "regexp_match() requires both pattern and flags to be either string or largestring"
+                .to_string(),
+        ));
+    }
+
+    if is_rhs_scalar {
+        // Regex and flag is scalars
+        let (regex, flag) = match rhs.data_type() {
+            DataType::Utf8 => get_scalar_pattern_flag::<i32>(rhs, flags),
+            DataType::LargeUtf8 => get_scalar_pattern_flag::<i64>(rhs, flags),
+            _ => {
+                return Err(ArrowError::ComputeError(
+                    "regexp_match() requires pattern to be either Utf8 or LargeUtf8".to_string(),
+                ));
+            }
+        };
+
+        if regex.is_none() {
+            return Ok(new_null_array(
+                &DataType::List(Arc::new(Field::new(
+                    "item",
+                    array.data_type().clone(),
+                    true,
+                ))),
+                array.len(),
+            ));
+        }
+
+        let regex = regex.unwrap();
+
+        let pattern = if let Some(flag) = flag {
+            format!("(?{flag}){regex}")
+        } else {
+            regex.to_string()
+        };
+
+        let re = Regex::new(pattern.as_str()).map_err(|e| {
+            ArrowError::ComputeError(format!("Regular expression did not compile: {e:?}"))
+        })?;
+
+        match array.data_type() {
+            DataType::Utf8 => regexp_scalar_match(array.as_string::<i32>(), &re),
+            DataType::LargeUtf8 => regexp_scalar_match(array.as_string::<i64>(), &re),
+            _ => Err(ArrowError::ComputeError(
+                "regexp_match() requires array to be either Utf8 or LargeUtf8".to_string(),
+            )),
+        }
+    } else {
+        match array.data_type() {
+            DataType::Utf8 => {
+                let regex_array = rhs.as_string();
+                let flags_array = flags.map(|flags| flags.as_string());
+                regexp_array_match(array.as_string::<i32>(), regex_array, flags_array)
+            }
+            DataType::LargeUtf8 => {
+                let regex_array = rhs.as_string();
+                let flags_array = flags.map(|flags| flags.as_string());
+                regexp_array_match(array.as_string::<i64>(), regex_array, flags_array)
+            }
+            _ => Err(ArrowError::ComputeError(
+                "regexp_match() requires array to be either Utf8 or LargeUtf8".to_string(),
+            )),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use arrow_array::{ListArray, StringArray};
+
+    #[test]
+    fn match_single_group() {
+        let values = vec![
+            Some("abc-005-def"),
+            Some("X-7-5"),
+            Some("X545"),
+            None,
+            Some("foobarbequebaz"),
+            Some("foobarbequebaz"),
+        ];
+        let array = StringArray::from(values);
+        let mut pattern_values = vec![r".*-(\d*)-.*"; 4];
+        pattern_values.push(r"(bar)(bequ1e)");
+        pattern_values.push("");
+        let pattern = GenericStringArray::<i32>::from(pattern_values);
+        let actual = regexp_match(&array, &pattern, None).unwrap();
+        let elem_builder: GenericStringBuilder<i32> = GenericStringBuilder::new();
+        let mut expected_builder = ListBuilder::new(elem_builder);
+        expected_builder.values().append_value("005");
+        expected_builder.append(true);
+        expected_builder.values().append_value("7");
+        expected_builder.append(true);
+        expected_builder.append(false);
+        expected_builder.append(false);
+        expected_builder.append(false);
+        expected_builder.values().append_value("");
+        expected_builder.append(true);
+        let expected = expected_builder.finish();
+        let result = actual.as_any().downcast_ref::<ListArray>().unwrap();
+        assert_eq!(&expected, result);
+    }
+
+    #[test]
+    fn match_single_group_with_flags() {
+        let values = vec![Some("abc-005-def"), Some("X-7-5"), Some("X545"), None];
+        let array = StringArray::from(values);
+        let pattern = StringArray::from(vec![r"x.*-(\d*)-.*"; 4]);
+        let flags = StringArray::from(vec!["i"; 4]);
+        let actual = regexp_match(&array, &pattern, Some(&flags)).unwrap();
+        let elem_builder: GenericStringBuilder<i32> = GenericStringBuilder::with_capacity(0, 0);
+        let mut expected_builder = ListBuilder::new(elem_builder);
+        expected_builder.append(false);
+        expected_builder.values().append_value("7");
+        expected_builder.append(true);
+        expected_builder.append(false);
+        expected_builder.append(false);
+        let expected = expected_builder.finish();
+        let result = actual.as_any().downcast_ref::<ListArray>().unwrap();
+        assert_eq!(&expected, result);
+    }
+
+    #[test]
+    fn match_scalar_pattern() {
+        let values = vec![Some("abc-005-def"), Some("X-7-5"), Some("X545"), None];
+        let array = StringArray::from(values);
+        let pattern = Scalar::new(StringArray::from(vec![r"x.*-(\d*)-.*"; 1]));
+        let flags = Scalar::new(StringArray::from(vec!["i"; 1]));
+        let actual = regexp_match(&array, &pattern, Some(&flags)).unwrap();
+        let elem_builder: GenericStringBuilder<i32> = GenericStringBuilder::with_capacity(0, 0);
+        let mut expected_builder = ListBuilder::new(elem_builder);
+        expected_builder.append(false);
+        expected_builder.values().append_value("7");
+        expected_builder.append(true);
+        expected_builder.append(false);
+        expected_builder.append(false);
+        let expected = expected_builder.finish();
+        let result = actual.as_any().downcast_ref::<ListArray>().unwrap();
+        assert_eq!(&expected, result);
+
+        // No flag
+        let values = vec![Some("abc-005-def"), Some("x-7-5"), Some("X545"), None];
+        let array = StringArray::from(values);
+        let actual = regexp_match(&array, &pattern, None).unwrap();
+        let result = actual.as_any().downcast_ref::<ListArray>().unwrap();
+        assert_eq!(&expected, result);
+    }
+
+    #[test]
+    fn match_scalar_no_pattern() {
+        let values = vec![Some("abc-005-def"), Some("X-7-5"), Some("X545"), None];
+        let array = StringArray::from(values);
+        let pattern = Scalar::new(new_null_array(&DataType::Utf8, 1));
+        let actual = regexp_match(&array, &pattern, None).unwrap();
+        let elem_builder: GenericStringBuilder<i32> = GenericStringBuilder::with_capacity(0, 0);
+        let mut expected_builder = ListBuilder::new(elem_builder);
+        expected_builder.append(false);
+        expected_builder.append(false);
+        expected_builder.append(false);
+        expected_builder.append(false);
+        let expected = expected_builder.finish();
+        let result = actual.as_any().downcast_ref::<ListArray>().unwrap();
+        assert_eq!(&expected, result);
+    }
+
+    #[test]
+    fn test_single_group_not_skip_match() {
+        let array = StringArray::from(vec![Some("foo"), Some("bar")]);
+        let pattern = GenericStringArray::<i32>::from(vec![r"foo"]);
+        let actual = regexp_match(&array, &pattern, None).unwrap();
+        let result = actual.as_any().downcast_ref::<ListArray>().unwrap();
+        let elem_builder: GenericStringBuilder<i32> = GenericStringBuilder::new();
+        let mut expected_builder = ListBuilder::new(elem_builder);
+        expected_builder.values().append_value("foo");
+        expected_builder.append(true);
+        let expected = expected_builder.finish();
+        assert_eq!(&expected, result);
+    }
+
+    macro_rules! test_flag_utf8 {
+        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let left = StringArray::from($left);
+                let right = StringArray::from($right);
+                let res = $op(&left, &right, None).unwrap();
+                let expected = $expected;
+                assert_eq!(expected.len(), res.len());
+                for i in 0..res.len() {
+                    let v = res.value(i);
+                    assert_eq!(v, expected[i]);
+                }
+            }
+        };
+        ($test_name:ident, $left:expr, $right:expr, $flag:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let left = StringArray::from($left);
+                let right = StringArray::from($right);
+                let flag = Some(StringArray::from($flag));
+                let res = $op(&left, &right, flag.as_ref()).unwrap();
+                let expected = $expected;
+                assert_eq!(expected.len(), res.len());
+                for i in 0..res.len() {
+                    let v = res.value(i);
+                    assert_eq!(v, expected[i]);
+                }
+            }
+        };
+    }
+
+    macro_rules! test_flag_utf8_scalar {
+        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let left = StringArray::from($left);
+                let res = $op(&left, $right, None).unwrap();
+                let expected = $expected;
+                assert_eq!(expected.len(), res.len());
+                for i in 0..res.len() {
+                    let v = res.value(i);
+                    assert_eq!(
+                        v,
+                        expected[i],
+                        "unexpected result when comparing {} at position {} to {} ",
+                        left.value(i),
+                        i,
+                        $right
+                    );
+                }
+            }
+        };
+        ($test_name:ident, $left:expr, $right:expr, $flag:expr, $op:expr, $expected:expr) => {
+            #[test]
+            fn $test_name() {
+                let left = StringArray::from($left);
+                let flag = Some($flag);
+                let res = $op(&left, $right, flag).unwrap();
+                let expected = $expected;
+                assert_eq!(expected.len(), res.len());
+                for i in 0..res.len() {
+                    let v = res.value(i);
+                    assert_eq!(
+                        v,
+                        expected[i],
+                        "unexpected result when comparing {} at position {} to {} ",
+                        left.value(i),
+                        i,
+                        $right
+                    );
+                }
+            }
+        };
+    }
+
+    test_flag_utf8!(
+        test_utf8_array_regexp_is_match,
+        vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrow"],
+        vec!["^ar", "^AR", "ow$", "OW$", "foo", ""],
+        regexp_is_match_utf8,
+        [true, false, true, false, false, true]
+    );
+    test_flag_utf8!(
+        test_utf8_array_regexp_is_match_insensitive,
+        vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrow"],
+        vec!["^ar", "^AR", "ow$", "OW$", "foo", ""],
+        vec!["i"; 6],
+        regexp_is_match_utf8,
+        [true, true, true, true, false, true]
+    );
+
+    test_flag_utf8_scalar!(
+        test_utf8_array_regexp_is_match_scalar,
+        vec!["arrow", "ARROW", "parquet", "PARQUET"],
+        "^ar",
+        regexp_is_match_utf8_scalar,
+        [true, false, false, false]
+    );
+    test_flag_utf8_scalar!(
+        test_utf8_array_regexp_is_match_empty_scalar,
+        vec!["arrow", "ARROW", "parquet", "PARQUET"],
+        "",
+        regexp_is_match_utf8_scalar,
+        [true, true, true, true]
+    );
+    test_flag_utf8_scalar!(
+        test_utf8_array_regexp_is_match_insensitive_scalar,
+        vec!["arrow", "ARROW", "parquet", "PARQUET"],
+        "^ar",
+        "i",
+        regexp_is_match_utf8_scalar,
+        [true, true, false, false]
+    );
+}
diff --git a/arrow/src/compute/kernels/substring.rs b/arrow-string/src/substring.rs
similarity index 83%
rename from arrow/src/compute/kernels/substring.rs
rename to arrow-string/src/substring.rs
index 5190d0bf0b67..f5fe811032fb 100644
--- a/arrow/src/compute/kernels/substring.rs
+++ b/arrow-string/src/substring.rs
@@ -19,14 +19,13 @@
 //! Supported array types:
 //! [GenericStringArray], [GenericBinaryArray], [FixedSizeBinaryArray], [DictionaryArray]
 
-use crate::array::DictionaryArray;
-use crate::buffer::MutableBuffer;
-use crate::datatypes::*;
-use crate::{array::*, buffer::Buffer};
-use crate::{
-    datatypes::DataType,
-    error::{ArrowError, Result},
-};
+use arrow_array::builder::BufferBuilder;
+use arrow_array::types::*;
+use arrow_array::*;
+use arrow_buffer::{ArrowNativeType, Buffer, MutableBuffer};
+use arrow_data::ArrayData;
+use arrow_schema::{ArrowError, DataType};
+use num::Zero;
 use std::cmp::Ordering;
 use std::sync::Arc;
 
@@ -45,8 +44,8 @@ use std::sync::Arc;
 ///
 /// # Basic usage
 /// ```
-/// # use arrow::array::StringArray;
-/// # use arrow::compute::kernels::substring::substring;
+/// # use arrow_array::StringArray;
+/// # use arrow_string::substring::substring;
 /// let array = StringArray::from(vec![Some("arrow"), None, Some("rust")]);
 /// let result = substring(&array, 1, Some(4)).unwrap();
 /// let result = result.as_any().downcast_ref::<StringArray>().unwrap();
@@ -61,13 +60,17 @@ use std::sync::Arc;
 ///
 /// ## Example of trying to get an invalid utf-8 format substring
 /// ```
-/// # use arrow::array::StringArray;
-/// # use arrow::compute::kernels::substring::substring;
+/// # use arrow_array::StringArray;
+/// # use arrow_string::substring::substring;
 /// let array = StringArray::from(vec![Some("E=mc²")]);
 /// let error = substring(&array, 0, Some(5)).unwrap_err().to_string();
 /// assert!(error.contains("invalid utf-8 boundary"));
 /// ```
-pub fn substring(array: &dyn Array, start: i64, length: Option<u64>) -> Result<ArrayRef> {
+pub fn substring(
+    array: &dyn Array,
+    start: i64,
+    length: Option<u64>,
+) -> Result<ArrayRef, ArrowError> {
     macro_rules! substring_dict {
         ($kt: ident, $($t: ident: $gt: ident), *) => {
             match $kt.as_ref() {
@@ -81,7 +84,7 @@ pub fn substring(array: &dyn Array, start: i64, length: Option<u64>) -> Result<A
                                        stringify!($gt), array.data_type())
                             });
                         let values = substring(dict.values(), start, length)?;
-                        let result = DictionaryArray::try_new(dict.keys(), &values)?;
+                        let result = DictionaryArray::try_new(dict.keys().clone(), values)?;
                         Ok(Arc::new(result))
                     },
                 )*
@@ -104,7 +107,7 @@ pub fn substring(array: &dyn Array, start: i64, length: Option<u64>) -> Result<A
                 UInt64: UInt64Type
             )
         }
-        DataType::LargeBinary => binary_substring(
+        DataType::LargeBinary => byte_substring(
             array
                 .as_any()
                 .downcast_ref::<LargeBinaryArray>()
@@ -112,7 +115,7 @@ pub fn substring(array: &dyn Array, start: i64, length: Option<u64>) -> Result<A
             start,
             length.map(|e| e as i64),
         ),
-        DataType::Binary => binary_substring(
+        DataType::Binary => byte_substring(
             array
                 .as_any()
                 .downcast_ref::<BinaryArray>()
@@ -129,7 +132,7 @@ pub fn substring(array: &dyn Array, start: i64, length: Option<u64>) -> Result<A
             start as i32,
             length.map(|e| e as i32),
         ),
-        DataType::LargeUtf8 => utf8_substring(
+        DataType::LargeUtf8 => byte_substring(
             array
                 .as_any()
                 .downcast_ref::<LargeStringArray>()
@@ -137,7 +140,7 @@ pub fn substring(array: &dyn Array, start: i64, length: Option<u64>) -> Result<A
             start,
             length.map(|e| e as i64),
         ),
-        DataType::Utf8 => utf8_substring(
+        DataType::Utf8 => byte_substring(
             array
                 .as_any()
                 .downcast_ref::<StringArray>()
@@ -171,8 +174,8 @@ pub fn substring(array: &dyn Array, start: i64, length: Option<u64>) -> Result<A
 ///
 /// # Basic usage
 /// ```
-/// # use arrow::array::StringArray;
-/// # use arrow::compute::kernels::substring::substring_by_char;
+/// # use arrow_array::StringArray;
+/// # use arrow_string::substring::substring_by_char;
 /// let array = StringArray::from(vec![Some("arrow"), None, Some("Γ ⊢x:T")]);
 /// let result = substring_by_char(&array, 1, Some(4)).unwrap();
 /// assert_eq!(result, StringArray::from(vec![Some("rrow"), None, Some(" ⊢x:")]));
@@ -181,7 +184,7 @@ pub fn substring_by_char<OffsetSize: OffsetSizeTrait>(
     array: &GenericStringArray<OffsetSize>,
     start: i64,
     length: Option<u64>,
-) -> Result<GenericStringArray<OffsetSize>> {
+) -> Result<GenericStringArray<OffsetSize>, ArrowError> {
     let mut vals = BufferBuilder::<u8>::new({
         let offsets = array.value_offsets();
         (offsets[array.len()] - offsets[0]).to_usize().unwrap()
@@ -208,10 +211,7 @@ pub fn substring_by_char<OffsetSize: OffsetSizeTrait>(
             GenericStringArray::<OffsetSize>::DATA_TYPE,
             array.len(),
             None,
-            array
-                .data_ref()
-                .null_buffer()
-                .map(|b| b.bit_slice(array.offset(), array.len())),
+            array.nulls().map(|b| b.inner().sliced()),
             0,
             vec![new_offsets.finish(), vals.finish()],
             vec![],
@@ -225,11 +225,7 @@ pub fn substring_by_char<OffsetSize: OffsetSizeTrait>(
 /// * `length` - the char length of the substring
 ///
 /// Return the `start` and `end` offset (by byte) of the substring
-fn get_start_end_offset(
-    val: &str,
-    start: usize,
-    length: Option<usize>,
-) -> (usize, usize) {
+fn get_start_end_offset(val: &str, start: usize, length: Option<usize>) -> (usize, usize) {
     let len = val.len();
     let mut offset_char_iter = val.char_indices();
     let start_offset = offset_char_iter
@@ -247,62 +243,81 @@ fn get_start_end_offset(
     (start_offset, end_offset)
 }
 
-fn binary_substring<OffsetSize: OffsetSizeTrait>(
-    array: &GenericBinaryArray<OffsetSize>,
-    start: OffsetSize,
-    length: Option<OffsetSize>,
-) -> Result<ArrayRef> {
+fn byte_substring<T: ByteArrayType>(
+    array: &GenericByteArray<T>,
+    start: T::Offset,
+    length: Option<T::Offset>,
+) -> Result<ArrayRef, ArrowError>
+where
+    <T as ByteArrayType>::Native: PartialEq,
+{
     let offsets = array.value_offsets();
-    let values = array.value_data();
-    let data = values.as_slice();
-    let zero = OffsetSize::zero();
+    let data = array.value_data();
+    let zero = <T::Offset as Zero>::zero();
+
+    // When array is [Large]StringArray, we will check whether `offset` is at a valid char boundary.
+    let check_char_boundary = {
+        |offset: T::Offset| {
+            if !matches!(T::DATA_TYPE, DataType::Utf8 | DataType::LargeUtf8) {
+                return Ok(offset);
+            }
+            // Safety: a StringArray must contain valid UTF8 data
+            let data_str = unsafe { std::str::from_utf8_unchecked(data) };
+            let offset_usize = offset.as_usize();
+            if data_str.is_char_boundary(offset_usize) {
+                Ok(offset)
+            } else {
+                Err(ArrowError::ComputeError(format!(
+                    "The offset {offset_usize} is at an invalid utf-8 boundary."
+                )))
+            }
+        }
+    };
 
     // start and end offsets of all substrings
-    let mut new_starts_ends: Vec<(OffsetSize, OffsetSize)> =
-        Vec::with_capacity(array.len());
-    let mut new_offsets: Vec<OffsetSize> = Vec::with_capacity(array.len() + 1);
+    let mut new_starts_ends: Vec<(T::Offset, T::Offset)> = Vec::with_capacity(array.len());
+    let mut new_offsets: Vec<T::Offset> = Vec::with_capacity(array.len() + 1);
     let mut len_so_far = zero;
     new_offsets.push(zero);
 
-    offsets.windows(2).for_each(|pair| {
-        let new_start = match start.cmp(&zero) {
-            Ordering::Greater => (pair[0] + start).min(pair[1]),
-            Ordering::Equal => pair[0],
-            Ordering::Less => (pair[1] + start).max(pair[0]),
-        };
-        let new_end = match length {
-            Some(length) => (length + new_start).min(pair[1]),
-            None => pair[1],
-        };
-        len_so_far += new_end - new_start;
-        new_starts_ends.push((new_start, new_end));
-        new_offsets.push(len_so_far);
-    });
+    offsets
+        .windows(2)
+        .try_for_each(|pair| -> Result<(), ArrowError> {
+            let new_start = match start.cmp(&zero) {
+                Ordering::Greater => check_char_boundary((pair[0] + start).min(pair[1]))?,
+                Ordering::Equal => pair[0],
+                Ordering::Less => check_char_boundary((pair[1] + start).max(pair[0]))?,
+            };
+            let new_end = match length {
+                Some(length) => check_char_boundary((length + new_start).min(pair[1]))?,
+                None => pair[1],
+            };
+            len_so_far += new_end - new_start;
+            new_starts_ends.push((new_start, new_end));
+            new_offsets.push(len_so_far);
+            Ok(())
+        })?;
 
     // concatenate substrings into a buffer
-    let mut new_values =
-        MutableBuffer::new(new_offsets.last().unwrap().to_usize().unwrap());
+    let mut new_values = MutableBuffer::new(new_offsets.last().unwrap().as_usize());
 
     new_starts_ends
         .iter()
         .map(|(start, end)| {
-            let start = start.to_usize().unwrap();
-            let end = end.to_usize().unwrap();
+            let start = start.as_usize();
+            let end = end.as_usize();
             &data[start..end]
         })
         .for_each(|slice| new_values.extend_from_slice(slice));
 
     let data = unsafe {
         ArrayData::new_unchecked(
-            GenericBinaryArray::<OffsetSize>::DATA_TYPE,
+            GenericByteArray::<T>::DATA_TYPE,
             array.len(),
             None,
-            array
-                .data_ref()
-                .null_buffer()
-                .map(|b| b.bit_slice(array.offset(), array.len())),
+            array.nulls().map(|b| b.inner().sliced()),
             0,
-            vec![Buffer::from_slice_ref(&new_offsets), new_values.into()],
+            vec![Buffer::from_vec(new_offsets), new_values.into()],
             vec![],
         )
     };
@@ -314,7 +329,7 @@ fn fixed_size_binary_substring(
     old_len: i32,
     start: i32,
     length: Option<i32>,
-) -> Result<ArrayRef> {
+) -> Result<ArrayRef, ArrowError> {
     let new_start = if start >= 0 {
         start.min(old_len)
     } else {
@@ -327,8 +342,7 @@ fn fixed_size_binary_substring(
 
     // build value buffer
     let num_of_elements = array.len();
-    let values = array.value_data();
-    let data = values.as_slice();
+    let data = array.value_data();
     let mut new_values = MutableBuffer::new(num_of_elements * (new_len as usize));
     (0..num_of_elements)
         .map(|idx| {
@@ -345,10 +359,7 @@ fn fixed_size_binary_substring(
             DataType::FixedSizeBinary(new_len),
             num_of_elements,
             None,
-            array
-                .data_ref()
-                .null_buffer()
-                .map(|b| b.bit_slice(array.offset(), num_of_elements)),
+            array.nulls().map(|b| b.inner().sliced()),
             0,
             vec![new_values.into()],
             vec![],
@@ -358,92 +369,9 @@ fn fixed_size_binary_substring(
     Ok(make_array(array_data))
 }
 
-/// substring by byte
-fn utf8_substring<OffsetSize: OffsetSizeTrait>(
-    array: &GenericStringArray<OffsetSize>,
-    start: OffsetSize,
-    length: Option<OffsetSize>,
-) -> Result<ArrayRef> {
-    let offsets = array.value_offsets();
-    let values = array.value_data();
-    let data = values.as_slice();
-    let zero = OffsetSize::zero();
-
-    // Check if `offset` is at a valid char boundary.
-    // If yes, return `offset`, else return error
-    let check_char_boundary = {
-        // Safety: a StringArray must contain valid UTF8 data
-        let data_str = unsafe { std::str::from_utf8_unchecked(data) };
-        |offset: OffsetSize| {
-            let offset_usize = offset.to_usize().unwrap();
-            if data_str.is_char_boundary(offset_usize) {
-                Ok(offset)
-            } else {
-                Err(ArrowError::ComputeError(format!(
-                    "The offset {} is at an invalid utf-8 boundary.",
-                    offset_usize
-                )))
-            }
-        }
-    };
-
-    // start and end offsets of all substrings
-    let mut new_starts_ends: Vec<(OffsetSize, OffsetSize)> =
-        Vec::with_capacity(array.len());
-    let mut new_offsets: Vec<OffsetSize> = Vec::with_capacity(array.len() + 1);
-    let mut len_so_far = zero;
-    new_offsets.push(zero);
-
-    offsets.windows(2).try_for_each(|pair| -> Result<()> {
-        let new_start = match start.cmp(&zero) {
-            Ordering::Greater => check_char_boundary((pair[0] + start).min(pair[1]))?,
-            Ordering::Equal => pair[0],
-            Ordering::Less => check_char_boundary((pair[1] + start).max(pair[0]))?,
-        };
-        let new_end = match length {
-            Some(length) => check_char_boundary((length + new_start).min(pair[1]))?,
-            None => pair[1],
-        };
-        len_so_far += new_end - new_start;
-        new_starts_ends.push((new_start, new_end));
-        new_offsets.push(len_so_far);
-        Ok(())
-    })?;
-
-    // concatenate substrings into a buffer
-    let mut new_values =
-        MutableBuffer::new(new_offsets.last().unwrap().to_usize().unwrap());
-
-    new_starts_ends
-        .iter()
-        .map(|(start, end)| {
-            let start = start.to_usize().unwrap();
-            let end = end.to_usize().unwrap();
-            &data[start..end]
-        })
-        .for_each(|slice| new_values.extend_from_slice(slice));
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            GenericStringArray::<OffsetSize>::DATA_TYPE,
-            array.len(),
-            None,
-            array
-                .data_ref()
-                .null_buffer()
-                .map(|b| b.bit_slice(array.offset(), array.len())),
-            0,
-            vec![Buffer::from_slice_ref(&new_offsets), new_values.into()],
-            vec![],
-        )
-    };
-    Ok(make_array(data))
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::datatypes::*;
 
     /// A helper macro to generate test cases.
     /// # Arguments
@@ -715,8 +643,9 @@ mod tests {
             .as_any()
             .downcast_ref::<FixedSizeBinaryArray>()
             .unwrap();
-        let expected = FixedSizeBinaryArray::try_from_sparse_iter(
+        let expected = FixedSizeBinaryArray::try_from_sparse_iter_with_size(
             vec![None, Some(b"rrow")].into_iter(),
+            4,
         )
         .unwrap();
         assert_eq!(result, &expected);
@@ -725,8 +654,7 @@ mod tests {
     fn with_nulls_generic_string<O: OffsetSizeTrait>() {
         let input = vec![Some("hello"), None, Some("word")];
         // all-nulls array is always identical
-        let base_case =
-            gen_test_cases!(vec![None, None, None], (0, None, vec![None, None, None]));
+        let base_case = gen_test_cases!(vec![None, None, None], (0, None, vec![None, None, None]));
         let cases = gen_test_cases!(
             input,
             // identity
@@ -847,8 +775,7 @@ mod tests {
     fn with_nulls_generic_string_by_char<O: OffsetSizeTrait>() {
         let input = vec![Some("hello"), None, Some("Γ ⊢x:T")];
         // all-nulls array is always identical
-        let base_case =
-            gen_test_cases!(vec![None, None, None], (0, None, vec![None, None, None]));
+        let base_case = gen_test_cases!(vec![None, None, None], (0, None, vec![None, None, None]));
         let cases = gen_test_cases!(
             input,
             // identity
@@ -930,10 +857,8 @@ mod tests {
         let values = "S→T = Πx:S.T";
         let offsets = &[
             O::zero(),
-            O::from_usize(values.char_indices().nth(3).map(|(pos, _)| pos).unwrap())
-                .unwrap(),
-            O::from_usize(values.char_indices().nth(6).map(|(pos, _)| pos).unwrap())
-                .unwrap(),
+            O::from_usize(values.char_indices().nth(3).map(|(pos, _)| pos).unwrap()).unwrap(),
+            O::from_usize(values.char_indices().nth(6).map(|(pos, _)| pos).unwrap()).unwrap(),
             O::from_usize(values.len()).unwrap(),
         ];
         // set the first and third element to be valid
@@ -994,8 +919,7 @@ mod tests {
 
         let dict_array: DictionaryArray<K> = data.clone().into_iter().collect();
 
-        let expected: Vec<Option<&str>> =
-            data.iter().map(|opt| opt.map(|s| &s[1..3])).collect();
+        let expected: Vec<Option<&str>> = data.iter().map(|opt| opt.map(|s| &s[1..3])).collect();
 
         let res = substring(&dict_array, 1, Some(2)).unwrap();
         let actual = res.as_any().downcast_ref::<DictionaryArray<K>>().unwrap();
@@ -1033,4 +957,17 @@ mod tests {
         let err = substring(&array, 0, Some(5)).unwrap_err().to_string();
         assert!(err.contains("invalid utf-8 boundary"));
     }
+
+    #[test]
+    fn non_utf8_bytes() {
+        // non-utf8 bytes
+        let bytes: &[u8] = &[0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD, 0xE8, 0xAF, 0xAD];
+        let array = BinaryArray::from(vec![Some(bytes)]);
+        let arr = substring(&array, 0, Some(5)).unwrap();
+        let actual = arr.as_any().downcast_ref::<BinaryArray>().unwrap();
+
+        let expected_bytes: &[u8] = &[0xE4, 0xBD, 0xA0, 0xE5, 0xA5];
+        let expected = BinaryArray::from(vec![Some(expected_bytes)]);
+        assert_eq!(expected, *actual);
+    }
 }
diff --git a/arrow/CONTRIBUTING.md b/arrow/CONTRIBUTING.md
index bbf309d4d225..0c795d6b9cbd 100644
--- a/arrow/CONTRIBUTING.md
+++ b/arrow/CONTRIBUTING.md
@@ -26,23 +26,6 @@ Rust [README.md](../README.md).
 Please refer to [lib.rs](src/lib.rs) for an introduction to this
 specific crate and its current functionality.
 
-## IPC
-
-The expected flatc version is 1.12.0+, built from [flatbuffers](https://github.com/google/flatbuffers)
-master at fixed commit ID, by regen.sh.
-
-The IPC flatbuffer code was generated by running this command from the root of the project:
-
-```bash
-./regen.sh
-```
-
-The above script will run the `flatc` compiler and perform some adjustments to the source code:
-
-- Replace `type__` with `type_`
-- Remove `org::apache::arrow::flatbuffers` namespace
-- Add includes to each generated file
-
 ## Guidelines in usage of `unsafe`
 
 [`unsafe`](https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html) has a high maintenance cost because debugging and testing it is difficult, time consuming, often requires external tools (e.g. `valgrind`), and requires a higher-than-usual attention to details. Undefined behavior is particularly difficult to identify and test, and usage of `unsafe` is the [primary cause of undefined behavior](https://doc.rust-lang.org/reference/behavior-considered-undefined.html) in a program written in Rust.
@@ -84,18 +67,6 @@ the impossibility of the compiler to derive the invariants (such as lifetime, nu
 
 The arrow format declares a IPC protocol, which this crate supports. IPC is equivalent to a FFI in that the rust compiler can't reason about the contract's invariants.
 
-#### SIMD
-
-The API provided by the [packed_simd_2](https://docs.rs/packed_simd_2/latest/packed_simd_2/) crate is currently `unsafe`. However,
-SIMD offers a significant performance improvement over non-SIMD operations. A related crate in development is
-[portable-simd](https://rust-lang.github.io/portable-simd/core_simd/) which has a nice
-[beginners guide](https://github.com/rust-lang/portable-simd/blob/master/beginners-guide.md). These crates provide the ability
-for code on x86 and ARM architectures to use some of the available parallel register operations. As an example if two arrays
-of numbers are added, [1,2,3,4] + [5,6,7,8], rather than using four instructions to add each of the elements of the arrays,
-one instruction can be used to all all four elements at the same time, which leads to improved time to solution. SIMD instructions
-are typically most effective when data is aligned to allow a single load instruction to bring multiple consecutive data elements
-to the registers, before use of a SIMD instruction.
-
 #### Performance
 
 Some operations are significantly faster when `unsafe` is used.
diff --git a/arrow/Cargo.toml b/arrow/Cargo.toml
index dbc606ad20e3..4f7fda9b8075 100644
--- a/arrow/Cargo.toml
+++ b/arrow/Cargo.toml
@@ -17,62 +17,55 @@
 
 [package]
 name = "arrow"
-version = "20.0.0"
+version = { workspace = true }
 description = "Rust implementation of Apache Arrow"
-homepage = "https://github.com/apache/arrow-rs"
-repository = "https://github.com/apache/arrow-rs"
-authors = ["Apache Arrow <dev@arrow.apache.org>"]
-license = "Apache-2.0"
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+license = { workspace = true }
 keywords = ["arrow"]
 include = [
     "benches/*.rs",
     "src/**/*.rs",
+    "tests/*.rs",
     "Cargo.toml",
 ]
-edition = "2021"
-rust-version = "1.62"
+edition = { workspace = true }
+rust-version = "1.70.0"
 
 [lib]
 name = "arrow"
 path = "src/lib.rs"
 bench = false
 
-[target.'cfg(target_arch = "wasm32")'.dependencies]
-ahash = { version = "0.8", default-features = false, features=["compile-time-rng"] }
-
-[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
-ahash = { version = "0.8", default-features = false, features=["runtime-rng"] }
-
 [dependencies]
-serde = { version = "1.0", default-features = false }
-serde_derive = { version = "1.0", default-features = false }
-serde_json = { version = "1.0", default-features = false, features = ["std"] }
-indexmap = { version = "1.9", default-features = false, features = ["std"] }
+arrow-arith = { workspace = true }
+arrow-array = { workspace = true }
+arrow-buffer = { workspace = true }
+arrow-cast = { workspace = true }
+arrow-csv = { workspace = true, optional = true }
+arrow-data = { workspace = true }
+arrow-ipc = { workspace = true, optional = true }
+arrow-json = { workspace = true, optional = true }
+arrow-ord = { workspace = true }
+arrow-row = { workspace = true }
+arrow-schema = { workspace = true }
+arrow-select = { workspace = true }
+arrow-string = { workspace = true }
+
 rand = { version = "0.8", default-features = false, features = ["std", "std_rng"], optional = true }
-num = { version = "0.4", default-features = false, features = ["std"] }
-half = { version = "2.0", default-features = false }
-hashbrown = { version = "0.12", default-features = false }
-csv_crate = { version = "1.1", default-features = false, optional = true, package = "csv" }
-regex = { version = "1.5.6", default-features = false, features = ["std", "unicode"] }
-regex-syntax = { version = "0.6.27", default-features = false, features = ["unicode"] }
-lazy_static = { version = "1.4", default-features = false }
-packed_simd = { version = "0.3", default-features = false, optional = true, package = "packed_simd_2" }
-chrono = { version = "0.4", default-features = false, features = ["clock"] }
-chrono-tz = { version = "0.6", default-features = false, optional = true }
-flatbuffers = { version = "2.1.2", default-features = false, features = ["thiserror"], optional = true }
-hex = { version = "0.4", default-features = false, features = ["std"] }
-comfy-table = { version = "6.0", optional = true, default-features = false }
-pyo3 = { version = "0.16", default-features = false, optional = true }
-lexical-core = { version = "^0.8", default-features = false, features = ["write-integers", "write-floats", "parse-integers", "parse-floats"] }
-multiversion = { version = "0.6.1", default-features = false }
-bitflags = { version = "1.2.1", default-features = false }
+pyo3 = { version = "0.20", default-features = false, optional = true }
+
+[package.metadata.docs.rs]
+features = ["prettyprint", "ipc_compression", "ffi", "pyarrow"]
 
 [features]
-default = ["csv", "ipc"]
-csv = ["csv_crate"]
-ipc = ["flatbuffers"]
-simd = ["packed_simd"]
-prettyprint = ["comfy-table"]
+default = ["csv", "ipc", "json"]
+ipc_compression = ["ipc", "arrow-ipc/lz4", "arrow-ipc/zstd"]
+csv = ["arrow-csv"]
+ipc = ["arrow-ipc"]
+json = ["arrow-json"]
+prettyprint = ["arrow-cast/prettyprint"]
 # The test utils feature enables code used in benchmarks and tests but
 # not the core arrow code itself. Be aware that `rand` must be kept as
 # an optional dependency for supporting compile to wasm32-unknown-unknown
@@ -82,22 +75,35 @@ pyarrow = ["pyo3", "ffi"]
 # force_validate runs full data validation for all arrays that are created
 # this is not enabled by default as it is too computationally expensive
 # but is run as part of our CI checks
-force_validate = []
+force_validate = ["arrow-data/force_validate"]
 # Enable ffi support
-ffi = []
+ffi = ["arrow-schema/ffi", "arrow-data/ffi"]
+chrono-tz = ["arrow-array/chrono-tz"]
 
 [dev-dependencies]
+chrono = { workspace = true }
+criterion = { version = "0.5", default-features = false }
+half = { version = "2.1", default-features = false }
 rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
-criterion = { version = "0.3", default-features = false }
-flate2 = { version = "1", default-features = false, features = ["rust_backend"] }
 tempfile = { version = "3", default-features = false }
+serde = { version = "1.0", default-features = false, features = ["derive"] }
 
 [build-dependencies]
 
 [[example]]
 name = "dynamic_types"
 required-features = ["prettyprint"]
-path="./examples/dynamic_types.rs"
+path = "./examples/dynamic_types.rs"
+
+[[example]]
+name = "read_csv"
+required-features = ["prettyprint", "csv"]
+path = "./examples/read_csv.rs"
+
+[[example]]
+name = "read_csv_infer_schema"
+required-features = ["prettyprint", "csv"]
+path = "./examples/read_csv_infer_schema.rs"
 
 [[bench]]
 name = "aggregate_kernels"
@@ -151,6 +157,11 @@ name = "take_kernels"
 harness = false
 required-features = ["test_utils"]
 
+[[bench]]
+name = "interleave_kernels"
+harness = false
+required-features = ["test_utils"]
+
 [[bench]]
 name = "length_kernel"
 harness = false
@@ -172,10 +183,22 @@ required-features = ["test_utils"]
 [[bench]]
 name = "csv_writer"
 harness = false
+required-features = ["csv"]
+
+[[bench]]
+name = "csv_reader"
+harness = false
+required-features = ["test_utils", "csv"]
 
 [[bench]]
 name = "json_reader"
 harness = false
+required-features = ["test_utils", "json"]
+
+[[bench]]
+name = "json_writer"
+harness = false
+required-features = ["test_utils", "json"]
 
 [[bench]]
 name = "equal"
@@ -201,11 +224,39 @@ name = "buffer_create"
 harness = false
 required-features = ["test_utils"]
 
+[[bench]]
+name = "string_dictionary_builder"
+harness = false
+
+[[bench]]
+name = "string_run_builder"
+harness = false
+required-features = ["test_utils"]
+
+[[bench]]
+name = "string_run_iterator"
+harness = false
+
+[[bench]]
+name = "primitive_run_accessor"
+harness = false
+required-features = ["test_utils"]
+
+[[bench]]
+name = "primitive_run_take"
+harness = false
+required-features = ["test_utils"]
+
 [[bench]]
 name = "substring_kernels"
 harness = false
 required-features = ["test_utils"]
 
+[[bench]]
+name = "regexp_kernels"
+harness = false
+required-features = ["test_utils"]
+
 [[bench]]
 name = "array_data_validate"
 harness = false
@@ -213,3 +264,38 @@ harness = false
 [[bench]]
 name = "decimal_validate"
 harness = false
+
+[[bench]]
+name = "row_format"
+harness = false
+required-features = ["test_utils"]
+
+[[bench]]
+name = "bitwise_kernel"
+harness = false
+required-features = ["test_utils"]
+
+[[bench]]
+name = "lexsort"
+harness = false
+required-features = ["test_utils"]
+
+[[test]]
+name = "csv"
+required-features = ["csv", "chrono-tz"]
+
+[[test]]
+name = "pyarrow"
+required-features = ["pyarrow"]
+
+[[test]]
+name = "array_cast"
+required-features = ["chrono-tz", "prettyprint"]
+
+[[test]]
+name = "timezone"
+required-features = ["chrono-tz"]
+
+[[test]]
+name = "arithmetic"
+required-features = ["chrono-tz"]
diff --git a/arrow/README.md b/arrow/README.md
index f7ccb9696455..bc95b91a9a4a 100644
--- a/arrow/README.md
+++ b/arrow/README.md
@@ -24,9 +24,11 @@
 
 This crate contains the official Native Rust implementation of [Apache Arrow][arrow] in memory format, governed by the Apache Software Foundation.
 
-The [crate documentation](https://docs.rs/arrow/latest/arrow/) contains examples and full API.
+The [API documentation](https://docs.rs/arrow/latest) contains examples and full API.
 There are several [examples](https://github.com/apache/arrow-rs/tree/master/arrow/examples) to start from as well.
 
+The API documentation for most recent, unreleased code is available [here](https://arrow.apache.org/rust/arrow/index.html).
+
 ## Rust Version Compatibility
 
 This crate is tested with the latest stable version of Rust. We do not currently test against other, older versions.
@@ -35,19 +37,18 @@ This crate is tested with the latest stable version of Rust. We do not currently
 
 The arrow crate follows the [SemVer standard](https://doc.rust-lang.org/cargo/reference/semver.html) defined by Cargo and works well within the Rust crate ecosystem.
 
-However, for historical reasons, this crate uses versions with major numbers greater than `0.x` (e.g. `20.0.0`), unlike many other crates in the Rust ecosystem which spend extended time releasing versions `0.x` to signal planned ongoing API changes. Minor arrow releases contain only compatible changes, while major releases may contain breaking API changes.
+However, for historical reasons, this crate uses versions with major numbers greater than `0.x` (e.g. `39.0.0`), unlike many other crates in the Rust ecosystem which spend extended time releasing versions `0.x` to signal planned ongoing API changes. Minor arrow releases contain only compatible changes, while major releases may contain breaking API changes.
 
 ## Feature Flags
 
 The `arrow` crate provides the following features which may be enabled in your `Cargo.toml`:
 
 - `csv` (default) - support for reading and writing Arrow arrays to/from csv files
-- `ipc` (default) - support for the [arrow-flight](https://crates.io/crates/arrow-flight) IPC and wire format
+- `json` (default) - support for reading and writing Arrow array to/from json files
+- `ipc` (default) - support for reading [Arrow IPC Format](https://arrow.apache.org/docs/format/Columnar.html#serialization-and-interprocess-communication-ipc), also used as the wire protocol in [arrow-flight](https://crates.io/crates/arrow-flight)
+- `ipc_compression` - Enables reading and writing compressed IPC streams (also enables `ipc`)
 - `prettyprint` - support for formatting record batches as textual columns
-- `js` - support for building arrow for WebAssembly / JavaScript
-- `simd` - (_Requires Nightly Rust_) Use alternate hand optimized
   implementations of some [compute](https://github.com/apache/arrow-rs/tree/master/arrow/src/compute/kernels)
-  kernels using explicit SIMD instructions via [packed_simd_2](https://docs.rs/packed_simd_2/latest/packed_simd_2/).
 - `chrono-tz` - support of parsing timezone using [chrono-tz](https://docs.rs/chrono-tz/0.6.0/chrono_tz/)
 - `ffi` - bindings for the Arrow C [C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html)
 - `pyarrow` - bindings for pyo3 to call arrow-rs from python
@@ -72,7 +73,6 @@ In particular there are a number of scenarios where `unsafe` is largely unavoida
 
 - Invariants that cannot be statically verified by the compiler and unlock non-trivial performance wins, e.g. values in a StringArray are UTF-8, [TrustedLen](https://doc.rust-lang.org/std/iter/trait.TrustedLen.html) iterators, etc...
 - FFI
-- SIMD
 
 Additionally, this crate exposes a number of `unsafe` APIs, allowing downstream crates to explicitly opt-out of potentially expensive invariant checking where appropriate.
 
@@ -92,7 +92,7 @@ In order to compile Arrow for `wasm32-unknown-unknown` you will need to disable
 
 ```toml
 [dependencies]
-arrow = { version = "5.0", default-features = false, features = ["csv", "ipc", "simd"] }
+arrow = { version = "5.0", default-features = false, features = ["csv", "ipc"] }
 ```
 
 ## Examples
diff --git a/arrow/benches/aggregate_kernels.rs b/arrow/benches/aggregate_kernels.rs
index c7b09f70f70e..1e7b9f894f2a 100644
--- a/arrow/benches/aggregate_kernels.rs
+++ b/arrow/benches/aggregate_kernels.rs
@@ -17,50 +17,55 @@
 
 #[macro_use]
 extern crate criterion;
-use criterion::Criterion;
+use criterion::{Criterion, Throughput};
+use rand::distributions::{Distribution, Standard};
 
 extern crate arrow;
 
 use arrow::compute::kernels::aggregate::*;
 use arrow::util::bench_util::*;
 use arrow::{array::*, datatypes::Float32Type};
+use arrow_array::types::{Float64Type, Int16Type, Int32Type, Int64Type, Int8Type};
 
-fn bench_sum(arr_a: &Float32Array) {
-    criterion::black_box(sum(arr_a).unwrap());
-}
-
-fn bench_min(arr_a: &Float32Array) {
-    criterion::black_box(min(arr_a).unwrap());
-}
-
-fn bench_max(arr_a: &Float32Array) {
-    criterion::black_box(max(arr_a).unwrap());
-}
+const BATCH_SIZE: usize = 64 * 1024;
 
-fn bench_min_string(arr_a: &StringArray) {
-    criterion::black_box(min_string(arr_a).unwrap());
+fn primitive_benchmark<T: ArrowNumericType>(c: &mut Criterion, name: &str)
+where
+    Standard: Distribution<T::Native>,
+{
+    let nonnull_array = create_primitive_array::<T>(BATCH_SIZE, 0.0);
+    let nullable_array = create_primitive_array::<T>(BATCH_SIZE, 0.5);
+    c.benchmark_group(name)
+        .throughput(Throughput::Bytes(
+            (std::mem::size_of::<T::Native>() * BATCH_SIZE) as u64,
+        ))
+        .bench_function("sum nonnull", |b| b.iter(|| sum(&nonnull_array)))
+        .bench_function("min nonnull", |b| b.iter(|| min(&nonnull_array)))
+        .bench_function("max nonnull", |b| b.iter(|| max(&nonnull_array)))
+        .bench_function("sum nullable", |b| b.iter(|| sum(&nullable_array)))
+        .bench_function("min nullable", |b| b.iter(|| min(&nullable_array)))
+        .bench_function("max nullable", |b| b.iter(|| max(&nullable_array)));
 }
 
 fn add_benchmark(c: &mut Criterion) {
-    let arr_a = create_primitive_array::<Float32Type>(512, 0.0);
-
-    c.bench_function("sum 512", |b| b.iter(|| bench_sum(&arr_a)));
-    c.bench_function("min 512", |b| b.iter(|| bench_min(&arr_a)));
-    c.bench_function("max 512", |b| b.iter(|| bench_max(&arr_a)));
-
-    let arr_a = create_primitive_array::<Float32Type>(512, 0.5);
-
-    c.bench_function("sum nulls 512", |b| b.iter(|| bench_sum(&arr_a)));
-    c.bench_function("min nulls 512", |b| b.iter(|| bench_min(&arr_a)));
-    c.bench_function("max nulls 512", |b| b.iter(|| bench_max(&arr_a)));
+    primitive_benchmark::<Float32Type>(c, "float32");
+    primitive_benchmark::<Float64Type>(c, "float64");
 
-    let arr_b = create_string_array::<i32>(512, 0.0);
-    c.bench_function("min string 512", |b| b.iter(|| bench_min_string(&arr_b)));
+    primitive_benchmark::<Int8Type>(c, "int8");
+    primitive_benchmark::<Int16Type>(c, "int16");
+    primitive_benchmark::<Int32Type>(c, "int32");
+    primitive_benchmark::<Int64Type>(c, "int64");
 
-    let arr_b = create_string_array::<i32>(512, 0.5);
-    c.bench_function("min nulls string 512", |b| {
-        b.iter(|| bench_min_string(&arr_b))
-    });
+    {
+        let nonnull_strings = create_string_array::<i32>(BATCH_SIZE, 0.0);
+        let nullable_strings = create_string_array::<i32>(BATCH_SIZE, 0.5);
+        c.benchmark_group("string")
+            .throughput(Throughput::Elements(BATCH_SIZE as u64))
+            .bench_function("min nonnull", |b| b.iter(|| min_string(&nonnull_strings)))
+            .bench_function("max nonnull", |b| b.iter(|| max_string(&nonnull_strings)))
+            .bench_function("min nullable", |b| b.iter(|| min_string(&nullable_strings)))
+            .bench_function("max nullable", |b| b.iter(|| max_string(&nullable_strings)));
+    }
 }
 
 criterion_group!(benches, add_benchmark);
diff --git a/arrow/benches/arithmetic_kernels.rs b/arrow/benches/arithmetic_kernels.rs
index 4be4a26933aa..e982b0eb4b5f 100644
--- a/arrow/benches/arithmetic_kernels.rs
+++ b/arrow/benches/arithmetic_kernels.rs
@@ -15,112 +15,63 @@
 // specific language governing permissions and limitations
 // under the License.
 
-#[macro_use]
-extern crate criterion;
-use criterion::Criterion;
-use rand::Rng;
-
-use std::sync::Arc;
+use criterion::*;
 
 extern crate arrow;
 
+use arrow::compute::kernels::numeric::*;
+use arrow::datatypes::Float32Type;
 use arrow::util::bench_util::*;
-use arrow::{array::*, datatypes::Float32Type};
-use arrow::{compute::kernels::arithmetic::*, util::test_util::seedable_rng};
-
-fn create_array(size: usize, with_nulls: bool) -> ArrayRef {
-    let null_density = if with_nulls { 0.5 } else { 0.0 };
-    let array = create_primitive_array::<Float32Type>(size, null_density);
-    Arc::new(array)
-}
-
-fn bench_add(arr_a: &ArrayRef, arr_b: &ArrayRef) {
-    let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
-    let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(add(arr_a, arr_b).unwrap());
-}
-
-fn bench_subtract(arr_a: &ArrayRef, arr_b: &ArrayRef) {
-    let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
-    let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(subtract(arr_a, arr_b).unwrap());
-}
-
-fn bench_multiply(arr_a: &ArrayRef, arr_b: &ArrayRef) {
-    let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
-    let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(multiply(arr_a, arr_b).unwrap());
-}
-
-fn bench_divide(arr_a: &ArrayRef, arr_b: &ArrayRef) {
-    let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
-    let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(divide(arr_a, arr_b).unwrap());
-}
-
-fn bench_divide_unchecked(arr_a: &ArrayRef, arr_b: &ArrayRef) {
-    let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
-    let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(divide_unchecked(arr_a, arr_b).unwrap());
-}
-
-fn bench_divide_scalar(array: &ArrayRef, divisor: f32) {
-    let array = array.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(divide_scalar(array, divisor).unwrap());
-}
-
-fn bench_modulo(arr_a: &ArrayRef, arr_b: &ArrayRef) {
-    let arr_a = arr_a.as_any().downcast_ref::<Float32Array>().unwrap();
-    let arr_b = arr_b.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(modulus(arr_a, arr_b).unwrap());
-}
-
-fn bench_modulo_scalar(array: &ArrayRef, divisor: f32) {
-    let array = array.as_any().downcast_ref::<Float32Array>().unwrap();
-    criterion::black_box(modulus_scalar(array, divisor).unwrap());
-}
+use arrow_array::Scalar;
 
 fn add_benchmark(c: &mut Criterion) {
     const BATCH_SIZE: usize = 64 * 1024;
-    let arr_a = create_array(BATCH_SIZE, false);
-    let arr_b = create_array(BATCH_SIZE, false);
-    let scalar = seedable_rng().gen();
-
-    c.bench_function("add", |b| b.iter(|| bench_add(&arr_a, &arr_b)));
-    c.bench_function("subtract", |b| b.iter(|| bench_subtract(&arr_a, &arr_b)));
-    c.bench_function("multiply", |b| b.iter(|| bench_multiply(&arr_a, &arr_b)));
-    c.bench_function("divide", |b| b.iter(|| bench_divide(&arr_a, &arr_b)));
-    c.bench_function("divide_unchecked", |b| {
-        b.iter(|| bench_divide_unchecked(&arr_a, &arr_b))
-    });
-    c.bench_function("divide_scalar", |b| {
-        b.iter(|| bench_divide_scalar(&arr_a, scalar))
-    });
-    c.bench_function("modulo", |b| b.iter(|| bench_modulo(&arr_a, &arr_b)));
-    c.bench_function("modulo_scalar", |b| {
-        b.iter(|| bench_modulo_scalar(&arr_a, scalar))
-    });
-
-    let arr_a_nulls = create_array(BATCH_SIZE, true);
-    let arr_b_nulls = create_array(BATCH_SIZE, true);
-    c.bench_function("add_nulls", |b| {
-        b.iter(|| bench_add(&arr_a_nulls, &arr_b_nulls))
-    });
-    c.bench_function("divide_nulls", |b| {
-        b.iter(|| bench_divide(&arr_a_nulls, &arr_b_nulls))
-    });
-    c.bench_function("divide_nulls_unchecked", |b| {
-        b.iter(|| bench_divide_unchecked(&arr_a_nulls, &arr_b_nulls))
-    });
-    c.bench_function("divide_scalar_nulls", |b| {
-        b.iter(|| bench_divide_scalar(&arr_a_nulls, scalar))
-    });
-    c.bench_function("modulo_nulls", |b| {
-        b.iter(|| bench_modulo(&arr_a_nulls, &arr_b_nulls))
-    });
-    c.bench_function("modulo_scalar_nulls", |b| {
-        b.iter(|| bench_modulo_scalar(&arr_a_nulls, scalar))
-    });
+    for null_density in [0., 0.1, 0.5, 0.9, 1.0] {
+        let arr_a = create_primitive_array::<Float32Type>(BATCH_SIZE, null_density);
+        let arr_b = create_primitive_array::<Float32Type>(BATCH_SIZE, null_density);
+        let scalar_a = create_primitive_array::<Float32Type>(1, 0.);
+        let scalar = Scalar::new(&scalar_a);
+
+        c.bench_function(&format!("add({null_density})"), |b| {
+            b.iter(|| criterion::black_box(add_wrapping(&arr_a, &arr_b).unwrap()))
+        });
+        c.bench_function(&format!("add_checked({null_density})"), |b| {
+            b.iter(|| criterion::black_box(add(&arr_a, &arr_b).unwrap()))
+        });
+        c.bench_function(&format!("add_scalar({null_density})"), |b| {
+            b.iter(|| criterion::black_box(add_wrapping(&arr_a, &scalar).unwrap()))
+        });
+        c.bench_function(&format!("subtract({null_density})"), |b| {
+            b.iter(|| criterion::black_box(sub_wrapping(&arr_a, &arr_b).unwrap()))
+        });
+        c.bench_function(&format!("subtract_checked({null_density})"), |b| {
+            b.iter(|| criterion::black_box(sub(&arr_a, &arr_b).unwrap()))
+        });
+        c.bench_function(&format!("subtract_scalar({null_density})"), |b| {
+            b.iter(|| criterion::black_box(sub_wrapping(&arr_a, &scalar).unwrap()))
+        });
+        c.bench_function(&format!("multiply({null_density})"), |b| {
+            b.iter(|| criterion::black_box(mul_wrapping(&arr_a, &arr_b).unwrap()))
+        });
+        c.bench_function(&format!("multiply_checked({null_density})"), |b| {
+            b.iter(|| criterion::black_box(mul(&arr_a, &arr_b).unwrap()))
+        });
+        c.bench_function(&format!("multiply_scalar({null_density})"), |b| {
+            b.iter(|| criterion::black_box(mul_wrapping(&arr_a, &scalar).unwrap()))
+        });
+        c.bench_function(&format!("divide({null_density})"), |b| {
+            b.iter(|| criterion::black_box(div(&arr_a, &arr_b).unwrap()))
+        });
+        c.bench_function(&format!("divide_scalar({null_density})"), |b| {
+            b.iter(|| criterion::black_box(div(&arr_a, &scalar).unwrap()))
+        });
+        c.bench_function(&format!("modulo({null_density})"), |b| {
+            b.iter(|| criterion::black_box(rem(&arr_a, &arr_b).unwrap()))
+        });
+        c.bench_function(&format!("modulo_scalar({null_density})"), |b| {
+            b.iter(|| criterion::black_box(rem(&arr_a, &scalar).unwrap()))
+        });
+    }
 }
 
 criterion_group!(benches, add_benchmark);
diff --git a/arrow/benches/array_data_validate.rs b/arrow/benches/array_data_validate.rs
index 3cd13c09c58a..531462f2d8b5 100644
--- a/arrow/benches/array_data_validate.rs
+++ b/arrow/benches/array_data_validate.rs
@@ -37,8 +37,8 @@ fn create_binary_array_data(length: i32) -> ArrayData {
     .unwrap()
 }
 
-fn validate_utf8_array(arr: &StringArray) {
-    arr.data().validate_values().unwrap();
+fn validate_utf8_array(arr: &ArrayData) {
+    arr.validate_values().unwrap();
 }
 
 fn validate_benchmark(c: &mut Criterion) {
@@ -48,10 +48,15 @@ fn validate_benchmark(c: &mut Criterion) {
     });
 
     //Utf8 Array
-    let str_arr = StringArray::from(vec!["test"; 20000]);
+    let str_arr = StringArray::from(vec!["test"; 20000]).to_data();
     c.bench_function("validate_utf8_array_data 20000", |b| {
         b.iter(|| validate_utf8_array(&str_arr))
     });
+
+    let byte_array = BinaryArray::from_iter_values(std::iter::repeat(b"test").take(20000));
+    c.bench_function("byte_array_to_string_array 20000", |b| {
+        b.iter(|| StringArray::from(BinaryArray::from(byte_array.to_data())))
+    });
 }
 
 criterion_group!(benches, validate_benchmark);
diff --git a/arrow/benches/array_from_vec.rs b/arrow/benches/array_from_vec.rs
index 3f82beb6f534..5fce3f113e43 100644
--- a/arrow/benches/array_from_vec.rs
+++ b/arrow/benches/array_from_vec.rs
@@ -17,11 +17,14 @@
 
 #[macro_use]
 extern crate criterion;
+
 use criterion::Criterion;
 
 extern crate arrow;
 
 use arrow::array::*;
+use arrow_buffer::i256;
+use rand::Rng;
 use std::{convert::TryFrom, sync::Arc};
 
 fn array_from_vec(n: usize) {
@@ -67,11 +70,60 @@ fn struct_array_from_vec(
     let strings: ArrayRef = Arc::new(StringArray::from(strings.to_owned()));
     let ints: ArrayRef = Arc::new(Int32Array::from(ints.to_owned()));
 
+    criterion::black_box(StructArray::try_from(vec![(field1, strings), (field2, ints)]).unwrap());
+}
+
+fn decimal128_array_from_vec(array: &[Option<i128>]) {
+    criterion::black_box(
+        array
+            .iter()
+            .copied()
+            .collect::<Decimal128Array>()
+            .with_precision_and_scale(34, 2)
+            .unwrap(),
+    );
+}
+
+fn decimal256_array_from_vec(array: &[Option<i256>]) {
     criterion::black_box(
-        StructArray::try_from(vec![(field1, strings), (field2, ints)]).unwrap(),
+        array
+            .iter()
+            .copied()
+            .collect::<Decimal256Array>()
+            .with_precision_and_scale(70, 2)
+            .unwrap(),
     );
 }
 
+fn decimal_benchmark(c: &mut Criterion) {
+    // bench decimal128 array
+    // create option<i128> array
+    let size: usize = 1 << 15;
+    let mut rng = rand::thread_rng();
+    let mut array = vec![];
+    for _ in 0..size {
+        array.push(Some(rng.gen_range::<i128, _>(0..9999999999)));
+    }
+    c.bench_function("decimal128_array_from_vec 32768", |b| {
+        b.iter(|| decimal128_array_from_vec(array.as_slice()))
+    });
+
+    // bench decimal256array
+    // create option<into<decimal256>> array
+    let size = 1 << 10;
+    let mut array = vec![];
+    let mut rng = rand::thread_rng();
+    for _ in 0..size {
+        let decimal = i256::from_i128(rng.gen_range::<i128, _>(0..9999999999999));
+        array.push(Some(decimal));
+    }
+
+    // bench decimal256 array
+    c.bench_function("decimal256_array_from_vec 32768", |b| {
+        b.iter(|| decimal256_array_from_vec(array.as_slice()))
+    });
+}
+
 fn criterion_benchmark(c: &mut Criterion) {
     c.bench_function("array_from_vec 128", |b| b.iter(|| array_from_vec(128)));
     c.bench_function("array_from_vec 256", |b| b.iter(|| array_from_vec(256)));
@@ -108,5 +160,5 @@ fn criterion_benchmark(c: &mut Criterion) {
     });
 }
 
-criterion_group!(benches, criterion_benchmark);
+criterion_group!(benches, criterion_benchmark, decimal_benchmark);
 criterion_main!(benches);
diff --git a/arrow/benches/bitwise_kernel.rs b/arrow/benches/bitwise_kernel.rs
new file mode 100644
index 000000000000..8604ea97eb3c
--- /dev/null
+++ b/arrow/benches/bitwise_kernel.rs
@@ -0,0 +1,117 @@
+// 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.
+
+#[macro_use]
+extern crate criterion;
+
+use arrow::compute::kernels::bitwise::{
+    bitwise_and, bitwise_and_scalar, bitwise_not, bitwise_or, bitwise_or_scalar, bitwise_xor,
+    bitwise_xor_scalar,
+};
+use arrow::datatypes::Int64Type;
+use criterion::{black_box, Criterion};
+use rand::RngCore;
+
+extern crate arrow;
+
+use arrow::util::bench_util::create_primitive_array;
+use arrow::util::test_util::seedable_rng;
+
+fn bitwise_array_benchmark(c: &mut Criterion) {
+    let size = 64 * 1024_usize;
+    let left_without_null = create_primitive_array::<Int64Type>(size, 0 as f32);
+    let right_without_null = create_primitive_array::<Int64Type>(size, 0 as f32);
+    let left_with_null = create_primitive_array::<Int64Type>(size, 0.2_f32);
+    let right_with_null = create_primitive_array::<Int64Type>(size, 0.2_f32);
+    // array and
+    let mut group = c.benchmark_group("bench bitwise array: and");
+    group.bench_function("bitwise array and, no nulls", |b| {
+        b.iter(|| black_box(bitwise_and(&left_without_null, &right_without_null).unwrap()))
+    });
+    group.bench_function("bitwise array and, 20% nulls", |b| {
+        b.iter(|| black_box(bitwise_and(&left_with_null, &right_with_null).unwrap()))
+    });
+    group.finish();
+    // array or
+    let mut group = c.benchmark_group("bench bitwise: or");
+    group.bench_function("bitwise array or, no nulls", |b| {
+        b.iter(|| black_box(bitwise_or(&left_without_null, &right_without_null).unwrap()))
+    });
+    group.bench_function("bitwise array or, 20% nulls", |b| {
+        b.iter(|| black_box(bitwise_or(&left_with_null, &right_with_null).unwrap()))
+    });
+    group.finish();
+    // xor
+    let mut group = c.benchmark_group("bench bitwise: xor");
+    group.bench_function("bitwise array xor, no nulls", |b| {
+        b.iter(|| black_box(bitwise_xor(&left_without_null, &right_without_null).unwrap()))
+    });
+    group.bench_function("bitwise array xor, 20% nulls", |b| {
+        b.iter(|| black_box(bitwise_xor(&left_with_null, &right_with_null).unwrap()))
+    });
+    group.finish();
+    // not
+    let mut group = c.benchmark_group("bench bitwise: not");
+    group.bench_function("bitwise array not, no nulls", |b| {
+        b.iter(|| black_box(bitwise_not(&left_without_null).unwrap()))
+    });
+    group.bench_function("bitwise array not, 20% nulls", |b| {
+        b.iter(|| black_box(bitwise_not(&left_with_null).unwrap()))
+    });
+    group.finish();
+}
+
+fn bitwise_array_scalar_benchmark(c: &mut Criterion) {
+    let size = 64 * 1024_usize;
+    let array_without_null = create_primitive_array::<Int64Type>(size, 0 as f32);
+    let array_with_null = create_primitive_array::<Int64Type>(size, 0.2_f32);
+    let scalar = seedable_rng().next_u64() as i64;
+    // array scalar and
+    let mut group = c.benchmark_group("bench bitwise array scalar: and");
+    group.bench_function("bitwise array scalar and, no nulls", |b| {
+        b.iter(|| black_box(bitwise_and_scalar(&array_without_null, scalar).unwrap()))
+    });
+    group.bench_function("bitwise array and, 20% nulls", |b| {
+        b.iter(|| black_box(bitwise_and_scalar(&array_with_null, scalar).unwrap()))
+    });
+    group.finish();
+    // array scalar or
+    let mut group = c.benchmark_group("bench bitwise array scalar: or");
+    group.bench_function("bitwise array scalar or, no nulls", |b| {
+        b.iter(|| black_box(bitwise_or_scalar(&array_without_null, scalar).unwrap()))
+    });
+    group.bench_function("bitwise array scalar or, 20% nulls", |b| {
+        b.iter(|| black_box(bitwise_or_scalar(&array_with_null, scalar).unwrap()))
+    });
+    group.finish();
+    // array scalar xor
+    let mut group = c.benchmark_group("bench bitwise array scalar: xor");
+    group.bench_function("bitwise array scalar xor, no nulls", |b| {
+        b.iter(|| black_box(bitwise_xor_scalar(&array_without_null, scalar).unwrap()))
+    });
+    group.bench_function("bitwise array scalar xor, 20% nulls", |b| {
+        b.iter(|| black_box(bitwise_xor_scalar(&array_with_null, scalar).unwrap()))
+    });
+    group.finish();
+}
+
+criterion_group!(
+    benches,
+    bitwise_array_benchmark,
+    bitwise_array_scalar_benchmark
+);
+criterion_main!(benches);
diff --git a/arrow/benches/boolean_append_packed.rs b/arrow/benches/boolean_append_packed.rs
index 62bcbcc352fd..40873422dbd5 100644
--- a/arrow/benches/boolean_append_packed.rs
+++ b/arrow/benches/boolean_append_packed.rs
@@ -30,7 +30,6 @@ fn boolean_append_packed(c: &mut Criterion) {
     let mut rng = thread_rng();
     let source = rand_bytes(1024);
     let ranges: Vec<_> = (0..100)
-        .into_iter()
         .map(|_| {
             let start: usize = rng.gen_range(0..1024 * 8);
             let end: usize = rng.gen_range(start..1024 * 8);
diff --git a/arrow/benches/buffer_bit_ops.rs b/arrow/benches/buffer_bit_ops.rs
index 6c6bb0463b28..ab122ac94165 100644
--- a/arrow/benches/buffer_bit_ops.rs
+++ b/arrow/benches/buffer_bit_ops.rs
@@ -22,9 +22,7 @@ use criterion::{Criterion, Throughput};
 
 extern crate arrow;
 
-use arrow::buffer::{
-    buffer_bin_and, buffer_bin_or, buffer_unary_not, Buffer, MutableBuffer,
-};
+use arrow::buffer::{buffer_bin_and, buffer_bin_or, buffer_unary_not, Buffer, MutableBuffer};
 
 ///  Helper function to create arrays
 fn create_buffer(size: usize) -> Buffer {
@@ -38,15 +36,15 @@ fn create_buffer(size: usize) -> Buffer {
 }
 
 fn bench_buffer_and(left: &Buffer, right: &Buffer) {
-    criterion::black_box((left & right).unwrap());
+    criterion::black_box(buffer_bin_and(left, 0, right, 0, left.len() * 8));
 }
 
 fn bench_buffer_or(left: &Buffer, right: &Buffer) {
-    criterion::black_box((left | right).unwrap());
+    criterion::black_box(buffer_bin_or(left, 0, right, 0, left.len() * 8));
 }
 
 fn bench_buffer_not(buffer: &Buffer) {
-    criterion::black_box(!buffer);
+    criterion::black_box(buffer_unary_not(buffer, 0, buffer.len() * 8));
 }
 
 fn bench_buffer_and_with_offsets(
@@ -82,14 +80,10 @@ fn bit_ops_benchmark(c: &mut Criterion) {
         .bench_function("and", |b| b.iter(|| bench_buffer_and(&left, &right)))
         .bench_function("or", |b| b.iter(|| bench_buffer_or(&left, &right)))
         .bench_function("and_with_offset", |b| {
-            b.iter(|| {
-                bench_buffer_and_with_offsets(&left, 1, &right, 2, left.len() * 8 - 5)
-            })
+            b.iter(|| bench_buffer_and_with_offsets(&left, 1, &right, 2, left.len() * 8 - 5))
         })
         .bench_function("or_with_offset", |b| {
-            b.iter(|| {
-                bench_buffer_or_with_offsets(&left, 1, &right, 2, left.len() * 8 - 5)
-            })
+            b.iter(|| bench_buffer_or_with_offsets(&left, 1, &right, 2, left.len() * 8 - 5))
         });
 
     c.benchmark_group("buffer_unary_ops")
diff --git a/arrow/benches/buffer_create.rs b/arrow/benches/buffer_create.rs
index d628e031ce6f..e7d24c2166d7 100644
--- a/arrow/benches/buffer_create.rs
+++ b/arrow/benches/buffer_create.rs
@@ -49,8 +49,8 @@ fn mutable_buffer_iter_bitset(data: &[Vec<bool>]) -> Vec<Buffer> {
     criterion::black_box({
         data.iter()
             .map(|datum| {
-                let mut result = MutableBuffer::new((data.len() + 7) / 8)
-                    .with_bitset(datum.len(), false);
+                let mut result =
+                    MutableBuffer::new((data.len() + 7) / 8).with_bitset(datum.len(), false);
                 for (i, value) in datum.iter().enumerate() {
                     if *value {
                         unsafe {
@@ -148,10 +148,7 @@ fn benchmark(c: &mut Criterion) {
 
     c.bench_function("mutable iter extend_from_slice", |b| {
         b.iter(|| {
-            mutable_iter_extend_from_slice(
-                criterion::black_box(&data),
-                criterion::black_box(0),
-            )
+            mutable_iter_extend_from_slice(criterion::black_box(&data), criterion::black_box(0))
         })
     });
     c.bench_function("mutable", |b| {
@@ -163,9 +160,7 @@ fn benchmark(c: &mut Criterion) {
     });
 
     c.bench_function("mutable prepared", |b| {
-        b.iter(|| {
-            mutable_buffer(criterion::black_box(&data), criterion::black_box(byte_cap))
-        })
+        b.iter(|| mutable_buffer(criterion::black_box(&data), criterion::black_box(byte_cap)))
     });
 
     c.bench_function("from_slice", |b| {
diff --git a/arrow/benches/builder.rs b/arrow/benches/builder.rs
index f6f90f475f7c..87a02e7ad1fd 100644
--- a/arrow/benches/builder.rs
+++ b/arrow/benches/builder.rs
@@ -26,6 +26,7 @@ use rand::distributions::Standard;
 
 use arrow::array::*;
 use arrow::util::test_util::seedable_rng;
+use arrow_buffer::i256;
 use rand::Rng;
 
 // Build arrays with 512k elements.
@@ -41,7 +42,7 @@ fn bench_primitive(c: &mut Criterion) {
     ));
     group.bench_function("bench_primitive", |b| {
         b.iter(|| {
-            let mut builder = Int64Builder::new(64);
+            let mut builder = Int64Builder::with_capacity(64);
             for _ in 0..NUM_BATCHES {
                 builder.append_slice(&data[..]);
             }
@@ -55,7 +56,7 @@ fn bench_primitive_nulls(c: &mut Criterion) {
     let mut group = c.benchmark_group("bench_primitive_nulls");
     group.bench_function("bench_primitive_nulls", |b| {
         b.iter(|| {
-            let mut builder = UInt8Builder::new(64);
+            let mut builder = UInt8Builder::with_capacity(64);
             for _ in 0..NUM_BATCHES * BATCH_SIZE {
                 builder.append_null();
             }
@@ -78,7 +79,7 @@ fn bench_bool(c: &mut Criterion) {
     ));
     group.bench_function("bench_bool", |b| {
         b.iter(|| {
-            let mut builder = BooleanBuilder::new(64);
+            let mut builder = BooleanBuilder::with_capacity(64);
             for _ in 0..NUM_BATCHES {
                 builder.append_slice(&data[..]);
             }
@@ -96,7 +97,7 @@ fn bench_string(c: &mut Criterion) {
     ));
     group.bench_function("bench_string", |b| {
         b.iter(|| {
-            let mut builder = StringBuilder::new(64);
+            let mut builder = StringBuilder::new();
             for _ in 0..NUM_BATCHES * BATCH_SIZE {
                 builder.append_value(SAMPLE_STRING);
             }
@@ -106,11 +107,50 @@ fn bench_string(c: &mut Criterion) {
     group.finish();
 }
 
+fn bench_decimal128(c: &mut Criterion) {
+    c.bench_function("bench_decimal128_builder", |b| {
+        b.iter(|| {
+            let mut rng = rand::thread_rng();
+            let mut decimal_builder = Decimal128Builder::with_capacity(BATCH_SIZE);
+            for _ in 0..BATCH_SIZE {
+                decimal_builder.append_value(rng.gen_range::<i128, _>(0..9999999999));
+            }
+            black_box(
+                decimal_builder
+                    .finish()
+                    .with_precision_and_scale(38, 0)
+                    .unwrap(),
+            );
+        })
+    });
+}
+
+fn bench_decimal256(c: &mut Criterion) {
+    c.bench_function("bench_decimal128_builder", |b| {
+        b.iter(|| {
+            let mut rng = rand::thread_rng();
+            let mut decimal_builder = Decimal256Builder::with_capacity(BATCH_SIZE);
+            for _ in 0..BATCH_SIZE {
+                decimal_builder
+                    .append_value(i256::from_i128(rng.gen_range::<i128, _>(0..99999999999)));
+            }
+            black_box(
+                decimal_builder
+                    .finish()
+                    .with_precision_and_scale(76, 10)
+                    .unwrap(),
+            );
+        })
+    });
+}
+
 criterion_group!(
     benches,
     bench_primitive,
     bench_primitive_nulls,
     bench_bool,
-    bench_string
+    bench_string,
+    bench_decimal128,
+    bench_decimal256,
 );
 criterion_main!(benches);
diff --git a/arrow/benches/cast_kernels.rs b/arrow/benches/cast_kernels.rs
index d6cba8b3cdfa..6632dbc57c56 100644
--- a/arrow/benches/cast_kernels.rs
+++ b/arrow/benches/cast_kernels.rs
@@ -30,6 +30,7 @@ use arrow::compute::cast;
 use arrow::datatypes::*;
 use arrow::util::bench_util::*;
 use arrow::util::test_util::seedable_rng;
+use arrow_buffer::i256;
 
 fn build_array<T: ArrowPrimitiveType>(size: usize) -> ArrayRef
 where
@@ -44,14 +45,15 @@ fn build_utf8_date_array(size: usize, with_nulls: bool) -> ArrayRef {
 
     // use random numbers to avoid spurious compiler optimizations wrt to branching
     let mut rng = seedable_rng();
-    let mut builder = StringBuilder::new(size);
+    let mut builder = StringBuilder::new();
     let range = Uniform::new(0, 737776);
 
     for _ in 0..size {
         if with_nulls && rng.gen::<f32>() > 0.8 {
             builder.append_null();
         } else {
-            let string = NaiveDate::from_num_days_from_ce(rng.sample(range))
+            let string = NaiveDate::from_num_days_from_ce_opt(rng.sample(range))
+                .unwrap()
                 .format("%Y-%m-%d")
                 .to_string();
             builder.append_value(&string);
@@ -65,14 +67,15 @@ fn build_utf8_date_time_array(size: usize, with_nulls: bool) -> ArrayRef {
 
     // use random numbers to avoid spurious compiler optimizations wrt to branching
     let mut rng = seedable_rng();
-    let mut builder = StringBuilder::new(size);
+    let mut builder = StringBuilder::new();
     let range = Uniform::new(0, 1608071414123);
 
     for _ in 0..size {
         if with_nulls && rng.gen::<f32>() > 0.8 {
             builder.append_null();
         } else {
-            let string = NaiveDateTime::from_timestamp(rng.sample(range), 0)
+            let string = NaiveDateTime::from_timestamp_opt(rng.sample(range), 0)
+                .unwrap()
                 .format("%Y-%m-%dT%H:%M:%S")
                 .to_string();
             builder.append_value(&string);
@@ -81,6 +84,38 @@ fn build_utf8_date_time_array(size: usize, with_nulls: bool) -> ArrayRef {
     Arc::new(builder.finish())
 }
 
+fn build_decimal128_array(size: usize, precision: u8, scale: i8) -> ArrayRef {
+    let mut rng = seedable_rng();
+    let mut builder = Decimal128Builder::with_capacity(size);
+
+    for _ in 0..size {
+        builder.append_value(rng.gen_range::<i128, _>(0..1000000000));
+    }
+    Arc::new(
+        builder
+            .finish()
+            .with_precision_and_scale(precision, scale)
+            .unwrap(),
+    )
+}
+
+fn build_decimal256_array(size: usize, precision: u8, scale: i8) -> ArrayRef {
+    let mut rng = seedable_rng();
+    let mut builder = Decimal256Builder::with_capacity(size);
+    let mut bytes = [0; 32];
+    for _ in 0..size {
+        let num = rng.gen_range::<i128, _>(0..1000000000);
+        bytes[0..16].clone_from_slice(&num.to_le_bytes());
+        builder.append_value(i256::from_le_bytes(bytes));
+    }
+    Arc::new(
+        builder
+            .finish()
+            .with_precision_and_scale(precision, scale)
+            .unwrap(),
+    )
+}
+
 // cast array from specified primitive array type to desired data type
 fn cast_array(array: &ArrayRef, to_type: DataType) {
     criterion::black_box(cast(array, &to_type).unwrap());
@@ -102,6 +137,9 @@ fn add_benchmark(c: &mut Criterion) {
     let utf8_date_array = build_utf8_date_array(512, true);
     let utf8_date_time_array = build_utf8_date_time_array(512, true);
 
+    let decimal128_array = build_decimal128_array(512, 10, 3);
+    let decimal256_array = build_decimal256_array(512, 50, 3);
+
     c.bench_function("cast int32 to int32 512", |b| {
         b.iter(|| cast_array(&i32_array, DataType::Int32))
     });
@@ -169,7 +207,9 @@ fn add_benchmark(c: &mut Criterion) {
     c.bench_function("cast f32 to string 512", |b| {
         b.iter(|| cast_array(&f32_array, DataType::Utf8))
     });
-
+    c.bench_function("cast f64 to string 512", |b| {
+        b.iter(|| cast_array(&f64_array, DataType::Utf8))
+    });
     c.bench_function("cast timestamp_ms to i64 512", |b| {
         b.iter(|| cast_array(&time_ms_array, DataType::Int64))
     });
@@ -179,6 +219,26 @@ fn add_benchmark(c: &mut Criterion) {
     c.bench_function("cast utf8 to date64 512", |b| {
         b.iter(|| cast_array(&utf8_date_time_array, DataType::Date64))
     });
+
+    c.bench_function("cast decimal128 to decimal128 512", |b| {
+        b.iter(|| cast_array(&decimal128_array, DataType::Decimal128(30, 5)))
+    });
+    c.bench_function("cast decimal128 to decimal256 512", |b| {
+        b.iter(|| cast_array(&decimal128_array, DataType::Decimal256(50, 5)))
+    });
+    c.bench_function("cast decimal256 to decimal128 512", |b| {
+        b.iter(|| cast_array(&decimal256_array, DataType::Decimal128(38, 2)))
+    });
+    c.bench_function("cast decimal256 to decimal256 512", |b| {
+        b.iter(|| cast_array(&decimal256_array, DataType::Decimal256(50, 5)))
+    });
+
+    c.bench_function("cast decimal128 to decimal128 512 with same scale", |b| {
+        b.iter(|| cast_array(&decimal128_array, DataType::Decimal128(30, 3)))
+    });
+    c.bench_function("cast decimal256 to decimal256 512 with same scale", |b| {
+        b.iter(|| cast_array(&decimal256_array, DataType::Decimal256(60, 3)))
+    });
 }
 
 criterion_group!(benches, add_benchmark);
diff --git a/arrow/benches/comparison_kernels.rs b/arrow/benches/comparison_kernels.rs
index 21d83e07eec3..02de70c5d79d 100644
--- a/arrow/benches/comparison_kernels.rs
+++ b/arrow/benches/comparison_kernels.rs
@@ -21,112 +21,30 @@ use criterion::Criterion;
 
 extern crate arrow;
 
-use arrow::compute::*;
-use arrow::datatypes::{ArrowNumericType, IntervalMonthDayNanoType};
+use arrow::compute::kernels::cmp::*;
+use arrow::datatypes::IntervalMonthDayNanoType;
 use arrow::util::bench_util::*;
 use arrow::{array::*, datatypes::Float32Type, datatypes::Int32Type};
+use arrow_array::Scalar;
+use arrow_string::like::*;
+use arrow_string::regexp::regexp_is_match_utf8_scalar;
 
-fn bench_eq<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
-where
-    T: ArrowNumericType,
-{
-    eq(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
-}
-
-fn bench_eq_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
-where
-    T: ArrowNumericType,
-{
-    eq_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
-}
-
-fn bench_neq<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
-where
-    T: ArrowNumericType,
-{
-    neq(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
-}
-
-fn bench_neq_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
-where
-    T: ArrowNumericType,
-{
-    neq_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
-}
-
-fn bench_lt<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
-where
-    T: ArrowNumericType,
-{
-    lt(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
-}
-
-fn bench_lt_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
-where
-    T: ArrowNumericType,
-{
-    lt_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
-}
-
-fn bench_lt_eq<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
-where
-    T: ArrowNumericType,
-{
-    lt_eq(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
-}
-
-fn bench_lt_eq_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
-where
-    T: ArrowNumericType,
-{
-    lt_eq_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
-}
-
-fn bench_gt<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
-where
-    T: ArrowNumericType,
-{
-    gt(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
-}
-
-fn bench_gt_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
-where
-    T: ArrowNumericType,
-{
-    gt_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
-}
-
-fn bench_gt_eq<T>(arr_a: &PrimitiveArray<T>, arr_b: &PrimitiveArray<T>)
-where
-    T: ArrowNumericType,
-{
-    gt_eq(criterion::black_box(arr_a), criterion::black_box(arr_b)).unwrap();
-}
-
-fn bench_gt_eq_scalar<T>(arr_a: &PrimitiveArray<T>, value_b: T::Native)
-where
-    T: ArrowNumericType,
-{
-    gt_eq_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
-}
+const SIZE: usize = 65536;
 
 fn bench_like_utf8_scalar(arr_a: &StringArray, value_b: &str) {
-    like_utf8_scalar(criterion::black_box(arr_a), criterion::black_box(value_b)).unwrap();
+    like(arr_a, &StringArray::new_scalar(value_b)).unwrap();
 }
 
 fn bench_nlike_utf8_scalar(arr_a: &StringArray, value_b: &str) {
-    nlike_utf8_scalar(criterion::black_box(arr_a), criterion::black_box(value_b))
-        .unwrap();
+    nlike(arr_a, &StringArray::new_scalar(value_b)).unwrap();
 }
 
 fn bench_ilike_utf8_scalar(arr_a: &StringArray, value_b: &str) {
-    ilike_utf8_scalar(criterion::black_box(arr_a), criterion::black_box(value_b))
-        .unwrap();
+    ilike(arr_a, &StringArray::new_scalar(value_b)).unwrap();
 }
 
 fn bench_nilike_utf8_scalar(arr_a: &StringArray, value_b: &str) {
-    nilike_utf8_scalar(criterion::black_box(arr_a), criterion::black_box(value_b))
-        .unwrap();
+    nilike(arr_a, &StringArray::new_scalar(value_b)).unwrap();
 }
 
 fn bench_regexp_is_match_utf8_scalar(arr_a: &StringArray, value_b: &str) {
@@ -138,65 +56,89 @@ fn bench_regexp_is_match_utf8_scalar(arr_a: &StringArray, value_b: &str) {
     .unwrap();
 }
 
-fn bench_dict_eq<T>(arr_a: &DictionaryArray<T>, arr_b: &DictionaryArray<T>)
-where
-    T: ArrowNumericType,
-{
-    cmp_dict_utf8::<T, i32, _>(
-        criterion::black_box(arr_a),
-        criterion::black_box(arr_b),
-        |a, b| a == b,
-    )
-    .unwrap();
-}
-
 fn add_benchmark(c: &mut Criterion) {
-    let size = 65536;
-    let arr_a = create_primitive_array_with_seed::<Float32Type>(size, 0.0, 42);
-    let arr_b = create_primitive_array_with_seed::<Float32Type>(size, 0.0, 43);
+    let arr_a = create_primitive_array_with_seed::<Float32Type>(SIZE, 0.0, 42);
+    let arr_b = create_primitive_array_with_seed::<Float32Type>(SIZE, 0.0, 43);
 
     let arr_month_day_nano_a =
-        create_primitive_array_with_seed::<IntervalMonthDayNanoType>(size, 0.0, 43);
+        create_primitive_array_with_seed::<IntervalMonthDayNanoType>(SIZE, 0.0, 43);
     let arr_month_day_nano_b =
-        create_primitive_array_with_seed::<IntervalMonthDayNanoType>(size, 0.0, 43);
+        create_primitive_array_with_seed::<IntervalMonthDayNanoType>(SIZE, 0.0, 43);
 
-    let arr_string = create_string_array::<i32>(size, 0.0);
+    let arr_string = create_string_array::<i32>(SIZE, 0.0);
+    let scalar = Float32Array::from(vec![1.0]);
 
-    c.bench_function("eq Float32", |b| b.iter(|| bench_eq(&arr_a, &arr_b)));
+    c.bench_function("eq Float32", |b| b.iter(|| eq(&arr_a, &arr_b)));
     c.bench_function("eq scalar Float32", |b| {
-        b.iter(|| bench_eq_scalar(&arr_a, 1.0))
+        b.iter(|| eq(&arr_a, &Scalar::new(&scalar)).unwrap())
     });
 
-    c.bench_function("neq Float32", |b| b.iter(|| bench_neq(&arr_a, &arr_b)));
+    c.bench_function("neq Float32", |b| b.iter(|| neq(&arr_a, &arr_b)));
     c.bench_function("neq scalar Float32", |b| {
-        b.iter(|| bench_neq_scalar(&arr_a, 1.0))
+        b.iter(|| neq(&arr_a, &Scalar::new(&scalar)).unwrap())
     });
 
-    c.bench_function("lt Float32", |b| b.iter(|| bench_lt(&arr_a, &arr_b)));
+    c.bench_function("lt Float32", |b| b.iter(|| lt(&arr_a, &arr_b)));
     c.bench_function("lt scalar Float32", |b| {
-        b.iter(|| bench_lt_scalar(&arr_a, 1.0))
+        b.iter(|| lt(&arr_a, &Scalar::new(&scalar)).unwrap())
     });
 
-    c.bench_function("lt_eq Float32", |b| b.iter(|| bench_lt_eq(&arr_a, &arr_b)));
+    c.bench_function("lt_eq Float32", |b| b.iter(|| lt_eq(&arr_a, &arr_b)));
     c.bench_function("lt_eq scalar Float32", |b| {
-        b.iter(|| bench_lt_eq_scalar(&arr_a, 1.0))
+        b.iter(|| lt_eq(&arr_a, &Scalar::new(&scalar)).unwrap())
     });
 
-    c.bench_function("gt Float32", |b| b.iter(|| bench_gt(&arr_a, &arr_b)));
+    c.bench_function("gt Float32", |b| b.iter(|| gt(&arr_a, &arr_b)));
     c.bench_function("gt scalar Float32", |b| {
-        b.iter(|| bench_gt_scalar(&arr_a, 1.0))
+        b.iter(|| gt(&arr_a, &Scalar::new(&scalar)).unwrap())
     });
 
-    c.bench_function("gt_eq Float32", |b| b.iter(|| bench_gt_eq(&arr_a, &arr_b)));
+    c.bench_function("gt_eq Float32", |b| b.iter(|| gt_eq(&arr_a, &arr_b)));
     c.bench_function("gt_eq scalar Float32", |b| {
-        b.iter(|| bench_gt_eq_scalar(&arr_a, 1.0))
+        b.iter(|| gt_eq(&arr_a, &Scalar::new(&scalar)).unwrap())
+    });
+
+    let arr_a = create_primitive_array_with_seed::<Int32Type>(SIZE, 0.0, 42);
+    let arr_b = create_primitive_array_with_seed::<Int32Type>(SIZE, 0.0, 43);
+    let scalar = Int32Array::new_scalar(1);
+
+    c.bench_function("eq Int32", |b| b.iter(|| eq(&arr_a, &arr_b)));
+    c.bench_function("eq scalar Int32", |b| {
+        b.iter(|| eq(&arr_a, &scalar).unwrap())
+    });
+
+    c.bench_function("neq Int32", |b| b.iter(|| neq(&arr_a, &arr_b)));
+    c.bench_function("neq scalar Int32", |b| {
+        b.iter(|| neq(&arr_a, &scalar).unwrap())
+    });
+
+    c.bench_function("lt Int32", |b| b.iter(|| lt(&arr_a, &arr_b)));
+    c.bench_function("lt scalar Int32", |b| {
+        b.iter(|| lt(&arr_a, &scalar).unwrap())
+    });
+
+    c.bench_function("lt_eq Int32", |b| b.iter(|| lt_eq(&arr_a, &arr_b)));
+    c.bench_function("lt_eq scalar Int32", |b| {
+        b.iter(|| lt_eq(&arr_a, &scalar).unwrap())
+    });
+
+    c.bench_function("gt Int32", |b| b.iter(|| gt(&arr_a, &arr_b)));
+    c.bench_function("gt scalar Int32", |b| {
+        b.iter(|| gt(&arr_a, &scalar).unwrap())
+    });
+
+    c.bench_function("gt_eq Int32", |b| b.iter(|| gt_eq(&arr_a, &arr_b)));
+    c.bench_function("gt_eq scalar Int32", |b| {
+        b.iter(|| gt_eq(&arr_a, &scalar).unwrap())
     });
 
     c.bench_function("eq MonthDayNano", |b| {
-        b.iter(|| bench_eq(&arr_month_day_nano_a, &arr_month_day_nano_b))
+        b.iter(|| eq(&arr_month_day_nano_a, &arr_month_day_nano_b))
     });
+    let scalar = IntervalMonthDayNanoArray::new_scalar(123);
+
     c.bench_function("eq scalar MonthDayNano", |b| {
-        b.iter(|| bench_eq_scalar(&arr_month_day_nano_a, 123))
+        b.iter(|| eq(&arr_month_day_nano_b, &scalar).unwrap())
     });
 
     c.bench_function("like_utf8 scalar equals", |b| {
@@ -287,11 +229,33 @@ fn add_benchmark(c: &mut Criterion) {
         b.iter(|| bench_regexp_is_match_utf8_scalar(&arr_string, "xx$"))
     });
 
-    let dict_arr_a = create_string_dict_array::<Int32Type>(size, 0.0);
-    let dict_arr_b = create_string_dict_array::<Int32Type>(size, 0.0);
+    let strings = create_string_array::<i32>(20, 0.);
+    let dict_arr_a = create_dict_from_values::<Int32Type>(SIZE, 0., &strings);
+    let scalar = StringArray::from(vec!["test"]);
+
+    c.bench_function("eq_dyn_utf8_scalar dictionary[10] string[4])", |b| {
+        b.iter(|| eq(&dict_arr_a, &Scalar::new(&scalar)))
+    });
+
+    c.bench_function(
+        "gt_eq_dyn_utf8_scalar scalar dictionary[10] string[4])",
+        |b| b.iter(|| gt_eq(&dict_arr_a, &Scalar::new(&scalar))),
+    );
+
+    c.bench_function("like_utf8_scalar_dyn dictionary[10] string[4])", |b| {
+        b.iter(|| like(&dict_arr_a, &StringArray::new_scalar("test")))
+    });
+
+    c.bench_function("ilike_utf8_scalar_dyn dictionary[10] string[4])", |b| {
+        b.iter(|| ilike(&dict_arr_a, &StringArray::new_scalar("test")))
+    });
+
+    let strings = create_string_array::<i32>(20, 0.);
+    let dict_arr_a = create_dict_from_values::<Int32Type>(SIZE, 0., &strings);
+    let dict_arr_b = create_dict_from_values::<Int32Type>(SIZE, 0., &strings);
 
-    c.bench_function("dict eq string", |b| {
-        b.iter(|| bench_dict_eq(&dict_arr_a, &dict_arr_b))
+    c.bench_function("eq dictionary[10] string[4])", |b| {
+        b.iter(|| eq(&dict_arr_a, &dict_arr_b).unwrap())
     });
 }
 
diff --git a/arrow/benches/concatenate_kernel.rs b/arrow/benches/concatenate_kernel.rs
index 3fff2abd179c..2f5b654394e4 100644
--- a/arrow/benches/concatenate_kernel.rs
+++ b/arrow/benches/concatenate_kernel.rs
@@ -60,6 +60,28 @@ fn add_benchmark(c: &mut Criterion) {
     c.bench_function("concat str nulls 1024", |b| {
         b.iter(|| bench_concat(&v1, &v2))
     });
+
+    let v1 = create_string_array_with_len::<i32>(10, 0.0, 20);
+    let v1 = create_dict_from_values::<Int32Type>(1024, 0.0, &v1);
+    let v2 = create_string_array_with_len::<i32>(10, 0.0, 20);
+    let v2 = create_dict_from_values::<Int32Type>(1024, 0.0, &v2);
+    c.bench_function("concat str_dict 1024", |b| {
+        b.iter(|| bench_concat(&v1, &v2))
+    });
+
+    let v1 = create_string_array_with_len::<i32>(1024, 0.0, 20);
+    let v1 = create_sparse_dict_from_values::<Int32Type>(1024, 0.0, &v1, 10..20);
+    let v2 = create_string_array_with_len::<i32>(1024, 0.0, 20);
+    let v2 = create_sparse_dict_from_values::<Int32Type>(1024, 0.0, &v2, 30..40);
+    c.bench_function("concat str_dict_sparse 1024", |b| {
+        b.iter(|| bench_concat(&v1, &v2))
+    });
+
+    let v1 = create_string_array::<i32>(1024, 0.5);
+    let v2 = create_string_array::<i32>(1024, 0.5);
+    c.bench_function("concat str nulls 1024", |b| {
+        b.iter(|| bench_concat(&v1, &v2))
+    });
 }
 
 criterion_group!(benches, add_benchmark);
diff --git a/arrow/benches/csv_reader.rs b/arrow/benches/csv_reader.rs
new file mode 100644
index 000000000000..b5afac1f6a46
--- /dev/null
+++ b/arrow/benches/csv_reader.rs
@@ -0,0 +1,143 @@
+// 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.
+
+extern crate arrow;
+extern crate criterion;
+
+use std::io::Cursor;
+use std::sync::Arc;
+
+use criterion::*;
+use rand::Rng;
+
+use arrow::array::*;
+use arrow::csv;
+use arrow::datatypes::*;
+use arrow::record_batch::RecordBatch;
+use arrow::util::bench_util::{create_primitive_array, create_string_array_with_len};
+use arrow::util::test_util::seedable_rng;
+
+fn do_bench(c: &mut Criterion, name: &str, cols: Vec<ArrayRef>) {
+    let batch = RecordBatch::try_from_iter(cols.into_iter().map(|a| ("col", a))).unwrap();
+
+    let mut buf = Vec::with_capacity(1024);
+    let mut csv = csv::Writer::new(&mut buf);
+    csv.write(&batch).unwrap();
+    drop(csv);
+
+    for batch_size in [128, 1024, 4096] {
+        c.bench_function(&format!("{name} - {batch_size}"), |b| {
+            b.iter(|| {
+                let cursor = Cursor::new(buf.as_slice());
+                let reader = csv::ReaderBuilder::new(batch.schema())
+                    .with_batch_size(batch_size)
+                    .with_header(true)
+                    .build_buffered(cursor)
+                    .unwrap();
+
+                for next in reader {
+                    next.unwrap();
+                }
+            });
+        });
+    }
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut rng = seedable_rng();
+
+    let values = Int32Array::from_iter_values((0..4096).map(|_| rng.gen_range(0..1024)));
+    let cols = vec![Arc::new(values) as ArrayRef];
+    do_bench(c, "4096 i32_small(0)", cols);
+
+    let values = Int32Array::from_iter_values((0..4096).map(|_| rng.gen()));
+    let cols = vec![Arc::new(values) as ArrayRef];
+    do_bench(c, "4096 i32(0)", cols);
+
+    let values = UInt64Array::from_iter_values((0..4096).map(|_| rng.gen_range(0..1024)));
+    let cols = vec![Arc::new(values) as ArrayRef];
+    do_bench(c, "4096 u64_small(0)", cols);
+
+    let values = UInt64Array::from_iter_values((0..4096).map(|_| rng.gen()));
+    let cols = vec![Arc::new(values) as ArrayRef];
+    do_bench(c, "4096 u64(0)", cols);
+
+    let values = Int64Array::from_iter_values((0..4096).map(|_| rng.gen_range(0..1024) - 512));
+    let cols = vec![Arc::new(values) as ArrayRef];
+    do_bench(c, "4096 i64_small(0)", cols);
+
+    let values = Int64Array::from_iter_values((0..4096).map(|_| rng.gen()));
+    let cols = vec![Arc::new(values) as ArrayRef];
+    do_bench(c, "4096 i64(0)", cols);
+
+    let cols = vec![Arc::new(Float32Array::from_iter_values(
+        (0..4096).map(|_| rng.gen_range(0..1024000) as f32 / 1000.),
+    )) as _];
+    do_bench(c, "4096 f32_small(0)", cols);
+
+    let values = Float32Array::from_iter_values((0..4096).map(|_| rng.gen()));
+    let cols = vec![Arc::new(values) as ArrayRef];
+    do_bench(c, "4096 f32(0)", cols);
+
+    let cols = vec![Arc::new(Float64Array::from_iter_values(
+        (0..4096).map(|_| rng.gen_range(0..1024000) as f64 / 1000.),
+    )) as _];
+    do_bench(c, "4096 f64_small(0)", cols);
+
+    let values = Float64Array::from_iter_values((0..4096).map(|_| rng.gen()));
+    let cols = vec![Arc::new(values) as ArrayRef];
+    do_bench(c, "4096 f64(0)", cols);
+
+    let cols = vec![Arc::new(create_string_array_with_len::<i32>(4096, 0., 10)) as ArrayRef];
+    do_bench(c, "4096 string(10, 0)", cols);
+
+    let cols = vec![Arc::new(create_string_array_with_len::<i32>(4096, 0., 30)) as ArrayRef];
+    do_bench(c, "4096 string(30, 0)", cols);
+
+    let cols = vec![Arc::new(create_string_array_with_len::<i32>(4096, 0., 100)) as ArrayRef];
+    do_bench(c, "4096 string(100, 0)", cols);
+
+    let cols = vec![Arc::new(create_string_array_with_len::<i32>(4096, 0.5, 100)) as ArrayRef];
+    do_bench(c, "4096 string(100, 0.5)", cols);
+
+    let cols = vec![
+        Arc::new(create_string_array_with_len::<i32>(4096, 0.5, 20)) as ArrayRef,
+        Arc::new(create_string_array_with_len::<i32>(4096, 0., 30)) as ArrayRef,
+        Arc::new(create_string_array_with_len::<i32>(4096, 0., 100)) as ArrayRef,
+        Arc::new(create_primitive_array::<Int64Type>(4096, 0.)) as ArrayRef,
+    ];
+    do_bench(
+        c,
+        "4096 string(20, 0.5), string(30, 0), string(100, 0), i64(0)",
+        cols,
+    );
+
+    let cols = vec![
+        Arc::new(create_string_array_with_len::<i32>(4096, 0.5, 20)) as ArrayRef,
+        Arc::new(create_string_array_with_len::<i32>(4096, 0., 30)) as ArrayRef,
+        Arc::new(create_primitive_array::<Float64Type>(4096, 0.)) as ArrayRef,
+        Arc::new(create_primitive_array::<Int64Type>(4096, 0.)) as ArrayRef,
+    ];
+    do_bench(
+        c,
+        "4096 string(20, 0.5), string(30, 0), f64(0), i64(0)",
+        cols,
+    );
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow/benches/csv_writer.rs b/arrow/benches/csv_writer.rs
index 3ecf514ad6db..0c13428c9160 100644
--- a/arrow/benches/csv_writer.rs
+++ b/arrow/benches/csv_writer.rs
@@ -21,7 +21,6 @@ extern crate criterion;
 use criterion::*;
 
 use arrow::array::*;
-#[cfg(feature = "csv")]
 use arrow::csv;
 use arrow::datatypes::*;
 use arrow::record_batch::RecordBatch;
@@ -30,47 +29,40 @@ use std::fs::File;
 use std::sync::Arc;
 
 fn criterion_benchmark(c: &mut Criterion) {
-    #[cfg(feature = "csv")]
-    {
-        let schema = Schema::new(vec![
-            Field::new("c1", DataType::Utf8, false),
-            Field::new("c2", DataType::Float64, true),
-            Field::new("c3", DataType::UInt32, false),
-            Field::new("c4", DataType::Boolean, true),
-        ]);
+    let schema = Schema::new(vec![
+        Field::new("c1", DataType::Utf8, false),
+        Field::new("c2", DataType::Float64, true),
+        Field::new("c3", DataType::UInt32, false),
+        Field::new("c4", DataType::Boolean, true),
+    ]);
 
-        let c1 = StringArray::from(vec![
-            "Lorem ipsum dolor sit amet",
-            "consectetur adipiscing elit",
-            "sed do eiusmod tempor",
-        ]);
-        let c2 = PrimitiveArray::<Float64Type>::from(vec![
-            Some(123.564532),
-            None,
-            Some(-556132.25),
-        ]);
-        let c3 = PrimitiveArray::<UInt32Type>::from(vec![3, 2, 1]);
-        let c4 = BooleanArray::from(vec![Some(true), Some(false), None]);
+    let c1 = StringArray::from(vec![
+        "Lorem ipsum dolor sit amet",
+        "consectetur adipiscing elit",
+        "sed do eiusmod tempor",
+    ]);
+    let c2 = PrimitiveArray::<Float64Type>::from(vec![Some(123.564532), None, Some(-556132.25)]);
+    let c3 = PrimitiveArray::<UInt32Type>::from(vec![3, 2, 1]);
+    let c4 = BooleanArray::from(vec![Some(true), Some(false), None]);
 
-        let b = RecordBatch::try_new(
-            Arc::new(schema),
-            vec![Arc::new(c1), Arc::new(c2), Arc::new(c3), Arc::new(c4)],
-        )
-        .unwrap();
-        let path = env::temp_dir().join("bench_write_csv.csv");
-        let file = File::create(path).unwrap();
-        let mut writer = csv::Writer::new(file);
-        let batches = vec![&b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b];
+    let b = RecordBatch::try_new(
+        Arc::new(schema),
+        vec![Arc::new(c1), Arc::new(c2), Arc::new(c3), Arc::new(c4)],
+    )
+    .unwrap();
+    let path = env::temp_dir().join("bench_write_csv.csv");
+    let file = File::create(path).unwrap();
+    let mut writer = csv::Writer::new(file);
+    let batches = vec![&b, &b, &b, &b, &b, &b, &b, &b, &b, &b, &b];
 
-        c.bench_function("record_batches_to_csv", |b| {
-            b.iter(|| {
-                #[allow(clippy::unit_arg)]
-                criterion::black_box(for batch in &batches {
-                    writer.write(batch).unwrap()
-                });
+    c.bench_function("record_batches_to_csv", |b| {
+        b.iter(|| {
+            #[allow(clippy::unit_arg)]
+            criterion::black_box(for batch in &batches {
+                writer.write(batch).unwrap()
             });
         });
-    }
+    });
 }
 
 criterion_group!(benches, criterion_benchmark);
diff --git a/arrow/benches/decimal_validate.rs b/arrow/benches/decimal_validate.rs
index 1c726341e177..be812a225ca2 100644
--- a/arrow/benches/decimal_validate.rs
+++ b/arrow/benches/decimal_validate.rs
@@ -18,12 +18,13 @@
 #[macro_use]
 extern crate criterion;
 
-use arrow::array::{Array, Decimal128Array, Decimal256Array, Decimal256Builder};
+use arrow::array::{Array, Decimal128Array, Decimal128Builder, Decimal256Array, Decimal256Builder};
 use criterion::Criterion;
+use rand::Rng;
 
 extern crate arrow;
 
-use arrow::util::decimal::Decimal256;
+use arrow_buffer::i256;
 
 fn validate_decimal128_array(array: Decimal128Array) {
     array.with_precision_and_scale(35, 0).unwrap();
@@ -34,7 +35,16 @@ fn validate_decimal256_array(array: Decimal256Array) {
 }
 
 fn validate_decimal128_benchmark(c: &mut Criterion) {
-    let decimal_array = Decimal128Array::from_iter_values(vec![12324; 20000]);
+    let mut rng = rand::thread_rng();
+    let size: i128 = 20000;
+    let mut decimal_builder = Decimal128Builder::with_capacity(size as usize);
+    for _ in 0..size {
+        decimal_builder.append_value(rng.gen_range::<i128, _>(0..999999999999));
+    }
+    let decimal_array = decimal_builder
+        .finish()
+        .with_precision_and_scale(38, 0)
+        .unwrap();
     let data = decimal_array.into_data();
     c.bench_function("validate_decimal128_array 20000", |b| {
         b.iter(|| {
@@ -45,15 +55,18 @@ fn validate_decimal128_benchmark(c: &mut Criterion) {
 }
 
 fn validate_decimal256_benchmark(c: &mut Criterion) {
-    let mut decimal_builder = Decimal256Builder::new(20000, 76, 0);
-    let mut bytes = vec![0; 32];
-    bytes[0..16].clone_from_slice(&12324_i128.to_le_bytes());
-    for _ in 0..20000 {
-        decimal_builder
-            .append_value(&Decimal256::new(76, 0, &bytes))
-            .unwrap();
+    let mut rng = rand::thread_rng();
+    let size: i128 = 20000;
+    let mut decimal_builder = Decimal256Builder::with_capacity(size as usize);
+    for _ in 0..size {
+        let v = rng.gen_range::<i128, _>(0..999999999999999);
+        let decimal = i256::from_i128(v);
+        decimal_builder.append_value(decimal);
     }
-    let decimal_array256_data = decimal_builder.finish();
+    let decimal_array256_data = decimal_builder
+        .finish()
+        .with_precision_and_scale(76, 0)
+        .unwrap();
     let data = decimal_array256_data.into_data();
     c.bench_function("validate_decimal256_array 20000", |b| {
         b.iter(|| {
diff --git a/arrow/benches/equal.rs b/arrow/benches/equal.rs
index af535506e86d..4e99bf3071c9 100644
--- a/arrow/benches/equal.rs
+++ b/arrow/benches/equal.rs
@@ -38,6 +38,9 @@ fn add_benchmark(c: &mut Criterion) {
     let arr_a_nulls = create_primitive_array::<Float32Type>(512, 0.5);
     c.bench_function("equal_nulls_512", |b| b.iter(|| bench_equal(&arr_a_nulls)));
 
+    let arr_a = create_primitive_array::<Float32Type>(51200, 0.1);
+    c.bench_function("equal_51200", |b| b.iter(|| bench_equal(&arr_a)));
+
     let arr_a = create_string_array::<i32>(512, 0.0);
     c.bench_function("equal_string_512", |b| b.iter(|| bench_equal(&arr_a)));
 
diff --git a/arrow/benches/filter_kernels.rs b/arrow/benches/filter_kernels.rs
index be6d9027a8db..65726a271009 100644
--- a/arrow/benches/filter_kernels.rs
+++ b/arrow/benches/filter_kernels.rs
@@ -26,6 +26,7 @@ use arrow::array::*;
 use arrow::compute::filter;
 use arrow::datatypes::{Field, Float32Type, Int32Type, Schema, UInt8Type};
 
+use arrow_array::types::Decimal128Type;
 use criterion::{criterion_group, criterion_main, Criterion};
 
 fn bench_filter(data_array: &dyn Array, filter_array: &BooleanArray) {
@@ -143,6 +144,29 @@ fn add_benchmark(c: &mut Criterion) {
         b.iter(|| bench_built_filter(&sparse_filter, &data_array))
     });
 
+    let data_array = create_primitive_array::<Decimal128Type>(size, 0.0);
+    c.bench_function("filter decimal128 (kept 1/2)", |b| {
+        b.iter(|| bench_filter(&data_array, &filter_array))
+    });
+    c.bench_function("filter decimal128 high selectivity (kept 1023/1024)", |b| {
+        b.iter(|| bench_filter(&data_array, &dense_filter_array))
+    });
+    c.bench_function("filter decimal128 low selectivity (kept 1/1024)", |b| {
+        b.iter(|| bench_filter(&data_array, &sparse_filter_array))
+    });
+
+    c.bench_function("filter context decimal128 (kept 1/2)", |b| {
+        b.iter(|| bench_built_filter(&filter, &data_array))
+    });
+    c.bench_function(
+        "filter context decimal128 high selectivity (kept 1023/1024)",
+        |b| b.iter(|| bench_built_filter(&dense_filter, &data_array)),
+    );
+    c.bench_function(
+        "filter context decimal128 low selectivity (kept 1/1024)",
+        |b| b.iter(|| bench_built_filter(&sparse_filter, &data_array)),
+    );
+
     let data_array = create_string_array::<i32>(size, 0.5);
     c.bench_function("filter context string (kept 1/2)", |b| {
         b.iter(|| bench_built_filter(&filter, &data_array))
@@ -155,7 +179,7 @@ fn add_benchmark(c: &mut Criterion) {
         b.iter(|| bench_built_filter(&sparse_filter, &data_array))
     });
 
-    let data_array = create_string_dict_array::<Int32Type>(size, 0.0);
+    let data_array = create_string_dict_array::<Int32Type>(size, 0.0, 4);
     c.bench_function("filter context string dictionary (kept 1/2)", |b| {
         b.iter(|| bench_built_filter(&filter, &data_array))
     });
@@ -168,7 +192,7 @@ fn add_benchmark(c: &mut Criterion) {
         |b| b.iter(|| bench_built_filter(&sparse_filter, &data_array)),
     );
 
-    let data_array = create_string_dict_array::<Int32Type>(size, 0.5);
+    let data_array = create_string_dict_array::<Int32Type>(size, 0.5, 4);
     c.bench_function("filter context string dictionary w NULLs (kept 1/2)", |b| {
         b.iter(|| bench_built_filter(&filter, &data_array))
     });
@@ -186,8 +210,7 @@ fn add_benchmark(c: &mut Criterion) {
     let field = Field::new("c1", data_array.data_type().clone(), true);
     let schema = Schema::new(vec![field]);
 
-    let batch =
-        RecordBatch::try_new(Arc::new(schema), vec![Arc::new(data_array)]).unwrap();
+    let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(data_array)]).unwrap();
 
     c.bench_function("filter single record batch", |b| {
         b.iter(|| filter_record_batch(&batch, &filter_array))
diff --git a/arrow/benches/interleave_kernels.rs b/arrow/benches/interleave_kernels.rs
new file mode 100644
index 000000000000..0941f1e3fd33
--- /dev/null
+++ b/arrow/benches/interleave_kernels.rs
@@ -0,0 +1,112 @@
+// 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.
+
+#[macro_use]
+extern crate criterion;
+
+use criterion::Criterion;
+use std::ops::Range;
+
+use rand::Rng;
+
+extern crate arrow;
+
+use arrow::datatypes::*;
+use arrow::util::test_util::seedable_rng;
+use arrow::{array::*, util::bench_util::*};
+use arrow_select::interleave::interleave;
+
+fn do_bench(
+    c: &mut Criterion,
+    prefix: &str,
+    len: usize,
+    base: &dyn Array,
+    slices: &[Range<usize>],
+) {
+    let arrays: Vec<_> = slices
+        .iter()
+        .map(|r| base.slice(r.start, r.end - r.start))
+        .collect();
+    let values: Vec<_> = arrays.iter().map(|x| x.as_ref()).collect();
+    bench_values(
+        c,
+        &format!("interleave {prefix} {len} {slices:?}"),
+        len,
+        &values,
+    );
+}
+
+fn bench_values(c: &mut Criterion, name: &str, len: usize, values: &[&dyn Array]) {
+    let mut rng = seedable_rng();
+    let indices: Vec<_> = (0..len)
+        .map(|_| {
+            let array_idx = rng.gen_range(0..values.len());
+            let value_idx = rng.gen_range(0..values[array_idx].len());
+            (array_idx, value_idx)
+        })
+        .collect();
+
+    c.bench_function(name, |b| {
+        b.iter(|| criterion::black_box(interleave(values, &indices).unwrap()))
+    });
+}
+
+fn add_benchmark(c: &mut Criterion) {
+    let i32 = create_primitive_array::<Int32Type>(1024, 0.);
+    let i32_opt = create_primitive_array::<Int32Type>(1024, 0.5);
+    let string = create_string_array_with_len::<i32>(1024, 0., 20);
+    let string_opt = create_string_array_with_len::<i32>(1024, 0.5, 20);
+    let values = create_string_array_with_len::<i32>(10, 0.0, 20);
+    let dict = create_dict_from_values::<Int32Type>(1024, 0.0, &values);
+
+    let values = create_string_array_with_len::<i32>(1024, 0.0, 20);
+    let sparse_dict = create_sparse_dict_from_values::<Int32Type>(1024, 0.0, &values, 10..20);
+
+    let cases: &[(&str, &dyn Array)] = &[
+        ("i32(0.0)", &i32),
+        ("i32(0.5)", &i32_opt),
+        ("str(20, 0.0)", &string),
+        ("str(20, 0.5)", &string_opt),
+        ("dict(20, 0.0)", &dict),
+        ("dict_sparse(20, 0.0)", &sparse_dict),
+    ];
+
+    for (prefix, base) in cases {
+        let slices: &[(usize, &[_])] = &[
+            (100, &[0..100, 100..230, 450..1000]),
+            (400, &[0..100, 100..230, 450..1000]),
+            (1024, &[0..100, 100..230, 450..1000]),
+            (1024, &[0..100, 100..230, 450..1000, 0..1000]),
+        ];
+
+        for (len, slice) in slices {
+            do_bench(c, prefix, *len, *base, slice);
+        }
+    }
+
+    for len in [100, 1024, 2048] {
+        bench_values(
+            c,
+            &format!("interleave dict_distinct {len}"),
+            100,
+            &[&dict, &sparse_dict],
+        );
+    }
+}
+
+criterion_group!(benches, add_benchmark);
+criterion_main!(benches);
diff --git a/arrow/benches/json_reader.rs b/arrow/benches/json_reader.rs
index ef3ddf0537bb..8f3898c51f9d 100644
--- a/arrow/benches/json_reader.rs
+++ b/arrow/benches/json_reader.rs
@@ -15,24 +15,39 @@
 // specific language governing permissions and limitations
 // under the License.
 
-extern crate arrow;
-extern crate criterion;
-
 use criterion::*;
 
 use arrow::datatypes::*;
-use arrow::json::ReaderBuilder;
+use arrow::util::bench_util::{
+    create_primitive_array, create_string_array, create_string_array_with_len,
+};
+use arrow_array::RecordBatch;
+use arrow_json::{LineDelimitedWriter, ReaderBuilder};
 use std::io::Cursor;
 use std::sync::Arc;
 
-fn json_primitive_to_record_batch() {
+#[allow(deprecated)]
+fn do_bench(c: &mut Criterion, name: &str, json: &str, schema: SchemaRef) {
+    c.bench_function(name, |b| {
+        b.iter(|| {
+            let cursor = Cursor::new(black_box(json));
+            let builder = ReaderBuilder::new(schema.clone()).with_batch_size(64);
+            let reader = builder.build(cursor).unwrap();
+            for next in reader {
+                next.unwrap();
+            }
+        })
+    });
+}
+
+fn small_bench_primitive(c: &mut Criterion) {
     let schema = Arc::new(Schema::new(vec![
         Field::new("c1", DataType::Utf8, true),
         Field::new("c2", DataType::Float64, true),
         Field::new("c3", DataType::UInt32, true),
         Field::new("c4", DataType::Boolean, true),
     ]));
-    let builder = ReaderBuilder::new().with_schema(schema).with_batch_size(64);
+
     let json_content = r#"
         {"c1": "eleven", "c2": 6.2222222225, "c3": 5.0, "c4": false}
         {"c1": "twelve", "c2": -55555555555555.2, "c3": 3}
@@ -45,39 +60,68 @@ fn json_primitive_to_record_batch() {
         {"c2": -35, "c3": 100.0, "c4": true}
         {"c1": "fifteen", "c2": null, "c4": true}
         "#;
-    let cursor = Cursor::new(json_content);
-    let mut reader = builder.build(cursor).unwrap();
-    #[allow(clippy::unit_arg)]
-    criterion::black_box({
-        reader.next().unwrap();
-    });
+
+    do_bench(c, "small_bench_primitive", json_content, schema)
 }
 
-fn json_list_primitive_to_record_batch() {
+fn large_bench_primitive(c: &mut Criterion) {
+    let schema = Arc::new(Schema::new(vec![
+        Field::new("c1", DataType::Utf8, true),
+        Field::new("c2", DataType::Int32, true),
+        Field::new("c3", DataType::UInt32, true),
+        Field::new("c4", DataType::Utf8, true),
+        Field::new("c5", DataType::Utf8, true),
+        Field::new("c6", DataType::Float32, true),
+    ]));
+
+    let c1 = Arc::new(create_string_array::<i32>(4096, 0.));
+    let c2 = Arc::new(create_primitive_array::<Int32Type>(4096, 0.));
+    let c3 = Arc::new(create_primitive_array::<UInt32Type>(4096, 0.));
+    let c4 = Arc::new(create_string_array_with_len::<i32>(4096, 0.2, 10));
+    let c5 = Arc::new(create_string_array_with_len::<i32>(4096, 0.2, 20));
+    let c6 = Arc::new(create_primitive_array::<Float32Type>(4096, 0.2));
+
+    let batch = RecordBatch::try_from_iter([
+        ("c1", c1 as _),
+        ("c2", c2 as _),
+        ("c3", c3 as _),
+        ("c4", c4 as _),
+        ("c5", c5 as _),
+        ("c6", c6 as _),
+    ])
+    .unwrap();
+
+    let mut out = Vec::with_capacity(1024);
+    LineDelimitedWriter::new(&mut out).write(&batch).unwrap();
+
+    let json = std::str::from_utf8(&out).unwrap();
+    do_bench(c, "large_bench_primitive", json, schema)
+}
+
+fn small_bench_list(c: &mut Criterion) {
     let schema = Arc::new(Schema::new(vec![
         Field::new(
             "c1",
-            DataType::List(Box::new(Field::new("item", DataType::Utf8, true))),
+            DataType::List(Arc::new(Field::new("item", DataType::Utf8, true))),
             true,
         ),
         Field::new(
             "c2",
-            DataType::List(Box::new(Field::new("item", DataType::Float64, true))),
+            DataType::List(Arc::new(Field::new("item", DataType::Float64, true))),
             true,
         ),
         Field::new(
             "c3",
-            DataType::List(Box::new(Field::new("item", DataType::UInt32, true))),
+            DataType::List(Arc::new(Field::new("item", DataType::UInt32, true))),
             true,
         ),
         Field::new(
             "c4",
-            DataType::List(Box::new(Field::new("item", DataType::Boolean, true))),
+            DataType::List(Arc::new(Field::new("item", DataType::Boolean, true))),
             true,
         ),
     ]));
-    let builder = ReaderBuilder::new().with_schema(schema).with_batch_size(64);
-    let json_content = r#"
+    let json = r#"
         {"c1": ["eleven"], "c2": [6.2222222225, -3.2, null], "c3": [5.0, 6], "c4": [false, true]}
         {"c1": ["twelve"], "c2": [-55555555555555.2, 12500000.0], "c3": [3, 4, 5]}
         {"c1": null, "c2": [3], "c3": [125, 127, 129], "c4": [null, false, true]}
@@ -91,21 +135,13 @@ fn json_list_primitive_to_record_batch() {
         {"c1": ["fifteen"], "c2": [null, 2.1, 1.5, -3], "c4": [true, false, null]}
         {"c1": ["fifteen"], "c2": [], "c4": [true, false, null]}
         "#;
-    let cursor = Cursor::new(json_content);
-    let mut reader = builder.build(cursor).unwrap();
-    #[allow(clippy::unit_arg)]
-    criterion::black_box({
-        reader.next().unwrap();
-    });
+    do_bench(c, "small_bench_list", json, schema)
 }
 
 fn criterion_benchmark(c: &mut Criterion) {
-    c.bench_function("json_primitive_to_record_batch", |b| {
-        b.iter(json_primitive_to_record_batch)
-    });
-    c.bench_function("json_list_primitive_to_record_batch", |b| {
-        b.iter(json_list_primitive_to_record_batch)
-    });
+    small_bench_primitive(c);
+    large_bench_primitive(c);
+    small_bench_list(c);
 }
 
 criterion_group!(benches, criterion_benchmark);
diff --git a/arrow/benches/json_writer.rs b/arrow/benches/json_writer.rs
new file mode 100644
index 000000000000..48be0bccb462
--- /dev/null
+++ b/arrow/benches/json_writer.rs
@@ -0,0 +1,198 @@
+// 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.
+
+use criterion::*;
+
+use arrow::datatypes::*;
+use arrow::util::bench_util::{
+    create_primitive_array, create_string_array, create_string_array_with_len,
+    create_string_dict_array,
+};
+use arrow::util::test_util::seedable_rng;
+use arrow_array::{Array, ListArray, RecordBatch, StructArray};
+use arrow_buffer::{BooleanBuffer, NullBuffer, OffsetBuffer};
+use arrow_json::LineDelimitedWriter;
+use rand::Rng;
+use std::sync::Arc;
+
+const NUM_ROWS: usize = 65536;
+
+fn do_bench(c: &mut Criterion, name: &str, batch: &RecordBatch) {
+    c.bench_function(name, |b| {
+        b.iter(|| {
+            let mut out = Vec::with_capacity(1024);
+            LineDelimitedWriter::new(&mut out).write(batch).unwrap();
+            out
+        })
+    });
+}
+
+fn create_mixed(len: usize) -> RecordBatch {
+    let c1 = Arc::new(create_string_array::<i32>(len, 0.));
+    let c2 = Arc::new(create_primitive_array::<Int32Type>(len, 0.));
+    let c3 = Arc::new(create_primitive_array::<UInt32Type>(len, 0.));
+    let c4 = Arc::new(create_string_array_with_len::<i32>(len, 0.2, 10));
+    let c5 = Arc::new(create_string_array_with_len::<i32>(len, 0.2, 20));
+    let c6 = Arc::new(create_primitive_array::<Float32Type>(len, 0.2));
+    RecordBatch::try_from_iter([
+        ("c1", c1 as _),
+        ("c2", c2 as _),
+        ("c3", c3 as _),
+        ("c4", c4 as _),
+        ("c5", c5 as _),
+        ("c6", c6 as _),
+    ])
+    .unwrap()
+}
+
+fn create_nulls(len: usize) -> NullBuffer {
+    let mut rng = seedable_rng();
+    BooleanBuffer::from_iter((0..len).map(|_| rng.gen_bool(0.2))).into()
+}
+
+fn create_offsets(len: usize) -> (usize, OffsetBuffer<i32>) {
+    let mut rng = seedable_rng();
+    let mut last_offset = 0;
+    let mut offsets = Vec::with_capacity(len + 1);
+    offsets.push(0);
+    for _ in 0..len {
+        let len = rng.gen_range(0..10);
+        offsets.push(last_offset + len);
+        last_offset += len;
+    }
+    (
+        *offsets.last().unwrap() as _,
+        OffsetBuffer::new(offsets.into()),
+    )
+}
+
+fn create_nullable_struct(len: usize) -> StructArray {
+    let c2 = StructArray::from(create_mixed(len));
+    StructArray::new(
+        c2.fields().clone(),
+        c2.columns().to_vec(),
+        Some(create_nulls(c2.len())),
+    )
+}
+
+fn bench_float(c: &mut Criterion) {
+    let c1 = Arc::new(create_primitive_array::<Float32Type>(NUM_ROWS, 0.));
+    let c2 = Arc::new(create_primitive_array::<Float64Type>(NUM_ROWS, 0.));
+
+    let batch = RecordBatch::try_from_iter([("c1", c1 as _), ("c2", c2 as _)]).unwrap();
+
+    do_bench(c, "bench_float", &batch)
+}
+
+fn bench_integer(c: &mut Criterion) {
+    let c1 = Arc::new(create_primitive_array::<UInt64Type>(NUM_ROWS, 0.));
+    let c2 = Arc::new(create_primitive_array::<Int32Type>(NUM_ROWS, 0.));
+    let c3 = Arc::new(create_primitive_array::<UInt32Type>(NUM_ROWS, 0.));
+
+    let batch =
+        RecordBatch::try_from_iter([("c1", c1 as _), ("c2", c2 as _), ("c3", c3 as _)]).unwrap();
+
+    do_bench(c, "bench_integer", &batch)
+}
+
+fn bench_mixed(c: &mut Criterion) {
+    let batch = create_mixed(NUM_ROWS);
+    do_bench(c, "bench_mixed", &batch)
+}
+
+fn bench_dict_array(c: &mut Criterion) {
+    let c1 = Arc::new(create_string_dict_array::<Int32Type>(NUM_ROWS, 0., 30));
+    let c2 = Arc::new(create_string_dict_array::<Int32Type>(NUM_ROWS, 0., 20));
+    let c3 = Arc::new(create_string_dict_array::<Int32Type>(NUM_ROWS, 0.1, 20));
+
+    let batch =
+        RecordBatch::try_from_iter([("c1", c1 as _), ("c2", c2 as _), ("c3", c3 as _)]).unwrap();
+
+    do_bench(c, "bench_dict_array", &batch)
+}
+
+fn bench_string(c: &mut Criterion) {
+    let c1 = Arc::new(create_string_array::<i32>(NUM_ROWS, 0.));
+    let c2 = Arc::new(create_string_array_with_len::<i32>(NUM_ROWS, 0., 10));
+    let c3 = Arc::new(create_string_array_with_len::<i32>(NUM_ROWS, 0.1, 20));
+
+    let batch =
+        RecordBatch::try_from_iter([("c1", c1 as _), ("c2", c2 as _), ("c3", c3 as _)]).unwrap();
+
+    do_bench(c, "bench_string", &batch)
+}
+
+fn bench_struct(c: &mut Criterion) {
+    let c1 = Arc::new(create_string_array::<i32>(NUM_ROWS, 0.));
+    let c2 = Arc::new(StructArray::from(create_mixed(NUM_ROWS)));
+    let batch = RecordBatch::try_from_iter([("c1", c1 as _), ("c2", c2 as _)]).unwrap();
+
+    do_bench(c, "bench_struct", &batch)
+}
+
+fn bench_nullable_struct(c: &mut Criterion) {
+    let c1 = Arc::new(create_string_array::<i32>(NUM_ROWS, 0.));
+    let c2 = Arc::new(create_nullable_struct(NUM_ROWS));
+    let batch = RecordBatch::try_from_iter([("c1", c1 as _), ("c2", c2 as _)]).unwrap();
+
+    do_bench(c, "bench_nullable_struct", &batch)
+}
+
+fn bench_list(c: &mut Criterion) {
+    let (values_len, offsets) = create_offsets(NUM_ROWS);
+    let c1_values = Arc::new(create_string_array::<i32>(values_len, 0.));
+    let c1_field = Arc::new(Field::new_list_field(c1_values.data_type().clone(), false));
+    let c1 = Arc::new(ListArray::new(c1_field, offsets, c1_values, None));
+    let batch = RecordBatch::try_from_iter([("c1", c1 as _)]).unwrap();
+    do_bench(c, "bench_list", &batch)
+}
+
+fn bench_nullable_list(c: &mut Criterion) {
+    let (values_len, offsets) = create_offsets(NUM_ROWS);
+    let c1_values = Arc::new(create_string_array::<i32>(values_len, 0.1));
+    let c1_field = Arc::new(Field::new_list_field(c1_values.data_type().clone(), true));
+    let c1_nulls = create_nulls(NUM_ROWS);
+    let c1 = Arc::new(ListArray::new(c1_field, offsets, c1_values, Some(c1_nulls)));
+    let batch = RecordBatch::try_from_iter([("c1", c1 as _)]).unwrap();
+    do_bench(c, "bench_nullable_list", &batch)
+}
+
+fn bench_struct_list(c: &mut Criterion) {
+    let (values_len, offsets) = create_offsets(NUM_ROWS);
+    let c1_values = Arc::new(create_nullable_struct(values_len));
+    let c1_field = Arc::new(Field::new_list_field(c1_values.data_type().clone(), true));
+    let c1_nulls = create_nulls(NUM_ROWS);
+    let c1 = Arc::new(ListArray::new(c1_field, offsets, c1_values, Some(c1_nulls)));
+    let batch = RecordBatch::try_from_iter([("c1", c1 as _)]).unwrap();
+    do_bench(c, "bench_struct_list", &batch)
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    bench_integer(c);
+    bench_float(c);
+    bench_string(c);
+    bench_mixed(c);
+    bench_dict_array(c);
+    bench_struct(c);
+    bench_nullable_struct(c);
+    bench_list(c);
+    bench_nullable_list(c);
+    bench_struct_list(c);
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow/benches/lexsort.rs b/arrow/benches/lexsort.rs
new file mode 100644
index 000000000000..bd2db1e5022d
--- /dev/null
+++ b/arrow/benches/lexsort.rs
@@ -0,0 +1,162 @@
+// 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.
+
+use arrow::compute::{lexsort_to_indices, SortColumn};
+use arrow::row::{RowConverter, SortField};
+use arrow::util::bench_util::{
+    create_dict_from_values, create_primitive_array, create_string_array_with_len,
+};
+use arrow_array::types::Int32Type;
+use arrow_array::{Array, ArrayRef, UInt32Array};
+use criterion::{criterion_group, criterion_main, Criterion};
+use std::sync::Arc;
+
+#[derive(Copy, Clone)]
+enum Column {
+    RequiredI32,
+    OptionalI32,
+    Required16CharString,
+    Optional16CharString,
+    Optional50CharString,
+    Optional100Value50CharStringDict,
+}
+
+impl std::fmt::Debug for Column {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let s = match self {
+            Column::RequiredI32 => "i32",
+            Column::OptionalI32 => "i32_opt",
+            Column::Required16CharString => "str(16)",
+            Column::Optional16CharString => "str_opt(16)",
+            Column::Optional50CharString => "str_opt(50)",
+            Column::Optional100Value50CharStringDict => "dict(100,str_opt(50))",
+        };
+        f.write_str(s)
+    }
+}
+
+impl Column {
+    fn generate(self, size: usize) -> ArrayRef {
+        match self {
+            Column::RequiredI32 => Arc::new(create_primitive_array::<Int32Type>(size, 0.)),
+            Column::OptionalI32 => Arc::new(create_primitive_array::<Int32Type>(size, 0.2)),
+            Column::Required16CharString => {
+                Arc::new(create_string_array_with_len::<i32>(size, 0., 16))
+            }
+            Column::Optional16CharString => {
+                Arc::new(create_string_array_with_len::<i32>(size, 0.2, 16))
+            }
+            Column::Optional50CharString => {
+                Arc::new(create_string_array_with_len::<i32>(size, 0., 50))
+            }
+            Column::Optional100Value50CharStringDict => {
+                Arc::new(create_dict_from_values::<Int32Type>(
+                    size,
+                    0.1,
+                    &create_string_array_with_len::<i32>(100, 0., 50),
+                ))
+            }
+        }
+    }
+}
+
+fn do_bench(c: &mut Criterion, columns: &[Column], len: usize) {
+    let arrays: Vec<_> = columns.iter().map(|x| x.generate(len)).collect();
+    let sort_columns: Vec<_> = arrays
+        .iter()
+        .cloned()
+        .map(|values| SortColumn {
+            values,
+            options: None,
+        })
+        .collect();
+
+    c.bench_function(&format!("lexsort_to_indices({columns:?}): {len}"), |b| {
+        b.iter(|| criterion::black_box(lexsort_to_indices(&sort_columns, None).unwrap()))
+    });
+
+    c.bench_function(&format!("lexsort_rows({columns:?}): {len}"), |b| {
+        b.iter(|| {
+            criterion::black_box({
+                let fields = arrays
+                    .iter()
+                    .map(|a| SortField::new(a.data_type().clone()))
+                    .collect();
+                let converter = RowConverter::new(fields).unwrap();
+                let rows = converter.convert_columns(&arrays).unwrap();
+                let mut sort: Vec<_> = rows.iter().enumerate().collect();
+                sort.sort_unstable_by(|(_, a), (_, b)| a.cmp(b));
+                UInt32Array::from_iter_values(sort.iter().map(|(i, _)| *i as u32))
+            })
+        })
+    });
+}
+
+fn add_benchmark(c: &mut Criterion) {
+    let cases: &[&[Column]] = &[
+        &[Column::RequiredI32, Column::OptionalI32],
+        &[Column::RequiredI32, Column::Optional16CharString],
+        &[Column::RequiredI32, Column::Required16CharString],
+        &[Column::Optional16CharString, Column::Required16CharString],
+        &[
+            Column::Optional16CharString,
+            Column::Optional50CharString,
+            Column::Required16CharString,
+        ],
+        &[
+            Column::Optional16CharString,
+            Column::Required16CharString,
+            Column::Optional16CharString,
+            Column::Optional16CharString,
+            Column::Optional16CharString,
+        ],
+        &[
+            Column::OptionalI32,
+            Column::Optional100Value50CharStringDict,
+        ],
+        &[
+            Column::Optional100Value50CharStringDict,
+            Column::Optional100Value50CharStringDict,
+        ],
+        &[
+            Column::Optional100Value50CharStringDict,
+            Column::Optional100Value50CharStringDict,
+            Column::Optional100Value50CharStringDict,
+            Column::Required16CharString,
+        ],
+        &[
+            Column::Optional100Value50CharStringDict,
+            Column::Optional100Value50CharStringDict,
+            Column::Optional100Value50CharStringDict,
+            Column::Optional50CharString,
+        ],
+        &[
+            Column::Optional100Value50CharStringDict,
+            Column::Optional100Value50CharStringDict,
+            Column::Optional100Value50CharStringDict,
+            Column::Optional50CharString,
+        ],
+    ];
+
+    for case in cases {
+        do_bench(c, case, 4096);
+        do_bench(c, case, 4096 * 8);
+    }
+}
+
+criterion_group!(benches, add_benchmark);
+criterion_main!(benches);
diff --git a/arrow/benches/mutable_array.rs b/arrow/benches/mutable_array.rs
index 3a42ec1be3c3..b04e5cd84926 100644
--- a/arrow/benches/mutable_array.rs
+++ b/arrow/benches/mutable_array.rs
@@ -39,7 +39,8 @@ fn create_slices(size: usize) -> Vec<(usize, usize)> {
 }
 
 fn bench<T: Array>(v1: &T, slices: &[(usize, usize)]) {
-    let mut mutable = MutableArrayData::new(vec![v1.data_ref()], false, 5);
+    let data = v1.to_data();
+    let mut mutable = MutableArrayData::new(vec![&data], false, 5);
     for (start, end) in slices {
         mutable.extend(0, *start, *end)
     }
diff --git a/arrow/benches/partition_kernels.rs b/arrow/benches/partition_kernels.rs
index ae55fbdad22c..85cafbe47a11 100644
--- a/arrow/benches/partition_kernels.rs
+++ b/arrow/benches/partition_kernels.rs
@@ -20,13 +20,13 @@ extern crate criterion;
 use criterion::Criterion;
 use std::sync::Arc;
 extern crate arrow;
-use arrow::compute::kernels::partition::lexicographical_partition_ranges;
 use arrow::compute::kernels::sort::{lexsort, SortColumn};
 use arrow::util::bench_util::*;
 use arrow::{
     array::*,
     datatypes::{ArrowPrimitiveType, Float64Type, UInt8Type},
 };
+use arrow_ord::partition::partition;
 use rand::distributions::{Distribution, Standard};
 use std::iter;
 
@@ -40,19 +40,7 @@ where
 }
 
 fn bench_partition(sorted_columns: &[ArrayRef]) {
-    let columns = sorted_columns
-        .iter()
-        .map(|arr| SortColumn {
-            values: arr.clone(),
-            options: None,
-        })
-        .collect::<Vec<_>>();
-
-    criterion::black_box(
-        lexicographical_partition_ranges(&columns)
-            .unwrap()
-            .collect::<Vec<_>>(),
-    );
+    criterion::black_box(partition(sorted_columns).unwrap().ranges());
 }
 
 fn create_sorted_low_cardinality_data(length: usize) -> Vec<ArrayRef> {
@@ -109,37 +97,34 @@ fn create_sorted_data(pow: u32, with_nulls: bool) -> Vec<ArrayRef> {
 
 fn add_benchmark(c: &mut Criterion) {
     let sorted_columns = create_sorted_data(10, false);
-    c.bench_function("lexicographical_partition_ranges(u8) 2^10", |b| {
+    c.bench_function("partition(u8) 2^10", |b| {
         b.iter(|| bench_partition(&sorted_columns))
     });
 
     let sorted_columns = create_sorted_data(12, false);
-    c.bench_function("lexicographical_partition_ranges(u8) 2^12", |b| {
+    c.bench_function("partition(u8) 2^12", |b| {
         b.iter(|| bench_partition(&sorted_columns))
     });
 
     let sorted_columns = create_sorted_data(10, true);
-    c.bench_function(
-        "lexicographical_partition_ranges(u8) 2^10 with nulls",
-        |b| b.iter(|| bench_partition(&sorted_columns)),
-    );
+    c.bench_function("partition(u8) 2^10 with nulls", |b| {
+        b.iter(|| bench_partition(&sorted_columns))
+    });
 
     let sorted_columns = create_sorted_data(12, true);
-    c.bench_function(
-        "lexicographical_partition_ranges(u8) 2^12 with nulls",
-        |b| b.iter(|| bench_partition(&sorted_columns)),
-    );
+    c.bench_function("partition(u8) 2^12 with nulls", |b| {
+        b.iter(|| bench_partition(&sorted_columns))
+    });
 
     let sorted_columns = create_sorted_float_data(10, false);
-    c.bench_function("lexicographical_partition_ranges(f64) 2^10", |b| {
+    c.bench_function("partition(f64) 2^10", |b| {
         b.iter(|| bench_partition(&sorted_columns))
     });
 
     let sorted_columns = create_sorted_low_cardinality_data(1024);
-    c.bench_function(
-        "lexicographical_partition_ranges(low cardinality) 1024",
-        |b| b.iter(|| bench_partition(&sorted_columns)),
-    );
+    c.bench_function("partition(low cardinality) 1024", |b| {
+        b.iter(|| bench_partition(&sorted_columns))
+    });
 }
 
 criterion_group!(benches, add_benchmark);
diff --git a/arrow/benches/primitive_run_accessor.rs b/arrow/benches/primitive_run_accessor.rs
new file mode 100644
index 000000000000..10c1e9ff39a9
--- /dev/null
+++ b/arrow/benches/primitive_run_accessor.rs
@@ -0,0 +1,54 @@
+// 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.
+
+use arrow::datatypes::Int32Type;
+use arrow::{array::PrimitiveArray, util::bench_util::create_primitive_run_array};
+use arrow_array::ArrayAccessor;
+use criterion::{criterion_group, criterion_main, Criterion};
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("primitive_run_accessor");
+
+    let mut do_bench = |physical_array_len: usize, logical_array_len: usize| {
+        group.bench_function(
+            format!("(run_array_len:{logical_array_len}, physical_array_len:{physical_array_len})"),
+            |b| {
+                let run_array = create_primitive_run_array::<Int32Type, Int32Type>(
+                    logical_array_len,
+                    physical_array_len,
+                );
+                let typed = run_array.downcast::<PrimitiveArray<Int32Type>>().unwrap();
+                b.iter(|| {
+                    for i in 0..logical_array_len {
+                        let _ = unsafe { typed.value_unchecked(i) };
+                    }
+                })
+            },
+        );
+    };
+
+    do_bench(128, 512);
+    do_bench(256, 1024);
+    do_bench(512, 2048);
+    do_bench(1024, 4096);
+    do_bench(2048, 8192);
+
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow/benches/primitive_run_take.rs b/arrow/benches/primitive_run_take.rs
new file mode 100644
index 000000000000..c10c16bfee3a
--- /dev/null
+++ b/arrow/benches/primitive_run_take.rs
@@ -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.
+
+use arrow::array::UInt32Builder;
+use arrow::compute::take;
+use arrow::datatypes::{Int32Type, Int64Type};
+use arrow::util::bench_util::*;
+use arrow::util::test_util::seedable_rng;
+use arrow_array::UInt32Array;
+use criterion::{criterion_group, criterion_main, Criterion};
+use rand::Rng;
+
+fn create_random_index(size: usize, null_density: f32, max_value: usize) -> UInt32Array {
+    let mut rng = seedable_rng();
+    let mut builder = UInt32Builder::with_capacity(size);
+    for _ in 0..size {
+        if rng.gen::<f32>() < null_density {
+            builder.append_null();
+        } else {
+            let value = rng.gen_range::<u32, _>(0u32..max_value as u32);
+            builder.append_value(value);
+        }
+    }
+    builder.finish()
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("primitive_run_take");
+
+    let mut do_bench = |physical_array_len: usize, logical_array_len: usize, take_len: usize| {
+        let run_array = create_primitive_run_array::<Int32Type, Int64Type>(
+            logical_array_len,
+            physical_array_len,
+        );
+        let indices = create_random_index(take_len, 0.0, logical_array_len);
+        group.bench_function(
+            format!(
+                "(run_array_len:{logical_array_len}, physical_array_len:{physical_array_len}, take_len:{take_len})"),
+            |b| {
+                b.iter(|| {
+                    criterion::black_box(take(&run_array, &indices, None).unwrap());
+                })
+            },
+        );
+    };
+
+    do_bench(64, 512, 512);
+    do_bench(128, 512, 512);
+
+    do_bench(256, 1024, 512);
+    do_bench(256, 1024, 1024);
+
+    do_bench(512, 2048, 512);
+    do_bench(512, 2048, 1024);
+
+    do_bench(1024, 4096, 512);
+    do_bench(1024, 4096, 1024);
+
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow/benches/regexp_kernels.rs b/arrow/benches/regexp_kernels.rs
new file mode 100644
index 000000000000..d5ffbcb997ff
--- /dev/null
+++ b/arrow/benches/regexp_kernels.rs
@@ -0,0 +1,51 @@
+// 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.
+
+#[macro_use]
+extern crate criterion;
+use criterion::Criterion;
+
+extern crate arrow;
+
+use arrow::array::*;
+use arrow::compute::kernels::regexp::*;
+use arrow::util::bench_util::*;
+
+fn bench_regexp(arr: &GenericStringArray<i32>, regex_array: &dyn Datum) {
+    regexp_match(criterion::black_box(arr), regex_array, None).unwrap();
+}
+
+fn add_benchmark(c: &mut Criterion) {
+    let size = 65536;
+    let val_len = 1000;
+
+    let arr_string = create_string_array_with_len::<i32>(size, 0.0, val_len);
+    let pattern_values = vec![r".*-(\d*)-.*"; size];
+    let pattern = GenericStringArray::<i32>::from(pattern_values);
+
+    c.bench_function("regexp", |b| b.iter(|| bench_regexp(&arr_string, &pattern)));
+
+    let pattern_values = vec![r".*-(\d*)-.*"];
+    let pattern = Scalar::new(GenericStringArray::<i32>::from(pattern_values));
+
+    c.bench_function("regexp scalar", |b| {
+        b.iter(|| bench_regexp(&arr_string, &pattern))
+    });
+}
+
+criterion_group!(benches, add_benchmark);
+criterion_main!(benches);
diff --git a/arrow/benches/row_format.rs b/arrow/benches/row_format.rs
new file mode 100644
index 000000000000..cb7455939e0b
--- /dev/null
+++ b/arrow/benches/row_format.rs
@@ -0,0 +1,127 @@
+// 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.
+
+#[macro_use]
+extern crate criterion;
+extern crate core;
+
+use arrow::array::ArrayRef;
+use arrow::datatypes::{Int64Type, UInt64Type};
+use arrow::row::{RowConverter, SortField};
+use arrow::util::bench_util::{
+    create_dict_from_values, create_primitive_array, create_string_array_with_len,
+    create_string_dict_array,
+};
+use arrow_array::types::Int32Type;
+use arrow_array::Array;
+use criterion::{black_box, Criterion};
+use std::sync::Arc;
+
+fn do_bench(c: &mut Criterion, name: &str, cols: Vec<ArrayRef>) {
+    let fields: Vec<_> = cols
+        .iter()
+        .map(|x| SortField::new(x.data_type().clone()))
+        .collect();
+
+    c.bench_function(&format!("convert_columns {name}"), |b| {
+        b.iter(|| {
+            let converter = RowConverter::new(fields.clone()).unwrap();
+            black_box(converter.convert_columns(&cols).unwrap())
+        });
+    });
+
+    let converter = RowConverter::new(fields).unwrap();
+    let rows = converter.convert_columns(&cols).unwrap();
+    // using a pre-prepared row converter should be faster than the first time
+    c.bench_function(&format!("convert_columns_prepared {name}"), |b| {
+        b.iter(|| black_box(converter.convert_columns(&cols).unwrap()));
+    });
+
+    c.bench_function(&format!("convert_rows {name}"), |b| {
+        b.iter(|| black_box(converter.convert_rows(&rows).unwrap()));
+    });
+}
+
+fn row_bench(c: &mut Criterion) {
+    let cols = vec![Arc::new(create_primitive_array::<UInt64Type>(4096, 0.)) as ArrayRef];
+    do_bench(c, "4096 u64(0)", cols);
+
+    let cols = vec![Arc::new(create_primitive_array::<Int64Type>(4096, 0.)) as ArrayRef];
+    do_bench(c, "4096 i64(0)", cols);
+
+    let cols = vec![Arc::new(create_string_array_with_len::<i32>(4096, 0., 10)) as ArrayRef];
+    do_bench(c, "4096 string(10, 0)", cols);
+
+    let cols = vec![Arc::new(create_string_array_with_len::<i32>(4096, 0., 30)) as ArrayRef];
+    do_bench(c, "4096 string(30, 0)", cols);
+
+    let cols = vec![Arc::new(create_string_array_with_len::<i32>(4096, 0., 100)) as ArrayRef];
+    do_bench(c, "4096 string(100, 0)", cols);
+
+    let cols = vec![Arc::new(create_string_array_with_len::<i32>(4096, 0.5, 100)) as ArrayRef];
+    do_bench(c, "4096 string(100, 0.5)", cols);
+
+    let cols = vec![Arc::new(create_string_dict_array::<Int32Type>(4096, 0., 10)) as ArrayRef];
+    do_bench(c, "4096 string_dictionary(10, 0)", cols);
+
+    let cols = vec![Arc::new(create_string_dict_array::<Int32Type>(4096, 0., 30)) as ArrayRef];
+    do_bench(c, "4096 string_dictionary(30, 0)", cols);
+
+    let cols = vec![Arc::new(create_string_dict_array::<Int32Type>(4096, 0., 100)) as ArrayRef];
+    do_bench(c, "4096 string_dictionary(100, 0)", cols.clone());
+
+    let cols = vec![Arc::new(create_string_dict_array::<Int32Type>(4096, 0.5, 100)) as ArrayRef];
+    do_bench(c, "4096 string_dictionary(100, 0.5)", cols.clone());
+
+    let values = create_string_array_with_len::<i32>(10, 0., 10);
+    let dict = create_dict_from_values::<Int32Type>(4096, 0., &values);
+    let cols = vec![Arc::new(dict) as ArrayRef];
+    do_bench(c, "4096 string_dictionary_low_cardinality(10, 0)", cols);
+
+    let values = create_string_array_with_len::<i32>(10, 0., 30);
+    let dict = create_dict_from_values::<Int32Type>(4096, 0., &values);
+    let cols = vec![Arc::new(dict) as ArrayRef];
+    do_bench(c, "4096 string_dictionary_low_cardinality(30, 0)", cols);
+
+    let values = create_string_array_with_len::<i32>(10, 0., 100);
+    let dict = create_dict_from_values::<Int32Type>(4096, 0., &values);
+    let cols = vec![Arc::new(dict) as ArrayRef];
+    do_bench(c, "4096 string_dictionary_low_cardinality(100, 0)", cols);
+
+    let cols = vec![
+        Arc::new(create_string_array_with_len::<i32>(4096, 0.5, 20)) as ArrayRef,
+        Arc::new(create_string_array_with_len::<i32>(4096, 0., 30)) as ArrayRef,
+        Arc::new(create_string_array_with_len::<i32>(4096, 0., 100)) as ArrayRef,
+        Arc::new(create_primitive_array::<Int64Type>(4096, 0.)) as ArrayRef,
+    ];
+    do_bench(
+        c,
+        "4096 string(20, 0.5), string(30, 0), string(100, 0), i64(0)",
+        cols,
+    );
+
+    let cols = vec![
+        Arc::new(create_string_dict_array::<Int32Type>(4096, 0.5, 20)) as ArrayRef,
+        Arc::new(create_string_dict_array::<Int32Type>(4096, 0., 30)) as ArrayRef,
+        Arc::new(create_string_dict_array::<Int32Type>(4096, 0., 100)) as ArrayRef,
+        Arc::new(create_primitive_array::<Int64Type>(4096, 0.)) as ArrayRef,
+    ];
+    do_bench(c, "4096 4096 string_dictionary(20, 0.5), string_dictionary(30, 0), string_dictionary(100, 0), i64(0)", cols);
+}
+
+criterion_group!(benches, row_bench);
+criterion_main!(benches);
diff --git a/arrow/benches/sort_kernel.rs b/arrow/benches/sort_kernel.rs
index f9f5f24c15a6..b6578d8d8026 100644
--- a/arrow/benches/sort_kernel.rs
+++ b/arrow/benches/sort_kernel.rs
@@ -17,15 +17,17 @@
 
 #[macro_use]
 extern crate criterion;
-use criterion::Criterion;
+use criterion::{black_box, Criterion};
 
 use std::sync::Arc;
 
 extern crate arrow;
 
-use arrow::compute::kernels::sort::{lexsort, SortColumn};
+use arrow::compute::{lexsort, sort, sort_to_indices, SortColumn};
+use arrow::datatypes::{Int16Type, Int32Type};
 use arrow::util::bench_util::*;
 use arrow::{array::*, datatypes::Float32Type};
+use arrow_ord::rank::rank;
 
 fn create_f32_array(size: usize, with_nulls: bool) -> ArrayRef {
     let null_density = if with_nulls { 0.5 } else { 0.0 };
@@ -40,7 +42,11 @@ fn create_bool_array(size: usize, with_nulls: bool) -> ArrayRef {
     Arc::new(array)
 }
 
-fn bench_sort(array_a: &ArrayRef, array_b: &ArrayRef, limit: Option<usize>) {
+fn bench_sort(array: &dyn Array) {
+    black_box(sort(array, None).unwrap());
+}
+
+fn bench_lexsort(array_a: &ArrayRef, array_b: &ArrayRef, limit: Option<usize>) {
     let columns = vec![
         SortColumn {
             values: array_a.clone(),
@@ -52,88 +58,180 @@ fn bench_sort(array_a: &ArrayRef, array_b: &ArrayRef, limit: Option<usize>) {
         },
     ];
 
-    criterion::black_box(lexsort(&columns, limit).unwrap());
+    black_box(lexsort(&columns, limit).unwrap());
+}
+
+fn bench_sort_to_indices(array: &dyn Array, limit: Option<usize>) {
+    black_box(sort_to_indices(array, None, limit).unwrap());
 }
 
 fn add_benchmark(c: &mut Criterion) {
-    let arr_a = create_f32_array(2u64.pow(10) as usize, false);
-    let arr_b = create_f32_array(2u64.pow(10) as usize, false);
+    let arr = create_primitive_array::<Int32Type>(2usize.pow(10), 0.0);
+    c.bench_function("sort i32 2^10", |b| b.iter(|| bench_sort(&arr)));
+    c.bench_function("sort i32 to indices 2^10", |b| {
+        b.iter(|| bench_sort_to_indices(&arr, None))
+    });
+
+    let arr = create_primitive_array::<Int32Type>(2usize.pow(12), 0.0);
+    c.bench_function("sort i32 2^12", |b| b.iter(|| bench_sort(&arr)));
+    c.bench_function("sort i32 to indices 2^12", |b| {
+        b.iter(|| bench_sort_to_indices(&arr, None))
+    });
+
+    let arr = create_primitive_array::<Int32Type>(2usize.pow(10), 0.5);
+    c.bench_function("sort i32 nulls 2^10", |b| b.iter(|| bench_sort(&arr)));
+    c.bench_function("sort i32 nulls to indices 2^10", |b| {
+        b.iter(|| bench_sort_to_indices(&arr, None))
+    });
+
+    let arr = create_primitive_array::<Int32Type>(2usize.pow(12), 0.5);
+    c.bench_function("sort i32 nulls 2^12", |b| b.iter(|| bench_sort(&arr)));
+    c.bench_function("sort i32 nulls to indices 2^12", |b| {
+        b.iter(|| bench_sort_to_indices(&arr, None))
+    });
+
+    let arr = create_f32_array(2_usize.pow(12), false);
+    c.bench_function("sort f32 2^12", |b| b.iter(|| bench_sort(&arr)));
+    c.bench_function("sort f32 to indices 2^12", |b| {
+        b.iter(|| bench_sort_to_indices(&arr, None))
+    });
 
-    c.bench_function("sort 2^10", |b| b.iter(|| bench_sort(&arr_a, &arr_b, None)));
+    let arr = create_f32_array(2usize.pow(12), true);
+    c.bench_function("sort f32 nulls 2^12", |b| b.iter(|| bench_sort(&arr)));
+    c.bench_function("sort f32 nulls to indices 2^12", |b| {
+        b.iter(|| bench_sort_to_indices(&arr, None))
+    });
 
-    let arr_a = create_f32_array(2u64.pow(12) as usize, false);
-    let arr_b = create_f32_array(2u64.pow(12) as usize, false);
+    let arr = create_string_array_with_len::<i32>(2usize.pow(12), 0.0, 10);
+    c.bench_function("sort string[10] to indices 2^12", |b| {
+        b.iter(|| bench_sort_to_indices(&arr, None))
+    });
 
-    c.bench_function("sort 2^12", |b| b.iter(|| bench_sort(&arr_a, &arr_b, None)));
+    let arr = create_string_array_with_len::<i32>(2usize.pow(12), 0.5, 10);
+    c.bench_function("sort string[10] nulls to indices 2^12", |b| {
+        b.iter(|| bench_sort_to_indices(&arr, None))
+    });
 
-    let arr_a = create_f32_array(2u64.pow(10) as usize, true);
-    let arr_b = create_f32_array(2u64.pow(10) as usize, true);
+    let arr = create_string_dict_array::<Int32Type>(2usize.pow(12), 0.0, 10);
+    c.bench_function("sort string[10] dict to indices 2^12", |b| {
+        b.iter(|| bench_sort_to_indices(&arr, None))
+    });
 
-    c.bench_function("sort nulls 2^10", |b| {
-        b.iter(|| bench_sort(&arr_a, &arr_b, None))
+    let arr = create_string_dict_array::<Int32Type>(2usize.pow(12), 0.5, 10);
+    c.bench_function("sort string[10] dict nulls to indices 2^12", |b| {
+        b.iter(|| bench_sort_to_indices(&arr, None))
     });
 
-    let arr_a = create_f32_array(2u64.pow(12) as usize, true);
-    let arr_b = create_f32_array(2u64.pow(12) as usize, true);
+    let run_encoded_array =
+        create_primitive_run_array::<Int16Type, Int32Type>(2usize.pow(12), 2usize.pow(10));
+
+    c.bench_function("sort primitive run 2^12", |b| {
+        b.iter(|| bench_sort(&run_encoded_array))
+    });
 
-    c.bench_function("sort nulls 2^12", |b| {
-        b.iter(|| bench_sort(&arr_a, &arr_b, None))
+    c.bench_function("sort primitive run to indices 2^12", |b| {
+        b.iter(|| bench_sort_to_indices(&run_encoded_array, None))
     });
 
-    let arr_a = create_bool_array(2u64.pow(12) as usize, false);
-    let arr_b = create_bool_array(2u64.pow(12) as usize, false);
-    c.bench_function("bool sort 2^12", |b| {
-        b.iter(|| bench_sort(&arr_a, &arr_b, None))
+    let arr_a = create_f32_array(2usize.pow(10), false);
+    let arr_b = create_f32_array(2usize.pow(10), false);
+
+    c.bench_function("lexsort (f32, f32) 2^10", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, None))
     });
 
-    let arr_a = create_bool_array(2u64.pow(12) as usize, true);
-    let arr_b = create_bool_array(2u64.pow(12) as usize, true);
-    c.bench_function("bool sort nulls 2^12", |b| {
-        b.iter(|| bench_sort(&arr_a, &arr_b, None))
+    let arr_a = create_f32_array(2usize.pow(12), false);
+    let arr_b = create_f32_array(2usize.pow(12), false);
+
+    c.bench_function("lexsort (f32, f32) 2^12", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, None))
     });
 
-    // with limit
-    {
-        let arr_a = create_f32_array(2u64.pow(12) as usize, false);
-        let arr_b = create_f32_array(2u64.pow(12) as usize, false);
-        c.bench_function("sort 2^12 limit 10", |b| {
-            b.iter(|| bench_sort(&arr_a, &arr_b, Some(10)))
-        });
+    let arr_a = create_f32_array(2usize.pow(10), true);
+    let arr_b = create_f32_array(2usize.pow(10), true);
 
-        let arr_a = create_f32_array(2u64.pow(12) as usize, false);
-        let arr_b = create_f32_array(2u64.pow(12) as usize, false);
-        c.bench_function("sort 2^12 limit 100", |b| {
-            b.iter(|| bench_sort(&arr_a, &arr_b, Some(100)))
-        });
+    c.bench_function("lexsort (f32, f32) nulls 2^10", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, None))
+    });
 
-        let arr_a = create_f32_array(2u64.pow(12) as usize, false);
-        let arr_b = create_f32_array(2u64.pow(12) as usize, false);
-        c.bench_function("sort 2^12 limit 1000", |b| {
-            b.iter(|| bench_sort(&arr_a, &arr_b, Some(1000)))
-        });
+    let arr_a = create_f32_array(2usize.pow(12), true);
+    let arr_b = create_f32_array(2usize.pow(12), true);
 
-        let arr_a = create_f32_array(2u64.pow(12) as usize, false);
-        let arr_b = create_f32_array(2u64.pow(12) as usize, false);
-        c.bench_function("sort 2^12 limit 2^12", |b| {
-            b.iter(|| bench_sort(&arr_a, &arr_b, Some(2u64.pow(12) as usize)))
-        });
+    c.bench_function("lexsort (f32, f32) nulls 2^12", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, None))
+    });
 
-        let arr_a = create_f32_array(2u64.pow(12) as usize, true);
-        let arr_b = create_f32_array(2u64.pow(12) as usize, true);
+    let arr_a = create_bool_array(2usize.pow(12), false);
+    let arr_b = create_bool_array(2usize.pow(12), false);
+    c.bench_function("lexsort (bool, bool) 2^12", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, None))
+    });
 
-        c.bench_function("sort nulls 2^12 limit 10", |b| {
-            b.iter(|| bench_sort(&arr_a, &arr_b, Some(10)))
-        });
-        c.bench_function("sort nulls 2^12 limit 100", |b| {
-            b.iter(|| bench_sort(&arr_a, &arr_b, Some(100)))
-        });
-        c.bench_function("sort nulls 2^12 limit 1000", |b| {
-            b.iter(|| bench_sort(&arr_a, &arr_b, Some(1000)))
-        });
-        c.bench_function("sort nulls 2^12 limit 2^12", |b| {
-            b.iter(|| bench_sort(&arr_a, &arr_b, Some(2u64.pow(12) as usize)))
-        });
-    }
+    let arr_a = create_bool_array(2usize.pow(12), true);
+    let arr_b = create_bool_array(2usize.pow(12), true);
+    c.bench_function("lexsort (bool, bool) nulls 2^12", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, None))
+    });
+
+    let arr_a = create_f32_array(2usize.pow(12), false);
+    let arr_b = create_f32_array(2usize.pow(12), false);
+    c.bench_function("lexsort (f32, f32) 2^12 limit 10", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, Some(10)))
+    });
+
+    let arr_a = create_f32_array(2usize.pow(12), false);
+    let arr_b = create_f32_array(2usize.pow(12), false);
+    c.bench_function("lexsort (f32, f32) 2^12 limit 100", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, Some(100)))
+    });
+
+    let arr_a = create_f32_array(2usize.pow(12), false);
+    let arr_b = create_f32_array(2usize.pow(12), false);
+    c.bench_function("lexsort (f32, f32) 2^12 limit 1000", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, Some(1000)))
+    });
+
+    let arr_a = create_f32_array(2usize.pow(12), false);
+    let arr_b = create_f32_array(2usize.pow(12), false);
+    c.bench_function("lexsort (f32, f32) 2^12 limit 2^12", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, Some(2usize.pow(12))))
+    });
+
+    let arr_a = create_f32_array(2usize.pow(12), true);
+    let arr_b = create_f32_array(2usize.pow(12), true);
+
+    c.bench_function("lexsort (f32, f32) nulls 2^12 limit 10", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, Some(10)))
+    });
+    c.bench_function("lexsort (f32, f32) nulls 2^12 limit 100", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, Some(100)))
+    });
+    c.bench_function("lexsort (f32, f32) nulls 2^12 limit 1000", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, Some(1000)))
+    });
+    c.bench_function("lexsort (f32, f32) nulls 2^12 limit 2^12", |b| {
+        b.iter(|| bench_lexsort(&arr_a, &arr_b, Some(2usize.pow(12))))
+    });
+
+    let arr = create_f32_array(2usize.pow(12), false);
+    c.bench_function("rank f32 2^12", |b| {
+        b.iter(|| black_box(rank(&arr, None).unwrap()))
+    });
+
+    let arr = create_f32_array(2usize.pow(12), true);
+    c.bench_function("rank f32 nulls 2^12", |b| {
+        b.iter(|| black_box(rank(&arr, None).unwrap()))
+    });
+
+    let arr = create_string_array_with_len::<i32>(2usize.pow(12), 0.0, 10);
+    c.bench_function("rank string[10] 2^12", |b| {
+        b.iter(|| black_box(rank(&arr, None).unwrap()))
+    });
+
+    let arr = create_string_array_with_len::<i32>(2usize.pow(12), 0.5, 10);
+    c.bench_function("rank string[10] nulls 2^12", |b| {
+        b.iter(|| black_box(rank(&arr, None).unwrap()))
+    });
 }
 
 criterion_group!(benches, add_benchmark);
diff --git a/arrow/benches/string_dictionary_builder.rs b/arrow/benches/string_dictionary_builder.rs
index bc014bec155d..424400674cd8 100644
--- a/arrow/benches/string_dictionary_builder.rs
+++ b/arrow/benches/string_dictionary_builder.rs
@@ -15,7 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::array::{Int32Builder, StringBuilder, StringDictionaryBuilder};
+use arrow::array::StringDictionaryBuilder;
+use arrow::datatypes::Int32Type;
 use criterion::{criterion_group, criterion_main, Criterion};
 use rand::{thread_rng, Rng};
 
@@ -36,16 +37,15 @@ fn criterion_benchmark(c: &mut Criterion) {
 
     let mut do_bench = |dict_size: usize, total_size: usize, key_len: usize| {
         group.bench_function(
-            format!(
-                "(dict_size:{}, len:{}, key_len: {})",
-                dict_size, total_size, key_len
-            ),
+            format!("(dict_size:{dict_size}, len:{total_size}, key_len: {key_len})"),
             |b| {
                 let strings = build_strings(dict_size, total_size, key_len);
                 b.iter(|| {
-                    let keys = Int32Builder::new(strings.len());
-                    let values = StringBuilder::new((key_len + 1) * dict_size);
-                    let mut builder = StringDictionaryBuilder::new(keys, values);
+                    let mut builder = StringDictionaryBuilder::<Int32Type>::with_capacity(
+                        strings.len(),
+                        key_len + 1,
+                        (key_len + 1) * dict_size,
+                    );
 
                     for val in &strings {
                         builder.append(val).unwrap();
diff --git a/arrow/benches/string_run_builder.rs b/arrow/benches/string_run_builder.rs
new file mode 100644
index 000000000000..b4457b74dada
--- /dev/null
+++ b/arrow/benches/string_run_builder.rs
@@ -0,0 +1,60 @@
+// 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.
+
+use arrow::array::StringRunBuilder;
+use arrow::datatypes::Int32Type;
+use arrow::util::bench_util::create_string_array_for_runs;
+use criterion::{criterion_group, criterion_main, Criterion};
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("string_run_builder");
+
+    let mut do_bench = |physical_array_len: usize, logical_array_len: usize, string_len: usize| {
+        group.bench_function(
+                format!(
+                    "(run_array_len:{logical_array_len}, physical_array_len:{physical_array_len}, string_len: {string_len})",
+                ),
+                |b| {
+                    let strings =
+                    create_string_array_for_runs(physical_array_len, logical_array_len, string_len);
+                    b.iter(|| {
+                        let mut builder = StringRunBuilder::<Int32Type>::with_capacity(
+                            physical_array_len,
+                            (string_len + 1) * physical_array_len,
+                        );
+
+                        for val in &strings {
+                            builder.append_value(val);
+                        }
+
+                        builder.finish();
+                    })
+                },
+            );
+    };
+
+    do_bench(20, 1000, 5);
+    do_bench(100, 1000, 5);
+    do_bench(100, 1000, 10);
+    do_bench(100, 10000, 10);
+    do_bench(100, 10000, 100);
+
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow/benches/string_run_iterator.rs b/arrow/benches/string_run_iterator.rs
new file mode 100644
index 000000000000..ac5cf7838408
--- /dev/null
+++ b/arrow/benches/string_run_iterator.rs
@@ -0,0 +1,82 @@
+// 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.
+
+use arrow::array::{Int32RunArray, StringArray, StringRunBuilder};
+use arrow::datatypes::Int32Type;
+use criterion::{criterion_group, criterion_main, Criterion};
+use rand::{thread_rng, Rng};
+
+fn build_strings_runs(
+    physical_array_len: usize,
+    logical_array_len: usize,
+    string_len: usize,
+) -> Int32RunArray {
+    let mut rng = thread_rng();
+    let run_len = logical_array_len / physical_array_len;
+    let mut values: Vec<String> = (0..physical_array_len)
+        .map(|_| (0..string_len).map(|_| rng.gen::<char>()).collect())
+        .flat_map(|s| std::iter::repeat(s).take(run_len))
+        .collect();
+    while values.len() < logical_array_len {
+        let last_val = values[values.len() - 1].clone();
+        values.push(last_val);
+    }
+    let mut builder = StringRunBuilder::<Int32Type>::with_capacity(
+        physical_array_len,
+        (string_len + 1) * physical_array_len,
+    );
+    builder.extend(values.into_iter().map(Some));
+
+    builder.finish()
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut group = c.benchmark_group("string_run_iterator");
+
+    let mut do_bench = |physical_array_len: usize, logical_array_len: usize, string_len: usize| {
+        group.bench_function(
+            format!(
+                "(run_array_len:{logical_array_len}, physical_array_len:{physical_array_len}, string_len: {string_len})"),
+            |b| {
+                let run_array =
+                    build_strings_runs(physical_array_len, logical_array_len, string_len);
+                let typed = run_array.downcast::<StringArray>().unwrap();
+                b.iter(|| {
+                    let iter = typed.into_iter();
+                    for _ in iter {}
+                })
+            },
+        );
+    };
+
+    do_bench(256, 1024, 5);
+    do_bench(256, 1024, 25);
+    do_bench(256, 1024, 100);
+
+    do_bench(512, 2048, 5);
+    do_bench(512, 2048, 25);
+    do_bench(512, 2048, 100);
+
+    do_bench(1024, 4096, 5);
+    do_bench(1024, 4096, 25);
+    do_bench(1024, 4096, 100);
+
+    group.finish();
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/arrow/benches/take_kernels.rs b/arrow/benches/take_kernels.rs
index 42b38b6e5d21..9c3f1eb40909 100644
--- a/arrow/benches/take_kernels.rs
+++ b/arrow/benches/take_kernels.rs
@@ -30,7 +30,7 @@ use arrow::{array::*, util::bench_util::*};
 
 fn create_random_index(size: usize, null_density: f32) -> UInt32Array {
     let mut rng = seedable_rng();
-    let mut builder = UInt32Builder::new(size);
+    let mut builder = UInt32Builder::with_capacity(size);
     for _ in 0..size {
         if rng.gen::<f32>() < null_density {
             builder.append_null();
@@ -47,20 +47,33 @@ fn bench_take(values: &dyn Array, indices: &UInt32Array) {
 }
 
 fn bench_take_bounds_check(values: &dyn Array, indices: &UInt32Array) {
-    criterion::black_box(
-        take(values, indices, Some(TakeOptions { check_bounds: true })).unwrap(),
-    );
+    criterion::black_box(take(values, indices, Some(TakeOptions { check_bounds: true })).unwrap());
 }
 
 fn add_benchmark(c: &mut Criterion) {
     let values = create_primitive_array::<Int32Type>(512, 0.0);
     let indices = create_random_index(512, 0.0);
     c.bench_function("take i32 512", |b| b.iter(|| bench_take(&values, &indices)));
+
     let values = create_primitive_array::<Int32Type>(1024, 0.0);
     let indices = create_random_index(1024, 0.0);
     c.bench_function("take i32 1024", |b| {
         b.iter(|| bench_take(&values, &indices))
     });
+    let indices = create_random_index(1024, 0.5);
+    c.bench_function("take i32 null indices 1024", |b| {
+        b.iter(|| bench_take(&values, &indices))
+    });
+
+    let values = create_primitive_array::<Int32Type>(1024, 0.5);
+    let indices = create_random_index(1024, 0.0);
+    c.bench_function("take i32 null values 1024", |b| {
+        b.iter(|| bench_take(&values, &indices))
+    });
+    let indices = create_random_index(1024, 0.5);
+    c.bench_function("take i32 null values null indices 1024", |b| {
+        b.iter(|| bench_take(&values, &indices))
+    });
 
     let values = create_primitive_array::<Int32Type>(512, 0.0);
     let indices = create_random_index(512, 0.0);
@@ -73,35 +86,32 @@ fn add_benchmark(c: &mut Criterion) {
         b.iter(|| bench_take_bounds_check(&values, &indices))
     });
 
-    let indices = create_random_index(512, 0.5);
-    c.bench_function("take i32 nulls 512", |b| {
-        b.iter(|| bench_take(&values, &indices))
-    });
-    let values = create_primitive_array::<Int32Type>(1024, 0.0);
-    let indices = create_random_index(1024, 0.5);
-    c.bench_function("take i32 nulls 1024", |b| {
-        b.iter(|| bench_take(&values, &indices))
-    });
-
     let values = create_boolean_array(512, 0.0, 0.5);
     let indices = create_random_index(512, 0.0);
     c.bench_function("take bool 512", |b| {
         b.iter(|| bench_take(&values, &indices))
     });
+
     let values = create_boolean_array(1024, 0.0, 0.5);
     let indices = create_random_index(1024, 0.0);
     c.bench_function("take bool 1024", |b| {
         b.iter(|| bench_take(&values, &indices))
     });
 
-    let values = create_boolean_array(512, 0.0, 0.5);
-    let indices = create_random_index(512, 0.5);
-    c.bench_function("take bool nulls 512", |b| {
+    let indices = create_random_index(1024, 0.5);
+    c.bench_function("take bool null indices 1024", |b| {
         b.iter(|| bench_take(&values, &indices))
     });
-    let values = create_boolean_array(1024, 0.0, 0.5);
+
+    let values = create_boolean_array(1024, 0.5, 0.5);
+    let indices = create_random_index(1024, 0.0);
+    c.bench_function("take bool null values 1024", |b| {
+        b.iter(|| bench_take(&values, &indices))
+    });
+
+    let values = create_boolean_array(1024, 0.5, 0.5);
     let indices = create_random_index(1024, 0.5);
-    c.bench_function("take bool nulls 1024", |b| {
+    c.bench_function("take bool null values null indices 1024", |b| {
         b.iter(|| bench_take(&values, &indices))
     });
 
@@ -128,7 +138,6 @@ fn add_benchmark(c: &mut Criterion) {
     });
 
     let values = create_string_array::<i32>(1024, 0.5);
-
     let indices = create_random_index(1024, 0.0);
     c.bench_function("take str null values 1024", |b| {
         b.iter(|| bench_take(&values, &indices))
@@ -139,6 +148,13 @@ fn add_benchmark(c: &mut Criterion) {
     c.bench_function("take str null values null indices 1024", |b| {
         b.iter(|| bench_take(&values, &indices))
     });
+
+    let values = create_primitive_run_array::<Int32Type, Int32Type>(1024, 512);
+    let indices = create_random_index(1024, 0.0);
+    c.bench_function(
+        "take primitive run logical len: 1024, physical len: 512, indices: 1024",
+        |b| b.iter(|| bench_take(&values, &indices)),
+    );
 }
 
 criterion_group!(benches, add_benchmark);
diff --git a/arrow/examples/README.md b/arrow/examples/README.md
index 41ffd823357d..7ec3b008b768 100644
--- a/arrow/examples/README.md
+++ b/arrow/examples/README.md
@@ -20,8 +20,8 @@
 # Examples
 
 - [`builders.rs`](builders.rs): Using the Builder API
-- `collect` (TODO): Using the `FromIter` API
+- [`collect.rs`](collect.rs): Using the `FromIter` API
 - [`dynamic_types.rs`](dynamic_types.rs):
-- [`read_csv.rs`](read_csv.rs): Reading CSV files with explict schema, pretty printing Arrays
+- [`read_csv.rs`](read_csv.rs): Reading CSV files with explicit schema, pretty printing Arrays
 - [`read_csv_infer_schema.rs`](read_csv_infer_schema.rs): Reading CSV files, pretty printing Arrays
 - [`tensor_builder.rs`](tensor_builder.rs): Using tensor builder
diff --git a/arrow/examples/builders.rs b/arrow/examples/builders.rs
index 45d92f54dd13..ad6b879642ab 100644
--- a/arrow/examples/builders.rs
+++ b/arrow/examples/builders.rs
@@ -15,8 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-///! Many builders are available to easily create different types of arrow arrays
-extern crate arrow;
+//! Many builders are available to easily create different types of arrow arrays
 
 use std::sync::Arc;
 
@@ -34,7 +33,7 @@ fn main() {
     // u64, i8, i16, i32, i64, f32, f64)
 
     // Create a new builder with a capacity of 100
-    let mut primitive_array_builder = Int32Builder::new(100);
+    let mut primitive_array_builder = Int32Builder::with_capacity(100);
 
     // Append an individual primitive value
     primitive_array_builder.append_value(55);
@@ -52,17 +51,16 @@ fn main() {
     // Build the `PrimitiveArray`
     let primitive_array = primitive_array_builder.finish();
     // Long arrays will have an ellipsis printed in the middle
-    println!("{:?}", primitive_array);
+    println!("{primitive_array:?}");
 
     // Arrays can also be built from `Vec<Option<T>>`. `None`
     // represents a null value in the array.
     let date_array: PrimitiveArray<Date64Type> =
         vec![Some(1550902545147), None, Some(1550902545147)].into();
-    println!("{:?}", date_array);
+    println!("{date_array:?}");
 
-    let time_array: PrimitiveArray<Time64NanosecondType> =
-        (0..100).collect::<Vec<i64>>().into();
-    println!("{:?}", time_array);
+    let time_array: PrimitiveArray<Time64NanosecondType> = (0..100).collect::<Vec<i64>>().into();
+    println!("{time_array:?}");
 
     // We can build arrays directly from the underlying buffers.
 
@@ -83,7 +81,7 @@ fn main() {
         .build()
         .unwrap();
     let binary_array = StringArray::from(array_data);
-    println!("{:?}", binary_array);
+    println!("{binary_array:?}");
 
     // ListArrays are similar to ByteArrays: they are arrays of other
     // arrays, where each child array is a slice of the underlying
@@ -99,8 +97,7 @@ fn main() {
     let value_offsets = Buffer::from(&[0, 3, 6, 8].to_byte_slice());
 
     // Construct a list array from the above two
-    let list_data_type =
-        DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
+    let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
     let list_data = ArrayData::builder(list_data_type)
         .len(3)
         .add_buffer(value_offsets)
@@ -109,7 +106,7 @@ fn main() {
         .unwrap();
     let list_array = ListArray::from(list_data);
 
-    println!("{:?}", list_array);
+    println!("{list_array:?}");
 
     // StructArrays are arrays of tuples, where each tuple element is
     // from a child array. (In other words, they're like zipping
@@ -119,14 +116,13 @@ fn main() {
     // helper, which takes the underlying arrays and field types.
     let struct_array = StructArray::from(vec![
         (
-            Field::new("b", DataType::Boolean, false),
-            Arc::new(BooleanArray::from(vec![false, false, true, true]))
-                as Arc<dyn Array>,
+            Arc::new(Field::new("b", DataType::Boolean, false)),
+            Arc::new(BooleanArray::from(vec![false, false, true, true])) as Arc<dyn Array>,
         ),
         (
-            Field::new("c", DataType::Int32, false),
+            Arc::new(Field::new("c", DataType::Int32, false)),
             Arc::new(Int32Array::from(vec![42, 28, 19, 31])),
         ),
     ]);
-    println!("{:?}", struct_array);
+    println!("{struct_array:?}");
 }
diff --git a/arrow/examples/collect.rs b/arrow/examples/collect.rs
new file mode 100644
index 000000000000..ced4640d600f
--- /dev/null
+++ b/arrow/examples/collect.rs
@@ -0,0 +1,87 @@
+// 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.
+
+//! `FromIterator` API is implemented for different array types to easily create them
+//! from values.
+
+use arrow::array::Array;
+use arrow_array::types::Int32Type;
+use arrow_array::{Float32Array, Int32Array, Int8Array, ListArray};
+
+fn main() {
+    // Primitive Arrays
+    //
+    // Primitive arrays are arrays of fixed-width primitive types (u8, u16, u32,
+    // u64, i8, i16, i32, i64, f32, f64, etc.)
+
+    // Create an Int8Array with 4 values
+    let array: Int8Array = vec![1, 2, 3, 4].into_iter().collect();
+    println!("{array:?}");
+
+    // Arrays can also be built from `Vec<Option<T>>`. `None`
+    // represents a null value in the array.
+    let array: Int8Array = vec![Some(1_i8), Some(2), None, Some(3)]
+        .into_iter()
+        .collect();
+    println!("{array:?}");
+    assert!(array.is_null(2));
+
+    let array: Float32Array = [Some(1.0_f32), Some(2.3), None].into_iter().collect();
+    println!("{array:?}");
+    assert_eq!(array.value(0), 1.0_f32);
+    assert_eq!(array.value(1), 2.3_f32);
+    assert!(array.is_null(2));
+
+    // Although not implementing `FromIterator`, ListArrays provides `from_iter_primitive`
+    // function to create ListArrays from `Vec<Option<Vec<Option<T>>>>`. The outer `None`
+    // represents a null list, the inner `None` represents a null value in a list.
+    let data = vec![
+        Some(vec![]),
+        None,
+        Some(vec![Some(3), None, Some(5), Some(19)]),
+        Some(vec![Some(6), Some(7)]),
+    ];
+    let list_array = ListArray::from_iter_primitive::<Int32Type, _, _>(data);
+
+    assert!(!list_array.is_valid(1));
+
+    let list0 = list_array.value(0);
+    let list2 = list_array.value(2);
+    let list3 = list_array.value(3);
+
+    assert_eq!(
+        &[] as &[i32],
+        list0
+            .as_any()
+            .downcast_ref::<Int32Array>()
+            .unwrap()
+            .values()
+    );
+    assert!(!list2
+        .as_any()
+        .downcast_ref::<Int32Array>()
+        .unwrap()
+        .is_valid(1));
+    assert_eq!(
+        &[6, 7],
+        list3
+            .as_any()
+            .downcast_ref::<Int32Array>()
+            .unwrap()
+            .values()
+    );
+}
diff --git a/arrow/examples/dynamic_types.rs b/arrow/examples/dynamic_types.rs
index eefbf6dcd4ff..4c01f0ea8c72 100644
--- a/arrow/examples/dynamic_types.rs
+++ b/arrow/examples/dynamic_types.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-///! This example demonstrates dealing with mixed types dynamically at runtime
+//! This example demonstrates dealing with mixed types dynamically at runtime
 use std::sync::Arc;
 
 extern crate arrow;
@@ -23,10 +23,10 @@ extern crate arrow;
 use arrow::array::*;
 use arrow::datatypes::*;
 use arrow::error::Result;
-use arrow::record_batch::*;
 
 #[cfg(feature = "prettyprint")]
 use arrow::util::pretty::print_batches;
+use arrow_schema::Fields;
 
 fn main() -> Result<()> {
     // define schema
@@ -34,11 +34,11 @@ fn main() -> Result<()> {
         Field::new("id", DataType::Int32, false),
         Field::new(
             "nested",
-            DataType::Struct(vec![
+            DataType::Struct(Fields::from(vec![
                 Field::new("a", DataType::Utf8, false),
                 Field::new("b", DataType::Float64, false),
                 Field::new("c", DataType::Float64, false),
-            ]),
+            ])),
             false,
         ),
     ]);
@@ -48,22 +48,21 @@ fn main() -> Result<()> {
 
     let nested = StructArray::from(vec![
         (
-            Field::new("a", DataType::Utf8, false),
+            Arc::new(Field::new("a", DataType::Utf8, false)),
             Arc::new(StringArray::from(vec!["a", "b", "c", "d", "e"])) as Arc<dyn Array>,
         ),
         (
-            Field::new("b", DataType::Float64, false),
+            Arc::new(Field::new("b", DataType::Float64, false)),
             Arc::new(Float64Array::from(vec![1.1, 2.2, 3.3, 4.4, 5.5])),
         ),
         (
-            Field::new("c", DataType::Float64, false),
+            Arc::new(Field::new("c", DataType::Float64, false)),
             Arc::new(Float64Array::from(vec![2.2, 3.3, 4.4, 5.5, 6.6])),
         ),
     ]);
 
     // build a record batch
-    let batch =
-        RecordBatch::try_new(Arc::new(schema), vec![Arc::new(id), Arc::new(nested)])?;
+    let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(id), Arc::new(nested)])?;
 
     print_batches(&[batch.clone()]).unwrap();
 
@@ -100,7 +99,7 @@ fn process(batch: &RecordBatch) {
         Arc::new(projected_schema),
         vec![
             id.clone(), // NOTE: this is cloning the Arc not the array data
-            Arc::new(Float64Array::from(nested_c.data().clone())),
+            Arc::new(Float64Array::from(nested_c.to_data())),
         ],
     )
     .unwrap();
diff --git a/arrow/examples/read_csv.rs b/arrow/examples/read_csv.rs
index 5ccf0c58a797..60545a6e52d8 100644
--- a/arrow/examples/read_csv.rs
+++ b/arrow/examples/read_csv.rs
@@ -20,30 +20,27 @@ extern crate arrow;
 use std::fs::File;
 use std::sync::Arc;
 
-#[cfg(feature = "csv")]
 use arrow::csv;
 use arrow::datatypes::{DataType, Field, Schema};
-#[cfg(feature = "prettyprint")]
 use arrow::util::pretty::print_batches;
 
 fn main() {
-    #[cfg(feature = "csv")]
-    {
-        let schema = Schema::new(vec![
-            Field::new("city", DataType::Utf8, false),
-            Field::new("lat", DataType::Float64, false),
-            Field::new("lng", DataType::Float64, false),
-        ]);
+    let schema = Schema::new(vec![
+        Field::new("city", DataType::Utf8, false),
+        Field::new("lat", DataType::Float64, false),
+        Field::new("lng", DataType::Float64, false),
+    ]);
 
-        let path = format!("{}/test/data/uk_cities.csv", env!("CARGO_MANIFEST_DIR"));
-        let file = File::open(path).unwrap();
+    let path = format!(
+        "{}/../arrow-csv/test/data/uk_cities.csv",
+        env!("CARGO_MANIFEST_DIR")
+    );
+    let file = File::open(path).unwrap();
 
-        let mut csv =
-            csv::Reader::new(file, Arc::new(schema), false, None, 1024, None, None, None);
-        let _batch = csv.next().unwrap().unwrap();
-        #[cfg(feature = "prettyprint")]
-        {
-            print_batches(&[_batch]).unwrap();
-        }
-    }
+    let mut csv = csv::ReaderBuilder::new(Arc::new(schema))
+        .build(file)
+        .unwrap();
+
+    let batch = csv.next().unwrap().unwrap();
+    print_batches(&[batch]).unwrap();
 }
diff --git a/arrow/examples/read_csv_infer_schema.rs b/arrow/examples/read_csv_infer_schema.rs
index e9f5ff650706..bd3c1c6a4623 100644
--- a/arrow/examples/read_csv_infer_schema.rs
+++ b/arrow/examples/read_csv_infer_schema.rs
@@ -17,28 +17,25 @@
 
 extern crate arrow;
 
-#[cfg(feature = "csv")]
 use arrow::csv;
-#[cfg(feature = "prettyprint")]
 use arrow::util::pretty::print_batches;
+use arrow_csv::reader::Format;
 use std::fs::File;
+use std::io::Seek;
+use std::sync::Arc;
 
 fn main() {
-    #[cfg(feature = "csv")]
-    {
-        let path = format!(
-            "{}/test/data/uk_cities_with_headers.csv",
-            env!("CARGO_MANIFEST_DIR")
-        );
-        let file = File::open(path).unwrap();
-        let builder = csv::ReaderBuilder::new()
-            .has_header(true)
-            .infer_schema(Some(100));
-        let mut csv = builder.build(file).unwrap();
-        let _batch = csv.next().unwrap().unwrap();
-        #[cfg(feature = "prettyprint")]
-        {
-            print_batches(&[_batch]).unwrap();
-        }
-    }
+    let path = format!(
+        "{}/../arrow-csv/test/data/uk_cities_with_headers.csv",
+        env!("CARGO_MANIFEST_DIR")
+    );
+    let mut file = File::open(path).unwrap();
+    let format = Format::default().with_header(true);
+    let (schema, _) = format.infer_schema(&mut file, Some(100)).unwrap();
+    file.rewind().unwrap();
+
+    let builder = csv::ReaderBuilder::new(Arc::new(schema)).with_format(format);
+    let mut csv = builder.build(file).unwrap();
+    let batch = csv.next().unwrap().unwrap();
+    print_batches(&[batch]).unwrap();
 }
diff --git a/arrow/examples/tensor_builder.rs b/arrow/examples/tensor_builder.rs
index 1ef53920e046..90ad1b4868f7 100644
--- a/arrow/examples/tensor_builder.rs
+++ b/arrow/examples/tensor_builder.rs
@@ -15,8 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-///! Tensor builder example
-extern crate arrow;
+//! Tensor builder example
 
 use arrow::array::*; //{Int32BufferBuilder, Float32BufferBuilder};
 use arrow::buffer::Buffer;
@@ -39,7 +38,7 @@ fn main() -> Result<()> {
     // storage data
     let tensor = Int32Tensor::try_new(buf, Some(vec![2, 8]), None, None)?;
     println!("Int32 Tensor");
-    println!("{:?}", tensor);
+    println!("{tensor:?}");
 
     // Creating a tensor using float type buffer builder
     let mut builder = Float32BufferBuilder::new(4);
@@ -54,14 +53,14 @@ fn main() -> Result<()> {
     // storage data
     let tensor = Float32Tensor::try_new(buf, Some(vec![2, 2]), None, None)?;
     println!("\nFloat32 Tensor");
-    println!("{:?}", tensor);
+    println!("{tensor:?}");
 
     // In order to build a tensor from an array the function to_byte_slice add the
     // required padding to the elements in the array.
     let buf = Buffer::from(&[0, 1, 2, 3, 4, 5, 6, 7, 9, 10].to_byte_slice());
     let tensor = Int32Tensor::try_new(buf, Some(vec![2, 5]), None, None)?;
     println!("\nInt32 Tensor");
-    println!("{:?}", tensor);
+    println!("{tensor:?}");
 
     Ok(())
 }
diff --git a/arrow/src/alloc/mod.rs b/arrow/src/alloc/mod.rs
deleted file mode 100644
index 526850685c48..000000000000
--- a/arrow/src/alloc/mod.rs
+++ /dev/null
@@ -1,155 +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.
-
-//! Defines memory-related functions, such as allocate/deallocate/reallocate memory
-//! regions, cache and allocation alignments.
-
-use std::alloc::{handle_alloc_error, Layout};
-use std::fmt::{Debug, Formatter};
-use std::mem::size_of;
-use std::panic::RefUnwindSafe;
-use std::ptr::NonNull;
-use std::sync::Arc;
-
-mod alignment;
-mod types;
-
-pub use alignment::ALIGNMENT;
-pub use types::NativeType;
-
-#[inline]
-unsafe fn null_pointer<T: NativeType>() -> NonNull<T> {
-    NonNull::new_unchecked(ALIGNMENT as *mut T)
-}
-
-/// Allocates a cache-aligned memory region of `size` bytes with uninitialized values.
-/// This is more performant than using [allocate_aligned_zeroed] when all bytes will have
-/// an unknown or non-zero value and is semantically similar to `malloc`.
-pub fn allocate_aligned<T: NativeType>(size: usize) -> NonNull<T> {
-    unsafe {
-        if size == 0 {
-            null_pointer()
-        } else {
-            let size = size * size_of::<T>();
-
-            let layout = Layout::from_size_align_unchecked(size, ALIGNMENT);
-            let raw_ptr = std::alloc::alloc(layout) as *mut T;
-            NonNull::new(raw_ptr).unwrap_or_else(|| handle_alloc_error(layout))
-        }
-    }
-}
-
-/// Allocates a cache-aligned memory region of `size` bytes with `0` on all of them.
-/// This is more performant than using [allocate_aligned] and setting all bytes to zero
-/// and is semantically similar to `calloc`.
-pub fn allocate_aligned_zeroed<T: NativeType>(size: usize) -> NonNull<T> {
-    unsafe {
-        if size == 0 {
-            null_pointer()
-        } else {
-            let size = size * size_of::<T>();
-
-            let layout = Layout::from_size_align_unchecked(size, ALIGNMENT);
-            let raw_ptr = std::alloc::alloc_zeroed(layout) as *mut T;
-            NonNull::new(raw_ptr).unwrap_or_else(|| handle_alloc_error(layout))
-        }
-    }
-}
-
-/// # Safety
-///
-/// This function is unsafe because undefined behavior can result if the caller does not ensure all
-/// of the following:
-///
-/// * ptr must denote a block of memory currently allocated via this allocator,
-///
-/// * size must be the same size that was used to allocate that block of memory,
-pub unsafe fn free_aligned<T: NativeType>(ptr: NonNull<T>, size: usize) {
-    if ptr != null_pointer() {
-        let size = size * size_of::<T>();
-        std::alloc::dealloc(
-            ptr.as_ptr() as *mut u8,
-            Layout::from_size_align_unchecked(size, ALIGNMENT),
-        );
-    }
-}
-
-/// # Safety
-///
-/// This function is unsafe because undefined behavior can result if the caller does not ensure all
-/// of the following:
-///
-/// * ptr must be currently allocated via this allocator,
-///
-/// * new_size must be greater than zero.
-///
-/// * new_size, when rounded up to the nearest multiple of [ALIGNMENT], must not overflow (i.e.,
-/// the rounded value must be less than usize::MAX).
-pub unsafe fn reallocate<T: NativeType>(
-    ptr: NonNull<T>,
-    old_size: usize,
-    new_size: usize,
-) -> NonNull<T> {
-    let old_size = old_size * size_of::<T>();
-    let new_size = new_size * size_of::<T>();
-    if ptr == null_pointer() {
-        return allocate_aligned(new_size);
-    }
-
-    if new_size == 0 {
-        free_aligned(ptr, old_size);
-        return null_pointer();
-    }
-
-    let raw_ptr = std::alloc::realloc(
-        ptr.as_ptr() as *mut u8,
-        Layout::from_size_align_unchecked(old_size, ALIGNMENT),
-        new_size,
-    ) as *mut T;
-    NonNull::new(raw_ptr).unwrap_or_else(|| {
-        handle_alloc_error(Layout::from_size_align_unchecked(new_size, ALIGNMENT))
-    })
-}
-
-/// The owner of an allocation.
-/// The trait implementation is responsible for dropping the allocations once no more references exist.
-pub trait Allocation: RefUnwindSafe + Send + Sync {}
-
-impl<T: RefUnwindSafe + Send + Sync> Allocation for T {}
-
-/// Mode of deallocating memory regions
-pub(crate) enum Deallocation {
-    /// An allocation of the given capacity that needs to be deallocated using arrows's cache aligned allocator.
-    /// See [allocate_aligned] and [free_aligned].
-    Arrow(usize),
-    /// An allocation from an external source like the FFI interface or a Rust Vec.
-    /// Deallocation will happen
-    Custom(Arc<dyn Allocation>),
-}
-
-impl Debug for Deallocation {
-    fn fmt(&self, f: &mut Formatter) -> std::fmt::Result {
-        match self {
-            Deallocation::Arrow(capacity) => {
-                write!(f, "Deallocation::Arrow {{ capacity: {} }}", capacity)
-            }
-            Deallocation::Custom(_) => {
-                write!(f, "Deallocation::Custom {{ capacity: unknown }}")
-            }
-        }
-    }
-}
diff --git a/arrow/src/alloc/types.rs b/arrow/src/alloc/types.rs
deleted file mode 100644
index 026e1241f46b..000000000000
--- a/arrow/src/alloc/types.rs
+++ /dev/null
@@ -1,73 +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.
-
-use crate::datatypes::DataType;
-use half::f16;
-
-/// A type that Rust's custom allocator knows how to allocate and deallocate.
-/// This is implemented for all Arrow's physical types whose in-memory representation
-/// matches Rust's physical types. Consider this trait sealed.
-/// # Safety
-/// Do not implement this trait.
-pub unsafe trait NativeType:
-    Sized + Copy + std::fmt::Debug + std::fmt::Display + PartialEq + Default + Sized + 'static
-{
-    type Bytes: AsRef<[u8]>;
-
-    /// Whether a DataType is a valid type for this physical representation.
-    fn is_valid(data_type: &DataType) -> bool;
-
-    /// How this type represents itself as bytes in little endianess.
-    /// This is used for IPC, where data is communicated with a specific endianess.
-    fn to_le_bytes(&self) -> Self::Bytes;
-}
-
-macro_rules! create_native {
-    ($native_ty:ty,$($impl_pattern:pat_param)|+) => {
-        unsafe impl NativeType for $native_ty {
-            type Bytes = [u8; std::mem::size_of::<Self>()];
-
-            #[inline]
-            fn to_le_bytes(&self) -> Self::Bytes {
-                Self::to_le_bytes(*self)
-            }
-
-            #[inline]
-            fn is_valid(data_type: &DataType) -> bool {
-                matches!(data_type, $($impl_pattern)|+)
-            }
-        }
-    };
-}
-
-create_native!(u8, DataType::UInt8);
-create_native!(u16, DataType::UInt16);
-create_native!(u32, DataType::UInt32);
-create_native!(u64, DataType::UInt64);
-create_native!(i8, DataType::Int8);
-create_native!(i16, DataType::Int16);
-create_native!(
-    i32,
-    DataType::Int32 | DataType::Date32 | DataType::Time32(_)
-);
-create_native!(
-    i64,
-    DataType::Int64 | DataType::Date64 | DataType::Time64(_) | DataType::Timestamp(_, _)
-);
-create_native!(f16, DataType::Float16);
-create_native!(f32, DataType::Float32);
-create_native!(f64, DataType::Float64);
diff --git a/arrow/src/array/array_boolean.rs b/arrow/src/array/array_boolean.rs
deleted file mode 100644
index 5d1e20705e75..000000000000
--- a/arrow/src/array/array_boolean.rs
+++ /dev/null
@@ -1,406 +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.
-
-use crate::array::array::ArrayAccessor;
-use std::borrow::Borrow;
-use std::convert::From;
-use std::iter::{FromIterator, IntoIterator};
-use std::{any::Any, fmt};
-
-use super::*;
-use super::{array::print_long_array, raw_pointer::RawPtrBox};
-use crate::buffer::{Buffer, MutableBuffer};
-use crate::util::bit_util;
-
-/// Array of bools
-///
-/// # Example
-///
-/// ```
-///     use arrow::array::{Array, BooleanArray};
-///     let arr = BooleanArray::from(vec![Some(false), Some(true), None, Some(true)]);
-///     assert_eq!(4, arr.len());
-///     assert_eq!(1, arr.null_count());
-///     assert!(arr.is_valid(0));
-///     assert!(!arr.is_null(0));
-///     assert_eq!(false, arr.value(0));
-///     assert!(arr.is_valid(1));
-///     assert!(!arr.is_null(1));
-///     assert_eq!(true, arr.value(1));
-///     assert!(!arr.is_valid(2));
-///     assert!(arr.is_null(2));
-///     assert!(arr.is_valid(3));
-///     assert!(!arr.is_null(3));
-///     assert_eq!(true, arr.value(3));
-/// ```
-///
-/// Using `from_iter`
-/// ```
-///     use arrow::array::{Array, BooleanArray};
-///     let v = vec![Some(false), Some(true), Some(false), Some(true)];
-///     let arr = v.into_iter().collect::<BooleanArray>();
-///     assert_eq!(4, arr.len());
-///     assert_eq!(0, arr.offset());
-///     assert_eq!(0, arr.null_count());
-///     assert!(arr.is_valid(0));
-///     assert_eq!(false, arr.value(0));
-///     assert!(arr.is_valid(1));
-///     assert_eq!(true, arr.value(1));
-///     assert!(arr.is_valid(2));
-///     assert_eq!(false, arr.value(2));
-///     assert!(arr.is_valid(3));
-///     assert_eq!(true, arr.value(3));
-/// ```
-pub struct BooleanArray {
-    data: ArrayData,
-    /// Pointer to the value array. The lifetime of this must be <= to the value buffer
-    /// stored in `data`, so it's safe to store.
-    raw_values: RawPtrBox<u8>,
-}
-
-impl fmt::Debug for BooleanArray {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "BooleanArray\n[\n")?;
-        print_long_array(self, f, |array, index, f| {
-            fmt::Debug::fmt(&array.value(index), f)
-        })?;
-        write!(f, "]")
-    }
-}
-
-impl BooleanArray {
-    /// Returns the length of this array.
-    pub fn len(&self) -> usize {
-        self.data.len()
-    }
-
-    /// Returns whether this array is empty.
-    pub fn is_empty(&self) -> bool {
-        self.data.is_empty()
-    }
-
-    // Returns a new boolean array builder
-    pub fn builder(capacity: usize) -> BooleanBuilder {
-        BooleanBuilder::new(capacity)
-    }
-
-    /// Returns a `Buffer` holding all the values of this array.
-    ///
-    /// Note this doesn't take the offset of this array into account.
-    pub fn values(&self) -> &Buffer {
-        &self.data.buffers()[0]
-    }
-
-    /// Returns the boolean value at index `i`.
-    ///
-    /// # Safety
-    /// This doesn't check bounds, the caller must ensure that index < self.len()
-    pub unsafe fn value_unchecked(&self, i: usize) -> bool {
-        let offset = i + self.offset();
-        bit_util::get_bit_raw(self.raw_values.as_ptr(), offset)
-    }
-
-    /// Returns the boolean value at index `i`.
-    ///
-    /// Panics of offset `i` is out of bounds
-    pub fn value(&self, i: usize) -> bool {
-        assert!(i < self.len());
-        // Safety:
-        // `i < self.len()
-        unsafe { self.value_unchecked(i) }
-    }
-
-    /// Returns an iterator that returns the values of `array.value(i)` for an iterator with each element `i`
-    pub fn take_iter<'a>(
-        &'a self,
-        indexes: impl Iterator<Item = Option<usize>> + 'a,
-    ) -> impl Iterator<Item = Option<bool>> + 'a {
-        indexes.map(|opt_index| opt_index.map(|index| self.value(index)))
-    }
-
-    /// Returns an iterator that returns the values of `array.value(i)` for an iterator with each element `i`
-    /// # Safety
-    ///
-    /// caller must ensure that the offsets in the iterator are less than the array len()
-    pub unsafe fn take_iter_unchecked<'a>(
-        &'a self,
-        indexes: impl Iterator<Item = Option<usize>> + 'a,
-    ) -> impl Iterator<Item = Option<bool>> + 'a {
-        indexes.map(|opt_index| opt_index.map(|index| self.value_unchecked(index)))
-    }
-}
-
-impl Array for BooleanArray {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.into()
-    }
-}
-
-impl<'a> ArrayAccessor for &'a BooleanArray {
-    type Item = bool;
-
-    fn value(&self, index: usize) -> Self::Item {
-        BooleanArray::value(self, index)
-    }
-
-    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
-        BooleanArray::value_unchecked(self, index)
-    }
-}
-
-impl From<Vec<bool>> for BooleanArray {
-    fn from(data: Vec<bool>) -> Self {
-        let mut mut_buf = MutableBuffer::new_null(data.len());
-        {
-            let mut_slice = mut_buf.as_slice_mut();
-            for (i, b) in data.iter().enumerate() {
-                if *b {
-                    bit_util::set_bit(mut_slice, i);
-                }
-            }
-        }
-        let array_data = ArrayData::builder(DataType::Boolean)
-            .len(data.len())
-            .add_buffer(mut_buf.into());
-
-        let array_data = unsafe { array_data.build_unchecked() };
-        BooleanArray::from(array_data)
-    }
-}
-
-impl From<Vec<Option<bool>>> for BooleanArray {
-    fn from(data: Vec<Option<bool>>) -> Self {
-        data.iter().collect()
-    }
-}
-
-impl From<ArrayData> for BooleanArray {
-    fn from(data: ArrayData) -> Self {
-        assert_eq!(
-            data.buffers().len(),
-            1,
-            "BooleanArray data should contain a single buffer only (values buffer)"
-        );
-        let ptr = data.buffers()[0].as_ptr();
-        Self {
-            data,
-            raw_values: unsafe { RawPtrBox::new(ptr) },
-        }
-    }
-}
-
-impl From<BooleanArray> for ArrayData {
-    fn from(array: BooleanArray) -> Self {
-        array.data
-    }
-}
-
-impl<'a> IntoIterator for &'a BooleanArray {
-    type Item = Option<bool>;
-    type IntoIter = BooleanIter<'a>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        BooleanIter::<'a>::new(self)
-    }
-}
-
-impl<'a> BooleanArray {
-    /// constructs a new iterator
-    pub fn iter(&'a self) -> BooleanIter<'a> {
-        BooleanIter::<'a>::new(self)
-    }
-}
-
-impl<Ptr: Borrow<Option<bool>>> FromIterator<Ptr> for BooleanArray {
-    fn from_iter<I: IntoIterator<Item = Ptr>>(iter: I) -> Self {
-        let iter = iter.into_iter();
-        let (_, data_len) = iter.size_hint();
-        let data_len = data_len.expect("Iterator must be sized"); // panic if no upper bound.
-
-        let num_bytes = bit_util::ceil(data_len, 8);
-        let mut null_builder = MutableBuffer::from_len_zeroed(num_bytes);
-        let mut val_builder = MutableBuffer::from_len_zeroed(num_bytes);
-
-        let data = val_builder.as_slice_mut();
-
-        let null_slice = null_builder.as_slice_mut();
-        iter.enumerate().for_each(|(i, item)| {
-            if let Some(a) = item.borrow() {
-                bit_util::set_bit(null_slice, i);
-                if *a {
-                    bit_util::set_bit(data, i);
-                }
-            }
-        });
-
-        let data = unsafe {
-            ArrayData::new_unchecked(
-                DataType::Boolean,
-                data_len,
-                None,
-                Some(null_builder.into()),
-                0,
-                vec![val_builder.into()],
-                vec![],
-            )
-        };
-        BooleanArray::from(data)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use crate::buffer::Buffer;
-    use crate::datatypes::DataType;
-
-    #[test]
-    fn test_boolean_fmt_debug() {
-        let arr = BooleanArray::from(vec![true, false, false]);
-        assert_eq!(
-            "BooleanArray\n[\n  true,\n  false,\n  false,\n]",
-            format!("{:?}", arr)
-        );
-    }
-
-    #[test]
-    fn test_boolean_with_null_fmt_debug() {
-        let mut builder = BooleanArray::builder(3);
-        builder.append_value(true);
-        builder.append_null();
-        builder.append_value(false);
-        let arr = builder.finish();
-        assert_eq!(
-            "BooleanArray\n[\n  true,\n  null,\n  false,\n]",
-            format!("{:?}", arr)
-        );
-    }
-
-    #[test]
-    fn test_boolean_array_from_vec() {
-        let buf = Buffer::from([10_u8]);
-        let arr = BooleanArray::from(vec![false, true, false, true]);
-        assert_eq!(&buf, arr.values());
-        assert_eq!(4, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(0, arr.null_count());
-        for i in 0..4 {
-            assert!(!arr.is_null(i));
-            assert!(arr.is_valid(i));
-            assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {}", i)
-        }
-    }
-
-    #[test]
-    fn test_boolean_array_from_vec_option() {
-        let buf = Buffer::from([10_u8]);
-        let arr = BooleanArray::from(vec![Some(false), Some(true), None, Some(true)]);
-        assert_eq!(&buf, arr.values());
-        assert_eq!(4, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(1, arr.null_count());
-        for i in 0..4 {
-            if i == 2 {
-                assert!(arr.is_null(i));
-                assert!(!arr.is_valid(i));
-            } else {
-                assert!(!arr.is_null(i));
-                assert!(arr.is_valid(i));
-                assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {}", i)
-            }
-        }
-    }
-
-    #[test]
-    fn test_boolean_array_from_iter() {
-        let v = vec![Some(false), Some(true), Some(false), Some(true)];
-        let arr = v.into_iter().collect::<BooleanArray>();
-        assert_eq!(4, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(0, arr.null_count());
-        assert!(arr.data().null_buffer().is_none());
-        for i in 0..3 {
-            assert!(!arr.is_null(i));
-            assert!(arr.is_valid(i));
-            assert_eq!(i == 1 || i == 3, arr.value(i), "failed at {}", i)
-        }
-    }
-
-    #[test]
-    fn test_boolean_array_from_nullable_iter() {
-        let v = vec![Some(true), None, Some(false), None];
-        let arr = v.into_iter().collect::<BooleanArray>();
-        assert_eq!(4, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(2, arr.null_count());
-        assert!(arr.data().null_buffer().is_some());
-
-        assert!(arr.is_valid(0));
-        assert!(arr.is_null(1));
-        assert!(arr.is_valid(2));
-        assert!(arr.is_null(3));
-
-        assert!(arr.value(0));
-        assert!(!arr.value(2));
-    }
-
-    #[test]
-    fn test_boolean_array_builder() {
-        // Test building a boolean array with ArrayData builder and offset
-        // 000011011
-        let buf = Buffer::from([27_u8]);
-        let buf2 = buf.clone();
-        let data = ArrayData::builder(DataType::Boolean)
-            .len(5)
-            .offset(2)
-            .add_buffer(buf)
-            .build()
-            .unwrap();
-        let arr = BooleanArray::from(data);
-        assert_eq!(&buf2, arr.values());
-        assert_eq!(5, arr.len());
-        assert_eq!(2, arr.offset());
-        assert_eq!(0, arr.null_count());
-        for i in 0..3 {
-            assert_eq!(i != 0, arr.value(i), "failed at {}", i);
-        }
-    }
-
-    #[test]
-    #[should_panic(expected = "BooleanArray data should contain a single buffer only \
-                               (values buffer)")]
-    // Different error messages, so skip for now
-    // https://github.com/apache/arrow-rs/issues/1545
-    #[cfg(not(feature = "force_validate"))]
-    fn test_boolean_array_invalid_buffer_len() {
-        let data = unsafe {
-            ArrayData::builder(DataType::Boolean)
-                .len(5)
-                .build_unchecked()
-        };
-        drop(BooleanArray::from(data));
-    }
-}
diff --git a/arrow/src/array/array_decimal.rs b/arrow/src/array/array_decimal.rs
deleted file mode 100644
index 455383124c03..000000000000
--- a/arrow/src/array/array_decimal.rs
+++ /dev/null
@@ -1,965 +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.
-
-use crate::array::ArrayAccessor;
-use num::BigInt;
-use std::borrow::Borrow;
-use std::convert::From;
-use std::fmt;
-use std::{any::Any, iter::FromIterator};
-
-use super::{
-    array::print_long_array, raw_pointer::RawPtrBox, Array, ArrayData, FixedSizeListArray,
-};
-use super::{BasicDecimalIter, BooleanBufferBuilder, FixedSizeBinaryArray};
-#[allow(deprecated)]
-pub use crate::array::DecimalIter;
-use crate::buffer::{Buffer, MutableBuffer};
-use crate::datatypes::{validate_decimal256_precision_with_lt_bytes, DataType};
-use crate::datatypes::{
-    validate_decimal_precision, DECIMAL256_MAX_PRECISION, DECIMAL_DEFAULT_SCALE,
-};
-use crate::error::{ArrowError, Result};
-use crate::util::decimal::{BasicDecimal, Decimal256};
-
-/// `Decimal128Array` stores fixed width decimal numbers,
-/// with a fixed precision and scale.
-///
-/// # Examples
-///
-/// ```
-///    use arrow::array::{Array, BasicDecimalArray, Decimal128Array};
-///    use arrow::datatypes::DataType;
-///
-///    // Create a DecimalArray with the default precision and scale
-///    let decimal_array: Decimal128Array = vec![
-///       Some(8_887_000_000),
-///       None,
-///       Some(-8_887_000_000),
-///     ]
-///     .into_iter().collect();
-///
-///    // set precision and scale so values are interpreted
-///    // as `8887.000000`, `Null`, and `-8887.000000`
-///    let decimal_array = decimal_array
-///     .with_precision_and_scale(23, 6)
-///     .unwrap();
-///
-///    assert_eq!(&DataType::Decimal128(23, 6), decimal_array.data_type());
-///    assert_eq!(8_887_000_000_i128, decimal_array.value(0).as_i128());
-///    assert_eq!("8887.000000", decimal_array.value_as_string(0));
-///    assert_eq!(3, decimal_array.len());
-///    assert_eq!(1, decimal_array.null_count());
-///    assert_eq!(32, decimal_array.value_offset(2));
-///    assert_eq!(16, decimal_array.value_length());
-///    assert_eq!(23, decimal_array.precision());
-///    assert_eq!(6, decimal_array.scale());
-/// ```
-///
-pub type Decimal128Array = BasicDecimalArray<16>;
-
-pub type Decimal256Array = BasicDecimalArray<32>;
-
-pub struct BasicDecimalArray<const BYTE_WIDTH: usize> {
-    data: ArrayData,
-    value_data: RawPtrBox<u8>,
-    precision: usize,
-    scale: usize,
-}
-
-impl<const BYTE_WIDTH: usize> BasicDecimalArray<BYTE_WIDTH> {
-    pub const VALUE_LENGTH: i32 = BYTE_WIDTH as i32;
-    const DEFAULT_TYPE: DataType = BasicDecimal::<BYTE_WIDTH>::DEFAULT_TYPE;
-    pub const MAX_PRECISION: usize = BasicDecimal::<BYTE_WIDTH>::MAX_PRECISION;
-    pub const MAX_SCALE: usize = BasicDecimal::<BYTE_WIDTH>::MAX_SCALE;
-    const TYPE_CONSTRUCTOR: fn(usize, usize) -> DataType =
-        BasicDecimal::<BYTE_WIDTH>::TYPE_CONSTRUCTOR;
-
-    pub fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    /// Return the precision (total digits) that can be stored by this array
-    pub fn precision(&self) -> usize {
-        self.precision
-    }
-
-    /// Return the scale (digits after the decimal) that can be stored by this array
-    pub fn scale(&self) -> usize {
-        self.scale
-    }
-
-    /// Returns the element at index `i`.
-    pub fn value(&self, i: usize) -> BasicDecimal<BYTE_WIDTH> {
-        assert!(i < self.data().len(), "Out of bounds access");
-
-        unsafe { self.value_unchecked(i) }
-    }
-
-    /// Returns the element at index `i`.
-    /// # Safety
-    /// Caller is responsible for ensuring that the index is within the bounds of the array
-    pub unsafe fn value_unchecked(&self, i: usize) -> BasicDecimal<BYTE_WIDTH> {
-        let data = self.data();
-        let offset = i + data.offset();
-        let raw_val = {
-            let pos = self.value_offset_at(offset);
-            std::slice::from_raw_parts(
-                self.raw_value_data_ptr().offset(pos as isize),
-                Self::VALUE_LENGTH as usize,
-            )
-        };
-        BasicDecimal::<BYTE_WIDTH>::new(self.precision(), self.scale(), raw_val)
-    }
-
-    /// Returns the offset for the element at index `i`.
-    ///
-    /// Note this doesn't do any bound checking, for performance reason.
-    #[inline]
-    pub fn value_offset(&self, i: usize) -> i32 {
-        self.value_offset_at(self.data().offset() + i)
-    }
-
-    /// Returns the length for an element.
-    ///
-    /// All elements have the same length as the array is a fixed size.
-    #[inline]
-    pub fn value_length(&self) -> i32 {
-        Self::VALUE_LENGTH
-    }
-
-    /// Returns a clone of the value data buffer
-    pub fn value_data(&self) -> Buffer {
-        self.data().buffers()[0].clone()
-    }
-
-    #[inline]
-    pub fn value_offset_at(&self, i: usize) -> i32 {
-        Self::VALUE_LENGTH * i as i32
-    }
-
-    #[inline]
-    pub fn value_as_string(&self, row: usize) -> String {
-        self.value(row).to_string()
-    }
-
-    /// Build a decimal array from [`FixedSizeBinaryArray`].
-    ///
-    /// NB: This function does not validate that each value is in the permissible
-    /// range for a decimal
-    pub fn from_fixed_size_binary_array(
-        v: FixedSizeBinaryArray,
-        precision: usize,
-        scale: usize,
-    ) -> Self {
-        assert!(
-            v.value_length() == Self::VALUE_LENGTH,
-            "Value length of the array ({}) must equal to the byte width of the decimal ({})",
-            v.value_length(),
-            Self::VALUE_LENGTH,
-        );
-        let data_type = if Self::VALUE_LENGTH == 16 {
-            DataType::Decimal128(precision, scale)
-        } else {
-            DataType::Decimal256(precision, scale)
-        };
-        let builder = v.into_data().into_builder().data_type(data_type);
-
-        let array_data = unsafe { builder.build_unchecked() };
-        Self::from(array_data)
-    }
-
-    /// Build a decimal array from [`FixedSizeListArray`].
-    ///
-    /// NB: This function does not validate that each value is in the permissible
-    /// range for a decimal.
-    #[deprecated(note = "please use `from_fixed_size_binary_array` instead")]
-    pub fn from_fixed_size_list_array(
-        v: FixedSizeListArray,
-        precision: usize,
-        scale: usize,
-    ) -> Self {
-        assert_eq!(
-            v.data_ref().child_data().len(),
-            1,
-            "DecimalArray can only be created from list array of u8 values \
-             (i.e. FixedSizeList<PrimitiveArray<u8>>)."
-        );
-        let child_data = &v.data_ref().child_data()[0];
-
-        assert_eq!(
-            child_data.child_data().len(),
-            0,
-            "DecimalArray can only be created from list array of u8 values \
-             (i.e. FixedSizeList<PrimitiveArray<u8>>)."
-        );
-        assert_eq!(
-            child_data.data_type(),
-            &DataType::UInt8,
-            "DecimalArray can only be created from FixedSizeList<u8> arrays, mismatched data types."
-        );
-        assert!(
-            v.value_length() == Self::VALUE_LENGTH,
-            "Value length of the array ({}) must equal to the byte width of the decimal ({})",
-            v.value_length(),
-            Self::VALUE_LENGTH,
-        );
-        assert_eq!(
-            v.data_ref().child_data()[0].null_count(),
-            0,
-            "The child array cannot contain null values."
-        );
-
-        let list_offset = v.offset();
-        let child_offset = child_data.offset();
-        let data_type = if Self::VALUE_LENGTH == 16 {
-            DataType::Decimal128(precision, scale)
-        } else {
-            DataType::Decimal256(precision, scale)
-        };
-        let builder = ArrayData::builder(data_type)
-            .len(v.len())
-            .add_buffer(child_data.buffers()[0].slice(child_offset))
-            .null_bit_buffer(v.data_ref().null_buffer().cloned())
-            .offset(list_offset);
-
-        let array_data = unsafe { builder.build_unchecked() };
-        Self::from(array_data)
-    }
-
-    /// The default precision and scale used when not specified.
-    pub const fn default_type() -> DataType {
-        Self::DEFAULT_TYPE
-    }
-
-    fn raw_value_data_ptr(&self) -> *const u8 {
-        self.value_data.as_ptr()
-    }
-}
-
-impl Decimal128Array {
-    /// Creates a [Decimal128Array] with default precision and scale,
-    /// based on an iterator of `i128` values without nulls
-    pub fn from_iter_values<I: IntoIterator<Item = i128>>(iter: I) -> Self {
-        let val_buf: Buffer = iter.into_iter().collect();
-        let data = unsafe {
-            ArrayData::new_unchecked(
-                Self::default_type(),
-                val_buf.len() / std::mem::size_of::<i128>(),
-                None,
-                None,
-                0,
-                vec![val_buf],
-                vec![],
-            )
-        };
-        Decimal128Array::from(data)
-    }
-
-    // Validates decimal values in this array can be properly interpreted
-    // with the specified precision.
-    fn validate_decimal_precision(&self, precision: usize) -> Result<()> {
-        for v in self.iter().flatten() {
-            validate_decimal_precision(v.as_i128(), precision)?;
-        }
-        Ok(())
-    }
-
-    /// Returns a Decimal array with the same data as self, with the
-    /// specified precision.
-    ///
-    /// Returns an Error if:
-    /// 1. `precision` is larger than [`Self::MAX_PRECISION`]
-    /// 2. `scale` is larger than [`Self::MAX_SCALE`];
-    /// 3. `scale` is > `precision`
-    pub fn with_precision_and_scale(self, precision: usize, scale: usize) -> Result<Self>
-    where
-        Self: Sized,
-    {
-        if precision > Self::MAX_PRECISION {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "precision {} is greater than max {}",
-                precision,
-                Self::MAX_PRECISION
-            )));
-        }
-        if scale > Self::MAX_SCALE {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "scale {} is greater than max {}",
-                scale,
-                Self::MAX_SCALE
-            )));
-        }
-        if scale > precision {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "scale {} is greater than precision {}",
-                scale, precision
-            )));
-        }
-
-        // Ensure that all values are within the requested
-        // precision. For performance, only check if the precision is
-        // decreased
-        if precision < self.precision {
-            self.validate_decimal_precision(precision)?;
-        }
-
-        let data_type = Self::TYPE_CONSTRUCTOR(self.precision, self.scale);
-        assert_eq!(self.data().data_type(), &data_type);
-
-        // safety: self.data is valid DataType::Decimal as checked above
-        let new_data_type = Self::TYPE_CONSTRUCTOR(precision, scale);
-
-        Ok(self.data().clone().with_data_type(new_data_type).into())
-    }
-}
-
-impl Decimal256Array {
-    // Validates decimal values in this array can be properly interpreted
-    // with the specified precision.
-    fn validate_decimal_precision(&self, precision: usize) -> Result<()> {
-        (0..self.len()).try_for_each(|idx| {
-            if self.is_valid(idx) {
-                let raw_val = unsafe {
-                    let pos = self.value_offset(idx);
-                    std::slice::from_raw_parts(
-                        self.raw_value_data_ptr().offset(pos as isize),
-                        Self::VALUE_LENGTH as usize,
-                    )
-                };
-                validate_decimal256_precision_with_lt_bytes(raw_val, precision)
-            } else {
-                Ok(())
-            }
-        })
-    }
-
-    /// Returns a Decimal array with the same data as self, with the
-    /// specified precision.
-    ///
-    /// Returns an Error if:
-    /// 1. `precision` is larger than [`Self::MAX_PRECISION`]
-    /// 2. `scale` is larger than [`Self::MAX_SCALE`];
-    /// 3. `scale` is > `precision`
-    pub fn with_precision_and_scale(self, precision: usize, scale: usize) -> Result<Self>
-    where
-        Self: Sized,
-    {
-        if precision > Self::MAX_PRECISION {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "precision {} is greater than max {}",
-                precision,
-                Self::MAX_PRECISION
-            )));
-        }
-        if scale > Self::MAX_SCALE {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "scale {} is greater than max {}",
-                scale,
-                Self::MAX_SCALE
-            )));
-        }
-        if scale > precision {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "scale {} is greater than precision {}",
-                scale, precision
-            )));
-        }
-
-        // Ensure that all values are within the requested
-        // precision. For performance, only check if the precision is
-        // decreased
-        if precision < self.precision {
-            self.validate_decimal_precision(precision)?;
-        }
-
-        let data_type = Self::TYPE_CONSTRUCTOR(self.precision, self.scale);
-        assert_eq!(self.data().data_type(), &data_type);
-
-        // safety: self.data is valid DataType::Decimal as checked above
-        let new_data_type = Self::TYPE_CONSTRUCTOR(precision, scale);
-
-        Ok(self.data().clone().with_data_type(new_data_type).into())
-    }
-}
-
-impl<const BYTE_WIDTH: usize> From<ArrayData> for BasicDecimalArray<BYTE_WIDTH> {
-    fn from(data: ArrayData) -> Self {
-        assert_eq!(
-            data.buffers().len(),
-            1,
-            "DecimalArray data should contain 1 buffer only (values)"
-        );
-        let values = data.buffers()[0].as_ptr();
-        let (precision, scale) = match (data.data_type(), BYTE_WIDTH) {
-            (DataType::Decimal128(precision, scale), 16)
-            | (DataType::Decimal256(precision, scale), 32) => (*precision, *scale),
-            _ => panic!("Expected data type to be Decimal"),
-        };
-        Self {
-            data,
-            value_data: unsafe { RawPtrBox::new(values) },
-            precision,
-            scale,
-        }
-    }
-}
-
-impl<'a> Decimal128Array {
-    /// Constructs a new iterator that iterates `Decimal128` values as i128 values.
-    /// This is kept mostly for back-compatibility purpose.
-    /// Suggests to use `iter()` that returns `Decimal128Iter`.
-    #[allow(deprecated)]
-    pub fn i128_iter(&'a self) -> DecimalIter<'a> {
-        DecimalIter::<'a>::new(self)
-    }
-}
-
-impl From<BigInt> for Decimal256 {
-    fn from(bigint: BigInt) -> Self {
-        Decimal256::from_big_int(&bigint, DECIMAL256_MAX_PRECISION, DECIMAL_DEFAULT_SCALE)
-            .unwrap()
-    }
-}
-
-fn build_decimal_array_from<const BYTE_WIDTH: usize>(
-    null_buf: BooleanBufferBuilder,
-    buffer: Buffer,
-) -> BasicDecimalArray<BYTE_WIDTH> {
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            BasicDecimalArray::<BYTE_WIDTH>::default_type(),
-            null_buf.len(),
-            None,
-            Some(null_buf.into()),
-            0,
-            vec![buffer],
-            vec![],
-        )
-    };
-    BasicDecimalArray::<BYTE_WIDTH>::from(data)
-}
-
-impl<Ptr: Into<Decimal256>> FromIterator<Option<Ptr>> for Decimal256Array {
-    fn from_iter<I: IntoIterator<Item = Option<Ptr>>>(iter: I) -> Self {
-        let iter = iter.into_iter();
-        let (lower, upper) = iter.size_hint();
-        let size_hint = upper.unwrap_or(lower);
-
-        let mut null_buf = BooleanBufferBuilder::new(size_hint);
-
-        let mut buffer = MutableBuffer::with_capacity(size_hint);
-
-        iter.for_each(|item| {
-            if let Some(a) = item {
-                null_buf.append(true);
-                buffer.extend_from_slice(Into::into(a).raw_value());
-            } else {
-                null_buf.append(false);
-                buffer.extend_zeros(32);
-            }
-        });
-
-        build_decimal_array_from::<32>(null_buf, buffer.into())
-    }
-}
-
-impl<Ptr: Borrow<Option<i128>>> FromIterator<Ptr> for Decimal128Array {
-    fn from_iter<I: IntoIterator<Item = Ptr>>(iter: I) -> Self {
-        let iter = iter.into_iter();
-        let (lower, upper) = iter.size_hint();
-        let size_hint = upper.unwrap_or(lower);
-
-        let mut null_buf = BooleanBufferBuilder::new(size_hint);
-
-        let buffer: Buffer = iter
-            .map(|item| {
-                if let Some(a) = item.borrow() {
-                    null_buf.append(true);
-                    *a
-                } else {
-                    null_buf.append(false);
-                    // arbitrary value for NULL
-                    0
-                }
-            })
-            .collect();
-
-        build_decimal_array_from::<16>(null_buf, buffer)
-    }
-}
-
-impl<const BYTE_WIDTH: usize> Array for BasicDecimalArray<BYTE_WIDTH> {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.into()
-    }
-}
-
-impl<const BYTE_WIDTH: usize> From<BasicDecimalArray<BYTE_WIDTH>> for ArrayData {
-    fn from(array: BasicDecimalArray<BYTE_WIDTH>) -> Self {
-        array.data
-    }
-}
-
-impl<const BYTE_WIDTH: usize> fmt::Debug for BasicDecimalArray<BYTE_WIDTH> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(
-            f,
-            "Decimal{}Array<{}, {}>\n[\n",
-            BYTE_WIDTH * 8,
-            self.precision,
-            self.scale
-        )?;
-        print_long_array(self, f, |array, index, f| {
-            let formatted_decimal = array.value_as_string(index);
-
-            write!(f, "{}", formatted_decimal)
-        })?;
-        write!(f, "]")
-    }
-}
-
-impl<'a, const BYTE_WIDTH: usize> ArrayAccessor for &'a BasicDecimalArray<BYTE_WIDTH> {
-    type Item = BasicDecimal<BYTE_WIDTH>;
-
-    fn value(&self, index: usize) -> Self::Item {
-        BasicDecimalArray::<BYTE_WIDTH>::value(self, index)
-    }
-
-    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
-        BasicDecimalArray::<BYTE_WIDTH>::value_unchecked(self, index)
-    }
-}
-
-impl<'a, const BYTE_WIDTH: usize> IntoIterator for &'a BasicDecimalArray<BYTE_WIDTH> {
-    type Item = Option<BasicDecimal<BYTE_WIDTH>>;
-    type IntoIter = BasicDecimalIter<'a, BYTE_WIDTH>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        BasicDecimalIter::<'a, BYTE_WIDTH>::new(self)
-    }
-}
-
-impl<'a, const BYTE_WIDTH: usize> BasicDecimalArray<BYTE_WIDTH> {
-    /// constructs a new iterator
-    pub fn iter(&'a self) -> BasicDecimalIter<'a, BYTE_WIDTH> {
-        BasicDecimalIter::<'a, BYTE_WIDTH>::new(self)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::array::Decimal256Builder;
-    use crate::{array::Decimal128Builder, datatypes::Field};
-    use num::{BigInt, Num};
-
-    use super::*;
-
-    #[test]
-    fn test_decimal_array() {
-        // let val_8887: [u8; 16] = [192, 219, 180, 17, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-        // let val_neg_8887: [u8; 16] = [64, 36, 75, 238, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255];
-        let values: [u8; 32] = [
-            192, 219, 180, 17, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 64, 36, 75, 238, 253,
-            255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        ];
-        let array_data = ArrayData::builder(DataType::Decimal128(38, 6))
-            .len(2)
-            .add_buffer(Buffer::from(&values[..]))
-            .build()
-            .unwrap();
-        let decimal_array = Decimal128Array::from(array_data);
-        assert_eq!(8_887_000_000_i128, decimal_array.value(0).into());
-        assert_eq!(-8_887_000_000_i128, decimal_array.value(1).into());
-        assert_eq!(16, decimal_array.value_length());
-    }
-
-    #[test]
-    #[cfg(not(feature = "force_validate"))]
-    fn test_decimal_append_error_value() {
-        let mut decimal_builder = Decimal128Builder::new(10, 5, 3);
-        let mut result = decimal_builder.append_value(123456);
-        let mut error = result.unwrap_err();
-        assert_eq!(
-            "Invalid argument error: 123456 is too large to store in a Decimal128 of precision 5. Max is 99999",
-            error.to_string()
-        );
-
-        unsafe {
-            decimal_builder.disable_value_validation();
-        }
-        result = decimal_builder.append_value(123456);
-        assert!(result.is_ok());
-        decimal_builder.append_value(12345).unwrap();
-        let arr = decimal_builder.finish();
-        assert_eq!("12.345", arr.value_as_string(1));
-
-        decimal_builder = Decimal128Builder::new(10, 2, 1);
-        result = decimal_builder.append_value(100);
-        error = result.unwrap_err();
-        assert_eq!(
-            "Invalid argument error: 100 is too large to store in a Decimal128 of precision 2. Max is 99",
-            error.to_string()
-        );
-
-        unsafe {
-            decimal_builder.disable_value_validation();
-        }
-        result = decimal_builder.append_value(100);
-        assert!(result.is_ok());
-        decimal_builder.append_value(99).unwrap();
-        result = decimal_builder.append_value(-100);
-        assert!(result.is_ok());
-        decimal_builder.append_value(-99).unwrap();
-        let arr = decimal_builder.finish();
-        assert_eq!("9.9", arr.value_as_string(1));
-        assert_eq!("-9.9", arr.value_as_string(3));
-    }
-
-    #[test]
-    fn test_decimal_from_iter_values() {
-        let array = Decimal128Array::from_iter_values(vec![-100, 0, 101].into_iter());
-        assert_eq!(array.len(), 3);
-        assert_eq!(array.data_type(), &DataType::Decimal128(38, 10));
-        assert_eq!(-100_i128, array.value(0).into());
-        assert!(!array.is_null(0));
-        assert_eq!(0_i128, array.value(1).into());
-        assert!(!array.is_null(1));
-        assert_eq!(101_i128, array.value(2).into());
-        assert!(!array.is_null(2));
-    }
-
-    #[test]
-    fn test_decimal_from_iter() {
-        let array: Decimal128Array =
-            vec![Some(-100), None, Some(101)].into_iter().collect();
-        assert_eq!(array.len(), 3);
-        assert_eq!(array.data_type(), &DataType::Decimal128(38, 10));
-        assert_eq!(-100_i128, array.value(0).into());
-        assert!(!array.is_null(0));
-        assert!(array.is_null(1));
-        assert_eq!(101_i128, array.value(2).into());
-        assert!(!array.is_null(2));
-    }
-
-    #[test]
-    fn test_decimal_iter() {
-        let data = vec![Some(-100), None, Some(101)];
-        let array: Decimal128Array = data.clone().into_iter().collect();
-
-        let collected: Vec<_> = array.iter().map(|d| d.map(|v| v.as_i128())).collect();
-        assert_eq!(data, collected);
-    }
-
-    #[test]
-    fn test_decimal_into_iter() {
-        let data = vec![Some(-100), None, Some(101)];
-        let array: Decimal128Array = data.clone().into_iter().collect();
-
-        let collected: Vec<_> =
-            array.into_iter().map(|d| d.map(|v| v.as_i128())).collect();
-        assert_eq!(data, collected);
-    }
-
-    #[test]
-    fn test_decimal_iter_sized() {
-        let data = vec![Some(-100), None, Some(101)];
-        let array: Decimal128Array = data.into_iter().collect();
-        let mut iter = array.into_iter();
-
-        // is exact sized
-        assert_eq!(array.len(), 3);
-
-        // size_hint is reported correctly
-        assert_eq!(iter.size_hint(), (3, Some(3)));
-        iter.next().unwrap();
-        assert_eq!(iter.size_hint(), (2, Some(2)));
-        iter.next().unwrap();
-        iter.next().unwrap();
-        assert_eq!(iter.size_hint(), (0, Some(0)));
-        assert!(iter.next().is_none());
-        assert_eq!(iter.size_hint(), (0, Some(0)));
-    }
-
-    #[test]
-    fn test_decimal_array_value_as_string() {
-        let arr = [123450, -123450, 100, -100, 10, -10, 0]
-            .into_iter()
-            .map(Some)
-            .collect::<Decimal128Array>()
-            .with_precision_and_scale(6, 3)
-            .unwrap();
-
-        assert_eq!("123.450", arr.value_as_string(0));
-        assert_eq!("-123.450", arr.value_as_string(1));
-        assert_eq!("0.100", arr.value_as_string(2));
-        assert_eq!("-0.100", arr.value_as_string(3));
-        assert_eq!("0.010", arr.value_as_string(4));
-        assert_eq!("-0.010", arr.value_as_string(5));
-        assert_eq!("0.000", arr.value_as_string(6));
-    }
-
-    #[test]
-    fn test_decimal_array_with_precision_and_scale() {
-        let arr = Decimal128Array::from_iter_values([12345, 456, 7890, -123223423432432])
-            .with_precision_and_scale(20, 2)
-            .unwrap();
-
-        assert_eq!(arr.data_type(), &DataType::Decimal128(20, 2));
-        assert_eq!(arr.precision(), 20);
-        assert_eq!(arr.scale(), 2);
-
-        let actual: Vec<_> = (0..arr.len()).map(|i| arr.value_as_string(i)).collect();
-        let expected = vec!["123.45", "4.56", "78.90", "-1232234234324.32"];
-
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "-123223423432432 is too small to store in a Decimal128 of precision 5. Min is -99999"
-    )]
-    fn test_decimal_array_with_precision_and_scale_out_of_range() {
-        Decimal128Array::from_iter_values([12345, 456, 7890, -123223423432432])
-            // precision is too small to hold value
-            .with_precision_and_scale(5, 2)
-            .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "precision 40 is greater than max 38")]
-    fn test_decimal_array_with_precision_and_scale_invalid_precision() {
-        Decimal128Array::from_iter_values([12345, 456])
-            .with_precision_and_scale(40, 2)
-            .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "scale 40 is greater than max 38")]
-    fn test_decimal_array_with_precision_and_scale_invalid_scale() {
-        Decimal128Array::from_iter_values([12345, 456])
-            .with_precision_and_scale(20, 40)
-            .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "scale 10 is greater than precision 4")]
-    fn test_decimal_array_with_precision_and_scale_invalid_precision_and_scale() {
-        Decimal128Array::from_iter_values([12345, 456])
-            .with_precision_and_scale(4, 10)
-            .unwrap();
-    }
-
-    #[test]
-    fn test_decimal_array_fmt_debug() {
-        let arr = [Some(8887000000), Some(-8887000000), None]
-            .iter()
-            .collect::<Decimal128Array>()
-            .with_precision_and_scale(23, 6)
-            .unwrap();
-
-        assert_eq!(
-            "Decimal128Array<23, 6>\n[\n  8887.000000,\n  -8887.000000,\n  null,\n]",
-            format!("{:?}", arr)
-        );
-    }
-
-    #[test]
-    fn test_decimal_array_from_fixed_size_binary() {
-        let value_data = ArrayData::builder(DataType::FixedSizeBinary(16))
-            .offset(1)
-            .len(3)
-            .add_buffer(Buffer::from_slice_ref(&[99999_i128, 2, 34, 560]))
-            .null_bit_buffer(Some(Buffer::from_slice_ref(&[0b1010])))
-            .build()
-            .unwrap();
-
-        let binary_array = FixedSizeBinaryArray::from(value_data);
-        let decimal = Decimal128Array::from_fixed_size_binary_array(binary_array, 38, 1);
-
-        assert_eq!(decimal.len(), 3);
-        assert_eq!(decimal.value_as_string(0), "0.2".to_string());
-        assert!(decimal.is_null(1));
-        assert_eq!(decimal.value_as_string(2), "56.0".to_string());
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Value length of the array (8) must equal to the byte width of the decimal (16)"
-    )]
-    fn test_decimal_array_from_fixed_size_binary_wrong_length() {
-        let value_data = ArrayData::builder(DataType::FixedSizeBinary(8))
-            .offset(1)
-            .len(3)
-            .add_buffer(Buffer::from_slice_ref(&[99999_i64, 2, 34, 560]))
-            .null_bit_buffer(Some(Buffer::from_slice_ref(&[0b1010])))
-            .build()
-            .unwrap();
-
-        let binary_array = FixedSizeBinaryArray::from(value_data);
-        let _ = Decimal128Array::from_fixed_size_binary_array(binary_array, 38, 1);
-    }
-
-    #[test]
-    #[allow(deprecated)]
-    fn test_decimal_array_from_fixed_size_list() {
-        let value_data = ArrayData::builder(DataType::UInt8)
-            .offset(16)
-            .len(48)
-            .add_buffer(Buffer::from_slice_ref(&[99999_i128, 12, 34, 56]))
-            .build()
-            .unwrap();
-
-        let null_buffer = Buffer::from_slice_ref(&[0b101]);
-
-        // Construct a list array from the above two
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::UInt8, false)),
-            16,
-        );
-        let list_data = ArrayData::builder(list_data_type)
-            .len(2)
-            .null_bit_buffer(Some(null_buffer))
-            .offset(1)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-        let list_array = FixedSizeListArray::from(list_data);
-        let decimal = Decimal128Array::from_fixed_size_list_array(list_array, 38, 0);
-
-        assert_eq!(decimal.len(), 2);
-        assert!(decimal.is_null(0));
-        assert_eq!(decimal.value_as_string(1), "56".to_string());
-    }
-
-    #[test]
-    #[allow(deprecated)]
-    #[should_panic(expected = "The child array cannot contain null values.")]
-    fn test_decimal_array_from_fixed_size_list_with_child_nulls_failed() {
-        let value_data = ArrayData::builder(DataType::UInt8)
-            .len(16)
-            .add_buffer(Buffer::from_slice_ref(&[12_i128]))
-            .null_bit_buffer(Some(Buffer::from_slice_ref(&[0b1010101010101010])))
-            .build()
-            .unwrap();
-
-        // Construct a list array from the above two
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::UInt8, false)),
-            16,
-        );
-        let list_data = ArrayData::builder(list_data_type)
-            .len(1)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-        let list_array = FixedSizeListArray::from(list_data);
-        drop(Decimal128Array::from_fixed_size_list_array(
-            list_array, 38, 0,
-        ));
-    }
-
-    #[test]
-    #[allow(deprecated)]
-    #[should_panic(
-        expected = "Value length of the array (8) must equal to the byte width of the decimal (16)"
-    )]
-    fn test_decimal_array_from_fixed_size_list_with_wrong_length() {
-        let value_data = ArrayData::builder(DataType::UInt8)
-            .len(16)
-            .add_buffer(Buffer::from_slice_ref(&[12_i128]))
-            .null_bit_buffer(Some(Buffer::from_slice_ref(&[0b1010101010101010])))
-            .build()
-            .unwrap();
-
-        // Construct a list array from the above two
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::UInt8, false)),
-            8,
-        );
-        let list_data = ArrayData::builder(list_data_type)
-            .len(2)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-        let list_array = FixedSizeListArray::from(list_data);
-        drop(Decimal128Array::from_fixed_size_list_array(
-            list_array, 38, 0,
-        ));
-    }
-
-    #[test]
-    fn test_decimal256_iter() {
-        let mut builder = Decimal256Builder::new(30, 76, 6);
-        let value = BigInt::from_str_radix("12345", 10).unwrap();
-        let decimal1 = Decimal256::from_big_int(&value, 76, 6).unwrap();
-        builder.append_value(&decimal1).unwrap();
-
-        builder.append_null();
-
-        let value = BigInt::from_str_radix("56789", 10).unwrap();
-        let decimal2 = Decimal256::from_big_int(&value, 76, 6).unwrap();
-        builder.append_value(&decimal2).unwrap();
-
-        let array: Decimal256Array = builder.finish();
-
-        let collected: Vec<_> = array.iter().collect();
-        assert_eq!(vec![Some(decimal1), None, Some(decimal2)], collected);
-    }
-
-    #[test]
-    fn test_from_iter_decimal256array() {
-        let value1 = BigInt::from_str_radix("12345", 10).unwrap();
-        let value2 = BigInt::from_str_radix("56789", 10).unwrap();
-
-        let array: Decimal256Array =
-            vec![Some(value1.clone()), None, Some(value2.clone())]
-                .into_iter()
-                .collect();
-        assert_eq!(array.len(), 3);
-        assert_eq!(array.data_type(), &DataType::Decimal256(76, 10));
-        assert_eq!(
-            Decimal256::from_big_int(
-                &value1,
-                DECIMAL256_MAX_PRECISION,
-                DECIMAL_DEFAULT_SCALE
-            )
-            .unwrap(),
-            array.value(0)
-        );
-        assert!(!array.is_null(0));
-        assert!(array.is_null(1));
-        assert_eq!(
-            Decimal256::from_big_int(
-                &value2,
-                DECIMAL256_MAX_PRECISION,
-                DECIMAL_DEFAULT_SCALE
-            )
-            .unwrap(),
-            array.value(2)
-        );
-        assert!(!array.is_null(2));
-    }
-}
diff --git a/arrow/src/array/array_dictionary.rs b/arrow/src/array/array_dictionary.rs
deleted file mode 100644
index 2acb51750d17..000000000000
--- a/arrow/src/array/array_dictionary.rs
+++ /dev/null
@@ -1,801 +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.
-
-use crate::array::{ArrayAccessor, ArrayIter};
-use std::any::Any;
-use std::fmt;
-use std::iter::IntoIterator;
-use std::{convert::From, iter::FromIterator};
-
-use super::{
-    make_array, Array, ArrayData, ArrayRef, PrimitiveArray, PrimitiveBuilder,
-    StringArray, StringBuilder, StringDictionaryBuilder,
-};
-use crate::datatypes::{
-    ArrowDictionaryKeyType, ArrowNativeType, ArrowPrimitiveType, DataType,
-};
-use crate::error::Result;
-
-/// A dictionary array where each element is a single value indexed by an integer key.
-/// This is mostly used to represent strings or a limited set of primitive types as integers,
-/// for example when doing NLP analysis or representing chromosomes by name.
-///
-/// [`DictionaryArray`] are represented using a `keys` array and a
-/// `values` array, which may be different lengths. The `keys` array
-/// stores indexes in the `values` array which holds
-/// the corresponding logical value, as shown here:
-///
-/// ```text
-/// ┌ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─
-///   ┌─────────────────┐  ┌─────────┐ │     ┌─────────────────┐
-/// │ │        A        │  │    0    │       │        A        │     values[keys[0]]
-///   ├─────────────────┤  ├─────────┤ │     ├─────────────────┤
-/// │ │        D        │  │    2    │       │        B        │     values[keys[1]]
-///   ├─────────────────┤  ├─────────┤ │     ├─────────────────┤
-/// │ │        B        │  │    2    │       │        B        │     values[keys[2]]
-///   └─────────────────┘  ├─────────┤ │     ├─────────────────┤
-/// │                      │    1    │       │        D        │     values[keys[3]]
-///                        ├─────────┤ │     ├─────────────────┤
-/// │                      │    1    │       │        D        │     values[keys[4]]
-///                        ├─────────┤ │     ├─────────────────┤
-/// │                      │    0    │       │        A        │     values[keys[5]]
-///                        └─────────┘ │     └─────────────────┘
-/// │       values            keys
-///  ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ─ ┘
-///                                             Logical array
-///                                                Contents
-///           DictionaryArray
-///              length = 6
-/// ```
-///
-/// Example **with nullable** data:
-///
-/// ```
-/// use arrow::array::{DictionaryArray, Int8Array};
-/// use arrow::datatypes::Int8Type;
-/// let test = vec!["a", "a", "b", "c"];
-/// let array : DictionaryArray<Int8Type> = test.iter().map(|&x| if x == "b" {None} else {Some(x)}).collect();
-/// assert_eq!(array.keys(), &Int8Array::from(vec![Some(0), Some(0), None, Some(1)]));
-/// ```
-///
-/// Example **without nullable** data:
-///
-/// ```
-/// use arrow::array::{DictionaryArray, Int8Array};
-/// use arrow::datatypes::Int8Type;
-/// let test = vec!["a", "a", "b", "c"];
-/// let array : DictionaryArray<Int8Type> = test.into_iter().collect();
-/// assert_eq!(array.keys(), &Int8Array::from(vec![0, 0, 1, 2]));
-/// ```
-///
-/// Example from existing arrays:
-///
-/// ```
-/// use arrow::array::{DictionaryArray, Int8Array, StringArray};
-/// use arrow::datatypes::Int8Type;
-/// // You can form your own DictionaryArray by providing the
-/// // values (dictionary) and keys (indexes into the dictionary):
-/// let values = StringArray::from_iter_values(["a", "b", "c"]);
-/// let keys = Int8Array::from_iter_values([0, 0, 1, 2]);
-/// let array = DictionaryArray::<Int8Type>::try_new(&keys, &values).unwrap();
-/// let expected: DictionaryArray::<Int8Type> = vec!["a", "a", "b", "c"]
-///    .into_iter()
-///    .collect();
-/// assert_eq!(&array, &expected);
-/// ```
-pub struct DictionaryArray<K: ArrowPrimitiveType> {
-    /// Data of this dictionary. Note that this is _not_ compatible with the C Data interface,
-    /// as, in the current implementation, `values` below are the first child of this struct.
-    data: ArrayData,
-
-    /// The keys of this dictionary. These are constructed from the
-    /// buffer and null bitmap of `data`.  Also, note that these do
-    /// not correspond to the true values of this array. Rather, they
-    /// map to the real values.
-    keys: PrimitiveArray<K>,
-
-    /// Array of dictionary values (can by any DataType).
-    values: ArrayRef,
-
-    /// Values are ordered.
-    is_ordered: bool,
-}
-
-impl<K: ArrowPrimitiveType> DictionaryArray<K> {
-    /// Attempt to create a new DictionaryArray with a specified keys
-    /// (indexes into the dictionary) and values (dictionary)
-    /// array. Returns an error if there are any keys that are outside
-    /// of the dictionary array.
-    pub fn try_new(keys: &PrimitiveArray<K>, values: &dyn Array) -> Result<Self> {
-        let dict_data_type = DataType::Dictionary(
-            Box::new(keys.data_type().clone()),
-            Box::new(values.data_type().clone()),
-        );
-
-        // Note: This use the ArrayDataBuilder::build_unchecked and afterwards
-        // call the new function which only validates that the keys are in bounds.
-        let mut data = ArrayData::builder(dict_data_type)
-            .len(keys.len())
-            .add_buffer(keys.data().buffers()[0].clone())
-            .add_child_data(values.data().clone());
-
-        match keys.data().null_buffer() {
-            Some(buffer) if keys.data().null_count() > 0 => {
-                data = data
-                    .null_bit_buffer(Some(buffer.clone()))
-                    .null_count(keys.data().null_count());
-            }
-            _ => data = data.null_count(0),
-        }
-
-        // Safety: `validate` ensures key type is correct, and
-        //  `validate_values` ensures all offsets are within range
-        let array = unsafe { data.build_unchecked() };
-
-        array.validate()?;
-        array.validate_values()?;
-
-        Ok(array.into())
-    }
-
-    /// Create a new DictionaryArray directly from specified keys
-    /// (indexes into the dictionary) and values (dictionary)
-    /// array, and the corresponding ArrayData. This is used internally
-    /// for the usage like filter kernel.
-    ///
-    /// # Safety
-    ///
-    /// The input keys, values and data must form a valid DictionaryArray,
-    /// or undefined behavior can occur.
-    pub(crate) unsafe fn try_new_unchecked(
-        keys: PrimitiveArray<K>,
-        values: ArrayRef,
-        data: ArrayData,
-    ) -> Self {
-        Self {
-            data,
-            keys,
-            values,
-            is_ordered: false,
-        }
-    }
-
-    /// Return an array view of the keys of this dictionary as a PrimitiveArray.
-    pub fn keys(&self) -> &PrimitiveArray<K> {
-        &self.keys
-    }
-
-    /// If `value` is present in `values` (aka the dictionary),
-    /// returns the corresponding key (index into the `values`
-    /// array). Otherwise returns `None`.
-    ///
-    /// Panics if `values` is not a [`StringArray`].
-    pub fn lookup_key(&self, value: &str) -> Option<K::Native> {
-        let rd_buf: &StringArray =
-            self.values.as_any().downcast_ref::<StringArray>().unwrap();
-
-        (0..rd_buf.len())
-            .position(|i| rd_buf.value(i) == value)
-            .and_then(K::Native::from_usize)
-    }
-
-    /// Returns a reference to the dictionary values array
-    pub fn values(&self) -> &ArrayRef {
-        &self.values
-    }
-
-    /// Returns a clone of the value type of this list.
-    pub fn value_type(&self) -> DataType {
-        self.values.data_ref().data_type().clone()
-    }
-
-    /// The length of the dictionary is the length of the keys array.
-    pub fn len(&self) -> usize {
-        self.keys.len()
-    }
-
-    /// Whether this dictionary is empty
-    pub fn is_empty(&self) -> bool {
-        self.keys.is_empty()
-    }
-
-    /// Currently exists for compatibility purposes with Arrow IPC.
-    pub fn is_ordered(&self) -> bool {
-        self.is_ordered
-    }
-
-    /// Return an iterator over the keys (indexes into the dictionary)
-    pub fn keys_iter(&self) -> impl Iterator<Item = Option<usize>> + '_ {
-        self.keys
-            .iter()
-            .map(|key| key.map(|k| k.to_usize().expect("Dictionary index not usize")))
-    }
-
-    /// Return the value of `keys` (the dictionary key) at index `i`,
-    /// cast to `usize`, `None` if the value at `i` is `NULL`.
-    pub fn key(&self, i: usize) -> Option<usize> {
-        self.keys.is_valid(i).then(|| {
-            self.keys
-                .value(i)
-                .to_usize()
-                .expect("Dictionary index not usize")
-        })
-    }
-
-    /// Downcast this dictionary to a [`TypedDictionaryArray`]
-    ///
-    /// ```
-    /// use arrow::array::{Array, ArrayAccessor, DictionaryArray, StringArray};
-    /// use arrow::datatypes::Int32Type;
-    ///
-    /// let orig = [Some("a"), Some("b"), None];
-    /// let dictionary = DictionaryArray::<Int32Type>::from_iter(orig);
-    /// let typed = dictionary.downcast_dict::<StringArray>().unwrap();
-    /// assert_eq!(typed.value(0), "a");
-    /// assert_eq!(typed.value(1), "b");
-    /// assert!(typed.is_null(2));
-    /// ```
-    ///
-    pub fn downcast_dict<V: 'static>(&self) -> Option<TypedDictionaryArray<'_, K, V>> {
-        let values = self.values.as_any().downcast_ref()?;
-        Some(TypedDictionaryArray {
-            dictionary: self,
-            values,
-        })
-    }
-}
-
-/// Constructs a `DictionaryArray` from an array data reference.
-impl<T: ArrowPrimitiveType> From<ArrayData> for DictionaryArray<T> {
-    fn from(data: ArrayData) -> Self {
-        assert_eq!(
-            data.buffers().len(),
-            1,
-            "DictionaryArray data should contain a single buffer only (keys)."
-        );
-        assert_eq!(
-            data.child_data().len(),
-            1,
-            "DictionaryArray should contain a single child array (values)."
-        );
-
-        if let DataType::Dictionary(key_data_type, _) = data.data_type() {
-            if key_data_type.as_ref() != &T::DATA_TYPE {
-                panic!("DictionaryArray's data type must match.")
-            };
-            // create a zero-copy of the keys' data
-            let keys = PrimitiveArray::<T>::from(unsafe {
-                ArrayData::new_unchecked(
-                    T::DATA_TYPE,
-                    data.len(),
-                    Some(data.null_count()),
-                    data.null_buffer().cloned(),
-                    data.offset(),
-                    data.buffers().to_vec(),
-                    vec![],
-                )
-            });
-            let values = make_array(data.child_data()[0].clone());
-            Self {
-                data,
-                keys,
-                values,
-                is_ordered: false,
-            }
-        } else {
-            panic!("DictionaryArray must have Dictionary data type.")
-        }
-    }
-}
-
-impl<T: ArrowPrimitiveType> From<DictionaryArray<T>> for ArrayData {
-    fn from(array: DictionaryArray<T>) -> Self {
-        array.data
-    }
-}
-
-/// Constructs a `DictionaryArray` from an iterator of optional strings.
-///
-/// # Example:
-/// ```
-/// use arrow::array::{DictionaryArray, PrimitiveArray, StringArray};
-/// use arrow::datatypes::Int8Type;
-///
-/// let test = vec!["a", "a", "b", "c"];
-/// let array: DictionaryArray<Int8Type> = test
-///     .iter()
-///     .map(|&x| if x == "b" { None } else { Some(x) })
-///     .collect();
-/// assert_eq!(
-///     "DictionaryArray {keys: PrimitiveArray<Int8>\n[\n  0,\n  0,\n  null,\n  1,\n] values: StringArray\n[\n  \"a\",\n  \"c\",\n]}\n",
-///     format!("{:?}", array)
-/// );
-/// ```
-impl<'a, T: ArrowDictionaryKeyType> FromIterator<Option<&'a str>> for DictionaryArray<T> {
-    fn from_iter<I: IntoIterator<Item = Option<&'a str>>>(iter: I) -> Self {
-        let it = iter.into_iter();
-        let (lower, _) = it.size_hint();
-        let key_builder = PrimitiveBuilder::<T>::new(lower);
-        let value_builder = StringBuilder::new(256);
-        let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
-        it.for_each(|i| {
-            if let Some(i) = i {
-                // Note: impl ... for Result<DictionaryArray<T>> fails with
-                // error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
-                builder
-                    .append(i)
-                    .expect("Unable to append a value to a dictionary array.");
-            } else {
-                builder.append_null();
-            }
-        });
-
-        builder.finish()
-    }
-}
-
-/// Constructs a `DictionaryArray` from an iterator of strings.
-///
-/// # Example:
-///
-/// ```
-/// use arrow::array::{DictionaryArray, PrimitiveArray, StringArray};
-/// use arrow::datatypes::Int8Type;
-///
-/// let test = vec!["a", "a", "b", "c"];
-/// let array: DictionaryArray<Int8Type> = test.into_iter().collect();
-/// assert_eq!(
-///     "DictionaryArray {keys: PrimitiveArray<Int8>\n[\n  0,\n  0,\n  1,\n  2,\n] values: StringArray\n[\n  \"a\",\n  \"b\",\n  \"c\",\n]}\n",
-///     format!("{:?}", array)
-/// );
-/// ```
-impl<'a, T: ArrowDictionaryKeyType> FromIterator<&'a str> for DictionaryArray<T> {
-    fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> Self {
-        let it = iter.into_iter();
-        let (lower, _) = it.size_hint();
-        let key_builder = PrimitiveBuilder::<T>::new(lower);
-        let value_builder = StringBuilder::new(256);
-        let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
-        it.for_each(|i| {
-            builder
-                .append(i)
-                .expect("Unable to append a value to a dictionary array.");
-        });
-
-        builder.finish()
-    }
-}
-
-impl<T: ArrowPrimitiveType> Array for DictionaryArray<T> {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.into()
-    }
-}
-
-impl<T: ArrowPrimitiveType> fmt::Debug for DictionaryArray<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(
-            f,
-            "DictionaryArray {{keys: {:?} values: {:?}}}",
-            self.keys, self.values
-        )
-    }
-}
-
-/// A strongly-typed wrapper around a [`DictionaryArray`] that implements [`ArrayAccessor`]
-/// allowing fast access to its elements
-///
-/// ```
-/// use arrow::array::{ArrayIter, DictionaryArray, StringArray};
-/// use arrow::datatypes::Int32Type;
-///
-/// let orig = ["a", "b", "a", "b"];
-/// let dictionary = DictionaryArray::<Int32Type>::from_iter(orig);
-///
-/// // `TypedDictionaryArray` allows you to access the values directly
-/// let typed = dictionary.downcast_dict::<StringArray>().unwrap();
-///
-/// for (maybe_val, orig) in typed.into_iter().zip(orig) {
-///     assert_eq!(maybe_val.unwrap(), orig)
-/// }
-/// ```
-pub struct TypedDictionaryArray<'a, K: ArrowPrimitiveType, V> {
-    /// The dictionary array
-    dictionary: &'a DictionaryArray<K>,
-    /// The values of the dictionary
-    values: &'a V,
-}
-
-// Manually implement `Clone` to avoid `V: Clone` type constraint
-impl<'a, K: ArrowPrimitiveType, V> Clone for TypedDictionaryArray<'a, K, V> {
-    fn clone(&self) -> Self {
-        Self {
-            dictionary: self.dictionary,
-            values: self.values,
-        }
-    }
-}
-
-impl<'a, K: ArrowPrimitiveType, V> Copy for TypedDictionaryArray<'a, K, V> {}
-
-impl<'a, K: ArrowPrimitiveType, V> fmt::Debug for TypedDictionaryArray<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        writeln!(f, "TypedDictionaryArray({:?})", self.dictionary)
-    }
-}
-
-impl<'a, K: ArrowPrimitiveType, V> TypedDictionaryArray<'a, K, V> {
-    /// Returns the keys of this [`TypedDictionaryArray`]
-    pub fn keys(&self) -> &'a PrimitiveArray<K> {
-        self.dictionary.keys()
-    }
-
-    /// Returns the values of this [`TypedDictionaryArray`]
-    pub fn values(&self) -> &'a V {
-        self.values
-    }
-}
-
-impl<'a, K: ArrowPrimitiveType, V: Sync> Array for TypedDictionaryArray<'a, K, V> {
-    fn as_any(&self) -> &dyn Any {
-        self.dictionary
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.dictionary.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.dictionary.into_data()
-    }
-}
-
-impl<'a, K, V> IntoIterator for TypedDictionaryArray<'a, K, V>
-where
-    K: ArrowPrimitiveType,
-    V: Sync + Send,
-    &'a V: ArrayAccessor,
-{
-    type Item = Option<<Self as ArrayAccessor>::Item>;
-    type IntoIter = ArrayIter<Self>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        ArrayIter::new(self)
-    }
-}
-
-impl<'a, K, V> ArrayAccessor for TypedDictionaryArray<'a, K, V>
-where
-    K: ArrowPrimitiveType,
-    V: Sync + Send,
-    &'a V: ArrayAccessor,
-{
-    type Item = <&'a V as ArrayAccessor>::Item;
-
-    fn value(&self, index: usize) -> Self::Item {
-        assert!(self.dictionary.is_valid(index), "{}", index);
-        let value_idx = self.dictionary.keys.value(index).to_usize().unwrap();
-        // Dictionary indexes should be valid
-        unsafe { self.values.value_unchecked(value_idx) }
-    }
-
-    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
-        let val = self.dictionary.keys.value_unchecked(index);
-        let value_idx = val.to_usize().unwrap();
-        // Dictionary indexes should be valid
-        self.values.value_unchecked(value_idx)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use crate::array::{Float32Array, Int8Array};
-    use crate::datatypes::{Float32Type, Int16Type};
-    use crate::{
-        array::Int16DictionaryArray, array::PrimitiveDictionaryBuilder,
-        datatypes::DataType,
-    };
-    use crate::{
-        array::{Int16Array, Int32Array},
-        datatypes::{Int32Type, Int8Type, UInt32Type, UInt8Type},
-    };
-    use crate::{buffer::Buffer, datatypes::ToByteSlice};
-
-    #[test]
-    fn test_dictionary_array() {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int8)
-            .len(8)
-            .add_buffer(Buffer::from(
-                &[10_i8, 11, 12, 13, 14, 15, 16, 17].to_byte_slice(),
-            ))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        let keys = Buffer::from(&[2_i16, 3, 4].to_byte_slice());
-
-        // Construct a dictionary array from the above two
-        let key_type = DataType::Int16;
-        let value_type = DataType::Int8;
-        let dict_data_type =
-            DataType::Dictionary(Box::new(key_type), Box::new(value_type));
-        let dict_data = ArrayData::builder(dict_data_type.clone())
-            .len(3)
-            .add_buffer(keys.clone())
-            .add_child_data(value_data.clone())
-            .build()
-            .unwrap();
-        let dict_array = Int16DictionaryArray::from(dict_data);
-
-        let values = dict_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int8, dict_array.value_type());
-        assert_eq!(3, dict_array.len());
-
-        // Null count only makes sense in terms of the component arrays.
-        assert_eq!(0, dict_array.null_count());
-        assert_eq!(0, dict_array.values().null_count());
-        assert_eq!(dict_array.keys(), &Int16Array::from(vec![2_i16, 3, 4]));
-
-        // Now test with a non-zero offset
-        let dict_data = ArrayData::builder(dict_data_type)
-            .len(2)
-            .offset(1)
-            .add_buffer(keys)
-            .add_child_data(value_data.clone())
-            .build()
-            .unwrap();
-        let dict_array = Int16DictionaryArray::from(dict_data);
-
-        let values = dict_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int8, dict_array.value_type());
-        assert_eq!(2, dict_array.len());
-        assert_eq!(dict_array.keys(), &Int16Array::from(vec![3_i16, 4]));
-    }
-
-    #[test]
-    fn test_dictionary_array_fmt_debug() {
-        let key_builder = PrimitiveBuilder::<UInt8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<UInt32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(12345678).unwrap();
-        builder.append_null();
-        builder.append(22345678).unwrap();
-        let array = builder.finish();
-        assert_eq!(
-            "DictionaryArray {keys: PrimitiveArray<UInt8>\n[\n  0,\n  null,\n  1,\n] values: PrimitiveArray<UInt32>\n[\n  12345678,\n  22345678,\n]}\n",
-            format!("{:?}", array)
-        );
-
-        let key_builder = PrimitiveBuilder::<UInt8Type>::new(20);
-        let value_builder = PrimitiveBuilder::<UInt32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        for _ in 0..20 {
-            builder.append(1).unwrap();
-        }
-        let array = builder.finish();
-        assert_eq!(
-            "DictionaryArray {keys: PrimitiveArray<UInt8>\n[\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n  0,\n] values: PrimitiveArray<UInt32>\n[\n  1,\n]}\n",
-            format!("{:?}", array)
-        );
-    }
-
-    #[test]
-    fn test_dictionary_array_from_iter() {
-        let test = vec!["a", "a", "b", "c"];
-        let array: DictionaryArray<Int8Type> = test
-            .iter()
-            .map(|&x| if x == "b" { None } else { Some(x) })
-            .collect();
-        assert_eq!(
-            "DictionaryArray {keys: PrimitiveArray<Int8>\n[\n  0,\n  0,\n  null,\n  1,\n] values: StringArray\n[\n  \"a\",\n  \"c\",\n]}\n",
-            format!("{:?}", array)
-        );
-
-        let array: DictionaryArray<Int8Type> = test.into_iter().collect();
-        assert_eq!(
-            "DictionaryArray {keys: PrimitiveArray<Int8>\n[\n  0,\n  0,\n  1,\n  2,\n] values: StringArray\n[\n  \"a\",\n  \"b\",\n  \"c\",\n]}\n",
-            format!("{:?}", array)
-        );
-    }
-
-    #[test]
-    fn test_dictionary_array_reverse_lookup_key() {
-        let test = vec!["a", "a", "b", "c"];
-        let array: DictionaryArray<Int8Type> = test.into_iter().collect();
-
-        assert_eq!(array.lookup_key("c"), Some(2));
-
-        // Direction of building a dictionary is the iterator direction
-        let test = vec!["t3", "t3", "t2", "t2", "t1", "t3", "t4", "t1", "t0"];
-        let array: DictionaryArray<Int8Type> = test.into_iter().collect();
-
-        assert_eq!(array.lookup_key("t1"), Some(2));
-        assert_eq!(array.lookup_key("non-existent"), None);
-    }
-
-    #[test]
-    fn test_dictionary_keys_as_primitive_array() {
-        let test = vec!["a", "b", "c", "a"];
-        let array: DictionaryArray<Int8Type> = test.into_iter().collect();
-
-        let keys = array.keys();
-        assert_eq!(&DataType::Int8, keys.data_type());
-        assert_eq!(0, keys.null_count());
-        assert_eq!(&[0, 1, 2, 0], keys.values());
-    }
-
-    #[test]
-    fn test_dictionary_keys_as_primitive_array_with_null() {
-        let test = vec![Some("a"), None, Some("b"), None, None, Some("a")];
-        let array: DictionaryArray<Int32Type> = test.into_iter().collect();
-
-        let keys = array.keys();
-        assert_eq!(&DataType::Int32, keys.data_type());
-        assert_eq!(3, keys.null_count());
-
-        assert!(keys.is_valid(0));
-        assert!(!keys.is_valid(1));
-        assert!(keys.is_valid(2));
-        assert!(!keys.is_valid(3));
-        assert!(!keys.is_valid(4));
-        assert!(keys.is_valid(5));
-
-        assert_eq!(0, keys.value(0));
-        assert_eq!(1, keys.value(2));
-        assert_eq!(0, keys.value(5));
-    }
-
-    #[test]
-    fn test_dictionary_all_nulls() {
-        let test = vec![None, None, None];
-        let array: DictionaryArray<Int32Type> = test.into_iter().collect();
-        array
-            .data()
-            .validate_full()
-            .expect("All null array has valid array data");
-    }
-
-    #[test]
-    fn test_dictionary_iter() {
-        // Construct a value array
-        let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
-        let keys = Int16Array::from_iter_values([2_i16, 3, 4]);
-
-        // Construct a dictionary array from the above two
-        let dict_array = DictionaryArray::<Int16Type>::try_new(&keys, &values).unwrap();
-
-        let mut key_iter = dict_array.keys_iter();
-        assert_eq!(2, key_iter.next().unwrap().unwrap());
-        assert_eq!(3, key_iter.next().unwrap().unwrap());
-        assert_eq!(4, key_iter.next().unwrap().unwrap());
-        assert!(key_iter.next().is_none());
-
-        let mut iter = dict_array
-            .values()
-            .as_any()
-            .downcast_ref::<Int8Array>()
-            .unwrap()
-            .take_iter(dict_array.keys_iter());
-
-        assert_eq!(12, iter.next().unwrap().unwrap());
-        assert_eq!(13, iter.next().unwrap().unwrap());
-        assert_eq!(14, iter.next().unwrap().unwrap());
-        assert!(iter.next().is_none());
-    }
-
-    #[test]
-    fn test_dictionary_iter_with_null() {
-        let test = vec![Some("a"), None, Some("b"), None, None, Some("a")];
-        let array: DictionaryArray<Int32Type> = test.into_iter().collect();
-
-        let mut iter = array
-            .values()
-            .as_any()
-            .downcast_ref::<StringArray>()
-            .unwrap()
-            .take_iter(array.keys_iter());
-
-        assert_eq!("a", iter.next().unwrap().unwrap());
-        assert!(iter.next().unwrap().is_none());
-        assert_eq!("b", iter.next().unwrap().unwrap());
-        assert!(iter.next().unwrap().is_none());
-        assert!(iter.next().unwrap().is_none());
-        assert_eq!("a", iter.next().unwrap().unwrap());
-        assert!(iter.next().is_none());
-    }
-
-    #[test]
-    fn test_dictionary_key() {
-        let keys = Int8Array::from(vec![Some(2), None, Some(1)]);
-        let values = StringArray::from(vec!["foo", "bar", "baz", "blarg"]);
-
-        let array = DictionaryArray::try_new(&keys, &values).unwrap();
-        assert_eq!(array.key(0), Some(2));
-        assert_eq!(array.key(1), None);
-        assert_eq!(array.key(2), Some(1));
-    }
-
-    #[test]
-    fn test_try_new() {
-        let values: StringArray = [Some("foo"), Some("bar"), Some("baz")]
-            .into_iter()
-            .collect();
-        let keys: Int32Array = [Some(0), Some(2), None, Some(1)].into_iter().collect();
-
-        let array = DictionaryArray::<Int32Type>::try_new(&keys, &values).unwrap();
-        assert_eq!(array.keys().data_type(), &DataType::Int32);
-        assert_eq!(array.values().data_type(), &DataType::Utf8);
-
-        assert_eq!(array.data().null_count(), 1);
-
-        assert!(array.keys().is_valid(0));
-        assert!(array.keys().is_valid(1));
-        assert!(array.keys().is_null(2));
-        assert!(array.keys().is_valid(3));
-
-        assert_eq!(array.keys().value(0), 0);
-        assert_eq!(array.keys().value(1), 2);
-        assert_eq!(array.keys().value(3), 1);
-
-        assert_eq!(
-            "DictionaryArray {keys: PrimitiveArray<Int32>\n[\n  0,\n  2,\n  null,\n  1,\n] values: StringArray\n[\n  \"foo\",\n  \"bar\",\n  \"baz\",\n]}\n",
-            format!("{:?}", array)
-        );
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Value at position 1 out of bounds: 3 (should be in [0, 1])"
-    )]
-    fn test_try_new_index_too_large() {
-        let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
-        // dictionary only has 2 values, so offset 3 is out of bounds
-        let keys: Int32Array = [Some(0), Some(3)].into_iter().collect();
-        DictionaryArray::<Int32Type>::try_new(&keys, &values).unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Value at position 0 out of bounds: -100 (should be in [0, 1])"
-    )]
-    fn test_try_new_index_too_small() {
-        let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
-        let keys: Int32Array = [Some(-100)].into_iter().collect();
-        DictionaryArray::<Int32Type>::try_new(&keys, &values).unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "Dictionary key type must be integer, but was Float32")]
-    fn test_try_wrong_dictionary_key_type() {
-        let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
-        let keys: Float32Array = [Some(0_f32), None, Some(3_f32)].into_iter().collect();
-        DictionaryArray::<Float32Type>::try_new(&keys, &values).unwrap();
-    }
-}
diff --git a/arrow/src/array/array_fixed_size_list.rs b/arrow/src/array/array_fixed_size_list.rs
deleted file mode 100644
index fc568d54a831..000000000000
--- a/arrow/src/array/array_fixed_size_list.rs
+++ /dev/null
@@ -1,388 +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.
-
-use std::any::Any;
-use std::fmt;
-
-use super::{array::print_long_array, make_array, Array, ArrayData, ArrayRef};
-use crate::array::array::ArrayAccessor;
-use crate::datatypes::DataType;
-
-/// A list array where each element is a fixed-size sequence of values with the same
-/// type whose maximum length is represented by a i32.
-///
-/// # Example
-///
-/// ```
-/// # use arrow::array::{Array, ArrayData, FixedSizeListArray, Int32Array};
-/// # use arrow::datatypes::{DataType, Field};
-/// # use arrow::buffer::Buffer;
-/// // Construct a value array
-/// let value_data = ArrayData::builder(DataType::Int32)
-///     .len(9)
-///     .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8]))
-///     .build()
-///     .unwrap();
-/// let list_data_type = DataType::FixedSizeList(
-///     Box::new(Field::new("item", DataType::Int32, false)),
-///     3,
-/// );
-/// let list_data = ArrayData::builder(list_data_type.clone())
-///     .len(3)
-///     .add_child_data(value_data.clone())
-///     .build()
-///     .unwrap();
-/// let list_array = FixedSizeListArray::from(list_data);
-/// let list0 = list_array.value(0);
-/// let list1 = list_array.value(1);
-/// let list2 = list_array.value(2);
-///
-/// assert_eq!( &[0, 1, 2], list0.as_any().downcast_ref::<Int32Array>().unwrap().values());
-/// assert_eq!( &[3, 4, 5], list1.as_any().downcast_ref::<Int32Array>().unwrap().values());
-/// assert_eq!( &[6, 7, 8], list2.as_any().downcast_ref::<Int32Array>().unwrap().values());
-/// ```
-///
-/// For non generic lists, you may wish to consider using
-/// [crate::array::FixedSizeBinaryArray]
-pub struct FixedSizeListArray {
-    data: ArrayData,
-    values: ArrayRef,
-    length: i32,
-}
-
-impl FixedSizeListArray {
-    /// Returns a reference to the values of this list.
-    pub fn values(&self) -> ArrayRef {
-        self.values.clone()
-    }
-
-    /// Returns a clone of the value type of this list.
-    pub fn value_type(&self) -> DataType {
-        self.values.data_ref().data_type().clone()
-    }
-
-    /// Returns ith value of this list array.
-    pub fn value(&self, i: usize) -> ArrayRef {
-        self.values
-            .slice(self.value_offset(i) as usize, self.value_length() as usize)
-    }
-
-    /// Returns the offset for value at index `i`.
-    ///
-    /// Note this doesn't do any bound checking, for performance reason.
-    #[inline]
-    pub fn value_offset(&self, i: usize) -> i32 {
-        self.value_offset_at(self.data.offset() + i)
-    }
-
-    /// Returns the length for an element.
-    ///
-    /// All elements have the same length as the array is a fixed size.
-    #[inline]
-    pub const fn value_length(&self) -> i32 {
-        self.length
-    }
-
-    #[inline]
-    const fn value_offset_at(&self, i: usize) -> i32 {
-        i as i32 * self.length
-    }
-}
-
-impl From<ArrayData> for FixedSizeListArray {
-    fn from(data: ArrayData) -> Self {
-        assert_eq!(
-            data.buffers().len(),
-            0,
-            "FixedSizeListArray data should not contain a buffer for value offsets"
-        );
-        assert_eq!(
-            data.child_data().len(),
-            1,
-            "FixedSizeListArray should contain a single child array (values array)"
-        );
-        let values = make_array(data.child_data()[0].clone());
-        let length = match data.data_type() {
-            DataType::FixedSizeList(_, len) => {
-                if *len > 0 {
-                    // check that child data is multiple of length
-                    assert_eq!(
-                        values.len() % *len as usize,
-                        0,
-                        "FixedSizeListArray child array length should be a multiple of {}",
-                        len
-                    );
-                }
-
-                *len
-            }
-            _ => {
-                panic!("FixedSizeListArray data should contain a FixedSizeList data type")
-            }
-        };
-        Self {
-            data,
-            values,
-            length,
-        }
-    }
-}
-
-impl From<FixedSizeListArray> for ArrayData {
-    fn from(array: FixedSizeListArray) -> Self {
-        array.data
-    }
-}
-
-impl Array for FixedSizeListArray {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.into()
-    }
-}
-
-impl ArrayAccessor for FixedSizeListArray {
-    type Item = ArrayRef;
-
-    fn value(&self, index: usize) -> Self::Item {
-        FixedSizeListArray::value(self, index)
-    }
-
-    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
-        FixedSizeListArray::value(self, index)
-    }
-}
-
-impl fmt::Debug for FixedSizeListArray {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "FixedSizeListArray<{}>\n[\n", self.value_length())?;
-        print_long_array(self, f, |array, index, f| {
-            fmt::Debug::fmt(&array.value(index), f)
-        })?;
-        write!(f, "]")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        array::ArrayData, array::Int32Array, buffer::Buffer, datatypes::Field,
-        util::bit_util,
-    };
-
-    use super::*;
-
-    #[test]
-    fn test_fixed_size_list_array() {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(9)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8]))
-            .build()
-            .unwrap();
-
-        // Construct a list array from the above two
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::Int32, false)),
-            3,
-        );
-        let list_data = ArrayData::builder(list_data_type.clone())
-            .len(3)
-            .add_child_data(value_data.clone())
-            .build()
-            .unwrap();
-        let list_array = FixedSizeListArray::from(list_data);
-
-        let values = list_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(3, list_array.len());
-        assert_eq!(0, list_array.null_count());
-        assert_eq!(6, list_array.value_offset(2));
-        assert_eq!(3, list_array.value_length());
-        assert_eq!(
-            0,
-            list_array
-                .value(0)
-                .as_any()
-                .downcast_ref::<Int32Array>()
-                .unwrap()
-                .value(0)
-        );
-        for i in 0..3 {
-            assert!(list_array.is_valid(i));
-            assert!(!list_array.is_null(i));
-        }
-
-        // Now test with a non-zero offset
-        let list_data = ArrayData::builder(list_data_type)
-            .len(3)
-            .offset(1)
-            .add_child_data(value_data.clone())
-            .build()
-            .unwrap();
-        let list_array = FixedSizeListArray::from(list_data);
-
-        let values = list_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(3, list_array.len());
-        assert_eq!(0, list_array.null_count());
-        assert_eq!(
-            3,
-            list_array
-                .value(0)
-                .as_any()
-                .downcast_ref::<Int32Array>()
-                .unwrap()
-                .value(0)
-        );
-        assert_eq!(6, list_array.value_offset(1));
-        assert_eq!(3, list_array.value_length());
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "FixedSizeListArray child array length should be a multiple of 3"
-    )]
-    // Different error messages, so skip for now
-    // https://github.com/apache/arrow-rs/issues/1545
-    #[cfg(not(feature = "force_validate"))]
-    fn test_fixed_size_list_array_unequal_children() {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(8)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7]))
-            .build()
-            .unwrap();
-
-        // Construct a list array from the above two
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::Int32, false)),
-            3,
-        );
-        let list_data = unsafe {
-            ArrayData::builder(list_data_type)
-                .len(3)
-                .add_child_data(value_data)
-                .build_unchecked()
-        };
-        drop(FixedSizeListArray::from(list_data));
-    }
-
-    #[test]
-    fn test_fixed_size_list_array_slice() {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(10)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
-            .build()
-            .unwrap();
-
-        // Set null buts for the nested array:
-        //  [[0, 1], null, null, [6, 7], [8, 9]]
-        // 01011001 00000001
-        let mut null_bits: [u8; 1] = [0; 1];
-        bit_util::set_bit(&mut null_bits, 0);
-        bit_util::set_bit(&mut null_bits, 3);
-        bit_util::set_bit(&mut null_bits, 4);
-
-        // Construct a fixed size list array from the above two
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::Int32, false)),
-            2,
-        );
-        let list_data = ArrayData::builder(list_data_type)
-            .len(5)
-            .add_child_data(value_data.clone())
-            .null_bit_buffer(Some(Buffer::from(null_bits)))
-            .build()
-            .unwrap();
-        let list_array = FixedSizeListArray::from(list_data);
-
-        let values = list_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(5, list_array.len());
-        assert_eq!(2, list_array.null_count());
-        assert_eq!(6, list_array.value_offset(3));
-        assert_eq!(2, list_array.value_length());
-
-        let sliced_array = list_array.slice(1, 4);
-        assert_eq!(4, sliced_array.len());
-        assert_eq!(1, sliced_array.offset());
-        assert_eq!(2, sliced_array.null_count());
-
-        for i in 0..sliced_array.len() {
-            if bit_util::get_bit(&null_bits, sliced_array.offset() + i) {
-                assert!(sliced_array.is_valid(i));
-            } else {
-                assert!(sliced_array.is_null(i));
-            }
-        }
-
-        // Check offset and length for each non-null value.
-        let sliced_list_array = sliced_array
-            .as_any()
-            .downcast_ref::<FixedSizeListArray>()
-            .unwrap();
-        assert_eq!(2, sliced_list_array.value_length());
-        assert_eq!(6, sliced_list_array.value_offset(2));
-        assert_eq!(8, sliced_list_array.value_offset(3));
-    }
-
-    #[test]
-    #[should_panic(expected = "assertion failed: (offset + length) <= self.len()")]
-    fn test_fixed_size_list_array_index_out_of_bound() {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(10)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
-            .build()
-            .unwrap();
-
-        // Set null buts for the nested array:
-        //  [[0, 1], null, null, [6, 7], [8, 9]]
-        // 01011001 00000001
-        let mut null_bits: [u8; 1] = [0; 1];
-        bit_util::set_bit(&mut null_bits, 0);
-        bit_util::set_bit(&mut null_bits, 3);
-        bit_util::set_bit(&mut null_bits, 4);
-
-        // Construct a fixed size list array from the above two
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::Int32, false)),
-            2,
-        );
-        let list_data = ArrayData::builder(list_data_type)
-            .len(5)
-            .add_child_data(value_data)
-            .null_bit_buffer(Some(Buffer::from(null_bits)))
-            .build()
-            .unwrap();
-        let list_array = FixedSizeListArray::from(list_data);
-
-        list_array.value(10);
-    }
-}
diff --git a/arrow/src/array/array_list.rs b/arrow/src/array/array_list.rs
deleted file mode 100644
index b9c05014c3f7..000000000000
--- a/arrow/src/array/array_list.rs
+++ /dev/null
@@ -1,956 +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.
-
-use std::any::Any;
-use std::fmt;
-
-use num::Integer;
-
-use super::{
-    array::print_long_array, make_array, raw_pointer::RawPtrBox, Array, ArrayData,
-    ArrayRef, BooleanBufferBuilder, GenericListArrayIter, PrimitiveArray,
-};
-use crate::array::array::ArrayAccessor;
-use crate::{
-    buffer::MutableBuffer,
-    datatypes::{ArrowNativeType, ArrowPrimitiveType, DataType, Field},
-    error::ArrowError,
-};
-
-/// trait declaring an offset size, relevant for i32 vs i64 array types.
-pub trait OffsetSizeTrait: ArrowNativeType + std::ops::AddAssign + Integer {
-    const IS_LARGE: bool;
-    const PREFIX: &'static str;
-}
-
-impl OffsetSizeTrait for i32 {
-    const IS_LARGE: bool = false;
-    const PREFIX: &'static str = "";
-}
-
-impl OffsetSizeTrait for i64 {
-    const IS_LARGE: bool = true;
-    const PREFIX: &'static str = "Large";
-}
-
-/// Generic struct for a variable-size list array.
-///
-/// Columnar format in Apache Arrow:
-/// <https://arrow.apache.org/docs/format/Columnar.html#variable-size-list-layout>
-///
-/// For non generic lists, you may wish to consider using [`ListArray`] or [`LargeListArray`]`
-pub struct GenericListArray<OffsetSize> {
-    data: ArrayData,
-    values: ArrayRef,
-    value_offsets: RawPtrBox<OffsetSize>,
-}
-
-impl<OffsetSize: OffsetSizeTrait> GenericListArray<OffsetSize> {
-    /// The data type constructor of list array.
-    /// The input is the schema of the child array and
-    /// the output is the [`DataType`], List or LargeList.
-    pub const DATA_TYPE_CONSTRUCTOR: fn(Box<Field>) -> DataType = if OffsetSize::IS_LARGE
-    {
-        DataType::LargeList
-    } else {
-        DataType::List
-    };
-
-    /// Returns a reference to the values of this list.
-    pub fn values(&self) -> ArrayRef {
-        self.values.clone()
-    }
-
-    /// Returns a clone of the value type of this list.
-    pub fn value_type(&self) -> DataType {
-        self.values.data_ref().data_type().clone()
-    }
-
-    /// Returns ith value of this list array.
-    /// # Safety
-    /// Caller must ensure that the index is within the array bounds
-    pub unsafe fn value_unchecked(&self, i: usize) -> ArrayRef {
-        let end = *self.value_offsets().get_unchecked(i + 1);
-        let start = *self.value_offsets().get_unchecked(i);
-        self.values
-            .slice(start.to_usize().unwrap(), (end - start).to_usize().unwrap())
-    }
-
-    /// Returns ith value of this list array.
-    pub fn value(&self, i: usize) -> ArrayRef {
-        let end = self.value_offsets()[i + 1];
-        let start = self.value_offsets()[i];
-        self.values
-            .slice(start.to_usize().unwrap(), (end - start).to_usize().unwrap())
-    }
-
-    /// Returns the offset values in the offsets buffer
-    #[inline]
-    pub fn value_offsets(&self) -> &[OffsetSize] {
-        // Soundness
-        //     pointer alignment & location is ensured by RawPtrBox
-        //     buffer bounds/offset is ensured by the ArrayData instance.
-        unsafe {
-            std::slice::from_raw_parts(
-                self.value_offsets.as_ptr().add(self.data.offset()),
-                self.len() + 1,
-            )
-        }
-    }
-
-    /// Returns the length for value at index `i`.
-    #[inline]
-    pub fn value_length(&self, i: usize) -> OffsetSize {
-        let offsets = self.value_offsets();
-        offsets[i + 1] - offsets[i]
-    }
-
-    /// constructs a new iterator
-    pub fn iter<'a>(&'a self) -> GenericListArrayIter<'a, OffsetSize> {
-        GenericListArrayIter::<'a, OffsetSize>::new(self)
-    }
-
-    #[inline]
-    fn get_type(data_type: &DataType) -> Option<&DataType> {
-        match (OffsetSize::IS_LARGE, data_type) {
-            (true, DataType::LargeList(child)) | (false, DataType::List(child)) => {
-                Some(child.data_type())
-            }
-            _ => None,
-        }
-    }
-
-    /// Creates a [`GenericListArray`] from an iterator of primitive values
-    /// # Example
-    /// ```
-    /// # use arrow::array::ListArray;
-    /// # use arrow::datatypes::Int32Type;
-    /// let data = vec![
-    ///    Some(vec![Some(0), Some(1), Some(2)]),
-    ///    None,
-    ///    Some(vec![Some(3), None, Some(5)]),
-    ///    Some(vec![Some(6), Some(7)]),
-    /// ];
-    /// let list_array = ListArray::from_iter_primitive::<Int32Type, _, _>(data);
-    /// println!("{:?}", list_array);
-    /// ```
-    pub fn from_iter_primitive<T, P, I>(iter: I) -> Self
-    where
-        T: ArrowPrimitiveType,
-        P: AsRef<[Option<<T as ArrowPrimitiveType>::Native>]>
-            + IntoIterator<Item = Option<<T as ArrowPrimitiveType>::Native>>,
-        I: IntoIterator<Item = Option<P>>,
-    {
-        let iterator = iter.into_iter();
-        let (lower, _) = iterator.size_hint();
-
-        let mut offsets =
-            MutableBuffer::new((lower + 1) * std::mem::size_of::<OffsetSize>());
-        let mut length_so_far = OffsetSize::zero();
-        offsets.push(length_so_far);
-
-        let mut null_buf = BooleanBufferBuilder::new(lower);
-
-        let values: PrimitiveArray<T> = iterator
-            .filter_map(|maybe_slice| {
-                // regardless of whether the item is Some, the offsets and null buffers must be updated.
-                match &maybe_slice {
-                    Some(x) => {
-                        length_so_far +=
-                            OffsetSize::from_usize(x.as_ref().len()).unwrap();
-                        null_buf.append(true);
-                    }
-                    None => null_buf.append(false),
-                };
-                offsets.push(length_so_far);
-                maybe_slice
-            })
-            .flatten()
-            .collect();
-
-        let field = Box::new(Field::new("item", T::DATA_TYPE, true));
-        let data_type = Self::DATA_TYPE_CONSTRUCTOR(field);
-        let array_data = ArrayData::builder(data_type)
-            .len(null_buf.len())
-            .add_buffer(offsets.into())
-            .add_child_data(values.into_data())
-            .null_bit_buffer(Some(null_buf.into()));
-        let array_data = unsafe { array_data.build_unchecked() };
-
-        Self::from(array_data)
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> From<ArrayData> for GenericListArray<OffsetSize> {
-    fn from(data: ArrayData) -> Self {
-        Self::try_new_from_array_data(data).expect(
-            "Expected infallable creation of GenericListArray from ArrayDataRef failed",
-        )
-    }
-}
-
-impl<OffsetSize: 'static + OffsetSizeTrait> From<GenericListArray<OffsetSize>>
-    for ArrayData
-{
-    fn from(array: GenericListArray<OffsetSize>) -> Self {
-        array.data
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> GenericListArray<OffsetSize> {
-    fn try_new_from_array_data(data: ArrayData) -> Result<Self, ArrowError> {
-        if data.buffers().len() != 1 {
-            return Err(ArrowError::InvalidArgumentError(
-                format!("ListArray data should contain a single buffer only (value offsets), had {}",
-                        data.len())));
-        }
-
-        if data.child_data().len() != 1 {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "ListArray should contain a single child array (values array), had {}",
-                data.child_data().len()
-            )));
-        }
-
-        let values = data.child_data()[0].clone();
-
-        if let Some(child_data_type) = Self::get_type(data.data_type()) {
-            if values.data_type() != child_data_type {
-                return Err(ArrowError::InvalidArgumentError(format!(
-                    "[Large]ListArray's child datatype {:?} does not \
-                             correspond to the List's datatype {:?}",
-                    values.data_type(),
-                    child_data_type
-                )));
-            }
-        } else {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "[Large]ListArray's datatype must be [Large]ListArray(). It is {:?}",
-                data.data_type()
-            )));
-        }
-
-        let values = make_array(values);
-        let value_offsets = data.buffers()[0].as_ptr();
-        let value_offsets = unsafe { RawPtrBox::<OffsetSize>::new(value_offsets) };
-        Ok(Self {
-            data,
-            values,
-            value_offsets,
-        })
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> Array for GenericListArray<OffsetSize> {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.into()
-    }
-}
-
-impl<'a, OffsetSize: OffsetSizeTrait> ArrayAccessor for &'a GenericListArray<OffsetSize> {
-    type Item = ArrayRef;
-
-    fn value(&self, index: usize) -> Self::Item {
-        GenericListArray::value(self, index)
-    }
-
-    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
-        GenericListArray::value(self, index)
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> fmt::Debug for GenericListArray<OffsetSize> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let prefix = OffsetSize::PREFIX;
-
-        write!(f, "{}ListArray\n[\n", prefix)?;
-        print_long_array(self, f, |array, index, f| {
-            fmt::Debug::fmt(&array.value(index), f)
-        })?;
-        write!(f, "]")
-    }
-}
-
-/// A list array where each element is a variable-sized sequence of values with the same
-/// type whose memory offsets between elements are represented by a i32.
-///
-/// # Example
-///
-/// ```
-/// # use arrow::array::{Array, ListArray, Int32Array};
-/// # use arrow::datatypes::{DataType, Int32Type};
-/// let data = vec![
-///    Some(vec![]),
-///    None,
-///    Some(vec![Some(3), None, Some(5), Some(19)]),
-///    Some(vec![Some(6), Some(7)]),
-/// ];
-/// let list_array = ListArray::from_iter_primitive::<Int32Type, _, _>(data);
-///
-/// assert_eq!(false, list_array.is_valid(1));
-///
-/// let list0 = list_array.value(0);
-/// let list2 = list_array.value(2);
-/// let list3 = list_array.value(3);
-///
-/// assert_eq!(&[] as &[i32], list0.as_any().downcast_ref::<Int32Array>().unwrap().values());
-/// assert_eq!(false, list2.as_any().downcast_ref::<Int32Array>().unwrap().is_valid(1));
-/// assert_eq!(&[6, 7], list3.as_any().downcast_ref::<Int32Array>().unwrap().values());
-/// ```
-pub type ListArray = GenericListArray<i32>;
-
-/// A list array where each element is a variable-sized sequence of values with the same
-/// type whose memory offsets between elements are represented by a i64.
-/// # Example
-///
-/// ```
-/// # use arrow::array::{Array, LargeListArray, Int32Array};
-/// # use arrow::datatypes::{DataType, Int32Type};
-/// let data = vec![
-///    Some(vec![]),
-///    None,
-///    Some(vec![Some(3), None, Some(5), Some(19)]),
-///    Some(vec![Some(6), Some(7)]),
-/// ];
-/// let list_array = LargeListArray::from_iter_primitive::<Int32Type, _, _>(data);
-///
-/// assert_eq!(false, list_array.is_valid(1));
-///
-/// let list0 = list_array.value(0);
-/// let list2 = list_array.value(2);
-/// let list3 = list_array.value(3);
-///
-/// assert_eq!(&[] as &[i32], list0.as_any().downcast_ref::<Int32Array>().unwrap().values());
-/// assert_eq!(false, list2.as_any().downcast_ref::<Int32Array>().unwrap().is_valid(1));
-/// assert_eq!(&[6, 7], list3.as_any().downcast_ref::<Int32Array>().unwrap().values());
-/// ```
-pub type LargeListArray = GenericListArray<i64>;
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        alloc,
-        array::ArrayData,
-        array::Int32Array,
-        buffer::Buffer,
-        datatypes::Field,
-        datatypes::{Int32Type, ToByteSlice},
-        util::bit_util,
-    };
-
-    use super::*;
-
-    fn create_from_buffers() -> ListArray {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(8)
-            .add_buffer(Buffer::from(&[0, 1, 2, 3, 4, 5, 6, 7].to_byte_slice()))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
-        let value_offsets = Buffer::from(&[0, 3, 6, 8].to_byte_slice());
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, true)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(3)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-        ListArray::from(list_data)
-    }
-
-    #[test]
-    fn test_from_iter_primitive() {
-        let data = vec![
-            Some(vec![Some(0), Some(1), Some(2)]),
-            Some(vec![Some(3), Some(4), Some(5)]),
-            Some(vec![Some(6), Some(7)]),
-        ];
-        let list_array = ListArray::from_iter_primitive::<Int32Type, _, _>(data);
-
-        let another = create_from_buffers();
-        assert_eq!(list_array, another)
-    }
-
-    #[test]
-    fn test_empty_list_array() {
-        // Construct an empty value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(0)
-            .add_buffer(Buffer::from([]))
-            .build()
-            .unwrap();
-
-        // Construct an empty offset buffer
-        let value_offsets = Buffer::from([]);
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(0)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-
-        let list_array = ListArray::from(list_data);
-        assert_eq!(list_array.len(), 0)
-    }
-
-    #[test]
-    fn test_list_array() {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(8)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7]))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
-        let value_offsets = Buffer::from_slice_ref(&[0, 3, 6, 8]);
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = ArrayData::builder(list_data_type.clone())
-            .len(3)
-            .add_buffer(value_offsets.clone())
-            .add_child_data(value_data.clone())
-            .build()
-            .unwrap();
-        let list_array = ListArray::from(list_data);
-
-        let values = list_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(3, list_array.len());
-        assert_eq!(0, list_array.null_count());
-        assert_eq!(6, list_array.value_offsets()[2]);
-        assert_eq!(2, list_array.value_length(2));
-        assert_eq!(
-            0,
-            list_array
-                .value(0)
-                .as_any()
-                .downcast_ref::<Int32Array>()
-                .unwrap()
-                .value(0)
-        );
-        assert_eq!(
-            0,
-            unsafe { list_array.value_unchecked(0) }
-                .as_any()
-                .downcast_ref::<Int32Array>()
-                .unwrap()
-                .value(0)
-        );
-        for i in 0..3 {
-            assert!(list_array.is_valid(i));
-            assert!(!list_array.is_null(i));
-        }
-
-        // Now test with a non-zero offset (skip first element)
-        //  [[3, 4, 5], [6, 7]]
-        let list_data = ArrayData::builder(list_data_type)
-            .len(2)
-            .offset(1)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data.clone())
-            .build()
-            .unwrap();
-        let list_array = ListArray::from(list_data);
-
-        let values = list_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(2, list_array.len());
-        assert_eq!(0, list_array.null_count());
-        assert_eq!(6, list_array.value_offsets()[1]);
-        assert_eq!(2, list_array.value_length(1));
-        assert_eq!(
-            3,
-            list_array
-                .value(0)
-                .as_any()
-                .downcast_ref::<Int32Array>()
-                .unwrap()
-                .value(0)
-        );
-        assert_eq!(
-            3,
-            unsafe { list_array.value_unchecked(0) }
-                .as_any()
-                .downcast_ref::<Int32Array>()
-                .unwrap()
-                .value(0)
-        );
-    }
-
-    #[test]
-    fn test_large_list_array() {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(8)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7]))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
-        let value_offsets = Buffer::from_slice_ref(&[0i64, 3, 6, 8]);
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::LargeList(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = ArrayData::builder(list_data_type.clone())
-            .len(3)
-            .add_buffer(value_offsets.clone())
-            .add_child_data(value_data.clone())
-            .build()
-            .unwrap();
-        let list_array = LargeListArray::from(list_data);
-
-        let values = list_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(3, list_array.len());
-        assert_eq!(0, list_array.null_count());
-        assert_eq!(6, list_array.value_offsets()[2]);
-        assert_eq!(2, list_array.value_length(2));
-        assert_eq!(
-            0,
-            list_array
-                .value(0)
-                .as_any()
-                .downcast_ref::<Int32Array>()
-                .unwrap()
-                .value(0)
-        );
-        assert_eq!(
-            0,
-            unsafe { list_array.value_unchecked(0) }
-                .as_any()
-                .downcast_ref::<Int32Array>()
-                .unwrap()
-                .value(0)
-        );
-        for i in 0..3 {
-            assert!(list_array.is_valid(i));
-            assert!(!list_array.is_null(i));
-        }
-
-        // Now test with a non-zero offset
-        //  [[3, 4, 5], [6, 7]]
-        let list_data = ArrayData::builder(list_data_type)
-            .len(2)
-            .offset(1)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data.clone())
-            .build()
-            .unwrap();
-        let list_array = LargeListArray::from(list_data);
-
-        let values = list_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(2, list_array.len());
-        assert_eq!(0, list_array.null_count());
-        assert_eq!(6, list_array.value_offsets()[1]);
-        assert_eq!(2, list_array.value_length(1));
-        assert_eq!(
-            3,
-            list_array
-                .value(0)
-                .as_any()
-                .downcast_ref::<Int32Array>()
-                .unwrap()
-                .value(0)
-        );
-        assert_eq!(
-            3,
-            unsafe { list_array.value_unchecked(0) }
-                .as_any()
-                .downcast_ref::<Int32Array>()
-                .unwrap()
-                .value(0)
-        );
-    }
-
-    #[test]
-    fn test_list_array_slice() {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(10)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1], null, null, [2, 3], [4, 5], null, [6, 7, 8], null, [9]]
-        let value_offsets = Buffer::from_slice_ref(&[0, 2, 2, 2, 4, 6, 6, 9, 9, 10]);
-        // 01011001 00000001
-        let mut null_bits: [u8; 2] = [0; 2];
-        bit_util::set_bit(&mut null_bits, 0);
-        bit_util::set_bit(&mut null_bits, 3);
-        bit_util::set_bit(&mut null_bits, 4);
-        bit_util::set_bit(&mut null_bits, 6);
-        bit_util::set_bit(&mut null_bits, 8);
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(9)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data.clone())
-            .null_bit_buffer(Some(Buffer::from(null_bits)))
-            .build()
-            .unwrap();
-        let list_array = ListArray::from(list_data);
-
-        let values = list_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(9, list_array.len());
-        assert_eq!(4, list_array.null_count());
-        assert_eq!(2, list_array.value_offsets()[3]);
-        assert_eq!(2, list_array.value_length(3));
-
-        let sliced_array = list_array.slice(1, 6);
-        assert_eq!(6, sliced_array.len());
-        assert_eq!(1, sliced_array.offset());
-        assert_eq!(3, sliced_array.null_count());
-
-        for i in 0..sliced_array.len() {
-            if bit_util::get_bit(&null_bits, sliced_array.offset() + i) {
-                assert!(sliced_array.is_valid(i));
-            } else {
-                assert!(sliced_array.is_null(i));
-            }
-        }
-
-        // Check offset and length for each non-null value.
-        let sliced_list_array =
-            sliced_array.as_any().downcast_ref::<ListArray>().unwrap();
-        assert_eq!(2, sliced_list_array.value_offsets()[2]);
-        assert_eq!(2, sliced_list_array.value_length(2));
-        assert_eq!(4, sliced_list_array.value_offsets()[3]);
-        assert_eq!(2, sliced_list_array.value_length(3));
-        assert_eq!(6, sliced_list_array.value_offsets()[5]);
-        assert_eq!(3, sliced_list_array.value_length(5));
-    }
-
-    #[test]
-    fn test_large_list_array_slice() {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(10)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1], null, null, [2, 3], [4, 5], null, [6, 7, 8], null, [9]]
-        let value_offsets = Buffer::from_slice_ref(&[0i64, 2, 2, 2, 4, 6, 6, 9, 9, 10]);
-        // 01011001 00000001
-        let mut null_bits: [u8; 2] = [0; 2];
-        bit_util::set_bit(&mut null_bits, 0);
-        bit_util::set_bit(&mut null_bits, 3);
-        bit_util::set_bit(&mut null_bits, 4);
-        bit_util::set_bit(&mut null_bits, 6);
-        bit_util::set_bit(&mut null_bits, 8);
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::LargeList(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(9)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data.clone())
-            .null_bit_buffer(Some(Buffer::from(null_bits)))
-            .build()
-            .unwrap();
-        let list_array = LargeListArray::from(list_data);
-
-        let values = list_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(9, list_array.len());
-        assert_eq!(4, list_array.null_count());
-        assert_eq!(2, list_array.value_offsets()[3]);
-        assert_eq!(2, list_array.value_length(3));
-
-        let sliced_array = list_array.slice(1, 6);
-        assert_eq!(6, sliced_array.len());
-        assert_eq!(1, sliced_array.offset());
-        assert_eq!(3, sliced_array.null_count());
-
-        for i in 0..sliced_array.len() {
-            if bit_util::get_bit(&null_bits, sliced_array.offset() + i) {
-                assert!(sliced_array.is_valid(i));
-            } else {
-                assert!(sliced_array.is_null(i));
-            }
-        }
-
-        // Check offset and length for each non-null value.
-        let sliced_list_array = sliced_array
-            .as_any()
-            .downcast_ref::<LargeListArray>()
-            .unwrap();
-        assert_eq!(2, sliced_list_array.value_offsets()[2]);
-        assert_eq!(2, sliced_list_array.value_length(2));
-        assert_eq!(4, sliced_list_array.value_offsets()[3]);
-        assert_eq!(2, sliced_list_array.value_length(3));
-        assert_eq!(6, sliced_list_array.value_offsets()[5]);
-        assert_eq!(3, sliced_list_array.value_length(5));
-    }
-
-    #[test]
-    #[should_panic(expected = "index out of bounds: the len is 10 but the index is 11")]
-    fn test_list_array_index_out_of_bound() {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(10)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1], null, null, [2, 3], [4, 5], null, [6, 7, 8], null, [9]]
-        let value_offsets = Buffer::from_slice_ref(&[0i64, 2, 2, 2, 4, 6, 6, 9, 9, 10]);
-        // 01011001 00000001
-        let mut null_bits: [u8; 2] = [0; 2];
-        bit_util::set_bit(&mut null_bits, 0);
-        bit_util::set_bit(&mut null_bits, 3);
-        bit_util::set_bit(&mut null_bits, 4);
-        bit_util::set_bit(&mut null_bits, 6);
-        bit_util::set_bit(&mut null_bits, 8);
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::LargeList(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(9)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .null_bit_buffer(Some(Buffer::from(null_bits)))
-            .build()
-            .unwrap();
-        let list_array = LargeListArray::from(list_data);
-        assert_eq!(9, list_array.len());
-
-        list_array.value(10);
-    }
-    #[test]
-    #[should_panic(
-        expected = "ListArray data should contain a single buffer only (value offsets)"
-    )]
-    // Different error messages, so skip for now
-    // https://github.com/apache/arrow-rs/issues/1545
-    #[cfg(not(feature = "force_validate"))]
-    fn test_list_array_invalid_buffer_len() {
-        let value_data = unsafe {
-            ArrayData::builder(DataType::Int32)
-                .len(8)
-                .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7]))
-                .build_unchecked()
-        };
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = unsafe {
-            ArrayData::builder(list_data_type)
-                .len(3)
-                .add_child_data(value_data)
-                .build_unchecked()
-        };
-        drop(ListArray::from(list_data));
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "ListArray should contain a single child array (values array)"
-    )]
-    // Different error messages, so skip for now
-    // https://github.com/apache/arrow-rs/issues/1545
-    #[cfg(not(feature = "force_validate"))]
-    fn test_list_array_invalid_child_array_len() {
-        let value_offsets = Buffer::from_slice_ref(&[0, 2, 5, 7]);
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = unsafe {
-            ArrayData::builder(list_data_type)
-                .len(3)
-                .add_buffer(value_offsets)
-                .build_unchecked()
-        };
-        drop(ListArray::from(list_data));
-    }
-
-    #[test]
-    fn test_list_array_offsets_need_not_start_at_zero() {
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(8)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7]))
-            .build()
-            .unwrap();
-
-        let value_offsets = Buffer::from_slice_ref(&[2, 2, 5, 7]);
-
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(3)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-
-        let list_array = ListArray::from(list_data);
-        assert_eq!(list_array.value_length(0), 0);
-        assert_eq!(list_array.value_length(1), 3);
-        assert_eq!(list_array.value_length(2), 2);
-    }
-
-    #[test]
-    #[should_panic(expected = "memory is not aligned")]
-    fn test_primitive_array_alignment() {
-        let ptr = alloc::allocate_aligned::<u8>(8);
-        let buf = unsafe { Buffer::from_raw_parts(ptr, 8, 8) };
-        let buf2 = buf.slice(1);
-        let array_data = ArrayData::builder(DataType::Int32)
-            .add_buffer(buf2)
-            .build()
-            .unwrap();
-        drop(Int32Array::from(array_data));
-    }
-
-    #[test]
-    #[should_panic(expected = "memory is not aligned")]
-    // Different error messages, so skip for now
-    // https://github.com/apache/arrow-rs/issues/1545
-    #[cfg(not(feature = "force_validate"))]
-    fn test_list_array_alignment() {
-        let ptr = alloc::allocate_aligned::<u8>(8);
-        let buf = unsafe { Buffer::from_raw_parts(ptr, 8, 8) };
-        let buf2 = buf.slice(1);
-
-        let values: [i32; 8] = [0; 8];
-        let value_data = unsafe {
-            ArrayData::builder(DataType::Int32)
-                .add_buffer(Buffer::from_slice_ref(&values))
-                .build_unchecked()
-        };
-
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = unsafe {
-            ArrayData::builder(list_data_type)
-                .add_buffer(buf2)
-                .add_child_data(value_data)
-                .build_unchecked()
-        };
-        drop(ListArray::from(list_data));
-    }
-
-    #[test]
-    fn list_array_equality() {
-        // test scaffold
-        fn do_comparison(
-            lhs_data: Vec<Option<Vec<Option<i32>>>>,
-            rhs_data: Vec<Option<Vec<Option<i32>>>>,
-            should_equal: bool,
-        ) {
-            let lhs = ListArray::from_iter_primitive::<Int32Type, _, _>(lhs_data.clone());
-            let rhs = ListArray::from_iter_primitive::<Int32Type, _, _>(rhs_data.clone());
-            assert_eq!(lhs == rhs, should_equal);
-
-            let lhs = LargeListArray::from_iter_primitive::<Int32Type, _, _>(lhs_data);
-            let rhs = LargeListArray::from_iter_primitive::<Int32Type, _, _>(rhs_data);
-            assert_eq!(lhs == rhs, should_equal);
-        }
-
-        do_comparison(
-            vec![
-                Some(vec![Some(0), Some(1), Some(2)]),
-                None,
-                Some(vec![Some(3), None, Some(5)]),
-                Some(vec![Some(6), Some(7)]),
-            ],
-            vec![
-                Some(vec![Some(0), Some(1), Some(2)]),
-                None,
-                Some(vec![Some(3), None, Some(5)]),
-                Some(vec![Some(6), Some(7)]),
-            ],
-            true,
-        );
-
-        do_comparison(
-            vec![
-                None,
-                None,
-                Some(vec![Some(3), None, Some(5)]),
-                Some(vec![Some(6), Some(7)]),
-            ],
-            vec![
-                Some(vec![Some(0), Some(1), Some(2)]),
-                None,
-                Some(vec![Some(3), None, Some(5)]),
-                Some(vec![Some(6), Some(7)]),
-            ],
-            false,
-        );
-
-        do_comparison(
-            vec![
-                None,
-                None,
-                Some(vec![Some(3), None, Some(5)]),
-                Some(vec![Some(6), Some(7)]),
-            ],
-            vec![
-                None,
-                None,
-                Some(vec![Some(3), None, Some(5)]),
-                Some(vec![Some(0), Some(0)]),
-            ],
-            false,
-        );
-
-        do_comparison(
-            vec![None, None, Some(vec![Some(1)])],
-            vec![None, None, Some(vec![Some(2)])],
-            false,
-        );
-    }
-}
diff --git a/arrow/src/array/array_map.rs b/arrow/src/array/array_map.rs
deleted file mode 100644
index 471d56c9c604..000000000000
--- a/arrow/src/array/array_map.rs
+++ /dev/null
@@ -1,532 +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.
-
-use crate::array::{StringArray, StructArray};
-use crate::buffer::Buffer;
-use std::any::Any;
-use std::fmt;
-use std::mem;
-use std::sync::Arc;
-
-use super::make_array;
-use super::{
-    array::print_long_array, raw_pointer::RawPtrBox, Array, ArrayData, ArrayRef,
-};
-use crate::datatypes::{ArrowNativeType, DataType, Field, ToByteSlice};
-use crate::error::ArrowError;
-
-/// A nested array type where each record is a key-value map.
-/// Keys should always be non-null, but values can be null.
-///
-/// [MapArray] is physically a [crate::array::ListArray] that has a
-/// [crate::array::StructArray] with 2 child fields.
-pub struct MapArray {
-    data: ArrayData,
-    values: ArrayRef,
-    value_offsets: RawPtrBox<i32>,
-}
-
-impl MapArray {
-    /// Returns a reference to the keys of this map.
-    pub fn keys(&self) -> ArrayRef {
-        make_array(self.values.data().child_data()[0].clone())
-    }
-
-    /// Returns a reference to the values of this map.
-    pub fn values(&self) -> ArrayRef {
-        make_array(self.values.data().child_data()[1].clone())
-    }
-
-    /// Returns the data type of the map's keys.
-    pub fn key_type(&self) -> DataType {
-        self.values.data().child_data()[0].data_type().clone()
-    }
-
-    /// Returns the data type of the map's values.
-    pub fn value_type(&self) -> DataType {
-        self.values.data().child_data()[1].data_type().clone()
-    }
-
-    /// Returns ith value of this map array.
-    /// # Safety
-    /// Caller must ensure that the index is within the array bounds
-    pub unsafe fn value_unchecked(&self, i: usize) -> ArrayRef {
-        let end = *self.value_offsets().get_unchecked(i + 1);
-        let start = *self.value_offsets().get_unchecked(i);
-        self.values
-            .slice(start.to_usize().unwrap(), (end - start).to_usize().unwrap())
-    }
-
-    /// Returns ith value of this map array.
-    pub fn value(&self, i: usize) -> ArrayRef {
-        let end = self.value_offsets()[i + 1] as usize;
-        let start = self.value_offsets()[i] as usize;
-        self.values.slice(start, end - start)
-    }
-
-    /// Returns the offset values in the offsets buffer
-    #[inline]
-    pub fn value_offsets(&self) -> &[i32] {
-        // Soundness
-        //     pointer alignment & location is ensured by RawPtrBox
-        //     buffer bounds/offset is ensured by the ArrayData instance.
-        unsafe {
-            std::slice::from_raw_parts(
-                self.value_offsets.as_ptr().add(self.data.offset()),
-                self.len() + 1,
-            )
-        }
-    }
-
-    /// Returns the length for value at index `i`.
-    #[inline]
-    pub fn value_length(&self, i: usize) -> i32 {
-        let offsets = self.value_offsets();
-        offsets[i + 1] - offsets[i]
-    }
-}
-
-impl From<ArrayData> for MapArray {
-    fn from(data: ArrayData) -> Self {
-        Self::try_new_from_array_data(data)
-            .expect("Expected infallable creation of MapArray from ArrayData failed")
-    }
-}
-
-impl From<MapArray> for ArrayData {
-    fn from(array: MapArray) -> Self {
-        array.data
-    }
-}
-
-impl MapArray {
-    fn try_new_from_array_data(data: ArrayData) -> Result<Self, ArrowError> {
-        if data.buffers().len() != 1 {
-            return Err(ArrowError::InvalidArgumentError(
-                format!("MapArray data should contain a single buffer only (value offsets), had {}",
-                        data.len())));
-        }
-
-        if data.child_data().len() != 1 {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "MapArray should contain a single child array (values array), had {}",
-                data.child_data().len()
-            )));
-        }
-
-        let entries = data.child_data()[0].clone();
-
-        if let DataType::Struct(fields) = entries.data_type() {
-            if fields.len() != 2 {
-                return Err(ArrowError::InvalidArgumentError(format!(
-                "MapArray should contain a struct array with 2 fields, have {} fields",
-                fields.len()
-            )));
-            }
-        } else {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "MapArray should contain a struct array child, found {:?}",
-                entries.data_type()
-            )));
-        }
-
-        let values = make_array(entries);
-        let value_offsets = data.buffers()[0].as_ptr();
-
-        let value_offsets = unsafe { RawPtrBox::<i32>::new(value_offsets) };
-        unsafe {
-            if (*value_offsets.as_ptr().offset(0)) != 0 {
-                return Err(ArrowError::InvalidArgumentError(String::from(
-                    "offsets do not start at zero",
-                )));
-            }
-        }
-        Ok(Self {
-            data,
-            values,
-            value_offsets,
-        })
-    }
-
-    /// Creates map array from provided keys, values and entry_offsets.
-    pub fn new_from_strings<'a>(
-        keys: impl Iterator<Item = &'a str>,
-        values: &dyn Array,
-        entry_offsets: &[u32],
-    ) -> Result<Self, ArrowError> {
-        let entry_offsets_buffer = Buffer::from(entry_offsets.to_byte_slice());
-        let keys_data = StringArray::from_iter_values(keys);
-
-        let keys_field = Field::new("keys", DataType::Utf8, false);
-        let values_field = Field::new(
-            "values",
-            values.data_type().clone(),
-            values.null_count() > 0,
-        );
-
-        let entry_struct = StructArray::from(vec![
-            (keys_field, Arc::new(keys_data) as ArrayRef),
-            (values_field, make_array(values.data().clone())),
-        ]);
-
-        let map_data_type = DataType::Map(
-            Box::new(Field::new(
-                "entries",
-                entry_struct.data_type().clone(),
-                true,
-            )),
-            false,
-        );
-        let map_data = ArrayData::builder(map_data_type)
-            .len(entry_offsets.len() - 1)
-            .add_buffer(entry_offsets_buffer)
-            .add_child_data(entry_struct.into_data())
-            .build()?;
-
-        Ok(MapArray::from(map_data))
-    }
-}
-
-impl Array for MapArray {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.into()
-    }
-
-    /// Returns the total number of bytes of memory occupied by the buffers owned by this [MapArray].
-    fn get_buffer_memory_size(&self) -> usize {
-        self.data.get_buffer_memory_size()
-    }
-
-    /// Returns the total number of bytes of memory occupied physically by this [MapArray].
-    fn get_array_memory_size(&self) -> usize {
-        self.data.get_array_memory_size() + mem::size_of_val(self)
-    }
-}
-
-impl fmt::Debug for MapArray {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "MapArray\n[\n")?;
-        print_long_array(self, f, |array, index, f| {
-            fmt::Debug::fmt(&array.value(index), f)
-        })?;
-        write!(f, "]")
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use crate::{
-        array::ArrayData,
-        array::{Int32Array, StructArray, UInt32Array},
-        buffer::Buffer,
-        datatypes::Field,
-        datatypes::ToByteSlice,
-    };
-
-    use super::*;
-
-    fn create_from_buffers() -> MapArray {
-        // Construct key and values
-        let keys_data = ArrayData::builder(DataType::Int32)
-            .len(8)
-            .add_buffer(Buffer::from(&[0, 1, 2, 3, 4, 5, 6, 7].to_byte_slice()))
-            .build()
-            .unwrap();
-        let values_data = ArrayData::builder(DataType::UInt32)
-            .len(8)
-            .add_buffer(Buffer::from(
-                &[0u32, 10, 20, 30, 40, 50, 60, 70].to_byte_slice(),
-            ))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
-        let entry_offsets = Buffer::from(&[0, 3, 6, 8].to_byte_slice());
-
-        let keys = Field::new("keys", DataType::Int32, false);
-        let values = Field::new("values", DataType::UInt32, false);
-        let entry_struct = StructArray::from(vec![
-            (keys, make_array(keys_data)),
-            (values, make_array(values_data)),
-        ]);
-
-        // Construct a map array from the above two
-        let map_data_type = DataType::Map(
-            Box::new(Field::new(
-                "entries",
-                entry_struct.data_type().clone(),
-                true,
-            )),
-            false,
-        );
-        let map_data = ArrayData::builder(map_data_type)
-            .len(3)
-            .add_buffer(entry_offsets)
-            .add_child_data(entry_struct.into_data())
-            .build()
-            .unwrap();
-        MapArray::from(map_data)
-    }
-
-    #[test]
-    fn test_map_array() {
-        // Construct key and values
-        let key_data = ArrayData::builder(DataType::Int32)
-            .len(8)
-            .add_buffer(Buffer::from(&[0, 1, 2, 3, 4, 5, 6, 7].to_byte_slice()))
-            .build()
-            .unwrap();
-        let value_data = ArrayData::builder(DataType::UInt32)
-            .len(8)
-            .add_buffer(Buffer::from(
-                &[0u32, 10, 20, 0, 40, 0, 60, 70].to_byte_slice(),
-            ))
-            .null_bit_buffer(Some(Buffer::from(&[0b11010110])))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
-        let entry_offsets = Buffer::from(&[0, 3, 6, 8].to_byte_slice());
-
-        let keys_field = Field::new("keys", DataType::Int32, false);
-        let values_field = Field::new("values", DataType::UInt32, true);
-        let entry_struct = StructArray::from(vec![
-            (keys_field.clone(), make_array(key_data)),
-            (values_field.clone(), make_array(value_data.clone())),
-        ]);
-
-        // Construct a map array from the above two
-        let map_data_type = DataType::Map(
-            Box::new(Field::new(
-                "entries",
-                entry_struct.data_type().clone(),
-                true,
-            )),
-            false,
-        );
-        let map_data = ArrayData::builder(map_data_type)
-            .len(3)
-            .add_buffer(entry_offsets)
-            .add_child_data(entry_struct.into_data())
-            .build()
-            .unwrap();
-        let map_array = MapArray::from(map_data);
-
-        let values = map_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::UInt32, map_array.value_type());
-        assert_eq!(3, map_array.len());
-        assert_eq!(0, map_array.null_count());
-        assert_eq!(6, map_array.value_offsets()[2]);
-        assert_eq!(2, map_array.value_length(2));
-
-        let key_array = Arc::new(Int32Array::from(vec![0, 1, 2])) as ArrayRef;
-        let value_array =
-            Arc::new(UInt32Array::from(vec![None, Some(10u32), Some(20)])) as ArrayRef;
-        let struct_array = StructArray::from(vec![
-            (keys_field.clone(), key_array),
-            (values_field.clone(), value_array),
-        ]);
-        assert_eq!(
-            struct_array,
-            StructArray::from(map_array.value(0).into_data())
-        );
-        assert_eq!(
-            &struct_array,
-            unsafe { map_array.value_unchecked(0) }
-                .as_any()
-                .downcast_ref::<StructArray>()
-                .unwrap()
-        );
-        for i in 0..3 {
-            assert!(map_array.is_valid(i));
-            assert!(!map_array.is_null(i));
-        }
-
-        // Now test with a non-zero offset
-        let map_data = ArrayData::builder(map_array.data_type().clone())
-            .len(2)
-            .offset(1)
-            .add_buffer(map_array.data().buffers()[0].clone())
-            .add_child_data(map_array.data().child_data()[0].clone())
-            .build()
-            .unwrap();
-        let map_array = MapArray::from(map_data);
-
-        let values = map_array.values();
-        assert_eq!(&value_data, values.data());
-        assert_eq!(DataType::UInt32, map_array.value_type());
-        assert_eq!(2, map_array.len());
-        assert_eq!(0, map_array.null_count());
-        assert_eq!(6, map_array.value_offsets()[1]);
-        assert_eq!(2, map_array.value_length(1));
-
-        let key_array = Arc::new(Int32Array::from(vec![3, 4, 5])) as ArrayRef;
-        let value_array =
-            Arc::new(UInt32Array::from(vec![None, Some(40), None])) as ArrayRef;
-        let struct_array =
-            StructArray::from(vec![(keys_field, key_array), (values_field, value_array)]);
-        assert_eq!(
-            &struct_array,
-            map_array
-                .value(0)
-                .as_any()
-                .downcast_ref::<StructArray>()
-                .unwrap()
-        );
-        assert_eq!(
-            &struct_array,
-            unsafe { map_array.value_unchecked(0) }
-                .as_any()
-                .downcast_ref::<StructArray>()
-                .unwrap()
-        );
-    }
-
-    #[test]
-    #[ignore = "Test fails because slice of <list<struct>> is still buggy"]
-    fn test_map_array_slice() {
-        let map_array = create_from_buffers();
-
-        let sliced_array = map_array.slice(1, 2);
-        assert_eq!(2, sliced_array.len());
-        assert_eq!(1, sliced_array.offset());
-        let sliced_array_data = sliced_array.data();
-        for array_data in sliced_array_data.child_data() {
-            assert_eq!(array_data.offset(), 1);
-        }
-
-        // Check offset and length for each non-null value.
-        let sliced_map_array = sliced_array.as_any().downcast_ref::<MapArray>().unwrap();
-        assert_eq!(3, sliced_map_array.value_offsets()[0]);
-        assert_eq!(3, sliced_map_array.value_length(0));
-        assert_eq!(6, sliced_map_array.value_offsets()[1]);
-        assert_eq!(2, sliced_map_array.value_length(1));
-
-        // Construct key and values
-        let keys_data = ArrayData::builder(DataType::Int32)
-            .len(5)
-            .add_buffer(Buffer::from(&[3, 4, 5, 6, 7].to_byte_slice()))
-            .build()
-            .unwrap();
-        let values_data = ArrayData::builder(DataType::UInt32)
-            .len(5)
-            .add_buffer(Buffer::from(&[30u32, 40, 50, 60, 70].to_byte_slice()))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[3, 4, 5], [6, 7]]
-        let entry_offsets = Buffer::from(&[0, 3, 5].to_byte_slice());
-
-        let keys = Field::new("keys", DataType::Int32, false);
-        let values = Field::new("values", DataType::UInt32, false);
-        let entry_struct = StructArray::from(vec![
-            (keys, make_array(keys_data)),
-            (values, make_array(values_data)),
-        ]);
-
-        // Construct a map array from the above two
-        let map_data_type = DataType::Map(
-            Box::new(Field::new(
-                "entries",
-                entry_struct.data_type().clone(),
-                true,
-            )),
-            false,
-        );
-        let expected_map_data = ArrayData::builder(map_data_type)
-            .len(2)
-            .add_buffer(entry_offsets)
-            .add_child_data(entry_struct.into_data())
-            .build()
-            .unwrap();
-        let expected_map_array = MapArray::from(expected_map_data);
-
-        assert_eq!(&expected_map_array, sliced_map_array)
-    }
-
-    #[test]
-    #[should_panic(expected = "index out of bounds: the len is ")]
-    fn test_map_array_index_out_of_bound() {
-        let map_array = create_from_buffers();
-
-        map_array.value(map_array.len());
-    }
-
-    #[test]
-    fn test_new_from_strings() {
-        let keys = vec!["a", "b", "c", "d", "e", "f", "g", "h"];
-        let values_data = UInt32Array::from(vec![0u32, 10, 20, 30, 40, 50, 60, 70]);
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[a, b, c], [d, e, f], [g, h]]
-        let entry_offsets = [0, 3, 6, 8];
-
-        let map_array = MapArray::new_from_strings(
-            keys.clone().into_iter(),
-            &values_data,
-            &entry_offsets,
-        )
-        .unwrap();
-
-        let values = map_array.values();
-        assert_eq!(
-            &values_data,
-            values.as_any().downcast_ref::<UInt32Array>().unwrap()
-        );
-        assert_eq!(DataType::UInt32, map_array.value_type());
-        assert_eq!(3, map_array.len());
-        assert_eq!(0, map_array.null_count());
-        assert_eq!(6, map_array.value_offsets()[2]);
-        assert_eq!(2, map_array.value_length(2));
-
-        let key_array = Arc::new(StringArray::from(vec!["a", "b", "c"])) as ArrayRef;
-        let value_array = Arc::new(UInt32Array::from(vec![0u32, 10, 20])) as ArrayRef;
-        let keys_field = Field::new("keys", DataType::Utf8, false);
-        let values_field = Field::new("values", DataType::UInt32, false);
-        let struct_array =
-            StructArray::from(vec![(keys_field, key_array), (values_field, value_array)]);
-        assert_eq!(
-            struct_array,
-            StructArray::from(map_array.value(0).into_data())
-        );
-        assert_eq!(
-            &struct_array,
-            unsafe { map_array.value_unchecked(0) }
-                .as_any()
-                .downcast_ref::<StructArray>()
-                .unwrap()
-        );
-        for i in 0..3 {
-            assert!(map_array.is_valid(i));
-            assert!(!map_array.is_null(i));
-        }
-    }
-}
diff --git a/arrow/src/array/array_primitive.rs b/arrow/src/array/array_primitive.rs
deleted file mode 100644
index a10104d980e1..000000000000
--- a/arrow/src/array/array_primitive.rs
+++ /dev/null
@@ -1,1131 +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.
-
-use std::any::Any;
-use std::convert::From;
-use std::fmt;
-use std::iter::{FromIterator, IntoIterator};
-use std::mem;
-
-use chrono::{prelude::*, Duration};
-
-use super::array::print_long_array;
-use super::raw_pointer::RawPtrBox;
-use super::*;
-use crate::temporal_conversions;
-use crate::util::bit_util;
-use crate::{
-    buffer::{Buffer, MutableBuffer},
-    util::trusted_len_unzip,
-};
-
-use crate::array::array::ArrayAccessor;
-use half::f16;
-
-/// Array whose elements are of primitive types.
-///
-/// # Example: From an iterator of values
-///
-/// ```
-/// use arrow::array::{Array, PrimitiveArray};
-/// use arrow::datatypes::Int32Type;
-/// let arr: PrimitiveArray<Int32Type> = PrimitiveArray::from_iter_values((0..10).map(|x| x + 1));
-/// assert_eq!(10, arr.len());
-/// assert_eq!(0, arr.null_count());
-/// for i in 0..10i32 {
-///     assert_eq!(i + 1, arr.value(i as usize));
-/// }
-/// ```
-pub struct PrimitiveArray<T: ArrowPrimitiveType> {
-    /// Underlying ArrayData
-    /// # Safety
-    /// must have exactly one buffer, aligned to type T
-    data: ArrayData,
-    /// Pointer to the value array. The lifetime of this must be <= to the value buffer
-    /// stored in `data`, so it's safe to store.
-    /// # Safety
-    /// raw_values must have a value equivalent to `data.buffers()[0].raw_data()`
-    /// raw_values must have alignment for type T::NativeType
-    raw_values: RawPtrBox<T::Native>,
-}
-
-impl<T: ArrowPrimitiveType> PrimitiveArray<T> {
-    /// Returns the length of this array.
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.data.len()
-    }
-
-    /// Returns whether this array is empty.
-    pub fn is_empty(&self) -> bool {
-        self.data.is_empty()
-    }
-
-    /// Returns a slice of the values of this array
-    #[inline]
-    pub fn values(&self) -> &[T::Native] {
-        // Soundness
-        //     raw_values alignment & location is ensured by fn from(ArrayDataRef)
-        //     buffer bounds/offset is ensured by the ArrayData instance.
-        unsafe {
-            std::slice::from_raw_parts(
-                self.raw_values.as_ptr().add(self.data.offset()),
-                self.len(),
-            )
-        }
-    }
-
-    // Returns a new primitive array builder
-    pub fn builder(capacity: usize) -> PrimitiveBuilder<T> {
-        PrimitiveBuilder::<T>::new(capacity)
-    }
-
-    /// Returns the primitive value at index `i`.
-    ///
-    /// # Safety
-    ///
-    /// caller must ensure that the passed in offset is less than the array len()
-    #[inline]
-    pub unsafe fn value_unchecked(&self, i: usize) -> T::Native {
-        let offset = i + self.offset();
-        *self.raw_values.as_ptr().add(offset)
-    }
-
-    /// Returns the primitive value at index `i`.
-    ///
-    /// Panics of offset `i` is out of bounds
-    #[inline]
-    pub fn value(&self, i: usize) -> T::Native {
-        assert!(i < self.len());
-        unsafe { self.value_unchecked(i) }
-    }
-
-    /// Creates a PrimitiveArray based on an iterator of values without nulls
-    pub fn from_iter_values<I: IntoIterator<Item = T::Native>>(iter: I) -> Self {
-        let val_buf: Buffer = iter.into_iter().collect();
-        let data = unsafe {
-            ArrayData::new_unchecked(
-                T::DATA_TYPE,
-                val_buf.len() / mem::size_of::<<T as ArrowPrimitiveType>::Native>(),
-                None,
-                None,
-                0,
-                vec![val_buf],
-                vec![],
-            )
-        };
-        PrimitiveArray::from(data)
-    }
-
-    /// Creates a PrimitiveArray based on a constant value with `count` elements
-    pub fn from_value(value: T::Native, count: usize) -> Self {
-        // # Safety: iterator (0..count) correctly reports its length
-        let val_buf = unsafe { Buffer::from_trusted_len_iter((0..count).map(|_| value)) };
-        let data = unsafe {
-            ArrayData::new_unchecked(
-                T::DATA_TYPE,
-                val_buf.len() / mem::size_of::<<T as ArrowPrimitiveType>::Native>(),
-                None,
-                None,
-                0,
-                vec![val_buf],
-                vec![],
-            )
-        };
-        PrimitiveArray::from(data)
-    }
-
-    /// Returns an iterator that returns the values of `array.value(i)` for an iterator with each element `i`
-    pub fn take_iter<'a>(
-        &'a self,
-        indexes: impl Iterator<Item = Option<usize>> + 'a,
-    ) -> impl Iterator<Item = Option<T::Native>> + 'a {
-        indexes.map(|opt_index| opt_index.map(|index| self.value(index)))
-    }
-
-    /// Returns an iterator that returns the values of `array.value(i)` for an iterator with each element `i`
-    /// # Safety
-    ///
-    /// caller must ensure that the offsets in the iterator are less than the array len()
-    pub unsafe fn take_iter_unchecked<'a>(
-        &'a self,
-        indexes: impl Iterator<Item = Option<usize>> + 'a,
-    ) -> impl Iterator<Item = Option<T::Native>> + 'a {
-        indexes.map(|opt_index| opt_index.map(|index| self.value_unchecked(index)))
-    }
-}
-
-impl<T: ArrowPrimitiveType> From<PrimitiveArray<T>> for ArrayData {
-    fn from(array: PrimitiveArray<T>) -> Self {
-        array.data
-    }
-}
-
-impl<T: ArrowPrimitiveType> Array for PrimitiveArray<T> {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.into()
-    }
-}
-
-impl<'a, T: ArrowPrimitiveType> ArrayAccessor for &'a PrimitiveArray<T> {
-    type Item = T::Native;
-
-    fn value(&self, index: usize) -> Self::Item {
-        PrimitiveArray::value(self, index)
-    }
-
-    unsafe fn value_unchecked(&self, index: usize) -> Self::Item {
-        PrimitiveArray::value_unchecked(self, index)
-    }
-}
-
-fn as_datetime<T: ArrowPrimitiveType>(v: i64) -> Option<NaiveDateTime> {
-    match T::DATA_TYPE {
-        DataType::Date32 => Some(temporal_conversions::date32_to_datetime(v as i32)),
-        DataType::Date64 => Some(temporal_conversions::date64_to_datetime(v)),
-        DataType::Time32(_) | DataType::Time64(_) => None,
-        DataType::Timestamp(unit, _) => match unit {
-            TimeUnit::Second => Some(temporal_conversions::timestamp_s_to_datetime(v)),
-            TimeUnit::Millisecond => {
-                Some(temporal_conversions::timestamp_ms_to_datetime(v))
-            }
-            TimeUnit::Microsecond => {
-                Some(temporal_conversions::timestamp_us_to_datetime(v))
-            }
-            TimeUnit::Nanosecond => {
-                Some(temporal_conversions::timestamp_ns_to_datetime(v))
-            }
-        },
-        // interval is not yet fully documented [ARROW-3097]
-        DataType::Interval(_) => None,
-        _ => None,
-    }
-}
-
-fn as_date<T: ArrowPrimitiveType>(v: i64) -> Option<NaiveDate> {
-    as_datetime::<T>(v).map(|datetime| datetime.date())
-}
-
-fn as_time<T: ArrowPrimitiveType>(v: i64) -> Option<NaiveTime> {
-    match T::DATA_TYPE {
-        DataType::Time32(unit) => {
-            // safe to immediately cast to u32 as `self.value(i)` is positive i32
-            let v = v as u32;
-            match unit {
-                TimeUnit::Second => Some(temporal_conversions::time32s_to_time(v as i32)),
-                TimeUnit::Millisecond => {
-                    Some(temporal_conversions::time32ms_to_time(v as i32))
-                }
-                _ => None,
-            }
-        }
-        DataType::Time64(unit) => match unit {
-            TimeUnit::Microsecond => Some(temporal_conversions::time64us_to_time(v)),
-            TimeUnit::Nanosecond => Some(temporal_conversions::time64ns_to_time(v)),
-            _ => None,
-        },
-        DataType::Timestamp(_, _) => as_datetime::<T>(v).map(|datetime| datetime.time()),
-        DataType::Date32 | DataType::Date64 => Some(NaiveTime::from_hms(0, 0, 0)),
-        DataType::Interval(_) => None,
-        _ => None,
-    }
-}
-
-fn as_duration<T: ArrowPrimitiveType>(v: i64) -> Option<Duration> {
-    match T::DATA_TYPE {
-        DataType::Duration(unit) => match unit {
-            TimeUnit::Second => Some(temporal_conversions::duration_s_to_duration(v)),
-            TimeUnit::Millisecond => {
-                Some(temporal_conversions::duration_ms_to_duration(v))
-            }
-            TimeUnit::Microsecond => {
-                Some(temporal_conversions::duration_us_to_duration(v))
-            }
-            TimeUnit::Nanosecond => {
-                Some(temporal_conversions::duration_ns_to_duration(v))
-            }
-        },
-        _ => None,
-    }
-}
-
-impl<T: ArrowTemporalType + ArrowNumericType> PrimitiveArray<T>
-where
-    i64: std::convert::From<T::Native>,
-{
-    /// Returns value as a chrono `NaiveDateTime`, handling time resolution
-    ///
-    /// If a data type cannot be converted to `NaiveDateTime`, a `None` is returned.
-    /// A valid value is expected, thus the user should first check for validity.
-    pub fn value_as_datetime(&self, i: usize) -> Option<NaiveDateTime> {
-        as_datetime::<T>(i64::from(self.value(i)))
-    }
-
-    /// Returns value as a chrono `NaiveDateTime`, handling time resolution with the provided tz
-    ///
-    /// functionally it is same as `value_as_datetime`, however it adds
-    /// the passed tz to the to-be-returned NaiveDateTime
-    pub fn value_as_datetime_with_tz(
-        &self,
-        i: usize,
-        tz: FixedOffset,
-    ) -> Option<NaiveDateTime> {
-        as_datetime::<T>(i64::from(self.value(i))).map(|datetime| datetime + tz)
-    }
-
-    /// Returns value as a chrono `NaiveDate` by using `Self::datetime()`
-    ///
-    /// If a data type cannot be converted to `NaiveDate`, a `None` is returned
-    pub fn value_as_date(&self, i: usize) -> Option<NaiveDate> {
-        self.value_as_datetime(i).map(|datetime| datetime.date())
-    }
-
-    /// Returns a value as a chrono `NaiveTime`
-    ///
-    /// `Date32` and `Date64` return UTC midnight as they do not have time resolution
-    pub fn value_as_time(&self, i: usize) -> Option<NaiveTime> {
-        as_time::<T>(i64::from(self.value(i)))
-    }
-
-    /// Returns a value as a chrono `Duration`
-    ///
-    /// If a data type cannot be converted to `Duration`, a `None` is returned
-    pub fn value_as_duration(&self, i: usize) -> Option<Duration> {
-        as_duration::<T>(i64::from(self.value(i)))
-    }
-}
-
-impl<T: ArrowPrimitiveType> fmt::Debug for PrimitiveArray<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "PrimitiveArray<{:?}>\n[\n", T::DATA_TYPE)?;
-        print_long_array(self, f, |array, index, f| match T::DATA_TYPE {
-            DataType::Date32 | DataType::Date64 => {
-                let v = self.value(index).to_isize().unwrap() as i64;
-                match as_date::<T>(v) {
-                    Some(date) => write!(f, "{:?}", date),
-                    None => write!(f, "null"),
-                }
-            }
-            DataType::Time32(_) | DataType::Time64(_) => {
-                let v = self.value(index).to_isize().unwrap() as i64;
-                match as_time::<T>(v) {
-                    Some(time) => write!(f, "{:?}", time),
-                    None => write!(f, "null"),
-                }
-            }
-            DataType::Timestamp(_, _) => {
-                let v = self.value(index).to_isize().unwrap() as i64;
-                match as_datetime::<T>(v) {
-                    Some(datetime) => write!(f, "{:?}", datetime),
-                    None => write!(f, "null"),
-                }
-            }
-            _ => fmt::Debug::fmt(&array.value(index), f),
-        })?;
-        write!(f, "]")
-    }
-}
-
-impl<'a, T: ArrowPrimitiveType> IntoIterator for &'a PrimitiveArray<T> {
-    type Item = Option<<T as ArrowPrimitiveType>::Native>;
-    type IntoIter = PrimitiveIter<'a, T>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        PrimitiveIter::<'a, T>::new(self)
-    }
-}
-
-impl<'a, T: ArrowPrimitiveType> PrimitiveArray<T> {
-    /// constructs a new iterator
-    pub fn iter(&'a self) -> PrimitiveIter<'a, T> {
-        PrimitiveIter::<'a, T>::new(self)
-    }
-}
-
-/// This struct is used as an adapter when creating `PrimitiveArray` from an iterator.
-/// `FromIterator` for `PrimitiveArray` takes an iterator where the elements can be `into`
-/// this struct. So once implementing `From` or `Into` trait for a type, an iterator of
-/// the type can be collected to `PrimitiveArray`.
-#[derive(Debug)]
-pub struct NativeAdapter<T: ArrowPrimitiveType> {
-    pub native: Option<T::Native>,
-}
-
-macro_rules! def_from_for_primitive {
-    ( $ty:ident, $tt:tt) => {
-        impl From<$tt> for NativeAdapter<$ty> {
-            fn from(value: $tt) -> Self {
-                NativeAdapter {
-                    native: Some(value),
-                }
-            }
-        }
-    };
-}
-
-def_from_for_primitive!(Int8Type, i8);
-def_from_for_primitive!(Int16Type, i16);
-def_from_for_primitive!(Int32Type, i32);
-def_from_for_primitive!(Int64Type, i64);
-def_from_for_primitive!(UInt8Type, u8);
-def_from_for_primitive!(UInt16Type, u16);
-def_from_for_primitive!(UInt32Type, u32);
-def_from_for_primitive!(UInt64Type, u64);
-def_from_for_primitive!(Float16Type, f16);
-def_from_for_primitive!(Float32Type, f32);
-def_from_for_primitive!(Float64Type, f64);
-
-impl<T: ArrowPrimitiveType> From<Option<<T as ArrowPrimitiveType>::Native>>
-    for NativeAdapter<T>
-{
-    fn from(value: Option<<T as ArrowPrimitiveType>::Native>) -> Self {
-        NativeAdapter { native: value }
-    }
-}
-
-impl<T: ArrowPrimitiveType> From<&Option<<T as ArrowPrimitiveType>::Native>>
-    for NativeAdapter<T>
-{
-    fn from(value: &Option<<T as ArrowPrimitiveType>::Native>) -> Self {
-        NativeAdapter { native: *value }
-    }
-}
-
-impl<T: ArrowPrimitiveType, Ptr: Into<NativeAdapter<T>>> FromIterator<Ptr>
-    for PrimitiveArray<T>
-{
-    fn from_iter<I: IntoIterator<Item = Ptr>>(iter: I) -> Self {
-        let iter = iter.into_iter();
-        let (lower, _) = iter.size_hint();
-
-        let mut null_builder = BooleanBufferBuilder::new(lower);
-
-        let buffer: Buffer = iter
-            .map(|item| {
-                if let Some(a) = item.into().native {
-                    null_builder.append(true);
-                    a
-                } else {
-                    null_builder.append(false);
-                    // this ensures that null items on the buffer are not arbitrary.
-                    // This is important because fallible operations can use null values (e.g. a vectorized "add")
-                    // which may panic (e.g. overflow if the number on the slots happen to be very large).
-                    T::Native::default()
-                }
-            })
-            .collect();
-
-        let len = null_builder.len();
-
-        let data = unsafe {
-            ArrayData::new_unchecked(
-                T::DATA_TYPE,
-                len,
-                None,
-                Some(null_builder.into()),
-                0,
-                vec![buffer],
-                vec![],
-            )
-        };
-        PrimitiveArray::from(data)
-    }
-}
-
-impl<T: ArrowPrimitiveType> PrimitiveArray<T> {
-    /// Creates a [`PrimitiveArray`] from an iterator of trusted length.
-    /// # Safety
-    /// The iterator must be [`TrustedLen`](https://doc.rust-lang.org/std/iter/trait.TrustedLen.html).
-    /// I.e. that `size_hint().1` correctly reports its length.
-    #[inline]
-    pub unsafe fn from_trusted_len_iter<I, P>(iter: I) -> Self
-    where
-        P: std::borrow::Borrow<Option<<T as ArrowPrimitiveType>::Native>>,
-        I: IntoIterator<Item = P>,
-    {
-        let iterator = iter.into_iter();
-        let (_, upper) = iterator.size_hint();
-        let len = upper.expect("trusted_len_unzip requires an upper limit");
-
-        let (null, buffer) = trusted_len_unzip(iterator);
-
-        let data = ArrayData::new_unchecked(
-            T::DATA_TYPE,
-            len,
-            None,
-            Some(null),
-            0,
-            vec![buffer],
-            vec![],
-        );
-        PrimitiveArray::from(data)
-    }
-}
-
-// TODO: the macro is needed here because we'd get "conflicting implementations" error
-// otherwise with both `From<Vec<T::Native>>` and `From<Vec<Option<T::Native>>>`.
-// We should revisit this in future.
-macro_rules! def_numeric_from_vec {
-    ( $ty:ident ) => {
-        impl From<Vec<<$ty as ArrowPrimitiveType>::Native>> for PrimitiveArray<$ty> {
-            fn from(data: Vec<<$ty as ArrowPrimitiveType>::Native>) -> Self {
-                let array_data = ArrayData::builder($ty::DATA_TYPE)
-                    .len(data.len())
-                    .add_buffer(Buffer::from_slice_ref(&data));
-                let array_data = unsafe { array_data.build_unchecked() };
-                PrimitiveArray::from(array_data)
-            }
-        }
-
-        // Constructs a primitive array from a vector. Should only be used for testing.
-        impl From<Vec<Option<<$ty as ArrowPrimitiveType>::Native>>>
-            for PrimitiveArray<$ty>
-        {
-            fn from(data: Vec<Option<<$ty as ArrowPrimitiveType>::Native>>) -> Self {
-                PrimitiveArray::from_iter(data.iter())
-            }
-        }
-    };
-}
-
-def_numeric_from_vec!(Int8Type);
-def_numeric_from_vec!(Int16Type);
-def_numeric_from_vec!(Int32Type);
-def_numeric_from_vec!(Int64Type);
-def_numeric_from_vec!(UInt8Type);
-def_numeric_from_vec!(UInt16Type);
-def_numeric_from_vec!(UInt32Type);
-def_numeric_from_vec!(UInt64Type);
-def_numeric_from_vec!(Float32Type);
-def_numeric_from_vec!(Float64Type);
-
-def_numeric_from_vec!(Date32Type);
-def_numeric_from_vec!(Date64Type);
-def_numeric_from_vec!(Time32SecondType);
-def_numeric_from_vec!(Time32MillisecondType);
-def_numeric_from_vec!(Time64MicrosecondType);
-def_numeric_from_vec!(Time64NanosecondType);
-def_numeric_from_vec!(IntervalYearMonthType);
-def_numeric_from_vec!(IntervalDayTimeType);
-def_numeric_from_vec!(IntervalMonthDayNanoType);
-def_numeric_from_vec!(DurationSecondType);
-def_numeric_from_vec!(DurationMillisecondType);
-def_numeric_from_vec!(DurationMicrosecondType);
-def_numeric_from_vec!(DurationNanosecondType);
-def_numeric_from_vec!(TimestampSecondType);
-def_numeric_from_vec!(TimestampMillisecondType);
-def_numeric_from_vec!(TimestampMicrosecondType);
-def_numeric_from_vec!(TimestampNanosecondType);
-
-impl<T: ArrowTimestampType> PrimitiveArray<T> {
-    /// Construct a timestamp array from a vec of i64 values and an optional timezone
-    pub fn from_vec(data: Vec<i64>, timezone: Option<String>) -> Self {
-        let array_data =
-            ArrayData::builder(DataType::Timestamp(T::get_time_unit(), timezone))
-                .len(data.len())
-                .add_buffer(Buffer::from_slice_ref(&data));
-        let array_data = unsafe { array_data.build_unchecked() };
-        PrimitiveArray::from(array_data)
-    }
-
-    /// Construct a timestamp array with new timezone
-    pub fn with_timezone(&self, timezone: String) -> Self {
-        let array_data = unsafe {
-            self.data
-                .clone()
-                .into_builder()
-                .data_type(DataType::Timestamp(T::get_time_unit(), Some(timezone)))
-                .build_unchecked()
-        };
-        PrimitiveArray::from(array_data)
-    }
-}
-
-impl<T: ArrowTimestampType> PrimitiveArray<T> {
-    /// Construct a timestamp array from a vec of Option<i64> values and an optional timezone
-    pub fn from_opt_vec(data: Vec<Option<i64>>, timezone: Option<String>) -> Self {
-        // TODO: duplicated from def_numeric_from_vec! macro, it looks possible to convert to generic
-        let data_len = data.len();
-        let mut null_buf = MutableBuffer::new_null(data_len);
-        let mut val_buf = MutableBuffer::new(data_len * mem::size_of::<i64>());
-
-        {
-            let null_slice = null_buf.as_slice_mut();
-            for (i, v) in data.iter().enumerate() {
-                if let Some(n) = v {
-                    bit_util::set_bit(null_slice, i);
-                    val_buf.push(*n);
-                } else {
-                    val_buf.push(0i64);
-                }
-            }
-        }
-
-        let array_data =
-            ArrayData::builder(DataType::Timestamp(T::get_time_unit(), timezone))
-                .len(data_len)
-                .add_buffer(val_buf.into())
-                .null_bit_buffer(Some(null_buf.into()));
-        let array_data = unsafe { array_data.build_unchecked() };
-        PrimitiveArray::from(array_data)
-    }
-}
-
-/// Constructs a `PrimitiveArray` from an array data reference.
-impl<T: ArrowPrimitiveType> From<ArrayData> for PrimitiveArray<T> {
-    fn from(data: ArrayData) -> Self {
-        assert_eq!(
-            data.buffers().len(),
-            1,
-            "PrimitiveArray data should contain a single buffer only (values buffer)"
-        );
-
-        let ptr = data.buffers()[0].as_ptr();
-        Self {
-            data,
-            raw_values: unsafe { RawPtrBox::new(ptr) },
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use std::thread;
-
-    use crate::buffer::Buffer;
-    use crate::compute::eq_dyn;
-    use crate::datatypes::DataType;
-
-    #[test]
-    fn test_primitive_array_from_vec() {
-        let buf = Buffer::from_slice_ref(&[0, 1, 2, 3, 4]);
-        let arr = Int32Array::from(vec![0, 1, 2, 3, 4]);
-        assert_eq!(buf, arr.data.buffers()[0]);
-        assert_eq!(5, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(0, arr.null_count());
-        for i in 0..5 {
-            assert!(!arr.is_null(i));
-            assert!(arr.is_valid(i));
-            assert_eq!(i as i32, arr.value(i));
-        }
-    }
-
-    #[test]
-    fn test_primitive_array_from_vec_option() {
-        // Test building a primitive array with null values
-        let arr = Int32Array::from(vec![Some(0), None, Some(2), None, Some(4)]);
-        assert_eq!(5, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(2, arr.null_count());
-        for i in 0..5 {
-            if i % 2 == 0 {
-                assert!(!arr.is_null(i));
-                assert!(arr.is_valid(i));
-                assert_eq!(i as i32, arr.value(i));
-            } else {
-                assert!(arr.is_null(i));
-                assert!(!arr.is_valid(i));
-            }
-        }
-    }
-
-    #[test]
-    fn test_date64_array_from_vec_option() {
-        // Test building a primitive array with null values
-        // we use Int32 and Int64 as a backing array, so all Int32 and Int64 conventions
-        // work
-        let arr: PrimitiveArray<Date64Type> =
-            vec![Some(1550902545147), None, Some(1550902545147)].into();
-        assert_eq!(3, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(1, arr.null_count());
-        for i in 0..3 {
-            if i % 2 == 0 {
-                assert!(!arr.is_null(i));
-                assert!(arr.is_valid(i));
-                assert_eq!(1550902545147, arr.value(i));
-                // roundtrip to and from datetime
-                assert_eq!(
-                    1550902545147,
-                    arr.value_as_datetime(i).unwrap().timestamp_millis()
-                );
-            } else {
-                assert!(arr.is_null(i));
-                assert!(!arr.is_valid(i));
-            }
-        }
-    }
-
-    #[test]
-    fn test_time32_millisecond_array_from_vec() {
-        // 1:        00:00:00.001
-        // 37800005: 10:30:00.005
-        // 86399210: 23:59:59.210
-        let arr: PrimitiveArray<Time32MillisecondType> =
-            vec![1, 37_800_005, 86_399_210].into();
-        assert_eq!(3, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(0, arr.null_count());
-        let formatted = vec!["00:00:00.001", "10:30:00.005", "23:59:59.210"];
-        for (i, formatted) in formatted.iter().enumerate().take(3) {
-            // check that we can't create dates or datetimes from time instances
-            assert_eq!(None, arr.value_as_datetime(i));
-            assert_eq!(None, arr.value_as_date(i));
-            let time = arr.value_as_time(i).unwrap();
-            assert_eq!(*formatted, time.format("%H:%M:%S%.3f").to_string());
-        }
-    }
-
-    #[test]
-    fn test_time64_nanosecond_array_from_vec() {
-        // Test building a primitive array with null values
-        // we use Int32 and Int64 as a backing array, so all Int32 and Int64 conventions
-        // work
-
-        // 1e6:        00:00:00.001
-        // 37800005e6: 10:30:00.005
-        // 86399210e6: 23:59:59.210
-        let arr: PrimitiveArray<Time64NanosecondType> =
-            vec![1_000_000, 37_800_005_000_000, 86_399_210_000_000].into();
-        assert_eq!(3, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(0, arr.null_count());
-        let formatted = vec!["00:00:00.001", "10:30:00.005", "23:59:59.210"];
-        for (i, item) in formatted.iter().enumerate().take(3) {
-            // check that we can't create dates or datetimes from time instances
-            assert_eq!(None, arr.value_as_datetime(i));
-            assert_eq!(None, arr.value_as_date(i));
-            let time = arr.value_as_time(i).unwrap();
-            assert_eq!(*item, time.format("%H:%M:%S%.3f").to_string());
-        }
-    }
-
-    #[test]
-    fn test_interval_array_from_vec() {
-        // intervals are currently not treated specially, but are Int32 and Int64 arrays
-        let arr = IntervalYearMonthArray::from(vec![Some(1), None, Some(-5)]);
-        assert_eq!(3, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(1, arr.null_count());
-        assert_eq!(1, arr.value(0));
-        assert_eq!(1, arr.values()[0]);
-        assert!(arr.is_null(1));
-        assert_eq!(-5, arr.value(2));
-        assert_eq!(-5, arr.values()[2]);
-
-        // a day_time interval contains days and milliseconds, but we do not yet have accessors for the values
-        let arr = IntervalDayTimeArray::from(vec![Some(1), None, Some(-5)]);
-        assert_eq!(3, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(1, arr.null_count());
-        assert_eq!(1, arr.value(0));
-        assert_eq!(1, arr.values()[0]);
-        assert!(arr.is_null(1));
-        assert_eq!(-5, arr.value(2));
-        assert_eq!(-5, arr.values()[2]);
-
-        // a month_day_nano interval contains months, days and nanoseconds,
-        // but we do not yet have accessors for the values.
-        // TODO: implement month, day, and nanos access method for month_day_nano.
-        let arr = IntervalMonthDayNanoArray::from(vec![
-            Some(100000000000000000000),
-            None,
-            Some(-500000000000000000000),
-        ]);
-        assert_eq!(3, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(1, arr.null_count());
-        assert_eq!(100000000000000000000, arr.value(0));
-        assert_eq!(100000000000000000000, arr.values()[0]);
-        assert!(arr.is_null(1));
-        assert_eq!(-500000000000000000000, arr.value(2));
-        assert_eq!(-500000000000000000000, arr.values()[2]);
-    }
-
-    #[test]
-    fn test_duration_array_from_vec() {
-        let arr = DurationSecondArray::from(vec![Some(1), None, Some(-5)]);
-        assert_eq!(3, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(1, arr.null_count());
-        assert_eq!(1, arr.value(0));
-        assert_eq!(1, arr.values()[0]);
-        assert!(arr.is_null(1));
-        assert_eq!(-5, arr.value(2));
-        assert_eq!(-5, arr.values()[2]);
-
-        let arr = DurationMillisecondArray::from(vec![Some(1), None, Some(-5)]);
-        assert_eq!(3, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(1, arr.null_count());
-        assert_eq!(1, arr.value(0));
-        assert_eq!(1, arr.values()[0]);
-        assert!(arr.is_null(1));
-        assert_eq!(-5, arr.value(2));
-        assert_eq!(-5, arr.values()[2]);
-
-        let arr = DurationMicrosecondArray::from(vec![Some(1), None, Some(-5)]);
-        assert_eq!(3, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(1, arr.null_count());
-        assert_eq!(1, arr.value(0));
-        assert_eq!(1, arr.values()[0]);
-        assert!(arr.is_null(1));
-        assert_eq!(-5, arr.value(2));
-        assert_eq!(-5, arr.values()[2]);
-
-        let arr = DurationNanosecondArray::from(vec![Some(1), None, Some(-5)]);
-        assert_eq!(3, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(1, arr.null_count());
-        assert_eq!(1, arr.value(0));
-        assert_eq!(1, arr.values()[0]);
-        assert!(arr.is_null(1));
-        assert_eq!(-5, arr.value(2));
-        assert_eq!(-5, arr.values()[2]);
-    }
-
-    #[test]
-    fn test_timestamp_array_from_vec() {
-        let arr = TimestampSecondArray::from_vec(vec![1, -5], None);
-        assert_eq!(2, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(0, arr.null_count());
-        assert_eq!(1, arr.value(0));
-        assert_eq!(-5, arr.value(1));
-        assert_eq!(&[1, -5], arr.values());
-
-        let arr = TimestampMillisecondArray::from_vec(vec![1, -5], None);
-        assert_eq!(2, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(0, arr.null_count());
-        assert_eq!(1, arr.value(0));
-        assert_eq!(-5, arr.value(1));
-        assert_eq!(&[1, -5], arr.values());
-
-        let arr = TimestampMicrosecondArray::from_vec(vec![1, -5], None);
-        assert_eq!(2, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(0, arr.null_count());
-        assert_eq!(1, arr.value(0));
-        assert_eq!(-5, arr.value(1));
-        assert_eq!(&[1, -5], arr.values());
-
-        let arr = TimestampNanosecondArray::from_vec(vec![1, -5], None);
-        assert_eq!(2, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(0, arr.null_count());
-        assert_eq!(1, arr.value(0));
-        assert_eq!(-5, arr.value(1));
-        assert_eq!(&[1, -5], arr.values());
-    }
-
-    #[test]
-    fn test_primitive_array_slice() {
-        let arr = Int32Array::from(vec![
-            Some(0),
-            None,
-            Some(2),
-            None,
-            Some(4),
-            Some(5),
-            Some(6),
-            None,
-            None,
-        ]);
-        assert_eq!(9, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(4, arr.null_count());
-
-        let arr2 = arr.slice(2, 5);
-        assert_eq!(5, arr2.len());
-        assert_eq!(2, arr2.offset());
-        assert_eq!(1, arr2.null_count());
-
-        for i in 0..arr2.len() {
-            assert_eq!(i == 1, arr2.is_null(i));
-            assert_eq!(i != 1, arr2.is_valid(i));
-        }
-        let int_arr2 = arr2.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(2, int_arr2.values()[0]);
-        assert_eq!(&[4, 5, 6], &int_arr2.values()[2..5]);
-
-        let arr3 = arr2.slice(2, 3);
-        assert_eq!(3, arr3.len());
-        assert_eq!(4, arr3.offset());
-        assert_eq!(0, arr3.null_count());
-
-        let int_arr3 = arr3.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(&[4, 5, 6], int_arr3.values());
-        assert_eq!(4, int_arr3.value(0));
-        assert_eq!(5, int_arr3.value(1));
-        assert_eq!(6, int_arr3.value(2));
-    }
-
-    #[test]
-    fn test_boolean_array_slice() {
-        let arr = BooleanArray::from(vec![
-            Some(true),
-            None,
-            Some(false),
-            None,
-            Some(true),
-            Some(false),
-            Some(true),
-            Some(false),
-            None,
-            Some(true),
-        ]);
-
-        assert_eq!(10, arr.len());
-        assert_eq!(0, arr.offset());
-        assert_eq!(3, arr.null_count());
-
-        let arr2 = arr.slice(3, 5);
-        assert_eq!(5, arr2.len());
-        assert_eq!(3, arr2.offset());
-        assert_eq!(1, arr2.null_count());
-
-        let bool_arr = arr2.as_any().downcast_ref::<BooleanArray>().unwrap();
-
-        assert!(!bool_arr.is_valid(0));
-
-        assert!(bool_arr.is_valid(1));
-        assert!(bool_arr.value(1));
-
-        assert!(bool_arr.is_valid(2));
-        assert!(!bool_arr.value(2));
-
-        assert!(bool_arr.is_valid(3));
-        assert!(bool_arr.value(3));
-
-        assert!(bool_arr.is_valid(4));
-        assert!(!bool_arr.value(4));
-    }
-
-    #[test]
-    fn test_int32_fmt_debug() {
-        let arr = Int32Array::from(vec![0, 1, 2, 3, 4]);
-        assert_eq!(
-            "PrimitiveArray<Int32>\n[\n  0,\n  1,\n  2,\n  3,\n  4,\n]",
-            format!("{:?}", arr)
-        );
-    }
-
-    #[test]
-    fn test_fmt_debug_up_to_20_elements() {
-        (1..=20).for_each(|i| {
-            let values = (0..i).collect::<Vec<i16>>();
-            let array_expected = format!(
-                "PrimitiveArray<Int16>\n[\n{}\n]",
-                values
-                    .iter()
-                    .map(|v| { format!("  {},", v) })
-                    .collect::<Vec<String>>()
-                    .join("\n")
-            );
-            let array = Int16Array::from(values);
-
-            assert_eq!(array_expected, format!("{:?}", array));
-        })
-    }
-
-    #[test]
-    fn test_int32_with_null_fmt_debug() {
-        let mut builder = Int32Array::builder(3);
-        builder.append_slice(&[0, 1]);
-        builder.append_null();
-        builder.append_slice(&[3, 4]);
-        let arr = builder.finish();
-        assert_eq!(
-            "PrimitiveArray<Int32>\n[\n  0,\n  1,\n  null,\n  3,\n  4,\n]",
-            format!("{:?}", arr)
-        );
-    }
-
-    #[test]
-    fn test_timestamp_fmt_debug() {
-        let arr: PrimitiveArray<TimestampMillisecondType> =
-            TimestampMillisecondArray::from_vec(
-                vec![1546214400000, 1546214400000, -1546214400000],
-                None,
-            );
-        assert_eq!(
-            "PrimitiveArray<Timestamp(Millisecond, None)>\n[\n  2018-12-31T00:00:00,\n  2018-12-31T00:00:00,\n  1921-01-02T00:00:00,\n]",
-            format!("{:?}", arr)
-        );
-    }
-
-    #[test]
-    fn test_date32_fmt_debug() {
-        let arr: PrimitiveArray<Date32Type> = vec![12356, 13548, -365].into();
-        assert_eq!(
-            "PrimitiveArray<Date32>\n[\n  2003-10-31,\n  2007-02-04,\n  1969-01-01,\n]",
-            format!("{:?}", arr)
-        );
-    }
-
-    #[test]
-    fn test_time32second_fmt_debug() {
-        let arr: PrimitiveArray<Time32SecondType> = vec![7201, 60054].into();
-        assert_eq!(
-            "PrimitiveArray<Time32(Second)>\n[\n  02:00:01,\n  16:40:54,\n]",
-            format!("{:?}", arr)
-        );
-    }
-
-    #[test]
-    #[should_panic(expected = "invalid time")]
-    fn test_time32second_invalid_neg() {
-        // The panic should come from chrono, not from arrow
-        let arr: PrimitiveArray<Time32SecondType> = vec![-7201, -60054].into();
-        println!("{:?}", arr);
-    }
-
-    #[test]
-    fn test_primitive_array_builder() {
-        // Test building a primitive array with ArrayData builder and offset
-        let buf = Buffer::from_slice_ref(&[0i32, 1, 2, 3, 4, 5, 6]);
-        let buf2 = buf.clone();
-        let data = ArrayData::builder(DataType::Int32)
-            .len(5)
-            .offset(2)
-            .add_buffer(buf)
-            .build()
-            .unwrap();
-        let arr = Int32Array::from(data);
-        assert_eq!(buf2, arr.data.buffers()[0]);
-        assert_eq!(5, arr.len());
-        assert_eq!(0, arr.null_count());
-        for i in 0..3 {
-            assert_eq!((i + 2) as i32, arr.value(i));
-        }
-    }
-
-    #[test]
-    fn test_primitive_from_iter_values() {
-        // Test building a primitive array with from_iter_values
-        let arr: PrimitiveArray<Int32Type> = PrimitiveArray::from_iter_values(0..10);
-        assert_eq!(10, arr.len());
-        assert_eq!(0, arr.null_count());
-        for i in 0..10i32 {
-            assert_eq!(i, arr.value(i as usize));
-        }
-    }
-
-    #[test]
-    fn test_primitive_array_from_unbound_iter() {
-        // iterator that doesn't declare (upper) size bound
-        let value_iter = (0..)
-            .scan(0usize, |pos, i| {
-                if *pos < 10 {
-                    *pos += 1;
-                    Some(Some(i))
-                } else {
-                    // actually returns up to 10 values
-                    None
-                }
-            })
-            // limited using take()
-            .take(100);
-
-        let (_, upper_size_bound) = value_iter.size_hint();
-        // the upper bound, defined by take above, is 100
-        assert_eq!(upper_size_bound, Some(100));
-        let primitive_array: PrimitiveArray<Int32Type> = value_iter.collect();
-        // but the actual number of items in the array should be 10
-        assert_eq!(primitive_array.len(), 10);
-    }
-
-    #[test]
-    fn test_primitive_array_from_non_null_iter() {
-        let iter = (0..10_i32).map(Some);
-        let primitive_array = PrimitiveArray::<Int32Type>::from_iter(iter);
-        assert_eq!(primitive_array.len(), 10);
-        assert_eq!(primitive_array.null_count(), 0);
-        assert_eq!(primitive_array.data().null_buffer(), None);
-        assert_eq!(primitive_array.values(), &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
-    }
-
-    #[test]
-    #[should_panic(expected = "PrimitiveArray data should contain a single buffer only \
-                               (values buffer)")]
-    // Different error messages, so skip for now
-    // https://github.com/apache/arrow-rs/issues/1545
-    #[cfg(not(feature = "force_validate"))]
-    fn test_primitive_array_invalid_buffer_len() {
-        let buffer = Buffer::from_slice_ref(&[0i32, 1, 2, 3, 4]);
-        let data = unsafe {
-            ArrayData::builder(DataType::Int32)
-                .add_buffer(buffer.clone())
-                .add_buffer(buffer)
-                .len(5)
-                .build_unchecked()
-        };
-
-        drop(Int32Array::from(data));
-    }
-
-    #[test]
-    fn test_access_array_concurrently() {
-        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
-        let ret = thread::spawn(move || a.value(3)).join();
-
-        assert!(ret.is_ok());
-        assert_eq!(8, ret.ok().unwrap());
-    }
-
-    #[test]
-    fn test_primitive_array_creation() {
-        let array1: Int8Array = [10_i8, 11, 12, 13, 14].into_iter().collect();
-        let array2: Int8Array = [10_i8, 11, 12, 13, 14].into_iter().map(Some).collect();
-
-        let result = eq_dyn(&array1, &array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![true, true, true, true, true])
-        );
-    }
-
-    #[cfg(feature = "chrono-tz")]
-    #[test]
-    fn test_with_timezone() {
-        use crate::compute::hour;
-        let a: TimestampMicrosecondArray = vec![37800000000, 86339000000].into();
-
-        let b = hour(&a).unwrap();
-        assert_eq!(10, b.value(0));
-        assert_eq!(23, b.value(1));
-
-        let a = a.with_timezone(String::from("America/Los_Angeles"));
-
-        let b = hour(&a).unwrap();
-        assert_eq!(2, b.value(0));
-        assert_eq!(15, b.value(1));
-    }
-}
diff --git a/arrow/src/array/array_struct.rs b/arrow/src/array/array_struct.rs
deleted file mode 100644
index a6c3146aef2e..000000000000
--- a/arrow/src/array/array_struct.rs
+++ /dev/null
@@ -1,540 +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.
-
-use std::any::Any;
-use std::convert::{From, TryFrom};
-use std::fmt;
-use std::iter::IntoIterator;
-
-use super::{make_array, Array, ArrayData, ArrayRef};
-use crate::datatypes::DataType;
-use crate::error::{ArrowError, Result};
-use crate::{
-    buffer::{buffer_bin_or, Buffer},
-    datatypes::Field,
-};
-
-/// A nested array type where each child (called *field*) is represented by a separate
-/// array.
-/// # Example: Create an array from a vector of fields
-///
-/// ```
-/// use std::sync::Arc;
-/// use arrow::array::{Array, ArrayRef, BooleanArray, Int32Array, StructArray};
-/// use arrow::datatypes::{DataType, Field};
-///
-/// let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
-/// let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
-///
-/// let struct_array = StructArray::from(vec![
-///     (
-///         Field::new("b", DataType::Boolean, false),
-///         boolean.clone() as ArrayRef,
-///     ),
-///     (
-///         Field::new("c", DataType::Int32, false),
-///         int.clone() as ArrayRef,
-///     ),
-/// ]);
-/// assert_eq!(struct_array.column(0).as_ref(), boolean.as_ref());
-/// assert_eq!(struct_array.column(1).as_ref(), int.as_ref());
-/// assert_eq!(4, struct_array.len());
-/// assert_eq!(0, struct_array.null_count());
-/// assert_eq!(0, struct_array.offset());
-/// ```
-pub struct StructArray {
-    data: ArrayData,
-    pub(crate) boxed_fields: Vec<ArrayRef>,
-}
-
-impl StructArray {
-    /// Returns the field at `pos`.
-    pub fn column(&self, pos: usize) -> &ArrayRef {
-        &self.boxed_fields[pos]
-    }
-
-    /// Return the number of fields in this struct array
-    pub fn num_columns(&self) -> usize {
-        self.boxed_fields.len()
-    }
-
-    /// Returns the fields of the struct array
-    pub fn columns(&self) -> Vec<&ArrayRef> {
-        self.boxed_fields.iter().collect()
-    }
-
-    /// Returns child array refs of the struct array
-    pub fn columns_ref(&self) -> Vec<ArrayRef> {
-        self.boxed_fields.clone()
-    }
-
-    /// Return field names in this struct array
-    pub fn column_names(&self) -> Vec<&str> {
-        match self.data.data_type() {
-            DataType::Struct(fields) => fields
-                .iter()
-                .map(|f| f.name().as_str())
-                .collect::<Vec<&str>>(),
-            _ => unreachable!("Struct array's data type is not struct!"),
-        }
-    }
-
-    /// Return child array whose field name equals to column_name
-    ///
-    /// Note: A schema can currently have duplicate field names, in which case
-    /// the first field will always be selected.
-    /// This issue will be addressed in [ARROW-11178](https://issues.apache.org/jira/browse/ARROW-11178)
-    pub fn column_by_name(&self, column_name: &str) -> Option<&ArrayRef> {
-        self.column_names()
-            .iter()
-            .position(|c| c == &column_name)
-            .map(|pos| self.column(pos))
-    }
-}
-
-impl From<ArrayData> for StructArray {
-    fn from(data: ArrayData) -> Self {
-        let boxed_fields = data
-            .child_data()
-            .iter()
-            .map(|cd| make_array(cd.clone()))
-            .collect();
-
-        Self { data, boxed_fields }
-    }
-}
-
-impl From<StructArray> for ArrayData {
-    fn from(array: StructArray) -> Self {
-        array.data
-    }
-}
-
-impl TryFrom<Vec<(&str, ArrayRef)>> for StructArray {
-    type Error = ArrowError;
-
-    /// builds a StructArray from a vector of names and arrays.
-    /// This errors if the values have a different length.
-    /// An entry is set to Null when all values are null.
-    fn try_from(values: Vec<(&str, ArrayRef)>) -> Result<Self> {
-        let values_len = values.len();
-
-        // these will be populated
-        let mut fields = Vec::with_capacity(values_len);
-        let mut child_data = Vec::with_capacity(values_len);
-
-        // len: the size of the arrays.
-        let mut len: Option<usize> = None;
-        // null: the null mask of the arrays.
-        let mut null: Option<Buffer> = None;
-        for (field_name, array) in values {
-            let child_datum = array.data();
-            let child_datum_len = child_datum.len();
-            if let Some(len) = len {
-                if len != child_datum_len {
-                    return Err(ArrowError::InvalidArgumentError(
-                        format!("Array of field \"{}\" has length {}, but previous elements have length {}.
-                        All arrays in every entry in a struct array must have the same length.", field_name, child_datum_len, len)
-                    ));
-                }
-            } else {
-                len = Some(child_datum_len)
-            }
-            child_data.push(child_datum.clone());
-            fields.push(Field::new(
-                field_name,
-                array.data_type().clone(),
-                child_datum.null_buffer().is_some(),
-            ));
-
-            if let Some(child_null_buffer) = child_datum.null_buffer() {
-                let child_datum_offset = child_datum.offset();
-
-                null = Some(if let Some(null_buffer) = &null {
-                    buffer_bin_or(
-                        null_buffer,
-                        0,
-                        child_null_buffer,
-                        child_datum_offset,
-                        child_datum_len,
-                    )
-                } else {
-                    child_null_buffer.bit_slice(child_datum_offset, child_datum_len)
-                });
-            } else if null.is_some() {
-                // when one of the fields has no nulls, them there is no null in the array
-                null = None;
-            }
-        }
-        let len = len.unwrap();
-
-        let builder = ArrayData::builder(DataType::Struct(fields))
-            .len(len)
-            .null_bit_buffer(null)
-            .child_data(child_data);
-
-        let array_data = unsafe { builder.build_unchecked() };
-
-        Ok(StructArray::from(array_data))
-    }
-}
-
-impl Array for StructArray {
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn data(&self) -> &ArrayData {
-        &self.data
-    }
-
-    fn into_data(self) -> ArrayData {
-        self.into()
-    }
-
-    /// Returns the length (i.e., number of elements) of this array
-    fn len(&self) -> usize {
-        self.data_ref().len()
-    }
-}
-
-impl From<Vec<(Field, ArrayRef)>> for StructArray {
-    fn from(v: Vec<(Field, ArrayRef)>) -> Self {
-        let (field_types, field_values): (Vec<_>, Vec<_>) = v.into_iter().unzip();
-
-        // Check the length of the child arrays
-        let length = field_values[0].len();
-        for i in 1..field_values.len() {
-            assert_eq!(
-                length,
-                field_values[i].len(),
-                "all child arrays of a StructArray must have the same length"
-            );
-            assert_eq!(
-                field_types[i].data_type(),
-                field_values[i].data().data_type(),
-                "the field data types must match the array data in a StructArray"
-            )
-        }
-
-        let array_data = ArrayData::builder(DataType::Struct(field_types))
-            .child_data(field_values.into_iter().map(|a| a.into_data()).collect())
-            .len(length);
-        let array_data = unsafe { array_data.build_unchecked() };
-        Self::from(array_data)
-    }
-}
-
-impl fmt::Debug for StructArray {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "StructArray\n[\n")?;
-        for (child_index, name) in self.column_names().iter().enumerate() {
-            let column = self.column(child_index);
-            writeln!(
-                f,
-                "-- child {}: \"{}\" ({:?})",
-                child_index,
-                name,
-                column.data_type()
-            )?;
-            fmt::Debug::fmt(column, f)?;
-            writeln!(f)?;
-        }
-        write!(f, "]")
-    }
-}
-
-impl From<(Vec<(Field, ArrayRef)>, Buffer)> for StructArray {
-    fn from(pair: (Vec<(Field, ArrayRef)>, Buffer)) -> Self {
-        let (field_types, field_values): (Vec<_>, Vec<_>) = pair.0.into_iter().unzip();
-
-        // Check the length of the child arrays
-        let length = field_values[0].len();
-        for i in 1..field_values.len() {
-            assert_eq!(
-                length,
-                field_values[i].len(),
-                "all child arrays of a StructArray must have the same length"
-            );
-            assert_eq!(
-                field_types[i].data_type(),
-                field_values[i].data().data_type(),
-                "the field data types must match the array data in a StructArray"
-            )
-        }
-
-        let array_data = ArrayData::builder(DataType::Struct(field_types))
-            .null_bit_buffer(Some(pair.1))
-            .child_data(field_values.into_iter().map(|a| a.into_data()).collect())
-            .len(length);
-        let array_data = unsafe { array_data.build_unchecked() };
-        Self::from(array_data)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use std::sync::Arc;
-
-    use crate::{
-        array::BooleanArray, array::Float32Array, array::Float64Array, array::Int32Array,
-        array::StringArray, bitmap::Bitmap,
-    };
-    use crate::{
-        array::Int64Array,
-        datatypes::{DataType, Field},
-    };
-    use crate::{buffer::Buffer, datatypes::ToByteSlice};
-
-    #[test]
-    fn test_struct_array_builder() {
-        let array = BooleanArray::from(vec![false, false, true, true]);
-        let boolean_data = array.data();
-        let array = Int64Array::from(vec![42, 28, 19, 31]);
-        let int_data = array.data();
-
-        let fields = vec![
-            Field::new("a", DataType::Boolean, false),
-            Field::new("b", DataType::Int64, false),
-        ];
-        let struct_array_data = ArrayData::builder(DataType::Struct(fields))
-            .len(4)
-            .add_child_data(boolean_data.clone())
-            .add_child_data(int_data.clone())
-            .build()
-            .unwrap();
-        let struct_array = StructArray::from(struct_array_data);
-
-        assert_eq!(boolean_data, struct_array.column(0).data());
-        assert_eq!(int_data, struct_array.column(1).data());
-    }
-
-    #[test]
-    fn test_struct_array_from() {
-        let boolean = Arc::new(BooleanArray::from(vec![false, false, true, true]));
-        let int = Arc::new(Int32Array::from(vec![42, 28, 19, 31]));
-
-        let struct_array = StructArray::from(vec![
-            (
-                Field::new("b", DataType::Boolean, false),
-                boolean.clone() as ArrayRef,
-            ),
-            (
-                Field::new("c", DataType::Int32, false),
-                int.clone() as ArrayRef,
-            ),
-        ]);
-        assert_eq!(struct_array.column(0).as_ref(), boolean.as_ref());
-        assert_eq!(struct_array.column(1).as_ref(), int.as_ref());
-        assert_eq!(4, struct_array.len());
-        assert_eq!(0, struct_array.null_count());
-        assert_eq!(0, struct_array.offset());
-    }
-
-    /// validates that the in-memory representation follows [the spec](https://arrow.apache.org/docs/format/Columnar.html#struct-layout)
-    #[test]
-    fn test_struct_array_from_vec() {
-        let strings: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joe"),
-            None,
-            None,
-            Some("mark"),
-        ]));
-        let ints: ArrayRef =
-            Arc::new(Int32Array::from(vec![Some(1), Some(2), None, Some(4)]));
-
-        let arr =
-            StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
-                .unwrap();
-
-        let struct_data = arr.data();
-        assert_eq!(4, struct_data.len());
-        assert_eq!(1, struct_data.null_count());
-        assert_eq!(
-            // 00001011
-            Some(&Bitmap::from(Buffer::from(&[11_u8]))),
-            struct_data.null_bitmap()
-        );
-
-        let expected_string_data = ArrayData::builder(DataType::Utf8)
-            .len(4)
-            .null_bit_buffer(Some(Buffer::from(&[9_u8])))
-            .add_buffer(Buffer::from(&[0, 3, 3, 3, 7].to_byte_slice()))
-            .add_buffer(Buffer::from(b"joemark"))
-            .build()
-            .unwrap();
-
-        let expected_int_data = ArrayData::builder(DataType::Int32)
-            .len(4)
-            .null_bit_buffer(Some(Buffer::from(&[11_u8])))
-            .add_buffer(Buffer::from(&[1, 2, 0, 4].to_byte_slice()))
-            .build()
-            .unwrap();
-
-        assert_eq!(expected_string_data, *arr.column(0).data());
-        assert_eq!(expected_int_data, *arr.column(1).data());
-    }
-
-    #[test]
-    fn test_struct_array_from_vec_error() {
-        let strings: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joe"),
-            None,
-            None,
-            // 3 elements, not 4
-        ]));
-        let ints: ArrayRef =
-            Arc::new(Int32Array::from(vec![Some(1), Some(2), None, Some(4)]));
-
-        let arr =
-            StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())]);
-
-        match arr {
-            Err(ArrowError::InvalidArgumentError(e)) => {
-                assert!(e.starts_with("Array of field \"f2\" has length 4, but previous elements have length 3."));
-            }
-            _ => panic!("This test got an unexpected error type"),
-        };
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "the field data types must match the array data in a StructArray"
-    )]
-    fn test_struct_array_from_mismatched_types() {
-        drop(StructArray::from(vec![
-            (
-                Field::new("b", DataType::Int16, false),
-                Arc::new(BooleanArray::from(vec![false, false, true, true]))
-                    as Arc<dyn Array>,
-            ),
-            (
-                Field::new("c", DataType::Utf8, false),
-                Arc::new(Int32Array::from(vec![42, 28, 19, 31])),
-            ),
-        ]));
-    }
-
-    #[test]
-    fn test_struct_array_slice() {
-        let boolean_data = ArrayData::builder(DataType::Boolean)
-            .len(5)
-            .add_buffer(Buffer::from([0b00010000]))
-            .null_bit_buffer(Some(Buffer::from([0b00010001])))
-            .build()
-            .unwrap();
-        let int_data = ArrayData::builder(DataType::Int32)
-            .len(5)
-            .add_buffer(Buffer::from([0, 28, 42, 0, 0].to_byte_slice()))
-            .null_bit_buffer(Some(Buffer::from([0b00000110])))
-            .build()
-            .unwrap();
-
-        let field_types = vec![
-            Field::new("a", DataType::Boolean, false),
-            Field::new("b", DataType::Int32, false),
-        ];
-        let struct_array_data = ArrayData::builder(DataType::Struct(field_types))
-            .len(5)
-            .add_child_data(boolean_data.clone())
-            .add_child_data(int_data.clone())
-            .null_bit_buffer(Some(Buffer::from([0b00010111])))
-            .build()
-            .unwrap();
-        let struct_array = StructArray::from(struct_array_data);
-
-        assert_eq!(5, struct_array.len());
-        assert_eq!(1, struct_array.null_count());
-        assert!(struct_array.is_valid(0));
-        assert!(struct_array.is_valid(1));
-        assert!(struct_array.is_valid(2));
-        assert!(struct_array.is_null(3));
-        assert!(struct_array.is_valid(4));
-        assert_eq!(&boolean_data, struct_array.column(0).data());
-        assert_eq!(&int_data, struct_array.column(1).data());
-
-        let c0 = struct_array.column(0);
-        let c0 = c0.as_any().downcast_ref::<BooleanArray>().unwrap();
-        assert_eq!(5, c0.len());
-        assert_eq!(3, c0.null_count());
-        assert!(c0.is_valid(0));
-        assert!(!c0.value(0));
-        assert!(c0.is_null(1));
-        assert!(c0.is_null(2));
-        assert!(c0.is_null(3));
-        assert!(c0.is_valid(4));
-        assert!(c0.value(4));
-
-        let c1 = struct_array.column(1);
-        let c1 = c1.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(5, c1.len());
-        assert_eq!(3, c1.null_count());
-        assert!(c1.is_null(0));
-        assert!(c1.is_valid(1));
-        assert_eq!(28, c1.value(1));
-        assert!(c1.is_valid(2));
-        assert_eq!(42, c1.value(2));
-        assert!(c1.is_null(3));
-        assert!(c1.is_null(4));
-
-        let sliced_array = struct_array.slice(2, 3);
-        let sliced_array = sliced_array.as_any().downcast_ref::<StructArray>().unwrap();
-        assert_eq!(3, sliced_array.len());
-        assert_eq!(2, sliced_array.offset());
-        assert_eq!(1, sliced_array.null_count());
-        assert!(sliced_array.is_valid(0));
-        assert!(sliced_array.is_null(1));
-        assert!(sliced_array.is_valid(2));
-
-        let sliced_c0 = sliced_array.column(0);
-        let sliced_c0 = sliced_c0.as_any().downcast_ref::<BooleanArray>().unwrap();
-        assert_eq!(3, sliced_c0.len());
-        assert_eq!(2, sliced_c0.offset());
-        assert!(sliced_c0.is_null(0));
-        assert!(sliced_c0.is_null(1));
-        assert!(sliced_c0.is_valid(2));
-        assert!(sliced_c0.value(2));
-
-        let sliced_c1 = sliced_array.column(1);
-        let sliced_c1 = sliced_c1.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(3, sliced_c1.len());
-        assert_eq!(2, sliced_c1.offset());
-        assert!(sliced_c1.is_valid(0));
-        assert_eq!(42, sliced_c1.value(0));
-        assert!(sliced_c1.is_null(1));
-        assert!(sliced_c1.is_null(2));
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "all child arrays of a StructArray must have the same length"
-    )]
-    fn test_invalid_struct_child_array_lengths() {
-        drop(StructArray::from(vec![
-            (
-                Field::new("b", DataType::Float32, false),
-                Arc::new(Float32Array::from(vec![1.1])) as Arc<dyn Array>,
-            ),
-            (
-                Field::new("c", DataType::Float64, false),
-                Arc::new(Float64Array::from(vec![2.2, 3.3])),
-            ),
-        ]));
-    }
-}
diff --git a/arrow/src/array/builder/decimal_builder.rs b/arrow/src/array/builder/decimal_builder.rs
deleted file mode 100644
index 5527679c3b7d..000000000000
--- a/arrow/src/array/builder/decimal_builder.rs
+++ /dev/null
@@ -1,390 +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.
-
-use std::any::Any;
-use std::sync::Arc;
-
-use crate::array::array_decimal::Decimal256Array;
-use crate::array::ArrayRef;
-use crate::array::Decimal128Array;
-use crate::array::{ArrayBuilder, FixedSizeBinaryBuilder};
-
-use crate::error::{ArrowError, Result};
-
-use crate::datatypes::{
-    validate_decimal256_precision_with_lt_bytes, validate_decimal_precision,
-};
-use crate::util::decimal::Decimal256;
-
-/// Array Builder for [`Decimal128Array`]
-///
-/// See [`Decimal128Array`] for example.
-///
-#[derive(Debug)]
-pub struct Decimal128Builder {
-    builder: FixedSizeBinaryBuilder,
-    precision: usize,
-    scale: usize,
-
-    /// Should i128 values be validated for compatibility with scale and precision?
-    /// defaults to true
-    value_validation: bool,
-}
-
-/// Array Builder for [`Decimal256Array`]
-///
-/// See [`Decimal256Array`] for example.
-#[derive(Debug)]
-pub struct Decimal256Builder {
-    builder: FixedSizeBinaryBuilder,
-    precision: usize,
-    scale: usize,
-
-    /// Should decimal values be validated for compatibility with scale and precision?
-    /// defaults to true
-    value_validation: bool,
-}
-
-impl Decimal128Builder {
-    const BYTE_LENGTH: i32 = 16;
-    /// Creates a new [`Decimal128Builder`], `capacity` is the number of bytes in the values
-    /// array
-    pub fn new(capacity: usize, precision: usize, scale: usize) -> Self {
-        Self {
-            builder: FixedSizeBinaryBuilder::new(capacity, Self::BYTE_LENGTH),
-            precision,
-            scale,
-            value_validation: true,
-        }
-    }
-
-    /// Disable validation
-    ///
-    /// # Safety
-    ///
-    /// After disabling validation, caller must ensure that appended values are compatible
-    /// for the specified precision and scale.
-    pub unsafe fn disable_value_validation(&mut self) {
-        self.value_validation = false;
-    }
-
-    /// Appends a decimal value into the builder.
-    #[inline]
-    pub fn append_value(&mut self, value: impl Into<i128>) -> Result<()> {
-        let value = if self.value_validation {
-            validate_decimal_precision(value.into(), self.precision)?
-        } else {
-            value.into()
-        };
-
-        let value_as_bytes =
-            Self::from_i128_to_fixed_size_bytes(value, Self::BYTE_LENGTH as usize)?;
-        if Self::BYTE_LENGTH != value_as_bytes.len() as i32 {
-            return Err(ArrowError::InvalidArgumentError(
-                "Byte slice does not have the same length as Decimal128Builder value lengths".to_string()
-            ));
-        }
-        self.builder.append_value(value_as_bytes.as_slice())
-    }
-
-    pub(crate) fn from_i128_to_fixed_size_bytes(v: i128, size: usize) -> Result<Vec<u8>> {
-        if size > 16 {
-            return Err(ArrowError::InvalidArgumentError(
-                "Decimal128Builder only supports values up to 16 bytes.".to_string(),
-            ));
-        }
-        let res = v.to_le_bytes();
-        let start_byte = 16 - size;
-        Ok(res[start_byte..16].to_vec())
-    }
-
-    /// Append a null value to the array.
-    #[inline]
-    pub fn append_null(&mut self) {
-        self.builder.append_null()
-    }
-
-    /// Appends an `Option<impl Into<i128>>` into the builder.
-    #[inline]
-    pub fn append_option(&mut self, value: Option<impl Into<i128>>) -> Result<()> {
-        match value {
-            None => {
-                self.append_null();
-                Ok(())
-            }
-            Some(value) => self.append_value(value),
-        }
-    }
-
-    /// Builds the `Decimal128Array` and reset this builder.
-    pub fn finish(&mut self) -> Decimal128Array {
-        Decimal128Array::from_fixed_size_binary_array(
-            self.builder.finish(),
-            self.precision,
-            self.scale,
-        )
-    }
-}
-
-impl ArrayBuilder for Decimal128Builder {
-    /// Returns the builder as a non-mutable `Any` reference.
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    /// Returns the builder as a mutable `Any` reference.
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    /// Returns the boxed builder as a box of `Any`.
-    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
-        self
-    }
-
-    /// Returns the number of array slots in the builder
-    fn len(&self) -> usize {
-        self.builder.len()
-    }
-
-    /// Returns whether the number of array slots is zero
-    fn is_empty(&self) -> bool {
-        self.builder.is_empty()
-    }
-
-    /// Builds the array and reset this builder.
-    fn finish(&mut self) -> ArrayRef {
-        Arc::new(self.finish())
-    }
-}
-
-impl Decimal256Builder {
-    const BYTE_LENGTH: i32 = 32;
-    /// Creates a new [`Decimal256Builder`], `capacity` is the number of bytes in the values
-    /// array
-    pub fn new(capacity: usize, precision: usize, scale: usize) -> Self {
-        Self {
-            builder: FixedSizeBinaryBuilder::new(capacity, Self::BYTE_LENGTH),
-            precision,
-            scale,
-            value_validation: true,
-        }
-    }
-
-    /// Disable validation
-    ///
-    /// # Safety
-    ///
-    /// After disabling validation, caller must ensure that appended values are compatible
-    /// for the specified precision and scale.
-    pub unsafe fn disable_value_validation(&mut self) {
-        self.value_validation = false;
-    }
-
-    /// Appends a [`Decimal256`] number into the builder.
-    ///
-    /// Returns an error if `value` has different precision, scale or length in bytes than this builder
-    #[inline]
-    pub fn append_value(&mut self, value: &Decimal256) -> Result<()> {
-        let value = if self.value_validation {
-            let raw_bytes = value.raw_value();
-            validate_decimal256_precision_with_lt_bytes(raw_bytes, self.precision)?;
-            value
-        } else {
-            value
-        };
-
-        if self.precision != value.precision() || self.scale != value.scale() {
-            return Err(ArrowError::InvalidArgumentError(
-                "Decimal value does not have the same precision or scale as Decimal256Builder".to_string()
-            ));
-        }
-
-        let value_as_bytes = value.raw_value();
-
-        if Self::BYTE_LENGTH != value_as_bytes.len() as i32 {
-            return Err(ArrowError::InvalidArgumentError(
-                "Byte slice does not have the same length as Decimal256Builder value lengths".to_string()
-            ));
-        }
-        self.builder.append_value(value_as_bytes)
-    }
-
-    /// Append a null value to the array.
-    #[inline]
-    pub fn append_null(&mut self) {
-        self.builder.append_null()
-    }
-
-    /// Appends an `Option<&Decimal256>` into the builder.
-    #[inline]
-    pub fn append_option(&mut self, value: Option<&Decimal256>) -> Result<()> {
-        match value {
-            None => {
-                self.append_null();
-                Ok(())
-            }
-            Some(value) => self.append_value(value),
-        }
-    }
-
-    /// Builds the [`Decimal256Array`] and reset this builder.
-    pub fn finish(&mut self) -> Decimal256Array {
-        Decimal256Array::from_fixed_size_binary_array(
-            self.builder.finish(),
-            self.precision,
-            self.scale,
-        )
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use num::{BigInt, Num};
-
-    use crate::array::array_decimal::Decimal128Array;
-    use crate::array::{array_decimal, Array};
-    use crate::datatypes::DataType;
-    use crate::util::decimal::{Decimal128, Decimal256};
-
-    #[test]
-    fn test_decimal_builder() {
-        let mut builder = Decimal128Builder::new(30, 38, 6);
-
-        builder.append_value(8_887_000_000_i128).unwrap();
-        builder.append_null();
-        builder.append_value(-8_887_000_000_i128).unwrap();
-        builder.append_option(None::<i128>).unwrap();
-        builder.append_option(Some(8_887_000_000_i128)).unwrap();
-        let decimal_array: Decimal128Array = builder.finish();
-
-        assert_eq!(&DataType::Decimal128(38, 6), decimal_array.data_type());
-        assert_eq!(5, decimal_array.len());
-        assert_eq!(2, decimal_array.null_count());
-        assert_eq!(32, decimal_array.value_offset(2));
-        assert_eq!(16, decimal_array.value_length());
-    }
-
-    #[test]
-    fn test_decimal_builder_with_decimal128() {
-        let mut builder = Decimal128Builder::new(30, 38, 6);
-
-        builder
-            .append_value(Decimal128::new_from_i128(30, 38, 8_887_000_000_i128))
-            .unwrap();
-        builder.append_null();
-        builder
-            .append_value(Decimal128::new_from_i128(30, 38, -8_887_000_000_i128))
-            .unwrap();
-        let decimal_array: Decimal128Array = builder.finish();
-
-        assert_eq!(&DataType::Decimal128(38, 6), decimal_array.data_type());
-        assert_eq!(3, decimal_array.len());
-        assert_eq!(1, decimal_array.null_count());
-        assert_eq!(32, decimal_array.value_offset(2));
-        assert_eq!(16, decimal_array.value_length());
-    }
-
-    #[test]
-    fn test_decimal256_builder() {
-        let mut builder = Decimal256Builder::new(30, 40, 6);
-
-        let mut bytes = [0_u8; 32];
-        bytes[0..16].clone_from_slice(&8_887_000_000_i128.to_le_bytes());
-        let value = Decimal256::try_new_from_bytes(40, 6, &bytes).unwrap();
-        builder.append_value(&value).unwrap();
-
-        builder.append_null();
-
-        bytes = [255; 32];
-        let value = Decimal256::try_new_from_bytes(40, 6, &bytes).unwrap();
-        builder.append_value(&value).unwrap();
-
-        bytes = [0; 32];
-        bytes[0..16].clone_from_slice(&0_i128.to_le_bytes());
-        bytes[15] = 128;
-        let value = Decimal256::try_new_from_bytes(40, 6, &bytes).unwrap();
-        builder.append_value(&value).unwrap();
-
-        builder.append_option(None::<&Decimal256>).unwrap();
-        builder.append_option(Some(&value)).unwrap();
-
-        let decimal_array: Decimal256Array = builder.finish();
-
-        assert_eq!(&DataType::Decimal256(40, 6), decimal_array.data_type());
-        assert_eq!(6, decimal_array.len());
-        assert_eq!(2, decimal_array.null_count());
-        assert_eq!(64, decimal_array.value_offset(2));
-        assert_eq!(32, decimal_array.value_length());
-
-        assert_eq!(decimal_array.value(0).to_string(), "8887.000000");
-        assert!(decimal_array.is_null(1));
-        assert_eq!(decimal_array.value(2).to_string(), "-0.000001");
-        assert_eq!(
-            decimal_array.value(3).to_string(),
-            "170141183460469231731687303715884.105728"
-        );
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Decimal value does not have the same precision or scale as Decimal256Builder"
-    )]
-    fn test_decimal256_builder_unmatched_precision_scale() {
-        let mut builder = Decimal256Builder::new(30, 10, 6);
-
-        let mut bytes = [0_u8; 32];
-        bytes[0..16].clone_from_slice(&8_887_000_000_i128.to_le_bytes());
-        let value = Decimal256::try_new_from_bytes(40, 6, &bytes).unwrap();
-        builder.append_value(&value).unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "9999999999999999999999999999999999999999999999999999999999999999999999999999 is too large to store in a Decimal256 of precision 75. Max is 999999999999999999999999999999999999999999999999999999999999999999999999999"
-    )]
-    fn test_decimal256_builder_out_of_range_precision_scale() {
-        let mut builder = Decimal256Builder::new(30, 75, 6);
-
-        let big_value = BigInt::from_str_radix("9999999999999999999999999999999999999999999999999999999999999999999999999999", 10).unwrap();
-        let value = Decimal256::from_big_int(&big_value, 75, 6).unwrap();
-        builder.append_value(&value).unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "9999999999999999999999999999999999999999999999999999999999999999999999999999 is too large to store in a Decimal256 of precision 75. Max is 999999999999999999999999999999999999999999999999999999999999999999999999999"
-    )]
-    fn test_decimal256_data_validation() {
-        let mut builder = Decimal256Builder::new(30, 75, 6);
-        // Disable validation at builder
-        unsafe {
-            builder.disable_value_validation();
-        }
-
-        let big_value = BigInt::from_str_radix("9999999999999999999999999999999999999999999999999999999999999999999999999999", 10).unwrap();
-        let value = Decimal256::from_big_int(&big_value, 75, 6).unwrap();
-        builder
-            .append_value(&value)
-            .expect("should not validate invalid value at builder");
-
-        let array = builder.finish();
-        let array_data = array_decimal::BasicDecimalArray::data(&array);
-        array_data.validate_values().unwrap();
-    }
-}
diff --git a/arrow/src/array/builder/generic_binary_builder.rs b/arrow/src/array/builder/generic_binary_builder.rs
deleted file mode 100644
index aca2e1d9694e..000000000000
--- a/arrow/src/array/builder/generic_binary_builder.rs
+++ /dev/null
@@ -1,233 +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.
-
-use crate::array::{
-    ArrayBuilder, ArrayDataBuilder, ArrayRef, GenericBinaryArray, OffsetSizeTrait,
-    UInt8BufferBuilder,
-};
-use std::any::Any;
-use std::sync::Arc;
-
-use super::{BufferBuilder, NullBufferBuilder};
-
-///  Array builder for [`GenericBinaryArray`]
-#[derive(Debug)]
-pub struct GenericBinaryBuilder<OffsetSize: OffsetSizeTrait> {
-    value_builder: UInt8BufferBuilder,
-    offsets_builder: BufferBuilder<OffsetSize>,
-    null_buffer_builder: NullBufferBuilder,
-}
-
-impl<OffsetSize: OffsetSizeTrait> GenericBinaryBuilder<OffsetSize> {
-    /// Creates a new [`GenericBinaryBuilder`].
-    /// `capacity` is the number of bytes in the values array.
-    pub fn new(capacity: usize) -> Self {
-        let mut offsets_builder = BufferBuilder::<OffsetSize>::new(1024);
-        offsets_builder.append(OffsetSize::zero());
-        Self {
-            value_builder: UInt8BufferBuilder::new(capacity),
-            offsets_builder,
-            null_buffer_builder: NullBufferBuilder::new(1024),
-        }
-    }
-
-    /// Creates a new [`GenericBinaryBuilder`],
-    /// `item_capacity` is the number of items to pre-allocate space for in this builder
-    /// `data_capacity` is the number of bytes to pre-allocate space for in this builder
-    pub fn with_capacity(item_capacity: usize, data_capacity: usize) -> Self {
-        let mut offsets_builder = BufferBuilder::<OffsetSize>::new(item_capacity + 1);
-        offsets_builder.append(OffsetSize::zero());
-        Self {
-            value_builder: UInt8BufferBuilder::new(data_capacity),
-            offsets_builder,
-            null_buffer_builder: NullBufferBuilder::new(item_capacity),
-        }
-    }
-
-    /// Appends a byte slice into the builder.
-    #[inline]
-    pub fn append_value(&mut self, value: impl AsRef<[u8]>) {
-        self.value_builder.append_slice(value.as_ref());
-        self.null_buffer_builder.append(true);
-        self.offsets_builder
-            .append(OffsetSize::from_usize(self.value_builder.len()).unwrap());
-    }
-
-    /// Append a null value to the array.
-    #[inline]
-    pub fn append_null(&mut self) {
-        self.null_buffer_builder.append(false);
-        self.offsets_builder
-            .append(OffsetSize::from_usize(self.value_builder.len()).unwrap());
-    }
-
-    /// Builds the [`GenericBinaryArray`] and reset this builder.
-    pub fn finish(&mut self) -> GenericBinaryArray<OffsetSize> {
-        let array_type = GenericBinaryArray::<OffsetSize>::DATA_TYPE;
-        let array_builder = ArrayDataBuilder::new(array_type)
-            .len(self.len())
-            .add_buffer(self.offsets_builder.finish())
-            .add_buffer(self.value_builder.finish())
-            .null_bit_buffer(self.null_buffer_builder.finish());
-
-        self.offsets_builder.append(OffsetSize::zero());
-        let array_data = unsafe { array_builder.build_unchecked() };
-        GenericBinaryArray::<OffsetSize>::from(array_data)
-    }
-
-    /// Returns the current values buffer as a slice
-    pub fn values_slice(&self) -> &[u8] {
-        self.value_builder.as_slice()
-    }
-
-    /// Returns the current offsets buffer as a slice
-    pub fn offsets_slice(&self) -> &[OffsetSize] {
-        self.offsets_builder.as_slice()
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> ArrayBuilder for GenericBinaryBuilder<OffsetSize> {
-    /// Returns the builder as a non-mutable `Any` reference.
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    /// Returns the builder as a mutable `Any` reference.
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    /// Returns the boxed builder as a box of `Any`.
-    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
-        self
-    }
-
-    /// Returns the number of binary slots in the builder
-    fn len(&self) -> usize {
-        self.null_buffer_builder.len()
-    }
-
-    /// Returns whether the number of binary slots is zero
-    fn is_empty(&self) -> bool {
-        self.null_buffer_builder.is_empty()
-    }
-
-    /// Builds the array and reset this builder.
-    fn finish(&mut self) -> ArrayRef {
-        Arc::new(self.finish())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::{Array, OffsetSizeTrait};
-
-    fn _test_generic_binary_builder<O: OffsetSizeTrait>() {
-        let mut builder = GenericBinaryBuilder::<O>::new(20);
-
-        builder.append_value(b"hello");
-        builder.append_value(b"");
-        builder.append_null();
-        builder.append_value(b"rust");
-
-        let array = builder.finish();
-
-        assert_eq!(4, array.len());
-        assert_eq!(1, array.null_count());
-        assert_eq!(b"hello", array.value(0));
-        assert_eq!([] as [u8; 0], array.value(1));
-        assert!(array.is_null(2));
-        assert_eq!(b"rust", array.value(3));
-        assert_eq!(O::from_usize(5).unwrap(), array.value_offsets()[2]);
-        assert_eq!(O::from_usize(4).unwrap(), array.value_length(3));
-    }
-
-    #[test]
-    fn test_binary_builder() {
-        _test_generic_binary_builder::<i32>()
-    }
-
-    #[test]
-    fn test_large_binary_builder() {
-        _test_generic_binary_builder::<i64>()
-    }
-
-    fn _test_generic_binary_builder_all_nulls<O: OffsetSizeTrait>() {
-        let mut builder = GenericBinaryBuilder::<O>::new(10);
-        builder.append_null();
-        builder.append_null();
-        builder.append_null();
-        assert_eq!(3, builder.len());
-        assert!(!builder.is_empty());
-
-        let array = builder.finish();
-        assert_eq!(3, array.null_count());
-        assert_eq!(3, array.len());
-        assert!(array.is_null(0));
-        assert!(array.is_null(1));
-        assert!(array.is_null(2));
-    }
-
-    #[test]
-    fn test_binary_builder_all_nulls() {
-        _test_generic_binary_builder_all_nulls::<i32>()
-    }
-
-    #[test]
-    fn test_large_binary_builder_all_nulls() {
-        _test_generic_binary_builder_all_nulls::<i64>()
-    }
-
-    fn _test_generic_binary_builder_reset<O: OffsetSizeTrait>() {
-        let mut builder = GenericBinaryBuilder::<O>::new(20);
-
-        builder.append_value(b"hello");
-        builder.append_value(b"");
-        builder.append_null();
-        builder.append_value(b"rust");
-        builder.finish();
-
-        assert!(builder.is_empty());
-
-        builder.append_value(b"parquet");
-        builder.append_null();
-        builder.append_value(b"arrow");
-        builder.append_value(b"");
-        let array = builder.finish();
-
-        assert_eq!(4, array.len());
-        assert_eq!(1, array.null_count());
-        assert_eq!(b"parquet", array.value(0));
-        assert!(array.is_null(1));
-        assert_eq!(b"arrow", array.value(2));
-        assert_eq!(b"", array.value(1));
-        assert_eq!(O::zero(), array.value_offsets()[0]);
-        assert_eq!(O::from_usize(7).unwrap(), array.value_offsets()[2]);
-        assert_eq!(O::from_usize(5).unwrap(), array.value_length(2));
-    }
-
-    #[test]
-    fn test_binary_builder_reset() {
-        _test_generic_binary_builder_reset::<i32>()
-    }
-
-    #[test]
-    fn test_large_binary_builder_reset() {
-        _test_generic_binary_builder_reset::<i64>()
-    }
-}
diff --git a/arrow/src/array/builder/generic_list_builder.rs b/arrow/src/array/builder/generic_list_builder.rs
deleted file mode 100644
index 686156df13bc..000000000000
--- a/arrow/src/array/builder/generic_list_builder.rs
+++ /dev/null
@@ -1,320 +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.
-
-use std::any::Any;
-use std::sync::Arc;
-
-use crate::array::ArrayData;
-use crate::array::ArrayRef;
-use crate::array::GenericListArray;
-use crate::array::OffsetSizeTrait;
-use crate::datatypes::Field;
-
-use super::{ArrayBuilder, BufferBuilder, NullBufferBuilder};
-
-///  Array builder for [`GenericListArray`]
-#[derive(Debug)]
-pub struct GenericListBuilder<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> {
-    offsets_builder: BufferBuilder<OffsetSize>,
-    null_buffer_builder: NullBufferBuilder,
-    values_builder: T,
-}
-
-impl<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> GenericListBuilder<OffsetSize, T> {
-    /// Creates a new [`GenericListBuilder`] from a given values array builder
-    pub fn new(values_builder: T) -> Self {
-        let capacity = values_builder.len();
-        Self::with_capacity(values_builder, capacity)
-    }
-
-    /// Creates a new [`GenericListBuilder`] from a given values array builder
-    /// `capacity` is the number of items to pre-allocate space for in this builder
-    pub fn with_capacity(values_builder: T, capacity: usize) -> Self {
-        let mut offsets_builder = BufferBuilder::<OffsetSize>::new(capacity + 1);
-        offsets_builder.append(OffsetSize::zero());
-        Self {
-            offsets_builder,
-            null_buffer_builder: NullBufferBuilder::new(capacity),
-            values_builder,
-        }
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> ArrayBuilder
-    for GenericListBuilder<OffsetSize, T>
-where
-    T: 'static,
-{
-    /// Returns the builder as a non-mutable `Any` reference.
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    /// Returns the builder as a mutable `Any` reference.
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    /// Returns the boxed builder as a box of `Any`.
-    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
-        self
-    }
-
-    /// Returns the number of array slots in the builder
-    fn len(&self) -> usize {
-        self.null_buffer_builder.len()
-    }
-
-    /// Returns whether the number of array slots is zero
-    fn is_empty(&self) -> bool {
-        self.null_buffer_builder.is_empty()
-    }
-
-    /// Builds the array and reset this builder.
-    fn finish(&mut self) -> ArrayRef {
-        Arc::new(self.finish())
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait, T: ArrayBuilder> GenericListBuilder<OffsetSize, T>
-where
-    T: 'static,
-{
-    /// Returns the child array builder as a mutable reference.
-    ///
-    /// This mutable reference can be used to append values into the child array builder,
-    /// but you must call [`append`](#method.append) to delimit each distinct list value.
-    pub fn values(&mut self) -> &mut T {
-        &mut self.values_builder
-    }
-
-    /// Returns the child array builder as an immutable reference
-    pub fn values_ref(&self) -> &T {
-        &self.values_builder
-    }
-
-    /// Finish the current variable-length list array slot
-    #[inline]
-    pub fn append(&mut self, is_valid: bool) {
-        self.offsets_builder
-            .append(OffsetSize::from_usize(self.values_builder.len()).unwrap());
-        self.null_buffer_builder.append(is_valid);
-    }
-
-    /// Builds the [`GenericListArray`] and reset this builder.
-    pub fn finish(&mut self) -> GenericListArray<OffsetSize> {
-        let len = self.len();
-        let values_arr = self
-            .values_builder
-            .as_any_mut()
-            .downcast_mut::<T>()
-            .unwrap()
-            .finish();
-        let values_data = values_arr.data();
-
-        let offset_buffer = self.offsets_builder.finish();
-        let null_bit_buffer = self.null_buffer_builder.finish();
-        self.offsets_builder.append(OffsetSize::zero());
-        let field = Box::new(Field::new(
-            "item",
-            values_data.data_type().clone(),
-            true, // TODO: find a consistent way of getting this
-        ));
-        let data_type = GenericListArray::<OffsetSize>::DATA_TYPE_CONSTRUCTOR(field);
-        let array_data_builder = ArrayData::builder(data_type)
-            .len(len)
-            .add_buffer(offset_buffer)
-            .add_child_data(values_data.clone())
-            .null_bit_buffer(null_bit_buffer);
-
-        let array_data = unsafe { array_data_builder.build_unchecked() };
-
-        GenericListArray::<OffsetSize>::from(array_data)
-    }
-
-    /// Returns the current offsets buffer as a slice
-    pub fn offsets_slice(&self) -> &[OffsetSize] {
-        self.offsets_builder.as_slice()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::builder::ListBuilder;
-    use crate::array::{Array, Int32Array, Int32Builder};
-    use crate::buffer::Buffer;
-    use crate::datatypes::DataType;
-
-    fn _test_generic_list_array_builder<O: OffsetSizeTrait>() {
-        let values_builder = Int32Builder::new(10);
-        let mut builder = GenericListBuilder::<O, _>::new(values_builder);
-
-        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
-        builder.values().append_value(0);
-        builder.values().append_value(1);
-        builder.values().append_value(2);
-        builder.append(true);
-        builder.values().append_value(3);
-        builder.values().append_value(4);
-        builder.values().append_value(5);
-        builder.append(true);
-        builder.values().append_value(6);
-        builder.values().append_value(7);
-        builder.append(true);
-        let list_array = builder.finish();
-
-        let values = list_array.values().data().buffers()[0].clone();
-        assert_eq!(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7]), values);
-        assert_eq!(
-            Buffer::from_slice_ref(&[0, 3, 6, 8].map(|n| O::from_usize(n).unwrap())),
-            list_array.data().buffers()[0].clone()
-        );
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(3, list_array.len());
-        assert_eq!(0, list_array.null_count());
-        assert_eq!(O::from_usize(6).unwrap(), list_array.value_offsets()[2]);
-        assert_eq!(O::from_usize(2).unwrap(), list_array.value_length(2));
-        for i in 0..3 {
-            assert!(list_array.is_valid(i));
-            assert!(!list_array.is_null(i));
-        }
-    }
-
-    #[test]
-    fn test_list_array_builder() {
-        _test_generic_list_array_builder::<i32>()
-    }
-
-    #[test]
-    fn test_large_list_array_builder() {
-        _test_generic_list_array_builder::<i64>()
-    }
-
-    fn _test_generic_list_array_builder_nulls<O: OffsetSizeTrait>() {
-        let values_builder = Int32Builder::new(10);
-        let mut builder = GenericListBuilder::<O, _>::new(values_builder);
-
-        //  [[0, 1, 2], null, [3, null, 5], [6, 7]]
-        builder.values().append_value(0);
-        builder.values().append_value(1);
-        builder.values().append_value(2);
-        builder.append(true);
-        builder.append(false);
-        builder.values().append_value(3);
-        builder.values().append_null();
-        builder.values().append_value(5);
-        builder.append(true);
-        builder.values().append_value(6);
-        builder.values().append_value(7);
-        builder.append(true);
-
-        let list_array = builder.finish();
-
-        assert_eq!(DataType::Int32, list_array.value_type());
-        assert_eq!(4, list_array.len());
-        assert_eq!(1, list_array.null_count());
-        assert_eq!(O::from_usize(3).unwrap(), list_array.value_offsets()[2]);
-        assert_eq!(O::from_usize(3).unwrap(), list_array.value_length(2));
-    }
-
-    #[test]
-    fn test_list_array_builder_nulls() {
-        _test_generic_list_array_builder_nulls::<i32>()
-    }
-
-    #[test]
-    fn test_large_list_array_builder_nulls() {
-        _test_generic_list_array_builder_nulls::<i64>()
-    }
-
-    #[test]
-    fn test_list_array_builder_finish() {
-        let values_builder = Int32Array::builder(5);
-        let mut builder = ListBuilder::new(values_builder);
-
-        builder.values().append_slice(&[1, 2, 3]);
-        builder.append(true);
-        builder.values().append_slice(&[4, 5, 6]);
-        builder.append(true);
-
-        let mut arr = builder.finish();
-        assert_eq!(2, arr.len());
-        assert!(builder.is_empty());
-
-        builder.values().append_slice(&[7, 8, 9]);
-        builder.append(true);
-        arr = builder.finish();
-        assert_eq!(1, arr.len());
-        assert!(builder.is_empty());
-    }
-
-    #[test]
-    fn test_list_list_array_builder() {
-        let primitive_builder = Int32Builder::new(10);
-        let values_builder = ListBuilder::new(primitive_builder);
-        let mut builder = ListBuilder::new(values_builder);
-
-        //  [[[1, 2], [3, 4]], [[5, 6, 7], null, [8]], null, [[9, 10]]]
-        builder.values().values().append_value(1);
-        builder.values().values().append_value(2);
-        builder.values().append(true);
-        builder.values().values().append_value(3);
-        builder.values().values().append_value(4);
-        builder.values().append(true);
-        builder.append(true);
-
-        builder.values().values().append_value(5);
-        builder.values().values().append_value(6);
-        builder.values().values().append_value(7);
-        builder.values().append(true);
-        builder.values().append(false);
-        builder.values().values().append_value(8);
-        builder.values().append(true);
-        builder.append(true);
-
-        builder.append(false);
-
-        builder.values().values().append_value(9);
-        builder.values().values().append_value(10);
-        builder.values().append(true);
-        builder.append(true);
-
-        let list_array = builder.finish();
-
-        assert_eq!(4, list_array.len());
-        assert_eq!(1, list_array.null_count());
-        assert_eq!(
-            Buffer::from_slice_ref(&[0, 2, 5, 5, 6]),
-            list_array.data().buffers()[0].clone()
-        );
-
-        assert_eq!(6, list_array.values().data().len());
-        assert_eq!(1, list_array.values().data().null_count());
-        assert_eq!(
-            Buffer::from_slice_ref(&[0, 2, 4, 7, 7, 8, 10]),
-            list_array.values().data().buffers()[0].clone()
-        );
-
-        assert_eq!(10, list_array.values().data().child_data()[0].len());
-        assert_eq!(0, list_array.values().data().child_data()[0].null_count());
-        assert_eq!(
-            Buffer::from_slice_ref(&[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),
-            list_array.values().data().child_data()[0].buffers()[0].clone()
-        );
-    }
-}
diff --git a/arrow/src/array/builder/generic_string_builder.rs b/arrow/src/array/builder/generic_string_builder.rs
deleted file mode 100644
index 02c34bdd3130..000000000000
--- a/arrow/src/array/builder/generic_string_builder.rs
+++ /dev/null
@@ -1,188 +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.
-
-use crate::array::{ArrayBuilder, ArrayRef, GenericStringArray, OffsetSizeTrait};
-use std::any::Any;
-use std::sync::Arc;
-
-use super::GenericBinaryBuilder;
-
-///  Array builder for [`GenericStringArray`]
-#[derive(Debug)]
-pub struct GenericStringBuilder<OffsetSize: OffsetSizeTrait> {
-    builder: GenericBinaryBuilder<OffsetSize>,
-}
-
-impl<OffsetSize: OffsetSizeTrait> GenericStringBuilder<OffsetSize> {
-    /// Creates a new [`GenericStringBuilder`],
-    /// `capacity` is the number of bytes of string data to pre-allocate space for in this builder
-    pub fn new(capacity: usize) -> Self {
-        Self {
-            builder: GenericBinaryBuilder::new(capacity),
-        }
-    }
-
-    /// Creates a new [`GenericStringBuilder`],
-    /// `data_capacity` is the number of bytes of string data to pre-allocate space for in this builder
-    /// `item_capacity` is the number of items to pre-allocate space for in this builder
-    pub fn with_capacity(item_capacity: usize, data_capacity: usize) -> Self {
-        Self {
-            builder: GenericBinaryBuilder::with_capacity(item_capacity, data_capacity),
-        }
-    }
-
-    /// Appends a string into the builder.
-    #[inline]
-    pub fn append_value(&mut self, value: impl AsRef<str>) {
-        self.builder.append_value(value.as_ref().as_bytes());
-    }
-
-    /// Append a null value to the array.
-    #[inline]
-    pub fn append_null(&mut self) {
-        self.builder.append_null()
-    }
-
-    /// Append an `Option` value to the array.
-    #[inline]
-    pub fn append_option(&mut self, value: Option<impl AsRef<str>>) {
-        match value {
-            None => self.append_null(),
-            Some(v) => self.append_value(v),
-        };
-    }
-
-    /// Builds the [`GenericStringArray`] and reset this builder.
-    pub fn finish(&mut self) -> GenericStringArray<OffsetSize> {
-        GenericStringArray::<OffsetSize>::from(self.builder.finish())
-    }
-
-    /// Returns the current values buffer as a slice
-    pub fn values_slice(&self) -> &[u8] {
-        self.builder.values_slice()
-    }
-
-    /// Returns the current offsets buffer as a slice
-    pub fn offsets_slice(&self) -> &[OffsetSize] {
-        self.builder.offsets_slice()
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> ArrayBuilder for GenericStringBuilder<OffsetSize> {
-    /// Returns the builder as a non-mutable `Any` reference.
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    /// Returns the builder as a mutable `Any` reference.
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    /// Returns the boxed builder as a box of `Any`.
-    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
-        self
-    }
-
-    /// Returns the number of array slots in the builder
-    fn len(&self) -> usize {
-        self.builder.len()
-    }
-
-    /// Returns whether the number of array slots is zero
-    fn is_empty(&self) -> bool {
-        self.builder.is_empty()
-    }
-
-    /// Builds the array and reset this builder.
-    fn finish(&mut self) -> ArrayRef {
-        let a = GenericStringBuilder::<OffsetSize>::finish(self);
-        Arc::new(a)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::{Array, ArrayBuilder, OffsetSizeTrait};
-
-    fn _test_generic_string_array_builder<O: OffsetSizeTrait>() {
-        let mut builder = GenericStringBuilder::<O>::new(20);
-        let owned = "arrow".to_owned();
-
-        builder.append_value("hello");
-        builder.append_value("");
-        builder.append_value(&owned);
-        builder.append_null();
-        builder.append_option(Some("rust"));
-        builder.append_option(None::<&str>);
-        builder.append_option(None::<String>);
-        assert_eq!(7, builder.len());
-
-        assert_eq!(
-            GenericStringArray::<O>::from(vec![
-                Some("hello"),
-                Some(""),
-                Some("arrow"),
-                None,
-                Some("rust"),
-                None,
-                None
-            ]),
-            builder.finish()
-        );
-    }
-
-    #[test]
-    fn test_string_array_builder() {
-        _test_generic_string_array_builder::<i32>()
-    }
-
-    #[test]
-    fn test_large_string_array_builder() {
-        _test_generic_string_array_builder::<i64>()
-    }
-
-    fn _test_generic_string_array_builder_finish<O: OffsetSizeTrait>() {
-        let mut builder = GenericStringBuilder::<O>::with_capacity(3, 11);
-
-        builder.append_value("hello");
-        builder.append_value("rust");
-        builder.append_null();
-
-        builder.finish();
-        assert!(builder.is_empty());
-        assert_eq!(&[O::zero()], builder.offsets_slice());
-
-        builder.append_value("arrow");
-        builder.append_value("parquet");
-        let arr = builder.finish();
-        // array should not have null buffer because there is not `null` value.
-        assert_eq!(None, arr.data().null_buffer());
-        assert_eq!(GenericStringArray::<O>::from(vec!["arrow", "parquet"]), arr,)
-    }
-
-    #[test]
-    fn test_string_array_builder_finish() {
-        _test_generic_string_array_builder_finish::<i32>()
-    }
-
-    #[test]
-    fn test_large_string_array_builder_finish() {
-        _test_generic_string_array_builder_finish::<i64>()
-    }
-}
diff --git a/arrow/src/array/builder/map_builder.rs b/arrow/src/array/builder/map_builder.rs
deleted file mode 100644
index 7e68abd5f1a1..000000000000
--- a/arrow/src/array/builder/map_builder.rs
+++ /dev/null
@@ -1,257 +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.
-
-use std::any::Any;
-use std::sync::Arc;
-
-use super::{ArrayBuilder, BufferBuilder, NullBufferBuilder};
-use crate::array::array::Array;
-use crate::array::ArrayData;
-use crate::array::ArrayRef;
-use crate::array::MapArray;
-use crate::array::StructArray;
-use crate::datatypes::DataType;
-use crate::datatypes::Field;
-use crate::error::ArrowError;
-use crate::error::Result;
-
-#[derive(Debug)]
-pub struct MapBuilder<K: ArrayBuilder, V: ArrayBuilder> {
-    offsets_builder: BufferBuilder<i32>,
-    null_buffer_builder: NullBufferBuilder,
-    field_names: MapFieldNames,
-    key_builder: K,
-    value_builder: V,
-    len: i32,
-}
-
-#[derive(Debug, Clone)]
-pub struct MapFieldNames {
-    pub entry: String,
-    pub key: String,
-    pub value: String,
-}
-
-impl Default for MapFieldNames {
-    fn default() -> Self {
-        Self {
-            entry: "entries".to_string(),
-            key: "keys".to_string(),
-            value: "values".to_string(),
-        }
-    }
-}
-
-#[allow(dead_code)]
-impl<K: ArrayBuilder, V: ArrayBuilder> MapBuilder<K, V> {
-    pub fn new(
-        field_names: Option<MapFieldNames>,
-        key_builder: K,
-        value_builder: V,
-    ) -> Self {
-        let capacity = key_builder.len();
-        Self::with_capacity(field_names, key_builder, value_builder, capacity)
-    }
-
-    pub fn with_capacity(
-        field_names: Option<MapFieldNames>,
-        key_builder: K,
-        value_builder: V,
-        capacity: usize,
-    ) -> Self {
-        let mut offsets_builder = BufferBuilder::<i32>::new(capacity + 1);
-        let len = 0;
-        offsets_builder.append(len);
-        Self {
-            offsets_builder,
-            null_buffer_builder: NullBufferBuilder::new(capacity),
-            field_names: field_names.unwrap_or_default(),
-            key_builder,
-            value_builder,
-            len,
-        }
-    }
-
-    pub fn keys(&mut self) -> &mut K {
-        &mut self.key_builder
-    }
-
-    pub fn values(&mut self) -> &mut V {
-        &mut self.value_builder
-    }
-
-    /// Finish the current map array slot
-    ///
-    /// Returns an error if the key and values builders are in an inconsistent state.
-    #[inline]
-    pub fn append(&mut self, is_valid: bool) -> Result<()> {
-        if self.key_builder.len() != self.value_builder.len() {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "Cannot append to a map builder when its keys and values have unequal lengths of {} and {}",
-                self.key_builder.len(),
-                self.value_builder.len()
-            )));
-        }
-        self.offsets_builder.append(self.key_builder.len() as i32);
-        self.null_buffer_builder.append(is_valid);
-        self.len += 1;
-        Ok(())
-    }
-
-    pub fn finish(&mut self) -> MapArray {
-        let len = self.len();
-        self.len = 0;
-
-        // Build the keys
-        let keys_arr = self
-            .key_builder
-            .as_any_mut()
-            .downcast_mut::<K>()
-            .unwrap()
-            .finish();
-        let values_arr = self
-            .value_builder
-            .as_any_mut()
-            .downcast_mut::<V>()
-            .unwrap()
-            .finish();
-
-        let keys_field = Field::new(
-            self.field_names.key.as_str(),
-            keys_arr.data_type().clone(),
-            false, // always nullable
-        );
-        let values_field = Field::new(
-            self.field_names.value.as_str(),
-            values_arr.data_type().clone(),
-            true,
-        );
-
-        let struct_array =
-            StructArray::from(vec![(keys_field, keys_arr), (values_field, values_arr)]);
-
-        let offset_buffer = self.offsets_builder.finish();
-        let null_bit_buffer = self.null_buffer_builder.finish();
-        self.offsets_builder.append(self.len);
-        let map_field = Box::new(Field::new(
-            self.field_names.entry.as_str(),
-            struct_array.data_type().clone(),
-            false, // always non-nullable
-        ));
-        let array_data = ArrayData::builder(DataType::Map(map_field, false)) // TODO: support sorted keys
-            .len(len)
-            .add_buffer(offset_buffer)
-            .add_child_data(struct_array.into_data())
-            .null_bit_buffer(null_bit_buffer);
-
-        let array_data = unsafe { array_data.build_unchecked() };
-
-        MapArray::from(array_data)
-    }
-}
-
-impl<K: ArrayBuilder, V: ArrayBuilder> ArrayBuilder for MapBuilder<K, V> {
-    fn len(&self) -> usize {
-        self.len as usize
-    }
-
-    fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    fn finish(&mut self) -> ArrayRef {
-        Arc::new(self.finish())
-    }
-
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
-        self
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use crate::array::builder::StringBuilder;
-    use crate::array::Int32Builder;
-    use crate::bitmap::Bitmap;
-    use crate::buffer::Buffer;
-
-    // TODO: add a test that finishes building, after designing a spec-compliant
-    // way of inserting values to the map.
-    // A map's values shouldn't be repeated within a slot
-
-    #[test]
-    fn test_map_array_builder() {
-        let string_builder = StringBuilder::new(4);
-        let int_builder = Int32Builder::new(4);
-
-        let mut builder = MapBuilder::new(None, string_builder, int_builder);
-
-        let string_builder = builder.keys();
-        string_builder.append_value("joe");
-        string_builder.append_null();
-        string_builder.append_null();
-        string_builder.append_value("mark");
-
-        let int_builder = builder.values();
-        int_builder.append_value(1);
-        int_builder.append_value(2);
-        int_builder.append_null();
-        int_builder.append_value(4);
-
-        builder.append(true).unwrap();
-        builder.append(false).unwrap();
-        builder.append(true).unwrap();
-
-        let arr = builder.finish();
-
-        let map_data = arr.data();
-        assert_eq!(3, map_data.len());
-        assert_eq!(1, map_data.null_count());
-        assert_eq!(
-            Some(&Bitmap::from(Buffer::from(&[5_u8]))),
-            map_data.null_bitmap()
-        );
-
-        let expected_string_data = ArrayData::builder(DataType::Utf8)
-            .len(4)
-            .null_bit_buffer(Some(Buffer::from(&[9_u8])))
-            .add_buffer(Buffer::from_slice_ref(&[0, 3, 3, 3, 7]))
-            .add_buffer(Buffer::from_slice_ref(b"joemark"))
-            .build()
-            .unwrap();
-
-        let expected_int_data = ArrayData::builder(DataType::Int32)
-            .len(4)
-            .null_bit_buffer(Some(Buffer::from_slice_ref(&[11_u8])))
-            .add_buffer(Buffer::from_slice_ref(&[1, 2, 0, 4]))
-            .build()
-            .unwrap();
-
-        assert_eq!(&expected_string_data, arr.keys().data());
-        assert_eq!(&expected_int_data, arr.values().data());
-    }
-}
diff --git a/arrow/src/array/builder/mod.rs b/arrow/src/array/builder/mod.rs
deleted file mode 100644
index 77dd907f6ee1..000000000000
--- a/arrow/src/array/builder/mod.rs
+++ /dev/null
@@ -1,151 +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.
-
-//! Defines a [`BufferBuilder`](crate::array::BufferBuilder) capable
-//! of creating a [`Buffer`](crate::buffer::Buffer) which can be used
-//! as an internal buffer in an [`ArrayData`](crate::array::ArrayData)
-//! object.
-
-mod boolean_buffer_builder;
-mod boolean_builder;
-mod buffer_builder;
-mod decimal_builder;
-mod fixed_size_binary_builder;
-mod fixed_size_list_builder;
-mod generic_binary_builder;
-mod generic_list_builder;
-mod generic_string_builder;
-mod map_builder;
-mod null_buffer_builder;
-mod primitive_builder;
-mod primitive_dictionary_builder;
-mod string_dictionary_builder;
-mod struct_builder;
-mod union_builder;
-
-use std::any::Any;
-use std::marker::PhantomData;
-use std::ops::Range;
-
-use super::ArrayRef;
-
-pub use boolean_buffer_builder::BooleanBufferBuilder;
-pub use boolean_builder::BooleanBuilder;
-pub use buffer_builder::BufferBuilder;
-pub use decimal_builder::Decimal128Builder;
-pub use decimal_builder::Decimal256Builder;
-pub use fixed_size_binary_builder::FixedSizeBinaryBuilder;
-pub use fixed_size_list_builder::FixedSizeListBuilder;
-pub use generic_binary_builder::GenericBinaryBuilder;
-pub use generic_list_builder::GenericListBuilder;
-pub use generic_string_builder::GenericStringBuilder;
-pub use map_builder::{MapBuilder, MapFieldNames};
-use null_buffer_builder::NullBufferBuilder;
-pub use primitive_builder::PrimitiveBuilder;
-pub use primitive_dictionary_builder::PrimitiveDictionaryBuilder;
-pub use string_dictionary_builder::StringDictionaryBuilder;
-pub use struct_builder::{make_builder, StructBuilder};
-pub use union_builder::UnionBuilder;
-
-/// Trait for dealing with different array builders at runtime
-///
-/// # Example
-///
-/// ```
-/// # use arrow::{
-/// #     array::{ArrayBuilder, ArrayRef, Float64Builder, Int64Builder, StringArray, StringBuilder},
-/// #     error::ArrowError,
-/// # };
-/// # fn main() -> std::result::Result<(), ArrowError> {
-/// // Create
-/// let mut data_builders: Vec<Box<dyn ArrayBuilder>> = vec![
-///     Box::new(Float64Builder::new(1024)),
-///     Box::new(Int64Builder::new(1024)),
-///     Box::new(StringBuilder::new(1024)),
-/// ];
-///
-/// // Fill
-/// data_builders[0]
-///     .as_any_mut()
-///     .downcast_mut::<Float64Builder>()
-///     .unwrap()
-///     .append_value(3.14);
-/// data_builders[1]
-///     .as_any_mut()
-///     .downcast_mut::<Int64Builder>()
-///     .unwrap()
-///     .append_value(-1);
-/// data_builders[2]
-///     .as_any_mut()
-///     .downcast_mut::<StringBuilder>()
-///     .unwrap()
-///     .append_value("🍎");
-///
-/// // Finish
-/// let array_refs: Vec<ArrayRef> = data_builders
-///     .iter_mut()
-///     .map(|builder| builder.finish())
-///     .collect();
-/// assert_eq!(array_refs[0].len(), 1);
-/// assert_eq!(array_refs[1].is_null(0), false);
-/// assert_eq!(
-///     array_refs[2]
-///         .as_any()
-///         .downcast_ref::<StringArray>()
-///         .unwrap()
-///         .value(0),
-///     "🍎"
-/// );
-/// # Ok(())
-/// # }
-/// ```
-pub trait ArrayBuilder: Any + Send {
-    /// Returns the number of array slots in the builder
-    fn len(&self) -> usize;
-
-    /// Returns whether number of array slots is zero
-    fn is_empty(&self) -> bool;
-
-    /// Builds the array
-    fn finish(&mut self) -> ArrayRef;
-
-    /// Returns the builder as a non-mutable `Any` reference.
-    ///
-    /// This is most useful when one wants to call non-mutable APIs on a specific builder
-    /// type. In this case, one can first cast this into a `Any`, and then use
-    /// `downcast_ref` to get a reference on the specific builder.
-    fn as_any(&self) -> &dyn Any;
-
-    /// Returns the builder as a mutable `Any` reference.
-    ///
-    /// This is most useful when one wants to call mutable APIs on a specific builder
-    /// type. In this case, one can first cast this into a `Any`, and then use
-    /// `downcast_mut` to get a reference on the specific builder.
-    fn as_any_mut(&mut self) -> &mut dyn Any;
-
-    /// Returns the boxed builder as a box of `Any`.
-    fn into_box_any(self: Box<Self>) -> Box<dyn Any>;
-}
-
-pub type ListBuilder<T> = GenericListBuilder<i32, T>;
-pub type LargeListBuilder<T> = GenericListBuilder<i64, T>;
-
-pub type BinaryBuilder = GenericBinaryBuilder<i32>;
-pub type LargeBinaryBuilder = GenericBinaryBuilder<i64>;
-
-pub type StringBuilder = GenericStringBuilder<i32>;
-pub type LargeStringBuilder = GenericStringBuilder<i64>;
diff --git a/arrow/src/array/builder/primitive_dictionary_builder.rs b/arrow/src/array/builder/primitive_dictionary_builder.rs
deleted file mode 100644
index 71656f985d16..000000000000
--- a/arrow/src/array/builder/primitive_dictionary_builder.rs
+++ /dev/null
@@ -1,252 +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.
-
-use std::any::Any;
-use std::collections::hash_map::Entry;
-use std::collections::HashMap;
-use std::sync::Arc;
-
-use crate::array::{Array, ArrayRef, ArrowPrimitiveType, DictionaryArray};
-use crate::datatypes::{ArrowNativeType, DataType, ToByteSlice};
-use crate::error::{ArrowError, Result};
-
-use super::ArrayBuilder;
-use super::PrimitiveBuilder;
-
-/// Wraps a type implementing `ToByteSlice` implementing `Hash` and `Eq` for it
-///
-/// This is necessary to handle types such as f32, which don't natively implement these
-#[derive(Debug)]
-struct Value<T>(T);
-
-impl<T: ToByteSlice> std::hash::Hash for Value<T> {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.0.to_byte_slice().hash(state)
-    }
-}
-
-impl<T: ToByteSlice> PartialEq for Value<T> {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.to_byte_slice().eq(other.0.to_byte_slice())
-    }
-}
-
-impl<T: ToByteSlice> Eq for Value<T> {}
-
-/// Array builder for `DictionaryArray`. For example to map a set of byte indices
-/// to f32 values. Note that the use of a `HashMap` here will not scale to very large
-/// arrays or result in an ordered dictionary.
-///
-/// # Example:
-///
-/// ```
-///  use arrow::array::{
-///      Array, PrimitiveBuilder, PrimitiveDictionaryBuilder,
-///      UInt8Array, UInt32Array,
-///    };
-///  use arrow::datatypes::{UInt8Type, UInt32Type};
-///
-///  let key_builder = PrimitiveBuilder::<UInt8Type>::new(3);
-///  let value_builder = PrimitiveBuilder::<UInt32Type>::new(2);
-///  let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-///  builder.append(12345678).unwrap();
-///  builder.append_null();
-///  builder.append(22345678).unwrap();
-///  let array = builder.finish();
-///
-///  assert_eq!(
-///      array.keys(),
-///      &UInt8Array::from(vec![Some(0), None, Some(1)])
-///  );
-///
-///  // Values are polymorphic and so require a downcast.
-///  let av = array.values();
-///  let ava: &UInt32Array = av.as_any().downcast_ref::<UInt32Array>().unwrap();
-///  let avs: &[u32] = ava.values();
-///
-///  assert!(!array.is_null(0));
-///  assert!(array.is_null(1));
-///  assert!(!array.is_null(2));
-///
-///  assert_eq!(avs, &[12345678, 22345678]);
-/// ```
-#[derive(Debug)]
-pub struct PrimitiveDictionaryBuilder<K, V>
-where
-    K: ArrowPrimitiveType,
-    V: ArrowPrimitiveType,
-{
-    keys_builder: PrimitiveBuilder<K>,
-    values_builder: PrimitiveBuilder<V>,
-    map: HashMap<Value<V::Native>, K::Native>,
-}
-
-impl<K, V> PrimitiveDictionaryBuilder<K, V>
-where
-    K: ArrowPrimitiveType,
-    V: ArrowPrimitiveType,
-{
-    /// Creates a new `PrimitiveDictionaryBuilder` from a keys builder and a value builder.
-    pub fn new(
-        keys_builder: PrimitiveBuilder<K>,
-        values_builder: PrimitiveBuilder<V>,
-    ) -> Self {
-        Self {
-            keys_builder,
-            values_builder,
-            map: HashMap::new(),
-        }
-    }
-}
-
-impl<K, V> ArrayBuilder for PrimitiveDictionaryBuilder<K, V>
-where
-    K: ArrowPrimitiveType,
-    V: ArrowPrimitiveType,
-{
-    /// Returns the builder as an non-mutable `Any` reference.
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    /// Returns the builder as an mutable `Any` reference.
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    /// Returns the boxed builder as a box of `Any`.
-    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
-        self
-    }
-
-    /// Returns the number of array slots in the builder
-    fn len(&self) -> usize {
-        self.keys_builder.len()
-    }
-
-    /// Returns whether the number of array slots is zero
-    fn is_empty(&self) -> bool {
-        self.keys_builder.is_empty()
-    }
-
-    /// Builds the array and reset this builder.
-    fn finish(&mut self) -> ArrayRef {
-        Arc::new(self.finish())
-    }
-}
-
-impl<K, V> PrimitiveDictionaryBuilder<K, V>
-where
-    K: ArrowPrimitiveType,
-    V: ArrowPrimitiveType,
-{
-    /// Append a primitive value to the array. Return an existing index
-    /// if already present in the values array or a new index if the
-    /// value is appended to the values array.
-    #[inline]
-    pub fn append(&mut self, value: V::Native) -> Result<K::Native> {
-        let key = match self.map.entry(Value(value)) {
-            Entry::Vacant(vacant) => {
-                // Append new value.
-                let key = K::Native::from_usize(self.values_builder.len())
-                    .ok_or(ArrowError::DictionaryKeyOverflowError)?;
-                self.values_builder.append_value(value);
-                vacant.insert(key);
-                key
-            }
-            Entry::Occupied(o) => *o.get(),
-        };
-
-        self.keys_builder.append_value(key);
-        Ok(key)
-    }
-
-    #[inline]
-    pub fn append_null(&mut self) {
-        self.keys_builder.append_null()
-    }
-
-    /// Builds the `DictionaryArray` and reset this builder.
-    pub fn finish(&mut self) -> DictionaryArray<K> {
-        self.map.clear();
-        let values = self.values_builder.finish();
-        let keys = self.keys_builder.finish();
-
-        let data_type =
-            DataType::Dictionary(Box::new(K::DATA_TYPE), Box::new(V::DATA_TYPE));
-
-        let builder = keys
-            .into_data()
-            .into_builder()
-            .data_type(data_type)
-            .child_data(vec![values.into_data()]);
-
-        DictionaryArray::from(unsafe { builder.build_unchecked() })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use crate::array::Array;
-    use crate::array::UInt32Array;
-    use crate::array::UInt8Array;
-    use crate::datatypes::UInt32Type;
-    use crate::datatypes::UInt8Type;
-
-    #[test]
-    fn test_primitive_dictionary_builder() {
-        let key_builder = PrimitiveBuilder::<UInt8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<UInt32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(12345678).unwrap();
-        builder.append_null();
-        builder.append(22345678).unwrap();
-        let array = builder.finish();
-
-        assert_eq!(
-            array.keys(),
-            &UInt8Array::from(vec![Some(0), None, Some(1)])
-        );
-
-        // Values are polymorphic and so require a downcast.
-        let av = array.values();
-        let ava: &UInt32Array = av.as_any().downcast_ref::<UInt32Array>().unwrap();
-        let avs: &[u32] = ava.values();
-
-        assert!(!array.is_null(0));
-        assert!(array.is_null(1));
-        assert!(!array.is_null(2));
-
-        assert_eq!(avs, &[12345678, 22345678]);
-    }
-
-    #[test]
-    #[should_panic(expected = "DictionaryKeyOverflowError")]
-    fn test_primitive_dictionary_overflow() {
-        let key_builder = PrimitiveBuilder::<UInt8Type>::new(257);
-        let value_builder = PrimitiveBuilder::<UInt32Type>::new(257);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        // 256 unique keys.
-        for i in 0..256 {
-            builder.append(i + 1000).unwrap();
-        }
-        // Special error if the key overflows (256th entry)
-        builder.append(1257).unwrap();
-    }
-}
diff --git a/arrow/src/array/builder/string_dictionary_builder.rs b/arrow/src/array/builder/string_dictionary_builder.rs
deleted file mode 100644
index 15a36a64c14e..000000000000
--- a/arrow/src/array/builder/string_dictionary_builder.rs
+++ /dev/null
@@ -1,374 +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.
-
-use super::PrimitiveBuilder;
-use crate::array::{
-    Array, ArrayBuilder, ArrayRef, DictionaryArray, StringArray, StringBuilder,
-};
-use crate::datatypes::{ArrowDictionaryKeyType, ArrowNativeType, DataType};
-use crate::error::{ArrowError, Result};
-use hashbrown::hash_map::RawEntryMut;
-use hashbrown::HashMap;
-use std::any::Any;
-use std::sync::Arc;
-
-/// Array builder for `DictionaryArray` that stores Strings. For example to map a set of byte indices
-/// to String values. Note that the use of a `HashMap` here will not scale to very large
-/// arrays or result in an ordered dictionary.
-///
-/// ```
-/// use arrow::{
-///   array::{
-///     Int8Array, StringArray,
-///     PrimitiveBuilder, StringBuilder, StringDictionaryBuilder,
-///   },
-///   datatypes::Int8Type,
-/// };
-///
-/// // Create a dictionary array indexed by bytes whose values are Strings.
-/// // It can thus hold up to 256 distinct string values.
-///
-/// let key_builder = PrimitiveBuilder::<Int8Type>::new(100);
-/// let value_builder = StringBuilder::new(100);
-/// let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
-///
-/// // The builder builds the dictionary value by value
-/// builder.append("abc").unwrap();
-/// builder.append_null();
-/// builder.append("def").unwrap();
-/// builder.append("def").unwrap();
-/// builder.append("abc").unwrap();
-/// let array = builder.finish();
-///
-/// assert_eq!(
-///   array.keys(),
-///   &Int8Array::from(vec![Some(0), None, Some(1), Some(1), Some(0)])
-/// );
-///
-/// // Values are polymorphic and so require a downcast.
-/// let av = array.values();
-/// let ava: &StringArray = av.as_any().downcast_ref::<StringArray>().unwrap();
-///
-/// assert_eq!(ava.value(0), "abc");
-/// assert_eq!(ava.value(1), "def");
-///
-/// ```
-#[derive(Debug)]
-pub struct StringDictionaryBuilder<K>
-where
-    K: ArrowDictionaryKeyType,
-{
-    state: ahash::RandomState,
-    /// Used to provide a lookup from string value to key type
-    ///
-    /// Note: K's hash implementation is not used, instead the raw entry
-    /// API is used to store keys w.r.t the hash of the strings themselves
-    ///
-    dedup: HashMap<K::Native, (), ()>,
-
-    keys_builder: PrimitiveBuilder<K>,
-    values_builder: StringBuilder,
-}
-
-impl<K> StringDictionaryBuilder<K>
-where
-    K: ArrowDictionaryKeyType,
-{
-    /// Creates a new `StringDictionaryBuilder` from a keys builder and a value builder.
-    pub fn new(keys_builder: PrimitiveBuilder<K>, values_builder: StringBuilder) -> Self {
-        Self {
-            state: Default::default(),
-            dedup: HashMap::with_capacity_and_hasher(keys_builder.capacity(), ()),
-            keys_builder,
-            values_builder,
-        }
-    }
-
-    /// Creates a new `StringDictionaryBuilder` from a keys builder and a dictionary
-    /// which is initialized with the given values.
-    /// The indices of those dictionary values are used as keys.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// use arrow::datatypes::Int16Type;
-    /// use arrow::array::{StringArray, StringDictionaryBuilder, PrimitiveBuilder, Int16Array};
-    /// use std::convert::TryFrom;
-    ///
-    /// let dictionary_values = StringArray::from(vec![None, Some("abc"), Some("def")]);
-    ///
-    /// let mut builder = StringDictionaryBuilder::new_with_dictionary(PrimitiveBuilder::<Int16Type>::new(3), &dictionary_values).unwrap();
-    /// builder.append("def").unwrap();
-    /// builder.append_null();
-    /// builder.append("abc").unwrap();
-    ///
-    /// let dictionary_array = builder.finish();
-    ///
-    /// let keys = dictionary_array.keys();
-    ///
-    /// assert_eq!(keys, &Int16Array::from(vec![Some(2), None, Some(1)]));
-    /// ```
-    pub fn new_with_dictionary(
-        keys_builder: PrimitiveBuilder<K>,
-        dictionary_values: &StringArray,
-    ) -> Result<Self> {
-        let state = ahash::RandomState::default();
-        let dict_len = dictionary_values.len();
-
-        let mut dedup = HashMap::with_capacity_and_hasher(dict_len, ());
-
-        let values_len = dictionary_values.value_data().len();
-        let mut values_builder = StringBuilder::with_capacity(dict_len, values_len);
-
-        for (idx, maybe_value) in dictionary_values.iter().enumerate() {
-            match maybe_value {
-                Some(value) => {
-                    let hash = state.hash_one(value.as_bytes());
-
-                    let key = K::Native::from_usize(idx)
-                        .ok_or(ArrowError::DictionaryKeyOverflowError)?;
-
-                    let entry =
-                        dedup.raw_entry_mut().from_hash(hash, |key: &K::Native| {
-                            value.as_bytes() == get_bytes(&values_builder, key)
-                        });
-
-                    if let RawEntryMut::Vacant(v) = entry {
-                        v.insert_with_hasher(hash, key, (), |key| {
-                            state.hash_one(get_bytes(&values_builder, key))
-                        });
-                    }
-
-                    values_builder.append_value(value);
-                }
-                None => values_builder.append_null(),
-            }
-        }
-
-        Ok(Self {
-            state,
-            dedup,
-            keys_builder,
-            values_builder,
-        })
-    }
-}
-
-impl<K> ArrayBuilder for StringDictionaryBuilder<K>
-where
-    K: ArrowDictionaryKeyType,
-{
-    /// Returns the builder as an non-mutable `Any` reference.
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    /// Returns the builder as an mutable `Any` reference.
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    /// Returns the boxed builder as a box of `Any`.
-    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
-        self
-    }
-
-    /// Returns the number of array slots in the builder
-    fn len(&self) -> usize {
-        self.keys_builder.len()
-    }
-
-    /// Returns whether the number of array slots is zero
-    fn is_empty(&self) -> bool {
-        self.keys_builder.is_empty()
-    }
-
-    /// Builds the array and reset this builder.
-    fn finish(&mut self) -> ArrayRef {
-        Arc::new(self.finish())
-    }
-}
-
-impl<K> StringDictionaryBuilder<K>
-where
-    K: ArrowDictionaryKeyType,
-{
-    /// Append a primitive value to the array. Return an existing index
-    /// if already present in the values array or a new index if the
-    /// value is appended to the values array.
-    ///
-    /// Returns an error if the new index would overflow the key type.
-    pub fn append(&mut self, value: impl AsRef<str>) -> Result<K::Native> {
-        let value = value.as_ref();
-
-        let state = &self.state;
-        let storage = &mut self.values_builder;
-        let hash = state.hash_one(value.as_bytes());
-
-        let entry = self
-            .dedup
-            .raw_entry_mut()
-            .from_hash(hash, |key| value.as_bytes() == get_bytes(storage, key));
-
-        let key = match entry {
-            RawEntryMut::Occupied(entry) => *entry.into_key(),
-            RawEntryMut::Vacant(entry) => {
-                let index = storage.len();
-                storage.append_value(value);
-                let key = K::Native::from_usize(index)
-                    .ok_or(ArrowError::DictionaryKeyOverflowError)?;
-
-                *entry
-                    .insert_with_hasher(hash, key, (), |key| {
-                        state.hash_one(get_bytes(storage, key))
-                    })
-                    .0
-            }
-        };
-        self.keys_builder.append_value(key);
-
-        Ok(key)
-    }
-
-    #[inline]
-    pub fn append_null(&mut self) {
-        self.keys_builder.append_null()
-    }
-
-    /// Builds the `DictionaryArray` and reset this builder.
-    pub fn finish(&mut self) -> DictionaryArray<K> {
-        self.dedup.clear();
-        let values = self.values_builder.finish();
-        let keys = self.keys_builder.finish();
-
-        let data_type =
-            DataType::Dictionary(Box::new(K::DATA_TYPE), Box::new(DataType::Utf8));
-
-        let builder = keys
-            .into_data()
-            .into_builder()
-            .data_type(data_type)
-            .child_data(vec![values.into_data()]);
-
-        DictionaryArray::from(unsafe { builder.build_unchecked() })
-    }
-}
-
-fn get_bytes<'a, K: ArrowNativeType>(values: &'a StringBuilder, key: &K) -> &'a [u8] {
-    let offsets = values.offsets_slice();
-    let values = values.values_slice();
-
-    let idx = key.to_usize().unwrap();
-    let end_offset = offsets[idx + 1].to_usize().unwrap();
-    let start_offset = offsets[idx].to_usize().unwrap();
-
-    &values[start_offset..end_offset]
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use crate::array::Array;
-    use crate::array::Int8Array;
-    use crate::datatypes::Int16Type;
-    use crate::datatypes::Int8Type;
-
-    #[test]
-    fn test_string_dictionary_builder() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(5);
-        let value_builder = StringBuilder::new(2);
-        let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
-        builder.append("abc").unwrap();
-        builder.append_null();
-        builder.append("def").unwrap();
-        builder.append("def").unwrap();
-        builder.append("abc").unwrap();
-        let array = builder.finish();
-
-        assert_eq!(
-            array.keys(),
-            &Int8Array::from(vec![Some(0), None, Some(1), Some(1), Some(0)])
-        );
-
-        // Values are polymorphic and so require a downcast.
-        let av = array.values();
-        let ava: &StringArray = av.as_any().downcast_ref::<StringArray>().unwrap();
-
-        assert_eq!(ava.value(0), "abc");
-        assert_eq!(ava.value(1), "def");
-    }
-
-    #[test]
-    fn test_string_dictionary_builder_with_existing_dictionary() {
-        let dictionary = StringArray::from(vec![None, Some("def"), Some("abc")]);
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(6);
-        let mut builder =
-            StringDictionaryBuilder::new_with_dictionary(key_builder, &dictionary)
-                .unwrap();
-        builder.append("abc").unwrap();
-        builder.append_null();
-        builder.append("def").unwrap();
-        builder.append("def").unwrap();
-        builder.append("abc").unwrap();
-        builder.append("ghi").unwrap();
-        let array = builder.finish();
-
-        assert_eq!(
-            array.keys(),
-            &Int8Array::from(vec![Some(2), None, Some(1), Some(1), Some(2), Some(3)])
-        );
-
-        // Values are polymorphic and so require a downcast.
-        let av = array.values();
-        let ava: &StringArray = av.as_any().downcast_ref::<StringArray>().unwrap();
-
-        assert!(!ava.is_valid(0));
-        assert_eq!(ava.value(1), "def");
-        assert_eq!(ava.value(2), "abc");
-        assert_eq!(ava.value(3), "ghi");
-    }
-
-    #[test]
-    fn test_string_dictionary_builder_with_reserved_null_value() {
-        let dictionary: Vec<Option<&str>> = vec![None];
-        let dictionary = StringArray::from(dictionary);
-
-        let key_builder = PrimitiveBuilder::<Int16Type>::new(4);
-        let mut builder =
-            StringDictionaryBuilder::new_with_dictionary(key_builder, &dictionary)
-                .unwrap();
-        builder.append("abc").unwrap();
-        builder.append_null();
-        builder.append("def").unwrap();
-        builder.append("abc").unwrap();
-        let array = builder.finish();
-
-        assert!(array.is_null(1));
-        assert!(!array.is_valid(1));
-
-        let keys = array.keys();
-
-        assert_eq!(keys.value(0), 1);
-        assert!(keys.is_null(1));
-        // zero initialization is currently guaranteed by Buffer allocation and resizing
-        assert_eq!(keys.value(1), 0);
-        assert_eq!(keys.value(2), 2);
-        assert_eq!(keys.value(3), 1);
-    }
-}
diff --git a/arrow/src/array/builder/struct_builder.rs b/arrow/src/array/builder/struct_builder.rs
deleted file mode 100644
index 554e3c553db5..000000000000
--- a/arrow/src/array/builder/struct_builder.rs
+++ /dev/null
@@ -1,414 +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.
-
-use std::any::Any;
-use std::fmt;
-use std::sync::Arc;
-
-use crate::array::builder::decimal_builder::Decimal128Builder;
-use crate::array::*;
-use crate::datatypes::DataType;
-use crate::datatypes::Field;
-
-use super::NullBufferBuilder;
-
-/// Array builder for Struct types.
-///
-/// Note that callers should make sure that methods of all the child field builders are
-/// properly called to maintain the consistency of the data structure.
-pub struct StructBuilder {
-    fields: Vec<Field>,
-    field_builders: Vec<Box<dyn ArrayBuilder>>,
-    null_buffer_builder: NullBufferBuilder,
-    len: usize,
-}
-
-impl fmt::Debug for StructBuilder {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("StructBuilder")
-            .field("fields", &self.fields)
-            .field("bitmap_builder", &self.null_buffer_builder)
-            .field("len", &self.len)
-            .finish()
-    }
-}
-
-impl ArrayBuilder for StructBuilder {
-    /// Returns the number of array slots in the builder.
-    ///
-    /// Note that this always return the first child field builder's length, and it is
-    /// the caller's responsibility to maintain the consistency that all the child field
-    /// builder should have the equal number of elements.
-    fn len(&self) -> usize {
-        self.len
-    }
-
-    /// Returns whether the number of array slots is zero
-    fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    /// Builds the array.
-    fn finish(&mut self) -> ArrayRef {
-        Arc::new(self.finish())
-    }
-
-    /// Returns the builder as a non-mutable `Any` reference.
-    ///
-    /// This is most useful when one wants to call non-mutable APIs on a specific builder
-    /// type. In this case, one can first cast this into a `Any`, and then use
-    /// `downcast_ref` to get a reference on the specific builder.
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    /// Returns the builder as a mutable `Any` reference.
-    ///
-    /// This is most useful when one wants to call mutable APIs on a specific builder
-    /// type. In this case, one can first cast this into a `Any`, and then use
-    /// `downcast_mut` to get a reference on the specific builder.
-    fn as_any_mut(&mut self) -> &mut dyn Any {
-        self
-    }
-
-    /// Returns the boxed builder as a box of `Any`.
-    fn into_box_any(self: Box<Self>) -> Box<dyn Any> {
-        self
-    }
-}
-
-/// Returns a builder with capacity `capacity` that corresponds to the datatype `DataType`
-/// This function is useful to construct arrays from an arbitrary vectors with known/expected
-/// schema.
-pub fn make_builder(datatype: &DataType, capacity: usize) -> Box<dyn ArrayBuilder> {
-    match datatype {
-        DataType::Null => unimplemented!(),
-        DataType::Boolean => Box::new(BooleanBuilder::new(capacity)),
-        DataType::Int8 => Box::new(Int8Builder::new(capacity)),
-        DataType::Int16 => Box::new(Int16Builder::new(capacity)),
-        DataType::Int32 => Box::new(Int32Builder::new(capacity)),
-        DataType::Int64 => Box::new(Int64Builder::new(capacity)),
-        DataType::UInt8 => Box::new(UInt8Builder::new(capacity)),
-        DataType::UInt16 => Box::new(UInt16Builder::new(capacity)),
-        DataType::UInt32 => Box::new(UInt32Builder::new(capacity)),
-        DataType::UInt64 => Box::new(UInt64Builder::new(capacity)),
-        DataType::Float32 => Box::new(Float32Builder::new(capacity)),
-        DataType::Float64 => Box::new(Float64Builder::new(capacity)),
-        DataType::Binary => Box::new(BinaryBuilder::new(capacity)),
-        DataType::FixedSizeBinary(len) => {
-            Box::new(FixedSizeBinaryBuilder::new(capacity, *len))
-        }
-        DataType::Decimal128(precision, scale) => {
-            Box::new(Decimal128Builder::new(capacity, *precision, *scale))
-        }
-        DataType::Utf8 => Box::new(StringBuilder::new(capacity)),
-        DataType::Date32 => Box::new(Date32Builder::new(capacity)),
-        DataType::Date64 => Box::new(Date64Builder::new(capacity)),
-        DataType::Time32(TimeUnit::Second) => {
-            Box::new(Time32SecondBuilder::new(capacity))
-        }
-        DataType::Time32(TimeUnit::Millisecond) => {
-            Box::new(Time32MillisecondBuilder::new(capacity))
-        }
-        DataType::Time64(TimeUnit::Microsecond) => {
-            Box::new(Time64MicrosecondBuilder::new(capacity))
-        }
-        DataType::Time64(TimeUnit::Nanosecond) => {
-            Box::new(Time64NanosecondBuilder::new(capacity))
-        }
-        DataType::Timestamp(TimeUnit::Second, _) => {
-            Box::new(TimestampSecondBuilder::new(capacity))
-        }
-        DataType::Timestamp(TimeUnit::Millisecond, _) => {
-            Box::new(TimestampMillisecondBuilder::new(capacity))
-        }
-        DataType::Timestamp(TimeUnit::Microsecond, _) => {
-            Box::new(TimestampMicrosecondBuilder::new(capacity))
-        }
-        DataType::Timestamp(TimeUnit::Nanosecond, _) => {
-            Box::new(TimestampNanosecondBuilder::new(capacity))
-        }
-        DataType::Interval(IntervalUnit::YearMonth) => {
-            Box::new(IntervalYearMonthBuilder::new(capacity))
-        }
-        DataType::Interval(IntervalUnit::DayTime) => {
-            Box::new(IntervalDayTimeBuilder::new(capacity))
-        }
-        DataType::Interval(IntervalUnit::MonthDayNano) => {
-            Box::new(IntervalMonthDayNanoBuilder::new(capacity))
-        }
-        DataType::Duration(TimeUnit::Second) => {
-            Box::new(DurationSecondBuilder::new(capacity))
-        }
-        DataType::Duration(TimeUnit::Millisecond) => {
-            Box::new(DurationMillisecondBuilder::new(capacity))
-        }
-        DataType::Duration(TimeUnit::Microsecond) => {
-            Box::new(DurationMicrosecondBuilder::new(capacity))
-        }
-        DataType::Duration(TimeUnit::Nanosecond) => {
-            Box::new(DurationNanosecondBuilder::new(capacity))
-        }
-        DataType::Struct(fields) => {
-            Box::new(StructBuilder::from_fields(fields.clone(), capacity))
-        }
-        t => panic!("Data type {:?} is not currently supported", t),
-    }
-}
-
-impl StructBuilder {
-    pub fn new(fields: Vec<Field>, field_builders: Vec<Box<dyn ArrayBuilder>>) -> Self {
-        Self {
-            fields,
-            field_builders,
-            null_buffer_builder: NullBufferBuilder::new(0),
-            len: 0,
-        }
-    }
-
-    pub fn from_fields(fields: Vec<Field>, capacity: usize) -> Self {
-        let mut builders = Vec::with_capacity(fields.len());
-        for field in &fields {
-            builders.push(make_builder(field.data_type(), capacity));
-        }
-        Self::new(fields, builders)
-    }
-
-    /// Returns a mutable reference to the child field builder at index `i`.
-    /// Result will be `None` if the input type `T` provided doesn't match the actual
-    /// field builder's type.
-    pub fn field_builder<T: ArrayBuilder>(&mut self, i: usize) -> Option<&mut T> {
-        self.field_builders[i].as_any_mut().downcast_mut::<T>()
-    }
-
-    /// Returns the number of fields for the struct this builder is building.
-    pub fn num_fields(&self) -> usize {
-        self.field_builders.len()
-    }
-
-    /// Appends an element (either null or non-null) to the struct. The actual elements
-    /// should be appended for each child sub-array in a consistent way.
-    #[inline]
-    pub fn append(&mut self, is_valid: bool) {
-        self.null_buffer_builder.append(is_valid);
-        self.len += 1;
-    }
-
-    /// Appends a null element to the struct.
-    #[inline]
-    pub fn append_null(&mut self) {
-        self.append(false)
-    }
-
-    /// Builds the `StructArray` and reset this builder.
-    pub fn finish(&mut self) -> StructArray {
-        let mut child_data = Vec::with_capacity(self.field_builders.len());
-        for f in &mut self.field_builders {
-            let arr = f.finish();
-            child_data.push(arr.into_data());
-        }
-
-        let null_bit_buffer = self.null_buffer_builder.finish();
-        let builder = ArrayData::builder(DataType::Struct(self.fields.clone()))
-            .len(self.len)
-            .child_data(child_data)
-            .null_bit_buffer(null_bit_buffer);
-
-        self.len = 0;
-
-        let array_data = unsafe { builder.build_unchecked() };
-        StructArray::from(array_data)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use crate::array::Array;
-    use crate::bitmap::Bitmap;
-    use crate::buffer::Buffer;
-
-    #[test]
-    fn test_struct_array_builder() {
-        let string_builder = StringBuilder::new(4);
-        let int_builder = Int32Builder::new(4);
-
-        let mut fields = Vec::new();
-        let mut field_builders = Vec::new();
-        fields.push(Field::new("f1", DataType::Utf8, false));
-        field_builders.push(Box::new(string_builder) as Box<dyn ArrayBuilder>);
-        fields.push(Field::new("f2", DataType::Int32, false));
-        field_builders.push(Box::new(int_builder) as Box<dyn ArrayBuilder>);
-
-        let mut builder = StructBuilder::new(fields, field_builders);
-        assert_eq!(2, builder.num_fields());
-
-        let string_builder = builder
-            .field_builder::<StringBuilder>(0)
-            .expect("builder at field 0 should be string builder");
-        string_builder.append_value("joe");
-        string_builder.append_null();
-        string_builder.append_null();
-        string_builder.append_value("mark");
-
-        let int_builder = builder
-            .field_builder::<Int32Builder>(1)
-            .expect("builder at field 1 should be int builder");
-        int_builder.append_value(1);
-        int_builder.append_value(2);
-        int_builder.append_null();
-        int_builder.append_value(4);
-
-        builder.append(true);
-        builder.append(true);
-        builder.append_null();
-        builder.append(true);
-
-        let arr = builder.finish();
-
-        let struct_data = arr.data();
-        assert_eq!(4, struct_data.len());
-        assert_eq!(1, struct_data.null_count());
-        assert_eq!(
-            Some(&Bitmap::from(Buffer::from(&[11_u8]))),
-            struct_data.null_bitmap()
-        );
-
-        let expected_string_data = ArrayData::builder(DataType::Utf8)
-            .len(4)
-            .null_bit_buffer(Some(Buffer::from(&[9_u8])))
-            .add_buffer(Buffer::from_slice_ref(&[0, 3, 3, 3, 7]))
-            .add_buffer(Buffer::from_slice_ref(b"joemark"))
-            .build()
-            .unwrap();
-
-        let expected_int_data = ArrayData::builder(DataType::Int32)
-            .len(4)
-            .null_bit_buffer(Some(Buffer::from_slice_ref(&[11_u8])))
-            .add_buffer(Buffer::from_slice_ref(&[1, 2, 0, 4]))
-            .build()
-            .unwrap();
-
-        assert_eq!(expected_string_data, *arr.column(0).data());
-        assert_eq!(expected_int_data, *arr.column(1).data());
-    }
-
-    #[test]
-    fn test_struct_array_builder_finish() {
-        let int_builder = Int32Builder::new(10);
-        let bool_builder = BooleanBuilder::new(10);
-
-        let mut fields = Vec::new();
-        let mut field_builders = Vec::new();
-        fields.push(Field::new("f1", DataType::Int32, false));
-        field_builders.push(Box::new(int_builder) as Box<dyn ArrayBuilder>);
-        fields.push(Field::new("f2", DataType::Boolean, false));
-        field_builders.push(Box::new(bool_builder) as Box<dyn ArrayBuilder>);
-
-        let mut builder = StructBuilder::new(fields, field_builders);
-        builder
-            .field_builder::<Int32Builder>(0)
-            .unwrap()
-            .append_slice(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]);
-        builder
-            .field_builder::<BooleanBuilder>(1)
-            .unwrap()
-            .append_slice(&[
-                false, true, false, true, false, true, false, true, false, true,
-            ]);
-
-        // Append slot values - all are valid.
-        for _ in 0..10 {
-            builder.append(true);
-        }
-
-        assert_eq!(10, builder.len());
-
-        let arr = builder.finish();
-
-        assert_eq!(10, arr.len());
-        assert_eq!(0, builder.len());
-
-        builder
-            .field_builder::<Int32Builder>(0)
-            .unwrap()
-            .append_slice(&[1, 3, 5, 7, 9]);
-        builder
-            .field_builder::<BooleanBuilder>(1)
-            .unwrap()
-            .append_slice(&[false, true, false, true, false]);
-
-        // Append slot values - all are valid.
-        for _ in 0..5 {
-            builder.append(true);
-        }
-
-        assert_eq!(5, builder.len());
-
-        let arr = builder.finish();
-
-        assert_eq!(5, arr.len());
-        assert_eq!(0, builder.len());
-    }
-
-    #[test]
-    fn test_struct_array_builder_from_schema() {
-        let mut fields = vec![
-            Field::new("f1", DataType::Float32, false),
-            Field::new("f2", DataType::Utf8, false),
-        ];
-        let sub_fields = vec![
-            Field::new("g1", DataType::Int32, false),
-            Field::new("g2", DataType::Boolean, false),
-        ];
-        let struct_type = DataType::Struct(sub_fields);
-        fields.push(Field::new("f3", struct_type, false));
-
-        let mut builder = StructBuilder::from_fields(fields, 5);
-        assert_eq!(3, builder.num_fields());
-        assert!(builder.field_builder::<Float32Builder>(0).is_some());
-        assert!(builder.field_builder::<StringBuilder>(1).is_some());
-        assert!(builder.field_builder::<StructBuilder>(2).is_some());
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Data type List(Field { name: \"item\", data_type: Int64, nullable: true, dict_id: 0, dict_is_ordered: false, metadata: None }) is not currently supported"
-    )]
-    fn test_struct_array_builder_from_schema_unsupported_type() {
-        let mut fields = vec![Field::new("f1", DataType::Int16, false)];
-        let list_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int64, true)));
-        fields.push(Field::new("f2", list_type, false));
-
-        let _ = StructBuilder::from_fields(fields, 5);
-    }
-
-    #[test]
-    fn test_struct_array_builder_field_builder_type_mismatch() {
-        let int_builder = Int32Builder::new(10);
-
-        let mut fields = Vec::new();
-        let mut field_builders = Vec::new();
-        fields.push(Field::new("f1", DataType::Int32, false));
-        field_builders.push(Box::new(int_builder) as Box<dyn ArrayBuilder>);
-
-        let mut builder = StructBuilder::new(fields, field_builders);
-        assert!(builder.field_builder::<BinaryBuilder>(0).is_none());
-    }
-}
diff --git a/arrow/src/array/cast.rs b/arrow/src/array/cast.rs
deleted file mode 100644
index fd57133bc843..000000000000
--- a/arrow/src/array/cast.rs
+++ /dev/null
@@ -1,213 +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.
-
-//! Defines helper functions for force [`Array`] downcasts
-
-use crate::array::*;
-use crate::datatypes::*;
-
-/// Force downcast of an [`Array`], such as an [`ArrayRef`], to
-/// [`PrimitiveArray<T>`], panic'ing on failure.
-///
-/// # Example
-///
-/// ```
-/// # use arrow::array::*;
-/// # use arrow::datatypes::*;
-/// # use std::sync::Arc;
-/// let arr: ArrayRef = Arc::new(Int32Array::from(vec![Some(1)]));
-///
-/// // Downcast an `ArrayRef` to Int32Array / PrimiveArray<Int32>:
-/// let primitive_array: &Int32Array = as_primitive_array(&arr);
-///
-/// // Equivalently:
-/// let primitive_array = as_primitive_array::<Int32Type>(&arr);
-///
-/// // This is the equivalent of:
-/// let primitive_array = arr
-///     .as_any()
-///     .downcast_ref::<Int32Array>()
-///     .unwrap();
-/// ```
-
-pub fn as_primitive_array<T>(arr: &dyn Array) -> &PrimitiveArray<T>
-where
-    T: ArrowPrimitiveType,
-{
-    arr.as_any()
-        .downcast_ref::<PrimitiveArray<T>>()
-        .expect("Unable to downcast to primitive array")
-}
-
-/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
-/// [`DictionaryArray<T>`], panic'ing on failure.
-///
-/// # Example
-///
-/// ```
-/// # use arrow::array::*;
-/// # use arrow::datatypes::*;
-/// # use std::sync::Arc;
-/// let arr: DictionaryArray<Int32Type> = vec![Some("foo")].into_iter().collect();
-/// let arr: ArrayRef = std::sync::Arc::new(arr);
-/// let dict_array: &DictionaryArray<Int32Type> = as_dictionary_array::<Int32Type>(&arr);
-/// ```
-pub fn as_dictionary_array<T>(arr: &dyn Array) -> &DictionaryArray<T>
-where
-    T: ArrowDictionaryKeyType,
-{
-    arr.as_any()
-        .downcast_ref::<DictionaryArray<T>>()
-        .expect("Unable to downcast to dictionary array")
-}
-
-/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
-/// [`GenericListArray<T>`], panic'ing on failure.
-pub fn as_generic_list_array<S: OffsetSizeTrait>(
-    arr: &dyn Array,
-) -> &GenericListArray<S> {
-    arr.as_any()
-        .downcast_ref::<GenericListArray<S>>()
-        .expect("Unable to downcast to list array")
-}
-
-/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
-/// [`ListArray`], panic'ing on failure.
-#[inline]
-pub fn as_list_array(arr: &dyn Array) -> &ListArray {
-    as_generic_list_array::<i32>(arr)
-}
-
-/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
-/// [`LargeListArray`], panic'ing on failure.
-#[inline]
-pub fn as_large_list_array(arr: &dyn Array) -> &LargeListArray {
-    as_generic_list_array::<i64>(arr)
-}
-
-/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
-/// [`GenericBinaryArray<S>`], panic'ing on failure.
-#[inline]
-pub fn as_generic_binary_array<S: OffsetSizeTrait>(
-    arr: &dyn Array,
-) -> &GenericBinaryArray<S> {
-    arr.as_any()
-        .downcast_ref::<GenericBinaryArray<S>>()
-        .expect("Unable to downcast to binary array")
-}
-
-/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
-/// [`StringArray`], panic'ing on failure.
-///
-/// # Example
-///
-/// ```
-/// # use arrow::array::*;
-/// # use std::sync::Arc;
-/// let arr: ArrayRef = Arc::new(StringArray::from_iter(vec![Some("foo")]));
-/// let string_array = as_string_array(&arr);
-/// ```
-pub fn as_string_array(arr: &dyn Array) -> &StringArray {
-    arr.as_any()
-        .downcast_ref::<StringArray>()
-        .expect("Unable to downcast to StringArray")
-}
-
-/// Force downcast of an [`Array`], such as an [`ArrayRef`] to
-/// [`BooleanArray`], panic'ing on failure.
-///
-/// # Example
-///
-/// ```
-/// # use arrow::array::*;
-/// # use std::sync::Arc;
-/// let arr: ArrayRef = Arc::new(BooleanArray::from_iter(vec![Some(true)]));
-/// let boolean_array = as_boolean_array(&arr);
-/// ```
-pub fn as_boolean_array(arr: &dyn Array) -> &BooleanArray {
-    arr.as_any()
-        .downcast_ref::<BooleanArray>()
-        .expect("Unable to downcast to BooleanArray")
-}
-
-macro_rules! array_downcast_fn {
-    ($name: ident, $arrty: ty, $arrty_str:expr) => {
-        #[doc = "Force downcast of an [`Array`], such as an [`ArrayRef`] to "]
-        #[doc = $arrty_str]
-        pub fn $name(arr: &dyn Array) -> &$arrty {
-            arr.as_any().downcast_ref::<$arrty>().expect(concat!(
-                "Unable to downcast to typed array through ",
-                stringify!($name)
-            ))
-        }
-    };
-
-    // use recursive macro to generate dynamic doc string for a given array type
-    ($name: ident, $arrty: ty) => {
-        array_downcast_fn!(
-            $name,
-            $arrty,
-            concat!("[`", stringify!($arrty), "`], panic'ing on failure.")
-        );
-    };
-}
-
-array_downcast_fn!(as_largestring_array, LargeStringArray);
-array_downcast_fn!(as_null_array, NullArray);
-array_downcast_fn!(as_struct_array, StructArray);
-array_downcast_fn!(as_union_array, UnionArray);
-array_downcast_fn!(as_map_array, MapArray);
-array_downcast_fn!(as_decimal_array, Decimal128Array);
-
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use super::*;
-
-    #[test]
-    fn test_as_decimal_array_ref() {
-        let array: Decimal128Array = vec![Some(123), None, Some(1111)]
-            .into_iter()
-            .collect::<Decimal128Array>()
-            .with_precision_and_scale(10, 2)
-            .unwrap();
-        assert!(!as_decimal_array(&array).is_empty());
-        let result_decimal = as_decimal_array(&array);
-        assert_eq!(result_decimal, &array);
-    }
-
-    #[test]
-    fn test_as_primitive_array_ref() {
-        let array: Int32Array = vec![1, 2, 3].into_iter().map(Some).collect();
-        assert!(!as_primitive_array::<Int32Type>(&array).is_empty());
-
-        // should also work when wrapped in an Arc
-        let array: ArrayRef = Arc::new(array);
-        assert!(!as_primitive_array::<Int32Type>(&array).is_empty());
-    }
-
-    #[test]
-    fn test_as_string_array_ref() {
-        let array: StringArray = vec!["foo", "bar"].into_iter().map(Some).collect();
-        assert!(!as_string_array(&array).is_empty());
-
-        // should also work when wrapped in an Arc
-        let array: ArrayRef = Arc::new(array);
-        assert!(!as_string_array(&array).is_empty())
-    }
-}
diff --git a/arrow/src/array/data.rs b/arrow/src/array/data.rs
deleted file mode 100644
index 37581b93fde2..000000000000
--- a/arrow/src/array/data.rs
+++ /dev/null
@@ -1,2898 +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.
-
-//! Contains `ArrayData`, a generic representation of Arrow array data which encapsulates
-//! common attributes and operations for Arrow array.
-
-use crate::datatypes::{
-    validate_decimal256_precision_with_lt_bytes, validate_decimal_precision, DataType,
-    IntervalUnit, UnionMode,
-};
-use crate::error::{ArrowError, Result};
-use crate::util::bit_iterator::BitSliceIterator;
-use crate::{bitmap::Bitmap, datatypes::ArrowNativeType};
-use crate::{
-    buffer::{Buffer, MutableBuffer},
-    util::bit_util,
-};
-use half::f16;
-use std::convert::TryInto;
-use std::mem;
-use std::ops::Range;
-use std::sync::Arc;
-
-use super::equal::equal;
-
-#[inline]
-pub(crate) fn contains_nulls(
-    null_bit_buffer: Option<&Buffer>,
-    offset: usize,
-    len: usize,
-) -> bool {
-    match null_bit_buffer {
-        Some(buffer) => match BitSliceIterator::new(buffer, offset, len).next() {
-            Some((start, end)) => start != 0 || end != len,
-            None => len != 0, // No non-null values
-        },
-        None => false, // No null buffer
-    }
-}
-
-#[inline]
-pub(crate) fn count_nulls(
-    null_bit_buffer: Option<&Buffer>,
-    offset: usize,
-    len: usize,
-) -> usize {
-    if let Some(buf) = null_bit_buffer {
-        len - buf.count_set_bits_offset(offset, len)
-    } else {
-        0
-    }
-}
-
-/// creates 2 [`MutableBuffer`]s with a given `capacity` (in slots).
-#[inline]
-pub(crate) fn new_buffers(data_type: &DataType, capacity: usize) -> [MutableBuffer; 2] {
-    let empty_buffer = MutableBuffer::new(0);
-    match data_type {
-        DataType::Null => [empty_buffer, MutableBuffer::new(0)],
-        DataType::Boolean => {
-            let bytes = bit_util::ceil(capacity, 8);
-            let buffer = MutableBuffer::new(bytes);
-            [buffer, empty_buffer]
-        }
-        DataType::UInt8 => [
-            MutableBuffer::new(capacity * mem::size_of::<u8>()),
-            empty_buffer,
-        ],
-        DataType::UInt16 => [
-            MutableBuffer::new(capacity * mem::size_of::<u16>()),
-            empty_buffer,
-        ],
-        DataType::UInt32 => [
-            MutableBuffer::new(capacity * mem::size_of::<u32>()),
-            empty_buffer,
-        ],
-        DataType::UInt64 => [
-            MutableBuffer::new(capacity * mem::size_of::<u64>()),
-            empty_buffer,
-        ],
-        DataType::Int8 => [
-            MutableBuffer::new(capacity * mem::size_of::<i8>()),
-            empty_buffer,
-        ],
-        DataType::Int16 => [
-            MutableBuffer::new(capacity * mem::size_of::<i16>()),
-            empty_buffer,
-        ],
-        DataType::Int32 => [
-            MutableBuffer::new(capacity * mem::size_of::<i32>()),
-            empty_buffer,
-        ],
-        DataType::Int64 => [
-            MutableBuffer::new(capacity * mem::size_of::<i64>()),
-            empty_buffer,
-        ],
-        DataType::Float16 => [
-            MutableBuffer::new(capacity * mem::size_of::<f16>()),
-            empty_buffer,
-        ],
-        DataType::Float32 => [
-            MutableBuffer::new(capacity * mem::size_of::<f32>()),
-            empty_buffer,
-        ],
-        DataType::Float64 => [
-            MutableBuffer::new(capacity * mem::size_of::<f64>()),
-            empty_buffer,
-        ],
-        DataType::Date32 | DataType::Time32(_) => [
-            MutableBuffer::new(capacity * mem::size_of::<i32>()),
-            empty_buffer,
-        ],
-        DataType::Date64
-        | DataType::Time64(_)
-        | DataType::Duration(_)
-        | DataType::Timestamp(_, _) => [
-            MutableBuffer::new(capacity * mem::size_of::<i64>()),
-            empty_buffer,
-        ],
-        DataType::Interval(IntervalUnit::YearMonth) => [
-            MutableBuffer::new(capacity * mem::size_of::<i32>()),
-            empty_buffer,
-        ],
-        DataType::Interval(IntervalUnit::DayTime) => [
-            MutableBuffer::new(capacity * mem::size_of::<i64>()),
-            empty_buffer,
-        ],
-        DataType::Interval(IntervalUnit::MonthDayNano) => [
-            MutableBuffer::new(capacity * mem::size_of::<i128>()),
-            empty_buffer,
-        ],
-        DataType::Utf8 | DataType::Binary => {
-            let mut buffer = MutableBuffer::new((1 + capacity) * mem::size_of::<i32>());
-            // safety: `unsafe` code assumes that this buffer is initialized with one element
-            buffer.push(0i32);
-            [buffer, MutableBuffer::new(capacity * mem::size_of::<u8>())]
-        }
-        DataType::LargeUtf8 | DataType::LargeBinary => {
-            let mut buffer = MutableBuffer::new((1 + capacity) * mem::size_of::<i64>());
-            // safety: `unsafe` code assumes that this buffer is initialized with one element
-            buffer.push(0i64);
-            [buffer, MutableBuffer::new(capacity * mem::size_of::<u8>())]
-        }
-        DataType::List(_) | DataType::Map(_, _) => {
-            // offset buffer always starts with a zero
-            let mut buffer = MutableBuffer::new((1 + capacity) * mem::size_of::<i32>());
-            buffer.push(0i32);
-            [buffer, empty_buffer]
-        }
-        DataType::LargeList(_) => {
-            // offset buffer always starts with a zero
-            let mut buffer = MutableBuffer::new((1 + capacity) * mem::size_of::<i64>());
-            buffer.push(0i64);
-            [buffer, empty_buffer]
-        }
-        DataType::FixedSizeBinary(size) => {
-            [MutableBuffer::new(capacity * *size as usize), empty_buffer]
-        }
-        DataType::Dictionary(child_data_type, _) => match child_data_type.as_ref() {
-            DataType::UInt8 => [
-                MutableBuffer::new(capacity * mem::size_of::<u8>()),
-                empty_buffer,
-            ],
-            DataType::UInt16 => [
-                MutableBuffer::new(capacity * mem::size_of::<u16>()),
-                empty_buffer,
-            ],
-            DataType::UInt32 => [
-                MutableBuffer::new(capacity * mem::size_of::<u32>()),
-                empty_buffer,
-            ],
-            DataType::UInt64 => [
-                MutableBuffer::new(capacity * mem::size_of::<u64>()),
-                empty_buffer,
-            ],
-            DataType::Int8 => [
-                MutableBuffer::new(capacity * mem::size_of::<i8>()),
-                empty_buffer,
-            ],
-            DataType::Int16 => [
-                MutableBuffer::new(capacity * mem::size_of::<i16>()),
-                empty_buffer,
-            ],
-            DataType::Int32 => [
-                MutableBuffer::new(capacity * mem::size_of::<i32>()),
-                empty_buffer,
-            ],
-            DataType::Int64 => [
-                MutableBuffer::new(capacity * mem::size_of::<i64>()),
-                empty_buffer,
-            ],
-            _ => unreachable!(),
-        },
-        DataType::FixedSizeList(_, _) | DataType::Struct(_) => {
-            [empty_buffer, MutableBuffer::new(0)]
-        }
-        DataType::Decimal128(_, _) | DataType::Decimal256(_, _) => [
-            MutableBuffer::new(capacity * mem::size_of::<u8>()),
-            empty_buffer,
-        ],
-        DataType::Union(_, _, mode) => {
-            let type_ids = MutableBuffer::new(capacity * mem::size_of::<i8>());
-            match mode {
-                UnionMode::Sparse => [type_ids, empty_buffer],
-                UnionMode::Dense => {
-                    let offsets = MutableBuffer::new(capacity * mem::size_of::<i32>());
-                    [type_ids, offsets]
-                }
-            }
-        }
-    }
-}
-
-/// Maps 2 [`MutableBuffer`]s into a vector of [Buffer]s whose size depends on `data_type`.
-#[inline]
-pub(crate) fn into_buffers(
-    data_type: &DataType,
-    buffer1: MutableBuffer,
-    buffer2: MutableBuffer,
-) -> Vec<Buffer> {
-    match data_type {
-        DataType::Null | DataType::Struct(_) | DataType::FixedSizeList(_, _) => vec![],
-        DataType::Utf8
-        | DataType::Binary
-        | DataType::LargeUtf8
-        | DataType::LargeBinary => vec![buffer1.into(), buffer2.into()],
-        DataType::Union(_, _, mode) => {
-            match mode {
-                // Based on Union's DataTypeLayout
-                UnionMode::Sparse => vec![buffer1.into()],
-                UnionMode::Dense => vec![buffer1.into(), buffer2.into()],
-            }
-        }
-        _ => vec![buffer1.into()],
-    }
-}
-
-/// An generic representation of Arrow array data which encapsulates common attributes and
-/// operations for Arrow array. Specific operations for different arrays types (e.g.,
-/// primitive, list, struct) are implemented in `Array`.
-#[derive(Debug, Clone)]
-pub struct ArrayData {
-    /// The data type for this array data
-    data_type: DataType,
-
-    /// The number of elements in this array data
-    len: usize,
-
-    /// The number of null elements in this array data
-    null_count: usize,
-
-    /// The offset into this array data, in number of items
-    offset: usize,
-
-    /// The buffers for this array data. Note that depending on the array types, this
-    /// could hold different kinds of buffers (e.g., value buffer, value offset buffer)
-    /// at different positions.
-    buffers: Vec<Buffer>,
-
-    /// The child(ren) of this array. Only non-empty for nested types, currently
-    /// `ListArray` and `StructArray`.
-    child_data: Vec<ArrayData>,
-
-    /// The null bitmap. A `None` value for this indicates all values are non-null in
-    /// this array.
-    null_bitmap: Option<Bitmap>,
-}
-
-pub type ArrayDataRef = Arc<ArrayData>;
-
-impl ArrayData {
-    /// Create a new ArrayData instance;
-    ///
-    /// If `null_count` is not specified, the number of nulls in
-    /// null_bit_buffer is calculated.
-    ///
-    /// If the number of nulls is 0 then the null_bit_buffer
-    /// is set to `None`.
-    ///
-    /// # Safety
-    ///
-    /// The input values *must* form a valid Arrow array for
-    /// `data_type`, or undefined behavior can results.
-    ///
-    /// Note: This is a low level API and most users of the arrow
-    /// crate should create arrays using the methods in the `array`
-    /// module.
-    #[allow(clippy::let_and_return)]
-    pub unsafe fn new_unchecked(
-        data_type: DataType,
-        len: usize,
-        null_count: Option<usize>,
-        null_bit_buffer: Option<Buffer>,
-        offset: usize,
-        buffers: Vec<Buffer>,
-        child_data: Vec<ArrayData>,
-    ) -> Self {
-        let null_count = match null_count {
-            None => count_nulls(null_bit_buffer.as_ref(), offset, len),
-            Some(null_count) => null_count,
-        };
-        let null_bitmap = null_bit_buffer.filter(|_| null_count > 0).map(Bitmap::from);
-        let new_self = Self {
-            data_type,
-            len,
-            null_count,
-            offset,
-            buffers,
-            child_data,
-            null_bitmap,
-        };
-
-        // Provide a force_validate mode
-        #[cfg(feature = "force_validate")]
-        new_self.validate_full().unwrap();
-        new_self
-    }
-
-    /// Create a new ArrayData, validating that the provided buffers
-    /// form a valid Arrow array of the specified data type.
-    ///
-    /// If the number of nulls in `null_bit_buffer` is 0 then the null_bit_buffer
-    /// is set to `None`.
-    ///
-    /// Note: This is a low level API and most users of the arrow
-    /// crate should create arrays using the methods in the `array`
-    /// module.
-    pub fn try_new(
-        data_type: DataType,
-        len: usize,
-        null_bit_buffer: Option<Buffer>,
-        offset: usize,
-        buffers: Vec<Buffer>,
-        child_data: Vec<ArrayData>,
-    ) -> Result<Self> {
-        // we must check the length of `null_bit_buffer` first
-        // because we use this buffer to calculate `null_count`
-        // in `Self::new_unchecked`.
-        if let Some(null_bit_buffer) = null_bit_buffer.as_ref() {
-            let needed_len = bit_util::ceil(len + offset, 8);
-            if null_bit_buffer.len() < needed_len {
-                return Err(ArrowError::InvalidArgumentError(format!(
-                    "null_bit_buffer size too small. got {} needed {}",
-                    null_bit_buffer.len(),
-                    needed_len
-                )));
-            }
-        }
-        // Safety justification: `validate_full` is called below
-        let new_self = unsafe {
-            Self::new_unchecked(
-                data_type,
-                len,
-                None,
-                null_bit_buffer,
-                offset,
-                buffers,
-                child_data,
-            )
-        };
-
-        // As the data is not trusted, do a full validation of its contents
-        new_self.validate_full()?;
-        Ok(new_self)
-    }
-
-    /// Returns a builder to construct a `ArrayData` instance.
-    #[inline]
-    pub const fn builder(data_type: DataType) -> ArrayDataBuilder {
-        ArrayDataBuilder::new(data_type)
-    }
-
-    /// Returns a reference to the data type of this array data
-    #[inline]
-    pub const fn data_type(&self) -> &DataType {
-        &self.data_type
-    }
-
-    /// Updates the [DataType] of this ArrayData/
-    ///
-    /// panic's if the new DataType is not compatible with the
-    /// existing type.
-    ///
-    /// Note: currently only changing a [DataType::Decimal128]s or
-    /// [DataType::Decimal256]s precision and scale are supported
-    #[inline]
-    pub(crate) fn with_data_type(mut self, new_data_type: DataType) -> Self {
-        if matches!(self.data_type, DataType::Decimal128(_, _)) {
-            assert!(
-                matches!(new_data_type, DataType::Decimal128(_, _)),
-                "only 128-bit DecimalType is supported for new datatype"
-            );
-        } else if matches!(self.data_type, DataType::Decimal256(_, _)) {
-            assert!(
-                matches!(new_data_type, DataType::Decimal256(_, _)),
-                "only 256-bit DecimalType is supported for new datatype"
-            );
-        } else {
-            panic!("only DecimalType is supported.")
-        }
-
-        self.data_type = new_data_type;
-        self
-    }
-
-    /// Returns a slice of buffers for this array data
-    pub fn buffers(&self) -> &[Buffer] {
-        &self.buffers[..]
-    }
-
-    /// Returns a slice of children data arrays
-    pub fn child_data(&self) -> &[ArrayData] {
-        &self.child_data[..]
-    }
-
-    /// Returns whether the element at index `i` is null
-    pub fn is_null(&self, i: usize) -> bool {
-        if let Some(ref b) = self.null_bitmap {
-            return !b.is_set(self.offset + i);
-        }
-        false
-    }
-
-    /// Returns a reference to the null bitmap of this array data
-    #[inline]
-    pub const fn null_bitmap(&self) -> Option<&Bitmap> {
-        self.null_bitmap.as_ref()
-    }
-
-    /// Returns a reference to the null buffer of this array data.
-    pub fn null_buffer(&self) -> Option<&Buffer> {
-        self.null_bitmap().as_ref().map(|b| b.buffer_ref())
-    }
-
-    /// Returns whether the element at index `i` is not null
-    pub fn is_valid(&self, i: usize) -> bool {
-        if let Some(ref b) = self.null_bitmap {
-            return b.is_set(self.offset + i);
-        }
-        true
-    }
-
-    /// Returns the length (i.e., number of elements) of this array
-    #[inline]
-    pub const fn len(&self) -> usize {
-        self.len
-    }
-
-    // Returns whether array data is empty
-    #[inline]
-    pub const fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    /// Returns the offset of this array
-    #[inline]
-    pub const fn offset(&self) -> usize {
-        self.offset
-    }
-
-    /// Returns the total number of nulls in this array
-    #[inline]
-    pub const fn null_count(&self) -> usize {
-        self.null_count
-    }
-
-    /// Returns the total number of bytes of memory occupied by the buffers owned by this [ArrayData].
-    pub fn get_buffer_memory_size(&self) -> usize {
-        let mut size = 0;
-        for buffer in &self.buffers {
-            size += buffer.capacity();
-        }
-        if let Some(bitmap) = &self.null_bitmap {
-            size += bitmap.get_buffer_memory_size()
-        }
-        for child in &self.child_data {
-            size += child.get_buffer_memory_size();
-        }
-        size
-    }
-
-    /// Returns the total number of bytes of memory occupied physically by this [ArrayData].
-    pub fn get_array_memory_size(&self) -> usize {
-        let mut size = mem::size_of_val(self);
-
-        // Calculate rest of the fields top down which contain actual data
-        for buffer in &self.buffers {
-            size += mem::size_of::<Buffer>();
-            size += buffer.capacity();
-        }
-        if let Some(bitmap) = &self.null_bitmap {
-            // this includes the size of the bitmap struct itself, since it is stored directly in
-            // this struct we already counted those bytes in the size_of_val(self) above
-            size += bitmap.get_array_memory_size();
-            size -= mem::size_of::<Bitmap>();
-        }
-        for child in &self.child_data {
-            size += child.get_array_memory_size();
-        }
-
-        size
-    }
-
-    /// Creates a zero-copy slice of itself. This creates a new [ArrayData]
-    /// with a different offset, len and a shifted null bitmap.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `offset + length > self.len()`.
-    pub fn slice(&self, offset: usize, length: usize) -> ArrayData {
-        assert!((offset + length) <= self.len());
-
-        if let DataType::Struct(_) = self.data_type() {
-            // Slice into children
-            let new_offset = self.offset + offset;
-            let new_data = ArrayData {
-                data_type: self.data_type().clone(),
-                len: length,
-                null_count: count_nulls(self.null_buffer(), new_offset, length),
-                offset: new_offset,
-                buffers: self.buffers.clone(),
-                // Slice child data, to propagate offsets down to them
-                child_data: self
-                    .child_data()
-                    .iter()
-                    .map(|data| data.slice(offset, length))
-                    .collect(),
-                null_bitmap: self.null_bitmap().cloned(),
-            };
-
-            new_data
-        } else {
-            let mut new_data = self.clone();
-
-            new_data.len = length;
-            new_data.offset = offset + self.offset;
-
-            new_data.null_count =
-                count_nulls(new_data.null_buffer(), new_data.offset, new_data.len);
-
-            new_data
-        }
-    }
-
-    /// Returns the `buffer` as a slice of type `T` starting at self.offset
-    /// # Panics
-    /// This function panics if:
-    /// * the buffer is not byte-aligned with type T, or
-    /// * the datatype is `Boolean` (it corresponds to a bit-packed buffer where the offset is not applicable)
-    #[inline]
-    pub(crate) fn buffer<T: ArrowNativeType>(&self, buffer: usize) -> &[T] {
-        let values = unsafe { self.buffers[buffer].as_slice().align_to::<T>() };
-        if !values.0.is_empty() || !values.2.is_empty() {
-            panic!("The buffer is not byte-aligned with its interpretation")
-        };
-        assert_ne!(self.data_type, DataType::Boolean);
-        &values.1[self.offset..]
-    }
-
-    /// Returns a new empty [ArrayData] valid for `data_type`.
-    pub fn new_empty(data_type: &DataType) -> Self {
-        let buffers = new_buffers(data_type, 0);
-        let [buffer1, buffer2] = buffers;
-        let buffers = into_buffers(data_type, buffer1, buffer2);
-
-        let child_data = match data_type {
-            DataType::Null
-            | DataType::Boolean
-            | DataType::UInt8
-            | DataType::UInt16
-            | DataType::UInt32
-            | DataType::UInt64
-            | DataType::Int8
-            | DataType::Int16
-            | DataType::Int32
-            | DataType::Int64
-            | DataType::Float16
-            | DataType::Float32
-            | DataType::Float64
-            | DataType::Date32
-            | DataType::Date64
-            | DataType::Time32(_)
-            | DataType::Time64(_)
-            | DataType::Duration(_)
-            | DataType::Timestamp(_, _)
-            | DataType::Utf8
-            | DataType::Binary
-            | DataType::LargeUtf8
-            | DataType::LargeBinary
-            | DataType::Interval(_)
-            | DataType::FixedSizeBinary(_)
-            | DataType::Decimal128(_, _)
-            | DataType::Decimal256(_, _) => vec![],
-            DataType::List(field) => {
-                vec![Self::new_empty(field.data_type())]
-            }
-            DataType::FixedSizeList(field, _) => {
-                vec![Self::new_empty(field.data_type())]
-            }
-            DataType::LargeList(field) => {
-                vec![Self::new_empty(field.data_type())]
-            }
-            DataType::Struct(fields) => fields
-                .iter()
-                .map(|field| Self::new_empty(field.data_type()))
-                .collect(),
-            DataType::Map(field, _) => {
-                vec![Self::new_empty(field.data_type())]
-            }
-            DataType::Union(fields, _, _) => fields
-                .iter()
-                .map(|field| Self::new_empty(field.data_type()))
-                .collect(),
-            DataType::Dictionary(_, data_type) => {
-                vec![Self::new_empty(data_type)]
-            }
-        };
-
-        // Data was constructed correctly above
-        unsafe {
-            Self::new_unchecked(
-                data_type.clone(),
-                0,
-                Some(0),
-                None,
-                0,
-                buffers,
-                child_data,
-            )
-        }
-    }
-
-    /// "cheap" validation of an `ArrayData`. Ensures buffers are
-    /// sufficiently sized to store `len` + `offset` total elements of
-    /// `data_type` and performs other inexpensive consistency checks.
-    ///
-    /// This check is "cheap" in the sense that it does not validate the
-    /// contents of the buffers (e.g. that all offsets for UTF8 arrays
-    /// are within the bounds of the values buffer).
-    ///
-    /// See [ArrayData::validate_full] to validate fully the offset content
-    /// and the validitiy of utf8 data
-    pub fn validate(&self) -> Result<()> {
-        // Need at least this mich space in each buffer
-        let len_plus_offset = self.len + self.offset;
-
-        // Check that the data layout conforms to the spec
-        let layout = layout(&self.data_type);
-
-        if !layout.can_contain_null_mask && self.null_bitmap.is_some() {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "Arrays of type {:?} cannot contain a null bitmask",
-                self.data_type,
-            )));
-        }
-
-        if self.buffers.len() != layout.buffers.len() {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "Expected {} buffers in array of type {:?}, got {}",
-                layout.buffers.len(),
-                self.data_type,
-                self.buffers.len(),
-            )));
-        }
-
-        for (i, (buffer, spec)) in
-            self.buffers.iter().zip(layout.buffers.iter()).enumerate()
-        {
-            match spec {
-                BufferSpec::FixedWidth { byte_width } => {
-                    let min_buffer_size = len_plus_offset
-                        .checked_mul(*byte_width)
-                        .expect("integer overflow computing min buffer size");
-
-                    if buffer.len() < min_buffer_size {
-                        return Err(ArrowError::InvalidArgumentError(format!(
-                            "Need at least {} bytes in buffers[{}] in array of type {:?}, but got {}",
-                            min_buffer_size, i, self.data_type, buffer.len()
-                        )));
-                    }
-                }
-                BufferSpec::VariableWidth => {
-                    // not cheap to validate (need to look at the
-                    // data). Partially checked in validate_offsets
-                    // called below. Can check with `validate_full`
-                }
-                BufferSpec::BitMap => {
-                    let min_buffer_size = bit_util::ceil(len_plus_offset, 8);
-                    if buffer.len() < min_buffer_size {
-                        return Err(ArrowError::InvalidArgumentError(format!(
-                            "Need at least {} bytes for bitmap in buffers[{}] in array of type {:?}, but got {}",
-                            min_buffer_size, i, self.data_type, buffer.len()
-                        )));
-                    }
-                }
-                BufferSpec::AlwaysNull => {
-                    // Nothing to validate
-                }
-            }
-        }
-
-        if self.null_count > self.len {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "null_count {} for an array exceeds length of {} elements",
-                self.null_count, self.len
-            )));
-        }
-
-        // check null bit buffer size
-        if let Some(null_bit_map) = self.null_bitmap.as_ref() {
-            let null_bit_buffer = null_bit_map.buffer_ref();
-            let needed_len = bit_util::ceil(len_plus_offset, 8);
-            if null_bit_buffer.len() < needed_len {
-                return Err(ArrowError::InvalidArgumentError(format!(
-                    "null_bit_buffer size too small. got {} needed {}",
-                    null_bit_buffer.len(),
-                    needed_len
-                )));
-            }
-        } else if self.null_count > 0 {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "Array of type {} has {} nulls but no null bitmap",
-                self.data_type, self.null_count
-            )));
-        }
-
-        self.validate_child_data()?;
-
-        // Additional Type specific checks
-        match &self.data_type {
-            DataType::Utf8 | DataType::Binary => {
-                self.validate_offsets::<i32>(self.buffers[1].len())?;
-            }
-            DataType::LargeUtf8 | DataType::LargeBinary => {
-                self.validate_offsets::<i64>(self.buffers[1].len())?;
-            }
-            DataType::Dictionary(key_type, _value_type) => {
-                // At the moment, constructing a DictionaryArray will also check this
-                if !DataType::is_dictionary_key_type(key_type) {
-                    return Err(ArrowError::InvalidArgumentError(format!(
-                        "Dictionary key type must be integer, but was {}",
-                        key_type
-                    )));
-                }
-            }
-            _ => {}
-        };
-
-        Ok(())
-    }
-
-    /// Returns a reference to the data in `buffer` as a typed slice
-    /// (typically `&[i32]` or `&[i64]`) after validating. The
-    /// returned slice is guaranteed to have at least `self.len + 1`
-    /// entries.
-    ///
-    /// For an empty array, the `buffer` can also be empty.
-    fn typed_offsets<T: ArrowNativeType + num::Num>(&self) -> Result<&[T]> {
-        // An empty list-like array can have 0 offsets
-        if self.len == 0 && self.buffers[0].is_empty() {
-            return Ok(&[]);
-        }
-
-        self.typed_buffer(0, self.len + 1)
-    }
-
-    /// Returns a reference to the data in `buffers[idx]` as a typed slice after validating
-    fn typed_buffer<T: ArrowNativeType + num::Num>(
-        &self,
-        idx: usize,
-        len: usize,
-    ) -> Result<&[T]> {
-        let buffer = &self.buffers[idx];
-
-        let required_len = (len + self.offset) * std::mem::size_of::<T>();
-
-        if buffer.len() < required_len {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "Buffer {} of {} isn't large enough. Expected {} bytes got {}",
-                idx,
-                self.data_type,
-                required_len,
-                buffer.len()
-            )));
-        }
-
-        Ok(&buffer.typed_data::<T>()[self.offset..self.offset + len])
-    }
-
-    /// Does a cheap sanity check that the `self.len` values in `buffer` are valid
-    /// offsets (of type T) into some other buffer of `values_length` bytes long
-    fn validate_offsets<T: ArrowNativeType + num::Num + std::fmt::Display>(
-        &self,
-        values_length: usize,
-    ) -> Result<()> {
-        // Justification: buffer size was validated above
-        let offsets = self.typed_offsets::<T>()?;
-        if offsets.is_empty() {
-            return Ok(());
-        }
-
-        let first_offset = offsets[0].to_usize().ok_or_else(|| {
-            ArrowError::InvalidArgumentError(format!(
-                "Error converting offset[0] ({}) to usize for {}",
-                offsets[0], self.data_type
-            ))
-        })?;
-
-        let last_offset = offsets[self.len].to_usize().ok_or_else(|| {
-            ArrowError::InvalidArgumentError(format!(
-                "Error converting offset[{}] ({}) to usize for {}",
-                self.len, offsets[self.len], self.data_type
-            ))
-        })?;
-
-        if first_offset > values_length {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "First offset {} of {} is larger than values length {}",
-                first_offset, self.data_type, values_length,
-            )));
-        }
-
-        if last_offset > values_length {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "Last offset {} of {} is larger than values length {}",
-                last_offset, self.data_type, values_length,
-            )));
-        }
-
-        if first_offset > last_offset {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "First offset {} in {} is smaller than last offset {}",
-                first_offset, self.data_type, last_offset,
-            )));
-        }
-
-        Ok(())
-    }
-
-    /// Validates the layout of `child_data` ArrayData structures
-    fn validate_child_data(&self) -> Result<()> {
-        match &self.data_type {
-            DataType::List(field) | DataType::Map(field, _) => {
-                let values_data = self.get_single_valid_child_data(field.data_type())?;
-                self.validate_offsets::<i32>(values_data.len)?;
-                Ok(())
-            }
-            DataType::LargeList(field) => {
-                let values_data = self.get_single_valid_child_data(field.data_type())?;
-                self.validate_offsets::<i64>(values_data.len)?;
-                Ok(())
-            }
-            DataType::FixedSizeList(field, list_size) => {
-                let values_data = self.get_single_valid_child_data(field.data_type())?;
-
-                let list_size: usize = (*list_size).try_into().map_err(|_| {
-                    ArrowError::InvalidArgumentError(format!(
-                        "{} has a negative list_size {}",
-                        self.data_type, list_size
-                    ))
-                })?;
-
-                let expected_values_len = self.len
-                    .checked_mul(list_size)
-                    .expect("integer overflow computing expected number of expected values in FixedListSize");
-
-                if values_data.len < expected_values_len {
-                    return Err(ArrowError::InvalidArgumentError(format!(
-                        "Values length {} is less than the length ({}) multiplied by the value size ({}) for {}",
-                        values_data.len, list_size, list_size, self.data_type
-                    )));
-                }
-
-                Ok(())
-            }
-            DataType::Struct(fields) => {
-                self.validate_num_child_data(fields.len())?;
-                for (i, field) in fields.iter().enumerate() {
-                    let field_data = self.get_valid_child_data(i, field.data_type())?;
-
-                    // Ensure child field has sufficient size
-                    if field_data.len < self.len {
-                        return Err(ArrowError::InvalidArgumentError(format!(
-                            "{} child array #{} for field {} has length smaller than expected for struct array ({} < {})",
-                            self.data_type, i, field.name(), field_data.len, self.len
-                        )));
-                    }
-                }
-                Ok(())
-            }
-            DataType::Union(fields, _, mode) => {
-                self.validate_num_child_data(fields.len())?;
-
-                for (i, field) in fields.iter().enumerate() {
-                    let field_data = self.get_valid_child_data(i, field.data_type())?;
-
-                    if mode == &UnionMode::Sparse
-                        && field_data.len < (self.len + self.offset)
-                    {
-                        return Err(ArrowError::InvalidArgumentError(format!(
-                            "Sparse union child array #{} has length smaller than expected for union array ({} < {})",
-                            i, field_data.len, self.len + self.offset
-                        )));
-                    }
-                }
-                Ok(())
-            }
-            DataType::Dictionary(_key_type, value_type) => {
-                self.get_single_valid_child_data(value_type)?;
-                Ok(())
-            }
-            _ => {
-                // other types do not have child data
-                if !self.child_data.is_empty() {
-                    return Err(ArrowError::InvalidArgumentError(format!(
-                        "Expected no child arrays for type {} but got {}",
-                        self.data_type,
-                        self.child_data.len()
-                    )));
-                }
-                Ok(())
-            }
-        }
-    }
-
-    /// Ensures that this array data has a single child_data with the
-    /// expected type, and calls `validate()` on it. Returns a
-    /// reference to that child_data
-    fn get_single_valid_child_data(
-        &self,
-        expected_type: &DataType,
-    ) -> Result<&ArrayData> {
-        self.validate_num_child_data(1)?;
-        self.get_valid_child_data(0, expected_type)
-    }
-
-    /// Returns `Err` if self.child_data does not have exactly `expected_len` elements
-    fn validate_num_child_data(&self, expected_len: usize) -> Result<()> {
-        if self.child_data().len() != expected_len {
-            Err(ArrowError::InvalidArgumentError(format!(
-                "Value data for {} should contain {} child data array(s), had {}",
-                self.data_type(),
-                expected_len,
-                self.child_data.len()
-            )))
-        } else {
-            Ok(())
-        }
-    }
-
-    /// Ensures that `child_data[i]` has the expected type, calls
-    /// `validate()` on it, and returns a reference to that child_data
-    fn get_valid_child_data(
-        &self,
-        i: usize,
-        expected_type: &DataType,
-    ) -> Result<&ArrayData> {
-        let values_data = self.child_data
-            .get(i)
-            .ok_or_else(|| {
-                ArrowError::InvalidArgumentError(format!(
-                    "{} did not have enough child arrays. Expected at least {} but had only {}",
-                    self.data_type, i+1, self.child_data.len()
-                ))
-            })?;
-
-        if expected_type != &values_data.data_type {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "Child type mismatch for {}. Expected {} but child data had {}",
-                self.data_type, expected_type, values_data.data_type
-            )));
-        }
-
-        values_data.validate()?;
-        Ok(values_data)
-    }
-
-    /// "expensive" validation that ensures:
-    ///
-    /// 1. Null count is correct
-    /// 2. All offsets are valid
-    /// 3. All String data is valid UTF-8
-    /// 4. All dictionary offsets are valid
-    ///
-    /// Does not (yet) check
-    /// 1. Union type_ids are valid see [#85](https://github.com/apache/arrow-rs/issues/85)
-    /// Note calls `validate()` internally
-    pub fn validate_full(&self) -> Result<()> {
-        // Check all buffer sizes prior to looking at them more deeply in this function
-        self.validate()?;
-
-        let null_bitmap_buffer = self
-            .null_bitmap
-            .as_ref()
-            .map(|null_bitmap| null_bitmap.buffer_ref());
-
-        let actual_null_count = count_nulls(null_bitmap_buffer, self.offset, self.len);
-        if actual_null_count != self.null_count {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "null_count value ({}) doesn't match actual number of nulls in array ({})",
-                self.null_count, actual_null_count
-            )));
-        }
-
-        self.validate_values()?;
-
-        // validate all children recursively
-        self.child_data
-            .iter()
-            .enumerate()
-            .try_for_each(|(i, child_data)| {
-                child_data.validate_full().map_err(|e| {
-                    ArrowError::InvalidArgumentError(format!(
-                        "{} child #{} invalid: {}",
-                        self.data_type, i, e
-                    ))
-                })
-            })?;
-
-        Ok(())
-    }
-
-    pub fn validate_values(&self) -> Result<()> {
-        match &self.data_type {
-            DataType::Decimal128(p, _) => {
-                let values_buffer: &[i128] = self.typed_buffer(0, self.len)?;
-                for value in values_buffer {
-                    validate_decimal_precision(*value, *p)?;
-                }
-                Ok(())
-            }
-            DataType::Decimal256(p, _) => {
-                let values = self.buffers()[0].as_slice();
-                for pos in 0..self.len() {
-                    let offset = pos * 32;
-                    let raw_bytes = &values[offset..offset + 32];
-                    validate_decimal256_precision_with_lt_bytes(raw_bytes, *p)?;
-                }
-                Ok(())
-            }
-            DataType::Utf8 => self.validate_utf8::<i32>(),
-            DataType::LargeUtf8 => self.validate_utf8::<i64>(),
-            DataType::Binary => self.validate_offsets_full::<i32>(self.buffers[1].len()),
-            DataType::LargeBinary => {
-                self.validate_offsets_full::<i64>(self.buffers[1].len())
-            }
-            DataType::List(_) | DataType::Map(_, _) => {
-                let child = &self.child_data[0];
-                self.validate_offsets_full::<i32>(child.len)
-            }
-            DataType::LargeList(_) => {
-                let child = &self.child_data[0];
-                self.validate_offsets_full::<i64>(child.len)
-            }
-            DataType::Union(_, _, _) => {
-                // Validate Union Array as part of implementing new Union semantics
-                // See comments in `ArrayData::validate()`
-                // https://github.com/apache/arrow-rs/issues/85
-                //
-                // TODO file follow on ticket for full union validation
-                Ok(())
-            }
-            DataType::Dictionary(key_type, _value_type) => {
-                let dictionary_length: i64 = self.child_data[0].len.try_into().unwrap();
-                let max_value = dictionary_length - 1;
-                match key_type.as_ref() {
-                    DataType::UInt8 => self.check_bounds::<u8>(max_value),
-                    DataType::UInt16 => self.check_bounds::<u16>(max_value),
-                    DataType::UInt32 => self.check_bounds::<u32>(max_value),
-                    DataType::UInt64 => self.check_bounds::<u64>(max_value),
-                    DataType::Int8 => self.check_bounds::<i8>(max_value),
-                    DataType::Int16 => self.check_bounds::<i16>(max_value),
-                    DataType::Int32 => self.check_bounds::<i32>(max_value),
-                    DataType::Int64 => self.check_bounds::<i64>(max_value),
-                    _ => unreachable!(),
-                }
-            }
-            _ => {
-                // No extra validation check required for other types
-                Ok(())
-            }
-        }
-    }
-
-    /// Calls the `validate(item_index, range)` function for each of
-    /// the ranges specified in the arrow offsets buffer of type
-    /// `T`. Also validates that each offset is smaller than
-    /// `offset_limit`
-    ///
-    /// For an empty array, the offsets buffer can either be empty
-    /// or contain a single `0`.
-    ///
-    /// For example, the offsets buffer contained `[1, 2, 4]`, this
-    /// function would call `validate([1,2])`, and `validate([2,4])`
-    fn validate_each_offset<T, V>(&self, offset_limit: usize, validate: V) -> Result<()>
-    where
-        T: ArrowNativeType + TryInto<usize> + num::Num + std::fmt::Display,
-        V: Fn(usize, Range<usize>) -> Result<()>,
-    {
-        self.typed_offsets::<T>()?
-            .iter()
-            .enumerate()
-            .map(|(i, x)| {
-                // check if the offset can be converted to usize
-                let r = x.to_usize().ok_or_else(|| {
-                    ArrowError::InvalidArgumentError(format!(
-                        "Offset invariant failure: Could not convert offset {} to usize at position {}",
-                        x, i))}
-                    );
-                // check if the offset exceeds the limit
-                match r {
-                    Ok(n) if n <= offset_limit => Ok((i, n)),
-                    Ok(_) => Err(ArrowError::InvalidArgumentError(format!(
-                        "Offset invariant failure: offset at position {} out of bounds: {} > {}",
-                        i, x, offset_limit))
-                    ),
-                    Err(e) => Err(e),
-                }
-            })
-            .scan(0_usize, |start, end| {
-                // check offsets are monotonically increasing
-                match end {
-                    Ok((i, end)) if *start <= end => {
-                        let range = Some(Ok((i, *start..end)));
-                        *start = end;
-                        range
-                    }
-                    Ok((i, end)) => Some(Err(ArrowError::InvalidArgumentError(format!(
-                        "Offset invariant failure: non-monotonic offset at slot {}: {} > {}",
-                        i - 1, start, end))
-                    )),
-                    Err(err) => Some(Err(err)),
-                }
-            })
-            .skip(1) // the first element is meaningless
-            .try_for_each(|res: Result<(usize, Range<usize>)>| {
-                let (item_index, range) = res?;
-                validate(item_index-1, range)
-            })
-    }
-
-    /// Ensures that all strings formed by the offsets in `buffers[0]`
-    /// into `buffers[1]` are valid utf8 sequences
-    fn validate_utf8<T>(&self) -> Result<()>
-    where
-        T: ArrowNativeType + TryInto<usize> + num::Num + std::fmt::Display,
-    {
-        let values_buffer = &self.buffers[1].as_slice();
-        if let Ok(values_str) = std::str::from_utf8(values_buffer) {
-            // Validate Offsets are correct
-            self.validate_each_offset::<T, _>(
-                values_buffer.len(),
-                |string_index, range| {
-                    if !values_str.is_char_boundary(range.start)
-                        || !values_str.is_char_boundary(range.end)
-                    {
-                        return Err(ArrowError::InvalidArgumentError(format!(
-                            "incomplete utf-8 byte sequence from index {}",
-                            string_index
-                        )));
-                    }
-                    Ok(())
-                },
-            )
-        } else {
-            // find specific offset that failed utf8 validation
-            self.validate_each_offset::<T, _>(
-                values_buffer.len(),
-                |string_index, range| {
-                    std::str::from_utf8(&values_buffer[range.clone()]).map_err(|e| {
-                        ArrowError::InvalidArgumentError(format!(
-                            "Invalid UTF8 sequence at string index {} ({:?}): {}",
-                            string_index, range, e
-                        ))
-                    })?;
-                    Ok(())
-                },
-            )
-        }
-    }
-
-    /// Ensures that all offsets in `buffers[0]` into `buffers[1]` are
-    /// between `0` and `offset_limit`
-    fn validate_offsets_full<T>(&self, offset_limit: usize) -> Result<()>
-    where
-        T: ArrowNativeType + TryInto<usize> + num::Num + std::fmt::Display,
-    {
-        self.validate_each_offset::<T, _>(offset_limit, |_string_index, _range| {
-            // No validation applied to each value, but the iteration
-            // itself applies bounds checking to each range
-            Ok(())
-        })
-    }
-
-    /// Validates that each value in self.buffers (typed as T)
-    /// is within the range [0, max_value], inclusive
-    fn check_bounds<T>(&self, max_value: i64) -> Result<()>
-    where
-        T: ArrowNativeType + TryInto<i64> + num::Num + std::fmt::Display,
-    {
-        let required_len = self.len + self.offset;
-        let buffer = &self.buffers[0];
-
-        // This should have been checked as part of `validate()` prior
-        // to calling `validate_full()` but double check to be sure
-        assert!(buffer.len() / std::mem::size_of::<T>() >= required_len);
-
-        // Justification: buffer size was validated above
-        let indexes: &[T] =
-            &buffer.typed_data::<T>()[self.offset..self.offset + self.len];
-
-        indexes.iter().enumerate().try_for_each(|(i, &dict_index)| {
-            // Do not check the value is null (value can be arbitrary)
-            if self.is_null(i) {
-                return Ok(());
-            }
-            let dict_index: i64 = dict_index.try_into().map_err(|_| {
-                ArrowError::InvalidArgumentError(format!(
-                    "Value at position {} out of bounds: {} (can not convert to i64)",
-                    i, dict_index
-                ))
-            })?;
-
-            if dict_index < 0 || dict_index > max_value {
-                return Err(ArrowError::InvalidArgumentError(format!(
-                    "Value at position {} out of bounds: {} (should be in [0, {}])",
-                    i, dict_index, max_value
-                )));
-            }
-            Ok(())
-        })
-    }
-
-    /// Returns true if this `ArrayData` is equal to `other`, using pointer comparisons
-    /// to determine buffer equality. This is cheaper than `PartialEq::eq` but may
-    /// return false when the arrays are logically equal
-    pub fn ptr_eq(&self, other: &Self) -> bool {
-        if self.offset != other.offset
-            || self.len != other.len
-            || self.null_count != other.null_count
-            || self.data_type != other.data_type
-            || self.buffers.len() != other.buffers.len()
-            || self.child_data.len() != other.child_data.len()
-        {
-            return false;
-        }
-
-        match (&self.null_bitmap, &other.null_bitmap) {
-            (Some(a), Some(b)) if a.bits.as_ptr() != b.bits.as_ptr() => return false,
-            (Some(_), None) | (None, Some(_)) => return false,
-            _ => {}
-        };
-
-        if !self
-            .buffers
-            .iter()
-            .zip(other.buffers.iter())
-            .all(|(a, b)| a.as_ptr() == b.as_ptr())
-        {
-            return false;
-        }
-
-        self.child_data
-            .iter()
-            .zip(other.child_data.iter())
-            .all(|(a, b)| a.ptr_eq(b))
-    }
-
-    /// Converts this [`ArrayData`] into an [`ArrayDataBuilder`]
-    pub fn into_builder(self) -> ArrayDataBuilder {
-        self.into()
-    }
-}
-
-/// Return the expected [`DataTypeLayout`] Arrays of this data
-/// type are expected to have
-pub(crate) fn layout(data_type: &DataType) -> DataTypeLayout {
-    // based on C/C++ implementation in
-    // https://github.com/apache/arrow/blob/661c7d749150905a63dd3b52e0a04dac39030d95/cpp/src/arrow/type.h (and .cc)
-    use std::mem::size_of;
-    match data_type {
-        DataType::Null => DataTypeLayout {
-            buffers: vec![],
-            can_contain_null_mask: false,
-        },
-        DataType::Boolean => DataTypeLayout {
-            buffers: vec![BufferSpec::BitMap],
-            can_contain_null_mask: true,
-        },
-        DataType::Int8 => DataTypeLayout::new_fixed_width(size_of::<i8>()),
-        DataType::Int16 => DataTypeLayout::new_fixed_width(size_of::<i16>()),
-        DataType::Int32 => DataTypeLayout::new_fixed_width(size_of::<i32>()),
-        DataType::Int64 => DataTypeLayout::new_fixed_width(size_of::<i64>()),
-        DataType::UInt8 => DataTypeLayout::new_fixed_width(size_of::<u8>()),
-        DataType::UInt16 => DataTypeLayout::new_fixed_width(size_of::<u16>()),
-        DataType::UInt32 => DataTypeLayout::new_fixed_width(size_of::<u32>()),
-        DataType::UInt64 => DataTypeLayout::new_fixed_width(size_of::<u64>()),
-        DataType::Float16 => DataTypeLayout::new_fixed_width(size_of::<f16>()),
-        DataType::Float32 => DataTypeLayout::new_fixed_width(size_of::<f32>()),
-        DataType::Float64 => DataTypeLayout::new_fixed_width(size_of::<f64>()),
-        DataType::Timestamp(_, _) => DataTypeLayout::new_fixed_width(size_of::<i64>()),
-        DataType::Date32 => DataTypeLayout::new_fixed_width(size_of::<i32>()),
-        DataType::Date64 => DataTypeLayout::new_fixed_width(size_of::<i64>()),
-        DataType::Time32(_) => DataTypeLayout::new_fixed_width(size_of::<i32>()),
-        DataType::Time64(_) => DataTypeLayout::new_fixed_width(size_of::<i64>()),
-        DataType::Interval(IntervalUnit::YearMonth) => {
-            DataTypeLayout::new_fixed_width(size_of::<i32>())
-        }
-        DataType::Interval(IntervalUnit::DayTime) => {
-            DataTypeLayout::new_fixed_width(size_of::<i64>())
-        }
-        DataType::Interval(IntervalUnit::MonthDayNano) => {
-            DataTypeLayout::new_fixed_width(size_of::<i128>())
-        }
-        DataType::Duration(_) => DataTypeLayout::new_fixed_width(size_of::<i64>()),
-        DataType::Binary => DataTypeLayout::new_binary(size_of::<i32>()),
-        DataType::FixedSizeBinary(bytes_per_value) => {
-            let bytes_per_value: usize = (*bytes_per_value)
-                .try_into()
-                .expect("negative size for fixed size binary");
-            DataTypeLayout::new_fixed_width(bytes_per_value)
-        }
-        DataType::LargeBinary => DataTypeLayout::new_binary(size_of::<i64>()),
-        DataType::Utf8 => DataTypeLayout::new_binary(size_of::<i32>()),
-        DataType::LargeUtf8 => DataTypeLayout::new_binary(size_of::<i64>()),
-        DataType::List(_) => DataTypeLayout::new_fixed_width(size_of::<i32>()),
-        DataType::FixedSizeList(_, _) => DataTypeLayout::new_empty(), // all in child data
-        DataType::LargeList(_) => DataTypeLayout::new_fixed_width(size_of::<i32>()),
-        DataType::Struct(_) => DataTypeLayout::new_empty(), // all in child data,
-        DataType::Union(_, _, mode) => {
-            let type_ids = BufferSpec::FixedWidth {
-                byte_width: size_of::<i8>(),
-            };
-
-            DataTypeLayout {
-                buffers: match mode {
-                    UnionMode::Sparse => {
-                        vec![type_ids]
-                    }
-                    UnionMode::Dense => {
-                        vec![
-                            type_ids,
-                            BufferSpec::FixedWidth {
-                                byte_width: size_of::<i32>(),
-                            },
-                        ]
-                    }
-                },
-                can_contain_null_mask: false,
-            }
-        }
-        DataType::Dictionary(key_type, _value_type) => layout(key_type),
-        DataType::Decimal128(_, _) => {
-            // Decimals are always some fixed width; The rust implementation
-            // always uses 16 bytes / size of i128
-            DataTypeLayout::new_fixed_width(size_of::<i128>())
-        }
-        DataType::Decimal256(_, _) => {
-            // Decimals are always some fixed width.
-            DataTypeLayout::new_fixed_width(32)
-        }
-        DataType::Map(_, _) => {
-            // same as ListType
-            DataTypeLayout::new_fixed_width(size_of::<i32>())
-        }
-    }
-}
-
-/// Layout specification for a data type
-#[derive(Debug, PartialEq)]
-// Note: Follows structure from C++: https://github.com/apache/arrow/blob/master/cpp/src/arrow/type.h#L91
-pub(crate) struct DataTypeLayout {
-    /// A vector of buffer layout specifications, one for each expected buffer
-    pub buffers: Vec<BufferSpec>,
-
-    /// Can contain a null bitmask
-    pub can_contain_null_mask: bool,
-}
-
-impl DataTypeLayout {
-    /// Describes a basic numeric array where each element has a fixed width
-    pub fn new_fixed_width(byte_width: usize) -> Self {
-        Self {
-            buffers: vec![BufferSpec::FixedWidth { byte_width }],
-            can_contain_null_mask: true,
-        }
-    }
-
-    /// Describes arrays which have no data of their own
-    /// (e.g. FixedSizeList). Note such arrays may still have a Null
-    /// Bitmap
-    pub fn new_empty() -> Self {
-        Self {
-            buffers: vec![],
-            can_contain_null_mask: true,
-        }
-    }
-
-    /// Describes a basic numeric array where each element has a fixed
-    /// with offset buffer of `offset_byte_width` bytes, followed by a
-    /// variable width data buffer
-    pub fn new_binary(offset_byte_width: usize) -> Self {
-        Self {
-            buffers: vec![
-                // offsets
-                BufferSpec::FixedWidth {
-                    byte_width: offset_byte_width,
-                },
-                // values
-                BufferSpec::VariableWidth,
-            ],
-            can_contain_null_mask: true,
-        }
-    }
-}
-
-/// Layout specification for a single data type buffer
-#[derive(Debug, PartialEq)]
-pub(crate) enum BufferSpec {
-    /// each element has a fixed width
-    FixedWidth { byte_width: usize },
-    /// Variable width, such as string data for utf8 data
-    VariableWidth,
-    /// Buffer holds a bitmap.
-    ///
-    /// Note: Unlike the C++ implementation, the null/validity buffer
-    /// is handled specially rather than as another of the buffers in
-    /// the spec, so this variant is only used for the Boolean type.
-    BitMap,
-    /// Buffer is always null. Unused currently in Rust implementation,
-    /// (used in C++ for Union type)
-    #[allow(dead_code)]
-    AlwaysNull,
-}
-
-impl PartialEq for ArrayData {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self, other)
-    }
-}
-
-/// Builder for `ArrayData` type
-#[derive(Debug)]
-pub struct ArrayDataBuilder {
-    data_type: DataType,
-    len: usize,
-    null_count: Option<usize>,
-    null_bit_buffer: Option<Buffer>,
-    offset: usize,
-    buffers: Vec<Buffer>,
-    child_data: Vec<ArrayData>,
-}
-
-impl ArrayDataBuilder {
-    #[inline]
-    pub const fn new(data_type: DataType) -> Self {
-        Self {
-            data_type,
-            len: 0,
-            null_count: None,
-            null_bit_buffer: None,
-            offset: 0,
-            buffers: vec![],
-            child_data: vec![],
-        }
-    }
-
-    pub fn data_type(self, data_type: DataType) -> Self {
-        Self { data_type, ..self }
-    }
-
-    #[inline]
-    #[allow(clippy::len_without_is_empty)]
-    pub const fn len(mut self, n: usize) -> Self {
-        self.len = n;
-        self
-    }
-
-    pub fn null_count(mut self, null_count: usize) -> Self {
-        self.null_count = Some(null_count);
-        self
-    }
-
-    pub fn null_bit_buffer(mut self, buf: Option<Buffer>) -> Self {
-        self.null_bit_buffer = buf;
-        self
-    }
-
-    #[inline]
-    pub const fn offset(mut self, n: usize) -> Self {
-        self.offset = n;
-        self
-    }
-
-    pub fn buffers(mut self, v: Vec<Buffer>) -> Self {
-        self.buffers = v;
-        self
-    }
-
-    pub fn add_buffer(mut self, b: Buffer) -> Self {
-        self.buffers.push(b);
-        self
-    }
-
-    pub fn child_data(mut self, v: Vec<ArrayData>) -> Self {
-        self.child_data = v;
-        self
-    }
-
-    pub fn add_child_data(mut self, r: ArrayData) -> Self {
-        self.child_data.push(r);
-        self
-    }
-
-    /// Creates an array data, without any validation
-    ///
-    /// # Safety
-    ///
-    /// The same caveats as [`ArrayData::new_unchecked`]
-    /// apply.
-    pub unsafe fn build_unchecked(self) -> ArrayData {
-        ArrayData::new_unchecked(
-            self.data_type,
-            self.len,
-            self.null_count,
-            self.null_bit_buffer,
-            self.offset,
-            self.buffers,
-            self.child_data,
-        )
-    }
-
-    /// Creates an array data, validating all inputs
-    pub fn build(self) -> Result<ArrayData> {
-        ArrayData::try_new(
-            self.data_type,
-            self.len,
-            self.null_bit_buffer,
-            self.offset,
-            self.buffers,
-            self.child_data,
-        )
-    }
-}
-
-impl From<ArrayData> for ArrayDataBuilder {
-    fn from(d: ArrayData) -> Self {
-        // TODO: Store Bitmap on ArrayData (#1799)
-        let null_bit_buffer = d.null_buffer().cloned();
-        Self {
-            null_bit_buffer,
-            data_type: d.data_type,
-            len: d.len,
-            null_count: Some(d.null_count),
-            offset: d.offset,
-            buffers: d.buffers,
-            child_data: d.child_data,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use std::ptr::NonNull;
-
-    use crate::array::{
-        make_array, Array, BooleanBuilder, Decimal128Builder, FixedSizeListBuilder,
-        Int32Array, Int32Builder, Int64Array, StringArray, StructBuilder, UInt64Array,
-        UInt8Builder,
-    };
-    use crate::buffer::Buffer;
-    use crate::datatypes::Field;
-    use crate::util::bit_util;
-
-    #[test]
-    fn test_builder() {
-        // Buffer needs to be at least 25 long
-        let v = (0..25).collect::<Vec<i32>>();
-        let b1 = Buffer::from_slice_ref(&v);
-        let arr_data = ArrayData::builder(DataType::Int32)
-            .len(20)
-            .offset(5)
-            .add_buffer(b1)
-            .null_bit_buffer(Some(Buffer::from(vec![
-                0b01011111, 0b10110101, 0b01100011, 0b00011110,
-            ])))
-            .build()
-            .unwrap();
-
-        assert_eq!(20, arr_data.len());
-        assert_eq!(10, arr_data.null_count());
-        assert_eq!(5, arr_data.offset());
-        assert_eq!(1, arr_data.buffers().len());
-        assert_eq!(
-            Buffer::from_slice_ref(&v).as_slice(),
-            arr_data.buffers()[0].as_slice()
-        );
-    }
-
-    #[test]
-    fn test_builder_with_child_data() {
-        let child_arr_data = ArrayData::try_new(
-            DataType::Int32,
-            5,
-            None,
-            0,
-            vec![Buffer::from_slice_ref(&[1i32, 2, 3, 4, 5])],
-            vec![],
-        )
-        .unwrap();
-
-        let data_type = DataType::Struct(vec![Field::new("x", DataType::Int32, true)]);
-
-        let arr_data = ArrayData::builder(data_type)
-            .len(5)
-            .offset(0)
-            .add_child_data(child_arr_data.clone())
-            .build()
-            .unwrap();
-
-        assert_eq!(5, arr_data.len());
-        assert_eq!(1, arr_data.child_data().len());
-        assert_eq!(child_arr_data, arr_data.child_data()[0]);
-    }
-
-    #[test]
-    fn test_null_count() {
-        let mut bit_v: [u8; 2] = [0; 2];
-        bit_util::set_bit(&mut bit_v, 0);
-        bit_util::set_bit(&mut bit_v, 3);
-        bit_util::set_bit(&mut bit_v, 10);
-        let arr_data = ArrayData::builder(DataType::Int32)
-            .len(16)
-            .add_buffer(make_i32_buffer(16))
-            .null_bit_buffer(Some(Buffer::from(bit_v)))
-            .build()
-            .unwrap();
-        assert_eq!(13, arr_data.null_count());
-
-        // Test with offset
-        let mut bit_v: [u8; 2] = [0; 2];
-        bit_util::set_bit(&mut bit_v, 0);
-        bit_util::set_bit(&mut bit_v, 3);
-        bit_util::set_bit(&mut bit_v, 10);
-        let arr_data = ArrayData::builder(DataType::Int32)
-            .len(12)
-            .offset(2)
-            .add_buffer(make_i32_buffer(14)) // requires at least 14 bytes of space,
-            .null_bit_buffer(Some(Buffer::from(bit_v)))
-            .build()
-            .unwrap();
-        assert_eq!(10, arr_data.null_count());
-    }
-
-    #[test]
-    fn test_null_buffer_ref() {
-        let mut bit_v: [u8; 2] = [0; 2];
-        bit_util::set_bit(&mut bit_v, 0);
-        bit_util::set_bit(&mut bit_v, 3);
-        bit_util::set_bit(&mut bit_v, 10);
-        let arr_data = ArrayData::builder(DataType::Int32)
-            .len(16)
-            .add_buffer(make_i32_buffer(16))
-            .null_bit_buffer(Some(Buffer::from(bit_v)))
-            .build()
-            .unwrap();
-        assert!(arr_data.null_buffer().is_some());
-        assert_eq!(&bit_v, arr_data.null_buffer().unwrap().as_slice());
-    }
-
-    #[test]
-    fn test_slice() {
-        let mut bit_v: [u8; 2] = [0; 2];
-        bit_util::set_bit(&mut bit_v, 0);
-        bit_util::set_bit(&mut bit_v, 3);
-        bit_util::set_bit(&mut bit_v, 10);
-        let data = ArrayData::builder(DataType::Int32)
-            .len(16)
-            .add_buffer(make_i32_buffer(16))
-            .null_bit_buffer(Some(Buffer::from(bit_v)))
-            .build()
-            .unwrap();
-        let new_data = data.slice(1, 15);
-        assert_eq!(data.len() - 1, new_data.len());
-        assert_eq!(1, new_data.offset());
-        assert_eq!(data.null_count(), new_data.null_count());
-
-        // slice of a slice (removes one null)
-        let new_data = new_data.slice(1, 14);
-        assert_eq!(data.len() - 2, new_data.len());
-        assert_eq!(2, new_data.offset());
-        assert_eq!(data.null_count() - 1, new_data.null_count());
-    }
-
-    #[test]
-    fn test_equality() {
-        let int_data = ArrayData::builder(DataType::Int32)
-            .len(1)
-            .add_buffer(make_i32_buffer(1))
-            .build()
-            .unwrap();
-
-        let float_data = ArrayData::builder(DataType::Float32)
-            .len(1)
-            .add_buffer(make_f32_buffer(1))
-            .build()
-            .unwrap();
-        assert_ne!(int_data, float_data);
-        assert!(!int_data.ptr_eq(&float_data));
-        assert!(int_data.ptr_eq(&int_data));
-
-        let int_data_clone = int_data.clone();
-        assert_eq!(int_data, int_data_clone);
-        assert!(int_data.ptr_eq(&int_data_clone));
-        assert!(int_data_clone.ptr_eq(&int_data));
-
-        let int_data_slice = int_data_clone.slice(1, 0);
-        assert!(int_data_slice.ptr_eq(&int_data_slice));
-        assert!(!int_data.ptr_eq(&int_data_slice));
-        assert!(!int_data_slice.ptr_eq(&int_data));
-
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        let offsets_buffer = Buffer::from_slice_ref(&[0_i32, 2_i32, 2_i32, 5_i32]);
-        let string_data = ArrayData::try_new(
-            DataType::Utf8,
-            3,
-            Some(Buffer::from_iter(vec![true, false, true])),
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-
-        assert_ne!(float_data, string_data);
-        assert!(!float_data.ptr_eq(&string_data));
-
-        assert!(string_data.ptr_eq(&string_data));
-
-        let string_data_cloned = string_data.clone();
-        assert!(string_data_cloned.ptr_eq(&string_data));
-        assert!(string_data.ptr_eq(&string_data_cloned));
-
-        let string_data_slice = string_data.slice(1, 2);
-        assert!(string_data_slice.ptr_eq(&string_data_slice));
-        assert!(!string_data_slice.ptr_eq(&string_data))
-    }
-
-    #[test]
-    fn test_count_nulls() {
-        let null_buffer = Some(Buffer::from(vec![0b00010110, 0b10011111]));
-        let count = count_nulls(null_buffer.as_ref(), 0, 16);
-        assert_eq!(count, 7);
-
-        let count = count_nulls(null_buffer.as_ref(), 4, 8);
-        assert_eq!(count, 3);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Need at least 80 bytes in buffers[0] in array of type Int64, but got 8"
-    )]
-    fn test_buffer_too_small() {
-        let buffer = Buffer::from_slice_ref(&[0i32, 2i32]);
-        // should fail as the declared size (10*8 = 80) is larger than the underlying bfufer (8)
-        ArrayData::try_new(DataType::Int64, 10, None, 0, vec![buffer], vec![]).unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Need at least 16 bytes in buffers[0] in array of type Int64, but got 8"
-    )]
-    fn test_buffer_too_small_offset() {
-        let buffer = Buffer::from_slice_ref(&[0i32, 2i32]);
-        // should fail -- size is ok, but also has offset
-        ArrayData::try_new(DataType::Int64, 1, None, 1, vec![buffer], vec![]).unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "Expected 1 buffers in array of type Int64, got 2")]
-    fn test_bad_number_of_buffers() {
-        let buffer1 = Buffer::from_slice_ref(&[0i32, 2i32]);
-        let buffer2 = Buffer::from_slice_ref(&[0i32, 2i32]);
-        ArrayData::try_new(DataType::Int64, 1, None, 0, vec![buffer1, buffer2], vec![])
-            .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "integer overflow computing min buffer size")]
-    fn test_fixed_width_overflow() {
-        let buffer = Buffer::from_slice_ref(&[0i32, 2i32]);
-        ArrayData::try_new(DataType::Int64, usize::MAX, None, 0, vec![buffer], vec![])
-            .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "null_bit_buffer size too small. got 1 needed 2")]
-    fn test_bitmap_too_small() {
-        let buffer = make_i32_buffer(9);
-        let null_bit_buffer = Buffer::from(vec![0b11111111]);
-
-        ArrayData::try_new(
-            DataType::Int32,
-            9,
-            Some(null_bit_buffer),
-            0,
-            vec![buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    // Test creating a dictionary with a non integer type
-    #[test]
-    #[should_panic(expected = "Dictionary key type must be integer, but was Utf8")]
-    fn test_non_int_dictionary() {
-        let i32_buffer = Buffer::from_slice_ref(&[0i32, 2i32]);
-        let data_type =
-            DataType::Dictionary(Box::new(DataType::Utf8), Box::new(DataType::Int32));
-        let child_data = ArrayData::try_new(
-            DataType::Int32,
-            1,
-            None,
-            0,
-            vec![i32_buffer.clone()],
-            vec![],
-        )
-        .unwrap();
-        ArrayData::try_new(
-            data_type,
-            1,
-            None,
-            0,
-            vec![i32_buffer.clone(), i32_buffer],
-            vec![child_data],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "Expected LargeUtf8 but child data had Utf8")]
-    fn test_mismatched_dictionary_types() {
-        // test w/ dictionary created with a child array data that has type different than declared
-        let string_array: StringArray =
-            vec![Some("foo"), Some("bar")].into_iter().collect();
-        let i32_buffer = Buffer::from_slice_ref(&[0i32, 1i32]);
-        // Dict says LargeUtf8 but array is Utf8
-        let data_type = DataType::Dictionary(
-            Box::new(DataType::Int32),
-            Box::new(DataType::LargeUtf8),
-        );
-        let child_data = string_array.into_data();
-        ArrayData::try_new(data_type, 1, None, 0, vec![i32_buffer], vec![child_data])
-            .unwrap();
-    }
-
-    #[test]
-    fn test_empty_utf8_array_with_empty_offsets_buffer() {
-        let data_buffer = Buffer::from(&[]);
-        let offsets_buffer = Buffer::from(&[]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            0,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_empty_utf8_array_with_single_zero_offset() {
-        let data_buffer = Buffer::from(&[]);
-        let offsets_buffer = Buffer::from_slice_ref(&[0i32]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            0,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "First offset 1 of Utf8 is larger than values length 0")]
-    fn test_empty_utf8_array_with_invalid_offset() {
-        let data_buffer = Buffer::from(&[]);
-        let offsets_buffer = Buffer::from_slice_ref(&[1i32]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            0,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_empty_utf8_array_with_non_zero_offset() {
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        let offsets_buffer = Buffer::from_slice_ref(&[0i32, 2, 6, 0]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            0,
-            None,
-            3,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Buffer 0 of LargeUtf8 isn't large enough. Expected 8 bytes got 4"
-    )]
-    fn test_empty_large_utf8_array_with_wrong_type_offsets() {
-        let data_buffer = Buffer::from(&[]);
-        let offsets_buffer = Buffer::from_slice_ref(&[0i32]);
-        ArrayData::try_new(
-            DataType::LargeUtf8,
-            0,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Buffer 0 of Utf8 isn't large enough. Expected 12 bytes got 8"
-    )]
-    fn test_validate_offsets_i32() {
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        let offsets_buffer = Buffer::from_slice_ref(&[0i32, 2i32]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            2,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Buffer 0 of LargeUtf8 isn't large enough. Expected 24 bytes got 16"
-    )]
-    fn test_validate_offsets_i64() {
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        let offsets_buffer = Buffer::from_slice_ref(&[0i64, 2i64]);
-        ArrayData::try_new(
-            DataType::LargeUtf8,
-            2,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "Error converting offset[0] (-2) to usize for Utf8")]
-    fn test_validate_offsets_negative_first_i32() {
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        let offsets_buffer = Buffer::from_slice_ref(&[-2i32, 1i32, 3i32]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            2,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "Error converting offset[2] (-3) to usize for Utf8")]
-    fn test_validate_offsets_negative_last_i32() {
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        let offsets_buffer = Buffer::from_slice_ref(&[0i32, 2i32, -3i32]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            2,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "First offset 4 in Utf8 is smaller than last offset 3")]
-    fn test_validate_offsets_range_too_small() {
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        // start offset is larger than end
-        let offsets_buffer = Buffer::from_slice_ref(&[4i32, 2i32, 3i32]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            2,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "Last offset 10 of Utf8 is larger than values length 6")]
-    fn test_validate_offsets_range_too_large() {
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        // 10 is off the end of the buffer
-        let offsets_buffer = Buffer::from_slice_ref(&[0i32, 2i32, 10i32]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            2,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "First offset 10 of Utf8 is larger than values length 6")]
-    fn test_validate_offsets_first_too_large() {
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        // 10 is off the end of the buffer
-        let offsets_buffer = Buffer::from_slice_ref(&[10i32, 2i32, 10i32]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            2,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_validate_offsets_first_too_large_skipped() {
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        // 10 is off the end of the buffer, but offset starts at 1 so it is skipped
-        let offsets_buffer = Buffer::from_slice_ref(&[10i32, 2i32, 3i32, 4i32]);
-        let data = ArrayData::try_new(
-            DataType::Utf8,
-            2,
-            None,
-            1,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-        let array: StringArray = data.into();
-        let expected: StringArray = vec![Some("c"), Some("d")].into_iter().collect();
-        assert_eq!(array, expected);
-    }
-
-    #[test]
-    #[should_panic(expected = "Last offset 8 of Utf8 is larger than values length 6")]
-    fn test_validate_offsets_last_too_large() {
-        let data_buffer = Buffer::from_slice_ref(&"abcdef".as_bytes());
-        // 10 is off the end of the buffer
-        let offsets_buffer = Buffer::from_slice_ref(&[5i32, 7i32, 8i32]);
-        ArrayData::try_new(
-            DataType::Utf8,
-            2,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Values length 4 is less than the length (2) multiplied by the value size (2) for FixedSizeList"
-    )]
-    fn test_validate_fixed_size_list() {
-        // child has 4 elements,
-        let child_array = vec![Some(1), Some(2), Some(3), None]
-            .into_iter()
-            .collect::<Int32Array>();
-
-        // but claim we have 3 elements for a fixed size of 2
-        // 10 is off the end of the buffer
-        let field = Field::new("field", DataType::Int32, true);
-        ArrayData::try_new(
-            DataType::FixedSizeList(Box::new(field), 2),
-            3,
-            None,
-            0,
-            vec![],
-            vec![child_array.into_data()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "Child type mismatch for Struct")]
-    fn test_validate_struct_child_type() {
-        let field1 = vec![Some(1), Some(2), Some(3), None]
-            .into_iter()
-            .collect::<Int32Array>();
-
-        // validate the the type of struct fields matches child fields
-        ArrayData::try_new(
-            DataType::Struct(vec![Field::new("field1", DataType::Int64, true)]),
-            3,
-            None,
-            0,
-            vec![],
-            vec![field1.into_data()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "child array #0 for field field1 has length smaller than expected for struct array (4 < 6)"
-    )]
-    fn test_validate_struct_child_length() {
-        // field length only has 4 items, but array claims to have 6
-        let field1 = vec![Some(1), Some(2), Some(3), None]
-            .into_iter()
-            .collect::<Int32Array>();
-
-        ArrayData::try_new(
-            DataType::Struct(vec![Field::new("field1", DataType::Int32, true)]),
-            6,
-            None,
-            0,
-            vec![],
-            vec![field1.into_data()],
-        )
-        .unwrap();
-    }
-
-    /// Test that the array of type `data_type` that has invalid utf8 data errors
-    fn check_utf8_validation<T: ArrowNativeType>(data_type: DataType) {
-        // 0x80 is a utf8 continuation sequence and is not a valid utf8 sequence itself
-        let data_buffer = Buffer::from_slice_ref(&[b'a', b'a', 0x80, 0x00]);
-        let offsets: Vec<T> = [0, 2, 3]
-            .iter()
-            .map(|&v| T::from_usize(v).unwrap())
-            .collect();
-
-        let offsets_buffer = Buffer::from_slice_ref(&offsets);
-        ArrayData::try_new(
-            data_type,
-            2,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "Invalid UTF8 sequence at string index 1 (2..3)")]
-    fn test_validate_utf8_content() {
-        check_utf8_validation::<i32>(DataType::Utf8);
-    }
-
-    #[test]
-    #[should_panic(expected = "Invalid UTF8 sequence at string index 1 (2..3)")]
-    fn test_validate_large_utf8_content() {
-        check_utf8_validation::<i64>(DataType::LargeUtf8);
-    }
-
-    /// Tests that offsets are at valid codepoint boundaries
-    fn check_utf8_char_boundary<T: ArrowNativeType>(data_type: DataType) {
-        let data_buffer = Buffer::from("🙀".as_bytes());
-        let offsets: Vec<T> = [0, 1, data_buffer.len()]
-            .iter()
-            .map(|&v| T::from_usize(v).unwrap())
-            .collect();
-
-        let offsets_buffer = Buffer::from_slice_ref(&offsets);
-        ArrayData::try_new(
-            data_type,
-            2,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "incomplete utf-8 byte sequence from index 0")]
-    fn test_validate_utf8_char_boundary() {
-        check_utf8_char_boundary::<i32>(DataType::Utf8);
-    }
-
-    #[test]
-    #[should_panic(expected = "incomplete utf-8 byte sequence from index 0")]
-    fn test_validate_large_utf8_char_boundary() {
-        check_utf8_char_boundary::<i64>(DataType::LargeUtf8);
-    }
-
-    /// Test that the array of type `data_type` that has invalid indexes (out of bounds)
-    fn check_index_out_of_bounds_validation<T: ArrowNativeType>(data_type: DataType) {
-        let data_buffer = Buffer::from_slice_ref(&[b'a', b'b', b'c', b'd']);
-        // First two offsets are fine, then 5 is out of bounds
-        let offsets: Vec<T> = [0, 1, 2, 5, 2]
-            .iter()
-            .map(|&v| T::from_usize(v).unwrap())
-            .collect();
-
-        let offsets_buffer = Buffer::from_slice_ref(&offsets);
-        ArrayData::try_new(
-            data_type,
-            4,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: offset at position 3 out of bounds: 5 > 4"
-    )]
-    fn test_validate_utf8_out_of_bounds() {
-        check_index_out_of_bounds_validation::<i32>(DataType::Utf8);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: offset at position 3 out of bounds: 5 > 4"
-    )]
-    fn test_validate_large_utf8_out_of_bounds() {
-        check_index_out_of_bounds_validation::<i64>(DataType::LargeUtf8);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: offset at position 3 out of bounds: 5 > 4"
-    )]
-    fn test_validate_binary_out_of_bounds() {
-        check_index_out_of_bounds_validation::<i32>(DataType::Binary);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: offset at position 3 out of bounds: 5 > 4"
-    )]
-    fn test_validate_large_binary_out_of_bounds() {
-        check_index_out_of_bounds_validation::<i64>(DataType::LargeBinary);
-    }
-
-    // validate that indexes don't go bacwards check indexes that go backwards
-    fn check_index_backwards_validation<T: ArrowNativeType>(data_type: DataType) {
-        let data_buffer = Buffer::from_slice_ref(&[b'a', b'b', b'c', b'd']);
-        // First three offsets are fine, then 1 goes backwards
-        let offsets: Vec<T> = [0, 1, 2, 2, 1]
-            .iter()
-            .map(|&v| T::from_usize(v).unwrap())
-            .collect();
-
-        let offsets_buffer = Buffer::from_slice_ref(&offsets);
-        ArrayData::try_new(
-            data_type,
-            4,
-            None,
-            0,
-            vec![offsets_buffer, data_buffer],
-            vec![],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: non-monotonic offset at slot 3: 2 > 1"
-    )]
-    fn test_validate_utf8_index_backwards() {
-        check_index_backwards_validation::<i32>(DataType::Utf8);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: non-monotonic offset at slot 3: 2 > 1"
-    )]
-    fn test_validate_large_utf8_index_backwards() {
-        check_index_backwards_validation::<i64>(DataType::LargeUtf8);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: non-monotonic offset at slot 3: 2 > 1"
-    )]
-    fn test_validate_binary_index_backwards() {
-        check_index_backwards_validation::<i32>(DataType::Binary);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: non-monotonic offset at slot 3: 2 > 1"
-    )]
-    fn test_validate_large_binary_index_backwards() {
-        check_index_backwards_validation::<i64>(DataType::LargeBinary);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Value at position 1 out of bounds: 3 (should be in [0, 1])"
-    )]
-    fn test_validate_dictionary_index_too_large() {
-        let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
-
-        // 3 is not a valid index into the values (only 0 and 1)
-        let keys: Int32Array = [Some(1), Some(3)].into_iter().collect();
-
-        let data_type = DataType::Dictionary(
-            Box::new(keys.data_type().clone()),
-            Box::new(values.data_type().clone()),
-        );
-
-        ArrayData::try_new(
-            data_type,
-            2,
-            None,
-            0,
-            vec![keys.data().buffers[0].clone()],
-            vec![values.into_data()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Value at position 1 out of bounds: -1 (should be in [0, 1]"
-    )]
-    fn test_validate_dictionary_index_negative() {
-        let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
-
-        // -1 is not a valid index at all!
-        let keys: Int32Array = [Some(1), Some(-1)].into_iter().collect();
-
-        let data_type = DataType::Dictionary(
-            Box::new(keys.data_type().clone()),
-            Box::new(values.data_type().clone()),
-        );
-
-        ArrayData::try_new(
-            data_type,
-            2,
-            None,
-            0,
-            vec![keys.data().buffers[0].clone()],
-            vec![values.into_data()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_validate_dictionary_index_negative_but_not_referenced() {
-        let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
-
-        // -1 is not a valid index at all, but the array is length 1
-        // so the -1 should not be looked at
-        let keys: Int32Array = [Some(1), Some(-1)].into_iter().collect();
-
-        let data_type = DataType::Dictionary(
-            Box::new(keys.data_type().clone()),
-            Box::new(values.data_type().clone()),
-        );
-
-        // Expect this not to panic
-        ArrayData::try_new(
-            data_type,
-            1,
-            None,
-            0,
-            vec![keys.data().buffers[0].clone()],
-            vec![values.into_data()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Value at position 0 out of bounds: 18446744073709551615 (can not convert to i64)"
-    )]
-    fn test_validate_dictionary_index_giant_negative() {
-        let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
-
-        // -1 is not a valid index at all!
-        let keys: UInt64Array = [Some(u64::MAX), Some(1)].into_iter().collect();
-
-        let data_type = DataType::Dictionary(
-            Box::new(keys.data_type().clone()),
-            Box::new(values.data_type().clone()),
-        );
-
-        ArrayData::try_new(
-            data_type,
-            2,
-            None,
-            0,
-            vec![keys.data().buffers[0].clone()],
-            vec![values.into_data()],
-        )
-        .unwrap();
-    }
-
-    /// Test that the list of type `data_type` generates correct offset out of bounds errors
-    fn check_list_offsets<T: ArrowNativeType>(data_type: DataType) {
-        let values: Int32Array =
-            [Some(1), Some(2), Some(3), Some(4)].into_iter().collect();
-
-        // 5 is an invalid offset into a list of only three values
-        let offsets: Vec<T> = [0, 2, 5, 4]
-            .iter()
-            .map(|&v| T::from_usize(v).unwrap())
-            .collect();
-        let offsets_buffer = Buffer::from_slice_ref(&offsets);
-
-        ArrayData::try_new(
-            data_type,
-            3,
-            None,
-            0,
-            vec![offsets_buffer],
-            vec![values.into_data()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: offset at position 2 out of bounds: 5 > 4"
-    )]
-    fn test_validate_list_offsets() {
-        let field_type = Field::new("f", DataType::Int32, true);
-        check_list_offsets::<i32>(DataType::List(Box::new(field_type)));
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: offset at position 2 out of bounds: 5 > 4"
-    )]
-    fn test_validate_large_list_offsets() {
-        let field_type = Field::new("f", DataType::Int32, true);
-        check_list_offsets::<i64>(DataType::LargeList(Box::new(field_type)));
-    }
-
-    /// Test that the list of type `data_type` generates correct errors for negative offsets
-    #[test]
-    #[should_panic(
-        expected = "Offset invariant failure: Could not convert offset -1 to usize at position 2"
-    )]
-    fn test_validate_list_negative_offsets() {
-        let values: Int32Array =
-            [Some(1), Some(2), Some(3), Some(4)].into_iter().collect();
-        let field_type = Field::new("f", values.data_type().clone(), true);
-        let data_type = DataType::List(Box::new(field_type));
-
-        // -1 is an invalid offset any way you look at it
-        let offsets: Vec<i32> = vec![0, 2, -1, 4];
-        let offsets_buffer = Buffer::from_slice_ref(&offsets);
-
-        ArrayData::try_new(
-            data_type,
-            3,
-            None,
-            0,
-            vec![offsets_buffer],
-            vec![values.into_data()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Value at position 1 out of bounds: -1 (should be in [0, 1])"
-    )]
-    /// test that children are validated recursively (aka bugs in child data of struct also are flagged)
-    fn test_validate_recursive() {
-        // Form invalid dictionary array
-        let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
-        // -1 is not a valid index
-        let keys: Int32Array = [Some(1), Some(-1), Some(1)].into_iter().collect();
-
-        let dict_data_type = DataType::Dictionary(
-            Box::new(keys.data_type().clone()),
-            Box::new(values.data_type().clone()),
-        );
-
-        // purposely create an invalid child data
-        let dict_data = unsafe {
-            ArrayData::new_unchecked(
-                dict_data_type,
-                2,
-                None,
-                None,
-                0,
-                vec![keys.data().buffers[0].clone()],
-                vec![values.into_data()],
-            )
-        };
-
-        // Now, try and create a struct with this invalid child data (and expect an error)
-        let data_type =
-            DataType::Struct(vec![Field::new("d", dict_data.data_type().clone(), true)]);
-
-        ArrayData::try_new(data_type, 1, None, 0, vec![], vec![dict_data]).unwrap();
-    }
-
-    /// returns a buffer initialized with some constant value for tests
-    fn make_i32_buffer(n: usize) -> Buffer {
-        Buffer::from_slice_ref(&vec![42i32; n])
-    }
-
-    /// returns a buffer initialized with some constant value for tests
-    fn make_f32_buffer(n: usize) -> Buffer {
-        Buffer::from_slice_ref(&vec![42f32; n])
-    }
-
-    #[test]
-    #[should_panic(expected = "Expected Int64 but child data had Int32")]
-    fn test_validate_union_different_types() {
-        let field1 = vec![Some(1), Some(2)].into_iter().collect::<Int32Array>();
-
-        let field2 = vec![Some(1), Some(2)].into_iter().collect::<Int32Array>();
-
-        let type_ids = Buffer::from_slice_ref(&[0i8, 1i8]);
-
-        ArrayData::try_new(
-            DataType::Union(
-                vec![
-                    Field::new("field1", DataType::Int32, true),
-                    Field::new("field2", DataType::Int64, true), // data is int32
-                ],
-                vec![0, 1],
-                UnionMode::Sparse,
-            ),
-            2,
-            None,
-            0,
-            vec![type_ids],
-            vec![field1.into_data(), field2.into_data()],
-        )
-        .unwrap();
-    }
-
-    // sparse with wrong sized children
-    #[test]
-    #[should_panic(
-        expected = "Sparse union child array #1 has length smaller than expected for union array (1 < 2)"
-    )]
-    fn test_validate_union_sparse_different_child_len() {
-        let field1 = vec![Some(1), Some(2)].into_iter().collect::<Int32Array>();
-
-        // field 2 only has 1 item but array should have 2
-        let field2 = vec![Some(1)].into_iter().collect::<Int64Array>();
-
-        let type_ids = Buffer::from_slice_ref(&[0i8, 1i8]);
-
-        ArrayData::try_new(
-            DataType::Union(
-                vec![
-                    Field::new("field1", DataType::Int32, true),
-                    Field::new("field2", DataType::Int64, true),
-                ],
-                vec![0, 1],
-                UnionMode::Sparse,
-            ),
-            2,
-            None,
-            0,
-            vec![type_ids],
-            vec![field1.into_data(), field2.into_data()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "Expected 2 buffers in array of type Union")]
-    fn test_validate_union_dense_without_offsets() {
-        let field1 = vec![Some(1), Some(2)].into_iter().collect::<Int32Array>();
-
-        let field2 = vec![Some(1)].into_iter().collect::<Int64Array>();
-
-        let type_ids = Buffer::from_slice_ref(&[0i8, 1i8]);
-
-        ArrayData::try_new(
-            DataType::Union(
-                vec![
-                    Field::new("field1", DataType::Int32, true),
-                    Field::new("field2", DataType::Int64, true),
-                ],
-                vec![0, 1],
-                UnionMode::Dense,
-            ),
-            2,
-            None,
-            0,
-            vec![type_ids], // need offsets buffer here too
-            vec![field1.into_data(), field2.into_data()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Need at least 8 bytes in buffers[1] in array of type Union"
-    )]
-    fn test_validate_union_dense_with_bad_len() {
-        let field1 = vec![Some(1), Some(2)].into_iter().collect::<Int32Array>();
-
-        let field2 = vec![Some(1)].into_iter().collect::<Int64Array>();
-
-        let type_ids = Buffer::from_slice_ref(&[0i8, 1i8]);
-        let offsets = Buffer::from_slice_ref(&[0i32]); // should have 2 offsets, but only have 1
-
-        ArrayData::try_new(
-            DataType::Union(
-                vec![
-                    Field::new("field1", DataType::Int32, true),
-                    Field::new("field2", DataType::Int64, true),
-                ],
-                vec![0, 1],
-                UnionMode::Dense,
-            ),
-            2,
-            None,
-            0,
-            vec![type_ids, offsets],
-            vec![field1.into_data(), field2.into_data()],
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_try_new_sliced_struct() {
-        let mut builder = StructBuilder::new(
-            vec![
-                Field::new("a", DataType::Int32, true),
-                Field::new("b", DataType::Boolean, true),
-            ],
-            vec![
-                Box::new(Int32Builder::new(5)),
-                Box::new(BooleanBuilder::new(5)),
-            ],
-        );
-
-        // struct[0] = { a: 10, b: true }
-        builder
-            .field_builder::<Int32Builder>(0)
-            .unwrap()
-            .append_option(Some(10));
-        builder
-            .field_builder::<BooleanBuilder>(1)
-            .unwrap()
-            .append_option(Some(true));
-        builder.append(true);
-
-        // struct[1] = null
-        builder
-            .field_builder::<Int32Builder>(0)
-            .unwrap()
-            .append_option(None);
-        builder
-            .field_builder::<BooleanBuilder>(1)
-            .unwrap()
-            .append_option(None);
-        builder.append(false);
-
-        // struct[2] = { a: null, b: false }
-        builder
-            .field_builder::<Int32Builder>(0)
-            .unwrap()
-            .append_option(None);
-        builder
-            .field_builder::<BooleanBuilder>(1)
-            .unwrap()
-            .append_option(Some(false));
-        builder.append(true);
-
-        // struct[3] = { a: 21, b: null }
-        builder
-            .field_builder::<Int32Builder>(0)
-            .unwrap()
-            .append_option(Some(21));
-        builder
-            .field_builder::<BooleanBuilder>(1)
-            .unwrap()
-            .append_option(None);
-        builder.append(true);
-
-        // struct[4] = { a: 18, b: false }
-        builder
-            .field_builder::<Int32Builder>(0)
-            .unwrap()
-            .append_option(Some(18));
-        builder
-            .field_builder::<BooleanBuilder>(1)
-            .unwrap()
-            .append_option(Some(false));
-        builder.append(true);
-
-        let struct_array = builder.finish();
-        let struct_array_slice = struct_array.slice(1, 3);
-        let struct_array_data = struct_array_slice.data();
-
-        let cloned_data = ArrayData::try_new(
-            struct_array_slice.data_type().clone(),
-            struct_array_slice.len(),
-            struct_array_data.null_buffer().cloned(),
-            struct_array_slice.offset(),
-            struct_array_data.buffers().to_vec(),
-            struct_array_data.child_data().to_vec(),
-        )
-        .unwrap();
-        let cloned = crate::array::make_array(cloned_data);
-
-        assert_eq!(&struct_array_slice, &cloned);
-    }
-
-    #[test]
-    fn test_into_buffers() {
-        let data_types = vec![
-            DataType::Union(vec![], vec![], UnionMode::Dense),
-            DataType::Union(vec![], vec![], UnionMode::Sparse),
-        ];
-
-        for data_type in data_types {
-            let buffers = new_buffers(&data_type, 0);
-            let [buffer1, buffer2] = buffers;
-            let buffers = into_buffers(&data_type, buffer1, buffer2);
-
-            let layout = layout(&data_type);
-            assert_eq!(buffers.len(), layout.buffers.len());
-        }
-    }
-
-    #[test]
-    fn test_string_data_from_foreign() {
-        let mut strings = "foobarfoobar".to_owned();
-        let mut offsets = vec![0_i32, 0, 3, 6, 12];
-        let mut bitmap = vec![0b1110_u8];
-
-        let strings_buffer = unsafe {
-            Buffer::from_custom_allocation(
-                NonNull::new_unchecked(strings.as_mut_ptr()),
-                strings.len(),
-                Arc::new(strings),
-            )
-        };
-        let offsets_buffer = unsafe {
-            Buffer::from_custom_allocation(
-                NonNull::new_unchecked(offsets.as_mut_ptr() as *mut u8),
-                offsets.len() * std::mem::size_of::<i32>(),
-                Arc::new(offsets),
-            )
-        };
-        let null_buffer = unsafe {
-            Buffer::from_custom_allocation(
-                NonNull::new_unchecked(bitmap.as_mut_ptr()),
-                bitmap.len(),
-                Arc::new(bitmap),
-            )
-        };
-
-        let data = ArrayData::try_new(
-            DataType::Utf8,
-            4,
-            Some(null_buffer),
-            0,
-            vec![offsets_buffer, strings_buffer],
-            vec![],
-        )
-        .unwrap();
-
-        let array = make_array(data);
-        let array = array.as_any().downcast_ref::<StringArray>().unwrap();
-
-        let expected =
-            StringArray::from(vec![None, Some("foo"), Some("bar"), Some("foobar")]);
-
-        assert_eq!(array, &expected);
-    }
-
-    #[test]
-    #[cfg(not(feature = "force_validate"))]
-    fn test_decimal_full_validation() {
-        let values_builder = UInt8Builder::new(10);
-        let byte_width = 16;
-        let mut fixed_size_builder =
-            FixedSizeListBuilder::new(values_builder, byte_width);
-        let value_as_bytes = Decimal128Builder::from_i128_to_fixed_size_bytes(
-            123456,
-            fixed_size_builder.value_length() as usize,
-        )
-        .unwrap();
-        fixed_size_builder
-            .values()
-            .append_slice(value_as_bytes.as_slice());
-        fixed_size_builder.append(true);
-        let fixed_size_array = fixed_size_builder.finish();
-
-        // Build ArrayData for Decimal
-        let builder = ArrayData::builder(DataType::Decimal128(5, 3))
-            .len(fixed_size_array.len())
-            .add_buffer(fixed_size_array.data_ref().child_data()[0].buffers()[0].clone());
-        let array_data = unsafe { builder.build_unchecked() };
-        let validation_result = array_data.validate_full();
-        let error = validation_result.unwrap_err();
-        assert_eq!(
-            "Invalid argument error: 123456 is too large to store in a Decimal128 of precision 5. Max is 99999",
-            error.to_string()
-        );
-    }
-
-    #[test]
-    fn test_decimal_validation() {
-        let mut builder = Decimal128Builder::new(4, 10, 4);
-        builder.append_value(10000).unwrap();
-        builder.append_value(20000).unwrap();
-        let array = builder.finish();
-
-        array.data().validate_full().unwrap();
-    }
-
-    #[test]
-    #[cfg(not(feature = "force_validate"))]
-    fn test_sliced_array_child() {
-        let values = Int32Array::from_iter_values([1, 2, 3]);
-        let values_sliced = values.slice(1, 2);
-        let offsets = Buffer::from_iter([1_i32, 3_i32]);
-
-        let list_field = Field::new("element", DataType::Int32, false);
-        let data_type = DataType::List(Box::new(list_field));
-
-        let data = unsafe {
-            ArrayData::new_unchecked(
-                data_type,
-                1,
-                None,
-                None,
-                0,
-                vec![offsets],
-                vec![values_sliced.into_data()],
-            )
-        };
-
-        let err = data.validate_values().unwrap_err();
-        assert_eq!(err.to_string(), "Invalid argument error: Offset invariant failure: offset at position 1 out of bounds: 3 > 2");
-    }
-
-    #[test]
-    fn test_contains_nulls() {
-        let buffer: Buffer =
-            MutableBuffer::from_iter([false, false, false, true, true, false]).into();
-
-        assert!(contains_nulls(Some(&buffer), 0, 6));
-        assert!(contains_nulls(Some(&buffer), 0, 3));
-        assert!(!contains_nulls(Some(&buffer), 3, 2));
-        assert!(!contains_nulls(Some(&buffer), 0, 0));
-    }
-}
diff --git a/arrow/src/array/equal/decimal.rs b/arrow/src/array/equal/decimal.rs
deleted file mode 100644
index 42a7d29e27d2..000000000000
--- a/arrow/src/array/equal/decimal.rs
+++ /dev/null
@@ -1,74 +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.
-
-use crate::array::{data::count_nulls, ArrayData};
-use crate::datatypes::DataType;
-use crate::util::bit_util::get_bit;
-
-use super::utils::equal_len;
-
-pub(super) fn decimal_equal(
-    lhs: &ArrayData,
-    rhs: &ArrayData,
-    lhs_start: usize,
-    rhs_start: usize,
-    len: usize,
-) -> bool {
-    let size = match lhs.data_type() {
-        DataType::Decimal128(_, _) => 16,
-        DataType::Decimal256(_, _) => 32,
-        _ => unreachable!(),
-    };
-
-    let lhs_values = &lhs.buffers()[0].as_slice()[lhs.offset() * size..];
-    let rhs_values = &rhs.buffers()[0].as_slice()[rhs.offset() * size..];
-
-    let lhs_null_count = count_nulls(lhs.null_buffer(), lhs_start + lhs.offset(), len);
-    let rhs_null_count = count_nulls(rhs.null_buffer(), rhs_start + rhs.offset(), len);
-
-    if lhs_null_count == 0 && rhs_null_count == 0 {
-        equal_len(
-            lhs_values,
-            rhs_values,
-            size * lhs_start,
-            size * rhs_start,
-            size * len,
-        )
-    } else {
-        // get a ref of the null buffer bytes, to use in testing for nullness
-        let lhs_null_bytes = lhs.null_buffer().as_ref().unwrap().as_slice();
-        let rhs_null_bytes = rhs.null_buffer().as_ref().unwrap().as_slice();
-        // with nulls, we need to compare item by item whenever it is not null
-        (0..len).all(|i| {
-            let lhs_pos = lhs_start + i;
-            let rhs_pos = rhs_start + i;
-
-            let lhs_is_null = !get_bit(lhs_null_bytes, lhs_pos + lhs.offset());
-            let rhs_is_null = !get_bit(rhs_null_bytes, rhs_pos + rhs.offset());
-
-            lhs_is_null
-                || (lhs_is_null == rhs_is_null)
-                    && equal_len(
-                        lhs_values,
-                        rhs_values,
-                        lhs_pos * size,
-                        rhs_pos * size,
-                        size, // 1 * size since we are comparing a single entry
-                    )
-        })
-    }
-}
diff --git a/arrow/src/array/equal/fixed_binary.rs b/arrow/src/array/equal/fixed_binary.rs
deleted file mode 100644
index aea0e08a9ebf..000000000000
--- a/arrow/src/array/equal/fixed_binary.rs
+++ /dev/null
@@ -1,73 +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.
-
-use crate::array::{data::count_nulls, ArrayData};
-use crate::datatypes::DataType;
-use crate::util::bit_util::get_bit;
-
-use super::utils::equal_len;
-
-pub(super) fn fixed_binary_equal(
-    lhs: &ArrayData,
-    rhs: &ArrayData,
-    lhs_start: usize,
-    rhs_start: usize,
-    len: usize,
-) -> bool {
-    let size = match lhs.data_type() {
-        DataType::FixedSizeBinary(i) => *i as usize,
-        _ => unreachable!(),
-    };
-
-    let lhs_values = &lhs.buffers()[0].as_slice()[lhs.offset() * size..];
-    let rhs_values = &rhs.buffers()[0].as_slice()[rhs.offset() * size..];
-
-    let lhs_null_count = count_nulls(lhs.null_buffer(), lhs_start + lhs.offset(), len);
-    let rhs_null_count = count_nulls(rhs.null_buffer(), rhs_start + rhs.offset(), len);
-
-    if lhs_null_count == 0 && rhs_null_count == 0 {
-        equal_len(
-            lhs_values,
-            rhs_values,
-            size * lhs_start,
-            size * rhs_start,
-            size * len,
-        )
-    } else {
-        // get a ref of the null buffer bytes, to use in testing for nullness
-        let lhs_null_bytes = lhs.null_buffer().as_ref().unwrap().as_slice();
-        let rhs_null_bytes = rhs.null_buffer().as_ref().unwrap().as_slice();
-        // with nulls, we need to compare item by item whenever it is not null
-        (0..len).all(|i| {
-            let lhs_pos = lhs_start + i;
-            let rhs_pos = rhs_start + i;
-
-            let lhs_is_null = !get_bit(lhs_null_bytes, lhs_pos + lhs.offset());
-            let rhs_is_null = !get_bit(rhs_null_bytes, rhs_pos + rhs.offset());
-
-            lhs_is_null
-                || (lhs_is_null == rhs_is_null)
-                    && equal_len(
-                        lhs_values,
-                        rhs_values,
-                        lhs_pos * size,
-                        rhs_pos * size,
-                        size, // 1 * size since we are comparing a single entry
-                    )
-        })
-    }
-}
diff --git a/arrow/src/array/equal/mod.rs b/arrow/src/array/equal/mod.rs
deleted file mode 100644
index 6fdc06f837c0..000000000000
--- a/arrow/src/array/equal/mod.rs
+++ /dev/null
@@ -1,1460 +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.
-
-//! Module containing functionality to compute array equality.
-//! This module uses [ArrayData] and does not
-//! depend on dynamic casting of `Array`.
-
-use super::{
-    Array, ArrayData, BooleanArray, Decimal128Array, DictionaryArray,
-    FixedSizeBinaryArray, FixedSizeListArray, GenericBinaryArray, GenericListArray,
-    GenericStringArray, MapArray, NullArray, OffsetSizeTrait, PrimitiveArray,
-    StructArray,
-};
-use crate::datatypes::{ArrowPrimitiveType, DataType, IntervalUnit};
-use half::f16;
-
-mod boolean;
-mod decimal;
-mod dictionary;
-mod fixed_binary;
-mod fixed_list;
-mod list;
-mod null;
-mod primitive;
-mod structure;
-mod union;
-mod utils;
-mod variable_size;
-
-// these methods assume the same type, len and null count.
-// For this reason, they are not exposed and are instead used
-// to build the generic functions below (`equal_range` and `equal`).
-use boolean::boolean_equal;
-use decimal::decimal_equal;
-use dictionary::dictionary_equal;
-use fixed_binary::fixed_binary_equal;
-use fixed_list::fixed_list_equal;
-use list::list_equal;
-use null::null_equal;
-use primitive::primitive_equal;
-use structure::struct_equal;
-use union::union_equal;
-use variable_size::variable_sized_equal;
-
-impl PartialEq for dyn Array {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl<T: Array> PartialEq<T> for dyn Array {
-    fn eq(&self, other: &T) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl PartialEq for NullArray {
-    fn eq(&self, other: &NullArray) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl<T: ArrowPrimitiveType> PartialEq for PrimitiveArray<T> {
-    fn eq(&self, other: &PrimitiveArray<T>) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl<K: ArrowPrimitiveType> PartialEq for DictionaryArray<K> {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl PartialEq for BooleanArray {
-    fn eq(&self, other: &BooleanArray) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> PartialEq for GenericStringArray<OffsetSize> {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> PartialEq for GenericBinaryArray<OffsetSize> {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl PartialEq for FixedSizeBinaryArray {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl PartialEq for Decimal128Array {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl<OffsetSize: OffsetSizeTrait> PartialEq for GenericListArray<OffsetSize> {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl PartialEq for MapArray {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl PartialEq for FixedSizeListArray {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-impl PartialEq for StructArray {
-    fn eq(&self, other: &Self) -> bool {
-        equal(self.data(), other.data())
-    }
-}
-
-/// Compares the values of two [ArrayData] starting at `lhs_start` and `rhs_start` respectively
-/// for `len` slots.
-#[inline]
-fn equal_values(
-    lhs: &ArrayData,
-    rhs: &ArrayData,
-    lhs_start: usize,
-    rhs_start: usize,
-    len: usize,
-) -> bool {
-    match lhs.data_type() {
-        DataType::Null => null_equal(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Boolean => boolean_equal(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::UInt8 => primitive_equal::<u8>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::UInt16 => primitive_equal::<u16>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::UInt32 => primitive_equal::<u32>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::UInt64 => primitive_equal::<u64>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Int8 => primitive_equal::<i8>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Int16 => primitive_equal::<i16>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Int32 => primitive_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Int64 => primitive_equal::<i64>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Float32 => primitive_equal::<f32>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Float64 => primitive_equal::<f64>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Date32
-        | DataType::Time32(_)
-        | DataType::Interval(IntervalUnit::YearMonth) => {
-            primitive_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len)
-        }
-        DataType::Date64
-        | DataType::Interval(IntervalUnit::DayTime)
-        | DataType::Time64(_)
-        | DataType::Timestamp(_, _)
-        | DataType::Duration(_) => {
-            primitive_equal::<i64>(lhs, rhs, lhs_start, rhs_start, len)
-        }
-        DataType::Interval(IntervalUnit::MonthDayNano) => {
-            primitive_equal::<i128>(lhs, rhs, lhs_start, rhs_start, len)
-        }
-        DataType::Utf8 | DataType::Binary => {
-            variable_sized_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len)
-        }
-        DataType::LargeUtf8 | DataType::LargeBinary => {
-            variable_sized_equal::<i64>(lhs, rhs, lhs_start, rhs_start, len)
-        }
-        DataType::FixedSizeBinary(_) => {
-            fixed_binary_equal(lhs, rhs, lhs_start, rhs_start, len)
-        }
-        DataType::Decimal128(_, _) | DataType::Decimal256(_, _) => {
-            decimal_equal(lhs, rhs, lhs_start, rhs_start, len)
-        }
-        DataType::List(_) => list_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::LargeList(_) => list_equal::<i64>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::FixedSizeList(_, _) => {
-            fixed_list_equal(lhs, rhs, lhs_start, rhs_start, len)
-        }
-        DataType::Struct(_) => struct_equal(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Union(_, _, _) => union_equal(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Dictionary(data_type, _) => match data_type.as_ref() {
-            DataType::Int8 => dictionary_equal::<i8>(lhs, rhs, lhs_start, rhs_start, len),
-            DataType::Int16 => {
-                dictionary_equal::<i16>(lhs, rhs, lhs_start, rhs_start, len)
-            }
-            DataType::Int32 => {
-                dictionary_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len)
-            }
-            DataType::Int64 => {
-                dictionary_equal::<i64>(lhs, rhs, lhs_start, rhs_start, len)
-            }
-            DataType::UInt8 => {
-                dictionary_equal::<u8>(lhs, rhs, lhs_start, rhs_start, len)
-            }
-            DataType::UInt16 => {
-                dictionary_equal::<u16>(lhs, rhs, lhs_start, rhs_start, len)
-            }
-            DataType::UInt32 => {
-                dictionary_equal::<u32>(lhs, rhs, lhs_start, rhs_start, len)
-            }
-            DataType::UInt64 => {
-                dictionary_equal::<u64>(lhs, rhs, lhs_start, rhs_start, len)
-            }
-            _ => unreachable!(),
-        },
-        DataType::Float16 => primitive_equal::<f16>(lhs, rhs, lhs_start, rhs_start, len),
-        DataType::Map(_, _) => list_equal::<i32>(lhs, rhs, lhs_start, rhs_start, len),
-    }
-}
-
-fn equal_range(
-    lhs: &ArrayData,
-    rhs: &ArrayData,
-    lhs_start: usize,
-    rhs_start: usize,
-    len: usize,
-) -> bool {
-    utils::equal_nulls(lhs, rhs, lhs_start, rhs_start, len)
-        && equal_values(lhs, rhs, lhs_start, rhs_start, len)
-}
-
-/// Logically compares two [ArrayData].
-/// Two arrays are logically equal if and only if:
-/// * their data types are equal
-/// * their lengths are equal
-/// * their null counts are equal
-/// * their null bitmaps are equal
-/// * each of their items are equal
-/// two items are equal when their in-memory representation is physically equal (i.e. same bit content).
-/// The physical comparison depend on the data type.
-/// # Panics
-/// This function may panic whenever any of the [ArrayData] does not follow the Arrow specification.
-/// (e.g. wrong number of buffers, buffer `len` does not correspond to the declared `len`)
-pub fn equal(lhs: &ArrayData, rhs: &ArrayData) -> bool {
-    utils::base_equal(lhs, rhs)
-        && lhs.null_count() == rhs.null_count()
-        && utils::equal_nulls(lhs, rhs, 0, 0, lhs.len())
-        && equal_values(lhs, rhs, 0, 0, lhs.len())
-}
-
-#[cfg(test)]
-mod tests {
-    use std::convert::TryFrom;
-    use std::sync::Arc;
-
-    use crate::array::{
-        array::Array, ArrayData, ArrayDataBuilder, ArrayRef, BooleanArray,
-        FixedSizeBinaryBuilder, FixedSizeListBuilder, GenericBinaryArray, Int32Builder,
-        ListBuilder, NullArray, PrimitiveBuilder, StringArray, StringDictionaryBuilder,
-        StructArray, UnionBuilder,
-    };
-    use crate::array::{GenericStringArray, Int32Array};
-    use crate::buffer::Buffer;
-    use crate::datatypes::{Field, Int16Type, Int32Type, ToByteSlice};
-
-    use super::*;
-
-    #[test]
-    fn test_null_equal() {
-        let a = NullArray::new(12);
-        let a = a.data();
-        let b = NullArray::new(12);
-        let b = b.data();
-        test_equal(a, b, true);
-
-        let b = NullArray::new(10);
-        let b = b.data();
-        test_equal(a, b, false);
-
-        // Test the case where offset != 0
-
-        let a_slice = a.slice(2, 3);
-        let b_slice = b.slice(1, 3);
-        test_equal(&a_slice, &b_slice, true);
-
-        let a_slice = a.slice(5, 4);
-        let b_slice = b.slice(3, 3);
-        test_equal(&a_slice, &b_slice, false);
-    }
-
-    #[test]
-    fn test_boolean_equal() {
-        let a = BooleanArray::from(vec![false, false, true]);
-        let a = a.data();
-        let b = BooleanArray::from(vec![false, false, true]);
-        let b = b.data();
-        test_equal(a, b, true);
-
-        let b = BooleanArray::from(vec![false, false, false]);
-        let b = b.data();
-        test_equal(a, b, false);
-    }
-
-    #[test]
-    fn test_boolean_equal_nulls() {
-        let a = BooleanArray::from(vec![Some(false), None, None, Some(true)]);
-        let a = a.data();
-        let b = BooleanArray::from(vec![Some(false), None, None, Some(true)]);
-        let b = b.data();
-        test_equal(a, b, true);
-
-        let b = BooleanArray::from(vec![None, None, None, Some(true)]);
-        let b = b.data();
-        test_equal(a, b, false);
-
-        let b = BooleanArray::from(vec![Some(true), None, None, Some(true)]);
-        let b = b.data();
-        test_equal(a, b, false);
-    }
-
-    #[test]
-    fn test_boolean_equal_offset() {
-        let a = BooleanArray::from(vec![false, true, false, true, false, false, true]);
-        let a = a.data();
-        let b =
-            BooleanArray::from(vec![true, false, false, false, true, false, true, true]);
-        let b = b.data();
-        assert!(!equal(a, b));
-        assert!(!equal(b, a));
-
-        let a_slice = a.slice(2, 3);
-        let b_slice = b.slice(3, 3);
-        assert!(equal(&a_slice, &b_slice));
-        assert!(equal(&b_slice, &a_slice));
-
-        let a_slice = a.slice(3, 4);
-        let b_slice = b.slice(4, 4);
-        assert!(!equal(&a_slice, &b_slice));
-        assert!(!equal(&b_slice, &a_slice));
-
-        // Test the optimization cases where null_count == 0 and starts at 0 and len >= size_of(u8)
-
-        // Elements fill in `u8`'s exactly.
-        let mut vector = vec![false, false, true, true, true, true, true, true];
-        let a = BooleanArray::from(vector.clone());
-        let a = a.data();
-        let b = BooleanArray::from(vector.clone());
-        let b = b.data();
-        test_equal(a, b, true);
-
-        // Elements fill in `u8`s + suffix bits.
-        vector.push(true);
-        let a = BooleanArray::from(vector.clone());
-        let a = a.data();
-        let b = BooleanArray::from(vector);
-        let b = b.data();
-        test_equal(a, b, true);
-    }
-
-    #[test]
-    fn test_primitive() {
-        let cases = vec![
-            (
-                vec![Some(1), Some(2), Some(3)],
-                vec![Some(1), Some(2), Some(3)],
-                true,
-            ),
-            (
-                vec![Some(1), Some(2), Some(3)],
-                vec![Some(1), Some(2), Some(4)],
-                false,
-            ),
-            (
-                vec![Some(1), Some(2), None],
-                vec![Some(1), Some(2), None],
-                true,
-            ),
-            (
-                vec![Some(1), None, Some(3)],
-                vec![Some(1), Some(2), None],
-                false,
-            ),
-            (
-                vec![Some(1), None, None],
-                vec![Some(1), Some(2), None],
-                false,
-            ),
-        ];
-
-        for (lhs, rhs, expected) in cases {
-            let lhs = Int32Array::from(lhs);
-            let lhs = lhs.data();
-            let rhs = Int32Array::from(rhs);
-            let rhs = rhs.data();
-            test_equal(lhs, rhs, expected);
-        }
-    }
-
-    #[test]
-    fn test_primitive_slice() {
-        let cases = vec![
-            (
-                vec![Some(1), Some(2), Some(3)],
-                (0, 1),
-                vec![Some(1), Some(2), Some(3)],
-                (0, 1),
-                true,
-            ),
-            (
-                vec![Some(1), Some(2), Some(3)],
-                (1, 1),
-                vec![Some(1), Some(2), Some(3)],
-                (2, 1),
-                false,
-            ),
-            (
-                vec![Some(1), Some(2), None],
-                (1, 1),
-                vec![Some(1), None, Some(2)],
-                (2, 1),
-                true,
-            ),
-            (
-                vec![None, Some(2), None],
-                (1, 1),
-                vec![None, None, Some(2)],
-                (2, 1),
-                true,
-            ),
-            (
-                vec![Some(1), None, Some(2), None, Some(3)],
-                (2, 2),
-                vec![None, Some(2), None, Some(3)],
-                (1, 2),
-                true,
-            ),
-            (
-                vec![Some(1), Some(2), None, Some(0)],
-                (2, 2),
-                vec![Some(4), Some(5), Some(0), None],
-                (2, 2),
-                false,
-            ),
-        ];
-
-        for (lhs, slice_lhs, rhs, slice_rhs, expected) in cases {
-            let lhs = Int32Array::from(lhs);
-            let lhs = lhs.data();
-            let lhs = lhs.slice(slice_lhs.0, slice_lhs.1);
-            let rhs = Int32Array::from(rhs);
-            let rhs = rhs.data();
-            let rhs = rhs.slice(slice_rhs.0, slice_rhs.1);
-
-            test_equal(&lhs, &rhs, expected);
-        }
-    }
-
-    fn test_equal(lhs: &ArrayData, rhs: &ArrayData, expected: bool) {
-        // equality is symmetric
-        assert!(equal(lhs, lhs), "\n{:?}\n{:?}", lhs, lhs);
-        assert!(equal(rhs, rhs), "\n{:?}\n{:?}", rhs, rhs);
-
-        assert_eq!(equal(lhs, rhs), expected, "\n{:?}\n{:?}", lhs, rhs);
-        assert_eq!(equal(rhs, lhs), expected, "\n{:?}\n{:?}", rhs, lhs);
-    }
-
-    type OptionString = Option<String>;
-
-    fn binary_cases() -> Vec<(Vec<OptionString>, Vec<OptionString>, bool)> {
-        let base = vec![
-            Some("hello".to_owned()),
-            None,
-            None,
-            Some("world".to_owned()),
-            None,
-            None,
-        ];
-        let not_base = vec![
-            Some("hello".to_owned()),
-            Some("foo".to_owned()),
-            None,
-            Some("world".to_owned()),
-            None,
-            None,
-        ];
-        vec![
-            (
-                vec![Some("hello".to_owned()), Some("world".to_owned())],
-                vec![Some("hello".to_owned()), Some("world".to_owned())],
-                true,
-            ),
-            (
-                vec![Some("hello".to_owned()), Some("world".to_owned())],
-                vec![Some("hello".to_owned()), Some("arrow".to_owned())],
-                false,
-            ),
-            (base.clone(), base.clone(), true),
-            (base, not_base, false),
-        ]
-    }
-
-    fn test_generic_string_equal<OffsetSize: OffsetSizeTrait>() {
-        let cases = binary_cases();
-
-        for (lhs, rhs, expected) in cases {
-            let lhs: GenericStringArray<OffsetSize> = lhs.into_iter().collect();
-            let lhs = lhs.data();
-            let rhs: GenericStringArray<OffsetSize> = rhs.into_iter().collect();
-            let rhs = rhs.data();
-            test_equal(lhs, rhs, expected);
-        }
-    }
-
-    #[test]
-    fn test_string_equal() {
-        test_generic_string_equal::<i32>()
-    }
-
-    #[test]
-    fn test_large_string_equal() {
-        test_generic_string_equal::<i64>()
-    }
-
-    fn test_generic_binary_equal<OffsetSize: OffsetSizeTrait>() {
-        let cases = binary_cases();
-
-        for (lhs, rhs, expected) in cases {
-            let lhs = lhs
-                .iter()
-                .map(|x| x.as_deref().map(|x| x.as_bytes()))
-                .collect();
-            let rhs = rhs
-                .iter()
-                .map(|x| x.as_deref().map(|x| x.as_bytes()))
-                .collect();
-            let lhs = GenericBinaryArray::<OffsetSize>::from_opt_vec(lhs);
-            let lhs = lhs.data();
-            let rhs = GenericBinaryArray::<OffsetSize>::from_opt_vec(rhs);
-            let rhs = rhs.data();
-            test_equal(lhs, rhs, expected);
-        }
-    }
-
-    #[test]
-    fn test_binary_equal() {
-        test_generic_binary_equal::<i32>()
-    }
-
-    #[test]
-    fn test_large_binary_equal() {
-        test_generic_binary_equal::<i64>()
-    }
-
-    #[test]
-    fn test_fixed_size_binary_array() {
-        let a_input_arg = vec![vec![1, 2], vec![3, 4], vec![5, 6]];
-        let a = FixedSizeBinaryArray::try_from_iter(a_input_arg.into_iter()).unwrap();
-        let a = a.data();
-
-        let b_input_arg = vec![vec![1, 2], vec![3, 4], vec![5, 6]];
-        let b = FixedSizeBinaryArray::try_from_iter(b_input_arg.into_iter()).unwrap();
-        let b = b.data();
-
-        test_equal(a, b, true);
-    }
-
-    #[test]
-    fn test_string_offset() {
-        let a = StringArray::from(vec![Some("a"), None, Some("b")]);
-        let a = a.data();
-        let a = a.slice(2, 1);
-        let b = StringArray::from(vec![Some("b")]);
-        let b = b.data();
-
-        test_equal(&a, b, true);
-    }
-
-    #[test]
-    fn test_string_offset_larger() {
-        let a = StringArray::from(vec![Some("a"), None, Some("b"), None, Some("c")]);
-        let a = a.data();
-        let b = StringArray::from(vec![None, Some("b"), None, Some("c")]);
-        let b = b.data();
-
-        test_equal(&a.slice(2, 2), &b.slice(0, 2), false);
-        test_equal(&a.slice(2, 2), &b.slice(1, 2), true);
-        test_equal(&a.slice(2, 2), &b.slice(2, 2), false);
-    }
-
-    #[test]
-    fn test_null() {
-        let a = NullArray::new(2);
-        let a = a.data();
-        let b = NullArray::new(2);
-        let b = b.data();
-        test_equal(a, b, true);
-
-        let b = NullArray::new(1);
-        let b = b.data();
-        test_equal(a, b, false);
-    }
-
-    fn create_list_array<U: AsRef<[i32]>, T: AsRef<[Option<U>]>>(data: T) -> ArrayData {
-        let mut builder = ListBuilder::new(Int32Builder::new(10));
-        for d in data.as_ref() {
-            if let Some(v) = d {
-                builder.values().append_slice(v.as_ref());
-                builder.append(true);
-            } else {
-                builder.append(false);
-            }
-        }
-        builder.finish().into_data()
-    }
-
-    #[test]
-    fn test_list_equal() {
-        let a = create_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
-        let b = create_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
-        test_equal(&a, &b, true);
-
-        let b = create_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 7])]);
-        test_equal(&a, &b, false);
-    }
-
-    #[test]
-    fn test_empty_offsets_list_equal() {
-        let empty: Vec<i32> = vec![];
-        let values = Int32Array::from(empty);
-        let empty_offsets: [u8; 0] = [];
-
-        let a = ArrayDataBuilder::new(DataType::List(Box::new(Field::new(
-            "item",
-            DataType::Int32,
-            true,
-        ))))
-        .len(0)
-        .add_buffer(Buffer::from(&empty_offsets))
-        .add_child_data(values.data().clone())
-        .null_bit_buffer(Some(Buffer::from(&empty_offsets)))
-        .build()
-        .unwrap();
-
-        let b = ArrayDataBuilder::new(DataType::List(Box::new(Field::new(
-            "item",
-            DataType::Int32,
-            true,
-        ))))
-        .len(0)
-        .add_buffer(Buffer::from(&empty_offsets))
-        .add_child_data(values.data().clone())
-        .null_bit_buffer(Some(Buffer::from(&empty_offsets)))
-        .build()
-        .unwrap();
-
-        test_equal(&a, &b, true);
-
-        let c = ArrayDataBuilder::new(DataType::List(Box::new(Field::new(
-            "item",
-            DataType::Int32,
-            true,
-        ))))
-        .len(0)
-        .add_buffer(Buffer::from(vec![0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
-        .add_child_data(
-            Int32Array::from(vec![1, 2, -1, -2, 3, 4, -3, -4])
-                .data()
-                .clone(),
-        )
-        .null_bit_buffer(Some(Buffer::from(vec![0b00001001])))
-        .build()
-        .unwrap();
-
-        test_equal(&a, &c, true);
-    }
-
-    // Test the case where null_count > 0
-    #[test]
-    fn test_list_null() {
-        let a =
-            create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
-        let b =
-            create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
-        test_equal(&a, &b, true);
-
-        let b = create_list_array(&[
-            Some(&[1, 2]),
-            None,
-            Some(&[5, 6]),
-            Some(&[3, 4]),
-            None,
-            None,
-        ]);
-        test_equal(&a, &b, false);
-
-        let b =
-            create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]);
-        test_equal(&a, &b, false);
-
-        // a list where the nullness of values is determined by the list's bitmap
-        let c_values = Int32Array::from(vec![1, 2, -1, -2, 3, 4, -3, -4]);
-        let c = ArrayDataBuilder::new(DataType::List(Box::new(Field::new(
-            "item",
-            DataType::Int32,
-            true,
-        ))))
-        .len(6)
-        .add_buffer(Buffer::from(vec![0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
-        .add_child_data(c_values.into_data())
-        .null_bit_buffer(Some(Buffer::from(vec![0b00001001])))
-        .build()
-        .unwrap();
-
-        let d_values = Int32Array::from(vec![
-            Some(1),
-            Some(2),
-            None,
-            None,
-            Some(3),
-            Some(4),
-            None,
-            None,
-        ]);
-        let d = ArrayDataBuilder::new(DataType::List(Box::new(Field::new(
-            "item",
-            DataType::Int32,
-            true,
-        ))))
-        .len(6)
-        .add_buffer(Buffer::from(vec![0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
-        .add_child_data(d_values.into_data())
-        .null_bit_buffer(Some(Buffer::from(vec![0b00001001])))
-        .build()
-        .unwrap();
-        test_equal(&c, &d, true);
-    }
-
-    // Test the case where offset != 0
-    #[test]
-    fn test_list_offsets() {
-        let a =
-            create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
-        let b =
-            create_list_array(&[Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]);
-
-        let a_slice = a.slice(0, 3);
-        let b_slice = b.slice(0, 3);
-        test_equal(&a_slice, &b_slice, true);
-
-        let a_slice = a.slice(0, 5);
-        let b_slice = b.slice(0, 5);
-        test_equal(&a_slice, &b_slice, false);
-
-        let a_slice = a.slice(4, 1);
-        let b_slice = b.slice(4, 1);
-        test_equal(&a_slice, &b_slice, true);
-    }
-
-    fn create_fixed_size_binary_array<U: AsRef<[u8]>, T: AsRef<[Option<U>]>>(
-        data: T,
-    ) -> ArrayData {
-        let mut builder = FixedSizeBinaryBuilder::new(15, 5);
-
-        for d in data.as_ref() {
-            if let Some(v) = d {
-                builder.append_value(v.as_ref()).unwrap();
-            } else {
-                builder.append_null();
-            }
-        }
-        builder.finish().into_data()
-    }
-
-    #[test]
-    fn test_fixed_size_binary_equal() {
-        let a = create_fixed_size_binary_array(&[Some(b"hello"), Some(b"world")]);
-        let b = create_fixed_size_binary_array(&[Some(b"hello"), Some(b"world")]);
-        test_equal(&a, &b, true);
-
-        let b = create_fixed_size_binary_array(&[Some(b"hello"), Some(b"arrow")]);
-        test_equal(&a, &b, false);
-    }
-
-    // Test the case where null_count > 0
-    #[test]
-    fn test_fixed_size_binary_null() {
-        let a = create_fixed_size_binary_array(&[Some(b"hello"), None, Some(b"world")]);
-        let b = create_fixed_size_binary_array(&[Some(b"hello"), None, Some(b"world")]);
-        test_equal(&a, &b, true);
-
-        let b = create_fixed_size_binary_array(&[Some(b"hello"), Some(b"world"), None]);
-        test_equal(&a, &b, false);
-
-        let b = create_fixed_size_binary_array(&[Some(b"hello"), None, Some(b"arrow")]);
-        test_equal(&a, &b, false);
-    }
-
-    #[test]
-    fn test_fixed_size_binary_offsets() {
-        // Test the case where offset != 0
-        let a = create_fixed_size_binary_array(&[
-            Some(b"hello"),
-            None,
-            None,
-            Some(b"world"),
-            None,
-            None,
-        ]);
-        let b = create_fixed_size_binary_array(&[
-            Some(b"hello"),
-            None,
-            None,
-            Some(b"arrow"),
-            None,
-            None,
-        ]);
-
-        let a_slice = a.slice(0, 3);
-        let b_slice = b.slice(0, 3);
-        test_equal(&a_slice, &b_slice, true);
-
-        let a_slice = a.slice(0, 5);
-        let b_slice = b.slice(0, 5);
-        test_equal(&a_slice, &b_slice, false);
-
-        let a_slice = a.slice(4, 1);
-        let b_slice = b.slice(4, 1);
-        test_equal(&a_slice, &b_slice, true);
-
-        let a_slice = a.slice(3, 1);
-        let b_slice = b.slice(3, 1);
-        test_equal(&a_slice, &b_slice, false);
-    }
-
-    fn create_decimal_array(data: &[Option<i128>]) -> ArrayData {
-        data.iter()
-            .collect::<Decimal128Array>()
-            .with_precision_and_scale(23, 6)
-            .unwrap()
-            .into()
-    }
-
-    #[test]
-    fn test_decimal_equal() {
-        let a = create_decimal_array(&[Some(8_887_000_000), Some(-8_887_000_000)]);
-        let b = create_decimal_array(&[Some(8_887_000_000), Some(-8_887_000_000)]);
-        test_equal(&a, &b, true);
-
-        let b = create_decimal_array(&[Some(15_887_000_000), Some(-8_887_000_000)]);
-        test_equal(&a, &b, false);
-    }
-
-    // Test the case where null_count > 0
-    #[test]
-    fn test_decimal_null() {
-        let a = create_decimal_array(&[Some(8_887_000_000), None, Some(-8_887_000_000)]);
-        let b = create_decimal_array(&[Some(8_887_000_000), None, Some(-8_887_000_000)]);
-        test_equal(&a, &b, true);
-
-        let b = create_decimal_array(&[Some(8_887_000_000), Some(-8_887_000_000), None]);
-        test_equal(&a, &b, false);
-
-        let b = create_decimal_array(&[Some(15_887_000_000), None, Some(-8_887_000_000)]);
-        test_equal(&a, &b, false);
-    }
-
-    #[test]
-    fn test_decimal_offsets() {
-        // Test the case where offset != 0
-        let a = create_decimal_array(&[
-            Some(8_887_000_000),
-            None,
-            None,
-            Some(-8_887_000_000),
-            None,
-            None,
-        ]);
-        let b = create_decimal_array(&[
-            None,
-            Some(8_887_000_000),
-            None,
-            None,
-            Some(15_887_000_000),
-            None,
-            None,
-        ]);
-
-        let a_slice = a.slice(0, 3);
-        let b_slice = b.slice(1, 3);
-        test_equal(&a_slice, &b_slice, true);
-
-        let a_slice = a.slice(0, 5);
-        let b_slice = b.slice(1, 5);
-        test_equal(&a_slice, &b_slice, false);
-
-        let a_slice = a.slice(4, 1);
-        let b_slice = b.slice(5, 1);
-        test_equal(&a_slice, &b_slice, true);
-
-        let a_slice = a.slice(3, 3);
-        let b_slice = b.slice(4, 3);
-        test_equal(&a_slice, &b_slice, false);
-
-        let a_slice = a.slice(1, 3);
-        let b_slice = b.slice(2, 3);
-        test_equal(&a_slice, &b_slice, false);
-
-        let b = create_decimal_array(&[
-            None,
-            None,
-            None,
-            Some(-8_887_000_000),
-            Some(-3_000),
-            None,
-        ]);
-        let a_slice = a.slice(1, 3);
-        let b_slice = b.slice(1, 3);
-        test_equal(&a_slice, &b_slice, true);
-    }
-
-    /// Create a fixed size list of 2 value lengths
-    fn create_fixed_size_list_array<U: AsRef<[i32]>, T: AsRef<[Option<U>]>>(
-        data: T,
-    ) -> ArrayData {
-        let mut builder = FixedSizeListBuilder::new(Int32Builder::new(10), 3);
-
-        for d in data.as_ref() {
-            if let Some(v) = d {
-                builder.values().append_slice(v.as_ref());
-                builder.append(true);
-            } else {
-                for _ in 0..builder.value_length() {
-                    builder.values().append_null();
-                }
-                builder.append(false);
-            }
-        }
-        builder.finish().into_data()
-    }
-
-    #[test]
-    fn test_fixed_size_list_equal() {
-        let a = create_fixed_size_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
-        let b = create_fixed_size_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
-        test_equal(&a, &b, true);
-
-        let b = create_fixed_size_list_array(&[Some(&[1, 2, 3]), Some(&[4, 5, 7])]);
-        test_equal(&a, &b, false);
-    }
-
-    // Test the case where null_count > 0
-    #[test]
-    fn test_fixed_list_null() {
-        let a = create_fixed_size_list_array(&[
-            Some(&[1, 2, 3]),
-            None,
-            None,
-            Some(&[4, 5, 6]),
-            None,
-            None,
-        ]);
-        let b = create_fixed_size_list_array(&[
-            Some(&[1, 2, 3]),
-            None,
-            None,
-            Some(&[4, 5, 6]),
-            None,
-            None,
-        ]);
-        test_equal(&a, &b, true);
-
-        let b = create_fixed_size_list_array(&[
-            Some(&[1, 2, 3]),
-            None,
-            Some(&[7, 8, 9]),
-            Some(&[4, 5, 6]),
-            None,
-            None,
-        ]);
-        test_equal(&a, &b, false);
-
-        let b = create_fixed_size_list_array(&[
-            Some(&[1, 2, 3]),
-            None,
-            None,
-            Some(&[3, 6, 9]),
-            None,
-            None,
-        ]);
-        test_equal(&a, &b, false);
-
-        let b = create_fixed_size_list_array(&[None, Some(&[4, 5, 6]), None, None]);
-
-        test_equal(&a.slice(2, 4), &b, true);
-        test_equal(&a.slice(3, 3), &b.slice(1, 3), true);
-    }
-
-    #[test]
-    fn test_fixed_list_offsets() {
-        // Test the case where offset != 0
-        let a = create_fixed_size_list_array(&[
-            Some(&[1, 2, 3]),
-            None,
-            None,
-            Some(&[4, 5, 6]),
-            None,
-            None,
-        ]);
-        let b = create_fixed_size_list_array(&[
-            Some(&[1, 2, 3]),
-            None,
-            None,
-            Some(&[3, 6, 9]),
-            None,
-            None,
-        ]);
-
-        let a_slice = a.slice(0, 3);
-        let b_slice = b.slice(0, 3);
-        test_equal(&a_slice, &b_slice, true);
-
-        let a_slice = a.slice(0, 5);
-        let b_slice = b.slice(0, 5);
-        test_equal(&a_slice, &b_slice, false);
-
-        let a_slice = a.slice(4, 1);
-        let b_slice = b.slice(4, 1);
-        test_equal(&a_slice, &b_slice, true);
-    }
-
-    #[test]
-    fn test_struct_equal() {
-        let strings: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joe"),
-            None,
-            None,
-            Some("mark"),
-            Some("doe"),
-        ]));
-        let ints: ArrayRef = Arc::new(Int32Array::from(vec![
-            Some(1),
-            Some(2),
-            None,
-            Some(4),
-            Some(5),
-        ]));
-
-        let a =
-            StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
-                .unwrap();
-        let a = a.data();
-
-        let b = StructArray::try_from(vec![("f1", strings), ("f2", ints)]).unwrap();
-        let b = b.data();
-
-        test_equal(a, b, true);
-    }
-
-    #[test]
-    fn test_struct_equal_null() {
-        let strings: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joe"),
-            None,
-            None,
-            Some("mark"),
-            Some("doe"),
-        ]));
-        let ints: ArrayRef = Arc::new(Int32Array::from(vec![
-            Some(1),
-            Some(2),
-            None,
-            Some(4),
-            Some(5),
-        ]));
-        let ints_non_null: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 0]));
-
-        let a = ArrayData::builder(DataType::Struct(vec![
-            Field::new("f1", DataType::Utf8, true),
-            Field::new("f2", DataType::Int32, true),
-        ]))
-        .null_bit_buffer(Some(Buffer::from(vec![0b00001011])))
-        .len(5)
-        .add_child_data(strings.data_ref().clone())
-        .add_child_data(ints.data_ref().clone())
-        .build()
-        .unwrap();
-        let a = crate::array::make_array(a);
-
-        let b = ArrayData::builder(DataType::Struct(vec![
-            Field::new("f1", DataType::Utf8, true),
-            Field::new("f2", DataType::Int32, true),
-        ]))
-        .null_bit_buffer(Some(Buffer::from(vec![0b00001011])))
-        .len(5)
-        .add_child_data(strings.data_ref().clone())
-        .add_child_data(ints_non_null.data_ref().clone())
-        .build()
-        .unwrap();
-        let b = crate::array::make_array(b);
-
-        test_equal(a.data_ref(), b.data_ref(), true);
-
-        // test with arrays that are not equal
-        let c_ints_non_null: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 0, 4]));
-        let c = ArrayData::builder(DataType::Struct(vec![
-            Field::new("f1", DataType::Utf8, true),
-            Field::new("f2", DataType::Int32, true),
-        ]))
-        .null_bit_buffer(Some(Buffer::from(vec![0b00001011])))
-        .len(5)
-        .add_child_data(strings.data_ref().clone())
-        .add_child_data(c_ints_non_null.data_ref().clone())
-        .build()
-        .unwrap();
-        let c = crate::array::make_array(c);
-
-        test_equal(a.data_ref(), c.data_ref(), false);
-
-        // test a nested struct
-        let a = ArrayData::builder(DataType::Struct(vec![Field::new(
-            "f3",
-            a.data_type().clone(),
-            true,
-        )]))
-        .null_bit_buffer(Some(Buffer::from(vec![0b00011110])))
-        .len(5)
-        .add_child_data(a.data_ref().clone())
-        .build()
-        .unwrap();
-        let a = crate::array::make_array(a);
-
-        // reconstruct b, but with different data where the first struct is null
-        let strings: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joanne"), // difference
-            None,
-            None,
-            Some("mark"),
-            Some("doe"),
-        ]));
-        let b = ArrayData::builder(DataType::Struct(vec![
-            Field::new("f1", DataType::Utf8, true),
-            Field::new("f2", DataType::Int32, true),
-        ]))
-        .null_bit_buffer(Some(Buffer::from(vec![0b00001011])))
-        .len(5)
-        .add_child_data(strings.data_ref().clone())
-        .add_child_data(ints_non_null.data_ref().clone())
-        .build()
-        .unwrap();
-
-        let b = ArrayData::builder(DataType::Struct(vec![Field::new(
-            "f3",
-            b.data_type().clone(),
-            true,
-        )]))
-        .null_bit_buffer(Some(Buffer::from(vec![0b00011110])))
-        .len(5)
-        .add_child_data(b)
-        .build()
-        .unwrap();
-        let b = crate::array::make_array(b);
-
-        test_equal(a.data_ref(), b.data_ref(), true);
-    }
-
-    #[test]
-    fn test_struct_equal_null_variable_size() {
-        // the string arrays differ, but where the struct array is null
-        let strings1: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joe"),
-            None,
-            None,
-            Some("mark"),
-            Some("doel"),
-        ]));
-        let strings2: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joel"),
-            None,
-            None,
-            Some("mark"),
-            Some("doe"),
-        ]));
-
-        let a = ArrayData::builder(DataType::Struct(vec![Field::new(
-            "f1",
-            DataType::Utf8,
-            true,
-        )]))
-        .null_bit_buffer(Some(Buffer::from(vec![0b00001010])))
-        .len(5)
-        .add_child_data(strings1.data_ref().clone())
-        .build()
-        .unwrap();
-        let a = crate::array::make_array(a);
-
-        let b = ArrayData::builder(DataType::Struct(vec![Field::new(
-            "f1",
-            DataType::Utf8,
-            true,
-        )]))
-        .null_bit_buffer(Some(Buffer::from(vec![0b00001010])))
-        .len(5)
-        .add_child_data(strings2.data_ref().clone())
-        .build()
-        .unwrap();
-        let b = crate::array::make_array(b);
-
-        test_equal(a.data_ref(), b.data_ref(), true);
-
-        // test with arrays that are not equal
-        let strings3: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("mark"),
-            None,
-            None,
-            Some("doe"),
-            Some("joe"),
-        ]));
-        let c = ArrayData::builder(DataType::Struct(vec![Field::new(
-            "f1",
-            DataType::Utf8,
-            true,
-        )]))
-        .null_bit_buffer(Some(Buffer::from(vec![0b00001011])))
-        .len(5)
-        .add_child_data(strings3.data_ref().clone())
-        .build()
-        .unwrap();
-        let c = crate::array::make_array(c);
-
-        test_equal(a.data_ref(), c.data_ref(), false);
-    }
-
-    fn create_dictionary_array(values: &[&str], keys: &[Option<&str>]) -> ArrayData {
-        let values = StringArray::from(values.to_vec());
-        let mut builder = StringDictionaryBuilder::new_with_dictionary(
-            PrimitiveBuilder::<Int16Type>::new(3),
-            &values,
-        )
-        .unwrap();
-        for key in keys {
-            if let Some(v) = key {
-                builder.append(v).unwrap();
-            } else {
-                builder.append_null()
-            }
-        }
-        builder.finish().into_data()
-    }
-
-    #[test]
-    fn test_dictionary_equal() {
-        // (a, b, c), (1, 2, 1, 3) => (a, b, a, c)
-        let a = create_dictionary_array(
-            &["a", "b", "c"],
-            &[Some("a"), Some("b"), Some("a"), Some("c")],
-        );
-        // different representation (values and keys are swapped), same result
-        let b = create_dictionary_array(
-            &["a", "c", "b"],
-            &[Some("a"), Some("b"), Some("a"), Some("c")],
-        );
-        test_equal(&a, &b, true);
-
-        // different len
-        let b =
-            create_dictionary_array(&["a", "c", "b"], &[Some("a"), Some("b"), Some("a")]);
-        test_equal(&a, &b, false);
-
-        // different key
-        let b = create_dictionary_array(
-            &["a", "c", "b"],
-            &[Some("a"), Some("b"), Some("a"), Some("a")],
-        );
-        test_equal(&a, &b, false);
-
-        // different values, same keys
-        let b = create_dictionary_array(
-            &["a", "b", "d"],
-            &[Some("a"), Some("b"), Some("a"), Some("d")],
-        );
-        test_equal(&a, &b, false);
-    }
-
-    #[test]
-    fn test_dictionary_equal_null() {
-        // (a, b, c), (1, 2, 1, 3) => (a, b, a, c)
-        let a = create_dictionary_array(
-            &["a", "b", "c"],
-            &[Some("a"), None, Some("a"), Some("c")],
-        );
-
-        // equal to self
-        test_equal(&a, &a, true);
-
-        // different representation (values and keys are swapped), same result
-        let b = create_dictionary_array(
-            &["a", "c", "b"],
-            &[Some("a"), None, Some("a"), Some("c")],
-        );
-        test_equal(&a, &b, true);
-
-        // different null position
-        let b = create_dictionary_array(
-            &["a", "c", "b"],
-            &[Some("a"), Some("b"), Some("a"), None],
-        );
-        test_equal(&a, &b, false);
-
-        // different key
-        let b = create_dictionary_array(
-            &["a", "c", "b"],
-            &[Some("a"), None, Some("a"), Some("a")],
-        );
-        test_equal(&a, &b, false);
-
-        // different values, same keys
-        let b = create_dictionary_array(
-            &["a", "b", "d"],
-            &[Some("a"), None, Some("a"), Some("d")],
-        );
-        test_equal(&a, &b, false);
-    }
-
-    #[test]
-    fn test_non_null_empty_strings() {
-        let s = StringArray::from(vec![Some(""), Some(""), Some("")]);
-
-        let string1 = s.data();
-
-        let string2 = ArrayData::builder(DataType::Utf8)
-            .len(string1.len())
-            .buffers(string1.buffers().to_vec())
-            .build()
-            .unwrap();
-
-        // string2 is identical to string1 except that it has no validity buffer but since there
-        // are no nulls, string1 and string2 are equal
-        test_equal(string1, &string2, true);
-    }
-
-    #[test]
-    fn test_null_empty_strings() {
-        let s = StringArray::from(vec![Some(""), None, Some("")]);
-
-        let string1 = s.data();
-
-        let string2 = ArrayData::builder(DataType::Utf8)
-            .len(string1.len())
-            .buffers(string1.buffers().to_vec())
-            .build()
-            .unwrap();
-
-        // string2 is identical to string1 except that it has no validity buffer since string1 has
-        // nulls in it, string1 and string2 are not equal
-        test_equal(string1, &string2, false);
-    }
-
-    #[test]
-    fn test_union_equal_dense() {
-        let mut builder = UnionBuilder::new_dense(7);
-        builder.append::<Int32Type>("a", 1).unwrap();
-        builder.append::<Int32Type>("b", 2).unwrap();
-        builder.append::<Int32Type>("c", 3).unwrap();
-        builder.append::<Int32Type>("a", 4).unwrap();
-        builder.append_null::<Int32Type>("a").unwrap();
-        builder.append::<Int32Type>("a", 6).unwrap();
-        builder.append::<Int32Type>("b", 7).unwrap();
-        let union1 = builder.build().unwrap();
-
-        builder = UnionBuilder::new_dense(7);
-        builder.append::<Int32Type>("a", 1).unwrap();
-        builder.append::<Int32Type>("b", 2).unwrap();
-        builder.append::<Int32Type>("c", 3).unwrap();
-        builder.append::<Int32Type>("a", 4).unwrap();
-        builder.append_null::<Int32Type>("a").unwrap();
-        builder.append::<Int32Type>("a", 6).unwrap();
-        builder.append::<Int32Type>("b", 7).unwrap();
-        let union2 = builder.build().unwrap();
-
-        builder = UnionBuilder::new_dense(7);
-        builder.append::<Int32Type>("a", 1).unwrap();
-        builder.append::<Int32Type>("b", 2).unwrap();
-        builder.append::<Int32Type>("c", 3).unwrap();
-        builder.append::<Int32Type>("a", 5).unwrap();
-        builder.append::<Int32Type>("c", 4).unwrap();
-        builder.append::<Int32Type>("a", 6).unwrap();
-        builder.append::<Int32Type>("b", 7).unwrap();
-        let union3 = builder.build().unwrap();
-
-        builder = UnionBuilder::new_dense(7);
-        builder.append::<Int32Type>("a", 1).unwrap();
-        builder.append::<Int32Type>("b", 2).unwrap();
-        builder.append::<Int32Type>("c", 3).unwrap();
-        builder.append::<Int32Type>("a", 4).unwrap();
-        builder.append_null::<Int32Type>("c").unwrap();
-        builder.append_null::<Int32Type>("b").unwrap();
-        builder.append::<Int32Type>("b", 7).unwrap();
-        let union4 = builder.build().unwrap();
-
-        test_equal(union1.data(), union2.data(), true);
-        test_equal(union1.data(), union3.data(), false);
-        test_equal(union1.data(), union4.data(), false);
-    }
-
-    #[test]
-    fn test_union_equal_sparse() {
-        let mut builder = UnionBuilder::new_sparse(7);
-        builder.append::<Int32Type>("a", 1).unwrap();
-        builder.append::<Int32Type>("b", 2).unwrap();
-        builder.append::<Int32Type>("c", 3).unwrap();
-        builder.append::<Int32Type>("a", 4).unwrap();
-        builder.append_null::<Int32Type>("a").unwrap();
-        builder.append::<Int32Type>("a", 6).unwrap();
-        builder.append::<Int32Type>("b", 7).unwrap();
-        let union1 = builder.build().unwrap();
-
-        builder = UnionBuilder::new_sparse(7);
-        builder.append::<Int32Type>("a", 1).unwrap();
-        builder.append::<Int32Type>("b", 2).unwrap();
-        builder.append::<Int32Type>("c", 3).unwrap();
-        builder.append::<Int32Type>("a", 4).unwrap();
-        builder.append_null::<Int32Type>("a").unwrap();
-        builder.append::<Int32Type>("a", 6).unwrap();
-        builder.append::<Int32Type>("b", 7).unwrap();
-        let union2 = builder.build().unwrap();
-
-        builder = UnionBuilder::new_sparse(7);
-        builder.append::<Int32Type>("a", 1).unwrap();
-        builder.append::<Int32Type>("b", 2).unwrap();
-        builder.append::<Int32Type>("c", 3).unwrap();
-        builder.append::<Int32Type>("a", 5).unwrap();
-        builder.append::<Int32Type>("c", 4).unwrap();
-        builder.append::<Int32Type>("a", 6).unwrap();
-        builder.append::<Int32Type>("b", 7).unwrap();
-        let union3 = builder.build().unwrap();
-
-        builder = UnionBuilder::new_sparse(7);
-        builder.append::<Int32Type>("a", 1).unwrap();
-        builder.append::<Int32Type>("b", 2).unwrap();
-        builder.append::<Int32Type>("c", 3).unwrap();
-        builder.append::<Int32Type>("a", 4).unwrap();
-        builder.append_null::<Int32Type>("a").unwrap();
-        builder.append_null::<Int32Type>("a").unwrap();
-        builder.append::<Int32Type>("b", 7).unwrap();
-        let union4 = builder.build().unwrap();
-
-        test_equal(union1.data(), union2.data(), true);
-        test_equal(union1.data(), union3.data(), false);
-        test_equal(union1.data(), union4.data(), false);
-    }
-}
diff --git a/arrow/src/array/equal/primitive.rs b/arrow/src/array/equal/primitive.rs
deleted file mode 100644
index 09882cd78509..000000000000
--- a/arrow/src/array/equal/primitive.rs
+++ /dev/null
@@ -1,70 +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.
-
-use std::mem::size_of;
-
-use crate::array::{data::count_nulls, ArrayData};
-use crate::util::bit_util::get_bit;
-
-use super::utils::equal_len;
-
-pub(super) fn primitive_equal<T>(
-    lhs: &ArrayData,
-    rhs: &ArrayData,
-    lhs_start: usize,
-    rhs_start: usize,
-    len: usize,
-) -> bool {
-    let byte_width = size_of::<T>();
-    let lhs_values = &lhs.buffers()[0].as_slice()[lhs.offset() * byte_width..];
-    let rhs_values = &rhs.buffers()[0].as_slice()[rhs.offset() * byte_width..];
-
-    let lhs_null_count = count_nulls(lhs.null_buffer(), lhs_start + lhs.offset(), len);
-    let rhs_null_count = count_nulls(rhs.null_buffer(), rhs_start + rhs.offset(), len);
-
-    if lhs_null_count == 0 && rhs_null_count == 0 {
-        // without nulls, we just need to compare slices
-        equal_len(
-            lhs_values,
-            rhs_values,
-            lhs_start * byte_width,
-            rhs_start * byte_width,
-            len * byte_width,
-        )
-    } else {
-        // get a ref of the null buffer bytes, to use in testing for nullness
-        let lhs_null_bytes = lhs.null_buffer().as_ref().unwrap().as_slice();
-        let rhs_null_bytes = rhs.null_buffer().as_ref().unwrap().as_slice();
-        // with nulls, we need to compare item by item whenever it is not null
-        (0..len).all(|i| {
-            let lhs_pos = lhs_start + i;
-            let rhs_pos = rhs_start + i;
-            let lhs_is_null = !get_bit(lhs_null_bytes, lhs_pos + lhs.offset());
-            let rhs_is_null = !get_bit(rhs_null_bytes, rhs_pos + rhs.offset());
-
-            lhs_is_null
-                || (lhs_is_null == rhs_is_null)
-                    && equal_len(
-                        lhs_values,
-                        rhs_values,
-                        lhs_pos * byte_width,
-                        rhs_pos * byte_width,
-                        byte_width, // 1 * byte_width since we are comparing a single entry
-                    )
-        })
-    }
-}
diff --git a/arrow/src/array/ffi.rs b/arrow/src/array/ffi.rs
index 72030f900a4e..d4d95a6e1770 100644
--- a/arrow/src/array/ffi.rs
+++ b/arrow/src/array/ffi.rs
@@ -19,42 +19,9 @@
 
 use std::convert::TryFrom;
 
-use crate::{
-    error::{ArrowError, Result},
-    ffi,
-    ffi::ArrowArrayRef,
-};
+use crate::{error::Result, ffi};
 
-use super::{make_array, ArrayData, ArrayRef};
-
-impl TryFrom<ffi::ArrowArray> for ArrayData {
-    type Error = ArrowError;
-
-    fn try_from(value: ffi::ArrowArray) -> Result<Self> {
-        value.to_data()
-    }
-}
-
-impl TryFrom<ArrayData> for ffi::ArrowArray {
-    type Error = ArrowError;
-
-    fn try_from(value: ArrayData) -> Result<Self> {
-        ffi::ArrowArray::try_new(value)
-    }
-}
-
-/// Creates a new array from two FFI pointers. Used to import arrays from the C Data Interface
-/// # Safety
-/// Assumes that these pointers represent valid C Data Interfaces, both in memory
-/// representation and lifetime via the `release` mechanism.
-pub unsafe fn make_array_from_raw(
-    array: *const ffi::FFI_ArrowArray,
-    schema: *const ffi::FFI_ArrowSchema,
-) -> Result<ArrayRef> {
-    let array = ffi::ArrowArray::try_from_raw(array, schema)?;
-    let data = ArrayData::try_from(array)?;
-    Ok(make_array(data))
-}
+use super::ArrayRef;
 
 /// Exports an array to raw pointers of the C Data Interface provided by the consumer.
 /// # Safety
@@ -64,13 +31,14 @@ pub unsafe fn make_array_from_raw(
 /// This function copies the content of two FFI structs [ffi::FFI_ArrowArray] and
 /// [ffi::FFI_ArrowSchema] in the array to the location pointed by the raw pointers.
 /// Usually the raw pointers are provided by the array data consumer.
+#[deprecated(note = "Use FFI_ArrowArray::new and FFI_ArrowSchema::try_from")]
 pub unsafe fn export_array_into_raw(
     src: ArrayRef,
     out_array: *mut ffi::FFI_ArrowArray,
     out_schema: *mut ffi::FFI_ArrowSchema,
 ) -> Result<()> {
-    let data = src.data();
-    let array = ffi::FFI_ArrowArray::new(data);
+    let data = src.to_data();
+    let array = ffi::FFI_ArrowArray::new(&data);
     let schema = ffi::FFI_ArrowSchema::try_from(data.data_type())?;
 
     std::ptr::write_unaligned(out_array, array);
@@ -87,89 +55,77 @@ mod tests {
     use crate::util::bit_util;
     use crate::{
         array::{
-            Array, ArrayData, BooleanArray, FixedSizeBinaryArray, Int64Array,
-            StructArray, UInt32Array, UInt64Array,
+            Array, ArrayData, BooleanArray, FixedSizeBinaryArray, Int64Array, StructArray,
+            UInt32Array, UInt64Array,
         },
         datatypes::{DataType, Field},
-        ffi::ArrowArray,
+        ffi::{from_ffi, FFI_ArrowArray, FFI_ArrowSchema},
     };
     use std::convert::TryFrom;
     use std::sync::Arc;
 
     fn test_round_trip(expected: &ArrayData) -> Result<()> {
-        // create a `ArrowArray` from the data.
-        let d1 = ArrowArray::try_from(expected.clone())?;
-
-        // here we export the array as 2 pointers. We would have no control over ownership if it was not for
-        // the release mechanism.
-        let (array, schema) = ArrowArray::into_raw(d1);
+        // here we export the array
+        let array = FFI_ArrowArray::new(expected);
+        let schema = FFI_ArrowSchema::try_from(expected.data_type())?;
 
         // simulate an external consumer by being the consumer
-        let d1 = unsafe { ArrowArray::try_from_raw(array, schema) }?;
-
-        let result = &ArrayData::try_from(d1)?;
+        let result = &unsafe { from_ffi(array, &schema) }?;
 
         assert_eq!(result, expected);
-
-        unsafe {
-            Arc::from_raw(array);
-            Arc::from_raw(schema);
-        }
         Ok(())
     }
 
     #[test]
     fn test_u32() -> Result<()> {
         let array = UInt32Array::from(vec![Some(2), None, Some(1), None]);
-        let data = array.data();
-        test_round_trip(data)
+        let data = array.into_data();
+        test_round_trip(&data)
     }
 
     #[test]
     fn test_u64() -> Result<()> {
         let array = UInt64Array::from(vec![Some(2), None, Some(1), None]);
-        let data = array.data();
-        test_round_trip(data)
+        let data = array.into_data();
+        test_round_trip(&data)
     }
 
     #[test]
     fn test_i64() -> Result<()> {
         let array = Int64Array::from(vec![Some(2), None, Some(1), None]);
-        let data = array.data();
-        test_round_trip(data)
+        let data = array.into_data();
+        test_round_trip(&data)
     }
 
     #[test]
     fn test_struct() -> Result<()> {
         let inner = StructArray::from(vec![
             (
-                Field::new("a1", DataType::Boolean, false),
-                Arc::new(BooleanArray::from(vec![true, true, false, false]))
-                    as Arc<dyn Array>,
+                Arc::new(Field::new("a1", DataType::Boolean, false)),
+                Arc::new(BooleanArray::from(vec![true, true, false, false])) as Arc<dyn Array>,
             ),
             (
-                Field::new("a2", DataType::UInt32, false),
+                Arc::new(Field::new("a2", DataType::UInt32, false)),
                 Arc::new(UInt32Array::from(vec![1, 2, 3, 4])),
             ),
         ]);
 
         let array = StructArray::from(vec![
             (
-                Field::new("a", inner.data_type().clone(), false),
+                Arc::new(Field::new("a", inner.data_type().clone(), false)),
                 Arc::new(inner) as Arc<dyn Array>,
             ),
             (
-                Field::new("b", DataType::Boolean, false),
-                Arc::new(BooleanArray::from(vec![false, false, true, true]))
-                    as Arc<dyn Array>,
+                Arc::new(Field::new("b", DataType::Boolean, false)),
+                Arc::new(BooleanArray::from(vec![false, false, true, true])) as Arc<dyn Array>,
             ),
             (
-                Field::new("c", DataType::UInt32, false),
+                Arc::new(Field::new("c", DataType::UInt32, false)),
                 Arc::new(UInt32Array::from(vec![42, 28, 19, 31])),
             ),
         ]);
-        let data = array.data();
-        test_round_trip(data)
+        let data = array.into_data();
+        test_round_trip(&data)
     }
 
     #[test]
@@ -187,10 +143,10 @@ mod tests {
             Some(1),
             None,
         ]);
-        let array = DictionaryArray::try_new(&keys, &values)?;
+        let array = DictionaryArray::new(keys, Arc::new(values));
 
-        let data = array.data();
-        test_round_trip(data)
+        let data = array.into_data();
+        test_round_trip(&data)
     }
 
     #[test]
@@ -198,8 +154,8 @@ mod tests {
         let values = vec![vec![10, 10, 10], vec![20, 20, 20], vec![30, 30, 30]];
         let array = FixedSizeBinaryArray::try_from_iter(values.into_iter())?;
 
-        let data = array.data();
-        test_round_trip(data)
+        let data = array.into_data();
+        test_round_trip(&data)
     }
 
     #[test]
@@ -212,29 +168,29 @@ mod tests {
             Some(vec![30, 30, 30]),
             None,
         ];
-        let array = FixedSizeBinaryArray::try_from_sparse_iter(values.into_iter())?;
+        let array = FixedSizeBinaryArray::try_from_sparse_iter_with_size(values.into_iter(), 3)?;
 
-        let data = array.data();
-        test_round_trip(data)
+        let data = array.into_data();
+        test_round_trip(&data)
     }
 
     #[test]
     fn test_fixed_size_list() -> Result<()> {
-        let v: Vec<i64> = (0..9).into_iter().collect();
+        let v: Vec<i64> = (0..9).collect();
         let value_data = ArrayData::builder(DataType::Int64)
             .len(9)
-            .add_buffer(Buffer::from_slice_ref(&v))
+            .add_buffer(Buffer::from_slice_ref(v))
             .build()?;
         let list_data_type =
-            DataType::FixedSizeList(Box::new(Field::new("f", DataType::Int64, false)), 3);
+            DataType::FixedSizeList(Arc::new(Field::new("f", DataType::Int64, false)), 3);
         let list_data = ArrayData::builder(list_data_type)
             .len(3)
             .add_child_data(value_data)
             .build()?;
         let array = FixedSizeListArray::from(list_data);
 
-        let data = array.data();
-        test_round_trip(data)
+        let data = array.into_data();
+        test_round_trip(&data)
     }
 
     #[test]
@@ -245,13 +201,13 @@ mod tests {
         bit_util::set_bit(&mut validity_bits, 2);
         bit_util::set_bit(&mut validity_bits, 6);
 
-        let v: Vec<i16> = (0..16).into_iter().collect();
+        let v: Vec<i16> = (0..16).collect();
         let value_data = ArrayData::builder(DataType::Int16)
             .len(16)
-            .add_buffer(Buffer::from_slice_ref(&v))
+            .add_buffer(Buffer::from_slice_ref(v))
             .build()?;
         let list_data_type =
-            DataType::FixedSizeList(Box::new(Field::new("f", DataType::Int16, false)), 2);
+            DataType::FixedSizeList(Arc::new(Field::new("f", DataType::Int16, false)), 2);
         let list_data = ArrayData::builder(list_data_type)
             .len(8)
             .null_bit_buffer(Some(Buffer::from(validity_bits)))
@@ -259,22 +215,22 @@ mod tests {
             .build()?;
         let array = FixedSizeListArray::from(list_data);
 
-        let data = array.data();
-        test_round_trip(data)
+        let data = array.into_data();
+        test_round_trip(&data)
     }
 
     #[test]
     fn test_fixed_size_list_nested() -> Result<()> {
-        let v: Vec<i32> = (0..16).into_iter().collect();
+        let v: Vec<i32> = (0..16).collect();
         let value_data = ArrayData::builder(DataType::Int32)
             .len(16)
-            .add_buffer(Buffer::from_slice_ref(&v))
+            .add_buffer(Buffer::from_slice_ref(v))
             .build()?;
 
         let offsets: Vec<i32> = vec![0, 2, 4, 6, 8, 10, 12, 14, 16];
-        let value_offsets = Buffer::from_slice_ref(&offsets);
+        let value_offsets = Buffer::from_slice_ref(offsets);
         let inner_list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
+            DataType::List(Arc::new(Field::new("item", DataType::Int32, false)));
         let inner_list_data = ArrayData::builder(inner_list_data_type.clone())
             .len(8)
             .add_buffer(value_offsets)
@@ -285,10 +241,8 @@ mod tests {
         let mut validity_bits: [u8; 1] = [0; 1];
         bit_util::set_bit(&mut validity_bits, 2);
 
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("f", inner_list_data_type, false)),
-            2,
-        );
+        let list_data_type =
+            DataType::FixedSizeList(Arc::new(Field::new("f", inner_list_data_type, false)), 2);
         let list_data = ArrayData::builder(list_data_type)
             .len(4)
             .null_bit_buffer(Some(Buffer::from(validity_bits)))
@@ -297,7 +251,7 @@ mod tests {
 
         let array = FixedSizeListArray::from(list_data);
 
-        let data = array.data();
-        test_round_trip(data)
+        let data = array.into_data();
+        test_round_trip(&data)
     }
 }
diff --git a/arrow/src/array/mod.rs b/arrow/src/array/mod.rs
index 4a7667741597..fa01f4c4c15b 100644
--- a/arrow/src/array/mod.rs
+++ b/arrow/src/array/mod.rs
@@ -15,635 +15,28 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! The central type in Apache Arrow are arrays, which are a known-length sequence of values
-//! all having the same type. This module provides concrete implementations of each type, as
-//! well as an [`Array`] trait that can be used for type-erasure.
+//! Statically typed implementations of Arrow Arrays
 //!
-//! # Downcasting an Array
-//!
-//! Arrays are often passed around as a dynamically typed [`&dyn Array`] or [`ArrayRef`].
-//! For example, [`RecordBatch`](`crate::record_batch::RecordBatch`) stores columns as [`ArrayRef`].
-//!
-//! Whilst these arrays can be passed directly to the
-//! [`compute`](crate::compute), [`csv`](crate::csv),
-//! [`json`](crate::json), etc... APIs, it is often the case that you
-//! wish to interact with the data directly. This requires downcasting
-//! to the concrete type of the array:
-//!
-//! ```
-//! # use arrow::array::{Array, Float32Array, Int32Array};
-//! #
-//! fn sum_int32(array: &dyn Array) -> i32 {
-//!     let integers: &Int32Array = array.as_any().downcast_ref().unwrap();
-//!     integers.iter().map(|val| val.unwrap_or_default()).sum()
-//! }
-//!
-//! // Note: the values for positions corresponding to nulls will be arbitrary
-//! fn as_f32_slice(array: &dyn Array) -> &[f32] {
-//!     array.as_any().downcast_ref::<Float32Array>().unwrap().values()
-//! }
-//! ```
-//!
-//! Additionally, there are convenient functions to do this casting
-//! such as [`as_primitive_array<T>`] and [`as_string_array`]:
-//!
-//! ```
-//! # use arrow::array::*;
-//! # use arrow::datatypes::*;
-//! #
-//! fn as_f32_slice(array: &dyn Array) -> &[f32] {
-//!     // use as_primtive_array
-//!     as_primitive_array::<Float32Type>(array).values()
-//! }
-//! ```
-
-//! # Building an Array
-//!
-//! Most [`Array`] implementations can be constructed directly from iterators or [`Vec`]
-//!
-//! ```
-//! # use arrow::array::Int32Array;
-//! # use arrow::array::StringArray;
-//! # use arrow::array::ListArray;
-//! # use arrow::datatypes::Int32Type;
-//! #
-//! Int32Array::from(vec![1, 2]);
-//! Int32Array::from(vec![Some(1), None]);
-//! Int32Array::from_iter([1, 2, 3, 4]);
-//! Int32Array::from_iter([Some(1), Some(2), None, Some(4)]);
-//!
-//! StringArray::from(vec!["foo", "bar"]);
-//! StringArray::from(vec![Some("foo"), None]);
-//! StringArray::from_iter([Some("foo"), None]);
-//! StringArray::from_iter_values(["foo", "bar"]);
-//!
-//! ListArray::from_iter_primitive::<Int32Type, _, _>([
-//!     Some(vec![Some(1), None, Some(3)]),
-//!     None,
-//!     Some(vec![])
-//! ]);
-//! ```
-//!
-//! Additionally [`ArrayBuilder`](crate::array::ArrayBuilder) implementations can be
-//! used to construct arrays with a push-based interface
-//!
-//! ```
-//! # use arrow::array::Int16Array;
-//! #
-//! // Create a new builder with a capacity of 100
-//! let mut builder = Int16Array::builder(100);
-//!
-//! // Append a single primitive value
-//! builder.append_value(1);
-//!
-//! // Append a null value
-//! builder.append_null();
-//!
-//! // Append a slice of primitive values
-//! builder.append_slice(&[2, 3, 4]);
-//!
-//! // Build the array
-//! let array = builder.finish();
-//!
-//! assert_eq!(
-//!     5,
-//!     array.len(),
-//!     "The array has 5 values, counting the null value"
-//! );
-//!
-//! assert_eq!(2, array.value(2), "Get the value with index 2");
-//!
-//! assert_eq!(
-//!     &array.values()[3..5],
-//!     &[3, 4],
-//!     "Get slice of len 2 starting at idx 3"
-//! )
-//! ```
-//!
-//! # Zero-Copy Slicing
-//!
-//! Given an [`Array`] of arbitrary length, it is possible to create an owned slice of this
-//! data. Internally this just increments some ref-counts, and so is incredibly cheap
-//!
-//! ```rust
-//! # use std::sync::Arc;
-//! # use arrow::array::{Array, Int32Array, ArrayRef};
-//! let array = Arc::new(Int32Array::from_iter([1, 2, 3])) as ArrayRef;
-//!
-//! // Slice with offset 1 and length 2
-//! let sliced = array.slice(1, 2);
-//! let ints = sliced.as_any().downcast_ref::<Int32Array>().unwrap();
-//! assert_eq!(ints.values(), &[2, 3]);
-//! ```
-//!
-//! # Internal Representation
-//!
-//! Internally, arrays are represented by one or several [`Buffer`], the number and meaning of
-//! which depend on the array’s data type, as documented in the [Arrow specification].
-//!
-//! For example, the type `Int16Array` represents an array of 16-bit integers and consists of:
-//!
-//! * An optional [`Bitmap`] identifying any null values
-//! * A contiguous [`Buffer`] of 16-bit integers
-//!
-//! Similarly, the type `StringArray` represents an array of UTF-8 strings and consists of:
-//!
-//! * An optional [`Bitmap`] identifying any null values
-//! * An offsets [`Buffer`] of 32-bit integers identifying valid UTF-8 sequences within the values buffer
-//! * A values [`Buffer`] of UTF-8 encoded string data
-//!
-//! [Arrow specification]: https://arrow.apache.org/docs/format/Columnar.html
-//! [`&dyn Array`]: Array
-//! [`Bitmap`]: crate::bitmap::Bitmap
-//! [`Buffer`]: crate::buffer::Buffer
+//! **See [arrow_array] for examples and usage instructions**
 
-#[allow(clippy::module_inception)]
-mod array;
-mod array_binary;
-mod array_boolean;
-mod array_decimal;
-mod array_dictionary;
-mod array_fixed_size_binary;
-mod array_fixed_size_list;
-mod array_list;
-mod array_map;
-mod array_primitive;
-mod array_string;
-mod array_struct;
-mod array_union;
-mod builder;
-mod cast;
-mod data;
-mod equal;
 #[cfg(feature = "ffi")]
 mod ffi;
-mod iterator;
-mod null;
-mod ord;
-mod raw_pointer;
-mod transform;
-
-use crate::datatypes::*;
 
 // --------------------- Array & ArrayData ---------------------
-
-pub use self::array::Array;
-pub use self::array::ArrayAccessor;
-pub use self::array::ArrayRef;
-pub(crate) use self::data::layout;
-pub use self::data::ArrayData;
-pub use self::data::ArrayDataBuilder;
-pub use self::data::ArrayDataRef;
-pub(crate) use self::data::BufferSpec;
-
-pub use self::array_binary::BinaryArray;
-pub use self::array_binary::LargeBinaryArray;
-pub use self::array_boolean::BooleanArray;
-pub use self::array_decimal::BasicDecimalArray;
-pub use self::array_decimal::Decimal128Array;
-pub use self::array_decimal::Decimal256Array;
-pub use self::array_fixed_size_binary::FixedSizeBinaryArray;
-pub use self::array_fixed_size_list::FixedSizeListArray;
-
-#[deprecated(note = "Please use `Decimal128Array` instead")]
-pub type DecimalArray = Decimal128Array;
-
-pub use self::array_dictionary::{DictionaryArray, TypedDictionaryArray};
-pub use self::array_list::LargeListArray;
-pub use self::array_list::ListArray;
-pub use self::array_map::MapArray;
-pub use self::array_primitive::PrimitiveArray;
-pub use self::array_string::LargeStringArray;
-pub use self::array_string::StringArray;
-pub use self::array_struct::StructArray;
-pub use self::array_union::UnionArray;
-pub use self::null::NullArray;
-
-pub use self::array::make_array;
-pub use self::array::new_empty_array;
-pub use self::array::new_null_array;
-
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::Int8Array;
-/// let arr : Int8Array = [Some(1), Some(2)].into_iter().collect();
-/// ```
-pub type Int8Array = PrimitiveArray<Int8Type>;
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::Int16Array;
-/// let arr : Int16Array = [Some(1), Some(2)].into_iter().collect();
-/// ```
-pub type Int16Array = PrimitiveArray<Int16Type>;
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::Int32Array;
-/// let arr : Int32Array = [Some(1), Some(2)].into_iter().collect();
-/// ```
-pub type Int32Array = PrimitiveArray<Int32Type>;
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::Int64Array;
-/// let arr : Int64Array = [Some(1), Some(2)].into_iter().collect();
-/// ```
-pub type Int64Array = PrimitiveArray<Int64Type>;
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::UInt8Array;
-/// let arr : UInt8Array = [Some(1), Some(2)].into_iter().collect();
-/// ```
-pub type UInt8Array = PrimitiveArray<UInt8Type>;
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::UInt16Array;
-/// let arr : UInt16Array = [Some(1), Some(2)].into_iter().collect();
-/// ```
-pub type UInt16Array = PrimitiveArray<UInt16Type>;
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::UInt32Array;
-/// let arr : UInt32Array = [Some(1), Some(2)].into_iter().collect();
-/// ```
-pub type UInt32Array = PrimitiveArray<UInt32Type>;
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::UInt64Array;
-/// let arr : UInt64Array = [Some(1), Some(2)].into_iter().collect();
-/// ```
-pub type UInt64Array = PrimitiveArray<UInt64Type>;
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::Float16Array;
-/// use half::f16;
-/// let arr : Float16Array = [Some(f16::from_f64(1.0)), Some(f16::from_f64(2.0))].into_iter().collect();
-/// ```
-pub type Float16Array = PrimitiveArray<Float16Type>;
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::Float32Array;
-/// let arr : Float32Array = [Some(1.0), Some(2.0)].into_iter().collect();
-/// ```
-pub type Float32Array = PrimitiveArray<Float32Type>;
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::Float64Array;
-/// let arr : Float64Array = [Some(1.0), Some(2.0)].into_iter().collect();
-/// ```
-pub type Float64Array = PrimitiveArray<Float64Type>;
-
-///
-/// A dictionary array where each element is a single value indexed by an integer key.
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::{Array, Int8DictionaryArray, Int8Array, StringArray};
-/// # use std::sync::Arc;
-///
-/// let array: Int8DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
-/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
-/// assert_eq!(array.keys(), &Int8Array::from(vec![0, 0, 1, 2]));
-/// assert_eq!(array.values(), &values);
-/// ```
-pub type Int8DictionaryArray = DictionaryArray<Int8Type>;
-///
-/// A dictionary array where each element is a single value indexed by an integer key.
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::{Array, Int16DictionaryArray, Int16Array, StringArray};
-/// # use std::sync::Arc;
-///
-/// let array: Int16DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
-/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
-/// assert_eq!(array.keys(), &Int16Array::from(vec![0, 0, 1, 2]));
-/// assert_eq!(array.values(), &values);
-/// ```
-pub type Int16DictionaryArray = DictionaryArray<Int16Type>;
-///
-/// A dictionary array where each element is a single value indexed by an integer key.
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::{Array, Int32DictionaryArray, Int32Array, StringArray};
-/// # use std::sync::Arc;
-///
-/// let array: Int32DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
-/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
-/// assert_eq!(array.keys(), &Int32Array::from(vec![0, 0, 1, 2]));
-/// assert_eq!(array.values(), &values);
-/// ```
-pub type Int32DictionaryArray = DictionaryArray<Int32Type>;
-///
-/// A dictionary array where each element is a single value indexed by an integer key.
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::{Array, Int64DictionaryArray, Int64Array, StringArray};
-/// # use std::sync::Arc;
-///
-/// let array: Int64DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
-/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
-/// assert_eq!(array.keys(), &Int64Array::from(vec![0, 0, 1, 2]));
-/// assert_eq!(array.values(), &values);
-/// ```
-pub type Int64DictionaryArray = DictionaryArray<Int64Type>;
-///
-/// A dictionary array where each element is a single value indexed by an integer key.
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::{Array, UInt8DictionaryArray, UInt8Array, StringArray};
-/// # use std::sync::Arc;
-///
-/// let array: UInt8DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
-/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
-/// assert_eq!(array.keys(), &UInt8Array::from(vec![0, 0, 1, 2]));
-/// assert_eq!(array.values(), &values);
-/// ```
-pub type UInt8DictionaryArray = DictionaryArray<UInt8Type>;
-///
-/// A dictionary array where each element is a single value indexed by an integer key.
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::{Array, UInt16DictionaryArray, UInt16Array, StringArray};
-/// # use std::sync::Arc;
-///
-/// let array: UInt16DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
-/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
-/// assert_eq!(array.keys(), &UInt16Array::from(vec![0, 0, 1, 2]));
-/// assert_eq!(array.values(), &values);
-/// ```
-pub type UInt16DictionaryArray = DictionaryArray<UInt16Type>;
-///
-/// A dictionary array where each element is a single value indexed by an integer key.
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::{Array, UInt32DictionaryArray, UInt32Array, StringArray};
-/// # use std::sync::Arc;
-///
-/// let array: UInt32DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
-/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
-/// assert_eq!(array.keys(), &UInt32Array::from(vec![0, 0, 1, 2]));
-/// assert_eq!(array.values(), &values);
-/// ```
-pub type UInt32DictionaryArray = DictionaryArray<UInt32Type>;
-///
-/// A dictionary array where each element is a single value indexed by an integer key.
-///
-/// # Example: Using `collect`
-/// ```
-/// # use arrow::array::{Array, UInt64DictionaryArray, UInt64Array, StringArray};
-/// # use std::sync::Arc;
-///
-/// let array: UInt64DictionaryArray = vec!["a", "a", "b", "c"].into_iter().collect();
-/// let values: Arc<dyn Array> = Arc::new(StringArray::from(vec!["a", "b", "c"]));
-/// assert_eq!(array.keys(), &UInt64Array::from(vec![0, 0, 1, 2]));
-/// assert_eq!(array.values(), &values);
-/// ```
-pub type UInt64DictionaryArray = DictionaryArray<UInt64Type>;
-///
-/// A primitive array where each element is of type [TimestampSecondType].
-/// See also [`Timestamp`](crate::datatypes::DataType::Timestamp).
-///
-/// # Example: UTC timestamps post epoch
-/// ```
-/// # use arrow::array::TimestampSecondArray;
-/// use chrono::FixedOffset;
-/// // Corresponds to single element array with entry 1970-05-09T14:25:11+0:00
-/// let arr = TimestampSecondArray::from_vec(vec![11111111], None);
-/// // OR
-/// let arr = TimestampSecondArray::from_opt_vec(vec![Some(11111111)], None);
-/// let utc_offset = FixedOffset::east(0);
-///
-/// assert_eq!(arr.value_as_datetime_with_tz(0, utc_offset).map(|v| v.to_string()).unwrap(), "1970-05-09 14:25:11")
-/// ```
-///
-/// # Example: UTC timestamps pre epoch
-/// ```
-/// # use arrow::array::TimestampSecondArray;
-/// use chrono::FixedOffset;
-/// // Corresponds to single element array with entry 1969-08-25T09:34:49+0:00
-/// let arr = TimestampSecondArray::from_vec(vec![-11111111], None);
-/// // OR
-/// let arr = TimestampSecondArray::from_opt_vec(vec![Some(-11111111)], None);
-/// let utc_offset = FixedOffset::east(0);
-///
-/// assert_eq!(arr.value_as_datetime_with_tz(0, utc_offset).map(|v| v.to_string()).unwrap(), "1969-08-25 09:34:49")
-/// ```
-///
-/// # Example: With timezone specified
-/// ```
-/// # use arrow::array::TimestampSecondArray;
-/// use chrono::FixedOffset;
-/// // Corresponds to single element array with entry 1970-05-10T00:25:11+10:00
-/// let arr = TimestampSecondArray::from_vec(vec![11111111], Some("+10:00".to_string()));
-/// // OR
-/// let arr = TimestampSecondArray::from_opt_vec(vec![Some(11111111)], Some("+10:00".to_string()));
-/// let sydney_offset = FixedOffset::east(10 * 60 * 60);
-///
-/// assert_eq!(arr.value_as_datetime_with_tz(0, sydney_offset).map(|v| v.to_string()).unwrap(), "1970-05-10 00:25:11")
-/// ```
-///
-pub type TimestampSecondArray = PrimitiveArray<TimestampSecondType>;
-/// A primitive array where each element is of type `TimestampMillisecondType.`
-/// See examples for [`TimestampSecondArray.`](crate::array::TimestampSecondArray)
-pub type TimestampMillisecondArray = PrimitiveArray<TimestampMillisecondType>;
-/// A primitive array where each element is of type `TimestampMicrosecondType.`
-/// See examples for [`TimestampSecondArray.`](crate::array::TimestampSecondArray)
-pub type TimestampMicrosecondArray = PrimitiveArray<TimestampMicrosecondType>;
-/// A primitive array where each element is of type `TimestampNanosecondType.`
-/// See examples for [`TimestampSecondArray.`](crate::array::TimestampSecondArray)
-pub type TimestampNanosecondArray = PrimitiveArray<TimestampNanosecondType>;
-pub type Date32Array = PrimitiveArray<Date32Type>;
-pub type Date64Array = PrimitiveArray<Date64Type>;
-pub type Time32SecondArray = PrimitiveArray<Time32SecondType>;
-pub type Time32MillisecondArray = PrimitiveArray<Time32MillisecondType>;
-pub type Time64MicrosecondArray = PrimitiveArray<Time64MicrosecondType>;
-pub type Time64NanosecondArray = PrimitiveArray<Time64NanosecondType>;
-pub type IntervalYearMonthArray = PrimitiveArray<IntervalYearMonthType>;
-pub type IntervalDayTimeArray = PrimitiveArray<IntervalDayTimeType>;
-pub type IntervalMonthDayNanoArray = PrimitiveArray<IntervalMonthDayNanoType>;
-pub type DurationSecondArray = PrimitiveArray<DurationSecondType>;
-pub type DurationMillisecondArray = PrimitiveArray<DurationMillisecondType>;
-pub type DurationMicrosecondArray = PrimitiveArray<DurationMicrosecondType>;
-pub type DurationNanosecondArray = PrimitiveArray<DurationNanosecondType>;
-
-pub use self::array_binary::GenericBinaryArray;
-pub use self::array_list::GenericListArray;
-pub use self::array_list::OffsetSizeTrait;
-pub use self::array_string::GenericStringArray;
-
-// --------------------- Array Builder ---------------------
-
-pub use self::builder::ArrayBuilder;
-pub use self::builder::BinaryBuilder;
-pub use self::builder::BooleanBufferBuilder;
-pub use self::builder::BooleanBuilder;
-pub use self::builder::BufferBuilder;
-pub use self::builder::Decimal128Builder;
-pub use self::builder::Decimal256Builder;
-
-#[deprecated(note = "Please use `Decimal128Builder` instead")]
-pub type DecimalBuilder = Decimal128Builder;
-
-pub use self::builder::FixedSizeBinaryBuilder;
-pub use self::builder::FixedSizeListBuilder;
-pub use self::builder::GenericListBuilder;
-pub use self::builder::GenericStringBuilder;
-pub use self::builder::LargeBinaryBuilder;
-pub use self::builder::LargeListBuilder;
-pub use self::builder::LargeStringBuilder;
-pub use self::builder::ListBuilder;
-pub use self::builder::MapBuilder;
-pub use self::builder::PrimitiveBuilder;
-pub use self::builder::PrimitiveDictionaryBuilder;
-pub use self::builder::StringBuilder;
-pub use self::builder::StringDictionaryBuilder;
-pub use self::builder::StructBuilder;
-pub use self::builder::UnionBuilder;
-
-pub use self::builder::make_builder;
-
-pub type Int8BufferBuilder = BufferBuilder<i8>;
-pub type Int16BufferBuilder = BufferBuilder<i16>;
-pub type Int32BufferBuilder = BufferBuilder<i32>;
-pub type Int64BufferBuilder = BufferBuilder<i64>;
-pub type UInt8BufferBuilder = BufferBuilder<u8>;
-pub type UInt16BufferBuilder = BufferBuilder<u16>;
-pub type UInt32BufferBuilder = BufferBuilder<u32>;
-pub type UInt64BufferBuilder = BufferBuilder<u64>;
-pub type Float32BufferBuilder = BufferBuilder<f32>;
-pub type Float64BufferBuilder = BufferBuilder<f64>;
-
-pub type TimestampSecondBufferBuilder =
-    BufferBuilder<<TimestampSecondType as ArrowPrimitiveType>::Native>;
-pub type TimestampMillisecondBufferBuilder =
-    BufferBuilder<<TimestampMillisecondType as ArrowPrimitiveType>::Native>;
-pub type TimestampMicrosecondBufferBuilder =
-    BufferBuilder<<TimestampMicrosecondType as ArrowPrimitiveType>::Native>;
-pub type TimestampNanosecondBufferBuilder =
-    BufferBuilder<<TimestampNanosecondType as ArrowPrimitiveType>::Native>;
-pub type Date32BufferBuilder = BufferBuilder<<Date32Type as ArrowPrimitiveType>::Native>;
-pub type Date64BufferBuilder = BufferBuilder<<Date64Type as ArrowPrimitiveType>::Native>;
-pub type Time32SecondBufferBuilder =
-    BufferBuilder<<Time32SecondType as ArrowPrimitiveType>::Native>;
-pub type Time32MillisecondBufferBuilder =
-    BufferBuilder<<Time32MillisecondType as ArrowPrimitiveType>::Native>;
-pub type Time64MicrosecondBufferBuilder =
-    BufferBuilder<<Time64MicrosecondType as ArrowPrimitiveType>::Native>;
-pub type Time64NanosecondBufferBuilder =
-    BufferBuilder<<Time64NanosecondType as ArrowPrimitiveType>::Native>;
-pub type IntervalYearMonthBufferBuilder =
-    BufferBuilder<<IntervalYearMonthType as ArrowPrimitiveType>::Native>;
-pub type IntervalDayTimeBufferBuilder =
-    BufferBuilder<<IntervalDayTimeType as ArrowPrimitiveType>::Native>;
-pub type IntervalMonthDayNanoBufferBuilder =
-    BufferBuilder<<IntervalMonthDayNanoType as ArrowPrimitiveType>::Native>;
-pub type DurationSecondBufferBuilder =
-    BufferBuilder<<DurationSecondType as ArrowPrimitiveType>::Native>;
-pub type DurationMillisecondBufferBuilder =
-    BufferBuilder<<DurationMillisecondType as ArrowPrimitiveType>::Native>;
-pub type DurationMicrosecondBufferBuilder =
-    BufferBuilder<<DurationMicrosecondType as ArrowPrimitiveType>::Native>;
-pub type DurationNanosecondBufferBuilder =
-    BufferBuilder<<DurationNanosecondType as ArrowPrimitiveType>::Native>;
-
-pub type Int8Builder = PrimitiveBuilder<Int8Type>;
-pub type Int16Builder = PrimitiveBuilder<Int16Type>;
-pub type Int32Builder = PrimitiveBuilder<Int32Type>;
-pub type Int64Builder = PrimitiveBuilder<Int64Type>;
-pub type UInt8Builder = PrimitiveBuilder<UInt8Type>;
-pub type UInt16Builder = PrimitiveBuilder<UInt16Type>;
-pub type UInt32Builder = PrimitiveBuilder<UInt32Type>;
-pub type UInt64Builder = PrimitiveBuilder<UInt64Type>;
-pub type Float32Builder = PrimitiveBuilder<Float32Type>;
-pub type Float64Builder = PrimitiveBuilder<Float64Type>;
-
-pub type TimestampSecondBuilder = PrimitiveBuilder<TimestampSecondType>;
-pub type TimestampMillisecondBuilder = PrimitiveBuilder<TimestampMillisecondType>;
-pub type TimestampMicrosecondBuilder = PrimitiveBuilder<TimestampMicrosecondType>;
-pub type TimestampNanosecondBuilder = PrimitiveBuilder<TimestampNanosecondType>;
-pub type Date32Builder = PrimitiveBuilder<Date32Type>;
-pub type Date64Builder = PrimitiveBuilder<Date64Type>;
-pub type Time32SecondBuilder = PrimitiveBuilder<Time32SecondType>;
-pub type Time32MillisecondBuilder = PrimitiveBuilder<Time32MillisecondType>;
-pub type Time64MicrosecondBuilder = PrimitiveBuilder<Time64MicrosecondType>;
-pub type Time64NanosecondBuilder = PrimitiveBuilder<Time64NanosecondType>;
-pub type IntervalYearMonthBuilder = PrimitiveBuilder<IntervalYearMonthType>;
-pub type IntervalDayTimeBuilder = PrimitiveBuilder<IntervalDayTimeType>;
-pub type IntervalMonthDayNanoBuilder = PrimitiveBuilder<IntervalMonthDayNanoType>;
-pub type DurationSecondBuilder = PrimitiveBuilder<DurationSecondType>;
-pub type DurationMillisecondBuilder = PrimitiveBuilder<DurationMillisecondType>;
-pub type DurationMicrosecondBuilder = PrimitiveBuilder<DurationMicrosecondType>;
-pub type DurationNanosecondBuilder = PrimitiveBuilder<DurationNanosecondType>;
-
-pub use self::transform::{Capacities, MutableArrayData};
-
-// --------------------- Array Iterator ---------------------
-
-pub use self::iterator::*;
-
-// --------------------- Array's values comparison ---------------------
-
-pub use self::ord::{build_compare, DynComparator};
-
-// --------------------- Array downcast helper functions ---------------------
-
-pub use self::cast::{
-    as_boolean_array, as_decimal_array, as_dictionary_array, as_generic_binary_array,
-    as_generic_list_array, as_large_list_array, as_largestring_array, as_list_array,
-    as_map_array, as_null_array, as_primitive_array, as_string_array, as_struct_array,
-    as_union_array,
+pub use arrow_array::builder::*;
+pub use arrow_array::cast::*;
+pub use arrow_array::iterator::*;
+pub use arrow_array::*;
+pub use arrow_data::{
+    layout, ArrayData, ArrayDataBuilder, ArrayDataRef, BufferSpec, DataTypeLayout,
 };
 
-// ------------------------------ C Data Interface ---------------------------
+pub use arrow_data::transform::{Capacities, MutableArrayData};
 
 #[cfg(feature = "ffi")]
-pub use self::ffi::{export_array_into_raw, make_array_from_raw};
+#[allow(deprecated)]
+pub use self::ffi::export_array_into_raw;
 
-#[cfg(test)]
-mod tests {
-    use crate::array::*;
+// --------------------- Array's values comparison ---------------------
 
-    #[test]
-    fn test_buffer_builder_availability() {
-        let _builder = Int8BufferBuilder::new(10);
-        let _builder = Int16BufferBuilder::new(10);
-        let _builder = Int32BufferBuilder::new(10);
-        let _builder = Int64BufferBuilder::new(10);
-        let _builder = UInt16BufferBuilder::new(10);
-        let _builder = UInt32BufferBuilder::new(10);
-        let _builder = Float32BufferBuilder::new(10);
-        let _builder = Float64BufferBuilder::new(10);
-        let _builder = TimestampSecondBufferBuilder::new(10);
-        let _builder = TimestampMillisecondBufferBuilder::new(10);
-        let _builder = TimestampMicrosecondBufferBuilder::new(10);
-        let _builder = TimestampNanosecondBufferBuilder::new(10);
-        let _builder = Date32BufferBuilder::new(10);
-        let _builder = Date64BufferBuilder::new(10);
-        let _builder = Time32SecondBufferBuilder::new(10);
-        let _builder = Time32MillisecondBufferBuilder::new(10);
-        let _builder = Time64MicrosecondBufferBuilder::new(10);
-        let _builder = Time64NanosecondBufferBuilder::new(10);
-        let _builder = IntervalYearMonthBufferBuilder::new(10);
-        let _builder = IntervalDayTimeBufferBuilder::new(10);
-        let _builder = IntervalMonthDayNanoBufferBuilder::new(10);
-        let _builder = DurationSecondBufferBuilder::new(10);
-        let _builder = DurationMillisecondBufferBuilder::new(10);
-        let _builder = DurationMicrosecondBufferBuilder::new(10);
-        let _builder = DurationNanosecondBufferBuilder::new(10);
-    }
-}
+pub use arrow_ord::ord::{build_compare, DynComparator};
diff --git a/arrow/src/array/ord.rs b/arrow/src/array/ord.rs
deleted file mode 100644
index 47173aa7d927..000000000000
--- a/arrow/src/array/ord.rs
+++ /dev/null
@@ -1,342 +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.
-
-//! Contains functions and function factories to compare arrays.
-
-use std::cmp::Ordering;
-
-use crate::array::*;
-use crate::datatypes::TimeUnit;
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-
-use num::Float;
-
-/// Compare the values at two arbitrary indices in two arrays.
-pub type DynComparator = Box<dyn Fn(usize, usize) -> Ordering + Send + Sync>;
-
-/// compares two floats, placing NaNs at last
-fn cmp_nans_last<T: Float>(a: &T, b: &T) -> Ordering {
-    match (a.is_nan(), b.is_nan()) {
-        (true, true) => Ordering::Equal,
-        (true, false) => Ordering::Greater,
-        (false, true) => Ordering::Less,
-        _ => a.partial_cmp(b).unwrap(),
-    }
-}
-
-fn compare_primitives<T: ArrowPrimitiveType>(
-    left: &dyn Array,
-    right: &dyn Array,
-) -> DynComparator
-where
-    T::Native: Ord,
-{
-    let left: PrimitiveArray<T> = PrimitiveArray::from(left.data().clone());
-    let right: PrimitiveArray<T> = PrimitiveArray::from(right.data().clone());
-    Box::new(move |i, j| left.value(i).cmp(&right.value(j)))
-}
-
-fn compare_boolean(left: &dyn Array, right: &dyn Array) -> DynComparator {
-    let left: BooleanArray = BooleanArray::from(left.data().clone());
-    let right: BooleanArray = BooleanArray::from(right.data().clone());
-
-    Box::new(move |i, j| left.value(i).cmp(&right.value(j)))
-}
-
-fn compare_float<T: ArrowPrimitiveType>(
-    left: &dyn Array,
-    right: &dyn Array,
-) -> DynComparator
-where
-    T::Native: Float,
-{
-    let left: PrimitiveArray<T> = PrimitiveArray::from(left.data().clone());
-    let right: PrimitiveArray<T> = PrimitiveArray::from(right.data().clone());
-    Box::new(move |i, j| cmp_nans_last(&left.value(i), &right.value(j)))
-}
-
-fn compare_string<T>(left: &dyn Array, right: &dyn Array) -> DynComparator
-where
-    T: OffsetSizeTrait,
-{
-    let left: StringArray = StringArray::from(left.data().clone());
-    let right: StringArray = StringArray::from(right.data().clone());
-
-    Box::new(move |i, j| left.value(i).cmp(right.value(j)))
-}
-
-fn compare_dict_string<T>(left: &dyn Array, right: &dyn Array) -> DynComparator
-where
-    T: ArrowDictionaryKeyType,
-{
-    let left = left.as_any().downcast_ref::<DictionaryArray<T>>().unwrap();
-    let right = right.as_any().downcast_ref::<DictionaryArray<T>>().unwrap();
-
-    let left_keys: PrimitiveArray<T> = PrimitiveArray::from(left.keys().data().clone());
-    let right_keys: PrimitiveArray<T> = PrimitiveArray::from(right.keys().data().clone());
-    let left_values = StringArray::from(left.values().data().clone());
-    let right_values = StringArray::from(right.values().data().clone());
-
-    Box::new(move |i: usize, j: usize| {
-        let key_left = left_keys.value(i).to_usize().unwrap();
-        let key_right = right_keys.value(j).to_usize().unwrap();
-        let left = left_values.value(key_left);
-        let right = right_values.value(key_right);
-        left.cmp(right)
-    })
-}
-
-/// returns a comparison function that compares two values at two different positions
-/// between the two arrays.
-/// The arrays' types must be equal.
-/// # Example
-/// ```
-/// use arrow::array::{build_compare, Int32Array};
-///
-/// # fn main() -> arrow::error::Result<()> {
-/// let array1 = Int32Array::from(vec![1, 2]);
-/// let array2 = Int32Array::from(vec![3, 4]);
-///
-/// let cmp = build_compare(&array1, &array2)?;
-///
-/// // 1 (index 0 of array1) is smaller than 4 (index 1 of array2)
-/// assert_eq!(std::cmp::Ordering::Less, (cmp)(0, 1));
-/// # Ok(())
-/// # }
-/// ```
-// This is a factory of comparisons.
-// The lifetime 'a enforces that we cannot use the closure beyond any of the array's lifetime.
-pub fn build_compare(left: &dyn Array, right: &dyn Array) -> Result<DynComparator> {
-    use DataType::*;
-    use IntervalUnit::*;
-    use TimeUnit::*;
-    Ok(match (left.data_type(), right.data_type()) {
-        (a, b) if a != b => {
-            return Err(ArrowError::InvalidArgumentError(
-                "Can't compare arrays of different types".to_string(),
-            ));
-        }
-        (Boolean, Boolean) => compare_boolean(left, right),
-        (UInt8, UInt8) => compare_primitives::<UInt8Type>(left, right),
-        (UInt16, UInt16) => compare_primitives::<UInt16Type>(left, right),
-        (UInt32, UInt32) => compare_primitives::<UInt32Type>(left, right),
-        (UInt64, UInt64) => compare_primitives::<UInt64Type>(left, right),
-        (Int8, Int8) => compare_primitives::<Int8Type>(left, right),
-        (Int16, Int16) => compare_primitives::<Int16Type>(left, right),
-        (Int32, Int32) => compare_primitives::<Int32Type>(left, right),
-        (Int64, Int64) => compare_primitives::<Int64Type>(left, right),
-        (Float32, Float32) => compare_float::<Float32Type>(left, right),
-        (Float64, Float64) => compare_float::<Float64Type>(left, right),
-        (Date32, Date32) => compare_primitives::<Date32Type>(left, right),
-        (Date64, Date64) => compare_primitives::<Date64Type>(left, right),
-        (Time32(Second), Time32(Second)) => {
-            compare_primitives::<Time32SecondType>(left, right)
-        }
-        (Time32(Millisecond), Time32(Millisecond)) => {
-            compare_primitives::<Time32MillisecondType>(left, right)
-        }
-        (Time64(Microsecond), Time64(Microsecond)) => {
-            compare_primitives::<Time64MicrosecondType>(left, right)
-        }
-        (Time64(Nanosecond), Time64(Nanosecond)) => {
-            compare_primitives::<Time64NanosecondType>(left, right)
-        }
-        (Timestamp(Second, _), Timestamp(Second, _)) => {
-            compare_primitives::<TimestampSecondType>(left, right)
-        }
-        (Timestamp(Millisecond, _), Timestamp(Millisecond, _)) => {
-            compare_primitives::<TimestampMillisecondType>(left, right)
-        }
-        (Timestamp(Microsecond, _), Timestamp(Microsecond, _)) => {
-            compare_primitives::<TimestampMicrosecondType>(left, right)
-        }
-        (Timestamp(Nanosecond, _), Timestamp(Nanosecond, _)) => {
-            compare_primitives::<TimestampNanosecondType>(left, right)
-        }
-        (Interval(YearMonth), Interval(YearMonth)) => {
-            compare_primitives::<IntervalYearMonthType>(left, right)
-        }
-        (Interval(DayTime), Interval(DayTime)) => {
-            compare_primitives::<IntervalDayTimeType>(left, right)
-        }
-        (Interval(MonthDayNano), Interval(MonthDayNano)) => {
-            compare_primitives::<IntervalMonthDayNanoType>(left, right)
-        }
-        (Duration(Second), Duration(Second)) => {
-            compare_primitives::<DurationSecondType>(left, right)
-        }
-        (Duration(Millisecond), Duration(Millisecond)) => {
-            compare_primitives::<DurationMillisecondType>(left, right)
-        }
-        (Duration(Microsecond), Duration(Microsecond)) => {
-            compare_primitives::<DurationMicrosecondType>(left, right)
-        }
-        (Duration(Nanosecond), Duration(Nanosecond)) => {
-            compare_primitives::<DurationNanosecondType>(left, right)
-        }
-        (Utf8, Utf8) => compare_string::<i32>(left, right),
-        (LargeUtf8, LargeUtf8) => compare_string::<i64>(left, right),
-        (
-            Dictionary(key_type_lhs, value_type_lhs),
-            Dictionary(key_type_rhs, value_type_rhs),
-        ) => {
-            if value_type_lhs.as_ref() != &DataType::Utf8
-                || value_type_rhs.as_ref() != &DataType::Utf8
-            {
-                return Err(ArrowError::InvalidArgumentError(
-                    "Arrow still does not support comparisons of non-string dictionary arrays"
-                        .to_string(),
-                ));
-            }
-            match (key_type_lhs.as_ref(), key_type_rhs.as_ref()) {
-                (a, b) if a != b => {
-                    return Err(ArrowError::InvalidArgumentError(
-                        "Can't compare arrays of different types".to_string(),
-                    ));
-                }
-                (UInt8, UInt8) => compare_dict_string::<UInt8Type>(left, right),
-                (UInt16, UInt16) => compare_dict_string::<UInt16Type>(left, right),
-                (UInt32, UInt32) => compare_dict_string::<UInt32Type>(left, right),
-                (UInt64, UInt64) => compare_dict_string::<UInt64Type>(left, right),
-                (Int8, Int8) => compare_dict_string::<Int8Type>(left, right),
-                (Int16, Int16) => compare_dict_string::<Int16Type>(left, right),
-                (Int32, Int32) => compare_dict_string::<Int32Type>(left, right),
-                (Int64, Int64) => compare_dict_string::<Int64Type>(left, right),
-                (lhs, _) => {
-                    return Err(ArrowError::InvalidArgumentError(format!(
-                        "Dictionaries do not support keys of type {:?}",
-                        lhs
-                    )));
-                }
-            }
-        }
-        (Decimal128(_, _), Decimal128(_, _)) => {
-            let left: Decimal128Array = Decimal128Array::from(left.data().clone());
-            let right: Decimal128Array = Decimal128Array::from(right.data().clone());
-            Box::new(move |i, j| left.value(i).cmp(&right.value(j)))
-        }
-        (lhs, _) => {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "The data type type {:?} has no natural order",
-                lhs
-            )));
-        }
-    })
-}
-
-#[cfg(test)]
-pub mod tests {
-    use super::*;
-    use crate::array::{Float64Array, Int32Array};
-    use crate::error::Result;
-    use std::cmp::Ordering;
-
-    #[test]
-    fn test_i32() -> Result<()> {
-        let array = Int32Array::from(vec![1, 2]);
-
-        let cmp = build_compare(&array, &array)?;
-
-        assert_eq!(Ordering::Less, (cmp)(0, 1));
-        Ok(())
-    }
-
-    #[test]
-    fn test_i32_i32() -> Result<()> {
-        let array1 = Int32Array::from(vec![1]);
-        let array2 = Int32Array::from(vec![2]);
-
-        let cmp = build_compare(&array1, &array2)?;
-
-        assert_eq!(Ordering::Less, (cmp)(0, 0));
-        Ok(())
-    }
-
-    #[test]
-    fn test_f64() -> Result<()> {
-        let array = Float64Array::from(vec![1.0, 2.0]);
-
-        let cmp = build_compare(&array, &array)?;
-
-        assert_eq!(Ordering::Less, (cmp)(0, 1));
-        Ok(())
-    }
-
-    #[test]
-    fn test_f64_nan() -> Result<()> {
-        let array = Float64Array::from(vec![1.0, f64::NAN]);
-
-        let cmp = build_compare(&array, &array)?;
-
-        assert_eq!(Ordering::Less, (cmp)(0, 1));
-        Ok(())
-    }
-
-    #[test]
-    fn test_f64_zeros() -> Result<()> {
-        let array = Float64Array::from(vec![-0.0, 0.0]);
-
-        let cmp = build_compare(&array, &array)?;
-
-        assert_eq!(Ordering::Equal, (cmp)(0, 1));
-        assert_eq!(Ordering::Equal, (cmp)(1, 0));
-        Ok(())
-    }
-
-    #[test]
-    fn test_decimal() -> Result<()> {
-        let array = vec![Some(5), Some(2), Some(3)]
-            .iter()
-            .collect::<Decimal128Array>()
-            .with_precision_and_scale(23, 6)
-            .unwrap();
-
-        let cmp = build_compare(&array, &array)?;
-        assert_eq!(Ordering::Less, (cmp)(1, 0));
-        assert_eq!(Ordering::Greater, (cmp)(0, 2));
-        Ok(())
-    }
-
-    #[test]
-    fn test_dict() -> Result<()> {
-        let data = vec!["a", "b", "c", "a", "a", "c", "c"];
-        let array = data.into_iter().collect::<DictionaryArray<Int16Type>>();
-
-        let cmp = build_compare(&array, &array)?;
-
-        assert_eq!(Ordering::Less, (cmp)(0, 1));
-        assert_eq!(Ordering::Equal, (cmp)(3, 4));
-        assert_eq!(Ordering::Greater, (cmp)(2, 3));
-        Ok(())
-    }
-
-    #[test]
-    fn test_multiple_dict() -> Result<()> {
-        let d1 = vec!["a", "b", "c", "d"];
-        let a1 = d1.into_iter().collect::<DictionaryArray<Int16Type>>();
-        let d2 = vec!["e", "f", "g", "a"];
-        let a2 = d2.into_iter().collect::<DictionaryArray<Int16Type>>();
-
-        let cmp = build_compare(&a1, &a2)?;
-
-        assert_eq!(Ordering::Less, (cmp)(0, 0));
-        assert_eq!(Ordering::Equal, (cmp)(0, 3));
-        assert_eq!(Ordering::Greater, (cmp)(1, 3));
-        Ok(())
-    }
-}
diff --git a/arrow/src/array/raw_pointer.rs b/arrow/src/array/raw_pointer.rs
deleted file mode 100644
index 1016b808bc5a..000000000000
--- a/arrow/src/array/raw_pointer.rs
+++ /dev/null
@@ -1,67 +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.
-
-use std::ptr::NonNull;
-
-/// This struct is highly `unsafe` and offers the possibility to
-/// self-reference a [crate::buffer::Buffer] from
-/// [crate::array::ArrayData], as a pointer to the beginning of its
-/// contents.
-pub(super) struct RawPtrBox<T> {
-    ptr: NonNull<T>,
-}
-
-impl<T> RawPtrBox<T> {
-    /// # Safety
-    /// The user must guarantee that:
-    /// * the contents where `ptr` points to are never `moved`. This is guaranteed when they are Pinned.
-    /// * the lifetime of this struct does not outlive the lifetime of `ptr`.
-    /// Failure to fulfill any the above conditions results in undefined behavior.
-    /// # Panic
-    /// This function panics if:
-    /// * `ptr` is null
-    /// * `ptr` is not aligned to a slice of type `T`. This is guaranteed if it was built from a slice of type `T`.
-    pub(super) unsafe fn new(ptr: *const u8) -> Self {
-        let ptr = NonNull::new(ptr as *mut u8).expect("Pointer cannot be null");
-        assert_eq!(
-            ptr.as_ptr().align_offset(std::mem::align_of::<T>()),
-            0,
-            "memory is not aligned"
-        );
-        Self { ptr: ptr.cast() }
-    }
-
-    pub(super) fn as_ptr(&self) -> *const T {
-        self.ptr.as_ptr()
-    }
-}
-
-unsafe impl<T> Send for RawPtrBox<T> {}
-unsafe impl<T> Sync for RawPtrBox<T> {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    #[should_panic(expected = "memory is not aligned")]
-    #[cfg_attr(miri, ignore)] // sometimes does not panic as expected
-    fn test_primitive_array_alignment() {
-        let bytes = vec![0u8, 1u8];
-        unsafe { RawPtrBox::<u64>::new(bytes.as_ptr().offset(1)) };
-    }
-}
diff --git a/arrow/src/array/transform/list.rs b/arrow/src/array/transform/list.rs
deleted file mode 100644
index 8eb2bd1778d3..000000000000
--- a/arrow/src/array/transform/list.rs
+++ /dev/null
@@ -1,99 +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.
-
-use crate::array::{ArrayData, OffsetSizeTrait};
-
-use super::{
-    Extend, _MutableArrayData,
-    utils::{extend_offsets, get_last_offset},
-};
-
-pub(super) fn build_extend<T: OffsetSizeTrait>(array: &ArrayData) -> Extend {
-    let offsets = array.buffer::<T>(0);
-    if array.null_count() == 0 {
-        // fast case where we can copy regions without nullability checks
-        Box::new(
-            move |mutable: &mut _MutableArrayData,
-                  index: usize,
-                  start: usize,
-                  len: usize| {
-                let offset_buffer = &mut mutable.buffer1;
-
-                // this is safe due to how offset is built. See details on `get_last_offset`
-                let last_offset: T = unsafe { get_last_offset(offset_buffer) };
-
-                // offsets
-                extend_offsets::<T>(
-                    offset_buffer,
-                    last_offset,
-                    &offsets[start..start + len + 1],
-                );
-
-                mutable.child_data[0].extend(
-                    index,
-                    offsets[start].to_usize().unwrap(),
-                    offsets[start + len].to_usize().unwrap(),
-                )
-            },
-        )
-    } else {
-        // nulls present: append item by item, ignoring null entries
-        Box::new(
-            move |mutable: &mut _MutableArrayData,
-                  index: usize,
-                  start: usize,
-                  len: usize| {
-                let offset_buffer = &mut mutable.buffer1;
-
-                // this is safe due to how offset is built. See details on `get_last_offset`
-                let mut last_offset: T = unsafe { get_last_offset(offset_buffer) };
-
-                let delta_len = array.len() - array.null_count();
-                offset_buffer.reserve(delta_len * std::mem::size_of::<T>());
-
-                let child = &mut mutable.child_data[0];
-                (start..start + len).for_each(|i| {
-                    if array.is_valid(i) {
-                        // compute the new offset
-                        last_offset += offsets[i + 1] - offsets[i];
-
-                        // append value
-                        child.extend(
-                            index,
-                            offsets[i].to_usize().unwrap(),
-                            offsets[i + 1].to_usize().unwrap(),
-                        );
-                    }
-                    // append offset
-                    offset_buffer.push(last_offset);
-                })
-            },
-        )
-    }
-}
-
-pub(super) fn extend_nulls<T: OffsetSizeTrait>(
-    mutable: &mut _MutableArrayData,
-    len: usize,
-) {
-    let offset_buffer = &mut mutable.buffer1;
-
-    // this is safe due to how offset is built. See details on `get_last_offset`
-    let last_offset: T = unsafe { get_last_offset(offset_buffer) };
-
-    (0..len).for_each(|_| offset_buffer.push(last_offset))
-}
diff --git a/arrow/src/array/transform/mod.rs b/arrow/src/array/transform/mod.rs
deleted file mode 100644
index f0fccef14fd7..000000000000
--- a/arrow/src/array/transform/mod.rs
+++ /dev/null
@@ -1,1711 +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.
-
-use super::{
-    data::{into_buffers, new_buffers},
-    ArrayData, ArrayDataBuilder, OffsetSizeTrait,
-};
-use crate::{
-    buffer::MutableBuffer,
-    datatypes::DataType,
-    error::{ArrowError, Result},
-    util::bit_util,
-};
-use half::f16;
-use std::mem;
-
-mod boolean;
-mod fixed_binary;
-mod fixed_size_list;
-mod list;
-mod null;
-mod primitive;
-mod structure;
-mod union;
-mod utils;
-mod variable_size;
-
-type ExtendNullBits<'a> = Box<dyn Fn(&mut _MutableArrayData, usize, usize) + 'a>;
-// function that extends `[start..start+len]` to the mutable array.
-// this is dynamic because different data_types influence how buffers and children are extended.
-type Extend<'a> = Box<dyn Fn(&mut _MutableArrayData, usize, usize, usize) + 'a>;
-
-type ExtendNulls = Box<dyn Fn(&mut _MutableArrayData, usize)>;
-
-/// A mutable [ArrayData] that knows how to freeze itself into an [ArrayData].
-/// This is just a data container.
-#[derive(Debug)]
-struct _MutableArrayData<'a> {
-    pub data_type: DataType,
-    pub null_count: usize,
-
-    pub len: usize,
-    pub null_buffer: MutableBuffer,
-
-    // arrow specification only allows up to 3 buffers (2 ignoring the nulls above).
-    // Thus, we place them in the stack to avoid bound checks and greater data locality.
-    pub buffer1: MutableBuffer,
-    pub buffer2: MutableBuffer,
-    pub child_data: Vec<MutableArrayData<'a>>,
-}
-
-impl<'a> _MutableArrayData<'a> {
-    fn freeze(self, dictionary: Option<ArrayData>) -> ArrayDataBuilder {
-        let buffers = into_buffers(&self.data_type, self.buffer1, self.buffer2);
-
-        let child_data = match self.data_type {
-            DataType::Dictionary(_, _) => vec![dictionary.unwrap()],
-            _ => {
-                let mut child_data = Vec::with_capacity(self.child_data.len());
-                for child in self.child_data {
-                    child_data.push(child.freeze());
-                }
-                child_data
-            }
-        };
-
-        ArrayDataBuilder::new(self.data_type)
-            .offset(0)
-            .len(self.len)
-            .null_count(self.null_count)
-            .buffers(buffers)
-            .child_data(child_data)
-            .null_bit_buffer((self.null_count > 0).then(|| self.null_buffer.into()))
-    }
-}
-
-fn build_extend_null_bits(array: &ArrayData, use_nulls: bool) -> ExtendNullBits {
-    if let Some(bitmap) = array.null_bitmap() {
-        let bytes = bitmap.bits.as_slice();
-        Box::new(move |mutable, start, len| {
-            utils::resize_for_bits(&mut mutable.null_buffer, mutable.len + len);
-            mutable.null_count += crate::util::bit_mask::set_bits(
-                mutable.null_buffer.as_slice_mut(),
-                bytes,
-                mutable.len,
-                array.offset() + start,
-                len,
-            );
-        })
-    } else if use_nulls {
-        Box::new(|mutable, _, len| {
-            utils::resize_for_bits(&mut mutable.null_buffer, mutable.len + len);
-            let write_data = mutable.null_buffer.as_slice_mut();
-            let offset = mutable.len;
-            (0..len).for_each(|i| {
-                bit_util::set_bit(write_data, offset + i);
-            });
-        })
-    } else {
-        Box::new(|_, _, _| {})
-    }
-}
-
-/// Struct to efficiently and interactively create an [ArrayData] from an existing [ArrayData] by
-/// copying chunks.
-/// The main use case of this struct is to perform unary operations to arrays of arbitrary types, such as `filter` and `take`.
-/// # Example:
-///
-/// ```
-/// use arrow::{array::{Int32Array, Array, MutableArrayData}};
-///
-/// let array = Int32Array::from(vec![1, 2, 3, 4, 5]);
-/// let array = array.data();
-/// // Create a new `MutableArrayData` from an array and with a capacity of 4.
-/// // Capacity here is equivalent to `Vec::with_capacity`
-/// let arrays = vec![array];
-/// let mut mutable = MutableArrayData::new(arrays, false, 4);
-/// mutable.extend(0, 1, 3); // extend from the slice [1..3], [2,3]
-/// mutable.extend(0, 0, 3); // extend from the slice [0..3], [1,2,3]
-/// // `.freeze()` to convert `MutableArrayData` into a `ArrayData`.
-/// let new_array = Int32Array::from(mutable.freeze());
-/// assert_eq!(Int32Array::from(vec![2, 3, 1, 2, 3]), new_array);
-/// ```
-pub struct MutableArrayData<'a> {
-    #[allow(dead_code)]
-    arrays: Vec<&'a ArrayData>,
-    // The attributes in [_MutableArrayData] cannot be in [MutableArrayData] due to
-    // mutability invariants (interior mutability):
-    // [MutableArrayData] contains a function that can only mutate [_MutableArrayData], not
-    // [MutableArrayData] itself
-    data: _MutableArrayData<'a>,
-
-    // the child data of the `Array` in Dictionary arrays.
-    // This is not stored in `MutableArrayData` because these values constant and only needed
-    // at the end, when freezing [_MutableArrayData].
-    dictionary: Option<ArrayData>,
-
-    // function used to extend values from arrays. This function's lifetime is bound to the array
-    // because it reads values from it.
-    extend_values: Vec<Extend<'a>>,
-    // function used to extend nulls from arrays. This function's lifetime is bound to the array
-    // because it reads nulls from it.
-    extend_null_bits: Vec<ExtendNullBits<'a>>,
-
-    // function used to extend nulls.
-    // this is independent of the arrays and therefore has no lifetime.
-    extend_nulls: ExtendNulls,
-}
-
-impl<'a> std::fmt::Debug for MutableArrayData<'a> {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        // ignores the closures.
-        f.debug_struct("MutableArrayData")
-            .field("data", &self.data)
-            .finish()
-    }
-}
-
-/// Builds an extend that adds `offset` to the source primitive
-/// Additionally validates that `max` fits into the
-/// the underlying primitive returning None if not
-fn build_extend_dictionary(
-    array: &ArrayData,
-    offset: usize,
-    max: usize,
-) -> Option<Extend> {
-    use crate::datatypes::*;
-    macro_rules! validate_and_build {
-        ($dt: ty) => {{
-            let _: $dt = max.try_into().ok()?;
-            let offset: $dt = offset.try_into().ok()?;
-            Some(primitive::build_extend_with_offset(array, offset))
-        }};
-    }
-    match array.data_type() {
-        DataType::Dictionary(child_data_type, _) => match child_data_type.as_ref() {
-            DataType::UInt8 => validate_and_build!(u8),
-            DataType::UInt16 => validate_and_build!(u16),
-            DataType::UInt32 => validate_and_build!(u32),
-            DataType::UInt64 => validate_and_build!(u64),
-            DataType::Int8 => validate_and_build!(i8),
-            DataType::Int16 => validate_and_build!(i16),
-            DataType::Int32 => validate_and_build!(i32),
-            DataType::Int64 => validate_and_build!(i64),
-            _ => unreachable!(),
-        },
-        _ => None,
-    }
-}
-
-fn build_extend(array: &ArrayData) -> Extend {
-    use crate::datatypes::*;
-    match array.data_type() {
-        DataType::Decimal128(_, _) => primitive::build_extend::<i128>(array),
-        DataType::Null => null::build_extend(array),
-        DataType::Boolean => boolean::build_extend(array),
-        DataType::UInt8 => primitive::build_extend::<u8>(array),
-        DataType::UInt16 => primitive::build_extend::<u16>(array),
-        DataType::UInt32 => primitive::build_extend::<u32>(array),
-        DataType::UInt64 => primitive::build_extend::<u64>(array),
-        DataType::Int8 => primitive::build_extend::<i8>(array),
-        DataType::Int16 => primitive::build_extend::<i16>(array),
-        DataType::Int32 => primitive::build_extend::<i32>(array),
-        DataType::Int64 => primitive::build_extend::<i64>(array),
-        DataType::Float32 => primitive::build_extend::<f32>(array),
-        DataType::Float64 => primitive::build_extend::<f64>(array),
-        DataType::Date32
-        | DataType::Time32(_)
-        | DataType::Interval(IntervalUnit::YearMonth) => {
-            primitive::build_extend::<i32>(array)
-        }
-        DataType::Date64
-        | DataType::Time64(_)
-        | DataType::Timestamp(_, _)
-        | DataType::Duration(_)
-        | DataType::Interval(IntervalUnit::DayTime) => {
-            primitive::build_extend::<i64>(array)
-        }
-        DataType::Interval(IntervalUnit::MonthDayNano) => {
-            primitive::build_extend::<i128>(array)
-        }
-        DataType::Utf8 | DataType::Binary => variable_size::build_extend::<i32>(array),
-        DataType::LargeUtf8 | DataType::LargeBinary => {
-            variable_size::build_extend::<i64>(array)
-        }
-        DataType::Map(_, _) | DataType::List(_) => list::build_extend::<i32>(array),
-        DataType::LargeList(_) => list::build_extend::<i64>(array),
-        DataType::Dictionary(_, _) => unreachable!("should use build_extend_dictionary"),
-        DataType::Struct(_) => structure::build_extend(array),
-        DataType::FixedSizeBinary(_) | DataType::Decimal256(_, _) => {
-            fixed_binary::build_extend(array)
-        }
-        DataType::Float16 => primitive::build_extend::<f16>(array),
-        DataType::FixedSizeList(_, _) => fixed_size_list::build_extend(array),
-        DataType::Union(_, _, mode) => match mode {
-            UnionMode::Sparse => union::build_extend_sparse(array),
-            UnionMode::Dense => union::build_extend_dense(array),
-        },
-    }
-}
-
-fn build_extend_nulls(data_type: &DataType) -> ExtendNulls {
-    use crate::datatypes::*;
-    Box::new(match data_type {
-        DataType::Decimal128(_, _) => primitive::extend_nulls::<i128>,
-        DataType::Null => null::extend_nulls,
-        DataType::Boolean => boolean::extend_nulls,
-        DataType::UInt8 => primitive::extend_nulls::<u8>,
-        DataType::UInt16 => primitive::extend_nulls::<u16>,
-        DataType::UInt32 => primitive::extend_nulls::<u32>,
-        DataType::UInt64 => primitive::extend_nulls::<u64>,
-        DataType::Int8 => primitive::extend_nulls::<i8>,
-        DataType::Int16 => primitive::extend_nulls::<i16>,
-        DataType::Int32 => primitive::extend_nulls::<i32>,
-        DataType::Int64 => primitive::extend_nulls::<i64>,
-        DataType::Float32 => primitive::extend_nulls::<f32>,
-        DataType::Float64 => primitive::extend_nulls::<f64>,
-        DataType::Date32
-        | DataType::Time32(_)
-        | DataType::Interval(IntervalUnit::YearMonth) => primitive::extend_nulls::<i32>,
-        DataType::Date64
-        | DataType::Time64(_)
-        | DataType::Timestamp(_, _)
-        | DataType::Duration(_)
-        | DataType::Interval(IntervalUnit::DayTime) => primitive::extend_nulls::<i64>,
-        DataType::Interval(IntervalUnit::MonthDayNano) => primitive::extend_nulls::<i128>,
-        DataType::Utf8 | DataType::Binary => variable_size::extend_nulls::<i32>,
-        DataType::LargeUtf8 | DataType::LargeBinary => variable_size::extend_nulls::<i64>,
-        DataType::Map(_, _) | DataType::List(_) => list::extend_nulls::<i32>,
-        DataType::LargeList(_) => list::extend_nulls::<i64>,
-        DataType::Dictionary(child_data_type, _) => match child_data_type.as_ref() {
-            DataType::UInt8 => primitive::extend_nulls::<u8>,
-            DataType::UInt16 => primitive::extend_nulls::<u16>,
-            DataType::UInt32 => primitive::extend_nulls::<u32>,
-            DataType::UInt64 => primitive::extend_nulls::<u64>,
-            DataType::Int8 => primitive::extend_nulls::<i8>,
-            DataType::Int16 => primitive::extend_nulls::<i16>,
-            DataType::Int32 => primitive::extend_nulls::<i32>,
-            DataType::Int64 => primitive::extend_nulls::<i64>,
-            _ => unreachable!(),
-        },
-        DataType::Struct(_) => structure::extend_nulls,
-        DataType::FixedSizeBinary(_) | DataType::Decimal256(_, _) => {
-            fixed_binary::extend_nulls
-        }
-        DataType::Float16 => primitive::extend_nulls::<f16>,
-        DataType::FixedSizeList(_, _) => fixed_size_list::extend_nulls,
-        DataType::Union(_, _, mode) => match mode {
-            UnionMode::Sparse => union::extend_nulls_sparse,
-            UnionMode::Dense => union::extend_nulls_dense,
-        },
-    })
-}
-
-fn preallocate_offset_and_binary_buffer<Offset: OffsetSizeTrait>(
-    capacity: usize,
-    binary_size: usize,
-) -> [MutableBuffer; 2] {
-    // offsets
-    let mut buffer = MutableBuffer::new((1 + capacity) * mem::size_of::<Offset>());
-    // safety: `unsafe` code assumes that this buffer is initialized with one element
-    buffer.push(Offset::zero());
-
-    [
-        buffer,
-        MutableBuffer::new(binary_size * mem::size_of::<u8>()),
-    ]
-}
-
-/// Define capacities of child data or data buffers.
-#[derive(Debug, Clone)]
-pub enum Capacities {
-    /// Binary, Utf8 and LargeUtf8 data types
-    /// Define
-    /// * the capacity of the array offsets
-    /// * the capacity of the binary/ str buffer
-    Binary(usize, Option<usize>),
-    /// List and LargeList data types
-    /// Define
-    /// * the capacity of the array offsets
-    /// * the capacity of the child data
-    List(usize, Option<Box<Capacities>>),
-    /// Struct type
-    /// * the capacity of the array
-    /// * the capacities of the fields
-    Struct(usize, Option<Vec<Capacities>>),
-    /// Dictionary type
-    /// * the capacity of the array/keys
-    /// * the capacity of the values
-    Dictionary(usize, Option<Box<Capacities>>),
-    /// Don't preallocate inner buffers and rely on array growth strategy
-    Array(usize),
-}
-impl<'a> MutableArrayData<'a> {
-    /// returns a new [MutableArrayData] with capacity to `capacity` slots and specialized to create an
-    /// [ArrayData] from multiple `arrays`.
-    ///
-    /// `use_nulls` is a flag used to optimize insertions. It should be `false` if the only source of nulls
-    /// are the arrays themselves and `true` if the user plans to call [MutableArrayData::extend_nulls].
-    /// In other words, if `use_nulls` is `false`, calling [MutableArrayData::extend_nulls] should not be used.
-    pub fn new(arrays: Vec<&'a ArrayData>, use_nulls: bool, capacity: usize) -> Self {
-        Self::with_capacities(arrays, use_nulls, Capacities::Array(capacity))
-    }
-
-    /// Similar to [MutableArrayData::new], but lets users define the preallocated capacities of the array.
-    /// See also [MutableArrayData::new] for more information on the arguments.
-    ///
-    /// # Panic
-    /// This function panics if the given `capacities` don't match the data type of `arrays`. Or when
-    /// a [Capacities] variant is not yet supported.
-    pub fn with_capacities(
-        arrays: Vec<&'a ArrayData>,
-        use_nulls: bool,
-        capacities: Capacities,
-    ) -> Self {
-        let data_type = arrays[0].data_type();
-        use crate::datatypes::*;
-
-        // if any of the arrays has nulls, insertions from any array requires setting bits
-        // as there is at least one array with nulls.
-        let use_nulls = use_nulls | arrays.iter().any(|array| array.null_count() > 0);
-
-        let mut array_capacity;
-
-        let [buffer1, buffer2] = match (data_type, &capacities) {
-            (
-                DataType::LargeUtf8 | DataType::LargeBinary,
-                Capacities::Binary(capacity, Some(value_cap)),
-            ) => {
-                array_capacity = *capacity;
-                preallocate_offset_and_binary_buffer::<i64>(*capacity, *value_cap)
-            }
-            (
-                DataType::Utf8 | DataType::Binary,
-                Capacities::Binary(capacity, Some(value_cap)),
-            ) => {
-                array_capacity = *capacity;
-                preallocate_offset_and_binary_buffer::<i32>(*capacity, *value_cap)
-            }
-            (_, Capacities::Array(capacity)) => {
-                array_capacity = *capacity;
-                new_buffers(data_type, *capacity)
-            }
-            (
-                DataType::List(_) | DataType::LargeList(_),
-                Capacities::List(capacity, _),
-            ) => {
-                array_capacity = *capacity;
-                new_buffers(data_type, *capacity)
-            }
-            _ => panic!("Capacities: {:?} not yet supported", capacities),
-        };
-
-        let child_data = match &data_type {
-            DataType::Decimal128(_, _)
-            | DataType::Decimal256(_, _)
-            | DataType::Null
-            | DataType::Boolean
-            | DataType::UInt8
-            | DataType::UInt16
-            | DataType::UInt32
-            | DataType::UInt64
-            | DataType::Int8
-            | DataType::Int16
-            | DataType::Int32
-            | DataType::Int64
-            | DataType::Float16
-            | DataType::Float32
-            | DataType::Float64
-            | DataType::Date32
-            | DataType::Date64
-            | DataType::Time32(_)
-            | DataType::Time64(_)
-            | DataType::Duration(_)
-            | DataType::Timestamp(_, _)
-            | DataType::Utf8
-            | DataType::Binary
-            | DataType::LargeUtf8
-            | DataType::LargeBinary
-            | DataType::Interval(_)
-            | DataType::FixedSizeBinary(_) => vec![],
-            DataType::Map(_, _) | DataType::List(_) | DataType::LargeList(_) => {
-                let childs = arrays
-                    .iter()
-                    .map(|array| &array.child_data()[0])
-                    .collect::<Vec<_>>();
-
-                let capacities = if let Capacities::List(capacity, ref child_capacities) =
-                    capacities
-                {
-                    child_capacities
-                        .clone()
-                        .map(|c| *c)
-                        .unwrap_or(Capacities::Array(capacity))
-                } else {
-                    Capacities::Array(array_capacity)
-                };
-
-                vec![MutableArrayData::with_capacities(
-                    childs, use_nulls, capacities,
-                )]
-            }
-            // the dictionary type just appends keys and clones the values.
-            DataType::Dictionary(_, _) => vec![],
-            DataType::Struct(fields) => match capacities {
-                Capacities::Struct(capacity, Some(ref child_capacities)) => {
-                    array_capacity = capacity;
-                    (0..fields.len())
-                        .zip(child_capacities)
-                        .map(|(i, child_cap)| {
-                            let child_arrays = arrays
-                                .iter()
-                                .map(|array| &array.child_data()[i])
-                                .collect::<Vec<_>>();
-                            MutableArrayData::with_capacities(
-                                child_arrays,
-                                use_nulls,
-                                child_cap.clone(),
-                            )
-                        })
-                        .collect::<Vec<_>>()
-                }
-                Capacities::Struct(capacity, None) => {
-                    array_capacity = capacity;
-                    (0..fields.len())
-                        .map(|i| {
-                            let child_arrays = arrays
-                                .iter()
-                                .map(|array| &array.child_data()[i])
-                                .collect::<Vec<_>>();
-                            MutableArrayData::new(child_arrays, use_nulls, capacity)
-                        })
-                        .collect::<Vec<_>>()
-                }
-                _ => (0..fields.len())
-                    .map(|i| {
-                        let child_arrays = arrays
-                            .iter()
-                            .map(|array| &array.child_data()[i])
-                            .collect::<Vec<_>>();
-                        MutableArrayData::new(child_arrays, use_nulls, array_capacity)
-                    })
-                    .collect::<Vec<_>>(),
-            },
-            DataType::FixedSizeList(_, _) => {
-                let childs = arrays
-                    .iter()
-                    .map(|array| &array.child_data()[0])
-                    .collect::<Vec<_>>();
-                vec![MutableArrayData::new(childs, use_nulls, array_capacity)]
-            }
-            DataType::Union(fields, _, _) => (0..fields.len())
-                .map(|i| {
-                    let child_arrays = arrays
-                        .iter()
-                        .map(|array| &array.child_data()[i])
-                        .collect::<Vec<_>>();
-                    MutableArrayData::new(child_arrays, use_nulls, array_capacity)
-                })
-                .collect::<Vec<_>>(),
-        };
-
-        // Get the dictionary if any, and if it is a concatenation of multiple
-        let (dictionary, dict_concat) = match &data_type {
-            DataType::Dictionary(_, _) => {
-                // If more than one dictionary, concatenate dictionaries together
-                let dict_concat = !arrays
-                    .windows(2)
-                    .all(|a| a[0].child_data()[0].ptr_eq(&a[1].child_data()[0]));
-
-                match dict_concat {
-                    false => (Some(arrays[0].child_data()[0].clone()), false),
-                    true => {
-                        if let Capacities::Dictionary(_, _) = capacities {
-                            panic!("dictionary capacity not yet supported")
-                        }
-                        let dictionaries: Vec<_> =
-                            arrays.iter().map(|array| &array.child_data()[0]).collect();
-                        let lengths: Vec<_> = dictionaries
-                            .iter()
-                            .map(|dictionary| dictionary.len())
-                            .collect();
-                        let capacity = lengths.iter().sum();
-
-                        let mut mutable =
-                            MutableArrayData::new(dictionaries, false, capacity);
-
-                        for (i, len) in lengths.iter().enumerate() {
-                            mutable.extend(i, 0, *len)
-                        }
-
-                        (Some(mutable.freeze()), true)
-                    }
-                }
-            }
-            _ => (None, false),
-        };
-
-        let extend_nulls = build_extend_nulls(data_type);
-
-        let extend_null_bits = arrays
-            .iter()
-            .map(|array| build_extend_null_bits(array, use_nulls))
-            .collect();
-
-        let null_buffer = if use_nulls {
-            let null_bytes = bit_util::ceil(array_capacity, 8);
-            MutableBuffer::from_len_zeroed(null_bytes)
-        } else {
-            // create 0 capacity mutable buffer with the intention that it won't be used
-            MutableBuffer::with_capacity(0)
-        };
-
-        let extend_values = match &data_type {
-            DataType::Dictionary(_, _) => {
-                let mut next_offset = 0;
-                let extend_values: Result<Vec<_>> = arrays
-                    .iter()
-                    .map(|array| {
-                        let offset = next_offset;
-                        let dict_len = array.child_data()[0].len();
-
-                        if dict_concat {
-                            next_offset += dict_len;
-                        }
-
-                        build_extend_dictionary(array, offset, offset + dict_len)
-                            .ok_or(ArrowError::DictionaryKeyOverflowError)
-                    })
-                    .collect();
-
-                extend_values.expect("MutableArrayData::new is infallible")
-            }
-            _ => arrays.iter().map(|array| build_extend(array)).collect(),
-        };
-
-        let data = _MutableArrayData {
-            data_type: data_type.clone(),
-            len: 0,
-            null_count: 0,
-            null_buffer,
-            buffer1,
-            buffer2,
-            child_data,
-        };
-        Self {
-            arrays,
-            data,
-            dictionary,
-            extend_values,
-            extend_null_bits,
-            extend_nulls,
-        }
-    }
-
-    /// Extends this array with a chunk of its source arrays
-    ///
-    /// # Arguments
-    /// * `index` - the index of array that you what to copy values from
-    /// * `start` - the start index of the chunk (inclusive)
-    /// * `end` - the end index of the chunk (exclusive)
-    ///
-    /// # Panic
-    /// This function panics if there is an invalid index,
-    /// i.e. `index` >= the number of source arrays
-    /// or `end` > the length of the `index`th array
-    pub fn extend(&mut self, index: usize, start: usize, end: usize) {
-        let len = end - start;
-        (self.extend_null_bits[index])(&mut self.data, start, len);
-        (self.extend_values[index])(&mut self.data, index, start, len);
-        self.data.len += len;
-    }
-
-    /// Extends this [MutableArrayData] with null elements, disregarding the bound arrays
-    pub fn extend_nulls(&mut self, len: usize) {
-        // TODO: null_buffer should probably be extended here as well
-        // otherwise is_valid() could later panic
-        // add test to confirm
-        self.data.null_count += len;
-        (self.extend_nulls)(&mut self.data, len);
-        self.data.len += len;
-    }
-
-    /// Returns the current length
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.data.len
-    }
-
-    /// Returns true if len is 0
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.data.len == 0
-    }
-
-    /// Returns the current null count
-    #[inline]
-    pub fn null_count(&self) -> usize {
-        self.data.null_count
-    }
-
-    /// Creates a [ArrayData] from the pushed regions up to this point, consuming `self`.
-    pub fn freeze(self) -> ArrayData {
-        unsafe { self.data.freeze(self.dictionary).build_unchecked() }
-    }
-
-    /// Creates a [ArrayDataBuilder] from the pushed regions up to this point, consuming `self`.
-    /// This is useful for extending the default behavior of MutableArrayData.
-    pub fn into_builder(self) -> ArrayDataBuilder {
-        self.data.freeze(self.dictionary)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::{convert::TryFrom, sync::Arc};
-
-    use super::*;
-    use crate::array::Decimal128Array;
-    use crate::{
-        array::{
-            Array, ArrayData, ArrayRef, BooleanArray, DictionaryArray,
-            FixedSizeBinaryArray, Int16Array, Int16Type, Int32Array, Int64Array,
-            Int64Builder, ListBuilder, MapBuilder, NullArray, PrimitiveBuilder,
-            StringArray, StringDictionaryBuilder, StructArray, UInt8Array,
-        },
-        buffer::Buffer,
-        datatypes::Field,
-    };
-    use crate::{
-        array::{ListArray, StringBuilder},
-        error::Result,
-    };
-
-    fn create_decimal_array(
-        array: &[Option<i128>],
-        precision: usize,
-        scale: usize,
-    ) -> Decimal128Array {
-        array
-            .iter()
-            .collect::<Decimal128Array>()
-            .with_precision_and_scale(precision, scale)
-            .unwrap()
-    }
-
-    #[test]
-    #[cfg(not(feature = "force_validate"))]
-    fn test_decimal() {
-        let decimal_array =
-            create_decimal_array(&[Some(1), Some(2), None, Some(3)], 10, 3);
-        let arrays = vec![Array::data(&decimal_array)];
-        let mut a = MutableArrayData::new(arrays, true, 3);
-        a.extend(0, 0, 3);
-        a.extend(0, 2, 3);
-        let result = a.freeze();
-        let array = Decimal128Array::from(result);
-        let expected = create_decimal_array(&[Some(1), Some(2), None, None], 10, 3);
-        assert_eq!(array, expected);
-    }
-    #[test]
-    #[cfg(not(feature = "force_validate"))]
-    fn test_decimal_offset() {
-        let decimal_array =
-            create_decimal_array(&[Some(1), Some(2), None, Some(3)], 10, 3);
-        let decimal_array = decimal_array.slice(1, 3); // 2, null, 3
-        let arrays = vec![decimal_array.data()];
-        let mut a = MutableArrayData::new(arrays, true, 2);
-        a.extend(0, 0, 2); // 2, null
-        let result = a.freeze();
-        let array = Decimal128Array::from(result);
-        let expected = create_decimal_array(&[Some(2), None], 10, 3);
-        assert_eq!(array, expected);
-    }
-
-    #[test]
-    #[cfg(not(feature = "force_validate"))]
-    fn test_decimal_null_offset_nulls() {
-        let decimal_array =
-            create_decimal_array(&[Some(1), Some(2), None, Some(3)], 10, 3);
-        let decimal_array = decimal_array.slice(1, 3); // 2, null, 3
-        let arrays = vec![decimal_array.data()];
-        let mut a = MutableArrayData::new(arrays, true, 2);
-        a.extend(0, 0, 2); // 2, null
-        a.extend_nulls(3); // 2, null, null, null, null
-        a.extend(0, 1, 3); //2, null, null, null, null, null, 3
-        let result = a.freeze();
-        let array = Decimal128Array::from(result);
-        let expected = create_decimal_array(
-            &[Some(2), None, None, None, None, None, Some(3)],
-            10,
-            3,
-        );
-        assert_eq!(array, expected);
-    }
-
-    /// tests extending from a primitive array w/ offset nor nulls
-    #[test]
-    fn test_primitive() {
-        let b = UInt8Array::from(vec![Some(1), Some(2), Some(3)]);
-        let arrays = vec![b.data()];
-        let mut a = MutableArrayData::new(arrays, false, 3);
-        a.extend(0, 0, 2);
-        let result = a.freeze();
-        let array = UInt8Array::from(result);
-        let expected = UInt8Array::from(vec![Some(1), Some(2)]);
-        assert_eq!(array, expected);
-    }
-
-    /// tests extending from a primitive array with offset w/ nulls
-    #[test]
-    fn test_primitive_offset() {
-        let b = UInt8Array::from(vec![Some(1), Some(2), Some(3)]);
-        let b = b.slice(1, 2);
-        let arrays = vec![b.data()];
-        let mut a = MutableArrayData::new(arrays, false, 2);
-        a.extend(0, 0, 2);
-        let result = a.freeze();
-        let array = UInt8Array::from(result);
-        let expected = UInt8Array::from(vec![Some(2), Some(3)]);
-        assert_eq!(array, expected);
-    }
-
-    /// tests extending from a primitive array with offset and nulls
-    #[test]
-    fn test_primitive_null_offset() {
-        let b = UInt8Array::from(vec![Some(1), None, Some(3)]);
-        let b = b.slice(1, 2);
-        let arrays = vec![b.data()];
-        let mut a = MutableArrayData::new(arrays, false, 2);
-        a.extend(0, 0, 2);
-        let result = a.freeze();
-        let array = UInt8Array::from(result);
-        let expected = UInt8Array::from(vec![None, Some(3)]);
-        assert_eq!(array, expected);
-    }
-
-    #[test]
-    fn test_primitive_null_offset_nulls() {
-        let b = UInt8Array::from(vec![Some(1), Some(2), Some(3)]);
-        let b = b.slice(1, 2);
-        let arrays = vec![b.data()];
-        let mut a = MutableArrayData::new(arrays, true, 2);
-        a.extend(0, 0, 2);
-        a.extend_nulls(3);
-        a.extend(0, 1, 2);
-        let result = a.freeze();
-        let array = UInt8Array::from(result);
-        let expected =
-            UInt8Array::from(vec![Some(2), Some(3), None, None, None, Some(3)]);
-        assert_eq!(array, expected);
-    }
-
-    #[test]
-    fn test_list_null_offset() {
-        let int_builder = Int64Builder::new(24);
-        let mut builder = ListBuilder::<Int64Builder>::new(int_builder);
-        builder.values().append_slice(&[1, 2, 3]);
-        builder.append(true);
-        builder.values().append_slice(&[4, 5]);
-        builder.append(true);
-        builder.values().append_slice(&[6, 7, 8]);
-        builder.append(true);
-        let array = builder.finish();
-        let arrays = vec![array.data()];
-
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-        mutable.extend(0, 0, 1);
-
-        let result = mutable.freeze();
-        let array = ListArray::from(result);
-
-        let int_builder = Int64Builder::new(24);
-        let mut builder = ListBuilder::<Int64Builder>::new(int_builder);
-        builder.values().append_slice(&[1, 2, 3]);
-        builder.append(true);
-        let expected = builder.finish();
-
-        assert_eq!(array, expected);
-    }
-
-    /// tests extending from a variable-sized (strings and binary) array w/ offset with nulls
-    #[test]
-    fn test_variable_sized_nulls() {
-        let array = StringArray::from(vec![Some("a"), Some("bc"), None, Some("defh")]);
-        let arrays = vec![array.data()];
-
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 1, 3);
-
-        let result = mutable.freeze();
-        let result = StringArray::from(result);
-
-        let expected = StringArray::from(vec![Some("bc"), None]);
-        assert_eq!(result, expected);
-    }
-
-    /// tests extending from a variable-sized (strings and binary) array
-    /// with an offset and nulls
-    #[test]
-    fn test_variable_sized_offsets() {
-        let array = StringArray::from(vec![Some("a"), Some("bc"), None, Some("defh")]);
-        let array = array.slice(1, 3);
-
-        let arrays = vec![array.data()];
-
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 0, 3);
-
-        let result = mutable.freeze();
-        let result = StringArray::from(result);
-
-        let expected = StringArray::from(vec![Some("bc"), None, Some("defh")]);
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_string_offsets() {
-        let array = StringArray::from(vec![Some("a"), Some("bc"), None, Some("defh")]);
-        let array = array.slice(1, 3);
-
-        let arrays = vec![array.data()];
-
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 0, 3);
-
-        let result = mutable.freeze();
-        let result = StringArray::from(result);
-
-        let expected = StringArray::from(vec![Some("bc"), None, Some("defh")]);
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_multiple_with_nulls() {
-        let array1 = StringArray::from(vec!["hello", "world"]);
-        let array2 = StringArray::from(vec![Some("1"), None]);
-
-        let arrays = vec![array1.data(), array2.data()];
-
-        let mut mutable = MutableArrayData::new(arrays, false, 5);
-
-        mutable.extend(0, 0, 2);
-        mutable.extend(1, 0, 2);
-
-        let result = mutable.freeze();
-        let result = StringArray::from(result);
-
-        let expected =
-            StringArray::from(vec![Some("hello"), Some("world"), Some("1"), None]);
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_string_null_offset_nulls() {
-        let array = StringArray::from(vec![Some("a"), Some("bc"), None, Some("defh")]);
-        let array = array.slice(1, 3);
-
-        let arrays = vec![array.data()];
-
-        let mut mutable = MutableArrayData::new(arrays, true, 0);
-
-        mutable.extend(0, 1, 3);
-        mutable.extend_nulls(1);
-
-        let result = mutable.freeze();
-        let result = StringArray::from(result);
-
-        let expected = StringArray::from(vec![None, Some("defh"), None]);
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_bool() {
-        let array = BooleanArray::from(vec![Some(false), Some(true), None, Some(false)]);
-        let arrays = vec![array.data()];
-
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 1, 3);
-
-        let result = mutable.freeze();
-        let result = BooleanArray::from(result);
-
-        let expected = BooleanArray::from(vec![Some(true), None]);
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_null() {
-        let array1 = NullArray::new(10);
-        let array2 = NullArray::new(5);
-        let arrays = vec![array1.data(), array2.data()];
-
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 1, 3);
-        mutable.extend(1, 0, 1);
-
-        let result = mutable.freeze();
-        let result = NullArray::from(result);
-
-        let expected = NullArray::new(3);
-        assert_eq!(result, expected);
-    }
-
-    fn create_dictionary_array(values: &[&str], keys: &[Option<&str>]) -> ArrayData {
-        let values = StringArray::from(values.to_vec());
-        let mut builder = StringDictionaryBuilder::new_with_dictionary(
-            PrimitiveBuilder::<Int16Type>::new(3),
-            &values,
-        )
-        .unwrap();
-        for key in keys {
-            if let Some(v) = key {
-                builder.append(v).unwrap();
-            } else {
-                builder.append_null()
-            }
-        }
-        builder.finish().into_data()
-    }
-
-    #[test]
-    fn test_dictionary() {
-        // (a, b, c), (0, 1, 0, 2) => (a, b, a, c)
-        let array = create_dictionary_array(
-            &["a", "b", "c"],
-            &[Some("a"), Some("b"), None, Some("c")],
-        );
-        let arrays = vec![&array];
-
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 1, 3);
-
-        let result = mutable.freeze();
-        let result = DictionaryArray::from(result);
-
-        let expected = Int16Array::from(vec![Some(1), None]);
-        assert_eq!(result.keys(), &expected);
-    }
-
-    #[test]
-    fn test_struct() {
-        let strings: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joe"),
-            None,
-            None,
-            Some("mark"),
-            Some("doe"),
-        ]));
-        let ints: ArrayRef = Arc::new(Int32Array::from(vec![
-            Some(1),
-            Some(2),
-            Some(3),
-            Some(4),
-            Some(5),
-        ]));
-
-        let array =
-            StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
-                .unwrap();
-        let arrays = vec![array.data()];
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 1, 3);
-        let data = mutable.freeze();
-        let array = StructArray::from(data);
-
-        let expected = StructArray::try_from(vec![
-            ("f1", strings.slice(1, 2)),
-            ("f2", ints.slice(1, 2)),
-        ])
-        .unwrap();
-        assert_eq!(array, expected)
-    }
-
-    #[test]
-    fn test_struct_offset() {
-        let strings: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joe"),
-            None,
-            None,
-            Some("mark"),
-            Some("doe"),
-        ]));
-        let ints: ArrayRef = Arc::new(Int32Array::from(vec![
-            Some(1),
-            Some(2),
-            Some(3),
-            Some(4),
-            Some(5),
-        ]));
-
-        let array =
-            StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
-                .unwrap()
-                .slice(1, 3);
-        let arrays = vec![array.data()];
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 1, 3);
-        let data = mutable.freeze();
-        let array = StructArray::from(data);
-
-        let expected_strings: ArrayRef =
-            Arc::new(StringArray::from(vec![None, Some("mark")]));
-        let expected = StructArray::try_from(vec![
-            ("f1", expected_strings),
-            ("f2", ints.slice(2, 2)),
-        ])
-        .unwrap();
-
-        assert_eq!(array, expected);
-    }
-
-    #[test]
-    fn test_struct_nulls() {
-        let strings: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joe"),
-            None,
-            None,
-            Some("mark"),
-            Some("doe"),
-        ]));
-        let ints: ArrayRef = Arc::new(Int32Array::from(vec![
-            Some(1),
-            Some(2),
-            None,
-            Some(4),
-            Some(5),
-        ]));
-
-        let array =
-            StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
-                .unwrap();
-        let arrays = vec![array.data()];
-
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 1, 3);
-        let data = mutable.freeze();
-        let array = StructArray::from(data);
-
-        let expected_string = Arc::new(StringArray::from(vec![None, None])) as ArrayRef;
-        let expected_int = Arc::new(Int32Array::from(vec![Some(2), None])) as ArrayRef;
-
-        let expected =
-            StructArray::try_from(vec![("f1", expected_string), ("f2", expected_int)])
-                .unwrap();
-        assert_eq!(array, expected)
-    }
-
-    #[test]
-    fn test_struct_many() {
-        let strings: ArrayRef = Arc::new(StringArray::from(vec![
-            Some("joe"),
-            None,
-            None,
-            Some("mark"),
-            Some("doe"),
-        ]));
-        let ints: ArrayRef = Arc::new(Int32Array::from(vec![
-            Some(1),
-            Some(2),
-            None,
-            Some(4),
-            Some(5),
-        ]));
-
-        let array =
-            StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
-                .unwrap();
-        let arrays = vec![array.data(), array.data()];
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 1, 3);
-        mutable.extend(1, 0, 2);
-        let data = mutable.freeze();
-        let array = StructArray::from(data);
-
-        let expected_string =
-            Arc::new(StringArray::from(vec![None, None, Some("joe"), None])) as ArrayRef;
-        let expected_int =
-            Arc::new(Int32Array::from(vec![Some(2), None, Some(1), Some(2)])) as ArrayRef;
-
-        let expected =
-            StructArray::try_from(vec![("f1", expected_string), ("f2", expected_int)])
-                .unwrap();
-        assert_eq!(array, expected)
-    }
-
-    #[test]
-    fn test_binary_fixed_sized_offsets() {
-        let array = FixedSizeBinaryArray::try_from_iter(
-            vec![vec![0, 0], vec![0, 1], vec![0, 2]].into_iter(),
-        )
-        .expect("Failed to create FixedSizeBinaryArray from iterable");
-        let array = array.slice(1, 2);
-        // = [[0, 1], [0, 2]] due to the offset = 1
-
-        let arrays = vec![array.data()];
-
-        let mut mutable = MutableArrayData::new(arrays, false, 0);
-
-        mutable.extend(0, 1, 2);
-        mutable.extend(0, 0, 1);
-
-        let result = mutable.freeze();
-        let result = FixedSizeBinaryArray::from(result);
-
-        let expected =
-            FixedSizeBinaryArray::try_from_iter(vec![vec![0, 2], vec![0, 1]].into_iter())
-                .expect("Failed to create FixedSizeBinaryArray from iterable");
-        assert_eq!(result, expected);
-    }
-
-    #[test]
-    fn test_list_append() {
-        let mut builder = ListBuilder::<Int64Builder>::new(Int64Builder::new(24));
-        builder.values().append_slice(&[1, 2, 3]);
-        builder.append(true);
-        builder.values().append_slice(&[4, 5]);
-        builder.append(true);
-        builder.values().append_slice(&[6, 7, 8]);
-        builder.values().append_slice(&[9, 10, 11]);
-        builder.append(true);
-        let a = builder.finish();
-
-        let a_builder = Int64Builder::new(24);
-        let mut a_builder = ListBuilder::<Int64Builder>::new(a_builder);
-        a_builder.values().append_slice(&[12, 13]);
-        a_builder.append(true);
-        a_builder.append(true);
-        a_builder.values().append_slice(&[14, 15]);
-        a_builder.append(true);
-        let b = a_builder.finish();
-
-        let c = b.slice(1, 2);
-
-        let mut mutable =
-            MutableArrayData::new(vec![a.data(), b.data(), c.data()], false, 1);
-        mutable.extend(0, 0, a.len());
-        mutable.extend(1, 0, b.len());
-        mutable.extend(2, 0, c.len());
-
-        let finished = mutable.freeze();
-
-        let expected_int_array = Int64Array::from(vec![
-            Some(1),
-            Some(2),
-            Some(3),
-            Some(4),
-            Some(5),
-            Some(6),
-            Some(7),
-            Some(8),
-            Some(9),
-            Some(10),
-            Some(11),
-            // append first array
-            Some(12),
-            Some(13),
-            Some(14),
-            Some(15),
-            // append second array
-            Some(14),
-            Some(15),
-        ]);
-        let list_value_offsets =
-            Buffer::from_slice_ref(&[0i32, 3, 5, 11, 13, 13, 15, 15, 17]);
-        let expected_list_data = ArrayData::try_new(
-            DataType::List(Box::new(Field::new("item", DataType::Int64, true))),
-            8,
-            None,
-            0,
-            vec![list_value_offsets],
-            vec![expected_int_array.into_data()],
-        )
-        .unwrap();
-        assert_eq!(finished, expected_list_data);
-    }
-
-    #[test]
-    fn test_list_nulls_append() -> Result<()> {
-        let mut builder = ListBuilder::<Int64Builder>::new(Int64Builder::new(32));
-        builder.values().append_slice(&[1, 2, 3]);
-        builder.append(true);
-        builder.values().append_slice(&[4, 5]);
-        builder.append(true);
-        builder.append(false);
-        builder.values().append_slice(&[6, 7, 8]);
-        builder.values().append_null();
-        builder.values().append_null();
-        builder.values().append_slice(&[9, 10, 11]);
-        builder.append(true);
-        let a = builder.finish();
-        let a = a.data();
-
-        let mut builder = ListBuilder::<Int64Builder>::new(Int64Builder::new(32));
-        builder.values().append_slice(&[12, 13]);
-        builder.append(true);
-        builder.append(false);
-        builder.append(true);
-        builder.values().append_null();
-        builder.values().append_null();
-        builder.values().append_slice(&[14, 15]);
-        builder.append(true);
-        let b = builder.finish();
-        let b = b.data();
-        let c = b.slice(1, 2);
-        let d = b.slice(2, 2);
-
-        let mut mutable = MutableArrayData::new(vec![a, b, &c, &d], false, 10);
-
-        mutable.extend(0, 0, a.len());
-        mutable.extend(1, 0, b.len());
-        mutable.extend(2, 0, c.len());
-        mutable.extend(3, 0, d.len());
-        let result = mutable.freeze();
-
-        let expected_int_array = Int64Array::from(vec![
-            Some(1),
-            Some(2),
-            Some(3),
-            Some(4),
-            Some(5),
-            Some(6),
-            Some(7),
-            Some(8),
-            None,
-            None,
-            Some(9),
-            Some(10),
-            Some(11),
-            // second array
-            Some(12),
-            Some(13),
-            None,
-            None,
-            Some(14),
-            Some(15),
-            // slice(1, 2) results in no values added
-            None,
-            None,
-            Some(14),
-            Some(15),
-        ]);
-        let list_value_offsets =
-            Buffer::from_slice_ref(&[0, 3, 5, 5, 13, 15, 15, 15, 19, 19, 19, 19, 23]);
-        let expected_list_data = ArrayData::try_new(
-            DataType::List(Box::new(Field::new("item", DataType::Int64, true))),
-            12,
-            Some(Buffer::from(&[0b11011011, 0b1110])),
-            0,
-            vec![list_value_offsets],
-            vec![expected_int_array.into_data()],
-        )
-        .unwrap();
-        assert_eq!(result, expected_list_data);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_list_append_with_capacities() {
-        let mut builder = ListBuilder::<Int64Builder>::new(Int64Builder::new(24));
-        builder.values().append_slice(&[1, 2, 3]);
-        builder.append(true);
-        builder.values().append_slice(&[4, 5]);
-        builder.append(true);
-        builder.values().append_slice(&[6, 7, 8]);
-        builder.values().append_slice(&[9, 10, 11]);
-        builder.append(true);
-        let a = builder.finish();
-
-        let a_builder = Int64Builder::new(24);
-        let mut a_builder = ListBuilder::<Int64Builder>::new(a_builder);
-        a_builder.values().append_slice(&[12, 13]);
-        a_builder.append(true);
-        a_builder.append(true);
-        a_builder.values().append_slice(&[14, 15, 16, 17]);
-        a_builder.append(true);
-        let b = a_builder.finish();
-
-        let mutable = MutableArrayData::with_capacities(
-            vec![a.data(), b.data()],
-            false,
-            Capacities::List(6, Some(Box::new(Capacities::Array(17)))),
-        );
-
-        // capacities are rounded up to multiples of 64 by MutableBuffer
-        assert_eq!(mutable.data.buffer1.capacity(), 64);
-        assert_eq!(mutable.data.child_data[0].data.buffer1.capacity(), 192);
-    }
-
-    #[test]
-    fn test_map_nulls_append() -> Result<()> {
-        let mut builder = MapBuilder::<Int64Builder, Int64Builder>::new(
-            None,
-            Int64Builder::new(32),
-            Int64Builder::new(32),
-        );
-        builder.keys().append_slice(&[1, 2, 3]);
-        builder.values().append_slice(&[1, 2, 3]);
-        builder.append(true).unwrap();
-        builder.keys().append_slice(&[4, 5]);
-        builder.values().append_slice(&[4, 5]);
-        builder.append(true).unwrap();
-        builder.append(false).unwrap();
-        builder.keys().append_slice(&[6, 7, 8, 100, 101, 9, 10, 11]);
-        builder.values().append_slice(&[6, 7, 8]);
-        builder.values().append_null();
-        builder.values().append_null();
-        builder.values().append_slice(&[9, 10, 11]);
-        builder.append(true).unwrap();
-
-        let a = builder.finish();
-        let a = a.data();
-
-        let mut builder = MapBuilder::<Int64Builder, Int64Builder>::new(
-            None,
-            Int64Builder::new(32),
-            Int64Builder::new(32),
-        );
-
-        builder.keys().append_slice(&[12, 13]);
-        builder.values().append_slice(&[12, 13]);
-        builder.append(true).unwrap();
-        builder.append(false).unwrap();
-        builder.append(true).unwrap();
-        builder.keys().append_slice(&[100, 101, 14, 15]);
-        builder.values().append_null();
-        builder.values().append_null();
-        builder.values().append_slice(&[14, 15]);
-        builder.append(true).unwrap();
-
-        let b = builder.finish();
-        let b = b.data();
-        let c = b.slice(1, 2);
-        let d = b.slice(2, 2);
-
-        let mut mutable = MutableArrayData::new(vec![a, b, &c, &d], false, 10);
-
-        mutable.extend(0, 0, a.len());
-        mutable.extend(1, 0, b.len());
-        mutable.extend(2, 0, c.len());
-        mutable.extend(3, 0, d.len());
-        let result = mutable.freeze();
-
-        let expected_key_array = Int64Array::from(vec![
-            Some(1),
-            Some(2),
-            Some(3),
-            Some(4),
-            Some(5),
-            Some(6),
-            Some(7),
-            Some(8),
-            Some(100),
-            Some(101),
-            Some(9),
-            Some(10),
-            Some(11),
-            // second array
-            Some(12),
-            Some(13),
-            Some(100),
-            Some(101),
-            Some(14),
-            Some(15),
-            // slice(1, 2) results in no values added
-            Some(100),
-            Some(101),
-            Some(14),
-            Some(15),
-        ]);
-
-        let expected_value_array = Int64Array::from(vec![
-            Some(1),
-            Some(2),
-            Some(3),
-            Some(4),
-            Some(5),
-            Some(6),
-            Some(7),
-            Some(8),
-            None,
-            None,
-            Some(9),
-            Some(10),
-            Some(11),
-            // second array
-            Some(12),
-            Some(13),
-            None,
-            None,
-            Some(14),
-            Some(15),
-            // slice(1, 2) results in no values added
-            None,
-            None,
-            Some(14),
-            Some(15),
-        ]);
-
-        let expected_entry_array = StructArray::from(vec![
-            (
-                Field::new("keys", DataType::Int64, false),
-                Arc::new(expected_key_array) as ArrayRef,
-            ),
-            (
-                Field::new("values", DataType::Int64, true),
-                Arc::new(expected_value_array) as ArrayRef,
-            ),
-        ]);
-
-        let map_offsets =
-            Buffer::from_slice_ref(&[0, 3, 5, 5, 13, 15, 15, 15, 19, 19, 19, 19, 23]);
-
-        let expected_list_data = ArrayData::try_new(
-            DataType::Map(
-                Box::new(Field::new(
-                    "entries",
-                    DataType::Struct(vec![
-                        Field::new("keys", DataType::Int64, false),
-                        Field::new("values", DataType::Int64, true),
-                    ]),
-                    false,
-                )),
-                false,
-            ),
-            12,
-            Some(Buffer::from(&[0b11011011, 0b1110])),
-            0,
-            vec![map_offsets],
-            vec![expected_entry_array.into_data()],
-        )
-        .unwrap();
-        assert_eq!(result, expected_list_data);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_list_of_strings_append() -> Result<()> {
-        // [["alpha", "beta", None]]
-        let mut builder = ListBuilder::new(StringBuilder::new(32));
-        builder.values().append_value("Hello");
-        builder.values().append_value("Arrow");
-        builder.values().append_null();
-        builder.append(true);
-        let a = builder.finish();
-
-        // [["alpha", "beta"], [None], ["gamma", "delta", None]]
-        let mut builder = ListBuilder::new(StringBuilder::new(32));
-        builder.values().append_value("alpha");
-        builder.values().append_value("beta");
-        builder.append(true);
-        builder.values().append_null();
-        builder.append(true);
-        builder.values().append_value("gamma");
-        builder.values().append_value("delta");
-        builder.values().append_null();
-        builder.append(true);
-        let b = builder.finish();
-
-        let mut mutable = MutableArrayData::new(vec![a.data(), b.data()], false, 10);
-
-        mutable.extend(0, 0, a.len());
-        mutable.extend(1, 0, b.len());
-        mutable.extend(1, 1, 3);
-        mutable.extend(1, 0, 0);
-        let result = mutable.freeze();
-
-        let expected_string_array = StringArray::from(vec![
-            // extend a[0..a.len()]
-            // a[0]
-            Some("Hello"),
-            Some("Arrow"),
-            None,
-            // extend b[0..b.len()]
-            // b[0]
-            Some("alpha"),
-            Some("beta"),
-            // b[1]
-            None,
-            // b[2]
-            Some("gamma"),
-            Some("delta"),
-            None,
-            // extend b[1..3]
-            // b[1]
-            None,
-            // b[2]
-            Some("gamma"),
-            Some("delta"),
-            None,
-            // extend b[0..0]
-        ]);
-        let list_value_offsets = Buffer::from_slice_ref(&[0, 3, 5, 6, 9, 10, 13]);
-        let expected_list_data = ArrayData::try_new(
-            DataType::List(Box::new(Field::new("item", DataType::Utf8, true))),
-            6,
-            None,
-            0,
-            vec![list_value_offsets],
-            vec![expected_string_array.into_data()],
-        )
-        .unwrap();
-        assert_eq!(result, expected_list_data);
-        Ok(())
-    }
-
-    #[test]
-    fn test_fixed_size_binary_append() {
-        let a = vec![Some(vec![1, 2]), Some(vec![3, 4]), Some(vec![5, 6])];
-        let a = FixedSizeBinaryArray::try_from_sparse_iter(a.into_iter())
-            .expect("Failed to create FixedSizeBinaryArray from iterable");
-
-        let b = vec![
-            None,
-            Some(vec![7, 8]),
-            Some(vec![9, 10]),
-            None,
-            Some(vec![13, 14]),
-            None,
-        ];
-        let b = FixedSizeBinaryArray::try_from_sparse_iter(b.into_iter())
-            .expect("Failed to create FixedSizeBinaryArray from iterable");
-
-        let mut mutable = MutableArrayData::new(vec![a.data(), b.data()], false, 10);
-
-        mutable.extend(0, 0, a.len());
-        mutable.extend(1, 0, b.len());
-        mutable.extend(1, 1, 4);
-        mutable.extend(1, 2, 3);
-        mutable.extend(1, 5, 5);
-        let result = mutable.freeze();
-
-        let expected = vec![
-            // a
-            Some(vec![1, 2]),
-            Some(vec![3, 4]),
-            Some(vec![5, 6]),
-            // b
-            None,
-            Some(vec![7, 8]),
-            Some(vec![9, 10]),
-            None,
-            Some(vec![13, 14]),
-            None,
-            // b[1..4]
-            Some(vec![7, 8]),
-            Some(vec![9, 10]),
-            None,
-            // b[2..3]
-            Some(vec![9, 10]),
-            // b[4..4]
-        ];
-        let expected = FixedSizeBinaryArray::try_from_sparse_iter(expected.into_iter())
-            .expect("Failed to create FixedSizeBinaryArray from iterable");
-        assert_eq!(&result, expected.data());
-    }
-
-    /*
-    // this is an old test used on a meanwhile removed dead code
-    // that is still useful when `MutableArrayData` supports fixed-size lists.
-    #[test]
-    fn test_fixed_size_list_append() -> Result<()> {
-        let int_builder = UInt16Builder::new(64);
-        let mut builder = FixedSizeListBuilder::<UInt16Builder>::new(int_builder, 2);
-        builder.values().append_slice(&[1, 2])?;
-        builder.append(true)?;
-        builder.values().append_slice(&[3, 4])?;
-        builder.append(false)?;
-        builder.values().append_slice(&[5, 6])?;
-        builder.append(true)?;
-
-        let a_builder = UInt16Builder::new(64);
-        let mut a_builder = FixedSizeListBuilder::<UInt16Builder>::new(a_builder, 2);
-        a_builder.values().append_slice(&[7, 8])?;
-        a_builder.append(true)?;
-        a_builder.values().append_slice(&[9, 10])?;
-        a_builder.append(true)?;
-        a_builder.values().append_slice(&[11, 12])?;
-        a_builder.append(false)?;
-        a_builder.values().append_slice(&[13, 14])?;
-        a_builder.append(true)?;
-        a_builder.values().append_null()?;
-        a_builder.values().append_null()?;
-        a_builder.append(true)?;
-        let a = a_builder.finish();
-
-        // append array
-        builder.append_data(&[
-            a.data(),
-            a.slice(1, 3).data(),
-            a.slice(2, 1).data(),
-            a.slice(5, 0).data(),
-        ])?;
-        let finished = builder.finish();
-
-        let expected_int_array = UInt16Array::from(vec![
-            Some(1),
-            Some(2),
-            Some(3),
-            Some(4),
-            Some(5),
-            Some(6),
-            // append first array
-            Some(7),
-            Some(8),
-            Some(9),
-            Some(10),
-            Some(11),
-            Some(12),
-            Some(13),
-            Some(14),
-            None,
-            None,
-            // append slice(1, 3)
-            Some(9),
-            Some(10),
-            Some(11),
-            Some(12),
-            Some(13),
-            Some(14),
-            // append slice(2, 1)
-            Some(11),
-            Some(12),
-        ]);
-        let expected_list_data = ArrayData::new(
-            DataType::FixedSizeList(
-                Box::new(Field::new("item", DataType::UInt16, true)),
-                2,
-            ),
-            12,
-            None,
-            None,
-            0,
-            vec![],
-            vec![expected_int_array.data()],
-        );
-        let expected_list =
-            FixedSizeListArray::from(Arc::new(expected_list_data) as ArrayData);
-        assert_eq!(&expected_list.values(), &finished.values());
-        assert_eq!(expected_list.len(), finished.len());
-
-        Ok(())
-    }
-    */
-}
diff --git a/arrow/src/array/transform/structure.rs b/arrow/src/array/transform/structure.rs
deleted file mode 100644
index 5c41d76a7f1c..000000000000
--- a/arrow/src/array/transform/structure.rs
+++ /dev/null
@@ -1,64 +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.
-
-use crate::array::ArrayData;
-
-use super::{Extend, _MutableArrayData};
-
-pub(super) fn build_extend(array: &ArrayData) -> Extend {
-    if array.null_count() == 0 {
-        Box::new(
-            move |mutable: &mut _MutableArrayData,
-                  index: usize,
-                  start: usize,
-                  len: usize| {
-                mutable
-                    .child_data
-                    .iter_mut()
-                    .for_each(|child| child.extend(index, start, start + len))
-            },
-        )
-    } else {
-        Box::new(
-            move |mutable: &mut _MutableArrayData,
-                  index: usize,
-                  start: usize,
-                  len: usize| {
-                (start..start + len).for_each(|i| {
-                    if array.is_valid(i) {
-                        mutable
-                            .child_data
-                            .iter_mut()
-                            .for_each(|child| child.extend(index, i, i + 1))
-                    } else {
-                        mutable
-                            .child_data
-                            .iter_mut()
-                            .for_each(|child| child.extend_nulls(1))
-                    }
-                })
-            },
-        )
-    }
-}
-
-pub(super) fn extend_nulls(mutable: &mut _MutableArrayData, len: usize) {
-    mutable
-        .child_data
-        .iter_mut()
-        .for_each(|child| child.extend_nulls(len))
-}
diff --git a/arrow/src/array/transform/variable_size.rs b/arrow/src/array/transform/variable_size.rs
deleted file mode 100644
index c9304dbca200..000000000000
--- a/arrow/src/array/transform/variable_size.rs
+++ /dev/null
@@ -1,105 +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.
-
-use crate::{
-    array::{ArrayData, OffsetSizeTrait},
-    buffer::MutableBuffer,
-};
-
-use super::{
-    Extend, _MutableArrayData,
-    utils::{extend_offsets, get_last_offset},
-};
-
-#[inline]
-fn extend_offset_values<T: OffsetSizeTrait>(
-    buffer: &mut MutableBuffer,
-    offsets: &[T],
-    values: &[u8],
-    start: usize,
-    len: usize,
-) {
-    let start_values = offsets[start].to_usize().unwrap();
-    let end_values = offsets[start + len].to_usize().unwrap();
-    let new_values = &values[start_values..end_values];
-    buffer.extend_from_slice(new_values);
-}
-
-pub(super) fn build_extend<T: OffsetSizeTrait>(array: &ArrayData) -> Extend {
-    let offsets = array.buffer::<T>(0);
-    let values = array.buffers()[1].as_slice();
-    if array.null_count() == 0 {
-        // fast case where we can copy regions without null issues
-        Box::new(
-            move |mutable: &mut _MutableArrayData, _, start: usize, len: usize| {
-                let offset_buffer = &mut mutable.buffer1;
-                let values_buffer = &mut mutable.buffer2;
-
-                // this is safe due to how offset is built. See details on `get_last_offset`
-                let last_offset = unsafe { get_last_offset(offset_buffer) };
-
-                extend_offsets::<T>(
-                    offset_buffer,
-                    last_offset,
-                    &offsets[start..start + len + 1],
-                );
-                // values
-                extend_offset_values::<T>(values_buffer, offsets, values, start, len);
-            },
-        )
-    } else {
-        Box::new(
-            move |mutable: &mut _MutableArrayData, _, start: usize, len: usize| {
-                let offset_buffer = &mut mutable.buffer1;
-                let values_buffer = &mut mutable.buffer2;
-
-                // this is safe due to how offset is built. See details on `get_last_offset`
-                let mut last_offset: T = unsafe { get_last_offset(offset_buffer) };
-
-                // nulls present: append item by item, ignoring null entries
-                offset_buffer.reserve(len * std::mem::size_of::<T>());
-
-                (start..start + len).for_each(|i| {
-                    if array.is_valid(i) {
-                        // compute the new offset
-                        let length = offsets[i + 1] - offsets[i];
-                        last_offset += length;
-
-                        // append value
-                        let bytes = &values[offsets[i].to_usize().unwrap()
-                            ..offsets[i + 1].to_usize().unwrap()];
-                        values_buffer.extend_from_slice(bytes);
-                    }
-                    // offsets are always present
-                    offset_buffer.push(last_offset);
-                })
-            },
-        )
-    }
-}
-
-pub(super) fn extend_nulls<T: OffsetSizeTrait>(
-    mutable: &mut _MutableArrayData,
-    len: usize,
-) {
-    let offset_buffer = &mut mutable.buffer1;
-
-    // this is safe due to how offset is built. See details on `get_last_offset`
-    let last_offset: T = unsafe { get_last_offset(offset_buffer) };
-
-    (0..len).for_each(|_| offset_buffer.push(last_offset))
-}
diff --git a/arrow/src/bitmap.rs b/arrow/src/bitmap.rs
deleted file mode 100644
index 4ba1bb9f8882..000000000000
--- a/arrow/src/bitmap.rs
+++ /dev/null
@@ -1,156 +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.
-
-//! Defines [Bitmap] for tracking validity bitmaps
-
-use crate::buffer::Buffer;
-use crate::error::Result;
-use crate::util::bit_util;
-use std::mem;
-
-use std::ops::{BitAnd, BitOr};
-
-#[derive(Debug, Clone)]
-/// Defines a bitmap, which is used to track which values in an Arrow
-/// array are null.
-///
-/// This is called a "validity bitmap" in the Arrow documentation.
-pub struct Bitmap {
-    pub(crate) bits: Buffer,
-}
-
-impl Bitmap {
-    pub fn new(num_bits: usize) -> Self {
-        let num_bytes = bit_util::ceil(num_bits, 8);
-        let len = bit_util::round_upto_multiple_of_64(num_bytes);
-        Bitmap {
-            bits: Buffer::from(&vec![0xFF; len]),
-        }
-    }
-
-    /// Return the length of this Bitmap in bits (not bytes)
-    pub fn bit_len(&self) -> usize {
-        self.bits.len() * 8
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.bits.is_empty()
-    }
-
-    pub fn is_set(&self, i: usize) -> bool {
-        assert!(i < (self.bits.len() << 3));
-        unsafe { bit_util::get_bit_raw(self.bits.as_ptr(), i) }
-    }
-
-    pub fn buffer_ref(&self) -> &Buffer {
-        &self.bits
-    }
-
-    pub fn into_buffer(self) -> Buffer {
-        self.bits
-    }
-
-    /// Returns the total number of bytes of memory occupied by the buffers owned by this [Bitmap].
-    pub fn get_buffer_memory_size(&self) -> usize {
-        self.bits.capacity()
-    }
-
-    /// Returns the total number of bytes of memory occupied physically by this [Bitmap].
-    pub fn get_array_memory_size(&self) -> usize {
-        self.bits.capacity() + mem::size_of_val(self)
-    }
-}
-
-impl<'a, 'b> BitAnd<&'b Bitmap> for &'a Bitmap {
-    type Output = Result<Bitmap>;
-
-    fn bitand(self, rhs: &'b Bitmap) -> Result<Bitmap> {
-        Ok(Bitmap::from((&self.bits & &rhs.bits)?))
-    }
-}
-
-impl<'a, 'b> BitOr<&'b Bitmap> for &'a Bitmap {
-    type Output = Result<Bitmap>;
-
-    fn bitor(self, rhs: &'b Bitmap) -> Result<Bitmap> {
-        Ok(Bitmap::from((&self.bits | &rhs.bits)?))
-    }
-}
-
-impl From<Buffer> for Bitmap {
-    fn from(buf: Buffer) -> Self {
-        Self { bits: buf }
-    }
-}
-
-impl PartialEq for Bitmap {
-    fn eq(&self, other: &Self) -> bool {
-        // buffer equality considers capacity, but here we want to only compare
-        // actual data contents
-        let self_len = self.bits.len();
-        let other_len = other.bits.len();
-        if self_len != other_len {
-            return false;
-        }
-        self.bits.as_slice()[..self_len] == other.bits.as_slice()[..self_len]
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_bitmap_length() {
-        assert_eq!(512, Bitmap::new(63 * 8).bit_len());
-        assert_eq!(512, Bitmap::new(64 * 8).bit_len());
-        assert_eq!(1024, Bitmap::new(65 * 8).bit_len());
-    }
-
-    #[test]
-    fn test_bitwise_and() {
-        let bitmap1 = Bitmap::from(Buffer::from([0b01101010]));
-        let bitmap2 = Bitmap::from(Buffer::from([0b01001110]));
-        assert_eq!(
-            Bitmap::from(Buffer::from([0b01001010])),
-            (&bitmap1 & &bitmap2).unwrap()
-        );
-    }
-
-    #[test]
-    fn test_bitwise_or() {
-        let bitmap1 = Bitmap::from(Buffer::from([0b01101010]));
-        let bitmap2 = Bitmap::from(Buffer::from([0b01001110]));
-        assert_eq!(
-            Bitmap::from(Buffer::from([0b01101110])),
-            (&bitmap1 | &bitmap2).unwrap()
-        );
-    }
-
-    #[test]
-    fn test_bitmap_is_set() {
-        let bitmap = Bitmap::from(Buffer::from([0b01001010]));
-        assert!(!bitmap.is_set(0));
-        assert!(bitmap.is_set(1));
-        assert!(!bitmap.is_set(2));
-        assert!(bitmap.is_set(3));
-        assert!(!bitmap.is_set(4));
-        assert!(!bitmap.is_set(5));
-        assert!(bitmap.is_set(6));
-        assert!(!bitmap.is_set(7));
-    }
-}
diff --git a/arrow/src/buffer/mod.rs b/arrow/src/buffer/mod.rs
deleted file mode 100644
index b392b0583d6d..000000000000
--- a/arrow/src/buffer/mod.rs
+++ /dev/null
@@ -1,72 +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.
-
-//! This module contains two main structs: [Buffer] and [MutableBuffer]. A buffer represents
-//! a contiguous memory region that can be shared via `offsets`.
-
-mod immutable;
-pub use immutable::*;
-mod mutable;
-pub use mutable::*;
-mod ops;
-mod scalar;
-pub use scalar::*;
-
-pub use ops::*;
-
-use crate::error::{ArrowError, Result};
-use std::ops::{BitAnd, BitOr, Not};
-
-impl<'a, 'b> BitAnd<&'b Buffer> for &'a Buffer {
-    type Output = Result<Buffer>;
-
-    fn bitand(self, rhs: &'b Buffer) -> Result<Buffer> {
-        if self.len() != rhs.len() {
-            return Err(ArrowError::ComputeError(
-                "Buffers must be the same size to apply Bitwise AND.".to_string(),
-            ));
-        }
-
-        let len_in_bits = self.len() * 8;
-        Ok(buffer_bin_and(self, 0, rhs, 0, len_in_bits))
-    }
-}
-
-impl<'a, 'b> BitOr<&'b Buffer> for &'a Buffer {
-    type Output = Result<Buffer>;
-
-    fn bitor(self, rhs: &'b Buffer) -> Result<Buffer> {
-        if self.len() != rhs.len() {
-            return Err(ArrowError::ComputeError(
-                "Buffers must be the same size to apply Bitwise OR.".to_string(),
-            ));
-        }
-
-        let len_in_bits = self.len() * 8;
-
-        Ok(buffer_bin_or(self, 0, rhs, 0, len_in_bits))
-    }
-}
-
-impl Not for &Buffer {
-    type Output = Buffer;
-
-    fn not(self) -> Buffer {
-        let len_in_bits = self.len() * 8;
-        buffer_unary_not(self, 0, len_in_bits)
-    }
-}
diff --git a/arrow/src/buffer/scalar.rs b/arrow/src/buffer/scalar.rs
deleted file mode 100644
index 7d663cd2bf96..000000000000
--- a/arrow/src/buffer/scalar.rs
+++ /dev/null
@@ -1,149 +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.
-
-use crate::buffer::Buffer;
-use crate::datatypes::ArrowNativeType;
-use std::ops::Deref;
-
-/// Provides a safe API for interpreting a [`Buffer`] as a slice of [`ArrowNativeType`]
-///
-/// # Safety
-///
-/// All [`ArrowNativeType`] are valid for all possible backing byte representations, and as
-/// a result they are "trivially safely transmutable".
-#[derive(Debug)]
-pub struct ScalarBuffer<T: ArrowNativeType> {
-    #[allow(unused)]
-    buffer: Buffer,
-    // Borrows from `buffer` and is valid for the lifetime of `buffer`
-    ptr: *const T,
-    // The length of this slice
-    len: usize,
-}
-
-impl<T: ArrowNativeType> ScalarBuffer<T> {
-    /// Create a new [`ScalarBuffer`] from a [`Buffer`], and an `offset`
-    /// and `length` in units of `T`
-    ///
-    /// # Panics
-    ///
-    /// This method will panic if
-    ///
-    /// * `offset` or `len` would result in overflow
-    /// * `buffer` is not aligned to a multiple of `std::mem::size_of::<T>`
-    /// * `bytes` is not large enough for the requested slice
-    pub fn new(buffer: Buffer, offset: usize, len: usize) -> Self {
-        let size = std::mem::size_of::<T>();
-        let offset_len = offset.checked_add(len).expect("length overflow");
-        let start_bytes = offset.checked_mul(size).expect("start bytes overflow");
-        let end_bytes = offset_len.checked_mul(size).expect("end bytes overflow");
-
-        let bytes = &buffer.as_slice()[start_bytes..end_bytes];
-
-        // SAFETY: all byte sequences correspond to a valid instance of T
-        let (prefix, offsets, suffix) = unsafe { bytes.align_to::<T>() };
-        assert!(
-            prefix.is_empty() && suffix.is_empty(),
-            "buffer is not aligned to {} byte boundary",
-            size
-        );
-
-        let ptr = offsets.as_ptr();
-        Self { buffer, ptr, len }
-    }
-}
-
-impl<T: ArrowNativeType> Deref for ScalarBuffer<T> {
-    type Target = [T];
-
-    fn deref(&self) -> &Self::Target {
-        // SAFETY: Bounds checked in constructor and ptr is valid for the lifetime of self
-        unsafe { std::slice::from_raw_parts(self.ptr, self.len) }
-    }
-}
-
-impl<T: ArrowNativeType> AsRef<[T]> for ScalarBuffer<T> {
-    fn as_ref(&self) -> &[T] {
-        self
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_basic() {
-        let expected = [0_i32, 1, 2];
-        let buffer = Buffer::from_iter(expected.iter().cloned());
-        let typed = ScalarBuffer::<i32>::new(buffer.clone(), 0, 3);
-        assert_eq!(*typed, expected);
-
-        let typed = ScalarBuffer::<i32>::new(buffer.clone(), 1, 2);
-        assert_eq!(*typed, expected[1..]);
-
-        let typed = ScalarBuffer::<i32>::new(buffer.clone(), 1, 0);
-        assert!(typed.is_empty());
-
-        let typed = ScalarBuffer::<i32>::new(buffer, 3, 0);
-        assert!(typed.is_empty());
-    }
-
-    #[test]
-    #[should_panic(expected = "buffer is not aligned to 4 byte boundary")]
-    fn test_unaligned() {
-        let expected = [0_i32, 1, 2];
-        let buffer = Buffer::from_iter(expected.iter().cloned());
-        let buffer = buffer.slice(1);
-        ScalarBuffer::<i32>::new(buffer, 0, 2);
-    }
-
-    #[test]
-    #[should_panic(expected = "range end index 16 out of range for slice of length 12")]
-    fn test_length_out_of_bounds() {
-        let buffer = Buffer::from_iter([0_i32, 1, 2]);
-        ScalarBuffer::<i32>::new(buffer, 1, 3);
-    }
-
-    #[test]
-    #[should_panic(expected = "range end index 16 out of range for slice of length 12")]
-    fn test_offset_out_of_bounds() {
-        let buffer = Buffer::from_iter([0_i32, 1, 2]);
-        ScalarBuffer::<i32>::new(buffer, 4, 0);
-    }
-
-    #[test]
-    #[should_panic(expected = "length overflow")]
-    fn test_length_overflow() {
-        let buffer = Buffer::from_iter([0_i32, 1, 2]);
-        ScalarBuffer::<i32>::new(buffer, usize::MAX, 1);
-    }
-
-    #[test]
-    #[should_panic(expected = "start bytes overflow")]
-    fn test_start_overflow() {
-        let buffer = Buffer::from_iter([0_i32, 1, 2]);
-        ScalarBuffer::<i32>::new(buffer, usize::MAX / 4 + 1, 0);
-    }
-
-    #[test]
-    #[should_panic(expected = "end bytes overflow")]
-    fn test_end_overflow() {
-        let buffer = Buffer::from_iter([0_i32, 1, 2]);
-        ScalarBuffer::<i32>::new(buffer, 0, usize::MAX / 4 + 1);
-    }
-}
diff --git a/arrow/src/compute/kernels.rs b/arrow/src/compute/kernels.rs
new file mode 100644
index 000000000000..4eeb5892c97c
--- /dev/null
+++ b/arrow/src/compute/kernels.rs
@@ -0,0 +1,32 @@
+// 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.
+
+//! Computation kernels on Arrow Arrays
+
+pub use arrow_arith::{aggregate, arithmetic, arity, bitwise, boolean, numeric, temporal};
+pub use arrow_cast::cast;
+pub use arrow_cast::parse as cast_utils;
+pub use arrow_ord::{cmp, partition, rank, sort};
+pub use arrow_select::{concat, filter, interleave, nullif, take, window, zip};
+pub use arrow_string::{concat_elements, length, regexp, substring};
+
+/// Comparison kernels for `Array`s.
+pub mod comparison {
+    pub use arrow_ord::comparison::*;
+    pub use arrow_string::like::*;
+    pub use arrow_string::regexp::{regexp_is_match_utf8, regexp_is_match_utf8_scalar};
+}
diff --git a/arrow/src/compute/kernels/aggregate.rs b/arrow/src/compute/kernels/aggregate.rs
deleted file mode 100644
index 12ead669f79d..000000000000
--- a/arrow/src/compute/kernels/aggregate.rs
+++ /dev/null
@@ -1,1006 +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.
-
-//! Defines aggregations over Arrow arrays.
-
-use multiversion::multiversion;
-use std::ops::Add;
-
-use crate::array::{
-    Array, BooleanArray, GenericBinaryArray, GenericStringArray, OffsetSizeTrait,
-    PrimitiveArray,
-};
-use crate::datatypes::{ArrowNativeType, ArrowNumericType};
-
-/// Generic test for NaN, the optimizer should be able to remove this for integer types.
-#[inline]
-fn is_nan<T: ArrowNativeType + PartialOrd + Copy>(a: T) -> bool {
-    #[allow(clippy::eq_op)]
-    !(a == a)
-}
-
-/// Returns the minimum value in the array, according to the natural order.
-/// For floating point arrays any NaN values are considered to be greater than any other non-null value
-#[cfg(not(feature = "simd"))]
-pub fn min<T>(array: &PrimitiveArray<T>) -> Option<T::Native>
-where
-    T: ArrowNumericType,
-    T::Native: ArrowNativeType,
-{
-    min_max_helper(array, |a, b| (is_nan(*a) & !is_nan(*b)) || a > b)
-}
-
-/// Returns the maximum value in the array, according to the natural order.
-/// For floating point arrays any NaN values are considered to be greater than any other non-null value
-#[cfg(not(feature = "simd"))]
-pub fn max<T>(array: &PrimitiveArray<T>) -> Option<T::Native>
-where
-    T: ArrowNumericType,
-    T::Native: ArrowNativeType,
-{
-    min_max_helper(array, |a, b| (!is_nan(*a) & is_nan(*b)) || a < b)
-}
-
-/// Helper function to perform min/max lambda function on values from a numeric array.
-#[multiversion]
-#[clone(target = "x86_64+avx")]
-fn min_max_helper<T, F>(array: &PrimitiveArray<T>, cmp: F) -> Option<T::Native>
-where
-    T: ArrowNumericType,
-    F: Fn(&T::Native, &T::Native) -> bool,
-{
-    let null_count = array.null_count();
-
-    // Includes case array.len() == 0
-    if null_count == array.len() {
-        return None;
-    }
-
-    let data = array.data();
-    let m = array.values();
-    let mut n;
-
-    if null_count == 0 {
-        // optimized path for arrays without null values
-        n = m[1..]
-            .iter()
-            .fold(m[0], |max, item| if cmp(&max, item) { *item } else { max });
-    } else {
-        n = T::default_value();
-        let mut has_value = false;
-        for (i, item) in m.iter().enumerate() {
-            if data.is_valid(i) && (!has_value || cmp(&n, item)) {
-                has_value = true;
-                n = *item
-            }
-        }
-    }
-    Some(n)
-}
-
-/// Returns the minimum value in the boolean array.
-///
-/// ```
-/// use arrow::{
-///   array::BooleanArray,
-///   compute::min_boolean,
-/// };
-///
-/// let a = BooleanArray::from(vec![Some(true), None, Some(false)]);
-/// assert_eq!(min_boolean(&a), Some(false))
-/// ```
-pub fn min_boolean(array: &BooleanArray) -> Option<bool> {
-    // short circuit if all nulls / zero length array
-    if array.null_count() == array.len() {
-        return None;
-    }
-
-    // Note the min bool is false (0), so short circuit as soon as we see it
-    array
-        .iter()
-        .find(|&b| b == Some(false))
-        .flatten()
-        .or(Some(true))
-}
-
-/// Returns the maximum value in the boolean array
-///
-/// ```
-/// use arrow::{
-///   array::BooleanArray,
-///   compute::max_boolean,
-/// };
-///
-/// let a = BooleanArray::from(vec![Some(true), None, Some(false)]);
-/// assert_eq!(max_boolean(&a), Some(true))
-/// ```
-pub fn max_boolean(array: &BooleanArray) -> Option<bool> {
-    // short circuit if all nulls / zero length array
-    if array.null_count() == array.len() {
-        return None;
-    }
-
-    // Note the max bool is true (1), so short circuit as soon as we see it
-    array
-        .iter()
-        .find(|&b| b == Some(true))
-        .flatten()
-        .or(Some(false))
-}
-
-/// Helper to compute min/max of [`GenericStringArray`] and [`GenericBinaryArray`]
-macro_rules! min_max_binary_string {
-    ($array: expr, $cmp: expr) => {{
-        let null_count = $array.null_count();
-        if null_count == $array.len() {
-            None
-        } else if null_count == 0 {
-            // JUSTIFICATION
-            //  Benefit:  ~8% speedup
-            //  Soundness: `i` is always within the array bounds
-            (0..$array.len())
-                .map(|i| unsafe { $array.value_unchecked(i) })
-                .reduce(|acc, item| if $cmp(acc, item) { item } else { acc })
-        } else {
-            $array
-                .iter()
-                .flatten()
-                .reduce(|acc, item| if $cmp(acc, item) { item } else { acc })
-        }
-    }};
-}
-
-/// Returns the maximum value in the binary array, according to the natural order.
-pub fn max_binary<T: OffsetSizeTrait>(array: &GenericBinaryArray<T>) -> Option<&[u8]> {
-    min_max_binary_string!(array, |a, b| a < b)
-}
-
-/// Returns the minimum value in the binary array, according to the natural order.
-pub fn min_binary<T: OffsetSizeTrait>(array: &GenericBinaryArray<T>) -> Option<&[u8]> {
-    min_max_binary_string!(array, |a, b| a > b)
-}
-
-/// Returns the maximum value in the string array, according to the natural order.
-pub fn max_string<T: OffsetSizeTrait>(array: &GenericStringArray<T>) -> Option<&str> {
-    min_max_binary_string!(array, |a, b| a < b)
-}
-
-/// Returns the minimum value in the string array, according to the natural order.
-pub fn min_string<T: OffsetSizeTrait>(array: &GenericStringArray<T>) -> Option<&str> {
-    min_max_binary_string!(array, |a, b| a > b)
-}
-
-/// Returns the sum of values in the array.
-///
-/// Returns `None` if the array is empty or only contains null values.
-#[cfg(not(feature = "simd"))]
-pub fn sum<T>(array: &PrimitiveArray<T>) -> Option<T::Native>
-where
-    T: ArrowNumericType,
-    T::Native: Add<Output = T::Native>,
-{
-    let null_count = array.null_count();
-
-    if null_count == array.len() {
-        return None;
-    }
-
-    let data: &[T::Native] = array.values();
-
-    match array.data().null_buffer() {
-        None => {
-            let sum = data.iter().fold(T::default_value(), |accumulator, value| {
-                accumulator + *value
-            });
-
-            Some(sum)
-        }
-        Some(buffer) => {
-            let mut sum = T::default_value();
-            let data_chunks = data.chunks_exact(64);
-            let remainder = data_chunks.remainder();
-
-            let bit_chunks = buffer.bit_chunks(array.offset(), array.len());
-            data_chunks
-                .zip(bit_chunks.iter())
-                .for_each(|(chunk, mask)| {
-                    // index_mask has value 1 << i in the loop
-                    let mut index_mask = 1;
-                    chunk.iter().for_each(|value| {
-                        if (mask & index_mask) != 0 {
-                            sum = sum + *value;
-                        }
-                        index_mask <<= 1;
-                    });
-                });
-
-            let remainder_bits = bit_chunks.remainder_bits();
-
-            remainder.iter().enumerate().for_each(|(i, value)| {
-                if remainder_bits & (1 << i) != 0 {
-                    sum = sum + *value;
-                }
-            });
-
-            Some(sum)
-        }
-    }
-}
-
-#[cfg(feature = "simd")]
-mod simd {
-    use super::is_nan;
-    use crate::array::{Array, PrimitiveArray};
-    use crate::datatypes::ArrowNumericType;
-    use std::marker::PhantomData;
-    use std::ops::Add;
-
-    pub(super) trait SimdAggregate<T: ArrowNumericType> {
-        type ScalarAccumulator;
-        type SimdAccumulator;
-
-        /// Returns the accumulator for aggregating scalar values
-        fn init_accumulator_scalar() -> Self::ScalarAccumulator;
-
-        /// Returns the accumulator for aggregating simd chunks of values
-        fn init_accumulator_chunk() -> Self::SimdAccumulator;
-
-        /// Updates the accumulator with the values of one chunk
-        fn accumulate_chunk_non_null(
-            accumulator: &mut Self::SimdAccumulator,
-            chunk: T::Simd,
-        );
-
-        /// Updates the accumulator with the values of one chunk according to the given vector mask
-        fn accumulate_chunk_nullable(
-            accumulator: &mut Self::SimdAccumulator,
-            chunk: T::Simd,
-            mask: T::SimdMask,
-        );
-
-        /// Updates the accumulator with one value
-        fn accumulate_scalar(accumulator: &mut Self::ScalarAccumulator, value: T::Native);
-
-        /// Reduces the vector lanes of the simd accumulator and the scalar accumulator to a single value
-        fn reduce(
-            simd_accumulator: Self::SimdAccumulator,
-            scalar_accumulator: Self::ScalarAccumulator,
-        ) -> Option<T::Native>;
-    }
-
-    pub(super) struct SumAggregate<T: ArrowNumericType> {
-        phantom: PhantomData<T>,
-    }
-
-    impl<T: ArrowNumericType> SimdAggregate<T> for SumAggregate<T>
-    where
-        T::Native: Add<Output = T::Native>,
-    {
-        type ScalarAccumulator = T::Native;
-        type SimdAccumulator = T::Simd;
-
-        fn init_accumulator_scalar() -> Self::ScalarAccumulator {
-            T::default_value()
-        }
-
-        fn init_accumulator_chunk() -> Self::SimdAccumulator {
-            T::init(Self::init_accumulator_scalar())
-        }
-
-        fn accumulate_chunk_non_null(accumulator: &mut T::Simd, chunk: T::Simd) {
-            *accumulator = *accumulator + chunk;
-        }
-
-        fn accumulate_chunk_nullable(
-            accumulator: &mut T::Simd,
-            chunk: T::Simd,
-            vecmask: T::SimdMask,
-        ) {
-            let zero = T::init(T::default_value());
-            let blended = T::mask_select(vecmask, chunk, zero);
-
-            *accumulator = *accumulator + blended;
-        }
-
-        fn accumulate_scalar(accumulator: &mut T::Native, value: T::Native) {
-            *accumulator = *accumulator + value
-        }
-
-        fn reduce(
-            simd_accumulator: Self::SimdAccumulator,
-            scalar_accumulator: Self::ScalarAccumulator,
-        ) -> Option<T::Native> {
-            // we can't use T::lanes() as the slice len because it is not const,
-            // instead always reserve the maximum number of lanes
-            let mut tmp = [T::default_value(); 64];
-            let slice = &mut tmp[0..T::lanes()];
-            T::write(simd_accumulator, slice);
-
-            let mut reduced = Self::init_accumulator_scalar();
-            slice
-                .iter()
-                .for_each(|value| Self::accumulate_scalar(&mut reduced, *value));
-
-            Self::accumulate_scalar(&mut reduced, scalar_accumulator);
-
-            // result can not be None because we checked earlier for the null count
-            Some(reduced)
-        }
-    }
-
-    pub(super) struct MinAggregate<T: ArrowNumericType> {
-        phantom: PhantomData<T>,
-    }
-
-    impl<T: ArrowNumericType> SimdAggregate<T> for MinAggregate<T>
-    where
-        T::Native: PartialOrd,
-    {
-        type ScalarAccumulator = (T::Native, bool);
-        type SimdAccumulator = (T::Simd, T::SimdMask);
-
-        fn init_accumulator_scalar() -> Self::ScalarAccumulator {
-            (T::default_value(), false)
-        }
-
-        fn init_accumulator_chunk() -> Self::SimdAccumulator {
-            (T::init(T::default_value()), T::mask_init(false))
-        }
-
-        fn accumulate_chunk_non_null(
-            accumulator: &mut Self::SimdAccumulator,
-            chunk: T::Simd,
-        ) {
-            let acc_is_nan = !T::eq(accumulator.0, accumulator.0);
-            let is_lt = acc_is_nan | T::lt(chunk, accumulator.0);
-            let first_or_lt = !accumulator.1 | is_lt;
-
-            accumulator.0 = T::mask_select(first_or_lt, chunk, accumulator.0);
-            accumulator.1 = T::mask_init(true);
-        }
-
-        fn accumulate_chunk_nullable(
-            accumulator: &mut Self::SimdAccumulator,
-            chunk: T::Simd,
-            vecmask: T::SimdMask,
-        ) {
-            let acc_is_nan = !T::eq(accumulator.0, accumulator.0);
-            let is_lt = vecmask & (acc_is_nan | T::lt(chunk, accumulator.0));
-            let first_or_lt = !accumulator.1 | is_lt;
-
-            accumulator.0 = T::mask_select(first_or_lt, chunk, accumulator.0);
-            accumulator.1 |= vecmask;
-        }
-
-        fn accumulate_scalar(
-            accumulator: &mut Self::ScalarAccumulator,
-            value: T::Native,
-        ) {
-            if !accumulator.1 {
-                accumulator.0 = value;
-            } else {
-                let acc_is_nan = is_nan(accumulator.0);
-                if acc_is_nan || value < accumulator.0 {
-                    accumulator.0 = value
-                }
-            }
-            accumulator.1 = true
-        }
-
-        fn reduce(
-            simd_accumulator: Self::SimdAccumulator,
-            scalar_accumulator: Self::ScalarAccumulator,
-        ) -> Option<T::Native> {
-            // we can't use T::lanes() as the slice len because it is not const,
-            // instead always reserve the maximum number of lanes
-            let mut tmp = [T::default_value(); 64];
-            let slice = &mut tmp[0..T::lanes()];
-            T::write(simd_accumulator.0, slice);
-
-            let mut reduced = Self::init_accumulator_scalar();
-            slice
-                .iter()
-                .enumerate()
-                .filter(|(i, _value)| T::mask_get(&simd_accumulator.1, *i))
-                .for_each(|(_i, value)| Self::accumulate_scalar(&mut reduced, *value));
-
-            if scalar_accumulator.1 {
-                Self::accumulate_scalar(&mut reduced, scalar_accumulator.0);
-            }
-
-            if reduced.1 {
-                Some(reduced.0)
-            } else {
-                None
-            }
-        }
-    }
-
-    pub(super) struct MaxAggregate<T: ArrowNumericType> {
-        phantom: PhantomData<T>,
-    }
-
-    impl<T: ArrowNumericType> SimdAggregate<T> for MaxAggregate<T>
-    where
-        T::Native: PartialOrd,
-    {
-        type ScalarAccumulator = (T::Native, bool);
-        type SimdAccumulator = (T::Simd, T::SimdMask);
-
-        fn init_accumulator_scalar() -> Self::ScalarAccumulator {
-            (T::default_value(), false)
-        }
-
-        fn init_accumulator_chunk() -> Self::SimdAccumulator {
-            (T::init(T::default_value()), T::mask_init(false))
-        }
-
-        fn accumulate_chunk_non_null(
-            accumulator: &mut Self::SimdAccumulator,
-            chunk: T::Simd,
-        ) {
-            let chunk_is_nan = !T::eq(chunk, chunk);
-            let is_gt = chunk_is_nan | T::gt(chunk, accumulator.0);
-            let first_or_gt = !accumulator.1 | is_gt;
-
-            accumulator.0 = T::mask_select(first_or_gt, chunk, accumulator.0);
-            accumulator.1 = T::mask_init(true);
-        }
-
-        fn accumulate_chunk_nullable(
-            accumulator: &mut Self::SimdAccumulator,
-            chunk: T::Simd,
-            vecmask: T::SimdMask,
-        ) {
-            let chunk_is_nan = !T::eq(chunk, chunk);
-            let is_gt = vecmask & (chunk_is_nan | T::gt(chunk, accumulator.0));
-            let first_or_gt = !accumulator.1 | is_gt;
-
-            accumulator.0 = T::mask_select(first_or_gt, chunk, accumulator.0);
-            accumulator.1 |= vecmask;
-        }
-
-        fn accumulate_scalar(
-            accumulator: &mut Self::ScalarAccumulator,
-            value: T::Native,
-        ) {
-            if !accumulator.1 {
-                accumulator.0 = value;
-            } else {
-                let value_is_nan = is_nan(value);
-                if value_is_nan || value > accumulator.0 {
-                    accumulator.0 = value
-                }
-            }
-            accumulator.1 = true;
-        }
-
-        fn reduce(
-            simd_accumulator: Self::SimdAccumulator,
-            scalar_accumulator: Self::ScalarAccumulator,
-        ) -> Option<T::Native> {
-            // we can't use T::lanes() as the slice len because it is not const,
-            // instead always reserve the maximum number of lanes
-            let mut tmp = [T::default_value(); 64];
-            let slice = &mut tmp[0..T::lanes()];
-            T::write(simd_accumulator.0, slice);
-
-            let mut reduced = Self::init_accumulator_scalar();
-            slice
-                .iter()
-                .enumerate()
-                .filter(|(i, _value)| T::mask_get(&simd_accumulator.1, *i))
-                .for_each(|(_i, value)| Self::accumulate_scalar(&mut reduced, *value));
-
-            if scalar_accumulator.1 {
-                Self::accumulate_scalar(&mut reduced, scalar_accumulator.0);
-            }
-
-            if reduced.1 {
-                Some(reduced.0)
-            } else {
-                None
-            }
-        }
-    }
-
-    pub(super) fn simd_aggregation<T: ArrowNumericType, A: SimdAggregate<T>>(
-        array: &PrimitiveArray<T>,
-    ) -> Option<T::Native> {
-        let null_count = array.null_count();
-
-        if null_count == array.len() {
-            return None;
-        }
-
-        let data: &[T::Native] = array.values();
-
-        let mut chunk_acc = A::init_accumulator_chunk();
-        let mut rem_acc = A::init_accumulator_scalar();
-
-        match array.data().null_buffer() {
-            None => {
-                let data_chunks = data.chunks_exact(64);
-                let remainder = data_chunks.remainder();
-
-                data_chunks.for_each(|chunk| {
-                    chunk.chunks_exact(T::lanes()).for_each(|chunk| {
-                        let chunk = T::load(&chunk);
-                        A::accumulate_chunk_non_null(&mut chunk_acc, chunk);
-                    });
-                });
-
-                remainder.iter().for_each(|value| {
-                    A::accumulate_scalar(&mut rem_acc, *value);
-                });
-            }
-            Some(buffer) => {
-                // process data in chunks of 64 elements since we also get 64 bits of validity information at a time
-                let data_chunks = data.chunks_exact(64);
-                let remainder = data_chunks.remainder();
-
-                let bit_chunks = buffer.bit_chunks(array.offset(), array.len());
-                let remainder_bits = bit_chunks.remainder_bits();
-
-                data_chunks.zip(bit_chunks).for_each(|(chunk, mut mask)| {
-                    // split chunks further into slices corresponding to the vector length
-                    // the compiler is able to unroll this inner loop and remove bounds checks
-                    // since the outer chunk size (64) is always a multiple of the number of lanes
-                    chunk.chunks_exact(T::lanes()).for_each(|chunk| {
-                        let vecmask = T::mask_from_u64(mask);
-                        let chunk = T::load(&chunk);
-
-                        A::accumulate_chunk_nullable(&mut chunk_acc, chunk, vecmask);
-
-                        // skip the shift and avoid overflow for u8 type, which uses 64 lanes.
-                        mask >>= T::lanes() % 64;
-                    });
-                });
-
-                remainder.iter().enumerate().for_each(|(i, value)| {
-                    if remainder_bits & (1 << i) != 0 {
-                        A::accumulate_scalar(&mut rem_acc, *value)
-                    }
-                });
-            }
-        }
-
-        A::reduce(chunk_acc, rem_acc)
-    }
-}
-
-/// Returns the sum of values in the array.
-///
-/// Returns `None` if the array is empty or only contains null values.
-#[cfg(feature = "simd")]
-pub fn sum<T: ArrowNumericType>(array: &PrimitiveArray<T>) -> Option<T::Native>
-where
-    T::Native: Add<Output = T::Native>,
-{
-    use simd::*;
-
-    simd::simd_aggregation::<T, SumAggregate<T>>(&array)
-}
-
-#[cfg(feature = "simd")]
-/// Returns the minimum value in the array, according to the natural order.
-/// For floating point arrays any NaN values are considered to be greater than any other non-null value
-pub fn min<T: ArrowNumericType>(array: &PrimitiveArray<T>) -> Option<T::Native>
-where
-    T::Native: PartialOrd,
-{
-    use simd::*;
-
-    simd::simd_aggregation::<T, MinAggregate<T>>(&array)
-}
-
-#[cfg(feature = "simd")]
-/// Returns the maximum value in the array, according to the natural order.
-/// For floating point arrays any NaN values are considered to be greater than any other non-null value
-pub fn max<T: ArrowNumericType>(array: &PrimitiveArray<T>) -> Option<T::Native>
-where
-    T::Native: PartialOrd,
-{
-    use simd::*;
-
-    simd::simd_aggregation::<T, MaxAggregate<T>>(&array)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::*;
-    use crate::compute::add;
-
-    #[test]
-    fn test_primitive_array_sum() {
-        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
-        assert_eq!(15, sum(&a).unwrap());
-    }
-
-    #[test]
-    fn test_primitive_array_float_sum() {
-        let a = Float64Array::from(vec![1.1, 2.2, 3.3, 4.4, 5.5]);
-        assert_eq!(16.5, sum(&a).unwrap());
-    }
-
-    #[test]
-    fn test_primitive_array_sum_with_nulls() {
-        let a = Int32Array::from(vec![None, Some(2), Some(3), None, Some(5)]);
-        assert_eq!(10, sum(&a).unwrap());
-    }
-
-    #[test]
-    fn test_primitive_array_sum_all_nulls() {
-        let a = Int32Array::from(vec![None, None, None]);
-        assert_eq!(None, sum(&a));
-    }
-
-    #[test]
-    fn test_primitive_array_sum_large_64() {
-        let a: Int64Array = (1..=100)
-            .map(|i| if i % 3 == 0 { Some(i) } else { None })
-            .collect();
-        let b: Int64Array = (1..=100)
-            .map(|i| if i % 3 == 0 { Some(0) } else { Some(i) })
-            .collect();
-        // create an array that actually has non-zero values at the invalid indices
-        let c = add(&a, &b).unwrap();
-        assert_eq!(Some((1..=100).filter(|i| i % 3 == 0).sum()), sum(&c));
-    }
-
-    #[test]
-    fn test_primitive_array_sum_large_32() {
-        let a: Int32Array = (1..=100)
-            .map(|i| if i % 3 == 0 { Some(i) } else { None })
-            .collect();
-        let b: Int32Array = (1..=100)
-            .map(|i| if i % 3 == 0 { Some(0) } else { Some(i) })
-            .collect();
-        // create an array that actually has non-zero values at the invalid indices
-        let c = add(&a, &b).unwrap();
-        assert_eq!(Some((1..=100).filter(|i| i % 3 == 0).sum()), sum(&c));
-    }
-
-    #[test]
-    fn test_primitive_array_sum_large_16() {
-        let a: Int16Array = (1..=100)
-            .map(|i| if i % 3 == 0 { Some(i) } else { None })
-            .collect();
-        let b: Int16Array = (1..=100)
-            .map(|i| if i % 3 == 0 { Some(0) } else { Some(i) })
-            .collect();
-        // create an array that actually has non-zero values at the invalid indices
-        let c = add(&a, &b).unwrap();
-        assert_eq!(Some((1..=100).filter(|i| i % 3 == 0).sum()), sum(&c));
-    }
-
-    #[test]
-    fn test_primitive_array_sum_large_8() {
-        // include fewer values than other large tests so the result does not overflow the u8
-        let a: UInt8Array = (1..=100)
-            .map(|i| if i % 33 == 0 { Some(i) } else { None })
-            .collect();
-        let b: UInt8Array = (1..=100)
-            .map(|i| if i % 33 == 0 { Some(0) } else { Some(i) })
-            .collect();
-        // create an array that actually has non-zero values at the invalid indices
-        let c = add(&a, &b).unwrap();
-        assert_eq!(Some((1..=100).filter(|i| i % 33 == 0).sum()), sum(&c));
-    }
-
-    #[test]
-    fn test_primitive_array_min_max() {
-        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
-        assert_eq!(5, min(&a).unwrap());
-        assert_eq!(9, max(&a).unwrap());
-    }
-
-    #[test]
-    fn test_primitive_array_min_max_with_nulls() {
-        let a = Int32Array::from(vec![Some(5), None, None, Some(8), Some(9)]);
-        assert_eq!(5, min(&a).unwrap());
-        assert_eq!(9, max(&a).unwrap());
-    }
-
-    #[test]
-    fn test_primitive_min_max_1() {
-        let a = Int32Array::from(vec![None, None, Some(5), Some(2)]);
-        assert_eq!(Some(2), min(&a));
-        assert_eq!(Some(5), max(&a));
-    }
-
-    #[test]
-    fn test_primitive_min_max_float_large_nonnull_array() {
-        let a: Float64Array = (0..256).map(|i| Some((i + 1) as f64)).collect();
-        // min/max are on boundaries of chunked data
-        assert_eq!(Some(1.0), min(&a));
-        assert_eq!(Some(256.0), max(&a));
-
-        // max is last value in remainder after chunking
-        let a: Float64Array = (0..255).map(|i| Some((i + 1) as f64)).collect();
-        assert_eq!(Some(255.0), max(&a));
-
-        // max is first value in remainder after chunking
-        let a: Float64Array = (0..257).map(|i| Some((i + 1) as f64)).collect();
-        assert_eq!(Some(257.0), max(&a));
-    }
-
-    #[test]
-    fn test_primitive_min_max_float_large_nullable_array() {
-        let a: Float64Array = (0..256)
-            .map(|i| {
-                if (i + 1) % 3 == 0 {
-                    None
-                } else {
-                    Some((i + 1) as f64)
-                }
-            })
-            .collect();
-        // min/max are on boundaries of chunked data
-        assert_eq!(Some(1.0), min(&a));
-        assert_eq!(Some(256.0), max(&a));
-
-        let a: Float64Array = (0..256)
-            .map(|i| {
-                if i == 0 || i == 255 {
-                    None
-                } else {
-                    Some((i + 1) as f64)
-                }
-            })
-            .collect();
-        // boundaries of chunked data are null
-        assert_eq!(Some(2.0), min(&a));
-        assert_eq!(Some(255.0), max(&a));
-
-        let a: Float64Array = (0..256)
-            .map(|i| if i != 100 { None } else { Some((i) as f64) })
-            .collect();
-        // a single non-null value somewhere in the middle
-        assert_eq!(Some(100.0), min(&a));
-        assert_eq!(Some(100.0), max(&a));
-
-        // max is last value in remainder after chunking
-        let a: Float64Array = (0..255).map(|i| Some((i + 1) as f64)).collect();
-        assert_eq!(Some(255.0), max(&a));
-
-        // max is first value in remainder after chunking
-        let a: Float64Array = (0..257).map(|i| Some((i + 1) as f64)).collect();
-        assert_eq!(Some(257.0), max(&a));
-    }
-
-    #[test]
-    fn test_primitive_min_max_float_edge_cases() {
-        let a: Float64Array = (0..100).map(|_| Some(f64::NEG_INFINITY)).collect();
-        assert_eq!(Some(f64::NEG_INFINITY), min(&a));
-        assert_eq!(Some(f64::NEG_INFINITY), max(&a));
-
-        let a: Float64Array = (0..100).map(|_| Some(f64::MIN)).collect();
-        assert_eq!(Some(f64::MIN), min(&a));
-        assert_eq!(Some(f64::MIN), max(&a));
-
-        let a: Float64Array = (0..100).map(|_| Some(f64::MAX)).collect();
-        assert_eq!(Some(f64::MAX), min(&a));
-        assert_eq!(Some(f64::MAX), max(&a));
-
-        let a: Float64Array = (0..100).map(|_| Some(f64::INFINITY)).collect();
-        assert_eq!(Some(f64::INFINITY), min(&a));
-        assert_eq!(Some(f64::INFINITY), max(&a));
-    }
-
-    #[test]
-    fn test_primitive_min_max_float_all_nans_non_null() {
-        let a: Float64Array = (0..100).map(|_| Some(f64::NAN)).collect();
-        assert!(max(&a).unwrap().is_nan());
-        assert!(min(&a).unwrap().is_nan());
-    }
-
-    #[test]
-    fn test_primitive_min_max_float_first_nan_nonnull() {
-        let a: Float64Array = (0..100)
-            .map(|i| {
-                if i == 0 {
-                    Some(f64::NAN)
-                } else {
-                    Some(i as f64)
-                }
-            })
-            .collect();
-        assert_eq!(Some(1.0), min(&a));
-        assert!(max(&a).unwrap().is_nan());
-    }
-
-    #[test]
-    fn test_primitive_min_max_float_last_nan_nonnull() {
-        let a: Float64Array = (0..100)
-            .map(|i| {
-                if i == 99 {
-                    Some(f64::NAN)
-                } else {
-                    Some((i + 1) as f64)
-                }
-            })
-            .collect();
-        assert_eq!(Some(1.0), min(&a));
-        assert!(max(&a).unwrap().is_nan());
-    }
-
-    #[test]
-    fn test_primitive_min_max_float_first_nan_nullable() {
-        let a: Float64Array = (0..100)
-            .map(|i| {
-                if i == 0 {
-                    Some(f64::NAN)
-                } else if i % 2 == 0 {
-                    None
-                } else {
-                    Some(i as f64)
-                }
-            })
-            .collect();
-        assert_eq!(Some(1.0), min(&a));
-        assert!(max(&a).unwrap().is_nan());
-    }
-
-    #[test]
-    fn test_primitive_min_max_float_last_nan_nullable() {
-        let a: Float64Array = (0..100)
-            .map(|i| {
-                if i == 99 {
-                    Some(f64::NAN)
-                } else if i % 2 == 0 {
-                    None
-                } else {
-                    Some(i as f64)
-                }
-            })
-            .collect();
-        assert_eq!(Some(1.0), min(&a));
-        assert!(max(&a).unwrap().is_nan());
-    }
-
-    #[test]
-    fn test_primitive_min_max_float_inf_and_nans() {
-        let a: Float64Array = (0..100)
-            .map(|i| {
-                let x = match i % 10 {
-                    0 => f64::NEG_INFINITY,
-                    1 => f64::MIN,
-                    2 => f64::MAX,
-                    4 => f64::INFINITY,
-                    5 => f64::NAN,
-                    _ => i as f64,
-                };
-                Some(x)
-            })
-            .collect();
-        assert_eq!(Some(f64::NEG_INFINITY), min(&a));
-        assert!(max(&a).unwrap().is_nan());
-    }
-
-    #[test]
-    fn test_binary_min_max_with_nulls() {
-        let a = BinaryArray::from(vec![
-            Some("b".as_bytes()),
-            None,
-            None,
-            Some(b"a"),
-            Some(b"c"),
-        ]);
-        assert_eq!(Some("a".as_bytes()), min_binary(&a));
-        assert_eq!(Some("c".as_bytes()), max_binary(&a));
-    }
-
-    #[test]
-    fn test_binary_min_max_no_null() {
-        let a = BinaryArray::from(vec![Some("b".as_bytes()), Some(b"a"), Some(b"c")]);
-        assert_eq!(Some("a".as_bytes()), min_binary(&a));
-        assert_eq!(Some("c".as_bytes()), max_binary(&a));
-    }
-
-    #[test]
-    fn test_binary_min_max_all_nulls() {
-        let a = BinaryArray::from(vec![None, None]);
-        assert_eq!(None, min_binary(&a));
-        assert_eq!(None, max_binary(&a));
-    }
-
-    #[test]
-    fn test_binary_min_max_1() {
-        let a = BinaryArray::from(vec![None, None, Some("b".as_bytes()), Some(b"a")]);
-        assert_eq!(Some("a".as_bytes()), min_binary(&a));
-        assert_eq!(Some("b".as_bytes()), max_binary(&a));
-    }
-
-    #[test]
-    fn test_string_min_max_with_nulls() {
-        let a = StringArray::from(vec![Some("b"), None, None, Some("a"), Some("c")]);
-        assert_eq!(Some("a"), min_string(&a));
-        assert_eq!(Some("c"), max_string(&a));
-    }
-
-    #[test]
-    fn test_string_min_max_all_nulls() {
-        let a = StringArray::from(vec![None, None]);
-        assert_eq!(None, min_string(&a));
-        assert_eq!(None, max_string(&a));
-    }
-
-    #[test]
-    fn test_string_min_max_1() {
-        let a = StringArray::from(vec![None, None, Some("b"), Some("a")]);
-        assert_eq!(Some("a"), min_string(&a));
-        assert_eq!(Some("b"), max_string(&a));
-    }
-
-    #[test]
-    fn test_boolean_min_max_empty() {
-        let a = BooleanArray::from(vec![] as Vec<Option<bool>>);
-        assert_eq!(None, min_boolean(&a));
-        assert_eq!(None, max_boolean(&a));
-    }
-
-    #[test]
-    fn test_boolean_min_max_all_null() {
-        let a = BooleanArray::from(vec![None, None]);
-        assert_eq!(None, min_boolean(&a));
-        assert_eq!(None, max_boolean(&a));
-    }
-
-    #[test]
-    fn test_boolean_min_max_no_null() {
-        let a = BooleanArray::from(vec![Some(true), Some(false), Some(true)]);
-        assert_eq!(Some(false), min_boolean(&a));
-        assert_eq!(Some(true), max_boolean(&a));
-    }
-
-    #[test]
-    fn test_boolean_min_max() {
-        let a = BooleanArray::from(vec![Some(true), Some(true), None, Some(false), None]);
-        assert_eq!(Some(false), min_boolean(&a));
-        assert_eq!(Some(true), max_boolean(&a));
-
-        let a = BooleanArray::from(vec![None, Some(true), None, Some(false), None]);
-        assert_eq!(Some(false), min_boolean(&a));
-        assert_eq!(Some(true), max_boolean(&a));
-
-        let a =
-            BooleanArray::from(vec![Some(false), Some(true), None, Some(false), None]);
-        assert_eq!(Some(false), min_boolean(&a));
-        assert_eq!(Some(true), max_boolean(&a));
-    }
-
-    #[test]
-    fn test_boolean_min_max_smaller() {
-        let a = BooleanArray::from(vec![Some(false)]);
-        assert_eq!(Some(false), min_boolean(&a));
-        assert_eq!(Some(false), max_boolean(&a));
-
-        let a = BooleanArray::from(vec![None, Some(false)]);
-        assert_eq!(Some(false), min_boolean(&a));
-        assert_eq!(Some(false), max_boolean(&a));
-
-        let a = BooleanArray::from(vec![None, Some(true)]);
-        assert_eq!(Some(true), min_boolean(&a));
-        assert_eq!(Some(true), max_boolean(&a));
-
-        let a = BooleanArray::from(vec![Some(true)]);
-        assert_eq!(Some(true), min_boolean(&a));
-        assert_eq!(Some(true), max_boolean(&a));
-    }
-}
diff --git a/arrow/src/compute/kernels/arithmetic.rs b/arrow/src/compute/kernels/arithmetic.rs
deleted file mode 100644
index c7ccc09c1d25..000000000000
--- a/arrow/src/compute/kernels/arithmetic.rs
+++ /dev/null
@@ -1,2022 +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.
-
-//! Defines basic arithmetic kernels for `PrimitiveArrays`.
-//!
-//! These kernels can leverage SIMD if available on your system.  Currently no runtime
-//! detection is provided, you should enable the specific SIMD intrinsics using
-//! `RUSTFLAGS="-C target-feature=+avx2"` for example.  See the documentation
-//! [here](https://doc.rust-lang.org/stable/core/arch/) for more information.
-
-use std::ops::{Add, Div, Mul, Neg, Rem, Sub};
-
-use num::{One, Zero};
-
-use crate::array::*;
-use crate::buffer::Buffer;
-#[cfg(feature = "simd")]
-use crate::buffer::MutableBuffer;
-use crate::compute::kernels::arity::unary;
-use crate::compute::unary_dyn;
-use crate::compute::util::combine_option_bitmap;
-use crate::datatypes;
-use crate::datatypes::{
-    ArrowNumericType, DataType, Date32Type, Date64Type, IntervalDayTimeType,
-    IntervalMonthDayNanoType, IntervalUnit, IntervalYearMonthType,
-};
-use crate::datatypes::{
-    Float32Type, Float64Type, Int16Type, Int32Type, Int64Type, Int8Type, UInt16Type,
-    UInt32Type, UInt64Type, UInt8Type,
-};
-use crate::error::{ArrowError, Result};
-use num::traits::Pow;
-use std::any::type_name;
-#[cfg(feature = "simd")]
-use std::borrow::BorrowMut;
-#[cfg(feature = "simd")]
-use std::slice::{ChunksExact, ChunksExactMut};
-use std::sync::Arc;
-
-/// Helper function to perform math lambda function on values from two arrays. If either
-/// left or right value is null then the output value is also null, so `1 + null` is
-/// `null`.
-///
-/// # Errors
-///
-/// This function errors if the arrays have different lengths
-pub fn math_op<LT, RT, F>(
-    left: &PrimitiveArray<LT>,
-    right: &PrimitiveArray<RT>,
-    op: F,
-) -> Result<PrimitiveArray<LT>>
-where
-    LT: ArrowNumericType,
-    RT: ArrowNumericType,
-    F: Fn(LT::Native, RT::Native) -> LT::Native,
-{
-    if left.len() != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform math operation on arrays of different length".to_string(),
-        ));
-    }
-
-    let null_bit_buffer =
-        combine_option_bitmap(&[left.data_ref(), right.data_ref()], left.len())?;
-
-    let values = left
-        .values()
-        .iter()
-        .zip(right.values().iter())
-        .map(|(l, r)| op(*l, *r));
-    // JUSTIFICATION
-    //  Benefit
-    //      ~60% speedup
-    //  Soundness
-    //      `values` is an iterator with a known size from a PrimitiveArray
-    let buffer = unsafe { Buffer::from_trusted_len_iter(values) };
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            LT::DATA_TYPE,
-            left.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![buffer],
-            vec![],
-        )
-    };
-    Ok(PrimitiveArray::<LT>::from(data))
-}
-
-/// Helper function for operations where a valid `0` on the right array should
-/// result in an [ArrowError::DivideByZero], namely the division and modulo operations
-///
-/// # Errors
-///
-/// This function errors if:
-/// * the arrays have different lengths
-/// * there is an element where both left and right values are valid and the right value is `0`
-fn math_checked_divide_op<T, F>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-    op: F,
-) -> Result<PrimitiveArray<T>>
-where
-    T: ArrowNumericType,
-    T::Native: One + Zero,
-    F: Fn(T::Native, T::Native) -> T::Native,
-{
-    if left.len() != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform math operation on arrays of different length".to_string(),
-        ));
-    }
-
-    let null_bit_buffer =
-        combine_option_bitmap(&[left.data_ref(), right.data_ref()], left.len())?;
-
-    math_checked_divide_op_on_iters(
-        left.into_iter(),
-        right.into_iter(),
-        op,
-        left.len(),
-        null_bit_buffer,
-    )
-}
-
-/// Helper function for operations where a valid `0` on the right array should
-/// result in an [ArrowError::DivideByZero], namely the division and modulo operations
-///
-/// # Errors
-///
-/// This function errors if:
-/// * the arrays have different lengths
-/// * there is an element where both left and right values are valid and the right value is `0`
-fn math_checked_divide_op_on_iters<T, F>(
-    left: impl Iterator<Item = Option<T::Native>>,
-    right: impl Iterator<Item = Option<T::Native>>,
-    op: F,
-    len: usize,
-    null_bit_buffer: Option<Buffer>,
-) -> Result<PrimitiveArray<T>>
-where
-    T: ArrowNumericType,
-    T::Native: One + Zero,
-    F: Fn(T::Native, T::Native) -> T::Native,
-{
-    let buffer = if null_bit_buffer.is_some() {
-        let values = left.zip(right).map(|(left, right)| {
-            if let (Some(l), Some(r)) = (left, right) {
-                if r.is_zero() {
-                    Err(ArrowError::DivideByZero)
-                } else {
-                    Ok(op(l, r))
-                }
-            } else {
-                Ok(T::default_value())
-            }
-        });
-        // Safety: Iterator comes from a PrimitiveArray which reports its size correctly
-        unsafe { Buffer::try_from_trusted_len_iter(values) }
-    } else {
-        // no value is null
-        let values = left.map(|l| l.unwrap()).zip(right.map(|r| r.unwrap())).map(
-            |(left, right)| {
-                if right.is_zero() {
-                    Err(ArrowError::DivideByZero)
-                } else {
-                    Ok(op(left, right))
-                }
-            },
-        );
-        // Safety: Iterator comes from a PrimitiveArray which reports its size correctly
-        unsafe { Buffer::try_from_trusted_len_iter(values) }
-    }?;
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            T::DATA_TYPE,
-            len,
-            None,
-            null_bit_buffer,
-            0,
-            vec![buffer],
-            vec![],
-        )
-    };
-    Ok(PrimitiveArray::<T>::from(data))
-}
-
-/// Calculates the modulus operation `left % right` on two SIMD inputs.
-/// The lower-most bits of `valid_mask` specify which vector lanes are considered as valid.
-///
-/// # Errors
-///
-/// This function returns a [`ArrowError::DivideByZero`] if a valid element in `right` is `0`
-#[cfg(feature = "simd")]
-#[inline]
-fn simd_checked_modulus<T: ArrowNumericType>(
-    valid_mask: Option<u64>,
-    left: T::Simd,
-    right: T::Simd,
-) -> Result<T::Simd>
-where
-    T::Native: One + Zero,
-{
-    let zero = T::init(T::Native::zero());
-    let one = T::init(T::Native::one());
-
-    let right_no_invalid_zeros = match valid_mask {
-        Some(mask) => {
-            let simd_mask = T::mask_from_u64(mask);
-            // select `1` for invalid lanes, which will be a no-op during division later
-            T::mask_select(simd_mask, right, one)
-        }
-        None => right,
-    };
-
-    let zero_mask = T::eq(right_no_invalid_zeros, zero);
-
-    if T::mask_any(zero_mask) {
-        Err(ArrowError::DivideByZero)
-    } else {
-        Ok(T::bin_op(left, right_no_invalid_zeros, |a, b| a % b))
-    }
-}
-
-/// Calculates the division operation `left / right` on two SIMD inputs.
-/// The lower-most bits of `valid_mask` specify which vector lanes are considered as valid.
-///
-/// # Errors
-///
-/// This function returns a [`ArrowError::DivideByZero`] if a valid element in `right` is `0`
-#[cfg(feature = "simd")]
-#[inline]
-fn simd_checked_divide<T: ArrowNumericType>(
-    valid_mask: Option<u64>,
-    left: T::Simd,
-    right: T::Simd,
-) -> Result<T::Simd>
-where
-    T::Native: One + Zero,
-{
-    let zero = T::init(T::Native::zero());
-    let one = T::init(T::Native::one());
-
-    let right_no_invalid_zeros = match valid_mask {
-        Some(mask) => {
-            let simd_mask = T::mask_from_u64(mask);
-            // select `1` for invalid lanes, which will be a no-op during division later
-            T::mask_select(simd_mask, right, one)
-        }
-        None => right,
-    };
-
-    let zero_mask = T::eq(right_no_invalid_zeros, zero);
-
-    if T::mask_any(zero_mask) {
-        Err(ArrowError::DivideByZero)
-    } else {
-        Ok(T::bin_op(left, right_no_invalid_zeros, |a, b| a / b))
-    }
-}
-
-/// Applies `op` on the remainder elements of two input chunks and writes the result into
-/// the remainder elements of `result_chunks`.
-/// The lower-most bits of `valid_mask` specify which elements are considered as valid.
-///
-/// # Errors
-///
-/// This function returns a [`ArrowError::DivideByZero`] if a valid element in `right` is `0`
-#[cfg(feature = "simd")]
-#[inline]
-fn simd_checked_divide_op_remainder<T, F>(
-    valid_mask: Option<u64>,
-    left_chunks: ChunksExact<T::Native>,
-    right_chunks: ChunksExact<T::Native>,
-    result_chunks: ChunksExactMut<T::Native>,
-    op: F,
-) -> Result<()>
-where
-    T: ArrowNumericType,
-    T::Native: Zero,
-    F: Fn(T::Native, T::Native) -> T::Native,
-{
-    let result_remainder = result_chunks.into_remainder();
-    let left_remainder = left_chunks.remainder();
-    let right_remainder = right_chunks.remainder();
-
-    result_remainder
-        .iter_mut()
-        .zip(left_remainder.iter().zip(right_remainder.iter()))
-        .enumerate()
-        .try_for_each(|(i, (result_scalar, (left_scalar, right_scalar)))| {
-            if valid_mask.map(|mask| mask & (1 << i) != 0).unwrap_or(true) {
-                if *right_scalar == T::Native::zero() {
-                    return Err(ArrowError::DivideByZero);
-                }
-                *result_scalar = op(*left_scalar, *right_scalar);
-            } else {
-                *result_scalar = T::default_value();
-            }
-            Ok(())
-        })?;
-
-    Ok(())
-}
-
-/// Creates a new PrimitiveArray by applying `simd_op` to the `left` and `right` input array.
-/// If the length of the arrays is not multiple of the number of vector lanes
-/// then the remainder of the array will be calculated using `scalar_op`.
-/// Any operation on a `NULL` value will result in a `NULL` value in the output.
-///
-/// # Errors
-///
-/// This function errors if:
-/// * the arrays have different lengths
-/// * there is an element where both left and right values are valid and the right value is `0`
-#[cfg(feature = "simd")]
-fn simd_checked_divide_op<T, SI, SC>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-    simd_op: SI,
-    scalar_op: SC,
-) -> Result<PrimitiveArray<T>>
-where
-    T: ArrowNumericType,
-    T::Native: One + Zero,
-    SI: Fn(Option<u64>, T::Simd, T::Simd) -> Result<T::Simd>,
-    SC: Fn(T::Native, T::Native) -> T::Native,
-{
-    if left.len() != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform math operation on arrays of different length".to_string(),
-        ));
-    }
-
-    // Create the combined `Bitmap`
-    let null_bit_buffer =
-        combine_option_bitmap(&[left.data_ref(), right.data_ref()], left.len())?;
-
-    let lanes = T::lanes();
-    let buffer_size = left.len() * std::mem::size_of::<T::Native>();
-    let mut result = MutableBuffer::new(buffer_size).with_bitset(buffer_size, false);
-
-    match &null_bit_buffer {
-        Some(b) => {
-            // combine_option_bitmap returns a slice or new buffer starting at 0
-            let valid_chunks = b.bit_chunks(0, left.len());
-
-            // process data in chunks of 64 elements since we also get 64 bits of validity information at a time
-
-            // safety: result is newly created above, always written as a T below
-            let mut result_chunks =
-                unsafe { result.typed_data_mut().chunks_exact_mut(64) };
-            let mut left_chunks = left.values().chunks_exact(64);
-            let mut right_chunks = right.values().chunks_exact(64);
-
-            valid_chunks
-                .iter()
-                .zip(
-                    result_chunks
-                        .borrow_mut()
-                        .zip(left_chunks.borrow_mut().zip(right_chunks.borrow_mut())),
-                )
-                .try_for_each(
-                    |(mut mask, (result_slice, (left_slice, right_slice)))| {
-                        // split chunks further into slices corresponding to the vector length
-                        // the compiler is able to unroll this inner loop and remove bounds checks
-                        // since the outer chunk size (64) is always a multiple of the number of lanes
-                        result_slice
-                            .chunks_exact_mut(lanes)
-                            .zip(left_slice.chunks_exact(lanes).zip(right_slice.chunks_exact(lanes)))
-                            .try_for_each(|(result_slice, (left_slice, right_slice))| -> Result<()> {
-                                let simd_left = T::load(left_slice);
-                                let simd_right = T::load(right_slice);
-
-                                let simd_result = simd_op(Some(mask), simd_left, simd_right)?;
-
-                                T::write(simd_result, result_slice);
-
-                                // skip the shift and avoid overflow for u8 type, which uses 64 lanes.
-                                mask >>= T::lanes() % 64;
-
-                                Ok(())
-                            })
-                    },
-                )?;
-
-            let valid_remainder = valid_chunks.remainder_bits();
-
-            simd_checked_divide_op_remainder::<T, _>(
-                Some(valid_remainder),
-                left_chunks,
-                right_chunks,
-                result_chunks,
-                scalar_op,
-            )?;
-        }
-        None => {
-            // safety: result is newly created above, always written as a T below
-            let mut result_chunks =
-                unsafe { result.typed_data_mut().chunks_exact_mut(lanes) };
-            let mut left_chunks = left.values().chunks_exact(lanes);
-            let mut right_chunks = right.values().chunks_exact(lanes);
-
-            result_chunks
-                .borrow_mut()
-                .zip(left_chunks.borrow_mut().zip(right_chunks.borrow_mut()))
-                .try_for_each(
-                    |(result_slice, (left_slice, right_slice))| -> Result<()> {
-                        let simd_left = T::load(left_slice);
-                        let simd_right = T::load(right_slice);
-
-                        let simd_result = simd_op(None, simd_left, simd_right)?;
-
-                        T::write(simd_result, result_slice);
-
-                        Ok(())
-                    },
-                )?;
-
-            simd_checked_divide_op_remainder::<T, _>(
-                None,
-                left_chunks,
-                right_chunks,
-                result_chunks,
-                scalar_op,
-            )?;
-        }
-    }
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            T::DATA_TYPE,
-            left.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![result.into()],
-            vec![],
-        )
-    };
-    Ok(PrimitiveArray::<T>::from(data))
-}
-
-/// Applies $OP to $LEFT and $RIGHT which are two dictionaries which have (the same) key type $KT
-macro_rules! typed_dict_op {
-    ($LEFT: expr, $RIGHT: expr, $OP: expr, $KT: tt, $MATH_OP: ident) => {{
-        match ($LEFT.value_type(), $RIGHT.value_type()) {
-            (DataType::Int8, DataType::Int8) => {
-                let array = $MATH_OP::<$KT, Int8Type, _>($LEFT, $RIGHT, $OP)?;
-                Ok(Arc::new(array))
-            }
-            (DataType::Int16, DataType::Int16) => {
-                let array = $MATH_OP::<$KT, Int16Type, _>($LEFT, $RIGHT, $OP)?;
-                Ok(Arc::new(array))
-            }
-            (DataType::Int32, DataType::Int32) => {
-                let array = $MATH_OP::<$KT, Int32Type, _>($LEFT, $RIGHT, $OP)?;
-                Ok(Arc::new(array))
-            }
-            (DataType::Int64, DataType::Int64) => {
-                let array = $MATH_OP::<$KT, Int64Type, _>($LEFT, $RIGHT, $OP)?;
-                Ok(Arc::new(array))
-            }
-            (DataType::UInt8, DataType::UInt8) => {
-                let array = $MATH_OP::<$KT, UInt8Type, _>($LEFT, $RIGHT, $OP)?;
-                Ok(Arc::new(array))
-            }
-            (DataType::UInt16, DataType::UInt16) => {
-                let array = $MATH_OP::<$KT, UInt16Type, _>($LEFT, $RIGHT, $OP)?;
-                Ok(Arc::new(array))
-            }
-            (DataType::UInt32, DataType::UInt32) => {
-                let array = $MATH_OP::<$KT, UInt32Type, _>($LEFT, $RIGHT, $OP)?;
-                Ok(Arc::new(array))
-            }
-            (DataType::UInt64, DataType::UInt64) => {
-                let array = $MATH_OP::<$KT, UInt64Type, _>($LEFT, $RIGHT, $OP)?;
-                Ok(Arc::new(array))
-            }
-            (DataType::Float32, DataType::Float32) => {
-                let array = $MATH_OP::<$KT, Float32Type, _>($LEFT, $RIGHT, $OP)?;
-                Ok(Arc::new(array))
-            }
-            (DataType::Float64, DataType::Float64) => {
-                let array = $MATH_OP::<$KT, Float64Type, _>($LEFT, $RIGHT, $OP)?;
-                Ok(Arc::new(array))
-            }
-            (t1, t2) => Err(ArrowError::CastError(format!(
-                "Cannot perform arithmetic operation on two dictionary arrays of different value types ({} and {})",
-                t1, t2
-            ))),
-        }
-    }};
-}
-
-macro_rules! typed_dict_math_op {
-   // Applies `LEFT OP RIGHT` when `LEFT` and `RIGHT` both are `DictionaryArray`
-    ($LEFT: expr, $RIGHT: expr, $OP: expr, $MATH_OP: ident) => {{
-        match ($LEFT.data_type(), $RIGHT.data_type()) {
-            (DataType::Dictionary(left_key_type, _), DataType::Dictionary(right_key_type, _))=> {
-                match (left_key_type.as_ref(), right_key_type.as_ref()) {
-                    (DataType::Int8, DataType::Int8) => {
-                        let left = as_dictionary_array::<Int8Type>($LEFT);
-                        let right = as_dictionary_array::<Int8Type>($RIGHT);
-                        typed_dict_op!(left, right, $OP, Int8Type, $MATH_OP)
-                    }
-                    (DataType::Int16, DataType::Int16) => {
-                        let left = as_dictionary_array::<Int16Type>($LEFT);
-                        let right = as_dictionary_array::<Int16Type>($RIGHT);
-                        typed_dict_op!(left, right, $OP, Int16Type, $MATH_OP)
-                    }
-                    (DataType::Int32, DataType::Int32) => {
-                        let left = as_dictionary_array::<Int32Type>($LEFT);
-                        let right = as_dictionary_array::<Int32Type>($RIGHT);
-                        typed_dict_op!(left, right, $OP, Int32Type, $MATH_OP)
-                    }
-                    (DataType::Int64, DataType::Int64) => {
-                        let left = as_dictionary_array::<Int64Type>($LEFT);
-                        let right = as_dictionary_array::<Int64Type>($RIGHT);
-                        typed_dict_op!(left, right, $OP, Int64Type, $MATH_OP)
-                    }
-                    (DataType::UInt8, DataType::UInt8) => {
-                        let left = as_dictionary_array::<UInt8Type>($LEFT);
-                        let right = as_dictionary_array::<UInt8Type>($RIGHT);
-                        typed_dict_op!(left, right, $OP, UInt8Type, $MATH_OP)
-                    }
-                    (DataType::UInt16, DataType::UInt16) => {
-                        let left = as_dictionary_array::<UInt16Type>($LEFT);
-                        let right = as_dictionary_array::<UInt16Type>($RIGHT);
-                        typed_dict_op!(left, right, $OP, UInt16Type, $MATH_OP)
-                    }
-                    (DataType::UInt32, DataType::UInt32) => {
-                        let left = as_dictionary_array::<UInt32Type>($LEFT);
-                        let right = as_dictionary_array::<UInt32Type>($RIGHT);
-                        typed_dict_op!(left, right, $OP, UInt32Type, $MATH_OP)
-                    }
-                    (DataType::UInt64, DataType::UInt64) => {
-                        let left = as_dictionary_array::<UInt64Type>($LEFT);
-                        let right = as_dictionary_array::<UInt64Type>($RIGHT);
-                        typed_dict_op!(left, right, $OP, UInt64Type, $MATH_OP)
-                    }
-                    (t1, t2) => Err(ArrowError::CastError(format!(
-                        "Cannot perform arithmetic operation on two dictionary arrays of different key types ({} and {})",
-                        t1, t2
-                    ))),
-                }
-            }
-            (t1, t2) => Err(ArrowError::CastError(format!(
-                "Cannot perform arithmetic operation on dictionary array with non-dictionary array ({} and {})",
-                t1, t2
-            ))),
-        }
-    }};
-}
-
-macro_rules! typed_op {
-    ($LEFT: expr, $RIGHT: expr, $T: ident, $OP: expr, $MATH_OP: ident) => {{
-        let left = $LEFT
-            .as_any()
-            .downcast_ref::<PrimitiveArray<$T>>()
-            .ok_or_else(|| {
-                ArrowError::CastError(format!(
-                    "Left array cannot be cast to {}",
-                    type_name::<$T>()
-                ))
-            })?;
-        let right = $RIGHT
-            .as_any()
-            .downcast_ref::<PrimitiveArray<$T>>()
-            .ok_or_else(|| {
-                ArrowError::CastError(format!(
-                    "Right array cannot be cast to {}",
-                    type_name::<$T>(),
-                ))
-            })?;
-        let array = $MATH_OP(left, right, $OP)?;
-        Ok(Arc::new(array))
-    }};
-}
-
-macro_rules! typed_math_op {
-    ($LEFT: expr, $RIGHT: expr, $OP: expr, $MATH_OP: ident) => {{
-        match $LEFT.data_type() {
-            DataType::Int8 => {
-                typed_op!($LEFT, $RIGHT, Int8Type, $OP, $MATH_OP)
-            }
-            DataType::Int16 => {
-                typed_op!($LEFT, $RIGHT, Int16Type, $OP, $MATH_OP)
-            }
-            DataType::Int32 => {
-                typed_op!($LEFT, $RIGHT, Int32Type, $OP, $MATH_OP)
-            }
-            DataType::Int64 => {
-                typed_op!($LEFT, $RIGHT, Int64Type, $OP, $MATH_OP)
-            }
-            DataType::UInt8 => {
-                typed_op!($LEFT, $RIGHT, UInt8Type, $OP, $MATH_OP)
-            }
-            DataType::UInt16 => {
-                typed_op!($LEFT, $RIGHT, UInt16Type, $OP, $MATH_OP)
-            }
-            DataType::UInt32 => {
-                typed_op!($LEFT, $RIGHT, UInt32Type, $OP, $MATH_OP)
-            }
-            DataType::UInt64 => {
-                typed_op!($LEFT, $RIGHT, UInt64Type, $OP, $MATH_OP)
-            }
-            DataType::Float32 => {
-                typed_op!($LEFT, $RIGHT, Float32Type, $OP, $MATH_OP)
-            }
-            DataType::Float64 => {
-                typed_op!($LEFT, $RIGHT, Float64Type, $OP, $MATH_OP)
-            }
-            t => Err(ArrowError::CastError(format!(
-                "Cannot perform arithmetic operation on arrays of type {}",
-                t
-            ))),
-        }
-    }};
-}
-
-/// Helper function to perform math lambda function on values from two dictionary arrays, this
-/// version does not attempt to use SIMD explicitly (though the compiler may auto vectorize)
-macro_rules! math_dict_op {
-    ($left: expr, $right:expr, $op:expr, $value_ty:ty) => {{
-        if $left.len() != $right.len() {
-            return Err(ArrowError::ComputeError(format!(
-                "Cannot perform operation on arrays of different length ({}, {})",
-                $left.len(),
-                $right.len()
-            )));
-        }
-
-        // Safety justification: Since the inputs are valid Arrow arrays, all values are
-        // valid indexes into the dictionary (which is verified during construction)
-
-        let left_iter = unsafe {
-            $left
-                .values()
-                .as_any()
-                .downcast_ref::<$value_ty>()
-                .unwrap()
-                .take_iter_unchecked($left.keys_iter())
-        };
-
-        let right_iter = unsafe {
-            $right
-                .values()
-                .as_any()
-                .downcast_ref::<$value_ty>()
-                .unwrap()
-                .take_iter_unchecked($right.keys_iter())
-        };
-
-        let result = left_iter
-            .zip(right_iter)
-            .map(|(left_value, right_value)| {
-                if let (Some(left), Some(right)) = (left_value, right_value) {
-                    Some($op(left, right))
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        Ok(result)
-    }};
-}
-
-/// Perform given operation on two `DictionaryArray`s.
-/// Returns an error if the two arrays have different value type
-fn math_op_dict<K, T, F>(
-    left: &DictionaryArray<K>,
-    right: &DictionaryArray<K>,
-    op: F,
-) -> Result<PrimitiveArray<T>>
-where
-    K: ArrowNumericType,
-    T: ArrowNumericType,
-    F: Fn(T::Native, T::Native) -> T::Native,
-{
-    math_dict_op!(left, right, op, PrimitiveArray<T>)
-}
-
-/// Helper function for operations where a valid `0` on the right array should
-/// result in an [ArrowError::DivideByZero], namely the division and modulo operations
-///
-/// # Errors
-///
-/// This function errors if:
-/// * the arrays have different lengths
-/// * there is an element where both left and right values are valid and the right value is `0`
-fn math_divide_checked_op_dict<K, T, F>(
-    left: &DictionaryArray<K>,
-    right: &DictionaryArray<K>,
-    op: F,
-) -> Result<PrimitiveArray<T>>
-where
-    K: ArrowNumericType,
-    T: ArrowNumericType,
-    T::Native: One + Zero,
-    F: Fn(T::Native, T::Native) -> T::Native,
-{
-    if left.len() != right.len() {
-        return Err(ArrowError::ComputeError(format!(
-            "Cannot perform operation on arrays of different length ({}, {})",
-            left.len(),
-            right.len()
-        )));
-    }
-
-    let null_bit_buffer =
-        combine_option_bitmap(&[left.data_ref(), right.data_ref()], left.len())?;
-
-    // Safety justification: Since the inputs are valid Arrow arrays, all values are
-    // valid indexes into the dictionary (which is verified during construction)
-
-    let left_iter = unsafe {
-        left.values()
-            .as_any()
-            .downcast_ref::<PrimitiveArray<T>>()
-            .unwrap()
-            .take_iter_unchecked(left.keys_iter())
-    };
-
-    let right_iter = unsafe {
-        right
-            .values()
-            .as_any()
-            .downcast_ref::<PrimitiveArray<T>>()
-            .unwrap()
-            .take_iter_unchecked(right.keys_iter())
-    };
-
-    math_checked_divide_op_on_iters(
-        left_iter,
-        right_iter,
-        op,
-        left.len(),
-        null_bit_buffer,
-    )
-}
-
-/// Perform `left + right` operation on two arrays. If either left or right value is null
-/// then the result is also null.
-pub fn add<T>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-) -> Result<PrimitiveArray<T>>
-where
-    T: ArrowNumericType,
-    T::Native: Add<Output = T::Native>,
-{
-    math_op(left, right, |a, b| a + b)
-}
-
-/// Perform `left + right` operation on two arrays. If either left or right value is null
-/// then the result is also null.
-pub fn add_dyn(left: &dyn Array, right: &dyn Array) -> Result<ArrayRef> {
-    match left.data_type() {
-        DataType::Dictionary(_, _) => {
-            typed_dict_math_op!(left, right, |a, b| a + b, math_op_dict)
-        }
-        DataType::Date32 => {
-            let l = as_primitive_array::<Date32Type>(left);
-            match right.data_type() {
-                DataType::Interval(IntervalUnit::YearMonth) => {
-                    let r = as_primitive_array::<IntervalYearMonthType>(right);
-                    let res = math_op(l, r, Date32Type::add_year_months)?;
-                    Ok(Arc::new(res))
-                }
-                DataType::Interval(IntervalUnit::DayTime) => {
-                    let r = as_primitive_array::<IntervalDayTimeType>(right);
-                    let res = math_op(l, r, Date32Type::add_day_time)?;
-                    Ok(Arc::new(res))
-                }
-                DataType::Interval(IntervalUnit::MonthDayNano) => {
-                    let r = as_primitive_array::<IntervalMonthDayNanoType>(right);
-                    let res = math_op(l, r, Date32Type::add_month_day_nano)?;
-                    Ok(Arc::new(res))
-                }
-                _ => Err(ArrowError::CastError(format!(
-                    "Cannot perform arithmetic operation between array of type {} and array of type {}",
-                    left.data_type(), right.data_type()
-                ))),
-            }
-        }
-        DataType::Date64 => {
-            let l = as_primitive_array::<Date64Type>(left);
-            match right.data_type() {
-                DataType::Interval(IntervalUnit::YearMonth) => {
-                    let r = as_primitive_array::<IntervalYearMonthType>(right);
-                    let res = math_op(l, r, Date64Type::add_year_months)?;
-                    Ok(Arc::new(res))
-                }
-                DataType::Interval(IntervalUnit::DayTime) => {
-                    let r = as_primitive_array::<IntervalDayTimeType>(right);
-                    let res = math_op(l, r, Date64Type::add_day_time)?;
-                    Ok(Arc::new(res))
-                }
-                DataType::Interval(IntervalUnit::MonthDayNano) => {
-                    let r = as_primitive_array::<IntervalMonthDayNanoType>(right);
-                    let res = math_op(l, r, Date64Type::add_month_day_nano)?;
-                    Ok(Arc::new(res))
-                }
-                _ => Err(ArrowError::CastError(format!(
-                    "Cannot perform arithmetic operation between array of type {} and array of type {}",
-                    left.data_type(), right.data_type()
-                ))),
-            }
-        }
-        _ => typed_math_op!(left, right, |a, b| a + b, math_op),
-    }
-}
-
-/// Add every value in an array by a scalar. If any value in the array is null then the
-/// result is also null.
-pub fn add_scalar<T>(
-    array: &PrimitiveArray<T>,
-    scalar: T::Native,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Add<Output = T::Native>,
-{
-    Ok(unary(array, |value| value + scalar))
-}
-
-/// Add every value in an array by a scalar. If any value in the array is null then the
-/// result is also null. The given array must be a `PrimitiveArray` of the type same as
-/// the scalar, or a `DictionaryArray` of the value type same as the scalar.
-pub fn add_scalar_dyn<T>(array: &dyn Array, scalar: T::Native) -> Result<ArrayRef>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Add<Output = T::Native>,
-{
-    unary_dyn::<_, T>(array, |value| value + scalar)
-}
-
-/// Perform `left - right` operation on two arrays. If either left or right value is null
-/// then the result is also null.
-pub fn subtract<T>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Sub<Output = T::Native>,
-{
-    math_op(left, right, |a, b| a - b)
-}
-
-/// Perform `left - right` operation on two arrays. If either left or right value is null
-/// then the result is also null.
-pub fn subtract_dyn(left: &dyn Array, right: &dyn Array) -> Result<ArrayRef> {
-    match left.data_type() {
-        DataType::Dictionary(_, _) => {
-            typed_dict_math_op!(left, right, |a, b| a - b, math_op_dict)
-        }
-        _ => typed_math_op!(left, right, |a, b| a - b, math_op),
-    }
-}
-
-/// Subtract every value in an array by a scalar. If any value in the array is null then the
-/// result is also null.
-pub fn subtract_scalar<T>(
-    array: &PrimitiveArray<T>,
-    scalar: T::Native,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Add<Output = T::Native>
-        + Sub<Output = T::Native>
-        + Mul<Output = T::Native>
-        + Div<Output = T::Native>
-        + Zero,
-{
-    Ok(unary(array, |value| value - scalar))
-}
-
-/// Subtract every value in an array by a scalar. If any value in the array is null then the
-/// result is also null. The given array must be a `PrimitiveArray` of the type same as
-/// the scalar, or a `DictionaryArray` of the value type same as the scalar.
-pub fn subtract_scalar_dyn<T>(array: &dyn Array, scalar: T::Native) -> Result<ArrayRef>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Add<Output = T::Native>
-        + Sub<Output = T::Native>
-        + Mul<Output = T::Native>
-        + Div<Output = T::Native>
-        + Zero,
-{
-    unary_dyn::<_, T>(array, |value| value - scalar)
-}
-
-/// Perform `-` operation on an array. If value is null then the result is also null.
-pub fn negate<T>(array: &PrimitiveArray<T>) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Neg<Output = T::Native>,
-{
-    Ok(unary(array, |x| -x))
-}
-
-/// Raise array with floating point values to the power of a scalar.
-pub fn powf_scalar<T>(
-    array: &PrimitiveArray<T>,
-    raise: T::Native,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowFloatNumericType,
-    T::Native: Pow<T::Native, Output = T::Native>,
-{
-    Ok(unary(array, |x| x.pow(raise)))
-}
-
-/// Perform `left * right` operation on two arrays. If either left or right value is null
-/// then the result is also null.
-pub fn multiply<T>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Mul<Output = T::Native>,
-{
-    math_op(left, right, |a, b| a * b)
-}
-
-/// Perform `left * right` operation on two arrays. If either left or right value is null
-/// then the result is also null.
-pub fn multiply_dyn(left: &dyn Array, right: &dyn Array) -> Result<ArrayRef> {
-    match left.data_type() {
-        DataType::Dictionary(_, _) => {
-            typed_dict_math_op!(left, right, |a, b| a * b, math_op_dict)
-        }
-        _ => typed_math_op!(left, right, |a, b| a * b, math_op),
-    }
-}
-
-/// Multiply every value in an array by a scalar. If any value in the array is null then the
-/// result is also null.
-pub fn multiply_scalar<T>(
-    array: &PrimitiveArray<T>,
-    scalar: T::Native,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Add<Output = T::Native>
-        + Sub<Output = T::Native>
-        + Mul<Output = T::Native>
-        + Div<Output = T::Native>
-        + Rem<Output = T::Native>
-        + Zero
-        + One,
-{
-    Ok(unary(array, |value| value * scalar))
-}
-
-/// Multiply every value in an array by a scalar. If any value in the array is null then the
-/// result is also null. The given array must be a `PrimitiveArray` of the type same as
-/// the scalar, or a `DictionaryArray` of the value type same as the scalar.
-pub fn multiply_scalar_dyn<T>(array: &dyn Array, scalar: T::Native) -> Result<ArrayRef>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Add<Output = T::Native>
-        + Sub<Output = T::Native>
-        + Mul<Output = T::Native>
-        + Div<Output = T::Native>
-        + Rem<Output = T::Native>
-        + Zero
-        + One,
-{
-    unary_dyn::<_, T>(array, |value| value * scalar)
-}
-
-/// Perform `left % right` operation on two arrays. If either left or right value is null
-/// then the result is also null. If any right hand value is zero then the result of this
-/// operation will be `Err(ArrowError::DivideByZero)`.
-pub fn modulus<T>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Rem<Output = T::Native> + Zero + One,
-{
-    #[cfg(feature = "simd")]
-    return simd_checked_divide_op(&left, &right, simd_checked_modulus::<T>, |a, b| {
-        a % b
-    });
-    #[cfg(not(feature = "simd"))]
-    return math_checked_divide_op(left, right, |a, b| a % b);
-}
-
-/// Perform `left / right` operation on two arrays. If either left or right value is null
-/// then the result is also null. If any right hand value is zero then the result of this
-/// operation will be `Err(ArrowError::DivideByZero)`.
-pub fn divide<T>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Div<Output = T::Native> + Zero + One,
-{
-    #[cfg(feature = "simd")]
-    return simd_checked_divide_op(&left, &right, simd_checked_divide::<T>, |a, b| a / b);
-    #[cfg(not(feature = "simd"))]
-    return math_checked_divide_op(left, right, |a, b| a / b);
-}
-
-/// Perform `left / right` operation on two arrays. If either left or right value is null
-/// then the result is also null. If any right hand value is zero then the result of this
-/// operation will be `Err(ArrowError::DivideByZero)`.
-pub fn divide_dyn(left: &dyn Array, right: &dyn Array) -> Result<ArrayRef> {
-    match left.data_type() {
-        DataType::Dictionary(_, _) => {
-            typed_dict_math_op!(left, right, |a, b| a / b, math_divide_checked_op_dict)
-        }
-        _ => typed_math_op!(left, right, |a, b| a / b, math_checked_divide_op),
-    }
-}
-
-/// Perform `left / right` operation on two arrays without checking for division by zero.
-/// The result of dividing by zero follows normal floating point rules.
-/// If either left or right value is null then the result is also null. If any right hand value is zero then the result of this
-pub fn divide_unchecked<T>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowFloatNumericType,
-    T::Native: Div<Output = T::Native>,
-{
-    math_op(left, right, |a, b| a / b)
-}
-
-/// Modulus every value in an array by a scalar. If any value in the array is null then the
-/// result is also null. If the scalar is zero then the result of this operation will be
-/// `Err(ArrowError::DivideByZero)`.
-pub fn modulus_scalar<T>(
-    array: &PrimitiveArray<T>,
-    modulo: T::Native,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Rem<Output = T::Native> + Zero,
-{
-    if modulo.is_zero() {
-        return Err(ArrowError::DivideByZero);
-    }
-
-    Ok(unary(array, |a| a % modulo))
-}
-
-/// Divide every value in an array by a scalar. If any value in the array is null then the
-/// result is also null. If the scalar is zero then the result of this operation will be
-/// `Err(ArrowError::DivideByZero)`.
-pub fn divide_scalar<T>(
-    array: &PrimitiveArray<T>,
-    divisor: T::Native,
-) -> Result<PrimitiveArray<T>>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Div<Output = T::Native> + Zero,
-{
-    if divisor.is_zero() {
-        return Err(ArrowError::DivideByZero);
-    }
-    Ok(unary(array, |a| a / divisor))
-}
-
-/// Divide every value in an array by a scalar. If any value in the array is null then the
-/// result is also null. If the scalar is zero then the result of this operation will be
-/// `Err(ArrowError::DivideByZero)`. The given array must be a `PrimitiveArray` of the type
-/// same as the scalar, or a `DictionaryArray` of the value type same as the scalar.
-pub fn divide_scalar_dyn<T>(array: &dyn Array, divisor: T::Native) -> Result<ArrayRef>
-where
-    T: datatypes::ArrowNumericType,
-    T::Native: Div<Output = T::Native> + Zero,
-{
-    if divisor.is_zero() {
-        return Err(ArrowError::DivideByZero);
-    }
-    unary_dyn::<_, T>(array, |value| value / divisor)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::Int32Array;
-    use crate::datatypes::Date64Type;
-    use chrono::NaiveDate;
-
-    #[test]
-    fn test_primitive_array_add() {
-        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
-        let b = Int32Array::from(vec![6, 7, 8, 9, 8]);
-        let c = add(&a, &b).unwrap();
-        assert_eq!(11, c.value(0));
-        assert_eq!(13, c.value(1));
-        assert_eq!(15, c.value(2));
-        assert_eq!(17, c.value(3));
-        assert_eq!(17, c.value(4));
-    }
-
-    #[test]
-    fn test_date32_month_add() {
-        let a = Date32Array::from(vec![Date32Type::from_naive_date(
-            NaiveDate::from_ymd(2000, 1, 1),
-        )]);
-        let b =
-            IntervalYearMonthArray::from(vec![IntervalYearMonthType::make_value(1, 2)]);
-        let c = add_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Date32Array>().unwrap();
-        assert_eq!(
-            c.value(0),
-            Date32Type::from_naive_date(NaiveDate::from_ymd(2001, 3, 1))
-        );
-    }
-
-    #[test]
-    fn test_date32_day_time_add() {
-        let a = Date32Array::from(vec![Date32Type::from_naive_date(
-            NaiveDate::from_ymd(2000, 1, 1),
-        )]);
-        let b = IntervalDayTimeArray::from(vec![IntervalDayTimeType::make_value(1, 2)]);
-        let c = add_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Date32Array>().unwrap();
-        assert_eq!(
-            c.value(0),
-            Date32Type::from_naive_date(NaiveDate::from_ymd(2000, 1, 2))
-        );
-    }
-
-    #[test]
-    fn test_date32_month_day_nano_add() {
-        let a = Date32Array::from(vec![Date32Type::from_naive_date(
-            NaiveDate::from_ymd(2000, 1, 1),
-        )]);
-        let b =
-            IntervalMonthDayNanoArray::from(vec![IntervalMonthDayNanoType::make_value(
-                1, 2, 3,
-            )]);
-        let c = add_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Date32Array>().unwrap();
-        assert_eq!(
-            c.value(0),
-            Date32Type::from_naive_date(NaiveDate::from_ymd(2000, 2, 3))
-        );
-    }
-
-    #[test]
-    fn test_date64_month_add() {
-        let a = Date64Array::from(vec![Date64Type::from_naive_date(
-            NaiveDate::from_ymd(2000, 1, 1),
-        )]);
-        let b =
-            IntervalYearMonthArray::from(vec![IntervalYearMonthType::make_value(1, 2)]);
-        let c = add_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Date64Array>().unwrap();
-        assert_eq!(
-            c.value(0),
-            Date64Type::from_naive_date(NaiveDate::from_ymd(2001, 3, 1))
-        );
-    }
-
-    #[test]
-    fn test_date64_day_time_add() {
-        let a = Date64Array::from(vec![Date64Type::from_naive_date(
-            NaiveDate::from_ymd(2000, 1, 1),
-        )]);
-        let b = IntervalDayTimeArray::from(vec![IntervalDayTimeType::make_value(1, 2)]);
-        let c = add_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Date64Array>().unwrap();
-        assert_eq!(
-            c.value(0),
-            Date64Type::from_naive_date(NaiveDate::from_ymd(2000, 1, 2))
-        );
-    }
-
-    #[test]
-    fn test_date64_month_day_nano_add() {
-        let a = Date64Array::from(vec![Date64Type::from_naive_date(
-            NaiveDate::from_ymd(2000, 1, 1),
-        )]);
-        let b =
-            IntervalMonthDayNanoArray::from(vec![IntervalMonthDayNanoType::make_value(
-                1, 2, 3,
-            )]);
-        let c = add_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Date64Array>().unwrap();
-        assert_eq!(
-            c.value(0),
-            Date64Type::from_naive_date(NaiveDate::from_ymd(2000, 2, 3))
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_add_dyn() {
-        let a = Int32Array::from(vec![Some(5), Some(6), Some(7), Some(8), Some(9)]);
-        let b = Int32Array::from(vec![Some(6), Some(7), Some(8), None, Some(8)]);
-        let c = add_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(11, c.value(0));
-        assert_eq!(13, c.value(1));
-        assert_eq!(15, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(17, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_add_dyn_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(5).unwrap();
-        builder.append(6).unwrap();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append(9).unwrap();
-        let a = builder.finish();
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(6).unwrap();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append_null();
-        builder.append(10).unwrap();
-        let b = builder.finish();
-
-        let c = add_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(11, c.value(0));
-        assert_eq!(13, c.value(1));
-        assert_eq!(15, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(19, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_add_scalar_dyn() {
-        let a = Int32Array::from(vec![Some(5), Some(6), Some(7), None, Some(9)]);
-        let b = 1_i32;
-        let c = add_scalar_dyn::<Int32Type>(&a, b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(6, c.value(0));
-        assert_eq!(7, c.value(1));
-        assert_eq!(8, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(10, c.value(4));
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(5).unwrap();
-        builder.append_null();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append(9).unwrap();
-        let a = builder.finish();
-        let b = -1_i32;
-
-        let c = add_scalar_dyn::<Int32Type>(&a, b).unwrap();
-        let c = c
-            .as_any()
-            .downcast_ref::<DictionaryArray<Int8Type>>()
-            .unwrap();
-        let values = c
-            .values()
-            .as_any()
-            .downcast_ref::<PrimitiveArray<Int32Type>>()
-            .unwrap();
-        assert_eq!(4, values.value(c.key(0).unwrap()));
-        assert!(c.is_null(1));
-        assert_eq!(6, values.value(c.key(2).unwrap()));
-        assert_eq!(7, values.value(c.key(3).unwrap()));
-        assert_eq!(8, values.value(c.key(4).unwrap()));
-    }
-
-    #[test]
-    fn test_primitive_array_subtract_dyn() {
-        let a = Int32Array::from(vec![Some(51), Some(6), Some(15), Some(8), Some(9)]);
-        let b = Int32Array::from(vec![Some(6), Some(7), Some(8), None, Some(8)]);
-        let c = subtract_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(45, c.value(0));
-        assert_eq!(-1, c.value(1));
-        assert_eq!(7, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(1, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_subtract_dyn_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(15).unwrap();
-        builder.append(8).unwrap();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append(20).unwrap();
-        let a = builder.finish();
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(6).unwrap();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append_null();
-        builder.append(10).unwrap();
-        let b = builder.finish();
-
-        let c = subtract_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(9, c.value(0));
-        assert_eq!(1, c.value(1));
-        assert_eq!(-1, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(10, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_subtract_scalar_dyn() {
-        let a = Int32Array::from(vec![Some(5), Some(6), Some(7), None, Some(9)]);
-        let b = 1_i32;
-        let c = subtract_scalar_dyn::<Int32Type>(&a, b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(4, c.value(0));
-        assert_eq!(5, c.value(1));
-        assert_eq!(6, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(8, c.value(4));
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(5).unwrap();
-        builder.append_null();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append(9).unwrap();
-        let a = builder.finish();
-        let b = -1_i32;
-
-        let c = subtract_scalar_dyn::<Int32Type>(&a, b).unwrap();
-        let c = c
-            .as_any()
-            .downcast_ref::<DictionaryArray<Int8Type>>()
-            .unwrap();
-        let values = c
-            .values()
-            .as_any()
-            .downcast_ref::<PrimitiveArray<Int32Type>>()
-            .unwrap();
-        assert_eq!(6, values.value(c.key(0).unwrap()));
-        assert!(c.is_null(1));
-        assert_eq!(8, values.value(c.key(2).unwrap()));
-        assert_eq!(9, values.value(c.key(3).unwrap()));
-        assert_eq!(10, values.value(c.key(4).unwrap()));
-    }
-
-    #[test]
-    fn test_primitive_array_multiply_dyn() {
-        let a = Int32Array::from(vec![Some(5), Some(6), Some(7), Some(8), Some(9)]);
-        let b = Int32Array::from(vec![Some(6), Some(7), Some(8), None, Some(8)]);
-        let c = multiply_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(30, c.value(0));
-        assert_eq!(42, c.value(1));
-        assert_eq!(56, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(72, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_multiply_dyn_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(5).unwrap();
-        builder.append(6).unwrap();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append(9).unwrap();
-        let a = builder.finish();
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(6).unwrap();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append_null();
-        builder.append(10).unwrap();
-        let b = builder.finish();
-
-        let c = multiply_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(30, c.value(0));
-        assert_eq!(42, c.value(1));
-        assert_eq!(56, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(90, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_divide_dyn() {
-        let a = Int32Array::from(vec![Some(15), Some(6), Some(1), Some(8), Some(9)]);
-        let b = Int32Array::from(vec![Some(5), Some(3), Some(1), None, Some(3)]);
-        let c = divide_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(3, c.value(0));
-        assert_eq!(2, c.value(1));
-        assert_eq!(1, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(3, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_divide_dyn_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(15).unwrap();
-        builder.append(6).unwrap();
-        builder.append(1).unwrap();
-        builder.append(8).unwrap();
-        builder.append(9).unwrap();
-        let a = builder.finish();
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(5).unwrap();
-        builder.append(3).unwrap();
-        builder.append(1).unwrap();
-        builder.append_null();
-        builder.append(3).unwrap();
-        let b = builder.finish();
-
-        let c = divide_dyn(&a, &b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(3, c.value(0));
-        assert_eq!(2, c.value(1));
-        assert_eq!(1, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(3, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_multiply_scalar_dyn() {
-        let a = Int32Array::from(vec![Some(5), Some(6), Some(7), None, Some(9)]);
-        let b = 2_i32;
-        let c = multiply_scalar_dyn::<Int32Type>(&a, b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(10, c.value(0));
-        assert_eq!(12, c.value(1));
-        assert_eq!(14, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(18, c.value(4));
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(5).unwrap();
-        builder.append_null();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append(9).unwrap();
-        let a = builder.finish();
-        let b = -1_i32;
-
-        let c = multiply_scalar_dyn::<Int32Type>(&a, b).unwrap();
-        let c = c
-            .as_any()
-            .downcast_ref::<DictionaryArray<Int8Type>>()
-            .unwrap();
-        let values = c
-            .values()
-            .as_any()
-            .downcast_ref::<PrimitiveArray<Int32Type>>()
-            .unwrap();
-        assert_eq!(-5, values.value(c.key(0).unwrap()));
-        assert!(c.is_null(1));
-        assert_eq!(-7, values.value(c.key(2).unwrap()));
-        assert_eq!(-8, values.value(c.key(3).unwrap()));
-        assert_eq!(-9, values.value(c.key(4).unwrap()));
-    }
-
-    #[test]
-    fn test_primitive_array_add_sliced() {
-        let a = Int32Array::from(vec![0, 0, 0, 5, 6, 7, 8, 9, 0]);
-        let b = Int32Array::from(vec![0, 0, 0, 6, 7, 8, 9, 8, 0]);
-        let a = a.slice(3, 5);
-        let b = b.slice(3, 5);
-        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
-        let b = b.as_any().downcast_ref::<Int32Array>().unwrap();
-
-        assert_eq!(5, a.value(0));
-        assert_eq!(6, b.value(0));
-
-        let c = add(a, b).unwrap();
-        assert_eq!(5, c.len());
-        assert_eq!(11, c.value(0));
-        assert_eq!(13, c.value(1));
-        assert_eq!(15, c.value(2));
-        assert_eq!(17, c.value(3));
-        assert_eq!(17, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_add_mismatched_length() {
-        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
-        let b = Int32Array::from(vec![6, 7, 8]);
-        let e = add(&a, &b).expect_err("should have failed due to different lengths");
-        assert_eq!(
-            "ComputeError(\"Cannot perform math operation on arrays of different length\")",
-            format!("{:?}", e)
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_add_scalar() {
-        let a = Int32Array::from(vec![15, 14, 9, 8, 1]);
-        let b = 3;
-        let c = add_scalar(&a, b).unwrap();
-        let expected = Int32Array::from(vec![18, 17, 12, 11, 4]);
-        assert_eq!(c, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_add_scalar_sliced() {
-        let a = Int32Array::from(vec![Some(15), None, Some(9), Some(8), None]);
-        let a = a.slice(1, 4);
-        let a = as_primitive_array(&a);
-        let actual = add_scalar(a, 3).unwrap();
-        let expected = Int32Array::from(vec![None, Some(12), Some(11), None]);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_subtract() {
-        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
-        let b = Int32Array::from(vec![5, 4, 3, 2, 1]);
-        let c = subtract(&a, &b).unwrap();
-        assert_eq!(-4, c.value(0));
-        assert_eq!(-2, c.value(1));
-        assert_eq!(0, c.value(2));
-        assert_eq!(2, c.value(3));
-        assert_eq!(4, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_subtract_scalar() {
-        let a = Int32Array::from(vec![15, 14, 9, 8, 1]);
-        let b = 3;
-        let c = subtract_scalar(&a, b).unwrap();
-        let expected = Int32Array::from(vec![12, 11, 6, 5, -2]);
-        assert_eq!(c, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_subtract_scalar_sliced() {
-        let a = Int32Array::from(vec![Some(15), None, Some(9), Some(8), None]);
-        let a = a.slice(1, 4);
-        let a = as_primitive_array(&a);
-        let actual = subtract_scalar(a, 3).unwrap();
-        let expected = Int32Array::from(vec![None, Some(6), Some(5), None]);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_multiply() {
-        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
-        let b = Int32Array::from(vec![6, 7, 8, 9, 8]);
-        let c = multiply(&a, &b).unwrap();
-        assert_eq!(30, c.value(0));
-        assert_eq!(42, c.value(1));
-        assert_eq!(56, c.value(2));
-        assert_eq!(72, c.value(3));
-        assert_eq!(72, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_multiply_scalar() {
-        let a = Int32Array::from(vec![15, 14, 9, 8, 1]);
-        let b = 3;
-        let c = multiply_scalar(&a, b).unwrap();
-        let expected = Int32Array::from(vec![45, 42, 27, 24, 3]);
-        assert_eq!(c, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_multiply_scalar_sliced() {
-        let a = Int32Array::from(vec![Some(15), None, Some(9), Some(8), None]);
-        let a = a.slice(1, 4);
-        let a = as_primitive_array(&a);
-        let actual = multiply_scalar(a, 3).unwrap();
-        let expected = Int32Array::from(vec![None, Some(27), Some(24), None]);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_divide() {
-        let a = Int32Array::from(vec![15, 15, 8, 1, 9]);
-        let b = Int32Array::from(vec![5, 6, 8, 9, 1]);
-        let c = divide(&a, &b).unwrap();
-        assert_eq!(3, c.value(0));
-        assert_eq!(2, c.value(1));
-        assert_eq!(1, c.value(2));
-        assert_eq!(0, c.value(3));
-        assert_eq!(9, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_modulus() {
-        let a = Int32Array::from(vec![15, 15, 8, 1, 9]);
-        let b = Int32Array::from(vec![5, 6, 8, 9, 1]);
-        let c = modulus(&a, &b).unwrap();
-        assert_eq!(0, c.value(0));
-        assert_eq!(3, c.value(1));
-        assert_eq!(0, c.value(2));
-        assert_eq!(1, c.value(3));
-        assert_eq!(0, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_divide_scalar() {
-        let a = Int32Array::from(vec![15, 14, 9, 8, 1]);
-        let b = 3;
-        let c = divide_scalar(&a, b).unwrap();
-        let expected = Int32Array::from(vec![5, 4, 3, 2, 0]);
-        assert_eq!(c, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_divide_scalar_dyn() {
-        let a = Int32Array::from(vec![Some(5), Some(6), Some(7), None, Some(9)]);
-        let b = 2_i32;
-        let c = divide_scalar_dyn::<Int32Type>(&a, b).unwrap();
-        let c = c.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(2, c.value(0));
-        assert_eq!(3, c.value(1));
-        assert_eq!(3, c.value(2));
-        assert!(c.is_null(3));
-        assert_eq!(4, c.value(4));
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(5).unwrap();
-        builder.append_null();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append(9).unwrap();
-        let a = builder.finish();
-        let b = -2_i32;
-
-        let c = divide_scalar_dyn::<Int32Type>(&a, b).unwrap();
-        let c = c
-            .as_any()
-            .downcast_ref::<DictionaryArray<Int8Type>>()
-            .unwrap();
-        let values = c
-            .values()
-            .as_any()
-            .downcast_ref::<PrimitiveArray<Int32Type>>()
-            .unwrap();
-        assert_eq!(-2, values.value(c.key(0).unwrap()));
-        assert!(c.is_null(1));
-        assert_eq!(-3, values.value(c.key(2).unwrap()));
-        assert_eq!(-4, values.value(c.key(3).unwrap()));
-        assert_eq!(-4, values.value(c.key(4).unwrap()));
-
-        let e = divide_scalar_dyn::<Int32Type>(&a, 0_i32)
-            .expect_err("should have failed due to divide by zero");
-        assert_eq!("DivideByZero", format!("{:?}", e));
-    }
-
-    #[test]
-    fn test_primitive_array_divide_scalar_sliced() {
-        let a = Int32Array::from(vec![Some(15), None, Some(9), Some(8), None]);
-        let a = a.slice(1, 4);
-        let a = as_primitive_array(&a);
-        let actual = divide_scalar(a, 3).unwrap();
-        let expected = Int32Array::from(vec![None, Some(3), Some(2), None]);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_modulus_scalar() {
-        let a = Int32Array::from(vec![15, 14, 9, 8, 1]);
-        let b = 3;
-        let c = modulus_scalar(&a, b).unwrap();
-        let expected = Int32Array::from(vec![0, 2, 0, 2, 1]);
-        assert_eq!(c, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_modulus_scalar_sliced() {
-        let a = Int32Array::from(vec![Some(15), None, Some(9), Some(8), None]);
-        let a = a.slice(1, 4);
-        let a = as_primitive_array(&a);
-        let actual = modulus_scalar(a, 3).unwrap();
-        let expected = Int32Array::from(vec![None, Some(0), Some(2), None]);
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_divide_sliced() {
-        let a = Int32Array::from(vec![0, 0, 0, 15, 15, 8, 1, 9, 0]);
-        let b = Int32Array::from(vec![0, 0, 0, 5, 6, 8, 9, 1, 0]);
-        let a = a.slice(3, 5);
-        let b = b.slice(3, 5);
-        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
-        let b = b.as_any().downcast_ref::<Int32Array>().unwrap();
-
-        let c = divide(a, b).unwrap();
-        assert_eq!(5, c.len());
-        assert_eq!(3, c.value(0));
-        assert_eq!(2, c.value(1));
-        assert_eq!(1, c.value(2));
-        assert_eq!(0, c.value(3));
-        assert_eq!(9, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_modulus_sliced() {
-        let a = Int32Array::from(vec![0, 0, 0, 15, 15, 8, 1, 9, 0]);
-        let b = Int32Array::from(vec![0, 0, 0, 5, 6, 8, 9, 1, 0]);
-        let a = a.slice(3, 5);
-        let b = b.slice(3, 5);
-        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
-        let b = b.as_any().downcast_ref::<Int32Array>().unwrap();
-
-        let c = modulus(a, b).unwrap();
-        assert_eq!(5, c.len());
-        assert_eq!(0, c.value(0));
-        assert_eq!(3, c.value(1));
-        assert_eq!(0, c.value(2));
-        assert_eq!(1, c.value(3));
-        assert_eq!(0, c.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_divide_with_nulls() {
-        let a = Int32Array::from(vec![Some(15), None, Some(8), Some(1), Some(9), None]);
-        let b = Int32Array::from(vec![Some(5), Some(6), Some(8), Some(9), None, None]);
-        let c = divide(&a, &b).unwrap();
-        assert_eq!(3, c.value(0));
-        assert!(c.is_null(1));
-        assert_eq!(1, c.value(2));
-        assert_eq!(0, c.value(3));
-        assert!(c.is_null(4));
-        assert!(c.is_null(5));
-    }
-
-    #[test]
-    fn test_primitive_array_modulus_with_nulls() {
-        let a = Int32Array::from(vec![Some(15), None, Some(8), Some(1), Some(9), None]);
-        let b = Int32Array::from(vec![Some(5), Some(6), Some(8), Some(9), None, None]);
-        let c = modulus(&a, &b).unwrap();
-        assert_eq!(0, c.value(0));
-        assert!(c.is_null(1));
-        assert_eq!(0, c.value(2));
-        assert_eq!(1, c.value(3));
-        assert!(c.is_null(4));
-        assert!(c.is_null(5));
-    }
-
-    #[test]
-    fn test_primitive_array_divide_scalar_with_nulls() {
-        let a = Int32Array::from(vec![Some(15), None, Some(8), Some(1), Some(9), None]);
-        let b = 3;
-        let c = divide_scalar(&a, b).unwrap();
-        let expected =
-            Int32Array::from(vec![Some(5), None, Some(2), Some(0), Some(3), None]);
-        assert_eq!(c, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_modulus_scalar_with_nulls() {
-        let a = Int32Array::from(vec![Some(15), None, Some(8), Some(1), Some(9), None]);
-        let b = 3;
-        let c = modulus_scalar(&a, b).unwrap();
-        let expected =
-            Int32Array::from(vec![Some(0), None, Some(2), Some(1), Some(0), None]);
-        assert_eq!(c, expected);
-    }
-
-    #[test]
-    fn test_primitive_array_divide_with_nulls_sliced() {
-        let a = Int32Array::from(vec![
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(15),
-            None,
-            Some(8),
-            Some(1),
-            Some(9),
-            None,
-            None,
-        ]);
-        let b = Int32Array::from(vec![
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(5),
-            Some(6),
-            Some(8),
-            Some(9),
-            None,
-            None,
-            None,
-        ]);
-
-        let a = a.slice(8, 6);
-        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
-
-        let b = b.slice(8, 6);
-        let b = b.as_any().downcast_ref::<Int32Array>().unwrap();
-
-        let c = divide(a, b).unwrap();
-        assert_eq!(6, c.len());
-        assert_eq!(3, c.value(0));
-        assert!(c.is_null(1));
-        assert_eq!(1, c.value(2));
-        assert_eq!(0, c.value(3));
-        assert!(c.is_null(4));
-        assert!(c.is_null(5));
-    }
-
-    #[test]
-    fn test_primitive_array_modulus_with_nulls_sliced() {
-        let a = Int32Array::from(vec![
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(15),
-            None,
-            Some(8),
-            Some(1),
-            Some(9),
-            None,
-            None,
-        ]);
-        let b = Int32Array::from(vec![
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            None,
-            Some(5),
-            Some(6),
-            Some(8),
-            Some(9),
-            None,
-            None,
-            None,
-        ]);
-
-        let a = a.slice(8, 6);
-        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
-
-        let b = b.slice(8, 6);
-        let b = b.as_any().downcast_ref::<Int32Array>().unwrap();
-
-        let c = modulus(a, b).unwrap();
-        assert_eq!(6, c.len());
-        assert_eq!(0, c.value(0));
-        assert!(c.is_null(1));
-        assert_eq!(0, c.value(2));
-        assert_eq!(1, c.value(3));
-        assert!(c.is_null(4));
-        assert!(c.is_null(5));
-    }
-
-    #[test]
-    #[should_panic(expected = "DivideByZero")]
-    fn test_primitive_array_divide_by_zero() {
-        let a = Int32Array::from(vec![15]);
-        let b = Int32Array::from(vec![0]);
-        divide(&a, &b).unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "DivideByZero")]
-    fn test_primitive_array_divide_dyn_by_zero() {
-        let a = Int32Array::from(vec![15]);
-        let b = Int32Array::from(vec![0]);
-        divide_dyn(&a, &b).unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "DivideByZero")]
-    fn test_primitive_array_divide_dyn_by_zero_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(1);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(1);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(15).unwrap();
-        let a = builder.finish();
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(1);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(1);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(0).unwrap();
-        let b = builder.finish();
-
-        divide_dyn(&a, &b).unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "DivideByZero")]
-    fn test_primitive_array_modulus_by_zero() {
-        let a = Int32Array::from(vec![15]);
-        let b = Int32Array::from(vec![0]);
-        modulus(&a, &b).unwrap();
-    }
-
-    #[test]
-    fn test_primitive_array_divide_f64() {
-        let a = Float64Array::from(vec![15.0, 15.0, 8.0]);
-        let b = Float64Array::from(vec![5.0, 6.0, 8.0]);
-        let c = divide(&a, &b).unwrap();
-        assert_eq!(3.0, c.value(0));
-        assert_eq!(2.5, c.value(1));
-        assert_eq!(1.0, c.value(2));
-    }
-
-    #[test]
-    fn test_primitive_array_add_with_nulls() {
-        let a = Int32Array::from(vec![Some(5), None, Some(7), None]);
-        let b = Int32Array::from(vec![None, None, Some(6), Some(7)]);
-        let c = add(&a, &b).unwrap();
-        assert!(c.is_null(0));
-        assert!(c.is_null(1));
-        assert!(!c.is_null(2));
-        assert!(c.is_null(3));
-        assert_eq!(13, c.value(2));
-    }
-
-    #[test]
-    fn test_primitive_array_negate() {
-        let a: Int64Array = (0..100).into_iter().map(Some).collect();
-        let actual = negate(&a).unwrap();
-        let expected: Int64Array = (0..100).into_iter().map(|i| Some(-i)).collect();
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn test_arithmetic_kernel_should_not_rely_on_padding() {
-        let a: UInt8Array = (0..128_u8).into_iter().map(Some).collect();
-        let a = a.slice(63, 65);
-        let a = a.as_any().downcast_ref::<UInt8Array>().unwrap();
-
-        let b: UInt8Array = (0..128_u8).into_iter().map(Some).collect();
-        let b = b.slice(63, 65);
-        let b = b.as_any().downcast_ref::<UInt8Array>().unwrap();
-
-        let actual = add(a, b).unwrap();
-        let actual: Vec<Option<u8>> = actual.iter().collect();
-        let expected: Vec<Option<u8>> = (63..63_u8 + 65_u8)
-            .into_iter()
-            .map(|i| Some(i + i))
-            .collect();
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn test_primitive_array_raise_power_scalar() {
-        let a = Float64Array::from(vec![1.0, 2.0, 3.0]);
-        let actual = powf_scalar(&a, 2.0).unwrap();
-        let expected = Float64Array::from(vec![1.0, 4.0, 9.0]);
-        assert_eq!(expected, actual);
-        let a = Float64Array::from(vec![Some(1.0), None, Some(3.0)]);
-        let actual = powf_scalar(&a, 2.0).unwrap();
-        let expected = Float64Array::from(vec![Some(1.0), None, Some(9.0)]);
-        assert_eq!(expected, actual);
-    }
-}
diff --git a/arrow/src/compute/kernels/arity.rs b/arrow/src/compute/kernels/arity.rs
deleted file mode 100644
index 3af9306d5268..000000000000
--- a/arrow/src/compute/kernels/arity.rs
+++ /dev/null
@@ -1,271 +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.
-
-//! Defines kernels suitable to perform operations to primitive arrays.
-
-use crate::array::{Array, ArrayData, ArrayRef, DictionaryArray, PrimitiveArray};
-use crate::buffer::Buffer;
-use crate::datatypes::{
-    ArrowNumericType, ArrowPrimitiveType, DataType, Int16Type, Int32Type, Int64Type,
-    Int8Type, UInt16Type, UInt32Type, UInt64Type, UInt8Type,
-};
-use crate::error::{ArrowError, Result};
-use std::sync::Arc;
-
-#[inline]
-fn into_primitive_array_data<I: ArrowPrimitiveType, O: ArrowPrimitiveType>(
-    array: &PrimitiveArray<I>,
-    buffer: Buffer,
-) -> ArrayData {
-    unsafe {
-        ArrayData::new_unchecked(
-            O::DATA_TYPE,
-            array.len(),
-            None,
-            array
-                .data_ref()
-                .null_buffer()
-                .map(|b| b.bit_slice(array.offset(), array.len())),
-            0,
-            vec![buffer],
-            vec![],
-        )
-    }
-}
-
-/// Applies an unary and infallible function to a primitive array.
-/// This is the fastest way to perform an operation on a primitive array when
-/// the benefits of a vectorized operation outweights the cost of branching nulls and non-nulls.
-/// # Implementation
-/// This will apply the function for all values, including those on null slots.
-/// This implies that the operation must be infallible for any value of the corresponding type
-/// or this function may panic.
-/// # Example
-/// ```rust
-/// # use arrow::array::Int32Array;
-/// # use arrow::datatypes::Int32Type;
-/// # use arrow::compute::kernels::arity::unary;
-/// # fn main() {
-/// let array = Int32Array::from(vec![Some(5), Some(7), None]);
-/// let c = unary::<_, _, Int32Type>(&array, |x| x * 2 + 1);
-/// assert_eq!(c, Int32Array::from(vec![Some(11), Some(15), None]));
-/// # }
-/// ```
-pub fn unary<I, F, O>(array: &PrimitiveArray<I>, op: F) -> PrimitiveArray<O>
-where
-    I: ArrowPrimitiveType,
-    O: ArrowPrimitiveType,
-    F: Fn(I::Native) -> O::Native,
-{
-    let values = array.values().iter().map(|v| op(*v));
-    // JUSTIFICATION
-    //  Benefit
-    //      ~60% speedup
-    //  Soundness
-    //      `values` is an iterator with a known size because arrays are sized.
-    let buffer = unsafe { Buffer::from_trusted_len_iter(values) };
-
-    let data = into_primitive_array_data::<_, O>(array, buffer);
-    PrimitiveArray::<O>::from(data)
-}
-
-/// A helper function that applies an unary function to a dictionary array with primitive value type.
-#[allow(clippy::redundant_closure)]
-fn unary_dict<K, F, T>(array: &DictionaryArray<K>, op: F) -> Result<ArrayRef>
-where
-    K: ArrowNumericType,
-    T: ArrowPrimitiveType,
-    F: Fn(T::Native) -> T::Native,
-{
-    let dict_values = array
-        .values()
-        .as_any()
-        .downcast_ref::<PrimitiveArray<T>>()
-        .unwrap();
-
-    let values = dict_values
-        .iter()
-        .map(|v| v.map(|value| op(value)))
-        .collect::<PrimitiveArray<T>>();
-
-    let keys = array.keys();
-
-    let mut data = ArrayData::builder(array.data_type().clone())
-        .len(keys.len())
-        .add_buffer(keys.data().buffers()[0].clone())
-        .add_child_data(values.data().clone());
-
-    match keys.data().null_buffer() {
-        Some(buffer) if keys.data().null_count() > 0 => {
-            data = data
-                .null_bit_buffer(Some(buffer.clone()))
-                .null_count(keys.data().null_count());
-        }
-        _ => data = data.null_count(0),
-    }
-
-    let new_dict: DictionaryArray<K> = unsafe { data.build_unchecked() }.into();
-    Ok(Arc::new(new_dict))
-}
-
-/// Applies an unary function to an array with primitive values.
-pub fn unary_dyn<F, T>(array: &dyn Array, op: F) -> Result<ArrayRef>
-where
-    T: ArrowPrimitiveType,
-    F: Fn(T::Native) -> T::Native,
-{
-    match array.data_type() {
-        DataType::Dictionary(key_type, _) => match key_type.as_ref() {
-            DataType::Int8 => unary_dict::<_, F, T>(
-                array
-                    .as_any()
-                    .downcast_ref::<DictionaryArray<Int8Type>>()
-                    .unwrap(),
-                op,
-            ),
-            DataType::Int16 => unary_dict::<_, F, T>(
-                array
-                    .as_any()
-                    .downcast_ref::<DictionaryArray<Int16Type>>()
-                    .unwrap(),
-                op,
-            ),
-            DataType::Int32 => unary_dict::<_, F, T>(
-                array
-                    .as_any()
-                    .downcast_ref::<DictionaryArray<Int32Type>>()
-                    .unwrap(),
-                op,
-            ),
-            DataType::Int64 => unary_dict::<_, F, T>(
-                array
-                    .as_any()
-                    .downcast_ref::<DictionaryArray<Int64Type>>()
-                    .unwrap(),
-                op,
-            ),
-            DataType::UInt8 => unary_dict::<_, F, T>(
-                array
-                    .as_any()
-                    .downcast_ref::<DictionaryArray<UInt8Type>>()
-                    .unwrap(),
-                op,
-            ),
-            DataType::UInt16 => unary_dict::<_, F, T>(
-                array
-                    .as_any()
-                    .downcast_ref::<DictionaryArray<UInt16Type>>()
-                    .unwrap(),
-                op,
-            ),
-            DataType::UInt32 => unary_dict::<_, F, T>(
-                array
-                    .as_any()
-                    .downcast_ref::<DictionaryArray<UInt32Type>>()
-                    .unwrap(),
-                op,
-            ),
-            DataType::UInt64 => unary_dict::<_, F, T>(
-                array
-                    .as_any()
-                    .downcast_ref::<DictionaryArray<UInt64Type>>()
-                    .unwrap(),
-                op,
-            ),
-            t => Err(ArrowError::NotYetImplemented(format!(
-                "Cannot perform unary operation on dictionary array of key type {}.",
-                t
-            ))),
-        },
-        _ => Ok(Arc::new(unary::<T, F, T>(
-            array.as_any().downcast_ref::<PrimitiveArray<T>>().unwrap(),
-            op,
-        ))),
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::{
-        as_primitive_array, Float64Array, PrimitiveBuilder, PrimitiveDictionaryBuilder,
-    };
-    use crate::datatypes::{Float64Type, Int32Type, Int8Type};
-
-    #[test]
-    fn test_unary_f64_slice() {
-        let input =
-            Float64Array::from(vec![Some(5.1f64), None, Some(6.8), None, Some(7.2)]);
-        let input_slice = input.slice(1, 4);
-        let input_slice: &Float64Array = as_primitive_array(&input_slice);
-        let result = unary(input_slice, |n| n.round());
-        assert_eq!(
-            result,
-            Float64Array::from(vec![None, Some(7.0), None, Some(7.0)])
-        );
-
-        let result = unary_dyn::<_, Float64Type>(input_slice, |n| n + 1.0).unwrap();
-
-        assert_eq!(
-            result.as_any().downcast_ref::<Float64Array>().unwrap(),
-            &Float64Array::from(vec![None, Some(7.8), None, Some(8.2)])
-        );
-    }
-
-    #[test]
-    fn test_unary_dict_and_unary_dyn() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(5).unwrap();
-        builder.append(6).unwrap();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append_null();
-        builder.append(9).unwrap();
-        let dictionary_array = builder.finish();
-
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(6).unwrap();
-        builder.append(7).unwrap();
-        builder.append(8).unwrap();
-        builder.append(9).unwrap();
-        builder.append_null();
-        builder.append(10).unwrap();
-        let expected = builder.finish();
-
-        let result = unary_dict::<_, _, Int32Type>(&dictionary_array, |n| n + 1).unwrap();
-        assert_eq!(
-            result
-                .as_any()
-                .downcast_ref::<DictionaryArray<Int8Type>>()
-                .unwrap(),
-            &expected
-        );
-
-        let result = unary_dyn::<_, Int32Type>(&dictionary_array, |n| n + 1).unwrap();
-        assert_eq!(
-            result
-                .as_any()
-                .downcast_ref::<DictionaryArray<Int8Type>>()
-                .unwrap(),
-            &expected
-        );
-    }
-}
diff --git a/arrow/src/compute/kernels/cast.rs b/arrow/src/compute/kernels/cast.rs
deleted file mode 100644
index ddca0c2e9351..000000000000
--- a/arrow/src/compute/kernels/cast.rs
+++ /dev/null
@@ -1,5434 +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.
-
-//! Defines cast kernels for `ArrayRef`, to convert `Array`s between
-//! supported datatypes.
-//!
-//! Example:
-//!
-//! ```
-//! use arrow::array::*;
-//! use arrow::compute::cast;
-//! use arrow::datatypes::DataType;
-//! use std::sync::Arc;
-//!
-//! let a = Int32Array::from(vec![5, 6, 7]);
-//! let array = Arc::new(a) as ArrayRef;
-//! let b = cast(&array, &DataType::Float64).unwrap();
-//! let c = b.as_any().downcast_ref::<Float64Array>().unwrap();
-//! assert_eq!(5.0, c.value(0));
-//! assert_eq!(6.0, c.value(1));
-//! assert_eq!(7.0, c.value(2));
-//! ```
-
-use chrono::Timelike;
-use std::ops::{Div, Mul};
-use std::str;
-use std::sync::Arc;
-
-use crate::buffer::MutableBuffer;
-use crate::compute::divide_scalar;
-use crate::compute::kernels::arithmetic::{divide, multiply};
-use crate::compute::kernels::arity::unary;
-use crate::compute::kernels::cast_utils::string_to_timestamp_nanos;
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-use crate::temporal_conversions::{
-    EPOCH_DAYS_FROM_CE, MICROSECONDS, MILLISECONDS, MILLISECONDS_IN_DAY, NANOSECONDS,
-    SECONDS_IN_DAY,
-};
-use crate::{array::*, compute::take};
-use crate::{buffer::Buffer, util::serialization::lexical_to_string};
-use num::cast::AsPrimitive;
-use num::{BigInt, NumCast, ToPrimitive};
-
-/// CastOptions provides a way to override the default cast behaviors
-#[derive(Debug)]
-pub struct CastOptions {
-    /// how to handle cast failures, either return NULL (safe=true) or return ERR (safe=false)
-    pub safe: bool,
-}
-
-pub const DEFAULT_CAST_OPTIONS: CastOptions = CastOptions { safe: true };
-
-/// Return true if a value of type `from_type` can be cast into a
-/// value of `to_type`. Note that such as cast may be lossy.
-///
-/// If this function returns true to stay consistent with the `cast` kernel below.
-pub fn can_cast_types(from_type: &DataType, to_type: &DataType) -> bool {
-    use self::DataType::*;
-    if from_type == to_type {
-        return true;
-    }
-
-    match (from_type, to_type) {
-        // TODO UTF8/unsigned numeric to decimal
-        // cast one decimal type to another decimal type
-        (Decimal128(_, _), Decimal128(_, _)) => true,
-        (Decimal256(_, _), Decimal256(_, _)) => true,
-        (Decimal128(_, _), Decimal256(_, _)) => true,
-        (Decimal256(_, _), Decimal128(_, _)) => true,
-        // signed numeric to decimal
-        (Null | Int8 | Int16 | Int32 | Int64 | Float32 | Float64, Decimal128(_, _)) |
-        // decimal to signed numeric
-        (Decimal128(_, _), Null | Int8 | Int16 | Int32 | Int64 | Float32 | Float64)
-        | (
-            Null,
-            Boolean
-            | Int8
-            | UInt8
-            | Int16
-            | UInt16
-            | Int32
-            | UInt32
-            | Float32
-            | Date32
-            | Time32(_)
-            | Int64
-            | UInt64
-            | Float64
-            | Date64
-            | Timestamp(_, _)
-            | Time64(_)
-            | Duration(_)
-            | Interval(_)
-            | FixedSizeBinary(_)
-            | Binary
-            | Utf8
-            | LargeBinary
-            | LargeUtf8
-            | List(_)
-            | LargeList(_)
-            | FixedSizeList(_, _)
-            | Struct(_)
-            | Map(_, _)
-            | Dictionary(_, _)
-        ) => true,
-        (Decimal128(_, _), _) => false,
-        (_, Decimal128(_, _)) => false,
-        (Struct(_), _) => false,
-        (_, Struct(_)) => false,
-        (LargeList(list_from), LargeList(list_to)) => {
-            can_cast_types(list_from.data_type(), list_to.data_type())
-        }
-        (List(list_from), List(list_to)) => {
-            can_cast_types(list_from.data_type(), list_to.data_type())
-        }
-        (List(list_from), LargeList(list_to)) => {
-            list_from.data_type() == list_to.data_type()
-        }
-        (List(_), _) => false,
-        (_, List(list_to)) => can_cast_types(from_type, list_to.data_type()),
-        (_, LargeList(list_to)) => can_cast_types(from_type, list_to.data_type()),
-        (Dictionary(_, from_value_type), Dictionary(_, to_value_type)) => {
-            can_cast_types(from_value_type, to_value_type)
-        }
-        (Dictionary(_, value_type), _) => can_cast_types(value_type, to_type),
-        (_, Dictionary(_, value_type)) => can_cast_types(from_type, value_type),
-
-        (_, Boolean) => DataType::is_numeric(from_type) || from_type == &Utf8,
-        (Boolean, _) => DataType::is_numeric(to_type) || to_type == &Utf8,
-
-        (Utf8, LargeUtf8) => true,
-        (LargeUtf8, Utf8) => true,
-        (Utf8,
-            Date32
-            | Date64
-            | Time32(TimeUnit::Second)
-            | Time32(TimeUnit::Millisecond)
-            | Time64(TimeUnit::Microsecond)
-            | Time64(TimeUnit::Nanosecond)
-            | Timestamp(TimeUnit::Nanosecond, None)
-        ) => true,
-        (Utf8, _) => DataType::is_numeric(to_type),
-        (LargeUtf8,
-            Date32
-            | Date64
-            | Time32(TimeUnit::Second)
-            | Time32(TimeUnit::Millisecond)
-            | Time64(TimeUnit::Microsecond)
-            | Time64(TimeUnit::Nanosecond)
-            | Timestamp(TimeUnit::Nanosecond, None)
-        ) => true,
-        (LargeUtf8, _) => DataType::is_numeric(to_type),
-        (Timestamp(_, _), Utf8) | (Timestamp(_, _), LargeUtf8) => true,
-        (Date32, Utf8) | (Date32, LargeUtf8) => true,
-        (Date64, Utf8) | (Date64, LargeUtf8) => true,
-        (_, Utf8 | LargeUtf8) => DataType::is_numeric(from_type) || from_type == &Binary,
-
-        // start numeric casts
-        (
-            UInt8,
-            UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float32 | Float64,
-        ) => true,
-
-        (
-            UInt16,
-            UInt8 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float32 | Float64,
-        ) => true,
-
-        (
-            UInt32,
-            UInt8 | UInt16 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float32 | Float64,
-        ) => true,
-
-        (
-            UInt64,
-            UInt8 | UInt16 | UInt32 | Int8 | Int16 | Int32 | Int64 | Float32 | Float64,
-        ) => true,
-
-        (
-            Int8,
-            UInt8 | UInt16 | UInt32 | UInt64 | Int16 | Int32 | Int64 | Float32 | Float64,
-        ) => true,
-
-        (
-            Int16,
-            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int32 | Int64 | Float32 | Float64,
-        ) => true,
-
-        (
-            Int32,
-            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int64 | Float32 | Float64,
-        ) => true,
-
-        (
-            Int64,
-            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Float32 | Float64,
-        ) => true,
-
-        (
-            Float32,
-            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float64,
-        ) => true,
-
-        (
-            Float64,
-            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64 | Float32,
-        ) => true,
-        // end numeric casts
-
-        // temporal casts
-        (Int32, Date32 | Date64 | Time32(_)) => true,
-        (Date32, Int32 | Int64) => true,
-        (Time32(_), Int32) => true,
-        (Int64, Date64 | Date32 | Time64(_)) => true,
-        (Date64, Int64 | Int32) => true,
-        (Time64(_), Int64) => true,
-        (Date32, Date64) => true,
-        (Date64, Date32) => true,
-        (Time32(TimeUnit::Second), Time32(TimeUnit::Millisecond)) => true,
-        (Time32(TimeUnit::Millisecond), Time32(TimeUnit::Second)) => true,
-        (Time32(_), Time64(_)) => true,
-        (Time64(TimeUnit::Microsecond), Time64(TimeUnit::Nanosecond)) => true,
-        (Time64(TimeUnit::Nanosecond), Time64(TimeUnit::Microsecond)) => true,
-        (Time64(_), Time32(to_unit)) => {
-            matches!(to_unit, TimeUnit::Second | TimeUnit::Millisecond)
-        }
-        (Timestamp(_, _), Int64) => true,
-        (Int64, Timestamp(_, _)) => true,
-        (Timestamp(_, _), Timestamp(_, _) | Date32 | Date64) => true,
-        // date64 to timestamp might not make sense,
-        (Int64, Duration(_)) => true,
-        (Duration(_), Int64) => true,
-        (Interval(from_type), Int64) => {
-            match from_type {
-                IntervalUnit::YearMonth => true,
-                IntervalUnit::DayTime => true,
-                IntervalUnit::MonthDayNano => false, // Native type is i128
-            }
-        }
-        (Int32, Interval(to_type)) => {
-            match to_type {
-                IntervalUnit::YearMonth => true,
-                IntervalUnit::DayTime => false,
-                IntervalUnit::MonthDayNano => false,
-            }
-        }
-        (Int64, Interval(to_type)) => {
-            match to_type {
-                IntervalUnit::YearMonth => false,
-                IntervalUnit::DayTime => true,
-                IntervalUnit::MonthDayNano => false,
-            }
-        }
-        (_, _) => false,
-    }
-}
-
-/// Cast `array` to the provided data type and return a new Array with
-/// type `to_type`, if possible.
-///
-/// Behavior:
-/// * Boolean to Utf8: `true` => '1', `false` => `0`
-/// * Utf8 to boolean: `true`, `yes`, `on`, `1` => `true`, `false`, `no`, `off`, `0` => `false`,
-///   short variants are accepted, other strings return null or error
-/// * Utf8 to numeric: strings that can't be parsed to numbers return null, float strings
-///   in integer casts return null
-/// * Numeric to boolean: 0 returns `false`, any other value returns `true`
-/// * List to List: the underlying data type is cast
-/// * Primitive to List: a list array with 1 value per slot is created
-/// * Date32 and Date64: precision lost when going to higher interval
-/// * Time32 and Time64: precision lost when going to higher interval
-/// * Timestamp and Date{32|64}: precision lost when going to higher interval
-/// * Temporal to/from backing primitive: zero-copy with data type change
-///
-/// Unsupported Casts
-/// * To or from `StructArray`
-/// * List to primitive
-/// * Interval and duration
-pub fn cast(array: &ArrayRef, to_type: &DataType) -> Result<ArrayRef> {
-    cast_with_options(array, to_type, &DEFAULT_CAST_OPTIONS)
-}
-
-/// Cast the primitive array to defined decimal data type array
-fn cast_primitive_to_decimal<T: ArrayAccessor, F>(
-    array: T,
-    op: F,
-    precision: usize,
-    scale: usize,
-) -> Result<Arc<dyn Array>>
-where
-    F: Fn(T::Item) -> i128,
-{
-    #[allow(clippy::redundant_closure)]
-    let decimal_array = ArrayIter::new(array)
-        .map(|v| v.map(|v| op(v)))
-        .collect::<Decimal128Array>()
-        .with_precision_and_scale(precision, scale)?;
-
-    Ok(Arc::new(decimal_array))
-}
-
-fn cast_integer_to_decimal<T: ArrowNumericType>(
-    array: &PrimitiveArray<T>,
-    precision: usize,
-    scale: usize,
-) -> Result<Arc<dyn Array>>
-where
-    <T as ArrowPrimitiveType>::Native: AsPrimitive<i128>,
-{
-    let mul: i128 = 10_i128.pow(scale as u32);
-
-    // with_precision_and_scale validates the
-    // value is within range for the output precision
-    cast_primitive_to_decimal(array, |v| v.as_() * mul, precision, scale)
-}
-
-fn cast_floating_point_to_decimal<T: ArrowNumericType>(
-    array: &PrimitiveArray<T>,
-    precision: usize,
-    scale: usize,
-) -> Result<Arc<dyn Array>>
-where
-    <T as ArrowPrimitiveType>::Native: AsPrimitive<f64>,
-{
-    let mul = 10_f64.powi(scale as i32);
-
-    cast_primitive_to_decimal(
-        array,
-        |v| {
-            // with_precision_and_scale validates the
-            // value is within range for the output precision
-            (v.as_() * mul) as i128
-        },
-        precision,
-        scale,
-    )
-}
-
-// cast the decimal array to integer array
-macro_rules! cast_decimal_to_integer {
-    ($ARRAY:expr, $SCALE : ident, $VALUE_BUILDER: ident, $NATIVE_TYPE : ident, $DATA_TYPE : expr) => {{
-        let array = $ARRAY.as_any().downcast_ref::<Decimal128Array>().unwrap();
-        let mut value_builder = $VALUE_BUILDER::new(array.len());
-        let div: i128 = 10_i128.pow(*$SCALE as u32);
-        let min_bound = ($NATIVE_TYPE::MIN) as i128;
-        let max_bound = ($NATIVE_TYPE::MAX) as i128;
-        for i in 0..array.len() {
-            if array.is_null(i) {
-                value_builder.append_null();
-            } else {
-                let v = array.value(i).as_i128() / div;
-                // check the overflow
-                // For example: Decimal(128,10,0) as i8
-                // 128 is out of range i8
-                if v <= max_bound && v >= min_bound {
-                    value_builder.append_value(v as $NATIVE_TYPE);
-                } else {
-                    return Err(ArrowError::CastError(format!(
-                        "value of {} is out of range {}",
-                        v, $DATA_TYPE
-                    )));
-                }
-            }
-        }
-        Ok(Arc::new(value_builder.finish()))
-    }};
-}
-
-// cast the decimal array to floating-point array
-macro_rules! cast_decimal_to_float {
-    ($ARRAY:expr, $SCALE : ident, $VALUE_BUILDER: ident, $NATIVE_TYPE : ty) => {{
-        let array = $ARRAY.as_any().downcast_ref::<Decimal128Array>().unwrap();
-        let div = 10_f64.powi(*$SCALE as i32);
-        let mut value_builder = $VALUE_BUILDER::new(array.len());
-        for i in 0..array.len() {
-            if array.is_null(i) {
-                value_builder.append_null();
-            } else {
-                // The range of f32 or f64 is larger than i128, we don't need to check overflow.
-                // cast the i128 to f64 will lose precision, for example the `112345678901234568` will be as `112345678901234560`.
-                let v = (array.value(i).as_i128() as f64 / div) as $NATIVE_TYPE;
-                value_builder.append_value(v);
-            }
-        }
-        Ok(Arc::new(value_builder.finish()))
-    }};
-}
-
-/// Cast `array` to the provided data type and return a new Array with
-/// type `to_type`, if possible. It accepts `CastOptions` to allow consumers
-/// to configure cast behavior.
-///
-/// Behavior:
-/// * Boolean to Utf8: `true` => '1', `false` => `0`
-/// * Utf8 to boolean: `true`, `yes`, `on`, `1` => `true`, `false`, `no`, `off`, `0` => `false`,
-///   short variants are accepted, other strings return null or error
-/// * Utf8 to numeric: strings that can't be parsed to numbers return null, float strings
-///   in integer casts return null
-/// * Numeric to boolean: 0 returns `false`, any other value returns `true`
-/// * List to List: the underlying data type is cast
-/// * Primitive to List: a list array with 1 value per slot is created
-/// * Date32 and Date64: precision lost when going to higher interval
-/// * Time32 and Time64: precision lost when going to higher interval
-/// * Timestamp and Date{32|64}: precision lost when going to higher interval
-/// * Temporal to/from backing primitive: zero-copy with data type change
-///
-/// Unsupported Casts
-/// * To or from `StructArray`
-/// * List to primitive
-pub fn cast_with_options(
-    array: &ArrayRef,
-    to_type: &DataType,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    use DataType::*;
-    let from_type = array.data_type();
-
-    // clone array if types are the same
-    if from_type == to_type {
-        return Ok(array.clone());
-    }
-    match (from_type, to_type) {
-        (Decimal128(_, s1), Decimal128(p2, s2)) => {
-            cast_decimal_to_decimal::<16, 16>(array, s1, p2, s2)
-        }
-        (Decimal256(_, s1), Decimal256(p2, s2)) => {
-            cast_decimal_to_decimal::<32, 32>(array, s1, p2, s2)
-        }
-        (Decimal128(_, s1), Decimal256(p2, s2)) => {
-            cast_decimal_to_decimal::<16, 32>(array, s1, p2, s2)
-        }
-        (Decimal256(_, s1), Decimal128(p2, s2)) => {
-            cast_decimal_to_decimal::<32, 16>(array, s1, p2, s2)
-        }
-        (Decimal128(_, scale), _) => {
-            // cast decimal to other type
-            match to_type {
-                Int8 => {
-                    cast_decimal_to_integer!(array, scale, Int8Builder, i8, Int8)
-                }
-                Int16 => {
-                    cast_decimal_to_integer!(array, scale, Int16Builder, i16, Int16)
-                }
-                Int32 => {
-                    cast_decimal_to_integer!(array, scale, Int32Builder, i32, Int32)
-                }
-                Int64 => {
-                    cast_decimal_to_integer!(array, scale, Int64Builder, i64, Int64)
-                }
-                Float32 => {
-                    cast_decimal_to_float!(array, scale, Float32Builder, f32)
-                }
-                Float64 => {
-                    cast_decimal_to_float!(array, scale, Float64Builder, f64)
-                }
-                Null => Ok(new_null_array(to_type, array.len())),
-                _ => Err(ArrowError::CastError(format!(
-                    "Casting from {:?} to {:?} not supported",
-                    from_type, to_type
-                ))),
-            }
-        }
-        (_, Decimal128(precision, scale)) => {
-            // cast data to decimal
-            match from_type {
-                // TODO now just support signed numeric to decimal, support decimal to numeric later
-                Int8 => cast_integer_to_decimal(
-                    as_primitive_array::<Int8Type>(array),
-                    *precision,
-                    *scale,
-                ),
-                Int16 => cast_integer_to_decimal(
-                    as_primitive_array::<Int16Type>(array),
-                    *precision,
-                    *scale,
-                ),
-                Int32 => cast_integer_to_decimal(
-                    as_primitive_array::<Int32Type>(array),
-                    *precision,
-                    *scale,
-                ),
-                Int64 => cast_integer_to_decimal(
-                    as_primitive_array::<Int64Type>(array),
-                    *precision,
-                    *scale,
-                ),
-                Float32 => cast_floating_point_to_decimal(
-                    as_primitive_array::<Float32Type>(array),
-                    *precision,
-                    *scale,
-                ),
-                Float64 => cast_floating_point_to_decimal(
-                    as_primitive_array::<Float64Type>(array),
-                    *precision,
-                    *scale,
-                ),
-                Null => Ok(new_null_array(to_type, array.len())),
-                _ => Err(ArrowError::CastError(format!(
-                    "Casting from {:?} to {:?} not supported",
-                    from_type, to_type
-                ))),
-            }
-        }
-        (
-            Null,
-            Boolean
-            | Int8
-            | UInt8
-            | Int16
-            | UInt16
-            | Int32
-            | UInt32
-            | Float32
-            | Date32
-            | Time32(_)
-            | Int64
-            | UInt64
-            | Float64
-            | Date64
-            | Timestamp(_, _)
-            | Time64(_)
-            | Duration(_)
-            | Interval(_)
-            | FixedSizeBinary(_)
-            | Binary
-            | Utf8
-            | LargeBinary
-            | LargeUtf8
-            | List(_)
-            | LargeList(_)
-            | FixedSizeList(_, _)
-            | Struct(_)
-            | Map(_, _)
-            | Dictionary(_, _),
-        ) => Ok(new_null_array(to_type, array.len())),
-        (Struct(_), _) => Err(ArrowError::CastError(
-            "Cannot cast from struct to other types".to_string(),
-        )),
-        (_, Struct(_)) => Err(ArrowError::CastError(
-            "Cannot cast to struct from other types".to_string(),
-        )),
-        (List(_), List(ref to)) => {
-            cast_list_inner::<i32>(array, to, to_type, cast_options)
-        }
-        (LargeList(_), LargeList(ref to)) => {
-            cast_list_inner::<i64>(array, to, to_type, cast_options)
-        }
-        (List(list_from), LargeList(list_to)) => {
-            if list_to.data_type() != list_from.data_type() {
-                Err(ArrowError::CastError(
-                    "cannot cast list to large-list with different child data".into(),
-                ))
-            } else {
-                cast_list_container::<i32, i64>(&**array, cast_options)
-            }
-        }
-        (LargeList(list_from), List(list_to)) => {
-            if list_to.data_type() != list_from.data_type() {
-                Err(ArrowError::CastError(
-                    "cannot cast large-list to list with different child data".into(),
-                ))
-            } else {
-                cast_list_container::<i64, i32>(&**array, cast_options)
-            }
-        }
-        (List(_), _) => Err(ArrowError::CastError(
-            "Cannot cast list to non-list data types".to_string(),
-        )),
-        (_, List(ref to)) => {
-            cast_primitive_to_list::<i32>(array, to, to_type, cast_options)
-        }
-        (_, LargeList(ref to)) => {
-            cast_primitive_to_list::<i64>(array, to, to_type, cast_options)
-        }
-        (Dictionary(index_type, _), _) => match **index_type {
-            DataType::Int8 => dictionary_cast::<Int8Type>(array, to_type, cast_options),
-            DataType::Int16 => dictionary_cast::<Int16Type>(array, to_type, cast_options),
-            DataType::Int32 => dictionary_cast::<Int32Type>(array, to_type, cast_options),
-            DataType::Int64 => dictionary_cast::<Int64Type>(array, to_type, cast_options),
-            DataType::UInt8 => dictionary_cast::<UInt8Type>(array, to_type, cast_options),
-            DataType::UInt16 => {
-                dictionary_cast::<UInt16Type>(array, to_type, cast_options)
-            }
-            DataType::UInt32 => {
-                dictionary_cast::<UInt32Type>(array, to_type, cast_options)
-            }
-            DataType::UInt64 => {
-                dictionary_cast::<UInt64Type>(array, to_type, cast_options)
-            }
-            _ => Err(ArrowError::CastError(format!(
-                "Casting from dictionary type {:?} to {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-        (_, Dictionary(index_type, value_type)) => match **index_type {
-            DataType::Int8 => {
-                cast_to_dictionary::<Int8Type>(array, value_type, cast_options)
-            }
-            DataType::Int16 => {
-                cast_to_dictionary::<Int16Type>(array, value_type, cast_options)
-            }
-            DataType::Int32 => {
-                cast_to_dictionary::<Int32Type>(array, value_type, cast_options)
-            }
-            DataType::Int64 => {
-                cast_to_dictionary::<Int64Type>(array, value_type, cast_options)
-            }
-            DataType::UInt8 => {
-                cast_to_dictionary::<UInt8Type>(array, value_type, cast_options)
-            }
-            DataType::UInt16 => {
-                cast_to_dictionary::<UInt16Type>(array, value_type, cast_options)
-            }
-            DataType::UInt32 => {
-                cast_to_dictionary::<UInt32Type>(array, value_type, cast_options)
-            }
-            DataType::UInt64 => {
-                cast_to_dictionary::<UInt64Type>(array, value_type, cast_options)
-            }
-            _ => Err(ArrowError::CastError(format!(
-                "Casting from type {:?} to dictionary type {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-        (_, Boolean) => match from_type {
-            UInt8 => cast_numeric_to_bool::<UInt8Type>(array),
-            UInt16 => cast_numeric_to_bool::<UInt16Type>(array),
-            UInt32 => cast_numeric_to_bool::<UInt32Type>(array),
-            UInt64 => cast_numeric_to_bool::<UInt64Type>(array),
-            Int8 => cast_numeric_to_bool::<Int8Type>(array),
-            Int16 => cast_numeric_to_bool::<Int16Type>(array),
-            Int32 => cast_numeric_to_bool::<Int32Type>(array),
-            Int64 => cast_numeric_to_bool::<Int64Type>(array),
-            Float32 => cast_numeric_to_bool::<Float32Type>(array),
-            Float64 => cast_numeric_to_bool::<Float64Type>(array),
-            Utf8 => cast_utf8_to_boolean(array, cast_options),
-            _ => Err(ArrowError::CastError(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-        (Boolean, _) => match to_type {
-            UInt8 => cast_bool_to_numeric::<UInt8Type>(array, cast_options),
-            UInt16 => cast_bool_to_numeric::<UInt16Type>(array, cast_options),
-            UInt32 => cast_bool_to_numeric::<UInt32Type>(array, cast_options),
-            UInt64 => cast_bool_to_numeric::<UInt64Type>(array, cast_options),
-            Int8 => cast_bool_to_numeric::<Int8Type>(array, cast_options),
-            Int16 => cast_bool_to_numeric::<Int16Type>(array, cast_options),
-            Int32 => cast_bool_to_numeric::<Int32Type>(array, cast_options),
-            Int64 => cast_bool_to_numeric::<Int64Type>(array, cast_options),
-            Float32 => cast_bool_to_numeric::<Float32Type>(array, cast_options),
-            Float64 => cast_bool_to_numeric::<Float64Type>(array, cast_options),
-            Utf8 => {
-                let array = array.as_any().downcast_ref::<BooleanArray>().unwrap();
-                Ok(Arc::new(
-                    array
-                        .iter()
-                        .map(|value| value.map(|value| if value { "1" } else { "0" }))
-                        .collect::<StringArray>(),
-                ))
-            }
-            _ => Err(ArrowError::CastError(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-        (Utf8, _) => match to_type {
-            LargeUtf8 => cast_str_container::<i32, i64>(&**array),
-            UInt8 => cast_string_to_numeric::<UInt8Type, i32>(array, cast_options),
-            UInt16 => cast_string_to_numeric::<UInt16Type, i32>(array, cast_options),
-            UInt32 => cast_string_to_numeric::<UInt32Type, i32>(array, cast_options),
-            UInt64 => cast_string_to_numeric::<UInt64Type, i32>(array, cast_options),
-            Int8 => cast_string_to_numeric::<Int8Type, i32>(array, cast_options),
-            Int16 => cast_string_to_numeric::<Int16Type, i32>(array, cast_options),
-            Int32 => cast_string_to_numeric::<Int32Type, i32>(array, cast_options),
-            Int64 => cast_string_to_numeric::<Int64Type, i32>(array, cast_options),
-            Float32 => cast_string_to_numeric::<Float32Type, i32>(array, cast_options),
-            Float64 => cast_string_to_numeric::<Float64Type, i32>(array, cast_options),
-            Date32 => cast_string_to_date32::<i32>(&**array, cast_options),
-            Date64 => cast_string_to_date64::<i32>(&**array, cast_options),
-            Time32(TimeUnit::Second) => {
-                cast_string_to_time32second::<i32>(&**array, cast_options)
-            }
-            Time32(TimeUnit::Millisecond) => {
-                cast_string_to_time32millisecond::<i32>(&**array, cast_options)
-            }
-            Time64(TimeUnit::Microsecond) => {
-                cast_string_to_time64microsecond::<i32>(&**array, cast_options)
-            }
-            Time64(TimeUnit::Nanosecond) => {
-                cast_string_to_time64nanosecond::<i32>(&**array, cast_options)
-            }
-            Timestamp(TimeUnit::Nanosecond, None) => {
-                cast_string_to_timestamp_ns::<i32>(&**array, cast_options)
-            }
-            _ => Err(ArrowError::CastError(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-        (_, Utf8) => match from_type {
-            LargeUtf8 => cast_str_container::<i64, i32>(&**array),
-            UInt8 => cast_numeric_to_string::<UInt8Type, i32>(array),
-            UInt16 => cast_numeric_to_string::<UInt16Type, i32>(array),
-            UInt32 => cast_numeric_to_string::<UInt32Type, i32>(array),
-            UInt64 => cast_numeric_to_string::<UInt64Type, i32>(array),
-            Int8 => cast_numeric_to_string::<Int8Type, i32>(array),
-            Int16 => cast_numeric_to_string::<Int16Type, i32>(array),
-            Int32 => cast_numeric_to_string::<Int32Type, i32>(array),
-            Int64 => cast_numeric_to_string::<Int64Type, i32>(array),
-            Float32 => cast_numeric_to_string::<Float32Type, i32>(array),
-            Float64 => cast_numeric_to_string::<Float64Type, i32>(array),
-            Timestamp(unit, _) => match unit {
-                TimeUnit::Nanosecond => {
-                    cast_timestamp_to_string::<TimestampNanosecondType, i32>(array)
-                }
-                TimeUnit::Microsecond => {
-                    cast_timestamp_to_string::<TimestampMicrosecondType, i32>(array)
-                }
-                TimeUnit::Millisecond => {
-                    cast_timestamp_to_string::<TimestampMillisecondType, i32>(array)
-                }
-                TimeUnit::Second => {
-                    cast_timestamp_to_string::<TimestampSecondType, i32>(array)
-                }
-            },
-            Date32 => cast_date32_to_string::<i32>(array),
-            Date64 => cast_date64_to_string::<i32>(array),
-            Binary => {
-                let array = array.as_any().downcast_ref::<BinaryArray>().unwrap();
-                Ok(Arc::new(
-                    array
-                        .iter()
-                        .map(|maybe_value| match maybe_value {
-                            Some(value) => {
-                                let result = str::from_utf8(value);
-                                if cast_options.safe {
-                                    Ok(result.ok())
-                                } else {
-                                    Some(result.map_err(|_| {
-                                        ArrowError::CastError(
-                                            "Cannot cast binary to string".to_string(),
-                                        )
-                                    }))
-                                    .transpose()
-                                }
-                            }
-                            None => Ok(None),
-                        })
-                        .collect::<Result<StringArray>>()?,
-                ))
-            }
-            _ => Err(ArrowError::CastError(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-        (_, LargeUtf8) => match from_type {
-            UInt8 => cast_numeric_to_string::<UInt8Type, i64>(array),
-            UInt16 => cast_numeric_to_string::<UInt16Type, i64>(array),
-            UInt32 => cast_numeric_to_string::<UInt32Type, i64>(array),
-            UInt64 => cast_numeric_to_string::<UInt64Type, i64>(array),
-            Int8 => cast_numeric_to_string::<Int8Type, i64>(array),
-            Int16 => cast_numeric_to_string::<Int16Type, i64>(array),
-            Int32 => cast_numeric_to_string::<Int32Type, i64>(array),
-            Int64 => cast_numeric_to_string::<Int64Type, i64>(array),
-            Float32 => cast_numeric_to_string::<Float32Type, i64>(array),
-            Float64 => cast_numeric_to_string::<Float64Type, i64>(array),
-            Timestamp(unit, _) => match unit {
-                TimeUnit::Nanosecond => {
-                    cast_timestamp_to_string::<TimestampNanosecondType, i64>(array)
-                }
-                TimeUnit::Microsecond => {
-                    cast_timestamp_to_string::<TimestampMicrosecondType, i64>(array)
-                }
-                TimeUnit::Millisecond => {
-                    cast_timestamp_to_string::<TimestampMillisecondType, i64>(array)
-                }
-                TimeUnit::Second => {
-                    cast_timestamp_to_string::<TimestampSecondType, i64>(array)
-                }
-            },
-            Date32 => cast_date32_to_string::<i64>(array),
-            Date64 => cast_date64_to_string::<i64>(array),
-            Binary => {
-                let array = array.as_any().downcast_ref::<BinaryArray>().unwrap();
-                Ok(Arc::new(
-                    array
-                        .iter()
-                        .map(|maybe_value| match maybe_value {
-                            Some(value) => {
-                                let result = str::from_utf8(value);
-                                if cast_options.safe {
-                                    Ok(result.ok())
-                                } else {
-                                    Some(result.map_err(|_| {
-                                        ArrowError::CastError(
-                                            "Cannot cast binary to string".to_string(),
-                                        )
-                                    }))
-                                    .transpose()
-                                }
-                            }
-                            None => Ok(None),
-                        })
-                        .collect::<Result<LargeStringArray>>()?,
-                ))
-            }
-            _ => Err(ArrowError::CastError(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-        (LargeUtf8, _) => match to_type {
-            UInt8 => cast_string_to_numeric::<UInt8Type, i64>(array, cast_options),
-            UInt16 => cast_string_to_numeric::<UInt16Type, i64>(array, cast_options),
-            UInt32 => cast_string_to_numeric::<UInt32Type, i64>(array, cast_options),
-            UInt64 => cast_string_to_numeric::<UInt64Type, i64>(array, cast_options),
-            Int8 => cast_string_to_numeric::<Int8Type, i64>(array, cast_options),
-            Int16 => cast_string_to_numeric::<Int16Type, i64>(array, cast_options),
-            Int32 => cast_string_to_numeric::<Int32Type, i64>(array, cast_options),
-            Int64 => cast_string_to_numeric::<Int64Type, i64>(array, cast_options),
-            Float32 => cast_string_to_numeric::<Float32Type, i64>(array, cast_options),
-            Float64 => cast_string_to_numeric::<Float64Type, i64>(array, cast_options),
-            Date32 => cast_string_to_date32::<i64>(&**array, cast_options),
-            Date64 => cast_string_to_date64::<i64>(&**array, cast_options),
-            Time32(TimeUnit::Second) => {
-                cast_string_to_time32second::<i64>(&**array, cast_options)
-            }
-            Time32(TimeUnit::Millisecond) => {
-                cast_string_to_time32millisecond::<i64>(&**array, cast_options)
-            }
-            Time64(TimeUnit::Microsecond) => {
-                cast_string_to_time64microsecond::<i64>(&**array, cast_options)
-            }
-            Time64(TimeUnit::Nanosecond) => {
-                cast_string_to_time64nanosecond::<i64>(&**array, cast_options)
-            }
-            Timestamp(TimeUnit::Nanosecond, None) => {
-                cast_string_to_timestamp_ns::<i64>(&**array, cast_options)
-            }
-            _ => Err(ArrowError::CastError(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-
-        // start numeric casts
-        (UInt8, UInt16) => cast_numeric_arrays::<UInt8Type, UInt16Type>(array),
-        (UInt8, UInt32) => cast_numeric_arrays::<UInt8Type, UInt32Type>(array),
-        (UInt8, UInt64) => cast_numeric_arrays::<UInt8Type, UInt64Type>(array),
-        (UInt8, Int8) => cast_numeric_arrays::<UInt8Type, Int8Type>(array),
-        (UInt8, Int16) => cast_numeric_arrays::<UInt8Type, Int16Type>(array),
-        (UInt8, Int32) => cast_numeric_arrays::<UInt8Type, Int32Type>(array),
-        (UInt8, Int64) => cast_numeric_arrays::<UInt8Type, Int64Type>(array),
-        (UInt8, Float32) => cast_numeric_arrays::<UInt8Type, Float32Type>(array),
-        (UInt8, Float64) => cast_numeric_arrays::<UInt8Type, Float64Type>(array),
-
-        (UInt16, UInt8) => cast_numeric_arrays::<UInt16Type, UInt8Type>(array),
-        (UInt16, UInt32) => cast_numeric_arrays::<UInt16Type, UInt32Type>(array),
-        (UInt16, UInt64) => cast_numeric_arrays::<UInt16Type, UInt64Type>(array),
-        (UInt16, Int8) => cast_numeric_arrays::<UInt16Type, Int8Type>(array),
-        (UInt16, Int16) => cast_numeric_arrays::<UInt16Type, Int16Type>(array),
-        (UInt16, Int32) => cast_numeric_arrays::<UInt16Type, Int32Type>(array),
-        (UInt16, Int64) => cast_numeric_arrays::<UInt16Type, Int64Type>(array),
-        (UInt16, Float32) => cast_numeric_arrays::<UInt16Type, Float32Type>(array),
-        (UInt16, Float64) => cast_numeric_arrays::<UInt16Type, Float64Type>(array),
-
-        (UInt32, UInt8) => cast_numeric_arrays::<UInt32Type, UInt8Type>(array),
-        (UInt32, UInt16) => cast_numeric_arrays::<UInt32Type, UInt16Type>(array),
-        (UInt32, UInt64) => cast_numeric_arrays::<UInt32Type, UInt64Type>(array),
-        (UInt32, Int8) => cast_numeric_arrays::<UInt32Type, Int8Type>(array),
-        (UInt32, Int16) => cast_numeric_arrays::<UInt32Type, Int16Type>(array),
-        (UInt32, Int32) => cast_numeric_arrays::<UInt32Type, Int32Type>(array),
-        (UInt32, Int64) => cast_numeric_arrays::<UInt32Type, Int64Type>(array),
-        (UInt32, Float32) => cast_numeric_arrays::<UInt32Type, Float32Type>(array),
-        (UInt32, Float64) => cast_numeric_arrays::<UInt32Type, Float64Type>(array),
-
-        (UInt64, UInt8) => cast_numeric_arrays::<UInt64Type, UInt8Type>(array),
-        (UInt64, UInt16) => cast_numeric_arrays::<UInt64Type, UInt16Type>(array),
-        (UInt64, UInt32) => cast_numeric_arrays::<UInt64Type, UInt32Type>(array),
-        (UInt64, Int8) => cast_numeric_arrays::<UInt64Type, Int8Type>(array),
-        (UInt64, Int16) => cast_numeric_arrays::<UInt64Type, Int16Type>(array),
-        (UInt64, Int32) => cast_numeric_arrays::<UInt64Type, Int32Type>(array),
-        (UInt64, Int64) => cast_numeric_arrays::<UInt64Type, Int64Type>(array),
-        (UInt64, Float32) => cast_numeric_arrays::<UInt64Type, Float32Type>(array),
-        (UInt64, Float64) => cast_numeric_arrays::<UInt64Type, Float64Type>(array),
-
-        (Int8, UInt8) => cast_numeric_arrays::<Int8Type, UInt8Type>(array),
-        (Int8, UInt16) => cast_numeric_arrays::<Int8Type, UInt16Type>(array),
-        (Int8, UInt32) => cast_numeric_arrays::<Int8Type, UInt32Type>(array),
-        (Int8, UInt64) => cast_numeric_arrays::<Int8Type, UInt64Type>(array),
-        (Int8, Int16) => cast_numeric_arrays::<Int8Type, Int16Type>(array),
-        (Int8, Int32) => cast_numeric_arrays::<Int8Type, Int32Type>(array),
-        (Int8, Int64) => cast_numeric_arrays::<Int8Type, Int64Type>(array),
-        (Int8, Float32) => cast_numeric_arrays::<Int8Type, Float32Type>(array),
-        (Int8, Float64) => cast_numeric_arrays::<Int8Type, Float64Type>(array),
-
-        (Int16, UInt8) => cast_numeric_arrays::<Int16Type, UInt8Type>(array),
-        (Int16, UInt16) => cast_numeric_arrays::<Int16Type, UInt16Type>(array),
-        (Int16, UInt32) => cast_numeric_arrays::<Int16Type, UInt32Type>(array),
-        (Int16, UInt64) => cast_numeric_arrays::<Int16Type, UInt64Type>(array),
-        (Int16, Int8) => cast_numeric_arrays::<Int16Type, Int8Type>(array),
-        (Int16, Int32) => cast_numeric_arrays::<Int16Type, Int32Type>(array),
-        (Int16, Int64) => cast_numeric_arrays::<Int16Type, Int64Type>(array),
-        (Int16, Float32) => cast_numeric_arrays::<Int16Type, Float32Type>(array),
-        (Int16, Float64) => cast_numeric_arrays::<Int16Type, Float64Type>(array),
-
-        (Int32, UInt8) => cast_numeric_arrays::<Int32Type, UInt8Type>(array),
-        (Int32, UInt16) => cast_numeric_arrays::<Int32Type, UInt16Type>(array),
-        (Int32, UInt32) => cast_numeric_arrays::<Int32Type, UInt32Type>(array),
-        (Int32, UInt64) => cast_numeric_arrays::<Int32Type, UInt64Type>(array),
-        (Int32, Int8) => cast_numeric_arrays::<Int32Type, Int8Type>(array),
-        (Int32, Int16) => cast_numeric_arrays::<Int32Type, Int16Type>(array),
-        (Int32, Int64) => cast_numeric_arrays::<Int32Type, Int64Type>(array),
-        (Int32, Float32) => cast_numeric_arrays::<Int32Type, Float32Type>(array),
-        (Int32, Float64) => cast_numeric_arrays::<Int32Type, Float64Type>(array),
-
-        (Int64, UInt8) => cast_numeric_arrays::<Int64Type, UInt8Type>(array),
-        (Int64, UInt16) => cast_numeric_arrays::<Int64Type, UInt16Type>(array),
-        (Int64, UInt32) => cast_numeric_arrays::<Int64Type, UInt32Type>(array),
-        (Int64, UInt64) => cast_numeric_arrays::<Int64Type, UInt64Type>(array),
-        (Int64, Int8) => cast_numeric_arrays::<Int64Type, Int8Type>(array),
-        (Int64, Int16) => cast_numeric_arrays::<Int64Type, Int16Type>(array),
-        (Int64, Int32) => cast_numeric_arrays::<Int64Type, Int32Type>(array),
-        (Int64, Float32) => cast_numeric_arrays::<Int64Type, Float32Type>(array),
-        (Int64, Float64) => cast_numeric_arrays::<Int64Type, Float64Type>(array),
-
-        (Float32, UInt8) => cast_numeric_arrays::<Float32Type, UInt8Type>(array),
-        (Float32, UInt16) => cast_numeric_arrays::<Float32Type, UInt16Type>(array),
-        (Float32, UInt32) => cast_numeric_arrays::<Float32Type, UInt32Type>(array),
-        (Float32, UInt64) => cast_numeric_arrays::<Float32Type, UInt64Type>(array),
-        (Float32, Int8) => cast_numeric_arrays::<Float32Type, Int8Type>(array),
-        (Float32, Int16) => cast_numeric_arrays::<Float32Type, Int16Type>(array),
-        (Float32, Int32) => cast_numeric_arrays::<Float32Type, Int32Type>(array),
-        (Float32, Int64) => cast_numeric_arrays::<Float32Type, Int64Type>(array),
-        (Float32, Float64) => cast_numeric_arrays::<Float32Type, Float64Type>(array),
-
-        (Float64, UInt8) => cast_numeric_arrays::<Float64Type, UInt8Type>(array),
-        (Float64, UInt16) => cast_numeric_arrays::<Float64Type, UInt16Type>(array),
-        (Float64, UInt32) => cast_numeric_arrays::<Float64Type, UInt32Type>(array),
-        (Float64, UInt64) => cast_numeric_arrays::<Float64Type, UInt64Type>(array),
-        (Float64, Int8) => cast_numeric_arrays::<Float64Type, Int8Type>(array),
-        (Float64, Int16) => cast_numeric_arrays::<Float64Type, Int16Type>(array),
-        (Float64, Int32) => cast_numeric_arrays::<Float64Type, Int32Type>(array),
-        (Float64, Int64) => cast_numeric_arrays::<Float64Type, Int64Type>(array),
-        (Float64, Float32) => cast_numeric_arrays::<Float64Type, Float32Type>(array),
-        // end numeric casts
-
-        // temporal casts
-        (Int32, Date32) => cast_array_data::<Date32Type>(array, to_type.clone()),
-        (Int32, Date64) => cast_with_options(
-            &cast_with_options(array, &DataType::Date32, cast_options)?,
-            &DataType::Date64,
-            cast_options,
-        ),
-        (Int32, Time32(TimeUnit::Second)) => {
-            cast_array_data::<Time32SecondType>(array, to_type.clone())
-        }
-        (Int32, Time32(TimeUnit::Millisecond)) => {
-            cast_array_data::<Time32MillisecondType>(array, to_type.clone())
-        }
-        // No support for microsecond/nanosecond with i32
-        (Date32, Int32) => cast_array_data::<Int32Type>(array, to_type.clone()),
-        (Date32, Int64) => cast_with_options(
-            &cast_with_options(array, &DataType::Int32, cast_options)?,
-            &DataType::Int64,
-            cast_options,
-        ),
-        (Time32(_), Int32) => cast_array_data::<Int32Type>(array, to_type.clone()),
-        (Int64, Date64) => cast_array_data::<Date64Type>(array, to_type.clone()),
-        (Int64, Date32) => cast_with_options(
-            &cast_with_options(array, &DataType::Int32, cast_options)?,
-            &DataType::Date32,
-            cast_options,
-        ),
-        // No support for second/milliseconds with i64
-        (Int64, Time64(TimeUnit::Microsecond)) => {
-            cast_array_data::<Time64MicrosecondType>(array, to_type.clone())
-        }
-        (Int64, Time64(TimeUnit::Nanosecond)) => {
-            cast_array_data::<Time64NanosecondType>(array, to_type.clone())
-        }
-
-        (Date64, Int64) => cast_array_data::<Int64Type>(array, to_type.clone()),
-        (Date64, Int32) => cast_with_options(
-            &cast_with_options(array, &DataType::Int64, cast_options)?,
-            &DataType::Int32,
-            cast_options,
-        ),
-        (Time64(_), Int64) => cast_array_data::<Int64Type>(array, to_type.clone()),
-        (Date32, Date64) => {
-            let date_array = array.as_any().downcast_ref::<Date32Array>().unwrap();
-
-            let values =
-                unary::<_, _, Date64Type>(date_array, |x| x as i64 * MILLISECONDS_IN_DAY);
-
-            Ok(Arc::new(values) as ArrayRef)
-        }
-        (Date64, Date32) => {
-            let date_array = array.as_any().downcast_ref::<Date64Array>().unwrap();
-
-            let values = unary::<_, _, Date32Type>(date_array, |x| {
-                (x / MILLISECONDS_IN_DAY) as i32
-            });
-
-            Ok(Arc::new(values) as ArrayRef)
-        }
-        (Time32(TimeUnit::Second), Time32(TimeUnit::Millisecond)) => {
-            let time_array = array.as_any().downcast_ref::<Time32SecondArray>().unwrap();
-
-            let values = unary::<_, _, Time32MillisecondType>(time_array, |x| {
-                x * MILLISECONDS as i32
-            });
-
-            Ok(Arc::new(values) as ArrayRef)
-        }
-        (Time32(TimeUnit::Millisecond), Time32(TimeUnit::Second)) => {
-            let time_array = array
-                .as_any()
-                .downcast_ref::<Time32MillisecondArray>()
-                .unwrap();
-
-            let values = unary::<_, _, Time32SecondType>(time_array, |x| {
-                x / (MILLISECONDS as i32)
-            });
-
-            Ok(Arc::new(values) as ArrayRef)
-        }
-        //(Time32(TimeUnit::Second), Time64(_)) => {},
-        (Time32(from_unit), Time64(to_unit)) => {
-            let time_array = Int32Array::from(array.data().clone());
-            // note: (numeric_cast + SIMD multiply) is faster than (cast & multiply)
-            let c: Int64Array = numeric_cast(&time_array);
-            let from_size = time_unit_multiple(from_unit);
-            let to_size = time_unit_multiple(to_unit);
-            // from is only smaller than to if 64milli/64second don't exist
-            let mult = Int64Array::from(vec![to_size / from_size; array.len()]);
-            let converted = multiply(&c, &mult)?;
-            let array_ref = Arc::new(converted) as ArrayRef;
-            use TimeUnit::*;
-            match to_unit {
-                Microsecond => cast_array_data::<TimestampMicrosecondType>(
-                    &array_ref,
-                    to_type.clone(),
-                ),
-                Nanosecond => cast_array_data::<TimestampNanosecondType>(
-                    &array_ref,
-                    to_type.clone(),
-                ),
-                _ => unreachable!("array type not supported"),
-            }
-        }
-        (Time64(TimeUnit::Microsecond), Time64(TimeUnit::Nanosecond)) => {
-            let time_array = array
-                .as_any()
-                .downcast_ref::<Time64MicrosecondArray>()
-                .unwrap();
-
-            let values =
-                unary::<_, _, Time64NanosecondType>(time_array, |x| x * MILLISECONDS);
-            Ok(Arc::new(values) as ArrayRef)
-        }
-        (Time64(TimeUnit::Nanosecond), Time64(TimeUnit::Microsecond)) => {
-            let time_array = array
-                .as_any()
-                .downcast_ref::<Time64NanosecondArray>()
-                .unwrap();
-
-            let values =
-                unary::<_, _, Time64MicrosecondType>(time_array, |x| x / MILLISECONDS);
-            Ok(Arc::new(values) as ArrayRef)
-        }
-        (Time64(from_unit), Time32(to_unit)) => {
-            let time_array = Int64Array::from(array.data().clone());
-            let from_size = time_unit_multiple(from_unit);
-            let to_size = time_unit_multiple(to_unit);
-            let divisor = from_size / to_size;
-            match to_unit {
-                TimeUnit::Second => {
-                    let values = unary::<_, _, Time32SecondType>(&time_array, |x| {
-                        (x as i64 / divisor) as i32
-                    });
-                    Ok(Arc::new(values) as ArrayRef)
-                }
-                TimeUnit::Millisecond => {
-                    let values = unary::<_, _, Time32MillisecondType>(&time_array, |x| {
-                        (x as i64 / divisor) as i32
-                    });
-                    Ok(Arc::new(values) as ArrayRef)
-                }
-                _ => unreachable!("array type not supported"),
-            }
-        }
-        (Timestamp(_, _), Int64) => cast_array_data::<Int64Type>(array, to_type.clone()),
-        (Int64, Timestamp(to_unit, _)) => {
-            use TimeUnit::*;
-            match to_unit {
-                Second => cast_array_data::<TimestampSecondType>(array, to_type.clone()),
-                Millisecond => {
-                    cast_array_data::<TimestampMillisecondType>(array, to_type.clone())
-                }
-                Microsecond => {
-                    cast_array_data::<TimestampMicrosecondType>(array, to_type.clone())
-                }
-                Nanosecond => {
-                    cast_array_data::<TimestampNanosecondType>(array, to_type.clone())
-                }
-            }
-        }
-        (Timestamp(from_unit, _), Timestamp(to_unit, _)) => {
-            let time_array = Int64Array::from(array.data().clone());
-            let from_size = time_unit_multiple(from_unit);
-            let to_size = time_unit_multiple(to_unit);
-            // we either divide or multiply, depending on size of each unit
-            // units are never the same when the types are the same
-            let converted = if from_size >= to_size {
-                divide_scalar(&time_array, from_size / to_size)?
-            } else {
-                multiply(
-                    &time_array,
-                    &Int64Array::from(vec![to_size / from_size; array.len()]),
-                )?
-            };
-            let array_ref = Arc::new(converted) as ArrayRef;
-            use TimeUnit::*;
-            match to_unit {
-                Second => {
-                    cast_array_data::<TimestampSecondType>(&array_ref, to_type.clone())
-                }
-                Millisecond => cast_array_data::<TimestampMillisecondType>(
-                    &array_ref,
-                    to_type.clone(),
-                ),
-                Microsecond => cast_array_data::<TimestampMicrosecondType>(
-                    &array_ref,
-                    to_type.clone(),
-                ),
-                Nanosecond => cast_array_data::<TimestampNanosecondType>(
-                    &array_ref,
-                    to_type.clone(),
-                ),
-            }
-        }
-        (Timestamp(from_unit, _), Date32) => {
-            let time_array = Int64Array::from(array.data().clone());
-            let from_size = time_unit_multiple(from_unit) * SECONDS_IN_DAY;
-
-            // Int32Array::from_iter(tim.iter)
-            let mut b = Date32Builder::new(array.len());
-
-            for i in 0..array.len() {
-                if time_array.is_null(i) {
-                    b.append_null();
-                } else {
-                    b.append_value((time_array.value(i) / from_size) as i32);
-                }
-            }
-
-            Ok(Arc::new(b.finish()) as ArrayRef)
-        }
-        (Timestamp(from_unit, _), Date64) => {
-            let from_size = time_unit_multiple(from_unit);
-            let to_size = MILLISECONDS;
-
-            // Scale time_array by (to_size / from_size) using a
-            // single integer operation, but need to avoid integer
-            // math rounding down to zero
-
-            match to_size.cmp(&from_size) {
-                std::cmp::Ordering::Less => {
-                    let time_array = Date64Array::from(array.data().clone());
-                    Ok(Arc::new(divide(
-                        &time_array,
-                        &Date64Array::from(vec![from_size / to_size; array.len()]),
-                    )?) as ArrayRef)
-                }
-                std::cmp::Ordering::Equal => {
-                    cast_array_data::<Date64Type>(array, to_type.clone())
-                }
-                std::cmp::Ordering::Greater => {
-                    let time_array = Date64Array::from(array.data().clone());
-                    Ok(Arc::new(multiply(
-                        &time_array,
-                        &Date64Array::from(vec![to_size / from_size; array.len()]),
-                    )?) as ArrayRef)
-                }
-            }
-        }
-        // date64 to timestamp might not make sense,
-        (Int64, Duration(to_unit)) => {
-            use TimeUnit::*;
-            match to_unit {
-                Second => cast_array_data::<DurationSecondType>(array, to_type.clone()),
-                Millisecond => {
-                    cast_array_data::<DurationMillisecondType>(array, to_type.clone())
-                }
-                Microsecond => {
-                    cast_array_data::<DurationMicrosecondType>(array, to_type.clone())
-                }
-                Nanosecond => {
-                    cast_array_data::<DurationNanosecondType>(array, to_type.clone())
-                }
-            }
-        }
-        (Duration(_), Int64) => cast_array_data::<Int64Type>(array, to_type.clone()),
-        (Interval(from_type), Int64) => match from_type {
-            IntervalUnit::YearMonth => {
-                cast_numeric_arrays::<IntervalYearMonthType, Int64Type>(array)
-            }
-            IntervalUnit::DayTime => cast_array_data::<Int64Type>(array, to_type.clone()),
-            IntervalUnit::MonthDayNano => Err(ArrowError::CastError(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-        (Int32, Interval(to_type)) => match to_type {
-            IntervalUnit::YearMonth => {
-                cast_array_data::<IntervalYearMonthType>(array, Interval(to_type.clone()))
-            }
-            _ => Err(ArrowError::CastError(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-        (Int64, Interval(to_type)) => match to_type {
-            IntervalUnit::DayTime => {
-                cast_array_data::<IntervalDayTimeType>(array, Interval(to_type.clone()))
-            }
-            _ => Err(ArrowError::CastError(format!(
-                "Casting from {:?} to {:?} not supported",
-                from_type, to_type,
-            ))),
-        },
-        (_, _) => Err(ArrowError::CastError(format!(
-            "Casting from {:?} to {:?} not supported",
-            from_type, to_type,
-        ))),
-    }
-}
-
-/// Get the time unit as a multiple of a second
-const fn time_unit_multiple(unit: &TimeUnit) -> i64 {
-    match unit {
-        TimeUnit::Second => 1,
-        TimeUnit::Millisecond => MILLISECONDS,
-        TimeUnit::Microsecond => MICROSECONDS,
-        TimeUnit::Nanosecond => NANOSECONDS,
-    }
-}
-
-/// Cast one type of decimal array to another type of decimal array
-fn cast_decimal_to_decimal<const BYTE_WIDTH1: usize, const BYTE_WIDTH2: usize>(
-    array: &ArrayRef,
-    input_scale: &usize,
-    output_precision: &usize,
-    output_scale: &usize,
-) -> Result<ArrayRef> {
-    if input_scale > output_scale {
-        // For example, input_scale is 4 and output_scale is 3;
-        // Original value is 11234_i128, and will be cast to 1123_i128.
-        let div = 10_i128.pow((input_scale - output_scale) as u32);
-        if BYTE_WIDTH1 == 16 {
-            let array = array.as_any().downcast_ref::<Decimal128Array>().unwrap();
-            let iter = array.iter().map(|v| v.map(|v| v.as_i128() / div));
-            if BYTE_WIDTH2 == 16 {
-                let output_array = iter
-                    .collect::<Decimal128Array>()
-                    .with_precision_and_scale(*output_precision, *output_scale)?;
-
-                Ok(Arc::new(output_array))
-            } else {
-                let output_array = iter
-                    .map(|v| v.map(BigInt::from))
-                    .collect::<Decimal256Array>()
-                    .with_precision_and_scale(*output_precision, *output_scale)?;
-
-                Ok(Arc::new(output_array))
-            }
-        } else {
-            let array = array.as_any().downcast_ref::<Decimal256Array>().unwrap();
-            let iter = array.iter().map(|v| v.map(|v| v.to_big_int().div(div)));
-            if BYTE_WIDTH2 == 16 {
-                let values = iter
-                    .map(|v| {
-                        if v.is_none() {
-                            Ok(None)
-                        } else {
-                            v.as_ref().and_then(|v| v.to_i128())
-                                .ok_or_else(|| {
-                                    ArrowError::InvalidArgumentError(
-                                    format!("{:?} cannot be casted to 128-bit integer for Decimal128", v),
-                                )
-                                })
-                                .map(Some)
-                        }
-                    })
-                    .collect::<Result<Vec<_>>>()?;
-
-                let output_array = values
-                    .into_iter()
-                    .collect::<Decimal128Array>()
-                    .with_precision_and_scale(*output_precision, *output_scale)?;
-
-                Ok(Arc::new(output_array))
-            } else {
-                let output_array = iter
-                    .collect::<Decimal256Array>()
-                    .with_precision_and_scale(*output_precision, *output_scale)?;
-
-                Ok(Arc::new(output_array))
-            }
-        }
-    } else {
-        // For example, input_scale is 3 and output_scale is 4;
-        // Original value is 1123_i128, and will be cast to 11230_i128.
-        let mul = 10_i128.pow((output_scale - input_scale) as u32);
-        if BYTE_WIDTH1 == 16 {
-            let array = array.as_any().downcast_ref::<Decimal128Array>().unwrap();
-            let iter = array.iter().map(|v| v.map(|v| v.as_i128() * mul));
-            if BYTE_WIDTH2 == 16 {
-                let output_array = iter
-                    .collect::<Decimal128Array>()
-                    .with_precision_and_scale(*output_precision, *output_scale)?;
-
-                Ok(Arc::new(output_array))
-            } else {
-                let output_array = iter
-                    .map(|v| v.map(BigInt::from))
-                    .collect::<Decimal256Array>()
-                    .with_precision_and_scale(*output_precision, *output_scale)?;
-
-                Ok(Arc::new(output_array))
-            }
-        } else {
-            let array = array.as_any().downcast_ref::<Decimal256Array>().unwrap();
-            let iter = array.iter().map(|v| v.map(|v| v.to_big_int().mul(mul)));
-            if BYTE_WIDTH2 == 16 {
-                let values = iter
-                    .map(|v| {
-                        if v.is_none() {
-                            Ok(None)
-                        } else {
-                            v.as_ref().and_then(|v| v.to_i128())
-                                .ok_or_else(|| {
-                                    ArrowError::InvalidArgumentError(
-                                    format!("{:?} cannot be casted to 128-bit integer for Decimal128", v),
-                                )
-                                })
-                                .map(Some)
-                        }
-                    })
-                    .collect::<Result<Vec<_>>>()?;
-
-                let output_array = values
-                    .into_iter()
-                    .collect::<Decimal128Array>()
-                    .with_precision_and_scale(*output_precision, *output_scale)?;
-
-                Ok(Arc::new(output_array))
-            } else {
-                let output_array = iter
-                    .collect::<Decimal256Array>()
-                    .with_precision_and_scale(*output_precision, *output_scale)?;
-
-                Ok(Arc::new(output_array))
-            }
-        }
-    }
-}
-
-/// Cast an array by changing its array_data type to the desired type
-///
-/// Arrays should have the same primitive data type, otherwise this should fail.
-/// We do not perform this check on primitive data types as we only use this
-/// function internally, where it is guaranteed to be infallible.
-fn cast_array_data<TO>(array: &ArrayRef, to_type: DataType) -> Result<ArrayRef>
-where
-    TO: ArrowNumericType,
-{
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            to_type,
-            array.len(),
-            Some(array.null_count()),
-            array
-                .data()
-                .null_bitmap()
-                .cloned()
-                .map(|bitmap| bitmap.bits),
-            array.data().offset(),
-            array.data().buffers().to_vec(),
-            vec![],
-        )
-    };
-    Ok(Arc::new(PrimitiveArray::<TO>::from(data)) as ArrayRef)
-}
-
-/// Convert Array into a PrimitiveArray of type, and apply numeric cast
-fn cast_numeric_arrays<FROM, TO>(from: &ArrayRef) -> Result<ArrayRef>
-where
-    FROM: ArrowNumericType,
-    TO: ArrowNumericType,
-    FROM::Native: num::NumCast,
-    TO::Native: num::NumCast,
-{
-    Ok(Arc::new(numeric_cast::<FROM, TO>(
-        from.as_any()
-            .downcast_ref::<PrimitiveArray<FROM>>()
-            .unwrap(),
-    )))
-}
-
-/// Natural cast between numeric types
-fn numeric_cast<T, R>(from: &PrimitiveArray<T>) -> PrimitiveArray<R>
-where
-    T: ArrowNumericType,
-    R: ArrowNumericType,
-    T::Native: num::NumCast,
-    R::Native: num::NumCast,
-{
-    let iter = from
-        .iter()
-        .map(|v| v.and_then(num::cast::cast::<T::Native, R::Native>));
-    // Soundness:
-    //  The iterator is trustedLen because it comes from an `PrimitiveArray`.
-    unsafe { PrimitiveArray::<R>::from_trusted_len_iter(iter) }
-}
-
-/// Cast timestamp types to Utf8/LargeUtf8
-fn cast_timestamp_to_string<T, OffsetSize>(array: &ArrayRef) -> Result<ArrayRef>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: From<<T as ArrowPrimitiveType>::Native>,
-    OffsetSize: OffsetSizeTrait,
-{
-    let array = array.as_any().downcast_ref::<PrimitiveArray<T>>().unwrap();
-
-    Ok(Arc::new(
-        (0..array.len())
-            .map(|ix| {
-                if array.is_null(ix) {
-                    None
-                } else {
-                    array.value_as_datetime(ix).map(|v| v.to_string())
-                }
-            })
-            .collect::<GenericStringArray<OffsetSize>>(),
-    ))
-}
-
-/// Cast date32 types to Utf8/LargeUtf8
-fn cast_date32_to_string<OffsetSize: OffsetSizeTrait>(
-    array: &ArrayRef,
-) -> Result<ArrayRef> {
-    let array = array.as_any().downcast_ref::<Date32Array>().unwrap();
-
-    Ok(Arc::new(
-        (0..array.len())
-            .map(|ix| {
-                if array.is_null(ix) {
-                    None
-                } else {
-                    array.value_as_date(ix).map(|v| v.to_string())
-                }
-            })
-            .collect::<GenericStringArray<OffsetSize>>(),
-    ))
-}
-
-/// Cast date64 types to Utf8/LargeUtf8
-fn cast_date64_to_string<OffsetSize: OffsetSizeTrait>(
-    array: &ArrayRef,
-) -> Result<ArrayRef> {
-    let array = array.as_any().downcast_ref::<Date64Array>().unwrap();
-
-    Ok(Arc::new(
-        (0..array.len())
-            .map(|ix| {
-                if array.is_null(ix) {
-                    None
-                } else {
-                    array.value_as_datetime(ix).map(|v| v.to_string())
-                }
-            })
-            .collect::<GenericStringArray<OffsetSize>>(),
-    ))
-}
-
-/// Cast numeric types to Utf8
-fn cast_numeric_to_string<FROM, OffsetSize>(array: &ArrayRef) -> Result<ArrayRef>
-where
-    FROM: ArrowNumericType,
-    FROM::Native: lexical_core::ToLexical,
-    OffsetSize: OffsetSizeTrait,
-{
-    Ok(Arc::new(numeric_to_string_cast::<FROM, OffsetSize>(
-        array
-            .as_any()
-            .downcast_ref::<PrimitiveArray<FROM>>()
-            .unwrap(),
-    )))
-}
-
-fn numeric_to_string_cast<T, OffsetSize>(
-    from: &PrimitiveArray<T>,
-) -> GenericStringArray<OffsetSize>
-where
-    T: ArrowPrimitiveType + ArrowNumericType,
-    T::Native: lexical_core::ToLexical,
-    OffsetSize: OffsetSizeTrait,
-{
-    from.iter()
-        .map(|maybe_value| maybe_value.map(lexical_to_string))
-        .collect()
-}
-
-/// Cast numeric types to Utf8
-fn cast_string_to_numeric<T, Offset: OffsetSizeTrait>(
-    from: &ArrayRef,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef>
-where
-    T: ArrowNumericType,
-    <T as ArrowPrimitiveType>::Native: lexical_core::FromLexical,
-{
-    Ok(Arc::new(string_to_numeric_cast::<T, Offset>(
-        from.as_any()
-            .downcast_ref::<GenericStringArray<Offset>>()
-            .unwrap(),
-        cast_options,
-    )?))
-}
-
-fn string_to_numeric_cast<T, Offset: OffsetSizeTrait>(
-    from: &GenericStringArray<Offset>,
-    cast_options: &CastOptions,
-) -> Result<PrimitiveArray<T>>
-where
-    T: ArrowNumericType,
-    <T as ArrowPrimitiveType>::Native: lexical_core::FromLexical,
-{
-    if cast_options.safe {
-        let iter = from
-            .iter()
-            .map(|v| v.and_then(|v| lexical_core::parse(v.as_bytes()).ok()));
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        Ok(unsafe { PrimitiveArray::<T>::from_trusted_len_iter(iter) })
-    } else {
-        let vec = from
-            .iter()
-            .map(|v| {
-                v.map(|v| {
-                    lexical_core::parse(v.as_bytes()).map_err(|_| {
-                        ArrowError::CastError(format!(
-                            "Cannot cast string '{}' to value of {:?} type",
-                            v,
-                            T::DATA_TYPE,
-                        ))
-                    })
-                })
-                .transpose()
-            })
-            .collect::<Result<Vec<_>>>()?;
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        Ok(unsafe { PrimitiveArray::<T>::from_trusted_len_iter(vec.iter()) })
-    }
-}
-
-/// Casts generic string arrays to Date32Array
-fn cast_string_to_date32<Offset: OffsetSizeTrait>(
-    array: &dyn Array,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    use chrono::Datelike;
-    let string_array = array
-        .as_any()
-        .downcast_ref::<GenericStringArray<Offset>>()
-        .unwrap();
-
-    let array = if cast_options.safe {
-        let iter = string_array.iter().map(|v| {
-            v.and_then(|v| {
-                v.parse::<chrono::NaiveDate>()
-                    .map(|date| date.num_days_from_ce() - EPOCH_DAYS_FROM_CE)
-                    .ok()
-            })
-        });
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Date32Array::from_trusted_len_iter(iter) }
-    } else {
-        let vec = string_array
-            .iter()
-            .map(|v| {
-                v.map(|v| {
-                    v.parse::<chrono::NaiveDate>()
-                        .map(|date| date.num_days_from_ce() - EPOCH_DAYS_FROM_CE)
-                        .map_err(|_| {
-                            ArrowError::CastError(format!(
-                                "Cannot cast string '{}' to value of {:?} type",
-                                v,
-                                DataType::Date32
-                            ))
-                        })
-                })
-                .transpose()
-            })
-            .collect::<Result<Vec<Option<i32>>>>()?;
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Date32Array::from_trusted_len_iter(vec.iter()) }
-    };
-
-    Ok(Arc::new(array) as ArrayRef)
-}
-
-/// Casts generic string arrays to Date64Array
-fn cast_string_to_date64<Offset: OffsetSizeTrait>(
-    array: &dyn Array,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    let string_array = array
-        .as_any()
-        .downcast_ref::<GenericStringArray<Offset>>()
-        .unwrap();
-
-    let array = if cast_options.safe {
-        let iter = string_array.iter().map(|v| {
-            v.and_then(|v| {
-                v.parse::<chrono::NaiveDateTime>()
-                    .map(|datetime| datetime.timestamp_millis())
-                    .ok()
-            })
-        });
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Date64Array::from_trusted_len_iter(iter) }
-    } else {
-        let vec = string_array
-            .iter()
-            .map(|v| {
-                v.map(|v| {
-                    v.parse::<chrono::NaiveDateTime>()
-                        .map(|datetime| datetime.timestamp_millis())
-                        .map_err(|_| {
-                            ArrowError::CastError(format!(
-                                "Cannot cast string '{}' to value of {:?} type",
-                                v,
-                                DataType::Date64
-                            ))
-                        })
-                })
-                .transpose()
-            })
-            .collect::<Result<Vec<Option<i64>>>>()?;
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Date64Array::from_trusted_len_iter(vec.iter()) }
-    };
-
-    Ok(Arc::new(array) as ArrayRef)
-}
-
-/// Casts generic string arrays to `Time32SecondArray`
-fn cast_string_to_time32second<Offset: OffsetSizeTrait>(
-    array: &dyn Array,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    /// The number of nanoseconds per millisecond.
-    const NANOS_PER_SEC: u32 = 1_000_000_000;
-
-    let string_array = array
-        .as_any()
-        .downcast_ref::<GenericStringArray<Offset>>()
-        .unwrap();
-
-    let array = if cast_options.safe {
-        let iter = string_array.iter().map(|v| {
-            v.and_then(|v| {
-                v.parse::<chrono::NaiveTime>()
-                    .map(|time| {
-                        (time.num_seconds_from_midnight()
-                            + time.nanosecond() / NANOS_PER_SEC)
-                            as i32
-                    })
-                    .ok()
-            })
-        });
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Time32SecondArray::from_trusted_len_iter(iter) }
-    } else {
-        let vec = string_array
-            .iter()
-            .map(|v| {
-                v.map(|v| {
-                    v.parse::<chrono::NaiveTime>()
-                        .map(|time| {
-                            (time.num_seconds_from_midnight()
-                                + time.nanosecond() / NANOS_PER_SEC)
-                                as i32
-                        })
-                        .map_err(|_| {
-                            ArrowError::CastError(format!(
-                                "Cannot cast string '{}' to value of {:?} type",
-                                v,
-                                DataType::Time32(TimeUnit::Second)
-                            ))
-                        })
-                })
-                .transpose()
-            })
-            .collect::<Result<Vec<Option<i32>>>>()?;
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Time32SecondArray::from_trusted_len_iter(vec.iter()) }
-    };
-
-    Ok(Arc::new(array) as ArrayRef)
-}
-
-/// Casts generic string arrays to `Time32MillisecondArray`
-fn cast_string_to_time32millisecond<Offset: OffsetSizeTrait>(
-    array: &dyn Array,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    /// The number of nanoseconds per millisecond.
-    const NANOS_PER_MILLI: u32 = 1_000_000;
-    /// The number of milliseconds per second.
-    const MILLIS_PER_SEC: u32 = 1_000;
-
-    let string_array = array
-        .as_any()
-        .downcast_ref::<GenericStringArray<Offset>>()
-        .unwrap();
-
-    let array = if cast_options.safe {
-        let iter = string_array.iter().map(|v| {
-            v.and_then(|v| {
-                v.parse::<chrono::NaiveTime>()
-                    .map(|time| {
-                        (time.num_seconds_from_midnight() * MILLIS_PER_SEC
-                            + time.nanosecond() / NANOS_PER_MILLI)
-                            as i32
-                    })
-                    .ok()
-            })
-        });
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Time32MillisecondArray::from_trusted_len_iter(iter) }
-    } else {
-        let vec = string_array
-            .iter()
-            .map(|v| {
-                v.map(|v| {
-                    v.parse::<chrono::NaiveTime>()
-                        .map(|time| {
-                            (time.num_seconds_from_midnight() * MILLIS_PER_SEC
-                                + time.nanosecond() / NANOS_PER_MILLI)
-                                as i32
-                        })
-                        .map_err(|_| {
-                            ArrowError::CastError(format!(
-                                "Cannot cast string '{}' to value of {:?} type",
-                                v,
-                                DataType::Time32(TimeUnit::Millisecond)
-                            ))
-                        })
-                })
-                .transpose()
-            })
-            .collect::<Result<Vec<Option<i32>>>>()?;
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Time32MillisecondArray::from_trusted_len_iter(vec.iter()) }
-    };
-
-    Ok(Arc::new(array) as ArrayRef)
-}
-
-/// Casts generic string arrays to `Time64MicrosecondArray`
-fn cast_string_to_time64microsecond<Offset: OffsetSizeTrait>(
-    array: &dyn Array,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    /// The number of nanoseconds per microsecond.
-    const NANOS_PER_MICRO: i64 = 1_000;
-    /// The number of microseconds per second.
-    const MICROS_PER_SEC: i64 = 1_000_000;
-
-    let string_array = array
-        .as_any()
-        .downcast_ref::<GenericStringArray<Offset>>()
-        .unwrap();
-
-    let array = if cast_options.safe {
-        let iter = string_array.iter().map(|v| {
-            v.and_then(|v| {
-                v.parse::<chrono::NaiveTime>()
-                    .map(|time| {
-                        time.num_seconds_from_midnight() as i64 * MICROS_PER_SEC
-                            + time.nanosecond() as i64 / NANOS_PER_MICRO
-                    })
-                    .ok()
-            })
-        });
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Time64MicrosecondArray::from_trusted_len_iter(iter) }
-    } else {
-        let vec = string_array
-            .iter()
-            .map(|v| {
-                v.map(|v| {
-                    v.parse::<chrono::NaiveTime>()
-                        .map(|time| {
-                            time.num_seconds_from_midnight() as i64 * MICROS_PER_SEC
-                                + time.nanosecond() as i64 / NANOS_PER_MICRO
-                        })
-                        .map_err(|_| {
-                            ArrowError::CastError(format!(
-                                "Cannot cast string '{}' to value of {:?} type",
-                                v,
-                                DataType::Time64(TimeUnit::Microsecond)
-                            ))
-                        })
-                })
-                .transpose()
-            })
-            .collect::<Result<Vec<Option<i64>>>>()?;
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Time64MicrosecondArray::from_trusted_len_iter(vec.iter()) }
-    };
-
-    Ok(Arc::new(array) as ArrayRef)
-}
-
-/// Casts generic string arrays to `Time64NanosecondArray`
-fn cast_string_to_time64nanosecond<Offset: OffsetSizeTrait>(
-    array: &dyn Array,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    /// The number of nanoseconds per second.
-    const NANOS_PER_SEC: i64 = 1_000_000_000;
-
-    let string_array = array
-        .as_any()
-        .downcast_ref::<GenericStringArray<Offset>>()
-        .unwrap();
-
-    let array = if cast_options.safe {
-        let iter = string_array.iter().map(|v| {
-            v.and_then(|v| {
-                v.parse::<chrono::NaiveTime>()
-                    .map(|time| {
-                        time.num_seconds_from_midnight() as i64 * NANOS_PER_SEC
-                            + time.nanosecond() as i64
-                    })
-                    .ok()
-            })
-        });
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Time64NanosecondArray::from_trusted_len_iter(iter) }
-    } else {
-        let vec = string_array
-            .iter()
-            .map(|v| {
-                v.map(|v| {
-                    v.parse::<chrono::NaiveTime>()
-                        .map(|time| {
-                            time.num_seconds_from_midnight() as i64 * NANOS_PER_SEC
-                                + time.nanosecond() as i64
-                        })
-                        .map_err(|_| {
-                            ArrowError::CastError(format!(
-                                "Cannot cast string '{}' to value of {:?} type",
-                                v,
-                                DataType::Time64(TimeUnit::Nanosecond)
-                            ))
-                        })
-                })
-                .transpose()
-            })
-            .collect::<Result<Vec<Option<i64>>>>()?;
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { Time64NanosecondArray::from_trusted_len_iter(vec.iter()) }
-    };
-
-    Ok(Arc::new(array) as ArrayRef)
-}
-
-/// Casts generic string arrays to TimeStampNanosecondArray
-fn cast_string_to_timestamp_ns<Offset: OffsetSizeTrait>(
-    array: &dyn Array,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    let string_array = array
-        .as_any()
-        .downcast_ref::<GenericStringArray<Offset>>()
-        .unwrap();
-
-    let array = if cast_options.safe {
-        let iter = string_array
-            .iter()
-            .map(|v| v.and_then(|v| string_to_timestamp_nanos(v).ok()));
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { TimestampNanosecondArray::from_trusted_len_iter(iter) }
-    } else {
-        let vec = string_array
-            .iter()
-            .map(|v| v.map(string_to_timestamp_nanos).transpose())
-            .collect::<Result<Vec<Option<i64>>>>()?;
-
-        // Benefit:
-        //     20% performance improvement
-        // Soundness:
-        //     The iterator is trustedLen because it comes from an `StringArray`.
-        unsafe { TimestampNanosecondArray::from_trusted_len_iter(vec.iter()) }
-    };
-
-    Ok(Arc::new(array) as ArrayRef)
-}
-
-/// Casts Utf8 to Boolean
-fn cast_utf8_to_boolean(from: &ArrayRef, cast_options: &CastOptions) -> Result<ArrayRef> {
-    let array = as_string_array(from);
-
-    let output_array = array
-        .iter()
-        .map(|value| match value {
-            Some(value) => match value.to_ascii_lowercase().trim() {
-                "t" | "tr" | "tru" | "true" | "y" | "ye" | "yes" | "on" | "1" => {
-                    Ok(Some(true))
-                }
-                "f" | "fa" | "fal" | "fals" | "false" | "n" | "no" | "of" | "off"
-                | "0" => Ok(Some(false)),
-                invalid_value => match cast_options.safe {
-                    true => Ok(None),
-                    false => Err(ArrowError::CastError(format!(
-                        "Cannot cast string '{}' to value of Boolean type",
-                        invalid_value,
-                    ))),
-                },
-            },
-            None => Ok(None),
-        })
-        .collect::<Result<BooleanArray>>()?;
-
-    Ok(Arc::new(output_array))
-}
-
-/// Cast numeric types to Boolean
-///
-/// Any zero value returns `false` while non-zero returns `true`
-fn cast_numeric_to_bool<FROM>(from: &ArrayRef) -> Result<ArrayRef>
-where
-    FROM: ArrowNumericType,
-{
-    numeric_to_bool_cast::<FROM>(
-        from.as_any()
-            .downcast_ref::<PrimitiveArray<FROM>>()
-            .unwrap(),
-    )
-    .map(|to| Arc::new(to) as ArrayRef)
-}
-
-fn numeric_to_bool_cast<T>(from: &PrimitiveArray<T>) -> Result<BooleanArray>
-where
-    T: ArrowPrimitiveType + ArrowNumericType,
-{
-    let mut b = BooleanBuilder::new(from.len());
-
-    for i in 0..from.len() {
-        if from.is_null(i) {
-            b.append_null();
-        } else if from.value(i) != T::default_value() {
-            b.append_value(true);
-        } else {
-            b.append_value(false);
-        }
-    }
-
-    Ok(b.finish())
-}
-
-/// Cast Boolean types to numeric
-///
-/// `false` returns 0 while `true` returns 1
-fn cast_bool_to_numeric<TO>(
-    from: &ArrayRef,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef>
-where
-    TO: ArrowNumericType,
-    TO::Native: num::cast::NumCast,
-{
-    Ok(Arc::new(bool_to_numeric_cast::<TO>(
-        from.as_any().downcast_ref::<BooleanArray>().unwrap(),
-        cast_options,
-    )))
-}
-
-fn bool_to_numeric_cast<T>(
-    from: &BooleanArray,
-    _cast_options: &CastOptions,
-) -> PrimitiveArray<T>
-where
-    T: ArrowNumericType,
-    T::Native: num::NumCast,
-{
-    let iter = (0..from.len()).map(|i| {
-        if from.is_null(i) {
-            None
-        } else if from.value(i) {
-            // a workaround to cast a primitive to T::Native, infallible
-            num::cast::cast(1)
-        } else {
-            Some(T::default_value())
-        }
-    });
-    // Benefit:
-    //     20% performance improvement
-    // Soundness:
-    //     The iterator is trustedLen because it comes from a Range
-    unsafe { PrimitiveArray::<T>::from_trusted_len_iter(iter) }
-}
-
-/// Attempts to cast an `ArrayDictionary` with index type K into
-/// `to_type` for supported types.
-///
-/// K is the key type
-fn dictionary_cast<K: ArrowDictionaryKeyType>(
-    array: &ArrayRef,
-    to_type: &DataType,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    use DataType::*;
-
-    match to_type {
-        Dictionary(to_index_type, to_value_type) => {
-            let dict_array = array
-                .as_any()
-                .downcast_ref::<DictionaryArray<K>>()
-                .ok_or_else(|| {
-                    ArrowError::ComputeError(
-                        "Internal Error: Cannot cast dictionary to DictionaryArray of expected type".to_string(),
-                    )
-                })?;
-
-            let keys_array: ArrayRef =
-                Arc::new(PrimitiveArray::<K>::from(dict_array.keys().data().clone()));
-            let values_array = dict_array.values();
-            let cast_keys = cast_with_options(&keys_array, to_index_type, cast_options)?;
-            let cast_values =
-                cast_with_options(values_array, to_value_type, cast_options)?;
-
-            // Failure to cast keys (because they don't fit in the
-            // target type) results in NULL values;
-            if cast_keys.null_count() > keys_array.null_count() {
-                return Err(ArrowError::ComputeError(format!(
-                    "Could not convert {} dictionary indexes from {:?} to {:?}",
-                    cast_keys.null_count() - keys_array.null_count(),
-                    keys_array.data_type(),
-                    to_index_type
-                )));
-            }
-
-            // keys are data, child_data is values (dictionary)
-            let data = unsafe {
-                ArrayData::new_unchecked(
-                    to_type.clone(),
-                    cast_keys.len(),
-                    Some(cast_keys.null_count()),
-                    cast_keys
-                        .data()
-                        .null_bitmap()
-                        .cloned()
-                        .map(|bitmap| bitmap.bits),
-                    cast_keys.data().offset(),
-                    cast_keys.data().buffers().to_vec(),
-                    vec![cast_values.into_data()],
-                )
-            };
-
-            // create the appropriate array type
-            let new_array: ArrayRef = match **to_index_type {
-                Int8 => Arc::new(DictionaryArray::<Int8Type>::from(data)),
-                Int16 => Arc::new(DictionaryArray::<Int16Type>::from(data)),
-                Int32 => Arc::new(DictionaryArray::<Int32Type>::from(data)),
-                Int64 => Arc::new(DictionaryArray::<Int64Type>::from(data)),
-                UInt8 => Arc::new(DictionaryArray::<UInt8Type>::from(data)),
-                UInt16 => Arc::new(DictionaryArray::<UInt16Type>::from(data)),
-                UInt32 => Arc::new(DictionaryArray::<UInt32Type>::from(data)),
-                UInt64 => Arc::new(DictionaryArray::<UInt64Type>::from(data)),
-                _ => {
-                    return Err(ArrowError::CastError(format!(
-                        "Unsupported type {:?} for dictionary index",
-                        to_index_type
-                    )));
-                }
-            };
-
-            Ok(new_array)
-        }
-        _ => unpack_dictionary::<K>(array, to_type, cast_options),
-    }
-}
-
-// Unpack a dictionary where the keys are of type <K> into a flattened array of type to_type
-fn unpack_dictionary<K>(
-    array: &ArrayRef,
-    to_type: &DataType,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef>
-where
-    K: ArrowDictionaryKeyType,
-{
-    let dict_array = array
-        .as_any()
-        .downcast_ref::<DictionaryArray<K>>()
-        .ok_or_else(|| {
-            ArrowError::ComputeError(
-                "Internal Error: Cannot cast dictionary to DictionaryArray of expected type".to_string(),
-            )
-        })?;
-
-    // attempt to cast the dict values to the target type
-    // use the take kernel to expand out the dictionary
-    let cast_dict_values = cast_with_options(dict_array.values(), to_type, cast_options)?;
-
-    // Note take requires first casting the indices to u32
-    let keys_array: ArrayRef =
-        Arc::new(PrimitiveArray::<K>::from(dict_array.keys().data().clone()));
-    let indices = cast_with_options(&keys_array, &DataType::UInt32, cast_options)?;
-    let u32_indices =
-        indices
-            .as_any()
-            .downcast_ref::<UInt32Array>()
-            .ok_or_else(|| {
-                ArrowError::ComputeError(
-                    "Internal Error: Cannot cast dict indices to UInt32".to_string(),
-                )
-            })?;
-
-    take(cast_dict_values.as_ref(), u32_indices, None)
-}
-
-/// Attempts to encode an array into an `ArrayDictionary` with index
-/// type K and value (dictionary) type value_type
-///
-/// K is the key type
-fn cast_to_dictionary<K: ArrowDictionaryKeyType>(
-    array: &ArrayRef,
-    dict_value_type: &DataType,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    use DataType::*;
-
-    match *dict_value_type {
-        Int8 => pack_numeric_to_dictionary::<K, Int8Type>(
-            array,
-            dict_value_type,
-            cast_options,
-        ),
-        Int16 => pack_numeric_to_dictionary::<K, Int16Type>(
-            array,
-            dict_value_type,
-            cast_options,
-        ),
-        Int32 => pack_numeric_to_dictionary::<K, Int32Type>(
-            array,
-            dict_value_type,
-            cast_options,
-        ),
-        Int64 => pack_numeric_to_dictionary::<K, Int64Type>(
-            array,
-            dict_value_type,
-            cast_options,
-        ),
-        UInt8 => pack_numeric_to_dictionary::<K, UInt8Type>(
-            array,
-            dict_value_type,
-            cast_options,
-        ),
-        UInt16 => pack_numeric_to_dictionary::<K, UInt16Type>(
-            array,
-            dict_value_type,
-            cast_options,
-        ),
-        UInt32 => pack_numeric_to_dictionary::<K, UInt32Type>(
-            array,
-            dict_value_type,
-            cast_options,
-        ),
-        UInt64 => pack_numeric_to_dictionary::<K, UInt64Type>(
-            array,
-            dict_value_type,
-            cast_options,
-        ),
-        Utf8 => pack_string_to_dictionary::<K>(array, cast_options),
-        _ => Err(ArrowError::CastError(format!(
-            "Unsupported output type for dictionary packing: {:?}",
-            dict_value_type
-        ))),
-    }
-}
-
-// Packs the data from the primitive array of type <V> to a
-// DictionaryArray with keys of type K and values of value_type V
-fn pack_numeric_to_dictionary<K, V>(
-    array: &ArrayRef,
-    dict_value_type: &DataType,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef>
-where
-    K: ArrowDictionaryKeyType,
-    V: ArrowNumericType,
-{
-    // attempt to cast the source array values to the target value type (the dictionary values type)
-    let cast_values = cast_with_options(array, dict_value_type, cast_options)?;
-    let values = cast_values
-        .as_any()
-        .downcast_ref::<PrimitiveArray<V>>()
-        .unwrap();
-
-    let keys_builder = PrimitiveBuilder::<K>::new(values.len());
-    let values_builder = PrimitiveBuilder::<V>::new(values.len());
-    let mut b = PrimitiveDictionaryBuilder::new(keys_builder, values_builder);
-
-    // copy each element one at a time
-    for i in 0..values.len() {
-        if values.is_null(i) {
-            b.append_null();
-        } else {
-            b.append(values.value(i))?;
-        }
-    }
-    Ok(Arc::new(b.finish()))
-}
-
-// Packs the data as a StringDictionaryArray, if possible, with the
-// key types of K
-fn pack_string_to_dictionary<K>(
-    array: &ArrayRef,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef>
-where
-    K: ArrowDictionaryKeyType,
-{
-    let cast_values = cast_with_options(array, &DataType::Utf8, cast_options)?;
-    let values = cast_values.as_any().downcast_ref::<StringArray>().unwrap();
-
-    let keys_builder = PrimitiveBuilder::<K>::new(values.len());
-    let values_builder = StringBuilder::new(values.len());
-    let mut b = StringDictionaryBuilder::new(keys_builder, values_builder);
-
-    // copy each element one at a time
-    for i in 0..values.len() {
-        if values.is_null(i) {
-            b.append_null();
-        } else {
-            b.append(values.value(i))?;
-        }
-    }
-    Ok(Arc::new(b.finish()))
-}
-
-/// Helper function that takes a primitive array and casts to a (generic) list array.
-fn cast_primitive_to_list<OffsetSize: OffsetSizeTrait + NumCast>(
-    array: &ArrayRef,
-    to: &Field,
-    to_type: &DataType,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    // cast primitive to list's primitive
-    let cast_array = cast_with_options(array, to.data_type(), cast_options)?;
-    // create offsets, where if array.len() = 2, we have [0,1,2]
-    // Safety:
-    // Length of range can be trusted.
-    // Note: could not yet create a generic range in stable Rust.
-    let offsets = unsafe {
-        MutableBuffer::from_trusted_len_iter(
-            (0..=array.len()).map(|i| OffsetSize::from(i).expect("integer")),
-        )
-    };
-
-    let list_data = unsafe {
-        ArrayData::new_unchecked(
-            to_type.clone(),
-            array.len(),
-            Some(cast_array.null_count()),
-            cast_array
-                .data()
-                .null_bitmap()
-                .cloned()
-                .map(|bitmap| bitmap.bits),
-            0,
-            vec![offsets.into()],
-            vec![cast_array.into_data()],
-        )
-    };
-    let list_array =
-        Arc::new(GenericListArray::<OffsetSize>::from(list_data)) as ArrayRef;
-
-    Ok(list_array)
-}
-
-/// Helper function that takes an Generic list container and casts the inner datatype.
-fn cast_list_inner<OffsetSize: OffsetSizeTrait>(
-    array: &Arc<dyn Array>,
-    to: &Field,
-    to_type: &DataType,
-    cast_options: &CastOptions,
-) -> Result<ArrayRef> {
-    let data = array.data_ref();
-    let underlying_array = make_array(data.child_data()[0].clone());
-    let cast_array = cast_with_options(&underlying_array, to.data_type(), cast_options)?;
-    let array_data = unsafe {
-        ArrayData::new_unchecked(
-            to_type.clone(),
-            array.len(),
-            Some(data.null_count()),
-            data.null_bitmap().cloned().map(|bitmap| bitmap.bits),
-            array.offset(),
-            // reuse offset buffer
-            data.buffers().to_vec(),
-            vec![cast_array.into_data()],
-        )
-    };
-    let list = GenericListArray::<OffsetSize>::from(array_data);
-    Ok(Arc::new(list) as ArrayRef)
-}
-
-/// Helper function to cast from `Utf8` to `LargeUtf8` and vice versa. If the `LargeUtf8` is too large for
-/// a `Utf8` array it will return an Error.
-fn cast_str_container<OffsetSizeFrom, OffsetSizeTo>(array: &dyn Array) -> Result<ArrayRef>
-where
-    OffsetSizeFrom: OffsetSizeTrait + ToPrimitive,
-    OffsetSizeTo: OffsetSizeTrait + NumCast + ArrowNativeType,
-{
-    let str_array = array
-        .as_any()
-        .downcast_ref::<GenericStringArray<OffsetSizeFrom>>()
-        .unwrap();
-    let list_data = array.data();
-    let str_values_buf = str_array.value_data();
-
-    let offsets = list_data.buffers()[0].typed_data::<OffsetSizeFrom>();
-
-    let mut offset_builder = BufferBuilder::<OffsetSizeTo>::new(offsets.len());
-    offsets.iter().try_for_each::<_, Result<_>>(|offset| {
-        let offset = OffsetSizeTo::from(*offset).ok_or_else(|| {
-            ArrowError::ComputeError(
-                "large-utf8 array too large to cast to utf8-array".into(),
-            )
-        })?;
-        offset_builder.append(offset);
-        Ok(())
-    })?;
-
-    let offset_buffer = offset_builder.finish();
-
-    let dtype = if matches!(std::mem::size_of::<OffsetSizeTo>(), 8) {
-        DataType::LargeUtf8
-    } else {
-        DataType::Utf8
-    };
-
-    let builder = ArrayData::builder(dtype)
-        .offset(array.offset())
-        .len(array.len())
-        .add_buffer(offset_buffer)
-        .add_buffer(str_values_buf)
-        .null_bit_buffer(list_data.null_buffer().cloned());
-
-    let array_data = unsafe { builder.build_unchecked() };
-
-    Ok(Arc::new(GenericStringArray::<OffsetSizeTo>::from(
-        array_data,
-    )))
-}
-
-/// Cast the container type of List/Largelist array but not the inner types.
-/// This function can leave the value data intact and only has to cast the offset dtypes.
-fn cast_list_container<OffsetSizeFrom, OffsetSizeTo>(
-    array: &dyn Array,
-    _cast_options: &CastOptions,
-) -> Result<ArrayRef>
-where
-    OffsetSizeFrom: OffsetSizeTrait + ToPrimitive,
-    OffsetSizeTo: OffsetSizeTrait + NumCast,
-{
-    let data = array.data_ref();
-    // the value data stored by the list
-    let value_data = data.child_data()[0].clone();
-
-    let out_dtype = match array.data_type() {
-        DataType::List(value_type) => {
-            assert_eq!(
-                std::mem::size_of::<OffsetSizeFrom>(),
-                std::mem::size_of::<i32>()
-            );
-            assert_eq!(
-                std::mem::size_of::<OffsetSizeTo>(),
-                std::mem::size_of::<i64>()
-            );
-            DataType::LargeList(value_type.clone())
-        }
-        DataType::LargeList(value_type) => {
-            assert_eq!(
-                std::mem::size_of::<OffsetSizeFrom>(),
-                std::mem::size_of::<i64>()
-            );
-            assert_eq!(
-                std::mem::size_of::<OffsetSizeTo>(),
-                std::mem::size_of::<i32>()
-            );
-            if value_data.len() > i32::MAX as usize {
-                return Err(ArrowError::ComputeError(
-                    "LargeList too large to cast to List".into(),
-                ));
-            }
-            DataType::List(value_type.clone())
-        }
-        // implementation error
-        _ => unreachable!(),
-    };
-
-    // Safety:
-    //      The first buffer is the offsets and they are aligned to OffSetSizeFrom: (i64 or i32)
-    // Justification:
-    //      The safe variant data.buffer::<OffsetSizeFrom> take the offset into account and we
-    //      cannot create a list array with offsets starting at non zero.
-    let offsets = unsafe { data.buffers()[0].as_slice().align_to::<OffsetSizeFrom>() }.1;
-
-    let iter = offsets.iter().map(|idx| {
-        let idx: OffsetSizeTo = NumCast::from(*idx).unwrap();
-        idx
-    });
-
-    // SAFETY
-    //      A slice produces a trusted length iterator
-    let offset_buffer = unsafe { Buffer::from_trusted_len_iter(iter) };
-
-    // wrap up
-    let builder = ArrayData::builder(out_dtype)
-        .offset(array.offset())
-        .len(array.len())
-        .add_buffer(offset_buffer)
-        .add_child_data(value_data)
-        .null_bit_buffer(data.null_buffer().cloned());
-
-    let array_data = unsafe { builder.build_unchecked() };
-    Ok(make_array(array_data))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::datatypes::TimeUnit;
-    use crate::util::decimal::{Decimal128, Decimal256};
-    use crate::{buffer::Buffer, util::display::array_value_to_string};
-
-    macro_rules! generate_cast_test_case {
-        ($INPUT_ARRAY: expr, $OUTPUT_TYPE_ARRAY: ident, $OUTPUT_TYPE: expr, $OUTPUT_VALUES: expr) => {
-            // assert cast type
-            let input_array_type = $INPUT_ARRAY.data_type();
-            assert!(can_cast_types(input_array_type, $OUTPUT_TYPE));
-            let casted_array = cast($INPUT_ARRAY, $OUTPUT_TYPE).unwrap();
-            let result_array = casted_array
-                .as_any()
-                .downcast_ref::<$OUTPUT_TYPE_ARRAY>()
-                .unwrap();
-            assert_eq!($OUTPUT_TYPE, result_array.data_type());
-            assert_eq!(result_array.len(), $OUTPUT_VALUES.len());
-            for (i, x) in $OUTPUT_VALUES.iter().enumerate() {
-                match x {
-                    Some(x) => {
-                        assert_eq!(result_array.value(i), *x);
-                    }
-                    None => {
-                        assert!(result_array.is_null(i));
-                    }
-                }
-            }
-        };
-    }
-
-    fn create_decimal_array(
-        array: &[Option<i128>],
-        precision: usize,
-        scale: usize,
-    ) -> Result<Decimal128Array> {
-        array
-            .iter()
-            .collect::<Decimal128Array>()
-            .with_precision_and_scale(precision, scale)
-    }
-
-    fn create_decimal256_array(
-        array: Vec<Option<BigInt>>,
-        precision: usize,
-        scale: usize,
-    ) -> Result<Decimal256Array> {
-        array
-            .into_iter()
-            .collect::<Decimal256Array>()
-            .with_precision_and_scale(precision, scale)
-    }
-
-    #[test]
-    fn test_cast_decimal128_to_decimal128() {
-        let input_type = DataType::Decimal128(20, 3);
-        let output_type = DataType::Decimal128(20, 4);
-        assert!(can_cast_types(&input_type, &output_type));
-        let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
-        let input_decimal_array = create_decimal_array(&array, 20, 3).unwrap();
-        let array = Arc::new(input_decimal_array) as ArrayRef;
-        generate_cast_test_case!(
-            &array,
-            Decimal128Array,
-            &output_type,
-            vec![
-                Some(Decimal128::new_from_i128(20, 4, 11234560_i128)),
-                Some(Decimal128::new_from_i128(20, 4, 21234560_i128)),
-                Some(Decimal128::new_from_i128(20, 4, 31234560_i128)),
-                None
-            ]
-        );
-        // negative test
-        let array = vec![Some(123456), None];
-        let input_decimal_array = create_decimal_array(&array, 10, 0).unwrap();
-        let array = Arc::new(input_decimal_array) as ArrayRef;
-        let result = cast(&array, &DataType::Decimal128(2, 2));
-        assert!(result.is_err());
-        assert_eq!("Invalid argument error: 12345600 is too large to store in a Decimal128 of precision 2. Max is 99",
-                   result.unwrap_err().to_string());
-    }
-
-    #[test]
-    fn test_cast_decimal128_to_decimal256() {
-        let input_type = DataType::Decimal128(20, 3);
-        let output_type = DataType::Decimal256(20, 4);
-        assert!(can_cast_types(&input_type, &output_type));
-        let array = vec![Some(1123456), Some(2123456), Some(3123456), None];
-        let input_decimal_array = create_decimal_array(&array, 20, 3).unwrap();
-        let array = Arc::new(input_decimal_array) as ArrayRef;
-        generate_cast_test_case!(
-            &array,
-            Decimal256Array,
-            &output_type,
-            vec![
-                Some(
-                    Decimal256::from_big_int(&BigInt::from(11234560_i128), 20, 4)
-                        .unwrap()
-                ),
-                Some(
-                    Decimal256::from_big_int(&BigInt::from(21234560_i128), 20, 4)
-                        .unwrap()
-                ),
-                Some(
-                    Decimal256::from_big_int(&BigInt::from(31234560_i128), 20, 4)
-                        .unwrap()
-                ),
-                None
-            ]
-        );
-    }
-
-    #[test]
-    fn test_cast_decimal256_to_decimal128() {
-        let input_type = DataType::Decimal256(20, 3);
-        let output_type = DataType::Decimal128(20, 4);
-        assert!(can_cast_types(&input_type, &output_type));
-        let array = vec![
-            Some(BigInt::from(1123456)),
-            Some(BigInt::from(2123456)),
-            Some(BigInt::from(3123456)),
-            None,
-        ];
-        let input_decimal_array = create_decimal256_array(array, 20, 3).unwrap();
-        let array = Arc::new(input_decimal_array) as ArrayRef;
-        generate_cast_test_case!(
-            &array,
-            Decimal128Array,
-            &output_type,
-            vec![
-                Some(Decimal128::new_from_i128(20, 4, 11234560_i128)),
-                Some(Decimal128::new_from_i128(20, 4, 21234560_i128)),
-                Some(Decimal128::new_from_i128(20, 4, 31234560_i128)),
-                None
-            ]
-        );
-    }
-
-    #[test]
-    fn test_cast_decimal256_to_decimal256() {
-        let input_type = DataType::Decimal256(20, 3);
-        let output_type = DataType::Decimal256(20, 4);
-        assert!(can_cast_types(&input_type, &output_type));
-        let array = vec![
-            Some(BigInt::from(1123456)),
-            Some(BigInt::from(2123456)),
-            Some(BigInt::from(3123456)),
-            None,
-        ];
-        let input_decimal_array = create_decimal256_array(array, 20, 3).unwrap();
-        let array = Arc::new(input_decimal_array) as ArrayRef;
-        generate_cast_test_case!(
-            &array,
-            Decimal256Array,
-            &output_type,
-            vec![
-                Some(
-                    Decimal256::from_big_int(&BigInt::from(11234560_i128), 20, 4)
-                        .unwrap()
-                ),
-                Some(
-                    Decimal256::from_big_int(&BigInt::from(21234560_i128), 20, 4)
-                        .unwrap()
-                ),
-                Some(
-                    Decimal256::from_big_int(&BigInt::from(31234560_i128), 20, 4)
-                        .unwrap()
-                ),
-                None
-            ]
-        );
-    }
-
-    #[test]
-    fn test_cast_decimal_to_numeric() {
-        let decimal_type = DataType::Decimal128(38, 2);
-        // negative test
-        assert!(!can_cast_types(&decimal_type, &DataType::UInt8));
-        let value_array: Vec<Option<i128>> =
-            vec![Some(125), Some(225), Some(325), None, Some(525)];
-        let decimal_array = create_decimal_array(&value_array, 38, 2).unwrap();
-        let array = Arc::new(decimal_array) as ArrayRef;
-        // i8
-        generate_cast_test_case!(
-            &array,
-            Int8Array,
-            &DataType::Int8,
-            vec![Some(1_i8), Some(2_i8), Some(3_i8), None, Some(5_i8)]
-        );
-        // i16
-        generate_cast_test_case!(
-            &array,
-            Int16Array,
-            &DataType::Int16,
-            vec![Some(1_i16), Some(2_i16), Some(3_i16), None, Some(5_i16)]
-        );
-        // i32
-        generate_cast_test_case!(
-            &array,
-            Int32Array,
-            &DataType::Int32,
-            vec![Some(1_i32), Some(2_i32), Some(3_i32), None, Some(5_i32)]
-        );
-        // i64
-        generate_cast_test_case!(
-            &array,
-            Int64Array,
-            &DataType::Int64,
-            vec![Some(1_i64), Some(2_i64), Some(3_i64), None, Some(5_i64)]
-        );
-        // f32
-        generate_cast_test_case!(
-            &array,
-            Int64Array,
-            &DataType::Int64,
-            vec![Some(1_i64), Some(2_i64), Some(3_i64), None, Some(5_i64)]
-        );
-        // f64
-        generate_cast_test_case!(
-            &array,
-            Int64Array,
-            &DataType::Int64,
-            vec![Some(1_i64), Some(2_i64), Some(3_i64), None, Some(5_i64)]
-        );
-
-        // overflow test: out of range of max i8
-        let value_array: Vec<Option<i128>> = vec![Some(24400)];
-        let decimal_array = create_decimal_array(&value_array, 38, 2).unwrap();
-        let array = Arc::new(decimal_array) as ArrayRef;
-        let casted_array = cast(&array, &DataType::Int8);
-        assert_eq!(
-            "Cast error: value of 244 is out of range Int8".to_string(),
-            casted_array.unwrap_err().to_string()
-        );
-
-        // loss the precision: convert decimal to f32、f64
-        // f32
-        // 112345678_f32 and 112345679_f32 are same, so the 112345679_f32 will lose precision.
-        let value_array: Vec<Option<i128>> = vec![
-            Some(125),
-            Some(225),
-            Some(325),
-            None,
-            Some(525),
-            Some(112345678),
-            Some(112345679),
-        ];
-        let decimal_array = create_decimal_array(&value_array, 38, 2).unwrap();
-        let array = Arc::new(decimal_array) as ArrayRef;
-        generate_cast_test_case!(
-            &array,
-            Float32Array,
-            &DataType::Float32,
-            vec![
-                Some(1.25_f32),
-                Some(2.25_f32),
-                Some(3.25_f32),
-                None,
-                Some(5.25_f32),
-                Some(1_123_456.7_f32),
-                Some(1_123_456.7_f32)
-            ]
-        );
-
-        // f64
-        // 112345678901234568_f64 and 112345678901234560_f64 are same, so the 112345678901234568_f64 will lose precision.
-        let value_array: Vec<Option<i128>> = vec![
-            Some(125),
-            Some(225),
-            Some(325),
-            None,
-            Some(525),
-            Some(112345678901234568),
-            Some(112345678901234560),
-        ];
-        let decimal_array = create_decimal_array(&value_array, 38, 2).unwrap();
-        let array = Arc::new(decimal_array) as ArrayRef;
-        generate_cast_test_case!(
-            &array,
-            Float64Array,
-            &DataType::Float64,
-            vec![
-                Some(1.25_f64),
-                Some(2.25_f64),
-                Some(3.25_f64),
-                None,
-                Some(5.25_f64),
-                Some(1_123_456_789_012_345.6_f64),
-                Some(1_123_456_789_012_345.6_f64),
-            ]
-        );
-    }
-
-    #[test]
-    fn test_cast_numeric_to_decimal() {
-        // test negative cast type
-        let decimal_type = DataType::Decimal128(38, 6);
-        assert!(!can_cast_types(&DataType::UInt64, &decimal_type));
-
-        // i8, i16, i32, i64
-        let input_datas = vec![
-            Arc::new(Int8Array::from(vec![
-                Some(1),
-                Some(2),
-                Some(3),
-                None,
-                Some(5),
-            ])) as ArrayRef, // i8
-            Arc::new(Int16Array::from(vec![
-                Some(1),
-                Some(2),
-                Some(3),
-                None,
-                Some(5),
-            ])) as ArrayRef, // i16
-            Arc::new(Int32Array::from(vec![
-                Some(1),
-                Some(2),
-                Some(3),
-                None,
-                Some(5),
-            ])) as ArrayRef, // i32
-            Arc::new(Int64Array::from(vec![
-                Some(1),
-                Some(2),
-                Some(3),
-                None,
-                Some(5),
-            ])) as ArrayRef, // i64
-        ];
-        for array in input_datas {
-            generate_cast_test_case!(
-                &array,
-                Decimal128Array,
-                &decimal_type,
-                vec![
-                    Some(Decimal128::new_from_i128(38, 6, 1000000_i128)),
-                    Some(Decimal128::new_from_i128(38, 6, 2000000_i128)),
-                    Some(Decimal128::new_from_i128(38, 6, 3000000_i128)),
-                    None,
-                    Some(Decimal128::new_from_i128(38, 6, 5000000_i128))
-                ]
-            );
-        }
-
-        // test i8 to decimal type with overflow the result type
-        // the 100 will be converted to 1000_i128, but it is out of range for max value in the precision 3.
-        let array = Int8Array::from(vec![1, 2, 3, 4, 100]);
-        let array = Arc::new(array) as ArrayRef;
-        let casted_array = cast(&array, &DataType::Decimal128(3, 1));
-        assert!(casted_array.is_err());
-        assert_eq!("Invalid argument error: 1000 is too large to store in a Decimal128 of precision 3. Max is 999", casted_array.unwrap_err().to_string());
-
-        // test f32 to decimal type
-        let array = Float32Array::from(vec![
-            Some(1.1),
-            Some(2.2),
-            Some(4.4),
-            None,
-            Some(1.123_456_7),
-            Some(1.123_456_7),
-        ]);
-        let array = Arc::new(array) as ArrayRef;
-        generate_cast_test_case!(
-            &array,
-            Decimal128Array,
-            &decimal_type,
-            vec![
-                Some(Decimal128::new_from_i128(38, 6, 1100000_i128)),
-                Some(Decimal128::new_from_i128(38, 6, 2200000_i128)),
-                Some(Decimal128::new_from_i128(38, 6, 4400000_i128)),
-                None,
-                Some(Decimal128::new_from_i128(38, 6, 1123456_i128)),
-                Some(Decimal128::new_from_i128(38, 6, 1123456_i128)),
-            ]
-        );
-
-        // test f64 to decimal type
-        let array = Float64Array::from(vec![
-            Some(1.1),
-            Some(2.2),
-            Some(4.4),
-            None,
-            Some(1.123_456_789_123_4),
-            Some(1.123_456_789_012_345_6),
-            Some(1.123_456_789_012_345_6),
-        ]);
-        let array = Arc::new(array) as ArrayRef;
-        generate_cast_test_case!(
-            &array,
-            Decimal128Array,
-            &decimal_type,
-            vec![
-                Some(Decimal128::new_from_i128(38, 6, 1100000_i128)),
-                Some(Decimal128::new_from_i128(38, 6, 2200000_i128)),
-                Some(Decimal128::new_from_i128(38, 6, 4400000_i128)),
-                None,
-                Some(Decimal128::new_from_i128(38, 6, 1123456_i128)),
-                Some(Decimal128::new_from_i128(38, 6, 1123456_i128)),
-                Some(Decimal128::new_from_i128(38, 6, 1123456_i128)),
-            ]
-        );
-    }
-
-    #[test]
-    fn test_cast_i32_to_f64() {
-        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Float64).unwrap();
-        let c = b.as_any().downcast_ref::<Float64Array>().unwrap();
-        assert_eq!(5.0, c.value(0));
-        assert_eq!(6.0, c.value(1));
-        assert_eq!(7.0, c.value(2));
-        assert_eq!(8.0, c.value(3));
-        assert_eq!(9.0, c.value(4));
-    }
-
-    #[test]
-    fn test_cast_i32_to_u8() {
-        let a = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::UInt8).unwrap();
-        let c = b.as_any().downcast_ref::<UInt8Array>().unwrap();
-        assert!(!c.is_valid(0));
-        assert_eq!(6, c.value(1));
-        assert!(!c.is_valid(2));
-        assert_eq!(8, c.value(3));
-        // overflows return None
-        assert!(!c.is_valid(4));
-    }
-
-    #[test]
-    fn test_cast_i32_to_u8_sliced() {
-        let a = Int32Array::from(vec![-5, 6, -7, 8, 100000000]);
-        let array = Arc::new(a) as ArrayRef;
-        assert_eq!(0, array.offset());
-        let array = array.slice(2, 3);
-        assert_eq!(2, array.offset());
-        let b = cast(&array, &DataType::UInt8).unwrap();
-        assert_eq!(3, b.len());
-        assert_eq!(0, b.offset());
-        let c = b.as_any().downcast_ref::<UInt8Array>().unwrap();
-        assert!(!c.is_valid(0));
-        assert_eq!(8, c.value(1));
-        // overflows return None
-        assert!(!c.is_valid(2));
-    }
-
-    #[test]
-    fn test_cast_i32_to_i32() {
-        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Int32).unwrap();
-        let c = b.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(5, c.value(0));
-        assert_eq!(6, c.value(1));
-        assert_eq!(7, c.value(2));
-        assert_eq!(8, c.value(3));
-        assert_eq!(9, c.value(4));
-    }
-
-    #[test]
-    fn test_cast_i32_to_list_i32() {
-        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(
-            &array,
-            &DataType::List(Box::new(Field::new("item", DataType::Int32, true))),
-        )
-        .unwrap();
-        assert_eq!(5, b.len());
-        let arr = b.as_any().downcast_ref::<ListArray>().unwrap();
-        assert_eq!(&[0, 1, 2, 3, 4, 5], arr.value_offsets());
-        assert_eq!(1, arr.value_length(0));
-        assert_eq!(1, arr.value_length(1));
-        assert_eq!(1, arr.value_length(2));
-        assert_eq!(1, arr.value_length(3));
-        assert_eq!(1, arr.value_length(4));
-        let values = arr.values();
-        let c = values.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(5, c.value(0));
-        assert_eq!(6, c.value(1));
-        assert_eq!(7, c.value(2));
-        assert_eq!(8, c.value(3));
-        assert_eq!(9, c.value(4));
-    }
-
-    #[test]
-    fn test_cast_i32_to_list_i32_nullable() {
-        let a = Int32Array::from(vec![Some(5), None, Some(7), Some(8), Some(9)]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(
-            &array,
-            &DataType::List(Box::new(Field::new("item", DataType::Int32, true))),
-        )
-        .unwrap();
-        assert_eq!(5, b.len());
-        assert_eq!(1, b.null_count());
-        let arr = b.as_any().downcast_ref::<ListArray>().unwrap();
-        assert_eq!(&[0, 1, 2, 3, 4, 5], arr.value_offsets());
-        assert_eq!(1, arr.value_length(0));
-        assert_eq!(1, arr.value_length(1));
-        assert_eq!(1, arr.value_length(2));
-        assert_eq!(1, arr.value_length(3));
-        assert_eq!(1, arr.value_length(4));
-        let values = arr.values();
-        let c = values.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(1, c.null_count());
-        assert_eq!(5, c.value(0));
-        assert!(!c.is_valid(1));
-        assert_eq!(7, c.value(2));
-        assert_eq!(8, c.value(3));
-        assert_eq!(9, c.value(4));
-    }
-
-    #[test]
-    fn test_cast_i32_to_list_f64_nullable_sliced() {
-        let a = Int32Array::from(vec![Some(5), None, Some(7), Some(8), None, Some(10)]);
-        let array = Arc::new(a) as ArrayRef;
-        let array = array.slice(2, 4);
-        let b = cast(
-            &array,
-            &DataType::List(Box::new(Field::new("item", DataType::Float64, true))),
-        )
-        .unwrap();
-        assert_eq!(4, b.len());
-        assert_eq!(1, b.null_count());
-        let arr = b.as_any().downcast_ref::<ListArray>().unwrap();
-        assert_eq!(&[0, 1, 2, 3, 4], arr.value_offsets());
-        assert_eq!(1, arr.value_length(0));
-        assert_eq!(1, arr.value_length(1));
-        assert_eq!(1, arr.value_length(2));
-        assert_eq!(1, arr.value_length(3));
-        let values = arr.values();
-        let c = values.as_any().downcast_ref::<Float64Array>().unwrap();
-        assert_eq!(1, c.null_count());
-        assert_eq!(7.0, c.value(0));
-        assert_eq!(8.0, c.value(1));
-        assert!(!c.is_valid(2));
-        assert_eq!(10.0, c.value(3));
-    }
-
-    #[test]
-    fn test_cast_utf8_to_i32() {
-        let a = StringArray::from(vec!["5", "6", "seven", "8", "9.1"]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Int32).unwrap();
-        let c = b.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(5, c.value(0));
-        assert_eq!(6, c.value(1));
-        assert!(!c.is_valid(2));
-        assert_eq!(8, c.value(3));
-        assert!(!c.is_valid(4));
-    }
-
-    #[test]
-    fn test_cast_with_options_utf8_to_i32() {
-        let a = StringArray::from(vec!["5", "6", "seven", "8", "9.1"]);
-        let array = Arc::new(a) as ArrayRef;
-        let result =
-            cast_with_options(&array, &DataType::Int32, &CastOptions { safe: false });
-        match result {
-            Ok(_) => panic!("expected error"),
-            Err(e) => {
-                assert!(
-                    e.to_string().contains(
-                        "Cast error: Cannot cast string 'seven' to value of Int32 type",
-                    ),
-                    "Error: {}",
-                    e
-                )
-            }
-        }
-    }
-
-    #[test]
-    fn test_cast_utf8_to_bool() {
-        let strings = Arc::new(StringArray::from(vec![
-            "true", "false", "invalid", " Y ", "",
-        ])) as ArrayRef;
-        let casted = cast(&strings, &DataType::Boolean).unwrap();
-        let expected =
-            BooleanArray::from(vec![Some(true), Some(false), None, Some(true), None]);
-        assert_eq!(*as_boolean_array(&casted), expected);
-    }
-
-    #[test]
-    fn test_cast_with_options_utf8_to_bool() {
-        let strings = Arc::new(StringArray::from(vec![
-            "true", "false", "invalid", " Y ", "",
-        ])) as ArrayRef;
-        let casted =
-            cast_with_options(&strings, &DataType::Boolean, &CastOptions { safe: false });
-        match casted {
-            Ok(_) => panic!("expected error"),
-            Err(e) => {
-                assert!(e.to_string().contains(
-                    "Cast error: Cannot cast string 'invalid' to value of Boolean type"
-                ))
-            }
-        }
-    }
-
-    #[test]
-    fn test_cast_bool_to_i32() {
-        let a = BooleanArray::from(vec![Some(true), Some(false), None]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Int32).unwrap();
-        let c = b.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(1, c.value(0));
-        assert_eq!(0, c.value(1));
-        assert!(!c.is_valid(2));
-    }
-
-    #[test]
-    fn test_cast_bool_to_f64() {
-        let a = BooleanArray::from(vec![Some(true), Some(false), None]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Float64).unwrap();
-        let c = b.as_any().downcast_ref::<Float64Array>().unwrap();
-        assert_eq!(1.0, c.value(0));
-        assert_eq!(0.0, c.value(1));
-        assert!(!c.is_valid(2));
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Casting from Int32 to Timestamp(Microsecond, None) not supported"
-    )]
-    fn test_cast_int32_to_timestamp() {
-        let a = Int32Array::from(vec![Some(2), Some(10), None]);
-        let array = Arc::new(a) as ArrayRef;
-        cast(&array, &DataType::Timestamp(TimeUnit::Microsecond, None)).unwrap();
-    }
-
-    #[test]
-    fn test_cast_list_i32_to_list_u16() {
-        let value_data = Int32Array::from(vec![0, 0, 0, -1, -2, -1, 2, 100000000])
-            .data()
-            .clone();
-
-        let value_offsets = Buffer::from_slice_ref(&[0, 3, 6, 8]);
-
-        // Construct a list array from the above two
-        // [[0,0,0], [-1, -2, -1], [2, 100000000]]
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, true)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(3)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-        let list_array = Arc::new(ListArray::from(list_data)) as ArrayRef;
-
-        let cast_array = cast(
-            &list_array,
-            &DataType::List(Box::new(Field::new("item", DataType::UInt16, true))),
-        )
-        .unwrap();
-
-        // For the ListArray itself, there are no null values (as there were no nulls when they went in)
-        //
-        // 3 negative values should get lost when casting to unsigned,
-        // 1 value should overflow
-        assert_eq!(0, cast_array.null_count());
-
-        // offsets should be the same
-        assert_eq!(
-            list_array.data().buffers().to_vec(),
-            cast_array.data().buffers().to_vec()
-        );
-        let array = cast_array
-            .as_ref()
-            .as_any()
-            .downcast_ref::<ListArray>()
-            .unwrap();
-        assert_eq!(DataType::UInt16, array.value_type());
-        assert_eq!(3, array.value_length(0));
-        assert_eq!(3, array.value_length(1));
-        assert_eq!(2, array.value_length(2));
-
-        // expect 4 nulls: negative numbers and overflow
-        let values = array.values();
-        assert_eq!(4, values.null_count());
-        let u16arr = values.as_any().downcast_ref::<UInt16Array>().unwrap();
-
-        // expect 4 nulls: negative numbers and overflow
-        let expected: UInt16Array =
-            vec![Some(0), Some(0), Some(0), None, None, None, Some(2), None]
-                .into_iter()
-                .collect();
-
-        assert_eq!(u16arr, &expected);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Casting from Int32 to Timestamp(Microsecond, None) not supported"
-    )]
-    fn test_cast_list_i32_to_list_timestamp() {
-        // Construct a value array
-        let value_data = Int32Array::from(vec![0, 0, 0, -1, -2, -1, 2, 8, 100000000])
-            .data()
-            .clone();
-
-        let value_offsets = Buffer::from_slice_ref(&[0, 3, 6, 9]);
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, true)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(3)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-        let list_array = Arc::new(ListArray::from(list_data)) as ArrayRef;
-
-        cast(
-            &list_array,
-            &DataType::List(Box::new(Field::new(
-                "item",
-                DataType::Timestamp(TimeUnit::Microsecond, None),
-                true,
-            ))),
-        )
-        .unwrap();
-    }
-
-    #[test]
-    fn test_cast_date32_to_date64() {
-        let a = Date32Array::from(vec![10000, 17890]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Date64).unwrap();
-        let c = b.as_any().downcast_ref::<Date64Array>().unwrap();
-        assert_eq!(864000000000, c.value(0));
-        assert_eq!(1545696000000, c.value(1));
-    }
-
-    #[test]
-    fn test_cast_date64_to_date32() {
-        let a = Date64Array::from(vec![Some(864000000005), Some(1545696000001), None]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Date32).unwrap();
-        let c = b.as_any().downcast_ref::<Date32Array>().unwrap();
-        assert_eq!(10000, c.value(0));
-        assert_eq!(17890, c.value(1));
-        assert!(c.is_null(2));
-    }
-
-    #[test]
-    fn test_cast_string_to_timestamp() {
-        let a1 = Arc::new(StringArray::from(vec![
-            Some("2020-09-08T12:00:00+00:00"),
-            Some("Not a valid date"),
-            None,
-        ])) as ArrayRef;
-        let a2 = Arc::new(LargeStringArray::from(vec![
-            Some("2020-09-08T12:00:00+00:00"),
-            Some("Not a valid date"),
-            None,
-        ])) as ArrayRef;
-        for array in &[a1, a2] {
-            let to_type = DataType::Timestamp(TimeUnit::Nanosecond, None);
-            let b = cast(array, &to_type).unwrap();
-            let c = b
-                .as_any()
-                .downcast_ref::<TimestampNanosecondArray>()
-                .unwrap();
-            assert_eq!(1599566400000000000, c.value(0));
-            assert!(c.is_null(1));
-            assert!(c.is_null(2));
-
-            let options = CastOptions { safe: false };
-            let err = cast_with_options(array, &to_type, &options).unwrap_err();
-            assert_eq!(
-                err.to_string(),
-                "Cast error: Error parsing 'Not a valid date' as timestamp"
-            );
-        }
-    }
-
-    #[test]
-    fn test_cast_string_to_date32() {
-        let a1 = Arc::new(StringArray::from(vec![
-            Some("2018-12-25"),
-            Some("Not a valid date"),
-            None,
-        ])) as ArrayRef;
-        let a2 = Arc::new(LargeStringArray::from(vec![
-            Some("2018-12-25"),
-            Some("Not a valid date"),
-            None,
-        ])) as ArrayRef;
-        for array in &[a1, a2] {
-            let to_type = DataType::Date32;
-            let b = cast(array, &to_type).unwrap();
-            let c = b.as_any().downcast_ref::<Date32Array>().unwrap();
-            assert_eq!(17890, c.value(0));
-            assert!(c.is_null(1));
-            assert!(c.is_null(2));
-
-            let options = CastOptions { safe: false };
-            let err = cast_with_options(array, &to_type, &options).unwrap_err();
-            assert_eq!(err.to_string(), "Cast error: Cannot cast string 'Not a valid date' to value of Date32 type");
-        }
-    }
-
-    #[test]
-    fn test_cast_string_to_time32second() {
-        let a1 = Arc::new(StringArray::from(vec![
-            Some("08:08:35.091323414"),
-            Some("08:08:60.091323414"), // leap second
-            Some("08:08:61.091323414"), // not valid
-            Some("Not a valid time"),
-            None,
-        ])) as ArrayRef;
-        let a2 = Arc::new(LargeStringArray::from(vec![
-            Some("08:08:35.091323414"),
-            Some("08:08:60.091323414"), // leap second
-            Some("08:08:61.091323414"), // not valid
-            Some("Not a valid time"),
-            None,
-        ])) as ArrayRef;
-        for array in &[a1, a2] {
-            let to_type = DataType::Time32(TimeUnit::Second);
-            let b = cast(array, &to_type).unwrap();
-            let c = b.as_any().downcast_ref::<Time32SecondArray>().unwrap();
-            assert_eq!(29315, c.value(0));
-            assert_eq!(29340, c.value(1));
-            assert!(c.is_null(2));
-            assert!(c.is_null(3));
-            assert!(c.is_null(4));
-
-            let options = CastOptions { safe: false };
-            let err = cast_with_options(array, &to_type, &options).unwrap_err();
-            assert_eq!(err.to_string(), "Cast error: Cannot cast string '08:08:61.091323414' to value of Time32(Second) type");
-        }
-    }
-
-    #[test]
-    fn test_cast_string_to_time32millisecond() {
-        let a1 = Arc::new(StringArray::from(vec![
-            Some("08:08:35.091323414"),
-            Some("08:08:60.091323414"), // leap second
-            Some("08:08:61.091323414"), // not valid
-            Some("Not a valid time"),
-            None,
-        ])) as ArrayRef;
-        let a2 = Arc::new(LargeStringArray::from(vec![
-            Some("08:08:35.091323414"),
-            Some("08:08:60.091323414"), // leap second
-            Some("08:08:61.091323414"), // not valid
-            Some("Not a valid time"),
-            None,
-        ])) as ArrayRef;
-        for array in &[a1, a2] {
-            let to_type = DataType::Time32(TimeUnit::Millisecond);
-            let b = cast(array, &to_type).unwrap();
-            let c = b.as_any().downcast_ref::<Time32MillisecondArray>().unwrap();
-            assert_eq!(29315091, c.value(0));
-            assert_eq!(29340091, c.value(1));
-            assert!(c.is_null(2));
-            assert!(c.is_null(3));
-            assert!(c.is_null(4));
-
-            let options = CastOptions { safe: false };
-            let err = cast_with_options(array, &to_type, &options).unwrap_err();
-            assert_eq!(err.to_string(), "Cast error: Cannot cast string '08:08:61.091323414' to value of Time32(Millisecond) type");
-        }
-    }
-
-    #[test]
-    fn test_cast_string_to_time64microsecond() {
-        let a1 = Arc::new(StringArray::from(vec![
-            Some("08:08:35.091323414"),
-            Some("Not a valid time"),
-            None,
-        ])) as ArrayRef;
-        let a2 = Arc::new(LargeStringArray::from(vec![
-            Some("08:08:35.091323414"),
-            Some("Not a valid time"),
-            None,
-        ])) as ArrayRef;
-        for array in &[a1, a2] {
-            let to_type = DataType::Time64(TimeUnit::Microsecond);
-            let b = cast(array, &to_type).unwrap();
-            let c = b.as_any().downcast_ref::<Time64MicrosecondArray>().unwrap();
-            assert_eq!(29315091323, c.value(0));
-            assert!(c.is_null(1));
-            assert!(c.is_null(2));
-
-            let options = CastOptions { safe: false };
-            let err = cast_with_options(array, &to_type, &options).unwrap_err();
-            assert_eq!(err.to_string(), "Cast error: Cannot cast string 'Not a valid time' to value of Time64(Microsecond) type");
-        }
-    }
-
-    #[test]
-    fn test_cast_string_to_time64nanosecond() {
-        let a1 = Arc::new(StringArray::from(vec![
-            Some("08:08:35.091323414"),
-            Some("Not a valid time"),
-            None,
-        ])) as ArrayRef;
-        let a2 = Arc::new(LargeStringArray::from(vec![
-            Some("08:08:35.091323414"),
-            Some("Not a valid time"),
-            None,
-        ])) as ArrayRef;
-        for array in &[a1, a2] {
-            let to_type = DataType::Time64(TimeUnit::Nanosecond);
-            let b = cast(array, &to_type).unwrap();
-            let c = b.as_any().downcast_ref::<Time64NanosecondArray>().unwrap();
-            assert_eq!(29315091323414, c.value(0));
-            assert!(c.is_null(1));
-            assert!(c.is_null(2));
-
-            let options = CastOptions { safe: false };
-            let err = cast_with_options(array, &to_type, &options).unwrap_err();
-            assert_eq!(err.to_string(), "Cast error: Cannot cast string 'Not a valid time' to value of Time64(Nanosecond) type");
-        }
-    }
-
-    #[test]
-    fn test_cast_string_to_date64() {
-        let a1 = Arc::new(StringArray::from(vec![
-            Some("2020-09-08T12:00:00"),
-            Some("Not a valid date"),
-            None,
-        ])) as ArrayRef;
-        let a2 = Arc::new(LargeStringArray::from(vec![
-            Some("2020-09-08T12:00:00"),
-            Some("Not a valid date"),
-            None,
-        ])) as ArrayRef;
-        for array in &[a1, a2] {
-            let to_type = DataType::Date64;
-            let b = cast(array, &to_type).unwrap();
-            let c = b.as_any().downcast_ref::<Date64Array>().unwrap();
-            assert_eq!(1599566400000, c.value(0));
-            assert!(c.is_null(1));
-            assert!(c.is_null(2));
-
-            let options = CastOptions { safe: false };
-            let err = cast_with_options(array, &to_type, &options).unwrap_err();
-            assert_eq!(err.to_string(), "Cast error: Cannot cast string 'Not a valid date' to value of Date64 type");
-        }
-    }
-
-    #[test]
-    fn test_cast_date32_to_int32() {
-        let a = Date32Array::from(vec![10000, 17890]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Int32).unwrap();
-        let c = b.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(10000, c.value(0));
-        assert_eq!(17890, c.value(1));
-    }
-
-    #[test]
-    fn test_cast_int32_to_date32() {
-        let a = Int32Array::from(vec![10000, 17890]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Date32).unwrap();
-        let c = b.as_any().downcast_ref::<Date32Array>().unwrap();
-        assert_eq!(10000, c.value(0));
-        assert_eq!(17890, c.value(1));
-    }
-
-    #[test]
-    fn test_cast_timestamp_to_date32() {
-        let a = TimestampMillisecondArray::from_opt_vec(
-            vec![Some(864000000005), Some(1545696000001), None],
-            Some(String::from("UTC")),
-        );
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Date32).unwrap();
-        let c = b.as_any().downcast_ref::<Date32Array>().unwrap();
-        assert_eq!(10000, c.value(0));
-        assert_eq!(17890, c.value(1));
-        assert!(c.is_null(2));
-    }
-
-    #[test]
-    fn test_cast_timestamp_to_date64() {
-        let a = TimestampMillisecondArray::from_opt_vec(
-            vec![Some(864000000005), Some(1545696000001), None],
-            None,
-        );
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Date64).unwrap();
-        let c = b.as_any().downcast_ref::<Date64Array>().unwrap();
-        assert_eq!(864000000005, c.value(0));
-        assert_eq!(1545696000001, c.value(1));
-        assert!(c.is_null(2));
-    }
-
-    #[test]
-    fn test_cast_timestamp_to_i64() {
-        let a = TimestampMillisecondArray::from_opt_vec(
-            vec![Some(864000000005), Some(1545696000001), None],
-            Some("UTC".to_string()),
-        );
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Int64).unwrap();
-        let c = b.as_any().downcast_ref::<Int64Array>().unwrap();
-        assert_eq!(&DataType::Int64, c.data_type());
-        assert_eq!(864000000005, c.value(0));
-        assert_eq!(1545696000001, c.value(1));
-        assert!(c.is_null(2));
-    }
-
-    #[test]
-    fn test_cast_timestamp_to_string() {
-        let a = TimestampMillisecondArray::from_opt_vec(
-            vec![Some(864000000005), Some(1545696000001), None],
-            Some("UTC".to_string()),
-        );
-        let array = Arc::new(a) as ArrayRef;
-        dbg!(&array);
-        let b = cast(&array, &DataType::Utf8).unwrap();
-        let c = b.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(&DataType::Utf8, c.data_type());
-        assert_eq!("1997-05-19 00:00:00.005", c.value(0));
-        assert_eq!("2018-12-25 00:00:00.001", c.value(1));
-        assert!(c.is_null(2));
-    }
-
-    #[test]
-    fn test_cast_date32_to_string() {
-        let a = Date32Array::from(vec![10000, 17890]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Utf8).unwrap();
-        let c = b.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(&DataType::Utf8, c.data_type());
-        assert_eq!("1997-05-19", c.value(0));
-        assert_eq!("2018-12-25", c.value(1));
-    }
-
-    #[test]
-    fn test_cast_date64_to_string() {
-        let a = Date64Array::from(vec![10000 * 86400000, 17890 * 86400000]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Utf8).unwrap();
-        let c = b.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(&DataType::Utf8, c.data_type());
-        assert_eq!("1997-05-19 00:00:00", c.value(0));
-        assert_eq!("2018-12-25 00:00:00", c.value(1));
-    }
-
-    #[test]
-    fn test_cast_between_timestamps() {
-        let a = TimestampMillisecondArray::from_opt_vec(
-            vec![Some(864000003005), Some(1545696002001), None],
-            None,
-        );
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Timestamp(TimeUnit::Second, None)).unwrap();
-        let c = b.as_any().downcast_ref::<TimestampSecondArray>().unwrap();
-        assert_eq!(864000003, c.value(0));
-        assert_eq!(1545696002, c.value(1));
-        assert!(c.is_null(2));
-    }
-
-    #[test]
-    fn test_cast_duration_to_i64() {
-        let base = vec![5, 6, 7, 8, 100000000];
-
-        let duration_arrays = vec![
-            Arc::new(DurationNanosecondArray::from(base.clone())) as ArrayRef,
-            Arc::new(DurationMicrosecondArray::from(base.clone())) as ArrayRef,
-            Arc::new(DurationMillisecondArray::from(base.clone())) as ArrayRef,
-            Arc::new(DurationSecondArray::from(base.clone())) as ArrayRef,
-        ];
-
-        for arr in duration_arrays {
-            assert!(can_cast_types(arr.data_type(), &DataType::Int64));
-            let result = cast(&arr, &DataType::Int64).unwrap();
-            let result = result.as_any().downcast_ref::<Int64Array>().unwrap();
-            assert_eq!(base.as_slice(), result.values());
-        }
-    }
-
-    #[test]
-    fn test_cast_interval_to_i64() {
-        let base = vec![5, 6, 7, 8];
-
-        let interval_arrays = vec![
-            Arc::new(IntervalDayTimeArray::from(base.clone())) as ArrayRef,
-            Arc::new(IntervalYearMonthArray::from(
-                base.iter().map(|x| *x as i32).collect::<Vec<i32>>(),
-            )) as ArrayRef,
-        ];
-
-        for arr in interval_arrays {
-            assert!(can_cast_types(arr.data_type(), &DataType::Int64));
-            let result = cast(&arr, &DataType::Int64).unwrap();
-            let result = result.as_any().downcast_ref::<Int64Array>().unwrap();
-            assert_eq!(base.as_slice(), result.values());
-        }
-    }
-
-    #[test]
-    fn test_cast_to_strings() {
-        let a = Arc::new(Int32Array::from(vec![1, 2, 3])) as ArrayRef;
-        let out = cast(&a, &DataType::Utf8).unwrap();
-        let out = out
-            .as_any()
-            .downcast_ref::<StringArray>()
-            .unwrap()
-            .into_iter()
-            .collect::<Vec<_>>();
-        assert_eq!(out, vec![Some("1"), Some("2"), Some("3")]);
-        let out = cast(&a, &DataType::LargeUtf8).unwrap();
-        let out = out
-            .as_any()
-            .downcast_ref::<LargeStringArray>()
-            .unwrap()
-            .into_iter()
-            .collect::<Vec<_>>();
-        assert_eq!(out, vec![Some("1"), Some("2"), Some("3")]);
-    }
-
-    #[test]
-    fn test_str_to_str_casts() {
-        for data in vec![
-            vec![Some("foo"), Some("bar"), Some("ham")],
-            vec![Some("foo"), None, Some("bar")],
-        ] {
-            let a = Arc::new(LargeStringArray::from(data.clone())) as ArrayRef;
-            let to = cast(&a, &DataType::Utf8).unwrap();
-            let expect = a
-                .as_any()
-                .downcast_ref::<LargeStringArray>()
-                .unwrap()
-                .into_iter()
-                .collect::<Vec<_>>();
-            let out = to
-                .as_any()
-                .downcast_ref::<StringArray>()
-                .unwrap()
-                .into_iter()
-                .collect::<Vec<_>>();
-            assert_eq!(expect, out);
-
-            let a = Arc::new(StringArray::from(data)) as ArrayRef;
-            let to = cast(&a, &DataType::LargeUtf8).unwrap();
-            let expect = a
-                .as_any()
-                .downcast_ref::<StringArray>()
-                .unwrap()
-                .into_iter()
-                .collect::<Vec<_>>();
-            let out = to
-                .as_any()
-                .downcast_ref::<LargeStringArray>()
-                .unwrap()
-                .into_iter()
-                .collect::<Vec<_>>();
-            assert_eq!(expect, out);
-        }
-    }
-
-    #[test]
-    fn test_cast_from_f64() {
-        let f64_values: Vec<f64> = vec![
-            std::i64::MIN as f64,
-            std::i32::MIN as f64,
-            std::i16::MIN as f64,
-            std::i8::MIN as f64,
-            0_f64,
-            std::u8::MAX as f64,
-            std::u16::MAX as f64,
-            std::u32::MAX as f64,
-            std::u64::MAX as f64,
-        ];
-        let f64_array: ArrayRef = Arc::new(Float64Array::from(f64_values));
-
-        let f64_expected = vec![
-            -9223372036854776000.0,
-            -2147483648.0,
-            -32768.0,
-            -128.0,
-            0.0,
-            255.0,
-            65535.0,
-            4294967295.0,
-            18446744073709552000.0,
-        ];
-        assert_eq!(
-            f64_expected,
-            get_cast_values::<Float64Type>(&f64_array, &DataType::Float64)
-                .iter()
-                .map(|i| i.parse::<f64>().unwrap())
-                .collect::<Vec<f64>>()
-        );
-
-        let f32_expected = vec![
-            -9223372000000000000.0,
-            -2147483600.0,
-            -32768.0,
-            -128.0,
-            0.0,
-            255.0,
-            65535.0,
-            4294967300.0,
-            18446744000000000000.0,
-        ];
-        assert_eq!(
-            f32_expected,
-            get_cast_values::<Float32Type>(&f64_array, &DataType::Float32)
-                .iter()
-                .map(|i| i.parse::<f32>().unwrap())
-                .collect::<Vec<f32>>()
-        );
-
-        let i64_expected = vec![
-            "-9223372036854775808",
-            "-2147483648",
-            "-32768",
-            "-128",
-            "0",
-            "255",
-            "65535",
-            "4294967295",
-            "null",
-        ];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Int64Type>(&f64_array, &DataType::Int64)
-        );
-
-        let i32_expected = vec![
-            "null",
-            "-2147483648",
-            "-32768",
-            "-128",
-            "0",
-            "255",
-            "65535",
-            "null",
-            "null",
-        ];
-        assert_eq!(
-            i32_expected,
-            get_cast_values::<Int32Type>(&f64_array, &DataType::Int32)
-        );
-
-        let i16_expected = vec![
-            "null", "null", "-32768", "-128", "0", "255", "null", "null", "null",
-        ];
-        assert_eq!(
-            i16_expected,
-            get_cast_values::<Int16Type>(&f64_array, &DataType::Int16)
-        );
-
-        let i8_expected = vec![
-            "null", "null", "null", "-128", "0", "null", "null", "null", "null",
-        ];
-        assert_eq!(
-            i8_expected,
-            get_cast_values::<Int8Type>(&f64_array, &DataType::Int8)
-        );
-
-        let u64_expected = vec![
-            "null",
-            "null",
-            "null",
-            "null",
-            "0",
-            "255",
-            "65535",
-            "4294967295",
-            "null",
-        ];
-        assert_eq!(
-            u64_expected,
-            get_cast_values::<UInt64Type>(&f64_array, &DataType::UInt64)
-        );
-
-        let u32_expected = vec![
-            "null",
-            "null",
-            "null",
-            "null",
-            "0",
-            "255",
-            "65535",
-            "4294967295",
-            "null",
-        ];
-        assert_eq!(
-            u32_expected,
-            get_cast_values::<UInt32Type>(&f64_array, &DataType::UInt32)
-        );
-
-        let u16_expected = vec![
-            "null", "null", "null", "null", "0", "255", "65535", "null", "null",
-        ];
-        assert_eq!(
-            u16_expected,
-            get_cast_values::<UInt16Type>(&f64_array, &DataType::UInt16)
-        );
-
-        let u8_expected = vec![
-            "null", "null", "null", "null", "0", "255", "null", "null", "null",
-        ];
-        assert_eq!(
-            u8_expected,
-            get_cast_values::<UInt8Type>(&f64_array, &DataType::UInt8)
-        );
-    }
-
-    #[test]
-    fn test_cast_from_f32() {
-        let f32_values: Vec<f32> = vec![
-            std::i32::MIN as f32,
-            std::i32::MIN as f32,
-            std::i16::MIN as f32,
-            std::i8::MIN as f32,
-            0_f32,
-            std::u8::MAX as f32,
-            std::u16::MAX as f32,
-            std::u32::MAX as f32,
-            std::u32::MAX as f32,
-        ];
-        let f32_array: ArrayRef = Arc::new(Float32Array::from(f32_values));
-
-        let f64_expected = vec![
-            "-2147483648.0",
-            "-2147483648.0",
-            "-32768.0",
-            "-128.0",
-            "0.0",
-            "255.0",
-            "65535.0",
-            "4294967296.0",
-            "4294967296.0",
-        ];
-        assert_eq!(
-            f64_expected,
-            get_cast_values::<Float64Type>(&f32_array, &DataType::Float64)
-        );
-
-        let f32_expected = vec![
-            "-2147483600.0",
-            "-2147483600.0",
-            "-32768.0",
-            "-128.0",
-            "0.0",
-            "255.0",
-            "65535.0",
-            "4294967300.0",
-            "4294967300.0",
-        ];
-        assert_eq!(
-            f32_expected,
-            get_cast_values::<Float32Type>(&f32_array, &DataType::Float32)
-        );
-
-        let i64_expected = vec![
-            "-2147483648",
-            "-2147483648",
-            "-32768",
-            "-128",
-            "0",
-            "255",
-            "65535",
-            "4294967296",
-            "4294967296",
-        ];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Int64Type>(&f32_array, &DataType::Int64)
-        );
-
-        let i32_expected = vec![
-            "-2147483648",
-            "-2147483648",
-            "-32768",
-            "-128",
-            "0",
-            "255",
-            "65535",
-            "null",
-            "null",
-        ];
-        assert_eq!(
-            i32_expected,
-            get_cast_values::<Int32Type>(&f32_array, &DataType::Int32)
-        );
-
-        let i16_expected = vec![
-            "null", "null", "-32768", "-128", "0", "255", "null", "null", "null",
-        ];
-        assert_eq!(
-            i16_expected,
-            get_cast_values::<Int16Type>(&f32_array, &DataType::Int16)
-        );
-
-        let i8_expected = vec![
-            "null", "null", "null", "-128", "0", "null", "null", "null", "null",
-        ];
-        assert_eq!(
-            i8_expected,
-            get_cast_values::<Int8Type>(&f32_array, &DataType::Int8)
-        );
-
-        let u64_expected = vec![
-            "null",
-            "null",
-            "null",
-            "null",
-            "0",
-            "255",
-            "65535",
-            "4294967296",
-            "4294967296",
-        ];
-        assert_eq!(
-            u64_expected,
-            get_cast_values::<UInt64Type>(&f32_array, &DataType::UInt64)
-        );
-
-        let u32_expected = vec![
-            "null", "null", "null", "null", "0", "255", "65535", "null", "null",
-        ];
-        assert_eq!(
-            u32_expected,
-            get_cast_values::<UInt32Type>(&f32_array, &DataType::UInt32)
-        );
-
-        let u16_expected = vec![
-            "null", "null", "null", "null", "0", "255", "65535", "null", "null",
-        ];
-        assert_eq!(
-            u16_expected,
-            get_cast_values::<UInt16Type>(&f32_array, &DataType::UInt16)
-        );
-
-        let u8_expected = vec![
-            "null", "null", "null", "null", "0", "255", "null", "null", "null",
-        ];
-        assert_eq!(
-            u8_expected,
-            get_cast_values::<UInt8Type>(&f32_array, &DataType::UInt8)
-        );
-    }
-
-    #[test]
-    fn test_cast_from_uint64() {
-        let u64_values: Vec<u64> = vec![
-            0,
-            std::u8::MAX as u64,
-            std::u16::MAX as u64,
-            std::u32::MAX as u64,
-            std::u64::MAX,
-        ];
-        let u64_array: ArrayRef = Arc::new(UInt64Array::from(u64_values));
-
-        let f64_expected =
-            vec![0.0, 255.0, 65535.0, 4294967295.0, 18446744073709552000.0];
-        assert_eq!(
-            f64_expected,
-            get_cast_values::<Float64Type>(&u64_array, &DataType::Float64)
-                .iter()
-                .map(|i| i.parse::<f64>().unwrap())
-                .collect::<Vec<f64>>()
-        );
-
-        let f32_expected =
-            vec![0.0, 255.0, 65535.0, 4294967300.0, 18446744000000000000.0];
-        assert_eq!(
-            f32_expected,
-            get_cast_values::<Float32Type>(&u64_array, &DataType::Float32)
-                .iter()
-                .map(|i| i.parse::<f32>().unwrap())
-                .collect::<Vec<f32>>()
-        );
-
-        let i64_expected = vec!["0", "255", "65535", "4294967295", "null"];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Int64Type>(&u64_array, &DataType::Int64)
-        );
-
-        let i32_expected = vec!["0", "255", "65535", "null", "null"];
-        assert_eq!(
-            i32_expected,
-            get_cast_values::<Int32Type>(&u64_array, &DataType::Int32)
-        );
-
-        let i16_expected = vec!["0", "255", "null", "null", "null"];
-        assert_eq!(
-            i16_expected,
-            get_cast_values::<Int16Type>(&u64_array, &DataType::Int16)
-        );
-
-        let i8_expected = vec!["0", "null", "null", "null", "null"];
-        assert_eq!(
-            i8_expected,
-            get_cast_values::<Int8Type>(&u64_array, &DataType::Int8)
-        );
-
-        let u64_expected =
-            vec!["0", "255", "65535", "4294967295", "18446744073709551615"];
-        assert_eq!(
-            u64_expected,
-            get_cast_values::<UInt64Type>(&u64_array, &DataType::UInt64)
-        );
-
-        let u32_expected = vec!["0", "255", "65535", "4294967295", "null"];
-        assert_eq!(
-            u32_expected,
-            get_cast_values::<UInt32Type>(&u64_array, &DataType::UInt32)
-        );
-
-        let u16_expected = vec!["0", "255", "65535", "null", "null"];
-        assert_eq!(
-            u16_expected,
-            get_cast_values::<UInt16Type>(&u64_array, &DataType::UInt16)
-        );
-
-        let u8_expected = vec!["0", "255", "null", "null", "null"];
-        assert_eq!(
-            u8_expected,
-            get_cast_values::<UInt8Type>(&u64_array, &DataType::UInt8)
-        );
-    }
-
-    #[test]
-    fn test_cast_from_uint32() {
-        let u32_values: Vec<u32> = vec![
-            0,
-            std::u8::MAX as u32,
-            std::u16::MAX as u32,
-            std::u32::MAX as u32,
-        ];
-        let u32_array: ArrayRef = Arc::new(UInt32Array::from(u32_values));
-
-        let f64_expected = vec!["0.0", "255.0", "65535.0", "4294967295.0"];
-        assert_eq!(
-            f64_expected,
-            get_cast_values::<Float64Type>(&u32_array, &DataType::Float64)
-        );
-
-        let f32_expected = vec!["0.0", "255.0", "65535.0", "4294967300.0"];
-        assert_eq!(
-            f32_expected,
-            get_cast_values::<Float32Type>(&u32_array, &DataType::Float32)
-        );
-
-        let i64_expected = vec!["0", "255", "65535", "4294967295"];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Int64Type>(&u32_array, &DataType::Int64)
-        );
-
-        let i32_expected = vec!["0", "255", "65535", "null"];
-        assert_eq!(
-            i32_expected,
-            get_cast_values::<Int32Type>(&u32_array, &DataType::Int32)
-        );
-
-        let i16_expected = vec!["0", "255", "null", "null"];
-        assert_eq!(
-            i16_expected,
-            get_cast_values::<Int16Type>(&u32_array, &DataType::Int16)
-        );
-
-        let i8_expected = vec!["0", "null", "null", "null"];
-        assert_eq!(
-            i8_expected,
-            get_cast_values::<Int8Type>(&u32_array, &DataType::Int8)
-        );
-
-        let u64_expected = vec!["0", "255", "65535", "4294967295"];
-        assert_eq!(
-            u64_expected,
-            get_cast_values::<UInt64Type>(&u32_array, &DataType::UInt64)
-        );
-
-        let u32_expected = vec!["0", "255", "65535", "4294967295"];
-        assert_eq!(
-            u32_expected,
-            get_cast_values::<UInt32Type>(&u32_array, &DataType::UInt32)
-        );
-
-        let u16_expected = vec!["0", "255", "65535", "null"];
-        assert_eq!(
-            u16_expected,
-            get_cast_values::<UInt16Type>(&u32_array, &DataType::UInt16)
-        );
-
-        let u8_expected = vec!["0", "255", "null", "null"];
-        assert_eq!(
-            u8_expected,
-            get_cast_values::<UInt8Type>(&u32_array, &DataType::UInt8)
-        );
-    }
-
-    #[test]
-    fn test_cast_from_uint16() {
-        let u16_values: Vec<u16> = vec![0, std::u8::MAX as u16, std::u16::MAX as u16];
-        let u16_array: ArrayRef = Arc::new(UInt16Array::from(u16_values));
-
-        let f64_expected = vec!["0.0", "255.0", "65535.0"];
-        assert_eq!(
-            f64_expected,
-            get_cast_values::<Float64Type>(&u16_array, &DataType::Float64)
-        );
-
-        let f32_expected = vec!["0.0", "255.0", "65535.0"];
-        assert_eq!(
-            f32_expected,
-            get_cast_values::<Float32Type>(&u16_array, &DataType::Float32)
-        );
-
-        let i64_expected = vec!["0", "255", "65535"];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Int64Type>(&u16_array, &DataType::Int64)
-        );
-
-        let i32_expected = vec!["0", "255", "65535"];
-        assert_eq!(
-            i32_expected,
-            get_cast_values::<Int32Type>(&u16_array, &DataType::Int32)
-        );
-
-        let i16_expected = vec!["0", "255", "null"];
-        assert_eq!(
-            i16_expected,
-            get_cast_values::<Int16Type>(&u16_array, &DataType::Int16)
-        );
-
-        let i8_expected = vec!["0", "null", "null"];
-        assert_eq!(
-            i8_expected,
-            get_cast_values::<Int8Type>(&u16_array, &DataType::Int8)
-        );
-
-        let u64_expected = vec!["0", "255", "65535"];
-        assert_eq!(
-            u64_expected,
-            get_cast_values::<UInt64Type>(&u16_array, &DataType::UInt64)
-        );
-
-        let u32_expected = vec!["0", "255", "65535"];
-        assert_eq!(
-            u32_expected,
-            get_cast_values::<UInt32Type>(&u16_array, &DataType::UInt32)
-        );
-
-        let u16_expected = vec!["0", "255", "65535"];
-        assert_eq!(
-            u16_expected,
-            get_cast_values::<UInt16Type>(&u16_array, &DataType::UInt16)
-        );
-
-        let u8_expected = vec!["0", "255", "null"];
-        assert_eq!(
-            u8_expected,
-            get_cast_values::<UInt8Type>(&u16_array, &DataType::UInt8)
-        );
-    }
-
-    #[test]
-    fn test_cast_from_uint8() {
-        let u8_values: Vec<u8> = vec![0, std::u8::MAX];
-        let u8_array: ArrayRef = Arc::new(UInt8Array::from(u8_values));
-
-        let f64_expected = vec!["0.0", "255.0"];
-        assert_eq!(
-            f64_expected,
-            get_cast_values::<Float64Type>(&u8_array, &DataType::Float64)
-        );
-
-        let f32_expected = vec!["0.0", "255.0"];
-        assert_eq!(
-            f32_expected,
-            get_cast_values::<Float32Type>(&u8_array, &DataType::Float32)
-        );
-
-        let i64_expected = vec!["0", "255"];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Int64Type>(&u8_array, &DataType::Int64)
-        );
-
-        let i32_expected = vec!["0", "255"];
-        assert_eq!(
-            i32_expected,
-            get_cast_values::<Int32Type>(&u8_array, &DataType::Int32)
-        );
-
-        let i16_expected = vec!["0", "255"];
-        assert_eq!(
-            i16_expected,
-            get_cast_values::<Int16Type>(&u8_array, &DataType::Int16)
-        );
-
-        let i8_expected = vec!["0", "null"];
-        assert_eq!(
-            i8_expected,
-            get_cast_values::<Int8Type>(&u8_array, &DataType::Int8)
-        );
-
-        let u64_expected = vec!["0", "255"];
-        assert_eq!(
-            u64_expected,
-            get_cast_values::<UInt64Type>(&u8_array, &DataType::UInt64)
-        );
-
-        let u32_expected = vec!["0", "255"];
-        assert_eq!(
-            u32_expected,
-            get_cast_values::<UInt32Type>(&u8_array, &DataType::UInt32)
-        );
-
-        let u16_expected = vec!["0", "255"];
-        assert_eq!(
-            u16_expected,
-            get_cast_values::<UInt16Type>(&u8_array, &DataType::UInt16)
-        );
-
-        let u8_expected = vec!["0", "255"];
-        assert_eq!(
-            u8_expected,
-            get_cast_values::<UInt8Type>(&u8_array, &DataType::UInt8)
-        );
-    }
-
-    #[test]
-    fn test_cast_from_int64() {
-        let i64_values: Vec<i64> = vec![
-            std::i64::MIN,
-            std::i32::MIN as i64,
-            std::i16::MIN as i64,
-            std::i8::MIN as i64,
-            0,
-            std::i8::MAX as i64,
-            std::i16::MAX as i64,
-            std::i32::MAX as i64,
-            std::i64::MAX,
-        ];
-        let i64_array: ArrayRef = Arc::new(Int64Array::from(i64_values));
-
-        let f64_expected = vec![
-            -9223372036854776000.0,
-            -2147483648.0,
-            -32768.0,
-            -128.0,
-            0.0,
-            127.0,
-            32767.0,
-            2147483647.0,
-            9223372036854776000.0,
-        ];
-        assert_eq!(
-            f64_expected,
-            get_cast_values::<Float64Type>(&i64_array, &DataType::Float64)
-                .iter()
-                .map(|i| i.parse::<f64>().unwrap())
-                .collect::<Vec<f64>>()
-        );
-
-        let f32_expected = vec![
-            -9223372000000000000.0,
-            -2147483600.0,
-            -32768.0,
-            -128.0,
-            0.0,
-            127.0,
-            32767.0,
-            2147483600.0,
-            9223372000000000000.0,
-        ];
-        assert_eq!(
-            f32_expected,
-            get_cast_values::<Float32Type>(&i64_array, &DataType::Float32)
-                .iter()
-                .map(|i| i.parse::<f32>().unwrap())
-                .collect::<Vec<f32>>()
-        );
-
-        let i64_expected = vec![
-            "-9223372036854775808",
-            "-2147483648",
-            "-32768",
-            "-128",
-            "0",
-            "127",
-            "32767",
-            "2147483647",
-            "9223372036854775807",
-        ];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Int64Type>(&i64_array, &DataType::Int64)
-        );
-
-        let i32_expected = vec![
-            "null",
-            "-2147483648",
-            "-32768",
-            "-128",
-            "0",
-            "127",
-            "32767",
-            "2147483647",
-            "null",
-        ];
-        assert_eq!(
-            i32_expected,
-            get_cast_values::<Int32Type>(&i64_array, &DataType::Int32)
-        );
-
-        assert_eq!(
-            i32_expected,
-            get_cast_values::<Date32Type>(&i64_array, &DataType::Date32)
-        );
-
-        let i16_expected = vec![
-            "null", "null", "-32768", "-128", "0", "127", "32767", "null", "null",
-        ];
-        assert_eq!(
-            i16_expected,
-            get_cast_values::<Int16Type>(&i64_array, &DataType::Int16)
-        );
-
-        let i8_expected = vec![
-            "null", "null", "null", "-128", "0", "127", "null", "null", "null",
-        ];
-        assert_eq!(
-            i8_expected,
-            get_cast_values::<Int8Type>(&i64_array, &DataType::Int8)
-        );
-
-        let u64_expected = vec![
-            "null",
-            "null",
-            "null",
-            "null",
-            "0",
-            "127",
-            "32767",
-            "2147483647",
-            "9223372036854775807",
-        ];
-        assert_eq!(
-            u64_expected,
-            get_cast_values::<UInt64Type>(&i64_array, &DataType::UInt64)
-        );
-
-        let u32_expected = vec![
-            "null",
-            "null",
-            "null",
-            "null",
-            "0",
-            "127",
-            "32767",
-            "2147483647",
-            "null",
-        ];
-        assert_eq!(
-            u32_expected,
-            get_cast_values::<UInt32Type>(&i64_array, &DataType::UInt32)
-        );
-
-        let u16_expected = vec![
-            "null", "null", "null", "null", "0", "127", "32767", "null", "null",
-        ];
-        assert_eq!(
-            u16_expected,
-            get_cast_values::<UInt16Type>(&i64_array, &DataType::UInt16)
-        );
-
-        let u8_expected = vec![
-            "null", "null", "null", "null", "0", "127", "null", "null", "null",
-        ];
-        assert_eq!(
-            u8_expected,
-            get_cast_values::<UInt8Type>(&i64_array, &DataType::UInt8)
-        );
-    }
-
-    #[test]
-    fn test_cast_from_int32() {
-        let i32_values: Vec<i32> = vec![
-            std::i32::MIN as i32,
-            std::i16::MIN as i32,
-            std::i8::MIN as i32,
-            0,
-            std::i8::MAX as i32,
-            std::i16::MAX as i32,
-            std::i32::MAX as i32,
-        ];
-        let i32_array: ArrayRef = Arc::new(Int32Array::from(i32_values));
-
-        let f64_expected = vec![
-            "-2147483648.0",
-            "-32768.0",
-            "-128.0",
-            "0.0",
-            "127.0",
-            "32767.0",
-            "2147483647.0",
-        ];
-        assert_eq!(
-            f64_expected,
-            get_cast_values::<Float64Type>(&i32_array, &DataType::Float64)
-        );
-
-        let f32_expected = vec![
-            "-2147483600.0",
-            "-32768.0",
-            "-128.0",
-            "0.0",
-            "127.0",
-            "32767.0",
-            "2147483600.0",
-        ];
-        assert_eq!(
-            f32_expected,
-            get_cast_values::<Float32Type>(&i32_array, &DataType::Float32)
-        );
-
-        let i16_expected = vec!["null", "-32768", "-128", "0", "127", "32767", "null"];
-        assert_eq!(
-            i16_expected,
-            get_cast_values::<Int16Type>(&i32_array, &DataType::Int16)
-        );
-
-        let i8_expected = vec!["null", "null", "-128", "0", "127", "null", "null"];
-        assert_eq!(
-            i8_expected,
-            get_cast_values::<Int8Type>(&i32_array, &DataType::Int8)
-        );
-
-        let u64_expected =
-            vec!["null", "null", "null", "0", "127", "32767", "2147483647"];
-        assert_eq!(
-            u64_expected,
-            get_cast_values::<UInt64Type>(&i32_array, &DataType::UInt64)
-        );
-
-        let u32_expected =
-            vec!["null", "null", "null", "0", "127", "32767", "2147483647"];
-        assert_eq!(
-            u32_expected,
-            get_cast_values::<UInt32Type>(&i32_array, &DataType::UInt32)
-        );
-
-        let u16_expected = vec!["null", "null", "null", "0", "127", "32767", "null"];
-        assert_eq!(
-            u16_expected,
-            get_cast_values::<UInt16Type>(&i32_array, &DataType::UInt16)
-        );
-
-        let u8_expected = vec!["null", "null", "null", "0", "127", "null", "null"];
-        assert_eq!(
-            u8_expected,
-            get_cast_values::<UInt8Type>(&i32_array, &DataType::UInt8)
-        );
-
-        // The date32 to date64 cast increases the numerical values in order to keep the same dates.
-        let i64_expected = vec![
-            "-185542587187200000",
-            "-2831155200000",
-            "-11059200000",
-            "0",
-            "10972800000",
-            "2831068800000",
-            "185542587100800000",
-        ];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Date64Type>(&i32_array, &DataType::Date64)
-        );
-    }
-
-    #[test]
-    fn test_cast_from_int16() {
-        let i16_values: Vec<i16> = vec![
-            std::i16::MIN,
-            std::i8::MIN as i16,
-            0,
-            std::i8::MAX as i16,
-            std::i16::MAX,
-        ];
-        let i16_array: ArrayRef = Arc::new(Int16Array::from(i16_values));
-
-        let f64_expected = vec!["-32768.0", "-128.0", "0.0", "127.0", "32767.0"];
-        assert_eq!(
-            f64_expected,
-            get_cast_values::<Float64Type>(&i16_array, &DataType::Float64)
-        );
-
-        let f32_expected = vec!["-32768.0", "-128.0", "0.0", "127.0", "32767.0"];
-        assert_eq!(
-            f32_expected,
-            get_cast_values::<Float32Type>(&i16_array, &DataType::Float32)
-        );
-
-        let i64_expected = vec!["-32768", "-128", "0", "127", "32767"];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Int64Type>(&i16_array, &DataType::Int64)
-        );
-
-        let i32_expected = vec!["-32768", "-128", "0", "127", "32767"];
-        assert_eq!(
-            i32_expected,
-            get_cast_values::<Int32Type>(&i16_array, &DataType::Int32)
-        );
-
-        let i16_expected = vec!["-32768", "-128", "0", "127", "32767"];
-        assert_eq!(
-            i16_expected,
-            get_cast_values::<Int16Type>(&i16_array, &DataType::Int16)
-        );
-
-        let i8_expected = vec!["null", "-128", "0", "127", "null"];
-        assert_eq!(
-            i8_expected,
-            get_cast_values::<Int8Type>(&i16_array, &DataType::Int8)
-        );
-
-        let u64_expected = vec!["null", "null", "0", "127", "32767"];
-        assert_eq!(
-            u64_expected,
-            get_cast_values::<UInt64Type>(&i16_array, &DataType::UInt64)
-        );
-
-        let u32_expected = vec!["null", "null", "0", "127", "32767"];
-        assert_eq!(
-            u32_expected,
-            get_cast_values::<UInt32Type>(&i16_array, &DataType::UInt32)
-        );
-
-        let u16_expected = vec!["null", "null", "0", "127", "32767"];
-        assert_eq!(
-            u16_expected,
-            get_cast_values::<UInt16Type>(&i16_array, &DataType::UInt16)
-        );
-
-        let u8_expected = vec!["null", "null", "0", "127", "null"];
-        assert_eq!(
-            u8_expected,
-            get_cast_values::<UInt8Type>(&i16_array, &DataType::UInt8)
-        );
-    }
-
-    #[test]
-    fn test_cast_from_date32() {
-        let i32_values: Vec<i32> = vec![
-            std::i32::MIN as i32,
-            std::i16::MIN as i32,
-            std::i8::MIN as i32,
-            0,
-            std::i8::MAX as i32,
-            std::i16::MAX as i32,
-            std::i32::MAX as i32,
-        ];
-        let date32_array: ArrayRef = Arc::new(Date32Array::from(i32_values));
-
-        let i64_expected = vec![
-            "-2147483648",
-            "-32768",
-            "-128",
-            "0",
-            "127",
-            "32767",
-            "2147483647",
-        ];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Int64Type>(&date32_array, &DataType::Int64)
-        );
-    }
-
-    #[test]
-    fn test_cast_from_int8() {
-        let i8_values: Vec<i8> = vec![std::i8::MIN, 0, std::i8::MAX];
-        let i8_array: ArrayRef = Arc::new(Int8Array::from(i8_values));
-
-        let f64_expected = vec!["-128.0", "0.0", "127.0"];
-        assert_eq!(
-            f64_expected,
-            get_cast_values::<Float64Type>(&i8_array, &DataType::Float64)
-        );
-
-        let f32_expected = vec!["-128.0", "0.0", "127.0"];
-        assert_eq!(
-            f32_expected,
-            get_cast_values::<Float32Type>(&i8_array, &DataType::Float32)
-        );
-
-        let i64_expected = vec!["-128", "0", "127"];
-        assert_eq!(
-            i64_expected,
-            get_cast_values::<Int64Type>(&i8_array, &DataType::Int64)
-        );
-
-        let i32_expected = vec!["-128", "0", "127"];
-        assert_eq!(
-            i32_expected,
-            get_cast_values::<Int32Type>(&i8_array, &DataType::Int32)
-        );
-
-        let i16_expected = vec!["-128", "0", "127"];
-        assert_eq!(
-            i16_expected,
-            get_cast_values::<Int16Type>(&i8_array, &DataType::Int16)
-        );
-
-        let i8_expected = vec!["-128", "0", "127"];
-        assert_eq!(
-            i8_expected,
-            get_cast_values::<Int8Type>(&i8_array, &DataType::Int8)
-        );
-
-        let u64_expected = vec!["null", "0", "127"];
-        assert_eq!(
-            u64_expected,
-            get_cast_values::<UInt64Type>(&i8_array, &DataType::UInt64)
-        );
-
-        let u32_expected = vec!["null", "0", "127"];
-        assert_eq!(
-            u32_expected,
-            get_cast_values::<UInt32Type>(&i8_array, &DataType::UInt32)
-        );
-
-        let u16_expected = vec!["null", "0", "127"];
-        assert_eq!(
-            u16_expected,
-            get_cast_values::<UInt16Type>(&i8_array, &DataType::UInt16)
-        );
-
-        let u8_expected = vec!["null", "0", "127"];
-        assert_eq!(
-            u8_expected,
-            get_cast_values::<UInt8Type>(&i8_array, &DataType::UInt8)
-        );
-    }
-
-    /// Convert `array` into a vector of strings by casting to data type dt
-    fn get_cast_values<T>(array: &ArrayRef, dt: &DataType) -> Vec<String>
-    where
-        T: ArrowNumericType,
-    {
-        let c = cast(array, dt).unwrap();
-        let a = c.as_any().downcast_ref::<PrimitiveArray<T>>().unwrap();
-        let mut v: Vec<String> = vec![];
-        for i in 0..array.len() {
-            if a.is_null(i) {
-                v.push("null".to_string())
-            } else {
-                v.push(format!("{:?}", a.value(i)));
-            }
-        }
-        v
-    }
-
-    #[test]
-    fn test_cast_utf8_dict() {
-        // FROM a dictionary with of Utf8 values
-        use DataType::*;
-
-        let keys_builder = PrimitiveBuilder::<Int8Type>::new(10);
-        let values_builder = StringBuilder::new(10);
-        let mut builder = StringDictionaryBuilder::new(keys_builder, values_builder);
-        builder.append("one").unwrap();
-        builder.append_null();
-        builder.append("three").unwrap();
-        let array: ArrayRef = Arc::new(builder.finish());
-
-        let expected = vec!["one", "null", "three"];
-
-        // Test casting TO StringArray
-        let cast_type = Utf8;
-        let cast_array = cast(&array, &cast_type).expect("cast to UTF-8 failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-
-        // Test casting TO Dictionary (with different index sizes)
-
-        let cast_type = Dictionary(Box::new(Int16), Box::new(Utf8));
-        let cast_array = cast(&array, &cast_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-
-        let cast_type = Dictionary(Box::new(Int32), Box::new(Utf8));
-        let cast_array = cast(&array, &cast_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-
-        let cast_type = Dictionary(Box::new(Int64), Box::new(Utf8));
-        let cast_array = cast(&array, &cast_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-
-        let cast_type = Dictionary(Box::new(UInt8), Box::new(Utf8));
-        let cast_array = cast(&array, &cast_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-
-        let cast_type = Dictionary(Box::new(UInt16), Box::new(Utf8));
-        let cast_array = cast(&array, &cast_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-
-        let cast_type = Dictionary(Box::new(UInt32), Box::new(Utf8));
-        let cast_array = cast(&array, &cast_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-
-        let cast_type = Dictionary(Box::new(UInt64), Box::new(Utf8));
-        let cast_array = cast(&array, &cast_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-    }
-
-    #[test]
-    fn test_cast_dict_to_dict_bad_index_value_primitive() {
-        use DataType::*;
-        // test converting from an array that has indexes of a type
-        // that are out of bounds for a particular other kind of
-        // index.
-
-        let keys_builder = PrimitiveBuilder::<Int32Type>::new(10);
-        let values_builder = PrimitiveBuilder::<Int64Type>::new(10);
-        let mut builder = PrimitiveDictionaryBuilder::new(keys_builder, values_builder);
-
-        // add 200 distinct values (which can be stored by a
-        // dictionary indexed by int32, but not a dictionary indexed
-        // with int8)
-        for i in 0..200 {
-            builder.append(i).unwrap();
-        }
-        let array: ArrayRef = Arc::new(builder.finish());
-
-        let cast_type = Dictionary(Box::new(Int8), Box::new(Utf8));
-        let res = cast(&array, &cast_type);
-        assert!(res.is_err());
-        let actual_error = format!("{:?}", res);
-        let expected_error = "Could not convert 72 dictionary indexes from Int32 to Int8";
-        assert!(
-            actual_error.contains(expected_error),
-            "did not find expected error '{}' in actual error '{}'",
-            actual_error,
-            expected_error
-        );
-    }
-
-    #[test]
-    fn test_cast_dict_to_dict_bad_index_value_utf8() {
-        use DataType::*;
-        // Same test as test_cast_dict_to_dict_bad_index_value but use
-        // string values (and encode the expected behavior here);
-
-        let keys_builder = PrimitiveBuilder::<Int32Type>::new(10);
-        let values_builder = StringBuilder::new(10);
-        let mut builder = StringDictionaryBuilder::new(keys_builder, values_builder);
-
-        // add 200 distinct values (which can be stored by a
-        // dictionary indexed by int32, but not a dictionary indexed
-        // with int8)
-        for i in 0..200 {
-            let val = format!("val{}", i);
-            builder.append(&val).unwrap();
-        }
-        let array: ArrayRef = Arc::new(builder.finish());
-
-        let cast_type = Dictionary(Box::new(Int8), Box::new(Utf8));
-        let res = cast(&array, &cast_type);
-        assert!(res.is_err());
-        let actual_error = format!("{:?}", res);
-        let expected_error = "Could not convert 72 dictionary indexes from Int32 to Int8";
-        assert!(
-            actual_error.contains(expected_error),
-            "did not find expected error '{}' in actual error '{}'",
-            actual_error,
-            expected_error
-        );
-    }
-
-    #[test]
-    fn test_cast_primitive_dict() {
-        // FROM a dictionary with of INT32 values
-        use DataType::*;
-
-        let keys_builder = PrimitiveBuilder::<Int8Type>::new(10);
-        let values_builder = PrimitiveBuilder::<Int32Type>::new(10);
-        let mut builder = PrimitiveDictionaryBuilder::new(keys_builder, values_builder);
-        builder.append(1).unwrap();
-        builder.append_null();
-        builder.append(3).unwrap();
-        let array: ArrayRef = Arc::new(builder.finish());
-
-        let expected = vec!["1", "null", "3"];
-
-        // Test casting TO PrimitiveArray, different dictionary type
-        let cast_array = cast(&array, &Utf8).expect("cast to UTF-8 failed");
-        assert_eq!(array_to_strings(&cast_array), expected);
-        assert_eq!(cast_array.data_type(), &Utf8);
-
-        let cast_array = cast(&array, &Int64).expect("cast to int64 failed");
-        assert_eq!(array_to_strings(&cast_array), expected);
-        assert_eq!(cast_array.data_type(), &Int64);
-    }
-
-    #[test]
-    fn test_cast_primitive_array_to_dict() {
-        use DataType::*;
-
-        let mut builder = PrimitiveBuilder::<Int32Type>::new(10);
-        builder.append_value(1);
-        builder.append_null();
-        builder.append_value(3);
-        let array: ArrayRef = Arc::new(builder.finish());
-
-        let expected = vec!["1", "null", "3"];
-
-        // Cast to a dictionary (same value type, Int32)
-        let cast_type = Dictionary(Box::new(UInt8), Box::new(Int32));
-        let cast_array = cast(&array, &cast_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-
-        // Cast to a dictionary (different value type, Int8)
-        let cast_type = Dictionary(Box::new(UInt8), Box::new(Int8));
-        let cast_array = cast(&array, &cast_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-    }
-
-    #[test]
-    fn test_cast_string_array_to_dict() {
-        use DataType::*;
-
-        let array = Arc::new(StringArray::from(vec![Some("one"), None, Some("three")]))
-            as ArrayRef;
-
-        let expected = vec!["one", "null", "three"];
-
-        // Cast to a dictionary (same value type, Utf8)
-        let cast_type = Dictionary(Box::new(UInt8), Box::new(Utf8));
-        let cast_array = cast(&array, &cast_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &cast_type);
-        assert_eq!(array_to_strings(&cast_array), expected);
-    }
-
-    #[test]
-    fn test_cast_null_array_to_from_decimal_array() {
-        let data_type = DataType::Decimal128(12, 4);
-        let array = new_null_array(&DataType::Null, 4);
-        assert_eq!(array.data_type(), &DataType::Null);
-        let cast_array = cast(&array, &data_type).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &data_type);
-        for i in 0..4 {
-            assert!(cast_array.is_null(i));
-        }
-
-        let array = new_null_array(&data_type, 4);
-        assert_eq!(array.data_type(), &data_type);
-        let cast_array = cast(&array, &DataType::Null).expect("cast failed");
-        assert_eq!(cast_array.data_type(), &DataType::Null);
-        for i in 0..4 {
-            assert!(cast_array.is_null(i));
-        }
-    }
-
-    #[test]
-    fn test_cast_null_array_from_and_to_primitive_array() {
-        macro_rules! typed_test {
-            ($ARR_TYPE:ident, $DATATYPE:ident, $TYPE:tt) => {{
-                {
-                    let array = Arc::new(NullArray::new(6)) as ArrayRef;
-                    let expected = $ARR_TYPE::from(vec![None; 6]);
-                    let cast_type = DataType::$DATATYPE;
-                    let cast_array = cast(&array, &cast_type).expect("cast failed");
-                    let cast_array = as_primitive_array::<$TYPE>(&cast_array);
-                    assert_eq!(cast_array.data_type(), &cast_type);
-                    assert_eq!(cast_array, &expected);
-                }
-            }};
-        }
-
-        typed_test!(Int16Array, Int16, Int16Type);
-        typed_test!(Int32Array, Int32, Int32Type);
-        typed_test!(Int64Array, Int64, Int64Type);
-
-        typed_test!(UInt16Array, UInt16, UInt16Type);
-        typed_test!(UInt32Array, UInt32, UInt32Type);
-        typed_test!(UInt64Array, UInt64, UInt64Type);
-
-        typed_test!(Float32Array, Float32, Float32Type);
-        typed_test!(Float64Array, Float64, Float64Type);
-
-        typed_test!(Date32Array, Date32, Date32Type);
-        typed_test!(Date64Array, Date64, Date64Type);
-    }
-
-    fn cast_from_null_to_other(data_type: &DataType) {
-        // Cast from null to data_type
-        {
-            let array = new_null_array(&DataType::Null, 4);
-            assert_eq!(array.data_type(), &DataType::Null);
-            let cast_array = cast(&array, data_type).expect("cast failed");
-            assert_eq!(cast_array.data_type(), data_type);
-            for i in 0..4 {
-                assert!(cast_array.is_null(i));
-            }
-        }
-    }
-
-    #[test]
-    fn test_cast_null_from_and_to_variable_sized() {
-        cast_from_null_to_other(&DataType::Utf8);
-        cast_from_null_to_other(&DataType::LargeUtf8);
-        cast_from_null_to_other(&DataType::Binary);
-        cast_from_null_to_other(&DataType::LargeBinary);
-    }
-
-    #[test]
-    fn test_cast_null_from_and_to_nested_type() {
-        // Cast null from and to map
-        let data_type = DataType::Map(
-            Box::new(Field::new(
-                "entry",
-                DataType::Struct(vec![
-                    Field::new("key", DataType::Utf8, false),
-                    Field::new("value", DataType::Int32, true),
-                ]),
-                false,
-            )),
-            false,
-        );
-        cast_from_null_to_other(&data_type);
-
-        // Cast null from and to list
-        let data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, true)));
-        cast_from_null_to_other(&data_type);
-        let data_type =
-            DataType::LargeList(Box::new(Field::new("item", DataType::Int32, true)));
-        cast_from_null_to_other(&data_type);
-        let data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::Int32, true)),
-            4,
-        );
-        cast_from_null_to_other(&data_type);
-
-        // Cast null from and to dictionary
-        let values = vec![None, None, None, None] as Vec<Option<&str>>;
-        let array: DictionaryArray<Int8Type> = values.into_iter().collect();
-        let array = Arc::new(array) as ArrayRef;
-        let data_type = array.data_type().to_owned();
-        cast_from_null_to_other(&data_type);
-
-        // Cast null from and to struct
-        let data_type =
-            DataType::Struct(vec![Field::new("data", DataType::Int64, false)]);
-        cast_from_null_to_other(&data_type);
-    }
-
-    /// Print the `DictionaryArray` `array` as a vector of strings
-    fn array_to_strings(array: &ArrayRef) -> Vec<String> {
-        (0..array.len())
-            .map(|i| {
-                if array.is_null(i) {
-                    "null".to_string()
-                } else {
-                    array_value_to_string(array, i).expect("Convert array to String")
-                }
-            })
-            .collect()
-    }
-
-    #[test]
-    fn test_cast_utf8_to_date32() {
-        use chrono::NaiveDate;
-        let from_ymd = chrono::NaiveDate::from_ymd;
-        let since = chrono::NaiveDate::signed_duration_since;
-
-        let a = StringArray::from(vec![
-            "2000-01-01",          // valid date with leading 0s
-            "2000-2-2",            // valid date without leading 0s
-            "2000-00-00",          // invalid month and day
-            "2000-01-01T12:00:00", // date + time is invalid
-            "2000",                // just a year is invalid
-        ]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Date32).unwrap();
-        let c = b.as_any().downcast_ref::<Date32Array>().unwrap();
-
-        // test valid inputs
-        let date_value = since(NaiveDate::from_ymd(2000, 1, 1), from_ymd(1970, 1, 1))
-            .num_days() as i32;
-        assert!(c.is_valid(0)); // "2000-01-01"
-        assert_eq!(date_value, c.value(0));
-
-        let date_value = since(NaiveDate::from_ymd(2000, 2, 2), from_ymd(1970, 1, 1))
-            .num_days() as i32;
-        assert!(c.is_valid(1)); // "2000-2-2"
-        assert_eq!(date_value, c.value(1));
-
-        // test invalid inputs
-        assert!(!c.is_valid(2)); // "2000-00-00"
-        assert!(!c.is_valid(3)); // "2000-01-01T12:00:00"
-        assert!(!c.is_valid(4)); // "2000"
-    }
-
-    #[test]
-    fn test_cast_utf8_to_date64() {
-        let a = StringArray::from(vec![
-            "2000-01-01T12:00:00", // date + time valid
-            "2020-12-15T12:34:56", // date + time valid
-            "2020-2-2T12:34:56",   // valid date time without leading 0s
-            "2000-00-00T12:00:00", // invalid month and day
-            "2000-01-01 12:00:00", // missing the 'T'
-            "2000-01-01",          // just a date is invalid
-        ]);
-        let array = Arc::new(a) as ArrayRef;
-        let b = cast(&array, &DataType::Date64).unwrap();
-        let c = b.as_any().downcast_ref::<Date64Array>().unwrap();
-
-        // test valid inputs
-        assert!(c.is_valid(0)); // "2000-01-01T12:00:00"
-        assert_eq!(946728000000, c.value(0));
-        assert!(c.is_valid(1)); // "2020-12-15T12:34:56"
-        assert_eq!(1608035696000, c.value(1));
-        assert!(c.is_valid(2)); // "2020-2-2T12:34:56"
-        assert_eq!(1580646896000, c.value(2));
-
-        // test invalid inputs
-        assert!(!c.is_valid(3)); // "2000-00-00T12:00:00"
-        assert!(!c.is_valid(4)); // "2000-01-01 12:00:00"
-        assert!(!c.is_valid(5)); // "2000-01-01"
-    }
-
-    #[test]
-    #[cfg_attr(miri, ignore)] // running forever
-    fn test_can_cast_types() {
-        // this function attempts to ensure that can_cast_types stays
-        // in sync with cast.  It simply tries all combinations of
-        // types and makes sure that if `can_cast_types` returns
-        // true, so does `cast`
-
-        let all_types = get_all_types();
-
-        for array in get_arrays_of_all_types() {
-            for to_type in &all_types {
-                println!("Test casting {:?} --> {:?}", array.data_type(), to_type);
-                let cast_result = cast(&array, to_type);
-                let reported_cast_ability = can_cast_types(array.data_type(), to_type);
-
-                // check for mismatch
-                match (cast_result, reported_cast_ability) {
-                    (Ok(_), false) => {
-                        panic!("Was able to cast array {:?} from {:?} to {:?} but can_cast_types reported false",
-                               array, array.data_type(), to_type)
-                    }
-                    (Err(e), true) => {
-                        panic!("Was not able to cast array {:?} from {:?} to {:?} but can_cast_types reported true. \
-                                Error was {:?}",
-                               array, array.data_type(), to_type, e)
-                    }
-                    // otherwise it was a match
-                    _ => {}
-                };
-            }
-        }
-    }
-
-    #[test]
-    fn test_cast_list_containers() {
-        // large-list to list
-        let array = Arc::new(make_large_list_array()) as ArrayRef;
-        let list_array = cast(
-            &array,
-            &DataType::List(Box::new(Field::new("", DataType::Int32, false))),
-        )
-        .unwrap();
-        let actual = list_array.as_any().downcast_ref::<ListArray>().unwrap();
-        let expected = array.as_any().downcast_ref::<LargeListArray>().unwrap();
-
-        assert_eq!(&expected.value(0), &actual.value(0));
-        assert_eq!(&expected.value(1), &actual.value(1));
-        assert_eq!(&expected.value(2), &actual.value(2));
-
-        // list to large-list
-        let array = Arc::new(make_list_array()) as ArrayRef;
-        let large_list_array = cast(
-            &array,
-            &DataType::LargeList(Box::new(Field::new("", DataType::Int32, false))),
-        )
-        .unwrap();
-        let actual = large_list_array
-            .as_any()
-            .downcast_ref::<LargeListArray>()
-            .unwrap();
-        let expected = array.as_any().downcast_ref::<ListArray>().unwrap();
-
-        assert_eq!(&expected.value(0), &actual.value(0));
-        assert_eq!(&expected.value(1), &actual.value(1));
-        assert_eq!(&expected.value(2), &actual.value(2));
-    }
-
-    /// Create instances of arrays with varying types for cast tests
-    fn get_arrays_of_all_types() -> Vec<ArrayRef> {
-        let tz_name = String::from("America/New_York");
-        let binary_data: Vec<&[u8]> = vec![b"foo", b"bar"];
-        vec![
-            Arc::new(BinaryArray::from(binary_data.clone())),
-            Arc::new(LargeBinaryArray::from(binary_data.clone())),
-            make_dictionary_primitive::<Int8Type>(),
-            make_dictionary_primitive::<Int16Type>(),
-            make_dictionary_primitive::<Int32Type>(),
-            make_dictionary_primitive::<Int64Type>(),
-            make_dictionary_primitive::<UInt8Type>(),
-            make_dictionary_primitive::<UInt16Type>(),
-            make_dictionary_primitive::<UInt32Type>(),
-            make_dictionary_primitive::<UInt64Type>(),
-            make_dictionary_utf8::<Int8Type>(),
-            make_dictionary_utf8::<Int16Type>(),
-            make_dictionary_utf8::<Int32Type>(),
-            make_dictionary_utf8::<Int64Type>(),
-            make_dictionary_utf8::<UInt8Type>(),
-            make_dictionary_utf8::<UInt16Type>(),
-            make_dictionary_utf8::<UInt32Type>(),
-            make_dictionary_utf8::<UInt64Type>(),
-            Arc::new(make_list_array()),
-            Arc::new(make_large_list_array()),
-            Arc::new(make_fixed_size_list_array()),
-            Arc::new(make_fixed_size_binary_array()),
-            Arc::new(StructArray::from(vec![
-                (
-                    Field::new("a", DataType::Boolean, false),
-                    Arc::new(BooleanArray::from(vec![false, false, true, true]))
-                        as Arc<dyn Array>,
-                ),
-                (
-                    Field::new("b", DataType::Int32, false),
-                    Arc::new(Int32Array::from(vec![42, 28, 19, 31])),
-                ),
-            ])),
-            Arc::new(make_union_array()),
-            Arc::new(NullArray::new(10)),
-            Arc::new(StringArray::from(vec!["foo", "bar"])),
-            Arc::new(LargeStringArray::from(vec!["foo", "bar"])),
-            Arc::new(BooleanArray::from(vec![true, false])),
-            Arc::new(Int8Array::from(vec![1, 2])),
-            Arc::new(Int16Array::from(vec![1, 2])),
-            Arc::new(Int32Array::from(vec![1, 2])),
-            Arc::new(Int64Array::from(vec![1, 2])),
-            Arc::new(UInt8Array::from(vec![1, 2])),
-            Arc::new(UInt16Array::from(vec![1, 2])),
-            Arc::new(UInt32Array::from(vec![1, 2])),
-            Arc::new(UInt64Array::from(vec![1, 2])),
-            Arc::new(Float32Array::from(vec![1.0, 2.0])),
-            Arc::new(Float64Array::from(vec![1.0, 2.0])),
-            Arc::new(TimestampSecondArray::from_vec(vec![1000, 2000], None)),
-            Arc::new(TimestampMillisecondArray::from_vec(vec![1000, 2000], None)),
-            Arc::new(TimestampMicrosecondArray::from_vec(vec![1000, 2000], None)),
-            Arc::new(TimestampNanosecondArray::from_vec(vec![1000, 2000], None)),
-            Arc::new(TimestampSecondArray::from_vec(
-                vec![1000, 2000],
-                Some(tz_name.clone()),
-            )),
-            Arc::new(TimestampMillisecondArray::from_vec(
-                vec![1000, 2000],
-                Some(tz_name.clone()),
-            )),
-            Arc::new(TimestampMicrosecondArray::from_vec(
-                vec![1000, 2000],
-                Some(tz_name.clone()),
-            )),
-            Arc::new(TimestampNanosecondArray::from_vec(
-                vec![1000, 2000],
-                Some(tz_name),
-            )),
-            Arc::new(Date32Array::from(vec![1000, 2000])),
-            Arc::new(Date64Array::from(vec![1000, 2000])),
-            Arc::new(Time32SecondArray::from(vec![1000, 2000])),
-            Arc::new(Time32MillisecondArray::from(vec![1000, 2000])),
-            Arc::new(Time64MicrosecondArray::from(vec![1000, 2000])),
-            Arc::new(Time64NanosecondArray::from(vec![1000, 2000])),
-            Arc::new(IntervalYearMonthArray::from(vec![1000, 2000])),
-            Arc::new(IntervalDayTimeArray::from(vec![1000, 2000])),
-            Arc::new(IntervalMonthDayNanoArray::from(vec![1000, 2000])),
-            Arc::new(DurationSecondArray::from(vec![1000, 2000])),
-            Arc::new(DurationMillisecondArray::from(vec![1000, 2000])),
-            Arc::new(DurationMicrosecondArray::from(vec![1000, 2000])),
-            Arc::new(DurationNanosecondArray::from(vec![1000, 2000])),
-            Arc::new(
-                create_decimal_array(&[Some(1), Some(2), Some(3), None], 38, 0).unwrap(),
-            ),
-        ]
-    }
-
-    fn make_list_array() -> ListArray {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(8)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7]))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
-        let value_offsets = Buffer::from_slice_ref(&[0, 3, 6, 8]);
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, true)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(3)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-        ListArray::from(list_data)
-    }
-
-    fn make_large_list_array() -> LargeListArray {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(8)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7]))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1, 2], [3, 4, 5], [6, 7]]
-        let value_offsets = Buffer::from_slice_ref(&[0i64, 3, 6, 8]);
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::LargeList(Box::new(Field::new("item", DataType::Int32, true)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(3)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-        LargeListArray::from(list_data)
-    }
-
-    fn make_fixed_size_list_array() -> FixedSizeListArray {
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(10)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
-            .build()
-            .unwrap();
-
-        // Construct a fixed size list array from the above two
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::Int32, true)),
-            2,
-        );
-        let list_data = ArrayData::builder(list_data_type)
-            .len(5)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-        FixedSizeListArray::from(list_data)
-    }
-
-    fn make_fixed_size_binary_array() -> FixedSizeBinaryArray {
-        let values: [u8; 15] = *b"hellotherearrow";
-
-        let array_data = ArrayData::builder(DataType::FixedSizeBinary(5))
-            .len(3)
-            .add_buffer(Buffer::from(&values[..]))
-            .build()
-            .unwrap();
-        FixedSizeBinaryArray::from(array_data)
-    }
-
-    fn make_union_array() -> UnionArray {
-        let mut builder = UnionBuilder::new_dense(7);
-        builder.append::<Int32Type>("a", 1).unwrap();
-        builder.append::<Int64Type>("b", 2).unwrap();
-        builder.build().unwrap()
-    }
-
-    /// Creates a dictionary with primitive dictionary values, and keys of type K
-    fn make_dictionary_primitive<K: ArrowDictionaryKeyType>() -> ArrayRef {
-        let keys_builder = PrimitiveBuilder::<K>::new(2);
-        // Pick Int32 arbitrarily for dictionary values
-        let values_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut b = PrimitiveDictionaryBuilder::new(keys_builder, values_builder);
-        b.append(1).unwrap();
-        b.append(2).unwrap();
-        Arc::new(b.finish())
-    }
-
-    /// Creates a dictionary with utf8 values, and keys of type K
-    fn make_dictionary_utf8<K: ArrowDictionaryKeyType>() -> ArrayRef {
-        let keys_builder = PrimitiveBuilder::<K>::new(2);
-        // Pick Int32 arbitrarily for dictionary values
-        let values_builder = StringBuilder::new(2);
-        let mut b = StringDictionaryBuilder::new(keys_builder, values_builder);
-        b.append("foo").unwrap();
-        b.append("bar").unwrap();
-        Arc::new(b.finish())
-    }
-
-    // Get a selection of datatypes to try and cast to
-    fn get_all_types() -> Vec<DataType> {
-        use DataType::*;
-        let tz_name = String::from("America/New_York");
-
-        vec![
-            Null,
-            Boolean,
-            Int8,
-            Int16,
-            Int32,
-            UInt64,
-            UInt8,
-            UInt16,
-            UInt32,
-            UInt64,
-            Float16,
-            Float32,
-            Float64,
-            Timestamp(TimeUnit::Second, None),
-            Timestamp(TimeUnit::Millisecond, None),
-            Timestamp(TimeUnit::Microsecond, None),
-            Timestamp(TimeUnit::Nanosecond, None),
-            Timestamp(TimeUnit::Second, Some(tz_name.clone())),
-            Timestamp(TimeUnit::Millisecond, Some(tz_name.clone())),
-            Timestamp(TimeUnit::Microsecond, Some(tz_name.clone())),
-            Timestamp(TimeUnit::Nanosecond, Some(tz_name)),
-            Date32,
-            Date64,
-            Time32(TimeUnit::Second),
-            Time32(TimeUnit::Millisecond),
-            Time64(TimeUnit::Microsecond),
-            Time64(TimeUnit::Nanosecond),
-            Duration(TimeUnit::Second),
-            Duration(TimeUnit::Millisecond),
-            Duration(TimeUnit::Microsecond),
-            Duration(TimeUnit::Nanosecond),
-            Interval(IntervalUnit::YearMonth),
-            Interval(IntervalUnit::DayTime),
-            Interval(IntervalUnit::MonthDayNano),
-            Binary,
-            FixedSizeBinary(10),
-            LargeBinary,
-            Utf8,
-            LargeUtf8,
-            List(Box::new(Field::new("item", DataType::Int8, true))),
-            List(Box::new(Field::new("item", DataType::Utf8, true))),
-            FixedSizeList(Box::new(Field::new("item", DataType::Int8, true)), 10),
-            FixedSizeList(Box::new(Field::new("item", DataType::Utf8, false)), 10),
-            LargeList(Box::new(Field::new("item", DataType::Int8, true))),
-            LargeList(Box::new(Field::new("item", DataType::Utf8, false))),
-            Struct(vec![
-                Field::new("f1", DataType::Int32, false),
-                Field::new("f2", DataType::Utf8, true),
-            ]),
-            Union(
-                vec![
-                    Field::new("f1", DataType::Int32, false),
-                    Field::new("f2", DataType::Utf8, true),
-                ],
-                vec![0, 1],
-                UnionMode::Dense,
-            ),
-            Dictionary(Box::new(DataType::Int8), Box::new(DataType::Int32)),
-            Dictionary(Box::new(DataType::Int16), Box::new(DataType::Utf8)),
-            Dictionary(Box::new(DataType::UInt32), Box::new(DataType::Utf8)),
-            Decimal128(38, 0),
-        ]
-    }
-
-    #[test]
-    fn test_utf8_cast_offsets() {
-        // test if offset of the array is taken into account during cast
-        let str_array = StringArray::from(vec!["a", "b", "c"]);
-        let str_array = str_array.slice(1, 2);
-
-        let out = cast(&str_array, &DataType::LargeUtf8).unwrap();
-
-        let large_str_array = out.as_any().downcast_ref::<LargeStringArray>().unwrap();
-        let strs = large_str_array.into_iter().flatten().collect::<Vec<_>>();
-        assert_eq!(strs, &["b", "c"])
-    }
-
-    #[test]
-    fn test_list_cast_offsets() {
-        // test if offset of the array is taken into account during cast
-        let array1 = make_list_array().slice(1, 2);
-        let array2 = Arc::new(make_list_array()) as ArrayRef;
-
-        let dt = DataType::LargeList(Box::new(Field::new("item", DataType::Int32, true)));
-        let out1 = cast(&array1, &dt).unwrap();
-        let out2 = cast(&array2, &dt).unwrap();
-
-        assert_eq!(&out1, &out2.slice(1, 2))
-    }
-}
diff --git a/arrow/src/compute/kernels/cast_utils.rs b/arrow/src/compute/kernels/cast_utils.rs
deleted file mode 100644
index e43961b4ab8a..000000000000
--- a/arrow/src/compute/kernels/cast_utils.rs
+++ /dev/null
@@ -1,300 +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.
-
-use crate::error::{ArrowError, Result};
-use chrono::{prelude::*, LocalResult};
-
-/// Accepts a string in RFC3339 / ISO8601 standard format and some
-/// variants and converts it to a nanosecond precision timestamp.
-///
-/// Implements the `to_timestamp` function to convert a string to a
-/// timestamp, following the model of spark SQL’s to_`timestamp`.
-///
-/// In addition to RFC3339 / ISO8601 standard timestamps, it also
-/// accepts strings that use a space ` ` to separate the date and time
-/// as well as strings that have no explicit timezone offset.
-///
-/// Examples of accepted inputs:
-/// * `1997-01-31T09:26:56.123Z`        # RCF3339
-/// * `1997-01-31T09:26:56.123-05:00`   # RCF3339
-/// * `1997-01-31 09:26:56.123-05:00`   # close to RCF3339 but with a space rather than T
-/// * `1997-01-31T09:26:56.123`         # close to RCF3339 but no timezone offset specified
-/// * `1997-01-31 09:26:56.123`         # close to RCF3339 but uses a space and no timezone offset
-/// * `1997-01-31 09:26:56`             # close to RCF3339, no fractional seconds
-//
-/// Internally, this function uses the `chrono` library for the
-/// datetime parsing
-///
-/// We hope to extend this function in the future with a second
-/// parameter to specifying the format string.
-///
-/// ## Timestamp Precision
-///
-/// Function uses the maximum precision timestamps supported by
-/// Arrow (nanoseconds stored as a 64-bit integer) timestamps. This
-/// means the range of dates that timestamps can represent is ~1677 AD
-/// to 2262 AM
-///
-///
-/// ## Timezone / Offset Handling
-///
-/// Numerical values of timestamps are stored compared to offset UTC.
-///
-/// This function interprets strings without an explicit time zone as
-/// timestamps with offsets of the local time on the machine
-///
-/// For example, `1997-01-31 09:26:56.123Z` is interpreted as UTC, as
-/// it has an explicit timezone specifier (“Z” for Zulu/UTC)
-///
-/// `1997-01-31T09:26:56.123` is interpreted as a local timestamp in
-/// the timezone of the machine. For example, if
-/// the system timezone is set to Americas/New_York (UTC-5) the
-/// timestamp will be interpreted as though it were
-/// `1997-01-31T09:26:56.123-05:00`
-#[inline]
-pub fn string_to_timestamp_nanos(s: &str) -> Result<i64> {
-    // Fast path:  RFC3339 timestamp (with a T)
-    // Example: 2020-09-08T13:42:29.190855Z
-    if let Ok(ts) = DateTime::parse_from_rfc3339(s) {
-        return Ok(ts.timestamp_nanos());
-    }
-
-    // Implement quasi-RFC3339 support by trying to parse the
-    // timestamp with various other format specifiers to to support
-    // separating the date and time with a space ' ' rather than 'T' to be
-    // (more) compatible with Apache Spark SQL
-
-    // timezone offset, using ' ' as a separator
-    // Example: 2020-09-08 13:42:29.190855-05:00
-    if let Ok(ts) = DateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S%.f%:z") {
-        return Ok(ts.timestamp_nanos());
-    }
-
-    // with an explicit Z, using ' ' as a separator
-    // Example: 2020-09-08 13:42:29Z
-    if let Ok(ts) = Utc.datetime_from_str(s, "%Y-%m-%d %H:%M:%S%.fZ") {
-        return Ok(ts.timestamp_nanos());
-    }
-
-    // Support timestamps without an explicit timezone offset, again
-    // to be compatible with what Apache Spark SQL does.
-
-    // without a timezone specifier as a local time, using T as a separator
-    // Example: 2020-09-08T13:42:29.190855
-    if let Ok(ts) = NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S%.f") {
-        return naive_datetime_to_timestamp(s, ts);
-    }
-
-    // without a timezone specifier as a local time, using T as a
-    // separator, no fractional seconds
-    // Example: 2020-09-08T13:42:29
-    if let Ok(ts) = NaiveDateTime::parse_from_str(s, "%Y-%m-%dT%H:%M:%S") {
-        return naive_datetime_to_timestamp(s, ts);
-    }
-
-    // without a timezone specifier as a local time, using ' ' as a separator
-    // Example: 2020-09-08 13:42:29.190855
-    if let Ok(ts) = NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S%.f") {
-        return naive_datetime_to_timestamp(s, ts);
-    }
-
-    // without a timezone specifier as a local time, using ' ' as a
-    // separator, no fractional seconds
-    // Example: 2020-09-08 13:42:29
-    if let Ok(ts) = NaiveDateTime::parse_from_str(s, "%Y-%m-%d %H:%M:%S") {
-        return naive_datetime_to_timestamp(s, ts);
-    }
-
-    // Note we don't pass along the error message from the underlying
-    // chrono parsing because we tried several different format
-    // strings and we don't know which the user was trying to
-    // match. Ths any of the specific error messages is likely to be
-    // be more confusing than helpful
-    Err(ArrowError::CastError(format!(
-        "Error parsing '{}' as timestamp",
-        s
-    )))
-}
-
-/// Converts the naive datetime (which has no specific timezone) to a
-/// nanosecond epoch timestamp relative to UTC.
-fn naive_datetime_to_timestamp(s: &str, datetime: NaiveDateTime) -> Result<i64> {
-    let l = Local {};
-
-    match l.from_local_datetime(&datetime) {
-        LocalResult::None => Err(ArrowError::CastError(format!(
-            "Error parsing '{}' as timestamp: local time representation is invalid",
-            s
-        ))),
-        LocalResult::Single(local_datetime) => {
-            Ok(local_datetime.with_timezone(&Utc).timestamp_nanos())
-        }
-        // Ambiguous times can happen if the timestamp is exactly when
-        // a daylight savings time transition occurs, for example, and
-        // so the datetime could validly be said to be in two
-        // potential offsets. However, since we are about to convert
-        // to UTC anyways, we can pick one arbitrarily
-        LocalResult::Ambiguous(local_datetime, _) => {
-            Ok(local_datetime.with_timezone(&Utc).timestamp_nanos())
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn string_to_timestamp_timezone() -> Result<()> {
-        // Explicit timezone
-        assert_eq!(
-            1599572549190855000,
-            parse_timestamp("2020-09-08T13:42:29.190855+00:00")?
-        );
-        assert_eq!(
-            1599572549190855000,
-            parse_timestamp("2020-09-08T13:42:29.190855Z")?
-        );
-        assert_eq!(
-            1599572549000000000,
-            parse_timestamp("2020-09-08T13:42:29Z")?
-        ); // no fractional part
-        assert_eq!(
-            1599590549190855000,
-            parse_timestamp("2020-09-08T13:42:29.190855-05:00")?
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn string_to_timestamp_timezone_space() -> Result<()> {
-        // Ensure space rather than T between time and date is accepted
-        assert_eq!(
-            1599572549190855000,
-            parse_timestamp("2020-09-08 13:42:29.190855+00:00")?
-        );
-        assert_eq!(
-            1599572549190855000,
-            parse_timestamp("2020-09-08 13:42:29.190855Z")?
-        );
-        assert_eq!(
-            1599572549000000000,
-            parse_timestamp("2020-09-08 13:42:29Z")?
-        ); // no fractional part
-        assert_eq!(
-            1599590549190855000,
-            parse_timestamp("2020-09-08 13:42:29.190855-05:00")?
-        );
-        Ok(())
-    }
-
-    /// Interprets a naive_datetime (with no explicit timezone offset)
-    /// using the local timezone and returns the timestamp in UTC (0
-    /// offset)
-    fn naive_datetime_to_timestamp(naive_datetime: &NaiveDateTime) -> i64 {
-        // Note: Use chrono APIs that are different than
-        // naive_datetime_to_timestamp to compute the utc offset to
-        // try and double check the logic
-        let utc_offset_secs = match Local.offset_from_local_datetime(naive_datetime) {
-            LocalResult::Single(local_offset) => {
-                local_offset.fix().local_minus_utc() as i64
-            }
-            _ => panic!("Unexpected failure converting to local datetime"),
-        };
-        let utc_offset_nanos = utc_offset_secs * 1_000_000_000;
-        naive_datetime.timestamp_nanos() - utc_offset_nanos
-    }
-
-    #[test]
-    #[cfg_attr(miri, ignore)] // unsupported operation: can't call foreign function: mktime
-    fn string_to_timestamp_no_timezone() -> Result<()> {
-        // This test is designed to succeed in regardless of the local
-        // timezone the test machine is running. Thus it is still
-        // somewhat susceptible to bugs in the use of chrono
-        let naive_datetime = NaiveDateTime::new(
-            NaiveDate::from_ymd(2020, 9, 8),
-            NaiveTime::from_hms_nano(13, 42, 29, 190855000),
-        );
-
-        // Ensure both T and ' ' variants work
-        assert_eq!(
-            naive_datetime_to_timestamp(&naive_datetime),
-            parse_timestamp("2020-09-08T13:42:29.190855")?
-        );
-
-        assert_eq!(
-            naive_datetime_to_timestamp(&naive_datetime),
-            parse_timestamp("2020-09-08 13:42:29.190855")?
-        );
-
-        // Also ensure that parsing timestamps with no fractional
-        // second part works as well
-        let naive_datetime_whole_secs = NaiveDateTime::new(
-            NaiveDate::from_ymd(2020, 9, 8),
-            NaiveTime::from_hms(13, 42, 29),
-        );
-
-        // Ensure both T and ' ' variants work
-        assert_eq!(
-            naive_datetime_to_timestamp(&naive_datetime_whole_secs),
-            parse_timestamp("2020-09-08T13:42:29")?
-        );
-
-        assert_eq!(
-            naive_datetime_to_timestamp(&naive_datetime_whole_secs),
-            parse_timestamp("2020-09-08 13:42:29")?
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn string_to_timestamp_invalid() {
-        // Test parsing invalid formats
-
-        // It would be nice to make these messages better
-        expect_timestamp_parse_error("", "Error parsing '' as timestamp");
-        expect_timestamp_parse_error("SS", "Error parsing 'SS' as timestamp");
-        expect_timestamp_parse_error(
-            "Wed, 18 Feb 2015 23:16:09 GMT",
-            "Error parsing 'Wed, 18 Feb 2015 23:16:09 GMT' as timestamp",
-        );
-    }
-
-    // Parse a timestamp to timestamp int with a useful human readable error message
-    fn parse_timestamp(s: &str) -> Result<i64> {
-        let result = string_to_timestamp_nanos(s);
-        if let Err(e) = &result {
-            eprintln!("Error parsing timestamp '{}': {:?}", s, e);
-        }
-        result
-    }
-
-    fn expect_timestamp_parse_error(s: &str, expected_err: &str) {
-        match string_to_timestamp_nanos(s) {
-            Ok(v) => panic!(
-                "Expected error '{}' while parsing '{}', but parsed {} instead",
-                expected_err, s, v
-            ),
-            Err(e) => {
-                assert!(e.to_string().contains(expected_err),
-                        "Can not find expected error '{}' while parsing '{}'. Actual error '{}'",
-                        expected_err, s, e);
-            }
-        }
-    }
-}
diff --git a/arrow/src/compute/kernels/comparison.rs b/arrow/src/compute/kernels/comparison.rs
deleted file mode 100644
index 1d0bc938ece9..000000000000
--- a/arrow/src/compute/kernels/comparison.rs
+++ /dev/null
@@ -1,4940 +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.
-
-//! Comparison kernels for `Array`s.
-//!
-//! These kernels can leverage SIMD if available on your system.  Currently no runtime
-//! detection is provided, you should enable the specific SIMD intrinsics using
-//! `RUSTFLAGS="-C target-feature=+avx2"` for example.  See the documentation
-//! [here](https://doc.rust-lang.org/stable/core/arch/) for more information.
-//!
-
-use crate::array::*;
-use crate::buffer::{buffer_unary_not, Buffer, MutableBuffer};
-use crate::compute::util::combine_option_bitmap;
-use crate::datatypes::{
-    ArrowNativeType, ArrowNumericType, DataType, Date32Type, Date64Type, Float32Type,
-    Float64Type, Int16Type, Int32Type, Int64Type, Int8Type, IntervalDayTimeType,
-    IntervalMonthDayNanoType, IntervalUnit, IntervalYearMonthType, TimeUnit,
-    TimestampMicrosecondType, TimestampMillisecondType, TimestampNanosecondType,
-    TimestampSecondType, UInt16Type, UInt32Type, UInt64Type, UInt8Type,
-};
-use crate::error::{ArrowError, Result};
-use crate::util::bit_util;
-use regex::Regex;
-use std::collections::HashMap;
-
-/// Helper function to perform boolean lambda function on values from two array accessors, this
-/// version does not attempt to use SIMD.
-fn compare_op<T: ArrayAccessor, F>(left: T, right: T, op: F) -> Result<BooleanArray>
-where
-    F: Fn(T::Item, T::Item) -> bool,
-{
-    if left.len() != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform comparison operation on arrays of different length"
-                .to_string(),
-        ));
-    }
-
-    let null_bit_buffer =
-        combine_option_bitmap(&[left.data_ref(), right.data_ref()], left.len())?;
-
-    // Safety:
-    // `i < $left.len()` and $left.len() == $right.len()
-    let comparison = (0..left.len())
-        .map(|i| unsafe { op(left.value_unchecked(i), right.value_unchecked(i)) });
-    // same size as $left.len() and $right.len()
-    let buffer = unsafe { MutableBuffer::from_trusted_len_iter_bool(comparison) };
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            left.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![Buffer::from(buffer)],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Helper function to perform boolean lambda function on values from array accessor, this
-/// version does not attempt to use SIMD.
-fn compare_op_scalar<T: ArrayAccessor, F>(left: T, op: F) -> Result<BooleanArray>
-where
-    F: Fn(T::Item) -> bool,
-{
-    let null_bit_buffer = left
-        .data()
-        .null_buffer()
-        .map(|b| b.bit_slice(left.offset(), left.len()));
-
-    // Safety:
-    // `i < $left.len()`
-    let comparison = (0..left.len()).map(|i| unsafe { op(left.value_unchecked(i)) });
-    // same as $left.len()
-    let buffer = unsafe { MutableBuffer::from_trusted_len_iter_bool(comparison) };
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            left.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![Buffer::from(buffer)],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Evaluate `op(left, right)` for [`PrimitiveArray`]s using a specified
-/// comparison function.
-pub fn no_simd_compare_op<T, F>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-    op: F,
-) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-    F: Fn(T::Native, T::Native) -> bool,
-{
-    compare_op(left, right, op)
-}
-
-/// Evaluate `op(left, right)` for [`PrimitiveArray`] and scalar using
-/// a specified comparison function.
-pub fn no_simd_compare_op_scalar<T, F>(
-    left: &PrimitiveArray<T>,
-    right: T::Native,
-    op: F,
-) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-    F: Fn(T::Native, T::Native) -> bool,
-{
-    compare_op_scalar(left, |l| op(l, right))
-}
-
-fn is_like_pattern(c: char) -> bool {
-    c == '%' || c == '_'
-}
-
-/// Evaluate regex `op(left)` matching `right` on [`StringArray`] / [`LargeStringArray`]
-///
-/// If `negate_regex` is true, the regex expression will be negated. (for example, with `not like`)
-fn regex_like<OffsetSize, F>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-    negate_regex: bool,
-    op: F,
-) -> Result<BooleanArray>
-where
-    OffsetSize: OffsetSizeTrait,
-    F: Fn(&str) -> Result<Regex>,
-{
-    let mut map = HashMap::new();
-    if left.len() != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform comparison operation on arrays of different length"
-                .to_string(),
-        ));
-    }
-
-    let null_bit_buffer =
-        combine_option_bitmap(&[left.data_ref(), right.data_ref()], left.len())?;
-
-    let mut result = BooleanBufferBuilder::new(left.len());
-    for i in 0..left.len() {
-        let haystack = left.value(i);
-        let pat = right.value(i);
-        let re = if let Some(ref regex) = map.get(pat) {
-            regex
-        } else {
-            let re_pattern = replace_like_wildcards(pat)?;
-            let re = op(&re_pattern)?;
-            map.insert(pat, re);
-            map.get(pat).unwrap()
-        };
-
-        result.append(if negate_regex {
-            !re.is_match(haystack)
-        } else {
-            re.is_match(haystack)
-        });
-    }
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            left.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![result.finish()],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Perform SQL `left LIKE right` operation on [`StringArray`] / [`LargeStringArray`].
-///
-/// There are two wildcards supported with the LIKE operator:
-///
-/// 1. `%` - The percent sign represents zero, one, or multiple characters
-/// 2. `_` - The underscore represents a single character
-///
-/// For example:
-/// ```
-/// use arrow::array::{StringArray, BooleanArray};
-/// use arrow::compute::like_utf8;
-///
-/// let strings = StringArray::from(vec!["Arrow", "Arrow", "Arrow", "Ar"]);
-/// let patterns = StringArray::from(vec!["A%", "B%", "A.", "A_"]);
-///
-/// let result = like_utf8(&strings, &patterns).unwrap();
-/// assert_eq!(result, BooleanArray::from(vec![true, false, false, true]));
-/// ```
-pub fn like_utf8<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    regex_like(left, right, false, |re_pattern| {
-        Regex::new(&format!("^{}$", re_pattern)).map_err(|e| {
-            ArrowError::ComputeError(format!(
-                "Unable to build regex from LIKE pattern: {}",
-                e
-            ))
-        })
-    })
-}
-
-/// Perform SQL `left LIKE right` operation on [`StringArray`] /
-/// [`LargeStringArray`] and a scalar.
-///
-/// See the documentation on [`like_utf8`] for more details.
-pub fn like_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &str,
-) -> Result<BooleanArray> {
-    let null_bit_buffer = left.data().null_buffer().cloned();
-    let bytes = bit_util::ceil(left.len(), 8);
-    let mut bool_buf = MutableBuffer::from_len_zeroed(bytes);
-    let bool_slice = bool_buf.as_slice_mut();
-
-    if !right.contains(is_like_pattern) {
-        // fast path, can use equals
-        for i in 0..left.len() {
-            if left.value(i) == right {
-                bit_util::set_bit(bool_slice, i);
-            }
-        }
-    } else if right.ends_with('%')
-        && !right.ends_with("\\%")
-        && !right[..right.len() - 1].contains(is_like_pattern)
-    {
-        // fast path, can use starts_with
-        let starts_with = &right[..right.len() - 1];
-        for i in 0..left.len() {
-            if left.value(i).starts_with(starts_with) {
-                bit_util::set_bit(bool_slice, i);
-            }
-        }
-    } else if right.starts_with('%') && !right[1..].contains(is_like_pattern) {
-        // fast path, can use ends_with
-        let ends_with = &right[1..];
-        for i in 0..left.len() {
-            if left.value(i).ends_with(ends_with) {
-                bit_util::set_bit(bool_slice, i);
-            }
-        }
-    } else {
-        let re_pattern = replace_like_wildcards(right)?;
-        let re = Regex::new(&format!("^{}$", re_pattern)).map_err(|e| {
-            ArrowError::ComputeError(format!(
-                "Unable to build regex from LIKE pattern: {}",
-                e
-            ))
-        })?;
-
-        for i in 0..left.len() {
-            let haystack = left.value(i);
-            if re.is_match(haystack) {
-                bit_util::set_bit(bool_slice, i);
-            }
-        }
-    };
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            left.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![bool_buf.into()],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Transforms a like `pattern` to a regex compatible pattern. To achieve that, it does:
-///
-/// 1. Replace like wildcards for regex expressions as the pattern will be evaluated using regex match: `%` => `.*` and `_` => `.`
-/// 2. Escape regex meta characters to match them and not be evaluated as regex special chars. For example: `.` => `\\.`
-/// 3. Replace escaped like wildcards removing the escape characters to be able to match it as a regex. For example: `\\%` => `%`
-fn replace_like_wildcards(pattern: &str) -> Result<String> {
-    let mut result = String::new();
-    let pattern = String::from(pattern);
-    let mut chars_iter = pattern.chars().peekable();
-    while let Some(c) = chars_iter.next() {
-        if c == '\\' {
-            let next = chars_iter.peek();
-            match next {
-                Some(next) if is_like_pattern(*next) => {
-                    result.push(*next);
-                    // Skipping the next char as it is already appended
-                    chars_iter.next();
-                }
-                _ => {
-                    result.push('\\');
-                    result.push('\\');
-                }
-            }
-        } else if regex_syntax::is_meta_character(c) {
-            result.push('\\');
-            result.push(c);
-        } else if c == '%' {
-            result.push_str(".*");
-        } else if c == '_' {
-            result.push('.');
-        } else {
-            result.push(c);
-        }
-    }
-    Ok(result)
-}
-
-/// Perform SQL `left NOT LIKE right` operation on [`StringArray`] /
-/// [`LargeStringArray`].
-///
-/// See the documentation on [`like_utf8`] for more details.
-pub fn nlike_utf8<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    regex_like(left, right, true, |re_pattern| {
-        Regex::new(&format!("^{}$", re_pattern)).map_err(|e| {
-            ArrowError::ComputeError(format!(
-                "Unable to build regex from LIKE pattern: {}",
-                e
-            ))
-        })
-    })
-}
-
-/// Perform SQL `left NOT LIKE right` operation on [`StringArray`] /
-/// [`LargeStringArray`] and a scalar.
-///
-/// See the documentation on [`like_utf8`] for more details.
-pub fn nlike_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &str,
-) -> Result<BooleanArray> {
-    let null_bit_buffer = left.data().null_buffer().cloned();
-    let mut result = BooleanBufferBuilder::new(left.len());
-
-    if !right.contains(is_like_pattern) {
-        // fast path, can use equals
-        for i in 0..left.len() {
-            result.append(left.value(i) != right);
-        }
-    } else if right.ends_with('%')
-        && !right.ends_with("\\%")
-        && !right[..right.len() - 1].contains(is_like_pattern)
-    {
-        // fast path, can use ends_with
-        for i in 0..left.len() {
-            result.append(!left.value(i).starts_with(&right[..right.len() - 1]));
-        }
-    } else if right.starts_with('%') && !right[1..].contains(is_like_pattern) {
-        // fast path, can use starts_with
-        for i in 0..left.len() {
-            result.append(!left.value(i).ends_with(&right[1..]));
-        }
-    } else {
-        let re_pattern = replace_like_wildcards(right)?;
-        let re = Regex::new(&format!("^{}$", re_pattern)).map_err(|e| {
-            ArrowError::ComputeError(format!(
-                "Unable to build regex from LIKE pattern: {}",
-                e
-            ))
-        })?;
-        for i in 0..left.len() {
-            let haystack = left.value(i);
-            result.append(!re.is_match(haystack));
-        }
-    }
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            left.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![result.finish()],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Perform SQL `left ILIKE right` operation on [`StringArray`] /
-/// [`LargeStringArray`].
-///
-/// See the documentation on [`like_utf8`] for more details.
-pub fn ilike_utf8<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    regex_like(left, right, false, |re_pattern| {
-        Regex::new(&format!("(?i)^{}$", re_pattern)).map_err(|e| {
-            ArrowError::ComputeError(format!(
-                "Unable to build regex from ILIKE pattern: {}",
-                e
-            ))
-        })
-    })
-}
-
-/// Perform SQL `left ILIKE right` operation on [`StringArray`] /
-/// [`LargeStringArray`] and a scalar.
-///
-/// See the documentation on [`like_utf8`] for more details.
-pub fn ilike_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &str,
-) -> Result<BooleanArray> {
-    let null_bit_buffer = left.data().null_buffer().cloned();
-    let mut result = BooleanBufferBuilder::new(left.len());
-
-    if !right.contains(is_like_pattern) {
-        // fast path, can use equals
-        for i in 0..left.len() {
-            result.append(left.value(i) == right);
-        }
-    } else if right.ends_with('%')
-        && !right.ends_with("\\%")
-        && !right[..right.len() - 1].contains(is_like_pattern)
-    {
-        // fast path, can use ends_with
-        for i in 0..left.len() {
-            result.append(
-                left.value(i)
-                    .to_uppercase()
-                    .starts_with(&right[..right.len() - 1].to_uppercase()),
-            );
-        }
-    } else if right.starts_with('%') && !right[1..].contains(is_like_pattern) {
-        // fast path, can use starts_with
-        for i in 0..left.len() {
-            result.append(
-                left.value(i)
-                    .to_uppercase()
-                    .ends_with(&right[1..].to_uppercase()),
-            );
-        }
-    } else {
-        let re_pattern = replace_like_wildcards(right)?;
-        let re = Regex::new(&format!("(?i)^{}$", re_pattern)).map_err(|e| {
-            ArrowError::ComputeError(format!(
-                "Unable to build regex from ILIKE pattern: {}",
-                e
-            ))
-        })?;
-        for i in 0..left.len() {
-            let haystack = left.value(i);
-            result.append(re.is_match(haystack));
-        }
-    }
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            left.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![result.finish()],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Perform SQL `left NOT ILIKE right` operation on [`StringArray`] /
-/// [`LargeStringArray`].
-///
-/// See the documentation on [`like_utf8`] for more details.
-pub fn nilike_utf8<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    regex_like(left, right, true, |re_pattern| {
-        Regex::new(&format!("(?i)^{}$", re_pattern)).map_err(|e| {
-            ArrowError::ComputeError(format!(
-                "Unable to build regex from ILIKE pattern: {}",
-                e
-            ))
-        })
-    })
-}
-
-/// Perform SQL `left NOT ILIKE right` operation on [`StringArray`] /
-/// [`LargeStringArray`] and a scalar.
-///
-/// See the documentation on [`like_utf8`] for more details.
-pub fn nilike_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &str,
-) -> Result<BooleanArray> {
-    let null_bit_buffer = left.data().null_buffer().cloned();
-    let mut result = BooleanBufferBuilder::new(left.len());
-
-    if !right.contains(is_like_pattern) {
-        // fast path, can use equals
-        for i in 0..left.len() {
-            result.append(left.value(i) != right);
-        }
-    } else if right.ends_with('%')
-        && !right.ends_with("\\%")
-        && !right[..right.len() - 1].contains(is_like_pattern)
-    {
-        // fast path, can use ends_with
-        for i in 0..left.len() {
-            result.append(
-                !left
-                    .value(i)
-                    .to_uppercase()
-                    .starts_with(&right[..right.len() - 1].to_uppercase()),
-            );
-        }
-    } else if right.starts_with('%') && !right[1..].contains(is_like_pattern) {
-        // fast path, can use starts_with
-        for i in 0..left.len() {
-            result.append(
-                !left
-                    .value(i)
-                    .to_uppercase()
-                    .ends_with(&right[1..].to_uppercase()),
-            );
-        }
-    } else {
-        let re_pattern = replace_like_wildcards(right)?;
-        let re = Regex::new(&format!("(?i)^{}$", re_pattern)).map_err(|e| {
-            ArrowError::ComputeError(format!(
-                "Unable to build regex from ILIKE pattern: {}",
-                e
-            ))
-        })?;
-        for i in 0..left.len() {
-            let haystack = left.value(i);
-            result.append(!re.is_match(haystack));
-        }
-    }
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            left.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![result.finish()],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Perform SQL `array ~ regex_array` operation on [`StringArray`] / [`LargeStringArray`].
-/// If `regex_array` element has an empty value, the corresponding result value is always true.
-///
-/// `flags_array` are optional [`StringArray`] / [`LargeStringArray`] flag, which allow
-/// special search modes, such as case insensitive and multi-line mode.
-/// See the documentation [here](https://docs.rs/regex/1.5.4/regex/#grouping-and-flags)
-/// for more information.
-pub fn regexp_is_match_utf8<OffsetSize: OffsetSizeTrait>(
-    array: &GenericStringArray<OffsetSize>,
-    regex_array: &GenericStringArray<OffsetSize>,
-    flags_array: Option<&GenericStringArray<OffsetSize>>,
-) -> Result<BooleanArray> {
-    if array.len() != regex_array.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform comparison operation on arrays of different length"
-                .to_string(),
-        ));
-    }
-    let null_bit_buffer =
-        combine_option_bitmap(&[array.data_ref(), regex_array.data_ref()], array.len())?;
-
-    let mut patterns: HashMap<String, Regex> = HashMap::new();
-    let mut result = BooleanBufferBuilder::new(array.len());
-
-    let complete_pattern = match flags_array {
-        Some(flags) => Box::new(regex_array.iter().zip(flags.iter()).map(
-            |(pattern, flags)| {
-                pattern.map(|pattern| match flags {
-                    Some(flag) => format!("(?{}){}", flag, pattern),
-                    None => pattern.to_string(),
-                })
-            },
-        )) as Box<dyn Iterator<Item = Option<String>>>,
-        None => Box::new(
-            regex_array
-                .iter()
-                .map(|pattern| pattern.map(|pattern| pattern.to_string())),
-        ),
-    };
-
-    array
-        .iter()
-        .zip(complete_pattern)
-        .map(|(value, pattern)| {
-            match (value, pattern) {
-                // Required for Postgres compatibility:
-                // SELECT 'foobarbequebaz' ~ ''); = true
-                (Some(_), Some(pattern)) if pattern == *"" => {
-                    result.append(true);
-                }
-                (Some(value), Some(pattern)) => {
-                    let existing_pattern = patterns.get(&pattern);
-                    let re = match existing_pattern {
-                        Some(re) => re.clone(),
-                        None => {
-                            let re = Regex::new(pattern.as_str()).map_err(|e| {
-                                ArrowError::ComputeError(format!(
-                                    "Regular expression did not compile: {:?}",
-                                    e
-                                ))
-                            })?;
-                            patterns.insert(pattern, re.clone());
-                            re
-                        }
-                    };
-                    result.append(re.is_match(value));
-                }
-                _ => result.append(false),
-            }
-            Ok(())
-        })
-        .collect::<Result<Vec<()>>>()?;
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            array.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![result.finish()],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Perform SQL `array ~ regex_array` operation on [`StringArray`] /
-/// [`LargeStringArray`] and a scalar.
-///
-/// See the documentation on [`regexp_is_match_utf8`] for more details.
-pub fn regexp_is_match_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    array: &GenericStringArray<OffsetSize>,
-    regex: &str,
-    flag: Option<&str>,
-) -> Result<BooleanArray> {
-    let null_bit_buffer = array.data().null_buffer().cloned();
-    let mut result = BooleanBufferBuilder::new(array.len());
-
-    let pattern = match flag {
-        Some(flag) => format!("(?{}){}", flag, regex),
-        None => regex.to_string(),
-    };
-    if pattern.is_empty() {
-        result.append_n(array.len(), true);
-    } else {
-        let re = Regex::new(pattern.as_str()).map_err(|e| {
-            ArrowError::ComputeError(format!(
-                "Regular expression did not compile: {:?}",
-                e
-            ))
-        })?;
-        for i in 0..array.len() {
-            let value = array.value(i);
-            result.append(re.is_match(value));
-        }
-    }
-
-    let buffer = result.finish();
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            array.len(),
-            None,
-            null_bit_buffer,
-            0,
-            vec![buffer],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Perform `left == right` operation on [`StringArray`] / [`LargeStringArray`].
-pub fn eq_utf8<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a == b)
-}
-
-/// Perform `left == right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
-pub fn eq_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &str,
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a == right)
-}
-
-/// Perform `left == right` operation on [`BooleanArray`]
-pub fn eq_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| !(a ^ b))
-}
-
-/// Perform `left != right` operation on [`BooleanArray`]
-pub fn neq_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| (a ^ b))
-}
-
-/// Perform `left < right` operation on [`BooleanArray`]
-pub fn lt_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| ((!a) & b))
-}
-
-/// Perform `left <= right` operation on [`BooleanArray`]
-pub fn lt_eq_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| !(a & (!b)))
-}
-
-/// Perform `left > right` operation on [`BooleanArray`]
-pub fn gt_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| (a & (!b)))
-}
-
-/// Perform `left >= right` operation on [`BooleanArray`]
-pub fn gt_eq_bool(left: &BooleanArray, right: &BooleanArray) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| !((!a) & b))
-}
-
-/// Perform `left == right` operation on [`BooleanArray`] and a scalar
-pub fn eq_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray> {
-    let len = left.len();
-    let left_offset = left.offset();
-
-    let values = if right {
-        left.values().bit_slice(left_offset, len)
-    } else {
-        buffer_unary_not(left.values(), left.offset(), left.len())
-    };
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            len,
-            None,
-            left.data_ref()
-                .null_bitmap()
-                .as_ref()
-                .map(|b| b.bits.bit_slice(left_offset, len)),
-            0,
-            vec![values],
-            vec![],
-        )
-    };
-
-    Ok(BooleanArray::from(data))
-}
-
-/// Perform `left < right` operation on [`BooleanArray`] and a scalar
-pub fn lt_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a: bool| !a & right)
-}
-
-/// Perform `left <= right` operation on [`BooleanArray`] and a scalar
-pub fn lt_eq_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a <= right)
-}
-
-/// Perform `left > right` operation on [`BooleanArray`] and a scalar
-pub fn gt_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a: bool| a & !right)
-}
-
-/// Perform `left >= right` operation on [`BooleanArray`] and a scalar
-pub fn gt_eq_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a >= right)
-}
-
-/// Perform `left != right` operation on [`BooleanArray`] and a scalar
-pub fn neq_bool_scalar(left: &BooleanArray, right: bool) -> Result<BooleanArray> {
-    eq_bool_scalar(left, !right)
-}
-
-/// Perform `left == right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
-pub fn eq_binary<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &GenericBinaryArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a == b)
-}
-
-/// Perform `left == right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar
-pub fn eq_binary_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &[u8],
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a == right)
-}
-
-/// Perform `left != right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
-pub fn neq_binary<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &GenericBinaryArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a != b)
-}
-
-/// Perform `left != right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar.
-pub fn neq_binary_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &[u8],
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a != right)
-}
-
-/// Perform `left < right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
-pub fn lt_binary<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &GenericBinaryArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a < b)
-}
-
-/// Perform `left < right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar.
-pub fn lt_binary_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &[u8],
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a < right)
-}
-
-/// Perform `left <= right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
-pub fn lt_eq_binary<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &GenericBinaryArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a <= b)
-}
-
-/// Perform `left <= right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar.
-pub fn lt_eq_binary_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &[u8],
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a <= right)
-}
-
-/// Perform `left > right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
-pub fn gt_binary<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &GenericBinaryArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a > b)
-}
-
-/// Perform `left > right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar.
-pub fn gt_binary_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &[u8],
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a > right)
-}
-
-/// Perform `left >= right` operation on [`BinaryArray`] / [`LargeBinaryArray`].
-pub fn gt_eq_binary<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &GenericBinaryArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a >= b)
-}
-
-/// Perform `left >= right` operation on [`BinaryArray`] / [`LargeBinaryArray`] and a scalar.
-pub fn gt_eq_binary_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericBinaryArray<OffsetSize>,
-    right: &[u8],
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a >= right)
-}
-
-/// Perform `left != right` operation on [`StringArray`] / [`LargeStringArray`].
-pub fn neq_utf8<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a != b)
-}
-
-/// Perform `left != right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
-pub fn neq_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &str,
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a != right)
-}
-
-/// Perform `left < right` operation on [`StringArray`] / [`LargeStringArray`].
-pub fn lt_utf8<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a < b)
-}
-
-/// Perform `left < right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
-pub fn lt_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &str,
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a < right)
-}
-
-/// Perform `left <= right` operation on [`StringArray`] / [`LargeStringArray`].
-pub fn lt_eq_utf8<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a <= b)
-}
-
-/// Perform `left <= right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
-pub fn lt_eq_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &str,
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a <= right)
-}
-
-/// Perform `left > right` operation on [`StringArray`] / [`LargeStringArray`].
-pub fn gt_utf8<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a > b)
-}
-
-/// Perform `left > right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
-pub fn gt_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &str,
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a > right)
-}
-
-/// Perform `left >= right` operation on [`StringArray`] / [`LargeStringArray`].
-pub fn gt_eq_utf8<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &GenericStringArray<OffsetSize>,
-) -> Result<BooleanArray> {
-    compare_op(left, right, |a, b| a >= b)
-}
-
-/// Perform `left >= right` operation on [`StringArray`] / [`LargeStringArray`] and a scalar.
-pub fn gt_eq_utf8_scalar<OffsetSize: OffsetSizeTrait>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &str,
-) -> Result<BooleanArray> {
-    compare_op_scalar(left, |a| a >= right)
-}
-
-// Avoids creating a closure for each combination of `$RIGHT` and `$TY`
-fn try_to_type_result<T>(value: Option<T>, right: &str, ty: &str) -> Result<T> {
-    value.ok_or_else(|| {
-        ArrowError::ComputeError(format!("Could not convert {} with {}", right, ty,))
-    })
-}
-
-/// Calls $RIGHT.$TY() (e.g. `right.to_i128()`) with a nice error message.
-/// Type of expression is `Result<.., ArrowError>`
-macro_rules! try_to_type {
-    ($RIGHT: expr, $TY: ident) => {
-        try_to_type_result($RIGHT.$TY(), stringify!($RIGHT), stringify!($TYPE))
-    };
-}
-
-macro_rules! dyn_compare_scalar {
-    // Applies `LEFT OP RIGHT` when `LEFT` is a `PrimitiveArray`
-    ($LEFT: expr, $RIGHT: expr, $OP: ident) => {{
-        match $LEFT.data_type() {
-            DataType::Int8 => {
-                let right = try_to_type!($RIGHT, to_i8)?;
-                let left = as_primitive_array::<Int8Type>($LEFT);
-                $OP::<Int8Type>(left, right)
-            }
-            DataType::Int16 => {
-                let right = try_to_type!($RIGHT, to_i16)?;
-                let left = as_primitive_array::<Int16Type>($LEFT);
-                $OP::<Int16Type>(left, right)
-            }
-            DataType::Int32 => {
-                let right = try_to_type!($RIGHT, to_i32)?;
-                let left = as_primitive_array::<Int32Type>($LEFT);
-                $OP::<Int32Type>(left, right)
-            }
-            DataType::Int64 => {
-                let right = try_to_type!($RIGHT, to_i64)?;
-                let left = as_primitive_array::<Int64Type>($LEFT);
-                $OP::<Int64Type>(left, right)
-            }
-            DataType::UInt8 => {
-                let right = try_to_type!($RIGHT, to_u8)?;
-                let left = as_primitive_array::<UInt8Type>($LEFT);
-                $OP::<UInt8Type>(left, right)
-            }
-            DataType::UInt16 => {
-                let right = try_to_type!($RIGHT, to_u16)?;
-                let left = as_primitive_array::<UInt16Type>($LEFT);
-                $OP::<UInt16Type>(left, right)
-            }
-            DataType::UInt32 => {
-                let right = try_to_type!($RIGHT, to_u32)?;
-                let left = as_primitive_array::<UInt32Type>($LEFT);
-                $OP::<UInt32Type>(left, right)
-            }
-            DataType::UInt64 => {
-                let right = try_to_type!($RIGHT, to_u64)?;
-                let left = as_primitive_array::<UInt64Type>($LEFT);
-                $OP::<UInt64Type>(left, right)
-            }
-            DataType::Float32 => {
-                let right = try_to_type!($RIGHT, to_f32)?;
-                let left = as_primitive_array::<Float32Type>($LEFT);
-                $OP::<Float32Type>(left, right)
-            }
-            DataType::Float64 => {
-                let right = try_to_type!($RIGHT, to_f64)?;
-                let left = as_primitive_array::<Float64Type>($LEFT);
-                $OP::<Float64Type>(left, right)
-            }
-            _ => Err(ArrowError::ComputeError(format!(
-                "Unsupported data type {:?} for comparison {} with {:?}",
-                $LEFT.data_type(),
-                stringify!($OP),
-                $RIGHT
-            ))),
-        }
-    }};
-    // Applies `LEFT OP RIGHT` when `LEFT` is a `DictionaryArray` with keys of type `KT`
-    ($LEFT: expr, $RIGHT: expr, $KT: ident, $OP: ident) => {{
-        match $KT.as_ref() {
-            DataType::UInt8 => {
-                let left = as_dictionary_array::<UInt8Type>($LEFT);
-                unpack_dict_comparison(left, $OP(left.values(), $RIGHT)?)
-            }
-            DataType::UInt16 => {
-                let left = as_dictionary_array::<UInt16Type>($LEFT);
-                unpack_dict_comparison(left, $OP(left.values(), $RIGHT)?)
-            }
-            DataType::UInt32 => {
-                let left = as_dictionary_array::<UInt32Type>($LEFT);
-                unpack_dict_comparison(left, $OP(left.values(), $RIGHT)?)
-            }
-            DataType::UInt64 => {
-                let left = as_dictionary_array::<UInt64Type>($LEFT);
-                unpack_dict_comparison(left, $OP(left.values(), $RIGHT)?)
-            }
-            DataType::Int8 => {
-                let left = as_dictionary_array::<Int8Type>($LEFT);
-                unpack_dict_comparison(left, $OP(left.values(), $RIGHT)?)
-            }
-            DataType::Int16 => {
-                let left = as_dictionary_array::<Int16Type>($LEFT);
-                unpack_dict_comparison(left, $OP(left.values(), $RIGHT)?)
-            }
-            DataType::Int32 => {
-                let left = as_dictionary_array::<Int32Type>($LEFT);
-                unpack_dict_comparison(left, $OP(left.values(), $RIGHT)?)
-            }
-            DataType::Int64 => {
-                let left = as_dictionary_array::<Int64Type>($LEFT);
-                unpack_dict_comparison(left, $OP(left.values(), $RIGHT)?)
-            }
-            _ => Err(ArrowError::ComputeError(format!(
-                "Unsupported dictionary key type {:?}",
-                $KT.as_ref()
-            ))),
-        }
-    }};
-}
-
-macro_rules! dyn_compare_utf8_scalar {
-    ($LEFT: expr, $RIGHT: expr, $KT: ident, $OP: ident) => {{
-        match $KT.as_ref() {
-            DataType::UInt8 => {
-                let left = as_dictionary_array::<UInt8Type>($LEFT);
-                let values = as_string_array(left.values());
-                unpack_dict_comparison(left, $OP(values, $RIGHT)?)
-            }
-            DataType::UInt16 => {
-                let left = as_dictionary_array::<UInt16Type>($LEFT);
-                let values = as_string_array(left.values());
-                unpack_dict_comparison(left, $OP(values, $RIGHT)?)
-            }
-            DataType::UInt32 => {
-                let left = as_dictionary_array::<UInt32Type>($LEFT);
-                let values = as_string_array(left.values());
-                unpack_dict_comparison(left, $OP(values, $RIGHT)?)
-            }
-            DataType::UInt64 => {
-                let left = as_dictionary_array::<UInt64Type>($LEFT);
-                let values = as_string_array(left.values());
-                unpack_dict_comparison(left, $OP(values, $RIGHT)?)
-            }
-            DataType::Int8 => {
-                let left = as_dictionary_array::<Int8Type>($LEFT);
-                let values = as_string_array(left.values());
-                unpack_dict_comparison(left, $OP(values, $RIGHT)?)
-            }
-            DataType::Int16 => {
-                let left = as_dictionary_array::<Int16Type>($LEFT);
-                let values = as_string_array(left.values());
-                unpack_dict_comparison(left, $OP(values, $RIGHT)?)
-            }
-            DataType::Int32 => {
-                let left = as_dictionary_array::<Int32Type>($LEFT);
-                let values = as_string_array(left.values());
-                unpack_dict_comparison(left, $OP(values, $RIGHT)?)
-            }
-            DataType::Int64 => {
-                let left = as_dictionary_array::<Int64Type>($LEFT);
-                let values = as_string_array(left.values());
-                unpack_dict_comparison(left, $OP(values, $RIGHT)?)
-            }
-            _ => Err(ArrowError::ComputeError(String::from("Unknown key type"))),
-        }
-    }};
-}
-
-/// Perform `left == right` operation on an array and a numeric scalar
-/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values
-pub fn eq_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray>
-where
-    T: num::ToPrimitive + std::fmt::Debug,
-{
-    match left.data_type() {
-        DataType::Dictionary(key_type, _value_type) => {
-            dyn_compare_scalar!(left, right, key_type, eq_dyn_scalar)
-        }
-        _ => dyn_compare_scalar!(left, right, eq_scalar),
-    }
-}
-
-/// Perform `left < right` operation on an array and a numeric scalar
-/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values
-pub fn lt_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray>
-where
-    T: num::ToPrimitive + std::fmt::Debug,
-{
-    match left.data_type() {
-        DataType::Dictionary(key_type, _value_type) => {
-            dyn_compare_scalar!(left, right, key_type, lt_dyn_scalar)
-        }
-        _ => dyn_compare_scalar!(left, right, lt_scalar),
-    }
-}
-
-/// Perform `left <= right` operation on an array and a numeric scalar
-/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values
-pub fn lt_eq_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray>
-where
-    T: num::ToPrimitive + std::fmt::Debug,
-{
-    match left.data_type() {
-        DataType::Dictionary(key_type, _value_type) => {
-            dyn_compare_scalar!(left, right, key_type, lt_eq_dyn_scalar)
-        }
-        _ => dyn_compare_scalar!(left, right, lt_eq_scalar),
-    }
-}
-
-/// Perform `left > right` operation on an array and a numeric scalar
-/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values
-pub fn gt_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray>
-where
-    T: num::ToPrimitive + std::fmt::Debug,
-{
-    match left.data_type() {
-        DataType::Dictionary(key_type, _value_type) => {
-            dyn_compare_scalar!(left, right, key_type, gt_dyn_scalar)
-        }
-        _ => dyn_compare_scalar!(left, right, gt_scalar),
-    }
-}
-
-/// Perform `left >= right` operation on an array and a numeric scalar
-/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values
-pub fn gt_eq_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray>
-where
-    T: num::ToPrimitive + std::fmt::Debug,
-{
-    match left.data_type() {
-        DataType::Dictionary(key_type, _value_type) => {
-            dyn_compare_scalar!(left, right, key_type, gt_eq_dyn_scalar)
-        }
-        _ => dyn_compare_scalar!(left, right, gt_eq_scalar),
-    }
-}
-
-/// Perform `left != right` operation on an array and a numeric scalar
-/// value. Supports PrimitiveArrays, and DictionaryArrays that have primitive values
-pub fn neq_dyn_scalar<T>(left: &dyn Array, right: T) -> Result<BooleanArray>
-where
-    T: num::ToPrimitive + std::fmt::Debug,
-{
-    match left.data_type() {
-        DataType::Dictionary(key_type, _value_type) => {
-            dyn_compare_scalar!(left, right, key_type, neq_dyn_scalar)
-        }
-        _ => dyn_compare_scalar!(left, right, neq_scalar),
-    }
-}
-
-/// Perform `left == right` operation on an array and a numeric scalar
-/// value. Supports BinaryArray and LargeBinaryArray
-pub fn eq_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Binary => {
-            let left = as_generic_binary_array::<i32>(left);
-            eq_binary_scalar(left, right)
-        }
-        DataType::LargeBinary => {
-            let left = as_generic_binary_array::<i64>(left);
-            eq_binary_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "eq_dyn_binary_scalar only supports Binary or LargeBinary arrays".to_string(),
-        )),
-    }
-}
-
-/// Perform `left != right` operation on an array and a numeric scalar
-/// value. Supports BinaryArray and LargeBinaryArray
-pub fn neq_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Binary => {
-            let left = as_generic_binary_array::<i32>(left);
-            neq_binary_scalar(left, right)
-        }
-        DataType::LargeBinary => {
-            let left = as_generic_binary_array::<i64>(left);
-            neq_binary_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "neq_dyn_binary_scalar only supports Binary or LargeBinary arrays"
-                .to_string(),
-        )),
-    }
-}
-
-/// Perform `left < right` operation on an array and a numeric scalar
-/// value. Supports BinaryArray and LargeBinaryArray
-pub fn lt_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Binary => {
-            let left = as_generic_binary_array::<i32>(left);
-            lt_binary_scalar(left, right)
-        }
-        DataType::LargeBinary => {
-            let left = as_generic_binary_array::<i64>(left);
-            lt_binary_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "lt_dyn_binary_scalar only supports Binary or LargeBinary arrays".to_string(),
-        )),
-    }
-}
-
-/// Perform `left <= right` operation on an array and a numeric scalar
-/// value. Supports BinaryArray and LargeBinaryArray
-pub fn lt_eq_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Binary => {
-            let left = as_generic_binary_array::<i32>(left);
-            lt_eq_binary_scalar(left, right)
-        }
-        DataType::LargeBinary => {
-            let left = as_generic_binary_array::<i64>(left);
-            lt_eq_binary_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "lt_eq_dyn_binary_scalar only supports Binary or LargeBinary arrays"
-                .to_string(),
-        )),
-    }
-}
-
-/// Perform `left > right` operation on an array and a numeric scalar
-/// value. Supports BinaryArray and LargeBinaryArray
-pub fn gt_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Binary => {
-            let left = as_generic_binary_array::<i32>(left);
-            gt_binary_scalar(left, right)
-        }
-        DataType::LargeBinary => {
-            let left = as_generic_binary_array::<i64>(left);
-            gt_binary_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "gt_dyn_binary_scalar only supports Binary or LargeBinary arrays".to_string(),
-        )),
-    }
-}
-
-/// Perform `left >= right` operation on an array and a numeric scalar
-/// value. Supports BinaryArray and LargeBinaryArray
-pub fn gt_eq_dyn_binary_scalar(left: &dyn Array, right: &[u8]) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Binary => {
-            let left = as_generic_binary_array::<i32>(left);
-            gt_eq_binary_scalar(left, right)
-        }
-        DataType::LargeBinary => {
-            let left = as_generic_binary_array::<i64>(left);
-            gt_eq_binary_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "gt_eq_dyn_binary_scalar only supports Binary or LargeBinary arrays"
-                .to_string(),
-        )),
-    }
-}
-
-/// Perform `left == right` operation on an array and a numeric scalar
-/// value. Supports StringArrays, and DictionaryArrays that have string values
-pub fn eq_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Dictionary(key_type, value_type) => match value_type.as_ref() {
-            DataType::Utf8 | DataType::LargeUtf8 => {
-                dyn_compare_utf8_scalar!(left, right, key_type, eq_utf8_scalar)
-            }
-            _ => Err(ArrowError::ComputeError(
-                "eq_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays or DictionaryArray with Utf8 or LargeUtf8 values".to_string(),
-            )),
-        },
-        DataType::Utf8 => {
-            let left = as_string_array(left);
-            eq_utf8_scalar(left, right)
-        }
-        DataType::LargeUtf8 => {
-            let left = as_largestring_array(left);
-            eq_utf8_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "eq_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left < right` operation on an array and a numeric scalar
-/// value. Supports StringArrays, and DictionaryArrays that have string values
-pub fn lt_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Dictionary(key_type, value_type) => match value_type.as_ref() {
-            DataType::Utf8 | DataType::LargeUtf8 => {
-                dyn_compare_utf8_scalar!(left, right, key_type, lt_utf8_scalar)
-            }
-            _ => Err(ArrowError::ComputeError(
-                "lt_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays or DictionaryArray with Utf8 or LargeUtf8 values".to_string(),
-            )),
-        },
-        DataType::Utf8 => {
-            let left = as_string_array(left);
-            lt_utf8_scalar(left, right)
-        }
-        DataType::LargeUtf8 => {
-            let left = as_largestring_array(left);
-            lt_utf8_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "lt_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left >= right` operation on an array and a numeric scalar
-/// value. Supports StringArrays, and DictionaryArrays that have string values
-pub fn gt_eq_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Dictionary(key_type, value_type) => match value_type.as_ref() {
-            DataType::Utf8 | DataType::LargeUtf8 => {
-                dyn_compare_utf8_scalar!(left, right, key_type, gt_eq_utf8_scalar)
-            }
-            _ => Err(ArrowError::ComputeError(
-                "gt_eq_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays or DictionaryArray with Utf8 or LargeUtf8 values".to_string(),
-            )),
-        },
-        DataType::Utf8 => {
-            let left = as_string_array(left);
-            gt_eq_utf8_scalar(left, right)
-        }
-        DataType::LargeUtf8 => {
-            let left = as_largestring_array(left);
-            gt_eq_utf8_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "gt_eq_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left <= right` operation on an array and a numeric scalar
-/// value. Supports StringArrays, and DictionaryArrays that have string values
-pub fn lt_eq_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Dictionary(key_type, value_type) => match value_type.as_ref() {
-            DataType::Utf8 | DataType::LargeUtf8 => {
-                dyn_compare_utf8_scalar!(left, right, key_type, lt_eq_utf8_scalar)
-            }
-            _ => Err(ArrowError::ComputeError(
-                "lt_eq_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays or DictionaryArray with Utf8 or LargeUtf8 values".to_string(),
-            )),
-        },
-        DataType::Utf8 => {
-            let left = as_string_array(left);
-            lt_eq_utf8_scalar(left, right)
-        }
-        DataType::LargeUtf8 => {
-            let left = as_largestring_array(left);
-            lt_eq_utf8_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "lt_eq_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left > right` operation on an array and a numeric scalar
-/// value. Supports StringArrays, and DictionaryArrays that have string values
-pub fn gt_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Dictionary(key_type, value_type) => match value_type.as_ref() {
-            DataType::Utf8 | DataType::LargeUtf8 => {
-                dyn_compare_utf8_scalar!(left, right, key_type, gt_utf8_scalar)
-            }
-            _ => Err(ArrowError::ComputeError(
-                "gt_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays or DictionaryArray with Utf8 or LargeUtf8 values".to_string(),
-            )),
-        },
-        DataType::Utf8 => {
-            let left = as_string_array(left);
-            gt_utf8_scalar(left, right)
-        }
-        DataType::LargeUtf8 => {
-            let left = as_largestring_array(left);
-            gt_utf8_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "gt_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left != right` operation on an array and a numeric scalar
-/// value. Supports StringArrays, and DictionaryArrays that have string values
-pub fn neq_dyn_utf8_scalar(left: &dyn Array, right: &str) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Dictionary(key_type, value_type) => match value_type.as_ref() {
-            DataType::Utf8 | DataType::LargeUtf8 => {
-                dyn_compare_utf8_scalar!(left, right, key_type, neq_utf8_scalar)
-            }
-            _ => Err(ArrowError::ComputeError(
-                "neq_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays or DictionaryArray with Utf8 or LargeUtf8 values".to_string(),
-            )),
-        },
-        DataType::Utf8 => {
-            let left = as_string_array(left);
-            neq_utf8_scalar(left, right)
-        }
-        DataType::LargeUtf8 => {
-            let left = as_largestring_array(left);
-            neq_utf8_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "neq_dyn_utf8_scalar only supports Utf8 or LargeUtf8 arrays".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left == right` operation on an array and a numeric scalar
-/// value.
-pub fn eq_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Boolean => {
-            let left = as_boolean_array(left);
-            eq_bool_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "eq_dyn_bool_scalar only supports BooleanArray".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left < right` operation on an array and a numeric scalar
-/// value. Supports BooleanArrays.
-pub fn lt_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Boolean => {
-            let left = as_boolean_array(left);
-            lt_bool_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "lt_dyn_bool_scalar only supports BooleanArray".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left > right` operation on an array and a numeric scalar
-/// value. Supports BooleanArrays.
-pub fn gt_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Boolean => {
-            let left = as_boolean_array(left);
-            gt_bool_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "gt_dyn_bool_scalar only supports BooleanArray".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left <= right` operation on an array and a numeric scalar
-/// value. Supports BooleanArrays.
-pub fn lt_eq_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Boolean => {
-            let left = as_boolean_array(left);
-            lt_eq_bool_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "lt_eq_dyn_bool_scalar only supports BooleanArray".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left >= right` operation on an array and a numeric scalar
-/// value. Supports BooleanArrays.
-pub fn gt_eq_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Boolean => {
-            let left = as_boolean_array(left);
-            gt_eq_bool_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "gt_eq_dyn_bool_scalar only supports BooleanArray".to_string(),
-        )),
-    };
-    result
-}
-
-/// Perform `left != right` operation on an array and a numeric scalar
-/// value. Supports BooleanArrays.
-pub fn neq_dyn_bool_scalar(left: &dyn Array, right: bool) -> Result<BooleanArray> {
-    let result = match left.data_type() {
-        DataType::Boolean => {
-            let left = as_boolean_array(left);
-            neq_bool_scalar(left, right)
-        }
-        _ => Err(ArrowError::ComputeError(
-            "neq_dyn_bool_scalar only supports BooleanArray".to_string(),
-        )),
-    };
-    result
-}
-
-/// unpacks the results of comparing left.values (as a boolean)
-///
-/// TODO add example
-///
-fn unpack_dict_comparison<K>(
-    dict: &DictionaryArray<K>,
-    dict_comparison: BooleanArray,
-) -> Result<BooleanArray>
-where
-    K: ArrowNumericType,
-{
-    assert_eq!(dict_comparison.len(), dict.values().len());
-
-    let result: BooleanArray = dict
-        .keys()
-        .iter()
-        .map(|key| {
-            key.map(|key| unsafe {
-                // safety lengths were verified above
-                let key = key.to_usize().expect("Dictionary index not usize");
-                dict_comparison.value_unchecked(key)
-            })
-        })
-        .collect();
-
-    Ok(result)
-}
-
-/// Helper function to perform boolean lambda function on values from two arrays using
-/// SIMD.
-#[cfg(feature = "simd")]
-fn simd_compare_op<T, SI, SC>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-    simd_op: SI,
-    scalar_op: SC,
-) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-    SI: Fn(T::Simd, T::Simd) -> T::SimdMask,
-    SC: Fn(T::Native, T::Native) -> bool,
-{
-    use std::borrow::BorrowMut;
-
-    let len = left.len();
-    if len != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform comparison operation on arrays of different length"
-                .to_string(),
-        ));
-    }
-
-    let null_bit_buffer =
-        combine_option_bitmap(&[left.data_ref(), right.data_ref()], len)?;
-
-    // we process the data in chunks so that each iteration results in one u64 of comparison result bits
-    const CHUNK_SIZE: usize = 64;
-    let lanes = T::lanes();
-
-    // this is currently the case for all our datatypes and allows us to always append full bytes
-    assert!(
-        lanes <= CHUNK_SIZE,
-        "Number of vector lanes must be at most 64"
-    );
-
-    let buffer_size = bit_util::ceil(len, 8);
-    let mut result = MutableBuffer::new(buffer_size).with_bitset(buffer_size, false);
-
-    let mut left_chunks = left.values().chunks_exact(CHUNK_SIZE);
-    let mut right_chunks = right.values().chunks_exact(CHUNK_SIZE);
-
-    // safety: result is newly created above, always written as a T below
-    let result_chunks = unsafe { result.typed_data_mut() };
-    let result_remainder = left_chunks
-        .borrow_mut()
-        .zip(right_chunks.borrow_mut())
-        .fold(result_chunks, |result_slice, (left_slice, right_slice)| {
-            let mut i = 0;
-            let mut bitmask = 0_u64;
-            while i < CHUNK_SIZE {
-                let simd_left = T::load(&left_slice[i..]);
-                let simd_right = T::load(&right_slice[i..]);
-                let simd_result = simd_op(simd_left, simd_right);
-
-                let m = T::mask_to_u64(&simd_result);
-                bitmask |= m << i;
-
-                i += lanes;
-            }
-            let bytes = bitmask.to_le_bytes();
-            result_slice[0..8].copy_from_slice(&bytes);
-
-            &mut result_slice[8..]
-        });
-
-    let left_remainder = left_chunks.remainder();
-    let right_remainder = right_chunks.remainder();
-
-    assert_eq!(left_remainder.len(), right_remainder.len());
-
-    if !left_remainder.is_empty() {
-        let remainder_bitmask = left_remainder
-            .iter()
-            .zip(right_remainder.iter())
-            .enumerate()
-            .fold(0_u64, |mut mask, (i, (scalar_left, scalar_right))| {
-                let bit = scalar_op(*scalar_left, *scalar_right) as u64;
-                mask |= bit << i;
-                mask
-            });
-        let remainder_mask_as_bytes =
-            &remainder_bitmask.to_le_bytes()[0..bit_util::ceil(left_remainder.len(), 8)];
-        result_remainder.copy_from_slice(remainder_mask_as_bytes);
-    }
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            len,
-            None,
-            null_bit_buffer,
-            0,
-            vec![result.into()],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Helper function to perform boolean lambda function on values from an array and a scalar value using
-/// SIMD.
-#[cfg(feature = "simd")]
-fn simd_compare_op_scalar<T, SI, SC>(
-    left: &PrimitiveArray<T>,
-    right: T::Native,
-    simd_op: SI,
-    scalar_op: SC,
-) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-    SI: Fn(T::Simd, T::Simd) -> T::SimdMask,
-    SC: Fn(T::Native, T::Native) -> bool,
-{
-    use std::borrow::BorrowMut;
-
-    let len = left.len();
-
-    // we process the data in chunks so that each iteration results in one u64 of comparison result bits
-    const CHUNK_SIZE: usize = 64;
-    let lanes = T::lanes();
-
-    // this is currently the case for all our datatypes and allows us to always append full bytes
-    assert!(
-        lanes <= CHUNK_SIZE,
-        "Number of vector lanes must be at most 64"
-    );
-
-    let buffer_size = bit_util::ceil(len, 8);
-    let mut result = MutableBuffer::new(buffer_size).with_bitset(buffer_size, false);
-
-    let mut left_chunks = left.values().chunks_exact(CHUNK_SIZE);
-    let simd_right = T::init(right);
-
-    // safety: result is newly created above, always written as a T below
-    let result_chunks = unsafe { result.typed_data_mut() };
-    let result_remainder =
-        left_chunks
-            .borrow_mut()
-            .fold(result_chunks, |result_slice, left_slice| {
-                let mut i = 0;
-                let mut bitmask = 0_u64;
-                while i < CHUNK_SIZE {
-                    let simd_left = T::load(&left_slice[i..]);
-                    let simd_result = simd_op(simd_left, simd_right);
-
-                    let m = T::mask_to_u64(&simd_result);
-                    bitmask |= m << i;
-
-                    i += lanes;
-                }
-                let bytes = bitmask.to_le_bytes();
-                result_slice[0..8].copy_from_slice(&bytes);
-
-                &mut result_slice[8..]
-            });
-
-    let left_remainder = left_chunks.remainder();
-
-    if !left_remainder.is_empty() {
-        let remainder_bitmask = left_remainder.iter().enumerate().fold(
-            0_u64,
-            |mut mask, (i, scalar_left)| {
-                let bit = scalar_op(*scalar_left, right) as u64;
-                mask |= bit << i;
-                mask
-            },
-        );
-        let remainder_mask_as_bytes =
-            &remainder_bitmask.to_le_bytes()[0..bit_util::ceil(left_remainder.len(), 8)];
-        result_remainder.copy_from_slice(remainder_mask_as_bytes);
-    }
-
-    let null_bit_buffer = left
-        .data_ref()
-        .null_buffer()
-        .map(|b| b.bit_slice(left.offset(), left.len()));
-
-    // null count is the same as in the input since the right side of the scalar comparison cannot be null
-    let null_count = left.null_count();
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            len,
-            Some(null_count),
-            null_bit_buffer,
-            0,
-            vec![result.into()],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-fn cmp_primitive_array<T: ArrowNumericType, F>(
-    left: &dyn Array,
-    right: &dyn Array,
-    op: F,
-) -> Result<BooleanArray>
-where
-    F: Fn(T::Native, T::Native) -> bool,
-{
-    let left_array = as_primitive_array::<T>(left);
-    let right_array = as_primitive_array::<T>(right);
-    compare_op(left_array, right_array, op)
-}
-
-macro_rules! typed_compares {
-    ($LEFT: expr, $RIGHT: expr, $OP_BOOL: expr, $OP: expr) => {{
-        match ($LEFT.data_type(), $RIGHT.data_type()) {
-            (DataType::Boolean, DataType::Boolean) => {
-                compare_op(as_boolean_array($LEFT), as_boolean_array($RIGHT), $OP_BOOL)
-            }
-            (DataType::Int8, DataType::Int8) => {
-                cmp_primitive_array::<Int8Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Int16, DataType::Int16) => {
-                cmp_primitive_array::<Int16Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Int32, DataType::Int32) => {
-                cmp_primitive_array::<Int32Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Int64, DataType::Int64) => {
-                cmp_primitive_array::<Int64Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::UInt8, DataType::UInt8) => {
-                cmp_primitive_array::<UInt8Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::UInt16, DataType::UInt16) => {
-                cmp_primitive_array::<UInt16Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::UInt32, DataType::UInt32) => {
-                cmp_primitive_array::<UInt32Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::UInt64, DataType::UInt64) => {
-                cmp_primitive_array::<UInt64Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Float32, DataType::Float32) => {
-                cmp_primitive_array::<Float32Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Float64, DataType::Float64) => {
-                cmp_primitive_array::<Float64Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Utf8, DataType::Utf8) => {
-                compare_op(as_string_array($LEFT), as_string_array($RIGHT), $OP)
-            }
-            (DataType::LargeUtf8, DataType::LargeUtf8) => compare_op(
-                as_largestring_array($LEFT),
-                as_largestring_array($RIGHT),
-                $OP,
-            ),
-            (DataType::Binary, DataType::Binary) => compare_op(
-                as_generic_binary_array::<i32>($LEFT),
-                as_generic_binary_array::<i32>($RIGHT),
-                $OP,
-            ),
-            (DataType::LargeBinary, DataType::LargeBinary) => compare_op(
-                as_generic_binary_array::<i64>($LEFT),
-                as_generic_binary_array::<i64>($RIGHT),
-                $OP,
-            ),
-            (
-                DataType::Timestamp(TimeUnit::Nanosecond, _),
-                DataType::Timestamp(TimeUnit::Nanosecond, _),
-            ) => cmp_primitive_array::<TimestampNanosecondType, _>($LEFT, $RIGHT, $OP),
-            (
-                DataType::Timestamp(TimeUnit::Microsecond, _),
-                DataType::Timestamp(TimeUnit::Microsecond, _),
-            ) => cmp_primitive_array::<TimestampMicrosecondType, _>($LEFT, $RIGHT, $OP),
-            (
-                DataType::Timestamp(TimeUnit::Millisecond, _),
-                DataType::Timestamp(TimeUnit::Millisecond, _),
-            ) => cmp_primitive_array::<TimestampMillisecondType, _>($LEFT, $RIGHT, $OP),
-            (
-                DataType::Timestamp(TimeUnit::Second, _),
-                DataType::Timestamp(TimeUnit::Second, _),
-            ) => cmp_primitive_array::<TimestampSecondType, _>($LEFT, $RIGHT, $OP),
-            (DataType::Date32, DataType::Date32) => {
-                cmp_primitive_array::<Date32Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Date64, DataType::Date64) => {
-                cmp_primitive_array::<Date64Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (
-                DataType::Interval(IntervalUnit::YearMonth),
-                DataType::Interval(IntervalUnit::YearMonth),
-            ) => cmp_primitive_array::<IntervalYearMonthType, _>($LEFT, $RIGHT, $OP),
-            (
-                DataType::Interval(IntervalUnit::DayTime),
-                DataType::Interval(IntervalUnit::DayTime),
-            ) => cmp_primitive_array::<IntervalDayTimeType, _>($LEFT, $RIGHT, $OP),
-            (
-                DataType::Interval(IntervalUnit::MonthDayNano),
-                DataType::Interval(IntervalUnit::MonthDayNano),
-            ) => cmp_primitive_array::<IntervalMonthDayNanoType, _>($LEFT, $RIGHT, $OP),
-            (t1, t2) if t1 == t2 => Err(ArrowError::NotYetImplemented(format!(
-                "Comparing arrays of type {} is not yet implemented",
-                t1
-            ))),
-            (t1, t2) => Err(ArrowError::CastError(format!(
-                "Cannot compare two arrays of different types ({} and {})",
-                t1, t2
-            ))),
-        }
-    }};
-}
-
-/// Applies $OP to $LEFT and $RIGHT which are two dictionaries which have (the same) key type $KT
-macro_rules! typed_dict_cmp {
-    ($LEFT: expr, $RIGHT: expr, $OP: expr, $OP_BOOL: expr, $KT: tt) => {{
-        match ($LEFT.value_type(), $RIGHT.value_type()) {
-            (DataType::Boolean, DataType::Boolean) => {
-                cmp_dict_bool::<$KT, _>($LEFT, $RIGHT, $OP_BOOL)
-            }
-            (DataType::Int8, DataType::Int8) => {
-                cmp_dict::<$KT, Int8Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Int16, DataType::Int16) => {
-                cmp_dict::<$KT, Int16Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Int32, DataType::Int32) => {
-                cmp_dict::<$KT, Int32Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Int64, DataType::Int64) => {
-                cmp_dict::<$KT, Int64Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::UInt8, DataType::UInt8) => {
-                cmp_dict::<$KT, UInt8Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::UInt16, DataType::UInt16) => {
-                cmp_dict::<$KT, UInt16Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::UInt32, DataType::UInt32) => {
-                cmp_dict::<$KT, UInt32Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::UInt64, DataType::UInt64) => {
-                cmp_dict::<$KT, UInt64Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Float32, DataType::Float32) => {
-                cmp_dict::<$KT, Float32Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Float64, DataType::Float64) => {
-                cmp_dict::<$KT, Float64Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Utf8, DataType::Utf8) => {
-                cmp_dict_utf8::<$KT, i32, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::LargeUtf8, DataType::LargeUtf8) => {
-                cmp_dict_utf8::<$KT, i64, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Binary, DataType::Binary) => {
-               cmp_dict_binary::<$KT, i32, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::LargeBinary, DataType::LargeBinary) => {
-                cmp_dict_binary::<$KT, i64, _>($LEFT, $RIGHT, $OP)
-            }
-            (
-                DataType::Timestamp(TimeUnit::Nanosecond, _),
-                DataType::Timestamp(TimeUnit::Nanosecond, _),
-            ) => {
-                cmp_dict::<$KT, TimestampNanosecondType, _>($LEFT, $RIGHT, $OP)
-            }
-            (
-                DataType::Timestamp(TimeUnit::Microsecond, _),
-                DataType::Timestamp(TimeUnit::Microsecond, _),
-            ) => {
-                cmp_dict::<$KT, TimestampMicrosecondType, _>($LEFT, $RIGHT, $OP)
-            }
-            (
-                DataType::Timestamp(TimeUnit::Millisecond, _),
-                DataType::Timestamp(TimeUnit::Millisecond, _),
-            ) => {
-                cmp_dict::<$KT, TimestampMillisecondType, _>($LEFT, $RIGHT, $OP)
-            }
-            (
-                DataType::Timestamp(TimeUnit::Second, _),
-                DataType::Timestamp(TimeUnit::Second, _),
-            ) => {
-                cmp_dict::<$KT, TimestampSecondType, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Date32, DataType::Date32) => {
-                cmp_dict::<$KT, Date32Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (DataType::Date64, DataType::Date64) => {
-                cmp_dict::<$KT, Date64Type, _>($LEFT, $RIGHT, $OP)
-            }
-            (
-                DataType::Interval(IntervalUnit::YearMonth),
-                DataType::Interval(IntervalUnit::YearMonth),
-            ) => {
-                cmp_dict::<$KT, IntervalYearMonthType, _>($LEFT, $RIGHT, $OP)
-            }
-            (
-                DataType::Interval(IntervalUnit::DayTime),
-                DataType::Interval(IntervalUnit::DayTime),
-            ) => {
-                cmp_dict::<$KT, IntervalDayTimeType, _>($LEFT, $RIGHT, $OP)
-            }
-            (
-                DataType::Interval(IntervalUnit::MonthDayNano),
-                DataType::Interval(IntervalUnit::MonthDayNano),
-            ) => {
-                cmp_dict::<$KT, IntervalMonthDayNanoType, _>($LEFT, $RIGHT, $OP)
-            }
-            (t1, t2) if t1 == t2 => Err(ArrowError::NotYetImplemented(format!(
-                "Comparing dictionary arrays of value type {} is not yet implemented",
-                t1
-            ))),
-            (t1, t2) => Err(ArrowError::CastError(format!(
-                "Cannot compare two dictionary arrays of different value types ({} and {})",
-                t1, t2
-            ))),
-        }
-    }};
-}
-
-macro_rules! typed_dict_compares {
-   // Applies `LEFT OP RIGHT` when `LEFT` and `RIGHT` both are `DictionaryArray`
-    ($LEFT: expr, $RIGHT: expr, $OP: expr, $OP_BOOL: expr) => {{
-        match ($LEFT.data_type(), $RIGHT.data_type()) {
-            (DataType::Dictionary(left_key_type, _), DataType::Dictionary(right_key_type, _))=> {
-                match (left_key_type.as_ref(), right_key_type.as_ref()) {
-                    (DataType::Int8, DataType::Int8) => {
-                        let left = as_dictionary_array::<Int8Type>($LEFT);
-                        let right = as_dictionary_array::<Int8Type>($RIGHT);
-                        typed_dict_cmp!(left, right, $OP, $OP_BOOL, Int8Type)
-                    }
-                    (DataType::Int16, DataType::Int16) => {
-                        let left = as_dictionary_array::<Int16Type>($LEFT);
-                        let right = as_dictionary_array::<Int16Type>($RIGHT);
-                        typed_dict_cmp!(left, right, $OP, $OP_BOOL, Int16Type)
-                    }
-                    (DataType::Int32, DataType::Int32) => {
-                        let left = as_dictionary_array::<Int32Type>($LEFT);
-                        let right = as_dictionary_array::<Int32Type>($RIGHT);
-                        typed_dict_cmp!(left, right, $OP, $OP_BOOL, Int32Type)
-                    }
-                    (DataType::Int64, DataType::Int64) => {
-                        let left = as_dictionary_array::<Int64Type>($LEFT);
-                        let right = as_dictionary_array::<Int64Type>($RIGHT);
-                        typed_dict_cmp!(left, right, $OP, $OP_BOOL, Int64Type)
-                    }
-                    (DataType::UInt8, DataType::UInt8) => {
-                        let left = as_dictionary_array::<UInt8Type>($LEFT);
-                        let right = as_dictionary_array::<UInt8Type>($RIGHT);
-                        typed_dict_cmp!(left, right, $OP, $OP_BOOL, UInt8Type)
-                    }
-                    (DataType::UInt16, DataType::UInt16) => {
-                        let left = as_dictionary_array::<UInt16Type>($LEFT);
-                        let right = as_dictionary_array::<UInt16Type>($RIGHT);
-                        typed_dict_cmp!(left, right, $OP, $OP_BOOL, UInt16Type)
-                    }
-                    (DataType::UInt32, DataType::UInt32) => {
-                        let left = as_dictionary_array::<UInt32Type>($LEFT);
-                        let right = as_dictionary_array::<UInt32Type>($RIGHT);
-                        typed_dict_cmp!(left, right, $OP, $OP_BOOL, UInt32Type)
-                    }
-                    (DataType::UInt64, DataType::UInt64) => {
-                        let left = as_dictionary_array::<UInt64Type>($LEFT);
-                        let right = as_dictionary_array::<UInt64Type>($RIGHT);
-                        typed_dict_cmp!(left, right, $OP, $OP_BOOL, UInt64Type)
-                    }
-                    (t1, t2) if t1 == t2 => Err(ArrowError::NotYetImplemented(format!(
-                        "Comparing dictionary arrays of type {} is not yet implemented",
-                        t1
-                    ))),
-                    (t1, t2) => Err(ArrowError::CastError(format!(
-                        "Cannot compare two dictionary arrays of different key types ({} and {})",
-                        t1, t2
-                    ))),
-                }
-            }
-            (t1, t2) => Err(ArrowError::CastError(format!(
-                "Cannot compare dictionary array with non-dictionary array ({} and {})",
-                t1, t2
-            ))),
-        }
-    }};
-}
-
-/// Helper function to perform boolean lambda function on values from two dictionary arrays, this
-/// version does not attempt to use SIMD explicitly (though the compiler may auto vectorize)
-macro_rules! compare_dict_op {
-    ($left: expr, $right:expr, $op:expr, $value_ty:ty) => {{
-        if $left.len() != $right.len() {
-            return Err(ArrowError::ComputeError(
-                "Cannot perform comparison operation on arrays of different length"
-                    .to_string(),
-            ));
-        }
-
-        // Safety justification: Since the inputs are valid Arrow arrays, all values are
-        // valid indexes into the dictionary (which is verified during construction)
-
-        let left_iter = unsafe {
-            $left
-                .values()
-                .as_any()
-                .downcast_ref::<$value_ty>()
-                .unwrap()
-                .take_iter_unchecked($left.keys_iter())
-        };
-
-        let right_iter = unsafe {
-            $right
-                .values()
-                .as_any()
-                .downcast_ref::<$value_ty>()
-                .unwrap()
-                .take_iter_unchecked($right.keys_iter())
-        };
-
-        let result = left_iter
-            .zip(right_iter)
-            .map(|(left_value, right_value)| {
-                if let (Some(left), Some(right)) = (left_value, right_value) {
-                    Some($op(left, right))
-                } else {
-                    None
-                }
-            })
-            .collect();
-
-        Ok(result)
-    }};
-}
-
-/// Perform given operation on two `DictionaryArray`s.
-/// Returns an error if the two arrays have different value type
-pub fn cmp_dict<K, T, F>(
-    left: &DictionaryArray<K>,
-    right: &DictionaryArray<K>,
-    op: F,
-) -> Result<BooleanArray>
-where
-    K: ArrowNumericType,
-    T: ArrowNumericType,
-    F: Fn(T::Native, T::Native) -> bool,
-{
-    compare_dict_op!(left, right, op, PrimitiveArray<T>)
-}
-
-/// Perform the given operation on two `DictionaryArray`s which value type is
-/// `DataType::Boolean`.
-pub fn cmp_dict_bool<K, F>(
-    left: &DictionaryArray<K>,
-    right: &DictionaryArray<K>,
-    op: F,
-) -> Result<BooleanArray>
-where
-    K: ArrowNumericType,
-    F: Fn(bool, bool) -> bool,
-{
-    compare_dict_op!(left, right, op, BooleanArray)
-}
-
-/// Perform the given operation on two `DictionaryArray`s which value type is
-/// `DataType::Utf8` or `DataType::LargeUtf8`.
-pub fn cmp_dict_utf8<K, OffsetSize: OffsetSizeTrait, F>(
-    left: &DictionaryArray<K>,
-    right: &DictionaryArray<K>,
-    op: F,
-) -> Result<BooleanArray>
-where
-    K: ArrowNumericType,
-    F: Fn(&str, &str) -> bool,
-{
-    compare_dict_op!(left, right, op, GenericStringArray<OffsetSize>)
-}
-
-/// Perform the given operation on two `DictionaryArray`s which value type is
-/// `DataType::Binary` or `DataType::LargeBinary`.
-pub fn cmp_dict_binary<K, OffsetSize: OffsetSizeTrait, F>(
-    left: &DictionaryArray<K>,
-    right: &DictionaryArray<K>,
-    op: F,
-) -> Result<BooleanArray>
-where
-    K: ArrowNumericType,
-    F: Fn(&[u8], &[u8]) -> bool,
-{
-    compare_dict_op!(left, right, op, GenericBinaryArray<OffsetSize>)
-}
-
-/// Perform `left == right` operation on two (dynamic) [`Array`]s.
-///
-/// Only when two arrays are of the same type the comparison will happen otherwise it will err
-/// with a casting error.
-///
-/// # Example
-/// ```
-/// use arrow::array::{StringArray, BooleanArray};
-/// use arrow::compute::eq_dyn;
-/// let array1 = StringArray::from(vec![Some("foo"), None, Some("bar")]);
-/// let array2 = StringArray::from(vec![Some("foo"), None, Some("baz")]);
-/// let result = eq_dyn(&array1, &array2).unwrap();
-/// assert_eq!(BooleanArray::from(vec![Some(true), None, Some(false)]), result);
-/// ```
-pub fn eq_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Dictionary(_, _) => {
-            typed_dict_compares!(left, right, |a, b| a == b, |a, b| a == b)
-        }
-        _ => typed_compares!(left, right, |a, b| !(a ^ b), |a, b| a == b),
-    }
-}
-
-/// Perform `left != right` operation on two (dynamic) [`Array`]s.
-///
-/// Only when two arrays are of the same type the comparison will happen otherwise it will err
-/// with a casting error.
-///
-/// # Example
-/// ```
-/// use arrow::array::{BinaryArray, BooleanArray};
-/// use arrow::compute::neq_dyn;
-/// let values1: Vec<Option<&[u8]>> = vec![Some(&[0xfc, 0xa9]), None, Some(&[0x36])];
-/// let values2: Vec<Option<&[u8]>> = vec![Some(&[0xfc, 0xa9]), None, Some(&[0x36, 0x00])];
-/// let array1 = BinaryArray::from(values1);
-/// let array2 = BinaryArray::from(values2);
-/// let result = neq_dyn(&array1, &array2).unwrap();
-/// assert_eq!(BooleanArray::from(vec![Some(false), None, Some(true)]), result);
-/// ```
-pub fn neq_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Dictionary(_, _) => {
-            typed_dict_compares!(left, right, |a, b| a != b, |a, b| a != b)
-        }
-        _ => typed_compares!(left, right, |a, b| (a ^ b), |a, b| a != b),
-    }
-}
-
-/// Perform `left < right` operation on two (dynamic) [`Array`]s.
-///
-/// Only when two arrays are of the same type the comparison will happen otherwise it will err
-/// with a casting error.
-///
-/// # Example
-/// ```
-/// use arrow::array::{PrimitiveArray, BooleanArray};
-/// use arrow::datatypes::Int32Type;
-/// use arrow::compute::lt_dyn;
-/// let array1: PrimitiveArray<Int32Type> = PrimitiveArray::from(vec![Some(0), Some(1), Some(2)]);
-/// let array2: PrimitiveArray<Int32Type> = PrimitiveArray::from(vec![Some(1), Some(1), None]);
-/// let result = lt_dyn(&array1, &array2).unwrap();
-/// assert_eq!(BooleanArray::from(vec![Some(true), Some(false), None]), result);
-/// ```
-#[allow(clippy::bool_comparison)]
-pub fn lt_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Dictionary(_, _) => {
-            typed_dict_compares!(left, right, |a, b| a < b, |a, b| a < b)
-        }
-        _ => typed_compares!(left, right, |a, b| ((!a) & b), |a, b| a < b),
-    }
-}
-
-/// Perform `left <= right` operation on two (dynamic) [`Array`]s.
-///
-/// Only when two arrays are of the same type the comparison will happen otherwise it will err
-/// with a casting error.
-///
-/// # Example
-/// ```
-/// use arrow::array::{PrimitiveArray, BooleanArray};
-/// use arrow::datatypes::Date32Type;
-/// use arrow::compute::lt_eq_dyn;
-/// let array1: PrimitiveArray<Date32Type> = vec![Some(12356), Some(13548), Some(-365), Some(365)].into();
-/// let array2: PrimitiveArray<Date32Type> = vec![Some(12355), Some(13548), Some(-364), None].into();
-/// let result = lt_eq_dyn(&array1, &array2).unwrap();
-/// assert_eq!(BooleanArray::from(vec![Some(false), Some(true), Some(true), None]), result);
-/// ```
-pub fn lt_eq_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Dictionary(_, _) => {
-            typed_dict_compares!(left, right, |a, b| a <= b, |a, b| a <= b)
-        }
-        _ => typed_compares!(left, right, |a, b| !(a & (!b)), |a, b| a <= b),
-    }
-}
-
-/// Perform `left > right` operation on two (dynamic) [`Array`]s.
-///
-/// Only when two arrays are of the same type the comparison will happen otherwise it will err
-/// with a casting error.
-///
-/// # Example
-/// ```
-/// use arrow::array::BooleanArray;
-/// use arrow::compute::gt_dyn;
-/// let array1 = BooleanArray::from(vec![Some(true), Some(false), None]);
-/// let array2 = BooleanArray::from(vec![Some(false), Some(true), None]);
-/// let result = gt_dyn(&array1, &array2).unwrap();
-/// assert_eq!(BooleanArray::from(vec![Some(true), Some(false), None]), result);
-/// ```
-#[allow(clippy::bool_comparison)]
-pub fn gt_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Dictionary(_, _) => {
-            typed_dict_compares!(left, right, |a, b| a > b, |a, b| a > b)
-        }
-        _ => typed_compares!(left, right, |a, b| (a & (!b)), |a, b| a > b),
-    }
-}
-
-/// Perform `left >= right` operation on two (dynamic) [`Array`]s.
-///
-/// Only when two arrays are of the same type the comparison will happen otherwise it will err
-/// with a casting error.
-///
-/// # Example
-/// ```
-/// use arrow::array::{BooleanArray, StringArray};
-/// use arrow::compute::gt_eq_dyn;
-/// let array1 = StringArray::from(vec![Some(""), Some("aaa"), None]);
-/// let array2 = StringArray::from(vec![Some(" "), Some("aa"), None]);
-/// let result = gt_eq_dyn(&array1, &array2).unwrap();
-/// assert_eq!(BooleanArray::from(vec![Some(false), Some(true), None]), result);
-/// ```
-pub fn gt_eq_dyn(left: &dyn Array, right: &dyn Array) -> Result<BooleanArray> {
-    match left.data_type() {
-        DataType::Dictionary(_, _) => {
-            typed_dict_compares!(left, right, |a, b| a >= b, |a, b| a >= b)
-        }
-        _ => typed_compares!(left, right, |a, b| !((!a) & b), |a, b| a >= b),
-    }
-}
-
-/// Perform `left == right` operation on two [`PrimitiveArray`]s.
-pub fn eq<T>(left: &PrimitiveArray<T>, right: &PrimitiveArray<T>) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op(left, right, T::eq, |a, b| a == b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op(left, right, |a, b| a == b);
-}
-
-/// Perform `left == right` operation on a [`PrimitiveArray`] and a scalar value.
-pub fn eq_scalar<T>(left: &PrimitiveArray<T>, right: T::Native) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op_scalar(left, right, T::eq, |a, b| a == b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op_scalar(left, |a| a == right);
-}
-
-/// Applies an unary and infallible comparison function to a primitive array.
-pub fn unary_cmp<T, F>(left: &PrimitiveArray<T>, op: F) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-    F: Fn(T::Native) -> bool,
-{
-    compare_op_scalar(left, op)
-}
-
-/// Perform `left != right` operation on two [`PrimitiveArray`]s.
-pub fn neq<T>(left: &PrimitiveArray<T>, right: &PrimitiveArray<T>) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op(left, right, T::ne, |a, b| a != b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op(left, right, |a, b| a != b);
-}
-
-/// Perform `left != right` operation on a [`PrimitiveArray`] and a scalar value.
-pub fn neq_scalar<T>(left: &PrimitiveArray<T>, right: T::Native) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op_scalar(left, right, T::ne, |a, b| a != b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op_scalar(left, |a| a != right);
-}
-
-/// Perform `left < right` operation on two [`PrimitiveArray`]s. Null values are less than non-null
-/// values.
-pub fn lt<T>(left: &PrimitiveArray<T>, right: &PrimitiveArray<T>) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op(left, right, T::lt, |a, b| a < b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op(left, right, |a, b| a < b);
-}
-
-/// Perform `left < right` operation on a [`PrimitiveArray`] and a scalar value.
-/// Null values are less than non-null values.
-pub fn lt_scalar<T>(left: &PrimitiveArray<T>, right: T::Native) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op_scalar(left, right, T::lt, |a, b| a < b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op_scalar(left, |a| a < right);
-}
-
-/// Perform `left <= right` operation on two [`PrimitiveArray`]s. Null values are less than non-null
-/// values.
-pub fn lt_eq<T>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op(left, right, T::le, |a, b| a <= b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op(left, right, |a, b| a <= b);
-}
-
-/// Perform `left <= right` operation on a [`PrimitiveArray`] and a scalar value.
-/// Null values are less than non-null values.
-pub fn lt_eq_scalar<T>(left: &PrimitiveArray<T>, right: T::Native) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op_scalar(left, right, T::le, |a, b| a <= b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op_scalar(left, |a| a <= right);
-}
-
-/// Perform `left > right` operation on two [`PrimitiveArray`]s. Non-null values are greater than null
-/// values.
-pub fn gt<T>(left: &PrimitiveArray<T>, right: &PrimitiveArray<T>) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op(left, right, T::gt, |a, b| a > b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op(left, right, |a, b| a > b);
-}
-
-/// Perform `left > right` operation on a [`PrimitiveArray`] and a scalar value.
-/// Non-null values are greater than null values.
-pub fn gt_scalar<T>(left: &PrimitiveArray<T>, right: T::Native) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op_scalar(left, right, T::gt, |a, b| a > b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op_scalar(left, |a| a > right);
-}
-
-/// Perform `left >= right` operation on two [`PrimitiveArray`]s. Non-null values are greater than null
-/// values.
-pub fn gt_eq<T>(
-    left: &PrimitiveArray<T>,
-    right: &PrimitiveArray<T>,
-) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op(left, right, T::ge, |a, b| a >= b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op(left, right, |a, b| a >= b);
-}
-
-/// Perform `left >= right` operation on a [`PrimitiveArray`] and a scalar value.
-/// Non-null values are greater than null values.
-pub fn gt_eq_scalar<T>(left: &PrimitiveArray<T>, right: T::Native) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-{
-    #[cfg(feature = "simd")]
-    return simd_compare_op_scalar(left, right, T::ge, |a, b| a >= b);
-    #[cfg(not(feature = "simd"))]
-    return compare_op_scalar(left, |a| a >= right);
-}
-
-/// Checks if a [`GenericListArray`] contains a value in the [`PrimitiveArray`]
-pub fn contains<T, OffsetSize>(
-    left: &PrimitiveArray<T>,
-    right: &GenericListArray<OffsetSize>,
-) -> Result<BooleanArray>
-where
-    T: ArrowNumericType,
-    OffsetSize: OffsetSizeTrait,
-{
-    let left_len = left.len();
-    if left_len != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform comparison operation on arrays of different length"
-                .to_string(),
-        ));
-    }
-
-    let num_bytes = bit_util::ceil(left_len, 8);
-
-    let not_both_null_bit_buffer =
-        match combine_option_bitmap(&[left.data_ref(), right.data_ref()], left_len)? {
-            Some(buff) => buff,
-            None => new_all_set_buffer(num_bytes),
-        };
-    let not_both_null_bitmap = not_both_null_bit_buffer.as_slice();
-
-    let mut bool_buf = MutableBuffer::from_len_zeroed(num_bytes);
-    let bool_slice = bool_buf.as_slice_mut();
-
-    // if both array slots are valid, check if list contains primitive
-    for i in 0..left_len {
-        if bit_util::get_bit(not_both_null_bitmap, i) {
-            let list = right.value(i);
-            let list = list.as_any().downcast_ref::<PrimitiveArray<T>>().unwrap();
-
-            for j in 0..list.len() {
-                if list.is_valid(j) && (left.value(i) == list.value(j)) {
-                    bit_util::set_bit(bool_slice, i);
-                    continue;
-                }
-            }
-        }
-    }
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            left.len(),
-            None,
-            None,
-            0,
-            vec![bool_buf.into()],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-/// Checks if a [`GenericListArray`] contains a value in the [`GenericStringArray`]
-pub fn contains_utf8<OffsetSize>(
-    left: &GenericStringArray<OffsetSize>,
-    right: &ListArray,
-) -> Result<BooleanArray>
-where
-    OffsetSize: OffsetSizeTrait,
-{
-    let left_len = left.len();
-    if left_len != right.len() {
-        return Err(ArrowError::ComputeError(
-            "Cannot perform comparison operation on arrays of different length"
-                .to_string(),
-        ));
-    }
-
-    let num_bytes = bit_util::ceil(left_len, 8);
-
-    let not_both_null_bit_buffer =
-        match combine_option_bitmap(&[left.data_ref(), right.data_ref()], left_len)? {
-            Some(buff) => buff,
-            None => new_all_set_buffer(num_bytes),
-        };
-    let not_both_null_bitmap = not_both_null_bit_buffer.as_slice();
-
-    let mut bool_buf = MutableBuffer::from_len_zeroed(num_bytes);
-    let bool_slice = &mut bool_buf;
-
-    for i in 0..left_len {
-        // contains(null, null) = false
-        if bit_util::get_bit(not_both_null_bitmap, i) {
-            let list = right.value(i);
-            let list = list
-                .as_any()
-                .downcast_ref::<GenericStringArray<OffsetSize>>()
-                .unwrap();
-
-            for j in 0..list.len() {
-                if list.is_valid(j) && (left.value(i) == list.value(j)) {
-                    bit_util::set_bit(bool_slice, i);
-                    continue;
-                }
-            }
-        }
-    }
-
-    let data = unsafe {
-        ArrayData::new_unchecked(
-            DataType::Boolean,
-            left.len(),
-            None,
-            None,
-            0,
-            vec![bool_buf.into()],
-            vec![],
-        )
-    };
-    Ok(BooleanArray::from(data))
-}
-
-// create a buffer and fill it with valid bits
-#[inline]
-fn new_all_set_buffer(len: usize) -> Buffer {
-    let buffer = MutableBuffer::new(len);
-    let buffer = buffer.with_bitset(len, true);
-
-    buffer.into()
-}
-
-// disable wrapping inside literal vectors used for test data and assertions
-#[rustfmt::skip::macros(vec)]
-#[cfg(test)]
-mod tests {
-    use std::sync::Arc;
-
-    use super::*;
-    use crate::datatypes::Int8Type;
-    use crate::{array::Int32Array, array::Int64Array, datatypes::Field};
-
-    /// Evaluate `KERNEL` with two vectors as inputs and assert against the expected output.
-    /// `A_VEC` and `B_VEC` can be of type `Vec<T>` or `Vec<Option<T>>` where `T` is the native
-    /// type of the data type of the Arrow array element.
-    /// `EXPECTED` can be either `Vec<bool>` or `Vec<Option<bool>>`.
-    /// The main reason for this macro is that inputs and outputs align nicely after `cargo fmt`.
-    macro_rules! cmp_vec {
-        ($KERNEL:ident, $DYN_KERNEL:ident, $ARRAY:ident, $A_VEC:expr, $B_VEC:expr, $EXPECTED:expr) => {
-            let a = $ARRAY::from($A_VEC);
-            let b = $ARRAY::from($B_VEC);
-            let c = $KERNEL(&a, &b).unwrap();
-            assert_eq!(BooleanArray::from($EXPECTED), c);
-
-            // slice and test if the dynamic array works
-            let a = a.slice(0, a.len());
-            let b = b.slice(0, b.len());
-            let c = $DYN_KERNEL(a.as_ref(), b.as_ref()).unwrap();
-            assert_eq!(BooleanArray::from($EXPECTED), c);
-
-            // test with a larger version of the same data to ensure we cover the chunked part of the comparison
-            let mut a = vec![];
-            let mut b = vec![];
-            let mut e = vec![];
-            for _i in 0..10 {
-                a.extend($A_VEC);
-                b.extend($B_VEC);
-                e.extend($EXPECTED);
-            }
-            let a = $ARRAY::from(a);
-            let b = $ARRAY::from(b);
-            let c = $KERNEL(&a, &b).unwrap();
-            assert_eq!(BooleanArray::from(e), c);
-        };
-    }
-
-    /// Evaluate `KERNEL` with two vectors as inputs and assert against the expected output.
-    /// `A_VEC` and `B_VEC` can be of type `Vec<i64>` or `Vec<Option<i64>>`.
-    /// `EXPECTED` can be either `Vec<bool>` or `Vec<Option<bool>>`.
-    /// The main reason for this macro is that inputs and outputs align nicely after `cargo fmt`.
-    macro_rules! cmp_i64 {
-        ($KERNEL:ident, $DYN_KERNEL:ident, $A_VEC:expr, $B_VEC:expr, $EXPECTED:expr) => {
-            cmp_vec!($KERNEL, $DYN_KERNEL, Int64Array, $A_VEC, $B_VEC, $EXPECTED);
-        };
-    }
-
-    /// Evaluate `KERNEL` with one vectors and one scalar as inputs and assert against the expected output.
-    /// `A_VEC` can be of type `Vec<i64>` or `Vec<Option<i64>>`.
-    /// `EXPECTED` can be either `Vec<bool>` or `Vec<Option<bool>>`.
-    /// The main reason for this macro is that inputs and outputs align nicely after `cargo fmt`.
-    macro_rules! cmp_i64_scalar {
-        ($KERNEL:ident, $A_VEC:expr, $B:literal, $EXPECTED:expr) => {
-            let a = Int64Array::from($A_VEC);
-            let c = $KERNEL(&a, $B).unwrap();
-            assert_eq!(BooleanArray::from($EXPECTED), c);
-
-            // test with a larger version of the same data to ensure we cover the chunked part of the comparison
-            let mut a = vec![];
-            let mut e = vec![];
-            for _i in 0..10 {
-                a.extend($A_VEC);
-                e.extend($EXPECTED);
-            }
-            let a = Int64Array::from(a);
-            let c = $KERNEL(&a, $B).unwrap();
-            assert_eq!(BooleanArray::from(e), c);
-
-        };
-    }
-
-    #[test]
-    fn test_primitive_array_eq() {
-        cmp_i64!(
-            eq,
-            eq_dyn,
-            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            vec![false, false, true, false, false, false, false, true, false, false]
-        );
-
-        cmp_vec!(
-            eq,
-            eq_dyn,
-            TimestampSecondArray,
-            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            vec![false, false, true, false, false, false, false, true, false, false]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_eq_scalar() {
-        cmp_i64_scalar!(
-            eq_scalar,
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            8,
-            vec![false, false, true, false, false, false, false, true, false, false]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_eq_with_slice() {
-        let a = Int32Array::from(vec![6, 7, 8, 8, 10]);
-        let b = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-        let b_slice = b.slice(5, 5);
-        let c = b_slice.as_any().downcast_ref().unwrap();
-        let d = eq(c, &a).unwrap();
-        assert!(d.value(0));
-        assert!(d.value(1));
-        assert!(d.value(2));
-        assert!(!d.value(3));
-        assert!(d.value(4));
-    }
-
-    #[test]
-    fn test_primitive_array_eq_scalar_with_slice() {
-        let a = Int32Array::from(vec![Some(1), None, Some(2), Some(3)]);
-        let a = a.slice(1, 3);
-        let a: &Int32Array = as_primitive_array(&a);
-        let a_eq = eq_scalar(a, 2).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![None, Some(true), Some(false)])
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_neq() {
-        cmp_i64!(
-            neq,
-            neq_dyn,
-            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            vec![true, true, false, true, true, true, true, false, true, true]
-        );
-
-        cmp_vec!(
-            neq,
-            neq_dyn,
-            TimestampMillisecondArray,
-            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            vec![true, true, false, true, true, true, true, false, true, true]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_neq_scalar() {
-        cmp_i64_scalar!(
-            neq_scalar,
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            8,
-            vec![true, true, false, true, true, true, true, false, true, true]
-        );
-    }
-
-    #[test]
-    fn test_boolean_array_eq() {
-        let a: BooleanArray =
-            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None]
-                .into();
-        let b: BooleanArray =
-            vec![Some(true), Some(true), Some(false), Some(false), None,  Some(false)]
-                .into();
-
-        let res: Vec<Option<bool>> = eq_bool(&a, &b).unwrap().iter().collect();
-
-        assert_eq!(
-            res,
-            vec![Some(true), Some(false), Some(true), Some(false), None, None]
-        )
-    }
-
-    #[test]
-    fn test_boolean_array_neq() {
-        let a: BooleanArray =
-            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None]
-                .into();
-        let b: BooleanArray =
-            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)]
-                .into();
-
-        let res: Vec<Option<bool>> = neq_bool(&a, &b).unwrap().iter().collect();
-
-        assert_eq!(
-            res,
-            vec![Some(false), Some(true), Some(false), Some(true), None, None]
-        )
-    }
-
-    #[test]
-    fn test_boolean_array_lt() {
-        let a: BooleanArray =
-            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None]
-                .into();
-        let b: BooleanArray =
-            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)]
-                .into();
-
-        let res: Vec<Option<bool>> = lt_bool(&a, &b).unwrap().iter().collect();
-
-        assert_eq!(
-            res,
-            vec![Some(false), Some(true), Some(false), Some(false), None, None]
-        )
-    }
-
-    #[test]
-    fn test_boolean_array_lt_eq() {
-        let a: BooleanArray =
-            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None]
-                .into();
-        let b: BooleanArray =
-            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)]
-                .into();
-
-        let res: Vec<Option<bool>> = lt_eq_bool(&a, &b).unwrap().iter().collect();
-
-        assert_eq!(
-            res,
-            vec![Some(true), Some(true), Some(true), Some(false), None, None]
-        )
-    }
-
-    #[test]
-    fn test_boolean_array_gt() {
-        let a: BooleanArray =
-            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None]
-                .into();
-        let b: BooleanArray =
-            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)]
-                .into();
-
-        let res: Vec<Option<bool>> = gt_bool(&a, &b).unwrap().iter().collect();
-
-        assert_eq!(
-            res,
-            vec![Some(false), Some(false), Some(false), Some(true), None, None]
-        )
-    }
-
-    #[test]
-    fn test_boolean_array_gt_eq() {
-        let a: BooleanArray =
-            vec![Some(true), Some(false), Some(false), Some(true), Some(true), None]
-                .into();
-        let b: BooleanArray =
-            vec![Some(true), Some(true), Some(false), Some(false), None, Some(false)]
-                .into();
-
-        let res: Vec<Option<bool>> = gt_eq_bool(&a, &b).unwrap().iter().collect();
-
-        assert_eq!(
-            res,
-            vec![Some(true), Some(false), Some(true), Some(true), None, None]
-        )
-    }
-
-    #[test]
-    fn test_boolean_array_eq_scalar() {
-        let a: BooleanArray = vec![Some(true), Some(false), None].into();
-
-        let res1: Vec<Option<bool>> = eq_bool_scalar(&a, false).unwrap().iter().collect();
-
-        assert_eq!(res1, vec![Some(false), Some(true), None]);
-
-        let res2: Vec<Option<bool>> = eq_bool_scalar(&a, true).unwrap().iter().collect();
-
-        assert_eq!(res2, vec![Some(true), Some(false), None]);
-    }
-
-    #[test]
-    fn test_boolean_array_neq_scalar() {
-        let a: BooleanArray = vec![Some(true), Some(false), None].into();
-
-        let res1: Vec<Option<bool>> =
-            neq_bool_scalar(&a, false).unwrap().iter().collect();
-
-        assert_eq!(res1, vec![Some(true), Some(false), None]);
-
-        let res2: Vec<Option<bool>> = neq_bool_scalar(&a, true).unwrap().iter().collect();
-
-        assert_eq!(res2, vec![Some(false), Some(true), None]);
-    }
-
-    #[test]
-    fn test_boolean_array_lt_scalar() {
-        let a: BooleanArray = vec![Some(true), Some(false), None].into();
-
-        let res1: Vec<Option<bool>> = lt_bool_scalar(&a, false).unwrap().iter().collect();
-
-        assert_eq!(res1, vec![Some(false), Some(false), None]);
-
-        let res2: Vec<Option<bool>> = lt_bool_scalar(&a, true).unwrap().iter().collect();
-
-        assert_eq!(res2, vec![Some(false), Some(true), None]);
-    }
-
-    #[test]
-    fn test_boolean_array_lt_eq_scalar() {
-        let a: BooleanArray = vec![Some(true), Some(false), None].into();
-
-        let res1: Vec<Option<bool>> =
-            lt_eq_bool_scalar(&a, false).unwrap().iter().collect();
-
-        assert_eq!(res1, vec![Some(false), Some(true), None]);
-
-        let res2: Vec<Option<bool>> =
-            lt_eq_bool_scalar(&a, true).unwrap().iter().collect();
-
-        assert_eq!(res2, vec![Some(true), Some(true), None]);
-    }
-
-    #[test]
-    fn test_boolean_array_gt_scalar() {
-        let a: BooleanArray = vec![Some(true), Some(false), None].into();
-
-        let res1: Vec<Option<bool>> = gt_bool_scalar(&a, false).unwrap().iter().collect();
-
-        assert_eq!(res1, vec![Some(true), Some(false), None]);
-
-        let res2: Vec<Option<bool>> = gt_bool_scalar(&a, true).unwrap().iter().collect();
-
-        assert_eq!(res2, vec![Some(false), Some(false), None]);
-    }
-
-    #[test]
-    fn test_boolean_array_gt_eq_scalar() {
-        let a: BooleanArray = vec![Some(true), Some(false), None].into();
-
-        let res1: Vec<Option<bool>> =
-            gt_eq_bool_scalar(&a, false).unwrap().iter().collect();
-
-        assert_eq!(res1, vec![Some(true), Some(true), None]);
-
-        let res2: Vec<Option<bool>> =
-            gt_eq_bool_scalar(&a, true).unwrap().iter().collect();
-
-        assert_eq!(res2, vec![Some(true), Some(false), None]);
-    }
-
-    #[test]
-    fn test_primitive_array_lt() {
-        cmp_i64!(
-            lt,
-            lt_dyn,
-            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            vec![false, false, false, true, true, false, false, false, true, true]
-        );
-
-        cmp_vec!(
-            lt,
-            lt_dyn,
-            TimestampMillisecondArray,
-            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            vec![false, false, false, true, true, false, false, false, true, true]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_lt_scalar() {
-        cmp_i64_scalar!(
-            lt_scalar,
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            8,
-            vec![true, true, false, false, false, true, true, false, false, false]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_lt_nulls() {
-        cmp_i64!(
-            lt,
-            lt_dyn,
-            vec![None, None, Some(1), Some(1), None, None, Some(2), Some(2),],
-            vec![None, Some(1), None, Some(1), None, Some(3), None, Some(3),],
-            vec![None, None, None, Some(false), None, None, None, Some(true)]
-        );
-
-        cmp_vec!(
-            lt,
-            lt_dyn,
-            TimestampMillisecondArray,
-            vec![None, None, Some(1), Some(1), None, None, Some(2), Some(2),],
-            vec![None, Some(1), None, Some(1), None, Some(3), None, Some(3),],
-            vec![None, None, None, Some(false), None, None, None, Some(true)]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_lt_scalar_nulls() {
-        cmp_i64_scalar!(
-            lt_scalar,
-            vec![None, Some(1), Some(2), Some(3), None, Some(1), Some(2), Some(3), Some(2), None],
-            2,
-            vec![None, Some(true), Some(false), Some(false), None, Some(true), Some(false), Some(false), Some(false), None]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_lt_eq() {
-        cmp_i64!(
-            lt_eq,
-            lt_eq_dyn,
-            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            vec![false, false, true, true, true, false, false, true, true, true]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_lt_eq_scalar() {
-        cmp_i64_scalar!(
-            lt_eq_scalar,
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            8,
-            vec![true, true, true, false, false, true, true, true, false, false]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_lt_eq_nulls() {
-        cmp_i64!(
-            lt_eq,
-            lt_eq_dyn,
-            vec![None, None, Some(1), None, None, Some(1), None, None, Some(1)],
-            vec![None, Some(1), Some(0), None, Some(1), Some(2), None, None, Some(3)],
-            vec![None, None, Some(false), None, None, Some(true), None, None, Some(true)]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_lt_eq_scalar_nulls() {
-        cmp_i64_scalar!(
-            lt_eq_scalar,
-            vec![None, Some(1), Some(2), None, Some(1), Some(2), None, Some(1), Some(2)],
-            1,
-            vec![None, Some(true), Some(false), None, Some(true), Some(false), None, Some(true), Some(false)]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_gt() {
-        cmp_i64!(
-            gt,
-            gt_dyn,
-            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            vec![true, true, false, false, false, true, true, false, false, false]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_gt_scalar() {
-        cmp_i64_scalar!(
-            gt_scalar,
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            8,
-            vec![false, false, false, true, true, false, false, false, true, true]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_gt_nulls() {
-        cmp_i64!(
-            gt,
-            gt_dyn,
-            vec![None, None, Some(1), None, None, Some(2), None, None, Some(3)],
-            vec![None, Some(1), Some(1), None, Some(1), Some(1), None, Some(1), Some(1)],
-            vec![None, None, Some(false), None, None, Some(true), None, None, Some(true)]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_gt_scalar_nulls() {
-        cmp_i64_scalar!(
-            gt_scalar,
-            vec![None, Some(1), Some(2), None, Some(1), Some(2), None, Some(1), Some(2)],
-            1,
-            vec![None, Some(false), Some(true), None, Some(false), Some(true), None, Some(false), Some(true)]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_gt_eq() {
-        cmp_i64!(
-            gt_eq,
-            gt_eq_dyn,
-            vec![8, 8, 8, 8, 8, 8, 8, 8, 8, 8],
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            vec![true, true, true, false, false, true, true, true, false, false]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_gt_eq_scalar() {
-        cmp_i64_scalar!(
-            gt_eq_scalar,
-            vec![6, 7, 8, 9, 10, 6, 7, 8, 9, 10],
-            8,
-            vec![false, false, true, true, true, false, false, true, true, true]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_gt_eq_nulls() {
-        cmp_i64!(
-            gt_eq,
-            gt_eq_dyn,
-            vec![None, None, Some(1), None, Some(1), Some(2), None, None, Some(1)],
-            vec![None, Some(1), None, None, Some(1), Some(1), None, Some(2), Some(2)],
-            vec![None, None, None, None, Some(true), Some(true), None, None, Some(false)]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_gt_eq_scalar_nulls() {
-        cmp_i64_scalar!(
-            gt_eq_scalar,
-            vec![None, Some(1), Some(2), None, Some(2), Some(3), None, Some(3), Some(4)],
-            2,
-            vec![None, Some(false), Some(true), None, Some(true), Some(true), None, Some(true), Some(true)]
-        );
-    }
-
-    #[test]
-    fn test_primitive_array_compare_slice() {
-        let a: Int32Array = (0..100).map(Some).collect();
-        let a = a.slice(50, 50);
-        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
-        let b: Int32Array = (100..200).map(Some).collect();
-        let b = b.slice(50, 50);
-        let b = b.as_any().downcast_ref::<Int32Array>().unwrap();
-        let actual = lt(a, b).unwrap();
-        let expected: BooleanArray = (0..50).map(|_| Some(true)).collect();
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn test_primitive_array_compare_scalar_slice() {
-        let a: Int32Array = (0..100).map(Some).collect();
-        let a = a.slice(50, 50);
-        let a = a.as_any().downcast_ref::<Int32Array>().unwrap();
-        let actual = lt_scalar(a, 200).unwrap();
-        let expected: BooleanArray = (0..50).map(|_| Some(true)).collect();
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn test_length_of_result_buffer() {
-        // `item_count` is chosen to not be a multiple of the number of SIMD lanes for this
-        // type (`Int8Type`), 64.
-        let item_count = 130;
-
-        let select_mask: BooleanArray = vec![true; item_count].into();
-
-        let array_a: PrimitiveArray<Int8Type> = vec![1; item_count].into();
-        let array_b: PrimitiveArray<Int8Type> = vec![2; item_count].into();
-        let result_mask = gt_eq(&array_a, &array_b).unwrap();
-
-        assert_eq!(
-            result_mask.data().buffers()[0].len(),
-            select_mask.data().buffers()[0].len()
-        );
-    }
-
-    // Expected behaviour:
-    // contains(1, [1, 2, null]) = true
-    // contains(3, [1, 2, null]) = false
-    // contains(null, [1, 2, null]) = false
-    // contains(null, null) = false
-    #[test]
-    fn test_contains() {
-        let value_data = Int32Array::from(vec![
-            Some(0),
-            Some(1),
-            Some(2),
-            Some(3),
-            Some(4),
-            Some(5),
-            Some(6),
-            None,
-            Some(7),
-        ])
-        .data()
-        .clone();
-        let value_offsets = Buffer::from_slice_ref(&[0i64, 3, 6, 6, 9]);
-        let list_data_type =
-            DataType::LargeList(Box::new(Field::new("item", DataType::Int32, true)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(4)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .null_bit_buffer(Some(Buffer::from([0b00001011])))
-            .build()
-            .unwrap();
-
-        //  [[0, 1, 2], [3, 4, 5], null, [6, null, 7]]
-        let list_array = LargeListArray::from(list_data);
-
-        let nulls = Int32Array::from(vec![None, None, None, None]);
-        let nulls_result = contains(&nulls, &list_array).unwrap();
-        assert_eq!(
-            nulls_result
-                .as_any()
-                .downcast_ref::<BooleanArray>()
-                .unwrap(),
-            &BooleanArray::from(vec![false, false, false, false]),
-        );
-
-        let values = Int32Array::from(vec![Some(0), Some(0), Some(0), Some(0)]);
-        let values_result = contains(&values, &list_array).unwrap();
-        assert_eq!(
-            values_result
-                .as_any()
-                .downcast_ref::<BooleanArray>()
-                .unwrap(),
-            &BooleanArray::from(vec![true, false, false, false]),
-        );
-    }
-
-    #[test]
-    fn test_interval_array() {
-        let a = IntervalDayTimeArray::from(
-            vec![Some(0), Some(6), Some(834), None, Some(3), None],
-        );
-        let b = IntervalDayTimeArray::from(
-            vec![Some(70), Some(6), Some(833), Some(6), Some(3), None],
-        );
-        let res = eq(&a, &b).unwrap();
-        let res_dyn = eq_dyn(&a, &b).unwrap();
-        assert_eq!(res, res_dyn);
-        assert_eq!(
-            &res_dyn,
-            &BooleanArray::from(
-                vec![Some(false), Some(true), Some(false), None, Some(true), None]
-            )
-        );
-
-        let a = IntervalMonthDayNanoArray::from(
-            vec![Some(0), Some(6), Some(834), None, Some(3), None],
-        );
-        let b = IntervalMonthDayNanoArray::from(
-            vec![Some(86), Some(5), Some(8), Some(6), Some(3), None],
-        );
-        let res = lt(&a, &b).unwrap();
-        let res_dyn = lt_dyn(&a, &b).unwrap();
-        assert_eq!(res, res_dyn);
-        assert_eq!(
-            &res_dyn,
-            &BooleanArray::from(
-                vec![Some(true), Some(false), Some(false), None, Some(false), None]
-            )
-        );
-
-        let a = IntervalYearMonthArray::from(
-            vec![Some(0), Some(623), Some(834), None, Some(3), None],
-        );
-        let b = IntervalYearMonthArray::from(
-            vec![Some(86), Some(5), Some(834), Some(6), Some(86), None],
-        );
-        let res = gt_eq(&a, &b).unwrap();
-        let res_dyn = gt_eq_dyn(&a, &b).unwrap();
-        assert_eq!(res, res_dyn);
-        assert_eq!(
-            &res_dyn,
-            &BooleanArray::from(
-                vec![Some(false), Some(true), Some(true), None, Some(false), None]
-            )
-        );
-    }
-
-    macro_rules! test_binary {
-        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
-            #[test]
-            fn $test_name() {
-                let left = BinaryArray::from_vec($left);
-                let right = BinaryArray::from_vec($right);
-                let res = $op(&left, &right).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(v, expected[i]);
-                }
-
-                let left = LargeBinaryArray::from_vec($left);
-                let right = LargeBinaryArray::from_vec($right);
-                let res = $op(&left, &right).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(v, expected[i]);
-                }
-            }
-        };
-    }
-
-    #[test]
-    fn test_binary_eq_scalar_on_slice() {
-        let a = BinaryArray::from_opt_vec(
-            vec![Some(b"hi"), None, Some(b"hello"), Some(b"world")],
-        );
-        let a = a.slice(1, 3);
-        let a = as_generic_binary_array::<i32>(&a);
-        let a_eq = eq_binary_scalar(a, b"hello").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![None, Some(true), Some(false)])
-        );
-    }
-
-    macro_rules! test_binary_scalar {
-        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
-            #[test]
-            fn $test_name() {
-                let left = BinaryArray::from_vec($left);
-                let res = $op(&left, $right).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(
-                        v,
-                        expected[i],
-                        "unexpected result when comparing {:?} at position {} to {:?} ",
-                        left.value(i),
-                        i,
-                        $right
-                    );
-                }
-
-                let left = LargeBinaryArray::from_vec($left);
-                let res = $op(&left, $right).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(
-                        v,
-                        expected[i],
-                        "unexpected result when comparing {:?} at position {} to {:?} ",
-                        left.value(i),
-                        i,
-                        $right
-                    );
-                }
-            }
-        };
-    }
-
-    test_binary!(
-        test_binary_array_eq,
-        vec![b"arrow", b"arrow", b"arrow", b"arrow", &[0xff, 0xf8]],
-        vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf8]],
-        eq_binary,
-        vec![true, false, false, false, true]
-    );
-
-    test_binary_scalar!(
-        test_binary_array_eq_scalar,
-        vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf8]],
-        "arrow".as_bytes(),
-        eq_binary_scalar,
-        vec![true, false, false, false, false]
-    );
-
-    test_binary!(
-        test_binary_array_neq,
-        vec![b"arrow", b"arrow", b"arrow", b"arrow", &[0xff, 0xf8]],
-        vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf9]],
-        neq_binary,
-        vec![false, true, true, true, true]
-    );
-    test_binary_scalar!(
-        test_binary_array_neq_scalar,
-        vec![b"arrow", b"parquet", b"datafusion", b"flight", &[0xff, 0xf8]],
-        "arrow".as_bytes(),
-        neq_binary_scalar,
-        vec![false, true, true, true, true]
-    );
-
-    test_binary!(
-        test_binary_array_lt,
-        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
-        vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf9]],
-        lt_binary,
-        vec![true, true, false, false, true]
-    );
-    test_binary_scalar!(
-        test_binary_array_lt_scalar,
-        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
-        "flight".as_bytes(),
-        lt_binary_scalar,
-        vec![true, true, false, false, false]
-    );
-
-    test_binary!(
-        test_binary_array_lt_eq,
-        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
-        vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf8, 0xf9]],
-        lt_eq_binary,
-        vec![true, true, true, false, true]
-    );
-    test_binary_scalar!(
-        test_binary_array_lt_eq_scalar,
-        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
-        "flight".as_bytes(),
-        lt_eq_binary_scalar,
-        vec![true, true, true, false, false]
-    );
-
-    test_binary!(
-        test_binary_array_gt,
-        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf9]],
-        vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf8]],
-        gt_binary,
-        vec![false, false, false, true, true]
-    );
-    test_binary_scalar!(
-        test_binary_array_gt_scalar,
-        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
-        "flight".as_bytes(),
-        gt_binary_scalar,
-        vec![false, false, false, true, true]
-    );
-
-    test_binary!(
-        test_binary_array_gt_eq,
-        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
-        vec![b"flight", b"flight", b"flight", b"flight", &[0xff, 0xf8]],
-        gt_eq_binary,
-        vec![false, false, true, true, true]
-    );
-    test_binary_scalar!(
-        test_binary_array_gt_eq_scalar,
-        vec![b"arrow", b"datafusion", b"flight", b"parquet", &[0xff, 0xf8]],
-        "flight".as_bytes(),
-        gt_eq_binary_scalar,
-        vec![false, false, true, true, true]
-    );
-
-    // Expected behaviour:
-    // contains("ab", ["ab", "cd", null]) = true
-    // contains("ef", ["ab", "cd", null]) = false
-    // contains(null, ["ab", "cd", null]) = false
-    // contains(null, null) = false
-    #[test]
-    fn test_contains_utf8() {
-        let values_builder = StringBuilder::new(10);
-        let mut builder = ListBuilder::new(values_builder);
-
-        builder.values().append_value("Lorem");
-        builder.values().append_value("ipsum");
-        builder.values().append_null();
-        builder.append(true);
-        builder.values().append_value("sit");
-        builder.values().append_value("amet");
-        builder.values().append_value("Lorem");
-        builder.append(true);
-        builder.append(false);
-        builder.values().append_value("ipsum");
-        builder.append(true);
-
-        //  [["Lorem", "ipsum", null], ["sit", "amet", "Lorem"], null, ["ipsum"]]
-        // value_offsets = [0, 3, 6, 6]
-        let list_array = builder.finish();
-
-        let nulls = StringArray::from(vec![None, None, None, None]);
-        let nulls_result = contains_utf8(&nulls, &list_array).unwrap();
-        assert_eq!(
-            nulls_result
-                .as_any()
-                .downcast_ref::<BooleanArray>()
-                .unwrap(),
-            &BooleanArray::from(vec![false, false, false, false]),
-        );
-
-        let values = StringArray::from(vec![
-            Some("Lorem"),
-            Some("Lorem"),
-            Some("Lorem"),
-            Some("Lorem"),
-        ]);
-        let values_result = contains_utf8(&values, &list_array).unwrap();
-        assert_eq!(
-            values_result
-                .as_any()
-                .downcast_ref::<BooleanArray>()
-                .unwrap(),
-            &BooleanArray::from(vec![true, true, false, false]),
-        );
-    }
-
-    macro_rules! test_utf8 {
-        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
-            #[test]
-            fn $test_name() {
-                let left = StringArray::from($left);
-                let right = StringArray::from($right);
-                let res = $op(&left, &right).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(v, expected[i]);
-                }
-            }
-        };
-    }
-
-    #[test]
-    fn test_utf8_eq_scalar_on_slice() {
-        let a = StringArray::from(vec![Some("hi"), None, Some("hello"), Some("world")]);
-        let a = a.slice(1, 3);
-        let a = as_string_array(&a);
-        let a_eq = eq_utf8_scalar(a, "hello").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![None, Some(true), Some(false)])
-        );
-    }
-
-    macro_rules! test_utf8_scalar {
-        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
-            #[test]
-            fn $test_name() {
-                let left = StringArray::from($left);
-                let res = $op(&left, $right).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(
-                        v,
-                        expected[i],
-                        "unexpected result when comparing {} at position {} to {} ",
-                        left.value(i),
-                        i,
-                        $right
-                    );
-                }
-
-                let left = LargeStringArray::from($left);
-                let res = $op(&left, $right).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(
-                        v,
-                        expected[i],
-                        "unexpected result when comparing {} at position {} to {} ",
-                        left.value(i),
-                        i,
-                        $right
-                    );
-                }
-            }
-        };
-    }
-
-    macro_rules! test_flag_utf8 {
-        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
-            #[test]
-            fn $test_name() {
-                let left = StringArray::from($left);
-                let right = StringArray::from($right);
-                let res = $op(&left, &right, None).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(v, expected[i]);
-                }
-            }
-        };
-        ($test_name:ident, $left:expr, $right:expr, $flag:expr, $op:expr, $expected:expr) => {
-            #[test]
-            fn $test_name() {
-                let left = StringArray::from($left);
-                let right = StringArray::from($right);
-                let flag = Some(StringArray::from($flag));
-                let res = $op(&left, &right, flag.as_ref()).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(v, expected[i]);
-                }
-            }
-        };
-    }
-
-    macro_rules! test_flag_utf8_scalar {
-        ($test_name:ident, $left:expr, $right:expr, $op:expr, $expected:expr) => {
-            #[test]
-            fn $test_name() {
-                let left = StringArray::from($left);
-                let res = $op(&left, $right, None).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(
-                        v,
-                        expected[i],
-                        "unexpected result when comparing {} at position {} to {} ",
-                        left.value(i),
-                        i,
-                        $right
-                    );
-                }
-            }
-        };
-        ($test_name:ident, $left:expr, $right:expr, $flag:expr, $op:expr, $expected:expr) => {
-            #[test]
-            fn $test_name() {
-                let left = StringArray::from($left);
-                let flag = Some($flag);
-                let res = $op(&left, $right, flag).unwrap();
-                let expected = $expected;
-                assert_eq!(expected.len(), res.len());
-                for i in 0..res.len() {
-                    let v = res.value(i);
-                    assert_eq!(
-                        v,
-                        expected[i],
-                        "unexpected result when comparing {} at position {} to {} ",
-                        left.value(i),
-                        i,
-                        $right
-                    );
-                }
-            }
-        };
-    }
-
-    test_utf8!(
-        test_utf8_array_like,
-        vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrows", "arrow", "arrow"],
-        vec!["arrow", "ar%", "%ro%", "foo", "arr", "arrow_", "arrow_", ".*"],
-        like_utf8,
-        vec![true, true, true, false, false, true, false, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_like_scalar_escape_testing,
-        vec!["varchar(255)", "int(255)", "varchar", "int"],
-        "%(%)%",
-        like_utf8_scalar,
-        vec![true, true, false, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_like_scalar_escape_regex,
-        vec![".*", "a", "*"],
-        ".*",
-        like_utf8_scalar,
-        vec![true, false, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_like_scalar_escape_regex_dot,
-        vec![".", "a", "*"],
-        ".",
-        like_utf8_scalar,
-        vec![true, false, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_like_scalar,
-        vec!["arrow", "parquet", "datafusion", "flight"],
-        "%ar%",
-        like_utf8_scalar,
-        vec![true, true, false, false]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_like_scalar_start,
-        vec!["arrow", "parrow", "arrows", "arr"],
-        "arrow%",
-        like_utf8_scalar,
-        vec![true, false, true, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_like_scalar_end,
-        vec!["arrow", "parrow", "arrows", "arr"],
-        "%arrow",
-        like_utf8_scalar,
-        vec![true, true, false, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_like_scalar_equals,
-        vec!["arrow", "parrow", "arrows", "arr"],
-        "arrow",
-        like_utf8_scalar,
-        vec![true, false, false, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_like_scalar_one,
-        vec!["arrow", "arrows", "parrow", "arr"],
-        "arrow_",
-        like_utf8_scalar,
-        vec![false, true, false, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_scalar_like_escape,
-        vec!["a%", "a\\x"],
-        "a\\%",
-        like_utf8_scalar,
-        vec![true, false]
-    );
-
-    test_utf8!(
-        test_utf8_scalar_ilike_regex,
-        vec!["%%%"],
-        vec![r#"\%_\%"#],
-        ilike_utf8,
-        vec![true]
-    );
-
-    #[test]
-    fn test_replace_like_wildcards() {
-        let a_eq = "_%";
-        let expected = "..*";
-        assert_eq!(replace_like_wildcards(a_eq).unwrap(), expected);
-    }
-
-    #[test]
-    fn test_replace_like_wildcards_leave_like_meta_chars() {
-        let a_eq = "\\%\\_";
-        let expected = "%_";
-        assert_eq!(replace_like_wildcards(a_eq).unwrap(), expected);
-    }
-
-    #[test]
-    fn test_replace_like_wildcards_with_multiple_escape_chars() {
-        let a_eq = "\\\\%";
-        let expected = "\\\\%";
-        assert_eq!(replace_like_wildcards(a_eq).unwrap(), expected);
-    }
-
-    #[test]
-    fn test_replace_like_wildcards_escape_regex_meta_char() {
-        let a_eq = ".";
-        let expected = "\\.";
-        assert_eq!(replace_like_wildcards(a_eq).unwrap(), expected);
-    }
-
-    test_utf8!(
-        test_utf8_array_eq,
-        vec!["arrow", "arrow", "arrow", "arrow"],
-        vec!["arrow", "parquet", "datafusion", "flight"],
-        eq_utf8,
-        vec![true, false, false, false]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_eq_scalar,
-        vec!["arrow", "parquet", "datafusion", "flight"],
-        "arrow",
-        eq_utf8_scalar,
-        vec![true, false, false, false]
-    );
-
-    test_utf8!(
-        test_utf8_array_nlike,
-        vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrows", "arrow"],
-        vec!["arrow", "ar%", "%ro%", "foo", "arr", "arrow_", "arrow_"],
-        nlike_utf8,
-        vec![false, false, false, true, true, false, true]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_nlike_escape_testing,
-        vec!["varchar(255)", "int(255)", "varchar", "int"],
-        "%(%)%",
-        nlike_utf8_scalar,
-        vec![false, false, true, true]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_nlike_scalar_escape_regex,
-        vec![".*", "a", "*"],
-        ".*",
-        nlike_utf8_scalar,
-        vec![false, true, true]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_nlike_scalar_escape_regex_dot,
-        vec![".", "a", "*"],
-        ".",
-        nlike_utf8_scalar,
-        vec![false, true, true]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_nlike_scalar,
-        vec!["arrow", "parquet", "datafusion", "flight"],
-        "%ar%",
-        nlike_utf8_scalar,
-        vec![false, false, true, true]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_nlike_scalar_start,
-        vec!["arrow", "parrow", "arrows", "arr"],
-        "arrow%",
-        nlike_utf8_scalar,
-        vec![false, true, false, true]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_nlike_scalar_end,
-        vec!["arrow", "parrow", "arrows", "arr"],
-        "%arrow",
-        nlike_utf8_scalar,
-        vec![false, false, true, true]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_nlike_scalar_equals,
-        vec!["arrow", "parrow", "arrows", "arr"],
-        "arrow",
-        nlike_utf8_scalar,
-        vec![false, true, true, true]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_nlike_scalar_one,
-        vec!["arrow", "arrows", "parrow", "arr"],
-        "arrow_",
-        nlike_utf8_scalar,
-        vec![true, false, true, true]
-    );
-
-    test_utf8!(
-        test_utf8_array_ilike,
-        vec!["arrow", "arrow", "ARROW", "arrow", "ARROW", "ARROWS", "arROw"],
-        vec!["arrow", "ar%", "%ro%", "foo", "ar%r", "arrow_", "arrow_"],
-        ilike_utf8,
-        vec![true, true, true, false, false, true, false]
-    );
-    test_utf8_scalar!(
-        ilike_utf8_scalar_escape_testing,
-        vec!["varchar(255)", "int(255)", "varchar", "int"],
-        "%(%)%",
-        ilike_utf8_scalar,
-        vec![true, true, false, false]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_ilike_scalar,
-        vec!["arrow", "parquet", "datafusion", "flight"],
-        "%AR%",
-        ilike_utf8_scalar,
-        vec![true, true, false, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_ilike_scalar_start,
-        vec!["arrow", "parrow", "arrows", "ARR"],
-        "aRRow%",
-        ilike_utf8_scalar,
-        vec![true, false, true, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_ilike_scalar_end,
-        vec!["ArroW", "parrow", "ARRowS", "arr"],
-        "%arrow",
-        ilike_utf8_scalar,
-        vec![true, true, false, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_ilike_scalar_equals,
-        vec!["arrow", "parrow", "arrows", "arr"],
-        "arrow",
-        ilike_utf8_scalar,
-        vec![true, false, false, false]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_ilike_scalar_one,
-        vec!["arrow", "arrows", "parrow", "arr"],
-        "arrow_",
-        ilike_utf8_scalar,
-        vec![false, true, false, false]
-    );
-
-    test_utf8!(
-        test_utf8_array_nilike,
-        vec!["arrow", "arrow", "ARROW", "arrow", "ARROW", "ARROWS", "arROw"],
-        vec!["arrow", "ar%", "%ro%", "foo", "ar%r", "arrow_", "arrow_"],
-        nilike_utf8,
-        vec![false, false, false, true, true, false, true]
-    );
-    test_utf8_scalar!(
-        nilike_utf8_scalar_escape_testing,
-        vec!["varchar(255)", "int(255)", "varchar", "int"],
-        "%(%)%",
-        nilike_utf8_scalar,
-        vec![false, false, true, true]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_nilike_scalar,
-        vec!["arrow", "parquet", "datafusion", "flight"],
-        "%AR%",
-        nilike_utf8_scalar,
-        vec![false, false, true, true]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_nilike_scalar_start,
-        vec!["arrow", "parrow", "arrows", "ARR"],
-        "aRRow%",
-        nilike_utf8_scalar,
-        vec![false, true, false, true]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_nilike_scalar_end,
-        vec!["ArroW", "parrow", "ARRowS", "arr"],
-        "%arrow",
-        nilike_utf8_scalar,
-        vec![false, false, true, true]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_nilike_scalar_equals,
-        vec!["arrow", "parrow", "arrows", "arr"],
-        "arrow",
-        nilike_utf8_scalar,
-        vec![false, true, true, true]
-    );
-
-    test_utf8_scalar!(
-        test_utf8_array_nilike_scalar_one,
-        vec!["arrow", "arrows", "parrow", "arr"],
-        "arrow_",
-        nilike_utf8_scalar,
-        vec![true, false, true, true]
-    );
-
-    test_utf8!(
-        test_utf8_array_neq,
-        vec!["arrow", "arrow", "arrow", "arrow"],
-        vec!["arrow", "parquet", "datafusion", "flight"],
-        neq_utf8,
-        vec![false, true, true, true]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_neq_scalar,
-        vec!["arrow", "parquet", "datafusion", "flight"],
-        "arrow",
-        neq_utf8_scalar,
-        vec![false, true, true, true]
-    );
-
-    test_utf8!(
-        test_utf8_array_lt,
-        vec!["arrow", "datafusion", "flight", "parquet"],
-        vec!["flight", "flight", "flight", "flight"],
-        lt_utf8,
-        vec![true, true, false, false]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_lt_scalar,
-        vec!["arrow", "datafusion", "flight", "parquet"],
-        "flight",
-        lt_utf8_scalar,
-        vec![true, true, false, false]
-    );
-
-    test_utf8!(
-        test_utf8_array_lt_eq,
-        vec!["arrow", "datafusion", "flight", "parquet"],
-        vec!["flight", "flight", "flight", "flight"],
-        lt_eq_utf8,
-        vec![true, true, true, false]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_lt_eq_scalar,
-        vec!["arrow", "datafusion", "flight", "parquet"],
-        "flight",
-        lt_eq_utf8_scalar,
-        vec![true, true, true, false]
-    );
-
-    test_utf8!(
-        test_utf8_array_gt,
-        vec!["arrow", "datafusion", "flight", "parquet"],
-        vec!["flight", "flight", "flight", "flight"],
-        gt_utf8,
-        vec![false, false, false, true]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_gt_scalar,
-        vec!["arrow", "datafusion", "flight", "parquet"],
-        "flight",
-        gt_utf8_scalar,
-        vec![false, false, false, true]
-    );
-
-    test_utf8!(
-        test_utf8_array_gt_eq,
-        vec!["arrow", "datafusion", "flight", "parquet"],
-        vec!["flight", "flight", "flight", "flight"],
-        gt_eq_utf8,
-        vec![false, false, true, true]
-    );
-    test_utf8_scalar!(
-        test_utf8_array_gt_eq_scalar,
-        vec!["arrow", "datafusion", "flight", "parquet"],
-        "flight",
-        gt_eq_utf8_scalar,
-        vec![false, false, true, true]
-    );
-    test_flag_utf8!(
-        test_utf8_array_regexp_is_match,
-        vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrow"],
-        vec!["^ar", "^AR", "ow$", "OW$", "foo", ""],
-        regexp_is_match_utf8,
-        vec![true, false, true, false, false, true]
-    );
-    test_flag_utf8!(
-        test_utf8_array_regexp_is_match_insensitive,
-        vec!["arrow", "arrow", "arrow", "arrow", "arrow", "arrow"],
-        vec!["^ar", "^AR", "ow$", "OW$", "foo", ""],
-        vec!["i"; 6],
-        regexp_is_match_utf8,
-        vec![true, true, true, true, false, true]
-    );
-
-    test_flag_utf8_scalar!(
-        test_utf8_array_regexp_is_match_scalar,
-        vec!["arrow", "ARROW", "parquet", "PARQUET"],
-        "^ar",
-        regexp_is_match_utf8_scalar,
-        vec![true, false, false, false]
-    );
-    test_flag_utf8_scalar!(
-        test_utf8_array_regexp_is_match_empty_scalar,
-        vec!["arrow", "ARROW", "parquet", "PARQUET"],
-        "",
-        regexp_is_match_utf8_scalar,
-        vec![true, true, true, true]
-    );
-    test_flag_utf8_scalar!(
-        test_utf8_array_regexp_is_match_insensitive_scalar,
-        vec!["arrow", "ARROW", "parquet", "PARQUET"],
-        "^ar",
-        "i",
-        regexp_is_match_utf8_scalar,
-        vec![true, true, false, false]
-    );
-
-    #[test]
-    fn test_eq_dyn_scalar() {
-        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
-        let a_eq = eq_dyn_scalar(&array, 8).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(false), Some(false), Some(true), Some(true), Some(false)]
-            )
-        );
-    }
-
-    #[test]
-    fn test_eq_dyn_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(123).unwrap();
-        builder.append_null();
-        builder.append(23).unwrap();
-        let array = builder.finish();
-        let a_eq = eq_dyn_scalar(&array, 123).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(true), None, Some(false)])
-        );
-    }
-
-    #[test]
-    fn test_eq_dyn_scalar_float() {
-        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
-            .into_iter()
-            .map(Some)
-            .collect();
-        let expected = BooleanArray::from(
-            vec![Some(false), Some(false), Some(true), Some(true), Some(false)],
-        );
-        assert_eq!(eq_dyn_scalar(&array, 8).unwrap(), expected);
-
-        let array: ArrayRef = Arc::new(array);
-        let array = crate::compute::cast(&array, &DataType::Float64).unwrap();
-        assert_eq!(eq_dyn_scalar(&array, 8).unwrap(), expected);
-    }
-
-    #[test]
-    fn test_lt_dyn_scalar() {
-        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
-        let a_eq = lt_dyn_scalar(&array, 8).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(true), Some(true), Some(false), Some(false), Some(false)]
-            )
-        );
-    }
-
-    #[test]
-    fn test_lt_dyn_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(123).unwrap();
-        builder.append_null();
-        builder.append(23).unwrap();
-        let array = builder.finish();
-        let a_eq = lt_dyn_scalar(&array, 123).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(false), None, Some(true)])
-        );
-    }
-
-    #[test]
-    fn test_lt_dyn_scalar_float() {
-        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
-            .into_iter()
-            .map(Some)
-            .collect();
-        let expected = BooleanArray::from(
-            vec![Some(true), Some(true), Some(false), Some(false), Some(false)],
-        );
-        assert_eq!(lt_dyn_scalar(&array, 8).unwrap(), expected);
-
-        let array: ArrayRef = Arc::new(array);
-        let array = crate::compute::cast(&array, &DataType::Float64).unwrap();
-        assert_eq!(lt_dyn_scalar(&array, 8).unwrap(), expected);
-    }
-
-    #[test]
-    fn test_lt_eq_dyn_scalar() {
-        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
-        let a_eq = lt_eq_dyn_scalar(&array, 8).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(true), Some(true), Some(true), Some(true), Some(false)]
-            )
-        );
-    }
-    #[test]
-    fn test_lt_eq_dyn_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(123).unwrap();
-        builder.append_null();
-        builder.append(23).unwrap();
-        let array = builder.finish();
-        let a_eq = lt_eq_dyn_scalar(&array, 23).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(false), None, Some(true)])
-        );
-    }
-
-    #[test]
-    fn test_lt_eq_dyn_scalar_float() {
-        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
-            .into_iter()
-            .map(Some)
-            .collect();
-        let expected = BooleanArray::from(
-            vec![Some(true), Some(true), Some(true), Some(true), Some(false)],
-        );
-        assert_eq!(lt_eq_dyn_scalar(&array, 8).unwrap(), expected);
-
-        let array: ArrayRef = Arc::new(array);
-        let array = crate::compute::cast(&array, &DataType::Float64).unwrap();
-        assert_eq!(lt_eq_dyn_scalar(&array, 8).unwrap(), expected);
-    }
-
-    #[test]
-    fn test_gt_dyn_scalar() {
-        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
-        let a_eq = gt_dyn_scalar(&array, 8).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(false), Some(false), Some(false), Some(false), Some(true)]
-            )
-        );
-    }
-
-    #[test]
-    fn test_gt_dyn_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(123).unwrap();
-        builder.append_null();
-        builder.append(23).unwrap();
-        let array = builder.finish();
-        let a_eq = gt_dyn_scalar(&array, 23).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(true), None, Some(false)])
-        );
-    }
-
-    #[test]
-    fn test_gt_dyn_scalar_float() {
-        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
-            .into_iter()
-            .map(Some)
-            .collect();
-        let expected = BooleanArray::from(
-            vec![Some(false), Some(false), Some(false), Some(false), Some(true)],
-        );
-        assert_eq!(gt_dyn_scalar(&array, 8).unwrap(), expected);
-
-        let array: ArrayRef = Arc::new(array);
-        let array = crate::compute::cast(&array, &DataType::Float64).unwrap();
-        assert_eq!(gt_dyn_scalar(&array, 8).unwrap(), expected);
-    }
-
-    #[test]
-    fn test_gt_eq_dyn_scalar() {
-        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
-        let a_eq = gt_eq_dyn_scalar(&array, 8).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(false), Some(false), Some(true), Some(true), Some(true)]
-            )
-        );
-    }
-
-    #[test]
-    fn test_gt_eq_dyn_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(22).unwrap();
-        builder.append_null();
-        builder.append(23).unwrap();
-        let array = builder.finish();
-        let a_eq = gt_eq_dyn_scalar(&array, 23).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(false), None, Some(true)])
-        );
-    }
-
-    #[test]
-    fn test_gt_eq_dyn_scalar_float() {
-        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
-            .into_iter()
-            .map(Some)
-            .collect();
-        let expected = BooleanArray::from(
-            vec![Some(false), Some(false), Some(true), Some(true), Some(true)],
-        );
-        assert_eq!(gt_eq_dyn_scalar(&array, 8).unwrap(), expected);
-
-        let array: ArrayRef = Arc::new(array);
-        let array = crate::compute::cast(&array, &DataType::Float64).unwrap();
-        assert_eq!(gt_eq_dyn_scalar(&array, 8).unwrap(), expected);
-    }
-
-    #[test]
-    fn test_neq_dyn_scalar() {
-        let array = Int32Array::from(vec![6, 7, 8, 8, 10]);
-        let a_eq = neq_dyn_scalar(&array, 8).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(true), Some(true), Some(false), Some(false), Some(true)]
-            )
-        );
-    }
-
-    #[test]
-    fn test_neq_dyn_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<Int32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
-        builder.append(22).unwrap();
-        builder.append_null();
-        builder.append(23).unwrap();
-        let array = builder.finish();
-        let a_eq = neq_dyn_scalar(&array, 23).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(true), None, Some(false)])
-        );
-    }
-
-    #[test]
-    fn test_neq_dyn_scalar_float() {
-        let array: Float32Array = vec![6.0, 7.0, 8.0, 8.0, 10.0]
-            .into_iter()
-            .map(Some)
-            .collect();
-        let expected = BooleanArray::from(
-            vec![Some(true), Some(true), Some(false), Some(false), Some(true)],
-        );
-        assert_eq!(neq_dyn_scalar(&array, 8).unwrap(), expected);
-
-        let array: ArrayRef = Arc::new(array);
-        let array = crate::compute::cast(&array, &DataType::Float64).unwrap();
-        assert_eq!(neq_dyn_scalar(&array, 8).unwrap(), expected);
-    }
-
-    #[test]
-    fn test_eq_dyn_binary_scalar() {
-        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
-        let array = BinaryArray::from(data.clone());
-        let large_array = LargeBinaryArray::from(data);
-        let scalar = "flight".as_bytes();
-        let expected = BooleanArray::from(
-            vec![Some(false), Some(false), Some(true), Some(false), Some(false), None],
-        );
-
-        assert_eq!(eq_dyn_binary_scalar(&array, scalar).unwrap(), expected);
-        assert_eq!(
-            eq_dyn_binary_scalar(&large_array, scalar).unwrap(),
-            expected
-        );
-    }
-
-    #[test]
-    fn test_neq_dyn_binary_scalar() {
-        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
-        let array = BinaryArray::from(data.clone());
-        let large_array = LargeBinaryArray::from(data);
-        let scalar = "flight".as_bytes();
-        let expected = BooleanArray::from(
-            vec![Some(true), Some(true), Some(false), Some(true), Some(true), None],
-        );
-
-        assert_eq!(neq_dyn_binary_scalar(&array, scalar).unwrap(), expected);
-        assert_eq!(
-            neq_dyn_binary_scalar(&large_array, scalar).unwrap(),
-            expected
-        );
-    }
-
-    #[test]
-    fn test_lt_dyn_binary_scalar() {
-        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
-        let array = BinaryArray::from(data.clone());
-        let large_array = LargeBinaryArray::from(data);
-        let scalar = "flight".as_bytes();
-        let expected = BooleanArray::from(
-            vec![Some(true), Some(true), Some(false), Some(false), Some(false), None],
-        );
-
-        assert_eq!(lt_dyn_binary_scalar(&array, scalar).unwrap(), expected);
-        assert_eq!(
-            lt_dyn_binary_scalar(&large_array, scalar).unwrap(),
-            expected
-        );
-    }
-
-    #[test]
-    fn test_lt_eq_dyn_binary_scalar() {
-        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
-        let array = BinaryArray::from(data.clone());
-        let large_array = LargeBinaryArray::from(data);
-        let scalar = "flight".as_bytes();
-        let expected = BooleanArray::from(
-            vec![Some(true), Some(true), Some(true), Some(false), Some(false), None],
-        );
-
-        assert_eq!(lt_eq_dyn_binary_scalar(&array, scalar).unwrap(), expected);
-        assert_eq!(
-            lt_eq_dyn_binary_scalar(&large_array, scalar).unwrap(),
-            expected
-        );
-    }
-
-    #[test]
-    fn test_gt_dyn_binary_scalar() {
-        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
-        let array = BinaryArray::from(data.clone());
-        let large_array = LargeBinaryArray::from(data);
-        let scalar = "flight".as_bytes();
-        let expected = BooleanArray::from(
-            vec![Some(false), Some(false), Some(false), Some(true), Some(true), None],
-        );
-
-        assert_eq!(gt_dyn_binary_scalar(&array, scalar).unwrap(), expected);
-        assert_eq!(
-            gt_dyn_binary_scalar(&large_array, scalar).unwrap(),
-            expected
-        );
-    }
-
-    #[test]
-    fn test_gt_eq_dyn_binary_scalar() {
-        let data: Vec<Option<&[u8]>> = vec![Some(b"arrow"), Some(b"datafusion"), Some(b"flight"), Some(b"parquet"), Some(&[0xff, 0xf8]), None];
-        let array = BinaryArray::from(data.clone());
-        let large_array = LargeBinaryArray::from(data);
-        let scalar = &[0xff, 0xf8];
-        let expected = BooleanArray::from(
-            vec![Some(false), Some(false), Some(false), Some(false), Some(true), None],
-        );
-
-        assert_eq!(gt_eq_dyn_binary_scalar(&array, scalar).unwrap(), expected);
-        assert_eq!(
-            gt_eq_dyn_binary_scalar(&large_array, scalar).unwrap(),
-            expected
-        );
-    }
-
-    #[test]
-    fn test_eq_dyn_utf8_scalar() {
-        let array = StringArray::from(vec!["abc", "def", "xyz"]);
-        let a_eq = eq_dyn_utf8_scalar(&array, "xyz").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(false), Some(false), Some(true)])
-        );
-    }
-
-    #[test]
-    fn test_eq_dyn_utf8_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = StringBuilder::new(100);
-        let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
-        builder.append("abc").unwrap();
-        builder.append_null();
-        builder.append("def").unwrap();
-        builder.append("def").unwrap();
-        builder.append("abc").unwrap();
-        let array = builder.finish();
-        let a_eq = eq_dyn_utf8_scalar(&array, "def").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(false), None, Some(true), Some(true), Some(false)]
-            )
-        );
-    }
-    #[test]
-    fn test_lt_dyn_utf8_scalar() {
-        let array = StringArray::from(vec!["abc", "def", "xyz"]);
-        let a_eq = lt_dyn_utf8_scalar(&array, "xyz").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(true), Some(true), Some(false)])
-        );
-    }
-    #[test]
-    fn test_lt_dyn_utf8_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = StringBuilder::new(100);
-        let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
-        builder.append("abc").unwrap();
-        builder.append_null();
-        builder.append("def").unwrap();
-        builder.append("def").unwrap();
-        builder.append("abc").unwrap();
-        let array = builder.finish();
-        let a_eq = lt_dyn_utf8_scalar(&array, "def").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(true), None, Some(false), Some(false), Some(true)]
-            )
-        );
-    }
-
-    #[test]
-    fn test_lt_eq_dyn_utf8_scalar() {
-        let array = StringArray::from(vec!["abc", "def", "xyz"]);
-        let a_eq = lt_eq_dyn_utf8_scalar(&array, "def").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(true), Some(true), Some(false)])
-        );
-    }
-    #[test]
-    fn test_lt_eq_dyn_utf8_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = StringBuilder::new(100);
-        let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
-        builder.append("abc").unwrap();
-        builder.append_null();
-        builder.append("def").unwrap();
-        builder.append("def").unwrap();
-        builder.append("xyz").unwrap();
-        let array = builder.finish();
-        let a_eq = lt_eq_dyn_utf8_scalar(&array, "def").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(true), None, Some(true), Some(true), Some(false)]
-            )
-        );
-    }
-
-    #[test]
-    fn test_gt_eq_dyn_utf8_scalar() {
-        let array = StringArray::from(vec!["abc", "def", "xyz"]);
-        let a_eq = gt_eq_dyn_utf8_scalar(&array, "def").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(false), Some(true), Some(true)])
-        );
-    }
-    #[test]
-    fn test_gt_eq_dyn_utf8_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = StringBuilder::new(100);
-        let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
-        builder.append("abc").unwrap();
-        builder.append_null();
-        builder.append("def").unwrap();
-        builder.append("def").unwrap();
-        builder.append("xyz").unwrap();
-        let array = builder.finish();
-        let a_eq = gt_eq_dyn_utf8_scalar(&array, "def").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(false), None, Some(true), Some(true), Some(true)]
-            )
-        );
-    }
-
-    #[test]
-    fn test_gt_dyn_utf8_scalar() {
-        let array = StringArray::from(vec!["abc", "def", "xyz"]);
-        let a_eq = gt_dyn_utf8_scalar(&array, "def").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(false), Some(false), Some(true)])
-        );
-    }
-
-    #[test]
-    fn test_gt_dyn_utf8_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = StringBuilder::new(100);
-        let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
-        builder.append("abc").unwrap();
-        builder.append_null();
-        builder.append("def").unwrap();
-        builder.append("def").unwrap();
-        builder.append("xyz").unwrap();
-        let array = builder.finish();
-        let a_eq = gt_dyn_utf8_scalar(&array, "def").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(false), None, Some(false), Some(false), Some(true)]
-            )
-        );
-    }
-
-    #[test]
-    fn test_neq_dyn_utf8_scalar() {
-        let array = StringArray::from(vec!["abc", "def", "xyz"]);
-        let a_eq = neq_dyn_utf8_scalar(&array, "xyz").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(true), Some(true), Some(false)])
-        );
-    }
-    #[test]
-    fn test_neq_dyn_utf8_scalar_with_dict() {
-        let key_builder = PrimitiveBuilder::<Int8Type>::new(3);
-        let value_builder = StringBuilder::new(100);
-        let mut builder = StringDictionaryBuilder::new(key_builder, value_builder);
-        builder.append("abc").unwrap();
-        builder.append_null();
-        builder.append("def").unwrap();
-        builder.append("def").unwrap();
-        builder.append("abc").unwrap();
-        let array = builder.finish();
-        let a_eq = neq_dyn_utf8_scalar(&array, "def").unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(
-                vec![Some(true), None, Some(false), Some(false), Some(true)]
-            )
-        );
-    }
-
-    #[test]
-    fn test_eq_dyn_bool_scalar() {
-        let array = BooleanArray::from(vec![true, false, true]);
-        let a_eq = eq_dyn_bool_scalar(&array, false).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(false), Some(true), Some(false)])
-        );
-    }
-
-    #[test]
-    fn test_lt_dyn_bool_scalar() {
-        let array = BooleanArray::from(vec![Some(true), Some(false), Some(true), None]);
-        let a_eq = lt_dyn_bool_scalar(&array, false).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(false), Some(false), Some(false), None])
-        );
-    }
-
-    #[test]
-    fn test_gt_dyn_bool_scalar() {
-        let array = BooleanArray::from(vec![true, false, true]);
-        let a_eq = gt_dyn_bool_scalar(&array, false).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(true), Some(false), Some(true)])
-        );
-    }
-
-    #[test]
-    fn test_lt_eq_dyn_bool_scalar() {
-        let array = BooleanArray::from(vec![true, false, true]);
-        let a_eq = lt_eq_dyn_bool_scalar(&array, false).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(false), Some(true), Some(false)])
-        );
-    }
-
-    #[test]
-    fn test_gt_eq_dyn_bool_scalar() {
-        let array = BooleanArray::from(vec![true, false, true]);
-        let a_eq = gt_eq_dyn_bool_scalar(&array, false).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(true), Some(true), Some(true)])
-        );
-    }
-
-    #[test]
-    fn test_neq_dyn_bool_scalar() {
-        let array = BooleanArray::from(vec![true, false, true]);
-        let a_eq = neq_dyn_bool_scalar(&array, false).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(true), Some(false), Some(true)])
-        );
-    }
-
-    #[test]
-    fn test_eq_dyn_neq_dyn_dictionary_i8_array() {
-        // Construct a value array
-        let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
-
-        let keys1 = Int8Array::from_iter_values([2_i8, 3, 4]);
-        let keys2 = Int8Array::from_iter_values([2_i8, 4, 4]);
-        let dict_array1 = DictionaryArray::try_new(&keys1, &values).unwrap();
-        let dict_array2 = DictionaryArray::try_new(&keys2, &values).unwrap();
-
-        let result = eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
-
-        let result = neq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![false, true, false])
-        );
-    }
-
-    #[test]
-    fn test_eq_dyn_neq_dyn_dictionary_u64_array() {
-        let values = UInt64Array::from_iter_values([10_u64, 11, 12, 13, 14, 15, 16, 17]);
-
-        let keys1 = UInt64Array::from_iter_values([1_u64, 3, 4]);
-        let keys2 = UInt64Array::from_iter_values([2_u64, 3, 5]);
-        let dict_array1 =
-            DictionaryArray::<UInt64Type>::try_new(&keys1, &values).unwrap();
-        let dict_array2 =
-            DictionaryArray::<UInt64Type>::try_new(&keys2, &values).unwrap();
-
-        let result = eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![false, true, false])
-        );
-
-        let result = neq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
-    }
-
-    #[test]
-    fn test_eq_dyn_neq_dyn_dictionary_utf8_array() {
-        let test1 = vec!["a", "a", "b", "c"];
-        let test2 = vec!["a", "b", "b", "c"];
-
-        let dict_array1: DictionaryArray<Int8Type> = test1
-            .iter()
-            .map(|&x| if x == "b" { None } else { Some(x) })
-            .collect();
-        let dict_array2: DictionaryArray<Int8Type> = test2
-            .iter()
-            .map(|&x| if x == "b" { None } else { Some(x) })
-            .collect();
-
-        let result = eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![Some(true), None, None, Some(true)])
-        );
-
-        let result = neq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![Some(false), None, None, Some(false)])
-        );
-    }
-
-    #[test]
-    fn test_eq_dyn_neq_dyn_dictionary_binary_array() {
-        let values: BinaryArray = ["hello", "", "parquet"]
-            .into_iter()
-            .map(|b| Some(b.as_bytes()))
-            .collect();
-
-        let keys1 = UInt64Array::from_iter_values([0_u64, 1, 2]);
-        let keys2 = UInt64Array::from_iter_values([0_u64, 2, 1]);
-        let dict_array1 =
-            DictionaryArray::<UInt64Type>::try_new(&keys1, &values).unwrap();
-        let dict_array2 =
-            DictionaryArray::<UInt64Type>::try_new(&keys2, &values).unwrap();
-
-        let result = eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![true, false, false])
-        );
-
-        let result = neq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
-    }
-
-    #[test]
-    fn test_eq_dyn_neq_dyn_dictionary_interval_array() {
-        let values = IntervalDayTimeArray::from(vec![1, 6, 10, 2, 3, 5]);
-
-        let keys1 = UInt64Array::from_iter_values([1_u64, 0, 3]);
-        let keys2 = UInt64Array::from_iter_values([2_u64, 0, 3]);
-        let dict_array1 =
-            DictionaryArray::<UInt64Type>::try_new(&keys1, &values).unwrap();
-        let dict_array2 =
-            DictionaryArray::<UInt64Type>::try_new(&keys2, &values).unwrap();
-
-        let result = eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
-
-        let result = neq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![true, false, false])
-        );
-    }
-
-    #[test]
-    fn test_eq_dyn_neq_dyn_dictionary_date_array() {
-        let values = Date32Array::from(vec![1, 6, 10, 2, 3, 5]);
-
-        let keys1 = UInt64Array::from_iter_values([1_u64, 0, 3]);
-        let keys2 = UInt64Array::from_iter_values([2_u64, 0, 3]);
-        let dict_array1 =
-            DictionaryArray::<UInt64Type>::try_new(&keys1, &values).unwrap();
-        let dict_array2 =
-            DictionaryArray::<UInt64Type>::try_new(&keys2, &values).unwrap();
-
-        let result = eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
-
-        let result = neq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![true, false, false])
-        );
-    }
-
-    #[test]
-    fn test_eq_dyn_neq_dyn_dictionary_bool_array() {
-        let values = BooleanArray::from(vec![true, false]);
-
-        let keys1 = UInt64Array::from_iter_values([1_u64, 1, 1]);
-        let keys2 = UInt64Array::from_iter_values([0_u64, 1, 0]);
-        let dict_array1 =
-            DictionaryArray::<UInt64Type>::try_new(&keys1, &values).unwrap();
-        let dict_array2 =
-            DictionaryArray::<UInt64Type>::try_new(&keys2, &values).unwrap();
-
-        let result = eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![false, true, false])
-        );
-
-        let result = neq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
-    }
-
-    #[test]
-    fn test_lt_dyn_gt_dyn_dictionary_i8_array() {
-        // Construct a value array
-        let values = Int8Array::from_iter_values([10_i8, 11, 12, 13, 14, 15, 16, 17]);
-
-        let keys1 = Int8Array::from_iter_values([3_i8, 4, 4]);
-        let keys2 = Int8Array::from_iter_values([4_i8, 3, 4]);
-        let dict_array1 = DictionaryArray::try_new(&keys1, &values).unwrap();
-        let dict_array2 = DictionaryArray::try_new(&keys2, &values).unwrap();
-
-        let result = lt_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![true, false, false])
-        );
-
-        let result = lt_eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(result.unwrap(), BooleanArray::from(vec![true, false, true]));
-
-        let result = gt_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![false, true, false])
-        );
-
-        let result = gt_eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
-    }
-
-    #[test]
-    fn test_lt_dyn_gt_dyn_dictionary_bool_array() {
-        let values = BooleanArray::from(vec![true, false]);
-
-        let keys1 = UInt64Array::from_iter_values([1_u64, 1, 0]);
-        let keys2 = UInt64Array::from_iter_values([0_u64, 1, 1]);
-        let dict_array1 =
-            DictionaryArray::<UInt64Type>::try_new(&keys1, &values).unwrap();
-        let dict_array2 =
-            DictionaryArray::<UInt64Type>::try_new(&keys2, &values).unwrap();
-
-        let result = lt_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![true, false, false])
-        );
-
-        let result = lt_eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(result.unwrap(), BooleanArray::from(vec![true, true, false]));
-
-        let result = gt_dyn(&dict_array1, &dict_array2);
-        assert_eq!(
-            result.unwrap(),
-            BooleanArray::from(vec![false, false, true])
-        );
-
-        let result = gt_eq_dyn(&dict_array1, &dict_array2);
-        assert_eq!(result.unwrap(), BooleanArray::from(vec![false, true, true]));
-    }
-
-    #[test]
-    fn test_unary_cmp() {
-        let a = Int32Array::from(vec![Some(1), None, Some(2), Some(3)]);
-        let values = vec![1_i32, 3];
-
-        let a_eq = unary_cmp(&a, |a| values.contains(&a)).unwrap();
-        assert_eq!(
-            a_eq,
-            BooleanArray::from(vec![Some(true), None, Some(false), Some(true)])
-        );
-    }
-}
diff --git a/arrow/src/compute/kernels/concat.rs b/arrow/src/compute/kernels/concat.rs
deleted file mode 100644
index a7a3ffc782c6..000000000000
--- a/arrow/src/compute/kernels/concat.rs
+++ /dev/null
@@ -1,572 +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.
-
-//! Defines concat kernel for `ArrayRef`
-//!
-//! Example:
-//!
-//! ```
-//! use arrow::array::{ArrayRef, StringArray};
-//! use arrow::compute::concat;
-//!
-//! let arr = concat(&[
-//!     &StringArray::from(vec!["hello", "world"]),
-//!     &StringArray::from(vec!["!"]),
-//! ]).unwrap();
-//! assert_eq!(arr.len(), 3);
-//! ```
-
-use crate::array::*;
-use crate::datatypes::DataType;
-use crate::error::{ArrowError, Result};
-
-fn compute_str_values_length<Offset: OffsetSizeTrait>(arrays: &[&ArrayData]) -> usize {
-    arrays
-        .iter()
-        .map(|&data| {
-            // get the length of the value buffer
-            let buf_len = data.buffers()[1].len();
-            // find the offset of the buffer
-            // this returns a slice of offsets, starting from the offset of the array
-            // so we can take the first value
-            let offset = data.buffer::<Offset>(0)[0];
-            buf_len - offset.to_usize().unwrap()
-        })
-        .sum()
-}
-
-/// Concatenate multiple [Array] of the same type into a single [ArrayRef].
-pub fn concat(arrays: &[&dyn Array]) -> Result<ArrayRef> {
-    if arrays.is_empty() {
-        return Err(ArrowError::ComputeError(
-            "concat requires input of at least one array".to_string(),
-        ));
-    } else if arrays.len() == 1 {
-        let array = arrays[0];
-        return Ok(array.slice(0, array.len()));
-    }
-
-    if arrays
-        .iter()
-        .any(|array| array.data_type() != arrays[0].data_type())
-    {
-        return Err(ArrowError::InvalidArgumentError(
-            "It is not possible to concatenate arrays of different data types."
-                .to_string(),
-        ));
-    }
-
-    let lengths = arrays.iter().map(|array| array.len()).collect::<Vec<_>>();
-    let capacity = lengths.iter().sum();
-
-    let arrays = arrays.iter().map(|a| a.data()).collect::<Vec<_>>();
-
-    let mut mutable = match arrays[0].data_type() {
-        DataType::Utf8 => {
-            let str_values_size = compute_str_values_length::<i32>(&arrays);
-            MutableArrayData::with_capacities(
-                arrays,
-                false,
-                Capacities::Binary(capacity, Some(str_values_size)),
-            )
-        }
-        DataType::LargeUtf8 => {
-            let str_values_size = compute_str_values_length::<i64>(&arrays);
-            MutableArrayData::with_capacities(
-                arrays,
-                false,
-                Capacities::Binary(capacity, Some(str_values_size)),
-            )
-        }
-        _ => MutableArrayData::new(arrays, false, capacity),
-    };
-
-    for (i, len) in lengths.iter().enumerate() {
-        mutable.extend(i, 0, *len)
-    }
-
-    Ok(make_array(mutable.freeze()))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::datatypes::*;
-    use std::sync::Arc;
-
-    #[test]
-    fn test_concat_empty_vec() {
-        let re = concat(&[]);
-        assert!(re.is_err());
-    }
-
-    #[test]
-    fn test_concat_one_element_vec() -> Result<()> {
-        let arr = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
-            Some(-1),
-            Some(2),
-            None,
-        ])) as ArrayRef;
-        let result = concat(&[arr.as_ref()])?;
-        assert_eq!(
-            &arr, &result,
-            "concatenating single element array gives back the same result"
-        );
-        Ok(())
-    }
-
-    #[test]
-    fn test_concat_incompatible_datatypes() {
-        let re = concat(&[
-            &PrimitiveArray::<Int64Type>::from(vec![Some(-1), Some(2), None]),
-            &StringArray::from(vec![Some("hello"), Some("bar"), Some("world")]),
-        ]);
-        assert!(re.is_err());
-    }
-
-    #[test]
-    fn test_concat_string_arrays() -> Result<()> {
-        let arr = concat(&[
-            &StringArray::from(vec!["hello", "world"]),
-            &StringArray::from(vec!["2", "3", "4"]),
-            &StringArray::from(vec![Some("foo"), Some("bar"), None, Some("baz")]),
-        ])?;
-
-        let expected_output = Arc::new(StringArray::from(vec![
-            Some("hello"),
-            Some("world"),
-            Some("2"),
-            Some("3"),
-            Some("4"),
-            Some("foo"),
-            Some("bar"),
-            None,
-            Some("baz"),
-        ])) as ArrayRef;
-
-        assert_eq!(&arr, &expected_output);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_concat_primitive_arrays() -> Result<()> {
-        let arr = concat(&[
-            &PrimitiveArray::<Int64Type>::from(vec![
-                Some(-1),
-                Some(-1),
-                Some(2),
-                None,
-                None,
-            ]),
-            &PrimitiveArray::<Int64Type>::from(vec![
-                Some(101),
-                Some(102),
-                Some(103),
-                None,
-            ]),
-            &PrimitiveArray::<Int64Type>::from(vec![Some(256), Some(512), Some(1024)]),
-        ])?;
-
-        let expected_output = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
-            Some(-1),
-            Some(-1),
-            Some(2),
-            None,
-            None,
-            Some(101),
-            Some(102),
-            Some(103),
-            None,
-            Some(256),
-            Some(512),
-            Some(1024),
-        ])) as ArrayRef;
-
-        assert_eq!(&arr, &expected_output);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_concat_primitive_array_slices() -> Result<()> {
-        let input_1 = PrimitiveArray::<Int64Type>::from(vec![
-            Some(-1),
-            Some(-1),
-            Some(2),
-            None,
-            None,
-        ])
-        .slice(1, 3);
-
-        let input_2 = PrimitiveArray::<Int64Type>::from(vec![
-            Some(101),
-            Some(102),
-            Some(103),
-            None,
-        ])
-        .slice(1, 3);
-        let arr = concat(&[input_1.as_ref(), input_2.as_ref()])?;
-
-        let expected_output = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
-            Some(-1),
-            Some(2),
-            None,
-            Some(102),
-            Some(103),
-            None,
-        ])) as ArrayRef;
-
-        assert_eq!(&arr, &expected_output);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_concat_boolean_primitive_arrays() -> Result<()> {
-        let arr = concat(&[
-            &BooleanArray::from(vec![
-                Some(true),
-                Some(true),
-                Some(false),
-                None,
-                None,
-                Some(false),
-            ]),
-            &BooleanArray::from(vec![None, Some(false), Some(true), Some(false)]),
-        ])?;
-
-        let expected_output = Arc::new(BooleanArray::from(vec![
-            Some(true),
-            Some(true),
-            Some(false),
-            None,
-            None,
-            Some(false),
-            None,
-            Some(false),
-            Some(true),
-            Some(false),
-        ])) as ArrayRef;
-
-        assert_eq!(&arr, &expected_output);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_concat_primitive_list_arrays() -> Result<()> {
-        let list1 = vec![
-            Some(vec![Some(-1), Some(-1), Some(2), None, None]),
-            Some(vec![]),
-            None,
-            Some(vec![Some(10)]),
-        ];
-        let list1_array =
-            ListArray::from_iter_primitive::<Int64Type, _, _>(list1.clone());
-
-        let list2 = vec![
-            None,
-            Some(vec![Some(100), None, Some(101)]),
-            Some(vec![Some(102)]),
-        ];
-        let list2_array =
-            ListArray::from_iter_primitive::<Int64Type, _, _>(list2.clone());
-
-        let list3 = vec![Some(vec![Some(1000), Some(1001)])];
-        let list3_array =
-            ListArray::from_iter_primitive::<Int64Type, _, _>(list3.clone());
-
-        let array_result = concat(&[&list1_array, &list2_array, &list3_array])?;
-
-        let expected = list1
-            .into_iter()
-            .chain(list2.into_iter())
-            .chain(list3.into_iter());
-        let array_expected = ListArray::from_iter_primitive::<Int64Type, _, _>(expected);
-
-        assert_eq!(array_result.as_ref(), &array_expected as &dyn Array);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_concat_struct_arrays() -> Result<()> {
-        let field = Field::new("field", DataType::Int64, true);
-        let input_primitive_1: ArrayRef =
-            Arc::new(PrimitiveArray::<Int64Type>::from(vec![
-                Some(-1),
-                Some(-1),
-                Some(2),
-                None,
-                None,
-            ]));
-        let input_struct_1 = StructArray::from(vec![(field.clone(), input_primitive_1)]);
-
-        let input_primitive_2: ArrayRef =
-            Arc::new(PrimitiveArray::<Int64Type>::from(vec![
-                Some(101),
-                Some(102),
-                Some(103),
-                None,
-            ]));
-        let input_struct_2 = StructArray::from(vec![(field.clone(), input_primitive_2)]);
-
-        let input_primitive_3: ArrayRef =
-            Arc::new(PrimitiveArray::<Int64Type>::from(vec![
-                Some(256),
-                Some(512),
-                Some(1024),
-            ]));
-        let input_struct_3 = StructArray::from(vec![(field, input_primitive_3)]);
-
-        let arr = concat(&[&input_struct_1, &input_struct_2, &input_struct_3])?;
-
-        let expected_primitive_output = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
-            Some(-1),
-            Some(-1),
-            Some(2),
-            None,
-            None,
-            Some(101),
-            Some(102),
-            Some(103),
-            None,
-            Some(256),
-            Some(512),
-            Some(1024),
-        ])) as ArrayRef;
-
-        let actual_primitive = arr
-            .as_any()
-            .downcast_ref::<StructArray>()
-            .unwrap()
-            .column(0);
-        assert_eq!(actual_primitive, &expected_primitive_output);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_concat_struct_array_slices() -> Result<()> {
-        let field = Field::new("field", DataType::Int64, true);
-        let input_primitive_1: ArrayRef =
-            Arc::new(PrimitiveArray::<Int64Type>::from(vec![
-                Some(-1),
-                Some(-1),
-                Some(2),
-                None,
-                None,
-            ]));
-        let input_struct_1 = StructArray::from(vec![(field.clone(), input_primitive_1)]);
-
-        let input_primitive_2: ArrayRef =
-            Arc::new(PrimitiveArray::<Int64Type>::from(vec![
-                Some(101),
-                Some(102),
-                Some(103),
-                None,
-            ]));
-        let input_struct_2 = StructArray::from(vec![(field, input_primitive_2)]);
-
-        let arr = concat(&[
-            input_struct_1.slice(1, 3).as_ref(),
-            input_struct_2.slice(1, 2).as_ref(),
-        ])?;
-
-        let expected_primitive_output = Arc::new(PrimitiveArray::<Int64Type>::from(vec![
-            Some(-1),
-            Some(2),
-            None,
-            Some(102),
-            Some(103),
-        ])) as ArrayRef;
-
-        let actual_primitive = arr
-            .as_any()
-            .downcast_ref::<StructArray>()
-            .unwrap()
-            .column(0);
-        assert_eq!(actual_primitive, &expected_primitive_output);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_string_array_slices() -> Result<()> {
-        let input_1 = StringArray::from(vec!["hello", "A", "B", "C"]);
-        let input_2 = StringArray::from(vec!["world", "D", "E", "Z"]);
-
-        let arr = concat(&[input_1.slice(1, 3).as_ref(), input_2.slice(1, 2).as_ref()])?;
-
-        let expected_output = StringArray::from(vec!["A", "B", "C", "D", "E"]);
-
-        let actual_output = arr.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(actual_output, &expected_output);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_string_array_with_null_slices() -> Result<()> {
-        let input_1 = StringArray::from(vec![Some("hello"), None, Some("A"), Some("C")]);
-        let input_2 = StringArray::from(vec![None, Some("world"), Some("D"), None]);
-
-        let arr = concat(&[input_1.slice(1, 3).as_ref(), input_2.slice(1, 2).as_ref()])?;
-
-        let expected_output =
-            StringArray::from(vec![None, Some("A"), Some("C"), Some("world"), Some("D")]);
-
-        let actual_output = arr.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(actual_output, &expected_output);
-
-        Ok(())
-    }
-
-    fn collect_string_dictionary(
-        dictionary: &DictionaryArray<Int32Type>,
-    ) -> Vec<Option<String>> {
-        let values = dictionary.values();
-        let values = values.as_any().downcast_ref::<StringArray>().unwrap();
-
-        dictionary
-            .keys()
-            .iter()
-            .map(|key| key.map(|key| values.value(key as _).to_string()))
-            .collect()
-    }
-
-    fn concat_dictionary(
-        input_1: DictionaryArray<Int32Type>,
-        input_2: DictionaryArray<Int32Type>,
-    ) -> Vec<Option<String>> {
-        let concat = concat(&[&input_1 as _, &input_2 as _]).unwrap();
-        let concat = concat
-            .as_any()
-            .downcast_ref::<DictionaryArray<Int32Type>>()
-            .unwrap();
-
-        collect_string_dictionary(concat)
-    }
-
-    #[test]
-    fn test_string_dictionary_array() {
-        let input_1: DictionaryArray<Int32Type> =
-            vec!["hello", "A", "B", "hello", "hello", "C"]
-                .into_iter()
-                .collect();
-        let input_2: DictionaryArray<Int32Type> =
-            vec!["hello", "E", "E", "hello", "F", "E"]
-                .into_iter()
-                .collect();
-
-        let expected: Vec<_> = vec![
-            "hello", "A", "B", "hello", "hello", "C", "hello", "E", "E", "hello", "F",
-            "E",
-        ]
-        .into_iter()
-        .map(|x| Some(x.to_string()))
-        .collect();
-
-        let concat = concat_dictionary(input_1, input_2);
-        assert_eq!(concat, expected);
-    }
-
-    #[test]
-    fn test_string_dictionary_array_nulls() {
-        let input_1: DictionaryArray<Int32Type> =
-            vec![Some("foo"), Some("bar"), None, Some("fiz")]
-                .into_iter()
-                .collect();
-        let input_2: DictionaryArray<Int32Type> = vec![None].into_iter().collect();
-        let expected = vec![
-            Some("foo".to_string()),
-            Some("bar".to_string()),
-            None,
-            Some("fiz".to_string()),
-            None,
-        ];
-
-        let concat = concat_dictionary(input_1, input_2);
-        assert_eq!(concat, expected);
-    }
-
-    #[test]
-    fn test_concat_string_sizes() -> Result<()> {
-        let a: LargeStringArray = ((0..150).map(|_| Some("foo"))).collect();
-        let b: LargeStringArray = ((0..150).map(|_| Some("foo"))).collect();
-        let c = LargeStringArray::from(vec![Some("foo"), Some("bar"), None, Some("baz")]);
-        // 150 * 3 = 450
-        // 150 * 3 = 450
-        // 3 * 3   = 9
-        // ------------+
-        // 909
-        // closest 64 byte aligned cap = 960
-
-        let arr = concat(&[&a, &b, &c])?;
-        // this would have been 1280 if we did not precompute the value lengths.
-        assert_eq!(arr.data().buffers()[1].capacity(), 960);
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_dictionary_concat_reuse() {
-        let array: DictionaryArray<Int8Type> =
-            vec!["a", "a", "b", "c"].into_iter().collect();
-        let copy: DictionaryArray<Int8Type> = array.data().clone().into();
-
-        // dictionary is "a", "b", "c"
-        assert_eq!(
-            array.values(),
-            &(Arc::new(StringArray::from(vec!["a", "b", "c"])) as ArrayRef)
-        );
-        assert_eq!(array.keys(), &Int8Array::from(vec![0, 0, 1, 2]));
-
-        // concatenate it with itself
-        let combined = concat(&[&copy as _, &array as _]).unwrap();
-
-        let combined = combined
-            .as_any()
-            .downcast_ref::<DictionaryArray<Int8Type>>()
-            .unwrap();
-
-        assert_eq!(
-            combined.values(),
-            &(Arc::new(StringArray::from(vec!["a", "b", "c"])) as ArrayRef),
-            "Actual: {:#?}",
-            combined
-        );
-
-        assert_eq!(
-            combined.keys(),
-            &Int8Array::from(vec![0, 0, 1, 2, 0, 0, 1, 2])
-        );
-
-        // Should have reused the dictionary
-        assert!(array.data().child_data()[0].ptr_eq(&combined.data().child_data()[0]));
-        assert!(copy.data().child_data()[0].ptr_eq(&combined.data().child_data()[0]));
-
-        let new: DictionaryArray<Int8Type> = vec!["d"].into_iter().collect();
-        let combined = concat(&[&copy as _, &array as _, &new as _]).unwrap();
-
-        // Should not have reused the dictionary
-        assert!(!array.data().child_data()[0].ptr_eq(&combined.data().child_data()[0]));
-        assert!(!copy.data().child_data()[0].ptr_eq(&combined.data().child_data()[0]));
-        assert!(!new.data().child_data()[0].ptr_eq(&combined.data().child_data()[0]));
-    }
-}
diff --git a/arrow/src/compute/kernels/limit.rs b/arrow/src/compute/kernels/limit.rs
deleted file mode 100644
index 07cf727b09d4..000000000000
--- a/arrow/src/compute/kernels/limit.rs
+++ /dev/null
@@ -1,206 +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.
-
-//! Defines miscellaneous array kernels.
-
-use crate::array::ArrayRef;
-
-/// Returns the array, taking only the number of elements specified
-///
-/// Limit performs a zero-copy slice of the array, and is a convenience method on slice
-/// where:
-/// * it performs a bounds-check on the array
-/// * it slices from offset 0
-pub fn limit(array: &ArrayRef, num_elements: usize) -> ArrayRef {
-    let lim = num_elements.min(array.len());
-    array.slice(0, lim)
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::*;
-    use crate::buffer::Buffer;
-    use crate::datatypes::{DataType, Field};
-    use crate::util::bit_util;
-
-    use std::sync::Arc;
-
-    #[test]
-    fn test_limit_array() {
-        let a: ArrayRef = Arc::new(Int32Array::from(vec![5, 6, 7, 8, 9]));
-        let b = limit(&a, 3);
-        let c = b.as_ref().as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(3, c.len());
-        assert_eq!(5, c.value(0));
-        assert_eq!(6, c.value(1));
-        assert_eq!(7, c.value(2));
-    }
-
-    #[test]
-    fn test_limit_string_array() {
-        let a: ArrayRef = Arc::new(StringArray::from(vec!["hello", " ", "world", "!"]));
-        let b = limit(&a, 2);
-        let c = b.as_ref().as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(2, c.len());
-        assert_eq!("hello", c.value(0));
-        assert_eq!(" ", c.value(1));
-    }
-
-    #[test]
-    fn test_limit_array_with_null() {
-        let a: ArrayRef = Arc::new(Int32Array::from(vec![None, Some(5)]));
-        let b = limit(&a, 1);
-        let c = b.as_ref().as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(1, c.len());
-        assert!(c.is_null(0));
-    }
-
-    #[test]
-    fn test_limit_array_with_limit_too_large() {
-        let a = Int32Array::from(vec![5, 6, 7, 8, 9]);
-        let a_ref: ArrayRef = Arc::new(a);
-        let b = limit(&a_ref, 6);
-        let c = b.as_ref().as_any().downcast_ref::<Int32Array>().unwrap();
-
-        assert_eq!(5, c.len());
-        assert_eq!(5, c.value(0));
-        assert_eq!(6, c.value(1));
-        assert_eq!(7, c.value(2));
-        assert_eq!(8, c.value(3));
-        assert_eq!(9, c.value(4));
-    }
-
-    #[test]
-    fn test_list_array_limit() {
-        // adapted from crate::array::test::test_list_array_slice
-        // Construct a value array
-        let value_data = ArrayData::builder(DataType::Int32)
-            .len(10)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
-            .build()
-            .unwrap();
-
-        // Construct a buffer for value offsets, for the nested array:
-        //  [[0, 1], null, [2, 3], null, [4, 5], null, [6, 7, 8], null, [9]]
-        let value_offsets = Buffer::from_slice_ref(&[0, 2, 2, 4, 4, 6, 6, 9, 9, 10]);
-        // 01010101 00000001
-        let mut null_bits: [u8; 2] = [0; 2];
-        bit_util::set_bit(&mut null_bits, 0);
-        bit_util::set_bit(&mut null_bits, 2);
-        bit_util::set_bit(&mut null_bits, 4);
-        bit_util::set_bit(&mut null_bits, 6);
-        bit_util::set_bit(&mut null_bits, 8);
-
-        // Construct a list array from the above two
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_data = ArrayData::builder(list_data_type)
-            .len(9)
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .null_bit_buffer(Some(Buffer::from(null_bits)))
-            .build()
-            .unwrap();
-        let list_array: ArrayRef = Arc::new(ListArray::from(list_data));
-
-        let limit_array = limit(&list_array, 6);
-        assert_eq!(6, limit_array.len());
-        assert_eq!(0, limit_array.offset());
-        assert_eq!(3, limit_array.null_count());
-
-        // Check offset and length for each non-null value.
-        let limit_array: &ListArray =
-            limit_array.as_any().downcast_ref::<ListArray>().unwrap();
-
-        for i in 0..limit_array.len() {
-            let offset = limit_array.value_offsets()[i];
-            let length = limit_array.value_length(i);
-            if i % 2 == 0 {
-                assert_eq!(2, length);
-                assert_eq!(i as i32, offset);
-            } else {
-                assert_eq!(0, length);
-            }
-        }
-    }
-
-    #[test]
-    fn test_struct_array_limit() {
-        // adapted from crate::array::test::test_struct_array_slice
-        let boolean_data = ArrayData::builder(DataType::Boolean)
-            .len(5)
-            .add_buffer(Buffer::from([0b00010000]))
-            .null_bit_buffer(Some(Buffer::from([0b00010001])))
-            .build()
-            .unwrap();
-        let int_data = ArrayData::builder(DataType::Int32)
-            .len(5)
-            .add_buffer(Buffer::from_slice_ref(&[0, 28, 42, 0, 0]))
-            .null_bit_buffer(Some(Buffer::from([0b00000110])))
-            .build()
-            .unwrap();
-
-        let field_types = vec![
-            Field::new("a", DataType::Boolean, false),
-            Field::new("b", DataType::Int32, false),
-        ];
-        let struct_array_data = ArrayData::builder(DataType::Struct(field_types))
-            .len(5)
-            .add_child_data(boolean_data.clone())
-            .add_child_data(int_data.clone())
-            .null_bit_buffer(Some(Buffer::from([0b00010111])))
-            .build()
-            .unwrap();
-        let struct_array = StructArray::from(struct_array_data);
-
-        assert_eq!(5, struct_array.len());
-        assert_eq!(1, struct_array.null_count());
-        assert_eq!(&boolean_data, struct_array.column(0).data());
-        assert_eq!(&int_data, struct_array.column(1).data());
-
-        let array: ArrayRef = Arc::new(struct_array);
-
-        let sliced_array = limit(&array, 3);
-        let sliced_array = sliced_array.as_any().downcast_ref::<StructArray>().unwrap();
-        assert_eq!(3, sliced_array.len());
-        assert_eq!(0, sliced_array.offset());
-        assert_eq!(0, sliced_array.null_count());
-        assert!(sliced_array.is_valid(0));
-        assert!(sliced_array.is_valid(1));
-        assert!(sliced_array.is_valid(2));
-
-        let sliced_c0 = sliced_array.column(0);
-        let sliced_c0 = sliced_c0.as_any().downcast_ref::<BooleanArray>().unwrap();
-        assert_eq!(3, sliced_c0.len());
-        assert_eq!(0, sliced_c0.offset());
-        assert_eq!(2, sliced_c0.null_count());
-        assert!(sliced_c0.is_valid(0));
-        assert!(sliced_c0.is_null(1));
-        assert!(sliced_c0.is_null(2));
-        assert!(!sliced_c0.value(0));
-
-        let sliced_c1 = sliced_array.column(1);
-        let sliced_c1 = sliced_c1.as_any().downcast_ref::<Int32Array>().unwrap();
-        assert_eq!(3, sliced_c1.len());
-        assert_eq!(0, sliced_c1.offset());
-        assert_eq!(1, sliced_c1.null_count());
-        assert!(sliced_c1.is_null(0));
-        assert_eq!(28, sliced_c1.value(1));
-        assert_eq!(42, sliced_c1.value(2));
-    }
-}
diff --git a/arrow/src/compute/kernels/partition.rs b/arrow/src/compute/kernels/partition.rs
deleted file mode 100644
index e3a1497b8d27..000000000000
--- a/arrow/src/compute/kernels/partition.rs
+++ /dev/null
@@ -1,408 +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.
-
-//! Defines partition kernel for `ArrayRef`
-
-use crate::compute::kernels::sort::LexicographicalComparator;
-use crate::compute::SortColumn;
-use crate::error::{ArrowError, Result};
-use std::cmp::Ordering;
-use std::iter::Iterator;
-use std::ops::Range;
-
-/// Given a list of already sorted columns, find partition ranges that would partition
-/// lexicographically equal values across columns.
-///
-/// Here LexicographicalComparator is used in conjunction with binary
-/// search so the columns *MUST* be pre-sorted already.
-///
-/// The returned vec would be of size k where k is cardinality of the sorted values; Consecutive
-/// values will be connected: (a, b) and (b, c), where start = 0 and end = n for the first and last
-/// range.
-pub fn lexicographical_partition_ranges(
-    columns: &[SortColumn],
-) -> Result<impl Iterator<Item = Range<usize>> + '_> {
-    LexicographicalPartitionIterator::try_new(columns)
-}
-
-struct LexicographicalPartitionIterator<'a> {
-    comparator: LexicographicalComparator<'a>,
-    num_rows: usize,
-    previous_partition_point: usize,
-    partition_point: usize,
-}
-
-impl<'a> LexicographicalPartitionIterator<'a> {
-    fn try_new(columns: &'a [SortColumn]) -> Result<LexicographicalPartitionIterator> {
-        if columns.is_empty() {
-            return Err(ArrowError::InvalidArgumentError(
-                "Sort requires at least one column".to_string(),
-            ));
-        }
-        let num_rows = columns[0].values.len();
-        if columns.iter().any(|item| item.values.len() != num_rows) {
-            return Err(ArrowError::ComputeError(
-                "Lexical sort columns have different row counts".to_string(),
-            ));
-        };
-
-        let comparator = LexicographicalComparator::try_new(columns)?;
-        Ok(LexicographicalPartitionIterator {
-            comparator,
-            num_rows,
-            previous_partition_point: 0,
-            partition_point: 0,
-        })
-    }
-}
-
-/// Returns the next partition point of the range `start..end` according to the given comparator.
-/// The return value is the index of the first element of the second partition,
-/// and is guaranteed to be between `start..=end` (inclusive).
-///
-/// The values corresponding to those indices are assumed to be partitioned according to the given comparator.
-///
-/// Exponential search is to remedy for the case when array size and cardinality are both large.
-/// In these cases the partition point would be near the beginning of the range and
-/// plain binary search would be doing some unnecessary iterations on each call.
-///
-/// see <https://en.wikipedia.org/wiki/Exponential_search>
-#[inline]
-fn exponential_search_next_partition_point(
-    start: usize,
-    end: usize,
-    comparator: &LexicographicalComparator<'_>,
-) -> usize {
-    let target = start;
-    let mut bound = 1;
-    while bound + start < end
-        && comparator.compare(&(bound + start), &target) != Ordering::Greater
-    {
-        bound *= 2;
-    }
-
-    // invariant after while loop:
-    // (start + bound / 2) <= target < min(end, start + bound + 1)
-    // where <= and < are defined by the comparator;
-    // note here we have right = min(end, start + bound + 1) because (start + bound) might
-    // actually be considered and must be included.
-    partition_point(start + bound / 2, end.min(start + bound + 1), |idx| {
-        comparator.compare(&idx, &target) != Ordering::Greater
-    })
-}
-
-/// Returns the partition point of the range `start..end` according to the given predicate.
-/// The return value is the index of the first element of the second partition,
-/// and is guaranteed to be between `start..=end` (inclusive).
-///
-/// The algorithm is similar to a binary search.
-///
-/// The values corresponding to those indices are assumed to be partitioned according to the given predicate.
-///
-/// See [`slice::partition_point`]
-#[inline]
-fn partition_point<P: Fn(usize) -> bool>(start: usize, end: usize, pred: P) -> usize {
-    let mut left = start;
-    let mut right = end;
-    let mut size = right - left;
-    while left < right {
-        let mid = left + size / 2;
-
-        let less = pred(mid);
-
-        if less {
-            left = mid + 1;
-        } else {
-            right = mid;
-        }
-
-        size = right - left;
-    }
-    left
-}
-
-impl<'a> Iterator for LexicographicalPartitionIterator<'a> {
-    type Item = Range<usize>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if self.partition_point < self.num_rows {
-            // invariant:
-            // in the range [0..previous_partition_point] all values are <= the value at [previous_partition_point]
-            // so in order to save time we can do binary search on the range [previous_partition_point..num_rows]
-            // and find the index where any value is greater than the value at [previous_partition_point]
-            self.partition_point = exponential_search_next_partition_point(
-                self.partition_point,
-                self.num_rows,
-                &self.comparator,
-            );
-            let start = self.previous_partition_point;
-            let end = self.partition_point;
-            self.previous_partition_point = self.partition_point;
-            Some(Range { start, end })
-        } else {
-            None
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::*;
-    use crate::compute::SortOptions;
-    use crate::datatypes::DataType;
-    use std::sync::Arc;
-
-    #[test]
-    fn test_partition_point() {
-        let input = &[1, 1, 1, 2, 2, 2, 2, 2, 2, 3, 3, 3, 4];
-        {
-            let median = input[input.len() / 2];
-            assert_eq!(
-                9,
-                partition_point(
-                    0,
-                    input.len(),
-                    &(|i: usize| input[i].cmp(&median) != Ordering::Greater)
-                )
-            );
-        }
-        {
-            let search = input[9];
-            assert_eq!(
-                12,
-                partition_point(
-                    9,
-                    input.len(),
-                    &(|i: usize| input[i].cmp(&search) != Ordering::Greater)
-                )
-            );
-        }
-        {
-            let search = input[0];
-            assert_eq!(
-                3,
-                partition_point(
-                    0,
-                    9,
-                    &(|i: usize| input[i].cmp(&search) != Ordering::Greater)
-                )
-            );
-        }
-        let input = &[1, 2, 2, 2, 2, 2, 2, 2, 9];
-        {
-            let search = input[5];
-            assert_eq!(
-                8,
-                partition_point(
-                    5,
-                    9,
-                    &(|i: usize| input[i].cmp(&search) != Ordering::Greater)
-                )
-            );
-        }
-    }
-
-    #[test]
-    fn test_lexicographical_partition_ranges_empty() {
-        let input = vec![];
-        assert!(
-            lexicographical_partition_ranges(&input).is_err(),
-            "lexicographical_partition_ranges should reject columns with empty rows"
-        );
-    }
-
-    #[test]
-    fn test_lexicographical_partition_ranges_unaligned_rows() {
-        let input = vec![
-            SortColumn {
-                values: Arc::new(Int64Array::from(vec![None, Some(-1)])) as ArrayRef,
-                options: None,
-            },
-            SortColumn {
-                values: Arc::new(StringArray::from(vec![Some("foo")])) as ArrayRef,
-                options: None,
-            },
-        ];
-        assert!(
-            lexicographical_partition_ranges(&input).is_err(),
-            "lexicographical_partition_ranges should reject columns with different row counts"
-        );
-    }
-
-    #[test]
-    fn test_lexicographical_partition_single_column() -> Result<()> {
-        let input = vec![SortColumn {
-            values: Arc::new(Int64Array::from(vec![1, 2, 2, 2, 2, 2, 2, 2, 9]))
-                as ArrayRef,
-            options: Some(SortOptions {
-                descending: false,
-                nulls_first: true,
-            }),
-        }];
-        {
-            let results = lexicographical_partition_ranges(&input)?;
-            assert_eq!(
-                vec![(0_usize..1_usize), (1_usize..8_usize), (8_usize..9_usize)],
-                results.collect::<Vec<_>>()
-            );
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn test_lexicographical_partition_all_equal_values() -> Result<()> {
-        let input = vec![SortColumn {
-            values: Arc::new(Int64Array::from_value(1, 1000)) as ArrayRef,
-            options: Some(SortOptions {
-                descending: false,
-                nulls_first: true,
-            }),
-        }];
-
-        {
-            let results = lexicographical_partition_ranges(&input)?;
-            assert_eq!(vec![(0_usize..1000_usize)], results.collect::<Vec<_>>());
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn test_lexicographical_partition_all_null_values() -> Result<()> {
-        let input = vec![
-            SortColumn {
-                values: new_null_array(&DataType::Int8, 1000),
-                options: Some(SortOptions {
-                    descending: false,
-                    nulls_first: true,
-                }),
-            },
-            SortColumn {
-                values: new_null_array(&DataType::UInt16, 1000),
-                options: Some(SortOptions {
-                    descending: false,
-                    nulls_first: false,
-                }),
-            },
-        ];
-        {
-            let results = lexicographical_partition_ranges(&input)?;
-            assert_eq!(vec![(0_usize..1000_usize)], results.collect::<Vec<_>>());
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn test_lexicographical_partition_unique_column_1() -> Result<()> {
-        let input = vec![
-            SortColumn {
-                values: Arc::new(Int64Array::from(vec![None, Some(-1)])) as ArrayRef,
-                options: Some(SortOptions {
-                    descending: false,
-                    nulls_first: true,
-                }),
-            },
-            SortColumn {
-                values: Arc::new(StringArray::from(vec![Some("foo"), Some("bar")]))
-                    as ArrayRef,
-                options: Some(SortOptions {
-                    descending: true,
-                    nulls_first: true,
-                }),
-            },
-        ];
-        {
-            let results = lexicographical_partition_ranges(&input)?;
-            assert_eq!(
-                vec![(0_usize..1_usize), (1_usize..2_usize)],
-                results.collect::<Vec<_>>()
-            );
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn test_lexicographical_partition_unique_column_2() -> Result<()> {
-        let input = vec![
-            SortColumn {
-                values: Arc::new(Int64Array::from(vec![None, Some(-1), Some(-1)]))
-                    as ArrayRef,
-                options: Some(SortOptions {
-                    descending: false,
-                    nulls_first: true,
-                }),
-            },
-            SortColumn {
-                values: Arc::new(StringArray::from(vec![
-                    Some("foo"),
-                    Some("bar"),
-                    Some("apple"),
-                ])) as ArrayRef,
-                options: Some(SortOptions {
-                    descending: true,
-                    nulls_first: true,
-                }),
-            },
-        ];
-        {
-            let results = lexicographical_partition_ranges(&input)?;
-            assert_eq!(
-                vec![(0_usize..1_usize), (1_usize..2_usize), (2_usize..3_usize),],
-                results.collect::<Vec<_>>()
-            );
-        }
-        Ok(())
-    }
-
-    #[test]
-    fn test_lexicographical_partition_non_unique_column_1() -> Result<()> {
-        let input = vec![
-            SortColumn {
-                values: Arc::new(Int64Array::from(vec![
-                    None,
-                    Some(-1),
-                    Some(-1),
-                    Some(1),
-                ])) as ArrayRef,
-                options: Some(SortOptions {
-                    descending: false,
-                    nulls_first: true,
-                }),
-            },
-            SortColumn {
-                values: Arc::new(StringArray::from(vec![
-                    Some("foo"),
-                    Some("bar"),
-                    Some("bar"),
-                    Some("bar"),
-                ])) as ArrayRef,
-                options: Some(SortOptions {
-                    descending: true,
-                    nulls_first: true,
-                }),
-            },
-        ];
-        {
-            let results = lexicographical_partition_ranges(&input)?;
-            assert_eq!(
-                vec![(0_usize..1_usize), (1_usize..3_usize), (3_usize..4_usize),],
-                results.collect::<Vec<_>>()
-            );
-        }
-        Ok(())
-    }
-}
diff --git a/arrow/src/compute/kernels/regexp.rs b/arrow/src/compute/kernels/regexp.rs
deleted file mode 100644
index b52a3e231ee6..000000000000
--- a/arrow/src/compute/kernels/regexp.rs
+++ /dev/null
@@ -1,155 +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.
-
-//! Defines kernel to extract substrings based on a regular
-//! expression of a \[Large\]StringArray
-
-use crate::array::{
-    ArrayRef, GenericStringArray, GenericStringBuilder, ListBuilder, OffsetSizeTrait,
-};
-use crate::error::{ArrowError, Result};
-use std::collections::HashMap;
-
-use std::sync::Arc;
-
-use regex::Regex;
-
-/// Extract all groups matched by a regular expression for a given String array.
-pub fn regexp_match<OffsetSize: OffsetSizeTrait>(
-    array: &GenericStringArray<OffsetSize>,
-    regex_array: &GenericStringArray<OffsetSize>,
-    flags_array: Option<&GenericStringArray<OffsetSize>>,
-) -> Result<ArrayRef> {
-    let mut patterns: HashMap<String, Regex> = HashMap::new();
-    let builder: GenericStringBuilder<OffsetSize> = GenericStringBuilder::new(0);
-    let mut list_builder = ListBuilder::new(builder);
-
-    let complete_pattern = match flags_array {
-        Some(flags) => Box::new(regex_array.iter().zip(flags.iter()).map(
-            |(pattern, flags)| {
-                pattern.map(|pattern| match flags {
-                    Some(value) => format!("(?{}){}", value, pattern),
-                    None => pattern.to_string(),
-                })
-            },
-        )) as Box<dyn Iterator<Item = Option<String>>>,
-        None => Box::new(
-            regex_array
-                .iter()
-                .map(|pattern| pattern.map(|pattern| pattern.to_string())),
-        ),
-    };
-    array
-        .iter()
-        .zip(complete_pattern)
-        .map(|(value, pattern)| {
-            match (value, pattern) {
-                // Required for Postgres compatibility:
-                // SELECT regexp_match('foobarbequebaz', ''); = {""}
-                (Some(_), Some(pattern)) if pattern == *"" => {
-                    list_builder.values().append_value("");
-                    list_builder.append(true);
-                }
-                (Some(value), Some(pattern)) => {
-                    let existing_pattern = patterns.get(&pattern);
-                    let re = match existing_pattern {
-                        Some(re) => re.clone(),
-                        None => {
-                            let re = Regex::new(pattern.as_str()).map_err(|e| {
-                                ArrowError::ComputeError(format!(
-                                    "Regular expression did not compile: {:?}",
-                                    e
-                                ))
-                            })?;
-                            patterns.insert(pattern, re.clone());
-                            re
-                        }
-                    };
-                    match re.captures(value) {
-                        Some(caps) => {
-                            for m in caps.iter().skip(1).flatten() {
-                                list_builder.values().append_value(m.as_str());
-                            }
-                            list_builder.append(true);
-                        }
-                        None => list_builder.append(false),
-                    }
-                }
-                _ => list_builder.append(false),
-            }
-            Ok(())
-        })
-        .collect::<Result<Vec<()>>>()?;
-    Ok(Arc::new(list_builder.finish()))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::{ListArray, StringArray};
-
-    #[test]
-    fn match_single_group() {
-        let values = vec![
-            Some("abc-005-def"),
-            Some("X-7-5"),
-            Some("X545"),
-            None,
-            Some("foobarbequebaz"),
-            Some("foobarbequebaz"),
-        ];
-        let array = StringArray::from(values);
-        let mut pattern_values = vec![r".*-(\d*)-.*"; 4];
-        pattern_values.push(r"(bar)(bequ1e)");
-        pattern_values.push("");
-        let pattern = StringArray::from(pattern_values);
-        let actual = regexp_match(&array, &pattern, None).unwrap();
-        let elem_builder: GenericStringBuilder<i32> = GenericStringBuilder::new(0);
-        let mut expected_builder = ListBuilder::new(elem_builder);
-        expected_builder.values().append_value("005");
-        expected_builder.append(true);
-        expected_builder.values().append_value("7");
-        expected_builder.append(true);
-        expected_builder.append(false);
-        expected_builder.append(false);
-        expected_builder.append(false);
-        expected_builder.values().append_value("");
-        expected_builder.append(true);
-        let expected = expected_builder.finish();
-        let result = actual.as_any().downcast_ref::<ListArray>().unwrap();
-        assert_eq!(&expected, result);
-    }
-
-    #[test]
-    fn match_single_group_with_flags() {
-        let values = vec![Some("abc-005-def"), Some("X-7-5"), Some("X545"), None];
-        let array = StringArray::from(values);
-        let pattern = StringArray::from(vec![r"x.*-(\d*)-.*"; 4]);
-        let flags = StringArray::from(vec!["i"; 4]);
-        let actual = regexp_match(&array, &pattern, Some(&flags)).unwrap();
-        let elem_builder: GenericStringBuilder<i32> = GenericStringBuilder::new(0);
-        let mut expected_builder = ListBuilder::new(elem_builder);
-        expected_builder.append(false);
-        expected_builder.values().append_value("7");
-        expected_builder.append(true);
-        expected_builder.append(false);
-        expected_builder.append(false);
-        let expected = expected_builder.finish();
-        let result = actual.as_any().downcast_ref::<ListArray>().unwrap();
-        assert_eq!(&expected, result);
-    }
-}
diff --git a/arrow/src/compute/kernels/temporal.rs b/arrow/src/compute/kernels/temporal.rs
deleted file mode 100644
index d917a6ef3c97..000000000000
--- a/arrow/src/compute/kernels/temporal.rs
+++ /dev/null
@@ -1,1015 +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.
-
-//! Defines temporal kernels for time and date related functions.
-
-use chrono::{Datelike, Timelike};
-
-use crate::array::*;
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-
-use chrono::format::strftime::StrftimeItems;
-use chrono::format::{parse, Parsed};
-use chrono::FixedOffset;
-
-macro_rules! extract_component_from_array {
-    ($array:ident, $builder:ident, $extract_fn:ident, $using:ident) => {
-        for i in 0..$array.len() {
-            if $array.is_null(i) {
-                $builder.append_null();
-            } else {
-                match $array.$using(i) {
-                    Some(dt) => $builder.append_value(dt.$extract_fn() as i32),
-                    None => $builder.append_null(),
-                }
-            }
-        }
-    };
-    ($array:ident, $builder:ident, $extract_fn1:ident, $extract_fn2:ident, $using:ident) => {
-        for i in 0..$array.len() {
-            if $array.is_null(i) {
-                $builder.append_null();
-            } else {
-                match $array.$using(i) {
-                    Some(dt) => {
-                        $builder.append_value(dt.$extract_fn1().$extract_fn2() as i32);
-                    }
-                    None => $builder.append_null(),
-                }
-            }
-        }
-    };
-    ($array:ident, $builder:ident, $extract_fn:ident, $using:ident, $tz:ident, $parsed:ident) => {
-        if ($tz.starts_with('+') || $tz.starts_with('-')) && !$tz.contains(':') {
-            return_compute_error_with!(
-                "Invalid timezone",
-                "Expected format [+-]XX:XX".to_string()
-            )
-        } else {
-            let tz_parse_result = parse(&mut $parsed, $tz, StrftimeItems::new("%z"));
-            let fixed_offset_from_parsed = match tz_parse_result {
-                Ok(_) => match $parsed.to_fixed_offset() {
-                    Ok(fo) => Some(fo),
-                    err => return_compute_error_with!("Invalid timezone", err),
-                },
-                _ => None,
-            };
-
-            for i in 0..$array.len() {
-                if $array.is_null(i) {
-                    $builder.append_null();
-                } else {
-                    match $array.value_as_datetime(i) {
-                        Some(utc) => {
-                            let fixed_offset = match fixed_offset_from_parsed {
-                                Some(fo) => fo,
-                                None => match using_chrono_tz_and_utc_naive_date_time(
-                                    $tz, utc,
-                                ) {
-                                    Some(fo) => fo,
-                                    err => return_compute_error_with!(
-                                        "Unable to parse timezone",
-                                        err
-                                    ),
-                                },
-                            };
-                            match $array.$using(i, fixed_offset) {
-                                Some(dt) => {
-                                    $builder.append_value(dt.$extract_fn() as i32);
-                                }
-                                None => $builder.append_null(),
-                            }
-                        }
-                        err => return_compute_error_with!(
-                            "Unable to read value as datetime",
-                            err
-                        ),
-                    }
-                }
-            }
-        }
-    };
-}
-
-macro_rules! return_compute_error_with {
-    ($msg:expr, $param:expr) => {
-        return { Err(ArrowError::ComputeError(format!("{}: {:?}", $msg, $param))) }
-    };
-}
-
-// Internal trait, which is used for mapping values from DateLike structures
-trait ChronoDateExt {
-    /// Returns a value in range `1..=4` indicating the quarter this date falls into
-    fn quarter(&self) -> u32;
-
-    /// Returns a value in range `0..=3` indicating the quarter (zero-based) this date falls into
-    fn quarter0(&self) -> u32;
-
-    /// Returns the day of week; Monday is encoded as `0`, Tuesday as `1`, etc.
-    fn num_days_from_monday(&self) -> i32;
-
-    /// Returns the day of week; Sunday is encoded as `0`, Monday as `1`, etc.
-    fn num_days_from_sunday(&self) -> i32;
-}
-
-impl<T: Datelike> ChronoDateExt for T {
-    fn quarter(&self) -> u32 {
-        self.quarter0() + 1
-    }
-
-    fn quarter0(&self) -> u32 {
-        self.month0() / 3
-    }
-
-    fn num_days_from_monday(&self) -> i32 {
-        self.weekday().num_days_from_monday() as i32
-    }
-
-    fn num_days_from_sunday(&self) -> i32 {
-        self.weekday().num_days_from_sunday() as i32
-    }
-}
-
-#[cfg(not(feature = "chrono-tz"))]
-pub fn using_chrono_tz_and_utc_naive_date_time(
-    _tz: &str,
-    _utc: chrono::NaiveDateTime,
-) -> Option<FixedOffset> {
-    None
-}
-
-/// Parse the given string into a string representing fixed-offset that is correct as of the given
-/// UTC NaiveDateTime.
-/// Note that the offset is function of time and can vary depending on whether daylight savings is
-/// in effect or not. e.g. Australia/Sydney is +10:00 or +11:00 depending on DST.
-#[cfg(feature = "chrono-tz")]
-pub fn using_chrono_tz_and_utc_naive_date_time(
-    tz: &str,
-    utc: chrono::NaiveDateTime,
-) -> Option<FixedOffset> {
-    use chrono::{Offset, TimeZone};
-    tz.parse::<chrono_tz::Tz>()
-        .map(|tz| tz.offset_from_utc_datetime(&utc).fix())
-        .ok()
-}
-
-/// Extracts the hours of a given temporal array as an array of integers
-pub fn hour<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-    match array.data_type() {
-        &DataType::Time32(_) | &DataType::Time64(_) => {
-            extract_component_from_array!(array, b, hour, value_as_time)
-        }
-        &DataType::Date32 | &DataType::Date64 | &DataType::Timestamp(_, None) => {
-            extract_component_from_array!(array, b, hour, value_as_datetime)
-        }
-        &DataType::Timestamp(_, Some(ref tz)) => {
-            let mut scratch = Parsed::new();
-            extract_component_from_array!(
-                array,
-                b,
-                hour,
-                value_as_datetime_with_tz,
-                tz,
-                scratch
-            )
-        }
-        dt => return_compute_error_with!("hour does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-/// Extracts the years of a given temporal array as an array of integers
-pub fn year<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-    match array.data_type() {
-        &DataType::Date32 | &DataType::Date64 | &DataType::Timestamp(_, _) => {
-            extract_component_from_array!(array, b, year, value_as_datetime)
-        }
-        dt => return_compute_error_with!("year does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-/// Extracts the quarter of a given temporal array as an array of integers
-pub fn quarter<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-    match array.data_type() {
-        &DataType::Date32 | &DataType::Date64 | &DataType::Timestamp(_, None) => {
-            extract_component_from_array!(array, b, quarter, value_as_datetime)
-        }
-        &DataType::Timestamp(_, Some(ref tz)) => {
-            let mut scratch = Parsed::new();
-            extract_component_from_array!(
-                array,
-                b,
-                quarter,
-                value_as_datetime_with_tz,
-                tz,
-                scratch
-            )
-        }
-        dt => return_compute_error_with!("quarter does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-/// Extracts the month of a given temporal array as an array of integers
-pub fn month<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-    match array.data_type() {
-        &DataType::Date32 | &DataType::Date64 | &DataType::Timestamp(_, None) => {
-            extract_component_from_array!(array, b, month, value_as_datetime)
-        }
-        &DataType::Timestamp(_, Some(ref tz)) => {
-            let mut scratch = Parsed::new();
-            extract_component_from_array!(
-                array,
-                b,
-                month,
-                value_as_datetime_with_tz,
-                tz,
-                scratch
-            )
-        }
-        dt => return_compute_error_with!("month does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-/// Extracts the day of week of a given temporal array as an array of
-/// integers.
-///
-/// Monday is encoded as `0`, Tuesday as `1`, etc.
-///
-/// See also [`num_days_from_sunday`] which starts at Sunday.
-pub fn num_days_from_monday<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-    match array.data_type() {
-        &DataType::Date32 | &DataType::Date64 | &DataType::Timestamp(_, None) => {
-            extract_component_from_array!(
-                array,
-                b,
-                num_days_from_monday,
-                value_as_datetime
-            )
-        }
-        &DataType::Timestamp(_, Some(ref tz)) => {
-            let mut scratch = Parsed::new();
-            extract_component_from_array!(
-                array,
-                b,
-                num_days_from_monday,
-                value_as_datetime_with_tz,
-                tz,
-                scratch
-            )
-        }
-        dt => return_compute_error_with!("weekday does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-/// Extracts the day of week of a given temporal array as an array of
-/// integers, starting at Sunday.
-///
-/// Sunday is encoded as `0`, Monday as `1`, etc.
-///
-/// See also [`num_days_from_monday`] which starts at Monday.
-pub fn num_days_from_sunday<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-    match array.data_type() {
-        &DataType::Date32 | &DataType::Date64 | &DataType::Timestamp(_, None) => {
-            extract_component_from_array!(
-                array,
-                b,
-                num_days_from_sunday,
-                value_as_datetime
-            )
-        }
-        &DataType::Timestamp(_, Some(ref tz)) => {
-            let mut scratch = Parsed::new();
-            extract_component_from_array!(
-                array,
-                b,
-                num_days_from_sunday,
-                value_as_datetime_with_tz,
-                tz,
-                scratch
-            )
-        }
-        dt => return_compute_error_with!("num_days_from_sunday does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-/// Extracts the day of a given temporal array as an array of integers
-pub fn day<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-    match array.data_type() {
-        &DataType::Date32 | &DataType::Date64 | &DataType::Timestamp(_, None) => {
-            extract_component_from_array!(array, b, day, value_as_datetime)
-        }
-        &DataType::Timestamp(_, Some(ref tz)) => {
-            let mut scratch = Parsed::new();
-            extract_component_from_array!(
-                array,
-                b,
-                day,
-                value_as_datetime_with_tz,
-                tz,
-                scratch
-            )
-        }
-        dt => return_compute_error_with!("day does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-/// Extracts the day of year of a given temporal array as an array of integers
-/// The day of year that ranges from 1 to 366
-pub fn doy<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-    match array.data_type() {
-        &DataType::Date32 | &DataType::Date64 | &DataType::Timestamp(_, None) => {
-            extract_component_from_array!(array, b, ordinal, value_as_datetime)
-        }
-        &DataType::Timestamp(_, Some(ref tz)) => {
-            let mut scratch = Parsed::new();
-            extract_component_from_array!(
-                array,
-                b,
-                ordinal,
-                value_as_datetime_with_tz,
-                tz,
-                scratch
-            )
-        }
-        dt => return_compute_error_with!("doy does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-/// Extracts the minutes of a given temporal array as an array of integers
-pub fn minute<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-    match array.data_type() {
-        &DataType::Date64 | &DataType::Timestamp(_, None) => {
-            extract_component_from_array!(array, b, minute, value_as_datetime)
-        }
-        &DataType::Timestamp(_, Some(ref tz)) => {
-            let mut scratch = Parsed::new();
-            extract_component_from_array!(
-                array,
-                b,
-                minute,
-                value_as_datetime_with_tz,
-                tz,
-                scratch
-            )
-        }
-        dt => return_compute_error_with!("minute does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-/// Extracts the week of a given temporal array as an array of integers
-pub fn week<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-
-    match array.data_type() {
-        &DataType::Date32 | &DataType::Date64 | &DataType::Timestamp(_, None) => {
-            extract_component_from_array!(array, b, iso_week, week, value_as_datetime)
-        }
-        dt => return_compute_error_with!("week does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-/// Extracts the seconds of a given temporal array as an array of integers
-pub fn second<T>(array: &PrimitiveArray<T>) -> Result<Int32Array>
-where
-    T: ArrowTemporalType + ArrowNumericType,
-    i64: std::convert::From<T::Native>,
-{
-    let mut b = Int32Builder::new(array.len());
-    match array.data_type() {
-        &DataType::Date64 | &DataType::Timestamp(_, None) => {
-            extract_component_from_array!(array, b, second, value_as_datetime)
-        }
-        &DataType::Timestamp(_, Some(ref tz)) => {
-            let mut scratch = Parsed::new();
-            extract_component_from_array!(
-                array,
-                b,
-                second,
-                value_as_datetime_with_tz,
-                tz,
-                scratch
-            )
-        }
-        dt => return_compute_error_with!("second does not support", dt),
-    }
-
-    Ok(b.finish())
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    #[cfg(feature = "chrono-tz")]
-    use chrono::NaiveDate;
-
-    #[test]
-    fn test_temporal_array_date64_hour() {
-        let a: PrimitiveArray<Date64Type> =
-            vec![Some(1514764800000), None, Some(1550636625000)].into();
-
-        let b = hour(&a).unwrap();
-        assert_eq!(0, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(4, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date32_hour() {
-        let a: PrimitiveArray<Date32Type> = vec![Some(15147), None, Some(15148)].into();
-
-        let b = hour(&a).unwrap();
-        assert_eq!(0, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(0, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_time32_second_hour() {
-        let a: PrimitiveArray<Time32SecondType> = vec![37800, 86339].into();
-
-        let b = hour(&a).unwrap();
-        assert_eq!(10, b.value(0));
-        assert_eq!(23, b.value(1));
-    }
-
-    #[test]
-    fn test_temporal_array_time64_micro_hour() {
-        let a: PrimitiveArray<Time64MicrosecondType> =
-            vec![37800000000, 86339000000].into();
-
-        let b = hour(&a).unwrap();
-        assert_eq!(10, b.value(0));
-        assert_eq!(23, b.value(1));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_micro_hour() {
-        let a: TimestampMicrosecondArray = vec![37800000000, 86339000000].into();
-
-        let b = hour(&a).unwrap();
-        assert_eq!(10, b.value(0));
-        assert_eq!(23, b.value(1));
-    }
-
-    #[test]
-    fn test_temporal_array_date64_year() {
-        let a: PrimitiveArray<Date64Type> =
-            vec![Some(1514764800000), None, Some(1550636625000)].into();
-
-        let b = year(&a).unwrap();
-        assert_eq!(2018, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(2019, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date32_year() {
-        let a: PrimitiveArray<Date32Type> = vec![Some(15147), None, Some(15448)].into();
-
-        let b = year(&a).unwrap();
-        assert_eq!(2011, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(2012, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date64_quarter() {
-        //1514764800000 -> 2018-01-01
-        //1566275025000 -> 2019-08-20
-        let a: PrimitiveArray<Date64Type> =
-            vec![Some(1514764800000), None, Some(1566275025000)].into();
-
-        let b = quarter(&a).unwrap();
-        assert_eq!(1, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(3, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date32_quarter() {
-        let a: PrimitiveArray<Date32Type> = vec![Some(1), None, Some(300)].into();
-
-        let b = quarter(&a).unwrap();
-        assert_eq!(1, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(4, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_quarter_with_timezone() {
-        use std::sync::Arc;
-
-        // 24 * 60 * 60 = 86400
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![86400 * 90],
-            Some("+00:00".to_string()),
-        ));
-        let b = quarter(&a).unwrap();
-        assert_eq!(2, b.value(0));
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![86400 * 90],
-            Some("-10:00".to_string()),
-        ));
-        let b = quarter(&a).unwrap();
-        assert_eq!(1, b.value(0));
-    }
-
-    #[test]
-    fn test_temporal_array_date64_month() {
-        //1514764800000 -> 2018-01-01
-        //1550636625000 -> 2019-02-20
-        let a: PrimitiveArray<Date64Type> =
-            vec![Some(1514764800000), None, Some(1550636625000)].into();
-
-        let b = month(&a).unwrap();
-        assert_eq!(1, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(2, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date32_month() {
-        let a: PrimitiveArray<Date32Type> = vec![Some(1), None, Some(31)].into();
-
-        let b = month(&a).unwrap();
-        assert_eq!(1, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(2, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_month_with_timezone() {
-        use std::sync::Arc;
-
-        // 24 * 60 * 60 = 86400
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![86400 * 31],
-            Some("+00:00".to_string()),
-        ));
-        let b = month(&a).unwrap();
-        assert_eq!(2, b.value(0));
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![86400 * 31],
-            Some("-10:00".to_string()),
-        ));
-        let b = month(&a).unwrap();
-        assert_eq!(1, b.value(0));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_day_with_timezone() {
-        use std::sync::Arc;
-
-        // 24 * 60 * 60 = 86400
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![86400],
-            Some("+00:00".to_string()),
-        ));
-        let b = day(&a).unwrap();
-        assert_eq!(2, b.value(0));
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![86400],
-            Some("-10:00".to_string()),
-        ));
-        let b = day(&a).unwrap();
-        assert_eq!(1, b.value(0));
-    }
-
-    #[test]
-    fn test_temporal_array_date64_weekday() {
-        //1514764800000 -> 2018-01-01 (Monday)
-        //1550636625000 -> 2019-02-20 (Wednesday)
-        let a: PrimitiveArray<Date64Type> =
-            vec![Some(1514764800000), None, Some(1550636625000)].into();
-
-        let b = num_days_from_monday(&a).unwrap();
-        assert_eq!(0, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(2, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date64_weekday0() {
-        //1483228800000 -> 2017-01-01 (Sunday)
-        //1514764800000 -> 2018-01-01 (Monday)
-        //1550636625000 -> 2019-02-20 (Wednesday)
-        let a: PrimitiveArray<Date64Type> = vec![
-            Some(1483228800000),
-            None,
-            Some(1514764800000),
-            Some(1550636625000),
-        ]
-        .into();
-
-        let b = num_days_from_sunday(&a).unwrap();
-        assert_eq!(0, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(1, b.value(2));
-        assert_eq!(3, b.value(3));
-    }
-
-    #[test]
-    fn test_temporal_array_date64_day() {
-        //1514764800000 -> 2018-01-01
-        //1550636625000 -> 2019-02-20
-        let a: PrimitiveArray<Date64Type> =
-            vec![Some(1514764800000), None, Some(1550636625000)].into();
-
-        let b = day(&a).unwrap();
-        assert_eq!(1, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(20, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date32_day() {
-        let a: PrimitiveArray<Date32Type> = vec![Some(0), None, Some(31)].into();
-
-        let b = day(&a).unwrap();
-        assert_eq!(1, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(1, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date64_doy() {
-        //1483228800000 -> 2017-01-01 (Sunday)
-        //1514764800000 -> 2018-01-01
-        //1550636625000 -> 2019-02-20
-        let a: PrimitiveArray<Date64Type> = vec![
-            Some(1483228800000),
-            Some(1514764800000),
-            None,
-            Some(1550636625000),
-        ]
-        .into();
-
-        let b = doy(&a).unwrap();
-        assert_eq!(1, b.value(0));
-        assert_eq!(1, b.value(1));
-        assert!(!b.is_valid(2));
-        assert_eq!(51, b.value(3));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_micro_year() {
-        let a: TimestampMicrosecondArray =
-            vec![Some(1612025847000000), None, Some(1722015847000000)].into();
-
-        let b = year(&a).unwrap();
-        assert_eq!(2021, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(2024, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date64_minute() {
-        let a: PrimitiveArray<Date64Type> =
-            vec![Some(1514764800000), None, Some(1550636625000)].into();
-
-        let b = minute(&a).unwrap();
-        assert_eq!(0, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(23, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_micro_minute() {
-        let a: TimestampMicrosecondArray =
-            vec![Some(1612025847000000), None, Some(1722015847000000)].into();
-
-        let b = minute(&a).unwrap();
-        assert_eq!(57, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(44, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date32_week() {
-        let a: PrimitiveArray<Date32Type> = vec![Some(0), None, Some(7)].into();
-
-        let b = week(&a).unwrap();
-        assert_eq!(1, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(2, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date64_week() {
-        // 1646116175000 -> 2022.03.01 , 1641171600000 -> 2022.01.03
-        // 1640998800000 -> 2022.01.01
-        let a: PrimitiveArray<Date64Type> = vec![
-            Some(1646116175000),
-            None,
-            Some(1641171600000),
-            Some(1640998800000),
-        ]
-        .into();
-
-        let b = week(&a).unwrap();
-        assert_eq!(9, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(1, b.value(2));
-        assert_eq!(52, b.value(3));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_micro_week() {
-        //1612025847000000 -> 2021.1.30
-        //1722015847000000 -> 2024.7.27
-        let a: TimestampMicrosecondArray =
-            vec![Some(1612025847000000), None, Some(1722015847000000)].into();
-
-        let b = week(&a).unwrap();
-        assert_eq!(4, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(30, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_date64_second() {
-        let a: PrimitiveArray<Date64Type> =
-            vec![Some(1514764800000), None, Some(1550636625000)].into();
-
-        let b = second(&a).unwrap();
-        assert_eq!(0, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(45, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_micro_second() {
-        let a: TimestampMicrosecondArray =
-            vec![Some(1612025847000000), None, Some(1722015847000000)].into();
-
-        let b = second(&a).unwrap();
-        assert_eq!(27, b.value(0));
-        assert!(!b.is_valid(1));
-        assert_eq!(7, b.value(2));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_second_with_timezone() {
-        use std::sync::Arc;
-
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![10, 20],
-            Some("+00:00".to_string()),
-        ));
-        let b = second(&a).unwrap();
-        assert_eq!(10, b.value(0));
-        assert_eq!(20, b.value(1));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_minute_with_timezone() {
-        use std::sync::Arc;
-
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![0, 60],
-            Some("+00:50".to_string()),
-        ));
-        let b = minute(&a).unwrap();
-        assert_eq!(50, b.value(0));
-        assert_eq!(51, b.value(1));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_minute_with_negative_timezone() {
-        use std::sync::Arc;
-
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![60 * 55],
-            Some("-00:50".to_string()),
-        ));
-        let b = minute(&a).unwrap();
-        assert_eq!(5, b.value(0));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_hour_with_timezone() {
-        use std::sync::Arc;
-
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![60 * 60 * 10],
-            Some("+01:00".to_string()),
-        ));
-        let b = hour(&a).unwrap();
-        assert_eq!(11, b.value(0));
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_hour_with_timezone_without_colon() {
-        use std::sync::Arc;
-
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![60 * 60 * 10],
-            Some("+0100".to_string()),
-        ));
-        assert!(matches!(hour(&a), Err(ArrowError::ComputeError(_))))
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_hour_with_timezone_without_initial_sign() {
-        use std::sync::Arc;
-
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![60 * 60 * 10],
-            Some("0100".to_string()),
-        ));
-        assert!(matches!(hour(&a), Err(ArrowError::ComputeError(_))))
-    }
-
-    #[test]
-    fn test_temporal_array_timestamp_hour_with_timezone_with_only_colon() {
-        use std::sync::Arc;
-
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![60 * 60 * 10],
-            Some("01:00".to_string()),
-        ));
-        assert!(matches!(hour(&a), Err(ArrowError::ComputeError(_))))
-    }
-
-    #[cfg(feature = "chrono-tz")]
-    #[test]
-    fn test_temporal_array_timestamp_hour_with_timezone_using_chrono_tz() {
-        use std::sync::Arc;
-
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![60 * 60 * 10],
-            Some("Asia/Kolkata".to_string()),
-        ));
-        let b = hour(&a).unwrap();
-        assert_eq!(15, b.value(0));
-    }
-
-    #[cfg(feature = "chrono-tz")]
-    #[test]
-    fn test_temporal_array_timestamp_hour_with_dst_timezone_using_chrono_tz() {
-        //
-        // 1635577147 converts to 2021-10-30 17:59:07 in time zone Australia/Sydney (AEDT)
-        // The offset (difference to UTC) is +11:00. Note that daylight savings is in effect on 2021-10-30.
-        // When daylight savings is not in effect, Australia/Sydney has an offset difference of +10:00.
-
-        let a = TimestampMillisecondArray::from_opt_vec(
-            vec![Some(1635577147000)],
-            Some("Australia/Sydney".to_string()),
-        );
-        let b = hour(&a).unwrap();
-        assert_eq!(17, b.value(0));
-    }
-
-    #[cfg(not(feature = "chrono-tz"))]
-    #[test]
-    fn test_temporal_array_timestamp_hour_with_timezone_using_chrono_tz() {
-        use std::sync::Arc;
-
-        let a = Arc::new(TimestampSecondArray::from_vec(
-            vec![60 * 60 * 10],
-            Some("Asia/Kolkatta".to_string()),
-        ));
-        assert!(matches!(hour(&a), Err(ArrowError::ComputeError(_))))
-    }
-
-    #[cfg(feature = "chrono-tz")]
-    #[test]
-    fn test_using_chrono_tz_and_utc_naive_date_time() {
-        let sydney_tz = "Australia/Sydney".to_string();
-        let sydney_offset_without_dst = FixedOffset::east(10 * 60 * 60);
-        let sydney_offset_with_dst = FixedOffset::east(11 * 60 * 60);
-        // Daylight savings ends
-        // When local daylight time was about to reach
-        // Sunday, 4 April 2021, 3:00:00 am clocks were turned backward 1 hour to
-        // Sunday, 4 April 2021, 2:00:00 am local standard time instead.
-
-        // Daylight savings starts
-        // When local standard time was about to reach
-        // Sunday, 3 October 2021, 2:00:00 am clocks were turned forward 1 hour to
-        // Sunday, 3 October 2021, 3:00:00 am local daylight time instead.
-
-        // Sydney 2021-04-04T02:30:00+11:00 is 2021-04-03T15:30:00Z
-        let utc_just_before_sydney_dst_ends =
-            NaiveDate::from_ymd(2021, 4, 3).and_hms_nano(15, 30, 0, 0);
-        assert_eq!(
-            using_chrono_tz_and_utc_naive_date_time(
-                &sydney_tz,
-                utc_just_before_sydney_dst_ends
-            ),
-            Some(sydney_offset_with_dst)
-        );
-        // Sydney 2021-04-04T02:30:00+10:00 is 2021-04-03T16:30:00Z
-        let utc_just_after_sydney_dst_ends =
-            NaiveDate::from_ymd(2021, 4, 3).and_hms_nano(16, 30, 0, 0);
-        assert_eq!(
-            using_chrono_tz_and_utc_naive_date_time(
-                &sydney_tz,
-                utc_just_after_sydney_dst_ends
-            ),
-            Some(sydney_offset_without_dst)
-        );
-        // Sydney 2021-10-03T01:30:00+10:00 is 2021-10-02T15:30:00Z
-        let utc_just_before_sydney_dst_starts =
-            NaiveDate::from_ymd(2021, 10, 2).and_hms_nano(15, 30, 0, 0);
-        assert_eq!(
-            using_chrono_tz_and_utc_naive_date_time(
-                &sydney_tz,
-                utc_just_before_sydney_dst_starts
-            ),
-            Some(sydney_offset_without_dst)
-        );
-        // Sydney 2021-04-04T03:30:00+11:00 is 2021-10-02T16:30:00Z
-        let utc_just_after_sydney_dst_starts =
-            NaiveDate::from_ymd(2022, 10, 2).and_hms_nano(16, 30, 0, 0);
-        assert_eq!(
-            using_chrono_tz_and_utc_naive_date_time(
-                &sydney_tz,
-                utc_just_after_sydney_dst_starts
-            ),
-            Some(sydney_offset_with_dst)
-        );
-    }
-}
diff --git a/arrow/src/compute/kernels/zip.rs b/arrow/src/compute/kernels/zip.rs
deleted file mode 100644
index c28529cf6762..000000000000
--- a/arrow/src/compute/kernels/zip.rs
+++ /dev/null
@@ -1,87 +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.
-
-use crate::array::*;
-use crate::compute::SlicesIterator;
-use crate::error::{ArrowError, Result};
-
-/// Zip two arrays by some boolean mask. Where the mask evaluates `true` values of `truthy`
-/// are taken, where the mask evaluates `false` values of `falsy` are taken.
-///
-/// # Arguments
-/// * `mask` - Boolean values used to determine from which array to take the values.
-/// * `truthy` - Values of this array are taken if mask evaluates `true`
-/// * `falsy` - Values of this array are taken if mask evaluates `false`
-pub fn zip(
-    mask: &BooleanArray,
-    truthy: &dyn Array,
-    falsy: &dyn Array,
-) -> Result<ArrayRef> {
-    if truthy.data_type() != falsy.data_type() {
-        return Err(ArrowError::InvalidArgumentError(
-            "arguments need to have the same data type".into(),
-        ));
-    }
-    if truthy.len() != falsy.len() || falsy.len() != mask.len() {
-        return Err(ArrowError::InvalidArgumentError(
-            "all arrays should have the same length".into(),
-        ));
-    }
-    let falsy = falsy.data();
-    let truthy = truthy.data();
-
-    let mut mutable = MutableArrayData::new(vec![truthy, falsy], false, truthy.len());
-
-    // the SlicesIterator slices only the true values. So the gaps left by this iterator we need to
-    // fill with falsy values
-
-    // keep track of how much is filled
-    let mut filled = 0;
-
-    SlicesIterator::new(mask).for_each(|(start, end)| {
-        // the gap needs to be filled with falsy values
-        if start > filled {
-            mutable.extend(1, filled, start);
-        }
-        // fill with truthy values
-        mutable.extend(0, start, end);
-        filled = end;
-    });
-    // the remaining part is falsy
-    if filled < truthy.len() {
-        mutable.extend(1, filled, truthy.len());
-    }
-
-    let data = mutable.freeze();
-    Ok(make_array(data))
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn test_zip_kernel() {
-        let a = Int32Array::from(vec![Some(5), None, Some(7), None, Some(1)]);
-        let b = Int32Array::from(vec![None, Some(3), Some(6), Some(7), Some(3)]);
-        let mask = BooleanArray::from(vec![true, true, false, false, true]);
-        let out = zip(&mask, &a, &b).unwrap();
-        let actual = out.as_any().downcast_ref::<Int32Array>().unwrap();
-        let expected = Int32Array::from(vec![Some(5), None, Some(6), Some(7), Some(1)]);
-        assert_eq!(actual, &expected);
-    }
-}
diff --git a/arrow/src/compute/mod.rs b/arrow/src/compute/mod.rs
index 2b3b9a76873a..47a9d149aadb 100644
--- a/arrow/src/compute/mod.rs
+++ b/arrow/src/compute/mod.rs
@@ -19,8 +19,6 @@
 
 pub mod kernels;
 
-mod util;
-
 pub use self::kernels::aggregate::*;
 pub use self::kernels::arithmetic::*;
 pub use self::kernels::arity::*;
@@ -29,8 +27,10 @@ pub use self::kernels::cast::*;
 pub use self::kernels::comparison::*;
 pub use self::kernels::concat::*;
 pub use self::kernels::filter::*;
-pub use self::kernels::limit::*;
+pub use self::kernels::interleave::*;
+pub use self::kernels::nullif::*;
 pub use self::kernels::partition::*;
+pub use self::kernels::rank::*;
 pub use self::kernels::regexp::*;
 pub use self::kernels::sort::*;
 pub use self::kernels::take::*;
diff --git a/arrow/src/compute/util.rs b/arrow/src/compute/util.rs
deleted file mode 100644
index 974af9593e36..000000000000
--- a/arrow/src/compute/util.rs
+++ /dev/null
@@ -1,494 +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.
-
-//! Common utilities for computation kernels.
-
-use crate::array::*;
-use crate::buffer::{buffer_bin_and, Buffer};
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-use num::{One, ToPrimitive, Zero};
-use std::ops::Add;
-
-/// Combines the null bitmaps of multiple arrays using a bitwise `and` operation.
-///
-/// This function is useful when implementing operations on higher level arrays.
-#[allow(clippy::unnecessary_wraps)]
-pub(super) fn combine_option_bitmap(
-    arrays: &[&ArrayData],
-    len_in_bits: usize,
-) -> Result<Option<Buffer>> {
-    arrays
-        .iter()
-        .map(|array| (array.null_buffer().cloned(), array.offset()))
-        .reduce(|acc, buffer_and_offset| match (acc, buffer_and_offset) {
-            ((None, _), (None, _)) => (None, 0),
-            ((Some(buffer), offset), (None, _)) | ((None, _), (Some(buffer), offset)) => {
-                (Some(buffer), offset)
-            }
-            ((Some(buffer_left), offset_left), (Some(buffer_right), offset_right)) => (
-                Some(buffer_bin_and(
-                    &buffer_left,
-                    offset_left,
-                    &buffer_right,
-                    offset_right,
-                    len_in_bits,
-                )),
-                0,
-            ),
-        })
-        .map_or(
-            Err(ArrowError::ComputeError(
-                "Arrays must not be empty".to_string(),
-            )),
-            |(buffer, offset)| {
-                Ok(buffer.map(|buffer| buffer.bit_slice(offset, len_in_bits)))
-            },
-        )
-}
-
-/// Takes/filters a list array's inner data using the offsets of the list array.
-///
-/// Where a list array has indices `[0,2,5,10]`, taking indices of `[2,0]` returns
-/// an array of the indices `[5..10, 0..2]` and offsets `[0,5,7]` (5 elements and 2
-/// elements)
-pub(super) fn take_value_indices_from_list<IndexType, OffsetType>(
-    list: &GenericListArray<OffsetType::Native>,
-    indices: &PrimitiveArray<IndexType>,
-) -> Result<(PrimitiveArray<OffsetType>, Vec<OffsetType::Native>)>
-where
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-    OffsetType: ArrowNumericType,
-    OffsetType::Native: OffsetSizeTrait + Add + Zero + One,
-    PrimitiveArray<OffsetType>: From<Vec<Option<OffsetType::Native>>>,
-{
-    // TODO: benchmark this function, there might be a faster unsafe alternative
-    let offsets: &[OffsetType::Native] = list.value_offsets();
-
-    let mut new_offsets = Vec::with_capacity(indices.len());
-    let mut values = Vec::new();
-    let mut current_offset = OffsetType::Native::zero();
-    // add first offset
-    new_offsets.push(OffsetType::Native::zero());
-    // compute the value indices, and set offsets accordingly
-    for i in 0..indices.len() {
-        if indices.is_valid(i) {
-            let ix = ToPrimitive::to_usize(&indices.value(i)).ok_or_else(|| {
-                ArrowError::ComputeError("Cast to usize failed".to_string())
-            })?;
-            let start = offsets[ix];
-            let end = offsets[ix + 1];
-            current_offset += end - start;
-            new_offsets.push(current_offset);
-
-            let mut curr = start;
-
-            // if start == end, this slot is empty
-            while curr < end {
-                values.push(Some(curr));
-                curr += OffsetType::Native::one();
-            }
-        } else {
-            new_offsets.push(current_offset);
-        }
-    }
-
-    Ok((PrimitiveArray::<OffsetType>::from(values), new_offsets))
-}
-
-/// Takes/filters a fixed size list array's inner data using the offsets of the list array.
-pub(super) fn take_value_indices_from_fixed_size_list<IndexType>(
-    list: &FixedSizeListArray,
-    indices: &PrimitiveArray<IndexType>,
-    length: <UInt32Type as ArrowPrimitiveType>::Native,
-) -> Result<PrimitiveArray<UInt32Type>>
-where
-    IndexType: ArrowNumericType,
-    IndexType::Native: ToPrimitive,
-{
-    let mut values = vec![];
-
-    for i in 0..indices.len() {
-        if indices.is_valid(i) {
-            let index = ToPrimitive::to_usize(&indices.value(i)).ok_or_else(|| {
-                ArrowError::ComputeError("Cast to usize failed".to_string())
-            })?;
-            let start =
-                list.value_offset(index) as <UInt32Type as ArrowPrimitiveType>::Native;
-
-            values.extend(start..start + length);
-        }
-    }
-
-    Ok(PrimitiveArray::<UInt32Type>::from(values))
-}
-
-#[cfg(test)]
-pub(super) mod tests {
-    use super::*;
-
-    use std::sync::Arc;
-
-    use crate::buffer::buffer_bin_or;
-    use crate::datatypes::DataType;
-    use crate::util::bit_util;
-    use crate::{array::ArrayData, buffer::MutableBuffer};
-
-    /// Compares the null bitmaps of two arrays using a bitwise `or` operation.
-    ///
-    /// This function is useful when implementing operations on higher level arrays.
-    pub(super) fn compare_option_bitmap(
-        left_data: &ArrayData,
-        right_data: &ArrayData,
-        len_in_bits: usize,
-    ) -> Result<Option<Buffer>> {
-        let left_offset_in_bits = left_data.offset();
-        let right_offset_in_bits = right_data.offset();
-
-        let left = left_data.null_buffer();
-        let right = right_data.null_buffer();
-
-        match left {
-            None => match right {
-                None => Ok(None),
-                Some(r) => Ok(Some(r.bit_slice(right_offset_in_bits, len_in_bits))),
-            },
-            Some(l) => match right {
-                None => Ok(Some(l.bit_slice(left_offset_in_bits, len_in_bits))),
-
-                Some(r) => Ok(Some(buffer_bin_or(
-                    l,
-                    left_offset_in_bits,
-                    r,
-                    right_offset_in_bits,
-                    len_in_bits,
-                ))),
-            },
-        }
-    }
-
-    fn make_data_with_null_bit_buffer(
-        len: usize,
-        offset: usize,
-        null_bit_buffer: Option<Buffer>,
-    ) -> Arc<ArrayData> {
-        let buffer = Buffer::from(&vec![11; len + offset]);
-
-        Arc::new(
-            ArrayData::try_new(
-                DataType::UInt8,
-                len,
-                null_bit_buffer,
-                offset,
-                vec![buffer],
-                vec![],
-            )
-            .unwrap(),
-        )
-    }
-
-    #[test]
-    fn test_combine_option_bitmap() {
-        let none_bitmap = make_data_with_null_bit_buffer(8, 0, None);
-        let some_bitmap =
-            make_data_with_null_bit_buffer(8, 0, Some(Buffer::from([0b01001010])));
-        let inverse_bitmap =
-            make_data_with_null_bit_buffer(8, 0, Some(Buffer::from([0b10110101])));
-        let some_other_bitmap =
-            make_data_with_null_bit_buffer(8, 0, Some(Buffer::from([0b11010111])));
-        assert_eq!(
-            combine_option_bitmap(&[], 8).unwrap_err().to_string(),
-            "Compute error: Arrays must not be empty",
-        );
-        assert_eq!(
-            Some(Buffer::from([0b01001010])),
-            combine_option_bitmap(&[&some_bitmap], 8).unwrap()
-        );
-        assert_eq!(
-            None,
-            combine_option_bitmap(&[&none_bitmap, &none_bitmap], 8).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b01001010])),
-            combine_option_bitmap(&[&some_bitmap, &none_bitmap], 8).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b11010111])),
-            combine_option_bitmap(&[&none_bitmap, &some_other_bitmap], 8).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b01001010])),
-            combine_option_bitmap(&[&some_bitmap, &some_bitmap], 8,).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b0])),
-            combine_option_bitmap(&[&some_bitmap, &inverse_bitmap], 8,).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b01000010])),
-            combine_option_bitmap(&[&some_bitmap, &some_other_bitmap, &none_bitmap], 8,)
-                .unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b00001001])),
-            combine_option_bitmap(
-                &[
-                    &some_bitmap.slice(3, 5),
-                    &inverse_bitmap.slice(2, 5),
-                    &some_other_bitmap.slice(1, 5)
-                ],
-                5,
-            )
-            .unwrap()
-        );
-    }
-
-    #[test]
-    fn test_combine_option_bitmap_with_offsets() {
-        let none_bitmap = make_data_with_null_bit_buffer(8, 0, None);
-        let bitmap0 =
-            make_data_with_null_bit_buffer(8, 0, Some(Buffer::from([0b10101010])));
-        let bitmap1 =
-            make_data_with_null_bit_buffer(8, 1, Some(Buffer::from([0b01010100, 0b1])));
-        let bitmap2 =
-            make_data_with_null_bit_buffer(8, 2, Some(Buffer::from([0b10101000, 0b10])));
-        assert_eq!(
-            Some(Buffer::from([0b10101010])),
-            combine_option_bitmap(&[&bitmap1], 8).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b10101010])),
-            combine_option_bitmap(&[&bitmap2], 8).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b10101010])),
-            combine_option_bitmap(&[&bitmap1, &none_bitmap], 8).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b10101010])),
-            combine_option_bitmap(&[&none_bitmap, &bitmap2], 8).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b10101010])),
-            combine_option_bitmap(&[&bitmap0, &bitmap1], 8).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b10101010])),
-            combine_option_bitmap(&[&bitmap1, &bitmap2], 8).unwrap()
-        );
-    }
-
-    #[test]
-    fn test_compare_option_bitmap() {
-        let none_bitmap = make_data_with_null_bit_buffer(8, 0, None);
-        let some_bitmap =
-            make_data_with_null_bit_buffer(8, 0, Some(Buffer::from([0b01001010])));
-        let inverse_bitmap =
-            make_data_with_null_bit_buffer(8, 0, Some(Buffer::from([0b10110101])));
-        assert_eq!(
-            None,
-            compare_option_bitmap(&none_bitmap, &none_bitmap, 8).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b01001010])),
-            compare_option_bitmap(&some_bitmap, &none_bitmap, 8).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b01001010])),
-            compare_option_bitmap(&none_bitmap, &some_bitmap, 8,).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b01001010])),
-            compare_option_bitmap(&some_bitmap, &some_bitmap, 8,).unwrap()
-        );
-        assert_eq!(
-            Some(Buffer::from([0b11111111])),
-            compare_option_bitmap(&some_bitmap, &inverse_bitmap, 8,).unwrap()
-        );
-    }
-
-    pub(crate) fn build_generic_list<S, T>(
-        data: Vec<Option<Vec<T::Native>>>,
-    ) -> GenericListArray<S>
-    where
-        S: OffsetSizeTrait + 'static,
-        T: ArrowPrimitiveType,
-        PrimitiveArray<T>: From<Vec<Option<T::Native>>>,
-    {
-        let data = data
-            .into_iter()
-            .map(|subarray| {
-                subarray.map(|item| {
-                    item.into_iter()
-                        .map(Some)
-                        .collect::<Vec<Option<T::Native>>>()
-                })
-            })
-            .collect();
-        build_generic_list_nullable(data)
-    }
-
-    pub(crate) fn build_generic_list_nullable<S, T>(
-        data: Vec<Option<Vec<Option<T::Native>>>>,
-    ) -> GenericListArray<S>
-    where
-        S: OffsetSizeTrait + 'static,
-        T: ArrowPrimitiveType,
-        PrimitiveArray<T>: From<Vec<Option<T::Native>>>,
-    {
-        let mut offset = vec![S::zero()];
-        let mut values = vec![];
-
-        let list_len = data.len();
-        let num_bytes = bit_util::ceil(list_len, 8);
-        let mut list_null_count = 0;
-        let mut list_bitmap = MutableBuffer::new(num_bytes).with_bitset(num_bytes, true);
-        for (idx, array) in data.into_iter().enumerate() {
-            if let Some(mut array) = array {
-                values.append(&mut array);
-            } else {
-                list_null_count += 1;
-                bit_util::unset_bit(list_bitmap.as_slice_mut(), idx);
-            }
-            offset.push(S::from_usize(values.len()).unwrap());
-        }
-
-        let value_data = PrimitiveArray::<T>::from(values).into_data();
-        let (list_data_type, value_offsets) = (
-            GenericListArray::<S>::DATA_TYPE_CONSTRUCTOR(Box::new(Field::new(
-                "item",
-                T::DATA_TYPE,
-                list_null_count == 0,
-            ))),
-            Buffer::from_slice_ref(&offset),
-        );
-
-        let list_data = ArrayData::builder(list_data_type)
-            .len(list_len)
-            .null_bit_buffer(Some(list_bitmap.into()))
-            .add_buffer(value_offsets)
-            .add_child_data(value_data)
-            .build()
-            .unwrap();
-
-        GenericListArray::<S>::from(list_data)
-    }
-
-    pub(crate) fn build_fixed_size_list_nullable<T>(
-        list_values: Vec<Option<Vec<Option<T::Native>>>>,
-        length: <Int32Type as ArrowPrimitiveType>::Native,
-    ) -> FixedSizeListArray
-    where
-        T: ArrowPrimitiveType,
-        PrimitiveArray<T>: From<Vec<Option<T::Native>>>,
-    {
-        let mut values = vec![];
-        let mut list_null_count = 0;
-        let list_len = list_values.len();
-
-        let num_bytes = bit_util::ceil(list_len, 8);
-        let mut list_bitmap = MutableBuffer::new(num_bytes).with_bitset(num_bytes, true);
-        for (idx, list_element) in list_values.into_iter().enumerate() {
-            if let Some(items) = list_element {
-                // every sub-array should have the same length
-                debug_assert_eq!(length as usize, items.len());
-
-                values.extend(items.into_iter());
-            } else {
-                list_null_count += 1;
-                bit_util::unset_bit(list_bitmap.as_slice_mut(), idx);
-                values.extend(vec![None; length as usize].into_iter());
-            }
-        }
-
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", T::DATA_TYPE, list_null_count == 0)),
-            length,
-        );
-
-        let child_data = PrimitiveArray::<T>::from(values).into_data();
-
-        let list_data = ArrayData::builder(list_data_type)
-            .len(list_len)
-            .null_bit_buffer(Some(list_bitmap.into()))
-            .add_child_data(child_data)
-            .build()
-            .unwrap();
-
-        FixedSizeListArray::from(list_data)
-    }
-
-    #[test]
-    fn test_take_value_index_from_list() {
-        let list = build_generic_list::<i32, Int32Type>(vec![
-            Some(vec![0, 1]),
-            Some(vec![2, 3, 4]),
-            Some(vec![5, 6, 7, 8, 9]),
-        ]);
-        let indices = UInt32Array::from(vec![2, 0]);
-
-        let (indexed, offsets) = take_value_indices_from_list(&list, &indices).unwrap();
-
-        assert_eq!(indexed, Int32Array::from(vec![5, 6, 7, 8, 9, 0, 1]));
-        assert_eq!(offsets, vec![0, 5, 7]);
-    }
-
-    #[test]
-    fn test_take_value_index_from_large_list() {
-        let list = build_generic_list::<i64, Int32Type>(vec![
-            Some(vec![0, 1]),
-            Some(vec![2, 3, 4]),
-            Some(vec![5, 6, 7, 8, 9]),
-        ]);
-        let indices = UInt32Array::from(vec![2, 0]);
-
-        let (indexed, offsets) =
-            take_value_indices_from_list::<_, Int64Type>(&list, &indices).unwrap();
-
-        assert_eq!(indexed, Int64Array::from(vec![5, 6, 7, 8, 9, 0, 1]));
-        assert_eq!(offsets, vec![0, 5, 7]);
-    }
-
-    #[test]
-    fn test_take_value_index_from_fixed_list() {
-        let list = build_fixed_size_list_nullable::<Int32Type>(
-            vec![
-                Some(vec![Some(1), Some(2), None]),
-                Some(vec![Some(4), None, Some(6)]),
-                None,
-                Some(vec![None, Some(8), Some(9)]),
-            ],
-            3,
-        );
-
-        let indices = UInt32Array::from(vec![2, 1, 0]);
-        let indexed =
-            take_value_indices_from_fixed_size_list(&list, &indices, 3).unwrap();
-
-        assert_eq!(indexed, UInt32Array::from(vec![6, 7, 8, 3, 4, 5, 0, 1, 2]));
-
-        let indices = UInt32Array::from(vec![3, 2, 1, 2, 0]);
-        let indexed =
-            take_value_indices_from_fixed_size_list(&list, &indices, 3).unwrap();
-
-        assert_eq!(
-            indexed,
-            UInt32Array::from(vec![9, 10, 11, 6, 7, 8, 3, 4, 5, 6, 7, 8, 0, 1, 2])
-        );
-    }
-}
diff --git a/arrow/src/csv/reader.rs b/arrow/src/csv/reader.rs
deleted file mode 100644
index f01ce37c7399..000000000000
--- a/arrow/src/csv/reader.rs
+++ /dev/null
@@ -1,2003 +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.
-
-//! CSV Reader
-//!
-//! This CSV reader allows CSV files to be read into the Arrow memory model. Records are
-//! loaded in batches and are then converted from row-based data to columnar data.
-//!
-//! Example:
-//!
-//! ```
-//! use arrow::csv;
-//! use arrow::datatypes::{DataType, Field, Schema};
-//! use std::fs::File;
-//! use std::sync::Arc;
-//!
-//! let schema = Schema::new(vec![
-//!     Field::new("city", DataType::Utf8, false),
-//!     Field::new("lat", DataType::Float64, false),
-//!     Field::new("lng", DataType::Float64, false),
-//! ]);
-//!
-//! let file = File::open("test/data/uk_cities.csv").unwrap();
-//!
-//! let mut csv = csv::Reader::new(file, Arc::new(schema), false, None, 1024, None, None, None);
-//! let batch = csv.next().unwrap().unwrap();
-//! ```
-
-use core::cmp::min;
-use lazy_static::lazy_static;
-use regex::{Regex, RegexBuilder};
-use std::collections::HashSet;
-use std::fmt;
-use std::fs::File;
-use std::io::{Read, Seek, SeekFrom};
-use std::sync::Arc;
-
-use crate::array::{
-    ArrayRef, BooleanArray, Decimal128Builder, DictionaryArray, PrimitiveArray,
-    StringArray,
-};
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-use crate::record_batch::RecordBatch;
-use crate::util::reader_parser::Parser;
-
-use csv_crate::{ByteRecord, StringRecord};
-use std::ops::Neg;
-
-lazy_static! {
-    static ref PARSE_DECIMAL_RE: Regex =
-        Regex::new(r"^-?(\d+\.?\d*|\d*\.?\d+)$").unwrap();
-    static ref DECIMAL_RE: Regex =
-        Regex::new(r"^-?((\d*\.\d+|\d+\.\d*)([eE]-?\d+)?|\d+([eE]-?\d+))$").unwrap();
-    static ref INTEGER_RE: Regex = Regex::new(r"^-?(\d+)$").unwrap();
-    static ref BOOLEAN_RE: Regex = RegexBuilder::new(r"^(true)$|^(false)$")
-        .case_insensitive(true)
-        .build()
-        .unwrap();
-    static ref DATE_RE: Regex = Regex::new(r"^\d{4}-\d\d-\d\d$").unwrap();
-    static ref DATETIME_RE: Regex =
-        Regex::new(r"^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d$").unwrap();
-}
-
-/// Infer the data type of a record
-fn infer_field_schema(string: &str, datetime_re: Option<Regex>) -> DataType {
-    let datetime_re = datetime_re.unwrap_or_else(|| DATETIME_RE.clone());
-    // when quoting is enabled in the reader, these quotes aren't escaped, we default to
-    // Utf8 for them
-    if string.starts_with('"') {
-        return DataType::Utf8;
-    }
-    // match regex in a particular order
-    if BOOLEAN_RE.is_match(string) {
-        DataType::Boolean
-    } else if DECIMAL_RE.is_match(string) {
-        DataType::Float64
-    } else if INTEGER_RE.is_match(string) {
-        DataType::Int64
-    } else if datetime_re.is_match(string) {
-        DataType::Date64
-    } else if DATE_RE.is_match(string) {
-        DataType::Date32
-    } else {
-        DataType::Utf8
-    }
-}
-
-/// This is a collection of options for csv reader when the builder pattern cannot be used
-/// and the parameters need to be passed around
-#[derive(Debug, Default, Clone)]
-pub struct ReaderOptions {
-    has_header: bool,
-    delimiter: Option<u8>,
-    escape: Option<u8>,
-    quote: Option<u8>,
-    terminator: Option<u8>,
-    max_read_records: Option<usize>,
-    datetime_re: Option<Regex>,
-}
-
-/// Infer the schema of a CSV file by reading through the first n records of the file,
-/// with `max_read_records` controlling the maximum number of records to read.
-///
-/// If `max_read_records` is not set, the whole file is read to infer its schema.
-///
-/// Return inferred schema and number of records used for inference. This function does not change
-/// reader cursor offset.
-pub fn infer_file_schema<R: Read + Seek>(
-    reader: R,
-    delimiter: u8,
-    max_read_records: Option<usize>,
-    has_header: bool,
-) -> Result<(Schema, usize)> {
-    let roptions = ReaderOptions {
-        delimiter: Some(delimiter),
-        max_read_records,
-        has_header,
-        ..Default::default()
-    };
-
-    infer_file_schema_with_csv_options(reader, roptions)
-}
-
-fn infer_file_schema_with_csv_options<R: Read + Seek>(
-    mut reader: R,
-    roptions: ReaderOptions,
-) -> Result<(Schema, usize)> {
-    let saved_offset = reader.seek(SeekFrom::Current(0))?;
-
-    let (schema, records_count) =
-        infer_reader_schema_with_csv_options(&mut reader, roptions)?;
-    // return the reader seek back to the start
-    reader.seek(SeekFrom::Start(saved_offset))?;
-
-    Ok((schema, records_count))
-}
-
-/// Infer schema of CSV records provided by struct that implements `Read` trait.
-///
-/// `max_read_records` controlling the maximum number of records to read. If `max_read_records` is
-/// not set, all records are read to infer the schema.
-///
-/// Return infered schema and number of records used for inference.
-pub fn infer_reader_schema<R: Read>(
-    reader: R,
-    delimiter: u8,
-    max_read_records: Option<usize>,
-    has_header: bool,
-) -> Result<(Schema, usize)> {
-    let roptions = ReaderOptions {
-        delimiter: Some(delimiter),
-        max_read_records,
-        has_header,
-        ..Default::default()
-    };
-    infer_reader_schema_with_csv_options(reader, roptions)
-}
-
-fn infer_reader_schema_with_csv_options<R: Read>(
-    reader: R,
-    roptions: ReaderOptions,
-) -> Result<(Schema, usize)> {
-    let mut csv_reader = Reader::build_csv_reader(
-        reader,
-        roptions.has_header,
-        roptions.delimiter,
-        roptions.escape,
-        roptions.quote,
-        roptions.terminator,
-    );
-
-    // get or create header names
-    // when has_header is false, creates default column names with column_ prefix
-    let headers: Vec<String> = if roptions.has_header {
-        let headers = &csv_reader.headers()?.clone();
-        headers.iter().map(|s| s.to_string()).collect()
-    } else {
-        let first_record_count = &csv_reader.headers()?.len();
-        (0..*first_record_count)
-            .map(|i| format!("column_{}", i + 1))
-            .collect()
-    };
-
-    let header_length = headers.len();
-    // keep track of inferred field types
-    let mut column_types: Vec<HashSet<DataType>> = vec![HashSet::new(); header_length];
-    // keep track of columns with nulls
-    let mut nulls: Vec<bool> = vec![false; header_length];
-
-    let mut records_count = 0;
-    let mut fields = vec![];
-
-    let mut record = StringRecord::new();
-    let max_records = roptions.max_read_records.unwrap_or(usize::MAX);
-    while records_count < max_records {
-        if !csv_reader.read_record(&mut record)? {
-            break;
-        }
-        records_count += 1;
-
-        for i in 0..header_length {
-            if let Some(string) = record.get(i) {
-                if string.is_empty() {
-                    nulls[i] = true;
-                } else {
-                    column_types[i]
-                        .insert(infer_field_schema(string, roptions.datetime_re.clone()));
-                }
-            }
-        }
-    }
-
-    // build schema from inference results
-    for i in 0..header_length {
-        let possibilities = &column_types[i];
-        let has_nulls = nulls[i];
-        let field_name = &headers[i];
-
-        // determine data type based on possible types
-        // if there are incompatible types, use DataType::Utf8
-        match possibilities.len() {
-            1 => {
-                for dtype in possibilities.iter() {
-                    fields.push(Field::new(field_name, dtype.clone(), has_nulls));
-                }
-            }
-            2 => {
-                if possibilities.contains(&DataType::Int64)
-                    && possibilities.contains(&DataType::Float64)
-                {
-                    // we have an integer and double, fall down to double
-                    fields.push(Field::new(field_name, DataType::Float64, has_nulls));
-                } else {
-                    // default to Utf8 for conflicting datatypes (e.g bool and int)
-                    fields.push(Field::new(field_name, DataType::Utf8, has_nulls));
-                }
-            }
-            _ => fields.push(Field::new(field_name, DataType::Utf8, has_nulls)),
-        }
-    }
-
-    Ok((Schema::new(fields), records_count))
-}
-
-/// Infer schema from a list of CSV files by reading through first n records
-/// with `max_read_records` controlling the maximum number of records to read.
-///
-/// Files will be read in the given order untill n records have been reached.
-///
-/// If `max_read_records` is not set, all files will be read fully to infer the schema.
-pub fn infer_schema_from_files(
-    files: &[String],
-    delimiter: u8,
-    max_read_records: Option<usize>,
-    has_header: bool,
-) -> Result<Schema> {
-    let mut schemas = vec![];
-    let mut records_to_read = max_read_records.unwrap_or(usize::MAX);
-
-    for fname in files.iter() {
-        let (schema, records_read) = infer_file_schema(
-            &mut File::open(fname)?,
-            delimiter,
-            Some(records_to_read),
-            has_header,
-        )?;
-        if records_read == 0 {
-            continue;
-        }
-        schemas.push(schema.clone());
-        records_to_read -= records_read;
-        if records_to_read == 0 {
-            break;
-        }
-    }
-
-    Schema::try_merge(schemas)
-}
-
-// optional bounds of the reader, of the form (min line, max line).
-type Bounds = Option<(usize, usize)>;
-
-/// CSV file reader
-pub struct Reader<R: Read> {
-    /// Explicit schema for the CSV file
-    schema: SchemaRef,
-    /// Optional projection for which columns to load (zero-based column indices)
-    projection: Option<Vec<usize>>,
-    /// File reader
-    reader: csv_crate::Reader<R>,
-    /// Current line number
-    line_number: usize,
-    /// Maximum number of rows to read
-    end: usize,
-    /// Number of records per batch
-    batch_size: usize,
-    /// Vector that can hold the `StringRecord`s of the batches
-    batch_records: Vec<StringRecord>,
-    /// datetime format used to parse datetime values, (format understood by chrono)
-    ///
-    /// For format refer to [chrono docs](https://docs.rs/chrono/0.4.19/chrono/format/strftime/index.html)
-    datetime_format: Option<String>,
-}
-
-impl<R> fmt::Debug for Reader<R>
-where
-    R: Read,
-{
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("Reader")
-            .field("schema", &self.schema)
-            .field("projection", &self.projection)
-            .field("line_number", &self.line_number)
-            .field("datetime_format", &self.datetime_format)
-            .finish()
-    }
-}
-
-impl<R: Read> Reader<R> {
-    /// Create a new CsvReader from any value that implements the `Read` trait.
-    ///
-    /// If reading a `File` or an input that supports `std::io::Read` and `std::io::Seek`;
-    /// you can customise the Reader, such as to enable schema inference, use
-    /// `ReaderBuilder`.
-    #[allow(clippy::too_many_arguments)]
-    pub fn new(
-        reader: R,
-        schema: SchemaRef,
-        has_header: bool,
-        delimiter: Option<u8>,
-        batch_size: usize,
-        bounds: Bounds,
-        projection: Option<Vec<usize>>,
-        datetime_format: Option<String>,
-    ) -> Self {
-        Self::from_reader(
-            reader,
-            schema,
-            has_header,
-            delimiter,
-            batch_size,
-            bounds,
-            projection,
-            datetime_format,
-        )
-    }
-
-    /// Returns the schema of the reader, useful for getting the schema without reading
-    /// record batches
-    pub fn schema(&self) -> SchemaRef {
-        match &self.projection {
-            Some(projection) => {
-                let fields = self.schema.fields();
-                let projected_fields: Vec<Field> =
-                    projection.iter().map(|i| fields[*i].clone()).collect();
-
-                Arc::new(Schema::new(projected_fields))
-            }
-            None => self.schema.clone(),
-        }
-    }
-
-    /// Create a new CsvReader from a Reader
-    ///
-    /// This constructor allows you more flexibility in what records are processed by the
-    /// csv reader.
-    #[allow(clippy::too_many_arguments)]
-    pub fn from_reader(
-        reader: R,
-        schema: SchemaRef,
-        has_header: bool,
-        delimiter: Option<u8>,
-        batch_size: usize,
-        bounds: Bounds,
-        projection: Option<Vec<usize>>,
-        datetime_format: Option<String>,
-    ) -> Self {
-        let csv_reader =
-            Self::build_csv_reader(reader, has_header, delimiter, None, None, None);
-        Self::from_csv_reader(
-            csv_reader,
-            schema,
-            has_header,
-            batch_size,
-            bounds,
-            projection,
-            datetime_format,
-        )
-    }
-
-    fn build_csv_reader(
-        reader: R,
-        has_header: bool,
-        delimiter: Option<u8>,
-        escape: Option<u8>,
-        quote: Option<u8>,
-        terminator: Option<u8>,
-    ) -> csv_crate::Reader<R> {
-        let mut reader_builder = csv_crate::ReaderBuilder::new();
-        reader_builder.has_headers(has_header);
-
-        if let Some(c) = delimiter {
-            reader_builder.delimiter(c);
-        }
-        reader_builder.escape(escape);
-        if let Some(c) = quote {
-            reader_builder.quote(c);
-        }
-        if let Some(t) = terminator {
-            reader_builder.terminator(csv_crate::Terminator::Any(t));
-        }
-        reader_builder.from_reader(reader)
-    }
-
-    fn from_csv_reader(
-        mut csv_reader: csv_crate::Reader<R>,
-        schema: SchemaRef,
-        has_header: bool,
-        batch_size: usize,
-        bounds: Bounds,
-        projection: Option<Vec<usize>>,
-        datetime_format: Option<String>,
-    ) -> Self {
-        let (start, end) = match bounds {
-            None => (0, usize::MAX),
-            Some((start, end)) => (start, end),
-        };
-
-        // First we will skip `start` rows
-        // note that this skips by iteration. This is because in general it is not possible
-        // to seek in CSV. However, skipping still saves the burden of creating arrow arrays,
-        // which is a slow operation that scales with the number of columns
-
-        let mut record = ByteRecord::new();
-        // Skip first start items
-        for _ in 0..start {
-            let res = csv_reader.read_byte_record(&mut record);
-            if !res.unwrap_or(false) {
-                break;
-            }
-        }
-
-        // Initialize batch_records with StringRecords so they
-        // can be reused across batches
-        let mut batch_records = Vec::with_capacity(batch_size);
-        batch_records.resize_with(batch_size, Default::default);
-
-        Self {
-            schema,
-            projection,
-            reader: csv_reader,
-            line_number: if has_header { start + 1 } else { start },
-            batch_size,
-            end,
-            batch_records,
-            datetime_format,
-        }
-    }
-}
-
-impl<R: Read> Iterator for Reader<R> {
-    type Item = Result<RecordBatch>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let remaining = self.end - self.line_number;
-
-        let mut read_records = 0;
-        for i in 0..min(self.batch_size, remaining) {
-            match self.reader.read_record(&mut self.batch_records[i]) {
-                Ok(true) => {
-                    read_records += 1;
-                }
-                Ok(false) => break,
-                Err(e) => {
-                    return Some(Err(ArrowError::ParseError(format!(
-                        "Error parsing line {}: {:?}",
-                        self.line_number + i,
-                        e
-                    ))));
-                }
-            }
-        }
-
-        // return early if no data was loaded
-        if read_records == 0 {
-            return None;
-        }
-
-        let format: Option<&str> = match self.datetime_format {
-            Some(ref format) => Some(format.as_ref()),
-            _ => None,
-        };
-
-        // parse the batches into a RecordBatch
-        let result = parse(
-            &self.batch_records[..read_records],
-            self.schema.fields(),
-            Some(self.schema.metadata.clone()),
-            self.projection.as_ref(),
-            self.line_number,
-            format,
-        );
-
-        self.line_number += read_records;
-
-        Some(result)
-    }
-}
-
-/// parses a slice of [csv_crate::StringRecord] into a
-/// [RecordBatch](crate::record_batch::RecordBatch).
-fn parse(
-    rows: &[StringRecord],
-    fields: &[Field],
-    metadata: Option<std::collections::HashMap<String, String>>,
-    projection: Option<&Vec<usize>>,
-    line_number: usize,
-    datetime_format: Option<&str>,
-) -> Result<RecordBatch> {
-    let projection: Vec<usize> = match projection {
-        Some(v) => v.clone(),
-        None => fields.iter().enumerate().map(|(i, _)| i).collect(),
-    };
-
-    let arrays: Result<Vec<ArrayRef>> = projection
-        .iter()
-        .map(|i| {
-            let i = *i;
-            let field = &fields[i];
-            match field.data_type() {
-                DataType::Boolean => build_boolean_array(line_number, rows, i),
-                DataType::Decimal128(precision, scale) => {
-                    build_decimal_array(line_number, rows, i, *precision, *scale)
-                }
-                DataType::Int8 => {
-                    build_primitive_array::<Int8Type>(line_number, rows, i, None)
-                }
-                DataType::Int16 => {
-                    build_primitive_array::<Int16Type>(line_number, rows, i, None)
-                }
-                DataType::Int32 => {
-                    build_primitive_array::<Int32Type>(line_number, rows, i, None)
-                }
-                DataType::Int64 => {
-                    build_primitive_array::<Int64Type>(line_number, rows, i, None)
-                }
-                DataType::UInt8 => {
-                    build_primitive_array::<UInt8Type>(line_number, rows, i, None)
-                }
-                DataType::UInt16 => {
-                    build_primitive_array::<UInt16Type>(line_number, rows, i, None)
-                }
-                DataType::UInt32 => {
-                    build_primitive_array::<UInt32Type>(line_number, rows, i, None)
-                }
-                DataType::UInt64 => {
-                    build_primitive_array::<UInt64Type>(line_number, rows, i, None)
-                }
-                DataType::Float32 => {
-                    build_primitive_array::<Float32Type>(line_number, rows, i, None)
-                }
-                DataType::Float64 => {
-                    build_primitive_array::<Float64Type>(line_number, rows, i, None)
-                }
-                DataType::Date32 => {
-                    build_primitive_array::<Date32Type>(line_number, rows, i, None)
-                }
-                DataType::Date64 => build_primitive_array::<Date64Type>(
-                    line_number,
-                    rows,
-                    i,
-                    datetime_format,
-                ),
-                DataType::Timestamp(TimeUnit::Microsecond, _) => {
-                    build_primitive_array::<TimestampMicrosecondType>(
-                        line_number,
-                        rows,
-                        i,
-                        None,
-                    )
-                }
-                DataType::Timestamp(TimeUnit::Nanosecond, _) => {
-                    build_primitive_array::<TimestampNanosecondType>(
-                        line_number,
-                        rows,
-                        i,
-                        None,
-                    )
-                }
-                DataType::Utf8 => Ok(Arc::new(
-                    rows.iter().map(|row| row.get(i)).collect::<StringArray>(),
-                ) as ArrayRef),
-                DataType::Dictionary(key_type, value_type)
-                    if value_type.as_ref() == &DataType::Utf8 =>
-                {
-                    match key_type.as_ref() {
-                        DataType::Int8 => Ok(Arc::new(
-                            rows.iter()
-                                .map(|row| row.get(i))
-                                .collect::<DictionaryArray<Int8Type>>(),
-                        ) as ArrayRef),
-                        DataType::Int16 => Ok(Arc::new(
-                            rows.iter()
-                                .map(|row| row.get(i))
-                                .collect::<DictionaryArray<Int16Type>>(),
-                        ) as ArrayRef),
-                        DataType::Int32 => Ok(Arc::new(
-                            rows.iter()
-                                .map(|row| row.get(i))
-                                .collect::<DictionaryArray<Int32Type>>(),
-                        ) as ArrayRef),
-                        DataType::Int64 => Ok(Arc::new(
-                            rows.iter()
-                                .map(|row| row.get(i))
-                                .collect::<DictionaryArray<Int64Type>>(),
-                        ) as ArrayRef),
-                        DataType::UInt8 => Ok(Arc::new(
-                            rows.iter()
-                                .map(|row| row.get(i))
-                                .collect::<DictionaryArray<UInt8Type>>(),
-                        ) as ArrayRef),
-                        DataType::UInt16 => Ok(Arc::new(
-                            rows.iter()
-                                .map(|row| row.get(i))
-                                .collect::<DictionaryArray<UInt16Type>>(),
-                        ) as ArrayRef),
-                        DataType::UInt32 => Ok(Arc::new(
-                            rows.iter()
-                                .map(|row| row.get(i))
-                                .collect::<DictionaryArray<UInt32Type>>(),
-                        ) as ArrayRef),
-                        DataType::UInt64 => Ok(Arc::new(
-                            rows.iter()
-                                .map(|row| row.get(i))
-                                .collect::<DictionaryArray<UInt64Type>>(),
-                        ) as ArrayRef),
-                        _ => Err(ArrowError::ParseError(format!(
-                            "Unsupported dictionary key type {:?}",
-                            key_type
-                        ))),
-                    }
-                }
-                other => Err(ArrowError::ParseError(format!(
-                    "Unsupported data type {:?}",
-                    other
-                ))),
-            }
-        })
-        .collect();
-
-    let projected_fields: Vec<Field> =
-        projection.iter().map(|i| fields[*i].clone()).collect();
-
-    let projected_schema = Arc::new(match metadata {
-        None => Schema::new(projected_fields),
-        Some(metadata) => Schema::new_with_metadata(projected_fields, metadata),
-    });
-
-    arrays.and_then(|arr| RecordBatch::try_new(projected_schema, arr))
-}
-fn parse_item<T: Parser>(string: &str) -> Option<T::Native> {
-    T::parse(string)
-}
-
-fn parse_formatted<T: Parser>(string: &str, format: &str) -> Option<T::Native> {
-    T::parse_formatted(string, format)
-}
-
-fn parse_bool(string: &str) -> Option<bool> {
-    if string.eq_ignore_ascii_case("false") {
-        Some(false)
-    } else if string.eq_ignore_ascii_case("true") {
-        Some(true)
-    } else {
-        None
-    }
-}
-
-// parse the column string to an Arrow Array
-fn build_decimal_array(
-    _line_number: usize,
-    rows: &[StringRecord],
-    col_idx: usize,
-    precision: usize,
-    scale: usize,
-) -> Result<ArrayRef> {
-    let mut decimal_builder = Decimal128Builder::new(rows.len(), precision, scale);
-    for row in rows {
-        let col_s = row.get(col_idx);
-        match col_s {
-            None => {
-                // No data for this row
-                decimal_builder.append_null();
-            }
-            Some(s) => {
-                if s.is_empty() {
-                    // append null
-                    decimal_builder.append_null();
-                } else {
-                    let decimal_value: Result<i128> =
-                        parse_decimal_with_parameter(s, precision, scale);
-                    match decimal_value {
-                        Ok(v) => {
-                            decimal_builder.append_value(v)?;
-                        }
-                        Err(e) => {
-                            return Err(e);
-                        }
-                    }
-                }
-            }
-        }
-    }
-    Ok(Arc::new(decimal_builder.finish()))
-}
-
-// Parse the string format decimal value to i128 format and checking the precision and scale.
-// The result i128 value can't be out of bounds.
-fn parse_decimal_with_parameter(s: &str, precision: usize, scale: usize) -> Result<i128> {
-    if PARSE_DECIMAL_RE.is_match(s) {
-        let mut offset = s.len();
-        let len = s.len();
-        let mut base = 1;
-
-        // handle the value after the '.' and meet the scale
-        let delimiter_position = s.find('.');
-        match delimiter_position {
-            None => {
-                // there is no '.'
-                base = 10_i128.pow(scale as u32);
-            }
-            Some(mid) => {
-                // there is the '.'
-                if len - mid >= scale + 1 {
-                    // If the string value is "123.12345" and the scale is 2, we should just remain '.12' and drop the '345' value.
-                    offset -= len - mid - 1 - scale;
-                } else {
-                    // If the string value is "123.12" and the scale is 4, we should append '00' to the tail.
-                    base = 10_i128.pow((scale + 1 + mid - len) as u32);
-                }
-            }
-        };
-
-        // each byte is digit、'-' or '.'
-        let bytes = s.as_bytes();
-        let mut negative = false;
-        let mut result: i128 = 0;
-
-        bytes[0..offset].iter().rev().for_each(|&byte| match byte {
-            b'-' => {
-                negative = true;
-            }
-            b'0'..=b'9' => {
-                result += i128::from(byte - b'0') * base;
-                base *= 10;
-            }
-            // because of the PARSE_DECIMAL_RE, bytes just contains digit、'-' and '.'.
-            _ => {}
-        });
-
-        if negative {
-            result = result.neg();
-        }
-        validate_decimal_precision(result, precision)
-            .map_err(|e| ArrowError::ParseError(format!("parse decimal overflow: {}", e)))
-    } else {
-        Err(ArrowError::ParseError(format!(
-            "can't parse the string value {} to decimal",
-            s
-        )))
-    }
-}
-
-// Parse the string format decimal value to i128 format without checking the precision and scale.
-// Like "125.12" to 12512_i128.
-#[cfg(test)]
-fn parse_decimal(s: &str) -> Result<i128> {
-    if PARSE_DECIMAL_RE.is_match(s) {
-        let mut offset = s.len();
-        // each byte is digit、'-' or '.'
-        let bytes = s.as_bytes();
-        let mut negative = false;
-        let mut result: i128 = 0;
-        let mut base = 1;
-        while offset > 0 {
-            match bytes[offset - 1] {
-                b'-' => {
-                    negative = true;
-                }
-                b'.' => {
-                    // do nothing
-                }
-                b'0'..=b'9' => {
-                    result += i128::from(bytes[offset - 1] - b'0') * base;
-                    base *= 10;
-                }
-                _ => {
-                    return Err(ArrowError::ParseError(format!(
-                        "can't match byte {}",
-                        bytes[offset - 1]
-                    )));
-                }
-            }
-            offset -= 1;
-        }
-        if negative {
-            Ok(result.neg())
-        } else {
-            Ok(result)
-        }
-    } else {
-        Err(ArrowError::ParseError(format!(
-            "can't parse the string value {} to decimal",
-            s
-        )))
-    }
-}
-
-// parses a specific column (col_idx) into an Arrow Array.
-fn build_primitive_array<T: ArrowPrimitiveType + Parser>(
-    line_number: usize,
-    rows: &[StringRecord],
-    col_idx: usize,
-    format: Option<&str>,
-) -> Result<ArrayRef> {
-    rows.iter()
-        .enumerate()
-        .map(|(row_index, row)| {
-            match row.get(col_idx) {
-                Some(s) => {
-                    if s.is_empty() {
-                        return Ok(None);
-                    }
-
-                    let parsed = match format {
-                        Some(format) => parse_formatted::<T>(s, format),
-                        _ => parse_item::<T>(s),
-                    };
-                    match parsed {
-                        Some(e) => Ok(Some(e)),
-                        None => Err(ArrowError::ParseError(format!(
-                            // TODO: we should surface the underlying error here.
-                            "Error while parsing value {} for column {} at line {}",
-                            s,
-                            col_idx,
-                            line_number + row_index
-                        ))),
-                    }
-                }
-                None => Ok(None),
-            }
-        })
-        .collect::<Result<PrimitiveArray<T>>>()
-        .map(|e| Arc::new(e) as ArrayRef)
-}
-
-// parses a specific column (col_idx) into an Arrow Array.
-fn build_boolean_array(
-    line_number: usize,
-    rows: &[StringRecord],
-    col_idx: usize,
-) -> Result<ArrayRef> {
-    rows.iter()
-        .enumerate()
-        .map(|(row_index, row)| {
-            match row.get(col_idx) {
-                Some(s) => {
-                    if s.is_empty() {
-                        return Ok(None);
-                    }
-
-                    let parsed = parse_bool(s);
-                    match parsed {
-                        Some(e) => Ok(Some(e)),
-                        None => Err(ArrowError::ParseError(format!(
-                            // TODO: we should surface the underlying error here.
-                            "Error while parsing value {} for column {} at line {}",
-                            s,
-                            col_idx,
-                            line_number + row_index
-                        ))),
-                    }
-                }
-                None => Ok(None),
-            }
-        })
-        .collect::<Result<BooleanArray>>()
-        .map(|e| Arc::new(e) as ArrayRef)
-}
-
-/// CSV file reader builder
-#[derive(Debug)]
-pub struct ReaderBuilder {
-    /// Optional schema for the CSV file
-    ///
-    /// If the schema is not supplied, the reader will try to infer the schema
-    /// based on the CSV structure.
-    schema: Option<SchemaRef>,
-    /// Whether the file has headers or not
-    ///
-    /// If schema inference is run on a file with no headers, default column names
-    /// are created.
-    has_header: bool,
-    /// An optional column delimiter. Defaults to `b','`
-    delimiter: Option<u8>,
-    /// An optional escape character. Defaults None
-    escape: Option<u8>,
-    /// An optional quote character. Defaults b'\"'
-    quote: Option<u8>,
-    /// An optional record terminator. Defaults CRLF
-    terminator: Option<u8>,
-    /// Optional maximum number of records to read during schema inference
-    ///
-    /// If a number is not provided, all the records are read.
-    max_records: Option<usize>,
-    /// Batch size (number of records to load each time)
-    ///
-    /// The default batch size when using the `ReaderBuilder` is 1024 records
-    batch_size: usize,
-    /// The bounds over which to scan the reader. `None` starts from 0 and runs until EOF.
-    bounds: Bounds,
-    /// Optional projection for which columns to load (zero-based column indices)
-    projection: Option<Vec<usize>>,
-    /// DateTime format to be used while trying to infer datetime format
-    datetime_re: Option<Regex>,
-    /// DateTime format to be used while parsing datetime format
-    datetime_format: Option<String>,
-}
-
-impl Default for ReaderBuilder {
-    fn default() -> Self {
-        Self {
-            schema: None,
-            has_header: false,
-            delimiter: None,
-            escape: None,
-            quote: None,
-            terminator: None,
-            max_records: None,
-            batch_size: 1024,
-            bounds: None,
-            projection: None,
-            datetime_re: None,
-            datetime_format: None,
-        }
-    }
-}
-
-impl ReaderBuilder {
-    /// Create a new builder for configuring CSV parsing options.
-    ///
-    /// To convert a builder into a reader, call `ReaderBuilder::build`
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// extern crate arrow;
-    ///
-    /// use arrow::csv;
-    /// use std::fs::File;
-    ///
-    /// fn example() -> csv::Reader<File> {
-    ///     let file = File::open("test/data/uk_cities_with_headers.csv").unwrap();
-    ///
-    ///     // create a builder, inferring the schema with the first 100 records
-    ///     let builder = csv::ReaderBuilder::new().infer_schema(Some(100));
-    ///
-    ///     let reader = builder.build(file).unwrap();
-    ///
-    ///     reader
-    /// }
-    /// ```
-    pub fn new() -> ReaderBuilder {
-        ReaderBuilder::default()
-    }
-
-    /// Set the CSV file's schema
-    pub fn with_schema(mut self, schema: SchemaRef) -> Self {
-        self.schema = Some(schema);
-        self
-    }
-
-    /// Set whether the CSV file has headers
-    pub fn has_header(mut self, has_header: bool) -> Self {
-        self.has_header = has_header;
-        self
-    }
-
-    /// Set the datetime regex used to parse the string to Date64Type
-    /// this regex is used while infering schema
-    pub fn with_datetime_re(mut self, datetime_re: Regex) -> Self {
-        self.datetime_re = Some(datetime_re);
-        self
-    }
-
-    /// Set the datetime fromat used to parse the string to Date64Type
-    /// this fromat is used while when the schema wants to parse Date64Type.
-    ///
-    /// For format refer to [chrono docs](https://docs.rs/chrono/0.4.19/chrono/format/strftime/index.html)
-    ///
-    pub fn with_datetime_format(mut self, datetime_format: String) -> Self {
-        self.datetime_format = Some(datetime_format);
-        self
-    }
-
-    /// Set the CSV file's column delimiter as a byte character
-    pub fn with_delimiter(mut self, delimiter: u8) -> Self {
-        self.delimiter = Some(delimiter);
-        self
-    }
-
-    pub fn with_escape(mut self, escape: u8) -> Self {
-        self.escape = Some(escape);
-        self
-    }
-
-    pub fn with_quote(mut self, quote: u8) -> Self {
-        self.quote = Some(quote);
-        self
-    }
-
-    pub fn with_terminator(mut self, terminator: u8) -> Self {
-        self.terminator = Some(terminator);
-        self
-    }
-
-    /// Set the CSV reader to infer the schema of the file
-    pub fn infer_schema(mut self, max_records: Option<usize>) -> Self {
-        // remove any schema that is set
-        self.schema = None;
-        self.max_records = max_records;
-        self
-    }
-
-    /// Set the batch size (number of records to load at one time)
-    pub fn with_batch_size(mut self, batch_size: usize) -> Self {
-        self.batch_size = batch_size;
-        self
-    }
-
-    /// Set the bounds over which to scan the reader.
-    /// `start` and `end` are line numbers.
-    pub fn with_bounds(mut self, start: usize, end: usize) -> Self {
-        self.bounds = Some((start, end));
-        self
-    }
-
-    /// Set the reader's column projection
-    pub fn with_projection(mut self, projection: Vec<usize>) -> Self {
-        self.projection = Some(projection);
-        self
-    }
-
-    /// Create a new `Reader` from the `ReaderBuilder`
-    pub fn build<R: Read + Seek>(self, mut reader: R) -> Result<Reader<R>> {
-        // check if schema should be inferred
-        let delimiter = self.delimiter.unwrap_or(b',');
-        let schema = match self.schema {
-            Some(schema) => schema,
-            None => {
-                let roptions = ReaderOptions {
-                    delimiter: Some(delimiter),
-                    max_read_records: self.max_records,
-                    has_header: self.has_header,
-                    escape: self.escape,
-                    quote: self.quote,
-                    terminator: self.terminator,
-                    datetime_re: self.datetime_re,
-                };
-                let (inferred_schema, _) =
-                    infer_file_schema_with_csv_options(&mut reader, roptions)?;
-
-                Arc::new(inferred_schema)
-            }
-        };
-        let csv_reader = Reader::build_csv_reader(
-            reader,
-            self.has_header,
-            self.delimiter,
-            self.escape,
-            self.quote,
-            self.terminator,
-        );
-        Ok(Reader::from_csv_reader(
-            csv_reader,
-            schema,
-            self.has_header,
-            self.batch_size,
-            self.bounds,
-            self.projection.clone(),
-            self.datetime_format,
-        ))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use std::fs::File;
-    use std::io::{Cursor, Write};
-    use tempfile::NamedTempFile;
-
-    use crate::array::*;
-    use crate::compute::cast;
-    use crate::datatypes::Field;
-    use chrono::{prelude::*, LocalResult};
-
-    #[test]
-    fn test_csv() {
-        let _: Vec<()> = vec![None, Some("%Y-%m-%dT%H:%M:%S%.f%:z".to_string())]
-            .into_iter()
-            .map(|format| {
-                let schema = Schema::new(vec![
-                    Field::new("city", DataType::Utf8, false),
-                    Field::new("lat", DataType::Float64, false),
-                    Field::new("lng", DataType::Float64, false),
-                ]);
-
-                let file = File::open("test/data/uk_cities.csv").unwrap();
-                let mut csv = Reader::new(
-                    file,
-                    Arc::new(schema.clone()),
-                    false,
-                    None,
-                    1024,
-                    None,
-                    None,
-                    format,
-                );
-                assert_eq!(Arc::new(schema), csv.schema());
-                let batch = csv.next().unwrap().unwrap();
-                assert_eq!(37, batch.num_rows());
-                assert_eq!(3, batch.num_columns());
-
-                // access data from a primitive array
-                let lat = batch
-                    .column(1)
-                    .as_any()
-                    .downcast_ref::<Float64Array>()
-                    .unwrap();
-                assert_eq!(57.653484, lat.value(0));
-
-                // access data from a string array (ListArray<u8>)
-                let city = batch
-                    .column(0)
-                    .as_any()
-                    .downcast_ref::<StringArray>()
-                    .unwrap();
-
-                assert_eq!("Aberdeen, Aberdeen City, UK", city.value(13));
-            })
-            .collect();
-    }
-
-    #[test]
-    fn test_csv_schema_metadata() {
-        let mut metadata = std::collections::HashMap::new();
-        metadata.insert("foo".to_owned(), "bar".to_owned());
-        let schema = Schema::new_with_metadata(
-            vec![
-                Field::new("city", DataType::Utf8, false),
-                Field::new("lat", DataType::Float64, false),
-                Field::new("lng", DataType::Float64, false),
-            ],
-            metadata.clone(),
-        );
-
-        let file = File::open("test/data/uk_cities.csv").unwrap();
-
-        let mut csv = Reader::new(
-            file,
-            Arc::new(schema.clone()),
-            false,
-            None,
-            1024,
-            None,
-            None,
-            None,
-        );
-        assert_eq!(Arc::new(schema), csv.schema());
-        let batch = csv.next().unwrap().unwrap();
-        assert_eq!(37, batch.num_rows());
-        assert_eq!(3, batch.num_columns());
-
-        assert_eq!(&metadata, batch.schema().metadata());
-    }
-
-    #[test]
-    fn test_csv_reader_with_decimal() {
-        let schema = Schema::new(vec![
-            Field::new("city", DataType::Utf8, false),
-            Field::new("lat", DataType::Decimal128(38, 6), false),
-            Field::new("lng", DataType::Decimal128(38, 6), false),
-        ]);
-
-        let file = File::open("test/data/decimal_test.csv").unwrap();
-
-        let mut csv =
-            Reader::new(file, Arc::new(schema), false, None, 1024, None, None, None);
-        let batch = csv.next().unwrap().unwrap();
-        // access data from a primitive array
-        let lat = batch
-            .column(1)
-            .as_any()
-            .downcast_ref::<Decimal128Array>()
-            .unwrap();
-
-        assert_eq!("57.653484", lat.value_as_string(0));
-        assert_eq!("53.002666", lat.value_as_string(1));
-        assert_eq!("52.412811", lat.value_as_string(2));
-        assert_eq!("51.481583", lat.value_as_string(3));
-        assert_eq!("12.123456", lat.value_as_string(4));
-        assert_eq!("50.760000", lat.value_as_string(5));
-        assert_eq!("0.123000", lat.value_as_string(6));
-        assert_eq!("123.000000", lat.value_as_string(7));
-        assert_eq!("123.000000", lat.value_as_string(8));
-        assert_eq!("-50.760000", lat.value_as_string(9));
-    }
-
-    #[test]
-    fn test_csv_from_buf_reader() {
-        let schema = Schema::new(vec![
-            Field::new("city", DataType::Utf8, false),
-            Field::new("lat", DataType::Float64, false),
-            Field::new("lng", DataType::Float64, false),
-        ]);
-
-        let file_with_headers =
-            File::open("test/data/uk_cities_with_headers.csv").unwrap();
-        let file_without_headers = File::open("test/data/uk_cities.csv").unwrap();
-        let both_files = file_with_headers
-            .chain(Cursor::new("\n".to_string()))
-            .chain(file_without_headers);
-        let mut csv = Reader::from_reader(
-            both_files,
-            Arc::new(schema),
-            true,
-            None,
-            1024,
-            None,
-            None,
-            None,
-        );
-        let batch = csv.next().unwrap().unwrap();
-        assert_eq!(74, batch.num_rows());
-        assert_eq!(3, batch.num_columns());
-    }
-
-    #[test]
-    fn test_csv_with_schema_inference() {
-        let file = File::open("test/data/uk_cities_with_headers.csv").unwrap();
-
-        let builder = ReaderBuilder::new().has_header(true).infer_schema(None);
-
-        let mut csv = builder.build(file).unwrap();
-        let expected_schema = Schema::new(vec![
-            Field::new("city", DataType::Utf8, false),
-            Field::new("lat", DataType::Float64, false),
-            Field::new("lng", DataType::Float64, false),
-        ]);
-        assert_eq!(Arc::new(expected_schema), csv.schema());
-        let batch = csv.next().unwrap().unwrap();
-        assert_eq!(37, batch.num_rows());
-        assert_eq!(3, batch.num_columns());
-
-        // access data from a primitive array
-        let lat = batch
-            .column(1)
-            .as_any()
-            .downcast_ref::<Float64Array>()
-            .unwrap();
-        assert_eq!(57.653484, lat.value(0));
-
-        // access data from a string array (ListArray<u8>)
-        let city = batch
-            .column(0)
-            .as_any()
-            .downcast_ref::<StringArray>()
-            .unwrap();
-
-        assert_eq!("Aberdeen, Aberdeen City, UK", city.value(13));
-    }
-
-    #[test]
-    fn test_csv_with_schema_inference_no_headers() {
-        let file = File::open("test/data/uk_cities.csv").unwrap();
-
-        let builder = ReaderBuilder::new().infer_schema(None);
-
-        let mut csv = builder.build(file).unwrap();
-
-        // csv field names should be 'column_{number}'
-        let schema = csv.schema();
-        assert_eq!("column_1", schema.field(0).name());
-        assert_eq!("column_2", schema.field(1).name());
-        assert_eq!("column_3", schema.field(2).name());
-        let batch = csv.next().unwrap().unwrap();
-        let batch_schema = batch.schema();
-
-        assert_eq!(schema, batch_schema);
-        assert_eq!(37, batch.num_rows());
-        assert_eq!(3, batch.num_columns());
-
-        // access data from a primitive array
-        let lat = batch
-            .column(1)
-            .as_any()
-            .downcast_ref::<Float64Array>()
-            .unwrap();
-        assert_eq!(57.653484, lat.value(0));
-
-        // access data from a string array (ListArray<u8>)
-        let city = batch
-            .column(0)
-            .as_any()
-            .downcast_ref::<StringArray>()
-            .unwrap();
-
-        assert_eq!("Aberdeen, Aberdeen City, UK", city.value(13));
-    }
-
-    #[test]
-    fn test_csv_builder_with_bounds() {
-        let file = File::open("test/data/uk_cities.csv").unwrap();
-
-        // Set the bounds to the lines 0, 1 and 2.
-        let mut csv = ReaderBuilder::new().with_bounds(0, 2).build(file).unwrap();
-        let batch = csv.next().unwrap().unwrap();
-
-        // access data from a string array (ListArray<u8>)
-        let city = batch
-            .column(0)
-            .as_any()
-            .downcast_ref::<StringArray>()
-            .unwrap();
-
-        // The value on line 0 is within the bounds
-        assert_eq!("Elgin, Scotland, the UK", city.value(0));
-
-        // The value on line 13 is outside of the bounds. Therefore
-        // the call to .value() will panic.
-        let result = std::panic::catch_unwind(|| city.value(13));
-        assert!(result.is_err());
-    }
-
-    #[test]
-    fn test_csv_with_projection() {
-        let schema = Schema::new(vec![
-            Field::new("city", DataType::Utf8, false),
-            Field::new("lat", DataType::Float64, false),
-            Field::new("lng", DataType::Float64, false),
-        ]);
-
-        let file = File::open("test/data/uk_cities.csv").unwrap();
-
-        let mut csv = Reader::new(
-            file,
-            Arc::new(schema),
-            false,
-            None,
-            1024,
-            None,
-            Some(vec![0, 1]),
-            None,
-        );
-        let projected_schema = Arc::new(Schema::new(vec![
-            Field::new("city", DataType::Utf8, false),
-            Field::new("lat", DataType::Float64, false),
-        ]));
-        assert_eq!(projected_schema, csv.schema());
-        let batch = csv.next().unwrap().unwrap();
-        assert_eq!(projected_schema, batch.schema());
-        assert_eq!(37, batch.num_rows());
-        assert_eq!(2, batch.num_columns());
-    }
-
-    #[test]
-    fn test_csv_with_dictionary() {
-        let schema = Schema::new(vec![
-            Field::new(
-                "city",
-                DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
-                false,
-            ),
-            Field::new("lat", DataType::Float64, false),
-            Field::new("lng", DataType::Float64, false),
-        ]);
-
-        let file = File::open("test/data/uk_cities.csv").unwrap();
-
-        let mut csv = Reader::new(
-            file,
-            Arc::new(schema),
-            false,
-            None,
-            1024,
-            None,
-            Some(vec![0, 1]),
-            None,
-        );
-        let projected_schema = Arc::new(Schema::new(vec![
-            Field::new(
-                "city",
-                DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
-                false,
-            ),
-            Field::new("lat", DataType::Float64, false),
-        ]));
-        assert_eq!(projected_schema, csv.schema());
-        let batch = csv.next().unwrap().unwrap();
-        assert_eq!(projected_schema, batch.schema());
-        assert_eq!(37, batch.num_rows());
-        assert_eq!(2, batch.num_columns());
-
-        let strings = cast(batch.column(0), &DataType::Utf8).unwrap();
-        let strings = strings.as_any().downcast_ref::<StringArray>().unwrap();
-
-        assert_eq!(strings.value(0), "Elgin, Scotland, the UK");
-        assert_eq!(strings.value(4), "Eastbourne, East Sussex, UK");
-        assert_eq!(strings.value(29), "Uckfield, East Sussex, UK");
-    }
-
-    #[test]
-    fn test_nulls() {
-        let schema = Schema::new(vec![
-            Field::new("c_int", DataType::UInt64, false),
-            Field::new("c_float", DataType::Float32, true),
-            Field::new("c_string", DataType::Utf8, false),
-        ]);
-
-        let file = File::open("test/data/null_test.csv").unwrap();
-
-        let mut csv =
-            Reader::new(file, Arc::new(schema), true, None, 1024, None, None, None);
-        let batch = csv.next().unwrap().unwrap();
-
-        assert!(!batch.column(1).is_null(0));
-        assert!(!batch.column(1).is_null(1));
-        assert!(batch.column(1).is_null(2));
-        assert!(!batch.column(1).is_null(3));
-        assert!(!batch.column(1).is_null(4));
-    }
-
-    #[test]
-    fn test_nulls_with_inference() {
-        let file = File::open("test/data/various_types.csv").unwrap();
-
-        let builder = ReaderBuilder::new()
-            .infer_schema(None)
-            .has_header(true)
-            .with_delimiter(b'|')
-            .with_batch_size(512)
-            .with_projection(vec![0, 1, 2, 3, 4, 5]);
-
-        let mut csv = builder.build(file).unwrap();
-        let batch = csv.next().unwrap().unwrap();
-
-        assert_eq!(7, batch.num_rows());
-        assert_eq!(6, batch.num_columns());
-
-        let schema = batch.schema();
-
-        assert_eq!(&DataType::Int64, schema.field(0).data_type());
-        assert_eq!(&DataType::Float64, schema.field(1).data_type());
-        assert_eq!(&DataType::Float64, schema.field(2).data_type());
-        assert_eq!(&DataType::Boolean, schema.field(3).data_type());
-        assert_eq!(&DataType::Date32, schema.field(4).data_type());
-        assert_eq!(&DataType::Date64, schema.field(5).data_type());
-
-        let names: Vec<&str> =
-            schema.fields().iter().map(|x| x.name().as_str()).collect();
-        assert_eq!(
-            names,
-            vec![
-                "c_int",
-                "c_float",
-                "c_string",
-                "c_bool",
-                "c_date",
-                "c_datetime"
-            ]
-        );
-
-        assert!(!schema.field(0).is_nullable());
-        assert!(schema.field(1).is_nullable());
-        assert!(schema.field(2).is_nullable());
-        assert!(!schema.field(3).is_nullable());
-        assert!(schema.field(4).is_nullable());
-        assert!(schema.field(5).is_nullable());
-
-        assert!(!batch.column(1).is_null(0));
-        assert!(!batch.column(1).is_null(1));
-        assert!(batch.column(1).is_null(2));
-        assert!(!batch.column(1).is_null(3));
-        assert!(!batch.column(1).is_null(4));
-    }
-
-    #[test]
-    fn test_parse_invalid_csv() {
-        let file = File::open("test/data/various_types_invalid.csv").unwrap();
-
-        let schema = Schema::new(vec![
-            Field::new("c_int", DataType::UInt64, false),
-            Field::new("c_float", DataType::Float32, false),
-            Field::new("c_string", DataType::Utf8, false),
-            Field::new("c_bool", DataType::Boolean, false),
-        ]);
-
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .has_header(true)
-            .with_delimiter(b'|')
-            .with_batch_size(512)
-            .with_projection(vec![0, 1, 2, 3]);
-
-        let mut csv = builder.build(file).unwrap();
-        match csv.next() {
-            Some(e) => match e {
-                Err(e) => assert_eq!(
-                    "ParseError(\"Error while parsing value 4.x4 for column 1 at line 4\")",
-                    format!("{:?}", e)
-                ),
-                Ok(_) => panic!("should have failed"),
-            },
-            None => panic!("should have failed"),
-        }
-    }
-
-    #[test]
-    fn test_infer_field_schema() {
-        assert_eq!(infer_field_schema("A", None), DataType::Utf8);
-        assert_eq!(infer_field_schema("\"123\"", None), DataType::Utf8);
-        assert_eq!(infer_field_schema("10", None), DataType::Int64);
-        assert_eq!(infer_field_schema("10.2", None), DataType::Float64);
-        assert_eq!(infer_field_schema(".2", None), DataType::Float64);
-        assert_eq!(infer_field_schema("2.", None), DataType::Float64);
-        assert_eq!(infer_field_schema("true", None), DataType::Boolean);
-        assert_eq!(infer_field_schema("false", None), DataType::Boolean);
-        assert_eq!(infer_field_schema("2020-11-08", None), DataType::Date32);
-        assert_eq!(
-            infer_field_schema("2020-11-08T14:20:01", None),
-            DataType::Date64
-        );
-        // to be inferred as a date64 this needs a custom datetime_re
-        assert_eq!(
-            infer_field_schema("2020-11-08 14:20:01", None),
-            DataType::Utf8
-        );
-        let reg = Regex::new(r"^\d{4}-\d\d-\d\d \d\d:\d\d:\d\d$").ok();
-        assert_eq!(
-            infer_field_schema("2020-11-08 14:20:01", reg),
-            DataType::Date64
-        );
-        assert_eq!(infer_field_schema("-5.13", None), DataType::Float64);
-        assert_eq!(infer_field_schema("0.1300", None), DataType::Float64);
-    }
-
-    #[test]
-    fn parse_date32() {
-        assert_eq!(parse_item::<Date32Type>("1970-01-01").unwrap(), 0);
-        assert_eq!(parse_item::<Date32Type>("2020-03-15").unwrap(), 18336);
-        assert_eq!(parse_item::<Date32Type>("1945-05-08").unwrap(), -9004);
-    }
-
-    #[test]
-    fn parse_date64() {
-        assert_eq!(parse_item::<Date64Type>("1970-01-01T00:00:00").unwrap(), 0);
-        assert_eq!(
-            parse_item::<Date64Type>("2018-11-13T17:11:10").unwrap(),
-            1542129070000
-        );
-        assert_eq!(
-            parse_item::<Date64Type>("2018-11-13T17:11:10.011").unwrap(),
-            1542129070011
-        );
-        assert_eq!(
-            parse_item::<Date64Type>("1900-02-28T12:34:56").unwrap(),
-            -2203932304000
-        );
-        assert_eq!(
-            parse_formatted::<Date64Type>("1900-02-28 12:34:56", "%Y-%m-%d %H:%M:%S")
-                .unwrap(),
-            -2203932304000
-        );
-        assert_eq!(
-            parse_formatted::<Date64Type>(
-                "1900-02-28 12:34:56+0030",
-                "%Y-%m-%d %H:%M:%S%z"
-            )
-            .unwrap(),
-            -2203932304000 - (30 * 60 * 1000)
-        );
-    }
-
-    #[test]
-    fn test_parse_decimal() {
-        let tests = [
-            ("123.00", 12300i128),
-            ("123.123", 123123i128),
-            ("0.0123", 123i128),
-            ("0.12300", 12300i128),
-            ("-5.123", -5123i128),
-            ("-45.432432", -45432432i128),
-        ];
-        for (s, i) in tests {
-            let result = parse_decimal(s);
-            assert_eq!(i, result.unwrap());
-        }
-    }
-
-    #[test]
-    fn test_parse_decimal_with_parameter() {
-        let tests = [
-            ("123.123", 123123i128),
-            ("123.1234", 123123i128),
-            ("123.1", 123100i128),
-            ("123", 123000i128),
-            ("-123.123", -123123i128),
-            ("-123.1234", -123123i128),
-            ("-123.1", -123100i128),
-            ("-123", -123000i128),
-            ("0.0000123", 0i128),
-            ("12.", 12000i128),
-            ("-12.", -12000i128),
-            ("00.1", 100i128),
-            ("-00.1", -100i128),
-            ("12345678912345678.1234", 12345678912345678123i128),
-            ("-12345678912345678.1234", -12345678912345678123i128),
-            ("99999999999999999.999", 99999999999999999999i128),
-            ("-99999999999999999.999", -99999999999999999999i128),
-            (".123", 123i128),
-            ("-.123", -123i128),
-            ("123.", 123000i128),
-            ("-123.", -123000i128),
-        ];
-        for (s, i) in tests {
-            let result = parse_decimal_with_parameter(s, 20, 3);
-            assert_eq!(i, result.unwrap())
-        }
-        let can_not_parse_tests = ["123,123", ".", "123.123.123"];
-        for s in can_not_parse_tests {
-            let result = parse_decimal_with_parameter(s, 20, 3);
-            assert_eq!(
-                format!(
-                    "Parser error: can't parse the string value {} to decimal",
-                    s
-                ),
-                result.unwrap_err().to_string()
-            );
-        }
-        let overflow_parse_tests = ["12345678", "12345678.9", "99999999.99"];
-        for s in overflow_parse_tests {
-            let result = parse_decimal_with_parameter(s, 10, 3);
-            let expected = "Parser error: parse decimal overflow";
-            let actual = result.unwrap_err().to_string();
-
-            assert!(
-                actual.contains(&expected),
-                "actual: '{}', expected: '{}'",
-                actual,
-                expected
-            );
-        }
-    }
-
-    /// Interprets a naive_datetime (with no explicit timezone offset)
-    /// using the local timezone and returns the timestamp in UTC (0
-    /// offset)
-    fn naive_datetime_to_timestamp(naive_datetime: &NaiveDateTime) -> i64 {
-        // Note: Use chrono APIs that are different than
-        // naive_datetime_to_timestamp to compute the utc offset to
-        // try and double check the logic
-        let utc_offset_secs = match Local.offset_from_local_datetime(naive_datetime) {
-            LocalResult::Single(local_offset) => {
-                local_offset.fix().local_minus_utc() as i64
-            }
-            _ => panic!(
-                "Unexpected failure converting {} to local datetime",
-                naive_datetime
-            ),
-        };
-        let utc_offset_nanos = utc_offset_secs * 1_000_000_000;
-        naive_datetime.timestamp_nanos() - utc_offset_nanos
-    }
-
-    #[test]
-    fn test_parse_timestamp_microseconds() {
-        assert_eq!(
-            parse_item::<TimestampMicrosecondType>("1970-01-01T00:00:00Z").unwrap(),
-            0
-        );
-        let naive_datetime = NaiveDateTime::new(
-            NaiveDate::from_ymd(2018, 11, 13),
-            NaiveTime::from_hms_nano(17, 11, 10, 0),
-        );
-        assert_eq!(
-            parse_item::<TimestampMicrosecondType>("2018-11-13T17:11:10").unwrap(),
-            naive_datetime_to_timestamp(&naive_datetime) / 1000
-        );
-        assert_eq!(
-            parse_item::<TimestampMicrosecondType>("2018-11-13 17:11:10").unwrap(),
-            naive_datetime_to_timestamp(&naive_datetime) / 1000
-        );
-        let naive_datetime = NaiveDateTime::new(
-            NaiveDate::from_ymd(2018, 11, 13),
-            NaiveTime::from_hms_nano(17, 11, 10, 11000000),
-        );
-        assert_eq!(
-            parse_item::<TimestampMicrosecondType>("2018-11-13T17:11:10.011").unwrap(),
-            naive_datetime_to_timestamp(&naive_datetime) / 1000
-        );
-        let naive_datetime = NaiveDateTime::new(
-            NaiveDate::from_ymd(1900, 2, 28),
-            NaiveTime::from_hms_nano(12, 34, 56, 0),
-        );
-        assert_eq!(
-            parse_item::<TimestampMicrosecondType>("1900-02-28T12:34:56").unwrap(),
-            naive_datetime_to_timestamp(&naive_datetime) / 1000
-        );
-    }
-
-    #[test]
-    fn test_parse_timestamp_nanoseconds() {
-        assert_eq!(
-            parse_item::<TimestampNanosecondType>("1970-01-01T00:00:00Z").unwrap(),
-            0
-        );
-        let naive_datetime = NaiveDateTime::new(
-            NaiveDate::from_ymd(2018, 11, 13),
-            NaiveTime::from_hms_nano(17, 11, 10, 0),
-        );
-        assert_eq!(
-            parse_item::<TimestampNanosecondType>("2018-11-13T17:11:10").unwrap(),
-            naive_datetime_to_timestamp(&naive_datetime)
-        );
-        assert_eq!(
-            parse_item::<TimestampNanosecondType>("2018-11-13 17:11:10").unwrap(),
-            naive_datetime_to_timestamp(&naive_datetime)
-        );
-        let naive_datetime = NaiveDateTime::new(
-            NaiveDate::from_ymd(2018, 11, 13),
-            NaiveTime::from_hms_nano(17, 11, 10, 11000000),
-        );
-        assert_eq!(
-            parse_item::<TimestampNanosecondType>("2018-11-13T17:11:10.011").unwrap(),
-            naive_datetime_to_timestamp(&naive_datetime)
-        );
-        let naive_datetime = NaiveDateTime::new(
-            NaiveDate::from_ymd(1900, 2, 28),
-            NaiveTime::from_hms_nano(12, 34, 56, 0),
-        );
-        assert_eq!(
-            parse_item::<TimestampNanosecondType>("1900-02-28T12:34:56").unwrap(),
-            naive_datetime_to_timestamp(&naive_datetime)
-        );
-    }
-
-    #[test]
-    fn test_infer_schema_from_multiple_files() -> Result<()> {
-        let mut csv1 = NamedTempFile::new()?;
-        let mut csv2 = NamedTempFile::new()?;
-        let csv3 = NamedTempFile::new()?; // empty csv file should be skipped
-        let mut csv4 = NamedTempFile::new()?;
-        writeln!(csv1, "c1,c2,c3")?;
-        writeln!(csv1, "1,\"foo\",0.5")?;
-        writeln!(csv1, "3,\"bar\",1")?;
-        writeln!(csv1, "3,\"bar\",2e-06")?;
-        // reading csv2 will set c2 to optional
-        writeln!(csv2, "c1,c2,c3,c4")?;
-        writeln!(csv2, "10,,3.14,true")?;
-        // reading csv4 will set c3 to optional
-        writeln!(csv4, "c1,c2,c3")?;
-        writeln!(csv4, "10,\"foo\",")?;
-
-        let schema = infer_schema_from_files(
-            &[
-                csv3.path().to_str().unwrap().to_string(),
-                csv1.path().to_str().unwrap().to_string(),
-                csv2.path().to_str().unwrap().to_string(),
-                csv4.path().to_str().unwrap().to_string(),
-            ],
-            b',',
-            Some(4), // only csv1 and csv2 should be read
-            true,
-        )?;
-
-        assert_eq!(schema.fields().len(), 4);
-        assert!(!schema.field(0).is_nullable());
-        assert!(schema.field(1).is_nullable());
-        assert!(!schema.field(2).is_nullable());
-        assert!(!schema.field(3).is_nullable());
-
-        assert_eq!(&DataType::Int64, schema.field(0).data_type());
-        assert_eq!(&DataType::Utf8, schema.field(1).data_type());
-        assert_eq!(&DataType::Float64, schema.field(2).data_type());
-        assert_eq!(&DataType::Boolean, schema.field(3).data_type());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_bounded() {
-        let schema = Schema::new(vec![Field::new("int", DataType::UInt32, false)]);
-        let data = vec![
-            vec!["0"],
-            vec!["1"],
-            vec!["2"],
-            vec!["3"],
-            vec!["4"],
-            vec!["5"],
-            vec!["6"],
-        ];
-
-        let data = data
-            .iter()
-            .map(|x| x.join(","))
-            .collect::<Vec<_>>()
-            .join("\n");
-        let data = data.as_bytes();
-
-        let reader = std::io::Cursor::new(data);
-
-        let mut csv = Reader::new(
-            reader,
-            Arc::new(schema),
-            false,
-            None,
-            2,
-            // starting at row 2 and up to row 6.
-            Some((2, 6)),
-            Some(vec![0]),
-            None,
-        );
-
-        let batch = csv.next().unwrap().unwrap();
-        let a = batch.column(0);
-        let a = a.as_any().downcast_ref::<UInt32Array>().unwrap();
-        assert_eq!(a, &UInt32Array::from(vec![2, 3]));
-
-        let batch = csv.next().unwrap().unwrap();
-        let a = batch.column(0);
-        let a = a.as_any().downcast_ref::<UInt32Array>().unwrap();
-        assert_eq!(a, &UInt32Array::from(vec![4, 5]));
-
-        assert!(csv.next().is_none());
-    }
-
-    #[test]
-    fn test_parsing_bool() {
-        // Encode the expected behavior of boolean parsing
-        assert_eq!(Some(true), parse_bool("true"));
-        assert_eq!(Some(true), parse_bool("tRUe"));
-        assert_eq!(Some(true), parse_bool("True"));
-        assert_eq!(Some(true), parse_bool("TRUE"));
-        assert_eq!(None, parse_bool("t"));
-        assert_eq!(None, parse_bool("T"));
-        assert_eq!(None, parse_bool(""));
-
-        assert_eq!(Some(false), parse_bool("false"));
-        assert_eq!(Some(false), parse_bool("fALse"));
-        assert_eq!(Some(false), parse_bool("False"));
-        assert_eq!(Some(false), parse_bool("FALSE"));
-        assert_eq!(None, parse_bool("f"));
-        assert_eq!(None, parse_bool("F"));
-        assert_eq!(None, parse_bool(""));
-    }
-
-    #[test]
-    fn test_parsing_float() {
-        assert_eq!(Some(12.34), parse_item::<Float64Type>("12.34"));
-        assert_eq!(Some(-12.34), parse_item::<Float64Type>("-12.34"));
-        assert_eq!(Some(12.0), parse_item::<Float64Type>("12"));
-        assert_eq!(Some(0.0), parse_item::<Float64Type>("0"));
-        assert_eq!(Some(2.0), parse_item::<Float64Type>("2."));
-        assert_eq!(Some(0.2), parse_item::<Float64Type>(".2"));
-        assert!(parse_item::<Float64Type>("nan").unwrap().is_nan());
-        assert!(parse_item::<Float64Type>("NaN").unwrap().is_nan());
-        assert!(parse_item::<Float64Type>("inf").unwrap().is_infinite());
-        assert!(parse_item::<Float64Type>("inf").unwrap().is_sign_positive());
-        assert!(parse_item::<Float64Type>("-inf").unwrap().is_infinite());
-        assert!(parse_item::<Float64Type>("-inf")
-            .unwrap()
-            .is_sign_negative());
-        assert_eq!(None, parse_item::<Float64Type>(""));
-        assert_eq!(None, parse_item::<Float64Type>("dd"));
-        assert_eq!(None, parse_item::<Float64Type>("12.34.56"));
-    }
-
-    #[test]
-    fn test_non_std_quote() {
-        let schema = Schema::new(vec![
-            Field::new("text1", DataType::Utf8, false),
-            Field::new("text2", DataType::Utf8, false),
-        ]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .has_header(false)
-            .with_quote(b'~'); // default is ", change to ~
-
-        let mut csv_text = Vec::new();
-        let mut csv_writer = std::io::Cursor::new(&mut csv_text);
-        for index in 0..10 {
-            let text1 = format!("id{:}", index);
-            let text2 = format!("value{:}", index);
-            csv_writer
-                .write_fmt(format_args!("~{}~,~{}~\r\n", text1, text2))
-                .unwrap();
-        }
-        let mut csv_reader = std::io::Cursor::new(&csv_text);
-        let mut reader = builder.build(&mut csv_reader).unwrap();
-        let batch = reader.next().unwrap().unwrap();
-        let col0 = batch.column(0);
-        assert_eq!(col0.len(), 10);
-        let col0_arr = col0.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(col0_arr.value(0), "id0");
-        let col1 = batch.column(1);
-        assert_eq!(col1.len(), 10);
-        let col1_arr = col1.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(col1_arr.value(5), "value5");
-    }
-
-    #[test]
-    fn test_non_std_escape() {
-        let schema = Schema::new(vec![
-            Field::new("text1", DataType::Utf8, false),
-            Field::new("text2", DataType::Utf8, false),
-        ]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .has_header(false)
-            .with_escape(b'\\'); // default is None, change to \
-
-        let mut csv_text = Vec::new();
-        let mut csv_writer = std::io::Cursor::new(&mut csv_text);
-        for index in 0..10 {
-            let text1 = format!("id{:}", index);
-            let text2 = format!("value\\\"{:}", index);
-            csv_writer
-                .write_fmt(format_args!("\"{}\",\"{}\"\r\n", text1, text2))
-                .unwrap();
-        }
-        let mut csv_reader = std::io::Cursor::new(&csv_text);
-        let mut reader = builder.build(&mut csv_reader).unwrap();
-        let batch = reader.next().unwrap().unwrap();
-        let col0 = batch.column(0);
-        assert_eq!(col0.len(), 10);
-        let col0_arr = col0.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(col0_arr.value(0), "id0");
-        let col1 = batch.column(1);
-        assert_eq!(col1.len(), 10);
-        let col1_arr = col1.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(col1_arr.value(5), "value\"5");
-    }
-
-    #[test]
-    fn test_non_std_terminator() {
-        let schema = Schema::new(vec![
-            Field::new("text1", DataType::Utf8, false),
-            Field::new("text2", DataType::Utf8, false),
-        ]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .has_header(false)
-            .with_terminator(b'\n'); // default is CRLF, change to LF
-
-        let mut csv_text = Vec::new();
-        let mut csv_writer = std::io::Cursor::new(&mut csv_text);
-        for index in 0..10 {
-            let text1 = format!("id{:}", index);
-            let text2 = format!("value{:}", index);
-            csv_writer
-                .write_fmt(format_args!("\"{}\",\"{}\"\n", text1, text2))
-                .unwrap();
-        }
-        let mut csv_reader = std::io::Cursor::new(&csv_text);
-        let mut reader = builder.build(&mut csv_reader).unwrap();
-        let batch = reader.next().unwrap().unwrap();
-        let col0 = batch.column(0);
-        assert_eq!(col0.len(), 10);
-        let col0_arr = col0.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(col0_arr.value(0), "id0");
-        let col1 = batch.column(1);
-        assert_eq!(col1.len(), 10);
-        let col1_arr = col1.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(col1_arr.value(5), "value5");
-    }
-}
diff --git a/arrow/src/csv/writer.rs b/arrow/src/csv/writer.rs
deleted file mode 100644
index 7097706ba5f3..000000000000
--- a/arrow/src/csv/writer.rs
+++ /dev/null
@@ -1,820 +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.
-
-//! CSV Writer
-//!
-//! This CSV writer allows Arrow data (in record batches) to be written as CSV files.
-//! The writer does not support writing `ListArray` and `StructArray`.
-//!
-//! Example:
-//!
-//! ```
-//! use arrow::array::*;
-//! use arrow::csv;
-//! use arrow::datatypes::*;
-//! use arrow::record_batch::RecordBatch;
-//! use std::sync::Arc;
-//!
-//! let schema = Schema::new(vec![
-//!     Field::new("c1", DataType::Utf8, false),
-//!     Field::new("c2", DataType::Float64, true),
-//!     Field::new("c3", DataType::UInt32, false),
-//!     Field::new("c4", DataType::Boolean, true),
-//! ]);
-//! let c1 = StringArray::from(vec![
-//!     "Lorem ipsum dolor sit amet",
-//!     "consectetur adipiscing elit",
-//!     "sed do eiusmod tempor",
-//! ]);
-//! let c2 = PrimitiveArray::<Float64Type>::from(vec![
-//!     Some(123.564532),
-//!     None,
-//!     Some(-556132.25),
-//! ]);
-//! let c3 = PrimitiveArray::<UInt32Type>::from(vec![3, 2, 1]);
-//! let c4 = BooleanArray::from(vec![Some(true), Some(false), None]);
-//!
-//! let batch = RecordBatch::try_new(
-//!     Arc::new(schema),
-//!     vec![Arc::new(c1), Arc::new(c2), Arc::new(c3), Arc::new(c4)],
-//! )
-//! .unwrap();
-//!
-//! let mut output = Vec::with_capacity(1024);
-//!
-//! let mut writer = csv::Writer::new(&mut output);
-//! let batches = vec![&batch, &batch];
-//! for batch in batches {
-//!     writer.write(batch).unwrap();
-//! }
-//! ```
-
-use std::io::Write;
-
-#[cfg(feature = "chrono-tz")]
-use crate::compute::kernels::temporal::using_chrono_tz_and_utc_naive_date_time;
-#[cfg(feature = "chrono-tz")]
-use chrono::{DateTime, Utc};
-
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-use crate::record_batch::RecordBatch;
-use crate::util::display::make_string_from_decimal;
-use crate::{array::*, util::serialization::lexical_to_string};
-const DEFAULT_DATE_FORMAT: &str = "%F";
-const DEFAULT_TIME_FORMAT: &str = "%T";
-const DEFAULT_TIMESTAMP_FORMAT: &str = "%FT%H:%M:%S.%9f";
-const DEFAULT_TIMESTAMP_TZ_FORMAT: &str = "%FT%H:%M:%S.%9f%:z";
-
-fn write_primitive_value<T>(array: &ArrayRef, i: usize) -> String
-where
-    T: ArrowNumericType,
-    T::Native: lexical_core::ToLexical,
-{
-    let c = array.as_any().downcast_ref::<PrimitiveArray<T>>().unwrap();
-    lexical_to_string(c.value(i))
-}
-
-/// A CSV writer
-#[derive(Debug)]
-pub struct Writer<W: Write> {
-    /// The object to write to
-    writer: csv_crate::Writer<W>,
-    /// Whether file should be written with headers. Defaults to `true`
-    has_headers: bool,
-    /// The date format for date arrays
-    date_format: String,
-    /// The datetime format for datetime arrays
-    datetime_format: String,
-    /// The timestamp format for timestamp arrays
-    timestamp_format: String,
-    /// The timestamp format for timestamp (with timezone) arrays
-    #[allow(dead_code)]
-    timestamp_tz_format: String,
-    /// The time format for time arrays
-    time_format: String,
-    /// Is the beginning-of-writer
-    beginning: bool,
-}
-
-impl<W: Write> Writer<W> {
-    /// Create a new CsvWriter from a writable object, with default options
-    pub fn new(writer: W) -> Self {
-        let delimiter = b',';
-        let mut builder = csv_crate::WriterBuilder::new();
-        let writer = builder.delimiter(delimiter).from_writer(writer);
-        Writer {
-            writer,
-            has_headers: true,
-            date_format: DEFAULT_DATE_FORMAT.to_string(),
-            datetime_format: DEFAULT_TIMESTAMP_FORMAT.to_string(),
-            time_format: DEFAULT_TIME_FORMAT.to_string(),
-            timestamp_format: DEFAULT_TIMESTAMP_FORMAT.to_string(),
-            timestamp_tz_format: DEFAULT_TIMESTAMP_TZ_FORMAT.to_string(),
-            beginning: true,
-        }
-    }
-
-    /// Convert a record to a string vector
-    fn convert(
-        &self,
-        batch: &[ArrayRef],
-        row_index: usize,
-        buffer: &mut [String],
-    ) -> Result<()> {
-        // TODO: it'd be more efficient if we could create `record: Vec<&[u8]>
-        for (col_index, item) in buffer.iter_mut().enumerate() {
-            let col = &batch[col_index];
-            if col.is_null(row_index) {
-                // write an empty value
-                *item = "".to_string();
-                continue;
-            }
-            let string = match col.data_type() {
-                DataType::Float64 => write_primitive_value::<Float64Type>(col, row_index),
-                DataType::Float32 => write_primitive_value::<Float32Type>(col, row_index),
-                DataType::Int8 => write_primitive_value::<Int8Type>(col, row_index),
-                DataType::Int16 => write_primitive_value::<Int16Type>(col, row_index),
-                DataType::Int32 => write_primitive_value::<Int32Type>(col, row_index),
-                DataType::Int64 => write_primitive_value::<Int64Type>(col, row_index),
-                DataType::UInt8 => write_primitive_value::<UInt8Type>(col, row_index),
-                DataType::UInt16 => write_primitive_value::<UInt16Type>(col, row_index),
-                DataType::UInt32 => write_primitive_value::<UInt32Type>(col, row_index),
-                DataType::UInt64 => write_primitive_value::<UInt64Type>(col, row_index),
-                DataType::Boolean => {
-                    let c = col.as_any().downcast_ref::<BooleanArray>().unwrap();
-                    c.value(row_index).to_string()
-                }
-                DataType::Utf8 => {
-                    let c = col.as_any().downcast_ref::<StringArray>().unwrap();
-                    c.value(row_index).to_owned()
-                }
-                DataType::LargeUtf8 => {
-                    let c = col.as_any().downcast_ref::<LargeStringArray>().unwrap();
-                    c.value(row_index).to_owned()
-                }
-                DataType::Date32 => {
-                    let c = col.as_any().downcast_ref::<Date32Array>().unwrap();
-                    c.value_as_date(row_index)
-                        .unwrap()
-                        .format(&self.date_format)
-                        .to_string()
-                }
-                DataType::Date64 => {
-                    let c = col.as_any().downcast_ref::<Date64Array>().unwrap();
-                    c.value_as_datetime(row_index)
-                        .unwrap()
-                        .format(&self.datetime_format)
-                        .to_string()
-                }
-                DataType::Time32(TimeUnit::Second) => {
-                    let c = col.as_any().downcast_ref::<Time32SecondArray>().unwrap();
-                    c.value_as_time(row_index)
-                        .unwrap()
-                        .format(&self.time_format)
-                        .to_string()
-                }
-                DataType::Time32(TimeUnit::Millisecond) => {
-                    let c = col
-                        .as_any()
-                        .downcast_ref::<Time32MillisecondArray>()
-                        .unwrap();
-                    c.value_as_time(row_index)
-                        .unwrap()
-                        .format(&self.time_format)
-                        .to_string()
-                }
-                DataType::Time64(TimeUnit::Microsecond) => {
-                    let c = col
-                        .as_any()
-                        .downcast_ref::<Time64MicrosecondArray>()
-                        .unwrap();
-                    c.value_as_time(row_index)
-                        .unwrap()
-                        .format(&self.time_format)
-                        .to_string()
-                }
-                DataType::Time64(TimeUnit::Nanosecond) => {
-                    let c = col
-                        .as_any()
-                        .downcast_ref::<Time64NanosecondArray>()
-                        .unwrap();
-                    c.value_as_time(row_index)
-                        .unwrap()
-                        .format(&self.time_format)
-                        .to_string()
-                }
-                DataType::Timestamp(time_unit, time_zone) => {
-                    self.handle_timestamp(time_unit, time_zone.as_ref(), row_index, col)?
-                }
-                DataType::Decimal128(..) => make_string_from_decimal(col, row_index)?,
-                t => {
-                    // List and Struct arrays not supported by the writer, any
-                    // other type needs to be implemented
-                    return Err(ArrowError::CsvError(format!(
-                        "CSV Writer does not support {:?} data type",
-                        t
-                    )));
-                }
-            };
-            *item = string;
-        }
-        Ok(())
-    }
-
-    #[cfg(not(feature = "chrono-tz"))]
-    fn handle_timestamp(
-        &self,
-        time_unit: &TimeUnit,
-        _time_zone: Option<&String>,
-        row_index: usize,
-        col: &ArrayRef,
-    ) -> Result<String> {
-        use TimeUnit::*;
-        let datetime = match time_unit {
-            Second => col
-                .as_any()
-                .downcast_ref::<TimestampSecondArray>()
-                .unwrap()
-                .value_as_datetime(row_index)
-                .unwrap(),
-            Millisecond => col
-                .as_any()
-                .downcast_ref::<TimestampMillisecondArray>()
-                .unwrap()
-                .value_as_datetime(row_index)
-                .unwrap(),
-            Microsecond => col
-                .as_any()
-                .downcast_ref::<TimestampMicrosecondArray>()
-                .unwrap()
-                .value_as_datetime(row_index)
-                .unwrap(),
-            Nanosecond => col
-                .as_any()
-                .downcast_ref::<TimestampNanosecondArray>()
-                .unwrap()
-                .value_as_datetime(row_index)
-                .unwrap(),
-        };
-        Ok(format!("{}", datetime.format(&self.timestamp_format)))
-    }
-
-    #[cfg(feature = "chrono-tz")]
-    fn handle_timestamp(
-        &self,
-        time_unit: &TimeUnit,
-        time_zone: Option<&String>,
-        row_index: usize,
-        col: &ArrayRef,
-    ) -> Result<String> {
-        use TimeUnit::*;
-
-        let datetime = match time_unit {
-            Second => col
-                .as_any()
-                .downcast_ref::<TimestampSecondArray>()
-                .unwrap()
-                .value_as_datetime(row_index)
-                .unwrap(),
-            Millisecond => col
-                .as_any()
-                .downcast_ref::<TimestampMillisecondArray>()
-                .unwrap()
-                .value_as_datetime(row_index)
-                .unwrap(),
-            Microsecond => col
-                .as_any()
-                .downcast_ref::<TimestampMicrosecondArray>()
-                .unwrap()
-                .value_as_datetime(row_index)
-                .unwrap(),
-            Nanosecond => col
-                .as_any()
-                .downcast_ref::<TimestampNanosecondArray>()
-                .unwrap()
-                .value_as_datetime(row_index)
-                .unwrap(),
-        };
-        let tzs = match time_zone {
-            None => "UTC".to_string(),
-            Some(tzs) => tzs.to_string(),
-        };
-
-        match using_chrono_tz_and_utc_naive_date_time(&tzs, datetime) {
-            Some(tz) => {
-                let utc_time = DateTime::<Utc>::from_utc(datetime, Utc);
-                Ok(format!(
-                    "{}",
-                    utc_time
-                        .with_timezone(&tz)
-                        .format(&self.timestamp_tz_format)
-                ))
-            }
-            err => Err(ArrowError::ComputeError(format!(
-                "{}: {:?}",
-                "Unable to parse timezone", err
-            ))),
-        }
-    }
-
-    /// Write a vector of record batches to a writable object
-    pub fn write(&mut self, batch: &RecordBatch) -> Result<()> {
-        let num_columns = batch.num_columns();
-        if self.beginning {
-            if self.has_headers {
-                let mut headers: Vec<String> = Vec::with_capacity(num_columns);
-                batch
-                    .schema()
-                    .fields()
-                    .iter()
-                    .for_each(|field| headers.push(field.name().to_string()));
-                self.writer.write_record(&headers[..])?;
-            }
-            self.beginning = false;
-        }
-
-        let columns: Vec<_> = batch
-            .columns()
-            .iter()
-            .map(|array| match array.data_type() {
-                DataType::Dictionary(_, value_type) => {
-                    crate::compute::kernels::cast::cast(array, value_type)
-                        .expect("cannot cast dictionary to underlying values")
-                }
-                _ => array.clone(),
-            })
-            .collect();
-
-        let mut buffer = vec!["".to_string(); batch.num_columns()];
-
-        for row_index in 0..batch.num_rows() {
-            self.convert(columns.as_slice(), row_index, &mut buffer)?;
-            self.writer.write_record(&buffer)?;
-        }
-        self.writer.flush()?;
-
-        Ok(())
-    }
-}
-
-/// A CSV writer builder
-#[derive(Debug)]
-pub struct WriterBuilder {
-    /// Optional column delimiter. Defaults to `b','`
-    delimiter: Option<u8>,
-    /// Whether to write column names as file headers. Defaults to `true`
-    has_headers: bool,
-    /// Optional date format for date arrays
-    date_format: Option<String>,
-    /// Optional datetime format for datetime arrays
-    datetime_format: Option<String>,
-    /// Optional timestamp format for timestamp arrays
-    timestamp_format: Option<String>,
-    /// Optional timestamp format for timestamp with timezone arrays
-    timestamp_tz_format: Option<String>,
-    /// Optional time format for time arrays
-    time_format: Option<String>,
-}
-
-impl Default for WriterBuilder {
-    fn default() -> Self {
-        Self {
-            has_headers: true,
-            delimiter: None,
-            date_format: Some(DEFAULT_DATE_FORMAT.to_string()),
-            datetime_format: Some(DEFAULT_TIMESTAMP_FORMAT.to_string()),
-            time_format: Some(DEFAULT_TIME_FORMAT.to_string()),
-            timestamp_format: Some(DEFAULT_TIMESTAMP_FORMAT.to_string()),
-            timestamp_tz_format: Some(DEFAULT_TIMESTAMP_TZ_FORMAT.to_string()),
-        }
-    }
-}
-
-impl WriterBuilder {
-    /// Create a new builder for configuring CSV writing options.
-    ///
-    /// To convert a builder into a writer, call `WriterBuilder::build`
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// extern crate arrow;
-    ///
-    /// use arrow::csv;
-    /// use std::fs::File;
-    ///
-    /// fn example() -> csv::Writer<File> {
-    ///     let file = File::create("target/out.csv").unwrap();
-    ///
-    ///     // create a builder that doesn't write headers
-    ///     let builder = csv::WriterBuilder::new().has_headers(false);
-    ///     let writer = builder.build(file);
-    ///
-    ///     writer
-    /// }
-    /// ```
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Set whether to write headers
-    pub fn has_headers(mut self, has_headers: bool) -> Self {
-        self.has_headers = has_headers;
-        self
-    }
-
-    /// Set the CSV file's column delimiter as a byte character
-    pub fn with_delimiter(mut self, delimiter: u8) -> Self {
-        self.delimiter = Some(delimiter);
-        self
-    }
-
-    /// Set the CSV file's date format
-    pub fn with_date_format(mut self, format: String) -> Self {
-        self.date_format = Some(format);
-        self
-    }
-
-    /// Set the CSV file's datetime format
-    pub fn with_datetime_format(mut self, format: String) -> Self {
-        self.datetime_format = Some(format);
-        self
-    }
-
-    /// Set the CSV file's time format
-    pub fn with_time_format(mut self, format: String) -> Self {
-        self.time_format = Some(format);
-        self
-    }
-
-    /// Set the CSV file's timestamp format
-    pub fn with_timestamp_format(mut self, format: String) -> Self {
-        self.timestamp_format = Some(format);
-        self
-    }
-
-    /// Create a new `Writer`
-    pub fn build<W: Write>(self, writer: W) -> Writer<W> {
-        let delimiter = self.delimiter.unwrap_or(b',');
-        let mut builder = csv_crate::WriterBuilder::new();
-        let writer = builder.delimiter(delimiter).from_writer(writer);
-        Writer {
-            writer,
-            has_headers: self.has_headers,
-            date_format: self
-                .date_format
-                .unwrap_or_else(|| DEFAULT_DATE_FORMAT.to_string()),
-            datetime_format: self
-                .datetime_format
-                .unwrap_or_else(|| DEFAULT_TIMESTAMP_FORMAT.to_string()),
-            time_format: self
-                .time_format
-                .unwrap_or_else(|| DEFAULT_TIME_FORMAT.to_string()),
-            timestamp_format: self
-                .timestamp_format
-                .unwrap_or_else(|| DEFAULT_TIMESTAMP_FORMAT.to_string()),
-            timestamp_tz_format: self
-                .timestamp_tz_format
-                .unwrap_or_else(|| DEFAULT_TIMESTAMP_TZ_FORMAT.to_string()),
-            beginning: true,
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use crate::csv::Reader;
-    use crate::datatypes::{Field, Schema};
-    #[cfg(feature = "chrono-tz")]
-    use crate::util::string_writer::StringWriter;
-    use crate::util::test_util::get_temp_file;
-    use std::fs::File;
-    use std::io::{Cursor, Read};
-    use std::sync::Arc;
-
-    #[test]
-    fn test_write_csv() {
-        let schema = Schema::new(vec![
-            Field::new("c1", DataType::Utf8, false),
-            Field::new("c2", DataType::Float64, true),
-            Field::new("c3", DataType::UInt32, false),
-            Field::new("c4", DataType::Boolean, true),
-            Field::new("c5", DataType::Timestamp(TimeUnit::Millisecond, None), true),
-            Field::new("c6", DataType::Time32(TimeUnit::Second), false),
-            Field::new(
-                "c7",
-                DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
-                false,
-            ),
-        ]);
-
-        let c1 = StringArray::from(vec![
-            "Lorem ipsum dolor sit amet",
-            "consectetur adipiscing elit",
-            "sed do eiusmod tempor",
-        ]);
-        let c2 = PrimitiveArray::<Float64Type>::from(vec![
-            Some(123.564532),
-            None,
-            Some(-556132.25),
-        ]);
-        let c3 = PrimitiveArray::<UInt32Type>::from(vec![3, 2, 1]);
-        let c4 = BooleanArray::from(vec![Some(true), Some(false), None]);
-        let c5 = TimestampMillisecondArray::from_opt_vec(
-            vec![None, Some(1555584887378), Some(1555555555555)],
-            None,
-        );
-        let c6 = Time32SecondArray::from(vec![1234, 24680, 85563]);
-        let c7: DictionaryArray<Int32Type> =
-            vec!["cupcakes", "cupcakes", "foo"].into_iter().collect();
-
-        let batch = RecordBatch::try_new(
-            Arc::new(schema),
-            vec![
-                Arc::new(c1),
-                Arc::new(c2),
-                Arc::new(c3),
-                Arc::new(c4),
-                Arc::new(c5),
-                Arc::new(c6),
-                Arc::new(c7),
-            ],
-        )
-        .unwrap();
-
-        let file = get_temp_file("columns.csv", &[]);
-
-        let mut writer = Writer::new(file);
-        let batches = vec![&batch, &batch];
-        for batch in batches {
-            writer.write(batch).unwrap();
-        }
-        // check that file was written successfully
-        let mut file = File::open("target/debug/testdata/columns.csv").unwrap();
-        let mut buffer: Vec<u8> = vec![];
-        file.read_to_end(&mut buffer).unwrap();
-
-        let expected = if cfg!(feature = "chrono-tz") {
-            r#"c1,c2,c3,c4,c5,c6,c7
-Lorem ipsum dolor sit amet,123.564532,3,true,,00:20:34,cupcakes
-consectetur adipiscing elit,,2,false,2019-04-18T10:54:47.378000000+00:00,06:51:20,cupcakes
-sed do eiusmod tempor,-556132.25,1,,2019-04-18T02:45:55.555000000+00:00,23:46:03,foo
-Lorem ipsum dolor sit amet,123.564532,3,true,,00:20:34,cupcakes
-consectetur adipiscing elit,,2,false,2019-04-18T10:54:47.378000000+00:00,06:51:20,cupcakes
-sed do eiusmod tempor,-556132.25,1,,2019-04-18T02:45:55.555000000+00:00,23:46:03,foo
-"#
-        } else {
-            r#"c1,c2,c3,c4,c5,c6,c7
-Lorem ipsum dolor sit amet,123.564532,3,true,,00:20:34,cupcakes
-consectetur adipiscing elit,,2,false,2019-04-18T10:54:47.378000000,06:51:20,cupcakes
-sed do eiusmod tempor,-556132.25,1,,2019-04-18T02:45:55.555000000,23:46:03,foo
-Lorem ipsum dolor sit amet,123.564532,3,true,,00:20:34,cupcakes
-consectetur adipiscing elit,,2,false,2019-04-18T10:54:47.378000000,06:51:20,cupcakes
-sed do eiusmod tempor,-556132.25,1,,2019-04-18T02:45:55.555000000,23:46:03,foo
-"#
-        };
-        assert_eq!(expected.to_string(), String::from_utf8(buffer).unwrap());
-    }
-
-    #[test]
-    fn test_write_csv_custom_options() {
-        let schema = Schema::new(vec![
-            Field::new("c1", DataType::Utf8, false),
-            Field::new("c2", DataType::Float64, true),
-            Field::new("c3", DataType::UInt32, false),
-            Field::new("c4", DataType::Boolean, true),
-            Field::new("c6", DataType::Time32(TimeUnit::Second), false),
-        ]);
-
-        let c1 = StringArray::from(vec![
-            "Lorem ipsum dolor sit amet",
-            "consectetur adipiscing elit",
-            "sed do eiusmod tempor",
-        ]);
-        let c2 = PrimitiveArray::<Float64Type>::from(vec![
-            Some(123.564532),
-            None,
-            Some(-556132.25),
-        ]);
-        let c3 = PrimitiveArray::<UInt32Type>::from(vec![3, 2, 1]);
-        let c4 = BooleanArray::from(vec![Some(true), Some(false), None]);
-        let c6 = Time32SecondArray::from(vec![1234, 24680, 85563]);
-
-        let batch = RecordBatch::try_new(
-            Arc::new(schema),
-            vec![
-                Arc::new(c1),
-                Arc::new(c2),
-                Arc::new(c3),
-                Arc::new(c4),
-                Arc::new(c6),
-            ],
-        )
-        .unwrap();
-
-        let file = get_temp_file("custom_options.csv", &[]);
-
-        let builder = WriterBuilder::new()
-            .has_headers(false)
-            .with_delimiter(b'|')
-            .with_time_format("%r".to_string());
-        let mut writer = builder.build(file);
-        let batches = vec![&batch];
-        for batch in batches {
-            writer.write(batch).unwrap();
-        }
-
-        // check that file was written successfully
-        let mut file = File::open("target/debug/testdata/custom_options.csv").unwrap();
-        let mut buffer: Vec<u8> = vec![];
-        file.read_to_end(&mut buffer).unwrap();
-
-        assert_eq!(
-            "Lorem ipsum dolor sit amet|123.564532|3|true|12:20:34 AM\nconsectetur adipiscing elit||2|false|06:51:20 AM\nsed do eiusmod tempor|-556132.25|1||11:46:03 PM\n"
-            .to_string(),
-            String::from_utf8(buffer).unwrap()
-        );
-    }
-
-    #[cfg(feature = "chrono-tz")]
-    #[test]
-    fn test_export_csv_timestamps() {
-        let schema = Schema::new(vec![
-            Field::new(
-                "c1",
-                DataType::Timestamp(
-                    TimeUnit::Millisecond,
-                    Some("Australia/Sydney".to_string()),
-                ),
-                true,
-            ),
-            Field::new("c2", DataType::Timestamp(TimeUnit::Millisecond, None), true),
-        ]);
-
-        let c1 = TimestampMillisecondArray::from_opt_vec(
-            // 1555584887 converts to 2019-04-18, 20:54:47 in time zone Australia/Sydney (AEST).
-            // The offset (difference to UTC) is +10:00.
-            // 1635577147 converts to 2021-10-30 17:59:07 in time zone Australia/Sydney (AEDT)
-            // The offset (difference to UTC) is +11:00. Note that daylight savings is in effect on 2021-10-30.
-            //
-            vec![Some(1555584887378), Some(1635577147000)],
-            Some("Australia/Sydney".to_string()),
-        );
-        let c2 = TimestampMillisecondArray::from_opt_vec(
-            vec![Some(1555584887378), Some(1635577147000)],
-            None,
-        );
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)])
-                .unwrap();
-
-        let sw = StringWriter::new();
-        let mut writer = Writer::new(sw);
-        let batches = vec![&batch];
-        for batch in batches {
-            writer.write(batch).unwrap();
-        }
-
-        let left = "c1,c2
-2019-04-18T20:54:47.378000000+10:00,2019-04-18T10:54:47.378000000+00:00
-2021-10-30T17:59:07.000000000+11:00,2021-10-30T06:59:07.000000000+00:00\n";
-        let right = writer.writer.into_inner().map(|s| s.to_string());
-        assert_eq!(Some(left.to_string()), right.ok());
-    }
-
-    #[cfg(not(feature = "chrono-tz"))]
-    #[test]
-    fn test_conversion_consistency() {
-        // test if we can serialize and deserialize whilst retaining the same type information/ precision
-
-        let schema = Schema::new(vec![
-            Field::new("c1", DataType::Date32, false),
-            Field::new("c2", DataType::Date64, false),
-        ]);
-
-        let c1 = Date32Array::from(vec![3, 2, 1]);
-        let c2 = Date64Array::from(vec![3, 2, 1]);
-
-        let batch = RecordBatch::try_new(
-            Arc::new(schema.clone()),
-            vec![Arc::new(c1), Arc::new(c2)],
-        )
-        .unwrap();
-
-        let builder = WriterBuilder::new().has_headers(false);
-
-        let mut buf: Cursor<Vec<u8>> = Default::default();
-        // drop the writer early to release the borrow.
-        {
-            let mut writer = builder.build(&mut buf);
-            writer.write(&batch).unwrap();
-        }
-        buf.set_position(0);
-
-        let mut reader = Reader::new(
-            buf,
-            Arc::new(schema),
-            false,
-            None,
-            3,
-            // starting at row 2 and up to row 6.
-            None,
-            None,
-            None,
-        );
-        let rb = reader.next().unwrap().unwrap();
-        let c1 = rb.column(0).as_any().downcast_ref::<Date32Array>().unwrap();
-        let c2 = rb.column(1).as_any().downcast_ref::<Date64Array>().unwrap();
-
-        let actual = c1.into_iter().collect::<Vec<_>>();
-        let expected = vec![Some(3), Some(2), Some(1)];
-        assert_eq!(actual, expected);
-        let actual = c2.into_iter().collect::<Vec<_>>();
-        let expected = vec![Some(3), Some(2), Some(1)];
-        assert_eq!(actual, expected);
-    }
-
-    #[cfg(feature = "chrono-tz")]
-    #[test]
-    fn test_conversion_consistency() {
-        // test if we can serialize and deserialize whilst retaining the same type information/ precision
-
-        let schema = Schema::new(vec![
-            Field::new("c1", DataType::Date32, false),
-            Field::new("c2", DataType::Date64, false),
-            Field::new("c3", DataType::Timestamp(TimeUnit::Nanosecond, None), false),
-        ]);
-
-        let nanoseconds = vec![
-            1599566300000000000,
-            1599566200000000000,
-            1599566100000000000,
-        ];
-        let c1 = Date32Array::from(vec![3, 2, 1]);
-        let c2 = Date64Array::from(vec![3, 2, 1]);
-        let c3 = TimestampNanosecondArray::from_vec(nanoseconds.clone(), None);
-
-        let batch = RecordBatch::try_new(
-            Arc::new(schema.clone()),
-            vec![Arc::new(c1), Arc::new(c2), Arc::new(c3)],
-        )
-        .unwrap();
-
-        let builder = WriterBuilder::new().has_headers(false);
-
-        let mut buf: Cursor<Vec<u8>> = Default::default();
-        // drop the writer early to release the borrow.
-        {
-            let mut writer = builder.build(&mut buf);
-            writer.write(&batch).unwrap();
-        }
-        buf.set_position(0);
-
-        let mut reader = Reader::new(
-            buf,
-            Arc::new(schema),
-            false,
-            None,
-            3,
-            // starting at row 2 and up to row 6.
-            None,
-            None,
-            None,
-        );
-        let rb = reader.next().unwrap().unwrap();
-        let c1 = rb.column(0).as_any().downcast_ref::<Date32Array>().unwrap();
-        let c2 = rb.column(1).as_any().downcast_ref::<Date64Array>().unwrap();
-        let c3 = rb
-            .column(2)
-            .as_any()
-            .downcast_ref::<TimestampNanosecondArray>()
-            .unwrap();
-
-        let actual = c1.into_iter().collect::<Vec<_>>();
-        let expected = vec![Some(3), Some(2), Some(1)];
-        assert_eq!(actual, expected);
-        let actual = c2.into_iter().collect::<Vec<_>>();
-        let expected = vec![Some(3), Some(2), Some(1)];
-        assert_eq!(actual, expected);
-        let actual = c3.into_iter().collect::<Vec<_>>();
-        let expected = nanoseconds.into_iter().map(|x| Some(x)).collect::<Vec<_>>();
-        assert_eq!(actual, expected);
-    }
-}
diff --git a/arrow/src/datatypes/datatype.rs b/arrow/src/datatypes/datatype.rs
deleted file mode 100644
index 1d922c8ebe68..000000000000
--- a/arrow/src/datatypes/datatype.rs
+++ /dev/null
@@ -1,1494 +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.
-
-use num::BigInt;
-use std::cmp::Ordering;
-use std::fmt;
-
-use serde_derive::{Deserialize, Serialize};
-use serde_json::{json, Value, Value::String as VString};
-
-use crate::error::{ArrowError, Result};
-use crate::util::decimal::singed_cmp_le_bytes;
-
-use super::Field;
-
-/// The set of datatypes that are supported by this implementation of Apache Arrow.
-///
-/// The Arrow specification on data types includes some more types.
-/// See also [`Schema.fbs`](https://github.com/apache/arrow/blob/master/format/Schema.fbs)
-/// for Arrow's specification.
-///
-/// The variants of this enum include primitive fixed size types as well as parametric or
-/// nested types.
-/// Currently the Rust implementation supports the following  nested types:
-///  - `List<T>`
-///  - `Struct<T, U, V, ...>`
-///
-/// Nested types can themselves be nested within other arrays.
-/// For more information on these types please see
-/// [the physical memory layout of Apache Arrow](https://arrow.apache.org/docs/format/Columnar.html#physical-memory-layout).
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum DataType {
-    /// Null type
-    Null,
-    /// A boolean datatype representing the values `true` and `false`.
-    Boolean,
-    /// A signed 8-bit integer.
-    Int8,
-    /// A signed 16-bit integer.
-    Int16,
-    /// A signed 32-bit integer.
-    Int32,
-    /// A signed 64-bit integer.
-    Int64,
-    /// An unsigned 8-bit integer.
-    UInt8,
-    /// An unsigned 16-bit integer.
-    UInt16,
-    /// An unsigned 32-bit integer.
-    UInt32,
-    /// An unsigned 64-bit integer.
-    UInt64,
-    /// A 16-bit floating point number.
-    Float16,
-    /// A 32-bit floating point number.
-    Float32,
-    /// A 64-bit floating point number.
-    Float64,
-    /// A timestamp with an optional timezone.
-    ///
-    /// Time is measured as a Unix epoch, counting the seconds from
-    /// 00:00:00.000 on 1 January 1970, excluding leap seconds,
-    /// as a 64-bit integer.
-    ///
-    /// The time zone is a string indicating the name of a time zone, one of:
-    ///
-    /// * As used in the Olson time zone database (the "tz database" or
-    ///   "tzdata"), such as "America/New_York"
-    /// * An absolute time zone offset of the form +XX:XX or -XX:XX, such as +07:30
-    ///
-    /// Timestamps with a non-empty timezone
-    /// ------------------------------------
-    ///
-    /// If a Timestamp column has a non-empty timezone value, its epoch is
-    /// 1970-01-01 00:00:00 (January 1st 1970, midnight) in the *UTC* timezone
-    /// (the Unix epoch), regardless of the Timestamp's own timezone.
-    ///
-    /// Therefore, timestamp values with a non-empty timezone correspond to
-    /// physical points in time together with some additional information about
-    /// how the data was obtained and/or how to display it (the timezone).
-    ///
-    ///   For example, the timestamp value 0 with the timezone string "Europe/Paris"
-    ///   corresponds to "January 1st 1970, 00h00" in the UTC timezone, but the
-    ///   application may prefer to display it as "January 1st 1970, 01h00" in
-    ///   the Europe/Paris timezone (which is the same physical point in time).
-    ///
-    /// One consequence is that timestamp values with a non-empty timezone
-    /// can be compared and ordered directly, since they all share the same
-    /// well-known point of reference (the Unix epoch).
-    ///
-    /// Timestamps with an unset / empty timezone
-    /// -----------------------------------------
-    ///
-    /// If a Timestamp column has no timezone value, its epoch is
-    /// 1970-01-01 00:00:00 (January 1st 1970, midnight) in an *unknown* timezone.
-    ///
-    /// Therefore, timestamp values without a timezone cannot be meaningfully
-    /// interpreted as physical points in time, but only as calendar / clock
-    /// indications ("wall clock time") in an unspecified timezone.
-    ///
-    ///   For example, the timestamp value 0 with an empty timezone string
-    ///   corresponds to "January 1st 1970, 00h00" in an unknown timezone: there
-    ///   is not enough information to interpret it as a well-defined physical
-    ///   point in time.
-    ///
-    /// One consequence is that timestamp values without a timezone cannot
-    /// be reliably compared or ordered, since they may have different points of
-    /// reference.  In particular, it is *not* possible to interpret an unset
-    /// or empty timezone as the same as "UTC".
-    ///
-    /// Conversion between timezones
-    /// ----------------------------
-    ///
-    /// If a Timestamp column has a non-empty timezone, changing the timezone
-    /// to a different non-empty value is a metadata-only operation:
-    /// the timestamp values need not change as their point of reference remains
-    /// the same (the Unix epoch).
-    ///
-    /// However, if a Timestamp column has no timezone value, changing it to a
-    /// non-empty value requires to think about the desired semantics.
-    /// One possibility is to assume that the original timestamp values are
-    /// relative to the epoch of the timezone being set; timestamp values should
-    /// then adjusted to the Unix epoch (for example, changing the timezone from
-    /// empty to "Europe/Paris" would require converting the timestamp values
-    /// from "Europe/Paris" to "UTC", which seems counter-intuitive but is
-    /// nevertheless correct).
-    Timestamp(TimeUnit, Option<String>),
-    /// A 32-bit date representing the elapsed time since UNIX epoch (1970-01-01)
-    /// in days (32 bits).
-    Date32,
-    /// A 64-bit date representing the elapsed time since UNIX epoch (1970-01-01)
-    /// in milliseconds (64 bits). Values are evenly divisible by 86400000.
-    Date64,
-    /// A 32-bit time representing the elapsed time since midnight in the unit of `TimeUnit`.
-    Time32(TimeUnit),
-    /// A 64-bit time representing the elapsed time since midnight in the unit of `TimeUnit`.
-    Time64(TimeUnit),
-    /// Measure of elapsed time in either seconds, milliseconds, microseconds or nanoseconds.
-    Duration(TimeUnit),
-    /// A "calendar" interval which models types that don't necessarily
-    /// have a precise duration without the context of a base timestamp (e.g.
-    /// days can differ in length during day light savings time transitions).
-    Interval(IntervalUnit),
-    /// Opaque binary data of variable length.
-    Binary,
-    /// Opaque binary data of fixed size.
-    /// Enum parameter specifies the number of bytes per value.
-    FixedSizeBinary(i32),
-    /// Opaque binary data of variable length and 64-bit offsets.
-    LargeBinary,
-    /// A variable-length string in Unicode with UTF-8 encoding.
-    Utf8,
-    /// A variable-length string in Unicode with UFT-8 encoding and 64-bit offsets.
-    LargeUtf8,
-    /// A list of some logical data type with variable length.
-    List(Box<Field>),
-    /// A list of some logical data type with fixed length.
-    FixedSizeList(Box<Field>, i32),
-    /// A list of some logical data type with variable length and 64-bit offsets.
-    LargeList(Box<Field>),
-    /// A nested datatype that contains a number of sub-fields.
-    Struct(Vec<Field>),
-    /// A nested datatype that can represent slots of differing types. Components:
-    ///
-    /// 1. [`Field`] for each possible child type the Union can hold
-    /// 2. The corresponding `type_id` used to identify which Field
-    /// 3. The type of union (Sparse or Dense)
-    Union(Vec<Field>, Vec<i8>, UnionMode),
-    /// A dictionary encoded array (`key_type`, `value_type`), where
-    /// each array element is an index of `key_type` into an
-    /// associated dictionary of `value_type`.
-    ///
-    /// Dictionary arrays are used to store columns of `value_type`
-    /// that contain many repeated values using less memory, but with
-    /// a higher CPU overhead for some operations.
-    ///
-    /// This type mostly used to represent low cardinality string
-    /// arrays or a limited set of primitive types as integers.
-    Dictionary(Box<DataType>, Box<DataType>),
-    /// Exact 128-bit width decimal value with precision and scale
-    ///
-    /// * precision is the total number of digits
-    /// * scale is the number of digits past the decimal
-    ///
-    /// For example the number 123.45 has precision 5 and scale 2.
-    Decimal128(usize, usize),
-    /// Exact 256-bit width decimal value with precision and scale
-    ///
-    /// * precision is the total number of digits
-    /// * scale is the number of digits past the decimal
-    ///
-    /// For example the number 123.45 has precision 5 and scale 2.
-    Decimal256(usize, usize),
-    /// A Map is a logical nested type that is represented as
-    ///
-    /// `List<entries: Struct<key: K, value: V>>`
-    ///
-    /// The keys and values are each respectively contiguous.
-    /// The key and value types are not constrained, but keys should be
-    /// hashable and unique.
-    /// Whether the keys are sorted can be set in the `bool` after the `Field`.
-    ///
-    /// In a field with Map type, the field has a child Struct field, which then
-    /// has two children: key type and the second the value type. The names of the
-    /// child fields may be respectively "entries", "key", and "value", but this is
-    /// not enforced.
-    Map(Box<Field>, bool),
-}
-
-/// An absolute length of time in seconds, milliseconds, microseconds or nanoseconds.
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum TimeUnit {
-    /// Time in seconds.
-    Second,
-    /// Time in milliseconds.
-    Millisecond,
-    /// Time in microseconds.
-    Microsecond,
-    /// Time in nanoseconds.
-    Nanosecond,
-}
-
-/// YEAR_MONTH, DAY_TIME, MONTH_DAY_NANO interval in SQL style.
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum IntervalUnit {
-    /// Indicates the number of elapsed whole months, stored as 4-byte integers.
-    YearMonth,
-    /// Indicates the number of elapsed days and milliseconds,
-    /// stored as 2 contiguous 32-bit integers (days, milliseconds) (8-bytes in total).
-    DayTime,
-    /// A triple of the number of elapsed months, days, and nanoseconds.
-    /// The values are stored contiguously in 16 byte blocks. Months and
-    /// days are encoded as 32 bit integers and nanoseconds is encoded as a
-    /// 64 bit integer. All integers are signed. Each field is independent
-    /// (e.g. there is no constraint that nanoseconds have the same sign
-    /// as days or that the quantity of nanoseconds represents less
-    /// than a day's worth of time).
-    MonthDayNano,
-}
-
-// Sparse or Dense union layouts
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord)]
-pub enum UnionMode {
-    Sparse,
-    Dense,
-}
-
-impl fmt::Display for DataType {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-// MAX decimal256 value of little-endian format for each precision.
-// Each element is the max value of signed 256-bit integer for the specified precision which
-// is encoded to the 32-byte width format of little-endian.
-pub(crate) const MAX_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION: [[u8; 32]; 76] = [
-    [
-        9, 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,
-    ],
-    [
-        99, 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,
-    ],
-    [
-        231, 3, 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,
-    ],
-    [
-        15, 39, 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,
-    ],
-    [
-        159, 134, 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,
-    ],
-    [
-        63, 66, 15, 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,
-    ],
-    [
-        127, 150, 152, 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,
-    ],
-    [
-        255, 224, 245, 5, 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,
-    ],
-    [
-        255, 201, 154, 59, 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,
-    ],
-    [
-        255, 227, 11, 84, 2, 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,
-    ],
-    [
-        255, 231, 118, 72, 23, 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,
-    ],
-    [
-        255, 15, 165, 212, 232, 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,
-    ],
-    [
-        255, 159, 114, 78, 24, 9, 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,
-    ],
-    [
-        255, 63, 122, 16, 243, 90, 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,
-    ],
-    [
-        255, 127, 198, 164, 126, 141, 3, 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,
-    ],
-    [
-        255, 255, 192, 111, 242, 134, 35, 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,
-    ],
-    [
-        255, 255, 137, 93, 120, 69, 99, 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,
-    ],
-    [
-        255, 255, 99, 167, 179, 182, 224, 13, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 231, 137, 4, 35, 199, 138, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 15, 99, 45, 94, 199, 107, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 159, 222, 197, 173, 201, 53, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 63, 178, 186, 201, 224, 25, 30, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 127, 246, 74, 225, 199, 2, 45, 21, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 160, 237, 204, 206, 27, 194, 211, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 73, 72, 1, 20, 22, 149, 69, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 227, 210, 12, 200, 220, 210, 183, 82, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 231, 60, 128, 208, 159, 60, 46, 59, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 15, 97, 2, 37, 62, 94, 206, 79, 32, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 159, 202, 23, 114, 109, 174, 15, 30, 67, 1, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 63, 234, 237, 116, 70, 208, 156, 44, 159, 12, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 127, 38, 75, 145, 192, 34, 32, 190, 55, 126, 0, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 128, 239, 172, 133, 91, 65, 109, 45, 238, 4, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 9, 91, 193, 56, 147, 141, 68, 198, 77, 49, 0, 0, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 99, 142, 141, 55, 192, 135, 173, 190, 9, 237, 1, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 231, 143, 135, 43, 130, 77, 199, 114, 97, 66, 19, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 15, 159, 75, 179, 21, 7, 201, 123, 206, 151, 192, 0, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 159, 54, 244, 0, 217, 70, 218, 213, 16, 238, 133, 7, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 63, 34, 138, 9, 122, 196, 134, 90, 168, 76, 59, 75, 0, 0, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 127, 86, 101, 95, 196, 172, 67, 137, 147, 254, 80, 240, 2, 0,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 96, 245, 185, 171, 191, 164, 92, 195, 241, 41, 99, 29,
-        0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 201, 149, 67, 181, 124, 111, 158, 161, 113, 163, 223,
-        37, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 227, 217, 163, 20, 223, 90, 48, 80, 112, 98, 188, 122,
-        11, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 231, 130, 102, 206, 182, 140, 227, 33, 99, 216, 91, 203,
-        114, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 15, 29, 1, 16, 36, 127, 227, 82, 223, 115, 150, 241,
-        123, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 159, 34, 11, 160, 104, 247, 226, 60, 185, 134, 224, 111,
-        215, 44, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 63, 90, 111, 64, 22, 170, 221, 96, 60, 67, 197, 94, 106,
-        192, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 127, 134, 89, 132, 222, 164, 168, 200, 91, 160, 180,
-        179, 39, 132, 17, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 64, 127, 43, 177, 112, 150, 214, 149, 67, 14, 5,
-        141, 41, 175, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 137, 248, 178, 235, 102, 224, 97, 218, 163, 142,
-        50, 130, 159, 215, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 99, 181, 253, 52, 5, 196, 210, 135, 102, 146, 249,
-        21, 59, 108, 68, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 231, 21, 233, 17, 52, 168, 59, 78, 1, 184, 191,
-        219, 78, 58, 172, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 15, 219, 26, 179, 8, 146, 84, 14, 13, 48, 125, 149,
-        20, 71, 186, 26, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 159, 142, 12, 255, 86, 180, 77, 143, 130, 224, 227,
-        214, 205, 198, 70, 11, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 63, 146, 125, 246, 101, 11, 9, 153, 25, 197, 230,
-        100, 10, 196, 195, 112, 10, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 127, 182, 231, 160, 251, 113, 90, 250, 255, 178, 3,
-        241, 103, 168, 165, 103, 104, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 32, 13, 73, 212, 115, 136, 199, 255, 253, 36,
-        106, 15, 148, 120, 12, 20, 4, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 73, 131, 218, 74, 134, 84, 203, 253, 235, 113,
-        37, 154, 200, 181, 124, 200, 40, 0, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 227, 32, 137, 236, 62, 77, 241, 233, 55, 115,
-        118, 5, 214, 25, 223, 212, 151, 1, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 231, 72, 91, 61, 117, 4, 109, 35, 47, 128,
-        160, 54, 92, 2, 183, 80, 238, 15, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 15, 217, 144, 101, 148, 44, 66, 98, 215, 1,
-        69, 34, 154, 23, 38, 39, 79, 159, 0, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 159, 122, 168, 247, 203, 189, 149, 214, 105,
-        18, 178, 86, 5, 236, 124, 135, 23, 57, 6, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 63, 202, 148, 172, 247, 105, 217, 97, 34, 184,
-        244, 98, 53, 56, 225, 74, 235, 58, 62, 0, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 127, 230, 207, 189, 172, 35, 126, 210, 87, 49,
-        143, 221, 21, 50, 204, 236, 48, 77, 110, 2, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 0, 31, 106, 191, 100, 237, 56, 110, 237,
-        151, 167, 218, 244, 249, 63, 233, 3, 79, 24, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 9, 54, 37, 122, 239, 69, 57, 78, 70, 239,
-        139, 138, 144, 195, 127, 28, 39, 22, 243, 0, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 99, 28, 116, 197, 90, 187, 60, 14, 191,
-        88, 119, 105, 165, 163, 253, 28, 135, 221, 126, 9, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 231, 27, 137, 182, 139, 81, 95, 142, 118,
-        119, 169, 30, 118, 100, 232, 33, 71, 167, 244, 94, 0, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 15, 23, 91, 33, 117, 47, 185, 143, 161,
-        170, 158, 50, 157, 236, 19, 83, 199, 136, 142, 181, 3, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 159, 230, 142, 77, 147, 218, 59, 157, 79,
-        170, 50, 250, 35, 62, 199, 62, 201, 87, 145, 23, 37, 0, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 63, 2, 149, 7, 193, 137, 86, 36, 28, 167,
-        250, 197, 103, 109, 200, 115, 220, 109, 173, 235, 114, 1, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 127, 22, 210, 75, 138, 97, 97, 107, 25,
-        135, 202, 187, 13, 70, 212, 133, 156, 74, 198, 52, 125, 14, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 224, 52, 246, 102, 207, 205, 49,
-        254, 70, 233, 85, 137, 188, 74, 58, 29, 234, 190, 15, 228, 144, 0, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 201, 16, 158, 5, 26, 10, 242, 237,
-        197, 28, 91, 93, 93, 235, 70, 36, 37, 117, 157, 232, 168, 5, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 227, 167, 44, 56, 4, 101, 116, 75,
-        187, 31, 143, 165, 165, 49, 197, 106, 115, 147, 38, 22, 153, 56, 0,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 231, 142, 190, 49, 42, 242, 139,
-        242, 80, 61, 151, 119, 120, 240, 179, 43, 130, 194, 129, 221, 250, 53, 2,
-    ],
-    [
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 15, 149, 113, 241, 165, 117, 119,
-        121, 41, 101, 232, 171, 180, 100, 7, 181, 21, 153, 17, 167, 204, 27, 22,
-    ],
-];
-
-// MIN decimal256 value of little-endian format for each precision.
-// Each element is the min value of signed 256-bit integer for the specified precision which
-// is encoded to the 76-byte width format of little-endian.
-pub(crate) const MIN_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION: [[u8; 32]; 76] = [
-    [
-        247, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        157, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        25, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        241, 216, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        97, 121, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        193, 189, 240, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        129, 105, 103, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 31, 10, 250, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 54, 101, 196, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 28, 244, 171, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 24, 137, 183, 232, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 240, 90, 43, 23, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 96, 141, 177, 231, 246, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 192, 133, 239, 12, 165, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 128, 57, 91, 129, 114, 252, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 63, 144, 13, 121, 220, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 118, 162, 135, 186, 156, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 156, 88, 76, 73, 31, 242, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 24, 118, 251, 220, 56, 117, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 240, 156, 210, 161, 56, 148, 250, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 96, 33, 58, 82, 54, 202, 201, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 192, 77, 69, 54, 31, 230, 225, 253, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 128, 9, 181, 30, 56, 253, 210, 234, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 95, 18, 51, 49, 228, 61, 44, 255, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 182, 183, 254, 235, 233, 106, 186, 247, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 28, 45, 243, 55, 35, 45, 72, 173, 255, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 24, 195, 127, 47, 96, 195, 209, 196, 252, 255, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 240, 158, 253, 218, 193, 161, 49, 176, 223, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 96, 53, 232, 141, 146, 81, 240, 225, 188, 254, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 192, 21, 18, 139, 185, 47, 99, 211, 96, 243, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 128, 217, 180, 110, 63, 221, 223, 65, 200, 129, 255, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 127, 16, 83, 122, 164, 190, 146, 210, 17, 251, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 246, 164, 62, 199, 108, 114, 187, 57, 178, 206, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 156, 113, 114, 200, 63, 120, 82, 65, 246, 18, 254, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 24, 112, 120, 212, 125, 178, 56, 141, 158, 189, 236, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 240, 96, 180, 76, 234, 248, 54, 132, 49, 104, 63, 255, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 96, 201, 11, 255, 38, 185, 37, 42, 239, 17, 122, 248, 255, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 192, 221, 117, 246, 133, 59, 121, 165, 87, 179, 196, 180, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 128, 169, 154, 160, 59, 83, 188, 118, 108, 1, 175, 15, 253, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 159, 10, 70, 84, 64, 91, 163, 60, 14, 214, 156, 226, 255, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 54, 106, 188, 74, 131, 144, 97, 94, 142, 92, 32, 218, 254, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 28, 38, 92, 235, 32, 165, 207, 175, 143, 157, 67, 133, 244, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 24, 125, 153, 49, 73, 115, 28, 222, 156, 39, 164, 52, 141, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 240, 226, 254, 239, 219, 128, 28, 173, 32, 140, 105, 14, 132, 251,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 96, 221, 244, 95, 151, 8, 29, 195, 70, 121, 31, 144, 40, 211, 255,
-        255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 192, 165, 144, 191, 233, 85, 34, 159, 195, 188, 58, 161, 149, 63,
-        254, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 128, 121, 166, 123, 33, 91, 87, 55, 164, 95, 75, 76, 216, 123,
-        238, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 191, 128, 212, 78, 143, 105, 41, 106, 188, 241, 250, 114, 214,
-        80, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 118, 7, 77, 20, 153, 31, 158, 37, 92, 113, 205, 125, 96, 40,
-        249, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 156, 74, 2, 203, 250, 59, 45, 120, 153, 109, 6, 234, 196, 147,
-        187, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 24, 234, 22, 238, 203, 87, 196, 177, 254, 71, 64, 36, 177, 197,
-        83, 253, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 240, 36, 229, 76, 247, 109, 171, 241, 242, 207, 130, 106, 235,
-        184, 69, 229, 255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 96, 113, 243, 0, 169, 75, 178, 112, 125, 31, 28, 41, 50, 57,
-        185, 244, 254, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 192, 109, 130, 9, 154, 244, 246, 102, 230, 58, 25, 155, 245,
-        59, 60, 143, 245, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 128, 73, 24, 95, 4, 142, 165, 5, 0, 77, 252, 14, 152, 87, 90,
-        152, 151, 255, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 223, 242, 182, 43, 140, 119, 56, 0, 2, 219, 149, 240, 107,
-        135, 243, 235, 251, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 182, 124, 37, 181, 121, 171, 52, 2, 20, 142, 218, 101, 55,
-        74, 131, 55, 215, 255, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 28, 223, 118, 19, 193, 178, 14, 22, 200, 140, 137, 250, 41,
-        230, 32, 43, 104, 254, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 24, 183, 164, 194, 138, 251, 146, 220, 208, 127, 95, 201,
-        163, 253, 72, 175, 17, 240, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 240, 38, 111, 154, 107, 211, 189, 157, 40, 254, 186, 221,
-        101, 232, 217, 216, 176, 96, 255, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 96, 133, 87, 8, 52, 66, 106, 41, 150, 237, 77, 169, 250, 19,
-        131, 120, 232, 198, 249, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 192, 53, 107, 83, 8, 150, 38, 158, 221, 71, 11, 157, 202,
-        199, 30, 181, 20, 197, 193, 255, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 128, 25, 48, 66, 83, 220, 129, 45, 168, 206, 112, 34, 234,
-        205, 51, 19, 207, 178, 145, 253, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 255, 224, 149, 64, 155, 18, 199, 145, 18, 104, 88, 37,
-        11, 6, 192, 22, 252, 176, 231, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 246, 201, 218, 133, 16, 186, 198, 177, 185, 16, 116, 117,
-        111, 60, 128, 227, 216, 233, 12, 255, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 156, 227, 139, 58, 165, 68, 195, 241, 64, 167, 136, 150,
-        90, 92, 2, 227, 120, 34, 129, 246, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 24, 228, 118, 73, 116, 174, 160, 113, 137, 136, 86, 225,
-        137, 155, 23, 222, 184, 88, 11, 161, 255, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 240, 232, 164, 222, 138, 208, 70, 112, 94, 85, 97, 205,
-        98, 19, 236, 172, 56, 119, 113, 74, 252, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 96, 25, 113, 178, 108, 37, 196, 98, 176, 85, 205, 5, 220,
-        193, 56, 193, 54, 168, 110, 232, 218, 255, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 192, 253, 106, 248, 62, 118, 169, 219, 227, 88, 5, 58,
-        152, 146, 55, 140, 35, 146, 82, 20, 141, 254, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 128, 233, 45, 180, 117, 158, 158, 148, 230, 120, 53, 68,
-        242, 185, 43, 122, 99, 181, 57, 203, 130, 241, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 0, 31, 203, 9, 153, 48, 50, 206, 1, 185, 22, 170, 118,
-        67, 181, 197, 226, 21, 65, 240, 27, 111, 255, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 0, 54, 239, 97, 250, 229, 245, 13, 18, 58, 227, 164, 162,
-        162, 20, 185, 219, 218, 138, 98, 23, 87, 250, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 0, 28, 88, 211, 199, 251, 154, 139, 180, 68, 224, 112,
-        90, 90, 206, 58, 149, 140, 108, 217, 233, 102, 199, 255,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 0, 24, 113, 65, 206, 213, 13, 116, 13, 175, 194, 104,
-        136, 135, 15, 76, 212, 125, 61, 126, 34, 5, 202, 253,
-    ],
-    [
-        1, 0, 0, 0, 0, 0, 0, 0, 0, 240, 106, 142, 14, 90, 138, 136, 134, 214, 154, 23,
-        84, 75, 155, 248, 74, 234, 102, 238, 88, 51, 228, 233,
-    ],
-];
-
-/// `MAX_DECIMAL_FOR_EACH_PRECISION[p]` holds the maximum `i128` value
-/// that can be stored in [DataType::Decimal128] value of precision `p`
-pub const MAX_DECIMAL_FOR_EACH_PRECISION: [i128; 38] = [
-    9,
-    99,
-    999,
-    9999,
-    99999,
-    999999,
-    9999999,
-    99999999,
-    999999999,
-    9999999999,
-    99999999999,
-    999999999999,
-    9999999999999,
-    99999999999999,
-    999999999999999,
-    9999999999999999,
-    99999999999999999,
-    999999999999999999,
-    9999999999999999999,
-    99999999999999999999,
-    999999999999999999999,
-    9999999999999999999999,
-    99999999999999999999999,
-    999999999999999999999999,
-    9999999999999999999999999,
-    99999999999999999999999999,
-    999999999999999999999999999,
-    9999999999999999999999999999,
-    99999999999999999999999999999,
-    999999999999999999999999999999,
-    9999999999999999999999999999999,
-    99999999999999999999999999999999,
-    999999999999999999999999999999999,
-    9999999999999999999999999999999999,
-    99999999999999999999999999999999999,
-    999999999999999999999999999999999999,
-    9999999999999999999999999999999999999,
-    99999999999999999999999999999999999999,
-];
-
-/// `MIN_DECIMAL_FOR_EACH_PRECISION[p]` holds the minimum `i128` value
-/// that can be stored in a [DataType::Decimal128] value of precision `p`
-pub const MIN_DECIMAL_FOR_EACH_PRECISION: [i128; 38] = [
-    -9,
-    -99,
-    -999,
-    -9999,
-    -99999,
-    -999999,
-    -9999999,
-    -99999999,
-    -999999999,
-    -9999999999,
-    -99999999999,
-    -999999999999,
-    -9999999999999,
-    -99999999999999,
-    -999999999999999,
-    -9999999999999999,
-    -99999999999999999,
-    -999999999999999999,
-    -9999999999999999999,
-    -99999999999999999999,
-    -999999999999999999999,
-    -9999999999999999999999,
-    -99999999999999999999999,
-    -999999999999999999999999,
-    -9999999999999999999999999,
-    -99999999999999999999999999,
-    -999999999999999999999999999,
-    -9999999999999999999999999999,
-    -99999999999999999999999999999,
-    -999999999999999999999999999999,
-    -9999999999999999999999999999999,
-    -99999999999999999999999999999999,
-    -999999999999999999999999999999999,
-    -9999999999999999999999999999999999,
-    -99999999999999999999999999999999999,
-    -999999999999999999999999999999999999,
-    -9999999999999999999999999999999999999,
-    -99999999999999999999999999999999999999,
-];
-
-/// The maximum precision for [DataType::Decimal128] values
-pub const DECIMAL128_MAX_PRECISION: usize = 38;
-
-/// The maximum scale for [DataType::Decimal128] values
-pub const DECIMAL128_MAX_SCALE: usize = 38;
-
-/// The maximum precision for [DataType::Decimal256] values
-pub const DECIMAL256_MAX_PRECISION: usize = 76;
-
-/// The maximum scale for [DataType::Decimal256] values
-pub const DECIMAL256_MAX_SCALE: usize = 76;
-
-/// The default scale for [DataType::Decimal128] and [DataType::Decimal256] values
-pub const DECIMAL_DEFAULT_SCALE: usize = 10;
-
-/// Validates that the specified `i128` value can be properly
-/// interpreted as a Decimal number with precision `precision`
-#[inline]
-pub(crate) fn validate_decimal_precision(value: i128, precision: usize) -> Result<i128> {
-    if precision > DECIMAL128_MAX_PRECISION {
-        return Err(ArrowError::InvalidArgumentError(format!(
-            "Max precision of a Decimal128 is {}, but got {}",
-            DECIMAL128_MAX_PRECISION, precision,
-        )));
-    }
-
-    let max = MAX_DECIMAL_FOR_EACH_PRECISION[precision - 1];
-    let min = MIN_DECIMAL_FOR_EACH_PRECISION[precision - 1];
-
-    if value > max {
-        Err(ArrowError::InvalidArgumentError(format!(
-            "{} is too large to store in a Decimal128 of precision {}. Max is {}",
-            value, precision, max
-        )))
-    } else if value < min {
-        Err(ArrowError::InvalidArgumentError(format!(
-            "{} is too small to store in a Decimal128 of precision {}. Min is {}",
-            value, precision, min
-        )))
-    } else {
-        Ok(value)
-    }
-}
-
-/// Validates that the specified `byte_array` of little-endian format
-/// value can be properly interpreted as a Decimal256 number with precision `precision`
-#[inline]
-pub(crate) fn validate_decimal256_precision_with_lt_bytes(
-    lt_value: &[u8],
-    precision: usize,
-) -> Result<()> {
-    if precision > DECIMAL256_MAX_PRECISION {
-        return Err(ArrowError::InvalidArgumentError(format!(
-            "Max precision of a Decimal256 is {}, but got {}",
-            DECIMAL256_MAX_PRECISION, precision,
-        )));
-    }
-    let max = MAX_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION[precision - 1];
-    let min = MIN_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION[precision - 1];
-
-    if singed_cmp_le_bytes(lt_value, &max) == Ordering::Greater {
-        Err(ArrowError::InvalidArgumentError(format!(
-            "{:?} is too large to store in a Decimal256 of precision {}. Max is {:?}",
-            BigInt::from_signed_bytes_le(lt_value),
-            precision,
-            BigInt::from_signed_bytes_le(&max)
-        )))
-    } else if singed_cmp_le_bytes(lt_value, &min) == Ordering::Less {
-        Err(ArrowError::InvalidArgumentError(format!(
-            "{:?} is too small to store in a Decimal256 of precision {}. Min is {:?}",
-            BigInt::from_signed_bytes_le(lt_value),
-            precision,
-            BigInt::from_signed_bytes_le(&min)
-        )))
-    } else {
-        Ok(())
-    }
-}
-
-impl DataType {
-    /// Parse a data type from a JSON representation.
-    pub(crate) fn from(json: &Value) -> Result<DataType> {
-        let default_field = Field::new("", DataType::Boolean, true);
-        match *json {
-            Value::Object(ref map) => match map.get("name") {
-                Some(s) if s == "null" => Ok(DataType::Null),
-                Some(s) if s == "bool" => Ok(DataType::Boolean),
-                Some(s) if s == "binary" => Ok(DataType::Binary),
-                Some(s) if s == "largebinary" => Ok(DataType::LargeBinary),
-                Some(s) if s == "utf8" => Ok(DataType::Utf8),
-                Some(s) if s == "largeutf8" => Ok(DataType::LargeUtf8),
-                Some(s) if s == "fixedsizebinary" => {
-                    // return a list with any type as its child isn't defined in the map
-                    if let Some(Value::Number(size)) = map.get("byteWidth") {
-                        Ok(DataType::FixedSizeBinary(size.as_i64().unwrap() as i32))
-                    } else {
-                        Err(ArrowError::ParseError(
-                            "Expecting a byteWidth for fixedsizebinary".to_string(),
-                        ))
-                    }
-                }
-                Some(s) if s == "decimal" => {
-                    // return a list with any type as its child isn't defined in the map
-                    let precision = match map.get("precision") {
-                        Some(p) => Ok(p.as_u64().unwrap() as usize),
-                        None => Err(ArrowError::ParseError(
-                            "Expecting a precision for decimal".to_string(),
-                        )),
-                    }?;
-                    let scale = match map.get("scale") {
-                        Some(s) => Ok(s.as_u64().unwrap() as usize),
-                        _ => Err(ArrowError::ParseError(
-                            "Expecting a scale for decimal".to_string(),
-                        )),
-                    }?;
-                    let bit_width: usize = match map.get("bitWidth") {
-                        Some(b) => b.as_u64().unwrap() as usize,
-                        _ => 128, // Default bit width
-                    };
-
-                    if bit_width == 128 {
-                        Ok(DataType::Decimal128(precision, scale))
-                    } else if bit_width == 256 {
-                        Ok(DataType::Decimal256(precision, scale))
-                    } else {
-                        Err(ArrowError::ParseError(
-                            "Decimal bit_width invalid".to_string(),
-                        ))
-                    }
-                }
-                Some(s) if s == "floatingpoint" => match map.get("precision") {
-                    Some(p) if p == "HALF" => Ok(DataType::Float16),
-                    Some(p) if p == "SINGLE" => Ok(DataType::Float32),
-                    Some(p) if p == "DOUBLE" => Ok(DataType::Float64),
-                    _ => Err(ArrowError::ParseError(
-                        "floatingpoint precision missing or invalid".to_string(),
-                    )),
-                },
-                Some(s) if s == "timestamp" => {
-                    let unit = match map.get("unit") {
-                        Some(p) if p == "SECOND" => Ok(TimeUnit::Second),
-                        Some(p) if p == "MILLISECOND" => Ok(TimeUnit::Millisecond),
-                        Some(p) if p == "MICROSECOND" => Ok(TimeUnit::Microsecond),
-                        Some(p) if p == "NANOSECOND" => Ok(TimeUnit::Nanosecond),
-                        _ => Err(ArrowError::ParseError(
-                            "timestamp unit missing or invalid".to_string(),
-                        )),
-                    };
-                    let tz = match map.get("timezone") {
-                        None => Ok(None),
-                        Some(VString(tz)) => Ok(Some(tz.clone())),
-                        _ => Err(ArrowError::ParseError(
-                            "timezone must be a string".to_string(),
-                        )),
-                    };
-                    Ok(DataType::Timestamp(unit?, tz?))
-                }
-                Some(s) if s == "date" => match map.get("unit") {
-                    Some(p) if p == "DAY" => Ok(DataType::Date32),
-                    Some(p) if p == "MILLISECOND" => Ok(DataType::Date64),
-                    _ => Err(ArrowError::ParseError(
-                        "date unit missing or invalid".to_string(),
-                    )),
-                },
-                Some(s) if s == "time" => {
-                    let unit = match map.get("unit") {
-                        Some(p) if p == "SECOND" => Ok(TimeUnit::Second),
-                        Some(p) if p == "MILLISECOND" => Ok(TimeUnit::Millisecond),
-                        Some(p) if p == "MICROSECOND" => Ok(TimeUnit::Microsecond),
-                        Some(p) if p == "NANOSECOND" => Ok(TimeUnit::Nanosecond),
-                        _ => Err(ArrowError::ParseError(
-                            "time unit missing or invalid".to_string(),
-                        )),
-                    };
-                    match map.get("bitWidth") {
-                        Some(p) if p == 32 => Ok(DataType::Time32(unit?)),
-                        Some(p) if p == 64 => Ok(DataType::Time64(unit?)),
-                        _ => Err(ArrowError::ParseError(
-                            "time bitWidth missing or invalid".to_string(),
-                        )),
-                    }
-                }
-                Some(s) if s == "duration" => match map.get("unit") {
-                    Some(p) if p == "SECOND" => Ok(DataType::Duration(TimeUnit::Second)),
-                    Some(p) if p == "MILLISECOND" => {
-                        Ok(DataType::Duration(TimeUnit::Millisecond))
-                    }
-                    Some(p) if p == "MICROSECOND" => {
-                        Ok(DataType::Duration(TimeUnit::Microsecond))
-                    }
-                    Some(p) if p == "NANOSECOND" => {
-                        Ok(DataType::Duration(TimeUnit::Nanosecond))
-                    }
-                    _ => Err(ArrowError::ParseError(
-                        "time unit missing or invalid".to_string(),
-                    )),
-                },
-                Some(s) if s == "interval" => match map.get("unit") {
-                    Some(p) if p == "DAY_TIME" => {
-                        Ok(DataType::Interval(IntervalUnit::DayTime))
-                    }
-                    Some(p) if p == "YEAR_MONTH" => {
-                        Ok(DataType::Interval(IntervalUnit::YearMonth))
-                    }
-                    Some(p) if p == "MONTH_DAY_NANO" => {
-                        Ok(DataType::Interval(IntervalUnit::MonthDayNano))
-                    }
-                    _ => Err(ArrowError::ParseError(
-                        "interval unit missing or invalid".to_string(),
-                    )),
-                },
-                Some(s) if s == "int" => match map.get("isSigned") {
-                    Some(&Value::Bool(true)) => match map.get("bitWidth") {
-                        Some(&Value::Number(ref n)) => match n.as_u64() {
-                            Some(8) => Ok(DataType::Int8),
-                            Some(16) => Ok(DataType::Int16),
-                            Some(32) => Ok(DataType::Int32),
-                            Some(64) => Ok(DataType::Int64),
-                            _ => Err(ArrowError::ParseError(
-                                "int bitWidth missing or invalid".to_string(),
-                            )),
-                        },
-                        _ => Err(ArrowError::ParseError(
-                            "int bitWidth missing or invalid".to_string(),
-                        )),
-                    },
-                    Some(&Value::Bool(false)) => match map.get("bitWidth") {
-                        Some(&Value::Number(ref n)) => match n.as_u64() {
-                            Some(8) => Ok(DataType::UInt8),
-                            Some(16) => Ok(DataType::UInt16),
-                            Some(32) => Ok(DataType::UInt32),
-                            Some(64) => Ok(DataType::UInt64),
-                            _ => Err(ArrowError::ParseError(
-                                "int bitWidth missing or invalid".to_string(),
-                            )),
-                        },
-                        _ => Err(ArrowError::ParseError(
-                            "int bitWidth missing or invalid".to_string(),
-                        )),
-                    },
-                    _ => Err(ArrowError::ParseError(
-                        "int signed missing or invalid".to_string(),
-                    )),
-                },
-                Some(s) if s == "list" => {
-                    // return a list with any type as its child isn't defined in the map
-                    Ok(DataType::List(Box::new(default_field)))
-                }
-                Some(s) if s == "largelist" => {
-                    // return a largelist with any type as its child isn't defined in the map
-                    Ok(DataType::LargeList(Box::new(default_field)))
-                }
-                Some(s) if s == "fixedsizelist" => {
-                    // return a list with any type as its child isn't defined in the map
-                    if let Some(Value::Number(size)) = map.get("listSize") {
-                        Ok(DataType::FixedSizeList(
-                            Box::new(default_field),
-                            size.as_i64().unwrap() as i32,
-                        ))
-                    } else {
-                        Err(ArrowError::ParseError(
-                            "Expecting a listSize for fixedsizelist".to_string(),
-                        ))
-                    }
-                }
-                Some(s) if s == "struct" => {
-                    // return an empty `struct` type as its children aren't defined in the map
-                    Ok(DataType::Struct(vec![]))
-                }
-                Some(s) if s == "map" => {
-                    if let Some(Value::Bool(keys_sorted)) = map.get("keysSorted") {
-                        // Return a map with an empty type as its children aren't defined in the map
-                        Ok(DataType::Map(Box::new(default_field), *keys_sorted))
-                    } else {
-                        Err(ArrowError::ParseError(
-                            "Expecting a keysSorted for map".to_string(),
-                        ))
-                    }
-                }
-                Some(s) if s == "union" => {
-                    if let Some(Value::String(mode)) = map.get("mode") {
-                        let union_mode = if mode == "SPARSE" {
-                            UnionMode::Sparse
-                        } else if mode == "DENSE" {
-                            UnionMode::Dense
-                        } else {
-                            return Err(ArrowError::ParseError(format!(
-                                "Unknown union mode {:?} for union",
-                                mode
-                            )));
-                        };
-                        if let Some(type_ids) = map.get("typeIds") {
-                            let type_ids = type_ids
-                                .as_array()
-                                .unwrap()
-                                .iter()
-                                .map(|t| t.as_i64().unwrap() as i8)
-                                .collect::<Vec<_>>();
-
-                            let default_fields = type_ids
-                                .iter()
-                                .map(|_| default_field.clone())
-                                .collect::<Vec<_>>();
-
-                            Ok(DataType::Union(default_fields, type_ids, union_mode))
-                        } else {
-                            Err(ArrowError::ParseError(
-                                "Expecting a typeIds for union ".to_string(),
-                            ))
-                        }
-                    } else {
-                        Err(ArrowError::ParseError(
-                            "Expecting a mode for union".to_string(),
-                        ))
-                    }
-                }
-                Some(other) => Err(ArrowError::ParseError(format!(
-                    "invalid or unsupported type name: {} in {:?}",
-                    other, json
-                ))),
-                None => Err(ArrowError::ParseError("type name missing".to_string())),
-            },
-            _ => Err(ArrowError::ParseError(
-                "invalid json value type".to_string(),
-            )),
-        }
-    }
-
-    /// Generate a JSON representation of the data type.
-    pub fn to_json(&self) -> Value {
-        match self {
-            DataType::Null => json!({"name": "null"}),
-            DataType::Boolean => json!({"name": "bool"}),
-            DataType::Int8 => json!({"name": "int", "bitWidth": 8, "isSigned": true}),
-            DataType::Int16 => json!({"name": "int", "bitWidth": 16, "isSigned": true}),
-            DataType::Int32 => json!({"name": "int", "bitWidth": 32, "isSigned": true}),
-            DataType::Int64 => json!({"name": "int", "bitWidth": 64, "isSigned": true}),
-            DataType::UInt8 => json!({"name": "int", "bitWidth": 8, "isSigned": false}),
-            DataType::UInt16 => json!({"name": "int", "bitWidth": 16, "isSigned": false}),
-            DataType::UInt32 => json!({"name": "int", "bitWidth": 32, "isSigned": false}),
-            DataType::UInt64 => json!({"name": "int", "bitWidth": 64, "isSigned": false}),
-            DataType::Float16 => json!({"name": "floatingpoint", "precision": "HALF"}),
-            DataType::Float32 => json!({"name": "floatingpoint", "precision": "SINGLE"}),
-            DataType::Float64 => json!({"name": "floatingpoint", "precision": "DOUBLE"}),
-            DataType::Utf8 => json!({"name": "utf8"}),
-            DataType::LargeUtf8 => json!({"name": "largeutf8"}),
-            DataType::Binary => json!({"name": "binary"}),
-            DataType::LargeBinary => json!({"name": "largebinary"}),
-            DataType::FixedSizeBinary(byte_width) => {
-                json!({"name": "fixedsizebinary", "byteWidth": byte_width})
-            }
-            DataType::Struct(_) => json!({"name": "struct"}),
-            DataType::Union(_, _, _) => json!({"name": "union"}),
-            DataType::List(_) => json!({ "name": "list"}),
-            DataType::LargeList(_) => json!({ "name": "largelist"}),
-            DataType::FixedSizeList(_, length) => {
-                json!({"name":"fixedsizelist", "listSize": length})
-            }
-            DataType::Time32(unit) => {
-                json!({"name": "time", "bitWidth": 32, "unit": match unit {
-                    TimeUnit::Second => "SECOND",
-                    TimeUnit::Millisecond => "MILLISECOND",
-                    TimeUnit::Microsecond => "MICROSECOND",
-                    TimeUnit::Nanosecond => "NANOSECOND",
-                }})
-            }
-            DataType::Time64(unit) => {
-                json!({"name": "time", "bitWidth": 64, "unit": match unit {
-                    TimeUnit::Second => "SECOND",
-                    TimeUnit::Millisecond => "MILLISECOND",
-                    TimeUnit::Microsecond => "MICROSECOND",
-                    TimeUnit::Nanosecond => "NANOSECOND",
-                }})
-            }
-            DataType::Date32 => {
-                json!({"name": "date", "unit": "DAY"})
-            }
-            DataType::Date64 => {
-                json!({"name": "date", "unit": "MILLISECOND"})
-            }
-            DataType::Timestamp(unit, None) => {
-                json!({"name": "timestamp", "unit": match unit {
-                    TimeUnit::Second => "SECOND",
-                    TimeUnit::Millisecond => "MILLISECOND",
-                    TimeUnit::Microsecond => "MICROSECOND",
-                    TimeUnit::Nanosecond => "NANOSECOND",
-                }})
-            }
-            DataType::Timestamp(unit, Some(tz)) => {
-                json!({"name": "timestamp", "unit": match unit {
-                    TimeUnit::Second => "SECOND",
-                    TimeUnit::Millisecond => "MILLISECOND",
-                    TimeUnit::Microsecond => "MICROSECOND",
-                    TimeUnit::Nanosecond => "NANOSECOND",
-                }, "timezone": tz})
-            }
-            DataType::Interval(unit) => json!({"name": "interval", "unit": match unit {
-                IntervalUnit::YearMonth => "YEAR_MONTH",
-                IntervalUnit::DayTime => "DAY_TIME",
-                IntervalUnit::MonthDayNano => "MONTH_DAY_NANO",
-            }}),
-            DataType::Duration(unit) => json!({"name": "duration", "unit": match unit {
-                TimeUnit::Second => "SECOND",
-                TimeUnit::Millisecond => "MILLISECOND",
-                TimeUnit::Microsecond => "MICROSECOND",
-                TimeUnit::Nanosecond => "NANOSECOND",
-            }}),
-            DataType::Dictionary(_, _) => json!({ "name": "dictionary"}),
-            DataType::Decimal128(precision, scale) => {
-                json!({"name": "decimal", "precision": precision, "scale": scale, "bitWidth": 128})
-            }
-            DataType::Decimal256(precision, scale) => {
-                json!({"name": "decimal", "precision": precision, "scale": scale, "bitWidth": 256})
-            }
-            DataType::Map(_, keys_sorted) => {
-                json!({"name": "map", "keysSorted": keys_sorted})
-            }
-        }
-    }
-
-    /// Returns true if this type is numeric: (UInt*, Unit*, or Float*).
-    pub fn is_numeric(t: &DataType) -> bool {
-        use DataType::*;
-        matches!(
-            t,
-            UInt8
-                | UInt16
-                | UInt32
-                | UInt64
-                | Int8
-                | Int16
-                | Int32
-                | Int64
-                | Float32
-                | Float64
-        )
-    }
-
-    /// Returns true if this type is temporal: (Date*, Time*, Duration, or Interval).
-    pub fn is_temporal(t: &DataType) -> bool {
-        use DataType::*;
-        matches!(
-            t,
-            Date32
-                | Date64
-                | Timestamp(_, _)
-                | Time32(_)
-                | Time64(_)
-                | Duration(_)
-                | Interval(_)
-        )
-    }
-
-    /// Returns true if this type is valid as a dictionary key
-    /// (e.g. [`super::ArrowDictionaryKeyType`]
-    pub fn is_dictionary_key_type(t: &DataType) -> bool {
-        use DataType::*;
-        matches!(
-            t,
-            UInt8 | UInt16 | UInt32 | UInt64 | Int8 | Int16 | Int32 | Int64
-        )
-    }
-
-    /// Compares the datatype with another, ignoring nested field names
-    /// and metadata.
-    pub fn equals_datatype(&self, other: &DataType) -> bool {
-        match (&self, other) {
-            (DataType::List(a), DataType::List(b))
-            | (DataType::LargeList(a), DataType::LargeList(b)) => {
-                a.is_nullable() == b.is_nullable()
-                    && a.data_type().equals_datatype(b.data_type())
-            }
-            (DataType::FixedSizeList(a, a_size), DataType::FixedSizeList(b, b_size)) => {
-                a_size == b_size
-                    && a.is_nullable() == b.is_nullable()
-                    && a.data_type().equals_datatype(b.data_type())
-            }
-            (DataType::Struct(a), DataType::Struct(b)) => {
-                a.len() == b.len()
-                    && a.iter().zip(b).all(|(a, b)| {
-                        a.is_nullable() == b.is_nullable()
-                            && a.data_type().equals_datatype(b.data_type())
-                    })
-            }
-            (
-                DataType::Map(a_field, a_is_sorted),
-                DataType::Map(b_field, b_is_sorted),
-            ) => a_field == b_field && a_is_sorted == b_is_sorted,
-            _ => self == other,
-        }
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use crate::datatypes::datatype::{
-        MAX_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION,
-        MIN_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION,
-    };
-    use crate::util::decimal::Decimal256;
-    use num::{BigInt, Num};
-
-    #[test]
-    fn test_decimal256_min_max_for_precision() {
-        // The precision from 1 to 76
-        let mut max_value = "9".to_string();
-        let mut min_value = "-9".to_string();
-        for i in 1..77 {
-            let max_decimal =
-                Decimal256::from(BigInt::from_str_radix(max_value.as_str(), 10).unwrap());
-            let min_decimal =
-                Decimal256::from(BigInt::from_str_radix(min_value.as_str(), 10).unwrap());
-            let max_bytes = MAX_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION[i - 1];
-            let min_bytes = MIN_DECIMAL_BYTES_FOR_LARGER_EACH_PRECISION[i - 1];
-            max_value += "9";
-            min_value += "9";
-            assert_eq!(max_decimal.raw_value(), max_bytes);
-            assert_eq!(min_decimal.raw_value(), min_bytes);
-        }
-    }
-}
diff --git a/arrow/src/datatypes/delta.rs b/arrow/src/datatypes/delta.rs
deleted file mode 100644
index b7efdab0a48d..000000000000
--- a/arrow/src/datatypes/delta.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-// MIT License
-//
-// Copyright (c) 2020-2022 Oliver Margetts
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in all
-// copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-// SOFTWARE.
-
-// Copied from chronoutil crate
-
-//! Contains utility functions for shifting Date objects.
-use chrono::Datelike;
-
-/// Returns true if the year is a leap-year, as naively defined in the Gregorian calendar.
-#[inline]
-pub(crate) fn is_leap_year(year: i32) -> bool {
-    year % 4 == 0 && (year % 100 != 0 || year % 400 == 0)
-}
-
-// If the day lies within the month, this function has no effect. Otherwise, it shifts
-// day backwards to the final day of the month.
-// XXX: No attempt is made to handle days outside the 1-31 range.
-#[inline]
-fn normalise_day(year: i32, month: u32, day: u32) -> u32 {
-    if day <= 28 {
-        day
-    } else if month == 2 {
-        28 + is_leap_year(year) as u32
-    } else if day == 31 && (month == 4 || month == 6 || month == 9 || month == 11) {
-        30
-    } else {
-        day
-    }
-}
-
-/// Shift a date by the given number of months.
-/// Ambiguous month-ends are shifted backwards as necessary.
-pub(crate) fn shift_months<D: Datelike>(date: D, months: i32) -> D {
-    let mut year = date.year() + (date.month() as i32 + months) / 12;
-    let mut month = (date.month() as i32 + months) % 12;
-    let mut day = date.day();
-
-    if month < 1 {
-        year -= 1;
-        month += 12;
-    }
-
-    day = normalise_day(year, month as u32, day);
-
-    // This is slow but guaranteed to succeed (short of interger overflow)
-    if day <= 28 {
-        date.with_day(day)
-            .unwrap()
-            .with_month(month as u32)
-            .unwrap()
-            .with_year(year)
-            .unwrap()
-    } else {
-        date.with_day(1)
-            .unwrap()
-            .with_month(month as u32)
-            .unwrap()
-            .with_year(year)
-            .unwrap()
-            .with_day(day)
-            .unwrap()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::collections::HashSet;
-
-    use chrono::naive::{NaiveDate, NaiveDateTime, NaiveTime};
-
-    use super::*;
-
-    #[test]
-    fn test_leap_year_cases() {
-        let _leap_years: Vec<i32> = vec![
-            1904, 1908, 1912, 1916, 1920, 1924, 1928, 1932, 1936, 1940, 1944, 1948, 1952,
-            1956, 1960, 1964, 1968, 1972, 1976, 1980, 1984, 1988, 1992, 1996, 2000, 2004,
-            2008, 2012, 2016, 2020,
-        ];
-        let leap_years_1900_to_2020: HashSet<i32> = _leap_years.into_iter().collect();
-
-        for year in 1900..2021 {
-            assert_eq!(is_leap_year(year), leap_years_1900_to_2020.contains(&year))
-        }
-    }
-
-    #[test]
-    fn test_shift_months() {
-        let base = NaiveDate::from_ymd(2020, 1, 31);
-
-        assert_eq!(shift_months(base, 0), NaiveDate::from_ymd(2020, 1, 31));
-        assert_eq!(shift_months(base, 1), NaiveDate::from_ymd(2020, 2, 29));
-        assert_eq!(shift_months(base, 2), NaiveDate::from_ymd(2020, 3, 31));
-        assert_eq!(shift_months(base, 3), NaiveDate::from_ymd(2020, 4, 30));
-        assert_eq!(shift_months(base, 4), NaiveDate::from_ymd(2020, 5, 31));
-        assert_eq!(shift_months(base, 5), NaiveDate::from_ymd(2020, 6, 30));
-        assert_eq!(shift_months(base, 6), NaiveDate::from_ymd(2020, 7, 31));
-        assert_eq!(shift_months(base, 7), NaiveDate::from_ymd(2020, 8, 31));
-        assert_eq!(shift_months(base, 8), NaiveDate::from_ymd(2020, 9, 30));
-        assert_eq!(shift_months(base, 9), NaiveDate::from_ymd(2020, 10, 31));
-        assert_eq!(shift_months(base, 10), NaiveDate::from_ymd(2020, 11, 30));
-        assert_eq!(shift_months(base, 11), NaiveDate::from_ymd(2020, 12, 31));
-        assert_eq!(shift_months(base, 12), NaiveDate::from_ymd(2021, 1, 31));
-        assert_eq!(shift_months(base, 13), NaiveDate::from_ymd(2021, 2, 28));
-
-        assert_eq!(shift_months(base, -1), NaiveDate::from_ymd(2019, 12, 31));
-        assert_eq!(shift_months(base, -2), NaiveDate::from_ymd(2019, 11, 30));
-        assert_eq!(shift_months(base, -3), NaiveDate::from_ymd(2019, 10, 31));
-        assert_eq!(shift_months(base, -4), NaiveDate::from_ymd(2019, 9, 30));
-        assert_eq!(shift_months(base, -5), NaiveDate::from_ymd(2019, 8, 31));
-        assert_eq!(shift_months(base, -6), NaiveDate::from_ymd(2019, 7, 31));
-        assert_eq!(shift_months(base, -7), NaiveDate::from_ymd(2019, 6, 30));
-        assert_eq!(shift_months(base, -8), NaiveDate::from_ymd(2019, 5, 31));
-        assert_eq!(shift_months(base, -9), NaiveDate::from_ymd(2019, 4, 30));
-        assert_eq!(shift_months(base, -10), NaiveDate::from_ymd(2019, 3, 31));
-        assert_eq!(shift_months(base, -11), NaiveDate::from_ymd(2019, 2, 28));
-        assert_eq!(shift_months(base, -12), NaiveDate::from_ymd(2019, 1, 31));
-        assert_eq!(shift_months(base, -13), NaiveDate::from_ymd(2018, 12, 31));
-
-        assert_eq!(shift_months(base, 1265), NaiveDate::from_ymd(2125, 6, 30));
-    }
-
-    #[test]
-    fn test_shift_months_with_overflow() {
-        let base = NaiveDate::from_ymd(2020, 12, 31);
-
-        assert_eq!(shift_months(base, 0), base);
-        assert_eq!(shift_months(base, 1), NaiveDate::from_ymd(2021, 1, 31));
-        assert_eq!(shift_months(base, 2), NaiveDate::from_ymd(2021, 2, 28));
-        assert_eq!(shift_months(base, 12), NaiveDate::from_ymd(2021, 12, 31));
-        assert_eq!(shift_months(base, 18), NaiveDate::from_ymd(2022, 6, 30));
-
-        assert_eq!(shift_months(base, -1), NaiveDate::from_ymd(2020, 11, 30));
-        assert_eq!(shift_months(base, -2), NaiveDate::from_ymd(2020, 10, 31));
-        assert_eq!(shift_months(base, -10), NaiveDate::from_ymd(2020, 2, 29));
-        assert_eq!(shift_months(base, -12), NaiveDate::from_ymd(2019, 12, 31));
-        assert_eq!(shift_months(base, -18), NaiveDate::from_ymd(2019, 6, 30));
-    }
-
-    #[test]
-    fn test_shift_months_datetime() {
-        let date = NaiveDate::from_ymd(2020, 1, 31);
-        let o_clock = NaiveTime::from_hms(1, 2, 3);
-
-        let base = NaiveDateTime::new(date, o_clock);
-
-        assert_eq!(
-            shift_months(base, 0).date(),
-            NaiveDate::from_ymd(2020, 1, 31)
-        );
-        assert_eq!(
-            shift_months(base, 1).date(),
-            NaiveDate::from_ymd(2020, 2, 29)
-        );
-        assert_eq!(
-            shift_months(base, 2).date(),
-            NaiveDate::from_ymd(2020, 3, 31)
-        );
-        assert_eq!(shift_months(base, 0).time(), o_clock);
-        assert_eq!(shift_months(base, 1).time(), o_clock);
-        assert_eq!(shift_months(base, 2).time(), o_clock);
-    }
-}
diff --git a/arrow/src/datatypes/ffi.rs b/arrow/src/datatypes/ffi.rs
deleted file mode 100644
index 60d285315c0b..000000000000
--- a/arrow/src/datatypes/ffi.rs
+++ /dev/null
@@ -1,460 +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.
-
-use std::convert::TryFrom;
-
-use crate::datatypes::DataType::Map;
-use crate::{
-    datatypes::{DataType, Field, Schema, TimeUnit},
-    error::{ArrowError, Result},
-    ffi::{FFI_ArrowSchema, Flags},
-};
-
-impl TryFrom<&FFI_ArrowSchema> for DataType {
-    type Error = ArrowError;
-
-    /// See [CDataInterface docs](https://arrow.apache.org/docs/format/CDataInterface.html#data-type-description-format-strings)
-    fn try_from(c_schema: &FFI_ArrowSchema) -> Result<Self> {
-        let mut dtype = match c_schema.format() {
-            "n" => DataType::Null,
-            "b" => DataType::Boolean,
-            "c" => DataType::Int8,
-            "C" => DataType::UInt8,
-            "s" => DataType::Int16,
-            "S" => DataType::UInt16,
-            "i" => DataType::Int32,
-            "I" => DataType::UInt32,
-            "l" => DataType::Int64,
-            "L" => DataType::UInt64,
-            "e" => DataType::Float16,
-            "f" => DataType::Float32,
-            "g" => DataType::Float64,
-            "z" => DataType::Binary,
-            "Z" => DataType::LargeBinary,
-            "u" => DataType::Utf8,
-            "U" => DataType::LargeUtf8,
-            "tdD" => DataType::Date32,
-            "tdm" => DataType::Date64,
-            "tts" => DataType::Time32(TimeUnit::Second),
-            "ttm" => DataType::Time32(TimeUnit::Millisecond),
-            "ttu" => DataType::Time64(TimeUnit::Microsecond),
-            "ttn" => DataType::Time64(TimeUnit::Nanosecond),
-            "tDs" => DataType::Duration(TimeUnit::Second),
-            "tDm" => DataType::Duration(TimeUnit::Millisecond),
-            "tDu" => DataType::Duration(TimeUnit::Microsecond),
-            "tDn" => DataType::Duration(TimeUnit::Nanosecond),
-            "+l" => {
-                let c_child = c_schema.child(0);
-                DataType::List(Box::new(Field::try_from(c_child)?))
-            }
-            "+L" => {
-                let c_child = c_schema.child(0);
-                DataType::LargeList(Box::new(Field::try_from(c_child)?))
-            }
-            "+s" => {
-                let fields = c_schema.children().map(Field::try_from);
-                DataType::Struct(fields.collect::<Result<Vec<_>>>()?)
-            }
-            "+m" => {
-                let c_child = c_schema.child(0);
-                let map_keys_sorted = c_schema.map_keys_sorted();
-                DataType::Map(Box::new(Field::try_from(c_child)?), map_keys_sorted)
-            }
-            // Parametrized types, requiring string parse
-            other => {
-                match other.splitn(2, ':').collect::<Vec<&str>>().as_slice() {
-                    // FixedSizeBinary type in format "w:num_bytes"
-                    ["w", num_bytes] => {
-                        let parsed_num_bytes = num_bytes.parse::<i32>().map_err(|_| {
-                            ArrowError::CDataInterface(
-                                "FixedSizeBinary requires an integer parameter representing number of bytes per element".to_string())
-                        })?;
-                        DataType::FixedSizeBinary(parsed_num_bytes)
-                    },
-                    // FixedSizeList type in format "+w:num_elems"
-                    ["+w", num_elems] => {
-                        let c_child = c_schema.child(0);
-                        let parsed_num_elems = num_elems.parse::<i32>().map_err(|_| {
-                            ArrowError::CDataInterface(
-                                "The FixedSizeList type requires an integer parameter representing number of elements per list".to_string())
-                        })?;
-                        DataType::FixedSizeList(Box::new(Field::try_from(c_child)?), parsed_num_elems)
-                    },
-                    // Decimal types in format "d:precision,scale" or "d:precision,scale,bitWidth"
-                    ["d", extra] => {
-                        match extra.splitn(3, ',').collect::<Vec<&str>>().as_slice() {
-                            [precision, scale] => {
-                                let parsed_precision = precision.parse::<usize>().map_err(|_| {
-                                    ArrowError::CDataInterface(
-                                        "The decimal type requires an integer precision".to_string(),
-                                    )
-                                })?;
-                                let parsed_scale = scale.parse::<usize>().map_err(|_| {
-                                    ArrowError::CDataInterface(
-                                        "The decimal type requires an integer scale".to_string(),
-                                    )
-                                })?;
-                                DataType::Decimal128(parsed_precision, parsed_scale)
-                            },
-                            [precision, scale, bits] => {
-                                if *bits != "128" {
-                                    return Err(ArrowError::CDataInterface("Only 128 bit wide decimal is supported in the Rust implementation".to_string()));
-                                }
-                                let parsed_precision = precision.parse::<usize>().map_err(|_| {
-                                    ArrowError::CDataInterface(
-                                        "The decimal type requires an integer precision".to_string(),
-                                    )
-                                })?;
-                                let parsed_scale = scale.parse::<usize>().map_err(|_| {
-                                    ArrowError::CDataInterface(
-                                        "The decimal type requires an integer scale".to_string(),
-                                    )
-                                })?;
-                                DataType::Decimal128(parsed_precision, parsed_scale)
-                            }
-                            _ => {
-                                return Err(ArrowError::CDataInterface(format!(
-                                    "The decimal pattern \"d:{:?}\" is not supported in the Rust implementation",
-                                    extra
-                                )))
-                            }
-                        }
-                    }
-
-                    // Timestamps in format "tts:" and "tts:America/New_York" for no timezones and timezones resp.
-                    ["tss", ""] => DataType::Timestamp(TimeUnit::Second, None),
-                    ["tsm", ""] => DataType::Timestamp(TimeUnit::Millisecond, None),
-                    ["tsu", ""] => DataType::Timestamp(TimeUnit::Microsecond, None),
-                    ["tsn", ""] => DataType::Timestamp(TimeUnit::Nanosecond, None),
-                    ["tss", tz] => {
-                        DataType::Timestamp(TimeUnit::Second, Some(tz.to_string()))
-                    }
-                    ["tsm", tz] => {
-                        DataType::Timestamp(TimeUnit::Millisecond, Some(tz.to_string()))
-                    }
-                    ["tsu", tz] => {
-                        DataType::Timestamp(TimeUnit::Microsecond, Some(tz.to_string()))
-                    }
-                    ["tsn", tz] => {
-                        DataType::Timestamp(TimeUnit::Nanosecond, Some(tz.to_string()))
-                    }
-                    _ => {
-                        return Err(ArrowError::CDataInterface(format!(
-                            "The datatype \"{:?}\" is still not supported in Rust implementation",
-                            other
-                        )))
-                    }
-                }
-            }
-        };
-
-        if let Some(dict_schema) = c_schema.dictionary() {
-            let value_type = Self::try_from(dict_schema)?;
-            dtype = DataType::Dictionary(Box::new(dtype), Box::new(value_type));
-        }
-
-        Ok(dtype)
-    }
-}
-
-impl TryFrom<&FFI_ArrowSchema> for Field {
-    type Error = ArrowError;
-
-    fn try_from(c_schema: &FFI_ArrowSchema) -> Result<Self> {
-        let dtype = DataType::try_from(c_schema)?;
-        let field = Field::new(c_schema.name(), dtype, c_schema.nullable());
-        Ok(field)
-    }
-}
-
-impl TryFrom<&FFI_ArrowSchema> for Schema {
-    type Error = ArrowError;
-
-    fn try_from(c_schema: &FFI_ArrowSchema) -> Result<Self> {
-        // interpret it as a struct type then extract its fields
-        let dtype = DataType::try_from(c_schema)?;
-        if let DataType::Struct(fields) = dtype {
-            Ok(Schema::new(fields))
-        } else {
-            Err(ArrowError::CDataInterface(
-                "Unable to interpret C data struct as a Schema".to_string(),
-            ))
-        }
-    }
-}
-
-impl TryFrom<&DataType> for FFI_ArrowSchema {
-    type Error = ArrowError;
-
-    /// See [CDataInterface docs](https://arrow.apache.org/docs/format/CDataInterface.html#data-type-description-format-strings)
-    fn try_from(dtype: &DataType) -> Result<Self> {
-        let format = get_format_string(dtype)?;
-        // allocate and hold the children
-        let children = match dtype {
-            DataType::List(child)
-            | DataType::LargeList(child)
-            | DataType::FixedSizeList(child, _)
-            | DataType::Map(child, _) => {
-                vec![FFI_ArrowSchema::try_from(child.as_ref())?]
-            }
-            DataType::Struct(fields) => fields
-                .iter()
-                .map(FFI_ArrowSchema::try_from)
-                .collect::<Result<Vec<_>>>()?,
-            _ => vec![],
-        };
-        let dictionary = if let DataType::Dictionary(_, value_data_type) = dtype {
-            Some(Self::try_from(value_data_type.as_ref())?)
-        } else {
-            None
-        };
-
-        let flags = match dtype {
-            Map(_, true) => Flags::MAP_KEYS_SORTED,
-            _ => Flags::empty(),
-        };
-
-        FFI_ArrowSchema::try_new(&format, children, dictionary)?.with_flags(flags)
-    }
-}
-
-fn get_format_string(dtype: &DataType) -> Result<String> {
-    match dtype {
-        DataType::Null => Ok("n".to_string()),
-        DataType::Boolean => Ok("b".to_string()),
-        DataType::Int8 => Ok("c".to_string()),
-        DataType::UInt8 => Ok("C".to_string()),
-        DataType::Int16 => Ok("s".to_string()),
-        DataType::UInt16 => Ok("S".to_string()),
-        DataType::Int32 => Ok("i".to_string()),
-        DataType::UInt32 => Ok("I".to_string()),
-        DataType::Int64 => Ok("l".to_string()),
-        DataType::UInt64 => Ok("L".to_string()),
-        DataType::Float16 => Ok("e".to_string()),
-        DataType::Float32 => Ok("f".to_string()),
-        DataType::Float64 => Ok("g".to_string()),
-        DataType::Binary => Ok("z".to_string()),
-        DataType::LargeBinary => Ok("Z".to_string()),
-        DataType::Utf8 => Ok("u".to_string()),
-        DataType::LargeUtf8 => Ok("U".to_string()),
-        DataType::FixedSizeBinary(num_bytes) => Ok(format!("w:{}", num_bytes)),
-        DataType::FixedSizeList(_, num_elems) => Ok(format!("+w:{}", num_elems)),
-        DataType::Decimal128(precision, scale) => {
-            Ok(format!("d:{},{}", precision, scale))
-        }
-        DataType::Date32 => Ok("tdD".to_string()),
-        DataType::Date64 => Ok("tdm".to_string()),
-        DataType::Time32(TimeUnit::Second) => Ok("tts".to_string()),
-        DataType::Time32(TimeUnit::Millisecond) => Ok("ttm".to_string()),
-        DataType::Time64(TimeUnit::Microsecond) => Ok("ttu".to_string()),
-        DataType::Time64(TimeUnit::Nanosecond) => Ok("ttn".to_string()),
-        DataType::Timestamp(TimeUnit::Second, None) => Ok("tss:".to_string()),
-        DataType::Timestamp(TimeUnit::Millisecond, None) => Ok("tsm:".to_string()),
-        DataType::Timestamp(TimeUnit::Microsecond, None) => Ok("tsu:".to_string()),
-        DataType::Timestamp(TimeUnit::Nanosecond, None) => Ok("tsn:".to_string()),
-        DataType::Timestamp(TimeUnit::Second, Some(tz)) => Ok(format!("tss:{}", tz)),
-        DataType::Timestamp(TimeUnit::Millisecond, Some(tz)) => Ok(format!("tsm:{}", tz)),
-        DataType::Timestamp(TimeUnit::Microsecond, Some(tz)) => Ok(format!("tsu:{}", tz)),
-        DataType::Timestamp(TimeUnit::Nanosecond, Some(tz)) => Ok(format!("tsn:{}", tz)),
-        DataType::Duration(TimeUnit::Second) => Ok("tDs".to_string()),
-        DataType::Duration(TimeUnit::Millisecond) => Ok("tDm".to_string()),
-        DataType::Duration(TimeUnit::Microsecond) => Ok("tDu".to_string()),
-        DataType::Duration(TimeUnit::Nanosecond) => Ok("tDn".to_string()),
-        DataType::List(_) => Ok("+l".to_string()),
-        DataType::LargeList(_) => Ok("+L".to_string()),
-        DataType::Struct(_) => Ok("+s".to_string()),
-        DataType::Map(_, _) => Ok("+m".to_string()),
-        DataType::Dictionary(key_data_type, _) => get_format_string(key_data_type),
-        other => Err(ArrowError::CDataInterface(format!(
-            "The datatype \"{:?}\" is still not supported in Rust implementation",
-            other
-        ))),
-    }
-}
-
-impl TryFrom<&Field> for FFI_ArrowSchema {
-    type Error = ArrowError;
-
-    fn try_from(field: &Field) -> Result<Self> {
-        let mut flags = if field.is_nullable() {
-            Flags::NULLABLE
-        } else {
-            Flags::empty()
-        };
-
-        if let Some(true) = field.dict_is_ordered() {
-            flags |= Flags::DICTIONARY_ORDERED;
-        }
-
-        FFI_ArrowSchema::try_from(field.data_type())?
-            .with_name(field.name())?
-            .with_flags(flags)
-    }
-}
-
-impl TryFrom<&Schema> for FFI_ArrowSchema {
-    type Error = ArrowError;
-
-    fn try_from(schema: &Schema) -> Result<Self> {
-        let dtype = DataType::Struct(schema.fields().clone());
-        let c_schema = FFI_ArrowSchema::try_from(&dtype)?;
-        Ok(c_schema)
-    }
-}
-
-impl TryFrom<DataType> for FFI_ArrowSchema {
-    type Error = ArrowError;
-
-    fn try_from(dtype: DataType) -> Result<Self> {
-        FFI_ArrowSchema::try_from(&dtype)
-    }
-}
-
-impl TryFrom<Field> for FFI_ArrowSchema {
-    type Error = ArrowError;
-
-    fn try_from(field: Field) -> Result<Self> {
-        FFI_ArrowSchema::try_from(&field)
-    }
-}
-
-impl TryFrom<Schema> for FFI_ArrowSchema {
-    type Error = ArrowError;
-
-    fn try_from(schema: Schema) -> Result<Self> {
-        FFI_ArrowSchema::try_from(&schema)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::datatypes::{DataType, Field, TimeUnit};
-    use crate::error::Result;
-    use std::convert::TryFrom;
-
-    fn round_trip_type(dtype: DataType) -> Result<()> {
-        let c_schema = FFI_ArrowSchema::try_from(&dtype)?;
-        let restored = DataType::try_from(&c_schema)?;
-        assert_eq!(restored, dtype);
-        Ok(())
-    }
-
-    fn round_trip_field(field: Field) -> Result<()> {
-        let c_schema = FFI_ArrowSchema::try_from(&field)?;
-        let restored = Field::try_from(&c_schema)?;
-        assert_eq!(restored, field);
-        Ok(())
-    }
-
-    fn round_trip_schema(schema: Schema) -> Result<()> {
-        let c_schema = FFI_ArrowSchema::try_from(&schema)?;
-        let restored = Schema::try_from(&c_schema)?;
-        assert_eq!(restored, schema);
-        Ok(())
-    }
-
-    #[test]
-    fn test_type() -> Result<()> {
-        round_trip_type(DataType::Int64)?;
-        round_trip_type(DataType::UInt64)?;
-        round_trip_type(DataType::Float64)?;
-        round_trip_type(DataType::Date64)?;
-        round_trip_type(DataType::Time64(TimeUnit::Nanosecond))?;
-        round_trip_type(DataType::FixedSizeBinary(12))?;
-        round_trip_type(DataType::FixedSizeList(
-            Box::new(Field::new("a", DataType::Int64, false)),
-            5,
-        ))?;
-        round_trip_type(DataType::Utf8)?;
-        round_trip_type(DataType::List(Box::new(Field::new(
-            "a",
-            DataType::Int16,
-            false,
-        ))))?;
-        round_trip_type(DataType::Struct(vec![Field::new(
-            "a",
-            DataType::Utf8,
-            true,
-        )]))?;
-        Ok(())
-    }
-
-    #[test]
-    fn test_field() -> Result<()> {
-        let dtype = DataType::Struct(vec![Field::new("a", DataType::Utf8, true)]);
-        round_trip_field(Field::new("test", dtype, true))?;
-        Ok(())
-    }
-
-    #[test]
-    fn test_schema() -> Result<()> {
-        let schema = Schema::new(vec![
-            Field::new("name", DataType::Utf8, false),
-            Field::new("address", DataType::Utf8, false),
-            Field::new("priority", DataType::UInt8, false),
-        ]);
-        round_trip_schema(schema)?;
-
-        // test that we can interpret struct types as schema
-        let dtype = DataType::Struct(vec![
-            Field::new("a", DataType::Utf8, true),
-            Field::new("b", DataType::Int16, false),
-        ]);
-        let c_schema = FFI_ArrowSchema::try_from(&dtype)?;
-        let schema = Schema::try_from(&c_schema)?;
-        assert_eq!(schema.fields().len(), 2);
-
-        // test that we assert the input type
-        let c_schema = FFI_ArrowSchema::try_from(&DataType::Float64)?;
-        let result = Schema::try_from(&c_schema);
-        assert!(result.is_err());
-        Ok(())
-    }
-
-    #[test]
-    fn test_map_keys_sorted() -> Result<()> {
-        let keys = Field::new("keys", DataType::Int32, false);
-        let values = Field::new("values", DataType::UInt32, false);
-        let entry_struct = DataType::Struct(vec![keys, values]);
-
-        // Construct a map array from the above two
-        let map_data_type =
-            DataType::Map(Box::new(Field::new("entries", entry_struct, true)), true);
-
-        let arrow_schema = FFI_ArrowSchema::try_from(map_data_type)?;
-        assert!(arrow_schema.map_keys_sorted());
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_dictionary_ordered() -> Result<()> {
-        let schema = Schema::new(vec![Field::new_dict(
-            "dict",
-            DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
-            false,
-            0,
-            true,
-        )]);
-
-        let arrow_schema = FFI_ArrowSchema::try_from(schema)?;
-        assert!(arrow_schema.child(0).dictionary_ordered());
-
-        Ok(())
-    }
-}
diff --git a/arrow/src/datatypes/field.rs b/arrow/src/datatypes/field.rs
deleted file mode 100644
index f50ebadd5e7c..000000000000
--- a/arrow/src/datatypes/field.rs
+++ /dev/null
@@ -1,881 +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.
-
-use std::cmp::Ordering;
-use std::collections::BTreeMap;
-use std::hash::{Hash, Hasher};
-
-use serde_derive::{Deserialize, Serialize};
-use serde_json::{json, Value};
-
-use crate::error::{ArrowError, Result};
-
-use super::DataType;
-
-/// Describes a single column in a [`Schema`](super::Schema).
-///
-/// A [`Schema`](super::Schema) is an ordered collection of
-/// [`Field`] objects.
-#[derive(Serialize, Deserialize, Debug, Clone)]
-pub struct Field {
-    name: String,
-    data_type: DataType,
-    nullable: bool,
-    dict_id: i64,
-    dict_is_ordered: bool,
-    /// A map of key-value pairs containing additional custom meta data.
-    #[serde(skip_serializing_if = "Option::is_none")]
-    metadata: Option<BTreeMap<String, String>>,
-}
-
-// Auto-derive `PartialEq` traits will pull `dict_id` and `dict_is_ordered`
-// into comparison. However, these properties are only used in IPC context
-// for matching dictionary encoded data. They are not necessary to be same
-// to consider schema equality. For example, in C++ `Field` implementation,
-// it doesn't contain these dictionary properties too.
-impl PartialEq for Field {
-    fn eq(&self, other: &Self) -> bool {
-        self.name == other.name
-            && self.data_type == other.data_type
-            && self.nullable == other.nullable
-            && self.metadata == other.metadata
-    }
-}
-
-impl Eq for Field {}
-
-impl PartialOrd for Field {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for Field {
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.name
-            .cmp(other.name())
-            .then(self.data_type.cmp(other.data_type()))
-            .then(self.nullable.cmp(&other.nullable))
-            .then(self.metadata.cmp(&other.metadata))
-    }
-}
-
-impl Hash for Field {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.name.hash(state);
-        self.data_type.hash(state);
-        self.nullable.hash(state);
-        self.metadata.hash(state);
-    }
-}
-
-impl Field {
-    /// Creates a new field
-    pub fn new(name: &str, data_type: DataType, nullable: bool) -> Self {
-        Field {
-            name: name.to_string(),
-            data_type,
-            nullable,
-            dict_id: 0,
-            dict_is_ordered: false,
-            metadata: None,
-        }
-    }
-
-    /// Creates a new field that has additional dictionary information
-    pub fn new_dict(
-        name: &str,
-        data_type: DataType,
-        nullable: bool,
-        dict_id: i64,
-        dict_is_ordered: bool,
-    ) -> Self {
-        Field {
-            name: name.to_string(),
-            data_type,
-            nullable,
-            dict_id,
-            dict_is_ordered,
-            metadata: None,
-        }
-    }
-
-    /// Sets the `Field`'s optional custom metadata.
-    /// The metadata is set as `None` for empty map.
-    #[inline]
-    pub fn set_metadata(&mut self, metadata: Option<BTreeMap<String, String>>) {
-        // To make serde happy, convert Some(empty_map) to None.
-        self.metadata = None;
-        if let Some(v) = metadata {
-            if !v.is_empty() {
-                self.metadata = Some(v);
-            }
-        }
-    }
-
-    /// Sets the metadata of this `Field` to be `metadata` and returns self
-    pub fn with_metadata(mut self, metadata: Option<BTreeMap<String, String>>) -> Self {
-        self.set_metadata(metadata);
-        self
-    }
-
-    /// Returns the immutable reference to the `Field`'s optional custom metadata.
-    #[inline]
-    pub const fn metadata(&self) -> Option<&BTreeMap<String, String>> {
-        self.metadata.as_ref()
-    }
-
-    /// Returns an immutable reference to the `Field`'s name.
-    #[inline]
-    pub const fn name(&self) -> &String {
-        &self.name
-    }
-
-    /// Set the name of the [`Field`] and returns self.
-    ///
-    /// ```
-    /// # use arrow::datatypes::*;
-    /// let field = Field::new("c1", DataType::Int64, false)
-    ///    .with_name("c2");
-    ///
-    /// assert_eq!(field.name(), "c2");
-    /// ```
-    pub fn with_name(mut self, name: impl Into<String>) -> Self {
-        self.name = name.into();
-        self
-    }
-
-    /// Returns an immutable reference to the [`Field`]'s  [`DataType`].
-    #[inline]
-    pub const fn data_type(&self) -> &DataType {
-        &self.data_type
-    }
-
-    /// Set [`DataType`] of the [`Field`] and returns self.
-    ///
-    /// ```
-    /// # use arrow::datatypes::*;
-    /// let field = Field::new("c1", DataType::Int64, false)
-    ///    .with_data_type(DataType::Utf8);
-    ///
-    /// assert_eq!(field.data_type(), &DataType::Utf8);
-    /// ```
-    pub fn with_data_type(mut self, data_type: DataType) -> Self {
-        self.data_type = data_type;
-        self
-    }
-
-    /// Indicates whether this [`Field`] supports null values.
-    #[inline]
-    pub const fn is_nullable(&self) -> bool {
-        self.nullable
-    }
-
-    /// Set `nullable` of the [`Field`] and returns self.
-    ///
-    /// ```
-    /// # use arrow::datatypes::*;
-    /// let field = Field::new("c1", DataType::Int64, false)
-    ///    .with_nullable(true);
-    ///
-    /// assert_eq!(field.is_nullable(), true);
-    /// ```
-    pub fn with_nullable(mut self, nullable: bool) -> Self {
-        self.nullable = nullable;
-        self
-    }
-
-    /// Returns a (flattened) [`Vec`] containing all child [`Field`]s
-    /// within `self` contained within this field (including `self`)
-    pub(crate) fn fields(&self) -> Vec<&Field> {
-        let mut collected_fields = vec![self];
-        collected_fields.append(&mut self._fields(&self.data_type));
-
-        collected_fields
-    }
-
-    fn _fields<'a>(&'a self, dt: &'a DataType) -> Vec<&Field> {
-        match dt {
-            DataType::Struct(fields) | DataType::Union(fields, _, _) => {
-                fields.iter().flat_map(|f| f.fields()).collect()
-            }
-            DataType::List(field)
-            | DataType::LargeList(field)
-            | DataType::FixedSizeList(field, _)
-            | DataType::Map(field, _) => field.fields(),
-            DataType::Dictionary(_, value_field) => self._fields(value_field.as_ref()),
-            _ => vec![],
-        }
-    }
-
-    /// Returns a vector containing all (potentially nested) `Field` instances selected by the
-    /// dictionary ID they use
-    #[inline]
-    pub(crate) fn fields_with_dict_id(&self, id: i64) -> Vec<&Field> {
-        self.fields()
-            .into_iter()
-            .filter(|&field| {
-                matches!(field.data_type(), DataType::Dictionary(_, _))
-                    && field.dict_id == id
-            })
-            .collect()
-    }
-
-    /// Returns the dictionary ID, if this is a dictionary type.
-    #[inline]
-    pub const fn dict_id(&self) -> Option<i64> {
-        match self.data_type {
-            DataType::Dictionary(_, _) => Some(self.dict_id),
-            _ => None,
-        }
-    }
-
-    /// Returns whether this `Field`'s dictionary is ordered, if this is a dictionary type.
-    #[inline]
-    pub const fn dict_is_ordered(&self) -> Option<bool> {
-        match self.data_type {
-            DataType::Dictionary(_, _) => Some(self.dict_is_ordered),
-            _ => None,
-        }
-    }
-
-    /// Parse a `Field` definition from a JSON representation.
-    pub fn from(json: &Value) -> Result<Self> {
-        match *json {
-            Value::Object(ref map) => {
-                let name = match map.get("name") {
-                    Some(&Value::String(ref name)) => name.to_string(),
-                    _ => {
-                        return Err(ArrowError::ParseError(
-                            "Field missing 'name' attribute".to_string(),
-                        ));
-                    }
-                };
-                let nullable = match map.get("nullable") {
-                    Some(&Value::Bool(b)) => b,
-                    _ => {
-                        return Err(ArrowError::ParseError(
-                            "Field missing 'nullable' attribute".to_string(),
-                        ));
-                    }
-                };
-                let data_type = match map.get("type") {
-                    Some(t) => DataType::from(t)?,
-                    _ => {
-                        return Err(ArrowError::ParseError(
-                            "Field missing 'type' attribute".to_string(),
-                        ));
-                    }
-                };
-
-                // Referenced example file: testing/data/arrow-ipc-stream/integration/1.0.0-littleendian/generated_custom_metadata.json.gz
-                let metadata = match map.get("metadata") {
-                    Some(&Value::Array(ref values)) => {
-                        let mut res: BTreeMap<String, String> = BTreeMap::new();
-                        for value in values {
-                            match value.as_object() {
-                                Some(map) => {
-                                    if map.len() != 2 {
-                                        return Err(ArrowError::ParseError(
-                                            "Field 'metadata' must have exact two entries for each key-value map".to_string(),
-                                        ));
-                                    }
-                                    if let (Some(k), Some(v)) =
-                                        (map.get("key"), map.get("value"))
-                                    {
-                                        if let (Some(k_str), Some(v_str)) =
-                                            (k.as_str(), v.as_str())
-                                        {
-                                            res.insert(
-                                                k_str.to_string().clone(),
-                                                v_str.to_string().clone(),
-                                            );
-                                        } else {
-                                            return Err(ArrowError::ParseError("Field 'metadata' must have map value of string type".to_string()));
-                                        }
-                                    } else {
-                                        return Err(ArrowError::ParseError("Field 'metadata' lacks map keys named \"key\" or \"value\"".to_string()));
-                                    }
-                                }
-                                _ => {
-                                    return Err(ArrowError::ParseError(
-                                        "Field 'metadata' contains non-object key-value pair".to_string(),
-                                    ));
-                                }
-                            }
-                        }
-                        Some(res)
-                    }
-                    // We also support map format, because Schema's metadata supports this.
-                    // See https://github.com/apache/arrow/pull/5907
-                    Some(&Value::Object(ref values)) => {
-                        let mut res: BTreeMap<String, String> = BTreeMap::new();
-                        for (k, v) in values {
-                            if let Some(str_value) = v.as_str() {
-                                res.insert(k.clone(), str_value.to_string().clone());
-                            } else {
-                                return Err(ArrowError::ParseError(
-                                    format!("Field 'metadata' contains non-string value for key {}", k),
-                                ));
-                            }
-                        }
-                        Some(res)
-                    }
-                    Some(_) => {
-                        return Err(ArrowError::ParseError(
-                            "Field `metadata` is not json array".to_string(),
-                        ));
-                    }
-                    _ => None,
-                };
-
-                // if data_type is a struct or list, get its children
-                let data_type = match data_type {
-                    DataType::List(_)
-                    | DataType::LargeList(_)
-                    | DataType::FixedSizeList(_, _) => match map.get("children") {
-                        Some(Value::Array(values)) => {
-                            if values.len() != 1 {
-                                return Err(ArrowError::ParseError(
-                                    "Field 'children' must have one element for a list data type".to_string(),
-                                ));
-                            }
-                            match data_type {
-                                    DataType::List(_) => {
-                                        DataType::List(Box::new(Self::from(&values[0])?))
-                                    }
-                                    DataType::LargeList(_) => {
-                                        DataType::LargeList(Box::new(Self::from(&values[0])?))
-                                    }
-                                    DataType::FixedSizeList(_, int) => DataType::FixedSizeList(
-                                        Box::new(Self::from(&values[0])?),
-                                        int,
-                                    ),
-                                    _ => unreachable!(
-                                        "Data type should be a list, largelist or fixedsizelist"
-                                    ),
-                                }
-                        }
-                        Some(_) => {
-                            return Err(ArrowError::ParseError(
-                                "Field 'children' must be an array".to_string(),
-                            ))
-                        }
-                        None => {
-                            return Err(ArrowError::ParseError(
-                                "Field missing 'children' attribute".to_string(),
-                            ));
-                        }
-                    },
-                    DataType::Struct(mut fields) => match map.get("children") {
-                        Some(Value::Array(values)) => {
-                            let struct_fields: Result<Vec<Field>> =
-                                values.iter().map(Field::from).collect();
-                            fields.append(&mut struct_fields?);
-                            DataType::Struct(fields)
-                        }
-                        Some(_) => {
-                            return Err(ArrowError::ParseError(
-                                "Field 'children' must be an array".to_string(),
-                            ))
-                        }
-                        None => {
-                            return Err(ArrowError::ParseError(
-                                "Field missing 'children' attribute".to_string(),
-                            ));
-                        }
-                    },
-                    DataType::Map(_, keys_sorted) => {
-                        match map.get("children") {
-                            Some(Value::Array(values)) if values.len() == 1 => {
-                                let child = Self::from(&values[0])?;
-                                // child must be a struct
-                                match child.data_type() {
-                                    DataType::Struct(map_fields) if map_fields.len() == 2 => {
-                                        DataType::Map(Box::new(child), keys_sorted)
-                                    }
-                                    t  => {
-                                        return Err(ArrowError::ParseError(
-                                            format!("Map children should be a struct with 2 fields, found {:?}",  t)
-                                        ))
-                                    }
-                                }
-                            }
-                            Some(_) => {
-                                return Err(ArrowError::ParseError(
-                                    "Field 'children' must be an array with 1 element"
-                                        .to_string(),
-                                ))
-                            }
-                            None => {
-                                return Err(ArrowError::ParseError(
-                                    "Field missing 'children' attribute".to_string(),
-                                ));
-                            }
-                        }
-                    }
-                    DataType::Union(_, type_ids, mode) => match map.get("children") {
-                        Some(Value::Array(values)) => {
-                            let union_fields: Vec<Field> =
-                                values.iter().map(Field::from).collect::<Result<_>>()?;
-                            DataType::Union(union_fields, type_ids, mode)
-                        }
-                        Some(_) => {
-                            return Err(ArrowError::ParseError(
-                                "Field 'children' must be an array".to_string(),
-                            ))
-                        }
-                        None => {
-                            return Err(ArrowError::ParseError(
-                                "Field missing 'children' attribute".to_string(),
-                            ));
-                        }
-                    },
-                    _ => data_type,
-                };
-
-                let mut dict_id = 0;
-                let mut dict_is_ordered = false;
-
-                let data_type = match map.get("dictionary") {
-                    Some(dictionary) => {
-                        let index_type = match dictionary.get("indexType") {
-                            Some(t) => DataType::from(t)?,
-                            _ => {
-                                return Err(ArrowError::ParseError(
-                                    "Field missing 'indexType' attribute".to_string(),
-                                ));
-                            }
-                        };
-                        dict_id = match dictionary.get("id") {
-                            Some(Value::Number(n)) => n.as_i64().unwrap(),
-                            _ => {
-                                return Err(ArrowError::ParseError(
-                                    "Field missing 'id' attribute".to_string(),
-                                ));
-                            }
-                        };
-                        dict_is_ordered = match dictionary.get("isOrdered") {
-                            Some(&Value::Bool(n)) => n,
-                            _ => {
-                                return Err(ArrowError::ParseError(
-                                    "Field missing 'isOrdered' attribute".to_string(),
-                                ));
-                            }
-                        };
-                        DataType::Dictionary(Box::new(index_type), Box::new(data_type))
-                    }
-                    _ => data_type,
-                };
-                Ok(Field {
-                    name,
-                    data_type,
-                    nullable,
-                    dict_id,
-                    dict_is_ordered,
-                    metadata,
-                })
-            }
-            _ => Err(ArrowError::ParseError(
-                "Invalid json value type for field".to_string(),
-            )),
-        }
-    }
-
-    /// Generate a JSON representation of the `Field`.
-    pub fn to_json(&self) -> Value {
-        let children: Vec<Value> = match self.data_type() {
-            DataType::Struct(fields) => fields.iter().map(|f| f.to_json()).collect(),
-            DataType::List(field)
-            | DataType::LargeList(field)
-            | DataType::FixedSizeList(field, _)
-            | DataType::Map(field, _) => vec![field.to_json()],
-            _ => vec![],
-        };
-        match self.data_type() {
-            DataType::Dictionary(ref index_type, ref value_type) => json!({
-                "name": self.name,
-                "nullable": self.nullable,
-                "type": value_type.to_json(),
-                "children": children,
-                "dictionary": {
-                    "id": self.dict_id,
-                    "indexType": index_type.to_json(),
-                    "isOrdered": self.dict_is_ordered
-                }
-            }),
-            _ => json!({
-                "name": self.name,
-                "nullable": self.nullable,
-                "type": self.data_type.to_json(),
-                "children": children
-            }),
-        }
-    }
-
-    /// Merge this field into self if it is compatible.
-    ///
-    /// Struct fields are merged recursively.
-    ///
-    /// NOTE: `self` may be updated to a partial / unexpected state in case of merge failure.
-    ///
-    /// Example:
-    ///
-    /// ```
-    /// # use arrow::datatypes::*;
-    /// let mut field = Field::new("c1", DataType::Int64, false);
-    /// assert!(field.try_merge(&Field::new("c1", DataType::Int64, true)).is_ok());
-    /// assert!(field.is_nullable());
-    /// ```
-    pub fn try_merge(&mut self, from: &Field) -> Result<()> {
-        if from.dict_id != self.dict_id {
-            return Err(ArrowError::SchemaError(
-                "Fail to merge schema Field due to conflicting dict_id".to_string(),
-            ));
-        }
-        if from.dict_is_ordered != self.dict_is_ordered {
-            return Err(ArrowError::SchemaError(
-                "Fail to merge schema Field due to conflicting dict_is_ordered"
-                    .to_string(),
-            ));
-        }
-        // merge metadata
-        match (self.metadata(), from.metadata()) {
-            (Some(self_metadata), Some(from_metadata)) => {
-                let mut merged = self_metadata.clone();
-                for (key, from_value) in from_metadata {
-                    if let Some(self_value) = self_metadata.get(key) {
-                        if self_value != from_value {
-                            return Err(ArrowError::SchemaError(format!(
-                                "Fail to merge field due to conflicting metadata data value for key {}", key),
-                            ));
-                        }
-                    } else {
-                        merged.insert(key.clone(), from_value.clone());
-                    }
-                }
-                self.set_metadata(Some(merged));
-            }
-            (None, Some(from_metadata)) => {
-                self.set_metadata(Some(from_metadata.clone()));
-            }
-            _ => {}
-        }
-        match &mut self.data_type {
-            DataType::Struct(nested_fields) => match &from.data_type {
-                DataType::Struct(from_nested_fields) => {
-                    for from_field in from_nested_fields {
-                        match nested_fields
-                            .iter_mut()
-                            .find(|self_field| self_field.name == from_field.name)
-                        {
-                            Some(self_field) => self_field.try_merge(from_field)?,
-                            None => nested_fields.push(from_field.clone()),
-                        }
-                    }
-                }
-                _ => {
-                    return Err(ArrowError::SchemaError(
-                        "Fail to merge schema Field due to conflicting datatype"
-                            .to_string(),
-                    ));
-                }
-            },
-            DataType::Union(nested_fields, type_ids, _) => match &from.data_type {
-                DataType::Union(from_nested_fields, from_type_ids, _) => {
-                    for (idx, from_field) in from_nested_fields.iter().enumerate() {
-                        let mut is_new_field = true;
-                        let field_type_id = from_type_ids.get(idx).unwrap();
-
-                        for (self_idx, self_field) in nested_fields.iter_mut().enumerate()
-                        {
-                            if from_field == self_field {
-                                let self_type_id = type_ids.get(self_idx).unwrap();
-
-                                // If the nested fields in two unions are the same, they must have same
-                                // type id.
-                                if self_type_id != field_type_id {
-                                    return Err(ArrowError::SchemaError(
-                                        "Fail to merge schema Field due to conflicting type ids in union datatype"
-                                            .to_string(),
-                                    ));
-                                }
-
-                                is_new_field = false;
-                                break;
-                            }
-                        }
-
-                        if is_new_field {
-                            nested_fields.push(from_field.clone());
-                            type_ids.push(*field_type_id);
-                        }
-                    }
-                }
-                _ => {
-                    return Err(ArrowError::SchemaError(
-                        "Fail to merge schema Field due to conflicting datatype"
-                            .to_string(),
-                    ));
-                }
-            },
-            DataType::Null
-            | DataType::Boolean
-            | DataType::Int8
-            | DataType::Int16
-            | DataType::Int32
-            | DataType::Int64
-            | DataType::UInt8
-            | DataType::UInt16
-            | DataType::UInt32
-            | DataType::UInt64
-            | DataType::Float16
-            | DataType::Float32
-            | DataType::Float64
-            | DataType::Timestamp(_, _)
-            | DataType::Date32
-            | DataType::Date64
-            | DataType::Time32(_)
-            | DataType::Time64(_)
-            | DataType::Duration(_)
-            | DataType::Binary
-            | DataType::LargeBinary
-            | DataType::Interval(_)
-            | DataType::LargeList(_)
-            | DataType::List(_)
-            | DataType::Map(_, _)
-            | DataType::Dictionary(_, _)
-            | DataType::FixedSizeList(_, _)
-            | DataType::FixedSizeBinary(_)
-            | DataType::Utf8
-            | DataType::LargeUtf8
-            | DataType::Decimal128(_, _)
-            | DataType::Decimal256(_, _) => {
-                if self.data_type != from.data_type {
-                    return Err(ArrowError::SchemaError(
-                        "Fail to merge schema Field due to conflicting datatype"
-                            .to_string(),
-                    ));
-                }
-            }
-        }
-        self.nullable |= from.nullable;
-
-        Ok(())
-    }
-
-    /// Check to see if `self` is a superset of `other` field. Superset is defined as:
-    ///
-    /// * if nullability doesn't match, self needs to be nullable
-    /// * self.metadata is a superset of other.metadata
-    /// * all other fields are equal
-    pub fn contains(&self, other: &Field) -> bool {
-        self.name == other.name
-        && self.data_type == other.data_type
-        && self.dict_id == other.dict_id
-        && self.dict_is_ordered == other.dict_is_ordered
-        // self need to be nullable or both of them are not nullable
-        && (self.nullable || !other.nullable)
-        // make sure self.metadata is a superset of other.metadata
-        && match (&self.metadata, &other.metadata) {
-            (_, None) => true,
-            (None, Some(_)) => false,
-            (Some(self_meta), Some(other_meta)) => {
-                other_meta.iter().all(|(k, v)| {
-                    match self_meta.get(k) {
-                        Some(s) => s == v,
-                        None => false
-                    }
-                })
-            }
-        }
-    }
-}
-
-// TODO: improve display with crate https://crates.io/crates/derive_more ?
-impl std::fmt::Display for Field {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        write!(f, "{:?}", self)
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-    use std::collections::hash_map::DefaultHasher;
-    use std::hash::{Hash, Hasher};
-
-    #[test]
-    fn test_fields_with_dict_id() {
-        let dict1 = Field::new_dict(
-            "dict1",
-            DataType::Dictionary(DataType::Utf8.into(), DataType::Int32.into()),
-            false,
-            10,
-            false,
-        );
-        let dict2 = Field::new_dict(
-            "dict2",
-            DataType::Dictionary(DataType::Int32.into(), DataType::Int8.into()),
-            false,
-            20,
-            false,
-        );
-
-        let field = Field::new(
-            "struct<dict1, list[struct<dict2, list[struct<dict1]>]>",
-            DataType::Struct(vec![
-                dict1.clone(),
-                Field::new(
-                    "list[struct<dict1, list[struct<dict2>]>]",
-                    DataType::List(Box::new(Field::new(
-                        "struct<dict1, list[struct<dict2>]>",
-                        DataType::Struct(vec![
-                            dict1.clone(),
-                            Field::new(
-                                "list[struct<dict2>]",
-                                DataType::List(Box::new(Field::new(
-                                    "struct<dict2>",
-                                    DataType::Struct(vec![dict2.clone()]),
-                                    false,
-                                ))),
-                                false,
-                            ),
-                        ]),
-                        false,
-                    ))),
-                    false,
-                ),
-            ]),
-            false,
-        );
-
-        for field in field.fields_with_dict_id(10) {
-            assert_eq!(dict1, *field);
-        }
-        for field in field.fields_with_dict_id(20) {
-            assert_eq!(dict2, *field);
-        }
-    }
-
-    fn get_field_hash(field: &Field) -> u64 {
-        let mut s = DefaultHasher::new();
-        field.hash(&mut s);
-        s.finish()
-    }
-
-    #[test]
-    fn test_field_comparison_case() {
-        // dictionary-encoding properties not used for field comparison
-        let dict1 = Field::new_dict(
-            "dict1",
-            DataType::Dictionary(DataType::Utf8.into(), DataType::Int32.into()),
-            false,
-            10,
-            false,
-        );
-        let dict2 = Field::new_dict(
-            "dict1",
-            DataType::Dictionary(DataType::Utf8.into(), DataType::Int32.into()),
-            false,
-            20,
-            false,
-        );
-
-        assert_eq!(dict1, dict2);
-        assert_eq!(get_field_hash(&dict1), get_field_hash(&dict2));
-
-        let dict1 = Field::new_dict(
-            "dict0",
-            DataType::Dictionary(DataType::Utf8.into(), DataType::Int32.into()),
-            false,
-            10,
-            false,
-        );
-
-        assert_ne!(dict1, dict2);
-        assert_ne!(get_field_hash(&dict1), get_field_hash(&dict2));
-    }
-
-    #[test]
-    fn test_contains_reflexivity() {
-        let mut field = Field::new("field1", DataType::Float16, false);
-        field.set_metadata(Some(BTreeMap::from([
-            (String::from("k0"), String::from("v0")),
-            (String::from("k1"), String::from("v1")),
-        ])));
-        assert!(field.contains(&field))
-    }
-
-    #[test]
-    fn test_contains_transitivity() {
-        let child_field = Field::new("child1", DataType::Float16, false);
-
-        let mut field1 = Field::new("field1", DataType::Struct(vec![child_field]), false);
-        field1.set_metadata(Some(BTreeMap::from([(
-            String::from("k1"),
-            String::from("v1"),
-        )])));
-
-        let mut field2 = Field::new("field1", DataType::Struct(vec![]), true);
-        field2.set_metadata(Some(BTreeMap::from([(
-            String::from("k2"),
-            String::from("v2"),
-        )])));
-        field2.try_merge(&field1).unwrap();
-
-        let mut field3 = Field::new("field1", DataType::Struct(vec![]), false);
-        field3.set_metadata(Some(BTreeMap::from([(
-            String::from("k3"),
-            String::from("v3"),
-        )])));
-        field3.try_merge(&field2).unwrap();
-
-        assert!(field2.contains(&field1));
-        assert!(field3.contains(&field2));
-        assert!(field3.contains(&field1));
-
-        assert!(!field1.contains(&field2));
-        assert!(!field1.contains(&field3));
-        assert!(!field2.contains(&field3));
-    }
-
-    #[test]
-    fn test_contains_nullable() {
-        let field1 = Field::new("field1", DataType::Boolean, true);
-        let field2 = Field::new("field1", DataType::Boolean, false);
-        assert!(field1.contains(&field2));
-        assert!(!field2.contains(&field1));
-    }
-
-    #[test]
-    fn test_contains_must_have_same_fields() {
-        let child_field1 = Field::new("child1", DataType::Float16, false);
-        let child_field2 = Field::new("child2", DataType::Float16, false);
-
-        let field1 =
-            Field::new("field1", DataType::Struct(vec![child_field1.clone()]), true);
-        let field2 = Field::new(
-            "field1",
-            DataType::Struct(vec![child_field1, child_field2]),
-            true,
-        );
-
-        assert!(!field1.contains(&field2));
-        assert!(!field2.contains(&field1));
-    }
-}
diff --git a/arrow/src/datatypes/mod.rs b/arrow/src/datatypes/mod.rs
index 1f98a4afa918..d41289d52e2a 100644
--- a/arrow/src/datatypes/mod.rs
+++ b/arrow/src/datatypes/mod.rs
@@ -18,1497 +18,15 @@
 //! Defines the logical data types of Arrow arrays.
 //!
 //! The most important things you might be looking for are:
-//!  * [`Schema`](crate::datatypes::Schema) to describe a schema.
-//!  * [`Field`](crate::datatypes::Field) to describe one field within a schema.
-//!  * [`DataType`](crate::datatypes::DataType) to describe the type of a field.
-
-use std::sync::Arc;
-
-mod native;
-pub use native::*;
-mod field;
-pub use field::*;
-mod schema;
-pub use schema::*;
-mod numeric;
-pub use numeric::*;
-mod types;
-pub use types::*;
-mod datatype;
-pub use datatype::*;
-mod delta;
-
-#[cfg(feature = "ffi")]
-mod ffi;
-#[cfg(feature = "ffi")]
-pub use ffi::*;
-
-/// A reference-counted reference to a [`Schema`](crate::datatypes::Schema).
-pub type SchemaRef = Arc<Schema>;
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::error::Result;
-    use serde_json::Value::{Bool, Number as VNumber, String as VString};
-    use serde_json::{Number, Value};
-    use std::{
-        collections::{BTreeMap, HashMap},
-        f32::NAN,
-    };
-
-    #[test]
-    fn test_list_datatype_equality() {
-        // tests that list type equality is checked while ignoring list names
-        let list_a = DataType::List(Box::new(Field::new("item", DataType::Int32, true)));
-        let list_b = DataType::List(Box::new(Field::new("array", DataType::Int32, true)));
-        let list_c = DataType::List(Box::new(Field::new("item", DataType::Int32, false)));
-        let list_d = DataType::List(Box::new(Field::new("item", DataType::UInt32, true)));
-        assert!(list_a.equals_datatype(&list_b));
-        assert!(!list_a.equals_datatype(&list_c));
-        assert!(!list_b.equals_datatype(&list_c));
-        assert!(!list_a.equals_datatype(&list_d));
-
-        let list_e =
-            DataType::FixedSizeList(Box::new(Field::new("item", list_a, false)), 3);
-        let list_f =
-            DataType::FixedSizeList(Box::new(Field::new("array", list_b, false)), 3);
-        let list_g = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::FixedSizeBinary(3), true)),
-            3,
-        );
-        assert!(list_e.equals_datatype(&list_f));
-        assert!(!list_e.equals_datatype(&list_g));
-        assert!(!list_f.equals_datatype(&list_g));
-
-        let list_h = DataType::Struct(vec![Field::new("f1", list_e, true)]);
-        let list_i = DataType::Struct(vec![Field::new("f1", list_f.clone(), true)]);
-        let list_j = DataType::Struct(vec![Field::new("f1", list_f.clone(), false)]);
-        let list_k = DataType::Struct(vec![
-            Field::new("f1", list_f.clone(), false),
-            Field::new("f2", list_g.clone(), false),
-            Field::new("f3", DataType::Utf8, true),
-        ]);
-        let list_l = DataType::Struct(vec![
-            Field::new("ff1", list_f.clone(), false),
-            Field::new("ff2", list_g.clone(), false),
-            Field::new("ff3", DataType::LargeUtf8, true),
-        ]);
-        let list_m = DataType::Struct(vec![
-            Field::new("ff1", list_f, false),
-            Field::new("ff2", list_g, false),
-            Field::new("ff3", DataType::Utf8, true),
-        ]);
-        assert!(list_h.equals_datatype(&list_i));
-        assert!(!list_h.equals_datatype(&list_j));
-        assert!(!list_k.equals_datatype(&list_l));
-        assert!(list_k.equals_datatype(&list_m));
-    }
-
-    #[test]
-    fn create_struct_type() {
-        let _person = DataType::Struct(vec![
-            Field::new("first_name", DataType::Utf8, false),
-            Field::new("last_name", DataType::Utf8, false),
-            Field::new(
-                "address",
-                DataType::Struct(vec![
-                    Field::new("street", DataType::Utf8, false),
-                    Field::new("zip", DataType::UInt16, false),
-                ]),
-                false,
-            ),
-        ]);
-    }
-
-    #[test]
-    fn serde_struct_type() {
-        let kv_array = [("k".to_string(), "v".to_string())];
-        let field_metadata: BTreeMap<String, String> = kv_array.iter().cloned().collect();
-
-        // Non-empty map: should be converted as JSON obj { ... }
-        let first_name = Field::new("first_name", DataType::Utf8, false)
-            .with_metadata(Some(field_metadata));
-
-        // Empty map: should be omitted.
-        let last_name = Field::new("last_name", DataType::Utf8, false)
-            .with_metadata(Some(BTreeMap::default()));
-
-        let person = DataType::Struct(vec![
-            first_name,
-            last_name,
-            Field::new(
-                "address",
-                DataType::Struct(vec![
-                    Field::new("street", DataType::Utf8, false),
-                    Field::new("zip", DataType::UInt16, false),
-                ]),
-                false,
-            ),
-        ]);
-
-        let serialized = serde_json::to_string(&person).unwrap();
-
-        // NOTE that this is testing the default (derived) serialization format, not the
-        // JSON format specified in metadata.md
-
-        assert_eq!(
-            "{\"Struct\":[\
-             {\"name\":\"first_name\",\"data_type\":\"Utf8\",\"nullable\":false,\"dict_id\":0,\"dict_is_ordered\":false,\"metadata\":{\"k\":\"v\"}},\
-             {\"name\":\"last_name\",\"data_type\":\"Utf8\",\"nullable\":false,\"dict_id\":0,\"dict_is_ordered\":false},\
-             {\"name\":\"address\",\"data_type\":{\"Struct\":\
-             [{\"name\":\"street\",\"data_type\":\"Utf8\",\"nullable\":false,\"dict_id\":0,\"dict_is_ordered\":false},\
-             {\"name\":\"zip\",\"data_type\":\"UInt16\",\"nullable\":false,\"dict_id\":0,\"dict_is_ordered\":false}\
-             ]},\"nullable\":false,\"dict_id\":0,\"dict_is_ordered\":false}]}",
-            serialized
-        );
-
-        let deserialized = serde_json::from_str(&serialized).unwrap();
-
-        assert_eq!(person, deserialized);
-    }
-
-    #[test]
-    fn struct_field_to_json() {
-        let f = Field::new(
-            "address",
-            DataType::Struct(vec![
-                Field::new("street", DataType::Utf8, false),
-                Field::new("zip", DataType::UInt16, false),
-            ]),
-            false,
-        );
-        let value: Value = serde_json::from_str(
-            r#"{
-                "name": "address",
-                "nullable": false,
-                "type": {
-                    "name": "struct"
-                },
-                "children": [
-                    {
-                        "name": "street",
-                        "nullable": false,
-                        "type": {
-                            "name": "utf8"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "zip",
-                        "nullable": false,
-                        "type": {
-                            "name": "int",
-                            "bitWidth": 16,
-                            "isSigned": false
-                        },
-                        "children": []
-                    }
-                ]
-            }"#,
-        )
-        .unwrap();
-        assert_eq!(value, f.to_json());
-    }
-
-    #[test]
-    fn map_field_to_json() {
-        let f = Field::new(
-            "my_map",
-            DataType::Map(
-                Box::new(Field::new(
-                    "my_entries",
-                    DataType::Struct(vec![
-                        Field::new("my_keys", DataType::Utf8, false),
-                        Field::new("my_values", DataType::UInt16, true),
-                    ]),
-                    false,
-                )),
-                true,
-            ),
-            false,
-        );
-        let value: Value = serde_json::from_str(
-            r#"{
-                "name": "my_map",
-                "nullable": false,
-                "type": {
-                    "name": "map",
-                    "keysSorted": true
-                },
-                "children": [
-                    {
-                        "name": "my_entries",
-                        "nullable": false,
-                        "type": {
-                            "name": "struct"
-                        },
-                        "children": [
-                            {
-                                "name": "my_keys",
-                                "nullable": false,
-                                "type": {
-                                    "name": "utf8"
-                                },
-                                "children": []
-                            },
-                            {
-                                "name": "my_values",
-                                "nullable": true,
-                                "type": {
-                                    "name": "int",
-                                    "bitWidth": 16,
-                                    "isSigned": false
-                                },
-                                "children": []
-                            }
-                        ]
-                    }
-                ]
-            }"#,
-        )
-        .unwrap();
-        assert_eq!(value, f.to_json());
-    }
-
-    #[test]
-    fn primitive_field_to_json() {
-        let f = Field::new("first_name", DataType::Utf8, false);
-        let value: Value = serde_json::from_str(
-            r#"{
-                "name": "first_name",
-                "nullable": false,
-                "type": {
-                    "name": "utf8"
-                },
-                "children": []
-            }"#,
-        )
-        .unwrap();
-        assert_eq!(value, f.to_json());
-    }
-    #[test]
-    fn parse_struct_from_json() {
-        let json = r#"
-        {
-            "name": "address",
-            "type": {
-                "name": "struct"
-            },
-            "nullable": false,
-            "children": [
-                {
-                    "name": "street",
-                    "type": {
-                    "name": "utf8"
-                    },
-                    "nullable": false,
-                    "children": []
-                },
-                {
-                    "name": "zip",
-                    "type": {
-                    "name": "int",
-                    "isSigned": false,
-                    "bitWidth": 16
-                    },
-                    "nullable": false,
-                    "children": []
-                }
-            ]
-        }
-        "#;
-        let value: Value = serde_json::from_str(json).unwrap();
-        let dt = Field::from(&value).unwrap();
-
-        let expected = Field::new(
-            "address",
-            DataType::Struct(vec![
-                Field::new("street", DataType::Utf8, false),
-                Field::new("zip", DataType::UInt16, false),
-            ]),
-            false,
-        );
-
-        assert_eq!(expected, dt);
-    }
-
-    #[test]
-    fn parse_map_from_json() {
-        let json = r#"
-        {
-            "name": "my_map",
-            "nullable": false,
-            "type": {
-                "name": "map",
-                "keysSorted": true
-            },
-            "children": [
-                {
-                    "name": "my_entries",
-                    "nullable": false,
-                    "type": {
-                        "name": "struct"
-                    },
-                    "children": [
-                        {
-                            "name": "my_keys",
-                            "nullable": false,
-                            "type": {
-                                "name": "utf8"
-                            },
-                            "children": []
-                        },
-                        {
-                            "name": "my_values",
-                            "nullable": true,
-                            "type": {
-                                "name": "int",
-                                "bitWidth": 16,
-                                "isSigned": false
-                            },
-                            "children": []
-                        }
-                    ]
-                }
-            ]
-        }
-        "#;
-        let value: Value = serde_json::from_str(json).unwrap();
-        let dt = Field::from(&value).unwrap();
-
-        let expected = Field::new(
-            "my_map",
-            DataType::Map(
-                Box::new(Field::new(
-                    "my_entries",
-                    DataType::Struct(vec![
-                        Field::new("my_keys", DataType::Utf8, false),
-                        Field::new("my_values", DataType::UInt16, true),
-                    ]),
-                    false,
-                )),
-                true,
-            ),
-            false,
-        );
-
-        assert_eq!(expected, dt);
-    }
-
-    #[test]
-    fn parse_union_from_json() {
-        let json = r#"
-        {
-            "name": "my_union",
-            "nullable": false,
-            "type": {
-                "name": "union",
-                "mode": "SPARSE",
-                "typeIds": [
-                    5,
-                    7
-                ]
-            },
-            "children": [
-                {
-                    "name": "f1",
-                    "type": {
-                        "name": "int",
-                        "isSigned": true,
-                        "bitWidth": 32
-                    },
-                    "nullable": true,
-                    "children": []
-                },
-                {
-                    "name": "f2",
-                    "type": {
-                        "name": "utf8"
-                    },
-                    "nullable": true,
-                    "children": []
-                }
-            ]
-        }
-        "#;
-        let value: Value = serde_json::from_str(json).unwrap();
-        let dt = Field::from(&value).unwrap();
-
-        let expected = Field::new(
-            "my_union",
-            DataType::Union(
-                vec![
-                    Field::new("f1", DataType::Int32, true),
-                    Field::new("f2", DataType::Utf8, true),
-                ],
-                vec![5, 7],
-                UnionMode::Sparse,
-            ),
-            false,
-        );
-
-        assert_eq!(expected, dt);
-    }
-
-    #[test]
-    fn parse_utf8_from_json() {
-        let json = "{\"name\":\"utf8\"}";
-        let value: Value = serde_json::from_str(json).unwrap();
-        let dt = DataType::from(&value).unwrap();
-        assert_eq!(DataType::Utf8, dt);
-    }
-
-    #[test]
-    fn parse_int32_from_json() {
-        let json = "{\"name\": \"int\", \"isSigned\": true, \"bitWidth\": 32}";
-        let value: Value = serde_json::from_str(json).unwrap();
-        let dt = DataType::from(&value).unwrap();
-        assert_eq!(DataType::Int32, dt);
-    }
-
-    #[test]
-    fn schema_json() {
-        // Add some custom metadata
-        let metadata: HashMap<String, String> =
-            [("Key".to_string(), "Value".to_string())]
-                .iter()
-                .cloned()
-                .collect();
-
-        let schema = Schema::new_with_metadata(
-            vec![
-                Field::new("c1", DataType::Utf8, false),
-                Field::new("c2", DataType::Binary, false),
-                Field::new("c3", DataType::FixedSizeBinary(3), false),
-                Field::new("c4", DataType::Boolean, false),
-                Field::new("c5", DataType::Date32, false),
-                Field::new("c6", DataType::Date64, false),
-                Field::new("c7", DataType::Time32(TimeUnit::Second), false),
-                Field::new("c8", DataType::Time32(TimeUnit::Millisecond), false),
-                Field::new("c9", DataType::Time32(TimeUnit::Microsecond), false),
-                Field::new("c10", DataType::Time32(TimeUnit::Nanosecond), false),
-                Field::new("c11", DataType::Time64(TimeUnit::Second), false),
-                Field::new("c12", DataType::Time64(TimeUnit::Millisecond), false),
-                Field::new("c13", DataType::Time64(TimeUnit::Microsecond), false),
-                Field::new("c14", DataType::Time64(TimeUnit::Nanosecond), false),
-                Field::new("c15", DataType::Timestamp(TimeUnit::Second, None), false),
-                Field::new(
-                    "c16",
-                    DataType::Timestamp(TimeUnit::Millisecond, Some("UTC".to_string())),
-                    false,
-                ),
-                Field::new(
-                    "c17",
-                    DataType::Timestamp(
-                        TimeUnit::Microsecond,
-                        Some("Africa/Johannesburg".to_string()),
-                    ),
-                    false,
-                ),
-                Field::new(
-                    "c18",
-                    DataType::Timestamp(TimeUnit::Nanosecond, None),
-                    false,
-                ),
-                Field::new("c19", DataType::Interval(IntervalUnit::DayTime), false),
-                Field::new("c20", DataType::Interval(IntervalUnit::YearMonth), false),
-                Field::new("c21", DataType::Interval(IntervalUnit::MonthDayNano), false),
-                Field::new(
-                    "c22",
-                    DataType::List(Box::new(Field::new("item", DataType::Boolean, true))),
-                    false,
-                ),
-                Field::new(
-                    "c23",
-                    DataType::FixedSizeList(
-                        Box::new(Field::new("bools", DataType::Boolean, false)),
-                        5,
-                    ),
-                    false,
-                ),
-                Field::new(
-                    "c24",
-                    DataType::List(Box::new(Field::new(
-                        "inner_list",
-                        DataType::List(Box::new(Field::new(
-                            "struct",
-                            DataType::Struct(vec![]),
-                            true,
-                        ))),
-                        false,
-                    ))),
-                    true,
-                ),
-                Field::new(
-                    "c25",
-                    DataType::Struct(vec![
-                        Field::new("a", DataType::Utf8, false),
-                        Field::new("b", DataType::UInt16, false),
-                    ]),
-                    false,
-                ),
-                Field::new("c26", DataType::Interval(IntervalUnit::YearMonth), true),
-                Field::new("c27", DataType::Interval(IntervalUnit::DayTime), true),
-                Field::new("c28", DataType::Interval(IntervalUnit::MonthDayNano), true),
-                Field::new("c29", DataType::Duration(TimeUnit::Second), false),
-                Field::new("c30", DataType::Duration(TimeUnit::Millisecond), false),
-                Field::new("c31", DataType::Duration(TimeUnit::Microsecond), false),
-                Field::new("c32", DataType::Duration(TimeUnit::Nanosecond), false),
-                Field::new_dict(
-                    "c33",
-                    DataType::Dictionary(
-                        Box::new(DataType::Int32),
-                        Box::new(DataType::Utf8),
-                    ),
-                    true,
-                    123,
-                    true,
-                ),
-                Field::new("c34", DataType::LargeBinary, true),
-                Field::new("c35", DataType::LargeUtf8, true),
-                Field::new(
-                    "c36",
-                    DataType::LargeList(Box::new(Field::new(
-                        "inner_large_list",
-                        DataType::LargeList(Box::new(Field::new(
-                            "struct",
-                            DataType::Struct(vec![]),
-                            false,
-                        ))),
-                        true,
-                    ))),
-                    true,
-                ),
-                Field::new(
-                    "c37",
-                    DataType::Map(
-                        Box::new(Field::new(
-                            "my_entries",
-                            DataType::Struct(vec![
-                                Field::new("my_keys", DataType::Utf8, false),
-                                Field::new("my_values", DataType::UInt16, true),
-                            ]),
-                            false,
-                        )),
-                        true,
-                    ),
-                    false,
-                ),
-            ],
-            metadata,
-        );
-
-        let expected = schema.to_json();
-        let json = r#"{
-                "fields": [
-                    {
-                        "name": "c1",
-                        "nullable": false,
-                        "type": {
-                            "name": "utf8"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c2",
-                        "nullable": false,
-                        "type": {
-                            "name": "binary"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c3",
-                        "nullable": false,
-                        "type": {
-                            "name": "fixedsizebinary",
-                            "byteWidth": 3
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c4",
-                        "nullable": false,
-                        "type": {
-                            "name": "bool"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c5",
-                        "nullable": false,
-                        "type": {
-                            "name": "date",
-                            "unit": "DAY"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c6",
-                        "nullable": false,
-                        "type": {
-                            "name": "date",
-                            "unit": "MILLISECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c7",
-                        "nullable": false,
-                        "type": {
-                            "name": "time",
-                            "bitWidth": 32,
-                            "unit": "SECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c8",
-                        "nullable": false,
-                        "type": {
-                            "name": "time",
-                            "bitWidth": 32,
-                            "unit": "MILLISECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c9",
-                        "nullable": false,
-                        "type": {
-                            "name": "time",
-                            "bitWidth": 32,
-                            "unit": "MICROSECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c10",
-                        "nullable": false,
-                        "type": {
-                            "name": "time",
-                            "bitWidth": 32,
-                            "unit": "NANOSECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c11",
-                        "nullable": false,
-                        "type": {
-                            "name": "time",
-                            "bitWidth": 64,
-                            "unit": "SECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c12",
-                        "nullable": false,
-                        "type": {
-                            "name": "time",
-                            "bitWidth": 64,
-                            "unit": "MILLISECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c13",
-                        "nullable": false,
-                        "type": {
-                            "name": "time",
-                            "bitWidth": 64,
-                            "unit": "MICROSECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c14",
-                        "nullable": false,
-                        "type": {
-                            "name": "time",
-                            "bitWidth": 64,
-                            "unit": "NANOSECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c15",
-                        "nullable": false,
-                        "type": {
-                            "name": "timestamp",
-                            "unit": "SECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c16",
-                        "nullable": false,
-                        "type": {
-                            "name": "timestamp",
-                            "unit": "MILLISECOND",
-                            "timezone": "UTC"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c17",
-                        "nullable": false,
-                        "type": {
-                            "name": "timestamp",
-                            "unit": "MICROSECOND",
-                            "timezone": "Africa/Johannesburg"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c18",
-                        "nullable": false,
-                        "type": {
-                            "name": "timestamp",
-                            "unit": "NANOSECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c19",
-                        "nullable": false,
-                        "type": {
-                            "name": "interval",
-                            "unit": "DAY_TIME"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c20",
-                        "nullable": false,
-                        "type": {
-                            "name": "interval",
-                            "unit": "YEAR_MONTH"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c21",
-                        "nullable": false,
-                        "type": {
-                            "name": "interval",
-                            "unit": "MONTH_DAY_NANO"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c22",
-                        "nullable": false,
-                        "type": {
-                            "name": "list"
-                        },
-                        "children": [
-                            {
-                                "name": "item",
-                                "nullable": true,
-                                "type": {
-                                    "name": "bool"
-                                },
-                                "children": []
-                            }
-                        ]
-                    },
-                    {
-                        "name": "c23",
-                        "nullable": false,
-                        "type": {
-                            "name": "fixedsizelist",
-                            "listSize": 5
-                        },
-                        "children": [
-                            {
-                                "name": "bools",
-                                "nullable": false,
-                                "type": {
-                                    "name": "bool"
-                                },
-                                "children": []
-                            }
-                        ]
-                    },
-                    {
-                        "name": "c24",
-                        "nullable": true,
-                        "type": {
-                            "name": "list"
-                        },
-                        "children": [
-                            {
-                                "name": "inner_list",
-                                "nullable": false,
-                                "type": {
-                                    "name": "list"
-                                },
-                                "children": [
-                                    {
-                                        "name": "struct",
-                                        "nullable": true,
-                                        "type": {
-                                            "name": "struct"
-                                        },
-                                        "children": []
-                                    }
-                                ]
-                            }
-                        ]
-                    },
-                    {
-                        "name": "c25",
-                        "nullable": false,
-                        "type": {
-                            "name": "struct"
-                        },
-                        "children": [
-                            {
-                                "name": "a",
-                                "nullable": false,
-                                "type": {
-                                    "name": "utf8"
-                                },
-                                "children": []
-                            },
-                            {
-                                "name": "b",
-                                "nullable": false,
-                                "type": {
-                                    "name": "int",
-                                    "bitWidth": 16,
-                                    "isSigned": false
-                                },
-                                "children": []
-                            }
-                        ]
-                    },
-                    {
-                        "name": "c26",
-                        "nullable": true,
-                        "type": {
-                            "name": "interval",
-                            "unit": "YEAR_MONTH"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c27",
-                        "nullable": true,
-                        "type": {
-                            "name": "interval",
-                            "unit": "DAY_TIME"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c28",
-                        "nullable": true,
-                        "type": {
-                            "name": "interval",
-                            "unit": "MONTH_DAY_NANO"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c29",
-                        "nullable": false,
-                        "type": {
-                            "name": "duration",
-                            "unit": "SECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c30",
-                        "nullable": false,
-                        "type": {
-                            "name": "duration",
-                            "unit": "MILLISECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c31",
-                        "nullable": false,
-                        "type": {
-                            "name": "duration",
-                            "unit": "MICROSECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c32",
-                        "nullable": false,
-                        "type": {
-                            "name": "duration",
-                            "unit": "NANOSECOND"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c33",
-                        "nullable": true,
-                        "children": [],
-                        "type": {
-                          "name": "utf8"
-                        },
-                        "dictionary": {
-                          "id": 123,
-                          "indexType": {
-                            "name": "int",
-                            "bitWidth": 32,
-                            "isSigned": true
-                          },
-                          "isOrdered": true
-                        }
-                    },
-                    {
-                        "name": "c34",
-                        "nullable": true,
-                        "type": {
-                          "name": "largebinary"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c35",
-                        "nullable": true,
-                        "type": {
-                          "name": "largeutf8"
-                        },
-                        "children": []
-                    },
-                    {
-                        "name": "c36",
-                        "nullable": true,
-                        "type": {
-                          "name": "largelist"
-                        },
-                        "children": [
-                            {
-                                "name": "inner_large_list",
-                                "nullable": true,
-                                "type": {
-                                    "name": "largelist"
-                                },
-                                "children": [
-                                    {
-                                        "name": "struct",
-                                        "nullable": false,
-                                        "type": {
-                                            "name": "struct"
-                                        },
-                                        "children": []
-                                    }
-                                ]
-                            }
-                        ]
-                    },
-                    {
-                        "name": "c37",
-                        "nullable": false,
-                        "type": {
-                            "name": "map",
-                            "keysSorted": true
-                        },
-                        "children": [
-                            {
-                                "name": "my_entries",
-                                "nullable": false,
-                                "type": {
-                                    "name": "struct"
-                                },
-                                "children": [
-                                    {
-                                        "name": "my_keys",
-                                        "nullable": false,
-                                        "type": {
-                                            "name": "utf8"
-                                        },
-                                        "children": []
-                                    },
-                                    {
-                                        "name": "my_values",
-                                        "nullable": true,
-                                        "type": {
-                                            "name": "int",
-                                            "bitWidth": 16,
-                                            "isSigned": false
-                                        },
-                                        "children": []
-                                    }
-                                ]
-                            }
-                        ]
-                    }
-                ],
-                "metadata" : {
-                    "Key": "Value"
-                }
-            }"#;
-        let value: Value = serde_json::from_str(json).unwrap();
-        assert_eq!(expected, value);
-
-        // convert back to a schema
-        let value: Value = serde_json::from_str(json).unwrap();
-        let schema2 = Schema::from(&value).unwrap();
-
-        assert_eq!(schema, schema2);
-
-        // Check that empty metadata produces empty value in JSON and can be parsed
-        let json = r#"{
-                "fields": [
-                    {
-                        "name": "c1",
-                        "nullable": false,
-                        "type": {
-                            "name": "utf8"
-                        },
-                        "children": []
-                    }
-                ],
-                "metadata": {}
-            }"#;
-        let value: Value = serde_json::from_str(json).unwrap();
-        let schema = Schema::from(&value).unwrap();
-        assert!(schema.metadata.is_empty());
-
-        // Check that metadata field is not required in the JSON.
-        let json = r#"{
-                "fields": [
-                    {
-                        "name": "c1",
-                        "nullable": false,
-                        "type": {
-                            "name": "utf8"
-                        },
-                        "children": []
-                    }
-                ]
-            }"#;
-        let value: Value = serde_json::from_str(json).unwrap();
-        let schema = Schema::from(&value).unwrap();
-        assert!(schema.metadata.is_empty());
-    }
-
-    #[test]
-    fn create_schema_string() {
-        let schema = person_schema();
-        assert_eq!(schema.to_string(),
-        "Field { name: \"first_name\", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: Some({\"k\": \"v\"}) }, \
-        Field { name: \"last_name\", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: None }, \
-        Field { name: \"address\", data_type: Struct([\
-            Field { name: \"street\", data_type: Utf8, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: None }, \
-            Field { name: \"zip\", data_type: UInt16, nullable: false, dict_id: 0, dict_is_ordered: false, metadata: None }\
-        ]), nullable: false, dict_id: 0, dict_is_ordered: false, metadata: None }, \
-        Field { name: \"interests\", data_type: Dictionary(Int32, Utf8), nullable: true, dict_id: 123, dict_is_ordered: true, metadata: None }")
-    }
-
-    #[test]
-    fn schema_field_accessors() {
-        let schema = person_schema();
-
-        // test schema accessors
-        assert_eq!(schema.fields().len(), 4);
-
-        // test field accessors
-        let first_name = &schema.fields()[0];
-        assert_eq!(first_name.name(), "first_name");
-        assert_eq!(first_name.data_type(), &DataType::Utf8);
-        assert!(!first_name.is_nullable());
-        assert_eq!(first_name.dict_id(), None);
-        assert_eq!(first_name.dict_is_ordered(), None);
-
-        let metadata = first_name.metadata();
-        assert!(metadata.is_some());
-        let md = metadata.as_ref().unwrap();
-        assert_eq!(md.len(), 1);
-        let key = md.get("k");
-        assert!(key.is_some());
-        assert_eq!(key.unwrap(), "v");
-
-        let interests = &schema.fields()[3];
-        assert_eq!(interests.name(), "interests");
-        assert_eq!(
-            interests.data_type(),
-            &DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8))
-        );
-        assert_eq!(interests.dict_id(), Some(123));
-        assert_eq!(interests.dict_is_ordered(), Some(true));
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Unable to get field named \\\"nickname\\\". Valid fields: [\\\"first_name\\\", \\\"last_name\\\", \\\"address\\\", \\\"interests\\\"]"
-    )]
-    fn schema_index_of() {
-        let schema = person_schema();
-        assert_eq!(schema.index_of("first_name").unwrap(), 0);
-        assert_eq!(schema.index_of("last_name").unwrap(), 1);
-        schema.index_of("nickname").unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Unable to get field named \\\"nickname\\\". Valid fields: [\\\"first_name\\\", \\\"last_name\\\", \\\"address\\\", \\\"interests\\\"]"
-    )]
-    fn schema_field_with_name() {
-        let schema = person_schema();
-        assert_eq!(
-            schema.field_with_name("first_name").unwrap().name(),
-            "first_name"
-        );
-        assert_eq!(
-            schema.field_with_name("last_name").unwrap().name(),
-            "last_name"
-        );
-        schema.field_with_name("nickname").unwrap();
-    }
-
-    #[test]
-    fn schema_field_with_dict_id() {
-        let schema = person_schema();
-
-        let fields_dict_123: Vec<_> = schema
-            .fields_with_dict_id(123)
-            .iter()
-            .map(|f| f.name())
-            .collect();
-        assert_eq!(fields_dict_123, vec!["interests"]);
-
-        assert!(schema.fields_with_dict_id(456).is_empty());
-    }
-
-    #[test]
-    fn schema_equality() {
-        let schema1 = Schema::new(vec![
-            Field::new("c1", DataType::Utf8, false),
-            Field::new("c2", DataType::Float64, true),
-            Field::new("c3", DataType::LargeBinary, true),
-        ]);
-        let schema2 = Schema::new(vec![
-            Field::new("c1", DataType::Utf8, false),
-            Field::new("c2", DataType::Float64, true),
-            Field::new("c3", DataType::LargeBinary, true),
-        ]);
-
-        assert_eq!(schema1, schema2);
-
-        let schema3 = Schema::new(vec![
-            Field::new("c1", DataType::Utf8, false),
-            Field::new("c2", DataType::Float32, true),
-        ]);
-        let schema4 = Schema::new(vec![
-            Field::new("C1", DataType::Utf8, false),
-            Field::new("C2", DataType::Float64, true),
-        ]);
-
-        assert!(schema1 != schema3);
-        assert!(schema1 != schema4);
-        assert!(schema2 != schema3);
-        assert!(schema2 != schema4);
-        assert!(schema3 != schema4);
-
-        let f = Field::new("c1", DataType::Utf8, false).with_metadata(Some(
-            [("foo".to_string(), "bar".to_string())]
-                .iter()
-                .cloned()
-                .collect(),
-        ));
-        let schema5 = Schema::new(vec![
-            f,
-            Field::new("c2", DataType::Float64, true),
-            Field::new("c3", DataType::LargeBinary, true),
-        ]);
-        assert!(schema1 != schema5);
-    }
-
-    #[test]
-    fn test_arrow_native_type_to_json() {
-        assert_eq!(Some(Bool(true)), true.into_json_value());
-        assert_eq!(Some(VNumber(Number::from(1))), 1i8.into_json_value());
-        assert_eq!(Some(VNumber(Number::from(1))), 1i16.into_json_value());
-        assert_eq!(Some(VNumber(Number::from(1))), 1i32.into_json_value());
-        assert_eq!(Some(VNumber(Number::from(1))), 1i64.into_json_value());
-        assert_eq!(Some(VString("1".to_string())), 1i128.into_json_value());
-        assert_eq!(Some(VNumber(Number::from(1))), 1u8.into_json_value());
-        assert_eq!(Some(VNumber(Number::from(1))), 1u16.into_json_value());
-        assert_eq!(Some(VNumber(Number::from(1))), 1u32.into_json_value());
-        assert_eq!(Some(VNumber(Number::from(1))), 1u64.into_json_value());
-        assert_eq!(
-            Some(VNumber(Number::from_f64(0.01f64).unwrap())),
-            0.01.into_json_value()
-        );
-        assert_eq!(
-            Some(VNumber(Number::from_f64(0.01f64).unwrap())),
-            0.01f64.into_json_value()
-        );
-        assert_eq!(None, NAN.into_json_value());
-    }
-
-    fn person_schema() -> Schema {
-        let kv_array = [("k".to_string(), "v".to_string())];
-        let field_metadata: BTreeMap<String, String> = kv_array.iter().cloned().collect();
-        let first_name = Field::new("first_name", DataType::Utf8, false)
-            .with_metadata(Some(field_metadata));
-
-        Schema::new(vec![
-            first_name,
-            Field::new("last_name", DataType::Utf8, false),
-            Field::new(
-                "address",
-                DataType::Struct(vec![
-                    Field::new("street", DataType::Utf8, false),
-                    Field::new("zip", DataType::UInt16, false),
-                ]),
-                false,
-            ),
-            Field::new_dict(
-                "interests",
-                DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
-                true,
-                123,
-                true,
-            ),
-        ])
-    }
-
-    #[test]
-    fn test_try_merge_field_with_metadata() {
-        // 1. Different values for the same key should cause error.
-        let metadata1: BTreeMap<String, String> =
-            [("foo".to_string(), "bar".to_string())]
-                .iter()
-                .cloned()
-                .collect();
-        let f1 = Field::new("first_name", DataType::Utf8, false)
-            .with_metadata(Some(metadata1));
-
-        let metadata2: BTreeMap<String, String> =
-            [("foo".to_string(), "baz".to_string())]
-                .iter()
-                .cloned()
-                .collect();
-        let f2 = Field::new("first_name", DataType::Utf8, false)
-            .with_metadata(Some(metadata2));
-
-        assert!(
-            Schema::try_merge(vec![Schema::new(vec![f1]), Schema::new(vec![f2])])
-                .is_err()
-        );
-
-        // 2. None + Some
-        let mut f1 = Field::new("first_name", DataType::Utf8, false);
-        let metadata2: BTreeMap<String, String> =
-            [("missing".to_string(), "value".to_string())]
-                .iter()
-                .cloned()
-                .collect();
-        let f2 = Field::new("first_name", DataType::Utf8, false)
-            .with_metadata(Some(metadata2));
-
-        assert!(f1.try_merge(&f2).is_ok());
-        assert!(f1.metadata().is_some());
-        assert_eq!(
-            f1.metadata().as_ref().unwrap(),
-            f2.metadata().as_ref().unwrap()
-        );
-
-        // 3. Some + Some
-        let mut f1 = Field::new("first_name", DataType::Utf8, false).with_metadata(Some(
-            [("foo".to_string(), "bar".to_string())]
-                .iter()
-                .cloned()
-                .collect(),
-        ));
-        let f2 = Field::new("first_name", DataType::Utf8, false).with_metadata(Some(
-            [("foo2".to_string(), "bar2".to_string())]
-                .iter()
-                .cloned()
-                .collect(),
-        ));
-
-        assert!(f1.try_merge(&f2).is_ok());
-        assert!(f1.metadata().is_some());
-        assert_eq!(
-            f1.metadata().cloned().unwrap(),
-            [
-                ("foo".to_string(), "bar".to_string()),
-                ("foo2".to_string(), "bar2".to_string())
-            ]
-            .iter()
-            .cloned()
-            .collect()
-        );
-
-        // 4. Some + None.
-        let mut f1 = Field::new("first_name", DataType::Utf8, false).with_metadata(Some(
-            [("foo".to_string(), "bar".to_string())]
-                .iter()
-                .cloned()
-                .collect(),
-        ));
-        let f2 = Field::new("first_name", DataType::Utf8, false);
-        assert!(f1.try_merge(&f2).is_ok());
-        assert!(f1.metadata().is_some());
-        assert_eq!(
-            f1.metadata().cloned().unwrap(),
-            [("foo".to_string(), "bar".to_string())]
-                .iter()
-                .cloned()
-                .collect()
-        );
-
-        // 5. None + None.
-        let mut f1 = Field::new("first_name", DataType::Utf8, false);
-        let f2 = Field::new("first_name", DataType::Utf8, false);
-        assert!(f1.try_merge(&f2).is_ok());
-        assert!(f1.metadata().is_none());
-    }
-
-    #[test]
-    fn test_schema_merge() -> Result<()> {
-        let merged = Schema::try_merge(vec![
-            Schema::new(vec![
-                Field::new("first_name", DataType::Utf8, false),
-                Field::new("last_name", DataType::Utf8, false),
-                Field::new(
-                    "address",
-                    DataType::Struct(vec![Field::new("zip", DataType::UInt16, false)]),
-                    false,
-                ),
-            ]),
-            Schema::new_with_metadata(
-                vec![
-                    // nullable merge
-                    Field::new("last_name", DataType::Utf8, true),
-                    Field::new(
-                        "address",
-                        DataType::Struct(vec![
-                            // add new nested field
-                            Field::new("street", DataType::Utf8, false),
-                            // nullable merge on nested field
-                            Field::new("zip", DataType::UInt16, true),
-                        ]),
-                        false,
-                    ),
-                    // new field
-                    Field::new("number", DataType::Utf8, true),
-                ],
-                [("foo".to_string(), "bar".to_string())]
-                    .iter()
-                    .cloned()
-                    .collect::<HashMap<String, String>>(),
-            ),
-        ])?;
-
-        assert_eq!(
-            merged,
-            Schema::new_with_metadata(
-                vec![
-                    Field::new("first_name", DataType::Utf8, false),
-                    Field::new("last_name", DataType::Utf8, true),
-                    Field::new(
-                        "address",
-                        DataType::Struct(vec![
-                            Field::new("zip", DataType::UInt16, true),
-                            Field::new("street", DataType::Utf8, false),
-                        ]),
-                        false,
-                    ),
-                    Field::new("number", DataType::Utf8, true),
-                ],
-                [("foo".to_string(), "bar".to_string())]
-                    .iter()
-                    .cloned()
-                    .collect::<HashMap<String, String>>()
-            )
-        );
-
-        // support merge union fields
-        assert_eq!(
-            Schema::try_merge(vec![
-                Schema::new(vec![Field::new(
-                    "c1",
-                    DataType::Union(
-                        vec![
-                            Field::new("c11", DataType::Utf8, true),
-                            Field::new("c12", DataType::Utf8, true),
-                        ],
-                        vec![0, 1],
-                        UnionMode::Dense
-                    ),
-                    false
-                ),]),
-                Schema::new(vec![Field::new(
-                    "c1",
-                    DataType::Union(
-                        vec![
-                            Field::new("c12", DataType::Utf8, true),
-                            Field::new("c13", DataType::Time64(TimeUnit::Second), true),
-                        ],
-                        vec![1, 2],
-                        UnionMode::Dense
-                    ),
-                    false
-                ),])
-            ])?,
-            Schema::new(vec![Field::new(
-                "c1",
-                DataType::Union(
-                    vec![
-                        Field::new("c11", DataType::Utf8, true),
-                        Field::new("c12", DataType::Utf8, true),
-                        Field::new("c13", DataType::Time64(TimeUnit::Second), true),
-                    ],
-                    vec![0, 1, 2],
-                    UnionMode::Dense
-                ),
-                false
-            ),]),
-        );
-
-        // incompatible field should throw error
-        assert!(Schema::try_merge(vec![
-            Schema::new(vec![
-                Field::new("first_name", DataType::Utf8, false),
-                Field::new("last_name", DataType::Utf8, false),
-            ]),
-            Schema::new(vec![Field::new("last_name", DataType::Int64, false),])
-        ])
-        .is_err());
-
-        // incompatible metadata should throw error
-        let res = Schema::try_merge(vec![
-            Schema::new_with_metadata(
-                vec![Field::new("first_name", DataType::Utf8, false)],
-                [("foo".to_string(), "bar".to_string())]
-                    .iter()
-                    .cloned()
-                    .collect::<HashMap<String, String>>(),
-            ),
-            Schema::new_with_metadata(
-                vec![Field::new("last_name", DataType::Utf8, false)],
-                [("foo".to_string(), "baz".to_string())]
-                    .iter()
-                    .cloned()
-                    .collect::<HashMap<String, String>>(),
-            ),
-        ])
-        .unwrap_err();
-
-        let expected = "Fail to merge schema due to conflicting metadata. Key 'foo' has different values 'bar' and 'baz'";
-        assert!(
-            res.to_string().contains(expected),
-            "Could not find expected string '{}' in '{}'",
-            expected,
-            res
-        );
-
-        Ok(())
-    }
-}
+//!  * [`Schema`] to describe a schema.
+//!  * [`Field`] to describe one field within a schema.
+//!  * [`DataType`] to describe the type of a field.
+
+pub use arrow_array::types::*;
+pub use arrow_array::{ArrowNativeTypeOp, ArrowNumericType, ArrowPrimitiveType};
+pub use arrow_buffer::{i256, ArrowNativeType, ToByteSlice};
+pub use arrow_data::decimal::*;
+pub use arrow_schema::{
+    DataType, Field, FieldRef, Fields, IntervalUnit, Schema, SchemaBuilder, SchemaRef, TimeUnit,
+    UnionFields, UnionMode,
+};
diff --git a/arrow/src/datatypes/native.rs b/arrow/src/datatypes/native.rs
deleted file mode 100644
index d9a3f667d8e4..000000000000
--- a/arrow/src/datatypes/native.rs
+++ /dev/null
@@ -1,414 +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.
-
-use super::DataType;
-use half::f16;
-use serde_json::{Number, Value};
-
-mod private {
-    pub trait Sealed {}
-}
-
-/// Trait declaring any type that is serializable to JSON. This includes all primitive types (bool, i32, etc.).
-pub trait JsonSerializable: 'static {
-    fn into_json_value(self) -> Option<Value>;
-}
-
-/// Trait expressing a Rust type that has the same in-memory representation
-/// as Arrow. This includes `i16`, `f32`, but excludes `bool` (which in arrow is represented in bits).
-///
-/// In little endian machines, types that implement [`ArrowNativeType`] can be memcopied to arrow buffers
-/// as is.
-///
-/// # Transmute Safety
-///
-/// A type T implementing this trait means that any arbitrary slice of bytes of length and
-/// alignment `size_of::<T>()` can be safely interpreted as a value of that type without
-/// being unsound, i.e. potentially resulting in undefined behaviour.
-///
-/// Note: in the case of floating point numbers this transmutation can result in a signalling
-/// NaN, which, whilst sound, can be unwieldy. In general, whilst it is perfectly sound to
-/// reinterpret bytes as different types using this trait, it is likely unwise. For more information
-/// see [f32::from_bits] and [f64::from_bits].
-///
-/// Note: `bool` is restricted to `0` or `1`, and so `bool: !ArrowNativeType`
-///
-/// # Sealed
-///
-/// Due to the above restrictions, this trait is sealed to prevent accidental misuse
-pub trait ArrowNativeType:
-    std::fmt::Debug
-    + Send
-    + Sync
-    + Copy
-    + PartialOrd
-    + std::str::FromStr
-    + Default
-    + JsonSerializable
-    + private::Sealed
-{
-    /// Convert native type from usize.
-    #[inline]
-    fn from_usize(_: usize) -> Option<Self> {
-        None
-    }
-
-    /// Convert native type to usize.
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        None
-    }
-
-    /// Convert native type to isize.
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        None
-    }
-
-    /// Convert native type from i32.
-    #[inline]
-    fn from_i32(_: i32) -> Option<Self> {
-        None
-    }
-
-    /// Convert native type from i64.
-    #[inline]
-    fn from_i64(_: i64) -> Option<Self> {
-        None
-    }
-
-    /// Convert native type from i128.
-    #[inline]
-    fn from_i128(_: i128) -> Option<Self> {
-        None
-    }
-}
-
-/// Trait bridging the dynamic-typed nature of Arrow (via [`DataType`]) with the
-/// static-typed nature of rust types ([`ArrowNativeType`]) for all types that implement [`ArrowNativeType`].
-pub trait ArrowPrimitiveType: 'static {
-    /// Corresponding Rust native type for the primitive type.
-    type Native: ArrowNativeType;
-
-    /// the corresponding Arrow data type of this primitive type.
-    const DATA_TYPE: DataType;
-
-    /// Returns the byte width of this primitive type.
-    fn get_byte_width() -> usize {
-        std::mem::size_of::<Self::Native>()
-    }
-
-    /// Returns a default value of this primitive type.
-    ///
-    /// This is useful for aggregate array ops like `sum()`, `mean()`.
-    fn default_value() -> Self::Native {
-        Default::default()
-    }
-}
-
-impl JsonSerializable for bool {
-    fn into_json_value(self) -> Option<Value> {
-        Some(self.into())
-    }
-}
-
-impl JsonSerializable for i8 {
-    fn into_json_value(self) -> Option<Value> {
-        Some(self.into())
-    }
-}
-
-impl private::Sealed for i8 {}
-impl ArrowNativeType for i8 {
-    #[inline]
-    fn from_usize(v: usize) -> Option<Self> {
-        num::FromPrimitive::from_usize(v)
-    }
-
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        num::ToPrimitive::to_usize(self)
-    }
-
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        num::ToPrimitive::to_isize(self)
-    }
-}
-
-impl JsonSerializable for i16 {
-    fn into_json_value(self) -> Option<Value> {
-        Some(self.into())
-    }
-}
-
-impl private::Sealed for i16 {}
-impl ArrowNativeType for i16 {
-    #[inline]
-    fn from_usize(v: usize) -> Option<Self> {
-        num::FromPrimitive::from_usize(v)
-    }
-
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        num::ToPrimitive::to_usize(self)
-    }
-
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        num::ToPrimitive::to_isize(self)
-    }
-}
-
-impl JsonSerializable for i32 {
-    fn into_json_value(self) -> Option<Value> {
-        Some(self.into())
-    }
-}
-
-impl private::Sealed for i32 {}
-impl ArrowNativeType for i32 {
-    #[inline]
-    fn from_usize(v: usize) -> Option<Self> {
-        num::FromPrimitive::from_usize(v)
-    }
-
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        num::ToPrimitive::to_usize(self)
-    }
-
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        num::ToPrimitive::to_isize(self)
-    }
-
-    /// Convert native type from i32.
-    #[inline]
-    fn from_i32(val: i32) -> Option<Self> {
-        Some(val)
-    }
-}
-
-impl JsonSerializable for i64 {
-    fn into_json_value(self) -> Option<Value> {
-        Some(Value::Number(Number::from(self)))
-    }
-}
-
-impl private::Sealed for i64 {}
-impl ArrowNativeType for i64 {
-    #[inline]
-    fn from_usize(v: usize) -> Option<Self> {
-        num::FromPrimitive::from_usize(v)
-    }
-
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        num::ToPrimitive::to_usize(self)
-    }
-
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        num::ToPrimitive::to_isize(self)
-    }
-
-    /// Convert native type from i64.
-    #[inline]
-    fn from_i64(val: i64) -> Option<Self> {
-        Some(val)
-    }
-}
-
-impl JsonSerializable for i128 {
-    fn into_json_value(self) -> Option<Value> {
-        // Serialize as string to avoid issues with arbitrary_precision serde_json feature
-        // - https://github.com/serde-rs/json/issues/559
-        // - https://github.com/serde-rs/json/issues/845
-        // - https://github.com/serde-rs/json/issues/846
-        Some(self.to_string().into())
-    }
-}
-
-impl private::Sealed for i128 {}
-impl ArrowNativeType for i128 {
-    #[inline]
-    fn from_usize(v: usize) -> Option<Self> {
-        num::FromPrimitive::from_usize(v)
-    }
-
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        num::ToPrimitive::to_usize(self)
-    }
-
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        num::ToPrimitive::to_isize(self)
-    }
-
-    /// Convert native type from i128.
-    #[inline]
-    fn from_i128(val: i128) -> Option<Self> {
-        Some(val)
-    }
-}
-
-impl JsonSerializable for u8 {
-    fn into_json_value(self) -> Option<Value> {
-        Some(self.into())
-    }
-}
-
-impl private::Sealed for u8 {}
-impl ArrowNativeType for u8 {
-    #[inline]
-    fn from_usize(v: usize) -> Option<Self> {
-        num::FromPrimitive::from_usize(v)
-    }
-
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        num::ToPrimitive::to_usize(self)
-    }
-
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        num::ToPrimitive::to_isize(self)
-    }
-}
-
-impl JsonSerializable for u16 {
-    fn into_json_value(self) -> Option<Value> {
-        Some(self.into())
-    }
-}
-
-impl private::Sealed for u16 {}
-impl ArrowNativeType for u16 {
-    #[inline]
-    fn from_usize(v: usize) -> Option<Self> {
-        num::FromPrimitive::from_usize(v)
-    }
-
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        num::ToPrimitive::to_usize(self)
-    }
-
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        num::ToPrimitive::to_isize(self)
-    }
-}
-
-impl JsonSerializable for u32 {
-    fn into_json_value(self) -> Option<Value> {
-        Some(self.into())
-    }
-}
-
-impl private::Sealed for u32 {}
-impl ArrowNativeType for u32 {
-    #[inline]
-    fn from_usize(v: usize) -> Option<Self> {
-        num::FromPrimitive::from_usize(v)
-    }
-
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        num::ToPrimitive::to_usize(self)
-    }
-
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        num::ToPrimitive::to_isize(self)
-    }
-}
-
-impl JsonSerializable for u64 {
-    fn into_json_value(self) -> Option<Value> {
-        Some(self.into())
-    }
-}
-
-impl private::Sealed for u64 {}
-impl ArrowNativeType for u64 {
-    #[inline]
-    fn from_usize(v: usize) -> Option<Self> {
-        num::FromPrimitive::from_usize(v)
-    }
-
-    #[inline]
-    fn to_usize(&self) -> Option<usize> {
-        num::ToPrimitive::to_usize(self)
-    }
-
-    #[inline]
-    fn to_isize(&self) -> Option<isize> {
-        num::ToPrimitive::to_isize(self)
-    }
-}
-
-impl JsonSerializable for f16 {
-    fn into_json_value(self) -> Option<Value> {
-        Number::from_f64(f64::round(f64::from(self) * 1000.0) / 1000.0).map(Value::Number)
-    }
-}
-
-impl JsonSerializable for f32 {
-    fn into_json_value(self) -> Option<Value> {
-        Number::from_f64(f64::round(self as f64 * 1000.0) / 1000.0).map(Value::Number)
-    }
-}
-
-impl JsonSerializable for f64 {
-    fn into_json_value(self) -> Option<Value> {
-        Number::from_f64(self).map(Value::Number)
-    }
-}
-
-impl ArrowNativeType for f16 {}
-impl private::Sealed for f16 {}
-impl ArrowNativeType for f32 {}
-impl private::Sealed for f32 {}
-impl ArrowNativeType for f64 {}
-impl private::Sealed for f64 {}
-
-/// Allows conversion from supported Arrow types to a byte slice.
-pub trait ToByteSlice {
-    /// Converts this instance into a byte slice
-    fn to_byte_slice(&self) -> &[u8];
-}
-
-impl<T: ArrowNativeType> ToByteSlice for [T] {
-    #[inline]
-    fn to_byte_slice(&self) -> &[u8] {
-        let raw_ptr = self.as_ptr() as *const T as *const u8;
-        unsafe {
-            std::slice::from_raw_parts(raw_ptr, self.len() * std::mem::size_of::<T>())
-        }
-    }
-}
-
-impl<T: ArrowNativeType> ToByteSlice for T {
-    #[inline]
-    fn to_byte_slice(&self) -> &[u8] {
-        let raw_ptr = self as *const T as *const u8;
-        unsafe { std::slice::from_raw_parts(raw_ptr, std::mem::size_of::<T>()) }
-    }
-}
diff --git a/arrow/src/datatypes/numeric.rs b/arrow/src/datatypes/numeric.rs
deleted file mode 100644
index b8fa87197c38..000000000000
--- a/arrow/src/datatypes/numeric.rs
+++ /dev/null
@@ -1,492 +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.
-
-use super::*;
-#[cfg(feature = "simd")]
-use packed_simd::*;
-#[cfg(feature = "simd")]
-use std::ops::{Add, BitAnd, BitAndAssign, BitOr, BitOrAssign, Div, Mul, Not, Rem, Sub};
-
-/// A subtype of primitive type that represents numeric values.
-///
-/// SIMD operations are defined in this trait if available on the target system.
-#[cfg(feature = "simd")]
-pub trait ArrowNumericType: ArrowPrimitiveType
-where
-    Self::Simd: Add<Output = Self::Simd>
-        + Sub<Output = Self::Simd>
-        + Mul<Output = Self::Simd>
-        + Div<Output = Self::Simd>
-        + Rem<Output = Self::Simd>
-        + Copy,
-    Self::SimdMask: BitAnd<Output = Self::SimdMask>
-        + BitOr<Output = Self::SimdMask>
-        + BitAndAssign
-        + BitOrAssign
-        + Not<Output = Self::SimdMask>
-        + Copy,
-{
-    /// Defines the SIMD type that should be used for this numeric type
-    type Simd;
-
-    /// Defines the SIMD Mask type that should be used for this numeric type
-    type SimdMask;
-
-    /// The number of SIMD lanes available
-    fn lanes() -> usize;
-
-    /// Initializes a SIMD register to a constant value
-    fn init(value: Self::Native) -> Self::Simd;
-
-    /// Loads a slice into a SIMD register
-    fn load(slice: &[Self::Native]) -> Self::Simd;
-
-    /// Creates a new SIMD mask for this SIMD type filling it with `value`
-    fn mask_init(value: bool) -> Self::SimdMask;
-
-    /// Creates a new SIMD mask for this SIMD type from the lower-most bits of the given `mask`.
-    /// The number of bits used corresponds to the number of lanes of this type
-    fn mask_from_u64(mask: u64) -> Self::SimdMask;
-
-    /// Creates a bitmask from the given SIMD mask.
-    /// Each bit corresponds to one vector lane, starting with the least-significant bit.
-    fn mask_to_u64(mask: &Self::SimdMask) -> u64;
-
-    /// Gets the value of a single lane in a SIMD mask
-    fn mask_get(mask: &Self::SimdMask, idx: usize) -> bool;
-
-    /// Sets the value of a single lane of a SIMD mask
-    fn mask_set(mask: Self::SimdMask, idx: usize, value: bool) -> Self::SimdMask;
-
-    /// Selects elements of `a` and `b` using `mask`
-    fn mask_select(mask: Self::SimdMask, a: Self::Simd, b: Self::Simd) -> Self::Simd;
-
-    /// Returns `true` if any of the lanes in the mask are `true`
-    fn mask_any(mask: Self::SimdMask) -> bool;
-
-    /// Performs a SIMD binary operation
-    fn bin_op<F: Fn(Self::Simd, Self::Simd) -> Self::Simd>(
-        left: Self::Simd,
-        right: Self::Simd,
-        op: F,
-    ) -> Self::Simd;
-
-    /// SIMD version of equal
-    fn eq(left: Self::Simd, right: Self::Simd) -> Self::SimdMask;
-
-    /// SIMD version of not equal
-    fn ne(left: Self::Simd, right: Self::Simd) -> Self::SimdMask;
-
-    /// SIMD version of less than
-    fn lt(left: Self::Simd, right: Self::Simd) -> Self::SimdMask;
-
-    /// SIMD version of less than or equal to
-    fn le(left: Self::Simd, right: Self::Simd) -> Self::SimdMask;
-
-    /// SIMD version of greater than
-    fn gt(left: Self::Simd, right: Self::Simd) -> Self::SimdMask;
-
-    /// SIMD version of greater than or equal to
-    fn ge(left: Self::Simd, right: Self::Simd) -> Self::SimdMask;
-
-    /// Writes a SIMD result back to a slice
-    fn write(simd_result: Self::Simd, slice: &mut [Self::Native]);
-
-    fn unary_op<F: Fn(Self::Simd) -> Self::Simd>(a: Self::Simd, op: F) -> Self::Simd;
-}
-
-#[cfg(not(feature = "simd"))]
-pub trait ArrowNumericType: ArrowPrimitiveType {}
-
-macro_rules! make_numeric_type {
-    ($impl_ty:ty, $native_ty:ty, $simd_ty:ident, $simd_mask_ty:ident) => {
-        #[cfg(feature = "simd")]
-        impl ArrowNumericType for $impl_ty {
-            type Simd = $simd_ty;
-
-            type SimdMask = $simd_mask_ty;
-
-            #[inline]
-            fn lanes() -> usize {
-                Self::Simd::lanes()
-            }
-
-            #[inline]
-            fn init(value: Self::Native) -> Self::Simd {
-                Self::Simd::splat(value)
-            }
-
-            #[inline]
-            fn load(slice: &[Self::Native]) -> Self::Simd {
-                unsafe { Self::Simd::from_slice_unaligned_unchecked(slice) }
-            }
-
-            #[inline]
-            fn mask_init(value: bool) -> Self::SimdMask {
-                Self::SimdMask::splat(value)
-            }
-
-            #[inline]
-            fn mask_from_u64(mask: u64) -> Self::SimdMask {
-                // this match will get removed by the compiler since the number of lanes is known at
-                // compile-time for each concrete numeric type
-                match Self::lanes() {
-                    4 => {
-                        // the bit position in each lane indicates the index of that lane
-                        let vecidx = i128x4::new(1, 2, 4, 8);
-
-                        // broadcast the lowermost 8 bits of mask to each lane
-                        let vecmask = i128x4::splat((mask & 0x0F) as i128);
-                        // compute whether the bit corresponding to each lanes index is set
-                        let vecmask = (vecidx & vecmask).eq(vecidx);
-
-                        // transmute is necessary because the different match arms return different
-                        // mask types, at runtime only one of those expressions will exist per type,
-                        // with the type being equal to `SimdMask`.
-                        unsafe { std::mem::transmute(vecmask) }
-                    }
-                    8 => {
-                        // the bit position in each lane indicates the index of that lane
-                        let vecidx = i64x8::new(1, 2, 4, 8, 16, 32, 64, 128);
-
-                        // broadcast the lowermost 8 bits of mask to each lane
-                        let vecmask = i64x8::splat((mask & 0xFF) as i64);
-                        // compute whether the bit corresponding to each lanes index is set
-                        let vecmask = (vecidx & vecmask).eq(vecidx);
-
-                        // transmute is necessary because the different match arms return different
-                        // mask types, at runtime only one of those expressions will exist per type,
-                        // with the type being equal to `SimdMask`.
-                        unsafe { std::mem::transmute(vecmask) }
-                    }
-                    16 => {
-                        // same general logic as for 8 lanes, extended to 16 bits
-                        let vecidx = i32x16::new(
-                            1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096,
-                            8192, 16384, 32768,
-                        );
-
-                        let vecmask = i32x16::splat((mask & 0xFFFF) as i32);
-                        let vecmask = (vecidx & vecmask).eq(vecidx);
-
-                        unsafe { std::mem::transmute(vecmask) }
-                    }
-                    32 => {
-                        // compute two separate m32x16 vector masks from  from the lower-most 32 bits of `mask`
-                        // and then combine them into one m16x32 vector mask by writing and reading a temporary
-                        let tmp = &mut [0_i16; 32];
-
-                        let vecidx = i32x16::new(
-                            1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096,
-                            8192, 16384, 32768,
-                        );
-
-                        let vecmask = i32x16::splat((mask & 0xFFFF) as i32);
-                        let vecmask = (vecidx & vecmask).eq(vecidx);
-
-                        i16x16::from_cast(vecmask)
-                            .write_to_slice_unaligned(&mut tmp[0..16]);
-
-                        let vecmask = i32x16::splat(((mask >> 16) & 0xFFFF) as i32);
-                        let vecmask = (vecidx & vecmask).eq(vecidx);
-
-                        i16x16::from_cast(vecmask)
-                            .write_to_slice_unaligned(&mut tmp[16..32]);
-
-                        unsafe { std::mem::transmute(i16x32::from_slice_unaligned(tmp)) }
-                    }
-                    64 => {
-                        // compute four m32x16 vector masks from  from all 64 bits of `mask`
-                        // and convert them into one m8x64 vector mask by writing and reading a temporary
-                        let tmp = &mut [0_i8; 64];
-
-                        let vecidx = i32x16::new(
-                            1, 2, 4, 8, 16, 32, 64, 128, 256, 512, 1024, 2048, 4096,
-                            8192, 16384, 32768,
-                        );
-
-                        let vecmask = i32x16::splat((mask & 0xFFFF) as i32);
-                        let vecmask = (vecidx & vecmask).eq(vecidx);
-
-                        i8x16::from_cast(vecmask)
-                            .write_to_slice_unaligned(&mut tmp[0..16]);
-
-                        let vecmask = i32x16::splat(((mask >> 16) & 0xFFFF) as i32);
-                        let vecmask = (vecidx & vecmask).eq(vecidx);
-
-                        i8x16::from_cast(vecmask)
-                            .write_to_slice_unaligned(&mut tmp[16..32]);
-
-                        let vecmask = i32x16::splat(((mask >> 32) & 0xFFFF) as i32);
-                        let vecmask = (vecidx & vecmask).eq(vecidx);
-
-                        i8x16::from_cast(vecmask)
-                            .write_to_slice_unaligned(&mut tmp[32..48]);
-
-                        let vecmask = i32x16::splat(((mask >> 48) & 0xFFFF) as i32);
-                        let vecmask = (vecidx & vecmask).eq(vecidx);
-
-                        i8x16::from_cast(vecmask)
-                            .write_to_slice_unaligned(&mut tmp[48..64]);
-
-                        unsafe { std::mem::transmute(i8x64::from_slice_unaligned(tmp)) }
-                    }
-                    _ => panic!("Invalid number of vector lanes"),
-                }
-            }
-
-            #[inline]
-            fn mask_to_u64(mask: &Self::SimdMask) -> u64 {
-                mask.bitmask() as u64
-            }
-
-            #[inline]
-            fn mask_get(mask: &Self::SimdMask, idx: usize) -> bool {
-                unsafe { mask.extract_unchecked(idx) }
-            }
-
-            #[inline]
-            fn mask_set(mask: Self::SimdMask, idx: usize, value: bool) -> Self::SimdMask {
-                unsafe { mask.replace_unchecked(idx, value) }
-            }
-
-            /// Selects elements of `a` and `b` using `mask`
-            #[inline]
-            fn mask_select(
-                mask: Self::SimdMask,
-                a: Self::Simd,
-                b: Self::Simd,
-            ) -> Self::Simd {
-                mask.select(a, b)
-            }
-
-            #[inline]
-            fn mask_any(mask: Self::SimdMask) -> bool {
-                mask.any()
-            }
-
-            #[inline]
-            fn bin_op<F: Fn(Self::Simd, Self::Simd) -> Self::Simd>(
-                left: Self::Simd,
-                right: Self::Simd,
-                op: F,
-            ) -> Self::Simd {
-                op(left, right)
-            }
-
-            #[inline]
-            fn eq(left: Self::Simd, right: Self::Simd) -> Self::SimdMask {
-                left.eq(right)
-            }
-
-            #[inline]
-            fn ne(left: Self::Simd, right: Self::Simd) -> Self::SimdMask {
-                left.ne(right)
-            }
-
-            #[inline]
-            fn lt(left: Self::Simd, right: Self::Simd) -> Self::SimdMask {
-                left.lt(right)
-            }
-
-            #[inline]
-            fn le(left: Self::Simd, right: Self::Simd) -> Self::SimdMask {
-                left.le(right)
-            }
-
-            #[inline]
-            fn gt(left: Self::Simd, right: Self::Simd) -> Self::SimdMask {
-                left.gt(right)
-            }
-
-            #[inline]
-            fn ge(left: Self::Simd, right: Self::Simd) -> Self::SimdMask {
-                left.ge(right)
-            }
-
-            #[inline]
-            fn write(simd_result: Self::Simd, slice: &mut [Self::Native]) {
-                unsafe { simd_result.write_to_slice_unaligned_unchecked(slice) };
-            }
-
-            #[inline]
-            fn unary_op<F: Fn(Self::Simd) -> Self::Simd>(
-                a: Self::Simd,
-                op: F,
-            ) -> Self::Simd {
-                op(a)
-            }
-        }
-
-        #[cfg(not(feature = "simd"))]
-        impl ArrowNumericType for $impl_ty {}
-    };
-}
-
-make_numeric_type!(Int8Type, i8, i8x64, m8x64);
-make_numeric_type!(Int16Type, i16, i16x32, m16x32);
-make_numeric_type!(Int32Type, i32, i32x16, m32x16);
-make_numeric_type!(Int64Type, i64, i64x8, m64x8);
-make_numeric_type!(UInt8Type, u8, u8x64, m8x64);
-make_numeric_type!(UInt16Type, u16, u16x32, m16x32);
-make_numeric_type!(UInt32Type, u32, u32x16, m32x16);
-make_numeric_type!(UInt64Type, u64, u64x8, m64x8);
-make_numeric_type!(Float32Type, f32, f32x16, m32x16);
-make_numeric_type!(Float64Type, f64, f64x8, m64x8);
-
-make_numeric_type!(TimestampSecondType, i64, i64x8, m64x8);
-make_numeric_type!(TimestampMillisecondType, i64, i64x8, m64x8);
-make_numeric_type!(TimestampMicrosecondType, i64, i64x8, m64x8);
-make_numeric_type!(TimestampNanosecondType, i64, i64x8, m64x8);
-make_numeric_type!(Date32Type, i32, i32x16, m32x16);
-make_numeric_type!(Date64Type, i64, i64x8, m64x8);
-make_numeric_type!(Time32SecondType, i32, i32x16, m32x16);
-make_numeric_type!(Time32MillisecondType, i32, i32x16, m32x16);
-make_numeric_type!(Time64MicrosecondType, i64, i64x8, m64x8);
-make_numeric_type!(Time64NanosecondType, i64, i64x8, m64x8);
-make_numeric_type!(IntervalYearMonthType, i32, i32x16, m32x16);
-make_numeric_type!(IntervalDayTimeType, i64, i64x8, m64x8);
-make_numeric_type!(IntervalMonthDayNanoType, i128, i128x4, m128x4);
-make_numeric_type!(DurationSecondType, i64, i64x8, m64x8);
-make_numeric_type!(DurationMillisecondType, i64, i64x8, m64x8);
-make_numeric_type!(DurationMicrosecondType, i64, i64x8, m64x8);
-make_numeric_type!(DurationNanosecondType, i64, i64x8, m64x8);
-
-#[cfg(feature = "simd")]
-pub trait ArrowFloatNumericType: ArrowNumericType {
-    fn pow(base: Self::Simd, raise: Self::Simd) -> Self::Simd;
-}
-
-#[cfg(not(feature = "simd"))]
-pub trait ArrowFloatNumericType: ArrowNumericType {}
-
-macro_rules! make_float_numeric_type {
-    ($impl_ty:ty, $simd_ty:ident) => {
-        #[cfg(feature = "simd")]
-        impl ArrowFloatNumericType for $impl_ty {
-            #[inline]
-            fn pow(base: Self::Simd, raise: Self::Simd) -> Self::Simd {
-                base.powf(raise)
-            }
-        }
-
-        #[cfg(not(feature = "simd"))]
-        impl ArrowFloatNumericType for $impl_ty {}
-    };
-}
-
-make_float_numeric_type!(Float32Type, f32x16);
-make_float_numeric_type!(Float64Type, f64x8);
-
-#[cfg(all(test, feature = "simd"))]
-mod tests {
-    use crate::datatypes::{
-        ArrowNumericType, Float32Type, Float64Type, Int32Type, Int64Type, Int8Type,
-        IntervalMonthDayNanoType, UInt16Type,
-    };
-    use packed_simd::*;
-    use FromCast;
-
-    /// calculate the expected mask by iterating over all bits
-    macro_rules! expected_mask {
-        ($T:ty, $MASK:expr) => {{
-            let mask = $MASK;
-            // simd width of all types is currently 64 bytes -> 512 bits
-            let lanes = 64 / std::mem::size_of::<$T>();
-            // translate each set bit into a value of all ones (-1) of the correct type
-            (0..lanes)
-                .map(|i| (if (mask & (1 << i)) != 0 { -1 } else { 0 }))
-                .collect::<Vec<$T>>()
-        }};
-    }
-
-    #[test]
-    fn test_mask_i128() {
-        let mask = 0b1101;
-        let actual = IntervalMonthDayNanoType::mask_from_u64(mask);
-        let expected = expected_mask!(i128, mask);
-        let expected =
-            m128x4::from_cast(i128x4::from_slice_unaligned(expected.as_slice()));
-
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn test_mask_f64() {
-        let mask = 0b10101010;
-        let actual = Float64Type::mask_from_u64(mask);
-        let expected = expected_mask!(i64, mask);
-        let expected = m64x8::from_cast(i64x8::from_slice_unaligned(expected.as_slice()));
-
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn test_mask_u64() {
-        let mask = 0b01010101;
-        let actual = Int64Type::mask_from_u64(mask);
-        let expected = expected_mask!(i64, mask);
-        let expected = m64x8::from_cast(i64x8::from_slice_unaligned(expected.as_slice()));
-
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn test_mask_f32() {
-        let mask = 0b10101010_10101010;
-        let actual = Float32Type::mask_from_u64(mask);
-        let expected = expected_mask!(i32, mask);
-        let expected =
-            m32x16::from_cast(i32x16::from_slice_unaligned(expected.as_slice()));
-
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn test_mask_i32() {
-        let mask = 0b01010101_01010101;
-        let actual = Int32Type::mask_from_u64(mask);
-        let expected = expected_mask!(i32, mask);
-        let expected =
-            m32x16::from_cast(i32x16::from_slice_unaligned(expected.as_slice()));
-
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn test_mask_u16() {
-        let mask = 0b01010101_01010101_10101010_10101010;
-        let actual = UInt16Type::mask_from_u64(mask);
-        let expected = expected_mask!(i16, mask);
-        dbg!(&expected);
-        let expected =
-            m16x32::from_cast(i16x32::from_slice_unaligned(expected.as_slice()));
-
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn test_mask_i8() {
-        let mask =
-            0b01010101_01010101_10101010_10101010_01010101_01010101_10101010_10101010;
-        let actual = Int8Type::mask_from_u64(mask);
-        let expected = expected_mask!(i8, mask);
-        let expected = m8x64::from_cast(i8x64::from_slice_unaligned(expected.as_slice()));
-
-        assert_eq!(expected, actual);
-    }
-}
diff --git a/arrow/src/datatypes/schema.rs b/arrow/src/datatypes/schema.rs
deleted file mode 100644
index 3ab627c687ea..000000000000
--- a/arrow/src/datatypes/schema.rs
+++ /dev/null
@@ -1,454 +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.
-
-use std::collections::HashMap;
-use std::default::Default;
-use std::fmt;
-use std::hash::Hash;
-
-use serde_derive::{Deserialize, Serialize};
-use serde_json::{json, Value};
-
-use crate::error::{ArrowError, Result};
-
-use super::Field;
-
-/// Describes the meta-data of an ordered sequence of relative types.
-///
-/// Note that this information is only part of the meta-data and not part of the physical
-/// memory layout.
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-pub struct Schema {
-    pub fields: Vec<Field>,
-    /// A map of key-value pairs containing additional meta data.
-    #[serde(skip_serializing_if = "HashMap::is_empty")]
-    #[serde(default)]
-    pub metadata: HashMap<String, String>,
-}
-
-impl Schema {
-    /// Creates an empty `Schema`
-    pub fn empty() -> Self {
-        Self {
-            fields: vec![],
-            metadata: HashMap::new(),
-        }
-    }
-
-    /// Creates a new `Schema` from a sequence of `Field` values.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use arrow::datatypes::{Field, DataType, Schema};
-    /// let field_a = Field::new("a", DataType::Int64, false);
-    /// let field_b = Field::new("b", DataType::Boolean, false);
-    ///
-    /// let schema = Schema::new(vec![field_a, field_b]);
-    /// ```
-    pub fn new(fields: Vec<Field>) -> Self {
-        Self::new_with_metadata(fields, HashMap::new())
-    }
-
-    /// Creates a new `Schema` from a sequence of `Field` values
-    /// and adds additional metadata in form of key value pairs.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use arrow::datatypes::{Field, DataType, Schema};
-    /// # use std::collections::HashMap;
-    /// let field_a = Field::new("a", DataType::Int64, false);
-    /// let field_b = Field::new("b", DataType::Boolean, false);
-    ///
-    /// let mut metadata: HashMap<String, String> = HashMap::new();
-    /// metadata.insert("row_count".to_string(), "100".to_string());
-    ///
-    /// let schema = Schema::new_with_metadata(vec![field_a, field_b], metadata);
-    /// ```
-    #[inline]
-    pub const fn new_with_metadata(
-        fields: Vec<Field>,
-        metadata: HashMap<String, String>,
-    ) -> Self {
-        Self { fields, metadata }
-    }
-
-    /// Sets the metadata of this `Schema` to be `metadata` and returns self
-    pub fn with_metadata(mut self, metadata: HashMap<String, String>) -> Self {
-        self.metadata = metadata;
-        self
-    }
-
-    /// Returns a new schema with only the specified columns in the new schema
-    /// This carries metadata from the parent schema over as well
-    pub fn project(&self, indices: &[usize]) -> Result<Schema> {
-        let new_fields = indices
-            .iter()
-            .map(|i| {
-                self.fields.get(*i).cloned().ok_or_else(|| {
-                    ArrowError::SchemaError(format!(
-                        "project index {} out of bounds, max field {}",
-                        i,
-                        self.fields().len()
-                    ))
-                })
-            })
-            .collect::<Result<Vec<_>>>()?;
-        Ok(Self::new_with_metadata(new_fields, self.metadata.clone()))
-    }
-
-    /// Merge schema into self if it is compatible. Struct fields will be merged recursively.
-    ///
-    /// Example:
-    ///
-    /// ```
-    /// use arrow::datatypes::*;
-    ///
-    /// let merged = Schema::try_merge(vec![
-    ///     Schema::new(vec![
-    ///         Field::new("c1", DataType::Int64, false),
-    ///         Field::new("c2", DataType::Utf8, false),
-    ///     ]),
-    ///     Schema::new(vec![
-    ///         Field::new("c1", DataType::Int64, true),
-    ///         Field::new("c2", DataType::Utf8, false),
-    ///         Field::new("c3", DataType::Utf8, false),
-    ///     ]),
-    /// ]).unwrap();
-    ///
-    /// assert_eq!(
-    ///     merged,
-    ///     Schema::new(vec![
-    ///         Field::new("c1", DataType::Int64, true),
-    ///         Field::new("c2", DataType::Utf8, false),
-    ///         Field::new("c3", DataType::Utf8, false),
-    ///     ]),
-    /// );
-    /// ```
-    pub fn try_merge(schemas: impl IntoIterator<Item = Self>) -> Result<Self> {
-        schemas
-            .into_iter()
-            .try_fold(Self::empty(), |mut merged, schema| {
-                let Schema { metadata, fields } = schema;
-                for (key, value) in metadata.into_iter() {
-                    // merge metadata
-                    if let Some(old_val) = merged.metadata.get(&key) {
-                        if old_val != &value {
-                            return Err(ArrowError::SchemaError(format!(
-                                "Fail to merge schema due to conflicting metadata. \
-                                         Key '{}' has different values '{}' and '{}'",
-                                key, old_val, value
-                            )));
-                        }
-                    }
-                    merged.metadata.insert(key, value);
-                }
-                // merge fields
-                for field in fields.into_iter() {
-                    let mut new_field = true;
-                    for merged_field in &mut merged.fields {
-                        if field.name() != merged_field.name() {
-                            continue;
-                        }
-                        new_field = false;
-                        merged_field.try_merge(&field)?
-                    }
-                    // found a new field, add to field list
-                    if new_field {
-                        merged.fields.push(field);
-                    }
-                }
-                Ok(merged)
-            })
-    }
-
-    /// Returns an immutable reference of the vector of `Field` instances.
-    #[inline]
-    pub const fn fields(&self) -> &Vec<Field> {
-        &self.fields
-    }
-
-    /// Returns a vector with references to all fields (including nested fields)
-    #[inline]
-    pub(crate) fn all_fields(&self) -> Vec<&Field> {
-        self.fields.iter().flat_map(|f| f.fields()).collect()
-    }
-
-    /// Returns an immutable reference of a specific `Field` instance selected using an
-    /// offset within the internal `fields` vector.
-    pub fn field(&self, i: usize) -> &Field {
-        &self.fields[i]
-    }
-
-    /// Returns an immutable reference of a specific `Field` instance selected by name.
-    pub fn field_with_name(&self, name: &str) -> Result<&Field> {
-        Ok(&self.fields[self.index_of(name)?])
-    }
-
-    /// Returns a vector of immutable references to all `Field` instances selected by
-    /// the dictionary ID they use.
-    pub fn fields_with_dict_id(&self, dict_id: i64) -> Vec<&Field> {
-        self.fields
-            .iter()
-            .flat_map(|f| f.fields_with_dict_id(dict_id))
-            .collect()
-    }
-
-    /// Find the index of the column with the given name.
-    pub fn index_of(&self, name: &str) -> Result<usize> {
-        for i in 0..self.fields.len() {
-            if self.fields[i].name() == name {
-                return Ok(i);
-            }
-        }
-        let valid_fields: Vec<String> =
-            self.fields.iter().map(|f| f.name().clone()).collect();
-        Err(ArrowError::InvalidArgumentError(format!(
-            "Unable to get field named \"{}\". Valid fields: {:?}",
-            name, valid_fields
-        )))
-    }
-
-    /// Returns an immutable reference to the Map of custom metadata key-value pairs.
-    #[inline]
-    pub const fn metadata(&self) -> &HashMap<String, String> {
-        &self.metadata
-    }
-
-    /// Look up a column by name and return a immutable reference to the column along with
-    /// its index.
-    pub fn column_with_name(&self, name: &str) -> Option<(usize, &Field)> {
-        self.fields
-            .iter()
-            .enumerate()
-            .find(|&(_, c)| c.name() == name)
-    }
-
-    /// Generate a JSON representation of the `Schema`.
-    pub fn to_json(&self) -> Value {
-        json!({
-            "fields": self.fields.iter().map(|field| field.to_json()).collect::<Vec<Value>>(),
-            "metadata": serde_json::to_value(&self.metadata).unwrap()
-        })
-    }
-
-    /// Parse a `Schema` definition from a JSON representation.
-    pub fn from(json: &Value) -> Result<Self> {
-        match *json {
-            Value::Object(ref schema) => {
-                let fields = if let Some(Value::Array(fields)) = schema.get("fields") {
-                    fields.iter().map(Field::from).collect::<Result<_>>()?
-                } else {
-                    return Err(ArrowError::ParseError(
-                        "Schema fields should be an array".to_string(),
-                    ));
-                };
-
-                let metadata = if let Some(value) = schema.get("metadata") {
-                    Self::from_metadata(value)?
-                } else {
-                    HashMap::default()
-                };
-
-                Ok(Self { fields, metadata })
-            }
-            _ => Err(ArrowError::ParseError(
-                "Invalid json value type for schema".to_string(),
-            )),
-        }
-    }
-
-    /// Parse a `metadata` definition from a JSON representation.
-    /// The JSON can either be an Object or an Array of Objects.
-    fn from_metadata(json: &Value) -> Result<HashMap<String, String>> {
-        match json {
-            Value::Array(_) => {
-                let mut hashmap = HashMap::new();
-                let values: Vec<MetadataKeyValue> = serde_json::from_value(json.clone())
-                    .map_err(|_| {
-                        ArrowError::JsonError(
-                            "Unable to parse object into key-value pair".to_string(),
-                        )
-                    })?;
-                for meta in values {
-                    hashmap.insert(meta.key.clone(), meta.value);
-                }
-                Ok(hashmap)
-            }
-            Value::Object(md) => md
-                .iter()
-                .map(|(k, v)| {
-                    if let Value::String(v) = v {
-                        Ok((k.to_string(), v.to_string()))
-                    } else {
-                        Err(ArrowError::ParseError(
-                            "metadata `value` field must be a string".to_string(),
-                        ))
-                    }
-                })
-                .collect::<Result<_>>(),
-            _ => Err(ArrowError::ParseError(
-                "`metadata` field must be an object".to_string(),
-            )),
-        }
-    }
-
-    /// Check to see if `self` is a superset of `other` schema. Here are the comparison rules:
-    ///
-    /// * `self` and `other` should contain the same number of fields
-    /// * for every field `f` in `other`, the field in `self` with corresponding index should be a
-    /// superset of `f`.
-    /// * self.metadata is a superset of other.metadata
-    ///
-    /// In other words, any record conforms to `other` should also conform to `self`.
-    pub fn contains(&self, other: &Schema) -> bool {
-        if self.fields.len() != other.fields.len() {
-            return false;
-        }
-
-        for (i, field) in other.fields.iter().enumerate() {
-            if !self.fields[i].contains(field) {
-                return false;
-            }
-        }
-
-        // make sure self.metadata is a superset of other.metadata
-        for (k, v) in &other.metadata {
-            match self.metadata.get(k) {
-                Some(s) => {
-                    if s != v {
-                        return false;
-                    }
-                }
-                None => {
-                    return false;
-                }
-            }
-        }
-
-        true
-    }
-}
-
-impl fmt::Display for Schema {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.write_str(
-            &self
-                .fields
-                .iter()
-                .map(|c| c.to_string())
-                .collect::<Vec<String>>()
-                .join(", "),
-        )
-    }
-}
-
-// need to implement `Hash` manually because `HashMap` implement Eq but no `Hash`
-#[allow(clippy::derive_hash_xor_eq)]
-impl Hash for Schema {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.fields.hash(state);
-
-        // ensure deterministic key order
-        let mut keys: Vec<&String> = self.metadata.keys().collect();
-        keys.sort();
-        for k in keys {
-            k.hash(state);
-            self.metadata.get(k).expect("key valid").hash(state);
-        }
-    }
-}
-
-#[derive(Deserialize)]
-struct MetadataKeyValue {
-    key: String,
-    value: String,
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::datatypes::DataType;
-
-    use super::*;
-
-    #[test]
-    fn test_ser_de_metadata() {
-        // ser/de with empty metadata
-        let schema = Schema::new(vec![
-            Field::new("name", DataType::Utf8, false),
-            Field::new("address", DataType::Utf8, false),
-            Field::new("priority", DataType::UInt8, false),
-        ]);
-
-        let json = serde_json::to_string(&schema).unwrap();
-        let de_schema = serde_json::from_str(&json).unwrap();
-
-        assert_eq!(schema, de_schema);
-
-        // ser/de with non-empty metadata
-        let schema = schema
-            .with_metadata([("key".to_owned(), "val".to_owned())].into_iter().collect());
-        let json = serde_json::to_string(&schema).unwrap();
-        let de_schema = serde_json::from_str(&json).unwrap();
-
-        assert_eq!(schema, de_schema);
-    }
-
-    #[test]
-    fn test_projection() {
-        let mut metadata = HashMap::new();
-        metadata.insert("meta".to_string(), "data".to_string());
-
-        let schema = Schema::new(vec![
-            Field::new("name", DataType::Utf8, false),
-            Field::new("address", DataType::Utf8, false),
-            Field::new("priority", DataType::UInt8, false),
-        ])
-        .with_metadata(metadata);
-
-        let projected: Schema = schema.project(&[0, 2]).unwrap();
-
-        assert_eq!(projected.fields().len(), 2);
-        assert_eq!(projected.fields()[0].name(), "name");
-        assert_eq!(projected.fields()[1].name(), "priority");
-        assert_eq!(projected.metadata.get("meta").unwrap(), "data")
-    }
-
-    #[test]
-    fn test_oob_projection() {
-        let mut metadata = HashMap::new();
-        metadata.insert("meta".to_string(), "data".to_string());
-
-        let schema = Schema::new(vec![
-            Field::new("name", DataType::Utf8, false),
-            Field::new("address", DataType::Utf8, false),
-            Field::new("priority", DataType::UInt8, false),
-        ])
-        .with_metadata(metadata);
-
-        let projected: Result<Schema> = schema.project(&[0, 3]);
-
-        assert!(projected.is_err());
-        if let Err(e) = projected {
-            assert_eq!(
-                e.to_string(),
-                "Schema error: project index 3 out of bounds, max field 3".to_string()
-            )
-        }
-    }
-}
diff --git a/arrow/src/datatypes/types.rs b/arrow/src/datatypes/types.rs
deleted file mode 100644
index 8c0ac7b3fd6e..000000000000
--- a/arrow/src/datatypes/types.rs
+++ /dev/null
@@ -1,497 +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.
-
-use super::{ArrowPrimitiveType, DataType, IntervalUnit, TimeUnit};
-use crate::datatypes::delta::shift_months;
-use chrono::{Duration, NaiveDate};
-use half::f16;
-use std::ops::{Add, Sub};
-
-// BooleanType is special: its bit-width is not the size of the primitive type, and its `index`
-// operation assumes bit-packing.
-#[derive(Debug)]
-pub struct BooleanType {}
-
-impl BooleanType {
-    pub const DATA_TYPE: DataType = DataType::Boolean;
-}
-
-macro_rules! make_type {
-    ($name:ident, $native_ty:ty, $data_ty:expr) => {
-        #[derive(Debug)]
-        pub struct $name {}
-
-        impl ArrowPrimitiveType for $name {
-            type Native = $native_ty;
-            const DATA_TYPE: DataType = $data_ty;
-        }
-    };
-}
-
-make_type!(Int8Type, i8, DataType::Int8);
-make_type!(Int16Type, i16, DataType::Int16);
-make_type!(Int32Type, i32, DataType::Int32);
-make_type!(Int64Type, i64, DataType::Int64);
-make_type!(UInt8Type, u8, DataType::UInt8);
-make_type!(UInt16Type, u16, DataType::UInt16);
-make_type!(UInt32Type, u32, DataType::UInt32);
-make_type!(UInt64Type, u64, DataType::UInt64);
-make_type!(Float16Type, f16, DataType::Float16);
-make_type!(Float32Type, f32, DataType::Float32);
-make_type!(Float64Type, f64, DataType::Float64);
-make_type!(
-    TimestampSecondType,
-    i64,
-    DataType::Timestamp(TimeUnit::Second, None)
-);
-make_type!(
-    TimestampMillisecondType,
-    i64,
-    DataType::Timestamp(TimeUnit::Millisecond, None)
-);
-make_type!(
-    TimestampMicrosecondType,
-    i64,
-    DataType::Timestamp(TimeUnit::Microsecond, None)
-);
-make_type!(
-    TimestampNanosecondType,
-    i64,
-    DataType::Timestamp(TimeUnit::Nanosecond, None)
-);
-make_type!(Date32Type, i32, DataType::Date32);
-make_type!(Date64Type, i64, DataType::Date64);
-make_type!(Time32SecondType, i32, DataType::Time32(TimeUnit::Second));
-make_type!(
-    Time32MillisecondType,
-    i32,
-    DataType::Time32(TimeUnit::Millisecond)
-);
-make_type!(
-    Time64MicrosecondType,
-    i64,
-    DataType::Time64(TimeUnit::Microsecond)
-);
-make_type!(
-    Time64NanosecondType,
-    i64,
-    DataType::Time64(TimeUnit::Nanosecond)
-);
-make_type!(
-    IntervalYearMonthType,
-    i32,
-    DataType::Interval(IntervalUnit::YearMonth)
-);
-make_type!(
-    IntervalDayTimeType,
-    i64,
-    DataType::Interval(IntervalUnit::DayTime)
-);
-make_type!(
-    IntervalMonthDayNanoType,
-    i128,
-    DataType::Interval(IntervalUnit::MonthDayNano)
-);
-make_type!(
-    DurationSecondType,
-    i64,
-    DataType::Duration(TimeUnit::Second)
-);
-make_type!(
-    DurationMillisecondType,
-    i64,
-    DataType::Duration(TimeUnit::Millisecond)
-);
-make_type!(
-    DurationMicrosecondType,
-    i64,
-    DataType::Duration(TimeUnit::Microsecond)
-);
-make_type!(
-    DurationNanosecondType,
-    i64,
-    DataType::Duration(TimeUnit::Nanosecond)
-);
-
-/// A subtype of primitive type that represents legal dictionary keys.
-/// See <https://arrow.apache.org/docs/format/Columnar.html>
-pub trait ArrowDictionaryKeyType: ArrowPrimitiveType {}
-
-impl ArrowDictionaryKeyType for Int8Type {}
-
-impl ArrowDictionaryKeyType for Int16Type {}
-
-impl ArrowDictionaryKeyType for Int32Type {}
-
-impl ArrowDictionaryKeyType for Int64Type {}
-
-impl ArrowDictionaryKeyType for UInt8Type {}
-
-impl ArrowDictionaryKeyType for UInt16Type {}
-
-impl ArrowDictionaryKeyType for UInt32Type {}
-
-impl ArrowDictionaryKeyType for UInt64Type {}
-
-/// A subtype of primitive type that represents temporal values.
-pub trait ArrowTemporalType: ArrowPrimitiveType {}
-
-impl ArrowTemporalType for TimestampSecondType {}
-impl ArrowTemporalType for TimestampMillisecondType {}
-impl ArrowTemporalType for TimestampMicrosecondType {}
-impl ArrowTemporalType for TimestampNanosecondType {}
-impl ArrowTemporalType for Date32Type {}
-impl ArrowTemporalType for Date64Type {}
-impl ArrowTemporalType for Time32SecondType {}
-impl ArrowTemporalType for Time32MillisecondType {}
-impl ArrowTemporalType for Time64MicrosecondType {}
-impl ArrowTemporalType for Time64NanosecondType {}
-// impl ArrowTemporalType for IntervalYearMonthType {}
-// impl ArrowTemporalType for IntervalDayTimeType {}
-// impl ArrowTemporalType for IntervalMonthDayNanoType {}
-impl ArrowTemporalType for DurationSecondType {}
-impl ArrowTemporalType for DurationMillisecondType {}
-impl ArrowTemporalType for DurationMicrosecondType {}
-impl ArrowTemporalType for DurationNanosecondType {}
-
-/// A timestamp type allows us to create array builders that take a timestamp.
-pub trait ArrowTimestampType: ArrowTemporalType {
-    /// Returns the `TimeUnit` of this timestamp.
-    fn get_time_unit() -> TimeUnit;
-}
-
-impl ArrowTimestampType for TimestampSecondType {
-    fn get_time_unit() -> TimeUnit {
-        TimeUnit::Second
-    }
-}
-impl ArrowTimestampType for TimestampMillisecondType {
-    fn get_time_unit() -> TimeUnit {
-        TimeUnit::Millisecond
-    }
-}
-impl ArrowTimestampType for TimestampMicrosecondType {
-    fn get_time_unit() -> TimeUnit {
-        TimeUnit::Microsecond
-    }
-}
-impl ArrowTimestampType for TimestampNanosecondType {
-    fn get_time_unit() -> TimeUnit {
-        TimeUnit::Nanosecond
-    }
-}
-
-impl IntervalYearMonthType {
-    /// Creates a IntervalYearMonthType::Native
-    ///
-    /// # Arguments
-    ///
-    /// * `years` - The number of years (+/-) represented in this interval
-    /// * `months` - The number of months (+/-) represented in this interval
-    pub fn make_value(
-        years: i32,
-        months: i32,
-    ) -> <IntervalYearMonthType as ArrowPrimitiveType>::Native {
-        years * 12 + months
-    }
-
-    /// Turns a IntervalYearMonthType type into an i32 of months.
-    ///
-    /// This operation is technically a no-op, it is included for comprehensiveness.
-    ///
-    /// # Arguments
-    ///
-    /// * `i` - The IntervalYearMonthType::Native to convert
-    pub fn to_months(i: <IntervalYearMonthType as ArrowPrimitiveType>::Native) -> i32 {
-        i
-    }
-}
-
-impl IntervalDayTimeType {
-    /// Creates a IntervalDayTimeType::Native
-    ///
-    /// # Arguments
-    ///
-    /// * `days` - The number of days (+/-) represented in this interval
-    /// * `millis` - The number of milliseconds (+/-) represented in this interval
-    pub fn make_value(
-        days: i32,
-        millis: i32,
-    ) -> <IntervalDayTimeType as ArrowPrimitiveType>::Native {
-        /*
-        https://github.com/apache/arrow/blob/02c8598d264c839a5b5cf3109bfd406f3b8a6ba5/cpp/src/arrow/type.h#L1433
-        struct DayMilliseconds {
-            int32_t days = 0;
-            int32_t milliseconds = 0;
-            ...
-        }
-        64      56      48      40      32      24      16      8       0
-        +-------+-------+-------+-------+-------+-------+-------+-------+
-        |             days              |         milliseconds          |
-        +-------+-------+-------+-------+-------+-------+-------+-------+
-        */
-        let m = millis as u64 & u32::MAX as u64;
-        let d = (days as u64 & u32::MAX as u64) << 32;
-        (m | d) as <IntervalDayTimeType as ArrowPrimitiveType>::Native
-    }
-
-    /// Turns a IntervalDayTimeType into a tuple of (days, milliseconds)
-    ///
-    /// # Arguments
-    ///
-    /// * `i` - The IntervalDayTimeType to convert
-    pub fn to_parts(
-        i: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
-    ) -> (i32, i32) {
-        let days = (i >> 32) as i32;
-        let ms = i as i32;
-        (days, ms)
-    }
-}
-
-impl IntervalMonthDayNanoType {
-    /// Creates a IntervalMonthDayNanoType::Native
-    ///
-    /// # Arguments
-    ///
-    /// * `months` - The number of months (+/-) represented in this interval
-    /// * `days` - The number of days (+/-) represented in this interval
-    /// * `nanos` - The number of nanoseconds (+/-) represented in this interval
-    pub fn make_value(
-        months: i32,
-        days: i32,
-        nanos: i64,
-    ) -> <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native {
-        /*
-        https://github.com/apache/arrow/blob/02c8598d264c839a5b5cf3109bfd406f3b8a6ba5/cpp/src/arrow/type.h#L1475
-        struct MonthDayNanos {
-            int32_t months;
-            int32_t days;
-            int64_t nanoseconds;
-        }
-        128     112     96      80      64      48      32      16      0
-        +-------+-------+-------+-------+-------+-------+-------+-------+
-        |     months    |      days     |             nanos             |
-        +-------+-------+-------+-------+-------+-------+-------+-------+
-        */
-        let m = (months as u128 & u32::MAX as u128) << 96;
-        let d = (days as u128 & u32::MAX as u128) << 64;
-        let n = nanos as u128 & u64::MAX as u128;
-        (m | d | n) as <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native
-    }
-
-    /// Turns a IntervalMonthDayNanoType into a tuple of (months, days, nanos)
-    ///
-    /// # Arguments
-    ///
-    /// * `i` - The IntervalMonthDayNanoType to convert
-    pub fn to_parts(
-        i: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
-    ) -> (i32, i32, i64) {
-        let months = (i >> 96) as i32;
-        let days = (i >> 64) as i32;
-        let nanos = i as i64;
-        (months, days, nanos)
-    }
-}
-
-impl Date32Type {
-    /// Converts an arrow Date32Type into a chrono::NaiveDate
-    ///
-    /// # Arguments
-    ///
-    /// * `i` - The Date32Type to convert
-    pub fn to_naive_date(i: <Date32Type as ArrowPrimitiveType>::Native) -> NaiveDate {
-        let epoch = NaiveDate::from_ymd(1970, 1, 1);
-        epoch.add(Duration::days(i as i64))
-    }
-
-    /// Converts a chrono::NaiveDate into an arrow Date32Type
-    ///
-    /// # Arguments
-    ///
-    /// * `d` - The NaiveDate to convert
-    pub fn from_naive_date(d: NaiveDate) -> <Date32Type as ArrowPrimitiveType>::Native {
-        let epoch = NaiveDate::from_ymd(1970, 1, 1);
-        d.sub(epoch).num_days() as <Date32Type as ArrowPrimitiveType>::Native
-    }
-
-    /// Adds the given IntervalYearMonthType to an arrow Date32Type
-    ///
-    /// # Arguments
-    ///
-    /// * `date` - The date on which to perform the operation
-    /// * `delta` - The interval to add
-    pub fn add_year_months(
-        date: <Date32Type as ArrowPrimitiveType>::Native,
-        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
-    ) -> <Date32Type as ArrowPrimitiveType>::Native {
-        let prior = Date32Type::to_naive_date(date);
-        let months = IntervalYearMonthType::to_months(delta);
-        let posterior = shift_months(prior, months);
-        Date32Type::from_naive_date(posterior)
-    }
-
-    /// Adds the given IntervalDayTimeType to an arrow Date32Type
-    ///
-    /// # Arguments
-    ///
-    /// * `date` - The date on which to perform the operation
-    /// * `delta` - The interval to add
-    pub fn add_day_time(
-        date: <Date32Type as ArrowPrimitiveType>::Native,
-        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
-    ) -> <Date32Type as ArrowPrimitiveType>::Native {
-        let (days, ms) = IntervalDayTimeType::to_parts(delta);
-        let res = Date32Type::to_naive_date(date);
-        let res = res.add(Duration::days(days as i64));
-        let res = res.add(Duration::milliseconds(ms as i64));
-        Date32Type::from_naive_date(res)
-    }
-
-    /// Adds the given IntervalMonthDayNanoType to an arrow Date32Type
-    ///
-    /// # Arguments
-    ///
-    /// * `date` - The date on which to perform the operation
-    /// * `delta` - The interval to add
-    pub fn add_month_day_nano(
-        date: <Date32Type as ArrowPrimitiveType>::Native,
-        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
-    ) -> <Date32Type as ArrowPrimitiveType>::Native {
-        let (months, days, nanos) = IntervalMonthDayNanoType::to_parts(delta);
-        let res = Date32Type::to_naive_date(date);
-        let res = shift_months(res, months);
-        let res = res.add(Duration::days(days as i64));
-        let res = res.add(Duration::nanoseconds(nanos));
-        Date32Type::from_naive_date(res)
-    }
-}
-
-impl Date64Type {
-    /// Converts an arrow Date64Type into a chrono::NaiveDate
-    ///
-    /// # Arguments
-    ///
-    /// * `i` - The Date64Type to convert
-    pub fn to_naive_date(i: <Date64Type as ArrowPrimitiveType>::Native) -> NaiveDate {
-        let epoch = NaiveDate::from_ymd(1970, 1, 1);
-        epoch.add(Duration::milliseconds(i as i64))
-    }
-
-    /// Converts a chrono::NaiveDate into an arrow Date64Type
-    ///
-    /// # Arguments
-    ///
-    /// * `d` - The NaiveDate to convert
-    pub fn from_naive_date(d: NaiveDate) -> <Date64Type as ArrowPrimitiveType>::Native {
-        let epoch = NaiveDate::from_ymd(1970, 1, 1);
-        d.sub(epoch).num_milliseconds() as <Date64Type as ArrowPrimitiveType>::Native
-    }
-
-    /// Adds the given IntervalYearMonthType to an arrow Date64Type
-    ///
-    /// # Arguments
-    ///
-    /// * `date` - The date on which to perform the operation
-    /// * `delta` - The interval to add
-    pub fn add_year_months(
-        date: <Date64Type as ArrowPrimitiveType>::Native,
-        delta: <IntervalYearMonthType as ArrowPrimitiveType>::Native,
-    ) -> <Date64Type as ArrowPrimitiveType>::Native {
-        let prior = Date64Type::to_naive_date(date);
-        let months = IntervalYearMonthType::to_months(delta);
-        let posterior = shift_months(prior, months);
-        Date64Type::from_naive_date(posterior)
-    }
-
-    /// Adds the given IntervalDayTimeType to an arrow Date64Type
-    ///
-    /// # Arguments
-    ///
-    /// * `date` - The date on which to perform the operation
-    /// * `delta` - The interval to add
-    pub fn add_day_time(
-        date: <Date64Type as ArrowPrimitiveType>::Native,
-        delta: <IntervalDayTimeType as ArrowPrimitiveType>::Native,
-    ) -> <Date64Type as ArrowPrimitiveType>::Native {
-        let (days, ms) = IntervalDayTimeType::to_parts(delta);
-        let res = Date64Type::to_naive_date(date);
-        let res = res.add(Duration::days(days as i64));
-        let res = res.add(Duration::milliseconds(ms as i64));
-        Date64Type::from_naive_date(res)
-    }
-
-    /// Adds the given IntervalMonthDayNanoType to an arrow Date64Type
-    ///
-    /// # Arguments
-    ///
-    /// * `date` - The date on which to perform the operation
-    /// * `delta` - The interval to add
-    pub fn add_month_day_nano(
-        date: <Date64Type as ArrowPrimitiveType>::Native,
-        delta: <IntervalMonthDayNanoType as ArrowPrimitiveType>::Native,
-    ) -> <Date64Type as ArrowPrimitiveType>::Native {
-        let (months, days, nanos) = IntervalMonthDayNanoType::to_parts(delta);
-        let res = Date64Type::to_naive_date(date);
-        let res = shift_months(res, months);
-        let res = res.add(Duration::days(days as i64));
-        let res = res.add(Duration::nanoseconds(nanos));
-        Date64Type::from_naive_date(res)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn month_day_nano_should_roundtrip() {
-        let value = IntervalMonthDayNanoType::make_value(1, 2, 3);
-        assert_eq!(IntervalMonthDayNanoType::to_parts(value), (1, 2, 3));
-    }
-
-    #[test]
-    fn month_day_nano_should_roundtrip_neg() {
-        let value = IntervalMonthDayNanoType::make_value(-1, -2, -3);
-        assert_eq!(IntervalMonthDayNanoType::to_parts(value), (-1, -2, -3));
-    }
-
-    #[test]
-    fn day_time_should_roundtrip() {
-        let value = IntervalDayTimeType::make_value(1, 2);
-        assert_eq!(IntervalDayTimeType::to_parts(value), (1, 2));
-    }
-
-    #[test]
-    fn day_time_should_roundtrip_neg() {
-        let value = IntervalDayTimeType::make_value(-1, -2);
-        assert_eq!(IntervalDayTimeType::to_parts(value), (-1, -2));
-    }
-
-    #[test]
-    fn year_month_should_roundtrip() {
-        let value = IntervalYearMonthType::make_value(1, 2);
-        assert_eq!(IntervalYearMonthType::to_months(value), 14);
-    }
-
-    #[test]
-    fn year_month_should_roundtrip_neg() {
-        let value = IntervalYearMonthType::make_value(-1, -2);
-        assert_eq!(IntervalYearMonthType::to_months(value), -14);
-    }
-}
diff --git a/arrow/src/error.rs b/arrow/src/error.rs
index ef7abbbddef9..f7acec0b34d7 100644
--- a/arrow/src/error.rs
+++ b/arrow/src/error.rs
@@ -16,119 +16,7 @@
 // under the License.
 
 //! Defines `ArrowError` for representing failures in various Arrow operations.
-use std::fmt::{Debug, Display, Formatter};
-use std::io::Write;
 
-use std::error::Error;
-
-/// Many different operations in the `arrow` crate return this error type.
-#[derive(Debug)]
-pub enum ArrowError {
-    /// Returned when functionality is not yet available.
-    NotYetImplemented(String),
-    ExternalError(Box<dyn Error + Send + Sync>),
-    CastError(String),
-    MemoryError(String),
-    ParseError(String),
-    SchemaError(String),
-    ComputeError(String),
-    DivideByZero,
-    CsvError(String),
-    JsonError(String),
-    IoError(String),
-    InvalidArgumentError(String),
-    ParquetError(String),
-    /// Error during import or export to/from the C Data Interface
-    CDataInterface(String),
-    DictionaryKeyOverflowError,
-}
-
-impl ArrowError {
-    /// Wraps an external error in an `ArrowError`.
-    pub fn from_external_error(
-        error: Box<dyn ::std::error::Error + Send + Sync>,
-    ) -> Self {
-        Self::ExternalError(error)
-    }
-}
-
-impl From<::std::io::Error> for ArrowError {
-    fn from(error: std::io::Error) -> Self {
-        ArrowError::IoError(error.to_string())
-    }
-}
-
-#[cfg(feature = "csv")]
-impl From<csv_crate::Error> for ArrowError {
-    fn from(error: csv_crate::Error) -> Self {
-        match error.kind() {
-            csv_crate::ErrorKind::Io(error) => ArrowError::CsvError(error.to_string()),
-            csv_crate::ErrorKind::Utf8 { pos: _, err } => ArrowError::CsvError(format!(
-                "Encountered UTF-8 error while reading CSV file: {}",
-                err
-            )),
-            csv_crate::ErrorKind::UnequalLengths {
-                expected_len, len, ..
-            } => ArrowError::CsvError(format!(
-                "Encountered unequal lengths between records on CSV file. Expected {} \
-                 records, found {} records",
-                len, expected_len
-            )),
-            _ => ArrowError::CsvError("Error reading CSV file".to_string()),
-        }
-    }
-}
-
-impl From<::std::string::FromUtf8Error> for ArrowError {
-    fn from(error: std::string::FromUtf8Error) -> Self {
-        ArrowError::ParseError(error.to_string())
-    }
-}
-
-impl From<serde_json::Error> for ArrowError {
-    fn from(error: serde_json::Error) -> Self {
-        ArrowError::JsonError(error.to_string())
-    }
-}
-
-impl<W: Write> From<::std::io::IntoInnerError<W>> for ArrowError {
-    fn from(error: std::io::IntoInnerError<W>) -> Self {
-        ArrowError::IoError(error.to_string())
-    }
-}
-
-impl Display for ArrowError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            ArrowError::NotYetImplemented(source) => {
-                write!(f, "Not yet implemented: {}", &source)
-            }
-            ArrowError::ExternalError(source) => write!(f, "External error: {}", &source),
-            ArrowError::CastError(desc) => write!(f, "Cast error: {}", desc),
-            ArrowError::MemoryError(desc) => write!(f, "Memory error: {}", desc),
-            ArrowError::ParseError(desc) => write!(f, "Parser error: {}", desc),
-            ArrowError::SchemaError(desc) => write!(f, "Schema error: {}", desc),
-            ArrowError::ComputeError(desc) => write!(f, "Compute error: {}", desc),
-            ArrowError::DivideByZero => write!(f, "Divide by zero error"),
-            ArrowError::CsvError(desc) => write!(f, "Csv error: {}", desc),
-            ArrowError::JsonError(desc) => write!(f, "Json error: {}", desc),
-            ArrowError::IoError(desc) => write!(f, "Io error: {}", desc),
-            ArrowError::InvalidArgumentError(desc) => {
-                write!(f, "Invalid argument error: {}", desc)
-            }
-            ArrowError::ParquetError(desc) => {
-                write!(f, "Parquet argument error: {}", desc)
-            }
-            ArrowError::CDataInterface(desc) => {
-                write!(f, "C Data interface error: {}", desc)
-            }
-            ArrowError::DictionaryKeyOverflowError => {
-                write!(f, "Dictionary key bigger than the key type")
-            }
-        }
-    }
-}
-
-impl Error for ArrowError {}
+pub use arrow_schema::ArrowError;
 
 pub type Result<T> = std::result::Result<T, ArrowError>;
diff --git a/arrow/src/ffi.rs b/arrow/src/ffi.rs
index 528f3adc2d84..d867f7c30d1f 100644
--- a/arrow/src/ffi.rs
+++ b/arrow/src/ffi.rs
@@ -22,70 +22,65 @@
 //! This is handled by [FFI_ArrowSchema] and [FFI_ArrowArray].
 //!
 //! The second interface maps native Rust types to the Rust-specific implementation of Arrow such as `format` to `Datatype`,
-//! `Buffer`, etc. This is handled by `ArrowArray`.
+//! `Buffer`, etc. This is handled by `from_ffi` and `to_ffi`.
+//!
+//!
+//! Export to FFI
 //!
 //! ```rust
 //! # use std::sync::Arc;
-//! # use arrow::array::{Int32Array, Array, ArrayData, export_array_into_raw, make_array, make_array_from_raw};
-//! # use arrow::error::{Result, ArrowError};
-//! # use arrow::compute::kernels::arithmetic;
-//! # use arrow::ffi::{ArrowArray, FFI_ArrowArray, FFI_ArrowSchema};
-//! # use std::convert::TryFrom;
+//! # use arrow::array::{Int32Array, Array, ArrayData, make_array};
+//! # use arrow::error::Result;
+//! # use arrow_arith::numeric::add;
+//! # use arrow::ffi::{to_ffi, from_ffi};
 //! # fn main() -> Result<()> {
 //! // create an array natively
-//! let array = Int32Array::from(vec![Some(1), None, Some(3)]);
 //!
-//! // export it
-//!
-//! let ffi_array = ArrowArray::try_new(array.data().clone())?;
-//! let (array_ptr, schema_ptr) = ArrowArray::into_raw(ffi_array);
+//! let array = Int32Array::from(vec![Some(1), None, Some(3)]);
+//! let data = array.into_data();
 //!
-//! // consumed and used by something else...
+//! // Export it
+//! let (out_array, out_schema) = to_ffi(&data)?;
 //!
 //! // import it
-//! let array = unsafe { make_array_from_raw(array_ptr, schema_ptr)? };
+//! let data = unsafe { from_ffi(out_array, &out_schema) }?;
+//! let array = Int32Array::from(data);
 //!
 //! // perform some operation
-//! let array = array.as_any().downcast_ref::<Int32Array>().ok_or(
-//!     ArrowError::ParseError("Expects an int32".to_string()),
-//! )?;
-//! let array = arithmetic::add(&array, &array)?;
+//! let array = add(&array, &array)?;
 //!
 //! // verify
-//! assert_eq!(array, Int32Array::from(vec![Some(2), None, Some(6)]));
-//!
-//! // Simulate if raw pointers are provided by consumer
-//! let array = make_array(Int32Array::from(vec![Some(1), None, Some(3)]).into_data());
-//!
-//! let out_array = Box::new(FFI_ArrowArray::empty());
-//! let out_schema = Box::new(FFI_ArrowSchema::empty());
-//! let out_array_ptr = Box::into_raw(out_array);
-//! let out_schema_ptr = Box::into_raw(out_schema);
-//!
-//! // export array into raw pointers from consumer
-//! unsafe { export_array_into_raw(array, out_array_ptr, out_schema_ptr)?; };
-//!
-//! // import it
-//! let array = unsafe { make_array_from_raw(out_array_ptr, out_schema_ptr)? };
+//! assert_eq!(array.as_ref(), &Int32Array::from(vec![Some(2), None, Some(6)]));
+//! #
+//! # Ok(())
+//! # }
+//! ```
 //!
-//! // perform some operation
-//! let array = array.as_any().downcast_ref::<Int32Array>().ok_or(
-//!     ArrowError::ParseError("Expects an int32".to_string()),
-//! )?;
-//! let array = arithmetic::add(&array, &array)?;
+//! Import from FFI
 //!
-//! // verify
-//! assert_eq!(array, Int32Array::from(vec![Some(2), None, Some(6)]));
+//! ```
+//! # use std::ptr::addr_of_mut;
+//! # use arrow::ffi::{from_ffi, FFI_ArrowArray, FFI_ArrowSchema};
+//! # use arrow_array::{ArrayRef, make_array};
+//! # use arrow_schema::ArrowError;
+//! #
+//! /// A foreign data container that can export to C Data interface
+//! struct ForeignArray {};
 //!
-//! // (drop/release)
-//! unsafe {
-//!     Box::from_raw(out_array_ptr);
-//!     Box::from_raw(out_schema_ptr);
-//!     Arc::from_raw(array_ptr);
-//!     Arc::from_raw(schema_ptr);
+//! impl ForeignArray {
+//!     /// Export from foreign array representation to C Data interface
+//!     /// e.g. <https://github.com/apache/arrow/blob/fc1f9ebbc4c3ae77d5cfc2f9322f4373d3d19b8a/python/pyarrow/array.pxi#L1552>
+//!     fn export_to_c(&self, array: *mut FFI_ArrowArray, schema: *mut FFI_ArrowSchema) {
+//!         // ...
+//!     }
 //! }
 //!
-//! Ok(())
+//! /// Import an [`ArrayRef`] from a [`ForeignArray`]
+//! fn import_array(foreign: &ForeignArray) -> Result<ArrayRef, ArrowError> {
+//!     let mut schema = FFI_ArrowSchema::empty();
+//!     let mut array = FFI_ArrowArray::empty();
+//!     foreign.export_to_c(addr_of_mut!(array), addr_of_mut!(schema));
+//!     Ok(make_array(unsafe { from_ffi(array, &schema) }?))
 //! }
 //! ```
 
@@ -109,464 +104,102 @@ To import an array, unsafely create an `ArrowArray` from two pointers using [Arr
 To export an array, create an `ArrowArray` using [ArrowArray::try_new].
 */
 
-use std::{
-    convert::TryFrom,
-    ffi::CStr,
-    ffi::CString,
-    iter,
-    mem::size_of,
-    os::raw::{c_char, c_void},
-    ptr::{self, NonNull},
-    sync::Arc,
-};
+use std::{mem::size_of, ptr::NonNull, sync::Arc};
+
+pub use arrow_data::ffi::FFI_ArrowArray;
+pub use arrow_schema::ffi::{FFI_ArrowSchema, Flags};
 
-use bitflags::bitflags;
+use arrow_schema::UnionMode;
 
 use crate::array::{layout, ArrayData};
-use crate::buffer::Buffer;
+use crate::buffer::{Buffer, MutableBuffer};
 use crate::datatypes::DataType;
 use crate::error::{ArrowError, Result};
 use crate::util::bit_util;
 
-bitflags! {
-    pub struct Flags: i64 {
-        const DICTIONARY_ORDERED = 0b00000001;
-        const NULLABLE = 0b00000010;
-        const MAP_KEYS_SORTED = 0b00000100;
-    }
-}
-
-/// ABI-compatible struct for `ArrowSchema` from C Data Interface
-/// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
-/// This was created by bindgen
-#[repr(C)]
-#[derive(Debug)]
-pub struct FFI_ArrowSchema {
-    pub(crate) format: *const c_char,
-    pub(crate) name: *const c_char,
-    pub(crate) metadata: *const c_char,
-    pub(crate) flags: i64,
-    pub(crate) n_children: i64,
-    pub(crate) children: *mut *mut FFI_ArrowSchema,
-    pub(crate) dictionary: *mut FFI_ArrowSchema,
-    pub(crate) release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowSchema)>,
-    pub(crate) private_data: *mut c_void,
-}
-
-struct SchemaPrivateData {
-    children: Box<[*mut FFI_ArrowSchema]>,
-    dictionary: *mut FFI_ArrowSchema,
-}
-
-// callback used to drop [FFI_ArrowSchema] when it is exported.
-unsafe extern "C" fn release_schema(schema: *mut FFI_ArrowSchema) {
-    if schema.is_null() {
-        return;
-    }
-    let schema = &mut *schema;
-
-    // take ownership back to release it.
-    drop(CString::from_raw(schema.format as *mut c_char));
-    if !schema.name.is_null() {
-        drop(CString::from_raw(schema.name as *mut c_char));
-    }
-    if !schema.private_data.is_null() {
-        let private_data = Box::from_raw(schema.private_data as *mut SchemaPrivateData);
-        for child in private_data.children.iter() {
-            drop(Box::from_raw(*child))
-        }
-        if !private_data.dictionary.is_null() {
-            drop(Box::from_raw(private_data.dictionary));
-        }
-
-        drop(private_data);
-    }
-
-    schema.release = None;
-}
-
-impl FFI_ArrowSchema {
-    /// create a new [`FFI_ArrowSchema`]. This fails if the fields'
-    /// [`DataType`] is not supported.
-    pub fn try_new(
-        format: &str,
-        children: Vec<FFI_ArrowSchema>,
-        dictionary: Option<FFI_ArrowSchema>,
-    ) -> Result<Self> {
-        let mut this = Self::empty();
-
-        let children_ptr = children
-            .into_iter()
-            .map(Box::new)
-            .map(Box::into_raw)
-            .collect::<Box<_>>();
-
-        this.format = CString::new(format).unwrap().into_raw();
-        this.release = Some(release_schema);
-        this.n_children = children_ptr.len() as i64;
-
-        let dictionary_ptr = dictionary
-            .map(|d| Box::into_raw(Box::new(d)))
-            .unwrap_or(std::ptr::null_mut());
-
-        let mut private_data = Box::new(SchemaPrivateData {
-            children: children_ptr,
-            dictionary: dictionary_ptr,
-        });
-
-        // intentionally set from private_data (see https://github.com/apache/arrow-rs/issues/580)
-        this.children = private_data.children.as_mut_ptr();
-
-        this.dictionary = dictionary_ptr;
-
-        this.private_data = Box::into_raw(private_data) as *mut c_void;
-
-        Ok(this)
-    }
-
-    pub fn with_name(mut self, name: &str) -> Result<Self> {
-        self.name = CString::new(name).unwrap().into_raw();
-        Ok(self)
-    }
-
-    pub fn with_flags(mut self, flags: Flags) -> Result<Self> {
-        self.flags = flags.bits();
-        Ok(self)
-    }
-
-    pub fn empty() -> Self {
-        Self {
-            format: std::ptr::null_mut(),
-            name: std::ptr::null_mut(),
-            metadata: std::ptr::null_mut(),
-            flags: 0,
-            n_children: 0,
-            children: ptr::null_mut(),
-            dictionary: std::ptr::null_mut(),
-            release: None,
-            private_data: std::ptr::null_mut(),
-        }
-    }
-
-    /// returns the format of this schema.
-    pub fn format(&self) -> &str {
-        assert!(!self.format.is_null());
-        // safe because the lifetime of `self.format` equals `self`
-        unsafe { CStr::from_ptr(self.format) }
-            .to_str()
-            .expect("The external API has a non-utf8 as format")
-    }
-
-    /// returns the name of this schema.
-    pub fn name(&self) -> &str {
-        assert!(!self.name.is_null());
-        // safe because the lifetime of `self.name` equals `self`
-        unsafe { CStr::from_ptr(self.name) }
-            .to_str()
-            .expect("The external API has a non-utf8 as name")
-    }
-
-    pub fn flags(&self) -> Option<Flags> {
-        Flags::from_bits(self.flags)
-    }
-
-    pub fn child(&self, index: usize) -> &Self {
-        assert!(index < self.n_children as usize);
-        unsafe { self.children.add(index).as_ref().unwrap().as_ref().unwrap() }
-    }
-
-    pub fn children(&self) -> impl Iterator<Item = &Self> {
-        (0..self.n_children as usize).map(move |i| self.child(i))
-    }
-
-    pub fn nullable(&self) -> bool {
-        (self.flags / 2) & 1 == 1
-    }
-
-    pub fn dictionary(&self) -> Option<&Self> {
-        unsafe { self.dictionary.as_ref() }
-    }
-
-    pub fn map_keys_sorted(&self) -> bool {
-        self.flags & 0b00000100 != 0
-    }
-
-    pub fn dictionary_ordered(&self) -> bool {
-        self.flags & 0b00000001 != 0
-    }
-}
-
-impl Drop for FFI_ArrowSchema {
-    fn drop(&mut self) {
-        match self.release {
-            None => (),
-            Some(release) => unsafe { release(self) },
-        };
-    }
-}
-
 // returns the number of bits that buffer `i` (in the C data interface) is expected to have.
 // This is set by the Arrow specification
-#[allow(clippy::manual_bits)]
 fn bit_width(data_type: &DataType, i: usize) -> Result<usize> {
+    if let Some(primitive) = data_type.primitive_width() {
+        return match i {
+            0 => Err(ArrowError::CDataInterface(format!(
+                "The datatype \"{data_type:?}\" doesn't expect buffer at index 0. Please verify that the C data interface is correctly implemented."
+            ))),
+            1 => Ok(primitive * 8),
+            i => Err(ArrowError::CDataInterface(format!(
+                "The datatype \"{data_type:?}\" expects 2 buffers, but requested {i}. Please verify that the C data interface is correctly implemented."
+            ))),
+        };
+    }
+
     Ok(match (data_type, i) {
-        // the null buffer is bit sized
-        (_, 0) => 1,
-        // primitive types first buffer's size is given by the native types
         (DataType::Boolean, 1) => 1,
-        (DataType::UInt8, 1) => size_of::<u8>() * 8,
-        (DataType::UInt16, 1) => size_of::<u16>() * 8,
-        (DataType::UInt32, 1) => size_of::<u32>() * 8,
-        (DataType::UInt64, 1) => size_of::<u64>() * 8,
-        (DataType::Int8, 1) => size_of::<i8>() * 8,
-        (DataType::Int16, 1) => size_of::<i16>() * 8,
-        (DataType::Int32, 1) | (DataType::Date32, 1) | (DataType::Time32(_), 1) => size_of::<i32>() * 8,
-        (DataType::Int64, 1) | (DataType::Date64, 1) | (DataType::Time64(_), 1) => size_of::<i64>() * 8,
-        (DataType::Float32, 1) => size_of::<f32>() * 8,
-        (DataType::Float64, 1) => size_of::<f64>() * 8,
-        (DataType::Decimal128(..), 1) => size_of::<i128>() * 8,
-        (DataType::Timestamp(..), 1) => size_of::<i64>() * 8,
-        (DataType::Duration(..), 1) => size_of::<i64>() * 8,
-        // primitive types have a single buffer
-        (DataType::Boolean, _) |
-        (DataType::UInt8, _) |
-        (DataType::UInt16, _) |
-        (DataType::UInt32, _) |
-        (DataType::UInt64, _) |
-        (DataType::Int8, _) |
-        (DataType::Int16, _) |
-        (DataType::Int32, _) | (DataType::Date32, _) | (DataType::Time32(_), _) |
-        (DataType::Int64, _) | (DataType::Date64, _) | (DataType::Time64(_), _) |
-        (DataType::Float32, _) |
-        (DataType::Float64, _) |
-        (DataType::Decimal128(..), _) |
-        (DataType::Timestamp(..), _) |
-        (DataType::Duration(..), _) => {
+        (DataType::Boolean, _) => {
             return Err(ArrowError::CDataInterface(format!(
-                "The datatype \"{:?}\" expects 2 buffers, but requested {}. Please verify that the C data interface is correctly implemented.",
-                data_type, i
+                "The datatype \"{data_type:?}\" expects 2 buffers, but requested {i}. Please verify that the C data interface is correctly implemented."
             )))
         }
-        (DataType::FixedSizeBinary(num_bytes), 1) => size_of::<u8>() * (*num_bytes as usize) * 8,
+        (DataType::FixedSizeBinary(num_bytes), 1) => *num_bytes as usize * u8::BITS as usize,
         (DataType::FixedSizeList(f, num_elems), 1) => {
             let child_bit_width = bit_width(f.data_type(), 1)?;
             child_bit_width * (*num_elems as usize)
         },
         (DataType::FixedSizeBinary(_), _) | (DataType::FixedSizeList(_, _), _) => {
             return Err(ArrowError::CDataInterface(format!(
-                "The datatype \"{:?}\" expects 2 buffers, but requested {}. Please verify that the C data interface is correctly implemented.",
-                data_type, i
+                "The datatype \"{data_type:?}\" expects 2 buffers, but requested {i}. Please verify that the C data interface is correctly implemented."
             )))
         },
         // Variable-size list and map have one i32 buffer.
         // Variable-sized binaries: have two buffers.
         // "small": first buffer is i32, second is in bytes
-        (DataType::Utf8, 1) | (DataType::Binary, 1) | (DataType::List(_), 1) | (DataType::Map(_, _), 1) => size_of::<i32>() * 8,
-        (DataType::Utf8, 2) | (DataType::Binary, 2) => size_of::<u8>() * 8,
+        (DataType::Utf8, 1) | (DataType::Binary, 1) | (DataType::List(_), 1) | (DataType::Map(_, _), 1) => i32::BITS as _,
+        (DataType::Utf8, 2) | (DataType::Binary, 2) => u8::BITS as _,
         (DataType::List(_), _) | (DataType::Map(_, _), _) => {
             return Err(ArrowError::CDataInterface(format!(
-                "The datatype \"{:?}\" expects 2 buffers, but requested {}. Please verify that the C data interface is correctly implemented.",
-                data_type, i
+                "The datatype \"{data_type:?}\" expects 2 buffers, but requested {i}. Please verify that the C data interface is correctly implemented."
             )))
         }
         (DataType::Utf8, _) | (DataType::Binary, _) => {
             return Err(ArrowError::CDataInterface(format!(
-                "The datatype \"{:?}\" expects 3 buffers, but requested {}. Please verify that the C data interface is correctly implemented.",
-                data_type, i
+                "The datatype \"{data_type:?}\" expects 3 buffers, but requested {i}. Please verify that the C data interface is correctly implemented."
             )))
         }
         // Variable-sized binaries: have two buffers.
         // LargeUtf8: first buffer is i64, second is in bytes
-        (DataType::LargeUtf8, 1) | (DataType::LargeBinary, 1) | (DataType::LargeList(_), 1) => size_of::<i64>() * 8,
-        (DataType::LargeUtf8, 2) | (DataType::LargeBinary, 2) | (DataType::LargeList(_), 2)=> size_of::<u8>() * 8,
+        (DataType::LargeUtf8, 1) | (DataType::LargeBinary, 1) | (DataType::LargeList(_), 1) => i64::BITS as _,
+        (DataType::LargeUtf8, 2) | (DataType::LargeBinary, 2) | (DataType::LargeList(_), 2)=> u8::BITS as _,
         (DataType::LargeUtf8, _) | (DataType::LargeBinary, _) | (DataType::LargeList(_), _)=> {
             return Err(ArrowError::CDataInterface(format!(
-                "The datatype \"{:?}\" expects 3 buffers, but requested {}. Please verify that the C data interface is correctly implemented.",
-                data_type, i
+                "The datatype \"{data_type:?}\" expects 3 buffers, but requested {i}. Please verify that the C data interface is correctly implemented."
             )))
         }
-        _ => {
+        // type ids. UnionArray doesn't have null bitmap so buffer index begins with 0.
+        (DataType::Union(_, _), 0) => i8::BITS as _,
+        // Only DenseUnion has 2nd buffer
+        (DataType::Union(_, UnionMode::Dense), 1) => i32::BITS as _,
+        (DataType::Union(_, UnionMode::Sparse), _) => {
             return Err(ArrowError::CDataInterface(format!(
-                "The datatype \"{:?}\" is still not supported in Rust implementation",
-                data_type
+                "The datatype \"{data_type:?}\" expects 1 buffer, but requested {i}. Please verify that the C data interface is correctly implemented."
             )))
         }
-    })
-}
-
-/// ABI-compatible struct for ArrowArray from C Data Interface
-/// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
-/// This was created by bindgen
-#[repr(C)]
-#[derive(Debug)]
-pub struct FFI_ArrowArray {
-    pub(crate) length: i64,
-    pub(crate) null_count: i64,
-    pub(crate) offset: i64,
-    pub(crate) n_buffers: i64,
-    pub(crate) n_children: i64,
-    pub(crate) buffers: *mut *const c_void,
-    pub(crate) children: *mut *mut FFI_ArrowArray,
-    pub(crate) dictionary: *mut FFI_ArrowArray,
-    pub(crate) release: Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArray)>,
-    // When exported, this MUST contain everything that is owned by this array.
-    // for example, any buffer pointed to in `buffers` must be here, as well
-    // as the `buffers` pointer itself.
-    // In other words, everything in [FFI_ArrowArray] must be owned by
-    // `private_data` and can assume that they do not outlive `private_data`.
-    pub(crate) private_data: *mut c_void,
-}
-
-impl Drop for FFI_ArrowArray {
-    fn drop(&mut self) {
-        match self.release {
-            None => (),
-            Some(release) => unsafe { release(self) },
-        };
-    }
-}
-
-unsafe impl Send for FFI_ArrowArray {}
-unsafe impl Sync for FFI_ArrowArray {}
-
-// callback used to drop [FFI_ArrowArray] when it is exported
-unsafe extern "C" fn release_array(array: *mut FFI_ArrowArray) {
-    if array.is_null() {
-        return;
-    }
-    let array = &mut *array;
-
-    // take ownership of `private_data`, therefore dropping it`
-    let private = Box::from_raw(array.private_data as *mut ArrayPrivateData);
-    for child in private.children.iter() {
-        let _ = Box::from_raw(*child);
-    }
-    if !private.dictionary.is_null() {
-        let _ = Box::from_raw(private.dictionary);
-    }
-
-    array.release = None;
-}
-
-struct ArrayPrivateData {
-    #[allow(dead_code)]
-    buffers: Vec<Option<Buffer>>,
-    buffers_ptr: Box<[*const c_void]>,
-    children: Box<[*mut FFI_ArrowArray]>,
-    dictionary: *mut FFI_ArrowArray,
-}
-
-impl FFI_ArrowArray {
-    /// creates a new `FFI_ArrowArray` from existing data.
-    /// # Memory Leaks
-    /// This method releases `buffers`. Consumers of this struct *must* call `release` before
-    /// releasing this struct, or contents in `buffers` leak.
-    pub fn new(data: &ArrayData) -> Self {
-        // * insert the null buffer at the start
-        // * make all others `Option<Buffer>`.
-        let buffers = iter::once(data.null_buffer().cloned())
-            .chain(data.buffers().iter().map(|b| Some(b.clone())))
-            .collect::<Vec<_>>();
-        let data_layout = layout(data.data_type());
-        // `n_buffers` is the number of buffers by the spec.
-        let n_buffers = {
-            data_layout.buffers.len() + {
-                // If the layout has a null buffer by Arrow spec.
-                // Note that even the array doesn't have a null buffer because it has
-                // no null value, we still need to count 1 here to follow the spec.
-                if data_layout.can_contain_null_mask {
-                    1
-                } else {
-                    0
-                }
-            }
-        } as i64;
-
-        let buffers_ptr = buffers
-            .iter()
-            .flat_map(|maybe_buffer| match maybe_buffer {
-                // note that `raw_data` takes into account the buffer's offset
-                Some(b) => Some(b.as_ptr() as *const c_void),
-                // This is for null buffer. We only put a null pointer for
-                // null buffer if by spec it can contain null mask.
-                None if data_layout.can_contain_null_mask => Some(std::ptr::null()),
-                None => None,
-            })
-            .collect::<Box<[_]>>();
-
-        let empty = vec![];
-        let (child_data, dictionary) = match data.data_type() {
-            DataType::Dictionary(_, _) => (
-                empty.as_slice(),
-                Box::into_raw(Box::new(FFI_ArrowArray::new(&data.child_data()[0]))),
-            ),
-            _ => (data.child_data(), std::ptr::null_mut()),
-        };
-
-        let children = child_data
-            .iter()
-            .map(|child| Box::into_raw(Box::new(FFI_ArrowArray::new(child))))
-            .collect::<Box<_>>();
-        let n_children = children.len() as i64;
-
-        // create the private data owning everything.
-        // any other data must be added here, e.g. via a struct, to track lifetime.
-        let mut private_data = Box::new(ArrayPrivateData {
-            buffers,
-            buffers_ptr,
-            children,
-            dictionary,
-        });
-
-        Self {
-            length: data.len() as i64,
-            null_count: data.null_count() as i64,
-            offset: data.offset() as i64,
-            n_buffers,
-            n_children,
-            buffers: private_data.buffers_ptr.as_mut_ptr(),
-            children: private_data.children.as_mut_ptr(),
-            dictionary,
-            release: Some(release_array),
-            private_data: Box::into_raw(private_data) as *mut c_void,
+        (DataType::Union(_, UnionMode::Dense), _) => {
+            return Err(ArrowError::CDataInterface(format!(
+                "The datatype \"{data_type:?}\" expects 2 buffer, but requested {i}. Please verify that the C data interface is correctly implemented."
+            )))
         }
-    }
-
-    /// create an empty `FFI_ArrowArray`, which can be used to import data into
-    pub fn empty() -> Self {
-        Self {
-            length: 0,
-            null_count: 0,
-            offset: 0,
-            n_buffers: 0,
-            n_children: 0,
-            buffers: std::ptr::null_mut(),
-            children: std::ptr::null_mut(),
-            dictionary: std::ptr::null_mut(),
-            release: None,
-            private_data: std::ptr::null_mut(),
+        (_, 0) => {
+            // We don't call this `bit_width` to compute buffer length for null buffer. If any types that don't have null buffer like
+            // UnionArray, they should be handled above.
+            return Err(ArrowError::CDataInterface(format!(
+                "The datatype \"{data_type:?}\" doesn't expect buffer at index 0. Please verify that the C data interface is correctly implemented."
+            )))
         }
-    }
-
-    /// the length of the array
-    pub fn len(&self) -> usize {
-        self.length as usize
-    }
-
-    /// whether the array is empty
-    pub fn is_empty(&self) -> bool {
-        self.length == 0
-    }
-
-    /// the offset of the array
-    pub fn offset(&self) -> usize {
-        self.offset as usize
-    }
-
-    /// the null count of the array
-    pub fn null_count(&self) -> usize {
-        self.null_count as usize
-    }
+        _ => {
+            return Err(ArrowError::CDataInterface(format!(
+                "The datatype \"{data_type:?}\" is still not supported in Rust implementation"
+            )))
+        }
+    })
 }
 
 /// returns a new buffer corresponding to the index `i` of the FFI array. It may not exist (null pointer).
@@ -582,66 +215,92 @@ unsafe fn create_buffer(
     index: usize,
     len: usize,
 ) -> Option<Buffer> {
-    if array.buffers.is_null() {
+    if array.num_buffers() == 0 {
         return None;
     }
-    let buffers = array.buffers as *mut *const u8;
+    NonNull::new(array.buffer(index) as _)
+        .map(|ptr| Buffer::from_custom_allocation(ptr, len, owner))
+}
 
-    assert!(index < array.n_buffers as usize);
-    let ptr = *buffers.add(index);
+/// Export to the C Data Interface
+pub fn to_ffi(data: &ArrayData) -> Result<(FFI_ArrowArray, FFI_ArrowSchema)> {
+    let array = FFI_ArrowArray::new(data);
+    let schema = FFI_ArrowSchema::try_from(data.data_type())?;
+    Ok((array, schema))
+}
 
-    NonNull::new(ptr as *mut u8)
-        .map(|ptr| Buffer::from_custom_allocation(ptr, len, owner))
+/// Import [ArrayData] from the C Data Interface
+///
+/// # Safety
+///
+/// This struct assumes that the incoming data agrees with the C data interface.
+pub unsafe fn from_ffi(array: FFI_ArrowArray, schema: &FFI_ArrowSchema) -> Result<ArrayData> {
+    let dt = DataType::try_from(schema)?;
+    let array = Arc::new(array);
+    let tmp = ImportedArrowArray {
+        array: &array,
+        data_type: dt,
+        owner: &array,
+    };
+    tmp.consume()
 }
 
-fn create_child(
-    owner: Arc<FFI_ArrowArray>,
-    array: &FFI_ArrowArray,
-    schema: &FFI_ArrowSchema,
-    index: usize,
-) -> ArrowArrayChild<'static> {
-    assert!(index < array.n_children as usize);
-    assert!(!array.children.is_null());
-    assert!(!array.children.is_null());
-    unsafe {
-        let arr_ptr = *array.children.add(index);
-        let schema_ptr = *schema.children.add(index);
-        assert!(!arr_ptr.is_null());
-        assert!(!schema_ptr.is_null());
-        let arr_ptr = &*arr_ptr;
-        let schema_ptr = &*schema_ptr;
-        ArrowArrayChild::from_raw(arr_ptr, schema_ptr, owner)
-    }
+/// Import [ArrayData] from the C Data Interface
+///
+/// # Safety
+///
+/// This struct assumes that the incoming data agrees with the C data interface.
+pub unsafe fn from_ffi_and_data_type(
+    array: FFI_ArrowArray,
+    data_type: DataType,
+) -> Result<ArrayData> {
+    let array = Arc::new(array);
+    let tmp = ImportedArrowArray {
+        array: &array,
+        data_type,
+        owner: &array,
+    };
+    tmp.consume()
 }
 
-pub trait ArrowArrayRef {
-    fn to_data(&self) -> Result<ArrayData> {
-        let data_type = self.data_type()?;
-        let len = self.array().len();
-        let offset = self.array().offset();
-        let null_count = self.array().null_count();
-        let buffers = self.buffers()?;
-        let null_bit_buffer = self.null_bit_buffer();
-
-        let mut child_data: Vec<ArrayData> = (0..self.array().n_children as usize)
-            .map(|i| {
-                let child = self.child(i);
-                child.to_data()
-            })
-            .map(|d| d.unwrap())
-            .collect();
+#[derive(Debug)]
+struct ImportedArrowArray<'a> {
+    array: &'a FFI_ArrowArray,
+    data_type: DataType,
+    owner: &'a Arc<FFI_ArrowArray>,
+}
+
+impl<'a> ImportedArrowArray<'a> {
+    fn consume(self) -> Result<ArrayData> {
+        let len = self.array.len();
+        let offset = self.array.offset();
+        let null_count = match &self.data_type {
+            DataType::Null => 0,
+            _ => self.array.null_count(),
+        };
+
+        let data_layout = layout(&self.data_type);
+        let buffers = self.buffers(data_layout.can_contain_null_mask)?;
+
+        let null_bit_buffer = if data_layout.can_contain_null_mask {
+            self.null_bit_buffer()
+        } else {
+            None
+        };
+
+        let mut child_data = self.consume_children()?;
 
-        if let Some(d) = self.dictionary() {
+        if let Some(d) = self.dictionary()? {
             // For dictionary type there should only be a single child, so we don't need to worry if
             // there are other children added above.
             assert!(child_data.is_empty());
-            child_data.push(d.to_data()?);
+            child_data.push(d.consume()?);
         }
 
         // Should FFI be checking validity?
         Ok(unsafe {
             ArrayData::new_unchecked(
-                data_type,
+                self.data_type,
                 len,
                 Some(null_count),
                 null_bit_buffer,
@@ -652,38 +311,80 @@ pub trait ArrowArrayRef {
         })
     }
 
-    /// returns all buffers, as organized by Rust (i.e. null buffer is skipped)
-    fn buffers(&self) -> Result<Vec<Buffer>> {
-        (0..self.array().n_buffers - 1)
+    fn consume_children(&self) -> Result<Vec<ArrayData>> {
+        match &self.data_type {
+            DataType::List(field)
+            | DataType::FixedSizeList(field, _)
+            | DataType::LargeList(field)
+            | DataType::Map(field, _) => Ok([self.consume_child(0, field.data_type())?].to_vec()),
+            DataType::Struct(fields) => {
+                assert!(fields.len() == self.array.num_children());
+                fields
+                    .iter()
+                    .enumerate()
+                    .map(|(i, field)| self.consume_child(i, field.data_type()))
+                    .collect::<Result<Vec<_>>>()
+            }
+            DataType::Union(union_fields, _) => {
+                assert!(union_fields.len() == self.array.num_children());
+                union_fields
+                    .iter()
+                    .enumerate()
+                    .map(|(i, (_, field))| self.consume_child(i, field.data_type()))
+                    .collect::<Result<Vec<_>>>()
+            }
+            _ => Ok(Vec::new()),
+        }
+    }
+
+    fn consume_child(&self, index: usize, child_type: &DataType) -> Result<ArrayData> {
+        ImportedArrowArray {
+            array: self.array.child(index),
+            data_type: child_type.clone(),
+            owner: self.owner,
+        }
+        .consume()
+    }
+
+    /// returns all buffers, as organized by Rust (i.e. null buffer is skipped if it's present
+    /// in the spec of the type)
+    fn buffers(&self, can_contain_null_mask: bool) -> Result<Vec<Buffer>> {
+        // + 1: skip null buffer
+        let buffer_begin = can_contain_null_mask as usize;
+        (buffer_begin..self.array.num_buffers())
             .map(|index| {
-                // + 1: skip null buffer
-                let index = (index + 1) as usize;
-
-                let len = self.buffer_len(index)?;
-
-                unsafe { create_buffer(self.owner().clone(), self.array(), index, len) }
-                    .ok_or_else(|| {
-                        ArrowError::CDataInterface(format!(
-                            "The external buffer at position {} is null.",
-                            index - 1
-                        ))
-                    })
+                let len = self.buffer_len(index, &self.data_type)?;
+
+                match unsafe { create_buffer(self.owner.clone(), self.array, index, len) } {
+                    Some(buf) => Ok(buf),
+                    None if len == 0 => {
+                        // Null data buffer, which Rust doesn't allow. So create
+                        // an empty buffer.
+                        Ok(MutableBuffer::new(0).into())
+                    }
+                    None => Err(ArrowError::CDataInterface(format!(
+                        "The external buffer at position {index} is null."
+                    ))),
+                }
             })
             .collect()
     }
 
     /// Returns the length, in bytes, of the buffer `i` (indexed according to the C data interface)
-    // Rust implementation uses fixed-sized buffers, which require knowledge of their `len`.
-    // for variable-sized buffers, such as the second buffer of a stringArray, we need
-    // to fetch offset buffer's len to build the second buffer.
-    fn buffer_len(&self, i: usize) -> Result<usize> {
+    /// Rust implementation uses fixed-sized buffers, which require knowledge of their `len`.
+    /// for variable-sized buffers, such as the second buffer of a stringArray, we need
+    /// to fetch offset buffer's len to build the second buffer.
+    fn buffer_len(&self, i: usize, dt: &DataType) -> Result<usize> {
         // Special handling for dictionary type as we only care about the key type in the case.
-        let t = self.data_type()?;
-        let data_type = match &t {
+        let data_type = match dt {
             DataType::Dictionary(key_data_type, _) => key_data_type.as_ref(),
             dt => dt,
         };
 
+        // `ffi::ArrowArray` records array offset, we need to add it back to the
+        // buffer length to get the actual buffer length.
+        let length = self.array.len() + self.array.offset();
+
         // Inner type is not important for buffer length.
         Ok(match (&data_type, i) {
             (DataType::Utf8, 1)
@@ -696,36 +397,32 @@ pub trait ArrowArrayRef {
                 // the len of the offset buffer (buffer 1) equals length + 1
                 let bits = bit_width(data_type, i)?;
                 debug_assert_eq!(bits % 8, 0);
-                (self.array().length as usize + 1) * (bits / 8)
+                (length + 1) * (bits / 8)
             }
             (DataType::Utf8, 2) | (DataType::Binary, 2) => {
                 // the len of the data buffer (buffer 2) equals the last value of the offset buffer (buffer 1)
-                let len = self.buffer_len(1)?;
+                let len = self.buffer_len(1, dt)?;
                 // first buffer is the null buffer => add(1)
                 // we assume that pointer is aligned for `i32`, as Utf8 uses `i32` offsets.
                 #[allow(clippy::cast_ptr_alignment)]
-                let offset_buffer = unsafe {
-                    *(self.array().buffers as *mut *const u8).add(1) as *const i32
-                };
+                let offset_buffer = self.array.buffer(1) as *const i32;
                 // get last offset
                 (unsafe { *offset_buffer.add(len / size_of::<i32>() - 1) }) as usize
             }
             (DataType::LargeUtf8, 2) | (DataType::LargeBinary, 2) => {
                 // the len of the data buffer (buffer 2) equals the last value of the offset buffer (buffer 1)
-                let len = self.buffer_len(1)?;
+                let len = self.buffer_len(1, dt)?;
                 // first buffer is the null buffer => add(1)
                 // we assume that pointer is aligned for `i64`, as Large uses `i64` offsets.
                 #[allow(clippy::cast_ptr_alignment)]
-                let offset_buffer = unsafe {
-                    *(self.array().buffers as *mut *const u8).add(1) as *const i64
-                };
+                let offset_buffer = self.array.buffer(1) as *const i64;
                 // get last offset
                 (unsafe { *offset_buffer.add(len / size_of::<i64>() - 1) }) as usize
             }
             // buffer len of primitive types
             _ => {
                 let bits = bit_width(data_type, i)?;
-                bit_util::ceil(self.array().length as usize * bits, 8)
+                bit_util::ceil(length * bits, 8)
             }
         })
     }
@@ -735,211 +432,119 @@ pub trait ArrowArrayRef {
     /// The C Data interface's null buffer is part of the array of buffers.
     fn null_bit_buffer(&self) -> Option<Buffer> {
         // similar to `self.buffer_len(0)`, but without `Result`.
-        let buffer_len = bit_util::ceil(self.array().length as usize, 8);
-
-        unsafe { create_buffer(self.owner().clone(), self.array(), 0, buffer_len) }
-    }
-
-    fn child(&self, index: usize) -> ArrowArrayChild {
-        create_child(self.owner().clone(), self.array(), self.schema(), index)
-    }
-
-    fn owner(&self) -> &Arc<FFI_ArrowArray>;
-    fn array(&self) -> &FFI_ArrowArray;
-    fn schema(&self) -> &FFI_ArrowSchema;
-    fn data_type(&self) -> Result<DataType>;
-    fn dictionary(&self) -> Option<ArrowArrayChild> {
-        unsafe {
-            assert!(!(self.array().dictionary.is_null() ^ self.schema().dictionary.is_null()),
-                    "Dictionary should both be set or not set in FFI_ArrowArray and FFI_ArrowSchema");
-            if !self.array().dictionary.is_null() {
-                Some(ArrowArrayChild::from_raw(
-                    &*self.array().dictionary,
-                    &*self.schema().dictionary,
-                    self.owner().clone(),
-                ))
-            } else {
-                None
-            }
+        // `ffi::ArrowArray` records array offset, we need to add it back to the
+        // buffer length to get the actual buffer length.
+        let length = self.array.len() + self.array.offset();
+        let buffer_len = bit_util::ceil(length, 8);
+
+        unsafe { create_buffer(self.owner.clone(), self.array, 0, buffer_len) }
+    }
+
+    fn dictionary(&self) -> Result<Option<ImportedArrowArray>> {
+        match (self.array.dictionary(), &self.data_type) {
+            (Some(array), DataType::Dictionary(_, value_type)) => Ok(Some(ImportedArrowArray {
+                array,
+                data_type: value_type.as_ref().clone(),
+                owner: self.owner,
+            })),
+            (Some(_), _) => Err(ArrowError::CDataInterface(
+                "Got dictionary in FFI_ArrowArray for non-dictionary data type".to_string(),
+            )),
+            (None, DataType::Dictionary(_, _)) => Err(ArrowError::CDataInterface(
+                "Missing dictionary in FFI_ArrowArray for dictionary data type".to_string(),
+            )),
+            (_, _) => Ok(None),
         }
     }
 }
 
-#[allow(rustdoc::private_intra_doc_links)]
-/// Struct used to move an Array from and to the C Data Interface.
-/// Its main responsibility is to expose functionality that requires
-/// both [FFI_ArrowArray] and [FFI_ArrowSchema].
-///
-/// This struct has two main paths:
-///
-/// ## Import from the C Data Interface
-/// * [ArrowArray::empty] to allocate memory to be filled by an external call
-/// * [ArrowArray::try_from_raw] to consume two non-null allocated pointers
-/// ## Export to the C Data Interface
-/// * [ArrowArray::try_new] to create a new [ArrowArray] from Rust-specific information
-/// * [ArrowArray::into_raw] to expose two pointers for [FFI_ArrowArray] and [FFI_ArrowSchema].
-///
-/// # Safety
-/// Whoever creates this struct is responsible for releasing their resources. Specifically,
-/// consumers *must* call [ArrowArray::into_raw] and take ownership of the individual pointers,
-/// calling [FFI_ArrowArray::release] and [FFI_ArrowSchema::release] accordingly.
-///
-/// Furthermore, this struct assumes that the incoming data agrees with the C data interface.
-#[derive(Debug)]
-pub struct ArrowArray {
-    pub(crate) array: Arc<FFI_ArrowArray>,
-    pub(crate) schema: Arc<FFI_ArrowSchema>,
-}
-
-#[derive(Debug)]
-pub struct ArrowArrayChild<'a> {
-    array: &'a FFI_ArrowArray,
-    schema: &'a FFI_ArrowSchema,
-    owner: Arc<FFI_ArrowArray>,
-}
-
-impl ArrowArrayRef for ArrowArray {
-    /// the data_type as declared in the schema
-    fn data_type(&self) -> Result<DataType> {
-        DataType::try_from(self.schema.as_ref())
-    }
-
-    fn array(&self) -> &FFI_ArrowArray {
-        self.array.as_ref()
-    }
+#[cfg(test)]
+mod tests {
+    use std::collections::HashMap;
+    use std::convert::TryFrom;
+    use std::mem::ManuallyDrop;
+    use std::ptr::addr_of_mut;
 
-    fn schema(&self) -> &FFI_ArrowSchema {
-        self.schema.as_ref()
-    }
+    use arrow_array::builder::UnionBuilder;
+    use arrow_array::cast::AsArray;
+    use arrow_array::types::{Float64Type, Int32Type};
+    use arrow_array::*;
 
-    fn owner(&self) -> &Arc<FFI_ArrowArray> {
-        &self.array
-    }
-}
+    use crate::array::{
+        make_array, Array, ArrayData, BooleanArray, DictionaryArray, DurationSecondArray,
+        FixedSizeBinaryArray, FixedSizeListArray, GenericBinaryArray, GenericListArray,
+        GenericStringArray, Int32Array, MapArray, OffsetSizeTrait, Time32MillisecondArray,
+        TimestampMillisecondArray, UInt32Array,
+    };
+    use crate::compute::kernels;
+    use crate::datatypes::{Field, Int8Type};
 
-impl<'a> ArrowArrayRef for ArrowArrayChild<'a> {
-    /// the data_type as declared in the schema
-    fn data_type(&self) -> Result<DataType> {
-        DataType::try_from(self.schema)
-    }
+    use super::*;
 
-    fn array(&self) -> &FFI_ArrowArray {
-        self.array
-    }
+    #[test]
+    fn test_round_trip() {
+        // create an array natively
+        let array = Int32Array::from(vec![1, 2, 3]);
 
-    fn schema(&self) -> &FFI_ArrowSchema {
-        self.schema
-    }
+        // export it
+        let (array, schema) = to_ffi(&array.into_data()).unwrap();
 
-    fn owner(&self) -> &Arc<FFI_ArrowArray> {
-        &self.owner
-    }
-}
+        // (simulate consumer) import it
+        let array = Int32Array::from(unsafe { from_ffi(array, &schema) }.unwrap());
+        let array = kernels::numeric::add(&array, &array).unwrap();
 
-impl ArrowArray {
-    /// creates a new `ArrowArray`. This is used to export to the C Data Interface.
-    ///
-    /// # Memory Leaks
-    /// This method releases `buffers`. Consumers of this struct *must* call `release` before
-    /// releasing this struct, or contents in `buffers` leak.
-    pub fn try_new(data: ArrayData) -> Result<Self> {
-        let array = Arc::new(FFI_ArrowArray::new(&data));
-        let schema = Arc::new(FFI_ArrowSchema::try_from(data.data_type())?);
-        Ok(ArrowArray { array, schema })
+        // verify
+        assert_eq!(array.as_ref(), &Int32Array::from(vec![2, 4, 6]));
     }
 
-    /// creates a new [ArrowArray] from two pointers. Used to import from the C Data Interface.
-    /// # Safety
-    /// See safety of [ArrowArray]
-    /// Note that this function will copy the content pointed by the raw pointers. Considering
-    /// the raw pointers can be from `Arc::into_raw` or other raw pointers, users must be responsible
-    /// on managing the allocation of the structs by themselves.
-    /// # Error
-    /// Errors if any of the pointers is null
-    pub unsafe fn try_from_raw(
-        array: *const FFI_ArrowArray,
-        schema: *const FFI_ArrowSchema,
-    ) -> Result<Self> {
-        if array.is_null() || schema.is_null() {
-            return Err(ArrowError::MemoryError(
-                "At least one of the pointers passed to `try_from_raw` is null"
-                    .to_string(),
-            ));
-        };
+    #[test]
+    fn test_import() {
+        // Model receiving const pointers from an external system
 
-        let array_mut = array as *mut FFI_ArrowArray;
-        let schema_mut = schema as *mut FFI_ArrowSchema;
+        // Create an array natively
+        let data = Int32Array::from(vec![1, 2, 3]).into_data();
+        let schema = FFI_ArrowSchema::try_from(data.data_type()).unwrap();
+        let array = FFI_ArrowArray::new(&data);
 
-        let array_data = std::ptr::replace(array_mut, FFI_ArrowArray::empty());
-        let schema_data = std::ptr::replace(schema_mut, FFI_ArrowSchema::empty());
+        // Use ManuallyDrop to avoid Box:Drop recursing
+        let schema = Box::new(ManuallyDrop::new(schema));
+        let array = Box::new(ManuallyDrop::new(array));
 
-        Ok(Self {
-            array: Arc::new(array_data),
-            schema: Arc::new(schema_data),
-        })
-    }
+        let schema_ptr = &**schema as *const _;
+        let array_ptr = &**array as *const _;
 
-    /// creates a new empty [ArrowArray]. Used to import from the C Data Interface.
-    /// # Safety
-    /// See safety of [ArrowArray]
-    pub unsafe fn empty() -> Self {
-        let schema = Arc::new(FFI_ArrowSchema::empty());
-        let array = Arc::new(FFI_ArrowArray::empty());
-        ArrowArray { array, schema }
-    }
+        // We can read them back to memory
+        // SAFETY:
+        // Pointers are aligned and valid
+        let data =
+            unsafe { from_ffi(std::ptr::read(array_ptr), &std::ptr::read(schema_ptr)).unwrap() };
 
-    /// exports [ArrowArray] to the C Data Interface
-    pub fn into_raw(this: ArrowArray) -> (*const FFI_ArrowArray, *const FFI_ArrowSchema) {
-        (Arc::into_raw(this.array), Arc::into_raw(this.schema))
-    }
-}
-
-impl<'a> ArrowArrayChild<'a> {
-    fn from_raw(
-        array: &'a FFI_ArrowArray,
-        schema: &'a FFI_ArrowSchema,
-        owner: Arc<FFI_ArrowArray>,
-    ) -> Self {
-        Self {
-            array,
-            schema,
-            owner,
-        }
+        let array = Int32Array::from(data);
+        assert_eq!(array, Int32Array::from(vec![1, 2, 3]));
     }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::array::{
-        export_array_into_raw, make_array, Array, ArrayData, BooleanArray,
-        Decimal128Array, DictionaryArray, DurationSecondArray, FixedSizeBinaryArray,
-        FixedSizeListArray, GenericBinaryArray, GenericListArray, GenericStringArray,
-        Int32Array, MapArray, NullArray, OffsetSizeTrait, Time32MillisecondArray,
-        TimestampMillisecondArray, UInt32Array,
-    };
-    use crate::compute::kernels;
-    use crate::datatypes::{Field, Int8Type};
-    use std::convert::TryFrom;
 
     #[test]
-    fn test_round_trip() -> Result<()> {
+    fn test_round_trip_with_offset() -> Result<()> {
         // create an array natively
-        let array = Int32Array::from(vec![1, 2, 3]);
+        let array = Int32Array::from(vec![Some(1), Some(2), None, Some(3), None]);
+
+        let array = array.slice(1, 2);
 
         // export it
-        let array = ArrowArray::try_from(array.into_data())?;
+        let (array, schema) = to_ffi(&array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
         let array = array.as_any().downcast_ref::<Int32Array>().unwrap();
-        let array = kernels::arithmetic::add(array, array).unwrap();
+        assert_eq!(array, &Int32Array::from(vec![Some(2), None]));
+
+        let array = kernels::numeric::add(array, array).unwrap();
 
         // verify
-        assert_eq!(array, Int32Array::from(vec![2, 4, 6]));
+        assert_eq!(array.as_ref(), &Int32Array::from(vec![Some(4), None]));
 
         // (drop/release)
         Ok(())
@@ -956,10 +561,10 @@ mod tests {
             .unwrap();
 
         // export it
-        let array = ArrowArray::try_from(Array::data(&original_array).clone())?;
+        let (array, schema) = to_ffi(&original_array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -975,14 +580,13 @@ mod tests {
 
     fn test_generic_string<Offset: OffsetSizeTrait>() -> Result<()> {
         // create an array natively
-        let array =
-            GenericStringArray::<Offset>::from(vec![Some("a"), None, Some("aaa")]);
+        let array = GenericStringArray::<Offset>::from(vec![Some("a"), None, Some("aaa")]);
 
         // export it
-        let array = ArrowArray::try_from(array.into_data())?;
+        let (array, schema) = to_ffi(&array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -1021,7 +625,7 @@ mod tests {
         // Construct a value array
         let value_data = ArrayData::builder(DataType::Int32)
             .len(8)
-            .add_buffer(Buffer::from_slice_ref(&[0, 1, 2, 3, 4, 5, 6, 7]))
+            .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
             .build()
             .unwrap();
 
@@ -1033,7 +637,7 @@ mod tests {
             .collect::<Buffer>();
 
         // Construct a list array from the above two
-        let list_data_type = GenericListArray::<Offset>::DATA_TYPE_CONSTRUCTOR(Box::new(
+        let list_data_type = GenericListArray::<Offset>::DATA_TYPE_CONSTRUCTOR(Arc::new(
             Field::new("item", DataType::Int32, false),
         ));
 
@@ -1048,10 +652,10 @@ mod tests {
         let array = GenericListArray::<Offset>::from(list_data.clone());
 
         // export it
-        let array = ArrowArray::try_from(array.into_data())?;
+        let (array, schema) = to_ffi(&array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // downcast
@@ -1060,8 +664,6 @@ mod tests {
             .downcast_ref::<GenericListArray<Offset>>()
             .unwrap();
 
-        dbg!(&array);
-
         // verify
         let expected = GenericListArray::<Offset>::from(list_data);
         assert_eq!(&array.value(0), &expected.value(0));
@@ -1088,10 +690,10 @@ mod tests {
         let array = GenericBinaryArray::<Offset>::from(array);
 
         // export it
-        let array = ArrowArray::try_from(array.into_data())?;
+        let (array, schema) = to_ffi(&array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -1133,10 +735,10 @@ mod tests {
         let array = BooleanArray::from(vec![None, Some(true), Some(false)]);
 
         // export it
-        let array = ArrowArray::try_from(array.into_data())?;
+        let (array, schema) = to_ffi(&array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -1159,10 +761,10 @@ mod tests {
         let array = Time32MillisecondArray::from(vec![None, Some(1), Some(2)]);
 
         // export it
-        let array = ArrowArray::try_from(array.into_data())?;
+        let (array, schema) = to_ffi(&array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -1175,14 +777,7 @@ mod tests {
         // verify
         assert_eq!(
             array,
-            &Time32MillisecondArray::from(vec![
-                None,
-                Some(1),
-                Some(2),
-                None,
-                Some(1),
-                Some(2)
-            ])
+            &Time32MillisecondArray::from(vec![None, Some(1), Some(2), None, Some(1), Some(2)])
         );
 
         // (drop/release)
@@ -1195,10 +790,10 @@ mod tests {
         let array = TimestampMillisecondArray::from(vec![None, Some(1), Some(2)]);
 
         // export it
-        let array = ArrowArray::try_from(array.into_data())?;
+        let (array, schema) = to_ffi(&array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -1211,14 +806,7 @@ mod tests {
         // verify
         assert_eq!(
             array,
-            &TimestampMillisecondArray::from(vec![
-                None,
-                Some(1),
-                Some(2),
-                None,
-                Some(1),
-                Some(2)
-            ])
+            &TimestampMillisecondArray::from(vec![None, Some(1), Some(2), None, Some(1), Some(2)])
         );
 
         // (drop/release)
@@ -1235,13 +823,13 @@ mod tests {
             Some(vec![30, 30, 30]),
             None,
         ];
-        let array = FixedSizeBinaryArray::try_from_sparse_iter(values.into_iter())?;
+        let array = FixedSizeBinaryArray::try_from_sparse_iter_with_size(values.into_iter(), 3)?;
 
         // export it
-        let array = ArrowArray::try_from(array.into_data())?;
+        let (array, schema) = to_ffi(&array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -1254,7 +842,7 @@ mod tests {
         // verify
         assert_eq!(
             array,
-            &FixedSizeBinaryArray::try_from_sparse_iter(
+            &FixedSizeBinaryArray::try_from_sparse_iter_with_size(
                 vec![
                     None,
                     Some(vec![10, 10, 10]),
@@ -1269,7 +857,8 @@ mod tests {
                     Some(vec![30, 30, 30]),
                     None,
                 ]
-                .into_iter()
+                .into_iter(),
+                3
             )?
         );
 
@@ -1283,14 +872,14 @@ mod tests {
         let mut validity_bits: [u8; 1] = [0; 1];
         bit_util::set_bit(&mut validity_bits, 2);
 
-        let v: Vec<i32> = (0..9).into_iter().collect();
+        let v: Vec<i32> = (0..9).collect();
         let value_data = ArrayData::builder(DataType::Int32)
             .len(9)
             .add_buffer(Buffer::from_slice_ref(&v))
             .build()?;
 
         let list_data_type =
-            DataType::FixedSizeList(Box::new(Field::new("f", DataType::Int32, false)), 3);
+            DataType::FixedSizeList(Arc::new(Field::new("f", DataType::Int32, false)), 3);
         let list_data = ArrayData::builder(list_data_type.clone())
             .len(3)
             .null_bit_buffer(Some(Buffer::from(validity_bits)))
@@ -1298,10 +887,10 @@ mod tests {
             .build()?;
 
         // export it
-        let array = ArrowArray::try_from(list_data)?;
+        let (array, schema) = to_ffi(&list_data)?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -1343,10 +932,10 @@ mod tests {
         let dict_array: DictionaryArray<Int8Type> = values.into_iter().collect();
 
         // export it
-        let array = ArrowArray::try_from(dict_array.into_data())?;
+        let (array, schema) = to_ffi(&dict_array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -1366,35 +955,33 @@ mod tests {
     }
 
     #[test]
+    #[allow(deprecated)]
     fn test_export_array_into_raw() -> Result<()> {
+        use crate::array::export_array_into_raw;
         let array = make_array(Int32Array::from(vec![1, 2, 3]).into_data());
 
         // Assume two raw pointers provided by the consumer
-        let out_array = Box::new(FFI_ArrowArray::empty());
-        let out_schema = Box::new(FFI_ArrowSchema::empty());
-        let out_array_ptr = Box::into_raw(out_array);
-        let out_schema_ptr = Box::into_raw(out_schema);
-
-        unsafe {
-            export_array_into_raw(array, out_array_ptr, out_schema_ptr)?;
+        let mut out_array = FFI_ArrowArray::empty();
+        let mut out_schema = FFI_ArrowSchema::empty();
+
+        {
+            let out_array_ptr = addr_of_mut!(out_array);
+            let out_schema_ptr = addr_of_mut!(out_schema);
+            unsafe {
+                export_array_into_raw(array, out_array_ptr, out_schema_ptr)?;
+            }
         }
 
         // (simulate consumer) import it
-        unsafe {
-            let array = ArrowArray::try_from_raw(out_array_ptr, out_schema_ptr).unwrap();
-            let data = ArrayData::try_from(array)?;
-            let array = make_array(data);
-
-            // perform some operation
-            let array = array.as_any().downcast_ref::<Int32Array>().unwrap();
-            let array = kernels::arithmetic::add(array, array).unwrap();
+        let data = unsafe { from_ffi(out_array, &out_schema) }?;
+        let array = make_array(data);
 
-            // verify
-            assert_eq!(array, Int32Array::from(vec![2, 4, 6]));
+        // perform some operation
+        let array = array.as_any().downcast_ref::<Int32Array>().unwrap();
+        let array = kernels::numeric::add(array, array).unwrap();
 
-            Box::from_raw(out_array_ptr);
-            Box::from_raw(out_schema_ptr);
-        }
+        // verify
+        assert_eq!(array.as_ref(), &Int32Array::from(vec![2, 4, 6]));
         Ok(())
     }
 
@@ -1404,10 +991,10 @@ mod tests {
         let array = DurationSecondArray::from(vec![None, Some(1), Some(2)]);
 
         // export it
-        let array = ArrowArray::try_from(array.into_data())?;
+        let (array, schema) = to_ffi(&array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -1420,38 +1007,13 @@ mod tests {
         // verify
         assert_eq!(
             array,
-            &DurationSecondArray::from(vec![
-                None,
-                Some(1),
-                Some(2),
-                None,
-                Some(1),
-                Some(2)
-            ])
+            &DurationSecondArray::from(vec![None, Some(1), Some(2), None, Some(1), Some(2)])
         );
 
         // (drop/release)
         Ok(())
     }
 
-    #[test]
-    fn null_array_n_buffers() -> Result<()> {
-        let array = NullArray::new(10);
-        let data = array.data();
-
-        let ffi_array = FFI_ArrowArray::new(data);
-        assert_eq!(0, ffi_array.n_buffers);
-
-        let private_data =
-            unsafe { Box::from_raw(ffi_array.private_data as *mut ArrayPrivateData) };
-
-        assert_eq!(0, private_data.buffers_ptr.len());
-
-        Box::into_raw(private_data);
-
-        Ok(())
-    }
-
     #[test]
     fn test_map_array() -> Result<()> {
         let keys = vec!["a", "b", "c", "d", "e", "f", "g", "h"];
@@ -1461,18 +1023,15 @@ mod tests {
         //  [[a, b, c], [d, e, f], [g, h]]
         let entry_offsets = [0, 3, 6, 8];
 
-        let map_array = MapArray::new_from_strings(
-            keys.clone().into_iter(),
-            &values_data,
-            &entry_offsets,
-        )
-        .unwrap();
+        let map_array =
+            MapArray::new_from_strings(keys.clone().into_iter(), &values_data, &entry_offsets)
+                .unwrap();
 
         // export it
-        let array = ArrowArray::try_from(map_array.data().clone())?;
+        let (array, schema) = to_ffi(&map_array.to_data())?;
 
         // (simulate consumer) import it
-        let data = ArrayData::try_from(array)?;
+        let data = unsafe { from_ffi(array, &schema) }?;
         let array = make_array(data);
 
         // perform some operation
@@ -1481,4 +1040,147 @@ mod tests {
 
         Ok(())
     }
+
+    #[test]
+    fn test_struct_array() -> Result<()> {
+        let metadata: HashMap<String, String> =
+            [("Hello".to_string(), "World! 😊".to_string())].into();
+        let struct_array = StructArray::from(vec![(
+            Arc::new(Field::new("a", DataType::Int32, false).with_metadata(metadata)),
+            Arc::new(Int32Array::from(vec![2, 4, 6])) as Arc<dyn Array>,
+        )]);
+
+        // export it
+        let (array, schema) = to_ffi(&struct_array.to_data())?;
+
+        // (simulate consumer) import it
+        let data = unsafe { from_ffi(array, &schema) }?;
+        let array = make_array(data);
+
+        // perform some operation
+        let array = array.as_any().downcast_ref::<StructArray>().unwrap();
+        assert_eq!(array.data_type(), struct_array.data_type());
+        assert_eq!(array, &struct_array);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_union_sparse_array() -> Result<()> {
+        let mut builder = UnionBuilder::new_sparse();
+        builder.append::<Int32Type>("a", 1).unwrap();
+        builder.append_null::<Int32Type>("a").unwrap();
+        builder.append::<Float64Type>("c", 3.0).unwrap();
+        builder.append::<Int32Type>("a", 4).unwrap();
+        let union = builder.build().unwrap();
+
+        // export it
+        let (array, schema) = to_ffi(&union.to_data())?;
+
+        // (simulate consumer) import it
+        let data = unsafe { from_ffi(array, &schema) }?;
+        let array = make_array(data);
+
+        let array = array.as_any().downcast_ref::<UnionArray>().unwrap();
+
+        let expected_type_ids = vec![0_i8, 0, 1, 0];
+
+        // Check type ids
+        assert_eq!(*array.type_ids(), expected_type_ids);
+        for (i, id) in expected_type_ids.iter().enumerate() {
+            assert_eq!(id, &array.type_id(i));
+        }
+
+        // Check offsets, sparse union should only have a single buffer, i.e. no offsets
+        assert!(array.offsets().is_none());
+
+        for i in 0..array.len() {
+            let slot = array.value(i);
+            match i {
+                0 => {
+                    let slot = slot.as_primitive::<Int32Type>();
+                    assert!(!slot.is_null(0));
+                    assert_eq!(slot.len(), 1);
+                    let value = slot.value(0);
+                    assert_eq!(1_i32, value);
+                }
+                1 => assert!(slot.is_null(0)),
+                2 => {
+                    let slot = slot.as_primitive::<Float64Type>();
+                    assert!(!slot.is_null(0));
+                    assert_eq!(slot.len(), 1);
+                    let value = slot.value(0);
+                    assert_eq!(value, 3_f64);
+                }
+                3 => {
+                    let slot = slot.as_primitive::<Int32Type>();
+                    assert!(!slot.is_null(0));
+                    assert_eq!(slot.len(), 1);
+                    let value = slot.value(0);
+                    assert_eq!(4_i32, value);
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_union_dense_array() -> Result<()> {
+        let mut builder = UnionBuilder::new_dense();
+        builder.append::<Int32Type>("a", 1).unwrap();
+        builder.append_null::<Int32Type>("a").unwrap();
+        builder.append::<Float64Type>("c", 3.0).unwrap();
+        builder.append::<Int32Type>("a", 4).unwrap();
+        let union = builder.build().unwrap();
+
+        // export it
+        let (array, schema) = to_ffi(&union.to_data())?;
+
+        // (simulate consumer) import it
+        let data = unsafe { from_ffi(array, &schema) }?;
+        let array = UnionArray::from(data);
+
+        let expected_type_ids = vec![0_i8, 0, 1, 0];
+
+        // Check type ids
+        assert_eq!(*array.type_ids(), expected_type_ids);
+        for (i, id) in expected_type_ids.iter().enumerate() {
+            assert_eq!(id, &array.type_id(i));
+        }
+
+        assert!(array.offsets().is_some());
+
+        for i in 0..array.len() {
+            let slot = array.value(i);
+            match i {
+                0 => {
+                    let slot = slot.as_primitive::<Int32Type>();
+                    assert!(!slot.is_null(0));
+                    assert_eq!(slot.len(), 1);
+                    let value = slot.value(0);
+                    assert_eq!(1_i32, value);
+                }
+                1 => assert!(slot.is_null(0)),
+                2 => {
+                    let slot = slot.as_primitive::<Float64Type>();
+                    assert!(!slot.is_null(0));
+                    assert_eq!(slot.len(), 1);
+                    let value = slot.value(0);
+                    assert_eq!(value, 3_f64);
+                }
+                3 => {
+                    let slot = slot.as_primitive::<Int32Type>();
+                    assert!(!slot.is_null(0));
+                    assert_eq!(slot.len(), 1);
+                    let value = slot.value(0);
+                    assert_eq!(4_i32, value);
+                }
+                _ => unreachable!(),
+            }
+        }
+
+        Ok(())
+    }
 }
diff --git a/arrow/src/ffi_stream.rs b/arrow/src/ffi_stream.rs
index 3a85f2ef6421..06128a1c9984 100644
--- a/arrow/src/ffi_stream.rs
+++ b/arrow/src/ffi_stream.rs
@@ -37,29 +37,26 @@
 //! let reader = Box::new(FileReader::try_new(file).unwrap());
 //!
 //! // export it
-//! let stream = Box::new(FFI_ArrowArrayStream::empty());
-//! let stream_ptr = Box::into_raw(stream) as *mut FFI_ArrowArrayStream;
-//! unsafe { export_reader_into_raw(reader, stream_ptr) };
+//! let mut stream = FFI_ArrowArrayStream::empty();
+//! unsafe { export_reader_into_raw(reader, &mut stream) };
 //!
 //! // consumed and used by something else...
 //!
 //! // import it
-//! let stream_reader = unsafe { ArrowArrayStreamReader::from_raw(stream_ptr).unwrap() };
+//! let stream_reader = unsafe { ArrowArrayStreamReader::from_raw(&mut stream).unwrap() };
 //! let imported_schema = stream_reader.schema();
 //!
 //! let mut produced_batches = vec![];
 //! for batch in stream_reader {
 //!      produced_batches.push(batch.unwrap());
 //! }
-//!
-//! // (drop/release)
-//! unsafe {
-//!   Box::from_raw(stream_ptr);
-//! }
 //! Ok(())
 //! }
 //! ```
 
+use arrow_schema::DataType;
+use std::ffi::CStr;
+use std::ptr::addr_of;
 use std::{
     convert::TryFrom,
     ffi::CString,
@@ -87,16 +84,10 @@ const ENOSYS: i32 = 78;
 #[derive(Debug)]
 pub struct FFI_ArrowArrayStream {
     pub get_schema: Option<
-        unsafe extern "C" fn(
-            arg1: *mut FFI_ArrowArrayStream,
-            out: *mut FFI_ArrowSchema,
-        ) -> c_int,
+        unsafe extern "C" fn(arg1: *mut FFI_ArrowArrayStream, out: *mut FFI_ArrowSchema) -> c_int,
     >,
     pub get_next: Option<
-        unsafe extern "C" fn(
-            arg1: *mut FFI_ArrowArrayStream,
-            out: *mut FFI_ArrowArray,
-        ) -> c_int,
+        unsafe extern "C" fn(arg1: *mut FFI_ArrowArrayStream, out: *mut FFI_ArrowArray) -> c_int,
     >,
     pub get_last_error:
         Option<unsafe extern "C" fn(arg1: *mut FFI_ArrowArrayStream) -> *const c_char>,
@@ -104,6 +95,8 @@ pub struct FFI_ArrowArrayStream {
     pub private_data: *mut c_void,
 }
 
+unsafe impl Send for FFI_ArrowArrayStream {}
+
 // callback used to drop [FFI_ArrowArrayStream] when it is exported.
 unsafe extern "C" fn release_stream(stream: *mut FFI_ArrowArrayStream) {
     if stream.is_null() {
@@ -122,8 +115,8 @@ unsafe extern "C" fn release_stream(stream: *mut FFI_ArrowArrayStream) {
 }
 
 struct StreamPrivateData {
-    batch_reader: Box<dyn RecordBatchReader>,
-    last_error: String,
+    batch_reader: Box<dyn RecordBatchReader + Send>,
+    last_error: Option<CString>,
 }
 
 // The callback used to get array schema
@@ -145,8 +138,12 @@ unsafe extern "C" fn get_next(
 // The callback used to get the error from last operation on the `FFI_ArrowArrayStream`
 unsafe extern "C" fn get_last_error(stream: *mut FFI_ArrowArrayStream) -> *const c_char {
     let mut ffi_stream = ExportedArrayStream { stream };
-    let last_error = ffi_stream.get_last_error();
-    CString::new(last_error.as_str()).unwrap().into_raw()
+    // The consumer should not take ownership of this string, we should return
+    // a const pointer to it.
+    match ffi_stream.get_last_error() {
+        Some(err_string) => err_string.as_ptr(),
+        None => std::ptr::null(),
+    }
 }
 
 impl Drop for FFI_ArrowArrayStream {
@@ -160,10 +157,10 @@ impl Drop for FFI_ArrowArrayStream {
 
 impl FFI_ArrowArrayStream {
     /// Creates a new [`FFI_ArrowArrayStream`].
-    pub fn new(batch_reader: Box<dyn RecordBatchReader>) -> Self {
+    pub fn new(batch_reader: Box<dyn RecordBatchReader + Send>) -> Self {
         let private_data = Box::new(StreamPrivateData {
             batch_reader,
-            last_error: String::new(),
+            last_error: None,
         });
 
         Self {
@@ -175,6 +172,22 @@ impl FFI_ArrowArrayStream {
         }
     }
 
+    /// Takes ownership of the pointed to [`FFI_ArrowArrayStream`]
+    ///
+    /// This acts to [move] the data out of `raw_stream`, setting the release callback to NULL
+    ///
+    /// # Safety
+    ///
+    /// * `raw_stream` must be [valid] for reads and writes
+    /// * `raw_stream` must be properly aligned
+    /// * `raw_stream` must point to a properly initialized value of [`FFI_ArrowArrayStream`]
+    ///
+    /// [move]: https://arrow.apache.org/docs/format/CDataInterface.html#moving-an-array
+    /// [valid]: https://doc.rust-lang.org/std/ptr/index.html#safety
+    pub unsafe fn from_raw(raw_stream: *mut FFI_ArrowArrayStream) -> Self {
+        std::ptr::replace(raw_stream, Self::empty())
+    }
+
     /// Creates a new empty [FFI_ArrowArrayStream]. Used to import from the C Stream Interface.
     pub fn empty() -> Self {
         Self {
@@ -197,59 +210,56 @@ impl ExportedArrayStream {
     }
 
     pub fn get_schema(&mut self, out: *mut FFI_ArrowSchema) -> i32 {
-        let mut private_data = self.get_private_data();
+        let private_data = self.get_private_data();
         let reader = &private_data.batch_reader;
 
         let schema = FFI_ArrowSchema::try_from(reader.schema().as_ref());
 
         match schema {
-            Ok(mut schema) => unsafe {
-                std::ptr::copy(&schema as *const FFI_ArrowSchema, out, 1);
-                schema.release = None;
+            Ok(schema) => {
+                unsafe { std::ptr::copy(addr_of!(schema), out, 1) };
+                std::mem::forget(schema);
                 0
-            },
+            }
             Err(ref err) => {
-                private_data.last_error = err.to_string();
+                private_data.last_error = Some(
+                    CString::new(err.to_string()).expect("Error string has a null byte in it."),
+                );
                 get_error_code(err)
             }
         }
     }
 
     pub fn get_next(&mut self, out: *mut FFI_ArrowArray) -> i32 {
-        let mut private_data = self.get_private_data();
+        let private_data = self.get_private_data();
         let reader = &mut private_data.batch_reader;
 
-        let ret_code = match reader.next() {
+        match reader.next() {
             None => {
                 // Marks ArrowArray released to indicate reaching the end of stream.
-                unsafe {
-                    (*out).release = None;
-                }
+                unsafe { std::ptr::write(out, FFI_ArrowArray::empty()) }
                 0
             }
             Some(next_batch) => {
                 if let Ok(batch) = next_batch {
                     let struct_array = StructArray::from(batch);
-                    let mut array = FFI_ArrowArray::new(struct_array.data());
+                    let array = FFI_ArrowArray::new(&struct_array.to_data());
 
-                    unsafe {
-                        std::ptr::copy(&array as *const FFI_ArrowArray, out, 1);
-                        array.release = None;
-                        0
-                    }
+                    unsafe { std::ptr::write_unaligned(out, array) };
+                    0
                 } else {
                     let err = &next_batch.unwrap_err();
-                    private_data.last_error = err.to_string();
+                    private_data.last_error = Some(
+                        CString::new(err.to_string()).expect("Error string has a null byte in it."),
+                    );
                     get_error_code(err)
                 }
             }
-        };
-
-        ret_code
+        }
     }
 
-    pub fn get_last_error(&mut self) -> &String {
-        &self.get_private_data().last_error
+    pub fn get_last_error(&mut self) -> Option<&CString> {
+        self.get_private_data().last_error.as_ref()
     }
 }
 
@@ -257,7 +267,7 @@ fn get_error_code(err: &ArrowError) -> i32 {
     match err {
         ArrowError::NotYetImplemented(_) => ENOSYS,
         ArrowError::MemoryError(_) => ENOMEM,
-        ArrowError::IoError(_) => EIO,
+        ArrowError::IoError(_, _) => EIO,
         _ => EINVAL,
     }
 }
@@ -266,29 +276,25 @@ fn get_error_code(err: &ArrowError) -> i32 {
 /// Struct used to fetch `RecordBatch` from the C Stream Interface.
 /// Its main responsibility is to expose `RecordBatchReader` functionality
 /// that requires [FFI_ArrowArrayStream].
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ArrowArrayStreamReader {
-    stream: Arc<FFI_ArrowArrayStream>,
+    stream: FFI_ArrowArrayStream,
     schema: SchemaRef,
 }
 
 /// Gets schema from a raw pointer of `FFI_ArrowArrayStream`. This is used when constructing
 /// `ArrowArrayStreamReader` to cache schema.
 fn get_stream_schema(stream_ptr: *mut FFI_ArrowArrayStream) -> Result<SchemaRef> {
-    let empty_schema = Arc::new(FFI_ArrowSchema::empty());
-    let schema_ptr = Arc::into_raw(empty_schema) as *mut FFI_ArrowSchema;
-
-    let ret_code = unsafe { (*stream_ptr).get_schema.unwrap()(stream_ptr, schema_ptr) };
+    let mut schema = FFI_ArrowSchema::empty();
 
-    let ffi_schema = unsafe { Arc::from_raw(schema_ptr) };
+    let ret_code = unsafe { (*stream_ptr).get_schema.unwrap()(stream_ptr, &mut schema) };
 
     if ret_code == 0 {
-        let schema = Schema::try_from(ffi_schema.as_ref()).unwrap();
+        let schema = Schema::try_from(&schema)?;
         Ok(Arc::new(schema))
     } else {
         Err(ArrowError::CDataInterface(format!(
-            "Cannot get schema from input stream. Error code: {:?}",
-            ret_code
+            "Cannot get schema from input stream. Error code: {ret_code:?}"
         )))
     }
 }
@@ -297,21 +303,16 @@ impl ArrowArrayStreamReader {
     /// Creates a new `ArrowArrayStreamReader` from a `FFI_ArrowArrayStream`.
     /// This is used to import from the C Stream Interface.
     #[allow(dead_code)]
-    pub fn try_new(stream: FFI_ArrowArrayStream) -> Result<Self> {
+    pub fn try_new(mut stream: FFI_ArrowArrayStream) -> Result<Self> {
         if stream.release.is_none() {
             return Err(ArrowError::CDataInterface(
                 "input stream is already released".to_string(),
             ));
         }
 
-        let stream_ptr = Arc::into_raw(Arc::new(stream)) as *mut FFI_ArrowArrayStream;
+        let schema = get_stream_schema(&mut stream)?;
 
-        let schema = get_stream_schema(stream_ptr)?;
-
-        Ok(Self {
-            stream: unsafe { Arc::from_raw(stream_ptr) },
-            schema,
-        })
+        Ok(Self { stream, schema })
     }
 
     /// Creates a new `ArrowArrayStreamReader` from a raw pointer of `FFI_ArrowArrayStream`.
@@ -322,29 +323,23 @@ impl ArrowArrayStreamReader {
     /// the pointer.
     ///
     /// # Safety
-    /// This function dereferences a raw pointer of `FFI_ArrowArrayStream`.
+    ///
+    /// See [`FFI_ArrowArrayStream::from_raw`]
     pub unsafe fn from_raw(raw_stream: *mut FFI_ArrowArrayStream) -> Result<Self> {
-        let stream_data = std::ptr::replace(raw_stream, FFI_ArrowArrayStream::empty());
-
-        Self::try_new(stream_data)
+        Self::try_new(FFI_ArrowArrayStream::from_raw(raw_stream))
     }
 
     /// Get the last error from `ArrowArrayStreamReader`
-    fn get_stream_last_error(&self) -> Option<String> {
-        self.stream.get_last_error?;
+    fn get_stream_last_error(&mut self) -> Option<String> {
+        let get_last_error = self.stream.get_last_error?;
 
-        let stream_ptr = Arc::as_ptr(&self.stream) as *mut FFI_ArrowArrayStream;
-
-        let error_str = unsafe {
-            let c_str = self.stream.get_last_error.unwrap()(stream_ptr) as *mut c_char;
-            CString::from_raw(c_str).into_string()
-        };
-
-        if let Err(err) = error_str {
-            Some(err.to_string())
-        } else {
-            Some(error_str.unwrap())
+        let error_str = unsafe { get_last_error(&mut self.stream) };
+        if error_str.is_null() {
+            return None;
         }
+
+        let error_str = unsafe { CStr::from_ptr(error_str) };
+        Some(error_str.to_string_lossy().to_string())
     }
 }
 
@@ -352,35 +347,21 @@ impl Iterator for ArrowArrayStreamReader {
     type Item = Result<RecordBatch>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let stream_ptr = Arc::as_ptr(&self.stream) as *mut FFI_ArrowArrayStream;
-
-        let empty_array = Arc::new(FFI_ArrowArray::empty());
-        let array_ptr = Arc::into_raw(empty_array) as *mut FFI_ArrowArray;
+        let mut array = FFI_ArrowArray::empty();
 
-        let ret_code = unsafe { self.stream.get_next.unwrap()(stream_ptr, array_ptr) };
+        let ret_code = unsafe { self.stream.get_next.unwrap()(&mut self.stream, &mut array) };
 
         if ret_code == 0 {
-            let ffi_array = unsafe { Arc::from_raw(array_ptr) };
-
             // The end of stream has been reached
-            ffi_array.release?;
-
-            let schema_ref = self.schema();
-            let schema = FFI_ArrowSchema::try_from(schema_ref.as_ref()).ok()?;
-
-            let data = ArrowArray {
-                array: ffi_array,
-                schema: Arc::new(schema),
+            if array.is_released() {
+                return None;
             }
-            .to_data()
-            .ok()?;
 
-            let record_batch = RecordBatch::from(&StructArray::from(data));
-
-            Some(Ok(record_batch))
+            let result = unsafe {
+                from_ffi_and_data_type(array, DataType::Struct(self.schema().fields().clone()))
+            };
+            Some(result.map(|data| RecordBatch::from(StructArray::from(data))))
         } else {
-            unsafe { Arc::from_raw(array_ptr) };
-
             let last_error = self.get_stream_last_error();
             let err = ArrowError::CDataInterface(last_error.unwrap());
             Some(Err(err))
@@ -399,8 +380,9 @@ impl RecordBatchReader for ArrowArrayStreamReader {
 /// # Safety
 /// Assumes that the pointer represents valid C Stream Interfaces, both in memory
 /// representation and lifetime via the `release` mechanism.
+#[deprecated(note = "Use FFI_ArrowArrayStream::new")]
 pub unsafe fn export_reader_into_raw(
-    reader: Box<dyn RecordBatchReader>,
+    reader: Box<dyn RecordBatchReader + Send>,
     out_stream: *mut FFI_ArrowArrayStream,
 ) {
     let stream = FFI_ArrowArrayStream::new(reader);
@@ -410,6 +392,8 @@ pub unsafe fn export_reader_into_raw(
 
 #[cfg(test)]
 mod tests {
+    use arrow_schema::DataType;
+
     use super::*;
 
     use crate::array::Int32Array;
@@ -417,13 +401,13 @@ mod tests {
 
     struct TestRecordBatchReader {
         schema: SchemaRef,
-        iter: Box<dyn Iterator<Item = Result<RecordBatch>>>,
+        iter: Box<dyn Iterator<Item = Result<RecordBatch>> + Send>,
     }
 
     impl TestRecordBatchReader {
         pub fn new(
             schema: SchemaRef,
-            iter: Box<dyn Iterator<Item = Result<RecordBatch>>>,
+            iter: Box<dyn Iterator<Item = Result<RecordBatch>> + Send>,
         ) -> Box<TestRecordBatchReader> {
             Box::new(TestRecordBatchReader { schema, iter })
         }
@@ -455,52 +439,36 @@ mod tests {
         let reader = TestRecordBatchReader::new(schema.clone(), iter);
 
         // Export a `RecordBatchReader` through `FFI_ArrowArrayStream`
-        let stream = Arc::new(FFI_ArrowArrayStream::empty());
-        let stream_ptr = Arc::into_raw(stream) as *mut FFI_ArrowArrayStream;
-
-        unsafe { export_reader_into_raw(reader, stream_ptr) };
-
-        let empty_schema = Arc::new(FFI_ArrowSchema::empty());
-        let schema_ptr = Arc::into_raw(empty_schema) as *mut FFI_ArrowSchema;
+        let mut ffi_stream = FFI_ArrowArrayStream::new(reader);
 
         // Get schema from `FFI_ArrowArrayStream`
-        let ret_code = unsafe { get_schema(stream_ptr, schema_ptr) };
+        let mut ffi_schema = FFI_ArrowSchema::empty();
+        let ret_code = unsafe { get_schema(&mut ffi_stream, &mut ffi_schema) };
         assert_eq!(ret_code, 0);
 
-        let ffi_schema = unsafe { Arc::from_raw(schema_ptr) };
-
-        let exported_schema = Schema::try_from(ffi_schema.as_ref()).unwrap();
+        let exported_schema = Schema::try_from(&ffi_schema).unwrap();
         assert_eq!(&exported_schema, schema.as_ref());
 
         // Get array from `FFI_ArrowArrayStream`
         let mut produced_batches = vec![];
         loop {
-            let empty_array = Arc::new(FFI_ArrowArray::empty());
-            let array_ptr = Arc::into_raw(empty_array.clone()) as *mut FFI_ArrowArray;
-
-            let ret_code = unsafe { get_next(stream_ptr, array_ptr) };
+            let mut ffi_array = FFI_ArrowArray::empty();
+            let ret_code = unsafe { get_next(&mut ffi_stream, &mut ffi_array) };
             assert_eq!(ret_code, 0);
 
             // The end of stream has been reached
-            let ffi_array = unsafe { Arc::from_raw(array_ptr) };
-            if ffi_array.release.is_none() {
+            if ffi_array.is_released() {
                 break;
             }
 
-            let array = ArrowArray {
-                array: ffi_array,
-                schema: ffi_schema.clone(),
-            }
-            .to_data()
-            .unwrap();
+            let array = unsafe { from_ffi(ffi_array, &ffi_schema) }.unwrap();
 
-            let record_batch = RecordBatch::from(&StructArray::from(array));
+            let record_batch = RecordBatch::from(StructArray::from(array));
             produced_batches.push(record_batch);
         }
 
         assert_eq!(produced_batches, vec![batch.clone(), batch]);
 
-        unsafe { Arc::from_raw(stream_ptr) };
         Ok(())
     }
 
@@ -516,10 +484,8 @@ mod tests {
         let reader = TestRecordBatchReader::new(schema.clone(), iter);
 
         // Import through `FFI_ArrowArrayStream` as `ArrowArrayStreamReader`
-        let stream = Arc::new(FFI_ArrowArrayStream::new(reader));
-        let stream_ptr = Arc::into_raw(stream) as *mut FFI_ArrowArrayStream;
-        let stream_reader =
-            unsafe { ArrowArrayStreamReader::from_raw(stream_ptr).unwrap() };
+        let stream = FFI_ArrowArrayStream::new(reader);
+        let stream_reader = ArrowArrayStreamReader::try_new(stream).unwrap();
 
         let imported_schema = stream_reader.schema();
         assert_eq!(imported_schema, schema);
@@ -531,7 +497,6 @@ mod tests {
 
         assert_eq!(produced_batches, vec![batch.clone(), batch]);
 
-        unsafe { Arc::from_raw(stream_ptr) };
         Ok(())
     }
 
@@ -550,4 +515,31 @@ mod tests {
 
         _test_round_trip_import(vec![array.clone(), array.clone(), array])
     }
+
+    #[test]
+    fn test_error_import() -> Result<()> {
+        let schema = Arc::new(Schema::new(vec![Field::new("a", DataType::Int32, true)]));
+
+        let iter = Box::new(vec![Err(ArrowError::MemoryError("".to_string()))].into_iter());
+
+        let reader = TestRecordBatchReader::new(schema.clone(), iter);
+
+        // Import through `FFI_ArrowArrayStream` as `ArrowArrayStreamReader`
+        let stream = FFI_ArrowArrayStream::new(reader);
+        let stream_reader = ArrowArrayStreamReader::try_new(stream).unwrap();
+
+        let imported_schema = stream_reader.schema();
+        assert_eq!(imported_schema, schema);
+
+        let mut produced_batches = vec![];
+        for batch in stream_reader {
+            produced_batches.push(batch);
+        }
+
+        // The results should outlive the lifetime of the stream itself.
+        assert_eq!(produced_batches.len(), 1);
+        assert!(produced_batches[0].is_err());
+
+        Ok(())
+    }
 }
diff --git a/arrow/src/ipc/reader.rs b/arrow/src/ipc/reader.rs
deleted file mode 100644
index ce44d74a1a1b..000000000000
--- a/arrow/src/ipc/reader.rs
+++ /dev/null
@@ -1,1958 +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.
-
-//! Arrow IPC File and Stream Readers
-//!
-//! The `FileReader` and `StreamReader` have similar interfaces,
-//! however the `FileReader` expects a reader that supports `Seek`ing
-
-use std::collections::HashMap;
-use std::io::{BufReader, Read, Seek, SeekFrom};
-use std::sync::Arc;
-
-use crate::array::*;
-use crate::buffer::Buffer;
-use crate::compute::cast;
-use crate::datatypes::{DataType, Field, IntervalUnit, Schema, SchemaRef, UnionMode};
-use crate::error::{ArrowError, Result};
-use crate::ipc;
-use crate::record_batch::{RecordBatch, RecordBatchOptions, RecordBatchReader};
-
-use ipc::CONTINUATION_MARKER;
-use DataType::*;
-
-/// Read a buffer based on offset and length
-fn read_buffer(buf: &ipc::Buffer, a_data: &[u8]) -> Buffer {
-    let start_offset = buf.offset() as usize;
-    let end_offset = start_offset + buf.length() as usize;
-    let buf_data = &a_data[start_offset..end_offset];
-    Buffer::from(&buf_data)
-}
-
-/// Coordinates reading arrays based on data types.
-///
-/// Notes:
-/// * In the IPC format, null buffers are always set, but may be empty. We discard them if an array has 0 nulls
-/// * Numeric values inside list arrays are often stored as 64-bit values regardless of their data type size.
-///   We thus:
-///     - check if the bit width of non-64-bit numbers is 64, and
-///     - read the buffer as 64-bit (signed integer or float), and
-///     - cast the 64-bit array to the appropriate data type
-#[allow(clippy::too_many_arguments)]
-fn create_array(
-    nodes: &[ipc::FieldNode],
-    field: &Field,
-    data: &[u8],
-    buffers: &[ipc::Buffer],
-    dictionaries_by_id: &HashMap<i64, ArrayRef>,
-    mut node_index: usize,
-    mut buffer_index: usize,
-    metadata: &ipc::MetadataVersion,
-) -> Result<(ArrayRef, usize, usize)> {
-    use DataType::*;
-    let data_type = field.data_type();
-    let array = match data_type {
-        Utf8 | Binary | LargeBinary | LargeUtf8 => {
-            let array = create_primitive_array(
-                &nodes[node_index],
-                data_type,
-                buffers[buffer_index..buffer_index + 3]
-                    .iter()
-                    .map(|buf| read_buffer(buf, data))
-                    .collect(),
-            );
-            node_index += 1;
-            buffer_index += 3;
-            array
-        }
-        FixedSizeBinary(_) => {
-            let array = create_primitive_array(
-                &nodes[node_index],
-                data_type,
-                buffers[buffer_index..buffer_index + 2]
-                    .iter()
-                    .map(|buf| read_buffer(buf, data))
-                    .collect(),
-            );
-            node_index += 1;
-            buffer_index += 2;
-            array
-        }
-        List(ref list_field) | LargeList(ref list_field) | Map(ref list_field, _) => {
-            let list_node = &nodes[node_index];
-            let list_buffers: Vec<Buffer> = buffers[buffer_index..buffer_index + 2]
-                .iter()
-                .map(|buf| read_buffer(buf, data))
-                .collect();
-            node_index += 1;
-            buffer_index += 2;
-            let triple = create_array(
-                nodes,
-                list_field,
-                data,
-                buffers,
-                dictionaries_by_id,
-                node_index,
-                buffer_index,
-                metadata,
-            )?;
-            node_index = triple.1;
-            buffer_index = triple.2;
-
-            create_list_array(list_node, data_type, &list_buffers[..], triple.0)
-        }
-        FixedSizeList(ref list_field, _) => {
-            let list_node = &nodes[node_index];
-            let list_buffers: Vec<Buffer> = buffers[buffer_index..=buffer_index]
-                .iter()
-                .map(|buf| read_buffer(buf, data))
-                .collect();
-            node_index += 1;
-            buffer_index += 1;
-            let triple = create_array(
-                nodes,
-                list_field,
-                data,
-                buffers,
-                dictionaries_by_id,
-                node_index,
-                buffer_index,
-                metadata,
-            )?;
-            node_index = triple.1;
-            buffer_index = triple.2;
-
-            create_list_array(list_node, data_type, &list_buffers[..], triple.0)
-        }
-        Struct(struct_fields) => {
-            let struct_node = &nodes[node_index];
-            let null_buffer: Buffer = read_buffer(&buffers[buffer_index], data);
-            node_index += 1;
-            buffer_index += 1;
-
-            // read the arrays for each field
-            let mut struct_arrays = vec![];
-            // TODO investigate whether just knowing the number of buffers could
-            // still work
-            for struct_field in struct_fields {
-                let triple = create_array(
-                    nodes,
-                    struct_field,
-                    data,
-                    buffers,
-                    dictionaries_by_id,
-                    node_index,
-                    buffer_index,
-                    metadata,
-                )?;
-                node_index = triple.1;
-                buffer_index = triple.2;
-                struct_arrays.push((struct_field.clone(), triple.0));
-            }
-            let null_count = struct_node.null_count() as usize;
-            let struct_array = if null_count > 0 {
-                // create struct array from fields, arrays and null data
-                StructArray::from((struct_arrays, null_buffer))
-            } else {
-                StructArray::from(struct_arrays)
-            };
-            Arc::new(struct_array)
-        }
-        // Create dictionary array from RecordBatch
-        Dictionary(_, _) => {
-            let index_node = &nodes[node_index];
-            let index_buffers: Vec<Buffer> = buffers[buffer_index..buffer_index + 2]
-                .iter()
-                .map(|buf| read_buffer(buf, data))
-                .collect();
-
-            let dict_id = field.dict_id().ok_or_else(|| {
-                ArrowError::IoError(format!("Field {} does not have dict id", field))
-            })?;
-
-            let value_array = dictionaries_by_id.get(&dict_id).ok_or_else(|| {
-                ArrowError::IoError(format!(
-                    "Cannot find a dictionary batch with dict id: {}",
-                    dict_id
-                ))
-            })?;
-            node_index += 1;
-            buffer_index += 2;
-
-            create_dictionary_array(
-                index_node,
-                data_type,
-                &index_buffers[..],
-                value_array.clone(),
-            )
-        }
-        Union(fields, field_type_ids, mode) => {
-            let union_node = nodes[node_index];
-            node_index += 1;
-
-            let len = union_node.length() as usize;
-
-            // In V4, union types has validity bitmap
-            // In V5 and later, union types have no validity bitmap
-            if metadata < &ipc::MetadataVersion::V5 {
-                read_buffer(&buffers[buffer_index], data);
-                buffer_index += 1;
-            }
-
-            let type_ids: Buffer =
-                read_buffer(&buffers[buffer_index], data)[..len].into();
-
-            buffer_index += 1;
-
-            let value_offsets = match mode {
-                UnionMode::Dense => {
-                    let buffer = read_buffer(&buffers[buffer_index], data);
-                    buffer_index += 1;
-                    Some(buffer[..len * 4].into())
-                }
-                UnionMode::Sparse => None,
-            };
-
-            let mut children = vec![];
-
-            for field in fields {
-                let triple = create_array(
-                    nodes,
-                    field,
-                    data,
-                    buffers,
-                    dictionaries_by_id,
-                    node_index,
-                    buffer_index,
-                    metadata,
-                )?;
-
-                node_index = triple.1;
-                buffer_index = triple.2;
-
-                children.push((field.clone(), triple.0));
-            }
-
-            let array =
-                UnionArray::try_new(field_type_ids, type_ids, value_offsets, children)?;
-            Arc::new(array)
-        }
-        Null => {
-            let length = nodes[node_index].length();
-            let null_count = nodes[node_index].null_count();
-
-            if length != null_count {
-                return Err(ArrowError::IoError(format!(
-                    "Field {} of NullArray has unequal null_count {} and len {}",
-                    field, null_count, length
-                )));
-            }
-
-            let data = ArrayData::builder(data_type.clone())
-                .len(length as usize)
-                .offset(0)
-                .build()
-                .unwrap();
-            node_index += 1;
-            // no buffer increases
-            make_array(data)
-        }
-        _ => {
-            let array = create_primitive_array(
-                &nodes[node_index],
-                data_type,
-                buffers[buffer_index..buffer_index + 2]
-                    .iter()
-                    .map(|buf| read_buffer(buf, data))
-                    .collect(),
-            );
-            node_index += 1;
-            buffer_index += 2;
-            array
-        }
-    };
-    Ok((array, node_index, buffer_index))
-}
-
-/// Skip fields based on data types to advance `node_index` and `buffer_index`.
-/// This function should be called when doing projection in fn `read_record_batch`.
-/// The advancement logic references fn `create_array`.
-fn skip_field(
-    nodes: &[ipc::FieldNode],
-    field: &Field,
-    data: &[u8],
-    buffers: &[ipc::Buffer],
-    dictionaries_by_id: &HashMap<i64, ArrayRef>,
-    mut node_index: usize,
-    mut buffer_index: usize,
-) -> Result<(usize, usize)> {
-    use DataType::*;
-    let data_type = field.data_type();
-    match data_type {
-        Utf8 | Binary | LargeBinary | LargeUtf8 => {
-            node_index += 1;
-            buffer_index += 3;
-        }
-        FixedSizeBinary(_) => {
-            node_index += 1;
-            buffer_index += 2;
-        }
-        List(ref list_field) | LargeList(ref list_field) | Map(ref list_field, _) => {
-            node_index += 1;
-            buffer_index += 2;
-            let tuple = skip_field(
-                nodes,
-                list_field,
-                data,
-                buffers,
-                dictionaries_by_id,
-                node_index,
-                buffer_index,
-            )?;
-            node_index = tuple.0;
-            buffer_index = tuple.1;
-        }
-        FixedSizeList(ref list_field, _) => {
-            node_index += 1;
-            buffer_index += 1;
-            let tuple = skip_field(
-                nodes,
-                list_field,
-                data,
-                buffers,
-                dictionaries_by_id,
-                node_index,
-                buffer_index,
-            )?;
-            node_index = tuple.0;
-            buffer_index = tuple.1;
-        }
-        Struct(struct_fields) => {
-            node_index += 1;
-            buffer_index += 1;
-
-            // skip for each field
-            for struct_field in struct_fields {
-                let tuple = skip_field(
-                    nodes,
-                    struct_field,
-                    data,
-                    buffers,
-                    dictionaries_by_id,
-                    node_index,
-                    buffer_index,
-                )?;
-                node_index = tuple.0;
-                buffer_index = tuple.1;
-            }
-        }
-        Dictionary(_, _) => {
-            node_index += 1;
-            buffer_index += 2;
-        }
-        Union(fields, _field_type_ids, mode) => {
-            node_index += 1;
-            buffer_index += 1;
-
-            match mode {
-                UnionMode::Dense => {
-                    buffer_index += 1;
-                }
-                UnionMode::Sparse => {}
-            };
-
-            for field in fields {
-                let tuple = skip_field(
-                    nodes,
-                    field,
-                    data,
-                    buffers,
-                    dictionaries_by_id,
-                    node_index,
-                    buffer_index,
-                )?;
-
-                node_index = tuple.0;
-                buffer_index = tuple.1;
-            }
-        }
-        Null => {
-            node_index += 1;
-            // no buffer increases
-        }
-        _ => {
-            node_index += 1;
-            buffer_index += 2;
-        }
-    };
-    Ok((node_index, buffer_index))
-}
-
-/// Reads the correct number of buffers based on data type and null_count, and creates a
-/// primitive array ref
-fn create_primitive_array(
-    field_node: &ipc::FieldNode,
-    data_type: &DataType,
-    buffers: Vec<Buffer>,
-) -> ArrayRef {
-    let length = field_node.length() as usize;
-    let null_count = field_node.null_count() as usize;
-    let array_data = match data_type {
-        Utf8 | Binary | LargeBinary | LargeUtf8 => {
-            // read 3 buffers
-            ArrayData::builder(data_type.clone())
-                .len(length)
-                .buffers(buffers[1..3].to_vec())
-                .offset(0)
-                .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()))
-                .build()
-                .unwrap()
-        }
-        FixedSizeBinary(_) => {
-            // read 3 buffers
-            let builder = ArrayData::builder(data_type.clone())
-                .len(length)
-                .buffers(buffers[1..2].to_vec())
-                .offset(0)
-                .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-            unsafe { builder.build_unchecked() }
-        }
-        Int8
-        | Int16
-        | Int32
-        | UInt8
-        | UInt16
-        | UInt32
-        | Time32(_)
-        | Date32
-        | Interval(IntervalUnit::YearMonth) => {
-            if buffers[1].len() / 8 == length && length != 1 {
-                // interpret as a signed i64, and cast appropriately
-                let builder = ArrayData::builder(DataType::Int64)
-                    .len(length)
-                    .buffers(buffers[1..].to_vec())
-                    .offset(0)
-                    .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-                let data = unsafe { builder.build_unchecked() };
-                let values = Arc::new(Int64Array::from(data)) as ArrayRef;
-                // this cast is infallible, the unwrap is safe
-                let casted = cast(&values, data_type).unwrap();
-                casted.into_data()
-            } else {
-                let builder = ArrayData::builder(data_type.clone())
-                    .len(length)
-                    .buffers(buffers[1..].to_vec())
-                    .offset(0)
-                    .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-                unsafe { builder.build_unchecked() }
-            }
-        }
-        Float32 => {
-            if buffers[1].len() / 8 == length && length != 1 {
-                // interpret as a f64, and cast appropriately
-                let builder = ArrayData::builder(DataType::Float64)
-                    .len(length)
-                    .buffers(buffers[1..].to_vec())
-                    .offset(0)
-                    .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-                let data = unsafe { builder.build_unchecked() };
-                let values = Arc::new(Float64Array::from(data)) as ArrayRef;
-                // this cast is infallible, the unwrap is safe
-                let casted = cast(&values, data_type).unwrap();
-                casted.into_data()
-            } else {
-                let builder = ArrayData::builder(data_type.clone())
-                    .len(length)
-                    .buffers(buffers[1..].to_vec())
-                    .offset(0)
-                    .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-                unsafe { builder.build_unchecked() }
-            }
-        }
-        Boolean
-        | Int64
-        | UInt64
-        | Float64
-        | Time64(_)
-        | Timestamp(_, _)
-        | Date64
-        | Duration(_)
-        | Interval(IntervalUnit::DayTime)
-        | Interval(IntervalUnit::MonthDayNano) => {
-            let builder = ArrayData::builder(data_type.clone())
-                .len(length)
-                .buffers(buffers[1..].to_vec())
-                .offset(0)
-                .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-            unsafe { builder.build_unchecked() }
-        }
-        Decimal128(_, _) | Decimal256(_, _) => {
-            // read 3 buffers
-            let builder = ArrayData::builder(data_type.clone())
-                .len(length)
-                .buffers(buffers[1..2].to_vec())
-                .offset(0)
-                .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-            unsafe { builder.build_unchecked() }
-        }
-        t => panic!("Data type {:?} either unsupported or not primitive", t),
-    };
-
-    make_array(array_data)
-}
-
-/// Reads the correct number of buffers based on list type and null_count, and creates a
-/// list array ref
-fn create_list_array(
-    field_node: &ipc::FieldNode,
-    data_type: &DataType,
-    buffers: &[Buffer],
-    child_array: ArrayRef,
-) -> ArrayRef {
-    if let DataType::List(_) | DataType::LargeList(_) = *data_type {
-        let null_count = field_node.null_count() as usize;
-        let builder = ArrayData::builder(data_type.clone())
-            .len(field_node.length() as usize)
-            .buffers(buffers[1..2].to_vec())
-            .offset(0)
-            .child_data(vec![child_array.into_data()])
-            .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-        make_array(unsafe { builder.build_unchecked() })
-    } else if let DataType::FixedSizeList(_, _) = *data_type {
-        let null_count = field_node.null_count() as usize;
-        let builder = ArrayData::builder(data_type.clone())
-            .len(field_node.length() as usize)
-            .buffers(buffers[1..1].to_vec())
-            .offset(0)
-            .child_data(vec![child_array.into_data()])
-            .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-        make_array(unsafe { builder.build_unchecked() })
-    } else if let DataType::Map(_, _) = *data_type {
-        let null_count = field_node.null_count() as usize;
-        let builder = ArrayData::builder(data_type.clone())
-            .len(field_node.length() as usize)
-            .buffers(buffers[1..2].to_vec())
-            .offset(0)
-            .child_data(vec![child_array.into_data()])
-            .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-        make_array(unsafe { builder.build_unchecked() })
-    } else {
-        panic!("Cannot create list or map array from {:?}", data_type)
-    }
-}
-
-/// Reads the correct number of buffers based on list type and null_count, and creates a
-/// list array ref
-fn create_dictionary_array(
-    field_node: &ipc::FieldNode,
-    data_type: &DataType,
-    buffers: &[Buffer],
-    value_array: ArrayRef,
-) -> ArrayRef {
-    if let DataType::Dictionary(_, _) = *data_type {
-        let null_count = field_node.null_count() as usize;
-        let builder = ArrayData::builder(data_type.clone())
-            .len(field_node.length() as usize)
-            .buffers(buffers[1..2].to_vec())
-            .offset(0)
-            .child_data(vec![value_array.into_data()])
-            .null_bit_buffer((null_count > 0).then(|| buffers[0].clone()));
-
-        make_array(unsafe { builder.build_unchecked() })
-    } else {
-        unreachable!("Cannot create dictionary array from {:?}", data_type)
-    }
-}
-
-/// Creates a record batch from binary data using the `ipc::RecordBatch` indexes and the `Schema`
-pub fn read_record_batch(
-    buf: &[u8],
-    batch: ipc::RecordBatch,
-    schema: SchemaRef,
-    dictionaries_by_id: &HashMap<i64, ArrayRef>,
-    projection: Option<&[usize]>,
-    metadata: &ipc::MetadataVersion,
-) -> Result<RecordBatch> {
-    let buffers = batch.buffers().ok_or_else(|| {
-        ArrowError::IoError("Unable to get buffers from IPC RecordBatch".to_string())
-    })?;
-    let field_nodes = batch.nodes().ok_or_else(|| {
-        ArrowError::IoError("Unable to get field nodes from IPC RecordBatch".to_string())
-    })?;
-    // keep track of buffer and node index, the functions that create arrays mutate these
-    let mut buffer_index = 0;
-    let mut node_index = 0;
-    let mut arrays = vec![];
-
-    let options = RecordBatchOptions {
-        row_count: Some(batch.length() as usize),
-        ..Default::default()
-    };
-
-    if let Some(projection) = projection {
-        // project fields
-        for (idx, field) in schema.fields().iter().enumerate() {
-            // Create array for projected field
-            if projection.contains(&idx) {
-                let triple = create_array(
-                    field_nodes,
-                    field,
-                    buf,
-                    buffers,
-                    dictionaries_by_id,
-                    node_index,
-                    buffer_index,
-                    metadata,
-                )?;
-                node_index = triple.1;
-                buffer_index = triple.2;
-                arrays.push(triple.0);
-            } else {
-                // Skip field.
-                // This must be called to advance `node_index` and `buffer_index`.
-                let tuple = skip_field(
-                    field_nodes,
-                    field,
-                    buf,
-                    buffers,
-                    dictionaries_by_id,
-                    node_index,
-                    buffer_index,
-                )?;
-                node_index = tuple.0;
-                buffer_index = tuple.1;
-            }
-        }
-
-        RecordBatch::try_new_with_options(
-            Arc::new(schema.project(projection)?),
-            arrays,
-            &options,
-        )
-    } else {
-        // keep track of index as lists require more than one node
-        for field in schema.fields() {
-            let triple = create_array(
-                field_nodes,
-                field,
-                buf,
-                buffers,
-                dictionaries_by_id,
-                node_index,
-                buffer_index,
-                metadata,
-            )?;
-            node_index = triple.1;
-            buffer_index = triple.2;
-            arrays.push(triple.0);
-        }
-        RecordBatch::try_new_with_options(schema, arrays, &options)
-    }
-}
-
-/// Read the dictionary from the buffer and provided metadata,
-/// updating the `dictionaries_by_id` with the resulting dictionary
-pub fn read_dictionary(
-    buf: &[u8],
-    batch: ipc::DictionaryBatch,
-    schema: &Schema,
-    dictionaries_by_id: &mut HashMap<i64, ArrayRef>,
-    metadata: &ipc::MetadataVersion,
-) -> Result<()> {
-    if batch.isDelta() {
-        return Err(ArrowError::IoError(
-            "delta dictionary batches not supported".to_string(),
-        ));
-    }
-
-    let id = batch.id();
-    let fields_using_this_dictionary = schema.fields_with_dict_id(id);
-    let first_field = fields_using_this_dictionary.first().ok_or_else(|| {
-        ArrowError::InvalidArgumentError("dictionary id not found in schema".to_string())
-    })?;
-
-    // As the dictionary batch does not contain the type of the
-    // values array, we need to retrieve this from the schema.
-    // Get an array representing this dictionary's values.
-    let dictionary_values: ArrayRef = match first_field.data_type() {
-        DataType::Dictionary(_, ref value_type) => {
-            // Make a fake schema for the dictionary batch.
-            let schema = Schema {
-                fields: vec![Field::new("", value_type.as_ref().clone(), true)],
-                metadata: HashMap::new(),
-            };
-            // Read a single column
-            let record_batch = read_record_batch(
-                buf,
-                batch.data().unwrap(),
-                Arc::new(schema),
-                dictionaries_by_id,
-                None,
-                metadata,
-            )?;
-            Some(record_batch.column(0).clone())
-        }
-        _ => None,
-    }
-    .ok_or_else(|| {
-        ArrowError::InvalidArgumentError("dictionary id not found in schema".to_string())
-    })?;
-
-    // We don't currently record the isOrdered field. This could be general
-    // attributes of arrays.
-    // Add (possibly multiple) array refs to the dictionaries array.
-    dictionaries_by_id.insert(id, dictionary_values.clone());
-
-    Ok(())
-}
-
-/// Arrow File reader
-pub struct FileReader<R: Read + Seek> {
-    /// Buffered file reader that supports reading and seeking
-    reader: BufReader<R>,
-
-    /// The schema that is read from the file header
-    schema: SchemaRef,
-
-    /// The blocks in the file
-    ///
-    /// A block indicates the regions in the file to read to get data
-    blocks: Vec<ipc::Block>,
-
-    /// A counter to keep track of the current block that should be read
-    current_block: usize,
-
-    /// The total number of blocks, which may contain record batches and other types
-    total_blocks: usize,
-
-    /// Optional dictionaries for each schema field.
-    ///
-    /// Dictionaries may be appended to in the streaming format.
-    dictionaries_by_id: HashMap<i64, ArrayRef>,
-
-    /// Metadata version
-    metadata_version: ipc::MetadataVersion,
-
-    /// Optional projection and projected_schema
-    projection: Option<(Vec<usize>, Schema)>,
-}
-
-impl<R: Read + Seek> FileReader<R> {
-    /// Try to create a new file reader
-    ///
-    /// Returns errors if the file does not meet the Arrow Format header and footer
-    /// requirements
-    pub fn try_new(reader: R, projection: Option<Vec<usize>>) -> Result<Self> {
-        let mut reader = BufReader::new(reader);
-        // check if header and footer contain correct magic bytes
-        let mut magic_buffer: [u8; 6] = [0; 6];
-        reader.read_exact(&mut magic_buffer)?;
-        if magic_buffer != super::ARROW_MAGIC {
-            return Err(ArrowError::IoError(
-                "Arrow file does not contain correct header".to_string(),
-            ));
-        }
-        reader.seek(SeekFrom::End(-6))?;
-        reader.read_exact(&mut magic_buffer)?;
-        if magic_buffer != super::ARROW_MAGIC {
-            return Err(ArrowError::IoError(
-                "Arrow file does not contain correct footer".to_string(),
-            ));
-        }
-        // read footer length
-        let mut footer_size: [u8; 4] = [0; 4];
-        reader.seek(SeekFrom::End(-10))?;
-        reader.read_exact(&mut footer_size)?;
-        let footer_len = i32::from_le_bytes(footer_size);
-
-        // read footer
-        let mut footer_data = vec![0; footer_len as usize];
-        reader.seek(SeekFrom::End(-10 - footer_len as i64))?;
-        reader.read_exact(&mut footer_data)?;
-
-        let footer = ipc::root_as_footer(&footer_data[..]).map_err(|err| {
-            ArrowError::IoError(format!("Unable to get root as footer: {:?}", err))
-        })?;
-
-        let blocks = footer.recordBatches().ok_or_else(|| {
-            ArrowError::IoError(
-                "Unable to get record batches from IPC Footer".to_string(),
-            )
-        })?;
-
-        let total_blocks = blocks.len();
-
-        let ipc_schema = footer.schema().unwrap();
-        let schema = ipc::convert::fb_to_schema(ipc_schema);
-
-        // Create an array of optional dictionary value arrays, one per field.
-        let mut dictionaries_by_id = HashMap::new();
-        if let Some(dictionaries) = footer.dictionaries() {
-            for block in dictionaries {
-                // read length from end of offset
-                let mut message_size: [u8; 4] = [0; 4];
-                reader.seek(SeekFrom::Start(block.offset() as u64))?;
-                reader.read_exact(&mut message_size)?;
-                if message_size == CONTINUATION_MARKER {
-                    reader.read_exact(&mut message_size)?;
-                }
-                let footer_len = i32::from_le_bytes(message_size);
-                let mut block_data = vec![0; footer_len as usize];
-
-                reader.read_exact(&mut block_data)?;
-
-                let message = ipc::root_as_message(&block_data[..]).map_err(|err| {
-                    ArrowError::IoError(format!(
-                        "Unable to get root as message: {:?}",
-                        err
-                    ))
-                })?;
-
-                match message.header_type() {
-                    ipc::MessageHeader::DictionaryBatch => {
-                        let batch = message.header_as_dictionary_batch().unwrap();
-
-                        // read the block that makes up the dictionary batch into a buffer
-                        let mut buf = vec![0; block.bodyLength() as usize];
-                        reader.seek(SeekFrom::Start(
-                            block.offset() as u64 + block.metaDataLength() as u64,
-                        ))?;
-                        reader.read_exact(&mut buf)?;
-
-                        read_dictionary(
-                            &buf,
-                            batch,
-                            &schema,
-                            &mut dictionaries_by_id,
-                            &message.version(),
-                        )?;
-                    }
-                    t => {
-                        return Err(ArrowError::IoError(format!(
-                            "Expecting DictionaryBatch in dictionary blocks, found {:?}.",
-                            t
-                        )));
-                    }
-                }
-            }
-        }
-        let projection = match projection {
-            Some(projection_indices) => {
-                let schema = schema.project(&projection_indices)?;
-                Some((projection_indices, schema))
-            }
-            _ => None,
-        };
-
-        Ok(Self {
-            reader,
-            schema: Arc::new(schema),
-            blocks: blocks.to_vec(),
-            current_block: 0,
-            total_blocks,
-            dictionaries_by_id,
-            metadata_version: footer.version(),
-            projection,
-        })
-    }
-
-    /// Return the number of batches in the file
-    pub fn num_batches(&self) -> usize {
-        self.total_blocks
-    }
-
-    /// Return the schema of the file
-    pub fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    /// Read a specific record batch
-    ///
-    /// Sets the current block to the index, allowing random reads
-    pub fn set_index(&mut self, index: usize) -> Result<()> {
-        if index >= self.total_blocks {
-            Err(ArrowError::IoError(format!(
-                "Cannot set batch to index {} from {} total batches",
-                index, self.total_blocks
-            )))
-        } else {
-            self.current_block = index;
-            Ok(())
-        }
-    }
-
-    fn maybe_next(&mut self) -> Result<Option<RecordBatch>> {
-        let block = self.blocks[self.current_block];
-        self.current_block += 1;
-
-        // read length
-        self.reader.seek(SeekFrom::Start(block.offset() as u64))?;
-        let mut meta_buf = [0; 4];
-        self.reader.read_exact(&mut meta_buf)?;
-        if meta_buf == CONTINUATION_MARKER {
-            // continuation marker encountered, read message next
-            self.reader.read_exact(&mut meta_buf)?;
-        }
-        let meta_len = i32::from_le_bytes(meta_buf);
-
-        let mut block_data = vec![0; meta_len as usize];
-        self.reader.read_exact(&mut block_data)?;
-
-        let message = ipc::root_as_message(&block_data[..]).map_err(|err| {
-            ArrowError::IoError(format!("Unable to get root as footer: {:?}", err))
-        })?;
-
-        // some old test data's footer metadata is not set, so we account for that
-        if self.metadata_version != ipc::MetadataVersion::V1
-            && message.version() != self.metadata_version
-        {
-            return Err(ArrowError::IoError(
-                "Could not read IPC message as metadata versions mismatch".to_string(),
-            ));
-        }
-
-        match message.header_type() {
-            ipc::MessageHeader::Schema => Err(ArrowError::IoError(
-                "Not expecting a schema when messages are read".to_string(),
-            )),
-            ipc::MessageHeader::RecordBatch => {
-                let batch = message.header_as_record_batch().ok_or_else(|| {
-                    ArrowError::IoError(
-                        "Unable to read IPC message as record batch".to_string(),
-                    )
-                })?;
-                // read the block that makes up the record batch into a buffer
-                let mut buf = vec![0; block.bodyLength() as usize];
-                self.reader.seek(SeekFrom::Start(
-                    block.offset() as u64 + block.metaDataLength() as u64,
-                ))?;
-                self.reader.read_exact(&mut buf)?;
-
-                read_record_batch(
-                    &buf,
-                    batch,
-                    self.schema(),
-                    &self.dictionaries_by_id,
-                    self.projection.as_ref().map(|x| x.0.as_ref()),
-                    &message.version()
-
-                ).map(Some)
-            }
-            ipc::MessageHeader::NONE => {
-                Ok(None)
-            }
-            t => Err(ArrowError::IoError(format!(
-                "Reading types other than record batches not yet supported, unable to read {:?}", t
-            ))),
-        }
-    }
-}
-
-impl<R: Read + Seek> Iterator for FileReader<R> {
-    type Item = Result<RecordBatch>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        // get current block
-        if self.current_block < self.total_blocks {
-            self.maybe_next().transpose()
-        } else {
-            None
-        }
-    }
-}
-
-impl<R: Read + Seek> RecordBatchReader for FileReader<R> {
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-}
-
-/// Arrow Stream reader
-pub struct StreamReader<R: Read> {
-    /// Buffered stream reader
-    reader: BufReader<R>,
-
-    /// The schema that is read from the stream's first message
-    schema: SchemaRef,
-
-    /// Optional dictionaries for each schema field.
-    ///
-    /// Dictionaries may be appended to in the streaming format.
-    dictionaries_by_id: HashMap<i64, ArrayRef>,
-
-    /// An indicator of whether the stream is complete.
-    ///
-    /// This value is set to `true` the first time the reader's `next()` returns `None`.
-    finished: bool,
-
-    /// Optional projection
-    projection: Option<(Vec<usize>, Schema)>,
-}
-
-impl<R: Read> StreamReader<R> {
-    /// Try to create a new stream reader
-    ///
-    /// The first message in the stream is the schema, the reader will fail if it does not
-    /// encounter a schema.
-    /// To check if the reader is done, use `is_finished(self)`
-    pub fn try_new(reader: R, projection: Option<Vec<usize>>) -> Result<Self> {
-        let mut reader = BufReader::new(reader);
-        // determine metadata length
-        let mut meta_size: [u8; 4] = [0; 4];
-        reader.read_exact(&mut meta_size)?;
-        let meta_len = {
-            // If a continuation marker is encountered, skip over it and read
-            // the size from the next four bytes.
-            if meta_size == CONTINUATION_MARKER {
-                reader.read_exact(&mut meta_size)?;
-            }
-            i32::from_le_bytes(meta_size)
-        };
-
-        let mut meta_buffer = vec![0; meta_len as usize];
-        reader.read_exact(&mut meta_buffer)?;
-
-        let message = ipc::root_as_message(meta_buffer.as_slice()).map_err(|err| {
-            ArrowError::IoError(format!("Unable to get root as message: {:?}", err))
-        })?;
-        // message header is a Schema, so read it
-        let ipc_schema: ipc::Schema = message.header_as_schema().ok_or_else(|| {
-            ArrowError::IoError("Unable to read IPC message as schema".to_string())
-        })?;
-        let schema = ipc::convert::fb_to_schema(ipc_schema);
-
-        // Create an array of optional dictionary value arrays, one per field.
-        let dictionaries_by_id = HashMap::new();
-
-        let projection = match projection {
-            Some(projection_indices) => {
-                let schema = schema.project(&projection_indices)?;
-                Some((projection_indices, schema))
-            }
-            _ => None,
-        };
-        Ok(Self {
-            reader,
-            schema: Arc::new(schema),
-            finished: false,
-            dictionaries_by_id,
-            projection,
-        })
-    }
-
-    /// Return the schema of the stream
-    pub fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-
-    /// Check if the stream is finished
-    pub fn is_finished(&self) -> bool {
-        self.finished
-    }
-
-    fn maybe_next(&mut self) -> Result<Option<RecordBatch>> {
-        if self.finished {
-            return Ok(None);
-        }
-        // determine metadata length
-        let mut meta_size: [u8; 4] = [0; 4];
-
-        match self.reader.read_exact(&mut meta_size) {
-            Ok(()) => (),
-            Err(e) => {
-                return if e.kind() == std::io::ErrorKind::UnexpectedEof {
-                    // Handle EOF without the "0xFFFFFFFF 0x00000000"
-                    // valid according to:
-                    // https://arrow.apache.org/docs/format/Columnar.html#ipc-streaming-format
-                    self.finished = true;
-                    Ok(None)
-                } else {
-                    Err(ArrowError::from(e))
-                };
-            }
-        }
-
-        let meta_len = {
-            // If a continuation marker is encountered, skip over it and read
-            // the size from the next four bytes.
-            if meta_size == CONTINUATION_MARKER {
-                self.reader.read_exact(&mut meta_size)?;
-            }
-            i32::from_le_bytes(meta_size)
-        };
-
-        if meta_len == 0 {
-            // the stream has ended, mark the reader as finished
-            self.finished = true;
-            return Ok(None);
-        }
-
-        let mut meta_buffer = vec![0; meta_len as usize];
-        self.reader.read_exact(&mut meta_buffer)?;
-
-        let vecs = &meta_buffer.to_vec();
-        let message = ipc::root_as_message(vecs).map_err(|err| {
-            ArrowError::IoError(format!("Unable to get root as message: {:?}", err))
-        })?;
-
-        match message.header_type() {
-            ipc::MessageHeader::Schema => Err(ArrowError::IoError(
-                "Not expecting a schema when messages are read".to_string(),
-            )),
-            ipc::MessageHeader::RecordBatch => {
-                let batch = message.header_as_record_batch().ok_or_else(|| {
-                    ArrowError::IoError(
-                        "Unable to read IPC message as record batch".to_string(),
-                    )
-                })?;
-                // read the block that makes up the record batch into a buffer
-                let mut buf = vec![0; message.bodyLength() as usize];
-                self.reader.read_exact(&mut buf)?;
-
-                read_record_batch(&buf, batch, self.schema(), &self.dictionaries_by_id, self.projection.as_ref().map(|x| x.0.as_ref()), &message.version()).map(Some)
-            }
-            ipc::MessageHeader::DictionaryBatch => {
-                let batch = message.header_as_dictionary_batch().ok_or_else(|| {
-                    ArrowError::IoError(
-                        "Unable to read IPC message as dictionary batch".to_string(),
-                    )
-                })?;
-                // read the block that makes up the dictionary batch into a buffer
-                let mut buf = vec![0; message.bodyLength() as usize];
-                self.reader.read_exact(&mut buf)?;
-
-                read_dictionary(
-                    &buf, batch, &self.schema, &mut self.dictionaries_by_id, &message.version()
-                )?;
-
-                // read the next message until we encounter a RecordBatch
-                self.maybe_next()
-            }
-            ipc::MessageHeader::NONE => {
-                Ok(None)
-            }
-            t => Err(ArrowError::IoError(
-                format!("Reading types other than record batches not yet supported, unable to read {:?} ", t)
-            )),
-        }
-    }
-}
-
-impl<R: Read> Iterator for StreamReader<R> {
-    type Item = Result<RecordBatch>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.maybe_next().transpose()
-    }
-}
-
-impl<R: Read> RecordBatchReader for StreamReader<R> {
-    fn schema(&self) -> SchemaRef {
-        self.schema.clone()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use std::fs::File;
-
-    use flate2::read::GzDecoder;
-
-    use crate::datatypes::{ArrowNativeType, Float64Type, Int32Type, Int8Type};
-    use crate::{datatypes, util::integration_util::*};
-
-    #[test]
-    #[cfg(not(feature = "force_validate"))]
-    fn read_generated_files_014() {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let version = "0.14.1";
-        // the test is repetitive, thus we can read all supported files at once
-        let paths = vec![
-            "generated_interval",
-            "generated_datetime",
-            "generated_dictionary",
-            "generated_map",
-            "generated_nested",
-            "generated_primitive_no_batches",
-            "generated_primitive_zerolength",
-            "generated_primitive",
-            "generated_decimal",
-        ];
-        paths.iter().for_each(|path| {
-            let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/{}/{}.arrow_file",
-                testdata, version, path
-            ))
-            .unwrap();
-
-            let mut reader = FileReader::try_new(file, None).unwrap();
-
-            // read expected JSON output
-            let arrow_json = read_gzip_json(version, path);
-            assert!(arrow_json.equals_reader(&mut reader).unwrap());
-        });
-    }
-
-    #[test]
-    #[should_panic(expected = "Big Endian is not supported for Decimal!")]
-    fn read_decimal_be_file_should_panic() {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/1.0.0-bigendian/generated_decimal.arrow_file",
-                testdata
-            ))
-            .unwrap();
-        FileReader::try_new(file, None).unwrap();
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "Last offset 687865856 of Utf8 is larger than values length 41"
-    )]
-    fn read_dictionary_be_not_implemented() {
-        // The offsets are not translated for big-endian files
-        // https://github.com/apache/arrow-rs/issues/859
-        let testdata = crate::util::test_util::arrow_test_data();
-        let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/1.0.0-bigendian/generated_dictionary.arrow_file",
-                testdata
-            ))
-            .unwrap();
-        FileReader::try_new(file, None).unwrap();
-    }
-
-    #[test]
-    fn read_generated_be_files_should_work() {
-        // complementary to the previous test
-        let testdata = crate::util::test_util::arrow_test_data();
-        let paths = vec![
-            "generated_interval",
-            "generated_datetime",
-            "generated_map",
-            "generated_nested",
-            "generated_null_trivial",
-            "generated_null",
-            "generated_primitive_no_batches",
-            "generated_primitive_zerolength",
-            "generated_primitive",
-        ];
-        paths.iter().for_each(|path| {
-            let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/1.0.0-bigendian/{}.arrow_file",
-                testdata, path
-            ))
-            .unwrap();
-
-            FileReader::try_new(file, None).unwrap();
-        });
-    }
-
-    #[test]
-    fn projection_should_work() {
-        // complementary to the previous test
-        let testdata = crate::util::test_util::arrow_test_data();
-        let paths = vec![
-            "generated_interval",
-            "generated_datetime",
-            "generated_map",
-            "generated_nested",
-            "generated_null_trivial",
-            "generated_null",
-            "generated_primitive_no_batches",
-            "generated_primitive_zerolength",
-            "generated_primitive",
-        ];
-        paths.iter().for_each(|path| {
-            // We must use littleendian files here.
-            // The offsets are not translated for big-endian files
-            // https://github.com/apache/arrow-rs/issues/859
-            let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/1.0.0-littleendian/{}.arrow_file",
-                testdata, path
-            ))
-            .unwrap();
-
-            let reader = FileReader::try_new(file, Some(vec![0])).unwrap();
-            let datatype_0 = reader.schema().fields()[0].data_type().clone();
-            reader.for_each(|batch| {
-                let batch = batch.unwrap();
-                assert_eq!(batch.columns().len(), 1);
-                assert_eq!(datatype_0, batch.schema().fields()[0].data_type().clone());
-            });
-        });
-    }
-
-    #[test]
-    #[cfg(not(feature = "force_validate"))]
-    fn read_generated_streams_014() {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let version = "0.14.1";
-        // the test is repetitive, thus we can read all supported files at once
-        let paths = vec![
-            "generated_interval",
-            "generated_datetime",
-            "generated_dictionary",
-            "generated_map",
-            "generated_nested",
-            "generated_primitive_no_batches",
-            "generated_primitive_zerolength",
-            "generated_primitive",
-            "generated_decimal",
-        ];
-        paths.iter().for_each(|path| {
-            let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/{}/{}.stream",
-                testdata, version, path
-            ))
-            .unwrap();
-
-            let mut reader = StreamReader::try_new(file, None).unwrap();
-
-            // read expected JSON output
-            let arrow_json = read_gzip_json(version, path);
-            assert!(arrow_json.equals_reader(&mut reader).unwrap());
-            // the next batch must be empty
-            assert!(reader.next().is_none());
-            // the stream must indicate that it's finished
-            assert!(reader.is_finished());
-        });
-    }
-
-    #[test]
-    fn read_generated_files_100() {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let version = "1.0.0-littleendian";
-        // the test is repetitive, thus we can read all supported files at once
-        let paths = vec![
-            "generated_interval",
-            "generated_datetime",
-            "generated_dictionary",
-            "generated_map",
-            // "generated_map_non_canonical",
-            "generated_nested",
-            "generated_null_trivial",
-            "generated_null",
-            "generated_primitive_no_batches",
-            "generated_primitive_zerolength",
-            "generated_primitive",
-        ];
-        paths.iter().for_each(|path| {
-            let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/{}/{}.arrow_file",
-                testdata, version, path
-            ))
-            .unwrap();
-
-            let mut reader = FileReader::try_new(file, None).unwrap();
-
-            // read expected JSON output
-            let arrow_json = read_gzip_json(version, path);
-            assert!(arrow_json.equals_reader(&mut reader).unwrap());
-        });
-    }
-
-    #[test]
-    fn read_generated_streams_100() {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let version = "1.0.0-littleendian";
-        // the test is repetitive, thus we can read all supported files at once
-        let paths = vec![
-            "generated_interval",
-            "generated_datetime",
-            "generated_dictionary",
-            "generated_map",
-            // "generated_map_non_canonical",
-            "generated_nested",
-            "generated_null_trivial",
-            "generated_null",
-            "generated_primitive_no_batches",
-            "generated_primitive_zerolength",
-            "generated_primitive",
-        ];
-        paths.iter().for_each(|path| {
-            let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/{}/{}.stream",
-                testdata, version, path
-            ))
-            .unwrap();
-
-            let mut reader = StreamReader::try_new(file, None).unwrap();
-
-            // read expected JSON output
-            let arrow_json = read_gzip_json(version, path);
-            assert!(arrow_json.equals_reader(&mut reader).unwrap());
-            // the next batch must be empty
-            assert!(reader.next().is_none());
-            // the stream must indicate that it's finished
-            assert!(reader.is_finished());
-        });
-    }
-
-    fn create_test_projection_schema() -> Schema {
-        // define field types
-        let list_data_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, true)));
-
-        let fixed_size_list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new("item", DataType::Int32, false)),
-            3,
-        );
-
-        let key_type = DataType::Int8;
-        let value_type = DataType::Utf8;
-        let dict_data_type =
-            DataType::Dictionary(Box::new(key_type), Box::new(value_type));
-
-        let union_fileds = vec![
-            Field::new("a", DataType::Int32, false),
-            Field::new("b", DataType::Float64, false),
-        ];
-        let union_data_type = DataType::Union(union_fileds, vec![0, 1], UnionMode::Dense);
-
-        let struct_fields = vec![
-            Field::new("id", DataType::Int32, false),
-            Field::new(
-                "list",
-                DataType::List(Box::new(Field::new("item", DataType::Int8, true))),
-                false,
-            ),
-        ];
-        let struct_data_type = DataType::Struct(struct_fields);
-
-        // define schema
-        Schema::new(vec![
-            Field::new("f0", DataType::UInt32, false),
-            Field::new("f1", DataType::Utf8, false),
-            Field::new("f2", DataType::Boolean, false),
-            Field::new("f3", union_data_type, true),
-            Field::new("f4", DataType::Null, true),
-            Field::new("f5", DataType::Float64, true),
-            Field::new("f6", list_data_type, false),
-            Field::new("f7", DataType::FixedSizeBinary(3), true),
-            Field::new("f8", fixed_size_list_data_type, false),
-            Field::new("f9", struct_data_type, false),
-            Field::new("f10", DataType::Boolean, false),
-            Field::new("f11", dict_data_type, false),
-            Field::new("f12", DataType::Utf8, false),
-        ])
-    }
-
-    fn create_test_projection_batch_data(schema: &Schema) -> RecordBatch {
-        // set test data for each column
-        let array0 = UInt32Array::from(vec![1, 2, 3]);
-        let array1 = StringArray::from(vec!["foo", "bar", "baz"]);
-        let array2 = BooleanArray::from(vec![true, false, true]);
-
-        let mut union_builder = UnionBuilder::new_dense(3);
-        union_builder.append::<Int32Type>("a", 1).unwrap();
-        union_builder.append::<Float64Type>("b", 10.1).unwrap();
-        union_builder.append_null::<Float64Type>("b").unwrap();
-        let array3 = union_builder.build().unwrap();
-
-        let array4 = NullArray::new(3);
-        let array5 = Float64Array::from(vec![Some(1.1), None, Some(3.3)]);
-        let array6_values = vec![
-            Some(vec![Some(10), Some(10), Some(10)]),
-            Some(vec![Some(20), Some(20), Some(20)]),
-            Some(vec![Some(30), Some(30)]),
-        ];
-        let array6 = ListArray::from_iter_primitive::<Int32Type, _, _>(array6_values);
-        let array7_values = vec![vec![11, 12, 13], vec![22, 23, 24], vec![33, 34, 35]];
-        let array7 =
-            FixedSizeBinaryArray::try_from_iter(array7_values.into_iter()).unwrap();
-
-        let array8_values = ArrayData::builder(DataType::Int32)
-            .len(9)
-            .add_buffer(Buffer::from_slice_ref(&[
-                40, 41, 42, 43, 44, 45, 46, 47, 48,
-            ]))
-            .build()
-            .unwrap();
-        let array8_data = ArrayData::builder(schema.field(8).data_type().clone())
-            .len(3)
-            .add_child_data(array8_values)
-            .build()
-            .unwrap();
-        let array8 = FixedSizeListArray::from(array8_data);
-
-        let array9_id: ArrayRef = Arc::new(Int32Array::from(vec![1001, 1002, 1003]));
-        let array9_list: ArrayRef =
-            Arc::new(ListArray::from_iter_primitive::<Int8Type, _, _>(vec![
-                Some(vec![Some(-10)]),
-                Some(vec![Some(-20), Some(-20), Some(-20)]),
-                Some(vec![Some(-30)]),
-            ]));
-        let array9 = ArrayDataBuilder::new(schema.field(9).data_type().clone())
-            .add_child_data(array9_id.into_data())
-            .add_child_data(array9_list.into_data())
-            .len(3)
-            .build()
-            .unwrap();
-        let array9: ArrayRef = Arc::new(StructArray::from(array9));
-
-        let array10 = BooleanArray::from(vec![false, false, true]);
-
-        let array11_values = StringArray::from(vec!["x", "yy", "zzz"]);
-        let array11_keys = Int8Array::from_iter_values([1, 1, 2]);
-        let array11 =
-            DictionaryArray::<Int8Type>::try_new(&array11_keys, &array11_values).unwrap();
-
-        let array12 = StringArray::from(vec!["a", "bb", "ccc"]);
-
-        // create record batch
-        RecordBatch::try_new(
-            Arc::new(schema.clone()),
-            vec![
-                Arc::new(array0),
-                Arc::new(array1),
-                Arc::new(array2),
-                Arc::new(array3),
-                Arc::new(array4),
-                Arc::new(array5),
-                Arc::new(array6),
-                Arc::new(array7),
-                Arc::new(array8),
-                Arc::new(array9),
-                Arc::new(array10),
-                Arc::new(array11),
-                Arc::new(array12),
-            ],
-        )
-        .unwrap()
-    }
-
-    #[test]
-    fn test_projection_array_values() {
-        // define schema
-        let schema = create_test_projection_schema();
-
-        // create record batch with test data
-        let batch = create_test_projection_batch_data(&schema);
-
-        // write record batch in IPC format
-        let mut buf = Vec::new();
-        {
-            let mut writer = ipc::writer::FileWriter::try_new(&mut buf, &schema).unwrap();
-            writer.write(&batch).unwrap();
-            writer.finish().unwrap();
-        }
-
-        // read record batch with projection
-        for index in 0..12 {
-            let projection = vec![index];
-            let reader =
-                FileReader::try_new(std::io::Cursor::new(buf.clone()), Some(projection));
-            let read_batch = reader.unwrap().next().unwrap().unwrap();
-            let projected_column = read_batch.column(0);
-            let expected_column = batch.column(index);
-
-            // check the projected column equals the expected column
-            assert_eq!(projected_column.as_ref(), expected_column.as_ref());
-        }
-    }
-
-    #[test]
-    fn test_arrow_single_float_row() {
-        let schema = Schema::new(vec![
-            Field::new("a", DataType::Float32, false),
-            Field::new("b", DataType::Float32, false),
-            Field::new("c", DataType::Int32, false),
-            Field::new("d", DataType::Int32, false),
-        ]);
-        let arrays = vec![
-            Arc::new(Float32Array::from(vec![1.23])) as ArrayRef,
-            Arc::new(Float32Array::from(vec![-6.50])) as ArrayRef,
-            Arc::new(Int32Array::from(vec![2])) as ArrayRef,
-            Arc::new(Int32Array::from(vec![1])) as ArrayRef,
-        ];
-        let batch = RecordBatch::try_new(Arc::new(schema.clone()), arrays).unwrap();
-        // create stream writer
-        let file = File::create("target/debug/testdata/float.stream").unwrap();
-        let mut stream_writer =
-            crate::ipc::writer::StreamWriter::try_new(file, &schema).unwrap();
-        stream_writer.write(&batch).unwrap();
-        stream_writer.finish().unwrap();
-
-        // read stream back
-        let file = File::open("target/debug/testdata/float.stream").unwrap();
-        let reader = StreamReader::try_new(file, None).unwrap();
-
-        reader.for_each(|batch| {
-            let batch = batch.unwrap();
-            assert!(
-                batch
-                    .column(0)
-                    .as_any()
-                    .downcast_ref::<Float32Array>()
-                    .unwrap()
-                    .value(0)
-                    != 0.0
-            );
-            assert!(
-                batch
-                    .column(1)
-                    .as_any()
-                    .downcast_ref::<Float32Array>()
-                    .unwrap()
-                    .value(0)
-                    != 0.0
-            );
-        });
-
-        let file = File::open("target/debug/testdata/float.stream").unwrap();
-
-        // Read with projection
-        let reader = StreamReader::try_new(file, Some(vec![0, 3])).unwrap();
-
-        reader.for_each(|batch| {
-            let batch = batch.unwrap();
-            assert_eq!(batch.schema().fields().len(), 2);
-            assert_eq!(batch.schema().fields()[0].data_type(), &DataType::Float32);
-            assert_eq!(batch.schema().fields()[1].data_type(), &DataType::Int32);
-        });
-    }
-
-    fn roundtrip_ipc(rb: &RecordBatch) -> RecordBatch {
-        let mut buf = Vec::new();
-        let mut writer =
-            ipc::writer::FileWriter::try_new(&mut buf, &rb.schema()).unwrap();
-        writer.write(rb).unwrap();
-        writer.finish().unwrap();
-        drop(writer);
-
-        let mut reader =
-            ipc::reader::FileReader::try_new(std::io::Cursor::new(buf), None).unwrap();
-        reader.next().unwrap().unwrap()
-    }
-
-    fn roundtrip_ipc_stream(rb: &RecordBatch) -> RecordBatch {
-        let mut buf = Vec::new();
-        let mut writer =
-            ipc::writer::StreamWriter::try_new(&mut buf, &rb.schema()).unwrap();
-        writer.write(rb).unwrap();
-        writer.finish().unwrap();
-        drop(writer);
-
-        let mut reader =
-            ipc::reader::StreamReader::try_new(std::io::Cursor::new(buf), None).unwrap();
-        reader.next().unwrap().unwrap()
-    }
-
-    #[test]
-    fn test_roundtrip_nested_dict() {
-        let inner: DictionaryArray<datatypes::Int32Type> =
-            vec!["a", "b", "a"].into_iter().collect();
-
-        let array = Arc::new(inner) as ArrayRef;
-
-        let dctfield = Field::new("dict", array.data_type().clone(), false);
-
-        let s = StructArray::from(vec![(dctfield, array)]);
-        let struct_array = Arc::new(s) as ArrayRef;
-
-        let schema = Arc::new(Schema::new(vec![Field::new(
-            "struct",
-            struct_array.data_type().clone(),
-            false,
-        )]));
-
-        let batch = RecordBatch::try_new(schema, vec![struct_array]).unwrap();
-
-        assert_eq!(batch, roundtrip_ipc(&batch));
-    }
-
-    fn check_union_with_builder(mut builder: UnionBuilder) {
-        builder.append::<datatypes::Int32Type>("a", 1).unwrap();
-        builder.append_null::<datatypes::Int32Type>("a").unwrap();
-        builder.append::<datatypes::Float64Type>("c", 3.0).unwrap();
-        builder.append::<datatypes::Int32Type>("a", 4).unwrap();
-        builder.append::<datatypes::Int64Type>("d", 11).unwrap();
-        let union = builder.build().unwrap();
-
-        let schema = Arc::new(Schema::new(vec![Field::new(
-            "union",
-            union.data_type().clone(),
-            false,
-        )]));
-
-        let union_array = Arc::new(union) as ArrayRef;
-
-        let rb = RecordBatch::try_new(schema, vec![union_array]).unwrap();
-        let rb2 = roundtrip_ipc(&rb);
-        // TODO: equality not yet implemented for union, so we check that the length of the array is
-        // the same and that all of the buffers are the same instead.
-        assert_eq!(rb.schema(), rb2.schema());
-        assert_eq!(rb.num_columns(), rb2.num_columns());
-        assert_eq!(rb.num_rows(), rb2.num_rows());
-        let union1 = rb.column(0);
-        let union2 = rb2.column(0);
-
-        assert_eq!(union1.data().buffers(), union2.data().buffers());
-    }
-
-    #[test]
-    fn test_roundtrip_dense_union() {
-        check_union_with_builder(UnionBuilder::new_dense(6));
-    }
-
-    #[test]
-    fn test_roundtrip_sparse_union() {
-        check_union_with_builder(UnionBuilder::new_sparse(6));
-    }
-
-    /// Read gzipped JSON file
-    fn read_gzip_json(version: &str, path: &str) -> ArrowJson {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let file = File::open(format!(
-            "{}/arrow-ipc-stream/integration/{}/{}.json.gz",
-            testdata, version, path
-        ))
-        .unwrap();
-        let mut gz = GzDecoder::new(&file);
-        let mut s = String::new();
-        gz.read_to_string(&mut s).unwrap();
-        // convert to Arrow JSON
-        let arrow_json: ArrowJson = serde_json::from_str(&s).unwrap();
-        arrow_json
-    }
-
-    #[test]
-    fn test_roundtrip_stream_nested_dict() {
-        let xs = vec!["AA", "BB", "AA", "CC", "BB"];
-        let dict = Arc::new(
-            xs.clone()
-                .into_iter()
-                .collect::<DictionaryArray<datatypes::Int8Type>>(),
-        );
-        let string_array: ArrayRef = Arc::new(StringArray::from(xs.clone()));
-        let struct_array = StructArray::from(vec![
-            (Field::new("f2.1", DataType::Utf8, false), string_array),
-            (
-                Field::new("f2.2_struct", dict.data_type().clone(), false),
-                dict.clone() as ArrayRef,
-            ),
-        ]);
-        let schema = Arc::new(Schema::new(vec![
-            Field::new("f1_string", DataType::Utf8, false),
-            Field::new("f2_struct", struct_array.data_type().clone(), false),
-        ]));
-        let input_batch = RecordBatch::try_new(
-            schema,
-            vec![
-                Arc::new(StringArray::from(xs.clone())),
-                Arc::new(struct_array),
-            ],
-        )
-        .unwrap();
-        let output_batch = roundtrip_ipc_stream(&input_batch);
-        assert_eq!(input_batch, output_batch);
-    }
-
-    #[test]
-    fn test_roundtrip_stream_nested_dict_of_map_of_dict() {
-        let values = StringArray::from(vec![Some("a"), None, Some("b"), Some("c")]);
-        let value_dict_keys = Int8Array::from_iter_values([0, 1, 1, 2, 3, 1]);
-        let value_dict_array =
-            DictionaryArray::<Int8Type>::try_new(&value_dict_keys, &values).unwrap();
-
-        let key_dict_keys = Int8Array::from_iter_values([0, 0, 2, 1, 1, 3]);
-        let key_dict_array =
-            DictionaryArray::<Int8Type>::try_new(&key_dict_keys, &values).unwrap();
-
-        let keys_field = Field::new_dict(
-            "keys",
-            DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
-            true,
-            1,
-            false,
-        );
-        let values_field = Field::new_dict(
-            "values",
-            DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
-            true,
-            1,
-            false,
-        );
-        let entry_struct = StructArray::from(vec![
-            (keys_field, make_array(key_dict_array.into_data())),
-            (values_field, make_array(value_dict_array.into_data())),
-        ]);
-        let map_data_type = DataType::Map(
-            Box::new(Field::new(
-                "entries",
-                entry_struct.data_type().clone(),
-                true,
-            )),
-            false,
-        );
-
-        let entry_offsets = Buffer::from_slice_ref(&[0, 2, 4, 6]);
-        let map_data = ArrayData::builder(map_data_type)
-            .len(3)
-            .add_buffer(entry_offsets)
-            .add_child_data(entry_struct.into_data())
-            .build()
-            .unwrap();
-        let map_array = MapArray::from(map_data);
-
-        let dict_keys = Int8Array::from_iter_values([0, 1, 1, 2, 2, 1]);
-        let dict_dict_array =
-            DictionaryArray::<Int8Type>::try_new(&dict_keys, &map_array).unwrap();
-
-        let schema = Arc::new(Schema::new(vec![Field::new(
-            "f1",
-            dict_dict_array.data_type().clone(),
-            false,
-        )]));
-        let input_batch =
-            RecordBatch::try_new(schema, vec![Arc::new(dict_dict_array)]).unwrap();
-        let output_batch = roundtrip_ipc_stream(&input_batch);
-        assert_eq!(input_batch, output_batch);
-    }
-
-    fn test_roundtrip_stream_dict_of_list_of_dict_impl<
-        OffsetSize: OffsetSizeTrait,
-        U: ArrowNativeType,
-    >(
-        list_data_type: DataType,
-        offsets: &[U; 5],
-    ) {
-        let values = StringArray::from(vec![Some("a"), None, Some("c"), None]);
-        let keys = Int8Array::from_iter_values([0, 0, 1, 2, 0, 1, 3]);
-        let dict_array = DictionaryArray::<Int8Type>::try_new(&keys, &values).unwrap();
-        let dict_data = dict_array.data();
-
-        let value_offsets = Buffer::from_slice_ref(offsets);
-
-        let list_data = ArrayData::builder(list_data_type)
-            .len(4)
-            .add_buffer(value_offsets)
-            .add_child_data(dict_data.clone())
-            .build()
-            .unwrap();
-        let list_array = GenericListArray::<OffsetSize>::from(list_data);
-
-        let keys_for_dict = Int8Array::from_iter_values([0, 3, 0, 1, 1, 2, 0, 1, 3]);
-        let dict_dict_array =
-            DictionaryArray::<Int8Type>::try_new(&keys_for_dict, &list_array).unwrap();
-
-        let schema = Arc::new(Schema::new(vec![Field::new(
-            "f1",
-            dict_dict_array.data_type().clone(),
-            false,
-        )]));
-        let input_batch =
-            RecordBatch::try_new(schema, vec![Arc::new(dict_dict_array)]).unwrap();
-        let output_batch = roundtrip_ipc_stream(&input_batch);
-        assert_eq!(input_batch, output_batch);
-    }
-
-    #[test]
-    fn test_roundtrip_stream_dict_of_list_of_dict() {
-        // list
-        let list_data_type = DataType::List(Box::new(Field::new_dict(
-            "item",
-            DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
-            true,
-            1,
-            false,
-        )));
-        let offsets: &[i32; 5] = &[0, 2, 4, 4, 6];
-        test_roundtrip_stream_dict_of_list_of_dict_impl::<i32, i32>(
-            list_data_type,
-            offsets,
-        );
-
-        // large list
-        let list_data_type = DataType::LargeList(Box::new(Field::new_dict(
-            "item",
-            DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
-            true,
-            1,
-            false,
-        )));
-        let offsets: &[i64; 5] = &[0, 2, 4, 4, 7];
-        test_roundtrip_stream_dict_of_list_of_dict_impl::<i64, i64>(
-            list_data_type,
-            offsets,
-        );
-    }
-
-    #[test]
-    fn test_roundtrip_stream_dict_of_fixed_size_list_of_dict() {
-        let values = StringArray::from(vec![Some("a"), None, Some("c"), None]);
-        let keys = Int8Array::from_iter_values([0, 0, 1, 2, 0, 1, 3, 1, 2]);
-        let dict_array = DictionaryArray::<Int8Type>::try_new(&keys, &values).unwrap();
-        let dict_data = dict_array.data();
-
-        let list_data_type = DataType::FixedSizeList(
-            Box::new(Field::new_dict(
-                "item",
-                DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
-                true,
-                1,
-                false,
-            )),
-            3,
-        );
-        let list_data = ArrayData::builder(list_data_type)
-            .len(3)
-            .add_child_data(dict_data.clone())
-            .build()
-            .unwrap();
-        let list_array = FixedSizeListArray::from(list_data);
-
-        let keys_for_dict = Int8Array::from_iter_values([0, 1, 0, 1, 1, 2, 0, 1, 2]);
-        let dict_dict_array =
-            DictionaryArray::<Int8Type>::try_new(&keys_for_dict, &list_array).unwrap();
-
-        let schema = Arc::new(Schema::new(vec![Field::new(
-            "f1",
-            dict_dict_array.data_type().clone(),
-            false,
-        )]));
-        let input_batch =
-            RecordBatch::try_new(schema, vec![Arc::new(dict_dict_array)]).unwrap();
-        let output_batch = roundtrip_ipc_stream(&input_batch);
-        assert_eq!(input_batch, output_batch);
-    }
-
-    #[test]
-    fn test_no_columns_batch() {
-        let schema = Arc::new(Schema::new(vec![]));
-        let options = RecordBatchOptions {
-            match_field_names: true,
-            row_count: Some(10),
-        };
-        let input_batch =
-            RecordBatch::try_new_with_options(schema, vec![], &options).unwrap();
-        let output_batch = roundtrip_ipc_stream(&input_batch);
-        assert_eq!(input_batch, output_batch);
-    }
-}
diff --git a/arrow/src/ipc/writer.rs b/arrow/src/ipc/writer.rs
deleted file mode 100644
index f0942b074cfe..000000000000
--- a/arrow/src/ipc/writer.rs
+++ /dev/null
@@ -1,1867 +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.
-
-//! Arrow IPC File and Stream Writers
-//!
-//! The `FileWriter` and `StreamWriter` have similar interfaces,
-//! however the `FileWriter` expects a reader that supports `Seek`ing
-
-use std::cmp::min;
-use std::collections::HashMap;
-use std::io::{BufWriter, Write};
-
-use flatbuffers::FlatBufferBuilder;
-
-use crate::array::{
-    as_large_list_array, as_list_array, as_map_array, as_struct_array, as_union_array,
-    layout, make_array, Array, ArrayData, ArrayRef, BinaryArray, BufferBuilder,
-    BufferSpec, FixedSizeListArray, GenericBinaryArray, GenericStringArray,
-    LargeBinaryArray, LargeStringArray, OffsetSizeTrait, StringArray,
-};
-use crate::buffer::{Buffer, MutableBuffer};
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-use crate::ipc;
-use crate::record_batch::RecordBatch;
-use crate::util::bit_util;
-
-use ipc::CONTINUATION_MARKER;
-
-/// IPC write options used to control the behaviour of the writer
-#[derive(Debug, Clone)]
-pub struct IpcWriteOptions {
-    /// Write padding after memory buffers to this multiple of bytes.
-    /// Generally 8 or 64, defaults to 8
-    alignment: usize,
-    /// The legacy format is for releases before 0.15.0, and uses metadata V4
-    write_legacy_ipc_format: bool,
-    /// The metadata version to write. The Rust IPC writer supports V4+
-    ///
-    /// *Default versions per crate*
-    ///
-    /// When creating the default IpcWriteOptions, the following metadata versions are used:
-    ///
-    /// version 2.0.0: V4, with legacy format enabled
-    /// version 4.0.0: V5
-    metadata_version: ipc::MetadataVersion,
-}
-
-impl IpcWriteOptions {
-    /// Try create IpcWriteOptions, checking for incompatible settings
-    pub fn try_new(
-        alignment: usize,
-        write_legacy_ipc_format: bool,
-        metadata_version: ipc::MetadataVersion,
-    ) -> Result<Self> {
-        if alignment == 0 || alignment % 8 != 0 {
-            return Err(ArrowError::InvalidArgumentError(
-                "Alignment should be greater than 0 and be a multiple of 8".to_string(),
-            ));
-        }
-        match metadata_version {
-            ipc::MetadataVersion::V1
-            | ipc::MetadataVersion::V2
-            | ipc::MetadataVersion::V3 => Err(ArrowError::InvalidArgumentError(
-                "Writing IPC metadata version 3 and lower not supported".to_string(),
-            )),
-            ipc::MetadataVersion::V4 => Ok(Self {
-                alignment,
-                write_legacy_ipc_format,
-                metadata_version,
-            }),
-            ipc::MetadataVersion::V5 => {
-                if write_legacy_ipc_format {
-                    Err(ArrowError::InvalidArgumentError(
-                        "Legacy IPC format only supported on metadata version 4"
-                            .to_string(),
-                    ))
-                } else {
-                    Ok(Self {
-                        alignment,
-                        write_legacy_ipc_format,
-                        metadata_version,
-                    })
-                }
-            }
-            z => panic!("Unsupported ipc::MetadataVersion {:?}", z),
-        }
-    }
-}
-
-impl Default for IpcWriteOptions {
-    fn default() -> Self {
-        Self {
-            alignment: 8,
-            write_legacy_ipc_format: false,
-            metadata_version: ipc::MetadataVersion::V5,
-        }
-    }
-}
-
-#[derive(Debug, Default)]
-pub struct IpcDataGenerator {}
-
-impl IpcDataGenerator {
-    pub fn schema_to_bytes(
-        &self,
-        schema: &Schema,
-        write_options: &IpcWriteOptions,
-    ) -> EncodedData {
-        let mut fbb = FlatBufferBuilder::new();
-        let schema = {
-            let fb = ipc::convert::schema_to_fb_offset(&mut fbb, schema);
-            fb.as_union_value()
-        };
-
-        let mut message = ipc::MessageBuilder::new(&mut fbb);
-        message.add_version(write_options.metadata_version);
-        message.add_header_type(ipc::MessageHeader::Schema);
-        message.add_bodyLength(0);
-        message.add_header(schema);
-        // TODO: custom metadata
-        let data = message.finish();
-        fbb.finish(data, None);
-
-        let data = fbb.finished_data();
-        EncodedData {
-            ipc_message: data.to_vec(),
-            arrow_data: vec![],
-        }
-    }
-
-    fn _encode_dictionaries(
-        &self,
-        column: &ArrayRef,
-        encoded_dictionaries: &mut Vec<EncodedData>,
-        dictionary_tracker: &mut DictionaryTracker,
-        write_options: &IpcWriteOptions,
-    ) -> Result<()> {
-        match column.data_type() {
-            DataType::Struct(fields) => {
-                let s = as_struct_array(column);
-                for (field, &column) in fields.iter().zip(s.columns().iter()) {
-                    self.encode_dictionaries(
-                        field,
-                        column,
-                        encoded_dictionaries,
-                        dictionary_tracker,
-                        write_options,
-                    )?;
-                }
-            }
-            DataType::List(field) => {
-                let list = as_list_array(column);
-                self.encode_dictionaries(
-                    field,
-                    &list.values(),
-                    encoded_dictionaries,
-                    dictionary_tracker,
-                    write_options,
-                )?;
-            }
-            DataType::LargeList(field) => {
-                let list = as_large_list_array(column);
-                self.encode_dictionaries(
-                    field,
-                    &list.values(),
-                    encoded_dictionaries,
-                    dictionary_tracker,
-                    write_options,
-                )?;
-            }
-            DataType::FixedSizeList(field, _) => {
-                let list = column
-                    .as_any()
-                    .downcast_ref::<FixedSizeListArray>()
-                    .expect("Unable to downcast to fixed size list array");
-                self.encode_dictionaries(
-                    field,
-                    &list.values(),
-                    encoded_dictionaries,
-                    dictionary_tracker,
-                    write_options,
-                )?;
-            }
-            DataType::Map(field, _) => {
-                let map_array = as_map_array(column);
-
-                let (keys, values) = match field.data_type() {
-                    DataType::Struct(fields) if fields.len() == 2 => {
-                        (&fields[0], &fields[1])
-                    }
-                    _ => panic!("Incorrect field data type {:?}", field.data_type()),
-                };
-
-                // keys
-                self.encode_dictionaries(
-                    keys,
-                    &map_array.keys(),
-                    encoded_dictionaries,
-                    dictionary_tracker,
-                    write_options,
-                )?;
-
-                // values
-                self.encode_dictionaries(
-                    values,
-                    &map_array.values(),
-                    encoded_dictionaries,
-                    dictionary_tracker,
-                    write_options,
-                )?;
-            }
-            DataType::Union(fields, _, _) => {
-                let union = as_union_array(column);
-                for (field, column) in fields
-                    .iter()
-                    .enumerate()
-                    .map(|(n, f)| (f, union.child(n as i8)))
-                {
-                    self.encode_dictionaries(
-                        field,
-                        column,
-                        encoded_dictionaries,
-                        dictionary_tracker,
-                        write_options,
-                    )?;
-                }
-            }
-            _ => (),
-        }
-
-        Ok(())
-    }
-
-    fn encode_dictionaries(
-        &self,
-        field: &Field,
-        column: &ArrayRef,
-        encoded_dictionaries: &mut Vec<EncodedData>,
-        dictionary_tracker: &mut DictionaryTracker,
-        write_options: &IpcWriteOptions,
-    ) -> Result<()> {
-        match column.data_type() {
-            DataType::Dictionary(_key_type, _value_type) => {
-                let dict_id = field
-                    .dict_id()
-                    .expect("All Dictionary types have `dict_id`");
-                let dict_data = column.data();
-                let dict_values = &dict_data.child_data()[0];
-
-                let values = make_array(dict_data.child_data()[0].clone());
-
-                self._encode_dictionaries(
-                    &values,
-                    encoded_dictionaries,
-                    dictionary_tracker,
-                    write_options,
-                )?;
-
-                let emit = dictionary_tracker.insert(dict_id, column)?;
-
-                if emit {
-                    encoded_dictionaries.push(self.dictionary_batch_to_bytes(
-                        dict_id,
-                        dict_values,
-                        write_options,
-                    ));
-                }
-            }
-            _ => self._encode_dictionaries(
-                column,
-                encoded_dictionaries,
-                dictionary_tracker,
-                write_options,
-            )?,
-        }
-
-        Ok(())
-    }
-
-    pub fn encoded_batch(
-        &self,
-        batch: &RecordBatch,
-        dictionary_tracker: &mut DictionaryTracker,
-        write_options: &IpcWriteOptions,
-    ) -> Result<(Vec<EncodedData>, EncodedData)> {
-        let schema = batch.schema();
-        let mut encoded_dictionaries = Vec::with_capacity(schema.all_fields().len());
-
-        for (i, field) in schema.fields().iter().enumerate() {
-            let column = batch.column(i);
-            self.encode_dictionaries(
-                field,
-                column,
-                &mut encoded_dictionaries,
-                dictionary_tracker,
-                write_options,
-            )?;
-        }
-
-        let encoded_message = self.record_batch_to_bytes(batch, write_options);
-        Ok((encoded_dictionaries, encoded_message))
-    }
-
-    /// Write a `RecordBatch` into two sets of bytes, one for the header (ipc::Message) and the
-    /// other for the batch's data
-    fn record_batch_to_bytes(
-        &self,
-        batch: &RecordBatch,
-        write_options: &IpcWriteOptions,
-    ) -> EncodedData {
-        let mut fbb = FlatBufferBuilder::new();
-
-        let mut nodes: Vec<ipc::FieldNode> = vec![];
-        let mut buffers: Vec<ipc::Buffer> = vec![];
-        let mut arrow_data: Vec<u8> = vec![];
-        let mut offset = 0;
-        for array in batch.columns() {
-            let array_data = array.data();
-            offset = write_array_data(
-                array_data,
-                &mut buffers,
-                &mut arrow_data,
-                &mut nodes,
-                offset,
-                array.len(),
-                array.null_count(),
-                write_options,
-            );
-        }
-
-        // write data
-        let buffers = fbb.create_vector(&buffers);
-        let nodes = fbb.create_vector(&nodes);
-
-        let root = {
-            let mut batch_builder = ipc::RecordBatchBuilder::new(&mut fbb);
-            batch_builder.add_length(batch.num_rows() as i64);
-            batch_builder.add_nodes(nodes);
-            batch_builder.add_buffers(buffers);
-            let b = batch_builder.finish();
-            b.as_union_value()
-        };
-        // create an ipc::Message
-        let mut message = ipc::MessageBuilder::new(&mut fbb);
-        message.add_version(write_options.metadata_version);
-        message.add_header_type(ipc::MessageHeader::RecordBatch);
-        message.add_bodyLength(arrow_data.len() as i64);
-        message.add_header(root);
-        let root = message.finish();
-        fbb.finish(root, None);
-        let finished_data = fbb.finished_data();
-
-        EncodedData {
-            ipc_message: finished_data.to_vec(),
-            arrow_data,
-        }
-    }
-
-    /// Write dictionary values into two sets of bytes, one for the header (ipc::Message) and the
-    /// other for the data
-    fn dictionary_batch_to_bytes(
-        &self,
-        dict_id: i64,
-        array_data: &ArrayData,
-        write_options: &IpcWriteOptions,
-    ) -> EncodedData {
-        let mut fbb = FlatBufferBuilder::new();
-
-        let mut nodes: Vec<ipc::FieldNode> = vec![];
-        let mut buffers: Vec<ipc::Buffer> = vec![];
-        let mut arrow_data: Vec<u8> = vec![];
-
-        write_array_data(
-            array_data,
-            &mut buffers,
-            &mut arrow_data,
-            &mut nodes,
-            0,
-            array_data.len(),
-            array_data.null_count(),
-            write_options,
-        );
-
-        // write data
-        let buffers = fbb.create_vector(&buffers);
-        let nodes = fbb.create_vector(&nodes);
-
-        let root = {
-            let mut batch_builder = ipc::RecordBatchBuilder::new(&mut fbb);
-            batch_builder.add_length(array_data.len() as i64);
-            batch_builder.add_nodes(nodes);
-            batch_builder.add_buffers(buffers);
-            batch_builder.finish()
-        };
-
-        let root = {
-            let mut batch_builder = ipc::DictionaryBatchBuilder::new(&mut fbb);
-            batch_builder.add_id(dict_id);
-            batch_builder.add_data(root);
-            batch_builder.finish().as_union_value()
-        };
-
-        let root = {
-            let mut message_builder = ipc::MessageBuilder::new(&mut fbb);
-            message_builder.add_version(write_options.metadata_version);
-            message_builder.add_header_type(ipc::MessageHeader::DictionaryBatch);
-            message_builder.add_bodyLength(arrow_data.len() as i64);
-            message_builder.add_header(root);
-            message_builder.finish()
-        };
-
-        fbb.finish(root, None);
-        let finished_data = fbb.finished_data();
-
-        EncodedData {
-            ipc_message: finished_data.to_vec(),
-            arrow_data,
-        }
-    }
-}
-
-/// Keeps track of dictionaries that have been written, to avoid emitting the same dictionary
-/// multiple times. Can optionally error if an update to an existing dictionary is attempted, which
-/// isn't allowed in the `FileWriter`.
-pub struct DictionaryTracker {
-    written: HashMap<i64, ArrayRef>,
-    error_on_replacement: bool,
-}
-
-impl DictionaryTracker {
-    pub fn new(error_on_replacement: bool) -> Self {
-        Self {
-            written: HashMap::new(),
-            error_on_replacement,
-        }
-    }
-
-    /// Keep track of the dictionary with the given ID and values. Behavior:
-    ///
-    /// * If this ID has been written already and has the same data, return `Ok(false)` to indicate
-    ///   that the dictionary was not actually inserted (because it's already been seen).
-    /// * If this ID has been written already but with different data, and this tracker is
-    ///   configured to return an error, return an error.
-    /// * If the tracker has not been configured to error on replacement or this dictionary
-    ///   has never been seen before, return `Ok(true)` to indicate that the dictionary was just
-    ///   inserted.
-    pub fn insert(&mut self, dict_id: i64, column: &ArrayRef) -> Result<bool> {
-        let dict_data = column.data();
-        let dict_values = &dict_data.child_data()[0];
-
-        // If a dictionary with this id was already emitted, check if it was the same.
-        if let Some(last) = self.written.get(&dict_id) {
-            if last.data().child_data()[0] == *dict_values {
-                // Same dictionary values => no need to emit it again
-                return Ok(false);
-            } else if self.error_on_replacement {
-                return Err(ArrowError::InvalidArgumentError(
-                    "Dictionary replacement detected when writing IPC file format. \
-                     Arrow IPC files only support a single dictionary for a given field \
-                     across all batches."
-                        .to_string(),
-                ));
-            }
-        }
-
-        self.written.insert(dict_id, column.clone());
-        Ok(true)
-    }
-}
-
-pub struct FileWriter<W: Write> {
-    /// The object to write to
-    writer: BufWriter<W>,
-    /// IPC write options
-    write_options: IpcWriteOptions,
-    /// A reference to the schema, used in validating record batches
-    schema: Schema,
-    /// The number of bytes between each block of bytes, as an offset for random access
-    block_offsets: usize,
-    /// Dictionary blocks that will be written as part of the IPC footer
-    dictionary_blocks: Vec<ipc::Block>,
-    /// Record blocks that will be written as part of the IPC footer
-    record_blocks: Vec<ipc::Block>,
-    /// Whether the writer footer has been written, and the writer is finished
-    finished: bool,
-    /// Keeps track of dictionaries that have been written
-    dictionary_tracker: DictionaryTracker,
-
-    data_gen: IpcDataGenerator,
-}
-
-impl<W: Write> FileWriter<W> {
-    /// Try create a new writer, with the schema written as part of the header
-    pub fn try_new(writer: W, schema: &Schema) -> Result<Self> {
-        let write_options = IpcWriteOptions::default();
-        Self::try_new_with_options(writer, schema, write_options)
-    }
-
-    /// Try create a new writer with IpcWriteOptions
-    pub fn try_new_with_options(
-        writer: W,
-        schema: &Schema,
-        write_options: IpcWriteOptions,
-    ) -> Result<Self> {
-        let data_gen = IpcDataGenerator::default();
-        let mut writer = BufWriter::new(writer);
-        // write magic to header
-        writer.write_all(&super::ARROW_MAGIC[..])?;
-        // create an 8-byte boundary after the header
-        writer.write_all(&[0, 0])?;
-        // write the schema, set the written bytes to the schema + header
-        let encoded_message = data_gen.schema_to_bytes(schema, &write_options);
-        let (meta, data) = write_message(&mut writer, encoded_message, &write_options)?;
-        Ok(Self {
-            writer,
-            write_options,
-            schema: schema.clone(),
-            block_offsets: meta + data + 8,
-            dictionary_blocks: vec![],
-            record_blocks: vec![],
-            finished: false,
-            dictionary_tracker: DictionaryTracker::new(true),
-            data_gen,
-        })
-    }
-
-    /// Write a record batch to the file
-    pub fn write(&mut self, batch: &RecordBatch) -> Result<()> {
-        if self.finished {
-            return Err(ArrowError::IoError(
-                "Cannot write record batch to file writer as it is closed".to_string(),
-            ));
-        }
-
-        let (encoded_dictionaries, encoded_message) = self.data_gen.encoded_batch(
-            batch,
-            &mut self.dictionary_tracker,
-            &self.write_options,
-        )?;
-
-        for encoded_dictionary in encoded_dictionaries {
-            let (meta, data) =
-                write_message(&mut self.writer, encoded_dictionary, &self.write_options)?;
-
-            let block =
-                ipc::Block::new(self.block_offsets as i64, meta as i32, data as i64);
-            self.dictionary_blocks.push(block);
-            self.block_offsets += meta + data;
-        }
-
-        let (meta, data) =
-            write_message(&mut self.writer, encoded_message, &self.write_options)?;
-        // add a record block for the footer
-        let block = ipc::Block::new(
-            self.block_offsets as i64,
-            meta as i32, // TODO: is this still applicable?
-            data as i64,
-        );
-        self.record_blocks.push(block);
-        self.block_offsets += meta + data;
-        Ok(())
-    }
-
-    /// Write footer and closing tag, then mark the writer as done
-    pub fn finish(&mut self) -> Result<()> {
-        if self.finished {
-            return Err(ArrowError::IoError(
-                "Cannot write footer to file writer as it is closed".to_string(),
-            ));
-        }
-
-        // write EOS
-        write_continuation(&mut self.writer, &self.write_options, 0)?;
-
-        let mut fbb = FlatBufferBuilder::new();
-        let dictionaries = fbb.create_vector(&self.dictionary_blocks);
-        let record_batches = fbb.create_vector(&self.record_blocks);
-        let schema = ipc::convert::schema_to_fb_offset(&mut fbb, &self.schema);
-
-        let root = {
-            let mut footer_builder = ipc::FooterBuilder::new(&mut fbb);
-            footer_builder.add_version(self.write_options.metadata_version);
-            footer_builder.add_schema(schema);
-            footer_builder.add_dictionaries(dictionaries);
-            footer_builder.add_recordBatches(record_batches);
-            footer_builder.finish()
-        };
-        fbb.finish(root, None);
-        let footer_data = fbb.finished_data();
-        self.writer.write_all(footer_data)?;
-        self.writer
-            .write_all(&(footer_data.len() as i32).to_le_bytes())?;
-        self.writer.write_all(&super::ARROW_MAGIC)?;
-        self.writer.flush()?;
-        self.finished = true;
-
-        Ok(())
-    }
-
-    /// Unwraps the BufWriter housed in FileWriter.writer, returning the underlying
-    /// writer
-    ///
-    /// The buffer is flushed and the FileWriter is finished before returning the
-    /// writer.
-    pub fn into_inner(mut self) -> Result<W> {
-        if !self.finished {
-            self.finish()?;
-        }
-        self.writer.into_inner().map_err(ArrowError::from)
-    }
-}
-
-pub struct StreamWriter<W: Write> {
-    /// The object to write to
-    writer: BufWriter<W>,
-    /// IPC write options
-    write_options: IpcWriteOptions,
-    /// Whether the writer footer has been written, and the writer is finished
-    finished: bool,
-    /// Keeps track of dictionaries that have been written
-    dictionary_tracker: DictionaryTracker,
-
-    data_gen: IpcDataGenerator,
-}
-
-impl<W: Write> StreamWriter<W> {
-    /// Try create a new writer, with the schema written as part of the header
-    pub fn try_new(writer: W, schema: &Schema) -> Result<Self> {
-        let write_options = IpcWriteOptions::default();
-        Self::try_new_with_options(writer, schema, write_options)
-    }
-
-    pub fn try_new_with_options(
-        writer: W,
-        schema: &Schema,
-        write_options: IpcWriteOptions,
-    ) -> Result<Self> {
-        let data_gen = IpcDataGenerator::default();
-        let mut writer = BufWriter::new(writer);
-        // write the schema, set the written bytes to the schema
-        let encoded_message = data_gen.schema_to_bytes(schema, &write_options);
-        write_message(&mut writer, encoded_message, &write_options)?;
-        Ok(Self {
-            writer,
-            write_options,
-            finished: false,
-            dictionary_tracker: DictionaryTracker::new(false),
-            data_gen,
-        })
-    }
-
-    /// Write a record batch to the stream
-    pub fn write(&mut self, batch: &RecordBatch) -> Result<()> {
-        if self.finished {
-            return Err(ArrowError::IoError(
-                "Cannot write record batch to stream writer as it is closed".to_string(),
-            ));
-        }
-
-        let (encoded_dictionaries, encoded_message) = self
-            .data_gen
-            .encoded_batch(batch, &mut self.dictionary_tracker, &self.write_options)
-            .expect("StreamWriter is configured to not error on dictionary replacement");
-
-        for encoded_dictionary in encoded_dictionaries {
-            write_message(&mut self.writer, encoded_dictionary, &self.write_options)?;
-        }
-
-        write_message(&mut self.writer, encoded_message, &self.write_options)?;
-        Ok(())
-    }
-
-    /// Write continuation bytes, and mark the stream as done
-    pub fn finish(&mut self) -> Result<()> {
-        if self.finished {
-            return Err(ArrowError::IoError(
-                "Cannot write footer to stream writer as it is closed".to_string(),
-            ));
-        }
-
-        write_continuation(&mut self.writer, &self.write_options, 0)?;
-
-        self.finished = true;
-
-        Ok(())
-    }
-
-    /// Unwraps the BufWriter housed in StreamWriter.writer, returning the underlying
-    /// writer
-    ///
-    /// The buffer is flushed and the StreamWriter is finished before returning the
-    /// writer.
-    ///
-    /// # Errors
-    ///
-    /// An ['Err'] may be returned if an error occurs while finishing the StreamWriter
-    /// or while flushing the buffer.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// # use arrow::datatypes::Schema;
-    /// # use arrow::ipc::writer::StreamWriter;
-    /// # use arrow::error::ArrowError;
-    /// # fn main() -> Result<(), ArrowError> {
-    /// // The result we expect from an empty schema
-    /// let expected = vec![
-    ///     255, 255, 255, 255,  64,   0,   0,   0,
-    ///      16,   0,   0,   0,   0,   0,  10,   0,
-    ///      14,   0,  12,   0,  11,   0,   4,   0,
-    ///      10,   0,   0,   0,  20,   0,   0,   0,
-    ///       0,   0,   0,   1,   4,   0,  10,   0,
-    ///      12,   0,   0,   0,   8,   0,   4,   0,
-    ///      10,   0,   0,   0,   8,   0,   0,   0,
-    ///       8,   0,   0,   0,   0,   0,   0,   0,
-    ///       0,   0,   0,   0,   0,   0,   0,   0,
-    ///     255, 255, 255, 255,   0,   0,   0,   0
-    /// ];
-    ///
-    /// let schema = Schema::new(vec![]);
-    /// let buffer: Vec<u8> = Vec::new();
-    /// let stream_writer = StreamWriter::try_new(buffer, &schema)?;
-    ///
-    /// assert_eq!(stream_writer.into_inner()?, expected);
-    /// # Ok(())
-    /// # }
-    /// ```
-    pub fn into_inner(mut self) -> Result<W> {
-        if !self.finished {
-            self.finish()?;
-        }
-        self.writer.into_inner().map_err(ArrowError::from)
-    }
-}
-
-/// Stores the encoded data, which is an ipc::Message, and optional Arrow data
-pub struct EncodedData {
-    /// An encoded ipc::Message
-    pub ipc_message: Vec<u8>,
-    /// Arrow buffers to be written, should be an empty vec for schema messages
-    pub arrow_data: Vec<u8>,
-}
-/// Write a message's IPC data and buffers, returning metadata and buffer data lengths written
-pub fn write_message<W: Write>(
-    mut writer: W,
-    encoded: EncodedData,
-    write_options: &IpcWriteOptions,
-) -> Result<(usize, usize)> {
-    let arrow_data_len = encoded.arrow_data.len();
-    if arrow_data_len % 8 != 0 {
-        return Err(ArrowError::MemoryError(
-            "Arrow data not aligned".to_string(),
-        ));
-    }
-
-    let a = write_options.alignment - 1;
-    let buffer = encoded.ipc_message;
-    let flatbuf_size = buffer.len();
-    let prefix_size = if write_options.write_legacy_ipc_format {
-        4
-    } else {
-        8
-    };
-    let aligned_size = (flatbuf_size + prefix_size + a) & !a;
-    let padding_bytes = aligned_size - flatbuf_size - prefix_size;
-
-    write_continuation(
-        &mut writer,
-        write_options,
-        (aligned_size - prefix_size) as i32,
-    )?;
-
-    // write the flatbuf
-    if flatbuf_size > 0 {
-        writer.write_all(&buffer)?;
-    }
-    // write padding
-    writer.write_all(&vec![0; padding_bytes])?;
-
-    // write arrow data
-    let body_len = if arrow_data_len > 0 {
-        write_body_buffers(&mut writer, &encoded.arrow_data)?
-    } else {
-        0
-    };
-
-    Ok((aligned_size, body_len))
-}
-
-fn write_body_buffers<W: Write>(mut writer: W, data: &[u8]) -> Result<usize> {
-    let len = data.len() as u32;
-    let pad_len = pad_to_8(len) as u32;
-    let total_len = len + pad_len;
-
-    // write body buffer
-    writer.write_all(data)?;
-    if pad_len > 0 {
-        writer.write_all(&vec![0u8; pad_len as usize][..])?;
-    }
-
-    writer.flush()?;
-    Ok(total_len as usize)
-}
-
-/// Write a record batch to the writer, writing the message size before the message
-/// if the record batch is being written to a stream
-fn write_continuation<W: Write>(
-    mut writer: W,
-    write_options: &IpcWriteOptions,
-    total_len: i32,
-) -> Result<usize> {
-    let mut written = 8;
-
-    // the version of the writer determines whether continuation markers should be added
-    match write_options.metadata_version {
-        ipc::MetadataVersion::V1
-        | ipc::MetadataVersion::V2
-        | ipc::MetadataVersion::V3 => {
-            unreachable!("Options with the metadata version cannot be created")
-        }
-        ipc::MetadataVersion::V4 => {
-            if !write_options.write_legacy_ipc_format {
-                // v0.15.0 format
-                writer.write_all(&CONTINUATION_MARKER)?;
-                written = 4;
-            }
-            writer.write_all(&total_len.to_le_bytes()[..])?;
-        }
-        ipc::MetadataVersion::V5 => {
-            // write continuation marker and message length
-            writer.write_all(&CONTINUATION_MARKER)?;
-            writer.write_all(&total_len.to_le_bytes()[..])?;
-        }
-        z => panic!("Unsupported ipc::MetadataVersion {:?}", z),
-    };
-
-    writer.flush()?;
-
-    Ok(written)
-}
-
-/// In V4, null types have no validity bitmap
-/// In V5 and later, null and union types have no validity bitmap
-fn has_validity_bitmap(data_type: &DataType, write_options: &IpcWriteOptions) -> bool {
-    if write_options.metadata_version < ipc::MetadataVersion::V5 {
-        !matches!(data_type, DataType::Null)
-    } else {
-        !matches!(data_type, DataType::Null | DataType::Union(_, _, _))
-    }
-}
-
-/// Whether to truncate the buffer
-#[inline]
-fn buffer_need_truncate(
-    array_offset: usize,
-    buffer: &Buffer,
-    spec: &BufferSpec,
-    min_length: usize,
-) -> bool {
-    spec != &BufferSpec::AlwaysNull && (array_offset != 0 || min_length < buffer.len())
-}
-
-/// Returns byte width for a buffer spec. Only for `BufferSpec::FixedWidth`.
-#[inline]
-fn get_buffer_element_width(spec: &BufferSpec) -> usize {
-    match spec {
-        BufferSpec::FixedWidth { byte_width } => *byte_width,
-        _ => 0,
-    }
-}
-
-/// Returns byte width for binary value_offset buffer spec.
-#[inline]
-fn get_value_offset_byte_width(data_type: &DataType) -> usize {
-    match data_type {
-        DataType::Binary | DataType::Utf8 => 4,
-        DataType::LargeBinary | DataType::LargeUtf8 => 8,
-        _ => unreachable!(),
-    }
-}
-
-/// Returns the number of total bytes in base binary arrays.
-fn get_binary_buffer_len(array_data: &ArrayData) -> usize {
-    if array_data.is_empty() {
-        return 0;
-    }
-    match array_data.data_type() {
-        DataType::Binary => {
-            let array: BinaryArray = array_data.clone().into();
-            let offsets = array.value_offsets();
-            (offsets[array_data.len()] - offsets[0]) as usize
-        }
-        DataType::LargeBinary => {
-            let array: LargeBinaryArray = array_data.clone().into();
-            let offsets = array.value_offsets();
-            (offsets[array_data.len()] - offsets[0]) as usize
-        }
-        DataType::Utf8 => {
-            let array: StringArray = array_data.clone().into();
-            let offsets = array.value_offsets();
-            (offsets[array_data.len()] - offsets[0]) as usize
-        }
-        DataType::LargeUtf8 => {
-            let array: LargeStringArray = array_data.clone().into();
-            let offsets = array.value_offsets();
-            (offsets[array_data.len()] - offsets[0]) as usize
-        }
-        _ => unreachable!(),
-    }
-}
-
-/// Rebase value offsets for given ArrayData to zero-based.
-fn get_zero_based_value_offsets<OffsetSize: OffsetSizeTrait>(
-    array_data: &ArrayData,
-) -> Buffer {
-    match array_data.data_type() {
-        DataType::Binary | DataType::LargeBinary => {
-            let array: GenericBinaryArray<OffsetSize> = array_data.clone().into();
-            let offsets = array.value_offsets();
-            let start_offset = offsets[0];
-
-            let mut builder = BufferBuilder::<OffsetSize>::new(array_data.len() + 1);
-            for x in offsets {
-                builder.append(*x - start_offset);
-            }
-
-            builder.finish()
-        }
-        DataType::Utf8 | DataType::LargeUtf8 => {
-            let array: GenericStringArray<OffsetSize> = array_data.clone().into();
-            let offsets = array.value_offsets();
-            let start_offset = offsets[0];
-
-            let mut builder = BufferBuilder::<OffsetSize>::new(array_data.len() + 1);
-            for x in offsets {
-                builder.append(*x - start_offset);
-            }
-
-            builder.finish()
-        }
-        _ => unreachable!(),
-    }
-}
-
-/// Returns the start offset of base binary array.
-fn get_buffer_offset<OffsetSize: OffsetSizeTrait>(array_data: &ArrayData) -> OffsetSize {
-    match array_data.data_type() {
-        DataType::Binary | DataType::LargeBinary => {
-            let array: GenericBinaryArray<OffsetSize> = array_data.clone().into();
-            let offsets = array.value_offsets();
-            offsets[0]
-        }
-        DataType::Utf8 | DataType::LargeUtf8 => {
-            let array: GenericStringArray<OffsetSize> = array_data.clone().into();
-            let offsets = array.value_offsets();
-            offsets[0]
-        }
-        _ => unreachable!(),
-    }
-}
-
-/// Write array data to a vector of bytes
-#[allow(clippy::too_many_arguments)]
-fn write_array_data(
-    array_data: &ArrayData,
-    buffers: &mut Vec<ipc::Buffer>,
-    arrow_data: &mut Vec<u8>,
-    nodes: &mut Vec<ipc::FieldNode>,
-    offset: i64,
-    num_rows: usize,
-    null_count: usize,
-    write_options: &IpcWriteOptions,
-) -> i64 {
-    let mut offset = offset;
-    if !matches!(array_data.data_type(), DataType::Null) {
-        nodes.push(ipc::FieldNode::new(num_rows as i64, null_count as i64));
-    } else {
-        // NullArray's null_count equals to len, but the `null_count` passed in is from ArrayData
-        // where null_count is always 0.
-        nodes.push(ipc::FieldNode::new(num_rows as i64, num_rows as i64));
-    }
-    if has_validity_bitmap(array_data.data_type(), write_options) {
-        // write null buffer if exists
-        let null_buffer = match array_data.null_buffer() {
-            None => {
-                // create a buffer and fill it with valid bits
-                let num_bytes = bit_util::ceil(num_rows, 8);
-                let buffer = MutableBuffer::new(num_bytes);
-                let buffer = buffer.with_bitset(num_bytes, true);
-                buffer.into()
-            }
-            Some(buffer) => buffer.bit_slice(array_data.offset(), array_data.len()),
-        };
-
-        offset = write_buffer(null_buffer.as_slice(), buffers, arrow_data, offset);
-    }
-
-    let data_type = array_data.data_type();
-    if matches!(
-        data_type,
-        DataType::Binary | DataType::LargeBinary | DataType::Utf8 | DataType::LargeUtf8
-    ) {
-        let offset_buffer = &array_data.buffers()[0];
-        let value_offset_byte_width = get_value_offset_byte_width(data_type);
-        let min_length = (array_data.len() + 1) * value_offset_byte_width;
-        if buffer_need_truncate(
-            array_data.offset(),
-            offset_buffer,
-            &BufferSpec::FixedWidth {
-                byte_width: value_offset_byte_width,
-            },
-            min_length,
-        ) {
-            // Rebase offsets and truncate values
-            let (new_offsets, byte_offset) =
-                if matches!(data_type, DataType::Binary | DataType::Utf8) {
-                    (
-                        get_zero_based_value_offsets::<i32>(array_data),
-                        get_buffer_offset::<i32>(array_data) as usize,
-                    )
-                } else {
-                    (
-                        get_zero_based_value_offsets::<i64>(array_data),
-                        get_buffer_offset::<i64>(array_data) as usize,
-                    )
-                };
-
-            offset = write_buffer(new_offsets.as_slice(), buffers, arrow_data, offset);
-
-            let total_bytes = get_binary_buffer_len(array_data);
-            let value_buffer = &array_data.buffers()[1];
-            let buffer_length = min(total_bytes, value_buffer.len() - byte_offset);
-            let buffer_slice =
-                &value_buffer.as_slice()[byte_offset..(byte_offset + buffer_length)];
-            offset = write_buffer(buffer_slice, buffers, arrow_data, offset);
-        } else {
-            array_data.buffers().iter().for_each(|buffer| {
-                offset = write_buffer(buffer.as_slice(), buffers, arrow_data, offset);
-            });
-        }
-    } else if DataType::is_numeric(data_type)
-        || DataType::is_temporal(data_type)
-        || matches!(
-            array_data.data_type(),
-            DataType::FixedSizeBinary(_) | DataType::Dictionary(_, _)
-        )
-    {
-        // Truncate values
-        assert!(array_data.buffers().len() == 1);
-
-        let buffer = &array_data.buffers()[0];
-        let layout = layout(data_type);
-        let spec = &layout.buffers[0];
-
-        let byte_width = get_buffer_element_width(spec);
-        let min_length = array_data.len() * byte_width;
-        if buffer_need_truncate(array_data.offset(), buffer, spec, min_length) {
-            let byte_offset = array_data.offset() * byte_width;
-            let buffer_length = min(min_length, buffer.len() - byte_offset);
-            let buffer_slice =
-                &buffer.as_slice()[byte_offset..(byte_offset + buffer_length)];
-            offset = write_buffer(buffer_slice, buffers, arrow_data, offset);
-        } else {
-            offset = write_buffer(buffer.as_slice(), buffers, arrow_data, offset);
-        }
-    } else {
-        array_data.buffers().iter().for_each(|buffer| {
-            offset = write_buffer(buffer, buffers, arrow_data, offset);
-        });
-    }
-
-    if !matches!(array_data.data_type(), DataType::Dictionary(_, _)) {
-        // recursively write out nested structures
-        array_data.child_data().iter().for_each(|data_ref| {
-            // write the nested data (e.g list data)
-            offset = write_array_data(
-                data_ref,
-                buffers,
-                arrow_data,
-                nodes,
-                offset,
-                data_ref.len(),
-                data_ref.null_count(),
-                write_options,
-            );
-        });
-    }
-
-    offset
-}
-
-/// Write a buffer to a vector of bytes, and add its ipc::Buffer to a vector
-fn write_buffer(
-    buffer: &[u8],
-    buffers: &mut Vec<ipc::Buffer>,
-    arrow_data: &mut Vec<u8>,
-    offset: i64,
-) -> i64 {
-    let len = buffer.len();
-    let pad_len = pad_to_8(len as u32);
-    let total_len: i64 = (len + pad_len) as i64;
-    // assert_eq!(len % 8, 0, "Buffer width not a multiple of 8 bytes");
-    buffers.push(ipc::Buffer::new(offset, total_len));
-    arrow_data.extend_from_slice(buffer);
-    arrow_data.extend_from_slice(&vec![0u8; pad_len][..]);
-    offset + total_len
-}
-
-/// Calculate an 8-byte boundary and return the number of bytes needed to pad to 8 bytes
-#[inline]
-fn pad_to_8(len: u32) -> usize {
-    (((len + 7) & !7) - len) as usize
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use std::fs::File;
-    use std::io::Read;
-    use std::sync::Arc;
-
-    use flate2::read::GzDecoder;
-    use ipc::MetadataVersion;
-
-    use crate::array::*;
-    use crate::datatypes::Field;
-    use crate::ipc::reader::*;
-    use crate::util::integration_util::*;
-
-    #[test]
-    fn test_write_file() {
-        let schema = Schema::new(vec![Field::new("field1", DataType::UInt32, true)]);
-        let values: Vec<Option<u32>> = vec![
-            Some(999),
-            None,
-            Some(235),
-            Some(123),
-            None,
-            None,
-            None,
-            None,
-            None,
-        ];
-        let array1 = UInt32Array::from(values);
-        let batch = RecordBatch::try_new(
-            Arc::new(schema.clone()),
-            vec![Arc::new(array1) as ArrayRef],
-        )
-        .unwrap();
-        {
-            let file = File::create("target/debug/testdata/arrow.arrow_file").unwrap();
-            let mut writer = FileWriter::try_new(file, &schema).unwrap();
-
-            writer.write(&batch).unwrap();
-            writer.finish().unwrap();
-        }
-
-        {
-            let file =
-                File::open(format!("target/debug/testdata/{}.arrow_file", "arrow"))
-                    .unwrap();
-            let mut reader = FileReader::try_new(file, None).unwrap();
-            while let Some(Ok(read_batch)) = reader.next() {
-                read_batch
-                    .columns()
-                    .iter()
-                    .zip(batch.columns())
-                    .for_each(|(a, b)| {
-                        assert_eq!(a.data_type(), b.data_type());
-                        assert_eq!(a.len(), b.len());
-                        assert_eq!(a.null_count(), b.null_count());
-                    });
-            }
-        }
-    }
-
-    fn write_null_file(options: IpcWriteOptions, suffix: &str) {
-        let schema = Schema::new(vec![
-            Field::new("nulls", DataType::Null, true),
-            Field::new("int32s", DataType::Int32, false),
-            Field::new("nulls2", DataType::Null, true),
-            Field::new("f64s", DataType::Float64, false),
-        ]);
-        let array1 = NullArray::new(32);
-        let array2 = Int32Array::from(vec![1; 32]);
-        let array3 = NullArray::new(32);
-        let array4 = Float64Array::from(vec![std::f64::NAN; 32]);
-        let batch = RecordBatch::try_new(
-            Arc::new(schema.clone()),
-            vec![
-                Arc::new(array1) as ArrayRef,
-                Arc::new(array2) as ArrayRef,
-                Arc::new(array3) as ArrayRef,
-                Arc::new(array4) as ArrayRef,
-            ],
-        )
-        .unwrap();
-        let file_name = format!("target/debug/testdata/nulls_{}.arrow_file", suffix);
-        {
-            let file = File::create(&file_name).unwrap();
-            let mut writer =
-                FileWriter::try_new_with_options(file, &schema, options).unwrap();
-
-            writer.write(&batch).unwrap();
-            writer.finish().unwrap();
-        }
-
-        {
-            let file = File::open(&file_name).unwrap();
-            let reader = FileReader::try_new(file, None).unwrap();
-            reader.for_each(|maybe_batch| {
-                maybe_batch
-                    .unwrap()
-                    .columns()
-                    .iter()
-                    .zip(batch.columns())
-                    .for_each(|(a, b)| {
-                        assert_eq!(a.data_type(), b.data_type());
-                        assert_eq!(a.len(), b.len());
-                        assert_eq!(a.null_count(), b.null_count());
-                    });
-            });
-        }
-    }
-    #[test]
-    fn test_write_null_file_v4() {
-        write_null_file(
-            IpcWriteOptions::try_new(8, false, MetadataVersion::V4).unwrap(),
-            "v4_a8",
-        );
-        write_null_file(
-            IpcWriteOptions::try_new(8, true, MetadataVersion::V4).unwrap(),
-            "v4_a8l",
-        );
-        write_null_file(
-            IpcWriteOptions::try_new(64, false, MetadataVersion::V4).unwrap(),
-            "v4_a64",
-        );
-        write_null_file(
-            IpcWriteOptions::try_new(64, true, MetadataVersion::V4).unwrap(),
-            "v4_a64l",
-        );
-    }
-
-    #[test]
-    fn test_write_null_file_v5() {
-        write_null_file(
-            IpcWriteOptions::try_new(8, false, MetadataVersion::V5).unwrap(),
-            "v5_a8",
-        );
-        write_null_file(
-            IpcWriteOptions::try_new(64, false, MetadataVersion::V5).unwrap(),
-            "v5_a64",
-        );
-    }
-
-    #[test]
-    #[cfg(not(feature = "force_validate"))]
-    fn read_and_rewrite_generated_files_014() {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let version = "0.14.1";
-        // the test is repetitive, thus we can read all supported files at once
-        let paths = vec![
-            "generated_interval",
-            "generated_datetime",
-            "generated_dictionary",
-            "generated_map",
-            "generated_nested",
-            "generated_primitive_no_batches",
-            "generated_primitive_zerolength",
-            "generated_primitive",
-            "generated_decimal",
-        ];
-        paths.iter().for_each(|path| {
-            let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/{}/{}.arrow_file",
-                testdata, version, path
-            ))
-            .unwrap();
-
-            let mut reader = FileReader::try_new(file, None).unwrap();
-
-            // read and rewrite the file to a temp location
-            {
-                let file = File::create(format!(
-                    "target/debug/testdata/{}-{}.arrow_file",
-                    version, path
-                ))
-                .unwrap();
-                let mut writer = FileWriter::try_new(file, &reader.schema()).unwrap();
-                while let Some(Ok(batch)) = reader.next() {
-                    writer.write(&batch).unwrap();
-                }
-                writer.finish().unwrap();
-            }
-
-            let file = File::open(format!(
-                "target/debug/testdata/{}-{}.arrow_file",
-                version, path
-            ))
-            .unwrap();
-            let mut reader = FileReader::try_new(file, None).unwrap();
-
-            // read expected JSON output
-            let arrow_json = read_gzip_json(version, path);
-            assert!(arrow_json.equals_reader(&mut reader).unwrap());
-        });
-    }
-
-    #[test]
-    #[cfg(not(feature = "force_validate"))]
-    fn read_and_rewrite_generated_streams_014() {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let version = "0.14.1";
-        // the test is repetitive, thus we can read all supported files at once
-        let paths = vec![
-            "generated_interval",
-            "generated_datetime",
-            "generated_dictionary",
-            "generated_map",
-            "generated_nested",
-            "generated_primitive_no_batches",
-            "generated_primitive_zerolength",
-            "generated_primitive",
-            "generated_decimal",
-        ];
-        paths.iter().for_each(|path| {
-            let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/{}/{}.stream",
-                testdata, version, path
-            ))
-            .unwrap();
-
-            let reader = StreamReader::try_new(file, None).unwrap();
-
-            // read and rewrite the stream to a temp location
-            {
-                let file = File::create(format!(
-                    "target/debug/testdata/{}-{}.stream",
-                    version, path
-                ))
-                .unwrap();
-                let mut writer = StreamWriter::try_new(file, &reader.schema()).unwrap();
-                reader.for_each(|batch| {
-                    writer.write(&batch.unwrap()).unwrap();
-                });
-                writer.finish().unwrap();
-            }
-
-            let file =
-                File::open(format!("target/debug/testdata/{}-{}.stream", version, path))
-                    .unwrap();
-            let mut reader = StreamReader::try_new(file, None).unwrap();
-
-            // read expected JSON output
-            let arrow_json = read_gzip_json(version, path);
-            assert!(arrow_json.equals_reader(&mut reader).unwrap());
-        });
-    }
-
-    #[test]
-    fn read_and_rewrite_generated_files_100() {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let version = "1.0.0-littleendian";
-        // the test is repetitive, thus we can read all supported files at once
-        let paths = vec![
-            "generated_custom_metadata",
-            "generated_datetime",
-            "generated_dictionary_unsigned",
-            "generated_dictionary",
-            // "generated_duplicate_fieldnames",
-            "generated_interval",
-            "generated_map",
-            "generated_nested",
-            // "generated_nested_large_offsets",
-            "generated_null_trivial",
-            "generated_null",
-            "generated_primitive_large_offsets",
-            "generated_primitive_no_batches",
-            "generated_primitive_zerolength",
-            "generated_primitive",
-            // "generated_recursive_nested",
-        ];
-        paths.iter().for_each(|path| {
-            let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/{}/{}.arrow_file",
-                testdata, version, path
-            ))
-            .unwrap();
-
-            let mut reader = FileReader::try_new(file, None).unwrap();
-
-            // read and rewrite the file to a temp location
-            {
-                let file = File::create(format!(
-                    "target/debug/testdata/{}-{}.arrow_file",
-                    version, path
-                ))
-                .unwrap();
-                // write IPC version 5
-                let options =
-                    IpcWriteOptions::try_new(8, false, ipc::MetadataVersion::V5).unwrap();
-                let mut writer =
-                    FileWriter::try_new_with_options(file, &reader.schema(), options)
-                        .unwrap();
-                while let Some(Ok(batch)) = reader.next() {
-                    writer.write(&batch).unwrap();
-                }
-                writer.finish().unwrap();
-            }
-
-            let file = File::open(format!(
-                "target/debug/testdata/{}-{}.arrow_file",
-                version, path
-            ))
-            .unwrap();
-            let mut reader = FileReader::try_new(file, None).unwrap();
-
-            // read expected JSON output
-            let arrow_json = read_gzip_json(version, path);
-            assert!(arrow_json.equals_reader(&mut reader).unwrap());
-        });
-    }
-
-    #[test]
-    fn read_and_rewrite_generated_streams_100() {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let version = "1.0.0-littleendian";
-        // the test is repetitive, thus we can read all supported files at once
-        let paths = vec![
-            "generated_custom_metadata",
-            "generated_datetime",
-            "generated_dictionary_unsigned",
-            "generated_dictionary",
-            // "generated_duplicate_fieldnames",
-            "generated_interval",
-            "generated_map",
-            "generated_nested",
-            // "generated_nested_large_offsets",
-            "generated_null_trivial",
-            "generated_null",
-            "generated_primitive_large_offsets",
-            "generated_primitive_no_batches",
-            "generated_primitive_zerolength",
-            "generated_primitive",
-            // "generated_recursive_nested",
-        ];
-        paths.iter().for_each(|path| {
-            let file = File::open(format!(
-                "{}/arrow-ipc-stream/integration/{}/{}.stream",
-                testdata, version, path
-            ))
-            .unwrap();
-
-            let reader = StreamReader::try_new(file, None).unwrap();
-
-            // read and rewrite the stream to a temp location
-            {
-                let file = File::create(format!(
-                    "target/debug/testdata/{}-{}.stream",
-                    version, path
-                ))
-                .unwrap();
-                let options =
-                    IpcWriteOptions::try_new(8, false, ipc::MetadataVersion::V5).unwrap();
-                let mut writer =
-                    StreamWriter::try_new_with_options(file, &reader.schema(), options)
-                        .unwrap();
-                reader.for_each(|batch| {
-                    writer.write(&batch.unwrap()).unwrap();
-                });
-                writer.finish().unwrap();
-            }
-
-            let file =
-                File::open(format!("target/debug/testdata/{}-{}.stream", version, path))
-                    .unwrap();
-            let mut reader = StreamReader::try_new(file, None).unwrap();
-
-            // read expected JSON output
-            let arrow_json = read_gzip_json(version, path);
-            assert!(arrow_json.equals_reader(&mut reader).unwrap());
-        });
-    }
-
-    /// Read gzipped JSON file
-    fn read_gzip_json(version: &str, path: &str) -> ArrowJson {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let file = File::open(format!(
-            "{}/arrow-ipc-stream/integration/{}/{}.json.gz",
-            testdata, version, path
-        ))
-        .unwrap();
-        let mut gz = GzDecoder::new(&file);
-        let mut s = String::new();
-        gz.read_to_string(&mut s).unwrap();
-        // convert to Arrow JSON
-        let arrow_json: ArrowJson = serde_json::from_str(&s).unwrap();
-        arrow_json
-    }
-
-    #[test]
-    fn track_union_nested_dict() {
-        let inner: DictionaryArray<Int32Type> = vec!["a", "b", "a"].into_iter().collect();
-
-        let array = Arc::new(inner) as ArrayRef;
-
-        // Dict field with id 2
-        let dctfield =
-            Field::new_dict("dict", array.data_type().clone(), false, 2, false);
-
-        let types = Buffer::from_slice_ref(&[0_i8, 0, 0]);
-        let offsets = Buffer::from_slice_ref(&[0_i32, 1, 2]);
-
-        let union =
-            UnionArray::try_new(&[0], types, Some(offsets), vec![(dctfield, array)])
-                .unwrap();
-
-        let schema = Arc::new(Schema::new(vec![Field::new(
-            "union",
-            union.data_type().clone(),
-            false,
-        )]));
-
-        let batch = RecordBatch::try_new(schema, vec![Arc::new(union)]).unwrap();
-
-        let gen = IpcDataGenerator {};
-        let mut dict_tracker = DictionaryTracker::new(false);
-        gen.encoded_batch(&batch, &mut dict_tracker, &Default::default())
-            .unwrap();
-
-        // Dictionary with id 2 should have been written to the dict tracker
-        assert!(dict_tracker.written.contains_key(&2));
-    }
-
-    #[test]
-    fn track_struct_nested_dict() {
-        let inner: DictionaryArray<Int32Type> = vec!["a", "b", "a"].into_iter().collect();
-
-        let array = Arc::new(inner) as ArrayRef;
-
-        // Dict field with id 2
-        let dctfield =
-            Field::new_dict("dict", array.data_type().clone(), false, 2, false);
-
-        let s = StructArray::from(vec![(dctfield, array)]);
-        let struct_array = Arc::new(s) as ArrayRef;
-
-        let schema = Arc::new(Schema::new(vec![Field::new(
-            "struct",
-            struct_array.data_type().clone(),
-            false,
-        )]));
-
-        let batch = RecordBatch::try_new(schema, vec![struct_array]).unwrap();
-
-        let gen = IpcDataGenerator {};
-        let mut dict_tracker = DictionaryTracker::new(false);
-        gen.encoded_batch(&batch, &mut dict_tracker, &Default::default())
-            .unwrap();
-
-        // Dictionary with id 2 should have been written to the dict tracker
-        assert!(dict_tracker.written.contains_key(&2));
-    }
-
-    #[test]
-    fn read_union_017() {
-        let testdata = crate::util::test_util::arrow_test_data();
-        let version = "0.17.1";
-        let data_file = File::open(format!(
-            "{}/arrow-ipc-stream/integration/0.17.1/generated_union.stream",
-            testdata,
-        ))
-        .unwrap();
-
-        let reader = StreamReader::try_new(data_file, None).unwrap();
-
-        // read and rewrite the stream to a temp location
-        {
-            let file = File::create(format!(
-                "target/debug/testdata/{}-generated_union.stream",
-                version
-            ))
-            .unwrap();
-            let mut writer = StreamWriter::try_new(file, &reader.schema()).unwrap();
-            reader.for_each(|batch| {
-                writer.write(&batch.unwrap()).unwrap();
-            });
-            writer.finish().unwrap();
-        }
-
-        // Compare original file and rewrote file
-        let file = File::open(format!(
-            "target/debug/testdata/{}-generated_union.stream",
-            version
-        ))
-        .unwrap();
-        let rewrite_reader = StreamReader::try_new(file, None).unwrap();
-
-        let data_file = File::open(format!(
-            "{}/arrow-ipc-stream/integration/0.17.1/generated_union.stream",
-            testdata,
-        ))
-        .unwrap();
-        let reader = StreamReader::try_new(data_file, None).unwrap();
-
-        reader.into_iter().zip(rewrite_reader.into_iter()).for_each(
-            |(batch1, batch2)| {
-                assert_eq!(batch1.unwrap(), batch2.unwrap());
-            },
-        );
-    }
-
-    fn write_union_file(options: IpcWriteOptions) {
-        let schema = Schema::new(vec![Field::new(
-            "union",
-            DataType::Union(
-                vec![
-                    Field::new("a", DataType::Int32, false),
-                    Field::new("c", DataType::Float64, false),
-                ],
-                vec![0, 1],
-                UnionMode::Sparse,
-            ),
-            true,
-        )]);
-        let mut builder = UnionBuilder::new_sparse(5);
-        builder.append::<Int32Type>("a", 1).unwrap();
-        builder.append_null::<Int32Type>("a").unwrap();
-        builder.append::<Float64Type>("c", 3.0).unwrap();
-        builder.append_null::<Float64Type>("c").unwrap();
-        builder.append::<Int32Type>("a", 4).unwrap();
-        let union = builder.build().unwrap();
-
-        let batch = RecordBatch::try_new(
-            Arc::new(schema.clone()),
-            vec![Arc::new(union) as ArrayRef],
-        )
-        .unwrap();
-        let file_name = "target/debug/testdata/union.arrow_file";
-        {
-            let file = File::create(&file_name).unwrap();
-            let mut writer =
-                FileWriter::try_new_with_options(file, &schema, options).unwrap();
-
-            writer.write(&batch).unwrap();
-            writer.finish().unwrap();
-        }
-
-        {
-            let file = File::open(&file_name).unwrap();
-            let reader = FileReader::try_new(file, None).unwrap();
-            reader.for_each(|maybe_batch| {
-                maybe_batch
-                    .unwrap()
-                    .columns()
-                    .iter()
-                    .zip(batch.columns())
-                    .for_each(|(a, b)| {
-                        assert_eq!(a.data_type(), b.data_type());
-                        assert_eq!(a.len(), b.len());
-                        assert_eq!(a.null_count(), b.null_count());
-                    });
-            });
-        }
-    }
-
-    #[test]
-    fn test_write_union_file_v4_v5() {
-        write_union_file(
-            IpcWriteOptions::try_new(8, false, MetadataVersion::V4).unwrap(),
-        );
-        write_union_file(
-            IpcWriteOptions::try_new(8, false, MetadataVersion::V5).unwrap(),
-        );
-    }
-
-    fn serialize(record: &RecordBatch) -> Vec<u8> {
-        let buffer: Vec<u8> = Vec::new();
-        let mut stream_writer = StreamWriter::try_new(buffer, &record.schema()).unwrap();
-        stream_writer.write(record).unwrap();
-        stream_writer.finish().unwrap();
-        stream_writer.into_inner().unwrap()
-    }
-
-    fn deserialize(bytes: Vec<u8>) -> RecordBatch {
-        let mut stream_reader =
-            ipc::reader::StreamReader::try_new(std::io::Cursor::new(bytes), None)
-                .unwrap();
-        stream_reader.next().unwrap().unwrap()
-    }
-
-    #[test]
-    fn truncate_ipc_record_batch() {
-        fn create_batch(rows: usize) -> RecordBatch {
-            let schema = Schema::new(vec![
-                Field::new("a", DataType::Int32, false),
-                Field::new("b", DataType::Utf8, false),
-            ]);
-
-            let a = Int32Array::from_iter_values(0..rows as i32);
-            let b = StringArray::from_iter_values((0..rows).map(|i| i.to_string()));
-
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)])
-                .unwrap()
-        }
-
-        let big_record_batch = create_batch(65536);
-
-        let length = 5;
-        let small_record_batch = create_batch(length);
-
-        let offset = 2;
-        let record_batch_slice = big_record_batch.slice(offset, length);
-        assert!(
-            serialize(&big_record_batch).len() > serialize(&small_record_batch).len()
-        );
-        assert_eq!(
-            serialize(&small_record_batch).len(),
-            serialize(&record_batch_slice).len()
-        );
-
-        assert_eq!(
-            deserialize(serialize(&record_batch_slice)),
-            record_batch_slice
-        );
-    }
-
-    #[test]
-    fn truncate_ipc_record_batch_with_nulls() {
-        fn create_batch() -> RecordBatch {
-            let schema = Schema::new(vec![
-                Field::new("a", DataType::Int32, true),
-                Field::new("b", DataType::Utf8, true),
-            ]);
-
-            let a = Int32Array::from(vec![Some(1), None, Some(1), None, Some(1)]);
-            let b = StringArray::from(vec![None, Some("a"), Some("a"), None, Some("a")]);
-
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)])
-                .unwrap()
-        }
-
-        let record_batch = create_batch();
-        let record_batch_slice = record_batch.slice(1, 2);
-        let deserialized_batch = deserialize(serialize(&record_batch_slice));
-
-        assert!(serialize(&record_batch).len() > serialize(&record_batch_slice).len());
-
-        assert!(deserialized_batch.column(0).is_null(0));
-        assert!(deserialized_batch.column(0).is_valid(1));
-        assert!(deserialized_batch.column(1).is_valid(0));
-        assert!(deserialized_batch.column(1).is_valid(1));
-
-        assert_eq!(record_batch_slice, deserialized_batch);
-    }
-
-    #[test]
-    fn truncate_ipc_dictionary_array() {
-        fn create_batch() -> RecordBatch {
-            let values: StringArray = [Some("foo"), Some("bar"), Some("baz")]
-                .into_iter()
-                .collect();
-            let keys: Int32Array =
-                [Some(0), Some(2), None, Some(1)].into_iter().collect();
-
-            let array = DictionaryArray::<Int32Type>::try_new(&keys, &values).unwrap();
-
-            let schema =
-                Schema::new(vec![Field::new("dict", array.data_type().clone(), true)]);
-
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(array)]).unwrap()
-        }
-
-        let record_batch = create_batch();
-        let record_batch_slice = record_batch.slice(1, 2);
-        let deserialized_batch = deserialize(serialize(&record_batch_slice));
-
-        assert!(serialize(&record_batch).len() > serialize(&record_batch_slice).len());
-
-        assert!(deserialized_batch.column(0).is_valid(0));
-        assert!(deserialized_batch.column(0).is_null(1));
-
-        assert_eq!(record_batch_slice, deserialized_batch);
-    }
-
-    #[test]
-    fn truncate_ipc_struct_array() {
-        fn create_batch() -> RecordBatch {
-            let strings: StringArray = [Some("foo"), None, Some("bar"), Some("baz")]
-                .into_iter()
-                .collect();
-            let ints: Int32Array =
-                [Some(0), Some(2), None, Some(1)].into_iter().collect();
-
-            let struct_array = StructArray::from(vec![
-                (
-                    Field::new("s", DataType::Utf8, true),
-                    Arc::new(strings) as ArrayRef,
-                ),
-                (
-                    Field::new("c", DataType::Int32, false),
-                    Arc::new(ints) as ArrayRef,
-                ),
-            ]);
-
-            let schema = Schema::new(vec![Field::new(
-                "struct_array",
-                struct_array.data_type().clone(),
-                true,
-            )]);
-
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(struct_array)]).unwrap()
-        }
-
-        let record_batch = create_batch();
-        let record_batch_slice = record_batch.slice(1, 2);
-        let deserialized_batch = deserialize(serialize(&record_batch_slice));
-
-        assert!(serialize(&record_batch).len() > serialize(&record_batch_slice).len());
-
-        let structs = deserialized_batch
-            .column(0)
-            .as_any()
-            .downcast_ref::<StructArray>()
-            .unwrap();
-
-        assert!(structs.column(0).is_null(0));
-        assert!(structs.column(0).is_valid(1));
-        assert!(structs.column(1).is_valid(0));
-        assert!(structs.column(1).is_null(1));
-        assert_eq!(record_batch_slice, deserialized_batch);
-    }
-
-    #[test]
-    fn truncate_ipc_string_array_with_all_empty_string() {
-        fn create_batch() -> RecordBatch {
-            let schema = Schema::new(vec![Field::new("a", DataType::Utf8, true)]);
-            let a =
-                StringArray::from(vec![Some(""), Some(""), Some(""), Some(""), Some("")]);
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap()
-        }
-
-        let record_batch = create_batch();
-        let record_batch_slice = record_batch.slice(0, 1);
-        let deserialized_batch = deserialize(serialize(&record_batch_slice));
-
-        assert!(serialize(&record_batch).len() > serialize(&record_batch_slice).len());
-        assert_eq!(record_batch_slice, deserialized_batch);
-    }
-}
diff --git a/arrow/src/json/reader.rs b/arrow/src/json/reader.rs
deleted file mode 100644
index 66fdc691887b..000000000000
--- a/arrow/src/json/reader.rs
+++ /dev/null
@@ -1,3331 +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.
-
-//! # JSON Reader
-//!
-//! This JSON reader allows JSON line-delimited files to be read into the Arrow memory
-//! model. Records are loaded in batches and are then converted from row-based data to
-//! columnar data.
-//!
-//! Example:
-//!
-//! ```
-//! use arrow::datatypes::{DataType, Field, Schema};
-//! use arrow::json;
-//! use std::fs::File;
-//! use std::io::BufReader;
-//! use std::sync::Arc;
-//!
-//! let schema = Schema::new(vec![
-//!     Field::new("a", DataType::Float64, false),
-//!     Field::new("b", DataType::Float64, false),
-//!     Field::new("c", DataType::Float64, true),
-//! ]);
-//!
-//! let file = File::open("test/data/basic.json").unwrap();
-//!
-//! let mut json = json::Reader::new(
-//!    BufReader::new(file),
-//!    Arc::new(schema),
-//!    json::reader::DecoderOptions::new(),
-//! );
-//!
-//! let batch = json.next().unwrap().unwrap();
-//! ```
-
-use std::io::{BufRead, BufReader, Read, Seek, SeekFrom};
-use std::sync::Arc;
-
-use indexmap::map::IndexMap as HashMap;
-use indexmap::set::IndexSet as HashSet;
-use serde_json::json;
-use serde_json::{map::Map as JsonMap, Value};
-
-use crate::buffer::MutableBuffer;
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-use crate::record_batch::RecordBatch;
-use crate::util::bit_util;
-use crate::util::reader_parser::Parser;
-use crate::{array::*, buffer::Buffer};
-
-#[derive(Debug, Clone)]
-enum InferredType {
-    Scalar(HashSet<DataType>),
-    Array(Box<InferredType>),
-    Object(HashMap<String, InferredType>),
-    Any,
-}
-
-impl InferredType {
-    fn merge(&mut self, other: InferredType) -> Result<()> {
-        match (self, other) {
-            (InferredType::Array(s), InferredType::Array(o)) => {
-                s.merge(*o)?;
-            }
-            (InferredType::Scalar(self_hs), InferredType::Scalar(other_hs)) => {
-                other_hs.into_iter().for_each(|v| {
-                    self_hs.insert(v);
-                });
-            }
-            (InferredType::Object(self_map), InferredType::Object(other_map)) => {
-                for (k, v) in other_map {
-                    self_map.entry(k).or_insert(InferredType::Any).merge(v)?;
-                }
-            }
-            (s @ InferredType::Any, v) => {
-                *s = v;
-            }
-            (_, InferredType::Any) => {}
-            // convert a scalar type to a single-item scalar array type.
-            (
-                InferredType::Array(self_inner_type),
-                other_scalar @ InferredType::Scalar(_),
-            ) => {
-                self_inner_type.merge(other_scalar)?;
-            }
-            (s @ InferredType::Scalar(_), InferredType::Array(mut other_inner_type)) => {
-                other_inner_type.merge(s.clone())?;
-                *s = InferredType::Array(other_inner_type);
-            }
-            // incompatible types
-            (s, o) => {
-                return Err(ArrowError::JsonError(format!(
-                    "Incompatible type found during schema inference: {:?} v.s. {:?}",
-                    s, o,
-                )));
-            }
-        }
-
-        Ok(())
-    }
-}
-
-/// Coerce data type during inference
-///
-/// * `Int64` and `Float64` should be `Float64`
-/// * Lists and scalars are coerced to a list of a compatible scalar
-/// * All other types are coerced to `Utf8`
-fn coerce_data_type(dt: Vec<&DataType>) -> DataType {
-    let mut dt_iter = dt.into_iter().cloned();
-    let dt_init = dt_iter.next().unwrap_or(DataType::Utf8);
-
-    dt_iter.fold(dt_init, |l, r| match (l, r) {
-        (DataType::Boolean, DataType::Boolean) => DataType::Boolean,
-        (DataType::Int64, DataType::Int64) => DataType::Int64,
-        (DataType::Float64, DataType::Float64)
-        | (DataType::Float64, DataType::Int64)
-        | (DataType::Int64, DataType::Float64) => DataType::Float64,
-        (DataType::List(l), DataType::List(r)) => DataType::List(Box::new(Field::new(
-            "item",
-            coerce_data_type(vec![l.data_type(), r.data_type()]),
-            true,
-        ))),
-        // coerce scalar and scalar array into scalar array
-        (DataType::List(e), not_list) | (not_list, DataType::List(e)) => {
-            DataType::List(Box::new(Field::new(
-                "item",
-                coerce_data_type(vec![e.data_type(), &not_list]),
-                true,
-            )))
-        }
-        _ => DataType::Utf8,
-    })
-}
-
-fn generate_datatype(t: &InferredType) -> Result<DataType> {
-    Ok(match t {
-        InferredType::Scalar(hs) => coerce_data_type(hs.iter().collect()),
-        InferredType::Object(spec) => DataType::Struct(generate_fields(spec)?),
-        InferredType::Array(ele_type) => DataType::List(Box::new(Field::new(
-            "item",
-            generate_datatype(ele_type)?,
-            true,
-        ))),
-        InferredType::Any => DataType::Null,
-    })
-}
-
-fn generate_fields(spec: &HashMap<String, InferredType>) -> Result<Vec<Field>> {
-    spec.iter()
-        .map(|(k, types)| Ok(Field::new(k, generate_datatype(types)?, true)))
-        .collect()
-}
-
-/// Generate schema from JSON field names and inferred data types
-fn generate_schema(spec: HashMap<String, InferredType>) -> Result<Schema> {
-    Ok(Schema::new(generate_fields(&spec)?))
-}
-
-/// JSON file reader that produces a serde_json::Value iterator from a Read trait
-///
-/// # Example
-///
-/// ```
-/// use std::fs::File;
-/// use std::io::BufReader;
-/// use arrow::json::reader::ValueIter;
-///
-/// let mut reader =
-///     BufReader::new(File::open("test/data/mixed_arrays.json").unwrap());
-/// let mut value_reader = ValueIter::new(&mut reader, None);
-/// for value in value_reader {
-///     println!("JSON value: {}", value.unwrap());
-/// }
-/// ```
-#[derive(Debug)]
-pub struct ValueIter<'a, R: Read> {
-    reader: &'a mut BufReader<R>,
-    max_read_records: Option<usize>,
-    record_count: usize,
-    // reuse line buffer to avoid allocation on each record
-    line_buf: String,
-}
-
-impl<'a, R: Read> ValueIter<'a, R> {
-    pub fn new(reader: &'a mut BufReader<R>, max_read_records: Option<usize>) -> Self {
-        Self {
-            reader,
-            max_read_records,
-            record_count: 0,
-            line_buf: String::new(),
-        }
-    }
-}
-
-impl<'a, R: Read> Iterator for ValueIter<'a, R> {
-    type Item = Result<Value>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        if let Some(max) = self.max_read_records {
-            if self.record_count >= max {
-                return None;
-            }
-        }
-
-        loop {
-            self.line_buf.truncate(0);
-            match self.reader.read_line(&mut self.line_buf) {
-                Ok(0) => {
-                    // read_line returns 0 when stream reached EOF
-                    return None;
-                }
-                Err(e) => {
-                    return Some(Err(ArrowError::JsonError(format!(
-                        "Failed to read JSON record: {}",
-                        e
-                    ))));
-                }
-                _ => {
-                    let trimmed_s = self.line_buf.trim();
-                    if trimmed_s.is_empty() {
-                        // ignore empty lines
-                        continue;
-                    }
-
-                    self.record_count += 1;
-                    return Some(serde_json::from_str(trimmed_s).map_err(|e| {
-                        ArrowError::JsonError(format!("Not valid JSON: {}", e))
-                    }));
-                }
-            }
-        }
-    }
-}
-
-/// Infer the fields of a JSON file by reading the first n records of the file, with
-/// `max_read_records` controlling the maximum number of records to read.
-///
-/// If `max_read_records` is not set, the whole file is read to infer its field types.
-///
-/// Contrary to [`infer_json_schema`], this function will seek back to the start of the `reader`.
-/// That way, the `reader` can be used immediately afterwards to create a [`Reader`].
-///
-/// # Examples
-/// ```
-/// use std::fs::File;
-/// use std::io::BufReader;
-/// use arrow::json::reader::infer_json_schema_from_seekable;
-///
-/// let file = File::open("test/data/mixed_arrays.json").unwrap();
-/// // file's cursor's offset at 0
-/// let mut reader = BufReader::new(file);
-/// let inferred_schema = infer_json_schema_from_seekable(&mut reader, None).unwrap();
-/// // file's cursor's offset automatically set at 0
-/// ```
-pub fn infer_json_schema_from_seekable<R: Read + Seek>(
-    reader: &mut BufReader<R>,
-    max_read_records: Option<usize>,
-) -> Result<Schema> {
-    let schema = infer_json_schema(reader, max_read_records);
-    // return the reader seek back to the start
-    reader.seek(SeekFrom::Start(0))?;
-
-    schema
-}
-
-/// Infer the fields of a JSON file by reading the first n records of the buffer, with
-/// `max_read_records` controlling the maximum number of records to read.
-///
-/// If `max_read_records` is not set, the whole file is read to infer its field types.
-///
-/// This function will not seek back to the start of the `reader`. The user has to manage the
-/// original file's cursor. This function is useful when the `reader`'s cursor is not available
-/// (does not implement [`Seek`]), such is the case for compressed streams decoders.
-///
-/// # Examples
-/// ```
-/// use std::fs::File;
-/// use std::io::{BufReader, SeekFrom, Seek};
-/// use flate2::read::GzDecoder;
-/// use arrow::json::reader::infer_json_schema;
-///
-/// let mut file = File::open("test/data/mixed_arrays.json.gz").unwrap();
-///
-/// // file's cursor's offset at 0
-/// let mut reader = BufReader::new(GzDecoder::new(&file));
-/// let inferred_schema = infer_json_schema(&mut reader, None).unwrap();
-/// // cursor's offset at end of file
-///
-/// // seek back to start so that the original file is usable again
-/// file.seek(SeekFrom::Start(0)).unwrap();
-/// ```
-pub fn infer_json_schema<R: Read>(
-    reader: &mut BufReader<R>,
-    max_read_records: Option<usize>,
-) -> Result<Schema> {
-    infer_json_schema_from_iterator(ValueIter::new(reader, max_read_records))
-}
-
-fn set_object_scalar_field_type(
-    field_types: &mut HashMap<String, InferredType>,
-    key: &str,
-    ftype: DataType,
-) -> Result<()> {
-    if !field_types.contains_key(key) {
-        field_types.insert(key.to_string(), InferredType::Scalar(HashSet::new()));
-    }
-
-    match field_types.get_mut(key).unwrap() {
-        InferredType::Scalar(hs) => {
-            hs.insert(ftype);
-            Ok(())
-        }
-        // in case of column contains both scalar type and scalar array type, we convert type of
-        // this column to scalar array.
-        scalar_array @ InferredType::Array(_) => {
-            let mut hs = HashSet::new();
-            hs.insert(ftype);
-            scalar_array.merge(InferredType::Scalar(hs))?;
-            Ok(())
-        }
-        t => Err(ArrowError::JsonError(format!(
-            "Expected scalar or scalar array JSON type, found: {:?}",
-            t,
-        ))),
-    }
-}
-
-fn infer_scalar_array_type(array: &[Value]) -> Result<InferredType> {
-    let mut hs = HashSet::new();
-
-    for v in array {
-        match v {
-            Value::Null => {}
-            Value::Number(n) => {
-                if n.is_i64() {
-                    hs.insert(DataType::Int64);
-                } else {
-                    hs.insert(DataType::Float64);
-                }
-            }
-            Value::Bool(_) => {
-                hs.insert(DataType::Boolean);
-            }
-            Value::String(_) => {
-                hs.insert(DataType::Utf8);
-            }
-            Value::Array(_) | Value::Object(_) => {
-                return Err(ArrowError::JsonError(format!(
-                    "Expected scalar value for scalar array, got: {:?}",
-                    v
-                )));
-            }
-        }
-    }
-
-    Ok(InferredType::Scalar(hs))
-}
-
-fn infer_nested_array_type(array: &[Value]) -> Result<InferredType> {
-    let mut inner_ele_type = InferredType::Any;
-
-    for v in array {
-        match v {
-            Value::Array(inner_array) => {
-                inner_ele_type.merge(infer_array_element_type(inner_array)?)?;
-            }
-            x => {
-                return Err(ArrowError::JsonError(format!(
-                    "Got non array element in nested array: {:?}",
-                    x
-                )));
-            }
-        }
-    }
-
-    Ok(InferredType::Array(Box::new(inner_ele_type)))
-}
-
-fn infer_struct_array_type(array: &[Value]) -> Result<InferredType> {
-    let mut field_types = HashMap::new();
-
-    for v in array {
-        match v {
-            Value::Object(map) => {
-                collect_field_types_from_object(&mut field_types, map)?;
-            }
-            _ => {
-                return Err(ArrowError::JsonError(format!(
-                    "Expected struct value for struct array, got: {:?}",
-                    v
-                )));
-            }
-        }
-    }
-
-    Ok(InferredType::Object(field_types))
-}
-
-fn infer_array_element_type(array: &[Value]) -> Result<InferredType> {
-    match array.iter().take(1).next() {
-        None => Ok(InferredType::Any), // empty array, return any type that can be updated later
-        Some(a) => match a {
-            Value::Array(_) => infer_nested_array_type(array),
-            Value::Object(_) => infer_struct_array_type(array),
-            _ => infer_scalar_array_type(array),
-        },
-    }
-}
-
-fn collect_field_types_from_object(
-    field_types: &mut HashMap<String, InferredType>,
-    map: &JsonMap<String, Value>,
-) -> Result<()> {
-    for (k, v) in map {
-        match v {
-            Value::Array(array) => {
-                let ele_type = infer_array_element_type(array)?;
-
-                if !field_types.contains_key(k) {
-                    match ele_type {
-                        InferredType::Scalar(_) => {
-                            field_types.insert(
-                                k.to_string(),
-                                InferredType::Array(Box::new(InferredType::Scalar(
-                                    HashSet::new(),
-                                ))),
-                            );
-                        }
-                        InferredType::Object(_) => {
-                            field_types.insert(
-                                k.to_string(),
-                                InferredType::Array(Box::new(InferredType::Object(
-                                    HashMap::new(),
-                                ))),
-                            );
-                        }
-                        InferredType::Any | InferredType::Array(_) => {
-                            // set inner type to any for nested array as well
-                            // so it can be updated properly from subsequent type merges
-                            field_types.insert(
-                                k.to_string(),
-                                InferredType::Array(Box::new(InferredType::Any)),
-                            );
-                        }
-                    }
-                }
-
-                match field_types.get_mut(k).unwrap() {
-                    InferredType::Array(inner_type) => {
-                        inner_type.merge(ele_type)?;
-                    }
-                    // in case of column contains both scalar type and scalar array type, we
-                    // convert type of this column to scalar array.
-                    field_type @ InferredType::Scalar(_) => {
-                        field_type.merge(ele_type)?;
-                        *field_type = InferredType::Array(Box::new(field_type.clone()));
-                    }
-                    t => {
-                        return Err(ArrowError::JsonError(format!(
-                            "Expected array json type, found: {:?}",
-                            t,
-                        )));
-                    }
-                }
-            }
-            Value::Bool(_) => {
-                set_object_scalar_field_type(field_types, k, DataType::Boolean)?;
-            }
-            Value::Null => {
-                // do nothing, we treat json as nullable by default when
-                // inferring
-            }
-            Value::Number(n) => {
-                if n.is_f64() {
-                    set_object_scalar_field_type(field_types, k, DataType::Float64)?;
-                } else {
-                    // default to i64
-                    set_object_scalar_field_type(field_types, k, DataType::Int64)?;
-                }
-            }
-            Value::String(_) => {
-                set_object_scalar_field_type(field_types, k, DataType::Utf8)?;
-            }
-            Value::Object(inner_map) => {
-                if !field_types.contains_key(k) {
-                    field_types
-                        .insert(k.to_string(), InferredType::Object(HashMap::new()));
-                }
-                match field_types.get_mut(k).unwrap() {
-                    InferredType::Object(inner_field_types) => {
-                        collect_field_types_from_object(inner_field_types, inner_map)?;
-                    }
-                    t => {
-                        return Err(ArrowError::JsonError(format!(
-                            "Expected object json type, found: {:?}",
-                            t,
-                        )));
-                    }
-                }
-            }
-        }
-    }
-
-    Ok(())
-}
-
-/// Infer the fields of a JSON file by reading all items from the JSON Value Iterator.
-///
-/// The following type coercion logic is implemented:
-/// * `Int64` and `Float64` are converted to `Float64`
-/// * Lists and scalars are coerced to a list of a compatible scalar
-/// * All other cases are coerced to `Utf8` (String)
-///
-/// Note that the above coercion logic is different from what Spark has, where it would default to
-/// String type in case of List and Scalar values appeared in the same field.
-///
-/// The reason we diverge here is because we don't have utilities to deal with JSON data once it's
-/// interpreted as Strings. We should match Spark's behavior once we added more JSON parsing
-/// kernels in the future.
-pub fn infer_json_schema_from_iterator<I>(value_iter: I) -> Result<Schema>
-where
-    I: Iterator<Item = Result<Value>>,
-{
-    let mut field_types: HashMap<String, InferredType> = HashMap::new();
-
-    for record in value_iter {
-        match record? {
-            Value::Object(map) => {
-                collect_field_types_from_object(&mut field_types, &map)?;
-            }
-            value => {
-                return Err(ArrowError::JsonError(format!(
-                    "Expected JSON record to be an object, found {:?}",
-                    value
-                )));
-            }
-        };
-    }
-
-    generate_schema(field_types)
-}
-
-/// JSON values to Arrow record batch decoder.
-///
-/// A [`Decoder`] decodes arbitrary streams of [`serde_json::Value`]s and
-/// converts them to [`RecordBatch`]es. To decode JSON formatted files,
-/// see [`Reader`].
-///
-/// # Examples
-/// ```
-/// use arrow::json::reader::{Decoder, DecoderOptions, ValueIter, infer_json_schema};
-/// use std::fs::File;
-/// use std::io::{BufReader, Seek, SeekFrom};
-/// use std::sync::Arc;
-///
-/// let mut reader =
-///     BufReader::new(File::open("test/data/mixed_arrays.json").unwrap());
-/// let inferred_schema = infer_json_schema(&mut reader, None).unwrap();
-/// let options = DecoderOptions::new()
-///     .with_batch_size(1024);
-/// let decoder = Decoder::new(Arc::new(inferred_schema), options);
-///
-/// // seek back to start so that the original file is usable again
-/// reader.seek(SeekFrom::Start(0)).unwrap();
-/// let mut value_reader = ValueIter::new(&mut reader, None);
-/// let batch = decoder.next_batch(&mut value_reader).unwrap().unwrap();
-/// assert_eq!(4, batch.num_rows());
-/// assert_eq!(4, batch.num_columns());
-/// ```
-#[derive(Debug)]
-pub struct Decoder {
-    /// Explicit schema for the JSON file
-    schema: SchemaRef,
-    /// This is a collection of options for json decoder
-    options: DecoderOptions,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-/// Options for JSON decoding
-pub struct DecoderOptions {
-    /// Batch size (number of records to load each time), defaults to 1024 records
-    batch_size: usize,
-    /// Optional projection for which columns to load (case-sensitive names)
-    projection: Option<Vec<String>>,
-    /// optional HashMap of column name to its format string
-    format_strings: Option<HashMap<String, String>>,
-}
-
-impl Default for DecoderOptions {
-    fn default() -> Self {
-        Self {
-            batch_size: 1024,
-            projection: None,
-            format_strings: None,
-        }
-    }
-}
-
-impl DecoderOptions {
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    /// Set the batch size (number of records to load at one time)
-    pub fn with_batch_size(mut self, batch_size: usize) -> Self {
-        self.batch_size = batch_size;
-        self
-    }
-
-    /// Set the reader's column projection
-    pub fn with_projection(mut self, projection: Vec<String>) -> Self {
-        self.projection = Some(projection);
-        self
-    }
-
-    /// Set the decoder's format Strings param
-    pub fn with_format_strings(
-        mut self,
-        format_strings: HashMap<String, String>,
-    ) -> Self {
-        self.format_strings = Some(format_strings);
-        self
-    }
-}
-
-impl Decoder {
-    /// Create a new JSON decoder from some value that implements an
-    /// iterator over [`serde_json::Value`]s (aka implements the
-    /// `Iterator<Item=Result<Value>>` trait).
-    pub fn new(schema: SchemaRef, options: DecoderOptions) -> Self {
-        Self { schema, options }
-    }
-
-    /// Returns the schema of the reader, useful for getting the schema without reading
-    /// record batches
-    pub fn schema(&self) -> SchemaRef {
-        match &self.options.projection {
-            Some(projection) => {
-                let fields = self.schema.fields();
-                let projected_fields: Vec<Field> = fields
-                    .iter()
-                    .filter_map(|field| {
-                        if projection.contains(field.name()) {
-                            Some(field.clone())
-                        } else {
-                            None
-                        }
-                    })
-                    .collect();
-
-                Arc::new(Schema::new(projected_fields))
-            }
-            None => self.schema.clone(),
-        }
-    }
-
-    /// Read the next batch of [`serde_json::Value`] records from the
-    /// interator into a [`RecordBatch`].
-    ///
-    /// Returns `None` if the input iterator is exhausted.
-    pub fn next_batch<I>(&self, value_iter: &mut I) -> Result<Option<RecordBatch>>
-    where
-        I: Iterator<Item = Result<Value>>,
-    {
-        let batch_size = self.options.batch_size;
-        let mut rows: Vec<Value> = Vec::with_capacity(batch_size);
-
-        for value in value_iter.by_ref().take(batch_size) {
-            let v = value?;
-            match v {
-                Value::Object(_) => rows.push(v),
-                _ => {
-                    return Err(ArrowError::JsonError(format!(
-                        "Row needs to be of type object, got: {:?}",
-                        v
-                    )));
-                }
-            }
-        }
-        if rows.is_empty() {
-            // reached end of file
-            return Ok(None);
-        }
-
-        let rows = &rows[..];
-        let projection = self.options.projection.clone().unwrap_or_default();
-        let arrays = self.build_struct_array(rows, self.schema.fields(), &projection);
-
-        let projected_fields: Vec<Field> = if projection.is_empty() {
-            self.schema.fields().to_vec()
-        } else {
-            projection
-                .iter()
-                .filter_map(|name| self.schema.column_with_name(name))
-                .map(|(_, field)| field.clone())
-                .collect()
-        };
-
-        let projected_schema = Arc::new(Schema::new(projected_fields));
-
-        arrays.and_then(|arr| RecordBatch::try_new(projected_schema, arr).map(Some))
-    }
-
-    fn build_wrapped_list_array(
-        &self,
-        rows: &[Value],
-        col_name: &str,
-        key_type: &DataType,
-    ) -> Result<ArrayRef> {
-        match *key_type {
-            DataType::Int8 => {
-                let dtype = DataType::Dictionary(
-                    Box::new(DataType::Int8),
-                    Box::new(DataType::Utf8),
-                );
-                self.list_array_string_array_builder::<Int8Type>(&dtype, col_name, rows)
-            }
-            DataType::Int16 => {
-                let dtype = DataType::Dictionary(
-                    Box::new(DataType::Int16),
-                    Box::new(DataType::Utf8),
-                );
-                self.list_array_string_array_builder::<Int16Type>(&dtype, col_name, rows)
-            }
-            DataType::Int32 => {
-                let dtype = DataType::Dictionary(
-                    Box::new(DataType::Int32),
-                    Box::new(DataType::Utf8),
-                );
-                self.list_array_string_array_builder::<Int32Type>(&dtype, col_name, rows)
-            }
-            DataType::Int64 => {
-                let dtype = DataType::Dictionary(
-                    Box::new(DataType::Int64),
-                    Box::new(DataType::Utf8),
-                );
-                self.list_array_string_array_builder::<Int64Type>(&dtype, col_name, rows)
-            }
-            DataType::UInt8 => {
-                let dtype = DataType::Dictionary(
-                    Box::new(DataType::UInt8),
-                    Box::new(DataType::Utf8),
-                );
-                self.list_array_string_array_builder::<UInt8Type>(&dtype, col_name, rows)
-            }
-            DataType::UInt16 => {
-                let dtype = DataType::Dictionary(
-                    Box::new(DataType::UInt16),
-                    Box::new(DataType::Utf8),
-                );
-                self.list_array_string_array_builder::<UInt16Type>(&dtype, col_name, rows)
-            }
-            DataType::UInt32 => {
-                let dtype = DataType::Dictionary(
-                    Box::new(DataType::UInt32),
-                    Box::new(DataType::Utf8),
-                );
-                self.list_array_string_array_builder::<UInt32Type>(&dtype, col_name, rows)
-            }
-            DataType::UInt64 => {
-                let dtype = DataType::Dictionary(
-                    Box::new(DataType::UInt64),
-                    Box::new(DataType::Utf8),
-                );
-                self.list_array_string_array_builder::<UInt64Type>(&dtype, col_name, rows)
-            }
-            ref e => Err(ArrowError::JsonError(format!(
-                "Data type is currently not supported for dictionaries in list : {:?}",
-                e
-            ))),
-        }
-    }
-
-    #[inline(always)]
-    fn list_array_string_array_builder<DT>(
-        &self,
-        data_type: &DataType,
-        col_name: &str,
-        rows: &[Value],
-    ) -> Result<ArrayRef>
-    where
-        DT: ArrowPrimitiveType + ArrowDictionaryKeyType,
-    {
-        let mut builder: Box<dyn ArrayBuilder> = match data_type {
-            DataType::Utf8 => {
-                let values_builder = StringBuilder::new(rows.len() * 5);
-                Box::new(ListBuilder::new(values_builder))
-            }
-            DataType::Dictionary(_, _) => {
-                let values_builder =
-                    self.build_string_dictionary_builder::<DT>(rows.len() * 5);
-                Box::new(ListBuilder::new(values_builder))
-            }
-            e => {
-                return Err(ArrowError::JsonError(format!(
-                    "Nested list data builder type is not supported: {:?}",
-                    e
-                )))
-            }
-        };
-
-        for row in rows {
-            if let Some(value) = row.get(col_name) {
-                // value can be an array or a scalar
-                let vals: Vec<Option<String>> = if let Value::String(v) = value {
-                    vec![Some(v.to_string())]
-                } else if let Value::Array(n) = value {
-                    n.iter()
-                        .map(|v: &Value| {
-                            if v.is_string() {
-                                Some(v.as_str().unwrap().to_string())
-                            } else if v.is_array() || v.is_object() || v.is_null() {
-                                // implicitly drop nested values
-                                // TODO support deep-nesting
-                                None
-                            } else {
-                                Some(v.to_string())
-                            }
-                        })
-                        .collect()
-                } else if let Value::Null = value {
-                    vec![None]
-                } else if !value.is_object() {
-                    vec![Some(value.to_string())]
-                } else {
-                    return Err(ArrowError::JsonError(
-                        "Only scalars are currently supported in JSON arrays".to_string(),
-                    ));
-                };
-
-                // TODO: ARROW-10335: APIs of dictionary arrays and others are different. Unify
-                // them.
-                match data_type {
-                    DataType::Utf8 => {
-                        let builder = builder
-                            .as_any_mut()
-                            .downcast_mut::<ListBuilder<StringBuilder>>()
-                            .ok_or_else(||ArrowError::JsonError(
-                                "Cast failed for ListBuilder<StringBuilder> during nested data parsing".to_string(),
-                            ))?;
-                        for val in vals {
-                            if let Some(v) = val {
-                                builder.values().append_value(&v);
-                            } else {
-                                builder.values().append_null();
-                            };
-                        }
-
-                        // Append to the list
-                        builder.append(true);
-                    }
-                    DataType::Dictionary(_, _) => {
-                        let builder = builder.as_any_mut().downcast_mut::<ListBuilder<StringDictionaryBuilder<DT>>>().ok_or_else(||ArrowError::JsonError(
-                            "Cast failed for ListBuilder<StringDictionaryBuilder> during nested data parsing".to_string(),
-                        ))?;
-                        for val in vals {
-                            if let Some(v) = val {
-                                let _ = builder.values().append(&v);
-                            } else {
-                                builder.values().append_null();
-                            };
-                        }
-
-                        // Append to the list
-                        builder.append(true);
-                    }
-                    e => {
-                        return Err(ArrowError::JsonError(format!(
-                            "Nested list data builder type is not supported: {:?}",
-                            e
-                        )))
-                    }
-                }
-            }
-        }
-
-        Ok(builder.finish() as ArrayRef)
-    }
-
-    #[inline(always)]
-    #[allow(clippy::unnecessary_wraps)]
-    fn build_string_dictionary_builder<T>(
-        &self,
-        row_len: usize,
-    ) -> StringDictionaryBuilder<T>
-    where
-        T: ArrowPrimitiveType + ArrowDictionaryKeyType,
-    {
-        let key_builder = PrimitiveBuilder::<T>::new(row_len);
-        let values_builder = StringBuilder::new(row_len * 5);
-        StringDictionaryBuilder::new(key_builder, values_builder)
-    }
-
-    #[inline(always)]
-    fn build_string_dictionary_array(
-        &self,
-        rows: &[Value],
-        col_name: &str,
-        key_type: &DataType,
-        value_type: &DataType,
-    ) -> Result<ArrayRef> {
-        if let DataType::Utf8 = *value_type {
-            match *key_type {
-                DataType::Int8 => self.build_dictionary_array::<Int8Type>(rows, col_name),
-                DataType::Int16 => {
-                    self.build_dictionary_array::<Int16Type>(rows, col_name)
-                }
-                DataType::Int32 => {
-                    self.build_dictionary_array::<Int32Type>(rows, col_name)
-                }
-                DataType::Int64 => {
-                    self.build_dictionary_array::<Int64Type>(rows, col_name)
-                }
-                DataType::UInt8 => {
-                    self.build_dictionary_array::<UInt8Type>(rows, col_name)
-                }
-                DataType::UInt16 => {
-                    self.build_dictionary_array::<UInt16Type>(rows, col_name)
-                }
-                DataType::UInt32 => {
-                    self.build_dictionary_array::<UInt32Type>(rows, col_name)
-                }
-                DataType::UInt64 => {
-                    self.build_dictionary_array::<UInt64Type>(rows, col_name)
-                }
-                _ => Err(ArrowError::JsonError(
-                    "unsupported dictionary key type".to_string(),
-                )),
-            }
-        } else {
-            Err(ArrowError::JsonError(
-                "dictionary types other than UTF-8 not yet supported".to_string(),
-            ))
-        }
-    }
-
-    fn build_boolean_array(&self, rows: &[Value], col_name: &str) -> Result<ArrayRef> {
-        let mut builder = BooleanBuilder::new(rows.len());
-        for row in rows {
-            if let Some(value) = row.get(&col_name) {
-                if let Some(boolean) = value.as_bool() {
-                    builder.append_value(boolean);
-                } else {
-                    builder.append_null();
-                }
-            } else {
-                builder.append_null();
-            }
-        }
-        Ok(Arc::new(builder.finish()))
-    }
-
-    #[allow(clippy::unnecessary_wraps)]
-    fn build_primitive_array<T: ArrowPrimitiveType + Parser>(
-        &self,
-        rows: &[Value],
-        col_name: &str,
-    ) -> Result<ArrayRef>
-    where
-        T: ArrowNumericType,
-        T::Native: num::NumCast,
-    {
-        let format_string = self
-            .options
-            .format_strings
-            .as_ref()
-            .and_then(|fmts| fmts.get(col_name));
-        Ok(Arc::new(
-            rows.iter()
-                .map(|row| {
-                    row.get(&col_name).and_then(|value| {
-                        if value.is_i64() {
-                            value.as_i64().and_then(num::cast::cast)
-                        } else if value.is_u64() {
-                            value.as_u64().and_then(num::cast::cast)
-                        } else if value.is_string() {
-                            match format_string {
-                                Some(fmt) => {
-                                    T::parse_formatted(value.as_str().unwrap(), fmt)
-                                }
-                                None => T::parse(value.as_str().unwrap()),
-                            }
-                        } else {
-                            value.as_f64().and_then(num::cast::cast)
-                        }
-                    })
-                })
-                .collect::<PrimitiveArray<T>>(),
-        ))
-    }
-
-    /// Build a nested GenericListArray from a list of unnested `Value`s
-    fn build_nested_list_array<OffsetSize: OffsetSizeTrait>(
-        &self,
-        rows: &[Value],
-        list_field: &Field,
-    ) -> Result<ArrayRef> {
-        // build list offsets
-        let mut cur_offset = OffsetSize::zero();
-        let list_len = rows.len();
-        let num_list_bytes = bit_util::ceil(list_len, 8);
-        let mut offsets = Vec::with_capacity(list_len + 1);
-        let mut list_nulls = MutableBuffer::from_len_zeroed(num_list_bytes);
-        let list_nulls = list_nulls.as_slice_mut();
-        offsets.push(cur_offset);
-        rows.iter().enumerate().for_each(|(i, v)| {
-            if let Value::Array(a) = v {
-                cur_offset += OffsetSize::from_usize(a.len()).unwrap();
-                bit_util::set_bit(list_nulls, i);
-            } else if let Value::Null = v {
-                // value is null, not incremented
-            } else {
-                cur_offset += OffsetSize::one();
-            }
-            offsets.push(cur_offset);
-        });
-        let valid_len = cur_offset.to_usize().unwrap();
-        let array_data = match list_field.data_type() {
-            DataType::Null => NullArray::new(valid_len).into_data(),
-            DataType::Boolean => {
-                let num_bytes = bit_util::ceil(valid_len, 8);
-                let mut bool_values = MutableBuffer::from_len_zeroed(num_bytes);
-                let mut bool_nulls =
-                    MutableBuffer::new(num_bytes).with_bitset(num_bytes, true);
-                let mut curr_index = 0;
-                rows.iter().for_each(|v| {
-                    if let Value::Array(vs) = v {
-                        vs.iter().for_each(|value| {
-                            if let Value::Bool(child) = value {
-                                // if valid boolean, append value
-                                if *child {
-                                    bit_util::set_bit(
-                                        bool_values.as_slice_mut(),
-                                        curr_index,
-                                    );
-                                }
-                            } else {
-                                // null slot
-                                bit_util::unset_bit(
-                                    bool_nulls.as_slice_mut(),
-                                    curr_index,
-                                );
-                            }
-                            curr_index += 1;
-                        });
-                    }
-                });
-                unsafe {
-                    ArrayData::builder(list_field.data_type().clone())
-                        .len(valid_len)
-                        .add_buffer(bool_values.into())
-                        .null_bit_buffer(Some(bool_nulls.into()))
-                        .build_unchecked()
-                }
-            }
-            DataType::Int8 => self.read_primitive_list_values::<Int8Type>(rows),
-            DataType::Int16 => self.read_primitive_list_values::<Int16Type>(rows),
-            DataType::Int32 => self.read_primitive_list_values::<Int32Type>(rows),
-            DataType::Int64 => self.read_primitive_list_values::<Int64Type>(rows),
-            DataType::UInt8 => self.read_primitive_list_values::<UInt8Type>(rows),
-            DataType::UInt16 => self.read_primitive_list_values::<UInt16Type>(rows),
-            DataType::UInt32 => self.read_primitive_list_values::<UInt32Type>(rows),
-            DataType::UInt64 => self.read_primitive_list_values::<UInt64Type>(rows),
-            DataType::Float16 => {
-                return Err(ArrowError::JsonError("Float16 not supported".to_string()))
-            }
-            DataType::Float32 => self.read_primitive_list_values::<Float32Type>(rows),
-            DataType::Float64 => self.read_primitive_list_values::<Float64Type>(rows),
-            DataType::Timestamp(_, _)
-            | DataType::Date32
-            | DataType::Date64
-            | DataType::Time32(_)
-            | DataType::Time64(_) => {
-                return Err(ArrowError::JsonError(
-                    "Temporal types are not yet supported, see ARROW-4803".to_string(),
-                ))
-            }
-            DataType::Utf8 => flatten_json_string_values(rows)
-                .into_iter()
-                .collect::<StringArray>()
-                .data()
-                .clone(),
-            DataType::LargeUtf8 => flatten_json_string_values(rows)
-                .into_iter()
-                .collect::<LargeStringArray>()
-                .data()
-                .clone(),
-            DataType::List(field) => {
-                let child = self
-                    .build_nested_list_array::<i32>(&flatten_json_values(rows), field)?;
-                child.into_data()
-            }
-            DataType::LargeList(field) => {
-                let child = self
-                    .build_nested_list_array::<i64>(&flatten_json_values(rows), field)?;
-                child.into_data()
-            }
-            DataType::Struct(fields) => {
-                // extract list values, with non-lists converted to Value::Null
-                let array_item_count = cur_offset.to_usize().unwrap();
-                let num_bytes = bit_util::ceil(array_item_count, 8);
-                let mut null_buffer = MutableBuffer::from_len_zeroed(num_bytes);
-                let mut struct_index = 0;
-                let rows: Vec<Value> = rows
-                    .iter()
-                    .flat_map(|row| match row {
-                        Value::Array(values) if !values.is_empty() => {
-                            values.iter().for_each(|value| {
-                                if !value.is_null() {
-                                    bit_util::set_bit(
-                                        null_buffer.as_slice_mut(),
-                                        struct_index,
-                                    );
-                                }
-                                struct_index += 1;
-                            });
-                            values.clone()
-                        }
-                        _ => {
-                            vec![]
-                        }
-                    })
-                    .collect();
-                let arrays =
-                    self.build_struct_array(rows.as_slice(), fields.as_slice(), &[])?;
-                let data_type = DataType::Struct(fields.clone());
-                let buf = null_buffer.into();
-                unsafe {
-                    ArrayDataBuilder::new(data_type)
-                        .len(rows.len())
-                        .null_bit_buffer(Some(buf))
-                        .child_data(arrays.into_iter().map(|a| a.into_data()).collect())
-                        .build_unchecked()
-                }
-            }
-            datatype => {
-                return Err(ArrowError::JsonError(format!(
-                    "Nested list of {:?} not supported",
-                    datatype
-                )));
-            }
-        };
-        // build list
-        let list_data = ArrayData::builder(DataType::List(Box::new(list_field.clone())))
-            .len(list_len)
-            .add_buffer(Buffer::from_slice_ref(&offsets))
-            .add_child_data(array_data)
-            .null_bit_buffer(Some(list_nulls.into()));
-        let list_data = unsafe { list_data.build_unchecked() };
-        Ok(Arc::new(GenericListArray::<OffsetSize>::from(list_data)))
-    }
-
-    /// Builds the child values of a `StructArray`, falling short of constructing the StructArray.
-    /// The function does not construct the StructArray as some callers would want the child arrays.
-    ///
-    /// *Note*: The function is recursive, and will read nested structs.
-    ///
-    /// If `projection` is not empty, then all values are returned. The first level of projection
-    /// occurs at the `RecordBatch` level. No further projection currently occurs, but would be
-    /// useful if plucking values from a struct, e.g. getting `a.b.c.e` from `a.b.c.{d, e}`.
-    fn build_struct_array(
-        &self,
-        rows: &[Value],
-        struct_fields: &[Field],
-        projection: &[String],
-    ) -> Result<Vec<ArrayRef>> {
-        let arrays: Result<Vec<ArrayRef>> = struct_fields
-            .iter()
-            .filter(|field| projection.is_empty() || projection.contains(field.name()))
-            .map(|field| {
-                match field.data_type() {
-                    DataType::Null => {
-                        Ok(Arc::new(NullArray::new(rows.len())) as ArrayRef)
-                    }
-                    DataType::Boolean => self.build_boolean_array(rows, field.name()),
-                    DataType::Float64 => {
-                        self.build_primitive_array::<Float64Type>(rows, field.name())
-                    }
-                    DataType::Float32 => {
-                        self.build_primitive_array::<Float32Type>(rows, field.name())
-                    }
-                    DataType::Int64 => {
-                        self.build_primitive_array::<Int64Type>(rows, field.name())
-                    }
-                    DataType::Int32 => {
-                        self.build_primitive_array::<Int32Type>(rows, field.name())
-                    }
-                    DataType::Int16 => {
-                        self.build_primitive_array::<Int16Type>(rows, field.name())
-                    }
-                    DataType::Int8 => {
-                        self.build_primitive_array::<Int8Type>(rows, field.name())
-                    }
-                    DataType::UInt64 => {
-                        self.build_primitive_array::<UInt64Type>(rows, field.name())
-                    }
-                    DataType::UInt32 => {
-                        self.build_primitive_array::<UInt32Type>(rows, field.name())
-                    }
-                    DataType::UInt16 => {
-                        self.build_primitive_array::<UInt16Type>(rows, field.name())
-                    }
-                    DataType::UInt8 => {
-                        self.build_primitive_array::<UInt8Type>(rows, field.name())
-                    }
-                    // TODO: this is incomplete
-                    DataType::Timestamp(unit, _) => match unit {
-                        TimeUnit::Second => self
-                            .build_primitive_array::<TimestampSecondType>(
-                                rows,
-                                field.name(),
-                            ),
-                        TimeUnit::Microsecond => self
-                            .build_primitive_array::<TimestampMicrosecondType>(
-                                rows,
-                                field.name(),
-                            ),
-                        TimeUnit::Millisecond => self
-                            .build_primitive_array::<TimestampMillisecondType>(
-                                rows,
-                                field.name(),
-                            ),
-                        TimeUnit::Nanosecond => self
-                            .build_primitive_array::<TimestampNanosecondType>(
-                                rows,
-                                field.name(),
-                            ),
-                    },
-                    DataType::Date64 => {
-                        self.build_primitive_array::<Date64Type>(rows, field.name())
-                    }
-                    DataType::Date32 => {
-                        self.build_primitive_array::<Date32Type>(rows, field.name())
-                    }
-                    DataType::Time64(unit) => match unit {
-                        TimeUnit::Microsecond => self
-                            .build_primitive_array::<Time64MicrosecondType>(
-                                rows,
-                                field.name(),
-                            ),
-                        TimeUnit::Nanosecond => self
-                            .build_primitive_array::<Time64NanosecondType>(
-                                rows,
-                                field.name(),
-                            ),
-                        t => Err(ArrowError::JsonError(format!(
-                            "TimeUnit {:?} not supported with Time64",
-                            t
-                        ))),
-                    },
-                    DataType::Time32(unit) => match unit {
-                        TimeUnit::Second => self
-                            .build_primitive_array::<Time32SecondType>(
-                                rows,
-                                field.name(),
-                            ),
-                        TimeUnit::Millisecond => self
-                            .build_primitive_array::<Time32MillisecondType>(
-                                rows,
-                                field.name(),
-                            ),
-                        t => Err(ArrowError::JsonError(format!(
-                            "TimeUnit {:?} not supported with Time32",
-                            t
-                        ))),
-                    },
-                    DataType::Utf8 => Ok(Arc::new(
-                        rows.iter()
-                            .map(|row| {
-                                let maybe_value = row.get(field.name());
-                                maybe_value.and_then(|value| value.as_str())
-                            })
-                            .collect::<StringArray>(),
-                    ) as ArrayRef),
-                    DataType::Binary => Ok(Arc::new(
-                        rows.iter()
-                            .map(|row| {
-                                let maybe_value = row.get(field.name());
-                                maybe_value.and_then(|value| value.as_str())
-                            })
-                            .collect::<BinaryArray>(),
-                    ) as ArrayRef),
-                    DataType::List(ref list_field) => {
-                        match list_field.data_type() {
-                            DataType::Dictionary(ref key_ty, _) => {
-                                self.build_wrapped_list_array(rows, field.name(), key_ty)
-                            }
-                            _ => {
-                                // extract rows by name
-                                let extracted_rows = rows
-                                    .iter()
-                                    .map(|row| {
-                                        row.get(field.name())
-                                            .cloned()
-                                            .unwrap_or(Value::Null)
-                                    })
-                                    .collect::<Vec<Value>>();
-                                self.build_nested_list_array::<i32>(
-                                    extracted_rows.as_slice(),
-                                    list_field,
-                                )
-                            }
-                        }
-                    }
-                    DataType::Dictionary(ref key_ty, ref val_ty) => self
-                        .build_string_dictionary_array(
-                            rows,
-                            field.name(),
-                            key_ty,
-                            val_ty,
-                        ),
-                    DataType::Struct(fields) => {
-                        let len = rows.len();
-                        let num_bytes = bit_util::ceil(len, 8);
-                        let mut null_buffer = MutableBuffer::from_len_zeroed(num_bytes);
-                        let struct_rows = rows
-                            .iter()
-                            .enumerate()
-                            .map(|(i, row)| {
-                                (i, row.as_object().and_then(|v| v.get(field.name())))
-                            })
-                            .map(|(i, v)| match v {
-                                // we want the field as an object, if it's not, we treat as null
-                                Some(Value::Object(value)) => {
-                                    bit_util::set_bit(null_buffer.as_slice_mut(), i);
-                                    Value::Object(value.clone())
-                                }
-                                _ => Value::Object(Default::default()),
-                            })
-                            .collect::<Vec<Value>>();
-                        let arrays =
-                            self.build_struct_array(&struct_rows, fields, &[])?;
-                        // construct a struct array's data in order to set null buffer
-                        let data_type = DataType::Struct(fields.clone());
-                        let data = ArrayDataBuilder::new(data_type)
-                            .len(len)
-                            .null_bit_buffer(Some(null_buffer.into()))
-                            .child_data(
-                                arrays.into_iter().map(|a| a.into_data()).collect(),
-                            );
-                        let data = unsafe { data.build_unchecked() };
-                        Ok(make_array(data))
-                    }
-                    DataType::Map(map_field, _) => self.build_map_array(
-                        rows,
-                        field.name(),
-                        field.data_type(),
-                        map_field,
-                    ),
-                    _ => Err(ArrowError::JsonError(format!(
-                        "{:?} type is not supported",
-                        field.data_type()
-                    ))),
-                }
-            })
-            .collect();
-        arrays
-    }
-
-    fn build_map_array(
-        &self,
-        rows: &[Value],
-        field_name: &str,
-        map_type: &DataType,
-        struct_field: &Field,
-    ) -> Result<ArrayRef> {
-        // A map has the format {"key": "value"} where key is most commonly a string,
-        // but could be a string, number or boolean (🤷🏾‍♂️) (e.g. {1: "value"}).
-        // A map is also represented as a flattened contiguous array, with the number
-        // of key-value pairs being separated by a list offset.
-        // If row 1 has 2 key-value pairs, and row 2 has 3, the offsets would be
-        // [0, 2, 5].
-        //
-        // Thus we try to read a map by iterating through the keys and values
-
-        let (key_field, value_field) =
-            if let DataType::Struct(fields) = struct_field.data_type() {
-                if fields.len() != 2 {
-                    return Err(ArrowError::InvalidArgumentError(format!(
-                        "DataType::Map expects a struct with 2 fields, found {} fields",
-                        fields.len()
-                    )));
-                }
-                (&fields[0], &fields[1])
-            } else {
-                return Err(ArrowError::InvalidArgumentError(format!(
-                    "JSON map array builder expects a DataType::Map, found {:?}",
-                    struct_field.data_type()
-                )));
-            };
-        let value_map_iter = rows.iter().map(|value| {
-            value
-                .get(field_name)
-                .and_then(|v| v.as_object().map(|map| (map, map.len() as i32)))
-        });
-        let rows_len = rows.len();
-        let mut list_offsets = Vec::with_capacity(rows_len + 1);
-        list_offsets.push(0i32);
-        let mut last_offset = 0;
-        let num_bytes = bit_util::ceil(rows_len, 8);
-        let mut list_bitmap = MutableBuffer::from_len_zeroed(num_bytes);
-        let null_data = list_bitmap.as_slice_mut();
-
-        let struct_rows = value_map_iter
-            .enumerate()
-            .filter_map(|(i, v)| match v {
-                Some((map, len)) => {
-                    list_offsets.push(last_offset + len);
-                    last_offset += len;
-                    bit_util::set_bit(null_data, i);
-                    Some(map.iter().map(|(k, v)| {
-                        json!({
-                            key_field.name(): k,
-                            value_field.name(): v
-                        })
-                    }))
-                }
-                None => {
-                    list_offsets.push(last_offset);
-                    None
-                }
-            })
-            .flatten()
-            .collect::<Vec<Value>>();
-
-        let struct_children = self.build_struct_array(
-            struct_rows.as_slice(),
-            &[key_field.clone(), value_field.clone()],
-            &[],
-        )?;
-
-        unsafe {
-            Ok(make_array(ArrayData::new_unchecked(
-                map_type.clone(),
-                rows_len,
-                None,
-                Some(list_bitmap.into()),
-                0,
-                vec![Buffer::from_slice_ref(&list_offsets)],
-                vec![ArrayData::new_unchecked(
-                    struct_field.data_type().clone(),
-                    struct_children[0].len(),
-                    None,
-                    None,
-                    0,
-                    vec![],
-                    struct_children
-                        .into_iter()
-                        .map(|array| array.into_data())
-                        .collect(),
-                )],
-            )))
-        }
-    }
-
-    #[inline(always)]
-    fn build_dictionary_array<T>(
-        &self,
-        rows: &[Value],
-        col_name: &str,
-    ) -> Result<ArrayRef>
-    where
-        T::Native: num::NumCast,
-        T: ArrowPrimitiveType + ArrowDictionaryKeyType,
-    {
-        let mut builder: StringDictionaryBuilder<T> =
-            self.build_string_dictionary_builder(rows.len());
-        for row in rows {
-            if let Some(value) = row.get(&col_name) {
-                if let Some(str_v) = value.as_str() {
-                    builder.append(str_v).map(drop)?
-                } else {
-                    builder.append_null();
-                }
-            } else {
-                builder.append_null();
-            }
-        }
-        Ok(Arc::new(builder.finish()) as ArrayRef)
-    }
-
-    /// Read the primitive list's values into ArrayData
-    fn read_primitive_list_values<T>(&self, rows: &[Value]) -> ArrayData
-    where
-        T: ArrowPrimitiveType + ArrowNumericType,
-        T::Native: num::NumCast,
-    {
-        let values = rows
-            .iter()
-            .flat_map(|row| {
-                // read values from list
-                if let Value::Array(values) = row {
-                    values
-                        .iter()
-                        .map(|value| {
-                            let v: Option<T::Native> =
-                                value.as_f64().and_then(num::cast::cast);
-                            v
-                        })
-                        .collect::<Vec<Option<T::Native>>>()
-                } else if let Value::Number(value) = row {
-                    // handle the scalar number case
-                    let v: Option<T::Native> = value.as_f64().and_then(num::cast::cast);
-                    v.map(|v| vec![Some(v)]).unwrap_or_default()
-                } else {
-                    vec![]
-                }
-            })
-            .collect::<Vec<Option<T::Native>>>();
-        let array = values.iter().collect::<PrimitiveArray<T>>();
-        array.into_data()
-    }
-}
-
-/// Reads a JSON value as a string, regardless of its type.
-/// This is useful if the expected datatype is a string, in which case we preserve
-/// all the values regardless of they type.
-///
-/// Applying `value.to_string()` unfortunately results in an escaped string, which
-/// is not what we want.
-#[inline(always)]
-fn json_value_as_string(value: &Value) -> Option<String> {
-    match value {
-        Value::Null => None,
-        Value::String(string) => Some(string.clone()),
-        _ => Some(value.to_string()),
-    }
-}
-
-/// Flattens a list of JSON values, by flattening lists, and treating all other values as
-/// single-value lists.
-/// This is used to read into nested lists (list of list, list of struct) and non-dictionary lists.
-#[inline]
-fn flatten_json_values(values: &[Value]) -> Vec<Value> {
-    values
-        .iter()
-        .flat_map(|row| {
-            if let Value::Array(values) = row {
-                values.clone()
-            } else if let Value::Null = row {
-                vec![Value::Null]
-            } else {
-                // we interpret a scalar as a single-value list to minimise data loss
-                vec![row.clone()]
-            }
-        })
-        .collect()
-}
-
-/// Flattens a list into string values, dropping Value::Null in the process.
-/// This is useful for interpreting any JSON array as string, dropping nulls.
-/// See `json_value_as_string`.
-#[inline]
-fn flatten_json_string_values(values: &[Value]) -> Vec<Option<String>> {
-    values
-        .iter()
-        .flat_map(|row| {
-            if let Value::Array(values) = row {
-                values
-                    .iter()
-                    .map(json_value_as_string)
-                    .collect::<Vec<Option<_>>>()
-            } else if let Value::Null = row {
-                vec![]
-            } else {
-                vec![json_value_as_string(row)]
-            }
-        })
-        .collect::<Vec<Option<_>>>()
-}
-/// JSON file reader
-#[derive(Debug)]
-pub struct Reader<R: Read> {
-    reader: BufReader<R>,
-    /// JSON value decoder
-    decoder: Decoder,
-}
-
-impl<R: Read> Reader<R> {
-    /// Create a new JSON Reader from any value that implements the `Read` trait.
-    ///
-    /// If reading a `File`, you can customise the Reader, such as to enable schema
-    /// inference, use `ReaderBuilder`.
-    pub fn new(reader: R, schema: SchemaRef, options: DecoderOptions) -> Self {
-        Self::from_buf_reader(BufReader::new(reader), schema, options)
-    }
-
-    /// Create a new JSON Reader from a `BufReader<R: Read>`
-    ///
-    /// To customize the schema, such as to enable schema inference, use `ReaderBuilder`
-    pub fn from_buf_reader(
-        reader: BufReader<R>,
-        schema: SchemaRef,
-        options: DecoderOptions,
-    ) -> Self {
-        Self {
-            reader,
-            decoder: Decoder::new(schema, options),
-        }
-    }
-
-    /// Returns the schema of the reader, useful for getting the schema without reading
-    /// record batches
-    pub fn schema(&self) -> SchemaRef {
-        self.decoder.schema()
-    }
-
-    /// Read the next batch of records
-    #[allow(clippy::should_implement_trait)]
-    pub fn next(&mut self) -> Result<Option<RecordBatch>> {
-        self.decoder
-            .next_batch(&mut ValueIter::new(&mut self.reader, None))
-    }
-}
-
-/// JSON file reader builder
-#[derive(Debug, Default)]
-pub struct ReaderBuilder {
-    /// Optional schema for the JSON file
-    ///
-    /// If the schema is not supplied, the reader will try to infer the schema
-    /// based on the JSON structure.
-    schema: Option<SchemaRef>,
-    /// Optional maximum number of records to read during schema inference
-    ///
-    /// If a number is not provided, all the records are read.
-    max_records: Option<usize>,
-    /// Options for json decoder
-    options: DecoderOptions,
-}
-
-impl ReaderBuilder {
-    /// Create a new builder for configuring JSON parsing options.
-    ///
-    /// To convert a builder into a reader, call `Reader::from_builder`
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// extern crate arrow;
-    ///
-    /// use arrow::json;
-    /// use std::fs::File;
-    ///
-    /// fn example() -> json::Reader<File> {
-    ///     let file = File::open("test/data/basic.json").unwrap();
-    ///
-    ///     // create a builder, inferring the schema with the first 100 records
-    ///     let builder = json::ReaderBuilder::new().infer_schema(Some(100));
-    ///
-    ///     let reader = builder.build::<File>(file).unwrap();
-    ///
-    ///     reader
-    /// }
-    /// ```
-    pub fn new() -> Self {
-        Self::default()
-    }
-
-    /// Set the JSON file's schema
-    pub fn with_schema(mut self, schema: SchemaRef) -> Self {
-        self.schema = Some(schema);
-        self
-    }
-
-    /// Set the JSON reader to infer the schema of the file
-    pub fn infer_schema(mut self, max_records: Option<usize>) -> Self {
-        // remove any schema that is set
-        self.schema = None;
-        self.max_records = max_records;
-        self
-    }
-
-    /// Set the batch size (number of records to load at one time)
-    pub fn with_batch_size(mut self, batch_size: usize) -> Self {
-        self.options = self.options.with_batch_size(batch_size);
-        self
-    }
-
-    /// Set the reader's column projection
-    pub fn with_projection(mut self, projection: Vec<String>) -> Self {
-        self.options = self.options.with_projection(projection);
-        self
-    }
-
-    /// Set the decoder's format Strings param
-    pub fn with_format_strings(
-        mut self,
-        format_strings: HashMap<String, String>,
-    ) -> Self {
-        self.options = self.options.with_format_strings(format_strings);
-        self
-    }
-
-    /// Create a new `Reader` from the `ReaderBuilder`
-    pub fn build<R>(self, source: R) -> Result<Reader<R>>
-    where
-        R: Read + Seek,
-    {
-        let mut buf_reader = BufReader::new(source);
-
-        // check if schema should be inferred
-        let schema = match self.schema {
-            Some(schema) => schema,
-            None => Arc::new(infer_json_schema_from_seekable(
-                &mut buf_reader,
-                self.max_records,
-            )?),
-        };
-
-        Ok(Reader::from_buf_reader(buf_reader, schema, self.options))
-    }
-}
-
-impl<R: Read> Iterator for Reader<R> {
-    type Item = Result<RecordBatch>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.next().transpose()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::{
-        buffer::Buffer,
-        datatypes::DataType::{Dictionary, List},
-    };
-
-    use super::*;
-    use flate2::read::GzDecoder;
-    use std::fs::File;
-    use std::io::Cursor;
-
-    #[test]
-    fn test_json_basic() {
-        let builder = ReaderBuilder::new().infer_schema(None).with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(5, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let a = schema.column_with_name("a").unwrap();
-        assert_eq!(0, a.0);
-        assert_eq!(&DataType::Int64, a.1.data_type());
-        let b = schema.column_with_name("b").unwrap();
-        assert_eq!(1, b.0);
-        assert_eq!(&DataType::Float64, b.1.data_type());
-        let c = schema.column_with_name("c").unwrap();
-        assert_eq!(2, c.0);
-        assert_eq!(&DataType::Boolean, c.1.data_type());
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(3, d.0);
-        assert_eq!(&DataType::Utf8, d.1.data_type());
-
-        let aa = batch
-            .column(a.0)
-            .as_any()
-            .downcast_ref::<Int64Array>()
-            .unwrap();
-        assert_eq!(1, aa.value(0));
-        assert_eq!(-10, aa.value(1));
-        let bb = batch
-            .column(b.0)
-            .as_any()
-            .downcast_ref::<Float64Array>()
-            .unwrap();
-        assert_eq!(2.0, bb.value(0));
-        assert_eq!(-3.5, bb.value(1));
-        let cc = batch
-            .column(c.0)
-            .as_any()
-            .downcast_ref::<BooleanArray>()
-            .unwrap();
-        assert!(!cc.value(0));
-        assert!(cc.value(10));
-        let dd = batch
-            .column(d.0)
-            .as_any()
-            .downcast_ref::<StringArray>()
-            .unwrap();
-        assert_eq!("4", dd.value(0));
-        assert_eq!("text", dd.value(8));
-    }
-
-    #[test]
-    fn test_json_basic_with_nulls() {
-        let builder = ReaderBuilder::new().infer_schema(None).with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(4, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let a = schema.column_with_name("a").unwrap();
-        assert_eq!(&DataType::Int64, a.1.data_type());
-        let b = schema.column_with_name("b").unwrap();
-        assert_eq!(&DataType::Float64, b.1.data_type());
-        let c = schema.column_with_name("c").unwrap();
-        assert_eq!(&DataType::Boolean, c.1.data_type());
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(&DataType::Utf8, d.1.data_type());
-
-        let aa = batch
-            .column(a.0)
-            .as_any()
-            .downcast_ref::<Int64Array>()
-            .unwrap();
-        assert!(aa.is_valid(0));
-        assert!(!aa.is_valid(1));
-        assert!(!aa.is_valid(11));
-        let bb = batch
-            .column(b.0)
-            .as_any()
-            .downcast_ref::<Float64Array>()
-            .unwrap();
-        assert!(bb.is_valid(0));
-        assert!(!bb.is_valid(2));
-        assert!(!bb.is_valid(11));
-        let cc = batch
-            .column(c.0)
-            .as_any()
-            .downcast_ref::<BooleanArray>()
-            .unwrap();
-        assert!(cc.is_valid(0));
-        assert!(!cc.is_valid(4));
-        assert!(!cc.is_valid(11));
-        let dd = batch
-            .column(d.0)
-            .as_any()
-            .downcast_ref::<StringArray>()
-            .unwrap();
-        assert!(!dd.is_valid(0));
-        assert!(dd.is_valid(1));
-        assert!(!dd.is_valid(4));
-        assert!(!dd.is_valid(11));
-    }
-
-    #[test]
-    fn test_json_basic_schema() {
-        let schema = Schema::new(vec![
-            Field::new("a", DataType::Int32, true),
-            Field::new("b", DataType::Float32, false),
-            Field::new("c", DataType::Boolean, false),
-            Field::new("d", DataType::Utf8, false),
-        ]);
-
-        let mut reader: Reader<File> = Reader::new(
-            File::open("test/data/basic.json").unwrap(),
-            Arc::new(schema.clone()),
-            DecoderOptions::new(),
-        );
-        let reader_schema = reader.schema();
-        assert_eq!(reader_schema, Arc::new(schema));
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(4, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = batch.schema();
-
-        let a = schema.column_with_name("a").unwrap();
-        assert_eq!(&DataType::Int32, a.1.data_type());
-        let b = schema.column_with_name("b").unwrap();
-        assert_eq!(&DataType::Float32, b.1.data_type());
-        let c = schema.column_with_name("c").unwrap();
-        assert_eq!(&DataType::Boolean, c.1.data_type());
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(&DataType::Utf8, d.1.data_type());
-
-        let aa = batch
-            .column(a.0)
-            .as_any()
-            .downcast_ref::<Int32Array>()
-            .unwrap();
-        assert_eq!(1, aa.value(0));
-        // test that a 64bit value is returned as null due to overflowing
-        assert!(!aa.is_valid(11));
-        let bb = batch
-            .column(b.0)
-            .as_any()
-            .downcast_ref::<Float32Array>()
-            .unwrap();
-        assert_eq!(2.0, bb.value(0));
-        assert_eq!(-3.5, bb.value(1));
-    }
-
-    #[test]
-    fn test_json_format_strings_for_date() {
-        let schema = Arc::new(Schema::new(vec![Field::new("e", DataType::Date32, true)]));
-        let e = schema.column_with_name("e").unwrap();
-        assert_eq!(&DataType::Date32, e.1.data_type());
-        let mut fmts = HashMap::new();
-        let date_format = "%Y-%m-%d".to_string();
-        fmts.insert("e".to_string(), date_format.clone());
-
-        let mut reader: Reader<File> = Reader::new(
-            File::open("test/data/basic.json").unwrap(),
-            schema.clone(),
-            DecoderOptions::new().with_format_strings(fmts),
-        );
-        let reader_schema = reader.schema();
-        assert_eq!(reader_schema, schema);
-        let batch = reader.next().unwrap().unwrap();
-
-        let ee = batch
-            .column(e.0)
-            .as_any()
-            .downcast_ref::<Date32Array>()
-            .unwrap();
-        let dt = Date32Type::parse_formatted("1970-1-2", &date_format).unwrap();
-        assert_eq!(dt, ee.value(0));
-        let dt = Date32Type::parse_formatted("1969-12-31", &date_format).unwrap();
-        assert_eq!(dt, ee.value(1));
-        assert!(!ee.is_valid(2));
-    }
-
-    #[test]
-    fn test_json_basic_schema_projection() {
-        // We test implicit and explicit projection:
-        // Implicit: omitting fields from a schema
-        // Explicit: supplying a vec of fields to take
-        let schema = Schema::new(vec![
-            Field::new("a", DataType::Int32, true),
-            Field::new("b", DataType::Float32, false),
-            Field::new("c", DataType::Boolean, false),
-        ]);
-
-        let mut reader: Reader<File> = Reader::new(
-            File::open("test/data/basic.json").unwrap(),
-            Arc::new(schema),
-            DecoderOptions::new().with_projection(vec!["a".to_string(), "c".to_string()]),
-        );
-        let reader_schema = reader.schema();
-        let expected_schema = Arc::new(Schema::new(vec![
-            Field::new("a", DataType::Int32, true),
-            Field::new("c", DataType::Boolean, false),
-        ]));
-        assert_eq!(reader_schema, expected_schema);
-
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(2, batch.num_columns());
-        assert_eq!(2, batch.schema().fields().len());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = batch.schema();
-        assert_eq!(reader_schema, schema);
-
-        let a = schema.column_with_name("a").unwrap();
-        assert_eq!(0, a.0);
-        assert_eq!(&DataType::Int32, a.1.data_type());
-        let c = schema.column_with_name("c").unwrap();
-        assert_eq!(1, c.0);
-        assert_eq!(&DataType::Boolean, c.1.data_type());
-    }
-
-    #[test]
-    fn test_json_arrays() {
-        let builder = ReaderBuilder::new().infer_schema(None).with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/arrays.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(4, batch.num_columns());
-        assert_eq!(3, batch.num_rows());
-
-        let schema = batch.schema();
-
-        let a = schema.column_with_name("a").unwrap();
-        assert_eq!(&DataType::Int64, a.1.data_type());
-        let b = schema.column_with_name("b").unwrap();
-        assert_eq!(
-            &DataType::List(Box::new(Field::new("item", DataType::Float64, true))),
-            b.1.data_type()
-        );
-        let c = schema.column_with_name("c").unwrap();
-        assert_eq!(
-            &DataType::List(Box::new(Field::new("item", DataType::Boolean, true))),
-            c.1.data_type()
-        );
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(&DataType::Utf8, d.1.data_type());
-
-        let aa = batch
-            .column(a.0)
-            .as_any()
-            .downcast_ref::<Int64Array>()
-            .unwrap();
-        assert_eq!(1, aa.value(0));
-        assert_eq!(-10, aa.value(1));
-        assert_eq!(1627668684594000000, aa.value(2));
-        let bb = batch
-            .column(b.0)
-            .as_any()
-            .downcast_ref::<ListArray>()
-            .unwrap();
-        let bb = bb.values();
-        let bb = bb.as_any().downcast_ref::<Float64Array>().unwrap();
-        assert_eq!(9, bb.len());
-        assert_eq!(2.0, bb.value(0));
-        assert_eq!(-6.1, bb.value(5));
-        assert!(!bb.is_valid(7));
-
-        let cc = batch
-            .column(c.0)
-            .as_any()
-            .downcast_ref::<ListArray>()
-            .unwrap();
-        let cc = cc.values();
-        let cc = cc.as_any().downcast_ref::<BooleanArray>().unwrap();
-        assert_eq!(6, cc.len());
-        assert!(!cc.value(0));
-        assert!(!cc.value(4));
-        assert!(!cc.is_valid(5));
-    }
-
-    #[test]
-    fn test_invalid_json_infer_schema() {
-        let re = infer_json_schema_from_seekable(
-            &mut BufReader::new(
-                File::open("test/data/uk_cities_with_headers.csv").unwrap(),
-            ),
-            None,
-        );
-        assert_eq!(
-            re.err().unwrap().to_string(),
-            "Json error: Not valid JSON: expected value at line 1 column 1",
-        );
-    }
-
-    #[test]
-    fn test_invalid_json_read_record() {
-        let schema = Arc::new(Schema::new(vec![Field::new(
-            "a",
-            DataType::Struct(vec![Field::new("a", DataType::Utf8, true)]),
-            true,
-        )]));
-        let builder = ReaderBuilder::new().with_schema(schema).with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/uk_cities_with_headers.csv").unwrap())
-            .unwrap();
-        assert_eq!(
-            reader.next().err().unwrap().to_string(),
-            "Json error: Not valid JSON: expected value at line 1 column 1",
-        );
-    }
-
-    #[test]
-    fn test_coersion_scalar_and_list() {
-        use crate::datatypes::DataType::*;
-
-        assert_eq!(
-            List(Box::new(Field::new("item", Float64, true))),
-            coerce_data_type(vec![
-                &Float64,
-                &List(Box::new(Field::new("item", Float64, true)))
-            ])
-        );
-        assert_eq!(
-            List(Box::new(Field::new("item", Float64, true))),
-            coerce_data_type(vec![
-                &Float64,
-                &List(Box::new(Field::new("item", Int64, true)))
-            ])
-        );
-        assert_eq!(
-            List(Box::new(Field::new("item", Int64, true))),
-            coerce_data_type(vec![
-                &Int64,
-                &List(Box::new(Field::new("item", Int64, true)))
-            ])
-        );
-        // boolean and number are incompatible, return utf8
-        assert_eq!(
-            List(Box::new(Field::new("item", Utf8, true))),
-            coerce_data_type(vec![
-                &Boolean,
-                &List(Box::new(Field::new("item", Float64, true)))
-            ])
-        );
-    }
-
-    #[test]
-    fn test_mixed_json_arrays() {
-        let builder = ReaderBuilder::new().infer_schema(None).with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/mixed_arrays.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        let mut file = File::open("test/data/mixed_arrays.json.gz").unwrap();
-        let mut reader = BufReader::new(GzDecoder::new(&file));
-        let schema = infer_json_schema(&mut reader, None).unwrap();
-        file.seek(SeekFrom::Start(0)).unwrap();
-
-        let reader = BufReader::new(GzDecoder::new(&file));
-        let options = DecoderOptions::new().with_batch_size(64);
-        let mut reader = Reader::from_buf_reader(reader, Arc::new(schema), options);
-        let batch_gz = reader.next().unwrap().unwrap();
-
-        for batch in vec![batch, batch_gz] {
-            assert_eq!(4, batch.num_columns());
-            assert_eq!(4, batch.num_rows());
-
-            let schema = batch.schema();
-
-            let a = schema.column_with_name("a").unwrap();
-            assert_eq!(&DataType::Int64, a.1.data_type());
-            let b = schema.column_with_name("b").unwrap();
-            assert_eq!(
-                &DataType::List(Box::new(Field::new("item", DataType::Float64, true))),
-                b.1.data_type()
-            );
-            let c = schema.column_with_name("c").unwrap();
-            assert_eq!(
-                &DataType::List(Box::new(Field::new("item", DataType::Boolean, true))),
-                c.1.data_type()
-            );
-            let d = schema.column_with_name("d").unwrap();
-            assert_eq!(
-                &DataType::List(Box::new(Field::new("item", DataType::Utf8, true))),
-                d.1.data_type()
-            );
-
-            let bb = batch
-                .column(b.0)
-                .as_any()
-                .downcast_ref::<ListArray>()
-                .unwrap();
-            let bb = bb.values();
-            let bb = bb.as_any().downcast_ref::<Float64Array>().unwrap();
-            assert_eq!(10, bb.len());
-            assert_eq!(4.0, bb.value(9));
-
-            let cc = batch
-                .column(c.0)
-                .as_any()
-                .downcast_ref::<ListArray>()
-                .unwrap();
-            // test that the list offsets are correct
-            assert_eq!(
-                cc.data().buffers()[0],
-                Buffer::from_slice_ref(&[0i32, 2, 2, 4, 5])
-            );
-            let cc = cc.values();
-            let cc = cc.as_any().downcast_ref::<BooleanArray>().unwrap();
-            let cc_expected = BooleanArray::from(vec![
-                Some(false),
-                Some(true),
-                Some(false),
-                None,
-                Some(false),
-            ]);
-            assert_eq!(cc.data_ref(), cc_expected.data_ref());
-
-            let dd: &ListArray = batch
-                .column(d.0)
-                .as_any()
-                .downcast_ref::<ListArray>()
-                .unwrap();
-            // test that the list offsets are correct
-            assert_eq!(
-                dd.data().buffers()[0],
-                Buffer::from_slice_ref(&[0i32, 1, 1, 2, 6])
-            );
-            let dd = dd.values();
-            let dd = dd.as_any().downcast_ref::<StringArray>().unwrap();
-            // values are 6 because a `d: null` is treated as a null slot
-            // and a list's null slot can be omitted from the child (i.e. same offset)
-            assert_eq!(6, dd.len());
-            assert_eq!("text", dd.value(1));
-            assert_eq!("1", dd.value(2));
-            assert_eq!("false", dd.value(3));
-            assert_eq!("array", dd.value(4));
-            assert_eq!("2.4", dd.value(5));
-        }
-    }
-
-    #[test]
-    fn test_nested_struct_json_arrays() {
-        let c_field = Field::new(
-            "c",
-            DataType::Struct(vec![Field::new("d", DataType::Utf8, true)]),
-            true,
-        );
-        let a_field = Field::new(
-            "a",
-            DataType::Struct(vec![
-                Field::new("b", DataType::Boolean, true),
-                c_field.clone(),
-            ]),
-            true,
-        );
-        let schema = Arc::new(Schema::new(vec![a_field.clone()]));
-        let builder = ReaderBuilder::new().with_schema(schema).with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/nested_structs.json").unwrap())
-            .unwrap();
-
-        // build expected output
-        let d = StringArray::from(vec![Some("text"), None, Some("text"), None]);
-        let c = ArrayDataBuilder::new(c_field.data_type().clone())
-            .len(4)
-            .add_child_data(d.into_data())
-            .null_bit_buffer(Some(Buffer::from(vec![0b00000101])))
-            .build()
-            .unwrap();
-        let b = BooleanArray::from(vec![Some(true), Some(false), Some(true), None]);
-        let a = ArrayDataBuilder::new(a_field.data_type().clone())
-            .len(4)
-            .add_child_data(b.into_data())
-            .add_child_data(c)
-            .null_bit_buffer(Some(Buffer::from(vec![0b00000111])))
-            .build()
-            .unwrap();
-        let expected = make_array(a);
-
-        // compare `a` with result from json reader
-        let batch = reader.next().unwrap().unwrap();
-        let read = batch.column(0);
-        assert!(
-            expected.data_ref() == read.data_ref(),
-            "{:?} != {:?}",
-            expected.data(),
-            read.data(),
-        );
-    }
-
-    #[test]
-    fn test_nested_list_json_arrays() {
-        let c_field = Field::new(
-            "c",
-            DataType::Struct(vec![Field::new("d", DataType::Utf8, true)]),
-            true,
-        );
-        let a_struct_field = Field::new(
-            "a",
-            DataType::Struct(vec![
-                Field::new("b", DataType::Boolean, true),
-                c_field.clone(),
-            ]),
-            true,
-        );
-        let a_field =
-            Field::new("a", DataType::List(Box::new(a_struct_field.clone())), true);
-        let schema = Arc::new(Schema::new(vec![a_field.clone()]));
-        let builder = ReaderBuilder::new().with_schema(schema).with_batch_size(64);
-        let json_content = r#"
-        {"a": [{"b": true, "c": {"d": "a_text"}}, {"b": false, "c": {"d": "b_text"}}]}
-        {"a": [{"b": false, "c": null}]}
-        {"a": [{"b": true, "c": {"d": "c_text"}}, {"b": null, "c": {"d": "d_text"}}, {"b": true, "c": {"d": null}}]}
-        {"a": null}
-        {"a": []}
-        {"a": [null]}
-        "#;
-        let mut reader = builder.build(Cursor::new(json_content)).unwrap();
-
-        // build expected output
-        let d = StringArray::from(vec![
-            Some("a_text"),
-            Some("b_text"),
-            None,
-            Some("c_text"),
-            Some("d_text"),
-            None,
-            None,
-        ]);
-        let c = ArrayDataBuilder::new(c_field.data_type().clone())
-            .len(7)
-            .add_child_data(d.data().clone())
-            .null_bit_buffer(Some(Buffer::from(vec![0b00111011])))
-            .build()
-            .unwrap();
-        let b = BooleanArray::from(vec![
-            Some(true),
-            Some(false),
-            Some(false),
-            Some(true),
-            None,
-            Some(true),
-            None,
-        ]);
-        let a = ArrayDataBuilder::new(a_struct_field.data_type().clone())
-            .len(7)
-            .add_child_data(b.data().clone())
-            .add_child_data(c.clone())
-            .null_bit_buffer(Some(Buffer::from(vec![0b00111111])))
-            .build()
-            .unwrap();
-        let a_list = ArrayDataBuilder::new(a_field.data_type().clone())
-            .len(6)
-            .add_buffer(Buffer::from_slice_ref(&[0i32, 2, 3, 6, 6, 6, 7]))
-            .add_child_data(a)
-            .null_bit_buffer(Some(Buffer::from(vec![0b00110111])))
-            .build()
-            .unwrap();
-        let expected = make_array(a_list);
-
-        // compare `a` with result from json reader
-        let batch = reader.next().unwrap().unwrap();
-        let read = batch.column(0);
-        assert_eq!(read.len(), 6);
-        // compare the arrays the long way around, to better detect differences
-        let read: &ListArray = read.as_any().downcast_ref::<ListArray>().unwrap();
-        let expected = expected.as_any().downcast_ref::<ListArray>().unwrap();
-        assert_eq!(
-            read.data().buffers()[0],
-            Buffer::from_slice_ref(&[0i32, 2, 3, 6, 6, 6, 7])
-        );
-        // compare list null buffers
-        assert_eq!(read.data().null_buffer(), expected.data().null_buffer());
-        // build struct from list
-        let struct_values = read.values();
-        let struct_array: &StructArray = struct_values
-            .as_any()
-            .downcast_ref::<StructArray>()
-            .unwrap();
-        let expected_struct_values = expected.values();
-        let expected_struct_array = expected_struct_values
-            .as_any()
-            .downcast_ref::<StructArray>()
-            .unwrap();
-
-        assert_eq!(7, struct_array.len());
-        assert_eq!(1, struct_array.null_count());
-        assert_eq!(7, expected_struct_array.len());
-        assert_eq!(1, expected_struct_array.null_count());
-        // test struct's nulls
-        assert_eq!(
-            struct_array.data().null_buffer(),
-            expected_struct_array.data().null_buffer()
-        );
-        // test struct's fields
-        let read_b = struct_array.column(0);
-        assert_eq!(b.data_ref(), read_b.data_ref());
-        let read_c = struct_array.column(1);
-        assert_eq!(&c, read_c.data_ref());
-        let read_c: &StructArray = read_c.as_any().downcast_ref::<StructArray>().unwrap();
-        let read_d = read_c.column(0);
-        assert_eq!(d.data_ref(), read_d.data_ref());
-
-        assert_eq!(read.data_ref(), expected.data_ref());
-    }
-
-    #[test]
-    fn test_map_json_arrays() {
-        let account_field = Field::new("account", DataType::UInt16, false);
-        let value_list_type =
-            DataType::List(Box::new(Field::new("item", DataType::Utf8, false)));
-        let entries_struct_type = DataType::Struct(vec![
-            Field::new("key", DataType::Utf8, false),
-            Field::new("value", value_list_type.clone(), true),
-        ]);
-        let stocks_field = Field::new(
-            "stocks",
-            DataType::Map(
-                Box::new(Field::new("entries", entries_struct_type.clone(), false)),
-                false,
-            ),
-            true,
-        );
-        let schema = Arc::new(Schema::new(vec![account_field, stocks_field.clone()]));
-        let builder = ReaderBuilder::new().with_schema(schema).with_batch_size(64);
-        // Note: account 456 has 'long' twice, to show that the JSON reader will overwrite
-        // existing keys. This thus guarantees unique keys for the map
-        let json_content = r#"
-        {"account": 123, "stocks":{"long": ["$AAA", "$BBB"], "short": ["$CCC", "$D"]}}
-        {"account": 456, "stocks":{"long": null, "long": ["$AAA", "$CCC", "$D"], "short": null}}
-        {"account": 789, "stocks":{"hedged": ["$YYY"], "long": null, "short": ["$D"]}}
-        "#;
-        let mut reader = builder.build(Cursor::new(json_content)).unwrap();
-
-        // build expected output
-        let expected_accounts = UInt16Array::from(vec![123, 456, 789]);
-
-        let expected_keys = StringArray::from(vec![
-            "long", "short", "long", "short", "hedged", "long", "short",
-        ])
-        .data()
-        .clone();
-        let expected_value_array_data = StringArray::from(vec![
-            "$AAA", "$BBB", "$CCC", "$D", "$AAA", "$CCC", "$D", "$YYY", "$D",
-        ])
-        .data()
-        .clone();
-        // Create the list that holds ["$_", "$_"]
-        let expected_values = ArrayDataBuilder::new(value_list_type)
-            .len(7)
-            .add_buffer(Buffer::from(
-                vec![0i32, 2, 4, 7, 7, 8, 8, 9].to_byte_slice(),
-            ))
-            .add_child_data(expected_value_array_data)
-            .null_bit_buffer(Some(Buffer::from(vec![0b01010111])))
-            .build()
-            .unwrap();
-        let expected_stocks_entries_data = ArrayDataBuilder::new(entries_struct_type)
-            .len(7)
-            .add_child_data(expected_keys)
-            .add_child_data(expected_values)
-            .build()
-            .unwrap();
-        let expected_stocks_data =
-            ArrayDataBuilder::new(stocks_field.data_type().clone())
-                .len(3)
-                .add_buffer(Buffer::from(vec![0i32, 2, 4, 7].to_byte_slice()))
-                .add_child_data(expected_stocks_entries_data)
-                .build()
-                .unwrap();
-
-        let expected_stocks = make_array(expected_stocks_data);
-
-        // compare with result from json reader
-        let batch = reader.next().unwrap().unwrap();
-        assert_eq!(batch.num_rows(), 3);
-        assert_eq!(batch.num_columns(), 2);
-        let col1 = batch.column(0);
-        assert_eq!(col1.data(), expected_accounts.data());
-        // Compare the map
-        let col2 = batch.column(1);
-        assert_eq!(col2.data(), expected_stocks.data());
-    }
-
-    #[test]
-    fn test_dictionary_from_json_basic_with_nulls() {
-        let schema = Schema::new(vec![Field::new(
-            "d",
-            Dictionary(Box::new(DataType::Int16), Box::new(DataType::Utf8)),
-            true,
-        )]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(
-            &Dictionary(Box::new(DataType::Int16), Box::new(DataType::Utf8)),
-            d.1.data_type()
-        );
-
-        let dd = batch
-            .column(d.0)
-            .as_any()
-            .downcast_ref::<DictionaryArray<Int16Type>>()
-            .unwrap();
-        assert!(!dd.is_valid(0));
-        assert!(dd.is_valid(1));
-        assert!(dd.is_valid(2));
-        assert!(!dd.is_valid(11));
-
-        assert_eq!(
-            dd.keys(),
-            &Int16Array::from(vec![
-                None,
-                Some(0),
-                Some(1),
-                Some(0),
-                None,
-                None,
-                Some(0),
-                None,
-                Some(1),
-                Some(0),
-                Some(0),
-                None
-            ])
-        );
-    }
-
-    #[test]
-    fn test_dictionary_from_json_int8() {
-        let schema = Schema::new(vec![Field::new(
-            "d",
-            Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
-            true,
-        )]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(
-            &Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
-            d.1.data_type()
-        );
-    }
-
-    #[test]
-    fn test_dictionary_from_json_int32() {
-        let schema = Schema::new(vec![Field::new(
-            "d",
-            Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
-            true,
-        )]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(
-            &Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
-            d.1.data_type()
-        );
-    }
-
-    #[test]
-    fn test_dictionary_from_json_int64() {
-        let schema = Schema::new(vec![Field::new(
-            "d",
-            Dictionary(Box::new(DataType::Int64), Box::new(DataType::Utf8)),
-            true,
-        )]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(
-            &Dictionary(Box::new(DataType::Int64), Box::new(DataType::Utf8)),
-            d.1.data_type()
-        );
-    }
-
-    #[test]
-    fn test_skip_empty_lines() {
-        let builder = ReaderBuilder::new().infer_schema(None).with_batch_size(64);
-        let json_content = "
-        {\"a\": 1}
-
-        {\"a\": 2}
-
-        {\"a\": 3}";
-        let mut reader = builder.build(Cursor::new(json_content)).unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(3, batch.num_rows());
-
-        let schema = reader.schema();
-        let c = schema.column_with_name("a").unwrap();
-        assert_eq!(&DataType::Int64, c.1.data_type());
-    }
-
-    #[test]
-    fn test_row_type_validation() {
-        let builder = ReaderBuilder::new().infer_schema(None).with_batch_size(64);
-        let json_content = "
-        [1, \"hello\"]
-        \"world\"";
-        let re = builder.build(Cursor::new(json_content));
-        assert_eq!(
-            re.err().unwrap().to_string(),
-            r#"Json error: Expected JSON record to be an object, found Array([Number(1), String("hello")])"#,
-        );
-    }
-
-    #[test]
-    fn test_list_of_string_dictionary_from_json() {
-        let schema = Schema::new(vec![Field::new(
-            "events",
-            List(Box::new(Field::new(
-                "item",
-                Dictionary(Box::new(DataType::UInt64), Box::new(DataType::Utf8)),
-                true,
-            ))),
-            true,
-        )]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/list_string_dict_nested.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(3, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let events = schema.column_with_name("events").unwrap();
-        assert_eq!(
-            &List(Box::new(Field::new(
-                "item",
-                Dictionary(Box::new(DataType::UInt64), Box::new(DataType::Utf8)),
-                true
-            ))),
-            events.1.data_type()
-        );
-
-        let evs_list = batch
-            .column(events.0)
-            .as_any()
-            .downcast_ref::<ListArray>()
-            .unwrap();
-        let evs_list = evs_list.values();
-        let evs_list = evs_list
-            .as_any()
-            .downcast_ref::<DictionaryArray<UInt64Type>>()
-            .unwrap();
-        assert_eq!(6, evs_list.len());
-        assert!(evs_list.is_valid(1));
-        assert_eq!(DataType::Utf8, evs_list.value_type());
-
-        // dict from the events list
-        let dict_el = evs_list.values();
-        let dict_el = dict_el.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(3, dict_el.len());
-        assert_eq!("Elect Leader", dict_el.value(0));
-        assert_eq!("Do Ballot", dict_el.value(1));
-        assert_eq!("Send Data", dict_el.value(2));
-    }
-
-    #[test]
-    fn test_list_of_string_dictionary_from_json_with_nulls() {
-        let schema = Schema::new(vec![Field::new(
-            "events",
-            List(Box::new(Field::new(
-                "item",
-                Dictionary(Box::new(DataType::UInt64), Box::new(DataType::Utf8)),
-                true,
-            ))),
-            true,
-        )]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(
-                File::open("test/data/list_string_dict_nested_nulls.json").unwrap(),
-            )
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(3, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let events = schema.column_with_name("events").unwrap();
-        assert_eq!(
-            &List(Box::new(Field::new(
-                "item",
-                Dictionary(Box::new(DataType::UInt64), Box::new(DataType::Utf8)),
-                true
-            ))),
-            events.1.data_type()
-        );
-
-        let evs_list = batch
-            .column(events.0)
-            .as_any()
-            .downcast_ref::<ListArray>()
-            .unwrap();
-        let evs_list = evs_list.values();
-        let evs_list = evs_list
-            .as_any()
-            .downcast_ref::<DictionaryArray<UInt64Type>>()
-            .unwrap();
-        assert_eq!(8, evs_list.len());
-        assert!(evs_list.is_valid(1));
-        assert_eq!(DataType::Utf8, evs_list.value_type());
-
-        // dict from the events list
-        let dict_el = evs_list.values();
-        let dict_el = dict_el.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(2, evs_list.null_count());
-        assert_eq!(3, dict_el.len());
-        assert_eq!("Elect Leader", dict_el.value(0));
-        assert_eq!("Do Ballot", dict_el.value(1));
-        assert_eq!("Send Data", dict_el.value(2));
-    }
-
-    #[test]
-    fn test_dictionary_from_json_uint8() {
-        let schema = Schema::new(vec![Field::new(
-            "d",
-            Dictionary(Box::new(DataType::UInt8), Box::new(DataType::Utf8)),
-            true,
-        )]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(
-            &Dictionary(Box::new(DataType::UInt8), Box::new(DataType::Utf8)),
-            d.1.data_type()
-        );
-    }
-
-    #[test]
-    fn test_dictionary_from_json_uint32() {
-        let schema = Schema::new(vec![Field::new(
-            "d",
-            Dictionary(Box::new(DataType::UInt32), Box::new(DataType::Utf8)),
-            true,
-        )]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(
-            &Dictionary(Box::new(DataType::UInt32), Box::new(DataType::Utf8)),
-            d.1.data_type()
-        );
-    }
-
-    #[test]
-    fn test_dictionary_from_json_uint64() {
-        let schema = Schema::new(vec![Field::new(
-            "d",
-            Dictionary(Box::new(DataType::UInt64), Box::new(DataType::Utf8)),
-            true,
-        )]);
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let d = schema.column_with_name("d").unwrap();
-        assert_eq!(
-            &Dictionary(Box::new(DataType::UInt64), Box::new(DataType::Utf8)),
-            d.1.data_type()
-        );
-    }
-
-    #[test]
-    fn test_with_multiple_batches() {
-        let builder = ReaderBuilder::new()
-            .infer_schema(Some(4))
-            .with_batch_size(5);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-
-        let mut num_records = Vec::new();
-        while let Some(rb) = reader.next().unwrap() {
-            num_records.push(rb.num_rows());
-        }
-
-        assert_eq!(vec![5, 5, 2], num_records);
-    }
-
-    #[test]
-    fn test_json_infer_schema() {
-        let schema = Schema::new(vec![
-            Field::new("a", DataType::Int64, true),
-            Field::new(
-                "b",
-                DataType::List(Box::new(Field::new("item", DataType::Float64, true))),
-                true,
-            ),
-            Field::new(
-                "c",
-                DataType::List(Box::new(Field::new("item", DataType::Boolean, true))),
-                true,
-            ),
-            Field::new(
-                "d",
-                DataType::List(Box::new(Field::new("item", DataType::Utf8, true))),
-                true,
-            ),
-        ]);
-
-        let mut reader =
-            BufReader::new(File::open("test/data/mixed_arrays.json").unwrap());
-        let inferred_schema = infer_json_schema_from_seekable(&mut reader, None).unwrap();
-
-        assert_eq!(inferred_schema, schema);
-
-        let file = File::open("test/data/mixed_arrays.json.gz").unwrap();
-        let mut reader = BufReader::new(GzDecoder::new(&file));
-        let inferred_schema = infer_json_schema(&mut reader, None).unwrap();
-
-        assert_eq!(inferred_schema, schema);
-    }
-
-    #[test]
-    fn test_json_infer_schema_nested_structs() {
-        let schema = Schema::new(vec![
-            Field::new(
-                "c1",
-                DataType::Struct(vec![
-                    Field::new("a", DataType::Boolean, true),
-                    Field::new(
-                        "b",
-                        DataType::Struct(vec![Field::new("c", DataType::Utf8, true)]),
-                        true,
-                    ),
-                ]),
-                true,
-            ),
-            Field::new("c2", DataType::Int64, true),
-            Field::new("c3", DataType::Utf8, true),
-        ]);
-
-        let inferred_schema = infer_json_schema_from_iterator(
-            vec![
-                Ok(serde_json::json!({"c1": {"a": true, "b": {"c": "text"}}, "c2": 1})),
-                Ok(serde_json::json!({"c1": {"a": false, "b": null}, "c2": 0})),
-                Ok(serde_json::json!({"c1": {"a": true, "b": {"c": "text"}}, "c3": "ok"})),
-            ]
-            .into_iter(),
-        )
-        .unwrap();
-
-        assert_eq!(inferred_schema, schema);
-    }
-
-    #[test]
-    fn test_json_infer_schema_struct_in_list() {
-        let schema = Schema::new(vec![
-            Field::new(
-                "c1",
-                DataType::List(Box::new(Field::new(
-                    "item",
-                    DataType::Struct(vec![
-                        Field::new("a", DataType::Utf8, true),
-                        Field::new("b", DataType::Int64, true),
-                        Field::new("c", DataType::Boolean, true),
-                    ]),
-                    true,
-                ))),
-                true,
-            ),
-            Field::new("c2", DataType::Float64, true),
-            Field::new(
-                "c3",
-                // empty json array's inner types are inferred as null
-                DataType::List(Box::new(Field::new("item", DataType::Null, true))),
-                true,
-            ),
-        ]);
-
-        let inferred_schema = infer_json_schema_from_iterator(
-            vec![
-                Ok(serde_json::json!({
-                    "c1": [{"a": "foo", "b": 100}], "c2": 1, "c3": [],
-                })),
-                Ok(serde_json::json!({
-                    "c1": [{"a": "bar", "b": 2}, {"a": "foo", "c": true}], "c2": 0, "c3": [],
-                })),
-                Ok(serde_json::json!({"c1": [], "c2": 0.5, "c3": []})),
-            ]
-            .into_iter(),
-        )
-        .unwrap();
-
-        assert_eq!(inferred_schema, schema);
-    }
-
-    #[test]
-    fn test_json_infer_schema_nested_list() {
-        let schema = Schema::new(vec![
-            Field::new(
-                "c1",
-                DataType::List(Box::new(Field::new(
-                    "item",
-                    DataType::List(Box::new(Field::new("item", DataType::Utf8, true))),
-                    true,
-                ))),
-                true,
-            ),
-            Field::new("c2", DataType::Float64, true),
-        ]);
-
-        let inferred_schema = infer_json_schema_from_iterator(
-            vec![
-                Ok(serde_json::json!({
-                    "c1": [],
-                    "c2": 12,
-                })),
-                Ok(serde_json::json!({
-                    "c1": [["a", "b"], ["c"]],
-                })),
-                Ok(serde_json::json!({
-                    "c1": [["foo"]],
-                    "c2": 0.11,
-                })),
-            ]
-            .into_iter(),
-        )
-        .unwrap();
-
-        assert_eq!(inferred_schema, schema);
-    }
-
-    #[test]
-    fn test_timestamp_from_json_seconds() {
-        let schema = Schema::new(vec![Field::new(
-            "a",
-            DataType::Timestamp(TimeUnit::Second, None),
-            true,
-        )]);
-
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let a = schema.column_with_name("a").unwrap();
-        assert_eq!(
-            &DataType::Timestamp(TimeUnit::Second, None),
-            a.1.data_type()
-        );
-
-        let aa = batch
-            .column(a.0)
-            .as_any()
-            .downcast_ref::<TimestampSecondArray>()
-            .unwrap();
-        assert!(aa.is_valid(0));
-        assert!(!aa.is_valid(1));
-        assert!(!aa.is_valid(2));
-        assert_eq!(1, aa.value(0));
-        assert_eq!(1, aa.value(3));
-        assert_eq!(5, aa.value(7));
-    }
-
-    #[test]
-    fn test_timestamp_from_json_milliseconds() {
-        let schema = Schema::new(vec![Field::new(
-            "a",
-            DataType::Timestamp(TimeUnit::Millisecond, None),
-            true,
-        )]);
-
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let a = schema.column_with_name("a").unwrap();
-        assert_eq!(
-            &DataType::Timestamp(TimeUnit::Millisecond, None),
-            a.1.data_type()
-        );
-
-        let aa = batch
-            .column(a.0)
-            .as_any()
-            .downcast_ref::<TimestampMillisecondArray>()
-            .unwrap();
-        assert!(aa.is_valid(0));
-        assert!(!aa.is_valid(1));
-        assert!(!aa.is_valid(2));
-        assert_eq!(1, aa.value(0));
-        assert_eq!(1, aa.value(3));
-        assert_eq!(5, aa.value(7));
-    }
-
-    #[test]
-    fn test_date_from_json_milliseconds() {
-        let schema = Schema::new(vec![Field::new("a", DataType::Date64, true)]);
-
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let a = schema.column_with_name("a").unwrap();
-        assert_eq!(&DataType::Date64, a.1.data_type());
-
-        let aa = batch
-            .column(a.0)
-            .as_any()
-            .downcast_ref::<Date64Array>()
-            .unwrap();
-        assert!(aa.is_valid(0));
-        assert!(!aa.is_valid(1));
-        assert!(!aa.is_valid(2));
-        assert_eq!(1, aa.value(0));
-        assert_eq!(1, aa.value(3));
-        assert_eq!(5, aa.value(7));
-    }
-
-    #[test]
-    fn test_time_from_json_nanoseconds() {
-        let schema = Schema::new(vec![Field::new(
-            "a",
-            DataType::Time64(TimeUnit::Nanosecond),
-            true,
-        )]);
-
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        assert_eq!(1, batch.num_columns());
-        assert_eq!(12, batch.num_rows());
-
-        let schema = reader.schema();
-        let batch_schema = batch.schema();
-        assert_eq!(schema, batch_schema);
-
-        let a = schema.column_with_name("a").unwrap();
-        assert_eq!(&DataType::Time64(TimeUnit::Nanosecond), a.1.data_type());
-
-        let aa = batch
-            .column(a.0)
-            .as_any()
-            .downcast_ref::<Time64NanosecondArray>()
-            .unwrap();
-        assert!(aa.is_valid(0));
-        assert!(!aa.is_valid(1));
-        assert!(!aa.is_valid(2));
-        assert_eq!(1, aa.value(0));
-        assert_eq!(1, aa.value(3));
-        assert_eq!(5, aa.value(7));
-    }
-
-    #[test]
-    fn test_time_from_string() {
-        parse_string_column::<Time64NanosecondType>(4);
-        parse_string_column::<Time64MicrosecondType>(4);
-        parse_string_column::<Time32MillisecondType>(4);
-        parse_string_column::<Time32SecondType>(4);
-    }
-
-    fn parse_string_column<T>(value: T::Native)
-    where
-        T: ArrowPrimitiveType,
-    {
-        let schema = Schema::new(vec![Field::new("d", T::DATA_TYPE, true)]);
-
-        let builder = ReaderBuilder::new()
-            .with_schema(Arc::new(schema))
-            .with_batch_size(64);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic_nulls.json").unwrap())
-            .unwrap();
-
-        let batch = reader.next().unwrap().unwrap();
-        let dd = batch
-            .column(0)
-            .as_any()
-            .downcast_ref::<PrimitiveArray<T>>()
-            .unwrap();
-        assert_eq!(value, dd.value(1));
-        assert!(!dd.is_valid(2));
-    }
-
-    #[test]
-    fn test_json_read_nested_list() {
-        let schema = Schema::new(vec![Field::new(
-            "c1",
-            DataType::List(Box::new(Field::new(
-                "item",
-                DataType::List(Box::new(Field::new("item", DataType::Utf8, true))),
-                true,
-            ))),
-            true,
-        )]);
-
-        let decoder = Decoder::new(Arc::new(schema), DecoderOptions::new());
-        let batch = decoder
-            .next_batch(
-                &mut vec![
-                    Ok(serde_json::json!({
-                        "c1": [],
-                    })),
-                    Ok(serde_json::json!({
-                        "c1": [["a", "b"], ["c"], ["e", "f"], ["g"], ["h"], ["i"], ["j"], ["k"]],
-                    })),
-                    Ok(serde_json::json!({
-                        "c1": [["foo"], ["bar"]],
-                    })),
-                ]
-                .into_iter(),
-            )
-            .unwrap()
-            .unwrap();
-
-        assert_eq!(batch.num_columns(), 1);
-        assert_eq!(batch.num_rows(), 3);
-    }
-
-    #[test]
-    fn test_json_read_list_of_structs() {
-        let schema = Schema::new(vec![Field::new(
-            "c1",
-            DataType::List(Box::new(Field::new(
-                "item",
-                DataType::Struct(vec![Field::new("a", DataType::Int64, true)]),
-                true,
-            ))),
-            true,
-        )]);
-
-        let decoder = Decoder::new(Arc::new(schema), DecoderOptions::new());
-        let batch = decoder
-            .next_batch(
-                // NOTE: total struct element count needs to be greater than
-                // bit_util::ceil(array_count, 8) to test validity bit buffer length calculation
-                // logic
-                &mut vec![
-                    Ok(serde_json::json!({
-                        "c1": [{"a": 1}],
-                    })),
-                    Ok(serde_json::json!({
-                        "c1": [{"a": 2}, {"a": 3}, {"a": 4}, {"a": 5}, {"a": 6}, {"a": 7}],
-                    })),
-                    Ok(serde_json::json!({
-                        "c1": [{"a": 10}, {"a": 11}],
-                    })),
-                ]
-                .into_iter(),
-            )
-            .unwrap()
-            .unwrap();
-
-        assert_eq!(batch.num_columns(), 1);
-        assert_eq!(batch.num_rows(), 3);
-    }
-
-    #[test]
-    fn test_json_read_binary_structs() {
-        let schema = Schema::new(vec![Field::new("c1", DataType::Binary, true)]);
-        let decoder = Decoder::new(Arc::new(schema), DecoderOptions::new());
-        let batch = decoder
-            .next_batch(
-                &mut vec![
-                    Ok(serde_json::json!({
-                        "c1": "₁₂₃",
-                    })),
-                    Ok(serde_json::json!({
-                        "c1": "foo",
-                    })),
-                ]
-                .into_iter(),
-            )
-            .unwrap()
-            .unwrap();
-        let data = batch.columns().iter().collect::<Vec<_>>();
-
-        let schema = Schema::new(vec![Field::new("c1", DataType::Binary, true)]);
-        let binary_values = BinaryArray::from(vec!["₁₂₃".as_bytes(), "foo".as_bytes()]);
-        let expected_batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(binary_values)])
-                .unwrap();
-        let expected_data = expected_batch.columns().iter().collect::<Vec<_>>();
-
-        assert_eq!(data, expected_data);
-        assert_eq!(batch.num_columns(), 1);
-        assert_eq!(batch.num_rows(), 2);
-    }
-
-    #[test]
-    fn test_json_iterator() {
-        let builder = ReaderBuilder::new().infer_schema(None).with_batch_size(5);
-        let reader: Reader<File> = builder
-            .build::<File>(File::open("test/data/basic.json").unwrap())
-            .unwrap();
-        let schema = reader.schema();
-        let (col_a_index, _) = schema.column_with_name("a").unwrap();
-
-        let mut sum_num_rows = 0;
-        let mut num_batches = 0;
-        let mut sum_a = 0;
-        for batch in reader {
-            let batch = batch.unwrap();
-            assert_eq!(5, batch.num_columns());
-            sum_num_rows += batch.num_rows();
-            num_batches += 1;
-            let batch_schema = batch.schema();
-            assert_eq!(schema, batch_schema);
-            let a_array = batch
-                .column(col_a_index)
-                .as_any()
-                .downcast_ref::<Int64Array>()
-                .unwrap();
-            sum_a += (0..a_array.len()).map(|i| a_array.value(i)).sum::<i64>();
-        }
-        assert_eq!(12, sum_num_rows);
-        assert_eq!(3, num_batches);
-        assert_eq!(100000000000011, sum_a);
-    }
-
-    #[test]
-    fn test_options_clone() {
-        // ensure options have appropriate derivation
-        let options = DecoderOptions::new().with_batch_size(64);
-        let cloned = options.clone();
-        assert_eq!(options, cloned);
-    }
-}
diff --git a/arrow/src/json/writer.rs b/arrow/src/json/writer.rs
deleted file mode 100644
index f21dad04313b..000000000000
--- a/arrow/src/json/writer.rs
+++ /dev/null
@@ -1,1515 +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.
-
-//! # JSON Writer
-//!
-//! This JSON writer converts Arrow [`RecordBatch`]es into arrays of
-//! JSON objects or JSON formatted byte streams.
-//!
-//! ## Writing JSON Objects
-//!
-//! To serialize [`RecordBatch`]es into array of
-//! [JSON](https://docs.serde.rs/serde_json/) objects, use
-//! [`record_batches_to_json_rows`]:
-//!
-//! ```
-//! use std::sync::Arc;
-//!
-//! use arrow::array::Int32Array;
-//! use arrow::datatypes::{DataType, Field, Schema};
-//! use arrow::json;
-//! use arrow::record_batch::RecordBatch;
-//!
-//! let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
-//! let a = Int32Array::from(vec![1, 2, 3]);
-//! let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap();
-//!
-//! let json_rows = json::writer::record_batches_to_json_rows(&[batch]).unwrap();
-//! assert_eq!(
-//!     serde_json::Value::Object(json_rows[1].clone()),
-//!     serde_json::json!({"a": 2}),
-//! );
-//! ```
-//!
-//! ## Writing JSON formatted byte streams
-//!
-//! To serialize [`RecordBatch`]es into line-delimited JSON bytes, use
-//! [`LineDelimitedWriter`]:
-//!
-//! ```
-//! use std::sync::Arc;
-//!
-//! use arrow::array::Int32Array;
-//! use arrow::datatypes::{DataType, Field, Schema};
-//! use arrow::json;
-//! use arrow::record_batch::RecordBatch;
-//!
-//! let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
-//! let a = Int32Array::from(vec![1, 2, 3]);
-//! let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap();
-//!
-//! // Write the record batch out as JSON
-//! let buf = Vec::new();
-//! let mut writer = json::LineDelimitedWriter::new(buf);
-//! writer.write_batches(&vec![batch]).unwrap();
-//! writer.finish().unwrap();
-//!
-//! // Get the underlying buffer back,
-//! let buf = writer.into_inner();
-//! assert_eq!(r#"{"a":1}
-//! {"a":2}
-//! {"a":3}
-//!"#, String::from_utf8(buf).unwrap())
-//! ```
-//!
-//! To serialize [`RecordBatch`]es into a well formed JSON array, use
-//! [`ArrayWriter`]:
-//!
-//! ```
-//! use std::sync::Arc;
-//!
-//! use arrow::array::Int32Array;
-//! use arrow::datatypes::{DataType, Field, Schema};
-//! use arrow::json;
-//! use arrow::record_batch::RecordBatch;
-//!
-//! let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
-//! let a = Int32Array::from(vec![1, 2, 3]);
-//! let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap();
-//!
-//! // Write the record batch out as a JSON array
-//! let buf = Vec::new();
-//! let mut writer = json::ArrayWriter::new(buf);
-//! writer.write_batches(&vec![batch]).unwrap();
-//! writer.finish().unwrap();
-//!
-//! // Get the underlying buffer back,
-//! let buf = writer.into_inner();
-//! assert_eq!(r#"[{"a":1},{"a":2},{"a":3}]"#, String::from_utf8(buf).unwrap())
-//! ```
-
-use std::iter;
-use std::{fmt::Debug, io::Write};
-
-use serde_json::map::Map as JsonMap;
-use serde_json::Value;
-
-use crate::array::*;
-use crate::datatypes::*;
-use crate::error::{ArrowError, Result};
-use crate::record_batch::RecordBatch;
-
-fn primitive_array_to_json<T: ArrowPrimitiveType>(
-    array: &ArrayRef,
-) -> Result<Vec<Value>> {
-    Ok(as_primitive_array::<T>(array)
-        .iter()
-        .map(|maybe_value| match maybe_value {
-            Some(v) => v.into_json_value().unwrap_or(Value::Null),
-            None => Value::Null,
-        })
-        .collect())
-}
-
-fn struct_array_to_jsonmap_array(
-    array: &StructArray,
-    row_count: usize,
-) -> Result<Vec<JsonMap<String, Value>>> {
-    let inner_col_names = array.column_names();
-
-    let mut inner_objs = iter::repeat(JsonMap::new())
-        .take(row_count)
-        .collect::<Vec<JsonMap<String, Value>>>();
-
-    for (j, struct_col) in array.columns().iter().enumerate() {
-        set_column_for_json_rows(
-            &mut inner_objs,
-            row_count,
-            struct_col,
-            inner_col_names[j],
-        )?
-    }
-    Ok(inner_objs)
-}
-
-/// Converts an arrow [`ArrayRef`] into a `Vec` of Serde JSON [`serde_json::Value`]'s
-pub fn array_to_json_array(array: &ArrayRef) -> Result<Vec<Value>> {
-    match array.data_type() {
-        DataType::Null => Ok(iter::repeat(Value::Null).take(array.len()).collect()),
-        DataType::Boolean => Ok(as_boolean_array(array)
-            .iter()
-            .map(|maybe_value| match maybe_value {
-                Some(v) => v.into(),
-                None => Value::Null,
-            })
-            .collect()),
-
-        DataType::Utf8 => Ok(as_string_array(array)
-            .iter()
-            .map(|maybe_value| match maybe_value {
-                Some(v) => v.into(),
-                None => Value::Null,
-            })
-            .collect()),
-        DataType::LargeUtf8 => Ok(as_largestring_array(array)
-            .iter()
-            .map(|maybe_value| match maybe_value {
-                Some(v) => v.into(),
-                None => Value::Null,
-            })
-            .collect()),
-        DataType::Int8 => primitive_array_to_json::<Int8Type>(array),
-        DataType::Int16 => primitive_array_to_json::<Int16Type>(array),
-        DataType::Int32 => primitive_array_to_json::<Int32Type>(array),
-        DataType::Int64 => primitive_array_to_json::<Int64Type>(array),
-        DataType::UInt8 => primitive_array_to_json::<UInt8Type>(array),
-        DataType::UInt16 => primitive_array_to_json::<UInt16Type>(array),
-        DataType::UInt32 => primitive_array_to_json::<UInt32Type>(array),
-        DataType::UInt64 => primitive_array_to_json::<UInt64Type>(array),
-        DataType::Float32 => primitive_array_to_json::<Float32Type>(array),
-        DataType::Float64 => primitive_array_to_json::<Float64Type>(array),
-        DataType::List(_) => as_list_array(array)
-            .iter()
-            .map(|maybe_value| match maybe_value {
-                Some(v) => Ok(Value::Array(array_to_json_array(&v)?)),
-                None => Ok(Value::Null),
-            })
-            .collect(),
-        DataType::LargeList(_) => as_large_list_array(array)
-            .iter()
-            .map(|maybe_value| match maybe_value {
-                Some(v) => Ok(Value::Array(array_to_json_array(&v)?)),
-                None => Ok(Value::Null),
-            })
-            .collect(),
-        DataType::Struct(_) => {
-            let jsonmaps =
-                struct_array_to_jsonmap_array(as_struct_array(array), array.len())?;
-            Ok(jsonmaps.into_iter().map(Value::Object).collect())
-        }
-        t => Err(ArrowError::JsonError(format!(
-            "data type {:?} not supported",
-            t
-        ))),
-    }
-}
-
-macro_rules! set_column_by_array_type {
-    ($cast_fn:ident, $col_name:ident, $rows:ident, $array:ident, $row_count:ident) => {
-        let arr = $cast_fn($array);
-        $rows.iter_mut().zip(arr.iter()).take($row_count).for_each(
-            |(row, maybe_value)| {
-                if let Some(v) = maybe_value {
-                    row.insert($col_name.to_string(), v.into());
-                }
-            },
-        );
-    };
-}
-
-macro_rules! set_temporal_column_by_array_type {
-    ($array_type:ident, $col_name:ident, $rows:ident, $array:ident, $row_count:ident, $cast_fn:ident) => {
-        let arr = $array.as_any().downcast_ref::<$array_type>().unwrap();
-
-        $rows
-            .iter_mut()
-            .enumerate()
-            .take($row_count)
-            .for_each(|(i, row)| {
-                if !arr.is_null(i) {
-                    if let Some(v) = arr.$cast_fn(i) {
-                        row.insert($col_name.to_string(), v.to_string().into());
-                    }
-                }
-            });
-    };
-}
-
-fn set_column_by_primitive_type<T: ArrowPrimitiveType>(
-    rows: &mut [JsonMap<String, Value>],
-    row_count: usize,
-    array: &ArrayRef,
-    col_name: &str,
-) {
-    let primitive_arr = as_primitive_array::<T>(array);
-
-    rows.iter_mut()
-        .zip(primitive_arr.iter())
-        .take(row_count)
-        .for_each(|(row, maybe_value)| {
-            // when value is null, we simply skip setting the key
-            if let Some(j) = maybe_value.and_then(|v| v.into_json_value()) {
-                row.insert(col_name.to_string(), j);
-            }
-        });
-}
-
-fn set_column_for_json_rows(
-    rows: &mut [JsonMap<String, Value>],
-    row_count: usize,
-    array: &ArrayRef,
-    col_name: &str,
-) -> Result<()> {
-    match array.data_type() {
-        DataType::Int8 => {
-            set_column_by_primitive_type::<Int8Type>(rows, row_count, array, col_name);
-        }
-        DataType::Int16 => {
-            set_column_by_primitive_type::<Int16Type>(rows, row_count, array, col_name);
-        }
-        DataType::Int32 => {
-            set_column_by_primitive_type::<Int32Type>(rows, row_count, array, col_name);
-        }
-        DataType::Int64 => {
-            set_column_by_primitive_type::<Int64Type>(rows, row_count, array, col_name);
-        }
-        DataType::UInt8 => {
-            set_column_by_primitive_type::<UInt8Type>(rows, row_count, array, col_name);
-        }
-        DataType::UInt16 => {
-            set_column_by_primitive_type::<UInt16Type>(rows, row_count, array, col_name);
-        }
-        DataType::UInt32 => {
-            set_column_by_primitive_type::<UInt32Type>(rows, row_count, array, col_name);
-        }
-        DataType::UInt64 => {
-            set_column_by_primitive_type::<UInt64Type>(rows, row_count, array, col_name);
-        }
-        DataType::Float32 => {
-            set_column_by_primitive_type::<Float32Type>(rows, row_count, array, col_name);
-        }
-        DataType::Float64 => {
-            set_column_by_primitive_type::<Float64Type>(rows, row_count, array, col_name);
-        }
-        DataType::Null => {
-            // when value is null, we simply skip setting the key
-        }
-        DataType::Boolean => {
-            set_column_by_array_type!(as_boolean_array, col_name, rows, array, row_count);
-        }
-        DataType::Utf8 => {
-            set_column_by_array_type!(as_string_array, col_name, rows, array, row_count);
-        }
-        DataType::LargeUtf8 => {
-            set_column_by_array_type!(
-                as_largestring_array,
-                col_name,
-                rows,
-                array,
-                row_count
-            );
-        }
-        DataType::Date32 => {
-            set_temporal_column_by_array_type!(
-                Date32Array,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_date
-            );
-        }
-        DataType::Date64 => {
-            set_temporal_column_by_array_type!(
-                Date64Array,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_date
-            );
-        }
-        DataType::Timestamp(TimeUnit::Second, _) => {
-            set_temporal_column_by_array_type!(
-                TimestampSecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_datetime
-            );
-        }
-        DataType::Timestamp(TimeUnit::Millisecond, _) => {
-            set_temporal_column_by_array_type!(
-                TimestampMillisecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_datetime
-            );
-        }
-        DataType::Timestamp(TimeUnit::Microsecond, _) => {
-            set_temporal_column_by_array_type!(
-                TimestampMicrosecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_datetime
-            );
-        }
-        DataType::Timestamp(TimeUnit::Nanosecond, _) => {
-            set_temporal_column_by_array_type!(
-                TimestampNanosecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_datetime
-            );
-        }
-        DataType::Time32(TimeUnit::Second) => {
-            set_temporal_column_by_array_type!(
-                Time32SecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_time
-            );
-        }
-        DataType::Time32(TimeUnit::Millisecond) => {
-            set_temporal_column_by_array_type!(
-                Time32MillisecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_time
-            );
-        }
-        DataType::Time64(TimeUnit::Microsecond) => {
-            set_temporal_column_by_array_type!(
-                Time64MicrosecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_time
-            );
-        }
-        DataType::Time64(TimeUnit::Nanosecond) => {
-            set_temporal_column_by_array_type!(
-                Time64NanosecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_time
-            );
-        }
-        DataType::Duration(TimeUnit::Second) => {
-            set_temporal_column_by_array_type!(
-                DurationSecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_duration
-            );
-        }
-        DataType::Duration(TimeUnit::Millisecond) => {
-            set_temporal_column_by_array_type!(
-                DurationMillisecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_duration
-            );
-        }
-        DataType::Duration(TimeUnit::Microsecond) => {
-            set_temporal_column_by_array_type!(
-                DurationMicrosecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_duration
-            );
-        }
-        DataType::Duration(TimeUnit::Nanosecond) => {
-            set_temporal_column_by_array_type!(
-                DurationNanosecondArray,
-                col_name,
-                rows,
-                array,
-                row_count,
-                value_as_duration
-            );
-        }
-        DataType::Struct(_) => {
-            let inner_objs =
-                struct_array_to_jsonmap_array(as_struct_array(array), row_count)?;
-            rows.iter_mut()
-                .take(row_count)
-                .zip(inner_objs.into_iter())
-                .for_each(|(row, obj)| {
-                    row.insert(col_name.to_string(), Value::Object(obj));
-                });
-        }
-        DataType::List(_) => {
-            let listarr = as_list_array(array);
-            rows.iter_mut()
-                .zip(listarr.iter())
-                .take(row_count)
-                .try_for_each(|(row, maybe_value)| -> Result<()> {
-                    if let Some(v) = maybe_value {
-                        row.insert(
-                            col_name.to_string(),
-                            Value::Array(array_to_json_array(&v)?),
-                        );
-                    }
-                    Ok(())
-                })?;
-        }
-        DataType::LargeList(_) => {
-            let listarr = as_large_list_array(array);
-            rows.iter_mut()
-                .zip(listarr.iter())
-                .take(row_count)
-                .try_for_each(|(row, maybe_value)| -> Result<()> {
-                    if let Some(v) = maybe_value {
-                        let val = array_to_json_array(&v)?;
-                        row.insert(col_name.to_string(), Value::Array(val));
-                    }
-                    Ok(())
-                })?;
-        }
-        DataType::Dictionary(_, value_type) => {
-            let slice = array.slice(0, row_count);
-            let hydrated = crate::compute::kernels::cast::cast(&slice, value_type)
-                .expect("cannot cast dictionary to underlying values");
-            set_column_for_json_rows(rows, row_count, &hydrated, col_name)?;
-        }
-        DataType::Map(_, _) => {
-            let maparr = as_map_array(array);
-
-            let keys = maparr.keys();
-            let values = maparr.values();
-
-            // Keys have to be strings to convert to json.
-            if !matches!(keys.data_type(), DataType::Utf8) {
-                return Err(ArrowError::JsonError(format!(
-                    "data type {:?} not supported in nested map for json writer",
-                    keys.data_type()
-                )));
-            }
-
-            let keys = as_string_array(&keys);
-            let values = array_to_json_array(&values)?;
-
-            let mut kv = keys.iter().zip(values.into_iter());
-
-            for (i, row) in rows.iter_mut().take(row_count).enumerate() {
-                if maparr.is_null(i) {
-                    row.insert(col_name.to_string(), serde_json::Value::Null);
-                    continue;
-                }
-
-                let len = maparr.value_length(i) as usize;
-                let mut obj = serde_json::Map::new();
-
-                for (_, (k, v)) in (0..len).zip(&mut kv) {
-                    obj.insert(
-                        k.expect("keys in a map should be non-null").to_string(),
-                        v,
-                    );
-                }
-
-                row.insert(col_name.to_string(), serde_json::Value::Object(obj));
-            }
-        }
-        _ => {
-            return Err(ArrowError::JsonError(format!(
-                "data type {:?} not supported in nested map for json writer",
-                array.data_type()
-            )))
-        }
-    }
-    Ok(())
-}
-
-/// Converts an arrow [`RecordBatch`] into a `Vec` of Serde JSON
-/// [`JsonMap`]s (objects)
-pub fn record_batches_to_json_rows(
-    batches: &[RecordBatch],
-) -> Result<Vec<JsonMap<String, Value>>> {
-    let mut rows: Vec<JsonMap<String, Value>> = iter::repeat(JsonMap::new())
-        .take(batches.iter().map(|b| b.num_rows()).sum())
-        .collect();
-
-    if !rows.is_empty() {
-        let schema = batches[0].schema();
-        let mut base = 0;
-        for batch in batches {
-            let row_count = batch.num_rows();
-            for (j, col) in batch.columns().iter().enumerate() {
-                let col_name = schema.field(j).name();
-                set_column_for_json_rows(&mut rows[base..], row_count, col, col_name)?
-            }
-            base += row_count;
-        }
-    }
-
-    Ok(rows)
-}
-
-/// This trait defines how to format a sequence of JSON objects to a
-/// byte stream.
-pub trait JsonFormat: Debug + Default {
-    #[inline]
-    /// write any bytes needed at the start of the file to the writer
-    fn start_stream<W: Write>(&self, _writer: &mut W) -> Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    /// write any bytes needed for the start of each row
-    fn start_row<W: Write>(&self, _writer: &mut W, _is_first_row: bool) -> Result<()> {
-        Ok(())
-    }
-
-    #[inline]
-    /// write any bytes needed for the end of each row
-    fn end_row<W: Write>(&self, _writer: &mut W) -> Result<()> {
-        Ok(())
-    }
-
-    /// write any bytes needed for the start of each row
-    fn end_stream<W: Write>(&self, _writer: &mut W) -> Result<()> {
-        Ok(())
-    }
-}
-
-/// Produces JSON output with one record per line. For example
-///
-/// ```json
-/// {"foo":1}
-/// {"bar":1}
-///
-/// ```
-#[derive(Debug, Default)]
-pub struct LineDelimited {}
-
-impl JsonFormat for LineDelimited {
-    fn end_row<W: Write>(&self, writer: &mut W) -> Result<()> {
-        writer.write_all(b"\n")?;
-        Ok(())
-    }
-}
-
-/// Produces JSON output as a single JSON array. For example
-///
-/// ```json
-/// [{"foo":1},{"bar":1}]
-/// ```
-#[derive(Debug, Default)]
-pub struct JsonArray {}
-
-impl JsonFormat for JsonArray {
-    fn start_stream<W: Write>(&self, writer: &mut W) -> Result<()> {
-        writer.write_all(b"[")?;
-        Ok(())
-    }
-
-    fn start_row<W: Write>(&self, writer: &mut W, is_first_row: bool) -> Result<()> {
-        if !is_first_row {
-            writer.write_all(b",")?;
-        }
-        Ok(())
-    }
-
-    fn end_stream<W: Write>(&self, writer: &mut W) -> Result<()> {
-        writer.write_all(b"]")?;
-        Ok(())
-    }
-}
-
-/// A JSON writer which serializes [`RecordBatch`]es to newline delimited JSON objects
-pub type LineDelimitedWriter<W> = Writer<W, LineDelimited>;
-
-/// A JSON writer which serializes [`RecordBatch`]es to JSON arrays
-pub type ArrayWriter<W> = Writer<W, JsonArray>;
-
-/// A JSON writer which serializes [`RecordBatch`]es to a stream of
-/// `u8` encoded JSON objects. See the module level documentation for
-/// detailed usage and examples. The specific format of the stream is
-/// controlled by the [`JsonFormat`] type parameter.
-#[derive(Debug)]
-pub struct Writer<W, F>
-where
-    W: Write,
-    F: JsonFormat,
-{
-    /// Underlying writer to use to write bytes
-    writer: W,
-
-    /// Has the writer output any records yet?
-    started: bool,
-
-    /// Is the writer finished?
-    finished: bool,
-
-    /// Determines how the byte stream is formatted
-    format: F,
-}
-
-impl<W, F> Writer<W, F>
-where
-    W: Write,
-    F: JsonFormat,
-{
-    /// Construct a new writer
-    pub fn new(writer: W) -> Self {
-        Self {
-            writer,
-            started: false,
-            finished: false,
-            format: F::default(),
-        }
-    }
-
-    /// Write a single JSON row to the output writer
-    pub fn write_row(&mut self, row: &Value) -> Result<()> {
-        let is_first_row = !self.started;
-        if !self.started {
-            self.format.start_stream(&mut self.writer)?;
-            self.started = true;
-        }
-
-        self.format.start_row(&mut self.writer, is_first_row)?;
-        self.writer.write_all(&serde_json::to_vec(row)?)?;
-        self.format.end_row(&mut self.writer)?;
-        Ok(())
-    }
-
-    /// Convert the `RecordBatch` into JSON rows, and write them to the output
-    pub fn write(&mut self, batch: RecordBatch) -> Result<()> {
-        for row in record_batches_to_json_rows(&[batch])? {
-            self.write_row(&Value::Object(row))?;
-        }
-        Ok(())
-    }
-
-    /// Convert the [`RecordBatch`] into JSON rows, and write them to the output
-    pub fn write_batches(&mut self, batches: &[RecordBatch]) -> Result<()> {
-        for row in record_batches_to_json_rows(batches)? {
-            self.write_row(&Value::Object(row))?;
-        }
-        Ok(())
-    }
-
-    /// Finishes the output stream. This function must be called after
-    /// all record batches have been produced. (e.g. producing the final `']'` if writing
-    /// arrays.
-    pub fn finish(&mut self) -> Result<()> {
-        if self.started && !self.finished {
-            self.format.end_stream(&mut self.writer)?;
-            self.finished = true;
-        }
-        Ok(())
-    }
-
-    /// Unwraps this `Writer<W>`, returning the underlying writer
-    pub fn into_inner(self) -> W {
-        self.writer
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use std::convert::TryFrom;
-    use std::fs::{read_to_string, File};
-    use std::sync::Arc;
-
-    use serde_json::json;
-
-    use crate::buffer::*;
-    use crate::json::reader::*;
-
-    use super::*;
-
-    /// Asserts that the NDJSON `input` is semantically identical to `expected`
-    fn assert_json_eq(input: &[u8], expected: &str) {
-        let expected: Vec<Option<Value>> = expected
-            .split('\n')
-            .map(|s| (!s.is_empty()).then(|| serde_json::from_str(s).unwrap()))
-            .collect();
-
-        let actual: Vec<Option<Value>> = input
-            .split(|b| *b == b'\n')
-            .map(|s| (!s.is_empty()).then(|| serde_json::from_slice(s).unwrap()))
-            .collect();
-
-        assert_eq!(expected, actual);
-    }
-
-    #[test]
-    fn write_simple_rows() {
-        let schema = Schema::new(vec![
-            Field::new("c1", DataType::Int32, true),
-            Field::new("c2", DataType::Utf8, true),
-        ]);
-
-        let a = Int32Array::from(vec![Some(1), Some(2), Some(3), None, Some(5)]);
-        let b = StringArray::from(vec![Some("a"), Some("b"), Some("c"), Some("d"), None]);
-
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)])
-                .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"c1":1,"c2":"a"}
-{"c1":2,"c2":"b"}
-{"c1":3,"c2":"c"}
-{"c2":"d"}
-{"c1":5}
-"#,
-        );
-    }
-
-    #[test]
-    fn write_large_utf8() {
-        let schema = Schema::new(vec![
-            Field::new("c1", DataType::Utf8, true),
-            Field::new("c2", DataType::LargeUtf8, true),
-        ]);
-
-        let a = StringArray::from(vec![Some("a"), None, Some("c"), Some("d"), None]);
-        let b = LargeStringArray::from(vec![Some("a"), Some("b"), None, Some("d"), None]);
-
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)])
-                .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"c1":"a","c2":"a"}
-{"c2":"b"}
-{"c1":"c"}
-{"c1":"d","c2":"d"}
-{}
-"#,
-        );
-    }
-
-    #[test]
-    fn write_dictionary() {
-        let schema = Schema::new(vec![
-            Field::new(
-                "c1",
-                DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
-                true,
-            ),
-            Field::new(
-                "c2",
-                DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)),
-                true,
-            ),
-        ]);
-
-        let a: DictionaryArray<Int32Type> = vec![
-            Some("cupcakes"),
-            Some("foo"),
-            Some("foo"),
-            None,
-            Some("cupcakes"),
-        ]
-        .into_iter()
-        .collect();
-        let b: DictionaryArray<Int8Type> =
-            vec![Some("sdsd"), Some("sdsd"), None, Some("sd"), Some("sdsd")]
-                .into_iter()
-                .collect();
-
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)])
-                .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"c1":"cupcakes","c2":"sdsd"}
-{"c1":"foo","c2":"sdsd"}
-{"c1":"foo"}
-{"c2":"sd"}
-{"c1":"cupcakes","c2":"sdsd"}
-"#,
-        );
-    }
-
-    #[test]
-    fn write_timestamps() {
-        let ts_string = "2018-11-13T17:11:10.011375885995";
-        let ts_nanos = ts_string
-            .parse::<chrono::NaiveDateTime>()
-            .unwrap()
-            .timestamp_nanos();
-        let ts_micros = ts_nanos / 1000;
-        let ts_millis = ts_micros / 1000;
-        let ts_secs = ts_millis / 1000;
-
-        let arr_nanos =
-            TimestampNanosecondArray::from_opt_vec(vec![Some(ts_nanos), None], None);
-        let arr_micros =
-            TimestampMicrosecondArray::from_opt_vec(vec![Some(ts_micros), None], None);
-        let arr_millis =
-            TimestampMillisecondArray::from_opt_vec(vec![Some(ts_millis), None], None);
-        let arr_secs =
-            TimestampSecondArray::from_opt_vec(vec![Some(ts_secs), None], None);
-        let arr_names = StringArray::from(vec![Some("a"), Some("b")]);
-
-        let schema = Schema::new(vec![
-            Field::new("nanos", arr_nanos.data_type().clone(), true),
-            Field::new("micros", arr_micros.data_type().clone(), true),
-            Field::new("millis", arr_millis.data_type().clone(), true),
-            Field::new("secs", arr_secs.data_type().clone(), true),
-            Field::new("name", arr_names.data_type().clone(), true),
-        ]);
-        let schema = Arc::new(schema);
-
-        let batch = RecordBatch::try_new(
-            schema,
-            vec![
-                Arc::new(arr_nanos),
-                Arc::new(arr_micros),
-                Arc::new(arr_millis),
-                Arc::new(arr_secs),
-                Arc::new(arr_names),
-            ],
-        )
-        .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"nanos":"2018-11-13 17:11:10.011375885","micros":"2018-11-13 17:11:10.011375","millis":"2018-11-13 17:11:10.011","secs":"2018-11-13 17:11:10","name":"a"}
-{"name":"b"}
-"#,
-        );
-    }
-
-    #[test]
-    fn write_dates() {
-        let ts_string = "2018-11-13T17:11:10.011375885995";
-        let ts_millis = ts_string
-            .parse::<chrono::NaiveDateTime>()
-            .unwrap()
-            .timestamp_millis();
-
-        let arr_date32 = Date32Array::from(vec![
-            Some(i32::try_from(ts_millis / 1000 / (60 * 60 * 24)).unwrap()),
-            None,
-        ]);
-        let arr_date64 = Date64Array::from(vec![Some(ts_millis), None]);
-        let arr_names = StringArray::from(vec![Some("a"), Some("b")]);
-
-        let schema = Schema::new(vec![
-            Field::new("date32", arr_date32.data_type().clone(), true),
-            Field::new("date64", arr_date64.data_type().clone(), true),
-            Field::new("name", arr_names.data_type().clone(), false),
-        ]);
-        let schema = Arc::new(schema);
-
-        let batch = RecordBatch::try_new(
-            schema,
-            vec![
-                Arc::new(arr_date32),
-                Arc::new(arr_date64),
-                Arc::new(arr_names),
-            ],
-        )
-        .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"date32":"2018-11-13","date64":"2018-11-13","name":"a"}
-{"name":"b"}
-"#,
-        );
-    }
-
-    #[test]
-    fn write_times() {
-        let arr_time32sec = Time32SecondArray::from(vec![Some(120), None]);
-        let arr_time32msec = Time32MillisecondArray::from(vec![Some(120), None]);
-        let arr_time64usec = Time64MicrosecondArray::from(vec![Some(120), None]);
-        let arr_time64nsec = Time64NanosecondArray::from(vec![Some(120), None]);
-        let arr_names = StringArray::from(vec![Some("a"), Some("b")]);
-
-        let schema = Schema::new(vec![
-            Field::new("time32sec", arr_time32sec.data_type().clone(), true),
-            Field::new("time32msec", arr_time32msec.data_type().clone(), true),
-            Field::new("time64usec", arr_time64usec.data_type().clone(), true),
-            Field::new("time64nsec", arr_time64nsec.data_type().clone(), true),
-            Field::new("name", arr_names.data_type().clone(), true),
-        ]);
-        let schema = Arc::new(schema);
-
-        let batch = RecordBatch::try_new(
-            schema,
-            vec![
-                Arc::new(arr_time32sec),
-                Arc::new(arr_time32msec),
-                Arc::new(arr_time64usec),
-                Arc::new(arr_time64nsec),
-                Arc::new(arr_names),
-            ],
-        )
-        .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"time32sec":"00:02:00","time32msec":"00:00:00.120","time64usec":"00:00:00.000120","time64nsec":"00:00:00.000000120","name":"a"}
-{"name":"b"}
-"#,
-        );
-    }
-
-    #[test]
-    fn write_durations() {
-        let arr_durationsec = DurationSecondArray::from(vec![Some(120), None]);
-        let arr_durationmsec = DurationMillisecondArray::from(vec![Some(120), None]);
-        let arr_durationusec = DurationMicrosecondArray::from(vec![Some(120), None]);
-        let arr_durationnsec = DurationNanosecondArray::from(vec![Some(120), None]);
-        let arr_names = StringArray::from(vec![Some("a"), Some("b")]);
-
-        let schema = Schema::new(vec![
-            Field::new("duration_sec", arr_durationsec.data_type().clone(), true),
-            Field::new("duration_msec", arr_durationmsec.data_type().clone(), true),
-            Field::new("duration_usec", arr_durationusec.data_type().clone(), true),
-            Field::new("duration_nsec", arr_durationnsec.data_type().clone(), true),
-            Field::new("name", arr_names.data_type().clone(), true),
-        ]);
-        let schema = Arc::new(schema);
-
-        let batch = RecordBatch::try_new(
-            schema,
-            vec![
-                Arc::new(arr_durationsec),
-                Arc::new(arr_durationmsec),
-                Arc::new(arr_durationusec),
-                Arc::new(arr_durationnsec),
-                Arc::new(arr_names),
-            ],
-        )
-        .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"duration_sec":"PT120S","duration_msec":"PT0.120S","duration_usec":"PT0.000120S","duration_nsec":"PT0.000000120S","name":"a"}
-{"name":"b"}
-"#,
-        );
-    }
-
-    #[test]
-    fn write_nested_structs() {
-        let schema = Schema::new(vec![
-            Field::new(
-                "c1",
-                DataType::Struct(vec![
-                    Field::new("c11", DataType::Int32, false),
-                    Field::new(
-                        "c12",
-                        DataType::Struct(vec![Field::new("c121", DataType::Utf8, false)]),
-                        false,
-                    ),
-                ]),
-                false,
-            ),
-            Field::new("c2", DataType::Utf8, false),
-        ]);
-
-        let c1 = StructArray::from(vec![
-            (
-                Field::new("c11", DataType::Int32, false),
-                Arc::new(Int32Array::from(vec![Some(1), None, Some(5)])) as ArrayRef,
-            ),
-            (
-                Field::new(
-                    "c12",
-                    DataType::Struct(vec![Field::new("c121", DataType::Utf8, false)]),
-                    false,
-                ),
-                Arc::new(StructArray::from(vec![(
-                    Field::new("c121", DataType::Utf8, false),
-                    Arc::new(StringArray::from(vec![Some("e"), Some("f"), Some("g")]))
-                        as ArrayRef,
-                )])) as ArrayRef,
-            ),
-        ]);
-        let c2 = StringArray::from(vec![Some("a"), Some("b"), Some("c")]);
-
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)])
-                .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"c1":{"c11":1,"c12":{"c121":"e"}},"c2":"a"}
-{"c1":{"c12":{"c121":"f"}},"c2":"b"}
-{"c1":{"c11":5,"c12":{"c121":"g"}},"c2":"c"}
-"#,
-        );
-    }
-
-    #[test]
-    fn write_struct_with_list_field() {
-        let field_c1 = Field::new(
-            "c1",
-            DataType::List(Box::new(Field::new("c_list", DataType::Utf8, false))),
-            false,
-        );
-        let field_c2 = Field::new("c2", DataType::Int32, false);
-        let schema = Schema::new(vec![field_c1.clone(), field_c2]);
-
-        let a_values = StringArray::from(vec!["a", "a1", "b", "c", "d", "e"]);
-        // list column rows: ["a", "a1"], ["b"], ["c"], ["d"], ["e"]
-        let a_value_offsets = Buffer::from(&[0, 2, 3, 4, 5, 6].to_byte_slice());
-        let a_list_data = ArrayData::builder(field_c1.data_type().clone())
-            .len(5)
-            .add_buffer(a_value_offsets)
-            .add_child_data(a_values.into_data())
-            .null_bit_buffer(Some(Buffer::from(vec![0b00011111])))
-            .build()
-            .unwrap();
-        let a = ListArray::from(a_list_data);
-
-        let b = Int32Array::from(vec![1, 2, 3, 4, 5]);
-
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)])
-                .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"c1":["a","a1"],"c2":1}
-{"c1":["b"],"c2":2}
-{"c1":["c"],"c2":3}
-{"c1":["d"],"c2":4}
-{"c1":["e"],"c2":5}
-"#,
-        );
-    }
-
-    #[test]
-    fn write_nested_list() {
-        let list_inner_type = Field::new(
-            "a",
-            DataType::List(Box::new(Field::new("b", DataType::Int32, false))),
-            false,
-        );
-        let field_c1 = Field::new(
-            "c1",
-            DataType::List(Box::new(list_inner_type.clone())),
-            false,
-        );
-        let field_c2 = Field::new("c2", DataType::Utf8, true);
-        let schema = Schema::new(vec![field_c1.clone(), field_c2]);
-
-        // list column rows: [[1, 2], [3]], [], [[4, 5, 6]]
-        let a_values = Int32Array::from(vec![1, 2, 3, 4, 5, 6]);
-
-        let a_value_offsets = Buffer::from(&[0, 2, 3, 6].to_byte_slice());
-        // Construct a list array from the above two
-        let a_list_data = ArrayData::builder(list_inner_type.data_type().clone())
-            .len(3)
-            .add_buffer(a_value_offsets)
-            .null_bit_buffer(Some(Buffer::from(vec![0b00000111])))
-            .add_child_data(a_values.into_data())
-            .build()
-            .unwrap();
-
-        let c1_value_offsets = Buffer::from(&[0, 2, 2, 3].to_byte_slice());
-        let c1_list_data = ArrayData::builder(field_c1.data_type().clone())
-            .len(3)
-            .add_buffer(c1_value_offsets)
-            .add_child_data(a_list_data)
-            .build()
-            .unwrap();
-
-        let c1 = ListArray::from(c1_list_data);
-        let c2 = StringArray::from(vec![Some("foo"), Some("bar"), None]);
-
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)])
-                .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"c1":[[1,2],[3]],"c2":"foo"}
-{"c1":[],"c2":"bar"}
-{"c1":[[4,5,6]]}
-"#,
-        );
-    }
-
-    #[test]
-    fn write_list_of_struct() {
-        let field_c1 = Field::new(
-            "c1",
-            DataType::List(Box::new(Field::new(
-                "s",
-                DataType::Struct(vec![
-                    Field::new("c11", DataType::Int32, false),
-                    Field::new(
-                        "c12",
-                        DataType::Struct(vec![Field::new("c121", DataType::Utf8, false)]),
-                        false,
-                    ),
-                ]),
-                false,
-            ))),
-            true,
-        );
-        let field_c2 = Field::new("c2", DataType::Int32, false);
-        let schema = Schema::new(vec![field_c1.clone(), field_c2]);
-
-        let struct_values = StructArray::from(vec![
-            (
-                Field::new("c11", DataType::Int32, false),
-                Arc::new(Int32Array::from(vec![Some(1), None, Some(5)])) as ArrayRef,
-            ),
-            (
-                Field::new(
-                    "c12",
-                    DataType::Struct(vec![Field::new("c121", DataType::Utf8, false)]),
-                    false,
-                ),
-                Arc::new(StructArray::from(vec![(
-                    Field::new("c121", DataType::Utf8, false),
-                    Arc::new(StringArray::from(vec![Some("e"), Some("f"), Some("g")]))
-                        as ArrayRef,
-                )])) as ArrayRef,
-            ),
-        ]);
-
-        // list column rows (c1):
-        // [{"c11": 1, "c12": {"c121": "e"}}, {"c12": {"c121": "f"}}],
-        // null,
-        // [{"c11": 5, "c12": {"c121": "g"}}]
-        let c1_value_offsets = Buffer::from(&[0, 2, 2, 3].to_byte_slice());
-        let c1_list_data = ArrayData::builder(field_c1.data_type().clone())
-            .len(3)
-            .add_buffer(c1_value_offsets)
-            .add_child_data(struct_values.into_data())
-            .null_bit_buffer(Some(Buffer::from(vec![0b00000101])))
-            .build()
-            .unwrap();
-        let c1 = ListArray::from(c1_list_data);
-
-        let c2 = Int32Array::from(vec![1, 2, 3]);
-
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)])
-                .unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"c1":[{"c11":1,"c12":{"c121":"e"}},{"c12":{"c121":"f"}}],"c2":1}
-{"c2":2}
-{"c1":[{"c11":5,"c12":{"c121":"g"}}],"c2":3}
-"#,
-        );
-    }
-
-    fn test_write_for_file(test_file: &str) {
-        let builder = ReaderBuilder::new()
-            .infer_schema(None)
-            .with_batch_size(1024);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open(test_file).unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        let result = String::from_utf8(buf).unwrap();
-        let expected = read_to_string(test_file).unwrap();
-        for (r, e) in result.lines().zip(expected.lines()) {
-            let mut expected_json = serde_json::from_str::<Value>(e).unwrap();
-            // remove null value from object to make comparision consistent:
-            if let Value::Object(obj) = expected_json {
-                expected_json = Value::Object(
-                    obj.into_iter().filter(|(_, v)| *v != Value::Null).collect(),
-                );
-            }
-            assert_eq!(serde_json::from_str::<Value>(r).unwrap(), expected_json,);
-        }
-    }
-
-    #[test]
-    fn write_basic_rows() {
-        test_write_for_file("test/data/basic.json");
-    }
-
-    #[test]
-    fn write_arrays() {
-        test_write_for_file("test/data/arrays.json");
-    }
-
-    #[test]
-    fn write_basic_nulls() {
-        test_write_for_file("test/data/basic_nulls.json");
-    }
-
-    #[test]
-    fn json_writer_empty() {
-        let mut writer = ArrayWriter::new(vec![] as Vec<u8>);
-        writer.finish().unwrap();
-        assert_eq!(String::from_utf8(writer.into_inner()).unwrap(), "");
-    }
-    #[test]
-    fn json_writer_one_row() {
-        let mut writer = ArrayWriter::new(vec![] as Vec<u8>);
-        let v = json!({ "an": "object" });
-        writer.write_row(&v).unwrap();
-        writer.finish().unwrap();
-        assert_eq!(
-            String::from_utf8(writer.into_inner()).unwrap(),
-            r#"[{"an":"object"}]"#
-        );
-    }
-
-    #[test]
-    fn json_writer_two_rows() {
-        let mut writer = ArrayWriter::new(vec![] as Vec<u8>);
-        let v = json!({ "an": "object" });
-        writer.write_row(&v).unwrap();
-        let v = json!({ "another": "object" });
-        writer.write_row(&v).unwrap();
-        writer.finish().unwrap();
-        assert_eq!(
-            String::from_utf8(writer.into_inner()).unwrap(),
-            r#"[{"an":"object"},{"another":"object"}]"#
-        );
-    }
-
-    #[test]
-    fn json_list_roundtrip() {
-        let json_content = r#"
-        {"list": [{"ints": 1}]}
-        {"list": [{}]}
-        {"list": []}
-        {"list": null}
-        {"list": [{"ints": null}]}
-        {"list": [null]}
-        "#;
-        let ints_struct =
-            DataType::Struct(vec![Field::new("ints", DataType::Int32, true)]);
-        let list_type = DataType::List(Box::new(Field::new("item", ints_struct, true)));
-        let list_field = Field::new("list", list_type, true);
-        let schema = Arc::new(Schema::new(vec![list_field]));
-        let builder = ReaderBuilder::new().with_schema(schema).with_batch_size(64);
-        let mut reader = builder.build(std::io::Cursor::new(json_content)).unwrap();
-
-        let batch = reader.next().unwrap().unwrap();
-
-        let list_row = batch
-            .column(0)
-            .as_any()
-            .downcast_ref::<ListArray>()
-            .unwrap();
-        let values = list_row.values();
-        assert_eq!(values.len(), 4);
-        assert_eq!(values.null_count(), 1);
-
-        // write the batch to JSON, and compare output with input
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        // NOTE: The last value should technically be {"list": [null]} but it appears
-        // that implementations differ on the treatment of a null struct.
-        // It would be more accurate to return a null struct, so this can be done
-        // as a follow up.
-        assert_json_eq(
-            &buf,
-            r#"{"list":[{"ints":1}]}
-{"list":[{}]}
-{"list":[]}
-{}
-{"list":[{}]}
-{"list":[{}]}
-"#,
-        );
-    }
-
-    #[test]
-    fn json_writer_map() {
-        let keys_array =
-            super::StringArray::from(vec!["foo", "bar", "baz", "qux", "quux"]);
-        let values_array = super::Int64Array::from(vec![10, 20, 30, 40, 50]);
-
-        let keys = Field::new("keys", DataType::Utf8, false);
-        let values = Field::new("values", DataType::Int64, false);
-        let entry_struct = StructArray::from(vec![
-            (keys, Arc::new(keys_array) as ArrayRef),
-            (values, Arc::new(values_array) as ArrayRef),
-        ]);
-
-        let map_data_type = DataType::Map(
-            Box::new(Field::new(
-                "entries",
-                entry_struct.data_type().clone(),
-                true,
-            )),
-            false,
-        );
-
-        // [{"foo": 10}, null, {}, {"bar": 20, "baz": 30, "qux": 40}, {"quux": 50}, {}]
-        let entry_offsets = Buffer::from(&[0, 1, 1, 1, 4, 5, 5].to_byte_slice());
-        let valid_buffer = Buffer::from([0b00111101]);
-
-        let map_data = ArrayData::builder(map_data_type.clone())
-            .len(6)
-            .null_bit_buffer(Some(valid_buffer))
-            .add_buffer(entry_offsets)
-            .add_child_data(entry_struct.into_data())
-            .build()
-            .unwrap();
-
-        let map = MapArray::from(map_data);
-
-        let map_field = Field::new("map", map_data_type, true);
-        let schema = Arc::new(Schema::new(vec![map_field]));
-
-        let batch = RecordBatch::try_new(schema, vec![Arc::new(map)]).unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write_batches(&[batch]).unwrap();
-        }
-
-        assert_json_eq(
-            &buf,
-            r#"{"map":{"foo":10}}
-{"map":null}
-{"map":{}}
-{"map":{"bar":20,"baz":30,"qux":40}}
-{"map":{"quux":50}}
-{"map":{}}
-"#,
-        );
-    }
-
-    #[test]
-    fn test_write_single_batch() {
-        let test_file = "test/data/basic.json";
-        let builder = ReaderBuilder::new()
-            .infer_schema(None)
-            .with_batch_size(1024);
-        let mut reader: Reader<File> = builder
-            .build::<File>(File::open(test_file).unwrap())
-            .unwrap();
-        let batch = reader.next().unwrap().unwrap();
-
-        let mut buf = Vec::new();
-        {
-            let mut writer = LineDelimitedWriter::new(&mut buf);
-            writer.write(batch).unwrap();
-        }
-
-        let result = String::from_utf8(buf).unwrap();
-        let expected = read_to_string(test_file).unwrap();
-        for (r, e) in result.lines().zip(expected.lines()) {
-            let mut expected_json = serde_json::from_str::<Value>(e).unwrap();
-            // remove null value from object to make comparision consistent:
-            if let Value::Object(obj) = expected_json {
-                expected_json = Value::Object(
-                    obj.into_iter().filter(|(_, v)| *v != Value::Null).collect(),
-                );
-            }
-            assert_eq!(serde_json::from_str::<Value>(r).unwrap(), expected_json,);
-        }
-    }
-}
diff --git a/arrow/src/lib.rs b/arrow/src/lib.rs
index 04f495dc0819..78e2363e4825 100644
--- a/arrow/src/lib.rs
+++ b/arrow/src/lib.rs
@@ -23,8 +23,8 @@
 //!
 //! # Columnar Format
 //!
-//! The [`array`] module provides statically typed implementations of all the array
-//! types as defined by the [Arrow Columnar Format](https://arrow.apache.org/docs/format/Columnar.html).
+//! The [`array`] module provides statically typed implementations of all the array types as defined
+//! by the [Arrow Columnar Format](https://arrow.apache.org/docs/format/Columnar.html)
 //!
 //! For example, an [`Int32Array`](array::Int32Array) represents a nullable array of `i32`
 //!
@@ -37,11 +37,11 @@
 //!
 //! let collected: Vec<_> = array.iter().collect();
 //! assert_eq!(collected, vec![Some(1), None, Some(3)]);
-//! assert_eq!(array.values(), [1, 0, 3])
+//! assert_eq!(array.values(), &[1, 0, 3])
 //! ```
 //!
 //! It is also possible to write generic code. For example, the following is generic over
-//! all primitively typed arrays:
+//! all primitively typed arrays
 //!
 //! ```rust
 //! # use std::iter::Sum;
@@ -77,7 +77,7 @@
 //! assert_eq!(min(&StringArray::from(vec!["b", "a", "c"])), Some("a"));
 //! ```
 //!
-//! For more examples, consult the [`array`] docs.
+//! **For more examples, and details consult the [arrow_array] docs.**
 //!
 //! # Type Erasure / Trait Objects
 //!
@@ -103,6 +103,25 @@
 //! }
 //! ```
 //!
+//! To facilitate downcasting, the [`AsArray`](crate::array::AsArray) extension trait can be used
+//!
+//! ```rust
+//! # use arrow::array::{Array, Float32Array, AsArray};
+//! # use arrow::array::StringArray;
+//! # use arrow::datatypes::DataType;
+//! #
+//! fn impl_string(array: &StringArray) {}
+//! fn impl_f32(array: &Float32Array) {}
+//!
+//! fn impl_dyn(array: &dyn Array) {
+//!     match array.data_type() {
+//!         DataType::Utf8 => impl_string(array.as_string()),
+//!         DataType::Float32 => impl_f32(array.as_primitive()),
+//!         _ => unimplemented!()
+//!     }
+//! }
+//! ```
+//!
 //! It is also common to want to write a function that returns one of a number of possible
 //! array implementations. [`ArrayRef`] is a type-alias for [`Arc<dyn Array>`](array::Array)
 //! which is frequently used for this purpose
@@ -117,6 +136,7 @@
 //! fn parse_to_primitive<'a, T, I>(iter: I) -> PrimitiveArray<T>
 //! where
 //!     T: ArrowPrimitiveType,
+//!     T::Native: FromStr,
 //!     I: IntoIterator<Item=&'a str>,
 //! {
 //!     PrimitiveArray::from_iter(iter.into_iter().map(|val| T::Native::from_str(val).ok()))
@@ -135,12 +155,12 @@
 //!
 //! let array = parse_strings(["1", "2", "3"], DataType::Int32);
 //! let integers = array.as_any().downcast_ref::<Int32Array>().unwrap();
-//! assert_eq!(integers.values(), [1, 2, 3])
+//! assert_eq!(integers.values(), &[1, 2, 3])
 //! ```
 //!
 //! # Compute Kernels
 //!
-//! The [`compute`](compute) module provides optimised implementations of many common operations,
+//! The [`compute`] module provides optimised implementations of many common operations,
 //! for example the `parse_strings` operation above could also be implemented as follows:
 //!
 //! ```
@@ -153,25 +173,39 @@
 //! where
 //!     I: IntoIterator<Item=&'a str>,
 //! {
-//!     let array = Arc::new(StringArray::from_iter(iter.into_iter().map(Some))) as _;
+//!     let array = StringArray::from_iter(iter.into_iter().map(Some));
 //!     arrow::compute::cast(&array, to_data_type)
 //! }
 //!
 //! let array = parse_strings(["1", "2", "3"], &DataType::UInt32).unwrap();
 //! let integers = array.as_any().downcast_ref::<UInt32Array>().unwrap();
-//! assert_eq!(integers.values(), [1, 2, 3])
+//! assert_eq!(integers.values(), &[1, 2, 3])
 //! ```
 //!
 //! This module also implements many common vertical operations:
 //!
-//! * All mathematical binary operators, such as [`subtract`](compute::kernels::arithmetic::subtract)
+//! * All mathematical binary operators, such as [`sub`](compute::kernels::numeric::sub)
 //! * All boolean binary operators such as [`equality`](compute::kernels::comparison::eq)
 //! * [`cast`](compute::kernels::cast::cast)
 //! * [`filter`](compute::kernels::filter::filter)
-//! * [`take`](compute::kernels::take::take) and [`limit`](compute::kernels::limit::limit)
+//! * [`take`](compute::kernels::take::take)
 //! * [`sort`](compute::kernels::sort::sort)
 //! * some string operators such as [`substring`](compute::kernels::substring::substring) and [`length`](compute::kernels::length::length)
 //!
+//! ```
+//! # use arrow::compute::gt_scalar;
+//! # use arrow_array::cast::AsArray;
+//! # use arrow_array::Int32Array;
+//! # use arrow_array::types::Int32Type;
+//! # use arrow_select::filter::filter;
+//! let array = Int32Array::from_iter(0..100);
+//! let predicate = gt_scalar(&array, 60).unwrap();
+//! let filtered = filter(&array, &predicate).unwrap();
+//!
+//! let expected = Int32Array::from_iter(61..100);
+//! assert_eq!(&expected, filtered.as_primitive::<Int32Type>());
+//! ```
+//!
 //! As well as some horizontal operations, such as:
 //!
 //! * [`min`](compute::kernels::aggregate::min) and [`max`](compute::kernels::aggregate::max)
@@ -205,18 +239,81 @@
 //!
 //! Parquet is published as a [separate crate](https://crates.io/crates/parquet)
 //!
-//! # Memory and Buffers
+//! # Serde Compatibility
+//!
+//! [`arrow_json::reader::Decoder`] provides a mechanism to convert arbitrary, serde-compatible
+//! structures into [`RecordBatch`].
 //!
-//! Advanced users may wish to interact with the underlying buffers of an [`Array`], for example,
-//! for FFI or high-performance conversion from other formats. This interface is provided by
-//! [`ArrayData`] which stores the [`Buffer`] comprising an [`Array`], and can be accessed
-//! with [`Array::data`](array::Array::data)
+//! Whilst likely less performant than implementing a custom builder, as described in
+//! [arrow_array::builder], this provides a simple mechanism to get up and running quickly
 //!
-//! The APIs for constructing [`ArrayData`] come in safe, and unsafe variants, with the former
-//! performing extensive, but potentially expensive validation to ensure the buffers are well-formed.
+//! ```
+//! # use std::sync::Arc;
+//! # use arrow_json::ReaderBuilder;
+//! # use arrow_schema::{DataType, Field, Schema};
+//! # use serde::Serialize;
+//! # use arrow_array::cast::AsArray;
+//! # use arrow_array::types::{Float32Type, Int32Type};
+//! #
+//! #[derive(Serialize)]
+//! struct MyStruct {
+//!     int32: i32,
+//!     string: String,
+//! }
+//!
+//! let schema = Schema::new(vec![
+//!     Field::new("int32", DataType::Int32, false),
+//!     Field::new("string", DataType::Utf8, false),
+//! ]);
 //!
-//! An [`ArrayRef`] can be cheaply created from an [`ArrayData`] using [`make_array`],
-//! or by using the appropriate [`From`] conversion on the concrete [`Array`] implementation.
+//! let rows = vec![
+//!     MyStruct{ int32: 5, string: "bar".to_string() },
+//!     MyStruct{ int32: 8, string: "foo".to_string() },
+//! ];
+//!
+//! let mut decoder = ReaderBuilder::new(Arc::new(schema)).build_decoder().unwrap();
+//! decoder.serialize(&rows).unwrap();
+//!
+//! let batch = decoder.flush().unwrap().unwrap();
+//!
+//! // Expect batch containing two columns
+//! let int32 = batch.column(0).as_primitive::<Int32Type>();
+//! assert_eq!(int32.values(), &[5, 8]);
+//!
+//! let string = batch.column(1).as_string::<i32>();
+//! assert_eq!(string.value(0), "bar");
+//! assert_eq!(string.value(1), "foo");
+//! ```
+//!
+//! # Crate Topology
+//!
+//! The [`arrow`] project is implemented as multiple sub-crates, which are then re-exported by
+//! this top-level crate.
+//!
+//! Crate authors can choose to depend on this top-level crate, or just
+//! the sub-crates they need.
+//!
+//! The current list of sub-crates is:
+//!
+//! * [`arrow-arith`][arrow_arith] - arithmetic kernels
+//! * [`arrow-array`][arrow_array] - type-safe arrow array abstractions
+//! * [`arrow-buffer`][arrow_buffer] - buffer abstractions for arrow arrays
+//! * [`arrow-cast`][arrow_cast] - cast kernels for arrow arrays
+//! * [`arrow-csv`][arrow_csv] - read/write CSV to arrow format
+//! * [`arrow-data`][arrow_data] - the underlying data of arrow arrays
+//! * [`arrow-ipc`][arrow_ipc] - read/write IPC to arrow format
+//! * [`arrow-json`][arrow_json] - read/write JSON to arrow format
+//! * [`arrow-ord`][arrow_ord] - ordering kernels for arrow arrays
+//! * [`arrow-row`][arrow_row] - comparable row format
+//! * [`arrow-schema`][arrow_schema] - the logical types for arrow arrays
+//! * [`arrow-select`][arrow_select] - selection kernels for arrow arrays
+//! * [`arrow-string`][arrow_string] - string kernels for arrow arrays
+//!
+//! Some functionality is also distributed independently of this crate:
+//!
+//! * [`arrow-flight`] - support for [Arrow Flight RPC]
+//! * [`arrow-integration-test`] - support for [Arrow JSON Test Format]
+//! * [`parquet`](https://docs.rs/parquet/latest/parquet/) - support for [Apache Parquet]
 //!
 //! # Safety and Security
 //!
@@ -234,6 +331,7 @@
 //! orchestrates the primitives exported by this crate into an embeddable query engine, with
 //! SQL and DataFrame frontends, and heavily influences this crate's roadmap.
 //!
+//! [`arrow`]: https://github.com/apache/arrow-rs
 //! [`array`]: mod@array
 //! [`Array`]: array::Array
 //! [`ArrayRef`]: array::ArrayRef
@@ -241,21 +339,27 @@
 //! [`make_array`]: array::make_array
 //! [`Buffer`]: buffer::Buffer
 //! [`RecordBatch`]: record_batch::RecordBatch
+//! [`arrow-flight`]: https://docs.rs/arrow-flight/latest/arrow_flight/
+//! [`arrow-integration-test`]: https://docs.rs/arrow-integration-test/latest/arrow_integration_test/
+//! [`parquet`]: https://docs.rs/parquet/latest/parquet/
+//! [Arrow Flight RPC]: https://arrow.apache.org/docs/format/Flight.html
+//! [Arrow JSON Test Format]: https://github.com/apache/arrow/blob/master/docs/source/format/Integration.rst#json-test-data-format
+//! [Apache Parquet]: https://parquet.apache.org/
 //! [DataFusion]: https://github.com/apache/arrow-datafusion
 //! [issue tracker]: https://github.com/apache/arrow-rs/issues
 //!
 
 #![deny(clippy::redundant_clone)]
 #![warn(missing_debug_implementations)]
+#![allow(rustdoc::invalid_html_tags)]
+pub use arrow_array::{downcast_dictionary_array, downcast_primitive_array};
+
+pub use arrow_buffer::{alloc, buffer};
 
-pub mod alloc;
 pub mod array;
-pub mod bitmap;
-pub mod buffer;
-mod bytes;
 pub mod compute;
 #[cfg(feature = "csv")]
-pub mod csv;
+pub use arrow_csv as csv;
 pub mod datatypes;
 pub mod error;
 #[cfg(feature = "ffi")]
@@ -263,11 +367,18 @@ pub mod ffi;
 #[cfg(feature = "ffi")]
 pub mod ffi_stream;
 #[cfg(feature = "ipc")]
-pub mod ipc;
-pub mod json;
+pub use arrow_ipc as ipc;
+#[cfg(feature = "json")]
+pub use arrow_json as json;
 #[cfg(feature = "pyarrow")]
 pub mod pyarrow;
-pub mod record_batch;
-pub mod temporal_conversions;
+
+pub mod record_batch {
+    pub use arrow_array::{
+        RecordBatch, RecordBatchIterator, RecordBatchOptions, RecordBatchReader, RecordBatchWriter,
+    };
+}
+pub use arrow_array::temporal_conversions;
+pub use arrow_row as row;
 pub mod tensor;
 pub mod util;
diff --git a/arrow/src/pyarrow.rs b/arrow/src/pyarrow.rs
index 3ae5b3b9987f..39702ce01aea 100644
--- a/arrow/src/pyarrow.rs
+++ b/arrow/src/pyarrow.rs
@@ -15,106 +15,266 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! This library demonstrates a minimal usage of Rust's C data interface to pass
-//! arrays from and to Python.
+//! Pass Arrow objects from and to PyArrow, using Arrow's
+//! [C Data Interface](https://arrow.apache.org/docs/format/CDataInterface.html)
+//! and [pyo3](https://docs.rs/pyo3/latest/pyo3/).
+//! For underlying implementation, see the [ffi] module.
+//!
+//! One can use these to write Python functions that take and return PyArrow
+//! objects, with automatic conversion to corresponding arrow-rs types.
+//!
+//! ```ignore
+//! #[pyfunction]
+//! fn double_array(array: PyArrowType<ArrayData>) -> PyResult<PyArrowType<ArrayData>> {
+//!     let array = array.0; // Extract from PyArrowType wrapper
+//!     let array: Arc<dyn Array> = make_array(array); // Convert ArrayData to ArrayRef
+//!     let array: &Int32Array = array.as_any().downcast_ref()
+//!         .ok_or_else(|| PyValueError::new_err("expected int32 array"))?;
+//!     let array: Int32Array = array.iter().map(|x| x.map(|x| x * 2)).collect();
+//!     Ok(PyArrowType(array.into_data()))
+//! }
+//! ```
+//!
+//! | pyarrow type                | arrow-rs type                                                      |
+//! |-----------------------------|--------------------------------------------------------------------|
+//! | `pyarrow.DataType`          | [DataType]                                                         |
+//! | `pyarrow.Field`             | [Field]                                                            |
+//! | `pyarrow.Schema`            | [Schema]                                                           |
+//! | `pyarrow.Array`             | [ArrayData]                                                        |
+//! | `pyarrow.RecordBatch`       | [RecordBatch]                                                      |
+//! | `pyarrow.RecordBatchReader` | [ArrowArrayStreamReader] / `Box<dyn RecordBatchReader + Send>` (1) |
+//!
+//! (1) `pyarrow.RecordBatchReader` can be imported as [ArrowArrayStreamReader]. Either
+//! [ArrowArrayStreamReader] or `Box<dyn RecordBatchReader + Send>` can be exported
+//! as `pyarrow.RecordBatchReader`. (`Box<dyn RecordBatchReader + Send>` is typically
+//! easier to create.)
+//!
+//! PyArrow has the notion of chunked arrays and tables, but arrow-rs doesn't
+//! have these same concepts. A chunked table is instead represented with
+//! `Vec<RecordBatch>`. A `pyarrow.Table` can be imported to Rust by calling
+//! [pyarrow.Table.to_reader()](https://arrow.apache.org/docs/python/generated/pyarrow.Table.html#pyarrow.Table.to_reader)
+//! and then importing the reader as a [ArrowArrayStreamReader].
 
 use std::convert::{From, TryFrom};
+use std::ptr::{addr_of, addr_of_mut};
 use std::sync::Arc;
 
+use arrow_array::{RecordBatchIterator, RecordBatchReader, StructArray};
+use pyo3::exceptions::{PyTypeError, PyValueError};
 use pyo3::ffi::Py_uintptr_t;
 use pyo3::import_exception;
 use pyo3::prelude::*;
-use pyo3::types::{PyList, PyTuple};
+use pyo3::types::{PyCapsule, PyList, PyTuple};
 
-use crate::array::{Array, ArrayData, ArrayRef};
+use crate::array::{make_array, ArrayData};
 use crate::datatypes::{DataType, Field, Schema};
 use crate::error::ArrowError;
 use crate::ffi;
-use crate::ffi::FFI_ArrowSchema;
-use crate::ffi_stream::{
-    export_reader_into_raw, ArrowArrayStreamReader, FFI_ArrowArrayStream,
-};
+use crate::ffi::{FFI_ArrowArray, FFI_ArrowSchema};
+use crate::ffi_stream::{ArrowArrayStreamReader, FFI_ArrowArrayStream};
 use crate::record_batch::RecordBatch;
 
 import_exception!(pyarrow, ArrowException);
 pub type PyArrowException = ArrowException;
 
-impl From<ArrowError> for PyErr {
-    fn from(err: ArrowError) -> PyErr {
-        PyArrowException::new_err(err.to_string())
-    }
+fn to_py_err(err: ArrowError) -> PyErr {
+    PyArrowException::new_err(err.to_string())
 }
 
-pub trait PyArrowConvert: Sized {
+pub trait FromPyArrow: Sized {
     fn from_pyarrow(value: &PyAny) -> PyResult<Self>;
+}
+
+/// Create a new PyArrow object from a arrow-rs type.
+pub trait ToPyArrow {
     fn to_pyarrow(&self, py: Python) -> PyResult<PyObject>;
 }
 
-impl PyArrowConvert for DataType {
+/// Convert an arrow-rs type into a PyArrow object.
+pub trait IntoPyArrow {
+    fn into_pyarrow(self, py: Python) -> PyResult<PyObject>;
+}
+
+impl<T: ToPyArrow> IntoPyArrow for T {
+    fn into_pyarrow(self, py: Python) -> PyResult<PyObject> {
+        self.to_pyarrow(py)
+    }
+}
+
+fn validate_class(expected: &str, value: &PyAny) -> PyResult<()> {
+    let pyarrow = PyModule::import(value.py(), "pyarrow")?;
+    let class = pyarrow.getattr(expected)?;
+    if !value.is_instance(class)? {
+        let expected_module = class.getattr("__module__")?.extract::<&str>()?;
+        let expected_name = class.getattr("__name__")?.extract::<&str>()?;
+        let found_class = value.get_type();
+        let found_module = found_class.getattr("__module__")?.extract::<&str>()?;
+        let found_name = found_class.getattr("__name__")?.extract::<&str>()?;
+        return Err(PyTypeError::new_err(format!(
+            "Expected instance of {}.{}, got {}.{}",
+            expected_module, expected_name, found_module, found_name
+        )));
+    }
+    Ok(())
+}
+
+fn validate_pycapsule(capsule: &PyCapsule, name: &str) -> PyResult<()> {
+    let capsule_name = capsule.name()?;
+    if capsule_name.is_none() {
+        return Err(PyValueError::new_err(
+            "Expected schema PyCapsule to have name set.",
+        ));
+    }
+
+    let capsule_name = capsule_name.unwrap().to_str()?;
+    if capsule_name != name {
+        return Err(PyValueError::new_err(format!(
+            "Expected name '{}' in PyCapsule, instead got '{}'",
+            name, capsule_name
+        )));
+    }
+
+    Ok(())
+}
+
+impl FromPyArrow for DataType {
     fn from_pyarrow(value: &PyAny) -> PyResult<Self> {
+        // Newer versions of PyArrow as well as other libraries with Arrow data implement this
+        // method, so prefer it over _export_to_c.
+        // See https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html
+        if value.hasattr("__arrow_c_schema__")? {
+            let capsule: &PyCapsule =
+                PyTryInto::try_into(value.getattr("__arrow_c_schema__")?.call0()?)?;
+            validate_pycapsule(capsule, "arrow_schema")?;
+
+            let schema_ptr = unsafe { capsule.reference::<FFI_ArrowSchema>() };
+            let dtype = DataType::try_from(schema_ptr).map_err(to_py_err)?;
+            return Ok(dtype);
+        }
+
+        validate_class("DataType", value)?;
+
         let c_schema = FFI_ArrowSchema::empty();
         let c_schema_ptr = &c_schema as *const FFI_ArrowSchema;
         value.call_method1("_export_to_c", (c_schema_ptr as Py_uintptr_t,))?;
-        let dtype = DataType::try_from(&c_schema)?;
+        let dtype = DataType::try_from(&c_schema).map_err(to_py_err)?;
         Ok(dtype)
     }
+}
 
+impl ToPyArrow for DataType {
     fn to_pyarrow(&self, py: Python) -> PyResult<PyObject> {
-        let c_schema = FFI_ArrowSchema::try_from(self)?;
+        let c_schema = FFI_ArrowSchema::try_from(self).map_err(to_py_err)?;
         let c_schema_ptr = &c_schema as *const FFI_ArrowSchema;
         let module = py.import("pyarrow")?;
         let class = module.getattr("DataType")?;
-        let dtype =
-            class.call_method1("_import_from_c", (c_schema_ptr as Py_uintptr_t,))?;
+        let dtype = class.call_method1("_import_from_c", (c_schema_ptr as Py_uintptr_t,))?;
         Ok(dtype.into())
     }
 }
 
-impl PyArrowConvert for Field {
+impl FromPyArrow for Field {
     fn from_pyarrow(value: &PyAny) -> PyResult<Self> {
+        // Newer versions of PyArrow as well as other libraries with Arrow data implement this
+        // method, so prefer it over _export_to_c.
+        // See https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html
+        if value.hasattr("__arrow_c_schema__")? {
+            let capsule: &PyCapsule =
+                PyTryInto::try_into(value.getattr("__arrow_c_schema__")?.call0()?)?;
+            validate_pycapsule(capsule, "arrow_schema")?;
+
+            let schema_ptr = unsafe { capsule.reference::<FFI_ArrowSchema>() };
+            let field = Field::try_from(schema_ptr).map_err(to_py_err)?;
+            return Ok(field);
+        }
+
+        validate_class("Field", value)?;
+
         let c_schema = FFI_ArrowSchema::empty();
         let c_schema_ptr = &c_schema as *const FFI_ArrowSchema;
         value.call_method1("_export_to_c", (c_schema_ptr as Py_uintptr_t,))?;
-        let field = Field::try_from(&c_schema)?;
+        let field = Field::try_from(&c_schema).map_err(to_py_err)?;
         Ok(field)
     }
+}
 
+impl ToPyArrow for Field {
     fn to_pyarrow(&self, py: Python) -> PyResult<PyObject> {
-        let c_schema = FFI_ArrowSchema::try_from(self)?;
+        let c_schema = FFI_ArrowSchema::try_from(self).map_err(to_py_err)?;
         let c_schema_ptr = &c_schema as *const FFI_ArrowSchema;
         let module = py.import("pyarrow")?;
         let class = module.getattr("Field")?;
-        let dtype =
-            class.call_method1("_import_from_c", (c_schema_ptr as Py_uintptr_t,))?;
+        let dtype = class.call_method1("_import_from_c", (c_schema_ptr as Py_uintptr_t,))?;
         Ok(dtype.into())
     }
 }
 
-impl PyArrowConvert for Schema {
+impl FromPyArrow for Schema {
     fn from_pyarrow(value: &PyAny) -> PyResult<Self> {
+        // Newer versions of PyArrow as well as other libraries with Arrow data implement this
+        // method, so prefer it over _export_to_c.
+        // See https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html
+        if value.hasattr("__arrow_c_schema__")? {
+            let capsule: &PyCapsule =
+                PyTryInto::try_into(value.getattr("__arrow_c_schema__")?.call0()?)?;
+            validate_pycapsule(capsule, "arrow_schema")?;
+
+            let schema_ptr = unsafe { capsule.reference::<FFI_ArrowSchema>() };
+            let schema = Schema::try_from(schema_ptr).map_err(to_py_err)?;
+            return Ok(schema);
+        }
+
+        validate_class("Schema", value)?;
+
         let c_schema = FFI_ArrowSchema::empty();
         let c_schema_ptr = &c_schema as *const FFI_ArrowSchema;
         value.call_method1("_export_to_c", (c_schema_ptr as Py_uintptr_t,))?;
-        let schema = Schema::try_from(&c_schema)?;
+        let schema = Schema::try_from(&c_schema).map_err(to_py_err)?;
         Ok(schema)
     }
+}
 
+impl ToPyArrow for Schema {
     fn to_pyarrow(&self, py: Python) -> PyResult<PyObject> {
-        let c_schema = FFI_ArrowSchema::try_from(self)?;
+        let c_schema = FFI_ArrowSchema::try_from(self).map_err(to_py_err)?;
         let c_schema_ptr = &c_schema as *const FFI_ArrowSchema;
         let module = py.import("pyarrow")?;
         let class = module.getattr("Schema")?;
-        let schema =
-            class.call_method1("_import_from_c", (c_schema_ptr as Py_uintptr_t,))?;
+        let schema = class.call_method1("_import_from_c", (c_schema_ptr as Py_uintptr_t,))?;
         Ok(schema.into())
     }
 }
 
-impl PyArrowConvert for ArrayData {
+impl FromPyArrow for ArrayData {
     fn from_pyarrow(value: &PyAny) -> PyResult<Self> {
+        // Newer versions of PyArrow as well as other libraries with Arrow data implement this
+        // method, so prefer it over _export_to_c.
+        // See https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html
+        if value.hasattr("__arrow_c_array__")? {
+            let tuple = value.getattr("__arrow_c_array__")?.call0()?;
+
+            if !tuple.is_instance_of::<PyTuple>() {
+                return Err(PyTypeError::new_err(
+                    "Expected __arrow_c_array__ to return a tuple.",
+                ));
+            }
+
+            let schema_capsule: &PyCapsule = PyTryInto::try_into(tuple.get_item(0)?)?;
+            let array_capsule: &PyCapsule = PyTryInto::try_into(tuple.get_item(1)?)?;
+
+            validate_pycapsule(schema_capsule, "arrow_schema")?;
+            validate_pycapsule(array_capsule, "arrow_array")?;
+
+            let schema_ptr = unsafe { schema_capsule.reference::<FFI_ArrowSchema>() };
+            let array = unsafe { FFI_ArrowArray::from_raw(array_capsule.pointer() as _) };
+            return unsafe { ffi::from_ffi(array, schema_ptr) }.map_err(to_py_err);
+        }
+
+        validate_class("Array", value)?;
+
         // prepare a pointer to receive the Array struct
-        let (array_pointer, schema_pointer) =
-            ffi::ArrowArray::into_raw(unsafe { ffi::ArrowArray::empty() });
+        let mut array = FFI_ArrowArray::empty();
+        let mut schema = FFI_ArrowSchema::empty();
 
         // make the conversion through PyArrow's private API
         // this changes the pointer's memory and is thus unsafe.
@@ -122,50 +282,92 @@ impl PyArrowConvert for ArrayData {
         value.call_method1(
             "_export_to_c",
             (
-                array_pointer as Py_uintptr_t,
-                schema_pointer as Py_uintptr_t,
+                addr_of_mut!(array) as Py_uintptr_t,
+                addr_of_mut!(schema) as Py_uintptr_t,
             ),
         )?;
 
-        let ffi_array =
-            unsafe { ffi::ArrowArray::try_from_raw(array_pointer, schema_pointer)? };
-        let data = ArrayData::try_from(ffi_array)?;
-
-        Ok(data)
+        unsafe { ffi::from_ffi(array, &schema) }.map_err(to_py_err)
     }
+}
 
+impl ToPyArrow for ArrayData {
     fn to_pyarrow(&self, py: Python) -> PyResult<PyObject> {
-        let array = ffi::ArrowArray::try_from(self.clone())?;
-        let (array_pointer, schema_pointer) = ffi::ArrowArray::into_raw(array);
+        let array = FFI_ArrowArray::new(self);
+        let schema = FFI_ArrowSchema::try_from(self.data_type()).map_err(to_py_err)?;
 
         let module = py.import("pyarrow")?;
         let class = module.getattr("Array")?;
         let array = class.call_method1(
             "_import_from_c",
             (
-                array_pointer as Py_uintptr_t,
-                schema_pointer as Py_uintptr_t,
+                addr_of!(array) as Py_uintptr_t,
+                addr_of!(schema) as Py_uintptr_t,
             ),
         )?;
         Ok(array.to_object(py))
     }
 }
 
-impl<T> PyArrowConvert for T
-where
-    T: Array + From<ArrayData>,
-{
+impl<T: FromPyArrow> FromPyArrow for Vec<T> {
     fn from_pyarrow(value: &PyAny) -> PyResult<Self> {
-        Ok(ArrayData::from_pyarrow(value)?.into())
+        let list = value.downcast::<PyList>()?;
+        list.iter().map(|x| T::from_pyarrow(x)).collect()
     }
+}
 
+impl<T: ToPyArrow> ToPyArrow for Vec<T> {
     fn to_pyarrow(&self, py: Python) -> PyResult<PyObject> {
-        self.data().to_pyarrow(py)
+        let values = self
+            .iter()
+            .map(|v| v.to_pyarrow(py))
+            .collect::<PyResult<Vec<_>>>()?;
+        Ok(values.to_object(py))
     }
 }
 
-impl PyArrowConvert for RecordBatch {
+impl FromPyArrow for RecordBatch {
     fn from_pyarrow(value: &PyAny) -> PyResult<Self> {
+        // Newer versions of PyArrow as well as other libraries with Arrow data implement this
+        // method, so prefer it over _export_to_c.
+        // See https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html
+        if value.hasattr("__arrow_c_array__")? {
+            let tuple = value.getattr("__arrow_c_array__")?.call0()?;
+
+            if !tuple.is_instance_of::<PyTuple>() {
+                return Err(PyTypeError::new_err(
+                    "Expected __arrow_c_array__ to return a tuple.",
+                ));
+            }
+
+            let schema_capsule: &PyCapsule = PyTryInto::try_into(tuple.get_item(0)?)?;
+            let array_capsule: &PyCapsule = PyTryInto::try_into(tuple.get_item(1)?)?;
+
+            validate_pycapsule(schema_capsule, "arrow_schema")?;
+            validate_pycapsule(array_capsule, "arrow_array")?;
+
+            let schema_ptr = unsafe { schema_capsule.reference::<FFI_ArrowSchema>() };
+            let ffi_array = unsafe { FFI_ArrowArray::from_raw(array_capsule.pointer() as _) };
+            let array_data = unsafe { ffi::from_ffi(ffi_array, schema_ptr) }.map_err(to_py_err)?;
+            if !matches!(array_data.data_type(), DataType::Struct(_)) {
+                return Err(PyTypeError::new_err(
+                    "Expected Struct type from __arrow_c_array.",
+                ));
+            }
+            let array = StructArray::from(array_data);
+            // StructArray does not embed metadata from schema. We need to override
+            // the output schema with the schema from the capsule.
+            let schema = Arc::new(Schema::try_from(schema_ptr).map_err(to_py_err)?);
+            let (_fields, columns, nulls) = array.into_parts();
+            assert_eq!(
+                nulls.map(|n| n.null_count()).unwrap_or_default(),
+                0,
+                "Cannot convert nullable StructArray to RecordBatch, see StructArray documentation"
+            );
+            return RecordBatch::try_new(schema, columns).map_err(to_py_err);
+        }
+
+        validate_class("RecordBatch", value)?;
         // TODO(kszucs): implement the FFI conversions in arrow-rs for RecordBatches
         let schema = value.getattr("schema")?;
         let schema = Arc::new(Schema::from_pyarrow(schema)?);
@@ -173,89 +375,110 @@ impl PyArrowConvert for RecordBatch {
         let arrays = value.getattr("columns")?.downcast::<PyList>()?;
         let arrays = arrays
             .iter()
-            .map(ArrayRef::from_pyarrow)
+            .map(|a| Ok(make_array(ArrayData::from_pyarrow(a)?)))
             .collect::<PyResult<_>>()?;
 
-        let batch = RecordBatch::try_new(schema, arrays)?;
+        let batch = RecordBatch::try_new(schema, arrays).map_err(to_py_err)?;
         Ok(batch)
     }
+}
 
+impl ToPyArrow for RecordBatch {
     fn to_pyarrow(&self, py: Python) -> PyResult<PyObject> {
-        let mut py_arrays = vec![];
-        let mut py_names = vec![];
+        // Workaround apache/arrow#37669 by returning RecordBatchIterator
+        let reader = RecordBatchIterator::new(vec![Ok(self.clone())], self.schema());
+        let reader: Box<dyn RecordBatchReader + Send> = Box::new(reader);
+        let py_reader = reader.into_pyarrow(py)?;
+        py_reader.call_method0(py, "read_next_batch")
+    }
+}
 
-        let schema = self.schema();
-        let fields = schema.fields().iter();
-        let columns = self.columns().iter();
+/// Supports conversion from `pyarrow.RecordBatchReader` to [ArrowArrayStreamReader].
+impl FromPyArrow for ArrowArrayStreamReader {
+    fn from_pyarrow(value: &PyAny) -> PyResult<Self> {
+        // Newer versions of PyArrow as well as other libraries with Arrow data implement this
+        // method, so prefer it over _export_to_c.
+        // See https://arrow.apache.org/docs/format/CDataInterface/PyCapsuleInterface.html
+        if value.hasattr("__arrow_c_stream__")? {
+            let capsule: &PyCapsule =
+                PyTryInto::try_into(value.getattr("__arrow_c_stream__")?.call0()?)?;
+            validate_pycapsule(capsule, "arrow_array_stream")?;
 
-        for (array, field) in columns.zip(fields) {
-            py_arrays.push(array.to_pyarrow(py)?);
-            py_names.push(field.name());
-        }
+            let stream = unsafe { FFI_ArrowArrayStream::from_raw(capsule.pointer() as _) };
 
-        let module = py.import("pyarrow")?;
-        let class = module.getattr("RecordBatch")?;
-        let record = class.call_method1("from_arrays", (py_arrays, py_names))?;
+            let stream_reader = ArrowArrayStreamReader::try_new(stream)
+                .map_err(|err| PyValueError::new_err(err.to_string()))?;
 
-        Ok(PyObject::from(record))
-    }
-}
+            return Ok(stream_reader);
+        }
+
+        validate_class("RecordBatchReader", value)?;
 
-impl PyArrowConvert for ArrowArrayStreamReader {
-    fn from_pyarrow(value: &PyAny) -> PyResult<Self> {
         // prepare a pointer to receive the stream struct
-        let stream = Box::new(FFI_ArrowArrayStream::empty());
-        let stream_ptr = Box::into_raw(stream) as *mut FFI_ArrowArrayStream;
+        let mut stream = FFI_ArrowArrayStream::empty();
+        let stream_ptr = &mut stream as *mut FFI_ArrowArrayStream;
 
         // make the conversion through PyArrow's private API
         // this changes the pointer's memory and is thus unsafe.
         // In particular, `_export_to_c` can go out of bounds
-        let args = PyTuple::new(value.py(), &[stream_ptr as Py_uintptr_t]);
+        let args = PyTuple::new(value.py(), [stream_ptr as Py_uintptr_t]);
         value.call_method1("_export_to_c", args)?;
 
-        let stream_reader =
-            unsafe { ArrowArrayStreamReader::from_raw(stream_ptr).unwrap() };
-
-        unsafe {
-            Box::from_raw(stream_ptr);
-        }
+        let stream_reader = ArrowArrayStreamReader::try_new(stream)
+            .map_err(|err| PyValueError::new_err(err.to_string()))?;
 
         Ok(stream_reader)
     }
+}
 
-    fn to_pyarrow(&self, py: Python) -> PyResult<PyObject> {
-        let stream = Box::new(FFI_ArrowArrayStream::empty());
-        let stream_ptr = Box::into_raw(stream) as *mut FFI_ArrowArrayStream;
-
-        unsafe { export_reader_into_raw(Box::new(self.clone()), stream_ptr) };
+/// Convert a [`RecordBatchReader`] into a `pyarrow.RecordBatchReader`.
+impl IntoPyArrow for Box<dyn RecordBatchReader + Send> {
+    // We can't implement `ToPyArrow` for `T: RecordBatchReader + Send` because
+    // there is already a blanket implementation for `T: ToPyArrow`.
+    fn into_pyarrow(self, py: Python) -> PyResult<PyObject> {
+        let mut stream = FFI_ArrowArrayStream::new(self);
 
+        let stream_ptr = (&mut stream) as *mut FFI_ArrowArrayStream;
         let module = py.import("pyarrow")?;
         let class = module.getattr("RecordBatchReader")?;
-        let args = PyTuple::new(py, &[stream_ptr as Py_uintptr_t]);
+        let args = PyTuple::new(py, [stream_ptr as Py_uintptr_t]);
         let reader = class.call_method1("_import_from_c", args)?;
+
         Ok(PyObject::from(reader))
     }
 }
 
-macro_rules! add_conversion {
-    ($typ:ty) => {
-        impl<'source> FromPyObject<'source> for $typ {
-            fn extract(value: &'source PyAny) -> PyResult<Self> {
-                Self::from_pyarrow(value)
-            }
-        }
+/// Convert a [`ArrowArrayStreamReader`] into a `pyarrow.RecordBatchReader`.
+impl IntoPyArrow for ArrowArrayStreamReader {
+    fn into_pyarrow(self, py: Python) -> PyResult<PyObject> {
+        let boxed: Box<dyn RecordBatchReader + Send> = Box::new(self);
+        boxed.into_pyarrow(py)
+    }
+}
 
-        impl<'a> IntoPy<PyObject> for $typ {
-            fn into_py(self, py: Python) -> PyObject {
-                self.to_pyarrow(py).unwrap()
-            }
+/// A newtype wrapper. When wrapped around a type `T: FromPyArrow`, it
+/// implements `FromPyObject` for the PyArrow objects. When wrapped around a
+/// `T: IntoPyArrow`, it implements `IntoPy<PyObject>` for the wrapped type.
+#[derive(Debug)]
+pub struct PyArrowType<T>(pub T);
+
+impl<'source, T: FromPyArrow> FromPyObject<'source> for PyArrowType<T> {
+    fn extract(value: &'source PyAny) -> PyResult<Self> {
+        Ok(Self(T::from_pyarrow(value)?))
+    }
+}
+
+impl<T: IntoPyArrow> IntoPy<PyObject> for PyArrowType<T> {
+    fn into_py(self, py: Python) -> PyObject {
+        match self.0.into_pyarrow(py) {
+            Ok(obj) => obj,
+            Err(err) => err.to_object(py),
         }
-    };
+    }
 }
 
-add_conversion!(DataType);
-add_conversion!(Field);
-add_conversion!(Schema);
-add_conversion!(ArrayData);
-add_conversion!(RecordBatch);
-add_conversion!(ArrowArrayStreamReader);
+impl<T> From<T> for PyArrowType<T> {
+    fn from(s: T) -> Self {
+        Self(s)
+    }
+}
diff --git a/arrow/src/temporal_conversions.rs b/arrow/src/temporal_conversions.rs
deleted file mode 100644
index 12982b7dabc2..000000000000
--- a/arrow/src/temporal_conversions.rs
+++ /dev/null
@@ -1,261 +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.
-
-//! Conversion methods for dates and times.
-
-use chrono::{Duration, NaiveDateTime, NaiveTime};
-
-/// Number of seconds in a day
-pub(crate) const SECONDS_IN_DAY: i64 = 86_400;
-/// Number of milliseconds in a second
-pub(crate) const MILLISECONDS: i64 = 1_000;
-/// Number of microseconds in a second
-pub(crate) const MICROSECONDS: i64 = 1_000_000;
-/// Number of nanoseconds in a second
-pub(crate) const NANOSECONDS: i64 = 1_000_000_000;
-
-/// Number of milliseconds in a day
-pub(crate) const MILLISECONDS_IN_DAY: i64 = SECONDS_IN_DAY * MILLISECONDS;
-/// Number of days between 0001-01-01 and 1970-01-01
-pub(crate) const EPOCH_DAYS_FROM_CE: i32 = 719_163;
-
-/// converts a `i32` representing a `date32` to [`NaiveDateTime`]
-#[inline]
-pub fn date32_to_datetime(v: i32) -> NaiveDateTime {
-    NaiveDateTime::from_timestamp(v as i64 * SECONDS_IN_DAY, 0)
-}
-
-/// converts a `i64` representing a `date64` to [`NaiveDateTime`]
-#[inline]
-pub fn date64_to_datetime(v: i64) -> NaiveDateTime {
-    let (sec, milli_sec) = split_second(v, MILLISECONDS);
-
-    NaiveDateTime::from_timestamp(
-        // extract seconds from milliseconds
-        sec,
-        // discard extracted seconds and convert milliseconds to nanoseconds
-        milli_sec * MICROSECONDS as u32,
-    )
-}
-
-/// converts a `i32` representing a `time32(s)` to [`NaiveDateTime`]
-#[inline]
-pub fn time32s_to_time(v: i32) -> NaiveTime {
-    NaiveTime::from_num_seconds_from_midnight(v as u32, 0)
-}
-
-/// converts a `i32` representing a `time32(ms)` to [`NaiveDateTime`]
-#[inline]
-pub fn time32ms_to_time(v: i32) -> NaiveTime {
-    let v = v as i64;
-    NaiveTime::from_num_seconds_from_midnight(
-        // extract seconds from milliseconds
-        (v / MILLISECONDS) as u32,
-        // discard extracted seconds and convert milliseconds to
-        // nanoseconds
-        (v % MILLISECONDS * MICROSECONDS) as u32,
-    )
-}
-
-/// converts a `i64` representing a `time64(us)` to [`NaiveDateTime`]
-#[inline]
-pub fn time64us_to_time(v: i64) -> NaiveTime {
-    NaiveTime::from_num_seconds_from_midnight(
-        // extract seconds from microseconds
-        (v / MICROSECONDS) as u32,
-        // discard extracted seconds and convert microseconds to
-        // nanoseconds
-        (v % MICROSECONDS * MILLISECONDS) as u32,
-    )
-}
-
-/// converts a `i64` representing a `time64(ns)` to [`NaiveDateTime`]
-#[inline]
-pub fn time64ns_to_time(v: i64) -> NaiveTime {
-    NaiveTime::from_num_seconds_from_midnight(
-        // extract seconds from nanoseconds
-        (v / NANOSECONDS) as u32,
-        // discard extracted seconds
-        (v % NANOSECONDS) as u32,
-    )
-}
-
-/// converts a `i64` representing a `timestamp(s)` to [`NaiveDateTime`]
-#[inline]
-pub fn timestamp_s_to_datetime(v: i64) -> NaiveDateTime {
-    NaiveDateTime::from_timestamp(v, 0)
-}
-
-/// converts a `i64` representing a `timestamp(ms)` to [`NaiveDateTime`]
-#[inline]
-pub fn timestamp_ms_to_datetime(v: i64) -> NaiveDateTime {
-    let (sec, milli_sec) = split_second(v, MILLISECONDS);
-
-    NaiveDateTime::from_timestamp(
-        // extract seconds from milliseconds
-        sec,
-        // discard extracted seconds and convert milliseconds to nanoseconds
-        milli_sec * MICROSECONDS as u32,
-    )
-}
-
-/// converts a `i64` representing a `timestamp(us)` to [`NaiveDateTime`]
-#[inline]
-pub fn timestamp_us_to_datetime(v: i64) -> NaiveDateTime {
-    let (sec, micro_sec) = split_second(v, MICROSECONDS);
-
-    NaiveDateTime::from_timestamp(
-        // extract seconds from microseconds
-        sec,
-        // discard extracted seconds and convert microseconds to nanoseconds
-        micro_sec * MILLISECONDS as u32,
-    )
-}
-
-/// converts a `i64` representing a `timestamp(ns)` to [`NaiveDateTime`]
-#[inline]
-pub fn timestamp_ns_to_datetime(v: i64) -> NaiveDateTime {
-    let (sec, nano_sec) = split_second(v, NANOSECONDS);
-
-    NaiveDateTime::from_timestamp(
-        // extract seconds from nanoseconds
-        sec, // discard extracted seconds
-        nano_sec,
-    )
-}
-
-///
-#[inline]
-pub(crate) fn split_second(v: i64, base: i64) -> (i64, u32) {
-    if v < 0 {
-        let v = -v;
-        let mut seconds = v / base;
-        let mut part = v % base;
-
-        if part > 0 {
-            seconds += 1;
-            part = base - part;
-        }
-        (-seconds, part as u32)
-    } else {
-        (v / base, (v % base) as u32)
-    }
-}
-
-/// converts a `i64` representing a `duration(s)` to [`Duration`]
-#[inline]
-pub fn duration_s_to_duration(v: i64) -> Duration {
-    Duration::seconds(v)
-}
-
-/// converts a `i64` representing a `duration(ms)` to [`Duration`]
-#[inline]
-pub fn duration_ms_to_duration(v: i64) -> Duration {
-    Duration::milliseconds(v)
-}
-
-/// converts a `i64` representing a `duration(us)` to [`Duration`]
-#[inline]
-pub fn duration_us_to_duration(v: i64) -> Duration {
-    Duration::microseconds(v)
-}
-
-/// converts a `i64` representing a `duration(ns)` to [`Duration`]
-#[inline]
-pub fn duration_ns_to_duration(v: i64) -> Duration {
-    Duration::nanoseconds(v)
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::temporal_conversions::{
-        date64_to_datetime, split_second, timestamp_ms_to_datetime,
-        timestamp_ns_to_datetime, timestamp_us_to_datetime, NANOSECONDS,
-    };
-    use chrono::NaiveDateTime;
-
-    #[test]
-    fn negative_input_timestamp_ns_to_datetime() {
-        assert_eq!(
-            timestamp_ns_to_datetime(-1),
-            NaiveDateTime::from_timestamp(-1, 999_999_999)
-        );
-
-        assert_eq!(
-            timestamp_ns_to_datetime(-1_000_000_001),
-            NaiveDateTime::from_timestamp(-2, 999_999_999)
-        );
-    }
-
-    #[test]
-    fn negative_input_timestamp_us_to_datetime() {
-        assert_eq!(
-            timestamp_us_to_datetime(-1),
-            NaiveDateTime::from_timestamp(-1, 999_999_000)
-        );
-
-        assert_eq!(
-            timestamp_us_to_datetime(-1_000_001),
-            NaiveDateTime::from_timestamp(-2, 999_999_000)
-        );
-    }
-
-    #[test]
-    fn negative_input_timestamp_ms_to_datetime() {
-        assert_eq!(
-            timestamp_ms_to_datetime(-1),
-            NaiveDateTime::from_timestamp(-1, 999_000_000)
-        );
-
-        assert_eq!(
-            timestamp_ms_to_datetime(-1_001),
-            NaiveDateTime::from_timestamp(-2, 999_000_000)
-        );
-    }
-
-    #[test]
-    fn negative_input_date64_to_datetime() {
-        assert_eq!(
-            date64_to_datetime(-1),
-            NaiveDateTime::from_timestamp(-1, 999_000_000)
-        );
-
-        assert_eq!(
-            date64_to_datetime(-1_001),
-            NaiveDateTime::from_timestamp(-2, 999_000_000)
-        );
-    }
-
-    #[test]
-    fn test_split_seconds() {
-        let (sec, nano_sec) = split_second(100, NANOSECONDS);
-        assert_eq!(sec, 0);
-        assert_eq!(nano_sec, 100);
-
-        let (sec, nano_sec) = split_second(123_000_000_456, NANOSECONDS);
-        assert_eq!(sec, 123);
-        assert_eq!(nano_sec, 456);
-
-        let (sec, nano_sec) = split_second(-1, NANOSECONDS);
-        assert_eq!(sec, -1);
-        assert_eq!(nano_sec, 999_999_999);
-
-        let (sec, nano_sec) = split_second(-123_000_000_001, NANOSECONDS);
-        assert_eq!(sec, -124);
-        assert_eq!(nano_sec, 999_999_999);
-    }
-}
diff --git a/arrow/src/tensor.rs b/arrow/src/tensor.rs
index b8d07f83fb90..c2a262b399de 100644
--- a/arrow/src/tensor.rs
+++ b/arrow/src/tensor.rs
@@ -27,9 +27,7 @@ use crate::datatypes::*;
 use crate::error::{ArrowError, Result};
 
 /// Computes the strides required assuming a row major memory layout
-fn compute_row_major_strides<T: ArrowPrimitiveType>(
-    shape: &[usize],
-) -> Result<Vec<usize>> {
+fn compute_row_major_strides<T: ArrowPrimitiveType>(shape: &[usize]) -> Result<Vec<usize>> {
     let mut remaining_bytes = mem::size_of::<T::Native>();
 
     for i in shape {
@@ -52,9 +50,7 @@ fn compute_row_major_strides<T: ArrowPrimitiveType>(
 }
 
 /// Computes the strides required assuming a column major memory layout
-fn compute_column_major_strides<T: ArrowPrimitiveType>(
-    shape: &[usize],
-) -> Result<Vec<usize>> {
+fn compute_column_major_strides<T: ArrowPrimitiveType>(shape: &[usize]) -> Result<Vec<usize>> {
     let mut remaining_bytes = mem::size_of::<T::Native>();
     let mut strides = Vec::<usize>::new();
 
@@ -85,16 +81,36 @@ pub struct Tensor<'a, T: ArrowPrimitiveType> {
 }
 
 pub type BooleanTensor<'a> = Tensor<'a, BooleanType>;
+pub type Date32Tensor<'a> = Tensor<'a, Date32Type>;
+pub type Date64Tensor<'a> = Tensor<'a, Date64Type>;
+pub type Decimal128Tensor<'a> = Tensor<'a, Decimal128Type>;
+pub type Decimal256Tensor<'a> = Tensor<'a, Decimal256Type>;
+pub type DurationMicrosecondTensor<'a> = Tensor<'a, DurationMicrosecondType>;
+pub type DurationMillisecondTensor<'a> = Tensor<'a, DurationMillisecondType>;
+pub type DurationNanosecondTensor<'a> = Tensor<'a, DurationNanosecondType>;
+pub type DurationSecondTensor<'a> = Tensor<'a, DurationSecondType>;
+pub type Float16Tensor<'a> = Tensor<'a, Float16Type>;
+pub type Float32Tensor<'a> = Tensor<'a, Float32Type>;
+pub type Float64Tensor<'a> = Tensor<'a, Float64Type>;
 pub type Int8Tensor<'a> = Tensor<'a, Int8Type>;
 pub type Int16Tensor<'a> = Tensor<'a, Int16Type>;
 pub type Int32Tensor<'a> = Tensor<'a, Int32Type>;
 pub type Int64Tensor<'a> = Tensor<'a, Int64Type>;
+pub type IntervalDayTimeTensor<'a> = Tensor<'a, IntervalDayTimeType>;
+pub type IntervalMonthDayNanoTensor<'a> = Tensor<'a, IntervalMonthDayNanoType>;
+pub type IntervalYearMonthTensor<'a> = Tensor<'a, IntervalYearMonthType>;
+pub type Time32MillisecondTensor<'a> = Tensor<'a, Time32MillisecondType>;
+pub type Time32SecondTensor<'a> = Tensor<'a, Time32SecondType>;
+pub type Time64MicrosecondTensor<'a> = Tensor<'a, Time64MicrosecondType>;
+pub type Time64NanosecondTensor<'a> = Tensor<'a, Time64NanosecondType>;
+pub type TimestampMicrosecondTensor<'a> = Tensor<'a, TimestampMicrosecondType>;
+pub type TimestampMillisecondTensor<'a> = Tensor<'a, TimestampMillisecondType>;
+pub type TimestampNanosecondTensor<'a> = Tensor<'a, TimestampNanosecondType>;
+pub type TimestampSecondTensor<'a> = Tensor<'a, TimestampSecondType>;
 pub type UInt8Tensor<'a> = Tensor<'a, UInt8Type>;
 pub type UInt16Tensor<'a> = Tensor<'a, UInt16Type>;
 pub type UInt32Tensor<'a> = Tensor<'a, UInt32Type>;
 pub type UInt64Tensor<'a> = Tensor<'a, UInt64Type>;
-pub type Float32Tensor<'a> = Tensor<'a, Float32Type>;
-pub type Float64Tensor<'a> = Tensor<'a, Float64Type>;
 
 impl<'a, T: ArrowPrimitiveType> Tensor<'a, T> {
     /// Creates a new `Tensor`
@@ -108,18 +124,17 @@ impl<'a, T: ArrowPrimitiveType> Tensor<'a, T> {
             None => {
                 if buffer.len() != mem::size_of::<T::Native>() {
                     return Err(ArrowError::InvalidArgumentError(
-                        "underlying buffer should only contain a single tensor element"
-                            .to_string(),
+                        "underlying buffer should only contain a single tensor element".to_string(),
                     ));
                 }
 
-                if strides != None {
+                if strides.is_some() {
                     return Err(ArrowError::InvalidArgumentError(
                         "expected None strides for tensor with no shape".to_string(),
                     ));
                 }
 
-                if names != None {
+                if names.is_some() {
                     return Err(ArrowError::InvalidArgumentError(
                         "expected None names for tensor with no shape".to_string(),
                     ));
@@ -138,8 +153,7 @@ impl<'a, T: ArrowPrimitiveType> Tensor<'a, T> {
                 if let Some(ref n) = names {
                     if n.len() != s.len() {
                         return Err(ArrowError::InvalidArgumentError(
-                            "number of dimensions and number of dimension names differ"
-                                .to_string(),
+                            "number of dimensions and number of dimension names differ".to_string(),
                         ));
                     }
                 }
@@ -147,8 +161,7 @@ impl<'a, T: ArrowPrimitiveType> Tensor<'a, T> {
                 let total_elements: usize = s.iter().product();
                 if total_elements != (buffer.len() / mem::size_of::<T::Native>()) {
                     return Err(ArrowError::InvalidArgumentError(
-                        "number of elements in buffer does not match dimensions"
-                            .to_string(),
+                        "number of elements in buffer does not match dimensions".to_string(),
                     ));
                 }
             }
@@ -165,8 +178,7 @@ impl<'a, T: ArrowPrimitiveType> Tensor<'a, T> {
                         Some(st)
                     } else {
                         return Err(ArrowError::InvalidArgumentError(
-                            "the input stride does not match the selected shape"
-                                .to_string(),
+                            "the input stride does not match the selected shape".to_string(),
                         ));
                     }
                 } else {
@@ -286,9 +298,7 @@ impl<'a, T: ArrowPrimitiveType> Tensor<'a, T> {
     pub fn is_column_major(&self) -> Result<bool> {
         match self.shape {
             None => Ok(false),
-            Some(ref s) => {
-                Ok(Some(compute_column_major_strides::<T>(s)?) == self.strides)
-            }
+            Some(ref s) => Ok(Some(compute_column_major_strides::<T>(s)?) == self.strides),
         }
     }
 }
@@ -414,8 +424,7 @@ mod tests {
         }
         let buf = builder.finish();
         let names = vec!["Dim 1", "Dim 2"];
-        let tensor =
-            Int64Tensor::new_column_major(buf, Some(vec![2, 4]), Some(names)).unwrap();
+        let tensor = Int64Tensor::new_column_major(buf, Some(vec![2, 4]), Some(names)).unwrap();
         assert_eq!(8, tensor.size());
         assert_eq!(Some(vec![2_usize, 4]).as_ref(), tensor.shape());
         assert_eq!(Some(vec![8_usize, 16]).as_ref(), tensor.strides());
@@ -435,8 +444,7 @@ mod tests {
         }
         let buf = builder.finish();
 
-        let result =
-            Int32Tensor::try_new(buf, Some(vec![2, 8]), Some(vec![2, 8, 1]), None);
+        let result = Int32Tensor::try_new(buf, Some(vec![2, 8]), Some(vec![2, 8, 1]), None);
 
         if result.is_ok() {
             panic!("shape and stride dimensions are different")
diff --git a/arrow/src/util/bench_util.rs b/arrow/src/util/bench_util.rs
index 395f3702d57a..b3fb2d293a72 100644
--- a/arrow/src/util/bench_util.rs
+++ b/arrow/src/util/bench_util.rs
@@ -20,12 +20,16 @@
 use crate::array::*;
 use crate::datatypes::*;
 use crate::util::test_util::seedable_rng;
+use arrow_buffer::Buffer;
+use rand::distributions::uniform::SampleUniform;
+use rand::thread_rng;
 use rand::Rng;
 use rand::SeedableRng;
 use rand::{
     distributions::{Alphanumeric, Distribution, Standard},
     prelude::StdRng,
 };
+use std::ops::Range;
 
 /// Creates an random (but fixed-seeded) array of a given size and null density
 pub fn create_primitive_array<T>(size: usize, null_density: f32) -> PrimitiveArray<T>
@@ -69,11 +73,7 @@ where
 }
 
 /// Creates an random (but fixed-seeded) array of a given size and null density
-pub fn create_boolean_array(
-    size: usize,
-    null_density: f32,
-    true_density: f32,
-) -> BooleanArray
+pub fn create_boolean_array(size: usize, null_density: f32, true_density: f32) -> BooleanArray
 where
     Standard: Distribution<bool>,
 {
@@ -124,6 +124,7 @@ pub fn create_string_array_with_len<Offset: OffsetSizeTrait>(
 pub fn create_string_dict_array<K: ArrowDictionaryKeyType>(
     size: usize,
     null_density: f32,
+    str_len: usize,
 ) -> DictionaryArray<K> {
     let rng = &mut seedable_rng();
 
@@ -132,7 +133,7 @@ pub fn create_string_dict_array<K: ArrowDictionaryKeyType>(
             if rng.gen::<f32>() < null_density {
                 None
             } else {
-                let value = rng.sample_iter(&Alphanumeric).take(4).collect();
+                let value = rng.sample_iter(&Alphanumeric).take(str_len).collect();
                 let value = String::from_utf8(value).unwrap();
                 Some(value)
             }
@@ -142,6 +143,73 @@ pub fn create_string_dict_array<K: ArrowDictionaryKeyType>(
     data.iter().map(|x| x.as_deref()).collect()
 }
 
+/// Create primitive run array for given logical and physical array lengths
+pub fn create_primitive_run_array<R: RunEndIndexType, V: ArrowPrimitiveType>(
+    logical_array_len: usize,
+    physical_array_len: usize,
+) -> RunArray<R> {
+    assert!(logical_array_len >= physical_array_len);
+    // typical length of each run
+    let run_len = logical_array_len / physical_array_len;
+
+    // Some runs should have extra length
+    let mut run_len_extra = logical_array_len % physical_array_len;
+
+    let mut values: Vec<V::Native> = (0..physical_array_len)
+        .flat_map(|s| {
+            let mut take_len = run_len;
+            if run_len_extra > 0 {
+                take_len += 1;
+                run_len_extra -= 1;
+            }
+            std::iter::repeat(V::Native::from_usize(s).unwrap()).take(take_len)
+        })
+        .collect();
+    while values.len() < logical_array_len {
+        let last_val = values[values.len() - 1];
+        values.push(last_val);
+    }
+    let mut builder = PrimitiveRunBuilder::<R, V>::with_capacity(physical_array_len);
+    builder.extend(values.into_iter().map(Some));
+
+    builder.finish()
+}
+
+/// Create string array to be used by run array builder. The string array
+/// will result in run array with physical length of `physical_array_len`
+/// and logical length of `logical_array_len`
+pub fn create_string_array_for_runs(
+    physical_array_len: usize,
+    logical_array_len: usize,
+    string_len: usize,
+) -> Vec<String> {
+    assert!(logical_array_len >= physical_array_len);
+    let mut rng = thread_rng();
+
+    // typical length of each run
+    let run_len = logical_array_len / physical_array_len;
+
+    // Some runs should have extra length
+    let mut run_len_extra = logical_array_len % physical_array_len;
+
+    let mut values: Vec<String> = (0..physical_array_len)
+        .map(|_| (0..string_len).map(|_| rng.gen::<char>()).collect())
+        .flat_map(|s| {
+            let mut take_len = run_len;
+            if run_len_extra > 0 {
+                take_len += 1;
+                run_len_extra -= 1;
+            }
+            std::iter::repeat(s).take(take_len)
+        })
+        .collect();
+    while values.len() < logical_array_len {
+        let last_val = values[values.len() - 1].clone();
+        values.push(last_val);
+    }
+    values
+}
+
 /// Creates an random (but fixed-seeded) binary array of a given size and null density
 pub fn create_binary_array<Offset: OffsetSizeTrait>(
     size: usize,
@@ -166,23 +234,74 @@ pub fn create_binary_array<Offset: OffsetSizeTrait>(
 }
 
 /// Creates an random (but fixed-seeded) array of a given size and null density
-pub fn create_fsb_array(
-    size: usize,
-    null_density: f32,
-    value_len: usize,
-) -> FixedSizeBinaryArray {
+pub fn create_fsb_array(size: usize, null_density: f32, value_len: usize) -> FixedSizeBinaryArray {
     let rng = &mut seedable_rng();
 
-    FixedSizeBinaryArray::try_from_sparse_iter((0..size).map(|_| {
-        if rng.gen::<f32>() < null_density {
-            None
-        } else {
-            let value = rng
-                .sample_iter::<u8, _>(Standard)
-                .take(value_len)
-                .collect::<Vec<u8>>();
-            Some(value)
-        }
-    }))
+    FixedSizeBinaryArray::try_from_sparse_iter_with_size(
+        (0..size).map(|_| {
+            if rng.gen::<f32>() < null_density {
+                None
+            } else {
+                let value = rng
+                    .sample_iter::<u8, _>(Standard)
+                    .take(value_len)
+                    .collect::<Vec<u8>>();
+                Some(value)
+            }
+        }),
+        value_len as i32,
+    )
     .unwrap()
 }
+
+/// Creates a random (but fixed-seeded) dictionary array of a given size and null density
+/// with the provided values array
+pub fn create_dict_from_values<K>(
+    size: usize,
+    null_density: f32,
+    values: &dyn Array,
+) -> DictionaryArray<K>
+where
+    K: ArrowDictionaryKeyType,
+    Standard: Distribution<K::Native>,
+    K::Native: SampleUniform,
+{
+    let min_key = K::Native::from_usize(0).unwrap();
+    let max_key = K::Native::from_usize(values.len()).unwrap();
+    create_sparse_dict_from_values(size, null_density, values, min_key..max_key)
+}
+
+/// Creates a random (but fixed-seeded) dictionary array of a given size and null density
+/// with the provided values array and key range
+pub fn create_sparse_dict_from_values<K>(
+    size: usize,
+    null_density: f32,
+    values: &dyn Array,
+    key_range: Range<K::Native>,
+) -> DictionaryArray<K>
+where
+    K: ArrowDictionaryKeyType,
+    Standard: Distribution<K::Native>,
+    K::Native: SampleUniform,
+{
+    let mut rng = seedable_rng();
+    let data_type =
+        DataType::Dictionary(Box::new(K::DATA_TYPE), Box::new(values.data_type().clone()));
+
+    let keys: Buffer = (0..size)
+        .map(|_| rng.gen_range(key_range.clone()))
+        .collect();
+
+    let nulls: Option<Buffer> =
+        (null_density != 0.).then(|| (0..size).map(|_| rng.gen_bool(null_density as _)).collect());
+
+    let data = ArrayDataBuilder::new(data_type)
+        .len(size)
+        .null_bit_buffer(nulls)
+        .add_buffer(keys)
+        .add_child_data(values.to_data())
+        .build()
+        .unwrap();
+
+    DictionaryArray::from(data)
+}
diff --git a/arrow/src/util/data_gen.rs b/arrow/src/util/data_gen.rs
index 4d974409a0ee..5733fdf22add 100644
--- a/arrow/src/util/data_gen.rs
+++ b/arrow/src/util/data_gen.rs
@@ -47,10 +47,7 @@ pub fn create_random_batch(
     RecordBatch::try_new_with_options(
         schema,
         columns,
-        &RecordBatchOptions {
-            match_field_names: false,
-            row_count: None,
-        },
+        &RecordBatchOptions::new().with_match_field_names(false),
     )
 }
 
@@ -81,15 +78,14 @@ pub fn create_random_array(
         UInt64 => Arc::new(create_primitive_array::<UInt64Type>(size, null_density)),
         Float16 => {
             return Err(ArrowError::NotYetImplemented(
-                "Float16 is not implememted".to_string(),
+                "Float16 is not implemented".to_string(),
             ))
         }
         Float32 => Arc::new(create_primitive_array::<Float32Type>(size, null_density)),
         Float64 => Arc::new(create_primitive_array::<Float64Type>(size, null_density)),
         Timestamp(_, _) => {
             let int64_array =
-                Arc::new(create_primitive_array::<Int64Type>(size, null_density))
-                    as ArrayRef;
+                Arc::new(create_primitive_array::<Int64Type>(size, null_density)) as ArrayRef;
             return crate::compute::cast(&int64_array, field.data_type());
         }
         Date32 => Arc::new(create_primitive_array::<Date32Type>(size, null_density)),
@@ -99,27 +95,28 @@ pub fn create_random_array(
                 size,
                 null_density,
             )) as ArrayRef,
-            TimeUnit::Millisecond => Arc::new(create_primitive_array::<
-                Time32MillisecondType,
-            >(size, null_density)),
+            TimeUnit::Millisecond => Arc::new(create_primitive_array::<Time32MillisecondType>(
+                size,
+                null_density,
+            )),
             _ => {
                 return Err(ArrowError::InvalidArgumentError(format!(
-                    "Unsupported unit {:?} for Time32",
-                    unit
+                    "Unsupported unit {unit:?} for Time32"
                 )))
             }
         },
         Time64(unit) => match unit {
-            TimeUnit::Microsecond => Arc::new(create_primitive_array::<
-                Time64MicrosecondType,
-            >(size, null_density)) as ArrayRef,
-            TimeUnit::Nanosecond => Arc::new(create_primitive_array::<
-                Time64NanosecondType,
-            >(size, null_density)),
+            TimeUnit::Microsecond => Arc::new(create_primitive_array::<Time64MicrosecondType>(
+                size,
+                null_density,
+            )) as ArrayRef,
+            TimeUnit::Nanosecond => Arc::new(create_primitive_array::<Time64NanosecondType>(
+                size,
+                null_density,
+            )),
             _ => {
                 return Err(ArrowError::InvalidArgumentError(format!(
-                    "Unsupported unit {:?} for Time64",
-                    unit
+                    "Unsupported unit {unit:?} for Time64"
                 )))
             }
         },
@@ -127,13 +124,9 @@ pub fn create_random_array(
         LargeUtf8 => Arc::new(create_string_array::<i64>(size, null_density)),
         Binary => Arc::new(create_binary_array::<i32>(size, null_density)),
         LargeBinary => Arc::new(create_binary_array::<i64>(size, null_density)),
-        FixedSizeBinary(len) => {
-            Arc::new(create_fsb_array(size, null_density, *len as usize))
-        }
+        FixedSizeBinary(len) => Arc::new(create_fsb_array(size, null_density, *len as usize)),
         List(_) => create_random_list_array(field, size, null_density, true_density)?,
-        LargeList(_) => {
-            create_random_list_array(field, size, null_density, true_density)?
-        }
+        LargeList(_) => create_random_list_array(field, size, null_density, true_density)?,
         Struct(fields) => Arc::new(StructArray::try_from(
             fields
                 .iter()
@@ -143,9 +136,7 @@ pub fn create_random_array(
                 })
                 .collect::<Result<Vec<(&str, ArrayRef)>>>()?,
         )?),
-        d @ Dictionary(_, value_type)
-            if crate::compute::can_cast_types(value_type, d) =>
-        {
+        d @ Dictionary(_, value_type) if crate::compute::can_cast_types(value_type, d) => {
             let f = Field::new(
                 field.name(),
                 value_type.as_ref().clone(),
@@ -156,8 +147,7 @@ pub fn create_random_array(
         }
         other => {
             return Err(ArrowError::NotYetImplemented(format!(
-                "Generating random arrays not yet implemented for {:?}",
-                other
+                "Generating random arrays not yet implemented for {other:?}"
             )))
         }
     })
@@ -189,16 +179,14 @@ fn create_random_list_array(
         }
         _ => {
             return Err(ArrowError::InvalidArgumentError(format!(
-                "Cannot create list array for field {:?}",
-                field
+                "Cannot create list array for field {field:?}"
             )))
         }
     };
 
     // Create list's child data
-    let child_array =
-        create_random_array(list_field, child_len as usize, null_density, true_density)?;
-    let child_data = child_array.data();
+    let child_array = create_random_array(list_field, child_len, null_density, true_density)?;
+    let child_data = child_array.to_data();
     // Create list's null buffers, if it is nullable
     let null_buffer = match field.is_nullable() {
         true => Some(create_random_null_buffer(size, null_density)),
@@ -212,7 +200,7 @@ fn create_random_list_array(
             null_buffer,
             0,
             vec![offsets],
-            vec![child_data.clone()],
+            vec![child_data],
         )
     };
     Ok(make_array(list_data))
@@ -256,6 +244,7 @@ fn create_random_null_buffer(size: usize, null_density: f32) -> Buffer {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use arrow_schema::Fields;
 
     #[test]
     fn test_create_batch() {
@@ -279,7 +268,7 @@ mod tests {
             Field::new("a", DataType::Int32, false),
             Field::new(
                 "b",
-                DataType::List(Box::new(Field::new("item", DataType::LargeUtf8, true))),
+                DataType::List(Arc::new(Field::new("item", DataType::LargeUtf8, true))),
                 false,
             ),
             Field::new("a", DataType::Int32, false),
@@ -295,8 +284,8 @@ mod tests {
         }
         // Test that the list's child values are non-null
         let b_array = batch.column(1);
-        let list_array = b_array.as_any().downcast_ref::<ListArray>().unwrap();
-        let child_array = make_array(list_array.data().child_data()[0].clone());
+        let list_array = b_array.as_list::<i32>();
+        let child_array = list_array.values();
         assert_eq!(child_array.null_count(), 0);
         // There should be more values than the list, to show that it's a list
         assert!(child_array.len() > list_array.len());
@@ -305,13 +294,13 @@ mod tests {
     #[test]
     fn test_create_struct_array() {
         let size = 32;
-        let struct_fields = vec![
+        let struct_fields = Fields::from(vec![
             Field::new("b", DataType::Boolean, true),
             Field::new(
                 "c",
-                DataType::LargeList(Box::new(Field::new(
+                DataType::LargeList(Arc::new(Field::new(
                     "item",
-                    DataType::List(Box::new(Field::new(
+                    DataType::List(Arc::new(Field::new(
                         "item",
                         DataType::FixedSizeBinary(6),
                         true,
@@ -322,14 +311,14 @@ mod tests {
             ),
             Field::new(
                 "d",
-                DataType::Struct(vec![
+                DataType::Struct(Fields::from(vec![
                     Field::new("d_x", DataType::Int32, true),
                     Field::new("d_y", DataType::Float32, false),
                     Field::new("d_z", DataType::Binary, true),
-                ]),
+                ])),
                 true,
             ),
-        ];
+        ]);
         let field = Field::new("struct", DataType::Struct(struct_fields), true);
         let array = create_random_array(&field, size, 0.2, 0.5).unwrap();
 
@@ -342,10 +331,8 @@ mod tests {
         let col_c = struct_array.column_by_name("c").unwrap();
         let col_c = col_c.as_any().downcast_ref::<LargeListArray>().unwrap();
         assert_eq!(col_c.len(), size);
-        let col_c_values = col_c.values();
-        assert!(col_c_values.len() > size);
-        // col_c_values should be a list
-        let col_c_list = col_c_values.as_any().downcast_ref::<ListArray>().unwrap();
+        let col_c_list = col_c.values().as_list::<i32>();
+        assert!(col_c_list.len() > size);
         // Its values should be FixedSizeBinary(6)
         let fsb = col_c_list.values();
         assert_eq!(fsb.data_type(), &DataType::FixedSizeBinary(6));
diff --git a/arrow/src/util/decimal.rs b/arrow/src/util/decimal.rs
deleted file mode 100644
index 96399b870207..000000000000
--- a/arrow/src/util/decimal.rs
+++ /dev/null
@@ -1,473 +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.
-
-//! Decimal related utils
-
-use crate::datatypes::{
-    DataType, DECIMAL128_MAX_PRECISION, DECIMAL128_MAX_SCALE, DECIMAL256_MAX_PRECISION,
-    DECIMAL256_MAX_SCALE, DECIMAL_DEFAULT_SCALE,
-};
-use crate::error::{ArrowError, Result};
-use num::bigint::BigInt;
-use num::Signed;
-use std::cmp::{min, Ordering};
-
-#[derive(Debug)]
-pub struct BasicDecimal<const BYTE_WIDTH: usize> {
-    precision: usize,
-    scale: usize,
-    value: [u8; BYTE_WIDTH],
-}
-
-impl<const BYTE_WIDTH: usize> BasicDecimal<BYTE_WIDTH> {
-    #[allow(clippy::type_complexity)]
-    const MAX_PRECISION_SCALE_CONSTRUCTOR_DEFAULT_TYPE: (
-        usize,
-        usize,
-        fn(usize, usize) -> DataType,
-        DataType,
-    ) = match BYTE_WIDTH {
-        16 => (
-            DECIMAL128_MAX_PRECISION,
-            DECIMAL128_MAX_SCALE,
-            DataType::Decimal128,
-            DataType::Decimal128(DECIMAL128_MAX_PRECISION, DECIMAL_DEFAULT_SCALE),
-        ),
-        32 => (
-            DECIMAL256_MAX_PRECISION,
-            DECIMAL256_MAX_SCALE,
-            DataType::Decimal256,
-            DataType::Decimal256(DECIMAL256_MAX_PRECISION, DECIMAL_DEFAULT_SCALE),
-        ),
-        _ => panic!("invalid byte width"),
-    };
-
-    pub const MAX_PRECISION: usize = Self::MAX_PRECISION_SCALE_CONSTRUCTOR_DEFAULT_TYPE.0;
-    pub const MAX_SCALE: usize = Self::MAX_PRECISION_SCALE_CONSTRUCTOR_DEFAULT_TYPE.1;
-    pub const TYPE_CONSTRUCTOR: fn(usize, usize) -> DataType =
-        Self::MAX_PRECISION_SCALE_CONSTRUCTOR_DEFAULT_TYPE.2;
-    pub const DEFAULT_TYPE: DataType =
-        Self::MAX_PRECISION_SCALE_CONSTRUCTOR_DEFAULT_TYPE.3;
-
-    /// Tries to create a decimal value from precision, scale and bytes.
-    /// If the length of bytes isn't same as the bit width of this decimal,
-    /// returning an error. The bytes should be stored in little-endian order.
-    ///
-    /// Safety:
-    /// This method doesn't validate if the decimal value represented by the bytes
-    /// can be fitted into the specified precision.
-    pub fn try_new_from_bytes(
-        precision: usize,
-        scale: usize,
-        bytes: &[u8; BYTE_WIDTH],
-    ) -> Result<Self>
-    where
-        Self: Sized,
-    {
-        if precision > Self::MAX_PRECISION {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "precision {} is greater than max {}",
-                precision,
-                Self::MAX_PRECISION
-            )));
-        }
-        if scale > Self::MAX_SCALE {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "scale {} is greater than max {}",
-                scale,
-                Self::MAX_SCALE
-            )));
-        }
-
-        if precision < scale {
-            return Err(ArrowError::InvalidArgumentError(format!(
-                "Precision {} is less than scale {}",
-                precision, scale
-            )));
-        }
-
-        if bytes.len() == BYTE_WIDTH {
-            Ok(Self::new(precision, scale, bytes))
-        } else {
-            Err(ArrowError::InvalidArgumentError(format!(
-                "Input to Decimal{} must be {} bytes",
-                BYTE_WIDTH * 8,
-                BYTE_WIDTH
-            )))
-        }
-    }
-
-    /// Creates a decimal value from precision, scale, and bytes.
-    ///
-    /// Safety:
-    /// This method doesn't check if the length of bytes is compatible with this decimal.
-    /// Use `try_new_from_bytes` for safe constructor.
-    pub fn new(precision: usize, scale: usize, bytes: &[u8]) -> Self {
-        Self {
-            precision,
-            scale,
-            value: bytes.try_into().unwrap(),
-        }
-    }
-    /// Returns the raw bytes of the integer representation of the decimal.
-    pub fn raw_value(&self) -> &[u8] {
-        &self.value
-    }
-
-    /// Returns the precision of the decimal.
-    pub fn precision(&self) -> usize {
-        self.precision
-    }
-
-    /// Returns the scale of the decimal.
-    pub fn scale(&self) -> usize {
-        self.scale
-    }
-
-    /// Returns the string representation of the decimal.
-    /// If the string representation cannot be fitted with the precision of the decimal,
-    /// the string will be truncated.
-    #[allow(clippy::inherent_to_string)]
-    pub fn to_string(&self) -> String {
-        let raw_bytes = self.raw_value();
-        let integer = BigInt::from_signed_bytes_le(raw_bytes);
-        let value_str = integer.to_string();
-        let (sign, rest) =
-            value_str.split_at(if integer >= BigInt::from(0) { 0 } else { 1 });
-        let bound = min(self.precision(), rest.len()) + sign.len();
-        let value_str = &value_str[0..bound];
-
-        if self.scale() == 0 {
-            value_str.to_string()
-        } else if rest.len() > self.scale() {
-            // Decimal separator is in the middle of the string
-            let (whole, decimal) = value_str.split_at(value_str.len() - self.scale());
-            format!("{}.{}", whole, decimal)
-        } else {
-            // String has to be padded
-            format!("{}0.{:0>width$}", sign, rest, width = self.scale())
-        }
-    }
-}
-
-impl<const BYTE_WIDTH: usize> PartialOrd for BasicDecimal<BYTE_WIDTH> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        assert_eq!(
-            self.scale, other.scale,
-            "Cannot compare two Decimals with different scale: {}, {}",
-            self.scale, other.scale
-        );
-        Some(singed_cmp_le_bytes(&self.value, &other.value))
-    }
-}
-
-impl<const BYTE_WIDTH: usize> Ord for BasicDecimal<BYTE_WIDTH> {
-    fn cmp(&self, other: &Self) -> Ordering {
-        assert_eq!(
-            self.scale, other.scale,
-            "Cannot compare two Decimals with different scale: {}, {}",
-            self.scale, other.scale
-        );
-        singed_cmp_le_bytes(&self.value, &other.value)
-    }
-}
-
-impl<const BYTE_WIDTH: usize> PartialEq<Self> for BasicDecimal<BYTE_WIDTH> {
-    fn eq(&self, other: &Self) -> bool {
-        assert_eq!(
-            self.scale, other.scale,
-            "Cannot compare two Decimals with different scale: {}, {}",
-            self.scale, other.scale
-        );
-        self.value.eq(&other.value)
-    }
-}
-
-impl<const BYTE_WIDTH: usize> Eq for BasicDecimal<BYTE_WIDTH> {}
-
-/// Represents a decimal value with precision and scale.
-/// The decimal value could represented by a signed 128-bit integer.
-pub type Decimal128 = BasicDecimal<16>;
-
-impl Decimal128 {
-    /// Creates `Decimal128` from an `i128` value.
-    #[allow(dead_code)]
-    pub(crate) fn new_from_i128(precision: usize, scale: usize, value: i128) -> Self {
-        Decimal128 {
-            precision,
-            scale,
-            value: value.to_le_bytes(),
-        }
-    }
-
-    /// Returns `i128` representation of the decimal.
-    pub fn as_i128(&self) -> i128 {
-        i128::from_le_bytes(self.value)
-    }
-}
-
-impl From<Decimal128> for i128 {
-    fn from(decimal: Decimal128) -> Self {
-        decimal.as_i128()
-    }
-}
-
-/// Represents a decimal value with precision and scale.
-/// The decimal value could be represented by a signed 256-bit integer.
-pub type Decimal256 = BasicDecimal<32>;
-
-impl Decimal256 {
-    /// Constructs a `Decimal256` value from a `BigInt`.
-    pub fn from_big_int(
-        num: &BigInt,
-        precision: usize,
-        scale: usize,
-    ) -> Result<Decimal256> {
-        let mut bytes = if num.is_negative() {
-            [255_u8; 32]
-        } else {
-            [0; 32]
-        };
-        let num_bytes = &num.to_signed_bytes_le();
-        bytes[0..num_bytes.len()].clone_from_slice(num_bytes);
-        Decimal256::try_new_from_bytes(precision, scale, &bytes)
-    }
-
-    /// Constructs a `BigInt` from this `Decimal256` value.
-    pub(crate) fn to_big_int(&self) -> BigInt {
-        BigInt::from_signed_bytes_le(&self.value)
-    }
-}
-
-// compare two signed integer which are encoded with little endian.
-// left bytes and right bytes must have the same length.
-#[inline]
-pub(crate) fn singed_cmp_le_bytes(left: &[u8], right: &[u8]) -> Ordering {
-    assert_eq!(
-        left.len(),
-        right.len(),
-        "Can't compare bytes array with different len: {}, {}",
-        left.len(),
-        right.len()
-    );
-    assert_ne!(left.len(), 0, "Can't compare bytes array of length 0");
-    let len = left.len();
-    // the sign bit is 1, the value is negative
-    let left_negative = left[len - 1] >= 0x80_u8;
-    let right_negative = right[len - 1] >= 0x80_u8;
-    if left_negative != right_negative {
-        return match left_negative {
-            true => {
-                // left is negative value
-                // right is positive value
-                Ordering::Less
-            }
-            false => Ordering::Greater,
-        };
-    }
-    for i in 0..len {
-        let l_byte = left[len - 1 - i];
-        let r_byte = right[len - 1 - i];
-        match l_byte.cmp(&r_byte) {
-            Ordering::Less => {
-                return Ordering::Less;
-            }
-            Ordering::Greater => {
-                return Ordering::Greater;
-            }
-            Ordering::Equal => {}
-        }
-    }
-    Ordering::Equal
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use num::{BigInt, Num};
-    use rand::random;
-
-    #[test]
-    fn decimal_128_to_string() {
-        let mut value = Decimal128::new_from_i128(5, 2, 100);
-        assert_eq!(value.to_string(), "1.00");
-
-        value = Decimal128::new_from_i128(5, 3, 100);
-        assert_eq!(value.to_string(), "0.100");
-    }
-
-    #[test]
-    fn decimal_invalid_precision_scale() {
-        let bytes = 100_i128.to_le_bytes();
-        let err = Decimal128::try_new_from_bytes(5, 6, &bytes);
-        assert!(err.is_err());
-    }
-
-    #[test]
-    fn decimal_128_from_bytes() {
-        let mut bytes = 100_i128.to_le_bytes();
-        let value = Decimal128::try_new_from_bytes(5, 2, &bytes).unwrap();
-        assert_eq!(value.to_string(), "1.00");
-
-        bytes = (-1_i128).to_le_bytes();
-        let value = Decimal128::try_new_from_bytes(5, 2, &bytes).unwrap();
-        assert_eq!(value.to_string(), "-0.01");
-
-        bytes = i128::MAX.to_le_bytes();
-        let value = Decimal128::try_new_from_bytes(38, 2, &bytes).unwrap();
-        assert_eq!(value.to_string(), "170141183460469231731687303715884105.72");
-
-        bytes = i128::MIN.to_le_bytes();
-        let value = Decimal128::try_new_from_bytes(38, 2, &bytes).unwrap();
-        assert_eq!(
-            value.to_string(),
-            "-170141183460469231731687303715884105.72"
-        );
-
-        // Truncated
-        bytes = 12345_i128.to_le_bytes();
-        let value = Decimal128::try_new_from_bytes(3, 2, &bytes).unwrap();
-        assert_eq!(value.to_string(), "1.23");
-
-        bytes = (-12345_i128).to_le_bytes();
-        let value = Decimal128::try_new_from_bytes(3, 2, &bytes).unwrap();
-        assert_eq!(value.to_string(), "-1.23");
-    }
-
-    #[test]
-    fn decimal_256_from_bytes() {
-        let mut bytes = [0_u8; 32];
-        bytes[0..16].clone_from_slice(&100_i128.to_le_bytes());
-        let value = Decimal256::try_new_from_bytes(5, 2, &bytes).unwrap();
-        assert_eq!(value.to_string(), "1.00");
-
-        bytes[0..16].clone_from_slice(&i128::MAX.to_le_bytes());
-        let value = Decimal256::try_new_from_bytes(40, 4, &bytes).unwrap();
-        assert_eq!(
-            value.to_string(),
-            "17014118346046923173168730371588410.5727"
-        );
-
-        // i128 maximum + 1
-        bytes[0..16].clone_from_slice(&0_i128.to_le_bytes());
-        bytes[15] = 128;
-        let value = Decimal256::try_new_from_bytes(40, 4, &bytes).unwrap();
-        assert_eq!(
-            value.to_string(),
-            "17014118346046923173168730371588410.5728"
-        );
-
-        // smaller than i128 minimum
-        bytes = [255; 32];
-        bytes[31] = 128;
-        let value = Decimal256::try_new_from_bytes(76, 4, &bytes).unwrap();
-        assert_eq!(
-            value.to_string(),
-            "-574437317700748313234121683441537667865831564552201235664496608164256541.5731"
-        );
-
-        bytes = [255; 32];
-        let value = Decimal256::try_new_from_bytes(5, 2, &bytes).unwrap();
-        assert_eq!(value.to_string(), "-0.01");
-    }
-
-    fn i128_func(value: impl Into<i128>) -> i128 {
-        value.into()
-    }
-
-    #[test]
-    fn decimal_128_to_i128() {
-        let value = Decimal128::new_from_i128(5, 2, 100);
-        let integer = i128_func(value);
-        assert_eq!(integer, 100);
-    }
-
-    #[test]
-    fn bigint_to_decimal256() {
-        let num = BigInt::from_str_radix("123456789", 10).unwrap();
-        let value = Decimal256::from_big_int(&num, 30, 2).unwrap();
-        assert_eq!(value.to_string(), "1234567.89");
-
-        let num = BigInt::from_str_radix("-5744373177007483132341216834415376678658315645522012356644966081642565415731", 10).unwrap();
-        let value = Decimal256::from_big_int(&num, 76, 4).unwrap();
-        assert_eq!(value.to_string(), "-574437317700748313234121683441537667865831564552201235664496608164256541.5731");
-    }
-
-    #[test]
-    fn test_lt_cmp_byte() {
-        for _i in 0..100 {
-            let left = random::<i128>();
-            let right = random::<i128>();
-            let result = singed_cmp_le_bytes(
-                left.to_le_bytes().as_slice(),
-                right.to_le_bytes().as_slice(),
-            );
-            assert_eq!(left.cmp(&right), result);
-        }
-        for _i in 0..100 {
-            let left = random::<i32>();
-            let right = random::<i32>();
-            let result = singed_cmp_le_bytes(
-                left.to_le_bytes().as_slice(),
-                right.to_le_bytes().as_slice(),
-            );
-            assert_eq!(left.cmp(&right), result);
-        }
-    }
-
-    #[test]
-    fn compare_decimal128() {
-        let v1 = -100_i128;
-        let v2 = 10000_i128;
-        let right = Decimal128::new_from_i128(20, 3, v2);
-        for v in v1..v2 {
-            let left = Decimal128::new_from_i128(20, 3, v);
-            assert!(left < right);
-        }
-
-        for _i in 0..100 {
-            let left = random::<i128>();
-            let right = random::<i128>();
-            let left_decimal = Decimal128::new_from_i128(38, 2, left);
-            let right_decimal = Decimal128::new_from_i128(38, 2, right);
-            assert_eq!(left < right, left_decimal < right_decimal);
-            assert_eq!(left == right, left_decimal == right_decimal)
-        }
-    }
-
-    #[test]
-    fn compare_decimal256() {
-        let v1 = -100_i128;
-        let v2 = 10000_i128;
-        let right = Decimal256::from_big_int(&BigInt::from(v2), 75, 2).unwrap();
-        for v in v1..v2 {
-            let left = Decimal256::from_big_int(&BigInt::from(v), 75, 2).unwrap();
-            assert!(left < right);
-        }
-
-        for _i in 0..100 {
-            let left = random::<i128>();
-            let right = random::<i128>();
-            let left_decimal =
-                Decimal256::from_big_int(&BigInt::from(left), 75, 2).unwrap();
-            let right_decimal =
-                Decimal256::from_big_int(&BigInt::from(right), 75, 2).unwrap();
-            assert_eq!(left < right, left_decimal < right_decimal);
-            assert_eq!(left == right, left_decimal == right_decimal)
-        }
-    }
-}
diff --git a/arrow/src/util/display.rs b/arrow/src/util/display.rs
deleted file mode 100644
index aa4fd4200870..000000000000
--- a/arrow/src/util/display.rs
+++ /dev/null
@@ -1,467 +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.
-
-//! Functions for printing array values, as strings, for debugging
-//! purposes. See the `pretty` crate for additional functions for
-//! record batch pretty printing.
-
-use std::fmt::Write;
-use std::sync::Arc;
-
-use crate::array::Array;
-use crate::datatypes::{
-    ArrowNativeType, ArrowPrimitiveType, DataType, Field, Int16Type, Int32Type,
-    Int64Type, Int8Type, TimeUnit, UInt16Type, UInt32Type, UInt64Type, UInt8Type,
-    UnionMode,
-};
-use crate::{array, datatypes::IntervalUnit};
-
-use array::DictionaryArray;
-
-use crate::error::{ArrowError, Result};
-
-macro_rules! make_string {
-    ($array_type:ty, $column: ident, $row: ident) => {{
-        let array = $column.as_any().downcast_ref::<$array_type>().unwrap();
-
-        let s = if array.is_null($row) {
-            "".to_string()
-        } else {
-            array.value($row).to_string()
-        };
-
-        Ok(s)
-    }};
-}
-
-macro_rules! make_string_interval_year_month {
-    ($column: ident, $row: ident) => {{
-        let array = $column
-            .as_any()
-            .downcast_ref::<array::IntervalYearMonthArray>()
-            .unwrap();
-
-        let s = if array.is_null($row) {
-            "NULL".to_string()
-        } else {
-            let interval = array.value($row) as f64;
-            let years = (interval / 12_f64).floor();
-            let month = interval - (years * 12_f64);
-
-            format!(
-                "{} years {} mons 0 days 0 hours 0 mins 0.00 secs",
-                years, month,
-            )
-        };
-
-        Ok(s)
-    }};
-}
-
-macro_rules! make_string_interval_day_time {
-    ($column: ident, $row: ident) => {{
-        let array = $column
-            .as_any()
-            .downcast_ref::<array::IntervalDayTimeArray>()
-            .unwrap();
-
-        let s = if array.is_null($row) {
-            "NULL".to_string()
-        } else {
-            let value: u64 = array.value($row) as u64;
-
-            let days_parts: i32 = ((value & 0xFFFFFFFF00000000) >> 32) as i32;
-            let milliseconds_part: i32 = (value & 0xFFFFFFFF) as i32;
-
-            let secs = milliseconds_part / 1000;
-            let mins = secs / 60;
-            let hours = mins / 60;
-
-            let secs = secs - (mins * 60);
-            let mins = mins - (hours * 60);
-
-            format!(
-                "0 years 0 mons {} days {} hours {} mins {}.{:02} secs",
-                days_parts,
-                hours,
-                mins,
-                secs,
-                (milliseconds_part % 1000),
-            )
-        };
-
-        Ok(s)
-    }};
-}
-
-macro_rules! make_string_interval_month_day_nano {
-    ($column: ident, $row: ident) => {{
-        let array = $column
-            .as_any()
-            .downcast_ref::<array::IntervalMonthDayNanoArray>()
-            .unwrap();
-
-        let s = if array.is_null($row) {
-            "NULL".to_string()
-        } else {
-            let value: u128 = array.value($row) as u128;
-
-            let months_part: i32 =
-                ((value & 0xFFFFFFFF000000000000000000000000) >> 96) as i32;
-            let days_part: i32 = ((value & 0xFFFFFFFF0000000000000000) >> 64) as i32;
-            let nanoseconds_part: i64 = (value & 0xFFFFFFFFFFFFFFFF) as i64;
-
-            let secs = nanoseconds_part / 1000000000;
-            let mins = secs / 60;
-            let hours = mins / 60;
-
-            let secs = secs - (mins * 60);
-            let mins = mins - (hours * 60);
-
-            format!(
-                "0 years {} mons {} days {} hours {} mins {}.{:02} secs",
-                months_part,
-                days_part,
-                hours,
-                mins,
-                secs,
-                (nanoseconds_part % 1000000000),
-            )
-        };
-
-        Ok(s)
-    }};
-}
-
-macro_rules! make_string_date {
-    ($array_type:ty, $column: ident, $row: ident) => {{
-        let array = $column.as_any().downcast_ref::<$array_type>().unwrap();
-
-        let s = if array.is_null($row) {
-            "".to_string()
-        } else {
-            array
-                .value_as_date($row)
-                .map(|d| d.to_string())
-                .unwrap_or_else(|| "ERROR CONVERTING DATE".to_string())
-        };
-
-        Ok(s)
-    }};
-}
-
-macro_rules! make_string_time {
-    ($array_type:ty, $column: ident, $row: ident) => {{
-        let array = $column.as_any().downcast_ref::<$array_type>().unwrap();
-
-        let s = if array.is_null($row) {
-            "".to_string()
-        } else {
-            array
-                .value_as_time($row)
-                .map(|d| d.to_string())
-                .unwrap_or_else(|| "ERROR CONVERTING DATE".to_string())
-        };
-
-        Ok(s)
-    }};
-}
-
-macro_rules! make_string_datetime {
-    ($array_type:ty, $column: ident, $row: ident) => {{
-        let array = $column.as_any().downcast_ref::<$array_type>().unwrap();
-
-        let s = if array.is_null($row) {
-            "".to_string()
-        } else {
-            array
-                .value_as_datetime($row)
-                .map(|d| d.to_string())
-                .unwrap_or_else(|| "ERROR CONVERTING DATE".to_string())
-        };
-
-        Ok(s)
-    }};
-}
-
-// It's not possible to do array.value($row).to_string() for &[u8], let's format it as hex
-macro_rules! make_string_hex {
-    ($array_type:ty, $column: ident, $row: ident) => {{
-        let array = $column.as_any().downcast_ref::<$array_type>().unwrap();
-
-        let s = if array.is_null($row) {
-            "".to_string()
-        } else {
-            let mut tmp = "".to_string();
-
-            for character in array.value($row) {
-                let _ = write!(tmp, "{:02x}", character);
-            }
-
-            tmp
-        };
-
-        Ok(s)
-    }};
-}
-
-macro_rules! make_string_from_list {
-    ($column: ident, $row: ident) => {{
-        let list = $column
-            .as_any()
-            .downcast_ref::<array::ListArray>()
-            .ok_or(ArrowError::InvalidArgumentError(format!(
-                "Repl error: could not convert list column to list array."
-            )))?
-            .value($row);
-        let string_values = (0..list.len())
-            .map(|i| array_value_to_string(&list.clone(), i))
-            .collect::<Result<Vec<String>>>()?;
-        Ok(format!("[{}]", string_values.join(", ")))
-    }};
-}
-
-macro_rules! make_string_from_fixed_size_list {
-    ($column: ident, $row: ident) => {{
-        let list = $column
-            .as_any()
-            .downcast_ref::<array::FixedSizeListArray>()
-            .ok_or(ArrowError::InvalidArgumentError(format!(
-                "Repl error: could not convert list column to list array."
-            )))?
-            .value($row);
-        let string_values = (0..list.len())
-            .map(|i| array_value_to_string(&list.clone(), i))
-            .collect::<Result<Vec<String>>>()?;
-        Ok(format!("[{}]", string_values.join(", ")))
-    }};
-}
-
-#[inline(always)]
-pub fn make_string_from_decimal(column: &Arc<dyn Array>, row: usize) -> Result<String> {
-    let array = column
-        .as_any()
-        .downcast_ref::<array::Decimal128Array>()
-        .unwrap();
-
-    let formatted_decimal = array.value_as_string(row);
-    Ok(formatted_decimal)
-}
-
-fn append_struct_field_string(
-    target: &mut String,
-    name: &str,
-    field_col: &Arc<dyn Array>,
-    row: usize,
-) -> Result<()> {
-    target.push('"');
-    target.push_str(name);
-    target.push_str("\": ");
-
-    if field_col.is_null(row) {
-        target.push_str("null");
-    } else {
-        match field_col.data_type() {
-            DataType::Utf8 | DataType::LargeUtf8 => {
-                target.push('"');
-                target.push_str(array_value_to_string(field_col, row)?.as_str());
-                target.push('"');
-            }
-            _ => {
-                target.push_str(array_value_to_string(field_col, row)?.as_str());
-            }
-        }
-    }
-
-    Ok(())
-}
-
-/// Get the value at the given row in an array as a String.
-///
-/// Note this function is quite inefficient and is unlikely to be
-/// suitable for converting large arrays or record batches.
-pub fn array_value_to_string(column: &array::ArrayRef, row: usize) -> Result<String> {
-    if column.is_null(row) {
-        return Ok("".to_string());
-    }
-    match column.data_type() {
-        DataType::Utf8 => make_string!(array::StringArray, column, row),
-        DataType::LargeUtf8 => make_string!(array::LargeStringArray, column, row),
-        DataType::Binary => make_string_hex!(array::BinaryArray, column, row),
-        DataType::LargeBinary => make_string_hex!(array::LargeBinaryArray, column, row),
-        DataType::FixedSizeBinary(_) => {
-            make_string_hex!(array::FixedSizeBinaryArray, column, row)
-        }
-        DataType::Boolean => make_string!(array::BooleanArray, column, row),
-        DataType::Int8 => make_string!(array::Int8Array, column, row),
-        DataType::Int16 => make_string!(array::Int16Array, column, row),
-        DataType::Int32 => make_string!(array::Int32Array, column, row),
-        DataType::Int64 => make_string!(array::Int64Array, column, row),
-        DataType::UInt8 => make_string!(array::UInt8Array, column, row),
-        DataType::UInt16 => make_string!(array::UInt16Array, column, row),
-        DataType::UInt32 => make_string!(array::UInt32Array, column, row),
-        DataType::UInt64 => make_string!(array::UInt64Array, column, row),
-        DataType::Float16 => make_string!(array::Float16Array, column, row),
-        DataType::Float32 => make_string!(array::Float32Array, column, row),
-        DataType::Float64 => make_string!(array::Float64Array, column, row),
-        DataType::Decimal128(..) => make_string_from_decimal(column, row),
-        DataType::Timestamp(unit, _) if *unit == TimeUnit::Second => {
-            make_string_datetime!(array::TimestampSecondArray, column, row)
-        }
-        DataType::Timestamp(unit, _) if *unit == TimeUnit::Millisecond => {
-            make_string_datetime!(array::TimestampMillisecondArray, column, row)
-        }
-        DataType::Timestamp(unit, _) if *unit == TimeUnit::Microsecond => {
-            make_string_datetime!(array::TimestampMicrosecondArray, column, row)
-        }
-        DataType::Timestamp(unit, _) if *unit == TimeUnit::Nanosecond => {
-            make_string_datetime!(array::TimestampNanosecondArray, column, row)
-        }
-        DataType::Date32 => make_string_date!(array::Date32Array, column, row),
-        DataType::Date64 => make_string_date!(array::Date64Array, column, row),
-        DataType::Time32(unit) if *unit == TimeUnit::Second => {
-            make_string_time!(array::Time32SecondArray, column, row)
-        }
-        DataType::Time32(unit) if *unit == TimeUnit::Millisecond => {
-            make_string_time!(array::Time32MillisecondArray, column, row)
-        }
-        DataType::Time64(unit) if *unit == TimeUnit::Microsecond => {
-            make_string_time!(array::Time64MicrosecondArray, column, row)
-        }
-        DataType::Time64(unit) if *unit == TimeUnit::Nanosecond => {
-            make_string_time!(array::Time64NanosecondArray, column, row)
-        }
-        DataType::Interval(unit) => match unit {
-            IntervalUnit::DayTime => {
-                make_string_interval_day_time!(column, row)
-            }
-            IntervalUnit::YearMonth => {
-                make_string_interval_year_month!(column, row)
-            }
-            IntervalUnit::MonthDayNano => {
-                make_string_interval_month_day_nano!(column, row)
-            }
-        },
-        DataType::List(_) => make_string_from_list!(column, row),
-        DataType::Dictionary(index_type, _value_type) => match **index_type {
-            DataType::Int8 => dict_array_value_to_string::<Int8Type>(column, row),
-            DataType::Int16 => dict_array_value_to_string::<Int16Type>(column, row),
-            DataType::Int32 => dict_array_value_to_string::<Int32Type>(column, row),
-            DataType::Int64 => dict_array_value_to_string::<Int64Type>(column, row),
-            DataType::UInt8 => dict_array_value_to_string::<UInt8Type>(column, row),
-            DataType::UInt16 => dict_array_value_to_string::<UInt16Type>(column, row),
-            DataType::UInt32 => dict_array_value_to_string::<UInt32Type>(column, row),
-            DataType::UInt64 => dict_array_value_to_string::<UInt64Type>(column, row),
-            _ => Err(ArrowError::InvalidArgumentError(format!(
-                "Pretty printing not supported for {:?} due to index type",
-                column.data_type()
-            ))),
-        },
-        DataType::FixedSizeList(_, _) => make_string_from_fixed_size_list!(column, row),
-        DataType::Struct(_) => {
-            let st = column
-                .as_any()
-                .downcast_ref::<array::StructArray>()
-                .ok_or_else(|| {
-                    ArrowError::InvalidArgumentError(
-                        "Repl error: could not convert struct column to struct array."
-                            .to_string(),
-                    )
-                })?;
-
-            let mut s = String::new();
-            s.push('{');
-            let mut kv_iter = st.columns().into_iter().zip(st.column_names().into_iter());
-            if let Some((col, name)) = kv_iter.next() {
-                append_struct_field_string(&mut s, name, col, row)?;
-            }
-            for (col, name) in kv_iter {
-                s.push_str(", ");
-                append_struct_field_string(&mut s, name, col, row)?;
-            }
-            s.push('}');
-
-            Ok(s)
-        }
-        DataType::Union(field_vec, type_ids, mode) => {
-            union_to_string(column, row, field_vec, type_ids, mode)
-        }
-        _ => Err(ArrowError::InvalidArgumentError(format!(
-            "Pretty printing not implemented for {:?} type",
-            column.data_type()
-        ))),
-    }
-}
-
-/// Converts the value of the union array at `row` to a String
-fn union_to_string(
-    column: &array::ArrayRef,
-    row: usize,
-    fields: &[Field],
-    type_ids: &[i8],
-    mode: &UnionMode,
-) -> Result<String> {
-    let list = column
-        .as_any()
-        .downcast_ref::<array::UnionArray>()
-        .ok_or_else(|| {
-            ArrowError::InvalidArgumentError(
-                "Repl error: could not convert union column to union array.".to_string(),
-            )
-        })?;
-    let type_id = list.type_id(row);
-    let field_idx = type_ids.iter().position(|t| t == &type_id).ok_or_else(|| {
-        ArrowError::InvalidArgumentError(format!(
-            "Repl error: could not get field name for type id: {} in union array.",
-            type_id,
-        ))
-    })?;
-    let name = fields.get(field_idx).unwrap().name();
-
-    let value = array_value_to_string(
-        list.child(type_id),
-        match mode {
-            UnionMode::Dense => list.value_offset(row) as usize,
-            UnionMode::Sparse => row,
-        },
-    )?;
-
-    Ok(format!("{{{}={}}}", name, value))
-}
-/// Converts the value of the dictionary array at `row` to a String
-fn dict_array_value_to_string<K: ArrowPrimitiveType>(
-    colum: &array::ArrayRef,
-    row: usize,
-) -> Result<String> {
-    let dict_array = colum.as_any().downcast_ref::<DictionaryArray<K>>().unwrap();
-
-    let keys_array = dict_array.keys();
-
-    if keys_array.is_null(row) {
-        return Ok(String::from(""));
-    }
-
-    let dict_index = keys_array.value(row).to_usize().ok_or_else(|| {
-        ArrowError::InvalidArgumentError(format!(
-            "Can not convert value {:?} at index {:?} to usize for string conversion.",
-            keys_array.value(row),
-            row
-        ))
-    })?;
-
-    array_value_to_string(dict_array.values(), dict_index)
-}
diff --git a/arrow/src/util/mod.rs b/arrow/src/util/mod.rs
index 1ee05d8a02c7..7f7257100cd9 100644
--- a/arrow/src/util/mod.rs
+++ b/arrow/src/util/mod.rs
@@ -15,26 +15,19 @@
 // specific language governing permissions and limitations
 // under the License.
 
+pub use arrow_buffer::{bit_chunk_iterator, bit_util};
+
+pub use arrow_data::bit_iterator;
+pub use arrow_data::bit_mask;
+
 #[cfg(feature = "test_utils")]
 pub mod bench_util;
-pub mod bit_chunk_iterator;
-pub mod bit_iterator;
-pub(crate) mod bit_mask;
-pub mod bit_util;
 #[cfg(feature = "test_utils")]
 pub mod data_gen;
-pub mod display;
-#[cfg(any(test, feature = "test_utils"))]
-pub mod integration_util;
 #[cfg(feature = "prettyprint")]
-pub mod pretty;
-pub(crate) mod serialization;
+pub use arrow_cast::pretty;
 pub mod string_writer;
 #[cfg(any(test, feature = "test_utils"))]
 pub mod test_util;
 
-mod trusted_len;
-pub(crate) use trusted_len::trusted_len_unzip;
-
-pub mod decimal;
-pub(crate) mod reader_parser;
+pub use arrow_cast::display;
diff --git a/arrow/src/util/reader_parser.rs b/arrow/src/util/reader_parser.rs
deleted file mode 100644
index 6b6f24f82a43..000000000000
--- a/arrow/src/util/reader_parser.rs
+++ /dev/null
@@ -1,144 +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.
-
-use crate::compute::kernels::cast_utils::string_to_timestamp_nanos;
-use crate::datatypes::*;
-
-/// Specialized parsing implementations
-/// used by csv and json reader
-pub(crate) trait Parser: ArrowPrimitiveType {
-    fn parse(string: &str) -> Option<Self::Native> {
-        string.parse::<Self::Native>().ok()
-    }
-
-    fn parse_formatted(string: &str, _format: &str) -> Option<Self::Native> {
-        Self::parse(string)
-    }
-}
-
-impl Parser for Float32Type {
-    fn parse(string: &str) -> Option<f32> {
-        lexical_core::parse(string.as_bytes()).ok()
-    }
-}
-
-impl Parser for Float64Type {
-    fn parse(string: &str) -> Option<f64> {
-        lexical_core::parse(string.as_bytes()).ok()
-    }
-}
-
-impl Parser for UInt64Type {}
-
-impl Parser for UInt32Type {}
-
-impl Parser for UInt16Type {}
-
-impl Parser for UInt8Type {}
-
-impl Parser for Int64Type {}
-
-impl Parser for Int32Type {}
-
-impl Parser for Int16Type {}
-
-impl Parser for Int8Type {}
-
-impl Parser for TimestampNanosecondType {
-    fn parse(string: &str) -> Option<i64> {
-        string_to_timestamp_nanos(string).ok()
-    }
-}
-
-impl Parser for TimestampMicrosecondType {
-    fn parse(string: &str) -> Option<i64> {
-        let nanos = string_to_timestamp_nanos(string).ok();
-        nanos.map(|x| x / 1000)
-    }
-}
-
-impl Parser for TimestampMillisecondType {
-    fn parse(string: &str) -> Option<i64> {
-        let nanos = string_to_timestamp_nanos(string).ok();
-        nanos.map(|x| x / 1_000_000)
-    }
-}
-
-impl Parser for TimestampSecondType {
-    fn parse(string: &str) -> Option<i64> {
-        let nanos = string_to_timestamp_nanos(string).ok();
-        nanos.map(|x| x / 1_000_000_000)
-    }
-}
-
-impl Parser for Time64NanosecondType {}
-
-impl Parser for Time64MicrosecondType {}
-
-impl Parser for Time32MillisecondType {}
-
-impl Parser for Time32SecondType {}
-
-/// Number of days between 0001-01-01 and 1970-01-01
-const EPOCH_DAYS_FROM_CE: i32 = 719_163;
-
-impl Parser for Date32Type {
-    fn parse(string: &str) -> Option<i32> {
-        use chrono::Datelike;
-        let date = string.parse::<chrono::NaiveDate>().ok()?;
-        Self::Native::from_i32(date.num_days_from_ce() - EPOCH_DAYS_FROM_CE)
-    }
-
-    fn parse_formatted(string: &str, format: &str) -> Option<i32> {
-        use chrono::Datelike;
-        let date = chrono::NaiveDate::parse_from_str(string, format).ok()?;
-        Self::Native::from_i32(date.num_days_from_ce() - EPOCH_DAYS_FROM_CE)
-    }
-}
-
-impl Parser for Date64Type {
-    fn parse(string: &str) -> Option<i64> {
-        let date_time = string.parse::<chrono::NaiveDateTime>().ok()?;
-        Self::Native::from_i64(date_time.timestamp_millis())
-    }
-
-    fn parse_formatted(string: &str, format: &str) -> Option<i64> {
-        use chrono::format::Fixed;
-        use chrono::format::StrftimeItems;
-        let fmt = StrftimeItems::new(format);
-        let has_zone = fmt.into_iter().any(|item| match item {
-            chrono::format::Item::Fixed(fixed_item) => matches!(
-                fixed_item,
-                Fixed::RFC2822
-                    | Fixed::RFC3339
-                    | Fixed::TimezoneName
-                    | Fixed::TimezoneOffsetColon
-                    | Fixed::TimezoneOffsetColonZ
-                    | Fixed::TimezoneOffset
-                    | Fixed::TimezoneOffsetZ
-            ),
-            _ => false,
-        });
-        if has_zone {
-            let date_time = chrono::DateTime::parse_from_str(string, format).ok()?;
-            Self::Native::from_i64(date_time.timestamp_millis())
-        } else {
-            let date_time = chrono::NaiveDateTime::parse_from_str(string, format).ok()?;
-            Self::Native::from_i64(date_time.timestamp_millis())
-        }
-    }
-}
diff --git a/arrow/src/util/test_util.rs b/arrow/src/util/test_util.rs
index cae148a53d5c..fd051dea1a8d 100644
--- a/arrow/src/util/test_util.rs
+++ b/arrow/src/util/test_util.rs
@@ -78,7 +78,7 @@ pub fn get_temp_file(file_name: &str, content: &[u8]) -> fs::File {
 pub fn arrow_test_data() -> String {
     match get_data_dir("ARROW_TEST_DATA", "../testing/data") {
         Ok(pb) => pb.display().to_string(),
-        Err(err) => panic!("failed to get arrow data dir: {}", err),
+        Err(err) => panic!("failed to get arrow data dir: {err}"),
     }
 }
 
@@ -100,7 +100,7 @@ pub fn arrow_test_data() -> String {
 pub fn parquet_test_data() -> String {
     match get_data_dir("PARQUET_TEST_DATA", "../parquet-testing/data") {
         Ok(pb) => pb.display().to_string(),
-        Err(err) => panic!("failed to get parquet data dir: {}", err),
+        Err(err) => panic!("failed to get parquet data dir: {err}"),
     }
 }
 
@@ -167,8 +167,8 @@ pub struct BadIterator<T> {
 }
 
 impl<T> BadIterator<T> {
-    /// Create a new iterator for <limit> items, but that reports to
-    /// produce <claimed> items. Must provide at least 1 item.
+    /// Create a new iterator for `<limit>` items, but that reports to
+    /// produce `<claimed>` items. Must provide at least 1 item.
     pub fn new(limit: usize, claimed: usize, items: Vec<T>) -> Self {
         assert!(!items.is_empty());
         Self {
@@ -196,7 +196,7 @@ impl<T: Clone> Iterator for BadIterator<T> {
 
     /// report whatever the iterator says to
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, Some(self.claimed as usize))
+        (0, Some(self.claimed))
     }
 }
 
diff --git a/arrow/test/data/basic.json b/arrow/test/data/basic.json
deleted file mode 100644
index 556c39c46be9..000000000000
--- a/arrow/test/data/basic.json
+++ /dev/null
@@ -1,12 +0,0 @@
-{"a":1, "b":2.0, "c":false, "d":"4", "e":"1970-1-2"}
-{"a":-10, "b":-3.5, "c":true, "d":"4", "e": "1969-12-31"}
-{"a":2, "b":0.6, "c":false, "d":"text", "e": "1970-01-02 11:11:11"}
-{"a":1, "b":2.0, "c":false, "d":"4"}
-{"a":7, "b":-3.5, "c":true, "d":"4"}
-{"a":1, "b":0.6, "c":false, "d":"text"}
-{"a":1, "b":2.0, "c":false, "d":"4"}
-{"a":5, "b":-3.5, "c":true, "d":"4"}
-{"a":1, "b":0.6, "c":false, "d":"text"}
-{"a":1, "b":2.0, "c":false, "d":"4"}
-{"a":1, "b":-3.5, "c":true, "d":"4"}
-{"a":100000000000000, "b":0.6, "c":false, "d":"text"}
diff --git a/arrow/tests/arithmetic.rs b/arrow/tests/arithmetic.rs
new file mode 100644
index 000000000000..59a162ef6dc0
--- /dev/null
+++ b/arrow/tests/arithmetic.rs
@@ -0,0 +1,190 @@
+// 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.
+
+use arrow_arith::numeric::{add, sub};
+use arrow_arith::temporal::{date_part, DatePart};
+use arrow_array::cast::AsArray;
+use arrow_array::temporal_conversions::as_datetime_with_timezone;
+use arrow_array::timezone::Tz;
+use arrow_array::types::*;
+use arrow_array::*;
+use chrono::{DateTime, TimeZone};
+
+#[test]
+fn test_temporal_array_timestamp_hour_with_timezone_using_chrono_tz() {
+    let a =
+        TimestampSecondArray::from(vec![60 * 60 * 10]).with_timezone("Asia/Kolkata".to_string());
+    let b = date_part(&a, DatePart::Hour).unwrap();
+    let b = b.as_primitive::<Int32Type>();
+    assert_eq!(15, b.value(0));
+}
+
+#[test]
+fn test_temporal_array_timestamp_hour_with_dst_timezone_using_chrono_tz() {
+    //
+    // 1635577147 converts to 2021-10-30 17:59:07 in time zone Australia/Sydney (AEDT)
+    // The offset (difference to UTC) is +11:00. Note that daylight savings is in effect on 2021-10-30.
+    // When daylight savings is not in effect, Australia/Sydney has an offset difference of +10:00.
+
+    let a = TimestampMillisecondArray::from(vec![Some(1635577147000)])
+        .with_timezone("Australia/Sydney".to_string());
+    let b = date_part(&a, DatePart::Hour).unwrap();
+    let b = b.as_primitive::<Int32Type>();
+    assert_eq!(17, b.value(0));
+}
+
+fn test_timestamp_with_timezone_impl<T: ArrowTimestampType>(tz_str: &str) {
+    let tz: Tz = tz_str.parse().unwrap();
+
+    let transform_array = |x: &dyn Array| -> Vec<DateTime<_>> {
+        x.as_primitive::<T>()
+            .values()
+            .into_iter()
+            .map(|x| as_datetime_with_timezone::<T>(*x, tz).unwrap())
+            .collect()
+    };
+
+    let values = vec![
+        tz.with_ymd_and_hms(1970, 1, 28, 23, 0, 0)
+            .unwrap()
+            .naive_utc(),
+        tz.with_ymd_and_hms(1970, 1, 1, 0, 0, 0)
+            .unwrap()
+            .naive_utc(),
+        tz.with_ymd_and_hms(2010, 4, 1, 4, 0, 20)
+            .unwrap()
+            .naive_utc(),
+        tz.with_ymd_and_hms(1960, 1, 30, 4, 23, 20)
+            .unwrap()
+            .naive_utc(),
+        tz.with_ymd_and_hms(2023, 3, 25, 14, 0, 0)
+            .unwrap()
+            .naive_utc(),
+    ]
+    .into_iter()
+    .map(|x| T::make_value(x).unwrap())
+    .collect();
+
+    let a = PrimitiveArray::<T>::new(values, None).with_timezone(tz_str);
+
+    // IntervalYearMonth
+    let b = IntervalYearMonthArray::from(vec![
+        IntervalYearMonthType::make_value(0, 1),
+        IntervalYearMonthType::make_value(5, 34),
+        IntervalYearMonthType::make_value(-2, 4),
+        IntervalYearMonthType::make_value(7, -4),
+        IntervalYearMonthType::make_value(0, 1),
+    ]);
+    let r1 = add(&a, &b).unwrap();
+    assert_eq!(
+        &transform_array(r1.as_ref()),
+        &[
+            tz.with_ymd_and_hms(1970, 2, 28, 23, 0, 0).unwrap(),
+            tz.with_ymd_and_hms(1977, 11, 1, 0, 0, 0).unwrap(),
+            tz.with_ymd_and_hms(2008, 8, 1, 4, 0, 20).unwrap(),
+            tz.with_ymd_and_hms(1966, 9, 30, 4, 23, 20).unwrap(),
+            tz.with_ymd_and_hms(2023, 4, 25, 14, 0, 0).unwrap(),
+        ]
+    );
+
+    let r2 = sub(&r1, &b).unwrap();
+    assert_eq!(r2.as_ref(), &a);
+
+    // IntervalDayTime
+    let b = IntervalDayTimeArray::from(vec![
+        IntervalDayTimeType::make_value(0, 0),
+        IntervalDayTimeType::make_value(5, 454000),
+        IntervalDayTimeType::make_value(-34, 0),
+        IntervalDayTimeType::make_value(7, -4000),
+        IntervalDayTimeType::make_value(1, 0),
+    ]);
+    let r3 = add(&a, &b).unwrap();
+    assert_eq!(
+        &transform_array(r3.as_ref()),
+        &[
+            tz.with_ymd_and_hms(1970, 1, 28, 23, 0, 0).unwrap(),
+            tz.with_ymd_and_hms(1970, 1, 6, 0, 7, 34).unwrap(),
+            tz.with_ymd_and_hms(2010, 2, 26, 4, 0, 20).unwrap(),
+            tz.with_ymd_and_hms(1960, 2, 6, 4, 23, 16).unwrap(),
+            tz.with_ymd_and_hms(2023, 3, 26, 14, 0, 0).unwrap(),
+        ]
+    );
+
+    let r4 = sub(&r3, &b).unwrap();
+    assert_eq!(r4.as_ref(), &a);
+
+    // IntervalMonthDayNano
+    let b = IntervalMonthDayNanoArray::from(vec![
+        IntervalMonthDayNanoType::make_value(1, 0, 0),
+        IntervalMonthDayNanoType::make_value(344, 34, -43_000_000_000),
+        IntervalMonthDayNanoType::make_value(-593, -33, 13_000_000_000),
+        IntervalMonthDayNanoType::make_value(5, 2, 493_000_000_000),
+        IntervalMonthDayNanoType::make_value(1, 0, 0),
+    ]);
+    let r5 = add(&a, &b).unwrap();
+    assert_eq!(
+        &transform_array(r5.as_ref()),
+        &[
+            tz.with_ymd_and_hms(1970, 2, 28, 23, 0, 0).unwrap(),
+            tz.with_ymd_and_hms(1998, 10, 4, 23, 59, 17).unwrap(),
+            tz.with_ymd_and_hms(1960, 9, 29, 4, 0, 33).unwrap(),
+            tz.with_ymd_and_hms(1960, 7, 2, 4, 31, 33).unwrap(),
+            tz.with_ymd_and_hms(2023, 4, 25, 14, 0, 0).unwrap(),
+        ]
+    );
+
+    let r6 = sub(&r5, &b).unwrap();
+    assert_eq!(
+        &transform_array(r6.as_ref()),
+        &[
+            tz.with_ymd_and_hms(1970, 1, 28, 23, 0, 0).unwrap(),
+            tz.with_ymd_and_hms(1970, 1, 2, 0, 0, 0).unwrap(),
+            tz.with_ymd_and_hms(2010, 4, 2, 4, 0, 20).unwrap(),
+            tz.with_ymd_and_hms(1960, 1, 31, 4, 23, 20).unwrap(),
+            tz.with_ymd_and_hms(2023, 3, 25, 14, 0, 0).unwrap(),
+        ]
+    );
+}
+
+#[test]
+fn test_timestamp_with_offset_timezone() {
+    let timezones = ["+00:00", "+01:00", "-01:00", "+03:30"];
+    for timezone in timezones {
+        test_timestamp_with_timezone_impl::<TimestampSecondType>(timezone);
+        test_timestamp_with_timezone_impl::<TimestampMillisecondType>(timezone);
+        test_timestamp_with_timezone_impl::<TimestampMicrosecondType>(timezone);
+        test_timestamp_with_timezone_impl::<TimestampNanosecondType>(timezone);
+    }
+}
+
+#[test]
+fn test_timestamp_with_timezone() {
+    let timezones = [
+        "Europe/Paris",
+        "Europe/London",
+        "Africa/Bamako",
+        "America/Dominica",
+        "Asia/Seoul",
+        "Asia/Shanghai",
+    ];
+    for timezone in timezones {
+        test_timestamp_with_timezone_impl::<TimestampSecondType>(timezone);
+        test_timestamp_with_timezone_impl::<TimestampMillisecondType>(timezone);
+        test_timestamp_with_timezone_impl::<TimestampMicrosecondType>(timezone);
+        test_timestamp_with_timezone_impl::<TimestampNanosecondType>(timezone);
+    }
+}
diff --git a/arrow/tests/array_cast.rs b/arrow/tests/array_cast.rs
new file mode 100644
index 000000000000..c73f4f50ac01
--- /dev/null
+++ b/arrow/tests/array_cast.rs
@@ -0,0 +1,593 @@
+// 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.
+
+use arrow_array::builder::{PrimitiveDictionaryBuilder, StringDictionaryBuilder, UnionBuilder};
+use arrow_array::cast::AsArray;
+use arrow_array::types::{
+    ArrowDictionaryKeyType, Decimal128Type, Decimal256Type, Int16Type, Int32Type, Int64Type,
+    Int8Type, TimestampMicrosecondType, UInt16Type, UInt32Type, UInt64Type, UInt8Type,
+};
+use arrow_array::{
+    Array, ArrayRef, ArrowPrimitiveType, BinaryArray, BooleanArray, Date32Array, Date64Array,
+    Decimal128Array, DurationMicrosecondArray, DurationMillisecondArray, DurationNanosecondArray,
+    DurationSecondArray, FixedSizeBinaryArray, FixedSizeListArray, Float16Array, Float32Array,
+    Float64Array, Int16Array, Int32Array, Int64Array, Int8Array, IntervalDayTimeArray,
+    IntervalMonthDayNanoArray, IntervalYearMonthArray, LargeBinaryArray, LargeListArray,
+    LargeStringArray, ListArray, NullArray, PrimitiveArray, StringArray, StructArray,
+    Time32MillisecondArray, Time32SecondArray, Time64MicrosecondArray, Time64NanosecondArray,
+    TimestampMicrosecondArray, TimestampMillisecondArray, TimestampNanosecondArray,
+    TimestampSecondArray, UInt16Array, UInt32Array, UInt64Array, UInt8Array, UnionArray,
+};
+use arrow_buffer::{i256, Buffer};
+use arrow_cast::pretty::pretty_format_columns;
+use arrow_cast::{can_cast_types, cast};
+use arrow_data::ArrayData;
+use arrow_schema::{
+    ArrowError, DataType, Field, Fields, IntervalUnit, TimeUnit, UnionFields, UnionMode,
+};
+use half::f16;
+use std::sync::Arc;
+
+#[test]
+fn test_cast_timestamp_to_string() {
+    let a = TimestampMillisecondArray::from(vec![Some(864000000005), Some(1545696000001), None])
+        .with_timezone("UTC".to_string());
+    let array = Arc::new(a) as ArrayRef;
+    let b = cast(&array, &DataType::Utf8).unwrap();
+    let c = b.as_any().downcast_ref::<StringArray>().unwrap();
+    assert_eq!(&DataType::Utf8, c.data_type());
+    assert_eq!("1997-05-19T00:00:00.005Z", c.value(0));
+    assert_eq!("2018-12-25T00:00:00.001Z", c.value(1));
+    assert!(c.is_null(2));
+}
+
+// See: https://en.wikipedia.org/wiki/List_of_tz_database_time_zones for list of valid
+// timezones
+
+// Cast Timestamp(_, None) -> Timestamp(_, Some(timezone))
+#[test]
+fn test_cast_timestamp_with_timezone_daylight_1() {
+    let string_array: Arc<dyn Array> = Arc::new(StringArray::from(vec![
+        // This is winter in New York so daylight saving is not in effect
+        // UTC offset is -05:00
+        Some("2000-01-01T00:00:00.123456789"),
+        // This is summer in New York so daylight saving is in effect
+        // UTC offset is -04:00
+        Some("2010-07-01T00:00:00.123456789"),
+        None,
+    ]));
+    let to_type = DataType::Timestamp(TimeUnit::Nanosecond, None);
+    let timestamp_array = cast(&string_array, &to_type).unwrap();
+
+    let to_type = DataType::Timestamp(TimeUnit::Microsecond, Some("America/New_York".into()));
+    let timestamp_array = cast(&timestamp_array, &to_type).unwrap();
+
+    let string_array = cast(&timestamp_array, &DataType::Utf8).unwrap();
+    let result = string_array.as_string::<i32>();
+    assert_eq!("2000-01-01T00:00:00.123456-05:00", result.value(0));
+    assert_eq!("2010-07-01T00:00:00.123456-04:00", result.value(1));
+    assert!(result.is_null(2));
+}
+
+// Cast Timestamp(_, Some(timezone)) -> Timestamp(_, None)
+#[test]
+fn test_cast_timestamp_with_timezone_daylight_2() {
+    let string_array: Arc<dyn Array> = Arc::new(StringArray::from(vec![
+        Some("2000-01-01T07:00:00.123456789"),
+        Some("2010-07-01T07:00:00.123456789"),
+        None,
+    ]));
+    let to_type = DataType::Timestamp(TimeUnit::Millisecond, Some("America/New_York".into()));
+    let timestamp_array = cast(&string_array, &to_type).unwrap();
+
+    // Check intermediate representation is correct
+    let string_array = cast(&timestamp_array, &DataType::Utf8).unwrap();
+    let result = string_array.as_string::<i32>();
+    assert_eq!("2000-01-01T07:00:00.123-05:00", result.value(0));
+    assert_eq!("2010-07-01T07:00:00.123-04:00", result.value(1));
+    assert!(result.is_null(2));
+
+    let to_type = DataType::Timestamp(TimeUnit::Nanosecond, None);
+    let timestamp_array = cast(&timestamp_array, &to_type).unwrap();
+
+    let string_array = cast(&timestamp_array, &DataType::Utf8).unwrap();
+    let result = string_array.as_string::<i32>();
+    assert_eq!("2000-01-01T12:00:00.123", result.value(0));
+    assert_eq!("2010-07-01T11:00:00.123", result.value(1));
+    assert!(result.is_null(2));
+}
+
+// Cast Timestamp(_, Some(timezone)) -> Timestamp(_, Some(timezone))
+#[test]
+fn test_cast_timestamp_with_timezone_daylight_3() {
+    let string_array: Arc<dyn Array> = Arc::new(StringArray::from(vec![
+        // Winter in New York, summer in Sydney
+        // UTC offset is -05:00 (New York) and +11:00 (Sydney)
+        Some("2000-01-01T00:00:00.123456789"),
+        // Summer in New York, winter in Sydney
+        // UTC offset is -04:00 (New York) and +10:00 (Sydney)
+        Some("2010-07-01T00:00:00.123456789"),
+        None,
+    ]));
+    let to_type = DataType::Timestamp(TimeUnit::Microsecond, Some("America/New_York".into()));
+    let timestamp_array = cast(&string_array, &to_type).unwrap();
+
+    // Check intermediate representation is correct
+    let string_array = cast(&timestamp_array, &DataType::Utf8).unwrap();
+    let result = string_array.as_string::<i32>();
+    assert_eq!("2000-01-01T00:00:00.123456-05:00", result.value(0));
+    assert_eq!("2010-07-01T00:00:00.123456-04:00", result.value(1));
+    assert!(result.is_null(2));
+
+    let to_type = DataType::Timestamp(TimeUnit::Second, Some("Australia/Sydney".into()));
+    let timestamp_array = cast(&timestamp_array, &to_type).unwrap();
+
+    let string_array = cast(&timestamp_array, &DataType::Utf8).unwrap();
+    let result = string_array.as_string::<i32>();
+    assert_eq!("2000-01-01T16:00:00+11:00", result.value(0));
+    assert_eq!("2010-07-01T14:00:00+10:00", result.value(1));
+    assert!(result.is_null(2));
+}
+
+#[test]
+#[cfg_attr(miri, ignore)] // running forever
+fn test_can_cast_types() {
+    // this function attempts to ensure that can_cast_types stays
+    // in sync with cast.  It simply tries all combinations of
+    // types and makes sure that if `can_cast_types` returns
+    // true, so does `cast`
+
+    let all_types = get_all_types();
+
+    for array in get_arrays_of_all_types() {
+        for to_type in &all_types {
+            println!("Test casting {:?} --> {:?}", array.data_type(), to_type);
+            let cast_result = cast(&array, to_type);
+            let reported_cast_ability = can_cast_types(array.data_type(), to_type);
+
+            // check for mismatch
+            match (cast_result, reported_cast_ability) {
+                (Ok(_), false) => {
+                    panic!("Was able to cast array {:?} from {:?} to {:?} but can_cast_types reported false",
+                           array, array.data_type(), to_type)
+                }
+                (Err(e), true) => {
+                    panic!("Was not able to cast array {:?} from {:?} to {:?} but can_cast_types reported true. \
+                                Error was {:?}",
+                           array, array.data_type(), to_type, e)
+                }
+                // otherwise it was a match
+                _ => {}
+            };
+        }
+    }
+}
+
+/// Create instances of arrays with varying types for cast tests
+fn get_arrays_of_all_types() -> Vec<ArrayRef> {
+    let tz_name = String::from("+08:00");
+    let binary_data: Vec<&[u8]> = vec![b"foo", b"bar"];
+    vec![
+        Arc::new(BinaryArray::from(binary_data.clone())),
+        Arc::new(LargeBinaryArray::from(binary_data.clone())),
+        make_dictionary_primitive::<Int8Type, Int32Type>(vec![1, 2]),
+        make_dictionary_primitive::<Int16Type, Int32Type>(vec![1, 2]),
+        make_dictionary_primitive::<Int32Type, Int32Type>(vec![1, 2]),
+        make_dictionary_primitive::<Int64Type, Int32Type>(vec![1, 2]),
+        make_dictionary_primitive::<UInt8Type, Int32Type>(vec![1, 2]),
+        make_dictionary_primitive::<UInt16Type, Int32Type>(vec![1, 2]),
+        make_dictionary_primitive::<UInt32Type, Int32Type>(vec![1, 2]),
+        make_dictionary_primitive::<UInt64Type, Int32Type>(vec![1, 2]),
+        make_dictionary_utf8::<Int8Type>(),
+        make_dictionary_utf8::<Int16Type>(),
+        make_dictionary_utf8::<Int32Type>(),
+        make_dictionary_utf8::<Int64Type>(),
+        make_dictionary_utf8::<UInt8Type>(),
+        make_dictionary_utf8::<UInt16Type>(),
+        make_dictionary_utf8::<UInt32Type>(),
+        make_dictionary_utf8::<UInt64Type>(),
+        Arc::new(make_list_array()),
+        Arc::new(make_large_list_array()),
+        Arc::new(make_fixed_size_list_array()),
+        Arc::new(make_fixed_size_binary_array()),
+        Arc::new(StructArray::from(vec![
+            (
+                Arc::new(Field::new("a", DataType::Boolean, false)),
+                Arc::new(BooleanArray::from(vec![false, false, true, true])) as Arc<dyn Array>,
+            ),
+            (
+                Arc::new(Field::new("b", DataType::Int32, false)),
+                Arc::new(Int32Array::from(vec![42, 28, 19, 31])),
+            ),
+        ])),
+        Arc::new(make_union_array()),
+        Arc::new(NullArray::new(10)),
+        Arc::new(StringArray::from(vec!["foo", "bar"])),
+        Arc::new(LargeStringArray::from(vec!["foo", "bar"])),
+        Arc::new(BooleanArray::from(vec![true, false])),
+        Arc::new(Int8Array::from(vec![1, 2])),
+        Arc::new(Int16Array::from(vec![1, 2])),
+        Arc::new(Int32Array::from(vec![1, 2])),
+        Arc::new(Int64Array::from(vec![1, 2])),
+        Arc::new(UInt8Array::from(vec![1, 2])),
+        Arc::new(UInt16Array::from(vec![1, 2])),
+        Arc::new(UInt32Array::from(vec![1, 2])),
+        Arc::new(UInt64Array::from(vec![1, 2])),
+        Arc::new(
+            [Some(f16::from_f64(1.0)), Some(f16::from_f64(2.0))]
+                .into_iter()
+                .collect::<Float16Array>(),
+        ),
+        Arc::new(Float32Array::from(vec![1.0, 2.0])),
+        Arc::new(Float64Array::from(vec![1.0, 2.0])),
+        Arc::new(TimestampSecondArray::from(vec![1000, 2000])),
+        Arc::new(TimestampMillisecondArray::from(vec![1000, 2000])),
+        Arc::new(TimestampMicrosecondArray::from(vec![1000, 2000])),
+        Arc::new(TimestampNanosecondArray::from(vec![1000, 2000])),
+        Arc::new(TimestampSecondArray::from(vec![1000, 2000]).with_timezone(tz_name.clone())),
+        Arc::new(TimestampMillisecondArray::from(vec![1000, 2000]).with_timezone(tz_name.clone())),
+        Arc::new(TimestampMicrosecondArray::from(vec![1000, 2000]).with_timezone(tz_name.clone())),
+        Arc::new(TimestampNanosecondArray::from(vec![1000, 2000]).with_timezone(tz_name)),
+        Arc::new(Date32Array::from(vec![1000, 2000])),
+        Arc::new(Date64Array::from(vec![1000, 2000])),
+        Arc::new(Time32SecondArray::from(vec![1000, 2000])),
+        Arc::new(Time32MillisecondArray::from(vec![1000, 2000])),
+        Arc::new(Time64MicrosecondArray::from(vec![1000, 2000])),
+        Arc::new(Time64NanosecondArray::from(vec![1000, 2000])),
+        Arc::new(IntervalYearMonthArray::from(vec![1000, 2000])),
+        Arc::new(IntervalDayTimeArray::from(vec![1000, 2000])),
+        Arc::new(IntervalMonthDayNanoArray::from(vec![1000, 2000])),
+        Arc::new(DurationSecondArray::from(vec![1000, 2000])),
+        Arc::new(DurationMillisecondArray::from(vec![1000, 2000])),
+        Arc::new(DurationMicrosecondArray::from(vec![1000, 2000])),
+        Arc::new(DurationNanosecondArray::from(vec![1000, 2000])),
+        Arc::new(create_decimal_array(vec![Some(1), Some(2), Some(3)], 38, 0).unwrap()),
+        make_dictionary_primitive::<Int8Type, Decimal128Type>(vec![1, 2]),
+        make_dictionary_primitive::<Int16Type, Decimal128Type>(vec![1, 2]),
+        make_dictionary_primitive::<Int32Type, Decimal128Type>(vec![1, 2]),
+        make_dictionary_primitive::<Int64Type, Decimal128Type>(vec![1, 2]),
+        make_dictionary_primitive::<UInt8Type, Decimal128Type>(vec![1, 2]),
+        make_dictionary_primitive::<UInt16Type, Decimal128Type>(vec![1, 2]),
+        make_dictionary_primitive::<UInt32Type, Decimal128Type>(vec![1, 2]),
+        make_dictionary_primitive::<UInt64Type, Decimal128Type>(vec![1, 2]),
+        make_dictionary_primitive::<Int8Type, Decimal256Type>(vec![
+            i256::from_i128(1),
+            i256::from_i128(2),
+        ]),
+        make_dictionary_primitive::<Int16Type, Decimal256Type>(vec![
+            i256::from_i128(1),
+            i256::from_i128(2),
+        ]),
+        make_dictionary_primitive::<Int32Type, Decimal256Type>(vec![
+            i256::from_i128(1),
+            i256::from_i128(2),
+        ]),
+        make_dictionary_primitive::<Int64Type, Decimal256Type>(vec![
+            i256::from_i128(1),
+            i256::from_i128(2),
+        ]),
+        make_dictionary_primitive::<UInt8Type, Decimal256Type>(vec![
+            i256::from_i128(1),
+            i256::from_i128(2),
+        ]),
+        make_dictionary_primitive::<UInt16Type, Decimal256Type>(vec![
+            i256::from_i128(1),
+            i256::from_i128(2),
+        ]),
+        make_dictionary_primitive::<UInt32Type, Decimal256Type>(vec![
+            i256::from_i128(1),
+            i256::from_i128(2),
+        ]),
+        make_dictionary_primitive::<UInt64Type, Decimal256Type>(vec![
+            i256::from_i128(1),
+            i256::from_i128(2),
+        ]),
+    ]
+}
+
+fn make_fixed_size_list_array() -> FixedSizeListArray {
+    // Construct a value array
+    let value_data = ArrayData::builder(DataType::Int32)
+        .len(10)
+        .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7, 8, 9]))
+        .build()
+        .unwrap();
+
+    // Construct a fixed size list array from the above two
+    let list_data_type =
+        DataType::FixedSizeList(Arc::new(Field::new("item", DataType::Int32, true)), 2);
+    let list_data = ArrayData::builder(list_data_type)
+        .len(5)
+        .add_child_data(value_data)
+        .build()
+        .unwrap();
+    FixedSizeListArray::from(list_data)
+}
+
+fn make_fixed_size_binary_array() -> FixedSizeBinaryArray {
+    let values: [u8; 15] = *b"hellotherearrow";
+
+    let array_data = ArrayData::builder(DataType::FixedSizeBinary(5))
+        .len(3)
+        .add_buffer(Buffer::from(&values[..]))
+        .build()
+        .unwrap();
+    FixedSizeBinaryArray::from(array_data)
+}
+
+fn make_list_array() -> ListArray {
+    // Construct a value array
+    let value_data = ArrayData::builder(DataType::Int32)
+        .len(8)
+        .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+        .build()
+        .unwrap();
+
+    // Construct a buffer for value offsets, for the nested array:
+    //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+    let value_offsets = Buffer::from_slice_ref([0, 3, 6, 8]);
+
+    // Construct a list array from the above two
+    let list_data_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, true)));
+    let list_data = ArrayData::builder(list_data_type)
+        .len(3)
+        .add_buffer(value_offsets)
+        .add_child_data(value_data)
+        .build()
+        .unwrap();
+    ListArray::from(list_data)
+}
+
+fn make_large_list_array() -> LargeListArray {
+    // Construct a value array
+    let value_data = ArrayData::builder(DataType::Int32)
+        .len(8)
+        .add_buffer(Buffer::from_slice_ref([0, 1, 2, 3, 4, 5, 6, 7]))
+        .build()
+        .unwrap();
+
+    // Construct a buffer for value offsets, for the nested array:
+    //  [[0, 1, 2], [3, 4, 5], [6, 7]]
+    let value_offsets = Buffer::from_slice_ref([0i64, 3, 6, 8]);
+
+    // Construct a list array from the above two
+    let list_data_type = DataType::LargeList(Arc::new(Field::new("item", DataType::Int32, true)));
+    let list_data = ArrayData::builder(list_data_type)
+        .len(3)
+        .add_buffer(value_offsets)
+        .add_child_data(value_data)
+        .build()
+        .unwrap();
+    LargeListArray::from(list_data)
+}
+
+fn make_union_array() -> UnionArray {
+    let mut builder = UnionBuilder::with_capacity_dense(7);
+    builder.append::<Int32Type>("a", 1).unwrap();
+    builder.append::<Int64Type>("b", 2).unwrap();
+    builder.build().unwrap()
+}
+
+/// Creates a dictionary with primitive dictionary values, and keys of type K
+/// and values of type V
+fn make_dictionary_primitive<K: ArrowDictionaryKeyType, V: ArrowPrimitiveType>(
+    values: Vec<V::Native>,
+) -> ArrayRef {
+    // Pick Int32 arbitrarily for dictionary values
+    let mut b: PrimitiveDictionaryBuilder<K, V> = PrimitiveDictionaryBuilder::new();
+    values.iter().for_each(|v| {
+        b.append(*v).unwrap();
+    });
+    Arc::new(b.finish())
+}
+
+/// Creates a dictionary with utf8 values, and keys of type K
+fn make_dictionary_utf8<K: ArrowDictionaryKeyType>() -> ArrayRef {
+    // Pick Int32 arbitrarily for dictionary values
+    let mut b: StringDictionaryBuilder<K> = StringDictionaryBuilder::new();
+    b.append("foo").unwrap();
+    b.append("bar").unwrap();
+    Arc::new(b.finish())
+}
+
+fn create_decimal_array(
+    array: Vec<Option<i128>>,
+    precision: u8,
+    scale: i8,
+) -> Result<Decimal128Array, ArrowError> {
+    array
+        .into_iter()
+        .collect::<Decimal128Array>()
+        .with_precision_and_scale(precision, scale)
+}
+
+// Get a selection of datatypes to try and cast to
+fn get_all_types() -> Vec<DataType> {
+    use DataType::*;
+    let tz_name: Arc<str> = Arc::from("+08:00");
+
+    let mut types = vec![
+        Null,
+        Boolean,
+        Int8,
+        Int16,
+        Int32,
+        UInt64,
+        UInt8,
+        UInt16,
+        UInt32,
+        UInt64,
+        Float16,
+        Float32,
+        Float64,
+        Timestamp(TimeUnit::Second, None),
+        Timestamp(TimeUnit::Millisecond, None),
+        Timestamp(TimeUnit::Microsecond, None),
+        Timestamp(TimeUnit::Nanosecond, None),
+        Timestamp(TimeUnit::Second, Some(tz_name.clone())),
+        Timestamp(TimeUnit::Millisecond, Some(tz_name.clone())),
+        Timestamp(TimeUnit::Microsecond, Some(tz_name.clone())),
+        Timestamp(TimeUnit::Nanosecond, Some(tz_name)),
+        Date32,
+        Date64,
+        Time32(TimeUnit::Second),
+        Time32(TimeUnit::Millisecond),
+        Time64(TimeUnit::Microsecond),
+        Time64(TimeUnit::Nanosecond),
+        Duration(TimeUnit::Second),
+        Duration(TimeUnit::Millisecond),
+        Duration(TimeUnit::Microsecond),
+        Duration(TimeUnit::Nanosecond),
+        Interval(IntervalUnit::YearMonth),
+        Interval(IntervalUnit::DayTime),
+        Interval(IntervalUnit::MonthDayNano),
+        Binary,
+        FixedSizeBinary(3),
+        LargeBinary,
+        Utf8,
+        LargeUtf8,
+        List(Arc::new(Field::new("item", DataType::Int8, true))),
+        List(Arc::new(Field::new("item", DataType::Utf8, true))),
+        FixedSizeList(Arc::new(Field::new("item", DataType::Int8, true)), 10),
+        FixedSizeList(Arc::new(Field::new("item", DataType::Utf8, false)), 10),
+        LargeList(Arc::new(Field::new("item", DataType::Int8, true))),
+        LargeList(Arc::new(Field::new("item", DataType::Utf8, false))),
+        Struct(Fields::from(vec![
+            Field::new("f1", DataType::Int32, true),
+            Field::new("f2", DataType::Utf8, true),
+        ])),
+        Union(
+            UnionFields::new(
+                vec![0, 1],
+                vec![
+                    Field::new("f1", DataType::Int32, false),
+                    Field::new("f2", DataType::Utf8, true),
+                ],
+            ),
+            UnionMode::Dense,
+        ),
+        Decimal128(38, 0),
+    ];
+
+    let dictionary_key_types = vec![Int8, Int16, Int32, Int64, UInt8, UInt16, UInt32, UInt64];
+
+    let mut dictionary_types = dictionary_key_types
+        .into_iter()
+        .flat_map(|key_type| {
+            vec![
+                Dictionary(Box::new(key_type.clone()), Box::new(Int32)),
+                Dictionary(Box::new(key_type.clone()), Box::new(Utf8)),
+                Dictionary(Box::new(key_type.clone()), Box::new(LargeUtf8)),
+                Dictionary(Box::new(key_type.clone()), Box::new(Binary)),
+                Dictionary(Box::new(key_type.clone()), Box::new(LargeBinary)),
+                Dictionary(Box::new(key_type.clone()), Box::new(Decimal128(38, 0))),
+                Dictionary(Box::new(key_type), Box::new(Decimal256(76, 0))),
+            ]
+        })
+        .collect::<Vec<_>>();
+
+    types.append(&mut dictionary_types);
+    types
+}
+
+#[test]
+fn test_timestamp_cast_utf8() {
+    let array: PrimitiveArray<TimestampMicrosecondType> =
+        vec![Some(37800000000), None, Some(86339000000)].into();
+    let out = cast(&(Arc::new(array) as ArrayRef), &DataType::Utf8).unwrap();
+
+    let expected = StringArray::from(vec![
+        Some("1970-01-01T10:30:00"),
+        None,
+        Some("1970-01-01T23:58:59"),
+    ]);
+
+    assert_eq!(
+        out.as_any().downcast_ref::<StringArray>().unwrap(),
+        &expected
+    );
+
+    let array: PrimitiveArray<TimestampMicrosecondType> =
+        vec![Some(37800000000), None, Some(86339000000)].into();
+    let array = array.with_timezone("Australia/Sydney".to_string());
+    let out = cast(&(Arc::new(array) as ArrayRef), &DataType::Utf8).unwrap();
+
+    let expected = StringArray::from(vec![
+        Some("1970-01-01T20:30:00+10:00"),
+        None,
+        Some("1970-01-02T09:58:59+10:00"),
+    ]);
+
+    assert_eq!(
+        out.as_any().downcast_ref::<StringArray>().unwrap(),
+        &expected
+    );
+}
+
+fn format_timezone(tz: &str) -> Result<String, ArrowError> {
+    let array = Arc::new(TimestampSecondArray::from(vec![Some(11111111), None]).with_timezone(tz));
+    Ok(pretty_format_columns("f", &[array])?.to_string())
+}
+
+#[test]
+fn test_pretty_format_timestamp_second_with_utc_timezone() {
+    let table = format_timezone("UTC").unwrap();
+    let expected = vec![
+        "+----------------------+",
+        "| f                    |",
+        "+----------------------+",
+        "| 1970-05-09T14:25:11Z |",
+        "|                      |",
+        "+----------------------+",
+    ];
+    let actual: Vec<&str> = table.lines().collect();
+    assert_eq!(expected, actual, "Actual result:\n\n{actual:#?}\n\n");
+}
+
+#[test]
+fn test_pretty_format_timestamp_second_with_non_utc_timezone() {
+    let table = format_timezone("Asia/Taipei").unwrap();
+
+    let expected = vec![
+        "+---------------------------+",
+        "| f                         |",
+        "+---------------------------+",
+        "| 1970-05-09T22:25:11+08:00 |",
+        "|                           |",
+        "+---------------------------+",
+    ];
+    let actual: Vec<&str> = table.lines().collect();
+    assert_eq!(expected, actual, "Actual result:\n\n{actual:#?}\n\n");
+}
+
+#[test]
+fn test_pretty_format_timestamp_second_with_incorrect_fixed_offset_timezone() {
+    let err = format_timezone("08:00").unwrap_err().to_string();
+    assert_eq!(
+        err,
+        "Parser error: Invalid timezone \"08:00\": '08:00' is not a valid timezone"
+    );
+}
+
+#[test]
+fn test_pretty_format_timestamp_second_with_unknown_timezone() {
+    let err = format_timezone("unknown").unwrap_err().to_string();
+    assert_eq!(
+        err,
+        "Parser error: Invalid timezone \"unknown\": 'unknown' is not a valid timezone"
+    );
+}
diff --git a/arrow/tests/array_equal.rs b/arrow/tests/array_equal.rs
new file mode 100644
index 000000000000..9bd276428880
--- /dev/null
+++ b/arrow/tests/array_equal.rs
@@ -0,0 +1,1255 @@
+// 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.
+
+use arrow::array::{
+    make_array, Array, ArrayRef, BooleanArray, Decimal128Array, FixedSizeBinaryArray,
+    FixedSizeBinaryBuilder, FixedSizeListBuilder, GenericBinaryArray, GenericStringArray,
+    Int32Array, Int32Builder, Int64Builder, ListArray, ListBuilder, NullArray, OffsetSizeTrait,
+    StringArray, StringDictionaryBuilder, StructArray, UnionBuilder,
+};
+use arrow::datatypes::{Int16Type, Int32Type};
+use arrow_array::builder::{StringBuilder, StructBuilder};
+use arrow_array::{DictionaryArray, FixedSizeListArray};
+use arrow_buffer::{Buffer, ToByteSlice};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::{DataType, Field, Fields};
+use std::sync::Arc;
+
+#[test]
+fn test_null_equal() {
+    let a = NullArray::new(12);
+    let b = NullArray::new(12);
+    test_equal(&a, &b, true);
+
+    let b = NullArray::new(10);
+    test_equal(&a, &b, false);
+
+    // Test the case where offset != 0
+
+    let a_slice = a.slice(2, 3);
+    let b_slice = b.slice(1, 3);
+    test_equal(&a_slice, &b_slice, true);
+
+    let a_slice = a.slice(5, 4);
+    let b_slice = b.slice(3, 3);
+    test_equal(&a_slice, &b_slice, false);
+}
+
+#[test]
+fn test_boolean_equal() {
+    let a = BooleanArray::from(vec![false, false, true]);
+    let b = BooleanArray::from(vec![false, false, true]);
+    test_equal(&a, &b, true);
+
+    let b = BooleanArray::from(vec![false, false, false]);
+    test_equal(&a, &b, false);
+}
+
+#[test]
+fn test_boolean_equal_nulls() {
+    let a = BooleanArray::from(vec![Some(false), None, None, Some(true)]);
+    let b = BooleanArray::from(vec![Some(false), None, None, Some(true)]);
+    test_equal(&a, &b, true);
+
+    let b = BooleanArray::from(vec![None, None, None, Some(true)]);
+    test_equal(&a, &b, false);
+
+    let b = BooleanArray::from(vec![Some(true), None, None, Some(true)]);
+    test_equal(&a, &b, false);
+}
+
+#[test]
+fn test_boolean_equal_offset() {
+    let a = BooleanArray::from(vec![false, true, false, true, false, false, true]);
+    let b = BooleanArray::from(vec![true, false, false, false, true, false, true, true]);
+    test_equal(&a, &b, false);
+
+    let a_slice = a.slice(2, 3);
+    let b_slice = b.slice(3, 3);
+    test_equal(&a_slice, &b_slice, true);
+
+    let a_slice = a.slice(3, 4);
+    let b_slice = b.slice(4, 4);
+    test_equal(&a_slice, &b_slice, false);
+
+    // Test the optimization cases where null_count == 0 and starts at 0 and len >= size_of(u8)
+
+    // Elements fill in `u8`'s exactly.
+    let mut vector = vec![false, false, true, true, true, true, true, true];
+    let a = BooleanArray::from(vector.clone());
+    let b = BooleanArray::from(vector.clone());
+    test_equal(&a, &b, true);
+
+    // Elements fill in `u8`s + suffix bits.
+    vector.push(true);
+    let a = BooleanArray::from(vector.clone());
+    let b = BooleanArray::from(vector);
+    test_equal(&a, &b, true);
+}
+
+#[test]
+fn test_primitive() {
+    let cases = vec![
+        (
+            vec![Some(1), Some(2), Some(3)],
+            vec![Some(1), Some(2), Some(3)],
+            true,
+        ),
+        (
+            vec![Some(1), Some(2), Some(3)],
+            vec![Some(1), Some(2), Some(4)],
+            false,
+        ),
+        (
+            vec![Some(1), Some(2), None],
+            vec![Some(1), Some(2), None],
+            true,
+        ),
+        (
+            vec![Some(1), None, Some(3)],
+            vec![Some(1), Some(2), None],
+            false,
+        ),
+        (
+            vec![Some(1), None, None],
+            vec![Some(1), Some(2), None],
+            false,
+        ),
+    ];
+
+    for (lhs, rhs, expected) in cases {
+        let lhs = Int32Array::from(lhs);
+        let rhs = Int32Array::from(rhs);
+        test_equal(&lhs, &rhs, expected);
+    }
+}
+
+#[test]
+fn test_primitive_slice() {
+    let cases = vec![
+        (
+            vec![Some(1), Some(2), Some(3)],
+            (0, 1),
+            vec![Some(1), Some(2), Some(3)],
+            (0, 1),
+            true,
+        ),
+        (
+            vec![Some(1), Some(2), Some(3)],
+            (1, 1),
+            vec![Some(1), Some(2), Some(3)],
+            (2, 1),
+            false,
+        ),
+        (
+            vec![Some(1), Some(2), None],
+            (1, 1),
+            vec![Some(1), None, Some(2)],
+            (2, 1),
+            true,
+        ),
+        (
+            vec![None, Some(2), None],
+            (1, 1),
+            vec![None, None, Some(2)],
+            (2, 1),
+            true,
+        ),
+        (
+            vec![Some(1), None, Some(2), None, Some(3)],
+            (2, 2),
+            vec![None, Some(2), None, Some(3)],
+            (1, 2),
+            true,
+        ),
+        (
+            vec![Some(1), Some(2), None, Some(0)],
+            (2, 2),
+            vec![Some(4), Some(5), Some(0), None],
+            (2, 2),
+            false,
+        ),
+    ];
+
+    for (lhs, slice_lhs, rhs, slice_rhs, expected) in cases {
+        let lhs = Int32Array::from(lhs);
+        let lhs = lhs.slice(slice_lhs.0, slice_lhs.1);
+        let rhs = Int32Array::from(rhs);
+        let rhs = rhs.slice(slice_rhs.0, slice_rhs.1);
+
+        test_equal(&lhs, &rhs, expected);
+    }
+}
+
+#[allow(clippy::eq_op)]
+fn test_equal(lhs: &dyn Array, rhs: &dyn Array, expected: bool) {
+    // equality is symmetric
+    assert_eq!(lhs, lhs);
+    assert_eq!(rhs, rhs);
+
+    match expected {
+        true => {
+            assert_eq!(lhs, rhs);
+            assert_eq!(rhs, lhs);
+        }
+        false => {
+            assert_ne!(lhs, rhs);
+            assert_ne!(rhs, lhs);
+        }
+    }
+}
+
+type OptionString = Option<String>;
+
+fn binary_cases() -> Vec<(Vec<OptionString>, Vec<OptionString>, bool)> {
+    let base = vec![
+        Some("hello".to_owned()),
+        None,
+        None,
+        Some("world".to_owned()),
+        None,
+        None,
+    ];
+    let not_base = vec![
+        Some("hello".to_owned()),
+        Some("foo".to_owned()),
+        None,
+        Some("world".to_owned()),
+        None,
+        None,
+    ];
+    vec![
+        (
+            vec![Some("hello".to_owned()), Some("world".to_owned())],
+            vec![Some("hello".to_owned()), Some("world".to_owned())],
+            true,
+        ),
+        (
+            vec![Some("hello".to_owned()), Some("world".to_owned())],
+            vec![Some("hello".to_owned()), Some("arrow".to_owned())],
+            false,
+        ),
+        (base.clone(), base.clone(), true),
+        (base, not_base, false),
+    ]
+}
+
+fn test_generic_string_equal<OffsetSize: OffsetSizeTrait>() {
+    let cases = binary_cases();
+
+    for (lhs, rhs, expected) in cases {
+        let lhs: GenericStringArray<OffsetSize> = lhs.into_iter().collect();
+        let rhs: GenericStringArray<OffsetSize> = rhs.into_iter().collect();
+        test_equal(&lhs, &rhs, expected);
+    }
+}
+
+#[test]
+fn test_string_equal() {
+    test_generic_string_equal::<i32>()
+}
+
+#[test]
+fn test_large_string_equal() {
+    test_generic_string_equal::<i64>()
+}
+
+fn test_generic_binary_equal<OffsetSize: OffsetSizeTrait>() {
+    let cases = binary_cases();
+
+    for (lhs, rhs, expected) in cases {
+        let lhs = lhs
+            .iter()
+            .map(|x| x.as_deref().map(|x| x.as_bytes()))
+            .collect();
+        let rhs = rhs
+            .iter()
+            .map(|x| x.as_deref().map(|x| x.as_bytes()))
+            .collect();
+        let lhs = GenericBinaryArray::<OffsetSize>::from_opt_vec(lhs);
+        let rhs = GenericBinaryArray::<OffsetSize>::from_opt_vec(rhs);
+        test_equal(&lhs, &rhs, expected);
+    }
+}
+
+#[test]
+fn test_binary_equal() {
+    test_generic_binary_equal::<i32>()
+}
+
+#[test]
+fn test_large_binary_equal() {
+    test_generic_binary_equal::<i64>()
+}
+
+#[test]
+fn test_fixed_size_binary_array() {
+    let a_input_arg = vec![vec![1, 2], vec![3, 4], vec![5, 6]];
+    let a = FixedSizeBinaryArray::try_from_iter(a_input_arg.into_iter()).unwrap();
+
+    let b_input_arg = vec![vec![1, 2], vec![3, 4], vec![5, 6]];
+    let b = FixedSizeBinaryArray::try_from_iter(b_input_arg.into_iter()).unwrap();
+
+    test_equal(&a, &b, true);
+}
+
+#[test]
+fn test_string_offset() {
+    let a = StringArray::from(vec![Some("a"), None, Some("b")]);
+    let a = a.slice(2, 1);
+    let b = StringArray::from(vec![Some("b")]);
+
+    test_equal(&a, &b, true);
+}
+
+#[test]
+fn test_string_offset_larger() {
+    let a = StringArray::from(vec![Some("a"), None, Some("b"), None, Some("c")]);
+    let b = StringArray::from(vec![None, Some("b"), None, Some("c")]);
+
+    test_equal(&a.slice(2, 2), &b.slice(0, 2), false);
+    test_equal(&a.slice(2, 2), &b.slice(1, 2), true);
+    test_equal(&a.slice(2, 2), &b.slice(2, 2), false);
+}
+
+#[test]
+fn test_null() {
+    let a = NullArray::new(2);
+    let b = NullArray::new(2);
+    test_equal(&a, &b, true);
+
+    let b = NullArray::new(1);
+    test_equal(&a, &b, false);
+}
+
+fn create_list_array<U: AsRef<[i32]>, T: AsRef<[Option<U>]>>(data: T) -> ListArray {
+    let mut builder = ListBuilder::new(Int32Builder::with_capacity(10));
+    for d in data.as_ref() {
+        if let Some(v) = d {
+            builder.values().append_slice(v.as_ref());
+            builder.append(true);
+        } else {
+            builder.append(false);
+        }
+    }
+    builder.finish()
+}
+
+#[test]
+fn test_list_equal() {
+    let a = create_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
+    let b = create_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
+    test_equal(&a, &b, true);
+
+    let b = create_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 7])]);
+    test_equal(&a, &b, false);
+}
+
+#[test]
+fn test_empty_offsets_list_equal() {
+    let empty: Vec<i32> = vec![];
+    let values = Int32Array::from(empty);
+    let empty_offsets: [u8; 0] = [];
+
+    let a: ListArray = ArrayDataBuilder::new(DataType::List(Arc::new(Field::new(
+        "item",
+        DataType::Int32,
+        true,
+    ))))
+    .len(0)
+    .add_buffer(Buffer::from(&empty_offsets))
+    .add_child_data(values.to_data())
+    .null_bit_buffer(Some(Buffer::from(&empty_offsets)))
+    .build()
+    .unwrap()
+    .into();
+
+    let b: ListArray = ArrayDataBuilder::new(DataType::List(Arc::new(Field::new(
+        "item",
+        DataType::Int32,
+        true,
+    ))))
+    .len(0)
+    .add_buffer(Buffer::from(&empty_offsets))
+    .add_child_data(values.to_data())
+    .null_bit_buffer(Some(Buffer::from(&empty_offsets)))
+    .build()
+    .unwrap()
+    .into();
+
+    test_equal(&a, &b, true);
+
+    let c: ListArray = ArrayDataBuilder::new(DataType::List(Arc::new(Field::new(
+        "item",
+        DataType::Int32,
+        true,
+    ))))
+    .len(0)
+    .add_buffer(Buffer::from([0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
+    .add_child_data(Int32Array::from(vec![1, 2, -1, -2, 3, 4, -3, -4]).into_data())
+    .null_bit_buffer(Some(Buffer::from(vec![0b00001001])))
+    .build()
+    .unwrap()
+    .into();
+
+    test_equal(&a, &c, true);
+}
+
+// Test the case where null_count > 0
+#[test]
+fn test_list_null() {
+    let a = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
+    let b = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
+    test_equal(&a, &b, true);
+
+    let b = create_list_array([
+        Some(&[1, 2]),
+        None,
+        Some(&[5, 6]),
+        Some(&[3, 4]),
+        None,
+        None,
+    ]);
+    test_equal(&a, &b, false);
+
+    let b = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]);
+    test_equal(&a, &b, false);
+
+    // a list where the nullness of values is determined by the list's bitmap
+    let c_values = Int32Array::from(vec![1, 2, -1, -2, 3, 4, -3, -4]);
+    let c: ListArray = ArrayDataBuilder::new(DataType::List(Arc::new(Field::new(
+        "item",
+        DataType::Int32,
+        true,
+    ))))
+    .len(6)
+    .add_buffer(Buffer::from([0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
+    .add_child_data(c_values.into_data())
+    .null_bit_buffer(Some(Buffer::from(vec![0b00001001])))
+    .build()
+    .unwrap()
+    .into();
+
+    let d_values = Int32Array::from(vec![
+        Some(1),
+        Some(2),
+        None,
+        None,
+        Some(3),
+        Some(4),
+        None,
+        None,
+    ]);
+    let d: ListArray = ArrayDataBuilder::new(DataType::List(Arc::new(Field::new(
+        "item",
+        DataType::Int32,
+        true,
+    ))))
+    .len(6)
+    .add_buffer(Buffer::from([0i32, 2, 3, 4, 6, 7, 8].to_byte_slice()))
+    .add_child_data(d_values.into_data())
+    .null_bit_buffer(Some(Buffer::from(vec![0b00001001])))
+    .build()
+    .unwrap()
+    .into();
+    test_equal(&c, &d, true);
+}
+
+// Test the case where offset != 0
+#[test]
+fn test_list_offsets() {
+    let a = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 4]), None, None]);
+    let b = create_list_array([Some(&[1, 2]), None, None, Some(&[3, 5]), None, None]);
+
+    let a_slice = a.slice(0, 3);
+    let b_slice = b.slice(0, 3);
+    test_equal(&a_slice, &b_slice, true);
+
+    let a_slice = a.slice(0, 5);
+    let b_slice = b.slice(0, 5);
+    test_equal(&a_slice, &b_slice, false);
+
+    let a_slice = a.slice(4, 1);
+    let b_slice = b.slice(4, 1);
+    test_equal(&a_slice, &b_slice, true);
+}
+
+fn create_fixed_size_binary_array<U: AsRef<[u8]>, T: AsRef<[Option<U>]>>(
+    data: T,
+) -> FixedSizeBinaryArray {
+    let mut builder = FixedSizeBinaryBuilder::with_capacity(data.as_ref().len(), 5);
+
+    for d in data.as_ref() {
+        if let Some(v) = d {
+            builder.append_value(v.as_ref()).unwrap();
+        } else {
+            builder.append_null();
+        }
+    }
+    builder.finish()
+}
+
+#[test]
+fn test_fixed_size_binary_equal() {
+    let a = create_fixed_size_binary_array([Some(b"hello"), Some(b"world")]);
+    let b = create_fixed_size_binary_array([Some(b"hello"), Some(b"world")]);
+    test_equal(&a, &b, true);
+
+    let b = create_fixed_size_binary_array([Some(b"hello"), Some(b"arrow")]);
+    test_equal(&a, &b, false);
+}
+
+// Test the case where null_count > 0
+#[test]
+fn test_fixed_size_binary_null() {
+    let a = create_fixed_size_binary_array([Some(b"hello"), None, Some(b"world")]);
+    let b = create_fixed_size_binary_array([Some(b"hello"), None, Some(b"world")]);
+    test_equal(&a, &b, true);
+
+    let b = create_fixed_size_binary_array([Some(b"hello"), Some(b"world"), None]);
+    test_equal(&a, &b, false);
+
+    let b = create_fixed_size_binary_array([Some(b"hello"), None, Some(b"arrow")]);
+    test_equal(&a, &b, false);
+}
+
+#[test]
+fn test_fixed_size_binary_offsets() {
+    // Test the case where offset != 0
+    let a =
+        create_fixed_size_binary_array([Some(b"hello"), None, None, Some(b"world"), None, None]);
+    let b =
+        create_fixed_size_binary_array([Some(b"hello"), None, None, Some(b"arrow"), None, None]);
+
+    let a_slice = a.slice(0, 3);
+    let b_slice = b.slice(0, 3);
+    test_equal(&a_slice, &b_slice, true);
+
+    let a_slice = a.slice(0, 5);
+    let b_slice = b.slice(0, 5);
+    test_equal(&a_slice, &b_slice, false);
+
+    let a_slice = a.slice(4, 1);
+    let b_slice = b.slice(4, 1);
+    test_equal(&a_slice, &b_slice, true);
+
+    let a_slice = a.slice(3, 1);
+    let b_slice = b.slice(3, 1);
+    test_equal(&a_slice, &b_slice, false);
+}
+
+fn create_decimal_array(data: Vec<Option<i128>>) -> Decimal128Array {
+    data.into_iter()
+        .collect::<Decimal128Array>()
+        .with_precision_and_scale(23, 6)
+        .unwrap()
+}
+
+#[test]
+fn test_decimal_equal() {
+    let a = create_decimal_array(vec![Some(8_887_000_000), Some(-8_887_000_000)]);
+    let b = create_decimal_array(vec![Some(8_887_000_000), Some(-8_887_000_000)]);
+    test_equal(&a, &b, true);
+
+    let b = create_decimal_array(vec![Some(15_887_000_000), Some(-8_887_000_000)]);
+    test_equal(&a, &b, false);
+}
+
+// Test the case where null_count > 0
+#[test]
+fn test_decimal_null() {
+    let a = create_decimal_array(vec![Some(8_887_000_000), None, Some(-8_887_000_000)]);
+    let b = create_decimal_array(vec![Some(8_887_000_000), None, Some(-8_887_000_000)]);
+    test_equal(&a, &b, true);
+
+    let b = create_decimal_array(vec![Some(8_887_000_000), Some(-8_887_000_000), None]);
+    test_equal(&a, &b, false);
+
+    let b = create_decimal_array(vec![Some(15_887_000_000), None, Some(-8_887_000_000)]);
+    test_equal(&a, &b, false);
+}
+
+#[test]
+fn test_decimal_offsets() {
+    // Test the case where offset != 0
+    let a = create_decimal_array(vec![
+        Some(8_887_000_000),
+        None,
+        None,
+        Some(-8_887_000_000),
+        None,
+        None,
+    ]);
+    let b = create_decimal_array(vec![
+        None,
+        Some(8_887_000_000),
+        None,
+        None,
+        Some(15_887_000_000),
+        None,
+        None,
+    ]);
+
+    let a_slice = a.slice(0, 3);
+    let b_slice = b.slice(1, 3);
+    test_equal(&a_slice, &b_slice, true);
+
+    let a_slice = a.slice(0, 5);
+    let b_slice = b.slice(1, 5);
+    test_equal(&a_slice, &b_slice, false);
+
+    let a_slice = a.slice(4, 1);
+    let b_slice = b.slice(5, 1);
+    test_equal(&a_slice, &b_slice, true);
+
+    let a_slice = a.slice(3, 3);
+    let b_slice = b.slice(4, 3);
+    test_equal(&a_slice, &b_slice, false);
+
+    let a_slice = a.slice(1, 3);
+    let b_slice = b.slice(2, 3);
+    test_equal(&a_slice, &b_slice, false);
+
+    let b = create_decimal_array(vec![
+        None,
+        None,
+        None,
+        Some(-8_887_000_000),
+        Some(-3_000),
+        None,
+    ]);
+    let a_slice = a.slice(1, 3);
+    let b_slice = b.slice(1, 3);
+    test_equal(&a_slice, &b_slice, true);
+}
+
+/// Create a fixed size list of 2 value lengths
+fn create_fixed_size_list_array<U: AsRef<[i32]>, T: AsRef<[Option<U>]>>(
+    data: T,
+) -> FixedSizeListArray {
+    let mut builder = FixedSizeListBuilder::new(Int32Builder::with_capacity(10), 3);
+
+    for d in data.as_ref() {
+        if let Some(v) = d {
+            builder.values().append_slice(v.as_ref());
+            builder.append(true);
+        } else {
+            for _ in 0..builder.value_length() {
+                builder.values().append_null();
+            }
+            builder.append(false);
+        }
+    }
+    builder.finish()
+}
+
+#[test]
+fn test_fixed_size_list_equal() {
+    let a = create_fixed_size_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
+    let b = create_fixed_size_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 6])]);
+    test_equal(&a, &b, true);
+
+    let b = create_fixed_size_list_array([Some(&[1, 2, 3]), Some(&[4, 5, 7])]);
+    test_equal(&a, &b, false);
+}
+
+// Test the case where null_count > 0
+#[test]
+fn test_fixed_list_null() {
+    let a =
+        create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]);
+    let b =
+        create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]);
+    test_equal(&a, &b, true);
+
+    let b = create_fixed_size_list_array([
+        Some(&[1, 2, 3]),
+        None,
+        Some(&[7, 8, 9]),
+        Some(&[4, 5, 6]),
+        None,
+        None,
+    ]);
+    test_equal(&a, &b, false);
+
+    let b =
+        create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[3, 6, 9]), None, None]);
+    test_equal(&a, &b, false);
+
+    let b = create_fixed_size_list_array([None, Some(&[4, 5, 6]), None, None]);
+
+    test_equal(&a.slice(2, 4), &b, true);
+    test_equal(&a.slice(3, 3), &b.slice(1, 3), true);
+}
+
+#[test]
+fn test_fixed_list_offsets() {
+    // Test the case where offset != 0
+    let a =
+        create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[4, 5, 6]), None, None]);
+    let b =
+        create_fixed_size_list_array([Some(&[1, 2, 3]), None, None, Some(&[3, 6, 9]), None, None]);
+
+    let a_slice = a.slice(0, 3);
+    let b_slice = b.slice(0, 3);
+    test_equal(&a_slice, &b_slice, true);
+
+    let a_slice = a.slice(0, 5);
+    let b_slice = b.slice(0, 5);
+    test_equal(&a_slice, &b_slice, false);
+
+    let a_slice = a.slice(4, 1);
+    let b_slice = b.slice(4, 1);
+    test_equal(&a_slice, &b_slice, true);
+}
+
+#[test]
+fn test_struct_equal() {
+    let strings: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("joe"),
+        None,
+        None,
+        Some("mark"),
+        Some("doe"),
+    ]));
+    let ints: ArrayRef = Arc::new(Int32Array::from(vec![
+        Some(1),
+        Some(2),
+        None,
+        Some(4),
+        Some(5),
+    ]));
+
+    let a = StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())]).unwrap();
+
+    let b = StructArray::try_from(vec![("f1", strings), ("f2", ints)]).unwrap();
+
+    test_equal(&a, &b, true);
+}
+
+#[test]
+fn test_struct_equal_null() {
+    let strings: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("joe"),
+        None,
+        None,
+        Some("mark"),
+        Some("doe"),
+    ]));
+    let ints: ArrayRef = Arc::new(Int32Array::from(vec![
+        Some(1),
+        Some(2),
+        None,
+        Some(4),
+        Some(5),
+    ]));
+    let ints_non_null: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 4, 0]));
+
+    let a = ArrayData::builder(DataType::Struct(Fields::from(vec![
+        Field::new("f1", DataType::Utf8, true),
+        Field::new("f2", DataType::Int32, true),
+    ])))
+    .null_bit_buffer(Some(Buffer::from(vec![0b00001011])))
+    .len(5)
+    .add_child_data(strings.to_data())
+    .add_child_data(ints.to_data())
+    .build()
+    .unwrap();
+    let a = make_array(a);
+
+    let b = ArrayData::builder(DataType::Struct(Fields::from(vec![
+        Field::new("f1", DataType::Utf8, true),
+        Field::new("f2", DataType::Int32, true),
+    ])))
+    .null_bit_buffer(Some(Buffer::from(vec![0b00001011])))
+    .len(5)
+    .add_child_data(strings.to_data())
+    .add_child_data(ints_non_null.to_data())
+    .build()
+    .unwrap();
+    let b = make_array(b);
+
+    test_equal(&a, &b, true);
+
+    // test with arrays that are not equal
+    let c_ints_non_null: ArrayRef = Arc::new(Int32Array::from(vec![1, 2, 3, 0, 4]));
+    let c = ArrayData::builder(DataType::Struct(Fields::from(vec![
+        Field::new("f1", DataType::Utf8, true),
+        Field::new("f2", DataType::Int32, true),
+    ])))
+    .null_bit_buffer(Some(Buffer::from(vec![0b00001011])))
+    .len(5)
+    .add_child_data(strings.to_data())
+    .add_child_data(c_ints_non_null.to_data())
+    .build()
+    .unwrap();
+    let c = make_array(c);
+
+    test_equal(&a, &c, false);
+
+    // test a nested struct
+    let a = ArrayData::builder(DataType::Struct(
+        vec![Field::new("f3", a.data_type().clone(), true)].into(),
+    ))
+    .null_bit_buffer(Some(Buffer::from(vec![0b00011110])))
+    .len(5)
+    .add_child_data(a.to_data())
+    .build()
+    .unwrap();
+    let a = make_array(a);
+
+    // reconstruct b, but with different data where the first struct is null
+    let strings: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("joanne"), // difference
+        None,
+        None,
+        Some("mark"),
+        Some("doe"),
+    ]));
+    let b = ArrayData::builder(DataType::Struct(Fields::from(vec![
+        Field::new("f1", DataType::Utf8, true),
+        Field::new("f2", DataType::Int32, true),
+    ])))
+    .null_bit_buffer(Some(Buffer::from(vec![0b00001011])))
+    .len(5)
+    .add_child_data(strings.to_data())
+    .add_child_data(ints_non_null.to_data())
+    .build()
+    .unwrap();
+
+    let b = ArrayData::builder(DataType::Struct(
+        vec![Field::new("f3", b.data_type().clone(), true)].into(),
+    ))
+    .null_bit_buffer(Some(Buffer::from(vec![0b00011110])))
+    .len(5)
+    .add_child_data(b)
+    .build()
+    .unwrap();
+    let b = make_array(b);
+
+    test_equal(&a, &b, true);
+}
+
+#[test]
+fn test_struct_equal_null_variable_size() {
+    // the string arrays differ, but where the struct array is null
+    let strings1: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("joe"),
+        None,
+        None,
+        Some("mark"),
+        Some("doel"),
+    ]));
+    let strings2: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("joel"),
+        None,
+        None,
+        Some("mark"),
+        Some("doe"),
+    ]));
+
+    let a = ArrayData::builder(DataType::Struct(
+        vec![Field::new("f1", DataType::Utf8, true)].into(),
+    ))
+    .null_bit_buffer(Some(Buffer::from(vec![0b00001010])))
+    .len(5)
+    .add_child_data(strings1.to_data())
+    .build()
+    .unwrap();
+    let a = make_array(a);
+
+    let b = ArrayData::builder(DataType::Struct(
+        vec![Field::new("f1", DataType::Utf8, true)].into(),
+    ))
+    .null_bit_buffer(Some(Buffer::from(vec![0b00001010])))
+    .len(5)
+    .add_child_data(strings2.to_data())
+    .build()
+    .unwrap();
+    let b = make_array(b);
+
+    test_equal(&a, &b, true);
+
+    // test with arrays that are not equal
+    let strings3: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("mark"),
+        None,
+        None,
+        Some("doe"),
+        Some("joe"),
+    ]));
+    let c = ArrayData::builder(DataType::Struct(
+        vec![Field::new("f1", DataType::Utf8, true)].into(),
+    ))
+    .null_bit_buffer(Some(Buffer::from(vec![0b00001011])))
+    .len(5)
+    .add_child_data(strings3.to_data())
+    .build()
+    .unwrap();
+    let c = make_array(c);
+
+    test_equal(&a, &c, false);
+}
+
+fn create_dictionary_array(values: &[&str], keys: &[Option<&str>]) -> DictionaryArray<Int16Type> {
+    let values = StringArray::from(values.to_vec());
+    let mut builder =
+        StringDictionaryBuilder::<Int16Type>::new_with_dictionary(keys.len(), &values).unwrap();
+    for key in keys {
+        if let Some(v) = key {
+            builder.append(v).unwrap();
+        } else {
+            builder.append_null()
+        }
+    }
+    builder.finish()
+}
+
+#[test]
+fn test_dictionary_equal() {
+    // (a, b, c), (1, 2, 1, 3) => (a, b, a, c)
+    let a = create_dictionary_array(
+        &["a", "b", "c"],
+        &[Some("a"), Some("b"), Some("a"), Some("c")],
+    );
+    // different representation (values and keys are swapped), same result
+    let b = create_dictionary_array(
+        &["a", "c", "b"],
+        &[Some("a"), Some("b"), Some("a"), Some("c")],
+    );
+    test_equal(&a, &b, true);
+
+    // different len
+    let b = create_dictionary_array(&["a", "c", "b"], &[Some("a"), Some("b"), Some("a")]);
+    test_equal(&a, &b, false);
+
+    // different key
+    let b = create_dictionary_array(
+        &["a", "c", "b"],
+        &[Some("a"), Some("b"), Some("a"), Some("a")],
+    );
+    test_equal(&a, &b, false);
+
+    // different values, same keys
+    let b = create_dictionary_array(
+        &["a", "b", "d"],
+        &[Some("a"), Some("b"), Some("a"), Some("d")],
+    );
+    test_equal(&a, &b, false);
+}
+
+#[test]
+fn test_dictionary_equal_null() {
+    // (a, b, c), (1, 2, 1, 3) => (a, b, a, c)
+    let a = create_dictionary_array(&["a", "b", "c"], &[Some("a"), None, Some("a"), Some("c")]);
+
+    // equal to self
+    test_equal(&a, &a, true);
+
+    // different representation (values and keys are swapped), same result
+    let b = create_dictionary_array(&["a", "c", "b"], &[Some("a"), None, Some("a"), Some("c")]);
+    test_equal(&a, &b, true);
+
+    // different null position
+    let b = create_dictionary_array(&["a", "c", "b"], &[Some("a"), Some("b"), Some("a"), None]);
+    test_equal(&a, &b, false);
+
+    // different key
+    let b = create_dictionary_array(&["a", "c", "b"], &[Some("a"), None, Some("a"), Some("a")]);
+    test_equal(&a, &b, false);
+
+    // different values, same keys
+    let b = create_dictionary_array(&["a", "b", "d"], &[Some("a"), None, Some("a"), Some("d")]);
+    test_equal(&a, &b, false);
+}
+
+#[test]
+fn test_non_null_empty_strings() {
+    let s1 = StringArray::from(vec![Some(""), Some(""), Some("")]);
+    let data = s1.to_data().into_builder().nulls(None).build().unwrap();
+    let s2 = StringArray::from(data);
+
+    // s2 is identical to s1 except that it has no validity buffer but since there
+    // are no nulls, s1 and s2 are equal
+    test_equal(&s1, &s2, true);
+}
+
+#[test]
+fn test_null_empty_strings() {
+    let s1 = StringArray::from(vec![Some(""), None, Some("")]);
+    let data = s1.to_data().into_builder().nulls(None).build().unwrap();
+    let s2 = StringArray::from(data);
+
+    // s2 is identical to s1 except that it has no validity buffer since string1 has
+    // nulls in it, s1 and s2 are not equal
+    test_equal(&s1, &s2, false);
+}
+
+#[test]
+fn test_union_equal_dense() {
+    let mut builder = UnionBuilder::new_dense();
+    builder.append::<Int32Type>("a", 1).unwrap();
+    builder.append::<Int32Type>("b", 2).unwrap();
+    builder.append::<Int32Type>("c", 3).unwrap();
+    builder.append::<Int32Type>("a", 4).unwrap();
+    builder.append_null::<Int32Type>("a").unwrap();
+    builder.append::<Int32Type>("a", 6).unwrap();
+    builder.append::<Int32Type>("b", 7).unwrap();
+    let union1 = builder.build().unwrap();
+
+    builder = UnionBuilder::new_dense();
+    builder.append::<Int32Type>("a", 1).unwrap();
+    builder.append::<Int32Type>("b", 2).unwrap();
+    builder.append::<Int32Type>("c", 3).unwrap();
+    builder.append::<Int32Type>("a", 4).unwrap();
+    builder.append_null::<Int32Type>("a").unwrap();
+    builder.append::<Int32Type>("a", 6).unwrap();
+    builder.append::<Int32Type>("b", 7).unwrap();
+    let union2 = builder.build().unwrap();
+
+    builder = UnionBuilder::new_dense();
+    builder.append::<Int32Type>("a", 1).unwrap();
+    builder.append::<Int32Type>("b", 2).unwrap();
+    builder.append::<Int32Type>("c", 3).unwrap();
+    builder.append::<Int32Type>("a", 5).unwrap();
+    builder.append::<Int32Type>("c", 4).unwrap();
+    builder.append::<Int32Type>("a", 6).unwrap();
+    builder.append::<Int32Type>("b", 7).unwrap();
+    let union3 = builder.build().unwrap();
+
+    builder = UnionBuilder::new_dense();
+    builder.append::<Int32Type>("a", 1).unwrap();
+    builder.append::<Int32Type>("b", 2).unwrap();
+    builder.append::<Int32Type>("c", 3).unwrap();
+    builder.append::<Int32Type>("a", 4).unwrap();
+    builder.append_null::<Int32Type>("c").unwrap();
+    builder.append_null::<Int32Type>("b").unwrap();
+    builder.append::<Int32Type>("b", 7).unwrap();
+    let union4 = builder.build().unwrap();
+
+    test_equal(&union1, &union2, true);
+    test_equal(&union1, &union3, false);
+    test_equal(&union1, &union4, false);
+}
+
+#[test]
+fn test_union_equal_sparse() {
+    let mut builder = UnionBuilder::new_sparse();
+    builder.append::<Int32Type>("a", 1).unwrap();
+    builder.append::<Int32Type>("b", 2).unwrap();
+    builder.append::<Int32Type>("c", 3).unwrap();
+    builder.append::<Int32Type>("a", 4).unwrap();
+    builder.append_null::<Int32Type>("a").unwrap();
+    builder.append::<Int32Type>("a", 6).unwrap();
+    builder.append::<Int32Type>("b", 7).unwrap();
+    let union1 = builder.build().unwrap();
+
+    builder = UnionBuilder::new_sparse();
+    builder.append::<Int32Type>("a", 1).unwrap();
+    builder.append::<Int32Type>("b", 2).unwrap();
+    builder.append::<Int32Type>("c", 3).unwrap();
+    builder.append::<Int32Type>("a", 4).unwrap();
+    builder.append_null::<Int32Type>("a").unwrap();
+    builder.append::<Int32Type>("a", 6).unwrap();
+    builder.append::<Int32Type>("b", 7).unwrap();
+    let union2 = builder.build().unwrap();
+
+    builder = UnionBuilder::new_sparse();
+    builder.append::<Int32Type>("a", 1).unwrap();
+    builder.append::<Int32Type>("b", 2).unwrap();
+    builder.append::<Int32Type>("c", 3).unwrap();
+    builder.append::<Int32Type>("a", 5).unwrap();
+    builder.append::<Int32Type>("c", 4).unwrap();
+    builder.append::<Int32Type>("a", 6).unwrap();
+    builder.append::<Int32Type>("b", 7).unwrap();
+    let union3 = builder.build().unwrap();
+
+    builder = UnionBuilder::new_sparse();
+    builder.append::<Int32Type>("a", 1).unwrap();
+    builder.append::<Int32Type>("b", 2).unwrap();
+    builder.append::<Int32Type>("c", 3).unwrap();
+    builder.append::<Int32Type>("a", 4).unwrap();
+    builder.append_null::<Int32Type>("a").unwrap();
+    builder.append_null::<Int32Type>("a").unwrap();
+    builder.append::<Int32Type>("b", 7).unwrap();
+    let union4 = builder.build().unwrap();
+
+    test_equal(&union1, &union2, true);
+    test_equal(&union1, &union3, false);
+    test_equal(&union1, &union4, false);
+}
+
+#[test]
+fn test_union_equal_sparse_slice() {
+    let mut builder = UnionBuilder::new_sparse();
+    builder.append::<Int32Type>("a", 1).unwrap();
+    builder.append::<Int32Type>("a", 2).unwrap();
+    builder.append::<Int32Type>("b", 3).unwrap();
+    let a1 = builder.build().unwrap();
+
+    let mut builder = UnionBuilder::new_sparse();
+    builder.append::<Int32Type>("a", 2).unwrap();
+    builder.append::<Int32Type>("b", 3).unwrap();
+    let a2 = builder.build().unwrap();
+
+    test_equal(&a1.slice(1, 2), &a2, true)
+}
+
+#[test]
+fn test_boolean_slice() {
+    let array = BooleanArray::from(vec![true; 32]);
+    let slice = array.slice(4, 12);
+    assert_eq!(&slice, &slice);
+
+    let slice = array.slice(8, 12);
+    assert_eq!(&slice, &slice);
+
+    let slice = array.slice(8, 24);
+    assert_eq!(&slice, &slice);
+}
+
+#[test]
+fn test_sliced_nullable_boolean_array() {
+    let a = BooleanArray::from(vec![None; 32]);
+    let b = BooleanArray::from(vec![true; 32]);
+    let slice_a = a.slice(1, 12);
+    let slice_b = b.slice(1, 12);
+    assert_ne!(&slice_a, &slice_b);
+}
+
+#[test]
+fn list_array_non_zero_nulls() {
+    // Tests handling of list arrays with non-empty null ranges
+    let mut builder = ListBuilder::new(Int64Builder::with_capacity(10));
+    builder.values().append_value(1);
+    builder.values().append_value(2);
+    builder.values().append_value(3);
+    builder.append(true);
+    builder.append(false);
+    let array1 = builder.finish();
+
+    let mut builder = ListBuilder::new(Int64Builder::with_capacity(10));
+    builder.values().append_value(1);
+    builder.values().append_value(2);
+    builder.values().append_value(3);
+    builder.append(true);
+    builder.values().append_null();
+    builder.values().append_null();
+    builder.append(false);
+    let array2 = builder.finish();
+
+    assert_eq!(array1, array2);
+}
+
+#[test]
+fn test_list_different_offsets() {
+    let a = ListArray::from_iter_primitive::<Int32Type, _, _>([
+        Some([Some(0), Some(0)]),
+        Some([Some(1), Some(2)]),
+        Some([None, None]),
+    ]);
+    let b = ListArray::from_iter_primitive::<Int32Type, _, _>([
+        Some([Some(1), Some(2)]),
+        Some([None, None]),
+        Some([None, None]),
+    ]);
+    let a_slice = a.slice(1, 2);
+    let b_slice = b.slice(0, 2);
+    assert_eq!(&a_slice, &b_slice);
+}
+
+fn make_struct(elements: Vec<Option<(Option<&'static str>, Option<i32>)>>) -> StructArray {
+    let mut builder = StructBuilder::new(
+        vec![
+            Field::new("f1", DataType::Utf8, true),
+            Field::new("f2", DataType::Int32, true),
+        ],
+        vec![
+            Box::new(StringBuilder::new()),
+            Box::new(Int32Builder::new()),
+        ],
+    );
+
+    for element in elements {
+        match element.and_then(|e| e.0) {
+            None => builder
+                .field_builder::<StringBuilder>(0)
+                .unwrap()
+                .append_null(),
+            Some(s) => builder
+                .field_builder::<StringBuilder>(0)
+                .unwrap()
+                .append_value(s),
+        };
+
+        builder
+            .field_builder::<Int32Builder>(1)
+            .unwrap()
+            .append_option(element.and_then(|e| e.1));
+
+        builder.append(element.is_some());
+    }
+
+    builder.finish()
+}
+
+#[test]
+fn test_struct_equal_slice() {
+    let a = make_struct(vec![
+        None,
+        Some((Some("joe"), Some(1))),
+        Some((None, Some(2))),
+        Some((None, None)),
+        Some((Some("mark"), Some(4))),
+        Some((Some("doe"), Some(5))),
+    ]);
+    let a = a.slice(1, 5);
+    let a = a.as_any().downcast_ref::<StructArray>().unwrap();
+
+    let b = make_struct(vec![
+        Some((Some("joe"), Some(1))),
+        Some((None, Some(2))),
+        Some((None, None)),
+        Some((Some("mark"), Some(4))),
+        Some((Some("doe"), Some(5))),
+    ]);
+    assert_eq!(a, &b);
+
+    test_equal(&a, &b, true);
+}
+
+#[test]
+fn test_list_excess_children_equal() {
+    let mut a = ListBuilder::new(FixedSizeBinaryBuilder::new(5));
+    a.values().append_value(b"11111").unwrap(); // Masked value
+    a.append_null();
+    a.values().append_value(b"22222").unwrap();
+    a.values().append_null();
+    a.append(true);
+    let a = a.finish();
+
+    let mut b = ListBuilder::new(FixedSizeBinaryBuilder::new(5));
+    b.append_null();
+    b.values().append_value(b"22222").unwrap();
+    b.values().append_null();
+    b.append(true);
+    let b = b.finish();
+
+    assert_eq!(a.value_offsets(), &[0, 1, 3]);
+    assert_eq!(b.value_offsets(), &[0, 0, 2]);
+    assert_eq!(a, b);
+}
diff --git a/arrow/tests/array_transform.rs b/arrow/tests/array_transform.rs
new file mode 100644
index 000000000000..5a267c876d6a
--- /dev/null
+++ b/arrow/tests/array_transform.rs
@@ -0,0 +1,1124 @@
+// 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.
+
+use arrow::array::{
+    Array, ArrayRef, BooleanArray, Decimal128Array, DictionaryArray, FixedSizeBinaryArray,
+    Int16Array, Int32Array, Int64Array, Int64Builder, ListArray, ListBuilder, MapBuilder,
+    NullArray, StringArray, StringBuilder, StringDictionaryBuilder, StructArray, UInt8Array,
+    UnionArray,
+};
+use arrow::datatypes::Int16Type;
+use arrow_buffer::Buffer;
+use arrow_data::transform::MutableArrayData;
+use arrow_data::ArrayData;
+use arrow_schema::{DataType, Field, Fields};
+use std::sync::Arc;
+
+#[allow(unused)]
+fn create_decimal_array(array: Vec<Option<i128>>, precision: u8, scale: i8) -> Decimal128Array {
+    array
+        .into_iter()
+        .collect::<Decimal128Array>()
+        .with_precision_and_scale(precision, scale)
+        .unwrap()
+}
+
+#[test]
+#[cfg(not(feature = "force_validate"))]
+fn test_decimal() {
+    let decimal_array =
+        create_decimal_array(vec![Some(1), Some(2), None, Some(3)], 10, 3).into_data();
+    let arrays = vec![&decimal_array];
+    let mut a = MutableArrayData::new(arrays, true, 3);
+    a.extend(0, 0, 3);
+    a.extend(0, 2, 3);
+    let result = a.freeze();
+    let array = Decimal128Array::from(result);
+    let expected = create_decimal_array(vec![Some(1), Some(2), None, None], 10, 3);
+    assert_eq!(array, expected);
+}
+#[test]
+#[cfg(not(feature = "force_validate"))]
+fn test_decimal_offset() {
+    let decimal_array = create_decimal_array(vec![Some(1), Some(2), None, Some(3)], 10, 3);
+    let decimal_array = decimal_array.slice(1, 3).into_data(); // 2, null, 3
+    let arrays = vec![&decimal_array];
+    let mut a = MutableArrayData::new(arrays, true, 2);
+    a.extend(0, 0, 2); // 2, null
+    let result = a.freeze();
+    let array = Decimal128Array::from(result);
+    let expected = create_decimal_array(vec![Some(2), None], 10, 3);
+    assert_eq!(array, expected);
+}
+
+#[test]
+#[cfg(not(feature = "force_validate"))]
+fn test_decimal_null_offset_nulls() {
+    let decimal_array = create_decimal_array(vec![Some(1), Some(2), None, Some(3)], 10, 3);
+    let decimal_array = decimal_array.slice(1, 3).into_data(); // 2, null, 3
+    let arrays = vec![&decimal_array];
+    let mut a = MutableArrayData::new(arrays, true, 2);
+    a.extend(0, 0, 2); // 2, null
+    a.extend_nulls(3); // 2, null, null, null, null
+    a.extend(0, 1, 3); //2, null, null, null, null, null, 3
+    let result = a.freeze();
+    let array = Decimal128Array::from(result);
+    let expected =
+        create_decimal_array(vec![Some(2), None, None, None, None, None, Some(3)], 10, 3);
+    assert_eq!(array, expected);
+}
+
+/// tests extending from a primitive array w/ offset nor nulls
+#[test]
+fn test_primitive() {
+    let b = UInt8Array::from(vec![Some(1), Some(2), Some(3)]).into_data();
+    let arrays = vec![&b];
+    let mut a = MutableArrayData::new(arrays, false, 3);
+    a.extend(0, 0, 2);
+    let result = a.freeze();
+    let array = UInt8Array::from(result);
+    let expected = UInt8Array::from(vec![Some(1), Some(2)]);
+    assert_eq!(array, expected);
+}
+
+/// tests extending from a primitive array with offset w/ nulls
+#[test]
+fn test_primitive_offset() {
+    let b = UInt8Array::from(vec![Some(1), Some(2), Some(3)]).into_data();
+    let b = b.slice(1, 2);
+    let arrays = vec![&b];
+    let mut a = MutableArrayData::new(arrays, false, 2);
+    a.extend(0, 0, 2);
+    let result = a.freeze();
+    let array = UInt8Array::from(result);
+    let expected = UInt8Array::from(vec![Some(2), Some(3)]);
+    assert_eq!(array, expected);
+}
+
+/// tests extending from a primitive array with offset and nulls
+#[test]
+fn test_primitive_null_offset() {
+    let b = UInt8Array::from(vec![Some(1), None, Some(3)]);
+    let b = b.slice(1, 2).into_data();
+    let arrays = vec![&b];
+    let mut a = MutableArrayData::new(arrays, false, 2);
+    a.extend(0, 0, 2);
+    let result = a.freeze();
+    let array = UInt8Array::from(result);
+    let expected = UInt8Array::from(vec![None, Some(3)]);
+    assert_eq!(array, expected);
+}
+
+#[test]
+fn test_primitive_null_offset_nulls() {
+    let b = UInt8Array::from(vec![Some(1), Some(2), Some(3)]).into_data();
+    let b = b.slice(1, 2);
+    let arrays = vec![&b];
+    let mut a = MutableArrayData::new(arrays, true, 2);
+    a.extend(0, 0, 2);
+    a.extend_nulls(3);
+    a.extend(0, 1, 2);
+    let result = a.freeze();
+    let array = UInt8Array::from(result);
+    let expected = UInt8Array::from(vec![Some(2), Some(3), None, None, None, Some(3)]);
+    assert_eq!(array, expected);
+}
+
+#[test]
+fn test_list_null_offset() {
+    let int_builder = Int64Builder::with_capacity(24);
+    let mut builder = ListBuilder::<Int64Builder>::new(int_builder);
+    builder.values().append_slice(&[1, 2, 3]);
+    builder.append(true);
+    builder.values().append_slice(&[4, 5]);
+    builder.append(true);
+    builder.values().append_slice(&[6, 7, 8]);
+    builder.append(true);
+    let array = builder.finish().into_data();
+    let arrays = vec![&array];
+
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+    mutable.extend(0, 0, 1);
+
+    let result = mutable.freeze();
+    let array = ListArray::from(result);
+
+    let int_builder = Int64Builder::with_capacity(24);
+    let mut builder = ListBuilder::<Int64Builder>::new(int_builder);
+    builder.values().append_slice(&[1, 2, 3]);
+    builder.append(true);
+    let expected = builder.finish();
+
+    assert_eq!(array, expected);
+}
+
+/// tests extending from a variable-sized (strings and binary) array w/ offset with nulls
+#[test]
+fn test_variable_sized_nulls() {
+    let array = StringArray::from(vec![Some("a"), Some("bc"), None, Some("defh")]).into_data();
+    let arrays = vec![&array];
+
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 1, 3);
+
+    let result = mutable.freeze();
+    let result = StringArray::from(result);
+
+    let expected = StringArray::from(vec![Some("bc"), None]);
+    assert_eq!(result, expected);
+}
+
+/// tests extending from a variable-sized (strings and binary) array
+/// with an offset and nulls
+#[test]
+fn test_variable_sized_offsets() {
+    let array = StringArray::from(vec![Some("a"), Some("bc"), None, Some("defh")]);
+    let array = array.into_data().slice(1, 3);
+
+    let arrays = vec![&array];
+
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 0, 3);
+
+    let result = mutable.freeze();
+    let result = StringArray::from(result);
+
+    let expected = StringArray::from(vec![Some("bc"), None, Some("defh")]);
+    assert_eq!(result, expected);
+}
+
+#[test]
+fn test_string_offsets() {
+    let array = StringArray::from(vec![Some("a"), Some("bc"), None, Some("defh")]);
+    let array = array.into_data().slice(1, 3);
+
+    let arrays = vec![&array];
+
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 0, 3);
+
+    let result = mutable.freeze();
+    let result = StringArray::from(result);
+
+    let expected = StringArray::from(vec![Some("bc"), None, Some("defh")]);
+    assert_eq!(result, expected);
+}
+
+#[test]
+fn test_multiple_with_nulls() {
+    let array1 = StringArray::from(vec!["hello", "world"]).into_data();
+    let array2 = StringArray::from(vec![Some("1"), None]).into_data();
+
+    let arrays = vec![&array1, &array2];
+
+    let mut mutable = MutableArrayData::new(arrays, false, 5);
+
+    mutable.extend(0, 0, 2);
+    mutable.extend(1, 0, 2);
+
+    let result = mutable.freeze();
+    let result = StringArray::from(result);
+
+    let expected = StringArray::from(vec![Some("hello"), Some("world"), Some("1"), None]);
+    assert_eq!(result, expected);
+}
+
+#[test]
+fn test_string_null_offset_nulls() {
+    let array = StringArray::from(vec![Some("a"), Some("bc"), None, Some("defh")]);
+    let array = array.into_data().slice(1, 3);
+
+    let arrays = vec![&array];
+
+    let mut mutable = MutableArrayData::new(arrays, true, 0);
+
+    mutable.extend(0, 1, 3);
+    mutable.extend_nulls(1);
+
+    let result = mutable.freeze();
+    let result = StringArray::from(result);
+
+    let expected = StringArray::from(vec![None, Some("defh"), None]);
+    assert_eq!(result, expected);
+}
+
+#[test]
+fn test_bool() {
+    let array = BooleanArray::from(vec![Some(false), Some(true), None, Some(false)]).into_data();
+    let arrays = vec![&array];
+
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 1, 3);
+
+    let result = mutable.freeze();
+    let result = BooleanArray::from(result);
+
+    let expected = BooleanArray::from(vec![Some(true), None]);
+    assert_eq!(result, expected);
+}
+
+#[test]
+fn test_null() {
+    let array1 = NullArray::new(10).into_data();
+    let array2 = NullArray::new(5).into_data();
+    let arrays = vec![&array1, &array2];
+
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 1, 3);
+    mutable.extend(1, 0, 1);
+
+    let result = mutable.freeze();
+    let result = NullArray::from(result);
+
+    let expected = NullArray::new(3);
+    assert_eq!(result, expected);
+}
+
+fn create_dictionary_array(values: &[&str], keys: &[Option<&str>]) -> ArrayData {
+    let values = StringArray::from(values.to_vec());
+    let mut builder =
+        StringDictionaryBuilder::<Int16Type>::new_with_dictionary(keys.len(), &values).unwrap();
+    for key in keys {
+        if let Some(v) = key {
+            builder.append(v).unwrap();
+        } else {
+            builder.append_null()
+        }
+    }
+    builder.finish().into_data()
+}
+
+#[test]
+fn test_dictionary() {
+    // (a, b, c), (0, 1, 0, 2) => (a, b, a, c)
+    let array = create_dictionary_array(&["a", "b", "c"], &[Some("a"), Some("b"), None, Some("c")]);
+    let arrays = vec![&array];
+
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 1, 3);
+
+    let result = mutable.freeze();
+    let result = DictionaryArray::from(result);
+
+    let expected = Int16Array::from(vec![Some(1), None]);
+    assert_eq!(result.keys(), &expected);
+}
+
+#[test]
+fn test_struct() {
+    let strings: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("joe"),
+        None,
+        None,
+        Some("mark"),
+        Some("doe"),
+    ]));
+    let ints: ArrayRef = Arc::new(Int32Array::from(vec![
+        Some(1),
+        Some(2),
+        Some(3),
+        Some(4),
+        Some(5),
+    ]));
+
+    let array = StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
+        .unwrap()
+        .into_data();
+    let arrays = vec![&array];
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 1, 3);
+    let data = mutable.freeze();
+    let array = StructArray::from(data);
+
+    let expected =
+        StructArray::try_from(vec![("f1", strings.slice(1, 2)), ("f2", ints.slice(1, 2))]).unwrap();
+    assert_eq!(array, expected)
+}
+
+#[test]
+fn test_struct_offset() {
+    let strings: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("joe"),
+        None,
+        None,
+        Some("mark"),
+        Some("doe"),
+    ]));
+    let ints: ArrayRef = Arc::new(Int32Array::from(vec![
+        Some(1),
+        Some(2),
+        Some(3),
+        Some(4),
+        Some(5),
+    ]));
+
+    let array = StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
+        .unwrap()
+        .into_data()
+        .slice(1, 3);
+    let arrays = vec![&array];
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 1, 3);
+    let data = mutable.freeze();
+    let array = StructArray::from(data);
+
+    let expected_strings: ArrayRef = Arc::new(StringArray::from(vec![None, Some("mark")]));
+    let expected =
+        StructArray::try_from(vec![("f1", expected_strings), ("f2", ints.slice(2, 2))]).unwrap();
+
+    assert_eq!(array, expected);
+}
+
+#[test]
+fn test_struct_nulls() {
+    let strings: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("joe"),
+        None,
+        None,
+        Some("mark"),
+        Some("doe"),
+    ]));
+    let ints: ArrayRef = Arc::new(Int32Array::from(vec![
+        Some(1),
+        Some(2),
+        None,
+        Some(4),
+        Some(5),
+    ]));
+
+    let array = StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
+        .unwrap()
+        .into_data();
+    let arrays = vec![&array];
+
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 1, 3);
+    let data = mutable.freeze();
+    let array = StructArray::from(data);
+
+    let v: Vec<Option<&str>> = vec![None, None];
+    let expected_string = Arc::new(StringArray::from(v)) as ArrayRef;
+    let expected_int = Arc::new(Int32Array::from(vec![Some(2), None])) as ArrayRef;
+
+    let expected =
+        StructArray::try_from(vec![("f1", expected_string), ("f2", expected_int)]).unwrap();
+    assert_eq!(array, expected)
+}
+
+#[test]
+fn test_struct_many() {
+    let strings: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("joe"),
+        None,
+        None,
+        Some("mark"),
+        Some("doe"),
+    ]));
+    let ints: ArrayRef = Arc::new(Int32Array::from(vec![
+        Some(1),
+        Some(2),
+        None,
+        Some(4),
+        Some(5),
+    ]));
+
+    let array = StructArray::try_from(vec![("f1", strings.clone()), ("f2", ints.clone())])
+        .unwrap()
+        .into_data();
+    let arrays = vec![&array, &array];
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 1, 3);
+    mutable.extend(1, 0, 2);
+    let data = mutable.freeze();
+    let array = StructArray::from(data);
+
+    let expected_string =
+        Arc::new(StringArray::from(vec![None, None, Some("joe"), None])) as ArrayRef;
+    let expected_int =
+        Arc::new(Int32Array::from(vec![Some(2), None, Some(1), Some(2)])) as ArrayRef;
+
+    let expected =
+        StructArray::try_from(vec![("f1", expected_string), ("f2", expected_int)]).unwrap();
+    assert_eq!(array, expected)
+}
+
+#[test]
+fn test_union_dense() {
+    // Input data
+    let strings: ArrayRef = Arc::new(StringArray::from(vec![
+        Some("joe"),
+        Some("mark"),
+        Some("doe"),
+    ]));
+    let ints: ArrayRef = Arc::new(Int32Array::from(vec![
+        Some(1),
+        Some(2),
+        Some(3),
+        Some(4),
+        Some(5),
+    ]));
+    let offsets = Buffer::from_slice_ref([0, 0, 1, 1, 2, 2, 3, 4i32]);
+    let type_ids = Buffer::from_slice_ref([42, 84, 42, 84, 84, 42, 84, 84i8]);
+
+    let array = UnionArray::try_new(
+        &[84, 42],
+        type_ids,
+        Some(offsets),
+        vec![
+            (Field::new("int", DataType::Int32, false), ints),
+            (Field::new("string", DataType::Utf8, false), strings),
+        ],
+    )
+    .unwrap()
+    .into_data();
+    let arrays = vec![&array];
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    // Slice it by `MutableArrayData`
+    mutable.extend(0, 4, 7);
+    let data = mutable.freeze();
+    let array = UnionArray::from(data);
+
+    // Expected data
+    let strings: ArrayRef = Arc::new(StringArray::from(vec![Some("doe")]));
+    let ints: ArrayRef = Arc::new(Int32Array::from(vec![Some(3), Some(4)]));
+    let offsets = Buffer::from_slice_ref([0, 0, 1i32]);
+    let type_ids = Buffer::from_slice_ref([84, 42, 84i8]);
+
+    let expected = UnionArray::try_new(
+        &[84, 42],
+        type_ids,
+        Some(offsets),
+        vec![
+            (Field::new("int", DataType::Int32, false), ints),
+            (Field::new("string", DataType::Utf8, false), strings),
+        ],
+    )
+    .unwrap();
+
+    assert_eq!(array.to_data(), expected.to_data());
+}
+
+#[test]
+fn test_binary_fixed_sized_offsets() {
+    let array =
+        FixedSizeBinaryArray::try_from_iter(vec![vec![0, 0], vec![0, 1], vec![0, 2]].into_iter())
+            .expect("Failed to create FixedSizeBinaryArray from iterable");
+    let array = array.slice(1, 2).into_data();
+    // = [[0, 1], [0, 2]] due to the offset = 1
+
+    let arrays = vec![&array];
+
+    let mut mutable = MutableArrayData::new(arrays, false, 0);
+
+    mutable.extend(0, 1, 2);
+    mutable.extend(0, 0, 1);
+
+    let result = mutable.freeze();
+    let result = FixedSizeBinaryArray::from(result);
+
+    let expected = FixedSizeBinaryArray::try_from_iter(vec![vec![0, 2], vec![0, 1]].into_iter())
+        .expect("Failed to create FixedSizeBinaryArray from iterable");
+    assert_eq!(result, expected);
+}
+
+#[test]
+fn test_list_append() {
+    let mut builder = ListBuilder::<Int64Builder>::new(Int64Builder::with_capacity(24));
+    builder.values().append_slice(&[1, 2, 3]);
+    builder.append(true);
+    builder.values().append_slice(&[4, 5]);
+    builder.append(true);
+    builder.values().append_slice(&[6, 7, 8]);
+    builder.values().append_slice(&[9, 10, 11]);
+    builder.append(true);
+    let a = builder.finish().into_data();
+
+    let a_builder = Int64Builder::with_capacity(24);
+    let mut a_builder = ListBuilder::<Int64Builder>::new(a_builder);
+    a_builder.values().append_slice(&[12, 13]);
+    a_builder.append(true);
+    a_builder.append(true);
+    a_builder.values().append_slice(&[14, 15]);
+    a_builder.append(true);
+    let b = a_builder.finish().into_data();
+
+    let c = b.slice(1, 2);
+
+    let mut mutable = MutableArrayData::new(vec![&a, &b, &c], false, 1);
+    mutable.extend(0, 0, a.len());
+    mutable.extend(1, 0, b.len());
+    mutable.extend(2, 0, c.len());
+
+    let finished = mutable.freeze();
+
+    let expected_int_array = Int64Array::from(vec![
+        Some(1),
+        Some(2),
+        Some(3),
+        Some(4),
+        Some(5),
+        Some(6),
+        Some(7),
+        Some(8),
+        Some(9),
+        Some(10),
+        Some(11),
+        // append first array
+        Some(12),
+        Some(13),
+        Some(14),
+        Some(15),
+        // append second array
+        Some(14),
+        Some(15),
+    ]);
+    let list_value_offsets = Buffer::from_slice_ref([0i32, 3, 5, 11, 13, 13, 15, 15, 17]);
+    let expected_list_data = ArrayData::try_new(
+        DataType::List(Arc::new(Field::new("item", DataType::Int64, true))),
+        8,
+        None,
+        0,
+        vec![list_value_offsets],
+        vec![expected_int_array.into_data()],
+    )
+    .unwrap();
+    assert_eq!(finished, expected_list_data);
+}
+
+#[test]
+fn test_list_nulls_append() {
+    let mut builder = ListBuilder::<Int64Builder>::new(Int64Builder::with_capacity(32));
+    builder.values().append_slice(&[1, 2, 3]);
+    builder.append(true);
+    builder.values().append_slice(&[4, 5]);
+    builder.append(true);
+    builder.append(false);
+    builder.values().append_slice(&[6, 7, 8]);
+    builder.values().append_null();
+    builder.values().append_null();
+    builder.values().append_slice(&[9, 10, 11]);
+    builder.append(true);
+    let a = builder.finish().into_data();
+
+    let mut builder = ListBuilder::<Int64Builder>::new(Int64Builder::with_capacity(32));
+    builder.values().append_slice(&[12, 13]);
+    builder.append(true);
+    builder.append(false);
+    builder.append(true);
+    builder.values().append_null();
+    builder.values().append_null();
+    builder.values().append_slice(&[14, 15]);
+    builder.append(true);
+    let b = builder.finish().into_data();
+    let c = b.slice(1, 2);
+    let d = b.slice(2, 2);
+
+    let mut mutable = MutableArrayData::new(vec![&a, &b, &c, &d], false, 10);
+
+    mutable.extend(0, 0, a.len());
+    mutable.extend(1, 0, b.len());
+    mutable.extend(2, 0, c.len());
+    mutable.extend(3, 0, d.len());
+    let result = mutable.freeze();
+
+    let expected_int_array = Int64Array::from(vec![
+        Some(1),
+        Some(2),
+        Some(3),
+        Some(4),
+        Some(5),
+        Some(6),
+        Some(7),
+        Some(8),
+        None,
+        None,
+        Some(9),
+        Some(10),
+        Some(11),
+        // second array
+        Some(12),
+        Some(13),
+        None,
+        None,
+        Some(14),
+        Some(15),
+        // slice(1, 2) results in no values added
+        None,
+        None,
+        Some(14),
+        Some(15),
+    ]);
+    let list_value_offsets =
+        Buffer::from_slice_ref([0, 3, 5, 5, 13, 15, 15, 15, 19, 19, 19, 19, 23]);
+    let expected_list_data = ArrayData::try_new(
+        DataType::List(Arc::new(Field::new("item", DataType::Int64, true))),
+        12,
+        Some(Buffer::from(&[0b11011011, 0b1110])),
+        0,
+        vec![list_value_offsets],
+        vec![expected_int_array.into_data()],
+    )
+    .unwrap();
+    assert_eq!(result, expected_list_data);
+}
+
+#[test]
+fn test_map_nulls_append() {
+    let mut builder = MapBuilder::<Int64Builder, Int64Builder>::new(
+        None,
+        Int64Builder::with_capacity(32),
+        Int64Builder::with_capacity(32),
+    );
+    builder.keys().append_slice(&[1, 2, 3]);
+    builder.values().append_slice(&[1, 2, 3]);
+    builder.append(true).unwrap();
+    builder.keys().append_slice(&[4, 5]);
+    builder.values().append_slice(&[4, 5]);
+    builder.append(true).unwrap();
+    builder.append(false).unwrap();
+    builder.keys().append_slice(&[6, 7, 8, 100, 101, 9, 10, 11]);
+    builder.values().append_slice(&[6, 7, 8]);
+    builder.values().append_null();
+    builder.values().append_null();
+    builder.values().append_slice(&[9, 10, 11]);
+    builder.append(true).unwrap();
+
+    let a = builder.finish().into_data();
+
+    let mut builder = MapBuilder::<Int64Builder, Int64Builder>::new(
+        None,
+        Int64Builder::with_capacity(32),
+        Int64Builder::with_capacity(32),
+    );
+
+    builder.keys().append_slice(&[12, 13]);
+    builder.values().append_slice(&[12, 13]);
+    builder.append(true).unwrap();
+    builder.append(false).unwrap();
+    builder.append(true).unwrap();
+    builder.keys().append_slice(&[100, 101, 14, 15]);
+    builder.values().append_null();
+    builder.values().append_null();
+    builder.values().append_slice(&[14, 15]);
+    builder.append(true).unwrap();
+
+    let b = builder.finish().into_data();
+    let c = b.slice(1, 2);
+    let d = b.slice(2, 2);
+
+    let mut mutable = MutableArrayData::new(vec![&a, &b, &c, &d], false, 10);
+
+    mutable.extend(0, 0, a.len());
+    mutable.extend(1, 0, b.len());
+    mutable.extend(2, 0, c.len());
+    mutable.extend(3, 0, d.len());
+    let result = mutable.freeze();
+
+    let expected_key_array = Int64Array::from(vec![
+        Some(1),
+        Some(2),
+        Some(3),
+        Some(4),
+        Some(5),
+        Some(6),
+        Some(7),
+        Some(8),
+        Some(100),
+        Some(101),
+        Some(9),
+        Some(10),
+        Some(11),
+        // second array
+        Some(12),
+        Some(13),
+        Some(100),
+        Some(101),
+        Some(14),
+        Some(15),
+        // slice(1, 2) results in no values added
+        Some(100),
+        Some(101),
+        Some(14),
+        Some(15),
+    ]);
+
+    let expected_value_array = Int64Array::from(vec![
+        Some(1),
+        Some(2),
+        Some(3),
+        Some(4),
+        Some(5),
+        Some(6),
+        Some(7),
+        Some(8),
+        None,
+        None,
+        Some(9),
+        Some(10),
+        Some(11),
+        // second array
+        Some(12),
+        Some(13),
+        None,
+        None,
+        Some(14),
+        Some(15),
+        // slice(1, 2) results in no values added
+        None,
+        None,
+        Some(14),
+        Some(15),
+    ]);
+
+    let expected_entry_array = StructArray::from(vec![
+        (
+            Arc::new(Field::new("keys", DataType::Int64, false)),
+            Arc::new(expected_key_array) as ArrayRef,
+        ),
+        (
+            Arc::new(Field::new("values", DataType::Int64, true)),
+            Arc::new(expected_value_array) as ArrayRef,
+        ),
+    ]);
+
+    let map_offsets = Buffer::from_slice_ref([0, 3, 5, 5, 13, 15, 15, 15, 19, 19, 19, 19, 23]);
+
+    let expected_list_data = ArrayData::try_new(
+        DataType::Map(
+            Arc::new(Field::new(
+                "entries",
+                DataType::Struct(Fields::from(vec![
+                    Field::new("keys", DataType::Int64, false),
+                    Field::new("values", DataType::Int64, true),
+                ])),
+                false,
+            )),
+            false,
+        ),
+        12,
+        Some(Buffer::from(&[0b11011011, 0b1110])),
+        0,
+        vec![map_offsets],
+        vec![expected_entry_array.into_data()],
+    )
+    .unwrap();
+    assert_eq!(result, expected_list_data);
+}
+
+#[test]
+fn test_map_keys_values_append() {
+    let mut builder = MapBuilder::<Int64Builder, Int64Builder>::new(
+        None,
+        Int64Builder::with_capacity(32),
+        Int64Builder::with_capacity(32),
+    );
+    let (keys, values) = builder.entries();
+    keys.append_slice(&[1, 2, 3]);
+    values.append_slice(&[1, 3, 4]);
+    builder.append(true).unwrap();
+
+    let (keys, values) = builder.entries();
+    keys.append_slice(&[4, 5]);
+    values.append_slice(&[4, 6]);
+    builder.append(true).unwrap();
+
+    builder.append(false).unwrap();
+
+    let map = builder.finish();
+    assert!(map.is_null(2));
+
+    let first = map.value(0);
+    let keys = first
+        .column(0)
+        .as_any()
+        .downcast_ref::<Int64Array>()
+        .unwrap();
+    let values = first
+        .column(1)
+        .as_any()
+        .downcast_ref::<Int64Array>()
+        .unwrap();
+    assert_eq!(keys, &Int64Array::from(vec![Some(1), Some(2), Some(3)]));
+    assert_eq!(values, &Int64Array::from(vec![Some(1), Some(3), Some(4)]));
+
+    let second = map.value(1);
+    let keys = second
+        .column(0)
+        .as_any()
+        .downcast_ref::<Int64Array>()
+        .unwrap();
+    let values = second
+        .column(1)
+        .as_any()
+        .downcast_ref::<Int64Array>()
+        .unwrap();
+    assert_eq!(keys, &Int64Array::from(vec![Some(4), Some(5)]));
+    assert_eq!(values, &Int64Array::from(vec![Some(4), Some(6)]));
+}
+
+#[test]
+fn test_list_of_strings_append() {
+    // [["alpha", "beta", None]]
+    let mut builder = ListBuilder::new(StringBuilder::new());
+    builder.values().append_value("Hello");
+    builder.values().append_value("Arrow");
+    builder.values().append_null();
+    builder.append(true);
+    let a = builder.finish().into_data();
+
+    // [["alpha", "beta"], [None], ["gamma", "delta", None]]
+    let mut builder = ListBuilder::new(StringBuilder::new());
+    builder.values().append_value("alpha");
+    builder.values().append_value("beta");
+    builder.append(true);
+    builder.values().append_null();
+    builder.append(true);
+    builder.values().append_value("gamma");
+    builder.values().append_value("delta");
+    builder.values().append_null();
+    builder.append(true);
+    let b = builder.finish().into_data();
+
+    let mut mutable = MutableArrayData::new(vec![&a, &b], false, 10);
+
+    mutable.extend(0, 0, a.len());
+    mutable.extend(1, 0, b.len());
+    mutable.extend(1, 1, 3);
+    mutable.extend(1, 0, 0);
+    let result = mutable.freeze();
+
+    let expected_string_array = StringArray::from(vec![
+        // extend a[0..a.len()]
+        // a[0]
+        Some("Hello"),
+        Some("Arrow"),
+        None,
+        // extend b[0..b.len()]
+        // b[0]
+        Some("alpha"),
+        Some("beta"),
+        // b[1]
+        None,
+        // b[2]
+        Some("gamma"),
+        Some("delta"),
+        None,
+        // extend b[1..3]
+        // b[1]
+        None,
+        // b[2]
+        Some("gamma"),
+        Some("delta"),
+        None,
+        // extend b[0..0]
+    ]);
+    let list_value_offsets = Buffer::from_slice_ref([0, 3, 5, 6, 9, 10, 13]);
+    let expected_list_data = ArrayData::try_new(
+        DataType::List(Arc::new(Field::new("item", DataType::Utf8, true))),
+        6,
+        None,
+        0,
+        vec![list_value_offsets],
+        vec![expected_string_array.into_data()],
+    )
+    .unwrap();
+    assert_eq!(result, expected_list_data);
+}
+
+#[test]
+fn test_fixed_size_binary_append() {
+    let a = vec![Some(vec![1, 2]), Some(vec![3, 4]), Some(vec![5, 6])];
+    let a = FixedSizeBinaryArray::try_from_sparse_iter_with_size(a.into_iter(), 2)
+        .expect("Failed to create FixedSizeBinaryArray from iterable")
+        .into_data();
+
+    let b = vec![
+        None,
+        Some(vec![7, 8]),
+        Some(vec![9, 10]),
+        None,
+        Some(vec![13, 14]),
+        None,
+    ];
+    let b = FixedSizeBinaryArray::try_from_sparse_iter_with_size(b.into_iter(), 2)
+        .expect("Failed to create FixedSizeBinaryArray from iterable")
+        .into_data();
+
+    let mut mutable = MutableArrayData::new(vec![&a, &b], false, 10);
+
+    mutable.extend(0, 0, a.len());
+    mutable.extend(1, 0, b.len());
+    mutable.extend(1, 1, 4);
+    mutable.extend(1, 2, 3);
+    mutable.extend(1, 5, 5);
+    let result = mutable.freeze();
+
+    let expected = vec![
+        // a
+        Some(vec![1, 2]),
+        Some(vec![3, 4]),
+        Some(vec![5, 6]),
+        // b
+        None,
+        Some(vec![7, 8]),
+        Some(vec![9, 10]),
+        None,
+        Some(vec![13, 14]),
+        None,
+        // b[1..4]
+        Some(vec![7, 8]),
+        Some(vec![9, 10]),
+        None,
+        // b[2..3]
+        Some(vec![9, 10]),
+        // b[4..4]
+    ];
+    let expected = FixedSizeBinaryArray::try_from_sparse_iter_with_size(expected.into_iter(), 2)
+        .expect("Failed to create FixedSizeBinaryArray from iterable")
+        .into_data();
+    assert_eq!(result, expected);
+}
+
+#[test]
+fn test_extend_nulls() {
+    let int = Int32Array::from(vec![1, 2, 3, 4]).into_data();
+    let mut mutable = MutableArrayData::new(vec![&int], true, 4);
+    mutable.extend(0, 2, 3);
+    mutable.extend_nulls(2);
+
+    let data = mutable.freeze();
+    data.validate_full().unwrap();
+    let out = Int32Array::from(data);
+
+    assert_eq!(out.null_count(), 2);
+    assert_eq!(out.iter().collect::<Vec<_>>(), vec![Some(3), None, None]);
+}
+
+#[test]
+#[should_panic(expected = "MutableArrayData not nullable")]
+fn test_extend_nulls_panic() {
+    let int = Int32Array::from(vec![1, 2, 3, 4]).into_data();
+    let mut mutable = MutableArrayData::new(vec![&int], false, 4);
+    mutable.extend_nulls(2);
+}
+
+#[test]
+#[should_panic(expected = "Arrays with inconsistent types passed to MutableArrayData")]
+fn test_mixed_types() {
+    let a = StringArray::from(vec!["abc", "def"]).to_data();
+    let b = Int32Array::from(vec![1, 2, 3]).to_data();
+    MutableArrayData::new(vec![&a, &b], false, 4);
+}
+
+/*
+// this is an old test used on a meanwhile removed dead code
+// that is still useful when `MutableArrayData` supports fixed-size lists.
+#[test]
+fn test_fixed_size_list_append() -> Result<()> {
+    let int_builder = UInt16Builder::new(64);
+    let mut builder = FixedSizeListBuilder::<UInt16Builder>::new(int_builder, 2);
+    builder.values().append_slice(&[1, 2])?;
+    builder.append(true)?;
+    builder.values().append_slice(&[3, 4])?;
+    builder.append(false)?;
+    builder.values().append_slice(&[5, 6])?;
+    builder.append(true)?;
+
+    let a_builder = UInt16Builder::new(64);
+    let mut a_builder = FixedSizeListBuilder::<UInt16Builder>::new(a_builder, 2);
+    a_builder.values().append_slice(&[7, 8])?;
+    a_builder.append(true)?;
+    a_builder.values().append_slice(&[9, 10])?;
+    a_builder.append(true)?;
+    a_builder.values().append_slice(&[11, 12])?;
+    a_builder.append(false)?;
+    a_builder.values().append_slice(&[13, 14])?;
+    a_builder.append(true)?;
+    a_builder.values().append_null()?;
+    a_builder.values().append_null()?;
+    a_builder.append(true)?;
+    let a = a_builder.finish();
+
+    // append array
+    builder.append_data(&[
+        a.data(),
+        a.slice(1, 3).data(),
+        a.slice(2, 1).data(),
+        a.slice(5, 0).data(),
+    ])?;
+    let finished = builder.finish();
+
+    let expected_int_array = UInt16Array::from(vec![
+        Some(1),
+        Some(2),
+        Some(3),
+        Some(4),
+        Some(5),
+        Some(6),
+        // append first array
+        Some(7),
+        Some(8),
+        Some(9),
+        Some(10),
+        Some(11),
+        Some(12),
+        Some(13),
+        Some(14),
+        None,
+        None,
+        // append slice(1, 3)
+        Some(9),
+        Some(10),
+        Some(11),
+        Some(12),
+        Some(13),
+        Some(14),
+        // append slice(2, 1)
+        Some(11),
+        Some(12),
+    ]);
+    let expected_list_data = ArrayData::new(
+        DataType::FixedSizeList(
+            Arc::new(Field::new("item", DataType::UInt16, true)),
+            2,
+        ),
+        12,
+        None,
+        None,
+        0,
+        vec![],
+        vec![expected_int_array.data()],
+    );
+    let expected_list =
+        FixedSizeListArray::from(Arc::new(expected_list_data) as ArrayData);
+    assert_eq!(&expected_list.values(), &finished.values());
+    assert_eq!(expected_list.len(), finished.len());
+
+    Ok(())
+}
+*/
diff --git a/arrow/tests/array_validation.rs b/arrow/tests/array_validation.rs
new file mode 100644
index 000000000000..f5298f82e0a4
--- /dev/null
+++ b/arrow/tests/array_validation.rs
@@ -0,0 +1,1013 @@
+// 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.
+
+use arrow::array::{
+    make_array, Array, BooleanBuilder, Decimal128Builder, Int32Array, Int32Builder, Int64Array,
+    StringArray, StructBuilder, UInt64Array,
+};
+use arrow_array::Decimal128Array;
+use arrow_buffer::{ArrowNativeType, Buffer};
+use arrow_data::ArrayData;
+use arrow_schema::{DataType, Field, UnionFields, UnionMode};
+use std::ptr::NonNull;
+use std::sync::Arc;
+
+#[test]
+#[should_panic(expected = "Need at least 80 bytes in buffers[0] in array of type Int64, but got 8")]
+fn test_buffer_too_small() {
+    let buffer = Buffer::from_slice_ref([0i32, 2i32]);
+    // should fail as the declared size (10*8 = 80) is larger than the underlying bfufer (8)
+    ArrayData::try_new(DataType::Int64, 10, None, 0, vec![buffer], vec![]).unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Need at least 16 bytes in buffers[0] in array of type Int64, but got 8")]
+fn test_buffer_too_small_offset() {
+    let buffer = Buffer::from_slice_ref([0i32, 2i32]);
+    // should fail -- size is ok, but also has offset
+    ArrayData::try_new(DataType::Int64, 1, None, 1, vec![buffer], vec![]).unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Expected 1 buffers in array of type Int64, got 2")]
+fn test_bad_number_of_buffers() {
+    let buffer1 = Buffer::from_slice_ref([0i32, 2i32]);
+    let buffer2 = Buffer::from_slice_ref([0i32, 2i32]);
+    ArrayData::try_new(DataType::Int64, 1, None, 0, vec![buffer1, buffer2], vec![]).unwrap();
+}
+
+#[test]
+#[should_panic(
+    expected = "Need at least 18446744073709551615 bytes in buffers[0] in array of type Int64, but got 8"
+)]
+fn test_fixed_width_overflow() {
+    let buffer = Buffer::from_slice_ref([0i32, 2i32]);
+    ArrayData::try_new(DataType::Int64, usize::MAX, None, 0, vec![buffer], vec![]).unwrap();
+}
+
+#[test]
+#[should_panic(expected = "null_bit_buffer size too small. got 1 needed 2")]
+fn test_bitmap_too_small() {
+    let buffer = make_i32_buffer(9);
+    let null_bit_buffer = Buffer::from(vec![0b11111111]);
+
+    ArrayData::try_new(
+        DataType::Int32,
+        9,
+        Some(null_bit_buffer),
+        0,
+        vec![buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+// Test creating a dictionary with a non integer type
+#[test]
+#[should_panic(expected = "Dictionary key type must be integer, but was Utf8")]
+fn test_non_int_dictionary() {
+    let i32_buffer = Buffer::from_slice_ref([0i32, 2i32]);
+    let data_type = DataType::Dictionary(Box::new(DataType::Utf8), Box::new(DataType::Int32));
+    let child_data = ArrayData::try_new(
+        DataType::Int32,
+        1,
+        None,
+        0,
+        vec![i32_buffer.clone()],
+        vec![],
+    )
+    .unwrap();
+    ArrayData::try_new(
+        data_type,
+        1,
+        None,
+        0,
+        vec![i32_buffer.clone(), i32_buffer],
+        vec![child_data],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Expected LargeUtf8 but child data had Utf8")]
+fn test_mismatched_dictionary_types() {
+    // test w/ dictionary created with a child array data that has type different than declared
+    let string_array: StringArray = vec![Some("foo"), Some("bar")].into_iter().collect();
+    let i32_buffer = Buffer::from_slice_ref([0i32, 1i32]);
+    // Dict says LargeUtf8 but array is Utf8
+    let data_type = DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::LargeUtf8));
+    let child_data = string_array.into_data();
+    ArrayData::try_new(data_type, 1, None, 0, vec![i32_buffer], vec![child_data]).unwrap();
+}
+
+#[test]
+fn test_empty_utf8_array_with_empty_offsets_buffer() {
+    let data_buffer = Buffer::from(&[]);
+    let offsets_buffer = Buffer::from(&[]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        0,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+fn test_empty_utf8_array_with_single_zero_offset() {
+    let data_buffer = Buffer::from(&[]);
+    let offsets_buffer = Buffer::from_slice_ref([0i32]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        0,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "First offset 1 of Utf8 is larger than values length 0")]
+fn test_empty_utf8_array_with_invalid_offset() {
+    let data_buffer = Buffer::from(&[]);
+    let offsets_buffer = Buffer::from_slice_ref([1i32]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        0,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+fn test_empty_utf8_array_with_non_zero_offset() {
+    let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+    let offsets_buffer = Buffer::from_slice_ref([0i32, 2, 6, 0]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        0,
+        None,
+        3,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Buffer 0 of LargeUtf8 isn't large enough. Expected 8 bytes got 4")]
+fn test_empty_large_utf8_array_with_wrong_type_offsets() {
+    let data_buffer = Buffer::from(&[]);
+    let offsets_buffer = Buffer::from_slice_ref([0i32]);
+    ArrayData::try_new(
+        DataType::LargeUtf8,
+        0,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Buffer 0 of Utf8 isn't large enough. Expected 12 bytes got 8")]
+fn test_validate_offsets_i32() {
+    let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+    let offsets_buffer = Buffer::from_slice_ref([0i32, 2i32]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        2,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Buffer 0 of LargeUtf8 isn't large enough. Expected 24 bytes got 16")]
+fn test_validate_offsets_i64() {
+    let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+    let offsets_buffer = Buffer::from_slice_ref([0i64, 2i64]);
+    ArrayData::try_new(
+        DataType::LargeUtf8,
+        2,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Error converting offset[0] (-2) to usize for Utf8")]
+fn test_validate_offsets_negative_first_i32() {
+    let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+    let offsets_buffer = Buffer::from_slice_ref([-2i32, 1i32, 3i32]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        2,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Error converting offset[2] (-3) to usize for Utf8")]
+fn test_validate_offsets_negative_last_i32() {
+    let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+    let offsets_buffer = Buffer::from_slice_ref([0i32, 2i32, -3i32]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        2,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "First offset 4 in Utf8 is smaller than last offset 3")]
+fn test_validate_offsets_range_too_small() {
+    let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+    // start offset is larger than end
+    let offsets_buffer = Buffer::from_slice_ref([4i32, 2i32, 3i32]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        2,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Last offset 10 of Utf8 is larger than values length 6")]
+fn test_validate_offsets_range_too_large() {
+    let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+    // 10 is off the end of the buffer
+    let offsets_buffer = Buffer::from_slice_ref([0i32, 2i32, 10i32]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        2,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "First offset 10 of Utf8 is larger than values length 6")]
+fn test_validate_offsets_first_too_large() {
+    let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+    // 10 is off the end of the buffer
+    let offsets_buffer = Buffer::from_slice_ref([10i32, 2i32, 10i32]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        2,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+fn test_validate_offsets_first_too_large_skipped() {
+    let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+    // 10 is off the end of the buffer, but offset starts at 1 so it is skipped
+    let offsets_buffer = Buffer::from_slice_ref([10i32, 2i32, 3i32, 4i32]);
+    let data = ArrayData::try_new(
+        DataType::Utf8,
+        2,
+        None,
+        1,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+    let array: StringArray = data.into();
+    let expected: StringArray = vec![Some("c"), Some("d")].into_iter().collect();
+    assert_eq!(array, expected);
+}
+
+#[test]
+#[should_panic(expected = "Last offset 8 of Utf8 is larger than values length 6")]
+fn test_validate_offsets_last_too_large() {
+    let data_buffer = Buffer::from_slice_ref("abcdef".as_bytes());
+    // 10 is off the end of the buffer
+    let offsets_buffer = Buffer::from_slice_ref([5i32, 7i32, 8i32]);
+    ArrayData::try_new(
+        DataType::Utf8,
+        2,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(
+    expected = "Values length 4 is less than the length (2) multiplied by the value size (2) for FixedSizeList"
+)]
+fn test_validate_fixed_size_list() {
+    // child has 4 elements,
+    let child_array = vec![Some(1), Some(2), Some(3), None]
+        .into_iter()
+        .collect::<Int32Array>();
+
+    // but claim we have 3 elements for a fixed size of 2
+    // 10 is off the end of the buffer
+    let field = Field::new("field", DataType::Int32, true);
+    ArrayData::try_new(
+        DataType::FixedSizeList(Arc::new(field), 2),
+        3,
+        None,
+        0,
+        vec![],
+        vec![child_array.into_data()],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Child type mismatch for Struct")]
+fn test_validate_struct_child_type() {
+    let field1 = vec![Some(1), Some(2), Some(3), None]
+        .into_iter()
+        .collect::<Int32Array>();
+
+    // validate the the type of struct fields matches child fields
+    ArrayData::try_new(
+        DataType::Struct(vec![Field::new("field1", DataType::Int64, true)].into()),
+        3,
+        None,
+        0,
+        vec![],
+        vec![field1.into_data()],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(
+    expected = "child array #0 for field field1 has length smaller than expected for struct array (4 < 6)"
+)]
+fn test_validate_struct_child_length() {
+    // field length only has 4 items, but array claims to have 6
+    let field1 = vec![Some(1), Some(2), Some(3), None]
+        .into_iter()
+        .collect::<Int32Array>();
+
+    ArrayData::try_new(
+        DataType::Struct(vec![Field::new("field1", DataType::Int32, true)].into()),
+        6,
+        None,
+        0,
+        vec![],
+        vec![field1.into_data()],
+    )
+    .unwrap();
+}
+
+/// Test that the array of type `data_type` that has invalid utf8 data errors
+fn check_utf8_validation<T: ArrowNativeType>(data_type: DataType) {
+    // 0x80 is a utf8 continuation sequence and is not a valid utf8 sequence itself
+    let data_buffer = Buffer::from_slice_ref([b'a', b'a', 0x80, 0x00]);
+    let offsets: Vec<T> = [0, 2, 3]
+        .iter()
+        .map(|&v| T::from_usize(v).unwrap())
+        .collect();
+
+    let offsets_buffer = Buffer::from_slice_ref(offsets);
+    ArrayData::try_new(
+        data_type,
+        2,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Invalid UTF8 sequence at string index 1 (2..3)")]
+fn test_validate_utf8_content() {
+    check_utf8_validation::<i32>(DataType::Utf8);
+}
+
+#[test]
+#[should_panic(expected = "Invalid UTF8 sequence at string index 1 (2..3)")]
+fn test_validate_large_utf8_content() {
+    check_utf8_validation::<i64>(DataType::LargeUtf8);
+}
+
+/// Tests that offsets are at valid codepoint boundaries
+fn check_utf8_char_boundary<T: ArrowNativeType>(data_type: DataType) {
+    let data_buffer = Buffer::from("🙀".as_bytes());
+    let offsets: Vec<T> = [0, 1, data_buffer.len()]
+        .iter()
+        .map(|&v| T::from_usize(v).unwrap())
+        .collect();
+
+    let offsets_buffer = Buffer::from_slice_ref(offsets);
+    ArrayData::try_new(
+        data_type,
+        2,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "incomplete utf-8 byte sequence from index 0")]
+fn test_validate_utf8_char_boundary() {
+    check_utf8_char_boundary::<i32>(DataType::Utf8);
+}
+
+#[test]
+#[should_panic(expected = "incomplete utf-8 byte sequence from index 0")]
+fn test_validate_large_utf8_char_boundary() {
+    check_utf8_char_boundary::<i64>(DataType::LargeUtf8);
+}
+
+/// Test that the array of type `data_type` that has invalid indexes (out of bounds)
+fn check_index_out_of_bounds_validation<T: ArrowNativeType>(data_type: DataType) {
+    let data_buffer = Buffer::from_slice_ref([b'a', b'b', b'c', b'd']);
+    // First two offsets are fine, then 5 is out of bounds
+    let offsets: Vec<T> = [0, 1, 2, 5, 2]
+        .iter()
+        .map(|&v| T::from_usize(v).unwrap())
+        .collect();
+
+    let offsets_buffer = Buffer::from_slice_ref(offsets);
+    ArrayData::try_new(
+        data_type,
+        4,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Offset invariant failure: offset at position 3 out of bounds: 5 > 4")]
+fn test_validate_utf8_out_of_bounds() {
+    check_index_out_of_bounds_validation::<i32>(DataType::Utf8);
+}
+
+#[test]
+#[should_panic(expected = "Offset invariant failure: offset at position 3 out of bounds: 5 > 4")]
+fn test_validate_large_utf8_out_of_bounds() {
+    check_index_out_of_bounds_validation::<i64>(DataType::LargeUtf8);
+}
+
+#[test]
+#[should_panic(expected = "Offset invariant failure: offset at position 3 out of bounds: 5 > 4")]
+fn test_validate_binary_out_of_bounds() {
+    check_index_out_of_bounds_validation::<i32>(DataType::Binary);
+}
+
+#[test]
+#[should_panic(expected = "Offset invariant failure: offset at position 3 out of bounds: 5 > 4")]
+fn test_validate_large_binary_out_of_bounds() {
+    check_index_out_of_bounds_validation::<i64>(DataType::LargeBinary);
+}
+
+// validate that indexes don't go bacwards check indexes that go backwards
+fn check_index_backwards_validation<T: ArrowNativeType>(data_type: DataType) {
+    let data_buffer = Buffer::from_slice_ref([b'a', b'b', b'c', b'd']);
+    // First three offsets are fine, then 1 goes backwards
+    let offsets: Vec<T> = [0, 1, 2, 2, 1]
+        .iter()
+        .map(|&v| T::from_usize(v).unwrap())
+        .collect();
+
+    let offsets_buffer = Buffer::from_slice_ref(offsets);
+    ArrayData::try_new(
+        data_type,
+        4,
+        None,
+        0,
+        vec![offsets_buffer, data_buffer],
+        vec![],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Offset invariant failure: non-monotonic offset at slot 3: 2 > 1")]
+fn test_validate_utf8_index_backwards() {
+    check_index_backwards_validation::<i32>(DataType::Utf8);
+}
+
+#[test]
+#[should_panic(expected = "Offset invariant failure: non-monotonic offset at slot 3: 2 > 1")]
+fn test_validate_large_utf8_index_backwards() {
+    check_index_backwards_validation::<i64>(DataType::LargeUtf8);
+}
+
+#[test]
+#[should_panic(expected = "Offset invariant failure: non-monotonic offset at slot 3: 2 > 1")]
+fn test_validate_binary_index_backwards() {
+    check_index_backwards_validation::<i32>(DataType::Binary);
+}
+
+#[test]
+#[should_panic(expected = "Offset invariant failure: non-monotonic offset at slot 3: 2 > 1")]
+fn test_validate_large_binary_index_backwards() {
+    check_index_backwards_validation::<i64>(DataType::LargeBinary);
+}
+
+#[test]
+#[should_panic(expected = "Value at position 1 out of bounds: 3 (should be in [0, 1])")]
+fn test_validate_dictionary_index_too_large() {
+    let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
+
+    // 3 is not a valid index into the values (only 0 and 1)
+    let keys: Int32Array = [Some(1), Some(3)].into_iter().collect();
+
+    let data_type = DataType::Dictionary(
+        Box::new(keys.data_type().clone()),
+        Box::new(values.data_type().clone()),
+    );
+
+    ArrayData::try_new(
+        data_type,
+        2,
+        None,
+        0,
+        vec![keys.into_data().buffers()[0].clone()],
+        vec![values.into_data()],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Value at position 1 out of bounds: -1 (should be in [0, 1]")]
+fn test_validate_dictionary_index_negative() {
+    let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
+
+    // -1 is not a valid index at all!
+    let keys: Int32Array = [Some(1), Some(-1)].into_iter().collect();
+
+    let data_type = DataType::Dictionary(
+        Box::new(keys.data_type().clone()),
+        Box::new(values.data_type().clone()),
+    );
+
+    ArrayData::try_new(
+        data_type,
+        2,
+        None,
+        0,
+        vec![keys.into_data().buffers()[0].clone()],
+        vec![values.into_data()],
+    )
+    .unwrap();
+}
+
+#[test]
+fn test_validate_dictionary_index_negative_but_not_referenced() {
+    let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
+
+    // -1 is not a valid index at all, but the array is length 1
+    // so the -1 should not be looked at
+    let keys: Int32Array = [Some(1), Some(-1)].into_iter().collect();
+
+    let data_type = DataType::Dictionary(
+        Box::new(keys.data_type().clone()),
+        Box::new(values.data_type().clone()),
+    );
+
+    // Expect this not to panic
+    ArrayData::try_new(
+        data_type,
+        1,
+        None,
+        0,
+        vec![keys.into_data().buffers()[0].clone()],
+        vec![values.into_data()],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(
+    expected = "Value at position 0 out of bounds: 18446744073709551615 (can not convert to i64)"
+)]
+fn test_validate_dictionary_index_giant_negative() {
+    let values: StringArray = [Some("foo"), Some("bar")].into_iter().collect();
+
+    // -1 is not a valid index at all!
+    let keys: UInt64Array = [Some(u64::MAX), Some(1)].into_iter().collect();
+
+    let data_type = DataType::Dictionary(
+        Box::new(keys.data_type().clone()),
+        Box::new(values.data_type().clone()),
+    );
+
+    ArrayData::try_new(
+        data_type,
+        2,
+        None,
+        0,
+        vec![keys.into_data().buffers()[0].clone()],
+        vec![values.into_data()],
+    )
+    .unwrap();
+}
+
+/// Test that the list of type `data_type` generates correct offset out of bounds errors
+fn check_list_offsets<T: ArrowNativeType>(data_type: DataType) {
+    let values: Int32Array = [Some(1), Some(2), Some(3), Some(4)].into_iter().collect();
+
+    // 5 is an invalid offset into a list of only three values
+    let offsets: Vec<T> = [0, 2, 5, 4]
+        .iter()
+        .map(|&v| T::from_usize(v).unwrap())
+        .collect();
+    let offsets_buffer = Buffer::from_slice_ref(offsets);
+
+    ArrayData::try_new(
+        data_type,
+        3,
+        None,
+        0,
+        vec![offsets_buffer],
+        vec![values.into_data()],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Offset invariant failure: offset at position 2 out of bounds: 5 > 4")]
+fn test_validate_list_offsets() {
+    let field_type = Field::new("f", DataType::Int32, true);
+    check_list_offsets::<i32>(DataType::List(Arc::new(field_type)));
+}
+
+#[test]
+#[should_panic(expected = "Offset invariant failure: offset at position 2 out of bounds: 5 > 4")]
+fn test_validate_large_list_offsets() {
+    let field_type = Field::new("f", DataType::Int32, true);
+    check_list_offsets::<i64>(DataType::LargeList(Arc::new(field_type)));
+}
+
+/// Test that the list of type `data_type` generates correct errors for negative offsets
+#[test]
+#[should_panic(
+    expected = "Offset invariant failure: Could not convert offset -1 to usize at position 2"
+)]
+fn test_validate_list_negative_offsets() {
+    let values: Int32Array = [Some(1), Some(2), Some(3), Some(4)].into_iter().collect();
+    let field_type = Field::new("f", values.data_type().clone(), true);
+    let data_type = DataType::List(Arc::new(field_type));
+
+    // -1 is an invalid offset any way you look at it
+    let offsets: Vec<i32> = vec![0, 2, -1, 4];
+    let offsets_buffer = Buffer::from_slice_ref(offsets);
+
+    ArrayData::try_new(
+        data_type,
+        3,
+        None,
+        0,
+        vec![offsets_buffer],
+        vec![values.into_data()],
+    )
+    .unwrap();
+}
+
+/// returns a buffer initialized with some constant value for tests
+fn make_i32_buffer(n: usize) -> Buffer {
+    Buffer::from_slice_ref(vec![42i32; n])
+}
+
+#[test]
+#[should_panic(expected = "Expected Int64 but child data had Int32")]
+fn test_validate_union_different_types() {
+    let field1 = vec![Some(1), Some(2)].into_iter().collect::<Int32Array>();
+
+    let field2 = vec![Some(1), Some(2)].into_iter().collect::<Int32Array>();
+
+    let type_ids = Buffer::from_slice_ref([0i8, 1i8]);
+
+    ArrayData::try_new(
+        DataType::Union(
+            UnionFields::new(
+                vec![0, 1],
+                vec![
+                    Field::new("field1", DataType::Int32, true),
+                    Field::new("field2", DataType::Int64, true), // data is int32
+                ],
+            ),
+            UnionMode::Sparse,
+        ),
+        2,
+        None,
+        0,
+        vec![type_ids],
+        vec![field1.into_data(), field2.into_data()],
+    )
+    .unwrap();
+}
+
+// sparse with wrong sized children
+#[test]
+#[should_panic(
+    expected = "Sparse union child array #1 has length smaller than expected for union array (1 < 2)"
+)]
+fn test_validate_union_sparse_different_child_len() {
+    let field1 = vec![Some(1), Some(2)].into_iter().collect::<Int32Array>();
+
+    // field 2 only has 1 item but array should have 2
+    let field2 = vec![Some(1)].into_iter().collect::<Int64Array>();
+
+    let type_ids = Buffer::from_slice_ref([0i8, 1i8]);
+
+    ArrayData::try_new(
+        DataType::Union(
+            UnionFields::new(
+                vec![0, 1],
+                vec![
+                    Field::new("field1", DataType::Int32, true),
+                    Field::new("field2", DataType::Int64, true),
+                ],
+            ),
+            UnionMode::Sparse,
+        ),
+        2,
+        None,
+        0,
+        vec![type_ids],
+        vec![field1.into_data(), field2.into_data()],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Expected 2 buffers in array of type Union")]
+fn test_validate_union_dense_without_offsets() {
+    let field1 = vec![Some(1), Some(2)].into_iter().collect::<Int32Array>();
+
+    let field2 = vec![Some(1)].into_iter().collect::<Int64Array>();
+
+    let type_ids = Buffer::from_slice_ref([0i8, 1i8]);
+
+    ArrayData::try_new(
+        DataType::Union(
+            UnionFields::new(
+                vec![0, 1],
+                vec![
+                    Field::new("field1", DataType::Int32, true),
+                    Field::new("field2", DataType::Int64, true),
+                ],
+            ),
+            UnionMode::Dense,
+        ),
+        2,
+        None,
+        0,
+        vec![type_ids], // need offsets buffer here too
+        vec![field1.into_data(), field2.into_data()],
+    )
+    .unwrap();
+}
+
+#[test]
+#[should_panic(expected = "Need at least 8 bytes in buffers[1] in array of type Union")]
+fn test_validate_union_dense_with_bad_len() {
+    let field1 = vec![Some(1), Some(2)].into_iter().collect::<Int32Array>();
+
+    let field2 = vec![Some(1)].into_iter().collect::<Int64Array>();
+
+    let type_ids = Buffer::from_slice_ref([0i8, 1i8]);
+    let offsets = Buffer::from_slice_ref([0i32]); // should have 2 offsets, but only have 1
+
+    ArrayData::try_new(
+        DataType::Union(
+            UnionFields::new(
+                vec![0, 1],
+                vec![
+                    Field::new("field1", DataType::Int32, true),
+                    Field::new("field2", DataType::Int64, true),
+                ],
+            ),
+            UnionMode::Dense,
+        ),
+        2,
+        None,
+        0,
+        vec![type_ids, offsets],
+        vec![field1.into_data(), field2.into_data()],
+    )
+    .unwrap();
+}
+
+#[test]
+fn test_try_new_sliced_struct() {
+    let mut builder = StructBuilder::new(
+        vec![
+            Field::new("a", DataType::Int32, true),
+            Field::new("b", DataType::Boolean, true),
+        ],
+        vec![
+            Box::new(Int32Builder::with_capacity(5)),
+            Box::new(BooleanBuilder::with_capacity(5)),
+        ],
+    );
+
+    // struct[0] = { a: 10, b: true }
+    builder
+        .field_builder::<Int32Builder>(0)
+        .unwrap()
+        .append_option(Some(10));
+    builder
+        .field_builder::<BooleanBuilder>(1)
+        .unwrap()
+        .append_option(Some(true));
+    builder.append(true);
+
+    // struct[1] = null
+    builder
+        .field_builder::<Int32Builder>(0)
+        .unwrap()
+        .append_option(None);
+    builder
+        .field_builder::<BooleanBuilder>(1)
+        .unwrap()
+        .append_option(None);
+    builder.append(false);
+
+    // struct[2] = { a: null, b: false }
+    builder
+        .field_builder::<Int32Builder>(0)
+        .unwrap()
+        .append_option(None);
+    builder
+        .field_builder::<BooleanBuilder>(1)
+        .unwrap()
+        .append_option(Some(false));
+    builder.append(true);
+
+    // struct[3] = { a: 21, b: null }
+    builder
+        .field_builder::<Int32Builder>(0)
+        .unwrap()
+        .append_option(Some(21));
+    builder
+        .field_builder::<BooleanBuilder>(1)
+        .unwrap()
+        .append_option(None);
+    builder.append(true);
+
+    // struct[4] = { a: 18, b: false }
+    builder
+        .field_builder::<Int32Builder>(0)
+        .unwrap()
+        .append_option(Some(18));
+    builder
+        .field_builder::<BooleanBuilder>(1)
+        .unwrap()
+        .append_option(Some(false));
+    builder.append(true);
+
+    let struct_array = builder.finish();
+    let struct_array_slice = struct_array.slice(1, 3);
+    assert_eq!(struct_array_slice, struct_array_slice);
+}
+
+#[test]
+fn test_string_data_from_foreign() {
+    let mut strings = "foobarfoobar".to_owned();
+    let mut offsets = vec![0_i32, 0, 3, 6, 12];
+    let mut bitmap = vec![0b1110_u8];
+
+    let strings_buffer = unsafe {
+        Buffer::from_custom_allocation(
+            NonNull::new_unchecked(strings.as_mut_ptr()),
+            strings.len(),
+            Arc::new(strings),
+        )
+    };
+    let offsets_buffer = unsafe {
+        Buffer::from_custom_allocation(
+            NonNull::new_unchecked(offsets.as_mut_ptr() as *mut u8),
+            offsets.len() * std::mem::size_of::<i32>(),
+            Arc::new(offsets),
+        )
+    };
+    let null_buffer = unsafe {
+        Buffer::from_custom_allocation(
+            NonNull::new_unchecked(bitmap.as_mut_ptr()),
+            bitmap.len(),
+            Arc::new(bitmap),
+        )
+    };
+
+    let data = ArrayData::try_new(
+        DataType::Utf8,
+        4,
+        Some(null_buffer),
+        0,
+        vec![offsets_buffer, strings_buffer],
+        vec![],
+    )
+    .unwrap();
+
+    let array = make_array(data);
+    let array = array.as_any().downcast_ref::<StringArray>().unwrap();
+
+    let expected = StringArray::from(vec![None, Some("foo"), Some("bar"), Some("foobar")]);
+
+    assert_eq!(array, &expected);
+}
+
+#[test]
+fn test_decimal_full_validation() {
+    let array = Decimal128Array::from(vec![123456_i128]);
+    let error = array.validate_decimal_precision(5).unwrap_err();
+    assert_eq!(
+        "Invalid argument error: 123456 is too large to store in a Decimal128 of precision 5. Max is 99999",
+        error.to_string()
+    );
+}
+
+#[test]
+fn test_decimal_validation() {
+    let mut builder = Decimal128Builder::with_capacity(4);
+    builder.append_value(10000);
+    builder.append_value(20000);
+    let array = builder.finish();
+
+    array.into_data().validate_full().unwrap();
+}
+
+#[test]
+#[cfg(not(feature = "force_validate"))]
+fn test_sliced_array_child() {
+    let values = Int32Array::from_iter_values([1, 2, 3]);
+    let values_sliced = values.slice(1, 2);
+    let offsets = Buffer::from_iter([1_i32, 3_i32]);
+
+    let list_field = Field::new("element", DataType::Int32, false);
+    let data_type = DataType::List(Arc::new(list_field));
+
+    let data = unsafe {
+        ArrayData::new_unchecked(
+            data_type,
+            1,
+            None,
+            None,
+            0,
+            vec![offsets],
+            vec![values_sliced.into_data()],
+        )
+    };
+
+    let err = data.validate_values().unwrap_err();
+    assert_eq!(err.to_string(), "Invalid argument error: Offset invariant failure: offset at position 1 out of bounds: 3 > 2");
+}
diff --git a/arrow/tests/csv.rs b/arrow/tests/csv.rs
new file mode 100644
index 000000000000..fd01f1663955
--- /dev/null
+++ b/arrow/tests/csv.rs
@@ -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.
+
+use std::sync::Arc;
+
+use arrow_array::*;
+use arrow_schema::*;
+
+#[test]
+fn test_export_csv_timestamps() {
+    let schema = Schema::new(vec![
+        Field::new(
+            "c1",
+            DataType::Timestamp(TimeUnit::Millisecond, Some("Australia/Sydney".into())),
+            true,
+        ),
+        Field::new("c2", DataType::Timestamp(TimeUnit::Millisecond, None), true),
+    ]);
+
+    let c1 = TimestampMillisecondArray::from(
+        // 1555584887 converts to 2019-04-18, 20:54:47 in time zone Australia/Sydney (AEST).
+        // The offset (difference to UTC) is +10:00.
+        // 1635577147 converts to 2021-10-30 17:59:07 in time zone Australia/Sydney (AEDT)
+        // The offset (difference to UTC) is +11:00. Note that daylight savings is in effect on 2021-10-30.
+        //
+        vec![Some(1555584887378), Some(1635577147000)],
+    )
+    .with_timezone("Australia/Sydney".to_string());
+    let c2 = TimestampMillisecondArray::from(vec![Some(1555584887378), Some(1635577147000)]);
+    let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(c1), Arc::new(c2)]).unwrap();
+
+    let mut sw = Vec::new();
+    let mut writer = arrow_csv::Writer::new(&mut sw);
+    let batches = vec![&batch];
+    for batch in batches {
+        writer.write(batch).unwrap();
+    }
+    drop(writer);
+
+    let left = "c1,c2
+2019-04-18T20:54:47.378+10:00,2019-04-18T10:54:47.378
+2021-10-30T17:59:07+11:00,2021-10-30T06:59:07\n";
+    let right = String::from_utf8(sw).unwrap();
+    assert_eq!(left, right);
+}
diff --git a/arrow/tests/pyarrow.rs b/arrow/tests/pyarrow.rs
new file mode 100644
index 000000000000..4b6991da0063
--- /dev/null
+++ b/arrow/tests/pyarrow.rs
@@ -0,0 +1,42 @@
+// 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.
+
+use arrow::array::{ArrayRef, Int32Array, StringArray};
+use arrow::pyarrow::{FromPyArrow, ToPyArrow};
+use arrow::record_batch::RecordBatch;
+use pyo3::Python;
+use std::sync::Arc;
+
+#[test]
+fn test_to_pyarrow() {
+    pyo3::prepare_freethreaded_python();
+
+    let a: ArrayRef = Arc::new(Int32Array::from(vec![1, 2]));
+    let b: ArrayRef = Arc::new(StringArray::from(vec!["a", "b"]));
+    let input = RecordBatch::try_from_iter(vec![("a", a), ("b", b)]).unwrap();
+    println!("input: {:?}", input);
+
+    let res = Python::with_gil(|py| {
+        let py_input = input.to_pyarrow(py)?;
+        let records = RecordBatch::from_pyarrow(py_input.as_ref(py))?;
+        let py_records = records.to_pyarrow(py)?;
+        RecordBatch::from_pyarrow(py_records.as_ref(py))
+    })
+    .unwrap();
+
+    assert_eq!(input, res);
+}
diff --git a/arrow/tests/schema.rs b/arrow/tests/schema.rs
index ff544b68937b..f252d77ca65d 100644
--- a/arrow/tests/schema.rs
+++ b/arrow/tests/schema.rs
@@ -29,18 +29,19 @@ fn schema_destructure() {
     let field = Field::new("c1", DataType::Utf8, false);
     let schema = Schema::new(vec![field]).with_metadata(meta);
 
-    // Destructuring a Schema allows rewriting fields and metadata
+    // Destructuring a Schema allows rewriting metadata
     // without copying
     //
     // Model this usecase below:
 
     let Schema {
-        mut fields,
-        metadata,
+        fields,
+        mut metadata,
     } = schema;
-    fields.push(Field::new("c2", DataType::Utf8, false));
+
+    metadata.insert("foo".to_string(), "bar".to_string());
 
     let new_schema = Schema::new(fields).with_metadata(metadata);
 
-    assert_eq!(new_schema.fields().len(), 2);
+    assert_eq!(new_schema.metadata.get("foo").unwrap(), "bar");
 }
diff --git a/arrow/tests/timezone.rs b/arrow/tests/timezone.rs
new file mode 100644
index 000000000000..b71d04d64be0
--- /dev/null
+++ b/arrow/tests/timezone.rs
@@ -0,0 +1,81 @@
+// 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.
+
+use arrow_cast::parse::string_to_datetime;
+use chrono::Utc;
+
+#[test]
+fn test_parse_timezone() {
+    let cases = [
+        (
+            "2023-01-01 040506 America/Los_Angeles",
+            "2023-01-01T12:05:06+00:00",
+        ),
+        (
+            "2023-01-01 04:05:06.345 America/Los_Angeles",
+            "2023-01-01T12:05:06.345+00:00",
+        ),
+        (
+            "2023-01-01 04:05:06.345 America/Los_Angeles",
+            "2023-01-01T12:05:06.345+00:00",
+        ),
+        (
+            "2023-01-01 04:05:06.789 -08",
+            "2023-01-01T12:05:06.789+00:00",
+        ),
+        (
+            "2023-03-12 040506 America/Los_Angeles",
+            "2023-03-12T11:05:06+00:00",
+        ), // Daylight savings
+    ];
+
+    for (s, expected) in cases {
+        let actual = string_to_datetime(&Utc, s).unwrap().to_rfc3339();
+        assert_eq!(actual, expected, "{s}")
+    }
+}
+
+#[test]
+fn test_parse_timezone_invalid() {
+    let cases = [
+        (
+            "2015-01-20T17:35:20-24:00",
+            "Parser error: Invalid timezone \"-24:00\": '-24:00' is not a valid timezone",
+        ),
+        (
+            "2023-01-01 04:05:06.789 +07:30:00",
+            "Parser error: Invalid timezone \"+07:30:00\": '+07:30:00' is not a valid timezone"
+        ),
+        (
+            // Sunday, 12 March 2023, 02:00:00 clocks are turned forward 1 hour to
+            // Sunday, 12 March 2023, 03:00:00 local daylight time instead.
+            "2023-03-12 02:05:06 America/Los_Angeles",
+            "Parser error: Error parsing timestamp from '2023-03-12 02:05:06 America/Los_Angeles': error computing timezone offset",
+        ),
+        (
+            // Sunday, 5 November 2023, 02:00:00 clocks are turned backward 1 hour to
+            // Sunday, 5 November 2023, 01:00:00 local standard time instead.
+            "2023-11-05 01:30:06 America/Los_Angeles",
+            "Parser error: Error parsing timestamp from '2023-11-05 01:30:06 America/Los_Angeles': error computing timezone offset",
+        ),
+    ];
+
+    for (s, expected) in cases {
+        let actual = string_to_datetime(&Utc, s).unwrap_err().to_string();
+        assert_eq!(actual, expected)
+    }
+}
diff --git a/dev/release/README.md b/dev/release/README.md
index 4ffa85d2abaa..177f33bcbb4d 100644
--- a/dev/release/README.md
+++ b/dev/release/README.md
@@ -67,19 +67,40 @@ For `object_store` the same process is done in the `object_store` directory. Exa
 ```bash
 git checkout master
 git pull
-git checkout -b make-release
+git checkout -b <RELEASE_BRANCH>
 
-# Move the content of CHANGELOG.md to CHANGELOG-old.md
+# Update versions. Make sure to run it before the next step since we do not want CHANGELOG-old.md affected.
+sed -i '' -e 's/14.0.0/39.0.0/g' `find . -name 'Cargo.toml' -or -name '*.md' | grep -v CHANGELOG.md`
+git commit -a -m 'Update version'
+
+# ensure your github token is available
+export ARROW_GITHUB_API_TOKEN=<TOKEN>
 
-# manully edit ./dev/release/update_change_log.sh to reflect the release version
+# manually edit ./dev/release/update_change_log.sh to reflect the release version
 # create the changelog
-CHANGELOG_GITHUB_TOKEN=<TOKEN> ./dev/release/update_change_log.sh
+./dev/release/update_change_log.sh
+
+# run automated script to copy labels to issues based on referenced PRs
+# (NOTE 1:  this must be done by a committer / other who has
+# write access to the repository)
+#
+# NOTE 2: this must be done after creating the initial CHANGELOG file
+python dev/release/label_issues.py
+
 # review change log / edit issues and labels if needed, rerun
 git commit -a -m 'Create changelog'
 
-# update versions
-sed -i '' -e 's/14.0.0/20.0.0/g' `find . -name 'Cargo.toml' -or -name '*.md' | grep -v CHANGELOG.md`
-git commit -a -m 'Update version'
+
+# Manually edit ./dev/release/update_change_log.sh to reflect the release version
+# Create the changelog
+CHANGELOG_GITHUB_TOKEN=<TOKEN> ./dev/release/update_change_log.sh
+# Review change log / edit issues and labels if needed, rerun
+git commit -a -m 'Create changelog'
+
+git push
+
+# File the release PR
+export BRANCH=<RELEASE_BRANCH> && export GITHUB_USERNAME=<USERNAME> && export GITHUB_TOKEN=<TOKEN> && ./file_release_pr.sh
 ```
 
 Note that when reviewing the change log, rather than editing the
@@ -203,7 +224,7 @@ Rust Arrow Crates:
 ./object_store/dev/release/release-tarball.sh 4.1.0 2
 ```
 
-Congratulations! The release is now offical!
+Congratulations! The release is now official!
 
 ### Publish on Crates.io
 
@@ -228,10 +249,25 @@ following commands
 Rust Arrow Crates:
 
 ```shell
+(cd arrow-buffer && cargo publish)
+(cd arrow-schema && cargo publish)
+(cd arrow-data && cargo publish)
+(cd arrow-array && cargo publish)
+(cd arrow-select && cargo publish)
+(cd arrow-cast && cargo publish)
+(cd arrow-ipc && cargo publish)
+(cd arrow-csv && cargo publish)
+(cd arrow-json && cargo publish)
+(cd arrow-avro && cargo publish)
+(cd arrow-ord && cargo publish)
+(cd arrow-arith && cargo publish)
+(cd arrow-string && cargo publish)
+(cd arrow-row && cargo publish)
 (cd arrow && cargo publish)
 (cd arrow-flight && cargo publish)
 (cd parquet && cargo publish)
 (cd parquet_derive && cargo publish)
+(cd arrow-integration-test && cargo publish)
 ```
 
 `object_store`
diff --git a/dev/release/create-tarball.sh b/dev/release/create-tarball.sh
index 06320171bb23..a77ddbe75701 100755
--- a/dev/release/create-tarball.sh
+++ b/dev/release/create-tarball.sh
@@ -53,6 +53,17 @@ fi
 tag=$1
 rc=$2
 
+
+# mac tar doesn't have --delete, so use gnutar
+# e.g. brew install gtar
+if command -v gtar &> /dev/null
+then
+    echo "using gtar (gnu)tar"
+    tar=gtar
+else
+    tar=tar
+fi
+
 release_hash=$(cd "${SOURCE_TOP_DIR}" && git rev-list --max-count=1 ${tag})
 
 release=apache-arrow-rs-${tag}
@@ -103,10 +114,15 @@ MAIL
 echo "---------------------------------------------------------"
 
 
+
 # create <tarball> containing the files in git at $release_hash
 # the files in the tarball are prefixed with {tag} (e.g. 4.0.1)
+# use --delete to filter out `object_store` files
 mkdir -p ${distdir}
-(cd "${SOURCE_TOP_DIR}" && git archive ${release_hash} --prefix ${release}/ | gzip > ${tarball})
+(cd "${SOURCE_TOP_DIR}" && \
+     git archive ${release_hash} --prefix ${release}/ \
+         | $tar --delete ${release}/'object_store' \
+         | gzip > ${tarball})
 
 echo "Running rat license checker on ${tarball}"
 ${SOURCE_DIR}/run-rat.sh ${tarball}
diff --git a/dev/release/file_release_pr.sh b/dev/release/file_release_pr.sh
new file mode 100644
index 000000000000..081b7c436aa5
--- /dev/null
+++ b/dev/release/file_release_pr.sh
@@ -0,0 +1,40 @@
+#!/bin/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.
+#
+# generates a standard release PR like this:
+# https://github.com/apache/arrow-rs/pull/2734
+#
+# Usage:
+# export BRANCH=<RELEASE_BRANCH> && export GITHUB_USERNAME=<USERNAME> && export GITHUB_TOKEN=<TOKEN> && ./file_release_pr.sh
+
+set -e
+
+FUTURE_RELEASE="35.0.0"
+ISSUE_NUMBER=3830
+
+TITLE="Update version to \`$FUTURE_RELEASE\` and update \`CHANGELOG\`"
+BODY="# Which issue does this PR close?\n\nCloses #$ISSUE_NUMBER.\n\n# Rationale for this change\nPrepare for biweekly release\n\n# What changes are included in this PR?\n\n# Are there any user-facing changes?\nYes"
+DATA="{\"title\":\"$TITLE\", \"body\":\"$BODY\", \"head\":\"$GITHUB_USERNAME:$BRANCH\",\"base\":\"master\"}"
+
+# Create the pull request
+curl -X POST \
+    -H "Accept: application/vnd.github+json" \
+    -H "Authorization: Bearer $GITHUB_TOKEN" \
+    https://api.github.com/repos/apache/arrow-rs/pulls \
+    -d "$DATA"
diff --git a/dev/release/label_issues.py b/dev/release/label_issues.py
new file mode 100755
index 000000000000..b004b7fa7f86
--- /dev/null
+++ b/dev/release/label_issues.py
@@ -0,0 +1,153 @@
+#!/usr/bin/env python
+
+##############################################################################
+# 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.
+##############################################################################
+
+# Python script to add labels to github issues from the PRs that closed them
+#
+# Required setup:
+# $ pip install PyGithub
+#
+# ARROW_GITHUB_API_TOKEN  needs to be set to your github token
+from github import Github
+import os
+import re
+
+
+
+# get all cross referenced issues from the named issue
+# (aka linked PRs)
+#    issue = arrow_repo.get_issue(issue_number)
+def get_cross_referenced_issues(issue):
+    all_issues = set()
+    for timeline_item in issue.get_timeline():
+        if timeline_item.event == 'cross-referenced' and timeline_item.source.type == 'issue':
+            all_issues.add(timeline_item.source.issue)
+
+    # convert to list
+    return [i for i in all_issues]
+
+
+# labels not to transfer
+BLACKLIST_LABELS = {'development-process', 'api-change'}
+
+# Adds labels to the specified issue with the labels from linked pull requests
+def relabel_issue(arrow_repo, issue_number):
+    #print(issue_number, 'fetching issue')
+    issue = arrow_repo.get_issue(issue_number)
+    print('considering issue', issue.html_url)
+    linked_issues = get_cross_referenced_issues(issue)
+    #print('  ', 'cross referenced issues:', linked_issues)
+
+    # Figure out what labels need to be added, if any
+    existing_labels = set()
+    for label in issue.labels:
+        existing_labels.add(label.name)
+
+    # find all labels to add
+    for linked_issue in linked_issues:
+        if linked_issue.pull_request is None:
+            print('  ', 'not pull request, skipping', linked_issue.html_url)
+            continue
+
+        if linked_issue.repository.name != 'arrow-rs':
+            print('  ', 'not in arrow-rs, skipping', linked_issue.html_url)
+            continue
+
+        print('  ', 'finding labels for linked pr', linked_issue.html_url)
+        linked_labels = set()
+        for label in linked_issue.labels:
+            linked_labels.add(label.name)
+            #print('  ', 'existing labels:', existing_labels)
+
+            labels_to_add = linked_labels.difference(existing_labels)
+
+            # remove any blacklist labels, if any
+            for l in BLACKLIST_LABELS:
+                labels_to_add.discard(l)
+
+            if len(labels_to_add) > 0:
+                print('  ', 'adding labels: ', labels_to_add, 'to', issue.number)
+                for label in labels_to_add:
+                    issue.add_to_labels(label)
+                    print('    ', 'added', label)
+                    existing_labels.add(label)
+
+                # leave a note about what updated these labels
+                issue.create_comment('`label_issue.py` automatically added labels {} from #{}'.format(labels_to_add, linked_issue.number))
+
+
+# what section headings in the CHANGELOG.md file contain closed issues that may need relabeling
+ISSUE_SECTION_NAMES = ['Closed issues:', 'Fixed bugs:', 'Implemented enhancements:']
+
+# find all possible issues / bugs by scraping CHANGELOG.md
+#
+# TODO: Find all tickets merged since this tag
+# The compare api can find all commits since that tag
+# I could not find a good way in the github API to find the PRs connected to a commit
+#since_tag = '22.0.0'
+
+def find_issues_from_changelog():
+    script_dir = os.path.dirname(os.path.realpath(__file__))
+    path = os.path.join(script_dir, '..', '..', 'CHANGELOG.md')
+
+    issues = set()
+
+    # Flag that
+    in_issue_section = False
+
+    with open(path, 'r') as f:
+        for line in f:
+            #print('line: ', line)
+            line = line.strip()
+            if line.startswith('**'):
+                section_name = line.replace('**', '')
+                if section_name in ISSUE_SECTION_NAMES:
+                    #print('  ', 'is issue section', section_name)
+                    in_issue_section = True
+                else:
+                    #print('  ', 'is not issue section', section_name)
+                    in_issue_section = False
+
+            if in_issue_section:
+                match = re.search('#([\d]+)', line)
+                if match is not None:
+                    #print('  ', 'reference', match.group(1))
+                    issues.add(match.group(1))
+
+    # Convert to list of number
+    return sorted([int(i) for i in issues])
+
+
+if __name__ == '__main__':
+    print('Attempting to label github issues from their corresponding PRs')
+
+    issues = find_issues_from_changelog()
+    print('Issues found in CHANGELOG: ', issues)
+
+    github_token = os.environ.get("ARROW_GITHUB_API_TOKEN")
+
+    print('logging into GITHUB...')
+    github = Github(github_token)
+
+    print('getting github repo...')
+    arrow_repo = github.get_repo('apache/arrow-rs')
+
+    for issue in issues:
+        relabel_issue(arrow_repo, issue)
diff --git a/dev/release/rat_exclude_files.txt b/dev/release/rat_exclude_files.txt
index 466f6fa45267..6f9d1b5f302b 100644
--- a/dev/release/rat_exclude_files.txt
+++ b/dev/release/rat_exclude_files.txt
@@ -3,7 +3,10 @@ testing/*
 target/*
 dev/release/rat_exclude_files.txt
 arrow/test/data/*
+arrow-csv/test/data/*
+arrow-json/test/data/*
 arrow/test/dependency/*
+arrow-integration-test/data/*
 parquet_derive/test/dependency/*
 .gitattributes
 **.gitignore
@@ -21,3 +24,4 @@ arrow-flight/src/arrow.flight.protocol.rs
 arrow-flight/src/sql/arrow.flight.protocol.sql.rs
 .github/*
 parquet/src/bin/parquet-fromcsv-help.txt
+arrow-flight/examples/data/*
diff --git a/dev/release/update_change_log.sh b/dev/release/update_change_log.sh
index b2ca561e073d..e8590ddd6788 100755
--- a/dev/release/update_change_log.sh
+++ b/dev/release/update_change_log.sh
@@ -25,25 +25,54 @@
 # arrow-rs/.github_changelog_generator
 #
 # Usage:
-# CHANGELOG_GITHUB_TOKEN=<TOKEN> ./update_change_log.sh
+# ARROW_GITHUB_API_TOKEN=<TOKEN> ./update_change_log.sh
 
 set -e
 
-SINCE_TAG="19.0.0"
-FUTURE_RELEASE="20.0.0"
+SINCE_TAG="49.0.0"
+FUTURE_RELEASE="50.0.0"
 
 SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SOURCE_TOP_DIR="$(cd "${SOURCE_DIR}/../../" && pwd)"
 
 OUTPUT_PATH="${SOURCE_TOP_DIR}/CHANGELOG.md"
+OLD_OUTPUT_PATH="${SOURCE_TOP_DIR}/CHANGELOG-old.md"
 
 # remove license header so github-changelog-generator has a clean base to append
-sed -i.bak '1,18d' "${OUTPUT_PATH}"
+sed -i.bak '1,21d' "${OUTPUT_PATH}"
+sed -i.bak '1,21d' "${OLD_OUTPUT_PATH}"
+# remove the github-changelog-generator footer from the old CHANGELOG.md
+LINE_COUNT=$(wc -l <"${OUTPUT_PATH}")
+sed -i.bak2 "$(( $LINE_COUNT-4+1 )),$ d" "${OUTPUT_PATH}"
+
+# Copy the previous CHANGELOG.md to CHANGELOG-old.md
+echo '<!---
+  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.
+-->
+
+# Historical Changelog
+' | cat - "${OUTPUT_PATH}" "${OLD_OUTPUT_PATH}" > "${OLD_OUTPUT_PATH}".tmp
+mv "${OLD_OUTPUT_PATH}".tmp "${OLD_OUTPUT_PATH}"
 
 # use exclude-tags-regex to filter out tags used for object_store
 # crates and only only look at tags that DO NOT begin with `object_store_`
 pushd "${SOURCE_TOP_DIR}"
-docker run -it --rm -e CHANGELOG_GITHUB_TOKEN="$CHANGELOG_GITHUB_TOKEN" -v "$(pwd)":/usr/local/src/your-app githubchangeloggenerator/github-changelog-generator \
+docker run -it --rm -e CHANGELOG_GITHUB_TOKEN="$ARROW_GITHUB_API_TOKEN" -v "$(pwd)":/usr/local/src/your-app githubchangeloggenerator/github-changelog-generator \
     --user apache \
     --project arrow-rs \
     --cache-file=.githubchangeloggenerator.cache \
diff --git a/dev/release/verify-release-candidate.sh b/dev/release/verify-release-candidate.sh
index b60465b9732c..2629d362aaff 100755
--- a/dev/release/verify-release-candidate.sh
+++ b/dev/release/verify-release-candidate.sh
@@ -113,19 +113,13 @@ test_source_distribution() {
   export ARROW_TEST_DATA=$PWD/arrow-testing-data/data
   export PARQUET_TEST_DATA=$PWD/parquet-testing-data/data
 
-  # use local modules because we don't publish modules to crates.io yet
-  sed \
-    -i.bak \
-    -E \
-    -e 's/^arrow = "([^"]*)"/arrow = { version = "\1", path = "..\/arrow" }/g' \
-    -e 's/^parquet = "([^"]*)"/parquet = { version = "\1", path = "..\/parquet" }/g' \
-    */Cargo.toml
-
-  cargo build
   cargo test --all
 
-  # verify that the crates can be published to crates.io
-  pushd arrow
+  # verify that the leaf crates can be published to crates.io
+  # we can't verify crates that depend on others
+  # (because the others haven't yet been published to crates.io)
+
+  pushd arrow-buffer
     cargo publish --dry-run
   popd
 
diff --git a/format/Flight.proto b/format/Flight.proto
index b291d9dbd9aa..653b983ef2c7 100644
--- a/format/Flight.proto
+++ b/format/Flight.proto
@@ -16,320 +16,513 @@
  * limitations under the License.
  */
 
-syntax = "proto3";
-
-option java_package = "org.apache.arrow.flight.impl";
-option go_package = "github.com/apache/arrow/go/flight;flight";
-option csharp_namespace = "Apache.Arrow.Flight.Protocol";
-
-package arrow.flight.protocol;
-
-/*
- * A flight service is an endpoint for retrieving or storing Arrow data. A
- * flight service can expose one or more predefined endpoints that can be
- * accessed using the Arrow Flight Protocol. Additionally, a flight service
- * can expose a set of actions that are available.
- */
-service FlightService {
-
-  /*
-   * Handshake between client and server. Depending on the server, the
-   * handshake may be required to determine the token that should be used for
-   * future operations. Both request and response are streams to allow multiple
-   * round-trips depending on auth mechanism.
-   */
-  rpc Handshake(stream HandshakeRequest) returns (stream HandshakeResponse) {}
-
-  /*
-   * Get a list of available streams given a particular criteria. Most flight
-   * services will expose one or more streams that are readily available for
-   * retrieval. This api allows listing the streams available for
-   * consumption. A user can also provide a criteria. The criteria can limit
-   * the subset of streams that can be listed via this interface. Each flight
-   * service allows its own definition of how to consume criteria.
-   */
-  rpc ListFlights(Criteria) returns (stream FlightInfo) {}
-
-  /*
-   * For a given FlightDescriptor, get information about how the flight can be
-   * consumed. This is a useful interface if the consumer of the interface
-   * already can identify the specific flight to consume. This interface can
-   * also allow a consumer to generate a flight stream through a specified
-   * descriptor. For example, a flight descriptor might be something that
-   * includes a SQL statement or a Pickled Python operation that will be
-   * executed. In those cases, the descriptor will not be previously available
-   * within the list of available streams provided by ListFlights but will be
-   * available for consumption for the duration defined by the specific flight
-   * service.
-   */
-  rpc GetFlightInfo(FlightDescriptor) returns (FlightInfo) {}
-
-  /*
-   * For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
-   * This is used when a consumer needs the Schema of flight stream. Similar to
-   * GetFlightInfo this interface may generate a new flight that was not previously
-   * available in ListFlights.
-   */
-   rpc GetSchema(FlightDescriptor) returns (SchemaResult) {}
-
-  /*
-   * Retrieve a single stream associated with a particular descriptor
-   * associated with the referenced ticket. A Flight can be composed of one or
-   * more streams where each stream can be retrieved using a separate opaque
-   * ticket that the flight service uses for managing a collection of streams.
-   */
-  rpc DoGet(Ticket) returns (stream FlightData) {}
-
-  /*
-   * Push a stream to the flight service associated with a particular
-   * flight stream. This allows a client of a flight service to upload a stream
-   * of data. Depending on the particular flight service, a client consumer
-   * could be allowed to upload a single stream per descriptor or an unlimited
-   * number. In the latter, the service might implement a 'seal' action that
-   * can be applied to a descriptor once all streams are uploaded.
-   */
-  rpc DoPut(stream FlightData) returns (stream PutResult) {}
-
-  /*
-   * Open a bidirectional data channel for a given descriptor. This
-   * allows clients to send and receive arbitrary Arrow data and
-   * application-specific metadata in a single logical stream. In
-   * contrast to DoGet/DoPut, this is more suited for clients
-   * offloading computation (rather than storage) to a Flight service.
-   */
-  rpc DoExchange(stream FlightData) returns (stream FlightData) {}
-
-  /*
-   * Flight services can support an arbitrary number of simple actions in
-   * addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut
-   * operations that are potentially available. DoAction allows a flight client
-   * to do a specific action against a flight service. An action includes
-   * opaque request and response objects that are specific to the type action
-   * being undertaken.
-   */
-  rpc DoAction(Action) returns (stream Result) {}
-
-  /*
-   * A flight service exposes all of the available action types that it has
-   * along with descriptions. This allows different flight consumers to
-   * understand the capabilities of the flight service.
-   */
-  rpc ListActions(Empty) returns (stream ActionType) {}
-
-}
-
-/*
- * The request that a client provides to a server on handshake.
- */
-message HandshakeRequest {
-
-  /*
-   * A defined protocol version
-   */
-  uint64 protocol_version = 1;
-
-  /*
-   * Arbitrary auth/handshake info.
-   */
-  bytes payload = 2;
-}
-
-message HandshakeResponse {
-
-  /*
-   * A defined protocol version
-   */
-  uint64 protocol_version = 1;
-
-  /*
-   * Arbitrary auth/handshake info.
-   */
-  bytes payload = 2;
-}
-
-/*
- * A message for doing simple auth.
- */
-message BasicAuth {
-  string username = 2;
-  string password = 3;
-}
-
-message Empty {}
-
-/*
- * Describes an available action, including both the name used for execution
- * along with a short description of the purpose of the action.
- */
-message ActionType {
-  string type = 1;
-  string description = 2;
-}
-
-/*
- * A service specific expression that can be used to return a limited set
- * of available Arrow Flight streams.
- */
-message Criteria {
-  bytes expression = 1;
-}
-
-/*
- * An opaque action specific for the service.
- */
-message Action {
-  string type = 1;
-  bytes body = 2;
-}
-
-/*
- * An opaque result returned after executing an action.
- */
-message Result {
-  bytes body = 1;
-}
-
-/*
- * Wrap the result of a getSchema call
- */
-message SchemaResult {
-  // schema of the dataset as described in Schema.fbs::Schema.
-  bytes schema = 1;
-}
-
-/*
- * The name or tag for a Flight. May be used as a way to retrieve or generate
- * a flight or be used to expose a set of previously defined flights.
- */
-message FlightDescriptor {
-
-  /*
-   * Describes what type of descriptor is defined.
-   */
-  enum DescriptorType {
-
-    // Protobuf pattern, not used.
-    UNKNOWN = 0;
-
-    /*
-     * A named path that identifies a dataset. A path is composed of a string
-     * or list of strings describing a particular dataset. This is conceptually
-     *  similar to a path inside a filesystem.
-     */
-    PATH = 1;
-
-    /*
-     * An opaque command to generate a dataset.
-     */
-    CMD = 2;
-  }
-
-  DescriptorType type = 1;
-
-  /*
-   * Opaque value used to express a command. Should only be defined when
-   * type = CMD.
-   */
-  bytes cmd = 2;
-
-  /*
-   * List of strings identifying a particular dataset. Should only be defined
-   * when type = PATH.
-   */
-  repeated string path = 3;
-}
-
-/*
- * The access coordinates for retrieval of a dataset. With a FlightInfo, a
- * consumer is able to determine how to retrieve a dataset.
- */
-message FlightInfo {
-  // schema of the dataset as described in Schema.fbs::Schema.
-  bytes schema = 1;
-
-  /*
-   * The descriptor associated with this info.
-   */
-  FlightDescriptor flight_descriptor = 2;
-
-  /*
-   * A list of endpoints associated with the flight. To consume the whole
-   * flight, all endpoints must be consumed.
-   */
-  repeated FlightEndpoint endpoint = 3;
-
-  // Set these to -1 if unknown.
-  int64 total_records = 4;
-  int64 total_bytes = 5;
-}
-
-/*
- * A particular stream or split associated with a flight.
- */
-message FlightEndpoint {
-
-  /*
-   * Token used to retrieve this stream.
-   */
-  Ticket ticket = 1;
-
-  /*
-   * A list of URIs where this ticket can be redeemed. If the list is
-   * empty, the expectation is that the ticket can only be redeemed on the
-   * current service where the ticket was generated.
-   */
-  repeated Location location = 2;
-}
-
-/*
- * A location where a Flight service will accept retrieval of a particular
- * stream given a ticket.
- */
-message Location {
-  string uri = 1;
-}
-
-/*
- * An opaque identifier that the service can use to retrieve a particular
- * portion of a stream.
- */
-message Ticket {
-  bytes ticket = 1;
-}
-
-/*
- * A batch of Arrow data as part of a stream of batches.
- */
-message FlightData {
-
-  /*
-   * The descriptor of the data. This is only relevant when a client is
-   * starting a new DoPut stream.
-   */
-  FlightDescriptor flight_descriptor = 1;
-
-  /*
-   * Header for message data as described in Message.fbs::Message.
-   */
-  bytes data_header = 2;
-
-  /*
-   * Application-defined metadata.
-   */
-  bytes app_metadata = 3;
-
-  /*
-   * The actual batch of Arrow data. Preferably handled with minimal-copies
-   * coming last in the definition to help with sidecar patterns (it is
-   * expected that some implementations will fetch this field off the wire
-   * with specialized code to avoid extra memory copies).
-   */
-  bytes data_body = 1000;
-}
-
-/**
- * The response message associated with the submission of a DoPut.
- */
-message PutResult {
-  bytes app_metadata = 1;
-}
+ syntax = "proto3";
+ import "google/protobuf/timestamp.proto";
+
+ option java_package = "org.apache.arrow.flight.impl";
+ option go_package = "github.com/apache/arrow/go/arrow/flight/gen/flight";
+ option csharp_namespace = "Apache.Arrow.Flight.Protocol";
+ 
+ package arrow.flight.protocol;
+ 
+ /*
+  * A flight service is an endpoint for retrieving or storing Arrow data. A
+  * flight service can expose one or more predefined endpoints that can be
+  * accessed using the Arrow Flight Protocol. Additionally, a flight service
+  * can expose a set of actions that are available.
+  */
+ service FlightService {
+ 
+   /*
+    * Handshake between client and server. Depending on the server, the
+    * handshake may be required to determine the token that should be used for
+    * future operations. Both request and response are streams to allow multiple
+    * round-trips depending on auth mechanism.
+    */
+   rpc Handshake(stream HandshakeRequest) returns (stream HandshakeResponse) {}
+ 
+   /*
+    * Get a list of available streams given a particular criteria. Most flight
+    * services will expose one or more streams that are readily available for
+    * retrieval. This api allows listing the streams available for
+    * consumption. A user can also provide a criteria. The criteria can limit
+    * the subset of streams that can be listed via this interface. Each flight
+    * service allows its own definition of how to consume criteria.
+    */
+   rpc ListFlights(Criteria) returns (stream FlightInfo) {}
+ 
+   /*
+    * For a given FlightDescriptor, get information about how the flight can be
+    * consumed. This is a useful interface if the consumer of the interface
+    * already can identify the specific flight to consume. This interface can
+    * also allow a consumer to generate a flight stream through a specified
+    * descriptor. For example, a flight descriptor might be something that
+    * includes a SQL statement or a Pickled Python operation that will be
+    * executed. In those cases, the descriptor will not be previously available
+    * within the list of available streams provided by ListFlights but will be
+    * available for consumption for the duration defined by the specific flight
+    * service.
+    */
+   rpc GetFlightInfo(FlightDescriptor) returns (FlightInfo) {}
+ 
+   /*
+    * For a given FlightDescriptor, start a query and get information
+    * to poll its execution status. This is a useful interface if the
+    * query may be a long-running query. The first PollFlightInfo call
+    * should return as quickly as possible. (GetFlightInfo doesn't
+    * return until the query is complete.)
+    *
+    * A client can consume any available results before
+    * the query is completed. See PollInfo.info for details.
+    *
+    * A client can poll the updated query status by calling
+    * PollFlightInfo() with PollInfo.flight_descriptor. A server
+    * should not respond until the result would be different from last
+    * time. That way, the client can "long poll" for updates
+    * without constantly making requests. Clients can set a short timeout
+    * to avoid blocking calls if desired.
+    *
+    * A client can't use PollInfo.flight_descriptor after
+    * PollInfo.expiration_time passes. A server might not accept the
+    * retry descriptor anymore and the query may be cancelled.
+    *
+    * A client may use the CancelFlightInfo action with
+    * PollInfo.info to cancel the running query.
+    */
+   rpc PollFlightInfo(FlightDescriptor) returns (PollInfo) {}
+ 
+   /*
+    * For a given FlightDescriptor, get the Schema as described in Schema.fbs::Schema
+    * This is used when a consumer needs the Schema of flight stream. Similar to
+    * GetFlightInfo this interface may generate a new flight that was not previously
+    * available in ListFlights.
+    */
+    rpc GetSchema(FlightDescriptor) returns (SchemaResult) {}
+ 
+   /*
+    * Retrieve a single stream associated with a particular descriptor
+    * associated with the referenced ticket. A Flight can be composed of one or
+    * more streams where each stream can be retrieved using a separate opaque
+    * ticket that the flight service uses for managing a collection of streams.
+    */
+   rpc DoGet(Ticket) returns (stream FlightData) {}
+ 
+   /*
+    * Push a stream to the flight service associated with a particular
+    * flight stream. This allows a client of a flight service to upload a stream
+    * of data. Depending on the particular flight service, a client consumer
+    * could be allowed to upload a single stream per descriptor or an unlimited
+    * number. In the latter, the service might implement a 'seal' action that
+    * can be applied to a descriptor once all streams are uploaded.
+    */
+   rpc DoPut(stream FlightData) returns (stream PutResult) {}
+ 
+   /*
+    * Open a bidirectional data channel for a given descriptor. This
+    * allows clients to send and receive arbitrary Arrow data and
+    * application-specific metadata in a single logical stream. In
+    * contrast to DoGet/DoPut, this is more suited for clients
+    * offloading computation (rather than storage) to a Flight service.
+    */
+   rpc DoExchange(stream FlightData) returns (stream FlightData) {}
+ 
+   /*
+    * Flight services can support an arbitrary number of simple actions in
+    * addition to the possible ListFlights, GetFlightInfo, DoGet, DoPut
+    * operations that are potentially available. DoAction allows a flight client
+    * to do a specific action against a flight service. An action includes
+    * opaque request and response objects that are specific to the type action
+    * being undertaken.
+    */
+   rpc DoAction(Action) returns (stream Result) {}
+ 
+   /*
+    * A flight service exposes all of the available action types that it has
+    * along with descriptions. This allows different flight consumers to
+    * understand the capabilities of the flight service.
+    */
+   rpc ListActions(Empty) returns (stream ActionType) {}
+ 
+ }
+ 
+ /*
+  * The request that a client provides to a server on handshake.
+  */
+ message HandshakeRequest {
+ 
+   /*
+    * A defined protocol version
+    */
+   uint64 protocol_version = 1;
+ 
+   /*
+    * Arbitrary auth/handshake info.
+    */
+   bytes payload = 2;
+ }
+ 
+ message HandshakeResponse {
+ 
+   /*
+    * A defined protocol version
+    */
+   uint64 protocol_version = 1;
+ 
+   /*
+    * Arbitrary auth/handshake info.
+    */
+   bytes payload = 2;
+ }
+ 
+ /*
+  * A message for doing simple auth.
+  */
+ message BasicAuth {
+   string username = 2;
+   string password = 3;
+ }
+ 
+ message Empty {}
+ 
+ /*
+  * Describes an available action, including both the name used for execution
+  * along with a short description of the purpose of the action.
+  */
+ message ActionType {
+   string type = 1;
+   string description = 2;
+ }
+ 
+ /*
+  * A service specific expression that can be used to return a limited set
+  * of available Arrow Flight streams.
+  */
+ message Criteria {
+   bytes expression = 1;
+ }
+ 
+ /*
+  * An opaque action specific for the service.
+  */
+ message Action {
+   string type = 1;
+   bytes body = 2;
+ }
+ 
+ /*
+  * The request of the CancelFlightInfo action.
+  *
+  * The request should be stored in Action.body.
+  */
+ message CancelFlightInfoRequest {
+   FlightInfo info = 1;
+ }
+ 
+ /*
+  * The request of the RenewFlightEndpoint action.
+  *
+  * The request should be stored in Action.body.
+  */
+ message RenewFlightEndpointRequest {
+   FlightEndpoint endpoint = 1;
+ }
+ 
+ /*
+  * An opaque result returned after executing an action.
+  */
+ message Result {
+   bytes body = 1;
+ }
+ 
+ /*
+  * The result of a cancel operation.
+  *
+  * This is used by CancelFlightInfoResult.status.
+  */
+ enum CancelStatus {
+   // The cancellation status is unknown. Servers should avoid using
+   // this value (send a NOT_FOUND error if the requested query is
+   // not known). Clients can retry the request.
+   CANCEL_STATUS_UNSPECIFIED = 0;
+   // The cancellation request is complete. Subsequent requests with
+   // the same payload may return CANCELLED or a NOT_FOUND error.
+   CANCEL_STATUS_CANCELLED = 1;
+   // The cancellation request is in progress. The client may retry
+   // the cancellation request.
+   CANCEL_STATUS_CANCELLING = 2;
+   // The query is not cancellable. The client should not retry the
+   // cancellation request.
+   CANCEL_STATUS_NOT_CANCELLABLE = 3;
+ }
+ 
+ /*
+  * The result of the CancelFlightInfo action.
+  *
+  * The result should be stored in Result.body.
+  */
+ message CancelFlightInfoResult {
+   CancelStatus status = 1;
+ }
+ 
+ /*
+  * Wrap the result of a getSchema call
+  */
+ message SchemaResult {
+   // The schema of the dataset in its IPC form:
+   //   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+   //   4 bytes - the byte length of the payload
+   //   a flatbuffer Message whose header is the Schema
+   bytes schema = 1;
+ }
+ 
+ /*
+  * The name or tag for a Flight. May be used as a way to retrieve or generate
+  * a flight or be used to expose a set of previously defined flights.
+  */
+ message FlightDescriptor {
+ 
+   /*
+    * Describes what type of descriptor is defined.
+    */
+   enum DescriptorType {
+ 
+     // Protobuf pattern, not used.
+     UNKNOWN = 0;
+ 
+     /*
+      * A named path that identifies a dataset. A path is composed of a string
+      * or list of strings describing a particular dataset. This is conceptually
+      *  similar to a path inside a filesystem.
+      */
+     PATH = 1;
+ 
+     /*
+      * An opaque command to generate a dataset.
+      */
+     CMD = 2;
+   }
+ 
+   DescriptorType type = 1;
+ 
+   /*
+    * Opaque value used to express a command. Should only be defined when
+    * type = CMD.
+    */
+   bytes cmd = 2;
+ 
+   /*
+    * List of strings identifying a particular dataset. Should only be defined
+    * when type = PATH.
+    */
+   repeated string path = 3;
+ }
+ 
+ /*
+  * The access coordinates for retrieval of a dataset. With a FlightInfo, a
+  * consumer is able to determine how to retrieve a dataset.
+  */
+ message FlightInfo {
+   // The schema of the dataset in its IPC form:
+   //   4 bytes - an optional IPC_CONTINUATION_TOKEN prefix
+   //   4 bytes - the byte length of the payload
+   //   a flatbuffer Message whose header is the Schema
+   bytes schema = 1;
+ 
+   /*
+    * The descriptor associated with this info.
+    */
+   FlightDescriptor flight_descriptor = 2;
+ 
+   /*
+    * A list of endpoints associated with the flight. To consume the
+    * whole flight, all endpoints (and hence all Tickets) must be
+    * consumed. Endpoints can be consumed in any order.
+    *
+    * In other words, an application can use multiple endpoints to
+    * represent partitioned data.
+    *
+    * If the returned data has an ordering, an application can use
+    * "FlightInfo.ordered = true" or should return the all data in a
+    * single endpoint. Otherwise, there is no ordering defined on
+    * endpoints or the data within.
+    *
+    * A client can read ordered data by reading data from returned
+    * endpoints, in order, from front to back.
+    *
+    * Note that a client may ignore "FlightInfo.ordered = true". If an
+    * ordering is important for an application, an application must
+    * choose one of them:
+    *
+    * * An application requires that all clients must read data in
+    *   returned endpoints order.
+    * * An application must return the all data in a single endpoint.
+    */
+   repeated FlightEndpoint endpoint = 3;
+ 
+   // Set these to -1 if unknown.
+   int64 total_records = 4;
+   int64 total_bytes = 5;
+ 
+   /*
+    * FlightEndpoints are in the same order as the data.
+    */
+   bool ordered = 6;
+ 
+   /*
+    * Application-defined metadata.
+    * 
+    * There is no inherent or required relationship between this
+    * and the app_metadata fields in the FlightEndpoints or resulting
+    * FlightData messages. Since this metadata is application-defined,
+    * a given application could define there to be a relationship,
+    * but there is none required by the spec.
+    */
+   bytes app_metadata = 7;
+ }
+ 
+ /*
+  * The information to process a long-running query.
+  */
+ message PollInfo {
+   /*
+    * The currently available results.
+    *
+    * If "flight_descriptor" is not specified, the query is complete
+    * and "info" specifies all results. Otherwise, "info" contains
+    * partial query results.
+    *
+    * Note that each PollInfo response contains a complete
+    * FlightInfo (not just the delta between the previous and current
+    * FlightInfo).
+    *
+    * Subsequent PollInfo responses may only append new endpoints to
+    * info.
+    *
+    * Clients can begin fetching results via DoGet(Ticket) with the
+    * ticket in the info before the query is
+    * completed. FlightInfo.ordered is also valid.
+    */
+   FlightInfo info = 1;
+
+   /*
+    * The descriptor the client should use on the next try.
+    * If unset, the query is complete.
+    */
+   FlightDescriptor flight_descriptor = 2;
+
+   /*
+    * Query progress. If known, must be in [0.0, 1.0] but need not be
+    * monotonic or nondecreasing. If unknown, do not set.
+    */
+   optional double progress = 3;
+
+   /*
+    * Expiration time for this request. After this passes, the server
+    * might not accept the retry descriptor anymore (and the query may
+    * be cancelled). This may be updated on a call to PollFlightInfo.
+    */
+   google.protobuf.Timestamp expiration_time = 4;
+ }
+ 
+ /*
+  * A particular stream or split associated with a flight.
+  */
+ message FlightEndpoint {
+ 
+   /*
+    * Token used to retrieve this stream.
+    */
+   Ticket ticket = 1;
+ 
+   /*
+    * A list of URIs where this ticket can be redeemed via DoGet().
+    *
+    * If the list is empty, the expectation is that the ticket can only
+    * be redeemed on the current service where the ticket was
+    * generated.
+    *
+    * If the list is not empty, the expectation is that the ticket can
+    * be redeemed at any of the locations, and that the data returned
+    * will be equivalent. In this case, the ticket may only be redeemed
+    * at one of the given locations, and not (necessarily) on the
+    * current service.
+    *
+    * In other words, an application can use multiple locations to
+    * represent redundant and/or load balanced services.
+    */
+   repeated Location location = 2;
+ 
+   /*
+    * Expiration time of this stream. If present, clients may assume
+    * they can retry DoGet requests. Otherwise, it is
+    * application-defined whether DoGet requests may be retried.
+    */
+   google.protobuf.Timestamp expiration_time = 3;
+
+   /*
+    * Application-defined metadata.
+    * 
+    * There is no inherent or required relationship between this
+    * and the app_metadata fields in the FlightInfo or resulting
+    * FlightData messages. Since this metadata is application-defined,
+    * a given application could define there to be a relationship,
+    * but there is none required by the spec.
+    */
+   bytes app_metadata = 4;
+ }
+ 
+ /*
+  * A location where a Flight service will accept retrieval of a particular
+  * stream given a ticket.
+  */
+ message Location {
+   string uri = 1;
+ }
+ 
+ /*
+  * An opaque identifier that the service can use to retrieve a particular
+  * portion of a stream.
+  *
+  * Tickets are meant to be single use. It is an error/application-defined
+  * behavior to reuse a ticket.
+  */
+ message Ticket {
+   bytes ticket = 1;
+ }
+ 
+ /*
+  * A batch of Arrow data as part of a stream of batches.
+  */
+ message FlightData {
+ 
+   /*
+    * The descriptor of the data. This is only relevant when a client is
+    * starting a new DoPut stream.
+    */
+   FlightDescriptor flight_descriptor = 1;
+ 
+   /*
+    * Header for message data as described in Message.fbs::Message.
+    */
+   bytes data_header = 2;
+ 
+   /*
+    * Application-defined metadata.
+    */
+   bytes app_metadata = 3;
+ 
+   /*
+    * The actual batch of Arrow data. Preferably handled with minimal-copies
+    * coming last in the definition to help with sidecar patterns (it is
+    * expected that some implementations will fetch this field off the wire
+    * with specialized code to avoid extra memory copies).
+    */
+   bytes data_body = 1000;
+ }
+ 
+ /**
+  * The response message associated with the submission of a DoPut.
+  */
+ message PutResult {
+   bytes app_metadata = 1;
+ }
diff --git a/format/FlightSql.proto b/format/FlightSql.proto
index 3e85e348bc9c..f78e77e23278 100644
--- a/format/FlightSql.proto
+++ b/format/FlightSql.proto
@@ -16,1322 +16,1846 @@
  * limitations under the License.
  */
 
-syntax = "proto3";
-import "google/protobuf/descriptor.proto";
-
-option java_package = "org.apache.arrow.flight.sql.impl";
-
-package arrow.flight.protocol.sql;
-
-/*
- * Represents a metadata request. Used in the command member of FlightDescriptor
- * for the following RPC calls:
- *  - GetSchema: return the Arrow schema of the query.
- *  - GetFlightInfo: execute the metadata request.
- *
- * The returned Arrow schema will be:
- * <
- *  info_name: uint32 not null,
- *  value: dense_union<
- *              string_value: utf8,
- *              bool_value: bool,
- *              bigint_value: int64,
- *              int32_bitmask: int32,
- *              string_list: list<string_data: utf8>
- *              int32_to_int32_list_map: map<key: int32, value: list<$data$: int32>>
- * >
- * where there is one row per requested piece of metadata information.
- */
-message CommandGetSqlInfo {
-  option (experimental) = true;
-
-  /*
-   * Values are modelled after ODBC's SQLGetInfo() function. This information is intended to provide
-   * Flight SQL clients with basic, SQL syntax and SQL functions related information.
-   * More information types can be added in future releases.
-   * E.g. more SQL syntax support types, scalar functions support, type conversion support etc.
-   *
-   * Note that the set of metadata may expand.
-   *
-   * Initially, Flight SQL will support the following information types:
-   * - Server Information - Range [0-500)
-   * - Syntax Information - Range [500-1000)
-   * Range [0-10,000) is reserved for defaults (see SqlInfo enum for default options). 
-   * Custom options should start at 10,000.
-   *
-   * If omitted, then all metadata will be retrieved.
-   * Flight SQL Servers may choose to include additional metadata above and beyond the specified set, however they must
-   * at least return the specified set. IDs ranging from 0 to 10,000 (exclusive) are reserved for future use.
-   * If additional metadata is included, the metadata IDs should start from 10,000.
-   */
-  repeated uint32 info = 1;
-}
-
-// Options for CommandGetSqlInfo.
-enum SqlInfo {
-
-  // Server Information [0-500): Provides basic information about the Flight SQL Server.
-
-  // Retrieves a UTF-8 string with the name of the Flight SQL Server.
-  FLIGHT_SQL_SERVER_NAME = 0;
-
-  // Retrieves a UTF-8 string with the native version of the Flight SQL Server.
-  FLIGHT_SQL_SERVER_VERSION = 1;
-
-  // Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server.
-  FLIGHT_SQL_SERVER_ARROW_VERSION = 2;
-
-  /* 
-   * Retrieves a boolean value indicating whether the Flight SQL Server is read only.
-   *
-   * Returns:
-   * - false: if read-write
-   * - true: if read only
-   */
-  FLIGHT_SQL_SERVER_READ_ONLY = 3;
-
-
-  // SQL Syntax Information [500-1000): provides information about SQL syntax supported by the Flight SQL Server.
-
-  /*
-   * Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of catalogs.
-   *
-   * Returns:
-   * - false: if it doesn't support CREATE and DROP of catalogs.
-   * - true: if it supports CREATE and DROP of catalogs.
-   */
-  SQL_DDL_CATALOG = 500;
-
-  /*
-   * Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of schemas.
-   *
-   * Returns:
-   * - false: if it doesn't support CREATE and DROP of schemas.
-   * - true: if it supports CREATE and DROP of schemas.
-   */
-  SQL_DDL_SCHEMA = 501;
-
-  /*
-   * Indicates whether the Flight SQL Server supports CREATE and DROP of tables.
-   *
-   * Returns:
-   * - false: if it doesn't support CREATE and DROP of tables.
-   * - true: if it supports CREATE and DROP of tables.
-   */
-  SQL_DDL_TABLE = 502;
-
-  /*
-   * Retrieves a uint32 value representing the enu uint32 ordinal for the case sensitivity of catalog, table, schema and table names.
-   *
-   * The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
-   */
-  SQL_IDENTIFIER_CASE = 503;
-
-  // Retrieves a UTF-8 string with the supported character(s) used to surround a delimited identifier.
-  SQL_IDENTIFIER_QUOTE_CHAR = 504;
-
-  /*
-   * Retrieves a uint32 value representing the enu uint32 ordinal for the case sensitivity of quoted identifiers.
-   *
-   * The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
-   */
-  SQL_QUOTED_IDENTIFIER_CASE = 505;
-
-  /*
-   * Retrieves a boolean value indicating whether all tables are selectable.
-   *
-   * Returns:
-   * - false: if not all tables are selectable or if none are;
-   * - true: if all tables are selectable.
-   */
-  SQL_ALL_TABLES_ARE_SELECTABLE = 506;
-
-  /*
-   * Retrieves the null ordering.
-   *
-   * Returns a uint32 ordinal for the null ordering being used, as described in
-   * `arrow.flight.protocol.sql.SqlNullOrdering`.
-   */
-  SQL_NULL_ORDERING = 507;
-
-  // Retrieves a UTF-8 string list with values of the supported keywords.
-  SQL_KEYWORDS = 508;
-
-  // Retrieves a UTF-8 string list with values of the supported numeric functions.
-  SQL_NUMERIC_FUNCTIONS = 509;
-
-  // Retrieves a UTF-8 string list with values of the supported string functions.
-  SQL_STRING_FUNCTIONS = 510;
-
-  // Retrieves a UTF-8 string list with values of the supported system functions.
-  SQL_SYSTEM_FUNCTIONS = 511;
-
-  // Retrieves a UTF-8 string list with values of the supported datetime functions.
-  SQL_DATETIME_FUNCTIONS = 512;
-
-  /*
-   * Retrieves the UTF-8 string that can be used to escape wildcard characters.
-   * This is the string that can be used to escape '_' or '%' in the catalog search parameters that are a pattern
-   * (and therefore use one of the wildcard characters).
-   * The '_' character represents any single character; the '%' character represents any sequence of zero or more
-   * characters.
-   */
-  SQL_SEARCH_STRING_ESCAPE = 513;
-
-  /*
-   * Retrieves a UTF-8 string with all the "extra" characters that can be used in unquoted identifier names
-   * (those beyond a-z, A-Z, 0-9 and _).
-   */
-  SQL_EXTRA_NAME_CHARACTERS = 514;
-
-  /*
-   * Retrieves a boolean value indicating whether column aliasing is supported.
-   * If so, the SQL AS clause can be used to provide names for computed columns or to provide alias names for columns
-   * as required.
-   *
-   * Returns:
-   * - false: if column aliasing is unsupported;
-   * - true: if column aliasing is supported.
-   */
-  SQL_SUPPORTS_COLUMN_ALIASING = 515;
-
-  /*
-   * Retrieves a boolean value indicating whether concatenations between null and non-null values being
-   * null are supported.
-   *
-   * - Returns:
-   * - false: if concatenations between null and non-null values being null are unsupported;
-   * - true: if concatenations between null and non-null values being null are supported.
-   */
-  SQL_NULL_PLUS_NULL_IS_NULL = 516;
-
-  /*
-   * Retrieves a map where the key is the type to convert from and the value is a list with the types to convert to,
-   * indicating the supported conversions. Each key and each item on the list value is a value to a predefined type on
-   * SqlSupportsConvert enum.
-   * The returned map will be:  map<int32, list<int32>>
-   */
-  SQL_SUPPORTS_CONVERT = 517;
-
-  /*
-   * Retrieves a boolean value indicating whether, when table correlation names are supported,
-   * they are restricted to being different from the names of the tables.
-   *
-   * Returns:
-   * - false: if table correlation names are unsupported;
-   * - true: if table correlation names are supported.
-   */
-  SQL_SUPPORTS_TABLE_CORRELATION_NAMES = 518;
-
-  /*
-   * Retrieves a boolean value indicating whether, when table correlation names are supported,
-   * they are restricted to being different from the names of the tables.
-   *
-   * Returns:
-   * - false: if different table correlation names are unsupported;
-   * - true: if different table correlation names are supported
-   */
-  SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES = 519;
-
-  /*
-   * Retrieves a boolean value indicating whether expressions in ORDER BY lists are supported.
-   *
-   * Returns:
-   * - false: if expressions in ORDER BY are unsupported;
-   * - true: if expressions in ORDER BY are supported;
-   */
-  SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY = 520;
-
-  /*
-   * Retrieves a boolean value indicating whether using a column that is not in the SELECT statement in a GROUP BY
-   * clause is supported.
-   *
-   * Returns:
-   * - false: if using a column that is not in the SELECT statement in a GROUP BY clause is unsupported;
-   * - true: if using a column that is not in the SELECT statement in a GROUP BY clause is supported.
-   */
-  SQL_SUPPORTS_ORDER_BY_UNRELATED = 521;
-
-  /*
-   * Retrieves the supported GROUP BY commands;
-   *
-   * Returns an int32 bitmask value representing the supported commands.
-   * The returned bitmask should be parsed in order to retrieve the supported commands.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (GROUP BY is unsupported);
-   * - return 1 (\b1)   => [SQL_GROUP_BY_UNRELATED];
-   * - return 2 (\b10)  => [SQL_GROUP_BY_BEYOND_SELECT];
-   * - return 3 (\b11)  => [SQL_GROUP_BY_UNRELATED, SQL_GROUP_BY_BEYOND_SELECT].
-   * Valid GROUP BY types are described under `arrow.flight.protocol.sql.SqlSupportedGroupBy`.
-   */
-  SQL_SUPPORTED_GROUP_BY = 522;
-
-  /*
-   * Retrieves a boolean value indicating whether specifying a LIKE escape clause is supported.
-   *
-   * Returns:
-   * - false: if specifying a LIKE escape clause is unsupported;
-   * - true: if specifying a LIKE escape clause is supported.
-   */
-  SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE = 523;
-
-  /*
-   * Retrieves a boolean value indicating whether columns may be defined as non-nullable.
-   *
-   * Returns:
-   * - false: if columns cannot be defined as non-nullable;
-   * - true: if columns may be defined as non-nullable.
-   */
-  SQL_SUPPORTS_NON_NULLABLE_COLUMNS = 524;
-
-  /*
-   * Retrieves the supported SQL grammar level as per the ODBC specification.
-   *
-   * Returns an int32 bitmask value representing the supported SQL grammar level.
-   * The returned bitmask should be parsed in order to retrieve the supported grammar levels.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (SQL grammar is unsupported);
-   * - return 1 (\b1)   => [SQL_MINIMUM_GRAMMAR];
-   * - return 2 (\b10)  => [SQL_CORE_GRAMMAR];
-   * - return 3 (\b11)  => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR];
-   * - return 4 (\b100) => [SQL_EXTENDED_GRAMMAR];
-   * - return 5 (\b101) => [SQL_MINIMUM_GRAMMAR, SQL_EXTENDED_GRAMMAR];
-   * - return 6 (\b110) => [SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR];
-   * - return 7 (\b111) => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR].
-   * Valid SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedSqlGrammar`.
-   */
-  SQL_SUPPORTED_GRAMMAR = 525;
-
-  /*
-   * Retrieves the supported ANSI92 SQL grammar level.
-   *
-   * Returns an int32 bitmask value representing the supported ANSI92 SQL grammar level.
-   * The returned bitmask should be parsed in order to retrieve the supported commands.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (ANSI92 SQL grammar is unsupported);
-   * - return 1 (\b1)   => [ANSI92_ENTRY_SQL];
-   * - return 2 (\b10)  => [ANSI92_INTERMEDIATE_SQL];
-   * - return 3 (\b11)  => [ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL];
-   * - return 4 (\b100) => [ANSI92_FULL_SQL];
-   * - return 5 (\b101) => [ANSI92_ENTRY_SQL, ANSI92_FULL_SQL];
-   * - return 6 (\b110) => [ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL];
-   * - return 7 (\b111) => [ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL].
-   * Valid ANSI92 SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedAnsi92SqlGrammarLevel`.
-   */
-  SQL_ANSI92_SUPPORTED_LEVEL = 526;
-
-  /*
-   * Retrieves a boolean value indicating whether the SQL Integrity Enhancement Facility is supported.
-   *
-   * Returns:
-   * - false: if the SQL Integrity Enhancement Facility is supported;
-   * - true: if the SQL Integrity Enhancement Facility is supported.
-   */
-  SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY = 527;
-
-  /*
-   * Retrieves the support level for SQL OUTER JOINs.
-   *
-   * Returns a uint3 uint32 ordinal for the SQL ordering being used, as described in
-   * `arrow.flight.protocol.sql.SqlOuterJoinsSupportLevel`.
-   */
-  SQL_OUTER_JOINS_SUPPORT_LEVEL = 528;
-
-  // Retrieves a UTF-8 string with the preferred term for "schema".
-  SQL_SCHEMA_TERM = 529;
-
-  // Retrieves a UTF-8 string with the preferred term for "procedure".
-  SQL_PROCEDURE_TERM = 530;
-
-  // Retrieves a UTF-8 string with the preferred term for "catalog".
-  SQL_CATALOG_TERM = 531;
-
-  /*
-   * Retrieves a boolean value indicating whether a catalog appears at the start of a fully qualified table name.
-   *
-   * - false: if a catalog does not appear at the start of a fully qualified table name;
-   * - true: if a catalog appears at the start of a fully qualified table name.
-   */
-  SQL_CATALOG_AT_START = 532;
-
-  /*
-   * Retrieves the supported actions for a SQL schema.
-   *
-   * Returns an int32 bitmask value representing the supported actions for a SQL schema.
-   * The returned bitmask should be parsed in order to retrieve the supported actions for a SQL schema.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (no supported actions for SQL schema);
-   * - return 1 (\b1)   => [SQL_ELEMENT_IN_PROCEDURE_CALLS];
-   * - return 2 (\b10)  => [SQL_ELEMENT_IN_INDEX_DEFINITIONS];
-   * - return 3 (\b11)  => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS];
-   * - return 4 (\b100) => [SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
-   * - return 5 (\b101) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
-   * - return 6 (\b110) => [SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
-   * - return 7 (\b111) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS].
-   * Valid actions for a SQL schema described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
-   */
-  SQL_SCHEMAS_SUPPORTED_ACTIONS = 533;
-
-  /*
-   * Retrieves the supported actions for a SQL schema.
-   *
-   * Returns an int32 bitmask value representing the supported actions for a SQL catalog.
-   * The returned bitmask should be parsed in order to retrieve the supported actions for a SQL catalog.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (no supported actions for SQL catalog);
-   * - return 1 (\b1)   => [SQL_ELEMENT_IN_PROCEDURE_CALLS];
-   * - return 2 (\b10)  => [SQL_ELEMENT_IN_INDEX_DEFINITIONS];
-   * - return 3 (\b11)  => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS];
-   * - return 4 (\b100) => [SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
-   * - return 5 (\b101) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
-   * - return 6 (\b110) => [SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
-   * - return 7 (\b111) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS].
-   * Valid actions for a SQL catalog are described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
-   */
-  SQL_CATALOGS_SUPPORTED_ACTIONS = 534;
-
-  /*
-   * Retrieves the supported SQL positioned commands.
-   *
-   * Returns an int32 bitmask value representing the supported SQL positioned commands.
-   * The returned bitmask should be parsed in order to retrieve the supported SQL positioned commands.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (no supported SQL positioned commands);
-   * - return 1 (\b1)   => [SQL_POSITIONED_DELETE];
-   * - return 2 (\b10)  => [SQL_POSITIONED_UPDATE];
-   * - return 3 (\b11)  => [SQL_POSITIONED_DELETE, SQL_POSITIONED_UPDATE].
-   * Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedPositionedCommands`.
-   */
-  SQL_SUPPORTED_POSITIONED_COMMANDS = 535;
-
-  /*
-   * Retrieves a boolean value indicating whether SELECT FOR UPDATE statements are supported.
-   *
-   * Returns:
-   * - false: if SELECT FOR UPDATE statements are unsupported;
-   * - true: if SELECT FOR UPDATE statements are supported.
-   */
-  SQL_SELECT_FOR_UPDATE_SUPPORTED = 536;
-
-  /*
-   * Retrieves a boolean value indicating whether stored procedure calls that use the stored procedure escape syntax
-   * are supported.
-   *
-   * Returns:
-   * - false: if stored procedure calls that use the stored procedure escape syntax are unsupported;
-   * - true: if stored procedure calls that use the stored procedure escape syntax are supported.
-   */
-  SQL_STORED_PROCEDURES_SUPPORTED = 537;
-
-  /*
-   * Retrieves the supported SQL subqueries.
-   *
-   * Returns an int32 bitmask value representing the supported SQL subqueries.
-   * The returned bitmask should be parsed in order to retrieve the supported SQL subqueries.
-   *
-   * For instance:
-   * - return 0   (\b0)     => [] (no supported SQL subqueries);
-   * - return 1   (\b1)     => [SQL_SUBQUERIES_IN_COMPARISONS];
-   * - return 2   (\b10)    => [SQL_SUBQUERIES_IN_EXISTS];
-   * - return 3   (\b11)    => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS];
-   * - return 4   (\b100)   => [SQL_SUBQUERIES_IN_INS];
-   * - return 5   (\b101)   => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS];
-   * - return 6   (\b110)   => [SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_EXISTS];
-   * - return 7   (\b111)   => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS];
-   * - return 8   (\b1000)  => [SQL_SUBQUERIES_IN_QUANTIFIEDS];
-   * - return 9   (\b1001)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-   * - return 10  (\b1010)  => [SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-   * - return 11  (\b1011)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-   * - return 12  (\b1100)  => [SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-   * - return 13  (\b1101)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-   * - return 14  (\b1110)  => [SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-   * - return 15  (\b1111)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
-   * - ...
-   * Valid SQL subqueries are described under `arrow.flight.protocol.sql.SqlSupportedSubqueries`.
-   */
-  SQL_SUPPORTED_SUBQUERIES = 538;
-
-  /*
-   * Retrieves a boolean value indicating whether correlated subqueries are supported.
-   *
-   * Returns:
-   * - false: if correlated subqueries are unsupported;
-   * - true: if correlated subqueries are supported.
-   */
-  SQL_CORRELATED_SUBQUERIES_SUPPORTED = 539;
-
-  /*
-   * Retrieves the supported SQL UNIONs.
-   *
-   * Returns an int32 bitmask value representing the supported SQL UNIONs.
-   * The returned bitmask should be parsed in order to retrieve the supported SQL UNIONs.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (no supported SQL positioned commands);
-   * - return 1 (\b1)   => [SQL_UNION];
-   * - return 2 (\b10)  => [SQL_UNION_ALL];
-   * - return 3 (\b11)  => [SQL_UNION, SQL_UNION_ALL].
-   * Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedUnions`.
-   */
-  SQL_SUPPORTED_UNIONS = 540;
-
-  // Retrieves a uint32 value representing the maximum number of hex characters allowed in an inline binary literal.
-  SQL_MAX_BINARY_LITERAL_LENGTH = 541;
-
-  // Retrieves a uint32 value representing the maximum number of characters allowed for a character literal.
-  SQL_MAX_CHAR_LITERAL_LENGTH = 542;
-
-  // Retrieves a uint32 value representing the maximum number of characters allowed for a column name.
-  SQL_MAX_COLUMN_NAME_LENGTH = 543;
-
-  // Retrieves a uint32 value representing the the maximum number of columns allowed in a GROUP BY clause.
-  SQL_MAX_COLUMNS_IN_GROUP_BY = 544;
-
-  // Retrieves a uint32 value representing the maximum number of columns allowed in an index.
-  SQL_MAX_COLUMNS_IN_INDEX = 545;
-
-  // Retrieves a uint32 value representing the maximum number of columns allowed in an ORDER BY clause.
-  SQL_MAX_COLUMNS_IN_ORDER_BY = 546;
-
-  // Retrieves a uint32 value representing the maximum number of columns allowed in a SELECT list.
-  SQL_MAX_COLUMNS_IN_SELECT = 547;
-
-  // Retrieves a uint32 value representing the maximum number of columns allowed in a table.
-  SQL_MAX_COLUMNS_IN_TABLE = 548;
-
-  // Retrieves a uint32 value representing the maximum number of concurrent connections possible.
-  SQL_MAX_CONNECTIONS = 549;
-
-  // Retrieves a uint32 value the maximum number of characters allowed in a cursor name.
-  SQL_MAX_CURSOR_NAME_LENGTH = 550;
-
-  /*
-   * Retrieves a uint32 value representing the maximum number of bytes allowed for an index,
-   * including all of the parts of the index.
-   */
-  SQL_MAX_INDEX_LENGTH = 551;
-
-  // Retrieves a uint32 value representing the maximum number of characters allowed in a schema name.
-  SQL_DB_SCHEMA_NAME_LENGTH = 552;
-
-  // Retrieves a uint32 value representing the maximum number of characters allowed in a procedure name.
-  SQL_MAX_PROCEDURE_NAME_LENGTH = 553;
-
-  // Retrieves a uint32 value representing the maximum number of characters allowed in a catalog name.
-  SQL_MAX_CATALOG_NAME_LENGTH = 554;
-
-  // Retrieves a uint32 value representing the maximum number of bytes allowed in a single row.
-  SQL_MAX_ROW_SIZE = 555;
-
-  /*
-   * Retrieves a boolean indicating whether the return value for the JDBC method getMaxRowSize includes the SQL
-   * data types LONGVARCHAR and LONGVARBINARY.
-   *
-   * Returns:
-   * - false: if return value for the JDBC method getMaxRowSize does
-   *          not include the SQL data types LONGVARCHAR and LONGVARBINARY;
-   * - true: if return value for the JDBC method getMaxRowSize includes
-   *         the SQL data types LONGVARCHAR and LONGVARBINARY.
-   */
-  SQL_MAX_ROW_SIZE_INCLUDES_BLOBS = 556;
-
-  /*
-   * Retrieves a uint32 value representing the maximum number of characters allowed for an SQL statement;
-   * a result of 0 (zero) means that there is no limit or the limit is not known.
-   */
-  SQL_MAX_STATEMENT_LENGTH = 557;
-
-  // Retrieves a uint32 value representing the maximum number of active statements that can be open at the same time.
-  SQL_MAX_STATEMENTS = 558;
-
-  // Retrieves a uint32 value representing the maximum number of characters allowed in a table name.
-  SQL_MAX_TABLE_NAME_LENGTH = 559;
-
-  // Retrieves a uint32 value representing the maximum number of tables allowed in a SELECT statement.
-  SQL_MAX_TABLES_IN_SELECT = 560;
-
-  // Retrieves a uint32 value representing the maximum number of characters allowed in a user name.
-  SQL_MAX_USERNAME_LENGTH = 561;
-
-  /*
-   * Retrieves this database's default transaction isolation level as described in
-   * `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
-   *
-   * Returns a uint32 ordinal for the SQL transaction isolation level.
-   */
-  SQL_DEFAULT_TRANSACTION_ISOLATION = 562;
-
-  /*
-   * Retrieves a boolean value indicating whether transactions are supported. If not, invoking the method commit is a
-   * noop, and the isolation level is `arrow.flight.protocol.sql.SqlTransactionIsolationLevel.TRANSACTION_NONE`.
-   *
-   * Returns:
-   * - false: if transactions are unsupported;
-   * - true: if transactions are supported.
-   */
-  SQL_TRANSACTIONS_SUPPORTED = 563;
-
-  /*
-   * Retrieves the supported transactions isolation levels.
-   *
-   * Returns an int32 bitmask value representing the supported transactions isolation levels.
-   * The returned bitmask should be parsed in order to retrieve the supported transactions isolation levels.
-   *
-   * For instance:
-   * - return 0   (\b0)     => [] (no supported SQL transactions isolation levels);
-   * - return 1   (\b1)     => [SQL_TRANSACTION_NONE];
-   * - return 2   (\b10)    => [SQL_TRANSACTION_READ_UNCOMMITTED];
-   * - return 3   (\b11)    => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED];
-   * - return 4   (\b100)   => [SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 5   (\b101)   => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 6   (\b110)   => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 7   (\b111)   => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 8   (\b1000)  => [SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 9   (\b1001)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 10  (\b1010)  => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 11  (\b1011)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 12  (\b1100)  => [SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 13  (\b1101)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 14  (\b1110)  => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 15  (\b1111)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
-   * - return 16  (\b10000) => [SQL_TRANSACTION_SERIALIZABLE];
-   * - ...
-   * Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
-   */
-  SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS = 564;
-
-  /*
-   * Retrieves a boolean value indicating whether a data definition statement within a transaction forces
-   * the transaction to commit.
-   *
-   * Returns:
-   * - false: if a data definition statement within a transaction does not force the transaction to commit;
-   * - true: if a data definition statement within a transaction forces the transaction to commit.
-   */
-  SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT = 565;
-
-  /*
-   * Retrieves a boolean value indicating whether a data definition statement within a transaction is ignored.
-   *
-   * Returns:
-   * - false: if a data definition statement within a transaction is taken into account;
-   * - true: a data definition statement within a transaction is ignored.
-   */
-  SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED = 566;
-
-  /*
-   * Retrieves an int32 bitmask value representing the supported result set types.
-   * The returned bitmask should be parsed in order to retrieve the supported result set types.
-   *
-   * For instance:
-   * - return 0   (\b0)     => [] (no supported result set types);
-   * - return 1   (\b1)     => [SQL_RESULT_SET_TYPE_UNSPECIFIED];
-   * - return 2   (\b10)    => [SQL_RESULT_SET_TYPE_FORWARD_ONLY];
-   * - return 3   (\b11)    => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY];
-   * - return 4   (\b100)   => [SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
-   * - return 5   (\b101)   => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
-   * - return 6   (\b110)   => [SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
-   * - return 7   (\b111)   => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
-   * - return 8   (\b1000)  => [SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE];
-   * - ...
-   * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetType`.
-   */
-  SQL_SUPPORTED_RESULT_SET_TYPES = 567;
-
-  /*
-   * Returns an int32 bitmask value concurrency types supported for
-   * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_UNSPECIFIED`.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
-   * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
-   * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-   * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-   * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
-   */
-  SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED = 568;
-
-  /*
-   * Returns an int32 bitmask value concurrency types supported for
-   * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_FORWARD_ONLY`.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
-   * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
-   * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-   * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-   * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
-   */
-  SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY = 569;
-
-  /*
-   * Returns an int32 bitmask value concurrency types supported for
-   * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE`.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
-   * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
-   * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-   * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-   * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
-   */
-  SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE = 570;
-
-  /*
-   * Returns an int32 bitmask value concurrency types supported for
-   * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE`.
-   *
-   * For instance:
-   * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
-   * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
-   * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-   * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
-   * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
-   * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
-   */
-  SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE = 571;
-
-  /*
-   * Retrieves a boolean value indicating whether this database supports batch updates.
-   *
-   * - false: if this database does not support batch updates;
-   * - true: if this database supports batch updates.
-   */
-  SQL_BATCH_UPDATES_SUPPORTED = 572;
-
-  /*
-   * Retrieves a boolean value indicating whether this database supports savepoints.
-   *
-   * Returns:
-   * - false: if this database does not support savepoints;
-   * - true: if this database supports savepoints.
-   */
-  SQL_SAVEPOINTS_SUPPORTED = 573;
-
-  /*
-   * Retrieves a boolean value indicating whether named parameters are supported in callable statements.
-   *
-   * Returns:
-   * - false: if named parameters in callable statements are unsupported;
-   * - true: if named parameters in callable statements are supported.
-   */
-  SQL_NAMED_PARAMETERS_SUPPORTED = 574;
-
-  /*
-   * Retrieves a boolean value indicating whether updates made to a LOB are made on a copy or directly to the LOB.
-   *
-   * Returns:
-   * - false: if updates made to a LOB are made directly to the LOB;
-   * - true: if updates made to a LOB are made on a copy.
-   */
-  SQL_LOCATORS_UPDATE_COPY = 575;
-
-  /*
-   * Retrieves a boolean value indicating whether invoking user-defined or vendor functions
-   * using the stored procedure escape syntax is supported.
-   *
-   * Returns:
-   * - false: if invoking user-defined or vendor functions using the stored procedure escape syntax is unsupported;
-   * - true: if invoking user-defined or vendor functions using the stored procedure escape syntax is supported.
-   */
-  SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED = 576;
-}
-
-enum SqlSupportedCaseSensitivity {
-  SQL_CASE_SENSITIVITY_UNKNOWN = 0;
-  SQL_CASE_SENSITIVITY_CASE_INSENSITIVE = 1;
-  SQL_CASE_SENSITIVITY_UPPERCASE = 2;
-  SQL_CASE_SENSITIVITY_LOWERCASE = 3;
-}
-
-enum SqlNullOrdering {
-  SQL_NULLS_SORTED_HIGH = 0;
-  SQL_NULLS_SORTED_LOW = 1;
-  SQL_NULLS_SORTED_AT_START = 2;
-  SQL_NULLS_SORTED_AT_END = 3;
-}
-
-enum SupportedSqlGrammar {
-  SQL_MINIMUM_GRAMMAR = 0;
-  SQL_CORE_GRAMMAR = 1;
-  SQL_EXTENDED_GRAMMAR = 2;
-}
-
-enum SupportedAnsi92SqlGrammarLevel {
-  ANSI92_ENTRY_SQL = 0;
-  ANSI92_INTERMEDIATE_SQL = 1;
-  ANSI92_FULL_SQL = 2;
-}
-
-enum SqlOuterJoinsSupportLevel {
-  SQL_JOINS_UNSUPPORTED = 0;
-  SQL_LIMITED_OUTER_JOINS = 1;
-  SQL_FULL_OUTER_JOINS = 2;
-}
-
-enum SqlSupportedGroupBy {
-  SQL_GROUP_BY_UNRELATED = 0;
-  SQL_GROUP_BY_BEYOND_SELECT = 1;
-}
-
-enum SqlSupportedElementActions {
-  SQL_ELEMENT_IN_PROCEDURE_CALLS = 0;
-  SQL_ELEMENT_IN_INDEX_DEFINITIONS = 1;
-  SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS = 2;
-}
-
-enum SqlSupportedPositionedCommands {
-  SQL_POSITIONED_DELETE = 0;
-  SQL_POSITIONED_UPDATE = 1;
-}
-
-enum SqlSupportedSubqueries {
-  SQL_SUBQUERIES_IN_COMPARISONS = 0;
-  SQL_SUBQUERIES_IN_EXISTS = 1;
-  SQL_SUBQUERIES_IN_INS = 2;
-  SQL_SUBQUERIES_IN_QUANTIFIEDS = 3;
-}
-
-enum SqlSupportedUnions {
-  SQL_UNION = 0;
-  SQL_UNION_ALL = 1;
-}
-
-enum SqlTransactionIsolationLevel {
-  SQL_TRANSACTION_NONE = 0;
-  SQL_TRANSACTION_READ_UNCOMMITTED = 1;
-  SQL_TRANSACTION_READ_COMMITTED = 2;
-  SQL_TRANSACTION_REPEATABLE_READ = 3;
-  SQL_TRANSACTION_SERIALIZABLE = 4;
-}
-
-enum SqlSupportedTransactions {
-  SQL_TRANSACTION_UNSPECIFIED = 0;
-  SQL_DATA_DEFINITION_TRANSACTIONS = 1;
-  SQL_DATA_MANIPULATION_TRANSACTIONS = 2;
-}
-
-enum SqlSupportedResultSetType {
-  SQL_RESULT_SET_TYPE_UNSPECIFIED = 0;
-  SQL_RESULT_SET_TYPE_FORWARD_ONLY = 1;
-  SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE = 2;
-  SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE = 3;
-}
-
-enum SqlSupportedResultSetConcurrency {
-  SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED = 0;
-  SQL_RESULT_SET_CONCURRENCY_READ_ONLY = 1;
-  SQL_RESULT_SET_CONCURRENCY_UPDATABLE = 2;
-}
-
-enum SqlSupportsConvert {
-  SQL_CONVERT_BIGINT = 0;
-  SQL_CONVERT_BINARY = 1;
-  SQL_CONVERT_BIT = 2;
-  SQL_CONVERT_CHAR = 3;
-  SQL_CONVERT_DATE = 4;
-  SQL_CONVERT_DECIMAL = 5;
-  SQL_CONVERT_FLOAT = 6;
-  SQL_CONVERT_INTEGER = 7;
-  SQL_CONVERT_INTERVAL_DAY_TIME = 8;
-  SQL_CONVERT_INTERVAL_YEAR_MONTH = 9;
-  SQL_CONVERT_LONGVARBINARY = 10;
-  SQL_CONVERT_LONGVARCHAR = 11;
-  SQL_CONVERT_NUMERIC = 12;
-  SQL_CONVERT_REAL = 13;
-  SQL_CONVERT_SMALLINT = 14;
-  SQL_CONVERT_TIME = 15;
-  SQL_CONVERT_TIMESTAMP = 16;
-  SQL_CONVERT_TINYINT = 17;
-  SQL_CONVERT_VARBINARY = 18;
-  SQL_CONVERT_VARCHAR = 19;
-}
-
-/*
- * Represents a request to retrieve the list of catalogs on a Flight SQL enabled backend.
- * The definition of a catalog depends on vendor/implementation. It is usually the database itself
- * Used in the command member of FlightDescriptor for the following RPC calls:
- *  - GetSchema: return the Arrow schema of the query.
- *  - GetFlightInfo: execute the catalog metadata request.
- *
- * The returned Arrow schema will be:
- * <
- *  catalog_name: utf8 not null
- * >
- * The returned data should be ordered by catalog_name.
- */
-message CommandGetCatalogs {
-  option (experimental) = true;
-}
-
-/*
- * Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend.
- * The definition of a database schema depends on vendor/implementation. It is usually a collection of tables.
- * Used in the command member of FlightDescriptor for the following RPC calls:
- *  - GetSchema: return the Arrow schema of the query.
- *  - GetFlightInfo: execute the catalog metadata request.
- *
- * The returned Arrow schema will be:
- * <
- *  catalog_name: utf8,
- *  db_schema_name: utf8 not null
- * >
- * The returned data should be ordered by catalog_name, then db_schema_name.
- */
-message CommandGetDbSchemas {
-  option (experimental) = true;
-
-  /*
-   * Specifies the Catalog to search for the tables.
-   * An empty string retrieves those without a catalog.
-   * If omitted the catalog name should not be used to narrow the search.
-   */
-  optional string catalog = 1;
-
-  /*
-   * Specifies a filter pattern for schemas to search for.
-   * When no db_schema_filter_pattern is provided, the pattern will not be used to narrow the search.
-   * In the pattern string, two special characters can be used to denote matching rules:
-   *    - "%" means to match any substring with 0 or more characters.
-   *    - "_" means to match any one character.
-   */
-  optional string db_schema_filter_pattern = 2;
-}
-
-/*
- * Represents a request to retrieve the list of tables, and optionally their schemas, on a Flight SQL enabled backend.
- * Used in the command member of FlightDescriptor for the following RPC calls:
- *  - GetSchema: return the Arrow schema of the query.
- *  - GetFlightInfo: execute the catalog metadata request.
- *
- * The returned Arrow schema will be:
- * <
- *  catalog_name: utf8,
- *  db_schema_name: utf8,
- *  table_name: utf8 not null,
- *  table_type: utf8 not null,
- *  [optional] table_schema: bytes not null (schema of the table as described in Schema.fbs::Schema,
- *                                           it is serialized as an IPC message.)
- * >
- * The returned data should be ordered by catalog_name, db_schema_name, table_name, then table_type, followed by table_schema if requested.
- */
-message CommandGetTables {
-  option (experimental) = true;
-
-  /*
-   * Specifies the Catalog to search for the tables.
-   * An empty string retrieves those without a catalog.
-   * If omitted the catalog name should not be used to narrow the search.
-   */
-  optional string catalog = 1;
-
-  /*
-   * Specifies a filter pattern for schemas to search for.
-   * When no db_schema_filter_pattern is provided, all schemas matching other filters are searched.
-   * In the pattern string, two special characters can be used to denote matching rules:
-   *    - "%" means to match any substring with 0 or more characters.
-   *    - "_" means to match any one character.
-   */
-  optional string db_schema_filter_pattern = 2;
-
-  /*
-   * Specifies a filter pattern for tables to search for.
-   * When no table_name_filter_pattern is provided, all tables matching other filters are searched.
-   * In the pattern string, two special characters can be used to denote matching rules:
-   *    - "%" means to match any substring with 0 or more characters.
-   *    - "_" means to match any one character.
-   */
-  optional string table_name_filter_pattern = 3;
-
-  /*
-   * Specifies a filter of table types which must match.
-   * The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
-   * TABLE, VIEW, and SYSTEM TABLE are commonly supported.
-   */
-  repeated string table_types = 4;
-
-  // Specifies if the Arrow schema should be returned for found tables.
-  bool include_schema = 5;
-}
-
-/*
- * Represents a request to retrieve the list of table types on a Flight SQL enabled backend.
- * The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
- * TABLE, VIEW, and SYSTEM TABLE are commonly supported.
- * Used in the command member of FlightDescriptor for the following RPC calls:
- *  - GetSchema: return the Arrow schema of the query.
- *  - GetFlightInfo: execute the catalog metadata request.
- *
- * The returned Arrow schema will be:
- * <
- *  table_type: utf8 not null
- * >
- * The returned data should be ordered by table_type.
- */
-message CommandGetTableTypes {
-  option (experimental) = true;
-}
-
-/*
- * Represents a request to retrieve the primary keys of a table on a Flight SQL enabled backend.
- * Used in the command member of FlightDescriptor for the following RPC calls:
- *  - GetSchema: return the Arrow schema of the query.
- *  - GetFlightInfo: execute the catalog metadata request.
- *
- * The returned Arrow schema will be:
- * <
- *  catalog_name: utf8,
- *  db_schema_name: utf8,
- *  table_name: utf8 not null,
- *  column_name: utf8 not null,
- *  key_name: utf8,
- *  key_sequence: int not null
- * >
- * The returned data should be ordered by catalog_name, db_schema_name, table_name, key_name, then key_sequence.
- */
-message CommandGetPrimaryKeys {
-  option (experimental) = true;
-
-  /*
-   * Specifies the catalog to search for the table.
-   * An empty string retrieves those without a catalog.
-   * If omitted the catalog name should not be used to narrow the search.
-   */
-  optional string catalog = 1;
-
-  /*
-   * Specifies the schema to search for the table.
-   * An empty string retrieves those without a schema.
-   * If omitted the schema name should not be used to narrow the search.
-   */
-  optional string db_schema = 2;
-
-  // Specifies the table to get the primary keys for.
-  string table = 3;
-}
-
-enum UpdateDeleteRules {
-  CASCADE = 0;
-  RESTRICT = 1;
-  SET_NULL = 2;
-  NO_ACTION = 3;
-  SET_DEFAULT = 4;
-}
-
-/*
- * Represents a request to retrieve a description of the foreign key columns that reference the given table's
- * primary key columns (the foreign keys exported by a table) of a table on a Flight SQL enabled backend.
- * Used in the command member of FlightDescriptor for the following RPC calls:
- *  - GetSchema: return the Arrow schema of the query.
- *  - GetFlightInfo: execute the catalog metadata request.
- *
- * The returned Arrow schema will be:
- * <
- *  pk_catalog_name: utf8,
- *  pk_db_schema_name: utf8,
- *  pk_table_name: utf8 not null,
- *  pk_column_name: utf8 not null,
- *  fk_catalog_name: utf8,
- *  fk_db_schema_name: utf8,
- *  fk_table_name: utf8 not null,
- *  fk_column_name: utf8 not null,
- *  key_sequence: int not null,
- *  fk_key_name: utf8,
- *  pk_key_name: utf8,
- *  update_rule: uint1 not null,
- *  delete_rule: uint1 not null
- * >
- * The returned data should be ordered by fk_catalog_name, fk_db_schema_name, fk_table_name, fk_key_name, then key_sequence.
- * update_rule and delete_rule returns a byte that is equivalent to actions declared on UpdateDeleteRules enum.
- */
-message CommandGetExportedKeys {
-  option (experimental) = true;
-
-  /*
-   * Specifies the catalog to search for the foreign key table.
-   * An empty string retrieves those without a catalog.
-   * If omitted the catalog name should not be used to narrow the search.
-   */
-  optional string catalog = 1;
-
-  /*
-   * Specifies the schema to search for the foreign key table.
-   * An empty string retrieves those without a schema.
-   * If omitted the schema name should not be used to narrow the search.
-   */
-  optional string db_schema = 2;
-
-  // Specifies the foreign key table to get the foreign keys for.
-  string table = 3;
-}
-
-/*
- * Represents a request to retrieve the foreign keys of a table on a Flight SQL enabled backend.
- * Used in the command member of FlightDescriptor for the following RPC calls:
- *  - GetSchema: return the Arrow schema of the query.
- *  - GetFlightInfo: execute the catalog metadata request.
- *
- * The returned Arrow schema will be:
- * <
- *  pk_catalog_name: utf8,
- *  pk_db_schema_name: utf8,
- *  pk_table_name: utf8 not null,
- *  pk_column_name: utf8 not null,
- *  fk_catalog_name: utf8,
- *  fk_db_schema_name: utf8,
- *  fk_table_name: utf8 not null,
- *  fk_column_name: utf8 not null,
- *  key_sequence: int not null,
- *  fk_key_name: utf8,
- *  pk_key_name: utf8,
- *  update_rule: uint1 not null,
- *  delete_rule: uint1 not null
- * >
- * The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
- * update_rule and delete_rule returns a byte that is equivalent to actions:
- *    - 0 = CASCADE
- *    - 1 = RESTRICT
- *    - 2 = SET NULL
- *    - 3 = NO ACTION
- *    - 4 = SET DEFAULT
- */
-message CommandGetImportedKeys {
-  option (experimental) = true;
-
-  /*
-   * Specifies the catalog to search for the primary key table.
-   * An empty string retrieves those without a catalog.
-   * If omitted the catalog name should not be used to narrow the search.
-   */
-  optional string catalog = 1;
-
-  /*
-   * Specifies the schema to search for the primary key table.
-   * An empty string retrieves those without a schema.
-   * If omitted the schema name should not be used to narrow the search.
-   */
-  optional string db_schema = 2;
-
-  // Specifies the primary key table to get the foreign keys for.
-  string table = 3;
-}
-
-/*
- * Represents a request to retrieve a description of the foreign key columns in the given foreign key table that
- * reference the primary key or the columns representing a unique constraint of the parent table (could be the same
- * or a different table) on a Flight SQL enabled backend.
- * Used in the command member of FlightDescriptor for the following RPC calls:
- *  - GetSchema: return the Arrow schema of the query.
- *  - GetFlightInfo: execute the catalog metadata request.
- *
- * The returned Arrow schema will be:
- * <
- *  pk_catalog_name: utf8,
- *  pk_db_schema_name: utf8,
- *  pk_table_name: utf8 not null,
- *  pk_column_name: utf8 not null,
- *  fk_catalog_name: utf8,
- *  fk_db_schema_name: utf8,
- *  fk_table_name: utf8 not null,
- *  fk_column_name: utf8 not null,
- *  key_sequence: int not null,
- *  fk_key_name: utf8,
- *  pk_key_name: utf8,
- *  update_rule: uint1 not null,
- *  delete_rule: uint1 not null
- * >
- * The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
- * update_rule and delete_rule returns a byte that is equivalent to actions:
- *    - 0 = CASCADE
- *    - 1 = RESTRICT
- *    - 2 = SET NULL
- *    - 3 = NO ACTION
- *    - 4 = SET DEFAULT
- */
-message CommandGetCrossReference {
-  option (experimental) = true;
-
-  /**
-   * The catalog name where the parent table is.
-   * An empty string retrieves those without a catalog.
-   * If omitted the catalog name should not be used to narrow the search.
-   */
-  optional string pk_catalog = 1;
-
-  /**
-   * The Schema name where the parent table is.
-   * An empty string retrieves those without a schema.
-   * If omitted the schema name should not be used to narrow the search.
-   */
-  optional string pk_db_schema = 2;
-
-  /**
-   * The parent table name. It cannot be null.
-   */
-  string pk_table = 3;
-
-  /**
-   * The catalog name where the foreign table is.
-   * An empty string retrieves those without a catalog.
-   * If omitted the catalog name should not be used to narrow the search.
-   */
-  optional string fk_catalog = 4;
-
-  /**
-   * The schema name where the foreign table is.
-   * An empty string retrieves those without a schema.
-   * If omitted the schema name should not be used to narrow the search.
-   */
-  optional string fk_db_schema = 5;
-
-  /**
-   * The foreign table name. It cannot be null.
-   */
-  string fk_table = 6;
-}
-
-// SQL Execution Action Messages
-
-/*
- * Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
- */
-message ActionCreatePreparedStatementRequest {
-  option (experimental) = true;
-
-  // The valid SQL string to create a prepared statement for.
-  string query = 1;
-}
-
-/*
- * Wrap the result of a "GetPreparedStatement" action.
- *
- * The resultant PreparedStatement can be closed either:
- * - Manually, through the "ClosePreparedStatement" action;
- * - Automatically, by a server timeout.
- */
-message ActionCreatePreparedStatementResult {
-  option (experimental) = true;
-
-  // Opaque handle for the prepared statement on the server.
-  bytes prepared_statement_handle = 1;
-
-  // If a result set generating query was provided, dataset_schema contains the 
-  // schema of the dataset as described in Schema.fbs::Schema, it is serialized as an IPC message.
-  bytes dataset_schema = 2;
-
-  // If the query provided contained parameters, parameter_schema contains the 
-  // schema of the expected parameters as described in Schema.fbs::Schema, it is serialized as an IPC message.
-  bytes parameter_schema = 3;
-}
-
-/*
- * Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
- * Closes server resources associated with the prepared statement handle.
- */
-message ActionClosePreparedStatementRequest {
-  option (experimental) = true;
-
-  // Opaque handle for the prepared statement on the server.
-  bytes prepared_statement_handle = 1;
-}
-
-
-// SQL Execution Messages.
-
-/*
- * Represents a SQL query. Used in the command member of FlightDescriptor
- * for the following RPC calls:
- *  - GetSchema: return the Arrow schema of the query.
- *  - GetFlightInfo: execute the query.
- */
-message CommandStatementQuery {
-  option (experimental) = true;
-
-  // The SQL syntax.
-  string query = 1;
-}
-
-/**
- * Represents a ticket resulting from GetFlightInfo with a CommandStatementQuery.
- * This should be used only once and treated as an opaque value, that is, clients should not attempt to parse this.
- */
-message TicketStatementQuery {
-  option (experimental) = true;
-
-  // Unique identifier for the instance of the statement to execute.
-  bytes statement_handle = 1;
-}
-
-/*
- * Represents an instance of executing a prepared statement. Used in the command member of FlightDescriptor for
- * the following RPC calls:
- *  - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
- *  - GetFlightInfo: execute the prepared statement instance.
- */
-message CommandPreparedStatementQuery {
-  option (experimental) = true;
-
-  // Opaque handle for the prepared statement on the server.
-  bytes prepared_statement_handle = 1;
-}
-
-/*
- * Represents a SQL update query. Used in the command member of FlightDescriptor
- * for the the RPC call DoPut to cause the server to execute the included SQL update.
- */
-message CommandStatementUpdate {
-  option (experimental) = true;
-
-  // The SQL syntax.
-  string query = 1;
-}
-
-/*
- * Represents a SQL update query. Used in the command member of FlightDescriptor
- * for the the RPC call DoPut to cause the server to execute the included 
- * prepared statement handle as an update.
- */
-message CommandPreparedStatementUpdate {
-  option (experimental) = true;
-
-  // Opaque handle for the prepared statement on the server.
-  bytes prepared_statement_handle = 1;
-}
-
-/*
- * Returned from the RPC call DoPut when a CommandStatementUpdate
- * CommandPreparedStatementUpdate was in the request, containing
- * results from the update. 
- */
-message DoPutUpdateResult {
-  option (experimental) = true;
-
-  // The number of records updated. A return value of -1 represents 
-  // an unknown updated record count.
-  int64 record_count = 1;
-}
-
-extend google.protobuf.MessageOptions {
-  bool experimental = 1000;
-}
+ syntax = "proto3";
+ import "google/protobuf/descriptor.proto";
+ 
+ option java_package = "org.apache.arrow.flight.sql.impl";
+ option go_package = "github.com/apache/arrow/go/arrow/flight/gen/flight";
+ package arrow.flight.protocol.sql;
+ 
+ /*
+  * Represents a metadata request. Used in the command member of FlightDescriptor
+  * for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *  - GetFlightInfo: execute the metadata request.
+  *
+  * The returned Arrow schema will be:
+  * <
+  *  info_name: uint32 not null,
+  *  value: dense_union<
+  *              string_value: utf8,
+  *              bool_value: bool,
+  *              bigint_value: int64,
+  *              int32_bitmask: int32,
+  *              string_list: list<string_data: utf8>
+  *              int32_to_int32_list_map: map<key: int32, value: list<$data$: int32>>
+  * >
+  * where there is one row per requested piece of metadata information.
+  */
+ message CommandGetSqlInfo {
+   option (experimental) = true;
+ 
+   /*
+    * Values are modelled after ODBC's SQLGetInfo() function. This information is intended to provide
+    * Flight SQL clients with basic, SQL syntax and SQL functions related information.
+    * More information types can be added in future releases.
+    * E.g. more SQL syntax support types, scalar functions support, type conversion support etc.
+    *
+    * Note that the set of metadata may expand.
+    *
+    * Initially, Flight SQL will support the following information types:
+    * - Server Information - Range [0-500)
+    * - Syntax Information - Range [500-1000)
+    * Range [0-10,000) is reserved for defaults (see SqlInfo enum for default options).
+    * Custom options should start at 10,000.
+    *
+    * If omitted, then all metadata will be retrieved.
+    * Flight SQL Servers may choose to include additional metadata above and beyond the specified set, however they must
+    * at least return the specified set. IDs ranging from 0 to 10,000 (exclusive) are reserved for future use.
+    * If additional metadata is included, the metadata IDs should start from 10,000.
+    */
+   repeated uint32 info = 1;
+ }
+ 
+ // Options for CommandGetSqlInfo.
+ enum SqlInfo {
+ 
+   // Server Information [0-500): Provides basic information about the Flight SQL Server.
+ 
+   // Retrieves a UTF-8 string with the name of the Flight SQL Server.
+   FLIGHT_SQL_SERVER_NAME = 0;
+ 
+   // Retrieves a UTF-8 string with the native version of the Flight SQL Server.
+   FLIGHT_SQL_SERVER_VERSION = 1;
+ 
+   // Retrieves a UTF-8 string with the Arrow format version of the Flight SQL Server.
+   FLIGHT_SQL_SERVER_ARROW_VERSION = 2;
+ 
+   /*
+    * Retrieves a boolean value indicating whether the Flight SQL Server is read only.
+    *
+    * Returns:
+    * - false: if read-write
+    * - true: if read only
+    */
+   FLIGHT_SQL_SERVER_READ_ONLY = 3;
+ 
+   /*
+    * Retrieves a boolean value indicating whether the Flight SQL Server supports executing
+    * SQL queries.
+    *
+    * Note that the absence of this info (as opposed to a false value) does not necessarily
+    * mean that SQL is not supported, as this property was not originally defined.
+    */
+   FLIGHT_SQL_SERVER_SQL = 4;
+ 
+   /*
+    * Retrieves a boolean value indicating whether the Flight SQL Server supports executing
+    * Substrait plans.
+    */
+   FLIGHT_SQL_SERVER_SUBSTRAIT = 5;
+ 
+   /*
+    * Retrieves a string value indicating the minimum supported Substrait version, or null
+    * if Substrait is not supported.
+    */
+   FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION = 6;
+ 
+   /*
+    * Retrieves a string value indicating the maximum supported Substrait version, or null
+    * if Substrait is not supported.
+    */
+   FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION = 7;
+ 
+   /*
+    * Retrieves an int32 indicating whether the Flight SQL Server supports the
+    * BeginTransaction/EndTransaction/BeginSavepoint/EndSavepoint actions.
+    *
+    * Even if this is not supported, the database may still support explicit "BEGIN
+    * TRANSACTION"/"COMMIT" SQL statements (see SQL_TRANSACTIONS_SUPPORTED); this property
+    * is only about whether the server implements the Flight SQL API endpoints.
+    *
+    * The possible values are listed in `SqlSupportedTransaction`.
+    */
+   FLIGHT_SQL_SERVER_TRANSACTION = 8;
+ 
+   /*
+    * Retrieves a boolean value indicating whether the Flight SQL Server supports explicit
+    * query cancellation (the CancelQuery action).
+    */
+   FLIGHT_SQL_SERVER_CANCEL = 9;
+ 
+   /*
+    * Retrieves an int32 indicating the timeout (in milliseconds) for prepared statement handles.
+    *
+    * If 0, there is no timeout.  Servers should reset the timeout when the handle is used in a command.
+    */
+   FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT = 100;
+ 
+   /*
+    * Retrieves an int32 indicating the timeout (in milliseconds) for transactions, since transactions are not tied to a connection.
+    *
+    * If 0, there is no timeout.  Servers should reset the timeout when the handle is used in a command.
+    */
+   FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT = 101;
+ 
+   // SQL Syntax Information [500-1000): provides information about SQL syntax supported by the Flight SQL Server.
+ 
+   /*
+    * Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of catalogs.
+    *
+    * Returns:
+    * - false: if it doesn't support CREATE and DROP of catalogs.
+    * - true: if it supports CREATE and DROP of catalogs.
+    */
+   SQL_DDL_CATALOG = 500;
+ 
+   /*
+    * Retrieves a boolean value indicating whether the Flight SQL Server supports CREATE and DROP of schemas.
+    *
+    * Returns:
+    * - false: if it doesn't support CREATE and DROP of schemas.
+    * - true: if it supports CREATE and DROP of schemas.
+    */
+   SQL_DDL_SCHEMA = 501;
+ 
+   /*
+    * Indicates whether the Flight SQL Server supports CREATE and DROP of tables.
+    *
+    * Returns:
+    * - false: if it doesn't support CREATE and DROP of tables.
+    * - true: if it supports CREATE and DROP of tables.
+    */
+   SQL_DDL_TABLE = 502;
+ 
+   /*
+    * Retrieves a int32 ordinal representing the case sensitivity of catalog, table, schema and table names.
+    *
+    * The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
+    */
+   SQL_IDENTIFIER_CASE = 503;
+ 
+   // Retrieves a UTF-8 string with the supported character(s) used to surround a delimited identifier.
+   SQL_IDENTIFIER_QUOTE_CHAR = 504;
+ 
+   /*
+    * Retrieves a int32 describing the case sensitivity of quoted identifiers.
+    *
+    * The possible values are listed in `arrow.flight.protocol.sql.SqlSupportedCaseSensitivity`.
+    */
+   SQL_QUOTED_IDENTIFIER_CASE = 505;
+ 
+   /*
+    * Retrieves a boolean value indicating whether all tables are selectable.
+    *
+    * Returns:
+    * - false: if not all tables are selectable or if none are;
+    * - true: if all tables are selectable.
+    */
+   SQL_ALL_TABLES_ARE_SELECTABLE = 506;
+ 
+   /*
+    * Retrieves the null ordering.
+    *
+    * Returns a int32 ordinal for the null ordering being used, as described in
+    * `arrow.flight.protocol.sql.SqlNullOrdering`.
+    */
+   SQL_NULL_ORDERING = 507;
+ 
+   // Retrieves a UTF-8 string list with values of the supported keywords.
+   SQL_KEYWORDS = 508;
+ 
+   // Retrieves a UTF-8 string list with values of the supported numeric functions.
+   SQL_NUMERIC_FUNCTIONS = 509;
+ 
+   // Retrieves a UTF-8 string list with values of the supported string functions.
+   SQL_STRING_FUNCTIONS = 510;
+ 
+   // Retrieves a UTF-8 string list with values of the supported system functions.
+   SQL_SYSTEM_FUNCTIONS = 511;
+ 
+   // Retrieves a UTF-8 string list with values of the supported datetime functions.
+   SQL_DATETIME_FUNCTIONS = 512;
+ 
+   /*
+    * Retrieves the UTF-8 string that can be used to escape wildcard characters.
+    * This is the string that can be used to escape '_' or '%' in the catalog search parameters that are a pattern
+    * (and therefore use one of the wildcard characters).
+    * The '_' character represents any single character; the '%' character represents any sequence of zero or more
+    * characters.
+    */
+   SQL_SEARCH_STRING_ESCAPE = 513;
+ 
+   /*
+    * Retrieves a UTF-8 string with all the "extra" characters that can be used in unquoted identifier names
+    * (those beyond a-z, A-Z, 0-9 and _).
+    */
+   SQL_EXTRA_NAME_CHARACTERS = 514;
+ 
+   /*
+    * Retrieves a boolean value indicating whether column aliasing is supported.
+    * If so, the SQL AS clause can be used to provide names for computed columns or to provide alias names for columns
+    * as required.
+    *
+    * Returns:
+    * - false: if column aliasing is unsupported;
+    * - true: if column aliasing is supported.
+    */
+   SQL_SUPPORTS_COLUMN_ALIASING = 515;
+ 
+   /*
+    * Retrieves a boolean value indicating whether concatenations between null and non-null values being
+    * null are supported.
+    *
+    * - Returns:
+    * - false: if concatenations between null and non-null values being null are unsupported;
+    * - true: if concatenations between null and non-null values being null are supported.
+    */
+   SQL_NULL_PLUS_NULL_IS_NULL = 516;
+ 
+   /*
+    * Retrieves a map where the key is the type to convert from and the value is a list with the types to convert to,
+    * indicating the supported conversions. Each key and each item on the list value is a value to a predefined type on
+    * SqlSupportsConvert enum.
+    * The returned map will be:  map<int32, list<int32>>
+    */
+   SQL_SUPPORTS_CONVERT = 517;
+ 
+   /*
+    * Retrieves a boolean value indicating whether, when table correlation names are supported,
+    * they are restricted to being different from the names of the tables.
+    *
+    * Returns:
+    * - false: if table correlation names are unsupported;
+    * - true: if table correlation names are supported.
+    */
+   SQL_SUPPORTS_TABLE_CORRELATION_NAMES = 518;
+ 
+   /*
+    * Retrieves a boolean value indicating whether, when table correlation names are supported,
+    * they are restricted to being different from the names of the tables.
+    *
+    * Returns:
+    * - false: if different table correlation names are unsupported;
+    * - true: if different table correlation names are supported
+    */
+   SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES = 519;
+ 
+   /*
+    * Retrieves a boolean value indicating whether expressions in ORDER BY lists are supported.
+    *
+    * Returns:
+    * - false: if expressions in ORDER BY are unsupported;
+    * - true: if expressions in ORDER BY are supported;
+    */
+   SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY = 520;
+ 
+   /*
+    * Retrieves a boolean value indicating whether using a column that is not in the SELECT statement in a GROUP BY
+    * clause is supported.
+    *
+    * Returns:
+    * - false: if using a column that is not in the SELECT statement in a GROUP BY clause is unsupported;
+    * - true: if using a column that is not in the SELECT statement in a GROUP BY clause is supported.
+    */
+   SQL_SUPPORTS_ORDER_BY_UNRELATED = 521;
+ 
+   /*
+    * Retrieves the supported GROUP BY commands;
+    *
+    * Returns an int32 bitmask value representing the supported commands.
+    * The returned bitmask should be parsed in order to retrieve the supported commands.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (GROUP BY is unsupported);
+    * - return 1 (\b1)   => [SQL_GROUP_BY_UNRELATED];
+    * - return 2 (\b10)  => [SQL_GROUP_BY_BEYOND_SELECT];
+    * - return 3 (\b11)  => [SQL_GROUP_BY_UNRELATED, SQL_GROUP_BY_BEYOND_SELECT].
+    * Valid GROUP BY types are described under `arrow.flight.protocol.sql.SqlSupportedGroupBy`.
+    */
+   SQL_SUPPORTED_GROUP_BY = 522;
+ 
+   /*
+    * Retrieves a boolean value indicating whether specifying a LIKE escape clause is supported.
+    *
+    * Returns:
+    * - false: if specifying a LIKE escape clause is unsupported;
+    * - true: if specifying a LIKE escape clause is supported.
+    */
+   SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE = 523;
+ 
+   /*
+    * Retrieves a boolean value indicating whether columns may be defined as non-nullable.
+    *
+    * Returns:
+    * - false: if columns cannot be defined as non-nullable;
+    * - true: if columns may be defined as non-nullable.
+    */
+   SQL_SUPPORTS_NON_NULLABLE_COLUMNS = 524;
+ 
+   /*
+    * Retrieves the supported SQL grammar level as per the ODBC specification.
+    *
+    * Returns an int32 bitmask value representing the supported SQL grammar level.
+    * The returned bitmask should be parsed in order to retrieve the supported grammar levels.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (SQL grammar is unsupported);
+    * - return 1 (\b1)   => [SQL_MINIMUM_GRAMMAR];
+    * - return 2 (\b10)  => [SQL_CORE_GRAMMAR];
+    * - return 3 (\b11)  => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR];
+    * - return 4 (\b100) => [SQL_EXTENDED_GRAMMAR];
+    * - return 5 (\b101) => [SQL_MINIMUM_GRAMMAR, SQL_EXTENDED_GRAMMAR];
+    * - return 6 (\b110) => [SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR];
+    * - return 7 (\b111) => [SQL_MINIMUM_GRAMMAR, SQL_CORE_GRAMMAR, SQL_EXTENDED_GRAMMAR].
+    * Valid SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedSqlGrammar`.
+    */
+   SQL_SUPPORTED_GRAMMAR = 525;
+ 
+   /*
+    * Retrieves the supported ANSI92 SQL grammar level.
+    *
+    * Returns an int32 bitmask value representing the supported ANSI92 SQL grammar level.
+    * The returned bitmask should be parsed in order to retrieve the supported commands.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (ANSI92 SQL grammar is unsupported);
+    * - return 1 (\b1)   => [ANSI92_ENTRY_SQL];
+    * - return 2 (\b10)  => [ANSI92_INTERMEDIATE_SQL];
+    * - return 3 (\b11)  => [ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL];
+    * - return 4 (\b100) => [ANSI92_FULL_SQL];
+    * - return 5 (\b101) => [ANSI92_ENTRY_SQL, ANSI92_FULL_SQL];
+    * - return 6 (\b110) => [ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL];
+    * - return 7 (\b111) => [ANSI92_ENTRY_SQL, ANSI92_INTERMEDIATE_SQL, ANSI92_FULL_SQL].
+    * Valid ANSI92 SQL grammar levels are described under `arrow.flight.protocol.sql.SupportedAnsi92SqlGrammarLevel`.
+    */
+   SQL_ANSI92_SUPPORTED_LEVEL = 526;
+ 
+   /*
+    * Retrieves a boolean value indicating whether the SQL Integrity Enhancement Facility is supported.
+    *
+    * Returns:
+    * - false: if the SQL Integrity Enhancement Facility is supported;
+    * - true: if the SQL Integrity Enhancement Facility is supported.
+    */
+   SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY = 527;
+ 
+   /*
+    * Retrieves the support level for SQL OUTER JOINs.
+    *
+    * Returns a int32 ordinal for the SQL ordering being used, as described in
+    * `arrow.flight.protocol.sql.SqlOuterJoinsSupportLevel`.
+    */
+   SQL_OUTER_JOINS_SUPPORT_LEVEL = 528;
+ 
+   // Retrieves a UTF-8 string with the preferred term for "schema".
+   SQL_SCHEMA_TERM = 529;
+ 
+   // Retrieves a UTF-8 string with the preferred term for "procedure".
+   SQL_PROCEDURE_TERM = 530;
+ 
+   /*
+    * Retrieves a UTF-8 string with the preferred term for "catalog".
+    * If a empty string is returned its assumed that the server does NOT supports catalogs.
+    */
+   SQL_CATALOG_TERM = 531;
+ 
+   /*
+    * Retrieves a boolean value indicating whether a catalog appears at the start of a fully qualified table name.
+    *
+    * - false: if a catalog does not appear at the start of a fully qualified table name;
+    * - true: if a catalog appears at the start of a fully qualified table name.
+    */
+   SQL_CATALOG_AT_START = 532;
+ 
+   /*
+    * Retrieves the supported actions for a SQL schema.
+    *
+    * Returns an int32 bitmask value representing the supported actions for a SQL schema.
+    * The returned bitmask should be parsed in order to retrieve the supported actions for a SQL schema.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (no supported actions for SQL schema);
+    * - return 1 (\b1)   => [SQL_ELEMENT_IN_PROCEDURE_CALLS];
+    * - return 2 (\b10)  => [SQL_ELEMENT_IN_INDEX_DEFINITIONS];
+    * - return 3 (\b11)  => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS];
+    * - return 4 (\b100) => [SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+    * - return 5 (\b101) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+    * - return 6 (\b110) => [SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+    * - return 7 (\b111) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS].
+    * Valid actions for a SQL schema described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
+    */
+   SQL_SCHEMAS_SUPPORTED_ACTIONS = 533;
+ 
+   /*
+    * Retrieves the supported actions for a SQL schema.
+    *
+    * Returns an int32 bitmask value representing the supported actions for a SQL catalog.
+    * The returned bitmask should be parsed in order to retrieve the supported actions for a SQL catalog.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (no supported actions for SQL catalog);
+    * - return 1 (\b1)   => [SQL_ELEMENT_IN_PROCEDURE_CALLS];
+    * - return 2 (\b10)  => [SQL_ELEMENT_IN_INDEX_DEFINITIONS];
+    * - return 3 (\b11)  => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS];
+    * - return 4 (\b100) => [SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+    * - return 5 (\b101) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+    * - return 6 (\b110) => [SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS];
+    * - return 7 (\b111) => [SQL_ELEMENT_IN_PROCEDURE_CALLS, SQL_ELEMENT_IN_INDEX_DEFINITIONS, SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS].
+    * Valid actions for a SQL catalog are described under `arrow.flight.protocol.sql.SqlSupportedElementActions`.
+    */
+   SQL_CATALOGS_SUPPORTED_ACTIONS = 534;
+ 
+   /*
+    * Retrieves the supported SQL positioned commands.
+    *
+    * Returns an int32 bitmask value representing the supported SQL positioned commands.
+    * The returned bitmask should be parsed in order to retrieve the supported SQL positioned commands.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (no supported SQL positioned commands);
+    * - return 1 (\b1)   => [SQL_POSITIONED_DELETE];
+    * - return 2 (\b10)  => [SQL_POSITIONED_UPDATE];
+    * - return 3 (\b11)  => [SQL_POSITIONED_DELETE, SQL_POSITIONED_UPDATE].
+    * Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedPositionedCommands`.
+    */
+   SQL_SUPPORTED_POSITIONED_COMMANDS = 535;
+ 
+   /*
+    * Retrieves a boolean value indicating whether SELECT FOR UPDATE statements are supported.
+    *
+    * Returns:
+    * - false: if SELECT FOR UPDATE statements are unsupported;
+    * - true: if SELECT FOR UPDATE statements are supported.
+    */
+   SQL_SELECT_FOR_UPDATE_SUPPORTED = 536;
+ 
+   /*
+    * Retrieves a boolean value indicating whether stored procedure calls that use the stored procedure escape syntax
+    * are supported.
+    *
+    * Returns:
+    * - false: if stored procedure calls that use the stored procedure escape syntax are unsupported;
+    * - true: if stored procedure calls that use the stored procedure escape syntax are supported.
+    */
+   SQL_STORED_PROCEDURES_SUPPORTED = 537;
+ 
+   /*
+    * Retrieves the supported SQL subqueries.
+    *
+    * Returns an int32 bitmask value representing the supported SQL subqueries.
+    * The returned bitmask should be parsed in order to retrieve the supported SQL subqueries.
+    *
+    * For instance:
+    * - return 0   (\b0)     => [] (no supported SQL subqueries);
+    * - return 1   (\b1)     => [SQL_SUBQUERIES_IN_COMPARISONS];
+    * - return 2   (\b10)    => [SQL_SUBQUERIES_IN_EXISTS];
+    * - return 3   (\b11)    => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS];
+    * - return 4   (\b100)   => [SQL_SUBQUERIES_IN_INS];
+    * - return 5   (\b101)   => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS];
+    * - return 6   (\b110)   => [SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_EXISTS];
+    * - return 7   (\b111)   => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS];
+    * - return 8   (\b1000)  => [SQL_SUBQUERIES_IN_QUANTIFIEDS];
+    * - return 9   (\b1001)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+    * - return 10  (\b1010)  => [SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+    * - return 11  (\b1011)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+    * - return 12  (\b1100)  => [SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+    * - return 13  (\b1101)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+    * - return 14  (\b1110)  => [SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+    * - return 15  (\b1111)  => [SQL_SUBQUERIES_IN_COMPARISONS, SQL_SUBQUERIES_IN_EXISTS, SQL_SUBQUERIES_IN_INS, SQL_SUBQUERIES_IN_QUANTIFIEDS];
+    * - ...
+    * Valid SQL subqueries are described under `arrow.flight.protocol.sql.SqlSupportedSubqueries`.
+    */
+   SQL_SUPPORTED_SUBQUERIES = 538;
+ 
+   /*
+    * Retrieves a boolean value indicating whether correlated subqueries are supported.
+    *
+    * Returns:
+    * - false: if correlated subqueries are unsupported;
+    * - true: if correlated subqueries are supported.
+    */
+   SQL_CORRELATED_SUBQUERIES_SUPPORTED = 539;
+ 
+   /*
+    * Retrieves the supported SQL UNIONs.
+    *
+    * Returns an int32 bitmask value representing the supported SQL UNIONs.
+    * The returned bitmask should be parsed in order to retrieve the supported SQL UNIONs.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (no supported SQL positioned commands);
+    * - return 1 (\b1)   => [SQL_UNION];
+    * - return 2 (\b10)  => [SQL_UNION_ALL];
+    * - return 3 (\b11)  => [SQL_UNION, SQL_UNION_ALL].
+    * Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlSupportedUnions`.
+    */
+   SQL_SUPPORTED_UNIONS = 540;
+ 
+   // Retrieves a int64 value representing the maximum number of hex characters allowed in an inline binary literal.
+   SQL_MAX_BINARY_LITERAL_LENGTH = 541;
+ 
+   // Retrieves a int64 value representing the maximum number of characters allowed for a character literal.
+   SQL_MAX_CHAR_LITERAL_LENGTH = 542;
+ 
+   // Retrieves a int64 value representing the maximum number of characters allowed for a column name.
+   SQL_MAX_COLUMN_NAME_LENGTH = 543;
+ 
+   // Retrieves a int64 value representing the maximum number of columns allowed in a GROUP BY clause.
+   SQL_MAX_COLUMNS_IN_GROUP_BY = 544;
+ 
+   // Retrieves a int64 value representing the maximum number of columns allowed in an index.
+   SQL_MAX_COLUMNS_IN_INDEX = 545;
+ 
+   // Retrieves a int64 value representing the maximum number of columns allowed in an ORDER BY clause.
+   SQL_MAX_COLUMNS_IN_ORDER_BY = 546;
+ 
+   // Retrieves a int64 value representing the maximum number of columns allowed in a SELECT list.
+   SQL_MAX_COLUMNS_IN_SELECT = 547;
+ 
+   // Retrieves a int64 value representing the maximum number of columns allowed in a table.
+   SQL_MAX_COLUMNS_IN_TABLE = 548;
+ 
+   // Retrieves a int64 value representing the maximum number of concurrent connections possible.
+   SQL_MAX_CONNECTIONS = 549;
+ 
+   // Retrieves a int64 value the maximum number of characters allowed in a cursor name.
+   SQL_MAX_CURSOR_NAME_LENGTH = 550;
+ 
+   /*
+    * Retrieves a int64 value representing the maximum number of bytes allowed for an index,
+    * including all of the parts of the index.
+    */
+   SQL_MAX_INDEX_LENGTH = 551;
+ 
+   // Retrieves a int64 value representing the maximum number of characters allowed in a schema name.
+   SQL_DB_SCHEMA_NAME_LENGTH = 552;
+ 
+   // Retrieves a int64 value representing the maximum number of characters allowed in a procedure name.
+   SQL_MAX_PROCEDURE_NAME_LENGTH = 553;
+ 
+   // Retrieves a int64 value representing the maximum number of characters allowed in a catalog name.
+   SQL_MAX_CATALOG_NAME_LENGTH = 554;
+ 
+   // Retrieves a int64 value representing the maximum number of bytes allowed in a single row.
+   SQL_MAX_ROW_SIZE = 555;
+ 
+   /*
+    * Retrieves a boolean indicating whether the return value for the JDBC method getMaxRowSize includes the SQL
+    * data types LONGVARCHAR and LONGVARBINARY.
+    *
+    * Returns:
+    * - false: if return value for the JDBC method getMaxRowSize does
+    *          not include the SQL data types LONGVARCHAR and LONGVARBINARY;
+    * - true: if return value for the JDBC method getMaxRowSize includes
+    *         the SQL data types LONGVARCHAR and LONGVARBINARY.
+    */
+   SQL_MAX_ROW_SIZE_INCLUDES_BLOBS = 556;
+ 
+   /*
+    * Retrieves a int64 value representing the maximum number of characters allowed for an SQL statement;
+    * a result of 0 (zero) means that there is no limit or the limit is not known.
+    */
+   SQL_MAX_STATEMENT_LENGTH = 557;
+ 
+   // Retrieves a int64 value representing the maximum number of active statements that can be open at the same time.
+   SQL_MAX_STATEMENTS = 558;
+ 
+   // Retrieves a int64 value representing the maximum number of characters allowed in a table name.
+   SQL_MAX_TABLE_NAME_LENGTH = 559;
+ 
+   // Retrieves a int64 value representing the maximum number of tables allowed in a SELECT statement.
+   SQL_MAX_TABLES_IN_SELECT = 560;
+ 
+   // Retrieves a int64 value representing the maximum number of characters allowed in a user name.
+   SQL_MAX_USERNAME_LENGTH = 561;
+ 
+   /*
+    * Retrieves this database's default transaction isolation level as described in
+    * `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
+    *
+    * Returns a int32 ordinal for the SQL transaction isolation level.
+    */
+   SQL_DEFAULT_TRANSACTION_ISOLATION = 562;
+ 
+   /*
+    * Retrieves a boolean value indicating whether transactions are supported. If not, invoking the method commit is a
+    * noop, and the isolation level is `arrow.flight.protocol.sql.SqlTransactionIsolationLevel.TRANSACTION_NONE`.
+    *
+    * Returns:
+    * - false: if transactions are unsupported;
+    * - true: if transactions are supported.
+    */
+   SQL_TRANSACTIONS_SUPPORTED = 563;
+ 
+   /*
+    * Retrieves the supported transactions isolation levels.
+    *
+    * Returns an int32 bitmask value representing the supported transactions isolation levels.
+    * The returned bitmask should be parsed in order to retrieve the supported transactions isolation levels.
+    *
+    * For instance:
+    * - return 0   (\b0)     => [] (no supported SQL transactions isolation levels);
+    * - return 1   (\b1)     => [SQL_TRANSACTION_NONE];
+    * - return 2   (\b10)    => [SQL_TRANSACTION_READ_UNCOMMITTED];
+    * - return 3   (\b11)    => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED];
+    * - return 4   (\b100)   => [SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 5   (\b101)   => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 6   (\b110)   => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 7   (\b111)   => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 8   (\b1000)  => [SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 9   (\b1001)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 10  (\b1010)  => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 11  (\b1011)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 12  (\b1100)  => [SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 13  (\b1101)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 14  (\b1110)  => [SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 15  (\b1111)  => [SQL_TRANSACTION_NONE, SQL_TRANSACTION_READ_UNCOMMITTED, SQL_TRANSACTION_REPEATABLE_READ, SQL_TRANSACTION_REPEATABLE_READ];
+    * - return 16  (\b10000) => [SQL_TRANSACTION_SERIALIZABLE];
+    * - ...
+    * Valid SQL positioned commands are described under `arrow.flight.protocol.sql.SqlTransactionIsolationLevel`.
+    */
+   SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS = 564;
+ 
+   /*
+    * Retrieves a boolean value indicating whether a data definition statement within a transaction forces
+    * the transaction to commit.
+    *
+    * Returns:
+    * - false: if a data definition statement within a transaction does not force the transaction to commit;
+    * - true: if a data definition statement within a transaction forces the transaction to commit.
+    */
+   SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT = 565;
+ 
+   /*
+    * Retrieves a boolean value indicating whether a data definition statement within a transaction is ignored.
+    *
+    * Returns:
+    * - false: if a data definition statement within a transaction is taken into account;
+    * - true: a data definition statement within a transaction is ignored.
+    */
+   SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED = 566;
+ 
+   /*
+    * Retrieves an int32 bitmask value representing the supported result set types.
+    * The returned bitmask should be parsed in order to retrieve the supported result set types.
+    *
+    * For instance:
+    * - return 0   (\b0)     => [] (no supported result set types);
+    * - return 1   (\b1)     => [SQL_RESULT_SET_TYPE_UNSPECIFIED];
+    * - return 2   (\b10)    => [SQL_RESULT_SET_TYPE_FORWARD_ONLY];
+    * - return 3   (\b11)    => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY];
+    * - return 4   (\b100)   => [SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
+    * - return 5   (\b101)   => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
+    * - return 6   (\b110)   => [SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
+    * - return 7   (\b111)   => [SQL_RESULT_SET_TYPE_UNSPECIFIED, SQL_RESULT_SET_TYPE_FORWARD_ONLY, SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE];
+    * - return 8   (\b1000)  => [SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE];
+    * - ...
+    * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetType`.
+    */
+   SQL_SUPPORTED_RESULT_SET_TYPES = 567;
+ 
+   /*
+    * Returns an int32 bitmask value concurrency types supported for
+    * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_UNSPECIFIED`.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
+    * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
+    * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+    * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+    * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+    */
+   SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED = 568;
+ 
+   /*
+    * Returns an int32 bitmask value concurrency types supported for
+    * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_FORWARD_ONLY`.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
+    * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
+    * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+    * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+    * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+    */
+   SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY = 569;
+ 
+   /*
+    * Returns an int32 bitmask value concurrency types supported for
+    * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE`.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
+    * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
+    * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+    * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+    * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+    */
+   SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE = 570;
+ 
+   /*
+    * Returns an int32 bitmask value concurrency types supported for
+    * `arrow.flight.protocol.sql.SqlSupportedResultSetType.SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE`.
+    *
+    * For instance:
+    * - return 0 (\b0)   => [] (no supported concurrency types for this result set type)
+    * - return 1 (\b1)   => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED]
+    * - return 2 (\b10)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+    * - return 3 (\b11)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY]
+    * - return 4 (\b100) => [SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 5 (\b101) => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 6 (\b110)  => [SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * - return 7 (\b111)  => [SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED, SQL_RESULT_SET_CONCURRENCY_READ_ONLY, SQL_RESULT_SET_CONCURRENCY_UPDATABLE]
+    * Valid result set types are described under `arrow.flight.protocol.sql.SqlSupportedResultSetConcurrency`.
+    */
+   SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE = 571;
+ 
+   /*
+    * Retrieves a boolean value indicating whether this database supports batch updates.
+    *
+    * - false: if this database does not support batch updates;
+    * - true: if this database supports batch updates.
+    */
+   SQL_BATCH_UPDATES_SUPPORTED = 572;
+ 
+   /*
+    * Retrieves a boolean value indicating whether this database supports savepoints.
+    *
+    * Returns:
+    * - false: if this database does not support savepoints;
+    * - true: if this database supports savepoints.
+    */
+   SQL_SAVEPOINTS_SUPPORTED = 573;
+ 
+   /*
+    * Retrieves a boolean value indicating whether named parameters are supported in callable statements.
+    *
+    * Returns:
+    * - false: if named parameters in callable statements are unsupported;
+    * - true: if named parameters in callable statements are supported.
+    */
+   SQL_NAMED_PARAMETERS_SUPPORTED = 574;
+ 
+   /*
+    * Retrieves a boolean value indicating whether updates made to a LOB are made on a copy or directly to the LOB.
+    *
+    * Returns:
+    * - false: if updates made to a LOB are made directly to the LOB;
+    * - true: if updates made to a LOB are made on a copy.
+    */
+   SQL_LOCATORS_UPDATE_COPY = 575;
+ 
+   /*
+    * Retrieves a boolean value indicating whether invoking user-defined or vendor functions
+    * using the stored procedure escape syntax is supported.
+    *
+    * Returns:
+    * - false: if invoking user-defined or vendor functions using the stored procedure escape syntax is unsupported;
+    * - true: if invoking user-defined or vendor functions using the stored procedure escape syntax is supported.
+    */
+   SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED = 576;
+ }
+ 
+ // The level of support for Flight SQL transaction RPCs.
+ enum SqlSupportedTransaction {
+   // Unknown/not indicated/no support
+   SQL_SUPPORTED_TRANSACTION_NONE = 0;
+   // Transactions, but not savepoints.
+   // A savepoint is a mark within a transaction that can be individually
+   // rolled back to. Not all databases support savepoints.
+   SQL_SUPPORTED_TRANSACTION_TRANSACTION = 1;
+   // Transactions and savepoints
+   SQL_SUPPORTED_TRANSACTION_SAVEPOINT = 2;
+ }
+ 
+ enum SqlSupportedCaseSensitivity {
+   SQL_CASE_SENSITIVITY_UNKNOWN = 0;
+   SQL_CASE_SENSITIVITY_CASE_INSENSITIVE = 1;
+   SQL_CASE_SENSITIVITY_UPPERCASE = 2;
+   SQL_CASE_SENSITIVITY_LOWERCASE = 3;
+ }
+ 
+ enum SqlNullOrdering {
+   SQL_NULLS_SORTED_HIGH = 0;
+   SQL_NULLS_SORTED_LOW = 1;
+   SQL_NULLS_SORTED_AT_START = 2;
+   SQL_NULLS_SORTED_AT_END = 3;
+ }
+ 
+ enum SupportedSqlGrammar {
+   SQL_MINIMUM_GRAMMAR = 0;
+   SQL_CORE_GRAMMAR = 1;
+   SQL_EXTENDED_GRAMMAR = 2;
+ }
+ 
+ enum SupportedAnsi92SqlGrammarLevel {
+   ANSI92_ENTRY_SQL = 0;
+   ANSI92_INTERMEDIATE_SQL = 1;
+   ANSI92_FULL_SQL = 2;
+ }
+ 
+ enum SqlOuterJoinsSupportLevel {
+   SQL_JOINS_UNSUPPORTED = 0;
+   SQL_LIMITED_OUTER_JOINS = 1;
+   SQL_FULL_OUTER_JOINS = 2;
+ }
+ 
+ enum SqlSupportedGroupBy {
+   SQL_GROUP_BY_UNRELATED = 0;
+   SQL_GROUP_BY_BEYOND_SELECT = 1;
+ }
+ 
+ enum SqlSupportedElementActions {
+   SQL_ELEMENT_IN_PROCEDURE_CALLS = 0;
+   SQL_ELEMENT_IN_INDEX_DEFINITIONS = 1;
+   SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS = 2;
+ }
+ 
+ enum SqlSupportedPositionedCommands {
+   SQL_POSITIONED_DELETE = 0;
+   SQL_POSITIONED_UPDATE = 1;
+ }
+ 
+ enum SqlSupportedSubqueries {
+   SQL_SUBQUERIES_IN_COMPARISONS = 0;
+   SQL_SUBQUERIES_IN_EXISTS = 1;
+   SQL_SUBQUERIES_IN_INS = 2;
+   SQL_SUBQUERIES_IN_QUANTIFIEDS = 3;
+ }
+ 
+ enum SqlSupportedUnions {
+   SQL_UNION = 0;
+   SQL_UNION_ALL = 1;
+ }
+ 
+ enum SqlTransactionIsolationLevel {
+   SQL_TRANSACTION_NONE = 0;
+   SQL_TRANSACTION_READ_UNCOMMITTED = 1;
+   SQL_TRANSACTION_READ_COMMITTED = 2;
+   SQL_TRANSACTION_REPEATABLE_READ = 3;
+   SQL_TRANSACTION_SERIALIZABLE = 4;
+ }
+ 
+ enum SqlSupportedTransactions {
+   SQL_TRANSACTION_UNSPECIFIED = 0;
+   SQL_DATA_DEFINITION_TRANSACTIONS = 1;
+   SQL_DATA_MANIPULATION_TRANSACTIONS = 2;
+ }
+ 
+ enum SqlSupportedResultSetType {
+   SQL_RESULT_SET_TYPE_UNSPECIFIED = 0;
+   SQL_RESULT_SET_TYPE_FORWARD_ONLY = 1;
+   SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE = 2;
+   SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE = 3;
+ }
+ 
+ enum SqlSupportedResultSetConcurrency {
+   SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED = 0;
+   SQL_RESULT_SET_CONCURRENCY_READ_ONLY = 1;
+   SQL_RESULT_SET_CONCURRENCY_UPDATABLE = 2;
+ }
+ 
+ enum SqlSupportsConvert {
+   SQL_CONVERT_BIGINT = 0;
+   SQL_CONVERT_BINARY = 1;
+   SQL_CONVERT_BIT = 2;
+   SQL_CONVERT_CHAR = 3;
+   SQL_CONVERT_DATE = 4;
+   SQL_CONVERT_DECIMAL = 5;
+   SQL_CONVERT_FLOAT = 6;
+   SQL_CONVERT_INTEGER = 7;
+   SQL_CONVERT_INTERVAL_DAY_TIME = 8;
+   SQL_CONVERT_INTERVAL_YEAR_MONTH = 9;
+   SQL_CONVERT_LONGVARBINARY = 10;
+   SQL_CONVERT_LONGVARCHAR = 11;
+   SQL_CONVERT_NUMERIC = 12;
+   SQL_CONVERT_REAL = 13;
+   SQL_CONVERT_SMALLINT = 14;
+   SQL_CONVERT_TIME = 15;
+   SQL_CONVERT_TIMESTAMP = 16;
+   SQL_CONVERT_TINYINT = 17;
+   SQL_CONVERT_VARBINARY = 18;
+   SQL_CONVERT_VARCHAR = 19;
+ }
+ 
+ /**
+  * The JDBC/ODBC-defined type of any object.
+  * All the values here are the same as in the JDBC and ODBC specs.
+  */
+ enum XdbcDataType {
+   XDBC_UNKNOWN_TYPE = 0;
+   XDBC_CHAR = 1;
+   XDBC_NUMERIC = 2;
+   XDBC_DECIMAL = 3;
+   XDBC_INTEGER = 4;
+   XDBC_SMALLINT = 5;
+   XDBC_FLOAT = 6;
+   XDBC_REAL = 7;
+   XDBC_DOUBLE = 8;
+   XDBC_DATETIME = 9;
+   XDBC_INTERVAL = 10;
+   XDBC_VARCHAR = 12;
+   XDBC_DATE = 91;
+   XDBC_TIME = 92;
+   XDBC_TIMESTAMP = 93;
+   XDBC_LONGVARCHAR = -1;
+   XDBC_BINARY = -2;
+   XDBC_VARBINARY = -3;
+   XDBC_LONGVARBINARY = -4;
+   XDBC_BIGINT = -5;
+   XDBC_TINYINT = -6;
+   XDBC_BIT = -7;
+   XDBC_WCHAR = -8;
+   XDBC_WVARCHAR = -9;
+ }
+ 
+ /**
+  * Detailed subtype information for XDBC_TYPE_DATETIME and XDBC_TYPE_INTERVAL.
+  */
+ enum XdbcDatetimeSubcode {
+   option allow_alias = true;
+   XDBC_SUBCODE_UNKNOWN = 0;
+   XDBC_SUBCODE_YEAR = 1;
+   XDBC_SUBCODE_DATE = 1;
+   XDBC_SUBCODE_TIME = 2;
+   XDBC_SUBCODE_MONTH = 2;
+   XDBC_SUBCODE_TIMESTAMP = 3;
+   XDBC_SUBCODE_DAY = 3;
+   XDBC_SUBCODE_TIME_WITH_TIMEZONE = 4;
+   XDBC_SUBCODE_HOUR = 4;
+   XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE = 5;
+   XDBC_SUBCODE_MINUTE = 5;
+   XDBC_SUBCODE_SECOND = 6;
+   XDBC_SUBCODE_YEAR_TO_MONTH = 7;
+   XDBC_SUBCODE_DAY_TO_HOUR = 8;
+   XDBC_SUBCODE_DAY_TO_MINUTE = 9;
+   XDBC_SUBCODE_DAY_TO_SECOND = 10;
+   XDBC_SUBCODE_HOUR_TO_MINUTE = 11;
+   XDBC_SUBCODE_HOUR_TO_SECOND = 12;
+   XDBC_SUBCODE_MINUTE_TO_SECOND = 13;
+   XDBC_SUBCODE_INTERVAL_YEAR = 101;
+   XDBC_SUBCODE_INTERVAL_MONTH = 102;
+   XDBC_SUBCODE_INTERVAL_DAY = 103;
+   XDBC_SUBCODE_INTERVAL_HOUR = 104;
+   XDBC_SUBCODE_INTERVAL_MINUTE = 105;
+   XDBC_SUBCODE_INTERVAL_SECOND = 106;
+   XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH = 107;
+   XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR = 108;
+   XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE = 109;
+   XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND = 110;
+   XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE = 111;
+   XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND = 112;
+   XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND = 113;
+ }
+ 
+ enum Nullable {
+   /**
+    * Indicates that the fields does not allow the use of null values.
+    */
+   NULLABILITY_NO_NULLS = 0;
+ 
+   /**
+    * Indicates that the fields allow the use of null values.
+    */
+   NULLABILITY_NULLABLE = 1;
+ 
+   /**
+    * Indicates that nullability of the fields cannot be determined.
+    */
+   NULLABILITY_UNKNOWN = 2;
+ }
+ 
+ enum Searchable {
+   /**
+    * Indicates that column cannot be used in a WHERE clause.
+    */
+   SEARCHABLE_NONE = 0;
+ 
+   /**
+    * Indicates that the column can be used in a WHERE clause if it is using a
+    * LIKE operator.
+    */
+   SEARCHABLE_CHAR = 1;
+ 
+   /**
+    * Indicates that the column can be used In a WHERE clause with any
+    * operator other than LIKE.
+    *
+    * - Allowed operators: comparison, quantified comparison, BETWEEN,
+    *                      DISTINCT, IN, MATCH, and UNIQUE.
+    */
+   SEARCHABLE_BASIC = 2;
+ 
+   /**
+    * Indicates that the column can be used in a WHERE clause using any operator.
+    */
+   SEARCHABLE_FULL = 3;
+ }
+ 
+ /*
+  * Represents a request to retrieve information about data type supported on a Flight SQL enabled backend.
+  * Used in the command member of FlightDescriptor for the following RPC calls:
+  *  - GetSchema: return the schema of the query.
+  *  - GetFlightInfo: execute the catalog metadata request.
+  *
+  * The returned schema will be:
+  * <
+  *   type_name: utf8 not null (The name of the data type, for example: VARCHAR, INTEGER, etc),
+  *   data_type: int32 not null (The SQL data type),
+  *   column_size: int32 (The maximum size supported by that column.
+  *                       In case of exact numeric types, this represents the maximum precision.
+  *                       In case of string types, this represents the character length.
+  *                       In case of datetime data types, this represents the length in characters of the string representation.
+  *                       NULL is returned for data types where column size is not applicable.),
+  *   literal_prefix: utf8 (Character or characters used to prefix a literal, NULL is returned for
+  *                         data types where a literal prefix is not applicable.),
+  *   literal_suffix: utf8 (Character or characters used to terminate a literal,
+  *                         NULL is returned for data types where a literal suffix is not applicable.),
+  *   create_params: list<utf8 not null>
+  *                        (A list of keywords corresponding to which parameters can be used when creating
+  *                         a column for that specific type.
+  *                         NULL is returned if there are no parameters for the data type definition.),
+  *   nullable: int32 not null (Shows if the data type accepts a NULL value. The possible values can be seen in the
+  *                             Nullable enum.),
+  *   case_sensitive: bool not null (Shows if a character data type is case-sensitive in collations and comparisons),
+  *   searchable: int32 not null (Shows how the data type is used in a WHERE clause. The possible values can be seen in the
+  *                               Searchable enum.),
+  *   unsigned_attribute: bool (Shows if the data type is unsigned. NULL is returned if the attribute is
+  *                             not applicable to the data type or the data type is not numeric.),
+  *   fixed_prec_scale: bool not null (Shows if the data type has predefined fixed precision and scale.),
+  *   auto_increment: bool (Shows if the data type is auto incremental. NULL is returned if the attribute
+  *                         is not applicable to the data type or the data type is not numeric.),
+  *   local_type_name: utf8 (Localized version of the data source-dependent name of the data type. NULL
+  *                          is returned if a localized name is not supported by the data source),
+  *   minimum_scale: int32 (The minimum scale of the data type on the data source.
+  *                         If a data type has a fixed scale, the MINIMUM_SCALE and MAXIMUM_SCALE
+  *                         columns both contain this value. NULL is returned if scale is not applicable.),
+  *   maximum_scale: int32 (The maximum scale of the data type on the data source.
+  *                         NULL is returned if scale is not applicable.),
+  *   sql_data_type: int32 not null (The value of the SQL DATA TYPE which has the same values
+  *                                  as data_type value. Except for interval and datetime, which
+  *                                  uses generic values. More info about those types can be
+  *                                  obtained through datetime_subcode. The possible values can be seen
+  *                                  in the XdbcDataType enum.),
+  *   datetime_subcode: int32 (Only used when the SQL DATA TYPE is interval or datetime. It contains
+  *                            its sub types. For type different from interval and datetime, this value
+  *                            is NULL. The possible values can be seen in the XdbcDatetimeSubcode enum.),
+  *   num_prec_radix: int32 (If the data type is an approximate numeric type, this column contains
+  *                          the value 2 to indicate that COLUMN_SIZE specifies a number of bits. For
+  *                          exact numeric types, this column contains the value 10 to indicate that
+  *                          column size specifies a number of decimal digits. Otherwise, this column is NULL.),
+  *   interval_precision: int32 (If the data type is an interval data type, then this column contains the value
+  *                              of the interval leading precision. Otherwise, this column is NULL. This fields
+  *                              is only relevant to be used by ODBC).
+  * >
+  * The returned data should be ordered by data_type and then by type_name.
+  */
+ message CommandGetXdbcTypeInfo {
+   option (experimental) = true;
+ 
+   /*
+    * Specifies the data type to search for the info.
+    */
+   optional int32 data_type = 1;
+ }
+ 
+ /*
+  * Represents a request to retrieve the list of catalogs on a Flight SQL enabled backend.
+  * The definition of a catalog depends on vendor/implementation. It is usually the database itself
+  * Used in the command member of FlightDescriptor for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *  - GetFlightInfo: execute the catalog metadata request.
+  *
+  * The returned Arrow schema will be:
+  * <
+  *  catalog_name: utf8 not null
+  * >
+  * The returned data should be ordered by catalog_name.
+  */
+ message CommandGetCatalogs {
+   option (experimental) = true;
+ }
+ 
+ /*
+  * Represents a request to retrieve the list of database schemas on a Flight SQL enabled backend.
+  * The definition of a database schema depends on vendor/implementation. It is usually a collection of tables.
+  * Used in the command member of FlightDescriptor for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *  - GetFlightInfo: execute the catalog metadata request.
+  *
+  * The returned Arrow schema will be:
+  * <
+  *  catalog_name: utf8,
+  *  db_schema_name: utf8 not null
+  * >
+  * The returned data should be ordered by catalog_name, then db_schema_name.
+  */
+ message CommandGetDbSchemas {
+   option (experimental) = true;
+ 
+   /*
+    * Specifies the Catalog to search for the tables.
+    * An empty string retrieves those without a catalog.
+    * If omitted the catalog name should not be used to narrow the search.
+    */
+   optional string catalog = 1;
+ 
+   /*
+    * Specifies a filter pattern for schemas to search for.
+    * When no db_schema_filter_pattern is provided, the pattern will not be used to narrow the search.
+    * In the pattern string, two special characters can be used to denote matching rules:
+    *    - "%" means to match any substring with 0 or more characters.
+    *    - "_" means to match any one character.
+    */
+   optional string db_schema_filter_pattern = 2;
+ }
+ 
+ /*
+  * Represents a request to retrieve the list of tables, and optionally their schemas, on a Flight SQL enabled backend.
+  * Used in the command member of FlightDescriptor for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *  - GetFlightInfo: execute the catalog metadata request.
+  *
+  * The returned Arrow schema will be:
+  * <
+  *  catalog_name: utf8,
+  *  db_schema_name: utf8,
+  *  table_name: utf8 not null,
+  *  table_type: utf8 not null,
+  *  [optional] table_schema: bytes not null (schema of the table as described in Schema.fbs::Schema,
+  *                                           it is serialized as an IPC message.)
+  * >
+  * Fields on table_schema may contain the following metadata:
+  *  - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+  *  - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+  *  - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+  *  - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+  *  - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+  *  - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+  *  - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+  *  - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+  *  - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+  *  - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+  * The returned data should be ordered by catalog_name, db_schema_name, table_name, then table_type, followed by table_schema if requested.
+  */
+ message CommandGetTables {
+   option (experimental) = true;
+ 
+   /*
+    * Specifies the Catalog to search for the tables.
+    * An empty string retrieves those without a catalog.
+    * If omitted the catalog name should not be used to narrow the search.
+    */
+   optional string catalog = 1;
+ 
+   /*
+    * Specifies a filter pattern for schemas to search for.
+    * When no db_schema_filter_pattern is provided, all schemas matching other filters are searched.
+    * In the pattern string, two special characters can be used to denote matching rules:
+    *    - "%" means to match any substring with 0 or more characters.
+    *    - "_" means to match any one character.
+    */
+   optional string db_schema_filter_pattern = 2;
+ 
+   /*
+    * Specifies a filter pattern for tables to search for.
+    * When no table_name_filter_pattern is provided, all tables matching other filters are searched.
+    * In the pattern string, two special characters can be used to denote matching rules:
+    *    - "%" means to match any substring with 0 or more characters.
+    *    - "_" means to match any one character.
+    */
+   optional string table_name_filter_pattern = 3;
+ 
+   /*
+    * Specifies a filter of table types which must match.
+    * The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
+    * TABLE, VIEW, and SYSTEM TABLE are commonly supported.
+    */
+   repeated string table_types = 4;
+ 
+   // Specifies if the Arrow schema should be returned for found tables.
+   bool include_schema = 5;
+ }
+ 
+ /*
+  * Represents a request to retrieve the list of table types on a Flight SQL enabled backend.
+  * The table types depend on vendor/implementation. It is usually used to separate tables from views or system tables.
+  * TABLE, VIEW, and SYSTEM TABLE are commonly supported.
+  * Used in the command member of FlightDescriptor for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *  - GetFlightInfo: execute the catalog metadata request.
+  *
+  * The returned Arrow schema will be:
+  * <
+  *  table_type: utf8 not null
+  * >
+  * The returned data should be ordered by table_type.
+  */
+ message CommandGetTableTypes {
+   option (experimental) = true;
+ }
+ 
+ /*
+  * Represents a request to retrieve the primary keys of a table on a Flight SQL enabled backend.
+  * Used in the command member of FlightDescriptor for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *  - GetFlightInfo: execute the catalog metadata request.
+  *
+  * The returned Arrow schema will be:
+  * <
+  *  catalog_name: utf8,
+  *  db_schema_name: utf8,
+  *  table_name: utf8 not null,
+  *  column_name: utf8 not null,
+  *  key_name: utf8,
+  *  key_sequence: int32 not null
+  * >
+  * The returned data should be ordered by catalog_name, db_schema_name, table_name, key_name, then key_sequence.
+  */
+ message CommandGetPrimaryKeys {
+   option (experimental) = true;
+ 
+   /*
+    * Specifies the catalog to search for the table.
+    * An empty string retrieves those without a catalog.
+    * If omitted the catalog name should not be used to narrow the search.
+    */
+   optional string catalog = 1;
+ 
+   /*
+    * Specifies the schema to search for the table.
+    * An empty string retrieves those without a schema.
+    * If omitted the schema name should not be used to narrow the search.
+    */
+   optional string db_schema = 2;
+ 
+   // Specifies the table to get the primary keys for.
+   string table = 3;
+ }
+ 
+ enum UpdateDeleteRules {
+   CASCADE = 0;
+   RESTRICT = 1;
+   SET_NULL = 2;
+   NO_ACTION = 3;
+   SET_DEFAULT = 4;
+ }
+ 
+ /*
+  * Represents a request to retrieve a description of the foreign key columns that reference the given table's
+  * primary key columns (the foreign keys exported by a table) of a table on a Flight SQL enabled backend.
+  * Used in the command member of FlightDescriptor for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *  - GetFlightInfo: execute the catalog metadata request.
+  *
+  * The returned Arrow schema will be:
+  * <
+  *  pk_catalog_name: utf8,
+  *  pk_db_schema_name: utf8,
+  *  pk_table_name: utf8 not null,
+  *  pk_column_name: utf8 not null,
+  *  fk_catalog_name: utf8,
+  *  fk_db_schema_name: utf8,
+  *  fk_table_name: utf8 not null,
+  *  fk_column_name: utf8 not null,
+  *  key_sequence: int32 not null,
+  *  fk_key_name: utf8,
+  *  pk_key_name: utf8,
+  *  update_rule: uint8 not null,
+  *  delete_rule: uint8 not null
+  * >
+  * The returned data should be ordered by fk_catalog_name, fk_db_schema_name, fk_table_name, fk_key_name, then key_sequence.
+  * update_rule and delete_rule returns a byte that is equivalent to actions declared on UpdateDeleteRules enum.
+  */
+ message CommandGetExportedKeys {
+   option (experimental) = true;
+ 
+   /*
+    * Specifies the catalog to search for the foreign key table.
+    * An empty string retrieves those without a catalog.
+    * If omitted the catalog name should not be used to narrow the search.
+    */
+   optional string catalog = 1;
+ 
+   /*
+    * Specifies the schema to search for the foreign key table.
+    * An empty string retrieves those without a schema.
+    * If omitted the schema name should not be used to narrow the search.
+    */
+   optional string db_schema = 2;
+ 
+   // Specifies the foreign key table to get the foreign keys for.
+   string table = 3;
+ }
+ 
+ /*
+  * Represents a request to retrieve the foreign keys of a table on a Flight SQL enabled backend.
+  * Used in the command member of FlightDescriptor for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *  - GetFlightInfo: execute the catalog metadata request.
+  *
+  * The returned Arrow schema will be:
+  * <
+  *  pk_catalog_name: utf8,
+  *  pk_db_schema_name: utf8,
+  *  pk_table_name: utf8 not null,
+  *  pk_column_name: utf8 not null,
+  *  fk_catalog_name: utf8,
+  *  fk_db_schema_name: utf8,
+  *  fk_table_name: utf8 not null,
+  *  fk_column_name: utf8 not null,
+  *  key_sequence: int32 not null,
+  *  fk_key_name: utf8,
+  *  pk_key_name: utf8,
+  *  update_rule: uint8 not null,
+  *  delete_rule: uint8 not null
+  * >
+  * The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
+  * update_rule and delete_rule returns a byte that is equivalent to actions:
+  *    - 0 = CASCADE
+  *    - 1 = RESTRICT
+  *    - 2 = SET NULL
+  *    - 3 = NO ACTION
+  *    - 4 = SET DEFAULT
+  */
+ message CommandGetImportedKeys {
+   option (experimental) = true;
+ 
+   /*
+    * Specifies the catalog to search for the primary key table.
+    * An empty string retrieves those without a catalog.
+    * If omitted the catalog name should not be used to narrow the search.
+    */
+   optional string catalog = 1;
+ 
+   /*
+    * Specifies the schema to search for the primary key table.
+    * An empty string retrieves those without a schema.
+    * If omitted the schema name should not be used to narrow the search.
+    */
+   optional string db_schema = 2;
+ 
+   // Specifies the primary key table to get the foreign keys for.
+   string table = 3;
+ }
+ 
+ /*
+  * Represents a request to retrieve a description of the foreign key columns in the given foreign key table that
+  * reference the primary key or the columns representing a unique constraint of the parent table (could be the same
+  * or a different table) on a Flight SQL enabled backend.
+  * Used in the command member of FlightDescriptor for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *  - GetFlightInfo: execute the catalog metadata request.
+  *
+  * The returned Arrow schema will be:
+  * <
+  *  pk_catalog_name: utf8,
+  *  pk_db_schema_name: utf8,
+  *  pk_table_name: utf8 not null,
+  *  pk_column_name: utf8 not null,
+  *  fk_catalog_name: utf8,
+  *  fk_db_schema_name: utf8,
+  *  fk_table_name: utf8 not null,
+  *  fk_column_name: utf8 not null,
+  *  key_sequence: int32 not null,
+  *  fk_key_name: utf8,
+  *  pk_key_name: utf8,
+  *  update_rule: uint8 not null,
+  *  delete_rule: uint8 not null
+  * >
+  * The returned data should be ordered by pk_catalog_name, pk_db_schema_name, pk_table_name, pk_key_name, then key_sequence.
+  * update_rule and delete_rule returns a byte that is equivalent to actions:
+  *    - 0 = CASCADE
+  *    - 1 = RESTRICT
+  *    - 2 = SET NULL
+  *    - 3 = NO ACTION
+  *    - 4 = SET DEFAULT
+  */
+ message CommandGetCrossReference {
+   option (experimental) = true;
+ 
+   /**
+    * The catalog name where the parent table is.
+    * An empty string retrieves those without a catalog.
+    * If omitted the catalog name should not be used to narrow the search.
+    */
+   optional string pk_catalog = 1;
+ 
+   /**
+    * The Schema name where the parent table is.
+    * An empty string retrieves those without a schema.
+    * If omitted the schema name should not be used to narrow the search.
+    */
+   optional string pk_db_schema = 2;
+ 
+   /**
+    * The parent table name. It cannot be null.
+    */
+   string pk_table = 3;
+ 
+   /**
+    * The catalog name where the foreign table is.
+    * An empty string retrieves those without a catalog.
+    * If omitted the catalog name should not be used to narrow the search.
+    */
+   optional string fk_catalog = 4;
+ 
+   /**
+    * The schema name where the foreign table is.
+    * An empty string retrieves those without a schema.
+    * If omitted the schema name should not be used to narrow the search.
+    */
+   optional string fk_db_schema = 5;
+ 
+   /**
+    * The foreign table name. It cannot be null.
+    */
+   string fk_table = 6;
+ }
+ 
+ // Query Execution Action Messages
+ 
+ /*
+  * Request message for the "CreatePreparedStatement" action on a Flight SQL enabled backend.
+  */
+ message ActionCreatePreparedStatementRequest {
+   option (experimental) = true;
+ 
+   // The valid SQL string to create a prepared statement for.
+   string query = 1;
+   // Create/execute the prepared statement as part of this transaction (if
+   // unset, executions of the prepared statement will be auto-committed).
+   optional bytes transaction_id = 2;
+ }
+ 
+ /*
+  * An embedded message describing a Substrait plan to execute.
+  */
+ message SubstraitPlan {
+   option (experimental) = true;
+ 
+   // The serialized substrait.Plan to create a prepared statement for.
+   // XXX(ARROW-16902): this is bytes instead of an embedded message
+   // because Protobuf does not really support one DLL using Protobuf
+   // definitions from another DLL.
+   bytes plan = 1;
+   // The Substrait release, e.g. "0.12.0". This information is not
+   // tracked in the plan itself, so this is the only way for consumers
+   // to potentially know if they can handle the plan.
+   string version = 2;
+ }
+ 
+ /*
+  * Request message for the "CreatePreparedSubstraitPlan" action on a Flight SQL enabled backend.
+  */
+ message ActionCreatePreparedSubstraitPlanRequest {
+   option (experimental) = true;
+ 
+   // The serialized substrait.Plan to create a prepared statement for.
+   SubstraitPlan plan = 1;
+   // Create/execute the prepared statement as part of this transaction (if
+   // unset, executions of the prepared statement will be auto-committed).
+   optional bytes transaction_id = 2;
+ }
+ 
+ /*
+  * Wrap the result of a "CreatePreparedStatement" or "CreatePreparedSubstraitPlan" action.
+  *
+  * The resultant PreparedStatement can be closed either:
+  * - Manually, through the "ClosePreparedStatement" action;
+  * - Automatically, by a server timeout.
+  *
+  * The result should be wrapped in a google.protobuf.Any message.
+  */
+ message ActionCreatePreparedStatementResult {
+   option (experimental) = true;
+ 
+   // Opaque handle for the prepared statement on the server.
+   bytes prepared_statement_handle = 1;
+ 
+   // If a result set generating query was provided, dataset_schema contains the
+   // schema of the result set.  It should be an IPC-encapsulated Schema, as described in Schema.fbs.
+   // For some queries, the schema of the results may depend on the schema of the parameters.  The server
+   // should provide its best guess as to the schema at this point.  Clients must not assume that this
+   // schema, if provided, will be accurate.
+   bytes dataset_schema = 2;
+ 
+   // If the query provided contained parameters, parameter_schema contains the
+   // schema of the expected parameters.  It should be an IPC-encapsulated Schema, as described in Schema.fbs.
+   bytes parameter_schema = 3;
+ }
+ 
+ /*
+  * Request message for the "ClosePreparedStatement" action on a Flight SQL enabled backend.
+  * Closes server resources associated with the prepared statement handle.
+  */
+ message ActionClosePreparedStatementRequest {
+   option (experimental) = true;
+ 
+   // Opaque handle for the prepared statement on the server.
+   bytes prepared_statement_handle = 1;
+ }
+ 
+ /*
+  * Request message for the "BeginTransaction" action.
+  * Begins a transaction.
+  */
+ message ActionBeginTransactionRequest {
+   option (experimental) = true;
+ }
+ 
+ /*
+  * Request message for the "BeginSavepoint" action.
+  * Creates a savepoint within a transaction.
+  *
+  * Only supported if FLIGHT_SQL_TRANSACTION is
+  * FLIGHT_SQL_TRANSACTION_SUPPORT_SAVEPOINT.
+  */
+ message ActionBeginSavepointRequest {
+   option (experimental) = true;
+ 
+   // The transaction to which a savepoint belongs.
+   bytes transaction_id = 1;
+   // Name for the savepoint.
+   string name = 2;
+ }
+ 
+ /*
+  * The result of a "BeginTransaction" action.
+  *
+  * The transaction can be manipulated with the "EndTransaction" action, or
+  * automatically via server timeout. If the transaction times out, then it is
+  * automatically rolled back.
+  *
+  * The result should be wrapped in a google.protobuf.Any message.
+  */
+ message ActionBeginTransactionResult {
+   option (experimental) = true;
+ 
+   // Opaque handle for the transaction on the server.
+   bytes transaction_id = 1;
+ }
+ 
+ /*
+  * The result of a "BeginSavepoint" action.
+  *
+  * The transaction can be manipulated with the "EndSavepoint" action.
+  * If the associated transaction is committed, rolled back, or times
+  * out, then the savepoint is also invalidated.
+  *
+  * The result should be wrapped in a google.protobuf.Any message.
+  */
+ message ActionBeginSavepointResult {
+   option (experimental) = true;
+ 
+   // Opaque handle for the savepoint on the server.
+   bytes savepoint_id = 1;
+ }
+ 
+ /*
+  * Request message for the "EndTransaction" action.
+  *
+  * Commit (COMMIT) or rollback (ROLLBACK) the transaction.
+  *
+  * If the action completes successfully, the transaction handle is
+  * invalidated, as are all associated savepoints.
+  */
+ message ActionEndTransactionRequest {
+   option (experimental) = true;
+ 
+   enum EndTransaction {
+     END_TRANSACTION_UNSPECIFIED = 0;
+     // Commit the transaction.
+     END_TRANSACTION_COMMIT = 1;
+     // Roll back the transaction.
+     END_TRANSACTION_ROLLBACK = 2;
+   }
+   // Opaque handle for the transaction on the server.
+   bytes transaction_id = 1;
+   // Whether to commit/rollback the given transaction.
+   EndTransaction action = 2;
+ }
+ 
+ /*
+  * Request message for the "EndSavepoint" action.
+  *
+  * Release (RELEASE) the savepoint or rollback (ROLLBACK) to the
+  * savepoint.
+  *
+  * Releasing a savepoint invalidates that savepoint.  Rolling back to
+  * a savepoint does not invalidate the savepoint, but invalidates all
+  * savepoints created after the current savepoint.
+  */
+ message ActionEndSavepointRequest {
+   option (experimental) = true;
+ 
+   enum EndSavepoint {
+     END_SAVEPOINT_UNSPECIFIED = 0;
+     // Release the savepoint.
+     END_SAVEPOINT_RELEASE = 1;
+     // Roll back to a savepoint.
+     END_SAVEPOINT_ROLLBACK = 2;
+   }
+   // Opaque handle for the savepoint on the server.
+   bytes savepoint_id = 1;
+   // Whether to rollback/release the given savepoint.
+   EndSavepoint action = 2;
+ }
+ 
+ // Query Execution Messages.
+ 
+ /*
+  * Represents a SQL query. Used in the command member of FlightDescriptor
+  * for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *    Fields on this schema may contain the following metadata:
+  *    - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+  *    - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+  *    - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+  *    - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+  *    - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+  *    - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+  *    - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+  *    - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+  *    - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+  *    - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+  *  - GetFlightInfo: execute the query.
+  */
+ message CommandStatementQuery {
+   option (experimental) = true;
+ 
+   // The SQL syntax.
+   string query = 1;
+   // Include the query as part of this transaction (if unset, the query is auto-committed).
+   optional bytes transaction_id = 2;
+ }
+ 
+ /*
+  * Represents a Substrait plan. Used in the command member of FlightDescriptor
+  * for the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *    Fields on this schema may contain the following metadata:
+  *    - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+  *    - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+  *    - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+  *    - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+  *    - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+  *    - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+  *    - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+  *    - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+  *    - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+  *    - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+  *  - GetFlightInfo: execute the query.
+  *  - DoPut: execute the query.
+  */
+ message CommandStatementSubstraitPlan {
+   option (experimental) = true;
+ 
+   // A serialized substrait.Plan
+   SubstraitPlan plan = 1;
+   // Include the query as part of this transaction (if unset, the query is auto-committed).
+   optional bytes transaction_id = 2;
+ }
+ 
+ /**
+  * Represents a ticket resulting from GetFlightInfo with a CommandStatementQuery.
+  * This should be used only once and treated as an opaque value, that is, clients should not attempt to parse this.
+  */
+ message TicketStatementQuery {
+   option (experimental) = true;
+ 
+   // Unique identifier for the instance of the statement to execute.
+   bytes statement_handle = 1;
+ }
+ 
+ /*
+  * Represents an instance of executing a prepared statement. Used in the command member of FlightDescriptor for
+  * the following RPC calls:
+  *  - GetSchema: return the Arrow schema of the query.
+  *    Fields on this schema may contain the following metadata:
+  *    - ARROW:FLIGHT:SQL:CATALOG_NAME      - Table's catalog name
+  *    - ARROW:FLIGHT:SQL:DB_SCHEMA_NAME    - Database schema name
+  *    - ARROW:FLIGHT:SQL:TABLE_NAME        - Table name
+  *    - ARROW:FLIGHT:SQL:TYPE_NAME         - The data source-specific name for the data type of the column.
+  *    - ARROW:FLIGHT:SQL:PRECISION         - Column precision/size
+  *    - ARROW:FLIGHT:SQL:SCALE             - Column scale/decimal digits if applicable
+  *    - ARROW:FLIGHT:SQL:IS_AUTO_INCREMENT - "1" indicates if the column is auto incremented, "0" otherwise.
+  *    - ARROW:FLIGHT:SQL:IS_CASE_SENSITIVE - "1" indicates if the column is case-sensitive, "0" otherwise.
+  *    - ARROW:FLIGHT:SQL:IS_READ_ONLY      - "1" indicates if the column is read only, "0" otherwise.
+  *    - ARROW:FLIGHT:SQL:IS_SEARCHABLE     - "1" indicates if the column is searchable via WHERE clause, "0" otherwise.
+  *
+  *    If the schema is retrieved after parameter values have been bound with DoPut, then the server should account
+  *    for the parameters when determining the schema.
+  *  - DoPut: bind parameter values. All of the bound parameter sets will be executed as a single atomic execution.
+  *  - GetFlightInfo: execute the prepared statement instance.
+  */
+ message CommandPreparedStatementQuery {
+   option (experimental) = true;
+ 
+   // Opaque handle for the prepared statement on the server.
+   bytes prepared_statement_handle = 1;
+ }
+ 
+ /*
+  * Represents a SQL update query. Used in the command member of FlightDescriptor
+  * for the RPC call DoPut to cause the server to execute the included SQL update.
+  */
+ message CommandStatementUpdate {
+   option (experimental) = true;
+ 
+   // The SQL syntax.
+   string query = 1;
+   // Include the query as part of this transaction (if unset, the query is auto-committed).
+   optional bytes transaction_id = 2;
+ }
+ 
+ /*
+  * Represents a SQL update query. Used in the command member of FlightDescriptor
+  * for the RPC call DoPut to cause the server to execute the included
+  * prepared statement handle as an update.
+  */
+ message CommandPreparedStatementUpdate {
+   option (experimental) = true;
+ 
+   // Opaque handle for the prepared statement on the server.
+   bytes prepared_statement_handle = 1;
+ }
+ 
+ /*
+  * Returned from the RPC call DoPut when a CommandStatementUpdate
+  * CommandPreparedStatementUpdate was in the request, containing
+  * results from the update.
+  */
+ message DoPutUpdateResult {
+   option (experimental) = true;
+ 
+   // The number of records updated. A return value of -1 represents
+   // an unknown updated record count.
+   int64 record_count = 1;
+ }
+ 
+ /*
+  * Request message for the "CancelQuery" action.
+  *
+  * Explicitly cancel a running query.
+  *
+  * This lets a single client explicitly cancel work, no matter how many clients
+  * are involved/whether the query is distributed or not, given server support.
+  * The transaction/statement is not rolled back; it is the application's job to
+  * commit or rollback as appropriate. This only indicates the client no longer
+  * wishes to read the remainder of the query results or continue submitting
+  * data.
+  *
+  * This command is idempotent.
+  *
+  * This command is deprecated since 13.0.0. Use the "CancelFlightInfo"
+  * action with DoAction instead.
+  */
+ message ActionCancelQueryRequest {
+   option deprecated = true;
+   option (experimental) = true;
+ 
+   // The result of the GetFlightInfo RPC that initiated the query.
+   // XXX(ARROW-16902): this must be a serialized FlightInfo, but is
+   // rendered as bytes because Protobuf does not really support one
+   // DLL using Protobuf definitions from another DLL.
+   bytes info = 1;
+ }
+ 
+ /*
+  * The result of cancelling a query.
+  *
+  * The result should be wrapped in a google.protobuf.Any message.
+  *
+  * This command is deprecated since 13.0.0. Use the "CancelFlightInfo"
+  * action with DoAction instead.
+  */
+ message ActionCancelQueryResult {
+   option deprecated = true;
+   option (experimental) = true;
+ 
+   enum CancelResult {
+     // The cancellation status is unknown. Servers should avoid using
+     // this value (send a NOT_FOUND error if the requested query is
+     // not known). Clients can retry the request.
+     CANCEL_RESULT_UNSPECIFIED = 0;
+     // The cancellation request is complete. Subsequent requests with
+     // the same payload may return CANCELLED or a NOT_FOUND error.
+     CANCEL_RESULT_CANCELLED = 1;
+     // The cancellation request is in progress. The client may retry
+     // the cancellation request.
+     CANCEL_RESULT_CANCELLING = 2;
+     // The query is not cancellable. The client should not retry the
+     // cancellation request.
+     CANCEL_RESULT_NOT_CANCELLABLE = 3;
+   }
+ 
+   CancelResult result = 1;
+ }
+ 
+ extend google.protobuf.MessageOptions {
+   bool experimental = 1000;
+ }
diff --git a/format/Message.fbs b/format/Message.fbs
index f1c18d765d46..170ea8fbced8 100644
--- a/format/Message.fbs
+++ b/format/Message.fbs
@@ -70,7 +70,8 @@ enum BodyCompressionMethod:byte {
 /// bodies. Intended for use with RecordBatch but could be used for other
 /// message types
 table BodyCompression {
-  /// Compressor library
+  /// Compressor library.
+  /// For LZ4_FRAME, each compressed buffer must consist of a single frame.
   codec: CompressionType = LZ4_FRAME;
 
   /// Indicates the way the record batch body was compressed
diff --git a/format/Schema.fbs b/format/Schema.fbs
index 9da095177c7d..6337f72ec9de 100644
--- a/format/Schema.fbs
+++ b/format/Schema.fbs
@@ -17,6 +17,12 @@
 
 /// Logical types, vector layouts, and schemas
 
+/// Format Version History.
+/// Version 1.0 - Forward and backwards compatibility guaranteed.
+/// Version 1.1 - Add Decimal256.
+/// Version 1.2 - Add Interval MONTH_DAY_NANO
+/// Version 1.3 - Add Run-End Encoded.
+
 namespace org.apache.arrow.flatbuf;
 
 enum MetadataVersion:short {
@@ -173,6 +179,14 @@ table FixedSizeBinary {
 table Bool {
 }
 
+/// Contains two child arrays, run_ends and values.
+/// The run_ends child array must be a 16/32/64-bit integer array
+/// which encodes the indices at which the run with the value in
+/// each corresponding index in the values child array ends.
+/// Like list/struct types, the value array can be of any type.
+table RunEndEncoded {
+}
+
 /// Exact decimal value represented as an integer value in two's
 /// complement. Currently only 128-bit (16-byte) and 256-bit (32-byte) integers
 /// are used. The representation uses the endianness indicated
@@ -194,8 +208,8 @@ enum DateUnit: short {
   MILLISECOND
 }
 
-/// Date is either a 32-bit or 64-bit type representing elapsed time since UNIX
-/// epoch (1970-01-01), stored in either of two units:
+/// Date is either a 32-bit or 64-bit signed integer type representing an
+/// elapsed time since UNIX epoch (1970-01-01), stored in either of two units:
 ///
 /// * Milliseconds (64 bits) indicating UNIX time elapsed since the epoch (no
 ///   leap seconds), where the values are evenly divisible by 86400000
@@ -206,43 +220,143 @@ table Date {
 
 enum TimeUnit: short { SECOND, MILLISECOND, MICROSECOND, NANOSECOND }
 
-/// Time type. The physical storage type depends on the unit
-/// - SECOND and MILLISECOND: 32 bits
-/// - MICROSECOND and NANOSECOND: 64 bits
+/// Time is either a 32-bit or 64-bit signed integer type representing an
+/// elapsed time since midnight, stored in either of four units: seconds,
+/// milliseconds, microseconds or nanoseconds.
+///
+/// The integer `bitWidth` depends on the `unit` and must be one of the following:
+/// * SECOND and MILLISECOND: 32 bits
+/// * MICROSECOND and NANOSECOND: 64 bits
+///
+/// The allowed values are between 0 (inclusive) and 86400 (=24*60*60) seconds
+/// (exclusive), adjusted for the time unit (for example, up to 86400000
+/// exclusive for the MILLISECOND unit).
+/// This definition doesn't allow for leap seconds. Time values from
+/// measurements with leap seconds will need to be corrected when ingesting
+/// into Arrow (for example by replacing the value 86400 with 86399).
 table Time {
   unit: TimeUnit = MILLISECOND;
   bitWidth: int = 32;
 }
 
-/// Time elapsed from the Unix epoch, 00:00:00.000 on 1 January 1970, excluding
-/// leap seconds, as a 64-bit integer. Note that UNIX time does not include
-/// leap seconds.
+/// Timestamp is a 64-bit signed integer representing an elapsed time since a
+/// fixed epoch, stored in either of four units: seconds, milliseconds,
+/// microseconds or nanoseconds, and is optionally annotated with a timezone.
+///
+/// Timestamp values do not include any leap seconds (in other words, all
+/// days are considered 86400 seconds long).
+///
+/// Timestamps with a non-empty timezone
+/// ------------------------------------
+///
+/// If a Timestamp column has a non-empty timezone value, its epoch is
+/// 1970-01-01 00:00:00 (January 1st 1970, midnight) in the *UTC* timezone
+/// (the Unix epoch), regardless of the Timestamp's own timezone.
+///
+/// Therefore, timestamp values with a non-empty timezone correspond to
+/// physical points in time together with some additional information about
+/// how the data was obtained and/or how to display it (the timezone).
+///
+///   For example, the timestamp value 0 with the timezone string "Europe/Paris"
+///   corresponds to "January 1st 1970, 00h00" in the UTC timezone, but the
+///   application may prefer to display it as "January 1st 1970, 01h00" in
+///   the Europe/Paris timezone (which is the same physical point in time).
+///
+/// One consequence is that timestamp values with a non-empty timezone
+/// can be compared and ordered directly, since they all share the same
+/// well-known point of reference (the Unix epoch).
+///
+/// Timestamps with an unset / empty timezone
+/// -----------------------------------------
+///
+/// If a Timestamp column has no timezone value, its epoch is
+/// 1970-01-01 00:00:00 (January 1st 1970, midnight) in an *unknown* timezone.
+///
+/// Therefore, timestamp values without a timezone cannot be meaningfully
+/// interpreted as physical points in time, but only as calendar / clock
+/// indications ("wall clock time") in an unspecified timezone.
 ///
-/// The Timestamp metadata supports both "time zone naive" and "time zone
-/// aware" timestamps. Read about the timezone attribute for more detail
+///   For example, the timestamp value 0 with an empty timezone string
+///   corresponds to "January 1st 1970, 00h00" in an unknown timezone: there
+///   is not enough information to interpret it as a well-defined physical
+///   point in time.
+///
+/// One consequence is that timestamp values without a timezone cannot
+/// be reliably compared or ordered, since they may have different points of
+/// reference.  In particular, it is *not* possible to interpret an unset
+/// or empty timezone as the same as "UTC".
+///
+/// Conversion between timezones
+/// ----------------------------
+///
+/// If a Timestamp column has a non-empty timezone, changing the timezone
+/// to a different non-empty value is a metadata-only operation:
+/// the timestamp values need not change as their point of reference remains
+/// the same (the Unix epoch).
+///
+/// However, if a Timestamp column has no timezone value, changing it to a
+/// non-empty value requires to think about the desired semantics.
+/// One possibility is to assume that the original timestamp values are
+/// relative to the epoch of the timezone being set; timestamp values should
+/// then adjusted to the Unix epoch (for example, changing the timezone from
+/// empty to "Europe/Paris" would require converting the timestamp values
+/// from "Europe/Paris" to "UTC", which seems counter-intuitive but is
+/// nevertheless correct).
+///
+/// Guidelines for encoding data from external libraries
+/// ----------------------------------------------------
+///
+/// Date & time libraries often have multiple different data types for temporal
+/// data. In order to ease interoperability between different implementations the
+/// Arrow project has some recommendations for encoding these types into a Timestamp
+/// column.
+///
+/// An "instant" represents a physical point in time that has no relevant timezone
+/// (for example, astronomical data). To encode an instant, use a Timestamp with
+/// the timezone string set to "UTC", and make sure the Timestamp values
+/// are relative to the UTC epoch (January 1st 1970, midnight).
+///
+/// A "zoned date-time" represents a physical point in time annotated with an
+/// informative timezone (for example, the timezone in which the data was
+/// recorded).  To encode a zoned date-time, use a Timestamp with the timezone
+/// string set to the name of the timezone, and make sure the Timestamp values
+/// are relative to the UTC epoch (January 1st 1970, midnight).
+///
+///  (There is some ambiguity between an instant and a zoned date-time with the
+///   UTC timezone.  Both of these are stored the same in Arrow.  Typically,
+///   this distinction does not matter.  If it does, then an application should
+///   use custom metadata or an extension type to distinguish between the two cases.)
+///
+/// An "offset date-time" represents a physical point in time combined with an
+/// explicit offset from UTC.  To encode an offset date-time, use a Timestamp
+/// with the timezone string set to the numeric timezone offset string
+/// (e.g. "+03:00"), and make sure the Timestamp values are relative to
+/// the UTC epoch (January 1st 1970, midnight).
+///
+/// A "naive date-time" (also called "local date-time" in some libraries)
+/// represents a wall clock time combined with a calendar date, but with
+/// no indication of how to map this information to a physical point in time.
+/// Naive date-times must be handled with care because of this missing
+/// information, and also because daylight saving time (DST) may make
+/// some values ambiguous or non-existent. A naive date-time may be
+/// stored as a struct with Date and Time fields. However, it may also be
+/// encoded into a Timestamp column with an empty timezone. The timestamp
+/// values should be computed "as if" the timezone of the date-time values
+/// was UTC; for example, the naive date-time "January 1st 1970, 00h00" would
+/// be encoded as timestamp value 0.
 table Timestamp {
   unit: TimeUnit;
 
-  /// The time zone is a string indicating the name of a time zone, one of:
+  /// The timezone is an optional string indicating the name of a timezone,
+  /// one of:
   ///
-  /// * As used in the Olson time zone database (the "tz database" or
-  ///   "tzdata"), such as "America/New_York"
-  /// * An absolute time zone offset of the form +XX:XX or -XX:XX, such as +07:30
+  /// * As used in the Olson timezone database (the "tz database" or
+  ///   "tzdata"), such as "America/New_York".
+  /// * An absolute timezone offset of the form "+XX:XX" or "-XX:XX",
+  ///   such as "+07:30".
   ///
   /// Whether a timezone string is present indicates different semantics about
-  /// the data:
-  ///
-  /// * If the time zone is null or equal to an empty string, the data is "time
-  ///   zone naive" and shall be displayed *as is* to the user, not localized
-  ///   to the locale of the user. This data can be though of as UTC but
-  ///   without having "UTC" as the time zone, it is not considered to be
-  ///   localized to any time zone
-  ///
-  /// * If the time zone is set to a valid value, values can be displayed as
-  ///   "localized" to that time zone, even though the underlying 64-bit
-  ///   integers are identical to the same data stored in UTC. Converting
-  ///   between time zones is a metadata-only operation and does not change the
-  ///   underlying values
+  /// the data (see above).
   timezone: string;
 }
 
@@ -252,18 +366,19 @@ enum IntervalUnit: short { YEAR_MONTH, DAY_TIME, MONTH_DAY_NANO}
 // days can differ in length during day light savings time transitions).
 // All integers in the types below are stored in the endianness indicated
 // by the schema.
+//
 // YEAR_MONTH - Indicates the number of elapsed whole months, stored as
 //   4-byte signed integers.
-// DAY_TIME - Indicates the number of elapsed days and milliseconds,
-//   stored as 2 contiguous 32-bit integers (8-bytes in total).  Support
+// DAY_TIME - Indicates the number of elapsed days and milliseconds (no leap seconds),
+//   stored as 2 contiguous 32-bit signed integers (8-bytes in total). Support
 //   of this IntervalUnit is not required for full arrow compatibility.
 // MONTH_DAY_NANO - A triple of the number of elapsed months, days, and nanoseconds.
-//  The values are stored contiguously in 16 byte blocks. Months and
-//  days are encoded as 32 bit integers and nanoseconds is encoded as a
-//  64 bit integer. All integers are signed. Each field is independent
-//  (e.g. there is no constraint that nanoseconds have the same sign
-//   as days or that the quantity of nanoseconds represents less
-//   than a day's worth of time).
+//  The values are stored contiguously in 16-byte blocks. Months and days are
+//  encoded as 32-bit signed integers and nanoseconds is encoded as a 64-bit
+//  signed integer. Nanoseconds does not allow for leap seconds. Each field is
+//  independent (e.g. there is no constraint that nanoseconds have the same
+//  sign as days or that the quantity of nanoseconds represents less than a
+//  day's worth of time).
 table Interval {
   unit: IntervalUnit;
 }
@@ -311,6 +426,7 @@ union Type {
   LargeBinary,
   LargeUtf8,
   LargeList,
+  RunEndEncoded,
 }
 
 /// ----------------------------------------------------------------------
diff --git a/integration-testing/src/lib.rs b/integration-testing/src/lib.rs
deleted file mode 100644
index 5d3da15d3f50..000000000000
--- a/integration-testing/src/lib.rs
+++ /dev/null
@@ -1,78 +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.
-
-//! Common code used in the integration test binaries
-
-use serde_json::Value;
-
-use arrow::util::integration_util::ArrowJsonBatch;
-
-use arrow::datatypes::Schema;
-use arrow::error::Result;
-use arrow::record_batch::RecordBatch;
-use arrow::util::integration_util::*;
-use std::collections::HashMap;
-use std::fs::File;
-use std::io::BufReader;
-
-/// The expected username for the basic auth integration test.
-pub const AUTH_USERNAME: &str = "arrow";
-/// The expected password for the basic auth integration test.
-pub const AUTH_PASSWORD: &str = "flight";
-
-pub mod flight_client_scenarios;
-pub mod flight_server_scenarios;
-
-pub struct ArrowFile {
-    pub schema: Schema,
-    // we can evolve this into a concrete Arrow type
-    // this is temporarily not being read from
-    pub _dictionaries: HashMap<i64, ArrowJsonDictionaryBatch>,
-    pub batches: Vec<RecordBatch>,
-}
-
-pub fn read_json_file(json_name: &str) -> Result<ArrowFile> {
-    let json_file = File::open(json_name)?;
-    let reader = BufReader::new(json_file);
-    let arrow_json: Value = serde_json::from_reader(reader).unwrap();
-    let schema = Schema::from(&arrow_json["schema"])?;
-    // read dictionaries
-    let mut dictionaries = HashMap::new();
-    if let Some(dicts) = arrow_json.get("dictionaries") {
-        for d in dicts
-            .as_array()
-            .expect("Unable to get dictionaries as array")
-        {
-            let json_dict: ArrowJsonDictionaryBatch = serde_json::from_value(d.clone())
-                .expect("Unable to get dictionary from JSON");
-            // TODO: convert to a concrete Arrow type
-            dictionaries.insert(json_dict.id, json_dict);
-        }
-    }
-
-    let mut batches = vec![];
-    for b in arrow_json["batches"].as_array().unwrap() {
-        let json_batch: ArrowJsonBatch = serde_json::from_value(b.clone()).unwrap();
-        let batch = record_batch_from_json(&schema, json_batch, Some(&dictionaries))?;
-        batches.push(batch);
-    }
-    Ok(ArrowFile {
-        schema,
-        _dictionaries: dictionaries,
-        batches,
-    })
-}
diff --git a/object_store/.github_changelog_generator b/object_store/.github_changelog_generator
index cbd8aa0c4b48..6d44a8eb83eb 100644
--- a/object_store/.github_changelog_generator
+++ b/object_store/.github_changelog_generator
@@ -23,5 +23,5 @@ add-sections={"documentation":{"prefix":"**Documentation updates:**","labels":["
 # so that the component is shown associated with the issue
 issue-line-labels=object-store
 # skip non object_store issues
-exclude-labels=development-process,invalid,arrow,parquet,arrow-flight
+exclude-labels=development-process,invalid,arrow,parquet,arrow-flight,parquet-derive,question
 breaking_labels=api-change
diff --git a/object_store/CHANGELOG-old.md b/object_store/CHANGELOG-old.md
new file mode 100644
index 000000000000..d01b8a3aa76d
--- /dev/null
+++ b/object_store/CHANGELOG-old.md
@@ -0,0 +1,515 @@
+<!---
+  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.
+-->
+
+# Historical Changelog
+
+## [object_store_0.8.0](https://github.com/apache/arrow-rs/tree/object_store_0.8.0) (2023-11-02)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.7.1...object_store_0.8.0)
+
+**Breaking changes:**
+
+- Remove ObjectStore::append [\#5016](https://github.com/apache/arrow-rs/pull/5016) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Don't panic on invalid Azure access key \(\#4972\) [\#4974](https://github.com/apache/arrow-rs/pull/4974) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Return `PutResult` with an ETag from ObjectStore::put \(\#4934\) [\#4944](https://github.com/apache/arrow-rs/pull/4944) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add ObjectMeta::version and GetOptions::version \(\#4925\) [\#4935](https://github.com/apache/arrow-rs/pull/4935) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add GetOptions::head [\#4931](https://github.com/apache/arrow-rs/pull/4931) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Remove Nested async and Fallibility from ObjectStore::list [\#4930](https://github.com/apache/arrow-rs/pull/4930) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add ObjectStore::put_opts / Conditional Put [\#4879](https://github.com/apache/arrow-rs/pull/4984) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Relax Path Safety on Parse [\#5019](https://github.com/apache/arrow-rs/issues/5019) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- ObjectStore: hard to determine the cause of the error thrown from retry [\#5013](https://github.com/apache/arrow-rs/issues/5013) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- continue existing multi-part upload [\#4961](https://github.com/apache/arrow-rs/issues/4961) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Simplify ObjectStore::List [\#4946](https://github.com/apache/arrow-rs/issues/4946) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Return ETag and Version on Put [\#4934](https://github.com/apache/arrow-rs/issues/4934) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Support Not Signing Requests in AmazonS3 [\#4927](https://github.com/apache/arrow-rs/issues/4927) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Get Object By Version [\#4925](https://github.com/apache/arrow-rs/issues/4925) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Plans for supporting Extension Array to support Fixed shape tensor Array [\#4890](https://github.com/apache/arrow-rs/issues/4890)
+- Conditional Put Support [\#4879](https://github.com/apache/arrow-rs/issues/4879) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- creates\_dir\_if\_not\_present\_append Test is Flaky [\#4872](https://github.com/apache/arrow-rs/issues/4872) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Release object\_store `0.7.1` [\#4858](https://github.com/apache/arrow-rs/issues/4858) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Support User-Defined Object Metadata [\#4754](https://github.com/apache/arrow-rs/issues/4754) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- APIs for directly managing multi-part uploads and saving potential parquet footers [\#4608](https://github.com/apache/arrow-rs/issues/4608)
+
+**Fixed bugs:**
+
+- ObjectStore parse\_url Incorrectly Handles URLs with Spaces [\#5017](https://github.com/apache/arrow-rs/issues/5017) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- \[objects-store\]: periods/dots error in GCP bucket [\#4991](https://github.com/apache/arrow-rs/issues/4991) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Azure ImdsManagedIdentityProvider does not work in Azure functions [\#4976](https://github.com/apache/arrow-rs/issues/4976) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Panic when using an azure object store with an invalid access key [\#4972](https://github.com/apache/arrow-rs/issues/4972) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Handle Body Errors in AWS CompleteMultipartUpload [\#4965](https://github.com/apache/arrow-rs/issues/4965) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- ObjectStore multiple\_append Test is Flaky [\#4868](https://github.com/apache/arrow-rs/issues/4868) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- \[objectstore\] Problem with special characters in file path [\#4454](https://github.com/apache/arrow-rs/issues/4454)
+
+**Closed issues:**
+
+- Include onelake fabric path for https [\#5000](https://github.com/apache/arrow-rs/issues/5000) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- \[object\_store\] Support generating and using signed upload URLs [\#4763](https://github.com/apache/arrow-rs/issues/4763) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Merged pull requests:**
+
+- Relax path safety \(\#5019\) [\#5020](https://github.com/apache/arrow-rs/pull/5020) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Decode URL paths \(\#5017\) [\#5018](https://github.com/apache/arrow-rs/pull/5018) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- ObjectStore: make error msg thrown from retry more detailed [\#5012](https://github.com/apache/arrow-rs/pull/5012) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([Rachelint](https://github.com/Rachelint))
+- Support onelake fabric paths in parse\_url \(\#5000\) [\#5002](https://github.com/apache/arrow-rs/pull/5002) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Object tagging \(\#4754\)  [\#4999](https://github.com/apache/arrow-rs/pull/4999) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- \[MINOR\] No need to jump to web pages [\#4994](https://github.com/apache/arrow-rs/pull/4994) ([smallzhongfeng](https://github.com/smallzhongfeng))
+- Pushdown list\_with\_offset for GCS [\#4993](https://github.com/apache/arrow-rs/pull/4993) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Support bucket name with `.` when parsing GCS URL \(\#4991\) [\#4992](https://github.com/apache/arrow-rs/pull/4992) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Increase default timeout to 30 seconds [\#4989](https://github.com/apache/arrow-rs/pull/4989) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Conditional Put \(\#4879\)  [\#4984](https://github.com/apache/arrow-rs/pull/4984) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Update quick-xml requirement from 0.30.0 to 0.31.0 in /object\_store [\#4983](https://github.com/apache/arrow-rs/pull/4983) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump actions/setup-node from 3 to 4 [\#4982](https://github.com/apache/arrow-rs/pull/4982) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Support ImdsManagedIdentityProvider in Azure Functions \(\#4976\) [\#4977](https://github.com/apache/arrow-rs/pull/4977) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add MultiPartStore \(\#4961\) \(\#4608\) [\#4971](https://github.com/apache/arrow-rs/pull/4971) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Split gcp Module [\#4956](https://github.com/apache/arrow-rs/pull/4956) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add module links in docs root [\#4955](https://github.com/apache/arrow-rs/pull/4955) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Prepare arrow 48.0.0 [\#4948](https://github.com/apache/arrow-rs/pull/4948) ([tustvold](https://github.com/tustvold))
+- Allow opting out of request signing \(\#4927\) [\#4929](https://github.com/apache/arrow-rs/pull/4929) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Default connection and request timeouts of 5 seconds [\#4928](https://github.com/apache/arrow-rs/pull/4928) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Support service\_account in ApplicationDefaultCredentials and Use SelfSignedJwt [\#4926](https://github.com/apache/arrow-rs/pull/4926) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Generate `ETag`s for `InMemory` and `LocalFileSystem` \(\#4879\) [\#4922](https://github.com/apache/arrow-rs/pull/4922) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Cleanup `object_store::retry` client error handling [\#4915](https://github.com/apache/arrow-rs/pull/4915) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Fix integration tests [\#4889](https://github.com/apache/arrow-rs/pull/4889) ([tustvold](https://github.com/tustvold))
+- Support Parsing Avro File Headers [\#4888](https://github.com/apache/arrow-rs/pull/4888) ([tustvold](https://github.com/tustvold))
+- Update ring requirement from 0.16 to 0.17 in /object\_store [\#4887](https://github.com/apache/arrow-rs/pull/4887) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add AWS presigned URL support [\#4876](https://github.com/apache/arrow-rs/pull/4876) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([carols10cents](https://github.com/carols10cents))
+- Flush in creates\_dir\_if\_not\_present\_append \(\#4872\) [\#4874](https://github.com/apache/arrow-rs/pull/4874) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Flush in multiple\_append test \(\#4868\) [\#4869](https://github.com/apache/arrow-rs/pull/4869) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Enable new integration tests \(\#4828\) [\#4862](https://github.com/apache/arrow-rs/pull/4862) ([tustvold](https://github.com/tustvold))
+
+## [object_store_0.7.1](https://github.com/apache/arrow-rs/tree/object_store_0.7.1) (2023-09-26)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.7.0...object_store_0.7.1)
+
+**Implemented enhancements:**
+
+- Automatically Cleanup LocalFileSystem Temporary Files [\#4778](https://github.com/apache/arrow-rs/issues/4778) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object-store: Expose an async reader API for object store [\#4762](https://github.com/apache/arrow-rs/issues/4762)
+- Improve proxy support by using reqwest::Proxy as configuration [\#4713](https://github.com/apache/arrow-rs/issues/4713) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Fixed bugs:**
+
+- object-store: http shouldn't perform range requests unless `accept-ranges: bytes` header is present [\#4839](https://github.com/apache/arrow-rs/issues/4839)
+- object-store: http-store fails when url doesn't have last-modified header on 0.7.0 [\#4831](https://github.com/apache/arrow-rs/issues/4831)
+- object-store fails to compile for `wasm32-unknown-unknown` with `http` feature [\#4776](https://github.com/apache/arrow-rs/issues/4776) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object-store: could not find `header` in `client` for `http` feature [\#4775](https://github.com/apache/arrow-rs/issues/4775) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- LocalFileSystem Copy and Rename Don't Create Intermediate Directories [\#4760](https://github.com/apache/arrow-rs/issues/4760) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- LocalFileSystem Copy is not Atomic [\#4758](https://github.com/apache/arrow-rs/issues/4758) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Closed issues:**
+
+- object\_store Azure Government Cloud functionality? [\#4853](https://github.com/apache/arrow-rs/issues/4853)
+
+**Merged pull requests:**
+
+- Add ObjectStore BufReader \(\#4762\) [\#4857](https://github.com/apache/arrow-rs/pull/4857) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Allow overriding azure endpoint [\#4854](https://github.com/apache/arrow-rs/pull/4854) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Minor: Improve object\_store docs.rs landing page [\#4849](https://github.com/apache/arrow-rs/pull/4849) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([alamb](https://github.com/alamb))
+- Error if Remote Ignores HTTP Range Header [\#4841](https://github.com/apache/arrow-rs/pull/4841) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([universalmind303](https://github.com/universalmind303))
+- Perform HEAD request for HttpStore::head [\#4837](https://github.com/apache/arrow-rs/pull/4837) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- fix: object store http header last modified [\#4834](https://github.com/apache/arrow-rs/pull/4834) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([universalmind303](https://github.com/universalmind303))
+- Prepare arrow 47.0.0 [\#4827](https://github.com/apache/arrow-rs/pull/4827) ([tustvold](https://github.com/tustvold))
+- ObjectStore Wasm32 Fixes \(\#4775\) \(\#4776\) [\#4796](https://github.com/apache/arrow-rs/pull/4796) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Best effort cleanup of staged upload files \(\#4778\) [\#4792](https://github.com/apache/arrow-rs/pull/4792) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Relaxing type bounds on coalesce\_ranges and collect\_bytes [\#4787](https://github.com/apache/arrow-rs/pull/4787) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([sumerman](https://github.com/sumerman))
+- Update object\_store chrono deprecations [\#4786](https://github.com/apache/arrow-rs/pull/4786) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Make coalesce\_ranges and collect\_bytes available for crate users [\#4784](https://github.com/apache/arrow-rs/pull/4784) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([sumerman](https://github.com/sumerman))
+- Bump actions/checkout from 3 to 4 [\#4767](https://github.com/apache/arrow-rs/pull/4767) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Make ObjectStore::copy Atomic and Automatically Create Parent Directories \(\#4758\) \(\#4760\) [\#4759](https://github.com/apache/arrow-rs/pull/4759) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Update nix requirement from 0.26.1 to 0.27.1 in /object\_store [\#4744](https://github.com/apache/arrow-rs/pull/4744) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([viirya](https://github.com/viirya))
+- Add `with_proxy_ca_certificate` and `with_proxy_excludes` [\#4714](https://github.com/apache/arrow-rs/pull/4714) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([gordonwang0](https://github.com/gordonwang0))
+- Update object\_store Dependencies and Configure Dependabot [\#4700](https://github.com/apache/arrow-rs/pull/4700) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+
+## [object_store_0.7.0](https://github.com/apache/arrow-rs/tree/object_store_0.7.0) (2023-08-15)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.6.1...object_store_0.7.0)
+
+**Breaking changes:**
+
+- Add range and ObjectMeta to GetResult \(\#4352\) \(\#4495\) [\#4677](https://github.com/apache/arrow-rs/pull/4677) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- Add AzureConfigKey::ContainerName [\#4629](https://github.com/apache/arrow-rs/issues/4629) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: multipart ranges for HTTP [\#4612](https://github.com/apache/arrow-rs/issues/4612)
+- Make object\_store::multipart public [\#4569](https://github.com/apache/arrow-rs/issues/4569) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: Export `ClientConfigKey` and make the `HttpBuilder` more consistent with other builders [\#4515](https://github.com/apache/arrow-rs/issues/4515) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store/InMemory: Make `clone()` non-async [\#4496](https://github.com/apache/arrow-rs/issues/4496) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Add Range to GetResult::File [\#4352](https://github.com/apache/arrow-rs/issues/4352) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Support copy\_if\_not\_exists for Cloudflare R2 \(S3 API\)  [\#4190](https://github.com/apache/arrow-rs/issues/4190)
+
+**Fixed bugs:**
+
+- object\_store documentation is broken [\#4683](https://github.com/apache/arrow-rs/issues/4683) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Exports are not sufficient for configuring some object stores, for example minio running locally [\#4530](https://github.com/apache/arrow-rs/issues/4530) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: Uploading empty file to S3 results in "411 Length Required" [\#4514](https://github.com/apache/arrow-rs/issues/4514) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- GCP doesn't fetch public objects [\#4417](https://github.com/apache/arrow-rs/issues/4417) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Closed issues:**
+
+- \[object\_store\] when Create a AmazonS3 instance  work with MinIO without set endpoint got error MissingRegion [\#4617](https://github.com/apache/arrow-rs/issues/4617)
+- AWS Profile credentials no longer working in object\_store 0.6.1 [\#4556](https://github.com/apache/arrow-rs/issues/4556) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Merged pull requests:**
+
+- Add AzureConfigKey::ContainerName \(\#4629\) [\#4686](https://github.com/apache/arrow-rs/pull/4686) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Fix MSRV CI [\#4671](https://github.com/apache/arrow-rs/pull/4671) ([tustvold](https://github.com/tustvold))
+- Use Config System for Object Store Integration Tests [\#4628](https://github.com/apache/arrow-rs/pull/4628) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Prepare arrow 45 [\#4590](https://github.com/apache/arrow-rs/pull/4590) ([tustvold](https://github.com/tustvold))
+- Add Support for Microsoft Fabric / OneLake [\#4573](https://github.com/apache/arrow-rs/pull/4573) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([vmuddassir-msft](https://github.com/vmuddassir-msft))
+- Cleanup multipart upload trait [\#4572](https://github.com/apache/arrow-rs/pull/4572) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Make object\_store::multipart public [\#4570](https://github.com/apache/arrow-rs/pull/4570) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([yjshen](https://github.com/yjshen))
+- Handle empty S3 payloads \(\#4514\) [\#4518](https://github.com/apache/arrow-rs/pull/4518) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- object\_store: Export `ClientConfigKey` and add `HttpBuilder::with_config` [\#4516](https://github.com/apache/arrow-rs/pull/4516) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([thehabbos007](https://github.com/thehabbos007))
+- object\_store: Implement `ObjectStore` for `Arc` [\#4502](https://github.com/apache/arrow-rs/pull/4502) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([Turbo87](https://github.com/Turbo87))
+- object\_store/InMemory: Add `fork()` fn and deprecate `clone()` fn [\#4499](https://github.com/apache/arrow-rs/pull/4499) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([Turbo87](https://github.com/Turbo87))
+- Bump actions/deploy-pages from 1 to 2 [\#4449](https://github.com/apache/arrow-rs/pull/4449) ([dependabot[bot]](https://github.com/apps/dependabot))
+- gcp: Exclude authorization header when bearer empty [\#4418](https://github.com/apache/arrow-rs/pull/4418) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([vrongmeal](https://github.com/vrongmeal))
+- Support copy\_if\_not\_exists for Cloudflare R2 \(\#4190\) [\#4239](https://github.com/apache/arrow-rs/pull/4239) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+
+## [object_store_0.6.0](https://github.com/apache/arrow-rs/tree/object_store_0.6.0) (2023-05-18)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.5.6...object_store_0.6.0)
+
+**Breaking changes:**
+
+- Add ObjectStore::get\_opts \(\#2241\) [\#4212](https://github.com/apache/arrow-rs/pull/4212) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Simplify ObjectStore configuration pattern [\#4189](https://github.com/apache/arrow-rs/pull/4189) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- object\_store: fix: Incorrect parsing of https Path Style S3 url [\#4082](https://github.com/apache/arrow-rs/pull/4082) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+- feat: add etag for objectMeta [\#3937](https://github.com/apache/arrow-rs/pull/3937) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([Weijun-H](https://github.com/Weijun-H))
+
+**Implemented enhancements:**
+
+- Object Store Authorization [\#4223](https://github.com/apache/arrow-rs/issues/4223) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Use XML API for GCS [\#4209](https://github.com/apache/arrow-rs/issues/4209) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- ObjectStore with\_url Should Handle Path [\#4199](https://github.com/apache/arrow-rs/issues/4199)
+- Return Error on Invalid Config Value [\#4191](https://github.com/apache/arrow-rs/issues/4191) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Extensible ObjectStore Authentication [\#4163](https://github.com/apache/arrow-rs/issues/4163) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: When using an AWS profile, obtain the default AWS region from the active profile [\#4158](https://github.com/apache/arrow-rs/issues/4158) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- InMemory append API [\#4152](https://github.com/apache/arrow-rs/issues/4152) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Support accessing ipc Reader/Writer inner by reference [\#4121](https://github.com/apache/arrow-rs/issues/4121)
+- \[object\_store\] Retry requests on connection error [\#4119](https://github.com/apache/arrow-rs/issues/4119) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: Instantiate object store from provided url with store options [\#4047](https://github.com/apache/arrow-rs/issues/4047) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: Builders \(S3/Azure/GCS\) are missing the `get method` to get the actual configuration information  [\#4021](https://github.com/apache/arrow-rs/issues/4021) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Fixed bugs:**
+
+- ObjectStore::head Returns Directory for LocalFileSystem and Hierarchical Azure [\#4230](https://github.com/apache/arrow-rs/issues/4230) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: different behavior from aws cli for default profile [\#4137](https://github.com/apache/arrow-rs/issues/4137) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- ImdsManagedIdentityOAuthProvider should send resource ID instead of OIDC scope [\#4096](https://github.com/apache/arrow-rs/issues/4096) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Update readme to remove reference to Jira [\#4091](https://github.com/apache/arrow-rs/issues/4091)
+- object\_store: Incorrect parsing of https Path Style S3 url [\#4078](https://github.com/apache/arrow-rs/issues/4078) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- \[object\_store\] `local::tests::test_list_root` test fails during release verification [\#3772](https://github.com/apache/arrow-rs/issues/3772) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Merged pull requests:**
+
+- Remove AWS\_PROFILE support [\#4238](https://github.com/apache/arrow-rs/pull/4238) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Expose AwsAuthorizer [\#4237](https://github.com/apache/arrow-rs/pull/4237) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Expose CredentialProvider [\#4235](https://github.com/apache/arrow-rs/pull/4235) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Return NotFound for directories in Head and Get \(\#4230\) [\#4231](https://github.com/apache/arrow-rs/pull/4231) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Standardise credentials API \(\#4223\) \(\#4163\) [\#4225](https://github.com/apache/arrow-rs/pull/4225) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Extract Common Listing and Retrieval Functionality [\#4220](https://github.com/apache/arrow-rs/pull/4220) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- feat\(object-store\): extend Options API for http client [\#4208](https://github.com/apache/arrow-rs/pull/4208) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+- Consistently use GCP XML API [\#4207](https://github.com/apache/arrow-rs/pull/4207) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Implement list\_with\_offset for PrefixStore [\#4203](https://github.com/apache/arrow-rs/pull/4203) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Allow setting ClientOptions with Options API [\#4202](https://github.com/apache/arrow-rs/pull/4202) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Create ObjectStore from URL and Options \(\#4047\) [\#4200](https://github.com/apache/arrow-rs/pull/4200) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Skip test\_list\_root on OS X \(\#3772\) [\#4198](https://github.com/apache/arrow-rs/pull/4198) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Recognise R2 URLs for S3 object store \(\#4190\) [\#4194](https://github.com/apache/arrow-rs/pull/4194) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Fix ImdsManagedIdentityProvider \(\#4096\) [\#4193](https://github.com/apache/arrow-rs/pull/4193) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Deffered Object Store Config Parsing \(\#4191\)  [\#4192](https://github.com/apache/arrow-rs/pull/4192) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Object Store \(AWS\): Support dynamically resolving S3 bucket region [\#4188](https://github.com/apache/arrow-rs/pull/4188) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([mr-brobot](https://github.com/mr-brobot))
+- Faster prefix match in object\_store path handling [\#4164](https://github.com/apache/arrow-rs/pull/4164) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Object Store \(AWS\): Support region configured via named profile [\#4161](https://github.com/apache/arrow-rs/pull/4161) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([mr-brobot](https://github.com/mr-brobot))
+- InMemory append API [\#4153](https://github.com/apache/arrow-rs/pull/4153) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([berkaysynnada](https://github.com/berkaysynnada))
+- docs: fix the wrong ln command in CONTRIBUTING.md [\#4139](https://github.com/apache/arrow-rs/pull/4139) ([SteveLauC](https://github.com/SteveLauC))
+- Display the file path in the error message when failed to open credentials file for GCS [\#4124](https://github.com/apache/arrow-rs/pull/4124) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([haoxins](https://github.com/haoxins))
+- Retry on Connection Errors [\#4120](https://github.com/apache/arrow-rs/pull/4120) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([kindly](https://github.com/kindly))
+- Simplify reference to GitHub issues [\#4092](https://github.com/apache/arrow-rs/pull/4092) ([bkmgit](https://github.com/bkmgit))
+- Use reqwest build\_split [\#4039](https://github.com/apache/arrow-rs/pull/4039) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Fix object\_store CI [\#4037](https://github.com/apache/arrow-rs/pull/4037) ([tustvold](https://github.com/tustvold))
+- Add get\_config\_value to AWS/Azure/GCP Builders [\#4035](https://github.com/apache/arrow-rs/pull/4035) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([r4ntix](https://github.com/r4ntix))
+- Update AWS SDK [\#3993](https://github.com/apache/arrow-rs/pull/3993) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+
+## [object_store_0.5.6](https://github.com/apache/arrow-rs/tree/object_store_0.5.6) (2023-03-30)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.5.5...object_store_0.5.6)
+
+**Implemented enhancements:**
+
+- Document ObjectStore::list Ordering [\#3975](https://github.com/apache/arrow-rs/issues/3975) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Add option to start listing at a particular key [\#3970](https://github.com/apache/arrow-rs/issues/3970) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Implement `ObjectStore` for trait objects [\#3865](https://github.com/apache/arrow-rs/issues/3865) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Add ObjectStore::append [\#3790](https://github.com/apache/arrow-rs/issues/3790) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Make `InMemory` object store track last modified time for each entry [\#3782](https://github.com/apache/arrow-rs/issues/3782) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Support Unsigned S3 Payloads [\#3737](https://github.com/apache/arrow-rs/issues/3737) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Add Content-MD5 or checksum header for using an Object Locked S3 [\#3725](https://github.com/apache/arrow-rs/issues/3725) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Fixed bugs:**
+
+- LocalFileSystem::put is not Atomic [\#3780](https://github.com/apache/arrow-rs/issues/3780) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Merged pull requests:**
+
+- Add ObjectStore::list\_with\_offset \(\#3970\) [\#3973](https://github.com/apache/arrow-rs/pull/3973) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Remove incorrect validation logic on S3 bucket names [\#3947](https://github.com/apache/arrow-rs/pull/3947) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([rtyler](https://github.com/rtyler))
+- Prepare arrow 36 [\#3935](https://github.com/apache/arrow-rs/pull/3935) ([tustvold](https://github.com/tustvold))
+- fix: Specify content length for gcp copy request [\#3921](https://github.com/apache/arrow-rs/pull/3921) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([scsmithr](https://github.com/scsmithr))
+- Revert structured ArrayData \(\#3877\) [\#3894](https://github.com/apache/arrow-rs/pull/3894) ([tustvold](https://github.com/tustvold))
+- Add support for checksum algorithms in AWS [\#3873](https://github.com/apache/arrow-rs/pull/3873) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([trueleo](https://github.com/trueleo))
+- Rename PrefixObjectStore to PrefixStore [\#3870](https://github.com/apache/arrow-rs/pull/3870) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Implement append for LimitStore, PrefixObjectStore, ThrottledStore [\#3869](https://github.com/apache/arrow-rs/pull/3869) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Supporting metadata fetch without open file read mode [\#3868](https://github.com/apache/arrow-rs/pull/3868) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([metesynnada](https://github.com/metesynnada))
+- Impl ObjectStore for trait object [\#3866](https://github.com/apache/arrow-rs/pull/3866) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([Kinrany](https://github.com/Kinrany))
+- Update quick-xml requirement from 0.27.0 to 0.28.0 [\#3857](https://github.com/apache/arrow-rs/pull/3857) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Update changelog for 35.0.0 [\#3843](https://github.com/apache/arrow-rs/pull/3843) ([tustvold](https://github.com/tustvold))
+- Cleanup ApplicationDefaultCredentials [\#3799](https://github.com/apache/arrow-rs/pull/3799) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Make InMemory object store track last modified time for each entry [\#3796](https://github.com/apache/arrow-rs/pull/3796) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([Weijun-H](https://github.com/Weijun-H))
+- Add ObjectStore::append [\#3791](https://github.com/apache/arrow-rs/pull/3791) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Make LocalFileSystem::put atomic \(\#3780\) [\#3781](https://github.com/apache/arrow-rs/pull/3781) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add support for unsigned payloads in aws [\#3741](https://github.com/apache/arrow-rs/pull/3741) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([trueleo](https://github.com/trueleo))
+
+## [object_store_0.5.5](https://github.com/apache/arrow-rs/tree/object_store_0.5.5) (2023-02-27)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.5.4...object_store_0.5.5)
+
+**Implemented enhancements:**
+
+- object\_store: support azure cli credential [\#3697](https://github.com/apache/arrow-rs/issues/3697) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: support encoded path as input [\#3651](https://github.com/apache/arrow-rs/issues/3651) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Fixed bugs:**
+
+- object-store: aws\_profile fails to load static credentials [\#3765](https://github.com/apache/arrow-rs/issues/3765) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Inconsistent Behaviour Listing File [\#3712](https://github.com/apache/arrow-rs/issues/3712) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: bearer token is azure is used like access key [\#3696](https://github.com/apache/arrow-rs/issues/3696) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Merged pull requests:**
+
+- object-store: fix handling of AWS profile credentials without expiry [\#3766](https://github.com/apache/arrow-rs/pull/3766) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([helmus](https://github.com/helmus))
+- update object\_store deps to patch potential security vulnerabilities [\#3761](https://github.com/apache/arrow-rs/pull/3761) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([spencerbart](https://github.com/spencerbart))
+- Filter exact list prefix matches for azure gen2 accounts [\#3714](https://github.com/apache/arrow-rs/pull/3714) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+- Filter exact list prefix matches for MemoryStore and HttpStore \(\#3712\) [\#3713](https://github.com/apache/arrow-rs/pull/3713) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- object\_store: azure cli authorization [\#3698](https://github.com/apache/arrow-rs/pull/3698) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+- object\_store: add Path::from\_url\_path [\#3663](https://github.com/apache/arrow-rs/pull/3663) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([jychen7](https://github.com/jychen7))
+
+## [object_store_0.5.4](https://github.com/apache/arrow-rs/tree/object_store_0.5.4) (2023-01-30)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.5.3...object_store_0.5.4)
+
+**Implemented enhancements:**
+
+- \[object\_store\] support more identity based auth flows for azure [\#3580](https://github.com/apache/arrow-rs/issues/3580) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Implement workload identity and application default credentials for GCP object store. [\#3533](https://github.com/apache/arrow-rs/issues/3533) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Support GCP Workload Identity [\#3490](https://github.com/apache/arrow-rs/issues/3490) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Allow providing service account key directly when building GCP object store client [\#3488](https://github.com/apache/arrow-rs/issues/3488) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Closed issues:**
+
+- object\_store: temporary aws credentials not refreshed? [\#3446](https://github.com/apache/arrow-rs/issues/3446) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Merged pull requests:**
+
+- Final tweaks to 32.0.0 changelog [\#3618](https://github.com/apache/arrow-rs/pull/3618) ([tustvold](https://github.com/tustvold))
+- Update AWS SDK [\#3617](https://github.com/apache/arrow-rs/pull/3617) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add ClientOption.allow\_insecure [\#3600](https://github.com/apache/arrow-rs/pull/3600) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([poelzi](https://github.com/poelzi))
+- \[object\_store\] support azure managed and workload identities [\#3581](https://github.com/apache/arrow-rs/pull/3581) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+- Additional GCP authentication [\#3541](https://github.com/apache/arrow-rs/pull/3541) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([winding-lines](https://github.com/winding-lines))
+- Update aws-config and aws-types requirements from 0.52 to 0.53 [\#3539](https://github.com/apache/arrow-rs/pull/3539) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([viirya](https://github.com/viirya))
+- Use GHA concurrency groups \(\#3495\) [\#3538](https://github.com/apache/arrow-rs/pull/3538) ([tustvold](https://github.com/tustvold))
+- Remove azurite test exception [\#3497](https://github.com/apache/arrow-rs/pull/3497) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- feat: Allow providing a service account key directly for GCS [\#3489](https://github.com/apache/arrow-rs/pull/3489) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([scsmithr](https://github.com/scsmithr))
+
+## [object_store_0.5.3](https://github.com/apache/arrow-rs/tree/object_store_0.5.3) (2023-01-04)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.5.2...object_store_0.5.3)
+
+**Implemented enhancements:**
+
+- Derive Clone for the builders in object-store. [\#3419](https://github.com/apache/arrow-rs/issues/3419)
+- Add a constant prefix object store wrapper [\#3328](https://github.com/apache/arrow-rs/issues/3328) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Add support for content-type while uploading files through ObjectStore API [\#3300](https://github.com/apache/arrow-rs/issues/3300) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Add HttpStore [\#3294](https://github.com/apache/arrow-rs/issues/3294) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Add support for Azure Data Lake Storage Gen2 \(aka: ADLS Gen2\) in Object Store library [\#3283](https://github.com/apache/arrow-rs/issues/3283)
+- object\_store: Add Put and Multipart Upload Doc Examples [\#2863](https://github.com/apache/arrow-rs/issues/2863) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Closed issues:**
+
+- Only flush buffered multi-part data on poll\_shutdown not on poll\_flush [\#3390](https://github.com/apache/arrow-rs/issues/3390) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Merged pull requests:**
+
+- object\_store: builder configuration api [\#3436](https://github.com/apache/arrow-rs/pull/3436) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+- Derive Clone for ObjectStore builders and Make URL Parsing Stricter \(\#3419\) [\#3424](https://github.com/apache/arrow-rs/pull/3424) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add Put and Multipart Put doc examples [\#3420](https://github.com/apache/arrow-rs/pull/3420) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([GeauxEric](https://github.com/GeauxEric))
+- object\_store: update localstack instructions [\#3403](https://github.com/apache/arrow-rs/pull/3403) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([wjones127](https://github.com/wjones127))
+- object\_store: Flush buffered multipart only during poll\_shutdown [\#3397](https://github.com/apache/arrow-rs/pull/3397) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([askoa](https://github.com/askoa))
+- Update quick-xml to 0.27 [\#3395](https://github.com/apache/arrow-rs/pull/3395) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add HttpStore \(\#3294\) [\#3380](https://github.com/apache/arrow-rs/pull/3380) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- add support for content-type in `ClientOptions` [\#3358](https://github.com/apache/arrow-rs/pull/3358) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([ByteBaker](https://github.com/ByteBaker))
+- Update AWS SDK [\#3349](https://github.com/apache/arrow-rs/pull/3349) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Upstream newline\_delimited\_stream and ChunkedStore from DataFusion [\#3341](https://github.com/apache/arrow-rs/pull/3341) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- feat\(object\_store\): add PrefixObjectStore [\#3329](https://github.com/apache/arrow-rs/pull/3329) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+- feat\(object\_store\): parse well-known storage urls [\#3327](https://github.com/apache/arrow-rs/pull/3327) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+- Disable getrandom object\_store [\#3278](https://github.com/apache/arrow-rs/pull/3278) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Reload token from AWS\_WEB\_IDENTITY\_TOKEN\_FILE [\#3274](https://github.com/apache/arrow-rs/pull/3274) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Minor: skip aws integration test if TEST\_INTEGRATION is not set [\#3262](https://github.com/apache/arrow-rs/pull/3262) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([viirya](https://github.com/viirya))
+
+## [object_store_0.5.2](https://github.com/apache/arrow-rs/tree/object_store_0.5.2) (2022-12-02)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.5.1...object_store_0.5.2)
+
+**Implemented enhancements:**
+
+- Object Store: Allow custom reqwest client [\#3127](https://github.com/apache/arrow-rs/issues/3127)
+- socks5 proxy support for the object\_store crate [\#2989](https://github.com/apache/arrow-rs/issues/2989) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Cannot query S3 paths containing whitespace [\#2799](https://github.com/apache/arrow-rs/issues/2799) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Fixed bugs:**
+
+- object\_store\(gcp\): GCP complains about content-length for copy [\#3235](https://github.com/apache/arrow-rs/issues/3235)
+- object\_store\(aws\): EntityTooSmall error on multi-part upload [\#3233](https://github.com/apache/arrow-rs/issues/3233) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Merged pull requests:**
+
+- Add more ClientConfig Options for Object Store RequestBuilder \(\#3127\) [\#3256](https://github.com/apache/arrow-rs/pull/3256) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add ObjectStore ClientConfig [\#3252](https://github.com/apache/arrow-rs/pull/3252) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- fix\(object\_store,gcp\): test copy\_if\_not\_exist [\#3236](https://github.com/apache/arrow-rs/pull/3236) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([wjones127](https://github.com/wjones127))
+- fix\(object\_store,aws,gcp\): multipart upload enforce size limit of 5 MiB not 5MB [\#3234](https://github.com/apache/arrow-rs/pull/3234) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([wjones127](https://github.com/wjones127))
+- object\_store: add support for using proxy\_url for connection testing [\#3109](https://github.com/apache/arrow-rs/pull/3109) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([sum12](https://github.com/sum12))
+- Update AWS SDK [\#2974](https://github.com/apache/arrow-rs/pull/2974) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Update quick-xml requirement from 0.25.0 to 0.26.0 [\#2918](https://github.com/apache/arrow-rs/pull/2918) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Support building object_store and parquet on wasm32-unknown-unknown target [\#2896](https://github.com/apache/arrow-rs/pull/2899) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([jondo2010](https://github.com/jondo2010))
+- Add experimental AWS\_PROFILE support \(\#2178\) [\#2891](https://github.com/apache/arrow-rs/pull/2891) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+
+## [object_store_0.5.1](https://github.com/apache/arrow-rs/tree/object_store_0.5.1) (2022-10-04)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.5.0...object_store_0.5.1)
+
+**Implemented enhancements:**
+
+- Allow HTTP S3 URLs [\#2806](https://github.com/apache/arrow-rs/issues/2806)
+- object\_store: support AWS ECS instance credentials [\#2802](https://github.com/apache/arrow-rs/issues/2802)
+- Object Store S3 Alibaba Cloud OSS support [\#2777](https://github.com/apache/arrow-rs/issues/2777) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Expose option to use GCS object store in integration tests [\#2627](https://github.com/apache/arrow-rs/issues/2627) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Fixed bugs:**
+
+- S3 Signature Error Performing List With Prefix Containing Spaces  [\#2800](https://github.com/apache/arrow-rs/issues/2800) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Erratic Behaviour if Incorrect S3 Region Configured [\#2795](https://github.com/apache/arrow-rs/issues/2795) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Merged pull requests:**
+
+- Support for overriding instance metadata endpoint [\#2811](https://github.com/apache/arrow-rs/pull/2811) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([wjones127](https://github.com/wjones127))
+- Allow Configuring non-TLS HTTP Connections in AmazonS3Builder::from\_env [\#2807](https://github.com/apache/arrow-rs/pull/2807) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([avantgardnerio](https://github.com/avantgardnerio))
+- Fix S3 query canonicalization \(\#2800\) [\#2801](https://github.com/apache/arrow-rs/pull/2801) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Handle incomplete HTTP redirects missing LOCATION \(\#2795\) [\#2796](https://github.com/apache/arrow-rs/pull/2796) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Handle S3 virtual host request type [\#2782](https://github.com/apache/arrow-rs/pull/2782) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([askoa](https://github.com/askoa))
+- Fix object\_store multipart uploads on S3 Compatible Stores [\#2731](https://github.com/apache/arrow-rs/pull/2731) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([mildbyte](https://github.com/mildbyte))
+
+
+## [object_store_0.5.0](https://github.com/apache/arrow-rs/tree/object_store_0.5.0) (2022-09-08)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.4.0...object_store_0.5.0)
+
+**Breaking changes:**
+
+- Replace azure sdk with custom implementation [\#2509](https://github.com/apache/arrow-rs/pull/2509) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+- Replace rusoto with custom implementation for AWS \(\#2176\)  [\#2352](https://github.com/apache/arrow-rs/pull/2352) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+
+**Implemented enhancements:**
+
+- IMDSv1 Fallback for S3 [\#2609](https://github.com/apache/arrow-rs/issues/2609) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Print Response Body On Error [\#2572](https://github.com/apache/arrow-rs/issues/2572) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Coalesce Ranges Parallel Fetch [\#2562](https://github.com/apache/arrow-rs/issues/2562) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Support Coalescing Out-of-Order Ranges [\#2561](https://github.com/apache/arrow-rs/issues/2561) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: Add TokenProvider authorization to azure [\#2373](https://github.com/apache/arrow-rs/issues/2373) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- AmazonS3Builder::from\_env to populate credentials from environment [\#2361](https://github.com/apache/arrow-rs/issues/2361) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- AmazonS3 Support IMDSv2 [\#2350](https://github.com/apache/arrow-rs/issues/2350) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Fixed bugs:**
+
+- Retry Logic Fails to Retry Server Errors [\#2573](https://github.com/apache/arrow-rs/issues/2573) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Fix multiple part uploads at once making vector size inconsistent [\#2681](https://github.com/apache/arrow-rs/pull/2681) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([gruuya](https://github.com/gruuya))
+- Fix panic in `object_store::util::coalesce_ranges` [\#2554](https://github.com/apache/arrow-rs/pull/2554) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([thinkharderdev](https://github.com/thinkharderdev))
+
+**Merged pull requests:**
+
+- update doc for object\_store copy\_if\_not\_exists [\#2653](https://github.com/apache/arrow-rs/pull/2653) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([JanKaul](https://github.com/JanKaul))
+- Update quick-xml 0.24 [\#2625](https://github.com/apache/arrow-rs/pull/2625) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add IMDSv1 fallback \(\#2609\) [\#2610](https://github.com/apache/arrow-rs/pull/2610) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- ObjectStore cleanup \(\#2587\) [\#2590](https://github.com/apache/arrow-rs/pull/2590) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Fix retry logic \(\#2573\) \(\#2572\) [\#2574](https://github.com/apache/arrow-rs/pull/2574) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Improve coalesce\_ranges \(\#2561\) \(\#2562\) [\#2563](https://github.com/apache/arrow-rs/pull/2563) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Update environment variable name for amazonS3builder in integration \(\#2550\) [\#2553](https://github.com/apache/arrow-rs/pull/2553) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([amrltqt](https://github.com/amrltqt))
+- Build AmazonS3builder from environment variables \(\#2361\) [\#2536](https://github.com/apache/arrow-rs/pull/2536) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([amrltqt](https://github.com/amrltqt))
+- feat: add token provider authorization to azure store [\#2374](https://github.com/apache/arrow-rs/pull/2374) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+
+## [object_store_0.4.0](https://github.com/apache/arrow-rs/tree/object_store_0.4.0) (2022-08-10)
+
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.3.0...object_store_0.4.0)
+
+**Implemented enhancements:**
+
+- Relax Path Validation to Allow Any Percent-Encoded Sequence [\#2355](https://github.com/apache/arrow-rs/issues/2355) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Support get\_multi\_ranges in ObjectStore [\#2293](https://github.com/apache/arrow-rs/issues/2293)
+- object\_store: Create explicit test for symlinks [\#2206](https://github.com/apache/arrow-rs/issues/2206) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: Make builder style configuration for object stores [\#2203](https://github.com/apache/arrow-rs/issues/2203) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: Add example in the main documentation readme [\#2202](https://github.com/apache/arrow-rs/issues/2202) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Fixed bugs:**
+
+- Azure/S3 Storage Fails to Copy Blob with URL-encoded Path [\#2353](https://github.com/apache/arrow-rs/issues/2353) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Accessing a file with a percent-encoded name on the filesystem with ObjectStore LocalFileSystem [\#2349](https://github.com/apache/arrow-rs/issues/2349) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+
+**Documentation updates:**
+
+- Improve `object_store crate` documentation [\#2260](https://github.com/apache/arrow-rs/pull/2260) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([alamb](https://github.com/alamb))
+
+**Merged pull requests:**
+
+- Canonicalize filesystem paths in user-facing APIs \(\#2370\) [\#2371](https://github.com/apache/arrow-rs/pull/2371) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Fix object\_store lint [\#2367](https://github.com/apache/arrow-rs/pull/2367) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Relax path validation \(\#2355\) [\#2356](https://github.com/apache/arrow-rs/pull/2356) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Fix Copy from percent-encoded path \(\#2353\) [\#2354](https://github.com/apache/arrow-rs/pull/2354) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add ObjectStore::get\_ranges \(\#2293\) [\#2336](https://github.com/apache/arrow-rs/pull/2336) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Remove vestigal ` object_store/.circleci/` [\#2337](https://github.com/apache/arrow-rs/pull/2337) ([alamb](https://github.com/alamb))
+- Handle symlinks in LocalFileSystem \(\#2206\) [\#2269](https://github.com/apache/arrow-rs/pull/2269) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Retry GCP requests on server error [\#2243](https://github.com/apache/arrow-rs/pull/2243) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Add LimitStore \(\#2175\) [\#2242](https://github.com/apache/arrow-rs/pull/2242) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Only trigger `arrow` CI on changes to arrow [\#2227](https://github.com/apache/arrow-rs/pull/2227) ([alamb](https://github.com/alamb))
+- Update instructions on how to join the Slack channel [\#2219](https://github.com/apache/arrow-rs/pull/2219) ([HaoYang670](https://github.com/HaoYang670))
+- Add Builder style config objects for object\_store [\#2204](https://github.com/apache/arrow-rs/pull/2204) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([alamb](https://github.com/alamb))
+- Ignore broken symlinks for LocalFileSystem object store [\#2195](https://github.com/apache/arrow-rs/pull/2195) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([jccampagne](https://github.com/jccampagne))
+- Change CI names to match crate names [\#2189](https://github.com/apache/arrow-rs/pull/2189) ([alamb](https://github.com/alamb))
+- Split most arrow specific CI checks into their own workflows \(reduce common CI time to 21 minutes\) [\#2168](https://github.com/apache/arrow-rs/pull/2168) ([alamb](https://github.com/alamb))
+- Remove another attempt to cache target directory in action.yaml [\#2167](https://github.com/apache/arrow-rs/pull/2167) ([alamb](https://github.com/alamb))
+- Run actions on push to master, pull requests [\#2166](https://github.com/apache/arrow-rs/pull/2166) ([alamb](https://github.com/alamb))
+- Break parquet\_derive and arrow\_flight tests into their own workflows [\#2165](https://github.com/apache/arrow-rs/pull/2165) ([alamb](https://github.com/alamb))
+- Only run integration tests when `arrow` changes [\#2152](https://github.com/apache/arrow-rs/pull/2152) ([alamb](https://github.com/alamb))
+- Break out docs CI job to its own github action [\#2151](https://github.com/apache/arrow-rs/pull/2151) ([alamb](https://github.com/alamb))
+- Do not pretend to cache rust build artifacts, speed up CI by ~20% [\#2150](https://github.com/apache/arrow-rs/pull/2150) ([alamb](https://github.com/alamb))
+- Port `object_store` integration tests, use github actions [\#2148](https://github.com/apache/arrow-rs/pull/2148) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([alamb](https://github.com/alamb))
+- Port Add stream upload \(multi-part upload\)  [\#2147](https://github.com/apache/arrow-rs/pull/2147) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([alamb](https://github.com/alamb))
+- Increase upper wait time to reduce flakiness of object store test [\#2142](https://github.com/apache/arrow-rs/pull/2142) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([viirya](https://github.com/viirya))
+
+\* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*
diff --git a/object_store/CHANGELOG.md b/object_store/CHANGELOG.md
index 93faa678ffa8..db2009b443e9 100644
--- a/object_store/CHANGELOG.md
+++ b/object_store/CHANGELOG.md
@@ -19,52 +19,61 @@
 
 # Changelog
 
-## [object_store_0.4.0](https://github.com/apache/arrow-rs/tree/object_store_0.4.0) (2022-08-10)
+## [object_store_0.9.0](https://github.com/apache/arrow-rs/tree/object_store_0.9.0) (2024-01-05)
 
-[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.3.0...object_store_0.4.0)
+[Full Changelog](https://github.com/apache/arrow-rs/compare/object_store_0.8.0...object_store_0.9.0)
+
+**Breaking changes:**
+
+- Remove deprecated try\_with\_option methods [\#5237](https://github.com/apache/arrow-rs/pull/5237) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- object\_store: full HTTP range support [\#5222](https://github.com/apache/arrow-rs/pull/5222) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([clbarnes](https://github.com/clbarnes))
+- feat\(object\_store\): use http1 by default [\#5204](https://github.com/apache/arrow-rs/pull/5204) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([wjones127](https://github.com/wjones127))
+- refactor: change `object_store` CA handling [\#5056](https://github.com/apache/arrow-rs/pull/5056) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([crepererum](https://github.com/crepererum))
 
 **Implemented enhancements:**
 
-- Relax Path Validation to Allow Any Percent-Encoded Sequence [\#2355](https://github.com/apache/arrow-rs/issues/2355) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
-- Support get\_multi\_ranges in ObjectStore [\#2293](https://github.com/apache/arrow-rs/issues/2293)
-- object\_store: Create explicit test for symlinks [\#2206](https://github.com/apache/arrow-rs/issues/2206) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
-- object\_store: Make builder style configuration for object stores [\#2203](https://github.com/apache/arrow-rs/issues/2203) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
-- object\_store: Add example in the main documentation readme [\#2202](https://github.com/apache/arrow-rs/issues/2202) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Azure Signed URL Support [\#5232](https://github.com/apache/arrow-rs/issues/5232) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- \[object-store\] Make aws region optional. [\#5211](https://github.com/apache/arrow-rs/issues/5211) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- \[object\_store,gcp\] Document GoogleCloudStorage Default Credentials [\#5187](https://github.com/apache/arrow-rs/issues/5187) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Support S3 Express One Zone [\#5140](https://github.com/apache/arrow-rs/issues/5140) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- `object_store`: Allow 403 Forbidden for `copy_if_not_exists` S3 status code [\#5132](https://github.com/apache/arrow-rs/issues/5132) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Add `copy_if_not_exists` support for AmazonS3 via DynamoDB Lock Support [\#4880](https://github.com/apache/arrow-rs/issues/4880) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- object\_store: native certs, w/o webpki-roots [\#4870](https://github.com/apache/arrow-rs/issues/4870)
+- object\_store: range request with suffix [\#4611](https://github.com/apache/arrow-rs/issues/4611)
 
 **Fixed bugs:**
 
-- Azure/S3 Storage Fails to Copy Blob with URL-encoded Path [\#2353](https://github.com/apache/arrow-rs/issues/2353) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
-- Accessing a file with a percent-encoded name on the filesystem with ObjectStore LocalFileSystem [\#2349](https://github.com/apache/arrow-rs/issues/2349) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- ObjectStore::get\_opts Incorrectly Returns Response Size not Object Size [\#5272](https://github.com/apache/arrow-rs/issues/5272) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Single object store has limited throughput on GCS [\#5194](https://github.com/apache/arrow-rs/issues/5194) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- local::tests::invalid\_path fails during object store release verification [\#5035](https://github.com/apache/arrow-rs/issues/5035) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
+- Object Store Doctest Failure with Default Features [\#5025](https://github.com/apache/arrow-rs/issues/5025) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)]
 
 **Documentation updates:**
 
-- Improve `object_store crate` documentation [\#2260](https://github.com/apache/arrow-rs/pull/2260) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([alamb](https://github.com/alamb))
+- Document default value of InstanceCredentialProvider [\#5188](https://github.com/apache/arrow-rs/pull/5188) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([justinabrahms](https://github.com/justinabrahms))
 
 **Merged pull requests:**
 
-- Canonicalize filesystem paths in user-facing APIs \(\#2370\) [\#2371](https://github.com/apache/arrow-rs/pull/2371) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
-- Fix object\_store lint [\#2367](https://github.com/apache/arrow-rs/pull/2367) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
-- Relax path validation \(\#2355\) [\#2356](https://github.com/apache/arrow-rs/pull/2356) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
-- Fix Copy from percent-encoded path \(\#2353\) [\#2354](https://github.com/apache/arrow-rs/pull/2354) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
-- Add ObjectStore::get\_ranges \(\#2293\) [\#2336](https://github.com/apache/arrow-rs/pull/2336) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
-- Remove vestigal ` object_store/.circleci/` [\#2337](https://github.com/apache/arrow-rs/pull/2337) ([alamb](https://github.com/alamb))
-- Handle symlinks in LocalFileSystem \(\#2206\) [\#2269](https://github.com/apache/arrow-rs/pull/2269) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
-- Retry GCP requests on server error [\#2243](https://github.com/apache/arrow-rs/pull/2243) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
-- Add LimitStore \(\#2175\) [\#2242](https://github.com/apache/arrow-rs/pull/2242) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
-- Only trigger `arrow` CI on changes to arrow [\#2227](https://github.com/apache/arrow-rs/pull/2227) ([alamb](https://github.com/alamb))
-- Update instructions on how to join the Slack channel [\#2219](https://github.com/apache/arrow-rs/pull/2219) ([HaoYang670](https://github.com/HaoYang670))
-- Add Builder style config objects for object\_store [\#2204](https://github.com/apache/arrow-rs/pull/2204) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([alamb](https://github.com/alamb))
-- Ignore broken symlinks for LocalFileSystem object store [\#2195](https://github.com/apache/arrow-rs/pull/2195) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([jccampagne](https://github.com/jccampagne))
-- Change CI names to match crate names [\#2189](https://github.com/apache/arrow-rs/pull/2189) ([alamb](https://github.com/alamb))
-- Split most arrow specific CI checks into their own workflows \(reduce common CI time to 21 minutes\) [\#2168](https://github.com/apache/arrow-rs/pull/2168) ([alamb](https://github.com/alamb))
-- Remove another attempt to cache target directory in action.yaml [\#2167](https://github.com/apache/arrow-rs/pull/2167) ([alamb](https://github.com/alamb))
-- Run actions on push to master, pull requests [\#2166](https://github.com/apache/arrow-rs/pull/2166) ([alamb](https://github.com/alamb))
-- Break parquet\_derive and arrow\_flight tests into their own workflows [\#2165](https://github.com/apache/arrow-rs/pull/2165) ([alamb](https://github.com/alamb))
-- Only run integration tests when `arrow` changes [\#2152](https://github.com/apache/arrow-rs/pull/2152) ([alamb](https://github.com/alamb))
-- Break out docs CI job to its own github action [\#2151](https://github.com/apache/arrow-rs/pull/2151) ([alamb](https://github.com/alamb))
-- Do not pretend to cache rust build artifacts, speed up CI by ~20% [\#2150](https://github.com/apache/arrow-rs/pull/2150) ([alamb](https://github.com/alamb))
-- Port `object_store` integration tests, use github actions [\#2148](https://github.com/apache/arrow-rs/pull/2148) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([alamb](https://github.com/alamb))
-- Port Add stream upload \(multi-part upload\)  [\#2147](https://github.com/apache/arrow-rs/pull/2147) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([alamb](https://github.com/alamb))
-- Increase upper wait time to reduce flakyness of object store test [\#2142](https://github.com/apache/arrow-rs/pull/2142) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([viirya](https://github.com/viirya))
+- Retry Safe/Read-Only Requests on Timeout [\#5278](https://github.com/apache/arrow-rs/pull/5278) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Fix ObjectMeta::size for range requests \(\#5272\) [\#5276](https://github.com/apache/arrow-rs/pull/5276) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- docs\(object\_store\): Mention `with_allow_http` in docs of `with_endpoint` [\#5275](https://github.com/apache/arrow-rs/pull/5275) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([Xuanwo](https://github.com/Xuanwo))
+- Support S3 Express One Zone [\#5268](https://github.com/apache/arrow-rs/pull/5268) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- feat\(object\_store\): Azure url signing [\#5259](https://github.com/apache/arrow-rs/pull/5259) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([roeap](https://github.com/roeap))
+- DynamoDB ConditionalPut [\#5247](https://github.com/apache/arrow-rs/pull/5247) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Default AWS region to us-east-1 \(\#5211\) [\#5244](https://github.com/apache/arrow-rs/pull/5244) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- ci: Fail Miri CI on first failure [\#5243](https://github.com/apache/arrow-rs/pull/5243) ([Jefffrey](https://github.com/Jefffrey))
+- Bump actions/upload-pages-artifact from 2 to 3 [\#5229](https://github.com/apache/arrow-rs/pull/5229) ([dependabot[bot]](https://github.com/apps/dependabot))
+- Bump actions/setup-python from 4 to 5 [\#5175](https://github.com/apache/arrow-rs/pull/5175) ([dependabot[bot]](https://github.com/apps/dependabot))
+- fix: ensure take\_fixed\_size\_list can handle null indices [\#5170](https://github.com/apache/arrow-rs/pull/5170) ([westonpace](https://github.com/westonpace))
+- Bump actions/labeler from 4.3.0 to 5.0.0 [\#5167](https://github.com/apache/arrow-rs/pull/5167) ([dependabot[bot]](https://github.com/apps/dependabot))
+- object\_store: fix failing doctest with default features [\#5161](https://github.com/apache/arrow-rs/pull/5161) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([Jefffrey](https://github.com/Jefffrey))
+- Update rustls-pemfile requirement from 1.0 to 2.0 in /object\_store [\#5155](https://github.com/apache/arrow-rs/pull/5155) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Allow 403 for overwrite prevention [\#5134](https://github.com/apache/arrow-rs/pull/5134) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([emcake](https://github.com/emcake))
+- Fix ObjectStore.LocalFileSystem.put\_opts for blobfuse [\#5094](https://github.com/apache/arrow-rs/pull/5094) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([RobinLin666](https://github.com/RobinLin666))
+- Update itertools requirement from 0.11.0 to 0.12.0 in /object\_store [\#5077](https://github.com/apache/arrow-rs/pull/5077) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([dependabot[bot]](https://github.com/apps/dependabot))
+- Add a PR under "Breaking changes" in the object\_store 0.8.0 changelog [\#5063](https://github.com/apache/arrow-rs/pull/5063) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([carols10cents](https://github.com/carols10cents))
+- Prepare arrow 49.0.0 [\#5054](https://github.com/apache/arrow-rs/pull/5054) ([tustvold](https://github.com/tustvold))
+- Fix invalid\_path test [\#5026](https://github.com/apache/arrow-rs/pull/5026) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
+- Implement `copy_if_not_exist` for `AmazonS3` using DynamoDB \(\#4880\) [\#4918](https://github.com/apache/arrow-rs/pull/4918) [[object-store](https://github.com/apache/arrow-rs/labels/object-store)] ([tustvold](https://github.com/tustvold))
 
 \* *This Changelog was automatically generated by [github_changelog_generator](https://github.com/github-changelog-generator/github-changelog-generator)*
diff --git a/object_store/CONTRIBUTING.md b/object_store/CONTRIBUTING.md
index 7c2832cf7ef1..4b0ef1f0e696 100644
--- a/object_store/CONTRIBUTING.md
+++ b/object_store/CONTRIBUTING.md
@@ -39,7 +39,9 @@ To test the S3 integration against [localstack](https://localstack.cloud/)
 First start up a container running localstack
 
 ```
-$ podman run --rm -it -p 4566:4566 -p 4510-4559:4510-4559 localstack/localstack
+$ LOCALSTACK_VERSION=sha256:a0b79cb2430f1818de2c66ce89d41bba40f5a1823410f5a7eaf3494b692eed97
+$ podman run -d -p 4566:4566 localstack/localstack@$LOCALSTACK_VERSION
+$ podman run -d -p 1338:1338 amazon/amazon-ec2-metadata-mock:v1.9.2 --imdsv2
 ```
 
 Setup environment
@@ -49,8 +51,9 @@ export TEST_INTEGRATION=1
 export AWS_DEFAULT_REGION=us-east-1
 export AWS_ACCESS_KEY_ID=test
 export AWS_SECRET_ACCESS_KEY=test
-export AWS_ENDPOINT=http://127.0.0.1:4566
-export OBJECT_STORE_BUCKET=test-bucket
+export AWS_ENDPOINT=http://localhost:4566
+export AWS_ALLOW_HTTP=true
+export AWS_BUCKET_NAME=test-bucket
 ```
 
 Create a bucket using the AWS CLI
@@ -59,12 +62,45 @@ Create a bucket using the AWS CLI
 podman run --net=host --env-host amazon/aws-cli --endpoint-url=http://localhost:4566 s3 mb s3://test-bucket
 ```
 
+Or directly with:
+
+```
+aws s3 mb s3://test-bucket --endpoint-url=http://localhost:4566
+aws --endpoint-url=http://localhost:4566 dynamodb create-table --table-name test-table --key-schema AttributeName=path,KeyType=HASH AttributeName=etag,KeyType=RANGE --attribute-definitions AttributeName=path,AttributeType=S AttributeName=etag,AttributeType=S --provisioned-throughput ReadCapacityUnits=5,WriteCapacityUnits=5
+```
+
 Run tests
 
 ```
 $ cargo test --features aws
 ```
 
+#### Encryption tests
+
+To create an encryption key for the tests, you can run the following command:
+
+```
+export AWS_SSE_KMS_KEY_ID=$(aws --endpoint-url=http://localhost:4566 \
+  kms create-key --description "test key" |
+  jq -r '.KeyMetadata.KeyId')
+```
+
+To run integration tests with encryption, you can set the following environment variables:
+
+```
+export AWS_SERVER_SIDE_ENCRYPTION=aws:kms
+export AWS_SSE_BUCKET_KEY=false
+cargo test --features aws
+```
+
+As well as:
+
+```
+unset AWS_SSE_BUCKET_KEY
+export AWS_SERVER_SIDE_ENCRYPTION=aws:kms:dsse
+cargo test --features aws
+```
+
 ### Azure
 
 To test the Azure integration
@@ -84,8 +120,13 @@ $ podman run --net=host mcr.microsoft.com/azure-cli az storage container create
 
 Run tests
 
-```
-$ cargo test --features azure
+```shell
+AZURE_USE_EMULATOR=1 \
+TEST_INTEGRATION=1 \
+OBJECT_STORE_BUCKET=test-bucket \
+AZURE_STORAGE_ACCOUNT=devstoreaccount1 \
+AZURE_STORAGE_ACCESS_KEY=Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw== \
+cargo test --features azure
 ```
 
 ### GCP
@@ -95,13 +136,13 @@ To test the GCS integration, we use [Fake GCS Server](https://github.com/fsouza/
 Startup the fake server:
 
 ```shell
-docker run -p 4443:4443 fsouza/fake-gcs-server
+docker run -p 4443:4443 tustvold/fake-gcs-server -scheme http
 ```
 
 Configure the account:
 ```shell
-curl --insecure -v -X POST --data-binary '{"name":"test-bucket"}' -H "Content-Type: application/json" "https://localhost:4443/storage/v1/b"
-echo '{"gcs_base_url": "https://localhost:4443", "disable_oauth": true, "client_email": "", "private_key": ""}' > /tmp/gcs.json
+curl -v -X POST --data-binary '{"name":"test-bucket"}' -H "Content-Type: application/json" "http://localhost:4443/storage/v1/b"
+echo '{"gcs_base_url": "http://localhost:4443", "disable_oauth": true, "client_email": "", "private_key": ""}' > /tmp/gcs.json
 ```
 
 Now run the tests:
diff --git a/object_store/Cargo.toml b/object_store/Cargo.toml
index ffb65aaa7ee7..6b38a8d21ffd 100644
--- a/object_store/Cargo.toml
+++ b/object_store/Cargo.toml
@@ -17,65 +17,62 @@
 
 [package]
 name = "object_store"
-version = "0.4.0"
+version = "0.9.0"
 edition = "2021"
 license = "MIT/Apache-2.0"
 readme = "README.md"
 description = "A generic object store interface for uniformly interacting with AWS S3, Google Cloud Storage, Azure Blob Storage and local files."
-keywords = [
-    "object",
-    "storage",
-    "cloud",
-]
-repository = "https://github.com/apache/arrow-rs"
+keywords = ["object", "storage", "cloud"]
+repository = "https://github.com/apache/arrow-rs/tree/master/object_store"
+rust-version = "1.62.1"
 
 [package.metadata.docs.rs]
 all-features = true
 
 [dependencies] # In alphabetical order
 async-trait = "0.1.53"
-# Microsoft Azure Blob storage integration
-azure_core = { version = "0.2", optional = true, default-features = false, features = ["enable_reqwest_rustls"] }
-azure_storage = { version = "0.2", optional = true, default-features = false, features = ["account"] }
-azure_storage_blobs = { version = "0.2", optional = true, default-features = false, features = ["enable_reqwest_rustls"] }
 bytes = "1.0"
-chrono = { version = "0.4", default-features = false, features = ["clock"] }
-# Google Cloud Storage integration
+chrono = { version = "0.4.31", default-features = false, features = ["clock"] }
 futures = "0.3"
-serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
-serde_json = { version = "1.0", default-features = false, optional = true }
-quick-xml = { version = "0.23.0", features = ["serialize"], optional = true }
-rustls-pemfile = { version = "1.0", default-features = false, optional = true }
-ring = { version = "0.16", default-features = false, features = ["std"], optional = true }
-base64 = { version = "0.13", default-features = false, optional = true }
-rand = { version = "0.8", default-features = false, features = ["std", "std_rng"], optional = true }
-# for rusoto
-hyper = { version = "0.14", optional = true, default-features = false }
-# for rusoto
-hyper-rustls = { version = "0.23.0", optional = true, default-features = false, features = ["webpki-tokio", "http1", "http2", "tls12"] }
-itertools = "0.10.1"
+humantime = "2.1"
+itertools = "0.12.0"
+parking_lot = { version = "0.12" }
 percent-encoding = "2.1"
-# rusoto crates are for Amazon S3 integration
-rusoto_core = { version = "0.48.0", optional = true, default-features = false, features = ["rustls"] }
-rusoto_credential = { version = "0.48.0", optional = true, default-features = false }
-rusoto_s3 = { version = "0.48.0", optional = true, default-features = false, features = ["rustls"] }
-rusoto_sts = { version = "0.48.0", optional = true, default-features = false, features = ["rustls"] }
 snafu = "0.7"
-tokio = { version = "1.18", features = ["sync", "macros", "parking_lot", "rt-multi-thread", "time", "io-util"] }
 tracing = { version = "0.1" }
-reqwest = { version = "0.11", default-features = false, features = ["rustls-tls"], optional = true }
-parking_lot = { version = "0.12" }
-# Filesystem integration
 url = "2.2"
 walkdir = "2"
 
+# Cloud storage support
+base64 = { version = "0.21", default-features = false, features = ["std"], optional = true }
+hyper = { version = "0.14", default-features = false, optional = true }
+quick-xml = { version = "0.31.0", features = ["serialize", "overlapped-lists"], optional = true }
+serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
+serde_json = { version = "1.0", default-features = false, optional = true }
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"], optional = true }
+reqwest = { version = "0.11", default-features = false, features = ["rustls-tls-native-roots"], optional = true }
+ring = { version = "0.17", default-features = false, features = ["std"], optional = true }
+rustls-pemfile = { version = "2.0", default-features = false, features = ["std"], optional = true }
+tokio = { version = "1.25.0", features = ["sync", "macros", "rt", "time", "io-util"] }
+md-5 = { version = "0.10.6", default-features = false, optional = true }
+
+[target.'cfg(target_family="unix")'.dev-dependencies]
+nix = { version = "0.28.0", features = ["fs"] }
+
 [features]
-azure = ["azure_core", "azure_storage_blobs", "azure_storage", "reqwest"]
-azure_test = ["azure", "azure_core/azurite_workaround", "azure_storage/azurite_workaround", "azure_storage_blobs/azurite_workaround"]
-gcp = ["serde", "serde_json", "quick-xml", "reqwest", "reqwest/json", "reqwest/stream", "chrono/serde", "rustls-pemfile", "base64", "rand", "ring"]
-aws = ["rusoto_core", "rusoto_credential", "rusoto_s3", "rusoto_sts", "hyper", "hyper-rustls"]
+cloud = ["serde", "serde_json", "quick-xml", "hyper", "reqwest", "reqwest/json", "reqwest/stream", "chrono/serde", "base64", "rand", "ring"]
+azure = ["cloud"]
+gcp = ["cloud", "rustls-pemfile"]
+aws = ["cloud", "md-5"]
+http = ["cloud"]
+tls-webpki-roots = ["reqwest?/rustls-tls-webpki-roots"]
 
 [dev-dependencies] # In alphabetical order
-dotenv = "0.15.0"
+futures-test = "0.3"
+hyper = { version = "0.14.24", features = ["server"] }
+rand = "0.8"
 tempfile = "3.1.0"
-futures-test = "0.3"
\ No newline at end of file
+
+[[test]]
+name = "get_range_file"
+path = "tests/get_range_file.rs"
diff --git a/object_store/README.md b/object_store/README.md
index fd10414a9285..1799bf8b8816 100644
--- a/object_store/README.md
+++ b/object_store/README.md
@@ -20,7 +20,7 @@
 # Rust Object Store
 
 A focused, easy to use, idiomatic, high performance, `async` object
-store library interacting with object stores.
+store library for interacting with object stores.
 
 Using this crate, the same binary and code can easily run in multiple
 clouds and local test environments, via a simple runtime configuration
@@ -31,9 +31,17 @@ change. Supported object stores include:
 * [Google Cloud Storage](https://cloud.google.com/storage)
 * Local files
 * Memory
+* [HTTP/WebDAV Storage](https://datatracker.ietf.org/doc/html/rfc2518)
 * Custom implementations
 
-
-Originally developed for [InfluxDB IOx](https://github.com/influxdata/influxdb_iox/) and later split out and donated to [Apache Arrow](https://arrow.apache.org/).
+Originally developed by [InfluxData](https://www.influxdata.com/) and later donated to [Apache Arrow](https://arrow.apache.org/).
 
 See [docs.rs](https://docs.rs/object_store) for usage instructions
+
+## Support for `wasm32-unknown-unknown` target
+
+It's possible to build `object_store` for the `wasm32-unknown-unknown` target, however the cloud storage features `aws`, `azure`, `gcp`, and `http` are not supported.
+
+```
+cargo build -p object_store --target wasm32-unknown-unknown
+```
\ No newline at end of file
diff --git a/object_store/dev/release/release-tarball.sh b/object_store/dev/release/release-tarball.sh
index 75ff886c6b1e..958118639143 100755
--- a/object_store/dev/release/release-tarball.sh
+++ b/object_store/dev/release/release-tarball.sh
@@ -74,3 +74,6 @@ rm -rf ${tmp_dir}
 echo "Success!"
 echo "The release is available here:"
 echo "  https://dist.apache.org/repos/dist/release/arrow/${release_version}"
+
+echo "Clean up old versions from svn"
+"${SOURCE_TOP_DIR}"/dev/release/remove-old-releases.sh
diff --git a/object_store/dev/release/remove-old-releases.sh b/object_store/dev/release/remove-old-releases.sh
new file mode 100755
index 000000000000..c8bd8b748396
--- /dev/null
+++ b/object_store/dev/release/remove-old-releases.sh
@@ -0,0 +1,45 @@
+#!/bin/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.
+#
+
+# This script removes all but the most recent versions of arrow-rs
+# from svn
+#
+# The older versions are in SVN history as well as available on the
+# archive page https://archive.apache.org/dist/
+#
+# See
+# https://infra.apache.org/release-download-pages.html
+
+set -e
+set -u
+
+svn_base="https://dist.apache.org/repos/dist/release/arrow"
+
+echo "Remove all but the most recent version"
+old_releases=$(
+  svn ls ${svn_base} | \
+  grep -E '^arrow-object-store-rs-[0-9\.]+' | \
+  sort --version-sort --reverse | \
+  tail -n +2
+)
+for old_release_version in $old_releases; do
+  echo "Remove old release ${old_release_version}"
+  svn delete -m "Removing ${old_release_version}" ${svn_base}/${old_release_version}
+done
diff --git a/object_store/dev/release/update_change_log.sh b/object_store/dev/release/update_change_log.sh
index ebd50df7ffc0..a083f6125b18 100755
--- a/object_store/dev/release/update_change_log.sh
+++ b/object_store/dev/release/update_change_log.sh
@@ -29,8 +29,8 @@
 
 set -e
 
-SINCE_TAG="object_store_0.3.0"
-FUTURE_RELEASE="object_store_0.4.0"
+SINCE_TAG="object_store_0.8.0"
+FUTURE_RELEASE="object_store_0.9.0"
 
 SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
 SOURCE_TOP_DIR="$(cd "${SOURCE_DIR}/../../" && pwd)"
@@ -49,8 +49,8 @@ docker run -it --rm -e CHANGELOG_GITHUB_TOKEN="$CHANGELOG_GITHUB_TOKEN" -v "$(pw
     --cache-file=.githubchangeloggenerator.cache \
     --cache-log=.githubchangeloggenerator.cache.log \
     --http-cache \
-    --max-issues=300 \
-    --exclude-tags-regex "^\d+\.\d+\.\d+$" \
+    --max-issues=600 \
+    --exclude-tags-regex "(^\d+\.\d+\.\d+$)|(rc)" \
     --since-tag ${SINCE_TAG} \
     --future-release ${FUTURE_RELEASE}
 
diff --git a/object_store/dev/release/verify-release-candidate.sh b/object_store/dev/release/verify-release-candidate.sh
index 06a5d8bcb838..b24bd8fbb743 100755
--- a/object_store/dev/release/verify-release-candidate.sh
+++ b/object_store/dev/release/verify-release-candidate.sh
@@ -103,7 +103,7 @@ test_source_distribution() {
 
   # build and test rust
   cargo build
-  cargo test --all
+  cargo test --all --all-features
 
   # verify that the crate can be published to crates.io
   cargo publish --dry-run
diff --git a/object_store/src/aws.rs b/object_store/src/aws.rs
deleted file mode 100644
index bcb294c00373..000000000000
--- a/object_store/src/aws.rs
+++ /dev/null
@@ -1,1343 +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.
-
-//! An object store implementation for S3
-//!
-//! ## Multi-part uploads
-//!
-//! Multi-part uploads can be initiated with the [ObjectStore::put_multipart] method.
-//! Data passed to the writer is automatically buffered to meet the minimum size
-//! requirements for a part. Multiple parts are uploaded concurrently.
-//!
-//! If the writer fails for any reason, you may have parts uploaded to AWS but not
-//! used that you may be charged for. Use the [ObjectStore::abort_multipart] method
-//! to abort the upload and drop those unneeded parts. In addition, you may wish to
-//! consider implementing [automatic cleanup] of unused parts that are older than one
-//! week.
-//!
-//! [automatic cleanup]: https://aws.amazon.com/blogs/aws/s3-lifecycle-management-update-support-for-multipart-uploads-and-delete-markers/
-use crate::multipart::{CloudMultiPartUpload, CloudMultiPartUploadImpl, UploadPart};
-use crate::util::format_http_range;
-use crate::MultipartId;
-use crate::{
-    collect_bytes,
-    path::{Path, DELIMITER},
-    util::format_prefix,
-    GetResult, ListResult, ObjectMeta, ObjectStore, Result,
-};
-use async_trait::async_trait;
-use bytes::Bytes;
-use chrono::{DateTime, Utc};
-use futures::future::BoxFuture;
-use futures::{
-    stream::{self, BoxStream},
-    Future, Stream, StreamExt, TryStreamExt,
-};
-use hyper::client::Builder as HyperBuilder;
-use percent_encoding::{percent_encode, AsciiSet, NON_ALPHANUMERIC};
-use rusoto_core::ByteStream;
-use rusoto_credential::{InstanceMetadataProvider, StaticProvider};
-use rusoto_s3::S3;
-use rusoto_sts::WebIdentityProvider;
-use snafu::{OptionExt, ResultExt, Snafu};
-use std::io;
-use std::ops::Range;
-use std::{
-    convert::TryFrom, fmt, num::NonZeroUsize, ops::Deref, sync::Arc, time::Duration,
-};
-use tokio::io::AsyncWrite;
-use tokio::sync::{OwnedSemaphorePermit, Semaphore};
-use tracing::{debug, warn};
-
-// Do not URI-encode any of the unreserved characters that RFC 3986 defines:
-// A-Z, a-z, 0-9, hyphen ( - ), underscore ( _ ), period ( . ), and tilde ( ~ ).
-const STRICT_ENCODE_SET: AsciiSet = NON_ALPHANUMERIC
-    .remove(b'-')
-    .remove(b'.')
-    .remove(b'_')
-    .remove(b'~');
-
-/// This struct is used to maintain the URI path encoding
-const STRICT_PATH_ENCODE_SET: AsciiSet = STRICT_ENCODE_SET.remove(b'/');
-
-/// The maximum number of times a request will be retried in the case of an AWS server error
-pub const MAX_NUM_RETRIES: u32 = 3;
-
-/// A specialized `Error` for object store-related errors
-#[derive(Debug, Snafu)]
-#[allow(missing_docs)]
-enum Error {
-    #[snafu(display(
-        "Expected streamed data to have length {}, got {}",
-        expected,
-        actual
-    ))]
-    DataDoesNotMatchLength { expected: usize, actual: usize },
-
-    #[snafu(display(
-        "Did not receive any data. Bucket: {}, Location: {}",
-        bucket,
-        path
-    ))]
-    NoData { bucket: String, path: String },
-
-    #[snafu(display(
-        "Unable to DELETE data. Bucket: {}, Location: {}, Error: {} ({:?})",
-        bucket,
-        path,
-        source,
-        source,
-    ))]
-    UnableToDeleteData {
-        source: rusoto_core::RusotoError<rusoto_s3::DeleteObjectError>,
-        bucket: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to GET data. Bucket: {}, Location: {}, Error: {} ({:?})",
-        bucket,
-        path,
-        source,
-        source,
-    ))]
-    UnableToGetData {
-        source: rusoto_core::RusotoError<rusoto_s3::GetObjectError>,
-        bucket: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to HEAD data. Bucket: {}, Location: {}, Error: {} ({:?})",
-        bucket,
-        path,
-        source,
-        source,
-    ))]
-    UnableToHeadData {
-        source: rusoto_core::RusotoError<rusoto_s3::HeadObjectError>,
-        bucket: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to GET part of the data. Bucket: {}, Location: {}, Error: {} ({:?})",
-        bucket,
-        path,
-        source,
-        source,
-    ))]
-    UnableToGetPieceOfData {
-        source: std::io::Error,
-        bucket: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to PUT data. Bucket: {}, Location: {}, Error: {} ({:?})",
-        bucket,
-        path,
-        source,
-        source,
-    ))]
-    UnableToPutData {
-        source: rusoto_core::RusotoError<rusoto_s3::PutObjectError>,
-        bucket: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to upload data. Bucket: {}, Location: {}, Error: {} ({:?})",
-        bucket,
-        path,
-        source,
-        source,
-    ))]
-    UnableToUploadData {
-        source: rusoto_core::RusotoError<rusoto_s3::CreateMultipartUploadError>,
-        bucket: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to cleanup multipart data. Bucket: {}, Location: {}, Error: {} ({:?})",
-        bucket,
-        path,
-        source,
-        source,
-    ))]
-    UnableToCleanupMultipartData {
-        source: rusoto_core::RusotoError<rusoto_s3::AbortMultipartUploadError>,
-        bucket: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to list data. Bucket: {}, Error: {} ({:?})",
-        bucket,
-        source,
-        source,
-    ))]
-    UnableToListData {
-        source: rusoto_core::RusotoError<rusoto_s3::ListObjectsV2Error>,
-        bucket: String,
-    },
-
-    #[snafu(display(
-        "Unable to copy object. Bucket: {}, From: {}, To: {}, Error: {}",
-        bucket,
-        from,
-        to,
-        source,
-    ))]
-    UnableToCopyObject {
-        source: rusoto_core::RusotoError<rusoto_s3::CopyObjectError>,
-        bucket: String,
-        from: String,
-        to: String,
-    },
-
-    #[snafu(display(
-        "Unable to parse last modified date. Bucket: {}, Error: {} ({:?})",
-        bucket,
-        source,
-        source,
-    ))]
-    UnableToParseLastModified {
-        source: chrono::ParseError,
-        bucket: String,
-    },
-
-    #[snafu(display(
-        "Unable to buffer data into temporary file, Error: {} ({:?})",
-        source,
-        source,
-    ))]
-    UnableToBufferStream { source: std::io::Error },
-
-    #[snafu(display(
-        "Could not parse `{}` as an AWS region. Regions should look like `us-east-2`. {} ({:?})",
-        region,
-        source,
-        source,
-    ))]
-    InvalidRegion {
-        region: String,
-        source: rusoto_core::region::ParseRegionError,
-    },
-
-    #[snafu(display(
-        "Region must be specified for AWS S3. Regions should look like `us-east-2`"
-    ))]
-    MissingRegion {},
-
-    #[snafu(display("Missing bucket name"))]
-    MissingBucketName {},
-
-    #[snafu(display("Missing aws-access-key"))]
-    MissingAccessKey,
-
-    #[snafu(display("Missing aws-secret-access-key"))]
-    MissingSecretAccessKey,
-
-    NotFound {
-        path: String,
-        source: Box<dyn std::error::Error + Send + Sync + 'static>,
-    },
-}
-
-impl From<Error> for super::Error {
-    fn from(source: Error) -> Self {
-        match source {
-            Error::NotFound { path, source } => Self::NotFound { path, source },
-            _ => Self::Generic {
-                store: "S3",
-                source: Box::new(source),
-            },
-        }
-    }
-}
-
-/// Interface for [Amazon S3](https://aws.amazon.com/s3/).
-pub struct AmazonS3 {
-    /// S3 client w/o any connection limit.
-    ///
-    /// You should normally use [`Self::client`] instead.
-    client_unrestricted: rusoto_s3::S3Client,
-
-    /// Semaphore that limits the usage of [`client_unrestricted`](Self::client_unrestricted).
-    connection_semaphore: Arc<Semaphore>,
-
-    /// Bucket name used by this object store client.
-    bucket_name: String,
-}
-
-impl fmt::Debug for AmazonS3 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("AmazonS3")
-            .field("client", &"rusoto_s3::S3Client")
-            .field("bucket_name", &self.bucket_name)
-            .finish()
-    }
-}
-
-impl fmt::Display for AmazonS3 {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "AmazonS3({})", self.bucket_name)
-    }
-}
-
-#[async_trait]
-impl ObjectStore for AmazonS3 {
-    async fn put(&self, location: &Path, bytes: Bytes) -> Result<()> {
-        let bucket_name = self.bucket_name.clone();
-        let request_factory = move || {
-            let bytes = bytes.clone();
-
-            let length = bytes.len();
-            let stream_data = Ok(bytes);
-            let stream = futures::stream::once(async move { stream_data });
-            let byte_stream = ByteStream::new_with_size(stream, length);
-
-            rusoto_s3::PutObjectRequest {
-                bucket: bucket_name.clone(),
-                key: location.to_string(),
-                body: Some(byte_stream),
-                ..Default::default()
-            }
-        };
-
-        let s3 = self.client().await;
-
-        s3_request(move || {
-            let (s3, request_factory) = (s3.clone(), request_factory.clone());
-
-            async move { s3.put_object(request_factory()).await }
-        })
-        .await
-        .context(UnableToPutDataSnafu {
-            bucket: &self.bucket_name,
-            path: location.as_ref(),
-        })?;
-
-        Ok(())
-    }
-
-    async fn put_multipart(
-        &self,
-        location: &Path,
-    ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
-        let bucket_name = self.bucket_name.clone();
-
-        let request_factory = move || rusoto_s3::CreateMultipartUploadRequest {
-            bucket: bucket_name.clone(),
-            key: location.to_string(),
-            ..Default::default()
-        };
-
-        let s3 = self.client().await;
-
-        let data = s3_request(move || {
-            let (s3, request_factory) = (s3.clone(), request_factory.clone());
-
-            async move { s3.create_multipart_upload(request_factory()).await }
-        })
-        .await
-        .context(UnableToUploadDataSnafu {
-            bucket: &self.bucket_name,
-            path: location.as_ref(),
-        })?;
-
-        let upload_id = data.upload_id.unwrap();
-
-        let inner = S3MultiPartUpload {
-            upload_id: upload_id.clone(),
-            bucket: self.bucket_name.clone(),
-            key: location.to_string(),
-            client_unrestricted: self.client_unrestricted.clone(),
-            connection_semaphore: Arc::clone(&self.connection_semaphore),
-        };
-
-        Ok((upload_id, Box::new(CloudMultiPartUpload::new(inner, 8))))
-    }
-
-    async fn abort_multipart(
-        &self,
-        location: &Path,
-        multipart_id: &MultipartId,
-    ) -> Result<()> {
-        let request_factory = move || rusoto_s3::AbortMultipartUploadRequest {
-            bucket: self.bucket_name.clone(),
-            key: location.to_string(),
-            upload_id: multipart_id.to_string(),
-            ..Default::default()
-        };
-
-        let s3 = self.client().await;
-        s3_request(move || {
-            let (s3, request_factory) = (s3.clone(), request_factory);
-
-            async move { s3.abort_multipart_upload(request_factory()).await }
-        })
-        .await
-        .context(UnableToCleanupMultipartDataSnafu {
-            bucket: &self.bucket_name,
-            path: location.as_ref(),
-        })?;
-
-        Ok(())
-    }
-
-    async fn get(&self, location: &Path) -> Result<GetResult> {
-        Ok(GetResult::Stream(
-            self.get_object(location, None).await?.boxed(),
-        ))
-    }
-
-    async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes> {
-        let size_hint = range.end - range.start;
-        let stream = self.get_object(location, Some(range)).await?;
-        collect_bytes(stream, Some(size_hint)).await
-    }
-
-    async fn head(&self, location: &Path) -> Result<ObjectMeta> {
-        let key = location.to_string();
-        let head_request = rusoto_s3::HeadObjectRequest {
-            bucket: self.bucket_name.clone(),
-            key: key.clone(),
-            ..Default::default()
-        };
-        let s = self
-            .client()
-            .await
-            .head_object(head_request)
-            .await
-            .map_err(|e| match e {
-                rusoto_core::RusotoError::Service(
-                    rusoto_s3::HeadObjectError::NoSuchKey(_),
-                ) => Error::NotFound {
-                    path: key.clone(),
-                    source: e.into(),
-                },
-                rusoto_core::RusotoError::Unknown(h) if h.status.as_u16() == 404 => {
-                    Error::NotFound {
-                        path: key.clone(),
-                        source: "resource not found".into(),
-                    }
-                }
-                _ => Error::UnableToHeadData {
-                    bucket: self.bucket_name.to_owned(),
-                    path: key.clone(),
-                    source: e,
-                },
-            })?;
-
-        // Note: GetObject and HeadObject return a different date format from ListObjects
-        //
-        // S3 List returns timestamps in the form
-        //     <LastModified>2013-09-17T18:07:53.000Z</LastModified>
-        // S3 GetObject returns timestamps in the form
-        //            Last-Modified: Sun, 1 Jan 2006 12:00:00 GMT
-        let last_modified = match s.last_modified {
-            Some(lm) => DateTime::parse_from_rfc2822(&lm)
-                .context(UnableToParseLastModifiedSnafu {
-                    bucket: &self.bucket_name,
-                })?
-                .with_timezone(&Utc),
-            None => Utc::now(),
-        };
-
-        Ok(ObjectMeta {
-            last_modified,
-            location: location.clone(),
-            size: usize::try_from(s.content_length.unwrap_or(0))
-                .expect("unsupported size on this platform"),
-        })
-    }
-
-    async fn delete(&self, location: &Path) -> Result<()> {
-        let bucket_name = self.bucket_name.clone();
-
-        let request_factory = move || rusoto_s3::DeleteObjectRequest {
-            bucket: bucket_name.clone(),
-            key: location.to_string(),
-            ..Default::default()
-        };
-
-        let s3 = self.client().await;
-
-        s3_request(move || {
-            let (s3, request_factory) = (s3.clone(), request_factory.clone());
-
-            async move { s3.delete_object(request_factory()).await }
-        })
-        .await
-        .context(UnableToDeleteDataSnafu {
-            bucket: &self.bucket_name,
-            path: location.as_ref(),
-        })?;
-
-        Ok(())
-    }
-
-    async fn list(
-        &self,
-        prefix: Option<&Path>,
-    ) -> Result<BoxStream<'_, Result<ObjectMeta>>> {
-        Ok(self
-            .list_objects_v2(prefix, None)
-            .await?
-            .map_ok(move |list_objects_v2_result| {
-                let contents = list_objects_v2_result.contents.unwrap_or_default();
-                let iter = contents
-                    .into_iter()
-                    .map(|object| convert_object_meta(object, &self.bucket_name));
-
-                futures::stream::iter(iter)
-            })
-            .try_flatten()
-            .boxed())
-    }
-
-    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
-        Ok(self
-            .list_objects_v2(prefix, Some(DELIMITER.to_string()))
-            .await?
-            .try_fold(
-                ListResult {
-                    common_prefixes: vec![],
-                    objects: vec![],
-                },
-                |acc, list_objects_v2_result| async move {
-                    let mut res = acc;
-                    let contents = list_objects_v2_result.contents.unwrap_or_default();
-                    let mut objects = contents
-                        .into_iter()
-                        .map(|object| convert_object_meta(object, &self.bucket_name))
-                        .collect::<Result<Vec<_>>>()?;
-
-                    res.objects.append(&mut objects);
-
-                    let prefixes =
-                        list_objects_v2_result.common_prefixes.unwrap_or_default();
-                    res.common_prefixes.reserve(prefixes.len());
-
-                    for p in prefixes {
-                        let prefix =
-                            p.prefix.expect("can't have a prefix without a value");
-                        res.common_prefixes.push(Path::parse(prefix)?);
-                    }
-
-                    Ok(res)
-                },
-            )
-            .await?)
-    }
-
-    async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
-        let from = from.as_ref();
-        let to = to.as_ref();
-        let bucket_name = self.bucket_name.clone();
-
-        let copy_source = format!(
-            "{}/{}",
-            &bucket_name,
-            percent_encode(from.as_ref(), &STRICT_PATH_ENCODE_SET)
-        );
-
-        let request_factory = move || rusoto_s3::CopyObjectRequest {
-            bucket: bucket_name.clone(),
-            copy_source,
-            key: to.to_string(),
-            ..Default::default()
-        };
-
-        let s3 = self.client().await;
-
-        s3_request(move || {
-            let (s3, request_factory) = (s3.clone(), request_factory.clone());
-
-            async move { s3.copy_object(request_factory()).await }
-        })
-        .await
-        .context(UnableToCopyObjectSnafu {
-            bucket: &self.bucket_name,
-            from,
-            to,
-        })?;
-
-        Ok(())
-    }
-
-    async fn copy_if_not_exists(&self, _source: &Path, _dest: &Path) -> Result<()> {
-        // Will need dynamodb_lock
-        Err(crate::Error::NotImplemented)
-    }
-}
-
-fn convert_object_meta(object: rusoto_s3::Object, bucket: &str) -> Result<ObjectMeta> {
-    let key = object.key.expect("object doesn't exist without a key");
-    let location = Path::parse(key)?;
-    let last_modified = match object.last_modified {
-        Some(lm) => DateTime::parse_from_rfc3339(&lm)
-            .context(UnableToParseLastModifiedSnafu { bucket })?
-            .with_timezone(&Utc),
-        None => Utc::now(),
-    };
-    let size = usize::try_from(object.size.unwrap_or(0))
-        .expect("unsupported size on this platform");
-
-    Ok(ObjectMeta {
-        location,
-        last_modified,
-        size,
-    })
-}
-
-/// Configure a connection to Amazon S3 using the specified credentials in
-/// the specified Amazon region and bucket.
-///
-/// # Example
-/// ```
-/// # let REGION = "foo";
-/// # let BUCKET_NAME = "foo";
-/// # let ACCESS_KEY_ID = "foo";
-/// # let SECRET_KEY = "foo";
-/// # use object_store::aws::AmazonS3Builder;
-/// let s3 = AmazonS3Builder::new()
-///  .with_region(REGION)
-///  .with_bucket_name(BUCKET_NAME)
-///  .with_access_key_id(ACCESS_KEY_ID)
-///  .with_secret_access_key(SECRET_KEY)
-///  .build();
-/// ```
-#[derive(Debug)]
-pub struct AmazonS3Builder {
-    access_key_id: Option<String>,
-    secret_access_key: Option<String>,
-    region: Option<String>,
-    bucket_name: Option<String>,
-    endpoint: Option<String>,
-    token: Option<String>,
-    max_connections: NonZeroUsize,
-    allow_http: bool,
-}
-
-impl Default for AmazonS3Builder {
-    fn default() -> Self {
-        Self {
-            access_key_id: None,
-            secret_access_key: None,
-            region: None,
-            bucket_name: None,
-            endpoint: None,
-            token: None,
-            max_connections: NonZeroUsize::new(16).unwrap(),
-            allow_http: false,
-        }
-    }
-}
-
-impl AmazonS3Builder {
-    /// Create a new [`AmazonS3Builder`] with default values.
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    /// Set the AWS Access Key (required)
-    pub fn with_access_key_id(mut self, access_key_id: impl Into<String>) -> Self {
-        self.access_key_id = Some(access_key_id.into());
-        self
-    }
-
-    /// Set the AWS Secret Access Key (required)
-    pub fn with_secret_access_key(
-        mut self,
-        secret_access_key: impl Into<String>,
-    ) -> Self {
-        self.secret_access_key = Some(secret_access_key.into());
-        self
-    }
-
-    /// Set the region (e.g. `us-east-1`) (required)
-    pub fn with_region(mut self, region: impl Into<String>) -> Self {
-        self.region = Some(region.into());
-        self
-    }
-
-    /// Set the bucket_name (required)
-    pub fn with_bucket_name(mut self, bucket_name: impl Into<String>) -> Self {
-        self.bucket_name = Some(bucket_name.into());
-        self
-    }
-
-    /// Sets the endpoint for communicating with AWS S3. Default value
-    /// is based on region.
-    ///
-    /// For example, this might be set to `"http://localhost:4566:`
-    /// for testing against a localstack instance.
-    pub fn with_endpoint(mut self, endpoint: impl Into<String>) -> Self {
-        self.endpoint = Some(endpoint.into());
-        self
-    }
-
-    /// Set the token to use for requests (passed to underlying provider)
-    pub fn with_token(mut self, token: impl Into<String>) -> Self {
-        self.token = Some(token.into());
-        self
-    }
-
-    /// Sets the maximum number of concurrent outstanding
-    /// connectons. Default is `16`.
-    #[deprecated(note = "use LimitStore instead")]
-    pub fn with_max_connections(mut self, max_connections: NonZeroUsize) -> Self {
-        self.max_connections = max_connections;
-        self
-    }
-
-    /// Sets what protocol is allowed. If `allow_http` is :
-    /// * false (default):  Only HTTPS are allowed
-    /// * true:  HTTP and HTTPS are allowed
-    pub fn with_allow_http(mut self, allow_http: bool) -> Self {
-        self.allow_http = allow_http;
-        self
-    }
-
-    /// Create a [`AmazonS3`] instance from the provided values,
-    /// consuming `self`.
-    pub fn build(self) -> Result<AmazonS3> {
-        let Self {
-            access_key_id,
-            secret_access_key,
-            region,
-            bucket_name,
-            endpoint,
-            token,
-            max_connections,
-            allow_http,
-        } = self;
-
-        let region = region.ok_or(Error::MissingRegion {})?;
-        let bucket_name = bucket_name.ok_or(Error::MissingBucketName {})?;
-
-        let region: rusoto_core::Region = match endpoint {
-            None => region.parse().context(InvalidRegionSnafu { region })?,
-            Some(endpoint) => rusoto_core::Region::Custom {
-                name: region,
-                endpoint,
-            },
-        };
-
-        let mut builder = HyperBuilder::default();
-        builder.pool_max_idle_per_host(max_connections.get());
-
-        let connector = if allow_http {
-            hyper_rustls::HttpsConnectorBuilder::new()
-                .with_webpki_roots()
-                .https_or_http()
-                .enable_http1()
-                .enable_http2()
-                .build()
-        } else {
-            hyper_rustls::HttpsConnectorBuilder::new()
-                .with_webpki_roots()
-                .https_only()
-                .enable_http1()
-                .enable_http2()
-                .build()
-        };
-
-        let http_client =
-            rusoto_core::request::HttpClient::from_builder(builder, connector);
-
-        let client = match (access_key_id, secret_access_key, token) {
-            (Some(access_key_id), Some(secret_access_key), Some(token)) => {
-                let credentials_provider = StaticProvider::new(
-                    access_key_id,
-                    secret_access_key,
-                    Some(token),
-                    None,
-                );
-                rusoto_s3::S3Client::new_with(http_client, credentials_provider, region)
-            }
-            (Some(access_key_id), Some(secret_access_key), None) => {
-                let credentials_provider =
-                    StaticProvider::new_minimal(access_key_id, secret_access_key);
-                rusoto_s3::S3Client::new_with(http_client, credentials_provider, region)
-            }
-            (None, Some(_), _) => return Err(Error::MissingAccessKey.into()),
-            (Some(_), None, _) => return Err(Error::MissingSecretAccessKey.into()),
-            _ if std::env::var_os("AWS_WEB_IDENTITY_TOKEN_FILE").is_some() => {
-                rusoto_s3::S3Client::new_with(
-                    http_client,
-                    WebIdentityProvider::from_k8s_env(),
-                    region,
-                )
-            }
-            _ => rusoto_s3::S3Client::new_with(
-                http_client,
-                InstanceMetadataProvider::new(),
-                region,
-            ),
-        };
-
-        Ok(AmazonS3 {
-            client_unrestricted: client,
-            connection_semaphore: Arc::new(Semaphore::new(max_connections.get())),
-            bucket_name,
-        })
-    }
-}
-
-/// S3 client bundled w/ a semaphore permit.
-#[derive(Clone)]
-struct SemaphoreClient {
-    /// Permit for this specific use of the client.
-    ///
-    /// Note that this field is never read and therefore considered "dead code" by rustc.
-    #[allow(dead_code)]
-    permit: Arc<OwnedSemaphorePermit>,
-
-    inner: rusoto_s3::S3Client,
-}
-
-impl Deref for SemaphoreClient {
-    type Target = rusoto_s3::S3Client;
-
-    fn deref(&self) -> &Self::Target {
-        &self.inner
-    }
-}
-
-impl AmazonS3 {
-    /// Get a client according to the current connection limit.
-    async fn client(&self) -> SemaphoreClient {
-        let permit = Arc::clone(&self.connection_semaphore)
-            .acquire_owned()
-            .await
-            .expect("semaphore shouldn't be closed yet");
-        SemaphoreClient {
-            permit: Arc::new(permit),
-            inner: self.client_unrestricted.clone(),
-        }
-    }
-
-    async fn get_object(
-        &self,
-        location: &Path,
-        range: Option<Range<usize>>,
-    ) -> Result<impl Stream<Item = Result<Bytes>>> {
-        let key = location.to_string();
-        let get_request = rusoto_s3::GetObjectRequest {
-            bucket: self.bucket_name.clone(),
-            key: key.clone(),
-            range: range.map(format_http_range),
-            ..Default::default()
-        };
-        let bucket_name = self.bucket_name.clone();
-        let stream = self
-            .client()
-            .await
-            .get_object(get_request)
-            .await
-            .map_err(|e| match e {
-                rusoto_core::RusotoError::Service(
-                    rusoto_s3::GetObjectError::NoSuchKey(_),
-                ) => Error::NotFound {
-                    path: key.clone(),
-                    source: e.into(),
-                },
-                _ => Error::UnableToGetData {
-                    bucket: self.bucket_name.to_owned(),
-                    path: key.clone(),
-                    source: e,
-                },
-            })?
-            .body
-            .context(NoDataSnafu {
-                bucket: self.bucket_name.to_owned(),
-                path: key.clone(),
-            })?
-            .map_err(move |source| Error::UnableToGetPieceOfData {
-                source,
-                bucket: bucket_name.clone(),
-                path: key.clone(),
-            })
-            .err_into();
-
-        Ok(stream)
-    }
-
-    async fn list_objects_v2(
-        &self,
-        prefix: Option<&Path>,
-        delimiter: Option<String>,
-    ) -> Result<BoxStream<'_, Result<rusoto_s3::ListObjectsV2Output>>> {
-        enum ListState {
-            Start,
-            HasMore(String),
-            Done,
-        }
-
-        let prefix = format_prefix(prefix);
-        let bucket = self.bucket_name.clone();
-
-        let request_factory = move || rusoto_s3::ListObjectsV2Request {
-            bucket,
-            prefix,
-            delimiter,
-            ..Default::default()
-        };
-        let s3 = self.client().await;
-
-        Ok(stream::unfold(ListState::Start, move |state| {
-            let request_factory = request_factory.clone();
-            let s3 = s3.clone();
-
-            async move {
-                let continuation_token = match &state {
-                    ListState::HasMore(continuation_token) => Some(continuation_token),
-                    ListState::Done => {
-                        return None;
-                    }
-                    // If this is the first request we've made, we don't need to make any
-                    // modifications to the request
-                    ListState::Start => None,
-                };
-
-                let resp = s3_request(move || {
-                    let (s3, request_factory, continuation_token) = (
-                        s3.clone(),
-                        request_factory.clone(),
-                        continuation_token.cloned(),
-                    );
-
-                    async move {
-                        s3.list_objects_v2(rusoto_s3::ListObjectsV2Request {
-                            continuation_token,
-                            ..request_factory()
-                        })
-                        .await
-                    }
-                })
-                .await;
-
-                let resp = match resp {
-                    Ok(resp) => resp,
-                    Err(e) => return Some((Err(e), state)),
-                };
-
-                // The AWS response contains a field named `is_truncated` as well as
-                // `next_continuation_token`, and we're assuming that `next_continuation_token`
-                // is only set when `is_truncated` is true (and therefore not
-                // checking `is_truncated`).
-                let next_state = if let Some(next_continuation_token) =
-                    &resp.next_continuation_token
-                {
-                    ListState::HasMore(next_continuation_token.to_string())
-                } else {
-                    ListState::Done
-                };
-
-                Some((Ok(resp), next_state))
-            }
-        })
-        .map_err(move |e| {
-            Error::UnableToListData {
-                source: e,
-                bucket: self.bucket_name.clone(),
-            }
-            .into()
-        })
-        .boxed())
-    }
-}
-
-/// Handles retrying a request to S3 up to `MAX_NUM_RETRIES` times if S3 returns 5xx server errors.
-///
-/// The `future_factory` argument is a function `F` that takes no arguments and, when called, will
-/// return a `Future` (type `G`) that, when `await`ed, will perform a request to S3 through
-/// `rusoto` and return a `Result` that returns some type `R` on success and some
-/// `rusoto_core::RusotoError<E>` on error.
-///
-/// If the executed `Future` returns success, this function will return that success.
-/// If the executed `Future` returns a 5xx server error, this function will wait an amount of
-/// time that increases exponentially with the number of times it has retried, get a new `Future` by
-/// calling `future_factory` again, and retry the request by `await`ing the `Future` again.
-/// The retries will continue until the maximum number of retries has been attempted. In that case,
-/// this function will return the last encountered error.
-///
-/// Client errors (4xx) will never be retried by this function.
-async fn s3_request<E, F, G, R>(
-    future_factory: F,
-) -> Result<R, rusoto_core::RusotoError<E>>
-where
-    E: std::error::Error + Send,
-    F: Fn() -> G + Send,
-    G: Future<Output = Result<R, rusoto_core::RusotoError<E>>> + Send,
-    R: Send,
-{
-    let mut attempts = 0;
-
-    loop {
-        let request = future_factory();
-
-        let result = request.await;
-
-        match result {
-            Ok(r) => return Ok(r),
-            Err(error) => {
-                attempts += 1;
-
-                let should_retry = matches!(
-                    error,
-                    rusoto_core::RusotoError::Unknown(ref response)
-                        if response.status.is_server_error()
-                );
-
-                if attempts > MAX_NUM_RETRIES {
-                    warn!(
-                        ?error,
-                        attempts, "maximum number of retries exceeded for AWS S3 request"
-                    );
-                    return Err(error);
-                } else if !should_retry {
-                    return Err(error);
-                } else {
-                    debug!(?error, attempts, "retrying AWS S3 request");
-                    let wait_time = Duration::from_millis(2u64.pow(attempts) * 50);
-                    tokio::time::sleep(wait_time).await;
-                }
-            }
-        }
-    }
-}
-
-struct S3MultiPartUpload {
-    bucket: String,
-    key: String,
-    upload_id: String,
-    client_unrestricted: rusoto_s3::S3Client,
-    connection_semaphore: Arc<Semaphore>,
-}
-
-impl CloudMultiPartUploadImpl for S3MultiPartUpload {
-    fn put_multipart_part(
-        &self,
-        buf: Vec<u8>,
-        part_idx: usize,
-    ) -> BoxFuture<'static, Result<(usize, UploadPart), io::Error>> {
-        // Get values to move into future; we don't want a reference to Self
-        let bucket = self.bucket.clone();
-        let key = self.key.clone();
-        let upload_id = self.upload_id.clone();
-        let content_length = buf.len();
-
-        let request_factory = move || rusoto_s3::UploadPartRequest {
-            bucket,
-            key,
-            upload_id,
-            // AWS part number is 1-indexed
-            part_number: (part_idx + 1).try_into().unwrap(),
-            content_length: Some(content_length.try_into().unwrap()),
-            body: Some(buf.into()),
-            ..Default::default()
-        };
-
-        let s3 = self.client_unrestricted.clone();
-        let connection_semaphore = Arc::clone(&self.connection_semaphore);
-
-        Box::pin(async move {
-            let _permit = connection_semaphore
-                .acquire_owned()
-                .await
-                .expect("semaphore shouldn't be closed yet");
-
-            let response = s3_request(move || {
-                let (s3, request_factory) = (s3.clone(), request_factory.clone());
-                async move { s3.upload_part(request_factory()).await }
-            })
-            .await
-            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
-
-            Ok((
-                part_idx,
-                UploadPart {
-                    content_id: response.e_tag.unwrap(),
-                },
-            ))
-        })
-    }
-
-    fn complete(
-        &self,
-        completed_parts: Vec<Option<UploadPart>>,
-    ) -> BoxFuture<'static, Result<(), io::Error>> {
-        let parts =
-            completed_parts
-                .into_iter()
-                .enumerate()
-                .map(|(part_number, maybe_part)| match maybe_part {
-                    Some(part) => {
-                        Ok(rusoto_s3::CompletedPart {
-                            e_tag: Some(part.content_id),
-                            part_number: Some((part_number + 1).try_into().map_err(
-                                |err| io::Error::new(io::ErrorKind::Other, err),
-                            )?),
-                        })
-                    }
-                    None => Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        format!("Missing information for upload part {:?}", part_number),
-                    )),
-                });
-
-        // Get values to move into future; we don't want a reference to Self
-        let bucket = self.bucket.clone();
-        let key = self.key.clone();
-        let upload_id = self.upload_id.clone();
-
-        let request_factory = move || -> Result<_, io::Error> {
-            Ok(rusoto_s3::CompleteMultipartUploadRequest {
-                bucket,
-                key,
-                upload_id,
-                multipart_upload: Some(rusoto_s3::CompletedMultipartUpload {
-                    parts: Some(parts.collect::<Result<_, io::Error>>()?),
-                }),
-                ..Default::default()
-            })
-        };
-
-        let s3 = self.client_unrestricted.clone();
-        let connection_semaphore = Arc::clone(&self.connection_semaphore);
-
-        Box::pin(async move {
-            let _permit = connection_semaphore
-                .acquire_owned()
-                .await
-                .expect("semaphore shouldn't be closed yet");
-
-            s3_request(move || {
-                let (s3, request_factory) = (s3.clone(), request_factory.clone());
-
-                async move { s3.complete_multipart_upload(request_factory()?).await }
-            })
-            .await
-            .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
-
-            Ok(())
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::{
-        tests::{
-            get_nonexistent_object, list_uses_directories_correctly, list_with_delimiter,
-            put_get_delete_list, rename_and_copy, stream_get,
-        },
-        Error as ObjectStoreError,
-    };
-    use bytes::Bytes;
-    use std::env;
-
-    const NON_EXISTENT_NAME: &str = "nonexistentname";
-
-    // Helper macro to skip tests if TEST_INTEGRATION and the AWS
-    // environment variables are not set. Returns a configured
-    // AmazonS3Builder
-    macro_rules! maybe_skip_integration {
-        () => {{
-            dotenv::dotenv().ok();
-
-            let required_vars = [
-                "AWS_DEFAULT_REGION",
-                "OBJECT_STORE_BUCKET",
-                "AWS_ACCESS_KEY_ID",
-                "AWS_SECRET_ACCESS_KEY",
-            ];
-            let unset_vars: Vec<_> = required_vars
-                .iter()
-                .filter_map(|&name| match env::var(name) {
-                    Ok(_) => None,
-                    Err(_) => Some(name),
-                })
-                .collect();
-            let unset_var_names = unset_vars.join(", ");
-
-            let force = env::var("TEST_INTEGRATION");
-
-            if force.is_ok() && !unset_var_names.is_empty() {
-                panic!(
-                    "TEST_INTEGRATION is set, \
-                            but variable(s) {} need to be set",
-                    unset_var_names
-                );
-            } else if force.is_err() {
-                eprintln!(
-                    "skipping AWS integration test - set {}TEST_INTEGRATION to run",
-                    if unset_var_names.is_empty() {
-                        String::new()
-                    } else {
-                        format!("{} and ", unset_var_names)
-                    }
-                );
-                return;
-            } else {
-                let config = AmazonS3Builder::new()
-                    .with_access_key_id(
-                        env::var("AWS_ACCESS_KEY_ID")
-                            .expect("already checked AWS_ACCESS_KEY_ID"),
-                    )
-                    .with_secret_access_key(
-                        env::var("AWS_SECRET_ACCESS_KEY")
-                            .expect("already checked AWS_SECRET_ACCESS_KEY"),
-                    )
-                    .with_region(
-                        env::var("AWS_DEFAULT_REGION")
-                            .expect("already checked AWS_DEFAULT_REGION"),
-                    )
-                    .with_bucket_name(
-                        env::var("OBJECT_STORE_BUCKET")
-                            .expect("already checked OBJECT_STORE_BUCKET"),
-                    )
-                    .with_allow_http(true);
-
-                let config = if let Some(endpoint) = env::var("AWS_ENDPOINT").ok() {
-                    config.with_endpoint(endpoint)
-                } else {
-                    config
-                };
-
-                let config = if let Some(token) = env::var("AWS_SESSION_TOKEN").ok() {
-                    config.with_token(token)
-                } else {
-                    config
-                };
-
-                config
-            }
-        }};
-    }
-
-    #[tokio::test]
-    async fn s3_test() {
-        let config = maybe_skip_integration!();
-        let integration = config.build().unwrap();
-
-        put_get_delete_list(&integration).await;
-        list_uses_directories_correctly(&integration).await;
-        list_with_delimiter(&integration).await;
-        rename_and_copy(&integration).await;
-        stream_get(&integration).await;
-    }
-
-    #[tokio::test]
-    async fn s3_test_get_nonexistent_location() {
-        let config = maybe_skip_integration!();
-        let integration = config.build().unwrap();
-
-        let location = Path::from_iter([NON_EXISTENT_NAME]);
-
-        let err = get_nonexistent_object(&integration, Some(location))
-            .await
-            .unwrap_err();
-        if let ObjectStoreError::NotFound { path, source } = err {
-            let source_variant = source.downcast_ref::<rusoto_core::RusotoError<_>>();
-            assert!(
-                matches!(
-                    source_variant,
-                    Some(rusoto_core::RusotoError::Service(
-                        rusoto_s3::GetObjectError::NoSuchKey(_)
-                    )),
-                ),
-                "got: {:?}",
-                source_variant
-            );
-            assert_eq!(path, NON_EXISTENT_NAME);
-        } else {
-            panic!("unexpected error type: {:?}", err);
-        }
-    }
-
-    #[tokio::test]
-    async fn s3_test_get_nonexistent_bucket() {
-        let config = maybe_skip_integration!().with_bucket_name(NON_EXISTENT_NAME);
-        let integration = config.build().unwrap();
-
-        let location = Path::from_iter([NON_EXISTENT_NAME]);
-
-        let err = integration.get(&location).await.unwrap_err().to_string();
-        assert!(
-            err.contains("The specified bucket does not exist"),
-            "{}",
-            err
-        )
-    }
-
-    #[tokio::test]
-    async fn s3_test_put_nonexistent_bucket() {
-        let config = maybe_skip_integration!().with_bucket_name(NON_EXISTENT_NAME);
-
-        let integration = config.build().unwrap();
-
-        let location = Path::from_iter([NON_EXISTENT_NAME]);
-        let data = Bytes::from("arbitrary data");
-
-        let err = integration
-            .put(&location, data)
-            .await
-            .unwrap_err()
-            .to_string();
-
-        assert!(
-            err.contains("The specified bucket does not exist")
-                && err.contains("Unable to PUT data"),
-            "{}",
-            err
-        )
-    }
-
-    #[tokio::test]
-    async fn s3_test_delete_nonexistent_location() {
-        let config = maybe_skip_integration!();
-        let integration = config.build().unwrap();
-
-        let location = Path::from_iter([NON_EXISTENT_NAME]);
-
-        integration.delete(&location).await.unwrap();
-    }
-
-    #[tokio::test]
-    async fn s3_test_delete_nonexistent_bucket() {
-        let config = maybe_skip_integration!().with_bucket_name(NON_EXISTENT_NAME);
-        let integration = config.build().unwrap();
-
-        let location = Path::from_iter([NON_EXISTENT_NAME]);
-
-        let err = integration.delete(&location).await.unwrap_err().to_string();
-        assert!(
-            err.contains("The specified bucket does not exist")
-                && err.contains("Unable to DELETE data"),
-            "{}",
-            err
-        )
-    }
-}
diff --git a/object_store/src/aws/builder.rs b/object_store/src/aws/builder.rs
new file mode 100644
index 000000000000..a578d1abbfae
--- /dev/null
+++ b/object_store/src/aws/builder.rs
@@ -0,0 +1,1384 @@
+// 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.
+
+use crate::aws::client::{S3Client, S3Config};
+use crate::aws::credential::{
+    InstanceCredentialProvider, SessionProvider, TaskCredentialProvider, WebIdentityProvider,
+};
+use crate::aws::{
+    AmazonS3, AwsCredential, AwsCredentialProvider, Checksum, S3ConditionalPut, S3CopyIfNotExists,
+    STORE,
+};
+use crate::client::TokenCredentialProvider;
+use crate::config::ConfigValue;
+use crate::{ClientConfigKey, ClientOptions, Result, RetryConfig, StaticCredentialProvider};
+use itertools::Itertools;
+use reqwest::header::{HeaderMap, HeaderValue};
+use serde::{Deserialize, Serialize};
+use snafu::{OptionExt, ResultExt, Snafu};
+use std::str::FromStr;
+use std::sync::Arc;
+use std::time::Duration;
+use tracing::info;
+use url::Url;
+
+/// Default metadata endpoint
+static DEFAULT_METADATA_ENDPOINT: &str = "http://169.254.169.254";
+
+/// A specialized `Error` for object store-related errors
+#[derive(Debug, Snafu)]
+#[allow(missing_docs)]
+enum Error {
+    #[snafu(display("Missing bucket name"))]
+    MissingBucketName,
+
+    #[snafu(display("Missing AccessKeyId"))]
+    MissingAccessKeyId,
+
+    #[snafu(display("Missing SecretAccessKey"))]
+    MissingSecretAccessKey,
+
+    #[snafu(display("Unable parse source url. Url: {}, Error: {}", url, source))]
+    UnableToParseUrl {
+        source: url::ParseError,
+        url: String,
+    },
+
+    #[snafu(display(
+        "Unknown url scheme cannot be parsed into storage location: {}",
+        scheme
+    ))]
+    UnknownUrlScheme { scheme: String },
+
+    #[snafu(display("URL did not match any known pattern for scheme: {}", url))]
+    UrlNotRecognised { url: String },
+
+    #[snafu(display("Configuration key: '{}' is not known.", key))]
+    UnknownConfigurationKey { key: String },
+
+    #[snafu(display("Bucket '{}' not found", bucket))]
+    BucketNotFound { bucket: String },
+
+    #[snafu(display("Failed to resolve region for bucket '{}'", bucket))]
+    ResolveRegion {
+        bucket: String,
+        source: reqwest::Error,
+    },
+
+    #[snafu(display("Invalid Zone suffix for bucket '{bucket}'"))]
+    ZoneSuffix { bucket: String },
+
+    #[snafu(display("Failed to parse the region for bucket '{}'", bucket))]
+    RegionParse { bucket: String },
+
+    #[snafu(display("Invalid encryption type: {}. Valid values are \"AES256\", \"sse:kms\", and \"sse:kms:dsse\".", passed))]
+    InvalidEncryptionType { passed: String },
+
+    #[snafu(display(
+        "Invalid encryption header values. Header: {}, source: {}",
+        header,
+        source
+    ))]
+    InvalidEncryptionHeader {
+        header: &'static str,
+        source: Box<dyn std::error::Error + Send + Sync + 'static>,
+    },
+}
+
+impl From<Error> for crate::Error {
+    fn from(source: Error) -> Self {
+        match source {
+            Error::UnknownConfigurationKey { key } => {
+                Self::UnknownConfigurationKey { store: STORE, key }
+            }
+            _ => Self::Generic {
+                store: STORE,
+                source: Box::new(source),
+            },
+        }
+    }
+}
+
+/// Configure a connection to Amazon S3 using the specified credentials in
+/// the specified Amazon region and bucket.
+///
+/// # Example
+/// ```
+/// # let REGION = "foo";
+/// # let BUCKET_NAME = "foo";
+/// # let ACCESS_KEY_ID = "foo";
+/// # let SECRET_KEY = "foo";
+/// # use object_store::aws::AmazonS3Builder;
+/// let s3 = AmazonS3Builder::new()
+///  .with_region(REGION)
+///  .with_bucket_name(BUCKET_NAME)
+///  .with_access_key_id(ACCESS_KEY_ID)
+///  .with_secret_access_key(SECRET_KEY)
+///  .build();
+/// ```
+#[derive(Debug, Default, Clone)]
+pub struct AmazonS3Builder {
+    /// Access key id
+    access_key_id: Option<String>,
+    /// Secret access_key
+    secret_access_key: Option<String>,
+    /// Region
+    region: Option<String>,
+    /// Bucket name
+    bucket_name: Option<String>,
+    /// Endpoint for communicating with AWS S3
+    endpoint: Option<String>,
+    /// Token to use for requests
+    token: Option<String>,
+    /// Url
+    url: Option<String>,
+    /// Retry config
+    retry_config: RetryConfig,
+    /// When set to true, fallback to IMDSv1
+    imdsv1_fallback: ConfigValue<bool>,
+    /// When set to true, virtual hosted style request has to be used
+    virtual_hosted_style_request: ConfigValue<bool>,
+    /// When set to true, S3 express is used
+    s3_express: ConfigValue<bool>,
+    /// When set to true, unsigned payload option has to be used
+    unsigned_payload: ConfigValue<bool>,
+    /// Checksum algorithm which has to be used for object integrity check during upload
+    checksum_algorithm: Option<ConfigValue<Checksum>>,
+    /// Metadata endpoint, see <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html>
+    metadata_endpoint: Option<String>,
+    /// Container credentials URL, see <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html>
+    container_credentials_relative_uri: Option<String>,
+    /// Client options
+    client_options: ClientOptions,
+    /// Credentials
+    credentials: Option<AwsCredentialProvider>,
+    /// Skip signing requests
+    skip_signature: ConfigValue<bool>,
+    /// Copy if not exists
+    copy_if_not_exists: Option<ConfigValue<S3CopyIfNotExists>>,
+    /// Put precondition
+    conditional_put: Option<ConfigValue<S3ConditionalPut>>,
+    /// Ignore tags
+    disable_tagging: ConfigValue<bool>,
+    /// Encryption (See [`S3EncryptionConfigKey`])
+    encryption_type: Option<ConfigValue<S3EncryptionType>>,
+    encryption_kms_key_id: Option<String>,
+    encryption_bucket_key_enabled: Option<ConfigValue<bool>>,
+}
+
+/// Configuration keys for [`AmazonS3Builder`]
+///
+/// Configuration via keys can be done via [`AmazonS3Builder::with_config`]
+///
+/// # Example
+/// ```
+/// # use object_store::aws::{AmazonS3Builder, AmazonS3ConfigKey};
+/// let builder = AmazonS3Builder::new()
+///     .with_config("aws_access_key_id".parse().unwrap(), "my-access-key-id")
+///     .with_config(AmazonS3ConfigKey::DefaultRegion, "my-default-region");
+/// ```
+#[derive(PartialEq, Eq, Hash, Clone, Debug, Copy, Serialize, Deserialize)]
+#[non_exhaustive]
+pub enum AmazonS3ConfigKey {
+    /// AWS Access Key
+    ///
+    /// See [`AmazonS3Builder::with_access_key_id`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_access_key_id`
+    /// - `access_key_id`
+    AccessKeyId,
+
+    /// Secret Access Key
+    ///
+    /// See [`AmazonS3Builder::with_secret_access_key`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_secret_access_key`
+    /// - `secret_access_key`
+    SecretAccessKey,
+
+    /// Region
+    ///
+    /// See [`AmazonS3Builder::with_region`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_region`
+    /// - `region`
+    Region,
+
+    /// Default region
+    ///
+    /// See [`AmazonS3Builder::with_region`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_default_region`
+    /// - `default_region`
+    DefaultRegion,
+
+    /// Bucket name
+    ///
+    /// See [`AmazonS3Builder::with_bucket_name`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_bucket`
+    /// - `aws_bucket_name`
+    /// - `bucket`
+    /// - `bucket_name`
+    Bucket,
+
+    /// Sets custom endpoint for communicating with AWS S3.
+    ///
+    /// See [`AmazonS3Builder::with_endpoint`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_endpoint`
+    /// - `aws_endpoint_url`
+    /// - `endpoint`
+    /// - `endpoint_url`
+    Endpoint,
+
+    /// Token to use for requests (passed to underlying provider)
+    ///
+    /// See [`AmazonS3Builder::with_token`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_session_token`
+    /// - `aws_token`
+    /// - `session_token`
+    /// - `token`
+    Token,
+
+    /// Fall back to ImdsV1
+    ///
+    /// See [`AmazonS3Builder::with_imdsv1_fallback`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_imdsv1_fallback`
+    /// - `imdsv1_fallback`
+    ImdsV1Fallback,
+
+    /// If virtual hosted style request has to be used
+    ///
+    /// See [`AmazonS3Builder::with_virtual_hosted_style_request`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_virtual_hosted_style_request`
+    /// - `virtual_hosted_style_request`
+    VirtualHostedStyleRequest,
+
+    /// Avoid computing payload checksum when calculating signature.
+    ///
+    /// See [`AmazonS3Builder::with_unsigned_payload`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_unsigned_payload`
+    /// - `unsigned_payload`
+    UnsignedPayload,
+
+    /// Set the checksum algorithm for this client
+    ///
+    /// See [`AmazonS3Builder::with_checksum_algorithm`]
+    Checksum,
+
+    /// Set the instance metadata endpoint
+    ///
+    /// See [`AmazonS3Builder::with_metadata_endpoint`] for details.
+    ///
+    /// Supported keys:
+    /// - `aws_metadata_endpoint`
+    /// - `metadata_endpoint`
+    MetadataEndpoint,
+
+    /// Set the container credentials relative URI
+    ///
+    /// <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html>
+    ContainerCredentialsRelativeUri,
+
+    /// Configure how to provide `copy_if_not_exists`
+    ///
+    /// See [`S3CopyIfNotExists`]
+    CopyIfNotExists,
+
+    /// Configure how to provide conditional put operations
+    ///
+    /// See [`S3ConditionalPut`]
+    ConditionalPut,
+
+    /// Skip signing request
+    SkipSignature,
+
+    /// Disable tagging objects
+    ///
+    /// This can be desirable if not supported by the backing store
+    ///
+    /// Supported keys:
+    /// - `aws_disable_tagging`
+    /// - `disable_tagging`
+    DisableTagging,
+
+    /// Enable Support for S3 Express One Zone
+    ///
+    /// Supported keys:
+    /// - `aws_s3_express`
+    /// - `s3_express`
+    S3Express,
+
+    /// Client options
+    Client(ClientConfigKey),
+
+    /// Encryption options
+    Encryption(S3EncryptionConfigKey),
+}
+
+impl AsRef<str> for AmazonS3ConfigKey {
+    fn as_ref(&self) -> &str {
+        match self {
+            Self::AccessKeyId => "aws_access_key_id",
+            Self::SecretAccessKey => "aws_secret_access_key",
+            Self::Region => "aws_region",
+            Self::Bucket => "aws_bucket",
+            Self::Endpoint => "aws_endpoint",
+            Self::Token => "aws_session_token",
+            Self::ImdsV1Fallback => "aws_imdsv1_fallback",
+            Self::VirtualHostedStyleRequest => "aws_virtual_hosted_style_request",
+            Self::S3Express => "aws_s3_express",
+            Self::DefaultRegion => "aws_default_region",
+            Self::MetadataEndpoint => "aws_metadata_endpoint",
+            Self::UnsignedPayload => "aws_unsigned_payload",
+            Self::Checksum => "aws_checksum_algorithm",
+            Self::ContainerCredentialsRelativeUri => "aws_container_credentials_relative_uri",
+            Self::SkipSignature => "aws_skip_signature",
+            Self::CopyIfNotExists => "aws_copy_if_not_exists",
+            Self::ConditionalPut => "aws_conditional_put",
+            Self::DisableTagging => "aws_disable_tagging",
+            Self::Client(opt) => opt.as_ref(),
+            Self::Encryption(opt) => opt.as_ref(),
+        }
+    }
+}
+
+impl FromStr for AmazonS3ConfigKey {
+    type Err = crate::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "aws_access_key_id" | "access_key_id" => Ok(Self::AccessKeyId),
+            "aws_secret_access_key" | "secret_access_key" => Ok(Self::SecretAccessKey),
+            "aws_default_region" | "default_region" => Ok(Self::DefaultRegion),
+            "aws_region" | "region" => Ok(Self::Region),
+            "aws_bucket" | "aws_bucket_name" | "bucket_name" | "bucket" => Ok(Self::Bucket),
+            "aws_endpoint_url" | "aws_endpoint" | "endpoint_url" | "endpoint" => Ok(Self::Endpoint),
+            "aws_session_token" | "aws_token" | "session_token" | "token" => Ok(Self::Token),
+            "aws_virtual_hosted_style_request" | "virtual_hosted_style_request" => {
+                Ok(Self::VirtualHostedStyleRequest)
+            }
+            "aws_s3_express" | "s3_express" => Ok(Self::S3Express),
+            "aws_imdsv1_fallback" | "imdsv1_fallback" => Ok(Self::ImdsV1Fallback),
+            "aws_metadata_endpoint" | "metadata_endpoint" => Ok(Self::MetadataEndpoint),
+            "aws_unsigned_payload" | "unsigned_payload" => Ok(Self::UnsignedPayload),
+            "aws_checksum_algorithm" | "checksum_algorithm" => Ok(Self::Checksum),
+            "aws_container_credentials_relative_uri" => Ok(Self::ContainerCredentialsRelativeUri),
+            "aws_skip_signature" | "skip_signature" => Ok(Self::SkipSignature),
+            "aws_copy_if_not_exists" | "copy_if_not_exists" => Ok(Self::CopyIfNotExists),
+            "aws_conditional_put" | "conditional_put" => Ok(Self::ConditionalPut),
+            "aws_disable_tagging" | "disable_tagging" => Ok(Self::DisableTagging),
+            // Backwards compatibility
+            "aws_allow_http" => Ok(Self::Client(ClientConfigKey::AllowHttp)),
+            "aws_server_side_encryption" => Ok(Self::Encryption(
+                S3EncryptionConfigKey::ServerSideEncryption,
+            )),
+            "aws_sse_kms_key_id" => Ok(Self::Encryption(S3EncryptionConfigKey::KmsKeyId)),
+            "aws_sse_bucket_key_enabled" => {
+                Ok(Self::Encryption(S3EncryptionConfigKey::BucketKeyEnabled))
+            }
+            _ => match s.parse() {
+                Ok(key) => Ok(Self::Client(key)),
+                Err(_) => Err(Error::UnknownConfigurationKey { key: s.into() }.into()),
+            },
+        }
+    }
+}
+
+impl AmazonS3Builder {
+    /// Create a new [`AmazonS3Builder`] with default values.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Fill the [`AmazonS3Builder`] with regular AWS environment variables
+    ///
+    /// Variables extracted from environment:
+    /// * `AWS_ACCESS_KEY_ID` -> access_key_id
+    /// * `AWS_SECRET_ACCESS_KEY` -> secret_access_key
+    /// * `AWS_DEFAULT_REGION` -> region
+    /// * `AWS_ENDPOINT` -> endpoint
+    /// * `AWS_SESSION_TOKEN` -> token
+    /// * `AWS_CONTAINER_CREDENTIALS_RELATIVE_URI` -> <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html>
+    /// * `AWS_ALLOW_HTTP` -> set to "true" to permit HTTP connections without TLS
+    /// # Example
+    /// ```
+    /// use object_store::aws::AmazonS3Builder;
+    ///
+    /// let s3 = AmazonS3Builder::from_env()
+    ///     .with_bucket_name("foo")
+    ///     .build();
+    /// ```
+    pub fn from_env() -> Self {
+        let mut builder: Self = Default::default();
+
+        for (os_key, os_value) in std::env::vars_os() {
+            if let (Some(key), Some(value)) = (os_key.to_str(), os_value.to_str()) {
+                if key.starts_with("AWS_") {
+                    if let Ok(config_key) = key.to_ascii_lowercase().parse() {
+                        builder = builder.with_config(config_key, value);
+                    }
+                }
+            }
+        }
+
+        builder
+    }
+
+    /// Parse available connection info form a well-known storage URL.
+    ///
+    /// The supported url schemes are:
+    ///
+    /// - `s3://<bucket>/<path>`
+    /// - `s3a://<bucket>/<path>`
+    /// - `https://s3.<region>.amazonaws.com/<bucket>`
+    /// - `https://<bucket>.s3.<region>.amazonaws.com`
+    /// - `https://ACCOUNT_ID.r2.cloudflarestorage.com/bucket`
+    ///
+    /// Note: Settings derived from the URL will override any others set on this builder
+    ///
+    /// # Example
+    /// ```
+    /// use object_store::aws::AmazonS3Builder;
+    ///
+    /// let s3 = AmazonS3Builder::from_env()
+    ///     .with_url("s3://bucket/path")
+    ///     .build();
+    /// ```
+    pub fn with_url(mut self, url: impl Into<String>) -> Self {
+        self.url = Some(url.into());
+        self
+    }
+
+    /// Set an option on the builder via a key - value pair.
+    pub fn with_config(mut self, key: AmazonS3ConfigKey, value: impl Into<String>) -> Self {
+        match key {
+            AmazonS3ConfigKey::AccessKeyId => self.access_key_id = Some(value.into()),
+            AmazonS3ConfigKey::SecretAccessKey => self.secret_access_key = Some(value.into()),
+            AmazonS3ConfigKey::Region => self.region = Some(value.into()),
+            AmazonS3ConfigKey::Bucket => self.bucket_name = Some(value.into()),
+            AmazonS3ConfigKey::Endpoint => self.endpoint = Some(value.into()),
+            AmazonS3ConfigKey::Token => self.token = Some(value.into()),
+            AmazonS3ConfigKey::ImdsV1Fallback => self.imdsv1_fallback.parse(value),
+            AmazonS3ConfigKey::VirtualHostedStyleRequest => {
+                self.virtual_hosted_style_request.parse(value)
+            }
+            AmazonS3ConfigKey::S3Express => self.s3_express.parse(value),
+            AmazonS3ConfigKey::DefaultRegion => {
+                self.region = self.region.or_else(|| Some(value.into()))
+            }
+            AmazonS3ConfigKey::MetadataEndpoint => self.metadata_endpoint = Some(value.into()),
+            AmazonS3ConfigKey::UnsignedPayload => self.unsigned_payload.parse(value),
+            AmazonS3ConfigKey::Checksum => {
+                self.checksum_algorithm = Some(ConfigValue::Deferred(value.into()))
+            }
+            AmazonS3ConfigKey::ContainerCredentialsRelativeUri => {
+                self.container_credentials_relative_uri = Some(value.into())
+            }
+            AmazonS3ConfigKey::Client(key) => {
+                self.client_options = self.client_options.with_config(key, value)
+            }
+            AmazonS3ConfigKey::SkipSignature => self.skip_signature.parse(value),
+            AmazonS3ConfigKey::DisableTagging => self.disable_tagging.parse(value),
+            AmazonS3ConfigKey::CopyIfNotExists => {
+                self.copy_if_not_exists = Some(ConfigValue::Deferred(value.into()))
+            }
+            AmazonS3ConfigKey::ConditionalPut => {
+                self.conditional_put = Some(ConfigValue::Deferred(value.into()))
+            }
+            AmazonS3ConfigKey::Encryption(key) => match key {
+                S3EncryptionConfigKey::ServerSideEncryption => {
+                    self.encryption_type = Some(ConfigValue::Deferred(value.into()))
+                }
+                S3EncryptionConfigKey::KmsKeyId => self.encryption_kms_key_id = Some(value.into()),
+                S3EncryptionConfigKey::BucketKeyEnabled => {
+                    self.encryption_bucket_key_enabled = Some(ConfigValue::Deferred(value.into()))
+                }
+            },
+        };
+        self
+    }
+
+    /// Get config value via a [`AmazonS3ConfigKey`].
+    ///
+    /// # Example
+    /// ```
+    /// use object_store::aws::{AmazonS3Builder, AmazonS3ConfigKey};
+    ///
+    /// let builder = AmazonS3Builder::from_env()
+    ///     .with_bucket_name("foo");
+    /// let bucket_name = builder.get_config_value(&AmazonS3ConfigKey::Bucket).unwrap_or_default();
+    /// assert_eq!("foo", &bucket_name);
+    /// ```
+    pub fn get_config_value(&self, key: &AmazonS3ConfigKey) -> Option<String> {
+        match key {
+            AmazonS3ConfigKey::AccessKeyId => self.access_key_id.clone(),
+            AmazonS3ConfigKey::SecretAccessKey => self.secret_access_key.clone(),
+            AmazonS3ConfigKey::Region | AmazonS3ConfigKey::DefaultRegion => self.region.clone(),
+            AmazonS3ConfigKey::Bucket => self.bucket_name.clone(),
+            AmazonS3ConfigKey::Endpoint => self.endpoint.clone(),
+            AmazonS3ConfigKey::Token => self.token.clone(),
+            AmazonS3ConfigKey::ImdsV1Fallback => Some(self.imdsv1_fallback.to_string()),
+            AmazonS3ConfigKey::VirtualHostedStyleRequest => {
+                Some(self.virtual_hosted_style_request.to_string())
+            }
+            AmazonS3ConfigKey::S3Express => Some(self.s3_express.to_string()),
+            AmazonS3ConfigKey::MetadataEndpoint => self.metadata_endpoint.clone(),
+            AmazonS3ConfigKey::UnsignedPayload => Some(self.unsigned_payload.to_string()),
+            AmazonS3ConfigKey::Checksum => {
+                self.checksum_algorithm.as_ref().map(ToString::to_string)
+            }
+            AmazonS3ConfigKey::Client(key) => self.client_options.get_config_value(key),
+            AmazonS3ConfigKey::ContainerCredentialsRelativeUri => {
+                self.container_credentials_relative_uri.clone()
+            }
+            AmazonS3ConfigKey::SkipSignature => Some(self.skip_signature.to_string()),
+            AmazonS3ConfigKey::CopyIfNotExists => {
+                self.copy_if_not_exists.as_ref().map(ToString::to_string)
+            }
+            AmazonS3ConfigKey::ConditionalPut => {
+                self.conditional_put.as_ref().map(ToString::to_string)
+            }
+            AmazonS3ConfigKey::DisableTagging => Some(self.disable_tagging.to_string()),
+            AmazonS3ConfigKey::Encryption(key) => match key {
+                S3EncryptionConfigKey::ServerSideEncryption => {
+                    self.encryption_type.as_ref().map(ToString::to_string)
+                }
+                S3EncryptionConfigKey::KmsKeyId => self.encryption_kms_key_id.clone(),
+                S3EncryptionConfigKey::BucketKeyEnabled => self
+                    .encryption_bucket_key_enabled
+                    .as_ref()
+                    .map(ToString::to_string),
+            },
+        }
+    }
+
+    /// Sets properties on this builder based on a URL
+    ///
+    /// This is a separate member function to allow fallible computation to
+    /// be deferred until [`Self::build`] which in turn allows deriving [`Clone`]
+    fn parse_url(&mut self, url: &str) -> Result<()> {
+        let parsed = Url::parse(url).context(UnableToParseUrlSnafu { url })?;
+        let host = parsed.host_str().context(UrlNotRecognisedSnafu { url })?;
+        match parsed.scheme() {
+            "s3" | "s3a" => self.bucket_name = Some(host.to_string()),
+            "https" => match host.splitn(4, '.').collect_tuple() {
+                Some(("s3", region, "amazonaws", "com")) => {
+                    self.region = Some(region.to_string());
+                    let bucket = parsed.path_segments().into_iter().flatten().next();
+                    if let Some(bucket) = bucket {
+                        self.bucket_name = Some(bucket.into());
+                    }
+                }
+                Some((bucket, "s3", region, "amazonaws.com")) => {
+                    self.bucket_name = Some(bucket.to_string());
+                    self.region = Some(region.to_string());
+                    self.virtual_hosted_style_request = true.into();
+                }
+                Some((account, "r2", "cloudflarestorage", "com")) => {
+                    self.region = Some("auto".to_string());
+                    let endpoint = format!("https://{account}.r2.cloudflarestorage.com");
+                    self.endpoint = Some(endpoint);
+
+                    let bucket = parsed.path_segments().into_iter().flatten().next();
+                    if let Some(bucket) = bucket {
+                        self.bucket_name = Some(bucket.into());
+                    }
+                }
+                _ => return Err(UrlNotRecognisedSnafu { url }.build().into()),
+            },
+            scheme => return Err(UnknownUrlSchemeSnafu { scheme }.build().into()),
+        };
+        Ok(())
+    }
+
+    /// Set the AWS Access Key
+    pub fn with_access_key_id(mut self, access_key_id: impl Into<String>) -> Self {
+        self.access_key_id = Some(access_key_id.into());
+        self
+    }
+
+    /// Set the AWS Secret Access Key
+    pub fn with_secret_access_key(mut self, secret_access_key: impl Into<String>) -> Self {
+        self.secret_access_key = Some(secret_access_key.into());
+        self
+    }
+
+    /// Set the AWS Session Token to use for requests
+    pub fn with_token(mut self, token: impl Into<String>) -> Self {
+        self.token = Some(token.into());
+        self
+    }
+
+    /// Set the region, defaults to `us-east-1`
+    pub fn with_region(mut self, region: impl Into<String>) -> Self {
+        self.region = Some(region.into());
+        self
+    }
+
+    /// Set the bucket_name (required)
+    pub fn with_bucket_name(mut self, bucket_name: impl Into<String>) -> Self {
+        self.bucket_name = Some(bucket_name.into());
+        self
+    }
+
+    /// Sets the endpoint for communicating with AWS S3, defaults to the [region endpoint]
+    ///
+    /// For example, this might be set to `"http://localhost:4566:`
+    /// for testing against a localstack instance.
+    ///
+    /// The `endpoint` field should be consistent with [`Self::with_virtual_hosted_style_request`],
+    /// i.e. if `virtual_hosted_style_request` is set to true then `endpoint`
+    /// should have the bucket name included.
+    ///
+    /// By default, only HTTPS schemes are enabled. To connect to an HTTP endpoint, enable
+    /// [`Self::with_allow_http`].
+    ///
+    /// [region endpoint]: https://docs.aws.amazon.com/general/latest/gr/s3.html
+    pub fn with_endpoint(mut self, endpoint: impl Into<String>) -> Self {
+        self.endpoint = Some(endpoint.into());
+        self
+    }
+
+    /// Set the credential provider overriding any other options
+    pub fn with_credentials(mut self, credentials: AwsCredentialProvider) -> Self {
+        self.credentials = Some(credentials);
+        self
+    }
+
+    /// Sets what protocol is allowed. If `allow_http` is :
+    /// * false (default):  Only HTTPS are allowed
+    /// * true:  HTTP and HTTPS are allowed
+    pub fn with_allow_http(mut self, allow_http: bool) -> Self {
+        self.client_options = self.client_options.with_allow_http(allow_http);
+        self
+    }
+
+    /// Sets if virtual hosted style request has to be used.
+    ///
+    /// If `virtual_hosted_style_request` is:
+    /// * false (default):  Path style request is used
+    /// * true:  Virtual hosted style request is used
+    ///
+    /// If the `endpoint` is provided then it should be
+    /// consistent with `virtual_hosted_style_request`.
+    /// i.e. if `virtual_hosted_style_request` is set to true
+    /// then `endpoint` should have bucket name included.
+    pub fn with_virtual_hosted_style_request(mut self, virtual_hosted_style_request: bool) -> Self {
+        self.virtual_hosted_style_request = virtual_hosted_style_request.into();
+        self
+    }
+
+    /// Configure this as an S3 Express One Zone Bucket
+    pub fn with_s3_express(mut self, s3_express: bool) -> Self {
+        self.s3_express = s3_express.into();
+        self
+    }
+
+    /// Set the retry configuration
+    pub fn with_retry(mut self, retry_config: RetryConfig) -> Self {
+        self.retry_config = retry_config;
+        self
+    }
+
+    /// By default instance credentials will only be fetched over [IMDSv2], as AWS recommends
+    /// against having IMDSv1 enabled on EC2 instances as it is vulnerable to [SSRF attack]
+    ///
+    /// However, certain deployment environments, such as those running old versions of kube2iam,
+    /// may not support IMDSv2. This option will enable automatic fallback to using IMDSv1
+    /// if the token endpoint returns a 403 error indicating that IMDSv2 is not supported.
+    ///
+    /// This option has no effect if not using instance credentials
+    ///
+    /// [IMDSv2]: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html
+    /// [SSRF attack]: https://aws.amazon.com/blogs/security/defense-in-depth-open-firewalls-reverse-proxies-ssrf-vulnerabilities-ec2-instance-metadata-service/
+    ///
+    pub fn with_imdsv1_fallback(mut self) -> Self {
+        self.imdsv1_fallback = true.into();
+        self
+    }
+
+    /// Sets if unsigned payload option has to be used.
+    /// See [unsigned payload option](https://docs.aws.amazon.com/AmazonS3/latest/API/sig-v4-header-based-auth.html)
+    /// * false (default): Signed payload option is used, where the checksum for the request body is computed and included when constructing a canonical request.
+    /// * true: Unsigned payload option is used. `UNSIGNED-PAYLOAD` literal is included when constructing a canonical request,
+    pub fn with_unsigned_payload(mut self, unsigned_payload: bool) -> Self {
+        self.unsigned_payload = unsigned_payload.into();
+        self
+    }
+
+    /// If enabled, [`AmazonS3`] will not fetch credentials and will not sign requests
+    ///
+    /// This can be useful when interacting with public S3 buckets that deny authorized requests
+    pub fn with_skip_signature(mut self, skip_signature: bool) -> Self {
+        self.skip_signature = skip_signature.into();
+        self
+    }
+
+    /// Sets the [checksum algorithm] which has to be used for object integrity check during upload.
+    ///
+    /// [checksum algorithm]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/checking-object-integrity.html
+    pub fn with_checksum_algorithm(mut self, checksum_algorithm: Checksum) -> Self {
+        // Convert to String to enable deferred parsing of config
+        self.checksum_algorithm = Some(checksum_algorithm.into());
+        self
+    }
+
+    /// Set the [instance metadata endpoint](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-instance-metadata.html),
+    /// used primarily within AWS EC2.
+    ///
+    /// This defaults to the IPv4 endpoint: http://169.254.169.254. One can alternatively use the IPv6
+    /// endpoint http://fd00:ec2::254.
+    pub fn with_metadata_endpoint(mut self, endpoint: impl Into<String>) -> Self {
+        self.metadata_endpoint = Some(endpoint.into());
+        self
+    }
+
+    /// Set the proxy_url to be used by the underlying client
+    pub fn with_proxy_url(mut self, proxy_url: impl Into<String>) -> Self {
+        self.client_options = self.client_options.with_proxy_url(proxy_url);
+        self
+    }
+
+    /// Set a trusted proxy CA certificate
+    pub fn with_proxy_ca_certificate(mut self, proxy_ca_certificate: impl Into<String>) -> Self {
+        self.client_options = self
+            .client_options
+            .with_proxy_ca_certificate(proxy_ca_certificate);
+        self
+    }
+
+    /// Set a list of hosts to exclude from proxy connections
+    pub fn with_proxy_excludes(mut self, proxy_excludes: impl Into<String>) -> Self {
+        self.client_options = self.client_options.with_proxy_excludes(proxy_excludes);
+        self
+    }
+
+    /// Sets the client options, overriding any already set
+    pub fn with_client_options(mut self, options: ClientOptions) -> Self {
+        self.client_options = options;
+        self
+    }
+
+    /// Configure how to provide `copy_if_not_exists`
+    pub fn with_copy_if_not_exists(mut self, config: S3CopyIfNotExists) -> Self {
+        self.copy_if_not_exists = Some(config.into());
+        self
+    }
+
+    /// Configure how to provide conditional put operations
+    pub fn with_conditional_put(mut self, config: S3ConditionalPut) -> Self {
+        self.conditional_put = Some(config.into());
+        self
+    }
+
+    /// If set to `true` will ignore any tags provided to put_opts
+    pub fn with_disable_tagging(mut self, ignore: bool) -> Self {
+        self.disable_tagging = ignore.into();
+        self
+    }
+
+    /// Use SSE-KMS for server side encryption.
+    pub fn with_sse_kms_encryption(mut self, kms_key_id: impl Into<String>) -> Self {
+        self.encryption_type = Some(ConfigValue::Parsed(S3EncryptionType::SseKms));
+        if let Some(kms_key_id) = kms_key_id.into().into() {
+            self.encryption_kms_key_id = Some(kms_key_id);
+        }
+        self
+    }
+
+    /// Use dual server side encryption for server side encryption.
+    pub fn with_dsse_kms_encryption(mut self, kms_key_id: impl Into<String>) -> Self {
+        self.encryption_type = Some(ConfigValue::Parsed(S3EncryptionType::DsseKms));
+        if let Some(kms_key_id) = kms_key_id.into().into() {
+            self.encryption_kms_key_id = Some(kms_key_id);
+        }
+        self
+    }
+
+    /// Set whether to enable bucket key for server side encryption. This overrides
+    /// the bucket default setting for bucket keys.
+    ///
+    /// When bucket keys are disabled, each object is encrypted with a unique data key.
+    /// When bucket keys are enabled, a single data key is used for the entire bucket,
+    /// reducing overhead of encryption.
+    pub fn with_bucket_key(mut self, enabled: bool) -> Self {
+        self.encryption_bucket_key_enabled = Some(ConfigValue::Parsed(enabled));
+        self
+    }
+
+    /// Create a [`AmazonS3`] instance from the provided values,
+    /// consuming `self`.
+    pub fn build(mut self) -> Result<AmazonS3> {
+        if let Some(url) = self.url.take() {
+            self.parse_url(&url)?;
+        }
+
+        let bucket = self.bucket_name.context(MissingBucketNameSnafu)?;
+        let region = self.region.unwrap_or_else(|| "us-east-1".to_string());
+        let checksum = self.checksum_algorithm.map(|x| x.get()).transpose()?;
+        let copy_if_not_exists = self.copy_if_not_exists.map(|x| x.get()).transpose()?;
+        let put_precondition = self.conditional_put.map(|x| x.get()).transpose()?;
+
+        let credentials = if let Some(credentials) = self.credentials {
+            credentials
+        } else if self.access_key_id.is_some() || self.secret_access_key.is_some() {
+            match (self.access_key_id, self.secret_access_key, self.token) {
+                (Some(key_id), Some(secret_key), token) => {
+                    info!("Using Static credential provider");
+                    let credential = AwsCredential {
+                        key_id,
+                        secret_key,
+                        token,
+                    };
+                    Arc::new(StaticCredentialProvider::new(credential)) as _
+                }
+                (None, Some(_), _) => return Err(Error::MissingAccessKeyId.into()),
+                (Some(_), None, _) => return Err(Error::MissingSecretAccessKey.into()),
+                (None, None, _) => unreachable!(),
+            }
+        } else if let (Ok(token_path), Ok(role_arn)) = (
+            std::env::var("AWS_WEB_IDENTITY_TOKEN_FILE"),
+            std::env::var("AWS_ROLE_ARN"),
+        ) {
+            // TODO: Replace with `AmazonS3Builder::credentials_from_env`
+            info!("Using WebIdentity credential provider");
+
+            let session_name = std::env::var("AWS_ROLE_SESSION_NAME")
+                .unwrap_or_else(|_| "WebIdentitySession".to_string());
+
+            let endpoint = format!("https://sts.{region}.amazonaws.com");
+
+            // Disallow non-HTTPs requests
+            let client = self
+                .client_options
+                .clone()
+                .with_allow_http(false)
+                .client()?;
+
+            let token = WebIdentityProvider {
+                token_path,
+                session_name,
+                role_arn,
+                endpoint,
+            };
+
+            Arc::new(TokenCredentialProvider::new(
+                token,
+                client,
+                self.retry_config.clone(),
+            )) as _
+        } else if let Some(uri) = self.container_credentials_relative_uri {
+            info!("Using Task credential provider");
+            Arc::new(TaskCredentialProvider {
+                url: format!("http://169.254.170.2{uri}"),
+                retry: self.retry_config.clone(),
+                // The instance metadata endpoint is access over HTTP
+                client: self.client_options.clone().with_allow_http(true).client()?,
+                cache: Default::default(),
+            }) as _
+        } else {
+            info!("Using Instance credential provider");
+
+            let token = InstanceCredentialProvider {
+                cache: Default::default(),
+                imdsv1_fallback: self.imdsv1_fallback.get()?,
+                metadata_endpoint: self
+                    .metadata_endpoint
+                    .unwrap_or_else(|| DEFAULT_METADATA_ENDPOINT.into()),
+            };
+
+            Arc::new(TokenCredentialProvider::new(
+                token,
+                self.client_options.metadata_client()?,
+                self.retry_config.clone(),
+            )) as _
+        };
+
+        let (session_provider, zonal_endpoint) = match self.s3_express.get()? {
+            true => {
+                let zone = parse_bucket_az(&bucket).context(ZoneSuffixSnafu { bucket: &bucket })?;
+
+                // https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-express-Regions-and-Zones.html
+                let endpoint = format!("https://{bucket}.s3express-{zone}.{region}.amazonaws.com");
+
+                let session = Arc::new(
+                    TokenCredentialProvider::new(
+                        SessionProvider {
+                            endpoint: endpoint.clone(),
+                            region: region.clone(),
+                            credentials: Arc::clone(&credentials),
+                        },
+                        self.client_options.client()?,
+                        self.retry_config.clone(),
+                    )
+                    .with_min_ttl(Duration::from_secs(60)), // Credentials only valid for 5 minutes
+                );
+                (Some(session as _), Some(endpoint))
+            }
+            false => (None, None),
+        };
+
+        // If `endpoint` is provided it's assumed to be consistent with `virtual_hosted_style_request` or `s3_express`.
+        // For example, if `virtual_hosted_style_request` is true then `endpoint` should have bucket name included.
+        let virtual_hosted = self.virtual_hosted_style_request.get()?;
+        let bucket_endpoint = match (&self.endpoint, zonal_endpoint, virtual_hosted) {
+            (Some(endpoint), _, true) => endpoint.clone(),
+            (Some(endpoint), _, false) => format!("{endpoint}/{bucket}"),
+            (None, Some(endpoint), _) => endpoint,
+            (None, None, true) => format!("https://{bucket}.s3.{region}.amazonaws.com"),
+            (None, None, false) => format!("https://s3.{region}.amazonaws.com/{bucket}"),
+        };
+
+        let encryption_headers = if let Some(encryption_type) = self.encryption_type {
+            S3EncryptionHeaders::try_new(
+                &encryption_type.get()?,
+                self.encryption_kms_key_id,
+                self.encryption_bucket_key_enabled
+                    .map(|val| val.get())
+                    .transpose()?,
+            )?
+        } else {
+            S3EncryptionHeaders::default()
+        };
+
+        let config = S3Config {
+            region,
+            endpoint: self.endpoint,
+            bucket,
+            bucket_endpoint,
+            credentials,
+            session_provider,
+            retry_config: self.retry_config,
+            client_options: self.client_options,
+            sign_payload: !self.unsigned_payload.get()?,
+            skip_signature: self.skip_signature.get()?,
+            disable_tagging: self.disable_tagging.get()?,
+            checksum,
+            copy_if_not_exists,
+            conditional_put: put_precondition,
+            encryption_headers,
+        };
+
+        let client = Arc::new(S3Client::new(config)?);
+
+        Ok(AmazonS3 { client })
+    }
+}
+
+/// Extracts the AZ from a S3 Express One Zone bucket name
+///
+/// <https://docs.aws.amazon.com/AmazonS3/latest/userguide/directory-bucket-naming-rules.html>
+fn parse_bucket_az(bucket: &str) -> Option<&str> {
+    Some(bucket.strip_suffix("--x-s3")?.rsplit_once("--")?.1)
+}
+
+/// Encryption configuration options for S3.
+///
+/// These options are used to configure server-side encryption for S3 objects.
+/// To configure them, pass them to [`AmazonS3Builder::with_config`].
+///
+/// Both [SSE-KMS] and [DSSE-KMS] are supported. [SSE-C] is not yet supported.
+///
+/// [SSE-KMS]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingKMSEncryption.html
+/// [DSSE-KMS]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/UsingDSSEncryption.html
+/// [SSE-C]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/ServerSideEncryptionCustomerKeys.html
+#[derive(PartialEq, Eq, Hash, Clone, Debug, Copy, Serialize, Deserialize)]
+#[non_exhaustive]
+pub enum S3EncryptionConfigKey {
+    /// Type of encryption to use. If set, must be one of "AES256", "aws:kms", or "aws:kms:dsse".
+    ServerSideEncryption,
+    /// The KMS key ID to use for server-side encryption. If set, ServerSideEncryption
+    /// must be "aws:kms" or "aws:kms:dsse".
+    KmsKeyId,
+    /// If set to true, will use the bucket's default KMS key for server-side encryption.
+    /// If set to false, will disable the use of the bucket's default KMS key for server-side encryption.
+    BucketKeyEnabled,
+}
+
+impl AsRef<str> for S3EncryptionConfigKey {
+    fn as_ref(&self) -> &str {
+        match self {
+            Self::ServerSideEncryption => "aws_server_side_encryption",
+            Self::KmsKeyId => "aws_sse_kms_key_id",
+            Self::BucketKeyEnabled => "aws_sse_bucket_key_enabled",
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+enum S3EncryptionType {
+    S3,
+    SseKms,
+    DsseKms,
+}
+
+impl crate::config::Parse for S3EncryptionType {
+    fn parse(s: &str) -> Result<Self> {
+        match s {
+            "AES256" => Ok(Self::S3),
+            "aws:kms" => Ok(Self::SseKms),
+            "aws:kms:dsse" => Ok(Self::DsseKms),
+            _ => Err(Error::InvalidEncryptionType { passed: s.into() }.into()),
+        }
+    }
+}
+
+impl From<&S3EncryptionType> for &'static str {
+    fn from(value: &S3EncryptionType) -> Self {
+        match value {
+            S3EncryptionType::S3 => "AES256",
+            S3EncryptionType::SseKms => "aws:kms",
+            S3EncryptionType::DsseKms => "aws:kms:dsse",
+        }
+    }
+}
+
+impl std::fmt::Display for S3EncryptionType {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.write_str(self.into())
+    }
+}
+
+/// A sequence of headers to be sent for write requests that specify server-side
+/// encryption.
+///
+/// Whether these headers are sent depends on both the kind of encryption set
+/// and the kind of request being made.
+#[derive(Default, Clone, Debug)]
+pub struct S3EncryptionHeaders(HeaderMap);
+
+impl S3EncryptionHeaders {
+    fn try_new(
+        encryption_type: &S3EncryptionType,
+        key_id: Option<String>,
+        bucket_key_enabled: Option<bool>,
+    ) -> Result<Self> {
+        let mut headers = HeaderMap::new();
+        // Note: if we later add support for SSE-C, we should be sure to use
+        // HeaderValue::set_sensitive to prevent the key from being logged.
+        headers.insert(
+            "x-amz-server-side-encryption",
+            HeaderValue::from_static(encryption_type.into()),
+        );
+        if let Some(key_id) = key_id {
+            headers.insert(
+                "x-amz-server-side-encryption-aws-kms-key-id",
+                key_id
+                    .try_into()
+                    .map_err(|err| Error::InvalidEncryptionHeader {
+                        header: "kms-key-id",
+                        source: Box::new(err),
+                    })?,
+            );
+        }
+        if let Some(bucket_key_enabled) = bucket_key_enabled {
+            headers.insert(
+                "x-amz-server-side-encryption-bucket-key-enabled",
+                HeaderValue::from_static(if bucket_key_enabled { "true" } else { "false" }),
+            );
+        }
+        Ok(Self(headers))
+    }
+}
+
+impl From<S3EncryptionHeaders> for HeaderMap {
+    fn from(headers: S3EncryptionHeaders) -> Self {
+        headers.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    #[test]
+    fn s3_test_config_from_map() {
+        let aws_access_key_id = "object_store:fake_access_key_id".to_string();
+        let aws_secret_access_key = "object_store:fake_secret_key".to_string();
+        let aws_default_region = "object_store:fake_default_region".to_string();
+        let aws_endpoint = "object_store:fake_endpoint".to_string();
+        let aws_session_token = "object_store:fake_session_token".to_string();
+        let options = HashMap::from([
+            ("aws_access_key_id", aws_access_key_id.clone()),
+            ("aws_secret_access_key", aws_secret_access_key),
+            ("aws_default_region", aws_default_region.clone()),
+            ("aws_endpoint", aws_endpoint.clone()),
+            ("aws_session_token", aws_session_token.clone()),
+            ("aws_unsigned_payload", "true".to_string()),
+            ("aws_checksum_algorithm", "sha256".to_string()),
+        ]);
+
+        let builder = options
+            .into_iter()
+            .fold(AmazonS3Builder::new(), |builder, (key, value)| {
+                builder.with_config(key.parse().unwrap(), value)
+            })
+            .with_config(AmazonS3ConfigKey::SecretAccessKey, "new-secret-key");
+
+        assert_eq!(builder.access_key_id.unwrap(), aws_access_key_id.as_str());
+        assert_eq!(builder.secret_access_key.unwrap(), "new-secret-key");
+        assert_eq!(builder.region.unwrap(), aws_default_region);
+        assert_eq!(builder.endpoint.unwrap(), aws_endpoint);
+        assert_eq!(builder.token.unwrap(), aws_session_token);
+        assert_eq!(
+            builder.checksum_algorithm.unwrap().get().unwrap(),
+            Checksum::SHA256
+        );
+        assert!(builder.unsigned_payload.get().unwrap());
+    }
+
+    #[test]
+    fn s3_test_config_get_value() {
+        let aws_access_key_id = "object_store:fake_access_key_id".to_string();
+        let aws_secret_access_key = "object_store:fake_secret_key".to_string();
+        let aws_default_region = "object_store:fake_default_region".to_string();
+        let aws_endpoint = "object_store:fake_endpoint".to_string();
+        let aws_session_token = "object_store:fake_session_token".to_string();
+
+        let builder = AmazonS3Builder::new()
+            .with_config(AmazonS3ConfigKey::AccessKeyId, &aws_access_key_id)
+            .with_config(AmazonS3ConfigKey::SecretAccessKey, &aws_secret_access_key)
+            .with_config(AmazonS3ConfigKey::DefaultRegion, &aws_default_region)
+            .with_config(AmazonS3ConfigKey::Endpoint, &aws_endpoint)
+            .with_config(AmazonS3ConfigKey::Token, &aws_session_token)
+            .with_config(AmazonS3ConfigKey::UnsignedPayload, "true")
+            .with_config("aws_server_side_encryption".parse().unwrap(), "AES256")
+            .with_config("aws_sse_kms_key_id".parse().unwrap(), "some_key_id")
+            .with_config("aws_sse_bucket_key_enabled".parse().unwrap(), "true");
+
+        assert_eq!(
+            builder
+                .get_config_value(&AmazonS3ConfigKey::AccessKeyId)
+                .unwrap(),
+            aws_access_key_id
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&AmazonS3ConfigKey::SecretAccessKey)
+                .unwrap(),
+            aws_secret_access_key
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&AmazonS3ConfigKey::DefaultRegion)
+                .unwrap(),
+            aws_default_region
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&AmazonS3ConfigKey::Endpoint)
+                .unwrap(),
+            aws_endpoint
+        );
+        assert_eq!(
+            builder.get_config_value(&AmazonS3ConfigKey::Token).unwrap(),
+            aws_session_token
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&AmazonS3ConfigKey::UnsignedPayload)
+                .unwrap(),
+            "true"
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&"aws_server_side_encryption".parse().unwrap())
+                .unwrap(),
+            "AES256"
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&"aws_sse_kms_key_id".parse().unwrap())
+                .unwrap(),
+            "some_key_id"
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&"aws_sse_bucket_key_enabled".parse().unwrap())
+                .unwrap(),
+            "true"
+        );
+    }
+
+    #[test]
+    fn s3_default_region() {
+        let builder = AmazonS3Builder::new()
+            .with_bucket_name("foo")
+            .build()
+            .unwrap();
+        assert_eq!(builder.client.config.region, "us-east-1");
+    }
+
+    #[test]
+    fn s3_test_urls() {
+        let mut builder = AmazonS3Builder::new();
+        builder.parse_url("s3://bucket/path").unwrap();
+        assert_eq!(builder.bucket_name, Some("bucket".to_string()));
+
+        let mut builder = AmazonS3Builder::new();
+        builder
+            .parse_url("s3://buckets.can.have.dots/path")
+            .unwrap();
+        assert_eq!(
+            builder.bucket_name,
+            Some("buckets.can.have.dots".to_string())
+        );
+
+        let mut builder = AmazonS3Builder::new();
+        builder
+            .parse_url("https://s3.region.amazonaws.com")
+            .unwrap();
+        assert_eq!(builder.region, Some("region".to_string()));
+
+        let mut builder = AmazonS3Builder::new();
+        builder
+            .parse_url("https://s3.region.amazonaws.com/bucket")
+            .unwrap();
+        assert_eq!(builder.region, Some("region".to_string()));
+        assert_eq!(builder.bucket_name, Some("bucket".to_string()));
+
+        let mut builder = AmazonS3Builder::new();
+        builder
+            .parse_url("https://s3.region.amazonaws.com/bucket.with.dot/path")
+            .unwrap();
+        assert_eq!(builder.region, Some("region".to_string()));
+        assert_eq!(builder.bucket_name, Some("bucket.with.dot".to_string()));
+
+        let mut builder = AmazonS3Builder::new();
+        builder
+            .parse_url("https://bucket.s3.region.amazonaws.com")
+            .unwrap();
+        assert_eq!(builder.bucket_name, Some("bucket".to_string()));
+        assert_eq!(builder.region, Some("region".to_string()));
+        assert!(builder.virtual_hosted_style_request.get().unwrap());
+
+        let mut builder = AmazonS3Builder::new();
+        builder
+            .parse_url("https://account123.r2.cloudflarestorage.com/bucket-123")
+            .unwrap();
+
+        assert_eq!(builder.bucket_name, Some("bucket-123".to_string()));
+        assert_eq!(builder.region, Some("auto".to_string()));
+        assert_eq!(
+            builder.endpoint,
+            Some("https://account123.r2.cloudflarestorage.com".to_string())
+        );
+
+        let err_cases = [
+            "mailto://bucket/path",
+            "https://s3.bucket.mydomain.com",
+            "https://s3.bucket.foo.amazonaws.com",
+            "https://bucket.mydomain.region.amazonaws.com",
+            "https://bucket.s3.region.bar.amazonaws.com",
+            "https://bucket.foo.s3.amazonaws.com",
+        ];
+        let mut builder = AmazonS3Builder::new();
+        for case in err_cases {
+            builder.parse_url(case).unwrap_err();
+        }
+    }
+
+    #[tokio::test]
+    async fn s3_test_proxy_url() {
+        let s3 = AmazonS3Builder::new()
+            .with_access_key_id("access_key_id")
+            .with_secret_access_key("secret_access_key")
+            .with_region("region")
+            .with_bucket_name("bucket_name")
+            .with_allow_http(true)
+            .with_proxy_url("https://example.com")
+            .build();
+
+        assert!(s3.is_ok());
+
+        let err = AmazonS3Builder::new()
+            .with_access_key_id("access_key_id")
+            .with_secret_access_key("secret_access_key")
+            .with_region("region")
+            .with_bucket_name("bucket_name")
+            .with_allow_http(true)
+            .with_proxy_url("asdf://example.com")
+            .build()
+            .unwrap_err()
+            .to_string();
+
+        assert_eq!(
+            "Generic HTTP client error: builder error: unknown proxy scheme",
+            err
+        );
+    }
+
+    #[test]
+    fn test_invalid_config() {
+        let err = AmazonS3Builder::new()
+            .with_config(AmazonS3ConfigKey::ImdsV1Fallback, "enabled")
+            .with_bucket_name("bucket")
+            .with_region("region")
+            .build()
+            .unwrap_err()
+            .to_string();
+
+        assert_eq!(
+            err,
+            "Generic Config error: failed to parse \"enabled\" as boolean"
+        );
+
+        let err = AmazonS3Builder::new()
+            .with_config(AmazonS3ConfigKey::Checksum, "md5")
+            .with_bucket_name("bucket")
+            .with_region("region")
+            .build()
+            .unwrap_err()
+            .to_string();
+
+        assert_eq!(
+            err,
+            "Generic Config error: \"md5\" is not a valid checksum algorithm"
+        );
+    }
+
+    #[test]
+    fn test_parse_bucket_az() {
+        let cases = [
+            ("bucket-base-name--usw2-az1--x-s3", Some("usw2-az1")),
+            ("bucket-base--name--azid--x-s3", Some("azid")),
+            ("bucket-base-name", None),
+            ("bucket-base-name--x-s3", None),
+        ];
+
+        for (bucket, expected) in cases {
+            assert_eq!(parse_bucket_az(bucket), expected)
+        }
+    }
+}
diff --git a/object_store/src/aws/checksum.rs b/object_store/src/aws/checksum.rs
new file mode 100644
index 000000000000..a50bd2d18b9c
--- /dev/null
+++ b/object_store/src/aws/checksum.rs
@@ -0,0 +1,78 @@
+// 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.
+
+use crate::config::Parse;
+use ring::digest::{self, digest as ring_digest};
+use std::str::FromStr;
+
+#[allow(non_camel_case_types)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// Enum representing checksum algorithm supported by S3.
+pub enum Checksum {
+    /// SHA-256 algorithm.
+    SHA256,
+}
+
+impl Checksum {
+    pub(super) fn digest(&self, bytes: &[u8]) -> Vec<u8> {
+        match self {
+            Self::SHA256 => ring_digest(&digest::SHA256, bytes).as_ref().to_owned(),
+        }
+    }
+
+    pub(super) fn header_name(&self) -> &'static str {
+        match self {
+            Self::SHA256 => "x-amz-checksum-sha256",
+        }
+    }
+}
+
+impl std::fmt::Display for Checksum {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match &self {
+            Self::SHA256 => write!(f, "sha256"),
+        }
+    }
+}
+
+impl FromStr for Checksum {
+    type Err = ();
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "sha256" => Ok(Self::SHA256),
+            _ => Err(()),
+        }
+    }
+}
+
+impl TryFrom<&String> for Checksum {
+    type Error = ();
+
+    fn try_from(value: &String) -> Result<Self, Self::Error> {
+        value.parse()
+    }
+}
+
+impl Parse for Checksum {
+    fn parse(v: &str) -> crate::Result<Self> {
+        v.parse().map_err(|_| crate::Error::Generic {
+            store: "Config",
+            source: format!("\"{v}\" is not a valid checksum algorithm").into(),
+        })
+    }
+}
diff --git a/object_store/src/aws/client.rs b/object_store/src/aws/client.rs
new file mode 100644
index 000000000000..aa9f6bf3320c
--- /dev/null
+++ b/object_store/src/aws/client.rs
@@ -0,0 +1,710 @@
+// 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.
+
+use crate::aws::builder::S3EncryptionHeaders;
+use crate::aws::checksum::Checksum;
+use crate::aws::credential::{AwsCredential, CredentialExt};
+use crate::aws::{
+    AwsAuthorizer, AwsCredentialProvider, S3ConditionalPut, S3CopyIfNotExists, STORE,
+    STRICT_PATH_ENCODE_SET,
+};
+use crate::client::get::GetClient;
+use crate::client::header::{get_etag, HeaderConfig};
+use crate::client::header::{get_put_result, get_version};
+use crate::client::list::ListClient;
+use crate::client::retry::RetryExt;
+use crate::client::s3::{
+    CompleteMultipartUpload, CompleteMultipartUploadResult, InitiateMultipartUploadResult,
+    ListResponse,
+};
+use crate::client::GetOptionsExt;
+use crate::multipart::PartId;
+use crate::path::DELIMITER;
+use crate::{
+    ClientOptions, GetOptions, ListResult, MultipartId, Path, PutResult, Result, RetryConfig,
+};
+use async_trait::async_trait;
+use base64::prelude::BASE64_STANDARD;
+use base64::Engine;
+use bytes::{Buf, Bytes};
+use hyper::http;
+use hyper::http::HeaderName;
+use itertools::Itertools;
+use md5::{Digest, Md5};
+use percent_encoding::{utf8_percent_encode, PercentEncode};
+use quick_xml::events::{self as xml_events};
+use reqwest::{
+    header::{CONTENT_LENGTH, CONTENT_TYPE},
+    Client as ReqwestClient, Method, RequestBuilder, Response,
+};
+use serde::{Deserialize, Serialize};
+use snafu::{ResultExt, Snafu};
+use std::sync::Arc;
+
+const VERSION_HEADER: &str = "x-amz-version-id";
+
+/// A specialized `Error` for object store-related errors
+#[derive(Debug, Snafu)]
+#[allow(missing_docs)]
+pub(crate) enum Error {
+    #[snafu(display("Error fetching get response body {}: {}", path, source))]
+    GetResponseBody {
+        source: reqwest::Error,
+        path: String,
+    },
+
+    #[snafu(display("Error performing DeleteObjects request: {}", source))]
+    DeleteObjectsRequest { source: crate::client::retry::Error },
+
+    #[snafu(display(
+        "DeleteObjects request failed for key {}: {} (code: {})",
+        path,
+        message,
+        code
+    ))]
+    DeleteFailed {
+        path: String,
+        code: String,
+        message: String,
+    },
+
+    #[snafu(display("Error getting DeleteObjects response body: {}", source))]
+    DeleteObjectsResponse { source: reqwest::Error },
+
+    #[snafu(display("Got invalid DeleteObjects response: {}", source))]
+    InvalidDeleteObjectsResponse {
+        source: Box<dyn std::error::Error + Send + Sync + 'static>,
+    },
+
+    #[snafu(display("Error performing list request: {}", source))]
+    ListRequest { source: crate::client::retry::Error },
+
+    #[snafu(display("Error getting list response body: {}", source))]
+    ListResponseBody { source: reqwest::Error },
+
+    #[snafu(display("Error performing create multipart request: {}", source))]
+    CreateMultipartRequest { source: crate::client::retry::Error },
+
+    #[snafu(display("Error getting create multipart response body: {}", source))]
+    CreateMultipartResponseBody { source: reqwest::Error },
+
+    #[snafu(display("Error performing complete multipart request: {}", source))]
+    CompleteMultipartRequest { source: crate::client::retry::Error },
+
+    #[snafu(display("Error getting complete multipart response body: {}", source))]
+    CompleteMultipartResponseBody { source: reqwest::Error },
+
+    #[snafu(display("Got invalid list response: {}", source))]
+    InvalidListResponse { source: quick_xml::de::DeError },
+
+    #[snafu(display("Got invalid multipart response: {}", source))]
+    InvalidMultipartResponse { source: quick_xml::de::DeError },
+
+    #[snafu(display("Unable to extract metadata from headers: {}", source))]
+    Metadata {
+        source: crate::client::header::Error,
+    },
+}
+
+impl From<Error> for crate::Error {
+    fn from(err: Error) -> Self {
+        Self::Generic {
+            store: STORE,
+            source: Box::new(err),
+        }
+    }
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "PascalCase", rename = "DeleteResult")]
+struct BatchDeleteResponse {
+    #[serde(rename = "$value")]
+    content: Vec<DeleteObjectResult>,
+}
+
+#[derive(Deserialize)]
+enum DeleteObjectResult {
+    Deleted(DeletedObject),
+    Error(DeleteError),
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "PascalCase", rename = "Deleted")]
+struct DeletedObject {
+    #[allow(dead_code)]
+    key: String,
+}
+
+#[derive(Deserialize)]
+#[serde(rename_all = "PascalCase", rename = "Error")]
+struct DeleteError {
+    key: String,
+    code: String,
+    message: String,
+}
+
+impl From<DeleteError> for Error {
+    fn from(err: DeleteError) -> Self {
+        Self::DeleteFailed {
+            path: err.key,
+            code: err.code,
+            message: err.message,
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct S3Config {
+    pub region: String,
+    pub endpoint: Option<String>,
+    pub bucket: String,
+    pub bucket_endpoint: String,
+    pub credentials: AwsCredentialProvider,
+    pub session_provider: Option<AwsCredentialProvider>,
+    pub retry_config: RetryConfig,
+    pub client_options: ClientOptions,
+    pub sign_payload: bool,
+    pub skip_signature: bool,
+    pub disable_tagging: bool,
+    pub checksum: Option<Checksum>,
+    pub copy_if_not_exists: Option<S3CopyIfNotExists>,
+    pub conditional_put: Option<S3ConditionalPut>,
+    pub encryption_headers: S3EncryptionHeaders,
+}
+
+impl S3Config {
+    pub(crate) fn path_url(&self, path: &Path) -> String {
+        format!("{}/{}", self.bucket_endpoint, encode_path(path))
+    }
+
+    async fn get_session_credential(&self) -> Result<SessionCredential<'_>> {
+        let credential = match self.skip_signature {
+            false => {
+                let provider = self.session_provider.as_ref().unwrap_or(&self.credentials);
+                Some(provider.get_credential().await?)
+            }
+            true => None,
+        };
+
+        Ok(SessionCredential {
+            credential,
+            session_token: self.session_provider.is_some(),
+            config: self,
+        })
+    }
+
+    pub(crate) async fn get_credential(&self) -> Result<Option<Arc<AwsCredential>>> {
+        Ok(match self.skip_signature {
+            false => Some(self.credentials.get_credential().await?),
+            true => None,
+        })
+    }
+
+    #[inline]
+    pub(crate) fn is_s3_express(&self) -> bool {
+        self.session_provider.is_some()
+    }
+}
+
+struct SessionCredential<'a> {
+    credential: Option<Arc<AwsCredential>>,
+    session_token: bool,
+    config: &'a S3Config,
+}
+
+impl<'a> SessionCredential<'a> {
+    fn authorizer(&self) -> Option<AwsAuthorizer<'_>> {
+        let mut authorizer =
+            AwsAuthorizer::new(self.credential.as_deref()?, "s3", &self.config.region)
+                .with_sign_payload(self.config.sign_payload);
+
+        if self.session_token {
+            let token = HeaderName::from_static("x-amz-s3session-token");
+            authorizer = authorizer.with_token_header(token)
+        }
+
+        Some(authorizer)
+    }
+}
+
+#[derive(Debug, Snafu)]
+pub enum RequestError {
+    #[snafu(context(false))]
+    Generic { source: crate::Error },
+    Retry {
+        source: crate::client::retry::Error,
+        path: String,
+    },
+}
+
+impl From<RequestError> for crate::Error {
+    fn from(value: RequestError) -> Self {
+        match value {
+            RequestError::Generic { source } => source,
+            RequestError::Retry { source, path } => source.error(STORE, path),
+        }
+    }
+}
+
+/// A builder for a request allowing customisation of the headers and query string
+pub(crate) struct Request<'a> {
+    path: &'a Path,
+    config: &'a S3Config,
+    builder: RequestBuilder,
+    payload_sha256: Option<Vec<u8>>,
+    use_session_creds: bool,
+}
+
+impl<'a> Request<'a> {
+    pub fn query<T: Serialize + ?Sized + Sync>(self, query: &T) -> Self {
+        let builder = self.builder.query(query);
+        Self { builder, ..self }
+    }
+
+    pub fn header<K>(self, k: K, v: &str) -> Self
+    where
+        HeaderName: TryFrom<K>,
+        <HeaderName as TryFrom<K>>::Error: Into<http::Error>,
+    {
+        let builder = self.builder.header(k, v);
+        Self { builder, ..self }
+    }
+
+    pub async fn send(self) -> Result<Response, RequestError> {
+        let credential = match self.use_session_creds {
+            true => self.config.get_session_credential().await?,
+            false => SessionCredential {
+                credential: self.config.get_credential().await?,
+                session_token: false,
+                config: self.config,
+            },
+        };
+
+        let path = self.path.as_ref();
+        self.builder
+            .with_aws_sigv4(credential.authorizer(), self.payload_sha256.as_deref())
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(RetrySnafu { path })
+    }
+
+    pub async fn do_put(self) -> Result<PutResult> {
+        let response = self.send().await?;
+        Ok(get_put_result(response.headers(), VERSION_HEADER).context(MetadataSnafu)?)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct S3Client {
+    pub config: S3Config,
+    pub client: ReqwestClient,
+}
+
+impl S3Client {
+    pub fn new(config: S3Config) -> Result<Self> {
+        let client = config.client_options.client()?;
+        Ok(Self { config, client })
+    }
+
+    /// Make an S3 PUT request <https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html>
+    ///
+    /// Returns the ETag
+    pub fn put_request<'a>(
+        &'a self,
+        path: &'a Path,
+        bytes: Bytes,
+        with_encryption_headers: bool,
+    ) -> Request<'a> {
+        let url = self.config.path_url(path);
+        let mut builder = self.client.request(Method::PUT, url);
+        if with_encryption_headers {
+            builder = builder.headers(self.config.encryption_headers.clone().into());
+        }
+        let mut payload_sha256 = None;
+
+        if let Some(checksum) = self.config.checksum {
+            let digest = checksum.digest(&bytes);
+            builder = builder.header(checksum.header_name(), BASE64_STANDARD.encode(&digest));
+            if checksum == Checksum::SHA256 {
+                payload_sha256 = Some(digest);
+            }
+        }
+
+        builder = match bytes.is_empty() {
+            true => builder.header(CONTENT_LENGTH, 0), // Handle empty uploads (#4514)
+            false => builder.body(bytes),
+        };
+
+        if let Some(value) = self.config.client_options.get_content_type(path) {
+            builder = builder.header(CONTENT_TYPE, value);
+        }
+
+        Request {
+            path,
+            builder,
+            payload_sha256,
+            config: &self.config,
+            use_session_creds: true,
+        }
+    }
+
+    /// Make an S3 Delete request <https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObject.html>
+    pub async fn delete_request<T: Serialize + ?Sized + Sync>(
+        &self,
+        path: &Path,
+        query: &T,
+    ) -> Result<()> {
+        let credential = self.config.get_session_credential().await?;
+        let url = self.config.path_url(path);
+
+        self.client
+            .request(Method::DELETE, url)
+            .query(query)
+            .with_aws_sigv4(credential.authorizer(), None)
+            .send_retry(&self.config.retry_config)
+            .await
+            .map_err(|e| e.error(STORE, path.to_string()))?;
+
+        Ok(())
+    }
+
+    /// Make an S3 Delete Objects request <https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjects.html>
+    ///
+    /// Produces a vector of results, one for each path in the input vector. If
+    /// the delete was successful, the path is returned in the `Ok` variant. If
+    /// there was an error for a certain path, the error will be returned in the
+    /// vector. If there was an issue with making the overall request, an error
+    /// will be returned at the top level.
+    pub async fn bulk_delete_request(&self, paths: Vec<Path>) -> Result<Vec<Result<Path>>> {
+        if paths.is_empty() {
+            return Ok(Vec::new());
+        }
+
+        let credential = self.config.get_session_credential().await?;
+        let url = format!("{}?delete", self.config.bucket_endpoint);
+
+        let mut buffer = Vec::new();
+        let mut writer = quick_xml::Writer::new(&mut buffer);
+        writer
+            .write_event(xml_events::Event::Start(
+                xml_events::BytesStart::new("Delete")
+                    .with_attributes([("xmlns", "http://s3.amazonaws.com/doc/2006-03-01/")]),
+            ))
+            .unwrap();
+        for path in &paths {
+            // <Object><Key>{path}</Key></Object>
+            writer
+                .write_event(xml_events::Event::Start(xml_events::BytesStart::new(
+                    "Object",
+                )))
+                .unwrap();
+            writer
+                .write_event(xml_events::Event::Start(xml_events::BytesStart::new("Key")))
+                .unwrap();
+            writer
+                .write_event(xml_events::Event::Text(xml_events::BytesText::new(
+                    path.as_ref(),
+                )))
+                .map_err(|err| crate::Error::Generic {
+                    store: STORE,
+                    source: Box::new(err),
+                })?;
+            writer
+                .write_event(xml_events::Event::End(xml_events::BytesEnd::new("Key")))
+                .unwrap();
+            writer
+                .write_event(xml_events::Event::End(xml_events::BytesEnd::new("Object")))
+                .unwrap();
+        }
+        writer
+            .write_event(xml_events::Event::End(xml_events::BytesEnd::new("Delete")))
+            .unwrap();
+
+        let body = Bytes::from(buffer);
+
+        let mut builder = self.client.request(Method::POST, url);
+
+        // Compute checksum - S3 *requires* this for DeleteObjects requests, so we default to
+        // their algorithm if the user hasn't specified one.
+        let checksum = self.config.checksum.unwrap_or(Checksum::SHA256);
+        let digest = checksum.digest(&body);
+        builder = builder.header(checksum.header_name(), BASE64_STANDARD.encode(&digest));
+        let payload_sha256 = if checksum == Checksum::SHA256 {
+            Some(digest)
+        } else {
+            None
+        };
+
+        // S3 *requires* DeleteObjects to include a Content-MD5 header:
+        // https://docs.aws.amazon.com/AmazonS3/latest/API/API_DeleteObjects.html
+        // >   "The Content-MD5 request header is required for all Multi-Object Delete requests"
+        // Some platforms, like MinIO, enforce this requirement and fail requests without the header.
+        let mut hasher = Md5::new();
+        hasher.update(&body);
+        builder = builder.header("Content-MD5", BASE64_STANDARD.encode(hasher.finalize()));
+
+        let response = builder
+            .header(CONTENT_TYPE, "application/xml")
+            .body(body)
+            .with_aws_sigv4(credential.authorizer(), payload_sha256.as_deref())
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(DeleteObjectsRequestSnafu {})?
+            .bytes()
+            .await
+            .context(DeleteObjectsResponseSnafu {})?;
+
+        let response: BatchDeleteResponse =
+            quick_xml::de::from_reader(response.reader()).map_err(|err| {
+                Error::InvalidDeleteObjectsResponse {
+                    source: Box::new(err),
+                }
+            })?;
+
+        // Assume all were ok, then fill in errors. This guarantees output order
+        // matches input order.
+        let mut results: Vec<Result<Path>> = paths.iter().cloned().map(Ok).collect();
+        for content in response.content.into_iter() {
+            if let DeleteObjectResult::Error(error) = content {
+                let path =
+                    Path::parse(&error.key).map_err(|err| Error::InvalidDeleteObjectsResponse {
+                        source: Box::new(err),
+                    })?;
+                let i = paths.iter().find_position(|&p| p == &path).unwrap().0;
+                results[i] = Err(Error::from(error).into());
+            }
+        }
+
+        Ok(results)
+    }
+
+    /// Make an S3 Copy request <https://docs.aws.amazon.com/AmazonS3/latest/API/API_CopyObject.html>
+    pub fn copy_request<'a>(&'a self, from: &'a Path, to: &Path) -> Request<'a> {
+        let url = self.config.path_url(to);
+        let source = format!("{}/{}", self.config.bucket, encode_path(from));
+
+        let builder = self
+            .client
+            .request(Method::PUT, url)
+            .header("x-amz-copy-source", source)
+            .headers(self.config.encryption_headers.clone().into());
+
+        Request {
+            builder,
+            path: from,
+            config: &self.config,
+            payload_sha256: None,
+            use_session_creds: false,
+        }
+    }
+
+    pub async fn create_multipart(&self, location: &Path) -> Result<MultipartId> {
+        let credential = self.config.get_session_credential().await?;
+        let url = format!("{}?uploads=", self.config.path_url(location),);
+
+        let response = self
+            .client
+            .request(Method::POST, url)
+            .headers(self.config.encryption_headers.clone().into())
+            .with_aws_sigv4(credential.authorizer(), None)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(CreateMultipartRequestSnafu)?
+            .bytes()
+            .await
+            .context(CreateMultipartResponseBodySnafu)?;
+
+        let response: InitiateMultipartUploadResult =
+            quick_xml::de::from_reader(response.reader()).context(InvalidMultipartResponseSnafu)?;
+
+        Ok(response.upload_id)
+    }
+
+    pub async fn put_part(
+        &self,
+        path: &Path,
+        upload_id: &MultipartId,
+        part_idx: usize,
+        data: Bytes,
+    ) -> Result<PartId> {
+        let part = (part_idx + 1).to_string();
+
+        let response = self
+            .put_request(path, data, false)
+            .query(&[("partNumber", &part), ("uploadId", upload_id)])
+            .send()
+            .await?;
+
+        let content_id = get_etag(response.headers()).context(MetadataSnafu)?;
+        Ok(PartId { content_id })
+    }
+
+    pub async fn complete_multipart(
+        &self,
+        location: &Path,
+        upload_id: &str,
+        parts: Vec<PartId>,
+    ) -> Result<PutResult> {
+        let parts = if parts.is_empty() {
+            // If no parts were uploaded, upload an empty part
+            // otherwise the completion request will fail
+            let part = self
+                .put_part(location, &upload_id.to_string(), 0, Bytes::new())
+                .await?;
+            vec![part]
+        } else {
+            parts
+        };
+        let request = CompleteMultipartUpload::from(parts);
+        let body = quick_xml::se::to_string(&request).unwrap();
+
+        let credential = self.config.get_session_credential().await?;
+        let url = self.config.path_url(location);
+
+        let response = self
+            .client
+            .request(Method::POST, url)
+            .query(&[("uploadId", upload_id)])
+            .body(body)
+            .with_aws_sigv4(credential.authorizer(), None)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(CompleteMultipartRequestSnafu)?;
+
+        let version = get_version(response.headers(), VERSION_HEADER).context(MetadataSnafu)?;
+
+        let data = response
+            .bytes()
+            .await
+            .context(CompleteMultipartResponseBodySnafu)?;
+
+        let response: CompleteMultipartUploadResult =
+            quick_xml::de::from_reader(data.reader()).context(InvalidMultipartResponseSnafu)?;
+
+        Ok(PutResult {
+            e_tag: Some(response.e_tag),
+            version,
+        })
+    }
+
+    #[cfg(test)]
+    pub async fn get_object_tagging(&self, path: &Path) -> Result<Response> {
+        let credential = self.config.get_session_credential().await?;
+        let url = format!("{}?tagging", self.config.path_url(path));
+        let response = self
+            .client
+            .request(Method::GET, url)
+            .with_aws_sigv4(credential.authorizer(), None)
+            .send_retry(&self.config.retry_config)
+            .await
+            .map_err(|e| e.error(STORE, path.to_string()))?;
+        Ok(response)
+    }
+}
+
+#[async_trait]
+impl GetClient for S3Client {
+    const STORE: &'static str = STORE;
+
+    const HEADER_CONFIG: HeaderConfig = HeaderConfig {
+        etag_required: false,
+        last_modified_required: false,
+        version_header: Some(VERSION_HEADER),
+    };
+
+    /// Make an S3 GET request <https://docs.aws.amazon.com/AmazonS3/latest/API/API_GetObject.html>
+    async fn get_request(&self, path: &Path, options: GetOptions) -> Result<Response> {
+        let credential = self.config.get_session_credential().await?;
+        let url = self.config.path_url(path);
+        let method = match options.head {
+            true => Method::HEAD,
+            false => Method::GET,
+        };
+
+        let mut builder = self.client.request(method, url);
+
+        if let Some(v) = &options.version {
+            builder = builder.query(&[("versionId", v)])
+        }
+
+        let response = builder
+            .with_get_options(options)
+            .with_aws_sigv4(credential.authorizer(), None)
+            .send_retry(&self.config.retry_config)
+            .await
+            .map_err(|e| e.error(STORE, path.to_string()))?;
+
+        Ok(response)
+    }
+}
+
+#[async_trait]
+impl ListClient for S3Client {
+    /// Make an S3 List request <https://docs.aws.amazon.com/AmazonS3/latest/API/API_ListObjectsV2.html>
+    async fn list_request(
+        &self,
+        prefix: Option<&str>,
+        delimiter: bool,
+        token: Option<&str>,
+        offset: Option<&str>,
+    ) -> Result<(ListResult, Option<String>)> {
+        let credential = self.config.get_session_credential().await?;
+        let url = self.config.bucket_endpoint.clone();
+
+        let mut query = Vec::with_capacity(4);
+
+        if let Some(token) = token {
+            query.push(("continuation-token", token))
+        }
+
+        if delimiter {
+            query.push(("delimiter", DELIMITER))
+        }
+
+        query.push(("list-type", "2"));
+
+        if let Some(prefix) = prefix {
+            query.push(("prefix", prefix))
+        }
+
+        if let Some(offset) = offset {
+            query.push(("start-after", offset))
+        }
+
+        let response = self
+            .client
+            .request(Method::GET, &url)
+            .query(&query)
+            .with_aws_sigv4(credential.authorizer(), None)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(ListRequestSnafu)?
+            .bytes()
+            .await
+            .context(ListResponseBodySnafu)?;
+
+        let mut response: ListResponse =
+            quick_xml::de::from_reader(response.reader()).context(InvalidListResponseSnafu)?;
+        let token = response.next_continuation_token.take();
+
+        Ok((response.try_into()?, token))
+    }
+}
+
+fn encode_path(path: &Path) -> PercentEncode<'_> {
+    utf8_percent_encode(path.as_ref(), &STRICT_PATH_ENCODE_SET)
+}
diff --git a/object_store/src/aws/credential.rs b/object_store/src/aws/credential.rs
new file mode 100644
index 000000000000..f8614f4f563c
--- /dev/null
+++ b/object_store/src/aws/credential.rs
@@ -0,0 +1,1032 @@
+// 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.
+
+use crate::aws::{AwsCredentialProvider, STORE, STRICT_ENCODE_SET, STRICT_PATH_ENCODE_SET};
+use crate::client::retry::RetryExt;
+use crate::client::token::{TemporaryToken, TokenCache};
+use crate::client::TokenProvider;
+use crate::util::hmac_sha256;
+use crate::{CredentialProvider, Result, RetryConfig};
+use async_trait::async_trait;
+use bytes::Buf;
+use chrono::{DateTime, Utc};
+use hyper::header::HeaderName;
+use percent_encoding::utf8_percent_encode;
+use reqwest::header::{HeaderMap, HeaderValue, AUTHORIZATION};
+use reqwest::{Client, Method, Request, RequestBuilder, StatusCode};
+use serde::Deserialize;
+use snafu::{ResultExt, Snafu};
+use std::collections::BTreeMap;
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tracing::warn;
+use url::Url;
+
+#[derive(Debug, Snafu)]
+#[allow(clippy::enum_variant_names)]
+enum Error {
+    #[snafu(display("Error performing CreateSession request: {source}"))]
+    CreateSessionRequest { source: crate::client::retry::Error },
+
+    #[snafu(display("Error getting CreateSession response: {source}"))]
+    CreateSessionResponse { source: reqwest::Error },
+
+    #[snafu(display("Invalid CreateSessionOutput response: {source}"))]
+    CreateSessionOutput { source: quick_xml::DeError },
+}
+
+impl From<Error> for crate::Error {
+    fn from(value: Error) -> Self {
+        Self::Generic {
+            store: STORE,
+            source: Box::new(value),
+        }
+    }
+}
+
+type StdError = Box<dyn std::error::Error + Send + Sync>;
+
+/// SHA256 hash of empty string
+static EMPTY_SHA256_HASH: &str = "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855";
+static UNSIGNED_PAYLOAD: &str = "UNSIGNED-PAYLOAD";
+static STREAMING_PAYLOAD: &str = "STREAMING-AWS4-HMAC-SHA256-PAYLOAD";
+
+/// A set of AWS security credentials
+#[derive(Debug, Eq, PartialEq)]
+pub struct AwsCredential {
+    /// AWS_ACCESS_KEY_ID
+    pub key_id: String,
+    /// AWS_SECRET_ACCESS_KEY
+    pub secret_key: String,
+    /// AWS_SESSION_TOKEN
+    pub token: Option<String>,
+}
+
+impl AwsCredential {
+    /// Signs a string
+    ///
+    /// <https://docs.aws.amazon.com/general/latest/gr/sigv4-calculate-signature.html>
+    fn sign(&self, to_sign: &str, date: DateTime<Utc>, region: &str, service: &str) -> String {
+        let date_string = date.format("%Y%m%d").to_string();
+        let date_hmac = hmac_sha256(format!("AWS4{}", self.secret_key), date_string);
+        let region_hmac = hmac_sha256(date_hmac, region);
+        let service_hmac = hmac_sha256(region_hmac, service);
+        let signing_hmac = hmac_sha256(service_hmac, b"aws4_request");
+        hex_encode(hmac_sha256(signing_hmac, to_sign).as_ref())
+    }
+}
+
+/// Authorize a [`Request`] with an [`AwsCredential`] using [AWS SigV4]
+///
+/// [AWS SigV4]: https://docs.aws.amazon.com/general/latest/gr/sigv4-calculate-signature.html
+#[derive(Debug)]
+pub struct AwsAuthorizer<'a> {
+    date: Option<DateTime<Utc>>,
+    credential: &'a AwsCredential,
+    service: &'a str,
+    region: &'a str,
+    token_header: Option<HeaderName>,
+    sign_payload: bool,
+}
+
+static DATE_HEADER: HeaderName = HeaderName::from_static("x-amz-date");
+static HASH_HEADER: HeaderName = HeaderName::from_static("x-amz-content-sha256");
+static TOKEN_HEADER: HeaderName = HeaderName::from_static("x-amz-security-token");
+const ALGORITHM: &str = "AWS4-HMAC-SHA256";
+
+impl<'a> AwsAuthorizer<'a> {
+    /// Create a new [`AwsAuthorizer`]
+    pub fn new(credential: &'a AwsCredential, service: &'a str, region: &'a str) -> Self {
+        Self {
+            credential,
+            service,
+            region,
+            date: None,
+            sign_payload: true,
+            token_header: None,
+        }
+    }
+
+    /// Controls whether this [`AwsAuthorizer`] will attempt to sign the request payload,
+    /// the default is `true`
+    pub fn with_sign_payload(mut self, signed: bool) -> Self {
+        self.sign_payload = signed;
+        self
+    }
+
+    /// Overrides the header name for security tokens, defaults to `x-amz-security-token`
+    pub(crate) fn with_token_header(mut self, header: HeaderName) -> Self {
+        self.token_header = Some(header);
+        self
+    }
+
+    /// Authorize `request` with an optional pre-calculated SHA256 digest by attaching
+    /// the relevant [AWS SigV4] headers
+    ///
+    /// # Payload Signature
+    ///
+    /// AWS SigV4 requests must contain the `x-amz-content-sha256` header, it is set as follows:
+    ///
+    /// * If not configured to sign payloads, it is set to `UNSIGNED-PAYLOAD`
+    /// * If a `pre_calculated_digest` is provided, it is set to the hex encoding of it
+    /// * If it is a streaming request, it is set to `STREAMING-AWS4-HMAC-SHA256-PAYLOAD`
+    /// * Otherwise it is set to the hex encoded SHA256 of the request body
+    ///
+    /// [AWS SigV4]: https://docs.aws.amazon.com/IAM/latest/UserGuide/create-signed-request.html
+    pub fn authorize(&self, request: &mut Request, pre_calculated_digest: Option<&[u8]>) {
+        if let Some(ref token) = self.credential.token {
+            let token_val = HeaderValue::from_str(token).unwrap();
+            let header = self.token_header.as_ref().unwrap_or(&TOKEN_HEADER);
+            request.headers_mut().insert(header, token_val);
+        }
+
+        let host = &request.url()[url::Position::BeforeHost..url::Position::AfterPort];
+        let host_val = HeaderValue::from_str(host).unwrap();
+        request.headers_mut().insert("host", host_val);
+
+        let date = self.date.unwrap_or_else(Utc::now);
+        let date_str = date.format("%Y%m%dT%H%M%SZ").to_string();
+        let date_val = HeaderValue::from_str(&date_str).unwrap();
+        request.headers_mut().insert(&DATE_HEADER, date_val);
+
+        let digest = match self.sign_payload {
+            false => UNSIGNED_PAYLOAD.to_string(),
+            true => match pre_calculated_digest {
+                Some(digest) => hex_encode(digest),
+                None => match request.body() {
+                    None => EMPTY_SHA256_HASH.to_string(),
+                    Some(body) => match body.as_bytes() {
+                        Some(bytes) => hex_digest(bytes),
+                        None => STREAMING_PAYLOAD.to_string(),
+                    },
+                },
+            },
+        };
+
+        let header_digest = HeaderValue::from_str(&digest).unwrap();
+        request.headers_mut().insert(&HASH_HEADER, header_digest);
+
+        let (signed_headers, canonical_headers) = canonicalize_headers(request.headers());
+
+        let scope = self.scope(date);
+
+        let string_to_sign = self.string_to_sign(
+            date,
+            &scope,
+            request.method(),
+            request.url(),
+            &canonical_headers,
+            &signed_headers,
+            &digest,
+        );
+
+        // sign the string
+        let signature = self
+            .credential
+            .sign(&string_to_sign, date, self.region, self.service);
+
+        // build the actual auth header
+        let authorisation = format!(
+            "{} Credential={}/{}, SignedHeaders={}, Signature={}",
+            ALGORITHM, self.credential.key_id, scope, signed_headers, signature
+        );
+
+        let authorization_val = HeaderValue::from_str(&authorisation).unwrap();
+        request
+            .headers_mut()
+            .insert(&AUTHORIZATION, authorization_val);
+    }
+
+    pub(crate) fn sign(&self, method: Method, url: &mut Url, expires_in: Duration) {
+        let date = self.date.unwrap_or_else(Utc::now);
+        let scope = self.scope(date);
+
+        // https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
+        url.query_pairs_mut()
+            .append_pair("X-Amz-Algorithm", ALGORITHM)
+            .append_pair(
+                "X-Amz-Credential",
+                &format!("{}/{}", self.credential.key_id, scope),
+            )
+            .append_pair("X-Amz-Date", &date.format("%Y%m%dT%H%M%SZ").to_string())
+            .append_pair("X-Amz-Expires", &expires_in.as_secs().to_string())
+            .append_pair("X-Amz-SignedHeaders", "host");
+
+        // For S3, you must include the X-Amz-Security-Token query parameter in the URL if
+        // using credentials sourced from the STS service.
+        if let Some(ref token) = self.credential.token {
+            url.query_pairs_mut()
+                .append_pair("X-Amz-Security-Token", token);
+        }
+
+        // We don't have a payload; the user is going to send the payload directly themselves.
+        let digest = UNSIGNED_PAYLOAD;
+
+        let host = &url[url::Position::BeforeHost..url::Position::AfterPort].to_string();
+        let mut headers = HeaderMap::new();
+        let host_val = HeaderValue::from_str(host).unwrap();
+        headers.insert("host", host_val);
+
+        let (signed_headers, canonical_headers) = canonicalize_headers(&headers);
+
+        let string_to_sign = self.string_to_sign(
+            date,
+            &scope,
+            &method,
+            url,
+            &canonical_headers,
+            &signed_headers,
+            digest,
+        );
+
+        let signature = self
+            .credential
+            .sign(&string_to_sign, date, self.region, self.service);
+
+        url.query_pairs_mut()
+            .append_pair("X-Amz-Signature", &signature);
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn string_to_sign(
+        &self,
+        date: DateTime<Utc>,
+        scope: &str,
+        request_method: &Method,
+        url: &Url,
+        canonical_headers: &str,
+        signed_headers: &str,
+        digest: &str,
+    ) -> String {
+        // Each path segment must be URI-encoded twice (except for Amazon S3 which only gets
+        // URI-encoded once).
+        // see https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+        let canonical_uri = match self.service {
+            "s3" => url.path().to_string(),
+            _ => utf8_percent_encode(url.path(), &STRICT_PATH_ENCODE_SET).to_string(),
+        };
+
+        let canonical_query = canonicalize_query(url);
+
+        // https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+        let canonical_request = format!(
+            "{}\n{}\n{}\n{}\n{}\n{}",
+            request_method.as_str(),
+            canonical_uri,
+            canonical_query,
+            canonical_headers,
+            signed_headers,
+            digest
+        );
+
+        let hashed_canonical_request = hex_digest(canonical_request.as_bytes());
+
+        format!(
+            "{}\n{}\n{}\n{}",
+            ALGORITHM,
+            date.format("%Y%m%dT%H%M%SZ"),
+            scope,
+            hashed_canonical_request
+        )
+    }
+
+    fn scope(&self, date: DateTime<Utc>) -> String {
+        format!(
+            "{}/{}/{}/aws4_request",
+            date.format("%Y%m%d"),
+            self.region,
+            self.service
+        )
+    }
+}
+
+pub trait CredentialExt {
+    /// Sign a request <https://docs.aws.amazon.com/general/latest/gr/sigv4_signing.html>
+    fn with_aws_sigv4(
+        self,
+        authorizer: Option<AwsAuthorizer<'_>>,
+        payload_sha256: Option<&[u8]>,
+    ) -> Self;
+}
+
+impl CredentialExt for RequestBuilder {
+    fn with_aws_sigv4(
+        self,
+        authorizer: Option<AwsAuthorizer<'_>>,
+        payload_sha256: Option<&[u8]>,
+    ) -> Self {
+        match authorizer {
+            Some(authorizer) => {
+                let (client, request) = self.build_split();
+                let mut request = request.expect("request valid");
+                authorizer.authorize(&mut request, payload_sha256);
+
+                Self::from_parts(client, request)
+            }
+            None => self,
+        }
+    }
+}
+
+/// Computes the SHA256 digest of `body` returned as a hex encoded string
+fn hex_digest(bytes: &[u8]) -> String {
+    let digest = ring::digest::digest(&ring::digest::SHA256, bytes);
+    hex_encode(digest.as_ref())
+}
+
+/// Returns `bytes` as a lower-case hex encoded string
+fn hex_encode(bytes: &[u8]) -> String {
+    use std::fmt::Write;
+    let mut out = String::with_capacity(bytes.len() * 2);
+    for byte in bytes {
+        // String writing is infallible
+        let _ = write!(out, "{byte:02x}");
+    }
+    out
+}
+
+/// Canonicalizes query parameters into the AWS canonical form
+///
+/// <https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html>
+fn canonicalize_query(url: &Url) -> String {
+    use std::fmt::Write;
+
+    let capacity = match url.query() {
+        Some(q) if !q.is_empty() => q.len(),
+        _ => return String::new(),
+    };
+    let mut encoded = String::with_capacity(capacity + 1);
+
+    let mut headers = url.query_pairs().collect::<Vec<_>>();
+    headers.sort_unstable_by(|(a, _), (b, _)| a.cmp(b));
+
+    let mut first = true;
+    for (k, v) in headers {
+        if !first {
+            encoded.push('&');
+        }
+        first = false;
+        let _ = write!(
+            encoded,
+            "{}={}",
+            utf8_percent_encode(k.as_ref(), &STRICT_ENCODE_SET),
+            utf8_percent_encode(v.as_ref(), &STRICT_ENCODE_SET)
+        );
+    }
+    encoded
+}
+
+/// Canonicalizes headers into the AWS Canonical Form.
+///
+/// <https://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html>
+fn canonicalize_headers(header_map: &HeaderMap) -> (String, String) {
+    let mut headers = BTreeMap::<&str, Vec<&str>>::new();
+    let mut value_count = 0;
+    let mut value_bytes = 0;
+    let mut key_bytes = 0;
+
+    for (key, value) in header_map {
+        let key = key.as_str();
+        if ["authorization", "content-length", "user-agent"].contains(&key) {
+            continue;
+        }
+
+        let value = std::str::from_utf8(value.as_bytes()).unwrap();
+        key_bytes += key.len();
+        value_bytes += value.len();
+        value_count += 1;
+        headers.entry(key).or_default().push(value);
+    }
+
+    let mut signed_headers = String::with_capacity(key_bytes + headers.len());
+    let mut canonical_headers =
+        String::with_capacity(key_bytes + value_bytes + headers.len() + value_count);
+
+    for (header_idx, (name, values)) in headers.into_iter().enumerate() {
+        if header_idx != 0 {
+            signed_headers.push(';');
+        }
+
+        signed_headers.push_str(name);
+        canonical_headers.push_str(name);
+        canonical_headers.push(':');
+        for (value_idx, value) in values.into_iter().enumerate() {
+            if value_idx != 0 {
+                canonical_headers.push(',');
+            }
+            canonical_headers.push_str(value.trim());
+        }
+        canonical_headers.push('\n');
+    }
+
+    (signed_headers, canonical_headers)
+}
+
+/// Credentials sourced from the instance metadata service
+///
+/// <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/configuring-instance-metadata-service.html>
+#[derive(Debug)]
+pub struct InstanceCredentialProvider {
+    pub cache: TokenCache<Arc<AwsCredential>>,
+    pub imdsv1_fallback: bool,
+    pub metadata_endpoint: String,
+}
+
+#[async_trait]
+impl TokenProvider for InstanceCredentialProvider {
+    type Credential = AwsCredential;
+
+    async fn fetch_token(
+        &self,
+        client: &Client,
+        retry: &RetryConfig,
+    ) -> Result<TemporaryToken<Arc<AwsCredential>>> {
+        instance_creds(client, retry, &self.metadata_endpoint, self.imdsv1_fallback)
+            .await
+            .map_err(|source| crate::Error::Generic {
+                store: STORE,
+                source,
+            })
+    }
+}
+
+/// Credentials sourced using AssumeRoleWithWebIdentity
+///
+/// <https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts-technical-overview.html>
+#[derive(Debug)]
+pub struct WebIdentityProvider {
+    pub token_path: String,
+    pub role_arn: String,
+    pub session_name: String,
+    pub endpoint: String,
+}
+
+#[async_trait]
+impl TokenProvider for WebIdentityProvider {
+    type Credential = AwsCredential;
+
+    async fn fetch_token(
+        &self,
+        client: &Client,
+        retry: &RetryConfig,
+    ) -> Result<TemporaryToken<Arc<AwsCredential>>> {
+        web_identity(
+            client,
+            retry,
+            &self.token_path,
+            &self.role_arn,
+            &self.session_name,
+            &self.endpoint,
+        )
+        .await
+        .map_err(|source| crate::Error::Generic {
+            store: STORE,
+            source,
+        })
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct InstanceCredentials {
+    access_key_id: String,
+    secret_access_key: String,
+    token: String,
+    expiration: DateTime<Utc>,
+}
+
+impl From<InstanceCredentials> for AwsCredential {
+    fn from(s: InstanceCredentials) -> Self {
+        Self {
+            key_id: s.access_key_id,
+            secret_key: s.secret_access_key,
+            token: Some(s.token),
+        }
+    }
+}
+
+/// <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/iam-roles-for-amazon-ec2.html#instance-metadata-security-credentials>
+async fn instance_creds(
+    client: &Client,
+    retry_config: &RetryConfig,
+    endpoint: &str,
+    imdsv1_fallback: bool,
+) -> Result<TemporaryToken<Arc<AwsCredential>>, StdError> {
+    const CREDENTIALS_PATH: &str = "latest/meta-data/iam/security-credentials";
+    const AWS_EC2_METADATA_TOKEN_HEADER: &str = "X-aws-ec2-metadata-token";
+
+    let token_url = format!("{endpoint}/latest/api/token");
+
+    let token_result = client
+        .request(Method::PUT, token_url)
+        .header("X-aws-ec2-metadata-token-ttl-seconds", "600") // 10 minute TTL
+        .send_retry(retry_config)
+        .await;
+
+    let token = match token_result {
+        Ok(t) => Some(t.text().await?),
+        Err(e) if imdsv1_fallback && matches!(e.status(), Some(StatusCode::FORBIDDEN)) => {
+            warn!("received 403 from metadata endpoint, falling back to IMDSv1");
+            None
+        }
+        Err(e) => return Err(e.into()),
+    };
+
+    let role_url = format!("{endpoint}/{CREDENTIALS_PATH}/");
+    let mut role_request = client.request(Method::GET, role_url);
+
+    if let Some(token) = &token {
+        role_request = role_request.header(AWS_EC2_METADATA_TOKEN_HEADER, token);
+    }
+
+    let role = role_request.send_retry(retry_config).await?.text().await?;
+
+    let creds_url = format!("{endpoint}/{CREDENTIALS_PATH}/{role}");
+    let mut creds_request = client.request(Method::GET, creds_url);
+    if let Some(token) = &token {
+        creds_request = creds_request.header(AWS_EC2_METADATA_TOKEN_HEADER, token);
+    }
+
+    let creds: InstanceCredentials = creds_request.send_retry(retry_config).await?.json().await?;
+
+    let now = Utc::now();
+    let ttl = (creds.expiration - now).to_std().unwrap_or_default();
+    Ok(TemporaryToken {
+        token: Arc::new(creds.into()),
+        expiry: Some(Instant::now() + ttl),
+    })
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct AssumeRoleResponse {
+    assume_role_with_web_identity_result: AssumeRoleResult,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct AssumeRoleResult {
+    credentials: SessionCredentials,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct SessionCredentials {
+    session_token: String,
+    secret_access_key: String,
+    access_key_id: String,
+    expiration: DateTime<Utc>,
+}
+
+impl From<SessionCredentials> for AwsCredential {
+    fn from(s: SessionCredentials) -> Self {
+        Self {
+            key_id: s.access_key_id,
+            secret_key: s.secret_access_key,
+            token: Some(s.session_token),
+        }
+    }
+}
+
+/// <https://docs.aws.amazon.com/eks/latest/userguide/iam-roles-for-service-accounts-technical-overview.html>
+async fn web_identity(
+    client: &Client,
+    retry_config: &RetryConfig,
+    token_path: &str,
+    role_arn: &str,
+    session_name: &str,
+    endpoint: &str,
+) -> Result<TemporaryToken<Arc<AwsCredential>>, StdError> {
+    let token = std::fs::read_to_string(token_path)
+        .map_err(|e| format!("Failed to read token file '{token_path}': {e}"))?;
+
+    let bytes = client
+        .request(Method::POST, endpoint)
+        .query(&[
+            ("Action", "AssumeRoleWithWebIdentity"),
+            ("DurationSeconds", "3600"),
+            ("RoleArn", role_arn),
+            ("RoleSessionName", session_name),
+            ("Version", "2011-06-15"),
+            ("WebIdentityToken", &token),
+        ])
+        .send_retry(retry_config)
+        .await?
+        .bytes()
+        .await?;
+
+    let resp: AssumeRoleResponse = quick_xml::de::from_reader(bytes.reader())
+        .map_err(|e| format!("Invalid AssumeRoleWithWebIdentity response: {e}"))?;
+
+    let creds = resp.assume_role_with_web_identity_result.credentials;
+    let now = Utc::now();
+    let ttl = (creds.expiration - now).to_std().unwrap_or_default();
+
+    Ok(TemporaryToken {
+        token: Arc::new(creds.into()),
+        expiry: Some(Instant::now() + ttl),
+    })
+}
+
+/// Credentials sourced from a task IAM role
+///
+/// <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html>
+#[derive(Debug)]
+pub struct TaskCredentialProvider {
+    pub url: String,
+    pub retry: RetryConfig,
+    pub client: Client,
+    pub cache: TokenCache<Arc<AwsCredential>>,
+}
+
+#[async_trait]
+impl CredentialProvider for TaskCredentialProvider {
+    type Credential = AwsCredential;
+
+    async fn get_credential(&self) -> Result<Arc<AwsCredential>> {
+        self.cache
+            .get_or_insert_with(|| task_credential(&self.client, &self.retry, &self.url))
+            .await
+            .map_err(|source| crate::Error::Generic {
+                store: STORE,
+                source,
+            })
+    }
+}
+
+/// <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html>
+async fn task_credential(
+    client: &Client,
+    retry: &RetryConfig,
+    url: &str,
+) -> Result<TemporaryToken<Arc<AwsCredential>>, StdError> {
+    let creds: InstanceCredentials = client.get(url).send_retry(retry).await?.json().await?;
+
+    let now = Utc::now();
+    let ttl = (creds.expiration - now).to_std().unwrap_or_default();
+    Ok(TemporaryToken {
+        token: Arc::new(creds.into()),
+        expiry: Some(Instant::now() + ttl),
+    })
+}
+
+/// A session provider as used by S3 Express One Zone
+///
+/// <https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html>
+#[derive(Debug)]
+pub struct SessionProvider {
+    pub endpoint: String,
+    pub region: String,
+    pub credentials: AwsCredentialProvider,
+}
+
+#[async_trait]
+impl TokenProvider for SessionProvider {
+    type Credential = AwsCredential;
+
+    async fn fetch_token(
+        &self,
+        client: &Client,
+        retry: &RetryConfig,
+    ) -> Result<TemporaryToken<Arc<Self::Credential>>> {
+        let creds = self.credentials.get_credential().await?;
+        let authorizer = AwsAuthorizer::new(&creds, "s3", &self.region);
+
+        let bytes = client
+            .get(format!("{}?session", self.endpoint))
+            .with_aws_sigv4(Some(authorizer), None)
+            .send_retry(retry)
+            .await
+            .context(CreateSessionRequestSnafu)?
+            .bytes()
+            .await
+            .context(CreateSessionResponseSnafu)?;
+
+        let resp: CreateSessionOutput =
+            quick_xml::de::from_reader(bytes.reader()).context(CreateSessionOutputSnafu)?;
+
+        let creds = resp.credentials;
+        Ok(TemporaryToken {
+            token: Arc::new(creds.into()),
+            // Credentials last 5 minutes - https://docs.aws.amazon.com/AmazonS3/latest/API/API_CreateSession.html
+            expiry: Some(Instant::now() + Duration::from_secs(5 * 60)),
+        })
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct CreateSessionOutput {
+    credentials: SessionCredentials,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::client::mock_server::MockServer;
+    use hyper::{Body, Response};
+    use reqwest::{Client, Method};
+    use std::env;
+
+    // Test generated using https://docs.aws.amazon.com/general/latest/gr/sigv4-signed-request-examples.html
+    #[test]
+    fn test_sign_with_signed_payload() {
+        let client = Client::new();
+
+        // Test credentials from https://docs.aws.amazon.com/AmazonS3/latest/userguide/RESTAuthentication.html
+        let credential = AwsCredential {
+            key_id: "AKIAIOSFODNN7EXAMPLE".to_string(),
+            secret_key: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY".to_string(),
+            token: None,
+        };
+
+        // method = 'GET'
+        // service = 'ec2'
+        // host = 'ec2.amazonaws.com'
+        // region = 'us-east-1'
+        // endpoint = 'https://ec2.amazonaws.com'
+        // request_parameters = ''
+        let date = DateTime::parse_from_rfc3339("2022-08-06T18:01:34Z")
+            .unwrap()
+            .with_timezone(&Utc);
+
+        let mut request = client
+            .request(Method::GET, "https://ec2.amazon.com/")
+            .build()
+            .unwrap();
+
+        let signer = AwsAuthorizer {
+            date: Some(date),
+            credential: &credential,
+            service: "ec2",
+            region: "us-east-1",
+            sign_payload: true,
+            token_header: None,
+        };
+
+        signer.authorize(&mut request, None);
+        assert_eq!(request.headers().get(&AUTHORIZATION).unwrap(), "AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20220806/us-east-1/ec2/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature=a3c787a7ed37f7fdfbfd2d7056a3d7c9d85e6d52a2bfbec73793c0be6e7862d4")
+    }
+
+    #[test]
+    fn test_sign_with_unsigned_payload() {
+        let client = Client::new();
+
+        // Test credentials from https://docs.aws.amazon.com/AmazonS3/latest/userguide/RESTAuthentication.html
+        let credential = AwsCredential {
+            key_id: "AKIAIOSFODNN7EXAMPLE".to_string(),
+            secret_key: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY".to_string(),
+            token: None,
+        };
+
+        // method = 'GET'
+        // service = 'ec2'
+        // host = 'ec2.amazonaws.com'
+        // region = 'us-east-1'
+        // endpoint = 'https://ec2.amazonaws.com'
+        // request_parameters = ''
+        let date = DateTime::parse_from_rfc3339("2022-08-06T18:01:34Z")
+            .unwrap()
+            .with_timezone(&Utc);
+
+        let mut request = client
+            .request(Method::GET, "https://ec2.amazon.com/")
+            .build()
+            .unwrap();
+
+        let authorizer = AwsAuthorizer {
+            date: Some(date),
+            credential: &credential,
+            service: "ec2",
+            region: "us-east-1",
+            token_header: None,
+            sign_payload: false,
+        };
+
+        authorizer.authorize(&mut request, None);
+        assert_eq!(request.headers().get(&AUTHORIZATION).unwrap(), "AWS4-HMAC-SHA256 Credential=AKIAIOSFODNN7EXAMPLE/20220806/us-east-1/ec2/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature=653c3d8ea261fd826207df58bc2bb69fbb5003e9eb3c0ef06e4a51f2a81d8699");
+    }
+
+    #[test]
+    fn signed_get_url() {
+        // Values from https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html
+        let credential = AwsCredential {
+            key_id: "AKIAIOSFODNN7EXAMPLE".to_string(),
+            secret_key: "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY".to_string(),
+            token: None,
+        };
+
+        let date = DateTime::parse_from_rfc3339("2013-05-24T00:00:00Z")
+            .unwrap()
+            .with_timezone(&Utc);
+
+        let authorizer = AwsAuthorizer {
+            date: Some(date),
+            credential: &credential,
+            service: "s3",
+            region: "us-east-1",
+            token_header: None,
+            sign_payload: false,
+        };
+
+        let mut url = Url::parse("https://examplebucket.s3.amazonaws.com/test.txt").unwrap();
+        authorizer.sign(Method::GET, &mut url, Duration::from_secs(86400));
+
+        assert_eq!(
+            url,
+            Url::parse(
+                "https://examplebucket.s3.amazonaws.com/test.txt?\
+                X-Amz-Algorithm=AWS4-HMAC-SHA256&\
+                X-Amz-Credential=AKIAIOSFODNN7EXAMPLE%2F20130524%2Fus-east-1%2Fs3%2Faws4_request&\
+                X-Amz-Date=20130524T000000Z&\
+                X-Amz-Expires=86400&\
+                X-Amz-SignedHeaders=host&\
+                X-Amz-Signature=aeeed9bbccd4d02ee5c0109b86d86835f995330da4c265957d157751f604d404"
+            )
+            .unwrap()
+        );
+    }
+
+    #[test]
+    fn test_sign_port() {
+        let client = Client::new();
+
+        let credential = AwsCredential {
+            key_id: "H20ABqCkLZID4rLe".to_string(),
+            secret_key: "jMqRDgxSsBqqznfmddGdu1TmmZOJQxdM".to_string(),
+            token: None,
+        };
+
+        let date = DateTime::parse_from_rfc3339("2022-08-09T13:05:25Z")
+            .unwrap()
+            .with_timezone(&Utc);
+
+        let mut request = client
+            .request(Method::GET, "http://localhost:9000/tsm-schemas")
+            .query(&[
+                ("delimiter", "/"),
+                ("encoding-type", "url"),
+                ("list-type", "2"),
+                ("prefix", ""),
+            ])
+            .build()
+            .unwrap();
+
+        let authorizer = AwsAuthorizer {
+            date: Some(date),
+            credential: &credential,
+            service: "s3",
+            region: "us-east-1",
+            token_header: None,
+            sign_payload: true,
+        };
+
+        authorizer.authorize(&mut request, None);
+        assert_eq!(request.headers().get(&AUTHORIZATION).unwrap(), "AWS4-HMAC-SHA256 Credential=H20ABqCkLZID4rLe/20220809/us-east-1/s3/aws4_request, SignedHeaders=host;x-amz-content-sha256;x-amz-date, Signature=9ebf2f92872066c99ac94e573b4e1b80f4dbb8a32b1e8e23178318746e7d1b4d")
+    }
+
+    #[tokio::test]
+    async fn test_instance_metadata() {
+        if env::var("TEST_INTEGRATION").is_err() {
+            eprintln!("skipping AWS integration test");
+            return;
+        }
+
+        // For example https://github.com/aws/amazon-ec2-metadata-mock
+        let endpoint = env::var("EC2_METADATA_ENDPOINT").unwrap();
+        let client = Client::new();
+        let retry_config = RetryConfig::default();
+
+        // Verify only allows IMDSv2
+        let resp = client
+            .request(Method::GET, format!("{endpoint}/latest/meta-data/ami-id"))
+            .send()
+            .await
+            .unwrap();
+
+        assert_eq!(
+            resp.status(),
+            StatusCode::UNAUTHORIZED,
+            "Ensure metadata endpoint is set to only allow IMDSv2"
+        );
+
+        let creds = instance_creds(&client, &retry_config, &endpoint, false)
+            .await
+            .unwrap();
+
+        let id = &creds.token.key_id;
+        let secret = &creds.token.secret_key;
+        let token = creds.token.token.as_ref().unwrap();
+
+        assert!(!id.is_empty());
+        assert!(!secret.is_empty());
+        assert!(!token.is_empty())
+    }
+
+    #[tokio::test]
+    async fn test_mock() {
+        let server = MockServer::new();
+
+        const IMDSV2_HEADER: &str = "X-aws-ec2-metadata-token";
+
+        let secret_access_key = "SECRET";
+        let access_key_id = "KEYID";
+        let token = "TOKEN";
+
+        let endpoint = server.url();
+        let client = Client::new();
+        let retry_config = RetryConfig::default();
+
+        // Test IMDSv2
+        server.push_fn(|req| {
+            assert_eq!(req.uri().path(), "/latest/api/token");
+            assert_eq!(req.method(), &Method::PUT);
+            Response::new(Body::from("cupcakes"))
+        });
+        server.push_fn(|req| {
+            assert_eq!(
+                req.uri().path(),
+                "/latest/meta-data/iam/security-credentials/"
+            );
+            assert_eq!(req.method(), &Method::GET);
+            let t = req.headers().get(IMDSV2_HEADER).unwrap().to_str().unwrap();
+            assert_eq!(t, "cupcakes");
+            Response::new(Body::from("myrole"))
+        });
+        server.push_fn(|req| {
+            assert_eq!(req.uri().path(), "/latest/meta-data/iam/security-credentials/myrole");
+            assert_eq!(req.method(), &Method::GET);
+            let t = req.headers().get(IMDSV2_HEADER).unwrap().to_str().unwrap();
+            assert_eq!(t, "cupcakes");
+            Response::new(Body::from(r#"{"AccessKeyId":"KEYID","Code":"Success","Expiration":"2022-08-30T10:51:04Z","LastUpdated":"2022-08-30T10:21:04Z","SecretAccessKey":"SECRET","Token":"TOKEN","Type":"AWS-HMAC"}"#))
+        });
+
+        let creds = instance_creds(&client, &retry_config, endpoint, true)
+            .await
+            .unwrap();
+
+        assert_eq!(creds.token.token.as_deref().unwrap(), token);
+        assert_eq!(&creds.token.key_id, access_key_id);
+        assert_eq!(&creds.token.secret_key, secret_access_key);
+
+        // Test IMDSv1 fallback
+        server.push_fn(|req| {
+            assert_eq!(req.uri().path(), "/latest/api/token");
+            assert_eq!(req.method(), &Method::PUT);
+            Response::builder()
+                .status(StatusCode::FORBIDDEN)
+                .body(Body::empty())
+                .unwrap()
+        });
+        server.push_fn(|req| {
+            assert_eq!(
+                req.uri().path(),
+                "/latest/meta-data/iam/security-credentials/"
+            );
+            assert_eq!(req.method(), &Method::GET);
+            assert!(req.headers().get(IMDSV2_HEADER).is_none());
+            Response::new(Body::from("myrole"))
+        });
+        server.push_fn(|req| {
+            assert_eq!(req.uri().path(), "/latest/meta-data/iam/security-credentials/myrole");
+            assert_eq!(req.method(), &Method::GET);
+            assert!(req.headers().get(IMDSV2_HEADER).is_none());
+            Response::new(Body::from(r#"{"AccessKeyId":"KEYID","Code":"Success","Expiration":"2022-08-30T10:51:04Z","LastUpdated":"2022-08-30T10:21:04Z","SecretAccessKey":"SECRET","Token":"TOKEN","Type":"AWS-HMAC"}"#))
+        });
+
+        let creds = instance_creds(&client, &retry_config, endpoint, true)
+            .await
+            .unwrap();
+
+        assert_eq!(creds.token.token.as_deref().unwrap(), token);
+        assert_eq!(&creds.token.key_id, access_key_id);
+        assert_eq!(&creds.token.secret_key, secret_access_key);
+
+        // Test IMDSv1 fallback disabled
+        server.push(
+            Response::builder()
+                .status(StatusCode::FORBIDDEN)
+                .body(Body::empty())
+                .unwrap(),
+        );
+
+        // Should fail
+        instance_creds(&client, &retry_config, endpoint, false)
+            .await
+            .unwrap_err();
+    }
+}
diff --git a/object_store/src/aws/dynamo.rs b/object_store/src/aws/dynamo.rs
new file mode 100644
index 000000000000..2390187e7f72
--- /dev/null
+++ b/object_store/src/aws/dynamo.rs
@@ -0,0 +1,605 @@
+// 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.
+
+//! A DynamoDB based lock system
+
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::future::Future;
+use std::time::{Duration, Instant};
+
+use chrono::Utc;
+use reqwest::{Response, StatusCode};
+use serde::ser::SerializeMap;
+use serde::{Deserialize, Serialize, Serializer};
+
+use crate::aws::client::S3Client;
+use crate::aws::credential::CredentialExt;
+use crate::aws::{AwsAuthorizer, AwsCredential};
+use crate::client::get::GetClientExt;
+use crate::client::retry::Error as RetryError;
+use crate::client::retry::RetryExt;
+use crate::path::Path;
+use crate::{Error, GetOptions, Result};
+
+/// The exception returned by DynamoDB on conflict
+const CONFLICT: &str = "ConditionalCheckFailedException";
+
+const STORE: &str = "DynamoDB";
+
+/// A DynamoDB-based commit protocol, used to provide conditional write support for S3
+///
+/// ## Limitations
+///
+/// Only conditional operations, e.g. `copy_if_not_exists` will be synchronized, and can
+/// therefore race with non-conditional operations, e.g. `put`, `copy`, `delete`, or
+/// conditional operations performed by writers not configured to synchronize with DynamoDB.
+///
+/// Workloads making use of this mechanism **must** ensure:
+///
+/// * Conditional and non-conditional operations are not performed on the same paths
+/// * Conditional operations are only performed via similarly configured clients
+///
+/// Additionally as the locking mechanism relies on timeouts to detect stale locks,
+/// performance will be poor for systems that frequently delete and then create
+/// objects at the same path, instead being optimised for systems that primarily create
+/// files with paths never used before, or perform conditional updates to existing files
+///
+/// ## Commit Protocol
+///
+/// The DynamoDB schema is as follows:
+///
+/// * A string partition key named `"path"`
+/// * A string sort key named `"etag"`
+/// * A numeric [TTL] attribute named `"ttl"`
+/// * A numeric attribute named `"generation"`
+/// * A numeric attribute named `"timeout"`
+///
+/// An appropriate DynamoDB table can be created with the CLI as follows:
+///
+/// ```bash
+/// $ aws dynamodb create-table --table-name <TABLE_NAME> --key-schema AttributeName=path,KeyType=HASH AttributeName=etag,KeyType=RANGE --attribute-definitions AttributeName=path,AttributeType=S AttributeName=etag,AttributeType=S
+/// $ aws dynamodb update-time-to-live --table-name <TABLE_NAME> --time-to-live-specification Enabled=true,AttributeName=ttl
+/// ```
+///
+/// To perform a conditional operation on an object with a given `path` and `etag` (`*` if creating),
+/// the commit protocol is as follows:
+///
+/// 1. Perform HEAD request on `path` and error on precondition mismatch
+/// 2. Create record in DynamoDB with given `path` and `etag` with the configured timeout
+///     1. On Success: Perform operation with the configured timeout
+///     2. On Conflict:
+///         1. Periodically re-perform HEAD request on `path` and error on precondition mismatch
+///         2. If `timeout * max_skew_rate` passed, replace the record incrementing the `"generation"`
+///             1. On Success: GOTO 2.1
+///             2. On Conflict: GOTO 2.2
+///
+/// Provided no writer modifies an object with a given `path` and `etag` without first adding a
+/// corresponding record to DynamoDB, we are guaranteed that only one writer will ever commit.
+///
+/// This is inspired by the [DynamoDB Lock Client] but simplified for the more limited
+/// requirements of synchronizing object storage. The major changes are:
+///
+/// * Uses a monotonic generation count instead of a UUID rvn, as this is:
+///     * Cheaper to generate, serialize and compare
+///     * Cannot collide
+///     * More human readable / interpretable
+/// * Relies on [TTL] to eventually clean up old locks
+///
+/// It also draws inspiration from the DeltaLake [S3 Multi-Cluster] commit protocol, but
+/// generalised to not make assumptions about the workload and not rely on first writing
+/// to a temporary path.
+///
+/// [TTL]: https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/howitworks-ttl.html
+/// [DynamoDB Lock Client]: https://aws.amazon.com/blogs/database/building-distributed-locks-with-the-dynamodb-lock-client/
+/// [S3 Multi-Cluster]: https://docs.google.com/document/d/1Gs4ZsTH19lMxth4BSdwlWjUNR-XhKHicDvBjd2RqNd8/edit#heading=h.mjjuxw9mcz9h
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct DynamoCommit {
+    table_name: String,
+    /// The number of milliseconds a lease is valid for
+    timeout: u64,
+    /// The maximum clock skew rate tolerated by the system
+    max_clock_skew_rate: u32,
+    /// The length of time a record will be retained in DynamoDB before being cleaned up
+    ///
+    /// This is purely an optimisation to avoid indefinite growth of the DynamoDB table
+    /// and does not impact how long clients may wait to acquire a lock
+    ttl: Duration,
+    /// The backoff duration before retesting a condition
+    test_interval: Duration,
+}
+
+impl DynamoCommit {
+    /// Create a new [`DynamoCommit`] with a given table name
+    pub fn new(table_name: String) -> Self {
+        Self {
+            table_name,
+            timeout: 20_000,
+            max_clock_skew_rate: 3,
+            ttl: Duration::from_secs(60 * 60),
+            test_interval: Duration::from_millis(100),
+        }
+    }
+
+    /// Overrides the lock timeout.
+    ///
+    /// A longer lock timeout reduces the probability of spurious commit failures and multi-writer
+    /// races, but will increase the time that writers must wait to reclaim a lock lost. The
+    /// default value of 20 seconds should be appropriate for must use-cases.
+    pub fn with_timeout(mut self, millis: u64) -> Self {
+        self.timeout = millis;
+        self
+    }
+
+    /// The maximum clock skew rate tolerated by the system.
+    ///
+    /// An environment in which the clock on the fastest node ticks twice as fast as the slowest
+    /// node, would have a clock skew rate of 2. The default value of 3 should be appropriate
+    /// for most environments.
+    pub fn with_max_clock_skew_rate(mut self, rate: u32) -> Self {
+        self.max_clock_skew_rate = rate;
+        self
+    }
+
+    /// The length of time a record should be retained in DynamoDB before being cleaned up
+    ///
+    /// This should be significantly larger than the configured lock timeout, with the default
+    /// value of 1 hour appropriate for most use-cases.
+    pub fn with_ttl(mut self, ttl: Duration) -> Self {
+        self.ttl = ttl;
+        self
+    }
+
+    /// Parse [`DynamoCommit`] from a string
+    pub(crate) fn from_str(value: &str) -> Option<Self> {
+        Some(match value.split_once(':') {
+            Some((table_name, timeout)) => {
+                Self::new(table_name.trim().to_string()).with_timeout(timeout.parse().ok()?)
+            }
+            None => Self::new(value.trim().to_string()),
+        })
+    }
+
+    /// Returns the name of the DynamoDB table.
+    pub(crate) fn table_name(&self) -> &str {
+        &self.table_name
+    }
+
+    pub(crate) async fn copy_if_not_exists(
+        &self,
+        client: &S3Client,
+        from: &Path,
+        to: &Path,
+    ) -> Result<()> {
+        self.conditional_op(client, to, None, || async {
+            client.copy_request(from, to).send().await?;
+            Ok(())
+        })
+        .await
+    }
+
+    #[allow(clippy::future_not_send)] // Generics confound this lint
+    pub(crate) async fn conditional_op<F, Fut, T>(
+        &self,
+        client: &S3Client,
+        to: &Path,
+        etag: Option<&str>,
+        op: F,
+    ) -> Result<T>
+    where
+        F: FnOnce() -> Fut,
+        Fut: Future<Output = Result<T, Error>>,
+    {
+        check_precondition(client, to, etag).await?;
+
+        let mut previous_lease = None;
+
+        loop {
+            let existing = previous_lease.as_ref();
+            match self.try_lock(client, to.as_ref(), etag, existing).await? {
+                TryLockResult::Ok(lease) => {
+                    let expiry = lease.acquire + lease.timeout;
+                    return match tokio::time::timeout_at(expiry.into(), op()).await {
+                        Ok(Ok(v)) => Ok(v),
+                        Ok(Err(e)) => Err(e),
+                        Err(_) => Err(Error::Generic {
+                            store: "DynamoDB",
+                            source: format!(
+                                "Failed to perform conditional operation in {} milliseconds",
+                                self.timeout
+                            )
+                            .into(),
+                        }),
+                    };
+                }
+                TryLockResult::Conflict(conflict) => {
+                    let mut interval = tokio::time::interval(self.test_interval);
+                    let expiry = conflict.timeout * self.max_clock_skew_rate;
+                    loop {
+                        interval.tick().await;
+                        check_precondition(client, to, etag).await?;
+                        if conflict.acquire.elapsed() > expiry {
+                            previous_lease = Some(conflict);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    /// Attempt to acquire a lock, reclaiming an existing lease if provided
+    async fn try_lock(
+        &self,
+        s3: &S3Client,
+        path: &str,
+        etag: Option<&str>,
+        existing: Option<&Lease>,
+    ) -> Result<TryLockResult> {
+        let attributes;
+        let (next_gen, condition_expression, expression_attribute_values) = match existing {
+            None => (0_u64, "attribute_not_exists(#pk)", Map(&[])),
+            Some(existing) => {
+                attributes = [(":g", AttributeValue::Number(existing.generation))];
+                (
+                    existing.generation.checked_add(1).unwrap(),
+                    "attribute_exists(#pk) AND generation = :g",
+                    Map(attributes.as_slice()),
+                )
+            }
+        };
+
+        let ttl = (Utc::now() + self.ttl).timestamp();
+        let items = [
+            ("path", AttributeValue::from(path)),
+            ("etag", AttributeValue::from(etag.unwrap_or("*"))),
+            ("generation", AttributeValue::Number(next_gen)),
+            ("timeout", AttributeValue::Number(self.timeout)),
+            ("ttl", AttributeValue::Number(ttl as _)),
+        ];
+        let names = [("#pk", "path")];
+
+        let req = PutItem {
+            table_name: &self.table_name,
+            condition_expression,
+            expression_attribute_values,
+            expression_attribute_names: Map(&names),
+            item: Map(&items),
+            return_values: None,
+            return_values_on_condition_check_failure: Some(ReturnValues::AllOld),
+        };
+
+        let credential = s3.config.get_credential().await?;
+
+        let acquire = Instant::now();
+        match self
+            .request(s3, credential.as_deref(), "DynamoDB_20120810.PutItem", req)
+            .await
+        {
+            Ok(_) => Ok(TryLockResult::Ok(Lease {
+                acquire,
+                generation: next_gen,
+                timeout: Duration::from_millis(self.timeout),
+            })),
+            Err(e) => match parse_error_response(&e) {
+                Some(e) if e.error.ends_with(CONFLICT) => match extract_lease(&e.item) {
+                    Some(lease) => Ok(TryLockResult::Conflict(lease)),
+                    None => Err(Error::Generic {
+                        store: STORE,
+                        source: "Failed to extract lease from conflict ReturnValuesOnConditionCheckFailure response".into()
+                    }),
+                },
+                _ => Err(Error::Generic {
+                    store: STORE,
+                    source: Box::new(e),
+                }),
+            },
+        }
+    }
+
+    async fn request<R: Serialize + Send + Sync>(
+        &self,
+        s3: &S3Client,
+        cred: Option<&AwsCredential>,
+        target: &str,
+        req: R,
+    ) -> Result<Response, RetryError> {
+        let region = &s3.config.region;
+        let authorizer = cred.map(|x| AwsAuthorizer::new(x, "dynamodb", region));
+
+        let builder = match &s3.config.endpoint {
+            Some(e) => s3.client.post(e),
+            None => {
+                let url = format!("https://dynamodb.{region}.amazonaws.com");
+                s3.client.post(url)
+            }
+        };
+
+        builder
+            .timeout(Duration::from_millis(self.timeout))
+            .json(&req)
+            .header("X-Amz-Target", target)
+            .with_aws_sigv4(authorizer, None)
+            .send_retry(&s3.config.retry_config)
+            .await
+    }
+}
+
+#[derive(Debug)]
+enum TryLockResult {
+    /// Successfully acquired a lease
+    Ok(Lease),
+    /// An existing lease was found
+    Conflict(Lease),
+}
+
+/// Validates that `path` has the given `etag` or doesn't exist if `None`
+async fn check_precondition(client: &S3Client, path: &Path, etag: Option<&str>) -> Result<()> {
+    let options = GetOptions {
+        head: true,
+        ..Default::default()
+    };
+
+    match etag {
+        Some(expected) => match client.get_opts(path, options).await {
+            Ok(r) => match r.meta.e_tag {
+                Some(actual) if expected == actual => Ok(()),
+                actual => Err(Error::Precondition {
+                    path: path.to_string(),
+                    source: format!("{} does not match {expected}", actual.unwrap_or_default())
+                        .into(),
+                }),
+            },
+            Err(Error::NotFound { .. }) => Err(Error::Precondition {
+                path: path.to_string(),
+                source: format!("Object at location {path} not found").into(),
+            }),
+            Err(e) => Err(e),
+        },
+        None => match client.get_opts(path, options).await {
+            Ok(_) => Err(Error::AlreadyExists {
+                path: path.to_string(),
+                source: "Already Exists".to_string().into(),
+            }),
+            Err(Error::NotFound { .. }) => Ok(()),
+            Err(e) => Err(e),
+        },
+    }
+}
+
+/// Parses the error response if any
+fn parse_error_response(e: &RetryError) -> Option<ErrorResponse<'_>> {
+    match e {
+        RetryError::Client {
+            status: StatusCode::BAD_REQUEST,
+            body: Some(b),
+        } => serde_json::from_str(b).ok(),
+        _ => None,
+    }
+}
+
+/// Extracts a lease from `item`, returning `None` on error
+fn extract_lease(item: &HashMap<&str, AttributeValue<'_>>) -> Option<Lease> {
+    let generation = match item.get("generation") {
+        Some(AttributeValue::Number(generation)) => generation,
+        _ => return None,
+    };
+
+    let timeout = match item.get("timeout") {
+        Some(AttributeValue::Number(timeout)) => *timeout,
+        _ => return None,
+    };
+
+    Some(Lease {
+        acquire: Instant::now(),
+        generation: *generation,
+        timeout: Duration::from_millis(timeout),
+    })
+}
+
+/// A lock lease
+#[derive(Debug, Clone)]
+struct Lease {
+    acquire: Instant,
+    generation: u64,
+    timeout: Duration,
+}
+
+/// A DynamoDB [PutItem] payload
+///
+/// [PutItem]: https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_PutItem.html
+#[derive(Serialize)]
+#[serde(rename_all = "PascalCase")]
+struct PutItem<'a> {
+    /// The table name
+    table_name: &'a str,
+
+    /// A condition that must be satisfied in order for a conditional PutItem operation to succeed.
+    condition_expression: &'a str,
+
+    /// One or more substitution tokens for attribute names in an expression
+    expression_attribute_names: Map<'a, &'a str, &'a str>,
+
+    /// One or more values that can be substituted in an expression
+    expression_attribute_values: Map<'a, &'a str, AttributeValue<'a>>,
+
+    /// A map of attribute name/value pairs, one for each attribute
+    item: Map<'a, &'a str, AttributeValue<'a>>,
+
+    /// Use ReturnValues if you want to get the item attributes as they appeared
+    /// before they were updated with the PutItem request.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    return_values: Option<ReturnValues>,
+
+    /// An optional parameter that returns the item attributes for a PutItem operation
+    /// that failed a condition check.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    return_values_on_condition_check_failure: Option<ReturnValues>,
+}
+
+/// A DynamoDB [GetItem] payload
+///
+/// [GetItem]: https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_GetItem.html
+#[derive(Serialize)]
+#[serde(rename_all = "PascalCase")]
+struct GetItem<'a> {
+    /// The table name
+    table_name: &'a str,
+    /// The primary key
+    key: Map<'a, &'a str, AttributeValue<'a>>,
+}
+
+#[derive(Deserialize)]
+struct ErrorResponse<'a> {
+    #[serde(rename = "__type")]
+    error: &'a str,
+
+    #[serde(borrow, default, rename = "Item")]
+    item: HashMap<&'a str, AttributeValue<'a>>,
+}
+
+#[derive(Serialize)]
+#[serde(rename_all = "SCREAMING_SNAKE_CASE")]
+enum ReturnValues {
+    AllOld,
+}
+
+/// A collection of key value pairs
+///
+/// This provides cheap, ordered serialization of maps
+struct Map<'a, K, V>(&'a [(K, V)]);
+
+impl<'a, K: Serialize, V: Serialize> Serialize for Map<'a, K, V> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        if self.0.is_empty() {
+            return serializer.serialize_none();
+        }
+        let mut map = serializer.serialize_map(Some(self.0.len()))?;
+        for (k, v) in self.0 {
+            map.serialize_entry(k, v)?
+        }
+        map.end()
+    }
+}
+
+/// A DynamoDB [AttributeValue]
+///
+/// [AttributeValue]: https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/API_AttributeValue.html
+#[derive(Debug, Serialize, Deserialize)]
+enum AttributeValue<'a> {
+    #[serde(rename = "S")]
+    String(Cow<'a, str>),
+    #[serde(rename = "N", with = "number")]
+    Number(u64),
+}
+
+impl<'a> From<&'a str> for AttributeValue<'a> {
+    fn from(value: &'a str) -> Self {
+        Self::String(Cow::Borrowed(value))
+    }
+}
+
+/// Numbers are serialized as strings
+mod number {
+    use serde::{Deserialize, Deserializer, Serializer};
+
+    pub fn serialize<S: Serializer>(v: &u64, s: S) -> Result<S::Ok, S::Error> {
+        s.serialize_str(&v.to_string())
+    }
+
+    pub fn deserialize<'de, D: Deserializer<'de>>(d: D) -> Result<u64, D::Error> {
+        let v: &str = Deserialize::deserialize(d)?;
+        v.parse().map_err(serde::de::Error::custom)
+    }
+}
+
+/// Re-export integration_test to be called by s3_test
+#[cfg(test)]
+pub(crate) use tests::integration_test;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::aws::AmazonS3;
+    use crate::ObjectStore;
+    use rand::distributions::Alphanumeric;
+    use rand::{thread_rng, Rng};
+
+    #[test]
+    fn test_attribute_serde() {
+        let serde = serde_json::to_string(&AttributeValue::Number(23)).unwrap();
+        assert_eq!(serde, "{\"N\":\"23\"}");
+        let back: AttributeValue<'_> = serde_json::from_str(&serde).unwrap();
+        assert!(matches!(back, AttributeValue::Number(23)));
+    }
+
+    /// An integration test for DynamoDB
+    ///
+    /// This is a function called by s3_test to avoid test concurrency issues
+    pub async fn integration_test(integration: &AmazonS3, d: &DynamoCommit) {
+        let client = integration.client.as_ref();
+
+        let src = Path::from("dynamo_path_src");
+        integration.put(&src, "asd".into()).await.unwrap();
+
+        let dst = Path::from("dynamo_path");
+        let _ = integration.delete(&dst).await; // Delete if present
+
+        // Create a lock if not already exists
+        let existing = match d.try_lock(client, dst.as_ref(), None, None).await.unwrap() {
+            TryLockResult::Conflict(l) => l,
+            TryLockResult::Ok(l) => l,
+        };
+
+        // Should not be able to acquire a lock again
+        let r = d.try_lock(client, dst.as_ref(), None, None).await;
+        assert!(matches!(r, Ok(TryLockResult::Conflict(_))));
+
+        // But should still be able to reclaim lock and perform copy
+        d.copy_if_not_exists(client, &src, &dst).await.unwrap();
+
+        match d.try_lock(client, dst.as_ref(), None, None).await.unwrap() {
+            TryLockResult::Conflict(new) => {
+                // Should have incremented generation to do so
+                assert_eq!(new.generation, existing.generation + 1);
+            }
+            _ => panic!("Should conflict"),
+        }
+
+        let rng = thread_rng();
+        let etag = String::from_utf8(rng.sample_iter(Alphanumeric).take(32).collect()).unwrap();
+        let t = Some(etag.as_str());
+
+        let l = match d.try_lock(client, dst.as_ref(), t, None).await.unwrap() {
+            TryLockResult::Ok(l) => l,
+            _ => panic!("should not conflict"),
+        };
+
+        match d.try_lock(client, dst.as_ref(), t, None).await.unwrap() {
+            TryLockResult::Conflict(c) => assert_eq!(l.generation, c.generation),
+            _ => panic!("should conflict"),
+        }
+
+        match d.try_lock(client, dst.as_ref(), t, Some(&l)).await.unwrap() {
+            TryLockResult::Ok(new) => assert_eq!(new.generation, l.generation + 1),
+            _ => panic!("should not conflict"),
+        }
+    }
+}
diff --git a/object_store/src/aws/mod.rs b/object_store/src/aws/mod.rs
new file mode 100644
index 000000000000..b11f4513b6df
--- /dev/null
+++ b/object_store/src/aws/mod.rs
@@ -0,0 +1,566 @@
+// 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.
+
+//! An object store implementation for S3
+//!
+//! ## Multi-part uploads
+//!
+//! Multi-part uploads can be initiated with the [ObjectStore::put_multipart] method.
+//! Data passed to the writer is automatically buffered to meet the minimum size
+//! requirements for a part. Multiple parts are uploaded concurrently.
+//!
+//! If the writer fails for any reason, you may have parts uploaded to AWS but not
+//! used that you may be charged for. Use the [ObjectStore::abort_multipart] method
+//! to abort the upload and drop those unneeded parts. In addition, you may wish to
+//! consider implementing [automatic cleanup] of unused parts that are older than one
+//! week.
+//!
+//! [automatic cleanup]: https://aws.amazon.com/blogs/aws/s3-lifecycle-management-update-support-for-multipart-uploads-and-delete-markers/
+
+use async_trait::async_trait;
+use bytes::Bytes;
+use futures::stream::BoxStream;
+use futures::{StreamExt, TryStreamExt};
+use reqwest::header::{HeaderName, IF_MATCH, IF_NONE_MATCH};
+use reqwest::{Method, StatusCode};
+use std::{sync::Arc, time::Duration};
+use tokio::io::AsyncWrite;
+use url::Url;
+
+use crate::aws::client::{RequestError, S3Client};
+use crate::client::get::GetClientExt;
+use crate::client::list::ListClientExt;
+use crate::client::CredentialProvider;
+use crate::multipart::{MultiPartStore, PartId, PutPart, WriteMultiPart};
+use crate::signer::Signer;
+use crate::{
+    Error, GetOptions, GetResult, ListResult, MultipartId, ObjectMeta, ObjectStore, Path, PutMode,
+    PutOptions, PutResult, Result,
+};
+
+static TAGS_HEADER: HeaderName = HeaderName::from_static("x-amz-tagging");
+
+mod builder;
+mod checksum;
+mod client;
+mod credential;
+mod dynamo;
+mod precondition;
+mod resolve;
+
+pub use builder::{AmazonS3Builder, AmazonS3ConfigKey, S3EncryptionHeaders};
+pub use checksum::Checksum;
+pub use dynamo::DynamoCommit;
+pub use precondition::{S3ConditionalPut, S3CopyIfNotExists};
+pub use resolve::resolve_bucket_region;
+
+// http://docs.aws.amazon.com/general/latest/gr/sigv4-create-canonical-request.html
+//
+// Do not URI-encode any of the unreserved characters that RFC 3986 defines:
+// A-Z, a-z, 0-9, hyphen ( - ), underscore ( _ ), period ( . ), and tilde ( ~ ).
+pub(crate) const STRICT_ENCODE_SET: percent_encoding::AsciiSet = percent_encoding::NON_ALPHANUMERIC
+    .remove(b'-')
+    .remove(b'.')
+    .remove(b'_')
+    .remove(b'~');
+
+/// This struct is used to maintain the URI path encoding
+const STRICT_PATH_ENCODE_SET: percent_encoding::AsciiSet = STRICT_ENCODE_SET.remove(b'/');
+
+const STORE: &str = "S3";
+
+/// [`CredentialProvider`] for [`AmazonS3`]
+pub type AwsCredentialProvider = Arc<dyn CredentialProvider<Credential = AwsCredential>>;
+pub use credential::{AwsAuthorizer, AwsCredential};
+
+/// Interface for [Amazon S3](https://aws.amazon.com/s3/).
+#[derive(Debug)]
+pub struct AmazonS3 {
+    client: Arc<S3Client>,
+}
+
+impl std::fmt::Display for AmazonS3 {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "AmazonS3({})", self.client.config.bucket)
+    }
+}
+
+impl AmazonS3 {
+    /// Returns the [`AwsCredentialProvider`] used by [`AmazonS3`]
+    pub fn credentials(&self) -> &AwsCredentialProvider {
+        &self.client.config.credentials
+    }
+
+    /// Create a full URL to the resource specified by `path` with this instance's configuration.
+    fn path_url(&self, path: &Path) -> String {
+        self.client.config.path_url(path)
+    }
+}
+
+#[async_trait]
+impl Signer for AmazonS3 {
+    /// Create a URL containing the relevant [AWS SigV4] query parameters that authorize a request
+    /// via `method` to the resource at `path` valid for the duration specified in `expires_in`.
+    ///
+    /// [AWS SigV4]: https://docs.aws.amazon.com/IAM/latest/UserGuide/create-signed-request.html
+    ///
+    /// # Example
+    ///
+    /// This example returns a URL that will enable a user to upload a file to
+    /// "some-folder/some-file.txt" in the next hour.
+    ///
+    /// ```
+    /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+    /// # use object_store::{aws::AmazonS3Builder, path::Path, signer::Signer};
+    /// # use reqwest::Method;
+    /// # use std::time::Duration;
+    /// #
+    /// let region = "us-east-1";
+    /// let s3 = AmazonS3Builder::new()
+    ///     .with_region(region)
+    ///     .with_bucket_name("my-bucket")
+    ///     .with_access_key_id("my-access-key-id")
+    ///     .with_secret_access_key("my-secret-access-key")
+    ///     .build()?;
+    ///
+    /// let url = s3.signed_url(
+    ///     Method::PUT,
+    ///     &Path::from("some-folder/some-file.txt"),
+    ///     Duration::from_secs(60 * 60)
+    /// ).await?;
+    /// #     Ok(())
+    /// # }
+    /// ```
+    async fn signed_url(&self, method: Method, path: &Path, expires_in: Duration) -> Result<Url> {
+        let credential = self.credentials().get_credential().await?;
+        let authorizer = AwsAuthorizer::new(&credential, "s3", &self.client.config.region);
+
+        let path_url = self.path_url(path);
+        let mut url = Url::parse(&path_url).map_err(|e| crate::Error::Generic {
+            store: STORE,
+            source: format!("Unable to parse url {path_url}: {e}").into(),
+        })?;
+
+        authorizer.sign(method, &mut url, expires_in);
+
+        Ok(url)
+    }
+}
+
+#[async_trait]
+impl ObjectStore for AmazonS3 {
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        let mut request = self.client.put_request(location, bytes, true);
+        let tags = opts.tags.encoded();
+        if !tags.is_empty() && !self.client.config.disable_tagging {
+            request = request.header(&TAGS_HEADER, tags);
+        }
+
+        match (opts.mode, &self.client.config.conditional_put) {
+            (PutMode::Overwrite, _) => request.do_put().await,
+            (PutMode::Create | PutMode::Update(_), None) => Err(Error::NotImplemented),
+            (PutMode::Create, Some(S3ConditionalPut::ETagMatch)) => {
+                match request.header(&IF_NONE_MATCH, "*").do_put().await {
+                    // Technically If-None-Match should return NotModified but some stores,
+                    // such as R2, instead return PreconditionFailed
+                    // https://developers.cloudflare.com/r2/api/s3/extensions/#conditional-operations-in-putobject
+                    Err(e @ Error::NotModified { .. } | e @ Error::Precondition { .. }) => {
+                        Err(Error::AlreadyExists {
+                            path: location.to_string(),
+                            source: Box::new(e),
+                        })
+                    }
+                    r => r,
+                }
+            }
+            (PutMode::Create, Some(S3ConditionalPut::Dynamo(d))) => {
+                d.conditional_op(&self.client, location, None, move || request.do_put())
+                    .await
+            }
+            (PutMode::Update(v), Some(put)) => {
+                let etag = v.e_tag.ok_or_else(|| Error::Generic {
+                    store: STORE,
+                    source: "ETag required for conditional put".to_string().into(),
+                })?;
+                match put {
+                    S3ConditionalPut::ETagMatch => {
+                        request.header(&IF_MATCH, etag.as_str()).do_put().await
+                    }
+                    S3ConditionalPut::Dynamo(d) => {
+                        d.conditional_op(&self.client, location, Some(&etag), move || {
+                            request.do_put()
+                        })
+                        .await
+                    }
+                }
+            }
+        }
+    }
+
+    async fn put_multipart(
+        &self,
+        location: &Path,
+    ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
+        let id = self.client.create_multipart(location).await?;
+
+        let upload = S3MultiPartUpload {
+            location: location.clone(),
+            upload_id: id.clone(),
+            client: Arc::clone(&self.client),
+        };
+
+        Ok((id, Box::new(WriteMultiPart::new(upload, 8))))
+    }
+
+    async fn abort_multipart(&self, location: &Path, multipart_id: &MultipartId) -> Result<()> {
+        self.client
+            .delete_request(location, &[("uploadId", multipart_id)])
+            .await
+    }
+
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        self.client.get_opts(location, options).await
+    }
+
+    async fn delete(&self, location: &Path) -> Result<()> {
+        self.client.delete_request(location, &()).await
+    }
+
+    fn delete_stream<'a>(
+        &'a self,
+        locations: BoxStream<'a, Result<Path>>,
+    ) -> BoxStream<'a, Result<Path>> {
+        locations
+            .try_chunks(1_000)
+            .map(move |locations| async {
+                // Early return the error. We ignore the paths that have already been
+                // collected into the chunk.
+                let locations = locations.map_err(|e| e.1)?;
+                self.client
+                    .bulk_delete_request(locations)
+                    .await
+                    .map(futures::stream::iter)
+            })
+            .buffered(20)
+            .try_flatten()
+            .boxed()
+    }
+
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        self.client.list(prefix)
+    }
+
+    fn list_with_offset(
+        &self,
+        prefix: Option<&Path>,
+        offset: &Path,
+    ) -> BoxStream<'_, Result<ObjectMeta>> {
+        if self.client.config.is_s3_express() {
+            let offset = offset.clone();
+            // S3 Express does not support start-after
+            return self
+                .client
+                .list(prefix)
+                .try_filter(move |f| futures::future::ready(f.location > offset))
+                .boxed();
+        }
+
+        self.client.list_with_offset(prefix, offset)
+    }
+
+    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
+        self.client.list_with_delimiter(prefix).await
+    }
+
+    async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
+        self.client.copy_request(from, to).send().await?;
+        Ok(())
+    }
+
+    async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
+        let (k, v, status) = match &self.client.config.copy_if_not_exists {
+            Some(S3CopyIfNotExists::Header(k, v)) => (k, v, StatusCode::PRECONDITION_FAILED),
+            Some(S3CopyIfNotExists::HeaderWithStatus(k, v, status)) => (k, v, *status),
+            Some(S3CopyIfNotExists::Dynamo(lock)) => {
+                return lock.copy_if_not_exists(&self.client, from, to).await
+            }
+            None => {
+                return Err(Error::NotSupported {
+                    source: "S3 does not support copy-if-not-exists".to_string().into(),
+                })
+            }
+        };
+
+        let req = self.client.copy_request(from, to);
+        match req.header(k, v).send().await {
+            Err(RequestError::Retry { source, path }) if source.status() == Some(status) => {
+                Err(Error::AlreadyExists {
+                    source: Box::new(source),
+                    path,
+                })
+            }
+            Err(e) => Err(e.into()),
+            Ok(_) => Ok(()),
+        }
+    }
+}
+
+struct S3MultiPartUpload {
+    location: Path,
+    upload_id: String,
+    client: Arc<S3Client>,
+}
+
+#[async_trait]
+impl PutPart for S3MultiPartUpload {
+    async fn put_part(&self, buf: Vec<u8>, part_idx: usize) -> Result<PartId> {
+        self.client
+            .put_part(&self.location, &self.upload_id, part_idx, buf.into())
+            .await
+    }
+
+    async fn complete(&self, completed_parts: Vec<PartId>) -> Result<()> {
+        self.client
+            .complete_multipart(&self.location, &self.upload_id, completed_parts)
+            .await?;
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl MultiPartStore for AmazonS3 {
+    async fn create_multipart(&self, path: &Path) -> Result<MultipartId> {
+        self.client.create_multipart(path).await
+    }
+
+    async fn put_part(
+        &self,
+        path: &Path,
+        id: &MultipartId,
+        part_idx: usize,
+        data: Bytes,
+    ) -> Result<PartId> {
+        self.client.put_part(path, id, part_idx, data).await
+    }
+
+    async fn complete_multipart(
+        &self,
+        path: &Path,
+        id: &MultipartId,
+        parts: Vec<PartId>,
+    ) -> Result<PutResult> {
+        self.client.complete_multipart(path, id, parts).await
+    }
+
+    async fn abort_multipart(&self, path: &Path, id: &MultipartId) -> Result<()> {
+        self.client.delete_request(path, &[("uploadId", id)]).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::{client::get::GetClient, tests::*};
+    use bytes::Bytes;
+    use hyper::HeaderMap;
+    use tokio::io::AsyncWriteExt;
+
+    const NON_EXISTENT_NAME: &str = "nonexistentname";
+
+    #[tokio::test]
+    async fn s3_test() {
+        crate::test_util::maybe_skip_integration!();
+        let config = AmazonS3Builder::from_env();
+
+        let integration = config.build().unwrap();
+        let config = &integration.client.config;
+        let test_not_exists = config.copy_if_not_exists.is_some();
+        let test_conditional_put = config.conditional_put.is_some();
+
+        put_get_delete_list_opts(&integration).await;
+        get_opts(&integration).await;
+        list_uses_directories_correctly(&integration).await;
+        list_with_delimiter(&integration).await;
+        rename_and_copy(&integration).await;
+        stream_get(&integration).await;
+        multipart(&integration, &integration).await;
+        signing(&integration).await;
+        s3_encryption(&integration).await;
+
+        // Object tagging is not supported by S3 Express One Zone
+        if config.session_provider.is_none() {
+            tagging(&integration, !config.disable_tagging, |p| {
+                let client = Arc::clone(&integration.client);
+                async move { client.get_object_tagging(&p).await }
+            })
+            .await;
+        }
+
+        if test_not_exists {
+            copy_if_not_exists(&integration).await;
+        }
+        if test_conditional_put {
+            put_opts(&integration, true).await;
+        }
+
+        // run integration test with unsigned payload enabled
+        let builder = AmazonS3Builder::from_env().with_unsigned_payload(true);
+        let integration = builder.build().unwrap();
+        put_get_delete_list_opts(&integration).await;
+
+        // run integration test with checksum set to sha256
+        let builder = AmazonS3Builder::from_env().with_checksum_algorithm(Checksum::SHA256);
+        let integration = builder.build().unwrap();
+        put_get_delete_list_opts(&integration).await;
+
+        match &integration.client.config.copy_if_not_exists {
+            Some(S3CopyIfNotExists::Dynamo(d)) => dynamo::integration_test(&integration, d).await,
+            _ => eprintln!("Skipping dynamo integration test - dynamo not configured"),
+        };
+    }
+
+    #[tokio::test]
+    async fn s3_test_get_nonexistent_location() {
+        crate::test_util::maybe_skip_integration!();
+        let integration = AmazonS3Builder::from_env().build().unwrap();
+
+        let location = Path::from_iter([NON_EXISTENT_NAME]);
+
+        let err = get_nonexistent_object(&integration, Some(location))
+            .await
+            .unwrap_err();
+        assert!(matches!(err, crate::Error::NotFound { .. }), "{}", err);
+    }
+
+    #[tokio::test]
+    async fn s3_test_get_nonexistent_bucket() {
+        crate::test_util::maybe_skip_integration!();
+        let config = AmazonS3Builder::from_env().with_bucket_name(NON_EXISTENT_NAME);
+        let integration = config.build().unwrap();
+
+        let location = Path::from_iter([NON_EXISTENT_NAME]);
+
+        let err = integration.get(&location).await.unwrap_err();
+        assert!(matches!(err, crate::Error::NotFound { .. }), "{}", err);
+    }
+
+    #[tokio::test]
+    async fn s3_test_put_nonexistent_bucket() {
+        crate::test_util::maybe_skip_integration!();
+        let config = AmazonS3Builder::from_env().with_bucket_name(NON_EXISTENT_NAME);
+        let integration = config.build().unwrap();
+
+        let location = Path::from_iter([NON_EXISTENT_NAME]);
+        let data = Bytes::from("arbitrary data");
+
+        let err = integration.put(&location, data).await.unwrap_err();
+        assert!(matches!(err, crate::Error::NotFound { .. }), "{}", err);
+    }
+
+    #[tokio::test]
+    async fn s3_test_delete_nonexistent_location() {
+        crate::test_util::maybe_skip_integration!();
+        let integration = AmazonS3Builder::from_env().build().unwrap();
+
+        let location = Path::from_iter([NON_EXISTENT_NAME]);
+
+        integration.delete(&location).await.unwrap();
+    }
+
+    #[tokio::test]
+    async fn s3_test_delete_nonexistent_bucket() {
+        crate::test_util::maybe_skip_integration!();
+        let config = AmazonS3Builder::from_env().with_bucket_name(NON_EXISTENT_NAME);
+        let integration = config.build().unwrap();
+
+        let location = Path::from_iter([NON_EXISTENT_NAME]);
+
+        let err = integration.delete(&location).await.unwrap_err();
+        assert!(matches!(err, crate::Error::NotFound { .. }), "{}", err);
+    }
+
+    #[tokio::test]
+    #[ignore = "Tests shouldn't call use remote services by default"]
+    async fn test_disable_creds() {
+        // https://registry.opendata.aws/daylight-osm/
+        let v1 = AmazonS3Builder::new()
+            .with_bucket_name("daylight-map-distribution")
+            .with_region("us-west-1")
+            .with_access_key_id("local")
+            .with_secret_access_key("development")
+            .build()
+            .unwrap();
+
+        let prefix = Path::from("release");
+
+        v1.list_with_delimiter(Some(&prefix)).await.unwrap_err();
+
+        let v2 = AmazonS3Builder::new()
+            .with_bucket_name("daylight-map-distribution")
+            .with_region("us-west-1")
+            .with_skip_signature(true)
+            .build()
+            .unwrap();
+
+        v2.list_with_delimiter(Some(&prefix)).await.unwrap();
+    }
+
+    async fn s3_encryption(store: &AmazonS3) {
+        crate::test_util::maybe_skip_integration!();
+
+        let data = Bytes::from(vec![3u8; 1024]);
+
+        let encryption_headers: HeaderMap = store.client.config.encryption_headers.clone().into();
+        let expected_encryption =
+            if let Some(encryption_type) = encryption_headers.get("x-amz-server-side-encryption") {
+                encryption_type
+            } else {
+                eprintln!("Skipping S3 encryption test - encryption not configured");
+                return;
+            };
+
+        let locations = [
+            Path::from("test-encryption-1"),
+            Path::from("test-encryption-2"),
+            Path::from("test-encryption-3"),
+        ];
+
+        store.put(&locations[0], data.clone()).await.unwrap();
+        store.copy(&locations[0], &locations[1]).await.unwrap();
+
+        let (_, mut writer) = store.put_multipart(&locations[2]).await.unwrap();
+        writer.write_all(&data).await.unwrap();
+        writer.shutdown().await.unwrap();
+
+        for location in &locations {
+            let res = store
+                .client
+                .get_request(location, GetOptions::default())
+                .await
+                .unwrap();
+            let headers = res.headers();
+            assert_eq!(
+                headers
+                    .get("x-amz-server-side-encryption")
+                    .expect("object is not encrypted"),
+                expected_encryption
+            );
+
+            store.delete(location).await.unwrap();
+        }
+    }
+}
diff --git a/object_store/src/aws/precondition.rs b/object_store/src/aws/precondition.rs
new file mode 100644
index 000000000000..ad9e21537939
--- /dev/null
+++ b/object_store/src/aws/precondition.rs
@@ -0,0 +1,252 @@
+// 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.
+
+use crate::aws::dynamo::DynamoCommit;
+use crate::config::Parse;
+
+use itertools::Itertools;
+
+/// Configure how to provide [`ObjectStore::copy_if_not_exists`] for [`AmazonS3`].
+///
+/// [`ObjectStore::copy_if_not_exists`]: crate::ObjectStore::copy_if_not_exists
+/// [`AmazonS3`]: super::AmazonS3
+#[derive(Debug, Clone, PartialEq, Eq)]
+#[non_exhaustive]
+pub enum S3CopyIfNotExists {
+    /// Some S3-compatible stores, such as Cloudflare R2, support copy if not exists
+    /// semantics through custom headers.
+    ///
+    /// If set, [`ObjectStore::copy_if_not_exists`] will perform a normal copy operation
+    /// with the provided header pair, and expect the store to fail with `412 Precondition Failed`
+    /// if the destination file already exists.
+    ///
+    /// Encoded as `header:<HEADER_NAME>:<HEADER_VALUE>` ignoring whitespace
+    ///
+    /// For example `header: cf-copy-destination-if-none-match: *`, would set
+    /// the header `cf-copy-destination-if-none-match` to `*`
+    ///
+    /// [`ObjectStore::copy_if_not_exists`]: crate::ObjectStore::copy_if_not_exists
+    Header(String, String),
+    /// The same as [`S3CopyIfNotExists::Header`] but allows custom status code checking, for object stores that return values
+    /// other than 412.
+    ///
+    /// Encoded as `header-with-status:<HEADER_NAME>:<HEADER_VALUE>:<STATUS>` ignoring whitespace
+    HeaderWithStatus(String, String, reqwest::StatusCode),
+    /// The name of a DynamoDB table to use for coordination
+    ///
+    /// Encoded as either `dynamo:<TABLE_NAME>` or `dynamo:<TABLE_NAME>:<TIMEOUT_MILLIS>`
+    /// ignoring whitespace. The default timeout is used if not specified
+    ///
+    /// See [`DynamoCommit`] for more information
+    ///
+    /// This will use the same region, credentials and endpoint as configured for S3
+    Dynamo(DynamoCommit),
+}
+
+impl std::fmt::Display for S3CopyIfNotExists {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Header(k, v) => write!(f, "header: {}: {}", k, v),
+            Self::HeaderWithStatus(k, v, code) => {
+                write!(f, "header-with-status: {k}: {v}: {}", code.as_u16())
+            }
+            Self::Dynamo(lock) => write!(f, "dynamo: {}", lock.table_name()),
+        }
+    }
+}
+
+impl S3CopyIfNotExists {
+    fn from_str(s: &str) -> Option<Self> {
+        let (variant, value) = s.split_once(':')?;
+        match variant.trim() {
+            "header" => {
+                let (k, v) = value.split_once(':')?;
+                Some(Self::Header(k.trim().to_string(), v.trim().to_string()))
+            }
+            "header-with-status" => {
+                let (k, v, status) = value.split(':').collect_tuple()?;
+
+                let code = status.trim().parse().ok()?;
+
+                Some(Self::HeaderWithStatus(
+                    k.trim().to_string(),
+                    v.trim().to_string(),
+                    code,
+                ))
+            }
+            "dynamo" => Some(Self::Dynamo(DynamoCommit::from_str(value)?)),
+            _ => None,
+        }
+    }
+}
+
+impl Parse for S3CopyIfNotExists {
+    fn parse(v: &str) -> crate::Result<Self> {
+        Self::from_str(v).ok_or_else(|| crate::Error::Generic {
+            store: "Config",
+            source: format!("Failed to parse \"{v}\" as S3CopyIfNotExists").into(),
+        })
+    }
+}
+
+/// Configure how to provide conditional put support for [`AmazonS3`].
+///
+/// [`AmazonS3`]: super::AmazonS3
+#[derive(Debug, Clone, Eq, PartialEq)]
+#[allow(missing_copy_implementations)]
+#[non_exhaustive]
+pub enum S3ConditionalPut {
+    /// Some S3-compatible stores, such as Cloudflare R2 and minio support conditional
+    /// put using the standard [HTTP precondition] headers If-Match and If-None-Match
+    ///
+    /// Encoded as `etag` ignoring whitespace
+    ///
+    /// [HTTP precondition]: https://datatracker.ietf.org/doc/html/rfc9110#name-preconditions
+    ETagMatch,
+
+    /// The name of a DynamoDB table to use for coordination
+    ///
+    /// Encoded as either `dynamo:<TABLE_NAME>` or `dynamo:<TABLE_NAME>:<TIMEOUT_MILLIS>`
+    /// ignoring whitespace. The default timeout is used if not specified
+    ///
+    /// See [`DynamoCommit`] for more information
+    ///
+    /// This will use the same region, credentials and endpoint as configured for S3
+    Dynamo(DynamoCommit),
+}
+
+impl std::fmt::Display for S3ConditionalPut {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::ETagMatch => write!(f, "etag"),
+            Self::Dynamo(lock) => write!(f, "dynamo: {}", lock.table_name()),
+        }
+    }
+}
+
+impl S3ConditionalPut {
+    fn from_str(s: &str) -> Option<Self> {
+        match s.trim() {
+            "etag" => Some(Self::ETagMatch),
+            trimmed => match trimmed.split_once(':')? {
+                ("dynamo", s) => Some(Self::Dynamo(DynamoCommit::from_str(s)?)),
+                _ => None,
+            },
+        }
+    }
+}
+
+impl Parse for S3ConditionalPut {
+    fn parse(v: &str) -> crate::Result<Self> {
+        Self::from_str(v).ok_or_else(|| crate::Error::Generic {
+            store: "Config",
+            source: format!("Failed to parse \"{v}\" as S3PutConditional").into(),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::S3CopyIfNotExists;
+    use crate::aws::{DynamoCommit, S3ConditionalPut};
+
+    #[test]
+    fn parse_s3_copy_if_not_exists_header() {
+        let input = "header: cf-copy-destination-if-none-match: *";
+        let expected = Some(S3CopyIfNotExists::Header(
+            "cf-copy-destination-if-none-match".to_owned(),
+            "*".to_owned(),
+        ));
+
+        assert_eq!(expected, S3CopyIfNotExists::from_str(input));
+    }
+
+    #[test]
+    fn parse_s3_copy_if_not_exists_header_with_status() {
+        let input = "header-with-status:key:value:403";
+        let expected = Some(S3CopyIfNotExists::HeaderWithStatus(
+            "key".to_owned(),
+            "value".to_owned(),
+            reqwest::StatusCode::FORBIDDEN,
+        ));
+
+        assert_eq!(expected, S3CopyIfNotExists::from_str(input));
+    }
+
+    #[test]
+    fn parse_s3_copy_if_not_exists_dynamo() {
+        let input = "dynamo: table:100";
+        let expected = Some(S3CopyIfNotExists::Dynamo(
+            DynamoCommit::new("table".into()).with_timeout(100),
+        ));
+        assert_eq!(expected, S3CopyIfNotExists::from_str(input));
+    }
+
+    #[test]
+    fn parse_s3_condition_put_dynamo() {
+        let input = "dynamo: table:1300";
+        let expected = Some(S3ConditionalPut::Dynamo(
+            DynamoCommit::new("table".into()).with_timeout(1300),
+        ));
+        assert_eq!(expected, S3ConditionalPut::from_str(input));
+    }
+
+    #[test]
+    fn parse_s3_copy_if_not_exists_header_whitespace_invariant() {
+        let expected = Some(S3CopyIfNotExists::Header(
+            "cf-copy-destination-if-none-match".to_owned(),
+            "*".to_owned(),
+        ));
+
+        const INPUTS: &[&str] = &[
+            "header:cf-copy-destination-if-none-match:*",
+            "header: cf-copy-destination-if-none-match:*",
+            "header: cf-copy-destination-if-none-match: *",
+            "header : cf-copy-destination-if-none-match: *",
+            "header : cf-copy-destination-if-none-match : *",
+            "header : cf-copy-destination-if-none-match : * ",
+        ];
+
+        for input in INPUTS {
+            assert_eq!(expected, S3CopyIfNotExists::from_str(input));
+        }
+    }
+
+    #[test]
+    fn parse_s3_copy_if_not_exists_header_with_status_whitespace_invariant() {
+        let expected = Some(S3CopyIfNotExists::HeaderWithStatus(
+            "key".to_owned(),
+            "value".to_owned(),
+            reqwest::StatusCode::FORBIDDEN,
+        ));
+
+        const INPUTS: &[&str] = &[
+            "header-with-status:key:value:403",
+            "header-with-status: key:value:403",
+            "header-with-status: key: value:403",
+            "header-with-status: key: value: 403",
+            "header-with-status : key: value: 403",
+            "header-with-status : key : value: 403",
+            "header-with-status : key : value : 403",
+            "header-with-status : key : value : 403 ",
+        ];
+
+        for input in INPUTS {
+            assert_eq!(expected, S3CopyIfNotExists::from_str(input));
+        }
+    }
+}
diff --git a/object_store/src/aws/resolve.rs b/object_store/src/aws/resolve.rs
new file mode 100644
index 000000000000..12c9f26d220b
--- /dev/null
+++ b/object_store/src/aws/resolve.rs
@@ -0,0 +1,103 @@
+// 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.
+
+use crate::aws::STORE;
+use crate::{ClientOptions, Result};
+use snafu::{ensure, OptionExt, ResultExt, Snafu};
+
+/// A specialized `Error` for object store-related errors
+#[derive(Debug, Snafu)]
+#[allow(missing_docs)]
+enum Error {
+    #[snafu(display("Bucket '{}' not found", bucket))]
+    BucketNotFound { bucket: String },
+
+    #[snafu(display("Failed to resolve region for bucket '{}'", bucket))]
+    ResolveRegion {
+        bucket: String,
+        source: reqwest::Error,
+    },
+
+    #[snafu(display("Failed to parse the region for bucket '{}'", bucket))]
+    RegionParse { bucket: String },
+}
+
+impl From<Error> for crate::Error {
+    fn from(source: Error) -> Self {
+        Self::Generic {
+            store: STORE,
+            source: Box::new(source),
+        }
+    }
+}
+
+/// Get the bucket region using the [HeadBucket API]. This will fail if the bucket does not exist.
+///
+/// [HeadBucket API]: https://docs.aws.amazon.com/AmazonS3/latest/API/API_HeadBucket.html
+pub async fn resolve_bucket_region(bucket: &str, client_options: &ClientOptions) -> Result<String> {
+    use reqwest::StatusCode;
+
+    let endpoint = format!("https://{}.s3.amazonaws.com", bucket);
+
+    let client = client_options.client()?;
+
+    let response = client
+        .head(&endpoint)
+        .send()
+        .await
+        .context(ResolveRegionSnafu { bucket })?;
+
+    ensure!(
+        response.status() != StatusCode::NOT_FOUND,
+        BucketNotFoundSnafu { bucket }
+    );
+
+    let region = response
+        .headers()
+        .get("x-amz-bucket-region")
+        .and_then(|x| x.to_str().ok())
+        .context(RegionParseSnafu { bucket })?;
+
+    Ok(region.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_private_bucket() {
+        let bucket = "bloxbender";
+
+        let region = resolve_bucket_region(bucket, &ClientOptions::new())
+            .await
+            .unwrap();
+
+        let expected = "us-west-2".to_string();
+
+        assert_eq!(region, expected);
+    }
+
+    #[tokio::test]
+    async fn test_bucket_does_not_exist() {
+        let bucket = "please-dont-exist";
+
+        let result = resolve_bucket_region(bucket, &ClientOptions::new()).await;
+
+        assert!(result.is_err());
+    }
+}
diff --git a/object_store/src/azure.rs b/object_store/src/azure.rs
deleted file mode 100644
index 6a5f537997cd..000000000000
--- a/object_store/src/azure.rs
+++ /dev/null
@@ -1,867 +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.
-
-//! An object store implementation for Azure blob storage
-//!
-//! ## Streaming uploads
-//!
-//! [ObjectStore::put_multipart] will upload data in blocks and write a blob from those
-//! blocks. Data is buffered internally to make blocks of at least 5MB and blocks
-//! are uploaded concurrently.
-//!
-//! [ObjectStore::abort_multipart] is a no-op, since Azure Blob Store doesn't provide
-//! a way to drop old blocks. Instead unused blocks are automatically cleaned up
-//! after 7 days.
-use crate::{
-    multipart::{CloudMultiPartUpload, CloudMultiPartUploadImpl, UploadPart},
-    path::{Path, DELIMITER},
-    util::format_prefix,
-    GetResult, ListResult, MultipartId, ObjectMeta, ObjectStore, Result,
-};
-use async_trait::async_trait;
-use azure_core::{prelude::*, HttpClient};
-use azure_storage::core::prelude::{AsStorageClient, StorageAccountClient};
-use azure_storage_blobs::blob::responses::ListBlobsResponse;
-use azure_storage_blobs::blob::Blob;
-use azure_storage_blobs::{
-    prelude::{AsBlobClient, AsContainerClient, ContainerClient},
-    DeleteSnapshotsMethod,
-};
-use bytes::Bytes;
-use futures::{
-    future::BoxFuture,
-    stream::{self, BoxStream},
-    StreamExt, TryStreamExt,
-};
-use snafu::{ResultExt, Snafu};
-use std::collections::BTreeSet;
-use std::io;
-use std::{convert::TryInto, sync::Arc};
-use tokio::io::AsyncWrite;
-use url::Url;
-
-/// A specialized `Error` for Azure object store-related errors
-#[derive(Debug, Snafu)]
-#[allow(missing_docs)]
-enum Error {
-    #[snafu(display(
-        "Unable to DELETE data. Container: {}, Location: {}, Error: {} ({:?})",
-        container,
-        path,
-        source,
-        source,
-    ))]
-    UnableToDeleteData {
-        source: Box<dyn std::error::Error + Send + Sync>,
-        container: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to GET data. Container: {}, Location: {}, Error: {} ({:?})",
-        container,
-        path,
-        source,
-        source,
-    ))]
-    UnableToGetData {
-        source: Box<dyn std::error::Error + Send + Sync>,
-        container: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to HEAD data. Container: {}, Location: {}, Error: {} ({:?})",
-        container,
-        path,
-        source,
-        source,
-    ))]
-    UnableToHeadData {
-        source: Box<dyn std::error::Error + Send + Sync>,
-        container: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to GET part of the data. Container: {}, Location: {}, Error: {} ({:?})",
-        container,
-        path,
-        source,
-        source,
-    ))]
-    UnableToGetPieceOfData {
-        source: Box<dyn std::error::Error + Send + Sync>,
-        container: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to PUT data. Bucket: {}, Location: {}, Error: {} ({:?})",
-        container,
-        path,
-        source,
-        source,
-    ))]
-    UnableToPutData {
-        source: Box<dyn std::error::Error + Send + Sync>,
-        container: String,
-        path: String,
-    },
-
-    #[snafu(display(
-        "Unable to list data. Bucket: {}, Error: {} ({:?})",
-        container,
-        source,
-        source,
-    ))]
-    UnableToListData {
-        source: Box<dyn std::error::Error + Send + Sync>,
-        container: String,
-    },
-
-    #[snafu(display(
-        "Unable to copy object. Container: {}, From: {}, To: {}, Error: {}",
-        container,
-        from,
-        to,
-        source
-    ))]
-    UnableToCopyFile {
-        source: Box<dyn std::error::Error + Send + Sync>,
-        container: String,
-        from: String,
-        to: String,
-    },
-
-    #[snafu(display(
-        "Unable parse source url. Container: {}, Error: {}",
-        container,
-        source
-    ))]
-    UnableToParseUrl {
-        source: url::ParseError,
-        container: String,
-    },
-
-    NotFound {
-        path: String,
-        source: Box<dyn std::error::Error + Send + Sync + 'static>,
-    },
-
-    AlreadyExists {
-        path: String,
-        source: Box<dyn std::error::Error + Send + Sync + 'static>,
-    },
-
-    #[cfg(not(feature = "azure_test"))]
-    #[snafu(display(
-        "Azurite (azure emulator) support not compiled in, please add `azure_test` feature"
-    ))]
-    NoEmulatorFeature,
-
-    #[snafu(display(
-        "Unable parse emulator url {}={}, Error: {}",
-        env_name,
-        env_value,
-        source
-    ))]
-    UnableToParseEmulatorUrl {
-        env_name: String,
-        env_value: String,
-        source: url::ParseError,
-    },
-
-    #[snafu(display("Account must be specified"))]
-    MissingAccount {},
-
-    #[snafu(display("Access key must be specified"))]
-    MissingAccessKey {},
-
-    #[snafu(display("Container name must be specified"))]
-    MissingContainerName {},
-}
-
-impl From<Error> for super::Error {
-    fn from(source: Error) -> Self {
-        match source {
-            Error::NotFound { path, source } => Self::NotFound { path, source },
-            Error::AlreadyExists { path, source } => Self::AlreadyExists { path, source },
-            _ => Self::Generic {
-                store: "Azure Blob Storage",
-                source: Box::new(source),
-            },
-        }
-    }
-}
-
-/// Interface for [Microsoft Azure Blob Storage](https://azure.microsoft.com/en-us/services/storage/blobs/).
-#[derive(Debug)]
-pub struct MicrosoftAzure {
-    container_client: Arc<ContainerClient>,
-    container_name: String,
-    blob_base_url: String,
-    is_emulator: bool,
-}
-
-impl std::fmt::Display for MicrosoftAzure {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self.is_emulator {
-            true => write!(f, "MicrosoftAzureEmulator({})", self.container_name),
-            false => write!(f, "MicrosoftAzure({})", self.container_name),
-        }
-    }
-}
-
-#[allow(clippy::borrowed_box)]
-fn check_err_not_found(err: &Box<dyn std::error::Error + Send + Sync>) -> bool {
-    if let Some(azure_core::HttpError::StatusCode { status, .. }) =
-        err.downcast_ref::<azure_core::HttpError>()
-    {
-        return status.as_u16() == 404;
-    };
-    false
-}
-
-#[async_trait]
-impl ObjectStore for MicrosoftAzure {
-    async fn put(&self, location: &Path, bytes: Bytes) -> Result<()> {
-        let bytes = bytes::BytesMut::from(&*bytes);
-
-        self.container_client
-            .as_blob_client(location.as_ref())
-            .put_block_blob(bytes)
-            .execute()
-            .await
-            .context(UnableToPutDataSnafu {
-                container: &self.container_name,
-                path: location.to_owned(),
-            })?;
-
-        Ok(())
-    }
-
-    async fn put_multipart(
-        &self,
-        location: &Path,
-    ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
-        let inner = AzureMultiPartUpload {
-            container_client: Arc::clone(&self.container_client),
-            location: location.to_owned(),
-        };
-        Ok((String::new(), Box::new(CloudMultiPartUpload::new(inner, 8))))
-    }
-
-    async fn abort_multipart(
-        &self,
-        _location: &Path,
-        _multipart_id: &MultipartId,
-    ) -> Result<()> {
-        // There is no way to drop blocks that have been uploaded. Instead, they simply
-        // expire in 7 days.
-        Ok(())
-    }
-
-    async fn get(&self, location: &Path) -> Result<GetResult> {
-        let blob = self
-            .container_client
-            .as_blob_client(location.as_ref())
-            .get()
-            .execute()
-            .await
-            .map_err(|err| {
-                if check_err_not_found(&err) {
-                    return Error::NotFound {
-                        source: err,
-                        path: location.to_string(),
-                    };
-                };
-                Error::UnableToGetData {
-                    source: err,
-                    container: self.container_name.clone(),
-                    path: location.to_string(),
-                }
-            })?;
-
-        Ok(GetResult::Stream(
-            futures::stream::once(async move { Ok(blob.data) }).boxed(),
-        ))
-    }
-
-    async fn get_range(
-        &self,
-        location: &Path,
-        range: std::ops::Range<usize>,
-    ) -> Result<Bytes> {
-        let blob = self
-            .container_client
-            .as_blob_client(location.as_ref())
-            .get()
-            .range(range)
-            .execute()
-            .await
-            .map_err(|err| {
-                if check_err_not_found(&err) {
-                    return Error::NotFound {
-                        source: err,
-                        path: location.to_string(),
-                    };
-                };
-                Error::UnableToGetPieceOfData {
-                    source: err,
-                    container: self.container_name.clone(),
-                    path: location.to_string(),
-                }
-            })?;
-
-        Ok(blob.data)
-    }
-
-    async fn head(&self, location: &Path) -> Result<ObjectMeta> {
-        let res = self
-            .container_client
-            .as_blob_client(location.as_ref())
-            .get_properties()
-            .execute()
-            .await
-            .map_err(|err| {
-                if check_err_not_found(&err) {
-                    return Error::NotFound {
-                        source: err,
-                        path: location.to_string(),
-                    };
-                };
-                Error::UnableToHeadData {
-                    source: err,
-                    container: self.container_name.clone(),
-                    path: location.to_string(),
-                }
-            })?;
-
-        convert_object_meta(res.blob)?.ok_or_else(|| super::Error::NotFound {
-            path: location.to_string(),
-            source: "is directory".to_string().into(),
-        })
-    }
-
-    async fn delete(&self, location: &Path) -> Result<()> {
-        self.container_client
-            .as_blob_client(location.as_ref())
-            .delete()
-            .delete_snapshots_method(DeleteSnapshotsMethod::Include)
-            .execute()
-            .await
-            .context(UnableToDeleteDataSnafu {
-                container: &self.container_name,
-                path: location.to_string(),
-            })?;
-
-        Ok(())
-    }
-
-    async fn list(
-        &self,
-        prefix: Option<&Path>,
-    ) -> Result<BoxStream<'_, Result<ObjectMeta>>> {
-        let stream = self
-            .list_impl(prefix, false)
-            .await?
-            .map_ok(|resp| {
-                let names = resp
-                    .blobs
-                    .blobs
-                    .into_iter()
-                    .filter_map(|blob| convert_object_meta(blob).transpose());
-                futures::stream::iter(names)
-            })
-            .try_flatten()
-            .boxed();
-
-        Ok(stream)
-    }
-
-    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
-        let mut stream = self.list_impl(prefix, true).await?;
-
-        let mut common_prefixes = BTreeSet::new();
-        let mut objects = Vec::new();
-
-        while let Some(res) = stream.next().await {
-            let response = res?;
-
-            let prefixes = response.blobs.blob_prefix.unwrap_or_default();
-            for p in prefixes {
-                common_prefixes.insert(Path::parse(&p.name)?);
-            }
-
-            let blobs = response.blobs.blobs;
-            objects.reserve(blobs.len());
-            for blob in blobs {
-                if let Some(meta) = convert_object_meta(blob)? {
-                    objects.push(meta);
-                }
-            }
-        }
-
-        Ok(ListResult {
-            common_prefixes: common_prefixes.into_iter().collect(),
-            objects,
-        })
-    }
-
-    async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
-        let from_url = self.get_copy_from_url(from)?;
-        self.container_client
-            .as_blob_client(to.as_ref())
-            .copy(&from_url)
-            .execute()
-            .await
-            .context(UnableToCopyFileSnafu {
-                container: &self.container_name,
-                from: from.as_ref(),
-                to: to.as_ref(),
-            })?;
-        Ok(())
-    }
-
-    async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
-        let from_url = self.get_copy_from_url(from)?;
-        self.container_client
-            .as_blob_client(to.as_ref())
-            .copy(&from_url)
-            .if_match_condition(IfMatchCondition::NotMatch("*".to_string()))
-            .execute()
-            .await
-            .map_err(|err| {
-                if let Some(azure_core::HttpError::StatusCode { status, .. }) =
-                    err.downcast_ref::<azure_core::HttpError>()
-                {
-                    if status.as_u16() == 409 {
-                        return Error::AlreadyExists {
-                            source: err,
-                            path: to.to_string(),
-                        };
-                    };
-                };
-                Error::UnableToCopyFile {
-                    source: err,
-                    container: self.container_name.clone(),
-                    from: from.to_string(),
-                    to: to.to_string(),
-                }
-            })?;
-        Ok(())
-    }
-}
-
-impl MicrosoftAzure {
-    /// helper function to create a source url for copy function
-    fn get_copy_from_url(&self, from: &Path) -> Result<Url> {
-        let mut url =
-            Url::parse(&format!("{}/{}", &self.blob_base_url, self.container_name))
-                .context(UnableToParseUrlSnafu {
-                    container: &self.container_name,
-                })?;
-
-        url.path_segments_mut().unwrap().extend(from.parts());
-        Ok(url)
-    }
-
-    async fn list_impl(
-        &self,
-        prefix: Option<&Path>,
-        delimiter: bool,
-    ) -> Result<BoxStream<'_, Result<ListBlobsResponse>>> {
-        enum ListState {
-            Start,
-            HasMore(String),
-            Done,
-        }
-
-        let prefix_raw = format_prefix(prefix);
-
-        Ok(stream::unfold(ListState::Start, move |state| {
-            let mut request = self.container_client.list_blobs();
-
-            if let Some(p) = prefix_raw.as_deref() {
-                request = request.prefix(p);
-            }
-
-            if delimiter {
-                request = request.delimiter(Delimiter::new(DELIMITER));
-            }
-
-            async move {
-                match state {
-                    ListState::HasMore(ref marker) => {
-                        request = request.next_marker(marker as &str);
-                    }
-                    ListState::Done => {
-                        return None;
-                    }
-                    ListState::Start => {}
-                }
-
-                let resp = match request.execute().await.context(UnableToListDataSnafu {
-                    container: &self.container_name,
-                }) {
-                    Ok(resp) => resp,
-                    Err(err) => return Some((Err(crate::Error::from(err)), state)),
-                };
-
-                let next_state = if let Some(marker) = &resp.next_marker {
-                    ListState::HasMore(marker.as_str().to_string())
-                } else {
-                    ListState::Done
-                };
-
-                Some((Ok(resp), next_state))
-            }
-        })
-        .boxed())
-    }
-}
-
-/// Returns `None` if is a directory
-fn convert_object_meta(blob: Blob) -> Result<Option<ObjectMeta>> {
-    let location = Path::parse(blob.name)?;
-    let last_modified = blob.properties.last_modified;
-    let size = blob
-        .properties
-        .content_length
-        .try_into()
-        .expect("unsupported size on this platform");
-
-    // This is needed to filter out gen2 directories
-    // https://docs.microsoft.com/en-us/azure/storage/blobs/data-lake-storage-known-issues#blob-storage-apis
-    Ok((size > 0).then(|| ObjectMeta {
-        location,
-        last_modified,
-        size,
-    }))
-}
-
-#[cfg(feature = "azure_test")]
-fn check_if_emulator_works() -> Result<()> {
-    Ok(())
-}
-
-#[cfg(not(feature = "azure_test"))]
-fn check_if_emulator_works() -> Result<()> {
-    Err(Error::NoEmulatorFeature.into())
-}
-
-/// Parses the contents of the environment variable `env_name` as a URL
-/// if present, otherwise falls back to default_url
-fn url_from_env(env_name: &str, default_url: &str) -> Result<Url> {
-    let url = match std::env::var(env_name) {
-        Ok(env_value) => {
-            Url::parse(&env_value).context(UnableToParseEmulatorUrlSnafu {
-                env_name,
-                env_value,
-            })?
-        }
-        Err(_) => Url::parse(default_url).expect("Failed to parse default URL"),
-    };
-    Ok(url)
-}
-
-/// Configure a connection to Mirosoft Azure Blob Storage bucket using
-/// the specified credentials.
-///
-/// # Example
-/// ```
-/// # let ACCOUNT = "foo";
-/// # let BUCKET_NAME = "foo";
-/// # let ACCESS_KEY = "foo";
-/// # use object_store::azure::MicrosoftAzureBuilder;
-/// let azure = MicrosoftAzureBuilder::new()
-///  .with_account(ACCOUNT)
-///  .with_access_key(ACCESS_KEY)
-///  .with_container_name(BUCKET_NAME)
-///  .build();
-/// ```
-#[derive(Debug, Default)]
-pub struct MicrosoftAzureBuilder {
-    account: Option<String>,
-    access_key: Option<String>,
-    container_name: Option<String>,
-    use_emulator: bool,
-}
-
-impl MicrosoftAzureBuilder {
-    /// Create a new [`MicrosoftAzureBuilder`] with default values.
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    /// Set the Azure Account (required)
-    pub fn with_account(mut self, account: impl Into<String>) -> Self {
-        self.account = Some(account.into());
-        self
-    }
-
-    /// Set the Azure Access Key (required)
-    pub fn with_access_key(mut self, access_key: impl Into<String>) -> Self {
-        self.access_key = Some(access_key.into());
-        self
-    }
-
-    /// Set the Azure Container Name (required)
-    pub fn with_container_name(mut self, container_name: impl Into<String>) -> Self {
-        self.container_name = Some(container_name.into());
-        self
-    }
-
-    /// Set if the Azure emulator should be used (defaults to false)
-    pub fn with_use_emulator(mut self, use_emulator: bool) -> Self {
-        self.use_emulator = use_emulator;
-        self
-    }
-
-    /// Configure a connection to container with given name on Microsoft Azure
-    /// Blob store.
-    pub fn build(self) -> Result<MicrosoftAzure> {
-        let Self {
-            account,
-            access_key,
-            container_name,
-            use_emulator,
-        } = self;
-
-        let account = account.ok_or(Error::MissingAccount {})?;
-        let access_key = access_key.ok_or(Error::MissingAccessKey {})?;
-        let container_name = container_name.ok_or(Error::MissingContainerName {})?;
-
-        let http_client: Arc<dyn HttpClient> = Arc::new(reqwest::Client::new());
-
-        let (is_emulator, storage_account_client) = if use_emulator {
-            check_if_emulator_works()?;
-            // Allow overriding defaults. Values taken from
-            // from https://docs.rs/azure_storage/0.2.0/src/azure_storage/core/clients/storage_account_client.rs.html#129-141
-            let http_client = azure_core::new_http_client();
-            let blob_storage_url =
-                url_from_env("AZURITE_BLOB_STORAGE_URL", "http://127.0.0.1:10000")?;
-            let queue_storage_url =
-                url_from_env("AZURITE_QUEUE_STORAGE_URL", "http://127.0.0.1:10001")?;
-            let table_storage_url =
-                url_from_env("AZURITE_TABLE_STORAGE_URL", "http://127.0.0.1:10002")?;
-            let filesystem_url =
-                url_from_env("AZURITE_TABLE_STORAGE_URL", "http://127.0.0.1:10004")?;
-
-            let storage_client = StorageAccountClient::new_emulator(
-                http_client,
-                &blob_storage_url,
-                &table_storage_url,
-                &queue_storage_url,
-                &filesystem_url,
-            );
-
-            (true, storage_client)
-        } else {
-            (
-                false,
-                StorageAccountClient::new_access_key(
-                    Arc::clone(&http_client),
-                    &account,
-                    &access_key,
-                ),
-            )
-        };
-
-        let storage_client = storage_account_client.as_storage_client();
-        let blob_base_url = storage_account_client
-            .blob_storage_url()
-            .as_ref()
-            // make url ending consistent between the emulator and remote storage account
-            .trim_end_matches('/')
-            .to_string();
-
-        let container_client = storage_client.as_container_client(&container_name);
-
-        Ok(MicrosoftAzure {
-            container_client,
-            container_name,
-            blob_base_url,
-            is_emulator,
-        })
-    }
-}
-
-// Relevant docs: https://azure.github.io/Storage/docs/application-and-user-data/basics/azure-blob-storage-upload-apis/
-// In Azure Blob Store, parts are "blocks"
-// put_multipart_part -> PUT block
-// complete -> PUT block list
-// abort -> No equivalent; blocks are simply dropped after 7 days
-#[derive(Debug, Clone)]
-struct AzureMultiPartUpload {
-    container_client: Arc<ContainerClient>,
-    location: Path,
-}
-
-impl AzureMultiPartUpload {
-    /// Gets the block id corresponding to the part index.
-    ///
-    /// In Azure, the user determines what id each block has. They must be
-    /// unique within an upload and of consistent length.
-    fn get_block_id(&self, part_idx: usize) -> String {
-        format!("{:20}", part_idx)
-    }
-}
-
-impl CloudMultiPartUploadImpl for AzureMultiPartUpload {
-    fn put_multipart_part(
-        &self,
-        buf: Vec<u8>,
-        part_idx: usize,
-    ) -> BoxFuture<'static, Result<(usize, UploadPart), io::Error>> {
-        let client = Arc::clone(&self.container_client);
-        let location = self.location.clone();
-        let block_id = self.get_block_id(part_idx);
-
-        Box::pin(async move {
-            client
-                .as_blob_client(location.as_ref())
-                .put_block(block_id.clone(), buf)
-                .execute()
-                .await
-                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
-
-            Ok((
-                part_idx,
-                UploadPart {
-                    content_id: block_id,
-                },
-            ))
-        })
-    }
-
-    fn complete(
-        &self,
-        completed_parts: Vec<Option<UploadPart>>,
-    ) -> BoxFuture<'static, Result<(), io::Error>> {
-        let parts =
-            completed_parts
-                .into_iter()
-                .enumerate()
-                .map(|(part_number, maybe_part)| match maybe_part {
-                    Some(part) => {
-                        Ok(azure_storage_blobs::blob::BlobBlockType::Uncommitted(
-                            azure_storage_blobs::BlockId::new(part.content_id),
-                        ))
-                    }
-                    None => Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        format!("Missing information for upload part {:?}", part_number),
-                    )),
-                });
-
-        let client = Arc::clone(&self.container_client);
-        let location = self.location.clone();
-
-        Box::pin(async move {
-            let block_list = azure_storage_blobs::blob::BlockList {
-                blocks: parts.collect::<Result<_, io::Error>>()?,
-            };
-
-            client
-                .as_blob_client(location.as_ref())
-                .put_block_list(&block_list)
-                .execute()
-                .await
-                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
-
-            Ok(())
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::tests::{
-        copy_if_not_exists, list_uses_directories_correctly, list_with_delimiter,
-        put_get_delete_list, rename_and_copy,
-    };
-    use std::env;
-
-    // Helper macro to skip tests if TEST_INTEGRATION and the Azure environment
-    // variables are not set.
-    macro_rules! maybe_skip_integration {
-        () => {{
-            dotenv::dotenv().ok();
-
-            let use_emulator = std::env::var("AZURE_USE_EMULATOR").is_ok();
-
-            let mut required_vars = vec!["OBJECT_STORE_BUCKET"];
-            if !use_emulator {
-                required_vars.push("AZURE_STORAGE_ACCOUNT");
-                required_vars.push("AZURE_STORAGE_ACCESS_KEY");
-            }
-            let unset_vars: Vec<_> = required_vars
-                .iter()
-                .filter_map(|&name| match env::var(name) {
-                    Ok(_) => None,
-                    Err(_) => Some(name),
-                })
-                .collect();
-            let unset_var_names = unset_vars.join(", ");
-
-            let force = std::env::var("TEST_INTEGRATION");
-
-            if force.is_ok() && !unset_var_names.is_empty() {
-                panic!(
-                    "TEST_INTEGRATION is set, \
-                        but variable(s) {} need to be set",
-                    unset_var_names
-                )
-            } else if force.is_err() {
-                eprintln!(
-                    "skipping Azure integration test - set {}TEST_INTEGRATION to run",
-                    if unset_var_names.is_empty() {
-                        String::new()
-                    } else {
-                        format!("{} and ", unset_var_names)
-                    }
-                );
-                return;
-            } else {
-                MicrosoftAzureBuilder::new()
-                    .with_account(env::var("AZURE_STORAGE_ACCOUNT").unwrap_or_default())
-                    .with_access_key(
-                        env::var("AZURE_STORAGE_ACCESS_KEY").unwrap_or_default(),
-                    )
-                    .with_container_name(
-                        env::var("OBJECT_STORE_BUCKET")
-                            .expect("already checked OBJECT_STORE_BUCKET"),
-                    )
-                    .with_use_emulator(use_emulator)
-            }
-        }};
-    }
-
-    #[tokio::test]
-    async fn azure_blob_test() {
-        let integration = maybe_skip_integration!().build().unwrap();
-
-        put_get_delete_list(&integration).await;
-        list_uses_directories_correctly(&integration).await;
-        list_with_delimiter(&integration).await;
-        rename_and_copy(&integration).await;
-        copy_if_not_exists(&integration).await;
-    }
-}
diff --git a/object_store/src/azure/builder.rs b/object_store/src/azure/builder.rs
new file mode 100644
index 000000000000..ee0953456ad1
--- /dev/null
+++ b/object_store/src/azure/builder.rs
@@ -0,0 +1,1111 @@
+// 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.
+
+use crate::azure::client::{AzureClient, AzureConfig};
+use crate::azure::credential::{
+    AzureAccessKey, AzureCliCredential, ClientSecretOAuthProvider, ImdsManagedIdentityProvider,
+    WorkloadIdentityOAuthProvider,
+};
+use crate::azure::{AzureCredential, AzureCredentialProvider, MicrosoftAzure, STORE};
+use crate::client::TokenCredentialProvider;
+use crate::config::ConfigValue;
+use crate::{ClientConfigKey, ClientOptions, Result, RetryConfig, StaticCredentialProvider};
+use percent_encoding::percent_decode_str;
+use serde::{Deserialize, Serialize};
+use snafu::{OptionExt, ResultExt, Snafu};
+use std::str::FromStr;
+use std::sync::Arc;
+use url::Url;
+
+/// The well-known account used by Azurite and the legacy Azure Storage Emulator.
+///
+/// <https://docs.microsoft.com/azure/storage/common/storage-use-azurite#well-known-storage-account-and-key>
+const EMULATOR_ACCOUNT: &str = "devstoreaccount1";
+
+/// The well-known account key used by Azurite and the legacy Azure Storage Emulator.
+///
+/// <https://docs.microsoft.com/azure/storage/common/storage-use-azurite#well-known-storage-account-and-key>
+const EMULATOR_ACCOUNT_KEY: &str =
+    "Eby8vdM02xNOcqFlqUwJPLlmEtlCDXJ1OUzFT50uSRZ6IFsuFq2UVErCz4I6tq/K1SZFPTOtr/KBHBeksoGMGw==";
+
+const MSI_ENDPOINT_ENV_KEY: &str = "IDENTITY_ENDPOINT";
+
+/// A specialized `Error` for Azure builder-related errors
+#[derive(Debug, Snafu)]
+#[allow(missing_docs)]
+enum Error {
+    #[snafu(display("Unable parse source url. Url: {}, Error: {}", url, source))]
+    UnableToParseUrl {
+        source: url::ParseError,
+        url: String,
+    },
+
+    #[snafu(display(
+        "Unable parse emulator url {}={}, Error: {}",
+        env_name,
+        env_value,
+        source
+    ))]
+    UnableToParseEmulatorUrl {
+        env_name: String,
+        env_value: String,
+        source: url::ParseError,
+    },
+
+    #[snafu(display("Account must be specified"))]
+    MissingAccount {},
+
+    #[snafu(display("Container name must be specified"))]
+    MissingContainerName {},
+
+    #[snafu(display(
+        "Unknown url scheme cannot be parsed into storage location: {}",
+        scheme
+    ))]
+    UnknownUrlScheme { scheme: String },
+
+    #[snafu(display("URL did not match any known pattern for scheme: {}", url))]
+    UrlNotRecognised { url: String },
+
+    #[snafu(display("Failed parsing an SAS key"))]
+    DecodeSasKey { source: std::str::Utf8Error },
+
+    #[snafu(display("Missing component in SAS query pair"))]
+    MissingSasComponent {},
+
+    #[snafu(display("Configuration key: '{}' is not known.", key))]
+    UnknownConfigurationKey { key: String },
+
+    #[snafu(display("Unable to extract metadata from headers: {}", source))]
+    Metadata {
+        source: crate::client::header::Error,
+    },
+}
+
+impl From<Error> for crate::Error {
+    fn from(source: Error) -> Self {
+        match source {
+            Error::UnknownConfigurationKey { key } => {
+                Self::UnknownConfigurationKey { store: STORE, key }
+            }
+            _ => Self::Generic {
+                store: STORE,
+                source: Box::new(source),
+            },
+        }
+    }
+}
+
+/// Configure a connection to Microsoft Azure Blob Storage container using
+/// the specified credentials.
+///
+/// # Example
+/// ```
+/// # let ACCOUNT = "foo";
+/// # let BUCKET_NAME = "foo";
+/// # let ACCESS_KEY = "foo";
+/// # use object_store::azure::MicrosoftAzureBuilder;
+/// let azure = MicrosoftAzureBuilder::new()
+///  .with_account(ACCOUNT)
+///  .with_access_key(ACCESS_KEY)
+///  .with_container_name(BUCKET_NAME)
+///  .build();
+/// ```
+#[derive(Default, Clone)]
+pub struct MicrosoftAzureBuilder {
+    /// Account name
+    account_name: Option<String>,
+    /// Access key
+    access_key: Option<String>,
+    /// Container name
+    container_name: Option<String>,
+    /// Bearer token
+    bearer_token: Option<String>,
+    /// Client id
+    client_id: Option<String>,
+    /// Client secret
+    client_secret: Option<String>,
+    /// Tenant id
+    tenant_id: Option<String>,
+    /// Query pairs for shared access signature authorization
+    sas_query_pairs: Option<Vec<(String, String)>>,
+    /// Shared access signature
+    sas_key: Option<String>,
+    /// Authority host
+    authority_host: Option<String>,
+    /// Url
+    url: Option<String>,
+    /// When set to true, azurite storage emulator has to be used
+    use_emulator: ConfigValue<bool>,
+    /// Storage endpoint
+    endpoint: Option<String>,
+    /// Msi endpoint for acquiring managed identity token
+    msi_endpoint: Option<String>,
+    /// Object id for use with managed identity authentication
+    object_id: Option<String>,
+    /// Msi resource id for use with managed identity authentication
+    msi_resource_id: Option<String>,
+    /// File containing token for Azure AD workload identity federation
+    federated_token_file: Option<String>,
+    /// When set to true, azure cli has to be used for acquiring access token
+    use_azure_cli: ConfigValue<bool>,
+    /// Retry config
+    retry_config: RetryConfig,
+    /// Client options
+    client_options: ClientOptions,
+    /// Credentials
+    credentials: Option<AzureCredentialProvider>,
+    /// Skip signing requests
+    skip_signature: ConfigValue<bool>,
+    /// When set to true, fabric url scheme will be used
+    ///
+    /// i.e. https://{account_name}.dfs.fabric.microsoft.com
+    use_fabric_endpoint: ConfigValue<bool>,
+    /// When set to true, skips tagging objects
+    disable_tagging: ConfigValue<bool>,
+}
+
+/// Configuration keys for [`MicrosoftAzureBuilder`]
+///
+/// Configuration via keys can be done via [`MicrosoftAzureBuilder::with_config`]
+///
+/// # Example
+/// ```
+/// # use object_store::azure::{MicrosoftAzureBuilder, AzureConfigKey};
+/// let builder = MicrosoftAzureBuilder::new()
+///     .with_config("azure_client_id".parse().unwrap(), "my-client-id")
+///     .with_config(AzureConfigKey::AuthorityId, "my-tenant-id");
+/// ```
+#[derive(PartialEq, Eq, Hash, Clone, Debug, Copy, Deserialize, Serialize)]
+#[non_exhaustive]
+pub enum AzureConfigKey {
+    /// The name of the azure storage account
+    ///
+    /// Supported keys:
+    /// - `azure_storage_account_name`
+    /// - `account_name`
+    AccountName,
+
+    /// Master key for accessing storage account
+    ///
+    /// Supported keys:
+    /// - `azure_storage_account_key`
+    /// - `azure_storage_access_key`
+    /// - `azure_storage_master_key`
+    /// - `access_key`
+    /// - `account_key`
+    /// - `master_key`
+    AccessKey,
+
+    /// Service principal client id for authorizing requests
+    ///
+    /// Supported keys:
+    /// - `azure_storage_client_id`
+    /// - `azure_client_id`
+    /// - `client_id`
+    ClientId,
+
+    /// Service principal client secret for authorizing requests
+    ///
+    /// Supported keys:
+    /// - `azure_storage_client_secret`
+    /// - `azure_client_secret`
+    /// - `client_secret`
+    ClientSecret,
+
+    /// Tenant id used in oauth flows
+    ///
+    /// Supported keys:
+    /// - `azure_storage_tenant_id`
+    /// - `azure_storage_authority_id`
+    /// - `azure_tenant_id`
+    /// - `azure_authority_id`
+    /// - `tenant_id`
+    /// - `authority_id`
+    AuthorityId,
+
+    /// Shared access signature.
+    ///
+    /// The signature is expected to be percent-encoded, much like they are provided
+    /// in the azure storage explorer or azure portal.
+    ///
+    /// Supported keys:
+    /// - `azure_storage_sas_key`
+    /// - `azure_storage_sas_token`
+    /// - `sas_key`
+    /// - `sas_token`
+    SasKey,
+
+    /// Bearer token
+    ///
+    /// Supported keys:
+    /// - `azure_storage_token`
+    /// - `bearer_token`
+    /// - `token`
+    Token,
+
+    /// Use object store with azurite storage emulator
+    ///
+    /// Supported keys:
+    /// - `azure_storage_use_emulator`
+    /// - `object_store_use_emulator`
+    /// - `use_emulator`
+    UseEmulator,
+
+    /// Override the endpoint used to communicate with blob storage
+    ///
+    /// Supported keys:
+    /// - `azure_storage_endpoint`
+    /// - `azure_endpoint`
+    /// - `endpoint`
+    Endpoint,
+
+    /// Use object store with url scheme account.dfs.fabric.microsoft.com
+    ///
+    /// Supported keys:
+    /// - `azure_use_fabric_endpoint`
+    /// - `use_fabric_endpoint`
+    UseFabricEndpoint,
+
+    /// Endpoint to request a imds managed identity token
+    ///
+    /// Supported keys:
+    /// - `azure_msi_endpoint`
+    /// - `azure_identity_endpoint`
+    /// - `identity_endpoint`
+    /// - `msi_endpoint`
+    MsiEndpoint,
+
+    /// Object id for use with managed identity authentication
+    ///
+    /// Supported keys:
+    /// - `azure_object_id`
+    /// - `object_id`
+    ObjectId,
+
+    /// Msi resource id for use with managed identity authentication
+    ///
+    /// Supported keys:
+    /// - `azure_msi_resource_id`
+    /// - `msi_resource_id`
+    MsiResourceId,
+
+    /// File containing token for Azure AD workload identity federation
+    ///
+    /// Supported keys:
+    /// - `azure_federated_token_file`
+    /// - `federated_token_file`
+    FederatedTokenFile,
+
+    /// Use azure cli for acquiring access token
+    ///
+    /// Supported keys:
+    /// - `azure_use_azure_cli`
+    /// - `use_azure_cli`
+    UseAzureCli,
+
+    /// Skip signing requests
+    ///
+    /// Supported keys:
+    /// - `azure_skip_signature`
+    /// - `skip_signature`
+    SkipSignature,
+
+    /// Container name
+    ///
+    /// Supported keys:
+    /// - `azure_container_name`
+    /// - `container_name`
+    ContainerName,
+
+    /// Disables tagging objects
+    ///
+    /// This can be desirable if not supported by the backing store
+    ///
+    /// Supported keys:
+    /// - `azure_disable_tagging`
+    /// - `disable_tagging`
+    DisableTagging,
+
+    /// Client options
+    Client(ClientConfigKey),
+}
+
+impl AsRef<str> for AzureConfigKey {
+    fn as_ref(&self) -> &str {
+        match self {
+            Self::AccountName => "azure_storage_account_name",
+            Self::AccessKey => "azure_storage_account_key",
+            Self::ClientId => "azure_storage_client_id",
+            Self::ClientSecret => "azure_storage_client_secret",
+            Self::AuthorityId => "azure_storage_tenant_id",
+            Self::SasKey => "azure_storage_sas_key",
+            Self::Token => "azure_storage_token",
+            Self::UseEmulator => "azure_storage_use_emulator",
+            Self::UseFabricEndpoint => "azure_use_fabric_endpoint",
+            Self::Endpoint => "azure_storage_endpoint",
+            Self::MsiEndpoint => "azure_msi_endpoint",
+            Self::ObjectId => "azure_object_id",
+            Self::MsiResourceId => "azure_msi_resource_id",
+            Self::FederatedTokenFile => "azure_federated_token_file",
+            Self::UseAzureCli => "azure_use_azure_cli",
+            Self::SkipSignature => "azure_skip_signature",
+            Self::ContainerName => "azure_container_name",
+            Self::DisableTagging => "azure_disable_tagging",
+            Self::Client(key) => key.as_ref(),
+        }
+    }
+}
+
+impl FromStr for AzureConfigKey {
+    type Err = crate::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "azure_storage_account_key"
+            | "azure_storage_access_key"
+            | "azure_storage_master_key"
+            | "master_key"
+            | "account_key"
+            | "access_key" => Ok(Self::AccessKey),
+            "azure_storage_account_name" | "account_name" => Ok(Self::AccountName),
+            "azure_storage_client_id" | "azure_client_id" | "client_id" => Ok(Self::ClientId),
+            "azure_storage_client_secret" | "azure_client_secret" | "client_secret" => {
+                Ok(Self::ClientSecret)
+            }
+            "azure_storage_tenant_id"
+            | "azure_storage_authority_id"
+            | "azure_tenant_id"
+            | "azure_authority_id"
+            | "tenant_id"
+            | "authority_id" => Ok(Self::AuthorityId),
+            "azure_storage_sas_key" | "azure_storage_sas_token" | "sas_key" | "sas_token" => {
+                Ok(Self::SasKey)
+            }
+            "azure_storage_token" | "bearer_token" | "token" => Ok(Self::Token),
+            "azure_storage_use_emulator" | "use_emulator" => Ok(Self::UseEmulator),
+            "azure_storage_endpoint" | "azure_endpoint" | "endpoint" => Ok(Self::Endpoint),
+            "azure_msi_endpoint"
+            | "azure_identity_endpoint"
+            | "identity_endpoint"
+            | "msi_endpoint" => Ok(Self::MsiEndpoint),
+            "azure_object_id" | "object_id" => Ok(Self::ObjectId),
+            "azure_msi_resource_id" | "msi_resource_id" => Ok(Self::MsiResourceId),
+            "azure_federated_token_file" | "federated_token_file" => Ok(Self::FederatedTokenFile),
+            "azure_use_fabric_endpoint" | "use_fabric_endpoint" => Ok(Self::UseFabricEndpoint),
+            "azure_use_azure_cli" | "use_azure_cli" => Ok(Self::UseAzureCli),
+            "azure_skip_signature" | "skip_signature" => Ok(Self::SkipSignature),
+            "azure_container_name" | "container_name" => Ok(Self::ContainerName),
+            "azure_disable_tagging" | "disable_tagging" => Ok(Self::DisableTagging),
+            // Backwards compatibility
+            "azure_allow_http" => Ok(Self::Client(ClientConfigKey::AllowHttp)),
+            _ => match s.parse() {
+                Ok(key) => Ok(Self::Client(key)),
+                Err(_) => Err(Error::UnknownConfigurationKey { key: s.into() }.into()),
+            },
+        }
+    }
+}
+
+impl std::fmt::Debug for MicrosoftAzureBuilder {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "MicrosoftAzureBuilder {{ account: {:?}, container_name: {:?} }}",
+            self.account_name, self.container_name
+        )
+    }
+}
+
+impl MicrosoftAzureBuilder {
+    /// Create a new [`MicrosoftAzureBuilder`] with default values.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Create an instance of [`MicrosoftAzureBuilder`] with values pre-populated from environment variables.
+    ///
+    /// Variables extracted from environment:
+    /// * AZURE_STORAGE_ACCOUNT_NAME: storage account name
+    /// * AZURE_STORAGE_ACCOUNT_KEY: storage account master key
+    /// * AZURE_STORAGE_ACCESS_KEY: alias for AZURE_STORAGE_ACCOUNT_KEY
+    /// * AZURE_STORAGE_CLIENT_ID -> client id for service principal authorization
+    /// * AZURE_STORAGE_CLIENT_SECRET -> client secret for service principal authorization
+    /// * AZURE_STORAGE_TENANT_ID -> tenant id used in oauth flows
+    /// # Example
+    /// ```
+    /// use object_store::azure::MicrosoftAzureBuilder;
+    ///
+    /// let azure = MicrosoftAzureBuilder::from_env()
+    ///     .with_container_name("foo")
+    ///     .build();
+    /// ```
+    pub fn from_env() -> Self {
+        let mut builder = Self::default();
+        for (os_key, os_value) in std::env::vars_os() {
+            if let (Some(key), Some(value)) = (os_key.to_str(), os_value.to_str()) {
+                if key.starts_with("AZURE_") {
+                    if let Ok(config_key) = key.to_ascii_lowercase().parse() {
+                        builder = builder.with_config(config_key, value);
+                    }
+                }
+            }
+        }
+
+        if let Ok(text) = std::env::var(MSI_ENDPOINT_ENV_KEY) {
+            builder = builder.with_msi_endpoint(text);
+        }
+
+        builder
+    }
+
+    /// Parse available connection info form a well-known storage URL.
+    ///
+    /// The supported url schemes are:
+    ///
+    /// - `abfs[s]://<container>/<path>` (according to [fsspec](https://github.com/fsspec/adlfs))
+    /// - `abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path>`
+    /// - `abfs[s]://<file_system>@<account_name>.dfs.fabric.microsoft.com/<path>`
+    /// - `az://<container>/<path>` (according to [fsspec](https://github.com/fsspec/adlfs))
+    /// - `adl://<container>/<path>` (according to [fsspec](https://github.com/fsspec/adlfs))
+    /// - `azure://<container>/<path>` (custom)
+    /// - `https://<account>.dfs.core.windows.net`
+    /// - `https://<account>.blob.core.windows.net`
+    /// - `https://<account>.blob.core.windows.net/<container>`
+    /// - `https://<account>.dfs.fabric.microsoft.com`
+    /// - `https://<account>.dfs.fabric.microsoft.com/<container>`
+    /// - `https://<account>.blob.fabric.microsoft.com`
+    /// - `https://<account>.blob.fabric.microsoft.com/<container>`
+    ///
+    /// Note: Settings derived from the URL will override any others set on this builder
+    ///
+    /// # Example
+    /// ```
+    /// use object_store::azure::MicrosoftAzureBuilder;
+    ///
+    /// let azure = MicrosoftAzureBuilder::from_env()
+    ///     .with_url("abfss://file_system@account.dfs.core.windows.net/")
+    ///     .build();
+    /// ```
+    pub fn with_url(mut self, url: impl Into<String>) -> Self {
+        self.url = Some(url.into());
+        self
+    }
+
+    /// Set an option on the builder via a key - value pair.
+    pub fn with_config(mut self, key: AzureConfigKey, value: impl Into<String>) -> Self {
+        match key {
+            AzureConfigKey::AccessKey => self.access_key = Some(value.into()),
+            AzureConfigKey::AccountName => self.account_name = Some(value.into()),
+            AzureConfigKey::ClientId => self.client_id = Some(value.into()),
+            AzureConfigKey::ClientSecret => self.client_secret = Some(value.into()),
+            AzureConfigKey::AuthorityId => self.tenant_id = Some(value.into()),
+            AzureConfigKey::SasKey => self.sas_key = Some(value.into()),
+            AzureConfigKey::Token => self.bearer_token = Some(value.into()),
+            AzureConfigKey::MsiEndpoint => self.msi_endpoint = Some(value.into()),
+            AzureConfigKey::ObjectId => self.object_id = Some(value.into()),
+            AzureConfigKey::MsiResourceId => self.msi_resource_id = Some(value.into()),
+            AzureConfigKey::FederatedTokenFile => self.federated_token_file = Some(value.into()),
+            AzureConfigKey::UseAzureCli => self.use_azure_cli.parse(value),
+            AzureConfigKey::SkipSignature => self.skip_signature.parse(value),
+            AzureConfigKey::UseEmulator => self.use_emulator.parse(value),
+            AzureConfigKey::Endpoint => self.endpoint = Some(value.into()),
+            AzureConfigKey::UseFabricEndpoint => self.use_fabric_endpoint.parse(value),
+            AzureConfigKey::Client(key) => {
+                self.client_options = self.client_options.with_config(key, value)
+            }
+            AzureConfigKey::ContainerName => self.container_name = Some(value.into()),
+            AzureConfigKey::DisableTagging => self.disable_tagging.parse(value),
+        };
+        self
+    }
+
+    /// Get config value via a [`AzureConfigKey`].
+    ///
+    /// # Example
+    /// ```
+    /// use object_store::azure::{MicrosoftAzureBuilder, AzureConfigKey};
+    ///
+    /// let builder = MicrosoftAzureBuilder::from_env()
+    ///     .with_account("foo");
+    /// let account_name = builder.get_config_value(&AzureConfigKey::AccountName).unwrap_or_default();
+    /// assert_eq!("foo", &account_name);
+    /// ```
+    pub fn get_config_value(&self, key: &AzureConfigKey) -> Option<String> {
+        match key {
+            AzureConfigKey::AccountName => self.account_name.clone(),
+            AzureConfigKey::AccessKey => self.access_key.clone(),
+            AzureConfigKey::ClientId => self.client_id.clone(),
+            AzureConfigKey::ClientSecret => self.client_secret.clone(),
+            AzureConfigKey::AuthorityId => self.tenant_id.clone(),
+            AzureConfigKey::SasKey => self.sas_key.clone(),
+            AzureConfigKey::Token => self.bearer_token.clone(),
+            AzureConfigKey::UseEmulator => Some(self.use_emulator.to_string()),
+            AzureConfigKey::UseFabricEndpoint => Some(self.use_fabric_endpoint.to_string()),
+            AzureConfigKey::Endpoint => self.endpoint.clone(),
+            AzureConfigKey::MsiEndpoint => self.msi_endpoint.clone(),
+            AzureConfigKey::ObjectId => self.object_id.clone(),
+            AzureConfigKey::MsiResourceId => self.msi_resource_id.clone(),
+            AzureConfigKey::FederatedTokenFile => self.federated_token_file.clone(),
+            AzureConfigKey::UseAzureCli => Some(self.use_azure_cli.to_string()),
+            AzureConfigKey::SkipSignature => Some(self.skip_signature.to_string()),
+            AzureConfigKey::Client(key) => self.client_options.get_config_value(key),
+            AzureConfigKey::ContainerName => self.container_name.clone(),
+            AzureConfigKey::DisableTagging => Some(self.disable_tagging.to_string()),
+        }
+    }
+
+    /// Sets properties on this builder based on a URL
+    ///
+    /// This is a separate member function to allow fallible computation to
+    /// be deferred until [`Self::build`] which in turn allows deriving [`Clone`]
+    fn parse_url(&mut self, url: &str) -> Result<()> {
+        let parsed = Url::parse(url).context(UnableToParseUrlSnafu { url })?;
+        let host = parsed.host_str().context(UrlNotRecognisedSnafu { url })?;
+
+        let validate = |s: &str| match s.contains('.') {
+            true => Err(UrlNotRecognisedSnafu { url }.build()),
+            false => Ok(s.to_string()),
+        };
+
+        match parsed.scheme() {
+            "az" | "adl" | "azure" => self.container_name = Some(validate(host)?),
+            "abfs" | "abfss" => {
+                // abfs(s) might refer to the fsspec convention abfs://<container>/<path>
+                // or the convention for the hadoop driver abfs[s]://<file_system>@<account_name>.dfs.core.windows.net/<path>
+                if parsed.username().is_empty() {
+                    self.container_name = Some(validate(host)?);
+                } else if let Some(a) = host.strip_suffix(".dfs.core.windows.net") {
+                    self.container_name = Some(validate(parsed.username())?);
+                    self.account_name = Some(validate(a)?);
+                } else if let Some(a) = host.strip_suffix(".dfs.fabric.microsoft.com") {
+                    self.container_name = Some(validate(parsed.username())?);
+                    self.account_name = Some(validate(a)?);
+                    self.use_fabric_endpoint = true.into();
+                } else {
+                    return Err(UrlNotRecognisedSnafu { url }.build().into());
+                }
+            }
+            "https" => match host.split_once('.') {
+                Some((a, "dfs.core.windows.net")) | Some((a, "blob.core.windows.net")) => {
+                    self.account_name = Some(validate(a)?);
+                    if let Some(container) = parsed.path_segments().unwrap().next() {
+                        self.container_name = Some(validate(container)?);
+                    }
+                }
+                Some((a, "dfs.fabric.microsoft.com")) | Some((a, "blob.fabric.microsoft.com")) => {
+                    self.account_name = Some(validate(a)?);
+                    // Attempt to infer the container name from the URL
+                    // - https://onelake.dfs.fabric.microsoft.com/<workspaceGUID>/<itemGUID>/Files/test.csv
+                    // - https://onelake.dfs.fabric.microsoft.com/<workspace>/<item>.<itemtype>/<path>/<fileName>
+                    //
+                    // See <https://learn.microsoft.com/en-us/fabric/onelake/onelake-access-api>
+                    if let Some(workspace) = parsed.path_segments().unwrap().next() {
+                        if !workspace.is_empty() {
+                            self.container_name = Some(workspace.to_string())
+                        }
+                    }
+                    self.use_fabric_endpoint = true.into();
+                }
+                _ => return Err(UrlNotRecognisedSnafu { url }.build().into()),
+            },
+            scheme => return Err(UnknownUrlSchemeSnafu { scheme }.build().into()),
+        }
+        Ok(())
+    }
+
+    /// Set the Azure Account (required)
+    pub fn with_account(mut self, account: impl Into<String>) -> Self {
+        self.account_name = Some(account.into());
+        self
+    }
+
+    /// Set the Azure Container Name (required)
+    pub fn with_container_name(mut self, container_name: impl Into<String>) -> Self {
+        self.container_name = Some(container_name.into());
+        self
+    }
+
+    /// Set the Azure Access Key (required - one of access key, bearer token, or client credentials)
+    pub fn with_access_key(mut self, access_key: impl Into<String>) -> Self {
+        self.access_key = Some(access_key.into());
+        self
+    }
+
+    /// Set a static bearer token to be used for authorizing requests
+    pub fn with_bearer_token_authorization(mut self, bearer_token: impl Into<String>) -> Self {
+        self.bearer_token = Some(bearer_token.into());
+        self
+    }
+
+    /// Set a client secret used for client secret authorization
+    pub fn with_client_secret_authorization(
+        mut self,
+        client_id: impl Into<String>,
+        client_secret: impl Into<String>,
+        tenant_id: impl Into<String>,
+    ) -> Self {
+        self.client_id = Some(client_id.into());
+        self.client_secret = Some(client_secret.into());
+        self.tenant_id = Some(tenant_id.into());
+        self
+    }
+
+    /// Sets the client id for use in client secret or k8s federated credential flow
+    pub fn with_client_id(mut self, client_id: impl Into<String>) -> Self {
+        self.client_id = Some(client_id.into());
+        self
+    }
+
+    /// Sets the client secret for use in client secret flow
+    pub fn with_client_secret(mut self, client_secret: impl Into<String>) -> Self {
+        self.client_secret = Some(client_secret.into());
+        self
+    }
+
+    /// Sets the tenant id for use in client secret or k8s federated credential flow
+    pub fn with_tenant_id(mut self, tenant_id: impl Into<String>) -> Self {
+        self.tenant_id = Some(tenant_id.into());
+        self
+    }
+
+    /// Set query pairs appended to the url for shared access signature authorization
+    pub fn with_sas_authorization(mut self, query_pairs: impl Into<Vec<(String, String)>>) -> Self {
+        self.sas_query_pairs = Some(query_pairs.into());
+        self
+    }
+
+    /// Set the credential provider overriding any other options
+    pub fn with_credentials(mut self, credentials: AzureCredentialProvider) -> Self {
+        self.credentials = Some(credentials);
+        self
+    }
+
+    /// Set if the Azure emulator should be used (defaults to false)
+    pub fn with_use_emulator(mut self, use_emulator: bool) -> Self {
+        self.use_emulator = use_emulator.into();
+        self
+    }
+
+    /// Override the endpoint used to communicate with blob storage
+    ///
+    /// Defaults to `https://{account}.blob.core.windows.net`
+    ///
+    /// By default, only HTTPS schemes are enabled. To connect to an HTTP endpoint, enable
+    /// [`Self::with_allow_http`].
+    pub fn with_endpoint(mut self, endpoint: String) -> Self {
+        self.endpoint = Some(endpoint);
+        self
+    }
+
+    /// Set if Microsoft Fabric url scheme should be used (defaults to false)
+    ///
+    /// When disabled the url scheme used is `https://{account}.blob.core.windows.net`
+    /// When enabled the url scheme used is `https://{account}.dfs.fabric.microsoft.com`
+    ///
+    /// Note: [`Self::with_endpoint`] will take precedence over this option
+    pub fn with_use_fabric_endpoint(mut self, use_fabric_endpoint: bool) -> Self {
+        self.use_fabric_endpoint = use_fabric_endpoint.into();
+        self
+    }
+
+    /// Sets what protocol is allowed
+    ///
+    /// If `allow_http` is :
+    /// * false (default):  Only HTTPS are allowed
+    /// * true:  HTTP and HTTPS are allowed
+    pub fn with_allow_http(mut self, allow_http: bool) -> Self {
+        self.client_options = self.client_options.with_allow_http(allow_http);
+        self
+    }
+
+    /// Sets an alternative authority host for OAuth based authorization
+    ///
+    /// Common hosts for azure clouds are defined in [authority_hosts](crate::azure::authority_hosts).
+    ///
+    /// Defaults to <https://login.microsoftonline.com>
+    pub fn with_authority_host(mut self, authority_host: impl Into<String>) -> Self {
+        self.authority_host = Some(authority_host.into());
+        self
+    }
+
+    /// Set the retry configuration
+    pub fn with_retry(mut self, retry_config: RetryConfig) -> Self {
+        self.retry_config = retry_config;
+        self
+    }
+
+    /// Set the proxy_url to be used by the underlying client
+    pub fn with_proxy_url(mut self, proxy_url: impl Into<String>) -> Self {
+        self.client_options = self.client_options.with_proxy_url(proxy_url);
+        self
+    }
+
+    /// Set a trusted proxy CA certificate
+    pub fn with_proxy_ca_certificate(mut self, proxy_ca_certificate: impl Into<String>) -> Self {
+        self.client_options = self
+            .client_options
+            .with_proxy_ca_certificate(proxy_ca_certificate);
+        self
+    }
+
+    /// Set a list of hosts to exclude from proxy connections
+    pub fn with_proxy_excludes(mut self, proxy_excludes: impl Into<String>) -> Self {
+        self.client_options = self.client_options.with_proxy_excludes(proxy_excludes);
+        self
+    }
+
+    /// Sets the client options, overriding any already set
+    pub fn with_client_options(mut self, options: ClientOptions) -> Self {
+        self.client_options = options;
+        self
+    }
+
+    /// Sets the endpoint for acquiring managed identity token
+    pub fn with_msi_endpoint(mut self, msi_endpoint: impl Into<String>) -> Self {
+        self.msi_endpoint = Some(msi_endpoint.into());
+        self
+    }
+
+    /// Sets a file path for acquiring azure federated identity token in k8s
+    ///
+    /// requires `client_id` and `tenant_id` to be set
+    pub fn with_federated_token_file(mut self, federated_token_file: impl Into<String>) -> Self {
+        self.federated_token_file = Some(federated_token_file.into());
+        self
+    }
+
+    /// Set if the Azure Cli should be used for acquiring access token
+    ///
+    /// <https://learn.microsoft.com/en-us/cli/azure/account?view=azure-cli-latest#az-account-get-access-token>
+    pub fn with_use_azure_cli(mut self, use_azure_cli: bool) -> Self {
+        self.use_azure_cli = use_azure_cli.into();
+        self
+    }
+
+    /// If enabled, [`MicrosoftAzure`] will not fetch credentials and will not sign requests
+    ///
+    /// This can be useful when interacting with public containers
+    pub fn with_skip_signature(mut self, skip_signature: bool) -> Self {
+        self.skip_signature = skip_signature.into();
+        self
+    }
+
+    /// If set to `true` will ignore any tags provided to put_opts
+    pub fn with_disable_tagging(mut self, ignore: bool) -> Self {
+        self.disable_tagging = ignore.into();
+        self
+    }
+
+    /// Configure a connection to container with given name on Microsoft Azure Blob store.
+    pub fn build(mut self) -> Result<MicrosoftAzure> {
+        if let Some(url) = self.url.take() {
+            self.parse_url(&url)?;
+        }
+
+        let container = self.container_name.ok_or(Error::MissingContainerName {})?;
+
+        let static_creds = |credential: AzureCredential| -> AzureCredentialProvider {
+            Arc::new(StaticCredentialProvider::new(credential))
+        };
+
+        let (is_emulator, storage_url, auth, account) = if self.use_emulator.get()? {
+            let account_name = self
+                .account_name
+                .unwrap_or_else(|| EMULATOR_ACCOUNT.to_string());
+            // Allow overriding defaults. Values taken from
+            // from https://docs.rs/azure_storage/0.2.0/src/azure_storage/core/clients/storage_account_client.rs.html#129-141
+            let url = url_from_env("AZURITE_BLOB_STORAGE_URL", "http://127.0.0.1:10000")?;
+            let credential = if let Some(k) = self.access_key {
+                AzureCredential::AccessKey(AzureAccessKey::try_new(&k)?)
+            } else if let Some(bearer_token) = self.bearer_token {
+                AzureCredential::BearerToken(bearer_token)
+            } else if let Some(query_pairs) = self.sas_query_pairs {
+                AzureCredential::SASToken(query_pairs)
+            } else if let Some(sas) = self.sas_key {
+                AzureCredential::SASToken(split_sas(&sas)?)
+            } else {
+                AzureCredential::AccessKey(AzureAccessKey::try_new(EMULATOR_ACCOUNT_KEY)?)
+            };
+
+            self.client_options = self.client_options.with_allow_http(true);
+            (true, url, static_creds(credential), account_name)
+        } else {
+            let account_name = self.account_name.ok_or(Error::MissingAccount {})?;
+            let account_url = match self.endpoint {
+                Some(account_url) => account_url,
+                None => match self.use_fabric_endpoint.get()? {
+                    true => {
+                        format!("https://{}.blob.fabric.microsoft.com", &account_name)
+                    }
+                    false => format!("https://{}.blob.core.windows.net", &account_name),
+                },
+            };
+
+            let url =
+                Url::parse(&account_url).context(UnableToParseUrlSnafu { url: account_url })?;
+
+            let credential = if let Some(credential) = self.credentials {
+                credential
+            } else if let Some(bearer_token) = self.bearer_token {
+                static_creds(AzureCredential::BearerToken(bearer_token))
+            } else if let Some(access_key) = self.access_key {
+                let key = AzureAccessKey::try_new(&access_key)?;
+                static_creds(AzureCredential::AccessKey(key))
+            } else if let (Some(client_id), Some(tenant_id), Some(federated_token_file)) =
+                (&self.client_id, &self.tenant_id, self.federated_token_file)
+            {
+                let client_credential = WorkloadIdentityOAuthProvider::new(
+                    client_id,
+                    federated_token_file,
+                    tenant_id,
+                    self.authority_host,
+                );
+                Arc::new(TokenCredentialProvider::new(
+                    client_credential,
+                    self.client_options.client()?,
+                    self.retry_config.clone(),
+                )) as _
+            } else if let (Some(client_id), Some(client_secret), Some(tenant_id)) =
+                (&self.client_id, self.client_secret, &self.tenant_id)
+            {
+                let client_credential = ClientSecretOAuthProvider::new(
+                    client_id.clone(),
+                    client_secret,
+                    tenant_id,
+                    self.authority_host,
+                );
+                Arc::new(TokenCredentialProvider::new(
+                    client_credential,
+                    self.client_options.client()?,
+                    self.retry_config.clone(),
+                )) as _
+            } else if let Some(query_pairs) = self.sas_query_pairs {
+                static_creds(AzureCredential::SASToken(query_pairs))
+            } else if let Some(sas) = self.sas_key {
+                static_creds(AzureCredential::SASToken(split_sas(&sas)?))
+            } else if self.use_azure_cli.get()? {
+                Arc::new(AzureCliCredential::new()) as _
+            } else {
+                let msi_credential = ImdsManagedIdentityProvider::new(
+                    self.client_id,
+                    self.object_id,
+                    self.msi_resource_id,
+                    self.msi_endpoint,
+                );
+                Arc::new(TokenCredentialProvider::new(
+                    msi_credential,
+                    self.client_options.metadata_client()?,
+                    self.retry_config.clone(),
+                )) as _
+            };
+            (false, url, credential, account_name)
+        };
+
+        let config = AzureConfig {
+            account,
+            is_emulator,
+            skip_signature: self.skip_signature.get()?,
+            container,
+            disable_tagging: self.disable_tagging.get()?,
+            retry_config: self.retry_config,
+            client_options: self.client_options,
+            service: storage_url,
+            credentials: auth,
+        };
+
+        let client = Arc::new(AzureClient::new(config)?);
+
+        Ok(MicrosoftAzure { client })
+    }
+}
+
+/// Parses the contents of the environment variable `env_name` as a URL
+/// if present, otherwise falls back to default_url
+fn url_from_env(env_name: &str, default_url: &str) -> Result<Url> {
+    let url = match std::env::var(env_name) {
+        Ok(env_value) => Url::parse(&env_value).context(UnableToParseEmulatorUrlSnafu {
+            env_name,
+            env_value,
+        })?,
+        Err(_) => Url::parse(default_url).expect("Failed to parse default URL"),
+    };
+    Ok(url)
+}
+
+fn split_sas(sas: &str) -> Result<Vec<(String, String)>, Error> {
+    let sas = percent_decode_str(sas)
+        .decode_utf8()
+        .context(DecodeSasKeySnafu {})?;
+    let kv_str_pairs = sas
+        .trim_start_matches('?')
+        .split('&')
+        .filter(|s| !s.chars().all(char::is_whitespace));
+    let mut pairs = Vec::new();
+    for kv_pair_str in kv_str_pairs {
+        let (k, v) = kv_pair_str
+            .trim()
+            .split_once('=')
+            .ok_or(Error::MissingSasComponent {})?;
+        pairs.push((k.into(), v.into()))
+    }
+    Ok(pairs)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    #[test]
+    fn azure_blob_test_urls() {
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder
+            .parse_url("abfss://file_system@account.dfs.core.windows.net/")
+            .unwrap();
+        assert_eq!(builder.account_name, Some("account".to_string()));
+        assert_eq!(builder.container_name, Some("file_system".to_string()));
+        assert!(!builder.use_fabric_endpoint.get().unwrap());
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder
+            .parse_url("abfss://file_system@account.dfs.fabric.microsoft.com/")
+            .unwrap();
+        assert_eq!(builder.account_name, Some("account".to_string()));
+        assert_eq!(builder.container_name, Some("file_system".to_string()));
+        assert!(builder.use_fabric_endpoint.get().unwrap());
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder.parse_url("abfs://container/path").unwrap();
+        assert_eq!(builder.container_name, Some("container".to_string()));
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder.parse_url("az://container").unwrap();
+        assert_eq!(builder.container_name, Some("container".to_string()));
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder.parse_url("az://container/path").unwrap();
+        assert_eq!(builder.container_name, Some("container".to_string()));
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder
+            .parse_url("https://account.dfs.core.windows.net/")
+            .unwrap();
+        assert_eq!(builder.account_name, Some("account".to_string()));
+        assert!(!builder.use_fabric_endpoint.get().unwrap());
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder
+            .parse_url("https://account.blob.core.windows.net/")
+            .unwrap();
+        assert_eq!(builder.account_name, Some("account".to_string()));
+        assert!(!builder.use_fabric_endpoint.get().unwrap());
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder
+            .parse_url("https://account.blob.core.windows.net/container")
+            .unwrap();
+        assert_eq!(builder.account_name, Some("account".to_string()));
+        assert_eq!(builder.container_name, Some("container".to_string()));
+        assert!(!builder.use_fabric_endpoint.get().unwrap());
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder
+            .parse_url("https://account.dfs.fabric.microsoft.com/")
+            .unwrap();
+        assert_eq!(builder.account_name, Some("account".to_string()));
+        assert_eq!(builder.container_name, None);
+        assert!(builder.use_fabric_endpoint.get().unwrap());
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder
+            .parse_url("https://account.dfs.fabric.microsoft.com/container")
+            .unwrap();
+        assert_eq!(builder.account_name, Some("account".to_string()));
+        assert_eq!(builder.container_name.as_deref(), Some("container"));
+        assert!(builder.use_fabric_endpoint.get().unwrap());
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder
+            .parse_url("https://account.blob.fabric.microsoft.com/")
+            .unwrap();
+        assert_eq!(builder.account_name, Some("account".to_string()));
+        assert_eq!(builder.container_name, None);
+        assert!(builder.use_fabric_endpoint.get().unwrap());
+
+        let mut builder = MicrosoftAzureBuilder::new();
+        builder
+            .parse_url("https://account.blob.fabric.microsoft.com/container")
+            .unwrap();
+        assert_eq!(builder.account_name, Some("account".to_string()));
+        assert_eq!(builder.container_name.as_deref(), Some("container"));
+        assert!(builder.use_fabric_endpoint.get().unwrap());
+
+        let err_cases = [
+            "mailto://account.blob.core.windows.net/",
+            "az://blob.mydomain/",
+            "abfs://container.foo/path",
+            "abfss://file_system@account.foo.dfs.core.windows.net/",
+            "abfss://file_system.bar@account.dfs.core.windows.net/",
+            "https://blob.mydomain/",
+            "https://blob.foo.dfs.core.windows.net/",
+        ];
+        let mut builder = MicrosoftAzureBuilder::new();
+        for case in err_cases {
+            builder.parse_url(case).unwrap_err();
+        }
+    }
+
+    #[test]
+    fn azure_test_config_from_map() {
+        let azure_client_id = "object_store:fake_access_key_id";
+        let azure_storage_account_name = "object_store:fake_secret_key";
+        let azure_storage_token = "object_store:fake_default_region";
+        let options = HashMap::from([
+            ("azure_client_id", azure_client_id),
+            ("azure_storage_account_name", azure_storage_account_name),
+            ("azure_storage_token", azure_storage_token),
+        ]);
+
+        let builder = options
+            .into_iter()
+            .fold(MicrosoftAzureBuilder::new(), |builder, (key, value)| {
+                builder.with_config(key.parse().unwrap(), value)
+            });
+        assert_eq!(builder.client_id.unwrap(), azure_client_id);
+        assert_eq!(builder.account_name.unwrap(), azure_storage_account_name);
+        assert_eq!(builder.bearer_token.unwrap(), azure_storage_token);
+    }
+
+    #[test]
+    fn azure_test_split_sas() {
+        let raw_sas = "?sv=2021-10-04&st=2023-01-04T17%3A48%3A57Z&se=2023-01-04T18%3A15%3A00Z&sr=c&sp=rcwl&sig=C7%2BZeEOWbrxPA3R0Cw%2Fw1EZz0%2B4KBvQexeKZKe%2BB6h0%3D";
+        let expected = vec![
+            ("sv".to_string(), "2021-10-04".to_string()),
+            ("st".to_string(), "2023-01-04T17:48:57Z".to_string()),
+            ("se".to_string(), "2023-01-04T18:15:00Z".to_string()),
+            ("sr".to_string(), "c".to_string()),
+            ("sp".to_string(), "rcwl".to_string()),
+            (
+                "sig".to_string(),
+                "C7+ZeEOWbrxPA3R0Cw/w1EZz0+4KBvQexeKZKe+B6h0=".to_string(),
+            ),
+        ];
+        let pairs = split_sas(raw_sas).unwrap();
+        assert_eq!(expected, pairs);
+    }
+}
diff --git a/object_store/src/azure/client.rs b/object_store/src/azure/client.rs
new file mode 100644
index 000000000000..feea2f247878
--- /dev/null
+++ b/object_store/src/azure/client.rs
@@ -0,0 +1,914 @@
+// 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.
+
+use super::credential::AzureCredential;
+use crate::azure::credential::*;
+use crate::azure::{AzureCredentialProvider, STORE};
+use crate::client::get::GetClient;
+use crate::client::header::{get_put_result, HeaderConfig};
+use crate::client::list::ListClient;
+use crate::client::retry::RetryExt;
+use crate::client::GetOptionsExt;
+use crate::multipart::PartId;
+use crate::path::DELIMITER;
+use crate::util::{deserialize_rfc1123, GetRange};
+use crate::{
+    ClientOptions, GetOptions, ListResult, ObjectMeta, Path, PutMode, PutOptions, PutResult,
+    Result, RetryConfig,
+};
+use async_trait::async_trait;
+use base64::prelude::BASE64_STANDARD;
+use base64::Engine;
+use bytes::{Buf, Bytes};
+use chrono::{DateTime, Utc};
+use hyper::http::HeaderName;
+use itertools::Itertools;
+use reqwest::header::CONTENT_TYPE;
+use reqwest::{
+    header::{HeaderValue, CONTENT_LENGTH, IF_MATCH, IF_NONE_MATCH},
+    Client as ReqwestClient, Method, RequestBuilder, Response,
+};
+use serde::{Deserialize, Serialize};
+use snafu::{OptionExt, ResultExt, Snafu};
+use std::collections::HashMap;
+use std::sync::Arc;
+use std::time::Duration;
+use url::Url;
+
+const VERSION_HEADER: &str = "x-ms-version-id";
+
+static TAGS_HEADER: HeaderName = HeaderName::from_static("x-ms-tags");
+
+/// A specialized `Error` for object store-related errors
+#[derive(Debug, Snafu)]
+#[allow(missing_docs)]
+pub(crate) enum Error {
+    #[snafu(display("Error performing get request {}: {}", path, source))]
+    GetRequest {
+        source: crate::client::retry::Error,
+        path: String,
+    },
+
+    #[snafu(display("Error getting get response body {}: {}", path, source))]
+    GetResponseBody {
+        source: reqwest::Error,
+        path: String,
+    },
+
+    #[snafu(display("Error performing put request {}: {}", path, source))]
+    PutRequest {
+        source: crate::client::retry::Error,
+        path: String,
+    },
+
+    #[snafu(display("Error performing delete request {}: {}", path, source))]
+    DeleteRequest {
+        source: crate::client::retry::Error,
+        path: String,
+    },
+
+    #[snafu(display("Error performing list request: {}", source))]
+    ListRequest { source: crate::client::retry::Error },
+
+    #[snafu(display("Error getting list response body: {}", source))]
+    ListResponseBody { source: reqwest::Error },
+
+    #[snafu(display("Got invalid list response: {}", source))]
+    InvalidListResponse { source: quick_xml::de::DeError },
+
+    #[snafu(display("Error authorizing request: {}", source))]
+    Authorization {
+        source: crate::azure::credential::Error,
+    },
+
+    #[snafu(display("Unable to extract metadata from headers: {}", source))]
+    Metadata {
+        source: crate::client::header::Error,
+    },
+
+    #[snafu(display("ETag required for conditional update"))]
+    MissingETag,
+
+    #[snafu(display("Error requesting user delegation key: {}", source))]
+    DelegationKeyRequest { source: crate::client::retry::Error },
+
+    #[snafu(display("Error getting user delegation key response body: {}", source))]
+    DelegationKeyResponseBody { source: reqwest::Error },
+
+    #[snafu(display("Got invalid user delegation key response: {}", source))]
+    DelegationKeyResponse { source: quick_xml::de::DeError },
+
+    #[snafu(display("Generating SAS keys with SAS tokens auth is not supported"))]
+    SASforSASNotSupported,
+
+    #[snafu(display("Generating SAS keys while skipping signatures is not supported"))]
+    SASwithSkipSignature,
+}
+
+impl From<Error> for crate::Error {
+    fn from(err: Error) -> Self {
+        match err {
+            Error::GetRequest { source, path }
+            | Error::DeleteRequest { source, path }
+            | Error::PutRequest { source, path } => source.error(STORE, path),
+            _ => Self::Generic {
+                store: STORE,
+                source: Box::new(err),
+            },
+        }
+    }
+}
+
+/// Configuration for [AzureClient]
+#[derive(Debug)]
+pub(crate) struct AzureConfig {
+    pub account: String,
+    pub container: String,
+    pub credentials: AzureCredentialProvider,
+    pub retry_config: RetryConfig,
+    pub service: Url,
+    pub is_emulator: bool,
+    pub skip_signature: bool,
+    pub disable_tagging: bool,
+    pub client_options: ClientOptions,
+}
+
+impl AzureConfig {
+    pub(crate) fn path_url(&self, path: &Path) -> Url {
+        let mut url = self.service.clone();
+        {
+            let mut path_mut = url.path_segments_mut().unwrap();
+            if self.is_emulator {
+                path_mut.push(&self.account);
+            }
+            path_mut.push(&self.container).extend(path.parts());
+        }
+        url
+    }
+    async fn get_credential(&self) -> Result<Option<Arc<AzureCredential>>> {
+        if self.skip_signature {
+            Ok(None)
+        } else {
+            Some(self.credentials.get_credential().await).transpose()
+        }
+    }
+}
+
+/// A builder for a put request allowing customisation of the headers and query string
+struct PutRequest<'a> {
+    path: &'a Path,
+    config: &'a AzureConfig,
+    builder: RequestBuilder,
+}
+
+impl<'a> PutRequest<'a> {
+    fn header(self, k: &HeaderName, v: &str) -> Self {
+        let builder = self.builder.header(k, v);
+        Self { builder, ..self }
+    }
+
+    fn query<T: Serialize + ?Sized + Sync>(self, query: &T) -> Self {
+        let builder = self.builder.query(query);
+        Self { builder, ..self }
+    }
+
+    async fn send(self) -> Result<Response> {
+        let credential = self.config.get_credential().await?;
+        let response = self
+            .builder
+            .with_azure_authorization(&credential, &self.config.account)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(PutRequestSnafu {
+                path: self.path.as_ref(),
+            })?;
+
+        Ok(response)
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct AzureClient {
+    config: AzureConfig,
+    client: ReqwestClient,
+}
+
+impl AzureClient {
+    /// create a new instance of [AzureClient]
+    pub fn new(config: AzureConfig) -> Result<Self> {
+        let client = config.client_options.client()?;
+        Ok(Self { config, client })
+    }
+
+    /// Returns the config
+    pub fn config(&self) -> &AzureConfig {
+        &self.config
+    }
+
+    async fn get_credential(&self) -> Result<Option<Arc<AzureCredential>>> {
+        self.config.get_credential().await
+    }
+
+    fn put_request<'a>(&'a self, path: &'a Path, bytes: Bytes) -> PutRequest<'a> {
+        let url = self.config.path_url(path);
+
+        let mut builder = self.client.request(Method::PUT, url);
+
+        if let Some(value) = self.config().client_options.get_content_type(path) {
+            builder = builder.header(CONTENT_TYPE, value);
+        }
+
+        builder = builder
+            .header(CONTENT_LENGTH, HeaderValue::from(bytes.len()))
+            .body(bytes);
+
+        PutRequest {
+            path,
+            builder,
+            config: &self.config,
+        }
+    }
+
+    /// Make an Azure PUT request <https://docs.microsoft.com/en-us/rest/api/storageservices/put-blob>
+    pub async fn put_blob(&self, path: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        let builder = self.put_request(path, bytes);
+
+        let builder = match &opts.mode {
+            PutMode::Overwrite => builder,
+            PutMode::Create => builder.header(&IF_NONE_MATCH, "*"),
+            PutMode::Update(v) => {
+                let etag = v.e_tag.as_ref().context(MissingETagSnafu)?;
+                builder.header(&IF_MATCH, etag)
+            }
+        };
+
+        let builder = match (opts.tags.encoded(), self.config.disable_tagging) {
+            ("", _) | (_, true) => builder,
+            (tags, false) => builder.header(&TAGS_HEADER, tags),
+        };
+
+        let response = builder.header(&BLOB_TYPE, "BlockBlob").send().await?;
+        Ok(get_put_result(response.headers(), VERSION_HEADER).context(MetadataSnafu)?)
+    }
+
+    /// PUT a block <https://learn.microsoft.com/en-us/rest/api/storageservices/put-block>
+    pub async fn put_block(&self, path: &Path, part_idx: usize, data: Bytes) -> Result<PartId> {
+        let content_id = format!("{part_idx:20}");
+        let block_id = BASE64_STANDARD.encode(&content_id);
+
+        self.put_request(path, data)
+            .query(&[("comp", "block"), ("blockid", &block_id)])
+            .send()
+            .await?;
+
+        Ok(PartId { content_id })
+    }
+
+    /// PUT a block list <https://learn.microsoft.com/en-us/rest/api/storageservices/put-block-list>
+    pub async fn put_block_list(&self, path: &Path, parts: Vec<PartId>) -> Result<PutResult> {
+        let blocks = parts
+            .into_iter()
+            .map(|part| BlockId::from(part.content_id))
+            .collect();
+
+        let response = self
+            .put_request(path, BlockList { blocks }.to_xml().into())
+            .query(&[("comp", "blocklist")])
+            .send()
+            .await?;
+
+        Ok(get_put_result(response.headers(), VERSION_HEADER).context(MetadataSnafu)?)
+    }
+
+    /// Make an Azure Delete request <https://docs.microsoft.com/en-us/rest/api/storageservices/delete-blob>
+    pub async fn delete_request<T: Serialize + ?Sized + Sync>(
+        &self,
+        path: &Path,
+        query: &T,
+    ) -> Result<()> {
+        let credential = self.get_credential().await?;
+        let url = self.config.path_url(path);
+
+        self.client
+            .request(Method::DELETE, url)
+            .query(query)
+            .header(&DELETE_SNAPSHOTS, "include")
+            .with_azure_authorization(&credential, &self.config.account)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(DeleteRequestSnafu {
+                path: path.as_ref(),
+            })?;
+
+        Ok(())
+    }
+
+    /// Make an Azure Copy request <https://docs.microsoft.com/en-us/rest/api/storageservices/copy-blob>
+    pub async fn copy_request(&self, from: &Path, to: &Path, overwrite: bool) -> Result<()> {
+        let credential = self.get_credential().await?;
+        let url = self.config.path_url(to);
+        let mut source = self.config.path_url(from);
+
+        // If using SAS authorization must include the headers in the URL
+        // <https://docs.microsoft.com/en-us/rest/api/storageservices/copy-blob#request-headers>
+        if let Some(AzureCredential::SASToken(pairs)) = credential.as_deref() {
+            source.query_pairs_mut().extend_pairs(pairs);
+        }
+
+        let mut builder = self
+            .client
+            .request(Method::PUT, url)
+            .header(&COPY_SOURCE, source.to_string())
+            .header(CONTENT_LENGTH, HeaderValue::from_static("0"));
+
+        if !overwrite {
+            builder = builder.header(IF_NONE_MATCH, "*");
+        }
+
+        builder
+            .with_azure_authorization(&credential, &self.config.account)
+            .send_retry(&self.config.retry_config)
+            .await
+            .map_err(|err| err.error(STORE, from.to_string()))?;
+
+        Ok(())
+    }
+
+    /// Make a Get User Delegation Key request
+    /// <https://docs.microsoft.com/en-us/rest/api/storageservices/get-user-delegation-key>
+    async fn get_user_delegation_key(
+        &self,
+        start: &DateTime<Utc>,
+        end: &DateTime<Utc>,
+    ) -> Result<UserDelegationKey> {
+        let credential = self.get_credential().await?;
+        let url = self.config.service.clone();
+
+        let start = start.to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
+        let expiry = end.to_rfc3339_opts(chrono::SecondsFormat::Secs, true);
+
+        let mut body = String::new();
+        body.push_str("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<KeyInfo>\n");
+        body.push_str(&format!(
+            "\t<Start>{start}</Start>\n\t<Expiry>{expiry}</Expiry>\n"
+        ));
+        body.push_str("</KeyInfo>");
+
+        let response = self
+            .client
+            .request(Method::POST, url)
+            .body(body)
+            .query(&[("restype", "service"), ("comp", "userdelegationkey")])
+            .with_azure_authorization(&credential, &self.config.account)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(DelegationKeyRequestSnafu)?
+            .bytes()
+            .await
+            .context(DelegationKeyResponseBodySnafu)?;
+
+        let response: UserDelegationKey =
+            quick_xml::de::from_reader(response.reader()).context(DelegationKeyResponseSnafu)?;
+
+        Ok(response)
+    }
+
+    /// Creat an AzureSigner for generating SAS tokens (pre-signed urls).
+    ///
+    /// Depending on the type of credential, this will either use the account key or a user delegation key.
+    /// Since delegation keys are acquired ad-hoc, the signer aloows for signing multiple urls with the same key.
+    pub async fn signer(&self, expires_in: Duration) -> Result<AzureSigner> {
+        let credential = self.get_credential().await?;
+        let signed_start = chrono::Utc::now();
+        let signed_expiry = signed_start + expires_in;
+        match credential.as_deref() {
+            Some(AzureCredential::BearerToken(_)) => {
+                let key = self
+                    .get_user_delegation_key(&signed_start, &signed_expiry)
+                    .await?;
+                let signing_key = AzureAccessKey::try_new(&key.value)?;
+                Ok(AzureSigner::new(
+                    signing_key,
+                    self.config.account.clone(),
+                    signed_start,
+                    signed_expiry,
+                    Some(key),
+                ))
+            }
+            Some(AzureCredential::AccessKey(key)) => Ok(AzureSigner::new(
+                key.to_owned(),
+                self.config.account.clone(),
+                signed_start,
+                signed_expiry,
+                None,
+            )),
+            None => Err(Error::SASwithSkipSignature.into()),
+            _ => Err(Error::SASforSASNotSupported.into()),
+        }
+    }
+
+    #[cfg(test)]
+    pub async fn get_blob_tagging(&self, path: &Path) -> Result<Response> {
+        let credential = self.get_credential().await?;
+        let url = self.config.path_url(path);
+        let response = self
+            .client
+            .request(Method::GET, url)
+            .query(&[("comp", "tags")])
+            .with_azure_authorization(&credential, &self.config.account)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(GetRequestSnafu {
+                path: path.as_ref(),
+            })?;
+        Ok(response)
+    }
+}
+
+#[async_trait]
+impl GetClient for AzureClient {
+    const STORE: &'static str = STORE;
+
+    const HEADER_CONFIG: HeaderConfig = HeaderConfig {
+        etag_required: true,
+        last_modified_required: true,
+        version_header: Some(VERSION_HEADER),
+    };
+
+    /// Make an Azure GET request
+    /// <https://docs.microsoft.com/en-us/rest/api/storageservices/get-blob>
+    /// <https://docs.microsoft.com/en-us/rest/api/storageservices/get-blob-properties>
+    async fn get_request(&self, path: &Path, options: GetOptions) -> Result<Response> {
+        // As of 2024-01-02, Azure does not support suffix requests,
+        // so we should fail fast here rather than sending one
+        if let Some(GetRange::Suffix(_)) = options.range.as_ref() {
+            return Err(crate::Error::NotSupported {
+                source: "Azure does not support suffix range requests".into(),
+            });
+        }
+
+        let credential = self.get_credential().await?;
+        let url = self.config.path_url(path);
+        let method = match options.head {
+            true => Method::HEAD,
+            false => Method::GET,
+        };
+
+        let mut builder = self
+            .client
+            .request(method, url)
+            .header(CONTENT_LENGTH, HeaderValue::from_static("0"))
+            .body(Bytes::new());
+
+        if let Some(v) = &options.version {
+            builder = builder.query(&[("versionid", v)])
+        }
+
+        let response = builder
+            .with_get_options(options)
+            .with_azure_authorization(&credential, &self.config.account)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(GetRequestSnafu {
+                path: path.as_ref(),
+            })?;
+
+        match response.headers().get("x-ms-resource-type") {
+            Some(resource) if resource.as_ref() != b"file" => Err(crate::Error::NotFound {
+                path: path.to_string(),
+                source: format!(
+                    "Not a file, got x-ms-resource-type: {}",
+                    String::from_utf8_lossy(resource.as_ref())
+                )
+                .into(),
+            }),
+            _ => Ok(response),
+        }
+    }
+}
+
+#[async_trait]
+impl ListClient for AzureClient {
+    /// Make an Azure List request <https://docs.microsoft.com/en-us/rest/api/storageservices/list-blobs>
+    async fn list_request(
+        &self,
+        prefix: Option<&str>,
+        delimiter: bool,
+        token: Option<&str>,
+        offset: Option<&str>,
+    ) -> Result<(ListResult, Option<String>)> {
+        assert!(offset.is_none()); // Not yet supported
+
+        let credential = self.get_credential().await?;
+        let url = self.config.path_url(&Path::default());
+
+        let mut query = Vec::with_capacity(5);
+        query.push(("restype", "container"));
+        query.push(("comp", "list"));
+
+        if let Some(prefix) = prefix {
+            query.push(("prefix", prefix))
+        }
+
+        if delimiter {
+            query.push(("delimiter", DELIMITER))
+        }
+
+        if let Some(token) = token {
+            query.push(("marker", token))
+        }
+
+        let response = self
+            .client
+            .request(Method::GET, url)
+            .query(&query)
+            .with_azure_authorization(&credential, &self.config.account)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(ListRequestSnafu)?
+            .bytes()
+            .await
+            .context(ListResponseBodySnafu)?;
+
+        let mut response: ListResultInternal =
+            quick_xml::de::from_reader(response.reader()).context(InvalidListResponseSnafu)?;
+        let token = response.next_marker.take();
+
+        Ok((to_list_result(response, prefix)?, token))
+    }
+}
+
+/// Raw / internal response from list requests
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct ListResultInternal {
+    pub prefix: Option<String>,
+    pub max_results: Option<u32>,
+    pub delimiter: Option<String>,
+    pub next_marker: Option<String>,
+    pub blobs: Blobs,
+}
+
+fn to_list_result(value: ListResultInternal, prefix: Option<&str>) -> Result<ListResult> {
+    let prefix = prefix.map(Path::from).unwrap_or_default();
+    let common_prefixes = value
+        .blobs
+        .blob_prefix
+        .into_iter()
+        .map(|x| Ok(Path::parse(x.name)?))
+        .collect::<Result<_>>()?;
+
+    let objects = value
+        .blobs
+        .blobs
+        .into_iter()
+        .map(ObjectMeta::try_from)
+        // Note: workaround for gen2 accounts with hierarchical namespaces. These accounts also
+        // return path segments as "directories" and include blobs in list requests with prefix,
+        // if the prefix matches the blob. When we want directories, its always via
+        // the BlobPrefix mechanics, and during lists we state that prefixes are evaluated on path segment basis.
+        .filter_map_ok(|obj| {
+            if obj.size > 0 && obj.location.as_ref().len() > prefix.as_ref().len() {
+                Some(obj)
+            } else {
+                None
+            }
+        })
+        .collect::<Result<_>>()?;
+
+    Ok(ListResult {
+        common_prefixes,
+        objects,
+    })
+}
+
+/// Collection of blobs and potentially shared prefixes returned from list requests.
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct Blobs {
+    #[serde(default)]
+    pub blob_prefix: Vec<BlobPrefix>,
+    #[serde(rename = "Blob", default)]
+    pub blobs: Vec<Blob>,
+}
+
+/// Common prefix in list blobs response
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct BlobPrefix {
+    pub name: String,
+}
+
+/// Details for a specific blob
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct Blob {
+    pub name: String,
+    pub version_id: Option<String>,
+    pub is_current_version: Option<bool>,
+    pub deleted: Option<bool>,
+    pub properties: BlobProperties,
+    pub metadata: Option<HashMap<String, String>>,
+}
+
+impl TryFrom<Blob> for ObjectMeta {
+    type Error = crate::Error;
+
+    fn try_from(value: Blob) -> Result<Self> {
+        Ok(Self {
+            location: Path::parse(value.name)?,
+            last_modified: value.properties.last_modified,
+            size: value.properties.content_length as usize,
+            e_tag: value.properties.e_tag,
+            version: None, // For consistency with S3 and GCP which don't include this
+        })
+    }
+}
+
+/// Properties associated with individual blobs. The actual list
+/// of returned properties is much more exhaustive, but we limit
+/// the parsed fields to the ones relevant in this crate.
+#[derive(Debug, Clone, PartialEq, Eq, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+struct BlobProperties {
+    #[serde(deserialize_with = "deserialize_rfc1123", rename = "Last-Modified")]
+    pub last_modified: DateTime<Utc>,
+    #[serde(rename = "Content-Length")]
+    pub content_length: u64,
+    #[serde(rename = "Content-Type")]
+    pub content_type: String,
+    #[serde(rename = "Content-Encoding")]
+    pub content_encoding: Option<String>,
+    #[serde(rename = "Content-Language")]
+    pub content_language: Option<String>,
+    #[serde(rename = "Etag")]
+    pub e_tag: Option<String>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub(crate) struct BlockId(Bytes);
+
+impl BlockId {
+    pub fn new(block_id: impl Into<Bytes>) -> Self {
+        Self(block_id.into())
+    }
+}
+
+impl<B> From<B> for BlockId
+where
+    B: Into<Bytes>,
+{
+    fn from(v: B) -> Self {
+        Self::new(v)
+    }
+}
+
+impl AsRef<[u8]> for BlockId {
+    fn as_ref(&self) -> &[u8] {
+        self.0.as_ref()
+    }
+}
+
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub(crate) struct BlockList {
+    pub blocks: Vec<BlockId>,
+}
+
+impl BlockList {
+    pub fn to_xml(&self) -> String {
+        let mut s = String::new();
+        s.push_str("<?xml version=\"1.0\" encoding=\"utf-8\"?>\n<BlockList>\n");
+        for block_id in &self.blocks {
+            let node = format!(
+                "\t<Uncommitted>{}</Uncommitted>\n",
+                BASE64_STANDARD.encode(block_id)
+            );
+            s.push_str(&node);
+        }
+
+        s.push_str("</BlockList>");
+        s
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub(crate) struct UserDelegationKey {
+    pub signed_oid: String,
+    pub signed_tid: String,
+    pub signed_start: String,
+    pub signed_expiry: String,
+    pub signed_service: String,
+    pub signed_version: String,
+    pub value: String,
+}
+
+#[cfg(test)]
+mod tests {
+    use bytes::Bytes;
+
+    use super::*;
+
+    #[test]
+    fn deserde_azure() {
+        const S: &str = "<?xml version=\"1.0\" encoding=\"utf-8\"?>
+<EnumerationResults ServiceEndpoint=\"https://azureskdforrust.blob.core.windows.net/\" ContainerName=\"osa2\">
+    <Blobs>
+        <Blob>
+            <Name>blob0.txt</Name>
+            <Properties>
+                <Creation-Time>Thu, 01 Jul 2021 10:44:59 GMT</Creation-Time>
+                <Last-Modified>Thu, 01 Jul 2021 10:44:59 GMT</Last-Modified>
+                <Expiry-Time>Thu, 07 Jul 2022 14:38:48 GMT</Expiry-Time>
+                <Etag>0x8D93C7D4629C227</Etag>
+                <Content-Length>8</Content-Length>
+                <Content-Type>text/plain</Content-Type>
+                <Content-Encoding />
+                <Content-Language />
+                <Content-CRC64 />
+                <Content-MD5>rvr3UC1SmUw7AZV2NqPN0g==</Content-MD5>
+                <Cache-Control />
+                <Content-Disposition />
+                <BlobType>BlockBlob</BlobType>
+                <AccessTier>Hot</AccessTier>
+                <AccessTierInferred>true</AccessTierInferred>
+                <LeaseStatus>unlocked</LeaseStatus>
+                <LeaseState>available</LeaseState>
+                <ServerEncrypted>true</ServerEncrypted>
+            </Properties>
+            <Metadata><userkey>uservalue</userkey></Metadata>
+            <OrMetadata />
+        </Blob>
+        <Blob>
+            <Name>blob1.txt</Name>
+            <Properties>
+                <Creation-Time>Thu, 01 Jul 2021 10:44:59 GMT</Creation-Time>
+                <Last-Modified>Thu, 01 Jul 2021 10:44:59 GMT</Last-Modified>
+                <Etag>0x8D93C7D463004D6</Etag>
+                <Content-Length>8</Content-Length>
+                <Content-Type>text/plain</Content-Type>
+                <Content-Encoding />
+                <Content-Language />
+                <Content-CRC64 />
+                <Content-MD5>rvr3UC1SmUw7AZV2NqPN0g==</Content-MD5>
+                <Cache-Control />
+                <Content-Disposition />
+                <BlobType>BlockBlob</BlobType>
+                <AccessTier>Hot</AccessTier>
+                <AccessTierInferred>true</AccessTierInferred>
+                <LeaseStatus>unlocked</LeaseStatus>
+                <LeaseState>available</LeaseState>
+                <ServerEncrypted>true</ServerEncrypted>
+            </Properties>
+            <OrMetadata />
+        </Blob>
+        <Blob>
+            <Name>blob2.txt</Name>
+            <Properties>
+                <Creation-Time>Thu, 01 Jul 2021 10:44:59 GMT</Creation-Time>
+                <Last-Modified>Thu, 01 Jul 2021 10:44:59 GMT</Last-Modified>
+                <Etag>0x8D93C7D4636478A</Etag>
+                <Content-Length>8</Content-Length>
+                <Content-Type>text/plain</Content-Type>
+                <Content-Encoding />
+                <Content-Language />
+                <Content-CRC64 />
+                <Content-MD5>rvr3UC1SmUw7AZV2NqPN0g==</Content-MD5>
+                <Cache-Control />
+                <Content-Disposition />
+                <BlobType>BlockBlob</BlobType>
+                <AccessTier>Hot</AccessTier>
+                <AccessTierInferred>true</AccessTierInferred>
+                <LeaseStatus>unlocked</LeaseStatus>
+                <LeaseState>available</LeaseState>
+                <ServerEncrypted>true</ServerEncrypted>
+            </Properties>
+            <OrMetadata />
+        </Blob>
+    </Blobs>
+    <NextMarker />
+</EnumerationResults>";
+
+        let mut _list_blobs_response_internal: ListResultInternal =
+            quick_xml::de::from_str(S).unwrap();
+    }
+
+    #[test]
+    fn deserde_azurite() {
+        const S: &str = "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"yes\"?>
+<EnumerationResults ServiceEndpoint=\"http://127.0.0.1:10000/devstoreaccount1\" ContainerName=\"osa2\">
+    <Prefix/>
+    <Marker/>
+    <MaxResults>5000</MaxResults>
+    <Delimiter/>
+    <Blobs>
+        <Blob>
+            <Name>blob0.txt</Name>
+            <Properties>
+                <Creation-Time>Thu, 01 Jul 2021 10:45:02 GMT</Creation-Time>
+                <Last-Modified>Thu, 01 Jul 2021 10:45:02 GMT</Last-Modified>
+                <Etag>0x228281B5D517B20</Etag>
+                <Content-Length>8</Content-Length>
+                <Content-Type>text/plain</Content-Type>
+                <Content-MD5>rvr3UC1SmUw7AZV2NqPN0g==</Content-MD5>
+                <BlobType>BlockBlob</BlobType>
+                <LeaseStatus>unlocked</LeaseStatus>
+                <LeaseState>available</LeaseState>
+                <ServerEncrypted>true</ServerEncrypted>
+                <AccessTier>Hot</AccessTier>
+                <AccessTierInferred>true</AccessTierInferred>
+                <AccessTierChangeTime>Thu, 01 Jul 2021 10:45:02 GMT</AccessTierChangeTime>
+            </Properties>
+        </Blob>
+        <Blob>
+            <Name>blob1.txt</Name>
+            <Properties>
+                <Creation-Time>Thu, 01 Jul 2021 10:45:02 GMT</Creation-Time>
+                <Last-Modified>Thu, 01 Jul 2021 10:45:02 GMT</Last-Modified>
+                <Etag>0x1DD959381A8A860</Etag>
+                <Content-Length>8</Content-Length>
+                <Content-Type>text/plain</Content-Type>
+                <Content-MD5>rvr3UC1SmUw7AZV2NqPN0g==</Content-MD5>
+                <BlobType>BlockBlob</BlobType>
+                <LeaseStatus>unlocked</LeaseStatus>
+                <LeaseState>available</LeaseState>
+                <ServerEncrypted>true</ServerEncrypted>
+                <AccessTier>Hot</AccessTier>
+                <AccessTierInferred>true</AccessTierInferred>
+                <AccessTierChangeTime>Thu, 01 Jul 2021 10:45:02 GMT</AccessTierChangeTime>
+            </Properties>
+        </Blob>
+        <Blob>
+            <Name>blob2.txt</Name>
+            <Properties>
+                <Creation-Time>Thu, 01 Jul 2021 10:45:02 GMT</Creation-Time>
+                <Last-Modified>Thu, 01 Jul 2021 10:45:02 GMT</Last-Modified>
+                <Etag>0x1FBE9C9B0C7B650</Etag>
+                <Content-Length>8</Content-Length>
+                <Content-Type>text/plain</Content-Type>
+                <Content-MD5>rvr3UC1SmUw7AZV2NqPN0g==</Content-MD5>
+                <BlobType>BlockBlob</BlobType>
+                <LeaseStatus>unlocked</LeaseStatus>
+                <LeaseState>available</LeaseState>
+                <ServerEncrypted>true</ServerEncrypted>
+                <AccessTier>Hot</AccessTier>
+                <AccessTierInferred>true</AccessTierInferred>
+                <AccessTierChangeTime>Thu, 01 Jul 2021 10:45:02 GMT</AccessTierChangeTime>
+            </Properties>
+        </Blob>
+    </Blobs>
+    <NextMarker/>
+</EnumerationResults>";
+
+        let _list_blobs_response_internal: ListResultInternal = quick_xml::de::from_str(S).unwrap();
+    }
+
+    #[test]
+    fn to_xml() {
+        const S: &str = "<?xml version=\"1.0\" encoding=\"utf-8\"?>
+<BlockList>
+\t<Uncommitted>bnVtZXJvMQ==</Uncommitted>
+\t<Uncommitted>bnVtZXJvMg==</Uncommitted>
+\t<Uncommitted>bnVtZXJvMw==</Uncommitted>
+</BlockList>";
+        let mut blocks = BlockList { blocks: Vec::new() };
+        blocks.blocks.push(Bytes::from_static(b"numero1").into());
+        blocks.blocks.push("numero2".into());
+        blocks.blocks.push("numero3".into());
+
+        let res: &str = &blocks.to_xml();
+
+        assert_eq!(res, S)
+    }
+
+    #[test]
+    fn test_delegated_key_response() {
+        const S: &str = r#"<?xml version="1.0" encoding="utf-8"?>
+<UserDelegationKey>
+    <SignedOid>String containing a GUID value</SignedOid>
+    <SignedTid>String containing a GUID value</SignedTid>
+    <SignedStart>String formatted as ISO date</SignedStart>
+    <SignedExpiry>String formatted as ISO date</SignedExpiry>
+    <SignedService>b</SignedService>
+    <SignedVersion>String specifying REST api version to use to create the user delegation key</SignedVersion>
+    <Value>String containing the user delegation key</Value>
+</UserDelegationKey>"#;
+
+        let _delegated_key_response_internal: UserDelegationKey =
+            quick_xml::de::from_str(S).unwrap();
+    }
+}
diff --git a/object_store/src/azure/credential.rs b/object_store/src/azure/credential.rs
new file mode 100644
index 000000000000..9360831974ca
--- /dev/null
+++ b/object_store/src/azure/credential.rs
@@ -0,0 +1,1083 @@
+// 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.
+
+use crate::azure::STORE;
+use crate::client::retry::RetryExt;
+use crate::client::token::{TemporaryToken, TokenCache};
+use crate::client::{CredentialProvider, TokenProvider};
+use crate::util::hmac_sha256;
+use crate::RetryConfig;
+use async_trait::async_trait;
+use base64::prelude::BASE64_STANDARD;
+use base64::Engine;
+use chrono::{DateTime, SecondsFormat, Utc};
+use reqwest::header::{
+    HeaderMap, HeaderName, HeaderValue, ACCEPT, AUTHORIZATION, CONTENT_ENCODING, CONTENT_LANGUAGE,
+    CONTENT_LENGTH, CONTENT_TYPE, DATE, IF_MATCH, IF_MODIFIED_SINCE, IF_NONE_MATCH,
+    IF_UNMODIFIED_SINCE, RANGE,
+};
+use reqwest::{Client, Method, Request, RequestBuilder};
+use serde::Deserialize;
+use snafu::{ResultExt, Snafu};
+use std::borrow::Cow;
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::ops::Deref;
+use std::process::Command;
+use std::str;
+use std::sync::Arc;
+use std::time::{Duration, Instant, SystemTime};
+use url::Url;
+
+use super::client::UserDelegationKey;
+
+static AZURE_VERSION: HeaderValue = HeaderValue::from_static("2023-11-03");
+static VERSION: HeaderName = HeaderName::from_static("x-ms-version");
+pub(crate) static BLOB_TYPE: HeaderName = HeaderName::from_static("x-ms-blob-type");
+pub(crate) static DELETE_SNAPSHOTS: HeaderName = HeaderName::from_static("x-ms-delete-snapshots");
+pub(crate) static COPY_SOURCE: HeaderName = HeaderName::from_static("x-ms-copy-source");
+static CONTENT_MD5: HeaderName = HeaderName::from_static("content-md5");
+pub(crate) const RFC1123_FMT: &str = "%a, %d %h %Y %T GMT";
+const CONTENT_TYPE_JSON: &str = "application/json";
+const MSI_SECRET_ENV_KEY: &str = "IDENTITY_HEADER";
+const MSI_API_VERSION: &str = "2019-08-01";
+
+/// OIDC scope used when interacting with OAuth2 APIs
+///
+/// <https://learn.microsoft.com/en-us/azure/active-directory/develop/scopes-oidc#the-default-scope>
+const AZURE_STORAGE_SCOPE: &str = "https://storage.azure.com/.default";
+
+/// Resource ID used when obtaining an access token from the metadata endpoint
+///
+/// <https://learn.microsoft.com/en-us/azure/storage/blobs/authorize-access-azure-active-directory#microsoft-authentication-library-msal>
+const AZURE_STORAGE_RESOURCE: &str = "https://storage.azure.com";
+
+#[derive(Debug, Snafu)]
+pub enum Error {
+    #[snafu(display("Error performing token request: {}", source))]
+    TokenRequest { source: crate::client::retry::Error },
+
+    #[snafu(display("Error getting token response body: {}", source))]
+    TokenResponseBody { source: reqwest::Error },
+
+    #[snafu(display("Error reading federated token file "))]
+    FederatedTokenFile,
+
+    #[snafu(display("Invalid Access Key: {}", source))]
+    InvalidAccessKey { source: base64::DecodeError },
+
+    #[snafu(display("'az account get-access-token' command failed: {message}"))]
+    AzureCli { message: String },
+
+    #[snafu(display("Failed to parse azure cli response: {source}"))]
+    AzureCliResponse { source: serde_json::Error },
+
+    #[snafu(display("Generating SAS keys with SAS tokens auth is not supported"))]
+    SASforSASNotSupported,
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+impl From<Error> for crate::Error {
+    fn from(value: Error) -> Self {
+        Self::Generic {
+            store: STORE,
+            source: Box::new(value),
+        }
+    }
+}
+
+/// A shared Azure Storage Account Key
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct AzureAccessKey(Vec<u8>);
+
+impl AzureAccessKey {
+    /// Create a new [`AzureAccessKey`], checking it for validity
+    pub fn try_new(key: &str) -> Result<Self> {
+        let key = BASE64_STANDARD.decode(key).context(InvalidAccessKeySnafu)?;
+        Ok(Self(key))
+    }
+}
+
+/// An Azure storage credential
+#[derive(Debug, Eq, PartialEq)]
+pub enum AzureCredential {
+    /// A shared access key
+    ///
+    /// <https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key>
+    AccessKey(AzureAccessKey),
+    /// A shared access signature
+    ///
+    /// <https://learn.microsoft.com/en-us/rest/api/storageservices/delegate-access-with-shared-access-signature>
+    SASToken(Vec<(String, String)>),
+    /// An authorization token
+    ///
+    /// <https://learn.microsoft.com/en-us/rest/api/storageservices/authorize-with-azure-active-directory>
+    BearerToken(String),
+}
+
+/// A list of known Azure authority hosts
+pub mod authority_hosts {
+    /// China-based Azure Authority Host
+    pub const AZURE_CHINA: &str = "https://login.chinacloudapi.cn";
+    /// Germany-based Azure Authority Host
+    pub const AZURE_GERMANY: &str = "https://login.microsoftonline.de";
+    /// US Government Azure Authority Host
+    pub const AZURE_GOVERNMENT: &str = "https://login.microsoftonline.us";
+    /// Public Cloud Azure Authority Host
+    pub const AZURE_PUBLIC_CLOUD: &str = "https://login.microsoftonline.com";
+}
+
+pub(crate) struct AzureSigner {
+    signing_key: AzureAccessKey,
+    start: DateTime<Utc>,
+    end: DateTime<Utc>,
+    account: String,
+    delegation_key: Option<UserDelegationKey>,
+}
+
+impl AzureSigner {
+    pub fn new(
+        signing_key: AzureAccessKey,
+        account: String,
+        start: DateTime<Utc>,
+        end: DateTime<Utc>,
+        delegation_key: Option<UserDelegationKey>,
+    ) -> Self {
+        Self {
+            signing_key,
+            account,
+            start,
+            end,
+            delegation_key,
+        }
+    }
+
+    pub fn sign(&self, method: &Method, url: &mut Url) -> Result<()> {
+        let (str_to_sign, query_pairs) = match &self.delegation_key {
+            Some(delegation_key) => string_to_sign_user_delegation_sas(
+                url,
+                method,
+                &self.account,
+                &self.start,
+                &self.end,
+                delegation_key,
+            ),
+            None => string_to_sign_service_sas(url, method, &self.account, &self.start, &self.end),
+        };
+        let auth = hmac_sha256(&self.signing_key.0, str_to_sign);
+        url.query_pairs_mut().extend_pairs(query_pairs);
+        url.query_pairs_mut()
+            .append_pair("sig", BASE64_STANDARD.encode(auth).as_str());
+        Ok(())
+    }
+}
+
+fn add_date_and_version_headers(request: &mut Request) {
+    // rfc2822 string should never contain illegal characters
+    let date = Utc::now();
+    let date_str = date.format(RFC1123_FMT).to_string();
+    // we formatted the data string ourselves, so unwrapping should be fine
+    let date_val = HeaderValue::from_str(&date_str).unwrap();
+    request.headers_mut().insert(DATE, date_val);
+    request
+        .headers_mut()
+        .insert(&VERSION, AZURE_VERSION.clone());
+}
+
+/// Authorize a [`Request`] with an [`AzureAuthorizer`]
+#[derive(Debug)]
+pub struct AzureAuthorizer<'a> {
+    credential: &'a AzureCredential,
+    account: &'a str,
+}
+
+impl<'a> AzureAuthorizer<'a> {
+    /// Create a new [`AzureAuthorizer`]
+    pub fn new(credential: &'a AzureCredential, account: &'a str) -> Self {
+        AzureAuthorizer {
+            credential,
+            account,
+        }
+    }
+
+    /// Authorize `request`
+    pub fn authorize(&self, request: &mut Request) {
+        add_date_and_version_headers(request);
+
+        match self.credential {
+            AzureCredential::AccessKey(key) => {
+                let signature = generate_authorization(
+                    request.headers(),
+                    request.url(),
+                    request.method(),
+                    self.account,
+                    key,
+                );
+
+                // "signature" is a base 64 encoded string so it should never
+                // contain illegal characters
+                request.headers_mut().append(
+                    AUTHORIZATION,
+                    HeaderValue::from_str(signature.as_str()).unwrap(),
+                );
+            }
+            AzureCredential::BearerToken(token) => {
+                request.headers_mut().append(
+                    AUTHORIZATION,
+                    HeaderValue::from_str(format!("Bearer {}", token).as_str()).unwrap(),
+                );
+            }
+            AzureCredential::SASToken(query_pairs) => {
+                request
+                    .url_mut()
+                    .query_pairs_mut()
+                    .extend_pairs(query_pairs);
+            }
+        }
+    }
+}
+
+pub(crate) trait CredentialExt {
+    /// Apply authorization to requests against azure storage accounts
+    /// <https://docs.microsoft.com/en-us/rest/api/storageservices/authorize-requests-to-azure-storage>
+    fn with_azure_authorization(
+        self,
+        credential: &Option<impl Deref<Target = AzureCredential>>,
+        account: &str,
+    ) -> Self;
+}
+
+impl CredentialExt for RequestBuilder {
+    fn with_azure_authorization(
+        self,
+        credential: &Option<impl Deref<Target = AzureCredential>>,
+        account: &str,
+    ) -> Self {
+        let (client, request) = self.build_split();
+        let mut request = request.expect("request valid");
+
+        match credential.as_deref() {
+            Some(credential) => {
+                AzureAuthorizer::new(credential, account).authorize(&mut request);
+            }
+            None => {
+                add_date_and_version_headers(&mut request);
+            }
+        }
+
+        Self::from_parts(client, request)
+    }
+}
+
+/// Generate signed key for authorization via access keys
+/// <https://docs.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key>
+fn generate_authorization(
+    h: &HeaderMap,
+    u: &Url,
+    method: &Method,
+    account: &str,
+    key: &AzureAccessKey,
+) -> String {
+    let str_to_sign = string_to_sign(h, u, method, account);
+    let auth = hmac_sha256(&key.0, str_to_sign);
+    format!("SharedKey {}:{}", account, BASE64_STANDARD.encode(auth))
+}
+
+fn add_if_exists<'a>(h: &'a HeaderMap, key: &HeaderName) -> &'a str {
+    h.get(key)
+        .map(|s| s.to_str())
+        .transpose()
+        .ok()
+        .flatten()
+        .unwrap_or_default()
+}
+
+fn string_to_sign_sas(
+    u: &Url,
+    method: &Method,
+    account: &str,
+    start: &DateTime<Utc>,
+    end: &DateTime<Utc>,
+) -> (String, String, String, String, String) {
+    // NOTE: for now only blob signing is supported.
+    let signed_resource = "b".to_string();
+
+    // https://learn.microsoft.com/en-us/rest/api/storageservices/create-service-sas#permissions-for-a-directory-container-or-blob
+    let signed_permissions = match *method {
+        // read and list permissions
+        Method::GET => match signed_resource.as_str() {
+            "c" => "rl",
+            "b" => "r",
+            _ => unreachable!(),
+        },
+        // write permissions (also allows crating a new blob in a sub-key)
+        Method::PUT => "w",
+        // delete permissions
+        Method::DELETE => "d",
+        // other methods are not used in any of the current operations
+        _ => "",
+    }
+    .to_string();
+    let signed_start = start.to_rfc3339_opts(SecondsFormat::Secs, true);
+    let signed_expiry = end.to_rfc3339_opts(SecondsFormat::Secs, true);
+    let canonicalized_resource = if u.host_str().unwrap_or_default().contains(account) {
+        format!("/blob/{}{}", account, u.path())
+    } else {
+        // NOTE: in case of the emulator, the account name is not part of the host
+        //      but the path starts with the account name
+        format!("/blob{}", u.path())
+    };
+
+    (
+        signed_resource,
+        signed_permissions,
+        signed_start,
+        signed_expiry,
+        canonicalized_resource,
+    )
+}
+
+/// Create a string to be signed for authorization via [service sas].
+///
+/// [service sas]: https://learn.microsoft.com/en-us/rest/api/storageservices/create-service-sas#version-2020-12-06-and-later
+fn string_to_sign_service_sas(
+    u: &Url,
+    method: &Method,
+    account: &str,
+    start: &DateTime<Utc>,
+    end: &DateTime<Utc>,
+) -> (String, HashMap<&'static str, String>) {
+    let (signed_resource, signed_permissions, signed_start, signed_expiry, canonicalized_resource) =
+        string_to_sign_sas(u, method, account, start, end);
+
+    let string_to_sign = format!(
+        "{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}",
+        signed_permissions,
+        signed_start,
+        signed_expiry,
+        canonicalized_resource,
+        "",                               // signed identifier
+        "",                               // signed ip
+        "",                               // signed protocol
+        &AZURE_VERSION.to_str().unwrap(), // signed version
+        signed_resource,                  // signed resource
+        "",                               // signed snapshot time
+        "",                               // signed encryption scope
+        "",                               // rscc - response header: Cache-Control
+        "",                               // rscd - response header: Content-Disposition
+        "",                               // rsce - response header: Content-Encoding
+        "",                               // rscl - response header: Content-Language
+        "",                               // rsct - response header: Content-Type
+    );
+
+    let mut pairs = HashMap::new();
+    pairs.insert("sv", AZURE_VERSION.to_str().unwrap().to_string());
+    pairs.insert("sp", signed_permissions);
+    pairs.insert("st", signed_start);
+    pairs.insert("se", signed_expiry);
+    pairs.insert("sr", signed_resource);
+
+    (string_to_sign, pairs)
+}
+
+/// Create a string to be signed for authorization via [user delegation sas].
+///
+/// [user delegation sas]: https://learn.microsoft.com/en-us/rest/api/storageservices/create-user-delegation-sas#version-2020-12-06-and-later
+fn string_to_sign_user_delegation_sas(
+    u: &Url,
+    method: &Method,
+    account: &str,
+    start: &DateTime<Utc>,
+    end: &DateTime<Utc>,
+    delegation_key: &UserDelegationKey,
+) -> (String, HashMap<&'static str, String>) {
+    let (signed_resource, signed_permissions, signed_start, signed_expiry, canonicalized_resource) =
+        string_to_sign_sas(u, method, account, start, end);
+
+    let string_to_sign = format!(
+        "{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}",
+        signed_permissions,
+        signed_start,
+        signed_expiry,
+        canonicalized_resource,
+        delegation_key.signed_oid,        // signed key object id
+        delegation_key.signed_tid,        // signed key tenant id
+        delegation_key.signed_start,      // signed key start
+        delegation_key.signed_expiry,     // signed key expiry
+        delegation_key.signed_service,    // signed key service
+        delegation_key.signed_version,    // signed key version
+        "",                               // signed authorized user object id
+        "",                               // signed unauthorized user object id
+        "",                               // signed correlation id
+        "",                               // signed ip
+        "",                               // signed protocol
+        &AZURE_VERSION.to_str().unwrap(), // signed version
+        signed_resource,                  // signed resource
+        "",                               // signed snapshot time
+        "",                               // signed encryption scope
+        "",                               // rscc - response header: Cache-Control
+        "",                               // rscd - response header: Content-Disposition
+        "",                               // rsce - response header: Content-Encoding
+        "",                               // rscl - response header: Content-Language
+        "",                               // rsct - response header: Content-Type
+    );
+
+    let mut pairs = HashMap::new();
+    pairs.insert("sv", AZURE_VERSION.to_str().unwrap().to_string());
+    pairs.insert("sp", signed_permissions);
+    pairs.insert("st", signed_start);
+    pairs.insert("se", signed_expiry);
+    pairs.insert("sr", signed_resource);
+    pairs.insert("skoid", delegation_key.signed_oid.clone());
+    pairs.insert("sktid", delegation_key.signed_tid.clone());
+    pairs.insert("skt", delegation_key.signed_start.clone());
+    pairs.insert("ske", delegation_key.signed_expiry.clone());
+    pairs.insert("sks", delegation_key.signed_service.clone());
+    pairs.insert("skv", delegation_key.signed_version.clone());
+
+    (string_to_sign, pairs)
+}
+
+/// <https://docs.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key#constructing-the-signature-string>
+fn string_to_sign(h: &HeaderMap, u: &Url, method: &Method, account: &str) -> String {
+    // content length must only be specified if != 0
+    // this is valid from 2015-02-21
+    let content_length = h
+        .get(&CONTENT_LENGTH)
+        .map(|s| s.to_str())
+        .transpose()
+        .ok()
+        .flatten()
+        .filter(|&v| v != "0")
+        .unwrap_or_default();
+    format!(
+        "{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}\n{}{}",
+        method.as_ref(),
+        add_if_exists(h, &CONTENT_ENCODING),
+        add_if_exists(h, &CONTENT_LANGUAGE),
+        content_length,
+        add_if_exists(h, &CONTENT_MD5),
+        add_if_exists(h, &CONTENT_TYPE),
+        add_if_exists(h, &DATE),
+        add_if_exists(h, &IF_MODIFIED_SINCE),
+        add_if_exists(h, &IF_MATCH),
+        add_if_exists(h, &IF_NONE_MATCH),
+        add_if_exists(h, &IF_UNMODIFIED_SINCE),
+        add_if_exists(h, &RANGE),
+        canonicalize_header(h),
+        canonicalize_resource(account, u)
+    )
+}
+
+/// <https://docs.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key#constructing-the-canonicalized-headers-string>
+fn canonicalize_header(headers: &HeaderMap) -> String {
+    let mut names = headers
+        .iter()
+        .filter(|&(k, _)| (k.as_str().starts_with("x-ms")))
+        // TODO remove unwraps
+        .map(|(k, _)| (k.as_str(), headers.get(k).unwrap().to_str().unwrap()))
+        .collect::<Vec<_>>();
+    names.sort_unstable();
+
+    let mut result = String::new();
+    for (name, value) in names {
+        result.push_str(name);
+        result.push(':');
+        result.push_str(value);
+        result.push('\n');
+    }
+    result
+}
+
+/// <https://docs.microsoft.com/en-us/rest/api/storageservices/authorize-with-shared-key#constructing-the-canonicalized-resource-string>
+fn canonicalize_resource(account: &str, uri: &Url) -> String {
+    let mut can_res: String = String::new();
+    can_res.push('/');
+    can_res.push_str(account);
+    can_res.push_str(uri.path().to_string().as_str());
+    can_res.push('\n');
+
+    // query parameters
+    let query_pairs = uri.query_pairs();
+    {
+        let mut qps: Vec<String> = Vec::new();
+        for (q, _) in query_pairs {
+            if !(qps.iter().any(|x| x == &*q)) {
+                qps.push(q.into_owned());
+            }
+        }
+
+        qps.sort();
+
+        for qparam in qps {
+            // find correct parameter
+            let ret = lexy_sort(query_pairs, &qparam);
+
+            can_res = can_res + &qparam.to_lowercase() + ":";
+
+            for (i, item) in ret.iter().enumerate() {
+                if i > 0 {
+                    can_res.push(',');
+                }
+                can_res.push_str(item);
+            }
+
+            can_res.push('\n');
+        }
+    };
+
+    can_res[0..can_res.len() - 1].to_owned()
+}
+
+fn lexy_sort<'a>(
+    vec: impl Iterator<Item = (Cow<'a, str>, Cow<'a, str>)> + 'a,
+    query_param: &str,
+) -> Vec<Cow<'a, str>> {
+    let mut values = vec
+        .filter(|(k, _)| *k == query_param)
+        .map(|(_, v)| v)
+        .collect::<Vec<_>>();
+    values.sort_unstable();
+    values
+}
+
+/// <https://learn.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow#successful-response-1>
+#[derive(Deserialize, Debug)]
+struct OAuthTokenResponse {
+    access_token: String,
+    expires_in: u64,
+}
+
+/// Encapsulates the logic to perform an OAuth token challenge
+///
+/// <https://learn.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow#first-case-access-token-request-with-a-shared-secret>
+#[derive(Debug)]
+pub struct ClientSecretOAuthProvider {
+    token_url: String,
+    client_id: String,
+    client_secret: String,
+}
+
+impl ClientSecretOAuthProvider {
+    /// Create a new [`ClientSecretOAuthProvider`] for an azure backed store
+    pub fn new(
+        client_id: String,
+        client_secret: String,
+        tenant_id: impl AsRef<str>,
+        authority_host: Option<String>,
+    ) -> Self {
+        let authority_host =
+            authority_host.unwrap_or_else(|| authority_hosts::AZURE_PUBLIC_CLOUD.to_owned());
+
+        Self {
+            token_url: format!(
+                "{}/{}/oauth2/v2.0/token",
+                authority_host,
+                tenant_id.as_ref()
+            ),
+            client_id,
+            client_secret,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl TokenProvider for ClientSecretOAuthProvider {
+    type Credential = AzureCredential;
+
+    /// Fetch a token
+    async fn fetch_token(
+        &self,
+        client: &Client,
+        retry: &RetryConfig,
+    ) -> crate::Result<TemporaryToken<Arc<AzureCredential>>> {
+        let response: OAuthTokenResponse = client
+            .request(Method::POST, &self.token_url)
+            .header(ACCEPT, HeaderValue::from_static(CONTENT_TYPE_JSON))
+            .form(&[
+                ("client_id", self.client_id.as_str()),
+                ("client_secret", self.client_secret.as_str()),
+                ("scope", AZURE_STORAGE_SCOPE),
+                ("grant_type", "client_credentials"),
+            ])
+            .send_retry(retry)
+            .await
+            .context(TokenRequestSnafu)?
+            .json()
+            .await
+            .context(TokenResponseBodySnafu)?;
+
+        Ok(TemporaryToken {
+            token: Arc::new(AzureCredential::BearerToken(response.access_token)),
+            expiry: Some(Instant::now() + Duration::from_secs(response.expires_in)),
+        })
+    }
+}
+
+fn expires_on_string<'de, D>(deserializer: D) -> std::result::Result<Instant, D::Error>
+where
+    D: serde::de::Deserializer<'de>,
+{
+    let v = String::deserialize(deserializer)?;
+    let v = v.parse::<u64>().map_err(serde::de::Error::custom)?;
+    let now = SystemTime::now()
+        .duration_since(SystemTime::UNIX_EPOCH)
+        .map_err(serde::de::Error::custom)?;
+
+    Ok(Instant::now() + Duration::from_secs(v.saturating_sub(now.as_secs())))
+}
+
+/// NOTE: expires_on is a String version of unix epoch time, not an integer.
+/// <https://learn.microsoft.com/en-gb/azure/active-directory/managed-identities-azure-resources/how-to-use-vm-token#get-a-token-using-http>
+/// <https://learn.microsoft.com/en-us/azure/app-service/overview-managed-identity?tabs=portal%2Chttp#connect-to-azure-services-in-app-code>
+#[derive(Debug, Clone, Deserialize)]
+struct ImdsTokenResponse {
+    pub access_token: String,
+    #[serde(deserialize_with = "expires_on_string")]
+    pub expires_on: Instant,
+}
+
+/// Attempts authentication using a managed identity that has been assigned to the deployment environment.
+///
+/// This authentication type works in Azure VMs, App Service and Azure Functions applications, as well as the Azure Cloud Shell
+/// <https://learn.microsoft.com/en-gb/azure/active-directory/managed-identities-azure-resources/how-to-use-vm-token#get-a-token-using-http>
+#[derive(Debug)]
+pub struct ImdsManagedIdentityProvider {
+    msi_endpoint: String,
+    client_id: Option<String>,
+    object_id: Option<String>,
+    msi_res_id: Option<String>,
+}
+
+impl ImdsManagedIdentityProvider {
+    /// Create a new [`ImdsManagedIdentityProvider`] for an azure backed store
+    pub fn new(
+        client_id: Option<String>,
+        object_id: Option<String>,
+        msi_res_id: Option<String>,
+        msi_endpoint: Option<String>,
+    ) -> Self {
+        let msi_endpoint = msi_endpoint
+            .unwrap_or_else(|| "http://169.254.169.254/metadata/identity/oauth2/token".to_owned());
+
+        Self {
+            msi_endpoint,
+            client_id,
+            object_id,
+            msi_res_id,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl TokenProvider for ImdsManagedIdentityProvider {
+    type Credential = AzureCredential;
+
+    /// Fetch a token
+    async fn fetch_token(
+        &self,
+        client: &Client,
+        retry: &RetryConfig,
+    ) -> crate::Result<TemporaryToken<Arc<AzureCredential>>> {
+        let mut query_items = vec![
+            ("api-version", MSI_API_VERSION),
+            ("resource", AZURE_STORAGE_RESOURCE),
+        ];
+
+        let mut identity = None;
+        if let Some(client_id) = &self.client_id {
+            identity = Some(("client_id", client_id));
+        }
+        if let Some(object_id) = &self.object_id {
+            identity = Some(("object_id", object_id));
+        }
+        if let Some(msi_res_id) = &self.msi_res_id {
+            identity = Some(("msi_res_id", msi_res_id));
+        }
+        if let Some((key, value)) = identity {
+            query_items.push((key, value));
+        }
+
+        let mut builder = client
+            .request(Method::GET, &self.msi_endpoint)
+            .header("metadata", "true")
+            .query(&query_items);
+
+        if let Ok(val) = std::env::var(MSI_SECRET_ENV_KEY) {
+            builder = builder.header("x-identity-header", val);
+        };
+
+        let response: ImdsTokenResponse = builder
+            .send_retry(retry)
+            .await
+            .context(TokenRequestSnafu)?
+            .json()
+            .await
+            .context(TokenResponseBodySnafu)?;
+
+        Ok(TemporaryToken {
+            token: Arc::new(AzureCredential::BearerToken(response.access_token)),
+            expiry: Some(response.expires_on),
+        })
+    }
+}
+
+/// Credential for using workload identity federation
+///
+/// <https://learn.microsoft.com/en-us/azure/active-directory/develop/workload-identity-federation>
+#[derive(Debug)]
+pub struct WorkloadIdentityOAuthProvider {
+    token_url: String,
+    client_id: String,
+    federated_token_file: String,
+}
+
+impl WorkloadIdentityOAuthProvider {
+    /// Create a new [`WorkloadIdentityOAuthProvider`] for an azure backed store
+    pub fn new(
+        client_id: impl Into<String>,
+        federated_token_file: impl Into<String>,
+        tenant_id: impl AsRef<str>,
+        authority_host: Option<String>,
+    ) -> Self {
+        let authority_host =
+            authority_host.unwrap_or_else(|| authority_hosts::AZURE_PUBLIC_CLOUD.to_owned());
+
+        Self {
+            token_url: format!(
+                "{}/{}/oauth2/v2.0/token",
+                authority_host,
+                tenant_id.as_ref()
+            ),
+            client_id: client_id.into(),
+            federated_token_file: federated_token_file.into(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl TokenProvider for WorkloadIdentityOAuthProvider {
+    type Credential = AzureCredential;
+
+    /// Fetch a token
+    async fn fetch_token(
+        &self,
+        client: &Client,
+        retry: &RetryConfig,
+    ) -> crate::Result<TemporaryToken<Arc<AzureCredential>>> {
+        let token_str = std::fs::read_to_string(&self.federated_token_file)
+            .map_err(|_| Error::FederatedTokenFile)?;
+
+        // https://learn.microsoft.com/en-us/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow#third-case-access-token-request-with-a-federated-credential
+        let response: OAuthTokenResponse = client
+            .request(Method::POST, &self.token_url)
+            .header(ACCEPT, HeaderValue::from_static(CONTENT_TYPE_JSON))
+            .form(&[
+                ("client_id", self.client_id.as_str()),
+                (
+                    "client_assertion_type",
+                    "urn:ietf:params:oauth:client-assertion-type:jwt-bearer",
+                ),
+                ("client_assertion", token_str.as_str()),
+                ("scope", AZURE_STORAGE_SCOPE),
+                ("grant_type", "client_credentials"),
+            ])
+            .send_retry(retry)
+            .await
+            .context(TokenRequestSnafu)?
+            .json()
+            .await
+            .context(TokenResponseBodySnafu)?;
+
+        Ok(TemporaryToken {
+            token: Arc::new(AzureCredential::BearerToken(response.access_token)),
+            expiry: Some(Instant::now() + Duration::from_secs(response.expires_in)),
+        })
+    }
+}
+
+mod az_cli_date_format {
+    use chrono::{DateTime, TimeZone};
+    use serde::{self, Deserialize, Deserializer};
+
+    pub fn deserialize<'de, D>(deserializer: D) -> Result<DateTime<chrono::Local>, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let s = String::deserialize(deserializer)?;
+        // expiresOn from azure cli uses the local timezone
+        let date = chrono::NaiveDateTime::parse_from_str(&s, "%Y-%m-%d %H:%M:%S.%6f")
+            .map_err(serde::de::Error::custom)?;
+        chrono::Local
+            .from_local_datetime(&date)
+            .single()
+            .ok_or(serde::de::Error::custom(
+                "azure cli returned ambiguous expiry date",
+            ))
+    }
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(rename_all = "camelCase")]
+struct AzureCliTokenResponse {
+    pub access_token: String,
+    #[serde(with = "az_cli_date_format")]
+    pub expires_on: DateTime<chrono::Local>,
+    pub token_type: String,
+}
+
+#[derive(Default, Debug)]
+pub struct AzureCliCredential {
+    cache: TokenCache<Arc<AzureCredential>>,
+}
+
+impl AzureCliCredential {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Fetch a token
+    async fn fetch_token(&self) -> Result<TemporaryToken<Arc<AzureCredential>>> {
+        // on window az is a cmd and it should be called like this
+        // see https://doc.rust-lang.org/nightly/std/process/struct.Command.html
+        let program = if cfg!(target_os = "windows") {
+            "cmd"
+        } else {
+            "az"
+        };
+        let mut args = Vec::new();
+        if cfg!(target_os = "windows") {
+            args.push("/C");
+            args.push("az");
+        }
+        args.push("account");
+        args.push("get-access-token");
+        args.push("--output");
+        args.push("json");
+        args.push("--scope");
+        args.push(AZURE_STORAGE_SCOPE);
+
+        match Command::new(program).args(args).output() {
+            Ok(az_output) if az_output.status.success() => {
+                let output = str::from_utf8(&az_output.stdout).map_err(|_| Error::AzureCli {
+                    message: "az response is not a valid utf-8 string".to_string(),
+                })?;
+
+                let token_response = serde_json::from_str::<AzureCliTokenResponse>(output)
+                    .context(AzureCliResponseSnafu)?;
+                if !token_response.token_type.eq_ignore_ascii_case("bearer") {
+                    return Err(Error::AzureCli {
+                        message: format!(
+                            "got unexpected token type from azure cli: {0}",
+                            token_response.token_type
+                        ),
+                    });
+                }
+                let duration =
+                    token_response.expires_on.naive_local() - chrono::Local::now().naive_local();
+                Ok(TemporaryToken {
+                    token: Arc::new(AzureCredential::BearerToken(token_response.access_token)),
+                    expiry: Some(
+                        Instant::now()
+                            + duration.to_std().map_err(|_| Error::AzureCli {
+                                message: "az returned invalid lifetime".to_string(),
+                            })?,
+                    ),
+                })
+            }
+            Ok(az_output) => {
+                let message = String::from_utf8_lossy(&az_output.stderr);
+                Err(Error::AzureCli {
+                    message: message.into(),
+                })
+            }
+            Err(e) => match e.kind() {
+                std::io::ErrorKind::NotFound => Err(Error::AzureCli {
+                    message: "Azure Cli not installed".into(),
+                }),
+                error_kind => Err(Error::AzureCli {
+                    message: format!("io error: {error_kind:?}"),
+                }),
+            },
+        }
+    }
+}
+
+#[async_trait]
+impl CredentialProvider for AzureCliCredential {
+    type Credential = AzureCredential;
+
+    async fn get_credential(&self) -> crate::Result<Arc<Self::Credential>> {
+        Ok(self.cache.get_or_insert_with(|| self.fetch_token()).await?)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::executor::block_on;
+    use hyper::body::to_bytes;
+    use hyper::{Body, Response, StatusCode};
+    use reqwest::{Client, Method};
+    use tempfile::NamedTempFile;
+
+    use super::*;
+    use crate::azure::MicrosoftAzureBuilder;
+    use crate::client::mock_server::MockServer;
+    use crate::{ObjectStore, Path};
+
+    #[tokio::test]
+    async fn test_managed_identity() {
+        let server = MockServer::new();
+
+        std::env::set_var(MSI_SECRET_ENV_KEY, "env-secret");
+
+        let endpoint = server.url();
+        let client = Client::new();
+        let retry_config = RetryConfig::default();
+
+        // Test IMDS
+        server.push_fn(|req| {
+            assert_eq!(req.uri().path(), "/metadata/identity/oauth2/token");
+            assert!(req.uri().query().unwrap().contains("client_id=client_id"));
+            assert_eq!(req.method(), &Method::GET);
+            let t = req
+                .headers()
+                .get("x-identity-header")
+                .unwrap()
+                .to_str()
+                .unwrap();
+            assert_eq!(t, "env-secret");
+            let t = req.headers().get("metadata").unwrap().to_str().unwrap();
+            assert_eq!(t, "true");
+            Response::new(Body::from(
+                r#"
+            {
+                "access_token": "TOKEN",
+                "refresh_token": "",
+                "expires_in": "3599",
+                "expires_on": "1506484173",
+                "not_before": "1506480273",
+                "resource": "https://management.azure.com/",
+                "token_type": "Bearer"
+              }
+            "#,
+            ))
+        });
+
+        let credential = ImdsManagedIdentityProvider::new(
+            Some("client_id".into()),
+            None,
+            None,
+            Some(format!("{endpoint}/metadata/identity/oauth2/token")),
+        );
+
+        let token = credential
+            .fetch_token(&client, &retry_config)
+            .await
+            .unwrap();
+
+        assert_eq!(
+            token.token.as_ref(),
+            &AzureCredential::BearerToken("TOKEN".into())
+        );
+    }
+
+    #[tokio::test]
+    async fn test_workload_identity() {
+        let server = MockServer::new();
+        let tokenfile = NamedTempFile::new().unwrap();
+        let tenant = "tenant";
+        std::fs::write(tokenfile.path(), "federated-token").unwrap();
+
+        let endpoint = server.url();
+        let client = Client::new();
+        let retry_config = RetryConfig::default();
+
+        // Test IMDS
+        server.push_fn(move |req| {
+            assert_eq!(req.uri().path(), format!("/{tenant}/oauth2/v2.0/token"));
+            assert_eq!(req.method(), &Method::POST);
+            let body = block_on(to_bytes(req.into_body())).unwrap();
+            let body = String::from_utf8(body.to_vec()).unwrap();
+            assert!(body.contains("federated-token"));
+            Response::new(Body::from(
+                r#"
+            {
+                "access_token": "TOKEN",
+                "refresh_token": "",
+                "expires_in": 3599,
+                "expires_on": "1506484173",
+                "not_before": "1506480273",
+                "resource": "https://management.azure.com/",
+                "token_type": "Bearer"
+              }
+            "#,
+            ))
+        });
+
+        let credential = WorkloadIdentityOAuthProvider::new(
+            "client_id",
+            tokenfile.path().to_str().unwrap(),
+            tenant,
+            Some(endpoint.to_string()),
+        );
+
+        let token = credential
+            .fetch_token(&client, &retry_config)
+            .await
+            .unwrap();
+
+        assert_eq!(
+            token.token.as_ref(),
+            &AzureCredential::BearerToken("TOKEN".into())
+        );
+    }
+
+    #[tokio::test]
+    async fn test_no_credentials() {
+        let server = MockServer::new();
+
+        let endpoint = server.url();
+        let store = MicrosoftAzureBuilder::new()
+            .with_account("test")
+            .with_container_name("test")
+            .with_allow_http(true)
+            .with_bearer_token_authorization("token")
+            .with_endpoint(endpoint.to_string())
+            .with_skip_signature(true)
+            .build()
+            .unwrap();
+
+        server.push_fn(|req| {
+            assert_eq!(req.method(), &Method::GET);
+            assert!(req.headers().get("Authorization").is_none());
+            Response::builder()
+                .status(StatusCode::NOT_FOUND)
+                .body(Body::from("not found"))
+                .unwrap()
+        });
+
+        let path = Path::from("file.txt");
+        match store.get(&path).await {
+            Err(crate::Error::NotFound { .. }) => {}
+            _ => {
+                panic!("unexpected response");
+            }
+        }
+    }
+}
diff --git a/object_store/src/azure/mod.rs b/object_store/src/azure/mod.rs
new file mode 100644
index 000000000000..712b7a36c56a
--- /dev/null
+++ b/object_store/src/azure/mod.rs
@@ -0,0 +1,336 @@
+// 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.
+
+//! An object store implementation for Azure blob storage
+//!
+//! ## Streaming uploads
+//!
+//! [ObjectStore::put_multipart] will upload data in blocks and write a blob from those
+//! blocks. Data is buffered internally to make blocks of at least 5MB and blocks
+//! are uploaded concurrently.
+//!
+//! [ObjectStore::abort_multipart] is a no-op, since Azure Blob Store doesn't provide
+//! a way to drop old blocks. Instead unused blocks are automatically cleaned up
+//! after 7 days.
+use crate::{
+    multipart::{MultiPartStore, PartId, PutPart, WriteMultiPart},
+    path::Path,
+    signer::Signer,
+    GetOptions, GetResult, ListResult, MultipartId, ObjectMeta, ObjectStore, PutOptions, PutResult,
+    Result,
+};
+use async_trait::async_trait;
+use bytes::Bytes;
+use futures::stream::BoxStream;
+use reqwest::Method;
+use std::fmt::Debug;
+use std::sync::Arc;
+use std::time::Duration;
+use tokio::io::AsyncWrite;
+use url::Url;
+
+use crate::client::get::GetClientExt;
+use crate::client::list::ListClientExt;
+use crate::client::CredentialProvider;
+pub use credential::{authority_hosts, AzureAccessKey, AzureAuthorizer};
+
+mod builder;
+mod client;
+mod credential;
+
+/// [`CredentialProvider`] for [`MicrosoftAzure`]
+pub type AzureCredentialProvider = Arc<dyn CredentialProvider<Credential = AzureCredential>>;
+pub use builder::{AzureConfigKey, MicrosoftAzureBuilder};
+pub use credential::AzureCredential;
+
+const STORE: &str = "MicrosoftAzure";
+
+/// Interface for [Microsoft Azure Blob Storage](https://azure.microsoft.com/en-us/services/storage/blobs/).
+#[derive(Debug)]
+pub struct MicrosoftAzure {
+    client: Arc<client::AzureClient>,
+}
+
+impl MicrosoftAzure {
+    /// Returns the [`AzureCredentialProvider`] used by [`MicrosoftAzure`]
+    pub fn credentials(&self) -> &AzureCredentialProvider {
+        &self.client.config().credentials
+    }
+
+    /// Create a full URL to the resource specified by `path` with this instance's configuration.
+    fn path_url(&self, path: &Path) -> url::Url {
+        self.client.config().path_url(path)
+    }
+}
+
+impl std::fmt::Display for MicrosoftAzure {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "MicrosoftAzure {{ account: {}, container: {} }}",
+            self.client.config().account,
+            self.client.config().container
+        )
+    }
+}
+
+#[async_trait]
+impl ObjectStore for MicrosoftAzure {
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        self.client.put_blob(location, bytes, opts).await
+    }
+
+    async fn put_multipart(
+        &self,
+        location: &Path,
+    ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
+        let inner = AzureMultiPartUpload {
+            client: Arc::clone(&self.client),
+            location: location.to_owned(),
+        };
+        Ok((String::new(), Box::new(WriteMultiPart::new(inner, 8))))
+    }
+
+    async fn abort_multipart(&self, _location: &Path, _multipart_id: &MultipartId) -> Result<()> {
+        // There is no way to drop blocks that have been uploaded. Instead, they simply
+        // expire in 7 days.
+        Ok(())
+    }
+
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        self.client.get_opts(location, options).await
+    }
+
+    async fn delete(&self, location: &Path) -> Result<()> {
+        self.client.delete_request(location, &()).await
+    }
+
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        self.client.list(prefix)
+    }
+
+    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
+        self.client.list_with_delimiter(prefix).await
+    }
+
+    async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
+        self.client.copy_request(from, to, true).await
+    }
+
+    async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
+        self.client.copy_request(from, to, false).await
+    }
+}
+
+#[async_trait]
+impl Signer for MicrosoftAzure {
+    /// Create a URL containing the relevant [Service SAS] query parameters that authorize a request
+    /// via `method` to the resource at `path` valid for the duration specified in `expires_in`.
+    ///
+    /// [Service SAS]: https://learn.microsoft.com/en-us/rest/api/storageservices/create-service-sas
+    ///
+    /// # Example
+    ///
+    /// This example returns a URL that will enable a user to upload a file to
+    /// "some-folder/some-file.txt" in the next hour.
+    ///
+    /// ```
+    /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+    /// # use object_store::{azure::MicrosoftAzureBuilder, path::Path, signer::Signer};
+    /// # use reqwest::Method;
+    /// # use std::time::Duration;
+    /// #
+    /// let azure = MicrosoftAzureBuilder::new()
+    ///     .with_account("my-account")
+    ///     .with_access_key("my-access-key")
+    ///     .with_container_name("my-container")
+    ///     .build()?;
+    ///
+    /// let url = azure.signed_url(
+    ///     Method::PUT,
+    ///     &Path::from("some-folder/some-file.txt"),
+    ///     Duration::from_secs(60 * 60)
+    /// ).await?;
+    /// #     Ok(())
+    /// # }
+    /// ```
+    async fn signed_url(&self, method: Method, path: &Path, expires_in: Duration) -> Result<Url> {
+        let mut url = self.path_url(path);
+        let signer = self.client.signer(expires_in).await?;
+        signer.sign(&method, &mut url)?;
+        Ok(url)
+    }
+
+    async fn signed_urls(
+        &self,
+        method: Method,
+        paths: &[Path],
+        expires_in: Duration,
+    ) -> Result<Vec<Url>> {
+        let mut urls = Vec::with_capacity(paths.len());
+        let signer = self.client.signer(expires_in).await?;
+        for path in paths {
+            let mut url = self.path_url(path);
+            signer.sign(&method, &mut url)?;
+            urls.push(url);
+        }
+        Ok(urls)
+    }
+}
+
+/// Relevant docs: <https://azure.github.io/Storage/docs/application-and-user-data/basics/azure-blob-storage-upload-apis/>
+/// In Azure Blob Store, parts are "blocks"
+/// put_multipart_part -> PUT block
+/// complete -> PUT block list
+/// abort -> No equivalent; blocks are simply dropped after 7 days
+#[derive(Debug, Clone)]
+struct AzureMultiPartUpload {
+    client: Arc<client::AzureClient>,
+    location: Path,
+}
+
+#[async_trait]
+impl PutPart for AzureMultiPartUpload {
+    async fn put_part(&self, buf: Vec<u8>, idx: usize) -> Result<PartId> {
+        self.client.put_block(&self.location, idx, buf.into()).await
+    }
+
+    async fn complete(&self, parts: Vec<PartId>) -> Result<()> {
+        self.client.put_block_list(&self.location, parts).await?;
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl MultiPartStore for MicrosoftAzure {
+    async fn create_multipart(&self, _: &Path) -> Result<MultipartId> {
+        Ok(String::new())
+    }
+
+    async fn put_part(
+        &self,
+        path: &Path,
+        _: &MultipartId,
+        part_idx: usize,
+        data: Bytes,
+    ) -> Result<PartId> {
+        self.client.put_block(path, part_idx, data).await
+    }
+
+    async fn complete_multipart(
+        &self,
+        path: &Path,
+        _: &MultipartId,
+        parts: Vec<PartId>,
+    ) -> Result<PutResult> {
+        self.client.put_block_list(path, parts).await
+    }
+
+    async fn abort_multipart(&self, _: &Path, _: &MultipartId) -> Result<()> {
+        // There is no way to drop blocks that have been uploaded. Instead, they simply
+        // expire in 7 days.
+        Ok(())
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::tests::*;
+
+    #[tokio::test]
+    async fn azure_blob_test() {
+        crate::test_util::maybe_skip_integration!();
+        let integration = MicrosoftAzureBuilder::from_env().build().unwrap();
+
+        put_get_delete_list_opts(&integration).await;
+        get_opts(&integration).await;
+        list_uses_directories_correctly(&integration).await;
+        list_with_delimiter(&integration).await;
+        rename_and_copy(&integration).await;
+        copy_if_not_exists(&integration).await;
+        stream_get(&integration).await;
+        put_opts(&integration, true).await;
+        multipart(&integration, &integration).await;
+        signing(&integration).await;
+
+        let validate = !integration.client.config().disable_tagging;
+        tagging(&integration, validate, |p| {
+            let client = Arc::clone(&integration.client);
+            async move { client.get_blob_tagging(&p).await }
+        })
+        .await
+    }
+
+    #[ignore = "Used for manual testing against a real storage account."]
+    #[tokio::test]
+    async fn test_user_delegation_key() {
+        let account = std::env::var("AZURE_ACCOUNT_NAME").unwrap();
+        let container = std::env::var("AZURE_CONTAINER_NAME").unwrap();
+        let client_id = std::env::var("AZURE_CLIENT_ID").unwrap();
+        let client_secret = std::env::var("AZURE_CLIENT_SECRET").unwrap();
+        let tenant_id = std::env::var("AZURE_TENANT_ID").unwrap();
+        let integration = MicrosoftAzureBuilder::new()
+            .with_account(account)
+            .with_container_name(container)
+            .with_client_id(client_id)
+            .with_client_secret(client_secret)
+            .with_tenant_id(&tenant_id)
+            .build()
+            .unwrap();
+
+        let data = Bytes::from("hello world");
+        let path = Path::from("file.txt");
+        integration.put(&path, data.clone()).await.unwrap();
+
+        let signed = integration
+            .signed_url(Method::GET, &path, Duration::from_secs(60))
+            .await
+            .unwrap();
+
+        let resp = reqwest::get(signed).await.unwrap();
+        let loaded = resp.bytes().await.unwrap();
+
+        assert_eq!(data, loaded);
+    }
+
+    #[test]
+    fn azure_test_config_get_value() {
+        let azure_client_id = "object_store:fake_access_key_id".to_string();
+        let azure_storage_account_name = "object_store:fake_secret_key".to_string();
+        let azure_storage_token = "object_store:fake_default_region".to_string();
+        let builder = MicrosoftAzureBuilder::new()
+            .with_config(AzureConfigKey::ClientId, &azure_client_id)
+            .with_config(AzureConfigKey::AccountName, &azure_storage_account_name)
+            .with_config(AzureConfigKey::Token, &azure_storage_token);
+
+        assert_eq!(
+            builder.get_config_value(&AzureConfigKey::ClientId).unwrap(),
+            azure_client_id
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&AzureConfigKey::AccountName)
+                .unwrap(),
+            azure_storage_account_name
+        );
+        assert_eq!(
+            builder.get_config_value(&AzureConfigKey::Token).unwrap(),
+            azure_storage_token
+        );
+    }
+}
diff --git a/object_store/src/buffered.rs b/object_store/src/buffered.rs
new file mode 100644
index 000000000000..fdefe599f79e
--- /dev/null
+++ b/object_store/src/buffered.rs
@@ -0,0 +1,462 @@
+// 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.
+
+//! Utilities for performing tokio-style buffered IO
+
+use crate::path::Path;
+use crate::{MultipartId, ObjectMeta, ObjectStore};
+use bytes::Bytes;
+use futures::future::{BoxFuture, FutureExt};
+use futures::ready;
+use std::cmp::Ordering;
+use std::io::{Error, ErrorKind, SeekFrom};
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+use tokio::io::{AsyncBufRead, AsyncRead, AsyncSeek, AsyncWrite, AsyncWriteExt, ReadBuf};
+
+/// The default buffer size used by [`BufReader`]
+pub const DEFAULT_BUFFER_SIZE: usize = 1024 * 1024;
+
+/// An async-buffered reader compatible with the tokio IO traits
+///
+/// Internally this maintains a buffer of the requested size, and uses [`ObjectStore::get_range`]
+/// to populate its internal buffer once depleted. This buffer is cleared on seek.
+///
+/// Whilst simple, this interface will typically be outperformed by the native [`ObjectStore`]
+/// methods that better map to the network APIs. This is because most object stores have
+/// very [high first-byte latencies], on the order of 100-200ms, and so avoiding unnecessary
+/// round-trips is critical to throughput.
+///
+/// Systems looking to sequentially scan a file should instead consider using [`ObjectStore::get`],
+/// or [`ObjectStore::get_opts`], or [`ObjectStore::get_range`] to read a particular range.
+///
+/// Systems looking to read multiple ranges of a file should instead consider using
+/// [`ObjectStore::get_ranges`], which will optimise the vectored IO.
+///
+/// [high first-byte latencies]: https://docs.aws.amazon.com/AmazonS3/latest/userguide/optimizing-performance.html
+pub struct BufReader {
+    /// The object store to fetch data from
+    store: Arc<dyn ObjectStore>,
+    /// The size of the object
+    size: u64,
+    /// The path to the object
+    path: Path,
+    /// The current position in the object
+    cursor: u64,
+    /// The number of bytes to read in a single request
+    capacity: usize,
+    /// The buffered data if any
+    buffer: Buffer,
+}
+
+impl std::fmt::Debug for BufReader {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BufReader")
+            .field("path", &self.path)
+            .field("size", &self.size)
+            .field("capacity", &self.capacity)
+            .finish()
+    }
+}
+
+enum Buffer {
+    Empty,
+    Pending(BoxFuture<'static, std::io::Result<Bytes>>),
+    Ready(Bytes),
+}
+
+impl BufReader {
+    /// Create a new [`BufReader`] from the provided [`ObjectMeta`] and [`ObjectStore`]
+    pub fn new(store: Arc<dyn ObjectStore>, meta: &ObjectMeta) -> Self {
+        Self::with_capacity(store, meta, DEFAULT_BUFFER_SIZE)
+    }
+
+    /// Create a new [`BufReader`] from the provided [`ObjectMeta`], [`ObjectStore`], and `capacity`
+    pub fn with_capacity(store: Arc<dyn ObjectStore>, meta: &ObjectMeta, capacity: usize) -> Self {
+        Self {
+            path: meta.location.clone(),
+            size: meta.size as _,
+            store,
+            capacity,
+            cursor: 0,
+            buffer: Buffer::Empty,
+        }
+    }
+
+    fn poll_fill_buf_impl(
+        &mut self,
+        cx: &mut Context<'_>,
+        amnt: usize,
+    ) -> Poll<std::io::Result<&[u8]>> {
+        let buf = &mut self.buffer;
+        loop {
+            match buf {
+                Buffer::Empty => {
+                    let store = Arc::clone(&self.store);
+                    let path = self.path.clone();
+                    let start = self.cursor.min(self.size) as _;
+                    let end = self.cursor.saturating_add(amnt as u64).min(self.size) as _;
+
+                    if start == end {
+                        return Poll::Ready(Ok(&[]));
+                    }
+
+                    *buf = Buffer::Pending(Box::pin(async move {
+                        Ok(store.get_range(&path, start..end).await?)
+                    }))
+                }
+                Buffer::Pending(fut) => match ready!(fut.poll_unpin(cx)) {
+                    Ok(b) => *buf = Buffer::Ready(b),
+                    Err(e) => return Poll::Ready(Err(e)),
+                },
+                Buffer::Ready(r) => return Poll::Ready(Ok(r)),
+            }
+        }
+    }
+}
+
+impl AsyncSeek for BufReader {
+    fn start_seek(mut self: Pin<&mut Self>, position: SeekFrom) -> std::io::Result<()> {
+        self.cursor = match position {
+            SeekFrom::Start(offset) => offset,
+            SeekFrom::End(offset) => checked_add_signed(self.size, offset).ok_or_else(|| {
+                Error::new(
+                    ErrorKind::InvalidInput,
+                    format!(
+                        "Seeking {offset} from end of {} byte file would result in overflow",
+                        self.size
+                    ),
+                )
+            })?,
+            SeekFrom::Current(offset) => {
+                checked_add_signed(self.cursor, offset).ok_or_else(|| {
+                    Error::new(
+                        ErrorKind::InvalidInput,
+                        format!(
+                            "Seeking {offset} from current offset of {} would result in overflow",
+                            self.cursor
+                        ),
+                    )
+                })?
+            }
+        };
+        self.buffer = Buffer::Empty;
+        Ok(())
+    }
+
+    fn poll_complete(self: Pin<&mut Self>, _cx: &mut Context<'_>) -> Poll<std::io::Result<u64>> {
+        Poll::Ready(Ok(self.cursor))
+    }
+}
+
+impl AsyncRead for BufReader {
+    fn poll_read(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        out: &mut ReadBuf<'_>,
+    ) -> Poll<std::io::Result<()>> {
+        // Read the maximum of the internal buffer and `out`
+        let to_read = out.remaining().max(self.capacity);
+        let r = match ready!(self.poll_fill_buf_impl(cx, to_read)) {
+            Ok(buf) => {
+                let to_consume = out.remaining().min(buf.len());
+                out.put_slice(&buf[..to_consume]);
+                self.consume(to_consume);
+                Ok(())
+            }
+            Err(e) => Err(e),
+        };
+        Poll::Ready(r)
+    }
+}
+
+impl AsyncBufRead for BufReader {
+    fn poll_fill_buf(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<std::io::Result<&[u8]>> {
+        let capacity = self.capacity;
+        self.get_mut().poll_fill_buf_impl(cx, capacity)
+    }
+
+    fn consume(mut self: Pin<&mut Self>, amt: usize) {
+        match &mut self.buffer {
+            Buffer::Empty => assert_eq!(amt, 0, "cannot consume from empty buffer"),
+            Buffer::Ready(b) => match b.len().cmp(&amt) {
+                Ordering::Less => panic!("{amt} exceeds buffer sized of {}", b.len()),
+                Ordering::Greater => *b = b.slice(amt..),
+                Ordering::Equal => self.buffer = Buffer::Empty,
+            },
+            Buffer::Pending(_) => panic!("cannot consume from pending buffer"),
+        }
+        self.cursor += amt as u64;
+    }
+}
+
+/// An async buffered writer compatible with the tokio IO traits
+///
+/// Up to `capacity` bytes will be buffered in memory, and flushed on shutdown
+/// using [`ObjectStore::put`]. If `capacity` is exceeded, data will instead be
+/// streamed using [`ObjectStore::put_multipart`]
+pub struct BufWriter {
+    capacity: usize,
+    state: BufWriterState,
+    multipart_id: Option<MultipartId>,
+    store: Arc<dyn ObjectStore>,
+}
+
+impl std::fmt::Debug for BufWriter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("BufWriter")
+            .field("capacity", &self.capacity)
+            .field("multipart_id", &self.multipart_id)
+            .finish()
+    }
+}
+
+type MultipartResult = (MultipartId, Box<dyn AsyncWrite + Send + Unpin>);
+
+enum BufWriterState {
+    /// Buffer up to capacity bytes
+    Buffer(Path, Vec<u8>),
+    /// [`ObjectStore::put_multipart`]
+    Prepare(BoxFuture<'static, std::io::Result<MultipartResult>>),
+    /// Write to a multipart upload
+    Write(Box<dyn AsyncWrite + Send + Unpin>),
+    /// [`ObjectStore::put`]
+    Put(BoxFuture<'static, std::io::Result<()>>),
+}
+
+impl BufWriter {
+    /// Create a new [`BufWriter`] from the provided [`ObjectStore`] and [`Path`]
+    pub fn new(store: Arc<dyn ObjectStore>, path: Path) -> Self {
+        Self::with_capacity(store, path, 10 * 1024 * 1024)
+    }
+
+    /// Create a new [`BufWriter`] from the provided [`ObjectStore`], [`Path`] and `capacity`
+    pub fn with_capacity(store: Arc<dyn ObjectStore>, path: Path, capacity: usize) -> Self {
+        Self {
+            capacity,
+            store,
+            state: BufWriterState::Buffer(path, Vec::new()),
+            multipart_id: None,
+        }
+    }
+
+    /// Returns the [`MultipartId`] if multipart upload
+    pub fn multipart_id(&self) -> Option<&MultipartId> {
+        self.multipart_id.as_ref()
+    }
+}
+
+impl AsyncWrite for BufWriter {
+    fn poll_write(
+        mut self: Pin<&mut Self>,
+        cx: &mut Context<'_>,
+        buf: &[u8],
+    ) -> Poll<Result<usize, Error>> {
+        let cap = self.capacity;
+        loop {
+            return match &mut self.state {
+                BufWriterState::Write(write) => Pin::new(write).poll_write(cx, buf),
+                BufWriterState::Put(_) => panic!("Already shut down"),
+                BufWriterState::Prepare(f) => {
+                    let (id, w) = ready!(f.poll_unpin(cx)?);
+                    self.state = BufWriterState::Write(w);
+                    self.multipart_id = Some(id);
+                    continue;
+                }
+                BufWriterState::Buffer(path, b) => {
+                    if b.len().saturating_add(buf.len()) >= cap {
+                        let buffer = std::mem::take(b);
+                        let path = std::mem::take(path);
+                        let store = Arc::clone(&self.store);
+                        self.state = BufWriterState::Prepare(Box::pin(async move {
+                            let (id, mut writer) = store.put_multipart(&path).await?;
+                            writer.write_all(&buffer).await?;
+                            Ok((id, writer))
+                        }));
+                        continue;
+                    }
+                    b.extend_from_slice(buf);
+                    Poll::Ready(Ok(buf.len()))
+                }
+            };
+        }
+    }
+
+    fn poll_flush(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
+        loop {
+            return match &mut self.state {
+                BufWriterState::Buffer(_, _) => Poll::Ready(Ok(())),
+                BufWriterState::Write(write) => Pin::new(write).poll_flush(cx),
+                BufWriterState::Put(_) => panic!("Already shut down"),
+                BufWriterState::Prepare(f) => {
+                    let (id, w) = ready!(f.poll_unpin(cx)?);
+                    self.state = BufWriterState::Write(w);
+                    self.multipart_id = Some(id);
+                    continue;
+                }
+            };
+        }
+    }
+
+    fn poll_shutdown(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Result<(), Error>> {
+        loop {
+            match &mut self.state {
+                BufWriterState::Prepare(f) => {
+                    let (id, w) = ready!(f.poll_unpin(cx)?);
+                    self.state = BufWriterState::Write(w);
+                    self.multipart_id = Some(id);
+                }
+                BufWriterState::Buffer(p, b) => {
+                    let buf = std::mem::take(b);
+                    let path = std::mem::take(p);
+                    let store = Arc::clone(&self.store);
+                    self.state = BufWriterState::Put(Box::pin(async move {
+                        store.put(&path, buf.into()).await?;
+                        Ok(())
+                    }));
+                }
+                BufWriterState::Put(f) => return f.poll_unpin(cx),
+                BufWriterState::Write(w) => return Pin::new(w).poll_shutdown(cx),
+            }
+        }
+    }
+}
+
+/// Port of standardised function as requires Rust 1.66
+///
+/// <https://github.com/rust-lang/rust/pull/87601/files#diff-b9390ee807a1dae3c3128dce36df56748ad8d23c6e361c0ebba4d744bf6efdb9R1533>
+#[inline]
+fn checked_add_signed(a: u64, rhs: i64) -> Option<u64> {
+    let (res, overflowed) = a.overflowing_add(rhs as _);
+    let overflow = overflowed ^ (rhs < 0);
+    (!overflow).then_some(res)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::memory::InMemory;
+    use crate::path::Path;
+    use tokio::io::{AsyncBufReadExt, AsyncReadExt, AsyncSeekExt};
+
+    #[tokio::test]
+    async fn test_buf_reader() {
+        let store = Arc::new(InMemory::new()) as Arc<dyn ObjectStore>;
+
+        let existent = Path::from("exists.txt");
+        const BYTES: usize = 4096;
+
+        let data: Bytes = b"12345678".iter().cycle().copied().take(BYTES).collect();
+        store.put(&existent, data.clone()).await.unwrap();
+
+        let meta = store.head(&existent).await.unwrap();
+
+        let mut reader = BufReader::new(Arc::clone(&store), &meta);
+        let mut out = Vec::with_capacity(BYTES);
+        let read = reader.read_to_end(&mut out).await.unwrap();
+
+        assert_eq!(read, BYTES);
+        assert_eq!(&out, &data);
+
+        let err = reader.seek(SeekFrom::Current(i64::MIN)).await.unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Seeking -9223372036854775808 from current offset of 4096 would result in overflow"
+        );
+
+        reader.rewind().await.unwrap();
+
+        let err = reader.seek(SeekFrom::Current(-1)).await.unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Seeking -1 from current offset of 0 would result in overflow"
+        );
+
+        // Seeking beyond the bounds of the file is permitted but should return no data
+        reader.seek(SeekFrom::Start(u64::MAX)).await.unwrap();
+        let buf = reader.fill_buf().await.unwrap();
+        assert!(buf.is_empty());
+
+        let err = reader.seek(SeekFrom::Current(1)).await.unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Seeking 1 from current offset of 18446744073709551615 would result in overflow"
+        );
+
+        for capacity in [200, 1024, 4096, DEFAULT_BUFFER_SIZE] {
+            let store = Arc::clone(&store);
+            let mut reader = BufReader::with_capacity(store, &meta, capacity);
+
+            let mut bytes_read = 0;
+            loop {
+                let buf = reader.fill_buf().await.unwrap();
+                if buf.is_empty() {
+                    assert_eq!(bytes_read, BYTES);
+                    break;
+                }
+                assert!(buf.starts_with(b"12345678"));
+                bytes_read += 8;
+                reader.consume(8);
+            }
+
+            let mut buf = Vec::with_capacity(76);
+            reader.seek(SeekFrom::Current(-76)).await.unwrap();
+            reader.read_to_end(&mut buf).await.unwrap();
+            assert_eq!(&buf, &data[BYTES - 76..]);
+
+            reader.rewind().await.unwrap();
+            let buffer = reader.fill_buf().await.unwrap();
+            assert_eq!(buffer, &data[..capacity.min(BYTES)]);
+
+            reader.seek(SeekFrom::Start(325)).await.unwrap();
+            let buffer = reader.fill_buf().await.unwrap();
+            assert_eq!(buffer, &data[325..(325 + capacity).min(BYTES)]);
+
+            reader.seek(SeekFrom::End(0)).await.unwrap();
+            let buffer = reader.fill_buf().await.unwrap();
+            assert!(buffer.is_empty());
+        }
+    }
+
+    #[tokio::test]
+    async fn test_buf_writer() {
+        let store = Arc::new(InMemory::new()) as Arc<dyn ObjectStore>;
+        let path = Path::from("file.txt");
+
+        // Test put
+        let mut writer = BufWriter::with_capacity(Arc::clone(&store), path.clone(), 30);
+        writer.write_all(&[0; 20]).await.unwrap();
+        writer.flush().await.unwrap();
+        writer.write_all(&[0; 5]).await.unwrap();
+        assert!(writer.multipart_id().is_none());
+        writer.shutdown().await.unwrap();
+        assert!(writer.multipart_id().is_none());
+        assert_eq!(store.head(&path).await.unwrap().size, 25);
+
+        // Test multipart
+        let mut writer = BufWriter::with_capacity(Arc::clone(&store), path.clone(), 30);
+        writer.write_all(&[0; 20]).await.unwrap();
+        writer.flush().await.unwrap();
+        writer.write_all(&[0; 20]).await.unwrap();
+        assert!(writer.multipart_id().is_some());
+        writer.shutdown().await.unwrap();
+        assert!(writer.multipart_id().is_some());
+
+        assert_eq!(store.head(&path).await.unwrap().size, 40);
+    }
+}
diff --git a/object_store/src/chunked.rs b/object_store/src/chunked.rs
new file mode 100644
index 000000000000..d33556f4b12e
--- /dev/null
+++ b/object_store/src/chunked.rs
@@ -0,0 +1,230 @@
+// 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.
+
+//! A [`ChunkedStore`] that can be used to test streaming behaviour
+
+use std::fmt::{Debug, Display, Formatter};
+use std::ops::Range;
+use std::sync::Arc;
+
+use async_trait::async_trait;
+use bytes::{BufMut, Bytes, BytesMut};
+use futures::stream::BoxStream;
+use futures::StreamExt;
+use tokio::io::AsyncWrite;
+
+use crate::path::Path;
+use crate::{
+    GetOptions, GetResult, GetResultPayload, ListResult, ObjectMeta, ObjectStore, PutOptions,
+    PutResult,
+};
+use crate::{MultipartId, Result};
+
+/// Wraps a [`ObjectStore`] and makes its get response return chunks
+/// in a controllable manner.
+///
+/// A `ChunkedStore` makes the memory consumption and performance of
+/// the wrapped [`ObjectStore`] worse. It is intended for use within
+/// tests, to control the chunks in the produced output streams. For
+/// example, it is used to verify the delimiting logic in
+/// newline_delimited_stream.
+#[derive(Debug)]
+pub struct ChunkedStore {
+    inner: Arc<dyn ObjectStore>,
+    chunk_size: usize,
+}
+
+impl ChunkedStore {
+    /// Creates a new [`ChunkedStore`] with the specified chunk_size
+    pub fn new(inner: Arc<dyn ObjectStore>, chunk_size: usize) -> Self {
+        Self { inner, chunk_size }
+    }
+}
+
+impl Display for ChunkedStore {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(f, "ChunkedStore({})", self.inner)
+    }
+}
+
+#[async_trait]
+impl ObjectStore for ChunkedStore {
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        self.inner.put_opts(location, bytes, opts).await
+    }
+
+    async fn put_multipart(
+        &self,
+        location: &Path,
+    ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
+        self.inner.put_multipart(location).await
+    }
+
+    async fn abort_multipart(&self, location: &Path, multipart_id: &MultipartId) -> Result<()> {
+        self.inner.abort_multipart(location, multipart_id).await
+    }
+
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        let r = self.inner.get_opts(location, options).await?;
+        let stream = match r.payload {
+            GetResultPayload::File(file, path) => {
+                crate::local::chunked_stream(file, path, r.range.clone(), self.chunk_size)
+            }
+            GetResultPayload::Stream(stream) => {
+                let buffer = BytesMut::new();
+                futures::stream::unfold(
+                    (stream, buffer, false, self.chunk_size),
+                    |(mut stream, mut buffer, mut exhausted, chunk_size)| async move {
+                        // Keep accumulating bytes until we reach capacity as long as
+                        // the stream can provide them:
+                        if exhausted {
+                            return None;
+                        }
+                        while buffer.len() < chunk_size {
+                            match stream.next().await {
+                                None => {
+                                    exhausted = true;
+                                    let slice = buffer.split_off(0).freeze();
+                                    return Some((
+                                        Ok(slice),
+                                        (stream, buffer, exhausted, chunk_size),
+                                    ));
+                                }
+                                Some(Ok(bytes)) => {
+                                    buffer.put(bytes);
+                                }
+                                Some(Err(e)) => {
+                                    return Some((
+                                        Err(crate::Error::Generic {
+                                            store: "ChunkedStore",
+                                            source: Box::new(e),
+                                        }),
+                                        (stream, buffer, exhausted, chunk_size),
+                                    ))
+                                }
+                            };
+                        }
+                        // Return the chunked values as the next value in the stream
+                        let slice = buffer.split_to(chunk_size).freeze();
+                        Some((Ok(slice), (stream, buffer, exhausted, chunk_size)))
+                    },
+                )
+                .boxed()
+            }
+        };
+        Ok(GetResult {
+            payload: GetResultPayload::Stream(stream),
+            ..r
+        })
+    }
+
+    async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes> {
+        self.inner.get_range(location, range).await
+    }
+
+    async fn head(&self, location: &Path) -> Result<ObjectMeta> {
+        self.inner.head(location).await
+    }
+
+    async fn delete(&self, location: &Path) -> Result<()> {
+        self.inner.delete(location).await
+    }
+
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        self.inner.list(prefix)
+    }
+
+    fn list_with_offset(
+        &self,
+        prefix: Option<&Path>,
+        offset: &Path,
+    ) -> BoxStream<'_, Result<ObjectMeta>> {
+        self.inner.list_with_offset(prefix, offset)
+    }
+
+    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
+        self.inner.list_with_delimiter(prefix).await
+    }
+
+    async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
+        self.inner.copy(from, to).await
+    }
+
+    async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
+        self.inner.copy_if_not_exists(from, to).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::StreamExt;
+
+    use crate::local::LocalFileSystem;
+    use crate::memory::InMemory;
+    use crate::path::Path;
+    use crate::tests::*;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn test_chunked_basic() {
+        let location = Path::parse("test").unwrap();
+        let store: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+        store
+            .put(&location, Bytes::from(vec![0; 1001]))
+            .await
+            .unwrap();
+
+        for chunk_size in [10, 20, 31] {
+            let store = ChunkedStore::new(Arc::clone(&store), chunk_size);
+            let mut s = match store.get(&location).await.unwrap().payload {
+                GetResultPayload::Stream(s) => s,
+                _ => unreachable!(),
+            };
+
+            let mut remaining = 1001;
+            while let Some(next) = s.next().await {
+                let size = next.unwrap().len();
+                let expected = remaining.min(chunk_size);
+                assert_eq!(size, expected);
+                remaining -= expected;
+            }
+            assert_eq!(remaining, 0);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_chunked() {
+        let temporary = tempfile::tempdir().unwrap();
+        let integrations: &[Arc<dyn ObjectStore>] = &[
+            Arc::new(InMemory::new()),
+            Arc::new(LocalFileSystem::new_with_prefix(temporary.path()).unwrap()),
+        ];
+
+        for integration in integrations {
+            let integration = ChunkedStore::new(Arc::clone(integration), 100);
+
+            put_get_delete_list(&integration).await;
+            get_opts(&integration).await;
+            list_uses_directories_correctly(&integration).await;
+            list_with_delimiter(&integration).await;
+            rename_and_copy(&integration).await;
+            copy_if_not_exists(&integration).await;
+            stream_get(&integration).await;
+        }
+    }
+}
diff --git a/object_store/src/client/backoff.rs b/object_store/src/client/backoff.rs
index 5a6126cc45c6..e01589102eb1 100644
--- a/object_store/src/client/backoff.rs
+++ b/object_store/src/client/backoff.rs
@@ -98,10 +98,7 @@ impl Backoff {
         };
 
         let next_backoff = self.max_backoff_secs.min(rand_backoff);
-        Duration::from_secs_f64(std::mem::replace(
-            &mut self.next_backoff_secs,
-            next_backoff,
-        ))
+        Duration::from_secs_f64(std::mem::replace(&mut self.next_backoff_secs, next_backoff))
     }
 }
 
@@ -122,8 +119,7 @@ mod tests {
             base,
         };
 
-        let assert_fuzzy_eq =
-            |a: f64, b: f64| assert!((b - a).abs() < 0.0001, "{} != {}", a, b);
+        let assert_fuzzy_eq = |a: f64, b: f64| assert!((b - a).abs() < 0.0001, "{a} != {b}");
 
         // Create a static rng that takes the minimum of the range
         let rng = Box::new(StepRng::new(0, 0));
@@ -149,8 +145,8 @@ mod tests {
         let mut value = init_backoff_secs;
         for _ in 0..20 {
             assert_fuzzy_eq(backoff.next().as_secs_f64(), value);
-            value = (init_backoff_secs + (value * base - init_backoff_secs) / 2.)
-                .min(max_backoff_secs);
+            value =
+                (init_backoff_secs + (value * base - init_backoff_secs) / 2.).min(max_backoff_secs);
         }
     }
 }
diff --git a/object_store/src/client/get.rs b/object_store/src/client/get.rs
new file mode 100644
index 000000000000..2e399e523ed4
--- /dev/null
+++ b/object_store/src/client/get.rs
@@ -0,0 +1,319 @@
+// 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.
+
+use std::ops::Range;
+
+use crate::client::header::{header_meta, HeaderConfig};
+use crate::path::Path;
+use crate::{GetOptions, GetRange, GetResult, GetResultPayload, Result};
+use async_trait::async_trait;
+use futures::{StreamExt, TryStreamExt};
+use hyper::header::CONTENT_RANGE;
+use hyper::StatusCode;
+use reqwest::header::ToStrError;
+use reqwest::Response;
+use snafu::{ensure, OptionExt, ResultExt, Snafu};
+
+/// A client that can perform a get request
+#[async_trait]
+pub trait GetClient: Send + Sync + 'static {
+    const STORE: &'static str;
+
+    /// Configure the [`HeaderConfig`] for this client
+    const HEADER_CONFIG: HeaderConfig;
+
+    async fn get_request(&self, path: &Path, options: GetOptions) -> Result<Response>;
+}
+
+/// Extension trait for [`GetClient`] that adds common retrieval functionality
+#[async_trait]
+pub trait GetClientExt {
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult>;
+}
+
+#[async_trait]
+impl<T: GetClient> GetClientExt for T {
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        let range = options.range.clone();
+        if let Some(r) = range.as_ref() {
+            r.is_valid().map_err(|e| crate::Error::Generic {
+                store: T::STORE,
+                source: Box::new(e),
+            })?;
+        }
+        let response = self.get_request(location, options).await?;
+        get_result::<T>(location, range, response).map_err(|e| crate::Error::Generic {
+            store: T::STORE,
+            source: Box::new(e),
+        })
+    }
+}
+
+struct ContentRange {
+    /// The range of the object returned
+    range: Range<usize>,
+    /// The total size of the object being requested
+    size: usize,
+}
+
+impl ContentRange {
+    /// Parse a content range of the form `bytes <range-start>-<range-end>/<size>`
+    ///
+    /// <https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Content-Range>
+    fn from_str(s: &str) -> Option<Self> {
+        let rem = s.trim().strip_prefix("bytes ")?;
+        let (range, size) = rem.split_once('/')?;
+        let size = size.parse().ok()?;
+
+        let (start_s, end_s) = range.split_once('-')?;
+
+        let start = start_s.parse().ok()?;
+        let end: usize = end_s.parse().ok()?;
+
+        Some(Self {
+            size,
+            range: start..end + 1,
+        })
+    }
+}
+
+/// A specialized `Error` for get-related errors
+#[derive(Debug, Snafu)]
+#[allow(missing_docs)]
+enum GetResultError {
+    #[snafu(context(false))]
+    Header {
+        source: crate::client::header::Error,
+    },
+
+    #[snafu(context(false))]
+    InvalidRangeRequest {
+        source: crate::util::InvalidGetRange,
+    },
+
+    #[snafu(display("Received non-partial response when range requested"))]
+    NotPartial,
+
+    #[snafu(display("Content-Range header not present in partial response"))]
+    NoContentRange,
+
+    #[snafu(display("Failed to parse value for CONTENT_RANGE header: \"{value}\""))]
+    ParseContentRange { value: String },
+
+    #[snafu(display("Content-Range header contained non UTF-8 characters"))]
+    InvalidContentRange { source: ToStrError },
+
+    #[snafu(display("Requested {expected:?}, got {actual:?}"))]
+    UnexpectedRange {
+        expected: Range<usize>,
+        actual: Range<usize>,
+    },
+}
+
+fn get_result<T: GetClient>(
+    location: &Path,
+    range: Option<GetRange>,
+    response: Response,
+) -> Result<GetResult, GetResultError> {
+    let mut meta = header_meta(location, response.headers(), T::HEADER_CONFIG)?;
+
+    // ensure that we receive the range we asked for
+    let range = if let Some(expected) = range {
+        ensure!(
+            response.status() == StatusCode::PARTIAL_CONTENT,
+            NotPartialSnafu
+        );
+        let val = response
+            .headers()
+            .get(CONTENT_RANGE)
+            .context(NoContentRangeSnafu)?;
+
+        let value = val.to_str().context(InvalidContentRangeSnafu)?;
+        let value = ContentRange::from_str(value).context(ParseContentRangeSnafu { value })?;
+        let actual = value.range;
+
+        // Update size to reflect full size of object (#5272)
+        meta.size = value.size;
+
+        let expected = expected.as_range(meta.size)?;
+
+        ensure!(
+            actual == expected,
+            UnexpectedRangeSnafu { expected, actual }
+        );
+
+        actual
+    } else {
+        0..meta.size
+    };
+
+    let stream = response
+        .bytes_stream()
+        .map_err(|source| crate::Error::Generic {
+            store: T::STORE,
+            source: Box::new(source),
+        })
+        .boxed();
+
+    Ok(GetResult {
+        range,
+        meta,
+        payload: GetResultPayload::Stream(stream),
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use hyper::http;
+    use hyper::http::header::*;
+
+    struct TestClient {}
+
+    #[async_trait]
+    impl GetClient for TestClient {
+        const STORE: &'static str = "TEST";
+
+        const HEADER_CONFIG: HeaderConfig = HeaderConfig {
+            etag_required: false,
+            last_modified_required: false,
+            version_header: None,
+        };
+
+        async fn get_request(&self, _: &Path, _: GetOptions) -> Result<Response> {
+            unimplemented!()
+        }
+    }
+
+    fn make_response(
+        object_size: usize,
+        range: Option<Range<usize>>,
+        status: StatusCode,
+        content_range: Option<&str>,
+    ) -> Response {
+        let mut builder = http::Response::builder();
+        if let Some(range) = content_range {
+            builder = builder.header(CONTENT_RANGE, range);
+        }
+
+        let body = match range {
+            Some(range) => vec![0_u8; range.end - range.start],
+            None => vec![0_u8; object_size],
+        };
+
+        builder
+            .status(status)
+            .header(CONTENT_LENGTH, object_size)
+            .body(body)
+            .unwrap()
+            .into()
+    }
+
+    #[tokio::test]
+    async fn test_get_result() {
+        let path = Path::from("test");
+
+        let resp = make_response(12, None, StatusCode::OK, None);
+        let res = get_result::<TestClient>(&path, None, resp).unwrap();
+        assert_eq!(res.meta.size, 12);
+        assert_eq!(res.range, 0..12);
+        let bytes = res.bytes().await.unwrap();
+        assert_eq!(bytes.len(), 12);
+
+        let get_range = GetRange::from(2..3);
+
+        let resp = make_response(
+            12,
+            Some(2..3),
+            StatusCode::PARTIAL_CONTENT,
+            Some("bytes 2-2/12"),
+        );
+        let res = get_result::<TestClient>(&path, Some(get_range.clone()), resp).unwrap();
+        assert_eq!(res.meta.size, 12);
+        assert_eq!(res.range, 2..3);
+        let bytes = res.bytes().await.unwrap();
+        assert_eq!(bytes.len(), 1);
+
+        let resp = make_response(12, Some(2..3), StatusCode::OK, None);
+        let err = get_result::<TestClient>(&path, Some(get_range.clone()), resp).unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Received non-partial response when range requested"
+        );
+
+        let resp = make_response(
+            12,
+            Some(2..3),
+            StatusCode::PARTIAL_CONTENT,
+            Some("bytes 2-3/12"),
+        );
+        let err = get_result::<TestClient>(&path, Some(get_range.clone()), resp).unwrap_err();
+        assert_eq!(err.to_string(), "Requested 2..3, got 2..4");
+
+        let resp = make_response(
+            12,
+            Some(2..3),
+            StatusCode::PARTIAL_CONTENT,
+            Some("bytes 2-2/*"),
+        );
+        let err = get_result::<TestClient>(&path, Some(get_range.clone()), resp).unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Failed to parse value for CONTENT_RANGE header: \"bytes 2-2/*\""
+        );
+
+        let resp = make_response(12, Some(2..3), StatusCode::PARTIAL_CONTENT, None);
+        let err = get_result::<TestClient>(&path, Some(get_range.clone()), resp).unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Content-Range header not present in partial response"
+        );
+
+        let resp = make_response(
+            2,
+            Some(2..3),
+            StatusCode::PARTIAL_CONTENT,
+            Some("bytes 2-3/2"),
+        );
+        let err = get_result::<TestClient>(&path, Some(get_range.clone()), resp).unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "InvalidRangeRequest: Wanted range starting at 2, but object was only 2 bytes long"
+        );
+
+        let resp = make_response(
+            6,
+            Some(2..6),
+            StatusCode::PARTIAL_CONTENT,
+            Some("bytes 2-5/6"),
+        );
+        let res = get_result::<TestClient>(&path, Some(GetRange::Suffix(4)), resp).unwrap();
+        assert_eq!(res.meta.size, 6);
+        assert_eq!(res.range, 2..6);
+        let bytes = res.bytes().await.unwrap();
+        assert_eq!(bytes.len(), 4);
+
+        let resp = make_response(
+            6,
+            Some(2..6),
+            StatusCode::PARTIAL_CONTENT,
+            Some("bytes 2-3/6"),
+        );
+        let err = get_result::<TestClient>(&path, Some(GetRange::Suffix(4)), resp).unwrap_err();
+        assert_eq!(err.to_string(), "Requested 2..6, got 2..4");
+    }
+}
diff --git a/object_store/src/client/header.rs b/object_store/src/client/header.rs
new file mode 100644
index 000000000000..e85bf6ba52d0
--- /dev/null
+++ b/object_store/src/client/header.rs
@@ -0,0 +1,137 @@
+// 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.
+
+//! Logic for extracting ObjectMeta from headers used by AWS, GCP and Azure
+
+use crate::path::Path;
+use crate::ObjectMeta;
+use chrono::{DateTime, TimeZone, Utc};
+use hyper::header::{CONTENT_LENGTH, ETAG, LAST_MODIFIED};
+use hyper::HeaderMap;
+use snafu::{OptionExt, ResultExt, Snafu};
+
+#[derive(Debug, Copy, Clone)]
+/// Configuration for header extraction
+pub struct HeaderConfig {
+    /// Whether to require an ETag header when extracting [`ObjectMeta`] from headers.
+    ///
+    /// Defaults to `true`
+    pub etag_required: bool,
+    /// Whether to require a Last-Modified header when extracting [`ObjectMeta`] from headers.
+    ///
+    /// Defaults to `true`
+    pub last_modified_required: bool,
+
+    /// The version header name if any
+    pub version_header: Option<&'static str>,
+}
+
+#[derive(Debug, Snafu)]
+pub enum Error {
+    #[snafu(display("ETag Header missing from response"))]
+    MissingEtag,
+
+    #[snafu(display("Received header containing non-ASCII data"))]
+    BadHeader { source: reqwest::header::ToStrError },
+
+    #[snafu(display("Last-Modified Header missing from response"))]
+    MissingLastModified,
+
+    #[snafu(display("Content-Length Header missing from response"))]
+    MissingContentLength,
+
+    #[snafu(display("Invalid last modified '{}': {}", last_modified, source))]
+    InvalidLastModified {
+        last_modified: String,
+        source: chrono::ParseError,
+    },
+
+    #[snafu(display("Invalid content length '{}': {}", content_length, source))]
+    InvalidContentLength {
+        content_length: String,
+        source: std::num::ParseIntError,
+    },
+}
+
+/// Extracts a PutResult from the provided [`HeaderMap`]
+#[cfg(any(feature = "aws", feature = "gcp", feature = "azure"))]
+pub fn get_put_result(headers: &HeaderMap, version: &str) -> Result<crate::PutResult, Error> {
+    let e_tag = Some(get_etag(headers)?);
+    let version = get_version(headers, version)?;
+    Ok(crate::PutResult { e_tag, version })
+}
+
+/// Extracts a optional version from the provided [`HeaderMap`]
+#[cfg(any(feature = "aws", feature = "gcp", feature = "azure"))]
+pub fn get_version(headers: &HeaderMap, version: &str) -> Result<Option<String>, Error> {
+    Ok(match headers.get(version) {
+        Some(x) => Some(x.to_str().context(BadHeaderSnafu)?.to_string()),
+        None => None,
+    })
+}
+
+/// Extracts an etag from the provided [`HeaderMap`]
+pub fn get_etag(headers: &HeaderMap) -> Result<String, Error> {
+    let e_tag = headers.get(ETAG).ok_or(Error::MissingEtag)?;
+    Ok(e_tag.to_str().context(BadHeaderSnafu)?.to_string())
+}
+
+/// Extracts [`ObjectMeta`] from the provided [`HeaderMap`]
+pub fn header_meta(
+    location: &Path,
+    headers: &HeaderMap,
+    cfg: HeaderConfig,
+) -> Result<ObjectMeta, Error> {
+    let last_modified = match headers.get(LAST_MODIFIED) {
+        Some(last_modified) => {
+            let last_modified = last_modified.to_str().context(BadHeaderSnafu)?;
+            DateTime::parse_from_rfc2822(last_modified)
+                .context(InvalidLastModifiedSnafu { last_modified })?
+                .with_timezone(&Utc)
+        }
+        None if cfg.last_modified_required => return Err(Error::MissingLastModified),
+        None => Utc.timestamp_nanos(0),
+    };
+
+    let e_tag = match get_etag(headers) {
+        Ok(e_tag) => Some(e_tag),
+        Err(Error::MissingEtag) if !cfg.etag_required => None,
+        Err(e) => return Err(e),
+    };
+
+    let content_length = headers
+        .get(CONTENT_LENGTH)
+        .context(MissingContentLengthSnafu)?;
+
+    let content_length = content_length.to_str().context(BadHeaderSnafu)?;
+    let size = content_length
+        .parse()
+        .context(InvalidContentLengthSnafu { content_length })?;
+
+    let version = match cfg.version_header.and_then(|h| headers.get(h)) {
+        Some(v) => Some(v.to_str().context(BadHeaderSnafu)?.to_string()),
+        None => None,
+    };
+
+    Ok(ObjectMeta {
+        location: location.clone(),
+        last_modified,
+        version,
+        size,
+        e_tag,
+    })
+}
diff --git a/object_store/src/client/list.rs b/object_store/src/client/list.rs
new file mode 100644
index 000000000000..371894dfeb71
--- /dev/null
+++ b/object_store/src/client/list.rs
@@ -0,0 +1,125 @@
+// 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.
+
+use crate::client::pagination::stream_paginated;
+use crate::path::Path;
+use crate::Result;
+use crate::{ListResult, ObjectMeta};
+use async_trait::async_trait;
+use futures::stream::BoxStream;
+use futures::{StreamExt, TryStreamExt};
+use std::collections::BTreeSet;
+
+/// A client that can perform paginated list requests
+#[async_trait]
+pub trait ListClient: Send + Sync + 'static {
+    async fn list_request(
+        &self,
+        prefix: Option<&str>,
+        delimiter: bool,
+        token: Option<&str>,
+        offset: Option<&str>,
+    ) -> Result<(ListResult, Option<String>)>;
+}
+
+/// Extension trait for [`ListClient`] that adds common listing functionality
+#[async_trait]
+pub trait ListClientExt {
+    fn list_paginated(
+        &self,
+        prefix: Option<&Path>,
+        delimiter: bool,
+        offset: Option<&Path>,
+    ) -> BoxStream<'_, Result<ListResult>>;
+
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>>;
+
+    fn list_with_offset(
+        &self,
+        prefix: Option<&Path>,
+        offset: &Path,
+    ) -> BoxStream<'_, Result<ObjectMeta>>;
+
+    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult>;
+}
+
+#[async_trait]
+impl<T: ListClient> ListClientExt for T {
+    fn list_paginated(
+        &self,
+        prefix: Option<&Path>,
+        delimiter: bool,
+        offset: Option<&Path>,
+    ) -> BoxStream<'_, Result<ListResult>> {
+        let offset = offset.map(|x| x.to_string());
+        let prefix = prefix
+            .filter(|x| !x.as_ref().is_empty())
+            .map(|p| format!("{}{}", p.as_ref(), crate::path::DELIMITER));
+
+        stream_paginated(
+            (prefix, offset),
+            move |(prefix, offset), token| async move {
+                let (r, next_token) = self
+                    .list_request(
+                        prefix.as_deref(),
+                        delimiter,
+                        token.as_deref(),
+                        offset.as_deref(),
+                    )
+                    .await?;
+                Ok((r, (prefix, offset), next_token))
+            },
+        )
+        .boxed()
+    }
+
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        self.list_paginated(prefix, false, None)
+            .map_ok(|r| futures::stream::iter(r.objects.into_iter().map(Ok)))
+            .try_flatten()
+            .boxed()
+    }
+
+    fn list_with_offset(
+        &self,
+        prefix: Option<&Path>,
+        offset: &Path,
+    ) -> BoxStream<'_, Result<ObjectMeta>> {
+        self.list_paginated(prefix, false, Some(offset))
+            .map_ok(|r| futures::stream::iter(r.objects.into_iter().map(Ok)))
+            .try_flatten()
+            .boxed()
+    }
+
+    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
+        let mut stream = self.list_paginated(prefix, true, None);
+
+        let mut common_prefixes = BTreeSet::new();
+        let mut objects = Vec::new();
+
+        while let Some(result) = stream.next().await {
+            let response = result?;
+            common_prefixes.extend(response.common_prefixes.into_iter());
+            objects.extend(response.objects.into_iter());
+        }
+
+        Ok(ListResult {
+            common_prefixes: common_prefixes.into_iter().collect(),
+            objects,
+        })
+    }
+}
diff --git a/object_store/src/client/mock_server.rs b/object_store/src/client/mock_server.rs
new file mode 100644
index 000000000000..70b856186d72
--- /dev/null
+++ b/object_store/src/client/mock_server.rs
@@ -0,0 +1,117 @@
+// 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.
+
+use futures::future::BoxFuture;
+use futures::FutureExt;
+use hyper::service::{make_service_fn, service_fn};
+use hyper::{Body, Request, Response, Server};
+use parking_lot::Mutex;
+use std::collections::VecDeque;
+use std::convert::Infallible;
+use std::future::Future;
+use std::net::SocketAddr;
+use std::sync::Arc;
+use tokio::sync::oneshot;
+use tokio::task::JoinHandle;
+
+pub type ResponseFn = Box<dyn FnOnce(Request<Body>) -> BoxFuture<'static, Response<Body>> + Send>;
+
+/// A mock server
+pub struct MockServer {
+    responses: Arc<Mutex<VecDeque<ResponseFn>>>,
+    shutdown: oneshot::Sender<()>,
+    handle: JoinHandle<()>,
+    url: String,
+}
+
+impl MockServer {
+    pub fn new() -> Self {
+        let responses: Arc<Mutex<VecDeque<ResponseFn>>> =
+            Arc::new(Mutex::new(VecDeque::with_capacity(10)));
+
+        let r = Arc::clone(&responses);
+        let make_service = make_service_fn(move |_conn| {
+            let r = Arc::clone(&r);
+            async move {
+                Ok::<_, Infallible>(service_fn(move |req| {
+                    let r = Arc::clone(&r);
+                    let next = r.lock().pop_front();
+                    async move {
+                        Ok::<_, Infallible>(match next {
+                            Some(r) => r(req).await,
+                            None => Response::new(Body::from("Hello World")),
+                        })
+                    }
+                }))
+            }
+        });
+
+        let (shutdown, rx) = oneshot::channel::<()>();
+        let server = Server::bind(&SocketAddr::from(([127, 0, 0, 1], 0))).serve(make_service);
+
+        let url = format!("http://{}", server.local_addr());
+
+        let handle = tokio::spawn(async move {
+            server
+                .with_graceful_shutdown(async {
+                    rx.await.ok();
+                })
+                .await
+                .unwrap()
+        });
+
+        Self {
+            responses,
+            shutdown,
+            handle,
+            url,
+        }
+    }
+
+    /// The url of the mock server
+    pub fn url(&self) -> &str {
+        &self.url
+    }
+
+    /// Add a response
+    pub fn push(&self, response: Response<Body>) {
+        self.push_fn(|_| response)
+    }
+
+    /// Add a response function
+    pub fn push_fn<F>(&self, f: F)
+    where
+        F: FnOnce(Request<Body>) -> Response<Body> + Send + 'static,
+    {
+        let f = Box::new(|req| async move { f(req) }.boxed());
+        self.responses.lock().push_back(f)
+    }
+
+    pub fn push_async_fn<F, Fut>(&self, f: F)
+    where
+        F: FnOnce(Request<Body>) -> Fut + Send + 'static,
+        Fut: Future<Output = Response<Body>> + Send + 'static,
+    {
+        self.responses.lock().push_back(Box::new(|r| f(r).boxed()))
+    }
+
+    /// Shutdown the mock server
+    pub async fn shutdown(self) {
+        let _ = self.shutdown.send(());
+        self.handle.await.unwrap()
+    }
+}
diff --git a/object_store/src/client/mod.rs b/object_store/src/client/mod.rs
index 1166ebe7a525..252e9fdcadf5 100644
--- a/object_store/src/client/mod.rs
+++ b/object_store/src/client/mod.rs
@@ -18,6 +18,838 @@
 //! Generic utilities reqwest based ObjectStore implementations
 
 pub mod backoff;
-pub mod oauth;
+
+#[cfg(test)]
+pub mod mock_server;
+
 pub mod retry;
+
+#[cfg(any(feature = "aws", feature = "gcp", feature = "azure"))]
+pub mod pagination;
+
+pub mod get;
+
+#[cfg(any(feature = "aws", feature = "gcp", feature = "azure"))]
+pub mod list;
+
+#[cfg(any(feature = "aws", feature = "gcp", feature = "azure"))]
 pub mod token;
+
+pub mod header;
+
+#[cfg(any(feature = "aws", feature = "gcp"))]
+pub mod s3;
+
+use async_trait::async_trait;
+use std::collections::HashMap;
+use std::str::FromStr;
+use std::sync::Arc;
+use std::time::Duration;
+
+use reqwest::header::{HeaderMap, HeaderValue};
+use reqwest::{Client, ClientBuilder, NoProxy, Proxy, RequestBuilder};
+use serde::{Deserialize, Serialize};
+
+use crate::config::{fmt_duration, ConfigValue};
+use crate::path::Path;
+use crate::{GetOptions, Result};
+
+fn map_client_error(e: reqwest::Error) -> super::Error {
+    super::Error::Generic {
+        store: "HTTP client",
+        source: Box::new(e),
+    }
+}
+
+static DEFAULT_USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
+
+/// Configuration keys for [`ClientOptions`]
+#[derive(PartialEq, Eq, Hash, Clone, Debug, Copy, Deserialize, Serialize)]
+#[non_exhaustive]
+pub enum ClientConfigKey {
+    /// Allow non-TLS, i.e. non-HTTPS connections
+    AllowHttp,
+    /// Skip certificate validation on https connections.
+    ///
+    /// # Warning
+    ///
+    /// You should think very carefully before using this method. If
+    /// invalid certificates are trusted, *any* certificate for *any* site
+    /// will be trusted for use. This includes expired certificates. This
+    /// introduces significant vulnerabilities, and should only be used
+    /// as a last resort or for testing
+    AllowInvalidCertificates,
+    /// Timeout for only the connect phase of a Client
+    ConnectTimeout,
+    /// default CONTENT_TYPE for uploads
+    DefaultContentType,
+    /// Only use http1 connections
+    Http1Only,
+    /// Interval for HTTP2 Ping frames should be sent to keep a connection alive.
+    Http2KeepAliveInterval,
+    /// Timeout for receiving an acknowledgement of the keep-alive ping.
+    Http2KeepAliveTimeout,
+    /// Enable HTTP2 keep alive pings for idle connections
+    Http2KeepAliveWhileIdle,
+    /// Only use http2 connections
+    Http2Only,
+    /// The pool max idle timeout
+    ///
+    /// This is the length of time an idle connection will be kept alive
+    PoolIdleTimeout,
+    /// maximum number of idle connections per host
+    PoolMaxIdlePerHost,
+    /// HTTP proxy to use for requests
+    ProxyUrl,
+    /// PEM-formatted CA certificate for proxy connections
+    ProxyCaCertificate,
+    /// List of hosts that bypass proxy
+    ProxyExcludes,
+    /// Request timeout
+    ///
+    /// The timeout is applied from when the request starts connecting until the
+    /// response body has finished
+    Timeout,
+    /// User-Agent header to be used by this client
+    UserAgent,
+}
+
+impl AsRef<str> for ClientConfigKey {
+    fn as_ref(&self) -> &str {
+        match self {
+            Self::AllowHttp => "allow_http",
+            Self::AllowInvalidCertificates => "allow_invalid_certificates",
+            Self::ConnectTimeout => "connect_timeout",
+            Self::DefaultContentType => "default_content_type",
+            Self::Http1Only => "http1_only",
+            Self::Http2Only => "http2_only",
+            Self::Http2KeepAliveInterval => "http2_keep_alive_interval",
+            Self::Http2KeepAliveTimeout => "http2_keep_alive_timeout",
+            Self::Http2KeepAliveWhileIdle => "http2_keep_alive_while_idle",
+            Self::PoolIdleTimeout => "pool_idle_timeout",
+            Self::PoolMaxIdlePerHost => "pool_max_idle_per_host",
+            Self::ProxyUrl => "proxy_url",
+            Self::ProxyCaCertificate => "proxy_ca_certificate",
+            Self::ProxyExcludes => "proxy_excludes",
+            Self::Timeout => "timeout",
+            Self::UserAgent => "user_agent",
+        }
+    }
+}
+
+impl FromStr for ClientConfigKey {
+    type Err = super::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "allow_http" => Ok(Self::AllowHttp),
+            "allow_invalid_certificates" => Ok(Self::AllowInvalidCertificates),
+            "connect_timeout" => Ok(Self::ConnectTimeout),
+            "default_content_type" => Ok(Self::DefaultContentType),
+            "http1_only" => Ok(Self::Http1Only),
+            "http2_only" => Ok(Self::Http2Only),
+            "http2_keep_alive_interval" => Ok(Self::Http2KeepAliveInterval),
+            "http2_keep_alive_timeout" => Ok(Self::Http2KeepAliveTimeout),
+            "http2_keep_alive_while_idle" => Ok(Self::Http2KeepAliveWhileIdle),
+            "pool_idle_timeout" => Ok(Self::PoolIdleTimeout),
+            "pool_max_idle_per_host" => Ok(Self::PoolMaxIdlePerHost),
+            "proxy_url" => Ok(Self::ProxyUrl),
+            "timeout" => Ok(Self::Timeout),
+            "user_agent" => Ok(Self::UserAgent),
+            _ => Err(super::Error::UnknownConfigurationKey {
+                store: "HTTP",
+                key: s.into(),
+            }),
+        }
+    }
+}
+
+/// HTTP client configuration for remote object stores
+#[derive(Debug, Clone)]
+pub struct ClientOptions {
+    user_agent: Option<ConfigValue<HeaderValue>>,
+    content_type_map: HashMap<String, String>,
+    default_content_type: Option<String>,
+    default_headers: Option<HeaderMap>,
+    proxy_url: Option<String>,
+    proxy_ca_certificate: Option<String>,
+    proxy_excludes: Option<String>,
+    allow_http: ConfigValue<bool>,
+    allow_insecure: ConfigValue<bool>,
+    timeout: Option<ConfigValue<Duration>>,
+    connect_timeout: Option<ConfigValue<Duration>>,
+    pool_idle_timeout: Option<ConfigValue<Duration>>,
+    pool_max_idle_per_host: Option<ConfigValue<usize>>,
+    http2_keep_alive_interval: Option<ConfigValue<Duration>>,
+    http2_keep_alive_timeout: Option<ConfigValue<Duration>>,
+    http2_keep_alive_while_idle: ConfigValue<bool>,
+    http1_only: ConfigValue<bool>,
+    http2_only: ConfigValue<bool>,
+}
+
+impl Default for ClientOptions {
+    fn default() -> Self {
+        // Defaults based on
+        // <https://docs.aws.amazon.com/sdkref/latest/guide/feature-smart-config-defaults.html>
+        // <https://docs.aws.amazon.com/whitepapers/latest/s3-optimizing-performance-best-practices/timeouts-and-retries-for-latency-sensitive-applications.html>
+        // Which recommend a connection timeout of 3.1s and a request timeout of 2s
+        //
+        // As object store requests may involve the transfer of non-trivial volumes of data
+        // we opt for a slightly higher default timeout of 30 seconds
+        Self {
+            user_agent: None,
+            content_type_map: Default::default(),
+            default_content_type: None,
+            default_headers: None,
+            proxy_url: None,
+            proxy_ca_certificate: None,
+            proxy_excludes: None,
+            allow_http: Default::default(),
+            allow_insecure: Default::default(),
+            timeout: Some(Duration::from_secs(30).into()),
+            connect_timeout: Some(Duration::from_secs(5).into()),
+            pool_idle_timeout: None,
+            pool_max_idle_per_host: None,
+            http2_keep_alive_interval: None,
+            http2_keep_alive_timeout: None,
+            http2_keep_alive_while_idle: Default::default(),
+            // HTTP2 is known to be significantly slower than HTTP1, so we default
+            // to HTTP1 for now.
+            // https://github.com/apache/arrow-rs/issues/5194
+            http1_only: true.into(),
+            http2_only: Default::default(),
+        }
+    }
+}
+
+impl ClientOptions {
+    /// Create a new [`ClientOptions`] with default values
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Set an option by key
+    pub fn with_config(mut self, key: ClientConfigKey, value: impl Into<String>) -> Self {
+        match key {
+            ClientConfigKey::AllowHttp => self.allow_http.parse(value),
+            ClientConfigKey::AllowInvalidCertificates => self.allow_insecure.parse(value),
+            ClientConfigKey::ConnectTimeout => {
+                self.connect_timeout = Some(ConfigValue::Deferred(value.into()))
+            }
+            ClientConfigKey::DefaultContentType => self.default_content_type = Some(value.into()),
+            ClientConfigKey::Http1Only => self.http1_only.parse(value),
+            ClientConfigKey::Http2Only => self.http2_only.parse(value),
+            ClientConfigKey::Http2KeepAliveInterval => {
+                self.http2_keep_alive_interval = Some(ConfigValue::Deferred(value.into()))
+            }
+            ClientConfigKey::Http2KeepAliveTimeout => {
+                self.http2_keep_alive_timeout = Some(ConfigValue::Deferred(value.into()))
+            }
+            ClientConfigKey::Http2KeepAliveWhileIdle => {
+                self.http2_keep_alive_while_idle.parse(value)
+            }
+            ClientConfigKey::PoolIdleTimeout => {
+                self.pool_idle_timeout = Some(ConfigValue::Deferred(value.into()))
+            }
+            ClientConfigKey::PoolMaxIdlePerHost => {
+                self.pool_max_idle_per_host = Some(ConfigValue::Deferred(value.into()))
+            }
+            ClientConfigKey::ProxyUrl => self.proxy_url = Some(value.into()),
+            ClientConfigKey::ProxyCaCertificate => self.proxy_ca_certificate = Some(value.into()),
+            ClientConfigKey::ProxyExcludes => self.proxy_excludes = Some(value.into()),
+            ClientConfigKey::Timeout => self.timeout = Some(ConfigValue::Deferred(value.into())),
+            ClientConfigKey::UserAgent => {
+                self.user_agent = Some(ConfigValue::Deferred(value.into()))
+            }
+        }
+        self
+    }
+
+    /// Get an option by key
+    pub fn get_config_value(&self, key: &ClientConfigKey) -> Option<String> {
+        match key {
+            ClientConfigKey::AllowHttp => Some(self.allow_http.to_string()),
+            ClientConfigKey::AllowInvalidCertificates => Some(self.allow_insecure.to_string()),
+            ClientConfigKey::ConnectTimeout => self.connect_timeout.as_ref().map(fmt_duration),
+            ClientConfigKey::DefaultContentType => self.default_content_type.clone(),
+            ClientConfigKey::Http1Only => Some(self.http1_only.to_string()),
+            ClientConfigKey::Http2KeepAliveInterval => {
+                self.http2_keep_alive_interval.as_ref().map(fmt_duration)
+            }
+            ClientConfigKey::Http2KeepAliveTimeout => {
+                self.http2_keep_alive_timeout.as_ref().map(fmt_duration)
+            }
+            ClientConfigKey::Http2KeepAliveWhileIdle => {
+                Some(self.http2_keep_alive_while_idle.to_string())
+            }
+            ClientConfigKey::Http2Only => Some(self.http2_only.to_string()),
+            ClientConfigKey::PoolIdleTimeout => self.pool_idle_timeout.as_ref().map(fmt_duration),
+            ClientConfigKey::PoolMaxIdlePerHost => {
+                self.pool_max_idle_per_host.as_ref().map(|v| v.to_string())
+            }
+            ClientConfigKey::ProxyUrl => self.proxy_url.clone(),
+            ClientConfigKey::ProxyCaCertificate => self.proxy_ca_certificate.clone(),
+            ClientConfigKey::ProxyExcludes => self.proxy_excludes.clone(),
+            ClientConfigKey::Timeout => self.timeout.as_ref().map(fmt_duration),
+            ClientConfigKey::UserAgent => self
+                .user_agent
+                .as_ref()
+                .and_then(|v| v.get().ok())
+                .and_then(|v| v.to_str().ok().map(|s| s.to_string())),
+        }
+    }
+
+    /// Sets the User-Agent header to be used by this client
+    ///
+    /// Default is based on the version of this crate
+    pub fn with_user_agent(mut self, agent: HeaderValue) -> Self {
+        self.user_agent = Some(agent.into());
+        self
+    }
+
+    /// Set the default CONTENT_TYPE for uploads
+    pub fn with_default_content_type(mut self, mime: impl Into<String>) -> Self {
+        self.default_content_type = Some(mime.into());
+        self
+    }
+
+    /// Set the CONTENT_TYPE for a given file extension
+    pub fn with_content_type_for_suffix(
+        mut self,
+        extension: impl Into<String>,
+        mime: impl Into<String>,
+    ) -> Self {
+        self.content_type_map.insert(extension.into(), mime.into());
+        self
+    }
+
+    /// Sets the default headers for every request
+    pub fn with_default_headers(mut self, headers: HeaderMap) -> Self {
+        self.default_headers = Some(headers);
+        self
+    }
+
+    /// Sets what protocol is allowed. If `allow_http` is :
+    /// * false (default):  Only HTTPS are allowed
+    /// * true:  HTTP and HTTPS are allowed
+    pub fn with_allow_http(mut self, allow_http: bool) -> Self {
+        self.allow_http = allow_http.into();
+        self
+    }
+    /// Allows connections to invalid SSL certificates
+    /// * false (default):  Only valid HTTPS certificates are allowed
+    /// * true:  All HTTPS certificates are allowed
+    ///
+    /// # Warning
+    ///
+    /// You should think very carefully before using this method. If
+    /// invalid certificates are trusted, *any* certificate for *any* site
+    /// will be trusted for use. This includes expired certificates. This
+    /// introduces significant vulnerabilities, and should only be used
+    /// as a last resort or for testing
+    pub fn with_allow_invalid_certificates(mut self, allow_insecure: bool) -> Self {
+        self.allow_insecure = allow_insecure.into();
+        self
+    }
+
+    /// Only use http1 connections
+    ///
+    /// This is on by default, since http2 is known to be significantly slower than http1.
+    pub fn with_http1_only(mut self) -> Self {
+        self.http2_only = false.into();
+        self.http1_only = true.into();
+        self
+    }
+
+    /// Only use http2 connections
+    pub fn with_http2_only(mut self) -> Self {
+        self.http1_only = false.into();
+        self.http2_only = true.into();
+        self
+    }
+
+    /// Use http2 if supported, otherwise use http1.
+    pub fn with_allow_http2(mut self) -> Self {
+        self.http1_only = false.into();
+        self.http2_only = false.into();
+        self
+    }
+
+    /// Set a proxy URL to use for requests
+    pub fn with_proxy_url(mut self, proxy_url: impl Into<String>) -> Self {
+        self.proxy_url = Some(proxy_url.into());
+        self
+    }
+
+    /// Set a trusted proxy CA certificate
+    pub fn with_proxy_ca_certificate(mut self, proxy_ca_certificate: impl Into<String>) -> Self {
+        self.proxy_ca_certificate = Some(proxy_ca_certificate.into());
+        self
+    }
+
+    /// Set a list of hosts to exclude from proxy connections
+    pub fn with_proxy_excludes(mut self, proxy_excludes: impl Into<String>) -> Self {
+        self.proxy_excludes = Some(proxy_excludes.into());
+        self
+    }
+
+    /// Set a request timeout
+    ///
+    /// The timeout is applied from when the request starts connecting until the
+    /// response body has finished
+    ///
+    /// Default is 5 seconds
+    pub fn with_timeout(mut self, timeout: Duration) -> Self {
+        self.timeout = Some(ConfigValue::Parsed(timeout));
+        self
+    }
+
+    /// Disables the request timeout
+    ///
+    /// See [`Self::with_timeout`]
+    pub fn with_timeout_disabled(mut self) -> Self {
+        self.timeout = None;
+        self
+    }
+
+    /// Set a timeout for only the connect phase of a Client
+    ///
+    /// Default is 5 seconds
+    pub fn with_connect_timeout(mut self, timeout: Duration) -> Self {
+        self.connect_timeout = Some(ConfigValue::Parsed(timeout));
+        self
+    }
+
+    /// Disables the connection timeout
+    ///
+    /// See [`Self::with_connect_timeout`]
+    pub fn with_connect_timeout_disabled(mut self) -> Self {
+        self.timeout = None;
+        self
+    }
+
+    /// Set the pool max idle timeout
+    ///
+    /// This is the length of time an idle connection will be kept alive
+    ///
+    /// Default is 90 seconds
+    pub fn with_pool_idle_timeout(mut self, timeout: Duration) -> Self {
+        self.pool_idle_timeout = Some(ConfigValue::Parsed(timeout));
+        self
+    }
+
+    /// Set the maximum number of idle connections per host
+    ///
+    /// Default is no limit
+    pub fn with_pool_max_idle_per_host(mut self, max: usize) -> Self {
+        self.pool_max_idle_per_host = Some(max.into());
+        self
+    }
+
+    /// Sets an interval for HTTP2 Ping frames should be sent to keep a connection alive.
+    ///
+    /// Default is disabled
+    pub fn with_http2_keep_alive_interval(mut self, interval: Duration) -> Self {
+        self.http2_keep_alive_interval = Some(ConfigValue::Parsed(interval));
+        self
+    }
+
+    /// Sets a timeout for receiving an acknowledgement of the keep-alive ping.
+    ///
+    /// If the ping is not acknowledged within the timeout, the connection will be closed.
+    /// Does nothing if http2_keep_alive_interval is disabled.
+    ///
+    /// Default is disabled
+    pub fn with_http2_keep_alive_timeout(mut self, interval: Duration) -> Self {
+        self.http2_keep_alive_timeout = Some(ConfigValue::Parsed(interval));
+        self
+    }
+
+    /// Enable HTTP2 keep alive pings for idle connections
+    ///
+    /// If disabled, keep-alive pings are only sent while there are open request/response
+    /// streams. If enabled, pings are also sent when no streams are active
+    ///
+    /// Default is disabled
+    pub fn with_http2_keep_alive_while_idle(mut self) -> Self {
+        self.http2_keep_alive_while_idle = true.into();
+        self
+    }
+
+    /// Get the mime type for the file in `path` to be uploaded
+    ///
+    /// Gets the file extension from `path`, and returns the
+    /// mime type if it was defined initially through
+    /// `ClientOptions::with_content_type_for_suffix`
+    ///
+    /// Otherwise returns the default mime type if it was defined
+    /// earlier through `ClientOptions::with_default_content_type`
+    pub fn get_content_type(&self, path: &Path) -> Option<&str> {
+        match path.extension() {
+            Some(extension) => match self.content_type_map.get(extension) {
+                Some(ct) => Some(ct.as_str()),
+                None => self.default_content_type.as_deref(),
+            },
+            None => self.default_content_type.as_deref(),
+        }
+    }
+
+    /// Create a [`Client`] with overrides optimised for metadata endpoint access
+    ///
+    /// In particular:
+    /// * Allows HTTP as metadata endpoints do not use TLS
+    /// * Configures a low connection timeout to provide quick feedback if not present
+    #[cfg(any(feature = "aws", feature = "gcp", feature = "azure"))]
+    pub(crate) fn metadata_client(&self) -> Result<Client> {
+        self.clone()
+            .with_allow_http(true)
+            .with_connect_timeout(Duration::from_secs(1))
+            .client()
+    }
+
+    pub(crate) fn client(&self) -> Result<Client> {
+        let mut builder = ClientBuilder::new();
+
+        match &self.user_agent {
+            Some(user_agent) => builder = builder.user_agent(user_agent.get()?),
+            None => builder = builder.user_agent(DEFAULT_USER_AGENT),
+        }
+
+        if let Some(headers) = &self.default_headers {
+            builder = builder.default_headers(headers.clone())
+        }
+
+        if let Some(proxy) = &self.proxy_url {
+            let mut proxy = Proxy::all(proxy).map_err(map_client_error)?;
+
+            if let Some(certificate) = &self.proxy_ca_certificate {
+                let certificate = reqwest::tls::Certificate::from_pem(certificate.as_bytes())
+                    .map_err(map_client_error)?;
+
+                builder = builder.add_root_certificate(certificate);
+            }
+
+            if let Some(proxy_excludes) = &self.proxy_excludes {
+                let no_proxy = NoProxy::from_string(proxy_excludes);
+
+                proxy = proxy.no_proxy(no_proxy);
+            }
+
+            builder = builder.proxy(proxy);
+        }
+
+        if let Some(timeout) = &self.timeout {
+            builder = builder.timeout(timeout.get()?)
+        }
+
+        if let Some(timeout) = &self.connect_timeout {
+            builder = builder.connect_timeout(timeout.get()?)
+        }
+
+        if let Some(timeout) = &self.pool_idle_timeout {
+            builder = builder.pool_idle_timeout(timeout.get()?)
+        }
+
+        if let Some(max) = &self.pool_max_idle_per_host {
+            builder = builder.pool_max_idle_per_host(max.get()?)
+        }
+
+        if let Some(interval) = &self.http2_keep_alive_interval {
+            builder = builder.http2_keep_alive_interval(interval.get()?)
+        }
+
+        if let Some(interval) = &self.http2_keep_alive_timeout {
+            builder = builder.http2_keep_alive_timeout(interval.get()?)
+        }
+
+        if self.http2_keep_alive_while_idle.get()? {
+            builder = builder.http2_keep_alive_while_idle(true)
+        }
+
+        if self.http1_only.get()? {
+            builder = builder.http1_only()
+        }
+
+        if self.http2_only.get()? {
+            builder = builder.http2_prior_knowledge()
+        }
+
+        if self.allow_insecure.get()? {
+            builder = builder.danger_accept_invalid_certs(true)
+        }
+
+        builder
+            .https_only(!self.allow_http.get()?)
+            .build()
+            .map_err(map_client_error)
+    }
+}
+
+pub trait GetOptionsExt {
+    fn with_get_options(self, options: GetOptions) -> Self;
+}
+
+impl GetOptionsExt for RequestBuilder {
+    fn with_get_options(mut self, options: GetOptions) -> Self {
+        use hyper::header::*;
+
+        if let Some(range) = options.range {
+            self = self.header(RANGE, range.to_string());
+        }
+
+        if let Some(tag) = options.if_match {
+            self = self.header(IF_MATCH, tag);
+        }
+
+        if let Some(tag) = options.if_none_match {
+            self = self.header(IF_NONE_MATCH, tag);
+        }
+
+        const DATE_FORMAT: &str = "%a, %d %b %Y %H:%M:%S GMT";
+        if let Some(date) = options.if_unmodified_since {
+            self = self.header(IF_UNMODIFIED_SINCE, date.format(DATE_FORMAT).to_string());
+        }
+
+        if let Some(date) = options.if_modified_since {
+            self = self.header(IF_MODIFIED_SINCE, date.format(DATE_FORMAT).to_string());
+        }
+
+        self
+    }
+}
+
+/// Provides credentials for use when signing requests
+#[async_trait]
+pub trait CredentialProvider: std::fmt::Debug + Send + Sync {
+    /// The type of credential returned by this provider
+    type Credential;
+
+    /// Return a credential
+    async fn get_credential(&self) -> Result<Arc<Self::Credential>>;
+}
+
+/// A static set of credentials
+#[derive(Debug)]
+pub struct StaticCredentialProvider<T> {
+    credential: Arc<T>,
+}
+
+impl<T> StaticCredentialProvider<T> {
+    /// A [`CredentialProvider`] for a static credential of type `T`
+    pub fn new(credential: T) -> Self {
+        Self {
+            credential: Arc::new(credential),
+        }
+    }
+}
+
+#[async_trait]
+impl<T> CredentialProvider for StaticCredentialProvider<T>
+where
+    T: std::fmt::Debug + Send + Sync,
+{
+    type Credential = T;
+
+    async fn get_credential(&self) -> Result<Arc<T>> {
+        Ok(Arc::clone(&self.credential))
+    }
+}
+
+#[cfg(any(feature = "aws", feature = "azure", feature = "gcp"))]
+mod cloud {
+    use super::*;
+    use crate::client::token::{TemporaryToken, TokenCache};
+    use crate::RetryConfig;
+
+    /// A [`CredentialProvider`] that uses [`Client`] to fetch temporary tokens
+    #[derive(Debug)]
+    pub struct TokenCredentialProvider<T: TokenProvider> {
+        inner: T,
+        client: Client,
+        retry: RetryConfig,
+        cache: TokenCache<Arc<T::Credential>>,
+    }
+
+    impl<T: TokenProvider> TokenCredentialProvider<T> {
+        pub fn new(inner: T, client: Client, retry: RetryConfig) -> Self {
+            Self {
+                inner,
+                client,
+                retry,
+                cache: Default::default(),
+            }
+        }
+
+        /// Override the minimum remaining TTL for a cached token to be used
+        #[cfg(feature = "aws")]
+        pub fn with_min_ttl(mut self, min_ttl: Duration) -> Self {
+            self.cache = self.cache.with_min_ttl(min_ttl);
+            self
+        }
+    }
+
+    #[async_trait]
+    impl<T: TokenProvider> CredentialProvider for TokenCredentialProvider<T> {
+        type Credential = T::Credential;
+
+        async fn get_credential(&self) -> Result<Arc<Self::Credential>> {
+            self.cache
+                .get_or_insert_with(|| self.inner.fetch_token(&self.client, &self.retry))
+                .await
+        }
+    }
+
+    #[async_trait]
+    pub trait TokenProvider: std::fmt::Debug + Send + Sync {
+        type Credential: std::fmt::Debug + Send + Sync;
+
+        async fn fetch_token(
+            &self,
+            client: &Client,
+            retry: &RetryConfig,
+        ) -> Result<TemporaryToken<Arc<Self::Credential>>>;
+    }
+}
+
+#[cfg(any(feature = "aws", feature = "azure", feature = "gcp"))]
+pub use cloud::*;
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+
+    #[test]
+    fn client_test_config_from_map() {
+        let allow_http = "true".to_string();
+        let allow_invalid_certificates = "false".to_string();
+        let connect_timeout = "90 seconds".to_string();
+        let default_content_type = "object_store:fake_default_content_type".to_string();
+        let http1_only = "true".to_string();
+        let http2_only = "false".to_string();
+        let http2_keep_alive_interval = "90 seconds".to_string();
+        let http2_keep_alive_timeout = "91 seconds".to_string();
+        let http2_keep_alive_while_idle = "92 seconds".to_string();
+        let pool_idle_timeout = "93 seconds".to_string();
+        let pool_max_idle_per_host = "94".to_string();
+        let proxy_url = "https://fake_proxy_url".to_string();
+        let timeout = "95 seconds".to_string();
+        let user_agent = "object_store:fake_user_agent".to_string();
+
+        let options = HashMap::from([
+            ("allow_http", allow_http.clone()),
+            (
+                "allow_invalid_certificates",
+                allow_invalid_certificates.clone(),
+            ),
+            ("connect_timeout", connect_timeout.clone()),
+            ("default_content_type", default_content_type.clone()),
+            ("http1_only", http1_only.clone()),
+            ("http2_only", http2_only.clone()),
+            (
+                "http2_keep_alive_interval",
+                http2_keep_alive_interval.clone(),
+            ),
+            ("http2_keep_alive_timeout", http2_keep_alive_timeout.clone()),
+            (
+                "http2_keep_alive_while_idle",
+                http2_keep_alive_while_idle.clone(),
+            ),
+            ("pool_idle_timeout", pool_idle_timeout.clone()),
+            ("pool_max_idle_per_host", pool_max_idle_per_host.clone()),
+            ("proxy_url", proxy_url.clone()),
+            ("timeout", timeout.clone()),
+            ("user_agent", user_agent.clone()),
+        ]);
+
+        let builder = options
+            .into_iter()
+            .fold(ClientOptions::new(), |builder, (key, value)| {
+                builder.with_config(key.parse().unwrap(), value)
+            });
+
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::AllowHttp)
+                .unwrap(),
+            allow_http
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::AllowInvalidCertificates)
+                .unwrap(),
+            allow_invalid_certificates
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::ConnectTimeout)
+                .unwrap(),
+            connect_timeout
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::DefaultContentType)
+                .unwrap(),
+            default_content_type
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::Http1Only)
+                .unwrap(),
+            http1_only
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::Http2Only)
+                .unwrap(),
+            http2_only
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::Http2KeepAliveInterval)
+                .unwrap(),
+            http2_keep_alive_interval
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::Http2KeepAliveTimeout)
+                .unwrap(),
+            http2_keep_alive_timeout
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::Http2KeepAliveWhileIdle)
+                .unwrap(),
+            http2_keep_alive_while_idle
+        );
+
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::PoolIdleTimeout)
+                .unwrap(),
+            pool_idle_timeout
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::PoolMaxIdlePerHost)
+                .unwrap(),
+            pool_max_idle_per_host
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::ProxyUrl)
+                .unwrap(),
+            proxy_url
+        );
+        assert_eq!(
+            builder.get_config_value(&ClientConfigKey::Timeout).unwrap(),
+            timeout
+        );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::UserAgent)
+                .unwrap(),
+            user_agent
+        );
+    }
+}
diff --git a/object_store/src/client/oauth.rs b/object_store/src/client/oauth.rs
deleted file mode 100644
index 88e7a7b0f9e8..000000000000
--- a/object_store/src/client/oauth.rs
+++ /dev/null
@@ -1,221 +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.
-
-use crate::client::retry::RetryExt;
-use crate::client::token::TemporaryToken;
-use crate::RetryConfig;
-use reqwest::{Client, Method};
-use ring::signature::RsaKeyPair;
-use snafu::{ResultExt, Snafu};
-use std::time::{Duration, Instant};
-
-#[derive(Debug, Snafu)]
-pub enum Error {
-    #[snafu(display("No RSA key found in pem file"))]
-    MissingKey,
-
-    #[snafu(display("Invalid RSA key: {}", source), context(false))]
-    InvalidKey { source: ring::error::KeyRejected },
-
-    #[snafu(display("Error signing jwt: {}", source))]
-    Sign { source: ring::error::Unspecified },
-
-    #[snafu(display("Error encoding jwt payload: {}", source))]
-    Encode { source: serde_json::Error },
-
-    #[snafu(display("Unsupported key encoding: {}", encoding))]
-    UnsupportedKey { encoding: String },
-
-    #[snafu(display("Error performing token request: {}", source))]
-    TokenRequest { source: reqwest::Error },
-}
-
-pub type Result<T, E = Error> = std::result::Result<T, E>;
-
-#[derive(Debug, Default, serde::Serialize)]
-pub struct JwtHeader {
-    /// The type of JWS: it can only be "JWT" here
-    ///
-    /// Defined in [RFC7515#4.1.9](https://tools.ietf.org/html/rfc7515#section-4.1.9).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub typ: Option<String>,
-    /// The algorithm used
-    ///
-    /// Defined in [RFC7515#4.1.1](https://tools.ietf.org/html/rfc7515#section-4.1.1).
-    pub alg: String,
-    /// Content type
-    ///
-    /// Defined in [RFC7519#5.2](https://tools.ietf.org/html/rfc7519#section-5.2).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub cty: Option<String>,
-    /// JSON Key URL
-    ///
-    /// Defined in [RFC7515#4.1.2](https://tools.ietf.org/html/rfc7515#section-4.1.2).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub jku: Option<String>,
-    /// Key ID
-    ///
-    /// Defined in [RFC7515#4.1.4](https://tools.ietf.org/html/rfc7515#section-4.1.4).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub kid: Option<String>,
-    /// X.509 URL
-    ///
-    /// Defined in [RFC7515#4.1.5](https://tools.ietf.org/html/rfc7515#section-4.1.5).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub x5u: Option<String>,
-    /// X.509 certificate thumbprint
-    ///
-    /// Defined in [RFC7515#4.1.7](https://tools.ietf.org/html/rfc7515#section-4.1.7).
-    #[serde(skip_serializing_if = "Option::is_none")]
-    pub x5t: Option<String>,
-}
-
-#[derive(serde::Serialize)]
-struct TokenClaims<'a> {
-    iss: &'a str,
-    scope: &'a str,
-    aud: &'a str,
-    exp: u64,
-    iat: u64,
-}
-
-#[derive(serde::Deserialize, Debug)]
-struct TokenResponse {
-    access_token: String,
-    expires_in: u64,
-}
-
-/// Encapsulates the logic to perform an OAuth token challenge
-#[derive(Debug)]
-pub struct OAuthProvider {
-    issuer: String,
-    scope: String,
-    audience: String,
-    key_pair: RsaKeyPair,
-    jwt_header: String,
-    random: ring::rand::SystemRandom,
-}
-
-impl OAuthProvider {
-    /// Create a new [`OAuthProvider`]
-    pub fn new(
-        issuer: String,
-        private_key_pem: String,
-        scope: String,
-        audience: String,
-    ) -> Result<Self> {
-        let key_pair = decode_first_rsa_key(private_key_pem)?;
-        let jwt_header = b64_encode_obj(&JwtHeader {
-            alg: "RS256".to_string(),
-            ..Default::default()
-        })?;
-
-        Ok(Self {
-            issuer,
-            key_pair,
-            scope,
-            audience,
-            jwt_header,
-            random: ring::rand::SystemRandom::new(),
-        })
-    }
-
-    /// Fetch a fresh token
-    pub async fn fetch_token(
-        &self,
-        client: &Client,
-        retry: &RetryConfig,
-    ) -> Result<TemporaryToken<String>> {
-        let now = seconds_since_epoch();
-        let exp = now + 3600;
-
-        let claims = TokenClaims {
-            iss: &self.issuer,
-            scope: &self.scope,
-            aud: &self.audience,
-            exp,
-            iat: now,
-        };
-
-        let claim_str = b64_encode_obj(&claims)?;
-        let message = [self.jwt_header.as_ref(), claim_str.as_ref()].join(".");
-        let mut sig_bytes = vec![0; self.key_pair.public_modulus_len()];
-        self.key_pair
-            .sign(
-                &ring::signature::RSA_PKCS1_SHA256,
-                &self.random,
-                message.as_bytes(),
-                &mut sig_bytes,
-            )
-            .context(SignSnafu)?;
-
-        let signature = base64::encode_config(&sig_bytes, base64::URL_SAFE_NO_PAD);
-        let jwt = [message, signature].join(".");
-
-        let body = [
-            ("grant_type", "urn:ietf:params:oauth:grant-type:jwt-bearer"),
-            ("assertion", &jwt),
-        ];
-
-        let response: TokenResponse = client
-            .request(Method::POST, &self.audience)
-            .form(&body)
-            .send_retry(retry)
-            .await
-            .context(TokenRequestSnafu)?
-            .error_for_status()
-            .context(TokenRequestSnafu)?
-            .json()
-            .await
-            .context(TokenRequestSnafu)?;
-
-        let token = TemporaryToken {
-            token: response.access_token,
-            expiry: Instant::now() + Duration::from_secs(response.expires_in),
-        };
-
-        Ok(token)
-    }
-}
-
-/// Returns the number of seconds since unix epoch
-fn seconds_since_epoch() -> u64 {
-    std::time::SystemTime::now()
-        .duration_since(std::time::SystemTime::UNIX_EPOCH)
-        .unwrap()
-        .as_secs()
-}
-
-fn decode_first_rsa_key(private_key_pem: String) -> Result<RsaKeyPair> {
-    use rustls_pemfile::Item;
-    use std::io::{BufReader, Cursor};
-
-    let mut cursor = Cursor::new(private_key_pem);
-    let mut reader = BufReader::new(&mut cursor);
-
-    // Reading from string is infallible
-    match rustls_pemfile::read_one(&mut reader).unwrap() {
-        Some(Item::PKCS8Key(key)) => Ok(RsaKeyPair::from_pkcs8(&key)?),
-        Some(Item::RSAKey(key)) => Ok(RsaKeyPair::from_der(&key)?),
-        _ => Err(Error::MissingKey),
-    }
-}
-
-fn b64_encode_obj<T: serde::Serialize>(obj: &T) -> Result<String> {
-    let string = serde_json::to_string(obj).context(EncodeSnafu)?;
-    Ok(base64::encode_config(string, base64::URL_SAFE_NO_PAD))
-}
diff --git a/object_store/src/client/pagination.rs b/object_store/src/client/pagination.rs
new file mode 100644
index 000000000000..1febe3ae0a90
--- /dev/null
+++ b/object_store/src/client/pagination.rs
@@ -0,0 +1,72 @@
+// 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.
+
+use crate::Result;
+use futures::Stream;
+use std::future::Future;
+
+/// Takes a paginated operation `op` that when called with:
+///
+/// - A state `S`
+/// - An optional next token `Option<String>`
+///
+/// Returns
+///
+/// - A response value `T`
+/// - The next state `S`
+/// - The next continuation token `Option<String>`
+///
+/// And converts it into a `Stream<Result<T>>` which will first call `op(state, None)`, and yield
+/// the returned response `T`. If the returned continuation token was `None` the stream will then
+/// finish, otherwise it will continue to call `op(state, token)` with the values returned by the
+/// previous call to `op`, until a continuation token of `None` is returned
+///
+pub fn stream_paginated<F, Fut, S, T>(state: S, op: F) -> impl Stream<Item = Result<T>>
+where
+    F: Fn(S, Option<String>) -> Fut + Copy,
+    Fut: Future<Output = Result<(T, S, Option<String>)>>,
+{
+    enum PaginationState<T> {
+        Start(T),
+        HasMore(T, String),
+        Done,
+    }
+
+    futures::stream::unfold(PaginationState::Start(state), move |state| async move {
+        let (s, page_token) = match state {
+            PaginationState::Start(s) => (s, None),
+            PaginationState::HasMore(s, page_token) if !page_token.is_empty() => {
+                (s, Some(page_token))
+            }
+            _ => {
+                return None;
+            }
+        };
+
+        let (resp, s, continuation) = match op(s, page_token).await {
+            Ok(resp) => resp,
+            Err(e) => return Some((Err(e), PaginationState::Done)),
+        };
+
+        let next_state = match continuation {
+            Some(token) => PaginationState::HasMore(s, token),
+            None => PaginationState::Done,
+        };
+
+        Some((Ok(resp), next_state))
+    })
+}
diff --git a/object_store/src/client/retry.rs b/object_store/src/client/retry.rs
index c4dd6ee934cb..fbd3645d2780 100644
--- a/object_store/src/client/retry.rs
+++ b/object_store/src/client/retry.rs
@@ -20,15 +20,118 @@
 use crate::client::backoff::{Backoff, BackoffConfig};
 use futures::future::BoxFuture;
 use futures::FutureExt;
-use reqwest::{Response, Result};
+use reqwest::header::LOCATION;
+use reqwest::{Response, StatusCode};
+use snafu::Error as SnafuError;
+use snafu::Snafu;
 use std::time::{Duration, Instant};
 use tracing::info;
 
-/// Contains the configuration for how to respond to server errors
+/// Retry request error
+#[derive(Debug, Snafu)]
+pub enum Error {
+    #[snafu(display("Received redirect without LOCATION, this normally indicates an incorrectly configured region"))]
+    BareRedirect,
+
+    #[snafu(display("Client error with status {status}: {}", body.as_deref().unwrap_or("No Body")))]
+    Client {
+        status: StatusCode,
+        body: Option<String>,
+    },
+
+    #[snafu(display("Error after {retries} retries in {elapsed:?}, max_retries:{max_retries}, retry_timeout:{retry_timeout:?}, source:{source}"))]
+    Reqwest {
+        retries: usize,
+        max_retries: usize,
+        elapsed: Duration,
+        retry_timeout: Duration,
+        source: reqwest::Error,
+    },
+}
+
+impl Error {
+    /// Returns the status code associated with this error if any
+    pub fn status(&self) -> Option<StatusCode> {
+        match self {
+            Self::BareRedirect => None,
+            Self::Client { status, .. } => Some(*status),
+            Self::Reqwest { source, .. } => source.status(),
+        }
+    }
+
+    /// Returns the error body if any
+    pub fn body(&self) -> Option<&str> {
+        match self {
+            Self::Client { body, .. } => body.as_deref(),
+            Self::BareRedirect => None,
+            Self::Reqwest { .. } => None,
+        }
+    }
+
+    pub fn error(self, store: &'static str, path: String) -> crate::Error {
+        match self.status() {
+            Some(StatusCode::NOT_FOUND) => crate::Error::NotFound {
+                path,
+                source: Box::new(self),
+            },
+            Some(StatusCode::NOT_MODIFIED) => crate::Error::NotModified {
+                path,
+                source: Box::new(self),
+            },
+            Some(StatusCode::PRECONDITION_FAILED) => crate::Error::Precondition {
+                path,
+                source: Box::new(self),
+            },
+            Some(StatusCode::CONFLICT) => crate::Error::AlreadyExists {
+                path,
+                source: Box::new(self),
+            },
+            _ => crate::Error::Generic {
+                store,
+                source: Box::new(self),
+            },
+        }
+    }
+}
+
+impl From<Error> for std::io::Error {
+    fn from(err: Error) -> Self {
+        use std::io::ErrorKind;
+        match &err {
+            Error::Client {
+                status: StatusCode::NOT_FOUND,
+                ..
+            } => Self::new(ErrorKind::NotFound, err),
+            Error::Client {
+                status: StatusCode::BAD_REQUEST,
+                ..
+            } => Self::new(ErrorKind::InvalidInput, err),
+            Error::Reqwest { source, .. } if source.is_timeout() => {
+                Self::new(ErrorKind::TimedOut, err)
+            }
+            Error::Reqwest { source, .. } if source.is_connect() => {
+                Self::new(ErrorKind::NotConnected, err)
+            }
+            _ => Self::new(ErrorKind::Other, err),
+        }
+    }
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+/// The configuration for how to respond to request errors
+///
+/// The following categories of error will be retried:
 ///
-/// By default they will be retried up to some limit, using exponential
+/// * 5xx server errors
+/// * Connection errors
+/// * Dropped connections
+/// * Timeouts for [safe] / read-only requests
+///
+/// Requests will be retried up to some limit, using exponential
 /// backoff with jitter. See [`BackoffConfig`] for more information
 ///
+/// [safe]: https://datatracker.ietf.org/doc/html/rfc7231#section-4.2.1
 #[derive(Debug, Clone)]
 pub struct RetryConfig {
     /// The backoff configuration
@@ -78,29 +181,316 @@ impl RetryExt for reqwest::RequestBuilder {
         let max_retries = config.max_retries;
         let retry_timeout = config.retry_timeout;
 
+        let (client, req) = self.build_split();
+        let req = req.expect("request must be valid");
+
         async move {
             let mut retries = 0;
             let now = Instant::now();
 
             loop {
-                let s = self.try_clone().expect("request body must be cloneable");
-                match s.send().await {
-                    Err(e)
-                        if retries < max_retries
-                            && now.elapsed() < retry_timeout
-                            && e.status()
-                                .map(|s| s.is_server_error())
-                                .unwrap_or(false) =>
+                let s = req.try_clone().expect("request body must be cloneable");
+                match client.execute(s).await {
+                    Ok(r) => match r.error_for_status_ref() {
+                        Ok(_) if r.status().is_success() => return Ok(r),
+                        Ok(r) if r.status() == StatusCode::NOT_MODIFIED => {
+                            return Err(Error::Client {
+                                body: None,
+                                status: StatusCode::NOT_MODIFIED,
+                            })
+                        }
+                        Ok(r) => {
+                            let is_bare_redirect = r.status().is_redirection() && !r.headers().contains_key(LOCATION);
+                            return match is_bare_redirect {
+                                true => Err(Error::BareRedirect),
+                                // Not actually sure if this is reachable, but here for completeness
+                                false => Err(Error::Client {
+                                    body: None,
+                                    status: r.status(),
+                                })
+                            }
+                        }
+                        Err(e) => {
+                            let status = r.status();
+                            if retries == max_retries
+                                || now.elapsed() > retry_timeout
+                                || !status.is_server_error() {
+
+                                return Err(match status.is_client_error() {
+                                    true => match r.text().await {
+                                        Ok(body) => {
+                                            Error::Client {
+                                                body: Some(body).filter(|b| !b.is_empty()),
+                                                status,
+                                            }
+                                        }
+                                        Err(e) => {
+                                            Error::Reqwest {
+                                                retries,
+                                                max_retries,
+                                                elapsed: now.elapsed(),
+                                                retry_timeout,
+                                                source: e,
+                                            }
+                                        }
+                                    }
+                                    false => Error::Reqwest {
+                                        retries,
+                                        max_retries,
+                                        elapsed: now.elapsed(),
+                                        retry_timeout,
+                                        source: e,
+                                    }
+                                });
+                            }
+
+                            let sleep = backoff.next();
+                            retries += 1;
+                            info!(
+                                "Encountered server error, backing off for {} seconds, retry {} of {}: {}",
+                                sleep.as_secs_f32(),
+                                retries,
+                                max_retries,
+                                e,
+                            );
+                            tokio::time::sleep(sleep).await;
+                        }
+                    },
+                    Err(e) =>
                     {
+                        let mut do_retry = false;
+                        if req.method().is_safe() && e.is_timeout() {
+                            do_retry = true
+                        } else if let Some(source) = e.source() {
+                            if let Some(e) = source.downcast_ref::<hyper::Error>() {
+                                if e.is_connect() || e.is_closed() || e.is_incomplete_message() {
+                                    do_retry = true;
+                                }
+                            }
+                        }
+
+                        if retries == max_retries
+                            || now.elapsed() > retry_timeout
+                            || !do_retry {
+
+                            return Err(Error::Reqwest {
+                                retries,
+                                max_retries,
+                                elapsed: now.elapsed(),
+                                retry_timeout,
+                                source: e,
+                            })
+                        }
                         let sleep = backoff.next();
                         retries += 1;
-                        info!("Encountered server error, backing off for {} seconds, retry {} of {}", sleep.as_secs_f32(), retries, max_retries);
+                        info!(
+                            "Encountered transport error backing off for {} seconds, retry {} of {}: {}", 
+                            sleep.as_secs_f32(),
+                            retries,
+                            max_retries,
+                            e,
+                        );
                         tokio::time::sleep(sleep).await;
                     }
-                    r => return r,
                 }
             }
         }
         .boxed()
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::client::mock_server::MockServer;
+    use crate::client::retry::{Error, RetryExt};
+    use crate::RetryConfig;
+    use hyper::header::LOCATION;
+    use hyper::{Body, Response};
+    use reqwest::{Client, Method, StatusCode};
+    use std::time::Duration;
+
+    #[tokio::test]
+    async fn test_retry() {
+        let mock = MockServer::new();
+
+        let retry = RetryConfig {
+            backoff: Default::default(),
+            max_retries: 2,
+            retry_timeout: Duration::from_secs(1000),
+        };
+
+        let client = Client::builder()
+            .timeout(Duration::from_millis(100))
+            .build()
+            .unwrap();
+
+        let do_request = || client.request(Method::GET, mock.url()).send_retry(&retry);
+
+        // Simple request should work
+        let r = do_request().await.unwrap();
+        assert_eq!(r.status(), StatusCode::OK);
+
+        // Returns client errors immediately with status message
+        mock.push(
+            Response::builder()
+                .status(StatusCode::BAD_REQUEST)
+                .body(Body::from("cupcakes"))
+                .unwrap(),
+        );
+
+        let e = do_request().await.unwrap_err();
+        assert_eq!(e.status().unwrap(), StatusCode::BAD_REQUEST);
+        assert_eq!(e.body(), Some("cupcakes"));
+        assert_eq!(
+            e.to_string(),
+            "Client error with status 400 Bad Request: cupcakes"
+        );
+
+        // Handles client errors with no payload
+        mock.push(
+            Response::builder()
+                .status(StatusCode::BAD_REQUEST)
+                .body(Body::empty())
+                .unwrap(),
+        );
+
+        let e = do_request().await.unwrap_err();
+        assert_eq!(e.status().unwrap(), StatusCode::BAD_REQUEST);
+        assert_eq!(e.body(), None);
+        assert_eq!(
+            e.to_string(),
+            "Client error with status 400 Bad Request: No Body"
+        );
+
+        // Should retry server error request
+        mock.push(
+            Response::builder()
+                .status(StatusCode::BAD_GATEWAY)
+                .body(Body::empty())
+                .unwrap(),
+        );
+
+        let r = do_request().await.unwrap();
+        assert_eq!(r.status(), StatusCode::OK);
+
+        // Accepts 204 status code
+        mock.push(
+            Response::builder()
+                .status(StatusCode::NO_CONTENT)
+                .body(Body::empty())
+                .unwrap(),
+        );
+
+        let r = do_request().await.unwrap();
+        assert_eq!(r.status(), StatusCode::NO_CONTENT);
+
+        // Follows 402 redirects
+        mock.push(
+            Response::builder()
+                .status(StatusCode::FOUND)
+                .header(LOCATION, "/foo")
+                .body(Body::empty())
+                .unwrap(),
+        );
+
+        let r = do_request().await.unwrap();
+        assert_eq!(r.status(), StatusCode::OK);
+        assert_eq!(r.url().path(), "/foo");
+
+        // Follows 401 redirects
+        mock.push(
+            Response::builder()
+                .status(StatusCode::FOUND)
+                .header(LOCATION, "/bar")
+                .body(Body::empty())
+                .unwrap(),
+        );
+
+        let r = do_request().await.unwrap();
+        assert_eq!(r.status(), StatusCode::OK);
+        assert_eq!(r.url().path(), "/bar");
+
+        // Handles redirect loop
+        for _ in 0..10 {
+            mock.push(
+                Response::builder()
+                    .status(StatusCode::FOUND)
+                    .header(LOCATION, "/bar")
+                    .body(Body::empty())
+                    .unwrap(),
+            );
+        }
+
+        let e = do_request().await.unwrap_err().to_string();
+        assert!(e.ends_with("too many redirects"), "{}", e);
+
+        // Handles redirect missing location
+        mock.push(
+            Response::builder()
+                .status(StatusCode::FOUND)
+                .body(Body::empty())
+                .unwrap(),
+        );
+
+        let e = do_request().await.unwrap_err();
+        assert!(matches!(e, Error::BareRedirect));
+        assert_eq!(e.to_string(), "Received redirect without LOCATION, this normally indicates an incorrectly configured region");
+
+        // Gives up after the retrying the specified number of times
+        for _ in 0..=retry.max_retries {
+            mock.push(
+                Response::builder()
+                    .status(StatusCode::BAD_GATEWAY)
+                    .body(Body::from("ignored"))
+                    .unwrap(),
+            );
+        }
+
+        let e = do_request().await.unwrap_err().to_string();
+        assert!(
+            e.contains("Error after 2 retries in") &&
+            e.contains("max_retries:2, retry_timeout:1000s, source:HTTP status server error (502 Bad Gateway) for url"),
+            "{e}"
+        );
+
+        // Panic results in an incomplete message error in the client
+        mock.push_fn(|_| panic!());
+        let r = do_request().await.unwrap();
+        assert_eq!(r.status(), StatusCode::OK);
+
+        // Gives up after retrying multiple panics
+        for _ in 0..=retry.max_retries {
+            mock.push_fn(|_| panic!());
+        }
+        let e = do_request().await.unwrap_err().to_string();
+        assert!(
+            e.contains("Error after 2 retries in")
+                && e.contains(
+                    "max_retries:2, retry_timeout:1000s, source:error sending request for url"
+                ),
+            "{e}"
+        );
+
+        // Retries on client timeout
+        mock.push_async_fn(|_| async move {
+            tokio::time::sleep(Duration::from_secs(10)).await;
+            panic!()
+        });
+        do_request().await.unwrap();
+
+        // Does not retry PUT request
+        mock.push_async_fn(|_| async move {
+            tokio::time::sleep(Duration::from_secs(10)).await;
+            panic!()
+        });
+        let res = client.request(Method::PUT, mock.url()).send_retry(&retry);
+        let e = res.await.unwrap_err().to_string();
+        assert!(
+            e.contains("Error after 0 retries in") && e.contains("operation timed out"),
+            "{e}"
+        );
+
+        // Shutdown
+        mock.shutdown().await
+    }
+}
diff --git a/object_store/src/client/s3.rs b/object_store/src/client/s3.rs
new file mode 100644
index 000000000000..61237dc4beab
--- /dev/null
+++ b/object_store/src/client/s3.rs
@@ -0,0 +1,128 @@
+// 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.
+
+//! The list and multipart API used by both GCS and S3
+
+use crate::multipart::PartId;
+use crate::path::Path;
+use crate::{ListResult, ObjectMeta, Result};
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct ListResponse {
+    #[serde(default)]
+    pub contents: Vec<ListContents>,
+    #[serde(default)]
+    pub common_prefixes: Vec<ListPrefix>,
+    #[serde(default)]
+    pub next_continuation_token: Option<String>,
+}
+
+impl TryFrom<ListResponse> for ListResult {
+    type Error = crate::Error;
+
+    fn try_from(value: ListResponse) -> Result<Self> {
+        let common_prefixes = value
+            .common_prefixes
+            .into_iter()
+            .map(|x| Ok(Path::parse(x.prefix)?))
+            .collect::<Result<_>>()?;
+
+        let objects = value
+            .contents
+            .into_iter()
+            .map(TryFrom::try_from)
+            .collect::<Result<_>>()?;
+
+        Ok(Self {
+            common_prefixes,
+            objects,
+        })
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct ListPrefix {
+    pub prefix: String,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct ListContents {
+    pub key: String,
+    pub size: usize,
+    pub last_modified: DateTime<Utc>,
+    #[serde(rename = "ETag")]
+    pub e_tag: Option<String>,
+}
+
+impl TryFrom<ListContents> for ObjectMeta {
+    type Error = crate::Error;
+
+    fn try_from(value: ListContents) -> Result<Self> {
+        Ok(Self {
+            location: Path::parse(value.key)?,
+            last_modified: value.last_modified,
+            size: value.size,
+            e_tag: value.e_tag,
+            version: None,
+        })
+    }
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct InitiateMultipartUploadResult {
+    pub upload_id: String,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct CompleteMultipartUpload {
+    pub part: Vec<MultipartPart>,
+}
+
+impl From<Vec<PartId>> for CompleteMultipartUpload {
+    fn from(value: Vec<PartId>) -> Self {
+        let part = value
+            .into_iter()
+            .enumerate()
+            .map(|(part_number, part)| MultipartPart {
+                e_tag: part.content_id,
+                part_number: part_number + 1,
+            })
+            .collect();
+        Self { part }
+    }
+}
+
+#[derive(Debug, Serialize)]
+pub struct MultipartPart {
+    #[serde(rename = "ETag")]
+    pub e_tag: String,
+    #[serde(rename = "PartNumber")]
+    pub part_number: usize,
+}
+
+#[derive(Debug, Deserialize)]
+#[serde(rename_all = "PascalCase")]
+pub struct CompleteMultipartUploadResult {
+    #[serde(rename = "ETag")]
+    pub e_tag: String,
+}
diff --git a/object_store/src/client/token.rs b/object_store/src/client/token.rs
index a56a29462b14..7a3c8079449b 100644
--- a/object_store/src/client/token.rs
+++ b/object_store/src/client/token.rs
@@ -16,7 +16,7 @@
 // under the License.
 
 use std::future::Future;
-use std::time::Instant;
+use std::time::{Duration, Instant};
 use tokio::sync::Mutex;
 
 /// A temporary authentication token with an associated expiry
@@ -25,17 +25,34 @@ pub struct TemporaryToken<T> {
     /// The temporary credential
     pub token: T,
     /// The instant at which this credential is no longer valid
-    pub expiry: Instant,
+    /// None means the credential does not expire
+    pub expiry: Option<Instant>,
 }
 
 /// Provides [`TokenCache::get_or_insert_with`] which can be used to cache a
 /// [`TemporaryToken`] based on its expiry
-#[derive(Debug, Default)]
+#[derive(Debug)]
 pub struct TokenCache<T> {
     cache: Mutex<Option<TemporaryToken<T>>>,
+    min_ttl: Duration,
+}
+
+impl<T> Default for TokenCache<T> {
+    fn default() -> Self {
+        Self {
+            cache: Default::default(),
+            min_ttl: Duration::from_secs(300),
+        }
+    }
 }
 
 impl<T: Clone + Send> TokenCache<T> {
+    /// Override the minimum remaining TTL for a cached token to be used
+    #[cfg(feature = "aws")]
+    pub fn with_min_ttl(self, min_ttl: Duration) -> Self {
+        Self { min_ttl, ..self }
+    }
+
     pub async fn get_or_insert_with<F, Fut, E>(&self, f: F) -> Result<T, E>
     where
         F: FnOnce() -> Fut + Send,
@@ -45,13 +62,12 @@ impl<T: Clone + Send> TokenCache<T> {
         let mut locked = self.cache.lock().await;
 
         if let Some(cached) = locked.as_ref() {
-            let delta = cached
-                .expiry
-                .checked_duration_since(now)
-                .unwrap_or_default();
-
-            if delta.as_secs() > 300 {
-                return Ok(cached.token.clone());
+            match cached.expiry {
+                Some(ttl) if ttl.checked_duration_since(now).unwrap_or_default() > self.min_ttl => {
+                    return Ok(cached.token.clone());
+                }
+                None => return Ok(cached.token.clone()),
+                _ => (),
             }
         }
 
diff --git a/object_store/src/config.rs b/object_store/src/config.rs
new file mode 100644
index 000000000000..987e6e420eb3
--- /dev/null
+++ b/object_store/src/config.rs
@@ -0,0 +1,134 @@
+// 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.
+use std::fmt::{Debug, Display, Formatter};
+use std::str::FromStr;
+use std::time::Duration;
+
+use humantime::{format_duration, parse_duration};
+use reqwest::header::HeaderValue;
+
+use crate::{Error, Result};
+
+/// Provides deferred parsing of a value
+///
+/// This allows builders to defer fallibility to build
+#[derive(Debug, Clone)]
+pub enum ConfigValue<T> {
+    Parsed(T),
+    Deferred(String),
+}
+
+impl<T: Display> Display for ConfigValue<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Parsed(v) => write!(f, "{v}"),
+            Self::Deferred(v) => write!(f, "{v}"),
+        }
+    }
+}
+
+impl<T> From<T> for ConfigValue<T> {
+    fn from(value: T) -> Self {
+        Self::Parsed(value)
+    }
+}
+
+impl<T: Parse + Clone> ConfigValue<T> {
+    pub fn parse(&mut self, v: impl Into<String>) {
+        *self = Self::Deferred(v.into())
+    }
+
+    pub fn get(&self) -> Result<T> {
+        match self {
+            Self::Parsed(v) => Ok(v.clone()),
+            Self::Deferred(v) => T::parse(v),
+        }
+    }
+}
+
+impl<T: Default> Default for ConfigValue<T> {
+    fn default() -> Self {
+        Self::Parsed(T::default())
+    }
+}
+
+/// A value that can be stored in [`ConfigValue`]
+pub trait Parse: Sized {
+    fn parse(v: &str) -> Result<Self>;
+}
+
+impl Parse for bool {
+    fn parse(v: &str) -> Result<Self> {
+        let lower = v.to_ascii_lowercase();
+        match lower.as_str() {
+            "1" | "true" | "on" | "yes" | "y" => Ok(true),
+            "0" | "false" | "off" | "no" | "n" => Ok(false),
+            _ => Err(Error::Generic {
+                store: "Config",
+                source: format!("failed to parse \"{v}\" as boolean").into(),
+            }),
+        }
+    }
+}
+
+impl Parse for Duration {
+    fn parse(v: &str) -> Result<Self> {
+        parse_duration(v).map_err(|_| Error::Generic {
+            store: "Config",
+            source: format!("failed to parse \"{v}\" as Duration").into(),
+        })
+    }
+}
+
+impl Parse for usize {
+    fn parse(v: &str) -> Result<Self> {
+        Self::from_str(v).map_err(|_| Error::Generic {
+            store: "Config",
+            source: format!("failed to parse \"{v}\" as usize").into(),
+        })
+    }
+}
+
+impl Parse for HeaderValue {
+    fn parse(v: &str) -> Result<Self> {
+        Self::from_str(v).map_err(|_| Error::Generic {
+            store: "Config",
+            source: format!("failed to parse \"{v}\" as HeaderValue").into(),
+        })
+    }
+}
+
+pub(crate) fn fmt_duration(duration: &ConfigValue<Duration>) -> String {
+    match duration {
+        ConfigValue::Parsed(v) => format_duration(*v).to_string(),
+        ConfigValue::Deferred(v) => v.clone(),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::time::Duration;
+
+    #[test]
+    fn test_parse_duration() {
+        let duration = Duration::from_secs(60);
+        assert_eq!(Duration::parse("60 seconds").unwrap(), duration);
+        assert_eq!(Duration::parse("60 s").unwrap(), duration);
+        assert_eq!(Duration::parse("60s").unwrap(), duration)
+    }
+}
diff --git a/object_store/src/delimited.rs b/object_store/src/delimited.rs
new file mode 100644
index 000000000000..4f25c9d6d313
--- /dev/null
+++ b/object_store/src/delimited.rs
@@ -0,0 +1,269 @@
+// 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.
+
+//! Utility for streaming newline delimited files from object storage
+
+use std::collections::VecDeque;
+
+use bytes::Bytes;
+use futures::{Stream, StreamExt};
+use snafu::{ensure, Snafu};
+
+use super::Result;
+
+#[derive(Debug, Snafu)]
+enum Error {
+    #[snafu(display("encountered unterminated string"))]
+    UnterminatedString,
+
+    #[snafu(display("encountered trailing escape character"))]
+    TrailingEscape,
+}
+
+impl From<Error> for super::Error {
+    fn from(err: Error) -> Self {
+        Self::Generic {
+            store: "LineDelimiter",
+            source: Box::new(err),
+        }
+    }
+}
+
+/// The ASCII encoding of `"`
+const QUOTE: u8 = b'"';
+
+/// The ASCII encoding of `\n`
+const NEWLINE: u8 = b'\n';
+
+/// The ASCII encoding of `\`
+const ESCAPE: u8 = b'\\';
+
+/// [`LineDelimiter`] is provided with a stream of [`Bytes`] and returns an iterator
+/// of [`Bytes`] containing a whole number of new line delimited records
+#[derive(Debug, Default)]
+struct LineDelimiter {
+    /// Complete chunks of [`Bytes`]
+    complete: VecDeque<Bytes>,
+    /// Remainder bytes that form the next record
+    remainder: Vec<u8>,
+    /// True if the last character was the escape character
+    is_escape: bool,
+    /// True if currently processing a quoted string
+    is_quote: bool,
+}
+
+impl LineDelimiter {
+    /// Creates a new [`LineDelimiter`] with the provided delimiter
+    fn new() -> Self {
+        Self::default()
+    }
+
+    /// Adds the next set of [`Bytes`]
+    fn push(&mut self, val: impl Into<Bytes>) {
+        let val: Bytes = val.into();
+
+        let is_escape = &mut self.is_escape;
+        let is_quote = &mut self.is_quote;
+        let mut record_ends = val.iter().enumerate().filter_map(|(idx, v)| {
+            if *is_escape {
+                *is_escape = false;
+                None
+            } else if *v == ESCAPE {
+                *is_escape = true;
+                None
+            } else if *v == QUOTE {
+                *is_quote = !*is_quote;
+                None
+            } else if *is_quote {
+                None
+            } else {
+                (*v == NEWLINE).then_some(idx + 1)
+            }
+        });
+
+        let start_offset = match self.remainder.is_empty() {
+            true => 0,
+            false => match record_ends.next() {
+                Some(idx) => {
+                    self.remainder.extend_from_slice(&val[0..idx]);
+                    self.complete
+                        .push_back(Bytes::from(std::mem::take(&mut self.remainder)));
+                    idx
+                }
+                None => {
+                    self.remainder.extend_from_slice(&val);
+                    return;
+                }
+            },
+        };
+        let end_offset = record_ends.last().unwrap_or(start_offset);
+        if start_offset != end_offset {
+            self.complete.push_back(val.slice(start_offset..end_offset));
+        }
+
+        if end_offset != val.len() {
+            self.remainder.extend_from_slice(&val[end_offset..])
+        }
+    }
+
+    /// Marks the end of the stream, delimiting any remaining bytes
+    ///
+    /// Returns `true` if there is no remaining data to be read
+    fn finish(&mut self) -> Result<bool> {
+        if !self.remainder.is_empty() {
+            ensure!(!self.is_quote, UnterminatedStringSnafu);
+            ensure!(!self.is_quote, TrailingEscapeSnafu);
+
+            self.complete
+                .push_back(Bytes::from(std::mem::take(&mut self.remainder)))
+        }
+        Ok(self.complete.is_empty())
+    }
+}
+
+impl Iterator for LineDelimiter {
+    type Item = Bytes;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.complete.pop_front()
+    }
+}
+
+/// Given a [`Stream`] of [`Bytes`] returns a [`Stream`] where each
+/// yielded [`Bytes`] contains a whole number of new line delimited records
+/// accounting for `\` style escapes and `"` quotes
+pub fn newline_delimited_stream<S>(s: S) -> impl Stream<Item = Result<Bytes>>
+where
+    S: Stream<Item = Result<Bytes>> + Unpin,
+{
+    let delimiter = LineDelimiter::new();
+
+    futures::stream::unfold(
+        (s, delimiter, false),
+        |(mut s, mut delimiter, mut exhausted)| async move {
+            loop {
+                if let Some(next) = delimiter.next() {
+                    return Some((Ok(next), (s, delimiter, exhausted)));
+                } else if exhausted {
+                    return None;
+                }
+
+                match s.next().await {
+                    Some(Ok(bytes)) => delimiter.push(bytes),
+                    Some(Err(e)) => return Some((Err(e), (s, delimiter, exhausted))),
+                    None => {
+                        exhausted = true;
+                        match delimiter.finish() {
+                            Ok(true) => return None,
+                            Ok(false) => continue,
+                            Err(e) => return Some((Err(e), (s, delimiter, exhausted))),
+                        }
+                    }
+                }
+            }
+        },
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use futures::stream::{BoxStream, TryStreamExt};
+
+    use super::*;
+
+    #[test]
+    fn test_delimiter() {
+        let mut delimiter = LineDelimiter::new();
+        delimiter.push("hello\nworld");
+        delimiter.push("\n\n");
+
+        assert_eq!(delimiter.next().unwrap(), Bytes::from("hello\n"));
+        assert_eq!(delimiter.next().unwrap(), Bytes::from("world\n"));
+        assert_eq!(delimiter.next().unwrap(), Bytes::from("\n"));
+        assert!(delimiter.next().is_none());
+    }
+
+    #[test]
+    fn test_delimiter_escaped() {
+        let mut delimiter = LineDelimiter::new();
+        delimiter.push("");
+        delimiter.push("fo\\\n\"foo");
+        delimiter.push("bo\n\"bar\n");
+        delimiter.push("\"he");
+        delimiter.push("llo\"\n");
+        assert_eq!(
+            delimiter.next().unwrap(),
+            Bytes::from("fo\\\n\"foobo\n\"bar\n")
+        );
+        assert_eq!(delimiter.next().unwrap(), Bytes::from("\"hello\"\n"));
+        assert!(delimiter.next().is_none());
+
+        // Verify can push further data
+        delimiter.push("\"foo\nbar\",\"fiz\\\"inner\\\"\"\nhello");
+        assert!(!delimiter.finish().unwrap());
+
+        assert_eq!(
+            delimiter.next().unwrap(),
+            Bytes::from("\"foo\nbar\",\"fiz\\\"inner\\\"\"\n")
+        );
+        assert_eq!(delimiter.next().unwrap(), Bytes::from("hello"));
+        assert!(delimiter.finish().unwrap());
+        assert!(delimiter.next().is_none());
+    }
+
+    #[tokio::test]
+    async fn test_delimiter_stream() {
+        let input = vec!["hello\nworld\nbin", "go\ncup", "cakes"];
+        let input_stream = futures::stream::iter(input.into_iter().map(|s| Ok(Bytes::from(s))));
+        let stream = newline_delimited_stream(input_stream);
+
+        let results: Vec<_> = stream.try_collect().await.unwrap();
+        assert_eq!(
+            results,
+            vec![
+                Bytes::from("hello\nworld\n"),
+                Bytes::from("bingo\n"),
+                Bytes::from("cupcakes")
+            ]
+        )
+    }
+    #[tokio::test]
+    async fn test_delimiter_unfold_stream() {
+        let input_stream: BoxStream<'static, Result<Bytes>> = futures::stream::unfold(
+            VecDeque::from(["hello\nworld\nbin", "go\ncup", "cakes"]),
+            |mut input| async move {
+                if !input.is_empty() {
+                    Some((Ok(Bytes::from(input.pop_front().unwrap())), input))
+                } else {
+                    None
+                }
+            },
+        )
+        .boxed();
+        let stream = newline_delimited_stream(input_stream);
+
+        let results: Vec<_> = stream.try_collect().await.unwrap();
+        assert_eq!(
+            results,
+            vec![
+                Bytes::from("hello\nworld\n"),
+                Bytes::from("bingo\n"),
+                Bytes::from("cupcakes")
+            ]
+        )
+    }
+}
diff --git a/object_store/src/gcp.rs b/object_store/src/gcp.rs
deleted file mode 100644
index 0dc5a956ac08..000000000000
--- a/object_store/src/gcp.rs
+++ /dev/null
@@ -1,1106 +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.
-
-//! An object store implementation for Google Cloud Storage
-//!
-//! ## Multi-part uploads
-//!
-//! [Multi-part uploads](https://cloud.google.com/storage/docs/multipart-uploads)
-//! can be initiated with the [ObjectStore::put_multipart] method.
-//! Data passed to the writer is automatically buffered to meet the minimum size
-//! requirements for a part. Multiple parts are uploaded concurrently.
-//!
-//! If the writer fails for any reason, you may have parts uploaded to GCS but not
-//! used that you may be charged for. Use the [ObjectStore::abort_multipart] method
-//! to abort the upload and drop those unneeded parts. In addition, you may wish to
-//! consider implementing automatic clean up of unused parts that are older than one
-//! week.
-use std::collections::BTreeSet;
-use std::fs::File;
-use std::io::{self, BufReader};
-use std::ops::Range;
-use std::sync::Arc;
-
-use async_trait::async_trait;
-use bytes::{Buf, Bytes};
-use chrono::{DateTime, Utc};
-use futures::future::BoxFuture;
-use futures::{stream::BoxStream, StreamExt, TryStreamExt};
-use percent_encoding::{percent_encode, NON_ALPHANUMERIC};
-use reqwest::header::RANGE;
-use reqwest::{header, Client, Method, Response, StatusCode};
-use snafu::{ResultExt, Snafu};
-use tokio::io::AsyncWrite;
-
-use crate::client::retry::RetryExt;
-use crate::{
-    client::{oauth::OAuthProvider, token::TokenCache},
-    multipart::{CloudMultiPartUpload, CloudMultiPartUploadImpl, UploadPart},
-    path::{Path, DELIMITER},
-    util::{format_http_range, format_prefix},
-    GetResult, ListResult, MultipartId, ObjectMeta, ObjectStore, Result, RetryConfig,
-};
-
-#[derive(Debug, Snafu)]
-enum Error {
-    #[snafu(display("Unable to open service account file: {}", source))]
-    OpenCredentials { source: std::io::Error },
-
-    #[snafu(display("Unable to decode service account file: {}", source))]
-    DecodeCredentials { source: serde_json::Error },
-
-    #[snafu(display("Got invalid XML response for {} {}: {}", method, url, source))]
-    InvalidXMLResponse {
-        source: quick_xml::de::DeError,
-        method: String,
-        url: String,
-        data: Bytes,
-    },
-
-    #[snafu(display("Error performing list request: {}", source))]
-    ListRequest { source: reqwest::Error },
-
-    #[snafu(display("Error performing get request {}: {}", path, source))]
-    GetRequest {
-        source: reqwest::Error,
-        path: String,
-    },
-
-    #[snafu(display("Error performing delete request {}: {}", path, source))]
-    DeleteRequest {
-        source: reqwest::Error,
-        path: String,
-    },
-
-    #[snafu(display("Error performing copy request {}: {}", path, source))]
-    CopyRequest {
-        source: reqwest::Error,
-        path: String,
-    },
-
-    #[snafu(display("Error performing put request: {}", source))]
-    PutRequest { source: reqwest::Error },
-
-    #[snafu(display("Error decoding object size: {}", source))]
-    InvalidSize { source: std::num::ParseIntError },
-
-    #[snafu(display("Missing bucket name"))]
-    MissingBucketName {},
-
-    #[snafu(display("Missing service account path"))]
-    MissingServiceAccountPath,
-}
-
-impl From<Error> for super::Error {
-    fn from(err: Error) -> Self {
-        match err {
-            Error::GetRequest { source, path }
-            | Error::DeleteRequest { source, path }
-            | Error::CopyRequest { source, path }
-                if matches!(source.status(), Some(StatusCode::NOT_FOUND)) =>
-            {
-                Self::NotFound {
-                    path,
-                    source: Box::new(source),
-                }
-            }
-            _ => Self::Generic {
-                store: "GCS",
-                source: Box::new(err),
-            },
-        }
-    }
-}
-
-/// A deserialized `service-account-********.json`-file.
-#[derive(serde::Deserialize, Debug)]
-struct ServiceAccountCredentials {
-    /// The private key in RSA format.
-    pub private_key: String,
-
-    /// The email address associated with the service account.
-    pub client_email: String,
-
-    /// Base URL for GCS
-    #[serde(default = "default_gcs_base_url")]
-    pub gcs_base_url: String,
-
-    /// Disable oauth and use empty tokens.
-    #[serde(default = "default_disable_oauth")]
-    pub disable_oauth: bool,
-}
-
-fn default_gcs_base_url() -> String {
-    "https://storage.googleapis.com".to_owned()
-}
-
-fn default_disable_oauth() -> bool {
-    false
-}
-
-#[derive(serde::Deserialize, Debug)]
-#[serde(rename_all = "camelCase")]
-struct ListResponse {
-    next_page_token: Option<String>,
-    #[serde(default)]
-    prefixes: Vec<String>,
-    #[serde(default)]
-    items: Vec<Object>,
-}
-
-#[derive(serde::Deserialize, Debug)]
-struct Object {
-    name: String,
-    size: String,
-    updated: DateTime<Utc>,
-}
-
-#[derive(serde::Deserialize, Debug)]
-#[serde(rename_all = "PascalCase")]
-struct InitiateMultipartUploadResult {
-    upload_id: String,
-}
-
-#[derive(serde::Serialize, Debug)]
-#[serde(rename_all = "PascalCase", rename(serialize = "Part"))]
-struct MultipartPart {
-    #[serde(rename = "$unflatten=PartNumber")]
-    part_number: usize,
-    #[serde(rename = "$unflatten=ETag")]
-    e_tag: String,
-}
-
-#[derive(serde::Serialize, Debug)]
-#[serde(rename_all = "PascalCase")]
-struct CompleteMultipartUpload {
-    #[serde(rename = "Part", default)]
-    parts: Vec<MultipartPart>,
-}
-
-/// Interface for [Google Cloud Storage](https://cloud.google.com/storage/).
-#[derive(Debug)]
-pub struct GoogleCloudStorage {
-    client: Arc<GoogleCloudStorageClient>,
-}
-
-impl std::fmt::Display for GoogleCloudStorage {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        write!(f, "GoogleCloudStorage({})", self.client.bucket_name)
-    }
-}
-
-#[derive(Debug)]
-struct GoogleCloudStorageClient {
-    client: Client,
-    base_url: String,
-
-    oauth_provider: Option<OAuthProvider>,
-    token_cache: TokenCache<String>,
-
-    bucket_name: String,
-    bucket_name_encoded: String,
-
-    retry_config: RetryConfig,
-
-    // TODO: Hook this up in tests
-    max_list_results: Option<String>,
-}
-
-impl GoogleCloudStorageClient {
-    async fn get_token(&self) -> Result<String> {
-        if let Some(oauth_provider) = &self.oauth_provider {
-            Ok(self
-                .token_cache
-                .get_or_insert_with(|| {
-                    oauth_provider.fetch_token(&self.client, &self.retry_config)
-                })
-                .await?)
-        } else {
-            Ok("".to_owned())
-        }
-    }
-
-    fn object_url(&self, path: &Path) -> String {
-        let encoded =
-            percent_encoding::utf8_percent_encode(path.as_ref(), NON_ALPHANUMERIC);
-        format!(
-            "{}/storage/v1/b/{}/o/{}",
-            self.base_url, self.bucket_name_encoded, encoded
-        )
-    }
-
-    /// Perform a get request <https://cloud.google.com/storage/docs/json_api/v1/objects/get>
-    async fn get_request(
-        &self,
-        path: &Path,
-        range: Option<Range<usize>>,
-        head: bool,
-    ) -> Result<Response> {
-        let token = self.get_token().await?;
-        let url = self.object_url(path);
-
-        let mut builder = self.client.request(Method::GET, url);
-
-        if let Some(range) = range {
-            builder = builder.header(RANGE, format_http_range(range));
-        }
-
-        let alt = match head {
-            true => "json",
-            false => "media",
-        };
-
-        let response = builder
-            .bearer_auth(token)
-            .query(&[("alt", alt)])
-            .send_retry(&self.retry_config)
-            .await
-            .context(GetRequestSnafu {
-                path: path.as_ref(),
-            })?
-            .error_for_status()
-            .context(GetRequestSnafu {
-                path: path.as_ref(),
-            })?;
-
-        Ok(response)
-    }
-
-    /// Perform a put request <https://cloud.google.com/storage/docs/json_api/v1/objects/insert>
-    async fn put_request(&self, path: &Path, payload: Bytes) -> Result<()> {
-        let token = self.get_token().await?;
-        let url = format!(
-            "{}/upload/storage/v1/b/{}/o",
-            self.base_url, self.bucket_name_encoded
-        );
-
-        self.client
-            .request(Method::POST, url)
-            .bearer_auth(token)
-            .header(header::CONTENT_TYPE, "application/octet-stream")
-            .header(header::CONTENT_LENGTH, payload.len())
-            .query(&[("uploadType", "media"), ("name", path.as_ref())])
-            .body(payload)
-            .send_retry(&self.retry_config)
-            .await
-            .context(PutRequestSnafu)?
-            .error_for_status()
-            .context(PutRequestSnafu)?;
-
-        Ok(())
-    }
-
-    /// Initiate a multi-part upload <https://cloud.google.com/storage/docs/xml-api/post-object-multipart>
-    async fn multipart_initiate(&self, path: &Path) -> Result<MultipartId> {
-        let token = self.get_token().await?;
-        let url = format!("{}/{}/{}", self.base_url, self.bucket_name_encoded, path);
-
-        let response = self
-            .client
-            .request(Method::POST, &url)
-            .bearer_auth(token)
-            .header(header::CONTENT_TYPE, "application/octet-stream")
-            .header(header::CONTENT_LENGTH, "0")
-            .query(&[("uploads", "")])
-            .send_retry(&self.retry_config)
-            .await
-            .context(PutRequestSnafu)?
-            .error_for_status()
-            .context(PutRequestSnafu)?;
-
-        let data = response.bytes().await.context(PutRequestSnafu)?;
-        let result: InitiateMultipartUploadResult = quick_xml::de::from_reader(
-            data.as_ref().reader(),
-        )
-        .context(InvalidXMLResponseSnafu {
-            method: "POST".to_string(),
-            url,
-            data,
-        })?;
-
-        Ok(result.upload_id)
-    }
-
-    /// Cleanup unused parts <https://cloud.google.com/storage/docs/xml-api/delete-multipart>
-    async fn multipart_cleanup(
-        &self,
-        path: &str,
-        multipart_id: &MultipartId,
-    ) -> Result<()> {
-        let token = self.get_token().await?;
-        let url = format!("{}/{}/{}", self.base_url, self.bucket_name_encoded, path);
-
-        self.client
-            .request(Method::DELETE, &url)
-            .bearer_auth(token)
-            .header(header::CONTENT_TYPE, "application/octet-stream")
-            .header(header::CONTENT_LENGTH, "0")
-            .query(&[("uploadId", multipart_id)])
-            .send_retry(&self.retry_config)
-            .await
-            .context(PutRequestSnafu)?
-            .error_for_status()
-            .context(PutRequestSnafu)?;
-
-        Ok(())
-    }
-
-    /// Perform a delete request <https://cloud.google.com/storage/docs/json_api/v1/objects/delete>
-    async fn delete_request(&self, path: &Path) -> Result<()> {
-        let token = self.get_token().await?;
-        let url = self.object_url(path);
-
-        let builder = self.client.request(Method::DELETE, url);
-        builder
-            .bearer_auth(token)
-            .send_retry(&self.retry_config)
-            .await
-            .context(DeleteRequestSnafu {
-                path: path.as_ref(),
-            })?
-            .error_for_status()
-            .context(DeleteRequestSnafu {
-                path: path.as_ref(),
-            })?;
-
-        Ok(())
-    }
-
-    /// Perform a copy request <https://cloud.google.com/storage/docs/json_api/v1/objects/copy>
-    async fn copy_request(
-        &self,
-        from: &Path,
-        to: &Path,
-        if_not_exists: bool,
-    ) -> Result<()> {
-        let token = self.get_token().await?;
-
-        let source =
-            percent_encoding::utf8_percent_encode(from.as_ref(), NON_ALPHANUMERIC);
-        let destination =
-            percent_encoding::utf8_percent_encode(to.as_ref(), NON_ALPHANUMERIC);
-        let url = format!(
-            "{}/storage/v1/b/{}/o/{}/copyTo/b/{}/o/{}",
-            self.base_url,
-            self.bucket_name_encoded,
-            source,
-            self.bucket_name_encoded,
-            destination
-        );
-
-        let mut builder = self.client.request(Method::POST, url);
-
-        if if_not_exists {
-            builder = builder.query(&[("ifGenerationMatch", "0")]);
-        }
-
-        builder
-            .bearer_auth(token)
-            .send_retry(&self.retry_config)
-            .await
-            .context(CopyRequestSnafu {
-                path: from.as_ref(),
-            })?
-            .error_for_status()
-            .context(CopyRequestSnafu {
-                path: from.as_ref(),
-            })?;
-
-        Ok(())
-    }
-
-    /// Perform a list request <https://cloud.google.com/storage/docs/json_api/v1/objects/list>
-    async fn list_request(
-        &self,
-        prefix: Option<&str>,
-        delimiter: bool,
-        page_token: Option<&str>,
-    ) -> Result<ListResponse> {
-        let token = self.get_token().await?;
-
-        let url = format!(
-            "{}/storage/v1/b/{}/o",
-            self.base_url, self.bucket_name_encoded
-        );
-
-        let mut query = Vec::with_capacity(4);
-        if delimiter {
-            query.push(("delimiter", DELIMITER))
-        }
-
-        if let Some(prefix) = &prefix {
-            query.push(("prefix", prefix))
-        }
-
-        if let Some(page_token) = page_token {
-            query.push(("pageToken", page_token))
-        }
-
-        if let Some(max_results) = &self.max_list_results {
-            query.push(("maxResults", max_results))
-        }
-
-        let response: ListResponse = self
-            .client
-            .request(Method::GET, url)
-            .query(&query)
-            .bearer_auth(token)
-            .send_retry(&self.retry_config)
-            .await
-            .context(ListRequestSnafu)?
-            .error_for_status()
-            .context(ListRequestSnafu)?
-            .json()
-            .await
-            .context(ListRequestSnafu)?;
-
-        Ok(response)
-    }
-
-    /// Perform a list operation automatically handling pagination
-    fn list_paginated(
-        &self,
-        prefix: Option<&Path>,
-        delimiter: bool,
-    ) -> Result<BoxStream<'_, Result<ListResponse>>> {
-        let prefix = format_prefix(prefix);
-
-        enum ListState {
-            Start,
-            HasMore(String),
-            Done,
-        }
-
-        Ok(futures::stream::unfold(ListState::Start, move |state| {
-            let prefix = prefix.clone();
-
-            async move {
-                let page_token = match &state {
-                    ListState::Start => None,
-                    ListState::HasMore(page_token) => Some(page_token.as_str()),
-                    ListState::Done => {
-                        return None;
-                    }
-                };
-
-                let resp = match self
-                    .list_request(prefix.as_deref(), delimiter, page_token)
-                    .await
-                {
-                    Ok(resp) => resp,
-                    Err(e) => return Some((Err(e), state)),
-                };
-
-                let next_state = match &resp.next_page_token {
-                    Some(token) => ListState::HasMore(token.clone()),
-                    None => ListState::Done,
-                };
-
-                Some((Ok(resp), next_state))
-            }
-        })
-        .boxed())
-    }
-}
-
-fn reqwest_error_as_io(err: reqwest::Error) -> io::Error {
-    if err.is_builder() || err.is_request() {
-        io::Error::new(io::ErrorKind::InvalidInput, err)
-    } else if err.is_status() {
-        match err.status() {
-            Some(StatusCode::NOT_FOUND) => io::Error::new(io::ErrorKind::NotFound, err),
-            Some(StatusCode::BAD_REQUEST) => {
-                io::Error::new(io::ErrorKind::InvalidInput, err)
-            }
-            Some(_) => io::Error::new(io::ErrorKind::Other, err),
-            None => io::Error::new(io::ErrorKind::Other, err),
-        }
-    } else if err.is_timeout() {
-        io::Error::new(io::ErrorKind::TimedOut, err)
-    } else if err.is_connect() {
-        io::Error::new(io::ErrorKind::NotConnected, err)
-    } else {
-        io::Error::new(io::ErrorKind::Other, err)
-    }
-}
-
-struct GCSMultipartUpload {
-    client: Arc<GoogleCloudStorageClient>,
-    encoded_path: String,
-    multipart_id: MultipartId,
-}
-
-impl CloudMultiPartUploadImpl for GCSMultipartUpload {
-    /// Upload an object part <https://cloud.google.com/storage/docs/xml-api/put-object-multipart>
-    fn put_multipart_part(
-        &self,
-        buf: Vec<u8>,
-        part_idx: usize,
-    ) -> BoxFuture<'static, Result<(usize, UploadPart), io::Error>> {
-        let upload_id = self.multipart_id.clone();
-        let url = format!(
-            "{}/{}/{}",
-            self.client.base_url, self.client.bucket_name_encoded, self.encoded_path
-        );
-        let client = Arc::clone(&self.client);
-
-        Box::pin(async move {
-            let token = client
-                .get_token()
-                .await
-                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
-
-            let response = client
-                .client
-                .request(Method::PUT, &url)
-                .bearer_auth(token)
-                .query(&[
-                    ("partNumber", format!("{}", part_idx + 1)),
-                    ("uploadId", upload_id),
-                ])
-                .header(header::CONTENT_TYPE, "application/octet-stream")
-                .header(header::CONTENT_LENGTH, format!("{}", buf.len()))
-                .body(buf)
-                .send_retry(&client.retry_config)
-                .await
-                .map_err(reqwest_error_as_io)?
-                .error_for_status()
-                .map_err(reqwest_error_as_io)?;
-
-            let content_id = response
-                .headers()
-                .get("ETag")
-                .ok_or_else(|| {
-                    io::Error::new(
-                        io::ErrorKind::InvalidData,
-                        "response headers missing ETag",
-                    )
-                })?
-                .to_str()
-                .map_err(|err| io::Error::new(io::ErrorKind::InvalidData, err))?
-                .to_string();
-
-            Ok((part_idx, UploadPart { content_id }))
-        })
-    }
-
-    /// Complete a multipart upload <https://cloud.google.com/storage/docs/xml-api/post-object-complete>
-    fn complete(
-        &self,
-        completed_parts: Vec<Option<UploadPart>>,
-    ) -> BoxFuture<'static, Result<(), io::Error>> {
-        let client = Arc::clone(&self.client);
-        let upload_id = self.multipart_id.clone();
-        let url = format!(
-            "{}/{}/{}",
-            self.client.base_url, self.client.bucket_name_encoded, self.encoded_path
-        );
-
-        Box::pin(async move {
-            let parts: Vec<MultipartPart> = completed_parts
-                .into_iter()
-                .enumerate()
-                .map(|(part_number, maybe_part)| match maybe_part {
-                    Some(part) => Ok(MultipartPart {
-                        e_tag: part.content_id,
-                        part_number: part_number + 1,
-                    }),
-                    None => Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        format!("Missing information for upload part {:?}", part_number),
-                    )),
-                })
-                .collect::<Result<Vec<MultipartPart>, io::Error>>()?;
-
-            let token = client
-                .get_token()
-                .await
-                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?;
-
-            let upload_info = CompleteMultipartUpload { parts };
-
-            let data = quick_xml::se::to_string(&upload_info)
-                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?
-                // We cannot disable the escaping that transforms "/" to "&quote;" :(
-                // https://github.com/tafia/quick-xml/issues/362
-                // https://github.com/tafia/quick-xml/issues/350
-                .replace("&quot;", "\"");
-
-            client
-                .client
-                .request(Method::POST, &url)
-                .bearer_auth(token)
-                .query(&[("uploadId", upload_id)])
-                .body(data)
-                .send_retry(&client.retry_config)
-                .await
-                .map_err(reqwest_error_as_io)?
-                .error_for_status()
-                .map_err(reqwest_error_as_io)?;
-
-            Ok(())
-        })
-    }
-}
-
-#[async_trait]
-impl ObjectStore for GoogleCloudStorage {
-    async fn put(&self, location: &Path, bytes: Bytes) -> Result<()> {
-        self.client.put_request(location, bytes).await
-    }
-
-    async fn put_multipart(
-        &self,
-        location: &Path,
-    ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
-        let upload_id = self.client.multipart_initiate(location).await?;
-
-        let encoded_path =
-            percent_encode(location.to_string().as_bytes(), NON_ALPHANUMERIC).to_string();
-
-        let inner = GCSMultipartUpload {
-            client: Arc::clone(&self.client),
-            encoded_path,
-            multipart_id: upload_id.clone(),
-        };
-
-        Ok((upload_id, Box::new(CloudMultiPartUpload::new(inner, 8))))
-    }
-
-    async fn abort_multipart(
-        &self,
-        location: &Path,
-        multipart_id: &MultipartId,
-    ) -> Result<()> {
-        self.client
-            .multipart_cleanup(location.as_ref(), multipart_id)
-            .await?;
-
-        Ok(())
-    }
-
-    async fn get(&self, location: &Path) -> Result<GetResult> {
-        let response = self.client.get_request(location, None, false).await?;
-        let stream = response
-            .bytes_stream()
-            .map_err(|source| crate::Error::Generic {
-                store: "GCS",
-                source: Box::new(source),
-            })
-            .boxed();
-
-        Ok(GetResult::Stream(stream))
-    }
-
-    async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes> {
-        let response = self
-            .client
-            .get_request(location, Some(range), false)
-            .await?;
-        Ok(response.bytes().await.context(GetRequestSnafu {
-            path: location.as_ref(),
-        })?)
-    }
-
-    async fn head(&self, location: &Path) -> Result<ObjectMeta> {
-        let response = self.client.get_request(location, None, true).await?;
-        let object = response.json().await.context(GetRequestSnafu {
-            path: location.as_ref(),
-        })?;
-        convert_object_meta(&object)
-    }
-
-    async fn delete(&self, location: &Path) -> Result<()> {
-        self.client.delete_request(location).await
-    }
-
-    async fn list(
-        &self,
-        prefix: Option<&Path>,
-    ) -> Result<BoxStream<'_, Result<ObjectMeta>>> {
-        let stream = self
-            .client
-            .list_paginated(prefix, false)?
-            .map_ok(|r| {
-                futures::stream::iter(
-                    r.items.into_iter().map(|x| convert_object_meta(&x)),
-                )
-            })
-            .try_flatten()
-            .boxed();
-
-        Ok(stream)
-    }
-
-    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
-        let mut stream = self.client.list_paginated(prefix, true)?;
-
-        let mut common_prefixes = BTreeSet::new();
-        let mut objects = Vec::new();
-
-        while let Some(result) = stream.next().await {
-            let response = result?;
-
-            for p in response.prefixes {
-                common_prefixes.insert(Path::parse(p)?);
-            }
-
-            objects.reserve(response.items.len());
-            for object in &response.items {
-                objects.push(convert_object_meta(object)?);
-            }
-        }
-
-        Ok(ListResult {
-            common_prefixes: common_prefixes.into_iter().collect(),
-            objects,
-        })
-    }
-
-    async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
-        self.client.copy_request(from, to, false).await
-    }
-
-    async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
-        self.client.copy_request(from, to, true).await
-    }
-}
-
-fn reader_credentials_file(
-    service_account_path: impl AsRef<std::path::Path>,
-) -> Result<ServiceAccountCredentials> {
-    let file = File::open(service_account_path).context(OpenCredentialsSnafu)?;
-    let reader = BufReader::new(file);
-    Ok(serde_json::from_reader(reader).context(DecodeCredentialsSnafu)?)
-}
-
-/// Configure a connection to Google Cloud Storage using the specified
-/// credentials.
-///
-/// # Example
-/// ```
-/// # let BUCKET_NAME = "foo";
-/// # let SERVICE_ACCOUNT_PATH = "/tmp/foo.json";
-/// # use object_store::gcp::GoogleCloudStorageBuilder;
-/// let gcs = GoogleCloudStorageBuilder::new()
-///  .with_service_account_path(SERVICE_ACCOUNT_PATH)
-///  .with_bucket_name(BUCKET_NAME)
-///  .build();
-/// ```
-#[derive(Debug, Default)]
-pub struct GoogleCloudStorageBuilder {
-    bucket_name: Option<String>,
-    service_account_path: Option<String>,
-    client: Option<Client>,
-    retry_config: RetryConfig,
-}
-
-impl GoogleCloudStorageBuilder {
-    /// Create a new [`GoogleCloudStorageBuilder`] with default values.
-    pub fn new() -> Self {
-        Default::default()
-    }
-
-    /// Set the bucket name (required)
-    pub fn with_bucket_name(mut self, bucket_name: impl Into<String>) -> Self {
-        self.bucket_name = Some(bucket_name.into());
-        self
-    }
-
-    /// Set the path to the service account file (required). Example
-    /// `"/tmp/gcs.json"`
-    ///
-    /// Example contents of `gcs.json`:
-    ///
-    /// ```json
-    /// {
-    ///    "gcs_base_url": "https://localhost:4443",
-    ///    "disable_oauth": true,
-    ///    "client_email": "",
-    ///    "private_key": ""
-    /// }
-    /// ```
-    pub fn with_service_account_path(
-        mut self,
-        service_account_path: impl Into<String>,
-    ) -> Self {
-        self.service_account_path = Some(service_account_path.into());
-        self
-    }
-
-    /// Set the retry configuration
-    pub fn with_retry(mut self, retry_config: RetryConfig) -> Self {
-        self.retry_config = retry_config;
-        self
-    }
-
-    /// Use the specified http [`Client`] (defaults to [`Client::new`])
-    ///
-    /// This allows you to set custom client options such as allowing
-    /// non secure connections or custom headers.
-    ///
-    /// NOTE: Currently only available in `test`s to facilitate
-    /// testing, to avoid leaking details and preserve our ability to
-    /// make changes to the implementation.
-    #[cfg(test)]
-    pub fn with_client(mut self, client: Client) -> Self {
-        self.client = Some(client);
-        self
-    }
-
-    /// Configure a connection to Google Cloud Storage, returning a
-    /// new [`GoogleCloudStorage`] and consuming `self`
-    pub fn build(self) -> Result<GoogleCloudStorage> {
-        let Self {
-            bucket_name,
-            service_account_path,
-            client,
-            retry_config,
-        } = self;
-
-        let bucket_name = bucket_name.ok_or(Error::MissingBucketName {})?;
-        let service_account_path =
-            service_account_path.ok_or(Error::MissingServiceAccountPath)?;
-        let client = client.unwrap_or_else(Client::new);
-
-        let credentials = reader_credentials_file(service_account_path)?;
-
-        // TODO: https://cloud.google.com/storage/docs/authentication#oauth-scopes
-        let scope = "https://www.googleapis.com/auth/devstorage.full_control";
-        let audience = "https://www.googleapis.com/oauth2/v4/token".to_string();
-
-        let oauth_provider = (!credentials.disable_oauth)
-            .then(|| {
-                OAuthProvider::new(
-                    credentials.client_email,
-                    credentials.private_key,
-                    scope.to_string(),
-                    audience,
-                )
-            })
-            .transpose()?;
-
-        let encoded_bucket_name =
-            percent_encode(bucket_name.as_bytes(), NON_ALPHANUMERIC).to_string();
-
-        // The cloud storage crate currently only supports authentication via
-        // environment variables. Set the environment variable explicitly so
-        // that we can optionally accept command line arguments instead.
-        Ok(GoogleCloudStorage {
-            client: Arc::new(GoogleCloudStorageClient {
-                client,
-                base_url: credentials.gcs_base_url,
-                oauth_provider,
-                token_cache: Default::default(),
-                bucket_name,
-                bucket_name_encoded: encoded_bucket_name,
-                retry_config,
-                max_list_results: None,
-            }),
-        })
-    }
-}
-
-fn convert_object_meta(object: &Object) -> Result<ObjectMeta> {
-    let location = Path::parse(&object.name)?;
-    let last_modified = object.updated;
-    let size = object.size.parse().context(InvalidSizeSnafu)?;
-
-    Ok(ObjectMeta {
-        location,
-        last_modified,
-        size,
-    })
-}
-
-#[cfg(test)]
-mod test {
-    use std::env;
-
-    use bytes::Bytes;
-
-    use crate::{
-        tests::{
-            get_nonexistent_object, list_uses_directories_correctly, list_with_delimiter,
-            put_get_delete_list, rename_and_copy, stream_get,
-        },
-        Error as ObjectStoreError, ObjectStore,
-    };
-
-    use super::*;
-
-    const NON_EXISTENT_NAME: &str = "nonexistentname";
-
-    // Helper macro to skip tests if TEST_INTEGRATION and the GCP environment variables are not set.
-    macro_rules! maybe_skip_integration {
-        () => {{
-            dotenv::dotenv().ok();
-
-            let required_vars = ["OBJECT_STORE_BUCKET", "GOOGLE_SERVICE_ACCOUNT"];
-            let unset_vars: Vec<_> = required_vars
-                .iter()
-                .filter_map(|&name| match env::var(name) {
-                    Ok(_) => None,
-                    Err(_) => Some(name),
-                })
-                .collect();
-            let unset_var_names = unset_vars.join(", ");
-
-            let force = std::env::var("TEST_INTEGRATION");
-
-            if force.is_ok() && !unset_var_names.is_empty() {
-                panic!(
-                    "TEST_INTEGRATION is set, \
-                            but variable(s) {} need to be set",
-                    unset_var_names
-                )
-            } else if force.is_err() {
-                eprintln!(
-                    "skipping Google Cloud integration test - set {}TEST_INTEGRATION to run",
-                    if unset_var_names.is_empty() {
-                        String::new()
-                    } else {
-                        format!("{} and ", unset_var_names)
-                    }
-                );
-                return;
-            } else {
-                GoogleCloudStorageBuilder::new()
-                    .with_bucket_name(
-                        env::var("OBJECT_STORE_BUCKET")
-                            .expect("already checked OBJECT_STORE_BUCKET")
-                    )
-                    .with_service_account_path(
-                        env::var("GOOGLE_SERVICE_ACCOUNT")
-                            .expect("already checked GOOGLE_SERVICE_ACCOUNT")
-                    )
-                    .with_client(
-                        // ignore HTTPS errors in tests so we can use fake-gcs server
-                        Client::builder()
-                            .danger_accept_invalid_certs(true)
-                            .build()
-                            .expect("Error creating http client for testing")
-                    )
-            }
-        }};
-    }
-
-    #[tokio::test]
-    async fn gcs_test() {
-        let integration = maybe_skip_integration!().build().unwrap();
-
-        put_get_delete_list(&integration).await;
-        list_uses_directories_correctly(&integration).await;
-        list_with_delimiter(&integration).await;
-        rename_and_copy(&integration).await;
-        if integration.client.base_url == default_gcs_base_url() {
-            // Fake GCS server does not yet implement XML Multipart uploads
-            // https://github.com/fsouza/fake-gcs-server/issues/852
-            stream_get(&integration).await;
-        }
-    }
-
-    #[tokio::test]
-    async fn gcs_test_get_nonexistent_location() {
-        let integration = maybe_skip_integration!().build().unwrap();
-
-        let location = Path::from_iter([NON_EXISTENT_NAME]);
-
-        let err = integration.get(&location).await.unwrap_err();
-
-        assert!(
-            matches!(err, ObjectStoreError::NotFound { .. }),
-            "unexpected error type: {}",
-            err
-        );
-    }
-
-    #[tokio::test]
-    async fn gcs_test_get_nonexistent_bucket() {
-        let integration = maybe_skip_integration!()
-            .with_bucket_name(NON_EXISTENT_NAME)
-            .build()
-            .unwrap();
-
-        let location = Path::from_iter([NON_EXISTENT_NAME]);
-
-        let err = get_nonexistent_object(&integration, Some(location))
-            .await
-            .unwrap_err();
-
-        assert!(
-            matches!(err, ObjectStoreError::NotFound { .. }),
-            "unexpected error type: {}",
-            err
-        );
-    }
-
-    #[tokio::test]
-    async fn gcs_test_delete_nonexistent_location() {
-        let integration = maybe_skip_integration!().build().unwrap();
-
-        let location = Path::from_iter([NON_EXISTENT_NAME]);
-
-        let err = integration.delete(&location).await.unwrap_err();
-        assert!(
-            matches!(err, ObjectStoreError::NotFound { .. }),
-            "unexpected error type: {}",
-            err
-        );
-    }
-
-    #[tokio::test]
-    async fn gcs_test_delete_nonexistent_bucket() {
-        let integration = maybe_skip_integration!()
-            .with_bucket_name(NON_EXISTENT_NAME)
-            .build()
-            .unwrap();
-
-        let location = Path::from_iter([NON_EXISTENT_NAME]);
-
-        let err = integration.delete(&location).await.unwrap_err();
-        assert!(
-            matches!(err, ObjectStoreError::NotFound { .. }),
-            "unexpected error type: {}",
-            err
-        );
-    }
-
-    #[tokio::test]
-    async fn gcs_test_put_nonexistent_bucket() {
-        let integration = maybe_skip_integration!()
-            .with_bucket_name(NON_EXISTENT_NAME)
-            .build()
-            .unwrap();
-
-        let location = Path::from_iter([NON_EXISTENT_NAME]);
-        let data = Bytes::from("arbitrary data");
-
-        let err = integration
-            .put(&location, data)
-            .await
-            .unwrap_err()
-            .to_string();
-        assert!(
-            err.contains(
-                "Error performing put request: HTTP status client error (404 Not Found)"
-            ),
-            "{}",
-            err
-        )
-    }
-}
diff --git a/object_store/src/gcp/builder.rs b/object_store/src/gcp/builder.rs
new file mode 100644
index 000000000000..14c4257dc6a3
--- /dev/null
+++ b/object_store/src/gcp/builder.rs
@@ -0,0 +1,643 @@
+// 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.
+
+use crate::client::TokenCredentialProvider;
+use crate::gcp::client::{GoogleCloudStorageClient, GoogleCloudStorageConfig};
+use crate::gcp::credential::{
+    ApplicationDefaultCredentials, InstanceCredentialProvider, ServiceAccountCredentials,
+    DEFAULT_GCS_BASE_URL,
+};
+use crate::gcp::{credential, GcpCredential, GcpCredentialProvider, GoogleCloudStorage, STORE};
+use crate::{ClientConfigKey, ClientOptions, Result, RetryConfig, StaticCredentialProvider};
+use serde::{Deserialize, Serialize};
+use snafu::{OptionExt, ResultExt, Snafu};
+use std::str::FromStr;
+use std::sync::Arc;
+use url::Url;
+
+#[derive(Debug, Snafu)]
+enum Error {
+    #[snafu(display("Missing bucket name"))]
+    MissingBucketName {},
+
+    #[snafu(display("One of service account path or service account key may be provided."))]
+    ServiceAccountPathAndKeyProvided,
+
+    #[snafu(display("Unable parse source url. Url: {}, Error: {}", url, source))]
+    UnableToParseUrl {
+        source: url::ParseError,
+        url: String,
+    },
+
+    #[snafu(display(
+        "Unknown url scheme cannot be parsed into storage location: {}",
+        scheme
+    ))]
+    UnknownUrlScheme { scheme: String },
+
+    #[snafu(display("URL did not match any known pattern for scheme: {}", url))]
+    UrlNotRecognised { url: String },
+
+    #[snafu(display("Configuration key: '{}' is not known.", key))]
+    UnknownConfigurationKey { key: String },
+
+    #[snafu(display("Unable to extract metadata from headers: {}", source))]
+    Metadata {
+        source: crate::client::header::Error,
+    },
+
+    #[snafu(display("GCP credential error: {}", source))]
+    Credential { source: credential::Error },
+}
+
+impl From<Error> for crate::Error {
+    fn from(err: Error) -> Self {
+        match err {
+            Error::UnknownConfigurationKey { key } => {
+                Self::UnknownConfigurationKey { store: STORE, key }
+            }
+            _ => Self::Generic {
+                store: STORE,
+                source: Box::new(err),
+            },
+        }
+    }
+}
+
+/// Configure a connection to Google Cloud Storage.
+///
+/// If no credentials are explicitly provided, they will be sourced
+/// from the environment as documented [here](https://cloud.google.com/docs/authentication/application-default-credentials).
+///
+/// # Example
+/// ```
+/// # let BUCKET_NAME = "foo";
+/// # use object_store::gcp::GoogleCloudStorageBuilder;
+/// let gcs = GoogleCloudStorageBuilder::from_env().with_bucket_name(BUCKET_NAME).build();
+/// ```
+#[derive(Debug, Clone)]
+pub struct GoogleCloudStorageBuilder {
+    /// Bucket name
+    bucket_name: Option<String>,
+    /// Url
+    url: Option<String>,
+    /// Path to the service account file
+    service_account_path: Option<String>,
+    /// The serialized service account key
+    service_account_key: Option<String>,
+    /// Path to the application credentials file.
+    application_credentials_path: Option<String>,
+    /// Retry config
+    retry_config: RetryConfig,
+    /// Client options
+    client_options: ClientOptions,
+    /// Credentials
+    credentials: Option<GcpCredentialProvider>,
+}
+
+/// Configuration keys for [`GoogleCloudStorageBuilder`]
+///
+/// Configuration via keys can be done via [`GoogleCloudStorageBuilder::with_config`]
+///
+/// # Example
+/// ```
+/// # use object_store::gcp::{GoogleCloudStorageBuilder, GoogleConfigKey};
+/// let builder = GoogleCloudStorageBuilder::new()
+///     .with_config("google_service_account".parse().unwrap(), "my-service-account")
+///     .with_config(GoogleConfigKey::Bucket, "my-bucket");
+/// ```
+#[derive(PartialEq, Eq, Hash, Clone, Debug, Copy, Serialize, Deserialize)]
+#[non_exhaustive]
+pub enum GoogleConfigKey {
+    /// Path to the service account file
+    ///
+    /// Supported keys:
+    /// - `google_service_account`
+    /// - `service_account`
+    /// - `google_service_account_path`
+    /// - `service_account_path`
+    ServiceAccount,
+
+    /// The serialized service account key.
+    ///
+    /// Supported keys:
+    /// - `google_service_account_key`
+    /// - `service_account_key`
+    ServiceAccountKey,
+
+    /// Bucket name
+    ///
+    /// See [`GoogleCloudStorageBuilder::with_bucket_name`] for details.
+    ///
+    /// Supported keys:
+    /// - `google_bucket`
+    /// - `google_bucket_name`
+    /// - `bucket`
+    /// - `bucket_name`
+    Bucket,
+
+    /// Application credentials path
+    ///
+    /// See [`GoogleCloudStorageBuilder::with_application_credentials`].
+    ApplicationCredentials,
+
+    /// Client options
+    Client(ClientConfigKey),
+}
+
+impl AsRef<str> for GoogleConfigKey {
+    fn as_ref(&self) -> &str {
+        match self {
+            Self::ServiceAccount => "google_service_account",
+            Self::ServiceAccountKey => "google_service_account_key",
+            Self::Bucket => "google_bucket",
+            Self::ApplicationCredentials => "google_application_credentials",
+            Self::Client(key) => key.as_ref(),
+        }
+    }
+}
+
+impl FromStr for GoogleConfigKey {
+    type Err = crate::Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "google_service_account"
+            | "service_account"
+            | "google_service_account_path"
+            | "service_account_path" => Ok(Self::ServiceAccount),
+            "google_service_account_key" | "service_account_key" => Ok(Self::ServiceAccountKey),
+            "google_bucket" | "google_bucket_name" | "bucket" | "bucket_name" => Ok(Self::Bucket),
+            "google_application_credentials" => Ok(Self::ApplicationCredentials),
+            _ => match s.parse() {
+                Ok(key) => Ok(Self::Client(key)),
+                Err(_) => Err(Error::UnknownConfigurationKey { key: s.into() }.into()),
+            },
+        }
+    }
+}
+
+impl Default for GoogleCloudStorageBuilder {
+    fn default() -> Self {
+        Self {
+            bucket_name: None,
+            service_account_path: None,
+            service_account_key: None,
+            application_credentials_path: None,
+            retry_config: Default::default(),
+            client_options: ClientOptions::new().with_allow_http(true),
+            url: None,
+            credentials: None,
+        }
+    }
+}
+
+impl GoogleCloudStorageBuilder {
+    /// Create a new [`GoogleCloudStorageBuilder`] with default values.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Create an instance of [`GoogleCloudStorageBuilder`] with values pre-populated from environment variables.
+    ///
+    /// Variables extracted from environment:
+    /// * GOOGLE_SERVICE_ACCOUNT: location of service account file
+    /// * GOOGLE_SERVICE_ACCOUNT_PATH: (alias) location of service account file
+    /// * SERVICE_ACCOUNT: (alias) location of service account file
+    /// * GOOGLE_SERVICE_ACCOUNT_KEY: JSON serialized service account key
+    /// * GOOGLE_BUCKET: bucket name
+    /// * GOOGLE_BUCKET_NAME: (alias) bucket name
+    ///
+    /// # Example
+    /// ```
+    /// use object_store::gcp::GoogleCloudStorageBuilder;
+    ///
+    /// let gcs = GoogleCloudStorageBuilder::from_env()
+    ///     .with_bucket_name("foo")
+    ///     .build();
+    /// ```
+    pub fn from_env() -> Self {
+        let mut builder = Self::default();
+
+        if let Ok(service_account_path) = std::env::var("SERVICE_ACCOUNT") {
+            builder.service_account_path = Some(service_account_path);
+        }
+
+        for (os_key, os_value) in std::env::vars_os() {
+            if let (Some(key), Some(value)) = (os_key.to_str(), os_value.to_str()) {
+                if key.starts_with("GOOGLE_") {
+                    if let Ok(config_key) = key.to_ascii_lowercase().parse() {
+                        builder = builder.with_config(config_key, value);
+                    }
+                }
+            }
+        }
+
+        builder
+    }
+
+    /// Parse available connection info form a well-known storage URL.
+    ///
+    /// The supported url schemes are:
+    ///
+    /// - `gs://<bucket>/<path>`
+    ///
+    /// Note: Settings derived from the URL will override any others set on this builder
+    ///
+    /// # Example
+    /// ```
+    /// use object_store::gcp::GoogleCloudStorageBuilder;
+    ///
+    /// let gcs = GoogleCloudStorageBuilder::from_env()
+    ///     .with_url("gs://bucket/path")
+    ///     .build();
+    /// ```
+    pub fn with_url(mut self, url: impl Into<String>) -> Self {
+        self.url = Some(url.into());
+        self
+    }
+
+    /// Set an option on the builder via a key - value pair.
+    pub fn with_config(mut self, key: GoogleConfigKey, value: impl Into<String>) -> Self {
+        match key {
+            GoogleConfigKey::ServiceAccount => self.service_account_path = Some(value.into()),
+            GoogleConfigKey::ServiceAccountKey => self.service_account_key = Some(value.into()),
+            GoogleConfigKey::Bucket => self.bucket_name = Some(value.into()),
+            GoogleConfigKey::ApplicationCredentials => {
+                self.application_credentials_path = Some(value.into())
+            }
+            GoogleConfigKey::Client(key) => {
+                self.client_options = self.client_options.with_config(key, value)
+            }
+        };
+        self
+    }
+
+    /// Get config value via a [`GoogleConfigKey`].
+    ///
+    /// # Example
+    /// ```
+    /// use object_store::gcp::{GoogleCloudStorageBuilder, GoogleConfigKey};
+    ///
+    /// let builder = GoogleCloudStorageBuilder::from_env()
+    ///     .with_service_account_key("foo");
+    /// let service_account_key = builder.get_config_value(&GoogleConfigKey::ServiceAccountKey).unwrap_or_default();
+    /// assert_eq!("foo", &service_account_key);
+    /// ```
+    pub fn get_config_value(&self, key: &GoogleConfigKey) -> Option<String> {
+        match key {
+            GoogleConfigKey::ServiceAccount => self.service_account_path.clone(),
+            GoogleConfigKey::ServiceAccountKey => self.service_account_key.clone(),
+            GoogleConfigKey::Bucket => self.bucket_name.clone(),
+            GoogleConfigKey::ApplicationCredentials => self.application_credentials_path.clone(),
+            GoogleConfigKey::Client(key) => self.client_options.get_config_value(key),
+        }
+    }
+
+    /// Sets properties on this builder based on a URL
+    ///
+    /// This is a separate member function to allow fallible computation to
+    /// be deferred until [`Self::build`] which in turn allows deriving [`Clone`]
+    fn parse_url(&mut self, url: &str) -> Result<()> {
+        let parsed = Url::parse(url).context(UnableToParseUrlSnafu { url })?;
+        let host = parsed.host_str().context(UrlNotRecognisedSnafu { url })?;
+
+        match parsed.scheme() {
+            "gs" => self.bucket_name = Some(host.to_string()),
+            scheme => return Err(UnknownUrlSchemeSnafu { scheme }.build().into()),
+        }
+        Ok(())
+    }
+
+    /// Set the bucket name (required)
+    pub fn with_bucket_name(mut self, bucket_name: impl Into<String>) -> Self {
+        self.bucket_name = Some(bucket_name.into());
+        self
+    }
+
+    /// Set the path to the service account file.
+    ///
+    /// This or [`GoogleCloudStorageBuilder::with_service_account_key`] must be
+    /// set.
+    ///
+    /// Example `"/tmp/gcs.json"`.
+    ///
+    /// Example contents of `gcs.json`:
+    ///
+    /// ```json
+    /// {
+    ///    "gcs_base_url": "https://localhost:4443",
+    ///    "disable_oauth": true,
+    ///    "client_email": "",
+    ///    "private_key": ""
+    /// }
+    /// ```
+    pub fn with_service_account_path(mut self, service_account_path: impl Into<String>) -> Self {
+        self.service_account_path = Some(service_account_path.into());
+        self
+    }
+
+    /// Set the service account key. The service account must be in the JSON
+    /// format.
+    ///
+    /// This or [`GoogleCloudStorageBuilder::with_service_account_path`] must be
+    /// set.
+    pub fn with_service_account_key(mut self, service_account: impl Into<String>) -> Self {
+        self.service_account_key = Some(service_account.into());
+        self
+    }
+
+    /// Set the path to the application credentials file.
+    ///
+    /// <https://cloud.google.com/docs/authentication/provide-credentials-adc>
+    pub fn with_application_credentials(
+        mut self,
+        application_credentials_path: impl Into<String>,
+    ) -> Self {
+        self.application_credentials_path = Some(application_credentials_path.into());
+        self
+    }
+
+    /// Set the credential provider overriding any other options
+    pub fn with_credentials(mut self, credentials: GcpCredentialProvider) -> Self {
+        self.credentials = Some(credentials);
+        self
+    }
+
+    /// Set the retry configuration
+    pub fn with_retry(mut self, retry_config: RetryConfig) -> Self {
+        self.retry_config = retry_config;
+        self
+    }
+
+    /// Set the proxy_url to be used by the underlying client
+    pub fn with_proxy_url(mut self, proxy_url: impl Into<String>) -> Self {
+        self.client_options = self.client_options.with_proxy_url(proxy_url);
+        self
+    }
+
+    /// Set a trusted proxy CA certificate
+    pub fn with_proxy_ca_certificate(mut self, proxy_ca_certificate: impl Into<String>) -> Self {
+        self.client_options = self
+            .client_options
+            .with_proxy_ca_certificate(proxy_ca_certificate);
+        self
+    }
+
+    /// Set a list of hosts to exclude from proxy connections
+    pub fn with_proxy_excludes(mut self, proxy_excludes: impl Into<String>) -> Self {
+        self.client_options = self.client_options.with_proxy_excludes(proxy_excludes);
+        self
+    }
+
+    /// Sets the client options, overriding any already set
+    pub fn with_client_options(mut self, options: ClientOptions) -> Self {
+        self.client_options = options;
+        self
+    }
+
+    /// Configure a connection to Google Cloud Storage, returning a
+    /// new [`GoogleCloudStorage`] and consuming `self`
+    pub fn build(mut self) -> Result<GoogleCloudStorage> {
+        if let Some(url) = self.url.take() {
+            self.parse_url(&url)?;
+        }
+
+        let bucket_name = self.bucket_name.ok_or(Error::MissingBucketName {})?;
+
+        // First try to initialize from the service account information.
+        let service_account_credentials =
+            match (self.service_account_path, self.service_account_key) {
+                (Some(path), None) => {
+                    Some(ServiceAccountCredentials::from_file(path).context(CredentialSnafu)?)
+                }
+                (None, Some(key)) => {
+                    Some(ServiceAccountCredentials::from_key(&key).context(CredentialSnafu)?)
+                }
+                (None, None) => None,
+                (Some(_), Some(_)) => return Err(Error::ServiceAccountPathAndKeyProvided.into()),
+            };
+
+        // Then try to initialize from the application credentials file, or the environment.
+        let application_default_credentials =
+            ApplicationDefaultCredentials::read(self.application_credentials_path.as_deref())?;
+
+        let disable_oauth = service_account_credentials
+            .as_ref()
+            .map(|c| c.disable_oauth)
+            .unwrap_or(false);
+
+        let gcs_base_url: String = service_account_credentials
+            .as_ref()
+            .and_then(|c| c.gcs_base_url.clone())
+            .unwrap_or_else(|| DEFAULT_GCS_BASE_URL.to_string());
+
+        let credentials = if let Some(credentials) = self.credentials {
+            credentials
+        } else if disable_oauth {
+            Arc::new(StaticCredentialProvider::new(GcpCredential {
+                bearer: "".to_string(),
+            })) as _
+        } else if let Some(credentials) = service_account_credentials {
+            Arc::new(TokenCredentialProvider::new(
+                credentials.token_provider()?,
+                self.client_options.client()?,
+                self.retry_config.clone(),
+            )) as _
+        } else if let Some(credentials) = application_default_credentials {
+            match credentials {
+                ApplicationDefaultCredentials::AuthorizedUser(token) => {
+                    Arc::new(TokenCredentialProvider::new(
+                        token,
+                        self.client_options.client()?,
+                        self.retry_config.clone(),
+                    )) as _
+                }
+                ApplicationDefaultCredentials::ServiceAccount(token) => {
+                    Arc::new(TokenCredentialProvider::new(
+                        token.token_provider()?,
+                        self.client_options.client()?,
+                        self.retry_config.clone(),
+                    )) as _
+                }
+            }
+        } else {
+            Arc::new(TokenCredentialProvider::new(
+                InstanceCredentialProvider::default(),
+                self.client_options.metadata_client()?,
+                self.retry_config.clone(),
+            )) as _
+        };
+
+        let config = GoogleCloudStorageConfig {
+            base_url: gcs_base_url,
+            credentials,
+            bucket_name,
+            retry_config: self.retry_config,
+            client_options: self.client_options,
+        };
+
+        Ok(GoogleCloudStorage {
+            client: Arc::new(GoogleCloudStorageClient::new(config)?),
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use std::collections::HashMap;
+    use std::io::Write;
+    use tempfile::NamedTempFile;
+
+    const FAKE_KEY: &str = r#"{"private_key": "private_key", "private_key_id": "private_key_id", "client_email":"client_email", "disable_oauth":true}"#;
+
+    #[test]
+    fn gcs_test_service_account_key_and_path() {
+        let mut tfile = NamedTempFile::new().unwrap();
+        write!(tfile, "{FAKE_KEY}").unwrap();
+        let _ = GoogleCloudStorageBuilder::new()
+            .with_service_account_key(FAKE_KEY)
+            .with_service_account_path(tfile.path().to_str().unwrap())
+            .with_bucket_name("foo")
+            .build()
+            .unwrap_err();
+    }
+
+    #[test]
+    fn gcs_test_config_from_map() {
+        let google_service_account = "object_store:fake_service_account".to_string();
+        let google_bucket_name = "object_store:fake_bucket".to_string();
+        let options = HashMap::from([
+            ("google_service_account", google_service_account.clone()),
+            ("google_bucket_name", google_bucket_name.clone()),
+        ]);
+
+        let builder = options
+            .iter()
+            .fold(GoogleCloudStorageBuilder::new(), |builder, (key, value)| {
+                builder.with_config(key.parse().unwrap(), value)
+            });
+
+        assert_eq!(
+            builder.service_account_path.unwrap(),
+            google_service_account.as_str()
+        );
+        assert_eq!(builder.bucket_name.unwrap(), google_bucket_name.as_str());
+    }
+
+    #[test]
+    fn gcs_test_config_aliases() {
+        // Service account path
+        for alias in [
+            "google_service_account",
+            "service_account",
+            "google_service_account_path",
+            "service_account_path",
+        ] {
+            let builder = GoogleCloudStorageBuilder::new()
+                .with_config(alias.parse().unwrap(), "/fake/path.json");
+            assert_eq!("/fake/path.json", builder.service_account_path.unwrap());
+        }
+
+        // Service account key
+        for alias in ["google_service_account_key", "service_account_key"] {
+            let builder =
+                GoogleCloudStorageBuilder::new().with_config(alias.parse().unwrap(), FAKE_KEY);
+            assert_eq!(FAKE_KEY, builder.service_account_key.unwrap());
+        }
+
+        // Bucket name
+        for alias in [
+            "google_bucket",
+            "google_bucket_name",
+            "bucket",
+            "bucket_name",
+        ] {
+            let builder =
+                GoogleCloudStorageBuilder::new().with_config(alias.parse().unwrap(), "fake_bucket");
+            assert_eq!("fake_bucket", builder.bucket_name.unwrap());
+        }
+    }
+
+    #[tokio::test]
+    async fn gcs_test_proxy_url() {
+        let mut tfile = NamedTempFile::new().unwrap();
+        write!(tfile, "{FAKE_KEY}").unwrap();
+        let service_account_path = tfile.path();
+        let gcs = GoogleCloudStorageBuilder::new()
+            .with_service_account_path(service_account_path.to_str().unwrap())
+            .with_bucket_name("foo")
+            .with_proxy_url("https://example.com")
+            .build();
+        assert!(gcs.is_ok());
+
+        let err = GoogleCloudStorageBuilder::new()
+            .with_service_account_path(service_account_path.to_str().unwrap())
+            .with_bucket_name("foo")
+            .with_proxy_url("asdf://example.com")
+            .build()
+            .unwrap_err()
+            .to_string();
+
+        assert_eq!(
+            "Generic HTTP client error: builder error: unknown proxy scheme",
+            err
+        );
+    }
+
+    #[test]
+    fn gcs_test_urls() {
+        let mut builder = GoogleCloudStorageBuilder::new();
+        builder.parse_url("gs://bucket/path").unwrap();
+        assert_eq!(builder.bucket_name.as_deref(), Some("bucket"));
+
+        builder.parse_url("gs://bucket.mydomain/path").unwrap();
+        assert_eq!(builder.bucket_name.as_deref(), Some("bucket.mydomain"));
+
+        builder.parse_url("mailto://bucket/path").unwrap_err();
+    }
+
+    #[test]
+    fn gcs_test_service_account_key_only() {
+        let _ = GoogleCloudStorageBuilder::new()
+            .with_service_account_key(FAKE_KEY)
+            .with_bucket_name("foo")
+            .build()
+            .unwrap();
+    }
+
+    #[test]
+    fn gcs_test_config_get_value() {
+        let google_service_account = "object_store:fake_service_account".to_string();
+        let google_bucket_name = "object_store:fake_bucket".to_string();
+        let builder = GoogleCloudStorageBuilder::new()
+            .with_config(GoogleConfigKey::ServiceAccount, &google_service_account)
+            .with_config(GoogleConfigKey::Bucket, &google_bucket_name);
+
+        assert_eq!(
+            builder
+                .get_config_value(&GoogleConfigKey::ServiceAccount)
+                .unwrap(),
+            google_service_account
+        );
+        assert_eq!(
+            builder.get_config_value(&GoogleConfigKey::Bucket).unwrap(),
+            google_bucket_name
+        );
+    }
+}
diff --git a/object_store/src/gcp/client.rs b/object_store/src/gcp/client.rs
new file mode 100644
index 000000000000..e4b0f9af7d15
--- /dev/null
+++ b/object_store/src/gcp/client.rs
@@ -0,0 +1,518 @@
+// 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.
+
+use crate::client::get::GetClient;
+use crate::client::header::{get_put_result, get_version, HeaderConfig};
+use crate::client::list::ListClient;
+use crate::client::retry::RetryExt;
+use crate::client::s3::{
+    CompleteMultipartUpload, CompleteMultipartUploadResult, InitiateMultipartUploadResult,
+    ListResponse,
+};
+use crate::client::GetOptionsExt;
+use crate::gcp::{GcpCredential, GcpCredentialProvider, STORE};
+use crate::multipart::PartId;
+use crate::path::{Path, DELIMITER};
+use crate::{
+    ClientOptions, GetOptions, ListResult, MultipartId, PutMode, PutOptions, PutResult, Result,
+    RetryConfig,
+};
+use async_trait::async_trait;
+use bytes::{Buf, Bytes};
+use percent_encoding::{percent_encode, utf8_percent_encode, NON_ALPHANUMERIC};
+use reqwest::header::HeaderName;
+use reqwest::{header, Client, Method, RequestBuilder, Response, StatusCode};
+use serde::Serialize;
+use snafu::{OptionExt, ResultExt, Snafu};
+use std::sync::Arc;
+
+const VERSION_HEADER: &str = "x-goog-generation";
+
+static VERSION_MATCH: HeaderName = HeaderName::from_static("x-goog-if-generation-match");
+
+#[derive(Debug, Snafu)]
+enum Error {
+    #[snafu(display("Error performing list request: {}", source))]
+    ListRequest { source: crate::client::retry::Error },
+
+    #[snafu(display("Error getting list response body: {}", source))]
+    ListResponseBody { source: reqwest::Error },
+
+    #[snafu(display("Got invalid list response: {}", source))]
+    InvalidListResponse { source: quick_xml::de::DeError },
+
+    #[snafu(display("Error performing get request {}: {}", path, source))]
+    GetRequest {
+        source: crate::client::retry::Error,
+        path: String,
+    },
+
+    #[snafu(display("Error performing delete request {}: {}", path, source))]
+    DeleteRequest {
+        source: crate::client::retry::Error,
+        path: String,
+    },
+
+    #[snafu(display("Error performing put request {}: {}", path, source))]
+    PutRequest {
+        source: crate::client::retry::Error,
+        path: String,
+    },
+
+    #[snafu(display("Error getting put response body: {}", source))]
+    PutResponseBody { source: reqwest::Error },
+
+    #[snafu(display("Got invalid put response: {}", source))]
+    InvalidPutResponse { source: quick_xml::de::DeError },
+
+    #[snafu(display("Error performing post request {}: {}", path, source))]
+    PostRequest {
+        source: crate::client::retry::Error,
+        path: String,
+    },
+
+    #[snafu(display("Unable to extract metadata from headers: {}", source))]
+    Metadata {
+        source: crate::client::header::Error,
+    },
+
+    #[snafu(display("Version required for conditional update"))]
+    MissingVersion,
+
+    #[snafu(display("Error performing complete multipart request: {}", source))]
+    CompleteMultipartRequest { source: crate::client::retry::Error },
+
+    #[snafu(display("Error getting complete multipart response body: {}", source))]
+    CompleteMultipartResponseBody { source: reqwest::Error },
+
+    #[snafu(display("Got invalid multipart response: {}", source))]
+    InvalidMultipartResponse { source: quick_xml::de::DeError },
+}
+
+impl From<Error> for crate::Error {
+    fn from(err: Error) -> Self {
+        match err {
+            Error::GetRequest { source, path }
+            | Error::DeleteRequest { source, path }
+            | Error::PutRequest { source, path } => source.error(STORE, path),
+            _ => Self::Generic {
+                store: STORE,
+                source: Box::new(err),
+            },
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct GoogleCloudStorageConfig {
+    pub base_url: String,
+
+    pub credentials: GcpCredentialProvider,
+
+    pub bucket_name: String,
+
+    pub retry_config: RetryConfig,
+
+    pub client_options: ClientOptions,
+}
+
+/// A builder for a put request allowing customisation of the headers and query string
+pub struct PutRequest<'a> {
+    path: &'a Path,
+    config: &'a GoogleCloudStorageConfig,
+    builder: RequestBuilder,
+}
+
+impl<'a> PutRequest<'a> {
+    fn header(self, k: &HeaderName, v: &str) -> Self {
+        let builder = self.builder.header(k, v);
+        Self { builder, ..self }
+    }
+
+    fn query<T: Serialize + ?Sized + Sync>(self, query: &T) -> Self {
+        let builder = self.builder.query(query);
+        Self { builder, ..self }
+    }
+
+    async fn send(self) -> Result<PutResult> {
+        let credential = self.config.credentials.get_credential().await?;
+        let response = self
+            .builder
+            .bearer_auth(&credential.bearer)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(PutRequestSnafu {
+                path: self.path.as_ref(),
+            })?;
+
+        Ok(get_put_result(response.headers(), VERSION_HEADER).context(MetadataSnafu)?)
+    }
+}
+
+#[derive(Debug)]
+pub struct GoogleCloudStorageClient {
+    config: GoogleCloudStorageConfig,
+
+    client: Client,
+
+    bucket_name_encoded: String,
+
+    // TODO: Hook this up in tests
+    max_list_results: Option<String>,
+}
+
+impl GoogleCloudStorageClient {
+    pub fn new(config: GoogleCloudStorageConfig) -> Result<Self> {
+        let client = config.client_options.client()?;
+        let bucket_name_encoded =
+            percent_encode(config.bucket_name.as_bytes(), NON_ALPHANUMERIC).to_string();
+
+        Ok(Self {
+            config,
+            client,
+            bucket_name_encoded,
+            max_list_results: None,
+        })
+    }
+
+    pub fn config(&self) -> &GoogleCloudStorageConfig {
+        &self.config
+    }
+
+    async fn get_credential(&self) -> Result<Arc<GcpCredential>> {
+        self.config.credentials.get_credential().await
+    }
+
+    pub fn object_url(&self, path: &Path) -> String {
+        let encoded = utf8_percent_encode(path.as_ref(), NON_ALPHANUMERIC);
+        format!(
+            "{}/{}/{}",
+            self.config.base_url, self.bucket_name_encoded, encoded
+        )
+    }
+
+    /// Perform a put request <https://cloud.google.com/storage/docs/xml-api/put-object-upload>
+    ///
+    /// Returns the new ETag
+    pub fn put_request<'a>(&'a self, path: &'a Path, payload: Bytes) -> PutRequest<'a> {
+        let url = self.object_url(path);
+
+        let content_type = self
+            .config
+            .client_options
+            .get_content_type(path)
+            .unwrap_or("application/octet-stream");
+
+        let builder = self
+            .client
+            .request(Method::PUT, url)
+            .header(header::CONTENT_TYPE, content_type)
+            .header(header::CONTENT_LENGTH, payload.len())
+            .body(payload);
+
+        PutRequest {
+            path,
+            builder,
+            config: &self.config,
+        }
+    }
+
+    pub async fn put(&self, path: &Path, data: Bytes, opts: PutOptions) -> Result<PutResult> {
+        let builder = self.put_request(path, data);
+
+        let builder = match &opts.mode {
+            PutMode::Overwrite => builder,
+            PutMode::Create => builder.header(&VERSION_MATCH, "0"),
+            PutMode::Update(v) => {
+                let etag = v.version.as_ref().context(MissingVersionSnafu)?;
+                builder.header(&VERSION_MATCH, etag)
+            }
+        };
+
+        match (opts.mode, builder.send().await) {
+            (PutMode::Create, Err(crate::Error::Precondition { path, source })) => {
+                Err(crate::Error::AlreadyExists { path, source })
+            }
+            (_, r) => r,
+        }
+    }
+
+    /// Perform a put part request <https://cloud.google.com/storage/docs/xml-api/put-object-multipart>
+    ///
+    /// Returns the new [`PartId`]
+    pub async fn put_part(
+        &self,
+        path: &Path,
+        upload_id: &MultipartId,
+        part_idx: usize,
+        data: Bytes,
+    ) -> Result<PartId> {
+        let query = &[
+            ("partNumber", &format!("{}", part_idx + 1)),
+            ("uploadId", upload_id),
+        ];
+        let result = self.put_request(path, data).query(query).send().await?;
+
+        Ok(PartId {
+            content_id: result.e_tag.unwrap(),
+        })
+    }
+
+    /// Initiate a multi-part upload <https://cloud.google.com/storage/docs/xml-api/post-object-multipart>
+    pub async fn multipart_initiate(&self, path: &Path) -> Result<MultipartId> {
+        let credential = self.get_credential().await?;
+        let url = self.object_url(path);
+
+        let content_type = self
+            .config
+            .client_options
+            .get_content_type(path)
+            .unwrap_or("application/octet-stream");
+
+        let response = self
+            .client
+            .request(Method::POST, &url)
+            .bearer_auth(&credential.bearer)
+            .header(header::CONTENT_TYPE, content_type)
+            .header(header::CONTENT_LENGTH, "0")
+            .query(&[("uploads", "")])
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(PutRequestSnafu {
+                path: path.as_ref(),
+            })?;
+
+        let data = response.bytes().await.context(PutResponseBodySnafu)?;
+        let result: InitiateMultipartUploadResult =
+            quick_xml::de::from_reader(data.as_ref().reader()).context(InvalidPutResponseSnafu)?;
+
+        Ok(result.upload_id)
+    }
+
+    /// Cleanup unused parts <https://cloud.google.com/storage/docs/xml-api/delete-multipart>
+    pub async fn multipart_cleanup(&self, path: &Path, multipart_id: &MultipartId) -> Result<()> {
+        let credential = self.get_credential().await?;
+        let url = self.object_url(path);
+
+        self.client
+            .request(Method::DELETE, &url)
+            .bearer_auth(&credential.bearer)
+            .header(header::CONTENT_TYPE, "application/octet-stream")
+            .header(header::CONTENT_LENGTH, "0")
+            .query(&[("uploadId", multipart_id)])
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(PutRequestSnafu {
+                path: path.as_ref(),
+            })?;
+
+        Ok(())
+    }
+
+    pub async fn multipart_complete(
+        &self,
+        path: &Path,
+        multipart_id: &MultipartId,
+        completed_parts: Vec<PartId>,
+    ) -> Result<PutResult> {
+        let upload_id = multipart_id.clone();
+        let url = self.object_url(path);
+
+        let upload_info = CompleteMultipartUpload::from(completed_parts);
+        let credential = self.get_credential().await?;
+
+        let data = quick_xml::se::to_string(&upload_info)
+            .context(InvalidPutResponseSnafu)?
+            // We cannot disable the escaping that transforms "/" to "&quote;" :(
+            // https://github.com/tafia/quick-xml/issues/362
+            // https://github.com/tafia/quick-xml/issues/350
+            .replace("&quot;", "\"");
+
+        let response = self
+            .client
+            .request(Method::POST, &url)
+            .bearer_auth(&credential.bearer)
+            .query(&[("uploadId", upload_id)])
+            .body(data)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(CompleteMultipartRequestSnafu)?;
+
+        let version = get_version(response.headers(), VERSION_HEADER).context(MetadataSnafu)?;
+
+        let data = response
+            .bytes()
+            .await
+            .context(CompleteMultipartResponseBodySnafu)?;
+
+        let response: CompleteMultipartUploadResult =
+            quick_xml::de::from_reader(data.reader()).context(InvalidMultipartResponseSnafu)?;
+
+        Ok(PutResult {
+            e_tag: Some(response.e_tag),
+            version,
+        })
+    }
+
+    /// Perform a delete request <https://cloud.google.com/storage/docs/xml-api/delete-object>
+    pub async fn delete_request(&self, path: &Path) -> Result<()> {
+        let credential = self.get_credential().await?;
+        let url = self.object_url(path);
+
+        let builder = self.client.request(Method::DELETE, url);
+        builder
+            .bearer_auth(&credential.bearer)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(DeleteRequestSnafu {
+                path: path.as_ref(),
+            })?;
+
+        Ok(())
+    }
+
+    /// Perform a copy request <https://cloud.google.com/storage/docs/xml-api/put-object-copy>
+    pub async fn copy_request(&self, from: &Path, to: &Path, if_not_exists: bool) -> Result<()> {
+        let credential = self.get_credential().await?;
+        let url = self.object_url(to);
+
+        let from = utf8_percent_encode(from.as_ref(), NON_ALPHANUMERIC);
+        let source = format!("{}/{}", self.bucket_name_encoded, from);
+
+        let mut builder = self
+            .client
+            .request(Method::PUT, url)
+            .header("x-goog-copy-source", source);
+
+        if if_not_exists {
+            builder = builder.header(&VERSION_MATCH, 0);
+        }
+
+        builder
+            .bearer_auth(&credential.bearer)
+            // Needed if reqwest is compiled with native-tls instead of rustls-tls
+            // See https://github.com/apache/arrow-rs/pull/3921
+            .header(header::CONTENT_LENGTH, 0)
+            .send_retry(&self.config.retry_config)
+            .await
+            .map_err(|err| match err.status() {
+                Some(StatusCode::PRECONDITION_FAILED) => crate::Error::AlreadyExists {
+                    source: Box::new(err),
+                    path: to.to_string(),
+                },
+                _ => err.error(STORE, from.to_string()),
+            })?;
+
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl GetClient for GoogleCloudStorageClient {
+    const STORE: &'static str = STORE;
+    const HEADER_CONFIG: HeaderConfig = HeaderConfig {
+        etag_required: true,
+        last_modified_required: true,
+        version_header: Some(VERSION_HEADER),
+    };
+
+    /// Perform a get request <https://cloud.google.com/storage/docs/xml-api/get-object-download>
+    async fn get_request(&self, path: &Path, options: GetOptions) -> Result<Response> {
+        let credential = self.get_credential().await?;
+        let url = self.object_url(path);
+
+        let method = match options.head {
+            true => Method::HEAD,
+            false => Method::GET,
+        };
+
+        let mut request = self.client.request(method, url);
+
+        if let Some(version) = &options.version {
+            request = request.query(&[("generation", version)]);
+        }
+
+        if !credential.bearer.is_empty() {
+            request = request.bearer_auth(&credential.bearer);
+        }
+
+        let response = request
+            .with_get_options(options)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(GetRequestSnafu {
+                path: path.as_ref(),
+            })?;
+
+        Ok(response)
+    }
+}
+
+#[async_trait]
+impl ListClient for GoogleCloudStorageClient {
+    /// Perform a list request <https://cloud.google.com/storage/docs/xml-api/get-bucket-list>
+    async fn list_request(
+        &self,
+        prefix: Option<&str>,
+        delimiter: bool,
+        page_token: Option<&str>,
+        offset: Option<&str>,
+    ) -> Result<(ListResult, Option<String>)> {
+        let credential = self.get_credential().await?;
+        let url = format!("{}/{}", self.config.base_url, self.bucket_name_encoded);
+
+        let mut query = Vec::with_capacity(5);
+        query.push(("list-type", "2"));
+        if delimiter {
+            query.push(("delimiter", DELIMITER))
+        }
+
+        if let Some(prefix) = &prefix {
+            query.push(("prefix", prefix))
+        }
+
+        if let Some(page_token) = page_token {
+            query.push(("continuation-token", page_token))
+        }
+
+        if let Some(max_results) = &self.max_list_results {
+            query.push(("max-keys", max_results))
+        }
+
+        if let Some(offset) = offset {
+            query.push(("start-after", offset))
+        }
+
+        let response = self
+            .client
+            .request(Method::GET, url)
+            .query(&query)
+            .bearer_auth(&credential.bearer)
+            .send_retry(&self.config.retry_config)
+            .await
+            .context(ListRequestSnafu)?
+            .bytes()
+            .await
+            .context(ListResponseBodySnafu)?;
+
+        let mut response: ListResponse =
+            quick_xml::de::from_reader(response.reader()).context(InvalidListResponseSnafu)?;
+
+        let token = response.next_continuation_token.take();
+        Ok((response.try_into()?, token))
+    }
+}
diff --git a/object_store/src/gcp/credential.rs b/object_store/src/gcp/credential.rs
new file mode 100644
index 000000000000..dc504da05723
--- /dev/null
+++ b/object_store/src/gcp/credential.rs
@@ -0,0 +1,458 @@
+// 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.
+
+use crate::client::retry::RetryExt;
+use crate::client::token::TemporaryToken;
+use crate::client::TokenProvider;
+use crate::gcp::STORE;
+use crate::RetryConfig;
+use async_trait::async_trait;
+use base64::prelude::BASE64_URL_SAFE_NO_PAD;
+use base64::Engine;
+use futures::TryFutureExt;
+use reqwest::{Client, Method};
+use ring::signature::RsaKeyPair;
+use serde::Deserialize;
+use snafu::{ResultExt, Snafu};
+use std::env;
+use std::fs::File;
+use std::io::BufReader;
+use std::path::{Path, PathBuf};
+use std::sync::Arc;
+use std::time::{Duration, Instant};
+use tracing::info;
+
+pub const DEFAULT_SCOPE: &str = "https://www.googleapis.com/auth/devstorage.full_control";
+
+pub const DEFAULT_GCS_BASE_URL: &str = "https://storage.googleapis.com";
+
+#[derive(Debug, Snafu)]
+pub enum Error {
+    #[snafu(display("Unable to open service account file from {}: {}", path.display(), source))]
+    OpenCredentials {
+        source: std::io::Error,
+        path: PathBuf,
+    },
+
+    #[snafu(display("Unable to decode service account file: {}", source))]
+    DecodeCredentials { source: serde_json::Error },
+
+    #[snafu(display("No RSA key found in pem file"))]
+    MissingKey,
+
+    #[snafu(display("Invalid RSA key: {}", source), context(false))]
+    InvalidKey { source: ring::error::KeyRejected },
+
+    #[snafu(display("Error signing jwt: {}", source))]
+    Sign { source: ring::error::Unspecified },
+
+    #[snafu(display("Error encoding jwt payload: {}", source))]
+    Encode { source: serde_json::Error },
+
+    #[snafu(display("Unsupported key encoding: {}", encoding))]
+    UnsupportedKey { encoding: String },
+
+    #[snafu(display("Error performing token request: {}", source))]
+    TokenRequest { source: crate::client::retry::Error },
+
+    #[snafu(display("Error getting token response body: {}", source))]
+    TokenResponseBody { source: reqwest::Error },
+}
+
+impl From<Error> for crate::Error {
+    fn from(value: Error) -> Self {
+        Self::Generic {
+            store: STORE,
+            source: Box::new(value),
+        }
+    }
+}
+
+/// A Google Cloud Storage Credential
+#[derive(Debug, Eq, PartialEq)]
+pub struct GcpCredential {
+    /// An HTTP bearer token
+    pub bearer: String,
+}
+
+pub type Result<T, E = Error> = std::result::Result<T, E>;
+
+#[derive(Debug, Default, serde::Serialize)]
+pub struct JwtHeader<'a> {
+    /// The type of JWS: it can only be "JWT" here
+    ///
+    /// Defined in [RFC7515#4.1.9](https://tools.ietf.org/html/rfc7515#section-4.1.9).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub typ: Option<&'a str>,
+    /// The algorithm used
+    ///
+    /// Defined in [RFC7515#4.1.1](https://tools.ietf.org/html/rfc7515#section-4.1.1).
+    pub alg: &'a str,
+    /// Content type
+    ///
+    /// Defined in [RFC7519#5.2](https://tools.ietf.org/html/rfc7519#section-5.2).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub cty: Option<&'a str>,
+    /// JSON Key URL
+    ///
+    /// Defined in [RFC7515#4.1.2](https://tools.ietf.org/html/rfc7515#section-4.1.2).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub jku: Option<&'a str>,
+    /// Key ID
+    ///
+    /// Defined in [RFC7515#4.1.4](https://tools.ietf.org/html/rfc7515#section-4.1.4).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub kid: Option<&'a str>,
+    /// X.509 URL
+    ///
+    /// Defined in [RFC7515#4.1.5](https://tools.ietf.org/html/rfc7515#section-4.1.5).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub x5u: Option<&'a str>,
+    /// X.509 certificate thumbprint
+    ///
+    /// Defined in [RFC7515#4.1.7](https://tools.ietf.org/html/rfc7515#section-4.1.7).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub x5t: Option<&'a str>,
+}
+
+#[derive(serde::Serialize)]
+struct TokenClaims<'a> {
+    iss: &'a str,
+    sub: &'a str,
+    scope: &'a str,
+    exp: u64,
+    iat: u64,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct TokenResponse {
+    access_token: String,
+    expires_in: u64,
+}
+
+/// Self-signed JWT (JSON Web Token).
+///
+/// # References
+/// - <https://google.aip.dev/auth/4111>
+#[derive(Debug)]
+pub struct SelfSignedJwt {
+    issuer: String,
+    scope: String,
+    key_pair: RsaKeyPair,
+    jwt_header: String,
+    random: ring::rand::SystemRandom,
+}
+
+impl SelfSignedJwt {
+    /// Create a new [`SelfSignedJwt`]
+    pub fn new(
+        key_id: String,
+        issuer: String,
+        private_key_pem: String,
+        scope: String,
+    ) -> Result<Self> {
+        let key_pair = decode_first_rsa_key(private_key_pem)?;
+        let jwt_header = b64_encode_obj(&JwtHeader {
+            alg: "RS256",
+            typ: Some("JWT"),
+            kid: Some(&key_id),
+            ..Default::default()
+        })?;
+
+        Ok(Self {
+            issuer,
+            key_pair,
+            scope,
+            jwt_header,
+            random: ring::rand::SystemRandom::new(),
+        })
+    }
+}
+
+#[async_trait]
+impl TokenProvider for SelfSignedJwt {
+    type Credential = GcpCredential;
+
+    /// Fetch a fresh token
+    async fn fetch_token(
+        &self,
+        _client: &Client,
+        _retry: &RetryConfig,
+    ) -> crate::Result<TemporaryToken<Arc<GcpCredential>>> {
+        let now = seconds_since_epoch();
+        let exp = now + 3600;
+
+        let claims = TokenClaims {
+            iss: &self.issuer,
+            sub: &self.issuer,
+            scope: &self.scope,
+            iat: now,
+            exp,
+        };
+
+        let claim_str = b64_encode_obj(&claims)?;
+        let message = [self.jwt_header.as_ref(), claim_str.as_ref()].join(".");
+        let mut sig_bytes = vec![0; self.key_pair.public().modulus_len()];
+        self.key_pair
+            .sign(
+                &ring::signature::RSA_PKCS1_SHA256,
+                &self.random,
+                message.as_bytes(),
+                &mut sig_bytes,
+            )
+            .context(SignSnafu)?;
+
+        let signature = BASE64_URL_SAFE_NO_PAD.encode(sig_bytes);
+        let bearer = [message, signature].join(".");
+
+        Ok(TemporaryToken {
+            token: Arc::new(GcpCredential { bearer }),
+            expiry: Some(Instant::now() + Duration::from_secs(3600)),
+        })
+    }
+}
+
+fn read_credentials_file<T>(service_account_path: impl AsRef<std::path::Path>) -> Result<T>
+where
+    T: serde::de::DeserializeOwned,
+{
+    let file = File::open(&service_account_path).context(OpenCredentialsSnafu {
+        path: service_account_path.as_ref().to_owned(),
+    })?;
+    let reader = BufReader::new(file);
+    serde_json::from_reader(reader).context(DecodeCredentialsSnafu)
+}
+
+/// A deserialized `service-account-********.json`-file.
+#[derive(serde::Deserialize, Debug)]
+pub struct ServiceAccountCredentials {
+    /// The private key in RSA format.
+    pub private_key: String,
+
+    /// The private key ID
+    pub private_key_id: String,
+
+    /// The email address associated with the service account.
+    pub client_email: String,
+
+    /// Base URL for GCS
+    #[serde(default)]
+    pub gcs_base_url: Option<String>,
+
+    /// Disable oauth and use empty tokens.
+    #[serde(default)]
+    pub disable_oauth: bool,
+}
+
+impl ServiceAccountCredentials {
+    /// Create a new [`ServiceAccountCredentials`] from a file.
+    pub fn from_file<P: AsRef<Path>>(path: P) -> Result<Self> {
+        read_credentials_file(path)
+    }
+
+    /// Create a new [`ServiceAccountCredentials`] from a string.
+    pub fn from_key(key: &str) -> Result<Self> {
+        serde_json::from_str(key).context(DecodeCredentialsSnafu)
+    }
+
+    /// Create a [`SelfSignedJwt`] from this credentials struct.
+    ///
+    /// We use a scope of [`DEFAULT_SCOPE`] as opposed to an audience
+    /// as GCS appears to not support audience
+    ///
+    /// # References
+    /// - <https://stackoverflow.com/questions/63222450/service-account-authorization-without-oauth-can-we-get-file-from-google-cloud/71834557#71834557>
+    /// - <https://www.codejam.info/2022/05/google-cloud-service-account-authorization-without-oauth.html>
+    pub fn token_provider(self) -> crate::Result<SelfSignedJwt> {
+        Ok(SelfSignedJwt::new(
+            self.private_key_id,
+            self.client_email,
+            self.private_key,
+            DEFAULT_SCOPE.to_string(),
+        )?)
+    }
+}
+
+/// Returns the number of seconds since unix epoch
+fn seconds_since_epoch() -> u64 {
+    std::time::SystemTime::now()
+        .duration_since(std::time::SystemTime::UNIX_EPOCH)
+        .unwrap()
+        .as_secs()
+}
+
+fn decode_first_rsa_key(private_key_pem: String) -> Result<RsaKeyPair> {
+    use rustls_pemfile::Item;
+    use std::io::Cursor;
+
+    let mut cursor = Cursor::new(private_key_pem);
+    let mut reader = BufReader::new(&mut cursor);
+
+    // Reading from string is infallible
+    match rustls_pemfile::read_one(&mut reader).unwrap() {
+        Some(Item::Pkcs8Key(key)) => Ok(RsaKeyPair::from_pkcs8(key.secret_pkcs8_der())?),
+        Some(Item::Pkcs1Key(key)) => Ok(RsaKeyPair::from_der(key.secret_pkcs1_der())?),
+        _ => Err(Error::MissingKey),
+    }
+}
+
+fn b64_encode_obj<T: serde::Serialize>(obj: &T) -> Result<String> {
+    let string = serde_json::to_string(obj).context(EncodeSnafu)?;
+    Ok(BASE64_URL_SAFE_NO_PAD.encode(string))
+}
+
+/// A provider that uses the Google Cloud Platform metadata server to fetch a token.
+///
+/// <https://cloud.google.com/docs/authentication/get-id-token#metadata-server>
+#[derive(Debug, Default)]
+pub struct InstanceCredentialProvider {}
+
+/// Make a request to the metadata server to fetch a token, using a a given hostname.
+async fn make_metadata_request(
+    client: &Client,
+    hostname: &str,
+    retry: &RetryConfig,
+) -> crate::Result<TokenResponse> {
+    let url =
+        format!("http://{hostname}/computeMetadata/v1/instance/service-accounts/default/token");
+    let response: TokenResponse = client
+        .request(Method::GET, url)
+        .header("Metadata-Flavor", "Google")
+        .query(&[("audience", "https://www.googleapis.com/oauth2/v4/token")])
+        .send_retry(retry)
+        .await
+        .context(TokenRequestSnafu)?
+        .json()
+        .await
+        .context(TokenResponseBodySnafu)?;
+    Ok(response)
+}
+
+#[async_trait]
+impl TokenProvider for InstanceCredentialProvider {
+    type Credential = GcpCredential;
+
+    /// Fetch a token from the metadata server.
+    /// Since the connection is local we need to enable http access and don't actually use the client object passed in.
+    async fn fetch_token(
+        &self,
+        client: &Client,
+        retry: &RetryConfig,
+    ) -> crate::Result<TemporaryToken<Arc<GcpCredential>>> {
+        const METADATA_IP: &str = "169.254.169.254";
+        const METADATA_HOST: &str = "metadata";
+
+        info!("fetching token from metadata server");
+        let response = make_metadata_request(client, METADATA_HOST, retry)
+            .or_else(|_| make_metadata_request(client, METADATA_IP, retry))
+            .await?;
+        let token = TemporaryToken {
+            token: Arc::new(GcpCredential {
+                bearer: response.access_token,
+            }),
+            expiry: Some(Instant::now() + Duration::from_secs(response.expires_in)),
+        };
+        Ok(token)
+    }
+}
+
+/// A deserialized `application_default_credentials.json`-file.
+///
+/// # References
+/// - <https://cloud.google.com/docs/authentication/application-default-credentials#personal>
+/// - <https://google.aip.dev/auth/4110>
+#[derive(serde::Deserialize)]
+#[serde(tag = "type")]
+pub enum ApplicationDefaultCredentials {
+    /// Service Account.
+    ///
+    /// # References
+    /// - <https://google.aip.dev/auth/4112>
+    #[serde(rename = "service_account")]
+    ServiceAccount(ServiceAccountCredentials),
+    /// Authorized user via "gcloud CLI Integration".
+    ///
+    /// # References
+    /// - <https://google.aip.dev/auth/4113>
+    #[serde(rename = "authorized_user")]
+    AuthorizedUser(AuthorizedUserCredentials),
+}
+
+impl ApplicationDefaultCredentials {
+    const CREDENTIALS_PATH: &'static str = ".config/gcloud/application_default_credentials.json";
+
+    // Create a new application default credential in the following situations:
+    //  1. a file is passed in and the type matches.
+    //  2. without argument if the well-known configuration file is present.
+    pub fn read(path: Option<&str>) -> Result<Option<Self>, Error> {
+        if let Some(path) = path {
+            return read_credentials_file::<Self>(path).map(Some);
+        }
+        if let Some(home) = env::var_os("HOME") {
+            let path = Path::new(&home).join(Self::CREDENTIALS_PATH);
+
+            // It's expected for this file to not exist unless it has been explicitly configured by the user.
+            if path.try_exists().unwrap_or(false) {
+                return read_credentials_file::<Self>(path).map(Some);
+            }
+        }
+        Ok(None)
+    }
+}
+
+const DEFAULT_TOKEN_GCP_URI: &str = "https://accounts.google.com/o/oauth2/token";
+
+/// <https://google.aip.dev/auth/4113>
+#[derive(Debug, Deserialize)]
+pub struct AuthorizedUserCredentials {
+    client_id: String,
+    client_secret: String,
+    refresh_token: String,
+}
+
+#[async_trait]
+impl TokenProvider for AuthorizedUserCredentials {
+    type Credential = GcpCredential;
+
+    async fn fetch_token(
+        &self,
+        client: &Client,
+        retry: &RetryConfig,
+    ) -> crate::Result<TemporaryToken<Arc<GcpCredential>>> {
+        let response = client
+            .request(Method::POST, DEFAULT_TOKEN_GCP_URI)
+            .form(&[
+                ("grant_type", "refresh_token"),
+                ("client_id", &self.client_id),
+                ("client_secret", &self.client_secret),
+                ("refresh_token", &self.refresh_token),
+            ])
+            .send_retry(retry)
+            .await
+            .context(TokenRequestSnafu)?
+            .json::<TokenResponse>()
+            .await
+            .context(TokenResponseBodySnafu)?;
+
+        Ok(TemporaryToken {
+            token: Arc::new(GcpCredential {
+                bearer: response.access_token,
+            }),
+            expiry: Some(Instant::now() + Duration::from_secs(response.expires_in)),
+        })
+    }
+}
diff --git a/object_store/src/gcp/mod.rs b/object_store/src/gcp/mod.rs
new file mode 100644
index 000000000000..8633abbfb4dc
--- /dev/null
+++ b/object_store/src/gcp/mod.rs
@@ -0,0 +1,325 @@
+// 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.
+
+//! An object store implementation for Google Cloud Storage
+//!
+//! ## Multi-part uploads
+//!
+//! [Multi-part uploads](https://cloud.google.com/storage/docs/multipart-uploads)
+//! can be initiated with the [ObjectStore::put_multipart] method.
+//! Data passed to the writer is automatically buffered to meet the minimum size
+//! requirements for a part. Multiple parts are uploaded concurrently.
+//!
+//! If the writer fails for any reason, you may have parts uploaded to GCS but not
+//! used that you may be charged for. Use the [ObjectStore::abort_multipart] method
+//! to abort the upload and drop those unneeded parts. In addition, you may wish to
+//! consider implementing automatic clean up of unused parts that are older than one
+//! week.
+//!
+//! ## Using HTTP/2
+//!
+//! Google Cloud Storage supports both HTTP/2 and HTTP/1. HTTP/1 is used by default
+//! because it allows much higher throughput in our benchmarks (see
+//! [#5194](https://github.com/apache/arrow-rs/issues/5194)). HTTP/2 can be
+//! enabled by setting [crate::ClientConfigKey::Http1Only] to false.
+use std::sync::Arc;
+
+use crate::client::CredentialProvider;
+use crate::{
+    multipart::{PartId, PutPart, WriteMultiPart},
+    path::Path,
+    GetOptions, GetResult, ListResult, MultipartId, ObjectMeta, ObjectStore, PutOptions, PutResult,
+    Result,
+};
+use async_trait::async_trait;
+use bytes::Bytes;
+use client::GoogleCloudStorageClient;
+use futures::stream::BoxStream;
+use tokio::io::AsyncWrite;
+
+use crate::client::get::GetClientExt;
+use crate::client::list::ListClientExt;
+use crate::multipart::MultiPartStore;
+pub use builder::{GoogleCloudStorageBuilder, GoogleConfigKey};
+pub use credential::GcpCredential;
+
+mod builder;
+mod client;
+mod credential;
+
+const STORE: &str = "GCS";
+
+/// [`CredentialProvider`] for [`GoogleCloudStorage`]
+pub type GcpCredentialProvider = Arc<dyn CredentialProvider<Credential = GcpCredential>>;
+
+/// Interface for [Google Cloud Storage](https://cloud.google.com/storage/).
+#[derive(Debug)]
+pub struct GoogleCloudStorage {
+    client: Arc<GoogleCloudStorageClient>,
+}
+
+impl std::fmt::Display for GoogleCloudStorage {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(
+            f,
+            "GoogleCloudStorage({})",
+            self.client.config().bucket_name
+        )
+    }
+}
+
+impl GoogleCloudStorage {
+    /// Returns the [`GcpCredentialProvider`] used by [`GoogleCloudStorage`]
+    pub fn credentials(&self) -> &GcpCredentialProvider {
+        &self.client.config().credentials
+    }
+}
+
+struct GCSMultipartUpload {
+    client: Arc<GoogleCloudStorageClient>,
+    path: Path,
+    multipart_id: MultipartId,
+}
+
+#[async_trait]
+impl PutPart for GCSMultipartUpload {
+    /// Upload an object part <https://cloud.google.com/storage/docs/xml-api/put-object-multipart>
+    async fn put_part(&self, buf: Vec<u8>, part_idx: usize) -> Result<PartId> {
+        self.client
+            .put_part(&self.path, &self.multipart_id, part_idx, buf.into())
+            .await
+    }
+
+    /// Complete a multipart upload <https://cloud.google.com/storage/docs/xml-api/post-object-complete>
+    async fn complete(&self, completed_parts: Vec<PartId>) -> Result<()> {
+        self.client
+            .multipart_complete(&self.path, &self.multipart_id, completed_parts)
+            .await?;
+        Ok(())
+    }
+}
+
+#[async_trait]
+impl ObjectStore for GoogleCloudStorage {
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        self.client.put(location, bytes, opts).await
+    }
+
+    async fn put_multipart(
+        &self,
+        location: &Path,
+    ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
+        let upload_id = self.client.multipart_initiate(location).await?;
+
+        let inner = GCSMultipartUpload {
+            client: Arc::clone(&self.client),
+            path: location.clone(),
+            multipart_id: upload_id.clone(),
+        };
+
+        Ok((upload_id, Box::new(WriteMultiPart::new(inner, 8))))
+    }
+
+    async fn abort_multipart(&self, location: &Path, multipart_id: &MultipartId) -> Result<()> {
+        self.client
+            .multipart_cleanup(location, multipart_id)
+            .await?;
+
+        Ok(())
+    }
+
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        self.client.get_opts(location, options).await
+    }
+
+    async fn delete(&self, location: &Path) -> Result<()> {
+        self.client.delete_request(location).await
+    }
+
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        self.client.list(prefix)
+    }
+
+    fn list_with_offset(
+        &self,
+        prefix: Option<&Path>,
+        offset: &Path,
+    ) -> BoxStream<'_, Result<ObjectMeta>> {
+        self.client.list_with_offset(prefix, offset)
+    }
+
+    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
+        self.client.list_with_delimiter(prefix).await
+    }
+
+    async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
+        self.client.copy_request(from, to, false).await
+    }
+
+    async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
+        self.client.copy_request(from, to, true).await
+    }
+}
+
+#[async_trait]
+impl MultiPartStore for GoogleCloudStorage {
+    async fn create_multipart(&self, path: &Path) -> Result<MultipartId> {
+        self.client.multipart_initiate(path).await
+    }
+
+    async fn put_part(
+        &self,
+        path: &Path,
+        id: &MultipartId,
+        part_idx: usize,
+        data: Bytes,
+    ) -> Result<PartId> {
+        self.client.put_part(path, id, part_idx, data).await
+    }
+
+    async fn complete_multipart(
+        &self,
+        path: &Path,
+        id: &MultipartId,
+        parts: Vec<PartId>,
+    ) -> Result<PutResult> {
+        self.client.multipart_complete(path, id, parts).await
+    }
+
+    async fn abort_multipart(&self, path: &Path, id: &MultipartId) -> Result<()> {
+        self.client.multipart_cleanup(path, id).await
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use bytes::Bytes;
+    use credential::DEFAULT_GCS_BASE_URL;
+
+    use crate::tests::*;
+
+    use super::*;
+
+    const NON_EXISTENT_NAME: &str = "nonexistentname";
+
+    #[tokio::test]
+    async fn gcs_test() {
+        crate::test_util::maybe_skip_integration!();
+        let integration = GoogleCloudStorageBuilder::from_env().build().unwrap();
+
+        put_get_delete_list(&integration).await;
+        list_uses_directories_correctly(&integration).await;
+        list_with_delimiter(&integration).await;
+        rename_and_copy(&integration).await;
+        if integration.client.config().base_url == DEFAULT_GCS_BASE_URL {
+            // Fake GCS server doesn't currently honor ifGenerationMatch
+            // https://github.com/fsouza/fake-gcs-server/issues/994
+            copy_if_not_exists(&integration).await;
+            // Fake GCS server does not yet implement XML Multipart uploads
+            // https://github.com/fsouza/fake-gcs-server/issues/852
+            stream_get(&integration).await;
+            multipart(&integration, &integration).await;
+            // Fake GCS server doesn't currently honor preconditions
+            get_opts(&integration).await;
+            put_opts(&integration, true).await;
+        }
+    }
+
+    #[tokio::test]
+    async fn gcs_test_get_nonexistent_location() {
+        crate::test_util::maybe_skip_integration!();
+        let integration = GoogleCloudStorageBuilder::from_env().build().unwrap();
+
+        let location = Path::from_iter([NON_EXISTENT_NAME]);
+
+        let err = integration.get(&location).await.unwrap_err();
+
+        assert!(
+            matches!(err, crate::Error::NotFound { .. }),
+            "unexpected error type: {err}"
+        );
+    }
+
+    #[tokio::test]
+    async fn gcs_test_get_nonexistent_bucket() {
+        crate::test_util::maybe_skip_integration!();
+        let config = GoogleCloudStorageBuilder::from_env();
+        let integration = config.with_bucket_name(NON_EXISTENT_NAME).build().unwrap();
+
+        let location = Path::from_iter([NON_EXISTENT_NAME]);
+
+        let err = get_nonexistent_object(&integration, Some(location))
+            .await
+            .unwrap_err();
+
+        assert!(
+            matches!(err, crate::Error::NotFound { .. }),
+            "unexpected error type: {err}"
+        );
+    }
+
+    #[tokio::test]
+    async fn gcs_test_delete_nonexistent_location() {
+        crate::test_util::maybe_skip_integration!();
+        let integration = GoogleCloudStorageBuilder::from_env().build().unwrap();
+
+        let location = Path::from_iter([NON_EXISTENT_NAME]);
+
+        let err = integration.delete(&location).await.unwrap_err();
+        assert!(
+            matches!(err, crate::Error::NotFound { .. }),
+            "unexpected error type: {err}"
+        );
+    }
+
+    #[tokio::test]
+    async fn gcs_test_delete_nonexistent_bucket() {
+        crate::test_util::maybe_skip_integration!();
+        let config = GoogleCloudStorageBuilder::from_env();
+        let integration = config.with_bucket_name(NON_EXISTENT_NAME).build().unwrap();
+
+        let location = Path::from_iter([NON_EXISTENT_NAME]);
+
+        let err = integration.delete(&location).await.unwrap_err();
+        assert!(
+            matches!(err, crate::Error::NotFound { .. }),
+            "unexpected error type: {err}"
+        );
+    }
+
+    #[tokio::test]
+    async fn gcs_test_put_nonexistent_bucket() {
+        crate::test_util::maybe_skip_integration!();
+        let config = GoogleCloudStorageBuilder::from_env();
+        let integration = config.with_bucket_name(NON_EXISTENT_NAME).build().unwrap();
+
+        let location = Path::from_iter([NON_EXISTENT_NAME]);
+        let data = Bytes::from("arbitrary data");
+
+        let err = integration
+            .put(&location, data)
+            .await
+            .unwrap_err()
+            .to_string();
+        assert!(
+            err.contains("Client error with status 404 Not Found"),
+            "{}",
+            err
+        )
+    }
+}
diff --git a/object_store/src/http/client.rs b/object_store/src/http/client.rs
new file mode 100644
index 000000000000..8700775fb243
--- /dev/null
+++ b/object_store/src/http/client.rs
@@ -0,0 +1,417 @@
+// 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.
+
+use crate::client::get::GetClient;
+use crate::client::header::HeaderConfig;
+use crate::client::retry::{self, RetryConfig, RetryExt};
+use crate::client::GetOptionsExt;
+use crate::path::{Path, DELIMITER};
+use crate::util::deserialize_rfc1123;
+use crate::{ClientOptions, GetOptions, ObjectMeta, Result};
+use async_trait::async_trait;
+use bytes::{Buf, Bytes};
+use chrono::{DateTime, Utc};
+use percent_encoding::percent_decode_str;
+use reqwest::header::CONTENT_TYPE;
+use reqwest::{Method, Response, StatusCode};
+use serde::Deserialize;
+use snafu::{OptionExt, ResultExt, Snafu};
+use url::Url;
+
+#[derive(Debug, Snafu)]
+enum Error {
+    #[snafu(display("Request error: {}", source))]
+    Request { source: retry::Error },
+
+    #[snafu(display("Request error: {}", source))]
+    Reqwest { source: reqwest::Error },
+
+    #[snafu(display("Range request not supported by {}", href))]
+    RangeNotSupported { href: String },
+
+    #[snafu(display("Error decoding PROPFIND response: {}", source))]
+    InvalidPropFind { source: quick_xml::de::DeError },
+
+    #[snafu(display("Missing content size for {}", href))]
+    MissingSize { href: String },
+
+    #[snafu(display("Error getting properties of \"{}\" got \"{}\"", href, status))]
+    PropStatus { href: String, status: String },
+
+    #[snafu(display("Failed to parse href \"{}\": {}", href, source))]
+    InvalidHref {
+        href: String,
+        source: url::ParseError,
+    },
+
+    #[snafu(display("Path \"{}\" contained non-unicode characters: {}", path, source))]
+    NonUnicode {
+        path: String,
+        source: std::str::Utf8Error,
+    },
+
+    #[snafu(display("Encountered invalid path \"{}\": {}", path, source))]
+    InvalidPath {
+        path: String,
+        source: crate::path::Error,
+    },
+}
+
+impl From<Error> for crate::Error {
+    fn from(err: Error) -> Self {
+        Self::Generic {
+            store: "HTTP",
+            source: Box::new(err),
+        }
+    }
+}
+
+/// Internal client for HttpStore
+#[derive(Debug)]
+pub struct Client {
+    url: Url,
+    client: reqwest::Client,
+    retry_config: RetryConfig,
+    client_options: ClientOptions,
+}
+
+impl Client {
+    pub fn new(url: Url, client_options: ClientOptions, retry_config: RetryConfig) -> Result<Self> {
+        let client = client_options.client()?;
+        Ok(Self {
+            url,
+            retry_config,
+            client_options,
+            client,
+        })
+    }
+
+    pub fn base_url(&self) -> &Url {
+        &self.url
+    }
+
+    fn path_url(&self, location: &Path) -> Url {
+        let mut url = self.url.clone();
+        url.path_segments_mut().unwrap().extend(location.parts());
+        url
+    }
+
+    /// Create a directory with `path` using MKCOL
+    async fn make_directory(&self, path: &str) -> Result<(), Error> {
+        let method = Method::from_bytes(b"MKCOL").unwrap();
+        let mut url = self.url.clone();
+        url.path_segments_mut()
+            .unwrap()
+            .extend(path.split(DELIMITER));
+
+        self.client
+            .request(method, url)
+            .send_retry(&self.retry_config)
+            .await
+            .context(RequestSnafu)?;
+
+        Ok(())
+    }
+
+    /// Recursively create parent directories
+    async fn create_parent_directories(&self, location: &Path) -> Result<()> {
+        let mut stack = vec![];
+
+        // Walk backwards until a request succeeds
+        let mut last_prefix = location.as_ref();
+        while let Some((prefix, _)) = last_prefix.rsplit_once(DELIMITER) {
+            last_prefix = prefix;
+
+            match self.make_directory(prefix).await {
+                Ok(_) => break,
+                Err(Error::Request { source })
+                    if matches!(source.status(), Some(StatusCode::CONFLICT)) =>
+                {
+                    // Need to create parent
+                    stack.push(prefix)
+                }
+                Err(e) => return Err(e.into()),
+            }
+        }
+
+        // Retry the failed requests, which should now succeed
+        for prefix in stack.into_iter().rev() {
+            self.make_directory(prefix).await?;
+        }
+
+        Ok(())
+    }
+
+    pub async fn put(&self, location: &Path, bytes: Bytes) -> Result<Response> {
+        let mut retry = false;
+        loop {
+            let url = self.path_url(location);
+            let mut builder = self.client.put(url).body(bytes.clone());
+            if let Some(value) = self.client_options.get_content_type(location) {
+                builder = builder.header(CONTENT_TYPE, value);
+            }
+
+            match builder.send_retry(&self.retry_config).await {
+                Ok(response) => return Ok(response),
+                Err(source) => match source.status() {
+                    // Some implementations return 404 instead of 409
+                    Some(StatusCode::CONFLICT | StatusCode::NOT_FOUND) if !retry => {
+                        retry = true;
+                        self.create_parent_directories(location).await?
+                    }
+                    _ => return Err(Error::Request { source }.into()),
+                },
+            }
+        }
+    }
+
+    pub async fn list(&self, location: Option<&Path>, depth: &str) -> Result<MultiStatus> {
+        let url = location
+            .map(|path| self.path_url(path))
+            .unwrap_or_else(|| self.url.clone());
+
+        let method = Method::from_bytes(b"PROPFIND").unwrap();
+        let result = self
+            .client
+            .request(method, url)
+            .header("Depth", depth)
+            .send_retry(&self.retry_config)
+            .await;
+
+        let response = match result {
+            Ok(result) => result.bytes().await.context(ReqwestSnafu)?,
+            Err(e) if matches!(e.status(), Some(StatusCode::NOT_FOUND)) => {
+                return match depth {
+                    "0" => {
+                        let path = location.map(|x| x.as_ref()).unwrap_or("");
+                        Err(crate::Error::NotFound {
+                            path: path.to_string(),
+                            source: Box::new(e),
+                        })
+                    }
+                    _ => {
+                        // If prefix not found, return empty result set
+                        Ok(Default::default())
+                    }
+                };
+            }
+            Err(source) => return Err(Error::Request { source }.into()),
+        };
+
+        let status = quick_xml::de::from_reader(response.reader()).context(InvalidPropFindSnafu)?;
+        Ok(status)
+    }
+
+    pub async fn delete(&self, path: &Path) -> Result<()> {
+        let url = self.path_url(path);
+        self.client
+            .delete(url)
+            .send_retry(&self.retry_config)
+            .await
+            .map_err(|source| match source.status() {
+                Some(StatusCode::NOT_FOUND) => crate::Error::NotFound {
+                    source: Box::new(source),
+                    path: path.to_string(),
+                },
+                _ => Error::Request { source }.into(),
+            })?;
+        Ok(())
+    }
+
+    pub async fn copy(&self, from: &Path, to: &Path, overwrite: bool) -> Result<()> {
+        let mut retry = false;
+        loop {
+            let method = Method::from_bytes(b"COPY").unwrap();
+
+            let mut builder = self
+                .client
+                .request(method, self.path_url(from))
+                .header("Destination", self.path_url(to).as_str());
+
+            if !overwrite {
+                // While the Overwrite header appears to duplicate
+                // the functionality of the If-Match: * header of HTTP/1.1, If-Match
+                // applies only to the Request-URI, and not to the Destination of a COPY
+                // or MOVE.
+                builder = builder.header("Overwrite", "F");
+            }
+
+            return match builder.send_retry(&self.retry_config).await {
+                Ok(_) => Ok(()),
+                Err(source) => Err(match source.status() {
+                    Some(StatusCode::PRECONDITION_FAILED) if !overwrite => {
+                        crate::Error::AlreadyExists {
+                            path: to.to_string(),
+                            source: Box::new(source),
+                        }
+                    }
+                    // Some implementations return 404 instead of 409
+                    Some(StatusCode::CONFLICT | StatusCode::NOT_FOUND) if !retry => {
+                        retry = true;
+                        self.create_parent_directories(to).await?;
+                        continue;
+                    }
+                    _ => Error::Request { source }.into(),
+                }),
+            };
+        }
+    }
+}
+
+#[async_trait]
+impl GetClient for Client {
+    const STORE: &'static str = "HTTP";
+
+    /// Override the [`HeaderConfig`] to be less strict to support a
+    /// broader range of HTTP servers (#4831)
+    const HEADER_CONFIG: HeaderConfig = HeaderConfig {
+        etag_required: false,
+        last_modified_required: false,
+        version_header: None,
+    };
+
+    async fn get_request(&self, path: &Path, options: GetOptions) -> Result<Response> {
+        let url = self.path_url(path);
+        let method = match options.head {
+            true => Method::HEAD,
+            false => Method::GET,
+        };
+        let has_range = options.range.is_some();
+        let builder = self.client.request(method, url);
+
+        let res = builder
+            .with_get_options(options)
+            .send_retry(&self.retry_config)
+            .await
+            .map_err(|source| match source.status() {
+                // Some stores return METHOD_NOT_ALLOWED for get on directories
+                Some(StatusCode::NOT_FOUND | StatusCode::METHOD_NOT_ALLOWED) => {
+                    crate::Error::NotFound {
+                        source: Box::new(source),
+                        path: path.to_string(),
+                    }
+                }
+                _ => Error::Request { source }.into(),
+            })?;
+
+        // We expect a 206 Partial Content response if a range was requested
+        // a 200 OK response would indicate the server did not fulfill the request
+        if has_range && res.status() != StatusCode::PARTIAL_CONTENT {
+            return Err(crate::Error::NotSupported {
+                source: Box::new(Error::RangeNotSupported {
+                    href: path.to_string(),
+                }),
+            });
+        }
+
+        Ok(res)
+    }
+}
+
+/// The response returned by a PROPFIND request, i.e. list
+#[derive(Deserialize, Default)]
+pub struct MultiStatus {
+    pub response: Vec<MultiStatusResponse>,
+}
+
+#[derive(Deserialize)]
+pub struct MultiStatusResponse {
+    href: String,
+    #[serde(rename = "propstat")]
+    prop_stat: PropStat,
+}
+
+impl MultiStatusResponse {
+    /// Returns an error if this response is not OK
+    pub fn check_ok(&self) -> Result<()> {
+        match self.prop_stat.status.contains("200 OK") {
+            true => Ok(()),
+            false => Err(Error::PropStatus {
+                href: self.href.clone(),
+                status: self.prop_stat.status.clone(),
+            }
+            .into()),
+        }
+    }
+
+    /// Returns the resolved path of this element relative to `base_url`
+    pub fn path(&self, base_url: &Url) -> Result<Path> {
+        let url = Url::options()
+            .base_url(Some(base_url))
+            .parse(&self.href)
+            .context(InvalidHrefSnafu { href: &self.href })?;
+
+        // Reverse any percent encoding
+        let path = percent_decode_str(url.path())
+            .decode_utf8()
+            .context(NonUnicodeSnafu { path: url.path() })?;
+
+        Ok(Path::parse(path.as_ref()).context(InvalidPathSnafu { path })?)
+    }
+
+    fn size(&self) -> Result<usize> {
+        let size = self
+            .prop_stat
+            .prop
+            .content_length
+            .context(MissingSizeSnafu { href: &self.href })?;
+        Ok(size)
+    }
+
+    /// Returns this objects metadata as [`ObjectMeta`]
+    pub fn object_meta(&self, base_url: &Url) -> Result<ObjectMeta> {
+        let last_modified = self.prop_stat.prop.last_modified;
+        Ok(ObjectMeta {
+            location: self.path(base_url)?,
+            last_modified,
+            size: self.size()?,
+            e_tag: self.prop_stat.prop.e_tag.clone(),
+            version: None,
+        })
+    }
+
+    /// Returns true if this is a directory / collection
+    pub fn is_dir(&self) -> bool {
+        self.prop_stat.prop.resource_type.collection.is_some()
+    }
+}
+
+#[derive(Deserialize)]
+pub struct PropStat {
+    prop: Prop,
+    status: String,
+}
+
+#[derive(Deserialize)]
+pub struct Prop {
+    #[serde(deserialize_with = "deserialize_rfc1123", rename = "getlastmodified")]
+    last_modified: DateTime<Utc>,
+
+    #[serde(rename = "getcontentlength")]
+    content_length: Option<usize>,
+
+    #[serde(rename = "resourcetype")]
+    resource_type: ResourceType,
+
+    #[serde(rename = "getetag")]
+    e_tag: Option<String>,
+}
+
+#[derive(Deserialize)]
+pub struct ResourceType {
+    collection: Option<()>,
+}
diff --git a/object_store/src/http/mod.rs b/object_store/src/http/mod.rs
new file mode 100644
index 000000000000..f1d11db4762c
--- /dev/null
+++ b/object_store/src/http/mod.rs
@@ -0,0 +1,273 @@
+// 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.
+
+//! An object store implementation for generic HTTP servers
+//!
+//! This follows [rfc2518] commonly known as [WebDAV]
+//!
+//! Basic get support will work out of the box with most HTTP servers,
+//! even those that don't explicitly support [rfc2518]
+//!
+//! Other operations such as list, delete, copy, etc... will likely
+//! require server-side configuration. A list of HTTP servers with support
+//! can be found [here](https://wiki.archlinux.org/title/WebDAV#Server)
+//!
+//! Multipart uploads are not currently supported
+//!
+//! [rfc2518]: https://datatracker.ietf.org/doc/html/rfc2518
+//! [WebDAV]: https://en.wikipedia.org/wiki/WebDAV
+
+use async_trait::async_trait;
+use bytes::Bytes;
+use futures::stream::BoxStream;
+use futures::{StreamExt, TryStreamExt};
+use itertools::Itertools;
+use snafu::{OptionExt, ResultExt, Snafu};
+use tokio::io::AsyncWrite;
+use url::Url;
+
+use crate::client::get::GetClientExt;
+use crate::client::header::get_etag;
+use crate::http::client::Client;
+use crate::path::Path;
+use crate::{
+    ClientConfigKey, ClientOptions, GetOptions, GetResult, ListResult, MultipartId, ObjectMeta,
+    ObjectStore, PutMode, PutOptions, PutResult, Result, RetryConfig,
+};
+
+mod client;
+
+#[derive(Debug, Snafu)]
+enum Error {
+    #[snafu(display("Must specify a URL"))]
+    MissingUrl,
+
+    #[snafu(display("Unable parse source url. Url: {}, Error: {}", url, source))]
+    UnableToParseUrl {
+        source: url::ParseError,
+        url: String,
+    },
+
+    #[snafu(display("Unable to extract metadata from headers: {}", source))]
+    Metadata {
+        source: crate::client::header::Error,
+    },
+
+    #[snafu(display("Request error: {}", source))]
+    Reqwest { source: reqwest::Error },
+}
+
+impl From<Error> for crate::Error {
+    fn from(err: Error) -> Self {
+        Self::Generic {
+            store: "HTTP",
+            source: Box::new(err),
+        }
+    }
+}
+
+/// An [`ObjectStore`] implementation for generic HTTP servers
+///
+/// See [`crate::http`] for more information
+#[derive(Debug)]
+pub struct HttpStore {
+    client: Client,
+}
+
+impl std::fmt::Display for HttpStore {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "HttpStore")
+    }
+}
+
+#[async_trait]
+impl ObjectStore for HttpStore {
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        if opts.mode != PutMode::Overwrite {
+            // TODO: Add support for If header - https://datatracker.ietf.org/doc/html/rfc2518#section-9.4
+            return Err(crate::Error::NotImplemented);
+        }
+
+        let response = self.client.put(location, bytes).await?;
+        let e_tag = match get_etag(response.headers()) {
+            Ok(e_tag) => Some(e_tag),
+            Err(crate::client::header::Error::MissingEtag) => None,
+            Err(source) => return Err(Error::Metadata { source }.into()),
+        };
+
+        Ok(PutResult {
+            e_tag,
+            version: None,
+        })
+    }
+
+    async fn put_multipart(
+        &self,
+        _location: &Path,
+    ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
+        Err(super::Error::NotImplemented)
+    }
+
+    async fn abort_multipart(&self, _location: &Path, _multipart_id: &MultipartId) -> Result<()> {
+        Err(super::Error::NotImplemented)
+    }
+
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        self.client.get_opts(location, options).await
+    }
+
+    async fn delete(&self, location: &Path) -> Result<()> {
+        self.client.delete(location).await
+    }
+
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        let prefix_len = prefix.map(|p| p.as_ref().len()).unwrap_or_default();
+        let prefix = prefix.cloned();
+        futures::stream::once(async move {
+            let status = self.client.list(prefix.as_ref(), "infinity").await?;
+
+            let iter = status
+                .response
+                .into_iter()
+                .filter(|r| !r.is_dir())
+                .map(|response| {
+                    response.check_ok()?;
+                    response.object_meta(self.client.base_url())
+                })
+                // Filter out exact prefix matches
+                .filter_ok(move |r| r.location.as_ref().len() > prefix_len);
+
+            Ok::<_, crate::Error>(futures::stream::iter(iter))
+        })
+        .try_flatten()
+        .boxed()
+    }
+
+    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
+        let status = self.client.list(prefix, "1").await?;
+        let prefix_len = prefix.map(|p| p.as_ref().len()).unwrap_or(0);
+
+        let mut objects: Vec<ObjectMeta> = Vec::with_capacity(status.response.len());
+        let mut common_prefixes = Vec::with_capacity(status.response.len());
+        for response in status.response {
+            response.check_ok()?;
+            match response.is_dir() {
+                false => {
+                    let meta = response.object_meta(self.client.base_url())?;
+                    // Filter out exact prefix matches
+                    if meta.location.as_ref().len() > prefix_len {
+                        objects.push(meta);
+                    }
+                }
+                true => {
+                    let path = response.path(self.client.base_url())?;
+                    // Exclude the current object
+                    if path.as_ref().len() > prefix_len {
+                        common_prefixes.push(path);
+                    }
+                }
+            }
+        }
+
+        Ok(ListResult {
+            common_prefixes,
+            objects,
+        })
+    }
+
+    async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
+        self.client.copy(from, to, true).await
+    }
+
+    async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
+        self.client.copy(from, to, false).await
+    }
+}
+
+/// Configure a connection to a generic HTTP server
+#[derive(Debug, Default, Clone)]
+pub struct HttpBuilder {
+    url: Option<String>,
+    client_options: ClientOptions,
+    retry_config: RetryConfig,
+}
+
+impl HttpBuilder {
+    /// Create a new [`HttpBuilder`] with default values.
+    pub fn new() -> Self {
+        Default::default()
+    }
+
+    /// Set the URL
+    pub fn with_url(mut self, url: impl Into<String>) -> Self {
+        self.url = Some(url.into());
+        self
+    }
+
+    /// Set the retry configuration
+    pub fn with_retry(mut self, retry_config: RetryConfig) -> Self {
+        self.retry_config = retry_config;
+        self
+    }
+
+    /// Set individual client configuration without overriding the entire config
+    pub fn with_config(mut self, key: ClientConfigKey, value: impl Into<String>) -> Self {
+        self.client_options = self.client_options.with_config(key, value);
+        self
+    }
+
+    /// Sets the client options, overriding any already set
+    pub fn with_client_options(mut self, options: ClientOptions) -> Self {
+        self.client_options = options;
+        self
+    }
+
+    /// Build an [`HttpStore`] with the configured options
+    pub fn build(self) -> Result<HttpStore> {
+        let url = self.url.context(MissingUrlSnafu)?;
+        let parsed = Url::parse(&url).context(UnableToParseUrlSnafu { url })?;
+
+        Ok(HttpStore {
+            client: Client::new(parsed, self.client_options, self.retry_config)?,
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::tests::*;
+
+    use super::*;
+
+    #[tokio::test]
+    async fn http_test() {
+        crate::test_util::maybe_skip_integration!();
+        let url = std::env::var("HTTP_URL").expect("HTTP_URL must be set");
+        let options = ClientOptions::new().with_allow_http(true);
+        let integration = HttpBuilder::new()
+            .with_url(url)
+            .with_client_options(options)
+            .build()
+            .unwrap();
+
+        put_get_delete_list_opts(&integration).await;
+        list_uses_directories_correctly(&integration).await;
+        list_with_delimiter(&integration).await;
+        rename_and_copy(&integration).await;
+        copy_if_not_exists(&integration).await;
+    }
+}
diff --git a/object_store/src/lib.rs b/object_store/src/lib.rs
index f7adedb2682c..af5676ef5003 100644
--- a/object_store/src/lib.rs
+++ b/object_store/src/lib.rs
@@ -28,17 +28,80 @@
 
 //! # object_store
 //!
-//! This crate provides a uniform API for interacting with object storage services and
-//! local files via the the [`ObjectStore`] trait.
+//! This crate provides a uniform API for interacting with object
+//! storage services and local files via the [`ObjectStore`]
+//! trait.
 //!
-//! # Create an [`ObjectStore`] implementation:
+//! Using this crate, the same binary and code can run in multiple
+//! clouds and local test environments, via a simple runtime
+//! configuration change.
 //!
-//! * [Google Cloud Storage](https://cloud.google.com/storage/): [`GoogleCloudStorageBuilder`](gcp::GoogleCloudStorageBuilder)
-//! * [Amazon S3](https://aws.amazon.com/s3/): [`AmazonS3Builder`](aws::AmazonS3Builder)
-//! * [Azure Blob Storage](https://azure.microsoft.com/en-gb/services/storage/blobs/):: [`MicrosoftAzureBuilder`](azure::MicrosoftAzureBuilder)
-//! * In Memory: [`InMemory`](memory::InMemory)
+//! # Highlights
+//!
+//! 1. A high-performance async API focused on providing a consistent interface
+//! mirroring that of object stores such as [S3]
+//!
+//! 2. Production quality, leading this crate to be used in large
+//! scale production systems, such as [crates.io] and [InfluxDB IOx]
+//!
+//! 3. Support for advanced functionality, including atomic, conditional reads
+//! and writes, vectored IO, bulk deletion, and more...
+//!
+//! 4. Stable and predictable governance via the [Apache Arrow] project
+//!
+//! 5. Small dependency footprint, depending on only a small number of common crates
+//!
+//! Originally developed by [InfluxData] and subsequently donated
+//! to [Apache Arrow].
+//!
+//! [Apache Arrow]: https://arrow.apache.org/
+//! [InfluxData]: https://www.influxdata.com/
+//! [crates.io]: https://github.com/rust-lang/crates.io
+//! [ACID]: https://en.wikipedia.org/wiki/ACID
+//! [S3]: https://aws.amazon.com/s3/
+//!
+//! # Available [`ObjectStore`] Implementations
+//!
+//! By default, this crate provides the following implementations:
+//!
+//! * Memory: [`InMemory`](memory::InMemory)
 //! * Local filesystem: [`LocalFileSystem`](local::LocalFileSystem)
 //!
+//! Feature flags are used to enable support for other implementations:
+//!
+#![cfg_attr(
+    feature = "gcp",
+    doc = "* [`gcp`]: [Google Cloud Storage](https://cloud.google.com/storage/) support. See [`GoogleCloudStorageBuilder`](gcp::GoogleCloudStorageBuilder)"
+)]
+#![cfg_attr(
+    feature = "aws",
+    doc = "* [`aws`]: [Amazon S3](https://aws.amazon.com/s3/). See [`AmazonS3Builder`](aws::AmazonS3Builder)"
+)]
+#![cfg_attr(
+    feature = "azure",
+    doc = "* [`azure`]: [Azure Blob Storage](https://azure.microsoft.com/en-gb/services/storage/blobs/). See [`MicrosoftAzureBuilder`](azure::MicrosoftAzureBuilder)"
+)]
+#![cfg_attr(
+    feature = "http",
+    doc = "* [`http`]: [HTTP/WebDAV Storage](https://datatracker.ietf.org/doc/html/rfc2518). See [`HttpBuilder`](http::HttpBuilder)"
+)]
+//!
+//! # Why not a Filesystem Interface?
+//!
+//! Whilst this crate does provide a [`BufReader`], the [`ObjectStore`] interface mirrors the APIs
+//! of object stores and not filesystems, opting to provide stateless APIs instead of the cursor
+//! based interfaces such as [`Read`] or [`Seek`] favoured by filesystems.
+//!
+//! This provides some compelling advantages:
+//!
+//! * All operations are atomic, and readers cannot observe partial and/or failed writes
+//! * Methods map directly to object store APIs, providing both efficiency and predictability
+//! * Abstracts away filesystem and operating system specific quirks, ensuring portability
+//! * Allows for functionality not native to filesystems, such as operation preconditions
+//! and atomic multipart uploads
+//!
+//! [`BufReader`]: buffered::BufReader
+//!
 //! # Adapters
 //!
 //! [`ObjectStore`] instances can be composed with various adapters
@@ -47,48 +110,76 @@
 //! * Rate Throttling: [`ThrottleConfig`](throttle::ThrottleConfig)
 //! * Concurrent Request Limit: [`LimitStore`](limit::LimitStore)
 //!
+//! # Configuration System
 //!
-//! # Listing objects:
+//! This crate provides a configuration system inspired by the APIs exposed by [fsspec],
+//! [PyArrow FileSystem], and [Hadoop FileSystem], allowing creating a [`DynObjectStore`]
+//! from a URL and an optional list of key value pairs. This provides a flexible interface
+//! to support a wide variety of user-defined store configurations, with minimal additional
+//! application complexity.
+//!
+//! ```no_run
+//! # #[cfg(feature = "aws")] {
+//! # use url::Url;
+//! # use object_store::{parse_url, parse_url_opts};
+//! # use object_store::aws::{AmazonS3, AmazonS3Builder};
+//! #
+//! #
+//! // Can manually create a specific store variant using the appropriate builder
+//! let store: AmazonS3 = AmazonS3Builder::from_env()
+//!     .with_bucket_name("my-bucket").build().unwrap();
+//!
+//! // Alternatively can create an ObjectStore from an S3 URL
+//! let url = Url::parse("s3://bucket/path").unwrap();
+//! let (store, path) = parse_url(&url).unwrap();
+//! assert_eq!(path.as_ref(), "path");
+//!
+//! // Potentially with additional options
+//! let (store, path) = parse_url_opts(&url, vec![("aws_access_key_id", "...")]).unwrap();
+//!
+//! // Or with URLs that encode the bucket name in the URL path
+//! let url = Url::parse("https://ACCOUNT_ID.r2.cloudflarestorage.com/bucket/path").unwrap();
+//! let (store, path) = parse_url(&url).unwrap();
+//! assert_eq!(path.as_ref(), "path");
+//! # }
+//! ```
+//!
+//! [PyArrow FileSystem]: https://arrow.apache.org/docs/python/generated/pyarrow.fs.FileSystem.html#pyarrow.fs.FileSystem.from_uri
+//! [fsspec]: https://filesystem-spec.readthedocs.io/en/latest/api.html#fsspec.filesystem
+//! [Hadoop FileSystem]: https://hadoop.apache.org/docs/r3.0.0/api/org/apache/hadoop/fs/FileSystem.html#get-java.net.URI-org.apache.hadoop.conf.Configuration-
+//!
+//! # List objects
 //!
 //! Use the [`ObjectStore::list`] method to iterate over objects in
 //! remote storage or files in the local filesystem:
 //!
 //! ```
 //! # use object_store::local::LocalFileSystem;
+//! # use std::sync::Arc;
+//! # use object_store::{path::Path, ObjectStore};
+//! # use futures::stream::StreamExt;
 //! # // use LocalFileSystem for example
-//! # fn get_object_store() -> LocalFileSystem {
-//! #   LocalFileSystem::new_with_prefix("/tmp").unwrap()
+//! # fn get_object_store() -> Arc<dyn ObjectStore> {
+//! #   Arc::new(LocalFileSystem::new())
 //! # }
-//!
+//! #
 //! # async fn example() {
-//! use std::sync::Arc;
-//! use object_store::{path::Path, ObjectStore};
-//! use futures::stream::StreamExt;
-//!
+//! #
 //! // create an ObjectStore
-//! let object_store: Arc<dyn ObjectStore> = Arc::new(get_object_store());
+//! let object_store: Arc<dyn ObjectStore> = get_object_store();
 //!
 //! // Recursively list all files below the 'data' path.
 //! // 1. On AWS S3 this would be the 'data/' prefix
 //! // 2. On a local filesystem, this would be the 'data' directory
-//! let prefix: Path = "data".try_into().unwrap();
+//! let prefix = Path::from("data");
 //!
 //! // Get an `async` stream of Metadata objects:
-//!  let list_stream = object_store
-//!      .list(Some(&prefix))
-//!      .await
-//!      .expect("Error listing files");
-//!
-//!  // Print a line about each object based on its metadata
-//!  // using for_each from `StreamExt` trait.
-//!  list_stream
-//!      .for_each(move |meta|  {
-//!          async {
-//!              let meta = meta.expect("Error listing");
-//!              println!("Name: {}, size: {}", meta.location, meta.size);
-//!          }
-//!      })
-//!      .await;
+//! let mut list_stream = object_store.list(Some(&prefix));
+//!
+//! // Print a line about each object
+//! while let Some(meta) = list_stream.next().await.transpose().unwrap() {
+//!     println!("Name: {}, size: {}", meta.location, meta.size);
+//! }
 //! # }
 //! ```
 //!
@@ -101,92 +192,329 @@
 //! ...
 //! ```
 //!
-//! # Fetching objects
+//! # Fetch objects
 //!
 //! Use the [`ObjectStore::get`] method to fetch the data bytes
 //! from remote storage or files in the local filesystem as a stream.
 //!
 //! ```
+//! # use futures::TryStreamExt;
 //! # use object_store::local::LocalFileSystem;
-//! # // use LocalFileSystem for example
-//! # fn get_object_store() -> LocalFileSystem {
-//! #   LocalFileSystem::new_with_prefix("/tmp").unwrap()
+//! # use std::sync::Arc;
+//! #  use bytes::Bytes;
+//! # use object_store::{path::Path, ObjectStore, GetResult};
+//! # fn get_object_store() -> Arc<dyn ObjectStore> {
+//! #   Arc::new(LocalFileSystem::new())
 //! # }
-//!
+//! #
 //! # async fn example() {
-//! use std::sync::Arc;
-//! use object_store::{path::Path, ObjectStore};
-//! use futures::stream::StreamExt;
-//!
-//! // create an ObjectStore
-//! let object_store: Arc<dyn ObjectStore> = Arc::new(get_object_store());
+//! #
+//! // Create an ObjectStore
+//! let object_store: Arc<dyn ObjectStore> = get_object_store();
 //!
 //! // Retrieve a specific file
-//! let path: Path = "data/file01.parquet".try_into().unwrap();
+//! let path = Path::from("data/file01.parquet");
+//!
+//! // Fetch just the file metadata
+//! let meta = object_store.head(&path).await.unwrap();
+//! println!("{meta:?}");
 //!
-//! // fetch the bytes from object store
-//! let stream = object_store
-//!     .get(&path)
-//!     .await
-//!     .unwrap()
-//!     .into_stream();
+//! // Fetch the object including metadata
+//! let result: GetResult = object_store.get(&path).await.unwrap();
+//! assert_eq!(result.meta, meta);
 //!
-//! // Count the '0's using `map` from `StreamExt` trait
+//! // Buffer the entire object in memory
+//! let object: Bytes = result.bytes().await.unwrap();
+//! assert_eq!(object.len(), meta.size);
+//!
+//! // Alternatively stream the bytes from object storage
+//! let stream = object_store.get(&path).await.unwrap().into_stream();
+//!
+//! // Count the '0's using `try_fold` from `TryStreamExt` trait
 //! let num_zeros = stream
-//!     .map(|bytes| {
-//!         let bytes = bytes.unwrap();
-//!        bytes.iter().filter(|b| **b == 0).count()
-//!     })
-//!     .collect::<Vec<usize>>()
-//!     .await
-//!     .into_iter()
-//!     .sum::<usize>();
+//!     .try_fold(0, |acc, bytes| async move {
+//!         Ok(acc + bytes.iter().filter(|b| **b == 0).count())
+//!     }).await.unwrap();
 //!
 //! println!("Num zeros in {} is {}", path, num_zeros);
 //! # }
 //! ```
 //!
-//! Which will print out something like the following:
+//! #  Put Object
+//!
+//! Use the [`ObjectStore::put`] method to atomically write data.
+//!
+//! ```
+//! # use object_store::local::LocalFileSystem;
+//! # use object_store::ObjectStore;
+//! # use std::sync::Arc;
+//! # use bytes::Bytes;
+//! # use object_store::path::Path;
+//! # fn get_object_store() -> Arc<dyn ObjectStore> {
+//! #   Arc::new(LocalFileSystem::new())
+//! # }
+//! # async fn put() {
+//! #
+//! let object_store: Arc<dyn ObjectStore> = get_object_store();
+//! let path = Path::from("data/file1");
+//! let bytes = Bytes::from_static(b"hello");
+//! object_store.put(&path, bytes).await.unwrap();
+//! # }
+//! ```
+//!
+//! #  Multipart Upload
+//!
+//! Use the [`ObjectStore::put_multipart`] method to atomically write a large amount of data,
+//! with implementations automatically handling parallel, chunked upload where appropriate.
+//!
+//! ```
+//! # use object_store::local::LocalFileSystem;
+//! # use object_store::ObjectStore;
+//! # use std::sync::Arc;
+//! # use bytes::Bytes;
+//! # use tokio::io::AsyncWriteExt;
+//! # use object_store::path::Path;
+//! # fn get_object_store() -> Arc<dyn ObjectStore> {
+//! #   Arc::new(LocalFileSystem::new())
+//! # }
+//! # async fn multi_upload() {
+//! #
+//! let object_store: Arc<dyn ObjectStore> = get_object_store();
+//! let path = Path::from("data/large_file");
+//! let (_id, mut writer) =  object_store.put_multipart(&path).await.unwrap();
+//!
+//! let bytes = Bytes::from_static(b"hello");
+//! writer.write_all(&bytes).await.unwrap();
+//! writer.flush().await.unwrap();
+//! writer.shutdown().await.unwrap();
+//! # }
+//! ```
+//!
+//! # Vectored Read
+//!
+//! A common pattern, especially when reading structured datasets, is to need to fetch
+//! multiple, potentially non-contiguous, ranges of a particular object.
+//!
+//! [`ObjectStore::get_ranges`] provides an efficient way to perform such vectored IO, and will
+//! automatically coalesce adjacent ranges into an appropriate number of parallel requests.
 //!
-//! ```text
-//! Num zeros in data/file01.parquet is 657
 //! ```
+//! # use object_store::local::LocalFileSystem;
+//! # use object_store::ObjectStore;
+//! # use std::sync::Arc;
+//! # use bytes::Bytes;
+//! # use tokio::io::AsyncWriteExt;
+//! # use object_store::path::Path;
+//! # fn get_object_store() -> Arc<dyn ObjectStore> {
+//! #   Arc::new(LocalFileSystem::new())
+//! # }
+//! # async fn multi_upload() {
+//! #
+//! let object_store: Arc<dyn ObjectStore> = get_object_store();
+//! let path = Path::from("data/large_file");
+//! let ranges = object_store.get_ranges(&path, &[90..100, 400..600, 0..10]).await.unwrap();
+//! assert_eq!(ranges.len(), 3);
+//! assert_eq!(ranges[0].len(), 10);
+//! # }
+//! ```
+//!
+//! # Conditional Fetch
+//!
+//! More complex object retrieval can be supported by [`ObjectStore::get_opts`].
+//!
+//! For example, efficiently refreshing a cache without re-fetching the entire object
+//! data if the object hasn't been modified.
+//!
+//! ```
+//! # use std::collections::btree_map::Entry;
+//! # use std::collections::HashMap;
+//! # use object_store::{GetOptions, GetResult, ObjectStore, Result, Error};
+//! # use std::sync::Arc;
+//! # use std::time::{Duration, Instant};
+//! # use bytes::Bytes;
+//! # use tokio::io::AsyncWriteExt;
+//! # use object_store::path::Path;
+//! struct CacheEntry {
+//!     /// Data returned by last request
+//!     data: Bytes,
+//!     /// ETag identifying the object returned by the server
+//!     e_tag: String,
+//!     /// Instant of last refresh
+//!     refreshed_at: Instant,
+//! }
+//!
+//! /// Example cache that checks entries after 10 seconds for a new version
+//! struct Cache {
+//!     entries: HashMap<Path, CacheEntry>,
+//!     store: Arc<dyn ObjectStore>,
+//! }
+//!
+//! impl Cache {
+//!     pub async fn get(&mut self, path: &Path) -> Result<Bytes> {
+//!         Ok(match self.entries.get_mut(path) {
+//!             Some(e) => match e.refreshed_at.elapsed() < Duration::from_secs(10) {
+//!                 true => e.data.clone(), // Return cached data
+//!                 false => { // Check if remote version has changed
+//!                     let opts = GetOptions {
+//!                         if_none_match: Some(e.e_tag.clone()),
+//!                         ..GetOptions::default()
+//!                     };
+//!                     match self.store.get_opts(&path, opts).await {
+//!                         Ok(d) => e.data = d.bytes().await?,
+//!                         Err(Error::NotModified { .. }) => {} // Data has not changed
+//!                         Err(e) => return Err(e),
+//!                     };
+//!                     e.refreshed_at = Instant::now();
+//!                     e.data.clone()
+//!                 }
+//!             },
+//!             None => { // Not cached, fetch data
+//!                 let get = self.store.get(&path).await?;
+//!                 let e_tag = get.meta.e_tag.clone();
+//!                 let data = get.bytes().await?;
+//!                 if let Some(e_tag) = e_tag {
+//!                     let entry = CacheEntry {
+//!                         e_tag,
+//!                         data: data.clone(),
+//!                         refreshed_at: Instant::now(),
+//!                     };
+//!                     self.entries.insert(path.clone(), entry);
+//!                 }
+//!                 data
+//!             }
+//!         })
+//!     }
+//! }
+//! ```
+//!
+//! # Conditional Put
+//!
+//! The default behaviour when writing data is to upsert any existing object at the given path,
+//! overwriting any previous value. More complex behaviours can be achieved using [`PutMode`], and
+//! can be used to build [Optimistic Concurrency Control] based transactions. This facilitates
+//! building metadata catalogs, such as [Apache Iceberg] or [Delta Lake], directly on top of object
+//! storage, without relying on a separate DBMS.
+//!
+//! ```
+//! # use object_store::{Error, ObjectStore, PutMode, UpdateVersion};
+//! # use std::sync::Arc;
+//! # use bytes::Bytes;
+//! # use tokio::io::AsyncWriteExt;
+//! # use object_store::memory::InMemory;
+//! # use object_store::path::Path;
+//! # fn get_object_store() -> Arc<dyn ObjectStore> {
+//! #   Arc::new(InMemory::new())
+//! # }
+//! # fn do_update(b: Bytes) -> Bytes {b}
+//! # async fn conditional_put() {
+//! let store = get_object_store();
+//! let path = Path::from("test");
+//!
+//! // Perform a conditional update on path
+//! loop {
+//!     // Perform get request
+//!     let r = store.get(&path).await.unwrap();
+//!
+//!     // Save version information fetched
+//!     let version = UpdateVersion {
+//!         e_tag: r.meta.e_tag.clone(),
+//!         version: r.meta.version.clone(),
+//!     };
+//!
+//!     // Compute new version of object contents
+//!     let new = do_update(r.bytes().await.unwrap());
+//!
+//!     // Attempt to commit transaction
+//!     match store.put_opts(&path, new, PutMode::Update(version).into()).await {
+//!         Ok(_) => break, // Successfully committed
+//!         Err(Error::Precondition { .. }) => continue, // Object has changed, try again
+//!         Err(e) => panic!("{e}")
+//!     }
+//! }
+//! # }
+//! ```
+//!
+//! [Optimistic Concurrency Control]: https://en.wikipedia.org/wiki/Optimistic_concurrency_control
+//! [Apache Iceberg]: https://iceberg.apache.org/
+//! [Delta Lake]: https://delta.io/
+//!
+//! # TLS Certificates
+//!
+//! Stores that use HTTPS/TLS (this is true for most cloud stores) can choose the source of their [CA]
+//! certificates. By default the system-bundled certificates are used (see
+//! [`rustls-native-certs`]). The `tls-webpki-roots` feature switch can be used to also bundle Mozilla's
+//! root certificates with the library/application (see [`webpki-roots`]).
+//!
+//! [CA]: https://en.wikipedia.org/wiki/Certificate_authority
+//! [`rustls-native-certs`]: https://crates.io/crates/rustls-native-certs/
+//! [`webpki-roots`]: https://crates.io/crates/webpki-roots
 //!
 
+#[cfg(all(
+    target_arch = "wasm32",
+    any(feature = "gcp", feature = "aws", feature = "azure", feature = "http")
+))]
+compile_error!("Features 'gcp', 'aws', 'azure', 'http' are not supported on wasm.");
+
 #[cfg(feature = "aws")]
 pub mod aws;
 #[cfg(feature = "azure")]
 pub mod azure;
+pub mod buffered;
+#[cfg(not(target_arch = "wasm32"))]
+pub mod chunked;
+pub mod delimited;
 #[cfg(feature = "gcp")]
 pub mod gcp;
+#[cfg(feature = "http")]
+pub mod http;
 pub mod limit;
+#[cfg(not(target_arch = "wasm32"))]
 pub mod local;
 pub mod memory;
 pub mod path;
+pub mod prefix;
+#[cfg(feature = "cloud")]
+pub mod signer;
 pub mod throttle;
 
-#[cfg(feature = "gcp")]
+#[cfg(feature = "cloud")]
 mod client;
 
-#[cfg(feature = "gcp")]
-pub use client::{backoff::BackoffConfig, retry::RetryConfig};
+#[cfg(feature = "cloud")]
+pub use client::{
+    backoff::BackoffConfig, retry::RetryConfig, ClientConfigKey, ClientOptions, CredentialProvider,
+    StaticCredentialProvider,
+};
+
+#[cfg(feature = "cloud")]
+mod config;
+
+mod tags;
 
-#[cfg(any(feature = "azure", feature = "aws", feature = "gcp"))]
-mod multipart;
+pub use tags::TagSet;
+
+pub mod multipart;
+mod parse;
 mod util;
 
+pub use parse::{parse_url, parse_url_opts};
+pub use util::GetRange;
+
 use crate::path::Path;
-use crate::util::{
-    coalesce_ranges, collect_bytes, maybe_spawn_blocking, OBJECT_STORE_COALESCE_DEFAULT,
-};
+#[cfg(not(target_arch = "wasm32"))]
+use crate::util::maybe_spawn_blocking;
+pub use crate::util::{coalesce_ranges, collect_bytes, OBJECT_STORE_COALESCE_DEFAULT};
 use async_trait::async_trait;
 use bytes::Bytes;
 use chrono::{DateTime, Utc};
-use futures::{stream::BoxStream, StreamExt};
+use futures::{stream::BoxStream, StreamExt, TryStreamExt};
 use snafu::Snafu;
 use std::fmt::{Debug, Formatter};
+#[cfg(not(target_arch = "wasm32"))]
 use std::io::{Read, Seek, SeekFrom};
 use std::ops::Range;
+use std::sync::Arc;
 use tokio::io::AsyncWrite;
 
 /// An alias for a dynamically dispatched object store implementation.
@@ -198,19 +526,50 @@ pub type MultipartId = String;
 /// Universal API to multiple object store services.
 #[async_trait]
 pub trait ObjectStore: std::fmt::Display + Send + Sync + Debug + 'static {
-    /// Save the provided bytes to the specified location.
-    async fn put(&self, location: &Path, bytes: Bytes) -> Result<()>;
+    /// Save the provided bytes to the specified location
+    ///
+    /// The operation is guaranteed to be atomic, it will either successfully
+    /// write the entirety of `bytes` to `location`, or fail. No clients
+    /// should be able to observe a partially written object
+    async fn put(&self, location: &Path, bytes: Bytes) -> Result<PutResult> {
+        self.put_opts(location, bytes, PutOptions::default()).await
+    }
+
+    /// Save the provided bytes to the specified location with the given options
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult>;
 
-    /// Get a multi-part upload that allows writing data in chunks
+    /// Get a multi-part upload that allows writing data in chunks.
     ///
     /// Most cloud-based uploads will buffer and upload parts in parallel.
     ///
     /// To complete the upload, [AsyncWrite::poll_shutdown] must be called
-    /// to completion.
+    /// to completion. This operation is guaranteed to be atomic, it will either
+    /// make all the written data available at `location`, or fail. No clients
+    /// should be able to observe a partially written object.
     ///
     /// For some object stores (S3, GCS, and local in particular), if the
     /// writer fails or panics, you must call [ObjectStore::abort_multipart]
     /// to clean up partially written data.
+    ///
+    /// <div class="warning">
+    /// It is recommended applications wait for any in-flight requests to complete by calling `flush`, if
+    /// there may be a significant gap in time (> ~30s) before the next write.
+    /// These gaps can include times where the function returns control to the
+    /// caller while keeping the writer open. If `flush` is not called, futures
+    /// for in-flight requests may be left unpolled long enough for the requests
+    /// to time out, causing the write to fail.
+    /// </div>
+    ///
+    /// For applications requiring fine-grained control of multipart uploads
+    /// see [`MultiPartStore`], although note that this interface cannot be
+    /// supported by all [`ObjectStore`] backends.
+    ///
+    /// For applications looking to implement this interface for a custom
+    /// multipart API, see [`WriteMultiPart`] which handles the complexities
+    /// of performing parallel uploads of fixed size parts.
+    ///
+    /// [`WriteMultiPart`]: multipart::WriteMultiPart
+    /// [`MultiPartStore`]: multipart::MultiPartStore
     async fn put_multipart(
         &self,
         location: &Path,
@@ -220,26 +579,31 @@ pub trait ObjectStore: std::fmt::Display + Send + Sync + Debug + 'static {
     ///
     /// See documentation for individual stores for exact behavior, as capabilities
     /// vary by object store.
-    async fn abort_multipart(
-        &self,
-        location: &Path,
-        multipart_id: &MultipartId,
-    ) -> Result<()>;
+    async fn abort_multipart(&self, location: &Path, multipart_id: &MultipartId) -> Result<()>;
 
     /// Return the bytes that are stored at the specified location.
-    async fn get(&self, location: &Path) -> Result<GetResult>;
+    async fn get(&self, location: &Path) -> Result<GetResult> {
+        self.get_opts(location, GetOptions::default()).await
+    }
+
+    /// Perform a get request with options
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult>;
 
     /// Return the bytes that are stored at the specified location
-    /// in the given byte range
-    async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes>;
+    /// in the given byte range.
+    ///
+    /// See [`GetRange::Bounded`] for more details on how `range` gets interpreted
+    async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes> {
+        let options = GetOptions {
+            range: Some(range.into()),
+            ..Default::default()
+        };
+        self.get_opts(location, options).await?.bytes().await
+    }
 
     /// Return the bytes that are stored at the specified location
     /// in the given byte ranges
-    async fn get_ranges(
-        &self,
-        location: &Path,
-        ranges: &[Range<usize>],
-    ) -> Result<Vec<Bytes>> {
+    async fn get_ranges(&self, location: &Path, ranges: &[Range<usize>]) -> Result<Vec<Bytes>> {
         coalesce_ranges(
             ranges,
             |range| self.get_range(location, range),
@@ -249,19 +613,97 @@ pub trait ObjectStore: std::fmt::Display + Send + Sync + Debug + 'static {
     }
 
     /// Return the metadata for the specified location
-    async fn head(&self, location: &Path) -> Result<ObjectMeta>;
+    async fn head(&self, location: &Path) -> Result<ObjectMeta> {
+        let options = GetOptions {
+            head: true,
+            ..Default::default()
+        };
+        Ok(self.get_opts(location, options).await?.meta)
+    }
 
     /// Delete the object at the specified location.
     async fn delete(&self, location: &Path) -> Result<()>;
 
+    /// Delete all the objects at the specified locations
+    ///
+    /// When supported, this method will use bulk operations that delete more
+    /// than one object per a request. The default implementation will call
+    /// the single object delete method for each location, but with up to 10
+    /// concurrent requests.
+    ///
+    /// The returned stream yields the results of the delete operations in the
+    /// same order as the input locations. However, some errors will be from
+    /// an overall call to a bulk delete operation, and not from a specific
+    /// location.
+    ///
+    /// If the object did not exist, the result may be an error or a success,
+    /// depending on the behavior of the underlying store. For example, local
+    /// filesystems, GCP, and Azure return an error, while S3 and in-memory will
+    /// return Ok. If it is an error, it will be [`Error::NotFound`].
+    ///
+    /// ```
+    /// # use futures::{StreamExt, TryStreamExt};
+    /// # use object_store::local::LocalFileSystem;
+    /// # async fn example() -> Result<(), Box<dyn std::error::Error>> {
+    /// # let root = tempfile::TempDir::new().unwrap();
+    /// # let store = LocalFileSystem::new_with_prefix(root.path()).unwrap();
+    /// # use object_store::{ObjectStore, ObjectMeta};
+    /// # use object_store::path::Path;
+    /// # use futures::{StreamExt, TryStreamExt};
+    /// # use bytes::Bytes;
+    /// #
+    /// // Create two objects
+    /// store.put(&Path::from("foo"), Bytes::from("foo")).await?;
+    /// store.put(&Path::from("bar"), Bytes::from("bar")).await?;
+    ///
+    /// // List object
+    /// let locations = store.list(None).map_ok(|m| m.location).boxed();
+    ///
+    /// // Delete them
+    /// store.delete_stream(locations).try_collect::<Vec<Path>>().await?;
+    /// # Ok(())
+    /// # }
+    /// # let rt = tokio::runtime::Builder::new_current_thread().build().unwrap();
+    /// # rt.block_on(example()).unwrap();
+    /// ```
+    fn delete_stream<'a>(
+        &'a self,
+        locations: BoxStream<'a, Result<Path>>,
+    ) -> BoxStream<'a, Result<Path>> {
+        locations
+            .map(|location| async {
+                let location = location?;
+                self.delete(&location).await?;
+                Ok(location)
+            })
+            .buffered(10)
+            .boxed()
+    }
+
     /// List all the objects with the given prefix.
     ///
     /// Prefixes are evaluated on a path segment basis, i.e. `foo/bar/` is a prefix of `foo/bar/x` but not of
     /// `foo/bar_baz/x`.
-    async fn list(
+    ///
+    /// Note: the order of returned [`ObjectMeta`] is not guaranteed
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>>;
+
+    /// List all the objects with the given prefix and a location greater than `offset`
+    ///
+    /// Some stores, such as S3 and GCS, may be able to push `offset` down to reduce
+    /// the number of network requests required
+    ///
+    /// Note: the order of returned [`ObjectMeta`] is not guaranteed
+    fn list_with_offset(
         &self,
         prefix: Option<&Path>,
-    ) -> Result<BoxStream<'_, Result<ObjectMeta>>>;
+        offset: &Path,
+    ) -> BoxStream<'_, Result<ObjectMeta>> {
+        let offset = offset.clone();
+        self.list(prefix)
+            .try_filter(move |f| futures::future::ready(f.location > offset))
+            .boxed()
+    }
 
     /// List objects with the given prefix and an implementation specific
     /// delimiter. Returns common prefixes (directories) in addition to object
@@ -290,6 +732,10 @@ pub trait ObjectStore: std::fmt::Display + Send + Sync + Debug + 'static {
     /// Copy an object from one path to another, only if destination is empty.
     ///
     /// Will return an error if the destination already has an object.
+    ///
+    /// Performs an atomic operation if the underlying object storage supports it.
+    /// If atomic operations are not supported by the underlying object storage (like S3)
+    /// it will return an error.
     async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()>;
 
     /// Move an object from one path to another in the same object store.
@@ -301,6 +747,111 @@ pub trait ObjectStore: std::fmt::Display + Send + Sync + Debug + 'static {
     }
 }
 
+macro_rules! as_ref_impl {
+    ($type:ty) => {
+        #[async_trait]
+        impl ObjectStore for $type {
+            async fn put(&self, location: &Path, bytes: Bytes) -> Result<PutResult> {
+                self.as_ref().put(location, bytes).await
+            }
+
+            async fn put_opts(
+                &self,
+                location: &Path,
+                bytes: Bytes,
+                opts: PutOptions,
+            ) -> Result<PutResult> {
+                self.as_ref().put_opts(location, bytes, opts).await
+            }
+
+            async fn put_multipart(
+                &self,
+                location: &Path,
+            ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
+                self.as_ref().put_multipart(location).await
+            }
+
+            async fn abort_multipart(
+                &self,
+                location: &Path,
+                multipart_id: &MultipartId,
+            ) -> Result<()> {
+                self.as_ref().abort_multipart(location, multipart_id).await
+            }
+
+            async fn get(&self, location: &Path) -> Result<GetResult> {
+                self.as_ref().get(location).await
+            }
+
+            async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+                self.as_ref().get_opts(location, options).await
+            }
+
+            async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes> {
+                self.as_ref().get_range(location, range).await
+            }
+
+            async fn get_ranges(
+                &self,
+                location: &Path,
+                ranges: &[Range<usize>],
+            ) -> Result<Vec<Bytes>> {
+                self.as_ref().get_ranges(location, ranges).await
+            }
+
+            async fn head(&self, location: &Path) -> Result<ObjectMeta> {
+                self.as_ref().head(location).await
+            }
+
+            async fn delete(&self, location: &Path) -> Result<()> {
+                self.as_ref().delete(location).await
+            }
+
+            fn delete_stream<'a>(
+                &'a self,
+                locations: BoxStream<'a, Result<Path>>,
+            ) -> BoxStream<'a, Result<Path>> {
+                self.as_ref().delete_stream(locations)
+            }
+
+            fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+                self.as_ref().list(prefix)
+            }
+
+            fn list_with_offset(
+                &self,
+                prefix: Option<&Path>,
+                offset: &Path,
+            ) -> BoxStream<'_, Result<ObjectMeta>> {
+                self.as_ref().list_with_offset(prefix, offset)
+            }
+
+            async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
+                self.as_ref().list_with_delimiter(prefix).await
+            }
+
+            async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
+                self.as_ref().copy(from, to).await
+            }
+
+            async fn rename(&self, from: &Path, to: &Path) -> Result<()> {
+                self.as_ref().rename(from, to).await
+            }
+
+            async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
+                self.as_ref().copy_if_not_exists(from, to).await
+            }
+
+            async fn rename_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
+                self.as_ref().rename_if_not_exists(from, to).await
+            }
+        }
+    };
+}
+
+as_ref_impl!(Arc<dyn ObjectStore>);
+as_ref_impl!(Box<dyn ObjectStore>);
+
 /// Result of a list call that includes objects, prefixes (directories) and a
 /// token for the next set of results. Individual result sets may be limited to
 /// 1,000 objects based on the underlying object storage's limitations.
@@ -321,24 +872,139 @@ pub struct ObjectMeta {
     pub last_modified: DateTime<Utc>,
     /// The size in bytes of the object
     pub size: usize,
+    /// The unique identifier for the object
+    ///
+    /// <https://datatracker.ietf.org/doc/html/rfc9110#name-etag>
+    pub e_tag: Option<String>,
+    /// A version indicator for this object
+    pub version: Option<String>,
+}
+
+/// Options for a get request, such as range
+#[derive(Debug, Default)]
+pub struct GetOptions {
+    /// Request will succeed if the `ObjectMeta::e_tag` matches
+    /// otherwise returning [`Error::Precondition`]
+    ///
+    /// See <https://datatracker.ietf.org/doc/html/rfc9110#name-if-match>
+    ///
+    /// Examples:
+    ///
+    /// ```text
+    /// If-Match: "xyzzy"
+    /// If-Match: "xyzzy", "r2d2xxxx", "c3piozzzz"
+    /// If-Match: *
+    /// ```
+    pub if_match: Option<String>,
+    /// Request will succeed if the `ObjectMeta::e_tag` does not match
+    /// otherwise returning [`Error::NotModified`]
+    ///
+    /// See <https://datatracker.ietf.org/doc/html/rfc9110#section-13.1.2>
+    ///
+    /// Examples:
+    ///
+    /// ```text
+    /// If-None-Match: "xyzzy"
+    /// If-None-Match: "xyzzy", "r2d2xxxx", "c3piozzzz"
+    /// If-None-Match: *
+    /// ```
+    pub if_none_match: Option<String>,
+    /// Request will succeed if the object has been modified since
+    ///
+    /// <https://datatracker.ietf.org/doc/html/rfc9110#section-13.1.3>
+    pub if_modified_since: Option<DateTime<Utc>>,
+    /// Request will succeed if the object has not been modified since
+    /// otherwise returning [`Error::Precondition`]
+    ///
+    /// Some stores, such as S3, will only return `NotModified` for exact
+    /// timestamp matches, instead of for any timestamp greater than or equal.
+    ///
+    /// <https://datatracker.ietf.org/doc/html/rfc9110#section-13.1.4>
+    pub if_unmodified_since: Option<DateTime<Utc>>,
+    /// Request transfer of only the specified range of bytes
+    /// otherwise returning [`Error::NotModified`]
+    ///
+    /// <https://datatracker.ietf.org/doc/html/rfc9110#name-range>
+    pub range: Option<GetRange>,
+    /// Request a particular object version
+    pub version: Option<String>,
+    /// Request transfer of no content
+    ///
+    /// <https://datatracker.ietf.org/doc/html/rfc9110#name-head>
+    pub head: bool,
+}
+
+impl GetOptions {
+    /// Returns an error if the modification conditions on this request are not satisfied
+    ///
+    /// <https://datatracker.ietf.org/doc/html/rfc7232#section-6>
+    fn check_preconditions(&self, meta: &ObjectMeta) -> Result<()> {
+        // The use of the invalid etag "*" means no ETag is equivalent to never matching
+        let etag = meta.e_tag.as_deref().unwrap_or("*");
+        let last_modified = meta.last_modified;
+
+        if let Some(m) = &self.if_match {
+            if m != "*" && m.split(',').map(str::trim).all(|x| x != etag) {
+                return Err(Error::Precondition {
+                    path: meta.location.to_string(),
+                    source: format!("{etag} does not match {m}").into(),
+                });
+            }
+        } else if let Some(date) = self.if_unmodified_since {
+            if last_modified > date {
+                return Err(Error::Precondition {
+                    path: meta.location.to_string(),
+                    source: format!("{date} < {last_modified}").into(),
+                });
+            }
+        }
+
+        if let Some(m) = &self.if_none_match {
+            if m == "*" || m.split(',').map(str::trim).any(|x| x == etag) {
+                return Err(Error::NotModified {
+                    path: meta.location.to_string(),
+                    source: format!("{etag} matches {m}").into(),
+                });
+            }
+        } else if let Some(date) = self.if_modified_since {
+            if last_modified <= date {
+                return Err(Error::NotModified {
+                    path: meta.location.to_string(),
+                    source: format!("{date} >= {last_modified}").into(),
+                });
+            }
+        }
+        Ok(())
+    }
 }
 
 /// Result for a get request
+#[derive(Debug)]
+pub struct GetResult {
+    /// The [`GetResultPayload`]
+    pub payload: GetResultPayload,
+    /// The [`ObjectMeta`] for this object
+    pub meta: ObjectMeta,
+    /// The range of bytes returned by this request
+    pub range: Range<usize>,
+}
+
+/// The kind of a [`GetResult`]
 ///
 /// This special cases the case of a local file, as some systems may
 /// be able to optimise the case of a file already present on local disk
-pub enum GetResult {
-    /// A file and its path on the local filesystem
+pub enum GetResultPayload {
+    /// The file, path
     File(std::fs::File, std::path::PathBuf),
-    /// An asynchronous stream
+    /// An opaque stream of bytes
     Stream(BoxStream<'static, Result<Bytes>>),
 }
 
-impl Debug for GetResult {
+impl Debug for GetResultPayload {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
-            Self::File(_, _) => write!(f, "GetResult(File)"),
-            Self::Stream(_) => write!(f, "GetResult(Stream)"),
+            Self::File(_, _) => write!(f, "GetResultPayload(File)"),
+            Self::Stream(_) => write!(f, "GetResultPayload(Stream)"),
         }
     }
 }
@@ -346,40 +1012,36 @@ impl Debug for GetResult {
 impl GetResult {
     /// Collects the data into a [`Bytes`]
     pub async fn bytes(self) -> Result<Bytes> {
-        match self {
-            Self::File(mut file, path) => {
+        let len = self.range.end - self.range.start;
+        match self.payload {
+            #[cfg(not(target_arch = "wasm32"))]
+            GetResultPayload::File(mut file, path) => {
                 maybe_spawn_blocking(move || {
-                    let len = file.seek(SeekFrom::End(0)).map_err(|source| {
-                        local::Error::Seek {
-                            source,
-                            path: path.clone(),
-                        }
-                    })?;
-
-                    file.seek(SeekFrom::Start(0)).map_err(|source| {
-                        local::Error::Seek {
+                    file.seek(SeekFrom::Start(self.range.start as _))
+                        .map_err(|source| local::Error::Seek {
                             source,
                             path: path.clone(),
-                        }
-                    })?;
+                        })?;
 
-                    let mut buffer = Vec::with_capacity(len as usize);
-                    file.read_to_end(&mut buffer).map_err(|source| {
-                        local::Error::UnableToReadBytes { source, path }
-                    })?;
+                    let mut buffer = Vec::with_capacity(len);
+                    file.take(len as _)
+                        .read_to_end(&mut buffer)
+                        .map_err(|source| local::Error::UnableToReadBytes { source, path })?;
 
                     Ok(buffer.into())
                 })
                 .await
             }
-            Self::Stream(s) => collect_bytes(s, None).await,
+            GetResultPayload::Stream(s) => collect_bytes(s, Some(len)).await,
+            #[cfg(target_arch = "wasm32")]
+            _ => unimplemented!("File IO not implemented on wasm32."),
         }
     }
 
     /// Converts this into a byte stream
     ///
-    /// If the result is [`Self::File`] will perform chunked reads of the file, otherwise
-    /// will return the [`Self::Stream`].
+    /// If the `self.kind` is [`GetResultPayload::File`] will perform chunked reads of the file,
+    /// otherwise will return the [`GetResultPayload::Stream`].
     ///
     /// # Tokio Compatibility
     ///
@@ -391,39 +1053,96 @@ impl GetResult {
     /// If not called from a tokio context, this will perform IO on the current thread with
     /// no additional complexity or overheads
     pub fn into_stream(self) -> BoxStream<'static, Result<Bytes>> {
-        match self {
-            Self::File(file, path) => {
+        match self.payload {
+            #[cfg(not(target_arch = "wasm32"))]
+            GetResultPayload::File(file, path) => {
                 const CHUNK_SIZE: usize = 8 * 1024;
+                local::chunked_stream(file, path, self.range, CHUNK_SIZE)
+            }
+            GetResultPayload::Stream(s) => s,
+            #[cfg(target_arch = "wasm32")]
+            _ => unimplemented!("File IO not implemented on wasm32."),
+        }
+    }
+}
 
-                futures::stream::try_unfold(
-                    (file, path, false),
-                    |(mut file, path, finished)| {
-                        maybe_spawn_blocking(move || {
-                            if finished {
-                                return Ok(None);
-                            }
+/// Configure preconditions for the put operation
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub enum PutMode {
+    /// Perform an atomic write operation, overwriting any object present at the provided path
+    #[default]
+    Overwrite,
+    /// Perform an atomic write operation, returning [`Error::AlreadyExists`] if an
+    /// object already exists at the provided path
+    Create,
+    /// Perform an atomic write operation if the current version of the object matches the
+    /// provided [`UpdateVersion`], returning [`Error::Precondition`] otherwise
+    Update(UpdateVersion),
+}
 
-                            let mut buffer = Vec::with_capacity(CHUNK_SIZE);
-                            let read = file
-                                .by_ref()
-                                .take(CHUNK_SIZE as u64)
-                                .read_to_end(&mut buffer)
-                                .map_err(|e| local::Error::UnableToReadBytes {
-                                    source: e,
-                                    path: path.clone(),
-                                })?;
-
-                            Ok(Some((buffer.into(), (file, path, read != CHUNK_SIZE))))
-                        })
-                    },
-                )
-                .boxed()
-            }
-            Self::Stream(s) => s,
+/// Uniquely identifies a version of an object to update
+///
+/// Stores will use differing combinations of `e_tag` and `version` to provide conditional
+/// updates, and it is therefore recommended applications preserve both
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct UpdateVersion {
+    /// The unique identifier for the newly created object
+    ///
+    /// <https://datatracker.ietf.org/doc/html/rfc9110#name-etag>
+    pub e_tag: Option<String>,
+    /// A version indicator for the newly created object
+    pub version: Option<String>,
+}
+
+impl From<PutResult> for UpdateVersion {
+    fn from(value: PutResult) -> Self {
+        Self {
+            e_tag: value.e_tag,
+            version: value.version,
         }
     }
 }
 
+/// Options for a put request
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct PutOptions {
+    /// Configure the [`PutMode`] for this operation
+    pub mode: PutMode,
+    /// Provide a [`TagSet`] for this object
+    ///
+    /// Implementations that don't support object tagging should ignore this
+    pub tags: TagSet,
+}
+
+impl From<PutMode> for PutOptions {
+    fn from(mode: PutMode) -> Self {
+        Self {
+            mode,
+            ..Default::default()
+        }
+    }
+}
+
+impl From<TagSet> for PutOptions {
+    fn from(tags: TagSet) -> Self {
+        Self {
+            tags,
+            ..Default::default()
+        }
+    }
+}
+
+/// Result for a put request
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PutResult {
+    /// The unique identifier for the newly created object
+    ///
+    /// <https://datatracker.ietf.org/doc/html/rfc9110#name-etag>
+    pub e_tag: Option<String>,
+    /// A version indicator for the newly created object
+    pub version: Option<String>,
+}
+
 /// A specialized `Result` for object store-related errors
 pub type Result<T, E = Error> = std::result::Result<T, E>;
 
@@ -463,12 +1182,33 @@ pub enum Error {
         source: Box<dyn std::error::Error + Send + Sync + 'static>,
     },
 
+    #[snafu(display("Request precondition failure for path {}: {}", path, source))]
+    Precondition {
+        path: String,
+        source: Box<dyn std::error::Error + Send + Sync + 'static>,
+    },
+
+    #[snafu(display("Object at location {} not modified: {}", path, source))]
+    NotModified {
+        path: String,
+        source: Box<dyn std::error::Error + Send + Sync + 'static>,
+    },
+
     #[snafu(display("Operation not yet implemented."))]
     NotImplemented,
 
-    #[cfg(feature = "gcp")]
-    #[snafu(display("OAuth error: {}", source), context(false))]
-    OAuth { source: client::oauth::Error },
+    #[snafu(display("Configuration key: '{}' is not valid for store '{}'.", key, store))]
+    UnknownConfigurationKey { store: &'static str, key: String },
+}
+
+impl From<Error> for std::io::Error {
+    fn from(e: Error) -> Self {
+        let kind = match &e {
+            Error::NotFound { .. } => std::io::ErrorKind::NotFound,
+            _ => std::io::ErrorKind::Other,
+        };
+        Self::new(kind, e)
+    }
 }
 
 #[cfg(test)]
@@ -476,13 +1216,22 @@ mod test_util {
     use super::*;
     use futures::TryStreamExt;
 
+    macro_rules! maybe_skip_integration {
+        () => {
+            if std::env::var("TEST_INTEGRATION").is_err() {
+                eprintln!("Skipping integration test - set TEST_INTEGRATION");
+                return;
+            }
+        };
+    }
+    pub(crate) use maybe_skip_integration;
+
     pub async fn flatten_list_stream(
         storage: &DynObjectStore,
         prefix: Option<&Path>,
     ) -> Result<Vec<Path>> {
         storage
             .list(prefix)
-            .await?
             .map_ok(|meta| meta.location)
             .try_collect::<Vec<Path>>()
             .await
@@ -492,19 +1241,26 @@ mod test_util {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::multipart::MultiPartStore;
     use crate::test_util::flatten_list_stream;
+    use chrono::TimeZone;
+    use futures::stream::FuturesUnordered;
+    use rand::distributions::Alphanumeric;
+    use rand::{thread_rng, Rng};
+    use std::future::Future;
     use tokio::io::AsyncWriteExt;
 
     pub(crate) async fn put_get_delete_list(storage: &DynObjectStore) {
-        let store_str = storage.to_string();
+        put_get_delete_list_opts(storage).await
+    }
 
+    pub(crate) async fn put_get_delete_list_opts(storage: &DynObjectStore) {
         delete_fixtures(storage).await;
 
         let content_list = flatten_list_stream(storage, None).await.unwrap();
         assert!(
             content_list.is_empty(),
-            "Expected list to be empty; found: {:?}",
-            content_list
+            "Expected list to be empty; found: {content_list:?}"
         );
 
         let location = Path::from("test_dir/test_file.json");
@@ -535,6 +1291,14 @@ mod tests {
         assert_eq!(result.common_prefixes.len(), 1);
         assert_eq!(result.common_prefixes[0], Path::from("test_dir"));
 
+        // Should return not found
+        let err = storage.get(&Path::from("test_dir")).await.unwrap_err();
+        assert!(matches!(err, crate::Error::NotFound { .. }), "{}", err);
+
+        // Should return not found
+        let err = storage.head(&Path::from("test_dir")).await.unwrap_err();
+        assert!(matches!(err, crate::Error::NotFound { .. }), "{}", err);
+
         // List everything starting with a prefix that should return results
         let prefix = Path::from("test_dir");
         let content_list = flatten_list_stream(storage, Some(&prefix)).await.unwrap();
@@ -552,29 +1316,86 @@ mod tests {
         let range = 3..7;
         let range_result = storage.get_range(&location, range.clone()).await;
 
+        let bytes = range_result.unwrap();
+        assert_eq!(bytes, expected_data.slice(range.clone()));
+
+        let opts = GetOptions {
+            range: Some(GetRange::Bounded(2..5)),
+            ..Default::default()
+        };
+        let result = storage.get_opts(&location, opts).await.unwrap();
+        // Data is `"arbitrary data"`, length 14 bytes
+        assert_eq!(result.meta.size, 14); // Should return full object size (#5272)
+        assert_eq!(result.range, 2..5);
+        let bytes = result.bytes().await.unwrap();
+        assert_eq!(bytes, b"bit".as_ref());
+
         let out_of_range = 200..300;
         let out_of_range_result = storage.get_range(&location, out_of_range).await;
 
-        if store_str.starts_with("MicrosoftAzureEmulator") {
-            // Azurite doesn't support x-ms-range-get-content-crc64 set by Azure SDK
-            // https://github.com/Azure/Azurite/issues/444
-            let err = range_result.unwrap_err().to_string();
-            assert!(err.contains("x-ms-range-get-content-crc64 header or parameter is not supported in Azurite strict mode"), "{}", err);
-
-            let err = out_of_range_result.unwrap_err().to_string();
-            assert!(err.contains("x-ms-range-get-content-crc64 header or parameter is not supported in Azurite strict mode"), "{}", err);
-        } else {
-            let bytes = range_result.unwrap();
-            assert_eq!(bytes, expected_data.slice(range));
-
-            // Should be a non-fatal error
-            out_of_range_result.unwrap_err();
-
-            let ranges = vec![0..1, 2..3, 0..5];
-            let bytes = storage.get_ranges(&location, &ranges).await.unwrap();
-            for (range, bytes) in ranges.iter().zip(bytes) {
-                assert_eq!(bytes, expected_data.slice(range.clone()))
+        // Should be a non-fatal error
+        out_of_range_result.unwrap_err();
+
+        let opts = GetOptions {
+            range: Some(GetRange::Bounded(2..100)),
+            ..Default::default()
+        };
+        let result = storage.get_opts(&location, opts).await.unwrap();
+        assert_eq!(result.range, 2..14);
+        assert_eq!(result.meta.size, 14);
+        let bytes = result.bytes().await.unwrap();
+        assert_eq!(bytes, b"bitrary data".as_ref());
+
+        let opts = GetOptions {
+            range: Some(GetRange::Suffix(2)),
+            ..Default::default()
+        };
+        match storage.get_opts(&location, opts).await {
+            Ok(result) => {
+                assert_eq!(result.range, 12..14);
+                assert_eq!(result.meta.size, 14);
+                let bytes = result.bytes().await.unwrap();
+                assert_eq!(bytes, b"ta".as_ref());
+            }
+            Err(Error::NotSupported { .. }) => {}
+            Err(e) => panic!("{e}"),
+        }
+
+        let opts = GetOptions {
+            range: Some(GetRange::Suffix(100)),
+            ..Default::default()
+        };
+        match storage.get_opts(&location, opts).await {
+            Ok(result) => {
+                assert_eq!(result.range, 0..14);
+                assert_eq!(result.meta.size, 14);
+                let bytes = result.bytes().await.unwrap();
+                assert_eq!(bytes, b"arbitrary data".as_ref());
             }
+            Err(Error::NotSupported { .. }) => {}
+            Err(e) => panic!("{e}"),
+        }
+
+        let opts = GetOptions {
+            range: Some(GetRange::Offset(3)),
+            ..Default::default()
+        };
+        let result = storage.get_opts(&location, opts).await.unwrap();
+        assert_eq!(result.range, 3..14);
+        assert_eq!(result.meta.size, 14);
+        let bytes = result.bytes().await.unwrap();
+        assert_eq!(bytes, b"itrary data".as_ref());
+
+        let opts = GetOptions {
+            range: Some(GetRange::Offset(100)),
+            ..Default::default()
+        };
+        storage.get_opts(&location, opts).await.unwrap_err();
+
+        let ranges = vec![0..1, 2..3, 0..5];
+        let bytes = storage.get_ranges(&location, &ranges).await.unwrap();
+        for (range, bytes) in ranges.iter().zip(bytes) {
+            assert_eq!(bytes, expected_data.slice(range.clone()))
         }
 
         let head = storage.head(&location).await.unwrap();
@@ -661,8 +1482,24 @@ mod tests {
         files.sort_unstable();
         assert_eq!(files, vec![emoji_file.clone(), dst.clone()]);
 
+        let dst2 = Path::from("new/nested/foo.parquet");
+        storage.copy(&emoji_file, &dst2).await.unwrap();
+        let mut files = flatten_list_stream(storage, None).await.unwrap();
+        files.sort_unstable();
+        assert_eq!(files, vec![emoji_file.clone(), dst.clone(), dst2.clone()]);
+
+        let dst3 = Path::from("new/nested2/bar.parquet");
+        storage.rename(&dst, &dst3).await.unwrap();
+        let mut files = flatten_list_stream(storage, None).await.unwrap();
+        files.sort_unstable();
+        assert_eq!(files, vec![emoji_file.clone(), dst2.clone(), dst3.clone()]);
+
+        let err = storage.head(&dst).await.unwrap_err();
+        assert!(matches!(err, Error::NotFound { .. }));
+
         storage.delete(&emoji_file).await.unwrap();
-        storage.delete(&dst).await.unwrap();
+        storage.delete(&dst3).await.unwrap();
+        storage.delete(&dst2).await.unwrap();
         let files = flatten_list_stream(storage, Some(&emoji_prefix))
             .await
             .unwrap();
@@ -695,6 +1532,23 @@ mod tests {
 
         storage.delete(&path).await.unwrap();
 
+        // Test handling of unicode paths
+        let path = Path::parse("🇦🇺/$shenanigans@@~.txt").unwrap();
+        storage.put(&path, "test".into()).await.unwrap();
+
+        let r = storage.get(&path).await.unwrap();
+        assert_eq!(r.bytes().await.unwrap(), "test");
+
+        let dir = Path::parse("🇦🇺").unwrap();
+        let r = storage.list_with_delimiter(None).await.unwrap();
+        assert!(r.common_prefixes.contains(&dir));
+
+        let r = storage.list_with_delimiter(Some(&dir)).await.unwrap();
+        assert_eq!(r.objects.len(), 1);
+        assert_eq!(r.objects[0].location, path);
+
+        storage.delete(&path).await.unwrap();
+
         // Can also write non-percent encoded sequences
         let path = Path::parse("%Q.parquet").unwrap();
         storage.put(&path, Bytes::from(vec![0, 1])).await.unwrap();
@@ -703,19 +1557,369 @@ mod tests {
         assert_eq!(files, vec![path.clone()]);
 
         storage.delete(&path).await.unwrap();
+
+        let path = Path::parse("foo bar/I contain spaces.parquet").unwrap();
+        storage.put(&path, Bytes::from(vec![0, 1])).await.unwrap();
+        storage.head(&path).await.unwrap();
+
+        let files = flatten_list_stream(storage, Some(&Path::from("foo bar")))
+            .await
+            .unwrap();
+        assert_eq!(files, vec![path.clone()]);
+
+        storage.delete(&path).await.unwrap();
+
+        let files = flatten_list_stream(storage, None).await.unwrap();
+        assert!(files.is_empty(), "{files:?}");
+
+        // Test list order
+        let files = vec![
+            Path::from("a a/b.file"),
+            Path::parse("a%2Fa.file").unwrap(),
+            Path::from("a/😀.file"),
+            Path::from("a/a file"),
+            Path::parse("a/a%2F.file").unwrap(),
+            Path::from("a/a.file"),
+            Path::from("a/a/b.file"),
+            Path::from("a/b.file"),
+            Path::from("aa/a.file"),
+            Path::from("ab/a.file"),
+        ];
+
+        for file in &files {
+            storage.put(file, "foo".into()).await.unwrap();
+        }
+
+        let cases = [
+            (None, Path::from("a")),
+            (None, Path::from("a/a file")),
+            (None, Path::from("a/a/b.file")),
+            (None, Path::from("ab/a.file")),
+            (None, Path::from("a%2Fa.file")),
+            (None, Path::from("a/😀.file")),
+            (Some(Path::from("a")), Path::from("")),
+            (Some(Path::from("a")), Path::from("a")),
+            (Some(Path::from("a")), Path::from("a/😀")),
+            (Some(Path::from("a")), Path::from("a/😀.file")),
+            (Some(Path::from("a")), Path::from("a/b")),
+            (Some(Path::from("a")), Path::from("a/a/b.file")),
+        ];
+
+        for (prefix, offset) in cases {
+            let s = storage.list_with_offset(prefix.as_ref(), &offset);
+            let mut actual: Vec<_> = s.map_ok(|x| x.location).try_collect().await.unwrap();
+
+            actual.sort_unstable();
+
+            let expected: Vec<_> = files
+                .iter()
+                .filter(|x| {
+                    let prefix_match = prefix.as_ref().map(|p| x.prefix_matches(p)).unwrap_or(true);
+                    prefix_match && *x > &offset
+                })
+                .cloned()
+                .collect();
+
+            assert_eq!(actual, expected, "{prefix:?} - {offset:?}");
+        }
+
+        // Test bulk delete
+        let paths = vec![
+            Path::from("a/a.file"),
+            Path::from("a/a/b.file"),
+            Path::from("aa/a.file"),
+            Path::from("does_not_exist"),
+            Path::from("I'm a < & weird path"),
+            Path::from("ab/a.file"),
+            Path::from("a/😀.file"),
+        ];
+
+        storage.put(&paths[4], "foo".into()).await.unwrap();
+
+        let out_paths = storage
+            .delete_stream(futures::stream::iter(paths.clone()).map(Ok).boxed())
+            .collect::<Vec<_>>()
+            .await;
+
+        assert_eq!(out_paths.len(), paths.len());
+
+        let expect_errors = [3];
+
+        for (i, input_path) in paths.iter().enumerate() {
+            let err = storage.head(input_path).await.unwrap_err();
+            assert!(matches!(err, crate::Error::NotFound { .. }), "{}", err);
+
+            if expect_errors.contains(&i) {
+                // Some object stores will report NotFound, but others (such as S3) will
+                // report success regardless.
+                match &out_paths[i] {
+                    Err(Error::NotFound { path: out_path, .. }) => {
+                        assert!(out_path.ends_with(&input_path.to_string()));
+                    }
+                    Ok(out_path) => {
+                        assert_eq!(out_path, input_path);
+                    }
+                    _ => panic!("unexpected error"),
+                }
+            } else {
+                assert_eq!(out_paths[i].as_ref().unwrap(), input_path);
+            }
+        }
+
+        delete_fixtures(storage).await;
+
+        let path = Path::from("empty");
+        storage.put(&path, Bytes::new()).await.unwrap();
+        let meta = storage.head(&path).await.unwrap();
+        assert_eq!(meta.size, 0);
+        let data = storage.get(&path).await.unwrap().bytes().await.unwrap();
+        assert_eq!(data.len(), 0);
+
+        storage.delete(&path).await.unwrap();
+    }
+
+    pub(crate) async fn get_opts(storage: &dyn ObjectStore) {
+        let path = Path::from("test");
+        storage.put(&path, "foo".into()).await.unwrap();
+        let meta = storage.head(&path).await.unwrap();
+
+        let options = GetOptions {
+            if_unmodified_since: Some(meta.last_modified),
+            ..GetOptions::default()
+        };
+        match storage.get_opts(&path, options).await {
+            Ok(_) | Err(Error::NotSupported { .. }) => {}
+            Err(e) => panic!("{e}"),
+        }
+
+        let options = GetOptions {
+            if_unmodified_since: Some(meta.last_modified + chrono::Duration::hours(10)),
+            ..GetOptions::default()
+        };
+        match storage.get_opts(&path, options).await {
+            Ok(_) | Err(Error::NotSupported { .. }) => {}
+            Err(e) => panic!("{e}"),
+        }
+
+        let options = GetOptions {
+            if_unmodified_since: Some(meta.last_modified - chrono::Duration::hours(10)),
+            ..GetOptions::default()
+        };
+        match storage.get_opts(&path, options).await {
+            Err(Error::Precondition { .. } | Error::NotSupported { .. }) => {}
+            d => panic!("{d:?}"),
+        }
+
+        let options = GetOptions {
+            if_modified_since: Some(meta.last_modified),
+            ..GetOptions::default()
+        };
+        match storage.get_opts(&path, options).await {
+            Err(Error::NotModified { .. } | Error::NotSupported { .. }) => {}
+            d => panic!("{d:?}"),
+        }
+
+        let options = GetOptions {
+            if_modified_since: Some(meta.last_modified - chrono::Duration::hours(10)),
+            ..GetOptions::default()
+        };
+        match storage.get_opts(&path, options).await {
+            Ok(_) | Err(Error::NotSupported { .. }) => {}
+            Err(e) => panic!("{e}"),
+        }
+
+        let tag = meta.e_tag.unwrap();
+        let options = GetOptions {
+            if_match: Some(tag.clone()),
+            ..GetOptions::default()
+        };
+        storage.get_opts(&path, options).await.unwrap();
+
+        let options = GetOptions {
+            if_match: Some("invalid".to_string()),
+            ..GetOptions::default()
+        };
+        let err = storage.get_opts(&path, options).await.unwrap_err();
+        assert!(matches!(err, Error::Precondition { .. }), "{err}");
+
+        let options = GetOptions {
+            if_none_match: Some(tag.clone()),
+            ..GetOptions::default()
+        };
+        let err = storage.get_opts(&path, options).await.unwrap_err();
+        assert!(matches!(err, Error::NotModified { .. }), "{err}");
+
+        let options = GetOptions {
+            if_none_match: Some("invalid".to_string()),
+            ..GetOptions::default()
+        };
+        storage.get_opts(&path, options).await.unwrap();
+
+        let result = storage.put(&path, "test".into()).await.unwrap();
+        let new_tag = result.e_tag.unwrap();
+        assert_ne!(tag, new_tag);
+
+        let meta = storage.head(&path).await.unwrap();
+        assert_eq!(meta.e_tag.unwrap(), new_tag);
+
+        let options = GetOptions {
+            if_match: Some(new_tag),
+            ..GetOptions::default()
+        };
+        storage.get_opts(&path, options).await.unwrap();
+
+        let options = GetOptions {
+            if_match: Some(tag),
+            ..GetOptions::default()
+        };
+        let err = storage.get_opts(&path, options).await.unwrap_err();
+        assert!(matches!(err, Error::Precondition { .. }), "{err}");
+
+        if let Some(version) = meta.version {
+            storage.put(&path, "bar".into()).await.unwrap();
+
+            let options = GetOptions {
+                version: Some(version),
+                ..GetOptions::default()
+            };
+
+            // Can retrieve previous version
+            let get_opts = storage.get_opts(&path, options).await.unwrap();
+            let old = get_opts.bytes().await.unwrap();
+            assert_eq!(old, b"test".as_slice());
+
+            // Current version contains the updated data
+            let current = storage.get(&path).await.unwrap().bytes().await.unwrap();
+            assert_eq!(&current, b"bar".as_slice());
+        }
+    }
+
+    pub(crate) async fn put_opts(storage: &dyn ObjectStore, supports_update: bool) {
+        // When using DynamoCommit repeated runs of this test will produce the same sequence of records in DynamoDB
+        // As a result each conditional operation will need to wait for the lease to timeout before proceeding
+        // One solution would be to clear DynamoDB before each test, but this would require non-trivial additional code
+        // so we instead just generate a random suffix for the filenames
+        let rng = thread_rng();
+        let suffix = String::from_utf8(rng.sample_iter(Alphanumeric).take(32).collect()).unwrap();
+
+        delete_fixtures(storage).await;
+        let path = Path::from(format!("put_opts_{suffix}"));
+        let v1 = storage
+            .put_opts(&path, "a".into(), PutMode::Create.into())
+            .await
+            .unwrap();
+
+        let err = storage
+            .put_opts(&path, "b".into(), PutMode::Create.into())
+            .await
+            .unwrap_err();
+        assert!(matches!(err, Error::AlreadyExists { .. }), "{err}");
+
+        let b = storage.get(&path).await.unwrap().bytes().await.unwrap();
+        assert_eq!(b.as_ref(), b"a");
+
+        if !supports_update {
+            return;
+        }
+
+        let v2 = storage
+            .put_opts(&path, "c".into(), PutMode::Update(v1.clone().into()).into())
+            .await
+            .unwrap();
+
+        let b = storage.get(&path).await.unwrap().bytes().await.unwrap();
+        assert_eq!(b.as_ref(), b"c");
+
+        let err = storage
+            .put_opts(&path, "d".into(), PutMode::Update(v1.into()).into())
+            .await
+            .unwrap_err();
+        assert!(matches!(err, Error::Precondition { .. }), "{err}");
+
+        storage
+            .put_opts(&path, "e".into(), PutMode::Update(v2.clone().into()).into())
+            .await
+            .unwrap();
+
+        let b = storage.get(&path).await.unwrap().bytes().await.unwrap();
+        assert_eq!(b.as_ref(), b"e");
+
+        // Update not exists
+        let path = Path::from("I don't exist");
+        let err = storage
+            .put_opts(&path, "e".into(), PutMode::Update(v2.into()).into())
+            .await
+            .unwrap_err();
+        assert!(matches!(err, Error::Precondition { .. }), "{err}");
+
+        const NUM_WORKERS: usize = 5;
+        const NUM_INCREMENTS: usize = 10;
+
+        let path = Path::from(format!("RACE-{suffix}"));
+        let mut futures: FuturesUnordered<_> = (0..NUM_WORKERS)
+            .map(|_| async {
+                for _ in 0..NUM_INCREMENTS {
+                    loop {
+                        match storage.get(&path).await {
+                            Ok(r) => {
+                                let mode = PutMode::Update(UpdateVersion {
+                                    e_tag: r.meta.e_tag.clone(),
+                                    version: r.meta.version.clone(),
+                                });
+
+                                let b = r.bytes().await.unwrap();
+                                let v: usize = std::str::from_utf8(&b).unwrap().parse().unwrap();
+                                let new = (v + 1).to_string();
+
+                                match storage.put_opts(&path, new.into(), mode.into()).await {
+                                    Ok(_) => break,
+                                    Err(Error::Precondition { .. }) => continue,
+                                    Err(e) => return Err(e),
+                                }
+                            }
+                            Err(Error::NotFound { .. }) => {
+                                let mode = PutMode::Create;
+                                match storage.put_opts(&path, "1".into(), mode.into()).await {
+                                    Ok(_) => break,
+                                    Err(Error::AlreadyExists { .. }) => continue,
+                                    Err(e) => return Err(e),
+                                }
+                            }
+                            Err(e) => return Err(e),
+                        }
+                    }
+                }
+                Ok(())
+            })
+            .collect();
+
+        while futures.next().await.transpose().unwrap().is_some() {}
+        let b = storage.get(&path).await.unwrap().bytes().await.unwrap();
+        let v = std::str::from_utf8(&b).unwrap().parse::<usize>().unwrap();
+        assert_eq!(v, NUM_WORKERS * NUM_INCREMENTS);
     }
 
-    fn get_vec_of_bytes(chunk_length: usize, num_chunks: usize) -> Vec<Bytes> {
-        std::iter::repeat(Bytes::from_iter(std::iter::repeat(b'x').take(chunk_length)))
-            .take(num_chunks)
-            .collect()
+    /// Returns a chunk of length `chunk_length`
+    fn get_chunk(chunk_length: usize) -> Bytes {
+        let mut data = vec![0_u8; chunk_length];
+        let mut rng = thread_rng();
+        // Set a random selection of bytes
+        for _ in 0..1000 {
+            data[rng.gen_range(0..chunk_length)] = rng.gen();
+        }
+        data.into()
+    }
+
+    /// Returns `num_chunks` of length `chunks`
+    fn get_chunks(chunk_length: usize, num_chunks: usize) -> Vec<Bytes> {
+        (0..num_chunks).map(|_| get_chunk(chunk_length)).collect()
     }
 
     pub(crate) async fn stream_get(storage: &DynObjectStore) {
         let location = Path::from("test_dir/test_upload_file.txt");
 
         // Can write to storage
-        let data = get_vec_of_bytes(5_000_000, 10);
+        let data = get_chunks(5_000, 10);
         let bytes_expected = data.concat();
         let (_, mut writer) = storage.put_multipart(&location).await.unwrap();
         for chunk in &data {
@@ -730,12 +1934,19 @@ mod tests {
             crate::Error::NotFound { .. }
         ));
 
+        let files = flatten_list_stream(storage, None).await.unwrap();
+        assert_eq!(&files, &[]);
+
+        let result = storage.list_with_delimiter(None).await.unwrap();
+        assert_eq!(&result.objects, &[]);
+
         writer.shutdown().await.unwrap();
         let bytes_written = storage.get(&location).await.unwrap().bytes().await.unwrap();
         assert_eq!(bytes_expected, bytes_written);
 
         // Can overwrite some storage
-        let data = get_vec_of_bytes(5_000, 5);
+        // Sizes chosen to ensure we write three parts
+        let data = get_chunks(3_200_000, 7);
         let bytes_expected = data.concat();
         let (_, mut writer) = storage.put_multipart(&location).await.unwrap();
         for chunk in &data {
@@ -762,7 +1973,7 @@ mod tests {
 
         // We can abort an in-progress write
         let (upload_id, mut writer) = storage.put_multipart(&location).await.unwrap();
-        if let Some(chunk) = data.get(0) {
+        if let Some(chunk) = data.first() {
             writer.write_all(chunk).await.unwrap();
             let _ = writer.write(chunk).await.unwrap();
         }
@@ -786,8 +1997,7 @@ mod tests {
         let content_list = flatten_list_stream(storage, None).await.unwrap();
         assert!(
             content_list.is_empty(),
-            "Expected list to be empty; found: {:?}",
-            content_list
+            "Expected list to be empty; found: {content_list:?}"
         );
 
         let location1 = Path::from("foo/x.json");
@@ -801,9 +2011,29 @@ mod tests {
         let content_list = flatten_list_stream(storage, Some(&prefix)).await.unwrap();
         assert_eq!(content_list, &[location1.clone()]);
 
+        let result = storage.list_with_delimiter(Some(&prefix)).await.unwrap();
+        assert_eq!(result.objects.len(), 1);
+        assert_eq!(result.objects[0].location, location1);
+        assert_eq!(result.common_prefixes, &[]);
+
+        // Listing an existing path (file) should return an empty list:
+        // https://github.com/apache/arrow-rs/issues/3712
+        let content_list = flatten_list_stream(storage, Some(&location1))
+            .await
+            .unwrap();
+        assert_eq!(content_list, &[]);
+
+        let list = storage.list_with_delimiter(Some(&location1)).await.unwrap();
+        assert_eq!(list.objects, &[]);
+        assert_eq!(list.common_prefixes, &[]);
+
         let prefix = Path::from("foo/x");
         let content_list = flatten_list_stream(storage, Some(&prefix)).await.unwrap();
         assert_eq!(content_list, &[]);
+
+        let list = storage.list_with_delimiter(Some(&prefix)).await.unwrap();
+        assert_eq!(list.objects, &[]);
+        assert_eq!(list.common_prefixes, &[]);
     }
 
     pub(crate) async fn list_with_delimiter(storage: &DynObjectStore) {
@@ -880,8 +2110,7 @@ mod tests {
         storage: &DynObjectStore,
         location: Option<Path>,
     ) -> crate::Result<Bytes> {
-        let location =
-            location.unwrap_or_else(|| Path::from("this_file_should_not_exist"));
+        let location = location.unwrap_or_else(|| Path::from("this_file_should_not_exist"));
 
         let err = storage.head(&location).await.unwrap_err();
         assert!(matches!(err, crate::Error::NotFound { .. }));
@@ -920,7 +2149,7 @@ mod tests {
     pub(crate) async fn copy_if_not_exists(storage: &DynObjectStore) {
         // Create two objects
         let path1 = Path::from("test1");
-        let path2 = Path::from("test2");
+        let path2 = Path::from("not_exists_nested/test2");
         let contents1 = Bytes::from("cats");
         let contents2 = Bytes::from("dogs");
 
@@ -948,32 +2177,237 @@ mod tests {
         storage.delete(&path2).await.unwrap();
     }
 
-    async fn delete_fixtures(storage: &DynObjectStore) {
-        let paths = flatten_list_stream(storage, None).await.unwrap();
+    pub(crate) async fn multipart(storage: &dyn ObjectStore, multipart: &dyn MultiPartStore) {
+        let path = Path::from("test_multipart");
+        let chunk_size = 5 * 1024 * 1024;
+
+        let chunks = get_chunks(chunk_size, 2);
+
+        let id = multipart.create_multipart(&path).await.unwrap();
+
+        let parts: Vec<_> = futures::stream::iter(chunks)
+            .enumerate()
+            .map(|(idx, b)| multipart.put_part(&path, &id, idx, b))
+            .buffered(2)
+            .try_collect()
+            .await
+            .unwrap();
+
+        multipart
+            .complete_multipart(&path, &id, parts)
+            .await
+            .unwrap();
+
+        let meta = storage.head(&path).await.unwrap();
+        assert_eq!(meta.size, chunk_size * 2);
+
+        // Empty case
+        let path = Path::from("test_empty_multipart");
+
+        let id = multipart.create_multipart(&path).await.unwrap();
+
+        let parts = vec![];
+
+        multipart
+            .complete_multipart(&path, &id, parts)
+            .await
+            .unwrap();
+
+        let meta = storage.head(&path).await.unwrap();
+        assert_eq!(meta.size, 0);
+    }
 
-        for f in &paths {
-            let _ = storage.delete(f).await;
+    #[cfg(any(feature = "azure", feature = "aws"))]
+    pub(crate) async fn signing<T>(integration: &T)
+    where
+        T: ObjectStore + crate::signer::Signer,
+    {
+        use reqwest::Method;
+        use std::time::Duration;
+
+        let data = Bytes::from("hello world");
+        let path = Path::from("file.txt");
+        integration.put(&path, data.clone()).await.unwrap();
+
+        let signed = integration
+            .signed_url(Method::GET, &path, Duration::from_secs(60))
+            .await
+            .unwrap();
+
+        let resp = reqwest::get(signed).await.unwrap();
+        let loaded = resp.bytes().await.unwrap();
+
+        assert_eq!(data, loaded);
+    }
+
+    #[cfg(any(feature = "aws", feature = "azure"))]
+    pub(crate) async fn tagging<F, Fut>(storage: &dyn ObjectStore, validate: bool, get_tags: F)
+    where
+        F: Fn(Path) -> Fut + Send + Sync,
+        Fut: Future<Output = Result<reqwest::Response>> + Send,
+    {
+        use bytes::Buf;
+        use serde::Deserialize;
+
+        #[derive(Deserialize)]
+        struct Tagging {
+            #[serde(rename = "TagSet")]
+            list: TagList,
+        }
+
+        #[derive(Debug, Deserialize)]
+        struct TagList {
+            #[serde(rename = "Tag")]
+            tags: Vec<Tag>,
+        }
+
+        #[derive(Debug, Deserialize, Eq, PartialEq)]
+        #[serde(rename_all = "PascalCase")]
+        struct Tag {
+            key: String,
+            value: String,
+        }
+
+        let tags = vec![
+            Tag {
+                key: "foo.com=bar/s".to_string(),
+                value: "bananas/foo.com-_".to_string(),
+            },
+            Tag {
+                key: "namespace/key.foo".to_string(),
+                value: "value with a space".to_string(),
+            },
+        ];
+        let mut tag_set = TagSet::default();
+        for t in &tags {
+            tag_set.push(&t.key, &t.value)
         }
+
+        let path = Path::from("tag_test");
+        storage
+            .put_opts(&path, "test".into(), tag_set.into())
+            .await
+            .unwrap();
+
+        // Write should always succeed, but certain configurations may simply ignore tags
+        if !validate {
+            return;
+        }
+
+        let resp = get_tags(path.clone()).await.unwrap();
+        let body = resp.bytes().await.unwrap();
+
+        let mut resp: Tagging = quick_xml::de::from_reader(body.reader()).unwrap();
+        resp.list.tags.sort_by(|a, b| a.key.cmp(&b.key));
+        assert_eq!(resp.list.tags, tags);
+    }
+
+    async fn delete_fixtures(storage: &DynObjectStore) {
+        let paths = storage.list(None).map_ok(|meta| meta.location).boxed();
+        storage
+            .delete_stream(paths)
+            .try_collect::<Vec<_>>()
+            .await
+            .unwrap();
     }
 
     /// Test that the returned stream does not borrow the lifetime of Path
-    async fn list_store<'a, 'b>(
+    fn list_store<'a>(
         store: &'a dyn ObjectStore,
-        path_str: &'b str,
-    ) -> super::Result<BoxStream<'a, super::Result<ObjectMeta>>> {
+        path_str: &str,
+    ) -> BoxStream<'a, Result<ObjectMeta>> {
         let path = Path::from(path_str);
-        store.list(Some(&path)).await
+        store.list(Some(&path))
     }
 
     #[tokio::test]
     async fn test_list_lifetimes() {
         let store = memory::InMemory::new();
-        let mut stream = list_store(&store, "path").await.unwrap();
+        let mut stream = list_store(&store, "path");
         assert!(stream.next().await.is_none());
     }
 
-    // Tests TODO:
-    // GET nonexisting location (in_memory/file)
-    // DELETE nonexisting location
-    // PUT overwriting
+    #[test]
+    fn test_preconditions() {
+        let mut meta = ObjectMeta {
+            location: Path::from("test"),
+            last_modified: Utc.timestamp_nanos(100),
+            size: 100,
+            e_tag: Some("123".to_string()),
+            version: None,
+        };
+
+        let mut options = GetOptions::default();
+        options.check_preconditions(&meta).unwrap();
+
+        options.if_modified_since = Some(Utc.timestamp_nanos(50));
+        options.check_preconditions(&meta).unwrap();
+
+        options.if_modified_since = Some(Utc.timestamp_nanos(100));
+        options.check_preconditions(&meta).unwrap_err();
+
+        options.if_modified_since = Some(Utc.timestamp_nanos(101));
+        options.check_preconditions(&meta).unwrap_err();
+
+        options = GetOptions::default();
+
+        options.if_unmodified_since = Some(Utc.timestamp_nanos(50));
+        options.check_preconditions(&meta).unwrap_err();
+
+        options.if_unmodified_since = Some(Utc.timestamp_nanos(100));
+        options.check_preconditions(&meta).unwrap();
+
+        options.if_unmodified_since = Some(Utc.timestamp_nanos(101));
+        options.check_preconditions(&meta).unwrap();
+
+        options = GetOptions::default();
+
+        options.if_match = Some("123".to_string());
+        options.check_preconditions(&meta).unwrap();
+
+        options.if_match = Some("123,354".to_string());
+        options.check_preconditions(&meta).unwrap();
+
+        options.if_match = Some("354, 123,".to_string());
+        options.check_preconditions(&meta).unwrap();
+
+        options.if_match = Some("354".to_string());
+        options.check_preconditions(&meta).unwrap_err();
+
+        options.if_match = Some("*".to_string());
+        options.check_preconditions(&meta).unwrap();
+
+        // If-Match takes precedence
+        options.if_unmodified_since = Some(Utc.timestamp_nanos(200));
+        options.check_preconditions(&meta).unwrap();
+
+        options = GetOptions::default();
+
+        options.if_none_match = Some("123".to_string());
+        options.check_preconditions(&meta).unwrap_err();
+
+        options.if_none_match = Some("*".to_string());
+        options.check_preconditions(&meta).unwrap_err();
+
+        options.if_none_match = Some("1232".to_string());
+        options.check_preconditions(&meta).unwrap();
+
+        options.if_none_match = Some("23, 123".to_string());
+        options.check_preconditions(&meta).unwrap_err();
+
+        // If-None-Match takes precedence
+        options.if_modified_since = Some(Utc.timestamp_nanos(10));
+        options.check_preconditions(&meta).unwrap_err();
+
+        // Check missing ETag
+        meta.e_tag = None;
+        options = GetOptions::default();
+
+        options.if_none_match = Some("*".to_string()); // Fails if any file exists
+        options.check_preconditions(&meta).unwrap_err();
+
+        options = GetOptions::default();
+        options.if_match = Some("*".to_string()); // Passes if file exists
+        options.check_preconditions(&meta).unwrap();
+    }
 }
diff --git a/object_store/src/limit.rs b/object_store/src/limit.rs
index 09c88aa2a4bc..d1363d9a4d46 100644
--- a/object_store/src/limit.rs
+++ b/object_store/src/limit.rs
@@ -18,12 +18,12 @@
 //! An object store that limits the maximum concurrency of the wrapped implementation
 
 use crate::{
-    BoxStream, GetResult, ListResult, MultipartId, ObjectMeta, ObjectStore, Path, Result,
-    StreamExt,
+    BoxStream, GetOptions, GetResult, GetResultPayload, ListResult, MultipartId, ObjectMeta,
+    ObjectStore, Path, PutOptions, PutResult, Result, StreamExt,
 };
 use async_trait::async_trait;
 use bytes::Bytes;
-use futures::Stream;
+use futures::{FutureExt, Stream};
 use std::io::{Error, IoSlice};
 use std::ops::Range;
 use std::pin::Pin;
@@ -72,11 +72,15 @@ impl<T: ObjectStore> std::fmt::Display for LimitStore<T> {
 
 #[async_trait]
 impl<T: ObjectStore> ObjectStore for LimitStore<T> {
-    async fn put(&self, location: &Path, bytes: Bytes) -> Result<()> {
+    async fn put(&self, location: &Path, bytes: Bytes) -> Result<PutResult> {
         let _permit = self.semaphore.acquire().await.unwrap();
         self.inner.put(location, bytes).await
     }
 
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        let _permit = self.semaphore.acquire().await.unwrap();
+        self.inner.put_opts(location, bytes, opts).await
+    }
     async fn put_multipart(
         &self,
         location: &Path,
@@ -86,23 +90,20 @@ impl<T: ObjectStore> ObjectStore for LimitStore<T> {
         Ok((id, Box::new(PermitWrapper::new(write, permit))))
     }
 
-    async fn abort_multipart(
-        &self,
-        location: &Path,
-        multipart_id: &MultipartId,
-    ) -> Result<()> {
+    async fn abort_multipart(&self, location: &Path, multipart_id: &MultipartId) -> Result<()> {
         let _permit = self.semaphore.acquire().await.unwrap();
         self.inner.abort_multipart(location, multipart_id).await
     }
-
     async fn get(&self, location: &Path) -> Result<GetResult> {
         let permit = Arc::clone(&self.semaphore).acquire_owned().await.unwrap();
-        match self.inner.get(location).await? {
-            r @ GetResult::File(_, _) => Ok(r),
-            GetResult::Stream(s) => {
-                Ok(GetResult::Stream(PermitWrapper::new(s, permit).boxed()))
-            }
-        }
+        let r = self.inner.get(location).await?;
+        Ok(permit_get_result(r, permit))
+    }
+
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        let permit = Arc::clone(&self.semaphore).acquire_owned().await.unwrap();
+        let r = self.inner.get_opts(location, options).await?;
+        Ok(permit_get_result(r, permit))
     }
 
     async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes> {
@@ -110,11 +111,7 @@ impl<T: ObjectStore> ObjectStore for LimitStore<T> {
         self.inner.get_range(location, range).await
     }
 
-    async fn get_ranges(
-        &self,
-        location: &Path,
-        ranges: &[Range<usize>],
-    ) -> Result<Vec<Bytes>> {
+    async fn get_ranges(&self, location: &Path, ranges: &[Range<usize>]) -> Result<Vec<Bytes>> {
         let _permit = self.semaphore.acquire().await.unwrap();
         self.inner.get_ranges(location, ranges).await
     }
@@ -129,13 +126,38 @@ impl<T: ObjectStore> ObjectStore for LimitStore<T> {
         self.inner.delete(location).await
     }
 
-    async fn list(
+    fn delete_stream<'a>(
+        &'a self,
+        locations: BoxStream<'a, Result<Path>>,
+    ) -> BoxStream<'a, Result<Path>> {
+        self.inner.delete_stream(locations)
+    }
+
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        let prefix = prefix.cloned();
+        let fut = Arc::clone(&self.semaphore)
+            .acquire_owned()
+            .map(move |permit| {
+                let s = self.inner.list(prefix.as_ref());
+                PermitWrapper::new(s, permit.unwrap())
+            });
+        fut.into_stream().flatten().boxed()
+    }
+
+    fn list_with_offset(
         &self,
         prefix: Option<&Path>,
-    ) -> Result<BoxStream<'_, Result<ObjectMeta>>> {
-        let permit = Arc::clone(&self.semaphore).acquire_owned().await.unwrap();
-        let s = self.inner.list(prefix).await?;
-        Ok(PermitWrapper::new(s, permit).boxed())
+        offset: &Path,
+    ) -> BoxStream<'_, Result<ObjectMeta>> {
+        let prefix = prefix.cloned();
+        let offset = offset.clone();
+        let fut = Arc::clone(&self.semaphore)
+            .acquire_owned()
+            .map(move |permit| {
+                let s = self.inner.list_with_offset(prefix.as_ref(), &offset);
+                PermitWrapper::new(s, permit.unwrap())
+            });
+        fut.into_stream().flatten().boxed()
     }
 
     async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
@@ -164,6 +186,16 @@ impl<T: ObjectStore> ObjectStore for LimitStore<T> {
     }
 }
 
+fn permit_get_result(r: GetResult, permit: OwnedSemaphorePermit) -> GetResult {
+    let payload = match r.payload {
+        v @ GetResultPayload::File(_, _) => v,
+        GetResultPayload::Stream(s) => {
+            GetResultPayload::Stream(PermitWrapper::new(s, permit).boxed())
+        }
+    };
+    GetResult { payload, ..r }
+}
+
 /// Combines an [`OwnedSemaphorePermit`] with some other type
 struct PermitWrapper<T> {
     inner: T,
@@ -180,10 +212,7 @@ impl<T> PermitWrapper<T> {
 impl<T: Stream + Unpin> Stream for PermitWrapper<T> {
     type Item = T::Item;
 
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
         Pin::new(&mut self.inner).poll_next(cx)
     }
 
@@ -232,11 +261,10 @@ impl<T: AsyncWrite + Unpin> AsyncWrite for PermitWrapper<T> {
 mod tests {
     use crate::limit::LimitStore;
     use crate::memory::InMemory;
-    use crate::tests::{
-        list_uses_directories_correctly, list_with_delimiter, put_get_delete_list,
-        rename_and_copy, stream_get,
-    };
+    use crate::tests::*;
     use crate::ObjectStore;
+    use futures::stream::StreamExt;
+    use std::pin::Pin;
     use std::time::Duration;
     use tokio::time::timeout;
 
@@ -247,6 +275,7 @@ mod tests {
         let integration = LimitStore::new(memory, max_requests);
 
         put_get_delete_list(&integration).await;
+        get_opts(&integration).await;
         list_uses_directories_correctly(&integration).await;
         list_with_delimiter(&integration).await;
         rename_and_copy(&integration).await;
@@ -254,19 +283,21 @@ mod tests {
 
         let mut streams = Vec::with_capacity(max_requests);
         for _ in 0..max_requests {
-            let stream = integration.list(None).await.unwrap();
+            let mut stream = integration.list(None).peekable();
+            Pin::new(&mut stream).peek().await; // Ensure semaphore is acquired
             streams.push(stream);
         }
 
         let t = Duration::from_millis(20);
 
         // Expect to not be able to make another request
-        assert!(timeout(t, integration.list(None)).await.is_err());
+        let fut = integration.list(None).collect::<Vec<_>>();
+        assert!(timeout(t, fut).await.is_err());
 
         // Drop one of the streams
         streams.pop();
 
         // Can now make another request
-        integration.list(None).await.unwrap();
+        integration.list(None).collect::<Vec<_>>().await;
     }
 }
diff --git a/object_store/src/local.rs b/object_store/src/local.rs
index fd3c3592ab56..e985ff070cd4 100644
--- a/object_store/src/local.rs
+++ b/object_store/src/local.rs
@@ -19,20 +19,25 @@
 use crate::{
     maybe_spawn_blocking,
     path::{absolute_path_to_url, Path},
-    GetResult, ListResult, MultipartId, ObjectMeta, ObjectStore, Result,
+    util::InvalidGetRange,
+    GetOptions, GetResult, GetResultPayload, ListResult, MultipartId, ObjectMeta, ObjectStore,
+    PutMode, PutOptions, PutResult, Result,
 };
 use async_trait::async_trait;
 use bytes::Bytes;
+use chrono::{DateTime, Utc};
 use futures::future::BoxFuture;
-use futures::FutureExt;
+use futures::ready;
 use futures::{stream::BoxStream, StreamExt};
-use snafu::{ensure, OptionExt, ResultExt, Snafu};
-use std::fs::{metadata, symlink_metadata, File};
-use std::io::{Read, Seek, SeekFrom, Write};
+use futures::{FutureExt, TryStreamExt};
+use snafu::{ensure, ResultExt, Snafu};
+use std::fs::{metadata, symlink_metadata, File, Metadata, OpenOptions};
+use std::io::{ErrorKind, Read, Seek, SeekFrom, Write};
 use std::ops::Range;
 use std::pin::Pin;
 use std::sync::Arc;
 use std::task::Poll;
+use std::time::SystemTime;
 use std::{collections::BTreeSet, convert::TryFrom, io};
 use std::{collections::VecDeque, path::PathBuf};
 use tokio::io::AsyncWrite;
@@ -55,7 +60,7 @@ pub(crate) enum Error {
     },
 
     #[snafu(display("Unable to access metadata for {}: {}", path, source))]
-    UnableToAccessMetadata {
+    Metadata {
         source: Box<dyn std::error::Error + Send + Sync + 'static>,
         path: String,
     },
@@ -65,16 +70,21 @@ pub(crate) enum Error {
         source: io::Error,
     },
 
+    #[snafu(display("Unable to rename file: {}", source))]
+    UnableToRenameFile {
+        source: io::Error,
+    },
+
     #[snafu(display("Unable to create dir {}: {}", path.display(), source))]
     UnableToCreateDir {
         source: io::Error,
         path: PathBuf,
     },
 
-    #[snafu(display("Unable to create file {}: {}", path.display(), err))]
+    #[snafu(display("Unable to create file {}: {}", path.display(), source))]
     UnableToCreateFile {
+        source: io::Error,
         path: PathBuf,
-        err: io::Error,
     },
 
     #[snafu(display("Unable to delete file {}: {}", path.display(), source))]
@@ -102,6 +112,11 @@ pub(crate) enum Error {
         actual: usize,
     },
 
+    #[snafu(display("Requested range was invalid"))]
+    InvalidRange {
+        source: InvalidGetRange,
+    },
+
     #[snafu(display("Unable to copy file from {} to {}: {}", from.display(), to.display(), source))]
     UnableToCopyFile {
         from: PathBuf,
@@ -135,6 +150,11 @@ pub(crate) enum Error {
         path: PathBuf,
         source: io::Error,
     },
+
+    #[snafu(display("Filenames containing trailing '/#\\d+/' are not supported: {}", path))]
+    InvalidPath {
+        path: String,
+    },
 }
 
 impl From<Error> for super::Error {
@@ -167,6 +187,30 @@ impl From<Error> for super::Error {
 /// [file URI]: https://en.wikipedia.org/wiki/File_URI_scheme
 /// [RFC 3986]: https://www.rfc-editor.org/rfc/rfc3986
 ///
+/// # Path Semantics
+///
+/// [`LocalFileSystem`] will expose the path semantics of the underlying filesystem, which may
+/// have additional restrictions beyond those enforced by [`Path`].
+///
+/// For example:
+///
+/// * Windows forbids certain filenames, e.g. `COM0`,
+/// * Windows forbids folders with trailing `.`
+/// * Windows forbids certain ASCII characters, e.g. `<` or `|`
+/// * OS X forbids filenames containing `:`
+/// * Leading `-` are discouraged on Unix systems where they may be interpreted as CLI flags
+/// * Filesystems may have restrictions on the maximum path or path segment length
+/// * Filesystem support for non-ASCII characters is inconsistent
+///
+/// Additionally some filesystems, such as NTFS, are case-insensitive, whilst others like
+/// FAT don't preserve case at all. Further some filesystems support non-unicode character
+/// sequences, such as unpaired UTF-16 surrogates, and [`LocalFileSystem`] will error on
+/// encountering such sequences.
+///
+/// Finally, filenames matching the regex `/.*#\d+/`, e.g. `foo.parquet#123`, are not supported
+/// by [`LocalFileSystem`] as they are used to provide atomic writes. Such files will be ignored
+/// for listing operations, and attempting to address such a file will error.
+///
 /// # Tokio Compatibility
 ///
 /// Tokio discourages performing blocking IO on a tokio worker thread, however,
@@ -187,6 +231,11 @@ impl From<Error> for super::Error {
 /// * Mutating a file through one or more symlinks will mutate the underlying file
 /// * Deleting a path that resolves to a symlink will only delete the symlink
 ///
+/// # Cross-Filesystem Copy
+///
+/// [`LocalFileSystem::copy`] is implemented using [`std::fs::hard_link`], and therefore
+/// does not support copying across filesystem boundaries.
+///
 #[derive(Debug)]
 pub struct LocalFileSystem {
     config: Arc<Config>,
@@ -237,8 +286,19 @@ impl LocalFileSystem {
 }
 
 impl Config {
-    /// Return an absolute filesystem path of the given location
+    /// Return an absolute filesystem path of the given file location
     fn path_to_filesystem(&self, location: &Path) -> Result<PathBuf> {
+        ensure!(
+            is_valid_file_path(location),
+            InvalidPathSnafu {
+                path: location.as_ref()
+            }
+        );
+        self.prefix_to_filesystem(location)
+    }
+
+    /// Return an absolute filesystem path of the given location
+    fn prefix_to_filesystem(&self, location: &Path) -> Result<PathBuf> {
         let mut url = self.root.clone();
         url.path_segments_mut()
             .expect("url path")
@@ -260,18 +320,77 @@ impl Config {
     }
 }
 
+fn is_valid_file_path(path: &Path) -> bool {
+    match path.filename() {
+        Some(p) => match p.split_once('#') {
+            Some((_, suffix)) if !suffix.is_empty() => {
+                // Valid if contains non-digits
+                !suffix.as_bytes().iter().all(|x| x.is_ascii_digit())
+            }
+            _ => true,
+        },
+        None => false,
+    }
+}
+
 #[async_trait]
 impl ObjectStore for LocalFileSystem {
-    async fn put(&self, location: &Path, bytes: Bytes) -> Result<()> {
-        let path = self.config.path_to_filesystem(location)?;
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        if matches!(opts.mode, PutMode::Update(_)) {
+            return Err(crate::Error::NotImplemented);
+        }
 
+        let path = self.config.path_to_filesystem(location)?;
         maybe_spawn_blocking(move || {
-            let mut file = open_writable_file(&path)?;
+            let (mut file, suffix) = new_staged_upload(&path)?;
+            let staging_path = staged_upload_path(&path, &suffix);
+            let mut e_tag = None;
+
+            let err = match file.write_all(&bytes) {
+                Ok(_) => {
+                    let metadata = file.metadata().map_err(|e| Error::Metadata {
+                        source: e.into(),
+                        path: path.to_string_lossy().to_string(),
+                    })?;
+                    e_tag = Some(get_etag(&metadata));
+                    match opts.mode {
+                        PutMode::Overwrite => {
+                            // For some fuse types of file systems, the file must be closed first
+                            // to trigger the upload operation, and then renamed, such as Blobfuse
+                            std::mem::drop(file);
+                            match std::fs::rename(&staging_path, &path) {
+                                Ok(_) => None,
+                                Err(source) => Some(Error::UnableToRenameFile { source }),
+                            }
+                        }
+                        PutMode::Create => match std::fs::hard_link(&staging_path, &path) {
+                            Ok(_) => {
+                                let _ = std::fs::remove_file(&staging_path); // Attempt to cleanup
+                                None
+                            }
+                            Err(source) => match source.kind() {
+                                ErrorKind::AlreadyExists => Some(Error::AlreadyExists {
+                                    path: path.to_str().unwrap().to_string(),
+                                    source,
+                                }),
+                                _ => Some(Error::UnableToRenameFile { source }),
+                            },
+                        },
+                        PutMode::Update(_) => unreachable!(),
+                    }
+                }
+                Err(source) => Some(Error::UnableToCopyDataToFile { source }),
+            };
 
-            file.write_all(&bytes)
-                .context(UnableToCopyDataToFileSnafu)?;
+            if let Some(err) = err {
+                let _ = std::fs::remove_file(&staging_path); // Attempt to cleanup
+                return Err(err.into());
+            }
 
-            Ok(())
+            Ok(PutResult {
+                e_tag,
+                version: None,
+            })
         })
         .await
     }
@@ -282,52 +401,45 @@ impl ObjectStore for LocalFileSystem {
     ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
         let dest = self.config.path_to_filesystem(location)?;
 
-        // Generate an id in case of concurrent writes
-        let mut multipart_id = 1;
-
-        // Will write to a temporary path
-        let staging_path = loop {
-            let staging_path = get_upload_stage_path(&dest, &multipart_id.to_string());
-
-            match std::fs::metadata(&staging_path) {
-                Err(err) if err.kind() == io::ErrorKind::NotFound => break staging_path,
-                Err(err) => {
-                    return Err(Error::UnableToCopyDataToFile { source: err }.into())
-                }
-                Ok(_) => multipart_id += 1,
-            }
-        };
-        let multipart_id = multipart_id.to_string();
-
-        let file = open_writable_file(&staging_path)?;
-
+        let (file, suffix) = new_staged_upload(&dest)?;
         Ok((
-            multipart_id.clone(),
-            Box::new(LocalUpload::new(dest, multipart_id, Arc::new(file))),
+            suffix.clone(),
+            Box::new(LocalUpload::new(dest, suffix, Arc::new(file))),
         ))
     }
 
-    async fn abort_multipart(
-        &self,
-        location: &Path,
-        multipart_id: &MultipartId,
-    ) -> Result<()> {
+    async fn abort_multipart(&self, location: &Path, multipart_id: &MultipartId) -> Result<()> {
         let dest = self.config.path_to_filesystem(location)?;
-        let staging_path: PathBuf = get_upload_stage_path(&dest, multipart_id);
+        let path: PathBuf = staged_upload_path(&dest, multipart_id);
 
-        maybe_spawn_blocking(move || {
-            std::fs::remove_file(&staging_path)
-                .context(UnableToDeleteFileSnafu { path: staging_path })?;
-            Ok(())
+        maybe_spawn_blocking(move || match std::fs::remove_file(&path) {
+            Ok(_) => Ok(()),
+            Err(source) => match source.kind() {
+                ErrorKind::NotFound => Ok(()), // Already deleted
+                _ => Err(Error::UnableToDeleteFile { path, source }.into()),
+            },
         })
         .await
     }
 
-    async fn get(&self, location: &Path) -> Result<GetResult> {
-        let path = self.config.path_to_filesystem(location)?;
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        let location = location.clone();
+        let path = self.config.path_to_filesystem(&location)?;
         maybe_spawn_blocking(move || {
-            let file = open_file(&path)?;
-            Ok(GetResult::File(file, path))
+            let (file, metadata) = open_file(&path)?;
+            let meta = convert_metadata(metadata, location)?;
+            options.check_preconditions(&meta)?;
+
+            let range = match options.range {
+                Some(r) => r.as_range(meta.size).context(InvalidRangeSnafu)?,
+                None => 0..meta.size,
+            };
+
+            Ok(GetResult {
+                payload: GetResultPayload::File(file, path),
+                range,
+                meta,
+            })
         })
         .await
     }
@@ -335,22 +447,18 @@ impl ObjectStore for LocalFileSystem {
     async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes> {
         let path = self.config.path_to_filesystem(location)?;
         maybe_spawn_blocking(move || {
-            let mut file = open_file(&path)?;
+            let (mut file, _) = open_file(&path)?;
             read_range(&mut file, &path, range)
         })
         .await
     }
 
-    async fn get_ranges(
-        &self,
-        location: &Path,
-        ranges: &[Range<usize>],
-    ) -> Result<Vec<Bytes>> {
+    async fn get_ranges(&self, location: &Path, ranges: &[Range<usize>]) -> Result<Vec<Bytes>> {
         let path = self.config.path_to_filesystem(location)?;
         let ranges = ranges.to_vec();
         maybe_spawn_blocking(move || {
             // Vectored IO might be faster
-            let mut file = open_file(&path)?;
+            let (mut file, _) = open_file(&path)?;
             ranges
                 .into_iter()
                 .map(|r| read_range(&mut file, &path, r))
@@ -359,106 +467,91 @@ impl ObjectStore for LocalFileSystem {
         .await
     }
 
-    async fn head(&self, location: &Path) -> Result<ObjectMeta> {
-        let path = self.config.path_to_filesystem(location)?;
-        let location = location.clone();
-
-        maybe_spawn_blocking(move || {
-            let file = open_file(&path)?;
-            let metadata =
-                file.metadata().map_err(|e| Error::UnableToAccessMetadata {
-                    source: e.into(),
-                    path: location.to_string(),
-                })?;
-
-            convert_metadata(metadata, location)
-        })
-        .await
-    }
-
     async fn delete(&self, location: &Path) -> Result<()> {
         let path = self.config.path_to_filesystem(location)?;
-        maybe_spawn_blocking(move || {
-            std::fs::remove_file(&path).context(UnableToDeleteFileSnafu { path })?;
-            Ok(())
+        maybe_spawn_blocking(move || match std::fs::remove_file(&path) {
+            Ok(_) => Ok(()),
+            Err(e) => Err(match e.kind() {
+                ErrorKind::NotFound => Error::NotFound { path, source: e }.into(),
+                _ => Error::UnableToDeleteFile { path, source: e }.into(),
+            }),
         })
         .await
     }
 
-    async fn list(
-        &self,
-        prefix: Option<&Path>,
-    ) -> Result<BoxStream<'_, Result<ObjectMeta>>> {
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
         let config = Arc::clone(&self.config);
 
         let root_path = match prefix {
-            Some(prefix) => config.path_to_filesystem(prefix)?,
+            Some(prefix) => match config.prefix_to_filesystem(prefix) {
+                Ok(path) => path,
+                Err(e) => return futures::future::ready(Err(e)).into_stream().boxed(),
+            },
             None => self.config.root.to_file_path().unwrap(),
         };
 
-        let walkdir = WalkDir::new(&root_path)
+        let walkdir = WalkDir::new(root_path)
             // Don't include the root directory itself
             .min_depth(1)
             .follow_links(true);
 
         let s = walkdir.into_iter().flat_map(move |result_dir_entry| {
-            match convert_walkdir_result(result_dir_entry) {
+            let entry = match convert_walkdir_result(result_dir_entry).transpose()? {
+                Ok(entry) => entry,
+                Err(e) => return Some(Err(e)),
+            };
+
+            if !entry.path().is_file() {
+                return None;
+            }
+
+            match config.filesystem_to_path(entry.path()) {
+                Ok(path) => match is_valid_file_path(&path) {
+                    true => Some(convert_entry(entry, path)),
+                    false => None,
+                },
                 Err(e) => Some(Err(e)),
-                Ok(None) => None,
-                Ok(entry @ Some(_)) => entry
-                    .filter(|dir_entry| {
-                        dir_entry.file_type().is_file()
-                            // Ignore file names with # in them, since they might be in-progress uploads.
-                            // They would be rejected anyways by filesystem_to_path below.
-                            && !dir_entry.file_name().to_string_lossy().contains('#')
-                    })
-                    .map(|entry| {
-                        let location = config.filesystem_to_path(entry.path())?;
-                        convert_entry(entry, location)
-                    }),
             }
         });
 
         // If no tokio context, return iterator directly as no
         // need to perform chunked spawn_blocking reads
         if tokio::runtime::Handle::try_current().is_err() {
-            return Ok(futures::stream::iter(s).boxed());
+            return futures::stream::iter(s).boxed();
         }
 
         // Otherwise list in batches of CHUNK_SIZE
         const CHUNK_SIZE: usize = 1024;
 
         let buffer = VecDeque::with_capacity(CHUNK_SIZE);
-        let stream =
-            futures::stream::try_unfold((s, buffer), |(mut s, mut buffer)| async move {
-                if buffer.is_empty() {
-                    (s, buffer) = tokio::task::spawn_blocking(move || {
-                        for _ in 0..CHUNK_SIZE {
-                            match s.next() {
-                                Some(r) => buffer.push_back(r),
-                                None => break,
-                            }
+        futures::stream::try_unfold((s, buffer), |(mut s, mut buffer)| async move {
+            if buffer.is_empty() {
+                (s, buffer) = tokio::task::spawn_blocking(move || {
+                    for _ in 0..CHUNK_SIZE {
+                        match s.next() {
+                            Some(r) => buffer.push_back(r),
+                            None => break,
                         }
-                        (s, buffer)
-                    })
-                    .await?;
-                }
-
-                match buffer.pop_front() {
-                    Some(Err(e)) => Err(e),
-                    Some(Ok(meta)) => Ok(Some((meta, (s, buffer)))),
-                    None => Ok(None),
-                }
-            });
+                    }
+                    (s, buffer)
+                })
+                .await?;
+            }
 
-        Ok(stream.boxed())
+            match buffer.pop_front() {
+                Some(Err(e)) => Err(e),
+                Some(Ok(meta)) => Ok(Some((meta, (s, buffer)))),
+                None => Ok(None),
+            }
+        })
+        .boxed()
     }
 
     async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
         let config = Arc::clone(&self.config);
 
         let prefix = prefix.cloned().unwrap_or_default();
-        let resolved_prefix = config.path_to_filesystem(&prefix)?;
+        let resolved_prefix = config.prefix_to_filesystem(&prefix)?;
 
         maybe_spawn_blocking(move || {
             let walkdir = WalkDir::new(&resolved_prefix)
@@ -471,15 +564,11 @@ impl ObjectStore for LocalFileSystem {
 
             for entry_res in walkdir.into_iter().map(convert_walkdir_result) {
                 if let Some(entry) = entry_res? {
-                    if entry.file_type().is_file()
-                        // Ignore file names with # in them, since they might be in-progress uploads.
-                        // They would be rejected anyways by filesystem_to_path below.
-                        && entry.file_name().to_string_lossy().contains('#')
-                    {
-                        continue;
-                    }
                     let is_directory = entry.file_type().is_dir();
                     let entry_location = config.filesystem_to_path(entry.path())?;
+                    if !is_directory && !is_valid_file_path(&entry_location) {
+                        continue;
+                    }
 
                     let mut parts = match entry_location.prefix_match(&prefix) {
                         Some(parts) => parts,
@@ -512,10 +601,28 @@ impl ObjectStore for LocalFileSystem {
     async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
         let from = self.config.path_to_filesystem(from)?;
         let to = self.config.path_to_filesystem(to)?;
-
-        maybe_spawn_blocking(move || {
-            std::fs::copy(&from, &to).context(UnableToCopyFileSnafu { from, to })?;
-            Ok(())
+        let mut id = 0;
+        // In order to make this atomic we:
+        //
+        // - hard link to a hidden temporary file
+        // - atomically rename this temporary file into place
+        //
+        // This is necessary because hard_link returns an error if the destination already exists
+        maybe_spawn_blocking(move || loop {
+            let staged = staged_upload_path(&to, &id.to_string());
+            match std::fs::hard_link(&from, &staged) {
+                Ok(_) => {
+                    return std::fs::rename(&staged, &to).map_err(|source| {
+                        let _ = std::fs::remove_file(&staged); // Attempt to clean up
+                        Error::UnableToCopyFile { from, to, source }.into()
+                    });
+                }
+                Err(source) => match source.kind() {
+                    ErrorKind::AlreadyExists => id += 1,
+                    ErrorKind::NotFound => create_parent_dirs(&to, source)?,
+                    _ => return Err(Error::UnableToCopyFile { from, to, source }.into()),
+                },
+            }
         })
         .await
     }
@@ -523,9 +630,14 @@ impl ObjectStore for LocalFileSystem {
     async fn rename(&self, from: &Path, to: &Path) -> Result<()> {
         let from = self.config.path_to_filesystem(from)?;
         let to = self.config.path_to_filesystem(to)?;
-        maybe_spawn_blocking(move || {
-            std::fs::rename(&from, &to).context(UnableToCopyFileSnafu { from, to })?;
-            Ok(())
+        maybe_spawn_blocking(move || loop {
+            match std::fs::rename(&from, &to) {
+                Ok(_) => return Ok(()),
+                Err(source) => match source.kind() {
+                    ErrorKind::NotFound => create_parent_dirs(&to, source)?,
+                    _ => return Err(Error::UnableToCopyFile { from, to, source }.into()),
+                },
+            }
         })
         .await
     }
@@ -534,39 +646,70 @@ impl ObjectStore for LocalFileSystem {
         let from = self.config.path_to_filesystem(from)?;
         let to = self.config.path_to_filesystem(to)?;
 
-        maybe_spawn_blocking(move || {
-            std::fs::hard_link(&from, &to).map_err(|err| match err.kind() {
-                io::ErrorKind::AlreadyExists => Error::AlreadyExists {
-                    path: to.to_str().unwrap().to_string(),
-                    source: err,
-                }
-                .into(),
-                _ => Error::UnableToCopyFile {
-                    from,
-                    to,
-                    source: err,
-                }
-                .into(),
-            })
+        maybe_spawn_blocking(move || loop {
+            match std::fs::hard_link(&from, &to) {
+                Ok(_) => return Ok(()),
+                Err(source) => match source.kind() {
+                    ErrorKind::AlreadyExists => {
+                        return Err(Error::AlreadyExists {
+                            path: to.to_str().unwrap().to_string(),
+                            source,
+                        }
+                        .into())
+                    }
+                    ErrorKind::NotFound => create_parent_dirs(&to, source)?,
+                    _ => return Err(Error::UnableToCopyFile { from, to, source }.into()),
+                },
+            }
         })
         .await
     }
 }
 
-fn get_upload_stage_path(dest: &std::path::Path, multipart_id: &MultipartId) -> PathBuf {
+/// Creates the parent directories of `path` or returns an error based on `source` if no parent
+fn create_parent_dirs(path: &std::path::Path, source: io::Error) -> Result<()> {
+    let parent = path.parent().ok_or_else(|| Error::UnableToCreateFile {
+        path: path.to_path_buf(),
+        source,
+    })?;
+
+    std::fs::create_dir_all(parent).context(UnableToCreateDirSnafu { path: parent })?;
+    Ok(())
+}
+
+/// Generates a unique file path `{base}#{suffix}`, returning the opened `File` and `suffix`
+///
+/// Creates any directories if necessary
+fn new_staged_upload(base: &std::path::Path) -> Result<(File, String)> {
+    let mut multipart_id = 1;
+    loop {
+        let suffix = multipart_id.to_string();
+        let path = staged_upload_path(base, &suffix);
+        let mut options = OpenOptions::new();
+        match options.read(true).write(true).create_new(true).open(&path) {
+            Ok(f) => return Ok((f, suffix)),
+            Err(source) => match source.kind() {
+                ErrorKind::AlreadyExists => multipart_id += 1,
+                ErrorKind::NotFound => create_parent_dirs(&path, source)?,
+                _ => return Err(Error::UnableToOpenFile { source, path }.into()),
+            },
+        }
+    }
+}
+
+/// Returns the unique upload for the given path and suffix
+fn staged_upload_path(dest: &std::path::Path, suffix: &str) -> PathBuf {
     let mut staging_path = dest.as_os_str().to_owned();
-    staging_path.push(format!("#{}", multipart_id));
+    staging_path.push("#");
+    staging_path.push(suffix);
     staging_path.into()
 }
 
 enum LocalUploadState {
     /// Upload is ready to send new data
-    Idle(Arc<std::fs::File>),
+    Idle(Arc<File>),
     /// In the middle of a write
-    Writing(
-        Arc<std::fs::File>,
-        BoxFuture<'static, Result<usize, io::Error>>,
-    ),
+    Writing(Arc<File>, BoxFuture<'static, Result<usize, io::Error>>),
     /// In the middle of syncing data and closing file.
     ///
     /// Future will contain last reference to file, so it will call drop on completion.
@@ -584,11 +727,7 @@ struct LocalUpload {
 }
 
 impl LocalUpload {
-    pub fn new(
-        dest: PathBuf,
-        multipart_id: MultipartId,
-        file: Arc<std::fs::File>,
-    ) -> Self {
+    pub fn new(dest: PathBuf, multipart_id: MultipartId, file: Arc<File>) -> Self {
         Self {
             inner_state: LocalUploadState::Idle(file),
             dest,
@@ -602,14 +741,13 @@ impl AsyncWrite for LocalUpload {
         mut self: Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
         buf: &[u8],
-    ) -> std::task::Poll<Result<usize, io::Error>> {
-        let invalid_state =
-            |condition: &str| -> std::task::Poll<Result<usize, io::Error>> {
-                Poll::Ready(Err(io::Error::new(
-                    io::ErrorKind::InvalidInput,
-                    format!("Tried to write to file {}.", condition),
-                )))
-            };
+    ) -> Poll<Result<usize, io::Error>> {
+        let invalid_state = |condition: &str| -> Poll<Result<usize, io::Error>> {
+            Poll::Ready(Err(io::Error::new(
+                ErrorKind::InvalidInput,
+                format!("Tried to write to file {condition}."),
+            )))
+        };
 
         if let Ok(runtime) = tokio::runtime::Handle::try_current() {
             let mut data: Vec<u8> = buf.to_vec();
@@ -627,25 +765,16 @@ impl AsyncWrite for LocalUpload {
                                 runtime
                                     .spawn_blocking(move || (&*file2).write_all(&data))
                                     .map(move |res| match res {
-                                        Err(err) => {
-                                            Err(io::Error::new(io::ErrorKind::Other, err))
-                                        }
+                                        Err(err) => Err(io::Error::new(ErrorKind::Other, err)),
                                         Ok(res) => res.map(move |_| data_len),
                                     }),
                             ),
                         );
                     }
                     LocalUploadState::Writing(file, inner_write) => {
-                        match inner_write.poll_unpin(cx) {
-                            Poll::Ready(res) => {
-                                self.inner_state =
-                                    LocalUploadState::Idle(Arc::clone(file));
-                                return Poll::Ready(res);
-                            }
-                            Poll::Pending => {
-                                return Poll::Pending;
-                            }
-                        }
+                        let res = ready!(inner_write.poll_unpin(cx));
+                        self.inner_state = LocalUploadState::Idle(Arc::clone(file));
+                        return Poll::Ready(res);
                     }
                     LocalUploadState::ShuttingDown(_) => {
                         return invalid_state("when writer is shutting down");
@@ -671,14 +800,14 @@ impl AsyncWrite for LocalUpload {
     fn poll_flush(
         self: Pin<&mut Self>,
         _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), io::Error>> {
+    ) -> Poll<Result<(), io::Error>> {
         Poll::Ready(Ok(()))
     }
 
     fn poll_shutdown(
         mut self: Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), io::Error>> {
+    ) -> Poll<Result<(), io::Error>> {
         if let Ok(runtime) = tokio::runtime::Handle::try_current() {
             loop {
                 match &mut self.inner_state {
@@ -686,31 +815,24 @@ impl AsyncWrite for LocalUpload {
                         // We are moving file into the future, and it will be dropped on it's completion, closing the file.
                         let file = Arc::clone(file);
                         self.inner_state = LocalUploadState::ShuttingDown(Box::pin(
-                            runtime.spawn_blocking(move || (*file).sync_all()).map(
-                                move |res| match res {
-                                    Err(err) => {
-                                        Err(io::Error::new(io::ErrorKind::Other, err))
-                                    }
+                            runtime
+                                .spawn_blocking(move || (*file).sync_all())
+                                .map(move |res| match res {
+                                    Err(err) => Err(io::Error::new(io::ErrorKind::Other, err)),
                                     Ok(res) => res,
-                                },
-                            ),
+                                }),
                         ));
                     }
                     LocalUploadState::ShuttingDown(fut) => match fut.poll_unpin(cx) {
                         Poll::Ready(res) => {
                             res?;
-                            let staging_path =
-                                get_upload_stage_path(&self.dest, &self.multipart_id);
+                            let staging_path = staged_upload_path(&self.dest, &self.multipart_id);
                             let dest = self.dest.clone();
                             self.inner_state = LocalUploadState::Committing(Box::pin(
                                 runtime
-                                    .spawn_blocking(move || {
-                                        std::fs::rename(&staging_path, &dest)
-                                    })
+                                    .spawn_blocking(move || std::fs::rename(&staging_path, &dest))
                                     .map(move |res| match res {
-                                        Err(err) => {
-                                            Err(io::Error::new(io::ErrorKind::Other, err))
-                                        }
+                                        Err(err) => Err(io::Error::new(io::ErrorKind::Other, err)),
                                         Ok(res) => res,
                                     }),
                             ));
@@ -725,13 +847,11 @@ impl AsyncWrite for LocalUpload {
                             "Tried to commit a file where a write is in progress.",
                         )));
                     }
-                    LocalUploadState::Committing(fut) => match fut.poll_unpin(cx) {
-                        Poll::Ready(res) => {
-                            self.inner_state = LocalUploadState::Complete;
-                            return Poll::Ready(res);
-                        }
-                        Poll::Pending => return Poll::Pending,
-                    },
+                    LocalUploadState::Committing(fut) => {
+                        let res = ready!(fut.poll_unpin(cx));
+                        self.inner_state = LocalUploadState::Complete;
+                        return Poll::Ready(res);
+                    }
                     LocalUploadState::Complete => {
                         return Poll::Ready(Err(io::Error::new(
                             io::ErrorKind::Other,
@@ -741,29 +861,88 @@ impl AsyncWrite for LocalUpload {
                 }
             }
         } else {
-            let staging_path = get_upload_stage_path(&self.dest, &self.multipart_id);
+            let staging_path = staged_upload_path(&self.dest, &self.multipart_id);
             match &mut self.inner_state {
                 LocalUploadState::Idle(file) => {
                     let file = Arc::clone(file);
                     self.inner_state = LocalUploadState::Complete;
                     file.sync_all()?;
-                    std::mem::drop(file);
-                    std::fs::rename(&staging_path, &self.dest)?;
+                    drop(file);
+                    std::fs::rename(staging_path, &self.dest)?;
                     Poll::Ready(Ok(()))
                 }
                 _ => {
                     // If we are running on this thread, then only possible states are Idle and Complete.
-                    Poll::Ready(Err(io::Error::new(
-                        io::ErrorKind::Other,
-                        "Already complete",
-                    )))
+                    Poll::Ready(Err(io::Error::new(ErrorKind::Other, "Already complete")))
                 }
             }
         }
     }
 }
 
-fn read_range(file: &mut File, path: &PathBuf, range: Range<usize>) -> Result<Bytes> {
+impl Drop for LocalUpload {
+    fn drop(&mut self) {
+        match self.inner_state {
+            LocalUploadState::Complete => (),
+            _ => {
+                self.inner_state = LocalUploadState::Complete;
+                let path = staged_upload_path(&self.dest, &self.multipart_id);
+                // Try to cleanup intermediate file ignoring any error
+                match tokio::runtime::Handle::try_current() {
+                    Ok(r) => drop(r.spawn_blocking(move || std::fs::remove_file(path))),
+                    Err(_) => drop(std::fs::remove_file(path)),
+                };
+            }
+        }
+    }
+}
+
+pub(crate) fn chunked_stream(
+    mut file: File,
+    path: PathBuf,
+    range: Range<usize>,
+    chunk_size: usize,
+) -> BoxStream<'static, Result<Bytes, super::Error>> {
+    futures::stream::once(async move {
+        let (file, path) = maybe_spawn_blocking(move || {
+            file.seek(SeekFrom::Start(range.start as _))
+                .map_err(|source| Error::Seek {
+                    source,
+                    path: path.clone(),
+                })?;
+            Ok((file, path))
+        })
+        .await?;
+
+        let stream = futures::stream::try_unfold(
+            (file, path, range.end - range.start),
+            move |(mut file, path, remaining)| {
+                maybe_spawn_blocking(move || {
+                    if remaining == 0 {
+                        return Ok(None);
+                    }
+
+                    let to_read = remaining.min(chunk_size);
+                    let mut buffer = Vec::with_capacity(to_read);
+                    let read = (&mut file)
+                        .take(to_read as u64)
+                        .read_to_end(&mut buffer)
+                        .map_err(|e| Error::UnableToReadBytes {
+                            source: e,
+                            path: path.clone(),
+                        })?;
+
+                    Ok(Some((buffer.into(), (file, path, remaining - read))))
+                })
+            },
+        );
+        Ok::<_, super::Error>(stream)
+    })
+    .try_flatten()
+    .boxed()
+}
+
+pub(crate) fn read_range(file: &mut File, path: &PathBuf, range: Range<usize>) -> Result<Bytes> {
     let to_read = range.end - range.start;
     file.seek(SeekFrom::Start(range.start as u64))
         .context(SeekSnafu { path })?;
@@ -785,66 +964,62 @@ fn read_range(file: &mut File, path: &PathBuf, range: Range<usize>) -> Result<By
     Ok(buf.into())
 }
 
-fn open_file(path: &PathBuf) -> Result<File> {
-    let file = File::open(path).map_err(|e| {
-        if e.kind() == std::io::ErrorKind::NotFound {
-            Error::NotFound {
+fn open_file(path: &PathBuf) -> Result<(File, Metadata)> {
+    let ret = match File::open(path).and_then(|f| Ok((f.metadata()?, f))) {
+        Err(e) => Err(match e.kind() {
+            ErrorKind::NotFound => Error::NotFound {
                 path: path.clone(),
                 source: e,
-            }
-        } else {
-            Error::UnableToOpenFile {
+            },
+            _ => Error::UnableToOpenFile {
                 path: path.clone(),
                 source: e,
-            }
-        }
-    })?;
-    Ok(file)
-}
-
-fn open_writable_file(path: &PathBuf) -> Result<File> {
-    match File::create(&path) {
-        Ok(f) => Ok(f),
-        Err(err) if err.kind() == std::io::ErrorKind::NotFound => {
-            let parent = path
-                .parent()
-                .context(UnableToCreateFileSnafu { path: &path, err })?;
-            std::fs::create_dir_all(&parent)
-                .context(UnableToCreateDirSnafu { path: parent })?;
-
-            match File::create(&path) {
-                Ok(f) => Ok(f),
-                Err(err) => Err(Error::UnableToCreateFile {
-                    path: path.to_path_buf(),
-                    err,
-                }
-                .into()),
-            }
-        }
-        Err(err) => Err(Error::UnableToCreateFile {
-            path: path.to_path_buf(),
-            err,
-        }
-        .into()),
-    }
+            },
+        }),
+        Ok((metadata, file)) => match !metadata.is_dir() {
+            true => Ok((file, metadata)),
+            false => Err(Error::NotFound {
+                path: path.clone(),
+                source: io::Error::new(ErrorKind::NotFound, "is directory"),
+            }),
+        },
+    }?;
+    Ok(ret)
 }
 
 fn convert_entry(entry: DirEntry, location: Path) -> Result<ObjectMeta> {
-    let metadata = entry
-        .metadata()
-        .map_err(|e| Error::UnableToAccessMetadata {
-            source: e.into(),
-            path: location.to_string(),
-        })?;
+    let metadata = entry.metadata().map_err(|e| Error::Metadata {
+        source: e.into(),
+        path: location.to_string(),
+    })?;
     convert_metadata(metadata, location)
 }
 
-fn convert_metadata(metadata: std::fs::Metadata, location: Path) -> Result<ObjectMeta> {
-    let last_modified = metadata
+fn last_modified(metadata: &Metadata) -> DateTime<Utc> {
+    metadata
         .modified()
         .expect("Modified file time should be supported on this platform")
-        .into();
+        .into()
+}
 
+fn get_etag(metadata: &Metadata) -> String {
+    let inode = get_inode(metadata);
+    let size = metadata.len();
+    let mtime = metadata
+        .modified()
+        .ok()
+        .and_then(|mtime| mtime.duration_since(SystemTime::UNIX_EPOCH).ok())
+        .unwrap_or_default()
+        .as_micros();
+
+    // Use an ETag scheme based on that used by many popular HTTP servers
+    // <https://httpd.apache.org/docs/2.2/mod/core.html#fileetag>
+    // <https://stackoverflow.com/questions/47512043/how-etags-are-generated-and-configured>
+    format!("{inode:x}-{mtime:x}-{size:x}")
+}
+
+fn convert_metadata(metadata: Metadata, location: Path) -> Result<ObjectMeta> {
+    let last_modified = last_modified(&metadata);
     let size = usize::try_from(metadata.len()).context(FileSizeOverflowedUsizeSnafu {
         path: location.as_ref(),
     })?;
@@ -853,14 +1028,29 @@ fn convert_metadata(metadata: std::fs::Metadata, location: Path) -> Result<Objec
         location,
         last_modified,
         size,
+        e_tag: Some(get_etag(&metadata)),
+        version: None,
     })
 }
 
+#[cfg(unix)]
+/// We include the inode when available to yield an ETag more resistant to collisions
+/// and as used by popular web servers such as [Apache](https://httpd.apache.org/docs/2.2/mod/core.html#fileetag)
+fn get_inode(metadata: &Metadata) -> u64 {
+    std::os::unix::fs::MetadataExt::ino(metadata)
+}
+
+#[cfg(not(unix))]
+/// On platforms where an inode isn't available, fallback to just relying on size and mtime
+fn get_inode(metadata: &Metadata) -> u64 {
+    0
+}
+
 /// Convert walkdir results and converts not-found errors into `None`.
 /// Convert broken symlinks to `None`.
 fn convert_walkdir_result(
-    res: std::result::Result<walkdir::DirEntry, walkdir::Error>,
-) -> Result<Option<walkdir::DirEntry>> {
+    res: std::result::Result<DirEntry, walkdir::Error>,
+) -> Result<Option<DirEntry>> {
     match res {
         Ok(entry) => {
             // To check for broken symlink: call symlink_metadata() - it does not traverse symlinks);
@@ -889,7 +1079,7 @@ fn convert_walkdir_result(
 
         Err(walkdir_err) => match walkdir_err.io_error() {
             Some(io_err) => match io_err.kind() {
-                io::ErrorKind::NotFound => Ok(None),
+                ErrorKind::NotFound => Ok(None),
                 _ => Err(Error::UnableToWalkDir {
                     source: walkdir_err,
                 }
@@ -907,13 +1097,7 @@ fn convert_walkdir_result(
 mod tests {
     use super::*;
     use crate::test_util::flatten_list_stream;
-    use crate::{
-        tests::{
-            copy_if_not_exists, get_nonexistent_object, list_uses_directories_correctly,
-            list_with_delimiter, put_get_delete_list, rename_and_copy, stream_get,
-        },
-        Error as ObjectStoreError, ObjectStore,
-    };
+    use crate::tests::*;
     use futures::TryStreamExt;
     use tempfile::{NamedTempFile, TempDir};
     use tokio::io::AsyncWriteExt;
@@ -924,11 +1108,13 @@ mod tests {
         let integration = LocalFileSystem::new_with_prefix(root.path()).unwrap();
 
         put_get_delete_list(&integration).await;
+        get_opts(&integration).await;
         list_uses_directories_correctly(&integration).await;
         list_with_delimiter(&integration).await;
         rename_and_copy(&integration).await;
         copy_if_not_exists(&integration).await;
         stream_get(&integration).await;
+        put_opts(&integration, false).await;
     }
 
     #[test]
@@ -1004,21 +1190,14 @@ mod tests {
 
         let store = LocalFileSystem::new_with_prefix(root.path()).unwrap();
 
-        // `list` must fail
-        match store.list(None).await {
-            Err(_) => {
-                // ok, error found
-            }
-            Ok(mut stream) => {
-                let mut any_err = false;
-                while let Some(res) = stream.next().await {
-                    if res.is_err() {
-                        any_err = true;
-                    }
-                }
-                assert!(any_err);
+        let mut stream = store.list(None);
+        let mut any_err = false;
+        while let Some(res) = stream.next().await {
+            if res.is_err() {
+                any_err = true;
             }
         }
+        assert!(any_err);
 
         // `list_with_delimiter
         assert!(store.list_with_delimiter(None).await.is_err());
@@ -1036,16 +1215,15 @@ mod tests {
         let err = get_nonexistent_object(&integration, Some(location))
             .await
             .unwrap_err();
-        if let ObjectStoreError::NotFound { path, source } = err {
+        if let crate::Error::NotFound { path, source } = err {
             let source_variant = source.downcast_ref::<std::io::Error>();
             assert!(
                 matches!(source_variant, Some(std::io::Error { .. }),),
-                "got: {:?}",
-                source_variant
+                "got: {source_variant:?}"
             );
             assert!(path.ends_with(NON_EXISTENT_NAME), "{}", path);
         } else {
-            panic!("unexpected error type: {:?}", err);
+            panic!("unexpected error type: {err:?}");
         }
     }
 
@@ -1069,33 +1247,27 @@ mod tests {
     }
 
     #[tokio::test]
+    #[cfg(target_family = "windows")]
     async fn test_list_root() {
-        let integration = LocalFileSystem::new();
-        let result = integration.list_with_delimiter(None).await;
-        if cfg!(target_family = "windows") {
-            let r = result.unwrap_err().to_string();
-            assert!(
-                r.contains("Unable to convert URL \"file:///\" to filesystem path"),
-                "{}",
-                r
-            );
-        } else {
-            result.unwrap();
-        }
+        let fs = LocalFileSystem::new();
+        let r = fs.list_with_delimiter(None).await.unwrap_err().to_string();
+
+        assert!(
+            r.contains("Unable to convert URL \"file:///\" to filesystem path"),
+            "{}",
+            r
+        );
     }
 
-    async fn check_list(
-        integration: &LocalFileSystem,
-        prefix: Option<&Path>,
-        expected: &[&str],
-    ) {
-        let result: Vec<_> = integration
-            .list(prefix)
-            .await
-            .unwrap()
-            .try_collect()
-            .await
-            .unwrap();
+    #[tokio::test]
+    #[cfg(target_os = "linux")]
+    async fn test_list_root() {
+        let fs = LocalFileSystem::new();
+        fs.list_with_delimiter(None).await.unwrap();
+    }
+
+    async fn check_list(integration: &LocalFileSystem, prefix: Option<&Path>, expected: &[&str]) {
+        let result: Vec<_> = integration.list(prefix).try_collect().await.unwrap();
 
         let mut strings: Vec<_> = result.iter().map(|x| x.location.as_ref()).collect();
         strings.sort_unstable();
@@ -1121,8 +1293,7 @@ mod tests {
 
         // Follow out of tree symlink
         let other = NamedTempFile::new().unwrap();
-        std::os::unix::fs::symlink(other.path(), root.path().join("test.parquet"))
-            .unwrap();
+        std::os::unix::fs::symlink(other.path(), root.path().join("test.parquet")).unwrap();
 
         // Should return test.parquet even though out of tree
         check_list(&integration, None, &["a/file.parquet", "test.parquet"]).await;
@@ -1147,11 +1318,7 @@ mod tests {
             .unwrap();
 
         // Ignore broken symlink
-        std::os::unix::fs::symlink(
-            root.path().join("foo.parquet"),
-            root.path().join("c"),
-        )
-        .unwrap();
+        std::os::unix::fs::symlink(root.path().join("foo.parquet"), root.path().join("c")).unwrap();
 
         check_list(
             &integration,
@@ -1232,24 +1399,19 @@ mod tests {
         assert!(result.common_prefixes.is_empty());
         assert_eq!(result.objects[0].location, object);
 
-        let illegal = root.join("💀");
-        std::fs::write(illegal, "foo").unwrap();
+        let emoji = root.join("💀");
+        std::fs::write(emoji, "foo").unwrap();
 
-        // Can list directory that doesn't contain illegal path
-        flatten_list_stream(&integration, Some(&directory))
-            .await
-            .unwrap();
+        // Can list illegal file
+        let mut paths = flatten_list_stream(&integration, None).await.unwrap();
+        paths.sort_unstable();
 
-        // Cannot list illegal file
-        let err = flatten_list_stream(&integration, None)
-            .await
-            .unwrap_err()
-            .to_string();
-
-        assert!(
-            err.contains("Encountered illegal character sequence \"💀\" whilst parsing path segment \"💀\""),
-            "{}",
-            err
+        assert_eq!(
+            paths,
+            vec![
+                Path::parse("directory/child.txt").unwrap(),
+                Path::parse("💀").unwrap()
+            ]
         );
     }
 
@@ -1260,12 +1422,10 @@ mod tests {
         let location = Path::from("some_file");
 
         let data = Bytes::from("arbitrary data");
-        let (multipart_id, mut writer) =
-            integration.put_multipart(&location).await.unwrap();
+        let (multipart_id, mut writer) = integration.put_multipart(&location).await.unwrap();
         writer.write_all(&data).await.unwrap();
 
-        let (multipart_id_2, mut writer_2) =
-            integration.put_multipart(&location).await.unwrap();
+        let (multipart_id_2, mut writer_2) = integration.put_multipart(&location).await.unwrap();
         assert_ne!(multipart_id, multipart_id_2);
         writer_2.write_all(&data).await.unwrap();
 
@@ -1291,8 +1451,7 @@ mod tests {
 
         std::fs::write(temp_dir.path().join(filename), "foo").unwrap();
 
-        let list_stream = integration.list(None).await.unwrap();
-        let res: Vec<_> = list_stream.try_collect().await.unwrap();
+        let res: Vec<_> = integration.list(None).try_collect().await.unwrap();
         assert_eq!(res.len(), 1);
         assert_eq!(res[0].location.as_ref(), filename);
 
@@ -1311,4 +1470,108 @@ mod tests {
         let path = Path::from_filesystem_path(".").unwrap();
         integration.list_with_delimiter(Some(&path)).await.unwrap();
     }
+
+    #[test]
+    fn test_valid_path() {
+        let cases = [
+            ("foo#123/test.txt", true),
+            ("foo#123/test#23.txt", true),
+            ("foo#123/test#34", false),
+            ("foo😁/test#34", false),
+            ("foo/test#😁34", true),
+        ];
+
+        for (case, expected) in cases {
+            let path = Path::parse(case).unwrap();
+            assert_eq!(is_valid_file_path(&path), expected);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_intermediate_files() {
+        let root = TempDir::new().unwrap();
+        let integration = LocalFileSystem::new_with_prefix(root.path()).unwrap();
+
+        let a = Path::parse("foo#123/test.txt").unwrap();
+        integration.put(&a, "test".into()).await.unwrap();
+
+        let list = flatten_list_stream(&integration, None).await.unwrap();
+        assert_eq!(list, vec![a.clone()]);
+
+        std::fs::write(root.path().join("bar#123"), "test").unwrap();
+
+        // Should ignore file
+        let list = flatten_list_stream(&integration, None).await.unwrap();
+        assert_eq!(list, vec![a.clone()]);
+
+        let b = Path::parse("bar#123").unwrap();
+        let err = integration.get(&b).await.unwrap_err().to_string();
+        assert_eq!(err, "Generic LocalFileSystem error: Filenames containing trailing '/#\\d+/' are not supported: bar#123");
+
+        let c = Path::parse("foo#123.txt").unwrap();
+        integration.put(&c, "test".into()).await.unwrap();
+
+        let mut list = flatten_list_stream(&integration, None).await.unwrap();
+        list.sort_unstable();
+        assert_eq!(list, vec![c, a]);
+    }
+}
+
+#[cfg(not(target_arch = "wasm32"))]
+#[cfg(test)]
+mod not_wasm_tests {
+    use crate::local::LocalFileSystem;
+    use crate::{ObjectStore, Path};
+    use std::time::Duration;
+    use tempfile::TempDir;
+    use tokio::io::AsyncWriteExt;
+
+    #[tokio::test]
+    async fn test_cleanup_intermediate_files() {
+        let root = TempDir::new().unwrap();
+        let integration = LocalFileSystem::new_with_prefix(root.path()).unwrap();
+
+        let location = Path::from("some_file");
+        let (_, mut writer) = integration.put_multipart(&location).await.unwrap();
+        writer.write_all(b"hello").await.unwrap();
+
+        let file_count = std::fs::read_dir(root.path()).unwrap().count();
+        assert_eq!(file_count, 1);
+        drop(writer);
+
+        tokio::time::sleep(Duration::from_millis(1)).await;
+
+        let file_count = std::fs::read_dir(root.path()).unwrap().count();
+        assert_eq!(file_count, 0);
+    }
+}
+
+#[cfg(target_family = "unix")]
+#[cfg(test)]
+mod unix_test {
+    use crate::local::LocalFileSystem;
+    use crate::{ObjectStore, Path};
+    use nix::sys::stat;
+    use nix::unistd;
+    use std::fs::OpenOptions;
+    use tempfile::TempDir;
+
+    #[tokio::test]
+    async fn test_fifo() {
+        let filename = "some_file";
+        let root = TempDir::new().unwrap();
+        let integration = LocalFileSystem::new_with_prefix(root.path()).unwrap();
+        let path = root.path().join(filename);
+        unistd::mkfifo(&path, stat::Mode::S_IRWXU).unwrap();
+
+        // Need to open read and write side in parallel
+        let spawned =
+            tokio::task::spawn_blocking(|| OpenOptions::new().write(true).open(path).unwrap());
+
+        let location = Path::from(filename);
+        integration.head(&location).await.unwrap();
+        integration.get(&location).await.unwrap();
+
+        spawned.await.unwrap();
+    }
 }
diff --git a/object_store/src/memory.rs b/object_store/src/memory.rs
index e4be5b2afddf..41cfcc490da6 100644
--- a/object_store/src/memory.rs
+++ b/object_store/src/memory.rs
@@ -16,14 +16,18 @@
 // under the License.
 
 //! An in-memory object store implementation
-use crate::MultipartId;
-use crate::{path::Path, GetResult, ListResult, ObjectMeta, ObjectStore, Result};
+use crate::util::InvalidGetRange;
+use crate::{
+    path::Path, GetRange, GetResult, GetResultPayload, ListResult, ObjectMeta, ObjectStore,
+    PutMode, PutOptions, PutResult, Result, UpdateVersion,
+};
+use crate::{GetOptions, MultipartId};
 use async_trait::async_trait;
 use bytes::Bytes;
-use chrono::Utc;
+use chrono::{DateTime, Utc};
 use futures::{stream::BoxStream, StreamExt};
 use parking_lot::RwLock;
-use snafu::{ensure, OptionExt, Snafu};
+use snafu::{OptionExt, ResultExt, Snafu};
 use std::collections::BTreeMap;
 use std::collections::BTreeSet;
 use std::io;
@@ -40,14 +44,14 @@ enum Error {
     #[snafu(display("No data in memory found. Location: {path}"))]
     NoDataInMemory { path: String },
 
-    #[snafu(display("Out of range"))]
-    OutOfRange,
-
-    #[snafu(display("Bad range"))]
-    BadRange,
+    #[snafu(display("Invalid range: {source}"))]
+    Range { source: InvalidGetRange },
 
     #[snafu(display("Object already exists at that location: {path}"))]
     AlreadyExists { path: String },
+
+    #[snafu(display("ETag required for conditional update"))]
+    MissingETag,
 }
 
 impl From<Error> for super::Error {
@@ -73,7 +77,83 @@ impl From<Error> for super::Error {
 /// storage provider.
 #[derive(Debug, Default)]
 pub struct InMemory {
-    storage: Arc<RwLock<BTreeMap<Path, Bytes>>>,
+    storage: SharedStorage,
+}
+
+#[derive(Debug, Clone)]
+struct Entry {
+    data: Bytes,
+    last_modified: DateTime<Utc>,
+    e_tag: usize,
+}
+
+impl Entry {
+    fn new(data: Bytes, last_modified: DateTime<Utc>, e_tag: usize) -> Self {
+        Self {
+            data,
+            last_modified,
+            e_tag,
+        }
+    }
+}
+
+#[derive(Debug, Default, Clone)]
+struct Storage {
+    next_etag: usize,
+    map: BTreeMap<Path, Entry>,
+}
+
+type SharedStorage = Arc<RwLock<Storage>>;
+
+impl Storage {
+    fn insert(&mut self, location: &Path, bytes: Bytes) -> usize {
+        let etag = self.next_etag;
+        self.next_etag += 1;
+        let entry = Entry::new(bytes, Utc::now(), etag);
+        self.overwrite(location, entry);
+        etag
+    }
+
+    fn overwrite(&mut self, location: &Path, entry: Entry) {
+        self.map.insert(location.clone(), entry);
+    }
+
+    fn create(&mut self, location: &Path, entry: Entry) -> Result<()> {
+        use std::collections::btree_map;
+        match self.map.entry(location.clone()) {
+            btree_map::Entry::Occupied(_) => Err(Error::AlreadyExists {
+                path: location.to_string(),
+            }
+            .into()),
+            btree_map::Entry::Vacant(v) => {
+                v.insert(entry);
+                Ok(())
+            }
+        }
+    }
+
+    fn update(&mut self, location: &Path, v: UpdateVersion, entry: Entry) -> Result<()> {
+        match self.map.get_mut(location) {
+            // Return Precondition instead of NotFound for consistency with stores
+            None => Err(crate::Error::Precondition {
+                path: location.to_string(),
+                source: format!("Object at location {location} not found").into(),
+            }),
+            Some(e) => {
+                let existing = e.e_tag.to_string();
+                let expected = v.e_tag.context(MissingETagSnafu)?;
+                if existing == expected {
+                    *e = entry;
+                    Ok(())
+                } else {
+                    Err(crate::Error::Precondition {
+                        path: location.to_string(),
+                        source: format!("{existing} does not match {expected}").into(),
+                    })
+                }
+            }
+        }
+    }
 }
 
 impl std::fmt::Display for InMemory {
@@ -84,9 +164,22 @@ impl std::fmt::Display for InMemory {
 
 #[async_trait]
 impl ObjectStore for InMemory {
-    async fn put(&self, location: &Path, bytes: Bytes) -> Result<()> {
-        self.storage.write().insert(location.clone(), bytes);
-        Ok(())
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        let mut storage = self.storage.write();
+        let etag = storage.next_etag;
+        let entry = Entry::new(bytes, Utc::now(), etag);
+
+        match opts.mode {
+            PutMode::Overwrite => storage.overwrite(location, entry),
+            PutMode::Create => storage.create(location, entry)?,
+            PutMode::Update(v) => storage.update(location, v, entry)?,
+        }
+        storage.next_etag += 1;
+
+        Ok(PutResult {
+            e_tag: Some(etag.to_string()),
+            version: None,
+        })
     }
 
     async fn put_multipart(
@@ -103,82 +196,98 @@ impl ObjectStore for InMemory {
         ))
     }
 
-    async fn abort_multipart(
-        &self,
-        _location: &Path,
-        _multipart_id: &MultipartId,
-    ) -> Result<()> {
+    async fn abort_multipart(&self, _location: &Path, _multipart_id: &MultipartId) -> Result<()> {
         // Nothing to clean up
         Ok(())
     }
 
-    async fn get(&self, location: &Path) -> Result<GetResult> {
-        let data = self.get_bytes(location).await?;
-
-        Ok(GetResult::Stream(
-            futures::stream::once(async move { Ok(data) }).boxed(),
-        ))
-    }
-
-    async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes> {
-        let data = self.get_bytes(location).await?;
-        ensure!(range.end <= data.len(), OutOfRangeSnafu);
-        ensure!(range.start <= range.end, BadRangeSnafu);
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        let entry = self.entry(location).await?;
+        let e_tag = entry.e_tag.to_string();
 
-        Ok(data.slice(range))
+        let meta = ObjectMeta {
+            location: location.clone(),
+            last_modified: entry.last_modified,
+            size: entry.data.len(),
+            e_tag: Some(e_tag),
+            version: None,
+        };
+        options.check_preconditions(&meta)?;
+
+        let (range, data) = match options.range {
+            Some(range) => {
+                let r = range.as_range(entry.data.len()).context(RangeSnafu)?;
+                (r.clone(), entry.data.slice(r))
+            }
+            None => (0..entry.data.len(), entry.data),
+        };
+        let stream = futures::stream::once(futures::future::ready(Ok(data)));
+
+        Ok(GetResult {
+            payload: GetResultPayload::Stream(stream.boxed()),
+            meta,
+            range,
+        })
     }
 
-    async fn get_ranges(
-        &self,
-        location: &Path,
-        ranges: &[Range<usize>],
-    ) -> Result<Vec<Bytes>> {
-        let data = self.get_bytes(location).await?;
+    async fn get_ranges(&self, location: &Path, ranges: &[Range<usize>]) -> Result<Vec<Bytes>> {
+        let entry = self.entry(location).await?;
         ranges
             .iter()
             .map(|range| {
-                ensure!(range.end <= data.len(), OutOfRangeSnafu);
-                ensure!(range.start <= range.end, BadRangeSnafu);
-                Ok(data.slice(range.clone()))
+                let r = GetRange::Bounded(range.clone())
+                    .as_range(entry.data.len())
+                    .context(RangeSnafu)?;
+
+                Ok(entry.data.slice(r))
             })
             .collect()
     }
 
     async fn head(&self, location: &Path) -> Result<ObjectMeta> {
-        let last_modified = Utc::now();
-        let bytes = self.get_bytes(location).await?;
+        let entry = self.entry(location).await?;
+
         Ok(ObjectMeta {
             location: location.clone(),
-            last_modified,
-            size: bytes.len(),
+            last_modified: entry.last_modified,
+            size: entry.data.len(),
+            e_tag: Some(entry.e_tag.to_string()),
+            version: None,
         })
     }
 
     async fn delete(&self, location: &Path) -> Result<()> {
-        self.storage.write().remove(location);
+        self.storage.write().map.remove(location);
         Ok(())
     }
 
-    async fn list(
-        &self,
-        prefix: Option<&Path>,
-    ) -> Result<BoxStream<'_, Result<ObjectMeta>>> {
-        let last_modified = Utc::now();
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        let root = Path::default();
+        let prefix = prefix.unwrap_or(&root);
 
         let storage = self.storage.read();
         let values: Vec<_> = storage
-            .iter()
-            .filter(move |(key, _)| prefix.map(|p| key.prefix_matches(p)).unwrap_or(true))
-            .map(move |(key, value)| {
+            .map
+            .range((prefix)..)
+            .take_while(|(key, _)| key.as_ref().starts_with(prefix.as_ref()))
+            .filter(|(key, _)| {
+                // Don't return for exact prefix match
+                key.prefix_match(prefix)
+                    .map(|mut x| x.next().is_some())
+                    .unwrap_or(false)
+            })
+            .map(|(key, value)| {
                 Ok(ObjectMeta {
                     location: key.clone(),
-                    last_modified,
-                    size: value.len(),
+                    last_modified: value.last_modified,
+                    size: value.data.len(),
+                    e_tag: Some(value.e_tag.to_string()),
+                    version: None,
                 })
             })
             .collect();
 
-        Ok(futures::stream::iter(values).boxed())
+        futures::stream::iter(values).boxed()
     }
 
     /// The memory implementation returns all results, as opposed to the cloud
@@ -189,20 +298,24 @@ impl ObjectStore for InMemory {
         let prefix = prefix.unwrap_or(&root);
 
         let mut common_prefixes = BTreeSet::new();
-        let last_modified = Utc::now();
 
         // Only objects in this base level should be returned in the
         // response. Otherwise, we just collect the common prefixes.
         let mut objects = vec![];
-        for (k, v) in self.storage.read().range((prefix)..) {
+        for (k, v) in self.storage.read().map.range((prefix)..) {
+            if !k.as_ref().starts_with(prefix.as_ref()) {
+                break;
+            }
+
             let mut parts = match k.prefix_match(prefix) {
                 Some(parts) => parts,
-                None => break,
+                None => continue,
             };
 
             // Pop first element
             let common_prefix = match parts.next() {
                 Some(p) => p,
+                // Should only return children of the prefix
                 None => continue,
             };
 
@@ -211,8 +324,10 @@ impl ObjectStore for InMemory {
             } else {
                 let object = ObjectMeta {
                     location: k.clone(),
-                    last_modified,
-                    size: v.len(),
+                    last_modified: v.last_modified,
+                    size: v.data.len(),
+                    e_tag: Some(v.e_tag.to_string()),
+                    version: None,
                 };
                 objects.push(object);
             }
@@ -225,21 +340,21 @@ impl ObjectStore for InMemory {
     }
 
     async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
-        let data = self.get_bytes(from).await?;
-        self.storage.write().insert(to.clone(), data);
+        let entry = self.entry(from).await?;
+        self.storage.write().insert(to, entry.data);
         Ok(())
     }
 
     async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
-        let data = self.get_bytes(from).await?;
+        let entry = self.entry(from).await?;
         let mut storage = self.storage.write();
-        if storage.contains_key(to) {
+        if storage.map.contains_key(to) {
             return Err(Error::AlreadyExists {
                 path: to.to_string(),
             }
             .into());
         }
-        storage.insert(to.clone(), data);
+        storage.insert(to, entry.data);
         Ok(())
     }
 }
@@ -250,32 +365,38 @@ impl InMemory {
         Self::default()
     }
 
-    /// Creates a clone of the store
-    pub async fn clone(&self) -> Self {
+    /// Creates a fork of the store, with the current content copied into the
+    /// new store.
+    pub fn fork(&self) -> Self {
         let storage = self.storage.read();
-        let storage = storage.clone();
+        let storage = Arc::new(RwLock::new(storage.clone()));
+        Self { storage }
+    }
 
-        Self {
-            storage: Arc::new(RwLock::new(storage)),
-        }
+    /// Creates a clone of the store
+    #[deprecated(note = "Use fork() instead")]
+    pub async fn clone(&self) -> Self {
+        self.fork()
     }
 
-    async fn get_bytes(&self, location: &Path) -> Result<Bytes> {
+    async fn entry(&self, location: &Path) -> Result<Entry> {
         let storage = self.storage.read();
-        let bytes = storage
+        let value = storage
+            .map
             .get(location)
             .cloned()
             .context(NoDataInMemorySnafu {
                 path: location.to_string(),
             })?;
-        Ok(bytes)
+
+        Ok(value)
     }
 }
 
 struct InMemoryUpload {
     location: Path,
     data: Vec<u8>,
-    storage: Arc<RwLock<BTreeMap<Path, Bytes>>>,
+    storage: Arc<RwLock<Storage>>,
 }
 
 impl AsyncWrite for InMemoryUpload {
@@ -283,7 +404,7 @@ impl AsyncWrite for InMemoryUpload {
         mut self: Pin<&mut Self>,
         _cx: &mut std::task::Context<'_>,
         buf: &[u8],
-    ) -> std::task::Poll<Result<usize, io::Error>> {
+    ) -> Poll<Result<usize, io::Error>> {
         self.data.extend_from_slice(buf);
         Poll::Ready(Ok(buf.len()))
     }
@@ -291,16 +412,16 @@ impl AsyncWrite for InMemoryUpload {
     fn poll_flush(
         self: Pin<&mut Self>,
         _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), io::Error>> {
+    ) -> Poll<Result<(), io::Error>> {
         Poll::Ready(Ok(()))
     }
 
     fn poll_shutdown(
         mut self: Pin<&mut Self>,
         _cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), io::Error>> {
+    ) -> Poll<Result<(), io::Error>> {
         let data = Bytes::from(std::mem::take(&mut self.data));
-        self.storage.write().insert(self.location.clone(), data);
+        self.storage.write().insert(&self.location, data);
         Poll::Ready(Ok(()))
     }
 }
@@ -309,19 +430,41 @@ impl AsyncWrite for InMemoryUpload {
 mod tests {
     use super::*;
 
-    use crate::{
-        tests::{
-            copy_if_not_exists, get_nonexistent_object, list_uses_directories_correctly,
-            list_with_delimiter, put_get_delete_list, rename_and_copy, stream_get,
-        },
-        Error as ObjectStoreError, ObjectStore,
-    };
+    use crate::tests::*;
 
     #[tokio::test]
     async fn in_memory_test() {
         let integration = InMemory::new();
 
         put_get_delete_list(&integration).await;
+        get_opts(&integration).await;
+        list_uses_directories_correctly(&integration).await;
+        list_with_delimiter(&integration).await;
+        rename_and_copy(&integration).await;
+        copy_if_not_exists(&integration).await;
+        stream_get(&integration).await;
+        put_opts(&integration, true).await;
+    }
+
+    #[tokio::test]
+    async fn box_test() {
+        let integration: Box<dyn ObjectStore> = Box::new(InMemory::new());
+
+        put_get_delete_list(&integration).await;
+        get_opts(&integration).await;
+        list_uses_directories_correctly(&integration).await;
+        list_with_delimiter(&integration).await;
+        rename_and_copy(&integration).await;
+        copy_if_not_exists(&integration).await;
+        stream_get(&integration).await;
+    }
+
+    #[tokio::test]
+    async fn arc_test() {
+        let integration: Arc<dyn ObjectStore> = Arc::new(InMemory::new());
+
+        put_get_delete_list(&integration).await;
+        get_opts(&integration).await;
         list_uses_directories_correctly(&integration).await;
         list_with_delimiter(&integration).await;
         rename_and_copy(&integration).await;
@@ -361,16 +504,15 @@ mod tests {
         let err = get_nonexistent_object(&integration, Some(location))
             .await
             .unwrap_err();
-        if let ObjectStoreError::NotFound { path, source } = err {
+        if let crate::Error::NotFound { path, source } = err {
             let source_variant = source.downcast_ref::<Error>();
             assert!(
                 matches!(source_variant, Some(Error::NoDataInMemory { .. }),),
-                "got: {:?}",
-                source_variant
+                "got: {source_variant:?}"
             );
             assert_eq!(path, NON_EXISTENT_NAME);
         } else {
-            panic!("unexpected error type: {:?}", err);
+            panic!("unexpected error type: {err:?}");
         }
     }
 }
diff --git a/object_store/src/multipart.rs b/object_store/src/multipart.rs
index c16022d3735b..1dcd5a6f4960 100644
--- a/object_store/src/multipart.rs
+++ b/object_store/src/multipart.rs
@@ -15,66 +15,70 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use futures::{future::BoxFuture, stream::FuturesUnordered, Future, StreamExt};
+//! Cloud Multipart Upload
+//!
+//! This crate provides an asynchronous interface for multipart file uploads to cloud storage services.
+//! It's designed to offer efficient, non-blocking operations,
+//! especially useful when dealing with large files or high-throughput systems.
+
+use async_trait::async_trait;
+use bytes::Bytes;
+use futures::{stream::FuturesUnordered, Future, StreamExt};
 use std::{io, pin::Pin, sync::Arc, task::Poll};
 use tokio::io::AsyncWrite;
 
-use crate::Result;
+use crate::path::Path;
+use crate::{MultipartId, PutResult, Result};
 
 type BoxedTryFuture<T> = Pin<Box<dyn Future<Output = Result<T, io::Error>> + Send>>;
 
-/// A trait that can be implemented by cloud-based object stores
-/// and used in combination with [`CloudMultiPartUpload`] to provide
-/// multipart upload support
-///
-/// Note: this does not use AsyncTrait as the lifetimes are difficult to manage
-pub(crate) trait CloudMultiPartUploadImpl {
+/// A trait used in combination with [`WriteMultiPart`] to implement
+/// [`AsyncWrite`] on top of an API for multipart upload
+#[async_trait]
+pub trait PutPart: Send + Sync + 'static {
     /// Upload a single part
-    fn put_multipart_part(
-        &self,
-        buf: Vec<u8>,
-        part_idx: usize,
-    ) -> BoxFuture<'static, Result<(usize, UploadPart), io::Error>>;
+    async fn put_part(&self, buf: Vec<u8>, part_idx: usize) -> Result<PartId>;
 
     /// Complete the upload with the provided parts
     ///
     /// `completed_parts` is in order of part number
-    fn complete(
-        &self,
-        completed_parts: Vec<Option<UploadPart>>,
-    ) -> BoxFuture<'static, Result<(), io::Error>>;
+    async fn complete(&self, completed_parts: Vec<PartId>) -> Result<()>;
 }
 
+/// Represents a part of a file that has been successfully uploaded in a multipart upload process.
 #[derive(Debug, Clone)]
-pub(crate) struct UploadPart {
+pub struct PartId {
+    /// Id of this part
     pub content_id: String,
 }
 
-pub(crate) struct CloudMultiPartUpload<T>
-where
-    T: CloudMultiPartUploadImpl,
-{
+/// Wrapper around a [`PutPart`] that implements [`AsyncWrite`]
+///
+/// Data will be uploaded in fixed size chunks of 10 MiB in parallel,
+/// up to the configured maximum concurrency
+pub struct WriteMultiPart<T: PutPart> {
     inner: Arc<T>,
     /// A list of completed parts, in sequential order.
-    completed_parts: Vec<Option<UploadPart>>,
+    completed_parts: Vec<Option<PartId>>,
     /// Part upload tasks currently running
-    tasks: FuturesUnordered<BoxedTryFuture<(usize, UploadPart)>>,
+    tasks: FuturesUnordered<BoxedTryFuture<(usize, PartId)>>,
     /// Maximum number of upload tasks to run concurrently
     max_concurrency: usize,
     /// Buffer that will be sent in next upload.
     current_buffer: Vec<u8>,
-    /// Minimum size of a part in bytes
-    min_part_size: usize,
+    /// Size of each part.
+    ///
+    /// While S3 and Minio support variable part sizes, R2 requires they all be
+    /// exactly the same size.
+    part_size: usize,
     /// Index of current part
     current_part_idx: usize,
     /// The completion task
     completion_task: Option<BoxedTryFuture<()>>,
 }
 
-impl<T> CloudMultiPartUpload<T>
-where
-    T: CloudMultiPartUploadImpl,
-{
+impl<T: PutPart> WriteMultiPart<T> {
+    /// Create a new multipart upload with the implementation and the given maximum concurrency
     pub fn new(inner: T, max_concurrency: usize) -> Self {
         Self {
             inner: Arc::new(inner),
@@ -84,89 +88,130 @@ where
             current_buffer: Vec::new(),
             // TODO: Should self vary by provider?
             // TODO: Should we automatically increase then when part index gets large?
-            min_part_size: 5_000_000,
+
+            // Minimum size of 5 MiB
+            // https://docs.aws.amazon.com/AmazonS3/latest/userguide/qfacts.html
+            // https://cloud.google.com/storage/quotas#requests
+            part_size: 10 * 1024 * 1024,
             current_part_idx: 0,
             completion_task: None,
         }
     }
 
-    pub fn poll_tasks(
+    // Add data to the current buffer, returning the number of bytes added
+    fn add_to_buffer(mut self: Pin<&mut Self>, buf: &[u8], offset: usize) -> usize {
+        let remaining_capacity = self.part_size - self.current_buffer.len();
+        let to_copy = std::cmp::min(remaining_capacity, buf.len() - offset);
+        self.current_buffer
+            .extend_from_slice(&buf[offset..offset + to_copy]);
+        to_copy
+    }
+
+    /// Poll current tasks
+    fn poll_tasks(
         mut self: Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
     ) -> Result<(), io::Error> {
         if self.tasks.is_empty() {
             return Ok(());
         }
-        let total_parts = self.completed_parts.len();
         while let Poll::Ready(Some(res)) = self.tasks.poll_next_unpin(cx) {
             let (part_idx, part) = res?;
+            let total_parts = self.completed_parts.len();
             self.completed_parts
                 .resize(std::cmp::max(part_idx + 1, total_parts), None);
             self.completed_parts[part_idx] = Some(part);
         }
         Ok(())
     }
+
+    // The `poll_flush` function will only flush the in-progress tasks.
+    // The `final_flush` method called during `poll_shutdown` will flush
+    // the `current_buffer` along with in-progress tasks.
+    // Please see https://github.com/apache/arrow-rs/issues/3390 for more details.
+    fn final_flush(
+        mut self: Pin<&mut Self>,
+        cx: &mut std::task::Context<'_>,
+    ) -> Poll<Result<(), io::Error>> {
+        // Poll current tasks
+        self.as_mut().poll_tasks(cx)?;
+
+        // If current_buffer is not empty, see if it can be submitted
+        if !self.current_buffer.is_empty() && self.tasks.len() < self.max_concurrency {
+            let out_buffer: Vec<u8> = std::mem::take(&mut self.current_buffer);
+            let inner = Arc::clone(&self.inner);
+            let part_idx = self.current_part_idx;
+            self.tasks.push(Box::pin(async move {
+                let upload_part = inner.put_part(out_buffer, part_idx).await?;
+                Ok((part_idx, upload_part))
+            }));
+        }
+
+        self.as_mut().poll_tasks(cx)?;
+
+        // If tasks and current_buffer are empty, return Ready
+        if self.tasks.is_empty() && self.current_buffer.is_empty() {
+            Poll::Ready(Ok(()))
+        } else {
+            Poll::Pending
+        }
+    }
 }
 
-impl<T> AsyncWrite for CloudMultiPartUpload<T>
-where
-    T: CloudMultiPartUploadImpl + Send + Sync,
-{
+impl<T: PutPart> AsyncWrite for WriteMultiPart<T> {
     fn poll_write(
         mut self: Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
         buf: &[u8],
-    ) -> std::task::Poll<Result<usize, io::Error>> {
+    ) -> Poll<Result<usize, io::Error>> {
         // Poll current tasks
         self.as_mut().poll_tasks(cx)?;
 
-        // If adding buf to pending buffer would trigger send, check
-        // whether we have capacity for another task.
-        let enough_to_send = (buf.len() + self.current_buffer.len()) > self.min_part_size;
-        if enough_to_send && self.tasks.len() < self.max_concurrency {
-            // If we do, copy into the buffer and submit the task, and return ready.
-            self.current_buffer.extend_from_slice(buf);
-
-            let out_buffer = std::mem::take(&mut self.current_buffer);
-            let task = self
-                .inner
-                .put_multipart_part(out_buffer, self.current_part_idx);
-            self.tasks.push(task);
+        let mut offset = 0;
+
+        loop {
+            // Fill up current buffer
+            offset += self.as_mut().add_to_buffer(buf, offset);
+
+            // If we don't have a full buffer or we have too many tasks, break
+            if self.current_buffer.len() < self.part_size
+                || self.tasks.len() >= self.max_concurrency
+            {
+                break;
+            }
+
+            let new_buffer = Vec::with_capacity(self.part_size);
+            let out_buffer = std::mem::replace(&mut self.current_buffer, new_buffer);
+            let inner = Arc::clone(&self.inner);
+            let part_idx = self.current_part_idx;
+            self.tasks.push(Box::pin(async move {
+                let upload_part = inner.put_part(out_buffer, part_idx).await?;
+                Ok((part_idx, upload_part))
+            }));
             self.current_part_idx += 1;
 
             // We need to poll immediately after adding to setup waker
             self.as_mut().poll_tasks(cx)?;
+        }
 
-            Poll::Ready(Ok(buf.len()))
-        } else if !enough_to_send {
-            self.current_buffer.extend_from_slice(buf);
-            Poll::Ready(Ok(buf.len()))
-        } else {
-            // Waker registered by call to poll_tasks at beginning
+        // If offset is zero, then we didn't write anything because we didn't
+        // have capacity for more tasks and our buffer is full.
+        if offset == 0 && !buf.is_empty() {
             Poll::Pending
+        } else {
+            Poll::Ready(Ok(offset))
         }
     }
 
     fn poll_flush(
         mut self: Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), io::Error>> {
+    ) -> Poll<Result<(), io::Error>> {
         // Poll current tasks
         self.as_mut().poll_tasks(cx)?;
 
-        // If current_buffer is not empty, see if it can be submitted
-        if !self.current_buffer.is_empty() && self.tasks.len() < self.max_concurrency {
-            let out_buffer: Vec<u8> = std::mem::take(&mut self.current_buffer);
-            let task = self
-                .inner
-                .put_multipart_part(out_buffer, self.current_part_idx);
-            self.tasks.push(task);
-        }
-
-        self.as_mut().poll_tasks(cx)?;
-
-        // If tasks and current_buffer are empty, return Ready
-        if self.tasks.is_empty() && self.current_buffer.is_empty() {
+        // If tasks is empty, return Ready
+        if self.tasks.is_empty() {
             Poll::Ready(Ok(()))
         } else {
             Poll::Pending
@@ -176,20 +221,98 @@ where
     fn poll_shutdown(
         mut self: Pin<&mut Self>,
         cx: &mut std::task::Context<'_>,
-    ) -> std::task::Poll<Result<(), io::Error>> {
+    ) -> Poll<Result<(), io::Error>> {
         // First, poll flush
-        match self.as_mut().poll_flush(cx) {
+        match self.as_mut().final_flush(cx) {
             Poll::Pending => return Poll::Pending,
             Poll::Ready(res) => res?,
         };
 
         // If shutdown task is not set, set it
         let parts = std::mem::take(&mut self.completed_parts);
+        let parts = parts
+            .into_iter()
+            .enumerate()
+            .map(|(idx, part)| {
+                part.ok_or_else(|| {
+                    io::Error::new(
+                        io::ErrorKind::Other,
+                        format!("Missing information for upload part {idx}"),
+                    )
+                })
+            })
+            .collect::<Result<_, _>>()?;
+
         let inner = Arc::clone(&self.inner);
-        let completion_task = self
-            .completion_task
-            .get_or_insert_with(|| inner.complete(parts));
+        let completion_task = self.completion_task.get_or_insert_with(|| {
+            Box::pin(async move {
+                inner.complete(parts).await?;
+                Ok(())
+            })
+        });
 
         Pin::new(completion_task).poll(cx)
     }
 }
+
+impl<T: PutPart> std::fmt::Debug for WriteMultiPart<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("WriteMultiPart")
+            .field("completed_parts", &self.completed_parts)
+            .field("tasks", &self.tasks)
+            .field("max_concurrency", &self.max_concurrency)
+            .field("current_buffer", &self.current_buffer)
+            .field("part_size", &self.part_size)
+            .field("current_part_idx", &self.current_part_idx)
+            .finish()
+    }
+}
+
+/// A low-level interface for interacting with multipart upload APIs
+///
+/// Most use-cases should prefer [`ObjectStore::put_multipart`] as this is supported by more
+/// backends, including [`LocalFileSystem`], and automatically handles uploading fixed
+/// size parts of sufficient size in parallel
+///
+/// [`ObjectStore::put_multipart`]: crate::ObjectStore::put_multipart
+/// [`LocalFileSystem`]: crate::local::LocalFileSystem
+#[async_trait]
+pub trait MultiPartStore: Send + Sync + 'static {
+    /// Creates a new multipart upload, returning the [`MultipartId`]
+    async fn create_multipart(&self, path: &Path) -> Result<MultipartId>;
+
+    /// Uploads a new part with index `part_idx`
+    ///
+    /// `part_idx` should be an integer in the range `0..N` where `N` is the number of
+    /// parts in the upload. Parts may be uploaded concurrently and in any order.
+    ///
+    /// Most stores require that all parts excluding the last are at least 5 MiB, and some
+    /// further require that all parts excluding the last be the same size, e.g. [R2].
+    /// [`WriteMultiPart`] performs writes in fixed size blocks of 10 MiB, and clients wanting
+    /// to maximise compatibility should look to do likewise.
+    ///
+    /// [R2]: https://developers.cloudflare.com/r2/objects/multipart-objects/#limitations
+    async fn put_part(
+        &self,
+        path: &Path,
+        id: &MultipartId,
+        part_idx: usize,
+        data: Bytes,
+    ) -> Result<PartId>;
+
+    /// Completes a multipart upload
+    ///
+    /// The `i`'th value of `parts` must be a [`PartId`] returned by a call to [`Self::put_part`]
+    /// with a `part_idx` of `i`, and the same `path` and `id` as provided to this method. Calling
+    /// this method with out of sequence or repeated [`PartId`], or [`PartId`] returned for other
+    /// values of `path` or `id`, will result in implementation-defined behaviour
+    async fn complete_multipart(
+        &self,
+        path: &Path,
+        id: &MultipartId,
+        parts: Vec<PartId>,
+    ) -> Result<PutResult>;
+
+    /// Aborts a multipart upload
+    async fn abort_multipart(&self, path: &Path, id: &MultipartId) -> Result<()>;
+}
diff --git a/object_store/src/parse.rs b/object_store/src/parse.rs
new file mode 100644
index 000000000000..116c2ad2ac0e
--- /dev/null
+++ b/object_store/src/parse.rs
@@ -0,0 +1,333 @@
+// 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.
+
+#[cfg(not(target_arch = "wasm32"))]
+use crate::local::LocalFileSystem;
+use crate::memory::InMemory;
+use crate::path::Path;
+use crate::ObjectStore;
+use snafu::Snafu;
+use url::Url;
+
+#[derive(Debug, Snafu)]
+enum Error {
+    #[snafu(display("Unable to convert URL \"{}\" to filesystem path", url))]
+    InvalidUrl { url: Url },
+
+    #[snafu(display("Unable to recognise URL \"{}\"", url))]
+    Unrecognised { url: Url },
+
+    #[snafu(display("Feature {scheme:?} not enabled"))]
+    NotEnabled { scheme: ObjectStoreScheme },
+
+    #[snafu(context(false))]
+    Path { source: crate::path::Error },
+}
+
+impl From<Error> for super::Error {
+    fn from(e: Error) -> Self {
+        Self::Generic {
+            store: "URL",
+            source: Box::new(e),
+        }
+    }
+}
+
+/// Recognises various URL formats, identifying the relevant [`ObjectStore`]
+#[derive(Debug, Eq, PartialEq)]
+enum ObjectStoreScheme {
+    /// Url corresponding to [`LocalFileSystem`]
+    Local,
+    /// Url corresponding to [`InMemory`]
+    Memory,
+    /// Url corresponding to [`AmazonS3`](crate::aws::AmazonS3)
+    AmazonS3,
+    /// Url corresponding to [`GoogleCloudStorage`](crate::gcp::GoogleCloudStorage)
+    GoogleCloudStorage,
+    /// Url corresponding to [`MicrosoftAzure`](crate::azure::MicrosoftAzure)
+    MicrosoftAzure,
+    /// Url corresponding to [`HttpStore`](crate::http::HttpStore)
+    Http,
+}
+
+impl ObjectStoreScheme {
+    /// Create an [`ObjectStoreScheme`] from the provided [`Url`]
+    ///
+    /// Returns the [`ObjectStoreScheme`] and the remaining [`Path`]
+    fn parse(url: &Url) -> Result<(Self, Path), Error> {
+        let strip_bucket = || Some(url.path().strip_prefix('/')?.split_once('/')?.1);
+
+        let (scheme, path) = match (url.scheme(), url.host_str()) {
+            ("file", None) => (Self::Local, url.path()),
+            ("memory", None) => (Self::Memory, url.path()),
+            ("s3" | "s3a", Some(_)) => (Self::AmazonS3, url.path()),
+            ("gs", Some(_)) => (Self::GoogleCloudStorage, url.path()),
+            ("az" | "adl" | "azure" | "abfs" | "abfss", Some(_)) => {
+                (Self::MicrosoftAzure, url.path())
+            }
+            ("http", Some(_)) => (Self::Http, url.path()),
+            ("https", Some(host)) => {
+                if host.ends_with("dfs.core.windows.net")
+                    || host.ends_with("blob.core.windows.net")
+                    || host.ends_with("dfs.fabric.microsoft.com")
+                    || host.ends_with("blob.fabric.microsoft.com")
+                {
+                    (Self::MicrosoftAzure, url.path())
+                } else if host.ends_with("amazonaws.com") {
+                    match host.starts_with("s3") {
+                        true => (Self::AmazonS3, strip_bucket().unwrap_or_default()),
+                        false => (Self::AmazonS3, url.path()),
+                    }
+                } else if host.ends_with("r2.cloudflarestorage.com") {
+                    (Self::AmazonS3, strip_bucket().unwrap_or_default())
+                } else {
+                    (Self::Http, url.path())
+                }
+            }
+            _ => return Err(Error::Unrecognised { url: url.clone() }),
+        };
+
+        Ok((scheme, Path::from_url_path(path)?))
+    }
+}
+
+#[cfg(feature = "cloud")]
+macro_rules! builder_opts {
+    ($builder:ty, $url:expr, $options:expr) => {{
+        let builder = $options.into_iter().fold(
+            <$builder>::new().with_url($url.to_string()),
+            |builder, (key, value)| match key.as_ref().parse() {
+                Ok(k) => builder.with_config(k, value),
+                Err(_) => builder,
+            },
+        );
+        Box::new(builder.build()?) as _
+    }};
+}
+
+/// Create an [`ObjectStore`] based on the provided `url`
+///
+/// Returns
+/// - An [`ObjectStore`] of the corresponding type
+/// - The [`Path`] into the [`ObjectStore`] of the addressed resource
+pub fn parse_url(url: &Url) -> Result<(Box<dyn ObjectStore>, Path), super::Error> {
+    parse_url_opts(url, std::iter::empty::<(&str, &str)>())
+}
+
+/// Create an [`ObjectStore`] based on the provided `url` and options
+///
+/// Returns
+/// - An [`ObjectStore`] of the corresponding type
+/// - The [`Path`] into the [`ObjectStore`] of the addressed resource
+pub fn parse_url_opts<I, K, V>(
+    url: &Url,
+    options: I,
+) -> Result<(Box<dyn ObjectStore>, Path), super::Error>
+where
+    I: IntoIterator<Item = (K, V)>,
+    K: AsRef<str>,
+    V: Into<String>,
+{
+    let _options = options;
+    let (scheme, path) = ObjectStoreScheme::parse(url)?;
+    let path = Path::parse(path)?;
+
+    let store = match scheme {
+        #[cfg(not(target_arch = "wasm32"))]
+        ObjectStoreScheme::Local => Box::new(LocalFileSystem::new()) as _,
+        ObjectStoreScheme::Memory => Box::new(InMemory::new()) as _,
+        #[cfg(feature = "aws")]
+        ObjectStoreScheme::AmazonS3 => {
+            builder_opts!(crate::aws::AmazonS3Builder, url, _options)
+        }
+        #[cfg(feature = "gcp")]
+        ObjectStoreScheme::GoogleCloudStorage => {
+            builder_opts!(crate::gcp::GoogleCloudStorageBuilder, url, _options)
+        }
+        #[cfg(feature = "azure")]
+        ObjectStoreScheme::MicrosoftAzure => {
+            builder_opts!(crate::azure::MicrosoftAzureBuilder, url, _options)
+        }
+        #[cfg(feature = "http")]
+        ObjectStoreScheme::Http => {
+            let url = &url[..url::Position::BeforePath];
+            builder_opts!(crate::http::HttpBuilder, url, _options)
+        }
+        #[cfg(not(all(feature = "aws", feature = "azure", feature = "gcp", feature = "http")))]
+        s => {
+            return Err(super::Error::Generic {
+                store: "parse_url",
+                source: format!("feature for {s:?} not enabled").into(),
+            })
+        }
+    };
+
+    Ok((store, path))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_parse() {
+        let cases = [
+            ("file:/path", (ObjectStoreScheme::Local, "path")),
+            ("file:///path", (ObjectStoreScheme::Local, "path")),
+            ("memory:/path", (ObjectStoreScheme::Memory, "path")),
+            ("memory:///", (ObjectStoreScheme::Memory, "")),
+            ("s3://bucket/path", (ObjectStoreScheme::AmazonS3, "path")),
+            ("s3a://bucket/path", (ObjectStoreScheme::AmazonS3, "path")),
+            (
+                "https://s3.region.amazonaws.com/bucket",
+                (ObjectStoreScheme::AmazonS3, ""),
+            ),
+            (
+                "https://s3.region.amazonaws.com/bucket/path",
+                (ObjectStoreScheme::AmazonS3, "path"),
+            ),
+            (
+                "https://bucket.s3.region.amazonaws.com",
+                (ObjectStoreScheme::AmazonS3, ""),
+            ),
+            (
+                "https://ACCOUNT_ID.r2.cloudflarestorage.com/bucket",
+                (ObjectStoreScheme::AmazonS3, ""),
+            ),
+            (
+                "https://ACCOUNT_ID.r2.cloudflarestorage.com/bucket/path",
+                (ObjectStoreScheme::AmazonS3, "path"),
+            ),
+            (
+                "abfs://container/path",
+                (ObjectStoreScheme::MicrosoftAzure, "path"),
+            ),
+            (
+                "abfs://file_system@account_name.dfs.core.windows.net/path",
+                (ObjectStoreScheme::MicrosoftAzure, "path"),
+            ),
+            (
+                "abfss://file_system@account_name.dfs.core.windows.net/path",
+                (ObjectStoreScheme::MicrosoftAzure, "path"),
+            ),
+            (
+                "https://account.dfs.core.windows.net",
+                (ObjectStoreScheme::MicrosoftAzure, ""),
+            ),
+            (
+                "https://account.blob.core.windows.net",
+                (ObjectStoreScheme::MicrosoftAzure, ""),
+            ),
+            (
+                "gs://bucket/path",
+                (ObjectStoreScheme::GoogleCloudStorage, "path"),
+            ),
+            (
+                "gs://test.example.com/path",
+                (ObjectStoreScheme::GoogleCloudStorage, "path"),
+            ),
+            ("http://mydomain/path", (ObjectStoreScheme::Http, "path")),
+            ("https://mydomain/path", (ObjectStoreScheme::Http, "path")),
+            (
+                "s3://bucket/foo%20bar",
+                (ObjectStoreScheme::AmazonS3, "foo bar"),
+            ),
+            (
+                "https://foo/bar%20baz",
+                (ObjectStoreScheme::Http, "bar baz"),
+            ),
+            (
+                "file:///bar%252Efoo",
+                (ObjectStoreScheme::Local, "bar%2Efoo"),
+            ),
+            (
+                "abfss://file_system@account.dfs.fabric.microsoft.com/",
+                (ObjectStoreScheme::MicrosoftAzure, ""),
+            ),
+            (
+                "abfss://file_system@account.dfs.fabric.microsoft.com/",
+                (ObjectStoreScheme::MicrosoftAzure, ""),
+            ),
+            (
+                "https://account.dfs.fabric.microsoft.com/",
+                (ObjectStoreScheme::MicrosoftAzure, ""),
+            ),
+            (
+                "https://account.dfs.fabric.microsoft.com/container",
+                (ObjectStoreScheme::MicrosoftAzure, "container"),
+            ),
+            (
+                "https://account.blob.fabric.microsoft.com/",
+                (ObjectStoreScheme::MicrosoftAzure, ""),
+            ),
+            (
+                "https://account.blob.fabric.microsoft.com/container",
+                (ObjectStoreScheme::MicrosoftAzure, "container"),
+            ),
+        ];
+
+        for (s, (expected_scheme, expected_path)) in cases {
+            let url = Url::parse(s).unwrap();
+            let (scheme, path) = ObjectStoreScheme::parse(&url).unwrap();
+
+            assert_eq!(scheme, expected_scheme, "{s}");
+            assert_eq!(path, Path::parse(expected_path).unwrap(), "{s}");
+        }
+
+        let neg_cases = [
+            "unix:/run/foo.socket",
+            "file://remote/path",
+            "memory://remote/",
+        ];
+        for s in neg_cases {
+            let url = Url::parse(s).unwrap();
+            assert!(ObjectStoreScheme::parse(&url).is_err());
+        }
+    }
+
+    #[test]
+    fn test_url_spaces() {
+        let url = Url::parse("file:///my file with spaces").unwrap();
+        assert_eq!(url.path(), "/my%20file%20with%20spaces");
+        let (_, path) = parse_url(&url).unwrap();
+        assert_eq!(path.as_ref(), "my file with spaces");
+    }
+
+    #[tokio::test]
+    #[cfg(feature = "http")]
+    async fn test_url_http() {
+        use crate::client::mock_server::MockServer;
+        use hyper::{header::USER_AGENT, Body, Response};
+
+        let server = MockServer::new();
+
+        server.push_fn(|r| {
+            assert_eq!(r.uri().path(), "/foo/bar");
+            assert_eq!(r.headers().get(USER_AGENT).unwrap(), "test_url");
+            Response::new(Body::empty())
+        });
+
+        let test = format!("{}/foo/bar", server.url());
+        let opts = [("user_agent", "test_url"), ("allow_http", "true")];
+        let url = test.parse().unwrap();
+        let (store, path) = parse_url_opts(&url, opts).unwrap();
+        assert_eq!(path.as_ref(), "foo/bar");
+        store.get(&path).await.unwrap();
+
+        server.shutdown().await;
+    }
+}
diff --git a/object_store/src/path/mod.rs b/object_store/src/path/mod.rs
index e5a7b6443bb1..f914862bc53d 100644
--- a/object_store/src/path/mod.rs
+++ b/object_store/src/path/mod.rs
@@ -21,6 +21,7 @@ use itertools::Itertools;
 use percent_encoding::percent_decode;
 use snafu::{ensure, ResultExt, Snafu};
 use std::fmt::Formatter;
+#[cfg(not(target_arch = "wasm32"))]
 use url::Url;
 
 /// The delimiter to separate object namespaces, creating a directory structure.
@@ -64,10 +65,23 @@ pub enum Error {
 
 /// A parsed path representation that can be safely written to object storage
 ///
-/// # Path Safety
+/// A [`Path`] maintains the following invariants:
+///
+/// * Paths are delimited by `/`
+/// * Paths do not contain leading or trailing `/`
+/// * Paths do not contain relative path segments, i.e. `.` or `..`
+/// * Paths do not contain empty path segments
+/// * Paths do not contain any ASCII control characters
+///
+/// There are no enforced restrictions on path length, however, it should be noted that most
+/// object stores do not permit paths longer than 1024 bytes, and many filesystems do not
+/// support path segments longer than 255 bytes.
+///
+/// # Encode
 ///
 /// In theory object stores support any UTF-8 character sequence, however, certain character
-/// sequences cause compatibility problems with some applications and protocols. As such the
+/// sequences cause compatibility problems with some applications and protocols. Additionally
+/// some filesystems may impose character restrictions, see [`LocalFileSystem`]. As such the
 /// naming guidelines for [S3], [GCS] and [Azure Blob Storage] all recommend sticking to a
 /// limited character subset.
 ///
@@ -75,34 +89,16 @@ pub enum Error {
 /// [GCS]: https://cloud.google.com/storage/docs/naming-objects
 /// [Azure Blob Storage]: https://docs.microsoft.com/en-us/rest/api/storageservices/Naming-and-Referencing-Containers--Blobs--and-Metadata#blob-names
 ///
-/// This presents libraries with two options for consistent path handling:
-///
-/// 1. Allow constructing unsafe paths, allowing for both reading and writing of data to paths
-/// that may not be consistently understood or supported
-/// 2. Disallow constructing unsafe paths, ensuring data written can be consistently handled by
-/// all other systems, but preventing interaction with objects at unsafe paths
-///
-/// This library takes the second approach, in particular:
-///
-/// * Paths are delimited by `/`
-/// * Paths do not start with a `/`
-/// * Empty path segments are discarded (e.g. `//` is treated as though it were `/`)
-/// * Relative path segments, i.e. `.` and `..` are percent encoded
-/// * Unsafe characters are percent encoded, as described by [RFC 1738]
-/// * All paths are relative to the root of the object store
-///
-/// In order to provide these guarantees there are two ways to safely construct a [`Path`]
-///
-/// # Encode
-///
-/// A string containing potentially illegal path segments can be encoded to a [`Path`]
-/// using [`Path::from`] or [`Path::from_iter`].
+/// A string containing potentially problematic path segments can therefore be encoded to a [`Path`]
+/// using [`Path::from`] or [`Path::from_iter`]. This will percent encode any problematic
+/// segments according to [RFC 1738].
 ///
 /// ```
 /// # use object_store::path::Path;
 /// assert_eq!(Path::from("foo/bar").as_ref(), "foo/bar");
 /// assert_eq!(Path::from("foo//bar").as_ref(), "foo/bar");
 /// assert_eq!(Path::from("foo/../bar").as_ref(), "foo/%2E%2E/bar");
+/// assert_eq!(Path::from("/").as_ref(), "");
 /// assert_eq!(Path::from_iter(["foo", "foo/bar"]).as_ref(), "foo/foo%2Fbar");
 /// ```
 ///
@@ -115,20 +111,20 @@ pub enum Error {
 ///
 /// # Parse
 ///
-/// Alternatively a [`Path`] can be created from an existing string, returning an
-/// error if it is invalid. Unlike the encoding methods, this will permit
-/// valid percent encoded sequences.
+/// Alternatively a [`Path`] can be parsed from an existing string, returning an
+/// error if it is invalid. Unlike the encoding methods above, this will permit
+/// arbitrary unicode, including percent encoded sequences.
 ///
 /// ```
 /// # use object_store::path::Path;
-///
 /// assert_eq!(Path::parse("/foo/foo%2Fbar").unwrap().as_ref(), "foo/foo%2Fbar");
-/// Path::parse("..").unwrap_err();
-/// Path::parse("/foo//").unwrap_err();
-/// Path::parse("😀").unwrap_err();
+/// Path::parse("..").unwrap_err(); // Relative path segments are disallowed
+/// Path::parse("/foo//").unwrap_err(); // Empty path segments are disallowed
+/// Path::parse("\x00").unwrap_err(); // ASCII control characters are disallowed
 /// ```
 ///
 /// [RFC 1738]: https://www.ietf.org/rfc/rfc1738.txt
+/// [`LocalFileSystem`]: crate::local::LocalFileSystem
 #[derive(Debug, Clone, Default, PartialEq, Eq, Hash, Ord, PartialOrd)]
 pub struct Path {
     /// The raw path with no leading or trailing delimiters
@@ -160,15 +156,14 @@ impl Path {
         })
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
     /// Convert a filesystem path to a [`Path`] relative to the filesystem root
     ///
     /// This will return an error if the path contains illegal character sequences
-    /// as defined by [`Path::parse`] or does not exist
+    /// as defined on the docstring for [`Path`] or does not exist
     ///
     /// Note: this will canonicalize the provided path, resolving any symlinks
-    pub fn from_filesystem_path(
-        path: impl AsRef<std::path::Path>,
-    ) -> Result<Self, Error> {
+    pub fn from_filesystem_path(path: impl AsRef<std::path::Path>) -> Result<Self, Error> {
         let absolute = std::fs::canonicalize(&path).context(CanonicalizeSnafu {
             path: path.as_ref(),
         })?;
@@ -176,35 +171,48 @@ impl Path {
         Self::from_absolute_path(absolute)
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
     /// Convert an absolute filesystem path to a [`Path`] relative to the filesystem root
     ///
-    /// This will return an error if the path contains illegal character sequences
-    /// as defined by [`Path::parse`], or `base` is not an absolute path
+    /// This will return an error if the path contains illegal character sequences,
+    /// as defined on the docstring for [`Path`], or `base` is not an absolute path
     pub fn from_absolute_path(path: impl AsRef<std::path::Path>) -> Result<Self, Error> {
         Self::from_absolute_path_with_base(path, None)
     }
 
+    #[cfg(not(target_arch = "wasm32"))]
     /// Convert a filesystem path to a [`Path`] relative to the provided base
     ///
-    /// This will return an error if the path contains illegal character sequences
-    /// as defined by [`Path::parse`], or `base` does not refer to a parent path of `path`,
-    /// or `base` is not an absolute path
+    /// This will return an error if the path contains illegal character sequences,
+    /// as defined on the docstring for [`Path`], or `base` does not refer to a parent
+    /// path of `path`, or `base` is not an absolute path
     pub(crate) fn from_absolute_path_with_base(
         path: impl AsRef<std::path::Path>,
         base: Option<&Url>,
     ) -> Result<Self, Error> {
         let url = absolute_path_to_url(path)?;
         let path = match base {
-            Some(prefix) => url.path().strip_prefix(prefix.path()).ok_or_else(|| {
-                Error::PrefixMismatch {
-                    path: url.path().to_string(),
-                    prefix: prefix.to_string(),
-                }
-            })?,
+            Some(prefix) => {
+                url.path()
+                    .strip_prefix(prefix.path())
+                    .ok_or_else(|| Error::PrefixMismatch {
+                        path: url.path().to_string(),
+                        prefix: prefix.to_string(),
+                    })?
+            }
             None => url.path(),
         };
 
         // Reverse any percent encoding performed by conversion to URL
+        Self::from_url_path(path)
+    }
+
+    /// Parse a url encoded string as a [`Path`], returning a [`Error`] if invalid
+    ///
+    /// This will return an error if the path contains illegal character sequences
+    /// as defined on the docstring for [`Path`]
+    pub fn from_url_path(path: impl AsRef<str>) -> Result<Self, Error> {
+        let path = path.as_ref();
         let decoded = percent_decode(path.as_bytes())
             .decode_utf8()
             .context(NonUnicodeSnafu { path })?;
@@ -214,37 +222,44 @@ impl Path {
 
     /// Returns the [`PathPart`] of this [`Path`]
     pub fn parts(&self) -> impl Iterator<Item = PathPart<'_>> {
+        self.raw
+            .split_terminator(DELIMITER)
+            .map(|s| PathPart { raw: s.into() })
+    }
+
+    /// Returns the last path segment containing the filename stored in this [`Path`]
+    pub fn filename(&self) -> Option<&str> {
         match self.raw.is_empty() {
-            true => itertools::Either::Left(std::iter::empty()),
-            false => itertools::Either::Right(
-                self.raw
-                    .split(DELIMITER)
-                    .map(|s| PathPart { raw: s.into() }),
-            ),
+            true => None,
+            false => self.raw.rsplit(DELIMITER).next(),
         }
     }
 
+    /// Returns the extension of the file stored in this [`Path`], if any
+    pub fn extension(&self) -> Option<&str> {
+        self.filename()
+            .and_then(|f| f.rsplit_once('.'))
+            .and_then(|(_, extension)| {
+                if extension.is_empty() {
+                    None
+                } else {
+                    Some(extension)
+                }
+            })
+    }
+
     /// Returns an iterator of the [`PathPart`] of this [`Path`] after `prefix`
     ///
     /// Returns `None` if the prefix does not match
-    pub fn prefix_match(
-        &self,
-        prefix: &Self,
-    ) -> Option<impl Iterator<Item = PathPart<'_>> + '_> {
-        let diff = itertools::diff_with(self.parts(), prefix.parts(), |a, b| a == b);
-
-        match diff {
-            // Both were equal
-            None => Some(itertools::Either::Left(std::iter::empty())),
-            // Mismatch or prefix was longer => None
-            Some(
-                itertools::Diff::FirstMismatch(_, _, _) | itertools::Diff::Longer(_, _),
-            ) => None,
-            // Match with remaining
-            Some(itertools::Diff::Shorter(_, back)) => {
-                Some(itertools::Either::Right(back))
-            }
+    pub fn prefix_match(&self, prefix: &Self) -> Option<impl Iterator<Item = PathPart<'_>> + '_> {
+        let mut stripped = self.raw.strip_prefix(&prefix.raw)?;
+        if !stripped.is_empty() && !prefix.raw.is_empty() {
+            stripped = stripped.strip_prefix(DELIMITER)?;
         }
+        let iter = stripped
+            .split_terminator(DELIMITER)
+            .map(|x| PathPart { raw: x.into() });
+        Some(iter)
     }
 
     /// Returns true if this [`Path`] starts with `prefix`
@@ -308,10 +323,9 @@ where
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 /// Given an absolute filesystem path convert it to a URL representation without canonicalization
-pub(crate) fn absolute_path_to_url(
-    path: impl AsRef<std::path::Path>,
-) -> Result<Url, Error> {
+pub(crate) fn absolute_path_to_url(path: impl AsRef<std::path::Path>) -> Result<Url, Error> {
     Url::from_file_path(&path).map_err(|_| Error::InvalidPath {
         path: path.as_ref().into(),
     })
@@ -414,92 +428,74 @@ mod tests {
         assert!(existing_path.prefix_match(&prefix).is_none());
 
         // Prefix matches but there aren't any parts after it
-        let existing_path = Path::from("apple/bear/cow/dog");
+        let existing = Path::from("apple/bear/cow/dog");
 
-        let prefix = existing_path.clone();
-        assert_eq!(existing_path.prefix_match(&prefix).unwrap().count(), 0);
+        assert_eq!(existing.prefix_match(&existing).unwrap().count(), 0);
+        assert_eq!(Path::default().parts().count(), 0);
     }
 
     #[test]
     fn prefix_matches() {
         let haystack = Path::from_iter(["foo/bar", "baz%2Ftest", "something"]);
-        let needle = haystack.clone();
         // self starts with self
         assert!(
             haystack.prefix_matches(&haystack),
-            "{:?} should have started with {:?}",
-            haystack,
-            haystack
+            "{haystack:?} should have started with {haystack:?}"
         );
 
         // a longer prefix doesn't match
-        let needle = needle.child("longer now");
+        let needle = haystack.child("longer now");
         assert!(
             !haystack.prefix_matches(&needle),
-            "{:?} shouldn't have started with {:?}",
-            haystack,
-            needle
+            "{haystack:?} shouldn't have started with {needle:?}"
         );
 
         // one dir prefix matches
         let needle = Path::from_iter(["foo/bar"]);
         assert!(
             haystack.prefix_matches(&needle),
-            "{:?} should have started with {:?}",
-            haystack,
-            needle
+            "{haystack:?} should have started with {needle:?}"
         );
 
         // two dir prefix matches
         let needle = needle.child("baz%2Ftest");
         assert!(
             haystack.prefix_matches(&needle),
-            "{:?} should have started with {:?}",
-            haystack,
-            needle
+            "{haystack:?} should have started with {needle:?}"
         );
 
         // partial dir prefix doesn't match
         let needle = Path::from_iter(["f"]);
         assert!(
             !haystack.prefix_matches(&needle),
-            "{:?} should not have started with {:?}",
-            haystack,
-            needle
+            "{haystack:?} should not have started with {needle:?}"
         );
 
         // one dir and one partial dir doesn't match
         let needle = Path::from_iter(["foo/bar", "baz"]);
         assert!(
             !haystack.prefix_matches(&needle),
-            "{:?} should not have started with {:?}",
-            haystack,
-            needle
+            "{haystack:?} should not have started with {needle:?}"
         );
 
         // empty prefix matches
         let needle = Path::from("");
         assert!(
             haystack.prefix_matches(&needle),
-            "{:?} should have started with {:?}",
-            haystack,
-            needle
+            "{haystack:?} should have started with {needle:?}"
         );
     }
 
     #[test]
     fn prefix_matches_with_file_name() {
-        let haystack =
-            Path::from_iter(["foo/bar", "baz%2Ftest", "something", "foo.segment"]);
+        let haystack = Path::from_iter(["foo/bar", "baz%2Ftest", "something", "foo.segment"]);
 
         // All directories match and file name is a prefix
         let needle = Path::from_iter(["foo/bar", "baz%2Ftest", "something", "foo"]);
 
         assert!(
             !haystack.prefix_matches(&needle),
-            "{:?} should not have started with {:?}",
-            haystack,
-            needle
+            "{haystack:?} should not have started with {needle:?}"
         );
 
         // All directories match but file name is not a prefix
@@ -507,9 +503,7 @@ mod tests {
 
         assert!(
             !haystack.prefix_matches(&needle),
-            "{:?} should not have started with {:?}",
-            haystack,
-            needle
+            "{haystack:?} should not have started with {needle:?}"
         );
 
         // Not all directories match; file name is a prefix of the next directory; this
@@ -518,9 +512,7 @@ mod tests {
 
         assert!(
             !haystack.prefix_matches(&needle),
-            "{:?} should not have started with {:?}",
-            haystack,
-            needle
+            "{haystack:?} should not have started with {needle:?}"
         );
 
         // Not all directories match; file name is NOT a prefix of the next directory;
@@ -529,9 +521,59 @@ mod tests {
 
         assert!(
             !haystack.prefix_matches(&needle),
-            "{:?} should not have started with {:?}",
-            haystack,
-            needle
+            "{haystack:?} should not have started with {needle:?}"
         );
     }
+
+    #[test]
+    fn path_containing_spaces() {
+        let a = Path::from_iter(["foo bar", "baz"]);
+        let b = Path::from("foo bar/baz");
+        let c = Path::parse("foo bar/baz").unwrap();
+
+        assert_eq!(a.raw, "foo bar/baz");
+        assert_eq!(a.raw, b.raw);
+        assert_eq!(b.raw, c.raw);
+    }
+
+    #[test]
+    fn from_url_path() {
+        let a = Path::from_url_path("foo%20bar").unwrap();
+        let b = Path::from_url_path("foo/%2E%2E/bar").unwrap_err();
+        let c = Path::from_url_path("foo%2F%252E%252E%2Fbar").unwrap();
+        let d = Path::from_url_path("foo/%252E%252E/bar").unwrap();
+        let e = Path::from_url_path("%48%45%4C%4C%4F").unwrap();
+        let f = Path::from_url_path("foo/%FF/as").unwrap_err();
+
+        assert_eq!(a.raw, "foo bar");
+        assert!(matches!(b, Error::BadSegment { .. }));
+        assert_eq!(c.raw, "foo/%2E%2E/bar");
+        assert_eq!(d.raw, "foo/%2E%2E/bar");
+        assert_eq!(e.raw, "HELLO");
+        assert!(matches!(f, Error::NonUnicode { .. }));
+    }
+
+    #[test]
+    fn filename_from_path() {
+        let a = Path::from("foo/bar");
+        let b = Path::from("foo/bar.baz");
+        let c = Path::from("foo.bar/baz");
+
+        assert_eq!(a.filename(), Some("bar"));
+        assert_eq!(b.filename(), Some("bar.baz"));
+        assert_eq!(c.filename(), Some("baz"));
+    }
+
+    #[test]
+    fn file_extension() {
+        let a = Path::from("foo/bar");
+        let b = Path::from("foo/bar.baz");
+        let c = Path::from("foo.bar/baz");
+        let d = Path::from("foo.bar/baz.qux");
+
+        assert_eq!(a.extension(), None);
+        assert_eq!(b.extension(), Some("baz"));
+        assert_eq!(c.extension(), None);
+        assert_eq!(d.extension(), Some("qux"));
+    }
 }
diff --git a/object_store/src/path/parts.rs b/object_store/src/path/parts.rs
index 9da4815712db..df7097cbe9db 100644
--- a/object_store/src/path/parts.rs
+++ b/object_store/src/path/parts.rs
@@ -37,8 +37,10 @@ pub struct InvalidPart {
 /// The PathPart type exists to validate the directory/file names that form part
 /// of a path.
 ///
-/// A PathPart instance is guaranteed to to contain no illegal characters (e.g. `/`)
-/// as it can only be constructed by going through the `from` impl.
+/// A [`PathPart`] is guaranteed to:
+///
+/// * Contain no ASCII control characters or `/`
+/// * Not be a relative path segment, i.e. `.` or `..`
 #[derive(Clone, PartialEq, Eq, PartialOrd, Ord, Debug, Default, Hash)]
 pub struct PathPart<'a> {
     pub(super) raw: Cow<'a, str>,
@@ -54,19 +56,12 @@ impl<'a> PathPart<'a> {
             });
         }
 
-        for (idx, b) in segment.as_bytes().iter().cloned().enumerate() {
-            // A percent character is always valid, even if not
-            // followed by a valid 2-digit hex code
-            // https://url.spec.whatwg.org/#percent-encoded-bytes
-            if b == b'%' {
-                continue;
-            }
-
-            if !b.is_ascii() || should_percent_encode(b) {
+        for c in segment.chars() {
+            if c.is_ascii_control() || c == '/' {
                 return Err(InvalidPart {
                     segment: segment.to_string(),
                     // This is correct as only single byte characters up to this point
-                    illegal: segment.chars().nth(idx).unwrap().to_string(),
+                    illegal: c.to_string(),
                 });
             }
         }
@@ -77,10 +72,6 @@ impl<'a> PathPart<'a> {
     }
 }
 
-fn should_percent_encode(c: u8) -> bool {
-    percent_encode(&[c], INVALID).next().unwrap().len() != 1
-}
-
 /// Characters we want to encode.
 const INVALID: &AsciiSet = &CONTROLS
     // The delimiter we are reserving for internal hierarchy
diff --git a/object_store/src/prefix.rs b/object_store/src/prefix.rs
new file mode 100644
index 000000000000..38f9b07bbd05
--- /dev/null
+++ b/object_store/src/prefix.rs
@@ -0,0 +1,269 @@
+// 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.
+
+//! An object store wrapper handling a constant path prefix
+use bytes::Bytes;
+use futures::{stream::BoxStream, StreamExt, TryStreamExt};
+use std::ops::Range;
+use tokio::io::AsyncWrite;
+
+use crate::path::Path;
+use crate::{
+    GetOptions, GetResult, ListResult, MultipartId, ObjectMeta, ObjectStore, PutOptions, PutResult,
+    Result,
+};
+
+#[doc(hidden)]
+#[deprecated(note = "Use PrefixStore")]
+pub type PrefixObjectStore<T> = PrefixStore<T>;
+
+/// Store wrapper that applies a constant prefix to all paths handled by the store.
+#[derive(Debug, Clone)]
+pub struct PrefixStore<T: ObjectStore> {
+    prefix: Path,
+    inner: T,
+}
+
+impl<T: ObjectStore> std::fmt::Display for PrefixStore<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "PrefixObjectStore({})", self.prefix.as_ref())
+    }
+}
+
+impl<T: ObjectStore> PrefixStore<T> {
+    /// Create a new instance of [`PrefixStore`]
+    pub fn new(store: T, prefix: impl Into<Path>) -> Self {
+        Self {
+            prefix: prefix.into(),
+            inner: store,
+        }
+    }
+
+    /// Create the full path from a path relative to prefix
+    fn full_path(&self, location: &Path) -> Path {
+        self.prefix.parts().chain(location.parts()).collect()
+    }
+
+    /// Strip the constant prefix from a given path
+    fn strip_prefix(&self, path: Path) -> Path {
+        // Note cannot use match because of borrow checker
+        if let Some(suffix) = path.prefix_match(&self.prefix) {
+            return suffix.collect();
+        }
+        path
+    }
+
+    /// Strip the constant prefix from a given ObjectMeta
+    fn strip_meta(&self, meta: ObjectMeta) -> ObjectMeta {
+        ObjectMeta {
+            last_modified: meta.last_modified,
+            size: meta.size,
+            location: self.strip_prefix(meta.location),
+            e_tag: meta.e_tag,
+            version: None,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl<T: ObjectStore> ObjectStore for PrefixStore<T> {
+    async fn put(&self, location: &Path, bytes: Bytes) -> Result<PutResult> {
+        let full_path = self.full_path(location);
+        self.inner.put(&full_path, bytes).await
+    }
+
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        let full_path = self.full_path(location);
+        self.inner.put_opts(&full_path, bytes, opts).await
+    }
+
+    async fn put_multipart(
+        &self,
+        location: &Path,
+    ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
+        let full_path = self.full_path(location);
+        self.inner.put_multipart(&full_path).await
+    }
+
+    async fn abort_multipart(&self, location: &Path, multipart_id: &MultipartId) -> Result<()> {
+        let full_path = self.full_path(location);
+        self.inner.abort_multipart(&full_path, multipart_id).await
+    }
+    async fn get(&self, location: &Path) -> Result<GetResult> {
+        let full_path = self.full_path(location);
+        self.inner.get(&full_path).await
+    }
+
+    async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes> {
+        let full_path = self.full_path(location);
+        self.inner.get_range(&full_path, range).await
+    }
+
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        let full_path = self.full_path(location);
+        self.inner.get_opts(&full_path, options).await
+    }
+
+    async fn get_ranges(&self, location: &Path, ranges: &[Range<usize>]) -> Result<Vec<Bytes>> {
+        let full_path = self.full_path(location);
+        self.inner.get_ranges(&full_path, ranges).await
+    }
+
+    async fn head(&self, location: &Path) -> Result<ObjectMeta> {
+        let full_path = self.full_path(location);
+        let meta = self.inner.head(&full_path).await?;
+        Ok(self.strip_meta(meta))
+    }
+
+    async fn delete(&self, location: &Path) -> Result<()> {
+        let full_path = self.full_path(location);
+        self.inner.delete(&full_path).await
+    }
+
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        let prefix = self.full_path(prefix.unwrap_or(&Path::default()));
+        let s = self.inner.list(Some(&prefix));
+        s.map_ok(|meta| self.strip_meta(meta)).boxed()
+    }
+
+    fn list_with_offset(
+        &self,
+        prefix: Option<&Path>,
+        offset: &Path,
+    ) -> BoxStream<'_, Result<ObjectMeta>> {
+        let offset = self.full_path(offset);
+        let prefix = self.full_path(prefix.unwrap_or(&Path::default()));
+        let s = self.inner.list_with_offset(Some(&prefix), &offset);
+        s.map_ok(|meta| self.strip_meta(meta)).boxed()
+    }
+
+    async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
+        let prefix = self.full_path(prefix.unwrap_or(&Path::default()));
+        self.inner
+            .list_with_delimiter(Some(&prefix))
+            .await
+            .map(|lst| ListResult {
+                common_prefixes: lst
+                    .common_prefixes
+                    .into_iter()
+                    .map(|p| self.strip_prefix(p))
+                    .collect(),
+                objects: lst
+                    .objects
+                    .into_iter()
+                    .map(|meta| self.strip_meta(meta))
+                    .collect(),
+            })
+    }
+
+    async fn copy(&self, from: &Path, to: &Path) -> Result<()> {
+        let full_from = self.full_path(from);
+        let full_to = self.full_path(to);
+        self.inner.copy(&full_from, &full_to).await
+    }
+
+    async fn rename(&self, from: &Path, to: &Path) -> Result<()> {
+        let full_from = self.full_path(from);
+        let full_to = self.full_path(to);
+        self.inner.rename(&full_from, &full_to).await
+    }
+
+    async fn copy_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
+        let full_from = self.full_path(from);
+        let full_to = self.full_path(to);
+        self.inner.copy_if_not_exists(&full_from, &full_to).await
+    }
+
+    async fn rename_if_not_exists(&self, from: &Path, to: &Path) -> Result<()> {
+        let full_from = self.full_path(from);
+        let full_to = self.full_path(to);
+        self.inner.rename_if_not_exists(&full_from, &full_to).await
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::local::LocalFileSystem;
+    use crate::test_util::flatten_list_stream;
+    use crate::tests::*;
+
+    use tempfile::TempDir;
+
+    #[tokio::test]
+    async fn prefix_test() {
+        let root = TempDir::new().unwrap();
+        let inner = LocalFileSystem::new_with_prefix(root.path()).unwrap();
+        let integration = PrefixStore::new(inner, "prefix");
+
+        put_get_delete_list(&integration).await;
+        get_opts(&integration).await;
+        list_uses_directories_correctly(&integration).await;
+        list_with_delimiter(&integration).await;
+        rename_and_copy(&integration).await;
+        copy_if_not_exists(&integration).await;
+        stream_get(&integration).await;
+    }
+
+    #[tokio::test]
+    async fn prefix_test_applies_prefix() {
+        let tmpdir = TempDir::new().unwrap();
+        let local = LocalFileSystem::new_with_prefix(tmpdir.path()).unwrap();
+
+        let location = Path::from("prefix/test_file.json");
+        let data = Bytes::from("arbitrary data");
+        let expected_data = data.clone();
+
+        local.put(&location, data).await.unwrap();
+
+        let prefix = PrefixStore::new(local, "prefix");
+        let location_prefix = Path::from("test_file.json");
+
+        let content_list = flatten_list_stream(&prefix, None).await.unwrap();
+        assert_eq!(content_list, &[location_prefix.clone()]);
+
+        let root = Path::from("/");
+        let content_list = flatten_list_stream(&prefix, Some(&root)).await.unwrap();
+        assert_eq!(content_list, &[location_prefix.clone()]);
+
+        let read_data = prefix
+            .get(&location_prefix)
+            .await
+            .unwrap()
+            .bytes()
+            .await
+            .unwrap();
+        assert_eq!(&*read_data, expected_data);
+
+        let target_prefix = Path::from("/test_written.json");
+        prefix
+            .put(&target_prefix, expected_data.clone())
+            .await
+            .unwrap();
+
+        prefix.delete(&location_prefix).await.unwrap();
+
+        let local = LocalFileSystem::new_with_prefix(tmpdir.path()).unwrap();
+
+        let err = local.get(&location).await.unwrap_err();
+        assert!(matches!(err, crate::Error::NotFound { .. }), "{}", err);
+
+        let location = Path::from("prefix/test_written.json");
+        let read_data = local.get(&location).await.unwrap().bytes().await.unwrap();
+        assert_eq!(&*read_data, expected_data)
+    }
+}
diff --git a/object_store/src/signer.rs b/object_store/src/signer.rs
new file mode 100644
index 000000000000..da55c689aef5
--- /dev/null
+++ b/object_store/src/signer.rs
@@ -0,0 +1,50 @@
+// 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.
+
+//! Abstraction of signed URL generation for those object store implementations that support it
+
+use crate::{path::Path, Result};
+use async_trait::async_trait;
+use reqwest::Method;
+use std::{fmt, time::Duration};
+use url::Url;
+
+/// Universal API to generate presigned URLs from multiple object store services.
+#[async_trait]
+pub trait Signer: Send + Sync + fmt::Debug + 'static {
+    /// Given the intended [`Method`] and [`Path`] to use and the desired length of time for which
+    /// the URL should be valid, return a signed [`Url`] created with the object store
+    /// implementation's credentials such that the URL can be handed to something that doesn't have
+    /// access to the object store's credentials, to allow limited access to the object store.
+    async fn signed_url(&self, method: Method, path: &Path, expires_in: Duration) -> Result<Url>;
+
+    /// Generate signed urls for multiple paths.
+    ///
+    /// See [`Signer::signed_url`] for more details.
+    async fn signed_urls(
+        &self,
+        method: Method,
+        paths: &[Path],
+        expires_in: Duration,
+    ) -> Result<Vec<Url>> {
+        let mut urls = Vec::with_capacity(paths.len());
+        for path in paths {
+            urls.push(self.signed_url(method.clone(), path, expires_in).await?);
+        }
+        Ok(urls)
+    }
+}
diff --git a/object_store/src/tags.rs b/object_store/src/tags.rs
new file mode 100644
index 000000000000..fa6e5913f4b1
--- /dev/null
+++ b/object_store/src/tags.rs
@@ -0,0 +1,60 @@
+// 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.
+
+use url::form_urlencoded::Serializer;
+
+/// A collection of key value pairs used to annotate objects
+///
+/// <https://docs.aws.amazon.com/AmazonS3/latest/userguide/object-tagging.html>
+/// <https://learn.microsoft.com/en-us/rest/api/storageservices/set-blob-tags>
+#[derive(Debug, Clone, Default, Eq, PartialEq)]
+pub struct TagSet(String);
+
+impl TagSet {
+    /// Append a key value pair to this [`TagSet`]
+    ///
+    /// Stores have different restrictions on what characters are permitted,
+    /// for portability it is recommended applications use no more than 10 tags,
+    /// and stick to alphanumeric characters, and `+ - = . _ : /`
+    ///
+    /// <https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObjectTagging.html>
+    /// <https://learn.microsoft.com/en-us/rest/api/storageservices/set-blob-tags?tabs=azure-ad#request-body>
+    pub fn push(&mut self, key: &str, value: &str) {
+        Serializer::new(&mut self.0).append_pair(key, value);
+    }
+
+    /// Return this [`TagSet`] as a URL-encoded string
+    pub fn encoded(&self) -> &str {
+        &self.0
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_tag_set() {
+        let mut set = TagSet::default();
+        set.push("test/foo", "value sdlks");
+        set.push("foo", " sdf _ /+./sd");
+        assert_eq!(
+            set.encoded(),
+            "test%2Ffoo=value+sdlks&foo=+sdf+_+%2F%2B.%2Fsd"
+        );
+    }
+}
diff --git a/object_store/src/throttle.rs b/object_store/src/throttle.rs
index 90f427cc2651..252256a4599e 100644
--- a/object_store/src/throttle.rs
+++ b/object_store/src/throttle.rs
@@ -20,11 +20,14 @@ use parking_lot::Mutex;
 use std::ops::Range;
 use std::{convert::TryInto, sync::Arc};
 
-use crate::MultipartId;
-use crate::{path::Path, GetResult, ListResult, ObjectMeta, ObjectStore, Result};
+use crate::{
+    path::Path, GetResult, GetResultPayload, ListResult, ObjectMeta, ObjectStore, PutOptions,
+    PutResult, Result,
+};
+use crate::{GetOptions, MultipartId};
 use async_trait::async_trait;
 use bytes::Bytes;
-use futures::{stream::BoxStream, StreamExt};
+use futures::{stream::BoxStream, FutureExt, StreamExt};
 use std::time::Duration;
 use tokio::io::AsyncWrite;
 
@@ -145,12 +148,16 @@ impl<T: ObjectStore> std::fmt::Display for ThrottledStore<T> {
 
 #[async_trait]
 impl<T: ObjectStore> ObjectStore for ThrottledStore<T> {
-    async fn put(&self, location: &Path, bytes: Bytes) -> Result<()> {
+    async fn put(&self, location: &Path, bytes: Bytes) -> Result<PutResult> {
         sleep(self.config().wait_put_per_call).await;
-
         self.inner.put(location, bytes).await
     }
 
+    async fn put_opts(&self, location: &Path, bytes: Bytes, opts: PutOptions) -> Result<PutResult> {
+        sleep(self.config().wait_put_per_call).await;
+        self.inner.put_opts(location, bytes, opts).await
+    }
+
     async fn put_multipart(
         &self,
         _location: &Path,
@@ -158,11 +165,7 @@ impl<T: ObjectStore> ObjectStore for ThrottledStore<T> {
         Err(super::Error::NotImplemented)
     }
 
-    async fn abort_multipart(
-        &self,
-        _location: &Path,
-        _multipart_id: &MultipartId,
-    ) -> Result<()> {
+    async fn abort_multipart(&self, _location: &Path, _multipart_id: &MultipartId) -> Result<()> {
         Err(super::Error::NotImplemented)
     }
 
@@ -172,44 +175,32 @@ impl<T: ObjectStore> ObjectStore for ThrottledStore<T> {
         // need to copy to avoid moving / referencing `self`
         let wait_get_per_byte = self.config().wait_get_per_byte;
 
-        self.inner.get(location).await.map(|result| {
-            let s = match result {
-                GetResult::Stream(s) => s,
-                GetResult::File(_, _) => unimplemented!(),
-            };
+        let result = self.inner.get(location).await?;
+        Ok(throttle_get(result, wait_get_per_byte))
+    }
 
-            GetResult::Stream(
-                s.then(move |bytes_result| async move {
-                    match bytes_result {
-                        Ok(bytes) => {
-                            let bytes_len: u32 = usize_to_u32_saturate(bytes.len());
-                            sleep(wait_get_per_byte * bytes_len).await;
-                            Ok(bytes)
-                        }
-                        Err(err) => Err(err),
-                    }
-                })
-                .boxed(),
-            )
-        })
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        sleep(self.config().wait_get_per_call).await;
+
+        // need to copy to avoid moving / referencing `self`
+        let wait_get_per_byte = self.config().wait_get_per_byte;
+
+        let result = self.inner.get_opts(location, options).await?;
+        Ok(throttle_get(result, wait_get_per_byte))
     }
 
     async fn get_range(&self, location: &Path, range: Range<usize>) -> Result<Bytes> {
         let config = self.config();
 
-        let sleep_duration = config.wait_get_per_call
-            + config.wait_get_per_byte * (range.end - range.start) as u32;
+        let sleep_duration =
+            config.wait_get_per_call + config.wait_get_per_byte * (range.end - range.start) as u32;
 
         sleep(sleep_duration).await;
 
         self.inner.get_range(location, range).await
     }
 
-    async fn get_ranges(
-        &self,
-        location: &Path,
-        ranges: &[Range<usize>],
-    ) -> Result<Vec<Bytes>> {
+    async fn get_ranges(&self, location: &Path, ranges: &[Range<usize>]) -> Result<Vec<Bytes>> {
         let config = self.config();
 
         let total_bytes: usize = ranges.iter().map(|range| range.end - range.start).sum();
@@ -232,28 +223,30 @@ impl<T: ObjectStore> ObjectStore for ThrottledStore<T> {
         self.inner.delete(location).await
     }
 
-    async fn list(
+    fn list(&self, prefix: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        let stream = self.inner.list(prefix);
+        futures::stream::once(async move {
+            let wait_list_per_entry = self.config().wait_list_per_entry;
+            sleep(self.config().wait_list_per_call).await;
+            throttle_stream(stream, move |_| wait_list_per_entry)
+        })
+        .flatten()
+        .boxed()
+    }
+
+    fn list_with_offset(
         &self,
         prefix: Option<&Path>,
-    ) -> Result<BoxStream<'_, Result<ObjectMeta>>> {
-        sleep(self.config().wait_list_per_call).await;
-
-        // need to copy to avoid moving / referencing `self`
-        let wait_list_per_entry = self.config().wait_list_per_entry;
-
-        self.inner.list(prefix).await.map(|stream| {
-            stream
-                .then(move |result| async move {
-                    match result {
-                        Ok(entry) => {
-                            sleep(wait_list_per_entry).await;
-                            Ok(entry)
-                        }
-                        Err(err) => Err(err),
-                    }
-                })
-                .boxed()
+        offset: &Path,
+    ) -> BoxStream<'_, Result<ObjectMeta>> {
+        let stream = self.inner.list_with_offset(prefix, offset);
+        futures::stream::once(async move {
+            let wait_list_per_entry = self.config().wait_list_per_entry;
+            sleep(self.config().wait_list_per_call).await;
+            throttle_stream(stream, move |_| wait_list_per_entry)
         })
+        .flatten()
+        .boxed()
     }
 
     async fn list_with_delimiter(&self, prefix: Option<&Path>) -> Result<ListResult> {
@@ -262,8 +255,7 @@ impl<T: ObjectStore> ObjectStore for ThrottledStore<T> {
         match self.inner.list_with_delimiter(prefix).await {
             Ok(list_result) => {
                 let entries_len = usize_to_u32_saturate(list_result.objects.len());
-                sleep(self.config().wait_list_with_delimiter_per_entry * entries_len)
-                    .await;
+                sleep(self.config().wait_list_with_delimiter_per_entry * entries_len).await;
                 Ok(list_result)
             }
             Err(err) => Err(err),
@@ -300,16 +292,42 @@ fn usize_to_u32_saturate(x: usize) -> u32 {
     x.try_into().unwrap_or(u32::MAX)
 }
 
+fn throttle_get(result: GetResult, wait_get_per_byte: Duration) -> GetResult {
+    let s = match result.payload {
+        GetResultPayload::Stream(s) => s,
+        GetResultPayload::File(_, _) => unimplemented!(),
+    };
+
+    let stream = throttle_stream(s, move |bytes| {
+        let bytes_len: u32 = usize_to_u32_saturate(bytes.len());
+        wait_get_per_byte * bytes_len
+    });
+
+    GetResult {
+        payload: GetResultPayload::Stream(stream),
+        ..result
+    }
+}
+
+fn throttle_stream<T: Send + 'static, E: Send + 'static, F>(
+    stream: BoxStream<'_, Result<T, E>>,
+    delay: F,
+) -> BoxStream<'_, Result<T, E>>
+where
+    F: Fn(&T) -> Duration + Send + Sync + 'static,
+{
+    stream
+        .then(move |result| {
+            let delay = result.as_ref().ok().map(&delay).unwrap_or_default();
+            sleep(delay).then(|_| futures::future::ready(result))
+        })
+        .boxed()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        memory::InMemory,
-        tests::{
-            copy_if_not_exists, list_uses_directories_correctly, list_with_delimiter,
-            put_get_delete_list, rename_and_copy,
-        },
-    };
+    use crate::{memory::InMemory, tests::*, GetResultPayload};
     use bytes::Bytes;
     use futures::TryStreamExt;
     use tokio::time::Duration;
@@ -457,10 +475,7 @@ mod tests {
         assert_bounds!(measure_put(&store, 0).await, 0);
     }
 
-    async fn place_test_object(
-        store: &ThrottledStore<InMemory>,
-        n_bytes: Option<usize>,
-    ) -> Path {
+    async fn place_test_object(store: &ThrottledStore<InMemory>, n_bytes: Option<usize>) -> Path {
         let path = Path::from("foo");
 
         if let Some(n_bytes) = n_bytes {
@@ -476,20 +491,11 @@ mod tests {
     }
 
     #[allow(dead_code)]
-    async fn place_test_objects(
-        store: &ThrottledStore<InMemory>,
-        n_entries: usize,
-    ) -> Path {
+    async fn place_test_objects(store: &ThrottledStore<InMemory>, n_entries: usize) -> Path {
         let prefix = Path::from("foo");
 
         // clean up store
-        let entries: Vec<_> = store
-            .list(Some(&prefix))
-            .await
-            .unwrap()
-            .try_collect()
-            .await
-            .unwrap();
+        let entries: Vec<_> = store.list(Some(&prefix)).try_collect().await.unwrap();
 
         for entry in entries {
             store.delete(&entry.location).await.unwrap();
@@ -506,10 +512,7 @@ mod tests {
         prefix
     }
 
-    async fn measure_delete(
-        store: &ThrottledStore<InMemory>,
-        n_bytes: Option<usize>,
-    ) -> Duration {
+    async fn measure_delete(store: &ThrottledStore<InMemory>, n_bytes: Option<usize>) -> Duration {
         let path = place_test_object(store, n_bytes).await;
 
         let t0 = Instant::now();
@@ -519,19 +522,16 @@ mod tests {
     }
 
     #[allow(dead_code)]
-    async fn measure_get(
-        store: &ThrottledStore<InMemory>,
-        n_bytes: Option<usize>,
-    ) -> Duration {
+    async fn measure_get(store: &ThrottledStore<InMemory>, n_bytes: Option<usize>) -> Duration {
         let path = place_test_object(store, n_bytes).await;
 
         let t0 = Instant::now();
         let res = store.get(&path).await;
         if n_bytes.is_some() {
             // need to consume bytes to provoke sleep times
-            let s = match res.unwrap() {
-                GetResult::Stream(s) => s,
-                GetResult::File(_, _) => unimplemented!(),
+            let s = match res.unwrap().payload {
+                GetResultPayload::Stream(s) => s,
+                GetResultPayload::File(_, _) => unimplemented!(),
             };
 
             s.map_ok(|b| bytes::BytesMut::from(&b[..]))
@@ -546,17 +546,12 @@ mod tests {
     }
 
     #[allow(dead_code)]
-    async fn measure_list(
-        store: &ThrottledStore<InMemory>,
-        n_entries: usize,
-    ) -> Duration {
+    async fn measure_list(store: &ThrottledStore<InMemory>, n_entries: usize) -> Duration {
         let prefix = place_test_objects(store, n_entries).await;
 
         let t0 = Instant::now();
         store
             .list(Some(&prefix))
-            .await
-            .unwrap()
             .try_collect::<Vec<_>>()
             .await
             .unwrap();
diff --git a/object_store/src/util.rs b/object_store/src/util.rs
index 46e9e9ed8771..a19d5aab4b5b 100644
--- a/object_store/src/util.rs
+++ b/object_store/src/util.rs
@@ -16,29 +16,44 @@
 // under the License.
 
 //! Common logic for interacting with remote object stores
+use std::{
+    fmt::Display,
+    ops::{Range, RangeBounds},
+};
+
 use super::Result;
 use bytes::Bytes;
-use futures::{stream::StreamExt, Stream};
-
-/// Returns the prefix to be passed to an object store
-#[cfg(any(feature = "aws", feature = "gcp", feature = "azure"))]
-pub fn format_prefix(prefix: Option<&crate::path::Path>) -> Option<String> {
-    prefix
-        .filter(|x| !x.as_ref().is_empty())
-        .map(|p| format!("{}{}", p.as_ref(), crate::path::DELIMITER))
+use futures::{stream::StreamExt, Stream, TryStreamExt};
+use snafu::Snafu;
+
+#[cfg(any(feature = "azure", feature = "http"))]
+pub static RFC1123_FMT: &str = "%a, %d %h %Y %T GMT";
+
+// deserialize dates according to rfc1123
+#[cfg(any(feature = "azure", feature = "http"))]
+pub fn deserialize_rfc1123<'de, D>(
+    deserializer: D,
+) -> Result<chrono::DateTime<chrono::Utc>, D::Error>
+where
+    D: serde::Deserializer<'de>,
+{
+    let s: String = serde::Deserialize::deserialize(deserializer)?;
+    let naive =
+        chrono::NaiveDateTime::parse_from_str(&s, RFC1123_FMT).map_err(serde::de::Error::custom)?;
+    Ok(chrono::TimeZone::from_utc_datetime(&chrono::Utc, &naive))
 }
 
-/// Returns a formatted HTTP range header as per
-/// <https://httpwg.org/specs/rfc7233.html#header.range>
-#[cfg(any(feature = "aws", feature = "gcp"))]
-pub fn format_http_range(range: std::ops::Range<usize>) -> String {
-    format!("bytes={}-{}", range.start, range.end.saturating_sub(1))
+#[cfg(any(feature = "aws", feature = "azure"))]
+pub(crate) fn hmac_sha256(secret: impl AsRef<[u8]>, bytes: impl AsRef<[u8]>) -> ring::hmac::Tag {
+    let key = ring::hmac::Key::new(ring::hmac::HMAC_SHA256, secret.as_ref());
+    ring::hmac::sign(&key, bytes.as_ref())
 }
 
 /// Collect a stream into [`Bytes`] avoiding copying in the event of a single chunk
-pub async fn collect_bytes<S>(mut stream: S, size_hint: Option<usize>) -> Result<Bytes>
+pub async fn collect_bytes<S, E>(mut stream: S, size_hint: Option<usize>) -> Result<Bytes, E>
 where
-    S: Stream<Item = Result<Bytes>> + Send + Unpin,
+    E: Send,
+    S: Stream<Item = Result<Bytes, E>> + Send + Unpin,
 {
     let first = stream.next().await.transpose()?.unwrap_or_default();
 
@@ -60,6 +75,7 @@ where
     }
 }
 
+#[cfg(not(target_arch = "wasm32"))]
 /// Takes a function and spawns it to a tokio blocking pool if available
 pub async fn maybe_spawn_blocking<F, T>(f: F) -> Result<T>
 where
@@ -76,78 +92,240 @@ where
 /// will be coalesced into a single request by [`coalesce_ranges`]
 pub const OBJECT_STORE_COALESCE_DEFAULT: usize = 1024 * 1024;
 
-/// Takes a function to fetch ranges and coalesces adjacent ranges if they are
-/// less than `coalesce` bytes apart. Out of order `ranges` are not coalesced
-pub async fn coalesce_ranges<F, Fut>(
-    ranges: &[std::ops::Range<usize>],
-    mut fetch: F,
+/// Up to this number of range requests will be performed in parallel by [`coalesce_ranges`]
+pub const OBJECT_STORE_COALESCE_PARALLEL: usize = 10;
+
+/// Takes a function `fetch` that can fetch a range of bytes and uses this to
+/// fetch the provided byte `ranges`
+///
+/// To improve performance it will:
+///
+/// * Combine ranges less than `coalesce` bytes apart into a single call to `fetch`
+/// * Make multiple `fetch` requests in parallel (up to maximum of 10)
+///
+pub async fn coalesce_ranges<F, E, Fut>(
+    ranges: &[Range<usize>],
+    fetch: F,
     coalesce: usize,
-) -> Result<Vec<Bytes>>
+) -> Result<Vec<Bytes>, E>
 where
-    F: Send + FnMut(std::ops::Range<usize>) -> Fut,
-    Fut: std::future::Future<Output = Result<Bytes>> + Send,
+    F: Send + FnMut(Range<usize>) -> Fut,
+    E: Send,
+    Fut: std::future::Future<Output = Result<Bytes, E>> + Send,
 {
+    let fetch_ranges = merge_ranges(ranges, coalesce);
+
+    let fetched: Vec<_> = futures::stream::iter(fetch_ranges.iter().cloned())
+        .map(fetch)
+        .buffered(OBJECT_STORE_COALESCE_PARALLEL)
+        .try_collect()
+        .await?;
+
+    Ok(ranges
+        .iter()
+        .map(|range| {
+            let idx = fetch_ranges.partition_point(|v| v.start <= range.start) - 1;
+            let fetch_range = &fetch_ranges[idx];
+            let fetch_bytes = &fetched[idx];
+
+            let start = range.start - fetch_range.start;
+            let end = range.end - fetch_range.start;
+            fetch_bytes.slice(start..end.min(fetch_bytes.len()))
+        })
+        .collect())
+}
+
+/// Returns a sorted list of ranges that cover `ranges`
+fn merge_ranges(ranges: &[Range<usize>], coalesce: usize) -> Vec<Range<usize>> {
+    if ranges.is_empty() {
+        return vec![];
+    }
+
+    let mut ranges = ranges.to_vec();
+    ranges.sort_unstable_by_key(|range| range.start);
+
     let mut ret = Vec::with_capacity(ranges.len());
     let mut start_idx = 0;
     let mut end_idx = 1;
 
     while start_idx != ranges.len() {
+        let mut range_end = ranges[start_idx].end;
+
         while end_idx != ranges.len()
             && ranges[end_idx]
                 .start
-                .checked_sub(ranges[start_idx].end)
+                .checked_sub(range_end)
                 .map(|delta| delta <= coalesce)
-                .unwrap_or(false)
+                .unwrap_or(true)
         {
+            range_end = range_end.max(ranges[end_idx].end);
             end_idx += 1;
         }
 
         let start = ranges[start_idx].start;
-        let end = ranges[end_idx - 1].end;
-        let bytes = fetch(start..end).await?;
-        for range in ranges.iter().take(end_idx).skip(start_idx) {
-            ret.push(bytes.slice(range.start - start..range.end - start))
-        }
+        let end = range_end;
+        ret.push(start..end);
+
         start_idx = end_idx;
         end_idx += 1;
     }
-    Ok(ret)
+
+    ret
+}
+
+/// Request only a portion of an object's bytes
+///
+/// These can be created from [usize] ranges, like
+///
+/// ```rust
+/// # use object_store::GetRange;
+/// let range1: GetRange = (50..150).into();
+/// let range2: GetRange = (50..=150).into();
+/// let range3: GetRange = (50..).into();
+/// let range4: GetRange = (..150).into();
+/// ```
+///
+/// Implementations may wish to inspect [`GetResult`] for the exact byte
+/// range returned.
+///
+/// [`GetResult`]: crate::GetResult
+#[derive(Debug, PartialEq, Eq, Clone)]
+pub enum GetRange {
+    /// Request a specific range of bytes
+    ///
+    /// If the given range is zero-length or starts after the end of the object,
+    /// an error will be returned. Additionally, if the range ends after the end
+    /// of the object, the entire remainder of the object will be returned.
+    /// Otherwise, the exact requested range will be returned.
+    Bounded(Range<usize>),
+    /// Request all bytes starting from a given byte offset
+    Offset(usize),
+    /// Request up to the last n bytes
+    Suffix(usize),
+}
+
+#[derive(Debug, Snafu)]
+pub(crate) enum InvalidGetRange {
+    #[snafu(display(
+        "Wanted range starting at {requested}, but object was only {length} bytes long"
+    ))]
+    StartTooLarge { requested: usize, length: usize },
+
+    #[snafu(display("Range started at {start} and ended at {end}"))]
+    Inconsistent { start: usize, end: usize },
+}
+
+impl GetRange {
+    pub(crate) fn is_valid(&self) -> Result<(), InvalidGetRange> {
+        match self {
+            Self::Bounded(r) if r.end <= r.start => {
+                return Err(InvalidGetRange::Inconsistent {
+                    start: r.start,
+                    end: r.end,
+                });
+            }
+            _ => (),
+        };
+        Ok(())
+    }
+
+    /// Convert to a [`Range`] if valid.
+    pub(crate) fn as_range(&self, len: usize) -> Result<Range<usize>, InvalidGetRange> {
+        self.is_valid()?;
+        match self {
+            Self::Bounded(r) => {
+                if r.start >= len {
+                    Err(InvalidGetRange::StartTooLarge {
+                        requested: r.start,
+                        length: len,
+                    })
+                } else if r.end > len {
+                    Ok(r.start..len)
+                } else {
+                    Ok(r.clone())
+                }
+            }
+            Self::Offset(o) => {
+                if *o >= len {
+                    Err(InvalidGetRange::StartTooLarge {
+                        requested: *o,
+                        length: len,
+                    })
+                } else {
+                    Ok(*o..len)
+                }
+            }
+            Self::Suffix(n) => Ok(len.saturating_sub(*n)..len),
+        }
+    }
+}
+
+impl Display for GetRange {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::Bounded(r) => write!(f, "bytes={}-{}", r.start, r.end - 1),
+            Self::Offset(o) => write!(f, "bytes={o}-"),
+            Self::Suffix(n) => write!(f, "bytes=-{n}"),
+        }
+    }
+}
+
+impl<T: RangeBounds<usize>> From<T> for GetRange {
+    fn from(value: T) -> Self {
+        use std::ops::Bound::*;
+        let first = match value.start_bound() {
+            Included(i) => *i,
+            Excluded(i) => i + 1,
+            Unbounded => 0,
+        };
+        match value.end_bound() {
+            Included(i) => Self::Bounded(first..(i + 1)),
+            Excluded(i) => Self::Bounded(first..*i),
+            Unbounded => Self::Offset(first),
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
+    use crate::Error;
+
     use super::*;
+    use rand::{thread_rng, Rng};
     use std::ops::Range;
 
+    /// Calls coalesce_ranges and validates the returned data is correct
+    ///
+    /// Returns the fetched ranges
+    async fn do_fetch(ranges: Vec<Range<usize>>, coalesce: usize) -> Vec<Range<usize>> {
+        let max = ranges.iter().map(|x| x.end).max().unwrap_or(0);
+        let src: Vec<_> = (0..max).map(|x| x as u8).collect();
+
+        let mut fetches = vec![];
+        let coalesced = coalesce_ranges::<_, Error, _>(
+            &ranges,
+            |range| {
+                fetches.push(range.clone());
+                futures::future::ready(Ok(Bytes::from(src[range].to_vec())))
+            },
+            coalesce,
+        )
+        .await
+        .unwrap();
+
+        assert_eq!(ranges.len(), coalesced.len());
+        for (range, bytes) in ranges.iter().zip(coalesced) {
+            assert_eq!(bytes.as_ref(), &src[range.clone()]);
+        }
+        fetches
+    }
+
     #[tokio::test]
     async fn test_coalesce_ranges() {
-        let do_fetch = |ranges: Vec<Range<usize>>, coalesce: usize| async move {
-            let max = ranges.iter().map(|x| x.end).max().unwrap_or(0);
-            let src: Vec<_> = (0..max).map(|x| x as u8).collect();
-
-            let mut fetches = vec![];
-            let coalesced = coalesce_ranges(
-                &ranges,
-                |range| {
-                    fetches.push(range.clone());
-                    futures::future::ready(Ok(Bytes::from(src[range].to_vec())))
-                },
-                coalesce,
-            )
-            .await
-            .unwrap();
-
-            assert_eq!(ranges.len(), coalesced.len());
-            for (range, bytes) in ranges.iter().zip(coalesced) {
-                assert_eq!(bytes.as_ref(), &src[range.clone()]);
-            }
-            fetches
-        };
-
         let fetches = do_fetch(vec![], 0).await;
-        assert_eq!(fetches, vec![]);
+        assert!(fetches.is_empty());
 
-        let fetches = do_fetch(vec![0..3], 0).await;
+        let fetches = do_fetch(vec![0..3; 1], 0).await;
         assert_eq!(fetches, vec![0..3]);
 
         let fetches = do_fetch(vec![0..2, 3..5], 0).await;
@@ -163,6 +341,106 @@ mod tests {
         assert_eq!(fetches, vec![0..1, 56..75]);
 
         let fetches = do_fetch(vec![0..1, 5..6, 7..9, 2..3, 4..6], 1).await;
-        assert_eq!(fetches, vec![0..1, 5..9, 2..6]);
+        assert_eq!(fetches, vec![0..9]);
+
+        let fetches = do_fetch(vec![0..1, 5..6, 7..9, 2..3, 4..6], 1).await;
+        assert_eq!(fetches, vec![0..9]);
+
+        let fetches = do_fetch(vec![0..1, 6..7, 8..9, 10..14, 9..10], 4).await;
+        assert_eq!(fetches, vec![0..1, 6..14]);
+    }
+
+    #[tokio::test]
+    async fn test_coalesce_fuzz() {
+        let mut rand = thread_rng();
+        for _ in 0..100 {
+            let object_len = rand.gen_range(10..250);
+            let range_count = rand.gen_range(0..10);
+            let ranges: Vec<_> = (0..range_count)
+                .map(|_| {
+                    let start = rand.gen_range(0..object_len);
+                    let max_len = 20.min(object_len - start);
+                    let len = rand.gen_range(0..max_len);
+                    start..start + len
+                })
+                .collect();
+
+            let coalesce = rand.gen_range(1..5);
+            let fetches = do_fetch(ranges.clone(), coalesce).await;
+
+            for fetch in fetches.windows(2) {
+                assert!(
+                    fetch[0].start <= fetch[1].start,
+                    "fetches should be sorted, {:?} vs {:?}",
+                    fetch[0],
+                    fetch[1]
+                );
+
+                let delta = fetch[1].end - fetch[0].end;
+                assert!(
+                    delta > coalesce,
+                    "fetches should not overlap by {}, {:?} vs {:?} for {:?}",
+                    coalesce,
+                    fetch[0],
+                    fetch[1],
+                    ranges
+                );
+            }
+        }
+    }
+
+    #[test]
+    fn getrange_str() {
+        assert_eq!(GetRange::Offset(0).to_string(), "bytes=0-");
+        assert_eq!(GetRange::Bounded(10..19).to_string(), "bytes=10-18");
+        assert_eq!(GetRange::Suffix(10).to_string(), "bytes=-10");
+    }
+
+    #[test]
+    fn getrange_from() {
+        assert_eq!(Into::<GetRange>::into(10..15), GetRange::Bounded(10..15),);
+        assert_eq!(Into::<GetRange>::into(10..=15), GetRange::Bounded(10..16),);
+        assert_eq!(Into::<GetRange>::into(10..), GetRange::Offset(10),);
+        assert_eq!(Into::<GetRange>::into(..=15), GetRange::Bounded(0..16));
+    }
+
+    #[test]
+    fn test_as_range() {
+        let range = GetRange::Bounded(2..5);
+        assert_eq!(range.as_range(5).unwrap(), 2..5);
+
+        let range = range.as_range(4).unwrap();
+        assert_eq!(range, 2..4);
+
+        let range = GetRange::Bounded(3..3);
+        let err = range.as_range(2).unwrap_err().to_string();
+        assert_eq!(err, "Range started at 3 and ended at 3");
+
+        let range = GetRange::Bounded(2..2);
+        let err = range.as_range(3).unwrap_err().to_string();
+        assert_eq!(err, "Range started at 2 and ended at 2");
+
+        let range = GetRange::Suffix(3);
+        assert_eq!(range.as_range(3).unwrap(), 0..3);
+        assert_eq!(range.as_range(2).unwrap(), 0..2);
+
+        let range = GetRange::Suffix(0);
+        assert_eq!(range.as_range(0).unwrap(), 0..0);
+
+        let range = GetRange::Offset(2);
+        let err = range.as_range(2).unwrap_err().to_string();
+        assert_eq!(
+            err,
+            "Wanted range starting at 2, but object was only 2 bytes long"
+        );
+
+        let err = range.as_range(1).unwrap_err().to_string();
+        assert_eq!(
+            err,
+            "Wanted range starting at 2, but object was only 1 bytes long"
+        );
+
+        let range = GetRange::Offset(1);
+        assert_eq!(range.as_range(2).unwrap(), 1..2);
     }
 }
diff --git a/object_store/tests/get_range_file.rs b/object_store/tests/get_range_file.rs
new file mode 100644
index 000000000000..f73d78578f08
--- /dev/null
+++ b/object_store/tests/get_range_file.rs
@@ -0,0 +1,121 @@
+// 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.
+
+//! Tests the default implementation of get_range handles GetResult::File correctly (#4350)
+
+use async_trait::async_trait;
+use bytes::Bytes;
+use futures::stream::BoxStream;
+use object_store::local::LocalFileSystem;
+use object_store::path::Path;
+use object_store::*;
+use std::fmt::Formatter;
+use tempfile::tempdir;
+use tokio::io::AsyncWrite;
+
+#[derive(Debug)]
+struct MyStore(LocalFileSystem);
+
+impl std::fmt::Display for MyStore {
+    fn fmt(&self, _: &mut Formatter<'_>) -> std::fmt::Result {
+        todo!()
+    }
+}
+
+#[async_trait]
+impl ObjectStore for MyStore {
+    async fn put_opts(&self, path: &Path, data: Bytes, opts: PutOptions) -> Result<PutResult> {
+        self.0.put_opts(path, data, opts).await
+    }
+
+    async fn put_multipart(
+        &self,
+        _: &Path,
+    ) -> Result<(MultipartId, Box<dyn AsyncWrite + Unpin + Send>)> {
+        todo!()
+    }
+
+    async fn abort_multipart(&self, _: &Path, _: &MultipartId) -> Result<()> {
+        todo!()
+    }
+
+    async fn get_opts(&self, location: &Path, options: GetOptions) -> Result<GetResult> {
+        self.0.get_opts(location, options).await
+    }
+
+    async fn delete(&self, _: &Path) -> Result<()> {
+        todo!()
+    }
+
+    fn list(&self, _: Option<&Path>) -> BoxStream<'_, Result<ObjectMeta>> {
+        todo!()
+    }
+
+    async fn list_with_delimiter(&self, _: Option<&Path>) -> Result<ListResult> {
+        todo!()
+    }
+
+    async fn copy(&self, _: &Path, _: &Path) -> Result<()> {
+        todo!()
+    }
+
+    async fn copy_if_not_exists(&self, _: &Path, _: &Path) -> Result<()> {
+        todo!()
+    }
+}
+
+#[tokio::test]
+async fn test_get_range() {
+    let tmp = tempdir().unwrap();
+    let store = MyStore(LocalFileSystem::new_with_prefix(tmp.path()).unwrap());
+    let path = Path::from("foo");
+
+    let expected = Bytes::from_static(b"hello world");
+    store.put(&path, expected.clone()).await.unwrap();
+    let fetched = store.get(&path).await.unwrap().bytes().await.unwrap();
+    assert_eq!(expected, fetched);
+
+    for range in [0..10, 3..5, 0..expected.len()] {
+        let data = store.get_range(&path, range.clone()).await.unwrap();
+        assert_eq!(&data[..], &expected[range])
+    }
+
+    let over_range = 0..(expected.len() * 2);
+    let data = store.get_range(&path, over_range.clone()).await.unwrap();
+    assert_eq!(&data[..], expected)
+}
+
+/// Test that, when a requesting a range which overhangs the end of the resource,
+/// the resulting [GetResult::range] reports the returned range,
+/// not the requested.
+#[tokio::test]
+async fn test_get_opts_over_range() {
+    let tmp = tempdir().unwrap();
+    let store = MyStore(LocalFileSystem::new_with_prefix(tmp.path()).unwrap());
+    let path = Path::from("foo");
+
+    let expected = Bytes::from_static(b"hello world");
+    store.put(&path, expected.clone()).await.unwrap();
+
+    let opts = GetOptions {
+        range: Some(GetRange::Bounded(0..(expected.len() * 2))),
+        ..Default::default()
+    };
+    let res = store.get_opts(&path, opts).await.unwrap();
+    assert_eq!(res.range, 0..expected.len());
+    assert_eq!(res.bytes().await.unwrap(), expected);
+}
diff --git a/parquet-testing b/parquet-testing
index aafd3fc9df43..4cb3cff24c96 160000
--- a/parquet-testing
+++ b/parquet-testing
@@ -1 +1 @@
-Subproject commit aafd3fc9df431c2625a514fb46626e5614f1d199
+Subproject commit 4cb3cff24c965fb329cdae763eabce47395a68a0
diff --git a/parquet/CONTRIBUTING.md b/parquet/CONTRIBUTING.md
index 77e9f417e49a..922332b15d64 100644
--- a/parquet/CONTRIBUTING.md
+++ b/parquet/CONTRIBUTING.md
@@ -57,10 +57,13 @@ Run `cargo bench` for benchmarks.
 
 ## Docs
 
-To build documentation, run `cargo doc --no-deps`.
-To compile and view in the browser, run `cargo doc --no-deps --open`.
+To build documentation, run `cargo doc --no-deps --all-features`.
+To compile and view in the browser, run `cargo doc --no-deps --all-features --open`.
 
-## Update Supported Parquet Version
+Before submitting a pull request, run `cargo fmt --all` to format the change.
 
-To update Parquet format to a newer version, check if [parquet-format](https://github.com/sunchao/parquet-format-rs)
-version is available. Then simply update version of `parquet-format` crate in Cargo.toml.
+## Update Parquet Format
+
+To generate the parquet format (thrift definitions) code run [`./regen.sh`](./regen.sh).
+
+You may need to manually patch up doc comments that contain unescaped `[]`
diff --git a/parquet/Cargo.toml b/parquet/Cargo.toml
index 5a8e4c485328..60160a8b3fc1 100644
--- a/parquet/Cargo.toml
+++ b/parquet/Cargo.toml
@@ -17,76 +17,121 @@
 
 [package]
 name = "parquet"
-version = "20.0.0"
-license = "Apache-2.0"
+version = { workspace = true }
+license = { workspace = true }
 description = "Apache Parquet implementation in Rust"
-homepage = "https://github.com/apache/arrow-rs"
-repository = "https://github.com/apache/arrow-rs"
-authors = ["Apache Arrow <dev@arrow.apache.org>"]
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
 keywords = ["arrow", "parquet", "hadoop"]
 readme = "README.md"
-build = "build.rs"
-edition = "2021"
-rust-version = "1.62"
+edition = { workspace = true }
+rust-version = "1.70.0"
+
+[target.'cfg(target_arch = "wasm32")'.dependencies]
+ahash = { version = "0.8", default-features = false, features = ["compile-time-rng"] }
+
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+ahash = { version = "0.8", default-features = false, features = ["runtime-rng"] }
 
 [dependencies]
-ahash = "0.8"
-parquet-format = { version = "4.0.0", default-features = false }
+arrow-array = { workspace = true, optional = true }
+arrow-buffer = { workspace = true, optional = true }
+arrow-cast = { workspace = true, optional = true }
+arrow-csv = { workspace = true, optional = true }
+arrow-data = { workspace = true, optional = true }
+arrow-schema = { workspace = true, optional = true }
+arrow-select = { workspace = true, optional = true }
+arrow-ipc = { workspace = true, optional = true }
+# Intentionally not a path dependency as object_store is released separately
+object_store = { version = "0.9.0", default-features = false, optional = true }
+
 bytes = { version = "1.1", default-features = false, features = ["std"] }
-byteorder = { version = "1", default-features = false }
-thrift = { version = "0.13", default-features = false }
+thrift = { version = "0.17", default-features = false }
 snap = { version = "1.0", default-features = false, optional = true }
 brotli = { version = "3.3", default-features = false, features = ["std"], optional = true }
 flate2 = { version = "1.0", default-features = false, features = ["rust_backend"], optional = true }
-lz4 = { version = "1.23", default-features = false, optional = true }
-zstd = { version = "0.11.1", optional = true, default-features = false }
-chrono = { version = "0.4", default-features = false, features = ["alloc"] }
+lz4_flex = { version = "0.11", default-features = false, features = ["std", "frame"], optional = true }
+zstd = { version = "0.13.0", optional = true, default-features = false }
+chrono = { workspace = true }
 num = { version = "0.4", default-features = false }
 num-bigint = { version = "0.4", default-features = false }
-arrow = { path = "../arrow", version = "20.0.0", optional = true, default-features = false, features = ["ipc"] }
-base64 = { version = "0.13", default-features = false, features = ["std"], optional = true }
-clap = { version = "3", default-features = false, features = ["std", "derive", "env"], optional = true }
+base64 = { version = "0.21", default-features = false, features = ["std", ], optional = true }
+clap = { version = "4.1", default-features = false, features = ["std", "derive", "env", "help", "error-context", "usage"], optional = true }
+serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
 serde_json = { version = "1.0", default-features = false, features = ["std"], optional = true }
 seq-macro = { version = "0.3", default-features = false }
-rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
 futures = { version = "0.3", default-features = false, features = ["std"], optional = true }
-tokio = { version = "1.0", optional = true, default-features = false, features = ["macros", "fs", "rt", "io-util"] }
-hashbrown = { version = "0.12", default-features = false }
+tokio = { version = "1.0", optional = true, default-features = false, features = ["macros", "rt", "io-util"] }
+hashbrown = { version = "0.14", default-features = false }
+twox-hash = { version = "1.6", default-features = false }
+paste = { version = "1.0" }
+half = { version = "2.1", default-features = false, features = ["num-traits"] }
 
 [dev-dependencies]
-base64 = { version = "0.13", default-features = false, features = ["std"] }
-criterion = { version = "0.3", default-features = false }
+base64 = { version = "0.21", default-features = false, features = ["std"] }
+criterion = { version = "0.5", default-features = false }
 snap = { version = "1.0", default-features = false }
 tempfile = { version = "3.0", default-features = false }
 brotli = { version = "3.3", default-features = false, features = ["std"] }
 flate2 = { version = "1.0", default-features = false, features = ["rust_backend"] }
-lz4 = { version = "1.23", default-features = false }
-zstd = { version = "0.11", default-features = false }
+lz4_flex = { version = "0.11", default-features = false, features = ["std", "frame"] }
+zstd = { version = "0.13", default-features = false }
 serde_json = { version = "1.0", features = ["std"], default-features = false }
-arrow = { path = "../arrow", version = "20.0.0", default-features = false, features = ["ipc", "test_utils", "prettyprint"] }
+arrow = { workspace = true, features = ["ipc", "test_utils", "prettyprint", "json"] }
+tokio = { version = "1.0", default-features = false, features = ["macros", "rt", "io-util", "fs"] }
+rand = { version = "0.8", default-features = false, features = ["std", "std_rng"] }
+object_store = { version = "0.9.0", default-features = false, features = ["azure"] }
 
 [package.metadata.docs.rs]
 all-features = true
 
 [features]
 default = ["arrow", "snap", "brotli", "flate2", "lz4", "zstd", "base64"]
+# Enable lz4
+lz4 = ["lz4_flex"]
 # Enable arrow reader/writer APIs
-arrow = ["dep:arrow", "base64"]
+arrow = ["base64", "arrow-array", "arrow-buffer", "arrow-cast", "arrow-data", "arrow-schema", "arrow-select", "arrow-ipc"]
 # Enable CLI tools
-cli = ["json", "base64", "clap", "arrow/csv"]
+cli = ["json", "base64", "clap", "arrow-csv", "serde"]
 # Enable JSON APIs
-json = ["serde_json"]
+json = ["serde_json", "base64"]
 # Enable internal testing APIs
 test_common = ["arrow/test_utils"]
 # Experimental, unstable functionality primarily used for testing
 experimental = []
 # Enable async APIs
 async = ["futures", "tokio"]
+# Enable object_store integration
+object_store = ["dep:object_store", "async"]
+
+[[example]]
+name = "read_parquet"
+required-features = ["arrow"]
+path = "./examples/read_parquet.rs"
+
+[[example]]
+name = "async_read_parquet"
+required-features = ["arrow", "async"]
+path = "./examples/async_read_parquet.rs"
+
+[[example]]
+name = "read_with_rowgroup"
+required-features = ["arrow", "async"]
+path = "./examples/read_with_rowgroup.rs"
+
+[[test]]
+name = "arrow_writer_layout"
+required-features = ["arrow"]
 
 [[bin]]
 name = "parquet-read"
 required-features = ["cli"]
 
+[[bin]]
+name = "parquet-rewrite"
+required-features = ["arrow", "cli"]
+
 [[bin]]
 name = "parquet-schema"
 required-features = ["cli"]
@@ -95,8 +140,24 @@ required-features = ["cli"]
 name = "parquet-rowcount"
 required-features = ["cli"]
 
+[[bin]]
+name = "parquet-concat"
+required-features = ["cli"]
+
 [[bin]]
 name = "parquet-fromcsv"
+required-features = ["arrow", "cli", "snap", "brotli", "flate2", "lz4", "zstd"]
+
+[[bin]]
+name = "parquet-show-bloom-filter"
+required-features = ["cli"]
+
+[[bin]]
+name = "parquet-layout"
+required-features = ["cli"]
+
+[[bin]]
+name = "parquet-index"
 required-features = ["cli"]
 
 [[bench]]
@@ -109,5 +170,20 @@ name = "arrow_reader"
 required-features = ["arrow", "test_common", "experimental"]
 harness = false
 
+[[bench]]
+name = "compression"
+required-features = ["experimental", "default"]
+harness = false
+
+[[bench]]
+name = "encoding"
+required-features = ["experimental", "default"]
+harness = false
+
+
+[[bench]]
+name = "metadata"
+harness = false
+
 [lib]
 bench = false
diff --git a/parquet/README.md b/parquet/README.md
index 689a664b6326..e5b53050b70c 100644
--- a/parquet/README.md
+++ b/parquet/README.md
@@ -24,7 +24,9 @@
 
 This crate contains the official Native Rust implementation of [Apache Parquet](https://parquet.apache.org/), which is part of the [Apache Arrow](https://arrow.apache.org/) project.
 
-See [crate documentation](https://docs.rs/parquet/latest/parquet/) for examples and the full API.
+See the [API documentation](https://docs.rs/parquet/latest) for examples and the full API.
+
+The API documentation for most recent, unreleased code is available [here](https://arrow.apache.org/rust/parquet/index.html).
 
 ## Rust Version Compatibility
 
@@ -47,6 +49,7 @@ The `parquet` crate provides the following features which may be enabled in your
 - `flate2` (default) - support for parquet using `gzip` compression
 - `lz4` (default) - support for parquet using `lz4` compression
 - `zstd` (default) - support for parquet using `zstd` compression
+- `snap` (default) - support for parquet using `snappy` compression
 - `cli` - parquet [CLI tools](https://github.com/apache/arrow-rs/tree/master/parquet/src/bin)
 - `experimental` - Experimental APIs which may change, even between minor releases
 
@@ -64,8 +67,8 @@ The `parquet` crate provides the following features which may be enabled in your
   - [x] Primitive column value writers
   - [ ] Row record writer
   - [x] Arrow record writer
-  - [ ] Async support
-- [ ] Predicate pushdown
+  - [x] Async support
+- [x] Predicate pushdown
 - [x] Parquet format 4.0.0 support
 
 ## License
diff --git a/parquet/benches/arrow_reader.rs b/parquet/benches/arrow_reader.rs
index a3c904505c25..7eed86d2826e 100644
--- a/parquet/benches/arrow_reader.rs
+++ b/parquet/benches/arrow_reader.rs
@@ -17,10 +17,16 @@
 
 use arrow::array::Array;
 use arrow::datatypes::DataType;
+use arrow_schema::Field;
 use criterion::measurement::WallTime;
 use criterion::{criterion_group, criterion_main, BenchmarkGroup, Criterion};
 use num::FromPrimitive;
+use num_bigint::BigInt;
+use parquet::arrow::array_reader::{
+    make_byte_array_reader, make_fixed_len_byte_array_reader, ListArrayReader,
+};
 use parquet::basic::Type;
+use parquet::data_type::{ByteArray, FixedLenByteArrayType};
 use parquet::util::{DataPageBuilder, DataPageBuilderImpl, InMemoryPageIterator};
 use parquet::{
     arrow::array_reader::ArrayReader,
@@ -43,6 +49,19 @@ fn build_test_schema() -> SchemaDescPtr {
             OPTIONAL BYTE_ARRAY optional_string_leaf (UTF8);
             REQUIRED INT64 mandatory_int64_leaf;
             OPTIONAL INT64 optional_int64_leaf;
+            REQUIRED INT32 mandatory_decimal1_leaf (DECIMAL(8,2));
+            OPTIONAL INT32 optional_decimal1_leaf (DECIMAL(8,2));
+            REQUIRED INT64 mandatory_decimal2_leaf (DECIMAL(16,2));
+            OPTIONAL INT64 optional_decimal2_leaf (DECIMAL(16,2));
+            REQUIRED BYTE_ARRAY mandatory_decimal3_leaf (DECIMAL(16,2));
+            OPTIONAL BYTE_ARRAY optional_decimal3_leaf (DECIMAL(16,2));
+            REQUIRED FIXED_LEN_BYTE_ARRAY (16) mandatory_decimal4_leaf (DECIMAL(16,2));
+            OPTIONAL FIXED_LEN_BYTE_ARRAY (16) optional_decimal4_leaf (DECIMAL(16,2));
+            OPTIONAL GROUP string_list (LIST) {
+                repeated group list {
+                    optional BYTE_ARRAY element (UTF8);
+                }
+            }
         }
         ";
     parse_message_type(message_type)
@@ -55,17 +74,83 @@ const NUM_ROW_GROUPS: usize = 1;
 const PAGES_PER_GROUP: usize = 2;
 const VALUES_PER_PAGE: usize = 10_000;
 const BATCH_SIZE: usize = 8192;
+const MAX_LIST_LEN: usize = 10;
 const EXPECTED_VALUE_COUNT: usize = NUM_ROW_GROUPS * PAGES_PER_GROUP * VALUES_PER_PAGE;
 
 pub fn seedable_rng() -> StdRng {
     StdRng::seed_from_u64(42)
 }
 
+// support byte array for decimal
+fn build_encoded_decimal_bytes_page_iterator<T>(
+    column_desc: ColumnDescPtr,
+    null_density: f32,
+    encoding: Encoding,
+    min: i128,
+    max: i128,
+) -> impl PageIterator + Clone
+where
+    T: parquet::data_type::DataType,
+    T::T: From<Vec<u8>>,
+{
+    let max_def_level = column_desc.max_def_level();
+    let max_rep_level = column_desc.max_rep_level();
+    let rep_levels = vec![0; VALUES_PER_PAGE];
+    let mut rng = seedable_rng();
+    let mut pages: Vec<Vec<parquet::column::page::Page>> = Vec::new();
+    for _i in 0..NUM_ROW_GROUPS {
+        let mut column_chunk_pages = Vec::new();
+        for _j in 0..PAGES_PER_GROUP {
+            // generate page
+            let mut values = Vec::with_capacity(VALUES_PER_PAGE);
+            let mut def_levels = Vec::with_capacity(VALUES_PER_PAGE);
+            for _k in 0..VALUES_PER_PAGE {
+                let def_level = if rng.gen::<f32>() < null_density {
+                    max_def_level - 1
+                } else {
+                    max_def_level
+                };
+                if def_level == max_def_level {
+                    // create the decimal value
+                    let value = rng.gen_range(min..max);
+                    // decimal of parquet use the big-endian to store
+                    let bytes = match column_desc.physical_type() {
+                        Type::BYTE_ARRAY => {
+                            // byte array use the unfixed size
+                            let big_int = BigInt::from(value);
+                            big_int.to_signed_bytes_be()
+                        }
+                        Type::FIXED_LEN_BYTE_ARRAY => {
+                            assert_eq!(column_desc.type_length(), 16);
+                            // fixed length byte array use the fixed size
+                            // the size is 16
+                            value.to_be_bytes().to_vec()
+                        }
+                        _ => unimplemented!(),
+                    };
+                    let value = T::T::from(bytes);
+                    values.push(value);
+                }
+                def_levels.push(def_level);
+            }
+            let mut page_builder =
+                DataPageBuilderImpl::new(column_desc.clone(), values.len() as u32, true);
+            page_builder.add_rep_levels(max_rep_level, &rep_levels);
+            page_builder.add_def_levels(max_def_level, &def_levels);
+            page_builder.add_values::<T>(encoding, &values);
+            column_chunk_pages.push(page_builder.consume());
+        }
+        pages.push(column_chunk_pages);
+    }
+    InMemoryPageIterator::new(pages)
+}
+
 fn build_encoded_primitive_page_iterator<T>(
-    schema: SchemaDescPtr,
     column_desc: ColumnDescPtr,
     null_density: f32,
     encoding: Encoding,
+    min: usize,
+    max: usize,
 ) -> impl PageIterator + Clone
 where
     T: parquet::data_type::DataType,
@@ -89,8 +174,7 @@ where
                     max_def_level
                 };
                 if def_level == max_def_level {
-                    let value =
-                        FromPrimitive::from_usize(rng.gen_range(0..1000)).unwrap();
+                    let value = FromPrimitive::from_usize(rng.gen_range(min..max)).unwrap();
                     values.push(value);
                 }
                 def_levels.push(def_level);
@@ -105,11 +189,10 @@ where
         pages.push(column_chunk_pages);
     }
 
-    InMemoryPageIterator::new(schema, column_desc, pages)
+    InMemoryPageIterator::new(pages)
 }
 
 fn build_dictionary_encoded_primitive_page_iterator<T>(
-    schema: SchemaDescPtr,
     column_desc: ColumnDescPtr,
     null_density: f32,
 ) -> impl PageIterator + Clone
@@ -174,11 +257,10 @@ where
         pages.push(column_chunk_pages.into());
     }
 
-    InMemoryPageIterator::new(schema, column_desc, pages)
+    InMemoryPageIterator::new(pages)
 }
 
 fn build_plain_encoded_string_page_iterator(
-    schema: SchemaDescPtr,
     column_desc: ColumnDescPtr,
     null_density: f32,
 ) -> impl PageIterator + Clone {
@@ -200,10 +282,8 @@ fn build_plain_encoded_string_page_iterator(
                     max_def_level
                 };
                 if def_level == max_def_level {
-                    let string_value =
-                        format!("Test value {}, row group: {}, page: {}", k, i, j);
-                    values
-                        .push(parquet::data_type::ByteArray::from(string_value.as_str()));
+                    let string_value = format!("Test value {k}, row group: {i}, page: {j}");
+                    values.push(parquet::data_type::ByteArray::from(string_value.as_str()));
                 }
                 def_levels.push(def_level);
             }
@@ -217,11 +297,10 @@ fn build_plain_encoded_string_page_iterator(
         pages.push(column_chunk_pages);
     }
 
-    InMemoryPageIterator::new(schema, column_desc, pages)
+    InMemoryPageIterator::new(pages)
 }
 
 fn build_dictionary_encoded_string_page_iterator(
-    schema: SchemaDescPtr,
     column_desc: ColumnDescPtr,
     null_density: f32,
 ) -> impl PageIterator + Clone {
@@ -232,7 +311,7 @@ fn build_dictionary_encoded_string_page_iterator(
     // generate 1% unique values
     const NUM_UNIQUE_VALUES: usize = VALUES_PER_PAGE / 100;
     let unique_values = (0..NUM_UNIQUE_VALUES)
-        .map(|x| format!("Dictionary value {}", x))
+        .map(|x| format!("Dictionary value {x}"))
         .collect::<Vec<_>>();
     let mut rng = seedable_rng();
     let mut pages: Vec<Vec<parquet::column::page::Page>> = Vec::new();
@@ -252,8 +331,7 @@ fn build_dictionary_encoded_string_page_iterator(
                 };
                 if def_level == max_def_level {
                     // select random value from list of unique values
-                    let string_value =
-                        unique_values[rng.gen_range(0..NUM_UNIQUE_VALUES)].as_str();
+                    let string_value = unique_values[rng.gen_range(0..NUM_UNIQUE_VALUES)].as_str();
                     values.push(parquet::data_type::ByteArray::from(string_value));
                 }
                 def_levels.push(def_level);
@@ -283,7 +361,65 @@ fn build_dictionary_encoded_string_page_iterator(
         pages.push(column_chunk_pages.into());
     }
 
-    InMemoryPageIterator::new(schema, column_desc, pages)
+    InMemoryPageIterator::new(pages)
+}
+
+fn build_string_list_page_iterator(
+    column_desc: ColumnDescPtr,
+    null_density: f32,
+) -> impl PageIterator + Clone {
+    let max_def_level = column_desc.max_def_level();
+    let max_rep_level = column_desc.max_rep_level();
+    assert_eq!(max_def_level, 3);
+    assert_eq!(max_rep_level, 1);
+
+    let mut rng = seedable_rng();
+    let mut pages: Vec<Vec<parquet::column::page::Page>> = Vec::new();
+    for i in 0..NUM_ROW_GROUPS {
+        let mut column_chunk_pages = Vec::new();
+        for j in 0..PAGES_PER_GROUP {
+            // generate page
+            let mut values: Vec<ByteArray> = Vec::with_capacity(VALUES_PER_PAGE * MAX_LIST_LEN);
+            let mut def_levels = Vec::with_capacity(VALUES_PER_PAGE * MAX_LIST_LEN);
+            let mut rep_levels = Vec::with_capacity(VALUES_PER_PAGE * MAX_LIST_LEN);
+            for k in 0..VALUES_PER_PAGE {
+                rep_levels.push(0);
+                if rng.gen::<f32>() < null_density {
+                    // Null list
+                    def_levels.push(0);
+                    continue;
+                }
+                let len = rng.gen_range(0..MAX_LIST_LEN);
+                if len == 0 {
+                    // Empty list
+                    def_levels.push(1);
+                    continue;
+                }
+
+                (1..len).for_each(|_| rep_levels.push(1));
+
+                for l in 0..len {
+                    if rng.gen::<f32>() < null_density {
+                        // Null element
+                        def_levels.push(2);
+                    } else {
+                        def_levels.push(3);
+                        let value = format!("Test value {k}[{l}], row group: {i}, page: {j}");
+                        values.push(value.as_str().into());
+                    }
+                }
+            }
+            let mut page_builder =
+                DataPageBuilderImpl::new(column_desc.clone(), values.len() as u32, true);
+            page_builder.add_rep_levels(max_rep_level, &rep_levels);
+            page_builder.add_def_levels(max_def_level, &def_levels);
+            page_builder.add_values::<ByteArrayType>(Encoding::PLAIN, &values);
+            column_chunk_pages.push(page_builder.consume());
+        }
+        pages.push(column_chunk_pages);
+    }
+
+    InMemoryPageIterator::new(pages)
 }
 
 fn bench_array_reader(mut array_reader: Box<dyn ArrayReader>) -> usize {
@@ -320,6 +456,7 @@ fn bench_array_reader_skip(mut array_reader: Box<dyn ArrayReader>) -> usize {
     }
     total_count
 }
+
 fn create_primitive_array_reader(
     page_iterator: impl PageIterator + 'static,
     column_desc: ColumnDescPtr,
@@ -327,32 +464,41 @@ fn create_primitive_array_reader(
     use parquet::arrow::array_reader::PrimitiveArrayReader;
     match column_desc.physical_type() {
         Type::INT32 => {
-            let reader = PrimitiveArrayReader::<Int32Type>::new(
-                Box::new(page_iterator),
-                column_desc,
-                None,
-            )
-            .unwrap();
+            let reader =
+                PrimitiveArrayReader::<Int32Type>::new(Box::new(page_iterator), column_desc, None)
+                    .unwrap();
             Box::new(reader)
         }
         Type::INT64 => {
-            let reader = PrimitiveArrayReader::<Int64Type>::new(
-                Box::new(page_iterator),
-                column_desc,
-                None,
-            )
-            .unwrap();
+            let reader =
+                PrimitiveArrayReader::<Int64Type>::new(Box::new(page_iterator), column_desc, None)
+                    .unwrap();
             Box::new(reader)
         }
         _ => unreachable!(),
     }
 }
 
+fn create_decimal_by_bytes_reader(
+    page_iterator: impl PageIterator + 'static,
+    column_desc: ColumnDescPtr,
+) -> Box<dyn ArrayReader> {
+    let physical_type = column_desc.physical_type();
+    match physical_type {
+        Type::BYTE_ARRAY => {
+            make_byte_array_reader(Box::new(page_iterator), column_desc, None).unwrap()
+        }
+        Type::FIXED_LEN_BYTE_ARRAY => {
+            make_fixed_len_byte_array_reader(Box::new(page_iterator), column_desc, None).unwrap()
+        }
+        _ => unimplemented!(),
+    }
+}
+
 fn create_string_byte_array_reader(
     page_iterator: impl PageIterator + 'static,
     column_desc: ColumnDescPtr,
 ) -> Box<dyn ArrayReader> {
-    use parquet::arrow::array_reader::make_byte_array_reader;
     make_byte_array_reader(Box::new(page_iterator), column_desc, None).unwrap()
 }
 
@@ -361,22 +507,92 @@ fn create_string_byte_array_dictionary_reader(
     column_desc: ColumnDescPtr,
 ) -> Box<dyn ArrayReader> {
     use parquet::arrow::array_reader::make_byte_array_dictionary_reader;
-    let arrow_type =
-        DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8));
-
-    make_byte_array_dictionary_reader(
-        Box::new(page_iterator),
-        column_desc,
-        Some(arrow_type),
-    )
-    .unwrap()
+    let arrow_type = DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8));
+
+    make_byte_array_dictionary_reader(Box::new(page_iterator), column_desc, Some(arrow_type))
+        .unwrap()
+}
+
+fn create_string_list_reader(
+    page_iterator: impl PageIterator + 'static,
+    column_desc: ColumnDescPtr,
+) -> Box<dyn ArrayReader> {
+    let items = create_string_byte_array_reader(page_iterator, column_desc);
+    let field = Field::new("item", DataType::Utf8, true);
+    let data_type = DataType::List(Arc::new(field));
+    Box::new(ListArrayReader::<i32>::new(items, data_type, 2, 1, true))
+}
+
+fn bench_byte_decimal<T>(
+    group: &mut BenchmarkGroup<WallTime>,
+    mandatory_column_desc: &ColumnDescPtr,
+    optional_column_desc: &ColumnDescPtr,
+    min: i128,
+    max: i128,
+) where
+    T: parquet::data_type::DataType,
+    T::T: From<Vec<u8>>,
+{
+    // all are plain encoding
+    let mut count: usize = 0;
+
+    // plain encoded, no NULLs
+    let data = build_encoded_decimal_bytes_page_iterator::<T>(
+        mandatory_column_desc.clone(),
+        0.0,
+        Encoding::PLAIN,
+        min,
+        max,
+    );
+    group.bench_function("plain encoded, mandatory, no NULLs", |b| {
+        b.iter(|| {
+            let array_reader =
+                create_decimal_by_bytes_reader(data.clone(), mandatory_column_desc.clone());
+            count = bench_array_reader(array_reader);
+        });
+        assert_eq!(count, EXPECTED_VALUE_COUNT);
+    });
+
+    let data = build_encoded_decimal_bytes_page_iterator::<T>(
+        optional_column_desc.clone(),
+        0.0,
+        Encoding::PLAIN,
+        min,
+        max,
+    );
+    group.bench_function("plain encoded, optional, no NULLs", |b| {
+        b.iter(|| {
+            let array_reader =
+                create_decimal_by_bytes_reader(data.clone(), optional_column_desc.clone());
+            count = bench_array_reader(array_reader);
+        });
+        assert_eq!(count, EXPECTED_VALUE_COUNT);
+    });
+
+    // half null
+    let data = build_encoded_decimal_bytes_page_iterator::<T>(
+        optional_column_desc.clone(),
+        0.5,
+        Encoding::PLAIN,
+        min,
+        max,
+    );
+    group.bench_function("plain encoded, optional, half NULLs", |b| {
+        b.iter(|| {
+            let array_reader =
+                create_decimal_by_bytes_reader(data.clone(), optional_column_desc.clone());
+            count = bench_array_reader(array_reader);
+        });
+        assert_eq!(count, EXPECTED_VALUE_COUNT);
+    });
 }
 
 fn bench_primitive<T>(
     group: &mut BenchmarkGroup<WallTime>,
-    schema: &SchemaDescPtr,
     mandatory_column_desc: &ColumnDescPtr,
     optional_column_desc: &ColumnDescPtr,
+    min: usize,
+    max: usize,
 ) where
     T: parquet::data_type::DataType,
     T::T: SampleUniform + FromPrimitive + Copy,
@@ -385,27 +601,27 @@ fn bench_primitive<T>(
 
     // plain encoded, no NULLs
     let data = build_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
         mandatory_column_desc.clone(),
         0.0,
         Encoding::PLAIN,
+        min,
+        max,
     );
     group.bench_function("plain encoded, mandatory, no NULLs", |b| {
         b.iter(|| {
-            let array_reader = create_primitive_array_reader(
-                data.clone(),
-                mandatory_column_desc.clone(),
-            );
+            let array_reader =
+                create_primitive_array_reader(data.clone(), mandatory_column_desc.clone());
             count = bench_array_reader(array_reader);
         });
         assert_eq!(count, EXPECTED_VALUE_COUNT);
     });
 
     let data = build_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
         optional_column_desc.clone(),
         0.0,
         Encoding::PLAIN,
+        min,
+        max,
     );
     group.bench_function("plain encoded, optional, no NULLs", |b| {
         b.iter(|| {
@@ -418,10 +634,11 @@ fn bench_primitive<T>(
 
     // plain encoded, half NULLs
     let data = build_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
         optional_column_desc.clone(),
         0.5,
         Encoding::PLAIN,
+        min,
+        max,
     );
     group.bench_function("plain encoded, optional, half NULLs", |b| {
         b.iter(|| {
@@ -434,27 +651,27 @@ fn bench_primitive<T>(
 
     // binary packed, no NULLs
     let data = build_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
         mandatory_column_desc.clone(),
         0.0,
         Encoding::DELTA_BINARY_PACKED,
+        min,
+        max,
     );
     group.bench_function("binary packed, mandatory, no NULLs", |b| {
         b.iter(|| {
-            let array_reader = create_primitive_array_reader(
-                data.clone(),
-                mandatory_column_desc.clone(),
-            );
+            let array_reader =
+                create_primitive_array_reader(data.clone(), mandatory_column_desc.clone());
             count = bench_array_reader(array_reader);
         });
         assert_eq!(count, EXPECTED_VALUE_COUNT);
     });
 
     let data = build_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
         optional_column_desc.clone(),
         0.0,
         Encoding::DELTA_BINARY_PACKED,
+        min,
+        max,
     );
     group.bench_function("binary packed, optional, no NULLs", |b| {
         b.iter(|| {
@@ -467,27 +684,27 @@ fn bench_primitive<T>(
 
     // binary packed skip , no NULLs
     let data = build_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
         mandatory_column_desc.clone(),
         0.0,
         Encoding::DELTA_BINARY_PACKED,
+        min,
+        max,
     );
     group.bench_function("binary packed skip, mandatory, no NULLs", |b| {
         b.iter(|| {
-            let array_reader = create_primitive_array_reader(
-                data.clone(),
-                mandatory_column_desc.clone(),
-            );
+            let array_reader =
+                create_primitive_array_reader(data.clone(), mandatory_column_desc.clone());
             count = bench_array_reader_skip(array_reader);
         });
         assert_eq!(count, EXPECTED_VALUE_COUNT);
     });
 
     let data = build_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
         optional_column_desc.clone(),
         0.0,
         Encoding::DELTA_BINARY_PACKED,
+        min,
+        max,
     );
     group.bench_function("binary packed skip, optional, no NULLs", |b| {
         b.iter(|| {
@@ -500,10 +717,11 @@ fn bench_primitive<T>(
 
     // binary packed, half NULLs
     let data = build_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
         optional_column_desc.clone(),
         0.5,
         Encoding::DELTA_BINARY_PACKED,
+        min,
+        max,
     );
     group.bench_function("binary packed, optional, half NULLs", |b| {
         b.iter(|| {
@@ -515,27 +733,19 @@ fn bench_primitive<T>(
     });
 
     // dictionary encoded, no NULLs
-    let data = build_dictionary_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
-        mandatory_column_desc.clone(),
-        0.0,
-    );
+    let data =
+        build_dictionary_encoded_primitive_page_iterator::<T>(mandatory_column_desc.clone(), 0.0);
     group.bench_function("dictionary encoded, mandatory, no NULLs", |b| {
         b.iter(|| {
-            let array_reader = create_primitive_array_reader(
-                data.clone(),
-                mandatory_column_desc.clone(),
-            );
+            let array_reader =
+                create_primitive_array_reader(data.clone(), mandatory_column_desc.clone());
             count = bench_array_reader(array_reader);
         });
         assert_eq!(count, EXPECTED_VALUE_COUNT);
     });
 
-    let data = build_dictionary_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
-        optional_column_desc.clone(),
-        0.0,
-    );
+    let data =
+        build_dictionary_encoded_primitive_page_iterator::<T>(optional_column_desc.clone(), 0.0);
     group.bench_function("dictionary encoded, optional, no NULLs", |b| {
         b.iter(|| {
             let array_reader =
@@ -546,11 +756,8 @@ fn bench_primitive<T>(
     });
 
     // dictionary encoded, half NULLs
-    let data = build_dictionary_encoded_primitive_page_iterator::<T>(
-        schema.clone(),
-        optional_column_desc.clone(),
-        0.5,
-    );
+    let data =
+        build_dictionary_encoded_primitive_page_iterator::<T>(optional_column_desc.clone(), 0.5);
     group.bench_function("dictionary encoded, optional, half NULLs", |b| {
         b.iter(|| {
             let array_reader =
@@ -561,6 +768,64 @@ fn bench_primitive<T>(
     });
 }
 
+fn decimal_benches(c: &mut Criterion) {
+    let schema = build_test_schema();
+    // parquet int32, logical type decimal(8,2)
+    let mandatory_decimal1_leaf_desc = schema.column(6);
+    let optional_decimal1_leaf_desc = schema.column(7);
+    let mut group = c.benchmark_group("arrow_array_reader/INT32/Decimal128Array");
+    bench_primitive::<Int32Type>(
+        &mut group,
+        &mandatory_decimal1_leaf_desc,
+        &optional_decimal1_leaf_desc,
+        // precision is 8: the max is 99999999
+        9999000,
+        9999999,
+    );
+    group.finish();
+
+    // parquet int64, logical type decimal(16,2)
+    let mut group = c.benchmark_group("arrow_array_reader/INT64/Decimal128Array");
+    let mandatory_decimal2_leaf_desc = schema.column(8);
+    let optional_decimal2_leaf_desc = schema.column(9);
+    bench_primitive::<Int64Type>(
+        &mut group,
+        &mandatory_decimal2_leaf_desc,
+        &optional_decimal2_leaf_desc,
+        // precision is 16: the max is 9999999999999999
+        9999999999999000,
+        9999999999999999,
+    );
+    group.finish();
+
+    // parquet BYTE_ARRAY, logical type decimal(16,2)
+    let mut group = c.benchmark_group("arrow_array_reader/BYTE_ARRAY/Decimal128Array");
+    let mandatory_decimal3_leaf_desc = schema.column(10);
+    let optional_decimal3_leaf_desc = schema.column(11);
+    bench_byte_decimal::<ByteArrayType>(
+        &mut group,
+        &mandatory_decimal3_leaf_desc,
+        &optional_decimal3_leaf_desc,
+        // precision is 16: the max is 9999999999999999
+        9999999999999000,
+        9999999999999999,
+    );
+    group.finish();
+
+    let mut group = c.benchmark_group("arrow_array_reader/FIXED_LENGTH_BYTE_ARRAY/Decimal128Array");
+    let mandatory_decimal4_leaf_desc = schema.column(12);
+    let optional_decimal4_leaf_desc = schema.column(13);
+    bench_byte_decimal::<FixedLenByteArrayType>(
+        &mut group,
+        &mandatory_decimal4_leaf_desc,
+        &optional_decimal4_leaf_desc,
+        // precision is 16: the max is 9999999999999999
+        9999999999999000,
+        9999999999999999,
+    );
+    group.finish();
+}
+
 fn add_benches(c: &mut Criterion) {
     let mut count: usize = 0;
 
@@ -571,15 +836,18 @@ fn add_benches(c: &mut Criterion) {
     let optional_string_column_desc = schema.column(3);
     let mandatory_int64_column_desc = schema.column(4);
     let optional_int64_column_desc = schema.column(5);
+    let string_list_desc = schema.column(14);
+
     // primitive / int32 benchmarks
     // =============================
 
     let mut group = c.benchmark_group("arrow_array_reader/Int32Array");
     bench_primitive::<Int32Type>(
         &mut group,
-        &schema,
         &mandatory_int32_column_desc,
         &optional_int32_column_desc,
+        0,
+        1000,
     );
     group.finish();
 
@@ -589,9 +857,10 @@ fn add_benches(c: &mut Criterion) {
     let mut group = c.benchmark_group("arrow_array_reader/Int64Array");
     bench_primitive::<Int64Type>(
         &mut group,
-        &schema,
         &mandatory_int64_column_desc,
         &optional_int64_column_desc,
+        0,
+        1000,
     );
     group.finish();
 
@@ -601,11 +870,8 @@ fn add_benches(c: &mut Criterion) {
     let mut group = c.benchmark_group("arrow_array_reader/StringArray");
 
     // string, plain encoded, no NULLs
-    let plain_string_no_null_data = build_plain_encoded_string_page_iterator(
-        schema.clone(),
-        mandatory_string_column_desc.clone(),
-        0.0,
-    );
+    let plain_string_no_null_data =
+        build_plain_encoded_string_page_iterator(mandatory_string_column_desc.clone(), 0.0);
     group.bench_function("plain encoded, mandatory, no NULLs", |b| {
         b.iter(|| {
             let array_reader = create_string_byte_array_reader(
@@ -617,11 +883,8 @@ fn add_benches(c: &mut Criterion) {
         assert_eq!(count, EXPECTED_VALUE_COUNT);
     });
 
-    let plain_string_no_null_data = build_plain_encoded_string_page_iterator(
-        schema.clone(),
-        optional_string_column_desc.clone(),
-        0.0,
-    );
+    let plain_string_no_null_data =
+        build_plain_encoded_string_page_iterator(optional_string_column_desc.clone(), 0.0);
     group.bench_function("plain encoded, optional, no NULLs", |b| {
         b.iter(|| {
             let array_reader = create_string_byte_array_reader(
@@ -634,11 +897,8 @@ fn add_benches(c: &mut Criterion) {
     });
 
     // string, plain encoded, half NULLs
-    let plain_string_half_null_data = build_plain_encoded_string_page_iterator(
-        schema.clone(),
-        optional_string_column_desc.clone(),
-        0.5,
-    );
+    let plain_string_half_null_data =
+        build_plain_encoded_string_page_iterator(optional_string_column_desc.clone(), 0.5);
     group.bench_function("plain encoded, optional, half NULLs", |b| {
         b.iter(|| {
             let array_reader = create_string_byte_array_reader(
@@ -651,11 +911,8 @@ fn add_benches(c: &mut Criterion) {
     });
 
     // string, dictionary encoded, no NULLs
-    let dictionary_string_no_null_data = build_dictionary_encoded_string_page_iterator(
-        schema.clone(),
-        mandatory_string_column_desc.clone(),
-        0.0,
-    );
+    let dictionary_string_no_null_data =
+        build_dictionary_encoded_string_page_iterator(mandatory_string_column_desc.clone(), 0.0);
     group.bench_function("dictionary encoded, mandatory, no NULLs", |b| {
         b.iter(|| {
             let array_reader = create_string_byte_array_reader(
@@ -667,11 +924,8 @@ fn add_benches(c: &mut Criterion) {
         assert_eq!(count, EXPECTED_VALUE_COUNT);
     });
 
-    let dictionary_string_no_null_data = build_dictionary_encoded_string_page_iterator(
-        schema.clone(),
-        optional_string_column_desc.clone(),
-        0.0,
-    );
+    let dictionary_string_no_null_data =
+        build_dictionary_encoded_string_page_iterator(optional_string_column_desc.clone(), 0.0);
     group.bench_function("dictionary encoded, optional, no NULLs", |b| {
         b.iter(|| {
             let array_reader = create_string_byte_array_reader(
@@ -684,11 +938,8 @@ fn add_benches(c: &mut Criterion) {
     });
 
     // string, dictionary encoded, half NULLs
-    let dictionary_string_half_null_data = build_dictionary_encoded_string_page_iterator(
-        schema.clone(),
-        optional_string_column_desc.clone(),
-        0.5,
-    );
+    let dictionary_string_half_null_data =
+        build_dictionary_encoded_string_page_iterator(optional_string_column_desc.clone(), 0.5);
     group.bench_function("dictionary encoded, optional, half NULLs", |b| {
         b.iter(|| {
             let array_reader = create_string_byte_array_reader(
@@ -741,7 +992,28 @@ fn add_benches(c: &mut Criterion) {
     });
 
     group.finish();
+
+    // list benchmarks
+    //==============================
+
+    let list_data = build_string_list_page_iterator(string_list_desc.clone(), 0.);
+    let mut group = c.benchmark_group("arrow_array_reader/ListArray");
+    group.bench_function("plain encoded optional strings no NULLs", |b| {
+        b.iter(|| {
+            let reader = create_string_list_reader(list_data.clone(), string_list_desc.clone());
+            count = bench_array_reader(reader);
+        });
+        assert_eq!(count, EXPECTED_VALUE_COUNT);
+    });
+    let list_data = build_string_list_page_iterator(string_list_desc.clone(), 0.5);
+    group.bench_function("plain encoded optional strings half NULLs", |b| {
+        b.iter(|| {
+            let reader = create_string_list_reader(list_data.clone(), string_list_desc.clone());
+            count = bench_array_reader(reader);
+        });
+        assert_eq!(count, EXPECTED_VALUE_COUNT);
+    });
 }
 
-criterion_group!(benches, add_benches);
+criterion_group!(benches, add_benches, decimal_benches,);
 criterion_main!(benches);
diff --git a/parquet/benches/arrow_writer.rs b/parquet/benches/arrow_writer.rs
index ddca1e53c6de..b84e897db2f3 100644
--- a/parquet/benches/arrow_writer.rs
+++ b/parquet/benches/arrow_writer.rs
@@ -17,7 +17,10 @@
 
 #[macro_use]
 extern crate criterion;
+
 use criterion::{Criterion, Throughput};
+use std::env;
+use std::fs::File;
 
 extern crate arrow;
 extern crate parquet;
@@ -26,6 +29,7 @@ use std::sync::Arc;
 
 use arrow::datatypes::*;
 use arrow::{record_batch::RecordBatch, util::data_gen::*};
+use parquet::file::properties::WriterProperties;
 use parquet::{arrow::ArrowWriter, errors::Result};
 
 fn create_primitive_bench_batch(
@@ -167,17 +171,17 @@ fn create_list_primitive_bench_batch(
     let fields = vec![
         Field::new(
             "_1",
-            DataType::List(Box::new(Field::new("item", DataType::Int32, true))),
+            DataType::List(Arc::new(Field::new("item", DataType::Int32, true))),
             true,
         ),
         Field::new(
             "_2",
-            DataType::List(Box::new(Field::new("item", DataType::Boolean, true))),
+            DataType::List(Arc::new(Field::new("item", DataType::Boolean, true))),
             true,
         ),
         Field::new(
             "_3",
-            DataType::LargeList(Box::new(Field::new("item", DataType::Utf8, true))),
+            DataType::LargeList(Arc::new(Field::new("item", DataType::Utf8, true))),
             true,
         ),
     ];
@@ -198,17 +202,17 @@ fn create_list_primitive_bench_batch_non_null(
     let fields = vec![
         Field::new(
             "_1",
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false))),
+            DataType::List(Arc::new(Field::new("item", DataType::Int32, false))),
             false,
         ),
         Field::new(
             "_2",
-            DataType::List(Box::new(Field::new("item", DataType::Boolean, false))),
+            DataType::List(Arc::new(Field::new("item", DataType::Boolean, false))),
             false,
         ),
         Field::new(
             "_3",
-            DataType::LargeList(Box::new(Field::new("item", DataType::Utf8, false))),
+            DataType::LargeList(Arc::new(Field::new("item", DataType::Utf8, false))),
             false,
         ),
     ];
@@ -229,53 +233,53 @@ fn _create_nested_bench_batch(
     let fields = vec![
         Field::new(
             "_1",
-            DataType::Struct(vec![
+            DataType::Struct(Fields::from(vec![
                 Field::new("_1", DataType::Int8, true),
                 Field::new(
                     "_2",
-                    DataType::Struct(vec![
+                    DataType::Struct(Fields::from(vec![
                         Field::new("_1", DataType::Int8, true),
                         Field::new(
                             "_1",
-                            DataType::Struct(vec![
+                            DataType::Struct(Fields::from(vec![
                                 Field::new("_1", DataType::Int8, true),
                                 Field::new("_2", DataType::Utf8, true),
-                            ]),
+                            ])),
                             true,
                         ),
                         Field::new("_2", DataType::UInt8, true),
-                    ]),
+                    ])),
                     true,
                 ),
-            ]),
+            ])),
             true,
         ),
         Field::new(
             "_2",
-            DataType::LargeList(Box::new(Field::new(
+            DataType::LargeList(Arc::new(Field::new(
                 "item",
-                DataType::List(Box::new(Field::new(
+                DataType::List(Arc::new(Field::new(
                     "item",
-                    DataType::Struct(vec![
+                    DataType::Struct(Fields::from(vec![
                         Field::new(
                             "_1",
-                            DataType::Struct(vec![
+                            DataType::Struct(Fields::from(vec![
                                 Field::new("_1", DataType::Int8, true),
                                 Field::new("_2", DataType::Int16, true),
                                 Field::new("_3", DataType::Int32, true),
-                            ]),
+                            ])),
                             true,
                         ),
                         Field::new(
                             "_2",
-                            DataType::List(Box::new(Field::new(
+                            DataType::List(Arc::new(Field::new(
                                 "",
                                 DataType::FixedSizeBinary(2),
                                 true,
                             ))),
                             true,
                         ),
-                    ]),
+                    ])),
                     true,
                 ))),
                 true,
@@ -294,9 +298,23 @@ fn _create_nested_bench_batch(
 
 #[inline]
 fn write_batch(batch: &RecordBatch) -> Result<()> {
-    // Write batch to an in-memory writer
-    let buffer = vec![];
-    let mut writer = ArrowWriter::try_new(buffer, batch.schema(), None)?;
+    write_batch_with_option(batch, None)
+}
+
+#[inline]
+fn write_batch_enable_bloom_filter(batch: &RecordBatch) -> Result<()> {
+    let option = WriterProperties::builder()
+        .set_bloom_filter_enabled(true)
+        .build();
+
+    write_batch_with_option(batch, Some(option))
+}
+
+#[inline]
+fn write_batch_with_option(batch: &RecordBatch, props: Option<WriterProperties>) -> Result<()> {
+    let path = env::temp_dir().join("arrow_writer.temp");
+    let file = File::create(path).unwrap();
+    let mut writer = ArrowWriter::try_new(file, batch.schema(), props)?;
 
     writer.write(batch)?;
     writer.close()?;
@@ -317,6 +335,10 @@ fn bench_primitive_writer(c: &mut Criterion) {
         b.iter(|| write_batch(&batch).unwrap())
     });
 
+    group.bench_function("4096 values primitive with bloom filter", |b| {
+        b.iter(|| write_batch_enable_bloom_filter(&batch).unwrap())
+    });
+
     let batch = create_primitive_bench_batch_non_null(4096, 0.25, 0.75).unwrap();
     group.throughput(Throughput::Bytes(
         batch
@@ -329,6 +351,10 @@ fn bench_primitive_writer(c: &mut Criterion) {
         b.iter(|| write_batch(&batch).unwrap())
     });
 
+    group.bench_function("4096 values primitive non-null with bloom filter", |b| {
+        b.iter(|| write_batch_enable_bloom_filter(&batch).unwrap())
+    });
+
     let batch = create_bool_bench_batch(4096, 0.25, 0.75).unwrap();
     group.throughput(Throughput::Bytes(
         batch
@@ -365,6 +391,10 @@ fn bench_primitive_writer(c: &mut Criterion) {
         b.iter(|| write_batch(&batch).unwrap())
     });
 
+    group.bench_function("4096 values string with bloom filter", |b| {
+        b.iter(|| write_batch_enable_bloom_filter(&batch).unwrap())
+    });
+
     let batch = create_string_dictionary_bench_batch(4096, 0.25, 0.75).unwrap();
     group.throughput(Throughput::Bytes(
         batch
@@ -377,6 +407,10 @@ fn bench_primitive_writer(c: &mut Criterion) {
         b.iter(|| write_batch(&batch).unwrap())
     });
 
+    group.bench_function("4096 values string dictionary with bloom filter", |b| {
+        b.iter(|| write_batch_enable_bloom_filter(&batch).unwrap())
+    });
+
     let batch = create_string_bench_batch_non_null(4096, 0.25, 0.75).unwrap();
     group.throughput(Throughput::Bytes(
         batch
@@ -389,6 +423,10 @@ fn bench_primitive_writer(c: &mut Criterion) {
         b.iter(|| write_batch(&batch).unwrap())
     });
 
+    group.bench_function("4096 values string non-null with bloom filter", |b| {
+        b.iter(|| write_batch_enable_bloom_filter(&batch).unwrap())
+    });
+
     group.finish();
 }
 
diff --git a/parquet/benches/compression.rs b/parquet/benches/compression.rs
new file mode 100644
index 000000000000..2275a89405d9
--- /dev/null
+++ b/parquet/benches/compression.rs
@@ -0,0 +1,96 @@
+// 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.
+
+use criterion::*;
+use parquet::basic::{BrotliLevel, Compression, GzipLevel, ZstdLevel};
+use parquet::compression::create_codec;
+use rand::distributions::Alphanumeric;
+use rand::prelude::*;
+
+fn do_bench(c: &mut Criterion, name: &str, uncompressed: &[u8]) {
+    let codecs = [
+        Compression::BROTLI(BrotliLevel::default()),
+        Compression::GZIP(GzipLevel::default()),
+        Compression::LZ4,
+        Compression::LZ4_RAW,
+        Compression::SNAPPY,
+        Compression::GZIP(GzipLevel::default()),
+        Compression::ZSTD(ZstdLevel::default()),
+    ];
+
+    for compression in codecs {
+        let mut codec = create_codec(compression, &Default::default())
+            .unwrap()
+            .unwrap();
+
+        c.bench_function(&format!("compress {compression} - {name}"), |b| {
+            b.iter(|| {
+                let mut out = Vec::new();
+                codec.compress(uncompressed, &mut out).unwrap();
+                out
+            });
+        });
+
+        let mut compressed = Vec::new();
+        codec.compress(uncompressed, &mut compressed).unwrap();
+        println!(
+            "{compression} compressed {} bytes of {name} to {} bytes",
+            uncompressed.len(),
+            compressed.len()
+        );
+
+        c.bench_function(&format!("decompress {compression} - {name}"), |b| {
+            b.iter(|| {
+                let mut out = Vec::new();
+                codec
+                    .decompress(black_box(&compressed), &mut out, Some(uncompressed.len()))
+                    .unwrap();
+                out
+            });
+        });
+    }
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut rng = StdRng::seed_from_u64(42);
+    let rng = &mut rng;
+    const DATA_SIZE: usize = 1024 * 1024;
+
+    let uncompressed: Vec<_> = rng.sample_iter(&Alphanumeric).take(DATA_SIZE).collect();
+    do_bench(c, "alphanumeric", &uncompressed);
+
+    // Create a collection of 64 words
+    let words: Vec<Vec<_>> = (0..64)
+        .map(|_| {
+            let len = rng.gen_range(1..12);
+            rng.sample_iter(&Alphanumeric).take(len).collect()
+        })
+        .collect();
+
+    // Build data by concatenating these words randomly together
+    let mut uncompressed = Vec::with_capacity(DATA_SIZE);
+    while uncompressed.len() < DATA_SIZE {
+        let word = &words[rng.gen_range(0..words.len())];
+        uncompressed.extend_from_slice(&word[..word.len().min(DATA_SIZE - uncompressed.len())])
+    }
+    assert_eq!(uncompressed.len(), DATA_SIZE);
+
+    do_bench(c, "words", &uncompressed);
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/parquet/benches/encoding.rs b/parquet/benches/encoding.rs
new file mode 100644
index 000000000000..bdbca3567a2b
--- /dev/null
+++ b/parquet/benches/encoding.rs
@@ -0,0 +1,83 @@
+// 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.
+
+use criterion::*;
+use parquet::basic::Encoding;
+use parquet::data_type::{DataType, DoubleType, FloatType};
+use parquet::decoding::{get_decoder, Decoder};
+use parquet::encoding::get_encoder;
+use parquet::schema::types::{ColumnDescPtr, ColumnDescriptor, ColumnPath, Type};
+use rand::prelude::*;
+use std::sync::Arc;
+
+fn bench_typed<T: DataType>(c: &mut Criterion, values: &[T::T], encoding: Encoding) {
+    let name = format!(
+        "dtype={}, encoding={:?}",
+        std::any::type_name::<T::T>(),
+        encoding
+    );
+    c.bench_function(&format!("encoding: {}", name), |b| {
+        b.iter(|| {
+            let mut encoder = get_encoder::<T>(encoding).unwrap();
+            encoder.put(values).unwrap();
+            encoder.flush_buffer().unwrap();
+        });
+    });
+
+    let mut encoder = get_encoder::<T>(encoding).unwrap();
+    encoder.put(values).unwrap();
+    let encoded = encoder.flush_buffer().unwrap();
+    println!("{} encoded as {} bytes", name, encoded.len(),);
+
+    let mut buffer = vec![T::T::default(); values.len()];
+    let column_desc_ptr = ColumnDescPtr::new(ColumnDescriptor::new(
+        Arc::new(
+            Type::primitive_type_builder("", T::get_physical_type())
+                .build()
+                .unwrap(),
+        ),
+        0,
+        0,
+        ColumnPath::new(vec![]),
+    ));
+    c.bench_function(&format!("decoding: {}", name), |b| {
+        b.iter(|| {
+            let mut decoder: Box<dyn Decoder<T>> =
+                get_decoder(column_desc_ptr.clone(), encoding).unwrap();
+            decoder.set_data(encoded.clone(), values.len()).unwrap();
+            decoder.get(&mut buffer).unwrap();
+        });
+    });
+}
+
+fn criterion_benchmark(c: &mut Criterion) {
+    let mut rng = StdRng::seed_from_u64(0);
+    let n = 16 * 1024;
+
+    let mut f32s = Vec::new();
+    let mut f64s = Vec::new();
+    for _ in 0..n {
+        f32s.push(rng.gen::<f32>());
+        f64s.push(rng.gen::<f64>());
+    }
+
+    bench_typed::<FloatType>(c, &f32s, Encoding::BYTE_STREAM_SPLIT);
+    bench_typed::<DoubleType>(c, &f64s, Encoding::BYTE_STREAM_SPLIT);
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/parquet/benches/metadata.rs b/parquet/benches/metadata.rs
new file mode 100644
index 000000000000..c817385f6ba9
--- /dev/null
+++ b/parquet/benches/metadata.rs
@@ -0,0 +1,42 @@
+// 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.
+
+use bytes::Bytes;
+use criterion::*;
+use parquet::file::reader::SerializedFileReader;
+use parquet::file::serialized_reader::ReadOptionsBuilder;
+
+fn criterion_benchmark(c: &mut Criterion) {
+    // Read file into memory to isolate filesystem performance
+    let file = "../parquet-testing/data/alltypes_tiny_pages.parquet";
+    let data = std::fs::read(file).unwrap();
+    let data = Bytes::from(data);
+
+    c.bench_function("open(default)", |b| {
+        b.iter(|| SerializedFileReader::new(data.clone()).unwrap())
+    });
+
+    c.bench_function("open(page index)", |b| {
+        b.iter(|| {
+            let options = ReadOptionsBuilder::new().with_page_index().build();
+            SerializedFileReader::new_with_options(data.clone(), options).unwrap()
+        })
+    });
+}
+
+criterion_group!(benches, criterion_benchmark);
+criterion_main!(benches);
diff --git a/parquet/examples/async_read_parquet.rs b/parquet/examples/async_read_parquet.rs
new file mode 100644
index 000000000000..e59cad8055cb
--- /dev/null
+++ b/parquet/examples/async_read_parquet.rs
@@ -0,0 +1,69 @@
+// 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.
+
+use arrow::compute::kernels::cmp::eq;
+use arrow::util::pretty::print_batches;
+use arrow_array::{Int32Array, Scalar};
+use futures::TryStreamExt;
+use parquet::arrow::arrow_reader::{ArrowPredicateFn, RowFilter};
+use parquet::arrow::{ParquetRecordBatchStreamBuilder, ProjectionMask};
+use parquet::errors::Result;
+use std::time::SystemTime;
+use tokio::fs::File;
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> Result<()> {
+    // Create parquet file that will be read.
+    let testdata = arrow::util::test_util::parquet_test_data();
+    let path = format!("{testdata}/alltypes_plain.parquet");
+    let file = File::open(path).await.unwrap();
+
+    // Create a async parquet reader builder with batch_size.
+    // batch_size is the number of rows to read up to buffer once from pages, defaults to 1024
+    let mut builder = ParquetRecordBatchStreamBuilder::new(file)
+        .await
+        .unwrap()
+        .with_batch_size(8192);
+
+    let file_metadata = builder.metadata().file_metadata().clone();
+    let mask = ProjectionMask::roots(file_metadata.schema_descr(), [0, 1, 2]);
+    // Set projection mask to read only root columns 1 and 2.
+    builder = builder.with_projection(mask);
+
+    // Highlight: set `RowFilter`, it'll push down filter predicates to skip IO and decode.
+    // For more specific usage: please refer to https://github.com/apache/arrow-datafusion/blob/master/datafusion/core/src/physical_plan/file_format/parquet/row_filter.rs.
+    let scalar = Int32Array::from(vec![1]);
+    let filter = ArrowPredicateFn::new(
+        ProjectionMask::roots(file_metadata.schema_descr(), [0]),
+        move |record_batch| eq(record_batch.column(0), &Scalar::new(&scalar)),
+    );
+    let row_filter = RowFilter::new(vec![Box::new(filter)]);
+    builder = builder.with_row_filter(row_filter);
+
+    // Build a async parquet reader.
+    let stream = builder.build().unwrap();
+
+    let start = SystemTime::now();
+
+    let result = stream.try_collect::<Vec<_>>().await?;
+
+    println!("took: {} ms", start.elapsed().unwrap().as_millis());
+
+    print_batches(&result).unwrap();
+
+    Ok(())
+}
diff --git a/parquet/examples/read_parquet.rs b/parquet/examples/read_parquet.rs
new file mode 100644
index 000000000000..f374fcd2e1f7
--- /dev/null
+++ b/parquet/examples/read_parquet.rs
@@ -0,0 +1,43 @@
+// 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.
+
+use arrow::util::pretty::print_batches;
+use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
+use parquet::errors::Result;
+use std::fs::File;
+
+fn main() -> Result<()> {
+    // Create parquet file that will be read.
+    let testdata = arrow::util::test_util::parquet_test_data();
+    let path = format!("{testdata}/alltypes_plain.parquet");
+    let file = File::open(path).unwrap();
+
+    // Create a sync parquet reader with batch_size.
+    // batch_size is the number of rows to read up to buffer once from pages, defaults to 1024
+    let parquet_reader = ParquetRecordBatchReaderBuilder::try_new(file)?
+        .with_batch_size(8192)
+        .build()?;
+
+    let mut batches = Vec::new();
+
+    for batch in parquet_reader {
+        batches.push(batch?);
+    }
+
+    print_batches(&batches).unwrap();
+    Ok(())
+}
diff --git a/parquet/examples/read_with_rowgroup.rs b/parquet/examples/read_with_rowgroup.rs
new file mode 100644
index 000000000000..8cccc7fe14ac
--- /dev/null
+++ b/parquet/examples/read_with_rowgroup.rs
@@ -0,0 +1,182 @@
+// 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.
+
+use arrow::util::pretty::print_batches;
+use bytes::{Buf, Bytes};
+use parquet::arrow::arrow_reader::{ParquetRecordBatchReader, RowGroups, RowSelection};
+use parquet::arrow::async_reader::AsyncFileReader;
+use parquet::arrow::{parquet_to_arrow_field_levels, ProjectionMask};
+use parquet::column::page::{PageIterator, PageReader};
+use parquet::errors::{ParquetError, Result};
+use parquet::file::metadata::RowGroupMetaData;
+use parquet::file::reader::{ChunkReader, Length};
+use parquet::file::serialized_reader::SerializedPageReader;
+use std::sync::Arc;
+use tokio::fs::File;
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() -> Result<()> {
+    let testdata = arrow::util::test_util::parquet_test_data();
+    let path = format!("{testdata}/alltypes_plain.parquet");
+    let mut file = File::open(&path).await.unwrap();
+
+    // The metadata could be cached in other places, this example only shows how to read
+    let metadata = file.get_metadata().await?;
+
+    for rg in metadata.row_groups() {
+        let mut rowgroup = InMemoryRowGroup::create(rg.clone(), ProjectionMask::all());
+        rowgroup.async_fetch_data(&mut file, None).await?;
+        let reader = rowgroup.build_reader(1024, None)?;
+
+        for batch in reader {
+            let batch = batch?;
+            print_batches(&[batch])?;
+        }
+    }
+
+    Ok(())
+}
+
+/// Implements [`PageIterator`] for a single column chunk, yielding a single [`PageReader`]
+struct ColumnChunkIterator {
+    reader: Option<Result<Box<dyn PageReader>>>,
+}
+
+impl Iterator for ColumnChunkIterator {
+    type Item = Result<Box<dyn PageReader>>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.reader.take()
+    }
+}
+
+impl PageIterator for ColumnChunkIterator {}
+
+/// An in-memory column chunk
+#[derive(Clone)]
+pub struct ColumnChunkData {
+    offset: usize,
+    data: Bytes,
+}
+
+impl ColumnChunkData {
+    fn get(&self, start: u64) -> Result<Bytes> {
+        let start = start as usize - self.offset;
+        Ok(self.data.slice(start..))
+    }
+}
+
+impl Length for ColumnChunkData {
+    fn len(&self) -> u64 {
+        self.data.len() as u64
+    }
+}
+
+impl ChunkReader for ColumnChunkData {
+    type T = bytes::buf::Reader<Bytes>;
+
+    fn get_read(&self, start: u64) -> Result<Self::T> {
+        Ok(self.get(start)?.reader())
+    }
+
+    fn get_bytes(&self, start: u64, length: usize) -> Result<Bytes> {
+        Ok(self.get(start)?.slice(..length))
+    }
+}
+
+#[derive(Clone)]
+pub struct InMemoryRowGroup {
+    pub metadata: RowGroupMetaData,
+    mask: ProjectionMask,
+    column_chunks: Vec<Option<Arc<ColumnChunkData>>>,
+}
+
+impl RowGroups for InMemoryRowGroup {
+    fn num_rows(&self) -> usize {
+        self.metadata.num_rows() as usize
+    }
+
+    fn column_chunks(&self, i: usize) -> Result<Box<dyn PageIterator>> {
+        match &self.column_chunks[i] {
+            None => Err(ParquetError::General(format!(
+                "Invalid column index {i}, column was not fetched"
+            ))),
+            Some(data) => {
+                let page_reader: Box<dyn PageReader> = Box::new(SerializedPageReader::new(
+                    data.clone(),
+                    self.metadata.column(i),
+                    self.num_rows(),
+                    None,
+                )?);
+
+                Ok(Box::new(ColumnChunkIterator {
+                    reader: Some(Ok(page_reader)),
+                }))
+            }
+        }
+    }
+}
+
+impl InMemoryRowGroup {
+    pub fn create(metadata: RowGroupMetaData, mask: ProjectionMask) -> Self {
+        let column_chunks = metadata.columns().iter().map(|_| None).collect::<Vec<_>>();
+
+        Self {
+            metadata,
+            mask,
+            column_chunks,
+        }
+    }
+
+    pub fn build_reader(
+        &self,
+        batch_size: usize,
+        selection: Option<RowSelection>,
+    ) -> Result<ParquetRecordBatchReader> {
+        let levels = parquet_to_arrow_field_levels(
+            &self.metadata.schema_descr_ptr(),
+            self.mask.clone(),
+            None,
+        )?;
+
+        ParquetRecordBatchReader::try_new_with_row_groups(&levels, self, batch_size, selection)
+    }
+
+    /// fetch data from a reader in sync mode
+    pub async fn async_fetch_data<R: AsyncFileReader>(
+        &mut self,
+        reader: &mut R,
+        _selection: Option<&RowSelection>,
+    ) -> Result<()> {
+        let mut vs = std::mem::take(&mut self.column_chunks);
+        for (leaf_idx, meta) in self.metadata.columns().iter().enumerate() {
+            if self.mask.leaf_included(leaf_idx) {
+                let (start, len) = meta.byte_range();
+                let data = reader
+                    .get_bytes(start as usize..(start + len) as usize)
+                    .await?;
+
+                vs[leaf_idx] = Some(Arc::new(ColumnChunkData {
+                    offset: start as usize,
+                    data,
+                }));
+            }
+        }
+        self.column_chunks = std::mem::take(&mut vs);
+        Ok(())
+    }
+}
diff --git a/parquet/pytest/requirements.in b/parquet/pytest/requirements.in
new file mode 100644
index 000000000000..575fb839a182
--- /dev/null
+++ b/parquet/pytest/requirements.in
@@ -0,0 +1,20 @@
+# 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.
+pytest
+pyspark
+black
+pandas
diff --git a/parquet/pytest/requirements.txt b/parquet/pytest/requirements.txt
new file mode 100644
index 000000000000..7462e8ff3b0d
--- /dev/null
+++ b/parquet/pytest/requirements.txt
@@ -0,0 +1,173 @@
+# 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.
+#
+# This file is autogenerated by pip-compile with python 3.10
+# To update, run:
+#
+#    pip-compile --generate-hashes --resolver=backtracking
+#
+attrs==22.1.0 \
+    --hash=sha256:29adc2665447e5191d0e7c568fde78b21f9672d344281d0c6e1ab085429b22b6 \
+    --hash=sha256:86efa402f67bf2df34f51a335487cf46b1ec130d02b8d39fd248abfd30da551c
+    # via pytest
+black==22.10.0 \
+    --hash=sha256:14ff67aec0a47c424bc99b71005202045dc09270da44a27848d534600ac64fc7 \
+    --hash=sha256:197df8509263b0b8614e1df1756b1dd41be6738eed2ba9e9769f3880c2b9d7b6 \
+    --hash=sha256:1e464456d24e23d11fced2bc8c47ef66d471f845c7b7a42f3bd77bf3d1789650 \
+    --hash=sha256:2039230db3c6c639bd84efe3292ec7b06e9214a2992cd9beb293d639c6402edb \
+    --hash=sha256:21199526696b8f09c3997e2b4db8d0b108d801a348414264d2eb8eb2532e540d \
+    --hash=sha256:2644b5d63633702bc2c5f3754b1b475378fbbfb481f62319388235d0cd104c2d \
+    --hash=sha256:432247333090c8c5366e69627ccb363bc58514ae3e63f7fc75c54b1ea80fa7de \
+    --hash=sha256:444ebfb4e441254e87bad00c661fe32df9969b2bf224373a448d8aca2132b395 \
+    --hash=sha256:5b9b29da4f564ba8787c119f37d174f2b69cdfdf9015b7d8c5c16121ddc054ae \
+    --hash=sha256:5cc42ca67989e9c3cf859e84c2bf014f6633db63d1cbdf8fdb666dcd9e77e3fa \
+    --hash=sha256:5d8f74030e67087b219b032aa33a919fae8806d49c867846bfacde57f43972ef \
+    --hash=sha256:72ef3925f30e12a184889aac03d77d031056860ccae8a1e519f6cbb742736383 \
+    --hash=sha256:819dc789f4498ecc91438a7de64427c73b45035e2e3680c92e18795a839ebb66 \
+    --hash=sha256:915ace4ff03fdfff953962fa672d44be269deb2eaf88499a0f8805221bc68c87 \
+    --hash=sha256:9311e99228ae10023300ecac05be5a296f60d2fd10fff31cf5c1fa4ca4b1988d \
+    --hash=sha256:974308c58d057a651d182208a484ce80a26dac0caef2895836a92dd6ebd725e0 \
+    --hash=sha256:b8b49776299fece66bffaafe357d929ca9451450f5466e997a7285ab0fe28e3b \
+    --hash=sha256:c957b2b4ea88587b46cf49d1dc17681c1e672864fd7af32fc1e9664d572b3458 \
+    --hash=sha256:e41a86c6c650bcecc6633ee3180d80a025db041a8e2398dcc059b3afa8382cd4 \
+    --hash=sha256:f513588da599943e0cde4e32cc9879e825d58720d6557062d1098c5ad80080e1 \
+    --hash=sha256:fba8a281e570adafb79f7755ac8721b6cf1bbf691186a287e990c7929c7692ff
+    # via -r requirements.in
+click==8.1.3 \
+    --hash=sha256:7682dc8afb30297001674575ea00d1814d808d6a36af415a82bd481d37ba7b8e \
+    --hash=sha256:bb4d8133cb15a609f44e8213d9b391b0809795062913b383c62be0ee95b1db48
+    # via black
+exceptiongroup==1.0.4 \
+    --hash=sha256:542adf9dea4055530d6e1279602fa5cb11dab2395fa650b8674eaec35fc4a828 \
+    --hash=sha256:bd14967b79cd9bdb54d97323216f8fdf533e278df937aa2a90089e7d6e06e5ec
+    # via pytest
+iniconfig==1.1.1 \
+    --hash=sha256:011e24c64b7f47f6ebd835bb12a743f2fbe9a26d4cecaa7f53bc4f35ee9da8b3 \
+    --hash=sha256:bc3af051d7d14b2ee5ef9969666def0cd1a000e121eaea580d4a313df4b37f32
+    # via pytest
+mypy-extensions==0.4.3 \
+    --hash=sha256:090fedd75945a69ae91ce1303b5824f428daf5a028d2f6ab8a299250a846f15d \
+    --hash=sha256:2d82818f5bb3e369420cb3c4060a7970edba416647068eb4c5343488a6c604a8
+    # via black
+numpy==1.23.5 \
+    --hash=sha256:01dd17cbb340bf0fc23981e52e1d18a9d4050792e8fb8363cecbf066a84b827d \
+    --hash=sha256:06005a2ef6014e9956c09ba07654f9837d9e26696a0470e42beedadb78c11b07 \
+    --hash=sha256:09b7847f7e83ca37c6e627682f145856de331049013853f344f37b0c9690e3df \
+    --hash=sha256:0aaee12d8883552fadfc41e96b4c82ee7d794949e2a7c3b3a7201e968c7ecab9 \
+    --hash=sha256:0cbe9848fad08baf71de1a39e12d1b6310f1d5b2d0ea4de051058e6e1076852d \
+    --hash=sha256:1b1766d6f397c18153d40015ddfc79ddb715cabadc04d2d228d4e5a8bc4ded1a \
+    --hash=sha256:33161613d2269025873025b33e879825ec7b1d831317e68f4f2f0f84ed14c719 \
+    --hash=sha256:5039f55555e1eab31124a5768898c9e22c25a65c1e0037f4d7c495a45778c9f2 \
+    --hash=sha256:522e26bbf6377e4d76403826ed689c295b0b238f46c28a7251ab94716da0b280 \
+    --hash=sha256:56e454c7833e94ec9769fa0f86e6ff8e42ee38ce0ce1fa4cbb747ea7e06d56aa \
+    --hash=sha256:58f545efd1108e647604a1b5aa809591ccd2540f468a880bedb97247e72db387 \
+    --hash=sha256:5e05b1c973a9f858c74367553e236f287e749465f773328c8ef31abe18f691e1 \
+    --hash=sha256:7903ba8ab592b82014713c491f6c5d3a1cde5b4a3bf116404e08f5b52f6daf43 \
+    --hash=sha256:8969bfd28e85c81f3f94eb4a66bc2cf1dbdc5c18efc320af34bffc54d6b1e38f \
+    --hash=sha256:92c8c1e89a1f5028a4c6d9e3ccbe311b6ba53694811269b992c0b224269e2398 \
+    --hash=sha256:9c88793f78fca17da0145455f0d7826bcb9f37da4764af27ac945488116efe63 \
+    --hash=sha256:a7ac231a08bb37f852849bbb387a20a57574a97cfc7b6cabb488a4fc8be176de \
+    --hash=sha256:abdde9f795cf292fb9651ed48185503a2ff29be87770c3b8e2a14b0cd7aa16f8 \
+    --hash=sha256:af1da88f6bc3d2338ebbf0e22fe487821ea4d8e89053e25fa59d1d79786e7481 \
+    --hash=sha256:b2a9ab7c279c91974f756c84c365a669a887efa287365a8e2c418f8b3ba73fb0 \
+    --hash=sha256:bf837dc63ba5c06dc8797c398db1e223a466c7ece27a1f7b5232ba3466aafe3d \
+    --hash=sha256:ca51fcfcc5f9354c45f400059e88bc09215fb71a48d3768fb80e357f3b457e1e \
+    --hash=sha256:ce571367b6dfe60af04e04a1834ca2dc5f46004ac1cc756fb95319f64c095a96 \
+    --hash=sha256:d208a0f8729f3fb790ed18a003f3a57895b989b40ea4dce4717e9cf4af62c6bb \
+    --hash=sha256:dbee87b469018961d1ad79b1a5d50c0ae850000b639bcb1b694e9981083243b6 \
+    --hash=sha256:e9f4c4e51567b616be64e05d517c79a8a22f3606499941d97bb76f2ca59f982d \
+    --hash=sha256:f063b69b090c9d918f9df0a12116029e274daf0181df392839661c4c7ec9018a \
+    --hash=sha256:f9a909a8bae284d46bbfdefbdd4a262ba19d3bc9921b1e76126b1d21c3c34135
+    # via pandas
+packaging==21.3 \
+    --hash=sha256:dd47c42927d89ab911e606518907cc2d3a1f38bbd026385970643f9c5b8ecfeb \
+    --hash=sha256:ef103e05f519cdc783ae24ea4e2e0f508a9c99b2d4969652eed6a2e1ea5bd522
+    # via pytest
+pandas==1.5.2 \
+    --hash=sha256:0183cb04a057cc38fde5244909fca9826d5d57c4a5b7390c0cc3fa7acd9fa883 \
+    --hash=sha256:1fc87eac0541a7d24648a001d553406f4256e744d92df1df8ebe41829a915028 \
+    --hash=sha256:220b98d15cee0b2cd839a6358bd1f273d0356bf964c1a1aeb32d47db0215488b \
+    --hash=sha256:2552bffc808641c6eb471e55aa6899fa002ac94e4eebfa9ec058649122db5824 \
+    --hash=sha256:315e19a3e5c2ab47a67467fc0362cb36c7c60a93b6457f675d7d9615edad2ebe \
+    --hash=sha256:344021ed3e639e017b452aa8f5f6bf38a8806f5852e217a7594417fb9bbfa00e \
+    --hash=sha256:375262829c8c700c3e7cbb336810b94367b9c4889818bbd910d0ecb4e45dc261 \
+    --hash=sha256:457d8c3d42314ff47cc2d6c54f8fc0d23954b47977b2caed09cd9635cb75388b \
+    --hash=sha256:4aed257c7484d01c9a194d9a94758b37d3d751849c05a0050c087a358c41ad1f \
+    --hash=sha256:530948945e7b6c95e6fa7aa4be2be25764af53fba93fe76d912e35d1c9ee46f5 \
+    --hash=sha256:5ae7e989f12628f41e804847a8cc2943d362440132919a69429d4dea1f164da0 \
+    --hash=sha256:71f510b0efe1629bf2f7c0eadb1ff0b9cf611e87b73cd017e6b7d6adb40e2b3a \
+    --hash=sha256:73f219fdc1777cf3c45fde7f0708732ec6950dfc598afc50588d0d285fddaefc \
+    --hash=sha256:8092a368d3eb7116e270525329a3e5c15ae796ccdf7ccb17839a73b4f5084a39 \
+    --hash=sha256:82ae615826da838a8e5d4d630eb70c993ab8636f0eff13cb28aafc4291b632b5 \
+    --hash=sha256:9608000a5a45f663be6af5c70c3cbe634fa19243e720eb380c0d378666bc7702 \
+    --hash=sha256:a40dd1e9f22e01e66ed534d6a965eb99546b41d4d52dbdb66565608fde48203f \
+    --hash=sha256:b4f5a82afa4f1ff482ab8ded2ae8a453a2cdfde2001567b3ca24a4c5c5ca0db3 \
+    --hash=sha256:c009a92e81ce836212ce7aa98b219db7961a8b95999b97af566b8dc8c33e9519 \
+    --hash=sha256:c218796d59d5abd8780170c937b812c9637e84c32f8271bbf9845970f8c1351f \
+    --hash=sha256:cc3cd122bea268998b79adebbb8343b735a5511ec14efb70a39e7acbc11ccbdc \
+    --hash=sha256:d0d8fd58df5d17ddb8c72a5075d87cd80d71b542571b5f78178fb067fa4e9c72 \
+    --hash=sha256:e18bc3764cbb5e118be139b3b611bc3fbc5d3be42a7e827d1096f46087b395eb \
+    --hash=sha256:e2b83abd292194f350bb04e188f9379d36b8dfac24dd445d5c87575f3beaf789 \
+    --hash=sha256:e7469271497960b6a781eaa930cba8af400dd59b62ec9ca2f4d31a19f2f91090 \
+    --hash=sha256:e9dbacd22555c2d47f262ef96bb4e30880e5956169741400af8b306bbb24a273 \
+    --hash=sha256:f6257b314fc14958f8122779e5a1557517b0f8e500cfb2bd53fa1f75a8ad0af2
+    # via -r requirements.in
+pathspec==0.10.2 \
+    --hash=sha256:88c2606f2c1e818b978540f73ecc908e13999c6c3a383daf3705652ae79807a5 \
+    --hash=sha256:8f6bf73e5758fd365ef5d58ce09ac7c27d2833a8d7da51712eac6e27e35141b0
+    # via black
+platformdirs==2.5.4 \
+    --hash=sha256:1006647646d80f16130f052404c6b901e80ee4ed6bef6792e1f238a8969106f7 \
+    --hash=sha256:af0276409f9a02373d540bf8480021a048711d572745aef4b7842dad245eba10
+    # via black
+pluggy==1.0.0 \
+    --hash=sha256:4224373bacce55f955a878bf9cfa763c1e360858e330072059e10bad68531159 \
+    --hash=sha256:74134bbf457f031a36d68416e1509f34bd5ccc019f0bcc952c7b909d06b37bd3
+    # via pytest
+py4j==0.10.9.5 \
+    --hash=sha256:276a4a3c5a2154df1860ef3303a927460e02e97b047dc0a47c1c3fb8cce34db6 \
+    --hash=sha256:52d171a6a2b031d8a5d1de6efe451cf4f5baff1a2819aabc3741c8406539ba04
+    # via pyspark
+pyparsing==3.0.9 \
+    --hash=sha256:2b020ecf7d21b687f219b71ecad3631f644a47f01403fa1d1036b0c6416d70fb \
+    --hash=sha256:5026bae9a10eeaefb61dab2f09052b9f4307d44aee4eda64b309723d8d206bbc
+    # via packaging
+pyspark==3.3.1 \
+    --hash=sha256:e99fa7de92be406884bfd831c32b9306a3a99de44cfc39a2eefb6ed07445d5fa
+    # via -r requirements.in
+pytest==7.2.0 \
+    --hash=sha256:892f933d339f068883b6fd5a459f03d85bfcb355e4981e146d2c7616c21fef71 \
+    --hash=sha256:c4014eb40e10f11f355ad4e3c2fb2c6c6d1919c73f3b5a433de4708202cade59
+    # via -r requirements.in
+python-dateutil==2.8.2 \
+    --hash=sha256:0123cacc1627ae19ddf3c27a5de5bd67ee4586fbdd6440d9748f8abb483d3e86 \
+    --hash=sha256:961d03dc3453ebbc59dbdea9e4e11c5651520a876d0f4db161e8674aae935da9
+    # via pandas
+pytz==2022.6 \
+    --hash=sha256:222439474e9c98fced559f1709d89e6c9cbf8d79c794ff3eb9f8800064291427 \
+    --hash=sha256:e89512406b793ca39f5971bc999cc538ce125c0e51c27941bef4568b460095e2
+    # via pandas
+six==1.16.0 \
+    --hash=sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926 \
+    --hash=sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254
+    # via python-dateutil
+tomli==2.0.1 \
+    --hash=sha256:939de3e7a6161af0c887ef91b7d41a53e7c5a1ca976325f429cb46ea9bc30ecc \
+    --hash=sha256:de526c12914f0c550d15924c62d72abc48d6fe7364aa87328337a31007fe8a4f
+    # via
+    #   black
+    #   pytest
diff --git a/parquet/pytest/test_parquet_integration.py b/parquet/pytest/test_parquet_integration.py
new file mode 100755
index 000000000000..e0846d4e779f
--- /dev/null
+++ b/parquet/pytest/test_parquet_integration.py
@@ -0,0 +1,110 @@
+# 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 pyspark.sql
+import pandas as pd
+from tempfile import NamedTemporaryFile, TemporaryDirectory
+import subprocess
+import pathlib
+import pytest
+
+
+def create_data_and_spark_df(n):
+    spark = pyspark.sql.SparkSession.builder.getOrCreate()
+    spark.conf.set("parquet.bloom.filter.enabled", True)
+    spark.conf.set("parquet.bloom.filter.expected.ndv", 10)
+    spark.conf.set("parquet.bloom.filter.max.bytes", 32)
+    data = [(f"id-{i % 10}", f"name-{i%10}") for i in range(n)]
+    df = spark.createDataFrame(data, ["id", "name"]).repartition(1)
+    return data, df
+
+
+def create_data_and_pandas_df(n):
+    data = [(f"id-{i % 10}", f"name-{i%10}") for i in range(n)]
+    df = pd.DataFrame(data, columns=["id", "name"])
+    return data, df
+
+
+def get_expected_output(data):
+    expected = ["Row group #0", "=" * 80]
+    for v in data:
+        expected.append(f"Value {v[0]} is present in bloom filter")
+    for v in data:
+        expected.append(f"Value {v[1]} is absent in bloom filter")
+    expected = "\n".join(expected) + "\n"
+    return expected.encode("utf-8")
+
+
+def get_from_csv_cli_output(schema_file, output_file, csv_file):
+    args = [
+        "parquet-fromcsv",
+        "--schema",
+        schema_file,
+        "--enable-bloom-filter",
+        "true",
+        "--input-file",
+        csv_file,
+        "--output-file",
+        output_file,
+    ]
+    return subprocess.check_output(args)
+
+
+def get_show_filter_cli_output(output_dir, data, col_name="id"):
+    # take the first (and only) parquet file
+    (parquet_file,) = sorted(pathlib.Path(output_dir).glob("*.parquet"))
+    args = [
+        "parquet-show-bloom-filter",
+        parquet_file,
+        col_name,
+    ]
+    for v in data:
+        args.extend([v[0]])
+    for v in data:
+        args.extend([v[1]])
+    return subprocess.check_output(args)
+
+
+SCHEMA = b"""message schema {
+    required binary id (UTF8);
+    required binary name (UTF8);
+}"""
+
+
+@pytest.mark.parametrize("n", [1, 10])
+class TestParquetIntegration:
+    def test_pyspark_bloom_filter(self, n):
+        data, df = create_data_and_spark_df(n)
+        with TemporaryDirectory() as output_dir:
+            df.write.parquet(output_dir, mode="overwrite")
+            cli_output = get_show_filter_cli_output(output_dir, data)
+            assert cli_output == get_expected_output(data)
+
+    def test_bloom_filter_round_trip(self, n):
+        data, df = create_data_and_pandas_df(n)
+        with NamedTemporaryFile(suffix=".csv") as csv_file, NamedTemporaryFile(
+            suffix=".schema"
+        ) as schema_file, TemporaryDirectory() as output_dir:
+            schema_file.write(SCHEMA)
+            schema_file.flush()
+            df.to_csv(csv_file.name, index=False, header=True)
+            parquet_file = pathlib.Path(output_dir) / "output.parquet"
+            cli_output = get_from_csv_cli_output(
+                schema_file.name, parquet_file, csv_file.name
+            )
+            assert cli_output == b""
+            cli_output = get_show_filter_cli_output(output_dir, data)
+            assert cli_output == get_expected_output(data)
diff --git a/parquet/regen.sh b/parquet/regen.sh
new file mode 100755
index 000000000000..f2d8158765c4
--- /dev/null
+++ b/parquet/regen.sh
@@ -0,0 +1,39 @@
+#!/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.
+
+REVISION=46cc3a0647d301bb9579ca8dd2cc356caf2a72d2
+
+SOURCE_DIR="$(cd "$(dirname "${BASH_SOURCE[0]:-$0}")" && pwd)"
+
+docker run -v $SOURCE_DIR:/thrift -it archlinux /bin/bash -c "\
+  pacman -Sy --noconfirm wget thrift && \
+  wget https://raw.githubusercontent.com/apache/parquet-format/$REVISION/src/main/thrift/parquet.thrift -O /tmp/parquet.thrift && \
+  thrift --gen rs /tmp/parquet.thrift && \
+  echo 'Removing TProcessor' && \
+  sed -i '/use thrift::server::TProcessor;/d' parquet.rs && \
+  echo 'Replacing TSerializable' && \
+  sed -i 's/impl TSerializable for/impl crate::thrift::TSerializable for/g' parquet.rs && \
+  echo 'Rewriting write_to_out_protocol' && \
+  sed -i 's/fn write_to_out_protocol(&self, o_prot: &mut dyn TOutputProtocol)/fn write_to_out_protocol<T: TOutputProtocol>(\&self, o_prot: \&mut T)/g' parquet.rs && \
+  echo 'Rewriting read_from_in_protocol' && \
+  sed -i 's/fn read_from_in_protocol(i_prot: &mut dyn TInputProtocol)/fn read_from_in_protocol<T: TInputProtocol>(i_prot: \&mut T)/g' parquet.rs && \
+  echo 'Rewriting return value expectations' && \
+  sed -i 's/Ok(ret.expect(\"return value should have been constructed\"))/ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, \"return value should have been constructed\")))/g' parquet.rs && \
+  mv parquet.rs /thrift/src/format.rs
+  "
diff --git a/parquet/src/arrow/array_reader/builder.rs b/parquet/src/arrow/array_reader/builder.rs
index e389158a1931..bb3f403358ee 100644
--- a/parquet/src/arrow/array_reader/builder.rs
+++ b/parquet/src/arrow/array_reader/builder.rs
@@ -17,55 +17,55 @@
 
 use std::sync::Arc;
 
-use arrow::datatypes::{DataType, IntervalUnit, SchemaRef};
+use arrow_schema::{DataType, Fields, SchemaBuilder};
 
 use crate::arrow::array_reader::empty_array::make_empty_array_reader;
+use crate::arrow::array_reader::fixed_len_byte_array::make_fixed_len_byte_array_reader;
 use crate::arrow::array_reader::{
     make_byte_array_dictionary_reader, make_byte_array_reader, ArrayReader,
-    ComplexObjectArrayReader, ListArrayReader, MapArrayReader, NullArrayReader,
-    PrimitiveArrayReader, RowGroupCollection, StructArrayReader,
+    FixedSizeListArrayReader, ListArrayReader, MapArrayReader, NullArrayReader,
+    PrimitiveArrayReader, RowGroups, StructArrayReader,
 };
-use crate::arrow::buffer::converter::{
-    DecimalArrayConverter, DecimalByteArrayConvert, DecimalFixedLengthByteArrayConverter,
-    FixedLenBinaryConverter, FixedSizeArrayConverter, Int96ArrayConverter,
-    Int96Converter, IntervalDayTimeArrayConverter, IntervalDayTimeConverter,
-    IntervalYearMonthArrayConverter, IntervalYearMonthConverter,
-};
-use crate::arrow::schema::{convert_schema, ParquetField, ParquetFieldType};
+use crate::arrow::schema::{ParquetField, ParquetFieldType};
 use crate::arrow::ProjectionMask;
 use crate::basic::Type as PhysicalType;
 use crate::data_type::{
-    BoolType, ByteArrayType, DoubleType, FixedLenByteArrayType, FloatType, Int32Type,
-    Int64Type, Int96Type,
+    BoolType, DoubleType, FloatType, Int32Type, Int64Type, Int96Type,
 };
-use crate::errors::Result;
+use crate::errors::{ParquetError, Result};
 use crate::schema::types::{ColumnDescriptor, ColumnPath, Type};
 
 /// Create array reader from parquet schema, projection mask, and parquet file reader.
 pub fn build_array_reader(
-    arrow_schema: SchemaRef,
-    mask: ProjectionMask,
-    row_groups: &dyn RowGroupCollection,
+    field: Option<&ParquetField>,
+    mask: &ProjectionMask,
+    row_groups: &dyn RowGroups,
 ) -> Result<Box<dyn ArrayReader>> {
-    let field = convert_schema(&row_groups.schema(), mask, Some(arrow_schema.as_ref()))?;
+    let reader = field
+        .and_then(|field| build_reader(field, mask, row_groups).transpose())
+        .transpose()?
+        .unwrap_or_else(|| make_empty_array_reader(row_groups.num_rows()));
 
-    match &field {
-        Some(field) => build_reader(field, row_groups),
-        None => Ok(make_empty_array_reader(row_groups.num_rows())),
-    }
+    Ok(reader)
 }
 
 fn build_reader(
     field: &ParquetField,
-    row_groups: &dyn RowGroupCollection,
-) -> Result<Box<dyn ArrayReader>> {
+    mask: &ProjectionMask,
+    row_groups: &dyn RowGroups,
+) -> Result<Option<Box<dyn ArrayReader>>> {
     match field.field_type {
-        ParquetFieldType::Primitive { .. } => build_primitive_reader(field, row_groups),
+        ParquetFieldType::Primitive { .. } => {
+            build_primitive_reader(field, mask, row_groups)
+        }
         ParquetFieldType::Group { .. } => match &field.arrow_type {
-            DataType::Map(_, _) => build_map_reader(field, row_groups),
-            DataType::Struct(_) => build_struct_reader(field, row_groups),
-            DataType::List(_) => build_list_reader(field, false, row_groups),
-            DataType::LargeList(_) => build_list_reader(field, true, row_groups),
+            DataType::Map(_, _) => build_map_reader(field, mask, row_groups),
+            DataType::Struct(_) => build_struct_reader(field, mask, row_groups),
+            DataType::List(_) => build_list_reader(field, mask, false, row_groups),
+            DataType::LargeList(_) => build_list_reader(field, mask, true, row_groups),
+            DataType::FixedSizeList(_, _) => {
+                build_fixed_size_list_reader(field, mask, row_groups)
+            }
             d => unimplemented!("reading group type {} not implemented", d),
         },
     }
@@ -74,71 +74,159 @@ fn build_reader(
 /// Build array reader for map type.
 fn build_map_reader(
     field: &ParquetField,
-    row_groups: &dyn RowGroupCollection,
-) -> Result<Box<dyn ArrayReader>> {
+    mask: &ProjectionMask,
+    row_groups: &dyn RowGroups,
+) -> Result<Option<Box<dyn ArrayReader>>> {
     let children = field.children().unwrap();
     assert_eq!(children.len(), 2);
 
-    let key_reader = build_reader(&children[0], row_groups)?;
-    let value_reader = build_reader(&children[1], row_groups)?;
+    let key_reader = build_reader(&children[0], mask, row_groups)?;
+    let value_reader = build_reader(&children[1], mask, row_groups)?;
 
-    Ok(Box::new(MapArrayReader::new(
-        key_reader,
-        value_reader,
-        field.arrow_type.clone(),
-        field.def_level,
-        field.rep_level,
-    )))
+    match (key_reader, value_reader) {
+        (Some(key_reader), Some(value_reader)) => {
+            // Need to retrieve underlying data type to handle projection
+            let key_type = key_reader.get_data_type().clone();
+            let value_type = value_reader.get_data_type().clone();
+
+            let data_type = match &field.arrow_type {
+                DataType::Map(map_field, is_sorted) => match map_field.data_type() {
+                    DataType::Struct(fields) => {
+                        assert_eq!(fields.len(), 2);
+                        let struct_field = map_field.as_ref().clone().with_data_type(
+                            DataType::Struct(Fields::from(vec![
+                                fields[0].as_ref().clone().with_data_type(key_type),
+                                fields[1].as_ref().clone().with_data_type(value_type),
+                            ])),
+                        );
+                        DataType::Map(Arc::new(struct_field), *is_sorted)
+                    }
+                    _ => unreachable!(),
+                },
+                _ => unreachable!(),
+            };
+
+            Ok(Some(Box::new(MapArrayReader::new(
+                key_reader,
+                value_reader,
+                data_type,
+                field.def_level,
+                field.rep_level,
+                field.nullable,
+            ))))
+        }
+        (None, None) => Ok(None),
+        _ => Err(general_err!(
+            "partial projection of MapArray is not supported"
+        )),
+    }
 }
 
 /// Build array reader for list type.
 fn build_list_reader(
     field: &ParquetField,
+    mask: &ProjectionMask,
     is_large: bool,
-    row_groups: &dyn RowGroupCollection,
-) -> Result<Box<dyn ArrayReader>> {
+    row_groups: &dyn RowGroups,
+) -> Result<Option<Box<dyn ArrayReader>>> {
     let children = field.children().unwrap();
     assert_eq!(children.len(), 1);
 
-    let data_type = field.arrow_type.clone();
-    let item_reader = build_reader(&children[0], row_groups)?;
-
-    match is_large {
-        false => Ok(Box::new(ListArrayReader::<i32>::new(
-            item_reader,
-            data_type,
-            field.def_level,
-            field.rep_level,
-            field.nullable,
-        )) as _),
-        true => Ok(Box::new(ListArrayReader::<i64>::new(
-            item_reader,
-            data_type,
-            field.def_level,
-            field.rep_level,
-            field.nullable,
-        )) as _),
-    }
+    let reader = match build_reader(&children[0], mask, row_groups)? {
+        Some(item_reader) => {
+            // Need to retrieve underlying data type to handle projection
+            let item_type = item_reader.get_data_type().clone();
+            let data_type = match &field.arrow_type {
+                DataType::List(f) => {
+                    DataType::List(Arc::new(f.as_ref().clone().with_data_type(item_type)))
+                }
+                DataType::LargeList(f) => DataType::LargeList(Arc::new(
+                    f.as_ref().clone().with_data_type(item_type),
+                )),
+                _ => unreachable!(),
+            };
+
+            let reader = match is_large {
+                false => Box::new(ListArrayReader::<i32>::new(
+                    item_reader,
+                    data_type,
+                    field.def_level,
+                    field.rep_level,
+                    field.nullable,
+                )) as _,
+                true => Box::new(ListArrayReader::<i64>::new(
+                    item_reader,
+                    data_type,
+                    field.def_level,
+                    field.rep_level,
+                    field.nullable,
+                )) as _,
+            };
+            Some(reader)
+        }
+        None => None,
+    };
+    Ok(reader)
+}
+
+/// Build array reader for fixed-size list type.
+fn build_fixed_size_list_reader(
+    field: &ParquetField,
+    mask: &ProjectionMask,
+    row_groups: &dyn RowGroups,
+) -> Result<Option<Box<dyn ArrayReader>>> {
+    let children = field.children().unwrap();
+    assert_eq!(children.len(), 1);
+
+    let reader = match build_reader(&children[0], mask, row_groups)? {
+        Some(item_reader) => {
+            let item_type = item_reader.get_data_type().clone();
+            let reader = match &field.arrow_type {
+                &DataType::FixedSizeList(ref f, size) => {
+                    let data_type = DataType::FixedSizeList(
+                        Arc::new(f.as_ref().clone().with_data_type(item_type)),
+                        size,
+                    );
+
+                    Box::new(FixedSizeListArrayReader::new(
+                        item_reader,
+                        size as usize,
+                        data_type,
+                        field.def_level,
+                        field.rep_level,
+                        field.nullable,
+                    )) as _
+                }
+                _ => unimplemented!(),
+            };
+            Some(reader)
+        }
+        None => None,
+    };
+    Ok(reader)
 }
 
 /// Creates primitive array reader for each primitive type.
 fn build_primitive_reader(
     field: &ParquetField,
-    row_groups: &dyn RowGroupCollection,
-) -> Result<Box<dyn ArrayReader>> {
-    let (col_idx, primitive_type, type_len) = match &field.field_type {
+    mask: &ProjectionMask,
+    row_groups: &dyn RowGroups,
+) -> Result<Option<Box<dyn ArrayReader>>> {
+    let (col_idx, primitive_type) = match &field.field_type {
         ParquetFieldType::Primitive {
             col_idx,
             primitive_type,
         } => match primitive_type.as_ref() {
-            Type::PrimitiveType { type_length, .. } => {
-                (*col_idx, primitive_type.clone(), *type_length)
-            }
+            Type::PrimitiveType { .. } => (*col_idx, primitive_type.clone()),
             Type::GroupType { .. } => unreachable!(),
         },
         _ => unreachable!(),
     };
 
+    if !mask.leaf_included(col_idx) {
+        return Ok(None);
+    }
+
     let physical_type = primitive_type.get_physical_type();
 
     // We don't track the column path in ParquetField as it adds a potential source
@@ -157,161 +245,100 @@ fn build_primitive_reader(
     let page_iterator = row_groups.column_chunks(col_idx)?;
     let arrow_type = Some(field.arrow_type.clone());
 
-    match physical_type {
-        PhysicalType::BOOLEAN => Ok(Box::new(PrimitiveArrayReader::<BoolType>::new(
+    let reader = match physical_type {
+        PhysicalType::BOOLEAN => Box::new(PrimitiveArrayReader::<BoolType>::new(
             page_iterator,
             column_desc,
             arrow_type,
-        )?)),
+        )?) as _,
         PhysicalType::INT32 => {
             if let Some(DataType::Null) = arrow_type {
-                Ok(Box::new(NullArrayReader::<Int32Type>::new(
+                Box::new(NullArrayReader::<Int32Type>::new(
                     page_iterator,
                     column_desc,
-                )?))
+                )?) as _
             } else {
-                Ok(Box::new(PrimitiveArrayReader::<Int32Type>::new(
+                Box::new(PrimitiveArrayReader::<Int32Type>::new(
                     page_iterator,
                     column_desc,
                     arrow_type,
-                )?))
+                )?) as _
             }
         }
-        PhysicalType::INT64 => Ok(Box::new(PrimitiveArrayReader::<Int64Type>::new(
+        PhysicalType::INT64 => Box::new(PrimitiveArrayReader::<Int64Type>::new(
             page_iterator,
             column_desc,
             arrow_type,
-        )?)),
-        PhysicalType::INT96 => {
-            // get the optional timezone information from arrow type
-            let timezone = arrow_type.as_ref().and_then(|data_type| {
-                if let DataType::Timestamp(_, tz) = data_type {
-                    tz.clone()
-                } else {
-                    None
-                }
-            });
-            let converter = Int96Converter::new(Int96ArrayConverter { timezone });
-            Ok(Box::new(ComplexObjectArrayReader::<
-                Int96Type,
-                Int96Converter,
-            >::new(
-                page_iterator,
-                column_desc,
-                converter,
-                arrow_type,
-            )?))
-        }
-        PhysicalType::FLOAT => Ok(Box::new(PrimitiveArrayReader::<FloatType>::new(
+        )?) as _,
+        PhysicalType::INT96 => Box::new(PrimitiveArrayReader::<Int96Type>::new(
             page_iterator,
             column_desc,
             arrow_type,
-        )?)),
-        PhysicalType::DOUBLE => Ok(Box::new(PrimitiveArrayReader::<DoubleType>::new(
+        )?) as _,
+        PhysicalType::FLOAT => Box::new(PrimitiveArrayReader::<FloatType>::new(
             page_iterator,
             column_desc,
             arrow_type,
-        )?)),
+        )?) as _,
+        PhysicalType::DOUBLE => Box::new(PrimitiveArrayReader::<DoubleType>::new(
+            page_iterator,
+            column_desc,
+            arrow_type,
+        )?) as _,
         PhysicalType::BYTE_ARRAY => match arrow_type {
             Some(DataType::Dictionary(_, _)) => {
-                make_byte_array_dictionary_reader(page_iterator, column_desc, arrow_type)
-            }
-            Some(DataType::Decimal128(precision, scale)) => {
-                // read decimal data from parquet binary physical type
-                let convert = DecimalByteArrayConvert::new(DecimalArrayConverter::new(
-                    precision as i32,
-                    scale as i32,
-                ));
-                Ok(Box::new(ComplexObjectArrayReader::<
-                    ByteArrayType,
-                    DecimalByteArrayConvert,
-                >::new(
-                    page_iterator, column_desc, convert, arrow_type
-                )?))
-            }
-            _ => make_byte_array_reader(page_iterator, column_desc, arrow_type),
-        },
-        PhysicalType::FIXED_LEN_BYTE_ARRAY => match field.arrow_type {
-            DataType::Decimal128(precision, scale) => {
-                let converter = DecimalFixedLengthByteArrayConverter::new(
-                    DecimalArrayConverter::new(precision as i32, scale as i32),
-                );
-                Ok(Box::new(ComplexObjectArrayReader::<
-                    FixedLenByteArrayType,
-                    DecimalFixedLengthByteArrayConverter,
-                >::new(
-                    page_iterator,
-                    column_desc,
-                    converter,
-                    arrow_type,
-                )?))
-            }
-            DataType::Interval(IntervalUnit::DayTime) => {
-                let converter =
-                    IntervalDayTimeConverter::new(IntervalDayTimeArrayConverter {});
-                Ok(Box::new(ComplexObjectArrayReader::<
-                    FixedLenByteArrayType,
-                    _,
-                >::new(
-                    page_iterator,
-                    column_desc,
-                    converter,
-                    arrow_type,
-                )?))
-            }
-            DataType::Interval(IntervalUnit::YearMonth) => {
-                let converter =
-                    IntervalYearMonthConverter::new(IntervalYearMonthArrayConverter {});
-                Ok(Box::new(ComplexObjectArrayReader::<
-                    FixedLenByteArrayType,
-                    _,
-                >::new(
-                    page_iterator,
-                    column_desc,
-                    converter,
-                    arrow_type,
-                )?))
-            }
-            _ => {
-                let converter =
-                    FixedLenBinaryConverter::new(FixedSizeArrayConverter::new(type_len));
-                Ok(Box::new(ComplexObjectArrayReader::<
-                    FixedLenByteArrayType,
-                    FixedLenBinaryConverter,
-                >::new(
-                    page_iterator,
-                    column_desc,
-                    converter,
-                    arrow_type,
-                )?))
+                make_byte_array_dictionary_reader(page_iterator, column_desc, arrow_type)?
             }
+            _ => make_byte_array_reader(page_iterator, column_desc, arrow_type)?,
         },
-    }
+        PhysicalType::FIXED_LEN_BYTE_ARRAY => {
+            make_fixed_len_byte_array_reader(page_iterator, column_desc, arrow_type)?
+        }
+    };
+    Ok(Some(reader))
 }
 
 fn build_struct_reader(
     field: &ParquetField,
-    row_groups: &dyn RowGroupCollection,
-) -> Result<Box<dyn ArrayReader>> {
+    mask: &ProjectionMask,
+    row_groups: &dyn RowGroups,
+) -> Result<Option<Box<dyn ArrayReader>>> {
+    let arrow_fields = match &field.arrow_type {
+        DataType::Struct(children) => children,
+        _ => unreachable!(),
+    };
     let children = field.children().unwrap();
-    let children_reader = children
-        .iter()
-        .map(|child| build_reader(child, row_groups))
-        .collect::<Result<Vec<_>>>()?;
-
-    Ok(Box::new(StructArrayReader::new(
-        field.arrow_type.clone(),
-        children_reader,
+    assert_eq!(arrow_fields.len(), children.len());
+
+    let mut readers = Vec::with_capacity(children.len());
+    let mut builder = SchemaBuilder::with_capacity(children.len());
+
+    for (arrow, parquet) in arrow_fields.iter().zip(children) {
+        if let Some(reader) = build_reader(parquet, mask, row_groups)? {
+            // Need to retrieve underlying data type to handle projection
+            let child_type = reader.get_data_type().clone();
+            builder.push(arrow.as_ref().clone().with_data_type(child_type));
+            readers.push(reader);
+        }
+    }
+
+    if readers.is_empty() {
+        return Ok(None);
+    }
+
+    Ok(Some(Box::new(StructArrayReader::new(
+        DataType::Struct(builder.finish().fields),
+        readers,
         field.def_level,
         field.rep_level,
         field.nullable,
-    )) as _)
+    ))))
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::arrow::parquet_to_arrow_schema;
+    use crate::arrow::schema::parquet_to_arrow_schema_and_fields;
     use crate::file::reader::{FileReader, SerializedFileReader};
     use crate::util::test_common::file_util::get_test_file;
     use arrow::datatypes::Field;
@@ -325,21 +352,22 @@ mod tests {
 
         let file_metadata = file_reader.metadata().file_metadata();
         let mask = ProjectionMask::leaves(file_metadata.schema_descr(), [0]);
-        let arrow_schema = parquet_to_arrow_schema(
+        let (_, fields) = parquet_to_arrow_schema_and_fields(
             file_metadata.schema_descr(),
+            ProjectionMask::all(),
             file_metadata.key_value_metadata(),
         )
         .unwrap();
 
         let array_reader =
-            build_array_reader(Arc::new(arrow_schema), mask, &file_reader).unwrap();
+            build_array_reader(fields.as_ref(), &mask, &file_reader).unwrap();
 
         // Create arrow types
-        let arrow_type = DataType::Struct(vec![Field::new(
+        let arrow_type = DataType::Struct(Fields::from(vec![Field::new(
             "b_struct",
-            DataType::Struct(vec![Field::new("b_c_int", DataType::Int32, true)]),
+            DataType::Struct(vec![Field::new("b_c_int", DataType::Int32, true)].into()),
             true,
-        )]);
+        )]));
 
         assert_eq!(array_reader.get_data_type(), &arrow_type);
     }
diff --git a/parquet/src/arrow/array_reader/byte_array.rs b/parquet/src/arrow/array_reader/byte_array.rs
index 172aeb96d6d1..19086878c151 100644
--- a/parquet/src/arrow/array_reader/byte_array.rs
+++ b/parquet/src/arrow/array_reader/byte_array.rs
@@ -16,26 +16,26 @@
 // under the License.
 
 use crate::arrow::array_reader::{read_records, skip_records, ArrayReader};
+use crate::arrow::buffer::bit_util::sign_extend_be;
 use crate::arrow::buffer::offset_buffer::OffsetBuffer;
-use crate::arrow::record_reader::buffer::ScalarValue;
+use crate::arrow::decoder::{DeltaByteArrayDecoder, DictIndexDecoder};
 use crate::arrow::record_reader::GenericRecordReader;
 use crate::arrow::schema::parquet_to_arrow_field;
 use crate::basic::{ConvertedType, Encoding};
 use crate::column::page::PageIterator;
 use crate::column::reader::decoder::ColumnValueDecoder;
 use crate::data_type::Int32Type;
-use crate::encodings::{
-    decoding::{Decoder, DeltaBitPackDecoder},
-    rle::RleDecoder,
-};
+use crate::encodings::decoding::{Decoder, DeltaBitPackDecoder};
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::ColumnDescPtr;
-use crate::util::memory::ByteBufferPtr;
-use arrow::array::{ArrayRef, OffsetSizeTrait};
-use arrow::buffer::Buffer;
-use arrow::datatypes::DataType as ArrowType;
+use arrow_array::{
+    Array, ArrayRef, BinaryArray, Decimal128Array, Decimal256Array, OffsetSizeTrait,
+};
+use arrow_buffer::i256;
+use arrow_schema::DataType as ArrowType;
+use bytes::Bytes;
 use std::any::Any;
-use std::ops::Range;
+use std::sync::Arc;
 
 /// Returns an [`ArrayReader`] that decodes the provided byte array column
 pub fn make_byte_array_reader(
@@ -52,7 +52,10 @@ pub fn make_byte_array_reader(
     };
 
     match data_type {
-        ArrowType::Binary | ArrowType::Utf8 => {
+        ArrowType::Binary
+        | ArrowType::Utf8
+        | ArrowType::Decimal128(_, _)
+        | ArrowType::Decimal256(_, _) => {
             let reader = GenericRecordReader::new(column_desc);
             Ok(Box::new(ByteArrayReader::<i32>::new(
                 pages, data_type, reader,
@@ -72,22 +75,19 @@ pub fn make_byte_array_reader(
 }
 
 /// An [`ArrayReader`] for variable length byte arrays
-struct ByteArrayReader<I: ScalarValue> {
+struct ByteArrayReader<I: OffsetSizeTrait> {
     data_type: ArrowType,
     pages: Box<dyn PageIterator>,
-    def_levels_buffer: Option<Buffer>,
-    rep_levels_buffer: Option<Buffer>,
+    def_levels_buffer: Option<Vec<i16>>,
+    rep_levels_buffer: Option<Vec<i16>>,
     record_reader: GenericRecordReader<OffsetBuffer<I>, ByteArrayColumnValueDecoder<I>>,
 }
 
-impl<I: ScalarValue> ByteArrayReader<I> {
+impl<I: OffsetSizeTrait> ByteArrayReader<I> {
     fn new(
         pages: Box<dyn PageIterator>,
         data_type: ArrowType,
-        record_reader: GenericRecordReader<
-            OffsetBuffer<I>,
-            ByteArrayColumnValueDecoder<I>,
-        >,
+        record_reader: GenericRecordReader<OffsetBuffer<I>, ByteArrayColumnValueDecoder<I>>,
     ) -> Self {
         Self {
             data_type,
@@ -99,7 +99,7 @@ impl<I: ScalarValue> ByteArrayReader<I> {
     }
 }
 
-impl<I: OffsetSizeTrait + ScalarValue> ArrayReader for ByteArrayReader<I> {
+impl<I: OffsetSizeTrait> ArrayReader for ByteArrayReader<I> {
     fn as_any(&self) -> &dyn Any {
         self
     }
@@ -119,7 +119,33 @@ impl<I: OffsetSizeTrait + ScalarValue> ArrayReader for ByteArrayReader<I> {
         self.rep_levels_buffer = self.record_reader.consume_rep_levels();
         self.record_reader.reset();
 
-        Ok(buffer.into_array(null_buffer, self.data_type.clone()))
+        let array: ArrayRef = match self.data_type {
+            ArrowType::Decimal128(p, s) => {
+                let array = buffer.into_array(null_buffer, ArrowType::Binary);
+                let binary = array.as_any().downcast_ref::<BinaryArray>().unwrap();
+                let decimal = binary
+                    .iter()
+                    .map(|opt| Some(i128::from_be_bytes(sign_extend_be(opt?))))
+                    .collect::<Decimal128Array>()
+                    .with_precision_and_scale(p, s)?;
+
+                Arc::new(decimal)
+            }
+            ArrowType::Decimal256(p, s) => {
+                let array = buffer.into_array(null_buffer, ArrowType::Binary);
+                let binary = array.as_any().downcast_ref::<BinaryArray>().unwrap();
+                let decimal = binary
+                    .iter()
+                    .map(|opt| Some(i256::from_be_bytes(sign_extend_be(opt?))))
+                    .collect::<Decimal256Array>()
+                    .with_precision_and_scale(p, s)?;
+
+                Arc::new(decimal)
+            }
+            _ => buffer.into_array(null_buffer, self.data_type.clone()),
+        };
+
+        Ok(array)
     }
 
     fn skip_records(&mut self, num_records: usize) -> Result<usize> {
@@ -127,25 +153,23 @@ impl<I: OffsetSizeTrait + ScalarValue> ArrayReader for ByteArrayReader<I> {
     }
 
     fn get_def_levels(&self) -> Option<&[i16]> {
-        self.def_levels_buffer.as_ref().map(|buf| buf.typed_data())
+        self.def_levels_buffer.as_deref()
     }
 
     fn get_rep_levels(&self) -> Option<&[i16]> {
-        self.rep_levels_buffer.as_ref().map(|buf| buf.typed_data())
+        self.rep_levels_buffer.as_deref()
     }
 }
 
 /// A [`ColumnValueDecoder`] for variable length byte arrays
-struct ByteArrayColumnValueDecoder<I: ScalarValue> {
+struct ByteArrayColumnValueDecoder<I: OffsetSizeTrait> {
     dict: Option<OffsetBuffer<I>>,
     decoder: Option<ByteArrayDecoder>,
     validate_utf8: bool,
 }
 
-impl<I: OffsetSizeTrait + ScalarValue> ColumnValueDecoder
-    for ByteArrayColumnValueDecoder<I>
-{
-    type Slice = OffsetBuffer<I>;
+impl<I: OffsetSizeTrait> ColumnValueDecoder for ByteArrayColumnValueDecoder<I> {
+    type Buffer = OffsetBuffer<I>;
 
     fn new(desc: &ColumnDescPtr) -> Self {
         let validate_utf8 = desc.converted_type() == ConvertedType::UTF8;
@@ -158,7 +182,7 @@ impl<I: OffsetSizeTrait + ScalarValue> ColumnValueDecoder
 
     fn set_dict(
         &mut self,
-        buf: ByteBufferPtr,
+        buf: Bytes,
         num_values: u32,
         encoding: Encoding,
         _is_sorted: bool,
@@ -188,7 +212,7 @@ impl<I: OffsetSizeTrait + ScalarValue> ColumnValueDecoder
     fn set_data(
         &mut self,
         encoding: Encoding,
-        data: ByteBufferPtr,
+        data: Bytes,
         num_levels: usize,
         num_values: Option<usize>,
     ) -> Result<()> {
@@ -202,13 +226,13 @@ impl<I: OffsetSizeTrait + ScalarValue> ColumnValueDecoder
         Ok(())
     }
 
-    fn read(&mut self, out: &mut Self::Slice, range: Range<usize>) -> Result<usize> {
+    fn read(&mut self, out: &mut Self::Buffer, num_values: usize) -> Result<usize> {
         let decoder = self
             .decoder
             .as_mut()
             .ok_or_else(|| general_err!("no decoder set"))?;
 
-        decoder.read(out, range.end - range.start, self.dict.as_ref())
+        decoder.read(out, num_values, self.dict.as_ref())
     }
 
     fn skip_values(&mut self, num_values: usize) -> Result<usize> {
@@ -232,7 +256,7 @@ pub enum ByteArrayDecoder {
 impl ByteArrayDecoder {
     pub fn new(
         encoding: Encoding,
-        data: ByteBufferPtr,
+        data: Bytes,
         num_levels: usize,
         num_values: Option<usize>,
         validate_utf8: bool,
@@ -244,17 +268,15 @@ impl ByteArrayDecoder {
                 num_values,
                 validate_utf8,
             )),
-            Encoding::RLE_DICTIONARY | Encoding::PLAIN_DICTIONARY => {
-                ByteArrayDecoder::Dictionary(ByteArrayDecoderDictionary::new(
-                    data, num_levels, num_values,
-                ))
-            }
+            Encoding::RLE_DICTIONARY | Encoding::PLAIN_DICTIONARY => ByteArrayDecoder::Dictionary(
+                ByteArrayDecoderDictionary::new(data, num_levels, num_values),
+            ),
             Encoding::DELTA_LENGTH_BYTE_ARRAY => ByteArrayDecoder::DeltaLength(
                 ByteArrayDecoderDeltaLength::new(data, validate_utf8)?,
             ),
-            Encoding::DELTA_BYTE_ARRAY => ByteArrayDecoder::DeltaByteArray(
-                ByteArrayDecoderDelta::new(data, validate_utf8)?,
-            ),
+            Encoding::DELTA_BYTE_ARRAY => {
+                ByteArrayDecoder::DeltaByteArray(ByteArrayDecoderDelta::new(data, validate_utf8)?)
+            }
             _ => {
                 return Err(general_err!(
                     "unsupported encoding for byte array: {}",
@@ -267,7 +289,7 @@ impl ByteArrayDecoder {
     }
 
     /// Read up to `len` values to `out` with the optional dictionary
-    pub fn read<I: OffsetSizeTrait + ScalarValue>(
+    pub fn read<I: OffsetSizeTrait>(
         &mut self,
         out: &mut OffsetBuffer<I>,
         len: usize,
@@ -276,8 +298,8 @@ impl ByteArrayDecoder {
         match self {
             ByteArrayDecoder::Plain(d) => d.read(out, len),
             ByteArrayDecoder::Dictionary(d) => {
-                let dict = dict
-                    .ok_or_else(|| general_err!("missing dictionary page for column"))?;
+                let dict =
+                    dict.ok_or_else(|| general_err!("missing dictionary page for column"))?;
 
                 d.read(out, dict, len)
             }
@@ -287,7 +309,7 @@ impl ByteArrayDecoder {
     }
 
     /// Skip `len` values
-    pub fn skip<I: OffsetSizeTrait + ScalarValue>(
+    pub fn skip<I: OffsetSizeTrait>(
         &mut self,
         len: usize,
         dict: Option<&OffsetBuffer<I>>,
@@ -295,8 +317,8 @@ impl ByteArrayDecoder {
         match self {
             ByteArrayDecoder::Plain(d) => d.skip(len),
             ByteArrayDecoder::Dictionary(d) => {
-                let dict = dict
-                    .ok_or_else(|| general_err!("missing dictionary page for column"))?;
+                let dict =
+                    dict.ok_or_else(|| general_err!("missing dictionary page for column"))?;
 
                 d.skip(dict, len)
             }
@@ -308,7 +330,7 @@ impl ByteArrayDecoder {
 
 /// Decoder from [`Encoding::PLAIN`] data to [`OffsetBuffer`]
 pub struct ByteArrayDecoderPlain {
-    buf: ByteBufferPtr,
+    buf: Bytes,
     offset: usize,
     validate_utf8: bool,
 
@@ -319,7 +341,7 @@ pub struct ByteArrayDecoderPlain {
 
 impl ByteArrayDecoderPlain {
     pub fn new(
-        buf: ByteBufferPtr,
+        buf: Bytes,
         num_levels: usize,
         num_values: Option<usize>,
         validate_utf8: bool,
@@ -332,7 +354,7 @@ impl ByteArrayDecoderPlain {
         }
     }
 
-    pub fn read<I: OffsetSizeTrait + ScalarValue>(
+    pub fn read<I: OffsetSizeTrait>(
         &mut self,
         output: &mut OffsetBuffer<I>,
         len: usize,
@@ -361,8 +383,7 @@ impl ByteArrayDecoderPlain {
             if self.offset + 4 > buf.len() {
                 return Err(ParquetError::EOF("eof decoding byte array".into()));
             }
-            let len_bytes: [u8; 4] =
-                buf[self.offset..self.offset + 4].try_into().unwrap();
+            let len_bytes: [u8; 4] = buf[self.offset..self.offset + 4].try_into().unwrap();
             let len = u32::from_le_bytes(len_bytes);
 
             let start_offset = self.offset + 4;
@@ -393,8 +414,7 @@ impl ByteArrayDecoderPlain {
             if self.offset + 4 > buf.len() {
                 return Err(ParquetError::EOF("eof decoding byte array".into()));
             }
-            let len_bytes: [u8; 4] =
-                buf[self.offset..self.offset + 4].try_into().unwrap();
+            let len_bytes: [u8; 4] = buf[self.offset..self.offset + 4].try_into().unwrap();
             let len = u32::from_le_bytes(len_bytes) as usize;
             skip += 1;
             self.offset = self.offset + 4 + len;
@@ -407,16 +427,16 @@ impl ByteArrayDecoderPlain {
 /// Decoder from [`Encoding::DELTA_LENGTH_BYTE_ARRAY`] data to [`OffsetBuffer`]
 pub struct ByteArrayDecoderDeltaLength {
     lengths: Vec<i32>,
-    data: ByteBufferPtr,
+    data: Bytes,
     length_offset: usize,
     data_offset: usize,
     validate_utf8: bool,
 }
 
 impl ByteArrayDecoderDeltaLength {
-    fn new(data: ByteBufferPtr, validate_utf8: bool) -> Result<Self> {
+    fn new(data: Bytes, validate_utf8: bool) -> Result<Self> {
         let mut len_decoder = DeltaBitPackDecoder::<Int32Type>::new();
-        len_decoder.set_data(data.all(), 0)?;
+        len_decoder.set_data(data.clone(), 0)?;
         let values = len_decoder.values_left();
 
         let mut lengths = vec![0; values];
@@ -431,7 +451,7 @@ impl ByteArrayDecoderDeltaLength {
         })
     }
 
-    fn read<I: OffsetSizeTrait + ScalarValue>(
+    fn read<I: OffsetSizeTrait>(
         &mut self,
         output: &mut OffsetBuffer<I>,
         len: usize,
@@ -486,230 +506,80 @@ impl ByteArrayDecoderDeltaLength {
 
 /// Decoder from [`Encoding::DELTA_BYTE_ARRAY`] to [`OffsetBuffer`]
 pub struct ByteArrayDecoderDelta {
-    prefix_lengths: Vec<i32>,
-    suffix_lengths: Vec<i32>,
-    data: ByteBufferPtr,
-    length_offset: usize,
-    data_offset: usize,
-    last_value: Vec<u8>,
+    decoder: DeltaByteArrayDecoder,
     validate_utf8: bool,
 }
 
 impl ByteArrayDecoderDelta {
-    fn new(data: ByteBufferPtr, validate_utf8: bool) -> Result<Self> {
-        let mut prefix = DeltaBitPackDecoder::<Int32Type>::new();
-        prefix.set_data(data.all(), 0)?;
-
-        let num_prefix = prefix.values_left();
-        let mut prefix_lengths = vec![0; num_prefix];
-        assert_eq!(prefix.get(&mut prefix_lengths)?, num_prefix);
-
-        let mut suffix = DeltaBitPackDecoder::<Int32Type>::new();
-        suffix.set_data(data.start_from(prefix.get_offset()), 0)?;
-
-        let num_suffix = suffix.values_left();
-        let mut suffix_lengths = vec![0; num_suffix];
-        assert_eq!(suffix.get(&mut suffix_lengths)?, num_suffix);
-
-        if num_prefix != num_suffix {
-            return Err(general_err!(format!(
-                "inconsistent DELTA_BYTE_ARRAY lengths, prefixes: {}, suffixes: {}",
-                num_prefix, num_suffix
-            )));
-        }
-
+    fn new(data: Bytes, validate_utf8: bool) -> Result<Self> {
         Ok(Self {
-            prefix_lengths,
-            suffix_lengths,
-            data,
-            length_offset: 0,
-            data_offset: prefix.get_offset() + suffix.get_offset(),
-            last_value: vec![],
+            decoder: DeltaByteArrayDecoder::new(data)?,
             validate_utf8,
         })
     }
 
-    fn read<I: OffsetSizeTrait + ScalarValue>(
+    fn read<I: OffsetSizeTrait>(
         &mut self,
         output: &mut OffsetBuffer<I>,
         len: usize,
     ) -> Result<usize> {
         let initial_values_length = output.values.len();
-        assert_eq!(self.prefix_lengths.len(), self.suffix_lengths.len());
-
-        let to_read = len.min(self.prefix_lengths.len() - self.length_offset);
-
-        output.offsets.reserve(to_read);
+        output.offsets.reserve(len.min(self.decoder.remaining()));
 
-        let length_range = self.length_offset..self.length_offset + to_read;
-        let iter = self.prefix_lengths[length_range.clone()]
-            .iter()
-            .zip(&self.suffix_lengths[length_range]);
-
-        let data = self.data.as_ref();
-
-        for (prefix_length, suffix_length) in iter {
-            let prefix_length = *prefix_length as usize;
-            let suffix_length = *suffix_length as usize;
-
-            if self.data_offset + suffix_length > self.data.len() {
-                return Err(ParquetError::EOF("eof decoding byte array".into()));
-            }
-
-            self.last_value.truncate(prefix_length);
-            self.last_value.extend_from_slice(
-                &data[self.data_offset..self.data_offset + suffix_length],
-            );
-            output.try_push(&self.last_value, self.validate_utf8)?;
-
-            self.data_offset += suffix_length;
-        }
-
-        self.length_offset += to_read;
+        let read = self
+            .decoder
+            .read(len, |bytes| output.try_push(bytes, self.validate_utf8))?;
 
         if self.validate_utf8 {
             output.check_valid_utf8(initial_values_length)?;
         }
-        Ok(to_read)
+        Ok(read)
     }
 
     fn skip(&mut self, to_skip: usize) -> Result<usize> {
-        let to_skip = to_skip.min(self.prefix_lengths.len() - self.length_offset);
-
-        let length_range = self.length_offset..self.length_offset + to_skip;
-        let iter = self.prefix_lengths[length_range.clone()]
-            .iter()
-            .zip(&self.suffix_lengths[length_range]);
-
-        let data = self.data.as_ref();
-
-        for (prefix_length, suffix_length) in iter {
-            let prefix_length = *prefix_length as usize;
-            let suffix_length = *suffix_length as usize;
-
-            if self.data_offset + suffix_length > self.data.len() {
-                return Err(ParquetError::EOF("eof decoding byte array".into()));
-            }
-
-            self.last_value.truncate(prefix_length);
-            self.last_value.extend_from_slice(
-                &data[self.data_offset..self.data_offset + suffix_length],
-            );
-            self.data_offset += suffix_length;
-        }
-        self.length_offset += to_skip;
-        Ok(to_skip)
+        self.decoder.skip(to_skip)
     }
 }
 
 /// Decoder from [`Encoding::RLE_DICTIONARY`] to [`OffsetBuffer`]
 pub struct ByteArrayDecoderDictionary {
-    /// Decoder for the dictionary offsets array
-    decoder: RleDecoder,
-
-    /// We want to decode the offsets in chunks so we will maintain an internal buffer of decoded
-    /// offsets
-    index_buf: Box<[i32; 1024]>,
-    /// Current length of `index_buf`
-    index_buf_len: usize,
-    /// Current offset into `index_buf`. If `index_buf_offset` == `index_buf_len` then we've consumed
-    /// the entire buffer and need to decode another chunk of offsets.
-    index_offset: usize,
-
-    /// This is a maximum as the null count is not always known, e.g. value data from
-    /// a v1 data page
-    max_remaining_values: usize,
+    decoder: DictIndexDecoder,
 }
 
 impl ByteArrayDecoderDictionary {
-    fn new(data: ByteBufferPtr, num_levels: usize, num_values: Option<usize>) -> Self {
-        let bit_width = data[0];
-        let mut decoder = RleDecoder::new(bit_width);
-        decoder.set_data(data.start_from(1));
-
+    fn new(data: Bytes, num_levels: usize, num_values: Option<usize>) -> Self {
         Self {
-            decoder,
-            index_buf: Box::new([0; 1024]),
-            index_buf_len: 0,
-            index_offset: 0,
-            max_remaining_values: num_values.unwrap_or(num_levels),
+            decoder: DictIndexDecoder::new(data, num_levels, num_values),
         }
     }
 
-    fn read<I: OffsetSizeTrait + ScalarValue>(
+    fn read<I: OffsetSizeTrait>(
         &mut self,
         output: &mut OffsetBuffer<I>,
         dict: &OffsetBuffer<I>,
         len: usize,
     ) -> Result<usize> {
+        // All data must be NULL
         if dict.is_empty() {
-            return Ok(0); // All data must be NULL
+            return Ok(0);
         }
 
-        let mut values_read = 0;
-
-        while values_read != len && self.max_remaining_values != 0 {
-            if self.index_offset == self.index_buf_len {
-                // We've consumed the entire index buffer so we need to reload it before proceeding
-                let read = self.decoder.get_batch(self.index_buf.as_mut())?;
-                if read == 0 {
-                    break;
-                }
-                self.index_buf_len = read;
-                self.index_offset = 0;
-            }
-
-            let to_read = (len - values_read)
-                .min(self.index_buf_len - self.index_offset)
-                .min(self.max_remaining_values);
-
-            output.extend_from_dictionary(
-                &self.index_buf[self.index_offset..self.index_offset + to_read],
-                dict.offsets.as_slice(),
-                dict.values.as_slice(),
-            )?;
-
-            self.index_offset += to_read;
-            values_read += to_read;
-            self.max_remaining_values -= to_read;
-        }
-        Ok(values_read)
+        self.decoder.read(len, |keys| {
+            output.extend_from_dictionary(keys, dict.offsets.as_slice(), dict.values.as_slice())
+        })
     }
 
-    fn skip<I: OffsetSizeTrait + ScalarValue>(
+    fn skip<I: OffsetSizeTrait>(
         &mut self,
         dict: &OffsetBuffer<I>,
         to_skip: usize,
     ) -> Result<usize> {
-        let to_skip = to_skip.min(self.max_remaining_values);
         // All data must be NULL
         if dict.is_empty() {
             return Ok(0);
         }
 
-        let mut values_skip = 0;
-        while values_skip < to_skip {
-            if self.index_offset == self.index_buf_len {
-                // Instead of reloading the buffer, just skip in the decoder
-                let skip = self.decoder.skip(to_skip - values_skip)?;
-
-                if skip == 0 {
-                    break;
-                }
-
-                self.max_remaining_values -= skip;
-                values_skip += skip;
-            } else {
-                // We still have indices buffered, so skip within the buffer
-                let skip =
-                    (to_skip - values_skip).min(self.index_buf_len - self.index_offset);
-
-                self.index_offset += skip;
-                self.max_remaining_values -= skip;
-                values_skip += skip;
-            }
-        }
-        Ok(values_skip)
+        self.decoder.skip(to_skip)
     }
 }
 
@@ -718,7 +588,8 @@ mod tests {
     use super::*;
     use crate::arrow::array_reader::test_util::{byte_array_all_encodings, utf8_column};
     use crate::arrow::record_reader::buffer::ValuesBuffer;
-    use arrow::array::{Array, StringArray};
+    use arrow_array::{Array, StringArray};
+    use arrow_buffer::Buffer;
 
     #[test]
     fn test_byte_array_decoder() {
@@ -736,22 +607,22 @@ mod tests {
             let mut output = OffsetBuffer::<i32>::default();
             decoder.set_data(encoding, page, 4, Some(4)).unwrap();
 
-            assert_eq!(decoder.read(&mut output, 0..1).unwrap(), 1);
+            assert_eq!(decoder.read(&mut output, 1).unwrap(), 1);
 
             assert_eq!(output.values.as_slice(), "hello".as_bytes());
             assert_eq!(output.offsets.as_slice(), &[0, 5]);
 
-            assert_eq!(decoder.read(&mut output, 1..2).unwrap(), 1);
+            assert_eq!(decoder.read(&mut output, 1).unwrap(), 1);
             assert_eq!(output.values.as_slice(), "helloworld".as_bytes());
             assert_eq!(output.offsets.as_slice(), &[0, 5, 10]);
 
-            assert_eq!(decoder.read(&mut output, 2..4).unwrap(), 2);
+            assert_eq!(decoder.read(&mut output, 2).unwrap(), 2);
             assert_eq!(output.values.as_slice(), "helloworldab".as_bytes());
             assert_eq!(output.offsets.as_slice(), &[0, 5, 10, 11, 12]);
 
-            assert_eq!(decoder.read(&mut output, 4..8).unwrap(), 0);
+            assert_eq!(decoder.read(&mut output, 4).unwrap(), 0);
 
-            let valid = vec![false, false, true, true, false, true, true, false, false];
+            let valid = [false, false, true, true, false, true, true, false, false];
             let valid_buffer = Buffer::from_iter(valid.iter().cloned());
 
             output.pad_nulls(0, 4, valid.len(), valid_buffer.as_slice());
@@ -791,7 +662,7 @@ mod tests {
             let mut output = OffsetBuffer::<i32>::default();
             decoder.set_data(encoding, page, 4, Some(4)).unwrap();
 
-            assert_eq!(decoder.read(&mut output, 0..1).unwrap(), 1);
+            assert_eq!(decoder.read(&mut output, 1).unwrap(), 1);
 
             assert_eq!(output.values.as_slice(), "hello".as_bytes());
             assert_eq!(output.offsets.as_slice(), &[0, 5]);
@@ -799,13 +670,13 @@ mod tests {
             assert_eq!(decoder.skip_values(1).unwrap(), 1);
             assert_eq!(decoder.skip_values(1).unwrap(), 1);
 
-            assert_eq!(decoder.read(&mut output, 1..2).unwrap(), 1);
+            assert_eq!(decoder.read(&mut output, 1).unwrap(), 1);
             assert_eq!(output.values.as_slice(), "hellob".as_bytes());
             assert_eq!(output.offsets.as_slice(), &[0, 5, 6]);
 
-            assert_eq!(decoder.read(&mut output, 4..8).unwrap(), 0);
+            assert_eq!(decoder.read(&mut output, 4).unwrap(), 0);
 
-            let valid = vec![false, false, true, true, false, false];
+            let valid = [false, false, true, true, false, false];
             let valid_buffer = Buffer::from_iter(valid.iter().cloned());
 
             output.pad_nulls(0, 2, valid.len(), valid_buffer.as_slice());
@@ -834,7 +705,7 @@ mod tests {
         for (encoding, page) in pages.clone() {
             let mut output = OffsetBuffer::<i32>::default();
             decoder.set_data(encoding, page, 4, None).unwrap();
-            assert_eq!(decoder.read(&mut output, 0..1024).unwrap(), 0);
+            assert_eq!(decoder.read(&mut output, 1024).unwrap(), 0);
         }
 
         // test nulls skip
diff --git a/parquet/src/arrow/array_reader/byte_array_dictionary.rs b/parquet/src/arrow/array_reader/byte_array_dictionary.rs
index 0a5d94fa6ae8..3678f24621f8 100644
--- a/parquet/src/arrow/array_reader/byte_array_dictionary.rs
+++ b/parquet/src/arrow/array_reader/byte_array_dictionary.rs
@@ -17,19 +17,16 @@
 
 use std::any::Any;
 use std::marker::PhantomData;
-use std::ops::Range;
 use std::sync::Arc;
 
-use arrow::array::{Array, ArrayRef, OffsetSizeTrait};
-use arrow::buffer::Buffer;
-use arrow::datatypes::{ArrowNativeType, DataType as ArrowType};
+use arrow_array::{Array, ArrayRef, OffsetSizeTrait};
+use arrow_buffer::ArrowNativeType;
+use arrow_schema::DataType as ArrowType;
+use bytes::Bytes;
 
 use crate::arrow::array_reader::byte_array::{ByteArrayDecoder, ByteArrayDecoderPlain};
 use crate::arrow::array_reader::{read_records, skip_records, ArrayReader};
-use crate::arrow::buffer::{
-    dictionary_buffer::DictionaryBuffer, offset_buffer::OffsetBuffer,
-};
-use crate::arrow::record_reader::buffer::{BufferQueue, ScalarValue};
+use crate::arrow::buffer::{dictionary_buffer::DictionaryBuffer, offset_buffer::OffsetBuffer};
 use crate::arrow::record_reader::GenericRecordReader;
 use crate::arrow::schema::parquet_to_arrow_field;
 use crate::basic::{ConvertedType, Encoding};
@@ -39,7 +36,6 @@ use crate::encodings::rle::RleDecoder;
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::ColumnDescPtr;
 use crate::util::bit_util::FromBytes;
-use crate::util::memory::ByteBufferPtr;
 
 /// A macro to reduce verbosity of [`make_byte_array_dictionary_reader`]
 macro_rules! make_reader {
@@ -123,26 +119,23 @@ pub fn make_byte_array_dictionary_reader(
 /// An [`ArrayReader`] for dictionary encoded variable length byte arrays
 ///
 /// Will attempt to preserve any dictionary encoding present in the parquet data
-struct ByteArrayDictionaryReader<K: ScalarValue, V: ScalarValue> {
+struct ByteArrayDictionaryReader<K: ArrowNativeType, V: OffsetSizeTrait> {
     data_type: ArrowType,
     pages: Box<dyn PageIterator>,
-    def_levels_buffer: Option<Buffer>,
-    rep_levels_buffer: Option<Buffer>,
+    def_levels_buffer: Option<Vec<i16>>,
+    rep_levels_buffer: Option<Vec<i16>>,
     record_reader: GenericRecordReader<DictionaryBuffer<K, V>, DictionaryDecoder<K, V>>,
 }
 
 impl<K, V> ByteArrayDictionaryReader<K, V>
 where
-    K: FromBytes + ScalarValue + Ord + ArrowNativeType,
-    V: ScalarValue + OffsetSizeTrait,
+    K: FromBytes + Ord + ArrowNativeType,
+    V: OffsetSizeTrait,
 {
     fn new(
         pages: Box<dyn PageIterator>,
         data_type: ArrowType,
-        record_reader: GenericRecordReader<
-            DictionaryBuffer<K, V>,
-            DictionaryDecoder<K, V>,
-        >,
+        record_reader: GenericRecordReader<DictionaryBuffer<K, V>, DictionaryDecoder<K, V>>,
     ) -> Self {
         Self {
             data_type,
@@ -156,8 +149,8 @@ where
 
 impl<K, V> ArrayReader for ByteArrayDictionaryReader<K, V>
 where
-    K: FromBytes + ScalarValue + Ord + ArrowNativeType,
-    V: ScalarValue + OffsetSizeTrait,
+    K: FromBytes + Ord + ArrowNativeType,
+    V: OffsetSizeTrait,
 {
     fn as_any(&self) -> &dyn Any {
         self
@@ -188,15 +181,11 @@ where
     }
 
     fn get_def_levels(&self) -> Option<&[i16]> {
-        self.def_levels_buffer
-            .as_ref()
-            .map(|buf| buf.typed_data())
+        self.def_levels_buffer.as_deref()
     }
 
     fn get_rep_levels(&self) -> Option<&[i16]> {
-        self.rep_levels_buffer
-            .as_ref()
-            .map(|buf| buf.typed_data())
+        self.rep_levels_buffer.as_deref()
     }
 }
 
@@ -230,16 +219,15 @@ struct DictionaryDecoder<K, V> {
 
 impl<K, V> ColumnValueDecoder for DictionaryDecoder<K, V>
 where
-    K: FromBytes + ScalarValue + Ord + ArrowNativeType,
-    V: ScalarValue + OffsetSizeTrait,
+    K: FromBytes + Ord + ArrowNativeType,
+    V: OffsetSizeTrait,
 {
-    type Slice = DictionaryBuffer<K, V>;
+    type Buffer = DictionaryBuffer<K, V>;
 
     fn new(col: &ColumnDescPtr) -> Self {
         let validate_utf8 = col.converted_type() == ConvertedType::UTF8;
 
-        let value_type = match (V::IS_LARGE, col.converted_type() == ConvertedType::UTF8)
-        {
+        let value_type = match (V::IS_LARGE, col.converted_type() == ConvertedType::UTF8) {
             (true, true) => ArrowType::LargeUtf8,
             (true, false) => ArrowType::LargeBinary,
             (false, true) => ArrowType::Utf8,
@@ -257,7 +245,7 @@ where
 
     fn set_dict(
         &mut self,
-        buf: ByteBufferPtr,
+        buf: Bytes,
         num_values: u32,
         encoding: Encoding,
         _is_sorted: bool,
@@ -278,8 +266,7 @@ where
 
         let len = num_values as usize;
         let mut buffer = OffsetBuffer::<V>::default();
-        let mut decoder =
-            ByteArrayDecoderPlain::new(buf, len, Some(len), self.validate_utf8);
+        let mut decoder = ByteArrayDecoderPlain::new(buf, len, Some(len), self.validate_utf8);
         decoder.read(&mut buffer, usize::MAX)?;
 
         let array = buffer.into_array(None, self.value_type.clone());
@@ -290,7 +277,7 @@ where
     fn set_data(
         &mut self,
         encoding: Encoding,
-        data: ByteBufferPtr,
+        data: Bytes,
         num_levels: usize,
         num_values: Option<usize>,
     ) -> Result<()> {
@@ -298,7 +285,7 @@ where
             Encoding::RLE_DICTIONARY | Encoding::PLAIN_DICTIONARY => {
                 let bit_width = data[0];
                 let mut decoder = RleDecoder::new(bit_width);
-                decoder.set_data(data.start_from(1));
+                decoder.set_data(data.slice(1..));
                 MaybeDictionaryDecoder::Dict {
                     decoder,
                     max_remaining_values: num_values.unwrap_or(num_levels),
@@ -317,16 +304,16 @@ where
         Ok(())
     }
 
-    fn read(&mut self, out: &mut Self::Slice, range: Range<usize>) -> Result<usize> {
+    fn read(&mut self, out: &mut Self::Buffer, num_values: usize) -> Result<usize> {
         match self.decoder.as_mut().expect("decoder set") {
             MaybeDictionaryDecoder::Fallback(decoder) => {
-                decoder.read(out.spill_values()?, range.end - range.start, None)
+                decoder.read(out.spill_values()?, num_values, None)
             }
             MaybeDictionaryDecoder::Dict {
                 decoder,
                 max_remaining_values,
             } => {
-                let len = (range.end - range.start).min(*max_remaining_values);
+                let len = num_values.min(*max_remaining_values);
 
                 let dict = self
                     .dict
@@ -343,8 +330,12 @@ where
                     Some(keys) => {
                         // Happy path - can just copy keys
                         // Keys will be validated on conversion to arrow
-                        let keys_slice = keys.spare_capacity_mut(range.start + len);
-                        let len = decoder.get_batch(&mut keys_slice[range.start..])?;
+
+                        // TODO: Push vec into decoder (#5177)
+                        let start = keys.len();
+                        keys.resize(start + len, K::default());
+                        let len = decoder.get_batch(&mut keys[start..])?;
+                        keys.truncate(start + len);
                         *max_remaining_values -= len;
                         Ok(len)
                     }
@@ -359,15 +350,12 @@ where
 
                         assert_eq!(dict.data_type(), &self.value_type);
 
-                        let dict_buffers = dict.data().buffers();
+                        let data = dict.to_data();
+                        let dict_buffers = data.buffers();
                         let dict_offsets = dict_buffers[0].typed_data::<V>();
                         let dict_values = dict_buffers[1].as_slice();
 
-                        values.extend_from_dictionary(
-                            &keys[..len],
-                            dict_offsets,
-                            dict_values,
-                        )?;
+                        values.extend_from_dictionary(&keys[..len], dict_offsets, dict_values)?;
                         *max_remaining_values -= len;
                         Ok(len)
                     }
@@ -378,9 +366,7 @@ where
 
     fn skip_values(&mut self, num_values: usize) -> Result<usize> {
         match self.decoder.as_mut().expect("decoder set") {
-            MaybeDictionaryDecoder::Fallback(decoder) => {
-                decoder.skip::<V>(num_values, None)
-            }
+            MaybeDictionaryDecoder::Fallback(decoder) => decoder.skip::<V>(num_values, None),
             MaybeDictionaryDecoder::Dict {
                 decoder,
                 max_remaining_values,
@@ -395,8 +381,9 @@ where
 
 #[cfg(test)]
 mod tests {
-    use arrow::array::{Array, StringArray};
     use arrow::compute::cast;
+    use arrow_array::{Array, StringArray};
+    use arrow_buffer::Buffer;
 
     use crate::arrow::array_reader::test_util::{
         byte_array_all_encodings, encode_dictionary, utf8_column,
@@ -432,7 +419,7 @@ mod tests {
             .unwrap();
 
         let mut output = DictionaryBuffer::<i32, i32>::default();
-        assert_eq!(decoder.read(&mut output, 0..3).unwrap(), 3);
+        assert_eq!(decoder.read(&mut output, 3).unwrap(), 3);
 
         let mut valid = vec![false, false, true, true, false, true];
         let valid_buffer = Buffer::from_iter(valid.iter().cloned());
@@ -440,7 +427,7 @@ mod tests {
 
         assert!(matches!(output, DictionaryBuffer::Dict { .. }));
 
-        assert_eq!(decoder.read(&mut output, 0..4).unwrap(), 4);
+        assert_eq!(decoder.read(&mut output, 4).unwrap(), 4);
 
         valid.extend_from_slice(&[false, false, true, true, false, true, true, false]);
         let valid_buffer = Buffer::from_iter(valid.iter().cloned());
@@ -500,20 +487,20 @@ mod tests {
         let mut output = DictionaryBuffer::<i32, i32>::default();
 
         // read two skip one
-        assert_eq!(decoder.read(&mut output, 0..2).unwrap(), 2);
+        assert_eq!(decoder.read(&mut output, 2).unwrap(), 2);
         assert_eq!(decoder.skip_values(1).unwrap(), 1);
 
         assert!(matches!(output, DictionaryBuffer::Dict { .. }));
 
         // read two skip one
-        assert_eq!(decoder.read(&mut output, 2..4).unwrap(), 2);
+        assert_eq!(decoder.read(&mut output, 2).unwrap(), 2);
         assert_eq!(decoder.skip_values(1).unwrap(), 1);
 
         // read one and test on skip at the end
-        assert_eq!(decoder.read(&mut output, 4..5).unwrap(), 1);
+        assert_eq!(decoder.read(&mut output, 1).unwrap(), 1);
         assert_eq!(decoder.skip_values(4).unwrap(), 0);
 
-        let valid = vec![true, true, true, true, true];
+        let valid = [true, true, true, true, true];
         let valid_buffer = Buffer::from_iter(valid.iter().cloned());
         output.pad_nulls(0, 5, 5, valid_buffer.as_slice());
 
@@ -528,13 +515,7 @@ mod tests {
 
         assert_eq!(
             strings.iter().collect::<Vec<_>>(),
-            vec![
-                Some("0"),
-                Some("1"),
-                Some("1"),
-                Some("2"),
-                Some("2"),
-            ]
+            vec![Some("0"), Some("1"), Some("1"), Some("2"), Some("2"),]
         )
     }
 
@@ -558,7 +539,7 @@ mod tests {
 
         for (encoding, page) in pages {
             decoder.set_data(encoding, page, 4, Some(4)).unwrap();
-            assert_eq!(decoder.read(&mut output, 0..1024).unwrap(), 4);
+            assert_eq!(decoder.read(&mut output, 1024).unwrap(), 4);
         }
         let array = output.into_array(None, &data_type).unwrap();
         assert_eq!(array.data_type(), &data_type);
@@ -602,7 +583,7 @@ mod tests {
         for (encoding, page) in pages {
             decoder.set_data(encoding, page, 4, Some(4)).unwrap();
             decoder.skip_values(2).expect("skipping two values");
-            assert_eq!(decoder.read(&mut output, 0..1024).unwrap(), 2);
+            assert_eq!(decoder.read(&mut output, 1024).unwrap(), 2);
         }
         let array = output.into_array(None, &data_type).unwrap();
         assert_eq!(array.data_type(), &data_type);
@@ -625,7 +606,6 @@ mod tests {
         }
     }
 
-
     #[test]
     fn test_too_large_dictionary() {
         let data: Vec<_> = (0..128)
@@ -664,7 +644,7 @@ mod tests {
         for (encoding, page) in pages.clone() {
             let mut output = DictionaryBuffer::<i32, i32>::default();
             decoder.set_data(encoding, page, 8, None).unwrap();
-            assert_eq!(decoder.read(&mut output, 0..1024).unwrap(), 0);
+            assert_eq!(decoder.read(&mut output, 1024).unwrap(), 0);
 
             output.pad_nulls(0, 0, 8, &[0]);
             let array = output
diff --git a/parquet/src/arrow/array_reader/complex_object_array.rs b/parquet/src/arrow/array_reader/complex_object_array.rs
deleted file mode 100644
index 4f958fea446f..000000000000
--- a/parquet/src/arrow/array_reader/complex_object_array.rs
+++ /dev/null
@@ -1,605 +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.
-
-use crate::arrow::array_reader::ArrayReader;
-use crate::arrow::buffer::converter::Converter;
-use crate::arrow::schema::parquet_to_arrow_field;
-use crate::column::page::PageIterator;
-use crate::column::reader::ColumnReaderImpl;
-use crate::data_type::DataType;
-use crate::errors::Result;
-use crate::schema::types::ColumnDescPtr;
-use arrow::array::ArrayRef;
-use arrow::datatypes::DataType as ArrowType;
-use std::any::Any;
-use std::marker::PhantomData;
-
-/// Primitive array readers are leaves of array reader tree. They accept page iterator
-/// and read them into primitive arrays.
-pub struct ComplexObjectArrayReader<T, C>
-where
-    T: DataType,
-    C: Converter<Vec<Option<T::T>>, ArrayRef> + 'static,
-{
-    data_type: ArrowType,
-    pages: Box<dyn PageIterator>,
-    def_levels_buffer: Option<Vec<i16>>,
-    rep_levels_buffer: Option<Vec<i16>>,
-    data_buffer: Vec<T::T>,
-    column_desc: ColumnDescPtr,
-    column_reader: Option<ColumnReaderImpl<T>>,
-    converter: C,
-    in_progress_def_levels_buffer: Option<Vec<i16>>,
-    in_progress_rep_levels_buffer: Option<Vec<i16>>,
-    before_consume: bool,
-    _parquet_type_marker: PhantomData<T>,
-    _converter_marker: PhantomData<C>,
-}
-
-impl<T, C> ArrayReader for ComplexObjectArrayReader<T, C>
-where
-    T: DataType,
-    C: Converter<Vec<Option<T::T>>, ArrayRef> + Send + 'static,
-{
-    fn as_any(&self) -> &dyn Any {
-        self
-    }
-
-    fn get_data_type(&self) -> &ArrowType {
-        &self.data_type
-    }
-
-    fn read_records(&mut self, batch_size: usize) -> Result<usize> {
-        if !self.before_consume {
-            self.before_consume = true;
-        }
-        // Try to initialize column reader
-        if self.column_reader.is_none() {
-            self.next_column_reader()?;
-        }
-
-        let mut data_buffer: Vec<T::T> = Vec::with_capacity(batch_size);
-        data_buffer.resize_with(batch_size, T::T::default);
-
-        let mut def_levels_buffer = if self.column_desc.max_def_level() > 0 {
-            let mut buf: Vec<i16> = Vec::with_capacity(batch_size);
-            buf.resize_with(batch_size, || 0);
-            Some(buf)
-        } else {
-            None
-        };
-
-        let mut rep_levels_buffer = if self.column_desc.max_rep_level() > 0 {
-            let mut buf: Vec<i16> = Vec::with_capacity(batch_size);
-            buf.resize_with(batch_size, || 0);
-            Some(buf)
-        } else {
-            None
-        };
-
-        let mut num_read = 0;
-
-        while self.column_reader.is_some() && num_read < batch_size {
-            let num_to_read = batch_size - num_read;
-            let cur_data_buf = &mut data_buffer[num_read..];
-            let cur_def_levels_buf =
-                def_levels_buffer.as_mut().map(|b| &mut b[num_read..]);
-            let cur_rep_levels_buf =
-                rep_levels_buffer.as_mut().map(|b| &mut b[num_read..]);
-            let (data_read, levels_read) =
-                self.column_reader.as_mut().unwrap().read_batch(
-                    num_to_read,
-                    cur_def_levels_buf,
-                    cur_rep_levels_buf,
-                    cur_data_buf,
-                )?;
-
-            // Fill space
-            if levels_read > data_read {
-                def_levels_buffer.iter().for_each(|def_levels_buffer| {
-                    let (mut level_pos, mut data_pos) = (levels_read, data_read);
-                    while level_pos > 0 && data_pos > 0 {
-                        if def_levels_buffer[num_read + level_pos - 1]
-                            == self.column_desc.max_def_level()
-                        {
-                            cur_data_buf.swap(level_pos - 1, data_pos - 1);
-                            level_pos -= 1;
-                            data_pos -= 1;
-                        } else {
-                            level_pos -= 1;
-                        }
-                    }
-                });
-            }
-
-            let values_read = levels_read.max(data_read);
-            num_read += values_read;
-            // current page exhausted && page iterator exhausted
-            if values_read < num_to_read && !self.next_column_reader()? {
-                break;
-            }
-        }
-        data_buffer.truncate(num_read);
-        def_levels_buffer
-            .iter_mut()
-            .for_each(|buf| buf.truncate(num_read));
-        rep_levels_buffer
-            .iter_mut()
-            .for_each(|buf| buf.truncate(num_read));
-
-        if let Some(mut def_levels_buffer) = def_levels_buffer {
-            match &mut self.in_progress_def_levels_buffer {
-                None => {
-                    self.in_progress_def_levels_buffer = Some(def_levels_buffer);
-                }
-                Some(buf) => buf.append(&mut def_levels_buffer),
-            }
-        }
-
-        if let Some(mut rep_levels_buffer) = rep_levels_buffer {
-            match &mut self.in_progress_rep_levels_buffer {
-                None => {
-                    self.in_progress_rep_levels_buffer = Some(rep_levels_buffer);
-                }
-                Some(buf) => buf.append(&mut rep_levels_buffer),
-            }
-        }
-
-        self.data_buffer.append(&mut data_buffer);
-
-        Ok(num_read)
-    }
-
-    fn consume_batch(&mut self) -> Result<ArrayRef> {
-        let data: Vec<Option<T::T>> = if self.in_progress_def_levels_buffer.is_some() {
-            let data_buffer = std::mem::take(&mut self.data_buffer);
-            data_buffer
-                .into_iter()
-                .zip(self.in_progress_def_levels_buffer.as_ref().unwrap().iter())
-                .map(|(t, def_level)| {
-                    if *def_level == self.column_desc.max_def_level() {
-                        Some(t)
-                    } else {
-                        None
-                    }
-                })
-                .collect()
-        } else {
-            self.data_buffer.iter().map(|x| Some(x.clone())).collect()
-        };
-
-        let mut array = self.converter.convert(data)?;
-
-        if let ArrowType::Dictionary(_, _) = self.data_type {
-            array = arrow::compute::cast(&array, &self.data_type)?;
-        }
-
-        self.data_buffer = vec![];
-        self.def_levels_buffer = std::mem::take(&mut self.in_progress_def_levels_buffer);
-        self.rep_levels_buffer = std::mem::take(&mut self.in_progress_rep_levels_buffer);
-        self.before_consume = false;
-
-        Ok(array)
-    }
-
-    fn skip_records(&mut self, num_records: usize) -> Result<usize> {
-        let mut num_read = 0;
-        while (self.column_reader.is_some() || self.next_column_reader()?)
-            && num_read < num_records
-        {
-            let remain_to_skip = num_records - num_read;
-            let skip = self
-                .column_reader
-                .as_mut()
-                .unwrap()
-                .skip_records(remain_to_skip)?;
-            num_read += skip;
-            //  skip < remain_to_skip means end of row group
-            //  self.next_column_reader() == false means end of file
-            if skip < remain_to_skip && !self.next_column_reader()? {
-                break;
-            }
-        }
-        Ok(num_read)
-    }
-
-    fn get_def_levels(&self) -> Option<&[i16]> {
-        if self.before_consume {
-            self.in_progress_def_levels_buffer.as_deref()
-        } else {
-            self.def_levels_buffer.as_deref()
-        }
-    }
-
-    fn get_rep_levels(&self) -> Option<&[i16]> {
-        if self.before_consume {
-            self.in_progress_rep_levels_buffer.as_deref()
-        } else {
-            self.rep_levels_buffer.as_deref()
-        }
-    }
-}
-
-impl<T, C> ComplexObjectArrayReader<T, C>
-where
-    T: DataType,
-    C: Converter<Vec<Option<T::T>>, ArrayRef> + 'static,
-{
-    pub fn new(
-        pages: Box<dyn PageIterator>,
-        column_desc: ColumnDescPtr,
-        converter: C,
-        arrow_type: Option<ArrowType>,
-    ) -> Result<Self> {
-        let data_type = match arrow_type {
-            Some(t) => t,
-            None => parquet_to_arrow_field(column_desc.as_ref())?
-                .data_type()
-                .clone(),
-        };
-
-        Ok(Self {
-            data_type,
-            pages,
-            def_levels_buffer: None,
-            rep_levels_buffer: None,
-            data_buffer: vec![],
-            column_desc,
-            column_reader: None,
-            converter,
-            in_progress_def_levels_buffer: None,
-            in_progress_rep_levels_buffer: None,
-            before_consume: true,
-            _parquet_type_marker: PhantomData,
-            _converter_marker: PhantomData,
-        })
-    }
-
-    fn next_column_reader(&mut self) -> Result<bool> {
-        Ok(match self.pages.next() {
-            Some(page) => {
-                self.column_reader =
-                    Some(ColumnReaderImpl::<T>::new(self.column_desc.clone(), page?));
-                true
-            }
-            None => false,
-        })
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::arrow::buffer::converter::{Utf8ArrayConverter, Utf8Converter};
-    use crate::basic::Encoding;
-    use crate::column::page::Page;
-    use crate::data_type::{ByteArray, ByteArrayType};
-    use crate::schema::parser::parse_message_type;
-    use crate::schema::types::SchemaDescriptor;
-    use crate::util::{DataPageBuilder, DataPageBuilderImpl, InMemoryPageIterator};
-    use arrow::array::StringArray;
-    use rand::{thread_rng, Rng};
-    use std::sync::Arc;
-
-    #[test]
-    fn test_complex_array_reader_no_pages() {
-        let message_type = "
-        message test_schema {
-            REPEATED Group test_mid {
-                OPTIONAL BYTE_ARRAY leaf (UTF8);
-            }
-        }
-        ";
-        let schema = parse_message_type(message_type)
-            .map(|t| Arc::new(SchemaDescriptor::new(Arc::new(t))))
-            .unwrap();
-        let column_desc = schema.column(0);
-        let pages: Vec<Vec<Page>> = Vec::new();
-        let page_iterator = InMemoryPageIterator::new(schema, column_desc.clone(), pages);
-
-        let converter = Utf8Converter::new(Utf8ArrayConverter {});
-        let mut array_reader =
-            ComplexObjectArrayReader::<ByteArrayType, Utf8Converter>::new(
-                Box::new(page_iterator),
-                column_desc,
-                converter,
-                None,
-            )
-            .unwrap();
-
-        let values_per_page = 100; // this value is arbitrary in this test - the result should always be an array of 0 length
-        let array = array_reader.next_batch(values_per_page).unwrap();
-        assert_eq!(array.len(), 0);
-    }
-
-    #[test]
-    fn test_complex_array_reader_def_and_rep_levels() {
-        // Construct column schema
-        let message_type = "
-        message test_schema {
-            REPEATED Group test_mid {
-                OPTIONAL BYTE_ARRAY leaf (UTF8);
-            }
-        }
-        ";
-        let num_pages = 2;
-        let values_per_page = 100;
-        let str_base = "Hello World";
-
-        let schema = parse_message_type(message_type)
-            .map(|t| Arc::new(SchemaDescriptor::new(Arc::new(t))))
-            .unwrap();
-
-        let max_def_level = schema.column(0).max_def_level();
-        let max_rep_level = schema.column(0).max_rep_level();
-
-        assert_eq!(max_def_level, 2);
-        assert_eq!(max_rep_level, 1);
-
-        let mut rng = thread_rng();
-        let column_desc = schema.column(0);
-        let mut pages: Vec<Vec<Page>> = Vec::new();
-
-        let mut rep_levels = Vec::with_capacity(num_pages * values_per_page);
-        let mut def_levels = Vec::with_capacity(num_pages * values_per_page);
-        let mut all_values = Vec::with_capacity(num_pages * values_per_page);
-
-        for i in 0..num_pages {
-            let mut values = Vec::with_capacity(values_per_page);
-
-            for _ in 0..values_per_page {
-                let def_level = rng.gen_range(0..max_def_level + 1);
-                let rep_level = rng.gen_range(0..max_rep_level + 1);
-                if def_level == max_def_level {
-                    let len = rng.gen_range(1..str_base.len());
-                    let slice = &str_base[..len];
-                    values.push(ByteArray::from(slice));
-                    all_values.push(Some(slice.to_string()));
-                } else {
-                    all_values.push(None)
-                }
-                rep_levels.push(rep_level);
-                def_levels.push(def_level)
-            }
-
-            let range = i * values_per_page..(i + 1) * values_per_page;
-            let mut pb =
-                DataPageBuilderImpl::new(column_desc.clone(), values.len() as u32, true);
-
-            pb.add_rep_levels(max_rep_level, &rep_levels.as_slice()[range.clone()]);
-            pb.add_def_levels(max_def_level, &def_levels.as_slice()[range]);
-            pb.add_values::<ByteArrayType>(Encoding::PLAIN, values.as_slice());
-
-            let data_page = pb.consume();
-            pages.push(vec![data_page]);
-        }
-
-        let page_iterator = InMemoryPageIterator::new(schema, column_desc.clone(), pages);
-
-        let converter = Utf8Converter::new(Utf8ArrayConverter {});
-        let mut array_reader =
-            ComplexObjectArrayReader::<ByteArrayType, Utf8Converter>::new(
-                Box::new(page_iterator),
-                column_desc,
-                converter,
-                None,
-            )
-            .unwrap();
-
-        let mut accu_len: usize = 0;
-
-        let len = array_reader.read_records(values_per_page / 2).unwrap();
-        assert_eq!(len, values_per_page / 2);
-        assert_eq!(
-            Some(&def_levels[accu_len..(accu_len + len)]),
-            array_reader.get_def_levels()
-        );
-        assert_eq!(
-            Some(&rep_levels[accu_len..(accu_len + len)]),
-            array_reader.get_rep_levels()
-        );
-        accu_len += len;
-        array_reader.consume_batch().unwrap();
-
-        // Read next values_per_page values, the first values_per_page/2 ones are from the first column chunk,
-        // and the last values_per_page/2 ones are from the second column chunk
-        let len = array_reader.read_records(values_per_page).unwrap();
-        assert_eq!(len, values_per_page);
-        assert_eq!(
-            Some(&def_levels[accu_len..(accu_len + len)]),
-            array_reader.get_def_levels()
-        );
-        assert_eq!(
-            Some(&rep_levels[accu_len..(accu_len + len)]),
-            array_reader.get_rep_levels()
-        );
-        let array = array_reader.consume_batch().unwrap();
-        let strings = array.as_any().downcast_ref::<StringArray>().unwrap();
-        for i in 0..array.len() {
-            if array.is_valid(i) {
-                assert_eq!(
-                    all_values[i + accu_len].as_ref().unwrap().as_str(),
-                    strings.value(i)
-                )
-            } else {
-                assert_eq!(all_values[i + accu_len], None)
-            }
-        }
-        accu_len += len;
-
-        // Try to read values_per_page values, however there are only values_per_page/2 values
-        let len = array_reader.read_records(values_per_page).unwrap();
-        assert_eq!(len, values_per_page / 2);
-        assert_eq!(
-            Some(&def_levels[accu_len..(accu_len + len)]),
-            array_reader.get_def_levels()
-        );
-        assert_eq!(
-            Some(&rep_levels[accu_len..(accu_len + len)]),
-            array_reader.get_rep_levels()
-        );
-        array_reader.consume_batch().unwrap();
-    }
-
-    #[test]
-    fn test_complex_array_reader_dict_enc_string() {
-        use crate::encodings::encoding::{DictEncoder, Encoder};
-        // Construct column schema
-        let message_type = "
-        message test_schema {
-            REPEATED Group test_mid {
-                OPTIONAL BYTE_ARRAY leaf (UTF8);
-            }
-        }
-        ";
-        let num_pages = 2;
-        let values_per_page = 100;
-        let str_base = "Hello World";
-
-        let schema = parse_message_type(message_type)
-            .map(|t| Arc::new(SchemaDescriptor::new(Arc::new(t))))
-            .unwrap();
-        let column_desc = schema.column(0);
-        let max_def_level = column_desc.max_def_level();
-        let max_rep_level = column_desc.max_rep_level();
-
-        assert_eq!(max_def_level, 2);
-        assert_eq!(max_rep_level, 1);
-
-        let mut rng = thread_rng();
-        let mut pages: Vec<Vec<Page>> = Vec::new();
-
-        let mut rep_levels = Vec::with_capacity(num_pages * values_per_page);
-        let mut def_levels = Vec::with_capacity(num_pages * values_per_page);
-        let mut all_values = Vec::with_capacity(num_pages * values_per_page);
-
-        for i in 0..num_pages {
-            let mut dict_encoder = DictEncoder::<ByteArrayType>::new(column_desc.clone());
-            // add data page
-            let mut values = Vec::with_capacity(values_per_page);
-
-            for _ in 0..values_per_page {
-                let def_level = rng.gen_range(0..max_def_level + 1);
-                let rep_level = rng.gen_range(0..max_rep_level + 1);
-                if def_level == max_def_level {
-                    let len = rng.gen_range(1..str_base.len());
-                    let slice = &str_base[..len];
-                    values.push(ByteArray::from(slice));
-                    all_values.push(Some(slice.to_string()));
-                } else {
-                    all_values.push(None)
-                }
-                rep_levels.push(rep_level);
-                def_levels.push(def_level)
-            }
-
-            let range = i * values_per_page..(i + 1) * values_per_page;
-            let mut pb =
-                DataPageBuilderImpl::new(column_desc.clone(), values.len() as u32, true);
-            pb.add_rep_levels(max_rep_level, &rep_levels.as_slice()[range.clone()]);
-            pb.add_def_levels(max_def_level, &def_levels.as_slice()[range]);
-            let _ = dict_encoder.put(&values);
-            let indices = dict_encoder
-                .write_indices()
-                .expect("write_indices() should be OK");
-            pb.add_indices(indices);
-            let data_page = pb.consume();
-            // for each page log num_values vs actual values in page
-            // println!("page num_values: {}, values.len(): {}", data_page.num_values(), values.len());
-            // add dictionary page
-            let dict = dict_encoder
-                .write_dict()
-                .expect("write_dict() should be OK");
-            let dict_page = Page::DictionaryPage {
-                buf: dict,
-                num_values: dict_encoder.num_entries() as u32,
-                encoding: Encoding::RLE_DICTIONARY,
-                is_sorted: false,
-            };
-            pages.push(vec![dict_page, data_page]);
-        }
-
-        let page_iterator = InMemoryPageIterator::new(schema, column_desc.clone(), pages);
-        let converter = Utf8Converter::new(Utf8ArrayConverter {});
-        let mut array_reader =
-            ComplexObjectArrayReader::<ByteArrayType, Utf8Converter>::new(
-                Box::new(page_iterator),
-                column_desc,
-                converter,
-                None,
-            )
-            .unwrap();
-
-        let mut accu_len: usize = 0;
-
-        // println!("---------- reading a batch of {} values ----------", values_per_page / 2);
-        let len = array_reader.read_records(values_per_page / 2).unwrap();
-        assert_eq!(len, values_per_page / 2);
-        assert_eq!(
-            Some(&def_levels[accu_len..(accu_len + len)]),
-            array_reader.get_def_levels()
-        );
-        assert_eq!(
-            Some(&rep_levels[accu_len..(accu_len + len)]),
-            array_reader.get_rep_levels()
-        );
-        accu_len += len;
-        array_reader.consume_batch().unwrap();
-
-        // Read next values_per_page values, the first values_per_page/2 ones are from the first column chunk,
-        // and the last values_per_page/2 ones are from the second column chunk
-        // println!("---------- reading a batch of {} values ----------", values_per_page);
-        //let array = array_reader.next_batch(values_per_page).unwrap();
-        let len = array_reader.read_records(values_per_page).unwrap();
-        assert_eq!(len, values_per_page);
-        assert_eq!(
-            Some(&def_levels[accu_len..(accu_len + len)]),
-            array_reader.get_def_levels()
-        );
-        assert_eq!(
-            Some(&rep_levels[accu_len..(accu_len + len)]),
-            array_reader.get_rep_levels()
-        );
-        let array = array_reader.consume_batch().unwrap();
-        let strings = array.as_any().downcast_ref::<StringArray>().unwrap();
-        for i in 0..array.len() {
-            if array.is_valid(i) {
-                assert_eq!(
-                    all_values[i + accu_len].as_ref().unwrap().as_str(),
-                    strings.value(i)
-                )
-            } else {
-                assert_eq!(all_values[i + accu_len], None)
-            }
-        }
-        accu_len += len;
-
-        // Try to read values_per_page values, however there are only values_per_page/2 values
-        // println!("---------- reading a batch of {} values ----------", values_per_page);
-        let len = array_reader.read_records(values_per_page).unwrap();
-        assert_eq!(len, values_per_page / 2);
-        assert_eq!(
-            Some(&def_levels[accu_len..(accu_len + len)]),
-            array_reader.get_def_levels()
-        );
-        assert_eq!(
-            Some(&rep_levels[accu_len..(accu_len + len)]),
-            array_reader.get_rep_levels()
-        );
-        array_reader.consume_batch().unwrap();
-    }
-}
diff --git a/parquet/src/arrow/array_reader/empty_array.rs b/parquet/src/arrow/array_reader/empty_array.rs
index abe839b9dc29..51673f2f8cf2 100644
--- a/parquet/src/arrow/array_reader/empty_array.rs
+++ b/parquet/src/arrow/array_reader/empty_array.rs
@@ -17,8 +17,9 @@
 
 use crate::arrow::array_reader::ArrayReader;
 use crate::errors::Result;
-use arrow::array::{ArrayDataBuilder, ArrayRef, StructArray};
-use arrow::datatypes::DataType as ArrowType;
+use arrow_schema::{DataType as ArrowType, Fields};
+use arrow_array::{ArrayRef, StructArray};
+use arrow_data::ArrayDataBuilder;
 use std::any::Any;
 use std::sync::Arc;
 
@@ -39,7 +40,7 @@ struct EmptyArrayReader {
 impl EmptyArrayReader {
     pub fn new(row_count: usize) -> Self {
         Self {
-            data_type: ArrowType::Struct(vec![]),
+            data_type: ArrowType::Struct(Fields::empty()),
             remaining_rows: row_count,
             need_consume_records: 0,
         }
diff --git a/parquet/src/arrow/array_reader/fixed_len_byte_array.rs b/parquet/src/arrow/array_reader/fixed_len_byte_array.rs
new file mode 100644
index 000000000000..a0d25d403c1b
--- /dev/null
+++ b/parquet/src/arrow/array_reader/fixed_len_byte_array.rs
@@ -0,0 +1,467 @@
+// 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.
+
+use crate::arrow::array_reader::{read_records, skip_records, ArrayReader};
+use crate::arrow::buffer::bit_util::{iter_set_bits_rev, sign_extend_be};
+use crate::arrow::decoder::{DeltaByteArrayDecoder, DictIndexDecoder};
+use crate::arrow::record_reader::buffer::ValuesBuffer;
+use crate::arrow::record_reader::GenericRecordReader;
+use crate::arrow::schema::parquet_to_arrow_field;
+use crate::basic::{Encoding, Type};
+use crate::column::page::PageIterator;
+use crate::column::reader::decoder::ColumnValueDecoder;
+use crate::errors::{ParquetError, Result};
+use crate::schema::types::ColumnDescPtr;
+use arrow_array::{
+    ArrayRef, Decimal128Array, Decimal256Array, FixedSizeBinaryArray, Float16Array,
+    IntervalDayTimeArray, IntervalYearMonthArray,
+};
+use arrow_buffer::{i256, Buffer};
+use arrow_data::ArrayDataBuilder;
+use arrow_schema::{DataType as ArrowType, IntervalUnit};
+use bytes::Bytes;
+use half::f16;
+use std::any::Any;
+use std::sync::Arc;
+
+/// Returns an [`ArrayReader`] that decodes the provided fixed length byte array column
+pub fn make_fixed_len_byte_array_reader(
+    pages: Box<dyn PageIterator>,
+    column_desc: ColumnDescPtr,
+    arrow_type: Option<ArrowType>,
+) -> Result<Box<dyn ArrayReader>> {
+    // Check if Arrow type is specified, else create it from Parquet type
+    let data_type = match arrow_type {
+        Some(t) => t,
+        None => parquet_to_arrow_field(column_desc.as_ref())?
+            .data_type()
+            .clone(),
+    };
+
+    let byte_length = match column_desc.physical_type() {
+        Type::FIXED_LEN_BYTE_ARRAY => column_desc.type_length() as usize,
+        t => {
+            return Err(general_err!(
+                "invalid physical type for fixed length byte array reader - {}",
+                t
+            ))
+        }
+    };
+    match &data_type {
+        ArrowType::FixedSizeBinary(_) => {}
+        ArrowType::Decimal128(_, _) => {
+            if byte_length > 16 {
+                return Err(general_err!(
+                    "decimal 128 type too large, must be less than 16 bytes, got {}",
+                    byte_length
+                ));
+            }
+        }
+        ArrowType::Decimal256(_, _) => {
+            if byte_length > 32 {
+                return Err(general_err!(
+                    "decimal 256 type too large, must be less than 32 bytes, got {}",
+                    byte_length
+                ));
+            }
+        }
+        ArrowType::Interval(_) => {
+            if byte_length != 12 {
+                // https://github.com/apache/parquet-format/blob/master/LogicalTypes.md#interval
+                return Err(general_err!(
+                    "interval type must consist of 12 bytes got {}",
+                    byte_length
+                ));
+            }
+        }
+        ArrowType::Float16 => {
+            if byte_length != 2 {
+                return Err(general_err!(
+                    "float 16 type must be 2 bytes, got {}",
+                    byte_length
+                ));
+            }
+        }
+        _ => {
+            return Err(general_err!(
+                "invalid data type for fixed length byte array reader - {}",
+                data_type
+            ))
+        }
+    }
+
+    Ok(Box::new(FixedLenByteArrayReader::new(
+        pages,
+        column_desc,
+        data_type,
+        byte_length,
+    )))
+}
+
+struct FixedLenByteArrayReader {
+    data_type: ArrowType,
+    byte_length: usize,
+    pages: Box<dyn PageIterator>,
+    def_levels_buffer: Option<Vec<i16>>,
+    rep_levels_buffer: Option<Vec<i16>>,
+    record_reader: GenericRecordReader<FixedLenByteArrayBuffer, ValueDecoder>,
+}
+
+impl FixedLenByteArrayReader {
+    fn new(
+        pages: Box<dyn PageIterator>,
+        column_desc: ColumnDescPtr,
+        data_type: ArrowType,
+        byte_length: usize,
+    ) -> Self {
+        Self {
+            data_type,
+            byte_length,
+            pages,
+            def_levels_buffer: None,
+            rep_levels_buffer: None,
+            record_reader: GenericRecordReader::new(column_desc),
+        }
+    }
+}
+
+impl ArrayReader for FixedLenByteArrayReader {
+    fn as_any(&self) -> &dyn Any {
+        self
+    }
+
+    fn get_data_type(&self) -> &ArrowType {
+        &self.data_type
+    }
+
+    fn read_records(&mut self, batch_size: usize) -> Result<usize> {
+        read_records(&mut self.record_reader, self.pages.as_mut(), batch_size)
+    }
+
+    fn consume_batch(&mut self) -> Result<ArrayRef> {
+        let record_data = self.record_reader.consume_record_data();
+
+        let array_data = ArrayDataBuilder::new(ArrowType::FixedSizeBinary(self.byte_length as i32))
+            .len(self.record_reader.num_values())
+            .add_buffer(Buffer::from_vec(record_data.buffer))
+            .null_bit_buffer(self.record_reader.consume_bitmap_buffer());
+
+        let binary = FixedSizeBinaryArray::from(unsafe { array_data.build_unchecked() });
+
+        // TODO: An improvement might be to do this conversion on read
+        let array: ArrayRef = match &self.data_type {
+            ArrowType::Decimal128(p, s) => {
+                let decimal = binary
+                    .iter()
+                    .map(|opt| Some(i128::from_be_bytes(sign_extend_be(opt?))))
+                    .collect::<Decimal128Array>()
+                    .with_precision_and_scale(*p, *s)?;
+
+                Arc::new(decimal)
+            }
+            ArrowType::Decimal256(p, s) => {
+                let decimal = binary
+                    .iter()
+                    .map(|opt| Some(i256::from_be_bytes(sign_extend_be(opt?))))
+                    .collect::<Decimal256Array>()
+                    .with_precision_and_scale(*p, *s)?;
+
+                Arc::new(decimal)
+            }
+            ArrowType::Interval(unit) => {
+                // An interval is stored as 3x 32-bit unsigned integers storing months, days,
+                // and milliseconds
+                match unit {
+                    IntervalUnit::YearMonth => Arc::new(
+                        binary
+                            .iter()
+                            .map(|o| o.map(|b| i32::from_le_bytes(b[0..4].try_into().unwrap())))
+                            .collect::<IntervalYearMonthArray>(),
+                    ) as ArrayRef,
+                    IntervalUnit::DayTime => Arc::new(
+                        binary
+                            .iter()
+                            .map(|o| o.map(|b| i64::from_le_bytes(b[4..12].try_into().unwrap())))
+                            .collect::<IntervalDayTimeArray>(),
+                    ) as ArrayRef,
+                    IntervalUnit::MonthDayNano => {
+                        return Err(nyi_err!("MonthDayNano intervals not supported"));
+                    }
+                }
+            }
+            ArrowType::Float16 => Arc::new(
+                binary
+                    .iter()
+                    .map(|o| o.map(|b| f16::from_le_bytes(b[..2].try_into().unwrap())))
+                    .collect::<Float16Array>(),
+            ) as ArrayRef,
+            _ => Arc::new(binary) as ArrayRef,
+        };
+
+        self.def_levels_buffer = self.record_reader.consume_def_levels();
+        self.rep_levels_buffer = self.record_reader.consume_rep_levels();
+        self.record_reader.reset();
+
+        Ok(array)
+    }
+
+    fn skip_records(&mut self, num_records: usize) -> Result<usize> {
+        skip_records(&mut self.record_reader, self.pages.as_mut(), num_records)
+    }
+
+    fn get_def_levels(&self) -> Option<&[i16]> {
+        self.def_levels_buffer.as_deref()
+    }
+
+    fn get_rep_levels(&self) -> Option<&[i16]> {
+        self.rep_levels_buffer.as_deref()
+    }
+}
+
+#[derive(Default)]
+struct FixedLenByteArrayBuffer {
+    buffer: Vec<u8>,
+    /// The length of each element in bytes
+    byte_length: Option<usize>,
+}
+
+impl ValuesBuffer for FixedLenByteArrayBuffer {
+    fn pad_nulls(
+        &mut self,
+        read_offset: usize,
+        values_read: usize,
+        levels_read: usize,
+        valid_mask: &[u8],
+    ) {
+        let byte_length = self.byte_length.unwrap_or_default();
+
+        assert_eq!(self.buffer.len(), (read_offset + values_read) * byte_length);
+        self.buffer
+            .resize((read_offset + levels_read) * byte_length, 0);
+
+        let values_range = read_offset..read_offset + values_read;
+        for (value_pos, level_pos) in values_range.rev().zip(iter_set_bits_rev(valid_mask)) {
+            debug_assert!(level_pos >= value_pos);
+            if level_pos <= value_pos {
+                break;
+            }
+
+            let level_pos_bytes = level_pos * byte_length;
+            let value_pos_bytes = value_pos * byte_length;
+
+            for i in 0..byte_length {
+                self.buffer[level_pos_bytes + i] = self.buffer[value_pos_bytes + i]
+            }
+        }
+    }
+}
+
+struct ValueDecoder {
+    byte_length: usize,
+    dict_page: Option<Bytes>,
+    decoder: Option<Decoder>,
+}
+
+impl ColumnValueDecoder for ValueDecoder {
+    type Buffer = FixedLenByteArrayBuffer;
+
+    fn new(col: &ColumnDescPtr) -> Self {
+        Self {
+            byte_length: col.type_length() as usize,
+            dict_page: None,
+            decoder: None,
+        }
+    }
+
+    fn set_dict(
+        &mut self,
+        buf: Bytes,
+        num_values: u32,
+        encoding: Encoding,
+        _is_sorted: bool,
+    ) -> Result<()> {
+        if !matches!(
+            encoding,
+            Encoding::PLAIN | Encoding::RLE_DICTIONARY | Encoding::PLAIN_DICTIONARY
+        ) {
+            return Err(nyi_err!(
+                "Invalid/Unsupported encoding type for dictionary: {}",
+                encoding
+            ));
+        }
+        let expected_len = num_values as usize * self.byte_length;
+        if expected_len > buf.len() {
+            return Err(general_err!(
+                "too few bytes in dictionary page, expected {} got {}",
+                expected_len,
+                buf.len()
+            ));
+        }
+
+        self.dict_page = Some(buf);
+        Ok(())
+    }
+
+    fn set_data(
+        &mut self,
+        encoding: Encoding,
+        data: Bytes,
+        num_levels: usize,
+        num_values: Option<usize>,
+    ) -> Result<()> {
+        self.decoder = Some(match encoding {
+            Encoding::PLAIN => Decoder::Plain {
+                buf: data,
+                offset: 0,
+            },
+            Encoding::RLE_DICTIONARY | Encoding::PLAIN_DICTIONARY => Decoder::Dict {
+                decoder: DictIndexDecoder::new(data, num_levels, num_values),
+            },
+            Encoding::DELTA_BYTE_ARRAY => Decoder::Delta {
+                decoder: DeltaByteArrayDecoder::new(data)?,
+            },
+            _ => {
+                return Err(general_err!(
+                    "unsupported encoding for fixed length byte array: {}",
+                    encoding
+                ))
+            }
+        });
+        Ok(())
+    }
+
+    fn read(&mut self, out: &mut Self::Buffer, num_values: usize) -> Result<usize> {
+        match out.byte_length {
+            Some(x) => assert_eq!(x, self.byte_length),
+            None => out.byte_length = Some(self.byte_length),
+        }
+
+        match self.decoder.as_mut().unwrap() {
+            Decoder::Plain { offset, buf } => {
+                let to_read =
+                    (num_values * self.byte_length).min(buf.len() - *offset) / self.byte_length;
+                let end_offset = *offset + to_read * self.byte_length;
+                out.buffer
+                    .extend_from_slice(&buf.as_ref()[*offset..end_offset]);
+                *offset = end_offset;
+                Ok(to_read)
+            }
+            Decoder::Dict { decoder } => {
+                let dict = self.dict_page.as_ref().unwrap();
+                // All data must be NULL
+                if dict.is_empty() {
+                    return Ok(0);
+                }
+
+                decoder.read(num_values, |keys| {
+                    out.buffer.reserve(keys.len() * self.byte_length);
+                    for key in keys {
+                        let offset = *key as usize * self.byte_length;
+                        let val = &dict.as_ref()[offset..offset + self.byte_length];
+                        out.buffer.extend_from_slice(val);
+                    }
+                    Ok(())
+                })
+            }
+            Decoder::Delta { decoder } => {
+                let to_read = num_values.min(decoder.remaining());
+                out.buffer.reserve(to_read * self.byte_length);
+
+                decoder.read(to_read, |slice| {
+                    if slice.len() != self.byte_length {
+                        return Err(general_err!(
+                            "encountered array with incorrect length, got {} expected {}",
+                            slice.len(),
+                            self.byte_length
+                        ));
+                    }
+                    out.buffer.extend_from_slice(slice);
+                    Ok(())
+                })
+            }
+        }
+    }
+
+    fn skip_values(&mut self, num_values: usize) -> Result<usize> {
+        match self.decoder.as_mut().unwrap() {
+            Decoder::Plain { offset, buf } => {
+                let to_read = num_values.min((buf.len() - *offset) / self.byte_length);
+                *offset += to_read * self.byte_length;
+                Ok(to_read)
+            }
+            Decoder::Dict { decoder } => decoder.skip(num_values),
+            Decoder::Delta { decoder } => decoder.skip(num_values),
+        }
+    }
+}
+
+enum Decoder {
+    Plain { buf: Bytes, offset: usize },
+    Dict { decoder: DictIndexDecoder },
+    Delta { decoder: DeltaByteArrayDecoder },
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::arrow::arrow_reader::ParquetRecordBatchReader;
+    use crate::arrow::ArrowWriter;
+    use arrow::datatypes::Field;
+    use arrow::error::Result as ArrowResult;
+    use arrow_array::RecordBatch;
+    use arrow_array::{Array, ListArray};
+    use bytes::Bytes;
+    use std::sync::Arc;
+
+    #[test]
+    fn test_decimal_list() {
+        let decimals = Decimal256Array::from_iter_values(
+            [1, 2, 3, 4, 5, 6, 7, 8].into_iter().map(i256::from_i128),
+        );
+
+        // [[], [1], [2, 3], null, [4], null, [6, 7, 8]]
+        let data = ArrayDataBuilder::new(ArrowType::List(Arc::new(Field::new(
+            "item",
+            decimals.data_type().clone(),
+            false,
+        ))))
+        .len(7)
+        .add_buffer(Buffer::from_iter([0_i32, 0, 1, 3, 3, 4, 5, 8]))
+        .null_bit_buffer(Some(Buffer::from(&[0b01010111])))
+        .child_data(vec![decimals.into_data()])
+        .build()
+        .unwrap();
+
+        let written =
+            RecordBatch::try_from_iter([("list", Arc::new(ListArray::from(data)) as ArrayRef)])
+                .unwrap();
+
+        let mut buffer = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buffer, written.schema(), None).unwrap();
+        writer.write(&written).unwrap();
+        writer.close().unwrap();
+
+        let read = ParquetRecordBatchReader::try_new(Bytes::from(buffer), 3)
+            .unwrap()
+            .collect::<ArrowResult<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(&written.slice(0, 3), &read[0]);
+        assert_eq!(&written.slice(3, 3), &read[1]);
+        assert_eq!(&written.slice(6, 1), &read[2]);
+    }
+}
diff --git a/parquet/src/arrow/array_reader/fixed_size_list_array.rs b/parquet/src/arrow/array_reader/fixed_size_list_array.rs
new file mode 100644
index 000000000000..4cf68a06601c
--- /dev/null
+++ b/parquet/src/arrow/array_reader/fixed_size_list_array.rs
@@ -0,0 +1,688 @@
+// 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.
+
+use std::cmp::Ordering;
+use std::sync::Arc;
+
+use crate::arrow::array_reader::ArrayReader;
+use crate::errors::ParquetError;
+use crate::errors::Result;
+use arrow_array::FixedSizeListArray;
+use arrow_array::{builder::BooleanBufferBuilder, new_empty_array, Array, ArrayRef};
+use arrow_data::{transform::MutableArrayData, ArrayData};
+use arrow_schema::DataType as ArrowType;
+
+/// Implementation of fixed-size list array reader.
+pub struct FixedSizeListArrayReader {
+    item_reader: Box<dyn ArrayReader>,
+    /// The number of child items in each row of the list array
+    fixed_size: usize,
+    data_type: ArrowType,
+    /// The definition level at which this list is not null
+    def_level: i16,
+    /// The repetition level that corresponds to a new value in this array
+    rep_level: i16,
+    /// If the list is nullable
+    nullable: bool,
+}
+
+impl FixedSizeListArrayReader {
+    /// Construct fixed-size list array reader.
+    pub fn new(
+        item_reader: Box<dyn ArrayReader>,
+        fixed_size: usize,
+        data_type: ArrowType,
+        def_level: i16,
+        rep_level: i16,
+        nullable: bool,
+    ) -> Self {
+        Self {
+            item_reader,
+            fixed_size,
+            data_type,
+            def_level,
+            rep_level,
+            nullable,
+        }
+    }
+}
+
+impl ArrayReader for FixedSizeListArrayReader {
+    fn as_any(&self) -> &dyn std::any::Any {
+        self
+    }
+
+    fn get_data_type(&self) -> &ArrowType {
+        &self.data_type
+    }
+
+    fn read_records(&mut self, batch_size: usize) -> Result<usize> {
+        let size = self.item_reader.read_records(batch_size)?;
+        Ok(size)
+    }
+
+    fn consume_batch(&mut self) -> Result<ArrayRef> {
+        let next_batch_array = self.item_reader.consume_batch()?;
+        if next_batch_array.len() == 0 {
+            return Ok(new_empty_array(&self.data_type));
+        }
+
+        let def_levels = self
+            .get_def_levels()
+            .ok_or_else(|| general_err!("item_reader def levels are None"))?;
+        let rep_levels = self
+            .get_rep_levels()
+            .ok_or_else(|| general_err!("item_reader rep levels are None"))?;
+
+        if !rep_levels.is_empty() && rep_levels[0] != 0 {
+            // This implies either the source data was invalid, or the leaf column
+            // reader did not correctly delimit semantic records
+            return Err(general_err!("first repetition level of batch must be 0"));
+        }
+
+        let mut validity = self
+            .nullable
+            .then(|| BooleanBufferBuilder::new(next_batch_array.len()));
+
+        let data = next_batch_array.to_data();
+        let mut child_data_builder =
+            MutableArrayData::new(vec![&data], true, next_batch_array.len());
+
+        // The current index into the child array entries
+        let mut child_idx = 0;
+        // The total number of rows (valid and invalid) in the list array
+        let mut list_len = 0;
+        // Start of the current run of valid values
+        let mut start_idx = None;
+        let mut row_len = 0;
+
+        def_levels.iter().zip(rep_levels).try_for_each(|(d, r)| {
+            match r.cmp(&self.rep_level) {
+                Ordering::Greater => {
+                    // Repetition level greater than current => already handled by inner array
+                    if *d < self.def_level {
+                        return Err(general_err!(
+                            "Encountered repetition level too large for definition level"
+                        ));
+                    }
+                }
+                Ordering::Equal => {
+                    // Item inside of the current list
+                    child_idx += 1;
+                    row_len += 1;
+                }
+                Ordering::Less => {
+                    // Start of new list row
+                    list_len += 1;
+
+                    // Length of the previous row should be equal to:
+                    // - the list's fixed size (valid entries)
+                    // - zero (null entries, start of array)
+                    // Any other length indicates invalid data
+                    if start_idx.is_some() && row_len != self.fixed_size {
+                        return Err(general_err!(
+                            "Encountered misaligned row with length {} (expected length {})",
+                            row_len,
+                            self.fixed_size
+                        ))
+                    }
+                    row_len = 0;
+
+                    if *d >= self.def_level {
+                        row_len += 1;
+
+                        // Valid list entry
+                        if let Some(validity) = validity.as_mut() {
+                            validity.append(true);
+                        }
+                        // Start a run of valid rows if not already inside of one
+                        start_idx.get_or_insert(child_idx);
+                    } else {
+                        // Null list entry
+
+                        if let Some(start) = start_idx.take() {
+                            // Flush pending child items
+                            child_data_builder.extend(0, start, child_idx);
+                        }
+                        // Pad list with nulls
+                        child_data_builder.extend_nulls(self.fixed_size);
+
+                        if let Some(validity) = validity.as_mut() {
+                            // Valid if empty list
+                            validity.append(*d + 1 == self.def_level);
+                        }
+                    }
+                    child_idx += 1;
+                }
+            }
+            Ok(())
+        })?;
+
+        let child_data = match start_idx {
+            Some(0) => {
+                // No null entries - can reuse original array
+                next_batch_array.to_data()
+            }
+            Some(start) => {
+                // Flush pending child items
+                child_data_builder.extend(0, start, child_idx);
+                child_data_builder.freeze()
+            }
+            None => child_data_builder.freeze(),
+        };
+
+        // Verify total number of elements is aligned with fixed list size
+        if list_len * self.fixed_size != child_data.len() {
+            return Err(general_err!(
+                "fixed-size list length must be a multiple of {} but array contains {} elements",
+                self.fixed_size,
+                child_data.len()
+            ));
+        }
+
+        let mut list_builder = ArrayData::builder(self.get_data_type().clone())
+            .len(list_len)
+            .add_child_data(child_data);
+
+        if let Some(builder) = validity {
+            list_builder = list_builder.null_bit_buffer(Some(builder.into()));
+        }
+
+        let list_data = unsafe { list_builder.build_unchecked() };
+
+        let result_array = FixedSizeListArray::from(list_data);
+        Ok(Arc::new(result_array))
+    }
+
+    fn skip_records(&mut self, num_records: usize) -> Result<usize> {
+        self.item_reader.skip_records(num_records)
+    }
+
+    fn get_def_levels(&self) -> Option<&[i16]> {
+        self.item_reader.get_def_levels()
+    }
+
+    fn get_rep_levels(&self) -> Option<&[i16]> {
+        self.item_reader.get_rep_levels()
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::arrow::{
+        array_reader::{test_util::InMemoryArrayReader, ListArrayReader},
+        arrow_reader::{
+            ArrowReaderBuilder, ArrowReaderOptions, ParquetRecordBatchReader,
+        },
+        ArrowWriter,
+    };
+    use arrow::datatypes::{Field, Int32Type};
+    use arrow_array::{
+        builder::{FixedSizeListBuilder, Int32Builder, ListBuilder},
+        cast::AsArray,
+        FixedSizeListArray, ListArray, PrimitiveArray, RecordBatch,
+    };
+    use arrow_buffer::Buffer;
+    use arrow_data::ArrayDataBuilder;
+    use arrow_schema::Schema;
+    use bytes::Bytes;
+
+    #[test]
+    fn test_nullable_list() {
+        // [null, [1, null, 2], null, [3, 4, 5], [null, null, null]]
+        let expected = FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+            vec![
+                None,
+                Some([Some(1), None, Some(2)]),
+                None,
+                Some([Some(3), Some(4), Some(5)]),
+                Some([None, None, None]),
+            ],
+            3,
+        );
+
+        let array = Arc::new(PrimitiveArray::<Int32Type>::from(vec![
+            None,
+            Some(1),
+            None,
+            Some(2),
+            None,
+            Some(3),
+            Some(4),
+            Some(5),
+            None,
+            None,
+            None,
+        ]));
+        let item_array_reader = InMemoryArrayReader::new(
+            ArrowType::Int32,
+            array,
+            Some(vec![0, 3, 2, 3, 0, 3, 3, 3, 2, 2, 2]),
+            Some(vec![0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1]),
+        );
+
+        let mut list_array_reader = FixedSizeListArrayReader::new(
+            Box::new(item_array_reader),
+            3,
+            ArrowType::FixedSizeList(
+                Arc::new(Field::new("item", ArrowType::Int32, true)),
+                3,
+            ),
+            2,
+            1,
+            true,
+        );
+        let actual = list_array_reader.next_batch(1024).unwrap();
+        let actual = actual
+            .as_any()
+            .downcast_ref::<FixedSizeListArray>()
+            .unwrap();
+        assert_eq!(&expected, actual)
+    }
+
+    #[test]
+    fn test_required_list() {
+        // [[1, null], [2, 3], [null, null], [4, 5]]
+        let expected = FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+            vec![
+                Some([Some(1), None]),
+                Some([Some(2), Some(3)]),
+                Some([None, None]),
+                Some([Some(4), Some(5)]),
+            ],
+            2,
+        );
+
+        let array = Arc::new(PrimitiveArray::<Int32Type>::from(vec![
+            Some(1),
+            None,
+            Some(2),
+            Some(3),
+            None,
+            None,
+            Some(4),
+            Some(5),
+        ]));
+        let item_array_reader = InMemoryArrayReader::new(
+            ArrowType::Int32,
+            array,
+            Some(vec![2, 1, 2, 2, 1, 1, 2, 2]),
+            Some(vec![0, 1, 0, 1, 0, 1, 0, 1]),
+        );
+
+        let mut list_array_reader = FixedSizeListArrayReader::new(
+            Box::new(item_array_reader),
+            2,
+            ArrowType::FixedSizeList(
+                Arc::new(Field::new("item", ArrowType::Int32, true)),
+                2,
+            ),
+            1,
+            1,
+            false,
+        );
+        let actual = list_array_reader.next_batch(1024).unwrap();
+        let actual = actual
+            .as_any()
+            .downcast_ref::<FixedSizeListArray>()
+            .unwrap();
+        assert_eq!(&expected, actual)
+    }
+
+    #[test]
+    fn test_nested_list() {
+        // [
+        //   null,
+        //   [[1, 2]],
+        //   [[null, 3]],
+        //   null,
+        //   [[4, 5]],
+        //   [[null, null]],
+        // ]
+        let l2_type = ArrowType::FixedSizeList(
+            Arc::new(Field::new("item", ArrowType::Int32, true)),
+            2,
+        );
+        let l1_type = ArrowType::FixedSizeList(
+            Arc::new(Field::new("item", l2_type.clone(), false)),
+            1,
+        );
+
+        let array = PrimitiveArray::<Int32Type>::from(vec![
+            None,
+            None,
+            Some(1),
+            Some(2),
+            None,
+            Some(3),
+            None,
+            None,
+            Some(4),
+            Some(5),
+            None,
+            None,
+        ]);
+
+        let l2 = ArrayDataBuilder::new(l2_type.clone())
+            .len(6)
+            .add_child_data(array.into_data())
+            .build()
+            .unwrap();
+
+        let l1 = ArrayDataBuilder::new(l1_type.clone())
+            .len(6)
+            .add_child_data(l2)
+            .null_bit_buffer(Some(Buffer::from([0b110110])))
+            .build()
+            .unwrap();
+
+        let expected = FixedSizeListArray::from(l1);
+
+        let values = Arc::new(PrimitiveArray::<Int32Type>::from(vec![
+            None,
+            Some(1),
+            Some(2),
+            None,
+            Some(3),
+            None,
+            Some(4),
+            Some(5),
+            None,
+            None,
+        ]));
+
+        let item_array_reader = InMemoryArrayReader::new(
+            ArrowType::Int32,
+            values,
+            Some(vec![0, 5, 5, 4, 5, 0, 5, 5, 4, 4]),
+            Some(vec![0, 0, 2, 0, 2, 0, 0, 2, 0, 2]),
+        );
+
+        let l2 = FixedSizeListArrayReader::new(
+            Box::new(item_array_reader),
+            2,
+            l2_type,
+            4,
+            2,
+            false,
+        );
+        let mut l1 = FixedSizeListArrayReader::new(Box::new(l2), 1, l1_type, 3, 1, true);
+
+        let expected_1 = expected.slice(0, 2);
+        let expected_2 = expected.slice(2, 4);
+
+        let actual = l1.next_batch(2).unwrap();
+        assert_eq!(actual.as_ref(), &expected_1);
+
+        let actual = l1.next_batch(1024).unwrap();
+        assert_eq!(actual.as_ref(), &expected_2);
+    }
+
+    #[test]
+    fn test_empty_list() {
+        // [null, [], null, []]
+        let expected = FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+            vec![None, Some([]), None, Some([])],
+            0,
+        );
+
+        let array = Arc::new(PrimitiveArray::<Int32Type>::from(vec![
+            None, None, None, None,
+        ]));
+        let item_array_reader = InMemoryArrayReader::new(
+            ArrowType::Int32,
+            array,
+            Some(vec![0, 1, 0, 1]),
+            Some(vec![0, 0, 0, 0]),
+        );
+
+        let mut list_array_reader = FixedSizeListArrayReader::new(
+            Box::new(item_array_reader),
+            0,
+            ArrowType::FixedSizeList(
+                Arc::new(Field::new("item", ArrowType::Int32, true)),
+                0,
+            ),
+            2,
+            1,
+            true,
+        );
+        let actual = list_array_reader.next_batch(1024).unwrap();
+        let actual = actual
+            .as_any()
+            .downcast_ref::<FixedSizeListArray>()
+            .unwrap();
+        assert_eq!(&expected, actual)
+    }
+
+    #[test]
+    fn test_nested_var_list() {
+        // [[[1, null, 3], null], [[4], []], [[5, 6], [null, null]], null]
+        let mut builder =
+            FixedSizeListBuilder::new(ListBuilder::new(Int32Builder::new()), 2);
+        builder.values().append_value([Some(1), None, Some(3)]);
+        builder.values().append_null();
+        builder.append(true);
+        builder.values().append_value([Some(4)]);
+        builder.values().append_value([]);
+        builder.append(true);
+        builder.values().append_value([Some(5), Some(6)]);
+        builder.values().append_value([None, None]);
+        builder.append(true);
+        builder.values().append_null();
+        builder.values().append_null();
+        builder.append(false);
+        let expected = builder.finish();
+
+        let array = Arc::new(PrimitiveArray::<Int32Type>::from(vec![
+            Some(1),
+            None,
+            Some(3),
+            None,
+            Some(4),
+            None,
+            Some(5),
+            Some(6),
+            None,
+            None,
+            None,
+        ]));
+
+        let inner_type =
+            ArrowType::List(Arc::new(Field::new("item", ArrowType::Int32, true)));
+        let list_type = ArrowType::FixedSizeList(
+            Arc::new(Field::new("item", inner_type.clone(), true)),
+            2,
+        );
+
+        let item_array_reader = InMemoryArrayReader::new(
+            ArrowType::Int32,
+            array,
+            Some(vec![5, 4, 5, 2, 5, 3, 5, 5, 4, 4, 0]),
+            Some(vec![0, 2, 2, 1, 0, 1, 0, 2, 1, 2, 0]),
+        );
+
+        let inner_array_reader = ListArrayReader::<i32>::new(
+            Box::new(item_array_reader),
+            inner_type,
+            4,
+            2,
+            true,
+        );
+
+        let mut list_array_reader = FixedSizeListArrayReader::new(
+            Box::new(inner_array_reader),
+            2,
+            list_type,
+            2,
+            1,
+            true,
+        );
+        let actual = list_array_reader.next_batch(1024).unwrap();
+        let actual = actual
+            .as_any()
+            .downcast_ref::<FixedSizeListArray>()
+            .unwrap();
+        assert_eq!(&expected, actual)
+    }
+
+    #[test]
+    fn test_read_list_column() {
+        // This test writes a Parquet file containing a fixed-length array column and a primitive column,
+        // then reads the columns back from the file.
+
+        // [
+        //   [1, 2, 3, null],
+        //   [5, 6, 7, 8],
+        //   null,
+        //   [9, null, 11, 12],
+        // ]
+        let list = FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+            vec![
+                Some(vec![Some(1), Some(2), Some(3), None]),
+                Some(vec![Some(5), Some(6), Some(7), Some(8)]),
+                None,
+                Some(vec![Some(9), None, Some(11), Some(12)]),
+                Some(vec![None, None, None, None]),
+            ],
+            4,
+        );
+
+        // [null, 2, 3, null, 5]
+        let primitive = PrimitiveArray::<Int32Type>::from_iter(vec![
+            None,
+            Some(2),
+            Some(3),
+            None,
+            Some(5),
+        ]);
+
+        let schema = Arc::new(Schema::new(vec![
+            Field::new(
+                "list",
+                ArrowType::FixedSizeList(
+                    Arc::new(Field::new("item", ArrowType::Int32, true)),
+                    4,
+                ),
+                true,
+            ),
+            Field::new("primitive", ArrowType::Int32, true),
+        ]));
+
+        // Create record batch with a fixed-length array column and a primitive column
+        let batch = RecordBatch::try_new(
+            schema.clone(),
+            vec![Arc::new(list.clone()), Arc::new(primitive.clone())],
+        )
+        .expect("unable to create record batch");
+
+        // Write record batch to Parquet
+        let mut buffer = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buffer, schema.clone(), None)
+            .expect("unable to create parquet writer");
+        writer.write(&batch).expect("unable to write record batch");
+        writer.close().expect("unable to close parquet writer");
+
+        // Read record batch from Parquet
+        let reader = Bytes::from(buffer);
+        let mut batch_reader = ParquetRecordBatchReader::try_new(reader, 1024)
+            .expect("unable to create parquet reader");
+        let actual = batch_reader
+            .next()
+            .expect("missing record batch")
+            .expect("unable to read record batch");
+
+        // Verify values of both read columns match
+        assert_eq!(schema, actual.schema());
+        let actual_list = actual
+            .column(0)
+            .as_any()
+            .downcast_ref::<FixedSizeListArray>()
+            .expect("unable to cast array to FixedSizeListArray");
+        let actual_primitive = actual.column(1).as_primitive::<Int32Type>();
+        assert_eq!(actual_list, &list);
+        assert_eq!(actual_primitive, &primitive);
+    }
+
+    #[test]
+    fn test_read_as_dyn_list() {
+        // This test verifies that fixed-size list arrays can be read from Parquet
+        // as variable-length list arrays.
+
+        // [
+        //   [1, 2, 3, null],
+        //   [5, 6, 7, 8],
+        //   null,
+        //   [9, null, 11, 12],
+        // ]
+        let list = FixedSizeListArray::from_iter_primitive::<Int32Type, _, _>(
+            vec![
+                Some(vec![Some(1), Some(2), Some(3), None]),
+                Some(vec![Some(5), Some(6), Some(7), Some(8)]),
+                None,
+                Some(vec![Some(9), None, Some(11), Some(12)]),
+                Some(vec![None, None, None, None]),
+            ],
+            4,
+        );
+
+        let schema = Arc::new(Schema::new(vec![Field::new(
+            "list",
+            ArrowType::FixedSizeList(
+                Arc::new(Field::new("item", ArrowType::Int32, true)),
+                4,
+            ),
+            true,
+        )]));
+
+        // Create record batch with a single fixed-length array column
+        let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(list)]).unwrap();
+
+        // Write record batch to Parquet
+        let mut buffer = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buffer, schema, None)
+            .expect("unable to create parquet writer");
+        writer.write(&batch).expect("unable to write record batch");
+        writer.close().expect("unable to close parquet writer");
+
+        // Read record batch from Parquet - ignoring arrow metadata
+        let reader = Bytes::from(buffer);
+        let mut batch_reader = ArrowReaderBuilder::try_new_with_options(
+            reader,
+            ArrowReaderOptions::new().with_skip_arrow_metadata(true),
+        )
+        .expect("unable to create reader builder")
+        .build()
+        .expect("unable to create parquet reader");
+        let actual = batch_reader
+            .next()
+            .expect("missing record batch")
+            .expect("unable to read record batch");
+
+        // Verify the read column is a variable length list with values that match the input
+        let col = actual.column(0).as_list::<i32>();
+        let expected = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+            Some(vec![Some(1), Some(2), Some(3), None]),
+            Some(vec![Some(5), Some(6), Some(7), Some(8)]),
+            None,
+            Some(vec![Some(9), None, Some(11), Some(12)]),
+            Some(vec![None, None, None, None]),
+        ]);
+        assert_eq!(col, &expected);
+    }
+}
diff --git a/parquet/src/arrow/array_reader/list_array.rs b/parquet/src/arrow/array_reader/list_array.rs
index d2fa94611906..7c66c5c23112 100644
--- a/parquet/src/arrow/array_reader/list_array.rs
+++ b/parquet/src/arrow/array_reader/list_array.rs
@@ -18,13 +18,14 @@
 use crate::arrow::array_reader::ArrayReader;
 use crate::errors::ParquetError;
 use crate::errors::Result;
-use arrow::array::{
-    new_empty_array, Array, ArrayData, ArrayRef, BooleanBufferBuilder, GenericListArray,
-    MutableArrayData, OffsetSizeTrait,
+use arrow_array::{
+    builder::BooleanBufferBuilder, new_empty_array, Array, ArrayRef, GenericListArray,
+    OffsetSizeTrait,
 };
-use arrow::buffer::Buffer;
-use arrow::datatypes::DataType as ArrowType;
-use arrow::datatypes::ToByteSlice;
+use arrow_buffer::Buffer;
+use arrow_buffer::ToByteSlice;
+use arrow_data::{transform::MutableArrayData, ArrayData};
+use arrow_schema::DataType as ArrowType;
 use std::any::Any;
 use std::cmp::Ordering;
 use std::marker::PhantomData;
@@ -142,11 +143,9 @@ impl<OffsetSize: OffsetSizeTrait> ArrayReader for ListArrayReader<OffsetSize> {
         let mut skipped = 0;
 
         // Builder used to construct the filtered child data, skipping empty lists and nulls
-        let mut child_data_builder = MutableArrayData::new(
-            vec![next_batch_array.data()],
-            false,
-            next_batch_array.len(),
-        );
+        let data = next_batch_array.to_data();
+        let mut child_data_builder =
+            MutableArrayData::new(vec![&data], false, next_batch_array.len());
 
         def_levels.iter().zip(rep_levels).try_for_each(|(d, r)| {
             match r.cmp(&self.rep_level) {
@@ -200,7 +199,7 @@ impl<OffsetSize: OffsetSizeTrait> ArrayReader for ListArrayReader<OffsetSize> {
 
         let child_data = if skipped == 0 {
             // No filtered values - can reuse original array
-            next_batch_array.data().clone()
+            next_batch_array.to_data()
         } else {
             // One or more filtered values - must build new array
             if let Some(start) = filter_start.take() {
@@ -221,9 +220,9 @@ impl<OffsetSize: OffsetSizeTrait> ArrayReader for ListArrayReader<OffsetSize> {
             .add_buffer(value_offsets)
             .add_child_data(child_data);
 
-        if let Some(mut builder) = validity {
+        if let Some(builder) = validity {
             assert_eq!(builder.len(), list_offsets.len() - 1);
-            data_builder = data_builder.null_bit_buffer(Some(builder.finish()))
+            data_builder = data_builder.null_bit_buffer(Some(builder.into()))
         }
 
         let list_data = unsafe { data_builder.build_unchecked() };
@@ -251,20 +250,23 @@ mod tests {
     use crate::arrow::array_reader::build_array_reader;
     use crate::arrow::array_reader::list_array::ListArrayReader;
     use crate::arrow::array_reader::test_util::InMemoryArrayReader;
+    use crate::arrow::schema::parquet_to_arrow_schema_and_fields;
     use crate::arrow::{parquet_to_arrow_schema, ArrowWriter, ProjectionMask};
     use crate::file::properties::WriterProperties;
     use crate::file::reader::{FileReader, SerializedFileReader};
     use crate::schema::parser::parse_message_type;
     use crate::schema::types::SchemaDescriptor;
-    use arrow::array::{Array, ArrayDataBuilder, PrimitiveArray};
     use arrow::datatypes::{Field, Int32Type as ArrowInt32, Int32Type};
+    use arrow_array::{Array, PrimitiveArray};
+    use arrow_data::ArrayDataBuilder;
+    use arrow_schema::Fields;
     use std::sync::Arc;
 
     fn list_type<OffsetSize: OffsetSizeTrait>(
         data_type: ArrowType,
         item_nullable: bool,
     ) -> ArrowType {
-        let field = Box::new(Field::new("item", data_type, item_nullable));
+        let field = Arc::new(Field::new("item", data_type, item_nullable));
         GenericListArray::<OffsetSize>::DATA_TYPE_CONSTRUCTOR(field)
     }
 
@@ -389,30 +391,19 @@ mod tests {
             true,
         );
 
-        let l2 = ListArrayReader::<OffsetSize>::new(
-            Box::new(l3),
-            l2_type,
-            3,
-            2,
-            false,
-        );
+        let l2 = ListArrayReader::<OffsetSize>::new(Box::new(l3), l2_type, 3, 2, false);
 
-        let mut l1 = ListArrayReader::<OffsetSize>::new(
-            Box::new(l2),
-            l1_type,
-            2,
-            1,
-            true,
-        );
+        let mut l1 =
+            ListArrayReader::<OffsetSize>::new(Box::new(l2), l1_type, 2, 1, true);
 
         let expected_1 = expected.slice(0, 2);
         let expected_2 = expected.slice(2, 2);
 
         let actual = l1.next_batch(2).unwrap();
-        assert_eq!(expected_1.as_ref(), actual.as_ref());
+        assert_eq!(actual.as_ref(), &expected_1);
 
         let actual = l1.next_batch(1024).unwrap();
-        assert_eq!(expected_2.as_ref(), actual.as_ref());
+        assert_eq!(actual.as_ref(), &expected_2);
     }
 
     fn test_required_list<OffsetSize: OffsetSizeTrait>() {
@@ -573,32 +564,33 @@ mod tests {
             Arc::new(SerializedFileReader::new(file).unwrap());
 
         let file_metadata = file_reader.metadata().file_metadata();
-        let arrow_schema = parquet_to_arrow_schema(
-            file_metadata.schema_descr(),
+        let schema = file_metadata.schema_descr();
+        let mask = ProjectionMask::leaves(schema, vec![0]);
+        let (_, fields) = parquet_to_arrow_schema_and_fields(
+            schema,
+            ProjectionMask::all(),
             file_metadata.key_value_metadata(),
         )
         .unwrap();
 
-        let schema = file_metadata.schema_descr_ptr();
-        let mask = ProjectionMask::leaves(&schema, vec![0]);
-
         let mut array_reader =
-            build_array_reader(Arc::new(arrow_schema), mask, &file_reader)
-                .unwrap();
+            build_array_reader(fields.as_ref(), &mask, &file_reader).unwrap();
 
         let batch = array_reader.next_batch(100).unwrap();
         assert_eq!(batch.data_type(), array_reader.get_data_type());
         assert_eq!(
             batch.data_type(),
-            &ArrowType::Struct(vec![Field::new(
+            &ArrowType::Struct(Fields::from(vec![Field::new(
                 "table_info",
-                ArrowType::List(Box::new(Field::new(
+                ArrowType::List(Arc::new(Field::new(
                     "table_info",
-                    ArrowType::Struct(vec![Field::new("name", ArrowType::Binary, false)]),
+                    ArrowType::Struct(
+                        vec![Field::new("name", ArrowType::Binary, false)].into()
+                    ),
                     false
                 ))),
                 false
-            )])
+            )]))
         );
         assert_eq!(batch.len(), 0);
     }
diff --git a/parquet/src/arrow/array_reader/map_array.rs b/parquet/src/arrow/array_reader/map_array.rs
index 3ba7f6960ec3..9bfc047322a7 100644
--- a/parquet/src/arrow/array_reader/map_array.rs
+++ b/parquet/src/arrow/array_reader/map_array.rs
@@ -15,43 +15,67 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::arrow::array_reader::ArrayReader;
-use crate::errors::ParquetError::ArrowError;
-use crate::errors::{ParquetError, Result};
-use arrow::array::{Array, ArrayDataBuilder, ArrayRef, MapArray};
-use arrow::buffer::{Buffer, MutableBuffer};
-use arrow::datatypes::DataType as ArrowType;
-use arrow::datatypes::ToByteSlice;
-use arrow::util::bit_util;
+use crate::arrow::array_reader::{ArrayReader, ListArrayReader, StructArrayReader};
+use crate::errors::Result;
+use arrow_array::{Array, ArrayRef, MapArray};
+use arrow_schema::DataType as ArrowType;
 use std::any::Any;
 use std::sync::Arc;
 
 /// Implementation of a map array reader.
 pub struct MapArrayReader {
-    key_reader: Box<dyn ArrayReader>,
-    value_reader: Box<dyn ArrayReader>,
     data_type: ArrowType,
-    map_def_level: i16,
-    #[allow(unused)]
-    map_rep_level: i16,
+    reader: ListArrayReader<i32>,
 }
 
 impl MapArrayReader {
+    /// Creates a new [`MapArrayReader`] with a `def_level`, `rep_level` and `nullable`
+    /// as defined on [`ParquetField`][crate::arrow::schema::ParquetField]
     pub fn new(
         key_reader: Box<dyn ArrayReader>,
         value_reader: Box<dyn ArrayReader>,
         data_type: ArrowType,
         def_level: i16,
         rep_level: i16,
+        nullable: bool,
     ) -> Self {
-        Self {
-            key_reader,
-            value_reader,
-            data_type,
-            // These are the wrong way round https://github.com/apache/arrow-rs/issues/1699
-            map_def_level: rep_level,
-            map_rep_level: def_level,
-        }
+        let struct_def_level = match nullable {
+            true => def_level + 2,
+            false => def_level + 1,
+        };
+        let struct_rep_level = rep_level + 1;
+
+        let element = match &data_type {
+            ArrowType::Map(element, _) => match element.data_type() {
+                ArrowType::Struct(fields) if fields.len() == 2 => {
+                    // Parquet cannot represent nullability at this level (#1697)
+                    // and so encountering nullability here indicates some manner
+                    // of schema inconsistency / inference bug
+                    assert!(!element.is_nullable(), "map struct cannot be nullable");
+                    element
+                }
+                _ => unreachable!("expected struct with two fields"),
+            },
+            _ => unreachable!("expected map type"),
+        };
+
+        let struct_reader = StructArrayReader::new(
+            element.data_type().clone(),
+            vec![key_reader, value_reader],
+            struct_def_level,
+            struct_rep_level,
+            false,
+        );
+
+        let reader = ListArrayReader::new(
+            Box::new(struct_reader),
+            ArrowType::List(element.clone()),
+            def_level,
+            rep_level,
+            nullable,
+        );
+
+        Self { data_type, reader }
     }
 }
 
@@ -65,131 +89,129 @@ impl ArrayReader for MapArrayReader {
     }
 
     fn read_records(&mut self, batch_size: usize) -> Result<usize> {
-        let key_len = self.key_reader.read_records(batch_size)?;
-        let value_len = self.value_reader.read_records(batch_size)?;
-        // Check that key and value have the same lengths
-        if key_len != value_len {
-            return Err(general_err!(
-                "Map key and value should have the same lengths."
-            ));
-        }
-        Ok(key_len)
+        self.reader.read_records(batch_size)
     }
 
     fn consume_batch(&mut self) -> Result<ArrayRef> {
-        let key_array = self.key_reader.consume_batch()?;
-        let value_array = self.value_reader.consume_batch()?;
-
-        // Check that key and value have the same lengths
-        let key_length = key_array.len();
-        if key_length != value_array.len() {
-            return Err(general_err!(
-                "Map key and value should have the same lengths."
-            ));
-        }
-
-        let def_levels = self
-            .key_reader
-            .get_def_levels()
-            .ok_or_else(|| ArrowError("item_reader def levels are None.".to_string()))?;
-        let rep_levels = self
-            .key_reader
-            .get_rep_levels()
-            .ok_or_else(|| ArrowError("item_reader rep levels are None.".to_string()))?;
-
-        if !((def_levels.len() == rep_levels.len()) && (rep_levels.len() == key_length)) {
-            return Err(ArrowError(
-                "Expected item_reader def_levels and rep_levels to be same length as batch".to_string(),
-            ));
-        }
-
-        let entry_data_type = if let ArrowType::Map(field, _) = &self.data_type {
-            field.data_type().clone()
-        } else {
-            return Err(ArrowError("Expected a map arrow type".to_string()));
-        };
-
-        let entry_data = ArrayDataBuilder::new(entry_data_type)
-            .len(key_length)
-            .add_child_data(key_array.into_data())
-            .add_child_data(value_array.into_data());
-        let entry_data = unsafe { entry_data.build_unchecked() };
-
-        let entry_len = rep_levels.iter().filter(|level| **level == 0).count();
-
-        // first item in each list has rep_level = 0, subsequent items have rep_level = 1
-        let mut offsets: Vec<i32> = Vec::new();
-        let mut cur_offset = 0;
-        def_levels.iter().zip(rep_levels).for_each(|(d, r)| {
-            if *r == 0 || d == &self.map_def_level {
-                offsets.push(cur_offset);
-            }
-            if d > &self.map_def_level {
-                cur_offset += 1;
-            }
-        });
-        offsets.push(cur_offset);
-
-        let num_bytes = bit_util::ceil(offsets.len(), 8);
-        // TODO: A useful optimization is to use the null count to fill with
-        // 0 or null, to reduce individual bits set in a loop.
-        // To favour dense data, set every slot to true, then unset
-        let mut null_buf = MutableBuffer::new(num_bytes).with_bitset(num_bytes, true);
-        let null_slice = null_buf.as_slice_mut();
-        let mut list_index = 0;
-        for i in 0..rep_levels.len() {
-            // If the level is lower than empty, then the slot is null.
-            // When a list is non-nullable, its empty level = null level,
-            // so this automatically factors that in.
-            if rep_levels[i] == 0 && def_levels[i] < self.map_def_level {
-                // should be empty list
-                bit_util::unset_bit(null_slice, list_index);
-            }
-            if rep_levels[i] == 0 {
-                list_index += 1;
-            }
-        }
-        let value_offsets = Buffer::from(&offsets.to_byte_slice());
-
-        // Now we can build array data
-        let array_data = ArrayDataBuilder::new(self.data_type.clone())
-            .len(entry_len)
-            .add_buffer(value_offsets)
-            .null_bit_buffer(Some(null_buf.into()))
-            .add_child_data(entry_data);
-
-        let array_data = unsafe { array_data.build_unchecked() };
-
-        Ok(Arc::new(MapArray::from(array_data)))
+        // A MapArray is just a ListArray with a StructArray child
+        // we can therefore just alter the ArrayData
+        let array = self.reader.consume_batch().unwrap();
+        let data = array.to_data();
+        let builder = data.into_builder().data_type(self.data_type.clone());
+
+        // SAFETY - we can assume that ListArrayReader produces valid ListArray
+        // of the expected type, and as such its output can be reinterpreted as
+        // a MapArray without validation
+        Ok(Arc::new(MapArray::from(unsafe {
+            builder.build_unchecked()
+        })))
     }
 
     fn skip_records(&mut self, num_records: usize) -> Result<usize> {
-        let key_skipped = self.key_reader.skip_records(num_records)?;
-        let value_skipped = self.value_reader.skip_records(num_records)?;
-        if key_skipped != value_skipped {
-            return Err(general_err!(
-                "MapArrayReader out of sync, skipped {} keys and {} values",
-                key_skipped,
-                value_skipped
-            ));
-        }
-        Ok(key_skipped)
+        self.reader.skip_records(num_records)
     }
 
     fn get_def_levels(&self) -> Option<&[i16]> {
-        // Children definition levels should describe the same parent structure,
-        // so return key_reader only
-        self.key_reader.get_def_levels()
+        self.reader.get_def_levels()
     }
 
     fn get_rep_levels(&self) -> Option<&[i16]> {
-        // Children repetition levels should describe the same parent structure,
-        // so return key_reader only
-        self.key_reader.get_rep_levels()
+        self.reader.get_rep_levels()
     }
 }
 
 #[cfg(test)]
 mod tests {
-    //TODO: Add unit tests (#1561)
+    use super::*;
+    use crate::arrow::arrow_reader::ParquetRecordBatchReader;
+    use crate::arrow::ArrowWriter;
+    use arrow::datatypes::{Field, Int32Type, Schema};
+    use arrow_array::builder::{MapBuilder, PrimitiveBuilder, StringBuilder};
+    use arrow_array::cast::*;
+    use arrow_array::RecordBatch;
+    use arrow_schema::Fields;
+    use bytes::Bytes;
+
+    #[test]
+    // This test writes a parquet file with the following data:
+    // +--------------------------------------------------------+
+    // |map                                                     |
+    // +--------------------------------------------------------+
+    // |null                                                    |
+    // |null                                                    |
+    // |{three -> 3, four -> 4, five -> 5, six -> 6, seven -> 7}|
+    // +--------------------------------------------------------+
+    //
+    // It then attempts to read the data back and checks that the third record
+    // contains the expected values.
+    fn read_map_array_column() {
+        // Schema for single map of string to int32
+        let schema = Schema::new(vec![Field::new(
+            "map",
+            ArrowType::Map(
+                Arc::new(Field::new(
+                    "entries",
+                    ArrowType::Struct(Fields::from(vec![
+                        Field::new("keys", ArrowType::Utf8, false),
+                        Field::new("values", ArrowType::Int32, true),
+                    ])),
+                    false,
+                )),
+                false, // Map field not sorted
+            ),
+            true,
+        )]);
+
+        // Create builders for map
+        let string_builder = StringBuilder::new();
+        let ints_builder: PrimitiveBuilder<Int32Type> = PrimitiveBuilder::new();
+        let mut map_builder = MapBuilder::new(None, string_builder, ints_builder);
+
+        // Add two null records and one record with five entries
+        map_builder.append(false).expect("adding null map entry");
+        map_builder.append(false).expect("adding null map entry");
+        map_builder.keys().append_value("three");
+        map_builder.keys().append_value("four");
+        map_builder.keys().append_value("five");
+        map_builder.keys().append_value("six");
+        map_builder.keys().append_value("seven");
+
+        map_builder.values().append_value(3);
+        map_builder.values().append_value(4);
+        map_builder.values().append_value(5);
+        map_builder.values().append_value(6);
+        map_builder.values().append_value(7);
+        map_builder.append(true).expect("adding map entry");
+
+        // Create record batch
+        let batch =
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(map_builder.finish())])
+                .expect("create record batch");
+
+        // Write record batch to file
+        let mut buffer = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buffer, batch.schema(), None)
+            .expect("creat file writer");
+        writer.write(&batch).expect("writing file");
+        writer.close().expect("close writer");
+
+        // Read file
+        let reader = Bytes::from(buffer);
+        let record_batch_reader =
+            ParquetRecordBatchReader::try_new(reader, 1024).unwrap();
+        for maybe_record_batch in record_batch_reader {
+            let record_batch = maybe_record_batch.expect("Getting current batch");
+            let col = record_batch.column(0);
+            assert!(col.is_null(0));
+            assert!(col.is_null(1));
+            let map_entry = as_map_array(col).value(2);
+            let struct_col = as_struct_array(&map_entry);
+            let key_col = as_string_array(struct_col.column(0)); // Key column
+            assert_eq!(key_col.value(0), "three");
+            assert_eq!(key_col.value(1), "four");
+            assert_eq!(key_col.value(2), "five");
+            assert_eq!(key_col.value(3), "six");
+            assert_eq!(key_col.value(4), "seven");
+        }
+    }
 }
diff --git a/parquet/src/arrow/array_reader/mod.rs b/parquet/src/arrow/array_reader/mod.rs
index 54c45a336a37..c4e9fc5fa066 100644
--- a/parquet/src/arrow/array_reader/mod.rs
+++ b/parquet/src/arrow/array_reader/mod.rs
@@ -18,8 +18,8 @@
 //! Logic for reading into arrow arrays
 
 use crate::errors::Result;
-use arrow::array::ArrayRef;
-use arrow::datatypes::DataType as ArrowType;
+use arrow_array::ArrayRef;
+use arrow_schema::DataType as ArrowType;
 use std::any::Any;
 use std::sync::Arc;
 
@@ -28,13 +28,13 @@ use crate::arrow::record_reader::GenericRecordReader;
 use crate::column::page::PageIterator;
 use crate::column::reader::decoder::ColumnValueDecoder;
 use crate::file::reader::{FilePageIterator, FileReader};
-use crate::schema::types::SchemaDescPtr;
 
 mod builder;
 mod byte_array;
 mod byte_array_dictionary;
-mod complex_object_array;
 mod empty_array;
+mod fixed_len_byte_array;
+mod fixed_size_list_array;
 mod list_array;
 mod map_array;
 mod null_array;
@@ -47,7 +47,8 @@ mod test_util;
 pub use builder::build_array_reader;
 pub use byte_array::make_byte_array_reader;
 pub use byte_array_dictionary::make_byte_array_dictionary_reader;
-pub use complex_object_array::ComplexObjectArrayReader;
+pub use fixed_len_byte_array::make_fixed_len_byte_array_reader;
+pub use fixed_size_list_array::FixedSizeListArrayReader;
 pub use list_array::ListArrayReader;
 pub use map_array::MapArrayReader;
 pub use null_array::NullArrayReader;
@@ -98,22 +99,15 @@ pub trait ArrayReader: Send {
 }
 
 /// A collection of row groups
-pub trait RowGroupCollection {
-    /// Get schema of parquet file.
-    fn schema(&self) -> SchemaDescPtr;
-
-    /// Get the numer of rows in this collection
+pub trait RowGroups {
+    /// Get the number of rows in this collection
     fn num_rows(&self) -> usize;
 
-    /// Returns an iterator over the column chunks for particular column
+    /// Returns a [`PageIterator`] for the column chunks with the given leaf column index
     fn column_chunks(&self, i: usize) -> Result<Box<dyn PageIterator>>;
 }
 
-impl RowGroupCollection for Arc<dyn FileReader> {
-    fn schema(&self) -> SchemaDescPtr {
-        self.metadata().file_metadata().schema_descr_ptr()
-    }
-
+impl RowGroups for Arc<dyn FileReader> {
     fn num_rows(&self) -> usize {
         self.metadata().file_metadata().num_rows() as usize
     }
@@ -134,8 +128,8 @@ fn read_records<V, CV>(
     batch_size: usize,
 ) -> Result<usize>
 where
-    V: ValuesBuffer + Default,
-    CV: ColumnValueDecoder<Slice = V::Slice>,
+    V: ValuesBuffer,
+    CV: ColumnValueDecoder<Buffer = V>,
 {
     let mut records_read = 0usize;
     while records_read < batch_size {
@@ -158,7 +152,7 @@ where
     Ok(records_read)
 }
 
-/// Uses `record_reader` to skip up to `batch_size` records from`pages`
+/// Uses `record_reader` to skip up to `batch_size` records from `pages`
 ///
 /// Returns the number of records skipped, which can be less than `batch_size` if
 /// pages is exhausted
@@ -167,9 +161,9 @@ fn skip_records<V, CV>(
     pages: &mut dyn PageIterator,
     batch_size: usize,
 ) -> Result<usize>
-    where
-        V: ValuesBuffer + Default,
-        CV: ColumnValueDecoder<Slice = V::Slice>,
+where
+    V: ValuesBuffer,
+    CV: ColumnValueDecoder<Buffer = V>,
 {
     let mut records_skipped = 0usize;
     while records_skipped < batch_size {
diff --git a/parquet/src/arrow/array_reader/null_array.rs b/parquet/src/arrow/array_reader/null_array.rs
index 405633f0a823..838db854e05f 100644
--- a/parquet/src/arrow/array_reader/null_array.rs
+++ b/parquet/src/arrow/array_reader/null_array.rs
@@ -16,15 +16,14 @@
 // under the License.
 
 use crate::arrow::array_reader::{read_records, skip_records, ArrayReader};
-use crate::arrow::record_reader::buffer::ScalarValue;
 use crate::arrow::record_reader::RecordReader;
 use crate::column::page::PageIterator;
 use crate::data_type::DataType;
 use crate::errors::Result;
 use crate::schema::types::ColumnDescPtr;
-use arrow::array::ArrayRef;
-use arrow::buffer::Buffer;
-use arrow::datatypes::DataType as ArrowType;
+use arrow_array::ArrayRef;
+use arrow_buffer::ArrowNativeType;
+use arrow_schema::DataType as ArrowType;
 use std::any::Any;
 use std::sync::Arc;
 
@@ -33,19 +32,19 @@ use std::sync::Arc;
 pub struct NullArrayReader<T>
 where
     T: DataType,
-    T::T: ScalarValue,
+    T::T: ArrowNativeType,
 {
     data_type: ArrowType,
     pages: Box<dyn PageIterator>,
-    def_levels_buffer: Option<Buffer>,
-    rep_levels_buffer: Option<Buffer>,
+    def_levels_buffer: Option<Vec<i16>>,
+    rep_levels_buffer: Option<Vec<i16>>,
     record_reader: RecordReader<T>,
 }
 
 impl<T> NullArrayReader<T>
 where
     T: DataType,
-    T::T: ScalarValue,
+    T::T: ArrowNativeType,
 {
     /// Construct null array reader.
     pub fn new(pages: Box<dyn PageIterator>, column_desc: ColumnDescPtr) -> Result<Self> {
@@ -65,7 +64,7 @@ where
 impl<T> ArrayReader for NullArrayReader<T>
 where
     T: DataType,
-    T::T: ScalarValue,
+    T::T: ArrowNativeType,
 {
     fn as_any(&self) -> &dyn Any {
         self
@@ -82,7 +81,7 @@ where
 
     fn consume_batch(&mut self) -> Result<ArrayRef> {
         // convert to arrays
-        let array = arrow::array::NullArray::new(self.record_reader.num_values());
+        let array = arrow_array::NullArray::new(self.record_reader.num_values());
 
         // save definition and repetition buffers
         self.def_levels_buffer = self.record_reader.consume_def_levels();
@@ -100,10 +99,10 @@ where
     }
 
     fn get_def_levels(&self) -> Option<&[i16]> {
-        self.def_levels_buffer.as_ref().map(|buf| buf.typed_data())
+        self.def_levels_buffer.as_deref()
     }
 
     fn get_rep_levels(&self) -> Option<&[i16]> {
-        self.rep_levels_buffer.as_ref().map(|buf| buf.typed_data())
+        self.rep_levels_buffer.as_deref()
     }
 }
diff --git a/parquet/src/arrow/array_reader/primitive_array.rs b/parquet/src/arrow/array_reader/primitive_array.rs
index 35f523e3d0d7..07ecc27d9b0b 100644
--- a/parquet/src/arrow/array_reader/primitive_array.rs
+++ b/parquet/src/arrow/array_reader/primitive_array.rs
@@ -16,41 +16,77 @@
 // under the License.
 
 use crate::arrow::array_reader::{read_records, skip_records, ArrayReader};
-use crate::arrow::record_reader::buffer::ScalarValue;
 use crate::arrow::record_reader::RecordReader;
 use crate::arrow::schema::parquet_to_arrow_field;
 use crate::basic::Type as PhysicalType;
 use crate::column::page::PageIterator;
-use crate::data_type::DataType;
+use crate::data_type::{DataType, Int96};
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::ColumnDescPtr;
-use arrow::array::{
-    ArrayDataBuilder, ArrayRef, BooleanArray, BooleanBufferBuilder,
-    Decimal128Array, Float32Array, Float64Array, Int32Array, Int64Array,
+use arrow_array::Decimal256Array;
+use arrow_array::{
+    builder::TimestampNanosecondBufferBuilder, ArrayRef, BooleanArray, Decimal128Array,
+    Float32Array, Float64Array, Int32Array, Int64Array, TimestampNanosecondArray, UInt32Array,
+    UInt64Array,
 };
-use arrow::buffer::Buffer;
-use arrow::datatypes::DataType as ArrowType;
+use arrow_buffer::{i256, BooleanBuffer, Buffer};
+use arrow_data::ArrayDataBuilder;
+use arrow_schema::{DataType as ArrowType, TimeUnit};
 use std::any::Any;
 use std::sync::Arc;
 
+/// Provides conversion from `Vec<T>` to `Buffer`
+pub trait IntoBuffer {
+    fn into_buffer(self) -> Buffer;
+}
+
+macro_rules! native_buffer {
+    ($($t:ty),*) => {
+        $(impl IntoBuffer for Vec<$t> {
+            fn into_buffer(self) -> Buffer {
+                Buffer::from_vec(self)
+            }
+        })*
+    };
+}
+native_buffer!(i8, i16, i32, i64, u8, u16, u32, u64, f32, f64);
+
+impl IntoBuffer for Vec<bool> {
+    fn into_buffer(self) -> Buffer {
+        BooleanBuffer::from_iter(self).into_inner()
+    }
+}
+
+impl IntoBuffer for Vec<Int96> {
+    fn into_buffer(self) -> Buffer {
+        let mut builder = TimestampNanosecondBufferBuilder::new(self.len());
+        for v in self {
+            builder.append(v.to_nanos())
+        }
+        builder.finish()
+    }
+}
+
 /// Primitive array readers are leaves of array reader tree. They accept page iterator
 /// and read them into primitive arrays.
 pub struct PrimitiveArrayReader<T>
-    where
-        T: DataType,
-        T::T: ScalarValue,
+where
+    T: DataType,
+    T::T: Copy + Default,
+    Vec<T::T>: IntoBuffer,
 {
     data_type: ArrowType,
     pages: Box<dyn PageIterator>,
-    def_levels_buffer: Option<Buffer>,
-    rep_levels_buffer: Option<Buffer>,
+    def_levels_buffer: Option<Vec<i16>>,
+    rep_levels_buffer: Option<Vec<i16>>,
     record_reader: RecordReader<T>,
 }
 
 impl<T> PrimitiveArrayReader<T>
-    where
-        T: DataType,
-        T::T: ScalarValue,
+where
+    T: DataType,
+    T::T: Copy + Default,
+    Vec<T::T>: IntoBuffer,
 {
     /// Construct primitive array reader.
     pub fn new(
@@ -80,9 +116,10 @@ impl<T> PrimitiveArrayReader<T>
 
 /// Implementation of primitive array reader.
 impl<T> ArrayReader for PrimitiveArrayReader<T>
-    where
-        T: DataType,
-        T::T: ScalarValue,
+where
+    T: DataType,
+    T::T: Copy + Default,
+    Vec<T::T>: IntoBuffer,
 {
     fn as_any(&self) -> &dyn Any {
         self
@@ -98,7 +135,7 @@ impl<T> ArrayReader for PrimitiveArrayReader<T>
     }
 
     fn consume_batch(&mut self) -> Result<ArrayRef> {
-        let target_type = self.get_data_type().clone();
+        let target_type = &self.data_type;
         let arrow_data_type = match T::get_physical_type() {
             PhysicalType::BOOLEAN => ArrowType::Boolean,
             PhysicalType::INT32 => {
@@ -123,28 +160,19 @@ impl<T> ArrayReader for PrimitiveArrayReader<T>
             }
             PhysicalType::FLOAT => ArrowType::Float32,
             PhysicalType::DOUBLE => ArrowType::Float64,
-            PhysicalType::INT96
-            | PhysicalType::BYTE_ARRAY
-            | PhysicalType::FIXED_LEN_BYTE_ARRAY => {
-                unreachable!(
-                    "PrimitiveArrayReaders don't support complex physical types"
-                );
+            PhysicalType::INT96 => match target_type {
+                ArrowType::Timestamp(TimeUnit::Nanosecond, _) => target_type.clone(),
+                _ => unreachable!("INT96 must be timestamp nanosecond"),
+            },
+            PhysicalType::BYTE_ARRAY | PhysicalType::FIXED_LEN_BYTE_ARRAY => {
+                unreachable!("PrimitiveArrayReaders don't support complex physical types");
             }
         };
 
         // Convert to arrays by using the Parquet physical type.
         // The physical types are then cast to Arrow types if necessary
 
-        let mut record_data = self.record_reader.consume_record_data();
-
-        if T::get_physical_type() == PhysicalType::BOOLEAN {
-            let mut boolean_buffer = BooleanBufferBuilder::new(record_data.len());
-
-            for e in record_data.as_slice() {
-                boolean_buffer.append(*e > 0);
-            }
-            record_data = boolean_buffer.finish();
-        }
+        let record_data = self.record_reader.consume_record_data().into_buffer();
 
         let array_data = ArrayDataBuilder::new(arrow_data_type)
             .len(self.record_reader.num_values())
@@ -152,18 +180,23 @@ impl<T> ArrayReader for PrimitiveArrayReader<T>
             .null_bit_buffer(self.record_reader.consume_bitmap_buffer());
 
         let array_data = unsafe { array_data.build_unchecked() };
-        let array = match T::get_physical_type() {
-            PhysicalType::BOOLEAN => Arc::new(BooleanArray::from(array_data)) as ArrayRef,
-            PhysicalType::INT32 => Arc::new(Int32Array::from(array_data)) as ArrayRef,
-            PhysicalType::INT64 => Arc::new(Int64Array::from(array_data)) as ArrayRef,
-            PhysicalType::FLOAT => Arc::new(Float32Array::from(array_data)) as ArrayRef,
-            PhysicalType::DOUBLE => Arc::new(Float64Array::from(array_data)) as ArrayRef,
-            PhysicalType::INT96
-            | PhysicalType::BYTE_ARRAY
-            | PhysicalType::FIXED_LEN_BYTE_ARRAY => {
-                unreachable!(
-                    "PrimitiveArrayReaders don't support complex physical types"
-                );
+        let array: ArrayRef = match T::get_physical_type() {
+            PhysicalType::BOOLEAN => Arc::new(BooleanArray::from(array_data)),
+            PhysicalType::INT32 => match array_data.data_type() {
+                ArrowType::UInt32 => Arc::new(UInt32Array::from(array_data)),
+                ArrowType::Int32 => Arc::new(Int32Array::from(array_data)),
+                _ => unreachable!(),
+            },
+            PhysicalType::INT64 => match array_data.data_type() {
+                ArrowType::UInt64 => Arc::new(UInt64Array::from(array_data)),
+                ArrowType::Int64 => Arc::new(Int64Array::from(array_data)),
+                _ => unreachable!(),
+            },
+            PhysicalType::FLOAT => Arc::new(Float32Array::from(array_data)),
+            PhysicalType::DOUBLE => Arc::new(Float64Array::from(array_data)),
+            PhysicalType::INT96 => Arc::new(TimestampNanosecondArray::from(array_data)),
+            PhysicalType::BYTE_ARRAY | PhysicalType::FIXED_LEN_BYTE_ARRAY => {
+                unreachable!("PrimitiveArrayReaders don't support complex physical types");
             }
         };
 
@@ -180,8 +213,8 @@ impl<T> ArrayReader for PrimitiveArrayReader<T>
         let array = match target_type {
             ArrowType::Date64 => {
                 // this is cheap as it internally reinterprets the data
-                let a = arrow::compute::cast(&array, &ArrowType::Date32)?;
-                arrow::compute::cast(&a, &target_type)?
+                let a = arrow_cast::cast(&array, &ArrowType::Date32)?;
+                arrow_cast::cast(&a, target_type)?
             }
             ArrowType::Decimal128(p, s) => {
                 let array = match array.data_type() {
@@ -190,7 +223,7 @@ impl<T> ArrayReader for PrimitiveArrayReader<T>
                         .downcast_ref::<Int32Array>()
                         .unwrap()
                         .iter()
-                        .map(|v| v.map(|v| v.into()))
+                        .map(|v| v.map(|v| v as i128))
                         .collect::<Decimal128Array>(),
 
                     ArrowType::Int64 => array
@@ -198,7 +231,7 @@ impl<T> ArrayReader for PrimitiveArrayReader<T>
                         .downcast_ref::<Int64Array>()
                         .unwrap()
                         .iter()
-                        .map(|v| v.map(|v| v.into()))
+                        .map(|v| v.map(|v| v as i128))
                         .collect::<Decimal128Array>(),
                     _ => {
                         return Err(arrow_err!(
@@ -207,11 +240,39 @@ impl<T> ArrayReader for PrimitiveArrayReader<T>
                         ));
                     }
                 }
-                    .with_precision_and_scale(p, s)?;
+                .with_precision_and_scale(*p, *s)?;
 
                 Arc::new(array) as ArrayRef
             }
-            _ => arrow::compute::cast(&array, &target_type)?,
+            ArrowType::Decimal256(p, s) => {
+                let array = match array.data_type() {
+                    ArrowType::Int32 => array
+                        .as_any()
+                        .downcast_ref::<Int32Array>()
+                        .unwrap()
+                        .iter()
+                        .map(|v| v.map(|v| i256::from_i128(v as i128)))
+                        .collect::<Decimal256Array>(),
+
+                    ArrowType::Int64 => array
+                        .as_any()
+                        .downcast_ref::<Int64Array>()
+                        .unwrap()
+                        .iter()
+                        .map(|v| v.map(|v| i256::from_i128(v as i128)))
+                        .collect::<Decimal256Array>(),
+                    _ => {
+                        return Err(arrow_err!(
+                            "Cannot convert {:?} to decimal",
+                            array.data_type()
+                        ));
+                    }
+                }
+                .with_precision_and_scale(*p, *s)?;
+
+                Arc::new(array) as ArrayRef
+            }
+            _ => arrow_cast::cast(&array, target_type)?,
         };
 
         // save definition and repetition buffers
@@ -226,11 +287,11 @@ impl<T> ArrayReader for PrimitiveArrayReader<T>
     }
 
     fn get_def_levels(&self) -> Option<&[i16]> {
-        self.def_levels_buffer.as_ref().map(|buf| buf.typed_data())
+        self.def_levels_buffer.as_deref()
     }
 
     fn get_rep_levels(&self) -> Option<&[i16]> {
-        self.rep_levels_buffer.as_ref().map(|buf| buf.typed_data())
+        self.rep_levels_buffer.as_deref()
     }
 }
 
@@ -245,12 +306,12 @@ mod tests {
     use crate::schema::types::SchemaDescriptor;
     use crate::util::test_common::rand_gen::make_pages;
     use crate::util::InMemoryPageIterator;
-    use arrow::array::{Array, PrimitiveArray};
-    use arrow::datatypes::{ArrowPrimitiveType};
+    use arrow::datatypes::ArrowPrimitiveType;
+    use arrow_array::{Array, PrimitiveArray};
 
+    use arrow::datatypes::DataType::Decimal128;
     use rand::distributions::uniform::SampleUniform;
     use std::collections::VecDeque;
-    use arrow::datatypes::DataType::Decimal128;
 
     #[allow(clippy::too_many_arguments)]
     fn make_column_chunks<T: DataType>(
@@ -308,15 +369,12 @@ mod tests {
             .map(|t| Arc::new(SchemaDescriptor::new(Arc::new(t))))
             .unwrap();
 
-        let column_desc = schema.column(0);
-        let page_iterator = EmptyPageIterator::new(schema);
-
         let mut array_reader = PrimitiveArrayReader::<Int32Type>::new(
-            Box::new(page_iterator),
-            column_desc,
+            Box::<EmptyPageIterator>::default(),
+            schema.column(0),
             None,
         )
-            .unwrap();
+        .unwrap();
 
         // expect no values to be read
         let array = array_reader.next_batch(50).unwrap();
@@ -355,15 +413,11 @@ mod tests {
                 true,
                 2,
             );
-            let page_iterator =
-                InMemoryPageIterator::new(schema, column_desc.clone(), page_lists);
-
-            let mut array_reader = PrimitiveArrayReader::<Int32Type>::new(
-                Box::new(page_iterator),
-                column_desc,
-                None,
-            )
-                .unwrap();
+            let page_iterator = InMemoryPageIterator::new(page_lists);
+
+            let mut array_reader =
+                PrimitiveArrayReader::<Int32Type>::new(Box::new(page_iterator), column_desc, None)
+                    .unwrap();
 
             // Read first 50 values, which are all from the first column chunk
             let array = array_reader.next_batch(50).unwrap();
@@ -387,7 +441,15 @@ mod tests {
     }
 
     macro_rules! test_primitive_array_reader_one_type {
-        ($arrow_parquet_type:ty, $physical_type:expr, $converted_type_str:expr, $result_arrow_type:ty, $result_arrow_cast_type:ty, $result_primitive_type:ty) => {{
+        (
+            $arrow_parquet_type:ty,
+            $physical_type:expr,
+            $converted_type_str:expr,
+            $result_arrow_type:ty,
+            $result_arrow_cast_type:ty,
+            $result_primitive_type:ty
+            $(, $timezone:expr)?
+        ) => {{
             let message_type = format!(
                 "
             message test_schema {{
@@ -419,11 +481,7 @@ mod tests {
                     true,
                     2,
                 );
-                let page_iterator = InMemoryPageIterator::new(
-                    schema.clone(),
-                    column_desc.clone(),
-                    page_lists,
-                );
+                let page_iterator = InMemoryPageIterator::new(page_lists);
                 let mut array_reader = PrimitiveArrayReader::<$arrow_parquet_type>::new(
                     Box::new(page_iterator),
                     column_desc.clone(),
@@ -446,7 +504,9 @@ mod tests {
                             result_data_type
                         )
                         .as_str(),
-                    );
+                    )
+                    $(.clone().with_timezone($timezone))?
+                    ;
 
                 // create expected array as primitive, and cast to result type
                 let expected = PrimitiveArray::<$result_arrow_cast_type>::from(
@@ -469,7 +529,9 @@ mod tests {
                             result_data_type
                         )
                         .as_str(),
-                    );
+                    )
+                    $(.clone().with_timezone($timezone))?
+                    ;
                 assert_eq!(expected, array);
             }
         }};
@@ -507,7 +569,8 @@ mod tests {
             "TIMESTAMP_MILLIS",
             arrow::datatypes::TimestampMillisecondType,
             arrow::datatypes::Int64Type,
-            i64
+            i64,
+            "UTC"
         );
         test_primitive_array_reader_one_type!(
             crate::data_type::Int64Type,
@@ -515,7 +578,8 @@ mod tests {
             "TIMESTAMP_MICROS",
             arrow::datatypes::TimestampMicrosecondType,
             arrow::datatypes::Int64Type,
-            i64
+            i64,
+            "UTC"
         );
     }
 
@@ -555,15 +619,11 @@ mod tests {
                 2,
             );
 
-            let page_iterator =
-                InMemoryPageIterator::new(schema, column_desc.clone(), page_lists);
+            let page_iterator = InMemoryPageIterator::new(page_lists);
 
-            let mut array_reader = PrimitiveArrayReader::<Int32Type>::new(
-                Box::new(page_iterator),
-                column_desc,
-                None,
-            )
-                .unwrap();
+            let mut array_reader =
+                PrimitiveArrayReader::<Int32Type>::new(Box::new(page_iterator), column_desc, None)
+                    .unwrap();
 
             let mut accu_len: usize = 0;
 
@@ -605,7 +665,6 @@ mod tests {
         }
     }
 
-
     #[test]
     fn test_primitive_array_reader_decimal_types() {
         // parquet `INT32` to decimal
@@ -636,26 +695,34 @@ mod tests {
                 true,
                 2,
             );
-            let page_iterator =
-                InMemoryPageIterator::new(schema, column_desc.clone(), page_lists);
-
-            let mut array_reader = PrimitiveArrayReader::<Int32Type>::new(
-                Box::new(page_iterator),
-                column_desc,
-                None,
-            )
-                .unwrap();
+            let page_iterator = InMemoryPageIterator::new(page_lists);
+
+            let mut array_reader =
+                PrimitiveArrayReader::<Int32Type>::new(Box::new(page_iterator), column_desc, None)
+                    .unwrap();
 
             // read data from the reader
             // the data type is decimal(8,2)
             let array = array_reader.next_batch(50).unwrap();
             assert_eq!(array.data_type(), &Decimal128(8, 2));
             let array = array.as_any().downcast_ref::<Decimal128Array>().unwrap();
-            let data_decimal_array = data[0..50].iter().copied().map(|v| Some(v as i128)).collect::<Decimal128Array>().with_precision_and_scale(8, 2).unwrap();
+            let data_decimal_array = data[0..50]
+                .iter()
+                .copied()
+                .map(|v| Some(v as i128))
+                .collect::<Decimal128Array>()
+                .with_precision_and_scale(8, 2)
+                .unwrap();
             assert_eq!(array, &data_decimal_array);
 
             // not equal with different data type(precision and scale)
-            let data_decimal_array = data[0..50].iter().copied().map(|v| Some(v as i128)).collect::<Decimal128Array>().with_precision_and_scale(9, 0).unwrap();
+            let data_decimal_array = data[0..50]
+                .iter()
+                .copied()
+                .map(|v| Some(v as i128))
+                .collect::<Decimal128Array>()
+                .with_precision_and_scale(9, 0)
+                .unwrap();
             assert_ne!(array, &data_decimal_array)
         }
 
@@ -687,26 +754,34 @@ mod tests {
                 true,
                 2,
             );
-            let page_iterator =
-                InMemoryPageIterator::new(schema, column_desc.clone(), page_lists);
-
-            let mut array_reader = PrimitiveArrayReader::<Int64Type>::new(
-                Box::new(page_iterator),
-                column_desc,
-                None,
-            )
-                .unwrap();
+            let page_iterator = InMemoryPageIterator::new(page_lists);
+
+            let mut array_reader =
+                PrimitiveArrayReader::<Int64Type>::new(Box::new(page_iterator), column_desc, None)
+                    .unwrap();
 
             // read data from the reader
             // the data type is decimal(18,4)
             let array = array_reader.next_batch(50).unwrap();
             assert_eq!(array.data_type(), &Decimal128(18, 4));
             let array = array.as_any().downcast_ref::<Decimal128Array>().unwrap();
-            let data_decimal_array = data[0..50].iter().copied().map(|v| Some(v as i128)).collect::<Decimal128Array>().with_precision_and_scale(18, 4).unwrap();
+            let data_decimal_array = data[0..50]
+                .iter()
+                .copied()
+                .map(|v| Some(v as i128))
+                .collect::<Decimal128Array>()
+                .with_precision_and_scale(18, 4)
+                .unwrap();
             assert_eq!(array, &data_decimal_array);
 
             // not equal with different data type(precision and scale)
-            let data_decimal_array = data[0..50].iter().copied().map(|v| Some(v as i128)).collect::<Decimal128Array>().with_precision_and_scale(34, 0).unwrap();
+            let data_decimal_array = data[0..50]
+                .iter()
+                .copied()
+                .map(|v| Some(v as i128))
+                .collect::<Decimal128Array>()
+                .with_precision_and_scale(34, 0)
+                .unwrap();
             assert_ne!(array, &data_decimal_array)
         }
     }
diff --git a/parquet/src/arrow/array_reader/struct_array.rs b/parquet/src/arrow/array_reader/struct_array.rs
index f682f146c721..4af194774bfb 100644
--- a/parquet/src/arrow/array_reader/struct_array.rs
+++ b/parquet/src/arrow/array_reader/struct_array.rs
@@ -17,10 +17,9 @@
 
 use crate::arrow::array_reader::ArrayReader;
 use crate::errors::{ParquetError, Result};
-use arrow::array::{
-    ArrayData, ArrayDataBuilder, ArrayRef, BooleanBufferBuilder, StructArray,
-};
-use arrow::datatypes::DataType as ArrowType;
+use arrow_array::{builder::BooleanBufferBuilder, Array, ArrayRef, StructArray};
+use arrow_data::{ArrayData, ArrayDataBuilder};
+use arrow_schema::DataType as ArrowType;
 use std::any::Any;
 use std::sync::Arc;
 
@@ -71,7 +70,7 @@ impl ArrayReader for StructArrayReader {
                 Some(expected) => {
                     if expected != child_read {
                         return Err(general_err!(
-                            "StructArrayReader out of sync in read_records, expected {} skipped, got {}",
+                            "StructArrayReader out of sync in read_records, expected {} read, got {}",
                             expected,
                             child_read
                         ));
@@ -131,7 +130,7 @@ impl ArrayReader for StructArrayReader {
             .child_data(
                 children_array
                     .iter()
-                    .map(|x| x.data().clone())
+                    .map(|x| x.to_data())
                     .collect::<Vec<ArrayData>>(),
             );
 
@@ -171,7 +170,7 @@ impl ArrayReader for StructArrayReader {
             }
 
             array_data_builder =
-                array_data_builder.null_bit_buffer(Some(bitmap_builder.finish()));
+                array_data_builder.null_bit_buffer(Some(bitmap_builder.into()));
         }
 
         let array_data = unsafe { array_data_builder.build_unchecked() };
@@ -216,9 +215,11 @@ mod tests {
     use super::*;
     use crate::arrow::array_reader::test_util::InMemoryArrayReader;
     use crate::arrow::array_reader::ListArrayReader;
-    use arrow::array::{Array, Int32Array, ListArray};
     use arrow::buffer::Buffer;
     use arrow::datatypes::Field;
+    use arrow_array::cast::AsArray;
+    use arrow_array::{Array, Int32Array, ListArray};
+    use arrow_schema::Fields;
 
     #[test]
     fn test_struct_array_reader() {
@@ -238,10 +239,10 @@ mod tests {
             Some(vec![0, 1, 1, 1, 1]),
         );
 
-        let struct_type = ArrowType::Struct(vec![
+        let struct_type = ArrowType::Struct(Fields::from(vec![
             Field::new("f1", array_1.data_type().clone(), true),
             Field::new("f2", array_2.data_type().clone(), true),
-        ]);
+        ]));
 
         let mut struct_array_reader = StructArrayReader::new(
             struct_type,
@@ -252,13 +253,13 @@ mod tests {
         );
 
         let struct_array = struct_array_reader.next_batch(5).unwrap();
-        let struct_array = struct_array.as_any().downcast_ref::<StructArray>().unwrap();
+        let struct_array = struct_array.as_struct();
 
         assert_eq!(5, struct_array.len());
         assert_eq!(
             vec![true, false, false, false, false],
             (0..5)
-                .map(|idx| struct_array.data_ref().is_null(idx))
+                .map(|idx| struct_array.is_null(idx))
                 .collect::<Vec<bool>>()
         );
         assert_eq!(
@@ -291,7 +292,7 @@ mod tests {
 
         let validity = Buffer::from([0b00000111]);
         let struct_fields = vec![(
-            Field::new("foo", expected_l.data_type().clone(), true),
+            Arc::new(Field::new("foo", expected_l.data_type().clone(), true)),
             expected_l.clone() as ArrayRef,
         )];
         let expected = StructArray::from((struct_fields, validity));
@@ -328,7 +329,7 @@ mod tests {
         );
 
         let actual = struct_reader.next_batch(1024).unwrap();
-        let actual = actual.as_any().downcast_ref::<StructArray>().unwrap();
+        let actual = actual.as_struct();
         assert_eq!(actual, &expected)
     }
 }
diff --git a/parquet/src/arrow/array_reader/test_util.rs b/parquet/src/arrow/array_reader/test_util.rs
index ca1aabfd4aa1..05032920139b 100644
--- a/parquet/src/arrow/array_reader/test_util.rs
+++ b/parquet/src/arrow/array_reader/test_util.rs
@@ -15,8 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::array::{Array, ArrayRef};
-use arrow::datatypes::DataType as ArrowType;
+use arrow_array::{Array, ArrayRef};
+use arrow_schema::DataType as ArrowType;
+use bytes::Bytes;
 use std::any::Any;
 use std::sync::Arc;
 
@@ -26,10 +27,7 @@ use crate::column::page::{PageIterator, PageReader};
 use crate::data_type::{ByteArray, ByteArrayType};
 use crate::encodings::encoding::{get_encoder, DictEncoder, Encoder};
 use crate::errors::Result;
-use crate::schema::types::{
-    ColumnDescPtr, ColumnDescriptor, ColumnPath, SchemaDescPtr, Type,
-};
-use crate::util::memory::ByteBufferPtr;
+use crate::schema::types::{ColumnDescPtr, ColumnDescriptor, ColumnPath, Type};
 
 /// Returns a descriptor for a UTF-8 column
 pub fn utf8_column() -> ColumnDescPtr {
@@ -47,7 +45,7 @@ pub fn utf8_column() -> ColumnDescPtr {
 }
 
 /// Encode `data` with the provided `encoding`
-pub fn encode_byte_array(encoding: Encoding, data: &[ByteArray]) -> ByteBufferPtr {
+pub fn encode_byte_array(encoding: Encoding, data: &[ByteArray]) -> Bytes {
     let mut encoder = get_encoder::<ByteArrayType>(encoding).unwrap();
 
     encoder.put(data).unwrap();
@@ -55,7 +53,7 @@ pub fn encode_byte_array(encoding: Encoding, data: &[ByteArray]) -> ByteBufferPt
 }
 
 /// Returns the encoded dictionary and value data
-pub fn encode_dictionary(data: &[ByteArray]) -> (ByteBufferPtr, ByteBufferPtr) {
+pub fn encode_dictionary(data: &[ByteArray]) -> (Bytes, Bytes) {
     let mut dict_encoder = DictEncoder::<ByteArrayType>::new(utf8_column());
 
     dict_encoder.put(data).unwrap();
@@ -70,7 +68,7 @@ pub fn encode_dictionary(data: &[ByteArray]) -> (ByteBufferPtr, ByteBufferPtr) {
 /// Returns an array of data with its associated encoding, along with an encoded dictionary
 pub fn byte_array_all_encodings(
     data: Vec<impl Into<ByteArray>>,
-) -> (Vec<(Encoding, ByteBufferPtr)>, ByteBufferPtr) {
+) -> (Vec<(Encoding, Bytes)>, Bytes) {
     let data: Vec<_> = data.into_iter().map(Into::into).collect();
     let (encoded_dictionary, encoded_rle) = encode_dictionary(&data);
 
@@ -197,15 +195,8 @@ impl ArrayReader for InMemoryArrayReader {
 }
 
 /// Iterator for testing reading empty columns
-pub struct EmptyPageIterator {
-    schema: SchemaDescPtr,
-}
-
-impl EmptyPageIterator {
-    pub fn new(schema: SchemaDescPtr) -> Self {
-        EmptyPageIterator { schema }
-    }
-}
+#[derive(Default)]
+pub struct EmptyPageIterator {}
 
 impl Iterator for EmptyPageIterator {
     type Item = Result<Box<dyn PageReader>>;
@@ -215,12 +206,4 @@ impl Iterator for EmptyPageIterator {
     }
 }
 
-impl PageIterator for EmptyPageIterator {
-    fn schema(&mut self) -> Result<SchemaDescPtr> {
-        Ok(self.schema.clone())
-    }
-
-    fn column_schema(&mut self) -> Result<ColumnDescPtr> {
-        Ok(self.schema.column(0))
-    }
-}
+impl PageIterator for EmptyPageIterator {}
diff --git a/parquet/src/arrow/arrow_reader/filter.rs b/parquet/src/arrow/arrow_reader/filter.rs
index 8945ccde4248..a80255f413ee 100644
--- a/parquet/src/arrow/arrow_reader/filter.rs
+++ b/parquet/src/arrow/arrow_reader/filter.rs
@@ -16,9 +16,8 @@
 // under the License.
 
 use crate::arrow::ProjectionMask;
-use arrow::array::BooleanArray;
-use arrow::error::Result as ArrowResult;
-use arrow::record_batch::RecordBatch;
+use arrow_array::{BooleanArray, RecordBatch};
+use arrow_schema::ArrowError;
 
 /// A predicate operating on [`RecordBatch`]
 pub trait ArrowPredicate: Send + 'static {
@@ -30,9 +29,11 @@ pub trait ArrowPredicate: Send + 'static {
     /// Evaluate this predicate for the given [`RecordBatch`] containing the columns
     /// identified by [`Self::projection`]
     ///
-    /// Rows that are `true` in the returned [`BooleanArray`] will be returned by the
-    /// parquet reader, whereas rows that are `false` or `Null` will not be
-    fn evaluate(&mut self, batch: RecordBatch) -> ArrowResult<BooleanArray>;
+    /// Must return a  [`BooleanArray`] that has the same length as the input
+    /// `batch` where each row indicates whether the row should be returned:
+    /// * `true`:the row should be returned
+    /// * `false` or `null`: the row should not be returned
+    fn evaluate(&mut self, batch: RecordBatch) -> Result<BooleanArray, ArrowError>;
 }
 
 /// An [`ArrowPredicate`] created from an [`FnMut`]
@@ -43,7 +44,7 @@ pub struct ArrowPredicateFn<F> {
 
 impl<F> ArrowPredicateFn<F>
 where
-    F: FnMut(RecordBatch) -> ArrowResult<BooleanArray> + Send + 'static,
+    F: FnMut(RecordBatch) -> Result<BooleanArray, ArrowError> + Send + 'static,
 {
     /// Create a new [`ArrowPredicateFn`]. `f` will be passed batches
     /// that contains the columns specified in `projection`
@@ -56,13 +57,13 @@ where
 
 impl<F> ArrowPredicate for ArrowPredicateFn<F>
 where
-    F: FnMut(RecordBatch) -> ArrowResult<BooleanArray> + Send + 'static,
+    F: FnMut(RecordBatch) -> Result<BooleanArray, ArrowError> + Send + 'static,
 {
     fn projection(&self) -> &ProjectionMask {
         &self.projection
     }
 
-    fn evaluate(&mut self, batch: RecordBatch) -> ArrowResult<BooleanArray> {
+    fn evaluate(&mut self, batch: RecordBatch) -> Result<BooleanArray, ArrowError> {
         (self.f)(batch)
     }
 }
@@ -95,7 +96,7 @@ where
 /// leaves 99% of the rows, it may be better to not filter the data from parquet and
 /// apply the filter after the RecordBatch has been fully decoded.
 ///
-/// [`RowSelection`]: [super::selection::RowSelection]
+/// [`RowSelection`]: crate::arrow::arrow_reader::RowSelection
 pub struct RowFilter {
     /// A list of [`ArrowPredicate`]
     pub(crate) predicates: Vec<Box<dyn ArrowPredicate>>,
diff --git a/parquet/src/arrow/arrow_reader/mod.rs b/parquet/src/arrow/arrow_reader/mod.rs
index e363919f6516..6b6146042051 100644
--- a/parquet/src/arrow/arrow_reader/mod.rs
+++ b/parquet/src/arrow/arrow_reader/mod.rs
@@ -20,74 +20,176 @@
 use std::collections::VecDeque;
 use std::sync::Arc;
 
-use arrow::array::Array;
-use arrow::compute::prep_null_mask_filter;
-use arrow::datatypes::{DataType as ArrowType, Schema, SchemaRef};
-use arrow::error::Result as ArrowResult;
-use arrow::record_batch::{RecordBatch, RecordBatchReader};
-use arrow::{array::StructArray, error::ArrowError};
+use arrow_array::cast::AsArray;
+use arrow_array::Array;
+use arrow_array::{RecordBatch, RecordBatchReader};
+use arrow_schema::{ArrowError, DataType as ArrowType, Schema, SchemaRef};
+use arrow_select::filter::prep_null_mask_filter;
 
 use crate::arrow::array_reader::{build_array_reader, ArrayReader};
-use crate::arrow::schema::parquet_to_arrow_schema;
-use crate::arrow::schema::parquet_to_arrow_schema_by_columns;
-use crate::arrow::ProjectionMask;
+use crate::arrow::schema::{parquet_to_arrow_schema_and_fields, ParquetField};
+use crate::arrow::{FieldLevels, ProjectionMask};
 use crate::errors::{ParquetError, Result};
-use crate::file::metadata::{KeyValue, ParquetMetaData};
-use crate::file::reader::{ChunkReader, FileReader, SerializedFileReader};
-use crate::file::serialized_reader::ReadOptionsBuilder;
+use crate::file::metadata::ParquetMetaData;
+use crate::file::reader::{ChunkReader, SerializedPageReader};
 use crate::schema::types::SchemaDescriptor;
 
-#[allow(unused)]
 mod filter;
-#[allow(unused)]
 mod selection;
 
-// TODO: Make these public once stable (#1792)
-#[allow(unused_imports)]
-pub(crate) use filter::{ArrowPredicate, ArrowPredicateFn, RowFilter};
-#[allow(unused_imports)]
-pub(crate) use selection::{RowSelection, RowSelector};
+pub use crate::arrow::array_reader::RowGroups;
+use crate::column::page::{PageIterator, PageReader};
+use crate::file::footer;
+use crate::file::page_index::index_reader;
+pub use filter::{ArrowPredicate, ArrowPredicateFn, RowFilter};
+pub use selection::{RowSelection, RowSelector};
 
-/// Arrow reader api.
-/// With this api, user can get arrow schema from parquet file, and read parquet data
-/// into arrow arrays.
-pub trait ArrowReader {
-    type RecordReader: RecordBatchReader;
+/// A generic builder for constructing sync or async arrow parquet readers. This is not intended
+/// to be used directly, instead you should use the specialization for the type of reader
+/// you wish to use
+///
+/// * For a synchronous API - [`ParquetRecordBatchReaderBuilder`]
+/// * For an asynchronous API - [`ParquetRecordBatchStreamBuilder`]
+///
+/// [`ParquetRecordBatchStreamBuilder`]: crate::arrow::async_reader::ParquetRecordBatchStreamBuilder
+pub struct ArrowReaderBuilder<T> {
+    pub(crate) input: T,
+
+    pub(crate) metadata: Arc<ParquetMetaData>,
+
+    pub(crate) schema: SchemaRef,
+
+    pub(crate) fields: Option<Arc<ParquetField>>,
+
+    pub(crate) batch_size: usize,
+
+    pub(crate) row_groups: Option<Vec<usize>>,
+
+    pub(crate) projection: ProjectionMask,
+
+    pub(crate) filter: Option<RowFilter>,
+
+    pub(crate) selection: Option<RowSelection>,
 
-    /// Read parquet schema and convert it into arrow schema.
-    fn get_schema(&mut self) -> Result<Schema>;
+    pub(crate) limit: Option<usize>,
 
-    /// Read parquet schema and convert it into arrow schema.
-    /// This schema only includes columns identified by `mask`.
-    fn get_schema_by_columns(&mut self, mask: ProjectionMask) -> Result<Schema>;
+    pub(crate) offset: Option<usize>,
+}
+
+impl<T> ArrowReaderBuilder<T> {
+    pub(crate) fn new_builder(input: T, metadata: ArrowReaderMetadata) -> Self {
+        Self {
+            input,
+            metadata: metadata.metadata,
+            schema: metadata.schema,
+            fields: metadata.fields,
+            batch_size: 1024,
+            row_groups: None,
+            projection: ProjectionMask::all(),
+            filter: None,
+            selection: None,
+            limit: None,
+            offset: None,
+        }
+    }
+
+    /// Returns a reference to the [`ParquetMetaData`] for this parquet file
+    pub fn metadata(&self) -> &Arc<ParquetMetaData> {
+        &self.metadata
+    }
+
+    /// Returns the parquet [`SchemaDescriptor`] for this parquet file
+    pub fn parquet_schema(&self) -> &SchemaDescriptor {
+        self.metadata.file_metadata().schema_descr()
+    }
 
-    /// Returns record batch reader from whole parquet file.
+    /// Returns the arrow [`SchemaRef`] for this parquet file
+    pub fn schema(&self) -> &SchemaRef {
+        &self.schema
+    }
+
+    /// Set the size of [`RecordBatch`] to produce. Defaults to 1024
+    /// If the batch_size more than the file row count, use the file row count.
+    pub fn with_batch_size(self, batch_size: usize) -> Self {
+        // Try to avoid allocate large buffer
+        let batch_size = batch_size.min(self.metadata.file_metadata().num_rows() as usize);
+        Self { batch_size, ..self }
+    }
+
+    /// Only read data from the provided row group indexes
+    pub fn with_row_groups(self, row_groups: Vec<usize>) -> Self {
+        Self {
+            row_groups: Some(row_groups),
+            ..self
+        }
+    }
+
+    /// Only read data from the provided column indexes
+    pub fn with_projection(self, mask: ProjectionMask) -> Self {
+        Self {
+            projection: mask,
+            ..self
+        }
+    }
+
+    /// Provide a [`RowSelection`] to filter out rows, and avoid fetching their
+    /// data into memory.
+    ///
+    /// Row group filtering is applied prior to this, and therefore rows from skipped
+    /// row groups should not be included in the [`RowSelection`]
     ///
-    /// # Arguments
+    /// An example use case of this would be applying a selection determined by
+    /// evaluating predicates against the [`Index`]
+    ///
+    /// [`Index`]: crate::file::page_index::index::Index
+    pub fn with_row_selection(self, selection: RowSelection) -> Self {
+        Self {
+            selection: Some(selection),
+            ..self
+        }
+    }
+
+    /// Provide a [`RowFilter`] to skip decoding rows
     ///
-    /// `batch_size`: The size of each record batch returned from this reader. Only the
-    /// last batch may contain records less than this size, otherwise record batches
-    /// returned from this reader should contains exactly `batch_size` elements.
-    fn get_record_reader(&mut self, batch_size: usize) -> Result<Self::RecordReader>;
+    /// Row filters are applied after row group selection and row selection
+    pub fn with_row_filter(self, filter: RowFilter) -> Self {
+        Self {
+            filter: Some(filter),
+            ..self
+        }
+    }
 
-    /// Returns record batch reader whose record batch contains columns identified by
-    /// `mask`.
+    /// Provide a limit to the number of rows to be read
     ///
-    /// # Arguments
+    /// The limit will be applied after any [`Self::with_row_selection`] and [`Self::with_row_filter`]
+    /// allowing it to limit the final set of rows decoded after any pushed down predicates
+    pub fn with_limit(self, limit: usize) -> Self {
+        Self {
+            limit: Some(limit),
+            ..self
+        }
+    }
+
+    /// Provide an offset to skip over the given number of rows
     ///
-    /// `mask`: The columns that should be included in record batches.
-    /// `batch_size`: Please refer to `get_record_reader`.
-    fn get_record_reader_by_columns(
-        &mut self,
-        mask: ProjectionMask,
-        batch_size: usize,
-    ) -> Result<Self::RecordReader>;
+    /// The offset will be applied after any [`Self::with_row_selection`] and [`Self::with_row_filter`]
+    /// allowing it to skip rows after any pushed down predicates
+    pub fn with_offset(self, offset: usize) -> Self {
+        Self {
+            offset: Some(offset),
+            ..self
+        }
+    }
 }
 
+/// Options that control how metadata is read for a parquet file
+///
+/// See [`ArrowReaderBuilder`] for how to configure how the column data
+/// is then read from the file, including projection and filter pushdown
 #[derive(Debug, Clone, Default)]
 pub struct ArrowReaderOptions {
     skip_arrow_metadata: bool,
-    selection: Option<RowSelection>,
+    pub(crate) page_index: bool,
 }
 
 impl ArrowReaderOptions {
@@ -109,149 +211,285 @@ impl ArrowReaderOptions {
         }
     }
 
-    /// Scan rows from the parquet file according to the provided `selection`
+    /// Set this true to enable decoding of the [PageIndex] if present. This can be used
+    /// to push down predicates to the parquet scan, potentially eliminating unnecessary IO
     ///
-    /// TODO: Revisit this API, as [`Self`] is provided before the file metadata is available
-    #[allow(unused)]
-    pub(crate) fn with_row_selection(self, selection: impl Into<RowSelection>) -> Self {
-        Self {
-            selection: Some(selection.into()),
-            ..self
-        }
+    /// [PageIndex]: https://github.com/apache/parquet-format/blob/master/PageIndex.md
+    pub fn with_page_index(self, page_index: bool) -> Self {
+        Self { page_index, ..self }
     }
 }
 
-/// An `ArrowReader` that can be used to synchronously read parquet data as [`RecordBatch`]
+/// The cheaply clone-able metadata necessary to construct a [`ArrowReaderBuilder`]
 ///
-/// See [`crate::arrow::async_reader`] for an asynchronous interface
-pub struct ParquetFileArrowReader {
-    file_reader: Arc<dyn FileReader>,
+/// This allows loading the metadata for a file once and then using this to construct
+/// multiple separate readers, for example, to distribute readers across multiple threads
+#[derive(Debug, Clone)]
+pub struct ArrowReaderMetadata {
+    pub(crate) metadata: Arc<ParquetMetaData>,
 
-    options: ArrowReaderOptions,
-}
+    pub(crate) schema: SchemaRef,
 
-impl ArrowReader for ParquetFileArrowReader {
-    type RecordReader = ParquetRecordBatchReader;
+    pub(crate) fields: Option<Arc<ParquetField>>,
+}
 
-    fn get_schema(&mut self) -> Result<Schema> {
-        let file_metadata = self.file_reader.metadata().file_metadata();
-        parquet_to_arrow_schema(file_metadata.schema_descr(), self.get_kv_metadata())
+impl ArrowReaderMetadata {
+    /// Loads [`ArrowReaderMetadata`] from the provided [`ChunkReader`]
+    ///
+    /// See [`ParquetRecordBatchReaderBuilder::new_with_metadata`] for how this can be used
+    pub fn load<T: ChunkReader>(reader: &T, options: ArrowReaderOptions) -> Result<Self> {
+        let mut metadata = footer::parse_metadata(reader)?;
+        if options.page_index {
+            let column_index = metadata
+                .row_groups()
+                .iter()
+                .map(|rg| index_reader::read_columns_indexes(reader, rg.columns()))
+                .collect::<Result<Vec<_>>>()?;
+            metadata.set_column_index(Some(column_index));
+
+            let offset_index = metadata
+                .row_groups()
+                .iter()
+                .map(|rg| index_reader::read_pages_locations(reader, rg.columns()))
+                .collect::<Result<Vec<_>>>()?;
+
+            metadata.set_offset_index(Some(offset_index))
+        }
+        Self::try_new(Arc::new(metadata), options)
     }
 
-    fn get_schema_by_columns(&mut self, mask: ProjectionMask) -> Result<Schema> {
-        let file_metadata = self.file_reader.metadata().file_metadata();
-        parquet_to_arrow_schema_by_columns(
-            file_metadata.schema_descr(),
-            mask,
-            self.get_kv_metadata(),
-        )
+    pub(crate) fn try_new(
+        metadata: Arc<ParquetMetaData>,
+        options: ArrowReaderOptions,
+    ) -> Result<Self> {
+        let kv_metadata = match options.skip_arrow_metadata {
+            true => None,
+            false => metadata.file_metadata().key_value_metadata(),
+        };
+
+        let (schema, fields) = parquet_to_arrow_schema_and_fields(
+            metadata.file_metadata().schema_descr(),
+            ProjectionMask::all(),
+            kv_metadata,
+        )?;
+
+        Ok(Self {
+            metadata,
+            schema: Arc::new(schema),
+            fields: fields.map(Arc::new),
+        })
     }
 
-    fn get_record_reader(
-        &mut self,
-        batch_size: usize,
-    ) -> Result<ParquetRecordBatchReader> {
-        self.get_record_reader_by_columns(ProjectionMask::all(), batch_size)
+    /// Returns a reference to the [`ParquetMetaData`] for this parquet file
+    pub fn metadata(&self) -> &Arc<ParquetMetaData> {
+        &self.metadata
     }
 
-    fn get_record_reader_by_columns(
-        &mut self,
-        mask: ProjectionMask,
-        batch_size: usize,
-    ) -> Result<ParquetRecordBatchReader> {
-        let array_reader =
-            build_array_reader(Arc::new(self.get_schema()?), mask, &self.file_reader)?;
+    /// Returns the parquet [`SchemaDescriptor`] for this parquet file
+    pub fn parquet_schema(&self) -> &SchemaDescriptor {
+        self.metadata.file_metadata().schema_descr()
+    }
 
-        Ok(ParquetRecordBatchReader::new(
-            batch_size,
-            array_reader,
-            self.options.selection.clone(),
-        ))
+    /// Returns the arrow [`SchemaRef`] for this parquet file
+    pub fn schema(&self) -> &SchemaRef {
+        &self.schema
     }
 }
 
-impl ParquetFileArrowReader {
-    /// Create a new [`ParquetFileArrowReader`] with the provided [`ChunkReader`]
+#[doc(hidden)]
+/// A newtype used within [`ReaderOptionsBuilder`] to distinguish sync readers from async
+pub struct SyncReader<T: ChunkReader>(T);
+
+/// A synchronous builder used to construct [`ParquetRecordBatchReader`] for a file
+///
+/// For an async API see [`crate::arrow::async_reader::ParquetRecordBatchStreamBuilder`]
+///
+/// See [`ArrowReaderBuilder`] for additional member functions
+pub type ParquetRecordBatchReaderBuilder<T> = ArrowReaderBuilder<SyncReader<T>>;
+
+impl<T: ChunkReader + 'static> ParquetRecordBatchReaderBuilder<T> {
+    /// Create a new [`ParquetRecordBatchReaderBuilder`]
     ///
-    /// ```no_run
-    /// # use std::fs::File;
+    /// ```
+    /// # use std::sync::Arc;
     /// # use bytes::Bytes;
-    /// # use parquet::arrow::ParquetFileArrowReader;
+    /// # use arrow_array::{Int32Array, RecordBatch};
+    /// # use arrow_schema::{DataType, Field, Schema};
+    /// # use parquet::arrow::arrow_reader::{ParquetRecordBatchReader, ParquetRecordBatchReaderBuilder};
+    /// # use parquet::arrow::ArrowWriter;
+    /// # let mut file: Vec<u8> = Vec::with_capacity(1024);
+    /// # let schema = Arc::new(Schema::new(vec![Field::new("i32", DataType::Int32, false)]));
+    /// # let mut writer = ArrowWriter::try_new(&mut file, schema.clone(), None).unwrap();
+    /// # let batch = RecordBatch::try_new(schema, vec![Arc::new(Int32Array::from(vec![1, 2, 3]))]).unwrap();
+    /// # writer.write(&batch).unwrap();
+    /// # writer.close().unwrap();
+    /// # let file = Bytes::from(file);
+    /// #
+    /// let mut builder = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+    ///
+    /// // Inspect metadata
+    /// assert_eq!(builder.metadata().num_row_groups(), 1);
     ///
-    /// let file = File::open("file.parquet").unwrap();
-    /// let reader = ParquetFileArrowReader::try_new(file).unwrap();
+    /// // Construct reader
+    /// let mut reader: ParquetRecordBatchReader = builder.with_row_groups(vec![0]).build().unwrap();
     ///
-    /// let bytes = Bytes::from(vec![]);
-    /// let reader = ParquetFileArrowReader::try_new(bytes).unwrap();
+    /// // Read data
+    /// let _batch = reader.next().unwrap().unwrap();
     /// ```
-    pub fn try_new<R: ChunkReader + 'static>(chunk_reader: R) -> Result<Self> {
-        Self::try_new_with_options(chunk_reader, Default::default())
+    pub fn try_new(reader: T) -> Result<Self> {
+        Self::try_new_with_options(reader, Default::default())
     }
 
-    /// Create a new [`ParquetFileArrowReader`] with the provided [`ChunkReader`]
-    /// and [`ArrowReaderOptions`]
-    pub fn try_new_with_options<R: ChunkReader + 'static>(
-        chunk_reader: R,
-        options: ArrowReaderOptions,
-    ) -> Result<Self> {
-        let file_reader = if options.selection.is_some() {
-            let options = ReadOptionsBuilder::new().with_page_index().build();
-            Arc::new(SerializedFileReader::new_with_options(
-                chunk_reader,
-                options,
-            )?)
-        } else {
-            Arc::new(SerializedFileReader::new(chunk_reader)?)
-        };
-        Ok(Self::new_with_options(file_reader, options))
+    /// Create a new [`ParquetRecordBatchReaderBuilder`] with [`ArrowReaderOptions`]
+    pub fn try_new_with_options(reader: T, options: ArrowReaderOptions) -> Result<Self> {
+        let metadata = ArrowReaderMetadata::load(&reader, options)?;
+        Ok(Self::new_with_metadata(reader, metadata))
     }
 
-    /// Create a new [`ParquetFileArrowReader`] with the provided [`Arc<dyn FileReader>`]
-    pub fn new(file_reader: Arc<dyn FileReader>) -> Self {
-        Self::new_with_options(file_reader, Default::default())
+    /// Create a [`ParquetRecordBatchReaderBuilder`] from the provided [`ArrowReaderMetadata`]
+    ///
+    /// This allows loading metadata once and using it to create multiple builders with
+    /// potentially different settings
+    ///
+    /// ```
+    /// # use std::fs::metadata;
+    /// # use std::sync::Arc;
+    /// # use bytes::Bytes;
+    /// # use arrow_array::{Int32Array, RecordBatch};
+    /// # use arrow_schema::{DataType, Field, Schema};
+    /// # use parquet::arrow::arrow_reader::{ArrowReaderMetadata, ParquetRecordBatchReader, ParquetRecordBatchReaderBuilder};
+    /// # use parquet::arrow::ArrowWriter;
+    /// # let mut file: Vec<u8> = Vec::with_capacity(1024);
+    /// # let schema = Arc::new(Schema::new(vec![Field::new("i32", DataType::Int32, false)]));
+    /// # let mut writer = ArrowWriter::try_new(&mut file, schema.clone(), None).unwrap();
+    /// # let batch = RecordBatch::try_new(schema, vec![Arc::new(Int32Array::from(vec![1, 2, 3]))]).unwrap();
+    /// # writer.write(&batch).unwrap();
+    /// # writer.close().unwrap();
+    /// # let file = Bytes::from(file);
+    /// #
+    /// let metadata = ArrowReaderMetadata::load(&file, Default::default()).unwrap();
+    /// let mut a = ParquetRecordBatchReaderBuilder::new_with_metadata(file.clone(), metadata.clone()).build().unwrap();
+    /// let mut b = ParquetRecordBatchReaderBuilder::new_with_metadata(file, metadata).build().unwrap();
+    ///
+    /// // Should be able to read from both in parallel
+    /// assert_eq!(a.next().unwrap().unwrap(), b.next().unwrap().unwrap());
+    /// ```
+    pub fn new_with_metadata(input: T, metadata: ArrowReaderMetadata) -> Self {
+        Self::new_builder(SyncReader(input), metadata)
     }
 
-    /// Create a new [`ParquetFileArrowReader`] with the provided [`Arc<dyn FileReader>`]
-    /// and [`ArrowReaderOptions`]
-    pub fn new_with_options(
-        file_reader: Arc<dyn FileReader>,
-        options: ArrowReaderOptions,
-    ) -> Self {
-        Self {
-            file_reader,
-            options,
+    /// Build a [`ParquetRecordBatchReader`]
+    ///
+    /// Note: this will eagerly evaluate any `RowFilter` before returning
+    pub fn build(self) -> Result<ParquetRecordBatchReader> {
+        // Try to avoid allocate large buffer
+        let batch_size = self
+            .batch_size
+            .min(self.metadata.file_metadata().num_rows() as usize);
+
+        let row_groups = self
+            .row_groups
+            .unwrap_or_else(|| (0..self.metadata.num_row_groups()).collect());
+
+        let reader = ReaderRowGroups {
+            reader: Arc::new(self.input.0),
+            metadata: self.metadata,
+            row_groups,
+        };
+
+        let mut filter = self.filter;
+        let mut selection = self.selection;
+
+        if let Some(filter) = filter.as_mut() {
+            for predicate in filter.predicates.iter_mut() {
+                if !selects_any(selection.as_ref()) {
+                    break;
+                }
+
+                let array_reader =
+                    build_array_reader(self.fields.as_deref(), predicate.projection(), &reader)?;
+
+                selection = Some(evaluate_predicate(
+                    batch_size,
+                    array_reader,
+                    selection,
+                    predicate.as_mut(),
+                )?);
+            }
         }
-    }
 
-    /// Expose the reader metadata
-    #[deprecated = "use metadata() instead"]
-    pub fn get_metadata(&mut self) -> ParquetMetaData {
-        self.file_reader.metadata().clone()
+        let array_reader = build_array_reader(self.fields.as_deref(), &self.projection, &reader)?;
+
+        // If selection is empty, truncate
+        if !selects_any(selection.as_ref()) {
+            selection = Some(RowSelection::from(vec![]));
+        }
+
+        Ok(ParquetRecordBatchReader::new(
+            batch_size,
+            array_reader,
+            apply_range(selection, reader.num_rows(), self.offset, self.limit),
+        ))
     }
+}
 
-    /// Returns the parquet metadata
-    pub fn metadata(&self) -> &ParquetMetaData {
-        self.file_reader.metadata()
+struct ReaderRowGroups<T: ChunkReader> {
+    reader: Arc<T>,
+
+    metadata: Arc<ParquetMetaData>,
+    /// Optional list of row group indices to scan
+    row_groups: Vec<usize>,
+}
+
+impl<T: ChunkReader + 'static> RowGroups for ReaderRowGroups<T> {
+    fn num_rows(&self) -> usize {
+        let meta = self.metadata.row_groups();
+        self.row_groups
+            .iter()
+            .map(|x| meta[*x].num_rows() as usize)
+            .sum()
     }
 
-    /// Returns the parquet schema
-    pub fn parquet_schema(&self) -> &SchemaDescriptor {
-        self.file_reader.metadata().file_metadata().schema_descr()
+    fn column_chunks(&self, i: usize) -> Result<Box<dyn PageIterator>> {
+        Ok(Box::new(ReaderPageIterator {
+            column_idx: i,
+            reader: self.reader.clone(),
+            metadata: self.metadata.clone(),
+            row_groups: self.row_groups.clone().into_iter(),
+        }))
     }
+}
 
-    /// Returns the key value metadata, returns `None` if [`ArrowReaderOptions::skip_arrow_metadata`]
-    fn get_kv_metadata(&self) -> Option<&Vec<KeyValue>> {
-        if self.options.skip_arrow_metadata {
-            return None;
-        }
+struct ReaderPageIterator<T: ChunkReader> {
+    reader: Arc<T>,
+    column_idx: usize,
+    row_groups: std::vec::IntoIter<usize>,
+    metadata: Arc<ParquetMetaData>,
+}
+
+impl<T: ChunkReader + 'static> Iterator for ReaderPageIterator<T> {
+    type Item = Result<Box<dyn PageReader>>;
 
-        self.file_reader
-            .metadata()
-            .file_metadata()
-            .key_value_metadata()
+    fn next(&mut self) -> Option<Self::Item> {
+        let rg_idx = self.row_groups.next()?;
+        let rg = self.metadata.row_group(rg_idx);
+        let meta = rg.column(self.column_idx);
+        let offset_index = self.metadata.offset_index();
+        // `offset_index` may not exist and `i[rg_idx]` will be empty.
+        // To avoid `i[rg_idx][self.oolumn_idx`] panic, we need to filter out empty `i[rg_idx]`.
+        let page_locations = offset_index
+            .filter(|i| !i[rg_idx].is_empty())
+            .map(|i| i[rg_idx][self.column_idx].clone());
+        let total_rows = rg.num_rows() as usize;
+        let reader = self.reader.clone();
+
+        let ret = SerializedPageReader::new(reader, meta, total_rows, page_locations);
+        Some(ret.map(|x| Box::new(x) as _))
     }
 }
 
+impl<T: ChunkReader + 'static> PageIterator for ReaderPageIterator<T> {}
+
 /// An `Iterator<Item = ArrowResult<RecordBatch>>` that yields [`RecordBatch`]
 /// read from a parquet data source
 pub struct ParquetRecordBatchReader {
@@ -262,7 +500,7 @@ pub struct ParquetRecordBatchReader {
 }
 
 impl Iterator for ParquetRecordBatchReader {
-    type Item = ArrowResult<RecordBatch>;
+    type Item = Result<RecordBatch, ArrowError>;
 
     fn next(&mut self) -> Option<Self::Item> {
         let mut read_records = 0;
@@ -271,11 +509,10 @@ impl Iterator for ParquetRecordBatchReader {
                 while read_records < self.batch_size && !selection.is_empty() {
                     let front = selection.pop_front().unwrap();
                     if front.skip {
-                        let skipped =
-                            match self.array_reader.skip_records(front.row_count) {
-                                Ok(skipped) => skipped,
-                                Err(e) => return Some(Err(e.into())),
-                            };
+                        let skipped = match self.array_reader.skip_records(front.row_count) {
+                            Ok(skipped) => skipped,
+                            Err(e) => return Some(Err(e.into())),
+                        };
 
                         if skipped != front.row_count {
                             return Some(Err(general_err!(
@@ -288,6 +525,12 @@ impl Iterator for ParquetRecordBatchReader {
                         continue;
                     }
 
+                    //Currently, when RowSelectors with row_count = 0 are included then its interpreted as end of reader.
+                    //Fix is to skip such entries. See https://github.com/apache/arrow-rs/issues/2669
+                    if front.row_count == 0 {
+                        continue;
+                    }
+
                     // try to read record
                     let need_read = self.batch_size - read_records;
                     let to_read = match front.row_count.checked_sub(need_read) {
@@ -316,12 +559,11 @@ impl Iterator for ParquetRecordBatchReader {
         match self.array_reader.consume_batch() {
             Err(error) => Some(Err(error.into())),
             Ok(array) => {
-                let struct_array =
-                    array.as_any().downcast_ref::<StructArray>().ok_or_else(|| {
-                        ArrowError::ParquetError(
-                            "Struct array reader should return struct array".to_string(),
-                        )
-                    });
+                let struct_array = array.as_struct_opt().ok_or_else(|| {
+                    ArrowError::ParquetError(
+                        "Struct array reader should return struct array".to_string(),
+                    )
+                });
 
                 match struct_array {
                     Err(err) => Some(Err(err)),
@@ -333,12 +575,46 @@ impl Iterator for ParquetRecordBatchReader {
 }
 
 impl RecordBatchReader for ParquetRecordBatchReader {
+    /// Returns the projected [`SchemaRef`] for reading the parquet file.
+    ///
+    /// Note that the schema metadata will be stripped here. See
+    /// [`ParquetRecordBatchReaderBuilder::schema`] if the metadata is desired.
     fn schema(&self) -> SchemaRef {
         self.schema.clone()
     }
 }
 
 impl ParquetRecordBatchReader {
+    /// Create a new [`ParquetRecordBatchReader`] from the provided chunk reader
+    ///
+    /// See [`ParquetRecordBatchReaderBuilder`] for more options
+    pub fn try_new<T: ChunkReader + 'static>(reader: T, batch_size: usize) -> Result<Self> {
+        ParquetRecordBatchReaderBuilder::try_new(reader)?
+            .with_batch_size(batch_size)
+            .build()
+    }
+
+    /// Create a new [`ParquetRecordBatchReader`] from the provided [`RowGroups`]
+    ///
+    /// Note: this is a low-level interface see [`ParquetRecordBatchReader::try_new`] for a
+    /// higher-level interface for reading parquet data from a file
+    pub fn try_new_with_row_groups(
+        levels: &FieldLevels,
+        row_groups: &dyn RowGroups,
+        batch_size: usize,
+        selection: Option<RowSelection>,
+    ) -> Result<Self> {
+        let array_reader =
+            build_array_reader(levels.levels.as_ref(), &ProjectionMask::all(), row_groups)?;
+
+        Ok(Self {
+            batch_size,
+            array_reader,
+            schema: Arc::new(Schema::new(levels.fields.clone())),
+            selection: selection.map(|s| s.trim().into()),
+        })
+    }
+
     /// Create a new [`ParquetRecordBatchReader`] that will read at most `batch_size` rows at
     /// a time from [`ArrayReader`] based on the configured `selection`. If `selection` is `None`
     /// all rows will be returned
@@ -356,28 +632,80 @@ impl ParquetRecordBatchReader {
             batch_size,
             array_reader,
             schema: Arc::new(schema),
-            selection: selection.map(Into::into),
+            selection: selection.map(|s| s.trim().into()),
         }
     }
 }
 
-/// Evaluates an [`ArrowPredicate`] returning the [`RowSelection`]
+/// Returns `true` if `selection` is `None` or selects some rows
+pub(crate) fn selects_any(selection: Option<&RowSelection>) -> bool {
+    selection.map(|x| x.selects_any()).unwrap_or(true)
+}
+
+/// Applies an optional offset and limit to an optional [`RowSelection`]
+pub(crate) fn apply_range(
+    mut selection: Option<RowSelection>,
+    row_count: usize,
+    offset: Option<usize>,
+    limit: Option<usize>,
+) -> Option<RowSelection> {
+    // If an offset is defined, apply it to the `selection`
+    if let Some(offset) = offset {
+        selection = Some(match row_count.checked_sub(offset) {
+            None => RowSelection::from(vec![]),
+            Some(remaining) => selection
+                .map(|selection| selection.offset(offset))
+                .unwrap_or_else(|| {
+                    RowSelection::from(vec![
+                        RowSelector::skip(offset),
+                        RowSelector::select(remaining),
+                    ])
+                }),
+        });
+    }
+
+    // If a limit is defined, apply it to the final `selection`
+    if let Some(limit) = limit {
+        selection = Some(
+            selection
+                .map(|selection| selection.limit(limit))
+                .unwrap_or_else(|| {
+                    RowSelection::from(vec![RowSelector::select(limit.min(row_count))])
+                }),
+        );
+    }
+    selection
+}
+
+/// Evaluates an [`ArrowPredicate`], returning a [`RowSelection`] indicating
+/// which rows to return.
 ///
-/// If this [`ParquetRecordBatchReader`] has a [`RowSelection`], the
-/// returned [`RowSelection`] will be the conjunction of this and
-/// the rows selected by `predicate`
-#[allow(unused)]
+/// `input_selection`: Optional pre-existing selection. If `Some`, then the
+/// final [`RowSelection`] will be the conjunction of it and the rows selected
+/// by `predicate`.
+///
+/// Note: A pre-existing selection may come from evaluating a previous predicate
+/// or if the [`ParquetRecordBatchReader`] specified an explicit
+/// [`RowSelection`] in addition to one or more predicates.
 pub(crate) fn evaluate_predicate(
     batch_size: usize,
     array_reader: Box<dyn ArrayReader>,
     input_selection: Option<RowSelection>,
     predicate: &mut dyn ArrowPredicate,
 ) -> Result<RowSelection> {
-    let reader =
-        ParquetRecordBatchReader::new(batch_size, array_reader, input_selection.clone());
+    let reader = ParquetRecordBatchReader::new(batch_size, array_reader, input_selection.clone());
     let mut filters = vec![];
     for maybe_batch in reader {
-        let filter = predicate.evaluate(maybe_batch?)?;
+        let maybe_batch = maybe_batch?;
+        let input_rows = maybe_batch.num_rows();
+        let filter = predicate.evaluate(maybe_batch)?;
+        // Since user supplied predicate, check error here to catch bugs quickly
+        if filter.len() != input_rows {
+            return Err(arrow_err!(
+                "ArrowPredicate predicate returned {} rows, expected {input_rows}",
+                filter.len()
+            ));
+        }
         match filter.null_count() {
             0 => filters.push(filter),
             _ => filters.push(prep_null_mask_filter(&filter)),
@@ -393,41 +721,46 @@ pub(crate) fn evaluate_predicate(
 
 #[cfg(test)]
 mod tests {
-    use bytes::Bytes;
     use std::cmp::min;
     use std::collections::VecDeque;
-    use std::convert::TryFrom;
+    use std::fmt::Formatter;
     use std::fs::File;
     use std::io::Seek;
     use std::path::PathBuf;
     use std::sync::Arc;
 
+    use bytes::Bytes;
+    use half::f16;
+    use num::PrimInt;
     use rand::{thread_rng, Rng, RngCore};
     use tempfile::tempfile;
 
-    use arrow::array::*;
-    use arrow::buffer::Buffer;
-    use arrow::datatypes::{DataType as ArrowDataType, Field, Schema};
-    use arrow::error::Result as ArrowResult;
-    use arrow::record_batch::{RecordBatch, RecordBatchReader};
+    use arrow_array::builder::*;
+    use arrow_array::cast::AsArray;
+    use arrow_array::types::{
+        Decimal128Type, Decimal256Type, DecimalType, Float16Type, Float32Type, Float64Type,
+    };
+    use arrow_array::*;
+    use arrow_array::{RecordBatch, RecordBatchReader};
+    use arrow_buffer::{i256, ArrowNativeType, Buffer};
+    use arrow_data::ArrayDataBuilder;
+    use arrow_schema::{DataType as ArrowDataType, Field, Fields, Schema};
+    use arrow_select::concat::concat_batches;
 
     use crate::arrow::arrow_reader::{
-        ArrowReader, ArrowReaderOptions, ParquetFileArrowReader,
-        ParquetRecordBatchReader, RowSelection, RowSelector,
-    };
-    use crate::arrow::buffer::converter::{
-        Converter, FixedSizeArrayConverter, IntervalDayTimeArrayConverter,
+        ArrowPredicateFn, ArrowReaderOptions, ParquetRecordBatchReader,
+        ParquetRecordBatchReaderBuilder, RowFilter, RowSelection, RowSelector,
     };
     use crate::arrow::schema::add_encoded_arrow_schema_to_metadata;
     use crate::arrow::{ArrowWriter, ProjectionMask};
     use crate::basic::{ConvertedType, Encoding, Repetition, Type as PhysicalType};
+    use crate::column::reader::decoder::REPETITION_LEVELS_BATCH_SIZE;
     use crate::data_type::{
-        BoolType, ByteArray, ByteArrayType, DataType, FixedLenByteArray,
-        FixedLenByteArrayType, Int32Type, Int64Type,
+        BoolType, ByteArray, ByteArrayType, DataType, FixedLenByteArray, FixedLenByteArrayType,
+        FloatType, Int32Type, Int64Type, Int96Type,
     };
     use crate::errors::Result;
     use crate::file::properties::{EnabledStatistics, WriterProperties, WriterVersion};
-    use crate::file::reader::{FileReader, SerializedFileReader};
     use crate::file::writer::SerializedFileWriter;
     use crate::schema::parser::parse_message_type;
     use crate::schema::types::{Type, TypePtr};
@@ -435,38 +768,29 @@ mod tests {
 
     #[test]
     fn test_arrow_reader_all_columns() {
-        let parquet_file_reader =
-            get_test_reader("parquet/generated_simple_numerics/blogs.parquet");
-
-        let mut arrow_reader = ParquetFileArrowReader::new(parquet_file_reader);
+        let file = get_test_file("parquet/generated_simple_numerics/blogs.parquet");
 
-        let record_batch_reader = arrow_reader
-            .get_record_reader(60)
-            .expect("Failed to read into array!");
+        let builder = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+        let original_schema = Arc::clone(builder.schema());
+        let reader = builder.build().unwrap();
 
         // Verify that the schema was correctly parsed
-        let original_schema = arrow_reader.get_schema().unwrap().fields().clone();
-        assert_eq!(original_schema, *record_batch_reader.schema().fields());
+        assert_eq!(original_schema.fields(), reader.schema().fields());
     }
 
     #[test]
     fn test_arrow_reader_single_column() {
-        let parquet_file_reader =
-            get_test_reader("parquet/generated_simple_numerics/blogs.parquet");
+        let file = get_test_file("parquet/generated_simple_numerics/blogs.parquet");
 
-        let file_metadata = parquet_file_reader.metadata().file_metadata();
+        let builder = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+        let original_schema = Arc::clone(builder.schema());
 
-        let mask = ProjectionMask::leaves(file_metadata.schema_descr(), [2]);
-        let mut arrow_reader = ParquetFileArrowReader::new(parquet_file_reader);
-
-        let record_batch_reader = arrow_reader
-            .get_record_reader_by_columns(mask, 60)
-            .expect("Failed to read into array!");
+        let mask = ProjectionMask::leaves(builder.parquet_schema(), [2]);
+        let reader = builder.with_projection(mask).build().unwrap();
 
         // Verify that the schema was correctly parsed
-        let original_schema = arrow_reader.get_schema().unwrap().fields().clone();
-        assert_eq!(1, record_batch_reader.schema().fields().len());
-        assert_eq!(original_schema[1], record_batch_reader.schema().fields()[0]);
+        assert_eq!(1, reader.schema().fields().len());
+        assert_eq!(original_schema.fields()[1], reader.schema().fields()[0]);
     }
 
     #[test]
@@ -493,10 +817,8 @@ mod tests {
 
         file.rewind().unwrap();
 
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-        let record_reader = arrow_reader.get_record_reader(2).unwrap();
-
-        let batches = record_reader.collect::<ArrowResult<Vec<_>>>().unwrap();
+        let record_reader = ParquetRecordBatchReader::try_new(file, 2).unwrap();
+        let batches = record_reader.collect::<Result<Vec<_>, _>>().unwrap();
 
         assert_eq!(batches.len(), 4);
         for batch in &batches[0..3] {
@@ -541,6 +863,153 @@ mod tests {
                 Encoding::DELTA_BINARY_PACKED,
             ],
         );
+        run_single_column_reader_tests::<FloatType, _, FloatType>(
+            2,
+            ConvertedType::NONE,
+            None,
+            |vals| Arc::new(Float32Array::from_iter(vals.iter().cloned())),
+            &[Encoding::PLAIN, Encoding::BYTE_STREAM_SPLIT],
+        );
+    }
+
+    #[test]
+    fn test_unsigned_primitive_single_column_reader_test() {
+        run_single_column_reader_tests::<Int32Type, _, Int32Type>(
+            2,
+            ConvertedType::UINT_32,
+            Some(ArrowDataType::UInt32),
+            |vals| {
+                Arc::new(UInt32Array::from_iter(
+                    vals.iter().map(|x| x.map(|x| x as u32)),
+                ))
+            },
+            &[
+                Encoding::PLAIN,
+                Encoding::RLE_DICTIONARY,
+                Encoding::DELTA_BINARY_PACKED,
+            ],
+        );
+        run_single_column_reader_tests::<Int64Type, _, Int64Type>(
+            2,
+            ConvertedType::UINT_64,
+            Some(ArrowDataType::UInt64),
+            |vals| {
+                Arc::new(UInt64Array::from_iter(
+                    vals.iter().map(|x| x.map(|x| x as u64)),
+                ))
+            },
+            &[
+                Encoding::PLAIN,
+                Encoding::RLE_DICTIONARY,
+                Encoding::DELTA_BINARY_PACKED,
+            ],
+        );
+    }
+
+    #[test]
+    fn test_unsigned_roundtrip() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("uint32", ArrowDataType::UInt32, true),
+            Field::new("uint64", ArrowDataType::UInt64, true),
+        ]));
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buf, schema.clone(), None).unwrap();
+
+        let original = RecordBatch::try_new(
+            schema,
+            vec![
+                Arc::new(UInt32Array::from_iter_values([
+                    0,
+                    i32::MAX as u32,
+                    u32::MAX,
+                ])),
+                Arc::new(UInt64Array::from_iter_values([
+                    0,
+                    i64::MAX as u64,
+                    u64::MAX,
+                ])),
+            ],
+        )
+        .unwrap();
+
+        writer.write(&original).unwrap();
+        writer.close().unwrap();
+
+        let mut reader = ParquetRecordBatchReader::try_new(Bytes::from(buf), 1024).unwrap();
+        let ret = reader.next().unwrap().unwrap();
+        assert_eq!(ret, original);
+
+        // Check they can be downcast to the correct type
+        ret.column(0)
+            .as_any()
+            .downcast_ref::<UInt32Array>()
+            .unwrap();
+
+        ret.column(1)
+            .as_any()
+            .downcast_ref::<UInt64Array>()
+            .unwrap();
+    }
+
+    #[test]
+    fn test_float16_roundtrip() -> Result<()> {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("float16", ArrowDataType::Float16, false),
+            Field::new("float16-nullable", ArrowDataType::Float16, true),
+        ]));
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buf, schema.clone(), None)?;
+
+        let original = RecordBatch::try_new(
+            schema,
+            vec![
+                Arc::new(Float16Array::from_iter_values([
+                    f16::EPSILON,
+                    f16::MIN,
+                    f16::MAX,
+                    f16::NAN,
+                    f16::INFINITY,
+                    f16::NEG_INFINITY,
+                    f16::ONE,
+                    f16::NEG_ONE,
+                    f16::ZERO,
+                    f16::NEG_ZERO,
+                    f16::E,
+                    f16::PI,
+                    f16::FRAC_1_PI,
+                ])),
+                Arc::new(Float16Array::from(vec![
+                    None,
+                    None,
+                    None,
+                    Some(f16::NAN),
+                    Some(f16::INFINITY),
+                    Some(f16::NEG_INFINITY),
+                    None,
+                    None,
+                    None,
+                    None,
+                    None,
+                    None,
+                    Some(f16::FRAC_1_PI),
+                ])),
+            ],
+        )?;
+
+        writer.write(&original)?;
+        writer.close()?;
+
+        let mut reader = ParquetRecordBatchReader::try_new(Bytes::from(buf), 1024)?;
+        let ret = reader.next().unwrap()?;
+        assert_eq!(ret, original);
+
+        // Ensure can be downcast to the correct type
+        ret.column(0).as_primitive::<Float16Type>();
+        ret.column(1).as_primitive::<Float16Type>();
+
+        Ok(())
     }
 
     struct RandFixedLenGen {}
@@ -548,35 +1017,67 @@ mod tests {
     impl RandGen<FixedLenByteArrayType> for RandFixedLenGen {
         fn gen(len: i32) -> FixedLenByteArray {
             let mut v = vec![0u8; len as usize];
-            rand::thread_rng().fill_bytes(&mut v);
+            thread_rng().fill_bytes(&mut v);
             ByteArray::from(v).into()
         }
     }
 
     #[test]
     fn test_fixed_length_binary_column_reader() {
-        let converter = FixedSizeArrayConverter::new(20);
         run_single_column_reader_tests::<FixedLenByteArrayType, _, RandFixedLenGen>(
             20,
             ConvertedType::NONE,
             None,
-            |vals| Arc::new(converter.convert(vals.to_vec()).unwrap()),
+            |vals| {
+                let mut builder = FixedSizeBinaryBuilder::with_capacity(vals.len(), 20);
+                for val in vals {
+                    match val {
+                        Some(b) => builder.append_value(b).unwrap(),
+                        None => builder.append_null(),
+                    }
+                }
+                Arc::new(builder.finish())
+            },
             &[Encoding::PLAIN, Encoding::RLE_DICTIONARY],
         );
     }
 
     #[test]
     fn test_interval_day_time_column_reader() {
-        let converter = IntervalDayTimeArrayConverter {};
         run_single_column_reader_tests::<FixedLenByteArrayType, _, RandFixedLenGen>(
             12,
             ConvertedType::INTERVAL,
             None,
-            |vals| Arc::new(converter.convert(vals.to_vec()).unwrap()),
+            |vals| {
+                Arc::new(
+                    vals.iter()
+                        .map(|x| {
+                            x.as_ref()
+                                .map(|b| i64::from_le_bytes(b.as_ref()[4..12].try_into().unwrap()))
+                        })
+                        .collect::<IntervalDayTimeArray>(),
+                )
+            },
             &[Encoding::PLAIN, Encoding::RLE_DICTIONARY],
         );
     }
 
+    #[test]
+    fn test_int96_single_column_reader_test() {
+        let encodings = &[Encoding::PLAIN, Encoding::RLE_DICTIONARY];
+        run_single_column_reader_tests::<Int96Type, _, Int96Type>(
+            2,
+            ConvertedType::NONE,
+            None,
+            |vals| {
+                Arc::new(TimestampNanosecondArray::from_iter(
+                    vals.iter().map(|x| x.map(|x| x.to_nanos())),
+                )) as _
+            },
+            encodings,
+        );
+    }
+
     struct RandUtf8Gen {}
 
     impl RandGen<ByteArrayType> for RandUtf8Gen {
@@ -642,10 +1143,8 @@ mod tests {
                 let mut opts = TestOptions::new(2, 20, 15).with_null_percent(50);
                 opts.encoding = *encoding;
 
-                let data_type = ArrowDataType::Dictionary(
-                    Box::new(key.clone()),
-                    Box::new(ArrowDataType::Utf8),
-                );
+                let data_type =
+                    ArrowDataType::Dictionary(Box::new(key.clone()), Box::new(ArrowDataType::Utf8));
 
                 // Cannot run full test suite as keys overflow, run small test instead
                 single_column_reader_test::<ByteArrayType, _, RandUtf8Gen>(
@@ -671,10 +1170,8 @@ mod tests {
         ];
 
         for key in &key_types {
-            let data_type = ArrowDataType::Dictionary(
-                Box::new(key.clone()),
-                Box::new(ArrowDataType::Utf8),
-            );
+            let data_type =
+                ArrowDataType::Dictionary(Box::new(key.clone()), Box::new(ArrowDataType::Utf8));
 
             run_single_column_reader_tests::<ByteArrayType, _, RandUtf8Gen>(
                 2,
@@ -708,36 +1205,33 @@ mod tests {
 
     #[test]
     fn test_decimal_nullable_struct() {
-        let decimals = Decimal128Array::from_iter_values([1, 2, 3, 4, 5, 6, 7, 8]);
+        let decimals = Decimal256Array::from_iter_values(
+            [1, 2, 3, 4, 5, 6, 7, 8].into_iter().map(i256::from_i128),
+        );
 
-        let data = ArrayDataBuilder::new(ArrowDataType::Struct(vec![Field::new(
+        let data = ArrayDataBuilder::new(ArrowDataType::Struct(Fields::from(vec![Field::new(
             "decimals",
             decimals.data_type().clone(),
             false,
-        )]))
+        )])))
         .len(8)
         .null_bit_buffer(Some(Buffer::from(&[0b11101111])))
         .child_data(vec![decimals.into_data()])
         .build()
         .unwrap();
 
-        let written = RecordBatch::try_from_iter([(
-            "struct",
-            Arc::new(StructArray::from(data)) as ArrayRef,
-        )])
-        .unwrap();
+        let written =
+            RecordBatch::try_from_iter([("struct", Arc::new(StructArray::from(data)) as ArrayRef)])
+                .unwrap();
 
         let mut buffer = Vec::with_capacity(1024);
-        let mut writer =
-            ArrowWriter::try_new(&mut buffer, written.schema(), None).unwrap();
+        let mut writer = ArrowWriter::try_new(&mut buffer, written.schema(), None).unwrap();
         writer.write(&written).unwrap();
         writer.close().unwrap();
 
-        let read = ParquetFileArrowReader::try_new(Bytes::from(buffer))
+        let read = ParquetRecordBatchReader::try_new(Bytes::from(buffer), 3)
             .unwrap()
-            .get_record_reader(3)
-            .unwrap()
-            .collect::<ArrowResult<Vec<_>>>()
+            .collect::<Result<Vec<_>, _>>()
             .unwrap();
 
         assert_eq!(&written.slice(0, 3), &read[0]);
@@ -748,34 +1242,29 @@ mod tests {
     #[test]
     fn test_int32_nullable_struct() {
         let int32 = Int32Array::from_iter_values([1, 2, 3, 4, 5, 6, 7, 8]);
-        let data = ArrayDataBuilder::new(ArrowDataType::Struct(vec![Field::new(
+        let data = ArrayDataBuilder::new(ArrowDataType::Struct(Fields::from(vec![Field::new(
             "int32",
             int32.data_type().clone(),
             false,
-        )]))
+        )])))
         .len(8)
         .null_bit_buffer(Some(Buffer::from(&[0b11101111])))
         .child_data(vec![int32.into_data()])
         .build()
         .unwrap();
 
-        let written = RecordBatch::try_from_iter([(
-            "struct",
-            Arc::new(StructArray::from(data)) as ArrayRef,
-        )])
-        .unwrap();
+        let written =
+            RecordBatch::try_from_iter([("struct", Arc::new(StructArray::from(data)) as ArrayRef)])
+                .unwrap();
 
         let mut buffer = Vec::with_capacity(1024);
-        let mut writer =
-            ArrowWriter::try_new(&mut buffer, written.schema(), None).unwrap();
+        let mut writer = ArrowWriter::try_new(&mut buffer, written.schema(), None).unwrap();
         writer.write(&written).unwrap();
         writer.close().unwrap();
 
-        let read = ParquetFileArrowReader::try_new(Bytes::from(buffer))
+        let read = ParquetRecordBatchReader::try_new(Bytes::from(buffer), 3)
             .unwrap()
-            .get_record_reader(3)
-            .unwrap()
-            .collect::<ArrowResult<Vec<_>>>()
+            .collect::<Result<Vec<_>, _>>()
             .unwrap();
 
         assert_eq!(&written.slice(0, 3), &read[0]);
@@ -789,7 +1278,7 @@ mod tests {
         let decimals = Decimal128Array::from_iter_values([1, 2, 3, 4, 5, 6, 7, 8]);
 
         // [[], [1], [2, 3], null, [4], null, [6, 7, 8]]
-        let data = ArrayDataBuilder::new(ArrowDataType::List(Box::new(Field::new(
+        let data = ArrayDataBuilder::new(ArrowDataType::List(Arc::new(Field::new(
             "item",
             decimals.data_type().clone(),
             false,
@@ -801,23 +1290,18 @@ mod tests {
         .build()
         .unwrap();
 
-        let written = RecordBatch::try_from_iter([(
-            "list",
-            Arc::new(ListArray::from(data)) as ArrayRef,
-        )])
-        .unwrap();
+        let written =
+            RecordBatch::try_from_iter([("list", Arc::new(ListArray::from(data)) as ArrayRef)])
+                .unwrap();
 
         let mut buffer = Vec::with_capacity(1024);
-        let mut writer =
-            ArrowWriter::try_new(&mut buffer, written.schema(), None).unwrap();
+        let mut writer = ArrowWriter::try_new(&mut buffer, written.schema(), None).unwrap();
         writer.write(&written).unwrap();
         writer.close().unwrap();
 
-        let read = ParquetFileArrowReader::try_new(Bytes::from(buffer))
-            .unwrap()
-            .get_record_reader(3)
+        let read = ParquetRecordBatchReader::try_new(Bytes::from(buffer), 3)
             .unwrap()
-            .collect::<ArrowResult<Vec<_>>>()
+            .collect::<Result<Vec<_>, _>>()
             .unwrap();
 
         assert_eq!(&written.slice(0, 3), &read[0]);
@@ -827,7 +1311,7 @@ mod tests {
 
     #[test]
     fn test_read_decimal_file() {
-        use arrow::array::Decimal128Array;
+        use arrow_array::Decimal128Array;
         let testdata = arrow::util::test_util::parquet_test_data();
         let file_variants = vec![
             ("byte_array", 4),
@@ -836,11 +1320,9 @@ mod tests {
             ("int64", 10),
         ];
         for (prefix, target_precision) in file_variants {
-            let path = format!("{}/{}_decimal.parquet", testdata, prefix);
-            let file = File::open(&path).unwrap();
-            let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-
-            let mut record_reader = arrow_reader.get_record_reader(32).unwrap();
+            let path = format!("{testdata}/{prefix}_decimal.parquet");
+            let file = File::open(path).unwrap();
+            let mut record_reader = ParquetRecordBatchReader::try_new(file, 32).unwrap();
 
             let batch = record_reader.next().unwrap().unwrap();
             assert_eq!(batch.num_rows(), 24);
@@ -856,13 +1338,98 @@ mod tests {
             assert_eq!(col.scale(), 2);
 
             for (i, v) in expected.enumerate() {
-                assert_eq!(col.value(i).as_i128(), v * 100_i128);
+                assert_eq!(col.value(i), v * 100_i128);
             }
         }
     }
 
+    #[test]
+    fn test_read_float16_nonzeros_file() {
+        use arrow_array::Float16Array;
+        let testdata = arrow::util::test_util::parquet_test_data();
+        // see https://github.com/apache/parquet-testing/pull/40
+        let path = format!("{testdata}/float16_nonzeros_and_nans.parquet");
+        let file = File::open(path).unwrap();
+        let mut record_reader = ParquetRecordBatchReader::try_new(file, 32).unwrap();
+
+        let batch = record_reader.next().unwrap().unwrap();
+        assert_eq!(batch.num_rows(), 8);
+        let col = batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<Float16Array>()
+            .unwrap();
+
+        let f16_two = f16::ONE + f16::ONE;
+
+        assert_eq!(col.null_count(), 1);
+        assert!(col.is_null(0));
+        assert_eq!(col.value(1), f16::ONE);
+        assert_eq!(col.value(2), -f16_two);
+        assert!(col.value(3).is_nan());
+        assert_eq!(col.value(4), f16::ZERO);
+        assert!(col.value(4).is_sign_positive());
+        assert_eq!(col.value(5), f16::NEG_ONE);
+        assert_eq!(col.value(6), f16::NEG_ZERO);
+        assert!(col.value(6).is_sign_negative());
+        assert_eq!(col.value(7), f16_two);
+    }
+
+    #[test]
+    fn test_read_float16_zeros_file() {
+        use arrow_array::Float16Array;
+        let testdata = arrow::util::test_util::parquet_test_data();
+        // see https://github.com/apache/parquet-testing/pull/40
+        let path = format!("{testdata}/float16_zeros_and_nans.parquet");
+        let file = File::open(path).unwrap();
+        let mut record_reader = ParquetRecordBatchReader::try_new(file, 32).unwrap();
+
+        let batch = record_reader.next().unwrap().unwrap();
+        assert_eq!(batch.num_rows(), 3);
+        let col = batch
+            .column(0)
+            .as_any()
+            .downcast_ref::<Float16Array>()
+            .unwrap();
+
+        assert_eq!(col.null_count(), 1);
+        assert!(col.is_null(0));
+        assert_eq!(col.value(1), f16::ZERO);
+        assert!(col.value(1).is_sign_positive());
+        assert!(col.value(2).is_nan());
+    }
+
+    #[test]
+    fn test_read_float32_float64_byte_stream_split() {
+        let path = format!(
+            "{}/byte_stream_split.zstd.parquet",
+            arrow::util::test_util::parquet_test_data(),
+        );
+        let file = File::open(path).unwrap();
+        let record_reader = ParquetRecordBatchReader::try_new(file, 128).unwrap();
+
+        let mut row_count = 0;
+        for batch in record_reader {
+            let batch = batch.unwrap();
+            row_count += batch.num_rows();
+            let f32_col = batch.column(0).as_primitive::<Float32Type>();
+            let f64_col = batch.column(1).as_primitive::<Float64Type>();
+
+            // This file contains floats from a standard normal distribution
+            for &x in f32_col.values() {
+                assert!(x > -10.0);
+                assert!(x < 10.0);
+            }
+            for &x in f64_col.values() {
+                assert!(x > -10.0);
+                assert!(x < 10.0);
+            }
+        }
+        assert_eq!(row_count, 300);
+    }
+
     /// Parameters for single_column_reader_test
-    #[derive(Debug, Clone)]
+    #[derive(Clone)]
     struct TestOptions {
         /// Number of row group to write to parquet (row group size =
         /// num_row_groups / num_rows)
@@ -888,8 +1455,36 @@ mod tests {
         enabled_statistics: EnabledStatistics,
         /// Encoding
         encoding: Encoding,
-        //row selections and total selected row count
+        /// row selections and total selected row count
         row_selections: Option<(RowSelection, usize)>,
+        /// row filter
+        row_filter: Option<Vec<bool>>,
+        /// limit
+        limit: Option<usize>,
+        /// offset
+        offset: Option<usize>,
+    }
+
+    /// Manually implement this to avoid printing entire contents of row_selections and row_filter
+    impl std::fmt::Debug for TestOptions {
+        fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+            f.debug_struct("TestOptions")
+                .field("num_row_groups", &self.num_row_groups)
+                .field("num_rows", &self.num_rows)
+                .field("record_batch_size", &self.record_batch_size)
+                .field("null_percent", &self.null_percent)
+                .field("write_batch_size", &self.write_batch_size)
+                .field("max_data_page_size", &self.max_data_page_size)
+                .field("max_dict_page_size", &self.max_dict_page_size)
+                .field("writer_version", &self.writer_version)
+                .field("enabled_statistics", &self.enabled_statistics)
+                .field("encoding", &self.encoding)
+                .field("row_selections", &self.row_selections.is_some())
+                .field("row_filter", &self.row_filter.is_some())
+                .field("limit", &self.limit)
+                .field("offset", &self.offset)
+                .finish()
+        }
     }
 
     impl Default for TestOptions {
@@ -906,6 +1501,9 @@ mod tests {
                 enabled_statistics: EnabledStatistics::Page,
                 encoding: Encoding::PLAIN,
                 row_selections: None,
+                row_filter: None,
+                limit: None,
+                offset: None,
             }
         }
     }
@@ -949,22 +1547,48 @@ mod tests {
         }
 
         fn with_row_selections(self) -> Self {
+            assert!(self.row_filter.is_none(), "Must set row selection first");
+
             let mut rng = thread_rng();
             let step = rng.gen_range(self.record_batch_size..self.num_rows);
-            let row_selections = create_test_selection(
-                step,
-                self.num_row_groups * self.num_rows,
-                rng.gen::<bool>(),
-            );
+            let row_selections =
+                create_test_selection(step, self.num_row_groups * self.num_rows, rng.gen::<bool>());
             Self {
                 row_selections: Some(row_selections),
                 ..self
             }
         }
 
+        fn with_row_filter(self) -> Self {
+            let row_count = match &self.row_selections {
+                Some((_, count)) => *count,
+                None => self.num_row_groups * self.num_rows,
+            };
+
+            let mut rng = thread_rng();
+            Self {
+                row_filter: Some((0..row_count).map(|_| rng.gen_bool(0.9)).collect()),
+                ..self
+            }
+        }
+
+        fn with_limit(self, limit: usize) -> Self {
+            Self {
+                limit: Some(limit),
+                ..self
+            }
+        }
+
+        fn with_offset(self, offset: usize) -> Self {
+            Self {
+                offset: Some(offset),
+                ..self
+            }
+        }
+
         fn writer_props(&self) -> WriterProperties {
             let builder = WriterProperties::builder()
-                .set_data_pagesize_limit(self.max_data_page_size)
+                .set_data_page_size_limit(self.max_data_page_size)
                 .set_write_batch_size(self.write_batch_size)
                 .set_writer_version(self.writer_version)
                 .set_statistics_enabled(self.enabled_statistics);
@@ -972,7 +1596,7 @@ mod tests {
             let builder = match self.encoding {
                 Encoding::RLE_DICTIONARY | Encoding::PLAIN_DICTIONARY => builder
                     .set_dictionary_enabled(true)
-                    .set_dictionary_pagesize_limit(self.max_dict_page_size),
+                    .set_dictionary_page_size_limit(self.max_dict_page_size),
                 _ => builder
                     .set_dictionary_enabled(false)
                     .set_encoding(self.encoding),
@@ -999,7 +1623,7 @@ mod tests {
         G: RandGen<T>,
         F: Fn(&[Option<T::T>]) -> ArrayRef,
     {
-        let mut all_options = vec![
+        let all_options = vec![
             // choose record_batch_batch (15) so batches cross row
             // group boundaries (50 rows in 2 row groups) cases.
             TestOptions::new(2, 100, 15),
@@ -1020,6 +1644,20 @@ mod tests {
             TestOptions::new(2, 256, 127).with_null_percent(0),
             // Test optional with nulls
             TestOptions::new(2, 256, 93).with_null_percent(25),
+            // Test with limit of 0
+            TestOptions::new(4, 100, 25).with_limit(0),
+            // Test with limit of 50
+            TestOptions::new(4, 100, 25).with_limit(50),
+            // Test with limit equal to number of rows
+            TestOptions::new(4, 100, 25).with_limit(10),
+            // Test with limit larger than number of rows
+            TestOptions::new(4, 100, 25).with_limit(101),
+            // Test with limit + offset equal to number of rows
+            TestOptions::new(4, 100, 25).with_offset(30).with_limit(20),
+            // Test with limit + offset equal to number of rows
+            TestOptions::new(4, 100, 25).with_offset(20).with_limit(80),
+            // Test with limit + offset larger than number of rows
+            TestOptions::new(4, 100, 25).with_offset(20).with_limit(81),
             // Test with no page-level statistics
             TestOptions::new(2, 256, 91)
                 .with_null_percent(25)
@@ -1028,9 +1666,12 @@ mod tests {
             TestOptions::new(2, 256, 91)
                 .with_null_percent(25)
                 .with_enabled_statistics(EnabledStatistics::None),
-        ];
+            // Test with all null
+            TestOptions::new(2, 128, 91)
+                .with_null_percent(100)
+                .with_enabled_statistics(EnabledStatistics::None),
+            // Test skip
 
-        let skip_options = vec![
             // choose record_batch_batch (15) so batches cross row
             // group boundaries (50 rows in 2 row groups) cases.
             TestOptions::new(2, 100, 15).with_row_selections(),
@@ -1059,13 +1700,45 @@ mod tests {
             TestOptions::new(2, 256, 93)
                 .with_null_percent(25)
                 .with_row_selections(),
+            // Test optional with nulls
+            TestOptions::new(2, 256, 93)
+                .with_null_percent(25)
+                .with_row_selections()
+                .with_limit(10),
+            // Test optional with nulls
+            TestOptions::new(2, 256, 93)
+                .with_null_percent(25)
+                .with_row_selections()
+                .with_offset(20)
+                .with_limit(10),
+            // Test filter
+
+            // Test with row filter
+            TestOptions::new(4, 100, 25).with_row_filter(),
+            // Test with row selection and row filter
+            TestOptions::new(4, 100, 25)
+                .with_row_selections()
+                .with_row_filter(),
+            // Test with nulls and row filter
+            TestOptions::new(2, 256, 93)
+                .with_null_percent(25)
+                .with_max_data_page_size(10)
+                .with_row_filter(),
+            // Test with nulls and row filter and small pages
+            TestOptions::new(2, 256, 93)
+                .with_null_percent(25)
+                .with_max_data_page_size(10)
+                .with_row_selections()
+                .with_row_filter(),
+            // Test with row selection and no offset index and small pages
+            TestOptions::new(2, 256, 93)
+                .with_enabled_statistics(EnabledStatistics::None)
+                .with_max_data_page_size(10)
+                .with_row_selections(),
         ];
 
-        all_options.extend(skip_options);
-
         all_options.into_iter().for_each(|opts| {
-            for writer_version in [WriterVersion::PARQUET_1_0, WriterVersion::PARQUET_2_0]
-            {
+            for writer_version in [WriterVersion::PARQUET_1_0, WriterVersion::PARQUET_2_0] {
                 for encoding in encodings {
                     let opts = TestOptions {
                         writer_version,
@@ -1141,7 +1814,7 @@ mod tests {
             _ => -1,
         };
 
-        let mut fields = vec![Arc::new(
+        let fields = vec![Arc::new(
             Type::primitive_type_builder("leaf", T::get_physical_type())
                 .with_repetition(repetition)
                 .with_converted_type(converted_type)
@@ -1152,7 +1825,7 @@ mod tests {
 
         let schema = Arc::new(
             Type::group_type_builder("test_schema")
-                .with_fields(&mut fields)
+                .with_fields(fields)
                 .build()
                 .unwrap(),
         );
@@ -1173,35 +1846,81 @@ mod tests {
 
         file.rewind().unwrap();
 
-        let mut arrow_reader;
-        let expected_data: Vec<Option<T::T>>;
-        if let Some((selections, row_count)) = opts.row_selections.clone() {
-            let options =
-                ArrowReaderOptions::new().with_row_selection(selections.clone());
-            arrow_reader =
-                ParquetFileArrowReader::try_new_with_options(file, options).unwrap();
-            let mut without_skip_data = gen_expected_data::<T>(&def_levels, &values);
-
-            let mut skip_data: Vec<Option<T::T>> = vec![];
-            let selections: VecDeque<RowSelector> = selections.into();
-            for select in selections {
-                if select.skip {
-                    without_skip_data.drain(0..select.row_count);
-                } else {
-                    skip_data.extend(without_skip_data.drain(0..select.row_count));
+        let options = ArrowReaderOptions::new()
+            .with_page_index(opts.enabled_statistics == EnabledStatistics::Page);
+
+        let mut builder =
+            ParquetRecordBatchReaderBuilder::try_new_with_options(file, options).unwrap();
+
+        let expected_data = match opts.row_selections {
+            Some((selections, row_count)) => {
+                let mut without_skip_data = gen_expected_data::<T>(def_levels.as_ref(), &values);
+
+                let mut skip_data: Vec<Option<T::T>> = vec![];
+                let dequeue: VecDeque<RowSelector> = selections.clone().into();
+                for select in dequeue {
+                    if select.skip {
+                        without_skip_data.drain(0..select.row_count);
+                    } else {
+                        skip_data.extend(without_skip_data.drain(0..select.row_count));
+                    }
                 }
+                builder = builder.with_row_selection(selections);
+
+                assert_eq!(skip_data.len(), row_count);
+                skip_data
             }
-            expected_data = skip_data;
-            assert_eq!(expected_data.len(), row_count);
-        } else {
-            arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-            //get flatten table data
-            expected_data = gen_expected_data::<T>(&def_levels, &values);
-            assert_eq!(expected_data.len(), opts.num_rows * opts.num_row_groups);
+            None => {
+                //get flatten table data
+                let expected_data = gen_expected_data::<T>(def_levels.as_ref(), &values);
+                assert_eq!(expected_data.len(), opts.num_rows * opts.num_row_groups);
+                expected_data
+            }
+        };
+
+        let mut expected_data = match opts.row_filter {
+            Some(filter) => {
+                let expected_data = expected_data
+                    .into_iter()
+                    .zip(filter.iter())
+                    .filter_map(|(d, f)| f.then(|| d))
+                    .collect();
+
+                let mut filter_offset = 0;
+                let filter = RowFilter::new(vec![Box::new(ArrowPredicateFn::new(
+                    ProjectionMask::all(),
+                    move |b| {
+                        let array = BooleanArray::from_iter(
+                            filter
+                                .iter()
+                                .skip(filter_offset)
+                                .take(b.num_rows())
+                                .map(|x| Some(*x)),
+                        );
+                        filter_offset += b.num_rows();
+                        Ok(array)
+                    },
+                ))]);
+
+                builder = builder.with_row_filter(filter);
+                expected_data
+            }
+            None => expected_data,
+        };
+
+        if let Some(offset) = opts.offset {
+            builder = builder.with_offset(offset);
+            expected_data = expected_data.into_iter().skip(offset).collect();
+        }
+
+        if let Some(limit) = opts.limit {
+            builder = builder.with_limit(limit);
+            expected_data = expected_data.into_iter().take(limit).collect();
         }
 
-        let mut record_reader = arrow_reader
-            .get_record_reader(opts.record_batch_size)
+        let mut record_reader = builder
+            .with_batch_size(opts.record_batch_size)
+            .build()
             .unwrap();
 
         let mut total_read = 0;
@@ -1216,7 +1935,12 @@ mod tests {
                 let b = Arc::clone(batch.column(0));
 
                 assert_eq!(a.data_type(), b.data_type());
-                assert_eq!(a.data(), b.data(), "{:#?} vs {:#?}", a.data(), b.data());
+                assert_eq!(a.to_data(), b.to_data());
+                assert_eq!(
+                    a.as_any().type_id(),
+                    b.as_any().type_id(),
+                    "incorrect type ids"
+                );
 
                 total_read = end;
             } else {
@@ -1227,7 +1951,7 @@ mod tests {
     }
 
     fn gen_expected_data<T: DataType>(
-        def_levels: &Option<Vec<Vec<i16>>>,
+        def_levels: Option<&Vec<Vec<i16>>>,
         values: &[Vec<T::T>],
     ) -> Vec<Option<T::T>> {
         let data: Vec<Option<T::T>> = match def_levels {
@@ -1255,7 +1979,7 @@ mod tests {
         schema: TypePtr,
         field: Option<Field>,
         opts: &TestOptions,
-    ) -> Result<parquet_format::FileMetaData> {
+    ) -> Result<crate::format::FileMetaData> {
         let mut writer_props = opts.writer_props();
         if let Some(field) = field {
             let arrow_schema = Schema::new(vec![field]);
@@ -1284,15 +2008,6 @@ mod tests {
         writer.close()
     }
 
-    fn get_test_reader(file_name: &str) -> Arc<SerializedFileReader<File>> {
-        let file = get_test_file(file_name);
-
-        let reader =
-            SerializedFileReader::new(file).expect("Failed to create serialized reader");
-
-        Arc::new(reader)
-    }
-
     fn get_test_file(file_name: &str) -> File {
         let mut path = PathBuf::new();
         path.push(arrow::util::test_util::arrow_test_data());
@@ -1307,62 +2022,59 @@ mod tests {
         // a column that has the same name as one of the struct fields
         // (see: ARROW-11452)
         let testdata = arrow::util::test_util::parquet_test_data();
-        let path = format!("{}/nested_structs.rust.parquet", testdata);
+        let path = format!("{testdata}/nested_structs.rust.parquet");
         let file = File::open(&path).unwrap();
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-        let record_batch_reader = arrow_reader
-            .get_record_reader(60)
-            .expect("Failed to read into array!");
+        let record_batch_reader = ParquetRecordBatchReader::try_new(file, 60).unwrap();
 
         for batch in record_batch_reader {
             batch.unwrap();
         }
 
-        let mask = ProjectionMask::leaves(arrow_reader.parquet_schema(), [3, 8, 10]);
-        let projected_reader = arrow_reader
-            .get_record_reader_by_columns(mask.clone(), 60)
+        let file = File::open(&path).unwrap();
+        let builder = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+
+        let mask = ProjectionMask::leaves(builder.parquet_schema(), [3, 8, 10]);
+        let projected_reader = builder
+            .with_projection(mask)
+            .with_batch_size(60)
+            .build()
             .unwrap();
-        let projected_schema = arrow_reader.get_schema_by_columns(mask).unwrap();
 
         let expected_schema = Schema::new(vec![
             Field::new(
                 "roll_num",
-                ArrowDataType::Struct(vec![Field::new(
+                ArrowDataType::Struct(Fields::from(vec![Field::new(
                     "count",
                     ArrowDataType::UInt64,
                     false,
-                )]),
+                )])),
                 false,
             ),
             Field::new(
                 "PC_CUR",
-                ArrowDataType::Struct(vec![
+                ArrowDataType::Struct(Fields::from(vec![
                     Field::new("mean", ArrowDataType::Int64, false),
                     Field::new("sum", ArrowDataType::Int64, false),
-                ]),
+                ])),
                 false,
             ),
         ]);
 
         // Tests for #1652 and #1654
-        assert_eq!(projected_reader.schema().as_ref(), &projected_schema);
-        assert_eq!(expected_schema, projected_schema);
+        assert_eq!(&expected_schema, projected_reader.schema().as_ref());
 
         for batch in projected_reader {
             let batch = batch.unwrap();
-            assert_eq!(batch.schema().as_ref(), &projected_schema);
+            assert_eq!(batch.schema().as_ref(), &expected_schema);
         }
     }
 
     #[test]
     fn test_read_maps() {
         let testdata = arrow::util::test_util::parquet_test_data();
-        let path = format!("{}/nested_maps.snappy.parquet", testdata);
-        let file = File::open(&path).unwrap();
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-        let record_batch_reader = arrow_reader
-            .get_record_reader(60)
-            .expect("Failed to read into array!");
+        let path = format!("{testdata}/nested_maps.snappy.parquet");
+        let file = File::open(path).unwrap();
+        let record_batch_reader = ParquetRecordBatchReader::try_new(file, 60).unwrap();
 
         for batch in record_batch_reader {
             batch.unwrap();
@@ -1382,13 +2094,9 @@ mod tests {
 
         {
             // Write using low-level parquet API (#1167)
-            let writer_props = Arc::new(WriterProperties::builder().build());
-            let mut writer = SerializedFileWriter::new(
-                file.try_clone().unwrap(),
-                schema,
-                writer_props,
-            )
-            .unwrap();
+            let mut writer =
+                SerializedFileWriter::new(file.try_clone().unwrap(), schema, Default::default())
+                    .unwrap();
 
             {
                 let mut row_group_writer = writer.next_row_group().unwrap();
@@ -1406,47 +2114,43 @@ mod tests {
             writer.close().unwrap();
         }
 
-        let mut reader = ParquetFileArrowReader::try_new(file).unwrap();
-        let mask = ProjectionMask::leaves(reader.parquet_schema(), [0]);
+        let builder = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+        let mask = ProjectionMask::leaves(builder.parquet_schema(), [0]);
 
-        let reader = reader.get_record_reader_by_columns(mask, 1024).unwrap();
+        let reader = builder.with_projection(mask).build().unwrap();
 
-        let expected_schema = Schema::new(vec![Field::new(
+        let expected_schema = Schema::new(Fields::from(vec![Field::new(
             "group",
-            ArrowDataType::Struct(vec![Field::new("leaf", ArrowDataType::Int32, false)]),
+            ArrowDataType::Struct(vec![Field::new("leaf", ArrowDataType::Int32, false)].into()),
             true,
-        )]);
+        )]));
 
         let batch = reader.into_iter().next().unwrap().unwrap();
         assert_eq!(batch.schema().as_ref(), &expected_schema);
         assert_eq!(batch.num_rows(), 4);
-        assert_eq!(batch.column(0).data().null_count(), 2);
+        assert_eq!(batch.column(0).null_count(), 2);
     }
 
     #[test]
     fn test_invalid_utf8() {
         // a parquet file with 1 column with invalid utf8
         let data = vec![
-            80, 65, 82, 49, 21, 6, 21, 22, 21, 22, 92, 21, 2, 21, 0, 21, 2, 21, 0, 21, 4,
-            21, 0, 18, 28, 54, 0, 40, 5, 104, 101, 255, 108, 111, 24, 5, 104, 101, 255,
-            108, 111, 0, 0, 0, 3, 1, 5, 0, 0, 0, 104, 101, 255, 108, 111, 38, 110, 28,
-            21, 12, 25, 37, 6, 0, 25, 24, 2, 99, 49, 21, 0, 22, 2, 22, 102, 22, 102, 38,
-            8, 60, 54, 0, 40, 5, 104, 101, 255, 108, 111, 24, 5, 104, 101, 255, 108, 111,
-            0, 0, 0, 21, 4, 25, 44, 72, 4, 114, 111, 111, 116, 21, 2, 0, 21, 12, 37, 2,
-            24, 2, 99, 49, 37, 0, 76, 28, 0, 0, 0, 22, 2, 25, 28, 25, 28, 38, 110, 28,
-            21, 12, 25, 37, 6, 0, 25, 24, 2, 99, 49, 21, 0, 22, 2, 22, 102, 22, 102, 38,
-            8, 60, 54, 0, 40, 5, 104, 101, 255, 108, 111, 24, 5, 104, 101, 255, 108, 111,
-            0, 0, 0, 22, 102, 22, 2, 0, 40, 44, 65, 114, 114, 111, 119, 50, 32, 45, 32,
-            78, 97, 116, 105, 118, 101, 32, 82, 117, 115, 116, 32, 105, 109, 112, 108,
-            101, 109, 101, 110, 116, 97, 116, 105, 111, 110, 32, 111, 102, 32, 65, 114,
-            114, 111, 119, 0, 130, 0, 0, 0, 80, 65, 82, 49,
+            80, 65, 82, 49, 21, 6, 21, 22, 21, 22, 92, 21, 2, 21, 0, 21, 2, 21, 0, 21, 4, 21, 0,
+            18, 28, 54, 0, 40, 5, 104, 101, 255, 108, 111, 24, 5, 104, 101, 255, 108, 111, 0, 0, 0,
+            3, 1, 5, 0, 0, 0, 104, 101, 255, 108, 111, 38, 110, 28, 21, 12, 25, 37, 6, 0, 25, 24,
+            2, 99, 49, 21, 0, 22, 2, 22, 102, 22, 102, 38, 8, 60, 54, 0, 40, 5, 104, 101, 255, 108,
+            111, 24, 5, 104, 101, 255, 108, 111, 0, 0, 0, 21, 4, 25, 44, 72, 4, 114, 111, 111, 116,
+            21, 2, 0, 21, 12, 37, 2, 24, 2, 99, 49, 37, 0, 76, 28, 0, 0, 0, 22, 2, 25, 28, 25, 28,
+            38, 110, 28, 21, 12, 25, 37, 6, 0, 25, 24, 2, 99, 49, 21, 0, 22, 2, 22, 102, 22, 102,
+            38, 8, 60, 54, 0, 40, 5, 104, 101, 255, 108, 111, 24, 5, 104, 101, 255, 108, 111, 0, 0,
+            0, 22, 102, 22, 2, 0, 40, 44, 65, 114, 114, 111, 119, 50, 32, 45, 32, 78, 97, 116, 105,
+            118, 101, 32, 82, 117, 115, 116, 32, 105, 109, 112, 108, 101, 109, 101, 110, 116, 97,
+            116, 105, 111, 110, 32, 111, 102, 32, 65, 114, 114, 111, 119, 0, 130, 0, 0, 0, 80, 65,
+            82, 49,
         ];
 
         let file = Bytes::from(data);
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-        let mut record_batch_reader = arrow_reader
-            .get_record_reader_by_columns(ProjectionMask::all(), 10)
-            .unwrap();
+        let mut record_batch_reader = ParquetRecordBatchReader::try_new(file, 10).unwrap();
 
         let error = record_batch_reader.next().unwrap().unwrap_err();
 
@@ -1459,7 +2163,7 @@ mod tests {
 
     #[test]
     fn test_dictionary_preservation() {
-        let mut fields = vec![Arc::new(
+        let fields = vec![Arc::new(
             Type::primitive_type_builder("leaf", PhysicalType::BYTE_ARRAY)
                 .with_repetition(Repetition::OPTIONAL)
                 .with_converted_type(ConvertedType::UTF8)
@@ -1469,7 +2173,7 @@ mod tests {
 
         let schema = Arc::new(
             Type::group_type_builder("test_schema")
-                .with_fields(&mut fields)
+                .with_fields(fields)
                 .build()
                 .unwrap(),
         );
@@ -1519,12 +2223,10 @@ mod tests {
 
         file.rewind().unwrap();
 
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-
-        let record_reader = arrow_reader.get_record_reader(3).unwrap();
+        let record_reader = ParquetRecordBatchReader::try_new(file, 3).unwrap();
 
         let batches = record_reader
-            .collect::<ArrowResult<Vec<RecordBatch>>>()
+            .collect::<Result<Vec<RecordBatch>, _>>()
             .unwrap();
 
         assert_eq!(batches.len(), 6);
@@ -1540,8 +2242,7 @@ mod tests {
             vec![(3, 2), (3, 2), (3, 1), (3, 1), (3, 2), (2, 2)]
         );
 
-        let get_dict =
-            |batch: &RecordBatch| batch.column(0).data().child_data()[0].clone();
+        let get_dict = |batch: &RecordBatch| batch.column(0).to_data().child_data()[0].clone();
 
         // First and second batch in same row group -> same dictionary
         assert_eq!(get_dict(&batches[0]), get_dict(&batches[1]));
@@ -1556,12 +2257,9 @@ mod tests {
     #[test]
     fn test_read_null_list() {
         let testdata = arrow::util::test_util::parquet_test_data();
-        let path = format!("{}/null_list.parquet", testdata);
-        let file = File::open(&path).unwrap();
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-        let mut record_batch_reader = arrow_reader
-            .get_record_reader(60)
-            .expect("Failed to read into array!");
+        let path = format!("{testdata}/null_list.parquet");
+        let file = File::open(path).unwrap();
+        let mut record_batch_reader = ParquetRecordBatchReader::try_new(file, 60).unwrap();
 
         let batch = record_batch_reader.next().unwrap().unwrap();
         assert_eq!(batch.num_rows(), 1);
@@ -1583,19 +2281,18 @@ mod tests {
     #[test]
     fn test_null_schema_inference() {
         let testdata = arrow::util::test_util::parquet_test_data();
-        let path = format!("{}/null_list.parquet", testdata);
-        let reader =
-            Arc::new(SerializedFileReader::try_from(File::open(&path).unwrap()).unwrap());
+        let path = format!("{testdata}/null_list.parquet");
+        let file = File::open(path).unwrap();
 
         let arrow_field = Field::new(
             "emptylist",
-            ArrowDataType::List(Box::new(Field::new("item", ArrowDataType::Null, true))),
+            ArrowDataType::List(Arc::new(Field::new("item", ArrowDataType::Null, true))),
             true,
         );
 
-        let options = ArrowReaderOptions::default().with_skip_arrow_metadata(true);
-        let mut arrow_reader = ParquetFileArrowReader::new_with_options(reader, options);
-        let schema = arrow_reader.get_schema().unwrap();
+        let options = ArrowReaderOptions::new().with_skip_arrow_metadata(true);
+        let builder = ParquetRecordBatchReaderBuilder::try_new_with_options(file, options).unwrap();
+        let schema = builder.schema();
         assert_eq!(schema.fields().len(), 1);
         assert_eq!(schema.field(0), &arrow_field);
     }
@@ -1611,14 +2308,12 @@ mod tests {
             .into_iter()
             .collect();
 
-        let schema_with_metadata =
-            Arc::new(Schema::new(vec![field.with_metadata(Some(metadata))]));
+        let schema_with_metadata = Arc::new(Schema::new(vec![field.with_metadata(metadata)]));
 
         assert_ne!(schema_with_metadata, schema_without_metadata);
 
         let batch =
-            RecordBatch::try_new(schema_with_metadata.clone(), vec![col as ArrayRef])
-                .unwrap();
+            RecordBatch::try_new(schema_with_metadata.clone(), vec![col as ArrayRef]).unwrap();
 
         let file = |version: WriterVersion| {
             let props = WriterProperties::builder()
@@ -1626,66 +2321,57 @@ mod tests {
                 .build();
 
             let file = tempfile().unwrap();
-            let mut writer = ArrowWriter::try_new(
-                file.try_clone().unwrap(),
-                batch.schema(),
-                Some(props),
-            )
-            .unwrap();
+            let mut writer =
+                ArrowWriter::try_new(file.try_clone().unwrap(), batch.schema(), Some(props))
+                    .unwrap();
             writer.write(&batch).unwrap();
             writer.close().unwrap();
             file
         };
 
-        let v1_reader = Arc::new(
-            SerializedFileReader::new(file(WriterVersion::PARQUET_1_0)).unwrap(),
-        );
-        let v2_reader = Arc::new(
-            SerializedFileReader::new(file(WriterVersion::PARQUET_2_0)).unwrap(),
-        );
+        let skip_options = ArrowReaderOptions::new().with_skip_arrow_metadata(true);
 
-        let mut arrow_reader = ParquetFileArrowReader::new(v1_reader.clone());
-        assert_eq!(
-            &arrow_reader.get_schema().unwrap(),
-            schema_with_metadata.as_ref()
-        );
+        let v1_reader = file(WriterVersion::PARQUET_1_0);
+        let v2_reader = file(WriterVersion::PARQUET_2_0);
 
-        let options = ArrowReaderOptions::new().with_skip_arrow_metadata(true);
-        let mut arrow_reader =
-            ParquetFileArrowReader::new_with_options(v1_reader, options);
-        assert_eq!(
-            &arrow_reader.get_schema().unwrap(),
-            schema_without_metadata.as_ref()
-        );
+        let arrow_reader =
+            ParquetRecordBatchReader::try_new(v1_reader.try_clone().unwrap(), 1024).unwrap();
+        assert_eq!(arrow_reader.schema(), schema_with_metadata);
 
-        let mut arrow_reader = ParquetFileArrowReader::new(v2_reader.clone());
-        assert_eq!(
-            &arrow_reader.get_schema().unwrap(),
-            schema_with_metadata.as_ref()
-        );
+        let reader =
+            ParquetRecordBatchReaderBuilder::try_new_with_options(v1_reader, skip_options.clone())
+                .unwrap()
+                .build()
+                .unwrap();
+        assert_eq!(reader.schema(), schema_without_metadata);
 
-        let options = ArrowReaderOptions::new().with_skip_arrow_metadata(true);
-        let mut arrow_reader =
-            ParquetFileArrowReader::new_with_options(v2_reader, options);
-        assert_eq!(
-            &arrow_reader.get_schema().unwrap(),
-            schema_without_metadata.as_ref()
-        );
+        let arrow_reader =
+            ParquetRecordBatchReader::try_new(v2_reader.try_clone().unwrap(), 1024).unwrap();
+        assert_eq!(arrow_reader.schema(), schema_with_metadata);
+
+        let reader = ParquetRecordBatchReaderBuilder::try_new_with_options(v2_reader, skip_options)
+            .unwrap()
+            .build()
+            .unwrap();
+        assert_eq!(reader.schema(), schema_without_metadata);
     }
 
     #[test]
     fn test_empty_projection() {
         let testdata = arrow::util::test_util::parquet_test_data();
-        let path = format!("{}/alltypes_plain.parquet", testdata);
-        let file = File::open(&path).unwrap();
+        let path = format!("{testdata}/alltypes_plain.parquet");
+        let file = File::open(path).unwrap();
 
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-        let file_metadata = arrow_reader.metadata().file_metadata();
+        let builder = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+        let file_metadata = builder.metadata().file_metadata();
         let expected_rows = file_metadata.num_rows() as usize;
-        let schema = file_metadata.schema_descr_ptr();
 
-        let mask = ProjectionMask::leaves(&schema, []);
-        let batch_reader = arrow_reader.get_record_reader_by_columns(mask, 2).unwrap();
+        let mask = ProjectionMask::leaves(builder.parquet_schema(), []);
+        let batch_reader = builder
+            .with_projection(mask)
+            .with_batch_size(2)
+            .build()
+            .unwrap();
 
         let mut total_rows = 0;
         for maybe_batch in batch_reader {
@@ -1701,7 +2387,7 @@ mod tests {
     fn test_row_group_batch(row_group_size: usize, batch_size: usize) {
         let schema = Arc::new(Schema::new(vec![Field::new(
             "list",
-            ArrowDataType::List(Box::new(Field::new("item", ArrowDataType::Int32, true))),
+            ArrowDataType::List(Arc::new(Field::new("item", ArrowDataType::Int32, true))),
             true,
         )]));
 
@@ -1718,21 +2404,18 @@ mod tests {
         )
         .unwrap();
         for _ in 0..2 {
-            let mut list_builder = ListBuilder::new(Int32Builder::new(batch_size));
+            let mut list_builder = ListBuilder::new(Int32Builder::with_capacity(batch_size));
             for _ in 0..(batch_size) {
                 list_builder.append(true);
             }
-            let batch = RecordBatch::try_new(
-                schema.clone(),
-                vec![Arc::new(list_builder.finish())],
-            )
-            .unwrap();
+            let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(list_builder.finish())])
+                .unwrap();
             writer.write(&batch).unwrap();
         }
         writer.close().unwrap();
 
-        let mut file_reader = ParquetFileArrowReader::try_new(Bytes::from(buf)).unwrap();
-        let mut record_reader = file_reader.get_record_reader(batch_size).unwrap();
+        let mut record_reader =
+            ParquetRecordBatchReader::try_new(Bytes::from(buf), batch_size).unwrap();
         assert_eq!(
             batch_size,
             record_reader.next().unwrap().unwrap().num_rows()
@@ -1745,15 +2428,15 @@ mod tests {
 
     #[test]
     fn test_row_group_exact_multiple() {
-        use crate::arrow::record_reader::MIN_BATCH_SIZE;
+        const BATCH_SIZE: usize = REPETITION_LEVELS_BATCH_SIZE;
         test_row_group_batch(8, 8);
         test_row_group_batch(10, 8);
         test_row_group_batch(8, 10);
-        test_row_group_batch(MIN_BATCH_SIZE, MIN_BATCH_SIZE);
-        test_row_group_batch(MIN_BATCH_SIZE + 1, MIN_BATCH_SIZE);
-        test_row_group_batch(MIN_BATCH_SIZE, MIN_BATCH_SIZE + 1);
-        test_row_group_batch(MIN_BATCH_SIZE, MIN_BATCH_SIZE - 1);
-        test_row_group_batch(MIN_BATCH_SIZE - 1, MIN_BATCH_SIZE);
+        test_row_group_batch(BATCH_SIZE, BATCH_SIZE);
+        test_row_group_batch(BATCH_SIZE + 1, BATCH_SIZE);
+        test_row_group_batch(BATCH_SIZE, BATCH_SIZE + 1);
+        test_row_group_batch(BATCH_SIZE, BATCH_SIZE - 1);
+        test_row_group_batch(BATCH_SIZE - 1, BATCH_SIZE);
     }
 
     /// Given a RecordBatch containing all the column data, return the expected batches given
@@ -1788,8 +2471,7 @@ mod tests {
                 match skip {
                     true => {
                         if let Some(last_start) = last_start.take() {
-                            expected_batches
-                                .push(column.slice(last_start, row_offset - last_start))
+                            expected_batches.push(column.slice(last_start, row_offset - last_start))
                         }
                         row_offset += to_read
                     }
@@ -1844,28 +2526,23 @@ mod tests {
     #[test]
     fn test_scan_row_with_selection() {
         let testdata = arrow::util::test_util::parquet_test_data();
-        let path = format!("{}/alltypes_tiny_pages_plain.parquet", testdata);
+        let path = format!("{testdata}/alltypes_tiny_pages_plain.parquet");
         let test_file = File::open(&path).unwrap();
 
-        let mut serial_arrow_reader =
-            ParquetFileArrowReader::try_new(File::open(path).unwrap()).unwrap();
-        let mut serial_reader = serial_arrow_reader.get_record_reader(7300).unwrap();
+        let mut serial_reader =
+            ParquetRecordBatchReader::try_new(File::open(&path).unwrap(), 7300).unwrap();
         let data = serial_reader.next().unwrap().unwrap();
 
         let do_test = |batch_size: usize, selection_len: usize| {
             for skip_first in [false, true] {
-                let selections =
-                    create_test_selection(batch_size, data.num_rows(), skip_first).0;
+                let selections = create_test_selection(batch_size, data.num_rows(), skip_first).0;
 
                 let expected = get_expected_batches(&data, &selections, batch_size);
                 let skip_reader = create_skip_reader(&test_file, batch_size, selections);
                 assert_eq!(
-                    skip_reader.collect::<ArrowResult<Vec<_>>>().unwrap(),
+                    skip_reader.collect::<Result<Vec<_>, _>>().unwrap(),
                     expected,
-                    "batch_size: {}, selection_len: {}, skip_first: {}",
-                    batch_size,
-                    selection_len,
-                    skip_first
+                    "batch_size: {batch_size}, selection_len: {selection_len}, skip_first: {skip_first}"
                 );
             }
         };
@@ -1889,15 +2566,542 @@ mod tests {
             batch_size: usize,
             selections: RowSelection,
         ) -> ParquetRecordBatchReader {
-            let arrow_reader_options =
-                ArrowReaderOptions::new().with_row_selection(selections);
+            let options = ArrowReaderOptions::new().with_page_index(true);
+            let file = test_file.try_clone().unwrap();
+            ParquetRecordBatchReaderBuilder::try_new_with_options(file, options)
+                .unwrap()
+                .with_batch_size(batch_size)
+                .with_row_selection(selections)
+                .build()
+                .unwrap()
+        }
+    }
 
-            let mut skip_arrow_reader = ParquetFileArrowReader::try_new_with_options(
-                test_file.try_clone().unwrap(),
-                arrow_reader_options,
+    #[test]
+    fn test_batch_size_overallocate() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        // `alltypes_plain.parquet` only have 8 rows
+        let path = format!("{testdata}/alltypes_plain.parquet");
+        let test_file = File::open(path).unwrap();
+
+        let builder = ParquetRecordBatchReaderBuilder::try_new(test_file).unwrap();
+        let num_rows = builder.metadata.file_metadata().num_rows();
+        let reader = builder
+            .with_batch_size(1024)
+            .with_projection(ProjectionMask::all())
+            .build()
+            .unwrap();
+        assert_ne!(1024, num_rows);
+        assert_eq!(reader.batch_size, num_rows as usize);
+    }
+
+    #[test]
+    fn test_read_with_page_index_enabled() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+
+        {
+            // `alltypes_tiny_pages.parquet` has page index
+            let path = format!("{testdata}/alltypes_tiny_pages.parquet");
+            let test_file = File::open(path).unwrap();
+            let builder = ParquetRecordBatchReaderBuilder::try_new_with_options(
+                test_file,
+                ArrowReaderOptions::new().with_page_index(true),
+            )
+            .unwrap();
+            assert!(!builder.metadata().offset_index().unwrap()[0].is_empty());
+            let reader = builder.build().unwrap();
+            let batches = reader.collect::<Result<Vec<_>, _>>().unwrap();
+            assert_eq!(batches.len(), 8);
+        }
+
+        {
+            // `alltypes_plain.parquet` doesn't have page index
+            let path = format!("{testdata}/alltypes_plain.parquet");
+            let test_file = File::open(path).unwrap();
+            let builder = ParquetRecordBatchReaderBuilder::try_new_with_options(
+                test_file,
+                ArrowReaderOptions::new().with_page_index(true),
             )
             .unwrap();
-            skip_arrow_reader.get_record_reader(batch_size).unwrap()
+            // Although `Vec<Vec<PageLoacation>>` of each row group is empty,
+            // we should read the file successfully.
+            assert!(builder.metadata().offset_index().unwrap()[0].is_empty());
+            let reader = builder.build().unwrap();
+            let batches = reader.collect::<Result<Vec<_>, _>>().unwrap();
+            assert_eq!(batches.len(), 1);
+        }
+    }
+
+    #[test]
+    fn test_raw_repetition() {
+        const MESSAGE_TYPE: &str = "
+            message Log {
+              OPTIONAL INT32 eventType;
+              REPEATED INT32 category;
+              REPEATED group filter {
+                OPTIONAL INT32 error;
+              }
+            }
+        ";
+        let schema = Arc::new(parse_message_type(MESSAGE_TYPE).unwrap());
+        let props = Default::default();
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = SerializedFileWriter::new(&mut buf, schema, props).unwrap();
+        let mut row_group_writer = writer.next_row_group().unwrap();
+
+        // column 0
+        let mut col_writer = row_group_writer.next_column().unwrap().unwrap();
+        col_writer
+            .typed::<Int32Type>()
+            .write_batch(&[1], Some(&[1]), None)
+            .unwrap();
+        col_writer.close().unwrap();
+        // column 1
+        let mut col_writer = row_group_writer.next_column().unwrap().unwrap();
+        col_writer
+            .typed::<Int32Type>()
+            .write_batch(&[1, 1], Some(&[1, 1]), Some(&[0, 1]))
+            .unwrap();
+        col_writer.close().unwrap();
+        // column 2
+        let mut col_writer = row_group_writer.next_column().unwrap().unwrap();
+        col_writer
+            .typed::<Int32Type>()
+            .write_batch(&[1], Some(&[1]), Some(&[0]))
+            .unwrap();
+        col_writer.close().unwrap();
+
+        let rg_md = row_group_writer.close().unwrap();
+        assert_eq!(rg_md.num_rows(), 1);
+        writer.close().unwrap();
+
+        let bytes = Bytes::from(buf);
+
+        let mut no_mask = ParquetRecordBatchReader::try_new(bytes.clone(), 1024).unwrap();
+        let full = no_mask.next().unwrap().unwrap();
+
+        assert_eq!(full.num_columns(), 3);
+
+        for idx in 0..3 {
+            let b = ParquetRecordBatchReaderBuilder::try_new(bytes.clone()).unwrap();
+            let mask = ProjectionMask::leaves(b.parquet_schema(), [idx]);
+            let mut reader = b.with_projection(mask).build().unwrap();
+            let projected = reader.next().unwrap().unwrap();
+
+            assert_eq!(projected.num_columns(), 1);
+            assert_eq!(full.column(idx), projected.column(0));
+        }
+    }
+
+    #[test]
+    fn test_read_lz4_raw() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/lz4_raw_compressed.parquet");
+        let file = File::open(path).unwrap();
+
+        let batches = ParquetRecordBatchReader::try_new(file, 1024)
+            .unwrap()
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+        assert_eq!(batches.len(), 1);
+        let batch = &batches[0];
+
+        assert_eq!(batch.num_columns(), 3);
+        assert_eq!(batch.num_rows(), 4);
+
+        // https://github.com/apache/parquet-testing/pull/18
+        let a: &Int64Array = batch.column(0).as_any().downcast_ref().unwrap();
+        assert_eq!(
+            a.values(),
+            &[1593604800, 1593604800, 1593604801, 1593604801]
+        );
+
+        let a: &BinaryArray = batch.column(1).as_any().downcast_ref().unwrap();
+        let a: Vec<_> = a.iter().flatten().collect();
+        assert_eq!(a, &[b"abc", b"def", b"abc", b"def"]);
+
+        let a: &Float64Array = batch.column(2).as_any().downcast_ref().unwrap();
+        assert_eq!(a.values(), &[42.000000, 7.700000, 42.125000, 7.700000]);
+    }
+
+    // This test is to ensure backward compatibility, it test 2 files containing the LZ4 CompressionCodec
+    // but different algorithms: LZ4_HADOOP and LZ4_RAW.
+    // 1. hadoop_lz4_compressed.parquet -> It is a file with LZ4 CompressionCodec which uses
+    //    LZ4_HADOOP algorithm for compression.
+    // 2. non_hadoop_lz4_compressed.parquet -> It is a file with LZ4 CompressionCodec which uses
+    //    LZ4_RAW algorithm for compression. This fallback is done to keep backward compatibility with
+    //    older parquet-cpp versions.
+    //
+    // For more information, check: https://github.com/apache/arrow-rs/issues/2988
+    #[test]
+    fn test_read_lz4_hadoop_fallback() {
+        for file in [
+            "hadoop_lz4_compressed.parquet",
+            "non_hadoop_lz4_compressed.parquet",
+        ] {
+            let testdata = arrow::util::test_util::parquet_test_data();
+            let path = format!("{testdata}/{file}");
+            let file = File::open(path).unwrap();
+            let expected_rows = 4;
+
+            let batches = ParquetRecordBatchReader::try_new(file, expected_rows)
+                .unwrap()
+                .collect::<Result<Vec<_>, _>>()
+                .unwrap();
+            assert_eq!(batches.len(), 1);
+            let batch = &batches[0];
+
+            assert_eq!(batch.num_columns(), 3);
+            assert_eq!(batch.num_rows(), expected_rows);
+
+            let a: &Int64Array = batch.column(0).as_any().downcast_ref().unwrap();
+            assert_eq!(
+                a.values(),
+                &[1593604800, 1593604800, 1593604801, 1593604801]
+            );
+
+            let b: &BinaryArray = batch.column(1).as_any().downcast_ref().unwrap();
+            let b: Vec<_> = b.iter().flatten().collect();
+            assert_eq!(b, &[b"abc", b"def", b"abc", b"def"]);
+
+            let c: &Float64Array = batch.column(2).as_any().downcast_ref().unwrap();
+            assert_eq!(c.values(), &[42.0, 7.7, 42.125, 7.7]);
+        }
+    }
+
+    #[test]
+    fn test_read_lz4_hadoop_large() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/hadoop_lz4_compressed_larger.parquet");
+        let file = File::open(path).unwrap();
+        let expected_rows = 10000;
+
+        let batches = ParquetRecordBatchReader::try_new(file, expected_rows)
+            .unwrap()
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+        assert_eq!(batches.len(), 1);
+        let batch = &batches[0];
+
+        assert_eq!(batch.num_columns(), 1);
+        assert_eq!(batch.num_rows(), expected_rows);
+
+        let a: &StringArray = batch.column(0).as_any().downcast_ref().unwrap();
+        let a: Vec<_> = a.iter().flatten().collect();
+        assert_eq!(a[0], "c7ce6bef-d5b0-4863-b199-8ea8c7fb117b");
+        assert_eq!(a[1], "e8fb9197-cb9f-4118-b67f-fbfa65f61843");
+        assert_eq!(a[expected_rows - 2], "ab52a0cc-c6bb-4d61-8a8f-166dc4b8b13c");
+        assert_eq!(a[expected_rows - 1], "85440778-460a-41ac-aa2e-ac3ee41696bf");
+    }
+
+    #[test]
+    #[cfg(feature = "snap")]
+    fn test_read_nested_lists() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/nested_lists.snappy.parquet");
+        let file = File::open(path).unwrap();
+
+        let f = file.try_clone().unwrap();
+        let mut reader = ParquetRecordBatchReader::try_new(f, 60).unwrap();
+        let expected = reader.next().unwrap().unwrap();
+        assert_eq!(expected.num_rows(), 3);
+
+        let selection = RowSelection::from(vec![
+            RowSelector::skip(1),
+            RowSelector::select(1),
+            RowSelector::skip(1),
+        ]);
+        let mut reader = ParquetRecordBatchReaderBuilder::try_new(file)
+            .unwrap()
+            .with_row_selection(selection)
+            .build()
+            .unwrap();
+
+        let actual = reader.next().unwrap().unwrap();
+        assert_eq!(actual.num_rows(), 1);
+        assert_eq!(actual.column(0), &expected.column(0).slice(1, 1));
+    }
+
+    #[test]
+    fn test_arbitrary_decimal() {
+        let values = [1, 2, 3, 4, 5, 6, 7, 8];
+        let decimals_19_0 = Decimal128Array::from_iter_values(values)
+            .with_precision_and_scale(19, 0)
+            .unwrap();
+        let decimals_12_0 = Decimal128Array::from_iter_values(values)
+            .with_precision_and_scale(12, 0)
+            .unwrap();
+        let decimals_17_10 = Decimal128Array::from_iter_values(values)
+            .with_precision_and_scale(17, 10)
+            .unwrap();
+
+        let written = RecordBatch::try_from_iter([
+            ("decimal_values_19_0", Arc::new(decimals_19_0) as ArrayRef),
+            ("decimal_values_12_0", Arc::new(decimals_12_0) as ArrayRef),
+            ("decimal_values_17_10", Arc::new(decimals_17_10) as ArrayRef),
+        ])
+        .unwrap();
+
+        let mut buffer = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buffer, written.schema(), None).unwrap();
+        writer.write(&written).unwrap();
+        writer.close().unwrap();
+
+        let read = ParquetRecordBatchReader::try_new(Bytes::from(buffer), 8)
+            .unwrap()
+            .collect::<Result<Vec<_>, _>>()
+            .unwrap();
+
+        assert_eq!(&written.slice(0, 8), &read[0]);
+    }
+
+    #[test]
+    fn test_list_skip() {
+        let mut list = ListBuilder::new(Int32Builder::new());
+        list.append_value([Some(1), Some(2)]);
+        list.append_value([Some(3)]);
+        list.append_value([Some(4)]);
+        let list = list.finish();
+        let batch = RecordBatch::try_from_iter([("l", Arc::new(list) as _)]).unwrap();
+
+        // First page contains 2 values but only 1 row
+        let props = WriterProperties::builder()
+            .set_data_page_row_count_limit(1)
+            .set_write_batch_size(2)
+            .build();
+
+        let mut buffer = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buffer, batch.schema(), Some(props)).unwrap();
+        writer.write(&batch).unwrap();
+        writer.close().unwrap();
+
+        let selection = vec![RowSelector::skip(2), RowSelector::select(1)];
+        let mut reader = ParquetRecordBatchReaderBuilder::try_new(Bytes::from(buffer))
+            .unwrap()
+            .with_row_selection(selection.into())
+            .build()
+            .unwrap();
+        let out = reader.next().unwrap().unwrap();
+        assert_eq!(out.num_rows(), 1);
+        assert_eq!(out, batch.slice(2, 1));
+    }
+
+    fn test_decimal_roundtrip<T: DecimalType>() {
+        // Precision <= 9 -> INT32
+        // Precision <= 18 -> INT64
+        // Precision > 18 -> FIXED_LEN_BYTE_ARRAY
+
+        let d = |values: Vec<usize>, p: u8| {
+            let iter = values.into_iter().map(T::Native::usize_as);
+            PrimitiveArray::<T>::from_iter_values(iter)
+                .with_precision_and_scale(p, 2)
+                .unwrap()
+        };
+
+        let d1 = d(vec![1, 2, 3, 4, 5], 9);
+        let d2 = d(vec![1, 2, 3, 4, 10.pow(10) - 1], 10);
+        let d3 = d(vec![1, 2, 3, 4, 10.pow(18) - 1], 18);
+        let d4 = d(vec![1, 2, 3, 4, 10.pow(19) - 1], 19);
+
+        let batch = RecordBatch::try_from_iter([
+            ("d1", Arc::new(d1) as ArrayRef),
+            ("d2", Arc::new(d2) as ArrayRef),
+            ("d3", Arc::new(d3) as ArrayRef),
+            ("d4", Arc::new(d4) as ArrayRef),
+        ])
+        .unwrap();
+
+        let mut buffer = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buffer, batch.schema(), None).unwrap();
+        writer.write(&batch).unwrap();
+        writer.close().unwrap();
+
+        let builder = ParquetRecordBatchReaderBuilder::try_new(Bytes::from(buffer)).unwrap();
+        let t1 = builder.parquet_schema().columns()[0].physical_type();
+        assert_eq!(t1, PhysicalType::INT32);
+        let t2 = builder.parquet_schema().columns()[1].physical_type();
+        assert_eq!(t2, PhysicalType::INT64);
+        let t3 = builder.parquet_schema().columns()[2].physical_type();
+        assert_eq!(t3, PhysicalType::INT64);
+        let t4 = builder.parquet_schema().columns()[3].physical_type();
+        assert_eq!(t4, PhysicalType::FIXED_LEN_BYTE_ARRAY);
+
+        let mut reader = builder.build().unwrap();
+        assert_eq!(batch.schema(), reader.schema());
+
+        let out = reader.next().unwrap().unwrap();
+        assert_eq!(batch, out);
+    }
+
+    #[test]
+    fn test_decimal() {
+        test_decimal_roundtrip::<Decimal128Type>();
+        test_decimal_roundtrip::<Decimal256Type>();
+    }
+
+    #[test]
+    fn test_list_selection() {
+        let schema = Arc::new(Schema::new(vec![Field::new_list(
+            "list",
+            Field::new("item", ArrowDataType::Utf8, true),
+            false,
+        )]));
+        let mut buf = Vec::with_capacity(1024);
+
+        let mut writer = ArrowWriter::try_new(&mut buf, schema.clone(), None).unwrap();
+
+        for i in 0..2 {
+            let mut list_a_builder = ListBuilder::new(StringBuilder::new());
+            for j in 0..1024 {
+                list_a_builder.values().append_value(format!("{i} {j}"));
+                list_a_builder.append(true);
+            }
+            let batch =
+                RecordBatch::try_new(schema.clone(), vec![Arc::new(list_a_builder.finish())])
+                    .unwrap();
+            writer.write(&batch).unwrap();
+        }
+        let _metadata = writer.close().unwrap();
+
+        let buf = Bytes::from(buf);
+        let reader = ParquetRecordBatchReaderBuilder::try_new(buf)
+            .unwrap()
+            .with_row_selection(RowSelection::from(vec![
+                RowSelector::skip(100),
+                RowSelector::select(924),
+                RowSelector::skip(100),
+                RowSelector::select(924),
+            ]))
+            .build()
+            .unwrap();
+
+        let batches = reader.collect::<Result<Vec<_>, _>>().unwrap();
+        let batch = concat_batches(&schema, &batches).unwrap();
+
+        assert_eq!(batch.num_rows(), 924 * 2);
+        let list = batch.column(0).as_list::<i32>();
+
+        for w in list.value_offsets().windows(2) {
+            assert_eq!(w[0] + 1, w[1])
+        }
+        let mut values = list.values().as_string::<i32>().iter();
+
+        for i in 0..2 {
+            for j in 100..1024 {
+                let expected = format!("{i} {j}");
+                assert_eq!(values.next().unwrap().unwrap(), &expected);
+            }
+        }
+    }
+
+    #[test]
+    fn test_list_selection_fuzz() {
+        let mut rng = thread_rng();
+        let schema = Arc::new(Schema::new(vec![Field::new_list(
+            "list",
+            Field::new_list("item", Field::new("item", ArrowDataType::Int32, true), true),
+            true,
+        )]));
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buf, schema.clone(), None).unwrap();
+
+        let mut list_a_builder = ListBuilder::new(ListBuilder::new(Int32Builder::new()));
+
+        for _ in 0..2048 {
+            if rng.gen_bool(0.2) {
+                list_a_builder.append(false);
+                continue;
+            }
+
+            let list_a_len = rng.gen_range(0..10);
+            let list_b_builder = list_a_builder.values();
+
+            for _ in 0..list_a_len {
+                if rng.gen_bool(0.2) {
+                    list_b_builder.append(false);
+                    continue;
+                }
+
+                let list_b_len = rng.gen_range(0..10);
+                let int_builder = list_b_builder.values();
+                for _ in 0..list_b_len {
+                    match rng.gen_bool(0.2) {
+                        true => int_builder.append_null(),
+                        false => int_builder.append_value(rng.gen()),
+                    }
+                }
+                list_b_builder.append(true)
+            }
+            list_a_builder.append(true);
+        }
+
+        let array = Arc::new(list_a_builder.finish());
+        let batch = RecordBatch::try_new(schema, vec![array]).unwrap();
+
+        writer.write(&batch).unwrap();
+        let _metadata = writer.close().unwrap();
+
+        let buf = Bytes::from(buf);
+
+        let cases = [
+            vec![
+                RowSelector::skip(100),
+                RowSelector::select(924),
+                RowSelector::skip(100),
+                RowSelector::select(924),
+            ],
+            vec![
+                RowSelector::select(924),
+                RowSelector::skip(100),
+                RowSelector::select(924),
+                RowSelector::skip(100),
+            ],
+            vec![
+                RowSelector::skip(1023),
+                RowSelector::select(1),
+                RowSelector::skip(1023),
+                RowSelector::select(1),
+            ],
+            vec![
+                RowSelector::select(1),
+                RowSelector::skip(1023),
+                RowSelector::select(1),
+                RowSelector::skip(1023),
+            ],
+        ];
+
+        for batch_size in [100, 1024, 2048] {
+            for selection in &cases {
+                let selection = RowSelection::from(selection.clone());
+                let reader = ParquetRecordBatchReaderBuilder::try_new(buf.clone())
+                    .unwrap()
+                    .with_row_selection(selection.clone())
+                    .with_batch_size(batch_size)
+                    .build()
+                    .unwrap();
+
+                let batches = reader.collect::<Result<Vec<_>, _>>().unwrap();
+                let actual = concat_batches(&batch.schema(), &batches).unwrap();
+                assert_eq!(actual.num_rows(), selection.row_count());
+
+                let mut batch_offset = 0;
+                let mut actual_offset = 0;
+                for selector in selection.iter() {
+                    if selector.skip {
+                        batch_offset += selector.row_count;
+                        continue;
+                    }
+
+                    assert_eq!(
+                        batch.slice(batch_offset, selector.row_count),
+                        actual.slice(actual_offset, selector.row_count)
+                    );
+
+                    batch_offset += selector.row_count;
+                    actual_offset += selector.row_count;
+                }
+            }
         }
     }
 }
diff --git a/parquet/src/arrow/arrow_reader/selection.rs b/parquet/src/arrow/arrow_reader/selection.rs
index 8e129f5667ec..82f21461290b 100644
--- a/parquet/src/arrow/arrow_reader/selection.rs
+++ b/parquet/src/arrow/arrow_reader/selection.rs
@@ -15,14 +15,15 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::array::{Array, BooleanArray};
-use arrow::compute::SlicesIterator;
+use arrow_array::{Array, BooleanArray};
+use arrow_select::filter::SlicesIterator;
 use std::cmp::Ordering;
 use std::collections::VecDeque;
 use std::ops::Range;
 
-/// [`RowSelector`] represents a range of rows to scan from a parquet file
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+/// [`RowSelection`] is a collection of [`RowSelector`] used to skip rows when
+/// scanning a parquet file
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub struct RowSelector {
     /// The number of rows
     pub row_count: usize,
@@ -58,7 +59,36 @@ impl RowSelector {
 /// A typical use-case would be using the [`PageIndex`] to filter out rows
 /// that don't satisfy a predicate
 ///
-/// [`PageIndex`]: [crate::file::page_index::index::PageIndex]
+/// # Example
+/// ```
+/// use parquet::arrow::arrow_reader::{RowSelection, RowSelector};
+///
+/// let selectors = vec![
+///     RowSelector::skip(5),
+///     RowSelector::select(5),
+///     RowSelector::select(5),
+///     RowSelector::skip(5),
+/// ];
+///
+/// // Creating a selection will combine adjacent selectors
+/// let selection: RowSelection = selectors.into();
+///
+/// let expected = vec![
+///     RowSelector::skip(5),
+///     RowSelector::select(10),
+///     RowSelector::skip(5),
+/// ];
+///
+/// let actual: Vec<RowSelector> = selection.into();
+/// assert_eq!(actual, expected);
+/// ```
+///
+/// A [`RowSelection`] maintains the following invariants:
+///
+/// * It contains no [`RowSelector`] of 0 rows
+/// * Consecutive [`RowSelector`]s alternate skipping or selecting rows
+///
+/// [`PageIndex`]: crate::file::page_index::index::PageIndex
 #[derive(Debug, Clone, Default, Eq, PartialEq)]
 pub struct RowSelection {
     selectors: Vec<RowSelector>,
@@ -78,15 +108,14 @@ impl RowSelection {
             let offset = next_offset;
             next_offset += filter.len();
             assert_eq!(filter.null_count(), 0);
-            SlicesIterator::new(filter)
-                .map(move |(start, end)| start + offset..end + offset)
+            SlicesIterator::new(filter).map(move |(start, end)| start + offset..end + offset)
         });
 
         Self::from_consecutive_ranges(iter, total_rows)
     }
 
     /// Creates a [`RowSelection`] from an iterator of consecutive ranges to keep
-    fn from_consecutive_ranges<I: Iterator<Item = Range<usize>>>(
+    pub(crate) fn from_consecutive_ranges<I: Iterator<Item = Range<usize>>>(
         ranges: I,
         total_rows: usize,
     ) -> Self {
@@ -94,10 +123,13 @@ impl RowSelection {
         let mut last_end = 0;
         for range in ranges {
             let len = range.end - range.start;
+            if len == 0 {
+                continue;
+            }
 
             match range.start.cmp(&last_end) {
                 Ordering::Equal => match selectors.last_mut() {
-                    Some(last) => last.row_count += len,
+                    Some(last) => last.row_count = last.row_count.checked_add(len).unwrap(),
                     None => selectors.push(RowSelector::select(len)),
                 },
                 Ordering::Greater => {
@@ -116,18 +148,74 @@ impl RowSelection {
         Self { selectors }
     }
 
+    /// Given an offset index, return the byte ranges for all data pages selected by `self`
+    ///
+    /// This is useful for determining what byte ranges to fetch from underlying storage
+    ///
+    /// Note: this method does not make any effort to combine consecutive ranges, nor coalesce
+    /// ranges that are close together. This is instead delegated to the IO subsystem to optimise,
+    /// e.g. [`ObjectStore::get_ranges`](object_store::ObjectStore::get_ranges)
+    pub fn scan_ranges(&self, page_locations: &[crate::format::PageLocation]) -> Vec<Range<usize>> {
+        let mut ranges = vec![];
+        let mut row_offset = 0;
+
+        let mut pages = page_locations.iter().peekable();
+        let mut selectors = self.selectors.iter().cloned();
+        let mut current_selector = selectors.next();
+        let mut current_page = pages.next();
+
+        let mut current_page_included = false;
+
+        while let Some((selector, page)) = current_selector.as_mut().zip(current_page) {
+            if !(selector.skip || current_page_included) {
+                let start = page.offset as usize;
+                let end = start + page.compressed_page_size as usize;
+                ranges.push(start..end);
+                current_page_included = true;
+            }
+
+            if let Some(next_page) = pages.peek() {
+                if row_offset + selector.row_count > next_page.first_row_index as usize {
+                    let remaining_in_page = next_page.first_row_index as usize - row_offset;
+                    selector.row_count -= remaining_in_page;
+                    row_offset += remaining_in_page;
+                    current_page = pages.next();
+                    current_page_included = false;
+
+                    continue;
+                } else {
+                    if row_offset + selector.row_count == next_page.first_row_index as usize {
+                        current_page = pages.next();
+                        current_page_included = false;
+                    }
+                    row_offset += selector.row_count;
+                    current_selector = selectors.next();
+                }
+            } else {
+                if !(selector.skip || current_page_included) {
+                    let start = page.offset as usize;
+                    let end = start + page.compressed_page_size as usize;
+                    ranges.push(start..end);
+                }
+                current_selector = selectors.next()
+            }
+        }
+
+        ranges
+    }
+
     /// Splits off the first `row_count` from this [`RowSelection`]
     pub fn split_off(&mut self, row_count: usize) -> Self {
         let mut total_count = 0;
 
         // Find the index where the selector exceeds the row count
-        let find = self.selectors.iter().enumerate().find(|(_, selector)| {
+        let find = self.selectors.iter().position(|selector| {
             total_count += selector.row_count;
             total_count > row_count
         });
 
         let split_idx = match find {
-            Some((idx, _)) => idx,
+            Some(idx) => idx,
             None => {
                 let selectors = std::mem::take(&mut self.selectors);
                 return Self { selectors };
@@ -153,17 +241,27 @@ impl RowSelection {
             selectors: remaining,
         }
     }
-
-    /// Given a [`RowSelection`] computed under `self`, returns the [`RowSelection`]
-    /// representing their conjunction
+    /// returns a [`RowSelection`] representing rows that are selected in both
+    /// input [`RowSelection`]s.
     ///
-    /// For example:
+    /// This is equivalent to the logical `AND` / conjunction of the two
+    /// selections.
+    ///
+    /// # Example
+    /// If `N` means the row is not selected, and `Y` means it is
+    /// selected:
     ///
+    /// ```text
     /// self:     NNNNNNNNNNNNYYYYYYYYYYYYYYYYYYYYYYNNNYYYYY
     /// other:                YYYYYNNNNYYYYYYYYYYYYY   YYNNN
     ///
-    /// returned: NNNNNNNNNNNNYYYYYNNNNYYYYYYYYYYYYYYNNYNNNN
+    /// returned: NNNNNNNNNNNNYYYYYNNNNYYYYYYYYYYYYYNNNYYNNN
+    /// ```
     ///
+    /// # Panics
+    ///
+    /// Panics if `other` does not have a length equal to the number of rows selected
+    /// by this RowSelection
     ///
     pub fn and_then(&self, other: &Self) -> Self {
         let mut selectors = vec![];
@@ -172,7 +270,9 @@ impl RowSelection {
 
         let mut to_skip = 0;
         while let Some(b) = second.peek_mut() {
-            let a = first.peek_mut().unwrap();
+            let a = first
+                .peek_mut()
+                .expect("selection exceeds the number of selected rows");
 
             if b.row_count == 0 {
                 second.next().unwrap();
@@ -211,7 +311,10 @@ impl RowSelection {
 
         for v in first {
             if v.row_count != 0 {
-                assert!(v.skip);
+                assert!(
+                    v.skip,
+                    "selection contains less than the number of selected rows"
+                );
                 to_skip += v.row_count
             }
         }
@@ -223,27 +326,213 @@ impl RowSelection {
         Self { selectors }
     }
 
+    /// Compute the intersection of two [`RowSelection`]
+    /// For example:
+    /// self:      NNYYYYNNYYNYN
+    /// other:     NYNNNNNNY
+    ///
+    /// returned:  NNNNNNNNYYNYN
+    pub fn intersection(&self, other: &Self) -> Self {
+        intersect_row_selections(&self.selectors, &other.selectors)
+    }
+
     /// Returns `true` if this [`RowSelection`] selects any rows
     pub fn selects_any(&self) -> bool {
         self.selectors.iter().any(|x| !x.skip)
     }
+
+    /// Trims this [`RowSelection`] removing any trailing skips
+    pub(crate) fn trim(mut self) -> Self {
+        while self.selectors.last().map(|x| x.skip).unwrap_or(false) {
+            self.selectors.pop();
+        }
+        self
+    }
+
+    /// Applies an offset to this [`RowSelection`], skipping the first `offset` selected rows
+    pub(crate) fn offset(mut self, offset: usize) -> Self {
+        if offset == 0 {
+            return self;
+        }
+
+        let mut selected_count = 0;
+        let mut skipped_count = 0;
+
+        // Find the index where the selector exceeds the row count
+        let find = self
+            .selectors
+            .iter()
+            .position(|selector| match selector.skip {
+                true => {
+                    skipped_count += selector.row_count;
+                    false
+                }
+                false => {
+                    selected_count += selector.row_count;
+                    selected_count > offset
+                }
+            });
+
+        let split_idx = match find {
+            Some(idx) => idx,
+            None => {
+                self.selectors.clear();
+                return self;
+            }
+        };
+
+        let mut selectors = Vec::with_capacity(self.selectors.len() - split_idx + 1);
+        selectors.push(RowSelector::skip(skipped_count + offset));
+        selectors.push(RowSelector::select(selected_count - offset));
+        selectors.extend_from_slice(&self.selectors[split_idx + 1..]);
+
+        Self { selectors }
+    }
+
+    /// Limit this [`RowSelection`] to only select `limit` rows
+    pub(crate) fn limit(mut self, mut limit: usize) -> Self {
+        if limit == 0 {
+            self.selectors.clear();
+        }
+
+        for (idx, selection) in self.selectors.iter_mut().enumerate() {
+            if !selection.skip {
+                if selection.row_count >= limit {
+                    selection.row_count = limit;
+                    self.selectors.truncate(idx + 1);
+                    break;
+                } else {
+                    limit -= selection.row_count;
+                }
+            }
+        }
+        self
+    }
+
+    /// Returns an iterator over the [`RowSelector`]s for this
+    /// [`RowSelection`].
+    pub fn iter(&self) -> impl Iterator<Item = &RowSelector> {
+        self.selectors.iter()
+    }
+
+    /// Returns the number of selected rows
+    pub fn row_count(&self) -> usize {
+        self.iter().filter(|s| !s.skip).map(|s| s.row_count).sum()
+    }
 }
 
 impl From<Vec<RowSelector>> for RowSelection {
     fn from(selectors: Vec<RowSelector>) -> Self {
+        selectors.into_iter().collect()
+    }
+}
+
+impl FromIterator<RowSelector> for RowSelection {
+    fn from_iter<T: IntoIterator<Item = RowSelector>>(iter: T) -> Self {
+        let iter = iter.into_iter();
+
+        // Capacity before filter
+        let mut selectors = Vec::with_capacity(iter.size_hint().0);
+
+        let mut filtered = iter.filter(|x| x.row_count != 0);
+        if let Some(x) = filtered.next() {
+            selectors.push(x);
+        }
+
+        for s in filtered {
+            if s.row_count == 0 {
+                continue;
+            }
+
+            // Combine consecutive selectors
+            let last = selectors.last_mut().unwrap();
+            if last.skip == s.skip {
+                last.row_count = last.row_count.checked_add(s.row_count).unwrap();
+            } else {
+                selectors.push(s)
+            }
+        }
+
         Self { selectors }
     }
 }
 
+impl From<RowSelection> for Vec<RowSelector> {
+    fn from(r: RowSelection) -> Self {
+        r.selectors
+    }
+}
+
 impl From<RowSelection> for VecDeque<RowSelector> {
     fn from(r: RowSelection) -> Self {
         r.selectors.into()
     }
 }
 
+/// Combine two lists of `RowSelection` return the intersection of them
+/// For example:
+/// self:      NNYYYYNNYYNYN
+/// other:     NYNNNNNNY
+///
+/// returned:  NNNNNNNNYYNYN
+fn intersect_row_selections(left: &[RowSelector], right: &[RowSelector]) -> RowSelection {
+    let mut l_iter = left.iter().copied().peekable();
+    let mut r_iter = right.iter().copied().peekable();
+
+    let iter = std::iter::from_fn(move || {
+        loop {
+            let l = l_iter.peek_mut();
+            let r = r_iter.peek_mut();
+
+            match (l, r) {
+                (Some(a), _) if a.row_count == 0 => {
+                    l_iter.next().unwrap();
+                }
+                (_, Some(b)) if b.row_count == 0 => {
+                    r_iter.next().unwrap();
+                }
+                (Some(l), Some(r)) => {
+                    return match (l.skip, r.skip) {
+                        // Keep both ranges
+                        (false, false) => {
+                            if l.row_count < r.row_count {
+                                r.row_count -= l.row_count;
+                                l_iter.next()
+                            } else {
+                                l.row_count -= r.row_count;
+                                r_iter.next()
+                            }
+                        }
+                        // skip at least one
+                        _ => {
+                            if l.row_count < r.row_count {
+                                let skip = l.row_count;
+                                r.row_count -= l.row_count;
+                                l_iter.next();
+                                Some(RowSelector::skip(skip))
+                            } else {
+                                let skip = r.row_count;
+                                l.row_count -= skip;
+                                r_iter.next();
+                                Some(RowSelector::skip(skip))
+                            }
+                        }
+                    };
+                }
+                (Some(_), None) => return l_iter.next(),
+                (None, Some(_)) => return r_iter.next(),
+                (None, None) => return None,
+            }
+        }
+    });
+
+    iter.collect()
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::format::PageLocation;
     use rand::{thread_rng, Rng};
 
     #[test]
@@ -341,6 +630,64 @@ mod tests {
         assert!(selection.selectors.is_empty());
     }
 
+    #[test]
+    fn test_offset() {
+        let selection = RowSelection::from(vec![
+            RowSelector::select(5),
+            RowSelector::skip(23),
+            RowSelector::select(7),
+            RowSelector::skip(33),
+            RowSelector::select(6),
+        ]);
+
+        let selection = selection.offset(2);
+        assert_eq!(
+            selection.selectors,
+            vec![
+                RowSelector::skip(2),
+                RowSelector::select(3),
+                RowSelector::skip(23),
+                RowSelector::select(7),
+                RowSelector::skip(33),
+                RowSelector::select(6),
+            ]
+        );
+
+        let selection = selection.offset(5);
+        assert_eq!(
+            selection.selectors,
+            vec![
+                RowSelector::skip(30),
+                RowSelector::select(5),
+                RowSelector::skip(33),
+                RowSelector::select(6),
+            ]
+        );
+
+        let selection = selection.offset(3);
+        assert_eq!(
+            selection.selectors,
+            vec![
+                RowSelector::skip(33),
+                RowSelector::select(2),
+                RowSelector::skip(33),
+                RowSelector::select(6),
+            ]
+        );
+
+        let selection = selection.offset(2);
+        assert_eq!(
+            selection.selectors,
+            vec![RowSelector::skip(68), RowSelector::select(6),]
+        );
+
+        let selection = selection.offset(3);
+        assert_eq!(
+            selection.selectors,
+            vec![RowSelector::skip(71), RowSelector::select(3),]
+        );
+    }
+
     #[test]
     fn test_and() {
         let mut a = RowSelection::from(vec![
@@ -393,16 +740,179 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_combine() {
+        let a = vec![
+            RowSelector::skip(3),
+            RowSelector::skip(3),
+            RowSelector::select(10),
+            RowSelector::skip(4),
+        ];
+
+        let b = vec![
+            RowSelector::skip(3),
+            RowSelector::skip(3),
+            RowSelector::select(10),
+            RowSelector::skip(4),
+            RowSelector::skip(0),
+        ];
+
+        let c = vec![
+            RowSelector::skip(2),
+            RowSelector::skip(4),
+            RowSelector::select(3),
+            RowSelector::select(3),
+            RowSelector::select(4),
+            RowSelector::skip(3),
+            RowSelector::skip(1),
+            RowSelector::skip(0),
+        ];
+
+        let expected = RowSelection::from(vec![
+            RowSelector::skip(6),
+            RowSelector::select(10),
+            RowSelector::skip(4),
+        ]);
+
+        assert_eq!(RowSelection::from_iter(a), expected);
+        assert_eq!(RowSelection::from_iter(b), expected);
+        assert_eq!(RowSelection::from_iter(c), expected);
+    }
+
+    #[test]
+    fn test_combine_2elements() {
+        let a = vec![RowSelector::select(10), RowSelector::select(5)];
+        let a_expect = vec![RowSelector::select(15)];
+        assert_eq!(RowSelection::from_iter(a).selectors, a_expect);
+
+        let b = vec![RowSelector::select(10), RowSelector::skip(5)];
+        let b_expect = vec![RowSelector::select(10), RowSelector::skip(5)];
+        assert_eq!(RowSelection::from_iter(b).selectors, b_expect);
+
+        let c = vec![RowSelector::skip(10), RowSelector::select(5)];
+        let c_expect = vec![RowSelector::skip(10), RowSelector::select(5)];
+        assert_eq!(RowSelection::from_iter(c).selectors, c_expect);
+
+        let d = vec![RowSelector::skip(10), RowSelector::skip(5)];
+        let d_expect = vec![RowSelector::skip(15)];
+        assert_eq!(RowSelection::from_iter(d).selectors, d_expect);
+    }
+
+    #[test]
+    fn test_from_one_and_empty() {
+        let a = vec![RowSelector::select(10)];
+        let selection1 = RowSelection::from(a.clone());
+        assert_eq!(selection1.selectors, a);
+
+        let b = vec![];
+        let selection1 = RowSelection::from(b.clone());
+        assert_eq!(selection1.selectors, b)
+    }
+
+    #[test]
+    #[should_panic(expected = "selection exceeds the number of selected rows")]
+    fn test_and_longer() {
+        let a = RowSelection::from(vec![
+            RowSelector::select(3),
+            RowSelector::skip(33),
+            RowSelector::select(3),
+            RowSelector::skip(33),
+        ]);
+        let b = RowSelection::from(vec![RowSelector::select(36)]);
+        a.and_then(&b);
+    }
+
+    #[test]
+    #[should_panic(expected = "selection contains less than the number of selected rows")]
+    fn test_and_shorter() {
+        let a = RowSelection::from(vec![
+            RowSelector::select(3),
+            RowSelector::skip(33),
+            RowSelector::select(3),
+            RowSelector::skip(33),
+        ]);
+        let b = RowSelection::from(vec![RowSelector::select(3)]);
+        a.and_then(&b);
+    }
+
+    #[test]
+    fn test_intersect_row_selection_and_combine() {
+        // a size equal b size
+        let a = vec![
+            RowSelector::select(5),
+            RowSelector::skip(4),
+            RowSelector::select(1),
+        ];
+        let b = vec![
+            RowSelector::select(8),
+            RowSelector::skip(1),
+            RowSelector::select(1),
+        ];
+
+        let res = intersect_row_selections(&a, &b);
+        assert_eq!(
+            res.selectors,
+            vec![
+                RowSelector::select(5),
+                RowSelector::skip(4),
+                RowSelector::select(1),
+            ],
+        );
+
+        // a size larger than b size
+        let a = vec![
+            RowSelector::select(3),
+            RowSelector::skip(33),
+            RowSelector::select(3),
+            RowSelector::skip(33),
+        ];
+        let b = vec![RowSelector::select(36), RowSelector::skip(36)];
+        let res = intersect_row_selections(&a, &b);
+        assert_eq!(
+            res.selectors,
+            vec![RowSelector::select(3), RowSelector::skip(69)]
+        );
+
+        // a size less than b size
+        let a = vec![RowSelector::select(3), RowSelector::skip(7)];
+        let b = vec![
+            RowSelector::select(2),
+            RowSelector::skip(2),
+            RowSelector::select(2),
+            RowSelector::skip(2),
+            RowSelector::select(2),
+        ];
+        let res = intersect_row_selections(&a, &b);
+        assert_eq!(
+            res.selectors,
+            vec![RowSelector::select(2), RowSelector::skip(8)]
+        );
+
+        let a = vec![RowSelector::select(3), RowSelector::skip(7)];
+        let b = vec![
+            RowSelector::select(2),
+            RowSelector::skip(2),
+            RowSelector::select(2),
+            RowSelector::skip(2),
+            RowSelector::select(2),
+        ];
+        let res = intersect_row_selections(&a, &b);
+        assert_eq!(
+            res.selectors,
+            vec![RowSelector::select(2), RowSelector::skip(8)]
+        );
+    }
+
     #[test]
     fn test_and_fuzz() {
         let mut rand = thread_rng();
         for _ in 0..100 {
             let a_len = rand.gen_range(10..100);
-            let a_bools: Vec<_> = (0..a_len).map(|x| rand.gen_bool(0.2)).collect();
+            let a_bools: Vec<_> = (0..a_len).map(|_| rand.gen_bool(0.2)).collect();
             let a = RowSelection::from_filters(&[BooleanArray::from(a_bools.clone())]);
 
             let b_len: usize = a_bools.iter().map(|x| *x as usize).sum();
-            let b_bools: Vec<_> = (0..b_len).map(|x| rand.gen_bool(0.8)).collect();
+            let b_bools: Vec<_> = (0..b_len).map(|_| rand.gen_bool(0.8)).collect();
             let b = RowSelection::from_filters(&[BooleanArray::from(b_bools.clone())]);
 
             let mut expected_bools = vec![false; a_len];
@@ -414,8 +924,7 @@ mod tests {
                 }
             }
 
-            let expected =
-                RowSelection::from_filters(&[BooleanArray::from(expected_bools)]);
+            let expected = RowSelection::from_filters(&[BooleanArray::from(expected_bools)]);
 
             let total_rows: usize = expected.selectors.iter().map(|s| s.row_count).sum();
             assert_eq!(a_len, total_rows);
@@ -423,4 +932,272 @@ mod tests {
             assert_eq!(a.and_then(&b), expected);
         }
     }
+
+    #[test]
+    fn test_iter() {
+        // use the iter() API to show it does what is expected and
+        // avoid accidental deletion
+        let selectors = vec![
+            RowSelector::select(3),
+            RowSelector::skip(33),
+            RowSelector::select(4),
+        ];
+
+        let round_tripped = RowSelection::from(selectors.clone())
+            .iter()
+            .cloned()
+            .collect::<Vec<_>>();
+        assert_eq!(selectors, round_tripped);
+    }
+
+    #[test]
+    fn test_limit() {
+        // Limit to existing limit should no-op
+        let selection = RowSelection::from(vec![RowSelector::select(10), RowSelector::skip(90)]);
+        let limited = selection.limit(10);
+        assert_eq!(RowSelection::from(vec![RowSelector::select(10)]), limited);
+
+        let selection = RowSelection::from(vec![
+            RowSelector::select(10),
+            RowSelector::skip(10),
+            RowSelector::select(10),
+            RowSelector::skip(10),
+            RowSelector::select(10),
+        ]);
+
+        let limited = selection.clone().limit(5);
+        let expected = vec![RowSelector::select(5)];
+        assert_eq!(limited.selectors, expected);
+
+        let limited = selection.clone().limit(15);
+        let expected = vec![
+            RowSelector::select(10),
+            RowSelector::skip(10),
+            RowSelector::select(5),
+        ];
+        assert_eq!(limited.selectors, expected);
+
+        let limited = selection.clone().limit(0);
+        let expected = vec![];
+        assert_eq!(limited.selectors, expected);
+
+        let limited = selection.clone().limit(30);
+        let expected = vec![
+            RowSelector::select(10),
+            RowSelector::skip(10),
+            RowSelector::select(10),
+            RowSelector::skip(10),
+            RowSelector::select(10),
+        ];
+        assert_eq!(limited.selectors, expected);
+
+        let limited = selection.limit(100);
+        let expected = vec![
+            RowSelector::select(10),
+            RowSelector::skip(10),
+            RowSelector::select(10),
+            RowSelector::skip(10),
+            RowSelector::select(10),
+        ];
+        assert_eq!(limited.selectors, expected);
+    }
+
+    #[test]
+    fn test_scan_ranges() {
+        let index = vec![
+            PageLocation {
+                offset: 0,
+                compressed_page_size: 10,
+                first_row_index: 0,
+            },
+            PageLocation {
+                offset: 10,
+                compressed_page_size: 10,
+                first_row_index: 10,
+            },
+            PageLocation {
+                offset: 20,
+                compressed_page_size: 10,
+                first_row_index: 20,
+            },
+            PageLocation {
+                offset: 30,
+                compressed_page_size: 10,
+                first_row_index: 30,
+            },
+            PageLocation {
+                offset: 40,
+                compressed_page_size: 10,
+                first_row_index: 40,
+            },
+            PageLocation {
+                offset: 50,
+                compressed_page_size: 10,
+                first_row_index: 50,
+            },
+            PageLocation {
+                offset: 60,
+                compressed_page_size: 10,
+                first_row_index: 60,
+            },
+        ];
+
+        let selection = RowSelection::from(vec![
+            // Skip first page
+            RowSelector::skip(10),
+            // Multiple selects in same page
+            RowSelector::select(3),
+            RowSelector::skip(3),
+            RowSelector::select(4),
+            // Select to page boundary
+            RowSelector::skip(5),
+            RowSelector::select(5),
+            // Skip full page past page boundary
+            RowSelector::skip(12),
+            // Select across page boundaries
+            RowSelector::select(12),
+            // Skip final page
+            RowSelector::skip(12),
+        ]);
+
+        let ranges = selection.scan_ranges(&index);
+
+        // assert_eq!(mask, vec![false, true, true, false, true, true, false]);
+        assert_eq!(ranges, vec![10..20, 20..30, 40..50, 50..60]);
+
+        let selection = RowSelection::from(vec![
+            // Skip first page
+            RowSelector::skip(10),
+            // Multiple selects in same page
+            RowSelector::select(3),
+            RowSelector::skip(3),
+            RowSelector::select(4),
+            // Select to page boundary
+            RowSelector::skip(5),
+            RowSelector::select(5),
+            // Skip full page past page boundary
+            RowSelector::skip(12),
+            // Select across page boundaries
+            RowSelector::select(12),
+            RowSelector::skip(1),
+            // Select across page boundaries including final page
+            RowSelector::select(8),
+        ]);
+
+        let ranges = selection.scan_ranges(&index);
+
+        // assert_eq!(mask, vec![false, true, true, false, true, true, true]);
+        assert_eq!(ranges, vec![10..20, 20..30, 40..50, 50..60, 60..70]);
+
+        let selection = RowSelection::from(vec![
+            // Skip first page
+            RowSelector::skip(10),
+            // Multiple selects in same page
+            RowSelector::select(3),
+            RowSelector::skip(3),
+            RowSelector::select(4),
+            // Select to page boundary
+            RowSelector::skip(5),
+            RowSelector::select(5),
+            // Skip full page past page boundary
+            RowSelector::skip(12),
+            // Select to final page boundary
+            RowSelector::select(12),
+            RowSelector::skip(1),
+            // Skip across final page boundary
+            RowSelector::skip(8),
+            // Select from final page
+            RowSelector::select(4),
+        ]);
+
+        let ranges = selection.scan_ranges(&index);
+
+        // assert_eq!(mask, vec![false, true, true, false, true, true, true]);
+        assert_eq!(ranges, vec![10..20, 20..30, 40..50, 50..60, 60..70]);
+
+        let selection = RowSelection::from(vec![
+            // Skip first page
+            RowSelector::skip(10),
+            // Multiple selects in same page
+            RowSelector::select(3),
+            RowSelector::skip(3),
+            RowSelector::select(4),
+            // Select to remaining in page and first row of next page
+            RowSelector::skip(5),
+            RowSelector::select(6),
+            // Skip remaining
+            RowSelector::skip(50),
+        ]);
+
+        let ranges = selection.scan_ranges(&index);
+
+        // assert_eq!(mask, vec![false, true, true, false, true, true, true]);
+        assert_eq!(ranges, vec![10..20, 20..30, 30..40]);
+    }
+
+    #[test]
+    fn test_empty_ranges() {
+        let ranges = [1..3, 4..6, 6..6, 8..8, 9..10];
+        let selection = RowSelection::from_consecutive_ranges(ranges.into_iter(), 10);
+        assert_eq!(
+            selection.selectors,
+            vec![
+                RowSelector::skip(1),
+                RowSelector::select(2),
+                RowSelector::skip(1),
+                RowSelector::select(2),
+                RowSelector::skip(3),
+                RowSelector::select(1)
+            ]
+        )
+    }
+
+    #[test]
+    fn test_empty_selector() {
+        let selection = RowSelection::from(vec![
+            RowSelector::skip(0),
+            RowSelector::select(2),
+            RowSelector::skip(0),
+            RowSelector::select(2),
+        ]);
+        assert_eq!(selection.selectors, vec![RowSelector::select(4)]);
+
+        let selection = RowSelection::from(vec![
+            RowSelector::select(0),
+            RowSelector::skip(2),
+            RowSelector::select(0),
+            RowSelector::skip(2),
+        ]);
+        assert_eq!(selection.selectors, vec![RowSelector::skip(4)]);
+    }
+
+    #[test]
+    fn test_intersection() {
+        let selection = RowSelection::from(vec![RowSelector::select(1048576)]);
+        let result = selection.intersection(&selection);
+        assert_eq!(result, selection);
+
+        let a = RowSelection::from(vec![
+            RowSelector::skip(10),
+            RowSelector::select(10),
+            RowSelector::skip(10),
+            RowSelector::select(20),
+        ]);
+
+        let b = RowSelection::from(vec![
+            RowSelector::skip(20),
+            RowSelector::select(20),
+            RowSelector::skip(10),
+        ]);
+
+        let result = a.intersection(&b);
+        assert_eq!(
+            result.selectors,
+            vec![
+                RowSelector::skip(30),
+                RowSelector::select(10),
+                RowSelector::skip(10)
+            ]
+        );
+    }
 }
diff --git a/parquet/src/arrow/arrow_writer/byte_array.rs b/parquet/src/arrow/arrow_writer/byte_array.rs
index a7b6ccc3fc85..61933b24178e 100644
--- a/parquet/src/arrow/arrow_writer/byte_array.rs
+++ b/parquet/src/arrow/arrow_writer/byte_array.rs
@@ -15,33 +15,28 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::arrow::arrow_writer::levels::LevelInfo;
 use crate::basic::Encoding;
-use crate::column::page::PageWriter;
-use crate::column::writer::encoder::{
-    ColumnValueEncoder, DataPageValues, DictionaryPage,
-};
-use crate::column::writer::GenericColumnWriter;
+use crate::bloom_filter::Sbbf;
+use crate::column::writer::encoder::{ColumnValueEncoder, DataPageValues, DictionaryPage};
 use crate::data_type::{AsBytes, ByteArray, Int32Type};
 use crate::encodings::encoding::{DeltaBitPackEncoder, Encoder};
 use crate::encodings::rle::RleEncoder;
 use crate::errors::{ParquetError, Result};
-use crate::file::properties::{WriterProperties, WriterPropertiesPtr, WriterVersion};
-use crate::file::writer::OnCloseColumnChunk;
+use crate::file::properties::{EnabledStatistics, WriterProperties, WriterVersion};
 use crate::schema::types::ColumnDescPtr;
 use crate::util::bit_util::num_required_bits;
 use crate::util::interner::{Interner, Storage};
-use arrow::array::{
-    Array, ArrayAccessor, ArrayRef, BinaryArray, DictionaryArray, LargeBinaryArray,
-    LargeStringArray, StringArray,
+use arrow_array::{
+    Array, ArrayAccessor, BinaryArray, DictionaryArray, LargeBinaryArray, LargeStringArray,
+    StringArray,
 };
-use arrow::datatypes::DataType;
+use arrow_schema::DataType;
 
 macro_rules! downcast_dict_impl {
     ($array:ident, $key:ident, $val:ident, $op:expr $(, $arg:expr)*) => {{
         $op($array
             .as_any()
-            .downcast_ref::<DictionaryArray<arrow::datatypes::$key>>()
+            .downcast_ref::<DictionaryArray<arrow_array::types::$key>>()
             .unwrap()
             .downcast_dict::<$val>()
             .unwrap()$(, $arg)*)
@@ -93,56 +88,6 @@ macro_rules! downcast_op {
     };
 }
 
-/// A writer for byte array types
-pub(super) struct ByteArrayWriter<'a> {
-    writer: GenericColumnWriter<'a, ByteArrayEncoder>,
-    on_close: Option<OnCloseColumnChunk<'a>>,
-}
-
-impl<'a> ByteArrayWriter<'a> {
-    /// Returns a new [`ByteArrayWriter`]
-    pub fn new(
-        descr: ColumnDescPtr,
-        props: &'a WriterPropertiesPtr,
-        page_writer: Box<dyn PageWriter + 'a>,
-        on_close: OnCloseColumnChunk<'a>,
-    ) -> Result<Self> {
-        Ok(Self {
-            writer: GenericColumnWriter::new(descr, props.clone(), page_writer),
-            on_close: Some(on_close),
-        })
-    }
-
-    pub fn write(&mut self, array: &ArrayRef, levels: LevelInfo) -> Result<()> {
-        self.writer.write_batch_internal(
-            array,
-            Some(levels.non_null_indices()),
-            levels.def_levels(),
-            levels.rep_levels(),
-            None,
-            None,
-            None,
-        )?;
-        Ok(())
-    }
-
-    pub fn close(self) -> Result<()> {
-        let (bytes_written, rows_written, metadata, column_index, offset_index) =
-            self.writer.close()?;
-
-        if let Some(on_close) = self.on_close {
-            on_close(
-                bytes_written,
-                rows_written,
-                metadata,
-                column_index,
-                offset_index,
-            )?;
-        }
-        Ok(())
-    }
-}
-
 /// A fallback encoder, i.e. non-dictionary, for [`ByteArray`]
 struct FallbackEncoder {
     encoder: FallbackEncoderImpl,
@@ -172,12 +117,13 @@ impl FallbackEncoder {
     /// Create the fallback encoder for the given [`ColumnDescPtr`] and [`WriterProperties`]
     fn new(descr: &ColumnDescPtr, props: &WriterProperties) -> Result<Self> {
         // Set either main encoder or fallback encoder.
-        let encoding = props.encoding(descr.path()).unwrap_or_else(|| {
-            match props.writer_version() {
-                WriterVersion::PARQUET_1_0 => Encoding::PLAIN,
-                WriterVersion::PARQUET_2_0 => Encoding::DELTA_BYTE_ARRAY,
-            }
-        });
+        let encoding =
+            props
+                .encoding(descr.path())
+                .unwrap_or_else(|| match props.writer_version() {
+                    WriterVersion::PARQUET_1_0 => Encoding::PLAIN,
+                    WriterVersion::PARQUET_2_0 => Encoding::DELTA_BYTE_ARRAY,
+                });
 
         let encoder = match encoding {
             Encoding::PLAIN => FallbackEncoderImpl::Plain { buffer: vec![] },
@@ -285,32 +231,32 @@ impl FallbackEncoder {
         max_value: Option<ByteArray>,
     ) -> Result<DataPageValues<ByteArray>> {
         let (buf, encoding) = match &mut self.encoder {
-            FallbackEncoderImpl::Plain { buffer } => {
-                (std::mem::take(buffer), Encoding::PLAIN)
-            }
+            FallbackEncoderImpl::Plain { buffer } => (std::mem::take(buffer), Encoding::PLAIN),
             FallbackEncoderImpl::DeltaLength { buffer, lengths } => {
                 let lengths = lengths.flush_buffer()?;
 
                 let mut out = Vec::with_capacity(lengths.len() + buffer.len());
-                out.extend_from_slice(lengths.data());
+                out.extend_from_slice(&lengths);
                 out.extend_from_slice(buffer);
+                buffer.clear();
                 (out, Encoding::DELTA_LENGTH_BYTE_ARRAY)
             }
             FallbackEncoderImpl::Delta {
                 buffer,
                 prefix_lengths,
                 suffix_lengths,
-                ..
+                last_value,
             } => {
                 let prefix_lengths = prefix_lengths.flush_buffer()?;
                 let suffix_lengths = suffix_lengths.flush_buffer()?;
 
-                let mut out = Vec::with_capacity(
-                    prefix_lengths.len() + suffix_lengths.len() + buffer.len(),
-                );
-                out.extend_from_slice(prefix_lengths.data());
-                out.extend_from_slice(suffix_lengths.data());
+                let mut out =
+                    Vec::with_capacity(prefix_lengths.len() + suffix_lengths.len() + buffer.len());
+                out.extend_from_slice(&prefix_lengths);
+                out.extend_from_slice(&suffix_lengths);
                 out.extend_from_slice(buffer);
+                buffer.clear();
+                last_value.clear();
                 (out, Encoding::DELTA_BYTE_ARRAY)
             }
         };
@@ -386,8 +332,7 @@ impl DictEncoder {
 
     fn estimated_data_page_size(&self) -> usize {
         let bit_width = self.bit_width();
-        1 + RleEncoder::min_buffer_size(bit_width)
-            + RleEncoder::max_buffer_size(bit_width, self.indices.len())
+        1 + RleEncoder::max_buffer_size(bit_width, self.indices.len())
     }
 
     fn estimated_dict_page_size(&self) -> usize {
@@ -412,11 +357,11 @@ impl DictEncoder {
         let num_values = self.indices.len();
         let buffer_len = self.estimated_data_page_size();
         let mut buffer = Vec::with_capacity(buffer_len);
-        buffer.push(self.bit_width() as u8);
+        buffer.push(self.bit_width());
 
         let mut encoder = RleEncoder::new_from_buf(self.bit_width(), buffer);
         for index in &self.indices {
-            encoder.put(*index as u64)
+            encoder.put(*index)
         }
 
         self.indices.clear();
@@ -431,33 +376,20 @@ impl DictEncoder {
     }
 }
 
-struct ByteArrayEncoder {
+pub struct ByteArrayEncoder {
     fallback: FallbackEncoder,
     dict_encoder: Option<DictEncoder>,
-    num_values: usize,
+    statistics_enabled: EnabledStatistics,
     min_value: Option<ByteArray>,
     max_value: Option<ByteArray>,
+    bloom_filter: Option<Sbbf>,
 }
 
 impl ColumnValueEncoder for ByteArrayEncoder {
     type T = ByteArray;
-    type Values = ArrayRef;
-
-    fn min_max(
-        &self,
-        values: &ArrayRef,
-        value_indices: Option<&[usize]>,
-    ) -> Option<(Self::T, Self::T)> {
-        match value_indices {
-            Some(indices) => {
-                let iter = indices.iter().cloned();
-                downcast_op!(values.data_type(), values, compute_min_max, iter)
-            }
-            None => {
-                let len = Array::len(values);
-                downcast_op!(values.data_type(), values, compute_min_max, 0..len)
-            }
-        }
+    type Values = dyn Array;
+    fn flush_bloom_filter(&mut self) -> Option<Sbbf> {
+        self.bloom_filter.take()
     }
 
     fn try_new(descr: &ColumnDescPtr, props: &WriterProperties) -> Result<Self>
@@ -470,21 +402,24 @@ impl ColumnValueEncoder for ByteArrayEncoder {
 
         let fallback = FallbackEncoder::new(descr, props)?;
 
+        let bloom_filter = props
+            .bloom_filter_properties(descr.path())
+            .map(|props| Sbbf::new_with_ndv_fpp(props.ndv, props.fpp))
+            .transpose()?;
+
+        let statistics_enabled = props.statistics_enabled(descr.path());
+
         Ok(Self {
             fallback,
+            statistics_enabled,
+            bloom_filter,
             dict_encoder: dictionary,
-            num_values: 0,
             min_value: None,
             max_value: None,
         })
     }
 
-    fn write(
-        &mut self,
-        _values: &Self::Values,
-        _offset: usize,
-        _len: usize,
-    ) -> Result<()> {
+    fn write(&mut self, _values: &Self::Values, _offset: usize, _len: usize) -> Result<()> {
         unreachable!("should call write_gather instead")
     }
 
@@ -494,7 +429,10 @@ impl ColumnValueEncoder for ByteArrayEncoder {
     }
 
     fn num_values(&self) -> usize {
-        self.num_values
+        match &self.dict_encoder {
+            Some(encoder) => encoder.indices.len(),
+            None => self.fallback.num_values,
+        }
     }
 
     fn has_dictionary(&self) -> bool {
@@ -515,7 +453,7 @@ impl ColumnValueEncoder for ByteArrayEncoder {
     fn flush_dict_page(&mut self) -> Result<Option<DictionaryPage>> {
         match self.dict_encoder.take() {
             Some(encoder) => {
-                if self.num_values != 0 {
+                if !encoder.indices.is_empty() {
                     return Err(general_err!(
                         "Must flush data pages before flushing dictionary"
                     ));
@@ -546,13 +484,23 @@ where
     T: ArrayAccessor + Copy,
     T::Item: Copy + Ord + AsRef<[u8]>,
 {
-    if let Some((min, max)) = compute_min_max(values, indices.iter().cloned()) {
-        if encoder.min_value.as_ref().map_or(true, |m| m > &min) {
-            encoder.min_value = Some(min);
+    if encoder.statistics_enabled != EnabledStatistics::None {
+        if let Some((min, max)) = compute_min_max(values, indices.iter().cloned()) {
+            if encoder.min_value.as_ref().map_or(true, |m| m > &min) {
+                encoder.min_value = Some(min);
+            }
+
+            if encoder.max_value.as_ref().map_or(true, |m| m < &max) {
+                encoder.max_value = Some(max);
+            }
         }
+    }
 
-        if encoder.max_value.as_ref().map_or(true, |m| m < &max) {
-            encoder.max_value = Some(max);
+    // encode the values into bloom filter if enabled
+    if let Some(bloom_filter) = &mut encoder.bloom_filter {
+        let valid = indices.iter().cloned();
+        for idx in valid {
+            bloom_filter.insert(values.value(idx).as_ref());
         }
     }
 
diff --git a/parquet/src/arrow/arrow_writer/levels.rs b/parquet/src/arrow/arrow_writer/levels.rs
index 9a90d40d5a85..1f3078224159 100644
--- a/parquet/src/arrow/arrow_writer/levels.rs
+++ b/parquet/src/arrow/arrow_writer/levels.rs
@@ -41,21 +41,18 @@
 //! \[1\] [parquet-format#nested-encoding](https://github.com/apache/parquet-format#nested-encoding)
 
 use crate::errors::{ParquetError, Result};
-use arrow::array::{
-    make_array, Array, ArrayData, ArrayRef, GenericListArray, MapArray, OffsetSizeTrait,
-    StructArray,
-};
-use arrow::datatypes::{DataType, Field};
+use arrow_array::cast::AsArray;
+use arrow_array::{Array, ArrayRef, OffsetSizeTrait};
+use arrow_buffer::{NullBuffer, OffsetBuffer};
+use arrow_schema::{DataType, Field};
 use std::ops::Range;
+use std::sync::Arc;
 
-/// Performs a depth-first scan of the children of `array`, constructing [`LevelInfo`]
+/// Performs a depth-first scan of the children of `array`, constructing [`ArrayLevels`]
 /// for each leaf column encountered
-pub(crate) fn calculate_array_levels(
-    array: &ArrayRef,
-    field: &Field,
-) -> Result<Vec<LevelInfo>> {
-    let mut builder = LevelInfoBuilder::try_new(field, Default::default())?;
-    builder.write(array, 0..array.len());
+pub(crate) fn calculate_array_levels(array: &ArrayRef, field: &Field) -> Result<Vec<ArrayLevels>> {
+    let mut builder = LevelInfoBuilder::try_new(field, Default::default(), array)?;
+    builder.write(0..array.len());
     Ok(builder.finish())
 }
 
@@ -89,6 +86,7 @@ fn is_leaf(data_type: &DataType) -> bool {
             | DataType::Binary
             | DataType::LargeBinary
             | DataType::Decimal128(_, _)
+            | DataType::Decimal256(_, _)
             | DataType::FixedSizeBinary(_)
     )
 }
@@ -102,31 +100,62 @@ struct LevelContext {
     def_level: i16,
 }
 
-/// A helper to construct [`LevelInfo`] from a potentially nested [`Field`]
+/// A helper to construct [`ArrayLevels`] from a potentially nested [`Field`]
+#[derive(Debug)]
 enum LevelInfoBuilder {
     /// A primitive, leaf array
-    Primitive(LevelInfo),
-    /// A list array, contains the [`LevelInfoBuilder`] of the child and
-    /// the [`LevelContext`] of this list
-    List(Box<LevelInfoBuilder>, LevelContext),
-    /// A list array, contains the [`LevelInfoBuilder`] of its children and
-    /// the [`LevelContext`] of this struct array
-    Struct(Vec<LevelInfoBuilder>, LevelContext),
+    Primitive(ArrayLevels),
+    /// A list array
+    List(
+        Box<LevelInfoBuilder>, // Child Values
+        LevelContext,          // Context
+        OffsetBuffer<i32>,     // Offsets
+        Option<NullBuffer>,    // Nulls
+    ),
+    /// A large list array
+    LargeList(
+        Box<LevelInfoBuilder>, // Child Values
+        LevelContext,          // Context
+        OffsetBuffer<i64>,     // Offsets
+        Option<NullBuffer>,    // Nulls
+    ),
+    /// A fixed size list array
+    FixedSizeList(
+        Box<LevelInfoBuilder>, // Values
+        LevelContext,          // Context
+        usize,                 // List Size
+        Option<NullBuffer>,    // Nulls
+    ),
+    /// A struct array
+    Struct(Vec<LevelInfoBuilder>, LevelContext, Option<NullBuffer>),
 }
 
 impl LevelInfoBuilder {
     /// Create a new [`LevelInfoBuilder`] for the given [`Field`] and parent [`LevelContext`]
-    fn try_new(field: &Field, parent_ctx: LevelContext) -> Result<Self> {
-        match field.data_type() {
-            d if is_leaf(d) => Ok(Self::Primitive(LevelInfo::new(
-                parent_ctx,
-                field.is_nullable(),
-            ))),
-            DataType::Dictionary(_, v) if is_leaf(v.as_ref()) => Ok(Self::Primitive(
-                LevelInfo::new(parent_ctx, field.is_nullable()),
-            )),
+    fn try_new(field: &Field, parent_ctx: LevelContext, array: &ArrayRef) -> Result<Self> {
+        if field.data_type() != array.data_type() {
+            return Err(arrow_err!(format!(
+                "Incompatible type. Field '{}' has type {}, array has type {}",
+                field.name(),
+                field.data_type(),
+                array.data_type(),
+            )));
+        }
+
+        let is_nullable = field.is_nullable();
+
+        match array.data_type() {
+            d if is_leaf(d) => {
+                let levels = ArrayLevels::new(parent_ctx, is_nullable, array.clone());
+                Ok(Self::Primitive(levels))
+            }
+            DataType::Dictionary(_, v) if is_leaf(v.as_ref()) => {
+                let levels = ArrayLevels::new(parent_ctx, is_nullable, array.clone());
+                Ok(Self::Primitive(levels))
+            }
             DataType::Struct(children) => {
-                let def_level = match field.is_nullable() {
+                let array = array.as_struct();
+                let def_level = match is_nullable {
                     true => parent_ctx.def_level + 1,
                     false => parent_ctx.def_level,
                 };
@@ -138,15 +167,17 @@ impl LevelInfoBuilder {
 
                 let children = children
                     .iter()
-                    .map(|f| Self::try_new(f, ctx))
+                    .zip(array.columns())
+                    .map(|(f, a)| Self::try_new(f, ctx, a))
                     .collect::<Result<_>>()?;
 
-                Ok(Self::Struct(children, ctx))
+                Ok(Self::Struct(children, ctx, array.nulls().cloned()))
             }
             DataType::List(child)
             | DataType::LargeList(child)
-            | DataType::Map(child, _) => {
-                let def_level = match field.is_nullable() {
+            | DataType::Map(child, _)
+            | DataType::FixedSizeList(child, _) => {
+                let def_level = match is_nullable {
                     true => parent_ctx.def_level + 2,
                     false => parent_ctx.def_level + 1,
                 };
@@ -156,81 +187,86 @@ impl LevelInfoBuilder {
                     def_level,
                 };
 
-                let child = Self::try_new(child.as_ref(), ctx)?;
-                Ok(Self::List(Box::new(child), ctx))
+                Ok(match field.data_type() {
+                    DataType::List(_) => {
+                        let list = array.as_list();
+                        let child = Self::try_new(child.as_ref(), ctx, list.values())?;
+                        let offsets = list.offsets().clone();
+                        Self::List(Box::new(child), ctx, offsets, list.nulls().cloned())
+                    }
+                    DataType::LargeList(_) => {
+                        let list = array.as_list();
+                        let child = Self::try_new(child.as_ref(), ctx, list.values())?;
+                        let offsets = list.offsets().clone();
+                        let nulls = list.nulls().cloned();
+                        Self::LargeList(Box::new(child), ctx, offsets, nulls)
+                    }
+                    DataType::Map(_, _) => {
+                        let map = array.as_map();
+                        let entries = Arc::new(map.entries().clone()) as ArrayRef;
+                        let child = Self::try_new(child.as_ref(), ctx, &entries)?;
+                        let offsets = map.offsets().clone();
+                        Self::List(Box::new(child), ctx, offsets, map.nulls().cloned())
+                    }
+                    DataType::FixedSizeList(_, size) => {
+                        let list = array.as_fixed_size_list();
+                        let child = Self::try_new(child.as_ref(), ctx, list.values())?;
+                        let nulls = list.nulls().cloned();
+                        Self::FixedSizeList(Box::new(child), ctx, *size as _, nulls)
+                    }
+                    _ => unreachable!(),
+                })
             }
             d => Err(nyi_err!("Datatype {} is not yet supported", d)),
         }
     }
 
-    /// Finish this [`LevelInfoBuilder`] returning the [`LevelInfo`] for the leaf columns
+    /// Finish this [`LevelInfoBuilder`] returning the [`ArrayLevels`] for the leaf columns
     /// as enumerated by a depth-first search
-    fn finish(self) -> Vec<LevelInfo> {
+    fn finish(self) -> Vec<ArrayLevels> {
         match self {
             LevelInfoBuilder::Primitive(v) => vec![v],
-            LevelInfoBuilder::List(v, _) => v.finish(),
-            LevelInfoBuilder::Struct(v, _) => {
-                v.into_iter().flat_map(|l| l.finish()).collect()
-            }
+            LevelInfoBuilder::List(v, _, _, _)
+            | LevelInfoBuilder::LargeList(v, _, _, _)
+            | LevelInfoBuilder::FixedSizeList(v, _, _, _) => v.finish(),
+            LevelInfoBuilder::Struct(v, _, _) => v.into_iter().flat_map(|l| l.finish()).collect(),
         }
     }
 
     /// Given an `array`, write the level data for the elements in `range`
-    fn write(&mut self, array: &ArrayRef, range: Range<usize>) {
-        match array.data_type() {
-            d if is_leaf(d) => self.write_leaf(array, range),
-            DataType::Dictionary(_, v) if is_leaf(v.as_ref()) => {
-                self.write_leaf(array, range)
-            }
-            DataType::Struct(_) => {
-                let array = array.as_any().downcast_ref::<StructArray>().unwrap();
-                self.write_struct(array, range)
+    fn write(&mut self, range: Range<usize>) {
+        match self {
+            LevelInfoBuilder::Primitive(info) => Self::write_leaf(info, range),
+            LevelInfoBuilder::List(child, ctx, offsets, nulls) => {
+                Self::write_list(child, ctx, offsets, nulls.as_ref(), range)
             }
-            DataType::List(_) => {
-                let array = array
-                    .as_any()
-                    .downcast_ref::<GenericListArray<i32>>()
-                    .unwrap();
-                self.write_list(array.value_offsets(), array.data(), range)
+            LevelInfoBuilder::LargeList(child, ctx, offsets, nulls) => {
+                Self::write_list(child, ctx, offsets, nulls.as_ref(), range)
             }
-            DataType::LargeList(_) => {
-                let array = array
-                    .as_any()
-                    .downcast_ref::<GenericListArray<i64>>()
-                    .unwrap();
-
-                self.write_list(array.value_offsets(), array.data(), range)
+            LevelInfoBuilder::FixedSizeList(child, ctx, size, nulls) => {
+                Self::write_fixed_size_list(child, ctx, *size, nulls.as_ref(), range)
             }
-            DataType::Map(_, _) => {
-                let array = array.as_any().downcast_ref::<MapArray>().unwrap();
-                // A Map is just as ListArray<i32> with a StructArray child, we therefore
-                // treat it as such to avoid code duplication
-                self.write_list(array.value_offsets(), array.data(), range)
+            LevelInfoBuilder::Struct(children, ctx, nulls) => {
+                Self::write_struct(children, ctx, nulls.as_ref(), range)
             }
-            _ => unreachable!(),
         }
     }
 
     /// Write `range` elements from ListArray `array`
     ///
-    /// Note: MapArrays are ListArray<i32> under the hood and so are dispatched to this method
+    /// Note: MapArrays are `ListArray<i32>` under the hood and so are dispatched to this method
     fn write_list<O: OffsetSizeTrait>(
-        &mut self,
+        child: &mut LevelInfoBuilder,
+        ctx: &LevelContext,
         offsets: &[O],
-        list_data: &ArrayData,
+        nulls: Option<&NullBuffer>,
         range: Range<usize>,
     ) {
-        let (child, ctx) = match self {
-            Self::List(child, ctx) => (child, ctx),
-            _ => unreachable!(),
-        };
-
         let offsets = &offsets[range.start..range.end + 1];
-        let child_array = make_array(list_data.child_data()[0].clone());
 
         let write_non_null_slice =
             |child: &mut LevelInfoBuilder, start_idx: usize, end_idx: usize| {
-                child.write(&child_array, start_idx..end_idx);
+                child.write(start_idx..end_idx);
                 child.visit_leaves(|leaf| {
                     let rep_levels = leaf.rep_levels.as_mut().unwrap();
                     let mut rev = rep_levels.iter_mut().rev();
@@ -270,14 +306,14 @@ impl LevelInfoBuilder {
             })
         };
 
-        match list_data.null_bitmap() {
+        match nulls {
             Some(nulls) => {
-                let null_offset = list_data.offset() + range.start;
+                let null_offset = range.start;
                 // TODO: Faster bitmask iteration (#1757)
                 for (idx, w) in offsets.windows(2).enumerate() {
-                    let is_valid = nulls.is_set(idx + null_offset);
-                    let start_idx = w[0].to_usize().unwrap();
-                    let end_idx = w[1].to_usize().unwrap();
+                    let is_valid = nulls.is_valid(idx + null_offset);
+                    let start_idx = w[0].as_usize();
+                    let end_idx = w[1].as_usize();
                     if !is_valid {
                         write_null_slice(child)
                     } else if start_idx == end_idx {
@@ -289,8 +325,8 @@ impl LevelInfoBuilder {
             }
             None => {
                 for w in offsets.windows(2) {
-                    let start_idx = w[0].to_usize().unwrap();
-                    let end_idx = w[1].to_usize().unwrap();
+                    let start_idx = w[0].as_usize();
+                    let end_idx = w[1].as_usize();
                     if start_idx == end_idx {
                         write_empty_slice(child)
                     } else {
@@ -302,12 +338,12 @@ impl LevelInfoBuilder {
     }
 
     /// Write `range` elements from StructArray `array`
-    fn write_struct(&mut self, array: &StructArray, range: Range<usize>) {
-        let (children, ctx) = match self {
-            Self::Struct(children, ctx) => (children, ctx),
-            _ => unreachable!(),
-        };
-
+    fn write_struct(
+        children: &mut [LevelInfoBuilder],
+        ctx: &LevelContext,
+        nulls: Option<&NullBuffer>,
+        range: Range<usize>,
+    ) {
         let write_null = |children: &mut [LevelInfoBuilder], range: Range<usize>| {
             for child in children {
                 child.visit_leaves(|info| {
@@ -324,20 +360,19 @@ impl LevelInfoBuilder {
         };
 
         let write_non_null = |children: &mut [LevelInfoBuilder], range: Range<usize>| {
-            for (child_array, child) in array.columns().into_iter().zip(children) {
-                child.write(child_array, range.clone())
+            for child in children {
+                child.write(range.clone())
             }
         };
 
-        match array.data().null_bitmap() {
+        match nulls {
             Some(validity) => {
-                let null_offset = array.data().offset();
                 let mut last_non_null_idx = None;
                 let mut last_null_idx = None;
 
                 // TODO: Faster bitmask iteration (#1757)
                 for i in range.clone() {
-                    match validity.is_set(i + null_offset) {
+                    match validity.is_valid(i) {
                         true => {
                             if let Some(last_idx) = last_null_idx.take() {
                                 write_null(children, last_idx..i)
@@ -365,13 +400,94 @@ impl LevelInfoBuilder {
         }
     }
 
-    /// Write a primitive array, as defined by [`is_leaf`]
-    fn write_leaf(&mut self, array: &ArrayRef, range: Range<usize>) {
-        let info = match self {
-            Self::Primitive(info) => info,
-            _ => unreachable!(),
+    /// Write `range` elements from FixedSizeListArray with child data `values` and null bitmap `nulls`.
+    fn write_fixed_size_list(
+        child: &mut LevelInfoBuilder,
+        ctx: &LevelContext,
+        fixed_size: usize,
+        nulls: Option<&NullBuffer>,
+        range: Range<usize>,
+    ) {
+        let write_non_null = |child: &mut LevelInfoBuilder, start_idx: usize, end_idx: usize| {
+            let values_start = start_idx * fixed_size;
+            let values_end = end_idx * fixed_size;
+            child.write(values_start..values_end);
+
+            child.visit_leaves(|leaf| {
+                let rep_levels = leaf.rep_levels.as_mut().unwrap();
+
+                let row_indices = (0..fixed_size)
+                    .rev()
+                    .cycle()
+                    .take(values_end - values_start);
+
+                // Step backward over the child rep levels and mark the start of each list
+                rep_levels
+                    .iter_mut()
+                    .rev()
+                    // Filter out reps from nested children
+                    .filter(|&&mut r| r == ctx.rep_level)
+                    .zip(row_indices)
+                    .for_each(|(r, idx)| {
+                        if idx == 0 {
+                            *r = ctx.rep_level - 1;
+                        }
+                    });
+            })
         };
 
+        // If list size is 0, ignore values and just write rep/def levels.
+        let write_empty = |child: &mut LevelInfoBuilder, start_idx: usize, end_idx: usize| {
+            let len = end_idx - start_idx;
+            child.visit_leaves(|leaf| {
+                let rep_levels = leaf.rep_levels.as_mut().unwrap();
+                rep_levels.extend(std::iter::repeat(ctx.rep_level - 1).take(len));
+                let def_levels = leaf.def_levels.as_mut().unwrap();
+                def_levels.extend(std::iter::repeat(ctx.def_level - 1).take(len));
+            })
+        };
+
+        let write_rows = |child: &mut LevelInfoBuilder, start_idx: usize, end_idx: usize| {
+            if fixed_size > 0 {
+                write_non_null(child, start_idx, end_idx)
+            } else {
+                write_empty(child, start_idx, end_idx)
+            }
+        };
+
+        match nulls {
+            Some(nulls) => {
+                let mut start_idx = None;
+                for idx in range.clone() {
+                    if nulls.is_valid(idx) {
+                        // Start a run of valid rows if not already inside of one
+                        start_idx.get_or_insert(idx);
+                    } else {
+                        // Write out any pending valid rows
+                        if let Some(start) = start_idx.take() {
+                            write_rows(child, start, idx);
+                        }
+                        // Add null row
+                        child.visit_leaves(|leaf| {
+                            let rep_levels = leaf.rep_levels.as_mut().unwrap();
+                            rep_levels.push(ctx.rep_level - 1);
+                            let def_levels = leaf.def_levels.as_mut().unwrap();
+                            def_levels.push(ctx.def_level - 2);
+                        })
+                    }
+                }
+                // Write out any remaining valid rows
+                if let Some(start) = start_idx.take() {
+                    write_rows(child, start, range.end);
+                }
+            }
+            // If all rows are valid then write the whole array
+            None => write_rows(child, range.start, range.end),
+        }
+    }
+
+    /// Write a primitive array, as defined by [`is_leaf`]
+    fn write_leaf(info: &mut ArrayLevels, range: Range<usize>) {
         let len = range.end - range.start;
 
         match &mut info.def_levels {
@@ -379,12 +495,11 @@ impl LevelInfoBuilder {
                 def_levels.reserve(len);
                 info.non_null_indices.reserve(len);
 
-                match array.data().null_bitmap() {
+                match info.array.logical_nulls() {
                     Some(nulls) => {
-                        let nulls_offset = array.data().offset();
                         // TODO: Faster bitmask iteration (#1757)
                         for i in range {
-                            match nulls.is_set(i + nulls_offset) {
+                            match nulls.is_valid(i) {
                                 true => {
                                     def_levels.push(info.max_def_level);
                                     info.non_null_indices.push(i)
@@ -409,11 +524,13 @@ impl LevelInfoBuilder {
     }
 
     /// Visits all children of this node in depth first order
-    fn visit_leaves(&mut self, visit: impl Fn(&mut LevelInfo) + Copy) {
+    fn visit_leaves(&mut self, visit: impl Fn(&mut ArrayLevels) + Copy) {
         match self {
             LevelInfoBuilder::Primitive(info) => visit(info),
-            LevelInfoBuilder::List(c, _) => c.visit_leaves(visit),
-            LevelInfoBuilder::Struct(children, _) => {
+            LevelInfoBuilder::List(c, _, _, _)
+            | LevelInfoBuilder::LargeList(c, _, _, _)
+            | LevelInfoBuilder::FixedSizeList(c, _, _, _) => c.visit_leaves(visit),
+            LevelInfoBuilder::Struct(children, _, _) => {
                 for c in children {
                     c.visit_leaves(visit)
                 }
@@ -423,8 +540,8 @@ impl LevelInfoBuilder {
 }
 /// The data necessary to write a primitive Arrow array to parquet, taking into account
 /// any non-primitive parents it may have in the arrow representation
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub(crate) struct LevelInfo {
+#[derive(Debug, Clone)]
+pub(crate) struct ArrayLevels {
     /// Array's definition levels
     ///
     /// Present if `max_def_level != 0`
@@ -444,10 +561,25 @@ pub(crate) struct LevelInfo {
 
     /// The maximum repetition for this leaf column
     max_rep_level: i16,
+
+    /// The arrow array
+    array: ArrayRef,
 }
 
-impl LevelInfo {
-    fn new(ctx: LevelContext, is_nullable: bool) -> Self {
+impl PartialEq for ArrayLevels {
+    fn eq(&self, other: &Self) -> bool {
+        self.def_levels == other.def_levels
+            && self.rep_levels == other.rep_levels
+            && self.non_null_indices == other.non_null_indices
+            && self.max_def_level == other.max_def_level
+            && self.max_rep_level == other.max_rep_level
+            && self.array.as_ref() == other.array.as_ref()
+    }
+}
+impl Eq for ArrayLevels {}
+
+impl ArrayLevels {
+    fn new(ctx: LevelContext, is_nullable: bool, array: ArrayRef) -> Self {
         let max_rep_level = ctx.rep_level;
         let max_def_level = match is_nullable {
             true => ctx.def_level + 1,
@@ -460,9 +592,14 @@ impl LevelInfo {
             non_null_indices: vec![],
             max_def_level,
             max_rep_level,
+            array,
         }
     }
 
+    pub fn array(&self) -> &ArrayRef {
+        &self.array
+    }
+
     pub fn def_levels(&self) -> Option<&[i16]> {
         self.def_levels.as_deref()
     }
@@ -482,11 +619,14 @@ mod tests {
 
     use std::sync::Arc;
 
-    use arrow::array::*;
-    use arrow::buffer::Buffer;
-    use arrow::datatypes::{Int32Type, Schema, ToByteSlice};
-    use arrow::record_batch::RecordBatch;
-    use arrow::util::pretty::pretty_format_columns;
+    use arrow_array::builder::*;
+    use arrow_array::cast::AsArray;
+    use arrow_array::types::Int32Type;
+    use arrow_array::*;
+    use arrow_buffer::{Buffer, ToByteSlice};
+    use arrow_cast::display::array_value_to_string;
+    use arrow_data::{ArrayData, ArrayDataBuilder};
+    use arrow_schema::{Fields, Schema};
 
     #[test]
     fn test_calculate_array_levels_twitter_example() {
@@ -494,9 +634,9 @@ mod tests {
         // [[a, b, c], [d, e, f, g]], [[h], [i,j]]
 
         let leaf_type = Field::new("item", DataType::Int32, false);
-        let inner_type = DataType::List(Box::new(leaf_type));
+        let inner_type = DataType::List(Arc::new(leaf_type));
         let inner_field = Field::new("l2", inner_type.clone(), false);
-        let outer_type = DataType::List(Box::new(inner_field));
+        let outer_type = DataType::List(Arc::new(inner_field));
         let outer_field = Field::new("l1", outer_type.clone(), false);
 
         let primitives = Int32Array::from_iter(0..10);
@@ -506,7 +646,7 @@ mod tests {
         let inner_list = ArrayDataBuilder::new(inner_type)
             .len(4)
             .add_buffer(offsets)
-            .add_child_data(primitives.into_data())
+            .add_child_data(primitives.to_data())
             .build()
             .unwrap();
 
@@ -522,12 +662,13 @@ mod tests {
         let levels = calculate_array_levels(&outer_list, &outer_field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected = LevelInfo {
+        let expected = ArrayLevels {
             def_levels: Some(vec![2; 10]),
             rep_levels: Some(vec![0, 2, 2, 1, 2, 2, 2, 0, 1, 2]),
             non_null_indices: vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9],
             max_def_level: 2,
             max_rep_level: 2,
+            array: Arc::new(primitives),
         };
         assert_eq!(&levels[0], &expected);
     }
@@ -541,12 +682,13 @@ mod tests {
         let levels = calculate_array_levels(&array, &field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected_levels = LevelInfo {
+        let expected_levels = ArrayLevels {
             def_levels: None,
             rep_levels: None,
             non_null_indices: (0..10).collect(),
             max_def_level: 0,
             max_rep_level: 0,
+            array,
         };
         assert_eq!(&levels[0], &expected_levels);
     }
@@ -566,12 +708,13 @@ mod tests {
         let levels = calculate_array_levels(&array, &field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected_levels = LevelInfo {
+        let expected_levels = ArrayLevels {
             def_levels: Some(vec![1, 0, 1, 1, 0]),
             rep_levels: None,
             non_null_indices: vec![0, 2, 3],
             max_def_level: 1,
             max_rep_level: 0,
+            array,
         };
         assert_eq!(&levels[0], &expected_levels);
     }
@@ -579,7 +722,7 @@ mod tests {
     #[test]
     fn test_calculate_array_levels_1() {
         let leaf_field = Field::new("item", DataType::Int32, false);
-        let list_type = DataType::List(Box::new(leaf_field));
+        let list_type = DataType::List(Arc::new(leaf_field));
 
         // if all array values are defined (e.g. batch<list<_>>)
         // [[0], [1], [2], [3], [4]]
@@ -590,7 +733,7 @@ mod tests {
         let list = ArrayDataBuilder::new(list_type.clone())
             .len(5)
             .add_buffer(offsets)
-            .add_child_data(leaf_array.into_data())
+            .add_child_data(leaf_array.to_data())
             .build()
             .unwrap();
         let list = make_array(list);
@@ -599,12 +742,13 @@ mod tests {
         let levels = calculate_array_levels(&list, &list_field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected_levels = LevelInfo {
+        let expected_levels = ArrayLevels {
             def_levels: Some(vec![1; 5]),
             rep_levels: Some(vec![0; 5]),
             non_null_indices: (0..5).collect(),
             max_def_level: 1,
             max_rep_level: 1,
+            array: Arc::new(leaf_array),
         };
         assert_eq!(&levels[0], &expected_levels);
 
@@ -621,7 +765,7 @@ mod tests {
         let list = ArrayDataBuilder::new(list_type.clone())
             .len(5)
             .add_buffer(offsets)
-            .add_child_data(leaf_array.into_data())
+            .add_child_data(leaf_array.to_data())
             .null_bit_buffer(Some(Buffer::from([0b00011101])))
             .build()
             .unwrap();
@@ -631,12 +775,13 @@ mod tests {
         let levels = calculate_array_levels(&list, &list_field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected_levels = LevelInfo {
+        let expected_levels = ArrayLevels {
             def_levels: Some(vec![2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2]),
             rep_levels: Some(vec![0, 1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1]),
             non_null_indices: (0..11).collect(),
             max_def_level: 2,
             max_rep_level: 1,
+            array: Arc::new(leaf_array),
         };
         assert_eq!(&levels[0], &expected_levels);
     }
@@ -659,16 +804,16 @@ mod tests {
         let leaf = Int32Array::from_iter(0..11);
         let leaf_field = Field::new("leaf", DataType::Int32, false);
 
-        let list_type = DataType::List(Box::new(leaf_field));
+        let list_type = DataType::List(Arc::new(leaf_field));
         let list = ArrayData::builder(list_type.clone())
             .len(5)
-            .add_child_data(leaf.into_data())
+            .add_child_data(leaf.to_data())
             .add_buffer(Buffer::from_iter([0_i32, 2, 2, 4, 8, 11]))
             .build()
             .unwrap();
 
         let list = make_array(list);
-        let list_field = Field::new("list", list_type, true);
+        let list_field = Arc::new(Field::new("list", list_type, true));
 
         let struct_array =
             StructArray::from((vec![(list_field, list)], Buffer::from([0b00011010])));
@@ -679,12 +824,13 @@ mod tests {
         let levels = calculate_array_levels(&array, &struct_field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected_levels = LevelInfo {
+        let expected_levels = ArrayLevels {
             def_levels: Some(vec![0, 2, 0, 3, 3, 3, 3, 3, 3, 3]),
             rep_levels: Some(vec![0, 0, 0, 0, 1, 1, 1, 0, 1, 1]),
             non_null_indices: (4..11).collect(),
             max_def_level: 3,
             max_rep_level: 1,
+            array: Arc::new(leaf),
         };
 
         assert_eq!(&levels[0], &expected_levels);
@@ -700,17 +846,17 @@ mod tests {
         let leaf = Int32Array::from_iter(100..122);
         let leaf_field = Field::new("leaf", DataType::Int32, true);
 
-        let l1_type = DataType::List(Box::new(leaf_field));
+        let l1_type = DataType::List(Arc::new(leaf_field));
         let offsets = Buffer::from_iter([0_i32, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]);
         let l1 = ArrayData::builder(l1_type.clone())
             .len(11)
-            .add_child_data(leaf.into_data())
+            .add_child_data(leaf.to_data())
             .add_buffer(offsets)
             .build()
             .unwrap();
 
         let l1_field = Field::new("l1", l1_type, true);
-        let l2_type = DataType::List(Box::new(l1_field));
+        let l2_type = DataType::List(Arc::new(l1_field));
         let l2 = ArrayData::builder(l2_type)
             .len(5)
             .add_child_data(l1)
@@ -724,7 +870,7 @@ mod tests {
         let levels = calculate_array_levels(&l2, &l2_field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected_levels = LevelInfo {
+        let expected_levels = ArrayLevels {
             def_levels: Some(vec![
                 5, 5, 5, 5, 1, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5,
             ]),
@@ -734,6 +880,7 @@ mod tests {
             non_null_indices: (0..22).collect(),
             max_def_level: 5,
             max_rep_level: 2,
+            array: Arc::new(leaf),
         };
 
         assert_eq!(&levels[0], &expected_levels);
@@ -742,7 +889,7 @@ mod tests {
     #[test]
     fn test_calculate_array_levels_nested_list() {
         let leaf_field = Field::new("leaf", DataType::Int32, false);
-        let list_type = DataType::List(Box::new(leaf_field));
+        let list_type = DataType::List(Arc::new(leaf_field));
 
         // if all array values are defined (e.g. batch<list<_>>)
         // The array at this level looks like:
@@ -755,7 +902,7 @@ mod tests {
         let list = ArrayData::builder(list_type.clone())
             .len(4)
             .add_buffer(Buffer::from_iter(0_i32..5))
-            .add_child_data(leaf.into_data())
+            .add_child_data(leaf.to_data())
             .build()
             .unwrap();
         let list = make_array(list);
@@ -764,12 +911,13 @@ mod tests {
         let levels = calculate_array_levels(&list, &list_field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected_levels = LevelInfo {
+        let expected_levels = ArrayLevels {
             def_levels: Some(vec![1; 4]),
             rep_levels: Some(vec![0; 4]),
             non_null_indices: (0..4).collect(),
             max_def_level: 1,
             max_rep_level: 1,
+            array: Arc::new(leaf),
         };
         assert_eq!(&levels[0], &expected_levels);
 
@@ -782,11 +930,11 @@ mod tests {
             .len(4)
             .add_buffer(Buffer::from_iter([0_i32, 0, 3, 5, 7]))
             .null_bit_buffer(Some(Buffer::from([0b00001110])))
-            .add_child_data(leaf.into_data())
+            .add_child_data(leaf.to_data())
             .build()
             .unwrap();
         let list = make_array(list);
-        let list_field = Field::new("list", list_type, true);
+        let list_field = Arc::new(Field::new("list", list_type, true));
 
         let struct_array = StructArray::from(vec![(list_field, list)]);
         let array = Arc::new(struct_array) as ArrayRef;
@@ -795,12 +943,13 @@ mod tests {
         let levels = calculate_array_levels(&array, &struct_field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected_levels = LevelInfo {
+        let expected_levels = ArrayLevels {
             def_levels: Some(vec![1, 3, 3, 3, 3, 3, 3, 3]),
             rep_levels: Some(vec![0, 0, 1, 1, 0, 1, 0, 1]),
             non_null_indices: (0..7).collect(),
             max_def_level: 3,
             max_rep_level: 1,
+            array: Arc::new(leaf),
         };
         assert_eq!(&levels[0], &expected_levels);
 
@@ -813,16 +962,16 @@ mod tests {
 
         let leaf = Int32Array::from_iter(201..216);
         let leaf_field = Field::new("leaf", DataType::Int32, false);
-        let list_1_type = DataType::List(Box::new(leaf_field));
+        let list_1_type = DataType::List(Arc::new(leaf_field));
         let list_1 = ArrayData::builder(list_1_type.clone())
             .len(7)
             .add_buffer(Buffer::from_iter([0_i32, 1, 3, 3, 6, 10, 10, 15]))
-            .add_child_data(leaf.into_data())
+            .add_child_data(leaf.to_data())
             .build()
             .unwrap();
 
         let list_1_field = Field::new("l1", list_1_type, true);
-        let list_2_type = DataType::List(Box::new(list_1_field));
+        let list_2_type = DataType::List(Arc::new(list_1_field));
         let list_2 = ArrayData::builder(list_2_type.clone())
             .len(4)
             .add_buffer(Buffer::from_iter([0_i32, 0, 3, 5, 7]))
@@ -832,7 +981,7 @@ mod tests {
             .unwrap();
 
         let list_2 = make_array(list_2);
-        let list_2_field = Field::new("list_2", list_2_type, true);
+        let list_2_field = Arc::new(Field::new("list_2", list_2_type, true));
 
         let struct_array =
             StructArray::from((vec![(list_2_field, list_2)], Buffer::from([0b00001111])));
@@ -842,12 +991,13 @@ mod tests {
         let levels = calculate_array_levels(&array, &struct_field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected_levels = LevelInfo {
+        let expected_levels = ArrayLevels {
             def_levels: Some(vec![1, 5, 5, 5, 4, 5, 5, 5, 5, 5, 5, 5, 4, 5, 5, 5, 5, 5]),
             rep_levels: Some(vec![0, 0, 1, 2, 1, 0, 2, 2, 1, 2, 2, 2, 0, 1, 2, 2, 2, 2]),
             non_null_indices: (0..15).collect(),
             max_def_level: 5,
             max_rep_level: 2,
+            array: Arc::new(leaf),
         };
         assert_eq!(&levels[0], &expected_levels);
     }
@@ -864,13 +1014,11 @@ mod tests {
         //  - {a: {b: {c: 6}}}
 
         let c = Int32Array::from_iter([Some(1), None, Some(3), None, Some(5), Some(6)]);
-        let c_field = Field::new("c", DataType::Int32, true);
-        let b = StructArray::from((
-            (vec![(c_field, Arc::new(c) as ArrayRef)]),
-            Buffer::from([0b00110111]),
-        ));
+        let leaf = Arc::new(c) as ArrayRef;
+        let c_field = Arc::new(Field::new("c", DataType::Int32, true));
+        let b = StructArray::from(((vec![(c_field, leaf.clone())]), Buffer::from([0b00110111])));
 
-        let b_field = Field::new("b", b.data_type().clone(), true);
+        let b_field = Arc::new(Field::new("b", b.data_type().clone(), true));
         let a = StructArray::from((
             (vec![(b_field, Arc::new(b) as ArrayRef)]),
             Buffer::from([0b00101111]),
@@ -882,12 +1030,13 @@ mod tests {
         let levels = calculate_array_levels(&a_array, &a_field).unwrap();
         assert_eq!(levels.len(), 1);
 
-        let expected_levels = LevelInfo {
+        let expected_levels = ArrayLevels {
             def_levels: Some(vec![3, 2, 3, 1, 0, 3]),
             rep_levels: None,
             non_null_indices: vec![0, 2, 5],
             max_def_level: 3,
             max_rep_level: 0,
+            array: leaf,
         };
         assert_eq!(&levels[0], &expected_levels);
     }
@@ -898,37 +1047,35 @@ mod tests {
 
         let a_values = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
         let a_value_offsets = arrow::buffer::Buffer::from_iter([0_i32, 1, 3, 3, 6, 10]);
-        let a_list_type =
-            DataType::List(Box::new(Field::new("item", DataType::Int32, true)));
+        let a_list_type = DataType::List(Arc::new(Field::new("item", DataType::Int32, true)));
         let a_list_data = ArrayData::builder(a_list_type.clone())
             .len(5)
             .add_buffer(a_value_offsets)
             .null_bit_buffer(Some(Buffer::from(vec![0b00011011])))
-            .add_child_data(a_values.into_data())
+            .add_child_data(a_values.to_data())
             .build()
             .unwrap();
 
         assert_eq!(a_list_data.null_count(), 1);
 
         let a = ListArray::from(a_list_data);
-        let values = Arc::new(a) as _;
 
         let item_field = Field::new("item", a_list_type, true);
-        let mut builder =
-            LevelInfoBuilder::try_new(&item_field, Default::default()).unwrap();
-        builder.write(&values, 2..4);
+        let mut builder = levels(&item_field, a);
+        builder.write(2..4);
         let levels = builder.finish();
 
         assert_eq!(levels.len(), 1);
 
-        let list_level = levels.get(0).unwrap();
+        let list_level = &levels[0];
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: Some(vec![0, 3, 3, 3]),
             rep_levels: Some(vec![0, 0, 1, 1]),
             non_null_indices: vec![3, 4, 5],
             max_def_level: 3,
             max_rep_level: 1,
+            array: Arc::new(a_values),
         };
         assert_eq!(list_level, &expected_level);
     }
@@ -938,24 +1085,24 @@ mod tests {
         // this tests the level generation from the equivalent arrow_writer_complex test
 
         // define schema
-        let struct_field_d = Field::new("d", DataType::Float64, true);
-        let struct_field_f = Field::new("f", DataType::Float32, true);
-        let struct_field_g = Field::new(
+        let struct_field_d = Arc::new(Field::new("d", DataType::Float64, true));
+        let struct_field_f = Arc::new(Field::new("f", DataType::Float32, true));
+        let struct_field_g = Arc::new(Field::new(
             "g",
-            DataType::List(Box::new(Field::new("items", DataType::Int16, false))),
+            DataType::List(Arc::new(Field::new("items", DataType::Int16, false))),
             false,
-        );
-        let struct_field_e = Field::new(
+        ));
+        let struct_field_e = Arc::new(Field::new(
             "e",
-            DataType::Struct(vec![struct_field_f.clone(), struct_field_g.clone()]),
+            DataType::Struct(vec![struct_field_f.clone(), struct_field_g.clone()].into()),
             true,
-        );
+        ));
         let schema = Schema::new(vec![
             Field::new("a", DataType::Int32, false),
             Field::new("b", DataType::Int32, true),
             Field::new(
                 "c",
-                DataType::Struct(vec![struct_field_d.clone(), struct_field_e.clone()]),
+                DataType::Struct(vec![struct_field_d.clone(), struct_field_e.clone()].into()),
                 true, // https://github.com/apache/arrow-rs/issues/245
             ),
         ]);
@@ -970,8 +1117,7 @@ mod tests {
 
         // Construct a buffer for value offsets, for the nested array:
         //  [[1], [2, 3], null, [4, 5, 6], [7, 8, 9, 10]]
-        let g_value_offsets =
-            arrow::buffer::Buffer::from(&[0, 1, 3, 3, 6, 10].to_byte_slice());
+        let g_value_offsets = arrow::buffer::Buffer::from(&[0, 1, 3, 3, 6, 10].to_byte_slice());
 
         // Construct a list array from the above two
         let g_list_data = ArrayData::builder(struct_field_g.data_type().clone())
@@ -983,19 +1129,19 @@ mod tests {
         let g = ListArray::from(g_list_data);
 
         let e = StructArray::from(vec![
-            (struct_field_f, Arc::new(f) as ArrayRef),
+            (struct_field_f, Arc::new(f.clone()) as ArrayRef),
             (struct_field_g, Arc::new(g) as ArrayRef),
         ]);
 
         let c = StructArray::from(vec![
-            (struct_field_d, Arc::new(d) as ArrayRef),
+            (struct_field_d, Arc::new(d.clone()) as ArrayRef),
             (struct_field_e, Arc::new(e) as ArrayRef),
         ]);
 
         // build a record batch
         let batch = RecordBatch::try_new(
             Arc::new(schema),
-            vec![Arc::new(a), Arc::new(b), Arc::new(c)],
+            vec![Arc::new(a.clone()), Arc::new(b.clone()), Arc::new(c)],
         )
         .unwrap();
 
@@ -1013,50 +1159,54 @@ mod tests {
         assert_eq!(levels.len(), 5);
 
         // test "a" levels
-        let list_level = levels.get(0).unwrap();
+        let list_level = &levels[0];
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: None,
             rep_levels: None,
             non_null_indices: vec![0, 1, 2, 3, 4],
             max_def_level: 0,
             max_rep_level: 0,
+            array: Arc::new(a),
         };
         assert_eq!(list_level, &expected_level);
 
         // test "b" levels
         let list_level = levels.get(1).unwrap();
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: Some(vec![1, 0, 0, 1, 1]),
             rep_levels: None,
             non_null_indices: vec![0, 3, 4],
             max_def_level: 1,
             max_rep_level: 0,
+            array: Arc::new(b),
         };
         assert_eq!(list_level, &expected_level);
 
         // test "d" levels
         let list_level = levels.get(2).unwrap();
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: Some(vec![1, 1, 1, 2, 1]),
             rep_levels: None,
             non_null_indices: vec![3],
             max_def_level: 2,
             max_rep_level: 0,
+            array: Arc::new(d),
         };
         assert_eq!(list_level, &expected_level);
 
         // test "f" levels
         let list_level = levels.get(3).unwrap();
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: Some(vec![3, 2, 3, 2, 3]),
             rep_levels: None,
             non_null_indices: vec![0, 2, 4],
             max_def_level: 3,
             max_rep_level: 0,
+            array: Arc::new(f),
         };
         assert_eq!(list_level, &expected_level);
     }
@@ -1064,10 +1214,10 @@ mod tests {
     #[test]
     fn test_null_vs_nonnull_struct() {
         // define schema
-        let offset_field = Field::new("offset", DataType::Int32, true);
+        let offset_field = Arc::new(Field::new("offset", DataType::Int32, true));
         let schema = Schema::new(vec![Field::new(
             "some_nested_object",
-            DataType::Struct(vec![offset_field.clone()]),
+            DataType::Struct(vec![offset_field.clone()].into()),
             false,
         )]);
 
@@ -1079,18 +1229,17 @@ mod tests {
 
         // build a record batch
         let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(some_nested_object)])
-                .unwrap();
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(some_nested_object)]).unwrap();
 
         let struct_null_level =
-            calculate_array_levels(batch.column(0), batch.schema().field(0));
+            calculate_array_levels(batch.column(0), batch.schema().field(0)).unwrap();
 
         // create second batch
         // define schema
-        let offset_field = Field::new("offset", DataType::Int32, true);
+        let offset_field = Arc::new(Field::new("offset", DataType::Int32, true));
         let schema = Schema::new(vec![Field::new(
             "some_nested_object",
-            DataType::Struct(vec![offset_field.clone()]),
+            DataType::Struct(vec![offset_field.clone()].into()),
             true,
         )]);
 
@@ -1102,11 +1251,10 @@ mod tests {
 
         // build a record batch
         let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(some_nested_object)])
-                .unwrap();
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(some_nested_object)]).unwrap();
 
         let struct_non_null_level =
-            calculate_array_levels(batch.column(0), batch.schema().field(0));
+            calculate_array_levels(batch.column(0), batch.schema().field(0)).unwrap();
 
         // The 2 levels should not be the same
         if struct_non_null_level == struct_null_level {
@@ -1119,26 +1267,24 @@ mod tests {
         // Note: we are using the JSON Arrow reader for brevity
         let json_content = r#"
         {"stocks":{"long": "$AAA", "short": "$BBB"}}
-        {"stocks":{"long": null, "long": "$CCC", "short": null}}
+        {"stocks":{"long": "$CCC", "short": null}}
         {"stocks":{"hedged": "$YYY", "long": null, "short": "$D"}}
         "#;
-        let entries_struct_type = DataType::Struct(vec![
+        let entries_struct_type = DataType::Struct(Fields::from(vec![
             Field::new("key", DataType::Utf8, false),
             Field::new("value", DataType::Utf8, true),
-        ]);
+        ]));
         let stocks_field = Field::new(
             "stocks",
             DataType::Map(
-                Box::new(Field::new("entries", entries_struct_type, false)),
+                Arc::new(Field::new("entries", entries_struct_type, false)),
                 false,
             ),
             // not nullable, so the keys have max level = 1
             false,
         );
         let schema = Arc::new(Schema::new(vec![stocks_field]));
-        let builder = arrow::json::ReaderBuilder::new()
-            .with_schema(schema)
-            .with_batch_size(64);
+        let builder = arrow::json::ReaderBuilder::new(schema).with_batch_size(64);
         let mut reader = builder.build(std::io::Cursor::new(json_content)).unwrap();
 
         let batch = reader.next().unwrap().unwrap();
@@ -1155,27 +1301,31 @@ mod tests {
             });
         assert_eq!(levels.len(), 2);
 
+        let map = batch.column(0).as_map();
+
         // test key levels
-        let list_level = levels.get(0).unwrap();
+        let list_level = &levels[0];
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: Some(vec![1; 7]),
             rep_levels: Some(vec![0, 1, 0, 1, 0, 1, 1]),
             non_null_indices: vec![0, 1, 2, 3, 4, 5, 6],
             max_def_level: 1,
             max_rep_level: 1,
+            array: map.keys().clone(),
         };
         assert_eq!(list_level, &expected_level);
 
         // test values levels
         let list_level = levels.get(1).unwrap();
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: Some(vec![2, 2, 2, 1, 2, 1, 2]),
             rep_levels: Some(vec![0, 1, 0, 1, 0, 1, 1]),
             non_null_indices: vec![0, 1, 2, 4, 6],
             max_def_level: 2,
             max_rep_level: 1,
+            array: map.values().clone(),
         };
         assert_eq!(list_level, &expected_level);
     }
@@ -1184,13 +1334,12 @@ mod tests {
     fn test_list_of_struct() {
         // define schema
         let int_field = Field::new("a", DataType::Int32, true);
-        let item_field =
-            Field::new("item", DataType::Struct(vec![int_field.clone()]), true);
-        let list_field = Field::new("list", DataType::List(Box::new(item_field)), true);
+        let fields = Fields::from([Arc::new(int_field)]);
+        let item_field = Field::new("item", DataType::Struct(fields.clone()), true);
+        let list_field = Field::new("list", DataType::List(Arc::new(item_field)), true);
 
-        let int_builder = Int32Builder::new(10);
-        let struct_builder =
-            StructBuilder::new(vec![int_field], vec![Box::new(int_builder)]);
+        let int_builder = Int32Builder::with_capacity(10);
+        let struct_builder = StructBuilder::new(fields, vec![Box::new(int_builder)]);
         let mut list_builder = ListBuilder::new(struct_builder);
 
         // [{a: 1}], [], null, [null, null], [{a: null}], [{a: 2}]
@@ -1244,7 +1393,8 @@ mod tests {
 
         let array = Arc::new(list_builder.finish());
 
-        let values_len = array.data().child_data()[0].len();
+        let values = array.values().as_struct().column(0).clone();
+        let values_len = values.len();
         assert_eq!(values_len, 5);
 
         let schema = Arc::new(Schema::new(vec![list_field]));
@@ -1254,12 +1404,13 @@ mod tests {
         let levels = calculate_array_levels(rb.column(0), rb.schema().field(0)).unwrap();
         let list_level = &levels[0];
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: Some(vec![4, 1, 0, 2, 2, 3, 4]),
             rep_levels: Some(vec![0, 0, 0, 0, 1, 0, 0]),
             non_null_indices: vec![0, 4],
             max_def_level: 4,
             max_rep_level: 1,
+            array: values,
         };
 
         assert_eq!(list_level, &expected_level);
@@ -1277,11 +1428,12 @@ mod tests {
             None, // Masked by struct array
             None,
         ]);
+        let values = inner.values().clone();
 
         // This test assumes that nulls don't take up space
-        assert_eq!(inner.data().child_data()[0].len(), 7);
+        assert_eq!(inner.values().len(), 7);
 
-        let field = Field::new("list", inner.data_type().clone(), true);
+        let field = Arc::new(Field::new("list", inner.data_type().clone(), true));
         let array = Arc::new(inner) as ArrayRef;
         let nulls = Buffer::from([0b01010111]);
         let struct_a = StructArray::from((vec![(field, array)], nulls));
@@ -1292,12 +1444,13 @@ mod tests {
 
         assert_eq!(levels.len(), 1);
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: Some(vec![4, 4, 3, 2, 0, 4, 4, 0, 1]),
             rep_levels: Some(vec![0, 1, 0, 0, 0, 0, 1, 0, 0]),
             non_null_indices: vec![0, 1, 5, 6],
             max_def_level: 4,
             max_rep_level: 1,
+            array: values,
         };
 
         assert_eq!(&levels[0], &expected_level);
@@ -1308,14 +1461,16 @@ mod tests {
         // Test the null mask of a struct array and the null mask of a list array
         // masking out non-null elements of their children
 
-        let a1 = Arc::new(ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
+        let a1 = ListArray::from_iter_primitive::<Int32Type, _, _>(vec![
             Some(vec![None]), // Masked by list array
             Some(vec![]),     // Masked by list array
             Some(vec![Some(3), None]),
             Some(vec![Some(4), Some(5), None, Some(6)]), // Masked by struct array
             None,
             None,
-        ])) as ArrayRef;
+        ]);
+        let a1_values = a1.values().clone();
+        let a1 = Arc::new(a1) as ArrayRef;
 
         let a2 = Arc::new(Int32Array::from_iter(vec![
             Some(1), // Masked by list array
@@ -1325,19 +1480,21 @@ mod tests {
             Some(5),
             None,
         ])) as ArrayRef;
+        let a2_values = a2.clone();
 
-        let field_a1 = Field::new("list", a1.data_type().clone(), true);
-        let field_a2 = Field::new("integers", a2.data_type().clone(), true);
+        let field_a1 = Arc::new(Field::new("list", a1.data_type().clone(), true));
+        let field_a2 = Arc::new(Field::new("integers", a2.data_type().clone(), true));
 
         let nulls = Buffer::from([0b00110111]);
-        let struct_a = Arc::new(
-            StructArray::try_from((vec![(field_a1, a1), (field_a2, a2)], nulls)).unwrap(),
-        ) as ArrayRef;
+        let struct_a = Arc::new(StructArray::from((
+            vec![(field_a1, a1), (field_a2, a2)],
+            nulls,
+        ))) as ArrayRef;
 
         let offsets = Buffer::from_iter([0_i32, 0, 2, 2, 3, 5, 5]);
         let nulls = Buffer::from([0b00111100]);
 
-        let list_type = DataType::List(Box::new(Field::new(
+        let list_type = DataType::List(Arc::new(Field::new(
             "struct",
             struct_a.data_type().clone(),
             true,
@@ -1355,44 +1512,355 @@ mod tests {
         let list_field = Field::new("col", list_type, true);
 
         let expected = vec![
-            r#"+-------------------------------------+"#,
-            r#"| col                                 |"#,
-            r#"+-------------------------------------+"#,
-            r#"|                                     |"#,
-            r#"|                                     |"#,
-            r#"| []                                  |"#,
-            r#"| [{"list": [3, ], "integers": null}] |"#,
-            r#"| [, {"list": null, "integers": 5}]   |"#,
-            r#"| []                                  |"#,
-            r#"+-------------------------------------+"#,
-        ]
-        .join("\n");
-
-        let pretty = pretty_format_columns(list_field.name(), &[list.clone()]).unwrap();
-        assert_eq!(pretty.to_string(), expected);
+            r#""#.to_string(),
+            r#""#.to_string(),
+            r#"[]"#.to_string(),
+            r#"[{list: [3, ], integers: }]"#.to_string(),
+            r#"[, {list: , integers: 5}]"#.to_string(),
+            r#"[]"#.to_string(),
+        ];
+
+        let actual: Vec<_> = (0..6)
+            .map(|x| array_value_to_string(&list, x).unwrap())
+            .collect();
+        assert_eq!(actual, expected);
 
         let levels = calculate_array_levels(&list, &list_field).unwrap();
 
         assert_eq!(levels.len(), 2);
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: Some(vec![0, 0, 1, 6, 5, 2, 3, 1]),
             rep_levels: Some(vec![0, 0, 0, 0, 2, 0, 1, 0]),
             non_null_indices: vec![1],
             max_def_level: 6,
             max_rep_level: 2,
+            array: a1_values,
         };
 
         assert_eq!(&levels[0], &expected_level);
 
-        let expected_level = LevelInfo {
+        let expected_level = ArrayLevels {
             def_levels: Some(vec![0, 0, 1, 3, 2, 4, 1]),
             rep_levels: Some(vec![0, 0, 0, 0, 0, 1, 0]),
             non_null_indices: vec![4],
             max_def_level: 4,
             max_rep_level: 1,
+            array: a2_values,
         };
 
         assert_eq!(&levels[1], &expected_level);
     }
+
+    #[test]
+    fn test_fixed_size_list() {
+        // [[1, 2], null, null, [7, 8], null]
+        let mut builder = FixedSizeListBuilder::new(Int32Builder::new(), 2);
+        builder.values().append_slice(&[1, 2]);
+        builder.append(true);
+        builder.values().append_slice(&[3, 4]);
+        builder.append(false);
+        builder.values().append_slice(&[5, 6]);
+        builder.append(false);
+        builder.values().append_slice(&[7, 8]);
+        builder.append(true);
+        builder.values().append_slice(&[9, 10]);
+        builder.append(false);
+        let a = builder.finish();
+        let values = a.values().clone();
+
+        let item_field = Field::new("item", a.data_type().clone(), true);
+        let mut builder = levels(&item_field, a);
+        builder.write(1..4);
+        let levels = builder.finish();
+
+        assert_eq!(levels.len(), 1);
+
+        let list_level = &levels[0];
+
+        let expected_level = ArrayLevels {
+            def_levels: Some(vec![0, 0, 3, 3]),
+            rep_levels: Some(vec![0, 0, 0, 1]),
+            non_null_indices: vec![6, 7],
+            max_def_level: 3,
+            max_rep_level: 1,
+            array: values,
+        };
+        assert_eq!(list_level, &expected_level);
+    }
+
+    #[test]
+    fn test_fixed_size_list_of_struct() {
+        // define schema
+        let field_a = Field::new("a", DataType::Int32, true);
+        let field_b = Field::new("b", DataType::Int64, false);
+        let fields = Fields::from([Arc::new(field_a), Arc::new(field_b)]);
+        let item_field = Field::new("item", DataType::Struct(fields.clone()), true);
+        let list_field = Field::new(
+            "list",
+            DataType::FixedSizeList(Arc::new(item_field), 2),
+            true,
+        );
+
+        let builder_a = Int32Builder::with_capacity(10);
+        let builder_b = Int64Builder::with_capacity(10);
+        let struct_builder =
+            StructBuilder::new(fields, vec![Box::new(builder_a), Box::new(builder_b)]);
+        let mut list_builder = FixedSizeListBuilder::new(struct_builder, 2);
+
+        // [
+        //   [{a: 1, b: 2}, null],
+        //   null,
+        //   [null, null],
+        //   [{a: null, b: 3}, {a: 2, b: 4}]
+        // ]
+
+        // [{a: 1, b: 2}, null]
+        let values = list_builder.values();
+        // {a: 1, b: 2}
+        values
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_value(1);
+        values
+            .field_builder::<Int64Builder>(1)
+            .unwrap()
+            .append_value(2);
+        values.append(true);
+        // null
+        values
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_null();
+        values
+            .field_builder::<Int64Builder>(1)
+            .unwrap()
+            .append_value(0);
+        values.append(false);
+        list_builder.append(true);
+
+        // null
+        let values = list_builder.values();
+        // null
+        values
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_null();
+        values
+            .field_builder::<Int64Builder>(1)
+            .unwrap()
+            .append_value(0);
+        values.append(false);
+        // null
+        values
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_null();
+        values
+            .field_builder::<Int64Builder>(1)
+            .unwrap()
+            .append_value(0);
+        values.append(false);
+        list_builder.append(false);
+
+        // [null, null]
+        let values = list_builder.values();
+        // null
+        values
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_null();
+        values
+            .field_builder::<Int64Builder>(1)
+            .unwrap()
+            .append_value(0);
+        values.append(false);
+        // null
+        values
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_null();
+        values
+            .field_builder::<Int64Builder>(1)
+            .unwrap()
+            .append_value(0);
+        values.append(false);
+        list_builder.append(true);
+
+        // [{a: null, b: 3}, {a: 2, b: 4}]
+        let values = list_builder.values();
+        // {a: null, b: 3}
+        values
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_null();
+        values
+            .field_builder::<Int64Builder>(1)
+            .unwrap()
+            .append_value(3);
+        values.append(true);
+        // {a: 2, b: 4}
+        values
+            .field_builder::<Int32Builder>(0)
+            .unwrap()
+            .append_value(2);
+        values
+            .field_builder::<Int64Builder>(1)
+            .unwrap()
+            .append_value(4);
+        values.append(true);
+        list_builder.append(true);
+
+        let array = Arc::new(list_builder.finish());
+
+        assert_eq!(array.values().len(), 8);
+        assert_eq!(array.len(), 4);
+
+        let struct_values = array.values().as_struct();
+        let values_a = struct_values.column(0).clone();
+        let values_b = struct_values.column(1).clone();
+
+        let schema = Arc::new(Schema::new(vec![list_field]));
+        let rb = RecordBatch::try_new(schema, vec![array]).unwrap();
+
+        let levels = calculate_array_levels(rb.column(0), rb.schema().field(0)).unwrap();
+        let a_levels = &levels[0];
+        let b_levels = &levels[1];
+
+        // [[{a: 1}, null], null, [null, null], [{a: null}, {a: 2}]]
+        let expected_a = ArrayLevels {
+            def_levels: Some(vec![4, 2, 0, 2, 2, 3, 4]),
+            rep_levels: Some(vec![0, 1, 0, 0, 1, 0, 1]),
+            non_null_indices: vec![0, 7],
+            max_def_level: 4,
+            max_rep_level: 1,
+            array: values_a,
+        };
+        // [[{b: 2}, null], null, [null, null], [{b: 3}, {b: 4}]]
+        let expected_b = ArrayLevels {
+            def_levels: Some(vec![3, 2, 0, 2, 2, 3, 3]),
+            rep_levels: Some(vec![0, 1, 0, 0, 1, 0, 1]),
+            non_null_indices: vec![0, 6, 7],
+            max_def_level: 3,
+            max_rep_level: 1,
+            array: values_b,
+        };
+
+        assert_eq!(a_levels, &expected_a);
+        assert_eq!(b_levels, &expected_b);
+    }
+
+    #[test]
+    fn test_fixed_size_list_empty() {
+        let mut builder = FixedSizeListBuilder::new(Int32Builder::new(), 0);
+        builder.append(true);
+        builder.append(false);
+        builder.append(true);
+        let array = builder.finish();
+        let values = array.values().clone();
+
+        let item_field = Field::new("item", array.data_type().clone(), true);
+        let mut builder = levels(&item_field, array);
+        builder.write(0..3);
+        let levels = builder.finish();
+
+        assert_eq!(levels.len(), 1);
+
+        let list_level = &levels[0];
+
+        let expected_level = ArrayLevels {
+            def_levels: Some(vec![1, 0, 1]),
+            rep_levels: Some(vec![0, 0, 0]),
+            non_null_indices: vec![],
+            max_def_level: 3,
+            max_rep_level: 1,
+            array: values,
+        };
+        assert_eq!(list_level, &expected_level);
+    }
+
+    #[test]
+    fn test_fixed_size_list_of_var_lists() {
+        // [[[1, null, 3], null], [[4], []], [[5, 6], [null, null]], null]
+        let mut builder = FixedSizeListBuilder::new(ListBuilder::new(Int32Builder::new()), 2);
+        builder.values().append_value([Some(1), None, Some(3)]);
+        builder.values().append_null();
+        builder.append(true);
+        builder.values().append_value([Some(4)]);
+        builder.values().append_value([]);
+        builder.append(true);
+        builder.values().append_value([Some(5), Some(6)]);
+        builder.values().append_value([None, None]);
+        builder.append(true);
+        builder.values().append_null();
+        builder.values().append_null();
+        builder.append(false);
+        let a = builder.finish();
+        let values = a.values().as_list::<i32>().values().clone();
+
+        let item_field = Field::new("item", a.data_type().clone(), true);
+        let mut builder = levels(&item_field, a);
+        builder.write(0..4);
+        let levels = builder.finish();
+
+        let expected_level = ArrayLevels {
+            def_levels: Some(vec![5, 4, 5, 2, 5, 3, 5, 5, 4, 4, 0]),
+            rep_levels: Some(vec![0, 2, 2, 1, 0, 1, 0, 2, 1, 2, 0]),
+            non_null_indices: vec![0, 2, 3, 4, 5],
+            max_def_level: 5,
+            max_rep_level: 2,
+            array: values,
+        };
+
+        assert_eq!(levels[0], expected_level);
+    }
+
+    #[test]
+    fn test_null_dictionary_values() {
+        let values = Int32Array::new(
+            vec![1, 2, 3, 4].into(),
+            Some(NullBuffer::from(vec![true, false, true, true])),
+        );
+        let keys = Int32Array::new(
+            vec![1, 54, 2, 0].into(),
+            Some(NullBuffer::from(vec![true, false, true, true])),
+        );
+        // [NULL, NULL, 3, 0]
+        let dict = DictionaryArray::new(keys, Arc::new(values));
+
+        let item_field = Field::new("item", dict.data_type().clone(), true);
+
+        let mut builder = levels(&item_field, dict.clone());
+        builder.write(0..4);
+        let levels = builder.finish();
+        let expected_level = ArrayLevels {
+            def_levels: Some(vec![0, 0, 1, 1]),
+            rep_levels: None,
+            non_null_indices: vec![2, 3],
+            max_def_level: 1,
+            max_rep_level: 0,
+            array: Arc::new(dict),
+        };
+        assert_eq!(levels[0], expected_level);
+    }
+
+    #[test]
+    fn mismatched_types() {
+        let array = Arc::new(Int32Array::from_iter(0..10)) as ArrayRef;
+        let field = Field::new("item", DataType::Float64, false);
+
+        let err = LevelInfoBuilder::try_new(&field, Default::default(), &array)
+            .unwrap_err()
+            .to_string();
+
+        assert_eq!(
+            err,
+            "Arrow: Incompatible type. Field 'item' has type Float64, array has type Int32",
+        );
+    }
+
+    fn levels<T: Array + 'static>(field: &Field, array: T) -> LevelInfoBuilder {
+        let v = Arc::new(array) as ArrayRef;
+        LevelInfoBuilder::try_new(field, Default::default(), &v).unwrap()
+    }
 }
diff --git a/parquet/src/arrow/arrow_writer/mod.rs b/parquet/src/arrow/arrow_writer/mod.rs
index 08f37c395658..b677ef354c7f 100644
--- a/parquet/src/arrow/arrow_writer/mod.rs
+++ b/parquet/src/arrow/arrow_writer/mod.rs
@@ -17,46 +17,56 @@
 
 //! Contains writer which writes arrow data into parquet data.
 
-use std::collections::VecDeque;
-use std::io::Write;
-use std::sync::Arc;
-
-use arrow::array as arrow_array;
-use arrow::array::ArrayRef;
-use arrow::datatypes::{DataType as ArrowDataType, IntervalUnit, SchemaRef};
-use arrow::record_batch::RecordBatch;
-use arrow_array::Array;
+use bytes::Bytes;
+use std::io::{Read, Write};
+use std::iter::Peekable;
+use std::slice::Iter;
+use std::sync::{Arc, Mutex};
+use std::vec::IntoIter;
+use thrift::protocol::TCompactOutputProtocol;
+
+use arrow_array::cast::AsArray;
+use arrow_array::types::*;
+use arrow_array::{ArrayRef, RecordBatch, RecordBatchWriter};
+use arrow_schema::{ArrowError, DataType as ArrowDataType, Field, IntervalUnit, SchemaRef};
 
 use super::schema::{
-    add_encoded_arrow_schema_to_metadata, arrow_to_parquet_schema,
-    decimal_length_from_precision,
+    add_encoded_arrow_schema_to_metadata, arrow_to_parquet_schema, decimal_length_from_precision,
 };
 
-use crate::arrow::arrow_writer::byte_array::ByteArrayWriter;
-use crate::column::writer::{ColumnWriter, ColumnWriterImpl};
+use crate::arrow::arrow_writer::byte_array::ByteArrayEncoder;
+use crate::column::page::{CompressedPage, PageWriteSpec, PageWriter};
+use crate::column::writer::encoder::ColumnValueEncoder;
+use crate::column::writer::{
+    get_column_writer, ColumnCloseResult, ColumnWriter, GenericColumnWriter,
+};
+use crate::data_type::{ByteArray, FixedLenByteArray};
 use crate::errors::{ParquetError, Result};
-use crate::file::metadata::RowGroupMetaDataPtr;
-use crate::file::properties::WriterProperties;
-use crate::file::writer::SerializedRowGroupWriter;
-use crate::{data_type::*, file::writer::SerializedFileWriter};
-use levels::{calculate_array_levels, LevelInfo};
+use crate::file::metadata::{ColumnChunkMetaData, KeyValue, RowGroupMetaDataPtr};
+use crate::file::properties::{WriterProperties, WriterPropertiesPtr};
+use crate::file::reader::{ChunkReader, Length};
+use crate::file::writer::{SerializedFileWriter, SerializedRowGroupWriter};
+use crate::schema::types::{ColumnDescPtr, SchemaDescriptor};
+use crate::thrift::TSerializable;
+use levels::{calculate_array_levels, ArrayLevels};
 
 mod byte_array;
 mod levels;
 
-/// Arrow writer
+/// Encodes [`RecordBatch`] to parquet
 ///
-/// Writes Arrow `RecordBatch`es to a Parquet writer, buffering up `RecordBatch` in order
-/// to produce row groups with `max_row_group_size` rows. Any remaining rows will be
+/// Writes Arrow `RecordBatch`es to a Parquet writer. Multiple [`RecordBatch`] will be encoded
+/// to the same row group, up to `max_row_group_size` rows. Any remaining rows will be
 /// flushed on close, leading the final row group in the output file to potentially
 /// contain fewer than `max_row_group_size` rows
 ///
 /// ```
 /// # use std::sync::Arc;
 /// # use bytes::Bytes;
-/// # use arrow::array::{ArrayRef, Int64Array};
-/// # use arrow::record_batch::RecordBatch;
-/// # use parquet::arrow::{ArrowReader, ArrowWriter, ParquetFileArrowReader};
+/// # use arrow_array::{ArrayRef, Int64Array};
+/// # use arrow_array::RecordBatch;
+/// # use parquet::arrow::arrow_writer::ArrowWriter;
+/// # use parquet::arrow::arrow_reader::ParquetRecordBatchReader;
 /// let col = Arc::new(Int64Array::from_iter_values([1, 2, 3])) as ArrayRef;
 /// let to_write = RecordBatch::try_from_iter([("col", col)]).unwrap();
 ///
@@ -65,8 +75,7 @@ mod levels;
 /// writer.write(&to_write).unwrap();
 /// writer.close().unwrap();
 ///
-/// let mut reader = ParquetFileArrowReader::try_new(Bytes::from(buffer)).unwrap();
-/// let mut reader = reader.get_record_reader(1024).unwrap();
+/// let mut reader = ParquetRecordBatchReader::try_new(Bytes::from(buffer), 1024).unwrap();
 /// let read = reader.next().unwrap().unwrap();
 ///
 /// assert_eq!(to_write, read);
@@ -75,11 +84,8 @@ pub struct ArrowWriter<W: Write> {
     /// Underlying Parquet writer
     writer: SerializedFileWriter<W>,
 
-    /// For each column, maintain an ordered queue of arrays to write
-    buffer: Vec<VecDeque<ArrayRef>>,
-
-    /// The total number of rows currently buffered
-    buffered_rows: usize,
+    /// The in-progress row group if any
+    in_progress: Option<ArrowRowGroupWriter>,
 
     /// A copy of the Arrow schema.
     ///
@@ -90,7 +96,20 @@ pub struct ArrowWriter<W: Write> {
     max_row_group_size: usize,
 }
 
-impl<W: Write> ArrowWriter<W> {
+impl<W: Write + Send> std::fmt::Debug for ArrowWriter<W> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        let buffered_memory = self.in_progress_size();
+        f.debug_struct("ArrowWriter")
+            .field("writer", &self.writer)
+            .field("in_progress_size", &format_args!("{buffered_memory} bytes"))
+            .field("in_progress_rows", &self.in_progress_rows())
+            .field("arrow_schema", &self.arrow_schema)
+            .field("max_row_group_size", &self.max_row_group_size)
+            .finish()
+    }
+}
+
+impl<W: Write + Send> ArrowWriter<W> {
     /// Try to create a new Arrow writer
     ///
     /// The writer will fail if:
@@ -100,11 +119,27 @@ impl<W: Write> ArrowWriter<W> {
         writer: W,
         arrow_schema: SchemaRef,
         props: Option<WriterProperties>,
+    ) -> Result<Self> {
+        let options = ArrowWriterOptions::new().with_properties(props.unwrap_or_default());
+        Self::try_new_with_options(writer, arrow_schema, options)
+    }
+
+    /// Try to create a new Arrow writer with [`ArrowWriterOptions`].
+    ///
+    /// The writer will fail if:
+    ///  * a `SerializedFileWriter` cannot be created from the ParquetWriter
+    ///  * the Arrow schema contains unsupported datatypes such as Unions
+    pub fn try_new_with_options(
+        writer: W,
+        arrow_schema: SchemaRef,
+        options: ArrowWriterOptions,
     ) -> Result<Self> {
         let schema = arrow_to_parquet_schema(&arrow_schema)?;
-        // add serialized arrow schema
-        let mut props = props.unwrap_or_else(|| WriterProperties::builder().build());
-        add_encoded_arrow_schema_to_metadata(&arrow_schema, &mut props);
+        let mut props = options.properties;
+        if !options.skip_arrow_metadata {
+            // add serialized arrow schema
+            add_encoded_arrow_schema_to_metadata(&arrow_schema, &mut props);
+        }
 
         let max_row_group_size = props.max_row_group_size();
 
@@ -113,8 +148,7 @@ impl<W: Write> ArrowWriter<W> {
 
         Ok(Self {
             writer: file_writer,
-            buffer: vec![Default::default(); arrow_schema.fields().len()],
-            buffered_rows: 0,
+            in_progress: None,
             arrow_schema,
             max_row_group_size,
         })
@@ -125,313 +159,613 @@ impl<W: Write> ArrowWriter<W> {
         self.writer.flushed_row_groups()
     }
 
-    /// Enqueues the provided `RecordBatch` to be written
+    /// Returns the estimated length in bytes of the current in progress row group
+    pub fn in_progress_size(&self) -> usize {
+        match &self.in_progress {
+            Some(in_progress) => in_progress
+                .writers
+                .iter()
+                .map(|x| x.get_estimated_total_bytes())
+                .sum(),
+            None => 0,
+        }
+    }
+
+    /// Returns the number of rows buffered in the in progress row group
+    pub fn in_progress_rows(&self) -> usize {
+        self.in_progress
+            .as_ref()
+            .map(|x| x.buffered_rows)
+            .unwrap_or_default()
+    }
+
+    /// Returns the number of bytes written by this instance
+    pub fn bytes_written(&self) -> usize {
+        self.writer.bytes_written()
+    }
+
+    /// Encodes the provided [`RecordBatch`]
     ///
-    /// If following this there are more than `max_row_group_size` rows buffered,
-    /// this will flush out one or more row groups with `max_row_group_size` rows,
-    /// and drop any fully written `RecordBatch`
+    /// If this would cause the current row group to exceed [`WriterProperties::max_row_group_size`]
+    /// rows, the contents of `batch` will be written to one or more row groups such that all but
+    /// the final row group in the file contain [`WriterProperties::max_row_group_size`] rows.
+    ///
+    /// This will fail if the `batch`'s schema does not match the writer's schema.
     pub fn write(&mut self, batch: &RecordBatch) -> Result<()> {
-        // validate batch schema against writer's supplied schema
-        if self.arrow_schema != batch.schema() {
-            return Err(ParquetError::ArrowError(
-                "Record batch schema does not match writer schema".to_string(),
-            ));
+        if batch.num_rows() == 0 {
+            return Ok(());
         }
 
-        for (buffer, column) in self.buffer.iter_mut().zip(batch.columns()) {
-            buffer.push_back(column.clone())
+        let in_progress = match &mut self.in_progress {
+            Some(in_progress) => in_progress,
+            x => x.insert(ArrowRowGroupWriter::new(
+                self.writer.schema_descr(),
+                self.writer.properties(),
+                &self.arrow_schema,
+            )?),
+        };
+
+        // If would exceed max_row_group_size, split batch
+        if in_progress.buffered_rows + batch.num_rows() > self.max_row_group_size {
+            let to_write = self.max_row_group_size - in_progress.buffered_rows;
+            let a = batch.slice(0, to_write);
+            let b = batch.slice(to_write, batch.num_rows() - to_write);
+            self.write(&a)?;
+            return self.write(&b);
         }
 
-        self.buffered_rows += batch.num_rows();
-        self.flush_completed()?;
+        in_progress.write(batch)?;
 
+        if in_progress.buffered_rows >= self.max_row_group_size {
+            self.flush()?
+        }
         Ok(())
     }
 
-    /// Flushes buffered data until there are less than `max_row_group_size` rows buffered
-    fn flush_completed(&mut self) -> Result<()> {
-        while self.buffered_rows >= self.max_row_group_size {
-            self.flush_rows(self.max_row_group_size)?;
+    /// Flushes all buffered rows into a new row group
+    pub fn flush(&mut self) -> Result<()> {
+        let in_progress = match self.in_progress.take() {
+            Some(in_progress) => in_progress,
+            None => return Ok(()),
+        };
+
+        let mut row_group_writer = self.writer.next_row_group()?;
+        for chunk in in_progress.close()? {
+            chunk.append_to_row_group(&mut row_group_writer)?;
         }
+        row_group_writer.close()?;
         Ok(())
     }
 
-    /// Flushes all buffered rows into a new row group
-    pub fn flush(&mut self) -> Result<()> {
-        self.flush_rows(self.buffered_rows)
+    /// Additional [`KeyValue`] metadata to be written in addition to those from [`WriterProperties`]
+    ///
+    /// This method provide a way to append kv_metadata after write RecordBatch
+    pub fn append_key_value_metadata(&mut self, kv_metadata: KeyValue) {
+        self.writer.append_key_value_metadata(kv_metadata)
     }
 
-    /// Flushes `num_rows` from the buffer into a new row group
-    fn flush_rows(&mut self, num_rows: usize) -> Result<()> {
-        if num_rows == 0 {
-            return Ok(());
+    /// Flushes any outstanding data and returns the underlying writer.
+    pub fn into_inner(mut self) -> Result<W> {
+        self.flush()?;
+        self.writer.into_inner()
+    }
+
+    /// Close and finalize the underlying Parquet writer
+    pub fn close(mut self) -> Result<crate::format::FileMetaData> {
+        self.flush()?;
+        self.writer.close()
+    }
+}
+
+impl<W: Write + Send> RecordBatchWriter for ArrowWriter<W> {
+    fn write(&mut self, batch: &RecordBatch) -> Result<(), ArrowError> {
+        self.write(batch).map_err(|e| e.into())
+    }
+
+    fn close(self) -> std::result::Result<(), ArrowError> {
+        self.close()?;
+        Ok(())
+    }
+}
+
+/// Arrow-specific configuration settings for writing parquet files.
+///
+/// See [`ArrowWriter`] for how to configure the writer.
+#[derive(Debug, Clone, Default)]
+pub struct ArrowWriterOptions {
+    properties: WriterProperties,
+    skip_arrow_metadata: bool,
+}
+
+impl ArrowWriterOptions {
+    /// Creates a new [`ArrowWriterOptions`] with the default settings.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Sets the [`WriterProperties`] for writing parquet files.
+    pub fn with_properties(self, properties: WriterProperties) -> Self {
+        Self { properties, ..self }
+    }
+
+    /// Parquet files generated by the [`ArrowWriter`] contain embedded arrow schema
+    /// by default.
+    ///
+    /// Set `skip_arrow_metadata` to true, to skip encoding this.
+    pub fn with_skip_arrow_metadata(self, skip_arrow_metadata: bool) -> Self {
+        Self {
+            skip_arrow_metadata,
+            ..self
         }
+    }
+}
 
-        assert!(
-            num_rows <= self.buffered_rows,
-            "cannot flush {} rows only have {}",
-            num_rows,
-            self.buffered_rows
-        );
+/// A single column chunk produced by [`ArrowColumnWriter`]
+#[derive(Default)]
+struct ArrowColumnChunkData {
+    length: usize,
+    data: Vec<Bytes>,
+}
 
-        assert!(
-            num_rows <= self.max_row_group_size,
-            "cannot flush {} rows would exceed max row group size of {}",
-            num_rows,
-            self.max_row_group_size
-        );
+impl Length for ArrowColumnChunkData {
+    fn len(&self) -> u64 {
+        self.length as _
+    }
+}
 
-        let mut row_group_writer = self.writer.next_row_group()?;
+impl ChunkReader for ArrowColumnChunkData {
+    type T = ArrowColumnChunkReader;
 
-        for (col_buffer, field) in self.buffer.iter_mut().zip(self.arrow_schema.fields())
-        {
-            // Collect the number of arrays to append
-            let mut remaining = num_rows;
-            let mut arrays = Vec::with_capacity(col_buffer.len());
-            while remaining != 0 {
-                match col_buffer.pop_front() {
-                    Some(next) if next.len() > remaining => {
-                        col_buffer
-                            .push_front(next.slice(remaining, next.len() - remaining));
-                        arrays.push(next.slice(0, remaining));
-                        remaining = 0;
-                    }
-                    Some(next) => {
-                        remaining -= next.len();
-                        arrays.push(next);
-                    }
-                    _ => break,
+    fn get_read(&self, start: u64) -> Result<Self::T> {
+        assert_eq!(start, 0); // Assume append_column writes all data in one-shot
+        Ok(ArrowColumnChunkReader(
+            self.data.clone().into_iter().peekable(),
+        ))
+    }
+
+    fn get_bytes(&self, _start: u64, _length: usize) -> Result<Bytes> {
+        unimplemented!()
+    }
+}
+
+/// A [`Read`] for [`ArrowColumnChunkData`]
+struct ArrowColumnChunkReader(Peekable<IntoIter<Bytes>>);
+
+impl Read for ArrowColumnChunkReader {
+    fn read(&mut self, out: &mut [u8]) -> std::io::Result<usize> {
+        let buffer = loop {
+            match self.0.peek_mut() {
+                Some(b) if b.is_empty() => {
+                    self.0.next();
+                    continue;
                 }
+                Some(b) => break b,
+                None => return Ok(0),
             }
+        };
 
-            let mut levels = arrays
-                .iter()
-                .map(|array| {
-                    let mut levels = calculate_array_levels(array, field)?;
-                    // Reverse levels as we pop() them when writing arrays
-                    levels.reverse();
-                    Ok(levels)
-                })
-                .collect::<Result<Vec<_>>>()?;
-
-            write_leaves(&mut row_group_writer, &arrays, &mut levels)?;
+        let len = buffer.len().min(out.len());
+        let b = buffer.split_to(len);
+        out[..len].copy_from_slice(&b);
+        Ok(len)
+    }
+}
+
+/// A shared [`ArrowColumnChunkData`]
+///
+/// This allows it to be owned by [`ArrowPageWriter`] whilst allowing access via
+/// [`ArrowRowGroupWriter`] on flush, without requiring self-referential borrows
+type SharedColumnChunk = Arc<Mutex<ArrowColumnChunkData>>;
+
+#[derive(Default)]
+struct ArrowPageWriter {
+    buffer: SharedColumnChunk,
+}
+
+impl PageWriter for ArrowPageWriter {
+    fn write_page(&mut self, page: CompressedPage) -> Result<PageWriteSpec> {
+        let mut buf = self.buffer.try_lock().unwrap();
+        let page_header = page.to_thrift_header();
+        let header = {
+            let mut header = Vec::with_capacity(1024);
+            let mut protocol = TCompactOutputProtocol::new(&mut header);
+            page_header.write_to_out_protocol(&mut protocol)?;
+            Bytes::from(header)
+        };
+
+        let data = page.compressed_page().buffer().clone();
+        let compressed_size = data.len() + header.len();
+
+        let mut spec = PageWriteSpec::new();
+        spec.page_type = page.page_type();
+        spec.num_values = page.num_values();
+        spec.uncompressed_size = page.uncompressed_size() + header.len();
+        spec.offset = buf.length as u64;
+        spec.compressed_size = compressed_size;
+        spec.bytes_written = compressed_size as u64;
+
+        buf.length += compressed_size;
+        buf.data.push(header);
+        buf.data.push(data);
+
+        Ok(spec)
+    }
+
+    fn write_metadata(&mut self, _metadata: &ColumnChunkMetaData) -> Result<()> {
+        // Skip writing metadata as won't be copied anyway
+        Ok(())
+    }
+
+    fn close(&mut self) -> Result<()> {
+        Ok(())
+    }
+}
+
+/// A leaf column that can be encoded by [`ArrowColumnWriter`]
+#[derive(Debug)]
+pub struct ArrowLeafColumn(ArrayLevels);
+
+/// Computes the [`ArrowLeafColumn`] for a potentially nested [`ArrayRef`]
+pub fn compute_leaves(field: &Field, array: &ArrayRef) -> Result<Vec<ArrowLeafColumn>> {
+    let levels = calculate_array_levels(array, field)?;
+    Ok(levels.into_iter().map(ArrowLeafColumn).collect())
+}
+
+/// The data for a single column chunk, see [`ArrowColumnWriter`]
+pub struct ArrowColumnChunk {
+    data: ArrowColumnChunkData,
+    close: ColumnCloseResult,
+}
+
+impl std::fmt::Debug for ArrowColumnChunk {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ArrowColumnChunk")
+            .field("length", &self.data.length)
+            .finish_non_exhaustive()
+    }
+}
+
+impl ArrowColumnChunk {
+    /// Calls [`SerializedRowGroupWriter::append_column`] with this column's data
+    pub fn append_to_row_group<W: Write + Send>(
+        self,
+        writer: &mut SerializedRowGroupWriter<'_, W>,
+    ) -> Result<()> {
+        writer.append_column(&self.data, self.close)
+    }
+}
+
+/// Encodes [`ArrowLeafColumn`] to [`ArrowColumnChunk`]
+///
+/// Note: This is a low-level interface for applications that require fine-grained control
+/// of encoding, see [`ArrowWriter`] for a higher-level interface
+///
+/// ```
+/// // The arrow schema
+/// # use std::sync::Arc;
+/// # use arrow_array::*;
+/// # use arrow_schema::*;
+/// # use parquet::arrow::arrow_to_parquet_schema;
+/// # use parquet::arrow::arrow_writer::{ArrowLeafColumn, compute_leaves, get_column_writers};
+/// # use parquet::file::properties::WriterProperties;
+/// # use parquet::file::writer::SerializedFileWriter;
+/// #
+/// let schema = Arc::new(Schema::new(vec![
+///     Field::new("i32", DataType::Int32, false),
+///     Field::new("f32", DataType::Float32, false),
+/// ]));
+///
+/// // Compute the parquet schema
+/// let parquet_schema = arrow_to_parquet_schema(schema.as_ref()).unwrap();
+/// let props = Arc::new(WriterProperties::default());
+///
+/// // Create writers for each of the leaf columns
+/// let col_writers = get_column_writers(&parquet_schema, &props, &schema).unwrap();
+///
+/// // Spawn a worker thread for each column
+/// // This is for demonstration purposes, a thread-pool e.g. rayon or tokio, would be better
+/// let mut workers: Vec<_> = col_writers
+///     .into_iter()
+///     .map(|mut col_writer| {
+///         let (send, recv) = std::sync::mpsc::channel::<ArrowLeafColumn>();
+///         let handle = std::thread::spawn(move || {
+///             for col in recv {
+///                 col_writer.write(&col)?;
+///             }
+///             col_writer.close()
+///         });
+///         (handle, send)
+///     })
+///     .collect();
+///
+/// // Create parquet writer
+/// let root_schema = parquet_schema.root_schema_ptr();
+/// let mut out = Vec::with_capacity(1024); // This could be a File
+/// let mut writer = SerializedFileWriter::new(&mut out, root_schema, props.clone()).unwrap();
+///
+/// // Start row group
+/// let mut row_group = writer.next_row_group().unwrap();
+///
+/// // Columns to encode
+/// let to_write = vec![
+///     Arc::new(Int32Array::from_iter_values([1, 2, 3])) as _,
+///     Arc::new(Float32Array::from_iter_values([1., 45., -1.])) as _,
+/// ];
+///
+/// // Spawn work to encode columns
+/// let mut worker_iter = workers.iter_mut();
+/// for (arr, field) in to_write.iter().zip(&schema.fields) {
+///     for leaves in compute_leaves(field, arr).unwrap() {
+///         worker_iter.next().unwrap().1.send(leaves).unwrap();
+///     }
+/// }
+///
+/// // Finish up parallel column encoding
+/// for (handle, send) in workers {
+///     drop(send); // Drop send side to signal termination
+///     let chunk = handle.join().unwrap().unwrap();
+///     chunk.append_to_row_group(&mut row_group).unwrap();
+/// }
+/// row_group.close().unwrap();
+///
+/// let metadata = writer.close().unwrap();
+/// assert_eq!(metadata.num_rows, 3);
+/// ```
+pub struct ArrowColumnWriter {
+    writer: ArrowColumnWriterImpl,
+    chunk: SharedColumnChunk,
+}
+
+impl std::fmt::Debug for ArrowColumnWriter {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ArrowColumnWriter").finish_non_exhaustive()
+    }
+}
+
+enum ArrowColumnWriterImpl {
+    ByteArray(GenericColumnWriter<'static, ByteArrayEncoder>),
+    Column(ColumnWriter<'static>),
+}
+
+impl ArrowColumnWriter {
+    /// Write an [`ArrowLeafColumn`]
+    pub fn write(&mut self, col: &ArrowLeafColumn) -> Result<()> {
+        match &mut self.writer {
+            ArrowColumnWriterImpl::Column(c) => {
+                write_leaf(c, &col.0)?;
+            }
+            ArrowColumnWriterImpl::ByteArray(c) => {
+                write_primitive(c, col.0.array().as_ref(), &col.0)?;
+            }
+        }
+        Ok(())
+    }
+
+    /// Close this column returning the written [`ArrowColumnChunk`]
+    pub fn close(self) -> Result<ArrowColumnChunk> {
+        let close = match self.writer {
+            ArrowColumnWriterImpl::ByteArray(c) => c.close()?,
+            ArrowColumnWriterImpl::Column(c) => c.close()?,
+        };
+        let chunk = Arc::try_unwrap(self.chunk).ok().unwrap();
+        let data = chunk.into_inner().unwrap();
+        Ok(ArrowColumnChunk { data, close })
+    }
+
+    /// Returns the estimated total bytes for this column writer
+    pub fn get_estimated_total_bytes(&self) -> usize {
+        match &self.writer {
+            ArrowColumnWriterImpl::ByteArray(c) => c.get_estimated_total_bytes() as _,
+            ArrowColumnWriterImpl::Column(c) => c.get_estimated_total_bytes() as _,
         }
+    }
+}
 
-        row_group_writer.close()?;
-        self.buffered_rows -= num_rows;
+/// Encodes [`RecordBatch`] to a parquet row group
+struct ArrowRowGroupWriter {
+    writers: Vec<ArrowColumnWriter>,
+    schema: SchemaRef,
+    buffered_rows: usize,
+}
+
+impl ArrowRowGroupWriter {
+    fn new(
+        parquet: &SchemaDescriptor,
+        props: &WriterPropertiesPtr,
+        arrow: &SchemaRef,
+    ) -> Result<Self> {
+        let writers = get_column_writers(parquet, props, arrow)?;
+        Ok(Self {
+            writers,
+            schema: arrow.clone(),
+            buffered_rows: 0,
+        })
+    }
 
+    fn write(&mut self, batch: &RecordBatch) -> Result<()> {
+        self.buffered_rows += batch.num_rows();
+        let mut writers = self.writers.iter_mut();
+        for (field, column) in self.schema.fields().iter().zip(batch.columns()) {
+            for leaf in compute_leaves(field.as_ref(), column)? {
+                writers.next().unwrap().write(&leaf)?
+            }
+        }
         Ok(())
     }
 
-    /// Close and finalize the underlying Parquet writer
-    pub fn close(mut self) -> Result<parquet_format::FileMetaData> {
-        self.flush()?;
-        self.writer.close()
+    fn close(self) -> Result<Vec<ArrowColumnChunk>> {
+        self.writers
+            .into_iter()
+            .map(|writer| writer.close())
+            .collect()
     }
 }
 
-fn write_leaves<W: Write>(
-    row_group_writer: &mut SerializedRowGroupWriter<'_, W>,
-    arrays: &[ArrayRef],
-    levels: &mut [Vec<LevelInfo>],
+/// Returns the [`ArrowColumnWriter`] for a given schema
+pub fn get_column_writers(
+    parquet: &SchemaDescriptor,
+    props: &WriterPropertiesPtr,
+    arrow: &SchemaRef,
+) -> Result<Vec<ArrowColumnWriter>> {
+    let mut writers = Vec::with_capacity(arrow.fields.len());
+    let mut leaves = parquet.columns().iter();
+    for field in &arrow.fields {
+        get_arrow_column_writer(field.data_type(), props, &mut leaves, &mut writers)?;
+    }
+    Ok(writers)
+}
+
+/// Gets the [`ArrowColumnWriter`] for the given `data_type`
+fn get_arrow_column_writer(
+    data_type: &ArrowDataType,
+    props: &WriterPropertiesPtr,
+    leaves: &mut Iter<'_, ColumnDescPtr>,
+    out: &mut Vec<ArrowColumnWriter>,
 ) -> Result<()> {
-    assert_eq!(arrays.len(), levels.len());
-    assert!(!arrays.is_empty());
-
-    let data_type = arrays.first().unwrap().data_type().clone();
-    assert!(arrays.iter().all(|a| a.data_type() == &data_type));
-
-    match &data_type {
-        ArrowDataType::Null
-        | ArrowDataType::Boolean
-        | ArrowDataType::Int8
-        | ArrowDataType::Int16
-        | ArrowDataType::Int32
-        | ArrowDataType::Int64
-        | ArrowDataType::UInt8
-        | ArrowDataType::UInt16
-        | ArrowDataType::UInt32
-        | ArrowDataType::UInt64
-        | ArrowDataType::Float32
-        | ArrowDataType::Float64
-        | ArrowDataType::Timestamp(_, _)
-        | ArrowDataType::Date32
-        | ArrowDataType::Date64
-        | ArrowDataType::Time32(_)
-        | ArrowDataType::Time64(_)
-        | ArrowDataType::Duration(_)
-        | ArrowDataType::Interval(_)
-        | ArrowDataType::Decimal128(_, _)
-        | ArrowDataType::Decimal256(_, _)
-        | ArrowDataType::FixedSizeBinary(_) => {
-            let mut col_writer = row_group_writer.next_column()?.unwrap();
-            for (array, levels) in arrays.iter().zip(levels.iter_mut()) {
-                write_leaf(col_writer.untyped(), array, levels.pop().expect("Levels exhausted"))?;
-            }
-            col_writer.close()
+    let col = |desc: &ColumnDescPtr| {
+        let page_writer = Box::<ArrowPageWriter>::default();
+        let chunk = page_writer.buffer.clone();
+        let writer = get_column_writer(desc.clone(), props.clone(), page_writer);
+        ArrowColumnWriter {
+            chunk,
+            writer: ArrowColumnWriterImpl::Column(writer),
+        }
+    };
+
+    let bytes = |desc: &ColumnDescPtr| {
+        let page_writer = Box::<ArrowPageWriter>::default();
+        let chunk = page_writer.buffer.clone();
+        let writer = GenericColumnWriter::new(desc.clone(), props.clone(), page_writer);
+        ArrowColumnWriter {
+            chunk,
+            writer: ArrowColumnWriterImpl::ByteArray(writer),
         }
+    };
+
+    match data_type {
+        _ if data_type.is_primitive() => out.push(col(leaves.next().unwrap())),
+        ArrowDataType::FixedSizeBinary(_) | ArrowDataType::Boolean | ArrowDataType::Null => out.push(col(leaves.next().unwrap())),
         ArrowDataType::LargeBinary
         | ArrowDataType::Binary
         | ArrowDataType::Utf8
         | ArrowDataType::LargeUtf8 => {
-            let mut col_writer = row_group_writer.next_column_with_factory(ByteArrayWriter::new)?.unwrap();
-            for (array, levels) in arrays.iter().zip(levels.iter_mut()) {
-                col_writer.write(array, levels.pop().expect("Levels exhausted"))?;
-            }
-            col_writer.close()
+            out.push(bytes(leaves.next().unwrap()))
         }
-        ArrowDataType::List(_) | ArrowDataType::LargeList(_) => {
-            let arrays: Vec<_> = arrays.iter().map(|array|{
-                // write the child list
-                let data = array.data();
-                arrow_array::make_array(data.child_data()[0].clone())
-            }).collect();
-
-            write_leaves(row_group_writer, &arrays, levels)?;
-            Ok(())
+        ArrowDataType::List(f)
+        | ArrowDataType::LargeList(f)
+        | ArrowDataType::FixedSizeList(f, _) => {
+            get_arrow_column_writer(f.data_type(), props, leaves, out)?
         }
         ArrowDataType::Struct(fields) => {
-            // Groups child arrays by field
-            let mut field_arrays = vec![Vec::with_capacity(arrays.len()); fields.len()];
-
-            for array in arrays {
-                let struct_array: &arrow_array::StructArray = array
-                    .as_any()
-                    .downcast_ref::<arrow_array::StructArray>()
-                    .expect("Unable to get struct array");
-
-                assert_eq!(struct_array.columns().len(), fields.len());
-
-                for (child_array, field) in field_arrays.iter_mut().zip(struct_array.columns()) {
-                    child_array.push(field.clone())
-                }
-            }
-
-            for field in field_arrays {
-                write_leaves(row_group_writer, &field, levels)?;
+            for field in fields {
+                get_arrow_column_writer(field.data_type(), props, leaves, out)?
             }
-
-            Ok(())
         }
-        ArrowDataType::Map(_, _) => {
-            let mut keys = Vec::with_capacity(arrays.len());
-            let mut values = Vec::with_capacity(arrays.len());
-            for array in arrays {
-                let map_array: &arrow_array::MapArray = array
-                    .as_any()
-                    .downcast_ref::<arrow_array::MapArray>()
-                    .expect("Unable to get map array");
-                keys.push(map_array.keys());
-                values.push(map_array.values());
+        ArrowDataType::Map(f, _) => match f.data_type() {
+            ArrowDataType::Struct(f) => {
+                get_arrow_column_writer(f[0].data_type(), props, leaves, out)?;
+                get_arrow_column_writer(f[1].data_type(), props, leaves, out)?
             }
-
-            write_leaves(row_group_writer, &keys, levels)?;
-            write_leaves(row_group_writer, &values, levels)?;
-            Ok(())
+            _ => unreachable!("invalid map type"),
         }
         ArrowDataType::Dictionary(_, value_type) => match value_type.as_ref() {
             ArrowDataType::Utf8 | ArrowDataType::LargeUtf8 | ArrowDataType::Binary | ArrowDataType::LargeBinary => {
-                let mut col_writer = row_group_writer.next_column_with_factory(ByteArrayWriter::new)?.unwrap();
-                for (array, levels) in arrays.iter().zip(levels.iter_mut()) {
-                    col_writer.write(array, levels.pop().expect("Levels exhausted"))?;
-                }
-                col_writer.close()
+                out.push(bytes(leaves.next().unwrap()))
             }
             _ => {
-                let mut col_writer = row_group_writer.next_column()?.unwrap();
-                for (array, levels) in arrays.iter().zip(levels.iter_mut()) {
-                    write_leaf(col_writer.untyped(), array, levels.pop().expect("Levels exhausted"))?;
-                }
-                col_writer.close()
+                out.push(col(leaves.next().unwrap()))
             }
         }
-        ArrowDataType::Float16 => Err(ParquetError::ArrowError(
-            "Float16 arrays not supported".to_string(),
-        )),
-        ArrowDataType::FixedSizeList(_, _) | ArrowDataType::Union(_, _, _) => {
-            Err(ParquetError::NYI(
-                format!(
-                    "Attempting to write an Arrow type {:?} to parquet that is not yet implemented",
-                    data_type
-                )
-            ))
-        }
+       _ => return Err(ParquetError::NYI(
+           format!(
+               "Attempting to write an Arrow type {data_type:?} to parquet that is not yet implemented"
+           )
+       ))
     }
+    Ok(())
 }
 
-fn write_leaf(
-    writer: &mut ColumnWriter<'_>,
-    column: &ArrayRef,
-    levels: LevelInfo,
-) -> Result<i64> {
+fn write_leaf(writer: &mut ColumnWriter<'_>, levels: &ArrayLevels) -> Result<usize> {
+    let column = levels.array().as_ref();
     let indices = levels.non_null_indices();
-    let written = match writer {
+    match writer {
         ColumnWriter::Int32ColumnWriter(ref mut typed) => {
             match column.data_type() {
                 ArrowDataType::Date64 => {
                     // If the column is a Date64, we cast it to a Date32, and then interpret that as Int32
-                    let array = arrow::compute::cast(column, &ArrowDataType::Date32)?;
-                    let array = arrow::compute::cast(&array, &ArrowDataType::Int32)?;
+                    let array = arrow_cast::cast(column, &ArrowDataType::Date32)?;
+                    let array = arrow_cast::cast(&array, &ArrowDataType::Int32)?;
 
-                    let array = array
-                        .as_any()
-                        .downcast_ref::<arrow_array::Int32Array>()
-                        .expect("Unable to get int32 array");
-                    write_primitive(typed, array.values(), levels)?
+                    let array = array.as_primitive::<Int32Type>();
+                    write_primitive(typed, array.values(), levels)
                 }
                 ArrowDataType::UInt32 => {
-                    let data = column.data();
-                    let offset = data.offset();
+                    let values = column.as_primitive::<UInt32Type>().values();
                     // follow C++ implementation and use overflow/reinterpret cast from  u32 to i32 which will map
                     // `(i32::MAX as u32)..u32::MAX` to `i32::MIN..0`
-                    let array: &[i32] = data.buffers()[0].typed_data();
-                    write_primitive(typed, &array[offset..offset + data.len()], levels)?
+                    let array = values.inner().typed_data::<i32>();
+                    write_primitive(typed, array, levels)
+                }
+                ArrowDataType::Decimal128(_, _) => {
+                    // use the int32 to represent the decimal with low precision
+                    let array = column
+                        .as_primitive::<Decimal128Type>()
+                        .unary::<_, Int32Type>(|v| v as i32);
+                    write_primitive(typed, array.values(), levels)
+                }
+                ArrowDataType::Decimal256(_, _) => {
+                    // use the int32 to represent the decimal with low precision
+                    let array = column
+                        .as_primitive::<Decimal256Type>()
+                        .unary::<_, Int32Type>(|v| v.as_i128() as i32);
+                    write_primitive(typed, array.values(), levels)
                 }
                 _ => {
-                    let array = arrow::compute::cast(column, &ArrowDataType::Int32)?;
-                    let array = array
-                        .as_any()
-                        .downcast_ref::<arrow_array::Int32Array>()
-                        .expect("Unable to get i32 array");
-                    write_primitive(typed, array.values(), levels)?
+                    let array = arrow_cast::cast(column, &ArrowDataType::Int32)?;
+                    let array = array.as_primitive::<Int32Type>();
+                    write_primitive(typed, array.values(), levels)
                 }
             }
         }
         ColumnWriter::BoolColumnWriter(ref mut typed) => {
-            let array = column
-                .as_any()
-                .downcast_ref::<arrow_array::BooleanArray>()
-                .expect("Unable to get boolean array");
+            let array = column.as_boolean();
             typed.write_batch(
                 get_bool_array_slice(array, indices).as_slice(),
                 levels.def_levels(),
                 levels.rep_levels(),
-            )?
+            )
         }
         ColumnWriter::Int64ColumnWriter(ref mut typed) => {
             match column.data_type() {
                 ArrowDataType::Int64 => {
-                    let array = column
-                        .as_any()
-                        .downcast_ref::<arrow_array::Int64Array>()
-                        .expect("Unable to get i64 array");
-                    write_primitive(typed, array.values(), levels)?
+                    let array = column.as_primitive::<Int64Type>();
+                    write_primitive(typed, array.values(), levels)
                 }
                 ArrowDataType::UInt64 => {
+                    let values = column.as_primitive::<UInt64Type>().values();
                     // follow C++ implementation and use overflow/reinterpret cast from  u64 to i64 which will map
                     // `(i64::MAX as u64)..u64::MAX` to `i64::MIN..0`
-                    let data = column.data();
-                    let offset = data.offset();
-                    let array: &[i64] = data.buffers()[0].typed_data();
-                    write_primitive(typed, &array[offset..offset + data.len()], levels)?
+                    let array = values.inner().typed_data::<i64>();
+                    write_primitive(typed, array, levels)
+                }
+                ArrowDataType::Decimal128(_, _) => {
+                    // use the int64 to represent the decimal with low precision
+                    let array = column
+                        .as_primitive::<Decimal128Type>()
+                        .unary::<_, Int64Type>(|v| v as i64);
+                    write_primitive(typed, array.values(), levels)
+                }
+                ArrowDataType::Decimal256(_, _) => {
+                    // use the int64 to represent the decimal with low precision
+                    let array = column
+                        .as_primitive::<Decimal256Type>()
+                        .unary::<_, Int64Type>(|v| v.as_i128() as i64);
+                    write_primitive(typed, array.values(), levels)
                 }
                 _ => {
-                    let array = arrow::compute::cast(column, &ArrowDataType::Int64)?;
-                    let array = array
-                        .as_any()
-                        .downcast_ref::<arrow_array::Int64Array>()
-                        .expect("Unable to get i64 array");
-                    write_primitive(typed, array.values(), levels)?
+                    let array = arrow_cast::cast(column, &ArrowDataType::Int64)?;
+                    let array = array.as_primitive::<Int64Type>();
+                    write_primitive(typed, array.values(), levels)
                 }
             }
         }
@@ -439,18 +773,12 @@ fn write_leaf(
             unreachable!("Currently unreachable because data type not supported")
         }
         ColumnWriter::FloatColumnWriter(ref mut typed) => {
-            let array = column
-                .as_any()
-                .downcast_ref::<arrow_array::Float32Array>()
-                .expect("Unable to get Float32 array");
-            write_primitive(typed, array.values(), levels)?
+            let array = column.as_primitive::<Float32Type>();
+            write_primitive(typed, array.values(), levels)
         }
         ColumnWriter::DoubleColumnWriter(ref mut typed) => {
-            let array = column
-                .as_any()
-                .downcast_ref::<arrow_array::Float64Array>()
-                .expect("Unable to get Float64 array");
-            write_primitive(typed, array.values(), levels)?
+            let array = column.as_primitive::<Float64Type>();
+            write_primitive(typed, array.values(), levels)
         }
         ColumnWriter::ByteArrayColumnWriter(_) => {
             unreachable!("should use ByteArrayWriter")
@@ -475,8 +803,7 @@ fn write_leaf(
                     _ => {
                         return Err(ParquetError::NYI(
                             format!(
-                                "Attempting to write an Arrow interval type {:?} to parquet that is not yet implemented",
-                                interval_unit
+                                "Attempting to write an Arrow interval type {interval_unit:?} to parquet that is not yet implemented"
                             )
                         ));
                     }
@@ -489,33 +816,35 @@ fn write_leaf(
                     get_fsb_array_slice(array, indices)
                 }
                 ArrowDataType::Decimal128(_, _) => {
+                    let array = column.as_primitive::<Decimal128Type>();
+                    get_decimal_128_array_slice(array, indices)
+                }
+                ArrowDataType::Decimal256(_, _) => {
                     let array = column
                         .as_any()
-                        .downcast_ref::<arrow_array::Decimal128Array>()
+                        .downcast_ref::<arrow_array::Decimal256Array>()
                         .unwrap();
-                    get_decimal_array_slice(array, indices)
+                    get_decimal_256_array_slice(array, indices)
+                }
+                ArrowDataType::Float16 => {
+                    let array = column.as_primitive::<Float16Type>();
+                    get_float_16_array_slice(array, indices)
                 }
                 _ => {
                     return Err(ParquetError::NYI(
-                        "Attempting to write an Arrow type that is not yet implemented"
-                            .to_string(),
+                        "Attempting to write an Arrow type that is not yet implemented".to_string(),
                     ));
                 }
             };
-            typed.write_batch(
-                bytes.as_slice(),
-                levels.def_levels(),
-                levels.rep_levels(),
-            )?
+            typed.write_batch(bytes.as_slice(), levels.def_levels(), levels.rep_levels())
         }
-    };
-    Ok(written as i64)
+    }
 }
 
-fn write_primitive<'a, T: DataType>(
-    writer: &mut ColumnWriterImpl<'a, T>,
-    values: &[T::T],
-    levels: LevelInfo,
+fn write_primitive<E: ColumnValueEncoder>(
+    writer: &mut GenericColumnWriter<E>,
+    values: &E::Values,
+    levels: &ArrayLevels,
 ) -> Result<usize> {
     writer.write_batch_internal(
         values,
@@ -528,10 +857,7 @@ fn write_primitive<'a, T: DataType>(
     )
 }
 
-fn get_bool_array_slice(
-    array: &arrow_array::BooleanArray,
-    indices: &[usize],
-) -> Vec<bool> {
+fn get_bool_array_slice(array: &arrow_array::BooleanArray, indices: &[usize]) -> Vec<bool> {
     let mut values = Vec::with_capacity(indices.len());
     for i in indices {
         values.push(array.value(*i))
@@ -572,20 +898,46 @@ fn get_interval_dt_array_slice(
     values
 }
 
-fn get_decimal_array_slice(
+fn get_decimal_128_array_slice(
     array: &arrow_array::Decimal128Array,
     indices: &[usize],
 ) -> Vec<FixedLenByteArray> {
     let mut values = Vec::with_capacity(indices.len());
     let size = decimal_length_from_precision(array.precision());
     for i in indices {
-        let as_be_bytes = array.value(*i).as_i128().to_be_bytes();
+        let as_be_bytes = array.value(*i).to_be_bytes();
         let resized_value = as_be_bytes[(16 - size)..].to_vec();
         values.push(FixedLenByteArray::from(ByteArray::from(resized_value)));
     }
     values
 }
 
+fn get_decimal_256_array_slice(
+    array: &arrow_array::Decimal256Array,
+    indices: &[usize],
+) -> Vec<FixedLenByteArray> {
+    let mut values = Vec::with_capacity(indices.len());
+    let size = decimal_length_from_precision(array.precision());
+    for i in indices {
+        let as_be_bytes = array.value(*i).to_be_bytes();
+        let resized_value = as_be_bytes[(32 - size)..].to_vec();
+        values.push(FixedLenByteArray::from(ByteArray::from(resized_value)));
+    }
+    values
+}
+
+fn get_float_16_array_slice(
+    array: &arrow_array::Float16Array,
+    indices: &[usize],
+) -> Vec<FixedLenByteArray> {
+    let mut values = Vec::with_capacity(indices.len());
+    for i in indices {
+        let value = array.value(*i).to_le_bytes().to_vec();
+        values.push(FixedLenByteArray::from(ByteArray::from(value)));
+    }
+    values
+}
+
 fn get_fsb_array_slice(
     array: &arrow_array::FixedSizeBinaryArray,
     indices: &[usize],
@@ -606,17 +958,24 @@ mod tests {
     use std::fs::File;
     use std::sync::Arc;
 
+    use crate::arrow::arrow_reader::{ParquetRecordBatchReader, ParquetRecordBatchReaderBuilder};
+    use crate::arrow::ARROW_SCHEMA_META_KEY;
     use arrow::datatypes::ToByteSlice;
     use arrow::datatypes::{DataType, Field, Schema, UInt32Type, UInt8Type};
     use arrow::error::Result as ArrowResult;
-    use arrow::record_batch::RecordBatch;
     use arrow::util::pretty::pretty_format_batches;
     use arrow::{array::*, buffer::Buffer};
+    use arrow_array::RecordBatch;
+    use arrow_buffer::NullBuffer;
+    use arrow_schema::Fields;
 
-    use crate::arrow::{ArrowReader, ParquetFileArrowReader};
     use crate::basic::Encoding;
+    use crate::data_type::AsBytes;
     use crate::file::metadata::ParquetMetaData;
-    use crate::file::properties::WriterVersion;
+    use crate::file::page_index::index::Index;
+    use crate::file::page_index::index_reader::read_pages_locations;
+    use crate::file::properties::{EnabledStatistics, ReaderProperties, WriterVersion};
+    use crate::file::serialized_reader::ReadOptionsBuilder;
     use crate::file::{
         reader::{FileReader, SerializedFileReader},
         statistics::Statistics,
@@ -635,13 +994,27 @@ mod tests {
         let b = Int32Array::from(vec![Some(1), None, None, Some(4), Some(5)]);
 
         // build a record batch
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)])
-                .unwrap();
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a), Arc::new(b)]).unwrap();
 
         roundtrip(batch, Some(SMALL_SIZE / 2));
     }
 
+    fn get_bytes_after_close(schema: SchemaRef, expected_batch: &RecordBatch) -> Vec<u8> {
+        let mut buffer = vec![];
+
+        let mut writer = ArrowWriter::try_new(&mut buffer, schema, None).unwrap();
+        writer.write(expected_batch).unwrap();
+        writer.close().unwrap();
+
+        buffer
+    }
+
+    fn get_bytes_by_into_inner(schema: SchemaRef, expected_batch: &RecordBatch) -> Vec<u8> {
+        let mut writer = ArrowWriter::try_new(Vec::new(), schema, None).unwrap();
+        writer.write(expected_batch).unwrap();
+        writer.into_inner().unwrap()
+    }
+
     #[test]
     fn roundtrip_bytes() {
         // define schema
@@ -658,31 +1031,27 @@ mod tests {
         let expected_batch =
             RecordBatch::try_new(schema.clone(), vec![Arc::new(a), Arc::new(b)]).unwrap();
 
-        let mut buffer = vec![];
-
-        {
-            let mut writer = ArrowWriter::try_new(&mut buffer, schema, None).unwrap();
-            writer.write(&expected_batch).unwrap();
-            writer.close().unwrap();
-        }
-
-        let cursor = Bytes::from(buffer);
-        let mut arrow_reader = ParquetFileArrowReader::try_new(cursor).unwrap();
-        let mut record_batch_reader = arrow_reader.get_record_reader(1024).unwrap();
-
-        let actual_batch = record_batch_reader
-            .next()
-            .expect("No batch found")
-            .expect("Unable to get batch");
-
-        assert_eq!(expected_batch.schema(), actual_batch.schema());
-        assert_eq!(expected_batch.num_columns(), actual_batch.num_columns());
-        assert_eq!(expected_batch.num_rows(), actual_batch.num_rows());
-        for i in 0..expected_batch.num_columns() {
-            let expected_data = expected_batch.column(i).data().clone();
-            let actual_data = actual_batch.column(i).data().clone();
-
-            assert_eq!(expected_data, actual_data);
+        for buffer in [
+            get_bytes_after_close(schema.clone(), &expected_batch),
+            get_bytes_by_into_inner(schema, &expected_batch),
+        ] {
+            let cursor = Bytes::from(buffer);
+            let mut record_batch_reader = ParquetRecordBatchReader::try_new(cursor, 1024).unwrap();
+
+            let actual_batch = record_batch_reader
+                .next()
+                .expect("No batch found")
+                .expect("Unable to get batch");
+
+            assert_eq!(expected_batch.schema(), actual_batch.schema());
+            assert_eq!(expected_batch.num_columns(), actual_batch.num_columns());
+            assert_eq!(expected_batch.num_rows(), actual_batch.num_rows());
+            for i in 0..expected_batch.num_columns() {
+                let expected_data = expected_batch.column(i).to_data();
+                let actual_data = actual_batch.column(i).to_data();
+
+                assert_eq!(expected_data, actual_data);
+            }
         }
     }
 
@@ -705,7 +1074,7 @@ mod tests {
         // define schema
         let schema = Schema::new(vec![Field::new(
             "a",
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false))),
+            DataType::List(Arc::new(Field::new("item", DataType::Int32, false))),
             true,
         )]);
 
@@ -714,11 +1083,10 @@ mod tests {
 
         // Construct a buffer for value offsets, for the nested array:
         //  [[1], [2, 3], null, [4, 5, 6], [7, 8, 9, 10]]
-        let a_value_offsets =
-            arrow::buffer::Buffer::from(&[0, 1, 3, 3, 6, 10].to_byte_slice());
+        let a_value_offsets = arrow::buffer::Buffer::from(&[0, 1, 3, 3, 6, 10].to_byte_slice());
 
         // Construct a list array from the above two
-        let a_list_data = ArrayData::builder(DataType::List(Box::new(Field::new(
+        let a_list_data = ArrayData::builder(DataType::List(Arc::new(Field::new(
             "item",
             DataType::Int32,
             false,
@@ -734,7 +1102,7 @@ mod tests {
         // build a record batch
         let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap();
 
-        assert_eq!(batch.column(0).data().null_count(), 1);
+        assert_eq!(batch.column(0).null_count(), 1);
 
         // This test fails if the max row group size is less than the batch's length
         // see https://github.com/apache/arrow-rs/issues/518
@@ -746,7 +1114,7 @@ mod tests {
         // define schema
         let schema = Schema::new(vec![Field::new(
             "a",
-            DataType::List(Box::new(Field::new("item", DataType::Int32, false))),
+            DataType::List(Arc::new(Field::new("item", DataType::Int32, false))),
             false,
         )]);
 
@@ -755,11 +1123,10 @@ mod tests {
 
         // Construct a buffer for value offsets, for the nested array:
         //  [[1], [2, 3], [], [4, 5, 6], [7, 8, 9, 10]]
-        let a_value_offsets =
-            arrow::buffer::Buffer::from(&[0, 1, 3, 3, 6, 10].to_byte_slice());
+        let a_value_offsets = arrow::buffer::Buffer::from(&[0, 1, 3, 3, 6, 10].to_byte_slice());
 
         // Construct a list array from the above two
-        let a_list_data = ArrayData::builder(DataType::List(Box::new(Field::new(
+        let a_list_data = ArrayData::builder(DataType::List(Arc::new(Field::new(
             "item",
             DataType::Int32,
             false,
@@ -776,7 +1143,7 @@ mod tests {
 
         // This test fails if the max row group size is less than the batch's length
         // see https://github.com/apache/arrow-rs/issues/518
-        assert_eq!(batch.column(0).data().null_count(), 0);
+        assert_eq!(batch.column(0).null_count(), 0);
 
         roundtrip(batch, None);
     }
@@ -810,55 +1177,63 @@ mod tests {
         roundtrip(batch, Some(SMALL_SIZE / 2));
     }
 
-    #[test]
-    fn arrow_writer_decimal() {
-        let decimal_field = Field::new("a", DataType::Decimal128(5, 2), false);
+    fn get_decimal_batch(precision: u8, scale: i8) -> RecordBatch {
+        let decimal_field = Field::new("a", DataType::Decimal128(precision, scale), false);
         let schema = Schema::new(vec![decimal_field]);
 
         let decimal_values = vec![10_000, 50_000, 0, -100]
             .into_iter()
             .map(Some)
             .collect::<Decimal128Array>()
-            .with_precision_and_scale(5, 2)
+            .with_precision_and_scale(precision, scale)
             .unwrap();
 
-        let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(decimal_values)])
-                .unwrap();
+        RecordBatch::try_new(Arc::new(schema), vec![Arc::new(decimal_values)]).unwrap()
+    }
 
-        roundtrip(batch, Some(SMALL_SIZE / 2));
+    #[test]
+    fn arrow_writer_decimal() {
+        // int32 to store the decimal value
+        let batch_int32_decimal = get_decimal_batch(5, 2);
+        roundtrip(batch_int32_decimal, Some(SMALL_SIZE / 2));
+        // int64 to store the decimal value
+        let batch_int64_decimal = get_decimal_batch(12, 2);
+        roundtrip(batch_int64_decimal, Some(SMALL_SIZE / 2));
+        // fixed_length_byte_array to store the decimal value
+        let batch_fixed_len_byte_array_decimal = get_decimal_batch(30, 2);
+        roundtrip(batch_fixed_len_byte_array_decimal, Some(SMALL_SIZE / 2));
     }
 
     #[test]
     fn arrow_writer_complex() {
         // define schema
-        let struct_field_d = Field::new("d", DataType::Float64, true);
-        let struct_field_f = Field::new("f", DataType::Float32, true);
-        let struct_field_g = Field::new(
+        let struct_field_d = Arc::new(Field::new("d", DataType::Float64, true));
+        let struct_field_f = Arc::new(Field::new("f", DataType::Float32, true));
+        let struct_field_g = Arc::new(Field::new_list(
             "g",
-            DataType::List(Box::new(Field::new("item", DataType::Int16, true))),
+            Field::new("item", DataType::Int16, true),
             false,
-        );
-        let struct_field_h = Field::new(
+        ));
+        let struct_field_h = Arc::new(Field::new_list(
             "h",
-            DataType::List(Box::new(Field::new("item", DataType::Int16, false))),
+            Field::new("item", DataType::Int16, false),
             true,
-        );
-        let struct_field_e = Field::new(
+        ));
+        let struct_field_e = Arc::new(Field::new_struct(
             "e",
-            DataType::Struct(vec![
+            vec![
                 struct_field_f.clone(),
                 struct_field_g.clone(),
                 struct_field_h.clone(),
-            ]),
+            ],
             false,
-        );
+        ));
         let schema = Schema::new(vec![
             Field::new("a", DataType::Int32, false),
             Field::new("b", DataType::Int32, true),
-            Field::new(
+            Field::new_struct(
                 "c",
-                DataType::Struct(vec![struct_field_d.clone(), struct_field_e.clone()]),
+                vec![struct_field_d.clone(), struct_field_e.clone()],
                 false,
             ),
         ]);
@@ -873,14 +1248,13 @@ mod tests {
 
         // Construct a buffer for value offsets, for the nested array:
         //  [[1], [2, 3], [], [4, 5, 6], [7, 8, 9, 10]]
-        let g_value_offsets =
-            arrow::buffer::Buffer::from(&[0, 1, 3, 3, 6, 10].to_byte_slice());
+        let g_value_offsets = arrow::buffer::Buffer::from(&[0, 1, 3, 3, 6, 10].to_byte_slice());
 
         // Construct a list array from the above two
         let g_list_data = ArrayData::builder(struct_field_g.data_type().clone())
             .len(5)
             .add_buffer(g_value_offsets.clone())
-            .add_child_data(g_value.data().clone())
+            .add_child_data(g_value.to_data())
             .build()
             .unwrap();
         let g = ListArray::from(g_list_data);
@@ -888,7 +1262,7 @@ mod tests {
         let h_list_data = ArrayData::builder(struct_field_h.data_type().clone())
             .len(5)
             .add_buffer(g_value_offsets)
-            .add_child_data(g_value.data().clone())
+            .add_child_data(g_value.to_data())
             .null_bit_buffer(Some(Buffer::from(vec![0b00011011])))
             .build()
             .unwrap();
@@ -922,16 +1296,16 @@ mod tests {
         // It was subsequently fixed while investigating https://github.com/apache/arrow-rs/issues/245.
 
         // define schema
-        let offset_field = Field::new("offset", DataType::Int32, false);
-        let partition_field = Field::new("partition", DataType::Int64, true);
-        let topic_field = Field::new("topic", DataType::Utf8, true);
+        let offset_field = Arc::new(Field::new("offset", DataType::Int32, false));
+        let partition_field = Arc::new(Field::new("partition", DataType::Int64, true));
+        let topic_field = Arc::new(Field::new("topic", DataType::Utf8, true));
         let schema = Schema::new(vec![Field::new(
             "some_nested_object",
-            DataType::Struct(vec![
+            DataType::Struct(Fields::from(vec![
                 offset_field.clone(),
                 partition_field.clone(),
                 topic_field.clone(),
-            ]),
+            ])),
             false,
         )]);
 
@@ -948,8 +1322,7 @@ mod tests {
 
         // build a record batch
         let batch =
-            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(some_nested_object)])
-                .unwrap();
+            RecordBatch::try_new(Arc::new(schema), vec![Arc::new(some_nested_object)]).unwrap();
 
         roundtrip(batch, Some(SMALL_SIZE / 2));
     }
@@ -962,22 +1335,20 @@ mod tests {
         {"stocks":{"long": null, "long": "$CCC", "short": null}}
         {"stocks":{"hedged": "$YYY", "long": null, "short": "$D"}}
         "#;
-        let entries_struct_type = DataType::Struct(vec![
+        let entries_struct_type = DataType::Struct(Fields::from(vec![
             Field::new("key", DataType::Utf8, false),
             Field::new("value", DataType::Utf8, true),
-        ]);
+        ]));
         let stocks_field = Field::new(
             "stocks",
             DataType::Map(
-                Box::new(Field::new("entries", entries_struct_type, false)),
+                Arc::new(Field::new("entries", entries_struct_type, false)),
                 false,
             ),
             true,
         );
         let schema = Arc::new(Schema::new(vec![stocks_field]));
-        let builder = arrow::json::ReaderBuilder::new()
-            .with_schema(schema)
-            .with_batch_size(64);
+        let builder = arrow::json::ReaderBuilder::new(schema).with_batch_size(64);
         let mut reader = builder.build(std::io::Cursor::new(json_content)).unwrap();
 
         let batch = reader.next().unwrap().unwrap();
@@ -988,8 +1359,9 @@ mod tests {
     fn arrow_writer_2_level_struct() {
         // tests writing <struct<struct<primitive>>
         let field_c = Field::new("c", DataType::Int32, true);
-        let field_b = Field::new("b", DataType::Struct(vec![field_c]), true);
-        let field_a = Field::new("a", DataType::Struct(vec![field_b.clone()]), true);
+        let field_b = Field::new("b", DataType::Struct(vec![field_c].into()), true);
+        let type_a = DataType::Struct(vec![field_b.clone()].into());
+        let field_a = Field::new("a", type_a, true);
         let schema = Schema::new(vec![field_a.clone()]);
 
         // create data
@@ -1022,19 +1394,21 @@ mod tests {
     fn arrow_writer_2_level_struct_non_null() {
         // tests writing <struct<struct<primitive>>
         let field_c = Field::new("c", DataType::Int32, false);
-        let field_b = Field::new("b", DataType::Struct(vec![field_c]), false);
-        let field_a = Field::new("a", DataType::Struct(vec![field_b.clone()]), false);
-        let schema = Schema::new(vec![field_a.clone()]);
+        let type_b = DataType::Struct(vec![field_c].into());
+        let field_b = Field::new("b", type_b.clone(), false);
+        let type_a = DataType::Struct(vec![field_b].into());
+        let field_a = Field::new("a", type_a.clone(), false);
+        let schema = Schema::new(vec![field_a]);
 
         // create data
         let c = Int32Array::from(vec![1, 2, 3, 4, 5, 6]);
-        let b_data = ArrayDataBuilder::new(field_b.data_type().clone())
+        let b_data = ArrayDataBuilder::new(type_b)
             .len(6)
             .add_child_data(c.into_data())
             .build()
             .unwrap();
         let b = StructArray::from(b_data);
-        let a_data = ArrayDataBuilder::new(field_a.data_type().clone())
+        let a_data = ArrayDataBuilder::new(type_a)
             .len(6)
             .add_child_data(b.into_data())
             .build()
@@ -1054,13 +1428,15 @@ mod tests {
     fn arrow_writer_2_level_struct_mixed_null() {
         // tests writing <struct<struct<primitive>>
         let field_c = Field::new("c", DataType::Int32, false);
-        let field_b = Field::new("b", DataType::Struct(vec![field_c]), true);
-        let field_a = Field::new("a", DataType::Struct(vec![field_b.clone()]), false);
-        let schema = Schema::new(vec![field_a.clone()]);
+        let type_b = DataType::Struct(vec![field_c].into());
+        let field_b = Field::new("b", type_b.clone(), true);
+        let type_a = DataType::Struct(vec![field_b].into());
+        let field_a = Field::new("a", type_a.clone(), false);
+        let schema = Schema::new(vec![field_a]);
 
         // create data
         let c = Int32Array::from(vec![1, 2, 3, 4, 5, 6]);
-        let b_data = ArrayDataBuilder::new(field_b.data_type().clone())
+        let b_data = ArrayDataBuilder::new(type_b)
             .len(6)
             .null_bit_buffer(Some(Buffer::from(vec![0b00100111])))
             .add_child_data(c.into_data())
@@ -1068,7 +1444,7 @@ mod tests {
             .unwrap();
         let b = StructArray::from(b_data);
         // a intentionally has no null buffer, to test that this is handled correctly
-        let a_data = ArrayDataBuilder::new(field_a.data_type().clone())
+        let a_data = ArrayDataBuilder::new(type_a)
             .len(6)
             .add_child_data(b.into_data())
             .build()
@@ -1084,12 +1460,73 @@ mod tests {
         roundtrip(batch, Some(SMALL_SIZE / 2));
     }
 
+    #[test]
+    fn arrow_writer_page_size() {
+        let schema = Arc::new(Schema::new(vec![Field::new("col", DataType::Utf8, false)]));
+
+        let mut builder = StringBuilder::with_capacity(100, 329 * 10_000);
+
+        // Generate an array of 10 unique 10 character string
+        for i in 0..10 {
+            let value = i
+                .to_string()
+                .repeat(10)
+                .chars()
+                .take(10)
+                .collect::<String>();
+
+            builder.append_value(value);
+        }
+
+        let array = Arc::new(builder.finish());
+
+        let batch = RecordBatch::try_new(schema, vec![array]).unwrap();
+
+        let file = tempfile::tempfile().unwrap();
+
+        // Set everything very low so we fallback to PLAIN encoding after the first row
+        let props = WriterProperties::builder()
+            .set_data_page_size_limit(1)
+            .set_dictionary_page_size_limit(1)
+            .set_write_batch_size(1)
+            .build();
+
+        let mut writer =
+            ArrowWriter::try_new(file.try_clone().unwrap(), batch.schema(), Some(props))
+                .expect("Unable to write file");
+        writer.write(&batch).unwrap();
+        writer.close().unwrap();
+
+        let reader = SerializedFileReader::new(file.try_clone().unwrap()).unwrap();
+
+        let column = reader.metadata().row_group(0).columns();
+
+        assert_eq!(column.len(), 1);
+
+        // We should write one row before falling back to PLAIN encoding so there should still be a
+        // dictionary page.
+        assert!(
+            column[0].dictionary_page_offset().is_some(),
+            "Expected a dictionary page"
+        );
+
+        let page_locations = read_pages_locations(&file, column).unwrap();
+
+        let offset_index = page_locations[0].clone();
+
+        // We should fallback to PLAIN encoding after the first row and our max page size is 1 bytes
+        // so we expect one dictionary encoded page and then a page per row thereafter.
+        assert_eq!(
+            offset_index.len(),
+            10,
+            "Expected 9 pages but got {offset_index:#?}"
+        );
+    }
+
     const SMALL_SIZE: usize = 7;
+    const MEDIUM_SIZE: usize = 63;
 
-    fn roundtrip(
-        expected_batch: RecordBatch,
-        max_row_group_size: Option<usize>,
-    ) -> Vec<File> {
+    fn roundtrip(expected_batch: RecordBatch, max_row_group_size: Option<usize>) -> Vec<File> {
         let mut files = vec![];
         for version in [WriterVersion::PARQUET_1_0, WriterVersion::PARQUET_2_0] {
             let mut props = WriterProperties::builder().set_writer_version(version);
@@ -1104,7 +1541,14 @@ mod tests {
         files
     }
 
-    fn roundtrip_opts(expected_batch: &RecordBatch, props: WriterProperties) -> File {
+    fn roundtrip_opts_with_array_validation<F>(
+        expected_batch: &RecordBatch,
+        props: WriterProperties,
+        validate: F,
+    ) -> File
+    where
+        F: Fn(&ArrayData, &ArrayData),
+    {
         let file = tempfile::tempfile().unwrap();
 
         let mut writer = ArrowWriter::try_new(
@@ -1116,9 +1560,8 @@ mod tests {
         writer.write(expected_batch).unwrap();
         writer.close().unwrap();
 
-        let mut arrow_reader =
-            ParquetFileArrowReader::try_new(file.try_clone().unwrap()).unwrap();
-        let mut record_batch_reader = arrow_reader.get_record_reader(1024).unwrap();
+        let mut record_batch_reader =
+            ParquetRecordBatchReader::try_new(file.try_clone().unwrap(), 1024).unwrap();
 
         let actual_batch = record_batch_reader
             .next()
@@ -1129,34 +1572,61 @@ mod tests {
         assert_eq!(expected_batch.num_columns(), actual_batch.num_columns());
         assert_eq!(expected_batch.num_rows(), actual_batch.num_rows());
         for i in 0..expected_batch.num_columns() {
-            let expected_data = expected_batch.column(i).data();
-            let actual_data = actual_batch.column(i).data();
-
-            assert_eq!(expected_data, actual_data);
+            let expected_data = expected_batch.column(i).to_data();
+            let actual_data = actual_batch.column(i).to_data();
+            validate(&expected_data, &actual_data);
         }
 
         file
     }
 
-    fn one_column_roundtrip(values: ArrayRef, nullable: bool) -> Vec<File> {
-        let data_type = values.data_type().clone();
-        let schema = Schema::new(vec![Field::new("col", data_type, nullable)]);
-        one_column_roundtrip_with_schema(values, Arc::new(schema))
+    fn roundtrip_opts(expected_batch: &RecordBatch, props: WriterProperties) -> File {
+        roundtrip_opts_with_array_validation(expected_batch, props, |a, b| assert_eq!(a, b))
     }
 
-    fn one_column_roundtrip_with_schema(
+    struct RoundTripOptions {
         values: ArrayRef,
         schema: SchemaRef,
-    ) -> Vec<File> {
+        bloom_filter: bool,
+    }
+
+    impl RoundTripOptions {
+        fn new(values: ArrayRef, nullable: bool) -> Self {
+            let data_type = values.data_type().clone();
+            let schema = Schema::new(vec![Field::new("col", data_type, nullable)]);
+            Self {
+                values,
+                schema: Arc::new(schema),
+                bloom_filter: false,
+            }
+        }
+    }
+
+    fn one_column_roundtrip(values: ArrayRef, nullable: bool) -> Vec<File> {
+        one_column_roundtrip_with_options(RoundTripOptions::new(values, nullable))
+    }
+
+    fn one_column_roundtrip_with_schema(values: ArrayRef, schema: SchemaRef) -> Vec<File> {
+        let mut options = RoundTripOptions::new(values, false);
+        options.schema = schema;
+        one_column_roundtrip_with_options(options)
+    }
+
+    fn one_column_roundtrip_with_options(options: RoundTripOptions) -> Vec<File> {
+        let RoundTripOptions {
+            values,
+            schema,
+            bloom_filter,
+        } = options;
+
         let encodings = match values.data_type() {
-            DataType::Utf8
-            | DataType::LargeUtf8
-            | DataType::Binary
-            | DataType::LargeBinary => vec![
-                Encoding::PLAIN,
-                Encoding::DELTA_BYTE_ARRAY,
-                Encoding::DELTA_LENGTH_BYTE_ARRAY,
-            ],
+            DataType::Utf8 | DataType::LargeUtf8 | DataType::Binary | DataType::LargeBinary => {
+                vec![
+                    Encoding::PLAIN,
+                    Encoding::DELTA_BYTE_ARRAY,
+                    Encoding::DELTA_LENGTH_BYTE_ARRAY,
+                ]
+            }
             DataType::Int64
             | DataType::Int32
             | DataType::Int16
@@ -1165,6 +1635,9 @@ mod tests {
             | DataType::UInt32
             | DataType::UInt16
             | DataType::UInt8 => vec![Encoding::PLAIN, Encoding::DELTA_BINARY_PACKED],
+            DataType::Float32 | DataType::Float64 => {
+                vec![Encoding::PLAIN, Encoding::BYTE_STREAM_SPLIT]
+            }
             _ => vec![Encoding::PLAIN],
         };
 
@@ -1181,8 +1654,9 @@ mod tests {
                             .set_writer_version(version)
                             .set_max_row_group_size(row_group_size)
                             .set_dictionary_enabled(dictionary_size != 0)
-                            .set_dictionary_pagesize_limit(dictionary_size.max(1))
+                            .set_dictionary_page_size_limit(dictionary_size.max(1))
                             .set_encoding(*encoding)
+                            .set_bloom_filter_enabled(bloom_filter)
                             .build();
 
                         files.push(roundtrip_opts(&expected_batch, props))
@@ -1193,17 +1667,17 @@ mod tests {
         files
     }
 
-    fn values_required<A, I>(iter: I)
+    fn values_required<A, I>(iter: I) -> Vec<File>
     where
         A: From<Vec<I::Item>> + Array + 'static,
         I: IntoIterator,
     {
         let raw_values: Vec<_> = iter.into_iter().collect();
         let values = Arc::new(A::from(raw_values));
-        one_column_roundtrip(values, false);
+        one_column_roundtrip(values, false)
     }
 
-    fn values_optional<A, I>(iter: I)
+    fn values_optional<A, I>(iter: I) -> Vec<File>
     where
         A: From<Vec<Option<I::Item>>> + Array + 'static,
         I: IntoIterator,
@@ -1214,7 +1688,7 @@ mod tests {
             .map(|(i, v)| if i % 2 == 0 { None } else { Some(v) })
             .collect();
         let optional_values = Arc::new(A::from(optional_raw_values));
-        one_column_roundtrip(optional_values, true);
+        one_column_roundtrip(optional_values, true)
     }
 
     fn required_and_optional<A, I>(iter: I)
@@ -1226,6 +1700,68 @@ mod tests {
         values_optional::<A, I>(iter);
     }
 
+    fn check_bloom_filter<T: AsBytes>(
+        files: Vec<File>,
+        file_column: String,
+        positive_values: Vec<T>,
+        negative_values: Vec<T>,
+    ) {
+        files.into_iter().take(1).for_each(|file| {
+            let file_reader = SerializedFileReader::new_with_options(
+                file,
+                ReadOptionsBuilder::new()
+                    .with_reader_properties(
+                        ReaderProperties::builder()
+                            .set_read_bloom_filter(true)
+                            .build(),
+                    )
+                    .build(),
+            )
+            .expect("Unable to open file as Parquet");
+            let metadata = file_reader.metadata();
+
+            // Gets bloom filters from all row groups.
+            let mut bloom_filters: Vec<_> = vec![];
+            for (ri, row_group) in metadata.row_groups().iter().enumerate() {
+                if let Some((column_index, _)) = row_group
+                    .columns()
+                    .iter()
+                    .enumerate()
+                    .find(|(_, column)| column.column_path().string() == file_column)
+                {
+                    let row_group_reader = file_reader
+                        .get_row_group(ri)
+                        .expect("Unable to read row group");
+                    if let Some(sbbf) = row_group_reader.get_column_bloom_filter(column_index) {
+                        bloom_filters.push(sbbf.clone());
+                    } else {
+                        panic!("No bloom filter for column named {file_column} found");
+                    }
+                } else {
+                    panic!("No column named {file_column} found");
+                }
+            }
+
+            positive_values.iter().for_each(|value| {
+                let found = bloom_filters.iter().find(|sbbf| sbbf.check(value));
+                assert!(
+                    found.is_some(),
+                    "{}",
+                    format!("Value {:?} should be in bloom filter", value.as_bytes())
+                );
+            });
+
+            negative_values.iter().for_each(|value| {
+                let found = bloom_filters.iter().find(|sbbf| sbbf.check(value));
+                assert!(
+                    found.is_none(),
+                    "{}",
+                    format!("Value {:?} should not be in bloom filter", value.as_bytes())
+                );
+            });
+        });
+    }
+
     #[test]
     fn all_null_primitive_single_column() {
         let values = Arc::new(Int32Array::from(vec![None; SMALL_SIZE]));
@@ -1255,22 +1791,38 @@ mod tests {
                 .take(200_000)
                 .collect::<BooleanArray>(),
         );
-        let schema =
-            Schema::new(vec![Field::new("col", values.data_type().clone(), true)]);
-        let expected_batch =
-            RecordBatch::try_new(Arc::new(schema), vec![values]).unwrap();
+        let schema = Schema::new(vec![Field::new("col", values.data_type().clone(), true)]);
+        let expected_batch = RecordBatch::try_new(Arc::new(schema), vec![values]).unwrap();
         let file = tempfile::tempfile().unwrap();
 
-        let mut writer = ArrowWriter::try_new(
-            file.try_clone().unwrap(),
-            expected_batch.schema(),
-            None,
-        )
-        .expect("Unable to write file");
+        let mut writer =
+            ArrowWriter::try_new(file.try_clone().unwrap(), expected_batch.schema(), None)
+                .expect("Unable to write file");
         writer.write(&expected_batch).unwrap();
         writer.close().unwrap();
     }
 
+    #[test]
+    fn check_page_offset_index_with_nan() {
+        let values = Arc::new(Float64Array::from(vec![f64::NAN; 10]));
+        let schema = Schema::new(vec![Field::new("col", DataType::Float64, true)]);
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![values]).unwrap();
+
+        let mut out = Vec::with_capacity(1024);
+        let mut writer =
+            ArrowWriter::try_new(&mut out, batch.schema(), None).expect("Unable to write file");
+        writer.write(&batch).unwrap();
+        let file_meta_data = writer.close().unwrap();
+        for row_group in file_meta_data.row_groups {
+            for column in row_group.columns {
+                assert!(column.offset_index_offset.is_some());
+                assert!(column.offset_index_length.is_some());
+                assert!(column.column_index_offset.is_none());
+                assert!(column.column_index_length.is_none());
+            }
+        }
+    }
+
     #[test]
     fn i8_single_column() {
         required_and_optional::<Int8Array, _>(0..SMALL_SIZE as i8);
@@ -1328,7 +1880,7 @@ mod tests {
     #[test]
     fn timestamp_second_single_column() {
         let raw_values: Vec<_> = (0..SMALL_SIZE as i64).collect();
-        let values = Arc::new(TimestampSecondArray::from_vec(raw_values, None));
+        let values = Arc::new(TimestampSecondArray::from(raw_values));
 
         one_column_roundtrip(values, false);
     }
@@ -1336,7 +1888,7 @@ mod tests {
     #[test]
     fn timestamp_millisecond_single_column() {
         let raw_values: Vec<_> = (0..SMALL_SIZE as i64).collect();
-        let values = Arc::new(TimestampMillisecondArray::from_vec(raw_values, None));
+        let values = Arc::new(TimestampMillisecondArray::from(raw_values));
 
         one_column_roundtrip(values, false);
     }
@@ -1344,7 +1896,7 @@ mod tests {
     #[test]
     fn timestamp_microsecond_single_column() {
         let raw_values: Vec<_> = (0..SMALL_SIZE as i64).collect();
-        let values = Arc::new(TimestampMicrosecondArray::from_vec(raw_values, None));
+        let values = Arc::new(TimestampMicrosecondArray::from(raw_values));
 
         one_column_roundtrip(values, false);
     }
@@ -1352,7 +1904,7 @@ mod tests {
     #[test]
     fn timestamp_nanosecond_single_column() {
         let raw_values: Vec<_> = (0..SMALL_SIZE as i64).collect();
-        let values = Arc::new(TimestampNanosecondArray::from_vec(raw_values, None));
+        let values = Arc::new(TimestampNanosecondArray::from(raw_values));
 
         one_column_roundtrip(values, false);
     }
@@ -1442,6 +1994,60 @@ mod tests {
         values_required::<BinaryArray, _>(many_vecs_iter);
     }
 
+    #[test]
+    fn i32_column_bloom_filter() {
+        let array = Arc::new(Int32Array::from_iter(0..SMALL_SIZE as i32));
+        let mut options = RoundTripOptions::new(array, false);
+        options.bloom_filter = true;
+
+        let files = one_column_roundtrip_with_options(options);
+        check_bloom_filter(
+            files,
+            "col".to_string(),
+            (0..SMALL_SIZE as i32).collect(),
+            (SMALL_SIZE as i32 + 1..SMALL_SIZE as i32 + 10).collect(),
+        );
+    }
+
+    #[test]
+    fn binary_column_bloom_filter() {
+        let one_vec: Vec<u8> = (0..SMALL_SIZE as u8).collect();
+        let many_vecs: Vec<_> = std::iter::repeat(one_vec).take(SMALL_SIZE).collect();
+        let many_vecs_iter = many_vecs.iter().map(|v| v.as_slice());
+
+        let array = Arc::new(BinaryArray::from_iter_values(many_vecs_iter));
+        let mut options = RoundTripOptions::new(array, false);
+        options.bloom_filter = true;
+
+        let files = one_column_roundtrip_with_options(options);
+        check_bloom_filter(
+            files,
+            "col".to_string(),
+            many_vecs,
+            vec![vec![(SMALL_SIZE + 1) as u8]],
+        );
+    }
+
+    #[test]
+    fn empty_string_null_column_bloom_filter() {
+        let raw_values: Vec<_> = (0..SMALL_SIZE).map(|i| i.to_string()).collect();
+        let raw_strs = raw_values.iter().map(|s| s.as_str());
+
+        let array = Arc::new(StringArray::from_iter_values(raw_strs));
+        let mut options = RoundTripOptions::new(array, false);
+        options.bloom_filter = true;
+
+        let files = one_column_roundtrip_with_options(options);
+
+        let optional_raw_values: Vec<_> = raw_values
+            .iter()
+            .enumerate()
+            .filter_map(|(i, v)| if i % 2 == 0 { None } else { Some(v.as_str()) })
+            .collect();
+        // For null slots, empty string should not be in bloom filter.
+        check_bloom_filter(files, "col".to_string(), optional_raw_values, vec![""]);
+    }
+
     #[test]
     fn large_binary_single_column() {
         let one_vec: Vec<u8> = (0..SMALL_SIZE as u8).collect();
@@ -1454,7 +2060,7 @@ mod tests {
 
     #[test]
     fn fixed_size_binary_single_column() {
-        let mut builder = FixedSizeBinaryBuilder::new(16, 4);
+        let mut builder = FixedSizeBinaryBuilder::new(4);
         builder.append_value(b"0123").unwrap();
         builder.append_null();
         builder.append_value(b"8910").unwrap();
@@ -1483,15 +2089,14 @@ mod tests {
     #[test]
     fn null_list_single_column() {
         let null_field = Field::new("item", DataType::Null, true);
-        let list_field =
-            Field::new("emptylist", DataType::List(Box::new(null_field)), true);
+        let list_field = Field::new("emptylist", DataType::List(Arc::new(null_field)), true);
 
         let schema = Schema::new(vec![list_field]);
 
         // Build [[], null, [null, null]]
         let a_values = NullArray::new(2);
         let a_value_offsets = arrow::buffer::Buffer::from(&[0, 0, 0, 2].to_byte_slice());
-        let a_list_data = ArrayData::builder(DataType::List(Box::new(Field::new(
+        let a_list_data = ArrayData::builder(DataType::List(Arc::new(Field::new(
             "item",
             DataType::Null,
             true,
@@ -1511,7 +2116,7 @@ mod tests {
 
         assert_eq!(a.value(0).len(), 0);
         assert_eq!(a.value(2).len(), 2);
-        assert_eq!(a.value(2).null_count(), 2);
+        assert_eq!(a.value(2).logical_nulls().unwrap().null_count(), 2);
 
         let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap();
         roundtrip(batch, None);
@@ -1520,9 +2125,8 @@ mod tests {
     #[test]
     fn list_single_column() {
         let a_values = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-        let a_value_offsets =
-            arrow::buffer::Buffer::from(&[0, 1, 3, 3, 6, 10].to_byte_slice());
-        let a_list_data = ArrayData::builder(DataType::List(Box::new(Field::new(
+        let a_value_offsets = arrow::buffer::Buffer::from(&[0, 1, 3, 3, 6, 10].to_byte_slice());
+        let a_list_data = ArrayData::builder(DataType::List(Arc::new(Field::new(
             "item",
             DataType::Int32,
             false,
@@ -1545,9 +2149,8 @@ mod tests {
     #[test]
     fn large_list_single_column() {
         let a_values = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-        let a_value_offsets =
-            arrow::buffer::Buffer::from(&[0i64, 1, 3, 3, 6, 10].to_byte_slice());
-        let a_list_data = ArrayData::builder(DataType::LargeList(Box::new(Field::new(
+        let a_value_offsets = arrow::buffer::Buffer::from(&[0i64, 1, 3, 3, 6, 10].to_byte_slice());
+        let a_list_data = ArrayData::builder(DataType::LargeList(Arc::new(Field::new(
             "large_item",
             DataType::Int32,
             true,
@@ -1590,13 +2193,55 @@ mod tests {
     #[test]
     fn struct_single_column() {
         let a_values = Int32Array::from(vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-        let struct_field_a = Field::new("f", DataType::Int32, false);
+        let struct_field_a = Arc::new(Field::new("f", DataType::Int32, false));
         let s = StructArray::from(vec![(struct_field_a, Arc::new(a_values) as ArrayRef)]);
 
         let values = Arc::new(s);
         one_column_roundtrip(values, false);
     }
 
+    #[test]
+    fn fallback_flush_data_page() {
+        //tests if the Fallback::flush_data_page clears all buffers correctly
+        let raw_values: Vec<_> = (0..MEDIUM_SIZE).map(|i| i.to_string()).collect();
+        let values = Arc::new(StringArray::from(raw_values));
+        let encodings = vec![
+            Encoding::DELTA_BYTE_ARRAY,
+            Encoding::DELTA_LENGTH_BYTE_ARRAY,
+        ];
+        let data_type = values.data_type().clone();
+        let schema = Arc::new(Schema::new(vec![Field::new("col", data_type, false)]));
+        let expected_batch = RecordBatch::try_new(schema, vec![values]).unwrap();
+
+        let row_group_sizes = [1024, SMALL_SIZE, SMALL_SIZE / 2, SMALL_SIZE / 2 + 1, 10];
+        let data_page_size_limit: usize = 32;
+        let write_batch_size: usize = 16;
+
+        for encoding in &encodings {
+            for row_group_size in row_group_sizes {
+                let props = WriterProperties::builder()
+                    .set_writer_version(WriterVersion::PARQUET_2_0)
+                    .set_max_row_group_size(row_group_size)
+                    .set_dictionary_enabled(false)
+                    .set_encoding(*encoding)
+                    .set_data_page_size_limit(data_page_size_limit)
+                    .set_write_batch_size(write_batch_size)
+                    .build();
+
+                roundtrip_opts_with_array_validation(&expected_batch, props, |a, b| {
+                    let string_array_a = StringArray::from(a.clone());
+                    let string_array_b = StringArray::from(b.clone());
+                    let vec_a: Vec<&str> = string_array_a.iter().map(|v| v.unwrap()).collect();
+                    let vec_b: Vec<&str> = string_array_b.iter().map(|v| v.unwrap()).collect();
+                    assert_eq!(
+                        vec_a, vec_b,
+                        "failed for encoder: {encoding:?} and row_group_size: {row_group_size:?}"
+                    );
+                });
+            }
+        }
+    }
+
     #[test]
     fn arrow_writer_string_dictionary() {
         // define schema
@@ -1630,9 +2275,7 @@ mod tests {
         )]));
 
         // create some data
-        let key_builder = PrimitiveBuilder::<UInt8Type>::new(3);
-        let value_builder = PrimitiveBuilder::<UInt32Type>::new(2);
-        let mut builder = PrimitiveDictionaryBuilder::new(key_builder, value_builder);
+        let mut builder = PrimitiveDictionaryBuilder::<UInt8Type, UInt32Type>::new();
         builder.append(12345678).unwrap();
         builder.append_null();
         builder.append(22345678).unwrap();
@@ -1665,7 +2308,7 @@ mod tests {
     #[test]
     fn u32_min_max() {
         // check values roundtrip through parquet
-        let src = vec![
+        let src = [
             u32::MIN,
             u32::MIN + 1,
             (i32::MAX as u32) - 1,
@@ -1706,7 +2349,7 @@ mod tests {
     #[test]
     fn u64_min_max() {
         // check values roundtrip through parquet
-        let src = vec![
+        let src = [
             u64::MIN,
             u64::MIN + 1,
             (i64::MAX as u64) - 1,
@@ -1769,8 +2412,8 @@ mod tests {
         let int_field = Field::new("a", DataType::Int32, true);
         let int_field2 = Field::new("b", DataType::Int32, true);
 
-        let int_builder = Int32Builder::new(10);
-        let int_builder2 = Int32Builder::new(10);
+        let int_builder = Int32Builder::with_capacity(10);
+        let int_builder2 = Int32Builder::with_capacity(10);
 
         let struct_builder = StructBuilder::new(
             vec![int_field, int_field2],
@@ -1878,22 +2521,21 @@ mod tests {
             .build();
 
         let mut writer =
-            ArrowWriter::try_new(file.try_clone().unwrap(), schema.clone(), Some(props))
-                .unwrap();
+            ArrowWriter::try_new(file.try_clone().unwrap(), schema.clone(), Some(props)).unwrap();
 
         for array in arrays {
-            let batch =
-                RecordBatch::try_new(schema.clone(), vec![Arc::new(array)]).unwrap();
+            let batch = RecordBatch::try_new(schema.clone(), vec![Arc::new(array)]).unwrap();
             writer.write(&batch).unwrap();
         }
 
         writer.close().unwrap();
 
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-        assert_eq!(&row_group_sizes(arrow_reader.metadata()), &[200, 200, 50]);
+        let builder = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+        assert_eq!(&row_group_sizes(builder.metadata()), &[200, 200, 50]);
 
-        let batches = arrow_reader
-            .get_record_reader(100)
+        let batches = builder
+            .with_batch_size(100)
+            .build()
             .unwrap()
             .collect::<ArrowResult<Vec<_>>>()
             .unwrap();
@@ -1918,25 +2560,27 @@ mod tests {
             })
             .collect();
 
-        let expected_values: Vec<_> =
-            [0..100, 0..50, 200..500].into_iter().flatten().collect();
+        let expected_values: Vec<_> = [0..100, 0..50, 200..500].into_iter().flatten().collect();
         assert_eq!(&values, &expected_values)
     }
 
     #[test]
     fn complex_aggregate() {
         // Tests aggregating nested data
-        let field_a = Field::new("leaf_a", DataType::Int32, false);
-        let field_b = Field::new("leaf_b", DataType::Int32, true);
-        let struct_a = Field::new(
+        let field_a = Arc::new(Field::new("leaf_a", DataType::Int32, false));
+        let field_b = Arc::new(Field::new("leaf_b", DataType::Int32, true));
+        let struct_a = Arc::new(Field::new(
             "struct_a",
-            DataType::Struct(vec![field_a.clone(), field_b.clone()]),
+            DataType::Struct(vec![field_a.clone(), field_b.clone()].into()),
             true,
-        );
+        ));
 
-        let list_a = Field::new("list", DataType::List(Box::new(struct_a)), true);
-        let struct_b =
-            Field::new("struct_b", DataType::Struct(vec![list_a.clone()]), false);
+        let list_a = Arc::new(Field::new("list", DataType::List(struct_a), true));
+        let struct_b = Arc::new(Field::new(
+            "struct_b",
+            DataType::Struct(vec![list_a.clone()].into()),
+            false,
+        ));
 
         let schema = Arc::new(Schema::new(vec![struct_b]));
 
@@ -1965,11 +2609,9 @@ mod tests {
         let list_a_array = Arc::new(ListArray::from(list_data)) as ArrayRef;
         let struct_b_array = StructArray::from(vec![(list_a.clone(), list_a_array)]);
 
-        let batch1 = RecordBatch::try_from_iter(vec![(
-            "struct_b",
-            Arc::new(struct_b_array) as ArrayRef,
-        )])
-        .unwrap();
+        let batch1 =
+            RecordBatch::try_from_iter(vec![("struct_b", Arc::new(struct_b_array) as ArrayRef)])
+                .unwrap();
 
         let field_a_array = Int32Array::from(vec![6, 7, 8, 9, 10]);
         let field_b_array = Int32Array::from_iter(vec![None, None, None, Some(1), None]);
@@ -1989,28 +2631,26 @@ mod tests {
         let list_a_array = Arc::new(ListArray::from(list_data)) as ArrayRef;
         let struct_b_array = StructArray::from(vec![(list_a, list_a_array)]);
 
-        let batch2 = RecordBatch::try_from_iter(vec![(
-            "struct_b",
-            Arc::new(struct_b_array) as ArrayRef,
-        )])
-        .unwrap();
+        let batch2 =
+            RecordBatch::try_from_iter(vec![("struct_b", Arc::new(struct_b_array) as ArrayRef)])
+                .unwrap();
 
         let batches = &[batch1, batch2];
 
         // Verify data is as expected
 
         let expected = r#"
-            +-------------------------------------------------------------------------------------------------------------------------------------+
-            | struct_b                                                                                                                            |
-            +-------------------------------------------------------------------------------------------------------------------------------------+
-            | {"list": [{"leaf_a": 1, "leaf_b": 1}]}                                                                                              |
-            | {"list": null}                                                                                                                      |
-            | {"list": [{"leaf_a": 2, "leaf_b": null}, {"leaf_a": 3, "leaf_b": 2}]}                                                               |
-            | {"list": null}                                                                                                                      |
-            | {"list": [{"leaf_a": 4, "leaf_b": null}, {"leaf_a": 5, "leaf_b": null}]}                                                            |
-            | {"list": [{"leaf_a": 6, "leaf_b": null}, {"leaf_a": 7, "leaf_b": null}, {"leaf_a": 8, "leaf_b": null}, {"leaf_a": 9, "leaf_b": 1}]} |
-            | {"list": [{"leaf_a": 10, "leaf_b": null}]}                                                                                          |
-            +-------------------------------------------------------------------------------------------------------------------------------------+
+            +-------------------------------------------------------------------------------------------------------+
+            | struct_b                                                                                              |
+            +-------------------------------------------------------------------------------------------------------+
+            | {list: [{leaf_a: 1, leaf_b: 1}]}                                                                      |
+            | {list: }                                                                                              |
+            | {list: [{leaf_a: 2, leaf_b: }, {leaf_a: 3, leaf_b: 2}]}                                               |
+            | {list: }                                                                                              |
+            | {list: [{leaf_a: 4, leaf_b: }, {leaf_a: 5, leaf_b: }]}                                                |
+            | {list: [{leaf_a: 6, leaf_b: }, {leaf_a: 7, leaf_b: }, {leaf_a: 8, leaf_b: }, {leaf_a: 9, leaf_b: 1}]} |
+            | {list: [{leaf_a: 10, leaf_b: }]}                                                                      |
+            +-------------------------------------------------------------------------------------------------------+
         "#.trim().split('\n').map(|x| x.trim()).collect::<Vec<_>>().join("\n");
 
         let actual = pretty_format_batches(batches).unwrap().to_string();
@@ -2034,11 +2674,12 @@ mod tests {
         // Should have written entire first batch and first row of second to the first row group
         // leaving a single row in the second row group
 
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-        assert_eq!(&row_group_sizes(arrow_reader.metadata()), &[6, 1]);
+        let builder = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+        assert_eq!(&row_group_sizes(builder.metadata()), &[6, 1]);
 
-        let batches = arrow_reader
-            .get_record_reader(2)
+        let batches = builder
+            .with_batch_size(2)
+            .build()
             .unwrap()
             .collect::<ArrowResult<Vec<_>>>()
             .unwrap();
@@ -2050,4 +2691,311 @@ mod tests {
         let actual = pretty_format_batches(&batches).unwrap().to_string();
         assert_eq!(actual, expected);
     }
+
+    #[test]
+    fn test_arrow_writer_metadata() {
+        let batch_schema = Schema::new(vec![Field::new("int32", DataType::Int32, false)]);
+        let file_schema = batch_schema.clone().with_metadata(
+            vec![("foo".to_string(), "bar".to_string())]
+                .into_iter()
+                .collect(),
+        );
+
+        let batch = RecordBatch::try_new(
+            Arc::new(batch_schema),
+            vec![Arc::new(Int32Array::from(vec![1, 2, 3, 4])) as _],
+        )
+        .unwrap();
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buf, Arc::new(file_schema), None).unwrap();
+        writer.write(&batch).unwrap();
+        writer.close().unwrap();
+    }
+
+    #[test]
+    fn test_arrow_writer_nullable() {
+        let batch_schema = Schema::new(vec![Field::new("int32", DataType::Int32, false)]);
+        let file_schema = Schema::new(vec![Field::new("int32", DataType::Int32, true)]);
+        let file_schema = Arc::new(file_schema);
+
+        let batch = RecordBatch::try_new(
+            Arc::new(batch_schema),
+            vec![Arc::new(Int32Array::from(vec![1, 2, 3, 4])) as _],
+        )
+        .unwrap();
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buf, file_schema.clone(), None).unwrap();
+        writer.write(&batch).unwrap();
+        writer.close().unwrap();
+
+        let mut read = ParquetRecordBatchReader::try_new(Bytes::from(buf), 1024).unwrap();
+        let back = read.next().unwrap().unwrap();
+        assert_eq!(back.schema(), file_schema);
+        assert_ne!(back.schema(), batch.schema());
+        assert_eq!(back.column(0).as_ref(), batch.column(0).as_ref());
+    }
+
+    #[test]
+    fn in_progress_accounting() {
+        // define schema
+        let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
+
+        // create some data
+        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+
+        // build a record batch
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap();
+
+        let mut writer = ArrowWriter::try_new(vec![], batch.schema(), None).unwrap();
+
+        // starts empty
+        assert_eq!(writer.in_progress_size(), 0);
+        assert_eq!(writer.in_progress_rows(), 0);
+        assert_eq!(writer.bytes_written(), 4); // Initial header
+        writer.write(&batch).unwrap();
+
+        // updated on write
+        let initial_size = writer.in_progress_size();
+        assert!(initial_size > 0);
+        assert_eq!(writer.in_progress_rows(), 5);
+
+        // updated on second write
+        writer.write(&batch).unwrap();
+        assert!(writer.in_progress_size() > initial_size);
+        assert_eq!(writer.in_progress_rows(), 10);
+
+        // in progress tracking is cleared, but the overall data written is updated
+        let pre_flush_bytes_written = writer.bytes_written();
+        writer.flush().unwrap();
+        assert_eq!(writer.in_progress_size(), 0);
+        assert_eq!(writer.in_progress_rows(), 0);
+        assert!(writer.bytes_written() > pre_flush_bytes_written);
+
+        writer.close().unwrap();
+    }
+
+    #[test]
+    fn test_writer_all_null() {
+        let a = Int32Array::from(vec![1, 2, 3, 4, 5]);
+        let b = Int32Array::new(vec![0; 5].into(), Some(NullBuffer::new_null(5)));
+        let batch = RecordBatch::try_from_iter(vec![
+            ("a", Arc::new(a) as ArrayRef),
+            ("b", Arc::new(b) as ArrayRef),
+        ])
+        .unwrap();
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buf, batch.schema(), None).unwrap();
+        writer.write(&batch).unwrap();
+        writer.close().unwrap();
+
+        let bytes = Bytes::from(buf);
+        let options = ReadOptionsBuilder::new().with_page_index().build();
+        let reader = SerializedFileReader::new_with_options(bytes, options).unwrap();
+        let index = reader.metadata().offset_index().unwrap();
+
+        assert_eq!(index.len(), 1);
+        assert_eq!(index[0].len(), 2); // 2 columns
+        assert_eq!(index[0][0].len(), 1); // 1 page
+        assert_eq!(index[0][1].len(), 1); // 1 page
+    }
+
+    #[test]
+    fn test_disabled_statistics_with_page() {
+        let file_schema = Schema::new(vec![
+            Field::new("a", DataType::Utf8, true),
+            Field::new("b", DataType::Utf8, true),
+        ]);
+        let file_schema = Arc::new(file_schema);
+
+        let batch = RecordBatch::try_new(
+            file_schema.clone(),
+            vec![
+                Arc::new(StringArray::from(vec!["a", "b", "c", "d"])) as _,
+                Arc::new(StringArray::from(vec!["w", "x", "y", "z"])) as _,
+            ],
+        )
+        .unwrap();
+
+        let props = WriterProperties::builder()
+            .set_statistics_enabled(EnabledStatistics::None)
+            .set_column_statistics_enabled("a".into(), EnabledStatistics::Page)
+            .build();
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buf, file_schema.clone(), Some(props)).unwrap();
+        writer.write(&batch).unwrap();
+
+        let metadata = writer.close().unwrap();
+        assert_eq!(metadata.row_groups.len(), 1);
+        let row_group = &metadata.row_groups[0];
+        assert_eq!(row_group.columns.len(), 2);
+        // Column "a" has both offset and column index, as requested
+        assert!(row_group.columns[0].offset_index_offset.is_some());
+        assert!(row_group.columns[0].column_index_offset.is_some());
+        // Column "b" should only have offset index
+        assert!(row_group.columns[1].offset_index_offset.is_some());
+        assert!(row_group.columns[1].column_index_offset.is_none());
+
+        let options = ReadOptionsBuilder::new().with_page_index().build();
+        let reader = SerializedFileReader::new_with_options(Bytes::from(buf), options).unwrap();
+
+        let row_group = reader.get_row_group(0).unwrap();
+        let a_col = row_group.metadata().column(0);
+        let b_col = row_group.metadata().column(1);
+
+        // Column chunk of column "a" should have chunk level statistics
+        if let Statistics::ByteArray(byte_array_stats) = a_col.statistics().unwrap() {
+            let min = byte_array_stats.min();
+            let max = byte_array_stats.max();
+
+            assert_eq!(min.as_bytes(), &[b'a']);
+            assert_eq!(max.as_bytes(), &[b'd']);
+        } else {
+            panic!("expecting Statistics::ByteArray");
+        }
+
+        // The column chunk for column "b" shouldn't have statistics
+        assert!(b_col.statistics().is_none());
+
+        let offset_index = reader.metadata().offset_index().unwrap();
+        assert_eq!(offset_index.len(), 1); // 1 row group
+        assert_eq!(offset_index[0].len(), 2); // 2 columns
+
+        let column_index = reader.metadata().column_index().unwrap();
+        assert_eq!(column_index.len(), 1); // 1 row group
+        assert_eq!(column_index[0].len(), 2); // 2 columns
+
+        let a_idx = &column_index[0][0];
+        assert!(matches!(a_idx, Index::BYTE_ARRAY(_)), "{a_idx:?}");
+        let b_idx = &column_index[0][1];
+        assert!(matches!(b_idx, Index::NONE), "{b_idx:?}");
+    }
+
+    #[test]
+    fn test_disabled_statistics_with_chunk() {
+        let file_schema = Schema::new(vec![
+            Field::new("a", DataType::Utf8, true),
+            Field::new("b", DataType::Utf8, true),
+        ]);
+        let file_schema = Arc::new(file_schema);
+
+        let batch = RecordBatch::try_new(
+            file_schema.clone(),
+            vec![
+                Arc::new(StringArray::from(vec!["a", "b", "c", "d"])) as _,
+                Arc::new(StringArray::from(vec!["w", "x", "y", "z"])) as _,
+            ],
+        )
+        .unwrap();
+
+        let props = WriterProperties::builder()
+            .set_statistics_enabled(EnabledStatistics::None)
+            .set_column_statistics_enabled("a".into(), EnabledStatistics::Chunk)
+            .build();
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buf, file_schema.clone(), Some(props)).unwrap();
+        writer.write(&batch).unwrap();
+
+        let metadata = writer.close().unwrap();
+        assert_eq!(metadata.row_groups.len(), 1);
+        let row_group = &metadata.row_groups[0];
+        assert_eq!(row_group.columns.len(), 2);
+        // Column "a" should only have offset index
+        assert!(row_group.columns[0].offset_index_offset.is_some());
+        assert!(row_group.columns[0].column_index_offset.is_none());
+        // Column "b" should only have offset index
+        assert!(row_group.columns[1].offset_index_offset.is_some());
+        assert!(row_group.columns[1].column_index_offset.is_none());
+
+        let options = ReadOptionsBuilder::new().with_page_index().build();
+        let reader = SerializedFileReader::new_with_options(Bytes::from(buf), options).unwrap();
+
+        let row_group = reader.get_row_group(0).unwrap();
+        let a_col = row_group.metadata().column(0);
+        let b_col = row_group.metadata().column(1);
+
+        // Column chunk of column "a" should have chunk level statistics
+        if let Statistics::ByteArray(byte_array_stats) = a_col.statistics().unwrap() {
+            let min = byte_array_stats.min();
+            let max = byte_array_stats.max();
+
+            assert_eq!(min.as_bytes(), &[b'a']);
+            assert_eq!(max.as_bytes(), &[b'd']);
+        } else {
+            panic!("expecting Statistics::ByteArray");
+        }
+
+        // The column chunk for column "b"  shouldn't have statistics
+        assert!(b_col.statistics().is_none());
+
+        let column_index = reader.metadata().column_index().unwrap();
+        assert_eq!(column_index.len(), 1); // 1 row group
+        assert_eq!(column_index[0].len(), 2); // 2 columns
+
+        let a_idx = &column_index[0][0];
+        assert!(matches!(a_idx, Index::NONE), "{a_idx:?}");
+        let b_idx = &column_index[0][1];
+        assert!(matches!(b_idx, Index::NONE), "{b_idx:?}");
+    }
+
+    #[test]
+    fn test_arrow_writer_skip_metadata() {
+        let batch_schema = Schema::new(vec![Field::new("int32", DataType::Int32, false)]);
+        let file_schema = Arc::new(batch_schema.clone());
+
+        let batch = RecordBatch::try_new(
+            Arc::new(batch_schema),
+            vec![Arc::new(Int32Array::from(vec![1, 2, 3, 4])) as _],
+        )
+        .unwrap();
+        let skip_options = ArrowWriterOptions::new().with_skip_arrow_metadata(true);
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer =
+            ArrowWriter::try_new_with_options(&mut buf, file_schema.clone(), skip_options).unwrap();
+        writer.write(&batch).unwrap();
+        writer.close().unwrap();
+
+        let bytes = Bytes::from(buf);
+        let reader_builder = ParquetRecordBatchReaderBuilder::try_new(bytes).unwrap();
+        assert_eq!(file_schema, *reader_builder.schema());
+        if let Some(key_value_metadata) = reader_builder
+            .metadata()
+            .file_metadata()
+            .key_value_metadata()
+        {
+            assert!(!key_value_metadata
+                .iter()
+                .any(|kv| kv.key.as_str() == ARROW_SCHEMA_META_KEY));
+        }
+    }
+
+    #[test]
+    fn mismatched_schemas() {
+        let batch_schema = Schema::new(vec![Field::new("count", DataType::Int32, false)]);
+        let file_schema = Arc::new(Schema::new(vec![Field::new(
+            "temperature",
+            DataType::Float64,
+            false,
+        )]));
+
+        let batch = RecordBatch::try_new(
+            Arc::new(batch_schema),
+            vec![Arc::new(Int32Array::from(vec![1, 2, 3, 4])) as _],
+        )
+        .unwrap();
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buf, file_schema.clone(), None).unwrap();
+
+        let err = writer.write(&batch).unwrap_err().to_string();
+        assert_eq!(
+            err,
+            "Arrow: Incompatible type. Field 'temperature' has type Float64, array has type Int32"
+        );
+    }
 }
diff --git a/parquet/src/arrow/async_reader.rs b/parquet/src/arrow/async_reader.rs
deleted file mode 100644
index 5c186d7aa769..000000000000
--- a/parquet/src/arrow/async_reader.rs
+++ /dev/null
@@ -1,1054 +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.
-
-//! Provides `async` API for reading parquet files as
-//! [`RecordBatch`]es
-//!
-//! ```
-//! # #[tokio::main(flavor="current_thread")]
-//! # async fn main() {
-//! #
-//! use arrow::record_batch::RecordBatch;
-//! use arrow::util::pretty::pretty_format_batches;
-//! use futures::TryStreamExt;
-//! use tokio::fs::File;
-//!
-//! use parquet::arrow::{ParquetRecordBatchStreamBuilder, ProjectionMask};
-//!
-//! # fn assert_batches_eq(batches: &[RecordBatch], expected_lines: &[&str]) {
-//! #     let formatted = pretty_format_batches(batches).unwrap().to_string();
-//! #     let actual_lines: Vec<_> = formatted.trim().lines().collect();
-//! #     assert_eq!(
-//! #          &actual_lines, expected_lines,
-//! #          "\n\nexpected:\n\n{:#?}\nactual:\n\n{:#?}\n\n",
-//! #          expected_lines, actual_lines
-//! #      );
-//! #  }
-//!
-//! let testdata = arrow::util::test_util::parquet_test_data();
-//! let path = format!("{}/alltypes_plain.parquet", testdata);
-//! let file = File::open(path).await.unwrap();
-//!
-//! let builder = ParquetRecordBatchStreamBuilder::new(file)
-//!     .await
-//!     .unwrap()
-//!     .with_batch_size(3);
-//!
-//! let file_metadata = builder.metadata().file_metadata();
-//! let mask = ProjectionMask::roots(file_metadata.schema_descr(), [1, 2, 6]);
-//!
-//! let stream = builder.with_projection(mask).build().unwrap();
-//! let results = stream.try_collect::<Vec<_>>().await.unwrap();
-//! assert_eq!(results.len(), 3);
-//!
-//! assert_batches_eq(
-//!     &results,
-//!     &[
-//!         "+----------+-------------+-----------+",
-//!         "| bool_col | tinyint_col | float_col |",
-//!         "+----------+-------------+-----------+",
-//!         "| true     | 0           | 0         |",
-//!         "| false    | 1           | 1.1       |",
-//!         "| true     | 0           | 0         |",
-//!         "| false    | 1           | 1.1       |",
-//!         "| true     | 0           | 0         |",
-//!         "| false    | 1           | 1.1       |",
-//!         "| true     | 0           | 0         |",
-//!         "| false    | 1           | 1.1       |",
-//!         "+----------+-------------+-----------+",
-//!      ],
-//!  );
-//! # }
-//! ```
-
-use std::collections::VecDeque;
-use std::fmt::Formatter;
-
-use std::io::{Cursor, SeekFrom};
-use std::ops::Range;
-use std::pin::Pin;
-use std::sync::Arc;
-use std::task::{Context, Poll};
-
-use bytes::Bytes;
-use futures::future::{BoxFuture, FutureExt};
-use futures::ready;
-use futures::stream::Stream;
-use parquet_format::{PageHeader, PageType};
-use tokio::io::{AsyncRead, AsyncReadExt, AsyncSeek, AsyncSeekExt};
-
-use arrow::datatypes::SchemaRef;
-use arrow::record_batch::RecordBatch;
-
-use crate::arrow::array_reader::{build_array_reader, RowGroupCollection};
-use crate::arrow::arrow_reader::{
-    evaluate_predicate, ParquetRecordBatchReader, RowFilter, RowSelection,
-};
-use crate::arrow::schema::parquet_to_arrow_schema;
-use crate::arrow::ProjectionMask;
-use crate::basic::Compression;
-use crate::column::page::{Page, PageIterator, PageMetadata, PageReader};
-use crate::compression::{create_codec, Codec};
-use crate::errors::{ParquetError, Result};
-use crate::file::footer::{decode_footer, decode_metadata};
-use crate::file::metadata::{ParquetMetaData, RowGroupMetaData};
-use crate::file::serialized_reader::{decode_page, read_page_header};
-use crate::file::FOOTER_SIZE;
-use crate::schema::types::{ColumnDescPtr, SchemaDescPtr, SchemaDescriptor};
-
-/// The asynchronous interface used by [`ParquetRecordBatchStream`] to read parquet files
-pub trait AsyncFileReader: Send {
-    /// Retrieve the bytes in `range`
-    fn get_bytes(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>>;
-
-    /// Retrieve multiple byte ranges. The default implementation will call `get_bytes` sequentially
-    fn get_byte_ranges(
-        &mut self,
-        ranges: Vec<Range<usize>>,
-    ) -> BoxFuture<'_, Result<Vec<Bytes>>> {
-        async move {
-            let mut result = Vec::with_capacity(ranges.len());
-
-            for range in ranges.into_iter() {
-                let data = self.get_bytes(range).await?;
-                result.push(data);
-            }
-
-            Ok(result)
-        }
-        .boxed()
-    }
-
-    /// Provides asynchronous access to the [`ParquetMetaData`] of a parquet file,
-    /// allowing fine-grained control over how metadata is sourced, in particular allowing
-    /// for caching, pre-fetching, catalog metadata, etc...
-    fn get_metadata(&mut self) -> BoxFuture<'_, Result<Arc<ParquetMetaData>>>;
-}
-
-impl AsyncFileReader for Box<dyn AsyncFileReader> {
-    fn get_bytes(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>> {
-        self.as_mut().get_bytes(range)
-    }
-
-    fn get_byte_ranges(
-        &mut self,
-        ranges: Vec<Range<usize>>,
-    ) -> BoxFuture<'_, Result<Vec<Bytes>>> {
-        self.as_mut().get_byte_ranges(ranges)
-    }
-
-    fn get_metadata(&mut self) -> BoxFuture<'_, Result<Arc<ParquetMetaData>>> {
-        self.as_mut().get_metadata()
-    }
-}
-
-impl<T: AsyncRead + AsyncSeek + Unpin + Send> AsyncFileReader for T {
-    fn get_bytes(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>> {
-        async move {
-            self.seek(SeekFrom::Start(range.start as u64)).await?;
-
-            let to_read = range.end - range.start;
-            let mut buffer = Vec::with_capacity(to_read);
-            let read = self.take(to_read as u64).read_to_end(&mut buffer).await?;
-            if read != to_read {
-                eof_err!("expected to read {} bytes, got {}", to_read, read);
-            }
-
-            Ok(buffer.into())
-        }
-        .boxed()
-    }
-
-    fn get_metadata(&mut self) -> BoxFuture<'_, Result<Arc<ParquetMetaData>>> {
-        const FOOTER_SIZE_I64: i64 = FOOTER_SIZE as i64;
-        async move {
-            self.seek(SeekFrom::End(-FOOTER_SIZE_I64)).await?;
-
-            let mut buf = [0_u8; FOOTER_SIZE];
-            self.read_exact(&mut buf).await?;
-
-            let metadata_len = decode_footer(&buf)?;
-            self.seek(SeekFrom::End(-FOOTER_SIZE_I64 - metadata_len as i64))
-                .await?;
-
-            let mut buf = Vec::with_capacity(metadata_len);
-            self.read_to_end(&mut buf).await?;
-
-            Ok(Arc::new(decode_metadata(&buf)?))
-        }
-        .boxed()
-    }
-}
-
-/// A builder used to construct a [`ParquetRecordBatchStream`] for a parquet file
-///
-/// In particular, this handles reading the parquet file metadata, allowing consumers
-/// to use this information to select what specific columns, row groups, etc...
-/// they wish to be read by the resulting stream
-///
-pub struct ParquetRecordBatchStreamBuilder<T> {
-    input: T,
-
-    metadata: Arc<ParquetMetaData>,
-
-    schema: SchemaRef,
-
-    batch_size: usize,
-
-    row_groups: Option<Vec<usize>>,
-
-    projection: ProjectionMask,
-
-    filter: Option<RowFilter>,
-
-    selection: Option<RowSelection>,
-}
-
-impl<T: AsyncFileReader + Send + 'static> ParquetRecordBatchStreamBuilder<T> {
-    /// Create a new [`ParquetRecordBatchStreamBuilder`] with the provided parquet file
-    pub async fn new(mut input: T) -> Result<Self> {
-        let metadata = input.get_metadata().await?;
-
-        let schema = Arc::new(parquet_to_arrow_schema(
-            metadata.file_metadata().schema_descr(),
-            metadata.file_metadata().key_value_metadata(),
-        )?);
-
-        Ok(Self {
-            input,
-            metadata,
-            schema,
-            batch_size: 1024,
-            row_groups: None,
-            projection: ProjectionMask::all(),
-            filter: None,
-            selection: None,
-        })
-    }
-
-    /// Returns a reference to the [`ParquetMetaData`] for this parquet file
-    pub fn metadata(&self) -> &Arc<ParquetMetaData> {
-        &self.metadata
-    }
-
-    /// Returns the parquet [`SchemaDescriptor`] for this parquet file
-    pub fn parquet_schema(&self) -> &SchemaDescriptor {
-        self.metadata.file_metadata().schema_descr()
-    }
-
-    /// Returns the arrow [`SchemaRef`] for this parquet file
-    pub fn schema(&self) -> &SchemaRef {
-        &self.schema
-    }
-
-    /// Set the size of [`RecordBatch`] to produce
-    pub fn with_batch_size(self, batch_size: usize) -> Self {
-        Self { batch_size, ..self }
-    }
-
-    /// Only read data from the provided row group indexes
-    pub fn with_row_groups(self, row_groups: Vec<usize>) -> Self {
-        Self {
-            row_groups: Some(row_groups),
-            ..self
-        }
-    }
-
-    /// Only read data from the provided column indexes
-    pub fn with_projection(self, mask: ProjectionMask) -> Self {
-        Self {
-            projection: mask,
-            ..self
-        }
-    }
-
-    /// Provide a [`RowSelection] to filter out rows, and avoid fetching their
-    /// data into memory
-    ///
-    /// Row group filtering is applied prior to this, and rows from skipped
-    /// row groups should not be included in the [`RowSelection`]
-    ///
-    /// TODO: Make public once stable (#1792)
-    #[allow(unused)]
-    pub(crate) fn with_row_selection(self, selection: RowSelection) -> Self {
-        Self {
-            selection: Some(selection),
-            ..self
-        }
-    }
-
-    /// Provide a [`RowFilter`] to skip decoding rows
-    ///
-    /// TODO: Make public once stable (#1792)
-    #[allow(unused)]
-    pub(crate) fn with_row_filter(self, filter: RowFilter) -> Self {
-        Self {
-            filter: Some(filter),
-            ..self
-        }
-    }
-
-    /// Build a new [`ParquetRecordBatchStream`]
-    pub fn build(self) -> Result<ParquetRecordBatchStream<T>> {
-        let num_row_groups = self.metadata.row_groups().len();
-
-        let row_groups = match self.row_groups {
-            Some(row_groups) => {
-                if let Some(col) = row_groups.iter().find(|x| **x >= num_row_groups) {
-                    return Err(general_err!(
-                        "row group {} out of bounds 0..{}",
-                        col,
-                        num_row_groups
-                    ));
-                }
-                row_groups.into()
-            }
-            None => (0..self.metadata.row_groups().len()).collect(),
-        };
-
-        let reader = ReaderFactory {
-            input: self.input,
-            filter: self.filter,
-            metadata: self.metadata.clone(),
-            schema: self.schema.clone(),
-        };
-
-        Ok(ParquetRecordBatchStream {
-            metadata: self.metadata,
-            batch_size: self.batch_size,
-            row_groups,
-            projection: self.projection,
-            selection: self.selection,
-            schema: self.schema,
-            reader: Some(reader),
-            state: StreamState::Init,
-        })
-    }
-}
-
-type ReadResult<T> = Result<(ReaderFactory<T>, Option<ParquetRecordBatchReader>)>;
-
-/// [`ReaderFactory`] is used by [`ParquetRecordBatchStream`] to create
-/// [`ParquetRecordBatchReader`]
-struct ReaderFactory<T> {
-    metadata: Arc<ParquetMetaData>,
-
-    schema: SchemaRef,
-
-    input: T,
-
-    filter: Option<RowFilter>,
-}
-
-impl<T> ReaderFactory<T>
-where
-    T: AsyncFileReader + Send,
-{
-    /// Reads the next row group with the provided `selection`, `projection` and `batch_size`
-    ///
-    /// Note: this captures self so that the resulting future has a static lifetime
-    async fn read_row_group(
-        mut self,
-        row_group_idx: usize,
-        mut selection: Option<RowSelection>,
-        projection: ProjectionMask,
-        batch_size: usize,
-    ) -> ReadResult<T> {
-        // TODO: calling build_array multiple times is wasteful
-        let selects_any = |selection: Option<&RowSelection>| {
-            selection.map(|x| x.selects_any()).unwrap_or(true)
-        };
-
-        let meta = self.metadata.row_group(row_group_idx);
-        let mut row_group = InMemoryRowGroup {
-            schema: meta.schema_descr_ptr(),
-            row_count: meta.num_rows() as usize,
-            column_chunks: vec![None; meta.columns().len()],
-        };
-
-        if let Some(filter) = self.filter.as_mut() {
-            for predicate in filter.predicates.iter_mut() {
-                if !selects_any(selection.as_ref()) {
-                    return Ok((self, None));
-                }
-
-                let predicate_projection = predicate.projection().clone();
-                row_group
-                    .fetch(
-                        &mut self.input,
-                        meta,
-                        &predicate_projection,
-                        selection.as_ref(),
-                    )
-                    .await?;
-
-                let array_reader = build_array_reader(
-                    self.schema.clone(),
-                    predicate_projection,
-                    &row_group,
-                )?;
-
-                selection = Some(evaluate_predicate(
-                    batch_size,
-                    array_reader,
-                    selection,
-                    predicate.as_mut(),
-                )?);
-            }
-        }
-
-        if !selects_any(selection.as_ref()) {
-            return Ok((self, None));
-        }
-
-        row_group
-            .fetch(&mut self.input, meta, &projection, selection.as_ref())
-            .await?;
-
-        let reader = ParquetRecordBatchReader::new(
-            batch_size,
-            build_array_reader(self.schema.clone(), projection, &row_group)?,
-            selection,
-        );
-
-        Ok((self, Some(reader)))
-    }
-}
-
-enum StreamState<T> {
-    /// At the start of a new row group, or the end of the parquet stream
-    Init,
-    /// Decoding a batch
-    Decoding(ParquetRecordBatchReader),
-    /// Reading data from input
-    Reading(BoxFuture<'static, ReadResult<T>>),
-    /// Error
-    Error,
-}
-
-impl<T> std::fmt::Debug for StreamState<T> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        match self {
-            StreamState::Init => write!(f, "StreamState::Init"),
-            StreamState::Decoding(_) => write!(f, "StreamState::Decoding"),
-            StreamState::Reading(_) => write!(f, "StreamState::Reading"),
-            StreamState::Error => write!(f, "StreamState::Error"),
-        }
-    }
-}
-
-/// An asynchronous [`Stream`] of [`RecordBatch`] for a parquet file that can be
-/// constructed using [`ParquetRecordBatchStreamBuilder`]
-pub struct ParquetRecordBatchStream<T> {
-    metadata: Arc<ParquetMetaData>,
-
-    schema: SchemaRef,
-
-    row_groups: VecDeque<usize>,
-
-    projection: ProjectionMask,
-
-    batch_size: usize,
-
-    selection: Option<RowSelection>,
-
-    /// This is an option so it can be moved into a future
-    reader: Option<ReaderFactory<T>>,
-
-    state: StreamState<T>,
-}
-
-impl<T> std::fmt::Debug for ParquetRecordBatchStream<T> {
-    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("ParquetRecordBatchStream")
-            .field("metadata", &self.metadata)
-            .field("schema", &self.schema)
-            .field("batch_size", &self.batch_size)
-            .field("projection", &self.projection)
-            .field("state", &self.state)
-            .finish()
-    }
-}
-
-impl<T> ParquetRecordBatchStream<T> {
-    /// Returns the [`SchemaRef`] for this parquet file
-    pub fn schema(&self) -> &SchemaRef {
-        &self.schema
-    }
-}
-
-impl<T> Stream for ParquetRecordBatchStream<T>
-where
-    T: AsyncFileReader + Unpin + Send + 'static,
-{
-    type Item = Result<RecordBatch>;
-
-    fn poll_next(
-        mut self: Pin<&mut Self>,
-        cx: &mut Context<'_>,
-    ) -> Poll<Option<Self::Item>> {
-        loop {
-            match &mut self.state {
-                StreamState::Decoding(batch_reader) => match batch_reader.next() {
-                    Some(Ok(batch)) => return Poll::Ready(Some(Ok(batch))),
-                    Some(Err(e)) => {
-                        self.state = StreamState::Error;
-                        return Poll::Ready(Some(Err(ParquetError::ArrowError(
-                            e.to_string(),
-                        ))));
-                    }
-                    None => self.state = StreamState::Init,
-                },
-                StreamState::Init => {
-                    let row_group_idx = match self.row_groups.pop_front() {
-                        Some(idx) => idx,
-                        None => return Poll::Ready(None),
-                    };
-
-                    let reader = self.reader.take().expect("lost reader");
-
-                    let row_count =
-                        self.metadata.row_group(row_group_idx).num_rows() as usize;
-
-                    let selection =
-                        self.selection.as_mut().map(|s| s.split_off(row_count));
-
-                    let fut = reader
-                        .read_row_group(
-                            row_group_idx,
-                            selection,
-                            self.projection.clone(),
-                            self.batch_size,
-                        )
-                        .boxed();
-
-                    self.state = StreamState::Reading(fut)
-                }
-                StreamState::Reading(f) => match ready!(f.poll_unpin(cx)) {
-                    Ok((reader_factory, maybe_reader)) => {
-                        self.reader = Some(reader_factory);
-                        match maybe_reader {
-                            // Read records from [`ParquetRecordBatchReader`]
-                            Some(reader) => self.state = StreamState::Decoding(reader),
-                            // All rows skipped, read next row group
-                            None => self.state = StreamState::Init,
-                        }
-                    }
-                    Err(e) => {
-                        self.state = StreamState::Error;
-                        return Poll::Ready(Some(Err(e)));
-                    }
-                },
-                StreamState::Error => return Poll::Pending,
-            }
-        }
-    }
-}
-
-/// An in-memory collection of column chunks
-struct InMemoryRowGroup {
-    schema: SchemaDescPtr,
-    column_chunks: Vec<Option<InMemoryColumnChunk>>,
-    row_count: usize,
-}
-
-impl InMemoryRowGroup {
-    /// Fetches the necessary column data into memory
-    async fn fetch<T: AsyncFileReader + Send>(
-        &mut self,
-        input: &mut T,
-        metadata: &RowGroupMetaData,
-        projection: &ProjectionMask,
-        _selection: Option<&RowSelection>,
-    ) -> Result<()> {
-        // TODO: Use OffsetIndex and selection to prune pages
-
-        let fetch_ranges = self
-            .column_chunks
-            .iter()
-            .enumerate()
-            .into_iter()
-            .filter_map(|(idx, chunk)| {
-                (chunk.is_none() && projection.leaf_included(idx)).then(|| {
-                    let column = metadata.column(idx);
-                    let (start, length) = column.byte_range();
-                    start as usize..(start + length) as usize
-                })
-            })
-            .collect();
-
-        let mut chunk_data = input.get_byte_ranges(fetch_ranges).await?.into_iter();
-
-        for (idx, chunk) in self.column_chunks.iter_mut().enumerate() {
-            if chunk.is_some() || !projection.leaf_included(idx) {
-                continue;
-            }
-
-            let column = metadata.column(idx);
-
-            if let Some(data) = chunk_data.next() {
-                *chunk = Some(InMemoryColumnChunk {
-                    num_values: column.num_values(),
-                    compression: column.compression(),
-                    physical_type: column.column_type(),
-                    data,
-                });
-            }
-        }
-        Ok(())
-    }
-}
-
-impl RowGroupCollection for InMemoryRowGroup {
-    fn schema(&self) -> SchemaDescPtr {
-        self.schema.clone()
-    }
-
-    fn num_rows(&self) -> usize {
-        self.row_count
-    }
-
-    fn column_chunks(&self, i: usize) -> Result<Box<dyn PageIterator>> {
-        let page_reader = self.column_chunks[i].as_ref().unwrap().pages();
-
-        Ok(Box::new(ColumnChunkIterator {
-            schema: self.schema.clone(),
-            column_schema: self.schema.columns()[i].clone(),
-            reader: Some(page_reader),
-        }))
-    }
-}
-
-/// Data for a single column chunk
-#[derive(Clone)]
-struct InMemoryColumnChunk {
-    num_values: i64,
-    compression: Compression,
-    physical_type: crate::basic::Type,
-    data: Bytes,
-}
-
-impl InMemoryColumnChunk {
-    fn pages(&self) -> Result<Box<dyn PageReader>> {
-        let page_reader = InMemoryColumnChunkReader::new(self.clone())?;
-        Ok(Box::new(page_reader))
-    }
-}
-
-// A serialized implementation for Parquet [`PageReader`].
-struct InMemoryColumnChunkReader {
-    chunk: InMemoryColumnChunk,
-    decompressor: Option<Box<dyn Codec>>,
-    offset: usize,
-    seen_num_values: i64,
-    // If the next page header has already been "peeked", we will cache it here
-    next_page_header: Option<PageHeader>,
-}
-
-impl InMemoryColumnChunkReader {
-    /// Creates a new serialized page reader from file source.
-    fn new(chunk: InMemoryColumnChunk) -> Result<Self> {
-        let decompressor = create_codec(chunk.compression)?;
-        let result = Self {
-            chunk,
-            decompressor,
-            offset: 0,
-            seen_num_values: 0,
-            next_page_header: None,
-        };
-        Ok(result)
-    }
-}
-
-impl Iterator for InMemoryColumnChunkReader {
-    type Item = Result<Page>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.get_next_page().transpose()
-    }
-}
-
-impl PageReader for InMemoryColumnChunkReader {
-    fn get_next_page(&mut self) -> Result<Option<Page>> {
-        while self.seen_num_values < self.chunk.num_values {
-            let mut cursor = Cursor::new(&self.chunk.data.as_ref()[self.offset..]);
-            let page_header = if let Some(page_header) = self.next_page_header.take() {
-                // The next page header has already been peeked, so use the cached value
-                page_header
-            } else {
-                let page_header = read_page_header(&mut cursor)?;
-                self.offset += cursor.position() as usize;
-                page_header
-            };
-
-            let compressed_size = page_header.compressed_page_size as usize;
-
-            let start_offset = self.offset;
-            let end_offset = self.offset + compressed_size;
-            self.offset = end_offset;
-
-            let buffer = self.chunk.data.slice(start_offset..end_offset);
-
-            let result = match page_header.type_ {
-                PageType::DataPage | PageType::DataPageV2 => {
-                    let decoded = decode_page(
-                        page_header,
-                        buffer.into(),
-                        self.chunk.physical_type,
-                        self.decompressor.as_mut(),
-                    )?;
-                    self.seen_num_values += decoded.num_values() as i64;
-                    decoded
-                }
-                PageType::DictionaryPage => decode_page(
-                    page_header,
-                    buffer.into(),
-                    self.chunk.physical_type,
-                    self.decompressor.as_mut(),
-                )?,
-                _ => {
-                    // For unknown page type (e.g., INDEX_PAGE), skip and read next.
-                    continue;
-                }
-            };
-
-            return Ok(Some(result));
-        }
-
-        // We are at the end of this column chunk and no more page left. Return None.
-        Ok(None)
-    }
-
-    fn peek_next_page(&mut self) -> Result<Option<PageMetadata>> {
-        while self.seen_num_values < self.chunk.num_values {
-            return if let Some(buffered_header) = self.next_page_header.as_ref() {
-                if let Ok(page_metadata) = buffered_header.try_into() {
-                    Ok(Some(page_metadata))
-                } else {
-                    // For unknown page type (e.g., INDEX_PAGE), skip and read next.
-                    self.next_page_header = None;
-                    continue;
-                }
-            } else {
-                let mut cursor = Cursor::new(&self.chunk.data.as_ref()[self.offset..]);
-                let page_header = read_page_header(&mut cursor)?;
-                self.offset += cursor.position() as usize;
-
-                let page_metadata = if let Ok(page_metadata) = (&page_header).try_into() {
-                    Ok(Some(page_metadata))
-                } else {
-                    // For unknown page type (e.g., INDEX_PAGE), skip and read next.
-                    continue;
-                };
-
-                self.next_page_header = Some(page_header);
-                page_metadata
-            };
-        }
-
-        Ok(None)
-    }
-
-    fn skip_next_page(&mut self) -> Result<()> {
-        if let Some(buffered_header) = self.next_page_header.take() {
-            // The next page header has already been peeked, so just advance the offset
-            self.offset += buffered_header.compressed_page_size as usize;
-        } else {
-            let mut cursor = Cursor::new(&self.chunk.data.as_ref()[self.offset..]);
-            let page_header = read_page_header(&mut cursor)?;
-            self.offset += cursor.position() as usize;
-            self.offset += page_header.compressed_page_size as usize;
-        }
-
-        Ok(())
-    }
-}
-
-/// Implements [`PageIterator`] for a single column chunk, yielding a single [`PageReader`]
-struct ColumnChunkIterator {
-    schema: SchemaDescPtr,
-    column_schema: ColumnDescPtr,
-    reader: Option<Result<Box<dyn PageReader>>>,
-}
-
-impl Iterator for ColumnChunkIterator {
-    type Item = Result<Box<dyn PageReader>>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.reader.take()
-    }
-}
-
-impl PageIterator for ColumnChunkIterator {
-    fn schema(&mut self) -> Result<SchemaDescPtr> {
-        Ok(self.schema.clone())
-    }
-
-    fn column_schema(&mut self) -> Result<ColumnDescPtr> {
-        Ok(self.column_schema.clone())
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use crate::arrow::arrow_reader::ArrowPredicateFn;
-    use crate::arrow::{ArrowReader, ArrowWriter, ParquetFileArrowReader};
-    use crate::file::footer::parse_metadata;
-    use arrow::array::{Array, ArrayRef, Int32Array, StringArray};
-    use arrow::error::Result as ArrowResult;
-    use futures::TryStreamExt;
-    use std::sync::Mutex;
-
-    struct TestReader {
-        data: Bytes,
-        metadata: Arc<ParquetMetaData>,
-        requests: Arc<Mutex<Vec<Range<usize>>>>,
-    }
-
-    impl AsyncFileReader for TestReader {
-        fn get_bytes(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>> {
-            self.requests.lock().unwrap().push(range.clone());
-            futures::future::ready(Ok(self.data.slice(range))).boxed()
-        }
-
-        fn get_metadata(&mut self) -> BoxFuture<'_, Result<Arc<ParquetMetaData>>> {
-            futures::future::ready(Ok(self.metadata.clone())).boxed()
-        }
-    }
-
-    #[tokio::test]
-    async fn test_async_reader() {
-        let testdata = arrow::util::test_util::parquet_test_data();
-        let path = format!("{}/alltypes_plain.parquet", testdata);
-        let data = Bytes::from(std::fs::read(path).unwrap());
-
-        let metadata = crate::file::footer::parse_metadata(&data).unwrap();
-        let metadata = Arc::new(metadata);
-
-        assert_eq!(metadata.num_row_groups(), 1);
-
-        let async_reader = TestReader {
-            data: data.clone(),
-            metadata: metadata.clone(),
-            requests: Default::default(),
-        };
-
-        let requests = async_reader.requests.clone();
-        let builder = ParquetRecordBatchStreamBuilder::new(async_reader)
-            .await
-            .unwrap();
-
-        let mask = ProjectionMask::leaves(builder.parquet_schema(), vec![1, 2]);
-        let stream = builder
-            .with_projection(mask.clone())
-            .with_batch_size(1024)
-            .build()
-            .unwrap();
-
-        let async_batches: Vec<_> = stream.try_collect().await.unwrap();
-
-        let mut sync_reader = ParquetFileArrowReader::try_new(data).unwrap();
-        let sync_batches = sync_reader
-            .get_record_reader_by_columns(mask, 1024)
-            .unwrap()
-            .collect::<ArrowResult<Vec<_>>>()
-            .unwrap();
-
-        assert_eq!(async_batches, sync_batches);
-
-        let requests = requests.lock().unwrap();
-        let (offset_1, length_1) = metadata.row_group(0).column(1).byte_range();
-        let (offset_2, length_2) = metadata.row_group(0).column(2).byte_range();
-
-        assert_eq!(
-            &requests[..],
-            &[
-                offset_1 as usize..(offset_1 + length_1) as usize,
-                offset_2 as usize..(offset_2 + length_2) as usize
-            ]
-        );
-    }
-
-    #[tokio::test]
-    async fn test_in_memory_column_chunk_reader() {
-        let testdata = arrow::util::test_util::parquet_test_data();
-        let path = format!("{}/alltypes_plain.parquet", testdata);
-        let data = Bytes::from(std::fs::read(path).unwrap());
-
-        let metadata = crate::file::footer::parse_metadata(&data).unwrap();
-
-        let column_metadata = metadata.row_group(0).column(0);
-
-        let (start, length) = column_metadata.byte_range();
-
-        let column_data = data.slice(start as usize..(start + length) as usize);
-
-        let mut reader = InMemoryColumnChunkReader::new(InMemoryColumnChunk {
-            num_values: column_metadata.num_values(),
-            compression: column_metadata.compression(),
-            physical_type: column_metadata.column_type(),
-            data: column_data,
-        })
-        .expect("building reader");
-
-        let first_page = reader
-            .peek_next_page()
-            .expect("peeking first page")
-            .expect("first page is empty");
-
-        assert!(first_page.is_dict);
-        assert_eq!(first_page.num_rows, 0);
-
-        let first_page = reader
-            .get_next_page()
-            .expect("getting first page")
-            .expect("first page is empty");
-
-        assert_eq!(
-            first_page.page_type(),
-            crate::basic::PageType::DICTIONARY_PAGE
-        );
-        assert_eq!(first_page.num_values(), 8);
-
-        let second_page = reader
-            .peek_next_page()
-            .expect("peeking second page")
-            .expect("second page is empty");
-
-        assert!(!second_page.is_dict);
-        assert_eq!(second_page.num_rows, 8);
-
-        let second_page = reader
-            .get_next_page()
-            .expect("getting second page")
-            .expect("second page is empty");
-
-        assert_eq!(second_page.page_type(), crate::basic::PageType::DATA_PAGE);
-        assert_eq!(second_page.num_values(), 8);
-
-        let third_page = reader.peek_next_page().expect("getting third page");
-
-        assert!(third_page.is_none());
-
-        let third_page = reader.get_next_page().expect("getting third page");
-
-        assert!(third_page.is_none());
-    }
-
-    #[tokio::test]
-    async fn test_in_memory_column_chunk_reader_skip_page() {
-        let testdata = arrow::util::test_util::parquet_test_data();
-        let path = format!("{}/alltypes_plain.parquet", testdata);
-        let data = Bytes::from(std::fs::read(path).unwrap());
-
-        let metadata = crate::file::footer::parse_metadata(&data).unwrap();
-
-        let column_metadata = metadata.row_group(0).column(0);
-
-        let (start, length) = column_metadata.byte_range();
-
-        let column_data = data.slice(start as usize..(start + length) as usize);
-
-        let mut reader = InMemoryColumnChunkReader::new(InMemoryColumnChunk {
-            num_values: column_metadata.num_values(),
-            compression: column_metadata.compression(),
-            physical_type: column_metadata.column_type(),
-            data: column_data,
-        })
-        .expect("building reader");
-
-        reader.skip_next_page().expect("skipping first page");
-
-        let second_page = reader
-            .get_next_page()
-            .expect("getting second page")
-            .expect("second page is empty");
-
-        assert_eq!(second_page.page_type(), crate::basic::PageType::DATA_PAGE);
-        assert_eq!(second_page.num_values(), 8);
-    }
-
-    #[tokio::test]
-    async fn test_row_filter() {
-        let a = StringArray::from_iter_values(["a", "b", "b", "b", "c", "c"]);
-        let b = StringArray::from_iter_values(["1", "2", "3", "4", "5", "6"]);
-        let c = Int32Array::from_iter(0..6);
-        let data = RecordBatch::try_from_iter([
-            ("a", Arc::new(a) as ArrayRef),
-            ("b", Arc::new(b) as ArrayRef),
-            ("c", Arc::new(c) as ArrayRef),
-        ])
-        .unwrap();
-
-        let mut buf = Vec::with_capacity(1024);
-        let mut writer = ArrowWriter::try_new(&mut buf, data.schema(), None).unwrap();
-        writer.write(&data).unwrap();
-        writer.close().unwrap();
-
-        let data: Bytes = buf.into();
-        let metadata = parse_metadata(&data).unwrap();
-        let parquet_schema = metadata.file_metadata().schema_descr_ptr();
-
-        let test = TestReader {
-            data,
-            metadata: Arc::new(metadata),
-            requests: Default::default(),
-        };
-        let requests = test.requests.clone();
-
-        let a_filter = ArrowPredicateFn::new(
-            ProjectionMask::leaves(&parquet_schema, vec![0]),
-            |batch| arrow::compute::eq_dyn_utf8_scalar(batch.column(0), "b"),
-        );
-
-        let b_filter = ArrowPredicateFn::new(
-            ProjectionMask::leaves(&parquet_schema, vec![1]),
-            |batch| arrow::compute::eq_dyn_utf8_scalar(batch.column(0), "4"),
-        );
-
-        let filter = RowFilter::new(vec![Box::new(a_filter), Box::new(b_filter)]);
-
-        let mask = ProjectionMask::leaves(&parquet_schema, vec![0, 2]);
-        let stream = ParquetRecordBatchStreamBuilder::new(test)
-            .await
-            .unwrap()
-            .with_projection(mask.clone())
-            .with_batch_size(1024)
-            .with_row_filter(filter)
-            .build()
-            .unwrap();
-
-        let batches: Vec<_> = stream.try_collect().await.unwrap();
-        assert_eq!(batches.len(), 1);
-
-        let batch = &batches[0];
-        assert_eq!(batch.num_rows(), 1);
-        assert_eq!(batch.num_columns(), 2);
-
-        let col = batch.column(0);
-        let val = col.as_any().downcast_ref::<StringArray>().unwrap().value(0);
-        assert_eq!(val, "b");
-
-        let col = batch.column(1);
-        let val = col.as_any().downcast_ref::<Int32Array>().unwrap().value(0);
-        assert_eq!(val, 3);
-
-        // Should only have made 3 requests
-        assert_eq!(requests.lock().unwrap().len(), 3);
-    }
-}
diff --git a/parquet/src/arrow/async_reader/metadata.rs b/parquet/src/arrow/async_reader/metadata.rs
new file mode 100644
index 000000000000..9224ea3f68a8
--- /dev/null
+++ b/parquet/src/arrow/async_reader/metadata.rs
@@ -0,0 +1,361 @@
+// 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.
+
+use crate::arrow::async_reader::AsyncFileReader;
+use crate::errors::{ParquetError, Result};
+use crate::file::footer::{decode_footer, decode_metadata};
+use crate::file::metadata::ParquetMetaData;
+use crate::file::page_index::index::Index;
+use crate::file::page_index::index_reader::{acc_range, decode_column_index, decode_offset_index};
+use bytes::Bytes;
+use futures::future::BoxFuture;
+use futures::FutureExt;
+use std::future::Future;
+use std::ops::Range;
+
+/// A data source that can be used with [`MetadataLoader`] to load [`ParquetMetaData`]
+pub trait MetadataFetch {
+    fn fetch(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>>;
+}
+
+impl<'a, T: AsyncFileReader> MetadataFetch for &'a mut T {
+    fn fetch(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>> {
+        self.get_bytes(range)
+    }
+}
+
+/// An asynchronous interface to load [`ParquetMetaData`] from an async source
+pub struct MetadataLoader<F> {
+    /// Function that fetches byte ranges asynchronously
+    fetch: F,
+    /// The in-progress metadata
+    metadata: ParquetMetaData,
+    /// The offset and bytes of remaining unparsed data
+    remainder: Option<(usize, Bytes)>,
+}
+
+impl<F: MetadataFetch> MetadataLoader<F> {
+    /// Create a new [`MetadataLoader`] by reading the footer information
+    ///
+    /// See [`fetch_parquet_metadata`] for the meaning of the individual parameters
+    pub async fn load(mut fetch: F, file_size: usize, prefetch: Option<usize>) -> Result<Self> {
+        if file_size < 8 {
+            return Err(ParquetError::EOF(format!(
+                "file size of {file_size} is less than footer"
+            )));
+        }
+
+        // If a size hint is provided, read more than the minimum size
+        // to try and avoid a second fetch.
+        let footer_start = if let Some(size_hint) = prefetch {
+            file_size.saturating_sub(size_hint)
+        } else {
+            file_size - 8
+        };
+
+        let suffix = fetch.fetch(footer_start..file_size).await?;
+        let suffix_len = suffix.len();
+
+        let mut footer = [0; 8];
+        footer.copy_from_slice(&suffix[suffix_len - 8..suffix_len]);
+
+        let length = decode_footer(&footer)?;
+
+        if file_size < length + 8 {
+            return Err(ParquetError::EOF(format!(
+                "file size of {} is less than footer + metadata {}",
+                file_size,
+                length + 8
+            )));
+        }
+
+        // Did not fetch the entire file metadata in the initial read, need to make a second request
+        let (metadata, remainder) = if length > suffix_len - 8 {
+            let metadata_start = file_size - length - 8;
+            let meta = fetch.fetch(metadata_start..file_size - 8).await?;
+            (decode_metadata(&meta)?, None)
+        } else {
+            let metadata_start = file_size - length - 8 - footer_start;
+
+            let slice = &suffix[metadata_start..suffix_len - 8];
+            (
+                decode_metadata(slice)?,
+                Some((footer_start, suffix.slice(..metadata_start))),
+            )
+        };
+
+        Ok(Self {
+            fetch,
+            metadata,
+            remainder,
+        })
+    }
+
+    /// Create a new [`MetadataLoader`] from an existing [`ParquetMetaData`]
+    pub fn new(fetch: F, metadata: ParquetMetaData) -> Self {
+        Self {
+            fetch,
+            metadata,
+            remainder: None,
+        }
+    }
+
+    /// Loads the page index, if any
+    ///
+    /// * `column_index`: if true will load column index
+    /// * `offset_index`: if true will load offset index
+    pub async fn load_page_index(&mut self, column_index: bool, offset_index: bool) -> Result<()> {
+        if !column_index && !offset_index {
+            return Ok(());
+        }
+
+        let mut range = None;
+        for c in self.metadata.row_groups().iter().flat_map(|r| r.columns()) {
+            range = acc_range(range, c.column_index_range());
+            range = acc_range(range, c.offset_index_range());
+        }
+        let range = match range {
+            None => return Ok(()),
+            Some(range) => range,
+        };
+
+        let data = match &self.remainder {
+            Some((remainder_start, remainder)) if *remainder_start <= range.start => {
+                let offset = range.start - *remainder_start;
+                remainder.slice(offset..range.end - *remainder_start + offset)
+            }
+            // Note: this will potentially fetch data already in remainder, this keeps things simple
+            _ => self.fetch.fetch(range.start..range.end).await?,
+        };
+
+        // Sanity check
+        assert_eq!(data.len(), range.end - range.start);
+        let offset = range.start;
+
+        if column_index {
+            let index = self
+                .metadata
+                .row_groups()
+                .iter()
+                .map(|x| {
+                    x.columns()
+                        .iter()
+                        .map(|c| match c.column_index_range() {
+                            Some(r) => decode_column_index(
+                                &data[r.start - offset..r.end - offset],
+                                c.column_type(),
+                            ),
+                            None => Ok(Index::NONE),
+                        })
+                        .collect::<Result<Vec<_>>>()
+                })
+                .collect::<Result<Vec<_>>>()?;
+
+            self.metadata.set_column_index(Some(index));
+        }
+
+        if offset_index {
+            let index = self
+                .metadata
+                .row_groups()
+                .iter()
+                .map(|x| {
+                    x.columns()
+                        .iter()
+                        .map(|c| match c.offset_index_range() {
+                            Some(r) => decode_offset_index(&data[r.start - offset..r.end - offset]),
+                            None => Err(general_err!("missing offset index")),
+                        })
+                        .collect::<Result<Vec<_>>>()
+                })
+                .collect::<Result<Vec<_>>>()?;
+
+            self.metadata.set_offset_index(Some(index));
+        }
+
+        Ok(())
+    }
+
+    /// Returns the finished [`ParquetMetaData`]
+    pub fn finish(self) -> ParquetMetaData {
+        self.metadata
+    }
+}
+
+struct MetadataFetchFn<F>(F);
+
+impl<F, Fut> MetadataFetch for MetadataFetchFn<F>
+where
+    F: FnMut(Range<usize>) -> Fut + Send,
+    Fut: Future<Output = Result<Bytes>> + Send,
+{
+    fn fetch(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>> {
+        async move { self.0(range).await }.boxed()
+    }
+}
+
+/// Fetches parquet metadata
+///
+/// Parameters:
+/// * fetch: an async function that can fetch byte ranges
+/// * file_size: the total size of the parquet file
+/// * footer_size_hint: footer prefetch size (see comments below)
+///
+/// The length of the parquet footer, which contains file metadata, is not
+/// known up front. Therefore this function will first issue a request to read
+/// the last 8 bytes to determine the footer's precise length, before
+/// issuing a second request to fetch the metadata bytes
+///
+/// If `prefetch` is `Some`, this will read the specified number of bytes
+/// in the first request, instead of 8, and only issue further requests
+/// if additional bytes are needed. Providing a `prefetch` hint can therefore
+/// significantly reduce the number of `fetch` requests, and consequently latency
+pub async fn fetch_parquet_metadata<F, Fut>(
+    fetch: F,
+    file_size: usize,
+    prefetch: Option<usize>,
+) -> Result<ParquetMetaData>
+where
+    F: FnMut(Range<usize>) -> Fut + Send,
+    Fut: Future<Output = Result<Bytes>> + Send,
+{
+    let fetch = MetadataFetchFn(fetch);
+    let loader = MetadataLoader::load(fetch, file_size, prefetch).await?;
+    Ok(loader.finish())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::file::reader::{FileReader, Length, SerializedFileReader};
+    use crate::util::test_common::file_util::get_test_file;
+    use std::fs::File;
+    use std::io::{Read, Seek, SeekFrom};
+    use std::sync::atomic::{AtomicUsize, Ordering};
+
+    fn read_range(file: &mut File, range: Range<usize>) -> Result<Bytes> {
+        file.seek(SeekFrom::Start(range.start as _))?;
+        let len = range.end - range.start;
+        let mut buf = Vec::with_capacity(len);
+        file.take(len as _).read_to_end(&mut buf)?;
+        Ok(buf.into())
+    }
+
+    #[tokio::test]
+    async fn test_simple() {
+        let mut file = get_test_file("nulls.snappy.parquet");
+        let len = file.len() as usize;
+
+        let reader = SerializedFileReader::new(file.try_clone().unwrap()).unwrap();
+        let expected = reader.metadata().file_metadata().schema();
+        let fetch_count = AtomicUsize::new(0);
+
+        let mut fetch = |range| {
+            fetch_count.fetch_add(1, Ordering::SeqCst);
+            futures::future::ready(read_range(&mut file, range))
+        };
+
+        let actual = fetch_parquet_metadata(&mut fetch, len, None).await.unwrap();
+        assert_eq!(actual.file_metadata().schema(), expected);
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 2);
+
+        // Metadata hint too small
+        fetch_count.store(0, Ordering::SeqCst);
+        let actual = fetch_parquet_metadata(&mut fetch, len, Some(10))
+            .await
+            .unwrap();
+        assert_eq!(actual.file_metadata().schema(), expected);
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 2);
+
+        // Metadata hint too large
+        fetch_count.store(0, Ordering::SeqCst);
+        let actual = fetch_parquet_metadata(&mut fetch, len, Some(500))
+            .await
+            .unwrap();
+        assert_eq!(actual.file_metadata().schema(), expected);
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 1);
+
+        // Metadata hint exactly correct
+        fetch_count.store(0, Ordering::SeqCst);
+        let actual = fetch_parquet_metadata(&mut fetch, len, Some(428))
+            .await
+            .unwrap();
+        assert_eq!(actual.file_metadata().schema(), expected);
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 1);
+
+        let err = fetch_parquet_metadata(&mut fetch, 4, None)
+            .await
+            .unwrap_err()
+            .to_string();
+        assert_eq!(err, "EOF: file size of 4 is less than footer");
+
+        let err = fetch_parquet_metadata(&mut fetch, 20, None)
+            .await
+            .unwrap_err()
+            .to_string();
+        assert_eq!(err, "Parquet error: Invalid Parquet file. Corrupt footer");
+    }
+
+    #[tokio::test]
+    async fn test_page_index() {
+        let mut file = get_test_file("alltypes_tiny_pages.parquet");
+        let len = file.len() as usize;
+        let fetch_count = AtomicUsize::new(0);
+        let mut fetch = |range| {
+            fetch_count.fetch_add(1, Ordering::SeqCst);
+            futures::future::ready(read_range(&mut file, range))
+        };
+
+        let f = MetadataFetchFn(&mut fetch);
+        let mut loader = MetadataLoader::load(f, len, None).await.unwrap();
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 2);
+        loader.load_page_index(true, true).await.unwrap();
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 3);
+        let metadata = loader.finish();
+        assert!(metadata.offset_index().is_some() && metadata.column_index().is_some());
+
+        // Prefetch just footer exactly
+        fetch_count.store(0, Ordering::SeqCst);
+        let f = MetadataFetchFn(&mut fetch);
+        let mut loader = MetadataLoader::load(f, len, Some(1729)).await.unwrap();
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 1);
+        loader.load_page_index(true, true).await.unwrap();
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 2);
+        let metadata = loader.finish();
+        assert!(metadata.offset_index().is_some() && metadata.column_index().is_some());
+
+        // Prefetch more than footer but not enough
+        fetch_count.store(0, Ordering::SeqCst);
+        let f = MetadataFetchFn(&mut fetch);
+        let mut loader = MetadataLoader::load(f, len, Some(130649)).await.unwrap();
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 1);
+        loader.load_page_index(true, true).await.unwrap();
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 2);
+        let metadata = loader.finish();
+        assert!(metadata.offset_index().is_some() && metadata.column_index().is_some());
+
+        // Prefetch exactly enough
+        fetch_count.store(0, Ordering::SeqCst);
+        let f = MetadataFetchFn(&mut fetch);
+        let mut loader = MetadataLoader::load(f, len, Some(130650)).await.unwrap();
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 1);
+        loader.load_page_index(true, true).await.unwrap();
+        assert_eq!(fetch_count.load(Ordering::SeqCst), 1);
+        let metadata = loader.finish();
+        assert!(metadata.offset_index().is_some() && metadata.column_index().is_some());
+    }
+}
diff --git a/parquet/src/arrow/async_reader/mod.rs b/parquet/src/arrow/async_reader/mod.rs
new file mode 100644
index 000000000000..80a554026d9a
--- /dev/null
+++ b/parquet/src/arrow/async_reader/mod.rs
@@ -0,0 +1,1860 @@
+// 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.
+
+//! Provides `async` API for reading parquet files as
+//! [`RecordBatch`]es
+//!
+//! ```
+//! # #[tokio::main(flavor="current_thread")]
+//! # async fn main() {
+//! #
+//! # use arrow_array::RecordBatch;
+//! # use arrow::util::pretty::pretty_format_batches;
+//! # use futures::TryStreamExt;
+//! # use tokio::fs::File;
+//! #
+//! # use parquet::arrow::{ParquetRecordBatchStreamBuilder, ProjectionMask};
+//! #
+//! # fn assert_batches_eq(batches: &[RecordBatch], expected_lines: &[&str]) {
+//! #     let formatted = pretty_format_batches(batches).unwrap().to_string();
+//! #     let actual_lines: Vec<_> = formatted.trim().lines().collect();
+//! #     assert_eq!(
+//! #          &actual_lines, expected_lines,
+//! #          "\n\nexpected:\n\n{:#?}\nactual:\n\n{:#?}\n\n",
+//! #          expected_lines, actual_lines
+//! #      );
+//! #  }
+//! #
+//! let testdata = arrow::util::test_util::parquet_test_data();
+//! let path = format!("{}/alltypes_plain.parquet", testdata);
+//! let file = File::open(path).await.unwrap();
+//!
+//! let builder = ParquetRecordBatchStreamBuilder::new(file)
+//!     .await
+//!     .unwrap()
+//!     .with_batch_size(3);
+//!
+//! let file_metadata = builder.metadata().file_metadata();
+//! let mask = ProjectionMask::roots(file_metadata.schema_descr(), [1, 2, 6]);
+//!
+//! let stream = builder.with_projection(mask).build().unwrap();
+//! let results = stream.try_collect::<Vec<_>>().await.unwrap();
+//! assert_eq!(results.len(), 3);
+//!
+//! assert_batches_eq(
+//!     &results,
+//!     &[
+//!         "+----------+-------------+-----------+",
+//!         "| bool_col | tinyint_col | float_col |",
+//!         "+----------+-------------+-----------+",
+//!         "| true     | 0           | 0.0       |",
+//!         "| false    | 1           | 1.1       |",
+//!         "| true     | 0           | 0.0       |",
+//!         "| false    | 1           | 1.1       |",
+//!         "| true     | 0           | 0.0       |",
+//!         "| false    | 1           | 1.1       |",
+//!         "| true     | 0           | 0.0       |",
+//!         "| false    | 1           | 1.1       |",
+//!         "+----------+-------------+-----------+",
+//!      ],
+//!  );
+//! # }
+//! ```
+
+use std::collections::VecDeque;
+use std::fmt::Formatter;
+use std::io::SeekFrom;
+use std::ops::Range;
+use std::pin::Pin;
+use std::sync::Arc;
+use std::task::{Context, Poll};
+
+use bytes::{Buf, Bytes};
+use futures::future::{BoxFuture, FutureExt};
+use futures::ready;
+use futures::stream::Stream;
+use tokio::io::{AsyncRead, AsyncReadExt, AsyncSeek, AsyncSeekExt};
+
+use arrow_array::RecordBatch;
+use arrow_schema::{DataType, Fields, Schema, SchemaRef};
+
+use crate::arrow::array_reader::{build_array_reader, RowGroups};
+use crate::arrow::arrow_reader::{
+    apply_range, evaluate_predicate, selects_any, ArrowReaderBuilder, ArrowReaderMetadata,
+    ArrowReaderOptions, ParquetRecordBatchReader, RowFilter, RowSelection,
+};
+use crate::arrow::ProjectionMask;
+
+use crate::bloom_filter::{
+    chunk_read_bloom_filter_header_and_offset, Sbbf, SBBF_HEADER_SIZE_ESTIMATE,
+};
+use crate::column::page::{PageIterator, PageReader};
+use crate::errors::{ParquetError, Result};
+use crate::file::footer::{decode_footer, decode_metadata};
+use crate::file::metadata::{ParquetMetaData, RowGroupMetaData};
+use crate::file::reader::{ChunkReader, Length, SerializedPageReader};
+use crate::file::FOOTER_SIZE;
+use crate::format::{BloomFilterAlgorithm, BloomFilterCompression, BloomFilterHash, PageLocation};
+
+mod metadata;
+pub use metadata::*;
+
+#[cfg(feature = "object_store")]
+mod store;
+
+use crate::arrow::schema::ParquetField;
+#[cfg(feature = "object_store")]
+pub use store::*;
+
+/// The asynchronous interface used by [`ParquetRecordBatchStream`] to read parquet files
+pub trait AsyncFileReader: Send {
+    /// Retrieve the bytes in `range`
+    fn get_bytes(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>>;
+
+    /// Retrieve multiple byte ranges. The default implementation will call `get_bytes` sequentially
+    fn get_byte_ranges(&mut self, ranges: Vec<Range<usize>>) -> BoxFuture<'_, Result<Vec<Bytes>>> {
+        async move {
+            let mut result = Vec::with_capacity(ranges.len());
+
+            for range in ranges.into_iter() {
+                let data = self.get_bytes(range).await?;
+                result.push(data);
+            }
+
+            Ok(result)
+        }
+        .boxed()
+    }
+
+    /// Provides asynchronous access to the [`ParquetMetaData`] of a parquet file,
+    /// allowing fine-grained control over how metadata is sourced, in particular allowing
+    /// for caching, pre-fetching, catalog metadata, etc...
+    fn get_metadata(&mut self) -> BoxFuture<'_, Result<Arc<ParquetMetaData>>>;
+}
+
+impl AsyncFileReader for Box<dyn AsyncFileReader> {
+    fn get_bytes(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>> {
+        self.as_mut().get_bytes(range)
+    }
+
+    fn get_byte_ranges(&mut self, ranges: Vec<Range<usize>>) -> BoxFuture<'_, Result<Vec<Bytes>>> {
+        self.as_mut().get_byte_ranges(ranges)
+    }
+
+    fn get_metadata(&mut self) -> BoxFuture<'_, Result<Arc<ParquetMetaData>>> {
+        self.as_mut().get_metadata()
+    }
+}
+
+impl<T: AsyncRead + AsyncSeek + Unpin + Send> AsyncFileReader for T {
+    fn get_bytes(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>> {
+        async move {
+            self.seek(SeekFrom::Start(range.start as u64)).await?;
+
+            let to_read = range.end - range.start;
+            let mut buffer = Vec::with_capacity(to_read);
+            let read = self.take(to_read as u64).read_to_end(&mut buffer).await?;
+            if read != to_read {
+                return Err(eof_err!("expected to read {} bytes, got {}", to_read, read));
+            }
+
+            Ok(buffer.into())
+        }
+        .boxed()
+    }
+
+    fn get_metadata(&mut self) -> BoxFuture<'_, Result<Arc<ParquetMetaData>>> {
+        const FOOTER_SIZE_I64: i64 = FOOTER_SIZE as i64;
+        async move {
+            self.seek(SeekFrom::End(-FOOTER_SIZE_I64)).await?;
+
+            let mut buf = [0_u8; FOOTER_SIZE];
+            self.read_exact(&mut buf).await?;
+
+            let metadata_len = decode_footer(&buf)?;
+            self.seek(SeekFrom::End(-FOOTER_SIZE_I64 - metadata_len as i64))
+                .await?;
+
+            let mut buf = Vec::with_capacity(metadata_len);
+            self.take(metadata_len as _).read_to_end(&mut buf).await?;
+
+            Ok(Arc::new(decode_metadata(&buf)?))
+        }
+        .boxed()
+    }
+}
+
+impl ArrowReaderMetadata {
+    /// Returns a new [`ArrowReaderMetadata`] for this builder
+    ///
+    /// See [`ParquetRecordBatchStreamBuilder::new_with_metadata`] for how this can be used
+    pub async fn load_async<T: AsyncFileReader>(
+        input: &mut T,
+        options: ArrowReaderOptions,
+    ) -> Result<Self> {
+        let mut metadata = input.get_metadata().await?;
+
+        if options.page_index
+            && metadata.column_index().is_none()
+            && metadata.offset_index().is_none()
+        {
+            let m = Arc::try_unwrap(metadata).unwrap_or_else(|e| e.as_ref().clone());
+            let mut loader = MetadataLoader::new(input, m);
+            loader.load_page_index(true, true).await?;
+            metadata = Arc::new(loader.finish())
+        }
+        Self::try_new(metadata, options)
+    }
+}
+
+#[doc(hidden)]
+/// A newtype used within [`ReaderOptionsBuilder`] to distinguish sync readers from async
+///
+/// Allows sharing the same builder for both the sync and async versions, whilst also not
+/// breaking the pre-existing ParquetRecordBatchStreamBuilder API
+pub struct AsyncReader<T>(T);
+
+/// A builder used to construct a [`ParquetRecordBatchStream`] for a parquet file
+///
+/// In particular, this handles reading the parquet file metadata, allowing consumers
+/// to use this information to select what specific columns, row groups, etc...
+/// they wish to be read by the resulting stream
+///
+/// See [`ArrowReaderBuilder`] for additional member functions
+pub type ParquetRecordBatchStreamBuilder<T> = ArrowReaderBuilder<AsyncReader<T>>;
+
+impl<T: AsyncFileReader + Send + 'static> ParquetRecordBatchStreamBuilder<T> {
+    /// Create a new [`ParquetRecordBatchStreamBuilder`] with the provided parquet file
+    pub async fn new(input: T) -> Result<Self> {
+        Self::new_with_options(input, Default::default()).await
+    }
+
+    /// Create a new [`ParquetRecordBatchStreamBuilder`] with the provided parquet file
+    /// and [`ArrowReaderOptions`]
+    pub async fn new_with_options(mut input: T, options: ArrowReaderOptions) -> Result<Self> {
+        let metadata = ArrowReaderMetadata::load_async(&mut input, options).await?;
+        Ok(Self::new_with_metadata(input, metadata))
+    }
+
+    /// Create a [`ParquetRecordBatchStreamBuilder`] from the provided [`ArrowReaderMetadata`]
+    ///
+    /// This allows loading metadata once and using it to create multiple builders with
+    /// potentially different settings
+    ///
+    /// ```
+    /// # use std::fs::metadata;
+    /// # use std::sync::Arc;
+    /// # use bytes::Bytes;
+    /// # use arrow_array::{Int32Array, RecordBatch};
+    /// # use arrow_schema::{DataType, Field, Schema};
+    /// # use parquet::arrow::arrow_reader::ArrowReaderMetadata;
+    /// # use parquet::arrow::{ArrowWriter, ParquetRecordBatchStreamBuilder};
+    /// # use tempfile::tempfile;
+    /// # use futures::StreamExt;
+    /// # #[tokio::main(flavor="current_thread")]
+    /// # async fn main() {
+    /// #
+    /// let mut file = tempfile().unwrap();
+    /// # let schema = Arc::new(Schema::new(vec![Field::new("i32", DataType::Int32, false)]));
+    /// # let mut writer = ArrowWriter::try_new(&mut file, schema.clone(), None).unwrap();
+    /// # let batch = RecordBatch::try_new(schema, vec![Arc::new(Int32Array::from(vec![1, 2, 3]))]).unwrap();
+    /// # writer.write(&batch).unwrap();
+    /// # writer.close().unwrap();
+    /// #
+    /// let mut file = tokio::fs::File::from_std(file);
+    /// let meta = ArrowReaderMetadata::load_async(&mut file, Default::default()).await.unwrap();
+    /// let mut a = ParquetRecordBatchStreamBuilder::new_with_metadata(
+    ///     file.try_clone().await.unwrap(),
+    ///     meta.clone()
+    /// ).build().unwrap();
+    /// let mut b = ParquetRecordBatchStreamBuilder::new_with_metadata(file, meta).build().unwrap();
+    ///
+    /// // Should be able to read from both in parallel
+    /// assert_eq!(a.next().await.unwrap().unwrap(), b.next().await.unwrap().unwrap());
+    /// # }
+    /// ```
+    pub fn new_with_metadata(input: T, metadata: ArrowReaderMetadata) -> Self {
+        Self::new_builder(AsyncReader(input), metadata)
+    }
+
+    /// Read bloom filter for a column in a row group
+    /// Returns `None` if the column does not have a bloom filter
+    ///
+    /// We should call this function after other forms pruning, such as projection and predicate pushdown.
+    pub async fn get_row_group_column_bloom_filter(
+        &mut self,
+        row_group_idx: usize,
+        column_idx: usize,
+    ) -> Result<Option<Sbbf>> {
+        let metadata = self.metadata.row_group(row_group_idx);
+        let column_metadata = metadata.column(column_idx);
+
+        let offset: usize = if let Some(offset) = column_metadata.bloom_filter_offset() {
+            offset
+                .try_into()
+                .map_err(|_| ParquetError::General("Bloom filter offset is invalid".to_string()))?
+        } else {
+            return Ok(None);
+        };
+
+        let buffer = match column_metadata.bloom_filter_length() {
+            Some(length) => self.input.0.get_bytes(offset..offset + length as usize),
+            None => self
+                .input
+                .0
+                .get_bytes(offset..offset + SBBF_HEADER_SIZE_ESTIMATE),
+        }
+        .await?;
+
+        let (header, bitset_offset) =
+            chunk_read_bloom_filter_header_and_offset(offset as u64, buffer.clone())?;
+
+        match header.algorithm {
+            BloomFilterAlgorithm::BLOCK(_) => {
+                // this match exists to future proof the singleton algorithm enum
+            }
+        }
+        match header.compression {
+            BloomFilterCompression::UNCOMPRESSED(_) => {
+                // this match exists to future proof the singleton compression enum
+            }
+        }
+        match header.hash {
+            BloomFilterHash::XXHASH(_) => {
+                // this match exists to future proof the singleton hash enum
+            }
+        }
+
+        let bitset = match column_metadata.bloom_filter_length() {
+            Some(_) => buffer.slice((bitset_offset as usize - offset)..),
+            None => {
+                let bitset_length: usize = header.num_bytes.try_into().map_err(|_| {
+                    ParquetError::General("Bloom filter length is invalid".to_string())
+                })?;
+                self.input
+                    .0
+                    .get_bytes(bitset_offset as usize..bitset_offset as usize + bitset_length)
+                    .await?
+            }
+        };
+        Ok(Some(Sbbf::new(&bitset)))
+    }
+
+    /// Build a new [`ParquetRecordBatchStream`]
+    pub fn build(self) -> Result<ParquetRecordBatchStream<T>> {
+        let num_row_groups = self.metadata.row_groups().len();
+
+        let row_groups = match self.row_groups {
+            Some(row_groups) => {
+                if let Some(col) = row_groups.iter().find(|x| **x >= num_row_groups) {
+                    return Err(general_err!(
+                        "row group {} out of bounds 0..{}",
+                        col,
+                        num_row_groups
+                    ));
+                }
+                row_groups.into()
+            }
+            None => (0..self.metadata.row_groups().len()).collect(),
+        };
+
+        // Try to avoid allocate large buffer
+        let batch_size = self
+            .batch_size
+            .min(self.metadata.file_metadata().num_rows() as usize);
+        let reader = ReaderFactory {
+            input: self.input.0,
+            filter: self.filter,
+            metadata: self.metadata.clone(),
+            fields: self.fields,
+            limit: self.limit,
+            offset: self.offset,
+        };
+
+        // Ensure schema of ParquetRecordBatchStream respects projection, and does
+        // not store metadata (same as for ParquetRecordBatchReader and emitted RecordBatches)
+        let projected_fields = match reader.fields.as_deref().map(|pf| &pf.arrow_type) {
+            Some(DataType::Struct(fields)) => {
+                fields.filter_leaves(|idx, _| self.projection.leaf_included(idx))
+            }
+            None => Fields::empty(),
+            _ => unreachable!("Must be Struct for root type"),
+        };
+        let schema = Arc::new(Schema::new(projected_fields));
+
+        Ok(ParquetRecordBatchStream {
+            metadata: self.metadata,
+            batch_size,
+            row_groups,
+            projection: self.projection,
+            selection: self.selection,
+            schema,
+            reader: Some(reader),
+            state: StreamState::Init,
+        })
+    }
+}
+
+type ReadResult<T> = Result<(ReaderFactory<T>, Option<ParquetRecordBatchReader>)>;
+
+/// [`ReaderFactory`] is used by [`ParquetRecordBatchStream`] to create
+/// [`ParquetRecordBatchReader`]
+struct ReaderFactory<T> {
+    metadata: Arc<ParquetMetaData>,
+
+    fields: Option<Arc<ParquetField>>,
+
+    input: T,
+
+    filter: Option<RowFilter>,
+
+    limit: Option<usize>,
+
+    offset: Option<usize>,
+}
+
+impl<T> ReaderFactory<T>
+where
+    T: AsyncFileReader + Send,
+{
+    /// Reads the next row group with the provided `selection`, `projection` and `batch_size`
+    ///
+    /// Note: this captures self so that the resulting future has a static lifetime
+    async fn read_row_group(
+        mut self,
+        row_group_idx: usize,
+        mut selection: Option<RowSelection>,
+        projection: ProjectionMask,
+        batch_size: usize,
+    ) -> ReadResult<T> {
+        // TODO: calling build_array multiple times is wasteful
+
+        let meta = self.metadata.row_group(row_group_idx);
+        let page_locations = self
+            .metadata
+            .offset_index()
+            .map(|x| x[row_group_idx].as_slice());
+
+        let mut row_group = InMemoryRowGroup {
+            metadata: meta,
+            // schema: meta.schema_descr_ptr(),
+            row_count: meta.num_rows() as usize,
+            column_chunks: vec![None; meta.columns().len()],
+            page_locations,
+        };
+
+        if let Some(filter) = self.filter.as_mut() {
+            for predicate in filter.predicates.iter_mut() {
+                if !selects_any(selection.as_ref()) {
+                    return Ok((self, None));
+                }
+
+                let predicate_projection = predicate.projection();
+                row_group
+                    .fetch(&mut self.input, predicate_projection, selection.as_ref())
+                    .await?;
+
+                let array_reader =
+                    build_array_reader(self.fields.as_deref(), predicate_projection, &row_group)?;
+
+                selection = Some(evaluate_predicate(
+                    batch_size,
+                    array_reader,
+                    selection,
+                    predicate.as_mut(),
+                )?);
+            }
+        }
+
+        // Compute the number of rows in the selection before applying limit and offset
+        let rows_before = selection
+            .as_ref()
+            .map(|s| s.row_count())
+            .unwrap_or(row_group.row_count);
+
+        if rows_before == 0 {
+            return Ok((self, None));
+        }
+
+        selection = apply_range(selection, row_group.row_count, self.offset, self.limit);
+
+        // Compute the number of rows in the selection after applying limit and offset
+        let rows_after = selection
+            .as_ref()
+            .map(|s| s.row_count())
+            .unwrap_or(row_group.row_count);
+
+        // Update offset if necessary
+        if let Some(offset) = &mut self.offset {
+            // Reduction is either because of offset or limit, as limit is applied
+            // after offset has been "exhausted" can just use saturating sub here
+            *offset = offset.saturating_sub(rows_before - rows_after)
+        }
+
+        if rows_after == 0 {
+            return Ok((self, None));
+        }
+
+        if let Some(limit) = &mut self.limit {
+            *limit -= rows_after;
+        }
+
+        row_group
+            .fetch(&mut self.input, &projection, selection.as_ref())
+            .await?;
+
+        let reader = ParquetRecordBatchReader::new(
+            batch_size,
+            build_array_reader(self.fields.as_deref(), &projection, &row_group)?,
+            selection,
+        );
+
+        Ok((self, Some(reader)))
+    }
+}
+
+enum StreamState<T> {
+    /// At the start of a new row group, or the end of the parquet stream
+    Init,
+    /// Decoding a batch
+    Decoding(ParquetRecordBatchReader),
+    /// Reading data from input
+    Reading(BoxFuture<'static, ReadResult<T>>),
+    /// Error
+    Error,
+}
+
+impl<T> std::fmt::Debug for StreamState<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            StreamState::Init => write!(f, "StreamState::Init"),
+            StreamState::Decoding(_) => write!(f, "StreamState::Decoding"),
+            StreamState::Reading(_) => write!(f, "StreamState::Reading"),
+            StreamState::Error => write!(f, "StreamState::Error"),
+        }
+    }
+}
+
+/// An asynchronous [`Stream`](https://docs.rs/futures/latest/futures/stream/trait.Stream.html) of [`RecordBatch`]
+/// for a parquet file that can be constructed using [`ParquetRecordBatchStreamBuilder`].
+pub struct ParquetRecordBatchStream<T> {
+    metadata: Arc<ParquetMetaData>,
+
+    schema: SchemaRef,
+
+    row_groups: VecDeque<usize>,
+
+    projection: ProjectionMask,
+
+    batch_size: usize,
+
+    selection: Option<RowSelection>,
+
+    /// This is an option so it can be moved into a future
+    reader: Option<ReaderFactory<T>>,
+
+    state: StreamState<T>,
+}
+
+impl<T> std::fmt::Debug for ParquetRecordBatchStream<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("ParquetRecordBatchStream")
+            .field("metadata", &self.metadata)
+            .field("schema", &self.schema)
+            .field("batch_size", &self.batch_size)
+            .field("projection", &self.projection)
+            .field("state", &self.state)
+            .finish()
+    }
+}
+
+impl<T> ParquetRecordBatchStream<T> {
+    /// Returns the projected [`SchemaRef`] for reading the parquet file.
+    ///
+    /// Note that the schema metadata will be stripped here. See
+    /// [`ParquetRecordBatchStreamBuilder::schema`] if the metadata is desired.
+    pub fn schema(&self) -> &SchemaRef {
+        &self.schema
+    }
+}
+
+impl<T> Stream for ParquetRecordBatchStream<T>
+where
+    T: AsyncFileReader + Unpin + Send + 'static,
+{
+    type Item = Result<RecordBatch>;
+
+    fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> {
+        loop {
+            match &mut self.state {
+                StreamState::Decoding(batch_reader) => match batch_reader.next() {
+                    Some(Ok(batch)) => {
+                        return Poll::Ready(Some(Ok(batch)));
+                    }
+                    Some(Err(e)) => {
+                        self.state = StreamState::Error;
+                        return Poll::Ready(Some(Err(ParquetError::ArrowError(e.to_string()))));
+                    }
+                    None => self.state = StreamState::Init,
+                },
+                StreamState::Init => {
+                    let row_group_idx = match self.row_groups.pop_front() {
+                        Some(idx) => idx,
+                        None => return Poll::Ready(None),
+                    };
+
+                    let reader = self.reader.take().expect("lost reader");
+
+                    let row_count = self.metadata.row_group(row_group_idx).num_rows() as usize;
+
+                    let selection = self.selection.as_mut().map(|s| s.split_off(row_count));
+
+                    let fut = reader
+                        .read_row_group(
+                            row_group_idx,
+                            selection,
+                            self.projection.clone(),
+                            self.batch_size,
+                        )
+                        .boxed();
+
+                    self.state = StreamState::Reading(fut)
+                }
+                StreamState::Reading(f) => match ready!(f.poll_unpin(cx)) {
+                    Ok((reader_factory, maybe_reader)) => {
+                        self.reader = Some(reader_factory);
+                        match maybe_reader {
+                            // Read records from [`ParquetRecordBatchReader`]
+                            Some(reader) => self.state = StreamState::Decoding(reader),
+                            // All rows skipped, read next row group
+                            None => self.state = StreamState::Init,
+                        }
+                    }
+                    Err(e) => {
+                        self.state = StreamState::Error;
+                        return Poll::Ready(Some(Err(e)));
+                    }
+                },
+                StreamState::Error => return Poll::Ready(None), // Ends the stream as error happens.
+            }
+        }
+    }
+}
+
+/// An in-memory collection of column chunks
+struct InMemoryRowGroup<'a> {
+    metadata: &'a RowGroupMetaData,
+    page_locations: Option<&'a [Vec<PageLocation>]>,
+    column_chunks: Vec<Option<Arc<ColumnChunkData>>>,
+    row_count: usize,
+}
+
+impl<'a> InMemoryRowGroup<'a> {
+    /// Fetches the necessary column data into memory
+    async fn fetch<T: AsyncFileReader + Send>(
+        &mut self,
+        input: &mut T,
+        projection: &ProjectionMask,
+        selection: Option<&RowSelection>,
+    ) -> Result<()> {
+        if let Some((selection, page_locations)) = selection.zip(self.page_locations) {
+            // If we have a `RowSelection` and an `OffsetIndex` then only fetch pages required for the
+            // `RowSelection`
+            let mut page_start_offsets: Vec<Vec<usize>> = vec![];
+
+            let fetch_ranges = self
+                .column_chunks
+                .iter()
+                .zip(self.metadata.columns())
+                .enumerate()
+                .filter(|&(idx, (chunk, _chunk_meta))| {
+                    chunk.is_none() && projection.leaf_included(idx)
+                })
+                .flat_map(|(idx, (_chunk, chunk_meta))| {
+                    // If the first page does not start at the beginning of the column,
+                    // then we need to also fetch a dictionary page.
+                    let mut ranges = vec![];
+                    let (start, _len) = chunk_meta.byte_range();
+                    match page_locations[idx].first() {
+                        Some(first) if first.offset as u64 != start => {
+                            ranges.push(start as usize..first.offset as usize);
+                        }
+                        _ => (),
+                    }
+
+                    ranges.extend(selection.scan_ranges(&page_locations[idx]));
+                    page_start_offsets.push(ranges.iter().map(|range| range.start).collect());
+
+                    ranges
+                })
+                .collect();
+
+            let mut chunk_data = input.get_byte_ranges(fetch_ranges).await?.into_iter();
+            let mut page_start_offsets = page_start_offsets.into_iter();
+
+            for (idx, chunk) in self.column_chunks.iter_mut().enumerate() {
+                if chunk.is_some() || !projection.leaf_included(idx) {
+                    continue;
+                }
+
+                if let Some(offsets) = page_start_offsets.next() {
+                    let mut chunks = Vec::with_capacity(offsets.len());
+                    for _ in 0..offsets.len() {
+                        chunks.push(chunk_data.next().unwrap());
+                    }
+
+                    *chunk = Some(Arc::new(ColumnChunkData::Sparse {
+                        length: self.metadata.column(idx).byte_range().1 as usize,
+                        data: offsets.into_iter().zip(chunks.into_iter()).collect(),
+                    }))
+                }
+            }
+        } else {
+            let fetch_ranges = self
+                .column_chunks
+                .iter()
+                .enumerate()
+                .filter(|&(idx, chunk)| chunk.is_none() && projection.leaf_included(idx))
+                .map(|(idx, _chunk)| {
+                    let column = self.metadata.column(idx);
+                    let (start, length) = column.byte_range();
+                    start as usize..(start + length) as usize
+                })
+                .collect();
+
+            let mut chunk_data = input.get_byte_ranges(fetch_ranges).await?.into_iter();
+
+            for (idx, chunk) in self.column_chunks.iter_mut().enumerate() {
+                if chunk.is_some() || !projection.leaf_included(idx) {
+                    continue;
+                }
+
+                if let Some(data) = chunk_data.next() {
+                    *chunk = Some(Arc::new(ColumnChunkData::Dense {
+                        offset: self.metadata.column(idx).byte_range().0 as usize,
+                        data,
+                    }));
+                }
+            }
+        }
+
+        Ok(())
+    }
+}
+
+impl<'a> RowGroups for InMemoryRowGroup<'a> {
+    fn num_rows(&self) -> usize {
+        self.row_count
+    }
+
+    fn column_chunks(&self, i: usize) -> Result<Box<dyn PageIterator>> {
+        match &self.column_chunks[i] {
+            None => Err(ParquetError::General(format!(
+                "Invalid column index {i}, column was not fetched"
+            ))),
+            Some(data) => {
+                let page_locations = self.page_locations.map(|index| index[i].clone());
+                let page_reader: Box<dyn PageReader> = Box::new(SerializedPageReader::new(
+                    data.clone(),
+                    self.metadata.column(i),
+                    self.row_count,
+                    page_locations,
+                )?);
+
+                Ok(Box::new(ColumnChunkIterator {
+                    reader: Some(Ok(page_reader)),
+                }))
+            }
+        }
+    }
+}
+
+/// An in-memory column chunk
+#[derive(Clone)]
+enum ColumnChunkData {
+    /// Column chunk data representing only a subset of data pages
+    Sparse {
+        /// Length of the full column chunk
+        length: usize,
+        /// Set of data pages included in this sparse chunk. Each element is a tuple
+        /// of (page offset, page data)
+        data: Vec<(usize, Bytes)>,
+    },
+    /// Full column chunk and its offset
+    Dense { offset: usize, data: Bytes },
+}
+
+impl ColumnChunkData {
+    fn get(&self, start: u64) -> Result<Bytes> {
+        match &self {
+            ColumnChunkData::Sparse { data, .. } => data
+                .binary_search_by_key(&start, |(offset, _)| *offset as u64)
+                .map(|idx| data[idx].1.clone())
+                .map_err(|_| {
+                    ParquetError::General(format!(
+                        "Invalid offset in sparse column chunk data: {start}"
+                    ))
+                }),
+            ColumnChunkData::Dense { offset, data } => {
+                let start = start as usize - *offset;
+                Ok(data.slice(start..))
+            }
+        }
+    }
+}
+
+impl Length for ColumnChunkData {
+    fn len(&self) -> u64 {
+        match &self {
+            ColumnChunkData::Sparse { length, .. } => *length as u64,
+            ColumnChunkData::Dense { data, .. } => data.len() as u64,
+        }
+    }
+}
+
+impl ChunkReader for ColumnChunkData {
+    type T = bytes::buf::Reader<Bytes>;
+
+    fn get_read(&self, start: u64) -> Result<Self::T> {
+        Ok(self.get(start)?.reader())
+    }
+
+    fn get_bytes(&self, start: u64, length: usize) -> Result<Bytes> {
+        Ok(self.get(start)?.slice(..length))
+    }
+}
+
+/// Implements [`PageIterator`] for a single column chunk, yielding a single [`PageReader`]
+struct ColumnChunkIterator {
+    reader: Option<Result<Box<dyn PageReader>>>,
+}
+
+impl Iterator for ColumnChunkIterator {
+    type Item = Result<Box<dyn PageReader>>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.reader.take()
+    }
+}
+
+impl PageIterator for ColumnChunkIterator {}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::arrow::arrow_reader::{
+        ArrowPredicateFn, ParquetRecordBatchReaderBuilder, RowSelector,
+    };
+    use crate::arrow::schema::parquet_to_arrow_schema_and_fields;
+    use crate::arrow::ArrowWriter;
+    use crate::file::footer::parse_metadata;
+    use crate::file::page_index::index_reader;
+    use crate::file::properties::WriterProperties;
+    use arrow::compute::kernels::cmp::eq;
+    use arrow::error::Result as ArrowResult;
+    use arrow_array::builder::{ListBuilder, StringBuilder};
+    use arrow_array::cast::AsArray;
+    use arrow_array::types::Int32Type;
+    use arrow_array::{
+        Array, ArrayRef, Int32Array, Int8Array, RecordBatchReader, Scalar, StringArray,
+        StructArray, UInt64Array,
+    };
+    use arrow_schema::{DataType, Field, Schema};
+    use futures::{StreamExt, TryStreamExt};
+    use rand::{thread_rng, Rng};
+    use std::collections::HashMap;
+    use std::sync::{Arc, Mutex};
+    use tempfile::tempfile;
+
+    #[derive(Clone)]
+    struct TestReader {
+        data: Bytes,
+        metadata: Arc<ParquetMetaData>,
+        requests: Arc<Mutex<Vec<Range<usize>>>>,
+    }
+
+    impl AsyncFileReader for TestReader {
+        fn get_bytes(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>> {
+            self.requests.lock().unwrap().push(range.clone());
+            futures::future::ready(Ok(self.data.slice(range))).boxed()
+        }
+
+        fn get_metadata(&mut self) -> BoxFuture<'_, Result<Arc<ParquetMetaData>>> {
+            futures::future::ready(Ok(self.metadata.clone())).boxed()
+        }
+    }
+
+    #[tokio::test]
+    async fn test_async_reader() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/alltypes_plain.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+
+        let metadata = parse_metadata(&data).unwrap();
+        let metadata = Arc::new(metadata);
+
+        assert_eq!(metadata.num_row_groups(), 1);
+
+        let async_reader = TestReader {
+            data: data.clone(),
+            metadata: metadata.clone(),
+            requests: Default::default(),
+        };
+
+        let requests = async_reader.requests.clone();
+        let builder = ParquetRecordBatchStreamBuilder::new(async_reader)
+            .await
+            .unwrap();
+
+        let mask = ProjectionMask::leaves(builder.parquet_schema(), vec![1, 2]);
+        let stream = builder
+            .with_projection(mask.clone())
+            .with_batch_size(1024)
+            .build()
+            .unwrap();
+
+        let async_batches: Vec<_> = stream.try_collect().await.unwrap();
+
+        let sync_batches = ParquetRecordBatchReaderBuilder::try_new(data)
+            .unwrap()
+            .with_projection(mask)
+            .with_batch_size(104)
+            .build()
+            .unwrap()
+            .collect::<ArrowResult<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(async_batches, sync_batches);
+
+        let requests = requests.lock().unwrap();
+        let (offset_1, length_1) = metadata.row_group(0).column(1).byte_range();
+        let (offset_2, length_2) = metadata.row_group(0).column(2).byte_range();
+
+        assert_eq!(
+            &requests[..],
+            &[
+                offset_1 as usize..(offset_1 + length_1) as usize,
+                offset_2 as usize..(offset_2 + length_2) as usize
+            ]
+        );
+    }
+
+    #[tokio::test]
+    async fn test_async_reader_with_index() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/alltypes_tiny_pages_plain.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+
+        let metadata = parse_metadata(&data).unwrap();
+        let metadata = Arc::new(metadata);
+
+        assert_eq!(metadata.num_row_groups(), 1);
+
+        let async_reader = TestReader {
+            data: data.clone(),
+            metadata: metadata.clone(),
+            requests: Default::default(),
+        };
+
+        let options = ArrowReaderOptions::new().with_page_index(true);
+        let builder = ParquetRecordBatchStreamBuilder::new_with_options(async_reader, options)
+            .await
+            .unwrap();
+
+        // The builder should have page and offset indexes loaded now
+        let metadata_with_index = builder.metadata();
+
+        // Check offset indexes are present for all columns
+        let offset_index = metadata_with_index.offset_index().unwrap();
+        let column_index = metadata_with_index.column_index().unwrap();
+
+        assert_eq!(offset_index.len(), metadata_with_index.num_row_groups());
+        assert_eq!(column_index.len(), metadata_with_index.num_row_groups());
+
+        let num_columns = metadata_with_index
+            .file_metadata()
+            .schema_descr()
+            .num_columns();
+
+        // Check page indexes are present for all columns
+        offset_index
+            .iter()
+            .for_each(|x| assert_eq!(x.len(), num_columns));
+        column_index
+            .iter()
+            .for_each(|x| assert_eq!(x.len(), num_columns));
+
+        let mask = ProjectionMask::leaves(builder.parquet_schema(), vec![1, 2]);
+        let stream = builder
+            .with_projection(mask.clone())
+            .with_batch_size(1024)
+            .build()
+            .unwrap();
+
+        let async_batches: Vec<_> = stream.try_collect().await.unwrap();
+
+        let sync_batches = ParquetRecordBatchReaderBuilder::try_new(data)
+            .unwrap()
+            .with_projection(mask)
+            .with_batch_size(1024)
+            .build()
+            .unwrap()
+            .collect::<ArrowResult<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(async_batches, sync_batches);
+    }
+
+    #[tokio::test]
+    async fn test_async_reader_with_limit() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/alltypes_tiny_pages_plain.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+
+        let metadata = parse_metadata(&data).unwrap();
+        let metadata = Arc::new(metadata);
+
+        assert_eq!(metadata.num_row_groups(), 1);
+
+        let async_reader = TestReader {
+            data: data.clone(),
+            metadata: metadata.clone(),
+            requests: Default::default(),
+        };
+
+        let builder = ParquetRecordBatchStreamBuilder::new(async_reader)
+            .await
+            .unwrap();
+
+        let mask = ProjectionMask::leaves(builder.parquet_schema(), vec![1, 2]);
+        let stream = builder
+            .with_projection(mask.clone())
+            .with_batch_size(1024)
+            .with_limit(1)
+            .build()
+            .unwrap();
+
+        let async_batches: Vec<_> = stream.try_collect().await.unwrap();
+
+        let sync_batches = ParquetRecordBatchReaderBuilder::try_new(data)
+            .unwrap()
+            .with_projection(mask)
+            .with_batch_size(1024)
+            .with_limit(1)
+            .build()
+            .unwrap()
+            .collect::<ArrowResult<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(async_batches, sync_batches);
+    }
+
+    #[tokio::test]
+    async fn test_async_reader_skip_pages() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/alltypes_tiny_pages_plain.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+
+        let metadata = parse_metadata(&data).unwrap();
+        let metadata = Arc::new(metadata);
+
+        assert_eq!(metadata.num_row_groups(), 1);
+
+        let async_reader = TestReader {
+            data: data.clone(),
+            metadata: metadata.clone(),
+            requests: Default::default(),
+        };
+
+        let options = ArrowReaderOptions::new().with_page_index(true);
+        let builder = ParquetRecordBatchStreamBuilder::new_with_options(async_reader, options)
+            .await
+            .unwrap();
+
+        let selection = RowSelection::from(vec![
+            RowSelector::skip(21),   // Skip first page
+            RowSelector::select(21), // Select page to boundary
+            RowSelector::skip(41),   // Skip multiple pages
+            RowSelector::select(41), // Select multiple pages
+            RowSelector::skip(25),   // Skip page across boundary
+            RowSelector::select(25), // Select across page boundary
+            RowSelector::skip(7116), // Skip to final page boundary
+            RowSelector::select(10), // Select final page
+        ]);
+
+        let mask = ProjectionMask::leaves(builder.parquet_schema(), vec![9]);
+
+        let stream = builder
+            .with_projection(mask.clone())
+            .with_row_selection(selection.clone())
+            .build()
+            .expect("building stream");
+
+        let async_batches: Vec<_> = stream.try_collect().await.unwrap();
+
+        let sync_batches = ParquetRecordBatchReaderBuilder::try_new(data)
+            .unwrap()
+            .with_projection(mask)
+            .with_batch_size(1024)
+            .with_row_selection(selection)
+            .build()
+            .unwrap()
+            .collect::<ArrowResult<Vec<_>>>()
+            .unwrap();
+
+        assert_eq!(async_batches, sync_batches);
+    }
+
+    #[tokio::test]
+    async fn test_fuzz_async_reader_selection() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/alltypes_tiny_pages_plain.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+
+        let metadata = parse_metadata(&data).unwrap();
+        let metadata = Arc::new(metadata);
+
+        assert_eq!(metadata.num_row_groups(), 1);
+
+        let mut rand = thread_rng();
+
+        for _ in 0..100 {
+            let mut expected_rows = 0;
+            let mut total_rows = 0;
+            let mut skip = false;
+            let mut selectors = vec![];
+
+            while total_rows < 7300 {
+                let row_count: usize = rand.gen_range(1..100);
+
+                let row_count = row_count.min(7300 - total_rows);
+
+                selectors.push(RowSelector { row_count, skip });
+
+                total_rows += row_count;
+                if !skip {
+                    expected_rows += row_count;
+                }
+
+                skip = !skip;
+            }
+
+            let selection = RowSelection::from(selectors);
+
+            let async_reader = TestReader {
+                data: data.clone(),
+                metadata: metadata.clone(),
+                requests: Default::default(),
+            };
+
+            let options = ArrowReaderOptions::new().with_page_index(true);
+            let builder = ParquetRecordBatchStreamBuilder::new_with_options(async_reader, options)
+                .await
+                .unwrap();
+
+            let col_idx: usize = rand.gen_range(0..13);
+            let mask = ProjectionMask::leaves(builder.parquet_schema(), vec![col_idx]);
+
+            let stream = builder
+                .with_projection(mask.clone())
+                .with_row_selection(selection.clone())
+                .build()
+                .expect("building stream");
+
+            let async_batches: Vec<_> = stream.try_collect().await.unwrap();
+
+            let actual_rows: usize = async_batches.into_iter().map(|b| b.num_rows()).sum();
+
+            assert_eq!(actual_rows, expected_rows);
+        }
+    }
+
+    #[tokio::test]
+    async fn test_async_reader_zero_row_selector() {
+        //See https://github.com/apache/arrow-rs/issues/2669
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/alltypes_tiny_pages_plain.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+
+        let metadata = parse_metadata(&data).unwrap();
+        let metadata = Arc::new(metadata);
+
+        assert_eq!(metadata.num_row_groups(), 1);
+
+        let mut rand = thread_rng();
+
+        let mut expected_rows = 0;
+        let mut total_rows = 0;
+        let mut skip = false;
+        let mut selectors = vec![];
+
+        selectors.push(RowSelector {
+            row_count: 0,
+            skip: false,
+        });
+
+        while total_rows < 7300 {
+            let row_count: usize = rand.gen_range(1..100);
+
+            let row_count = row_count.min(7300 - total_rows);
+
+            selectors.push(RowSelector { row_count, skip });
+
+            total_rows += row_count;
+            if !skip {
+                expected_rows += row_count;
+            }
+
+            skip = !skip;
+        }
+
+        let selection = RowSelection::from(selectors);
+
+        let async_reader = TestReader {
+            data: data.clone(),
+            metadata: metadata.clone(),
+            requests: Default::default(),
+        };
+
+        let options = ArrowReaderOptions::new().with_page_index(true);
+        let builder = ParquetRecordBatchStreamBuilder::new_with_options(async_reader, options)
+            .await
+            .unwrap();
+
+        let col_idx: usize = rand.gen_range(0..13);
+        let mask = ProjectionMask::leaves(builder.parquet_schema(), vec![col_idx]);
+
+        let stream = builder
+            .with_projection(mask.clone())
+            .with_row_selection(selection.clone())
+            .build()
+            .expect("building stream");
+
+        let async_batches: Vec<_> = stream.try_collect().await.unwrap();
+
+        let actual_rows: usize = async_batches.into_iter().map(|b| b.num_rows()).sum();
+
+        assert_eq!(actual_rows, expected_rows);
+    }
+
+    #[tokio::test]
+    async fn test_row_filter() {
+        let a = StringArray::from_iter_values(["a", "b", "b", "b", "c", "c"]);
+        let b = StringArray::from_iter_values(["1", "2", "3", "4", "5", "6"]);
+        let c = Int32Array::from_iter(0..6);
+        let data = RecordBatch::try_from_iter([
+            ("a", Arc::new(a) as ArrayRef),
+            ("b", Arc::new(b) as ArrayRef),
+            ("c", Arc::new(c) as ArrayRef),
+        ])
+        .unwrap();
+
+        let mut buf = Vec::with_capacity(1024);
+        let mut writer = ArrowWriter::try_new(&mut buf, data.schema(), None).unwrap();
+        writer.write(&data).unwrap();
+        writer.close().unwrap();
+
+        let data: Bytes = buf.into();
+        let metadata = parse_metadata(&data).unwrap();
+        let parquet_schema = metadata.file_metadata().schema_descr_ptr();
+
+        let test = TestReader {
+            data,
+            metadata: Arc::new(metadata),
+            requests: Default::default(),
+        };
+        let requests = test.requests.clone();
+
+        let a_scalar = StringArray::from_iter_values(["b"]);
+        let a_filter = ArrowPredicateFn::new(
+            ProjectionMask::leaves(&parquet_schema, vec![0]),
+            move |batch| eq(batch.column(0), &Scalar::new(&a_scalar)),
+        );
+
+        let b_scalar = StringArray::from_iter_values(["4"]);
+        let b_filter = ArrowPredicateFn::new(
+            ProjectionMask::leaves(&parquet_schema, vec![1]),
+            move |batch| eq(batch.column(0), &Scalar::new(&b_scalar)),
+        );
+
+        let filter = RowFilter::new(vec![Box::new(a_filter), Box::new(b_filter)]);
+
+        let mask = ProjectionMask::leaves(&parquet_schema, vec![0, 2]);
+        let stream = ParquetRecordBatchStreamBuilder::new(test)
+            .await
+            .unwrap()
+            .with_projection(mask.clone())
+            .with_batch_size(1024)
+            .with_row_filter(filter)
+            .build()
+            .unwrap();
+
+        let batches: Vec<_> = stream.try_collect().await.unwrap();
+        assert_eq!(batches.len(), 1);
+
+        let batch = &batches[0];
+        assert_eq!(batch.num_rows(), 1);
+        assert_eq!(batch.num_columns(), 2);
+
+        let col = batch.column(0);
+        let val = col.as_any().downcast_ref::<StringArray>().unwrap().value(0);
+        assert_eq!(val, "b");
+
+        let col = batch.column(1);
+        let val = col.as_any().downcast_ref::<Int32Array>().unwrap().value(0);
+        assert_eq!(val, 3);
+
+        // Should only have made 3 requests
+        assert_eq!(requests.lock().unwrap().len(), 3);
+    }
+
+    #[tokio::test]
+    async fn test_limit_multiple_row_groups() {
+        let a = StringArray::from_iter_values(["a", "b", "b", "b", "c", "c"]);
+        let b = StringArray::from_iter_values(["1", "2", "3", "4", "5", "6"]);
+        let c = Int32Array::from_iter(0..6);
+        let data = RecordBatch::try_from_iter([
+            ("a", Arc::new(a) as ArrayRef),
+            ("b", Arc::new(b) as ArrayRef),
+            ("c", Arc::new(c) as ArrayRef),
+        ])
+        .unwrap();
+
+        let mut buf = Vec::with_capacity(1024);
+        let props = WriterProperties::builder()
+            .set_max_row_group_size(3)
+            .build();
+        let mut writer = ArrowWriter::try_new(&mut buf, data.schema(), Some(props)).unwrap();
+        writer.write(&data).unwrap();
+        writer.close().unwrap();
+
+        let data: Bytes = buf.into();
+        let metadata = parse_metadata(&data).unwrap();
+
+        assert_eq!(metadata.num_row_groups(), 2);
+
+        let test = TestReader {
+            data,
+            metadata: Arc::new(metadata),
+            requests: Default::default(),
+        };
+
+        let stream = ParquetRecordBatchStreamBuilder::new(test.clone())
+            .await
+            .unwrap()
+            .with_batch_size(1024)
+            .with_limit(4)
+            .build()
+            .unwrap();
+
+        let batches: Vec<_> = stream.try_collect().await.unwrap();
+        // Expect one batch for each row group
+        assert_eq!(batches.len(), 2);
+
+        let batch = &batches[0];
+        // First batch should contain all rows
+        assert_eq!(batch.num_rows(), 3);
+        assert_eq!(batch.num_columns(), 3);
+        let col2 = batch.column(2).as_primitive::<Int32Type>();
+        assert_eq!(col2.values(), &[0, 1, 2]);
+
+        let batch = &batches[1];
+        // Second batch should trigger the limit and only have one row
+        assert_eq!(batch.num_rows(), 1);
+        assert_eq!(batch.num_columns(), 3);
+        let col2 = batch.column(2).as_primitive::<Int32Type>();
+        assert_eq!(col2.values(), &[3]);
+
+        let stream = ParquetRecordBatchStreamBuilder::new(test.clone())
+            .await
+            .unwrap()
+            .with_offset(2)
+            .with_limit(3)
+            .build()
+            .unwrap();
+
+        let batches: Vec<_> = stream.try_collect().await.unwrap();
+        // Expect one batch for each row group
+        assert_eq!(batches.len(), 2);
+
+        let batch = &batches[0];
+        // First batch should contain one row
+        assert_eq!(batch.num_rows(), 1);
+        assert_eq!(batch.num_columns(), 3);
+        let col2 = batch.column(2).as_primitive::<Int32Type>();
+        assert_eq!(col2.values(), &[2]);
+
+        let batch = &batches[1];
+        // Second batch should contain two rows
+        assert_eq!(batch.num_rows(), 2);
+        assert_eq!(batch.num_columns(), 3);
+        let col2 = batch.column(2).as_primitive::<Int32Type>();
+        assert_eq!(col2.values(), &[3, 4]);
+
+        let stream = ParquetRecordBatchStreamBuilder::new(test.clone())
+            .await
+            .unwrap()
+            .with_offset(4)
+            .with_limit(20)
+            .build()
+            .unwrap();
+
+        let batches: Vec<_> = stream.try_collect().await.unwrap();
+        // Should skip first row group
+        assert_eq!(batches.len(), 1);
+
+        let batch = &batches[0];
+        // First batch should contain two rows
+        assert_eq!(batch.num_rows(), 2);
+        assert_eq!(batch.num_columns(), 3);
+        let col2 = batch.column(2).as_primitive::<Int32Type>();
+        assert_eq!(col2.values(), &[4, 5]);
+    }
+
+    #[tokio::test]
+    async fn test_row_filter_with_index() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/alltypes_tiny_pages_plain.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+
+        let metadata = parse_metadata(&data).unwrap();
+        let parquet_schema = metadata.file_metadata().schema_descr_ptr();
+        let metadata = Arc::new(metadata);
+
+        assert_eq!(metadata.num_row_groups(), 1);
+
+        let async_reader = TestReader {
+            data: data.clone(),
+            metadata: metadata.clone(),
+            requests: Default::default(),
+        };
+
+        let a_filter =
+            ArrowPredicateFn::new(ProjectionMask::leaves(&parquet_schema, vec![1]), |batch| {
+                Ok(batch.column(0).as_boolean().clone())
+            });
+
+        let b_scalar = Int8Array::from(vec![2]);
+        let b_filter = ArrowPredicateFn::new(
+            ProjectionMask::leaves(&parquet_schema, vec![2]),
+            move |batch| eq(batch.column(0), &Scalar::new(&b_scalar)),
+        );
+
+        let filter = RowFilter::new(vec![Box::new(a_filter), Box::new(b_filter)]);
+
+        let mask = ProjectionMask::leaves(&parquet_schema, vec![0, 2]);
+
+        let options = ArrowReaderOptions::new().with_page_index(true);
+        let stream = ParquetRecordBatchStreamBuilder::new_with_options(async_reader, options)
+            .await
+            .unwrap()
+            .with_projection(mask.clone())
+            .with_batch_size(1024)
+            .with_row_filter(filter)
+            .build()
+            .unwrap();
+
+        let batches: Vec<RecordBatch> = stream.try_collect().await.unwrap();
+
+        let total_rows: usize = batches.iter().map(|b| b.num_rows()).sum();
+
+        assert_eq!(total_rows, 730);
+    }
+
+    #[tokio::test]
+    async fn test_in_memory_row_group_sparse() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/alltypes_tiny_pages.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+
+        let metadata = parse_metadata(&data).unwrap();
+
+        let offset_index =
+            index_reader::read_pages_locations(&data, metadata.row_group(0).columns())
+                .expect("reading offset index");
+
+        let row_group_meta = metadata.row_group(0).clone();
+        let metadata = ParquetMetaData::new_with_page_index(
+            metadata.file_metadata().clone(),
+            vec![row_group_meta],
+            None,
+            Some(vec![offset_index.clone()]),
+        );
+
+        let metadata = Arc::new(metadata);
+
+        let num_rows = metadata.row_group(0).num_rows();
+
+        assert_eq!(metadata.num_row_groups(), 1);
+
+        let async_reader = TestReader {
+            data: data.clone(),
+            metadata: metadata.clone(),
+            requests: Default::default(),
+        };
+
+        let requests = async_reader.requests.clone();
+        let (_, fields) = parquet_to_arrow_schema_and_fields(
+            metadata.file_metadata().schema_descr(),
+            ProjectionMask::all(),
+            None,
+        )
+        .unwrap();
+
+        let _schema_desc = metadata.file_metadata().schema_descr();
+
+        let projection = ProjectionMask::leaves(metadata.file_metadata().schema_descr(), vec![0]);
+
+        let reader_factory = ReaderFactory {
+            metadata,
+            fields: fields.map(Arc::new),
+            input: async_reader,
+            filter: None,
+            limit: None,
+            offset: None,
+        };
+
+        let mut skip = true;
+        let mut pages = offset_index[0].iter().peekable();
+
+        // Setup `RowSelection` so that we can skip every other page, selecting the last page
+        let mut selectors = vec![];
+        let mut expected_page_requests: Vec<Range<usize>> = vec![];
+        while let Some(page) = pages.next() {
+            let num_rows = if let Some(next_page) = pages.peek() {
+                next_page.first_row_index - page.first_row_index
+            } else {
+                num_rows - page.first_row_index
+            };
+
+            if skip {
+                selectors.push(RowSelector::skip(num_rows as usize));
+            } else {
+                selectors.push(RowSelector::select(num_rows as usize));
+                let start = page.offset as usize;
+                let end = start + page.compressed_page_size as usize;
+                expected_page_requests.push(start..end);
+            }
+            skip = !skip;
+        }
+
+        let selection = RowSelection::from(selectors);
+
+        let (_factory, _reader) = reader_factory
+            .read_row_group(0, Some(selection), projection.clone(), 48)
+            .await
+            .expect("reading row group");
+
+        let requests = requests.lock().unwrap();
+
+        assert_eq!(&requests[..], &expected_page_requests)
+    }
+
+    #[tokio::test]
+    async fn test_batch_size_overallocate() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        // `alltypes_plain.parquet` only have 8 rows
+        let path = format!("{testdata}/alltypes_plain.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+
+        let metadata = parse_metadata(&data).unwrap();
+        let file_rows = metadata.file_metadata().num_rows() as usize;
+        let metadata = Arc::new(metadata);
+
+        let async_reader = TestReader {
+            data: data.clone(),
+            metadata: metadata.clone(),
+            requests: Default::default(),
+        };
+
+        let builder = ParquetRecordBatchStreamBuilder::new(async_reader)
+            .await
+            .unwrap();
+
+        let stream = builder
+            .with_projection(ProjectionMask::all())
+            .with_batch_size(1024)
+            .build()
+            .unwrap();
+        assert_ne!(1024, file_rows);
+        assert_eq!(stream.batch_size, file_rows);
+    }
+
+    #[tokio::test]
+    async fn test_get_row_group_column_bloom_filter_without_length() {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/data_index_bloom_encoding_stats.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+        test_get_row_group_column_bloom_filter(data, false).await;
+    }
+
+    #[tokio::test]
+    async fn test_parquet_record_batch_stream_schema() {
+        fn get_all_field_names(schema: &Schema) -> Vec<&String> {
+            schema.all_fields().iter().map(|f| f.name()).collect()
+        }
+
+        // ParquetRecordBatchReaderBuilder::schema differs from
+        // ParquetRecordBatchReader::schema and RecordBatch::schema in the returned
+        // schema contents (in terms of custom metadata attached to schema, and fields
+        // returned). Test to ensure this remains consistent behaviour.
+        //
+        // Ensure same for asynchronous versions of the above.
+
+        // Prep data, for a schema with nested fields, with custom metadata
+        let mut metadata = HashMap::with_capacity(1);
+        metadata.insert("key".to_string(), "value".to_string());
+
+        let nested_struct_array = StructArray::from(vec![
+            (
+                Arc::new(Field::new("d", DataType::Utf8, true)),
+                Arc::new(StringArray::from(vec!["a", "b"])) as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new("e", DataType::Utf8, true)),
+                Arc::new(StringArray::from(vec!["c", "d"])) as ArrayRef,
+            ),
+        ]);
+        let struct_array = StructArray::from(vec![
+            (
+                Arc::new(Field::new("a", DataType::Int32, true)),
+                Arc::new(Int32Array::from(vec![-1, 1])) as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new("b", DataType::UInt64, true)),
+                Arc::new(UInt64Array::from(vec![1, 2])) as ArrayRef,
+            ),
+            (
+                Arc::new(Field::new(
+                    "c",
+                    nested_struct_array.data_type().clone(),
+                    true,
+                )),
+                Arc::new(nested_struct_array) as ArrayRef,
+            ),
+        ]);
+
+        let schema =
+            Arc::new(Schema::new(struct_array.fields().clone()).with_metadata(metadata.clone()));
+        let record_batch = RecordBatch::from(struct_array)
+            .with_schema(schema.clone())
+            .unwrap();
+
+        // Write parquet with custom metadata in schema
+        let mut file = tempfile().unwrap();
+        let mut writer = ArrowWriter::try_new(&mut file, schema.clone(), None).unwrap();
+        writer.write(&record_batch).unwrap();
+        writer.close().unwrap();
+
+        let all_fields = ["a", "b", "c", "d", "e"];
+        // (leaf indices in mask, expected names in output schema all fields)
+        let projections = [
+            (vec![], vec![]),
+            (vec![0], vec!["a"]),
+            (vec![0, 1], vec!["a", "b"]),
+            (vec![0, 1, 2], vec!["a", "b", "c", "d"]),
+            (vec![0, 1, 2, 3], vec!["a", "b", "c", "d", "e"]),
+        ];
+
+        // Ensure we're consistent for each of these projections
+        for (indices, expected_projected_names) in projections {
+            let assert_schemas = |builder: SchemaRef, reader: SchemaRef, batch: SchemaRef| {
+                // Builder schema should preserve all fields and metadata
+                assert_eq!(get_all_field_names(&builder), all_fields);
+                assert_eq!(builder.metadata, metadata);
+                // Reader & batch schema should show only projected fields, and no metadata
+                assert_eq!(get_all_field_names(&reader), expected_projected_names);
+                assert_eq!(reader.metadata, HashMap::default());
+                assert_eq!(get_all_field_names(&batch), expected_projected_names);
+                assert_eq!(batch.metadata, HashMap::default());
+            };
+
+            let builder =
+                ParquetRecordBatchReaderBuilder::try_new(file.try_clone().unwrap()).unwrap();
+            let sync_builder_schema = builder.schema().clone();
+            let mask = ProjectionMask::leaves(builder.parquet_schema(), indices.clone());
+            let mut reader = builder.with_projection(mask).build().unwrap();
+            let sync_reader_schema = reader.schema();
+            let batch = reader.next().unwrap().unwrap();
+            let sync_batch_schema = batch.schema();
+            assert_schemas(sync_builder_schema, sync_reader_schema, sync_batch_schema);
+
+            // asynchronous should be same
+            let file = tokio::fs::File::from(file.try_clone().unwrap());
+            let builder = ParquetRecordBatchStreamBuilder::new(file).await.unwrap();
+            let async_builder_schema = builder.schema().clone();
+            let mask = ProjectionMask::leaves(builder.parquet_schema(), indices);
+            let mut reader = builder.with_projection(mask).build().unwrap();
+            let async_reader_schema = reader.schema().clone();
+            let batch = reader.next().await.unwrap().unwrap();
+            let async_batch_schema = batch.schema();
+            assert_schemas(
+                async_builder_schema,
+                async_reader_schema,
+                async_batch_schema,
+            );
+        }
+    }
+
+    #[tokio::test]
+    async fn test_get_row_group_column_bloom_filter_with_length() {
+        // convert to new parquet file with bloom_filter_length
+        let testdata = arrow::util::test_util::parquet_test_data();
+        let path = format!("{testdata}/data_index_bloom_encoding_stats.parquet");
+        let data = Bytes::from(std::fs::read(path).unwrap());
+        let metadata = parse_metadata(&data).unwrap();
+        let metadata = Arc::new(metadata);
+        let async_reader = TestReader {
+            data: data.clone(),
+            metadata: metadata.clone(),
+            requests: Default::default(),
+        };
+        let builder = ParquetRecordBatchStreamBuilder::new(async_reader)
+            .await
+            .unwrap();
+        let schema = builder.schema().clone();
+        let stream = builder.build().unwrap();
+        let batches = stream.try_collect::<Vec<_>>().await.unwrap();
+
+        let mut parquet_data = Vec::new();
+        let props = WriterProperties::builder()
+            .set_bloom_filter_enabled(true)
+            .build();
+        let mut writer = ArrowWriter::try_new(&mut parquet_data, schema, Some(props)).unwrap();
+        for batch in batches {
+            writer.write(&batch).unwrap();
+        }
+        writer.close().unwrap();
+
+        // test the new parquet file
+        test_get_row_group_column_bloom_filter(parquet_data.into(), true).await;
+    }
+
+    async fn test_get_row_group_column_bloom_filter(data: Bytes, with_length: bool) {
+        let metadata = parse_metadata(&data).unwrap();
+        let metadata = Arc::new(metadata);
+
+        assert_eq!(metadata.num_row_groups(), 1);
+        let row_group = metadata.row_group(0);
+        let column = row_group.column(0);
+        assert_eq!(column.bloom_filter_length().is_some(), with_length);
+
+        let async_reader = TestReader {
+            data: data.clone(),
+            metadata: metadata.clone(),
+            requests: Default::default(),
+        };
+
+        let mut builder = ParquetRecordBatchStreamBuilder::new(async_reader)
+            .await
+            .unwrap();
+
+        let sbbf = builder
+            .get_row_group_column_bloom_filter(0, 0)
+            .await
+            .unwrap()
+            .unwrap();
+        assert!(sbbf.check(&"Hello"));
+        assert!(!sbbf.check(&"Hello_Not_Exists"));
+    }
+
+    #[tokio::test]
+    async fn test_nested_skip() {
+        let schema = Arc::new(Schema::new(vec![
+            Field::new("col_1", DataType::UInt64, false),
+            Field::new_list("col_2", Field::new("item", DataType::Utf8, true), true),
+        ]));
+
+        // Default writer properties
+        let props = WriterProperties::builder()
+            .set_data_page_row_count_limit(256)
+            .set_write_batch_size(256)
+            .set_max_row_group_size(1024);
+
+        // Write data
+        let mut file = tempfile().unwrap();
+        let mut writer =
+            ArrowWriter::try_new(&mut file, schema.clone(), Some(props.build())).unwrap();
+
+        let mut builder = ListBuilder::new(StringBuilder::new());
+        for id in 0..1024 {
+            match id % 3 {
+                0 => builder.append_value([Some("val_1".to_string()), Some(format!("id_{id}"))]),
+                1 => builder.append_value([Some(format!("id_{id}"))]),
+                _ => builder.append_null(),
+            }
+        }
+        let refs = vec![
+            Arc::new(UInt64Array::from_iter_values(0..1024)) as ArrayRef,
+            Arc::new(builder.finish()) as ArrayRef,
+        ];
+
+        let batch = RecordBatch::try_new(schema.clone(), refs).unwrap();
+        writer.write(&batch).unwrap();
+        writer.close().unwrap();
+
+        let selections = [
+            RowSelection::from(vec![
+                RowSelector::skip(313),
+                RowSelector::select(1),
+                RowSelector::skip(709),
+                RowSelector::select(1),
+            ]),
+            RowSelection::from(vec![
+                RowSelector::skip(255),
+                RowSelector::select(1),
+                RowSelector::skip(767),
+                RowSelector::select(1),
+            ]),
+            RowSelection::from(vec![
+                RowSelector::select(255),
+                RowSelector::skip(1),
+                RowSelector::select(767),
+                RowSelector::skip(1),
+            ]),
+            RowSelection::from(vec![
+                RowSelector::skip(254),
+                RowSelector::select(1),
+                RowSelector::select(1),
+                RowSelector::skip(767),
+                RowSelector::select(1),
+            ]),
+        ];
+
+        for selection in selections {
+            let expected = selection.row_count();
+            // Read data
+            let mut reader = ParquetRecordBatchStreamBuilder::new_with_options(
+                tokio::fs::File::from_std(file.try_clone().unwrap()),
+                ArrowReaderOptions::new().with_page_index(true),
+            )
+            .await
+            .unwrap();
+
+            reader = reader.with_row_selection(selection);
+
+            let mut stream = reader.build().unwrap();
+
+            let mut total_rows = 0;
+            while let Some(rb) = stream.next().await {
+                let rb = rb.unwrap();
+                total_rows += rb.num_rows();
+            }
+            assert_eq!(total_rows, expected);
+        }
+    }
+}
diff --git a/parquet/src/arrow/async_reader/store.rs b/parquet/src/arrow/async_reader/store.rs
new file mode 100644
index 000000000000..293b91aea3ba
--- /dev/null
+++ b/parquet/src/arrow/async_reader/store.rs
@@ -0,0 +1,194 @@
+// 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.
+
+use std::ops::Range;
+use std::sync::Arc;
+
+use bytes::Bytes;
+use futures::future::BoxFuture;
+use futures::{FutureExt, TryFutureExt};
+
+use object_store::{ObjectMeta, ObjectStore};
+
+use crate::arrow::async_reader::{AsyncFileReader, MetadataLoader};
+use crate::errors::{ParquetError, Result};
+use crate::file::metadata::ParquetMetaData;
+
+/// Reads Parquet files in object storage using [`ObjectStore`].
+///
+/// ```no_run
+/// # use std::io::stdout;
+/// # use std::sync::Arc;
+/// # use object_store::azure::MicrosoftAzureBuilder;
+/// # use object_store::ObjectStore;
+/// # use object_store::path::Path;
+/// # use parquet::arrow::async_reader::ParquetObjectReader;
+/// # use parquet::arrow::ParquetRecordBatchStreamBuilder;
+/// # use parquet::schema::printer::print_parquet_metadata;
+/// # async fn run() {
+/// // Populate configuration from environment
+/// let storage_container = Arc::new(MicrosoftAzureBuilder::from_env().build().unwrap());
+/// let location = Path::from("path/to/blob.parquet");
+/// let meta = storage_container.head(&location).await.unwrap();
+/// println!("Found Blob with {}B at {}", meta.size, meta.location);
+///
+/// // Show Parquet metadata
+/// let reader = ParquetObjectReader::new(storage_container, meta);
+/// let builder = ParquetRecordBatchStreamBuilder::new(reader).await.unwrap();
+/// print_parquet_metadata(&mut stdout(), builder.metadata());
+/// # }
+/// ```
+#[derive(Clone, Debug)]
+pub struct ParquetObjectReader {
+    store: Arc<dyn ObjectStore>,
+    meta: ObjectMeta,
+    metadata_size_hint: Option<usize>,
+    preload_column_index: bool,
+    preload_offset_index: bool,
+}
+
+impl ParquetObjectReader {
+    /// Creates a new [`ParquetObjectReader`] for the provided [`ObjectStore`] and [`ObjectMeta`]
+    ///
+    /// [`ObjectMeta`] can be obtained using [`ObjectStore::list`] or [`ObjectStore::head`]
+    pub fn new(store: Arc<dyn ObjectStore>, meta: ObjectMeta) -> Self {
+        Self {
+            store,
+            meta,
+            metadata_size_hint: None,
+            preload_column_index: false,
+            preload_offset_index: false,
+        }
+    }
+
+    /// Provide a hint as to the size of the parquet file's footer,
+    /// see [fetch_parquet_metadata](crate::arrow::async_reader::fetch_parquet_metadata)
+    pub fn with_footer_size_hint(self, hint: usize) -> Self {
+        Self {
+            metadata_size_hint: Some(hint),
+            ..self
+        }
+    }
+
+    /// Load the Column Index as part of [`Self::get_metadata`]
+    pub fn with_preload_column_index(self, preload_column_index: bool) -> Self {
+        Self {
+            preload_column_index,
+            ..self
+        }
+    }
+
+    /// Load the Offset Index as part of [`Self::get_metadata`]
+    pub fn with_preload_offset_index(self, preload_offset_index: bool) -> Self {
+        Self {
+            preload_offset_index,
+            ..self
+        }
+    }
+}
+
+impl AsyncFileReader for ParquetObjectReader {
+    fn get_bytes(&mut self, range: Range<usize>) -> BoxFuture<'_, Result<Bytes>> {
+        self.store
+            .get_range(&self.meta.location, range)
+            .map_err(|e| ParquetError::General(format!("AsyncChunkReader::get_bytes error: {e}")))
+            .boxed()
+    }
+
+    fn get_byte_ranges(&mut self, ranges: Vec<Range<usize>>) -> BoxFuture<'_, Result<Vec<Bytes>>>
+    where
+        Self: Send,
+    {
+        async move {
+            self.store
+                .get_ranges(&self.meta.location, &ranges)
+                .await
+                .map_err(|e| {
+                    ParquetError::General(format!(
+                        "ParquetObjectReader::get_byte_ranges error: {e}"
+                    ))
+                })
+        }
+        .boxed()
+    }
+
+    fn get_metadata(&mut self) -> BoxFuture<'_, Result<Arc<ParquetMetaData>>> {
+        Box::pin(async move {
+            let preload_column_index = self.preload_column_index;
+            let preload_offset_index = self.preload_offset_index;
+            let file_size = self.meta.size;
+            let prefetch = self.metadata_size_hint;
+            let mut loader = MetadataLoader::load(self, file_size, prefetch).await?;
+            loader
+                .load_page_index(preload_column_index, preload_offset_index)
+                .await?;
+            Ok(Arc::new(loader.finish()))
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::sync::Arc;
+
+    use futures::TryStreamExt;
+
+    use arrow::util::test_util::parquet_test_data;
+    use object_store::local::LocalFileSystem;
+    use object_store::path::Path;
+    use object_store::ObjectStore;
+
+    use crate::arrow::async_reader::ParquetObjectReader;
+    use crate::arrow::ParquetRecordBatchStreamBuilder;
+
+    #[tokio::test]
+    async fn test_simple() {
+        let res = parquet_test_data();
+        let store = LocalFileSystem::new_with_prefix(res).unwrap();
+
+        let mut meta = store
+            .head(&Path::from("alltypes_plain.parquet"))
+            .await
+            .unwrap();
+
+        let store = Arc::new(store) as Arc<dyn ObjectStore>;
+        let object_reader = ParquetObjectReader::new(Arc::clone(&store), meta.clone());
+        let builder = ParquetRecordBatchStreamBuilder::new(object_reader)
+            .await
+            .unwrap();
+        let batches: Vec<_> = builder.build().unwrap().try_collect().await.unwrap();
+
+        assert_eq!(batches.len(), 1);
+        assert_eq!(batches[0].num_rows(), 8);
+
+        meta.location = Path::from("I don't exist.parquet");
+
+        let object_reader = ParquetObjectReader::new(store, meta);
+        // Cannot use unwrap_err as ParquetRecordBatchStreamBuilder: !Debug
+        match ParquetRecordBatchStreamBuilder::new(object_reader).await {
+            Ok(_) => panic!("expected failure"),
+            Err(e) => {
+                let err = e.to_string();
+                assert!(
+                    err.contains("not found: No such file or directory (os error 2)"),
+                    "{}",
+                    err
+                );
+            }
+        }
+    }
+}
diff --git a/parquet/src/arrow/async_writer/mod.rs b/parquet/src/arrow/async_writer/mod.rs
new file mode 100644
index 000000000000..60097e88737f
--- /dev/null
+++ b/parquet/src/arrow/async_writer/mod.rs
@@ -0,0 +1,492 @@
+// 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.
+
+//! Contains async writer which writes arrow data into parquet data.
+//!
+//! Provides `async` API for writing [`RecordBatch`]es as parquet files. The API is
+//! similar to the [`sync` API](crate::arrow::arrow_writer::ArrowWriter), so please
+//! read the documentation there before using this API.
+//!
+//! Here is an example for using [`AsyncArrowWriter`]:
+//! ```
+//! # #[tokio::main(flavor="current_thread")]
+//! # async fn main() {
+//! #
+//! use std::sync::Arc;
+//! use arrow_array::{ArrayRef, Int64Array, RecordBatch, RecordBatchReader};
+//! use bytes::Bytes;
+//! use parquet::arrow::{AsyncArrowWriter, arrow_reader::ParquetRecordBatchReaderBuilder};
+//!
+//! let col = Arc::new(Int64Array::from_iter_values([1, 2, 3])) as ArrayRef;
+//! let to_write = RecordBatch::try_from_iter([("col", col)]).unwrap();
+//!
+//! let mut buffer = Vec::new();
+//! let mut writer =
+//!     AsyncArrowWriter::try_new(&mut buffer, to_write.schema(), 0, None).unwrap();
+//! writer.write(&to_write).await.unwrap();
+//! writer.close().await.unwrap();
+//!
+//! let buffer = Bytes::from(buffer);
+//! let mut reader = ParquetRecordBatchReaderBuilder::try_new(buffer.clone())
+//!     .unwrap()
+//!     .build()
+//!     .unwrap();
+//! let read = reader.next().unwrap().unwrap();
+//!
+//! assert_eq!(to_write, read);
+//! # }
+//! ```
+
+use std::{io::Write, sync::Arc};
+
+use crate::{
+    arrow::arrow_writer::ArrowWriterOptions,
+    arrow::ArrowWriter,
+    errors::{ParquetError, Result},
+    file::{metadata::RowGroupMetaDataPtr, properties::WriterProperties},
+    format::{FileMetaData, KeyValue},
+};
+use arrow_array::RecordBatch;
+use arrow_schema::SchemaRef;
+use tokio::io::{AsyncWrite, AsyncWriteExt};
+
+/// Async arrow writer.
+///
+/// It is implemented based on the sync writer [`ArrowWriter`] with an inner buffer.
+/// The buffered data will be flushed to the writer provided by caller when the
+/// buffer's threshold is exceeded.
+pub struct AsyncArrowWriter<W> {
+    /// Underlying sync writer
+    sync_writer: ArrowWriter<SharedBuffer>,
+
+    /// Async writer provided by caller
+    async_writer: W,
+
+    /// The inner buffer shared by the `sync_writer` and the `async_writer`
+    shared_buffer: SharedBuffer,
+
+    /// Trigger forced flushing once buffer size reaches this value
+    buffer_size: usize,
+}
+
+impl<W: AsyncWrite + Unpin + Send> AsyncArrowWriter<W> {
+    /// Try to create a new Async Arrow Writer.
+    ///
+    /// `buffer_size` determines the number of bytes to buffer before flushing
+    /// to the underlying [`AsyncWrite`]
+    ///
+    /// The intermediate buffer will automatically be resized if necessary
+    ///
+    /// [`Self::write`] will flush this intermediate buffer if it is at least
+    /// half full
+    pub fn try_new(
+        writer: W,
+        arrow_schema: SchemaRef,
+        buffer_size: usize,
+        props: Option<WriterProperties>,
+    ) -> Result<Self> {
+        let options = ArrowWriterOptions::new().with_properties(props.unwrap_or_default());
+        Self::try_new_with_options(writer, arrow_schema, buffer_size, options)
+    }
+
+    /// Try to create a new Async Arrow Writer with [`ArrowWriterOptions`].
+    ///
+    /// `buffer_size` determines the number of bytes to buffer before flushing
+    /// to the underlying [`AsyncWrite`]
+    ///
+    /// The intermediate buffer will automatically be resized if necessary
+    ///
+    /// [`Self::write`] will flush this intermediate buffer if it is at least
+    /// half full
+    pub fn try_new_with_options(
+        writer: W,
+        arrow_schema: SchemaRef,
+        buffer_size: usize,
+        options: ArrowWriterOptions,
+    ) -> Result<Self> {
+        let shared_buffer = SharedBuffer::new(buffer_size);
+        let sync_writer =
+            ArrowWriter::try_new_with_options(shared_buffer.clone(), arrow_schema, options)?;
+
+        Ok(Self {
+            sync_writer,
+            async_writer: writer,
+            shared_buffer,
+            buffer_size,
+        })
+    }
+
+    /// Returns metadata for any flushed row groups
+    pub fn flushed_row_groups(&self) -> &[RowGroupMetaDataPtr] {
+        self.sync_writer.flushed_row_groups()
+    }
+
+    /// Returns the estimated length in bytes of the current in progress row group
+    pub fn in_progress_size(&self) -> usize {
+        self.sync_writer.in_progress_size()
+    }
+
+    /// Returns the number of rows buffered in the in progress row group
+    pub fn in_progress_rows(&self) -> usize {
+        self.sync_writer.in_progress_rows()
+    }
+
+    /// Returns the number of bytes written by this instance
+    pub fn bytes_written(&self) -> usize {
+        self.sync_writer.bytes_written()
+    }
+
+    /// Enqueues the provided `RecordBatch` to be written
+    ///
+    /// After every sync write by the inner [ArrowWriter], the inner buffer will be
+    /// checked and flush if at least half full
+    pub async fn write(&mut self, batch: &RecordBatch) -> Result<()> {
+        self.sync_writer.write(batch)?;
+        Self::try_flush(
+            &mut self.shared_buffer,
+            &mut self.async_writer,
+            self.buffer_size,
+        )
+        .await
+    }
+
+    /// Flushes all buffered rows into a new row group
+    pub async fn flush(&mut self) -> Result<()> {
+        self.sync_writer.flush()?;
+        Self::try_flush(&mut self.shared_buffer, &mut self.async_writer, 0).await?;
+
+        Ok(())
+    }
+
+    /// Append [`KeyValue`] metadata in addition to those in [`WriterProperties`]
+    ///
+    /// This method allows to append metadata after [`RecordBatch`]es are written.
+    pub fn append_key_value_metadata(&mut self, kv_metadata: KeyValue) {
+        self.sync_writer.append_key_value_metadata(kv_metadata);
+    }
+
+    /// Close and finalize the writer.
+    ///
+    /// All the data in the inner buffer will be force flushed.
+    pub async fn close(mut self) -> Result<FileMetaData> {
+        let metadata = self.sync_writer.close()?;
+
+        // Force to flush the remaining data.
+        Self::try_flush(&mut self.shared_buffer, &mut self.async_writer, 0).await?;
+        self.async_writer.shutdown().await?;
+
+        Ok(metadata)
+    }
+
+    /// Flush the data in the [`SharedBuffer`] into the `async_writer` if its size
+    /// exceeds the threshold.
+    async fn try_flush(
+        shared_buffer: &mut SharedBuffer,
+        async_writer: &mut W,
+        buffer_size: usize,
+    ) -> Result<()> {
+        let mut buffer = shared_buffer.buffer.try_lock().unwrap();
+        if buffer.is_empty() || buffer.len() < buffer_size {
+            // no need to flush
+            return Ok(());
+        }
+
+        async_writer
+            .write_all(buffer.as_slice())
+            .await
+            .map_err(|e| ParquetError::External(Box::new(e)))?;
+
+        async_writer
+            .flush()
+            .await
+            .map_err(|e| ParquetError::External(Box::new(e)))?;
+
+        // reuse the buffer.
+        buffer.clear();
+
+        Ok(())
+    }
+}
+
+/// A buffer with interior mutability shared by the [`ArrowWriter`] and
+/// [`AsyncArrowWriter`].
+#[derive(Clone)]
+struct SharedBuffer {
+    /// The inner buffer for reading and writing
+    ///
+    /// The lock is used to obtain internal mutability, so no worry about the
+    /// lock contention.
+    buffer: Arc<futures::lock::Mutex<Vec<u8>>>,
+}
+
+impl SharedBuffer {
+    pub fn new(capacity: usize) -> Self {
+        Self {
+            buffer: Arc::new(futures::lock::Mutex::new(Vec::with_capacity(capacity))),
+        }
+    }
+}
+
+impl Write for SharedBuffer {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        let mut buffer = self.buffer.try_lock().unwrap();
+        Write::write(&mut *buffer, buf)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        let mut buffer = self.buffer.try_lock().unwrap();
+        Write::flush(&mut *buffer)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use arrow::datatypes::{DataType, Field, Schema};
+    use arrow_array::{ArrayRef, BinaryArray, Int32Array, Int64Array, RecordBatchReader};
+    use bytes::Bytes;
+    use tokio::pin;
+
+    use crate::arrow::arrow_reader::{ParquetRecordBatchReader, ParquetRecordBatchReaderBuilder};
+
+    use super::*;
+
+    fn get_test_reader() -> ParquetRecordBatchReader {
+        let testdata = arrow::util::test_util::parquet_test_data();
+        // This test file is large enough to generate multiple row groups.
+        let path = format!("{}/alltypes_tiny_pages_plain.parquet", testdata);
+        let original_data = Bytes::from(std::fs::read(path).unwrap());
+        ParquetRecordBatchReaderBuilder::try_new(original_data)
+            .unwrap()
+            .build()
+            .unwrap()
+    }
+
+    #[tokio::test]
+    async fn test_async_writer() {
+        let col = Arc::new(Int64Array::from_iter_values([1, 2, 3])) as ArrayRef;
+        let to_write = RecordBatch::try_from_iter([("col", col)]).unwrap();
+
+        let mut buffer = Vec::new();
+        let mut writer =
+            AsyncArrowWriter::try_new(&mut buffer, to_write.schema(), 0, None).unwrap();
+        writer.write(&to_write).await.unwrap();
+        writer.close().await.unwrap();
+
+        let buffer = Bytes::from(buffer);
+        let mut reader = ParquetRecordBatchReaderBuilder::try_new(buffer)
+            .unwrap()
+            .build()
+            .unwrap();
+        let read = reader.next().unwrap().unwrap();
+
+        assert_eq!(to_write, read);
+    }
+
+    // Read the data from the test file and write it by the async writer and sync writer.
+    // And then compares the results of the two writers.
+    #[tokio::test]
+    async fn test_async_writer_with_sync_writer() {
+        let reader = get_test_reader();
+
+        let write_props = WriterProperties::builder()
+            .set_max_row_group_size(64)
+            .build();
+
+        let mut async_buffer = Vec::new();
+        let mut async_writer = AsyncArrowWriter::try_new(
+            &mut async_buffer,
+            reader.schema(),
+            1024,
+            Some(write_props.clone()),
+        )
+        .unwrap();
+
+        let mut sync_buffer = Vec::new();
+        let mut sync_writer =
+            ArrowWriter::try_new(&mut sync_buffer, reader.schema(), Some(write_props)).unwrap();
+        for record_batch in reader {
+            let record_batch = record_batch.unwrap();
+            async_writer.write(&record_batch).await.unwrap();
+            sync_writer.write(&record_batch).unwrap();
+        }
+        sync_writer.close().unwrap();
+        async_writer.close().await.unwrap();
+
+        assert_eq!(sync_buffer, async_buffer);
+    }
+
+    struct TestAsyncSink {
+        sink: Vec<u8>,
+        min_accept_bytes: usize,
+        expect_total_bytes: usize,
+    }
+
+    impl AsyncWrite for TestAsyncSink {
+        fn poll_write(
+            self: std::pin::Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+            buf: &[u8],
+        ) -> std::task::Poll<std::result::Result<usize, std::io::Error>> {
+            let written_bytes = self.sink.len();
+            if written_bytes + buf.len() < self.expect_total_bytes {
+                assert!(buf.len() >= self.min_accept_bytes);
+            } else {
+                assert_eq!(written_bytes + buf.len(), self.expect_total_bytes);
+            }
+
+            let sink = &mut self.get_mut().sink;
+            pin!(sink);
+            sink.poll_write(cx, buf)
+        }
+
+        fn poll_flush(
+            self: std::pin::Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+        ) -> std::task::Poll<std::result::Result<(), std::io::Error>> {
+            let sink = &mut self.get_mut().sink;
+            pin!(sink);
+            sink.poll_flush(cx)
+        }
+
+        fn poll_shutdown(
+            self: std::pin::Pin<&mut Self>,
+            cx: &mut std::task::Context<'_>,
+        ) -> std::task::Poll<std::result::Result<(), std::io::Error>> {
+            let sink = &mut self.get_mut().sink;
+            pin!(sink);
+            sink.poll_shutdown(cx)
+        }
+    }
+
+    #[tokio::test]
+    async fn test_async_writer_with_buffer_flush_threshold() {
+        let write_props = WriterProperties::builder()
+            .set_max_row_group_size(2048)
+            .build();
+        let expect_encode_size = {
+            let reader = get_test_reader();
+            let mut buffer = Vec::new();
+            let mut async_writer = AsyncArrowWriter::try_new(
+                &mut buffer,
+                reader.schema(),
+                0,
+                Some(write_props.clone()),
+            )
+            .unwrap();
+            for record_batch in reader {
+                let record_batch = record_batch.unwrap();
+                async_writer.write(&record_batch).await.unwrap();
+            }
+            async_writer.close().await.unwrap();
+            buffer.len()
+        };
+
+        let test_buffer_flush_thresholds = vec![0, 1024, 40 * 1024, 50 * 1024, 100 * 1024];
+
+        for buffer_flush_threshold in test_buffer_flush_thresholds {
+            let reader = get_test_reader();
+            let mut test_async_sink = TestAsyncSink {
+                sink: Vec::new(),
+                min_accept_bytes: buffer_flush_threshold,
+                expect_total_bytes: expect_encode_size,
+            };
+            let mut async_writer = AsyncArrowWriter::try_new(
+                &mut test_async_sink,
+                reader.schema(),
+                buffer_flush_threshold * 2,
+                Some(write_props.clone()),
+            )
+            .unwrap();
+
+            for record_batch in reader {
+                let record_batch = record_batch.unwrap();
+                async_writer.write(&record_batch).await.unwrap();
+            }
+            async_writer.close().await.unwrap();
+        }
+    }
+
+    #[tokio::test]
+    async fn test_async_writer_file() {
+        let col = Arc::new(Int64Array::from_iter_values([1, 2, 3])) as ArrayRef;
+        let col2 = Arc::new(BinaryArray::from_iter_values(vec![
+            vec![0; 500000],
+            vec![0; 500000],
+            vec![0; 500000],
+        ])) as ArrayRef;
+        let to_write = RecordBatch::try_from_iter([("col", col), ("col2", col2)]).unwrap();
+
+        let temp = tempfile::tempfile().unwrap();
+
+        let file = tokio::fs::File::from_std(temp.try_clone().unwrap());
+        let mut writer = AsyncArrowWriter::try_new(file, to_write.schema(), 0, None).unwrap();
+        writer.write(&to_write).await.unwrap();
+        writer.close().await.unwrap();
+
+        let mut reader = ParquetRecordBatchReaderBuilder::try_new(temp)
+            .unwrap()
+            .build()
+            .unwrap();
+        let read = reader.next().unwrap().unwrap();
+
+        assert_eq!(to_write, read);
+    }
+
+    #[tokio::test]
+    async fn in_progress_accounting() {
+        // define schema
+        let schema = Schema::new(vec![Field::new("a", DataType::Int32, false)]);
+
+        // create some data
+        let a = Int32Array::from_value(0_i32, 512);
+
+        // build a record batch
+        let batch = RecordBatch::try_new(Arc::new(schema), vec![Arc::new(a)]).unwrap();
+
+        for buffer_size in [0, 8, 1024] {
+            let temp = tempfile::tempfile().unwrap();
+            let file = tokio::fs::File::from_std(temp.try_clone().unwrap());
+            let mut writer =
+                AsyncArrowWriter::try_new(file, batch.schema(), buffer_size, None).unwrap();
+
+            // starts empty
+            assert_eq!(writer.in_progress_size(), 0);
+            assert_eq!(writer.in_progress_rows(), 0);
+            assert_eq!(writer.bytes_written(), 4); // Initial Parquet header
+            writer.write(&batch).await.unwrap();
+
+            // updated on write
+            let initial_size = writer.in_progress_size();
+            assert!(initial_size > 0);
+            assert_eq!(writer.in_progress_rows(), batch.num_rows());
+
+            // updated on second write
+            writer.write(&batch).await.unwrap();
+            assert!(writer.in_progress_size() > initial_size);
+            assert_eq!(writer.in_progress_rows(), batch.num_rows() * 2);
+
+            // in progress tracking is cleared, but the overall data written is updated
+            let pre_flush_bytes_written = writer.bytes_written();
+            writer.flush().await.unwrap();
+            assert_eq!(writer.in_progress_size(), 0);
+            assert_eq!(writer.in_progress_rows(), 0);
+            assert!(writer.bytes_written() > pre_flush_bytes_written);
+
+            writer.close().await.unwrap();
+        }
+    }
+}
diff --git a/parquet/src/arrow/buffer/bit_util.rs b/parquet/src/arrow/buffer/bit_util.rs
index 192ab4b72163..e7aea56a7f05 100644
--- a/parquet/src/arrow/buffer/bit_util.rs
+++ b/parquet/src/arrow/buffer/bit_util.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use arrow::util::bit_chunk_iterator::UnalignedBitChunk;
+use arrow_buffer::bit_chunk_iterator::UnalignedBitChunk;
 use std::ops::Range;
 
 /// Counts the number of set bits in the provided range
@@ -28,14 +28,13 @@ pub fn count_set_bits(bytes: &[u8], range: Range<usize>) -> usize {
 pub fn iter_set_bits_rev(bytes: &[u8]) -> impl Iterator<Item = usize> + '_ {
     let bit_length = bytes.len() * 8;
     let unaligned = UnalignedBitChunk::new(bytes, 0, bit_length);
-    let mut chunk_end_idx =
-        bit_length + unaligned.lead_padding() + unaligned.trailing_padding();
+    let mut chunk_end_idx = bit_length + unaligned.lead_padding() + unaligned.trailing_padding();
 
     let iter = unaligned
         .prefix()
         .into_iter()
         .chain(unaligned.chunks().iter().cloned())
-        .chain(unaligned.suffix().into_iter());
+        .chain(unaligned.suffix());
 
     iter.rev().flat_map(move |mut chunk| {
         let chunk_idx = chunk_end_idx - 64;
@@ -51,10 +50,21 @@ pub fn iter_set_bits_rev(bytes: &[u8]) -> impl Iterator<Item = usize> + '_ {
     })
 }
 
+/// Performs big endian sign extension
+pub fn sign_extend_be<const N: usize>(b: &[u8]) -> [u8; N] {
+    assert!(b.len() <= N, "Array too large, expected less than {N}");
+    let is_negative = (b[0] & 128u8) == 128u8;
+    let mut result = if is_negative { [255u8; N] } else { [0u8; N] };
+    for (d, s) in result.iter_mut().skip(N - b.len()).zip(b) {
+        *d = *s;
+    }
+    result
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
-    use arrow::array::BooleanBufferBuilder;
+    use arrow_array::builder::BooleanBufferBuilder;
     use rand::prelude::*;
 
     #[test]
@@ -73,7 +83,7 @@ mod tests {
             .iter()
             .enumerate()
             .rev()
-            .filter_map(|(x, y)| y.then(|| x))
+            .filter_map(|(x, y)| y.then_some(x))
             .collect();
         assert_eq!(actual, expected);
 
diff --git a/parquet/src/arrow/buffer/converter.rs b/parquet/src/arrow/buffer/converter.rs
deleted file mode 100644
index aeca548bde72..000000000000
--- a/parquet/src/arrow/buffer/converter.rs
+++ /dev/null
@@ -1,273 +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.
-
-use crate::data_type::{ByteArray, FixedLenByteArray, Int96};
-use arrow::array::{
-    Array, ArrayRef, Decimal128Array, FixedSizeBinaryArray, FixedSizeBinaryBuilder,
-    IntervalDayTimeArray, IntervalDayTimeBuilder, IntervalYearMonthArray,
-    IntervalYearMonthBuilder, TimestampNanosecondArray,
-};
-use std::sync::Arc;
-
-use crate::errors::Result;
-use std::marker::PhantomData;
-
-#[cfg(test)]
-use arrow::array::{StringArray, StringBuilder};
-
-/// A converter is used to consume record reader's content and convert it to arrow
-/// primitive array.
-pub trait Converter<S, T> {
-    /// This method converts record reader's buffered content into arrow array.
-    /// It will consume record reader's data, but will not reset record reader's
-    /// state.
-    fn convert(&self, source: S) -> Result<T>;
-}
-
-pub struct FixedSizeArrayConverter {
-    byte_width: i32,
-}
-
-impl FixedSizeArrayConverter {
-    pub fn new(byte_width: i32) -> Self {
-        Self { byte_width }
-    }
-}
-
-impl Converter<Vec<Option<FixedLenByteArray>>, FixedSizeBinaryArray>
-    for FixedSizeArrayConverter
-{
-    fn convert(
-        &self,
-        source: Vec<Option<FixedLenByteArray>>,
-    ) -> Result<FixedSizeBinaryArray> {
-        let mut builder = FixedSizeBinaryBuilder::new(source.len(), self.byte_width);
-        for v in source {
-            match v {
-                Some(array) => builder.append_value(array.data())?,
-                None => builder.append_null(),
-            }
-        }
-
-        Ok(builder.finish())
-    }
-}
-
-pub struct DecimalArrayConverter {
-    precision: i32,
-    scale: i32,
-}
-
-impl DecimalArrayConverter {
-    pub fn new(precision: i32, scale: i32) -> Self {
-        Self { precision, scale }
-    }
-}
-
-impl Converter<Vec<Option<FixedLenByteArray>>, Decimal128Array>
-    for DecimalArrayConverter
-{
-    fn convert(&self, source: Vec<Option<FixedLenByteArray>>) -> Result<Decimal128Array> {
-        let array = source
-            .into_iter()
-            .map(|array| array.map(|array| from_bytes_to_i128(array.data())))
-            .collect::<Decimal128Array>()
-            .with_precision_and_scale(self.precision as usize, self.scale as usize)?;
-
-        Ok(array)
-    }
-}
-
-impl Converter<Vec<Option<ByteArray>>, Decimal128Array> for DecimalArrayConverter {
-    fn convert(&self, source: Vec<Option<ByteArray>>) -> Result<Decimal128Array> {
-        let array = source
-            .into_iter()
-            .map(|array| array.map(|array| from_bytes_to_i128(array.data())))
-            .collect::<Decimal128Array>()
-            .with_precision_and_scale(self.precision as usize, self.scale as usize)?;
-
-        Ok(array)
-    }
-}
-
-// Convert the bytes array to i128.
-// The endian of the input bytes array must be big-endian.
-fn from_bytes_to_i128(b: &[u8]) -> i128 {
-    assert!(b.len() <= 16, "Decimal128Array supports only up to size 16");
-    let first_bit = b[0] & 128u8 == 128u8;
-    let mut result = if first_bit { [255u8; 16] } else { [0u8; 16] };
-    for (i, v) in b.iter().enumerate() {
-        result[i + (16 - b.len())] = *v;
-    }
-    // The bytes array are from parquet file and must be the big-endian.
-    // The endian is defined by parquet format, and the reference document
-    // https://github.com/apache/parquet-format/blob/54e53e5d7794d383529dd30746378f19a12afd58/src/main/thrift/parquet.thrift#L66
-    i128::from_be_bytes(result)
-}
-
-/// An Arrow Interval converter, which reads the first 4 bytes of a Parquet interval,
-/// and interprets it as an i32 value representing the Arrow YearMonth value
-pub struct IntervalYearMonthArrayConverter {}
-
-impl Converter<Vec<Option<FixedLenByteArray>>, IntervalYearMonthArray>
-    for IntervalYearMonthArrayConverter
-{
-    fn convert(
-        &self,
-        source: Vec<Option<FixedLenByteArray>>,
-    ) -> Result<IntervalYearMonthArray> {
-        let mut builder = IntervalYearMonthBuilder::new(source.len());
-        for v in source {
-            match v {
-                Some(array) => builder.append_value(i32::from_le_bytes(
-                    array.data()[0..4].try_into().unwrap(),
-                )),
-                None => builder.append_null(),
-            }
-        }
-
-        Ok(builder.finish())
-    }
-}
-
-/// An Arrow Interval converter, which reads the last 8 bytes of a Parquet interval,
-/// and interprets it as an i32 value representing the Arrow DayTime value
-pub struct IntervalDayTimeArrayConverter {}
-
-impl Converter<Vec<Option<FixedLenByteArray>>, IntervalDayTimeArray>
-    for IntervalDayTimeArrayConverter
-{
-    fn convert(
-        &self,
-        source: Vec<Option<FixedLenByteArray>>,
-    ) -> Result<IntervalDayTimeArray> {
-        let mut builder = IntervalDayTimeBuilder::new(source.len());
-        for v in source {
-            match v {
-                Some(array) => builder.append_value(i64::from_le_bytes(
-                    array.data()[4..12].try_into().unwrap(),
-                )),
-                None => builder.append_null(),
-            }
-        }
-
-        Ok(builder.finish())
-    }
-}
-
-pub struct Int96ArrayConverter {
-    pub timezone: Option<String>,
-}
-
-impl Converter<Vec<Option<Int96>>, TimestampNanosecondArray> for Int96ArrayConverter {
-    fn convert(&self, source: Vec<Option<Int96>>) -> Result<TimestampNanosecondArray> {
-        Ok(TimestampNanosecondArray::from_opt_vec(
-            source
-                .into_iter()
-                .map(|int96| int96.map(|val| val.to_i64() * 1_000_000))
-                .collect(),
-            self.timezone.clone(),
-        ))
-    }
-}
-
-#[cfg(test)]
-pub struct Utf8ArrayConverter {}
-
-#[cfg(test)]
-impl Converter<Vec<Option<ByteArray>>, StringArray> for Utf8ArrayConverter {
-    fn convert(&self, source: Vec<Option<ByteArray>>) -> Result<StringArray> {
-        let data_size = source
-            .iter()
-            .map(|x| x.as_ref().map(|b| b.len()).unwrap_or(0))
-            .sum();
-
-        let mut builder = StringBuilder::with_capacity(source.len(), data_size);
-        for v in source {
-            match v {
-                Some(array) => builder.append_value(array.as_utf8()?),
-                None => builder.append_null(),
-            }
-        }
-
-        Ok(builder.finish())
-    }
-}
-
-#[cfg(test)]
-pub type Utf8Converter =
-    ArrayRefConverter<Vec<Option<ByteArray>>, StringArray, Utf8ArrayConverter>;
-
-pub type Int96Converter =
-    ArrayRefConverter<Vec<Option<Int96>>, TimestampNanosecondArray, Int96ArrayConverter>;
-
-pub type FixedLenBinaryConverter = ArrayRefConverter<
-    Vec<Option<FixedLenByteArray>>,
-    FixedSizeBinaryArray,
-    FixedSizeArrayConverter,
->;
-pub type IntervalYearMonthConverter = ArrayRefConverter<
-    Vec<Option<FixedLenByteArray>>,
-    IntervalYearMonthArray,
-    IntervalYearMonthArrayConverter,
->;
-pub type IntervalDayTimeConverter = ArrayRefConverter<
-    Vec<Option<FixedLenByteArray>>,
-    IntervalDayTimeArray,
-    IntervalDayTimeArrayConverter,
->;
-
-pub type DecimalFixedLengthByteArrayConverter = ArrayRefConverter<
-    Vec<Option<FixedLenByteArray>>,
-    Decimal128Array,
-    DecimalArrayConverter,
->;
-
-pub type DecimalByteArrayConvert =
-    ArrayRefConverter<Vec<Option<ByteArray>>, Decimal128Array, DecimalArrayConverter>;
-
-pub struct ArrayRefConverter<S, A, C> {
-    _source: PhantomData<S>,
-    _array: PhantomData<A>,
-    converter: C,
-}
-
-impl<S, A, C> ArrayRefConverter<S, A, C>
-where
-    A: Array + 'static,
-    C: Converter<S, A> + 'static,
-{
-    pub fn new(converter: C) -> Self {
-        Self {
-            _source: PhantomData,
-            _array: PhantomData,
-            converter,
-        }
-    }
-}
-
-impl<S, A, C> Converter<S, ArrayRef> for ArrayRefConverter<S, A, C>
-where
-    A: Array + 'static,
-    C: Converter<S, A> + 'static,
-{
-    fn convert(&self, source: S) -> Result<ArrayRef> {
-        self.converter
-            .convert(source)
-            .map(|array| Arc::new(array) as ArrayRef)
-    }
-}
diff --git a/parquet/src/arrow/buffer/dictionary_buffer.rs b/parquet/src/arrow/buffer/dictionary_buffer.rs
index ae9e3590de3f..9e5b2293aa01 100644
--- a/parquet/src/arrow/buffer/dictionary_buffer.rs
+++ b/parquet/src/arrow/buffer/dictionary_buffer.rs
@@ -16,29 +16,22 @@
 // under the License.
 
 use crate::arrow::buffer::offset_buffer::OffsetBuffer;
-use crate::arrow::record_reader::buffer::{
-    BufferQueue, ScalarBuffer, ScalarValue, ValuesBuffer,
-};
-use crate::column::reader::decoder::ValuesBufferSlice;
+use crate::arrow::record_reader::buffer::ValuesBuffer;
 use crate::errors::{ParquetError, Result};
-use arrow::array::{make_array, Array, ArrayDataBuilder, ArrayRef, OffsetSizeTrait};
-use arrow::buffer::Buffer;
-use arrow::datatypes::{ArrowNativeType, DataType as ArrowType};
+use arrow_array::{make_array, Array, ArrayRef, OffsetSizeTrait};
+use arrow_buffer::{ArrowNativeType, Buffer};
+use arrow_data::ArrayDataBuilder;
+use arrow_schema::DataType as ArrowType;
 use std::sync::Arc;
 
 /// An array of variable length byte arrays that are potentially dictionary encoded
 /// and can be converted into a corresponding [`ArrayRef`]
-pub enum DictionaryBuffer<K: ScalarValue, V: ScalarValue> {
-    Dict {
-        keys: ScalarBuffer<K>,
-        values: ArrayRef,
-    },
-    Values {
-        values: OffsetBuffer<V>,
-    },
+pub enum DictionaryBuffer<K: ArrowNativeType, V: OffsetSizeTrait> {
+    Dict { keys: Vec<K>, values: ArrayRef },
+    Values { values: OffsetBuffer<V> },
 }
 
-impl<K: ScalarValue, V: ScalarValue> Default for DictionaryBuffer<K, V> {
+impl<K: ArrowNativeType, V: OffsetSizeTrait> Default for DictionaryBuffer<K, V> {
     fn default() -> Self {
         Self::Values {
             values: Default::default(),
@@ -46,9 +39,7 @@ impl<K: ScalarValue, V: ScalarValue> Default for DictionaryBuffer<K, V> {
     }
 }
 
-impl<K: ScalarValue + ArrowNativeType + Ord, V: ScalarValue + OffsetSizeTrait>
-    DictionaryBuffer<K, V>
-{
+impl<K: ArrowNativeType + Ord, V: OffsetSizeTrait> DictionaryBuffer<K, V> {
     #[allow(unused)]
     pub fn len(&self) -> usize {
         match self {
@@ -64,7 +55,7 @@ impl<K: ScalarValue + ArrowNativeType + Ord, V: ScalarValue + OffsetSizeTrait>
     /// # Panic
     ///
     /// Panics if the dictionary is too large for `K`
-    pub fn as_keys(&mut self, dictionary: &ArrayRef) -> Option<&mut ScalarBuffer<K>> {
+    pub fn as_keys(&mut self, dictionary: &ArrayRef) -> Option<&mut Vec<K>> {
         assert!(K::from_usize(dictionary.len()).is_some());
 
         match self {
@@ -106,24 +97,21 @@ impl<K: ScalarValue + ArrowNativeType + Ord, V: ScalarValue + OffsetSizeTrait>
             Self::Values { values } => Ok(values),
             Self::Dict { keys, values } => {
                 let mut spilled = OffsetBuffer::default();
-                let dict_buffers = values.data().buffers();
+                let data = values.to_data();
+                let dict_buffers = data.buffers();
                 let dict_offsets = dict_buffers[0].typed_data::<V>();
                 let dict_values = dict_buffers[1].as_slice();
 
                 if values.is_empty() {
                     // If dictionary is empty, zero pad offsets
-                    spilled.offsets.resize(keys.len() + 1);
+                    spilled.offsets.resize(keys.len() + 1, V::default());
                 } else {
                     // Note: at this point null positions will have arbitrary dictionary keys
                     // and this will hydrate them to the corresponding byte array. This is
                     // likely sub-optimal, as we would prefer zero length null "slots", but
                     // spilling is already a degenerate case and so it is unclear if this is
                     // worth optimising for, e.g. by keeping a null mask around
-                    spilled.extend_from_dictionary(
-                        keys.as_slice(),
-                        dict_offsets,
-                        dict_values,
-                    )?;
+                    spilled.extend_from_dictionary(keys.as_slice(), dict_offsets, dict_values)?;
                 }
 
                 *self = Self::Values { values: spilled };
@@ -150,8 +138,15 @@ impl<K: ScalarValue + ArrowNativeType + Ord, V: ScalarValue + OffsetSizeTrait>
                     let min = K::from_usize(0).unwrap();
                     let max = K::from_usize(values.len()).unwrap();
 
-                    // It may be possible to use SIMD here
-                    if keys.as_slice().iter().any(|x| *x < min || *x >= max) {
+                    // using copied and fold gets auto-vectorized since rust 1.70
+                    // all/any would allow early exit on invalid values
+                    // but in the happy case all values have to be checked anyway
+                    if !keys
+                        .as_slice()
+                        .iter()
+                        .copied()
+                        .fold(true, |a, x| a && x >= min && x < max)
+                    {
                         return Err(general_err!(
                             "dictionary key beyond bounds of dictionary: 0..{}",
                             values.len()
@@ -161,7 +156,7 @@ impl<K: ScalarValue + ArrowNativeType + Ord, V: ScalarValue + OffsetSizeTrait>
 
                 let builder = ArrayDataBuilder::new(data_type.clone())
                     .len(keys.len())
-                    .add_buffer(keys.into())
+                    .add_buffer(Buffer::from_vec(keys))
                     .add_child_data(values.into_data())
                     .null_bit_buffer(null_buffer);
 
@@ -179,11 +174,9 @@ impl<K: ScalarValue + ArrowNativeType + Ord, V: ScalarValue + OffsetSizeTrait>
                 };
 
                 // This will compute a new dictionary
-                let array = arrow::compute::cast(
-                    &values.into_array(null_buffer, value_type),
-                    data_type,
-                )
-                .expect("cast should be infallible");
+                let array =
+                    arrow_cast::cast(&values.into_array(null_buffer, value_type), data_type)
+                        .expect("cast should be infallible");
 
                 Ok(array)
             }
@@ -191,15 +184,7 @@ impl<K: ScalarValue + ArrowNativeType + Ord, V: ScalarValue + OffsetSizeTrait>
     }
 }
 
-impl<K: ScalarValue, V: ScalarValue> ValuesBufferSlice for DictionaryBuffer<K, V> {
-    fn capacity(&self) -> usize {
-        usize::MAX
-    }
-}
-
-impl<K: ScalarValue, V: ScalarValue + OffsetSizeTrait> ValuesBuffer
-    for DictionaryBuffer<K, V>
-{
+impl<K: ArrowNativeType, V: OffsetSizeTrait> ValuesBuffer for DictionaryBuffer<K, V> {
     fn pad_nulls(
         &mut self,
         read_offset: usize,
@@ -209,7 +194,7 @@ impl<K: ScalarValue, V: ScalarValue + OffsetSizeTrait> ValuesBuffer
     ) {
         match self {
             Self::Dict { keys, .. } => {
-                keys.resize(read_offset + levels_read);
+                keys.resize(read_offset + levels_read, K::default());
                 keys.pad_nulls(read_offset, values_read, levels_read, valid_mask)
             }
             Self::Values { values, .. } => {
@@ -219,49 +204,18 @@ impl<K: ScalarValue, V: ScalarValue + OffsetSizeTrait> ValuesBuffer
     }
 }
 
-impl<K: ScalarValue, V: ScalarValue + OffsetSizeTrait> BufferQueue
-    for DictionaryBuffer<K, V>
-{
-    type Output = Self;
-    type Slice = Self;
-
-    fn split_off(&mut self, len: usize) -> Self::Output {
-        match self {
-            Self::Dict { keys, values } => Self::Dict {
-                keys: keys.take(len),
-                values: values.clone(),
-            },
-            Self::Values { values } => Self::Values {
-                values: values.split_off(len),
-            },
-        }
-    }
-
-    fn spare_capacity_mut(&mut self, _batch_size: usize) -> &mut Self::Slice {
-        self
-    }
-
-    fn set_len(&mut self, len: usize) {
-        match self {
-            Self::Dict { keys, .. } => keys.set_len(len),
-            Self::Values { values } => values.set_len(len),
-        }
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use arrow::array::{Array, StringArray};
     use arrow::compute::cast;
+    use arrow_array::{Array, StringArray};
 
     #[test]
     fn test_dictionary_buffer() {
         let dict_type =
             ArrowType::Dictionary(Box::new(ArrowType::Int32), Box::new(ArrowType::Utf8));
 
-        let d1: ArrayRef =
-            Arc::new(StringArray::from(vec!["hello", "world", "", "a", "b"]));
+        let d1: ArrayRef = Arc::new(StringArray::from(vec!["hello", "world", "", "a", "b"]));
 
         let mut buffer = DictionaryBuffer::<i32, i32>::default();
 
@@ -273,20 +227,6 @@ mod tests {
         let valid_buffer = Buffer::from_iter(valid.iter().cloned());
         buffer.pad_nulls(0, values.len(), valid.len(), valid_buffer.as_slice());
 
-        // Split off some data
-
-        let split = buffer.split_off(4);
-        let null_buffer = Buffer::from_iter(valid.drain(0..4));
-        let array = split.into_array(Some(null_buffer), &dict_type).unwrap();
-        assert_eq!(array.data_type(), &dict_type);
-
-        let strings = cast(&array, &ArrowType::Utf8).unwrap();
-        let strings = strings.as_any().downcast_ref::<StringArray>().unwrap();
-        assert_eq!(
-            strings.iter().collect::<Vec<_>>(),
-            vec![None, None, Some("world"), Some("hello")]
-        );
-
         // Read some data not preserving the dictionary
 
         let values = buffer.spill_values().unwrap();
@@ -298,8 +238,8 @@ mod tests {
         let null_buffer = Buffer::from_iter(valid.iter().cloned());
         buffer.pad_nulls(read_offset, 2, 5, null_buffer.as_slice());
 
-        assert_eq!(buffer.len(), 9);
-        let split = buffer.split_off(9);
+        assert_eq!(buffer.len(), 13);
+        let split = std::mem::take(&mut buffer);
 
         let array = split.into_array(Some(null_buffer), &dict_type).unwrap();
         assert_eq!(array.data_type(), &dict_type);
@@ -309,6 +249,10 @@ mod tests {
         assert_eq!(
             strings.iter().collect::<Vec<_>>(),
             vec![
+                None,
+                None,
+                Some("world"),
+                Some("hello"),
                 None,
                 Some("a"),
                 Some(""),
@@ -330,7 +274,9 @@ mod tests {
             .unwrap()
             .extend_from_slice(&[0, 1, 0, 1]);
 
-        let array = buffer.split_off(4).into_array(None, &dict_type).unwrap();
+        let array = std::mem::take(&mut buffer)
+            .into_array(None, &dict_type)
+            .unwrap();
         assert_eq!(array.data_type(), &dict_type);
 
         let strings = cast(&array, &ArrowType::Utf8).unwrap();
@@ -341,7 +287,7 @@ mod tests {
         );
 
         // Can recreate with new dictionary as keys empty
-        assert!(matches!(&buffer, DictionaryBuffer::Dict { .. }));
+        assert!(matches!(&buffer, DictionaryBuffer::Values { .. }));
         assert_eq!(buffer.len(), 0);
         let d3 = Arc::new(StringArray::from(vec!["bongo"])) as ArrayRef;
         buffer.as_keys(&d3).unwrap().extend_from_slice(&[0, 0]);
diff --git a/parquet/src/arrow/buffer/mod.rs b/parquet/src/arrow/buffer/mod.rs
index 5ee89aa1a782..cbc795d94f57 100644
--- a/parquet/src/arrow/buffer/mod.rs
+++ b/parquet/src/arrow/buffer/mod.rs
@@ -18,6 +18,5 @@
 //! Logic for reading data into arrow buffers
 
 pub mod bit_util;
-pub mod converter;
 pub mod dictionary_buffer;
 pub mod offset_buffer;
diff --git a/parquet/src/arrow/buffer/offset_buffer.rs b/parquet/src/arrow/buffer/offset_buffer.rs
index 2d73e3f146b6..ce9eb1142a5b 100644
--- a/parquet/src/arrow/buffer/offset_buffer.rs
+++ b/parquet/src/arrow/buffer/offset_buffer.rs
@@ -16,35 +16,33 @@
 // under the License.
 
 use crate::arrow::buffer::bit_util::iter_set_bits_rev;
-use crate::arrow::record_reader::buffer::{
-    BufferQueue, ScalarBuffer, ScalarValue, ValuesBuffer,
-};
-use crate::column::reader::decoder::ValuesBufferSlice;
+use crate::arrow::record_reader::buffer::ValuesBuffer;
 use crate::errors::{ParquetError, Result};
-use arrow::array::{make_array, ArrayDataBuilder, ArrayRef, OffsetSizeTrait};
-use arrow::buffer::Buffer;
-use arrow::datatypes::{ArrowNativeType, DataType as ArrowType};
+use arrow_array::{make_array, ArrayRef, OffsetSizeTrait};
+use arrow_buffer::{ArrowNativeType, Buffer};
+use arrow_data::ArrayDataBuilder;
+use arrow_schema::DataType as ArrowType;
 
 /// A buffer of variable-sized byte arrays that can be converted into
 /// a corresponding [`ArrayRef`]
 #[derive(Debug)]
-pub struct OffsetBuffer<I: ScalarValue> {
-    pub offsets: ScalarBuffer<I>,
-    pub values: ScalarBuffer<u8>,
+pub struct OffsetBuffer<I: OffsetSizeTrait> {
+    pub offsets: Vec<I>,
+    pub values: Vec<u8>,
 }
 
-impl<I: ScalarValue> Default for OffsetBuffer<I> {
+impl<I: OffsetSizeTrait> Default for OffsetBuffer<I> {
     fn default() -> Self {
-        let mut offsets = ScalarBuffer::new();
-        offsets.resize(1);
+        let mut offsets = Vec::new();
+        offsets.resize(1, I::default());
         Self {
             offsets,
-            values: ScalarBuffer::new(),
+            values: Vec::new(),
         }
     }
 }
 
-impl<I: OffsetSizeTrait + ScalarValue> OffsetBuffer<I> {
+impl<I: OffsetSizeTrait> OffsetBuffer<I> {
     /// Returns the number of byte arrays in this buffer
     pub fn len(&self) -> usize {
         self.offsets.len() - 1
@@ -95,15 +93,15 @@ impl<I: OffsetSizeTrait + ScalarValue> OffsetBuffer<I> {
         dict_values: &[u8],
     ) -> Result<()> {
         for key in keys {
-            let index = key.to_usize().unwrap();
+            let index = key.as_usize();
             if index + 1 >= dict_offsets.len() {
                 return Err(general_err!(
                     "dictionary key beyond bounds of dictionary: 0..{}",
                     dict_offsets.len().saturating_sub(1)
                 ));
             }
-            let start_offset = dict_offsets[index].to_usize().unwrap();
-            let end_offset = dict_offsets[index + 1].to_usize().unwrap();
+            let start_offset = dict_offsets[index].as_usize();
+            let end_offset = dict_offsets[index + 1].as_usize();
 
             // Dictionary values are verified when decoding dictionary page
             self.try_push(&dict_values[start_offset..end_offset], false)?;
@@ -126,15 +124,11 @@ impl<I: OffsetSizeTrait + ScalarValue> OffsetBuffer<I> {
     }
 
     /// Converts this into an [`ArrayRef`] with the provided `data_type` and `null_buffer`
-    pub fn into_array(
-        self,
-        null_buffer: Option<Buffer>,
-        data_type: ArrowType,
-    ) -> ArrayRef {
+    pub fn into_array(self, null_buffer: Option<Buffer>, data_type: ArrowType) -> ArrayRef {
         let array_data_builder = ArrayDataBuilder::new(data_type)
             .len(self.len())
-            .add_buffer(self.offsets.into())
-            .add_buffer(self.values.into())
+            .add_buffer(Buffer::from_vec(self.offsets))
+            .add_buffer(Buffer::from_vec(self.values))
             .null_bit_buffer(null_buffer);
 
         let data = match cfg!(debug_assertions) {
@@ -146,41 +140,7 @@ impl<I: OffsetSizeTrait + ScalarValue> OffsetBuffer<I> {
     }
 }
 
-impl<I: OffsetSizeTrait + ScalarValue> BufferQueue for OffsetBuffer<I> {
-    type Output = Self;
-    type Slice = Self;
-
-    fn split_off(&mut self, len: usize) -> Self::Output {
-        assert!(self.offsets.len() > len, "{} > {}", self.offsets.len(), len);
-        let remaining_offsets = self.offsets.len() - len - 1;
-        let offsets = self.offsets.as_slice();
-
-        let end_offset = offsets[len];
-
-        let mut new_offsets = ScalarBuffer::new();
-        new_offsets.reserve(remaining_offsets + 1);
-        for v in &offsets[len..] {
-            new_offsets.push(*v - end_offset)
-        }
-
-        self.offsets.resize(len + 1);
-
-        Self {
-            offsets: std::mem::replace(&mut self.offsets, new_offsets),
-            values: self.values.take(end_offset.to_usize().unwrap()),
-        }
-    }
-
-    fn spare_capacity_mut(&mut self, _batch_size: usize) -> &mut Self::Slice {
-        self
-    }
-
-    fn set_len(&mut self, len: usize) {
-        assert_eq!(self.offsets.len(), len + 1);
-    }
-}
-
-impl<I: OffsetSizeTrait + ScalarValue> ValuesBuffer for OffsetBuffer<I> {
+impl<I: OffsetSizeTrait> ValuesBuffer for OffsetBuffer<I> {
     fn pad_nulls(
         &mut self,
         read_offset: usize,
@@ -189,9 +149,10 @@ impl<I: OffsetSizeTrait + ScalarValue> ValuesBuffer for OffsetBuffer<I> {
         valid_mask: &[u8],
     ) {
         assert_eq!(self.offsets.len(), read_offset + values_read + 1);
-        self.offsets.resize(read_offset + levels_read + 1);
+        self.offsets
+            .resize(read_offset + levels_read + 1, I::default());
 
-        let offsets = self.offsets.as_slice_mut();
+        let offsets = &mut self.offsets;
 
         let mut last_pos = read_offset + levels_read + 1;
         let mut last_start_offset = I::from_usize(self.values.len()).unwrap();
@@ -229,16 +190,10 @@ impl<I: OffsetSizeTrait + ScalarValue> ValuesBuffer for OffsetBuffer<I> {
     }
 }
 
-impl<I: ScalarValue> ValuesBufferSlice for OffsetBuffer<I> {
-    fn capacity(&self) -> usize {
-        usize::MAX
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
-    use arrow::array::{Array, LargeStringArray, StringArray};
+    use arrow_array::{Array, LargeStringArray, StringArray};
 
     #[test]
     fn test_offset_buffer_empty() {
@@ -266,18 +221,18 @@ mod tests {
     }
 
     #[test]
-    fn test_offset_buffer_split() {
+    fn test_offset_buffer() {
         let mut buffer = OffsetBuffer::<i32>::default();
         for v in ["hello", "world", "cupcakes", "a", "b", "c"] {
             buffer.try_push(v.as_bytes(), false).unwrap()
         }
-        let split = buffer.split_off(3);
+        let split = std::mem::take(&mut buffer);
 
         let array = split.into_array(None, ArrowType::Utf8);
         let strings = array.as_any().downcast_ref::<StringArray>().unwrap();
         assert_eq!(
             strings.iter().map(|x| x.unwrap()).collect::<Vec<_>>(),
-            vec!["hello", "world", "cupcakes"]
+            vec!["hello", "world", "cupcakes", "a", "b", "c"]
         );
 
         buffer.try_push("test".as_bytes(), false).unwrap();
@@ -285,7 +240,7 @@ mod tests {
         let strings = array.as_any().downcast_ref::<StringArray>().unwrap();
         assert_eq!(
             strings.iter().map(|x| x.unwrap()).collect::<Vec<_>>(),
-            vec!["a", "b", "c", "test"]
+            vec!["test"]
         );
     }
 
@@ -297,10 +252,10 @@ mod tests {
             buffer.try_push(v.as_bytes(), false).unwrap()
         }
 
-        let valid = vec![
+        let valid = [
             true, false, false, true, false, true, false, true, true, false, false,
         ];
-        let valid_mask = Buffer::from_iter(valid.iter().cloned());
+        let valid_mask = Buffer::from_iter(valid.iter().copied());
 
         // Both trailing and leading nulls
         buffer.pad_nulls(1, values.len() - 1, valid.len() - 1, valid_mask.as_slice());
diff --git a/parquet/src/arrow/decoder/delta_byte_array.rs b/parquet/src/arrow/decoder/delta_byte_array.rs
new file mode 100644
index 000000000000..7686a4292c43
--- /dev/null
+++ b/parquet/src/arrow/decoder/delta_byte_array.rs
@@ -0,0 +1,138 @@
+// 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.
+
+use bytes::Bytes;
+
+use crate::data_type::Int32Type;
+use crate::encodings::decoding::{Decoder, DeltaBitPackDecoder};
+use crate::errors::{ParquetError, Result};
+
+/// Decoder for `Encoding::DELTA_BYTE_ARRAY`
+pub struct DeltaByteArrayDecoder {
+    prefix_lengths: Vec<i32>,
+    suffix_lengths: Vec<i32>,
+    data: Bytes,
+    length_offset: usize,
+    data_offset: usize,
+    last_value: Vec<u8>,
+}
+
+impl DeltaByteArrayDecoder {
+    /// Create a new [`DeltaByteArrayDecoder`] with the provided data page
+    pub fn new(data: Bytes) -> Result<Self> {
+        let mut prefix = DeltaBitPackDecoder::<Int32Type>::new();
+        prefix.set_data(data.clone(), 0)?;
+
+        let num_prefix = prefix.values_left();
+        let mut prefix_lengths = vec![0; num_prefix];
+        assert_eq!(prefix.get(&mut prefix_lengths)?, num_prefix);
+
+        let mut suffix = DeltaBitPackDecoder::<Int32Type>::new();
+        suffix.set_data(data.slice(prefix.get_offset()..), 0)?;
+
+        let num_suffix = suffix.values_left();
+        let mut suffix_lengths = vec![0; num_suffix];
+        assert_eq!(suffix.get(&mut suffix_lengths)?, num_suffix);
+
+        if num_prefix != num_suffix {
+            return Err(general_err!(format!(
+                "inconsistent DELTA_BYTE_ARRAY lengths, prefixes: {num_prefix}, suffixes: {num_suffix}"
+            )));
+        }
+
+        assert_eq!(prefix_lengths.len(), suffix_lengths.len());
+
+        Ok(Self {
+            prefix_lengths,
+            suffix_lengths,
+            data,
+            length_offset: 0,
+            data_offset: prefix.get_offset() + suffix.get_offset(),
+            last_value: vec![],
+        })
+    }
+
+    /// Returns the number of values remaining
+    pub fn remaining(&self) -> usize {
+        self.prefix_lengths.len() - self.length_offset
+    }
+
+    /// Read up to `len` values, returning the number of values read
+    /// and calling `f` with each decoded byte slice
+    ///
+    /// Will short-circuit and return on error
+    pub fn read<F>(&mut self, len: usize, mut f: F) -> Result<usize>
+    where
+        F: FnMut(&[u8]) -> Result<()>,
+    {
+        let to_read = len.min(self.remaining());
+
+        let length_range = self.length_offset..self.length_offset + to_read;
+        let iter = self.prefix_lengths[length_range.clone()]
+            .iter()
+            .zip(&self.suffix_lengths[length_range]);
+
+        let data = self.data.as_ref();
+
+        for (prefix_length, suffix_length) in iter {
+            let prefix_length = *prefix_length as usize;
+            let suffix_length = *suffix_length as usize;
+
+            if self.data_offset + suffix_length > self.data.len() {
+                return Err(ParquetError::EOF("eof decoding byte array".into()));
+            }
+
+            self.last_value.truncate(prefix_length);
+            self.last_value
+                .extend_from_slice(&data[self.data_offset..self.data_offset + suffix_length]);
+            f(&self.last_value)?;
+
+            self.data_offset += suffix_length;
+        }
+
+        self.length_offset += to_read;
+        Ok(to_read)
+    }
+
+    /// Skip up to `to_skip` values, returning the number of values skipped
+    pub fn skip(&mut self, to_skip: usize) -> Result<usize> {
+        let to_skip = to_skip.min(self.prefix_lengths.len() - self.length_offset);
+
+        let length_range = self.length_offset..self.length_offset + to_skip;
+        let iter = self.prefix_lengths[length_range.clone()]
+            .iter()
+            .zip(&self.suffix_lengths[length_range]);
+
+        let data = self.data.as_ref();
+
+        for (prefix_length, suffix_length) in iter {
+            let prefix_length = *prefix_length as usize;
+            let suffix_length = *suffix_length as usize;
+
+            if self.data_offset + suffix_length > self.data.len() {
+                return Err(ParquetError::EOF("eof decoding byte array".into()));
+            }
+
+            self.last_value.truncate(prefix_length);
+            self.last_value
+                .extend_from_slice(&data[self.data_offset..self.data_offset + suffix_length]);
+            self.data_offset += suffix_length;
+        }
+        self.length_offset += to_skip;
+        Ok(to_skip)
+    }
+}
diff --git a/parquet/src/arrow/decoder/dictionary_index.rs b/parquet/src/arrow/decoder/dictionary_index.rs
new file mode 100644
index 000000000000..38f2b058360c
--- /dev/null
+++ b/parquet/src/arrow/decoder/dictionary_index.rs
@@ -0,0 +1,117 @@
+// 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.
+
+use bytes::Bytes;
+
+use crate::encodings::rle::RleDecoder;
+use crate::errors::Result;
+
+/// Decoder for `Encoding::RLE_DICTIONARY` indices
+pub struct DictIndexDecoder {
+    /// Decoder for the dictionary offsets array
+    decoder: RleDecoder,
+
+    /// We want to decode the offsets in chunks so we will maintain an internal buffer of decoded
+    /// offsets
+    index_buf: Box<[i32; 1024]>,
+    /// Current length of `index_buf`
+    index_buf_len: usize,
+    /// Current offset into `index_buf`. If `index_buf_offset` == `index_buf_len` then we've consumed
+    /// the entire buffer and need to decode another chunk of offsets.
+    index_offset: usize,
+
+    /// This is a maximum as the null count is not always known, e.g. value data from
+    /// a v1 data page
+    max_remaining_values: usize,
+}
+
+impl DictIndexDecoder {
+    /// Create a new [`DictIndexDecoder`] with the provided data page, the number of levels
+    /// associated with this data page, and the number of non-null values (if known)
+    pub fn new(data: Bytes, num_levels: usize, num_values: Option<usize>) -> Self {
+        let bit_width = data[0];
+        let mut decoder = RleDecoder::new(bit_width);
+        decoder.set_data(data.slice(1..));
+
+        Self {
+            decoder,
+            index_buf: Box::new([0; 1024]),
+            index_buf_len: 0,
+            index_offset: 0,
+            max_remaining_values: num_values.unwrap_or(num_levels),
+        }
+    }
+
+    /// Read up to `len` values, returning the number of values read
+    /// and calling `f` with each decoded dictionary index
+    ///
+    /// Will short-circuit and return on error
+    pub fn read<F: FnMut(&[i32]) -> Result<()>>(&mut self, len: usize, mut f: F) -> Result<usize> {
+        let mut values_read = 0;
+
+        while values_read != len && self.max_remaining_values != 0 {
+            if self.index_offset == self.index_buf_len {
+                // We've consumed the entire index buffer so we need to reload it before proceeding
+                let read = self.decoder.get_batch(self.index_buf.as_mut())?;
+                if read == 0 {
+                    break;
+                }
+                self.index_buf_len = read;
+                self.index_offset = 0;
+            }
+
+            let to_read = (len - values_read)
+                .min(self.index_buf_len - self.index_offset)
+                .min(self.max_remaining_values);
+
+            f(&self.index_buf[self.index_offset..self.index_offset + to_read])?;
+
+            self.index_offset += to_read;
+            values_read += to_read;
+            self.max_remaining_values -= to_read;
+        }
+        Ok(values_read)
+    }
+
+    /// Skip up to `to_skip` values, returning the number of values skipped
+    pub fn skip(&mut self, to_skip: usize) -> Result<usize> {
+        let to_skip = to_skip.min(self.max_remaining_values);
+
+        let mut values_skip = 0;
+        while values_skip < to_skip {
+            if self.index_offset == self.index_buf_len {
+                // Instead of reloading the buffer, just skip in the decoder
+                let skip = self.decoder.skip(to_skip - values_skip)?;
+
+                if skip == 0 {
+                    break;
+                }
+
+                self.max_remaining_values -= skip;
+                values_skip += skip;
+            } else {
+                // We still have indices buffered, so skip within the buffer
+                let skip = (to_skip - values_skip).min(self.index_buf_len - self.index_offset);
+
+                self.index_offset += skip;
+                self.max_remaining_values -= skip;
+                values_skip += skip;
+            }
+        }
+        Ok(values_skip)
+    }
+}
diff --git a/arrow/src/csv/mod.rs b/parquet/src/arrow/decoder/mod.rs
similarity index 73%
rename from arrow/src/csv/mod.rs
rename to parquet/src/arrow/decoder/mod.rs
index ffe82f335801..dc1000ffd15e 100644
--- a/arrow/src/csv/mod.rs
+++ b/parquet/src/arrow/decoder/mod.rs
@@ -15,13 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Transfer data between the Arrow memory format and CSV (comma-separated values).
+//! Specialized decoders optimised for decoding to arrow format
 
-pub mod reader;
-pub mod writer;
+mod delta_byte_array;
+mod dictionary_index;
 
-pub use self::reader::infer_schema_from_files;
-pub use self::reader::Reader;
-pub use self::reader::ReaderBuilder;
-pub use self::writer::Writer;
-pub use self::writer::WriterBuilder;
+pub use delta_byte_array::DeltaByteArrayDecoder;
+pub use dictionary_index::DictIndexDecoder;
diff --git a/parquet/src/arrow/mod.rs b/parquet/src/arrow/mod.rs
index 18edd06d72ce..950226aef721 100644
--- a/parquet/src/arrow/mod.rs
+++ b/parquet/src/arrow/mod.rs
@@ -15,9 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Provides API for reading/writing Arrow
-//! [RecordBatch](arrow::record_batch::RecordBatch)es and
-//! [Array](arrow::array::Array)s to/from Parquet Files.
+//! High-level API for reading/writing Arrow
+//! [RecordBatch](arrow_array::RecordBatch)es and
+//! [Array](arrow_array::Array)s to/from Parquet Files.
 //!
 //! [Apache Arrow](http://arrow.apache.org/) is a cross-language development platform for
 //! in-memory data.
@@ -25,12 +25,13 @@
 //!# Example of writing Arrow record batch to Parquet file
 //!
 //!```rust
-//! use arrow::array::{Int32Array, ArrayRef};
-//! use arrow::record_batch::RecordBatch;
-//! use parquet::arrow::arrow_writer::ArrowWriter;
-//! use parquet::file::properties::WriterProperties;
-//! use std::fs::File;
-//! use std::sync::Arc;
+//! # use arrow_array::{Int32Array, ArrayRef};
+//! # use arrow_array::RecordBatch;
+//! # use parquet::arrow::arrow_writer::ArrowWriter;
+//! # use parquet::file::properties::WriterProperties;
+//! # use tempfile::tempfile;
+//! # use std::sync::Arc;
+//! # use parquet::basic::Compression;
 //! let ids = Int32Array::from(vec![1, 2, 3, 4]);
 //! let vals = Int32Array::from(vec![5, 6, 7, 8]);
 //! let batch = RecordBatch::try_from_iter(vec![
@@ -38,10 +39,12 @@
 //!   ("val", Arc::new(vals) as ArrayRef),
 //! ]).unwrap();
 //!
-//! let file = File::create("data.parquet").unwrap();
+//! let file = tempfile().unwrap();
 //!
-//! // Default writer properties
-//! let props = WriterProperties::builder().build();
+//! // WriterProperties can be used to set Parquet file options
+//! let props = WriterProperties::builder()
+//!     .set_compression(Compression::SNAPPY)
+//!     .build();
 //!
 //! let mut writer = ArrowWriter::try_new(file, batch.schema(), Some(props)).unwrap();
 //!
@@ -51,41 +54,25 @@
 //! writer.close().unwrap();
 //! ```
 //!
-//! `WriterProperties` can be used to set Parquet file options
-//! ```rust
-//! use parquet::file::properties::WriterProperties;
-//! use parquet::basic::{ Compression, Encoding };
-//! use parquet::file::properties::WriterVersion;
-//!
-//! // File compression
-//! let props = WriterProperties::builder()
-//!     .set_compression(Compression::SNAPPY)
-//!     .build();
-//! ```
-//!
 //! # Example of reading parquet file into arrow record batch
 //!
 //! ```rust
-//! use arrow::record_batch::RecordBatchReader;
-//! use parquet::file::reader::{FileReader, SerializedFileReader};
-//! use parquet::arrow::{ParquetFileArrowReader, ArrowReader, ProjectionMask};
-//! use std::sync::Arc;
-//! use std::fs::File;
-//!
-//! # use arrow::array::Int32Array;
+//! # use std::fs::File;
+//! # use parquet::arrow::arrow_reader::ParquetRecordBatchReaderBuilder;
+//! # use std::sync::Arc;
+//! # use arrow_array::Int32Array;
 //! # use arrow::datatypes::{DataType, Field, Schema};
-//! # use arrow::record_batch::RecordBatch;
+//! # use arrow_array::RecordBatch;
 //! # use parquet::arrow::arrow_writer::ArrowWriter;
+//! #
 //! # let ids = Int32Array::from(vec![1, 2, 3, 4]);
 //! # let schema = Arc::new(Schema::new(vec![
-//! #    Field::new("id", DataType::Int32, false),
+//! #     Field::new("id", DataType::Int32, false),
 //! # ]));
 //! #
-//! # // Write to a memory buffer (can also write to a File)
 //! # let file = File::create("data.parquet").unwrap();
 //! #
-//! # let batch =
-//! #    RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(ids)]).unwrap();
+//! # let batch = RecordBatch::try_new(Arc::clone(&schema), vec![Arc::new(ids)]).unwrap();
 //! # let batches = vec![batch];
 //! #
 //! # let mut writer = ArrowWriter::try_new(file, Arc::clone(&schema), None).unwrap();
@@ -94,56 +81,55 @@
 //! #     writer.write(&batch).expect("Writing batch");
 //! # }
 //! # writer.close().unwrap();
-//!
+//! #
 //! let file = File::open("data.parquet").unwrap();
 //!
-//! let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-//! let mask = ProjectionMask::leaves(arrow_reader.parquet_schema(), [0]);
+//! let builder = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+//! println!("Converted arrow schema is: {}", builder.schema());
 //!
-//! println!("Converted arrow schema is: {}", arrow_reader.get_schema().unwrap());
-//! println!("Arrow schema after projection is: {}",
-//! arrow_reader.get_schema_by_columns(mask.clone()).unwrap());
+//! let mut reader = builder.build().unwrap();
 //!
-//! let mut unprojected = arrow_reader.get_record_reader(2048).unwrap();
-//! println!("Unprojected reader schema: {}", unprojected.schema());
+//! let record_batch = reader.next().unwrap().unwrap();
 //!
-//! let mut record_batch_reader = arrow_reader.get_record_reader_by_columns(mask, 2048).unwrap();
-//!
-//! for maybe_record_batch in record_batch_reader {
-//!    let record_batch = maybe_record_batch.unwrap();
-//!    if record_batch.num_rows() > 0 {
-//!        println!("Read {} records.", record_batch.num_rows());
-//!    } else {
-//!        println!("End of file!");
-//!    }
-//!}
+//! println!("Read {} records.", record_batch.num_rows());
 //! ```
 
 experimental!(mod array_reader);
 pub mod arrow_reader;
 pub mod arrow_writer;
 mod buffer;
+mod decoder;
 
 #[cfg(feature = "async")]
 pub mod async_reader;
+#[cfg(feature = "async")]
+pub mod async_writer;
 
 mod record_reader;
 experimental!(mod schema);
 
-pub use self::arrow_reader::ArrowReader;
-pub use self::arrow_reader::ParquetFileArrowReader;
 pub use self::arrow_writer::ArrowWriter;
 #[cfg(feature = "async")]
 pub use self::async_reader::ParquetRecordBatchStreamBuilder;
+#[cfg(feature = "async")]
+pub use self::async_writer::AsyncArrowWriter;
 use crate::schema::types::SchemaDescriptor;
 
 pub use self::schema::{
-    arrow_to_parquet_schema, parquet_to_arrow_schema, parquet_to_arrow_schema_by_columns,
+    arrow_to_parquet_schema, parquet_to_arrow_field_levels, parquet_to_arrow_schema,
+    parquet_to_arrow_schema_by_columns, FieldLevels,
 };
 
 /// Schema metadata key used to store serialized Arrow IPC schema
 pub const ARROW_SCHEMA_META_KEY: &str = "ARROW:schema";
 
+/// The value of this metadata key, if present on [`Field::metadata`], will be used
+/// to populate [`BasicTypeInfo::id`]
+///
+/// [`Field::metadata`]: arrow_schema::Field::metadata
+/// [`BasicTypeInfo::id`]: crate::schema::types::BasicTypeInfo::id
+pub const PARQUET_FIELD_ID_META_KEY: &str = "PARQUET:field_id";
+
 /// A [`ProjectionMask`] identifies a set of columns within a potentially nested schema to project
 ///
 /// In particular, a [`ProjectionMask`] can be constructed from a list of leaf column indices
@@ -189,10 +175,7 @@ impl ProjectionMask {
     /// Note: repeated or out of order indices will not impact the final mask
     ///
     /// i.e. `[0, 1, 2]` will construct the same mask as `[1, 0, 0, 2]`
-    pub fn leaves(
-        schema: &SchemaDescriptor,
-        indices: impl IntoIterator<Item = usize>,
-    ) -> Self {
+    pub fn leaves(schema: &SchemaDescriptor, indices: impl IntoIterator<Item = usize>) -> Self {
         let mut mask = vec![false; schema.num_columns()];
         for leaf_idx in indices {
             mask[leaf_idx] = true;
@@ -205,10 +188,7 @@ impl ProjectionMask {
     /// Note: repeated or out of order indices will not impact the final mask
     ///
     /// i.e. `[0, 1, 2]` will construct the same mask as `[1, 0, 0, 2]`
-    pub fn roots(
-        schema: &SchemaDescriptor,
-        indices: impl IntoIterator<Item = usize>,
-    ) -> Self {
+    pub fn roots(schema: &SchemaDescriptor, indices: impl IntoIterator<Item = usize>) -> Self {
         let num_root_columns = schema.root_schema().get_fields().len();
         let mut root_mask = vec![false; num_root_columns];
         for root_idx in indices {
diff --git a/parquet/src/arrow/record_reader/buffer.rs b/parquet/src/arrow/record_reader/buffer.rs
index 7101eaa9ccc9..880407a54745 100644
--- a/parquet/src/arrow/record_reader/buffer.rs
+++ b/parquet/src/arrow/record_reader/buffer.rs
@@ -15,210 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::marker::PhantomData;
-
 use crate::arrow::buffer::bit_util::iter_set_bits_rev;
-use arrow::buffer::{Buffer, MutableBuffer};
-use arrow::datatypes::ArrowNativeType;
-
-/// A buffer that supports writing new data to the end, and removing data from the front
-///
-/// Used by [RecordReader](`super::RecordReader`) to buffer up values before returning a
-/// potentially smaller number of values, corresponding to a whole number of semantic records
-pub trait BufferQueue: Sized {
-    type Output: Sized;
-
-    type Slice: ?Sized;
-
-    /// Split out the first `len` items
-    ///
-    /// # Panics
-    ///
-    /// Implementations must panic if `len` is beyond the length of [`BufferQueue`]
-    ///
-    fn split_off(&mut self, len: usize) -> Self::Output;
-
-    /// Returns a [`Self::Slice`] with at least `batch_size` capacity that can be used
-    /// to append data to the end of this [`BufferQueue`]
-    ///
-    /// NB: writes to the returned slice will not update the length of [`BufferQueue`]
-    /// instead a subsequent call should be made to [`BufferQueue::set_len`]
-    fn spare_capacity_mut(&mut self, batch_size: usize) -> &mut Self::Slice;
-
-    /// Sets the length of the [`BufferQueue`].
-    ///
-    /// Intended to be used in combination with [`BufferQueue::spare_capacity_mut`]
-    ///
-    /// # Panics
-    ///
-    /// Implementations must panic if `len` is beyond the initialized length
-    ///
-    /// Implementations may panic if `set_len` is called with less than what has been written
-    ///
-    /// This distinction is to allow for implementations that return a default initialized
-    /// [BufferQueue::Slice`] which doesn't track capacity and length separately
-    ///
-    /// For example, [`BufferQueue`] returns a default-initialized `&mut [T]`, and does not
-    /// track how much of this slice is actually written to by the caller. This is still
-    /// safe as the slice is default-initialized.
-    ///
-    fn set_len(&mut self, len: usize);
-}
-
-/// A marker trait for [scalar] types
-///
-/// This means that a `[Self::default()]` of length `len` can be safely created from a
-/// zero-initialized `[u8]` with length `len * std::mem::size_of::<Self>()` and
-/// alignment of `std::mem::size_of::<Self>()`
-///
-/// [scalar]: https://doc.rust-lang.org/book/ch03-02-data-types.html#scalar-types
-///
-pub trait ScalarValue: Copy {}
-impl ScalarValue for bool {}
-impl ScalarValue for u8 {}
-impl ScalarValue for i8 {}
-impl ScalarValue for u16 {}
-impl ScalarValue for i16 {}
-impl ScalarValue for u32 {}
-impl ScalarValue for i32 {}
-impl ScalarValue for u64 {}
-impl ScalarValue for i64 {}
-impl ScalarValue for f32 {}
-impl ScalarValue for f64 {}
-
-/// A typed buffer similar to [`Vec<T>`] but using [`MutableBuffer`] for storage
-#[derive(Debug)]
-pub struct ScalarBuffer<T: ScalarValue> {
-    buffer: MutableBuffer,
-
-    /// Length in elements of size T
-    len: usize,
-
-    /// Placeholder to allow `T` as an invariant generic parameter
-    /// without making it !Send
-    _phantom: PhantomData<fn(T) -> T>,
-}
-
-impl<T: ScalarValue> Default for ScalarBuffer<T> {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<T: ScalarValue> ScalarBuffer<T> {
-    pub fn new() -> Self {
-        Self {
-            buffer: MutableBuffer::new(0),
-            len: 0,
-            _phantom: Default::default(),
-        }
-    }
-
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    pub fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    pub fn reserve(&mut self, additional: usize) {
-        self.buffer.reserve(additional * std::mem::size_of::<T>());
-    }
 
-    pub fn resize(&mut self, len: usize) {
-        self.buffer.resize(len * std::mem::size_of::<T>(), 0);
-        self.len = len;
-    }
-
-    #[inline]
-    pub fn as_slice(&self) -> &[T] {
-        let (prefix, buf, suffix) = unsafe { self.buffer.as_slice().align_to::<T>() };
-        assert!(prefix.is_empty() && suffix.is_empty());
-        buf
-    }
-
-    #[inline]
-    pub fn as_slice_mut(&mut self) -> &mut [T] {
-        let (prefix, buf, suffix) =
-            unsafe { self.buffer.as_slice_mut().align_to_mut::<T>() };
-        assert!(prefix.is_empty() && suffix.is_empty());
-        buf
-    }
-
-    pub fn take(&mut self, len: usize) -> Self {
-        assert!(len <= self.len);
-
-        let num_bytes = len * std::mem::size_of::<T>();
-        let remaining_bytes = self.buffer.len() - num_bytes;
-        // TODO: Optimize to reduce the copy
-        // create an empty buffer, as it will be resized below
-        let mut remaining = MutableBuffer::new(0);
-        remaining.resize(remaining_bytes, 0);
-
-        let new_records = remaining.as_slice_mut();
-
-        new_records[0..remaining_bytes]
-            .copy_from_slice(&self.buffer.as_slice()[num_bytes..]);
-
-        self.buffer.resize(num_bytes, 0);
-        self.len -= len;
-
-        Self {
-            buffer: std::mem::replace(&mut self.buffer, remaining),
-            len,
-            _phantom: Default::default(),
-        }
-    }
-}
-
-impl<T: ScalarValue + ArrowNativeType> ScalarBuffer<T> {
-    pub fn push(&mut self, v: T) {
-        self.buffer.push(v);
-        self.len += 1;
-    }
-
-    pub fn extend_from_slice(&mut self, v: &[T]) {
-        self.buffer.extend_from_slice(v);
-        self.len += v.len();
-    }
-}
-
-impl<T: ScalarValue> From<ScalarBuffer<T>> for Buffer {
-    fn from(t: ScalarBuffer<T>) -> Self {
-        t.buffer.into()
-    }
-}
-
-impl<T: ScalarValue> BufferQueue for ScalarBuffer<T> {
-    type Output = Buffer;
-
-    type Slice = [T];
-
-    fn split_off(&mut self, len: usize) -> Self::Output {
-        self.take(len).into()
-    }
-
-    fn spare_capacity_mut(&mut self, batch_size: usize) -> &mut Self::Slice {
-        self.buffer
-            .resize((self.len + batch_size) * std::mem::size_of::<T>(), 0);
-
-        let range = self.len..self.len + batch_size;
-        &mut self.as_slice_mut()[range]
-    }
-
-    fn set_len(&mut self, len: usize) {
-        self.len = len;
-
-        let new_bytes = self.len * std::mem::size_of::<T>();
-        assert!(new_bytes <= self.buffer.len());
-        self.buffer.resize(new_bytes, 0);
-    }
-}
-
-/// A [`BufferQueue`] capable of storing column values
-pub trait ValuesBuffer: BufferQueue {
-    ///
+/// A buffer that supports padding with nulls
+pub trait ValuesBuffer: Default {
     /// If a column contains nulls, more level data may be read than value data, as null
     /// values are not encoded. Therefore, first the levels data is read, the null count
     /// determined, and then the corresponding number of values read to a [`ValuesBuffer`].
@@ -242,7 +42,7 @@ pub trait ValuesBuffer: BufferQueue {
     );
 }
 
-impl<T: ScalarValue> ValuesBuffer for ScalarBuffer<T> {
+impl<T: Copy + Default> ValuesBuffer for Vec<T> {
     fn pad_nulls(
         &mut self,
         read_offset: usize,
@@ -250,18 +50,15 @@ impl<T: ScalarValue> ValuesBuffer for ScalarBuffer<T> {
         levels_read: usize,
         valid_mask: &[u8],
     ) {
-        let slice = self.as_slice_mut();
-        assert!(slice.len() >= read_offset + levels_read);
+        self.resize(read_offset + levels_read, T::default());
 
         let values_range = read_offset..read_offset + values_read;
-        for (value_pos, level_pos) in
-            values_range.rev().zip(iter_set_bits_rev(valid_mask))
-        {
+        for (value_pos, level_pos) in values_range.rev().zip(iter_set_bits_rev(valid_mask)) {
             debug_assert!(level_pos >= value_pos);
             if level_pos <= value_pos {
                 break;
             }
-            slice[level_pos] = slice[value_pos];
+            self[level_pos] = self[value_pos];
         }
     }
 }
diff --git a/parquet/src/arrow/record_reader/definition_levels.rs b/parquet/src/arrow/record_reader/definition_levels.rs
index 2d65db77fa69..fcd04fbb9bbe 100644
--- a/parquet/src/arrow/record_reader/definition_levels.rs
+++ b/parquet/src/arrow/record_reader/definition_levels.rs
@@ -15,29 +15,23 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::ops::Range;
-
-use arrow::array::BooleanBufferBuilder;
-use arrow::bitmap::Bitmap;
-use arrow::buffer::Buffer;
-use arrow::util::bit_chunk_iterator::UnalignedBitChunk;
+use arrow_array::builder::BooleanBufferBuilder;
+use arrow_buffer::bit_chunk_iterator::UnalignedBitChunk;
+use arrow_buffer::Buffer;
+use bytes::Bytes;
 
 use crate::arrow::buffer::bit_util::count_set_bits;
-use crate::arrow::record_reader::buffer::BufferQueue;
 use crate::basic::Encoding;
 use crate::column::reader::decoder::{
-    ColumnLevelDecoder, ColumnLevelDecoderImpl, DefinitionLevelDecoder, LevelsBufferSlice,
+    ColumnLevelDecoder, DefinitionLevelDecoder, DefinitionLevelDecoderImpl,
 };
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::ColumnDescPtr;
-use crate::util::memory::ByteBufferPtr;
-
-use super::{buffer::ScalarBuffer, MIN_BATCH_SIZE};
 
 enum BufferInner {
     /// Compute levels and null mask
     Full {
-        levels: ScalarBuffer<i16>,
+        levels: Vec<i16>,
         nulls: BooleanBufferBuilder,
         max_level: i16,
     },
@@ -79,7 +73,7 @@ impl DefinitionLevelBuffer {
                 }
             }
             false => BufferInner::Full {
-                levels: ScalarBuffer::new(),
+                levels: Vec::new(),
                 nulls: BooleanBufferBuilder::new(0),
                 max_level: desc.max_def_level(),
             },
@@ -88,43 +82,21 @@ impl DefinitionLevelBuffer {
         Self { inner, len: 0 }
     }
 
-    pub fn split_levels(&mut self, len: usize) -> Option<Buffer> {
+    /// Returns the built level data
+    pub fn consume_levels(&mut self) -> Option<Vec<i16>> {
         match &mut self.inner {
-            BufferInner::Full { levels, .. } => {
-                let out = levels.split_off(len);
-                self.len = levels.len();
-                Some(out)
-            }
+            BufferInner::Full { levels, .. } => Some(std::mem::take(levels)),
             BufferInner::Mask { .. } => None,
         }
     }
 
-    pub fn set_len(&mut self, len: usize) {
-        assert_eq!(self.nulls().len(), len);
-        self.len = len;
-    }
-
-    /// Split `len` levels out of `self`
-    pub fn split_bitmask(&mut self, len: usize) -> Bitmap {
-        let old_builder = match &mut self.inner {
-            BufferInner::Full { nulls, .. } => nulls,
-            BufferInner::Mask { nulls } => nulls,
-        };
-
-        // Compute the number of values left behind
-        let num_left_values = old_builder.len() - len;
-        let mut new_builder =
-            BooleanBufferBuilder::new(MIN_BATCH_SIZE.max(num_left_values));
-
-        // Copy across remaining values
-        new_builder.append_packed_range(len..old_builder.len(), old_builder.as_slice());
-
-        // Truncate buffer
-        old_builder.resize(len);
-
-        // Swap into self
-        self.len = new_builder.len();
-        Bitmap::from(std::mem::replace(old_builder, new_builder).finish())
+    /// Returns the built null bitmask
+    pub fn consume_bitmask(&mut self) -> Buffer {
+        self.len = 0;
+        match &mut self.inner {
+            BufferInner::Full { nulls, .. } => nulls.finish().into_inner(),
+            BufferInner::Mask { nulls } => nulls.finish().into_inner(),
+        }
     }
 
     pub fn nulls(&self) -> &BooleanBufferBuilder {
@@ -135,21 +107,9 @@ impl DefinitionLevelBuffer {
     }
 }
 
-impl LevelsBufferSlice for DefinitionLevelBuffer {
-    fn capacity(&self) -> usize {
-        usize::MAX
-    }
-
-    fn count_nulls(&self, range: Range<usize>, _max_level: i16) -> usize {
-        let total_count = range.end - range.start;
-        let range = range.start + self.len..range.end + self.len;
-        total_count - count_set_bits(self.nulls().as_slice(), range)
-    }
-}
-
 enum MaybePacked {
     Packed(PackedDecoder),
-    Fallback(ColumnLevelDecoderImpl),
+    Fallback(DefinitionLevelDecoderImpl),
 }
 
 pub struct DefinitionLevelBufferDecoder {
@@ -161,7 +121,7 @@ impl DefinitionLevelBufferDecoder {
     pub fn new(max_level: i16, packed: bool) -> Self {
         let decoder = match packed {
             true => MaybePacked::Packed(PackedDecoder::new()),
-            false => MaybePacked::Fallback(ColumnLevelDecoderImpl::new(max_level)),
+            false => MaybePacked::Fallback(DefinitionLevelDecoderImpl::new(max_level)),
         };
 
         Self { max_level, decoder }
@@ -169,16 +129,22 @@ impl DefinitionLevelBufferDecoder {
 }
 
 impl ColumnLevelDecoder for DefinitionLevelBufferDecoder {
-    type Slice = DefinitionLevelBuffer;
+    type Buffer = DefinitionLevelBuffer;
 
-    fn set_data(&mut self, encoding: Encoding, data: ByteBufferPtr) {
+    fn set_data(&mut self, encoding: Encoding, data: Bytes) {
         match &mut self.decoder {
             MaybePacked::Packed(d) => d.set_data(encoding, data),
             MaybePacked::Fallback(d) => d.set_data(encoding, data),
         }
     }
+}
 
-    fn read(&mut self, writer: &mut Self::Slice, range: Range<usize>) -> Result<usize> {
+impl DefinitionLevelDecoder for DefinitionLevelBufferDecoder {
+    fn read_def_levels(
+        &mut self,
+        writer: &mut Self::Buffer,
+        num_levels: usize,
+    ) -> Result<(usize, usize)> {
         match (&mut writer.inner, &mut self.decoder) {
             (
                 BufferInner::Full {
@@ -189,41 +155,33 @@ impl ColumnLevelDecoder for DefinitionLevelBufferDecoder {
                 MaybePacked::Fallback(decoder),
             ) => {
                 assert_eq!(self.max_level, *max_level);
-                assert_eq!(range.start + writer.len, nulls.len());
 
-                levels.resize(range.end + writer.len);
-
-                let slice = &mut levels.as_slice_mut()[writer.len..];
-                let levels_read = decoder.read(slice, range.clone())?;
+                let start = levels.len();
+                let (values_read, levels_read) = decoder.read_def_levels(levels, num_levels)?;
 
                 nulls.reserve(levels_read);
-                for i in &slice[range.start..range.start + levels_read] {
-                    nulls.append(i == max_level)
+                for i in &levels[start..] {
+                    nulls.append(i == max_level);
                 }
 
-                Ok(levels_read)
+                Ok((values_read, levels_read))
             }
             (BufferInner::Mask { nulls }, MaybePacked::Packed(decoder)) => {
                 assert_eq!(self.max_level, 1);
-                assert_eq!(range.start + writer.len, nulls.len());
 
-                decoder.read(nulls, range.end - range.start)
+                let start = nulls.len();
+                let levels_read = decoder.read(nulls, num_levels)?;
+
+                let values_read = count_set_bits(nulls.as_slice(), start..start + levels_read);
+                Ok((values_read, levels_read))
             }
             _ => unreachable!("inconsistent null mask"),
         }
     }
-}
 
-impl DefinitionLevelDecoder for DefinitionLevelBufferDecoder {
-    fn skip_def_levels(
-        &mut self,
-        num_levels: usize,
-        max_def_level: i16,
-    ) -> Result<(usize, usize)> {
+    fn skip_def_levels(&mut self, num_levels: usize) -> Result<(usize, usize)> {
         match &mut self.decoder {
-            MaybePacked::Fallback(decoder) => {
-                decoder.skip_def_levels(num_levels, max_def_level)
-            }
+            MaybePacked::Fallback(decoder) => decoder.skip_def_levels(num_levels),
             MaybePacked::Packed(decoder) => decoder.skip(num_levels),
         }
     }
@@ -244,7 +202,7 @@ impl DefinitionLevelDecoder for DefinitionLevelBufferDecoder {
 /// [RLE]: https://github.com/apache/parquet-format/blob/master/Encodings.md#run-length-encoding--bit-packing-hybrid-rle--3
 /// [BIT_PACKED]: https://github.com/apache/parquet-format/blob/master/Encodings.md#bit-packed-deprecated-bit_packed--4
 struct PackedDecoder {
-    data: ByteBufferPtr,
+    data: Bytes,
     data_offset: usize,
     rle_left: usize,
     rle_value: bool,
@@ -263,8 +221,7 @@ impl PackedDecoder {
             self.rle_left = (indicator_value >> 1) as usize;
             let byte = *self.data.as_ref().get(self.data_offset).ok_or_else(|| {
                 ParquetError::EOF(
-                    "unexpected end of file whilst decoding definition levels rle value"
-                        .into(),
+                    "unexpected end of file whilst decoding definition levels rle value".into(),
                 )
             })?;
 
@@ -304,7 +261,7 @@ impl PackedDecoder {
 impl PackedDecoder {
     fn new() -> Self {
         Self {
-            data: ByteBufferPtr::new(vec![]),
+            data: Bytes::from(vec![]),
             data_offset: 0,
             rle_left: 0,
             rle_value: false,
@@ -313,12 +270,13 @@ impl PackedDecoder {
         }
     }
 
-    fn set_data(&mut self, encoding: Encoding, data: ByteBufferPtr) {
+    fn set_data(&mut self, encoding: Encoding, data: Bytes) {
         self.rle_left = 0;
         self.rle_value = false;
         self.packed_offset = 0;
         self.packed_count = match encoding {
             Encoding::RLE => 0,
+            #[allow(deprecated)]
             Encoding::BIT_PACKED => data.len() * 8,
             _ => unreachable!("invalid level encoding: {}", encoding),
         };
@@ -368,11 +326,10 @@ impl PackedDecoder {
                     skipped_value += to_skip;
                 }
             } else if self.packed_count != self.packed_offset {
-                let to_skip = (self.packed_count - self.packed_offset)
-                    .min(level_num - skipped_level);
+                let to_skip =
+                    (self.packed_count - self.packed_offset).min(level_num - skipped_level);
                 let offset = self.data_offset * 8 + self.packed_offset;
-                let bit_chunk =
-                    UnalignedBitChunk::new(self.data.as_ref(), offset, to_skip);
+                let bit_chunk = UnalignedBitChunk::new(self.data.as_ref(), offset, to_skip);
                 skipped_value += bit_chunk.count_ones();
                 self.packed_offset += to_skip;
                 skipped_level += to_skip;
@@ -392,11 +349,8 @@ impl PackedDecoder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use std::sync::Arc;
 
-    use crate::basic::Type as PhysicalType;
     use crate::encodings::rle::RleEncoder;
-    use crate::schema::types::{ColumnDescriptor, ColumnPath, Type};
     use rand::{thread_rng, Rng};
 
     #[test]
@@ -415,7 +369,7 @@ mod tests {
 
         let encoded = encoder.consume();
         let mut decoder = PackedDecoder::new();
-        decoder.set_data(Encoding::RLE, ByteBufferPtr::new(encoded));
+        decoder.set_data(Encoding::RLE, encoded.into());
 
         // Decode data in random length intervals
         let mut decoded = BooleanBufferBuilder::new(len);
@@ -454,7 +408,7 @@ mod tests {
 
         let encoded = encoder.consume();
         let mut decoder = PackedDecoder::new();
-        decoder.set_data(Encoding::RLE, ByteBufferPtr::new(encoded));
+        decoder.set_data(Encoding::RLE, encoded.into());
 
         let mut skip_value = 0;
         let mut read_value = 0;
@@ -469,14 +423,12 @@ mod tests {
             }
             let to_read_or_skip_level = rng.gen_range(1..=remaining_levels);
             if rng.gen_bool(0.5) {
-                let (skip_val_num, skip_level_num) =
-                    decoder.skip(to_read_or_skip_level).unwrap();
+                let (skip_val_num, skip_level_num) = decoder.skip(to_read_or_skip_level).unwrap();
                 skip_value += skip_val_num;
                 skip_level += skip_level_num
             } else {
                 let mut decoded = BooleanBufferBuilder::new(to_read_or_skip_level);
-                let read_level_num =
-                    decoder.read(&mut decoded, to_read_or_skip_level).unwrap();
+                let read_level_num = decoder.read(&mut decoded, to_read_or_skip_level).unwrap();
                 read_level += read_level_num;
                 for i in 0..read_level_num {
                     assert!(!decoded.is_empty());
@@ -493,30 +445,4 @@ mod tests {
         assert_eq!(read_level + skip_level, len);
         assert_eq!(read_value + skip_value, total_value);
     }
-
-    #[test]
-    fn test_split_off() {
-        let t = Type::primitive_type_builder("col", PhysicalType::INT32)
-            .build()
-            .unwrap();
-
-        let descriptor = Arc::new(ColumnDescriptor::new(
-            Arc::new(t),
-            1,
-            0,
-            ColumnPath::new(vec![]),
-        ));
-
-        let mut buffer = DefinitionLevelBuffer::new(&descriptor, true);
-        match &mut buffer.inner {
-            BufferInner::Mask { nulls } => nulls.append_n(100, false),
-            _ => unreachable!(),
-        };
-
-        let bitmap = buffer.split_bitmask(19);
-
-        // Should have split off 19 records leaving, 81 behind
-        assert_eq!(bitmap.bit_len(), 3 * 8); // Note: bitmask only tracks bytes not bits
-        assert_eq!(buffer.nulls().len(), 81);
-    }
 }
diff --git a/parquet/src/arrow/record_reader/mod.rs b/parquet/src/arrow/record_reader/mod.rs
index 18b4c9e07026..7456da053b9c 100644
--- a/parquet/src/arrow/record_reader/mod.rs
+++ b/parquet/src/arrow/record_reader/mod.rs
@@ -15,19 +15,17 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::cmp::{max, min};
-
-use arrow::bitmap::Bitmap;
-use arrow::buffer::Buffer;
+use arrow_buffer::Buffer;
 
 use crate::arrow::record_reader::{
-    buffer::{BufferQueue, ScalarBuffer, ValuesBuffer},
+    buffer::ValuesBuffer,
     definition_levels::{DefinitionLevelBuffer, DefinitionLevelBufferDecoder},
 };
+use crate::column::reader::decoder::RepetitionLevelDecoderImpl;
 use crate::column::{
     page::PageReader,
     reader::{
-        decoder::{ColumnLevelDecoderImpl, ColumnValueDecoder, ColumnValueDecoderImpl},
+        decoder::{ColumnValueDecoder, ColumnValueDecoderImpl},
         GenericColumnReader,
     },
 };
@@ -38,15 +36,11 @@ use crate::schema::types::ColumnDescPtr;
 pub(crate) mod buffer;
 mod definition_levels;
 
-/// The minimum number of levels read when reading a repeated field
-pub(crate) const MIN_BATCH_SIZE: usize = 1024;
-
 /// A `RecordReader` is a stateful column reader that delimits semantic records.
-pub type RecordReader<T> =
-    GenericRecordReader<ScalarBuffer<<T as DataType>::T>, ColumnValueDecoderImpl<T>>;
+pub type RecordReader<T> = GenericRecordReader<Vec<<T as DataType>::T>, ColumnValueDecoderImpl<T>>;
 
 pub(crate) type ColumnReader<CV> =
-    GenericColumnReader<ColumnLevelDecoderImpl, DefinitionLevelBufferDecoder, CV>;
+    GenericColumnReader<RepetitionLevelDecoderImpl, DefinitionLevelBufferDecoder, CV>;
 
 /// A generic stateful column reader that delimits semantic records
 ///
@@ -56,42 +50,36 @@ pub(crate) type ColumnReader<CV> =
 pub struct GenericRecordReader<V, CV> {
     column_desc: ColumnDescPtr,
 
-    records: V,
+    values: V,
     def_levels: Option<DefinitionLevelBuffer>,
-    rep_levels: Option<ScalarBuffer<i16>>,
+    rep_levels: Option<Vec<i16>>,
     column_reader: Option<ColumnReader<CV>>,
-
-    /// Number of records accumulated in records
-    num_records: usize,
-
-    /// Number of values `num_records` contains.
+    /// Number of buffered levels / null-padded values
     num_values: usize,
-
-    /// Starts from 1, number of values have been written to buffer
-    values_written: usize,
+    /// Number of buffered records
+    num_records: usize,
 }
 
 impl<V, CV> GenericRecordReader<V, CV>
 where
-    V: ValuesBuffer + Default,
-    CV: ColumnValueDecoder<Slice = V::Slice>,
+    V: ValuesBuffer,
+    CV: ColumnValueDecoder<Buffer = V>,
 {
     /// Create a new [`GenericRecordReader`]
     pub fn new(desc: ColumnDescPtr) -> Self {
         let def_levels = (desc.max_def_level() > 0)
             .then(|| DefinitionLevelBuffer::new(&desc, packed_null_mask(&desc)));
 
-        let rep_levels = (desc.max_rep_level() > 0).then(ScalarBuffer::new);
+        let rep_levels = (desc.max_rep_level() > 0).then(Vec::new);
 
         Self {
-            records: Default::default(),
+            values: V::default(),
             def_levels,
             rep_levels,
             column_reader: None,
             column_desc: desc,
-            num_records: 0,
             num_values: 0,
-            values_written: 0,
+            num_records: 0,
         }
     }
 
@@ -101,14 +89,11 @@ where
         let values_decoder = CV::new(descr);
 
         let def_level_decoder = (descr.max_def_level() != 0).then(|| {
-            DefinitionLevelBufferDecoder::new(
-                descr.max_def_level(),
-                packed_null_mask(descr),
-            )
+            DefinitionLevelBufferDecoder::new(descr.max_def_level(), packed_null_mask(descr))
         });
 
         let rep_level_decoder = (descr.max_rep_level() != 0)
-            .then(|| ColumnLevelDecoderImpl::new(descr.max_rep_level()));
+            .then(|| RepetitionLevelDecoderImpl::new(descr.max_rep_level()));
 
         self.column_reader = Some(GenericColumnReader::new_with_decoders(
             self.column_desc.clone(),
@@ -133,50 +118,12 @@ where
         let mut records_read = 0;
 
         loop {
-            // Try to find some records from buffers that has been read into memory
-            // but not counted as seen records.
-            let end_of_column = !self.column_reader.as_mut().unwrap().has_next()?;
-
-            let (record_count, value_count) =
-                self.count_records(num_records - records_read, end_of_column);
-
-            self.num_records += record_count;
-            self.num_values += value_count;
-            records_read += record_count;
-
-            if records_read == num_records || end_of_column {
+            let records_to_read = num_records - records_read;
+            records_read += self.read_one_batch(records_to_read)?;
+            if records_read == num_records || !self.column_reader.as_mut().unwrap().has_next()? {
                 break;
             }
-
-            // If repetition levels present, we don't know how much more to read
-            // in order to read the requested number of records, therefore read at least
-            // MIN_BATCH_SIZE, otherwise read **exactly** what was requested. This helps
-            // to avoid a degenerate case where the buffers are never fully drained.
-            //
-            // Consider the scenario where the user is requesting batches of MIN_BATCH_SIZE.
-            //
-            // When transitioning across a row group boundary, this will read some remainder
-            // from the row group `r`, before reading MIN_BATCH_SIZE from the next row group,
-            // leaving `MIN_BATCH_SIZE + r` in the buffer.
-            //
-            // The client will then only split off the `MIN_BATCH_SIZE` they actually wanted,
-            // leaving behind `r`. This will continue indefinitely.
-            //
-            // Aside from wasting cycles splitting and shuffling buffers unnecessarily, this
-            // prevents dictionary preservation from functioning correctly as the buffer
-            // will never be emptied, allowing a new dictionary to be registered.
-            //
-            // This degenerate case can still occur for repeated fields, but
-            // it is avoided for the more common case of a non-repeated field
-            let batch_size = match &self.rep_levels {
-                Some(_) => max(num_records - records_read, MIN_BATCH_SIZE),
-                None => num_records - records_read,
-            };
-
-            // Try to more value from parquet pages
-            self.read_one_batch(batch_size)?;
         }
-
         Ok(records_read)
     }
 
@@ -186,31 +133,10 @@ where
     ///
     /// Number of records skipped
     pub fn skip_records(&mut self, num_records: usize) -> Result<usize> {
-        // First need to clear the buffer
-        let end_of_column = match self.column_reader.as_mut() {
-            Some(reader) => !reader.has_next()?,
-            None => return Ok(0),
-        };
-
-        let (buffered_records, buffered_values) =
-            self.count_records(num_records, end_of_column);
-
-        self.num_records += buffered_records;
-        self.num_values += buffered_values;
-
-        let remaining = num_records - buffered_records;
-
-        if remaining == 0 {
-            return Ok(buffered_records);
+        match self.column_reader.as_mut() {
+            Some(reader) => reader.skip_records(num_records),
+            None => Ok(0),
         }
-
-        let skipped = self
-            .column_reader
-            .as_mut()
-            .unwrap()
-            .skip_records(remaining)?;
-
-        Ok(skipped + buffered_records)
     }
 
     /// Returns number of records stored in buffer.
@@ -230,171 +156,83 @@ where
     /// The implementation has side effects. It will create a new buffer to hold those
     /// definition level values that have already been read into memory but not counted
     /// as record values, e.g. those from `self.num_values` to `self.values_written`.
-    pub fn consume_def_levels(&mut self) -> Option<Buffer> {
-        match self.def_levels.as_mut() {
-            Some(x) => x.split_levels(self.num_values),
-            None => None,
-        }
+    pub fn consume_def_levels(&mut self) -> Option<Vec<i16>> {
+        self.def_levels.as_mut().and_then(|x| x.consume_levels())
     }
 
     /// Return repetition level data.
     /// The side effect is similar to `consume_def_levels`.
-    pub fn consume_rep_levels(&mut self) -> Option<Buffer> {
-        match self.rep_levels.as_mut() {
-            Some(x) => Some(x.split_off(self.num_values)),
-            None => None,
-        }
+    pub fn consume_rep_levels(&mut self) -> Option<Vec<i16>> {
+        self.rep_levels.as_mut().map(std::mem::take)
     }
 
     /// Returns currently stored buffer data.
     /// The side effect is similar to `consume_def_levels`.
-    pub fn consume_record_data(&mut self) -> V::Output {
-        self.records.split_off(self.num_values)
+    pub fn consume_record_data(&mut self) -> V {
+        std::mem::take(&mut self.values)
     }
 
     /// Returns currently stored null bitmap data.
     /// The side effect is similar to `consume_def_levels`.
     pub fn consume_bitmap_buffer(&mut self) -> Option<Buffer> {
-        self.consume_bitmap().map(|b| b.into_buffer())
+        self.consume_bitmap()
     }
 
     /// Reset state of record reader.
     /// Should be called after consuming data, e.g. `consume_rep_levels`,
     /// `consume_rep_levels`, `consume_record_data` and `consume_bitmap_buffer`.
     pub fn reset(&mut self) {
-        self.values_written -= self.num_values;
-        self.num_records = 0;
         self.num_values = 0;
+        self.num_records = 0;
     }
 
     /// Returns bitmap data.
-    pub fn consume_bitmap(&mut self) -> Option<Bitmap> {
+    pub fn consume_bitmap(&mut self) -> Option<Buffer> {
         self.def_levels
             .as_mut()
-            .map(|levels| levels.split_bitmask(self.num_values))
+            .map(|levels| levels.consume_bitmask())
     }
 
-    /// Try to read one batch of data.
+    /// Try to read one batch of data returning the number of records read
     fn read_one_batch(&mut self, batch_size: usize) -> Result<usize> {
-        let rep_levels = self
-            .rep_levels
-            .as_mut()
-            .map(|levels| levels.spare_capacity_mut(batch_size));
-
-        let def_levels = self.def_levels.as_mut();
-
-        let values = self.records.spare_capacity_mut(batch_size);
-
-        let (values_read, levels_read) = self
-            .column_reader
-            .as_mut()
-            .unwrap()
-            .read_batch(batch_size, def_levels, rep_levels, values)?;
+        let (records_read, values_read, levels_read) =
+            self.column_reader.as_mut().unwrap().read_records(
+                batch_size,
+                self.def_levels.as_mut(),
+                self.rep_levels.as_mut(),
+                &mut self.values,
+            )?;
 
         if values_read < levels_read {
             let def_levels = self.def_levels.as_ref().ok_or_else(|| {
-                general_err!(
-                    "Definition levels should exist when data is less than levels!"
-                )
+                general_err!("Definition levels should exist when data is less than levels!")
             })?;
 
-            self.records.pad_nulls(
-                self.values_written,
+            self.values.pad_nulls(
+                self.num_values,
                 values_read,
                 levels_read,
                 def_levels.nulls().as_slice(),
             );
         }
 
-        let values_read = max(levels_read, values_read);
-        self.set_values_written(self.values_written + values_read);
-        Ok(values_read)
-    }
-
-    /// Inspects the buffered repetition levels in the range `self.num_values..self.values_written`
-    /// and returns the number of "complete" records along with the corresponding number of values
-    ///
-    /// If `end_of_column` is true it indicates that there are no further values for this
-    /// column chunk beyond what is currently in the buffers
-    ///
-    /// A "complete" record is one where the buffer contains a subsequent repetition level of 0
-    fn count_records(
-        &self,
-        records_to_read: usize,
-        end_of_column: bool,
-    ) -> (usize, usize) {
-        match self.rep_levels.as_ref() {
-            Some(buf) => {
-                let buf = buf.as_slice();
-
-                let mut records_read = 0;
-                let mut end_of_last_record = self.num_values;
-
-                for (current, item) in buf
-                    .iter()
-                    .enumerate()
-                    .take(self.values_written)
-                    .skip(self.num_values)
-                {
-                    if *item == 0 && current != self.num_values {
-                        records_read += 1;
-                        end_of_last_record = current;
-
-                        if records_read == records_to_read {
-                            break;
-                        }
-                    }
-                }
-
-                // If reached end of column chunk => end of a record
-                if records_read != records_to_read
-                    && end_of_column
-                    && self.values_written != self.num_values
-                {
-                    records_read += 1;
-                    end_of_last_record = self.values_written;
-                }
-
-                (records_read, end_of_last_record - self.num_values)
-            }
-            None => {
-                let records_read =
-                    min(records_to_read, self.values_written - self.num_values);
-
-                (records_read, records_read)
-            }
-        }
-    }
-
-    fn set_values_written(&mut self, new_values_written: usize) {
-        self.values_written = new_values_written;
-        self.records.set_len(self.values_written);
-
-        if let Some(ref mut buf) = self.rep_levels {
-            buf.set_len(self.values_written)
-        };
-
-        if let Some(ref mut buf) = self.def_levels {
-            buf.set_len(self.values_written)
-        };
+        self.num_records += records_read;
+        self.num_values += levels_read;
+        Ok(records_read)
     }
 }
 
 /// Returns true if we do not need to unpack the nullability for this column, this is
-/// only possible if the max defiition level is 1, and corresponds to nulls at the
+/// only possible if the max definition level is 1, and corresponds to nulls at the
 /// leaf level, as opposed to a nullable parent nested type
 fn packed_null_mask(descr: &ColumnDescPtr) -> bool {
-    descr.max_def_level() == 1
-        && descr.max_rep_level() == 0
-        && descr.self_type().is_optional()
+    descr.max_def_level() == 1 && descr.max_rep_level() == 0 && descr.self_type().is_optional()
 }
 
 #[cfg(test)]
 mod tests {
     use std::sync::Arc;
 
-    use arrow::array::{Int16BufferBuilder, Int32BufferBuilder};
-    use arrow::bitmap::Bitmap;
     use arrow::buffer::Buffer;
 
     use crate::basic::Encoding;
@@ -472,10 +310,7 @@ mod tests {
             assert_eq!(7, record_reader.num_values());
         }
 
-        let mut bb = Int32BufferBuilder::new(7);
-        bb.append_slice(&[4, 7, 6, 3, 2, 8, 9]);
-        let expected_buffer = bb.finish();
-        assert_eq!(expected_buffer, record_reader.consume_record_data());
+        assert_eq!(record_reader.consume_record_data(), &[4, 7, 6, 3, 2, 8, 9]);
         assert_eq!(None, record_reader.consume_def_levels());
         assert_eq!(None, record_reader.consume_bitmap());
     }
@@ -557,29 +392,24 @@ mod tests {
         }
 
         // Verify result def levels
-        let mut bb = Int16BufferBuilder::new(7);
-        bb.append_slice(&[1i16, 2i16, 0i16, 2i16, 2i16, 0i16, 2i16]);
-        let expected_def_levels = bb.finish();
         assert_eq!(
-            Some(expected_def_levels),
+            Some(vec![1i16, 2i16, 0i16, 2i16, 2i16, 0i16, 2i16]),
             record_reader.consume_def_levels()
         );
 
         // Verify bitmap
         let expected_valid = &[false, true, false, true, true, false, true];
         let expected_buffer = Buffer::from_iter(expected_valid.iter().cloned());
-        let expected_bitmap = Bitmap::from(expected_buffer);
-        assert_eq!(Some(expected_bitmap), record_reader.consume_bitmap());
+        assert_eq!(Some(expected_buffer), record_reader.consume_bitmap());
 
         // Verify result record data
         let actual = record_reader.consume_record_data();
-        let actual_values = actual.typed_data::<i32>();
 
         let expected = &[0, 7, 0, 6, 3, 0, 8];
-        assert_eq!(actual_values.len(), expected.len());
+        assert_eq!(actual.len(), expected.len());
 
         // Only validate valid values are equal
-        let iter = expected_valid.iter().zip(actual_values).zip(expected);
+        let iter = expected_valid.iter().zip(&actual).zip(expected);
         for ((valid, actual), expected) in iter {
             if *valid {
                 assert_eq!(actual, expected)
@@ -668,28 +498,23 @@ mod tests {
         }
 
         // Verify result def levels
-        let mut bb = Int16BufferBuilder::new(9);
-        bb.append_slice(&[2i16, 0i16, 1i16, 2i16, 2i16, 2i16, 2i16, 2i16, 2i16]);
-        let expected_def_levels = bb.finish();
         assert_eq!(
-            Some(expected_def_levels),
+            Some(vec![2i16, 0i16, 1i16, 2i16, 2i16, 2i16, 2i16, 2i16, 2i16]),
             record_reader.consume_def_levels()
         );
 
         // Verify bitmap
         let expected_valid = &[true, false, false, true, true, true, true, true, true];
         let expected_buffer = Buffer::from_iter(expected_valid.iter().cloned());
-        let expected_bitmap = Bitmap::from(expected_buffer);
-        assert_eq!(Some(expected_bitmap), record_reader.consume_bitmap());
+        assert_eq!(Some(expected_buffer), record_reader.consume_bitmap());
 
         // Verify result record data
         let actual = record_reader.consume_record_data();
-        let actual_values = actual.typed_data::<i32>();
         let expected = &[4, 0, 0, 7, 6, 3, 2, 8, 9];
-        assert_eq!(actual_values.len(), expected.len());
+        assert_eq!(actual.len(), expected.len());
 
         // Only validate valid values are equal
-        let iter = expected_valid.iter().zip(actual_values).zip(expected);
+        let iter = expected_valid.iter().zip(&actual).zip(expected);
         for ((valid, actual), expected) in iter {
             if *valid {
                 assert_eq!(actual, expected)
@@ -853,10 +678,7 @@ mod tests {
             assert_eq!(0, record_reader.read_records(10).unwrap());
         }
 
-        let mut bb = Int32BufferBuilder::new(3);
-        bb.append_slice(&[6, 3, 2]);
-        let expected_buffer = bb.finish();
-        assert_eq!(expected_buffer, record_reader.consume_record_data());
+        assert_eq!(record_reader.consume_record_data(), &[6, 3, 2]);
         assert_eq!(None, record_reader.consume_def_levels());
         assert_eq!(None, record_reader.consume_bitmap());
     }
@@ -939,29 +761,24 @@ mod tests {
         }
 
         // Verify result def levels
-        let mut bb = Int16BufferBuilder::new(7);
-        bb.append_slice(&[0i16, 2i16, 2i16]);
-        let expected_def_levels = bb.finish();
         assert_eq!(
-            Some(expected_def_levels),
+            Some(vec![0i16, 2i16, 2i16]),
             record_reader.consume_def_levels()
         );
 
         // Verify bitmap
         let expected_valid = &[false, true, true];
         let expected_buffer = Buffer::from_iter(expected_valid.iter().cloned());
-        let expected_bitmap = Bitmap::from(expected_buffer);
-        assert_eq!(Some(expected_bitmap), record_reader.consume_bitmap());
+        assert_eq!(Some(expected_buffer), record_reader.consume_bitmap());
 
         // Verify result record data
         let actual = record_reader.consume_record_data();
-        let actual_values = actual.typed_data::<i32>();
 
         let expected = &[0, 6, 3];
-        assert_eq!(actual_values.len(), expected.len());
+        assert_eq!(actual.len(), expected.len());
 
         // Only validate valid values are equal
-        let iter = expected_valid.iter().zip(actual_values).zip(expected);
+        let iter = expected_valid.iter().zip(&actual).zip(expected);
         for ((valid, actual), expected) in iter {
             if *valid {
                 assert_eq!(actual, expected)
diff --git a/parquet/src/arrow/schema/complex.rs b/parquet/src/arrow/schema/complex.rs
index d63ab5606b03..9f85b2c284c6 100644
--- a/parquet/src/arrow/schema/complex.rs
+++ b/parquet/src/arrow/schema/complex.rs
@@ -15,13 +15,16 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use std::collections::HashMap;
+use std::sync::Arc;
+
 use crate::arrow::schema::primitive::convert_primitive;
-use crate::arrow::ProjectionMask;
+use crate::arrow::{ProjectionMask, PARQUET_FIELD_ID_META_KEY};
 use crate::basic::{ConvertedType, Repetition};
 use crate::errors::ParquetError;
 use crate::errors::Result;
 use crate::schema::types::{SchemaDescriptor, Type, TypePtr};
-use arrow::datatypes::{DataType, Field, Schema};
+use arrow_schema::{DataType, Field, Fields, SchemaBuilder};
 
 fn get_repetition(t: &Type) -> Repetition {
     let info = t.get_basic_info();
@@ -31,7 +34,8 @@ fn get_repetition(t: &Type) -> Repetition {
     }
 }
 
-/// Representation of a parquet file, in terms of arrow schema elements
+/// Representation of a parquet schema element, in terms of arrow schema elements
+#[derive(Debug, Clone)]
 pub struct ParquetField {
     /// The level which represents an insertion into the current list
     /// i.e. guaranteed to be > 0 for a list type
@@ -59,7 +63,7 @@ impl ParquetField {
             rep_level: self.rep_level,
             def_level: self.def_level,
             nullable: false,
-            arrow_type: DataType::List(Box::new(Field::new(
+            arrow_type: DataType::List(Arc::new(Field::new(
                 name,
                 self.arrow_type.clone(),
                 false,
@@ -79,6 +83,7 @@ impl ParquetField {
     }
 }
 
+#[derive(Debug, Clone)]
 pub enum ParquetFieldType {
     Primitive {
         /// The index of the column in parquet
@@ -191,7 +196,7 @@ impl Visitor {
             None => None,
         };
 
-        let mut child_fields = Vec::with_capacity(parquet_fields.len());
+        let mut child_fields = SchemaBuilder::with_capacity(parquet_fields.len());
         let mut children = Vec::with_capacity(parquet_fields.len());
 
         // Perform a DFS of children
@@ -211,7 +216,7 @@ impl Visitor {
                 None => None,
             };
 
-            let arrow_field = arrow_fields.map(|x| &x[idx]);
+            let arrow_field = arrow_fields.map(|x| &*x[idx]);
             let child_ctx = VisitorContext {
                 rep_level,
                 def_level,
@@ -234,7 +239,7 @@ impl Visitor {
             rep_level,
             def_level,
             nullable,
-            arrow_type: DataType::Struct(child_fields),
+            arrow_type: DataType::Struct(child_fields.finish().fields),
             field_type: ParquetFieldType::Group { children },
         };
 
@@ -300,7 +305,7 @@ impl Visitor {
                         ));
                     }
 
-                    (Some(field), Some(&fields[0]), Some(&fields[1]), *sorted)
+                    (Some(field), Some(&*fields[0]), Some(&*fields[1]), *sorted)
                 }
                 d => {
                     return Err(arrow_err!(
@@ -341,21 +346,25 @@ impl Visitor {
         // Need both columns to be projected
         match (maybe_key, maybe_value) {
             (Some(key), Some(value)) => {
-                let key_field = convert_field(map_key, &key, arrow_key);
-                let value_field = convert_field(map_value, &value, arrow_value);
+                let key_field = Arc::new(convert_field(map_key, &key, arrow_key));
+                let value_field = Arc::new(convert_field(map_value, &value, arrow_value));
+                let field_metadata = match arrow_map {
+                    Some(field) => field.metadata().clone(),
+                    _ => HashMap::default(),
+                };
 
-                let map_field = Field::new(
+                let map_field = Field::new_struct(
                     map_key_value.name(),
-                    DataType::Struct(vec![key_field, value_field]),
+                    [key_field, value_field],
                     false, // The inner map field is always non-nullable (#1697)
                 )
-                .with_metadata(arrow_map.and_then(|f| f.metadata().cloned()));
+                .with_metadata(field_metadata);
 
                 Ok(Some(ParquetField {
                     rep_level,
                     def_level,
                     nullable,
-                    arrow_type: DataType::Map(Box::new(map_field), sorted),
+                    arrow_type: DataType::Map(Arc::new(map_field), sorted),
                     field_type: ParquetFieldType::Group {
                         children: vec![key, value],
                     },
@@ -472,7 +481,7 @@ impl Visitor {
 
         match self.dispatch(item_type, new_context) {
             Ok(Some(item)) => {
-                let item_field = Box::new(convert_field(item_type, &item, arrow_field));
+                let item_field = Arc::new(convert_field(item_type, &item, arrow_field));
 
                 // Use arrow type as hint for index size
                 let arrow_type = match context.data_type {
@@ -539,21 +548,30 @@ fn convert_field(
                 _ => Field::new(name, data_type, nullable),
             };
 
-            field.with_metadata(hint.metadata().cloned())
+            field.with_metadata(hint.metadata().clone())
         }
-        None => Field::new(name, data_type, nullable),
+        None => {
+            let mut ret = Field::new(name, data_type, nullable);
+            let basic_info = parquet_type.get_basic_info();
+            if basic_info.has_id() {
+                let mut meta = HashMap::with_capacity(1);
+                meta.insert(PARQUET_FIELD_ID_META_KEY.to_string(), basic_info.id().to_string());
+                ret.set_metadata(meta);
+            }
+            ret
+        },
     }
 }
 
 /// Computes the [`ParquetField`] for the provided [`SchemaDescriptor`] with `leaf_columns` listing
 /// the indexes of leaf columns to project, and `embedded_arrow_schema` the optional
-/// [`Schema`] embedded in the parquet metadata
+/// [`Fields`] embedded in the parquet metadata
 ///
 /// Note: This does not support out of order column projection
 pub fn convert_schema(
     schema: &SchemaDescriptor,
     mask: ProjectionMask,
-    embedded_arrow_schema: Option<&Schema>,
+    embedded_arrow_schema: Option<&Fields>,
 ) -> Result<Option<ParquetField>> {
     let mut visitor = Visitor {
         next_col_idx: 0,
@@ -563,7 +581,7 @@ pub fn convert_schema(
     let context = VisitorContext {
         rep_level: 0,
         def_level: 0,
-        data_type: embedded_arrow_schema.map(|s| DataType::Struct(s.fields().clone())),
+        data_type: embedded_arrow_schema.map(|fields| DataType::Struct(fields.clone())),
     };
 
     visitor.dispatch(&schema.root_schema_ptr(), context)
diff --git a/parquet/src/arrow/schema.rs b/parquet/src/arrow/schema/mod.rs
similarity index 70%
rename from parquet/src/arrow/schema.rs
rename to parquet/src/arrow/schema/mod.rs
index 01aefcd48e1d..4c350c4b1d8c 100644
--- a/parquet/src/arrow/schema.rs
+++ b/parquet/src/arrow/schema/mod.rs
@@ -23,11 +23,13 @@
 //!
 //! The interfaces for converting arrow schema to parquet schema is coming.
 
+use base64::prelude::BASE64_STANDARD;
+use base64::Engine;
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use arrow::datatypes::{DataType, Field, Schema, TimeUnit};
-use arrow::ipc::writer;
+use arrow_ipc::writer;
+use arrow_schema::{DataType, Field, Fields, Schema, TimeUnit};
 
 use crate::basic::{
     ConvertedType, LogicalType, Repetition, TimeUnit as ParquetTimeUnit,
@@ -35,15 +37,18 @@ use crate::basic::{
 };
 use crate::errors::{ParquetError, Result};
 use crate::file::{metadata::KeyValue, properties::WriterProperties};
-use crate::schema::types::{ColumnDescriptor, SchemaDescriptor, Type, TypePtr};
+use crate::schema::types::{ColumnDescriptor, SchemaDescriptor, Type};
 
 mod complex;
 mod primitive;
 
 use crate::arrow::ProjectionMask;
-pub(crate) use complex::{convert_schema, ParquetField, ParquetFieldType};
+pub(crate) use complex::{ParquetField, ParquetFieldType};
 
-/// Convert Parquet schema to Arrow schema including optional metadata.
+use super::PARQUET_FIELD_ID_META_KEY;
+
+/// Convert Parquet schema to Arrow schema including optional metadata
+///
 /// Attempts to decode any existing Arrow schema metadata, falling back
 /// to converting the Parquet schema column-wise
 pub fn parquet_to_arrow_schema(
@@ -64,6 +69,15 @@ pub fn parquet_to_arrow_schema_by_columns(
     mask: ProjectionMask,
     key_value_metadata: Option<&Vec<KeyValue>>,
 ) -> Result<Schema> {
+    Ok(parquet_to_arrow_schema_and_fields(parquet_schema, mask, key_value_metadata)?.0)
+}
+
+/// Extracts the arrow metadata
+pub(crate) fn parquet_to_arrow_schema_and_fields(
+    parquet_schema: &SchemaDescriptor,
+    mask: ProjectionMask,
+    key_value_metadata: Option<&Vec<KeyValue>>,
+) -> Result<(Schema, Option<ParquetField>)> {
     let mut metadata = parse_key_value_metadata(key_value_metadata).unwrap_or_default();
     let maybe_schema = metadata
         .remove(super::ARROW_SCHEMA_META_KEY)
@@ -77,29 +91,73 @@ pub fn parquet_to_arrow_schema_by_columns(
         });
     }
 
-    match convert_schema(parquet_schema, mask, maybe_schema.as_ref())? {
-        Some(field) => match field.arrow_type {
-            DataType::Struct(fields) => Ok(Schema::new_with_metadata(fields, metadata)),
+    let hint = maybe_schema.as_ref().map(|s| s.fields());
+    let field_levels = parquet_to_arrow_field_levels(parquet_schema, mask, hint)?;
+    let schema = Schema::new_with_metadata(field_levels.fields, metadata);
+    Ok((schema, field_levels.levels))
+}
+
+/// Schema information necessary to decode a parquet file as arrow [`Fields`]
+///
+/// In particular this stores the dremel-level information necessary to correctly
+/// interpret the encoded definition and repetition levels
+///
+/// Note: this is an opaque container intended to be used with lower-level APIs
+/// within this crate
+#[derive(Debug, Clone)]
+pub struct FieldLevels {
+    pub(crate) fields: Fields,
+    pub(crate) levels: Option<ParquetField>,
+}
+
+/// Convert a parquet [`SchemaDescriptor`] to [`FieldLevels`]
+///
+/// Columns not included within [`ProjectionMask`] will be ignored.
+///
+/// Where a field type in `hint` is compatible with the corresponding parquet type in `schema`, it
+/// will be used, otherwise the default arrow type for the given parquet column type will be used.
+///
+/// This is to accommodate arrow types that cannot be round-tripped through parquet natively.
+/// Depending on the parquet writer, this can lead to a mismatch between a file's parquet schema
+/// and its embedded arrow schema. The parquet `schema` must be treated as authoritative in such
+/// an event. See [#1663](https://github.com/apache/arrow-rs/issues/1663) for more information
+///
+/// Note: this is a low-level API, most users will want to make use of the higher-level
+/// [`parquet_to_arrow_schema`] for decoding metadata from a parquet file.
+pub fn parquet_to_arrow_field_levels(
+    schema: &SchemaDescriptor,
+    mask: ProjectionMask,
+    hint: Option<&Fields>,
+) -> Result<FieldLevels> {
+    match complex::convert_schema(schema, mask, hint)? {
+        Some(field) => match &field.arrow_type {
+            DataType::Struct(fields) => Ok(FieldLevels {
+                fields: fields.clone(),
+                levels: Some(field),
+            }),
             _ => unreachable!(),
         },
-        None => Ok(Schema::new_with_metadata(vec![], metadata)),
+        None => Ok(FieldLevels {
+            fields: Fields::empty(),
+            levels: None,
+        }),
     }
 }
 
 /// Try to convert Arrow schema metadata into a schema
 fn get_arrow_schema_from_metadata(encoded_meta: &str) -> Result<Schema> {
-    let decoded = base64::decode(encoded_meta);
+    let decoded = BASE64_STANDARD.decode(encoded_meta);
     match decoded {
         Ok(bytes) => {
-            let slice = if bytes[0..4] == [255u8; 4] {
+            let slice = if bytes.len() > 8 && bytes[0..4] == [255u8; 4] {
                 &bytes[8..]
             } else {
                 bytes.as_slice()
             };
-            match arrow::ipc::root_as_message(slice) {
+            match arrow_ipc::root_as_message(slice) {
                 Ok(message) => message
                     .header_as_schema()
-                    .map(arrow::ipc::convert::fb_to_schema)
+                    .map(arrow_ipc::convert::fb_to_schema)
                     .ok_or_else(|| arrow_err!("the message is not Arrow Schema")),
                 Err(err) => {
                     // The flatbuffers implementation returns an error on verification error.
@@ -125,7 +183,7 @@ fn get_arrow_schema_from_metadata(encoded_meta: &str) -> Result<Schema> {
 /// Encodes the Arrow schema into the IPC format, and base64 encodes it
 fn encode_arrow_schema(schema: &Schema) -> String {
     let options = writer::IpcWriteOptions::default();
-    let data_gen = arrow::ipc::writer::IpcDataGenerator::default();
+    let data_gen = writer::IpcDataGenerator::default();
     let mut serialized_schema = data_gen.schema_to_bytes(schema, &options);
 
     // manually prepending the length to the schema as arrow uses the legacy IPC format
@@ -136,7 +194,7 @@ fn encode_arrow_schema(schema: &Schema) -> String {
     len_prefix_schema.append((schema_len as u32).to_le_bytes().to_vec().as_mut());
     len_prefix_schema.append(&mut serialized_schema.ipc_message);
 
-    base64::encode(&len_prefix_schema)
+    BASE64_STANDARD.encode(&len_prefix_schema)
 }
 
 /// Mutates writer metadata by storing the encoded Arrow schema.
@@ -174,13 +232,13 @@ pub(crate) fn add_encoded_arrow_schema_to_metadata(
 
 /// Convert arrow schema to parquet schema
 pub fn arrow_to_parquet_schema(schema: &Schema) -> Result<SchemaDescriptor> {
-    let fields: Result<Vec<TypePtr>> = schema
+    let fields = schema
         .fields()
         .iter()
         .map(|field| arrow_to_parquet_type(field).map(Arc::new))
-        .collect();
+        .collect::<Result<_>>()?;
     let group = Type::group_type_builder("arrow_schema")
-        .with_fields(&mut fields?)
+        .with_fields(fields)
         .build()?;
     Ok(SchemaDescriptor::new(Arc::new(group)))
 }
@@ -212,16 +270,31 @@ fn parse_key_value_metadata(
 /// Convert parquet column schema to arrow field.
 pub fn parquet_to_arrow_field(parquet_column: &ColumnDescriptor) -> Result<Field> {
     let field = complex::convert_type(&parquet_column.self_type_ptr())?;
-
-    Ok(Field::new(
+    let mut ret = Field::new(
         parquet_column.name(),
         field.arrow_type,
         field.nullable,
-    ))
+    );
+
+    let basic_info = parquet_column.self_type().get_basic_info();
+    if basic_info.has_id() {
+        let mut meta = HashMap::with_capacity(1);
+        meta.insert(PARQUET_FIELD_ID_META_KEY.to_string(), basic_info.id().to_string());
+        ret.set_metadata(meta);
+    }
+
+    Ok(ret)
 }
 
-pub fn decimal_length_from_precision(precision: usize) -> usize {
-    (10.0_f64.powi(precision as i32).log2() / 8.0).ceil() as usize
+pub fn decimal_length_from_precision(precision: u8) -> usize {
+    // digits = floor(log_10(2^(8*n - 1) - 1))  // definition in parquet's logical types
+    // ceil(digits) = log10(2^(8*n - 1) - 1)
+    // 10^ceil(digits) = 2^(8*n - 1) - 1
+    // 10^ceil(digits) + 1 = 2^(8*n - 1)
+    // log2(10^ceil(digits) + 1) = (8*n - 1)
+    // log2(10^ceil(digits) + 1) + 1 = 8*n
+    // (log2(10^ceil(a) + 1) + 1) / 8 = n
+    (((10.0_f64.powi(precision as i32) + 1.0).log2() + 1.0) / 8.0).ceil() as usize
 }
 
 /// Convert an arrow field to a parquet `Type`
@@ -232,14 +305,17 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
     } else {
         Repetition::REQUIRED
     };
+    let id = field_id(field);
     // create type from field
     match field.data_type() {
         DataType::Null => Type::primitive_type_builder(name, PhysicalType::INT32)
             .with_logical_type(Some(LogicalType::Unknown))
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::Boolean => Type::primitive_type_builder(name, PhysicalType::BOOLEAN)
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::Int8 => Type::primitive_type_builder(name, PhysicalType::INT32)
             .with_logical_type(Some(LogicalType::Integer {
@@ -247,6 +323,7 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                 is_signed: true,
             }))
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::Int16 => Type::primitive_type_builder(name, PhysicalType::INT32)
             .with_logical_type(Some(LogicalType::Integer {
@@ -254,12 +331,15 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                 is_signed: true,
             }))
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::Int32 => Type::primitive_type_builder(name, PhysicalType::INT32)
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::Int64 => Type::primitive_type_builder(name, PhysicalType::INT64)
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::UInt8 => Type::primitive_type_builder(name, PhysicalType::INT32)
             .with_logical_type(Some(LogicalType::Integer {
@@ -267,6 +347,7 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                 is_signed: false,
             }))
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::UInt16 => Type::primitive_type_builder(name, PhysicalType::INT32)
             .with_logical_type(Some(LogicalType::Integer {
@@ -274,6 +355,7 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                 is_signed: false,
             }))
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::UInt32 => Type::primitive_type_builder(name, PhysicalType::INT32)
             .with_logical_type(Some(LogicalType::Integer {
@@ -281,6 +363,7 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                 is_signed: false,
             }))
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::UInt64 => Type::primitive_type_builder(name, PhysicalType::INT64)
             .with_logical_type(Some(LogicalType::Integer {
@@ -288,25 +371,34 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                 is_signed: false,
             }))
             .with_repetition(repetition)
+            .with_id(id)
+            .build(),
+        DataType::Float16 => Type::primitive_type_builder(name, PhysicalType::FIXED_LEN_BYTE_ARRAY)
+            .with_repetition(repetition)
+            .with_id(id)
+            .with_logical_type(Some(LogicalType::Float16))
+            .with_length(2)
             .build(),
-        DataType::Float16 => Err(arrow_err!("Float16 arrays not supported")),
         DataType::Float32 => Type::primitive_type_builder(name, PhysicalType::FLOAT)
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::Float64 => Type::primitive_type_builder(name, PhysicalType::DOUBLE)
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::Timestamp(TimeUnit::Second, _) => {
             // Cannot represent seconds in LogicalType
             Type::primitive_type_builder(name, PhysicalType::INT64)
                 .with_repetition(repetition)
+                .with_id(id)
                 .build()
         }
         DataType::Timestamp(time_unit, tz) => {
             Type::primitive_type_builder(name, PhysicalType::INT64)
                 .with_logical_type(Some(LogicalType::Timestamp {
                     // If timezone set, values are normalized to UTC timezone
-                    is_adjusted_to_u_t_c: matches!(tz, Some(z) if !z.as_str().is_empty()),
+                    is_adjusted_to_u_t_c: matches!(tz, Some(z) if !z.as_ref().is_empty()),
                     unit: match time_unit {
                         TimeUnit::Second => unreachable!(),
                         TimeUnit::Millisecond => {
@@ -321,21 +413,25 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                     },
                 }))
                 .with_repetition(repetition)
+                .with_id(id)
                 .build()
         }
         DataType::Date32 => Type::primitive_type_builder(name, PhysicalType::INT32)
             .with_logical_type(Some(LogicalType::Date))
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         // date64 is cast to date32 (#1666)
         DataType::Date64 => Type::primitive_type_builder(name, PhysicalType::INT32)
             .with_logical_type(Some(LogicalType::Date))
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::Time32(TimeUnit::Second) => {
             // Cannot represent seconds in LogicalType
             Type::primitive_type_builder(name, PhysicalType::INT32)
                 .with_repetition(repetition)
+                .with_id(id)
                 .build()
         }
         DataType::Time32(unit) => Type::primitive_type_builder(name, PhysicalType::INT32)
@@ -347,6 +443,7 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                 },
             }))
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::Time64(unit) => Type::primitive_type_builder(name, PhysicalType::INT64)
             .with_logical_type(Some(LogicalType::Time {
@@ -358,6 +455,7 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                 },
             }))
             .with_repetition(repetition)
+            .with_id(id)
             .build(),
         DataType::Duration(_) => {
             Err(arrow_err!("Converting Duration to parquet not supported",))
@@ -366,38 +464,41 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
             Type::primitive_type_builder(name, PhysicalType::FIXED_LEN_BYTE_ARRAY)
                 .with_converted_type(ConvertedType::INTERVAL)
                 .with_repetition(repetition)
+                .with_id(id)
                 .with_length(12)
                 .build()
         }
         DataType::Binary | DataType::LargeBinary => {
             Type::primitive_type_builder(name, PhysicalType::BYTE_ARRAY)
                 .with_repetition(repetition)
+                .with_id(id)
                 .build()
         }
         DataType::FixedSizeBinary(length) => {
             Type::primitive_type_builder(name, PhysicalType::FIXED_LEN_BYTE_ARRAY)
                 .with_repetition(repetition)
+                .with_id(id)
                 .with_length(*length)
                 .build()
         }
         DataType::Decimal128(precision, scale)
         | DataType::Decimal256(precision, scale) => {
             // Decimal precision determines the Parquet physical type to use.
-            // TODO(ARROW-12018): Enable the below after ARROW-10818 Decimal support
-            //
-            // let (physical_type, length) = if *precision > 1 && *precision <= 9 {
-            //     (PhysicalType::INT32, -1)
-            // } else if *precision <= 18 {
-            //     (PhysicalType::INT64, -1)
-            // } else {
-            //     (
-            //         PhysicalType::FIXED_LEN_BYTE_ARRAY,
-            //         decimal_length_from_precision(*precision) as i32,
-            //     )
-            // };
-            Type::primitive_type_builder(name, PhysicalType::FIXED_LEN_BYTE_ARRAY)
+            // Following the: https://github.com/apache/parquet-format/blob/master/LogicalTypes.md#decimal
+            let (physical_type, length) = if *precision > 1 && *precision <= 9 {
+                (PhysicalType::INT32, -1)
+            } else if *precision <= 18 {
+                (PhysicalType::INT64, -1)
+            } else {
+                (
+                    PhysicalType::FIXED_LEN_BYTE_ARRAY,
+                    decimal_length_from_precision(*precision) as i32,
+                )
+            };
+            Type::primitive_type_builder(name, physical_type)
                 .with_repetition(repetition)
-                .with_length(decimal_length_from_precision(*precision) as i32)
+                .with_id(id)
+                .with_length(length)
                 .with_logical_type(Some(LogicalType::Decimal {
                     scale: *scale as i32,
                     precision: *precision as i32,
@@ -410,18 +511,20 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
             Type::primitive_type_builder(name, PhysicalType::BYTE_ARRAY)
                 .with_logical_type(Some(LogicalType::String))
                 .with_repetition(repetition)
+                .with_id(id)
                 .build()
         }
         DataType::List(f) | DataType::FixedSizeList(f, _) | DataType::LargeList(f) => {
             Type::group_type_builder(name)
-                .with_fields(&mut vec![Arc::new(
+                .with_fields(vec![Arc::new(
                     Type::group_type_builder("list")
-                        .with_fields(&mut vec![Arc::new(arrow_to_parquet_type(f)?)])
+                        .with_fields(vec![Arc::new(arrow_to_parquet_type(f)?)])
                         .with_repetition(Repetition::REPEATED)
                         .build()?,
                 )])
                 .with_logical_type(Some(LogicalType::List))
                 .with_repetition(repetition)
+                .with_id(id)
                 .build()
         }
         DataType::Struct(fields) => {
@@ -431,37 +534,31 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                 );
             }
             // recursively convert children to types/nodes
-            let fields: Result<Vec<TypePtr>> = fields
+            let fields = fields
                 .iter()
                 .map(|f| arrow_to_parquet_type(f).map(Arc::new))
-                .collect();
+                .collect::<Result<_>>()?;
             Type::group_type_builder(name)
-                .with_fields(&mut fields?)
+                .with_fields(fields)
                 .with_repetition(repetition)
+                .with_id(id)
                 .build()
         }
         DataType::Map(field, _) => {
             if let DataType::Struct(struct_fields) = field.data_type() {
                 Type::group_type_builder(name)
-                    .with_fields(&mut vec![Arc::new(
+                    .with_fields(vec![Arc::new(
                         Type::group_type_builder(field.name())
-                            .with_fields(&mut vec![
-                                Arc::new(arrow_to_parquet_type(&Field::new(
-                                    struct_fields[0].name(),
-                                    struct_fields[0].data_type().clone(),
-                                    false,
-                                ))?),
-                                Arc::new(arrow_to_parquet_type(&Field::new(
-                                    struct_fields[1].name(),
-                                    struct_fields[1].data_type().clone(),
-                                    struct_fields[1].is_nullable(),
-                                ))?),
+                            .with_fields(vec![
+                                Arc::new(arrow_to_parquet_type(&struct_fields[0])?),
+                                Arc::new(arrow_to_parquet_type(&struct_fields[1])?),
                             ])
                             .with_repetition(Repetition::REPEATED)
                             .build()?,
                     )])
                     .with_logical_type(Some(LogicalType::Map))
                     .with_repetition(repetition)
+                    .with_id(id)
                     .build()
             } else {
                 Err(arrow_err!(
@@ -469,15 +566,23 @@ fn arrow_to_parquet_type(field: &Field) -> Result<Type> {
                 ))
             }
         }
-        DataType::Union(_, _, _) => unimplemented!("See ARROW-8817."),
+        DataType::Union(_, _) => unimplemented!("See ARROW-8817."),
         DataType::Dictionary(_, ref value) => {
             // Dictionary encoding not handled at the schema level
-            let dict_field = Field::new(name, *value.clone(), field.is_nullable());
+            let dict_field = field.clone().with_data_type(value.as_ref().clone());
             arrow_to_parquet_type(&dict_field)
         }
+        DataType::RunEndEncoded(_, _) => Err(arrow_err!(
+            "Converting RunEndEncodedType to parquet not supported",
+        )),
     }
 }
 
+fn field_id(field: &Field) -> Option<i32> {
+    let value = field.metadata().get(super::PARQUET_FIELD_ID_META_KEY)?;
+    value.parse().ok() // Fail quietly if not a valid integer
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -486,9 +591,11 @@ mod tests {
 
     use arrow::datatypes::{DataType, Field, IntervalUnit, TimeUnit};
 
+    use crate::arrow::PARQUET_FIELD_ID_META_KEY;
     use crate::file::metadata::KeyValue;
+    use crate::file::reader::FileReader;
     use crate::{
-        arrow::{ArrowReader, ArrowWriter, ParquetFileArrowReader},
+        arrow::{arrow_reader::ParquetRecordBatchReaderBuilder, ArrowWriter},
         schema::{parser::parse_message_type, types::SchemaDescriptor},
     };
 
@@ -502,11 +609,13 @@ mod tests {
             REQUIRED INT32   uint8 (INTEGER(8,false));
             REQUIRED INT32   uint16 (INTEGER(16,false));
             REQUIRED INT32   int32;
-            REQUIRED INT64   int64 ;
+            REQUIRED INT64   int64;
             OPTIONAL DOUBLE  double;
             OPTIONAL FLOAT   float;
+            OPTIONAL FIXED_LEN_BYTE_ARRAY (2) float16 (FLOAT16);
             OPTIONAL BINARY  string (UTF8);
             OPTIONAL BINARY  string_2 (STRING);
+            OPTIONAL BINARY  json (JSON);
         }
         ";
         let parquet_group_type = parse_message_type(message_type).unwrap();
@@ -515,7 +624,7 @@ mod tests {
         let converted_arrow_schema =
             parquet_to_arrow_schema(&parquet_schema, None).unwrap();
 
-        let arrow_fields = vec![
+        let arrow_fields = Fields::from(vec![
             Field::new("boolean", DataType::Boolean, false),
             Field::new("int8", DataType::Int8, false),
             Field::new("int16", DataType::Int16, false),
@@ -525,9 +634,11 @@ mod tests {
             Field::new("int64", DataType::Int64, false),
             Field::new("double", DataType::Float64, true),
             Field::new("float", DataType::Float32, true),
+            Field::new("float16", DataType::Float16, true),
             Field::new("string", DataType::Utf8, true),
             Field::new("string_2", DataType::Utf8, true),
-        ];
+            Field::new("json", DataType::Utf8, true),
+        ]);
 
         assert_eq!(&arrow_fields, converted_arrow_schema.fields());
     }
@@ -540,6 +651,9 @@ mod tests {
                     REQUIRED INT64 decimal2 (DECIMAL(12,2));
                     REQUIRED FIXED_LEN_BYTE_ARRAY (16) decimal3 (DECIMAL(30,2));
                     REQUIRED BYTE_ARRAY decimal4 (DECIMAL(33,2));
+                    REQUIRED BYTE_ARRAY decimal5 (DECIMAL(38,2));
+                    REQUIRED FIXED_LEN_BYTE_ARRAY (17) decimal6 (DECIMAL(39,2));
+                    REQUIRED BYTE_ARRAY decimal7 (DECIMAL(39,2));
         }
         ";
 
@@ -549,12 +663,15 @@ mod tests {
         let converted_arrow_schema =
             parquet_to_arrow_schema(&parquet_schema, None).unwrap();
 
-        let arrow_fields = vec![
+        let arrow_fields = Fields::from(vec![
             Field::new("decimal1", DataType::Decimal128(4, 2), false),
             Field::new("decimal2", DataType::Decimal128(12, 2), false),
             Field::new("decimal3", DataType::Decimal128(30, 2), false),
             Field::new("decimal4", DataType::Decimal128(33, 2), false),
-        ];
+            Field::new("decimal5", DataType::Decimal128(38, 2), false),
+            Field::new("decimal6", DataType::Decimal256(39, 2), false),
+            Field::new("decimal7", DataType::Decimal256(39, 2), false),
+        ]);
         assert_eq!(&arrow_fields, converted_arrow_schema.fields());
     }
 
@@ -573,10 +690,10 @@ mod tests {
         let converted_arrow_schema =
             parquet_to_arrow_schema(&parquet_schema, None).unwrap();
 
-        let arrow_fields = vec![
+        let arrow_fields = Fields::from(vec![
             Field::new("binary", DataType::Binary, false),
             Field::new("fixed_binary", DataType::FixedSizeBinary(20), false),
-        ];
+        ]);
         assert_eq!(&arrow_fields, converted_arrow_schema.fields());
     }
 
@@ -595,10 +712,10 @@ mod tests {
         let converted_arrow_schema =
             parquet_to_arrow_schema(&parquet_schema, None).unwrap();
 
-        let arrow_fields = vec![
+        let arrow_fields = Fields::from(vec![
             Field::new("boolean", DataType::Boolean, false),
             Field::new("int8", DataType::Int8, false),
-        ];
+        ]);
         assert_eq!(&arrow_fields, converted_arrow_schema.fields());
 
         let converted_arrow_schema = parquet_to_arrow_schema_by_columns(
@@ -672,9 +789,9 @@ mod tests {
         //   }
         // }
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_list(
                 "my_list",
-                DataType::List(Box::new(Field::new("element", DataType::Utf8, true))),
+                Field::new("element", DataType::Utf8, true),
                 false,
             ));
         }
@@ -686,9 +803,9 @@ mod tests {
         //   }
         // }
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_list(
                 "my_list",
-                DataType::List(Box::new(Field::new("element", DataType::Utf8, false))),
+                Field::new("element", DataType::Utf8, false),
                 true,
             ));
         }
@@ -706,11 +823,10 @@ mod tests {
         //   }
         // }
         {
-            let arrow_inner_list =
-                DataType::List(Box::new(Field::new("element", DataType::Int32, false)));
-            arrow_fields.push(Field::new(
+            let arrow_inner_list = Field::new("element", DataType::Int32, false);
+            arrow_fields.push(Field::new_list(
                 "array_of_arrays",
-                DataType::List(Box::new(Field::new("element", arrow_inner_list, false))),
+                Field::new_list("element", arrow_inner_list, false),
                 true,
             ));
         }
@@ -722,9 +838,9 @@ mod tests {
         //   };
         // }
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_list(
                 "my_list",
-                DataType::List(Box::new(Field::new("str", DataType::Utf8, false))),
+                Field::new("str", DataType::Utf8, false),
                 true,
             ));
         }
@@ -734,9 +850,9 @@ mod tests {
         //   repeated int32 element;
         // }
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_list(
                 "my_list",
-                DataType::List(Box::new(Field::new("element", DataType::Int32, false))),
+                Field::new("element", DataType::Int32, false),
                 true,
             ));
         }
@@ -749,13 +865,13 @@ mod tests {
         //   };
         // }
         {
-            let arrow_struct = DataType::Struct(vec![
+            let fields = vec![
                 Field::new("str", DataType::Utf8, false),
                 Field::new("num", DataType::Int32, false),
-            ]);
-            arrow_fields.push(Field::new(
+            ];
+            arrow_fields.push(Field::new_list(
                 "my_list",
-                DataType::List(Box::new(Field::new("element", arrow_struct, false))),
+                Field::new_struct("element", fields, false),
                 true,
             ));
         }
@@ -768,11 +884,10 @@ mod tests {
         // }
         // Special case: group is named array
         {
-            let arrow_struct =
-                DataType::Struct(vec![Field::new("str", DataType::Utf8, false)]);
-            arrow_fields.push(Field::new(
+            let fields = vec![Field::new("str", DataType::Utf8, false)];
+            arrow_fields.push(Field::new_list(
                 "my_list",
-                DataType::List(Box::new(Field::new("array", arrow_struct, false))),
+                Field::new_struct("array", fields, false),
                 true,
             ));
         }
@@ -785,15 +900,10 @@ mod tests {
         // }
         // Special case: group named ends in _tuple
         {
-            let arrow_struct =
-                DataType::Struct(vec![Field::new("str", DataType::Utf8, false)]);
-            arrow_fields.push(Field::new(
+            let fields = vec![Field::new("str", DataType::Utf8, false)];
+            arrow_fields.push(Field::new_list(
                 "my_list",
-                DataType::List(Box::new(Field::new(
-                    "my_list_tuple",
-                    arrow_struct,
-                    false,
-                ))),
+                Field::new_struct("my_list_tuple", fields, false),
                 true,
             ));
         }
@@ -801,9 +911,9 @@ mod tests {
         // One-level encoding: Only allows required lists with required cells
         //   repeated value_type name
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_list(
                 "name",
-                DataType::List(Box::new(Field::new("name", DataType::Int32, false))),
+                Field::new("name", DataType::Int32, false),
                 false,
             ));
         }
@@ -817,7 +927,7 @@ mod tests {
 
         assert_eq!(arrow_fields.len(), converted_fields.len());
         for i in 0..arrow_fields.len() {
-            assert_eq!(arrow_fields[i], converted_fields[i], "{}", i);
+            assert_eq!(&arrow_fields[i], converted_fields[i].as_ref(), "{i}");
         }
     }
 
@@ -852,9 +962,9 @@ mod tests {
         //   }
         // }
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_list(
                 "my_list1",
-                DataType::List(Box::new(Field::new("element", DataType::Utf8, true))),
+                Field::new("element", DataType::Utf8, true),
                 false,
             ));
         }
@@ -866,9 +976,9 @@ mod tests {
         //   }
         // }
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_list(
                 "my_list2",
-                DataType::List(Box::new(Field::new("element", DataType::Utf8, false))),
+                Field::new("element", DataType::Utf8, false),
                 true,
             ));
         }
@@ -880,9 +990,9 @@ mod tests {
         //   }
         // }
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_list(
                 "my_list3",
-                DataType::List(Box::new(Field::new("element", DataType::Utf8, false))),
+                Field::new("element", DataType::Utf8, false),
                 false,
             ));
         }
@@ -896,7 +1006,7 @@ mod tests {
 
         assert_eq!(arrow_fields.len(), converted_fields.len());
         for i in 0..arrow_fields.len() {
-            assert_eq!(arrow_fields[i], converted_fields[i]);
+            assert_eq!(&arrow_fields[i], converted_fields[i].as_ref());
         }
     }
 
@@ -936,19 +1046,12 @@ mod tests {
         //   }
         // }
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_map(
                 "my_map1",
-                DataType::Map(
-                    Box::new(Field::new(
-                        "key_value",
-                        DataType::Struct(vec![
-                            Field::new("key", DataType::Utf8, false),
-                            Field::new("value", DataType::Int32, true),
-                        ]),
-                        false,
-                    )),
-                    false,
-                ),
+                "key_value",
+                Field::new("key", DataType::Utf8, false),
+                Field::new("value", DataType::Int32, true),
+                false,
                 false,
             ));
         }
@@ -961,19 +1064,12 @@ mod tests {
         //   }
         // }
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_map(
                 "my_map2",
-                DataType::Map(
-                    Box::new(Field::new(
-                        "map",
-                        DataType::Struct(vec![
-                            Field::new("str", DataType::Utf8, false),
-                            Field::new("num", DataType::Int32, false),
-                        ]),
-                        false, // (#1697)
-                    )),
-                    false,
-                ),
+                "map",
+                Field::new("str", DataType::Utf8, false),
+                Field::new("num", DataType::Int32, false),
+                false,
                 true,
             ));
         }
@@ -986,19 +1082,12 @@ mod tests {
         //   }
         // }
         {
-            arrow_fields.push(Field::new(
+            arrow_fields.push(Field::new_map(
                 "my_map3",
-                DataType::Map(
-                    Box::new(Field::new(
-                        "map",
-                        DataType::Struct(vec![
-                            Field::new("key", DataType::Utf8, false),
-                            Field::new("value", DataType::Int32, true),
-                        ]),
-                        false, // (#1697)
-                    )),
-                    false,
-                ),
+                "map",
+                Field::new("key", DataType::Utf8, false),
+                Field::new("value", DataType::Int32, true),
+                false,
                 true,
             ));
         }
@@ -1012,7 +1101,7 @@ mod tests {
 
         assert_eq!(arrow_fields.len(), converted_fields.len());
         for i in 0..arrow_fields.len() {
-            assert_eq!(arrow_fields[i], converted_fields[i]);
+            assert_eq!(&arrow_fields[i], converted_fields[i].as_ref());
         }
     }
 
@@ -1020,10 +1109,10 @@ mod tests {
     fn test_nested_schema() {
         let mut arrow_fields = Vec::new();
         {
-            let group1_fields = vec![
+            let group1_fields = Fields::from(vec![
                 Field::new("leaf1", DataType::Boolean, false),
                 Field::new("leaf2", DataType::Int32, false),
-            ];
+            ]);
             let group1_struct =
                 Field::new("group1", DataType::Struct(group1_fields), false);
             arrow_fields.push(group1_struct);
@@ -1050,7 +1139,7 @@ mod tests {
 
         assert_eq!(arrow_fields.len(), converted_fields.len());
         for i in 0..arrow_fields.len() {
-            assert_eq!(arrow_fields[i], converted_fields[i]);
+            assert_eq!(&arrow_fields[i], converted_fields[i].as_ref());
         }
     }
 
@@ -1058,11 +1147,11 @@ mod tests {
     fn test_nested_schema_partial() {
         let mut arrow_fields = Vec::new();
         {
-            let group1_fields = vec![Field::new("leaf1", DataType::Int64, false)];
+            let group1_fields = vec![Field::new("leaf1", DataType::Int64, false)].into();
             let group1 = Field::new("group1", DataType::Struct(group1_fields), false);
             arrow_fields.push(group1);
 
-            let group2_fields = vec![Field::new("leaf4", DataType::Int64, false)];
+            let group2_fields = vec![Field::new("leaf4", DataType::Int64, false)].into();
             let group2 = Field::new("group2", DataType::Struct(group2_fields), false);
             arrow_fields.push(group2);
 
@@ -1101,7 +1190,7 @@ mod tests {
 
         assert_eq!(arrow_fields.len(), converted_fields.len());
         for i in 0..arrow_fields.len() {
-            assert_eq!(arrow_fields[i], converted_fields[i]);
+            assert_eq!(&arrow_fields[i], converted_fields[i].as_ref());
         }
     }
 
@@ -1109,11 +1198,11 @@ mod tests {
     fn test_nested_schema_partial_ordering() {
         let mut arrow_fields = Vec::new();
         {
-            let group1_fields = vec![Field::new("leaf1", DataType::Int64, false)];
+            let group1_fields = vec![Field::new("leaf1", DataType::Int64, false)].into();
             let group1 = Field::new("group1", DataType::Struct(group1_fields), false);
             arrow_fields.push(group1);
 
-            let group2_fields = vec![Field::new("leaf4", DataType::Int64, false)];
+            let group2_fields = vec![Field::new("leaf4", DataType::Int64, false)].into();
             let group2 = Field::new("group2", DataType::Struct(group2_fields), false);
             arrow_fields.push(group2);
 
@@ -1152,7 +1241,7 @@ mod tests {
 
         assert_eq!(arrow_fields.len(), converted_fields.len());
         for i in 0..arrow_fields.len() {
-            assert_eq!(arrow_fields[i], converted_fields[i]);
+            assert_eq!(&arrow_fields[i], converted_fields[i].as_ref());
         }
     }
 
@@ -1162,26 +1251,23 @@ mod tests {
         {
             arrow_fields.push(Field::new("leaf1", DataType::Int32, true));
 
-            let inner_group_list = Field::new(
+            let inner_group_list = Field::new_list(
                 "innerGroup",
-                DataType::List(Box::new(Field::new(
+                Field::new_struct(
                     "innerGroup",
-                    DataType::Struct(vec![Field::new("leaf3", DataType::Int32, true)]),
+                    vec![Field::new("leaf3", DataType::Int32, true)],
                     false,
-                ))),
+                ),
                 false,
             );
 
-            let outer_group_list = Field::new(
+            let outer_group_list = Field::new_list(
                 "outerGroup",
-                DataType::List(Box::new(Field::new(
+                Field::new_struct(
                     "outerGroup",
-                    DataType::Struct(vec![
-                        Field::new("leaf2", DataType::Int32, true),
-                        inner_group_list,
-                    ]),
+                    vec![Field::new("leaf2", DataType::Int32, true), inner_group_list],
                     false,
-                ))),
+                ),
                 false,
             );
             arrow_fields.push(outer_group_list);
@@ -1207,7 +1293,7 @@ mod tests {
 
         assert_eq!(arrow_fields.len(), converted_fields.len());
         for i in 0..arrow_fields.len() {
-            assert_eq!(arrow_fields[i], converted_fields[i]);
+            assert_eq!(&arrow_fields[i], converted_fields[i].as_ref());
         }
     }
 
@@ -1224,6 +1310,7 @@ mod tests {
             REQUIRED INT64   int64;
             OPTIONAL DOUBLE  double;
             OPTIONAL FLOAT   float;
+            OPTIONAL FIXED_LEN_BYTE_ARRAY (2) float16 (FLOAT16);
             OPTIONAL BINARY  string (UTF8);
             REPEATED BOOLEAN bools;
             OPTIONAL INT32   date       (DATE);
@@ -1233,6 +1320,12 @@ mod tests {
             OPTIONAL INT64   ts_milli (TIMESTAMP_MILLIS);
             REQUIRED INT64   ts_micro (TIMESTAMP_MICROS);
             REQUIRED INT64   ts_nano (TIMESTAMP(NANOS,true));
+            REPEATED INT32   int_list;
+            REPEATED BINARY  byte_list;
+            REPEATED BINARY  string_list (UTF8);
+            REQUIRED INT32 decimal_int32 (DECIMAL(8,2));
+            REQUIRED INT64 decimal_int64 (DECIMAL(16,2));
+            REQUIRED FIXED_LEN_BYTE_ARRAY (13) decimal_fix_length (DECIMAL(30,2));
         }
         ";
         let parquet_group_type = parse_message_type(message_type).unwrap();
@@ -1254,10 +1347,11 @@ mod tests {
             Field::new("int64", DataType::Int64, false),
             Field::new("double", DataType::Float64, true),
             Field::new("float", DataType::Float32, true),
+            Field::new("float16", DataType::Float16, true),
             Field::new("string", DataType::Utf8, true),
-            Field::new(
+            Field::new_list(
                 "bools",
-                DataType::List(Box::new(Field::new("bools", DataType::Boolean, false))),
+                Field::new("bools", DataType::Boolean, false),
                 false,
             ),
             Field::new("date", DataType::Date32, true),
@@ -1266,19 +1360,37 @@ mod tests {
             Field::new("time_nano", DataType::Time64(TimeUnit::Nanosecond), true),
             Field::new(
                 "ts_milli",
-                DataType::Timestamp(TimeUnit::Millisecond, None),
+                DataType::Timestamp(TimeUnit::Millisecond, Some("UTC".into())),
                 true,
             ),
             Field::new(
                 "ts_micro",
-                DataType::Timestamp(TimeUnit::Microsecond, None),
+                DataType::Timestamp(TimeUnit::Microsecond, Some("UTC".into())),
                 false,
             ),
             Field::new(
                 "ts_nano",
-                DataType::Timestamp(TimeUnit::Nanosecond, Some("UTC".to_string())),
+                DataType::Timestamp(TimeUnit::Nanosecond, Some("UTC".into())),
                 false,
             ),
+            Field::new_list(
+                "int_list",
+                Field::new("int_list", DataType::Int32, false),
+                false,
+            ),
+            Field::new_list(
+                "byte_list",
+                Field::new("byte_list", DataType::Binary, false),
+                false,
+            ),
+            Field::new_list(
+                "string_list",
+                Field::new("string_list", DataType::Utf8, false),
+                false,
+            ),
+            Field::new("decimal_int32", DataType::Decimal128(8, 2), false),
+            Field::new("decimal_int64", DataType::Decimal128(16, 2), false),
+            Field::new("decimal_fix_length", DataType::Decimal128(30, 2), false),
         ];
 
         assert_eq!(arrow_fields, converted_arrow_fields);
@@ -1295,6 +1407,7 @@ mod tests {
             REQUIRED INT64   int64;
             OPTIONAL DOUBLE  double;
             OPTIONAL FLOAT   float;
+            OPTIONAL FIXED_LEN_BYTE_ARRAY (2) float16 (FLOAT16);
             OPTIONAL BINARY  string (STRING);
             OPTIONAL GROUP   bools (LIST) {
                 REPEATED GROUP list {
@@ -1326,6 +1439,11 @@ mod tests {
                 }
             }
             REQUIRED BINARY  dictionary_strings (STRING);
+            REQUIRED INT32 decimal_int32 (DECIMAL(8,2));
+            REQUIRED INT64 decimal_int64 (DECIMAL(16,2));
+            REQUIRED FIXED_LEN_BYTE_ARRAY (13) decimal_fix_length (DECIMAL(30,2));
+            REQUIRED FIXED_LEN_BYTE_ARRAY (16) decimal128 (DECIMAL(38,2));
+            REQUIRED FIXED_LEN_BYTE_ARRAY (17) decimal256 (DECIMAL(39,2));
         }
         ";
         let parquet_group_type = parse_message_type(message_type).unwrap();
@@ -1340,15 +1458,16 @@ mod tests {
             Field::new("int64", DataType::Int64, false),
             Field::new("double", DataType::Float64, true),
             Field::new("float", DataType::Float32, true),
+            Field::new("float16", DataType::Float16, true),
             Field::new("string", DataType::Utf8, true),
-            Field::new(
+            Field::new_list(
                 "bools",
-                DataType::List(Box::new(Field::new("element", DataType::Boolean, true))),
+                Field::new("element", DataType::Boolean, true),
                 true,
             ),
-            Field::new(
+            Field::new_list(
                 "bools_non_null",
-                DataType::List(Box::new(Field::new("element", DataType::Boolean, false))),
+                Field::new("element", DataType::Boolean, false),
                 false,
             ),
             Field::new("date", DataType::Date32, true),
@@ -1366,51 +1485,53 @@ mod tests {
             ),
             Field::new(
                 "ts_seconds",
-                DataType::Timestamp(TimeUnit::Second, Some("UTC".to_string())),
+                DataType::Timestamp(TimeUnit::Second, Some("UTC".into())),
                 false,
             ),
             Field::new(
                 "ts_micro_utc",
-                DataType::Timestamp(TimeUnit::Microsecond, Some("UTC".to_string())),
+                DataType::Timestamp(TimeUnit::Microsecond, Some("UTC".into())),
                 false,
             ),
             Field::new(
                 "ts_millis_zero_offset",
-                DataType::Timestamp(TimeUnit::Millisecond, Some("+00:00".to_string())),
+                DataType::Timestamp(TimeUnit::Millisecond, Some("+00:00".into())),
                 false,
             ),
             Field::new(
                 "ts_millis_zero_negative_offset",
-                DataType::Timestamp(TimeUnit::Millisecond, Some("-00:00".to_string())),
+                DataType::Timestamp(TimeUnit::Millisecond, Some("-00:00".into())),
                 false,
             ),
             Field::new(
                 "ts_micro_non_utc",
-                DataType::Timestamp(TimeUnit::Microsecond, Some("+01:00".to_string())),
+                DataType::Timestamp(TimeUnit::Microsecond, Some("+01:00".into())),
                 false,
             ),
-            Field::new(
+            Field::new_struct(
                 "struct",
-                DataType::Struct(vec![
+                vec![
                     Field::new("bools", DataType::Boolean, false),
                     Field::new("uint32", DataType::UInt32, false),
-                    Field::new(
+                    Field::new_list(
                         "int32",
-                        DataType::List(Box::new(Field::new(
-                            "element",
-                            DataType::Int32,
-                            true,
-                        ))),
+                        Field::new("element", DataType::Int32, true),
                         false,
                     ),
-                ]),
+                ],
                 false,
             ),
-            Field::new(
+            Field::new_dictionary(
                 "dictionary_strings",
-                DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),
+                DataType::Int32,
+                DataType::Utf8,
                 false,
             ),
+            Field::new("decimal_int32", DataType::Decimal128(8, 2), false),
+            Field::new("decimal_int64", DataType::Decimal128(16, 2), false),
+            Field::new("decimal_fix_length", DataType::Decimal128(30, 2), false),
+            Field::new("decimal128", DataType::Decimal128(38, 2), false),
+            Field::new("decimal256", DataType::Decimal256(39, 2), false),
         ];
         let arrow_schema = Schema::new(arrow_fields);
         let converted_arrow_schema = arrow_to_parquet_schema(&arrow_schema).unwrap();
@@ -1444,7 +1565,11 @@ mod tests {
     #[test]
     #[should_panic(expected = "Parquet does not support writing empty structs")]
     fn test_empty_struct_field() {
-        let arrow_fields = vec![Field::new("struct", DataType::Struct(vec![]), false)];
+        let arrow_fields = vec![Field::new(
+            "struct",
+            DataType::Struct(Fields::empty()),
+            false,
+        )];
         let arrow_schema = Schema::new(arrow_fields);
         let converted_arrow_schema = arrow_to_parquet_schema(&arrow_schema);
 
@@ -1478,17 +1603,18 @@ mod tests {
 
     #[test]
     fn test_arrow_schema_roundtrip() -> Result<()> {
-        // This tests the roundtrip of an Arrow schema
-        // Fields that are commented out fail roundtrip tests or are unsupported by the writer
-        let metadata: HashMap<String, String> =
-            [("Key".to_string(), "Value".to_string())]
-                .iter()
-                .cloned()
-                .collect();
+        let meta = |a: &[(&str, &str)]| -> HashMap<String, String> {
+            a.iter()
+                .map(|(a, b)| (a.to_string(), b.to_string()))
+                .collect()
+        };
 
         let schema = Schema::new_with_metadata(
             vec![
-                Field::new("c1", DataType::Utf8, false),
+                Field::new("c1", DataType::Utf8, false).with_metadata(meta(&[
+                    ("Key", "Foo"),
+                    (PARQUET_FIELD_ID_META_KEY, "2"),
+                ])),
                 Field::new("c2", DataType::Binary, false),
                 Field::new("c3", DataType::FixedSizeBinary(3), false),
                 Field::new("c4", DataType::Boolean, false),
@@ -1501,14 +1627,14 @@ mod tests {
                 Field::new("c15", DataType::Timestamp(TimeUnit::Second, None), false),
                 Field::new(
                     "c16",
-                    DataType::Timestamp(TimeUnit::Millisecond, Some("UTC".to_string())),
+                    DataType::Timestamp(TimeUnit::Millisecond, Some("UTC".into())),
                     false,
                 ),
                 Field::new(
                     "c17",
                     DataType::Timestamp(
                         TimeUnit::Microsecond,
-                        Some("Africa/Johannesburg".to_string()),
+                        Some("Africa/Johannesburg".into()),
                     ),
                     false,
                 ),
@@ -1519,36 +1645,55 @@ mod tests {
                 ),
                 Field::new("c19", DataType::Interval(IntervalUnit::DayTime), false),
                 Field::new("c20", DataType::Interval(IntervalUnit::YearMonth), false),
-                Field::new(
+                Field::new_list(
                     "c21",
-                    DataType::List(Box::new(Field::new("list", DataType::Boolean, true))),
+                    Field::new("item", DataType::Boolean, true).with_metadata(meta(&[
+                        ("Key", "Bar"),
+                        (PARQUET_FIELD_ID_META_KEY, "5"),
+                    ])),
+                    false,
+                )
+                .with_metadata(meta(&[(PARQUET_FIELD_ID_META_KEY, "4")])),
+                Field::new(
+                    "c22",
+                    DataType::FixedSizeList(
+                        Arc::new(Field::new("item", DataType::Boolean, true)),
+                        5,
+                    ),
+                    false,
+                ),
+                Field::new_list(
+                    "c23",
+                    Field::new_large_list(
+                        "inner",
+                        Field::new(
+                            "item",
+                            DataType::Struct(
+                                vec![
+                                    Field::new("a", DataType::Int16, true),
+                                    Field::new("b", DataType::Float64, false),
+                                    Field::new("c", DataType::Float32, false),
+                                    Field::new("d", DataType::Float16, false),
+                                ]
+                                .into(),
+                            ),
+                            false,
+                        ),
+                        true,
+                    ),
                     false,
                 ),
-                // Field::new(
-                //     "c22",
-                //     DataType::FixedSizeList(Box::new(DataType::Boolean), 5),
-                //     false,
-                // ),
-                // Field::new(
-                //     "c23",
-                //     DataType::List(Box::new(DataType::LargeList(Box::new(
-                //         DataType::Struct(vec![
-                //             Field::new("a", DataType::Int16, true),
-                //             Field::new("b", DataType::Float64, false),
-                //         ]),
-                //     )))),
-                //     true,
-                // ),
                 Field::new(
                     "c24",
-                    DataType::Struct(vec![
+                    DataType::Struct(Fields::from(vec![
                         Field::new("a", DataType::Utf8, false),
                         Field::new("b", DataType::UInt16, false),
-                    ]),
+                    ])),
                     false,
                 ),
                 Field::new("c25", DataType::Interval(IntervalUnit::YearMonth), true),
                 Field::new("c26", DataType::Interval(IntervalUnit::DayTime), true),
+                // Duration types not supported
                 // Field::new("c27", DataType::Duration(TimeUnit::Second), false),
                 // Field::new("c28", DataType::Duration(TimeUnit::Millisecond), false),
                 // Field::new("c29", DataType::Duration(TimeUnit::Microsecond), false),
@@ -1562,94 +1707,76 @@ mod tests {
                     true,
                     123,
                     true,
-                ),
+                )
+                .with_metadata(meta(&[(PARQUET_FIELD_ID_META_KEY, "6")])),
                 Field::new("c32", DataType::LargeBinary, true),
                 Field::new("c33", DataType::LargeUtf8, true),
-                // Field::new(
-                //     "c34",
-                //     DataType::LargeList(Box::new(DataType::List(Box::new(
-                //         DataType::Struct(vec![
-                //             Field::new("a", DataType::Int16, true),
-                //             Field::new("b", DataType::Float64, true),
-                //         ]),
-                //     )))),
-                //     true,
-                // ),
+                Field::new_large_list(
+                    "c34",
+                    Field::new_list(
+                        "inner",
+                        Field::new(
+                            "item",
+                            DataType::Struct(
+                                vec![
+                                    Field::new("a", DataType::Int16, true),
+                                    Field::new("b", DataType::Float64, true),
+                                ]
+                                .into(),
+                            ),
+                            true,
+                        ),
+                        true,
+                    ),
+                    true,
+                ),
                 Field::new("c35", DataType::Null, true),
                 Field::new("c36", DataType::Decimal128(2, 1), false),
-                Field::new("c37", DataType::Decimal128(50, 20), false),
+                Field::new("c37", DataType::Decimal256(50, 20), false),
                 Field::new("c38", DataType::Decimal128(18, 12), true),
-                Field::new(
+                Field::new_map(
                     "c39",
-                    DataType::Map(
-                        Box::new(Field::new(
-                            "key_value",
-                            DataType::Struct(vec![
-                                Field::new("key", DataType::Utf8, false),
-                                Field::new(
-                                    "value",
-                                    DataType::List(Box::new(Field::new(
-                                        "element",
-                                        DataType::Utf8,
-                                        true,
-                                    ))),
-                                    true,
-                                ),
-                            ]),
-                            false, // #1697
-                        )),
-                        false, // fails to roundtrip keys_sorted
+                    "key_value",
+                    Field::new("key", DataType::Utf8, false),
+                    Field::new_list(
+                        "value",
+                        Field::new("element", DataType::Utf8, true),
+                        true,
                     ),
+                    false, // fails to roundtrip keys_sorted
                     true,
                 ),
-                Field::new(
+                Field::new_map(
                     "c40",
-                    DataType::Map(
-                        Box::new(Field::new(
-                            "my_entries",
-                            DataType::Struct(vec![
-                                Field::new("my_key", DataType::Utf8, false),
-                                Field::new(
-                                    "my_value",
-                                    DataType::List(Box::new(Field::new(
-                                        "item",
-                                        DataType::Utf8,
-                                        true,
-                                    ))),
-                                    true,
-                                ),
-                            ]),
-                            false, // #1697
-                        )),
-                        false, // fails to roundtrip keys_sorted
-                    ),
+                    "my_entries",
+                    Field::new("my_key", DataType::Utf8, false)
+                        .with_metadata(meta(&[(PARQUET_FIELD_ID_META_KEY, "8")])),
+                    Field::new_list(
+                        "my_value",
+                        Field::new("item", DataType::Utf8, true)
+                            .with_metadata(meta(&[(PARQUET_FIELD_ID_META_KEY, "10")])),
+                        true,
+                    )
+                    .with_metadata(meta(&[(PARQUET_FIELD_ID_META_KEY, "9")])),
+                    false, // fails to roundtrip keys_sorted
                     true,
-                ),
-                Field::new(
+                )
+                .with_metadata(meta(&[(PARQUET_FIELD_ID_META_KEY, "7")])),
+                Field::new_map(
                     "c41",
-                    DataType::Map(
-                        Box::new(Field::new(
-                            "my_entries",
-                            DataType::Struct(vec![
-                                Field::new("my_key", DataType::Utf8, false),
-                                Field::new(
-                                    "my_value",
-                                    DataType::List(Box::new(Field::new(
-                                        "item",
-                                        DataType::Utf8,
-                                        true,
-                                    ))),
-                                    true,
-                                ),
-                            ]),
-                            false,
-                        )),
-                        false, // fails to roundtrip keys_sorted
+                    "my_entries",
+                    Field::new("my_key", DataType::Utf8, false),
+                    Field::new_list(
+                        "my_value",
+                        Field::new("item", DataType::Utf8, true)
+                            .with_metadata(meta(&[(PARQUET_FIELD_ID_META_KEY, "11")])),
+                        true,
                     ),
+                    false, // fails to roundtrip keys_sorted
                     false,
                 ),
             ],
-            metadata,
+            meta(&[("Key", "Value")]),
         );
 
         // write to an empty parquet file so that schema is serialized
@@ -1662,14 +1789,94 @@ mod tests {
         writer.close()?;
 
         // read file back
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-        let read_schema = arrow_reader.get_schema()?;
-        assert_eq!(schema, read_schema);
+        let arrow_reader = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+
+        // Check arrow schema
+        let read_schema = arrow_reader.schema();
+        assert_eq!(&schema, read_schema.as_ref());
+
+        // Walk schema finding field IDs
+        let mut stack = Vec::with_capacity(10);
+        let mut out = Vec::with_capacity(10);
+
+        let root = arrow_reader.parquet_schema().root_schema_ptr();
+        stack.push((root.name().to_string(), root));
+
+        while let Some((p, t)) = stack.pop() {
+            if t.is_group() {
+                for f in t.get_fields() {
+                    stack.push((format!("{p}.{}", f.name()), f.clone()))
+                }
+            }
 
-        // read all fields by columns
-        let partial_read_schema =
-            arrow_reader.get_schema_by_columns(ProjectionMask::all())?;
-        assert_eq!(schema, partial_read_schema);
+            let info = t.get_basic_info();
+            if info.has_id() {
+                out.push(format!("{p} -> {}", info.id()))
+            }
+        }
+        out.sort_unstable();
+        let out: Vec<_> = out.iter().map(|x| x.as_str()).collect();
+
+        assert_eq!(
+            &out,
+            &[
+                "arrow_schema.c1 -> 2",
+                "arrow_schema.c21 -> 4",
+                "arrow_schema.c21.list.item -> 5",
+                "arrow_schema.c31 -> 6",
+                "arrow_schema.c40 -> 7",
+                "arrow_schema.c40.my_entries.my_key -> 8",
+                "arrow_schema.c40.my_entries.my_value -> 9",
+                "arrow_schema.c40.my_entries.my_value.list.item -> 10",
+                "arrow_schema.c41.my_entries.my_value.list.item -> 11",
+            ]
+        );
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_read_parquet_field_ids_raw() -> Result<()> {
+        let meta = |a: &[(&str, &str)]| -> HashMap<String, String> {
+            a.iter()
+                .map(|(a, b)| (a.to_string(), b.to_string()))
+                .collect()
+        };
+        let schema = Schema::new_with_metadata(
+            vec![
+                Field::new("c1", DataType::Utf8, true).with_metadata(meta(&[
+                    (PARQUET_FIELD_ID_META_KEY, "1"),
+                ])),
+                Field::new("c2", DataType::Utf8, true).with_metadata(meta(&[
+                    (PARQUET_FIELD_ID_META_KEY, "2"),
+                ])),
+            ],
+            HashMap::new(),
+        );
+
+        let writer = ArrowWriter::try_new(
+            vec![],
+            Arc::new(schema.clone()),
+            None,
+        )?;
+        let parquet_bytes = writer.into_inner()?;
+
+        let reader = crate::file::reader::SerializedFileReader::new(
+            bytes::Bytes::from(parquet_bytes),
+        )?;
+        let schema_descriptor = reader.metadata().file_metadata().schema_descr_ptr();
+
+        // don't pass metadata so field ids are read from Parquet and not from serialized Arrow schema
+        let arrow_schema = crate::arrow::parquet_to_arrow_schema(
+            &schema_descriptor,
+            None,
+        )?;
+
+        let parq_schema_descr = crate::arrow::arrow_to_parquet_schema(&arrow_schema)?;
+        let parq_fields = parq_schema_descr.root_schema().get_fields();
+        assert_eq!(parq_fields.len(), 2);
+        assert_eq!(parq_fields[0].get_basic_info().id(), 1);
+        assert_eq!(parq_fields[1].get_basic_info().id(), 2);
 
         Ok(())
     }
@@ -1684,37 +1891,33 @@ mod tests {
 
         let schema = Schema::new_with_metadata(
             vec![
-                Field::new(
+                Field::new_list(
                     "c21",
-                    DataType::List(Box::new(Field::new(
-                        "array",
-                        DataType::Boolean,
-                        true,
-                    ))),
+                    Field::new("array", DataType::Boolean, true),
                     false,
                 ),
                 Field::new(
                     "c22",
                     DataType::FixedSizeList(
-                        Box::new(Field::new("items", DataType::Boolean, false)),
+                        Arc::new(Field::new("items", DataType::Boolean, false)),
                         5,
                     ),
                     false,
                 ),
-                Field::new(
+                Field::new_list(
                     "c23",
-                    DataType::List(Box::new(Field::new(
+                    Field::new_large_list(
                         "items",
-                        DataType::LargeList(Box::new(Field::new(
+                        Field::new_struct(
                             "items",
-                            DataType::Struct(vec![
+                            vec![
                                 Field::new("a", DataType::Int16, true),
                                 Field::new("b", DataType::Float64, false),
-                            ]),
+                            ],
                             true,
-                        ))),
+                        ),
                         true,
-                    ))),
+                    ),
                     true,
                 ),
             ],
@@ -1731,15 +1934,14 @@ mod tests {
         writer.close()?;
 
         // read file back
-        let mut arrow_reader = ParquetFileArrowReader::try_new(file).unwrap();
-        let read_schema = arrow_reader.get_schema()?;
-        assert_eq!(schema, read_schema);
-
-        // read all fields by columns
-        let partial_read_schema =
-            arrow_reader.get_schema_by_columns(ProjectionMask::all())?;
-        assert_eq!(schema, partial_read_schema);
-
+        let arrow_reader = ParquetRecordBatchReaderBuilder::try_new(file).unwrap();
+        let read_schema = arrow_reader.schema();
+        assert_eq!(&schema, read_schema.as_ref());
         Ok(())
     }
+
+    #[test]
+    fn test_get_arrow_schema_from_metadata() {
+        assert!(get_arrow_schema_from_metadata("").is_err());
+    }
 }
diff --git a/parquet/src/arrow/schema/primitive.rs b/parquet/src/arrow/schema/primitive.rs
index c05a13565b12..fdc744831a25 100644
--- a/parquet/src/arrow/schema/primitive.rs
+++ b/parquet/src/arrow/schema/primitive.rs
@@ -20,7 +20,7 @@ use crate::basic::{
 };
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::{BasicTypeInfo, Type};
-use arrow::datatypes::{DataType, IntervalUnit, TimeUnit};
+use arrow_schema::{DataType, IntervalUnit, TimeUnit, DECIMAL128_MAX_PRECISION};
 
 /// Converts [`Type`] to [`DataType`] with an optional `arrow_type_hint`
 /// provided by the arrow schema
@@ -62,6 +62,9 @@ fn apply_hint(parquet: DataType, hint: DataType) -> DataType {
         // Determine interval time unit (#1666)
         (DataType::Interval(_), DataType::Interval(_)) => hint,
 
+        // Promote to Decimal256
+        (DataType::Decimal128(_, _), DataType::Decimal256(_, _)) => hint,
+
         // Potentially preserve dictionary encoding
         (_, DataType::Dictionary(_, value)) => {
             // Apply hint to inner type
@@ -104,6 +107,14 @@ fn from_parquet(parquet_type: &Type) -> Result<DataType> {
 }
 
 fn decimal_type(scale: i32, precision: i32) -> Result<DataType> {
+    if precision <= DECIMAL128_MAX_PRECISION as _ {
+        decimal_128_type(scale, precision)
+    } else {
+        decimal_256_type(scale, precision)
+    }
+}
+
+fn decimal_128_type(scale: i32, precision: i32) -> Result<DataType> {
     let scale = scale
         .try_into()
         .map_err(|_| arrow_err!("scale cannot be negative: {}", scale))?;
@@ -115,6 +126,18 @@ fn decimal_type(scale: i32, precision: i32) -> Result<DataType> {
     Ok(DataType::Decimal128(precision, scale))
 }
 
+fn decimal_256_type(scale: i32, precision: i32) -> Result<DataType> {
+    let scale = scale
+        .try_into()
+        .map_err(|_| arrow_err!("scale cannot be negative: {}", scale))?;
+
+    let precision = precision
+        .try_into()
+        .map_err(|_| arrow_err!("precision cannot be negative: {}", precision))?;
+
+    Ok(DataType::Decimal256(precision, scale))
+}
+
 fn from_int32(info: &BasicTypeInfo, scale: i32, precision: i32) -> Result<DataType> {
     match (info.logical_type(), info.converted_type()) {
         (None, ConvertedType::NONE) => Ok(DataType::Int32),
@@ -136,7 +159,7 @@ fn from_int32(info: &BasicTypeInfo, scale: i32, precision: i32) -> Result<DataTy
             _ => Err(arrow_err!("Cannot create INT32 physical type from {:?}", t)),
         },
         (Some(LogicalType::Decimal { scale, precision }), _) => {
-            decimal_type(scale, precision)
+            decimal_128_type(scale, precision)
         }
         (Some(LogicalType::Date), _) => Ok(DataType::Date32),
         (Some(LogicalType::Time { unit, .. }), _) => match unit {
@@ -156,7 +179,7 @@ fn from_int32(info: &BasicTypeInfo, scale: i32, precision: i32) -> Result<DataTy
         (None, ConvertedType::INT_32) => Ok(DataType::Int32),
         (None, ConvertedType::DATE) => Ok(DataType::Date32),
         (None, ConvertedType::TIME_MILLIS) => Ok(DataType::Time32(TimeUnit::Millisecond)),
-        (None, ConvertedType::DECIMAL) => decimal_type(scale, precision),
+        (None, ConvertedType::DECIMAL) => decimal_128_type(scale, precision),
         (logical, converted) => Err(arrow_err!(
             "Unable to convert parquet INT32 logical type {:?} or converted type {}",
             logical,
@@ -170,11 +193,11 @@ fn from_int64(info: &BasicTypeInfo, scale: i32, precision: i32) -> Result<DataTy
         (None, ConvertedType::NONE) => Ok(DataType::Int64),
         (
             Some(LogicalType::Integer {
-                bit_width,
+                bit_width: 64,
                 is_signed,
             }),
             _,
-        ) if bit_width == 64 => match is_signed {
+        ) => match is_signed {
             true => Ok(DataType::Int64),
             false => Ok(DataType::UInt64),
         },
@@ -198,7 +221,7 @@ fn from_int64(info: &BasicTypeInfo, scale: i32, precision: i32) -> Result<DataTy
                 ParquetTimeUnit::NANOS(_) => TimeUnit::Nanosecond,
             },
             if is_adjusted_to_u_t_c {
-                Some("UTC".to_string())
+                Some("UTC".into())
             } else {
                 None
             },
@@ -206,16 +229,18 @@ fn from_int64(info: &BasicTypeInfo, scale: i32, precision: i32) -> Result<DataTy
         (None, ConvertedType::INT_64) => Ok(DataType::Int64),
         (None, ConvertedType::UINT_64) => Ok(DataType::UInt64),
         (None, ConvertedType::TIME_MICROS) => Ok(DataType::Time64(TimeUnit::Microsecond)),
-        (None, ConvertedType::TIMESTAMP_MILLIS) => {
-            Ok(DataType::Timestamp(TimeUnit::Millisecond, None))
-        }
-        (None, ConvertedType::TIMESTAMP_MICROS) => {
-            Ok(DataType::Timestamp(TimeUnit::Microsecond, None))
-        }
+        (None, ConvertedType::TIMESTAMP_MILLIS) => Ok(DataType::Timestamp(
+            TimeUnit::Millisecond,
+            Some("UTC".into()),
+        )),
+        (None, ConvertedType::TIMESTAMP_MICROS) => Ok(DataType::Timestamp(
+            TimeUnit::Microsecond,
+            Some("UTC".into()),
+        )),
         (Some(LogicalType::Decimal { scale, precision }), _) => {
-            decimal_type(scale, precision)
+            decimal_128_type(scale, precision)
         }
-        (None, ConvertedType::DECIMAL) => decimal_type(scale, precision),
+        (None, ConvertedType::DECIMAL) => decimal_128_type(scale, precision),
         (logical, converted) => Err(arrow_err!(
             "Unable to convert parquet INT64 logical type {:?} or converted type {}",
             logical,
@@ -227,20 +252,22 @@ fn from_int64(info: &BasicTypeInfo, scale: i32, precision: i32) -> Result<DataTy
 fn from_byte_array(info: &BasicTypeInfo, precision: i32, scale: i32) -> Result<DataType> {
     match (info.logical_type(), info.converted_type()) {
         (Some(LogicalType::String), _) => Ok(DataType::Utf8),
-        (Some(LogicalType::Json), _) => Ok(DataType::Binary),
+        (Some(LogicalType::Json), _) => Ok(DataType::Utf8),
         (Some(LogicalType::Bson), _) => Ok(DataType::Binary),
         (Some(LogicalType::Enum), _) => Ok(DataType::Binary),
         (None, ConvertedType::NONE) => Ok(DataType::Binary),
-        (None, ConvertedType::JSON) => Ok(DataType::Binary),
+        (None, ConvertedType::JSON) => Ok(DataType::Utf8),
         (None, ConvertedType::BSON) => Ok(DataType::Binary),
         (None, ConvertedType::ENUM) => Ok(DataType::Binary),
         (None, ConvertedType::UTF8) => Ok(DataType::Utf8),
-        (Some(LogicalType::Decimal { precision, scale }), _) => {
-            Ok(DataType::Decimal128(precision as usize, scale as usize))
-        }
-        (None, ConvertedType::DECIMAL) => {
-            Ok(DataType::Decimal128(precision as usize, scale as usize))
-        }
+        (
+            Some(LogicalType::Decimal {
+                scale: s,
+                precision: p,
+            }),
+            _,
+        ) => decimal_type(s, p),
+        (None, ConvertedType::DECIMAL) => decimal_type(scale, precision),
         (logical, converted) => Err(arrow_err!(
             "Unable to convert parquet BYTE_ARRAY logical type {:?} or converted type {}",
             logical,
@@ -258,15 +285,35 @@ fn from_fixed_len_byte_array(
     // TODO: This should check the type length for the decimal and interval types
     match (info.logical_type(), info.converted_type()) {
         (Some(LogicalType::Decimal { scale, precision }), _) => {
-            decimal_type(scale, precision)
+            if type_length <= 16 {
+                decimal_128_type(scale, precision)
+            } else {
+                decimal_256_type(scale, precision)
+            }
+        }
+        (None, ConvertedType::DECIMAL) => {
+            if type_length <= 16 {
+                decimal_128_type(scale, precision)
+            } else {
+                decimal_256_type(scale, precision)
+            }
         }
-        (None, ConvertedType::DECIMAL) => decimal_type(scale, precision),
         (None, ConvertedType::INTERVAL) => {
             // There is currently no reliable way of determining which IntervalUnit
             // to return. Thus without the original Arrow schema, the results
             // would be incorrect if all 12 bytes of the interval are populated
             Ok(DataType::Interval(IntervalUnit::DayTime))
         }
+        (Some(LogicalType::Float16), _) => {
+            if type_length == 2 {
+                Ok(DataType::Float16)
+            } else {
+                Err(ParquetError::General(
+                    "FLOAT16 logical type must be Fixed Length Byte Array with length 2"
+                        .to_string(),
+                ))
+            }
+        }
         _ => Ok(DataType::FixedSizeBinary(type_length)),
     }
 }
diff --git a/parquet/src/basic.rs b/parquet/src/basic.rs
index 7adbc8c1b6d0..2dd252a58956 100644
--- a/parquet/src/basic.rs
+++ b/parquet/src/basic.rs
@@ -16,18 +16,20 @@
 // under the License.
 
 //! Contains Rust mappings for Thrift definition.
-//! Refer to `parquet.thrift` file to see raw definitions.
+//! Refer to [`parquet.thrift`](https://github.com/apache/parquet-format/blob/master/src/main/thrift/parquet.thrift) file to see raw definitions.
 
-use std::{fmt, result, str};
+use std::str::FromStr;
+use std::{fmt, str};
 
-use parquet_format as parquet;
+pub use crate::compression::{BrotliLevel, GzipLevel, ZstdLevel};
+use crate::format as parquet;
 
-use crate::errors::ParquetError;
+use crate::errors::{ParquetError, Result};
 
-// Re-export parquet_format types used in this module
-pub use parquet_format::{
-    BsonType, DateType, DecimalType, EnumType, IntType, JsonType, ListType, MapType,
-    NullType, StringType, TimeType, TimeUnit, TimestampType, UUIDType,
+// Re-export crate::format types used in this module
+pub use crate::format::{
+    BsonType, DateType, DecimalType, EnumType, IntType, JsonType, ListType, MapType, NullType,
+    StringType, TimeType, TimeUnit, TimestampType, UUIDType,
 };
 
 // ----------------------------------------------------------------------
@@ -192,6 +194,7 @@ pub enum LogicalType {
     Json,
     Bson,
     Uuid,
+    Float16,
 }
 
 // ----------------------------------------------------------------------
@@ -213,8 +216,21 @@ pub enum Repetition {
 // Mirrors `parquet::Encoding`
 
 /// Encodings supported by Parquet.
+///
 /// Not all encodings are valid for all types. These enums are also used to specify the
 /// encoding of definition and repetition levels.
+///
+/// By default this crate uses [Encoding::PLAIN], [Encoding::RLE], and [Encoding::RLE_DICTIONARY].
+/// These provide very good encode and decode performance, whilst yielding reasonable storage
+/// efficiency and being supported by all major parquet readers.
+///
+/// The delta encodings are also supported and will be used if a newer [WriterVersion] is
+/// configured, however, it should be noted that these sacrifice encode and decode performance for
+/// improved storage efficiency. This performance regression is particularly pronounced in the case
+/// of record skipping as occurs during predicate push-down. It is recommended users assess the
+/// performance impact when evaluating these encodings.
+///
+/// [WriterVersion]: crate::file::properties::WriterVersion
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Ord, PartialOrd)]
 #[allow(non_camel_case_types)]
 pub enum Encoding {
@@ -240,10 +256,21 @@ pub enum Encoding {
     /// Usable for definition/repetition levels encoding and boolean values.
     RLE,
 
-    /// Bit packed encoding.
+    /// **Deprecated** Bit-packed encoding.
     ///
     /// This can only be used if the data has a known max width.
     /// Usable for definition/repetition levels encoding.
+    ///
+    /// There are compatibility issues with files using this encoding.
+    /// The parquet standard specifies the bits to be packed starting from the
+    /// most-significant bit, several implementations do not follow this bit order.
+    /// Several other implementations also have issues reading this encoding
+    /// because of incorrect assumptions about the length of the encoded data.
+    ///
+    /// The RLE/bit-packing hybrid is more cpu and memory efficient and should be used instead.
+    #[deprecated(
+        note = "Please see documentation for compatibility issues and use the RLE/bit-packing hybrid encoding instead"
+    )]
     BIT_PACKED,
 
     /// Delta encoding for integers, either INT32 or INT64.
@@ -277,19 +304,135 @@ pub enum Encoding {
     BYTE_STREAM_SPLIT,
 }
 
+impl FromStr for Encoding {
+    type Err = ParquetError;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "PLAIN" | "plain" => Ok(Encoding::PLAIN),
+            "PLAIN_DICTIONARY" | "plain_dictionary" => Ok(Encoding::PLAIN_DICTIONARY),
+            "RLE" | "rle" => Ok(Encoding::RLE),
+            #[allow(deprecated)]
+            "BIT_PACKED" | "bit_packed" => Ok(Encoding::BIT_PACKED),
+            "DELTA_BINARY_PACKED" | "delta_binary_packed" => Ok(Encoding::DELTA_BINARY_PACKED),
+            "DELTA_LENGTH_BYTE_ARRAY" | "delta_length_byte_array" => {
+                Ok(Encoding::DELTA_LENGTH_BYTE_ARRAY)
+            }
+            "DELTA_BYTE_ARRAY" | "delta_byte_array" => Ok(Encoding::DELTA_BYTE_ARRAY),
+            "RLE_DICTIONARY" | "rle_dictionary" => Ok(Encoding::RLE_DICTIONARY),
+            "BYTE_STREAM_SPLIT" | "byte_stream_split" => Ok(Encoding::BYTE_STREAM_SPLIT),
+            _ => Err(general_err!("unknown encoding: {}", s)),
+        }
+    }
+}
+
 // ----------------------------------------------------------------------
 // Mirrors `parquet::CompressionCodec`
 
-/// Supported compression algorithms.
+/// Supported block compression algorithms.
+///
+/// Block compression can yield non-trivial improvements to storage efficiency at the expense
+/// of potentially significantly worse encode and decode performance. Many applications,
+/// especially those making use of high-throughput and low-cost commodity object storage,
+/// may find storage efficiency less important than decode throughput, and therefore may
+/// wish to not make use of block compression.
+///
+/// The writers in this crate default to no block compression for this reason.
+///
+/// Applications that do still wish to use block compression, will find [`Compression::ZSTD`]
+/// to provide a good balance of compression, performance, and ecosystem support. Alternatively,
+/// [`Compression::LZ4_RAW`] provides much faster decompression speeds, at the cost of typically
+/// worse compression ratios. However, it is not as widely supported by the ecosystem, with the
+/// Hadoop ecosystem historically favoring the non-standard and now deprecated [`Compression::LZ4`].
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[allow(non_camel_case_types)]
 pub enum Compression {
     UNCOMPRESSED,
     SNAPPY,
-    GZIP,
+    GZIP(GzipLevel),
     LZO,
-    BROTLI,
+    BROTLI(BrotliLevel),
     LZ4,
-    ZSTD,
+    ZSTD(ZstdLevel),
+    LZ4_RAW,
+}
+
+fn split_compression_string(str_setting: &str) -> Result<(&str, Option<u32>), ParquetError> {
+    let split_setting = str_setting.split_once('(');
+
+    match split_setting {
+        Some((codec, level_str)) => {
+            let level = &level_str[..level_str.len() - 1]
+                .parse::<u32>()
+                .map_err(|_| {
+                    ParquetError::General(format!("invalid compression level: {}", level_str))
+                })?;
+            Ok((codec, Some(*level)))
+        }
+        None => Ok((str_setting, None)),
+    }
+}
+
+fn check_level_is_none(level: &Option<u32>) -> Result<(), ParquetError> {
+    if level.is_some() {
+        return Err(ParquetError::General("level is not support".to_string()));
+    }
+
+    Ok(())
+}
+
+fn require_level(codec: &str, level: Option<u32>) -> Result<u32, ParquetError> {
+    level.ok_or(ParquetError::General(format!("{} require level", codec)))
+}
+
+impl FromStr for Compression {
+    type Err = ParquetError;
+
+    fn from_str(s: &str) -> std::result::Result<Self, Self::Err> {
+        let (codec, level) = split_compression_string(s)?;
+
+        let c = match codec {
+            "UNCOMPRESSED" | "uncompressed" => {
+                check_level_is_none(&level)?;
+                Compression::UNCOMPRESSED
+            }
+            "SNAPPY" | "snappy" => {
+                check_level_is_none(&level)?;
+                Compression::SNAPPY
+            }
+            "GZIP" | "gzip" => {
+                let level = require_level(codec, level)?;
+                Compression::GZIP(GzipLevel::try_new(level)?)
+            }
+            "LZO" | "lzo" => {
+                check_level_is_none(&level)?;
+                Compression::LZO
+            }
+            "BROTLI" | "brotli" => {
+                let level = require_level(codec, level)?;
+                Compression::BROTLI(BrotliLevel::try_new(level)?)
+            }
+            "LZ4" | "lz4" => {
+                check_level_is_none(&level)?;
+                Compression::LZ4
+            }
+            "ZSTD" | "zstd" => {
+                let level = require_level(codec, level)?;
+                Compression::ZSTD(ZstdLevel::try_new(level as i32)?)
+            }
+            "LZ4_RAW" | "lz4_raw" => {
+                check_level_is_none(&level)?;
+                Compression::LZ4_RAW
+            }
+            _ => {
+                return Err(ParquetError::General(format!(
+                    "unsupport compression {codec}"
+                )));
+            }
+        };
+
+        Ok(c)
+    }
 }
 
 // ----------------------------------------------------------------------
@@ -328,6 +471,13 @@ pub enum SortOrder {
     UNDEFINED,
 }
 
+impl SortOrder {
+    /// Returns true if this is [`Self::SIGNED`]
+    pub fn is_signed(&self) -> bool {
+        matches!(self, Self::SIGNED)
+    }
+}
+
 /// Column order that specifies what method was used to aggregate min/max values for
 /// statistics.
 ///
@@ -354,10 +504,9 @@ impl ColumnOrder {
         // TODO: Should this take converted and logical type, for compatibility?
         match logical_type {
             Some(logical) => match logical {
-                LogicalType::String
-                | LogicalType::Enum
-                | LogicalType::Json
-                | LogicalType::Bson => SortOrder::UNSIGNED,
+                LogicalType::String | LogicalType::Enum | LogicalType::Json | LogicalType::Bson => {
+                    SortOrder::UNSIGNED
+                }
                 LogicalType::Integer { is_signed, .. } => match is_signed {
                     true => SortOrder::SIGNED,
                     false => SortOrder::UNSIGNED,
@@ -369,16 +518,14 @@ impl ColumnOrder {
                 LogicalType::Timestamp { .. } => SortOrder::SIGNED,
                 LogicalType::Unknown => SortOrder::UNDEFINED,
                 LogicalType::Uuid => SortOrder::UNSIGNED,
+                LogicalType::Float16 => SortOrder::SIGNED,
             },
             // Fall back to converted type
             None => Self::get_converted_sort_order(converted_type, physical_type),
         }
     }
 
-    fn get_converted_sort_order(
-        converted_type: ConvertedType,
-        physical_type: Type,
-    ) -> SortOrder {
+    fn get_converted_sort_order(converted_type: ConvertedType, physical_type: Type) -> SortOrder {
         match converted_type {
             // Unsigned byte-wise comparison.
             ConvertedType::UTF8
@@ -447,81 +594,84 @@ impl ColumnOrder {
 
 impl fmt::Display for Type {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 impl fmt::Display for ConvertedType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 impl fmt::Display for Repetition {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 impl fmt::Display for Encoding {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 impl fmt::Display for Compression {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 impl fmt::Display for PageType {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 impl fmt::Display for SortOrder {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 impl fmt::Display for ColumnOrder {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "{:?}", self)
+        write!(f, "{self:?}")
     }
 }
 
 // ----------------------------------------------------------------------
 // parquet::Type <=> Type conversion
 
-impl From<parquet::Type> for Type {
-    fn from(value: parquet::Type) -> Self {
-        match value {
-            parquet::Type::Boolean => Type::BOOLEAN,
-            parquet::Type::Int32 => Type::INT32,
-            parquet::Type::Int64 => Type::INT64,
-            parquet::Type::Int96 => Type::INT96,
-            parquet::Type::Float => Type::FLOAT,
-            parquet::Type::Double => Type::DOUBLE,
-            parquet::Type::ByteArray => Type::BYTE_ARRAY,
-            parquet::Type::FixedLenByteArray => Type::FIXED_LEN_BYTE_ARRAY,
-        }
+impl TryFrom<parquet::Type> for Type {
+    type Error = ParquetError;
+
+    fn try_from(value: parquet::Type) -> Result<Self> {
+        Ok(match value {
+            parquet::Type::BOOLEAN => Type::BOOLEAN,
+            parquet::Type::INT32 => Type::INT32,
+            parquet::Type::INT64 => Type::INT64,
+            parquet::Type::INT96 => Type::INT96,
+            parquet::Type::FLOAT => Type::FLOAT,
+            parquet::Type::DOUBLE => Type::DOUBLE,
+            parquet::Type::BYTE_ARRAY => Type::BYTE_ARRAY,
+            parquet::Type::FIXED_LEN_BYTE_ARRAY => Type::FIXED_LEN_BYTE_ARRAY,
+            _ => return Err(general_err!("unexpected parquet type: {}", value.0)),
+        })
     }
 }
 
 impl From<Type> for parquet::Type {
     fn from(value: Type) -> Self {
         match value {
-            Type::BOOLEAN => parquet::Type::Boolean,
-            Type::INT32 => parquet::Type::Int32,
-            Type::INT64 => parquet::Type::Int64,
-            Type::INT96 => parquet::Type::Int96,
-            Type::FLOAT => parquet::Type::Float,
-            Type::DOUBLE => parquet::Type::Double,
-            Type::BYTE_ARRAY => parquet::Type::ByteArray,
-            Type::FIXED_LEN_BYTE_ARRAY => parquet::Type::FixedLenByteArray,
+            Type::BOOLEAN => parquet::Type::BOOLEAN,
+            Type::INT32 => parquet::Type::INT32,
+            Type::INT64 => parquet::Type::INT64,
+            Type::INT96 => parquet::Type::INT96,
+            Type::FLOAT => parquet::Type::FLOAT,
+            Type::DOUBLE => parquet::Type::DOUBLE,
+            Type::BYTE_ARRAY => parquet::Type::BYTE_ARRAY,
+            Type::FIXED_LEN_BYTE_ARRAY => parquet::Type::FIXED_LEN_BYTE_ARRAY,
         }
     }
 }
@@ -529,39 +679,43 @@ impl From<Type> for parquet::Type {
 // ----------------------------------------------------------------------
 // parquet::ConvertedType <=> ConvertedType conversion
 
-impl From<Option<parquet::ConvertedType>> for ConvertedType {
-    fn from(option: Option<parquet::ConvertedType>) -> Self {
-        match option {
+impl TryFrom<Option<parquet::ConvertedType>> for ConvertedType {
+    type Error = ParquetError;
+
+    fn try_from(option: Option<parquet::ConvertedType>) -> Result<Self> {
+        Ok(match option {
             None => ConvertedType::NONE,
             Some(value) => match value {
-                parquet::ConvertedType::Utf8 => ConvertedType::UTF8,
-                parquet::ConvertedType::Map => ConvertedType::MAP,
-                parquet::ConvertedType::MapKeyValue => ConvertedType::MAP_KEY_VALUE,
-                parquet::ConvertedType::List => ConvertedType::LIST,
-                parquet::ConvertedType::Enum => ConvertedType::ENUM,
-                parquet::ConvertedType::Decimal => ConvertedType::DECIMAL,
-                parquet::ConvertedType::Date => ConvertedType::DATE,
-                parquet::ConvertedType::TimeMillis => ConvertedType::TIME_MILLIS,
-                parquet::ConvertedType::TimeMicros => ConvertedType::TIME_MICROS,
-                parquet::ConvertedType::TimestampMillis => {
-                    ConvertedType::TIMESTAMP_MILLIS
+                parquet::ConvertedType::UTF8 => ConvertedType::UTF8,
+                parquet::ConvertedType::MAP => ConvertedType::MAP,
+                parquet::ConvertedType::MAP_KEY_VALUE => ConvertedType::MAP_KEY_VALUE,
+                parquet::ConvertedType::LIST => ConvertedType::LIST,
+                parquet::ConvertedType::ENUM => ConvertedType::ENUM,
+                parquet::ConvertedType::DECIMAL => ConvertedType::DECIMAL,
+                parquet::ConvertedType::DATE => ConvertedType::DATE,
+                parquet::ConvertedType::TIME_MILLIS => ConvertedType::TIME_MILLIS,
+                parquet::ConvertedType::TIME_MICROS => ConvertedType::TIME_MICROS,
+                parquet::ConvertedType::TIMESTAMP_MILLIS => ConvertedType::TIMESTAMP_MILLIS,
+                parquet::ConvertedType::TIMESTAMP_MICROS => ConvertedType::TIMESTAMP_MICROS,
+                parquet::ConvertedType::UINT_8 => ConvertedType::UINT_8,
+                parquet::ConvertedType::UINT_16 => ConvertedType::UINT_16,
+                parquet::ConvertedType::UINT_32 => ConvertedType::UINT_32,
+                parquet::ConvertedType::UINT_64 => ConvertedType::UINT_64,
+                parquet::ConvertedType::INT_8 => ConvertedType::INT_8,
+                parquet::ConvertedType::INT_16 => ConvertedType::INT_16,
+                parquet::ConvertedType::INT_32 => ConvertedType::INT_32,
+                parquet::ConvertedType::INT_64 => ConvertedType::INT_64,
+                parquet::ConvertedType::JSON => ConvertedType::JSON,
+                parquet::ConvertedType::BSON => ConvertedType::BSON,
+                parquet::ConvertedType::INTERVAL => ConvertedType::INTERVAL,
+                _ => {
+                    return Err(general_err!(
+                        "unexpected parquet converted type: {}",
+                        value.0
+                    ))
                 }
-                parquet::ConvertedType::TimestampMicros => {
-                    ConvertedType::TIMESTAMP_MICROS
-                }
-                parquet::ConvertedType::Uint8 => ConvertedType::UINT_8,
-                parquet::ConvertedType::Uint16 => ConvertedType::UINT_16,
-                parquet::ConvertedType::Uint32 => ConvertedType::UINT_32,
-                parquet::ConvertedType::Uint64 => ConvertedType::UINT_64,
-                parquet::ConvertedType::Int8 => ConvertedType::INT_8,
-                parquet::ConvertedType::Int16 => ConvertedType::INT_16,
-                parquet::ConvertedType::Int32 => ConvertedType::INT_32,
-                parquet::ConvertedType::Int64 => ConvertedType::INT_64,
-                parquet::ConvertedType::Json => ConvertedType::JSON,
-                parquet::ConvertedType::Bson => ConvertedType::BSON,
-                parquet::ConvertedType::Interval => ConvertedType::INTERVAL,
             },
-        }
+        })
     }
 }
 
@@ -569,32 +723,28 @@ impl From<ConvertedType> for Option<parquet::ConvertedType> {
     fn from(value: ConvertedType) -> Self {
         match value {
             ConvertedType::NONE => None,
-            ConvertedType::UTF8 => Some(parquet::ConvertedType::Utf8),
-            ConvertedType::MAP => Some(parquet::ConvertedType::Map),
-            ConvertedType::MAP_KEY_VALUE => Some(parquet::ConvertedType::MapKeyValue),
-            ConvertedType::LIST => Some(parquet::ConvertedType::List),
-            ConvertedType::ENUM => Some(parquet::ConvertedType::Enum),
-            ConvertedType::DECIMAL => Some(parquet::ConvertedType::Decimal),
-            ConvertedType::DATE => Some(parquet::ConvertedType::Date),
-            ConvertedType::TIME_MILLIS => Some(parquet::ConvertedType::TimeMillis),
-            ConvertedType::TIME_MICROS => Some(parquet::ConvertedType::TimeMicros),
-            ConvertedType::TIMESTAMP_MILLIS => {
-                Some(parquet::ConvertedType::TimestampMillis)
-            }
-            ConvertedType::TIMESTAMP_MICROS => {
-                Some(parquet::ConvertedType::TimestampMicros)
-            }
-            ConvertedType::UINT_8 => Some(parquet::ConvertedType::Uint8),
-            ConvertedType::UINT_16 => Some(parquet::ConvertedType::Uint16),
-            ConvertedType::UINT_32 => Some(parquet::ConvertedType::Uint32),
-            ConvertedType::UINT_64 => Some(parquet::ConvertedType::Uint64),
-            ConvertedType::INT_8 => Some(parquet::ConvertedType::Int8),
-            ConvertedType::INT_16 => Some(parquet::ConvertedType::Int16),
-            ConvertedType::INT_32 => Some(parquet::ConvertedType::Int32),
-            ConvertedType::INT_64 => Some(parquet::ConvertedType::Int64),
-            ConvertedType::JSON => Some(parquet::ConvertedType::Json),
-            ConvertedType::BSON => Some(parquet::ConvertedType::Bson),
-            ConvertedType::INTERVAL => Some(parquet::ConvertedType::Interval),
+            ConvertedType::UTF8 => Some(parquet::ConvertedType::UTF8),
+            ConvertedType::MAP => Some(parquet::ConvertedType::MAP),
+            ConvertedType::MAP_KEY_VALUE => Some(parquet::ConvertedType::MAP_KEY_VALUE),
+            ConvertedType::LIST => Some(parquet::ConvertedType::LIST),
+            ConvertedType::ENUM => Some(parquet::ConvertedType::ENUM),
+            ConvertedType::DECIMAL => Some(parquet::ConvertedType::DECIMAL),
+            ConvertedType::DATE => Some(parquet::ConvertedType::DATE),
+            ConvertedType::TIME_MILLIS => Some(parquet::ConvertedType::TIME_MILLIS),
+            ConvertedType::TIME_MICROS => Some(parquet::ConvertedType::TIME_MICROS),
+            ConvertedType::TIMESTAMP_MILLIS => Some(parquet::ConvertedType::TIMESTAMP_MILLIS),
+            ConvertedType::TIMESTAMP_MICROS => Some(parquet::ConvertedType::TIMESTAMP_MICROS),
+            ConvertedType::UINT_8 => Some(parquet::ConvertedType::UINT_8),
+            ConvertedType::UINT_16 => Some(parquet::ConvertedType::UINT_16),
+            ConvertedType::UINT_32 => Some(parquet::ConvertedType::UINT_32),
+            ConvertedType::UINT_64 => Some(parquet::ConvertedType::UINT_64),
+            ConvertedType::INT_8 => Some(parquet::ConvertedType::INT_8),
+            ConvertedType::INT_16 => Some(parquet::ConvertedType::INT_16),
+            ConvertedType::INT_32 => Some(parquet::ConvertedType::INT_32),
+            ConvertedType::INT_64 => Some(parquet::ConvertedType::INT_64),
+            ConvertedType::JSON => Some(parquet::ConvertedType::JSON),
+            ConvertedType::BSON => Some(parquet::ConvertedType::BSON),
+            ConvertedType::INTERVAL => Some(parquet::ConvertedType::INTERVAL),
         }
     }
 }
@@ -630,6 +780,7 @@ impl From<parquet::LogicalType> for LogicalType {
             parquet::LogicalType::JSON(_) => LogicalType::Json,
             parquet::LogicalType::BSON(_) => LogicalType::Bson,
             parquet::LogicalType::UUID(_) => LogicalType::Uuid,
+            parquet::LogicalType::FLOAT16(_) => LogicalType::Float16,
         }
     }
 }
@@ -670,6 +821,7 @@ impl From<LogicalType> for parquet::LogicalType {
             LogicalType::Json => parquet::LogicalType::JSON(Default::default()),
             LogicalType::Bson => parquet::LogicalType::BSON(Default::default()),
             LogicalType::Uuid => parquet::LogicalType::UUID(Default::default()),
+            LogicalType::Float16 => parquet::LogicalType::FLOAT16(Default::default()),
         }
     }
 }
@@ -715,12 +867,13 @@ impl From<Option<LogicalType>> for ConvertedType {
                     (16, false) => ConvertedType::UINT_16,
                     (32, false) => ConvertedType::UINT_32,
                     (64, false) => ConvertedType::UINT_64,
-                    t => panic!("Integer type {:?} is not supported", t),
+                    t => panic!("Integer type {t:?} is not supported"),
                 },
-                LogicalType::Unknown => ConvertedType::NONE,
                 LogicalType::Json => ConvertedType::JSON,
                 LogicalType::Bson => ConvertedType::BSON,
-                LogicalType::Uuid => ConvertedType::NONE,
+                LogicalType::Uuid | LogicalType::Float16 | LogicalType::Unknown => {
+                    ConvertedType::NONE
+                }
             },
             None => ConvertedType::NONE,
         }
@@ -730,22 +883,30 @@ impl From<Option<LogicalType>> for ConvertedType {
 // ----------------------------------------------------------------------
 // parquet::FieldRepetitionType <=> Repetition conversion
 
-impl From<parquet::FieldRepetitionType> for Repetition {
-    fn from(value: parquet::FieldRepetitionType) -> Self {
-        match value {
-            parquet::FieldRepetitionType::Required => Repetition::REQUIRED,
-            parquet::FieldRepetitionType::Optional => Repetition::OPTIONAL,
-            parquet::FieldRepetitionType::Repeated => Repetition::REPEATED,
-        }
+impl TryFrom<parquet::FieldRepetitionType> for Repetition {
+    type Error = ParquetError;
+
+    fn try_from(value: parquet::FieldRepetitionType) -> Result<Self> {
+        Ok(match value {
+            parquet::FieldRepetitionType::REQUIRED => Repetition::REQUIRED,
+            parquet::FieldRepetitionType::OPTIONAL => Repetition::OPTIONAL,
+            parquet::FieldRepetitionType::REPEATED => Repetition::REPEATED,
+            _ => {
+                return Err(general_err!(
+                    "unexpected parquet repetition type: {}",
+                    value.0
+                ))
+            }
+        })
     }
 }
 
 impl From<Repetition> for parquet::FieldRepetitionType {
     fn from(value: Repetition) -> Self {
         match value {
-            Repetition::REQUIRED => parquet::FieldRepetitionType::Required,
-            Repetition::OPTIONAL => parquet::FieldRepetitionType::Optional,
-            Repetition::REPEATED => parquet::FieldRepetitionType::Repeated,
+            Repetition::REQUIRED => parquet::FieldRepetitionType::REQUIRED,
+            Repetition::OPTIONAL => parquet::FieldRepetitionType::OPTIONAL,
+            Repetition::REPEATED => parquet::FieldRepetitionType::REPEATED,
         }
     }
 }
@@ -753,34 +914,39 @@ impl From<Repetition> for parquet::FieldRepetitionType {
 // ----------------------------------------------------------------------
 // parquet::Encoding <=> Encoding conversion
 
-impl From<parquet::Encoding> for Encoding {
-    fn from(value: parquet::Encoding) -> Self {
-        match value {
-            parquet::Encoding::Plain => Encoding::PLAIN,
-            parquet::Encoding::PlainDictionary => Encoding::PLAIN_DICTIONARY,
-            parquet::Encoding::Rle => Encoding::RLE,
-            parquet::Encoding::BitPacked => Encoding::BIT_PACKED,
-            parquet::Encoding::DeltaBinaryPacked => Encoding::DELTA_BINARY_PACKED,
-            parquet::Encoding::DeltaLengthByteArray => Encoding::DELTA_LENGTH_BYTE_ARRAY,
-            parquet::Encoding::DeltaByteArray => Encoding::DELTA_BYTE_ARRAY,
-            parquet::Encoding::RleDictionary => Encoding::RLE_DICTIONARY,
-            parquet::Encoding::ByteStreamSplit => Encoding::BYTE_STREAM_SPLIT,
-        }
+impl TryFrom<parquet::Encoding> for Encoding {
+    type Error = ParquetError;
+
+    fn try_from(value: parquet::Encoding) -> Result<Self> {
+        Ok(match value {
+            parquet::Encoding::PLAIN => Encoding::PLAIN,
+            parquet::Encoding::PLAIN_DICTIONARY => Encoding::PLAIN_DICTIONARY,
+            parquet::Encoding::RLE => Encoding::RLE,
+            #[allow(deprecated)]
+            parquet::Encoding::BIT_PACKED => Encoding::BIT_PACKED,
+            parquet::Encoding::DELTA_BINARY_PACKED => Encoding::DELTA_BINARY_PACKED,
+            parquet::Encoding::DELTA_LENGTH_BYTE_ARRAY => Encoding::DELTA_LENGTH_BYTE_ARRAY,
+            parquet::Encoding::DELTA_BYTE_ARRAY => Encoding::DELTA_BYTE_ARRAY,
+            parquet::Encoding::RLE_DICTIONARY => Encoding::RLE_DICTIONARY,
+            parquet::Encoding::BYTE_STREAM_SPLIT => Encoding::BYTE_STREAM_SPLIT,
+            _ => return Err(general_err!("unexpected parquet encoding: {}", value.0)),
+        })
     }
 }
 
 impl From<Encoding> for parquet::Encoding {
     fn from(value: Encoding) -> Self {
         match value {
-            Encoding::PLAIN => parquet::Encoding::Plain,
-            Encoding::PLAIN_DICTIONARY => parquet::Encoding::PlainDictionary,
-            Encoding::RLE => parquet::Encoding::Rle,
-            Encoding::BIT_PACKED => parquet::Encoding::BitPacked,
-            Encoding::DELTA_BINARY_PACKED => parquet::Encoding::DeltaBinaryPacked,
-            Encoding::DELTA_LENGTH_BYTE_ARRAY => parquet::Encoding::DeltaLengthByteArray,
-            Encoding::DELTA_BYTE_ARRAY => parquet::Encoding::DeltaByteArray,
-            Encoding::RLE_DICTIONARY => parquet::Encoding::RleDictionary,
-            Encoding::BYTE_STREAM_SPLIT => parquet::Encoding::ByteStreamSplit,
+            Encoding::PLAIN => parquet::Encoding::PLAIN,
+            Encoding::PLAIN_DICTIONARY => parquet::Encoding::PLAIN_DICTIONARY,
+            Encoding::RLE => parquet::Encoding::RLE,
+            #[allow(deprecated)]
+            Encoding::BIT_PACKED => parquet::Encoding::BIT_PACKED,
+            Encoding::DELTA_BINARY_PACKED => parquet::Encoding::DELTA_BINARY_PACKED,
+            Encoding::DELTA_LENGTH_BYTE_ARRAY => parquet::Encoding::DELTA_LENGTH_BYTE_ARRAY,
+            Encoding::DELTA_BYTE_ARRAY => parquet::Encoding::DELTA_BYTE_ARRAY,
+            Encoding::RLE_DICTIONARY => parquet::Encoding::RLE_DICTIONARY,
+            Encoding::BYTE_STREAM_SPLIT => parquet::Encoding::BYTE_STREAM_SPLIT,
         }
     }
 }
@@ -788,30 +954,40 @@ impl From<Encoding> for parquet::Encoding {
 // ----------------------------------------------------------------------
 // parquet::CompressionCodec <=> Compression conversion
 
-impl From<parquet::CompressionCodec> for Compression {
-    fn from(value: parquet::CompressionCodec) -> Self {
-        match value {
-            parquet::CompressionCodec::Uncompressed => Compression::UNCOMPRESSED,
-            parquet::CompressionCodec::Snappy => Compression::SNAPPY,
-            parquet::CompressionCodec::Gzip => Compression::GZIP,
-            parquet::CompressionCodec::Lzo => Compression::LZO,
-            parquet::CompressionCodec::Brotli => Compression::BROTLI,
-            parquet::CompressionCodec::Lz4 => Compression::LZ4,
-            parquet::CompressionCodec::Zstd => Compression::ZSTD,
-        }
+impl TryFrom<parquet::CompressionCodec> for Compression {
+    type Error = ParquetError;
+
+    fn try_from(value: parquet::CompressionCodec) -> Result<Self> {
+        Ok(match value {
+            parquet::CompressionCodec::UNCOMPRESSED => Compression::UNCOMPRESSED,
+            parquet::CompressionCodec::SNAPPY => Compression::SNAPPY,
+            parquet::CompressionCodec::GZIP => Compression::GZIP(Default::default()),
+            parquet::CompressionCodec::LZO => Compression::LZO,
+            parquet::CompressionCodec::BROTLI => Compression::BROTLI(Default::default()),
+            parquet::CompressionCodec::LZ4 => Compression::LZ4,
+            parquet::CompressionCodec::ZSTD => Compression::ZSTD(Default::default()),
+            parquet::CompressionCodec::LZ4_RAW => Compression::LZ4_RAW,
+            _ => {
+                return Err(general_err!(
+                    "unexpected parquet compression codec: {}",
+                    value.0
+                ))
+            }
+        })
     }
 }
 
 impl From<Compression> for parquet::CompressionCodec {
     fn from(value: Compression) -> Self {
         match value {
-            Compression::UNCOMPRESSED => parquet::CompressionCodec::Uncompressed,
-            Compression::SNAPPY => parquet::CompressionCodec::Snappy,
-            Compression::GZIP => parquet::CompressionCodec::Gzip,
-            Compression::LZO => parquet::CompressionCodec::Lzo,
-            Compression::BROTLI => parquet::CompressionCodec::Brotli,
-            Compression::LZ4 => parquet::CompressionCodec::Lz4,
-            Compression::ZSTD => parquet::CompressionCodec::Zstd,
+            Compression::UNCOMPRESSED => parquet::CompressionCodec::UNCOMPRESSED,
+            Compression::SNAPPY => parquet::CompressionCodec::SNAPPY,
+            Compression::GZIP(_) => parquet::CompressionCodec::GZIP,
+            Compression::LZO => parquet::CompressionCodec::LZO,
+            Compression::BROTLI(_) => parquet::CompressionCodec::BROTLI,
+            Compression::LZ4 => parquet::CompressionCodec::LZ4,
+            Compression::ZSTD(_) => parquet::CompressionCodec::ZSTD,
+            Compression::LZ4_RAW => parquet::CompressionCodec::LZ4_RAW,
         }
     }
 }
@@ -819,24 +995,27 @@ impl From<Compression> for parquet::CompressionCodec {
 // ----------------------------------------------------------------------
 // parquet::PageType <=> PageType conversion
 
-impl From<parquet::PageType> for PageType {
-    fn from(value: parquet::PageType) -> Self {
-        match value {
-            parquet::PageType::DataPage => PageType::DATA_PAGE,
-            parquet::PageType::IndexPage => PageType::INDEX_PAGE,
-            parquet::PageType::DictionaryPage => PageType::DICTIONARY_PAGE,
-            parquet::PageType::DataPageV2 => PageType::DATA_PAGE_V2,
-        }
+impl TryFrom<parquet::PageType> for PageType {
+    type Error = ParquetError;
+
+    fn try_from(value: parquet::PageType) -> Result<Self> {
+        Ok(match value {
+            parquet::PageType::DATA_PAGE => PageType::DATA_PAGE,
+            parquet::PageType::INDEX_PAGE => PageType::INDEX_PAGE,
+            parquet::PageType::DICTIONARY_PAGE => PageType::DICTIONARY_PAGE,
+            parquet::PageType::DATA_PAGE_V2 => PageType::DATA_PAGE_V2,
+            _ => return Err(general_err!("unexpected parquet page type: {}", value.0)),
+        })
     }
 }
 
 impl From<PageType> for parquet::PageType {
     fn from(value: PageType) -> Self {
         match value {
-            PageType::DATA_PAGE => parquet::PageType::DataPage,
-            PageType::INDEX_PAGE => parquet::PageType::IndexPage,
-            PageType::DICTIONARY_PAGE => parquet::PageType::DictionaryPage,
-            PageType::DATA_PAGE_V2 => parquet::PageType::DataPageV2,
+            PageType::DATA_PAGE => parquet::PageType::DATA_PAGE,
+            PageType::INDEX_PAGE => parquet::PageType::INDEX_PAGE,
+            PageType::DICTIONARY_PAGE => parquet::PageType::DICTIONARY_PAGE,
+            PageType::DATA_PAGE_V2 => parquet::PageType::DATA_PAGE_V2,
         }
     }
 }
@@ -847,12 +1026,12 @@ impl From<PageType> for parquet::PageType {
 impl str::FromStr for Repetition {
     type Err = ParquetError;
 
-    fn from_str(s: &str) -> result::Result<Self, Self::Err> {
+    fn from_str(s: &str) -> Result<Self> {
         match s {
             "REQUIRED" => Ok(Repetition::REQUIRED),
             "OPTIONAL" => Ok(Repetition::OPTIONAL),
             "REPEATED" => Ok(Repetition::REPEATED),
-            other => Err(general_err!("Invalid repetition {}", other)),
+            other => Err(general_err!("Invalid parquet repetition {}", other)),
         }
     }
 }
@@ -860,7 +1039,7 @@ impl str::FromStr for Repetition {
 impl str::FromStr for Type {
     type Err = ParquetError;
 
-    fn from_str(s: &str) -> result::Result<Self, Self::Err> {
+    fn from_str(s: &str) -> Result<Self> {
         match s {
             "BOOLEAN" => Ok(Type::BOOLEAN),
             "INT32" => Ok(Type::INT32),
@@ -870,7 +1049,7 @@ impl str::FromStr for Type {
             "DOUBLE" => Ok(Type::DOUBLE),
             "BYTE_ARRAY" | "BINARY" => Ok(Type::BYTE_ARRAY),
             "FIXED_LEN_BYTE_ARRAY" => Ok(Type::FIXED_LEN_BYTE_ARRAY),
-            other => Err(general_err!("Invalid type {}", other)),
+            other => Err(general_err!("Invalid parquet type {}", other)),
         }
     }
 }
@@ -878,7 +1057,7 @@ impl str::FromStr for Type {
 impl str::FromStr for ConvertedType {
     type Err = ParquetError;
 
-    fn from_str(s: &str) -> result::Result<Self, Self::Err> {
+    fn from_str(s: &str) -> Result<Self> {
         match s {
             "NONE" => Ok(ConvertedType::NONE),
             "UTF8" => Ok(ConvertedType::UTF8),
@@ -903,7 +1082,7 @@ impl str::FromStr for ConvertedType {
             "JSON" => Ok(ConvertedType::JSON),
             "BSON" => Ok(ConvertedType::BSON),
             "INTERVAL" => Ok(ConvertedType::INTERVAL),
-            other => Err(general_err!("Invalid converted type {}", other)),
+            other => Err(general_err!("Invalid parquet converted type {}", other)),
         }
     }
 }
@@ -911,7 +1090,7 @@ impl str::FromStr for ConvertedType {
 impl str::FromStr for LogicalType {
     type Err = ParquetError;
 
-    fn from_str(s: &str) -> result::Result<Self, Self::Err> {
+    fn from_str(s: &str) -> Result<Self> {
         match s {
             // The type is a placeholder that gets updated elsewhere
             "INTEGER" => Ok(LogicalType::Integer {
@@ -939,13 +1118,17 @@ impl str::FromStr for LogicalType {
             "BSON" => Ok(LogicalType::Bson),
             "UUID" => Ok(LogicalType::Uuid),
             "UNKNOWN" => Ok(LogicalType::Unknown),
-            "INTERVAL" => Err(general_err!("Interval logical type not yet supported")),
-            other => Err(general_err!("Invalid logical type {}", other)),
+            "INTERVAL" => Err(general_err!(
+                "Interval parquet logical type not yet supported"
+            )),
+            "FLOAT16" => Ok(LogicalType::Float16),
+            other => Err(general_err!("Invalid parquet logical type {}", other)),
         }
     }
 }
 
 #[cfg(test)]
+#[allow(deprecated)] // allow BIT_PACKED encoding for the whole test module
 mod tests {
     use super::*;
 
@@ -966,30 +1149,36 @@ mod tests {
 
     #[test]
     fn test_from_type() {
-        assert_eq!(Type::from(parquet::Type::Boolean), Type::BOOLEAN);
-        assert_eq!(Type::from(parquet::Type::Int32), Type::INT32);
-        assert_eq!(Type::from(parquet::Type::Int64), Type::INT64);
-        assert_eq!(Type::from(parquet::Type::Int96), Type::INT96);
-        assert_eq!(Type::from(parquet::Type::Float), Type::FLOAT);
-        assert_eq!(Type::from(parquet::Type::Double), Type::DOUBLE);
-        assert_eq!(Type::from(parquet::Type::ByteArray), Type::BYTE_ARRAY);
-        assert_eq!(
-            Type::from(parquet::Type::FixedLenByteArray),
+        assert_eq!(
+            Type::try_from(parquet::Type::BOOLEAN).unwrap(),
+            Type::BOOLEAN
+        );
+        assert_eq!(Type::try_from(parquet::Type::INT32).unwrap(), Type::INT32);
+        assert_eq!(Type::try_from(parquet::Type::INT64).unwrap(), Type::INT64);
+        assert_eq!(Type::try_from(parquet::Type::INT96).unwrap(), Type::INT96);
+        assert_eq!(Type::try_from(parquet::Type::FLOAT).unwrap(), Type::FLOAT);
+        assert_eq!(Type::try_from(parquet::Type::DOUBLE).unwrap(), Type::DOUBLE);
+        assert_eq!(
+            Type::try_from(parquet::Type::BYTE_ARRAY).unwrap(),
+            Type::BYTE_ARRAY
+        );
+        assert_eq!(
+            Type::try_from(parquet::Type::FIXED_LEN_BYTE_ARRAY).unwrap(),
             Type::FIXED_LEN_BYTE_ARRAY
         );
     }
 
     #[test]
     fn test_into_type() {
-        assert_eq!(parquet::Type::Boolean, Type::BOOLEAN.into());
-        assert_eq!(parquet::Type::Int32, Type::INT32.into());
-        assert_eq!(parquet::Type::Int64, Type::INT64.into());
-        assert_eq!(parquet::Type::Int96, Type::INT96.into());
-        assert_eq!(parquet::Type::Float, Type::FLOAT.into());
-        assert_eq!(parquet::Type::Double, Type::DOUBLE.into());
-        assert_eq!(parquet::Type::ByteArray, Type::BYTE_ARRAY.into());
-        assert_eq!(
-            parquet::Type::FixedLenByteArray,
+        assert_eq!(parquet::Type::BOOLEAN, Type::BOOLEAN.into());
+        assert_eq!(parquet::Type::INT32, Type::INT32.into());
+        assert_eq!(parquet::Type::INT64, Type::INT64.into());
+        assert_eq!(parquet::Type::INT96, Type::INT96.into());
+        assert_eq!(parquet::Type::FLOAT, Type::FLOAT.into());
+        assert_eq!(parquet::Type::DOUBLE, Type::DOUBLE.into());
+        assert_eq!(parquet::Type::BYTE_ARRAY, Type::BYTE_ARRAY.into());
+        assert_eq!(
+            parquet::Type::FIXED_LEN_BYTE_ARRAY,
             Type::FIXED_LEN_BYTE_ARRAY.into()
         );
     }
@@ -1072,97 +1261,100 @@ mod tests {
     #[test]
     fn test_from_converted_type() {
         let parquet_conv_none: Option<parquet::ConvertedType> = None;
-        assert_eq!(ConvertedType::from(parquet_conv_none), ConvertedType::NONE);
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Utf8)),
+            ConvertedType::try_from(parquet_conv_none).unwrap(),
+            ConvertedType::NONE
+        );
+        assert_eq!(
+            ConvertedType::try_from(Some(parquet::ConvertedType::UTF8)).unwrap(),
             ConvertedType::UTF8
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Map)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::MAP)).unwrap(),
             ConvertedType::MAP
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::MapKeyValue)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::MAP_KEY_VALUE)).unwrap(),
             ConvertedType::MAP_KEY_VALUE
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::List)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::LIST)).unwrap(),
             ConvertedType::LIST
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Enum)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::ENUM)).unwrap(),
             ConvertedType::ENUM
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Decimal)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::DECIMAL)).unwrap(),
             ConvertedType::DECIMAL
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Date)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::DATE)).unwrap(),
             ConvertedType::DATE
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::TimeMillis)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::TIME_MILLIS)).unwrap(),
             ConvertedType::TIME_MILLIS
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::TimeMicros)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::TIME_MICROS)).unwrap(),
             ConvertedType::TIME_MICROS
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::TimestampMillis)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::TIMESTAMP_MILLIS)).unwrap(),
             ConvertedType::TIMESTAMP_MILLIS
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::TimestampMicros)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::TIMESTAMP_MICROS)).unwrap(),
             ConvertedType::TIMESTAMP_MICROS
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Uint8)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::UINT_8)).unwrap(),
             ConvertedType::UINT_8
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Uint16)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::UINT_16)).unwrap(),
             ConvertedType::UINT_16
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Uint32)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::UINT_32)).unwrap(),
             ConvertedType::UINT_32
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Uint64)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::UINT_64)).unwrap(),
             ConvertedType::UINT_64
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Int8)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::INT_8)).unwrap(),
             ConvertedType::INT_8
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Int16)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::INT_16)).unwrap(),
             ConvertedType::INT_16
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Int32)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::INT_32)).unwrap(),
             ConvertedType::INT_32
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Int64)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::INT_64)).unwrap(),
             ConvertedType::INT_64
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Json)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::JSON)).unwrap(),
             ConvertedType::JSON
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Bson)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::BSON)).unwrap(),
             ConvertedType::BSON
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Interval)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::INTERVAL)).unwrap(),
             ConvertedType::INTERVAL
         );
         assert_eq!(
-            ConvertedType::from(Some(parquet::ConvertedType::Decimal)),
+            ConvertedType::try_from(Some(parquet::ConvertedType::DECIMAL)).unwrap(),
             ConvertedType::DECIMAL
         )
     }
@@ -1172,92 +1364,92 @@ mod tests {
         let converted_type: Option<parquet::ConvertedType> = None;
         assert_eq!(converted_type, ConvertedType::NONE.into());
         assert_eq!(
-            Some(parquet::ConvertedType::Utf8),
+            Some(parquet::ConvertedType::UTF8),
             ConvertedType::UTF8.into()
         );
-        assert_eq!(Some(parquet::ConvertedType::Map), ConvertedType::MAP.into());
+        assert_eq!(Some(parquet::ConvertedType::MAP), ConvertedType::MAP.into());
         assert_eq!(
-            Some(parquet::ConvertedType::MapKeyValue),
+            Some(parquet::ConvertedType::MAP_KEY_VALUE),
             ConvertedType::MAP_KEY_VALUE.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::List),
+            Some(parquet::ConvertedType::LIST),
             ConvertedType::LIST.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Enum),
+            Some(parquet::ConvertedType::ENUM),
             ConvertedType::ENUM.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Decimal),
+            Some(parquet::ConvertedType::DECIMAL),
             ConvertedType::DECIMAL.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Date),
+            Some(parquet::ConvertedType::DATE),
             ConvertedType::DATE.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::TimeMillis),
+            Some(parquet::ConvertedType::TIME_MILLIS),
             ConvertedType::TIME_MILLIS.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::TimeMicros),
+            Some(parquet::ConvertedType::TIME_MICROS),
             ConvertedType::TIME_MICROS.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::TimestampMillis),
+            Some(parquet::ConvertedType::TIMESTAMP_MILLIS),
             ConvertedType::TIMESTAMP_MILLIS.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::TimestampMicros),
+            Some(parquet::ConvertedType::TIMESTAMP_MICROS),
             ConvertedType::TIMESTAMP_MICROS.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Uint8),
+            Some(parquet::ConvertedType::UINT_8),
             ConvertedType::UINT_8.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Uint16),
+            Some(parquet::ConvertedType::UINT_16),
             ConvertedType::UINT_16.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Uint32),
+            Some(parquet::ConvertedType::UINT_32),
             ConvertedType::UINT_32.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Uint64),
+            Some(parquet::ConvertedType::UINT_64),
             ConvertedType::UINT_64.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Int8),
+            Some(parquet::ConvertedType::INT_8),
             ConvertedType::INT_8.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Int16),
+            Some(parquet::ConvertedType::INT_16),
             ConvertedType::INT_16.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Int32),
+            Some(parquet::ConvertedType::INT_32),
             ConvertedType::INT_32.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Int64),
+            Some(parquet::ConvertedType::INT_64),
             ConvertedType::INT_64.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Json),
+            Some(parquet::ConvertedType::JSON),
             ConvertedType::JSON.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Bson),
+            Some(parquet::ConvertedType::BSON),
             ConvertedType::BSON.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Interval),
+            Some(parquet::ConvertedType::INTERVAL),
             ConvertedType::INTERVAL.into()
         );
         assert_eq!(
-            Some(parquet::ConvertedType::Decimal),
+            Some(parquet::ConvertedType::DECIMAL),
             ConvertedType::DECIMAL.into()
         )
     }
@@ -1575,6 +1767,10 @@ mod tests {
             ConvertedType::from(Some(LogicalType::Enum)),
             ConvertedType::ENUM
         );
+        assert_eq!(
+            ConvertedType::from(Some(LogicalType::Float16)),
+            ConvertedType::NONE
+        );
         assert_eq!(
             ConvertedType::from(Some(LogicalType::Unknown)),
             ConvertedType::NONE
@@ -1591,15 +1787,15 @@ mod tests {
     #[test]
     fn test_from_repetition() {
         assert_eq!(
-            Repetition::from(parquet::FieldRepetitionType::Required),
+            Repetition::try_from(parquet::FieldRepetitionType::REQUIRED).unwrap(),
             Repetition::REQUIRED
         );
         assert_eq!(
-            Repetition::from(parquet::FieldRepetitionType::Optional),
+            Repetition::try_from(parquet::FieldRepetitionType::OPTIONAL).unwrap(),
             Repetition::OPTIONAL
         );
         assert_eq!(
-            Repetition::from(parquet::FieldRepetitionType::Repeated),
+            Repetition::try_from(parquet::FieldRepetitionType::REPEATED).unwrap(),
             Repetition::REPEATED
         );
     }
@@ -1607,15 +1803,15 @@ mod tests {
     #[test]
     fn test_into_repetition() {
         assert_eq!(
-            parquet::FieldRepetitionType::Required,
+            parquet::FieldRepetitionType::REQUIRED,
             Repetition::REQUIRED.into()
         );
         assert_eq!(
-            parquet::FieldRepetitionType::Optional,
+            parquet::FieldRepetitionType::OPTIONAL,
             Repetition::OPTIONAL.into()
         );
         assert_eq!(
-            parquet::FieldRepetitionType::Repeated,
+            parquet::FieldRepetitionType::REPEATED,
             Repetition::REPEATED.into()
         );
     }
@@ -1665,49 +1861,55 @@ mod tests {
 
     #[test]
     fn test_from_encoding() {
-        assert_eq!(Encoding::from(parquet::Encoding::Plain), Encoding::PLAIN);
         assert_eq!(
-            Encoding::from(parquet::Encoding::PlainDictionary),
+            Encoding::try_from(parquet::Encoding::PLAIN).unwrap(),
+            Encoding::PLAIN
+        );
+        assert_eq!(
+            Encoding::try_from(parquet::Encoding::PLAIN_DICTIONARY).unwrap(),
             Encoding::PLAIN_DICTIONARY
         );
-        assert_eq!(Encoding::from(parquet::Encoding::Rle), Encoding::RLE);
         assert_eq!(
-            Encoding::from(parquet::Encoding::BitPacked),
+            Encoding::try_from(parquet::Encoding::RLE).unwrap(),
+            Encoding::RLE
+        );
+        assert_eq!(
+            Encoding::try_from(parquet::Encoding::BIT_PACKED).unwrap(),
             Encoding::BIT_PACKED
         );
         assert_eq!(
-            Encoding::from(parquet::Encoding::DeltaBinaryPacked),
+            Encoding::try_from(parquet::Encoding::DELTA_BINARY_PACKED).unwrap(),
             Encoding::DELTA_BINARY_PACKED
         );
         assert_eq!(
-            Encoding::from(parquet::Encoding::DeltaLengthByteArray),
+            Encoding::try_from(parquet::Encoding::DELTA_LENGTH_BYTE_ARRAY).unwrap(),
             Encoding::DELTA_LENGTH_BYTE_ARRAY
         );
         assert_eq!(
-            Encoding::from(parquet::Encoding::DeltaByteArray),
+            Encoding::try_from(parquet::Encoding::DELTA_BYTE_ARRAY).unwrap(),
             Encoding::DELTA_BYTE_ARRAY
         );
     }
 
     #[test]
     fn test_into_encoding() {
-        assert_eq!(parquet::Encoding::Plain, Encoding::PLAIN.into());
+        assert_eq!(parquet::Encoding::PLAIN, Encoding::PLAIN.into());
         assert_eq!(
-            parquet::Encoding::PlainDictionary,
+            parquet::Encoding::PLAIN_DICTIONARY,
             Encoding::PLAIN_DICTIONARY.into()
         );
-        assert_eq!(parquet::Encoding::Rle, Encoding::RLE.into());
-        assert_eq!(parquet::Encoding::BitPacked, Encoding::BIT_PACKED.into());
+        assert_eq!(parquet::Encoding::RLE, Encoding::RLE.into());
+        assert_eq!(parquet::Encoding::BIT_PACKED, Encoding::BIT_PACKED.into());
         assert_eq!(
-            parquet::Encoding::DeltaBinaryPacked,
+            parquet::Encoding::DELTA_BINARY_PACKED,
             Encoding::DELTA_BINARY_PACKED.into()
         );
         assert_eq!(
-            parquet::Encoding::DeltaLengthByteArray,
+            parquet::Encoding::DELTA_LENGTH_BYTE_ARRAY,
             Encoding::DELTA_LENGTH_BYTE_ARRAY.into()
         );
         assert_eq!(
-            parquet::Encoding::DeltaByteArray,
+            parquet::Encoding::DELTA_BYTE_ARRAY,
             Encoding::DELTA_BYTE_ARRAY.into()
         );
     }
@@ -1716,63 +1918,78 @@ mod tests {
     fn test_display_compression() {
         assert_eq!(Compression::UNCOMPRESSED.to_string(), "UNCOMPRESSED");
         assert_eq!(Compression::SNAPPY.to_string(), "SNAPPY");
-        assert_eq!(Compression::GZIP.to_string(), "GZIP");
+        assert_eq!(
+            Compression::GZIP(Default::default()).to_string(),
+            "GZIP(GzipLevel(6))"
+        );
         assert_eq!(Compression::LZO.to_string(), "LZO");
-        assert_eq!(Compression::BROTLI.to_string(), "BROTLI");
+        assert_eq!(
+            Compression::BROTLI(Default::default()).to_string(),
+            "BROTLI(BrotliLevel(1))"
+        );
         assert_eq!(Compression::LZ4.to_string(), "LZ4");
-        assert_eq!(Compression::ZSTD.to_string(), "ZSTD");
+        assert_eq!(
+            Compression::ZSTD(Default::default()).to_string(),
+            "ZSTD(ZstdLevel(1))"
+        );
     }
 
     #[test]
     fn test_from_compression() {
         assert_eq!(
-            Compression::from(parquet::CompressionCodec::Uncompressed),
+            Compression::try_from(parquet::CompressionCodec::UNCOMPRESSED).unwrap(),
             Compression::UNCOMPRESSED
         );
         assert_eq!(
-            Compression::from(parquet::CompressionCodec::Snappy),
+            Compression::try_from(parquet::CompressionCodec::SNAPPY).unwrap(),
             Compression::SNAPPY
         );
         assert_eq!(
-            Compression::from(parquet::CompressionCodec::Gzip),
-            Compression::GZIP
+            Compression::try_from(parquet::CompressionCodec::GZIP).unwrap(),
+            Compression::GZIP(Default::default())
         );
         assert_eq!(
-            Compression::from(parquet::CompressionCodec::Lzo),
+            Compression::try_from(parquet::CompressionCodec::LZO).unwrap(),
             Compression::LZO
         );
         assert_eq!(
-            Compression::from(parquet::CompressionCodec::Brotli),
-            Compression::BROTLI
+            Compression::try_from(parquet::CompressionCodec::BROTLI).unwrap(),
+            Compression::BROTLI(Default::default())
         );
         assert_eq!(
-            Compression::from(parquet::CompressionCodec::Lz4),
+            Compression::try_from(parquet::CompressionCodec::LZ4).unwrap(),
             Compression::LZ4
         );
         assert_eq!(
-            Compression::from(parquet::CompressionCodec::Zstd),
-            Compression::ZSTD
+            Compression::try_from(parquet::CompressionCodec::ZSTD).unwrap(),
+            Compression::ZSTD(Default::default())
         );
     }
 
     #[test]
     fn test_into_compression() {
         assert_eq!(
-            parquet::CompressionCodec::Uncompressed,
+            parquet::CompressionCodec::UNCOMPRESSED,
             Compression::UNCOMPRESSED.into()
         );
         assert_eq!(
-            parquet::CompressionCodec::Snappy,
+            parquet::CompressionCodec::SNAPPY,
             Compression::SNAPPY.into()
         );
-        assert_eq!(parquet::CompressionCodec::Gzip, Compression::GZIP.into());
-        assert_eq!(parquet::CompressionCodec::Lzo, Compression::LZO.into());
         assert_eq!(
-            parquet::CompressionCodec::Brotli,
-            Compression::BROTLI.into()
+            parquet::CompressionCodec::GZIP,
+            Compression::GZIP(Default::default()).into()
+        );
+        assert_eq!(parquet::CompressionCodec::LZO, Compression::LZO.into());
+        assert_eq!(
+            parquet::CompressionCodec::BROTLI,
+            Compression::BROTLI(Default::default()).into()
+        );
+        assert_eq!(parquet::CompressionCodec::LZ4, Compression::LZ4.into());
+        assert_eq!(
+            parquet::CompressionCodec::ZSTD,
+            Compression::ZSTD(Default::default()).into()
         );
-        assert_eq!(parquet::CompressionCodec::Lz4, Compression::LZ4.into());
-        assert_eq!(parquet::CompressionCodec::Zstd, Compression::ZSTD.into());
     }
 
     #[test]
@@ -1786,32 +2003,35 @@ mod tests {
     #[test]
     fn test_from_page_type() {
         assert_eq!(
-            PageType::from(parquet::PageType::DataPage),
+            PageType::try_from(parquet::PageType::DATA_PAGE).unwrap(),
             PageType::DATA_PAGE
         );
         assert_eq!(
-            PageType::from(parquet::PageType::IndexPage),
+            PageType::try_from(parquet::PageType::INDEX_PAGE).unwrap(),
             PageType::INDEX_PAGE
         );
         assert_eq!(
-            PageType::from(parquet::PageType::DictionaryPage),
+            PageType::try_from(parquet::PageType::DICTIONARY_PAGE).unwrap(),
             PageType::DICTIONARY_PAGE
         );
         assert_eq!(
-            PageType::from(parquet::PageType::DataPageV2),
+            PageType::try_from(parquet::PageType::DATA_PAGE_V2).unwrap(),
             PageType::DATA_PAGE_V2
         );
     }
 
     #[test]
     fn test_into_page_type() {
-        assert_eq!(parquet::PageType::DataPage, PageType::DATA_PAGE.into());
-        assert_eq!(parquet::PageType::IndexPage, PageType::INDEX_PAGE.into());
+        assert_eq!(parquet::PageType::DATA_PAGE, PageType::DATA_PAGE.into());
+        assert_eq!(parquet::PageType::INDEX_PAGE, PageType::INDEX_PAGE.into());
         assert_eq!(
-            parquet::PageType::DictionaryPage,
+            parquet::PageType::DICTIONARY_PAGE,
             PageType::DICTIONARY_PAGE.into()
         );
-        assert_eq!(parquet::PageType::DataPageV2, PageType::DATA_PAGE_V2.into());
+        assert_eq!(
+            parquet::PageType::DATA_PAGE_V2,
+            PageType::DATA_PAGE_V2.into()
+        );
     }
 
     #[test]
@@ -1845,11 +2065,7 @@ mod tests {
         fn check_sort_order(types: Vec<LogicalType>, expected_order: SortOrder) {
             for tpe in types {
                 assert_eq!(
-                    ColumnOrder::get_sort_order(
-                        Some(tpe),
-                        ConvertedType::NONE,
-                        Type::BYTE_ARRAY
-                    ),
+                    ColumnOrder::get_sort_order(Some(tpe), ConvertedType::NONE, Type::BYTE_ARRAY),
                     expected_order
                 );
             }
@@ -1928,6 +2144,7 @@ mod tests {
                 is_adjusted_to_u_t_c: true,
                 unit: TimeUnit::NANOS(Default::default()),
             },
+            LogicalType::Float16,
         ];
         check_sort_order(signed, SortOrder::SIGNED);
 
@@ -1937,7 +2154,7 @@ mod tests {
     }
 
     #[test]
-    fn test_column_order_get_coverted_type_sort_order() {
+    fn test_column_order_get_converted_type_sort_order() {
         // Helper to check the order in a list of values.
         // Only converted type is checked.
         fn check_sort_order(types: Vec<ConvertedType>, expected_order: SortOrder) {
@@ -2044,4 +2261,81 @@ mod tests {
         );
         assert_eq!(ColumnOrder::UNDEFINED.sort_order(), SortOrder::SIGNED);
     }
+
+    #[test]
+    fn test_parse_encoding() {
+        let mut encoding: Encoding = "PLAIN".parse().unwrap();
+        assert_eq!(encoding, Encoding::PLAIN);
+        encoding = "PLAIN_DICTIONARY".parse().unwrap();
+        assert_eq!(encoding, Encoding::PLAIN_DICTIONARY);
+        encoding = "RLE".parse().unwrap();
+        assert_eq!(encoding, Encoding::RLE);
+        encoding = "BIT_PACKED".parse().unwrap();
+        assert_eq!(encoding, Encoding::BIT_PACKED);
+        encoding = "DELTA_BINARY_PACKED".parse().unwrap();
+        assert_eq!(encoding, Encoding::DELTA_BINARY_PACKED);
+        encoding = "DELTA_LENGTH_BYTE_ARRAY".parse().unwrap();
+        assert_eq!(encoding, Encoding::DELTA_LENGTH_BYTE_ARRAY);
+        encoding = "DELTA_BYTE_ARRAY".parse().unwrap();
+        assert_eq!(encoding, Encoding::DELTA_BYTE_ARRAY);
+        encoding = "RLE_DICTIONARY".parse().unwrap();
+        assert_eq!(encoding, Encoding::RLE_DICTIONARY);
+        encoding = "BYTE_STREAM_SPLIT".parse().unwrap();
+        assert_eq!(encoding, Encoding::BYTE_STREAM_SPLIT);
+
+        // test lowercase
+        encoding = "byte_stream_split".parse().unwrap();
+        assert_eq!(encoding, Encoding::BYTE_STREAM_SPLIT);
+
+        // test unknown string
+        match "plain_xxx".parse::<Encoding>() {
+            Ok(e) => {
+                panic!("Should not be able to parse {:?}", e);
+            }
+            Err(e) => {
+                assert_eq!(e.to_string(), "Parquet error: unknown encoding: plain_xxx");
+            }
+        }
+    }
+
+    #[test]
+    fn test_parse_compression() {
+        let mut compress: Compression = "snappy".parse().unwrap();
+        assert_eq!(compress, Compression::SNAPPY);
+        compress = "lzo".parse().unwrap();
+        assert_eq!(compress, Compression::LZO);
+        compress = "zstd(3)".parse().unwrap();
+        assert_eq!(compress, Compression::ZSTD(ZstdLevel::try_new(3).unwrap()));
+        compress = "LZ4_RAW".parse().unwrap();
+        assert_eq!(compress, Compression::LZ4_RAW);
+        compress = "uncompressed".parse().unwrap();
+        assert_eq!(compress, Compression::UNCOMPRESSED);
+        compress = "snappy".parse().unwrap();
+        assert_eq!(compress, Compression::SNAPPY);
+        compress = "gzip(9)".parse().unwrap();
+        assert_eq!(compress, Compression::GZIP(GzipLevel::try_new(9).unwrap()));
+        compress = "lzo".parse().unwrap();
+        assert_eq!(compress, Compression::LZO);
+        compress = "brotli(3)".parse().unwrap();
+        assert_eq!(
+            compress,
+            Compression::BROTLI(BrotliLevel::try_new(3).unwrap())
+        );
+        compress = "lz4".parse().unwrap();
+        assert_eq!(compress, Compression::LZ4);
+
+        // test unknown compression
+        let mut err = "plain_xxx".parse::<Encoding>().unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Parquet error: unknown encoding: plain_xxx"
+        );
+
+        // test invalid compress level
+        err = "gzip(-10)".parse::<Encoding>().unwrap_err();
+        assert_eq!(
+            err.to_string(),
+            "Parquet error: unknown encoding: gzip(-10)"
+        );
+    }
 }
diff --git a/parquet/src/bin/parquet-concat.rs b/parquet/src/bin/parquet-concat.rs
new file mode 100644
index 000000000000..9cbdf8e7b399
--- /dev/null
+++ b/parquet/src/bin/parquet-concat.rs
@@ -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.
+
+//! Binary that concatenates the column data of one or more parquet files
+//!
+//! # Install
+//!
+//! `parquet-concat` can be installed using `cargo`:
+//! ```
+//! cargo install parquet --features=cli
+//! ```
+//! After this `parquet-concat` should be available:
+//! ```
+//! parquet-concat out.parquet a.parquet b.parquet
+//! ```
+//!
+//! The binary can also be built from the source code and run as follows:
+//! ```
+//! cargo run --features=cli --bin parquet-concat out.parquet a.parquet b.parquet
+//! ```
+//!
+//! Note: this does not currently support preserving the page index or bloom filters
+//!
+
+use clap::Parser;
+use parquet::column::writer::ColumnCloseResult;
+use parquet::errors::{ParquetError, Result};
+use parquet::file::properties::WriterProperties;
+use parquet::file::writer::SerializedFileWriter;
+use std::fs::File;
+use std::sync::Arc;
+
+#[derive(Debug, Parser)]
+#[clap(author, version)]
+/// Concatenates one or more parquet files
+struct Args {
+    /// Path to output
+    output: String,
+
+    /// Path to input files
+    input: Vec<String>,
+}
+
+impl Args {
+    fn run(&self) -> Result<()> {
+        if self.input.is_empty() {
+            return Err(ParquetError::General(
+                "Must provide at least one input file".into(),
+            ));
+        }
+
+        let output = File::create(&self.output)?;
+
+        let inputs = self
+            .input
+            .iter()
+            .map(|x| {
+                let reader = File::open(x)?;
+                let metadata = parquet::file::footer::parse_metadata(&reader)?;
+                Ok((reader, metadata))
+            })
+            .collect::<Result<Vec<_>>>()?;
+
+        let expected = inputs[0].1.file_metadata().schema();
+        for (_, metadata) in inputs.iter().skip(1) {
+            let actual = metadata.file_metadata().schema();
+            if expected != actual {
+                return Err(ParquetError::General(format!(
+                    "inputs must have the same schema, {expected:#?} vs {actual:#?}"
+                )));
+            }
+        }
+
+        let props = Arc::new(WriterProperties::builder().build());
+        let schema = inputs[0].1.file_metadata().schema_descr().root_schema_ptr();
+        let mut writer = SerializedFileWriter::new(output, schema, props)?;
+
+        for (input, metadata) in inputs {
+            for rg in metadata.row_groups() {
+                let mut rg_out = writer.next_row_group()?;
+                for column in rg.columns() {
+                    let result = ColumnCloseResult {
+                        bytes_written: column.compressed_size() as _,
+                        rows_written: rg.num_rows() as _,
+                        metadata: column.clone(),
+                        bloom_filter: None,
+                        column_index: None,
+                        offset_index: None,
+                    };
+                    rg_out.append_column(&input, result)?;
+                }
+                rg_out.close()?;
+            }
+        }
+
+        writer.close()?;
+
+        Ok(())
+    }
+}
+
+fn main() -> Result<()> {
+    Args::parse().run()
+}
diff --git a/parquet/src/bin/parquet-fromcsv-help.txt b/parquet/src/bin/parquet-fromcsv-help.txt
index f4fe704ab267..ac38c5689279 100644
--- a/parquet/src/bin/parquet-fromcsv-help.txt
+++ b/parquet/src/bin/parquet-fromcsv-help.txt
@@ -1,66 +1,75 @@
-Apache Arrow <dev@arrow.apache.org>
-Binary to convert csv to Parquet
 
-USAGE:
-    parquet [OPTIONS] --schema <SCHEMA> --input-file <INPUT_FILE> --output-file <OUTPUT_FILE>
+Usage: parquet [OPTIONS] --schema <SCHEMA> --input-file <INPUT_FILE> --output-file <OUTPUT_FILE>
 
-OPTIONS:
-    -b, --batch-size <BATCH_SIZE>
-            batch size
-            
-            [env: PARQUET_FROM_CSV_BATCHSIZE=]
-            [default: 1000]
+Options:
+  -s, --schema <SCHEMA>
+          message schema for output Parquet
 
-    -c, --parquet-compression <PARQUET_COMPRESSION>
-            compression mode
-            
-            [default: SNAPPY]
+  -i, --input-file <INPUT_FILE>
+          input CSV file
 
-    -d, --delimiter <DELIMITER>
-            field delimiter
-            
-            default value: when input_format==CSV: ',' when input_format==TSV: 'TAB'
+  -o, --output-file <OUTPUT_FILE>
+          output Parquet file
 
-    -D, --double-quote <DOUBLE_QUOTE>
-            double quote
+  -f, --input-format <INPUT_FORMAT>
+          input file format
+          
+          [default: csv]
+          [possible values: csv, tsv]
 
-    -e, --escape-char <ESCAPE_CHAR>
-            escape charactor
+  -b, --batch-size <BATCH_SIZE>
+          batch size
+          
+          [env: PARQUET_FROM_CSV_BATCHSIZE=]
+          [default: 1000]
 
-    -f, --input-format <INPUT_FORMAT>
-            input file format
-            
-            [default: csv]
-            [possible values: csv, tsv]
+  -h, --has-header
+          has header
 
-    -h, --has-header
-            has header
+  -d, --delimiter <DELIMITER>
+          field delimiter
+          
+          default value: when input_format==CSV: ',' when input_format==TSV: 'TAB'
 
-        --help
-            Print help information
+  -r, --record-terminator <RECORD_TERMINATOR>
+          record terminator
+          
+          [possible values: lf, crlf, cr]
 
-    -i, --input-file <INPUT_FILE>
-            input CSV file
+  -e, --escape-char <ESCAPE_CHAR>
+          escape character
 
-    -m, --max-row-group-size <MAX_ROW_GROUP_SIZE>
-            max row group size
+  -q, --quote-char <QUOTE_CHAR>
+          quote character
 
-    -o, --output-file <OUTPUT_FILE>
-            output Parquet file
+  -D, --double-quote <DOUBLE_QUOTE>
+          double quote
+          
+          [possible values: true, false]
 
-    -q, --quote-char <QUOTE_CHAR>
-            quate charactor
+  -C, --csv-compression <CSV_COMPRESSION>
+          compression mode of csv
+          
+          [default: UNCOMPRESSED]
 
-    -r, --record-terminator <RECORD_TERMINATOR>
-            record terminator
-            
-            [possible values: lf, crlf, cr]
+  -c, --parquet-compression <PARQUET_COMPRESSION>
+          compression mode of parquet
+          
+          [default: SNAPPY]
 
-    -s, --schema <SCHEMA>
-            message schema for output Parquet
+  -w, --writer-version <WRITER_VERSION>
+          writer version
 
-    -V, --version
-            Print version information
+  -m, --max-row-group-size <MAX_ROW_GROUP_SIZE>
+          max row group size
 
-    -w, --writer-version <WRITER_VERSION>
-            writer version
+      --enable-bloom-filter <ENABLE_BLOOM_FILTER>
+          whether to enable bloom filter writing
+          
+          [possible values: true, false]
+
+      --help
+          display usage help
+
+  -V, --version
+          Print version
diff --git a/parquet/src/bin/parquet-fromcsv.rs b/parquet/src/bin/parquet-fromcsv.rs
index 827aa7311f58..445409610a8f 100644
--- a/parquet/src/bin/parquet-fromcsv.rs
+++ b/parquet/src/bin/parquet-fromcsv.rs
@@ -25,7 +25,7 @@
 //! cargo install parquet --features=cli
 //! ```
 //!
-//! After this `parquet-fromcsv` shoud be available:
+//! After this `parquet-fromcsv` should be available:
 //!
 //! ```text
 //! parquet-fromcsv --schema message_schema_for_parquet.txt input.csv output.parquet
@@ -46,33 +46,41 @@
 //!
 //! ## Parquet file options
 //!
+//! ```text
 //! - `-b`, `--batch-size` : Batch size for Parquet
 //! - `-c`, `--parquet-compression` : Compression option for Parquet, default is SNAPPY
 //! - `-s`, `--schema` : Path to message schema for generated Parquet file
 //! - `-o`, `--output-file` : Path to output Parquet file
 //! - `-w`, `--writer-version` : Writer version
 //! - `-m`, `--max-row-group-size` : Max row group size
+//! -       `--enable-bloom-filter` : Enable bloom filter during writing
+//! ```
 //!
 //! ## Input file options
 //!
+//! ```text
 //! - `-i`, `--input-file` : Path to input CSV file
 //! - `-f`, `--input-format` : Dialect for input file, `csv` or `tsv`.
-//! - `-d`, `--delimiter : Field delimitor for CSV file, default depends `--input-format`
-//! - `-e`, `--escape` : Escape charactor for input file
+//! - `-C`, `--csv-compression` : Compression option for csv, default is UNCOMPRESSED
+//! - `-d`, `--delimiter : Field delimiter for CSV file, default depends `--input-format`
+//! - `-e`, `--escape` : Escape character for input file
 //! - `-h`, `--has-header` : Input has header
-//! - `-r`, `--record-terminator` : Record terminator charactor for input. default is CRLF
-//! - `-q`, `--quote-char` : Input quoting charactor
+//! - `-r`, `--record-terminator` : Record terminator character for input. default is CRLF
+//! - `-q`, `--quote-char` : Input quoting character
+//! ```
 //!
 
 use std::{
     fmt::Display,
     fs::{read_to_string, File},
+    io::Read,
     path::{Path, PathBuf},
     sync::Arc,
 };
 
-use arrow::{csv::ReaderBuilder, datatypes::Schema, error::ArrowError};
-use clap::{ArgEnum, Parser};
+use arrow_csv::ReaderBuilder;
+use arrow_schema::{ArrowError, Schema};
+use clap::{Parser, ValueEnum};
 use parquet::{
     arrow::{parquet_to_arrow_schema, ArrowWriter},
     basic::Compression,
@@ -127,20 +135,20 @@ impl ParquetFromCsvError {
 impl Display for ParquetFromCsvError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
-            ParquetFromCsvError::CommandLineParseError(e) => write!(f, "{}", e),
-            ParquetFromCsvError::IoError(e) => write!(f, "{}", e),
-            ParquetFromCsvError::ArrowError(e) => write!(f, "{}", e),
-            ParquetFromCsvError::ParquetError(e) => write!(f, "{}", e),
+            ParquetFromCsvError::CommandLineParseError(e) => write!(f, "{e}"),
+            ParquetFromCsvError::IoError(e) => write!(f, "{e}"),
+            ParquetFromCsvError::ArrowError(e) => write!(f, "{e}"),
+            ParquetFromCsvError::ParquetError(e) => write!(f, "{e}"),
             ParquetFromCsvError::WithContext(c, e) => {
-                writeln!(f, "{}", e)?;
-                write!(f, "context: {}", c)
+                writeln!(f, "{e}")?;
+                write!(f, "context: {c}")
             }
         }
     }
 }
 
 #[derive(Debug, Parser)]
-#[clap(author, version, about("Binary to convert csv to Parquet"), long_about=None)]
+#[clap(author, version, disable_help_flag=true, about("Binary to convert csv to Parquet"), long_about=None)]
 struct Args {
     /// Path to a text file containing a parquet schema definition
     #[clap(short, long, help("message schema for output Parquet"))]
@@ -153,7 +161,7 @@ struct Args {
     output_file: PathBuf,
     /// input file format
     #[clap(
-        arg_enum,
+        value_enum,
         short('f'),
         long,
         help("input file format"),
@@ -179,36 +187,44 @@ struct Args {
     ///  when input_format==TSV: 'TAB'
     #[clap(short, long, help("field delimiter"))]
     delimiter: Option<char>,
-    #[clap(arg_enum, short, long, help("record terminator"))]
+    #[clap(value_enum, short, long, help("record terminator"))]
     record_terminator: Option<RecordTerminator>,
-    #[clap(short, long, help("escape charactor"))]
+    #[clap(short, long, help("escape character"))]
     escape_char: Option<char>,
-    #[clap(short, long, help("quate charactor"))]
+    #[clap(short, long, help("quote character"))]
     quote_char: Option<char>,
     #[clap(short('D'), long, help("double quote"))]
     double_quote: Option<bool>,
-    #[clap(short('c'), long, help("compression mode"), default_value_t=Compression::SNAPPY)]
-    #[clap(parse(try_from_str =compression_from_str))]
+    #[clap(short('C'), long, help("compression mode of csv"), default_value_t=Compression::UNCOMPRESSED)]
+    #[clap(value_parser=compression_from_str)]
+    csv_compression: Compression,
+    #[clap(short('c'), long, help("compression mode of parquet"), default_value_t=Compression::SNAPPY)]
+    #[clap(value_parser=compression_from_str)]
     parquet_compression: Compression,
 
     #[clap(short, long, help("writer version"))]
-    #[clap(parse(try_from_str =writer_version_from_str))]
+    #[clap(value_parser=writer_version_from_str)]
     writer_version: Option<WriterVersion>,
     #[clap(short, long, help("max row group size"))]
     max_row_group_size: Option<usize>,
+    #[clap(long, help("whether to enable bloom filter writing"))]
+    enable_bloom_filter: Option<bool>,
+
+    #[clap(long, action=clap::ArgAction::Help, help("display usage help"))]
+    help: Option<bool>,
 }
 
 fn compression_from_str(cmp: &str) -> Result<Compression, String> {
     match cmp.to_uppercase().as_str() {
         "UNCOMPRESSED" => Ok(Compression::UNCOMPRESSED),
         "SNAPPY" => Ok(Compression::SNAPPY),
-        "GZIP" => Ok(Compression::GZIP),
+        "GZIP" => Ok(Compression::GZIP(Default::default())),
         "LZO" => Ok(Compression::LZO),
-        "BROTLI" => Ok(Compression::BROTLI),
+        "BROTLI" => Ok(Compression::BROTLI(Default::default())),
         "LZ4" => Ok(Compression::LZ4),
-        "ZSTD" => Ok(Compression::ZSTD),
+        "ZSTD" => Ok(Compression::ZSTD(Default::default())),
         v => Err(
-            format!("Unknown compression {0} : possible values UNCOMPRESSED, SNAPPY, GZIP, LZO, BROTLI, LZ4, ZSTD ",v)
+            format!("Unknown compression {v} : possible values UNCOMPRESSED, SNAPPY, GZIP, LZO, BROTLI, LZ4, ZSTD \n\nFor more information try --help")
         )
     }
 }
@@ -217,10 +233,7 @@ fn writer_version_from_str(cmp: &str) -> Result<WriterVersion, String> {
     match cmp.to_uppercase().as_str() {
         "1" => Ok(WriterVersion::PARQUET_1_0),
         "2" => Ok(WriterVersion::PARQUET_2_0),
-        v => Err(format!(
-            "Unknown writer version {0} : possible values 1, 2",
-            v
-        )),
+        v => Err(format!("Unknown writer version {v} : possible values 1, 2")),
     }
 }
 
@@ -263,13 +276,13 @@ impl Args {
     }
 }
 
-#[derive(Debug, Clone, Copy, ArgEnum, PartialEq)]
+#[derive(Debug, Clone, Copy, ValueEnum, PartialEq)]
 enum CsvDialect {
     Csv,
     Tsv,
 }
 
-#[derive(Debug, Clone, Copy, ArgEnum, PartialEq)]
+#[derive(Debug, Clone, Copy, ValueEnum, PartialEq)]
 enum RecordTerminator {
     LF,
     Crlf,
@@ -283,8 +296,10 @@ fn configure_writer_properties(args: &Args) -> WriterProperties {
         properties_builder = properties_builder.set_writer_version(writer_version);
     }
     if let Some(max_row_group_size) = args.max_row_group_size {
-        properties_builder =
-            properties_builder.set_max_row_group_size(max_row_group_size);
+        properties_builder = properties_builder.set_max_row_group_size(max_row_group_size);
+    }
+    if let Some(enable_bloom_filter) = args.enable_bloom_filter {
+        properties_builder = properties_builder.set_bloom_filter_enabled(enable_bloom_filter);
     }
     properties_builder.build()
 }
@@ -302,10 +317,9 @@ fn configure_reader_builder(args: &Args, arrow_schema: Arc<Schema>) -> ReaderBui
         }
     }
 
-    let mut builder = ReaderBuilder::new()
-        .with_schema(arrow_schema)
+    let mut builder = ReaderBuilder::new(arrow_schema)
         .with_batch_size(args.batch_size)
-        .has_header(args.has_header)
+        .with_header(args.has_header)
         .with_delimiter(args.get_delimiter());
 
     builder = configure_reader(
@@ -346,9 +360,7 @@ fn convert_csv_to_parquet(args: &Args) -> Result<(), ParquetFromCsvError> {
     let writer_properties = Some(configure_writer_properties(args));
     let mut arrow_writer =
         ArrowWriter::try_new(parquet_file, arrow_schema.clone(), writer_properties)
-            .map_err(|e| {
-                ParquetFromCsvError::with_context(e, "Failed to create ArrowWriter")
-            })?;
+            .map_err(|e| ParquetFromCsvError::with_context(e, "Failed to create ArrowWriter"))?;
 
     // open input file
     let input_file = File::open(&args.input_file).map_err(|e| {
@@ -357,9 +369,31 @@ fn convert_csv_to_parquet(args: &Args) -> Result<(), ParquetFromCsvError> {
             &format!("Failed to open input file {:#?}", &args.input_file),
         )
     })?;
+
+    // open input file decoder
+    let input_file_decoder = match args.csv_compression {
+        Compression::UNCOMPRESSED => Box::new(input_file) as Box<dyn Read>,
+        Compression::SNAPPY => Box::new(snap::read::FrameDecoder::new(input_file)) as Box<dyn Read>,
+        Compression::GZIP(_) => {
+            Box::new(flate2::read::MultiGzDecoder::new(input_file)) as Box<dyn Read>
+        }
+        Compression::BROTLI(_) => {
+            Box::new(brotli::Decompressor::new(input_file, 0)) as Box<dyn Read>
+        }
+        Compression::LZ4 => {
+            Box::new(lz4_flex::frame::FrameDecoder::new(input_file)) as Box<dyn Read>
+        }
+        Compression::ZSTD(_) => {
+            Box::new(zstd::Decoder::new(input_file).map_err(|e| {
+                ParquetFromCsvError::with_context(e, "Failed to create zstd::Decoder")
+            })?) as Box<dyn Read>
+        }
+        d => unimplemented!("compression type {d}"),
+    };
+
     // create input csv reader
     let builder = configure_reader_builder(args, arrow_schema);
-    let reader = builder.build(input_file)?;
+    let reader = builder.build(input_file_decoder)?;
     for batch_result in reader {
         let batch = batch_result.map_err(|e| {
             ParquetFromCsvError::with_context(e, "Failed to read RecordBatch from CSV")
@@ -382,13 +416,17 @@ fn main() -> Result<(), ParquetFromCsvError> {
 #[cfg(test)]
 mod tests {
     use std::{
-        io::{Seek, SeekFrom, Write},
+        io::Write,
         path::{Path, PathBuf},
     };
 
     use super::*;
     use arrow::datatypes::{DataType, Field};
+    use brotli::CompressorWriter;
     use clap::{CommandFactory, Parser};
+    use flate2::write::GzEncoder;
+    use parquet::basic::{BrotliLevel, GzipLevel, ZstdLevel};
+    use snap::write::FrameEncoder;
     use tempfile::NamedTempFile;
 
     #[test]
@@ -409,8 +447,7 @@ mod tests {
         actual = actual[pos..].to_string();
         assert_eq!(
             expected, actual,
-            "help text not match. please update to \n---\n{}\n---\n",
-            actual
+            "help text not match. please update to \n---\n{actual}\n---\n"
         )
     }
 
@@ -496,15 +533,24 @@ mod tests {
         let args = parse_args(vec!["--parquet-compression", "snappy"]).unwrap();
         assert_eq!(args.parquet_compression, Compression::SNAPPY);
         let args = parse_args(vec!["--parquet-compression", "gzip"]).unwrap();
-        assert_eq!(args.parquet_compression, Compression::GZIP);
+        assert_eq!(
+            args.parquet_compression,
+            Compression::GZIP(Default::default())
+        );
         let args = parse_args(vec!["--parquet-compression", "lzo"]).unwrap();
         assert_eq!(args.parquet_compression, Compression::LZO);
         let args = parse_args(vec!["--parquet-compression", "lz4"]).unwrap();
         assert_eq!(args.parquet_compression, Compression::LZ4);
         let args = parse_args(vec!["--parquet-compression", "brotli"]).unwrap();
-        assert_eq!(args.parquet_compression, Compression::BROTLI);
+        assert_eq!(
+            args.parquet_compression,
+            Compression::BROTLI(Default::default())
+        );
         let args = parse_args(vec!["--parquet-compression", "zstd"]).unwrap();
-        assert_eq!(args.parquet_compression, Compression::ZSTD);
+        assert_eq!(
+            args.parquet_compression,
+            Compression::ZSTD(Default::default())
+        );
     }
 
     #[test]
@@ -512,18 +558,16 @@ mod tests {
         match parse_args(vec!["--parquet-compression", "zip"]) {
             Ok(_) => panic!("unexpected success"),
             Err(e) => assert_eq!(
-                format!("{}", e),
-                "error: Invalid value \"zip\" for '--parquet-compression <PARQUET_COMPRESSION>': Unknown compression ZIP : possible values UNCOMPRESSED, SNAPPY, GZIP, LZO, BROTLI, LZ4, ZSTD \n\nFor more information try --help\n"),
+                format!("{e}"),
+                "error: invalid value 'zip' for '--parquet-compression <PARQUET_COMPRESSION>': Unknown compression ZIP : possible values UNCOMPRESSED, SNAPPY, GZIP, LZO, BROTLI, LZ4, ZSTD \n\nFor more information try --help\n"),
         }
     }
 
     fn assert_debug_text(debug_text: &str, name: &str, value: &str) {
-        let pattern = format!(" {}: {}", name, value);
+        let pattern = format!(" {name}: {value}");
         assert!(
             debug_text.contains(&pattern),
-            "\"{}\" not contains \"{}\"",
-            debug_text,
-            pattern
+            "\"{debug_text}\" not contains \"{pattern}\""
         )
     }
 
@@ -541,9 +585,12 @@ mod tests {
             escape_char: None,
             quote_char: None,
             double_quote: None,
+            csv_compression: Compression::UNCOMPRESSED,
             parquet_compression: Compression::SNAPPY,
             writer_version: None,
             max_row_group_size: None,
+            enable_bloom_filter: None,
+            help: None,
         };
         let arrow_schema = Arc::new(Schema::new(vec![
             Field::new("field1", DataType::Utf8, false),
@@ -554,8 +601,8 @@ mod tests {
         ]));
 
         let reader_builder = configure_reader_builder(&args, arrow_schema);
-        let builder_debug = format!("{:?}", reader_builder);
-        assert_debug_text(&builder_debug, "has_header", "false");
+        let builder_debug = format!("{reader_builder:?}");
+        assert_debug_text(&builder_debug, "header", "false");
         assert_debug_text(&builder_debug, "delimiter", "Some(44)");
         assert_debug_text(&builder_debug, "quote", "Some(34)");
         assert_debug_text(&builder_debug, "terminator", "None");
@@ -574,9 +621,12 @@ mod tests {
             escape_char: Some('\\'),
             quote_char: None,
             double_quote: None,
+            csv_compression: Compression::UNCOMPRESSED,
             parquet_compression: Compression::SNAPPY,
             writer_version: None,
             max_row_group_size: None,
+            enable_bloom_filter: None,
+            help: None,
         };
         let arrow_schema = Arc::new(Schema::new(vec![
             Field::new("field1", DataType::Utf8, false),
@@ -586,8 +636,8 @@ mod tests {
             Field::new("field5", DataType::Utf8, false),
         ]));
         let reader_builder = configure_reader_builder(&args, arrow_schema);
-        let builder_debug = format!("{:?}", reader_builder);
-        assert_debug_text(&builder_debug, "has_header", "true");
+        let builder_debug = format!("{reader_builder:?}");
+        assert_debug_text(&builder_debug, "header", "true");
         assert_debug_text(&builder_debug, "delimiter", "Some(9)");
         assert_debug_text(&builder_debug, "quote", "None");
         assert_debug_text(&builder_debug, "terminator", "Some(10)");
@@ -595,8 +645,7 @@ mod tests {
         assert_debug_text(&builder_debug, "escape", "Some(92)");
     }
 
-    #[test]
-    fn test_convert_csv_to_parquet() {
+    fn test_convert_compressed_csv_to_parquet(csv_compression: Compression) {
         let schema = NamedTempFile::new().unwrap();
         let schema_text = r"message schema {
             optional int32 id;
@@ -605,14 +654,57 @@ mod tests {
         schema.as_file().write_all(schema_text.as_bytes()).unwrap();
 
         let mut input_file = NamedTempFile::new().unwrap();
-        {
-            let csv = input_file.as_file_mut();
+
+        fn write_tmp_file<T: Write>(w: &mut T) {
             for index in 1..2000 {
-                write!(csv, "{},\"name_{}\"\r\n", index, index).unwrap();
+                write!(w, "{index},\"name_{index}\"\r\n").unwrap();
             }
-            csv.flush().unwrap();
-            csv.seek(SeekFrom::Start(0)).unwrap();
+            w.flush().unwrap();
         }
+
+        // make sure the input_file's lifetime being long enough
+        input_file = match csv_compression {
+            Compression::UNCOMPRESSED => {
+                write_tmp_file(&mut input_file);
+                input_file
+            }
+            Compression::SNAPPY => {
+                let mut encoder = FrameEncoder::new(input_file);
+                write_tmp_file(&mut encoder);
+                encoder.into_inner().unwrap()
+            }
+            Compression::GZIP(level) => {
+                let mut encoder = GzEncoder::new(
+                    input_file,
+                    flate2::Compression::new(level.compression_level()),
+                );
+                write_tmp_file(&mut encoder);
+                encoder.finish().unwrap()
+            }
+            Compression::BROTLI(level) => {
+                let mut encoder =
+                    CompressorWriter::new(input_file, 0, level.compression_level(), 0);
+                write_tmp_file(&mut encoder);
+                encoder.into_inner()
+            }
+            Compression::LZ4 => {
+                let mut encoder = lz4_flex::frame::FrameEncoder::new(input_file);
+                write_tmp_file(&mut encoder);
+                encoder.finish().unwrap()
+            }
+
+            Compression::ZSTD(level) => {
+                let mut encoder = zstd::Encoder::new(input_file, level.compression_level())
+                    .map_err(|e| {
+                        ParquetFromCsvError::with_context(e, "Failed to create zstd::Encoder")
+                    })
+                    .unwrap();
+                write_tmp_file(&mut encoder);
+                encoder.finish().unwrap()
+            }
+            d => unimplemented!("compression type {d}"),
+        };
+
         let output_parquet = NamedTempFile::new().unwrap();
 
         let args = Args {
@@ -627,10 +719,26 @@ mod tests {
             escape_char: None,
             quote_char: None,
             double_quote: None,
+            csv_compression,
             parquet_compression: Compression::SNAPPY,
             writer_version: None,
             max_row_group_size: None,
+            // by default we shall test bloom filter writing
+            enable_bloom_filter: Some(true),
+            help: None,
         };
         convert_csv_to_parquet(&args).unwrap();
     }
+
+    #[test]
+    fn test_convert_csv_to_parquet() {
+        test_convert_compressed_csv_to_parquet(Compression::UNCOMPRESSED);
+        test_convert_compressed_csv_to_parquet(Compression::SNAPPY);
+        test_convert_compressed_csv_to_parquet(Compression::GZIP(GzipLevel::try_new(1).unwrap()));
+        test_convert_compressed_csv_to_parquet(Compression::BROTLI(
+            BrotliLevel::try_new(2).unwrap(),
+        ));
+        test_convert_compressed_csv_to_parquet(Compression::LZ4);
+        test_convert_compressed_csv_to_parquet(Compression::ZSTD(ZstdLevel::try_new(1).unwrap()));
+    }
 }
diff --git a/parquet/src/bin/parquet-index.rs b/parquet/src/bin/parquet-index.rs
new file mode 100644
index 000000000000..86e08b6dafa3
--- /dev/null
+++ b/parquet/src/bin/parquet-index.rs
@@ -0,0 +1,172 @@
+// 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.
+
+//! Binary that prints the [page index] of a parquet file
+//!
+//! # Install
+//!
+//! `parquet-layout` can be installed using `cargo`:
+//! ```
+//! cargo install parquet --features=cli
+//! ```
+//! After this `parquet-index` should be available:
+//! ```
+//! parquet-index XYZ.parquet COLUMN_NAME
+//! ```
+//!
+//! The binary can also be built from the source code and run as follows:
+//! ```
+//! cargo run --features=cli --bin parquet-index XYZ.parquet COLUMN_NAME
+//!
+//! [page index]: https://github.com/apache/parquet-format/blob/master/PageIndex.md
+
+use clap::Parser;
+use parquet::errors::{ParquetError, Result};
+use parquet::file::page_index::index::{Index, PageIndex};
+use parquet::file::reader::{FileReader, SerializedFileReader};
+use parquet::file::serialized_reader::ReadOptionsBuilder;
+use parquet::format::PageLocation;
+use std::fs::File;
+
+#[derive(Debug, Parser)]
+#[clap(author, version, about("Prints the page index of a parquet file"), long_about = None)]
+struct Args {
+    #[clap(help("Path to a parquet file"))]
+    file: String,
+
+    #[clap(help("Column name to print"))]
+    column: String,
+}
+
+impl Args {
+    fn run(&self) -> Result<()> {
+        let file = File::open(&self.file)?;
+        let options = ReadOptionsBuilder::new().with_page_index().build();
+        let reader = SerializedFileReader::new_with_options(file, options)?;
+
+        let schema = reader.metadata().file_metadata().schema_descr();
+        let column_idx = schema
+            .columns()
+            .iter()
+            .position(|x| x.name() == self.column.as_str())
+            .ok_or_else(|| {
+                ParquetError::General(format!("Failed to find column {}", self.column))
+            })?;
+
+        // Column index data for all row groups and columns
+        let column_index = reader
+            .metadata()
+            .column_index()
+            .ok_or_else(|| ParquetError::General("Column index not found".to_string()))?;
+
+        // Offset index data for all row groups and columns
+        let offset_index = reader
+            .metadata()
+            .offset_index()
+            .ok_or_else(|| ParquetError::General("Offset index not found".to_string()))?;
+
+        // Iterate through each row group
+        for (row_group_idx, ((column_indices, offset_indices), row_group)) in column_index
+            .iter()
+            .zip(offset_index)
+            .zip(reader.metadata().row_groups())
+            .enumerate()
+        {
+            println!("Row Group: {row_group_idx}");
+            let offset_index = offset_indices.get(column_idx).ok_or_else(|| {
+                ParquetError::General(format!(
+                    "No offset index for row group {row_group_idx} column chunk {column_idx}"
+                ))
+            })?;
+
+            let row_counts = compute_row_counts(offset_index, row_group.num_rows());
+            match &column_indices[column_idx] {
+                Index::NONE => println!("NO INDEX"),
+                Index::BOOLEAN(v) => print_index(&v.indexes, offset_index, &row_counts)?,
+                Index::INT32(v) => print_index(&v.indexes, offset_index, &row_counts)?,
+                Index::INT64(v) => print_index(&v.indexes, offset_index, &row_counts)?,
+                Index::INT96(v) => print_index(&v.indexes, offset_index, &row_counts)?,
+                Index::FLOAT(v) => print_index(&v.indexes, offset_index, &row_counts)?,
+                Index::DOUBLE(v) => print_index(&v.indexes, offset_index, &row_counts)?,
+                Index::BYTE_ARRAY(v) => print_index(&v.indexes, offset_index, &row_counts)?,
+                Index::FIXED_LEN_BYTE_ARRAY(v) => {
+                    print_index(&v.indexes, offset_index, &row_counts)?
+                }
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Computes the number of rows in each page within a column chunk
+fn compute_row_counts(offset_index: &[PageLocation], rows: i64) -> Vec<i64> {
+    if offset_index.is_empty() {
+        return vec![];
+    }
+
+    let mut last = offset_index[0].first_row_index;
+    let mut out = Vec::with_capacity(offset_index.len());
+    for o in offset_index.iter().skip(1) {
+        out.push(o.first_row_index - last);
+        last = o.first_row_index;
+    }
+    out.push(rows - last);
+    out
+}
+
+/// Prints index information for a single column chunk
+fn print_index<T: std::fmt::Display>(
+    column_index: &[PageIndex<T>],
+    offset_index: &[PageLocation],
+    row_counts: &[i64],
+) -> Result<()> {
+    if column_index.len() != offset_index.len() {
+        return Err(ParquetError::General(format!(
+            "Index length mismatch, got {} and {}",
+            column_index.len(),
+            offset_index.len()
+        )));
+    }
+
+    for (idx, ((c, o), row_count)) in column_index
+        .iter()
+        .zip(offset_index)
+        .zip(row_counts)
+        .enumerate()
+    {
+        print!(
+            "Page {:>5} at offset {:#010x} with length {:>10} and row count {:>10}",
+            idx, o.offset, o.compressed_page_size, row_count
+        );
+        match &c.min {
+            Some(m) => print!(", min {m:>10}"),
+            None => print!(", min {:>10}", "NONE"),
+        }
+
+        match &c.max {
+            Some(m) => print!(", max {m:>10}"),
+            None => print!(", max {:>10}", "NONE"),
+        }
+        println!()
+    }
+
+    Ok(())
+}
+
+fn main() -> Result<()> {
+    Args::parse().run()
+}
diff --git a/parquet/src/bin/parquet-layout.rs b/parquet/src/bin/parquet-layout.rs
new file mode 100644
index 000000000000..79a0acb5f57c
--- /dev/null
+++ b/parquet/src/bin/parquet-layout.rs
@@ -0,0 +1,236 @@
+// 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.
+
+//! Binary that prints the physical layout of a parquet file
+//!
+//! # Install
+//!
+//! `parquet-layout` can be installed using `cargo`:
+//! ```
+//! cargo install parquet --features=cli
+//! ```
+//! After this `parquet-layout` should be available:
+//! ```
+//! parquet-layout XYZ.parquet
+//! ```
+//!
+//! The binary can also be built from the source code and run as follows:
+//! ```
+//! cargo run --features=cli --bin parquet-layout XYZ.parquet
+//! ```
+
+use std::fs::File;
+use std::io::Read;
+
+use clap::Parser;
+use serde::Serialize;
+use thrift::protocol::TCompactInputProtocol;
+
+use parquet::basic::{Compression, Encoding};
+use parquet::errors::Result;
+use parquet::file::reader::ChunkReader;
+use parquet::format::PageHeader;
+use parquet::thrift::TSerializable;
+
+#[derive(Serialize, Debug)]
+struct ParquetFile {
+    row_groups: Vec<RowGroup>,
+}
+
+#[derive(Serialize, Debug)]
+struct RowGroup {
+    columns: Vec<ColumnChunk>,
+    row_count: i64,
+}
+
+#[derive(Serialize, Debug)]
+struct ColumnChunk {
+    path: String,
+    has_offset_index: bool,
+    has_column_index: bool,
+    has_bloom_filter: bool,
+    pages: Vec<Page>,
+}
+
+#[derive(Serialize, Debug)]
+struct Page {
+    compression: Option<&'static str>,
+    encoding: &'static str,
+    page_type: &'static str,
+    offset: u64,
+    compressed_bytes: i32,
+    uncompressed_bytes: i32,
+    header_bytes: i32,
+    num_values: i32,
+}
+
+fn do_layout<C: ChunkReader>(reader: &C) -> Result<ParquetFile> {
+    let metadata = parquet::file::footer::parse_metadata(reader)?;
+    let schema = metadata.file_metadata().schema_descr();
+
+    let row_groups = (0..metadata.num_row_groups())
+        .map(|row_group_idx| {
+            let row_group = metadata.row_group(row_group_idx);
+            let columns = row_group
+                .columns()
+                .iter()
+                .zip(schema.columns())
+                .map(|(column, column_schema)| {
+                    let compression = compression(column.compression());
+                    let mut pages = vec![];
+
+                    let mut start = column
+                        .dictionary_page_offset()
+                        .unwrap_or_else(|| column.data_page_offset())
+                        as u64;
+
+                    let end = start + column.compressed_size() as u64;
+                    while start != end {
+                        let (header_len, header) = read_page_header(reader, start)?;
+                        if let Some(dictionary) = header.dictionary_page_header {
+                            pages.push(Page {
+                                compression,
+                                encoding: encoding(dictionary.encoding),
+                                page_type: "dictionary",
+                                offset: start,
+                                compressed_bytes: header.compressed_page_size,
+                                uncompressed_bytes: header.uncompressed_page_size,
+                                header_bytes: header_len as _,
+                                num_values: dictionary.num_values,
+                            })
+                        } else if let Some(data_page) = header.data_page_header {
+                            pages.push(Page {
+                                compression,
+                                encoding: encoding(data_page.encoding),
+                                page_type: "data_page_v1",
+                                offset: start,
+                                compressed_bytes: header.compressed_page_size,
+                                uncompressed_bytes: header.uncompressed_page_size,
+                                header_bytes: header_len as _,
+                                num_values: data_page.num_values,
+                            })
+                        } else if let Some(data_page) = header.data_page_header_v2 {
+                            let is_compressed = data_page.is_compressed.unwrap_or(true);
+
+                            pages.push(Page {
+                                compression: compression.filter(|_| is_compressed),
+                                encoding: encoding(data_page.encoding),
+                                page_type: "data_page_v2",
+                                offset: start,
+                                compressed_bytes: header.compressed_page_size,
+                                uncompressed_bytes: header.uncompressed_page_size,
+                                header_bytes: header_len as _,
+                                num_values: data_page.num_values,
+                            })
+                        }
+                        start += header.compressed_page_size as u64 + header_len as u64;
+                    }
+
+                    Ok(ColumnChunk {
+                        path: column_schema.path().parts().join("."),
+                        has_offset_index: column.offset_index_offset().is_some(),
+                        has_column_index: column.column_index_offset().is_some(),
+                        has_bloom_filter: column.bloom_filter_offset().is_some(),
+                        pages,
+                    })
+                })
+                .collect::<Result<Vec<_>>>()?;
+
+            Ok(RowGroup {
+                columns,
+                row_count: row_group.num_rows(),
+            })
+        })
+        .collect::<Result<Vec<_>>>()?;
+
+    Ok(ParquetFile { row_groups })
+}
+
+/// Reads the page header at `offset` from `reader`, returning
+/// both the `PageHeader` and its length in bytes
+fn read_page_header<C: ChunkReader>(reader: &C, offset: u64) -> Result<(usize, PageHeader)> {
+    struct TrackedRead<R>(R, usize);
+
+    impl<R: Read> Read for TrackedRead<R> {
+        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+            let v = self.0.read(buf)?;
+            self.1 += v;
+            Ok(v)
+        }
+    }
+
+    let input = reader.get_read(offset)?;
+    let mut tracked = TrackedRead(input, 0);
+    let mut prot = TCompactInputProtocol::new(&mut tracked);
+    let header = PageHeader::read_from_in_protocol(&mut prot)?;
+    Ok((tracked.1, header))
+}
+
+/// Returns a string representation for a given compression
+fn compression(compression: Compression) -> Option<&'static str> {
+    match compression {
+        Compression::UNCOMPRESSED => None,
+        Compression::SNAPPY => Some("snappy"),
+        Compression::GZIP(_) => Some("gzip"),
+        Compression::LZO => Some("lzo"),
+        Compression::BROTLI(_) => Some("brotli"),
+        Compression::LZ4 => Some("lz4"),
+        Compression::ZSTD(_) => Some("zstd"),
+        Compression::LZ4_RAW => Some("lz4_raw"),
+    }
+}
+
+/// Returns a string representation for a given encoding
+fn encoding(encoding: parquet::format::Encoding) -> &'static str {
+    match Encoding::try_from(encoding) {
+        Ok(Encoding::PLAIN) => "plain",
+        Ok(Encoding::PLAIN_DICTIONARY) => "plain_dictionary",
+        Ok(Encoding::RLE) => "rle",
+        #[allow(deprecated)]
+        Ok(Encoding::BIT_PACKED) => "bit_packed",
+        Ok(Encoding::DELTA_BINARY_PACKED) => "delta_binary_packed",
+        Ok(Encoding::DELTA_LENGTH_BYTE_ARRAY) => "delta_length_byte_array",
+        Ok(Encoding::DELTA_BYTE_ARRAY) => "delta_byte_array",
+        Ok(Encoding::RLE_DICTIONARY) => "rle_dictionary",
+        Ok(Encoding::BYTE_STREAM_SPLIT) => "byte_stream_split",
+        Err(_) => "unknown",
+    }
+}
+
+#[derive(Debug, Parser)]
+#[clap(author, version, about("Prints the physical layout of a parquet file"), long_about = None)]
+struct Args {
+    #[clap(help("Path to a parquet file"))]
+    file: String,
+}
+
+impl Args {
+    fn run(&self) -> Result<()> {
+        let file = File::open(&self.file)?;
+        let layout = do_layout(&file)?;
+
+        let out = std::io::stdout();
+        let writer = out.lock();
+
+        serde_json::to_writer_pretty(writer, &layout).unwrap();
+        Ok(())
+    }
+}
+
+fn main() -> Result<()> {
+    Args::parse().run()
+}
diff --git a/parquet/src/bin/parquet-read.rs b/parquet/src/bin/parquet-read.rs
index 927d96f8cde7..fe486e633624 100644
--- a/parquet/src/bin/parquet-read.rs
+++ b/parquet/src/bin/parquet-read.rs
@@ -36,17 +36,16 @@
 //! Note that `parquet-read` reads full file schema, no projection or filtering is
 //! applied.
 
-extern crate parquet;
-
 use clap::Parser;
 use parquet::file::reader::{FileReader, SerializedFileReader};
 use parquet::record::Row;
+use std::io::{self, Read};
 use std::{fs::File, path::Path};
 
 #[derive(Debug, Parser)]
 #[clap(author, version, about("Binary file to read data from a Parquet file"), long_about = None)]
 struct Args {
-    #[clap(short, long, help("Path to a parquet file"))]
+    #[clap(help("Path to a parquet file, or - for stdin"))]
     file_name: String,
     #[clap(
         short,
@@ -66,10 +65,19 @@ fn main() {
     let num_records = args.num_records;
     let json = args.json;
 
-    let path = Path::new(&filename);
-    let file = File::open(&path).expect("Unable to open file");
-    let parquet_reader =
-        SerializedFileReader::new(file).expect("Failed to create reader");
+    let parquet_reader: Box<dyn FileReader> = if filename == "-" {
+        let mut buf = Vec::new();
+        io::stdin()
+            .read_to_end(&mut buf)
+            .expect("Failed to read stdin into a buffer");
+        Box::new(
+            SerializedFileReader::new(bytes::Bytes::from(buf)).expect("Failed to create reader"),
+        )
+    } else {
+        let path = Path::new(&filename);
+        let file = File::open(path).expect("Unable to open file");
+        Box::new(SerializedFileReader::new(file).expect("Failed to create reader"))
+    };
 
     // Use full schema as projected schema
     let mut iter = parquet_reader
@@ -82,9 +90,9 @@ fn main() {
 
     while all_records || start < end {
         match iter.next() {
-            Some(row) => print_row(&row, json),
+            Some(row) => print_row(&row.unwrap(), json),
             None => break,
-        }
+        };
         start += 1;
     }
 }
@@ -93,6 +101,6 @@ fn print_row(row: &Row, json: bool) {
     if json {
         println!("{}", row.to_json_value())
     } else {
-        println!("{}", row);
+        println!("{row}");
     }
 }
diff --git a/parquet/src/bin/parquet-rewrite.rs b/parquet/src/bin/parquet-rewrite.rs
new file mode 100644
index 000000000000..ad0f7ae0df7d
--- /dev/null
+++ b/parquet/src/bin/parquet-rewrite.rs
@@ -0,0 +1,279 @@
+// 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.
+
+//! Binary file to rewrite parquet files.
+//!
+//! # Install
+//!
+//! `parquet-rewrite` can be installed using `cargo`:
+//! ```
+//! cargo install parquet --features=cli
+//! ```
+//! After this `parquet-rewrite` should be available:
+//! ```
+//! parquet-rewrite -i XYZ.parquet -o XYZ2.parquet
+//! ```
+//!
+//! The binary can also be built from the source code and run as follows:
+//! ```
+//! cargo run --features=cli --bin parquet-rewrite -- -i XYZ.parquet -o XYZ2.parquet
+//! ```
+
+use std::fs::File;
+
+use arrow_array::RecordBatchReader;
+use clap::{builder::PossibleValue, Parser, ValueEnum};
+use parquet::{
+    arrow::{arrow_reader::ParquetRecordBatchReaderBuilder, ArrowWriter},
+    basic::Compression,
+    file::{
+        properties::{EnabledStatistics, WriterProperties, WriterVersion},
+        reader::FileReader,
+        serialized_reader::SerializedFileReader,
+    },
+};
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum, Debug)]
+enum CompressionArgs {
+    /// No compression.
+    None,
+
+    /// Snappy
+    Snappy,
+
+    /// GZip
+    Gzip,
+
+    /// LZO
+    Lzo,
+
+    /// Brotli
+    Brotli,
+
+    /// LZ4
+    Lz4,
+
+    /// Zstd
+    Zstd,
+
+    /// LZ4 Raw
+    Lz4Raw,
+}
+
+impl From<CompressionArgs> for Compression {
+    fn from(value: CompressionArgs) -> Self {
+        match value {
+            CompressionArgs::None => Self::UNCOMPRESSED,
+            CompressionArgs::Snappy => Self::SNAPPY,
+            CompressionArgs::Gzip => Self::GZIP(Default::default()),
+            CompressionArgs::Lzo => Self::LZO,
+            CompressionArgs::Brotli => Self::BROTLI(Default::default()),
+            CompressionArgs::Lz4 => Self::LZ4,
+            CompressionArgs::Zstd => Self::ZSTD(Default::default()),
+            CompressionArgs::Lz4Raw => Self::LZ4_RAW,
+        }
+    }
+}
+
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, ValueEnum, Debug)]
+enum EnabledStatisticsArgs {
+    /// Compute no statistics
+    None,
+
+    /// Compute chunk-level statistics but not page-level
+    Chunk,
+
+    /// Compute page-level and chunk-level statistics
+    Page,
+}
+
+impl From<EnabledStatisticsArgs> for EnabledStatistics {
+    fn from(value: EnabledStatisticsArgs) -> Self {
+        match value {
+            EnabledStatisticsArgs::None => Self::None,
+            EnabledStatisticsArgs::Chunk => Self::Chunk,
+            EnabledStatisticsArgs::Page => Self::Page,
+        }
+    }
+}
+
+#[derive(Clone, Copy, Debug)]
+enum WriterVersionArgs {
+    Parquet1_0,
+    Parquet2_0,
+}
+
+impl ValueEnum for WriterVersionArgs {
+    fn value_variants<'a>() -> &'a [Self] {
+        &[Self::Parquet1_0, Self::Parquet2_0]
+    }
+
+    fn to_possible_value(&self) -> Option<PossibleValue> {
+        match self {
+            WriterVersionArgs::Parquet1_0 => Some(PossibleValue::new("1.0")),
+            WriterVersionArgs::Parquet2_0 => Some(PossibleValue::new("2.0")),
+        }
+    }
+}
+
+impl From<WriterVersionArgs> for WriterVersion {
+    fn from(value: WriterVersionArgs) -> Self {
+        match value {
+            WriterVersionArgs::Parquet1_0 => Self::PARQUET_1_0,
+            WriterVersionArgs::Parquet2_0 => Self::PARQUET_2_0,
+        }
+    }
+}
+
+#[derive(Debug, Parser)]
+#[clap(author, version, about("Read and write parquet file with potentially different settings"), long_about = None)]
+struct Args {
+    /// Path to input parquet file.
+    #[clap(short, long)]
+    input: String,
+
+    /// Path to output parquet file.
+    #[clap(short, long)]
+    output: String,
+
+    /// Compression used.
+    #[clap(long, value_enum)]
+    compression: Option<CompressionArgs>,
+
+    /// Sets maximum number of rows in a row group.
+    #[clap(long)]
+    max_row_group_size: Option<usize>,
+
+    /// Sets best effort maximum number of rows in a data page.
+    #[clap(long)]
+    data_page_row_count_limit: Option<usize>,
+
+    /// Sets best effort maximum size of a data page in bytes.
+    #[clap(long)]
+    data_page_size_limit: Option<usize>,
+
+    /// Sets max statistics size for any column.
+    ///
+    /// Applicable only if statistics are enabled.
+    #[clap(long)]
+    max_statistics_size: Option<usize>,
+
+    /// Sets best effort maximum dictionary page size, in bytes.
+    #[clap(long)]
+    dictionary_page_size_limit: Option<usize>,
+
+    /// Sets whether bloom filter is enabled for any column.
+    #[clap(long)]
+    bloom_filter_enabled: Option<bool>,
+
+    /// Sets bloom filter false positive probability (fpp) for any column.
+    #[clap(long)]
+    bloom_filter_fpp: Option<f64>,
+
+    /// Sets number of distinct values (ndv) for bloom filter for any column.
+    #[clap(long)]
+    bloom_filter_ndv: Option<u64>,
+
+    /// Sets flag to enable/disable dictionary encoding for any column.
+    #[clap(long)]
+    dictionary_enabled: Option<bool>,
+
+    /// Sets flag to enable/disable statistics for any column.
+    #[clap(long)]
+    statistics_enabled: Option<EnabledStatisticsArgs>,
+
+    /// Sets writer version.
+    #[clap(long)]
+    writer_version: Option<WriterVersionArgs>,
+}
+
+fn main() {
+    let args = Args::parse();
+
+    // read key-value metadata
+    let parquet_reader =
+        SerializedFileReader::new(File::open(&args.input).expect("Unable to open input file"))
+            .expect("Failed to create reader");
+    let kv_md = parquet_reader
+        .metadata()
+        .file_metadata()
+        .key_value_metadata()
+        .cloned();
+
+    // create actual parquet reader
+    let parquet_reader = ParquetRecordBatchReaderBuilder::try_new(
+        File::open(args.input).expect("Unable to open input file"),
+    )
+    .expect("parquet open")
+    .build()
+    .expect("parquet open");
+
+    let mut writer_properties_builder = WriterProperties::builder().set_key_value_metadata(kv_md);
+    if let Some(value) = args.compression {
+        writer_properties_builder = writer_properties_builder.set_compression(value.into());
+    }
+    if let Some(value) = args.max_row_group_size {
+        writer_properties_builder = writer_properties_builder.set_max_row_group_size(value);
+    }
+    if let Some(value) = args.data_page_row_count_limit {
+        writer_properties_builder = writer_properties_builder.set_data_page_row_count_limit(value);
+    }
+    if let Some(value) = args.data_page_size_limit {
+        writer_properties_builder = writer_properties_builder.set_data_page_size_limit(value);
+    }
+    if let Some(value) = args.dictionary_page_size_limit {
+        writer_properties_builder = writer_properties_builder.set_dictionary_page_size_limit(value);
+    }
+    if let Some(value) = args.max_statistics_size {
+        writer_properties_builder = writer_properties_builder.set_max_statistics_size(value);
+    }
+    if let Some(value) = args.bloom_filter_enabled {
+        writer_properties_builder = writer_properties_builder.set_bloom_filter_enabled(value);
+
+        if value {
+            if let Some(value) = args.bloom_filter_fpp {
+                writer_properties_builder = writer_properties_builder.set_bloom_filter_fpp(value);
+            }
+            if let Some(value) = args.bloom_filter_ndv {
+                writer_properties_builder = writer_properties_builder.set_bloom_filter_ndv(value);
+            }
+        }
+    }
+    if let Some(value) = args.dictionary_enabled {
+        writer_properties_builder = writer_properties_builder.set_dictionary_enabled(value);
+    }
+    if let Some(value) = args.statistics_enabled {
+        writer_properties_builder = writer_properties_builder.set_statistics_enabled(value.into());
+    }
+    if let Some(value) = args.writer_version {
+        writer_properties_builder = writer_properties_builder.set_writer_version(value.into());
+    }
+    let writer_properties = writer_properties_builder.build();
+    let mut parquet_writer = ArrowWriter::try_new(
+        File::create(&args.output).expect("Unable to open output file"),
+        parquet_reader.schema(),
+        Some(writer_properties),
+    )
+    .expect("create arrow writer");
+
+    for maybe_batch in parquet_reader {
+        let batch = maybe_batch.expect("reading batch");
+        parquet_writer.write(&batch).expect("writing data");
+    }
+
+    parquet_writer.close().expect("finalizing file");
+}
diff --git a/parquet/src/bin/parquet-rowcount.rs b/parquet/src/bin/parquet-rowcount.rs
index d2f0311cf7a0..07e4bd1d14cc 100644
--- a/parquet/src/bin/parquet-rowcount.rs
+++ b/parquet/src/bin/parquet-rowcount.rs
@@ -36,7 +36,6 @@
 //! Note that `parquet-rowcount` reads full file schema, no projection or filtering is
 //! applied.
 
-extern crate parquet;
 use clap::Parser;
 use parquet::file::reader::{FileReader, SerializedFileReader};
 use std::{fs::File, path::Path};
@@ -45,9 +44,7 @@ use std::{fs::File, path::Path};
 #[clap(author, version, about("Binary file to return the number of rows found from Parquet file(s)"), long_about = None)]
 struct Args {
     #[clap(
-        short,
-        long,
-        multiple_values(true),
+        number_of_values(1),
         help("List of Parquet files to read from separated by space")
     )]
     file_paths: Vec<String>,
@@ -59,8 +56,7 @@ fn main() {
     for filename in args.file_paths {
         let path = Path::new(&filename);
         let file = File::open(path).expect("Unable to open file");
-        let parquet_reader =
-            SerializedFileReader::new(file).expect("Unable to read file");
+        let parquet_reader = SerializedFileReader::new(file).expect("Unable to read file");
         let row_group_metadata = parquet_reader.metadata().row_groups();
         let mut total_num_rows = 0;
 
@@ -68,6 +64,6 @@ fn main() {
             total_num_rows += group_metadata.num_rows();
         }
 
-        eprintln!("File {}: rowcount={}", filename, total_num_rows);
+        eprintln!("File {filename}: rowcount={total_num_rows}");
     }
 }
diff --git a/parquet/src/bin/parquet-schema.rs b/parquet/src/bin/parquet-schema.rs
index 68c52def7c44..bfcb77d67b2e 100644
--- a/parquet/src/bin/parquet-schema.rs
+++ b/parquet/src/bin/parquet-schema.rs
@@ -36,7 +36,6 @@
 //! Note that `verbose` is an optional boolean flag that allows to print schema only,
 //! when not provided or print full file metadata when provided.
 
-extern crate parquet;
 use clap::Parser;
 use parquet::{
     file::reader::{FileReader, SerializedFileReader},
@@ -47,7 +46,7 @@ use std::{fs::File, path::Path};
 #[derive(Debug, Parser)]
 #[clap(author, version, about("Binary file to print the schema and metadata of a Parquet file"), long_about = None)]
 struct Args {
-    #[clap(short, long)]
+    #[clap(help("Path to the parquet file"))]
     file_path: String,
     #[clap(short, long, help("Enable printing full file metadata"))]
     verbose: bool,
@@ -57,11 +56,11 @@ fn main() {
     let args = Args::parse();
     let filename = args.file_path;
     let path = Path::new(&filename);
-    let file = File::open(&path).expect("Unable to open file");
+    let file = File::open(path).expect("Unable to open file");
     let verbose = args.verbose;
 
     match SerializedFileReader::new(file) {
-        Err(e) => panic!("Error when parsing Parquet file: {}", e),
+        Err(e) => panic!("Error when parsing Parquet file: {e}"),
         Ok(parquet_reader) => {
             let metadata = parquet_reader.metadata();
             println!("Metadata for file: {}", &filename);
diff --git a/parquet/src/bin/parquet-show-bloom-filter.rs b/parquet/src/bin/parquet-show-bloom-filter.rs
new file mode 100644
index 000000000000..b1b332590ad2
--- /dev/null
+++ b/parquet/src/bin/parquet-show-bloom-filter.rs
@@ -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.
+
+//! Binary file to read bloom filter data from a Parquet file.
+//!
+//! # Install
+//!
+//! `parquet-show-bloom-filter` can be installed using `cargo`:
+//! ```
+//! cargo install parquet --features=cli
+//! ```
+//! After this `parquet-show-bloom-filter` should be available:
+//! ```
+//! parquet-show-bloom-filter XYZ.parquet id a
+//! ```
+//!
+//! The binary can also be built from the source code and run as follows:
+//! ```
+//! cargo run --features=cli --bin parquet-show-bloom-filter -- --file-name XYZ.parquet --column id --values a
+//! ```
+
+use clap::Parser;
+use parquet::file::{
+    properties::ReaderProperties,
+    reader::{FileReader, SerializedFileReader},
+    serialized_reader::ReadOptionsBuilder,
+};
+use std::{fs::File, path::Path};
+
+#[derive(Debug, Parser)]
+#[clap(author, version, about("Binary file to read bloom filter data from a Parquet file"), long_about = None)]
+struct Args {
+    #[clap(help("Path to the parquet file"))]
+    file_name: String,
+    #[clap(help("Check the bloom filter indexes for the given column"))]
+    column: String,
+    #[clap(
+        help(
+            "Check if the given values match bloom filter, the values will be evaluated as strings"
+        ),
+        required = true
+    )]
+    values: Vec<String>,
+}
+
+fn main() {
+    let args = Args::parse();
+    let file_name = args.file_name;
+    let path = Path::new(&file_name);
+    let file = File::open(path).expect("Unable to open file");
+
+    let file_reader = SerializedFileReader::new_with_options(
+        file,
+        ReadOptionsBuilder::new()
+            .with_reader_properties(
+                ReaderProperties::builder()
+                    .set_read_bloom_filter(true)
+                    .build(),
+            )
+            .build(),
+    )
+    .expect("Unable to open file as Parquet");
+    let metadata = file_reader.metadata();
+    for (ri, row_group) in metadata.row_groups().iter().enumerate() {
+        println!("Row group #{ri}");
+        println!("{}", "=".repeat(80));
+        if let Some((column_index, _)) = row_group
+            .columns()
+            .iter()
+            .enumerate()
+            .find(|(_, column)| column.column_path().string() == args.column)
+        {
+            let row_group_reader = file_reader
+                .get_row_group(ri)
+                .expect("Unable to read row group");
+            if let Some(sbbf) = row_group_reader.get_column_bloom_filter(column_index) {
+                args.values.iter().for_each(|value| {
+                    println!(
+                        "Value {} is {} in bloom filter",
+                        value,
+                        if sbbf.check(&value.as_str()) {
+                            "present"
+                        } else {
+                            "absent"
+                        }
+                    )
+                });
+            } else {
+                println!("No bloom filter found for column {}", args.column);
+            }
+        } else {
+            println!(
+                "No column named {} found, candidate columns are: {}",
+                args.column,
+                row_group
+                    .columns()
+                    .iter()
+                    .map(|c| c.column_path().string())
+                    .collect::<Vec<_>>()
+                    .join(", ")
+            );
+        }
+    }
+}
diff --git a/parquet/src/bloom_filter/mod.rs b/parquet/src/bloom_filter/mod.rs
new file mode 100644
index 000000000000..897cce7620aa
--- /dev/null
+++ b/parquet/src/bloom_filter/mod.rs
@@ -0,0 +1,467 @@
+// 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.
+
+//! Bloom filter implementation specific to Parquet, as described
+//! in the [spec](https://github.com/apache/parquet-format/blob/master/BloomFilter.md).
+
+use crate::data_type::AsBytes;
+use crate::errors::ParquetError;
+use crate::file::metadata::ColumnChunkMetaData;
+use crate::file::reader::ChunkReader;
+use crate::format::{
+    BloomFilterAlgorithm, BloomFilterCompression, BloomFilterHash, BloomFilterHeader,
+    SplitBlockAlgorithm, Uncompressed, XxHash,
+};
+use crate::thrift::{TCompactSliceInputProtocol, TSerializable};
+use bytes::Bytes;
+use std::hash::Hasher;
+use std::io::Write;
+use std::sync::Arc;
+use thrift::protocol::{TCompactOutputProtocol, TOutputProtocol};
+use twox_hash::XxHash64;
+
+/// Salt as defined in the [spec](https://github.com/apache/parquet-format/blob/master/BloomFilter.md#technical-approach).
+const SALT: [u32; 8] = [
+    0x47b6137b_u32,
+    0x44974d91_u32,
+    0x8824ad5b_u32,
+    0xa2b7289d_u32,
+    0x705495c7_u32,
+    0x2df1424b_u32,
+    0x9efc4947_u32,
+    0x5c6bfb31_u32,
+];
+
+/// Each block is 256 bits, broken up into eight contiguous "words", each consisting of 32 bits.
+/// Each word is thought of as an array of bits; each bit is either "set" or "not set".
+#[derive(Debug, Copy, Clone)]
+struct Block([u32; 8]);
+impl Block {
+    const ZERO: Block = Block([0; 8]);
+
+    /// takes as its argument a single unsigned 32-bit integer and returns a block in which each
+    /// word has exactly one bit set.
+    fn mask(x: u32) -> Self {
+        let mut result = [0_u32; 8];
+        for i in 0..8 {
+            // wrapping instead of checking for overflow
+            let y = x.wrapping_mul(SALT[i]);
+            let y = y >> 27;
+            result[i] = 1 << y;
+        }
+        Self(result)
+    }
+
+    #[inline]
+    #[cfg(target_endian = "little")]
+    fn to_le_bytes(self) -> [u8; 32] {
+        self.to_ne_bytes()
+    }
+
+    #[inline]
+    #[cfg(not(target_endian = "little"))]
+    fn to_le_bytes(self) -> [u8; 32] {
+        self.swap_bytes().to_ne_bytes()
+    }
+
+    #[inline]
+    fn to_ne_bytes(self) -> [u8; 32] {
+        unsafe { std::mem::transmute(self) }
+    }
+
+    #[inline]
+    #[cfg(not(target_endian = "little"))]
+    fn swap_bytes(mut self) -> Self {
+        self.0.iter_mut().for_each(|x| *x = x.swap_bytes());
+        self
+    }
+
+    /// setting every bit in the block that was also set in the result from mask
+    fn insert(&mut self, hash: u32) {
+        let mask = Self::mask(hash);
+        for i in 0..8 {
+            self[i] |= mask[i];
+        }
+    }
+
+    /// returns true when every bit that is set in the result of mask is also set in the block.
+    fn check(&self, hash: u32) -> bool {
+        let mask = Self::mask(hash);
+        for i in 0..8 {
+            if self[i] & mask[i] == 0 {
+                return false;
+            }
+        }
+        true
+    }
+}
+
+impl std::ops::Index<usize> for Block {
+    type Output = u32;
+
+    #[inline]
+    fn index(&self, index: usize) -> &Self::Output {
+        self.0.index(index)
+    }
+}
+
+impl std::ops::IndexMut<usize> for Block {
+    #[inline]
+    fn index_mut(&mut self, index: usize) -> &mut Self::Output {
+        self.0.index_mut(index)
+    }
+}
+
+/// A split block Bloom filter. The creation of this structure is based on the
+/// [`crate::file::properties::BloomFilterProperties`] struct set via [`crate::file::properties::WriterProperties`] and
+/// is thus hidden by default.
+#[derive(Debug, Clone)]
+pub struct Sbbf(Vec<Block>);
+
+pub(crate) const SBBF_HEADER_SIZE_ESTIMATE: usize = 20;
+
+/// given an initial offset, and a byte buffer, try to read out a bloom filter header and return
+/// both the header and the offset after it (for bitset).
+pub(crate) fn chunk_read_bloom_filter_header_and_offset(
+    offset: u64,
+    buffer: Bytes,
+) -> Result<(BloomFilterHeader, u64), ParquetError> {
+    let (header, length) = read_bloom_filter_header_and_length(buffer)?;
+    Ok((header, offset + length))
+}
+
+/// given a [Bytes] buffer, try to read out a bloom filter header and return both the header and
+/// length of the header.
+#[inline]
+pub(crate) fn read_bloom_filter_header_and_length(
+    buffer: Bytes,
+) -> Result<(BloomFilterHeader, u64), ParquetError> {
+    let total_length = buffer.len();
+    let mut prot = TCompactSliceInputProtocol::new(buffer.as_ref());
+    let header = BloomFilterHeader::read_from_in_protocol(&mut prot)
+        .map_err(|e| ParquetError::General(format!("Could not read bloom filter header: {e}")))?;
+    Ok((header, (total_length - prot.as_slice().len()) as u64))
+}
+
+pub(crate) const BITSET_MIN_LENGTH: usize = 32;
+pub(crate) const BITSET_MAX_LENGTH: usize = 128 * 1024 * 1024;
+
+#[inline]
+fn optimal_num_of_bytes(num_bytes: usize) -> usize {
+    let num_bytes = num_bytes.min(BITSET_MAX_LENGTH);
+    let num_bytes = num_bytes.max(BITSET_MIN_LENGTH);
+    num_bytes.next_power_of_two()
+}
+
+// see http://algo2.iti.kit.edu/documents/cacheefficientbloomfilters-jea.pdf
+// given fpp = (1 - e^(-k * n / m)) ^ k
+// we have m = - k * n / ln(1 - fpp ^ (1 / k))
+// where k = number of hash functions, m = number of bits, n = number of distinct values
+#[inline]
+fn num_of_bits_from_ndv_fpp(ndv: u64, fpp: f64) -> usize {
+    let num_bits = -8.0 * ndv as f64 / (1.0 - fpp.powf(1.0 / 8.0)).ln();
+    num_bits as usize
+}
+
+impl Sbbf {
+    /// Create a new [Sbbf] with given number of distinct values and false positive probability.
+    /// Will panic if `fpp` is greater than 1.0 or less than 0.0.
+    pub(crate) fn new_with_ndv_fpp(ndv: u64, fpp: f64) -> Result<Self, ParquetError> {
+        if !(0.0..1.0).contains(&fpp) {
+            return Err(ParquetError::General(format!(
+                "False positive probability must be between 0.0 and 1.0, got {fpp}"
+            )));
+        }
+        let num_bits = num_of_bits_from_ndv_fpp(ndv, fpp);
+        Ok(Self::new_with_num_of_bytes(num_bits / 8))
+    }
+
+    /// Create a new [Sbbf] with given number of bytes, the exact number of bytes will be adjusted
+    /// to the next power of two bounded by [BITSET_MIN_LENGTH] and [BITSET_MAX_LENGTH].
+    pub(crate) fn new_with_num_of_bytes(num_bytes: usize) -> Self {
+        let num_bytes = optimal_num_of_bytes(num_bytes);
+        let bitset = vec![0_u8; num_bytes];
+        Self::new(&bitset)
+    }
+
+    pub(crate) fn new(bitset: &[u8]) -> Self {
+        let data = bitset
+            .chunks_exact(4 * 8)
+            .map(|chunk| {
+                let mut block = Block::ZERO;
+                for (i, word) in chunk.chunks_exact(4).enumerate() {
+                    block[i] = u32::from_le_bytes(word.try_into().unwrap());
+                }
+                block
+            })
+            .collect::<Vec<Block>>();
+        Self(data)
+    }
+
+    /// Write the bloom filter data (header and then bitset) to the output. This doesn't
+    /// flush the writer in order to boost performance of bulk writing all blocks. Caller
+    /// must remember to flush the writer.
+    pub(crate) fn write<W: Write>(&self, mut writer: W) -> Result<(), ParquetError> {
+        let mut protocol = TCompactOutputProtocol::new(&mut writer);
+        let header = self.header();
+        header.write_to_out_protocol(&mut protocol).map_err(|e| {
+            ParquetError::General(format!("Could not write bloom filter header: {e}"))
+        })?;
+        protocol.flush()?;
+        self.write_bitset(&mut writer)?;
+        Ok(())
+    }
+
+    /// Write the bitset in serialized form to the writer.
+    fn write_bitset<W: Write>(&self, mut writer: W) -> Result<(), ParquetError> {
+        for block in &self.0 {
+            writer
+                .write_all(block.to_le_bytes().as_slice())
+                .map_err(|e| {
+                    ParquetError::General(format!("Could not write bloom filter bit set: {e}"))
+                })?;
+        }
+        Ok(())
+    }
+
+    /// Create and populate [`BloomFilterHeader`] from this bitset for writing to serialized form
+    fn header(&self) -> BloomFilterHeader {
+        BloomFilterHeader {
+            // 8 i32 per block, 4 bytes per i32
+            num_bytes: self.0.len() as i32 * 4 * 8,
+            algorithm: BloomFilterAlgorithm::BLOCK(SplitBlockAlgorithm {}),
+            hash: BloomFilterHash::XXHASH(XxHash {}),
+            compression: BloomFilterCompression::UNCOMPRESSED(Uncompressed {}),
+        }
+    }
+
+    /// Read a new bloom filter from the given offset in the given reader.
+    pub(crate) fn read_from_column_chunk<R: ChunkReader>(
+        column_metadata: &ColumnChunkMetaData,
+        reader: Arc<R>,
+    ) -> Result<Option<Self>, ParquetError> {
+        let offset: u64 = if let Some(offset) = column_metadata.bloom_filter_offset() {
+            offset
+                .try_into()
+                .map_err(|_| ParquetError::General("Bloom filter offset is invalid".to_string()))?
+        } else {
+            return Ok(None);
+        };
+
+        let buffer = match column_metadata.bloom_filter_length() {
+            Some(length) => reader.get_bytes(offset, length as usize),
+            None => reader.get_bytes(offset, SBBF_HEADER_SIZE_ESTIMATE),
+        }?;
+
+        let (header, bitset_offset) =
+            chunk_read_bloom_filter_header_and_offset(offset, buffer.clone())?;
+
+        match header.algorithm {
+            BloomFilterAlgorithm::BLOCK(_) => {
+                // this match exists to future proof the singleton algorithm enum
+            }
+        }
+        match header.compression {
+            BloomFilterCompression::UNCOMPRESSED(_) => {
+                // this match exists to future proof the singleton compression enum
+            }
+        }
+        match header.hash {
+            BloomFilterHash::XXHASH(_) => {
+                // this match exists to future proof the singleton hash enum
+            }
+        }
+
+        let bitset = match column_metadata.bloom_filter_length() {
+            Some(_) => buffer.slice((bitset_offset - offset) as usize..),
+            None => {
+                let bitset_length: usize = header.num_bytes.try_into().map_err(|_| {
+                    ParquetError::General("Bloom filter length is invalid".to_string())
+                })?;
+                reader.get_bytes(bitset_offset, bitset_length)?
+            }
+        };
+
+        Ok(Some(Self::new(&bitset)))
+    }
+
+    #[inline]
+    fn hash_to_block_index(&self, hash: u64) -> usize {
+        // unchecked_mul is unstable, but in reality this is safe, we'd just use saturating mul
+        // but it will not saturate
+        (((hash >> 32).saturating_mul(self.0.len() as u64)) >> 32) as usize
+    }
+
+    /// Insert an [AsBytes] value into the filter
+    pub fn insert<T: AsBytes + ?Sized>(&mut self, value: &T) {
+        self.insert_hash(hash_as_bytes(value));
+    }
+
+    /// Insert a hash into the filter
+    fn insert_hash(&mut self, hash: u64) {
+        let block_index = self.hash_to_block_index(hash);
+        self.0[block_index].insert(hash as u32)
+    }
+
+    /// Check if an [AsBytes] value is probably present or definitely absent in the filter
+    pub fn check<T: AsBytes>(&self, value: &T) -> bool {
+        self.check_hash(hash_as_bytes(value))
+    }
+
+    /// Check if a hash is in the filter. May return
+    /// true for values that was never inserted ("false positive")
+    /// but will always return false if a hash has not been inserted.
+    fn check_hash(&self, hash: u64) -> bool {
+        let block_index = self.hash_to_block_index(hash);
+        self.0[block_index].check(hash as u32)
+    }
+}
+
+// per spec we use xxHash with seed=0
+const SEED: u64 = 0;
+
+#[inline]
+fn hash_as_bytes<A: AsBytes + ?Sized>(value: &A) -> u64 {
+    let mut hasher = XxHash64::with_seed(SEED);
+    hasher.write(value.as_bytes());
+    hasher.finish()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::format::{
+        BloomFilterAlgorithm, BloomFilterCompression, SplitBlockAlgorithm, Uncompressed, XxHash,
+    };
+
+    #[test]
+    fn test_hash_bytes() {
+        assert_eq!(hash_as_bytes(""), 17241709254077376921);
+    }
+
+    #[test]
+    fn test_mask_set_quick_check() {
+        for i in 0..1_000_000 {
+            let result = Block::mask(i);
+            assert!(result.0.iter().all(|&x| x.count_ones() == 1));
+        }
+    }
+
+    #[test]
+    fn test_block_insert_and_check() {
+        for i in 0..1_000_000 {
+            let mut block = Block::ZERO;
+            block.insert(i);
+            assert!(block.check(i));
+        }
+    }
+
+    #[test]
+    fn test_sbbf_insert_and_check() {
+        let mut sbbf = Sbbf(vec![Block::ZERO; 1_000]);
+        for i in 0..1_000_000 {
+            sbbf.insert(&i);
+            assert!(sbbf.check(&i));
+        }
+    }
+
+    #[test]
+    fn test_with_fixture() {
+        // bloom filter produced by parquet-mr/spark for a column of i64 f"a{i}" for i in 0..10
+        let bitset: &[u8] = &[
+            200, 1, 80, 20, 64, 68, 8, 109, 6, 37, 4, 67, 144, 80, 96, 32, 8, 132, 43, 33, 0, 5,
+            99, 65, 2, 0, 224, 44, 64, 78, 96, 4,
+        ];
+        let sbbf = Sbbf::new(bitset);
+        for a in 0..10i64 {
+            let value = format!("a{a}");
+            assert!(sbbf.check(&value.as_str()));
+        }
+    }
+
+    /// test the assumption that bloom filter header size should not exceed SBBF_HEADER_SIZE_ESTIMATE
+    /// essentially we are testing that the struct is packed with 4 i32 fields, each can be 1-5 bytes
+    /// so altogether it'll be 20 bytes at most.
+    #[test]
+    fn test_bloom_filter_header_size_assumption() {
+        let buffer: &[u8; 16] = &[21, 64, 28, 28, 0, 0, 28, 28, 0, 0, 28, 28, 0, 0, 0, 99];
+        let (
+            BloomFilterHeader {
+                algorithm,
+                compression,
+                hash,
+                num_bytes,
+            },
+            read_length,
+        ) = read_bloom_filter_header_and_length(Bytes::copy_from_slice(buffer)).unwrap();
+        assert_eq!(read_length, 15);
+        assert_eq!(
+            algorithm,
+            BloomFilterAlgorithm::BLOCK(SplitBlockAlgorithm {})
+        );
+        assert_eq!(
+            compression,
+            BloomFilterCompression::UNCOMPRESSED(Uncompressed {})
+        );
+        assert_eq!(hash, BloomFilterHash::XXHASH(XxHash {}));
+        assert_eq!(num_bytes, 32_i32);
+        assert_eq!(20, SBBF_HEADER_SIZE_ESTIMATE);
+    }
+
+    #[test]
+    fn test_optimal_num_of_bytes() {
+        for (input, expected) in &[
+            (0, 32),
+            (9, 32),
+            (31, 32),
+            (32, 32),
+            (33, 64),
+            (99, 128),
+            (1024, 1024),
+            (999_000_000, 128 * 1024 * 1024),
+        ] {
+            assert_eq!(*expected, optimal_num_of_bytes(*input));
+        }
+    }
+
+    #[test]
+    fn test_num_of_bits_from_ndv_fpp() {
+        for (fpp, ndv, num_bits) in &[
+            (0.1, 10, 57),
+            (0.01, 10, 96),
+            (0.001, 10, 146),
+            (0.1, 100, 577),
+            (0.01, 100, 968),
+            (0.001, 100, 1460),
+            (0.1, 1000, 5772),
+            (0.01, 1000, 9681),
+            (0.001, 1000, 14607),
+            (0.1, 10000, 57725),
+            (0.01, 10000, 96815),
+            (0.001, 10000, 146076),
+            (0.1, 100000, 577254),
+            (0.01, 100000, 968152),
+            (0.001, 100000, 1460769),
+            (0.1, 1000000, 5772541),
+            (0.01, 1000000, 9681526),
+            (0.001, 1000000, 14607697),
+            (1e-50, 1_000_000_000_000, 14226231280773240832),
+        ] {
+            assert_eq!(*num_bits, num_of_bits_from_ndv_fpp(*ndv, *fpp) as u64);
+        }
+    }
+}
diff --git a/parquet/src/column/mod.rs b/parquet/src/column/mod.rs
index 93a4f00d2eef..c81d6290abc2 100644
--- a/parquet/src/column/mod.rs
+++ b/parquet/src/column/mod.rs
@@ -36,18 +36,18 @@
 //! repetition levels and read them to verify write/read correctness.
 //!
 //! ```rust,no_run
-//! use std::{fs, path::Path, sync::Arc};
-//!
-//! use parquet::{
-//!     column::{reader::ColumnReader, writer::ColumnWriter},
-//!     data_type::Int32Type,
-//!     file::{
-//!         properties::WriterProperties,
-//!         reader::{FileReader, SerializedFileReader},
-//!         writer::SerializedFileWriter,
-//!     },
-//!     schema::parser::parse_message_type,
-//! };
+//! # use std::{fs, path::Path, sync::Arc};
+//! #
+//! # use parquet::{
+//! #    column::{reader::ColumnReader, writer::ColumnWriter},
+//! #    data_type::Int32Type,
+//! #    file::{
+//! #        properties::WriterProperties,
+//! #        reader::{FileReader, SerializedFileReader},
+//! #        writer::SerializedFileWriter,
+//! #    },
+//! #    schema::parser::parse_message_type,
+//! # };
 //!
 //! let path = Path::new("/path/to/column_sample.parquet");
 //!
@@ -63,9 +63,8 @@
 //!   }
 //! ";
 //! let schema = Arc::new(parse_message_type(message_type).unwrap());
-//! let props = Arc::new(WriterProperties::builder().build());
 //! let file = fs::File::create(path).unwrap();
-//! let mut writer = SerializedFileWriter::new(file, schema, props).unwrap();
+//! let mut writer = SerializedFileWriter::new(file, schema, Default::default()).unwrap();
 //!
 //! let mut row_group_writer = writer.next_row_group().unwrap();
 //! while let Some(mut col_writer) = row_group_writer.next_column().unwrap() {
@@ -85,7 +84,6 @@
 //! let reader = SerializedFileReader::new(file).unwrap();
 //! let metadata = reader.metadata();
 //!
-//! let mut res = Ok((0, 0));
 //! let mut values = vec![0; 8];
 //! let mut def_levels = vec![0; 8];
 //! let mut rep_levels = vec![0; 8];
@@ -99,19 +97,21 @@
 //!         match column_reader {
 //!             // You can also use `get_typed_column_reader` method to extract typed reader.
 //!             ColumnReader::Int32ColumnReader(ref mut typed_reader) => {
-//!                 res = typed_reader.read_batch(
-//!                     8, // batch size
+//!                 let (records, values, levels) = typed_reader.read_records(
+//!                     8, // maximum records to read
 //!                     Some(&mut def_levels),
 //!                     Some(&mut rep_levels),
 //!                     &mut values,
-//!                 );
+//!                 ).unwrap();
+//!                 assert_eq!(records, 2);
+//!                 assert_eq!(levels, 5);
+//!                 assert_eq!(values, 3);
 //!             }
 //!             _ => {}
 //!         }
 //!     }
 //! }
 //!
-//! assert_eq!(res, Ok((3, 5)));
 //! assert_eq!(values, vec![1, 2, 3, 0, 0, 0, 0, 0]);
 //! assert_eq!(def_levels, vec![3, 3, 3, 2, 2, 0, 0, 0]);
 //! assert_eq!(rep_levels, vec![0, 1, 0, 1, 1, 0, 0, 0]);
diff --git a/parquet/src/column/page.rs b/parquet/src/column/page.rs
index 1658797cee7d..947a633f48a2 100644
--- a/parquet/src/column/page.rs
+++ b/parquet/src/column/page.rs
@@ -17,12 +17,12 @@
 
 //! Contains Parquet Page definitions and page reader interface.
 
+use bytes::Bytes;
+
 use crate::basic::{Encoding, PageType};
 use crate::errors::{ParquetError, Result};
 use crate::file::{metadata::ColumnChunkMetaData, statistics::Statistics};
-use crate::schema::types::{ColumnDescPtr, SchemaDescPtr};
-use crate::util::memory::ByteBufferPtr;
-use parquet_format::PageHeader;
+use crate::format::PageHeader;
 
 /// Parquet Page definition.
 ///
@@ -32,7 +32,7 @@ use parquet_format::PageHeader;
 #[derive(Clone)]
 pub enum Page {
     DataPage {
-        buf: ByteBufferPtr,
+        buf: Bytes,
         num_values: u32,
         encoding: Encoding,
         def_level_encoding: Encoding,
@@ -40,7 +40,7 @@ pub enum Page {
         statistics: Option<Statistics>,
     },
     DataPageV2 {
-        buf: ByteBufferPtr,
+        buf: Bytes,
         num_values: u32,
         encoding: Encoding,
         num_nulls: u32,
@@ -51,7 +51,7 @@ pub enum Page {
         statistics: Option<Statistics>,
     },
     DictionaryPage {
-        buf: ByteBufferPtr,
+        buf: Bytes,
         num_values: u32,
         encoding: Encoding,
         is_sorted: bool,
@@ -59,7 +59,7 @@ pub enum Page {
 }
 
 impl Page {
-    /// Returns [`PageType`](crate::basic::PageType) for this page.
+    /// Returns [`PageType`] for this page.
     pub fn page_type(&self) -> PageType {
         match self {
             Page::DataPage { .. } => PageType::DATA_PAGE,
@@ -69,7 +69,7 @@ impl Page {
     }
 
     /// Returns internal byte buffer reference for this page.
-    pub fn buffer(&self) -> &ByteBufferPtr {
+    pub fn buffer(&self) -> &Bytes {
         match self {
             Page::DataPage { ref buf, .. } => buf,
             Page::DataPageV2 { ref buf, .. } => buf,
@@ -86,7 +86,7 @@ impl Page {
         }
     }
 
-    /// Returns this page [`Encoding`](crate::basic::Encoding).
+    /// Returns this page [`Encoding`].
     pub fn encoding(&self) -> Encoding {
         match self {
             Page::DataPage { encoding, .. } => *encoding,
@@ -95,7 +95,7 @@ impl Page {
         }
     }
 
-    /// Returns optional [`Statistics`](crate::file::statistics::Statistics).
+    /// Returns optional [`Statistics`].
     pub fn statistics(&self) -> Option<&Statistics> {
         match self {
             Page::DataPage { ref statistics, .. } => statistics.as_ref(),
@@ -160,7 +160,76 @@ impl CompressedPage {
 
     /// Returns slice of compressed buffer in the page.
     pub fn data(&self) -> &[u8] {
-        self.compressed_page.buffer().data()
+        self.compressed_page.buffer()
+    }
+
+    /// Returns the thrift page header
+    pub(crate) fn to_thrift_header(&self) -> PageHeader {
+        let uncompressed_size = self.uncompressed_size();
+        let compressed_size = self.compressed_size();
+        let num_values = self.num_values();
+        let encoding = self.encoding();
+        let page_type = self.page_type();
+
+        let mut page_header = PageHeader {
+            type_: page_type.into(),
+            uncompressed_page_size: uncompressed_size as i32,
+            compressed_page_size: compressed_size as i32,
+            // TODO: Add support for crc checksum
+            crc: None,
+            data_page_header: None,
+            index_page_header: None,
+            dictionary_page_header: None,
+            data_page_header_v2: None,
+        };
+
+        match self.compressed_page {
+            Page::DataPage {
+                def_level_encoding,
+                rep_level_encoding,
+                ref statistics,
+                ..
+            } => {
+                let data_page_header = crate::format::DataPageHeader {
+                    num_values: num_values as i32,
+                    encoding: encoding.into(),
+                    definition_level_encoding: def_level_encoding.into(),
+                    repetition_level_encoding: rep_level_encoding.into(),
+                    statistics: crate::file::statistics::to_thrift(statistics.as_ref()),
+                };
+                page_header.data_page_header = Some(data_page_header);
+            }
+            Page::DataPageV2 {
+                num_nulls,
+                num_rows,
+                def_levels_byte_len,
+                rep_levels_byte_len,
+                is_compressed,
+                ref statistics,
+                ..
+            } => {
+                let data_page_header_v2 = crate::format::DataPageHeaderV2 {
+                    num_values: num_values as i32,
+                    num_nulls: num_nulls as i32,
+                    num_rows: num_rows as i32,
+                    encoding: encoding.into(),
+                    definition_levels_byte_length: def_levels_byte_len as i32,
+                    repetition_levels_byte_length: rep_levels_byte_len as i32,
+                    is_compressed: Some(is_compressed),
+                    statistics: crate::file::statistics::to_thrift(statistics.as_ref()),
+                };
+                page_header.data_page_header_v2 = Some(data_page_header_v2);
+            }
+            Page::DictionaryPage { is_sorted, .. } => {
+                let dictionary_page_header = crate::format::DictionaryPageHeader {
+                    num_values: num_values as i32,
+                    encoding: encoding.into(),
+                    is_sorted: Some(is_sorted),
+                };
+                page_header.dictionary_page_header = Some(dictionary_page_header);
+            }
+        }
+        page_header
     }
 }
 
@@ -195,10 +264,12 @@ impl PageWriteSpec {
 }
 
 /// Contains metadata for a page
+#[derive(Clone)]
 pub struct PageMetadata {
-    /// The number of rows in this page
-    pub num_rows: usize,
-
+    /// The number of rows within the page if known
+    pub num_rows: Option<usize>,
+    /// The number of levels within the page if known
+    pub num_levels: Option<usize>,
     /// Returns true if the page is a dictionary page
     pub is_dict: bool,
 }
@@ -208,21 +279,29 @@ impl TryFrom<&PageHeader> for PageMetadata {
 
     fn try_from(value: &PageHeader) -> std::result::Result<Self, Self::Error> {
         match value.type_ {
-            parquet_format::PageType::DataPage => Ok(PageMetadata {
-                num_rows: value.data_page_header.as_ref().unwrap().num_values as usize,
-                is_dict: false,
-            }),
-            parquet_format::PageType::DictionaryPage => Ok(PageMetadata {
-                num_rows: usize::MIN,
+            crate::format::PageType::DATA_PAGE => {
+                let header = value.data_page_header.as_ref().unwrap();
+                Ok(PageMetadata {
+                    num_rows: None,
+                    num_levels: Some(header.num_values as _),
+                    is_dict: false,
+                })
+            }
+            crate::format::PageType::DICTIONARY_PAGE => Ok(PageMetadata {
+                num_rows: None,
+                num_levels: None,
                 is_dict: true,
             }),
-            parquet_format::PageType::DataPageV2 => Ok(PageMetadata {
-                num_rows: value.data_page_header_v2.as_ref().unwrap().num_rows as usize,
-                is_dict: false,
-            }),
+            crate::format::PageType::DATA_PAGE_V2 => {
+                let header = value.data_page_header_v2.as_ref().unwrap();
+                Ok(PageMetadata {
+                    num_rows: Some(header.num_rows as _),
+                    num_levels: Some(header.num_values as _),
+                    is_dict: false,
+                })
+            }
             other => Err(ParquetError::General(format!(
-                "page type {:?} cannot be converted to PageMetadata",
-                other
+                "page type {other:?} cannot be converted to PageMetadata"
             ))),
         }
     }
@@ -242,13 +321,27 @@ pub trait PageReader: Iterator<Item = Result<Page>> + Send {
     /// Skips reading the next page, returns an error if no
     /// column index information
     fn skip_next_page(&mut self) -> Result<()>;
+
+    /// Returns `true` if the next page can be assumed to contain the start of a new record
+    ///
+    /// Prior to parquet V2 the specification was ambiguous as to whether a single record
+    /// could be split across multiple pages, and prior to [(#4327)] the Rust writer would do
+    /// this in certain situations. However, correctly interpreting the offset index relies on
+    /// this assumption holding [(#4943)], and so this mechanism is provided for a [`PageReader`]
+    /// to signal this to the calling context
+    ///
+    /// [(#4327)]: https://github.com/apache/arrow-rs/pull/4327
+    /// [(#4943)]: https://github.com/apache/arrow-rs/pull/4943
+    fn at_record_boundary(&mut self) -> Result<bool> {
+        Ok(self.peek_next_page()?.is_none())
+    }
 }
 
 /// API for writing pages in a column chunk.
 ///
 /// It is reasonable to assume that all pages will be written in the correct order, e.g.
 /// dictionary page followed by data pages, or a set of data pages, etc.
-pub trait PageWriter {
+pub trait PageWriter: Send {
     /// Writes a page into the output stream/sink.
     /// Returns `PageWriteSpec` that contains information about written page metrics,
     /// including number of bytes, size, number of values, offset, etc.
@@ -269,13 +362,7 @@ pub trait PageWriter {
 }
 
 /// An iterator over pages of one specific column in a parquet file.
-pub trait PageIterator: Iterator<Item = Result<Box<dyn PageReader>>> + Send {
-    /// Get schema of parquet file.
-    fn schema(&mut self) -> Result<SchemaDescPtr>;
-
-    /// Get column schema of this page iterator.
-    fn column_schema(&mut self) -> Result<ColumnDescPtr>;
-}
+pub trait PageIterator: Iterator<Item = Result<Box<dyn PageReader>>> + Send {}
 
 #[cfg(test)]
 mod tests {
@@ -284,7 +371,7 @@ mod tests {
     #[test]
     fn test_page() {
         let data_page = Page::DataPage {
-            buf: ByteBufferPtr::new(vec![0, 1, 2]),
+            buf: Bytes::from(vec![0, 1, 2]),
             num_values: 10,
             encoding: Encoding::PLAIN,
             def_level_encoding: Encoding::RLE,
@@ -292,7 +379,7 @@ mod tests {
             statistics: Some(Statistics::int32(Some(1), Some(2), None, 1, true)),
         };
         assert_eq!(data_page.page_type(), PageType::DATA_PAGE);
-        assert_eq!(data_page.buffer().data(), vec![0, 1, 2].as_slice());
+        assert_eq!(data_page.buffer(), vec![0, 1, 2].as_slice());
         assert_eq!(data_page.num_values(), 10);
         assert_eq!(data_page.encoding(), Encoding::PLAIN);
         assert_eq!(
@@ -301,7 +388,7 @@ mod tests {
         );
 
         let data_page_v2 = Page::DataPageV2 {
-            buf: ByteBufferPtr::new(vec![0, 1, 2]),
+            buf: Bytes::from(vec![0, 1, 2]),
             num_values: 10,
             encoding: Encoding::PLAIN,
             num_nulls: 5,
@@ -312,7 +399,7 @@ mod tests {
             statistics: Some(Statistics::int32(Some(1), Some(2), None, 1, true)),
         };
         assert_eq!(data_page_v2.page_type(), PageType::DATA_PAGE_V2);
-        assert_eq!(data_page_v2.buffer().data(), vec![0, 1, 2].as_slice());
+        assert_eq!(data_page_v2.buffer(), vec![0, 1, 2].as_slice());
         assert_eq!(data_page_v2.num_values(), 10);
         assert_eq!(data_page_v2.encoding(), Encoding::PLAIN);
         assert_eq!(
@@ -321,13 +408,13 @@ mod tests {
         );
 
         let dict_page = Page::DictionaryPage {
-            buf: ByteBufferPtr::new(vec![0, 1, 2]),
+            buf: Bytes::from(vec![0, 1, 2]),
             num_values: 10,
             encoding: Encoding::PLAIN,
             is_sorted: false,
         };
         assert_eq!(dict_page.page_type(), PageType::DICTIONARY_PAGE);
-        assert_eq!(dict_page.buffer().data(), vec![0, 1, 2].as_slice());
+        assert_eq!(dict_page.buffer(), vec![0, 1, 2].as_slice());
         assert_eq!(dict_page.num_values(), 10);
         assert_eq!(dict_page.encoding(), Encoding::PLAIN);
         assert_eq!(dict_page.statistics(), None);
@@ -336,7 +423,7 @@ mod tests {
     #[test]
     fn test_compressed_page() {
         let data_page = Page::DataPage {
-            buf: ByteBufferPtr::new(vec![0, 1, 2]),
+            buf: Bytes::from(vec![0, 1, 2]),
             num_values: 10,
             encoding: Encoding::PLAIN,
             def_level_encoding: Encoding::RLE,
diff --git a/parquet/src/column/reader.rs b/parquet/src/column/reader.rs
index 1432c72b53f1..53d56dd6b9f6 100644
--- a/parquet/src/column/reader.rs
+++ b/parquet/src/column/reader.rs
@@ -17,19 +17,18 @@
 
 //! Contains column reader API.
 
-use std::cmp::min;
+use bytes::Bytes;
 
 use super::page::{Page, PageReader};
 use crate::basic::*;
 use crate::column::reader::decoder::{
-    ColumnLevelDecoderImpl, ColumnValueDecoder, ColumnValueDecoderImpl,
-    DefinitionLevelDecoder, LevelsBufferSlice, RepetitionLevelDecoder, ValuesBufferSlice,
+    ColumnValueDecoder, ColumnValueDecoderImpl, DefinitionLevelDecoder, DefinitionLevelDecoderImpl,
+    RepetitionLevelDecoder, RepetitionLevelDecoderImpl,
 };
 use crate::data_type::*;
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::ColumnDescPtr;
 use crate::util::bit_util::{ceil, num_required_bits, read_num_bytes};
-use crate::util::memory::ByteBufferPtr;
 
 pub(crate) mod decoder;
 
@@ -52,34 +51,27 @@ pub fn get_column_reader(
     col_page_reader: Box<dyn PageReader>,
 ) -> ColumnReader {
     match col_descr.physical_type() {
-        Type::BOOLEAN => ColumnReader::BoolColumnReader(ColumnReaderImpl::new(
-            col_descr,
-            col_page_reader,
-        )),
-        Type::INT32 => ColumnReader::Int32ColumnReader(ColumnReaderImpl::new(
-            col_descr,
-            col_page_reader,
-        )),
-        Type::INT64 => ColumnReader::Int64ColumnReader(ColumnReaderImpl::new(
-            col_descr,
-            col_page_reader,
-        )),
-        Type::INT96 => ColumnReader::Int96ColumnReader(ColumnReaderImpl::new(
-            col_descr,
-            col_page_reader,
-        )),
-        Type::FLOAT => ColumnReader::FloatColumnReader(ColumnReaderImpl::new(
-            col_descr,
-            col_page_reader,
-        )),
-        Type::DOUBLE => ColumnReader::DoubleColumnReader(ColumnReaderImpl::new(
-            col_descr,
-            col_page_reader,
-        )),
-        Type::BYTE_ARRAY => ColumnReader::ByteArrayColumnReader(ColumnReaderImpl::new(
-            col_descr,
-            col_page_reader,
-        )),
+        Type::BOOLEAN => {
+            ColumnReader::BoolColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+        }
+        Type::INT32 => {
+            ColumnReader::Int32ColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+        }
+        Type::INT64 => {
+            ColumnReader::Int64ColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+        }
+        Type::INT96 => {
+            ColumnReader::Int96ColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+        }
+        Type::FLOAT => {
+            ColumnReader::FloatColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+        }
+        Type::DOUBLE => {
+            ColumnReader::DoubleColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+        }
+        Type::BYTE_ARRAY => {
+            ColumnReader::ByteArrayColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+        }
         Type::FIXED_LEN_BYTE_ARRAY => ColumnReader::FixedLenByteArrayColumnReader(
             ColumnReaderImpl::new(col_descr, col_page_reader),
         ),
@@ -90,9 +82,7 @@ pub fn get_column_reader(
 /// non-generic type to a generic column reader type `ColumnReaderImpl`.
 ///
 /// Panics if actual enum value for `col_reader` does not match the type `T`.
-pub fn get_typed_column_reader<T: DataType>(
-    col_reader: ColumnReader,
-) -> ColumnReaderImpl<T> {
+pub fn get_typed_column_reader<T: DataType>(col_reader: ColumnReader) -> ColumnReaderImpl<T> {
     T::get_column_reader(col_reader).unwrap_or_else(|| {
         panic!(
             "Failed to convert column reader into a typed column reader for `{}` type",
@@ -103,8 +93,8 @@ pub fn get_typed_column_reader<T: DataType>(
 
 /// Typed value reader for a particular primitive column.
 pub type ColumnReaderImpl<T> = GenericColumnReader<
-    ColumnLevelDecoderImpl,
-    ColumnLevelDecoderImpl,
+    RepetitionLevelDecoderImpl,
+    DefinitionLevelDecoderImpl,
     ColumnValueDecoderImpl<T>,
 >;
 
@@ -119,11 +109,14 @@ pub struct GenericColumnReader<R, D, V> {
     page_reader: Box<dyn PageReader>,
 
     /// The total number of values stored in the data page.
-    num_buffered_values: u32,
+    num_buffered_values: usize,
 
     /// The number of values from the current data page that has been decoded into memory
     /// so far.
-    num_decoded_values: u32,
+    num_decoded_values: usize,
+
+    /// True if the end of the current data page denotes the end of a record
+    has_record_delimiter: bool,
 
     /// The decoder for the definition levels if any
     def_level_decoder: Option<D>,
@@ -135,7 +128,7 @@ pub struct GenericColumnReader<R, D, V> {
     values_decoder: V,
 }
 
-impl<V> GenericColumnReader<ColumnLevelDecoderImpl, ColumnLevelDecoderImpl, V>
+impl<V> GenericColumnReader<RepetitionLevelDecoderImpl, DefinitionLevelDecoderImpl, V>
 where
     V: ColumnValueDecoder,
 {
@@ -144,10 +137,10 @@ where
         let values_decoder = V::new(&descr);
 
         let def_level_decoder = (descr.max_def_level() != 0)
-            .then(|| ColumnLevelDecoderImpl::new(descr.max_def_level()));
+            .then(|| DefinitionLevelDecoderImpl::new(descr.max_def_level()));
 
         let rep_level_decoder = (descr.max_rep_level() != 0)
-            .then(|| ColumnLevelDecoderImpl::new(descr.max_rep_level()));
+            .then(|| RepetitionLevelDecoderImpl::new(descr.max_rep_level()));
 
         Self::new_with_decoders(
             descr,
@@ -180,6 +173,7 @@ where
             num_buffered_values: 0,
             num_decoded_values: 0,
             values_decoder,
+            has_record_delimiter: false,
         }
     }
 
@@ -195,99 +189,103 @@ where
     ///
     /// `values` will be contiguously populated with the non-null values. Note that if the column
     /// is not required, this may be less than either `batch_size` or the number of levels read
+    #[deprecated(note = "Use read_records")]
     pub fn read_batch(
         &mut self,
         batch_size: usize,
-        mut def_levels: Option<&mut D::Slice>,
-        mut rep_levels: Option<&mut R::Slice>,
-        values: &mut V::Slice,
+        def_levels: Option<&mut D::Buffer>,
+        rep_levels: Option<&mut R::Buffer>,
+        values: &mut V::Buffer,
     ) -> Result<(usize, usize)> {
-        let mut values_read = 0;
-        let mut levels_read = 0;
+        let (_, values, levels) = self.read_records(batch_size, def_levels, rep_levels, values)?;
 
-        // Compute the smallest batch size we can read based on provided slices
-        let mut batch_size = min(batch_size, values.capacity());
-        if let Some(ref levels) = def_levels {
-            batch_size = min(batch_size, levels.capacity());
-        }
-        if let Some(ref levels) = rep_levels {
-            batch_size = min(batch_size, levels.capacity());
-        }
-
-        // Read exhaustively all pages until we read all batch_size values/levels
-        // or there are no more values/levels to read.
-        while levels_read < batch_size {
-            if !self.has_next()? {
-                break;
-            }
-
-            // Batch size for the current iteration
-            let iter_batch_size = (batch_size - levels_read)
-                .min((self.num_buffered_values - self.num_decoded_values) as usize);
+        Ok((values, levels))
+    }
 
-            // If the field is required and non-repeated, there are no definition levels
-            let null_count = match self.descr.max_def_level() > 0 {
-                true => {
-                    let levels = def_levels
+    /// Read up to `max_records` whole records, returning the number of complete
+    /// records, non-null values and levels decoded. All levels for a given record
+    /// will be read, i.e. the next repetition level, if any, will be 0
+    ///
+    /// If the max definition level is 0, `def_levels` will be ignored and the number of records,
+    /// non-null values and levels decoded will all be equal, otherwise `def_levels` will be
+    /// populated with the number of levels read, with an error returned if it is `None`.
+    ///
+    /// If the max repetition level is 0, `rep_levels` will be ignored and the number of records
+    /// and levels decoded will both be equal, otherwise `rep_levels` will be populated with
+    /// the number of levels read, with an error returned if it is `None`.
+    ///
+    /// `values` will be contiguously populated with the non-null values. Note that if the column
+    /// is not required, this may be less than either `max_records` or the number of levels read
+    pub fn read_records(
+        &mut self,
+        max_records: usize,
+        mut def_levels: Option<&mut D::Buffer>,
+        mut rep_levels: Option<&mut R::Buffer>,
+        values: &mut V::Buffer,
+    ) -> Result<(usize, usize, usize)> {
+        let mut total_records_read = 0;
+        let mut total_levels_read = 0;
+        let mut total_values_read = 0;
+
+        while total_records_read < max_records && self.has_next()? {
+            let remaining_records = max_records - total_records_read;
+            let remaining_levels = self.num_buffered_values - self.num_decoded_values;
+
+            let (records_read, levels_to_read) = match self.rep_level_decoder.as_mut() {
+                Some(reader) => {
+                    let out = rep_levels
                         .as_mut()
-                        .ok_or_else(|| general_err!("must specify definition levels"))?;
+                        .ok_or_else(|| general_err!("must specify repetition levels"))?;
 
-                    let num_def_levels = self
-                        .def_level_decoder
-                        .as_mut()
-                        .expect("def_level_decoder be set")
-                        .read(levels, levels_read..levels_read + iter_batch_size)?;
+                    let (mut records_read, levels_read) =
+                        reader.read_rep_levels(out, remaining_records, remaining_levels)?;
 
-                    if num_def_levels != iter_batch_size {
-                        return Err(general_err!("insufficient definition levels read from column - expected {}, got {}", iter_batch_size, num_def_levels));
+                    if levels_read == remaining_levels && self.has_record_delimiter {
+                        // Reached end of page, which implies records_read < remaining_records
+                        // as otherwise would have stopped reading before reaching the end
+                        assert!(records_read < remaining_records); // Sanity check
+                        records_read += reader.flush_partial() as usize;
                     }
-
-                    levels.count_nulls(
-                        levels_read..levels_read + num_def_levels,
-                        self.descr.max_def_level(),
-                    )
+                    (records_read, levels_read)
+                }
+                None => {
+                    let min = remaining_records.min(remaining_levels);
+                    (min, min)
                 }
-                false => 0,
             };
 
-            if self.descr.max_rep_level() > 0 {
-                let levels = rep_levels
-                    .as_mut()
-                    .ok_or_else(|| general_err!("must specify repetition levels"))?;
+            let values_to_read = match self.def_level_decoder.as_mut() {
+                Some(reader) => {
+                    let out = def_levels
+                        .as_mut()
+                        .ok_or_else(|| general_err!("must specify definition levels"))?;
+
+                    let (values_read, levels_read) = reader.read_def_levels(out, levels_to_read)?;
 
-                let rep_levels = self
-                    .rep_level_decoder
-                    .as_mut()
-                    .expect("rep_level_decoder be set")
-                    .read(levels, levels_read..levels_read + iter_batch_size)?;
+                    if levels_read != levels_to_read {
+                        return Err(general_err!("insufficient definition levels read from column - expected {rep_levels}, got {read}"));
+                    }
 
-                if rep_levels != iter_batch_size {
-                    return Err(general_err!("insufficient repetition levels read from column - expected {}, got {}", iter_batch_size, rep_levels));
+                    values_read
                 }
-            }
+                None => levels_to_read,
+            };
 
-            let values_to_read = iter_batch_size - null_count;
-            let curr_values_read = self
-                .values_decoder
-                .read(values, values_read..values_read + values_to_read)?;
+            let values_read = self.values_decoder.read(values, values_to_read)?;
 
-            if curr_values_read != values_to_read {
+            if values_read != values_to_read {
                 return Err(general_err!(
-                    "insufficient values read from column - expected: {}, got: {}",
-                    values_to_read,
-                    curr_values_read
+                    "insufficient values read from column - expected: {values_to_read}, got: {values_read}",
                 ));
             }
 
-            // Update all "return" counters and internal state.
-
-            // This is to account for when def or rep levels are not provided
-            self.num_decoded_values += iter_batch_size as u32;
-            levels_read += iter_batch_size;
-            values_read += curr_values_read;
+            self.num_decoded_values += levels_to_read;
+            total_records_read += records_read;
+            total_levels_read += levels_to_read;
+            total_values_read += values_read;
         }
 
-        Ok((values_read, levels_read))
+        Ok((total_records_read, total_values_read, total_levels_read))
     }
 
     /// Skips over `num_records` records, where records are delimited by repetition levels of 0
@@ -296,46 +294,79 @@ where
     ///
     /// Returns the number of records skipped
     pub fn skip_records(&mut self, num_records: usize) -> Result<usize> {
-        let mut remaining = num_records;
-        while remaining != 0 {
+        let mut remaining_records = num_records;
+        while remaining_records != 0 {
             if self.num_buffered_values == self.num_decoded_values {
                 let metadata = match self.page_reader.peek_next_page()? {
-                    None => return Ok(num_records - remaining),
+                    None => return Ok(num_records - remaining_records),
                     Some(metadata) => metadata,
                 };
 
                 // If dictionary, we must read it
                 if metadata.is_dict {
-                    self.read_new_page()?;
+                    self.read_dictionary_page()?;
                     continue;
                 }
 
                 // If page has less rows than the remaining records to
                 // be skipped, skip entire page
-                if metadata.num_rows < remaining {
-                    self.page_reader.skip_next_page()?;
-                    remaining -= metadata.num_rows;
-                    continue;
-                };
+                let rows = metadata.num_rows.or_else(|| {
+                    // If no repetition levels, num_levels == num_rows
+                    self.rep_level_decoder
+                        .is_none()
+                        .then_some(metadata.num_levels)?
+                });
+
+                if let Some(rows) = rows {
+                    if rows <= remaining_records {
+                        self.page_reader.skip_next_page()?;
+                        remaining_records -= rows;
+                        continue;
+                    }
+                }
                 // because self.num_buffered_values == self.num_decoded_values means
                 // we need reads a new page and set up the decoders for levels
                 if !self.read_new_page()? {
-                    return Ok(num_records - remaining);
+                    return Ok(num_records - remaining_records);
                 }
             }
 
             // start skip values in page level
-            let to_read = remaining
-                .min((self.num_buffered_values - self.num_decoded_values) as usize);
+
+            // The number of levels in the current data page
+            let remaining_levels = self.num_buffered_values - self.num_decoded_values;
 
             let (records_read, rep_levels_read) = match self.rep_level_decoder.as_mut() {
-                Some(decoder) => decoder.skip_rep_levels(to_read)?,
-                None => (to_read, to_read),
+                Some(decoder) => {
+                    let (mut records_read, levels_read) =
+                        decoder.skip_rep_levels(remaining_records, remaining_levels)?;
+
+                    if levels_read == remaining_levels && self.has_record_delimiter {
+                        // Reached end of page, which implies records_read < remaining_records
+                        // as otherwise would have stopped reading before reaching the end
+                        assert!(records_read < remaining_records); // Sanity check
+                        records_read += decoder.flush_partial() as usize;
+                    }
+
+                    (records_read, levels_read)
+                }
+                None => {
+                    // No repetition levels, so each level corresponds to a row
+                    let levels = remaining_levels.min(remaining_records);
+                    (levels, levels)
+                }
             };
 
+            self.num_decoded_values += rep_levels_read;
+            remaining_records -= records_read;
+
+            if self.num_buffered_values == self.num_decoded_values {
+                // Exhausted buffered page - no need to advance other decoders
+                continue;
+            }
+
             let (values_read, def_levels_read) = match self.def_level_decoder.as_mut() {
-                Some(decoder) => decoder
-                    .skip_def_levels(rep_levels_read, self.descr.max_def_level())?,
+                Some(decoder) => decoder.skip_def_levels(rep_levels_read)?,
                 None => (rep_levels_read, rep_levels_read),
             };
 
@@ -355,11 +386,26 @@ where
                     values_read
                 ));
             }
+        }
+        Ok(num_records - remaining_records)
+    }
 
-            self.num_decoded_values += rep_levels_read as u32;
-            remaining -= records_read;
+    /// Read the next page as a dictionary page. If the next page is not a dictionary page,
+    /// this will return an error.
+    fn read_dictionary_page(&mut self) -> Result<()> {
+        match self.page_reader.get_next_page()? {
+            Some(Page::DictionaryPage {
+                buf,
+                num_values,
+                encoding,
+                is_sorted,
+            }) => self
+                .values_decoder
+                .set_dict(buf, num_values, encoding, is_sorted),
+            _ => Err(ParquetError::General(
+                "Invalid page. Expecting dictionary page".to_string(),
+            )),
         }
-        Ok(num_records - remaining)
     }
 
     /// Reads a new page and set up the decoders for levels, values or dictionary.
@@ -391,7 +437,7 @@ where
                             rep_level_encoding,
                             statistics: _,
                         } => {
-                            self.num_buffered_values = num_values;
+                            self.num_buffered_values = num_values as _;
                             self.num_decoded_values = 0;
 
                             let max_rep_level = self.descr.max_rep_level();
@@ -404,10 +450,13 @@ where
                                     max_rep_level,
                                     num_values,
                                     rep_level_encoding,
-                                    buf.start_from(offset),
+                                    buf.slice(offset..),
                                 )?;
                                 offset += bytes_read;
 
+                                self.has_record_delimiter =
+                                    self.page_reader.at_record_boundary()?;
+
                                 self.rep_level_decoder
                                     .as_mut()
                                     .unwrap()
@@ -419,7 +468,7 @@ where
                                     max_def_level,
                                     num_values,
                                     def_level_encoding,
-                                    buf.start_from(offset),
+                                    buf.slice(offset..),
                                 )?;
                                 offset += bytes_read;
 
@@ -431,7 +480,7 @@ where
 
                             self.values_decoder.set_data(
                                 encoding,
-                                buf.start_from(offset),
+                                buf.slice(offset..),
                                 num_values as usize,
                                 None,
                             )?;
@@ -453,15 +502,21 @@ where
                                 return Err(general_err!("more nulls than values in page, contained {} values and {} nulls", num_values, num_nulls));
                             }
 
-                            self.num_buffered_values = num_values;
+                            self.num_buffered_values = num_values as _;
                             self.num_decoded_values = 0;
 
                             // DataPage v2 only supports RLE encoding for repetition
                             // levels
                             if self.descr.max_rep_level() > 0 {
+                                // Technically a DataPage v2 should not write a record
+                                // across multiple pages, however, the parquet writer
+                                // used to do this so we preserve backwards compatibility
+                                self.has_record_delimiter =
+                                    self.page_reader.at_record_boundary()?;
+
                                 self.rep_level_decoder.as_mut().unwrap().set_data(
                                     Encoding::RLE,
-                                    buf.range(0, rep_levels_byte_len as usize),
+                                    buf.slice(..rep_levels_byte_len as usize),
                                 );
                             }
 
@@ -470,18 +525,16 @@ where
                             if self.descr.max_def_level() > 0 {
                                 self.def_level_decoder.as_mut().unwrap().set_data(
                                     Encoding::RLE,
-                                    buf.range(
-                                        rep_levels_byte_len as usize,
-                                        def_levels_byte_len as usize,
+                                    buf.slice(
+                                        rep_levels_byte_len as usize
+                                            ..(rep_levels_byte_len + def_levels_byte_len) as usize,
                                     ),
                                 );
                             }
 
                             self.values_decoder.set_data(
                                 encoding,
-                                buf.start_from(
-                                    (rep_levels_byte_len + def_levels_byte_len) as usize,
-                                ),
+                                buf.slice((rep_levels_byte_len + def_levels_byte_len) as usize..),
                                 num_values as usize,
                                 Some((num_values - num_nulls) as usize),
                             )?;
@@ -493,11 +546,12 @@ where
         }
     }
 
+    /// Check whether there is more data to read from this column,
+    /// If the current page is fully decoded, this will load the next page
+    /// (if it exists) into the buffer
     #[inline]
     pub(crate) fn has_next(&mut self) -> Result<bool> {
-        if self.num_buffered_values == 0
-            || self.num_buffered_values == self.num_decoded_values
-        {
+        if self.num_buffered_values == 0 || self.num_buffered_values == self.num_decoded_values {
             // TODO: should we return false if read_new_page() = true and
             // num_buffered_values = 0?
             if !self.read_new_page()? {
@@ -515,21 +569,22 @@ fn parse_v1_level(
     max_level: i16,
     num_buffered_values: u32,
     encoding: Encoding,
-    buf: ByteBufferPtr,
-) -> Result<(usize, ByteBufferPtr)> {
+    buf: Bytes,
+) -> Result<(usize, Bytes)> {
     match encoding {
         Encoding::RLE => {
             let i32_size = std::mem::size_of::<i32>();
             let data_size = read_num_bytes::<i32>(i32_size, buf.as_ref()) as usize;
-            Ok((i32_size + data_size, buf.range(i32_size, data_size)))
+            Ok((
+                i32_size + data_size,
+                buf.slice(i32_size..i32_size + data_size),
+            ))
         }
+        #[allow(deprecated)]
         Encoding::BIT_PACKED => {
             let bit_width = num_required_bits(max_level as u64);
-            let num_bytes = ceil(
-                (num_buffered_values as usize * bit_width as usize) as i64,
-                8,
-            ) as usize;
-            Ok((num_bytes, buf.range(0, num_bytes)))
+            let num_bytes = ceil(num_buffered_values as usize * bit_width as usize, 8);
+            Ok((num_bytes, buf.slice(..num_bytes)))
         }
         _ => Err(general_err!("invalid level encoding: {}", encoding)),
     }
@@ -937,39 +992,22 @@ mod tests {
 
     #[test]
     fn test_read_batch_values_only() {
-        test_read_batch_int32(16, &mut [0; 10], None, None); // < batch_size
-        test_read_batch_int32(16, &mut [0; 16], None, None); // == batch_size
-        test_read_batch_int32(16, &mut [0; 51], None, None); // > batch_size
+        test_read_batch_int32(16, 0, 0);
     }
 
     #[test]
     fn test_read_batch_values_def_levels() {
-        test_read_batch_int32(16, &mut [0; 10], Some(&mut [0; 10]), None);
-        test_read_batch_int32(16, &mut [0; 16], Some(&mut [0; 16]), None);
-        test_read_batch_int32(16, &mut [0; 51], Some(&mut [0; 51]), None);
+        test_read_batch_int32(16, MAX_DEF_LEVEL, 0);
     }
 
     #[test]
     fn test_read_batch_values_rep_levels() {
-        test_read_batch_int32(16, &mut [0; 10], None, Some(&mut [0; 10]));
-        test_read_batch_int32(16, &mut [0; 16], None, Some(&mut [0; 16]));
-        test_read_batch_int32(16, &mut [0; 51], None, Some(&mut [0; 51]));
-    }
-
-    #[test]
-    fn test_read_batch_different_buf_sizes() {
-        test_read_batch_int32(16, &mut [0; 8], Some(&mut [0; 9]), Some(&mut [0; 7]));
-        test_read_batch_int32(16, &mut [0; 1], Some(&mut [0; 9]), Some(&mut [0; 3]));
+        test_read_batch_int32(16, 0, MAX_REP_LEVEL);
     }
 
     #[test]
     fn test_read_batch_values_def_rep_levels() {
-        test_read_batch_int32(
-            128,
-            &mut [0; 128],
-            Some(&mut [0; 128]),
-            Some(&mut [0; 128]),
-        );
+        test_read_batch_int32(128, MAX_DEF_LEVEL, MAX_REP_LEVEL);
     }
 
     #[test]
@@ -991,9 +1029,6 @@ mod tests {
         let num_pages = 2;
         let num_levels = 4;
         let batch_size = 5;
-        let values = &mut vec![0; 7];
-        let def_levels = &mut vec![0; 7];
-        let rep_levels = &mut vec![0; 7];
 
         let mut tester = ColumnReaderTester::<Int32Type>::new();
         tester.test_read_batch(
@@ -1004,9 +1039,6 @@ mod tests {
             batch_size,
             std::i32::MIN,
             std::i32::MAX,
-            values,
-            Some(def_levels),
-            Some(rep_levels),
             false,
         );
     }
@@ -1079,24 +1111,8 @@ mod tests {
     //
     // This is a high level wrapper on `ColumnReaderTester` that allows us to specify some
     // boilerplate code for setting up definition/repetition levels and column descriptor.
-    fn test_read_batch_int32(
-        batch_size: usize,
-        values: &mut [i32],
-        def_levels: Option<&mut [i16]>,
-        rep_levels: Option<&mut [i16]>,
-    ) {
+    fn test_read_batch_int32(batch_size: usize, max_def_level: i16, max_rep_level: i16) {
         let primitive_type = get_test_int32_type();
-        // make field is required based on provided slices of levels
-        let max_def_level = if def_levels.is_some() {
-            MAX_DEF_LEVEL
-        } else {
-            0
-        };
-        let max_rep_level = if rep_levels.is_some() {
-            MAX_REP_LEVEL
-        } else {
-            0
-        };
 
         let desc = Arc::new(ColumnDescriptor::new(
             Arc::new(primitive_type),
@@ -1104,6 +1120,7 @@ mod tests {
             max_rep_level,
             ColumnPath::new(Vec::new()),
         ));
+
         let mut tester = ColumnReaderTester::<Int32Type>::new();
         tester.test_read_batch(
             desc,
@@ -1113,9 +1130,6 @@ mod tests {
             batch_size,
             i32::MIN,
             i32::MAX,
-            values,
-            def_levels,
-            rep_levels,
             false,
         );
     }
@@ -1243,21 +1257,8 @@ mod tests {
             max: T::T,
             use_v2: bool,
         ) {
-            let mut def_levels = vec![0; num_levels * num_pages];
-            let mut rep_levels = vec![0; num_levels * num_pages];
-            let mut values = vec![T::T::default(); num_levels * num_pages];
             self.test_read_batch(
-                desc,
-                encoding,
-                num_pages,
-                num_levels,
-                batch_size,
-                min,
-                max,
-                &mut values,
-                Some(&mut def_levels),
-                Some(&mut rep_levels),
-                use_v2,
+                desc, encoding, num_pages, num_levels, batch_size, min, max, use_v2,
             );
         }
 
@@ -1273,9 +1274,6 @@ mod tests {
             batch_size: usize,
             min: T::T,
             max: T::T,
-            values: &mut [T::T],
-            mut def_levels: Option<&mut [i16]>,
-            mut rep_levels: Option<&mut [i16]>,
             use_v2: bool,
         ) {
             let mut pages = VecDeque::new();
@@ -1295,68 +1293,45 @@ mod tests {
             let max_def_level = desc.max_def_level();
             let max_rep_level = desc.max_rep_level();
             let page_reader = InMemoryPageReader::new(pages);
-            let column_reader: ColumnReader =
-                get_column_reader(desc, Box::new(page_reader));
+            let column_reader: ColumnReader = get_column_reader(desc, Box::new(page_reader));
             let mut typed_column_reader = get_typed_column_reader::<T>(column_reader);
 
+            let mut values = Vec::new();
+            let mut def_levels = Vec::new();
+            let mut rep_levels = Vec::new();
+
             let mut curr_values_read = 0;
             let mut curr_levels_read = 0;
-            let mut done = false;
-            while !done {
-                let actual_def_levels =
-                    def_levels.as_mut().map(|vec| &mut vec[curr_levels_read..]);
-                let actual_rep_levels =
-                    rep_levels.as_mut().map(|vec| &mut vec[curr_levels_read..]);
-
-                let (values_read, levels_read) = typed_column_reader
-                    .read_batch(
+            loop {
+                let (_, values_read, levels_read) = typed_column_reader
+                    .read_records(
                         batch_size,
-                        actual_def_levels,
-                        actual_rep_levels,
-                        &mut values[curr_values_read..],
+                        Some(&mut def_levels),
+                        Some(&mut rep_levels),
+                        &mut values,
                     )
                     .expect("read_batch() should be OK");
 
-                if values_read == 0 && levels_read == 0 {
-                    done = true;
-                }
-
                 curr_values_read += values_read;
                 curr_levels_read += levels_read;
+
+                if values_read == 0 && levels_read == 0 {
+                    break;
+                }
             }
 
-            assert!(
-                values.len() >= curr_values_read,
-                "values.len() >= values_read"
-            );
-            assert_eq!(
-                &values[0..curr_values_read],
-                &self.values[0..curr_values_read],
-                "values content doesn't match"
-            );
+            assert_eq!(values, self.values, "values content doesn't match");
 
             if max_def_level > 0 {
-                let levels = def_levels.as_ref().unwrap();
-                assert!(
-                    levels.len() >= curr_levels_read,
-                    "def_levels.len() >= levels_read"
-                );
                 assert_eq!(
-                    &levels[0..curr_levels_read],
-                    &self.def_levels[0..curr_levels_read],
+                    def_levels, self.def_levels,
                     "definition levels content doesn't match"
                 );
             }
 
             if max_rep_level > 0 {
-                let levels = rep_levels.as_ref().unwrap();
-                assert!(
-                    levels.len() >= curr_levels_read,
-                    "rep_levels.len() >= levels_read"
-                );
                 assert_eq!(
-                    &levels[0..curr_levels_read],
-                    &self.rep_levels[0..curr_levels_read],
+                    rep_levels, self.rep_levels,
                     "repetition levels content doesn't match"
                 );
             }
diff --git a/parquet/src/column/reader/decoder.rs b/parquet/src/column/reader/decoder.rs
index b95b24a21c4b..afd58b3cd195 100644
--- a/parquet/src/column/reader/decoder.rs
+++ b/parquet/src/column/reader/decoder.rs
@@ -16,7 +16,8 @@
 // under the License.
 
 use std::collections::HashMap;
-use std::ops::Range;
+
+use bytes::Bytes;
 
 use crate::basic::Encoding;
 use crate::data_type::DataType;
@@ -26,83 +27,69 @@ use crate::encodings::{
 };
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::ColumnDescPtr;
-use crate::util::{
-    bit_util::{num_required_bits, BitReader},
-    memory::ByteBufferPtr,
-};
-
-/// A slice of levels buffer data that is written to by a [`ColumnLevelDecoder`]
-pub trait LevelsBufferSlice {
-    /// Returns the capacity of this slice or `usize::MAX` if no limit
-    fn capacity(&self) -> usize;
-
-    /// Count the number of levels in `range` not equal to `max_level`
-    fn count_nulls(&self, range: Range<usize>, max_level: i16) -> usize;
-}
-
-impl LevelsBufferSlice for [i16] {
-    fn capacity(&self) -> usize {
-        self.len()
-    }
-
-    fn count_nulls(&self, range: Range<usize>, max_level: i16) -> usize {
-        self[range].iter().filter(|i| **i != max_level).count()
-    }
-}
-
-/// A slice of values buffer data that is written to by a [`ColumnValueDecoder`]
-pub trait ValuesBufferSlice {
-    /// Returns the capacity of this slice or `usize::MAX` if no limit
-    fn capacity(&self) -> usize;
-}
-
-impl<T> ValuesBufferSlice for [T] {
-    fn capacity(&self) -> usize {
-        self.len()
-    }
-}
+use crate::util::bit_util::{num_required_bits, BitReader};
 
-/// Decodes level data to a [`LevelsBufferSlice`]
+/// Decodes level data
 pub trait ColumnLevelDecoder {
-    type Slice: LevelsBufferSlice + ?Sized;
+    type Buffer;
 
     /// Set data for this [`ColumnLevelDecoder`]
-    fn set_data(&mut self, encoding: Encoding, data: ByteBufferPtr);
+    fn set_data(&mut self, encoding: Encoding, data: Bytes);
+}
 
-    /// Read level data into `out[range]` returning the number of levels read
+pub trait RepetitionLevelDecoder: ColumnLevelDecoder {
+    /// Read up to `max_records` of repetition level data into `out` returning the number
+    /// of complete records and levels read
     ///
-    /// `range` is provided by the caller to allow for types such as default-initialized `[T]`
-    /// that only track capacity and not length
+    /// A record only ends when the data contains a subsequent repetition level of 0,
+    /// it is therefore left to the caller to delimit the final record in a column
     ///
     /// # Panics
     ///
     /// Implementations may panic if `range` overlaps with already written data
-    ///
-    fn read(&mut self, out: &mut Self::Slice, range: Range<usize>) -> Result<usize>;
-}
+    fn read_rep_levels(
+        &mut self,
+        out: &mut Self::Buffer,
+        num_records: usize,
+        num_levels: usize,
+    ) -> Result<(usize, usize)>;
 
-pub trait RepetitionLevelDecoder: ColumnLevelDecoder {
-    /// Skips over repetition level corresponding to `num_records` records, where a record
-    /// is delimited by a repetition level of 0
+    /// Skips over up to `num_levels` repetition levels corresponding to `num_records` records,
+    /// where a record is delimited by a repetition level of 0
     ///
     /// Returns the number of records skipped, and the number of levels skipped
-    fn skip_rep_levels(&mut self, num_records: usize) -> Result<(usize, usize)>;
+    ///
+    /// A record only ends when the data contains a subsequent repetition level of 0,
+    /// it is therefore left to the caller to delimit the final record in a column
+    fn skip_rep_levels(&mut self, num_records: usize, num_levels: usize) -> Result<(usize, usize)>;
+
+    /// Flush any partially read or skipped record
+    fn flush_partial(&mut self) -> bool;
 }
 
 pub trait DefinitionLevelDecoder: ColumnLevelDecoder {
-    /// Skips over `num_levels` definition levels
+    /// Read up to `num_levels` definition levels into `out`
     ///
     /// Returns the number of values skipped, and the number of levels skipped
-    fn skip_def_levels(
+    ///
+    /// # Panics
+    ///
+    /// Implementations may panic if `range` overlaps with already written data
+    fn read_def_levels(
         &mut self,
+        out: &mut Self::Buffer,
         num_levels: usize,
-        max_def_level: i16,
     ) -> Result<(usize, usize)>;
+
+    /// Skips over `num_levels` definition levels
+    ///
+    /// Returns the number of values skipped, and the number of levels skipped
+    fn skip_def_levels(&mut self, num_levels: usize) -> Result<(usize, usize)>;
 }
 
-/// Decodes value data to a [`ValuesBufferSlice`]
+/// Decodes value data
 pub trait ColumnValueDecoder {
-    type Slice: ValuesBufferSlice + ?Sized;
+    type Buffer;
 
     /// Create a new [`ColumnValueDecoder`]
     fn new(col: &ColumnDescPtr) -> Self;
@@ -110,7 +97,7 @@ pub trait ColumnValueDecoder {
     /// Set the current dictionary page
     fn set_dict(
         &mut self,
-        buf: ByteBufferPtr,
+        buf: Bytes,
         num_values: u32,
         encoding: Encoding,
         is_sorted: bool,
@@ -130,21 +117,18 @@ pub trait ColumnValueDecoder {
     fn set_data(
         &mut self,
         encoding: Encoding,
-        data: ByteBufferPtr,
+        data: Bytes,
         num_levels: usize,
         num_values: Option<usize>,
     ) -> Result<()>;
 
-    /// Read values data into `out[range]` returning the number of values read
-    ///
-    /// `range` is provided by the caller to allow for types such as default-initialized `[T]`
-    /// that only track capacity and not length
+    /// Read up to `num_values` values into `out`
     ///
     /// # Panics
     ///
     /// Implementations may panic if `range` overlaps with already written data
     ///
-    fn read(&mut self, out: &mut Self::Slice, range: Range<usize>) -> Result<usize>;
+    fn read(&mut self, out: &mut Self::Buffer, num_values: usize) -> Result<usize>;
 
     /// Skips over `num_values` values
     ///
@@ -163,7 +147,7 @@ pub struct ColumnValueDecoderImpl<T: DataType> {
 }
 
 impl<T: DataType> ColumnValueDecoder for ColumnValueDecoderImpl<T> {
-    type Slice = [T::T];
+    type Buffer = Vec<T::T>;
 
     fn new(descr: &ColumnDescPtr) -> Self {
         Self {
@@ -175,7 +159,7 @@ impl<T: DataType> ColumnValueDecoder for ColumnValueDecoderImpl<T> {
 
     fn set_dict(
         &mut self,
-        buf: ByteBufferPtr,
+        buf: Bytes,
         num_values: u32,
         mut encoding: Encoding,
         _is_sorted: bool,
@@ -207,7 +191,7 @@ impl<T: DataType> ColumnValueDecoder for ColumnValueDecoderImpl<T> {
     fn set_data(
         &mut self,
         mut encoding: Encoding,
-        data: ByteBufferPtr,
+        data: Bytes,
         num_levels: usize,
         num_values: Option<usize>,
     ) -> Result<()> {
@@ -237,7 +221,7 @@ impl<T: DataType> ColumnValueDecoder for ColumnValueDecoderImpl<T> {
         Ok(())
     }
 
-    fn read(&mut self, out: &mut Self::Slice, range: Range<usize>) -> Result<usize> {
+    fn read(&mut self, out: &mut Self::Buffer, num_values: usize) -> Result<usize> {
         let encoding = self
             .current_encoding
             .expect("current_encoding should be set");
@@ -245,9 +229,14 @@ impl<T: DataType> ColumnValueDecoder for ColumnValueDecoderImpl<T> {
         let current_decoder = self
             .decoders
             .get_mut(&encoding)
-            .unwrap_or_else(|| panic!("decoder for encoding {} should be set", encoding));
-
-        current_decoder.get(&mut out[range])
+            .unwrap_or_else(|| panic!("decoder for encoding {encoding} should be set"));
+
+        // TODO: Push vec into decoder (#5177)
+        let start = out.len();
+        out.resize(start + num_values, T::T::default());
+        let read = current_decoder.get(&mut out[start..])?;
+        out.truncate(start + read);
+        Ok(read)
     }
 
     fn skip_values(&mut self, num_values: usize) -> Result<usize> {
@@ -258,106 +247,312 @@ impl<T: DataType> ColumnValueDecoder for ColumnValueDecoderImpl<T> {
         let current_decoder = self
             .decoders
             .get_mut(&encoding)
-            .unwrap_or_else(|| panic!("decoder for encoding {} should be set", encoding));
+            .unwrap_or_else(|| panic!("decoder for encoding {encoding} should be set"));
 
         current_decoder.skip(num_values)
     }
 }
 
-/// An implementation of [`ColumnLevelDecoder`] for `[i16]`
-pub struct ColumnLevelDecoderImpl {
-    decoder: Option<LevelDecoderInner>,
+const SKIP_BUFFER_SIZE: usize = 1024;
+
+enum LevelDecoder {
+    Packed(BitReader, u8),
+    Rle(RleDecoder),
+}
+
+impl LevelDecoder {
+    fn new(encoding: Encoding, data: Bytes, bit_width: u8) -> Self {
+        match encoding {
+            Encoding::RLE => {
+                let mut decoder = RleDecoder::new(bit_width);
+                decoder.set_data(data);
+                Self::Rle(decoder)
+            }
+            #[allow(deprecated)]
+            Encoding::BIT_PACKED => Self::Packed(BitReader::new(data), bit_width),
+            _ => unreachable!("invalid level encoding: {}", encoding),
+        }
+    }
+
+    fn read(&mut self, out: &mut [i16]) -> Result<usize> {
+        match self {
+            Self::Packed(reader, bit_width) => {
+                Ok(reader.get_batch::<i16>(out, *bit_width as usize))
+            }
+            Self::Rle(reader) => Ok(reader.get_batch(out)?),
+        }
+    }
+}
+
+/// An implementation of [`DefinitionLevelDecoder`] for `[i16]`
+pub struct DefinitionLevelDecoderImpl {
+    decoder: Option<LevelDecoder>,
     bit_width: u8,
+    max_level: i16,
 }
 
-impl ColumnLevelDecoderImpl {
+impl DefinitionLevelDecoderImpl {
     pub fn new(max_level: i16) -> Self {
         let bit_width = num_required_bits(max_level as u64);
         Self {
             decoder: None,
             bit_width,
+            max_level,
         }
     }
 }
 
-enum LevelDecoderInner {
-    Packed(BitReader, u8),
-    Rle(RleDecoder),
+impl ColumnLevelDecoder for DefinitionLevelDecoderImpl {
+    type Buffer = Vec<i16>;
+
+    fn set_data(&mut self, encoding: Encoding, data: Bytes) {
+        self.decoder = Some(LevelDecoder::new(encoding, data, self.bit_width))
+    }
 }
 
-impl ColumnLevelDecoder for ColumnLevelDecoderImpl {
-    type Slice = [i16];
+impl DefinitionLevelDecoder for DefinitionLevelDecoderImpl {
+    fn read_def_levels(
+        &mut self,
+        out: &mut Self::Buffer,
+        num_levels: usize,
+    ) -> Result<(usize, usize)> {
+        // TODO: Push vec into decoder (#5177)
+        let start = out.len();
+        out.resize(start + num_levels, 0);
+        let levels_read = self.decoder.as_mut().unwrap().read(&mut out[start..])?;
+        out.truncate(start + levels_read);
+
+        let iter = out.iter().skip(start);
+        let values_read = iter.filter(|x| **x == self.max_level).count();
+        Ok((values_read, levels_read))
+    }
 
-    fn set_data(&mut self, encoding: Encoding, data: ByteBufferPtr) {
-        match encoding {
-            Encoding::RLE => {
-                let mut decoder = RleDecoder::new(self.bit_width);
-                decoder.set_data(data);
-                self.decoder = Some(LevelDecoderInner::Rle(decoder));
-            }
-            Encoding::BIT_PACKED => {
-                self.decoder = Some(LevelDecoderInner::Packed(
-                    BitReader::new(data),
-                    self.bit_width,
-                ));
+    fn skip_def_levels(&mut self, num_levels: usize) -> Result<(usize, usize)> {
+        let mut level_skip = 0;
+        let mut value_skip = 0;
+        let mut buf: Vec<i16> = vec![];
+        while level_skip < num_levels {
+            let remaining_levels = num_levels - level_skip;
+
+            let to_read = remaining_levels.min(SKIP_BUFFER_SIZE);
+            buf.resize(to_read, 0);
+            let (values_read, levels_read) = self.read_def_levels(&mut buf, to_read)?;
+            if levels_read == 0 {
+                // Reached end of page
+                break;
             }
-            _ => unreachable!("invalid level encoding: {}", encoding),
+
+            level_skip += levels_read;
+            value_skip += values_read;
+        }
+
+        Ok((value_skip, level_skip))
+    }
+}
+
+pub(crate) const REPETITION_LEVELS_BATCH_SIZE: usize = 1024;
+
+/// An implementation of [`RepetitionLevelDecoder`] for `[i16]`
+pub struct RepetitionLevelDecoderImpl {
+    decoder: Option<LevelDecoder>,
+    bit_width: u8,
+    buffer: Box<[i16; REPETITION_LEVELS_BATCH_SIZE]>,
+    buffer_len: usize,
+    buffer_offset: usize,
+    has_partial: bool,
+}
+
+impl RepetitionLevelDecoderImpl {
+    pub fn new(max_level: i16) -> Self {
+        let bit_width = num_required_bits(max_level as u64);
+        Self {
+            decoder: None,
+            bit_width,
+            buffer: Box::new([0; REPETITION_LEVELS_BATCH_SIZE]),
+            buffer_offset: 0,
+            buffer_len: 0,
+            has_partial: false,
         }
     }
 
-    fn read(&mut self, out: &mut Self::Slice, range: Range<usize>) -> Result<usize> {
-        match self.decoder.as_mut().unwrap() {
-            LevelDecoderInner::Packed(reader, bit_width) => {
-                Ok(reader.get_batch::<i16>(&mut out[range], *bit_width as usize))
+    fn fill_buf(&mut self) -> Result<()> {
+        let read = self.decoder.as_mut().unwrap().read(self.buffer.as_mut())?;
+        self.buffer_offset = 0;
+        self.buffer_len = read;
+        Ok(())
+    }
+
+    /// Inspects the buffered repetition levels in the range `self.buffer_offset..self.buffer_len`
+    /// and returns the number of "complete" records along with the corresponding number of values
+    ///
+    /// A "complete" record is one where the buffer contains a subsequent repetition level of 0
+    fn count_records(&mut self, records_to_read: usize, num_levels: usize) -> (bool, usize, usize) {
+        let mut records_read = 0;
+
+        let levels = num_levels.min(self.buffer_len - self.buffer_offset);
+        let buf = self.buffer.iter().skip(self.buffer_offset);
+        for (idx, item) in buf.take(levels).enumerate() {
+            if *item == 0 && (idx != 0 || self.has_partial) {
+                records_read += 1;
+
+                if records_read == records_to_read {
+                    return (false, records_read, idx);
+                }
             }
-            LevelDecoderInner::Rle(reader) => reader.get_batch(&mut out[range]),
         }
+        // Either ran out of space in `num_levels` or data in `self.buffer`
+        (true, records_read, levels)
+    }
+}
+
+impl ColumnLevelDecoder for RepetitionLevelDecoderImpl {
+    type Buffer = Vec<i16>;
+
+    fn set_data(&mut self, encoding: Encoding, data: Bytes) {
+        self.decoder = Some(LevelDecoder::new(encoding, data, self.bit_width));
+        self.buffer_len = 0;
+        self.buffer_offset = 0;
     }
 }
 
-impl DefinitionLevelDecoder for ColumnLevelDecoderImpl {
-    fn skip_def_levels(
+impl RepetitionLevelDecoder for RepetitionLevelDecoderImpl {
+    fn read_rep_levels(
         &mut self,
+        out: &mut Self::Buffer,
+        num_records: usize,
         num_levels: usize,
-        max_def_level: i16,
     ) -> Result<(usize, usize)> {
-        let mut level_skip = 0;
-        let mut value_skip = 0;
-        match self.decoder.as_mut().unwrap() {
-            LevelDecoderInner::Packed(reader, bit_width) => {
-                for _ in 0..num_levels {
-                    // Values are delimited by max_def_level
-                    if max_def_level
-                        == reader
-                            .get_value::<i16>(*bit_width as usize)
-                            .expect("Not enough values in Packed ColumnLevelDecoderImpl.")
-                    {
-                        value_skip += 1;
-                    }
-                    level_skip += 1;
+        let mut total_records_read = 0;
+        let mut total_levels_read = 0;
+
+        while total_records_read < num_records && total_levels_read < num_levels {
+            if self.buffer_len == self.buffer_offset {
+                self.fill_buf()?;
+                if self.buffer_len == 0 {
+                    break;
                 }
             }
-            LevelDecoderInner::Rle(reader) => {
-                for _ in 0..num_levels {
-                    if let Some(level) = reader
-                        .get::<i16>()
-                        .expect("Not enough values in Rle ColumnLevelDecoderImpl.")
-                    {
-                        // Values are delimited by max_def_level
-                        if level == max_def_level {
-                            value_skip += 1;
-                        }
-                    }
-                    level_skip += 1;
+
+            let (partial, records_read, levels_read) = self.count_records(
+                num_records - total_records_read,
+                num_levels - total_levels_read,
+            );
+
+            out.extend_from_slice(
+                &self.buffer[self.buffer_offset..self.buffer_offset + levels_read],
+            );
+
+            total_levels_read += levels_read;
+            total_records_read += records_read;
+            self.buffer_offset += levels_read;
+            self.has_partial = partial;
+        }
+        Ok((total_records_read, total_levels_read))
+    }
+
+    fn skip_rep_levels(&mut self, num_records: usize, num_levels: usize) -> Result<(usize, usize)> {
+        let mut total_records_read = 0;
+        let mut total_levels_read = 0;
+
+        while total_records_read < num_records && total_levels_read < num_levels {
+            if self.buffer_len == self.buffer_offset {
+                self.fill_buf()?;
+                if self.buffer_len == 0 {
+                    break;
                 }
             }
+
+            let (partial, records_read, levels_read) = self.count_records(
+                num_records - total_records_read,
+                num_levels - total_levels_read,
+            );
+
+            total_levels_read += levels_read;
+            total_records_read += records_read;
+            self.buffer_offset += levels_read;
+            self.has_partial = partial;
         }
-        Ok((value_skip, level_skip))
+        Ok((total_records_read, total_levels_read))
+    }
+
+    fn flush_partial(&mut self) -> bool {
+        std::mem::take(&mut self.has_partial)
     }
 }
 
-impl RepetitionLevelDecoder for ColumnLevelDecoderImpl {
-    fn skip_rep_levels(&mut self, _num_records: usize) -> Result<(usize, usize)> {
-        Err(nyi_err!("https://github.com/apache/arrow-rs/issues/1792"))
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::encodings::rle::RleEncoder;
+    use rand::prelude::*;
+
+    #[test]
+    fn test_skip_padding() {
+        let mut encoder = RleEncoder::new(1, 1024);
+        encoder.put(0);
+        (0..3).for_each(|_| encoder.put(1));
+        let data = Bytes::from(encoder.consume());
+
+        let mut decoder = RepetitionLevelDecoderImpl::new(1);
+        decoder.set_data(Encoding::RLE, data.clone());
+        let (_, levels) = decoder.skip_rep_levels(100, 4).unwrap();
+        assert_eq!(levels, 4);
+
+        // The length of the final bit packed run is ambiguous, so without the correct
+        // levels limit, it will decode zero padding
+        let mut decoder = RepetitionLevelDecoderImpl::new(1);
+        decoder.set_data(Encoding::RLE, data);
+        let (_, levels) = decoder.skip_rep_levels(100, 6).unwrap();
+        assert_eq!(levels, 6);
+    }
+
+    #[test]
+    fn test_skip_rep_levels() {
+        for _ in 0..10 {
+            let mut rng = thread_rng();
+            let total_len = 10000_usize;
+            let mut encoded: Vec<i16> = (0..total_len).map(|_| rng.gen_range(0..5)).collect();
+            encoded[0] = 0;
+            let mut encoder = RleEncoder::new(3, 1024);
+            for v in &encoded {
+                encoder.put(*v as _)
+            }
+            let data = Bytes::from(encoder.consume());
+
+            let mut decoder = RepetitionLevelDecoderImpl::new(5);
+            decoder.set_data(Encoding::RLE, data);
+
+            let total_records = encoded.iter().filter(|x| **x == 0).count();
+            let mut remaining_records = total_records;
+            let mut remaining_levels = encoded.len();
+            loop {
+                let skip = rng.gen_bool(0.5);
+                let records = rng.gen_range(1..=remaining_records.min(5));
+                let (records_read, levels_read) = if skip {
+                    decoder.skip_rep_levels(records, remaining_levels).unwrap()
+                } else {
+                    let mut decoded = Vec::new();
+                    let (records_read, levels_read) = decoder
+                        .read_rep_levels(&mut decoded, records, remaining_levels)
+                        .unwrap();
+
+                    assert_eq!(
+                        decoded,
+                        encoded[encoded.len() - remaining_levels..][..levels_read]
+                    );
+                    (records_read, levels_read)
+                };
+
+                remaining_levels = remaining_levels.checked_sub(levels_read).unwrap();
+                if remaining_levels == 0 {
+                    assert_eq!(records_read + 1, records);
+                    assert_eq!(records, remaining_records);
+                    break;
+                }
+                assert_eq!(records_read, records);
+                remaining_records -= records;
+                assert_ne!(remaining_records, 0);
+            }
+        }
     }
 }
diff --git a/parquet/src/column/writer/encoder.rs b/parquet/src/column/writer/encoder.rs
index 4fb4f210e146..8624f859f4b0 100644
--- a/parquet/src/column/writer/encoder.rs
+++ b/parquet/src/column/writer/encoder.rs
@@ -15,10 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use crate::basic::Encoding;
+use bytes::Bytes;
+use half::f16;
+
+use crate::basic::{ConvertedType, Encoding, LogicalType, Type};
+use crate::bloom_filter::Sbbf;
 use crate::column::writer::{
-    compare_greater, fallback_encoding, has_dictionary_support, is_nan, update_max,
-    update_min,
+    compare_greater, fallback_encoding, has_dictionary_support, is_nan, update_max, update_min,
 };
 use crate::data_type::private::ParquetValueType;
 use crate::data_type::DataType;
@@ -26,7 +29,6 @@ use crate::encodings::encoding::{get_encoder, DictEncoder, Encoder};
 use crate::errors::{ParquetError, Result};
 use crate::file::properties::{EnabledStatistics, WriterProperties};
 use crate::schema::types::{ColumnDescPtr, ColumnDescriptor};
-use crate::util::memory::ByteBufferPtr;
 
 /// A collection of [`ParquetValueType`] encoded by a [`ColumnValueEncoder`]
 pub trait ColumnValues {
@@ -34,10 +36,10 @@ pub trait ColumnValues {
     fn len(&self) -> usize;
 }
 
-#[cfg(any(feature = "arrow", test))]
-impl<T: arrow::array::Array> ColumnValues for T {
+#[cfg(feature = "arrow")]
+impl ColumnValues for dyn arrow_array::Array {
     fn len(&self) -> usize {
-        arrow::array::Array::len(self)
+        arrow_array::Array::len(self)
     }
 }
 
@@ -49,14 +51,14 @@ impl<T: ParquetValueType> ColumnValues for [T] {
 
 /// The encoded data for a dictionary page
 pub struct DictionaryPage {
-    pub buf: ByteBufferPtr,
+    pub buf: Bytes,
     pub num_values: usize,
     pub is_sorted: bool,
 }
 
 /// The encoded values for a data page, with optional statistics
 pub struct DataPageValues<T> {
-    pub buf: ByteBufferPtr,
+    pub buf: Bytes,
     pub num_values: usize,
     pub encoding: Encoding,
     pub min_value: Option<T>,
@@ -74,15 +76,6 @@ pub trait ColumnValueEncoder {
     /// The values encoded by this encoder
     type Values: ColumnValues + ?Sized;
 
-    /// Returns the min and max values in this collection, skipping any NaN values
-    ///
-    /// Returns `None` if no values found
-    fn min_max(
-        &self,
-        values: &Self::Values,
-        value_indices: Option<&[usize]>,
-    ) -> Option<(Self::T, Self::T)>;
-
     /// Create a new [`ColumnValueEncoder`]
     fn try_new(descr: &ColumnDescPtr, props: &WriterProperties) -> Result<Self>
     where
@@ -115,6 +108,11 @@ pub trait ColumnValueEncoder {
 
     /// Flush the next data page for this column chunk
     fn flush_data_page(&mut self) -> Result<DataPageValues<Self::T>>;
+
+    /// Flushes bloom filter if enabled and returns it, otherwise returns `None`. Subsequent writes
+    /// will *not* be tracked by the bloom filter as it is empty since. This should be called once
+    /// near the end of encoding.
+    fn flush_bloom_filter(&mut self) -> Option<Sbbf>;
 }
 
 pub struct ColumnValueEncoderImpl<T: DataType> {
@@ -125,17 +123,35 @@ pub struct ColumnValueEncoderImpl<T: DataType> {
     statistics_enabled: EnabledStatistics,
     min_value: Option<T::T>,
     max_value: Option<T::T>,
+    bloom_filter: Option<Sbbf>,
 }
 
 impl<T: DataType> ColumnValueEncoderImpl<T> {
+    fn min_max(&self, values: &[T::T], value_indices: Option<&[usize]>) -> Option<(T::T, T::T)> {
+        match value_indices {
+            Some(indices) => get_min_max(&self.descr, indices.iter().map(|x| &values[*x])),
+            None => get_min_max(&self.descr, values.iter()),
+        }
+    }
+
     fn write_slice(&mut self, slice: &[T::T]) -> Result<()> {
-        if self.statistics_enabled == EnabledStatistics::Page {
+        if self.statistics_enabled != EnabledStatistics::None
+            // INTERVAL has undefined sort order, so don't write min/max stats for it
+            && self.descr.converted_type() != ConvertedType::INTERVAL
+        {
             if let Some((min, max)) = self.min_max(slice, None) {
                 update_min(&self.descr, &min, &mut self.min_value);
                 update_max(&self.descr, &max, &mut self.max_value);
             }
         }
 
+        // encode the values into bloom filter if enabled
+        if let Some(bloom_filter) = &mut self.bloom_filter {
+            for value in slice {
+                bloom_filter.insert(value);
+            }
+        }
+
         match &mut self.dict_encoder {
             Some(encoder) => encoder.put(slice),
             _ => self.encoder.put(slice),
@@ -148,17 +164,8 @@ impl<T: DataType> ColumnValueEncoder for ColumnValueEncoderImpl<T> {
 
     type Values = [T::T];
 
-    fn min_max(
-        &self,
-        values: &Self::Values,
-        value_indices: Option<&[usize]>,
-    ) -> Option<(Self::T, Self::T)> {
-        match value_indices {
-            Some(indices) => {
-                get_min_max(&self.descr, indices.iter().map(|x| &values[*x]))
-            }
-            None => get_min_max(&self.descr, values.iter()),
-        }
+    fn flush_bloom_filter(&mut self) -> Option<Sbbf> {
+        self.bloom_filter.take()
     }
 
     fn try_new(descr: &ColumnDescPtr, props: &WriterProperties) -> Result<Self> {
@@ -175,12 +182,18 @@ impl<T: DataType> ColumnValueEncoder for ColumnValueEncoderImpl<T> {
 
         let statistics_enabled = props.statistics_enabled(descr.path());
 
+        let bloom_filter = props
+            .bloom_filter_properties(descr.path())
+            .map(|props| Sbbf::new_with_ndv_fpp(props.ndv, props.fpp))
+            .transpose()?;
+
         Ok(Self {
             encoder,
             dict_encoder,
             descr: descr.clone(),
             num_values: 0,
             statistics_enabled,
+            bloom_filter,
             min_value: None,
             max_value: None,
         })
@@ -201,6 +214,7 @@ impl<T: DataType> ColumnValueEncoder for ColumnValueEncoderImpl<T> {
     }
 
     fn write_gather(&mut self, values: &Self::Values, indices: &[usize]) -> Result<()> {
+        self.num_values += indices.len();
         let slice: Vec<_> = indices.iter().map(|idx| values[*idx].clone()).collect();
         self.write_slice(&slice)
     }
@@ -268,7 +282,7 @@ where
 {
     let first = loop {
         let next = iter.next()?;
-        if !is_nan(next) {
+        if !is_nan(descr, next) {
             break next;
         }
     };
@@ -276,7 +290,7 @@ where
     let mut min = first;
     let mut max = first;
     for val in iter {
-        if is_nan(val) {
+        if is_nan(descr, val) {
             continue;
         }
         if compare_greater(descr, min, val) {
@@ -286,5 +300,36 @@ where
             max = val;
         }
     }
-    Some((min.clone(), max.clone()))
+
+    // Float/Double statistics have special case for zero.
+    //
+    // If computed min is zero, whether negative or positive,
+    // the spec states that the min should be written as -0.0
+    // (negative zero)
+    //
+    // For max, it has similar logic but will be written as 0.0
+    // (positive zero)
+    let min = replace_zero(min, descr, -0.0);
+    let max = replace_zero(max, descr, 0.0);
+
+    Some((min, max))
+}
+
+#[inline]
+fn replace_zero<T: ParquetValueType>(val: &T, descr: &ColumnDescriptor, replace: f32) -> T {
+    match T::PHYSICAL_TYPE {
+        Type::FLOAT if f32::from_le_bytes(val.as_bytes().try_into().unwrap()) == 0.0 => {
+            T::try_from_le_slice(&f32::to_le_bytes(replace)).unwrap()
+        }
+        Type::DOUBLE if f64::from_le_bytes(val.as_bytes().try_into().unwrap()) == 0.0 => {
+            T::try_from_le_slice(&f64::to_le_bytes(replace as f64)).unwrap()
+        }
+        Type::FIXED_LEN_BYTE_ARRAY
+            if descr.logical_type() == Some(LogicalType::Float16)
+                && f16::from_le_bytes(val.as_bytes().try_into().unwrap()) == f16::NEG_ZERO =>
+        {
+            T::try_from_le_slice(&f16::to_le_bytes(f16::from_f32(replace))).unwrap()
+        }
+        _ => val.clone(),
+    }
 }
diff --git a/parquet/src/column/writer/mod.rs b/parquet/src/column/writer/mod.rs
index 669cacee6460..e993cb4c11a8 100644
--- a/parquet/src/column/writer/mod.rs
+++ b/parquet/src/column/writer/mod.rs
@@ -16,31 +16,49 @@
 // under the License.
 
 //! Contains column writer API.
-use parquet_format::{ColumnIndex, OffsetIndex};
+
+use bytes::Bytes;
+use half::f16;
+
+use crate::bloom_filter::Sbbf;
+use crate::format::{BoundaryOrder, ColumnIndex, OffsetIndex};
 use std::collections::{BTreeSet, VecDeque};
+use std::str;
 
 use crate::basic::{Compression, ConvertedType, Encoding, LogicalType, PageType, Type};
 use crate::column::page::{CompressedPage, Page, PageWriteSpec, PageWriter};
-use crate::column::writer::encoder::{
-    ColumnValueEncoder, ColumnValueEncoderImpl, ColumnValues,
-};
-use crate::compression::{create_codec, Codec};
+use crate::column::writer::encoder::{ColumnValueEncoder, ColumnValueEncoderImpl, ColumnValues};
+use crate::compression::{create_codec, Codec, CodecOptionsBuilder};
 use crate::data_type::private::ParquetValueType;
 use crate::data_type::*;
 use crate::encodings::levels::LevelEncoder;
 use crate::errors::{ParquetError, Result};
 use crate::file::metadata::{ColumnIndexBuilder, OffsetIndexBuilder};
 use crate::file::properties::EnabledStatistics;
-use crate::file::statistics::Statistics;
+use crate::file::statistics::{Statistics, ValueStatistics};
 use crate::file::{
     metadata::ColumnChunkMetaData,
     properties::{WriterProperties, WriterPropertiesPtr, WriterVersion},
 };
 use crate::schema::types::{ColumnDescPtr, ColumnDescriptor};
-use crate::util::memory::ByteBufferPtr;
 
 pub(crate) mod encoder;
 
+macro_rules! downcast_writer {
+    ($e:expr, $i:ident, $b:expr) => {
+        match $e {
+            Self::BoolColumnWriter($i) => $b,
+            Self::Int32ColumnWriter($i) => $b,
+            Self::Int64ColumnWriter($i) => $b,
+            Self::Int96ColumnWriter($i) => $b,
+            Self::FloatColumnWriter($i) => $b,
+            Self::DoubleColumnWriter($i) => $b,
+            Self::ByteArrayColumnWriter($i) => $b,
+            Self::FixedLenByteArrayColumnWriter($i) => $b,
+        }
+    };
+}
+
 /// Column writer for a Parquet type.
 pub enum ColumnWriter<'a> {
     BoolColumnWriter(ColumnWriterImpl<'a, BoolType>),
@@ -53,6 +71,19 @@ pub enum ColumnWriter<'a> {
     FixedLenByteArrayColumnWriter(ColumnWriterImpl<'a, FixedLenByteArrayType>),
 }
 
+impl<'a> ColumnWriter<'a> {
+    /// Returns the estimated total bytes for this column writer
+    #[cfg(feature = "arrow")]
+    pub(crate) fn get_estimated_total_bytes(&self) -> u64 {
+        downcast_writer!(self, typed, typed.get_estimated_total_bytes())
+    }
+
+    /// Close this [`ColumnWriter`]
+    pub fn close(self) -> Result<ColumnCloseResult> {
+        downcast_writer!(self, typed, typed.close())
+    }
+}
+
 pub enum Level {
     Page,
     Column,
@@ -65,41 +96,27 @@ pub fn get_column_writer<'a>(
     page_writer: Box<dyn PageWriter + 'a>,
 ) -> ColumnWriter<'a> {
     match descr.physical_type() {
-        Type::BOOLEAN => ColumnWriter::BoolColumnWriter(ColumnWriterImpl::new(
-            descr,
-            props,
-            page_writer,
-        )),
-        Type::INT32 => ColumnWriter::Int32ColumnWriter(ColumnWriterImpl::new(
-            descr,
-            props,
-            page_writer,
-        )),
-        Type::INT64 => ColumnWriter::Int64ColumnWriter(ColumnWriterImpl::new(
-            descr,
-            props,
-            page_writer,
-        )),
-        Type::INT96 => ColumnWriter::Int96ColumnWriter(ColumnWriterImpl::new(
-            descr,
-            props,
-            page_writer,
-        )),
-        Type::FLOAT => ColumnWriter::FloatColumnWriter(ColumnWriterImpl::new(
-            descr,
-            props,
-            page_writer,
-        )),
-        Type::DOUBLE => ColumnWriter::DoubleColumnWriter(ColumnWriterImpl::new(
-            descr,
-            props,
-            page_writer,
-        )),
-        Type::BYTE_ARRAY => ColumnWriter::ByteArrayColumnWriter(ColumnWriterImpl::new(
-            descr,
-            props,
-            page_writer,
-        )),
+        Type::BOOLEAN => {
+            ColumnWriter::BoolColumnWriter(ColumnWriterImpl::new(descr, props, page_writer))
+        }
+        Type::INT32 => {
+            ColumnWriter::Int32ColumnWriter(ColumnWriterImpl::new(descr, props, page_writer))
+        }
+        Type::INT64 => {
+            ColumnWriter::Int64ColumnWriter(ColumnWriterImpl::new(descr, props, page_writer))
+        }
+        Type::INT96 => {
+            ColumnWriter::Int96ColumnWriter(ColumnWriterImpl::new(descr, props, page_writer))
+        }
+        Type::FLOAT => {
+            ColumnWriter::FloatColumnWriter(ColumnWriterImpl::new(descr, props, page_writer))
+        }
+        Type::DOUBLE => {
+            ColumnWriter::DoubleColumnWriter(ColumnWriterImpl::new(descr, props, page_writer))
+        }
+        Type::BYTE_ARRAY => {
+            ColumnWriter::ByteArrayColumnWriter(ColumnWriterImpl::new(descr, props, page_writer))
+        }
         Type::FIXED_LEN_BYTE_ARRAY => ColumnWriter::FixedLenByteArrayColumnWriter(
             ColumnWriterImpl::new(descr, props, page_writer),
         ),
@@ -110,9 +127,7 @@ pub fn get_column_writer<'a>(
 /// non-generic type to a generic column writer type `ColumnWriterImpl`.
 ///
 /// Panics if actual enum value for `col_writer` does not match the type `T`.
-pub fn get_typed_column_writer<T: DataType>(
-    col_writer: ColumnWriter,
-) -> ColumnWriterImpl<T> {
+pub fn get_typed_column_writer<T: DataType>(col_writer: ColumnWriter) -> ColumnWriterImpl<T> {
     T::get_column_writer(col_writer).unwrap_or_else(|| {
         panic!(
             "Failed to convert column writer into a typed column writer for `{}` type",
@@ -145,13 +160,22 @@ pub fn get_typed_column_writer_mut<'a, 'b: 'a, T: DataType>(
     })
 }
 
-type ColumnCloseResult = (
-    u64,
-    u64,
-    ColumnChunkMetaData,
-    Option<ColumnIndex>,
-    Option<OffsetIndex>,
-);
+/// Metadata returned by [`GenericColumnWriter::close`]
+#[derive(Debug, Clone)]
+pub struct ColumnCloseResult {
+    /// The total number of bytes written
+    pub bytes_written: u64,
+    /// The total number of rows written
+    pub rows_written: u64,
+    /// Metadata for this column chunk
+    pub metadata: ColumnChunkMetaData,
+    /// Optional bloom filter for this column
+    pub bloom_filter: Option<Sbbf>,
+    /// Optional column index, for filtering
+    pub column_index: Option<ColumnIndex>,
+    /// Optional offset index, identifying page locations
+    pub offset_index: Option<OffsetIndex>,
+}
 
 // Metrics per page
 #[derive(Default)]
@@ -201,10 +225,16 @@ pub struct GenericColumnWriter<'a, E: ColumnValueEncoder> {
     def_levels_sink: Vec<i16>,
     rep_levels_sink: Vec<i16>,
     data_pages: VecDeque<CompressedPage>,
-
     // column index and offset index
     column_index_builder: ColumnIndexBuilder,
     offset_index_builder: OffsetIndexBuilder,
+
+    // Below fields used to incrementally check boundary order across data pages.
+    // We assume they are ascending/descending until proven wrong.
+    data_page_boundary_ascending: bool,
+    data_page_boundary_descending: bool,
+    /// (min, max)
+    last_non_null_data_page_min_max: Option<(E::T, E::T)>,
 }
 
 impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
@@ -214,7 +244,8 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
         page_writer: Box<dyn PageWriter + 'a>,
     ) -> Self {
         let codec = props.compression(descr.path());
-        let compressor = create_codec(codec).unwrap();
+        let codec_options = CodecOptionsBuilder::default().build();
+        let compressor = create_codec(codec, &codec_options).unwrap();
         let encoder = E::try_new(&descr, props.as_ref()).unwrap();
 
         let statistics_enabled = props.statistics_enabled(descr.path());
@@ -255,6 +286,9 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
             column_index_builder: ColumnIndexBuilder::new(),
             offset_index_builder: OffsetIndexBuilder::new(),
             encodings,
+            data_page_boundary_ascending: true,
+            data_page_boundary_descending: true,
+            last_non_null_data_page_min_max: None,
         }
     }
 
@@ -269,6 +303,17 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
         max: Option<&E::T>,
         distinct_count: Option<u64>,
     ) -> Result<usize> {
+        // Check if number of definition levels is the same as number of repetition levels.
+        if let (Some(def), Some(rep)) = (def_levels, rep_levels) {
+            if def.len() != rep.len() {
+                return Err(general_err!(
+                    "Inconsistent length of definition and repetition levels: {} != {}",
+                    def.len(),
+                    rep.len()
+                ));
+            }
+        }
+
         // We check for DataPage limits only after we have inserted the values. If a user
         // writes a large number of values, the DataPage size can be well above the limit.
         //
@@ -284,46 +329,11 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
             None => values.len(),
         };
 
-        // Find out number of batches to process.
-        let write_batch_size = self.props.write_batch_size();
-        let num_batches = num_levels / write_batch_size;
-
-        // If only computing chunk-level statistics compute them here, page-level statistics
-        // are computed in [`Self::write_mini_batch`] and used to update chunk statistics in
-        // [`Self::add_data_page`]
-        if self.statistics_enabled == EnabledStatistics::Chunk {
-            match (min, max) {
-                (Some(min), Some(max)) => {
-                    update_min(
-                        &self.descr,
-                        min,
-                        &mut self.column_metrics.min_column_value,
-                    );
-                    update_max(
-                        &self.descr,
-                        max,
-                        &mut self.column_metrics.max_column_value,
-                    );
-                }
-                (None, Some(_)) | (Some(_), None) => {
-                    panic!("min/max should be both set or both None")
-                }
-                (None, None) => {
-                    if let Some((min, max)) = self.encoder.min_max(values, value_indices)
-                    {
-                        update_min(
-                            &self.descr,
-                            &min,
-                            &mut self.column_metrics.min_column_value,
-                        );
-                        update_max(
-                            &self.descr,
-                            &max,
-                            &mut self.column_metrics.max_column_value,
-                        );
-                    }
-                }
-            };
+        if let Some(min) = min {
+            update_min(&self.descr, min, &mut self.column_metrics.min_column_value);
+        }
+        if let Some(max) = max {
+            update_max(&self.descr, max, &mut self.column_metrics.max_column_value);
         }
 
         // We can only set the distinct count if there are no other writes
@@ -335,27 +345,28 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
 
         let mut values_offset = 0;
         let mut levels_offset = 0;
-        for _ in 0..num_batches {
+        let base_batch_size = self.props.write_batch_size();
+        while levels_offset < num_levels {
+            let mut end_offset = num_levels.min(levels_offset + base_batch_size);
+
+            // Split at record boundary
+            if let Some(r) = rep_levels {
+                while end_offset < r.len() && r[end_offset] != 0 {
+                    end_offset += 1;
+                }
+            }
+
             values_offset += self.write_mini_batch(
                 values,
                 values_offset,
                 value_indices,
-                write_batch_size,
-                def_levels.map(|lv| &lv[levels_offset..levels_offset + write_batch_size]),
-                rep_levels.map(|lv| &lv[levels_offset..levels_offset + write_batch_size]),
+                end_offset - levels_offset,
+                def_levels.map(|lv| &lv[levels_offset..end_offset]),
+                rep_levels.map(|lv| &lv[levels_offset..end_offset]),
             )?;
-            levels_offset += write_batch_size;
+            levels_offset = end_offset;
         }
 
-        values_offset += self.write_mini_batch(
-            values,
-            values_offset,
-            value_indices,
-            num_levels - levels_offset,
-            def_levels.map(|lv| &lv[levels_offset..]),
-            rep_levels.map(|lv| &lv[levels_offset..]),
-        )?;
-
         // Return total number of values processed.
         Ok(values_offset)
     }
@@ -410,17 +421,36 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
 
     /// Returns total number of bytes written by this column writer so far.
     /// This value is also returned when column writer is closed.
+    ///
+    /// Note: this value does not include any buffered data that has not
+    /// yet been flushed to a page.
     pub fn get_total_bytes_written(&self) -> u64 {
         self.column_metrics.total_bytes_written
     }
 
+    /// Returns the estimated total bytes for this column writer
+    ///
+    /// Unlike [`Self::get_total_bytes_written`] this includes an estimate
+    /// of any data that has not yet been flushed to a page
+    #[cfg(feature = "arrow")]
+    pub(crate) fn get_estimated_total_bytes(&self) -> u64 {
+        self.column_metrics.total_bytes_written
+            + self.encoder.estimated_data_page_size() as u64
+            + self.encoder.estimated_dict_page_size().unwrap_or_default() as u64
+    }
+
     /// Returns total number of rows written by this column writer so far.
     /// This value is also returned when column writer is closed.
     pub fn get_total_rows_written(&self) -> u64 {
         self.column_metrics.total_rows_written
     }
 
-    /// Finalises writes and closes the column writer.
+    /// Returns a reference to a [`ColumnDescPtr`]
+    pub fn get_descriptor(&self) -> &ColumnDescPtr {
+        &self.descr
+    }
+
+    /// Finalizes writes and closes the column writer.
     /// Returns total bytes written, total rows written and column chunk metadata.
     pub fn close(mut self) -> Result<ColumnCloseResult> {
         if self.page_metrics.num_buffered_values > 0 {
@@ -433,22 +463,32 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
         let metadata = self.write_column_metadata()?;
         self.page_writer.close()?;
 
-        let (column_index, offset_index) = if self.column_index_builder.valid() {
-            // build the column and offset index
-            let column_index = self.column_index_builder.build_to_thrift();
-            let offset_index = self.offset_index_builder.build_to_thrift();
-            (Some(column_index), Some(offset_index))
-        } else {
-            (None, None)
+        let boundary_order = match (
+            self.data_page_boundary_ascending,
+            self.data_page_boundary_descending,
+        ) {
+            // If the lists are composed of equal elements then will be marked as ascending
+            // (Also the case if all pages are null pages)
+            (true, _) => BoundaryOrder::ASCENDING,
+            (false, true) => BoundaryOrder::DESCENDING,
+            (false, false) => BoundaryOrder::UNORDERED,
         };
-
-        Ok((
-            self.column_metrics.total_bytes_written,
-            self.column_metrics.total_rows_written,
+        self.column_index_builder.set_boundary_order(boundary_order);
+
+        let column_index = self
+            .column_index_builder
+            .valid()
+            .then(|| self.column_index_builder.build_to_thrift());
+        let offset_index = Some(self.offset_index_builder.build_to_thrift());
+
+        Ok(ColumnCloseResult {
+            bytes_written: self.column_metrics.total_bytes_written,
+            rows_written: self.column_metrics.total_rows_written,
+            bloom_filter: self.encoder.flush_bloom_filter(),
             metadata,
             column_index,
             offset_index,
-        ))
+        })
     }
 
     /// Writes mini batch of values, definition and repetition levels.
@@ -463,18 +503,6 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
         def_levels: Option<&[i16]>,
         rep_levels: Option<&[i16]>,
     ) -> Result<usize> {
-        // Check if number of definition levels is the same as number of repetition
-        // levels.
-        if let (Some(def), Some(rep)) = (def_levels, rep_levels) {
-            if def.len() != rep.len() {
-                return Err(general_err!(
-                    "Inconsistent length of definition and repetition levels: {} != {}",
-                    def.len(),
-                    rep.len()
-                ));
-            }
-        }
-
         // Process definition levels and determine how many values to write.
         let values_to_write = if self.descr.max_def_level() > 0 {
             let levels = def_levels.ok_or_else(|| {
@@ -510,6 +538,13 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
                 )
             })?;
 
+            if !levels.is_empty() && levels[0] != 0 {
+                return Err(general_err!(
+                    "Write must start at a record boundary, got non-zero repetition level of {}",
+                    levels[0]
+                ));
+            }
+
             // Count the occasions where we start a new row
             for &level in levels {
                 self.page_metrics.num_buffered_rows += (level == 0) as u32
@@ -550,7 +585,7 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
     #[inline]
     fn should_dict_fallback(&self) -> bool {
         match self.encoder.estimated_dict_page_size() {
-            Some(size) => size >= self.props.dictionary_pagesize_limit(),
+            Some(size) => size >= self.props.dictionary_page_size_limit(),
             None => false,
         }
     }
@@ -562,11 +597,12 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
         //
         // In such a scenario the dictionary decoder may return an estimated encoded
         // size in excess of the page size limit, even when there are no buffered values
-        if self.encoder.num_values() == 0 {
+        if self.page_metrics.num_buffered_values == 0 {
             return false;
         }
 
-        self.encoder.estimated_data_page_size() >= self.props.data_pagesize_limit()
+        self.page_metrics.num_buffered_rows as usize >= self.props.data_page_row_count_limit()
+            || self.encoder.estimated_data_page_size() >= self.props.data_page_size_limit()
     }
 
     /// Performs dictionary fallback.
@@ -582,17 +618,17 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
     }
 
     /// Update the column index and offset index when adding the data page
-    fn update_column_offset_index(&mut self, page_statistics: &Option<Statistics>) {
+    fn update_column_offset_index(&mut self, page_statistics: Option<&ValueStatistics<E::T>>) {
         // update the column index
-        let null_page = (self.page_metrics.num_buffered_rows as u64)
-            == self.page_metrics.num_page_nulls;
+        let null_page =
+            (self.page_metrics.num_buffered_rows as u64) == self.page_metrics.num_page_nulls;
         // a page contains only null values,
         // and writers have to set the corresponding entries in min_values and max_values to byte[0]
         if null_page && self.column_index_builder.valid() {
             self.column_index_builder.append(
                 null_page,
-                &[0; 1],
-                &[0; 1],
+                vec![0; 1],
+                vec![0; 1],
                 self.page_metrics.num_page_nulls as i64,
             );
         } else if self.column_index_builder.valid() {
@@ -603,21 +639,103 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
                     self.column_index_builder.to_invalid();
                 }
                 Some(stat) => {
-                    self.column_index_builder.append(
-                        null_page,
-                        stat.min_bytes(),
-                        stat.max_bytes(),
-                        self.page_metrics.num_page_nulls as i64,
-                    );
+                    // Check if min/max are still ascending/descending across pages
+                    let new_min = stat.min();
+                    let new_max = stat.max();
+                    if let Some((last_min, last_max)) = &self.last_non_null_data_page_min_max {
+                        if self.data_page_boundary_ascending {
+                            // If last min/max are greater than new min/max then not ascending anymore
+                            let not_ascending = compare_greater(&self.descr, last_min, new_min)
+                                || compare_greater(&self.descr, last_max, new_max);
+                            if not_ascending {
+                                self.data_page_boundary_ascending = false;
+                            }
+                        }
+
+                        if self.data_page_boundary_descending {
+                            // If new min/max are greater than last min/max then not descending anymore
+                            let not_descending = compare_greater(&self.descr, new_min, last_min)
+                                || compare_greater(&self.descr, new_max, last_max);
+                            if not_descending {
+                                self.data_page_boundary_descending = false;
+                            }
+                        }
+                    }
+                    self.last_non_null_data_page_min_max = Some((new_min.clone(), new_max.clone()));
+
+                    if self.can_truncate_value() {
+                        self.column_index_builder.append(
+                            null_page,
+                            self.truncate_min_value(
+                                self.props.column_index_truncate_length(),
+                                stat.min_bytes(),
+                            )
+                            .0,
+                            self.truncate_max_value(
+                                self.props.column_index_truncate_length(),
+                                stat.max_bytes(),
+                            )
+                            .0,
+                            self.page_metrics.num_page_nulls as i64,
+                        );
+                    } else {
+                        self.column_index_builder.append(
+                            null_page,
+                            stat.min_bytes().to_vec(),
+                            stat.max_bytes().to_vec(),
+                            self.page_metrics.num_page_nulls as i64,
+                        );
+                    }
                 }
             }
         }
-
         // update the offset index
         self.offset_index_builder
             .append_row_count(self.page_metrics.num_buffered_rows as i64);
     }
 
+    /// Determine if we should allow truncating min/max values for this column's statistics
+    fn can_truncate_value(&self) -> bool {
+        match self.descr.physical_type() {
+            // Don't truncate for Float16 and Decimal because their sort order is different
+            // from that of FIXED_LEN_BYTE_ARRAY sort order.
+            // So truncation of those types could lead to inaccurate min/max statistics
+            Type::FIXED_LEN_BYTE_ARRAY
+                if !matches!(
+                    self.descr.logical_type(),
+                    Some(LogicalType::Decimal { .. }) | Some(LogicalType::Float16)
+                ) =>
+            {
+                true
+            }
+            Type::BYTE_ARRAY => true,
+            // Truncation only applies for fba/binary physical types
+            _ => false,
+        }
+    }
+
+    fn truncate_min_value(&self, truncation_length: Option<usize>, data: &[u8]) -> (Vec<u8>, bool) {
+        truncation_length
+            .filter(|l| data.len() > *l)
+            .and_then(|l| match str::from_utf8(data) {
+                Ok(str_data) => truncate_utf8(str_data, l),
+                Err(_) => Some(data[..l].to_vec()),
+            })
+            .map(|truncated| (truncated, true))
+            .unwrap_or_else(|| (data.to_vec(), false))
+    }
+
+    fn truncate_max_value(&self, truncation_length: Option<usize>, data: &[u8]) -> (Vec<u8>, bool) {
+        truncation_length
+            .filter(|l| data.len() > *l)
+            .and_then(|l| match str::from_utf8(data) {
+                Ok(str_data) => truncate_utf8(str_data, l).and_then(increment_utf8),
+                Err(_) => increment(data[..l].to_vec()),
+            })
+            .map(|truncated| (truncated, true))
+            .unwrap_or_else(|| (data.to_vec(), false))
+    }
+
     /// Adds data page.
     /// Data page is either buffered in case of dictionary encoding or written directly.
     fn add_data_page(&mut self) -> Result<()> {
@@ -631,21 +749,26 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
 
         let page_statistics = match (values_data.min_value, values_data.max_value) {
             (Some(min), Some(max)) => {
+                // Update chunk level statistics
                 update_min(&self.descr, &min, &mut self.column_metrics.min_column_value);
                 update_max(&self.descr, &max, &mut self.column_metrics.max_column_value);
-                Some(Statistics::new(
-                    Some(min),
-                    Some(max),
-                    None,
-                    self.page_metrics.num_page_nulls,
-                    false,
-                ))
+
+                (self.statistics_enabled == EnabledStatistics::Page).then_some(
+                    ValueStatistics::new(
+                        Some(min),
+                        Some(max),
+                        None,
+                        self.page_metrics.num_page_nulls,
+                        false,
+                    ),
+                )
             }
             _ => None,
         };
 
         // update column and offset index
-        self.update_column_offset_index(&page_statistics);
+        self.update_column_offset_index(page_statistics.as_ref());
+        let page_statistics = page_statistics.map(Statistics::from);
 
         let compressed_page = match self.props.writer_version() {
             WriterVersion::PARQUET_1_0 => {
@@ -671,7 +794,7 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
                     );
                 }
 
-                buffer.extend_from_slice(values_data.buf.data());
+                buffer.extend_from_slice(&values_data.buf);
                 let uncompressed_size = buffer.len();
 
                 if let Some(ref mut cmpr) = self.compressor {
@@ -681,7 +804,7 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
                 }
 
                 let data_page = Page::DataPage {
-                    buf: ByteBufferPtr::new(buffer),
+                    buf: buffer.into(),
                     num_values: self.page_metrics.num_buffered_values,
                     encoding: values_data.encoding,
                     def_level_encoding: Encoding::RLE,
@@ -697,15 +820,13 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
                 let mut buffer = vec![];
 
                 if max_rep_level > 0 {
-                    let levels =
-                        self.encode_levels_v2(&self.rep_levels_sink[..], max_rep_level);
+                    let levels = self.encode_levels_v2(&self.rep_levels_sink[..], max_rep_level);
                     rep_levels_byte_len = levels.len();
                     buffer.extend_from_slice(&levels[..]);
                 }
 
                 if max_def_level > 0 {
-                    let levels =
-                        self.encode_levels_v2(&self.def_levels_sink[..], max_def_level);
+                    let levels = self.encode_levels_v2(&self.def_levels_sink[..], max_def_level);
                     def_levels_byte_len = levels.len();
                     buffer.extend_from_slice(&levels[..]);
                 }
@@ -716,13 +837,13 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
                 // Data Page v2 compresses values only.
                 match self.compressor {
                     Some(ref mut cmpr) => {
-                        cmpr.compress(values_data.buf.data(), &mut buffer)?;
+                        cmpr.compress(&values_data.buf, &mut buffer)?;
                     }
-                    None => buffer.extend_from_slice(values_data.buf.data()),
+                    None => buffer.extend_from_slice(&values_data.buf),
                 }
 
                 let data_page = Page::DataPageV2 {
-                    buf: ByteBufferPtr::new(buffer),
+                    buf: buffer.into(),
                     num_values: self.page_metrics.num_buffered_values,
                     encoding: values_data.encoding,
                     num_nulls: self.page_metrics.num_page_nulls as u32,
@@ -745,8 +866,7 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
         }
 
         // Update total number of rows.
-        self.column_metrics.total_rows_written +=
-            self.page_metrics.num_buffered_rows as u64;
+        self.column_metrics.total_rows_written += self.page_metrics.num_buffered_rows as u64;
 
         // Reset state.
         self.rep_levels_sink.clear();
@@ -777,8 +897,7 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
         let total_compressed_size = self.column_metrics.total_compressed_size as i64;
         let total_uncompressed_size = self.column_metrics.total_uncompressed_size as i64;
         let num_values = self.column_metrics.total_num_values as i64;
-        let dict_page_offset =
-            self.column_metrics.dictionary_page_offset.map(|v| v as i64);
+        let dict_page_offset = self.column_metrics.dictionary_page_offset.map(|v| v as i64);
         // If data page offset is not set, then no pages have been written
         let data_page_offset = self.column_metrics.data_page_offset.unwrap_or(0) as i64;
 
@@ -798,13 +917,66 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
             .set_dictionary_page_offset(dict_page_offset);
 
         if self.statistics_enabled != EnabledStatistics::None {
-            let statistics = Statistics::new(
+            let backwards_compatible_min_max = self.descr.sort_order().is_signed();
+
+            let statistics = ValueStatistics::<E::T>::new(
                 self.column_metrics.min_column_value.clone(),
                 self.column_metrics.max_column_value.clone(),
                 self.column_metrics.column_distinct_count,
                 self.column_metrics.num_column_nulls,
                 false,
-            );
+            )
+            .with_backwards_compatible_min_max(backwards_compatible_min_max)
+            .into();
+
+            let statistics = match statistics {
+                Statistics::ByteArray(stats) if stats.has_min_max_set() => {
+                    let (min, did_truncate_min) = self.truncate_min_value(
+                        self.props.statistics_truncate_length(),
+                        stats.min_bytes(),
+                    );
+                    let (max, did_truncate_max) = self.truncate_max_value(
+                        self.props.statistics_truncate_length(),
+                        stats.max_bytes(),
+                    );
+                    Statistics::ByteArray(
+                        ValueStatistics::new(
+                            Some(min.into()),
+                            Some(max.into()),
+                            stats.distinct_count(),
+                            stats.null_count(),
+                            backwards_compatible_min_max,
+                        )
+                        .with_max_is_exact(!did_truncate_max)
+                        .with_min_is_exact(!did_truncate_min),
+                    )
+                }
+                Statistics::FixedLenByteArray(stats)
+                    if (stats.has_min_max_set() && self.can_truncate_value()) =>
+                {
+                    let (min, did_truncate_min) = self.truncate_min_value(
+                        self.props.statistics_truncate_length(),
+                        stats.min_bytes(),
+                    );
+                    let (max, did_truncate_max) = self.truncate_max_value(
+                        self.props.statistics_truncate_length(),
+                        stats.max_bytes(),
+                    );
+                    Statistics::FixedLenByteArray(
+                        ValueStatistics::new(
+                            Some(min.into()),
+                            Some(max.into()),
+                            stats.distinct_count(),
+                            stats.null_count(),
+                            backwards_compatible_min_max,
+                        )
+                        .with_max_is_exact(!did_truncate_max)
+                        .with_min_is_exact(!did_truncate_min),
+                    )
+                }
+                stats => stats,
+            };
+
             builder = builder.set_statistics(statistics);
         }
 
@@ -816,12 +988,7 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
 
     /// Encodes definition or repetition levels for Data Page v1.
     #[inline]
-    fn encode_levels_v1(
-        &self,
-        encoding: Encoding,
-        levels: &[i16],
-        max_level: i16,
-    ) -> Vec<u8> {
+    fn encode_levels_v1(&self, encoding: Encoding, levels: &[i16], max_level: i16) -> Vec<u8> {
         let mut encoder = LevelEncoder::v1(encoding, max_level, levels.len());
         encoder.put(levels);
         encoder.consume()
@@ -843,10 +1010,8 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
         let page_spec = self.page_writer.write_page(page)?;
         // update offset index
         // compressed_size = header_size + compressed_data_size
-        self.offset_index_builder.append_offset_and_size(
-            page_spec.offset as i64,
-            page_spec.compressed_size as i32,
-        );
+        self.offset_index_builder
+            .append_offset_and_size(page_spec.offset as i64, page_spec.compressed_size as i32);
         self.update_metrics_for_page(page_spec);
         Ok(())
     }
@@ -864,8 +1029,8 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
 
             if let Some(ref mut cmpr) = self.compressor {
                 let mut output_buf = Vec::with_capacity(uncompressed_size);
-                cmpr.compress(page.buf.data(), &mut output_buf)?;
-                page.buf = ByteBufferPtr::new(output_buf);
+                cmpr.compress(&page.buf, &mut output_buf)?;
+                page.buf = Bytes::from(output_buf);
             }
 
             let dict_page = Page::DictionaryPage {
@@ -889,11 +1054,11 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
     fn update_metrics_for_page(&mut self, page_spec: PageWriteSpec) {
         self.column_metrics.total_uncompressed_size += page_spec.uncompressed_size as u64;
         self.column_metrics.total_compressed_size += page_spec.compressed_size as u64;
-        self.column_metrics.total_num_values += page_spec.num_values as u64;
         self.column_metrics.total_bytes_written += page_spec.bytes_written;
 
         match page_spec.page_type {
             PageType::DATA_PAGE | PageType::DATA_PAGE_V2 => {
+                self.column_metrics.total_num_values += page_spec.num_values as u64;
                 if self.column_metrics.data_page_offset.is_none() {
                     self.column_metrics.data_page_offset = Some(page_spec.offset);
                 }
@@ -910,27 +1075,24 @@ impl<'a, E: ColumnValueEncoder> GenericColumnWriter<'a, E> {
     }
 }
 
-fn update_min<T: ParquetValueType>(
-    descr: &ColumnDescriptor,
-    val: &T,
-    min: &mut Option<T>,
-) {
-    update_stat::<T, _>(val, min, |cur| compare_greater(descr, cur, val))
+fn update_min<T: ParquetValueType>(descr: &ColumnDescriptor, val: &T, min: &mut Option<T>) {
+    update_stat::<T, _>(descr, val, min, |cur| compare_greater(descr, cur, val))
 }
 
-fn update_max<T: ParquetValueType>(
-    descr: &ColumnDescriptor,
-    val: &T,
-    max: &mut Option<T>,
-) {
-    update_stat::<T, _>(val, max, |cur| compare_greater(descr, val, cur))
+fn update_max<T: ParquetValueType>(descr: &ColumnDescriptor, val: &T, max: &mut Option<T>) {
+    update_stat::<T, _>(descr, val, max, |cur| compare_greater(descr, val, cur))
 }
 
 #[inline]
 #[allow(clippy::eq_op)]
-fn is_nan<T: ParquetValueType>(val: &T) -> bool {
+fn is_nan<T: ParquetValueType>(descr: &ColumnDescriptor, val: &T) -> bool {
     match T::PHYSICAL_TYPE {
         Type::FLOAT | Type::DOUBLE => val != val,
+        Type::FIXED_LEN_BYTE_ARRAY if descr.logical_type() == Some(LogicalType::Float16) => {
+            let val = val.as_bytes();
+            let val = f16::from_le_bytes([val[0], val[1]]);
+            val.is_nan()
+        }
         _ => false,
     }
 }
@@ -939,12 +1101,15 @@ fn is_nan<T: ParquetValueType>(val: &T) -> bool {
 ///
 /// If `cur` is `None`, sets `cur` to `Some(val)`, otherwise calls `should_update` with
 /// the value of `cur`, and updates `cur` to `Some(val)` if it returns `true`
-
-fn update_stat<T: ParquetValueType, F>(val: &T, cur: &mut Option<T>, should_update: F)
-where
+fn update_stat<T: ParquetValueType, F>(
+    descr: &ColumnDescriptor,
+    val: &T,
+    cur: &mut Option<T>,
+    should_update: F,
+) where
     F: Fn(&T) -> bool,
 {
-    if is_nan(val) {
+    if is_nan(descr, val) {
         return;
     }
 
@@ -990,6 +1155,14 @@ fn compare_greater<T: ParquetValueType>(descr: &ColumnDescriptor, a: &T, b: &T)
         };
     };
 
+    if let Some(LogicalType::Float16) = descr.logical_type() {
+        let a = a.as_bytes();
+        let a = f16::from_le_bytes([a[0], a[1]]);
+        let b = b.as_bytes();
+        let b = f16::from_le_bytes([b[0], b[1]]);
+        return a > b;
+    }
+
     a > b
 }
 
@@ -1013,9 +1186,7 @@ fn fallback_encoding(kind: Type, props: &WriterProperties) -> Encoding {
         (Type::INT32, WriterVersion::PARQUET_2_0) => Encoding::DELTA_BINARY_PACKED,
         (Type::INT64, WriterVersion::PARQUET_2_0) => Encoding::DELTA_BINARY_PACKED,
         (Type::BYTE_ARRAY, WriterVersion::PARQUET_2_0) => Encoding::DELTA_BYTE_ARRAY,
-        (Type::FIXED_LEN_BYTE_ARRAY, WriterVersion::PARQUET_2_0) => {
-            Encoding::DELTA_BYTE_ARRAY
-        }
+        (Type::FIXED_LEN_BYTE_ARRAY, WriterVersion::PARQUET_2_0) => Encoding::DELTA_BYTE_ARRAY,
         _ => Encoding::PLAIN,
     }
 }
@@ -1048,9 +1219,7 @@ fn compare_greater_byte_array_decimals(a: &[u8], b: &[u8]) -> bool {
     // for equal length bytes arrays that have different first bytes.
     // The equality requirement is necessary for sign extension cases.
     // 0xFF10 should be equal to 0x10 (due to big endian sign extension).
-    if (0x80 & first_a) != (0x80 & first_b)
-        || (a_length == b_length && first_a != first_b)
-    {
+    if (0x80 & first_a) != (0x80 & first_b) || (a_length == b_length && first_a != first_b) {
         return (first_a as i8) > (first_b as i8);
     }
 
@@ -1064,10 +1233,10 @@ fn compare_greater_byte_array_decimals(a: &[u8], b: &[u8]) -> bool {
     if a_length != b_length {
         let not_equal = if a_length > b_length {
             let lead_length = a_length - b_length;
-            (&a[0..lead_length]).iter().any(|&x| x != extension)
+            a[0..lead_length].iter().any(|&x| x != extension)
         } else {
             let lead_length = b_length - a_length;
-            (&b[0..lead_length]).iter().any(|&x| x != extension)
+            b[0..lead_length].iter().any(|&x| x != extension)
         };
 
         if not_equal {
@@ -1080,9 +1249,52 @@ fn compare_greater_byte_array_decimals(a: &[u8], b: &[u8]) -> bool {
     (a[1..]) > (b[1..])
 }
 
+/// Truncate a UTF8 slice to the longest prefix that is still a valid UTF8 string,
+/// while being less than `length` bytes and non-empty
+fn truncate_utf8(data: &str, length: usize) -> Option<Vec<u8>> {
+    let split = (1..=length).rfind(|x| data.is_char_boundary(*x))?;
+    Some(data.as_bytes()[..split].to_vec())
+}
+
+/// Try and increment the bytes from right to left.
+///
+/// Returns `None` if all bytes are set to `u8::MAX`.
+fn increment(mut data: Vec<u8>) -> Option<Vec<u8>> {
+    for byte in data.iter_mut().rev() {
+        let (incremented, overflow) = byte.overflowing_add(1);
+        *byte = incremented;
+
+        if !overflow {
+            return Some(data);
+        }
+    }
+
+    None
+}
+
+/// Try and increment the the string's bytes from right to left, returning when the result
+/// is a valid UTF8 string. Returns `None` when it can't increment any byte.
+fn increment_utf8(mut data: Vec<u8>) -> Option<Vec<u8>> {
+    for idx in (0..data.len()).rev() {
+        let original = data[idx];
+        let (byte, overflow) = original.overflowing_add(1);
+        if !overflow {
+            data[idx] = byte;
+            if str::from_utf8(&data).is_ok() {
+                return Some(data);
+            }
+            data[idx] = original;
+        }
+    }
+
+    None
+}
+
 #[cfg(test)]
 mod tests {
-    use parquet_format::BoundaryOrder;
+    use crate::{file::properties::DEFAULT_COLUMN_INDEX_TRUNCATE_LENGTH, format::BoundaryOrder};
+    use bytes::Bytes;
+    use half::f16;
     use rand::distributions::uniform::SampleUniform;
     use std::sync::Arc;
 
@@ -1092,24 +1304,25 @@ mod tests {
     };
     use crate::file::writer::TrackedWrite;
     use crate::file::{
-        properties::WriterProperties, reader::SerializedPageReader,
+        properties::{ReaderProperties, WriterProperties},
+        reader::SerializedPageReader,
         writer::SerializedPageWriter,
     };
     use crate::schema::types::{ColumnDescriptor, ColumnPath, Type as SchemaType};
-    use crate::util::{io::FileSource, test_common::rand_gen::random_numbers_range};
+    use crate::util::test_common::rand_gen::random_numbers_range;
 
     use super::*;
 
     #[test]
     fn test_column_writer_inconsistent_def_rep_length() {
         let page_writer = get_test_page_writer();
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = get_test_column_writer::<Int32Type>(page_writer, 1, 1, props);
         let res = writer.write_batch(&[1, 2, 3, 4], Some(&[1, 1, 1]), Some(&[0, 0]));
         assert!(res.is_err());
         if let Err(err) = res {
             assert_eq!(
-                format!("{}", err),
+                format!("{err}"),
                 "Parquet error: Inconsistent length of definition and repetition levels: 3 != 2"
             );
         }
@@ -1118,13 +1331,13 @@ mod tests {
     #[test]
     fn test_column_writer_invalid_def_levels() {
         let page_writer = get_test_page_writer();
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = get_test_column_writer::<Int32Type>(page_writer, 1, 0, props);
         let res = writer.write_batch(&[1, 2, 3, 4], None, None);
         assert!(res.is_err());
         if let Err(err) = res {
             assert_eq!(
-                format!("{}", err),
+                format!("{err}"),
                 "Parquet error: Definition levels are required, because max definition level = 1"
             );
         }
@@ -1133,13 +1346,13 @@ mod tests {
     #[test]
     fn test_column_writer_invalid_rep_levels() {
         let page_writer = get_test_page_writer();
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = get_test_column_writer::<Int32Type>(page_writer, 0, 1, props);
         let res = writer.write_batch(&[1, 2, 3, 4], None, None);
         assert!(res.is_err());
         if let Err(err) = res {
             assert_eq!(
-                format!("{}", err),
+                format!("{err}"),
                 "Parquet error: Repetition levels are required, because max repetition level = 1"
             );
         }
@@ -1148,13 +1361,13 @@ mod tests {
     #[test]
     fn test_column_writer_not_enough_values_to_write() {
         let page_writer = get_test_page_writer();
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = get_test_column_writer::<Int32Type>(page_writer, 1, 0, props);
         let res = writer.write_batch(&[1, 2], Some(&[1, 1, 1, 1]), None);
         assert!(res.is_err());
         if let Err(err) = res {
             assert_eq!(
-                format!("{}", err),
+                format!("{err}"),
                 "Parquet error: Expected to write 4 values, but have only 2"
             );
         }
@@ -1163,7 +1376,7 @@ mod tests {
     #[test]
     fn test_column_writer_write_only_one_dictionary_page() {
         let page_writer = get_test_page_writer();
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = get_test_column_writer::<Int32Type>(page_writer, 0, 0, props);
         writer.write_batch(&[1, 2, 3, 4], None, None).unwrap();
         // First page should be correctly written.
@@ -1200,11 +1413,13 @@ mod tests {
             .write_batch(&[true, false, true, false], None, None)
             .unwrap();
 
-        let (bytes_written, rows_written, metadata, _, _) = writer.close().unwrap();
+        let r = writer.close().unwrap();
         // PlainEncoder uses bit writer to write boolean values, which all fit into 1
         // byte.
-        assert_eq!(bytes_written, 1);
-        assert_eq!(rows_written, 4);
+        assert_eq!(r.bytes_written, 1);
+        assert_eq!(r.rows_written, 4);
+
+        let metadata = r.metadata;
         assert_eq!(metadata.encodings(), &vec![Encoding::PLAIN, Encoding::RLE]);
         assert_eq!(metadata.num_values(), 4); // just values
         assert_eq!(metadata.dictionary_page_offset(), None);
@@ -1469,18 +1684,20 @@ mod tests {
     #[test]
     fn test_column_writer_check_metadata() {
         let page_writer = get_test_page_writer();
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = get_test_column_writer::<Int32Type>(page_writer, 0, 0, props);
         writer.write_batch(&[1, 2, 3, 4], None, None).unwrap();
 
-        let (bytes_written, rows_written, metadata, _, _) = writer.close().unwrap();
-        assert_eq!(bytes_written, 20);
-        assert_eq!(rows_written, 4);
+        let r = writer.close().unwrap();
+        assert_eq!(r.bytes_written, 20);
+        assert_eq!(r.rows_written, 4);
+
+        let metadata = r.metadata;
         assert_eq!(
             metadata.encodings(),
             &vec![Encoding::PLAIN, Encoding::RLE, Encoding::RLE_DICTIONARY]
         );
-        assert_eq!(metadata.num_values(), 8); // dictionary + value indexes
+        assert_eq!(metadata.num_values(), 4);
         assert_eq!(metadata.compressed_size(), 20);
         assert_eq!(metadata.uncompressed_size(), 20);
         assert_eq!(metadata.data_page_offset(), 0);
@@ -1503,49 +1720,48 @@ mod tests {
     #[test]
     fn test_column_writer_check_byte_array_min_max() {
         let page_writer = get_test_page_writer();
-        let props = Arc::new(WriterProperties::builder().build());
-        let mut writer =
-            get_test_decimals_column_writer::<ByteArrayType>(page_writer, 0, 0, props);
+        let props = Default::default();
+        let mut writer = get_test_decimals_column_writer::<ByteArrayType>(page_writer, 0, 0, props);
         writer
             .write_batch(
                 &[
                     ByteArray::from(vec![
-                        255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 179u8,
-                        172u8, 19u8, 35u8, 231u8, 90u8, 0u8, 0u8,
+                        255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 179u8, 172u8, 19u8,
+                        35u8, 231u8, 90u8, 0u8, 0u8,
                     ]),
                     ByteArray::from(vec![
-                        255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 228u8,
-                        62u8, 146u8, 152u8, 177u8, 56u8, 0u8, 0u8,
+                        255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 228u8, 62u8, 146u8,
+                        152u8, 177u8, 56u8, 0u8, 0u8,
                     ]),
                     ByteArray::from(vec![
-                        0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
-                        0u8, 0u8, 0u8,
+                        0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8,
+                        0u8,
                     ]),
                     ByteArray::from(vec![
-                        0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 41u8, 162u8, 36u8, 26u8,
-                        246u8, 44u8, 0u8, 0u8,
+                        0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 41u8, 162u8, 36u8, 26u8, 246u8,
+                        44u8, 0u8, 0u8,
                     ]),
                 ],
                 None,
                 None,
             )
             .unwrap();
-        let (_bytes_written, _rows_written, metadata, _, _) = writer.close().unwrap();
+        let metadata = writer.close().unwrap().metadata;
         if let Some(stats) = metadata.statistics() {
             assert!(stats.has_min_max_set());
             if let Statistics::ByteArray(stats) = stats {
                 assert_eq!(
                     stats.min(),
                     &ByteArray::from(vec![
-                        255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 179u8,
-                        172u8, 19u8, 35u8, 231u8, 90u8, 0u8, 0u8,
+                        255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 179u8, 172u8, 19u8,
+                        35u8, 231u8, 90u8, 0u8, 0u8,
                     ])
                 );
                 assert_eq!(
                     stats.max(),
                     &ByteArray::from(vec![
-                        0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 41u8, 162u8, 36u8, 26u8,
-                        246u8, 44u8, 0u8, 0u8,
+                        0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 0u8, 41u8, 162u8, 36u8, 26u8, 246u8,
+                        44u8, 0u8, 0u8,
                     ])
                 );
             } else {
@@ -1559,12 +1775,15 @@ mod tests {
     #[test]
     fn test_column_writer_uint32_converted_type_min_max() {
         let page_writer = get_test_page_writer();
-        let props = Arc::new(WriterProperties::builder().build());
-        let mut writer = get_test_unsigned_int_given_as_converted_column_writer::<
-            Int32Type,
-        >(page_writer, 0, 0, props);
+        let props = Default::default();
+        let mut writer = get_test_unsigned_int_given_as_converted_column_writer::<Int32Type>(
+            page_writer,
+            0,
+            0,
+            props,
+        );
         writer.write_batch(&[0, 1, 2, 3, 4, 5], None, None).unwrap();
-        let (_bytes_written, _rows_written, metadata, _, _) = writer.close().unwrap();
+        let metadata = writer.close().unwrap().metadata;
         if let Some(stats) = metadata.statistics() {
             assert!(stats.has_min_max_set());
             if let Statistics::Int32(stats) = stats {
@@ -1598,14 +1817,16 @@ mod tests {
             )
             .unwrap();
 
-        let (bytes_written, rows_written, metadata, _, _) = writer.close().unwrap();
-        assert_eq!(bytes_written, 20);
-        assert_eq!(rows_written, 4);
+        let r = writer.close().unwrap();
+        assert_eq!(r.bytes_written, 20);
+        assert_eq!(r.rows_written, 4);
+
+        let metadata = r.metadata;
         assert_eq!(
             metadata.encodings(),
             &vec![Encoding::PLAIN, Encoding::RLE, Encoding::RLE_DICTIONARY]
         );
-        assert_eq!(metadata.num_values(), 8); // dictionary + value indexes
+        assert_eq!(metadata.num_values(), 4);
         assert_eq!(metadata.compressed_size(), 20);
         assert_eq!(metadata.uncompressed_size(), 20);
         assert_eq!(metadata.data_page_offset(), 0);
@@ -1630,34 +1851,33 @@ mod tests {
         let mut buf = Vec::with_capacity(100);
         let mut write = TrackedWrite::new(&mut buf);
         let page_writer = Box::new(SerializedPageWriter::new(&mut write));
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = get_test_column_writer::<Int32Type>(page_writer, 0, 0, props);
 
         writer.write_batch(&[1, 2, 3, 4], None, None).unwrap();
         writer
-            .write_batch_with_statistics(
-                &[5, 6, 7],
-                None,
-                None,
-                Some(&5),
-                Some(&7),
-                Some(3),
-            )
+            .write_batch_with_statistics(&[5, 6, 7], None, None, Some(&5), Some(&7), Some(3))
             .unwrap();
 
-        let (_, _, metadata, _, _) = writer.close().unwrap();
+        let r = writer.close().unwrap();
 
-        let stats = metadata.statistics().unwrap();
+        let stats = r.metadata.statistics().unwrap();
         assert_eq!(stats.min_bytes(), 1_i32.to_le_bytes());
         assert_eq!(stats.max_bytes(), 7_i32.to_le_bytes());
         assert_eq!(stats.null_count(), 0);
         assert!(stats.distinct_count().is_none());
 
-        let reader = SerializedPageReader::new(
-            std::io::Cursor::new(buf),
-            7,
-            Compression::UNCOMPRESSED,
-            Type::INT32,
+        drop(write);
+
+        let props = ReaderProperties::builder()
+            .set_backward_compatible_lz4(false)
+            .build();
+        let reader = SerializedPageReader::new_with_properties(
+            Arc::new(Bytes::from(buf)),
+            &r.metadata,
+            r.rows_written as usize,
+            None,
+            Arc::new(props),
         )
         .unwrap();
 
@@ -1690,14 +1910,20 @@ mod tests {
             .write_batch(&[1, 2, 3, 4], Some(&[1, 0, 0, 1, 1, 1]), None)
             .unwrap();
 
-        let (_, _, metadata, _, _) = writer.close().unwrap();
-        assert!(metadata.statistics().is_none());
+        let r = writer.close().unwrap();
+        assert!(r.metadata.statistics().is_none());
+
+        drop(write);
 
-        let reader = SerializedPageReader::new(
-            std::io::Cursor::new(buf),
-            6,
-            Compression::UNCOMPRESSED,
-            Type::INT32,
+        let props = ReaderProperties::builder()
+            .set_backward_compatible_lz4(false)
+            .build();
+        let reader = SerializedPageReader::new_with_properties(
+            Arc::new(Bytes::from(buf)),
+            &r.metadata,
+            r.rows_written as usize,
+            None,
+            Arc::new(props),
         )
         .unwrap();
 
@@ -1726,33 +1952,33 @@ mod tests {
 
     #[test]
     fn test_column_writer_empty_column_roundtrip() {
-        let props = WriterProperties::builder().build();
+        let props = Default::default();
         column_roundtrip::<Int32Type>(props, &[], None, None);
     }
 
     #[test]
     fn test_column_writer_non_nullable_values_roundtrip() {
-        let props = WriterProperties::builder().build();
+        let props = Default::default();
         column_roundtrip_random::<Int32Type>(props, 1024, i32::MIN, i32::MAX, 0, 0);
     }
 
     #[test]
     fn test_column_writer_nullable_non_repeated_values_roundtrip() {
-        let props = WriterProperties::builder().build();
+        let props = Default::default();
         column_roundtrip_random::<Int32Type>(props, 1024, i32::MIN, i32::MAX, 10, 0);
     }
 
     #[test]
     fn test_column_writer_nullable_repeated_values_roundtrip() {
-        let props = WriterProperties::builder().build();
+        let props = Default::default();
         column_roundtrip_random::<Int32Type>(props, 1024, i32::MIN, i32::MAX, 10, 10);
     }
 
     #[test]
     fn test_column_writer_dictionary_fallback_small_data_page() {
         let props = WriterProperties::builder()
-            .set_dictionary_pagesize_limit(32)
-            .set_data_pagesize_limit(32)
+            .set_dictionary_page_size_limit(32)
+            .set_data_page_size_limit(32)
             .build();
         column_roundtrip_random::<Int32Type>(props, 1024, i32::MIN, i32::MAX, 10, 10);
     }
@@ -1807,42 +2033,45 @@ mod tests {
         // ARROW-5129: Test verifies that we add data page in case of dictionary encoding
         // and no fallback occurred so far.
         let mut file = tempfile::tempfile().unwrap();
-        let mut writer = TrackedWrite::new(&mut file);
-        let page_writer = Box::new(SerializedPageWriter::new(&mut writer));
+        let mut write = TrackedWrite::new(&mut file);
+        let page_writer = Box::new(SerializedPageWriter::new(&mut write));
         let props = Arc::new(
             WriterProperties::builder()
-                .set_data_pagesize_limit(15) // actually each page will have size 15-18 bytes
+                .set_data_page_size_limit(10)
                 .set_write_batch_size(3) // write 3 values at a time
                 .build(),
         );
         let data = &[1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
         let mut writer = get_test_column_writer::<Int32Type>(page_writer, 0, 0, props);
         writer.write_batch(data, None, None).unwrap();
-        let (bytes_written, _, _, _, _) = writer.close().unwrap();
+        let r = writer.close().unwrap();
+
+        drop(write);
 
         // Read pages and check the sequence
-        let source = FileSource::new(&file, 0, bytes_written as usize);
+        let props = ReaderProperties::builder()
+            .set_backward_compatible_lz4(false)
+            .build();
         let mut page_reader = Box::new(
-            SerializedPageReader::new(
-                source,
-                data.len() as i64,
-                Compression::UNCOMPRESSED,
-                Int32Type::get_physical_type(),
+            SerializedPageReader::new_with_properties(
+                Arc::new(file),
+                &r.metadata,
+                r.rows_written as usize,
+                None,
+                Arc::new(props),
             )
             .unwrap(),
         );
         let mut res = Vec::new();
         while let Some(page) = page_reader.get_next_page().unwrap() {
-            res.push((page.page_type(), page.num_values()));
+            res.push((page.page_type(), page.num_values(), page.buffer().len()));
         }
         assert_eq!(
             res,
             vec![
-                (PageType::DICTIONARY_PAGE, 10),
-                (PageType::DATA_PAGE, 3),
-                (PageType::DATA_PAGE, 3),
-                (PageType::DATA_PAGE, 3),
-                (PageType::DATA_PAGE, 1)
+                (PageType::DICTIONARY_PAGE, 10, 40),
+                (PageType::DATA_PAGE, 9, 10),
+                (PageType::DATA_PAGE, 1, 3),
             ]
         );
     }
@@ -1851,11 +2080,14 @@ mod tests {
     fn test_bool_statistics() {
         let stats = statistics_roundtrip::<BoolType>(&[true, false, false, true]);
         assert!(stats.has_min_max_set());
+        // Booleans have an unsigned sort order and so are not compatible
+        // with the deprecated `min` and `max` statistics
+        assert!(!stats.is_min_max_backwards_compatible());
         if let Statistics::Boolean(stats) = stats {
             assert_eq!(stats.min(), &false);
             assert_eq!(stats.max(), &true);
         } else {
-            panic!("expecting Statistics::Boolean, got {:?}", stats);
+            panic!("expecting Statistics::Boolean, got {stats:?}");
         }
     }
 
@@ -1863,11 +2095,12 @@ mod tests {
     fn test_int32_statistics() {
         let stats = statistics_roundtrip::<Int32Type>(&[-1, 3, -2, 2]);
         assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
         if let Statistics::Int32(stats) = stats {
             assert_eq!(stats.min(), &-2);
             assert_eq!(stats.max(), &3);
         } else {
-            panic!("expecting Statistics::Int32, got {:?}", stats);
+            panic!("expecting Statistics::Int32, got {stats:?}");
         }
     }
 
@@ -1875,11 +2108,12 @@ mod tests {
     fn test_int64_statistics() {
         let stats = statistics_roundtrip::<Int64Type>(&[-1, 3, -2, 2]);
         assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
         if let Statistics::Int64(stats) = stats {
             assert_eq!(stats.min(), &-2);
             assert_eq!(stats.max(), &3);
         } else {
-            panic!("expecting Statistics::Int64, got {:?}", stats);
+            panic!("expecting Statistics::Int64, got {stats:?}");
         }
     }
 
@@ -1896,11 +2130,12 @@ mod tests {
 
         let stats = statistics_roundtrip::<Int96Type>(&input);
         assert!(stats.has_min_max_set());
+        assert!(!stats.is_min_max_backwards_compatible());
         if let Statistics::Int96(stats) = stats {
             assert_eq!(stats.min(), &Int96::from(vec![0, 20, 30]));
             assert_eq!(stats.max(), &Int96::from(vec![3, 20, 10]));
         } else {
-            panic!("expecting Statistics::Int96, got {:?}", stats);
+            panic!("expecting Statistics::Int96, got {stats:?}");
         }
     }
 
@@ -1908,11 +2143,12 @@ mod tests {
     fn test_float_statistics() {
         let stats = statistics_roundtrip::<FloatType>(&[-1.0, 3.0, -2.0, 2.0]);
         assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
         if let Statistics::Float(stats) = stats {
             assert_eq!(stats.min(), &-2.0);
             assert_eq!(stats.max(), &3.0);
         } else {
-            panic!("expecting Statistics::Float, got {:?}", stats);
+            panic!("expecting Statistics::Float, got {stats:?}");
         }
     }
 
@@ -1920,57 +2156,187 @@ mod tests {
     fn test_double_statistics() {
         let stats = statistics_roundtrip::<DoubleType>(&[-1.0, 3.0, -2.0, 2.0]);
         assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
         if let Statistics::Double(stats) = stats {
             assert_eq!(stats.min(), &-2.0);
             assert_eq!(stats.max(), &3.0);
         } else {
-            panic!("expecting Statistics::Double, got {:?}", stats);
+            panic!("expecting Statistics::Double, got {stats:?}");
         }
     }
 
     #[test]
     fn test_byte_array_statistics() {
-        let input = vec!["aawaa", "zz", "aaw", "m", "qrs"]
+        let input = ["aawaa", "zz", "aaw", "m", "qrs"]
             .iter()
             .map(|&s| s.into())
-            .collect::<Vec<ByteArray>>();
+            .collect::<Vec<_>>();
 
         let stats = statistics_roundtrip::<ByteArrayType>(&input);
+        assert!(!stats.is_min_max_backwards_compatible());
         assert!(stats.has_min_max_set());
         if let Statistics::ByteArray(stats) = stats {
             assert_eq!(stats.min(), &ByteArray::from("aaw"));
             assert_eq!(stats.max(), &ByteArray::from("zz"));
         } else {
-            panic!("expecting Statistics::ByteArray, got {:?}", stats);
+            panic!("expecting Statistics::ByteArray, got {stats:?}");
         }
     }
 
     #[test]
     fn test_fixed_len_byte_array_statistics() {
-        let input = vec!["aawaa", "zz   ", "aaw  ", "m    ", "qrs  "]
+        let input = ["aawaa", "zz   ", "aaw  ", "m    ", "qrs  "]
             .iter()
-            .map(|&s| {
-                let b: ByteArray = s.into();
-                b.into()
-            })
-            .collect::<Vec<FixedLenByteArray>>();
+            .map(|&s| ByteArray::from(s).into())
+            .collect::<Vec<_>>();
 
         let stats = statistics_roundtrip::<FixedLenByteArrayType>(&input);
         assert!(stats.has_min_max_set());
+        assert!(!stats.is_min_max_backwards_compatible());
         if let Statistics::FixedLenByteArray(stats) = stats {
             let expected_min: FixedLenByteArray = ByteArray::from("aaw  ").into();
             assert_eq!(stats.min(), &expected_min);
             let expected_max: FixedLenByteArray = ByteArray::from("zz   ").into();
             assert_eq!(stats.max(), &expected_max);
         } else {
-            panic!("expecting Statistics::FixedLenByteArray, got {:?}", stats);
+            panic!("expecting Statistics::FixedLenByteArray, got {stats:?}");
         }
     }
 
+    #[test]
+    fn test_column_writer_check_float16_min_max() {
+        let input = [
+            -f16::ONE,
+            f16::from_f32(3.0),
+            -f16::from_f32(2.0),
+            f16::from_f32(2.0),
+        ]
+        .into_iter()
+        .map(|s| ByteArray::from(s).into())
+        .collect::<Vec<_>>();
+
+        let stats = float16_statistics_roundtrip(&input);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        assert_eq!(stats.min(), &ByteArray::from(-f16::from_f32(2.0)));
+        assert_eq!(stats.max(), &ByteArray::from(f16::from_f32(3.0)));
+    }
+
+    #[test]
+    fn test_column_writer_check_float16_nan_middle() {
+        let input = [f16::ONE, f16::NAN, f16::ONE + f16::ONE]
+            .into_iter()
+            .map(|s| ByteArray::from(s).into())
+            .collect::<Vec<_>>();
+
+        let stats = float16_statistics_roundtrip(&input);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        assert_eq!(stats.min(), &ByteArray::from(f16::ONE));
+        assert_eq!(stats.max(), &ByteArray::from(f16::ONE + f16::ONE));
+    }
+
+    #[test]
+    fn test_float16_statistics_nan_middle() {
+        let input = [f16::ONE, f16::NAN, f16::ONE + f16::ONE]
+            .into_iter()
+            .map(|s| ByteArray::from(s).into())
+            .collect::<Vec<_>>();
+
+        let stats = float16_statistics_roundtrip(&input);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        assert_eq!(stats.min(), &ByteArray::from(f16::ONE));
+        assert_eq!(stats.max(), &ByteArray::from(f16::ONE + f16::ONE));
+    }
+
+    #[test]
+    fn test_float16_statistics_nan_start() {
+        let input = [f16::NAN, f16::ONE, f16::ONE + f16::ONE]
+            .into_iter()
+            .map(|s| ByteArray::from(s).into())
+            .collect::<Vec<_>>();
+
+        let stats = float16_statistics_roundtrip(&input);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        assert_eq!(stats.min(), &ByteArray::from(f16::ONE));
+        assert_eq!(stats.max(), &ByteArray::from(f16::ONE + f16::ONE));
+    }
+
+    #[test]
+    fn test_float16_statistics_nan_only() {
+        let input = [f16::NAN, f16::NAN]
+            .into_iter()
+            .map(|s| ByteArray::from(s).into())
+            .collect::<Vec<_>>();
+
+        let stats = float16_statistics_roundtrip(&input);
+        assert!(!stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+    }
+
+    #[test]
+    fn test_float16_statistics_zero_only() {
+        let input = [f16::ZERO]
+            .into_iter()
+            .map(|s| ByteArray::from(s).into())
+            .collect::<Vec<_>>();
+
+        let stats = float16_statistics_roundtrip(&input);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        assert_eq!(stats.min(), &ByteArray::from(f16::NEG_ZERO));
+        assert_eq!(stats.max(), &ByteArray::from(f16::ZERO));
+    }
+
+    #[test]
+    fn test_float16_statistics_neg_zero_only() {
+        let input = [f16::NEG_ZERO]
+            .into_iter()
+            .map(|s| ByteArray::from(s).into())
+            .collect::<Vec<_>>();
+
+        let stats = float16_statistics_roundtrip(&input);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        assert_eq!(stats.min(), &ByteArray::from(f16::NEG_ZERO));
+        assert_eq!(stats.max(), &ByteArray::from(f16::ZERO));
+    }
+
+    #[test]
+    fn test_float16_statistics_zero_min() {
+        let input = [f16::ZERO, f16::ONE, f16::NAN, f16::PI]
+            .into_iter()
+            .map(|s| ByteArray::from(s).into())
+            .collect::<Vec<_>>();
+
+        let stats = float16_statistics_roundtrip(&input);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        assert_eq!(stats.min(), &ByteArray::from(f16::NEG_ZERO));
+        assert_eq!(stats.max(), &ByteArray::from(f16::PI));
+    }
+
+    #[test]
+    fn test_float16_statistics_neg_zero_max() {
+        let input = [f16::NEG_ZERO, f16::NEG_ONE, f16::NAN, -f16::PI]
+            .into_iter()
+            .map(|s| ByteArray::from(s).into())
+            .collect::<Vec<_>>();
+
+        let stats = float16_statistics_roundtrip(&input);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        assert_eq!(stats.min(), &ByteArray::from(-f16::PI));
+        assert_eq!(stats.max(), &ByteArray::from(f16::ZERO));
+    }
+
     #[test]
     fn test_float_statistics_nan_middle() {
         let stats = statistics_roundtrip::<FloatType>(&[1.0, f32::NAN, 2.0]);
         assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
         if let Statistics::Float(stats) = stats {
             assert_eq!(stats.min(), &1.0);
             assert_eq!(stats.max(), &2.0);
@@ -1983,6 +2349,7 @@ mod tests {
     fn test_float_statistics_nan_start() {
         let stats = statistics_roundtrip::<FloatType>(&[f32::NAN, 1.0, 2.0]);
         assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
         if let Statistics::Float(stats) = stats {
             assert_eq!(stats.min(), &1.0);
             assert_eq!(stats.max(), &2.0);
@@ -1995,27 +2362,48 @@ mod tests {
     fn test_float_statistics_nan_only() {
         let stats = statistics_roundtrip::<FloatType>(&[f32::NAN, f32::NAN]);
         assert!(!stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
         assert!(matches!(stats, Statistics::Float(_)));
     }
 
     #[test]
-    fn test_double_statistics_nan_middle() {
-        let stats = statistics_roundtrip::<DoubleType>(&[1.0, f64::NAN, 2.0]);
+    fn test_float_statistics_zero_only() {
+        let stats = statistics_roundtrip::<FloatType>(&[0.0]);
         assert!(stats.has_min_max_set());
-        if let Statistics::Double(stats) = stats {
-            assert_eq!(stats.min(), &1.0);
-            assert_eq!(stats.max(), &2.0);
+        assert!(stats.is_min_max_backwards_compatible());
+        if let Statistics::Float(stats) = stats {
+            assert_eq!(stats.min(), &-0.0);
+            assert!(stats.min().is_sign_negative());
+            assert_eq!(stats.max(), &0.0);
+            assert!(stats.max().is_sign_positive());
         } else {
             panic!("expecting Statistics::Float");
         }
     }
 
     #[test]
-    fn test_double_statistics_nan_start() {
-        let stats = statistics_roundtrip::<DoubleType>(&[f64::NAN, 1.0, 2.0]);
+    fn test_float_statistics_neg_zero_only() {
+        let stats = statistics_roundtrip::<FloatType>(&[-0.0]);
         assert!(stats.has_min_max_set());
-        if let Statistics::Double(stats) = stats {
-            assert_eq!(stats.min(), &1.0);
+        assert!(stats.is_min_max_backwards_compatible());
+        if let Statistics::Float(stats) = stats {
+            assert_eq!(stats.min(), &-0.0);
+            assert!(stats.min().is_sign_negative());
+            assert_eq!(stats.max(), &0.0);
+            assert!(stats.max().is_sign_positive());
+        } else {
+            panic!("expecting Statistics::Float");
+        }
+    }
+
+    #[test]
+    fn test_float_statistics_zero_min() {
+        let stats = statistics_roundtrip::<FloatType>(&[0.0, 1.0, f32::NAN, 2.0]);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        if let Statistics::Float(stats) = stats {
+            assert_eq!(stats.min(), &-0.0);
+            assert!(stats.min().is_sign_negative());
             assert_eq!(stats.max(), &2.0);
         } else {
             panic!("expecting Statistics::Float");
@@ -2023,17 +2411,116 @@ mod tests {
     }
 
     #[test]
-    fn test_double_statistics_nan_only() {
-        let stats = statistics_roundtrip::<DoubleType>(&[f64::NAN, f64::NAN]);
-        assert!(!stats.has_min_max_set());
-        assert!(matches!(stats, Statistics::Double(_)));
+    fn test_float_statistics_neg_zero_max() {
+        let stats = statistics_roundtrip::<FloatType>(&[-0.0, -1.0, f32::NAN, -2.0]);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        if let Statistics::Float(stats) = stats {
+            assert_eq!(stats.min(), &-2.0);
+            assert_eq!(stats.max(), &0.0);
+            assert!(stats.max().is_sign_positive());
+        } else {
+            panic!("expecting Statistics::Float");
+        }
     }
 
     #[test]
-    fn test_compare_greater_byte_array_decimals() {
-        assert!(!compare_greater_byte_array_decimals(&[], &[],),);
-        assert!(compare_greater_byte_array_decimals(&[1u8,], &[],),);
-        assert!(!compare_greater_byte_array_decimals(&[], &[1u8,],),);
+    fn test_double_statistics_nan_middle() {
+        let stats = statistics_roundtrip::<DoubleType>(&[1.0, f64::NAN, 2.0]);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        if let Statistics::Double(stats) = stats {
+            assert_eq!(stats.min(), &1.0);
+            assert_eq!(stats.max(), &2.0);
+        } else {
+            panic!("expecting Statistics::Double");
+        }
+    }
+
+    #[test]
+    fn test_double_statistics_nan_start() {
+        let stats = statistics_roundtrip::<DoubleType>(&[f64::NAN, 1.0, 2.0]);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        if let Statistics::Double(stats) = stats {
+            assert_eq!(stats.min(), &1.0);
+            assert_eq!(stats.max(), &2.0);
+        } else {
+            panic!("expecting Statistics::Double");
+        }
+    }
+
+    #[test]
+    fn test_double_statistics_nan_only() {
+        let stats = statistics_roundtrip::<DoubleType>(&[f64::NAN, f64::NAN]);
+        assert!(!stats.has_min_max_set());
+        assert!(matches!(stats, Statistics::Double(_)));
+        assert!(stats.is_min_max_backwards_compatible());
+    }
+
+    #[test]
+    fn test_double_statistics_zero_only() {
+        let stats = statistics_roundtrip::<DoubleType>(&[0.0]);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        if let Statistics::Double(stats) = stats {
+            assert_eq!(stats.min(), &-0.0);
+            assert!(stats.min().is_sign_negative());
+            assert_eq!(stats.max(), &0.0);
+            assert!(stats.max().is_sign_positive());
+        } else {
+            panic!("expecting Statistics::Double");
+        }
+    }
+
+    #[test]
+    fn test_double_statistics_neg_zero_only() {
+        let stats = statistics_roundtrip::<DoubleType>(&[-0.0]);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        if let Statistics::Double(stats) = stats {
+            assert_eq!(stats.min(), &-0.0);
+            assert!(stats.min().is_sign_negative());
+            assert_eq!(stats.max(), &0.0);
+            assert!(stats.max().is_sign_positive());
+        } else {
+            panic!("expecting Statistics::Double");
+        }
+    }
+
+    #[test]
+    fn test_double_statistics_zero_min() {
+        let stats = statistics_roundtrip::<DoubleType>(&[0.0, 1.0, f64::NAN, 2.0]);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        if let Statistics::Double(stats) = stats {
+            assert_eq!(stats.min(), &-0.0);
+            assert!(stats.min().is_sign_negative());
+            assert_eq!(stats.max(), &2.0);
+        } else {
+            panic!("expecting Statistics::Double");
+        }
+    }
+
+    #[test]
+    fn test_double_statistics_neg_zero_max() {
+        let stats = statistics_roundtrip::<DoubleType>(&[-0.0, -1.0, f64::NAN, -2.0]);
+        assert!(stats.has_min_max_set());
+        assert!(stats.is_min_max_backwards_compatible());
+        if let Statistics::Double(stats) = stats {
+            assert_eq!(stats.min(), &-2.0);
+            assert_eq!(stats.max(), &0.0);
+            assert!(stats.max().is_sign_positive());
+        } else {
+            panic!("expecting Statistics::Double");
+        }
+    }
+
+    #[test]
+    fn test_compare_greater_byte_array_decimals() {
+        assert!(!compare_greater_byte_array_decimals(&[], &[],),);
+        assert!(compare_greater_byte_array_decimals(&[1u8,], &[],),);
+        assert!(!compare_greater_byte_array_decimals(&[], &[1u8,],),);
         assert!(compare_greater_byte_array_decimals(&[1u8,], &[0u8,],),);
         assert!(!compare_greater_byte_array_decimals(&[1u8,], &[1u8,],),);
         assert!(compare_greater_byte_array_decimals(&[1u8, 0u8,], &[0u8,],),);
@@ -2056,7 +2543,7 @@ mod tests {
         // write data
         // and check the offset index and column index
         let page_writer = get_test_page_writer();
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = get_test_column_writer::<Int32Type>(page_writer, 0, 0, props);
         writer.write_batch(&[1, 2, 3, 4], None, None).unwrap();
         // first page
@@ -2064,44 +2551,31 @@ mod tests {
         // second page
         writer.write_batch(&[4, 8, 2, -5], None, None).unwrap();
 
-        let (_, rows_written, metadata, column_index, offset_index) =
-            writer.close().unwrap();
-        let column_index = match column_index {
-            None => {
-                panic!("Can't fine the column index");
-            }
-            Some(column_index) => column_index,
-        };
-        let offset_index = match offset_index {
-            None => {
-                panic!("Can't find the offset index");
-            }
-            Some(offset_index) => offset_index,
-        };
+        let r = writer.close().unwrap();
+        let column_index = r.column_index.unwrap();
+        let offset_index = r.offset_index.unwrap();
 
-        assert_eq!(8, rows_written);
+        assert_eq!(8, r.rows_written);
 
         // column index
         assert_eq!(2, column_index.null_pages.len());
         assert_eq!(2, offset_index.page_locations.len());
-        assert_eq!(BoundaryOrder::Unordered, column_index.boundary_order);
+        assert_eq!(BoundaryOrder::UNORDERED, column_index.boundary_order);
         for idx in 0..2 {
             assert!(!column_index.null_pages[idx]);
             assert_eq!(0, column_index.null_counts.as_ref().unwrap()[idx]);
         }
 
-        if let Some(stats) = metadata.statistics() {
+        if let Some(stats) = r.metadata.statistics() {
             assert!(stats.has_min_max_set());
             assert_eq!(stats.null_count(), 0);
             assert_eq!(stats.distinct_count(), None);
             if let Statistics::Int32(stats) = stats {
                 // first page is [1,2,3,4]
                 // second page is [-5,2,4,8]
+                // note that we don't increment here, as this is a non BinaryArray type.
                 assert_eq!(stats.min_bytes(), column_index.min_values[1].as_slice());
-                assert_eq!(
-                    stats.max_bytes(),
-                    column_index.max_values.get(1).unwrap().as_slice()
-                );
+                assert_eq!(stats.max_bytes(), column_index.max_values.get(1).unwrap());
             } else {
                 panic!("expecting Statistics::Int32");
             }
@@ -2110,14 +2584,611 @@ mod tests {
         }
 
         // page location
-        assert_eq!(
-            0,
-            offset_index.page_locations.get(0).unwrap().first_row_index
-        );
-        assert_eq!(
-            4,
-            offset_index.page_locations.get(1).unwrap().first_row_index
+        assert_eq!(0, offset_index.page_locations[0].first_row_index);
+        assert_eq!(4, offset_index.page_locations[1].first_row_index);
+    }
+
+    /// Verify min/max value truncation in the column index works as expected
+    #[test]
+    fn test_column_offset_index_metadata_truncating() {
+        // write data
+        // and check the offset index and column index
+        let page_writer = get_test_page_writer();
+        let props = Default::default();
+        let mut writer = get_test_column_writer::<FixedLenByteArrayType>(page_writer, 0, 0, props);
+
+        let mut data = vec![FixedLenByteArray::default(); 3];
+        // This is the expected min value - "aaa..."
+        data[0].set_data(Bytes::from(vec![97_u8; 200]));
+        // This is the expected max value - "ZZZ..."
+        data[1].set_data(Bytes::from(vec![112_u8; 200]));
+        data[2].set_data(Bytes::from(vec![98_u8; 200]));
+
+        writer.write_batch(&data, None, None).unwrap();
+
+        writer.flush_data_pages().unwrap();
+
+        let r = writer.close().unwrap();
+        let column_index = r.column_index.unwrap();
+        let offset_index = r.offset_index.unwrap();
+
+        assert_eq!(3, r.rows_written);
+
+        // column index
+        assert_eq!(1, column_index.null_pages.len());
+        assert_eq!(1, offset_index.page_locations.len());
+        assert_eq!(BoundaryOrder::ASCENDING, column_index.boundary_order);
+        assert!(!column_index.null_pages[0]);
+        assert_eq!(0, column_index.null_counts.as_ref().unwrap()[0]);
+
+        if let Some(stats) = r.metadata.statistics() {
+            assert!(stats.has_min_max_set());
+            assert_eq!(stats.null_count(), 0);
+            assert_eq!(stats.distinct_count(), None);
+            if let Statistics::FixedLenByteArray(stats) = stats {
+                let column_index_min_value = &column_index.min_values[0];
+                let column_index_max_value = &column_index.max_values[0];
+
+                // Column index stats are truncated, while the column chunk's aren't.
+                assert_ne!(stats.min_bytes(), column_index_min_value.as_slice());
+                assert_ne!(stats.max_bytes(), column_index_max_value.as_slice());
+
+                assert_eq!(
+                    column_index_min_value.len(),
+                    DEFAULT_COLUMN_INDEX_TRUNCATE_LENGTH.unwrap()
+                );
+                assert_eq!(column_index_min_value.as_slice(), &[97_u8; 64]);
+                assert_eq!(
+                    column_index_max_value.len(),
+                    DEFAULT_COLUMN_INDEX_TRUNCATE_LENGTH.unwrap()
+                );
+
+                // We expect the last byte to be incremented
+                assert_eq!(
+                    *column_index_max_value.last().unwrap(),
+                    *column_index_max_value.first().unwrap() + 1
+                );
+            } else {
+                panic!("expecting Statistics::FixedLenByteArray");
+            }
+        } else {
+            panic!("metadata missing statistics");
+        }
+    }
+
+    #[test]
+    fn test_column_offset_index_truncating_spec_example() {
+        // write data
+        // and check the offset index and column index
+        let page_writer = get_test_page_writer();
+
+        // Truncate values at 1 byte
+        let builder = WriterProperties::builder().set_column_index_truncate_length(Some(1));
+        let props = Arc::new(builder.build());
+        let mut writer = get_test_column_writer::<FixedLenByteArrayType>(page_writer, 0, 0, props);
+
+        let mut data = vec![FixedLenByteArray::default(); 1];
+        // This is the expected min value
+        data[0].set_data(Bytes::from(String::from("Blart Versenwald III")));
+
+        writer.write_batch(&data, None, None).unwrap();
+
+        writer.flush_data_pages().unwrap();
+
+        let r = writer.close().unwrap();
+        let column_index = r.column_index.unwrap();
+        let offset_index = r.offset_index.unwrap();
+
+        assert_eq!(1, r.rows_written);
+
+        // column index
+        assert_eq!(1, column_index.null_pages.len());
+        assert_eq!(1, offset_index.page_locations.len());
+        assert_eq!(BoundaryOrder::ASCENDING, column_index.boundary_order);
+        assert!(!column_index.null_pages[0]);
+        assert_eq!(0, column_index.null_counts.as_ref().unwrap()[0]);
+
+        if let Some(stats) = r.metadata.statistics() {
+            assert!(stats.has_min_max_set());
+            assert_eq!(stats.null_count(), 0);
+            assert_eq!(stats.distinct_count(), None);
+            if let Statistics::FixedLenByteArray(_stats) = stats {
+                let column_index_min_value = &column_index.min_values[0];
+                let column_index_max_value = &column_index.max_values[0];
+
+                assert_eq!(column_index_min_value.len(), 1);
+                assert_eq!(column_index_max_value.len(), 1);
+
+                assert_eq!("B".as_bytes(), column_index_min_value.as_slice());
+                assert_eq!("C".as_bytes(), column_index_max_value.as_slice());
+
+                assert_ne!(column_index_min_value, stats.min_bytes());
+                assert_ne!(column_index_max_value, stats.max_bytes());
+            } else {
+                panic!("expecting Statistics::FixedLenByteArray");
+            }
+        } else {
+            panic!("metadata missing statistics");
+        }
+    }
+
+    #[test]
+    fn test_float16_min_max_no_truncation() {
+        // Even if we set truncation to occur at 1 byte, we should not truncate for Float16
+        let builder = WriterProperties::builder().set_column_index_truncate_length(Some(1));
+        let props = Arc::new(builder.build());
+        let page_writer = get_test_page_writer();
+        let mut writer = get_test_float16_column_writer(page_writer, props);
+
+        let expected_value = f16::PI.to_le_bytes().to_vec();
+        let data = vec![ByteArray::from(expected_value.clone()).into()];
+        writer.write_batch(&data, None, None).unwrap();
+        writer.flush_data_pages().unwrap();
+
+        let r = writer.close().unwrap();
+
+        // stats should still be written
+        // ensure bytes weren't truncated for column index
+        let column_index = r.column_index.unwrap();
+        let column_index_min_bytes = column_index.min_values[0].as_slice();
+        let column_index_max_bytes = column_index.max_values[0].as_slice();
+        assert_eq!(expected_value, column_index_min_bytes);
+        assert_eq!(expected_value, column_index_max_bytes);
+
+        // ensure bytes weren't truncated for statistics
+        let stats = r.metadata.statistics().unwrap();
+        assert!(stats.has_min_max_set());
+        if let Statistics::FixedLenByteArray(stats) = stats {
+            let stats_min_bytes = stats.min_bytes();
+            let stats_max_bytes = stats.max_bytes();
+            assert_eq!(expected_value, stats_min_bytes);
+            assert_eq!(expected_value, stats_max_bytes);
+        } else {
+            panic!("expecting Statistics::FixedLenByteArray");
+        }
+    }
+
+    #[test]
+    fn test_decimal_min_max_no_truncation() {
+        // Even if we set truncation to occur at 1 byte, we should not truncate for Decimal
+        let builder = WriterProperties::builder().set_column_index_truncate_length(Some(1));
+        let props = Arc::new(builder.build());
+        let page_writer = get_test_page_writer();
+        let mut writer =
+            get_test_decimals_column_writer::<FixedLenByteArrayType>(page_writer, 0, 0, props);
+
+        let expected_value = vec![
+            255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 255u8, 179u8, 172u8, 19u8, 35u8,
+            231u8, 90u8, 0u8, 0u8,
+        ];
+        let data = vec![ByteArray::from(expected_value.clone()).into()];
+        writer.write_batch(&data, None, None).unwrap();
+        writer.flush_data_pages().unwrap();
+
+        let r = writer.close().unwrap();
+
+        // stats should still be written
+        // ensure bytes weren't truncated for column index
+        let column_index = r.column_index.unwrap();
+        let column_index_min_bytes = column_index.min_values[0].as_slice();
+        let column_index_max_bytes = column_index.max_values[0].as_slice();
+        assert_eq!(expected_value, column_index_min_bytes);
+        assert_eq!(expected_value, column_index_max_bytes);
+
+        // ensure bytes weren't truncated for statistics
+        let stats = r.metadata.statistics().unwrap();
+        assert!(stats.has_min_max_set());
+        if let Statistics::FixedLenByteArray(stats) = stats {
+            let stats_min_bytes = stats.min_bytes();
+            let stats_max_bytes = stats.max_bytes();
+            assert_eq!(expected_value, stats_min_bytes);
+            assert_eq!(expected_value, stats_max_bytes);
+        } else {
+            panic!("expecting Statistics::FixedLenByteArray");
+        }
+    }
+
+    #[test]
+    fn test_statistics_truncating_byte_array() {
+        let page_writer = get_test_page_writer();
+
+        const TEST_TRUNCATE_LENGTH: usize = 1;
+
+        // Truncate values at 1 byte
+        let builder =
+            WriterProperties::builder().set_statistics_truncate_length(Some(TEST_TRUNCATE_LENGTH));
+        let props = Arc::new(builder.build());
+        let mut writer = get_test_column_writer::<ByteArrayType>(page_writer, 0, 0, props);
+
+        let mut data = vec![ByteArray::default(); 1];
+        // This is the expected min value
+        data[0].set_data(Bytes::from(String::from("Blart Versenwald III")));
+
+        writer.write_batch(&data, None, None).unwrap();
+
+        writer.flush_data_pages().unwrap();
+
+        let r = writer.close().unwrap();
+
+        assert_eq!(1, r.rows_written);
+
+        let stats = r.metadata.statistics().expect("statistics");
+        assert!(stats.has_min_max_set());
+        assert_eq!(stats.null_count(), 0);
+        assert_eq!(stats.distinct_count(), None);
+        if let Statistics::ByteArray(_stats) = stats {
+            let min_value = _stats.min();
+            let max_value = _stats.max();
+
+            assert!(!_stats.min_is_exact());
+            assert!(!_stats.max_is_exact());
+
+            assert_eq!(min_value.len(), TEST_TRUNCATE_LENGTH);
+            assert_eq!(max_value.len(), TEST_TRUNCATE_LENGTH);
+
+            assert_eq!("B".as_bytes(), min_value.as_bytes());
+            assert_eq!("C".as_bytes(), max_value.as_bytes());
+        } else {
+            panic!("expecting Statistics::ByteArray");
+        }
+    }
+
+    #[test]
+    fn test_statistics_truncating_fixed_len_byte_array() {
+        let page_writer = get_test_page_writer();
+
+        const TEST_TRUNCATE_LENGTH: usize = 1;
+
+        // Truncate values at 1 byte
+        let builder =
+            WriterProperties::builder().set_statistics_truncate_length(Some(TEST_TRUNCATE_LENGTH));
+        let props = Arc::new(builder.build());
+        let mut writer = get_test_column_writer::<FixedLenByteArrayType>(page_writer, 0, 0, props);
+
+        let mut data = vec![FixedLenByteArray::default(); 1];
+
+        const PSEUDO_DECIMAL_VALUE: i128 = 6541894651216648486512564456564654;
+        const PSEUDO_DECIMAL_BYTES: [u8; 16] = PSEUDO_DECIMAL_VALUE.to_be_bytes();
+
+        const EXPECTED_MIN: [u8; TEST_TRUNCATE_LENGTH] = [PSEUDO_DECIMAL_BYTES[0]]; // parquet specifies big-endian order for decimals
+        const EXPECTED_MAX: [u8; TEST_TRUNCATE_LENGTH] =
+            [PSEUDO_DECIMAL_BYTES[0].overflowing_add(1).0];
+
+        // This is the expected min value
+        data[0].set_data(Bytes::from(PSEUDO_DECIMAL_BYTES.as_slice()));
+
+        writer.write_batch(&data, None, None).unwrap();
+
+        writer.flush_data_pages().unwrap();
+
+        let r = writer.close().unwrap();
+
+        assert_eq!(1, r.rows_written);
+
+        let stats = r.metadata.statistics().expect("statistics");
+        assert!(stats.has_min_max_set());
+        assert_eq!(stats.null_count(), 0);
+        assert_eq!(stats.distinct_count(), None);
+        if let Statistics::FixedLenByteArray(_stats) = stats {
+            let min_value = _stats.min();
+            let max_value = _stats.max();
+
+            assert!(!_stats.min_is_exact());
+            assert!(!_stats.max_is_exact());
+
+            assert_eq!(min_value.len(), TEST_TRUNCATE_LENGTH);
+            assert_eq!(max_value.len(), TEST_TRUNCATE_LENGTH);
+
+            assert_eq!(EXPECTED_MIN.as_slice(), min_value.as_bytes());
+            assert_eq!(EXPECTED_MAX.as_slice(), max_value.as_bytes());
+
+            let reconstructed_min = i128::from_be_bytes([
+                min_value.as_bytes()[0],
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+            ]);
+
+            let reconstructed_max = i128::from_be_bytes([
+                max_value.as_bytes()[0],
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+                0,
+            ]);
+
+            // check that the inner value is correctly bounded by the min/max
+            println!("min: {reconstructed_min} {PSEUDO_DECIMAL_VALUE}");
+            assert!(reconstructed_min <= PSEUDO_DECIMAL_VALUE);
+            println!("max {reconstructed_max} {PSEUDO_DECIMAL_VALUE}");
+            assert!(reconstructed_max >= PSEUDO_DECIMAL_VALUE);
+        } else {
+            panic!("expecting Statistics::FixedLenByteArray");
+        }
+    }
+
+    #[test]
+    fn test_send() {
+        fn test<T: Send>() {}
+        test::<ColumnWriterImpl<Int32Type>>();
+    }
+
+    #[test]
+    fn test_increment() {
+        let v = increment(vec![0, 0, 0]).unwrap();
+        assert_eq!(&v, &[0, 0, 1]);
+
+        // Handle overflow
+        let v = increment(vec![0, 255, 255]).unwrap();
+        assert_eq!(&v, &[1, 0, 0]);
+
+        // Return `None` if all bytes are u8::MAX
+        let v = increment(vec![255, 255, 255]);
+        assert!(v.is_none());
+    }
+
+    #[test]
+    fn test_increment_utf8() {
+        // Basic ASCII case
+        let v = increment_utf8("hello".as_bytes().to_vec()).unwrap();
+        assert_eq!(&v, "hellp".as_bytes());
+
+        // Also show that BinaryArray level comparison works here
+        let mut greater = ByteArray::new();
+        greater.set_data(Bytes::from(v));
+        let mut original = ByteArray::new();
+        original.set_data(Bytes::from("hello".as_bytes().to_vec()));
+        assert!(greater > original);
+
+        // UTF8 string
+        let s = "❤️🧡💛💚💙💜";
+        let v = increment_utf8(s.as_bytes().to_vec()).unwrap();
+
+        if let Ok(new) = String::from_utf8(v) {
+            assert_ne!(&new, s);
+            assert_eq!(new, "❤️🧡💛💚💙💝");
+            assert!(new.as_bytes().last().unwrap() > s.as_bytes().last().unwrap());
+        } else {
+            panic!("Expected incremented UTF8 string to also be valid.")
+        }
+
+        // Max UTF8 character - should be a No-Op
+        let s = char::MAX.to_string();
+        assert_eq!(s.len(), 4);
+        let v = increment_utf8(s.as_bytes().to_vec());
+        assert!(v.is_none());
+
+        // Handle multi-byte UTF8 characters
+        let s = "a\u{10ffff}";
+        let v = increment_utf8(s.as_bytes().to_vec());
+        assert_eq!(&v.unwrap(), "b\u{10ffff}".as_bytes());
+    }
+
+    #[test]
+    fn test_truncate_utf8() {
+        // No-op
+        let data = "❤️🧡💛💚💙💜";
+        let r = truncate_utf8(data, data.as_bytes().len()).unwrap();
+        assert_eq!(r.len(), data.as_bytes().len());
+        assert_eq!(&r, data.as_bytes());
+        println!("len is {}", data.len());
+
+        // We slice it away from the UTF8 boundary
+        let r = truncate_utf8(data, 13).unwrap();
+        assert_eq!(r.len(), 10);
+        assert_eq!(&r, "❤️🧡".as_bytes());
+
+        // One multi-byte code point, and a length shorter than it, so we can't slice it
+        let r = truncate_utf8("\u{0836}", 1);
+        assert!(r.is_none());
+    }
+
+    #[test]
+    fn test_increment_max_binary_chars() {
+        let r = increment(vec![0xFF, 0xFE, 0xFD, 0xFF, 0xFF]);
+        assert_eq!(&r.unwrap(), &[0xFF, 0xFE, 0xFE, 0x00, 0x00]);
+
+        let incremented = increment(vec![0xFF, 0xFF, 0xFF]);
+        assert!(incremented.is_none())
+    }
+
+    #[test]
+    fn test_boundary_order() -> Result<()> {
+        let descr = Arc::new(get_test_column_descr::<Int32Type>(1, 0));
+        // min max both ascending
+        let column_close_result = write_multiple_pages::<Int32Type>(
+            &descr,
+            &[
+                &[Some(-10), Some(10)],
+                &[Some(-5), Some(11)],
+                &[None],
+                &[Some(-5), Some(11)],
+            ],
+        )?;
+        let boundary_order = column_close_result.column_index.unwrap().boundary_order;
+        assert_eq!(boundary_order, BoundaryOrder::ASCENDING);
+
+        // min max both descending
+        let column_close_result = write_multiple_pages::<Int32Type>(
+            &descr,
+            &[
+                &[Some(10), Some(11)],
+                &[Some(5), Some(11)],
+                &[None],
+                &[Some(-5), Some(0)],
+            ],
+        )?;
+        let boundary_order = column_close_result.column_index.unwrap().boundary_order;
+        assert_eq!(boundary_order, BoundaryOrder::DESCENDING);
+
+        // min max both equal
+        let column_close_result = write_multiple_pages::<Int32Type>(
+            &descr,
+            &[&[Some(10), Some(11)], &[None], &[Some(10), Some(11)]],
+        )?;
+        let boundary_order = column_close_result.column_index.unwrap().boundary_order;
+        assert_eq!(boundary_order, BoundaryOrder::ASCENDING);
+
+        // only nulls
+        let column_close_result =
+            write_multiple_pages::<Int32Type>(&descr, &[&[None], &[None], &[None]])?;
+        let boundary_order = column_close_result.column_index.unwrap().boundary_order;
+        assert_eq!(boundary_order, BoundaryOrder::ASCENDING);
+
+        // one page
+        let column_close_result =
+            write_multiple_pages::<Int32Type>(&descr, &[&[Some(-10), Some(10)]])?;
+        let boundary_order = column_close_result.column_index.unwrap().boundary_order;
+        assert_eq!(boundary_order, BoundaryOrder::ASCENDING);
+
+        // one non-null page
+        let column_close_result =
+            write_multiple_pages::<Int32Type>(&descr, &[&[Some(-10), Some(10)], &[None]])?;
+        let boundary_order = column_close_result.column_index.unwrap().boundary_order;
+        assert_eq!(boundary_order, BoundaryOrder::ASCENDING);
+
+        // min max both unordered
+        let column_close_result = write_multiple_pages::<Int32Type>(
+            &descr,
+            &[
+                &[Some(10), Some(11)],
+                &[Some(11), Some(16)],
+                &[None],
+                &[Some(-5), Some(0)],
+            ],
+        )?;
+        let boundary_order = column_close_result.column_index.unwrap().boundary_order;
+        assert_eq!(boundary_order, BoundaryOrder::UNORDERED);
+
+        // min max both ordered in different orders
+        let column_close_result = write_multiple_pages::<Int32Type>(
+            &descr,
+            &[
+                &[Some(1), Some(9)],
+                &[Some(2), Some(8)],
+                &[None],
+                &[Some(3), Some(7)],
+            ],
+        )?;
+        let boundary_order = column_close_result.column_index.unwrap().boundary_order;
+        assert_eq!(boundary_order, BoundaryOrder::UNORDERED);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_boundary_order_logical_type() -> Result<()> {
+        // ensure that logical types account for different sort order than underlying
+        // physical type representation
+        let f16_descr = Arc::new(get_test_float16_column_descr(1, 0));
+        let fba_descr = {
+            let tpe = SchemaType::primitive_type_builder(
+                "col",
+                FixedLenByteArrayType::get_physical_type(),
+            )
+            .with_length(2)
+            .build()?;
+            Arc::new(ColumnDescriptor::new(
+                Arc::new(tpe),
+                1,
+                0,
+                ColumnPath::from("col"),
+            ))
+        };
+
+        let values: &[&[Option<FixedLenByteArray>]] = &[
+            &[Some(FixedLenByteArray::from(ByteArray::from(f16::ONE)))],
+            &[Some(FixedLenByteArray::from(ByteArray::from(f16::ZERO)))],
+            &[Some(FixedLenByteArray::from(ByteArray::from(
+                f16::NEG_ZERO,
+            )))],
+            &[Some(FixedLenByteArray::from(ByteArray::from(f16::NEG_ONE)))],
+        ];
+
+        // f16 descending
+        let column_close_result =
+            write_multiple_pages::<FixedLenByteArrayType>(&f16_descr, values)?;
+        let boundary_order = column_close_result.column_index.unwrap().boundary_order;
+        assert_eq!(boundary_order, BoundaryOrder::DESCENDING);
+
+        // same bytes, but fba unordered
+        let column_close_result =
+            write_multiple_pages::<FixedLenByteArrayType>(&fba_descr, values)?;
+        let boundary_order = column_close_result.column_index.unwrap().boundary_order;
+        assert_eq!(boundary_order, BoundaryOrder::UNORDERED);
+
+        Ok(())
+    }
+
+    #[test]
+    fn test_interval_stats_should_not_have_min_max() {
+        let input = [
+            vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
+            vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1],
+            vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2],
+        ]
+        .into_iter()
+        .map(|s| ByteArray::from(s).into())
+        .collect::<Vec<_>>();
+
+        let page_writer = get_test_page_writer();
+        let mut writer = get_test_interval_column_writer(page_writer);
+        writer.write_batch(&input, None, None).unwrap();
+
+        let metadata = writer.close().unwrap().metadata;
+        let stats = if let Some(Statistics::FixedLenByteArray(stats)) = metadata.statistics() {
+            stats.clone()
+        } else {
+            panic!("metadata missing statistics");
+        };
+        assert!(!stats.has_min_max_set());
+    }
+
+    fn write_multiple_pages<T: DataType>(
+        column_descr: &Arc<ColumnDescriptor>,
+        pages: &[&[Option<T::T>]],
+    ) -> Result<ColumnCloseResult> {
+        let column_writer = get_column_writer(
+            column_descr.clone(),
+            Default::default(),
+            get_test_page_writer(),
         );
+        let mut writer = get_typed_column_writer::<T>(column_writer);
+
+        for &page in pages {
+            let values = page.iter().filter_map(Clone::clone).collect::<Vec<_>>();
+            let def_levels = page
+                .iter()
+                .map(|maybe_value| if maybe_value.is_some() { 1 } else { 0 })
+                .collect::<Vec<_>>();
+            writer.write_batch(&values, Some(&def_levels), None)?;
+            writer.flush_data_pages()?;
+        }
+
+        writer.close()
     }
 
     /// Performs write-read roundtrip with randomly generated values and levels.
@@ -2152,6 +3223,7 @@ mod tests {
         let mut buf: Vec<i16> = Vec::new();
         let rep_levels = if max_rep_level > 0 {
             random_numbers_range(max_size, 0, max_rep_level + 1, &mut buf);
+            buf[0] = 0; // Must start on record boundary
             Some(&buf[..])
         } else {
             None
@@ -2171,8 +3243,8 @@ mod tests {
         rep_levels: Option<&[i16]>,
     ) {
         let mut file = tempfile::tempfile().unwrap();
-        let mut writer = TrackedWrite::new(&mut file);
-        let page_writer = Box::new(SerializedPageWriter::new(&mut writer));
+        let mut write = TrackedWrite::new(&mut file);
+        let page_writer = Box::new(SerializedPageWriter::new(&mut write));
 
         let max_def_level = match def_levels {
             Some(buf) => *buf.iter().max().unwrap_or(&0i16),
@@ -2192,42 +3264,42 @@ mod tests {
             max_batch_size = max_batch_size.max(levels.len());
         }
 
-        let mut writer = get_test_column_writer::<T>(
-            page_writer,
-            max_def_level,
-            max_rep_level,
-            Arc::new(props),
-        );
+        let mut writer =
+            get_test_column_writer::<T>(page_writer, max_def_level, max_rep_level, Arc::new(props));
 
         let values_written = writer.write_batch(values, def_levels, rep_levels).unwrap();
         assert_eq!(values_written, values.len());
-        let (bytes_written, rows_written, column_metadata, _, _) =
-            writer.close().unwrap();
+        let result = writer.close().unwrap();
 
-        let source = FileSource::new(&file, 0, bytes_written as usize);
+        drop(write);
+
+        let props = ReaderProperties::builder()
+            .set_backward_compatible_lz4(false)
+            .build();
         let page_reader = Box::new(
-            SerializedPageReader::new(
-                source,
-                column_metadata.num_values(),
-                column_metadata.compression(),
-                T::get_physical_type(),
+            SerializedPageReader::new_with_properties(
+                Arc::new(file),
+                &result.metadata,
+                result.rows_written as usize,
+                None,
+                Arc::new(props),
             )
             .unwrap(),
         );
-        let reader =
-            get_test_column_reader::<T>(page_reader, max_def_level, max_rep_level);
-
-        let mut actual_values = vec![T::T::default(); max_batch_size];
-        let mut actual_def_levels = def_levels.map(|_| vec![0i16; max_batch_size]);
-        let mut actual_rep_levels = rep_levels.map(|_| vec![0i16; max_batch_size]);
-
-        let (values_read, levels_read) = read_fully(
-            reader,
-            max_batch_size,
-            actual_def_levels.as_mut(),
-            actual_rep_levels.as_mut(),
-            actual_values.as_mut_slice(),
-        );
+        let mut reader = get_test_column_reader::<T>(page_reader, max_def_level, max_rep_level);
+
+        let mut actual_values = Vec::with_capacity(max_batch_size);
+        let mut actual_def_levels = def_levels.map(|_| Vec::with_capacity(max_batch_size));
+        let mut actual_rep_levels = rep_levels.map(|_| Vec::with_capacity(max_batch_size));
+
+        let (_, values_read, levels_read) = reader
+            .read_records(
+                max_batch_size,
+                actual_def_levels.as_mut(),
+                actual_rep_levels.as_mut(),
+                &mut actual_values,
+            )
+            .unwrap();
 
         // Assert values, definition and repetition levels.
 
@@ -2250,11 +3322,11 @@ mod tests {
                     actual_rows_written += 1;
                 }
             }
-            assert_eq!(actual_rows_written, rows_written);
+            assert_eq!(actual_rows_written, result.rows_written);
         } else if actual_def_levels.is_some() {
-            assert_eq!(levels_read as u64, rows_written);
+            assert_eq!(levels_read as u64, result.rows_written);
         } else {
-            assert_eq!(values_read as u64, rows_written);
+            assert_eq!(values_read as u64, result.rows_written);
         }
     }
 
@@ -2268,8 +3340,7 @@ mod tests {
         let props = Arc::new(props);
         let mut writer = get_test_column_writer::<T>(page_writer, 0, 0, props);
         writer.write_batch(values, None, None).unwrap();
-        let (_, _, metadata, _, _) = writer.close().unwrap();
-        metadata
+        writer.close().unwrap().metadata
     }
 
     // Function to use in tests for EncodingWriteSupport. This checks that dictionary
@@ -2291,22 +3362,6 @@ mod tests {
         assert_eq!(meta.encodings(), &encodings);
     }
 
-    /// Reads one batch of data, considering that batch is large enough to capture all of
-    /// the values and levels.
-    fn read_fully<T: DataType>(
-        mut reader: ColumnReaderImpl<T>,
-        batch_size: usize,
-        mut def_levels: Option<&mut Vec<i16>>,
-        mut rep_levels: Option<&mut Vec<i16>>,
-        values: &mut [T::T],
-    ) -> (usize, usize) {
-        let actual_def_levels = def_levels.as_mut().map(|vec| &mut vec[..]);
-        let actual_rep_levels = rep_levels.as_mut().map(|vec| &mut vec[..]);
-        reader
-            .read_batch(batch_size, actual_def_levels, actual_rep_levels, values)
-            .unwrap()
-    }
-
     /// Returns column writer.
     fn get_test_column_writer<'a, T: DataType>(
         page_writer: Box<dyn PageWriter + 'a>,
@@ -2376,11 +3431,11 @@ mod tests {
     /// Write data into parquet using [`get_test_page_writer`] and [`get_test_column_writer`] and returns generated statistics.
     fn statistics_roundtrip<T: DataType>(values: &[<T as DataType>::T]) -> Statistics {
         let page_writer = get_test_page_writer();
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = get_test_column_writer::<T>(page_writer, 0, 0, props);
         writer.write_batch(values, None, None).unwrap();
 
-        let (_bytes_written, _rows_written, metadata, _, _) = writer.close().unwrap();
+        let metadata = writer.close().unwrap().metadata;
         if let Some(stats) = metadata.statistics() {
             stats.clone()
         } else {
@@ -2422,6 +3477,60 @@ mod tests {
         ColumnDescriptor::new(Arc::new(tpe), max_def_level, max_rep_level, path)
     }
 
+    fn float16_statistics_roundtrip(
+        values: &[FixedLenByteArray],
+    ) -> ValueStatistics<FixedLenByteArray> {
+        let page_writer = get_test_page_writer();
+        let mut writer = get_test_float16_column_writer(page_writer, Default::default());
+        writer.write_batch(values, None, None).unwrap();
+
+        let metadata = writer.close().unwrap().metadata;
+        if let Some(Statistics::FixedLenByteArray(stats)) = metadata.statistics() {
+            stats.clone()
+        } else {
+            panic!("metadata missing statistics");
+        }
+    }
+
+    fn get_test_float16_column_writer(
+        page_writer: Box<dyn PageWriter>,
+        props: WriterPropertiesPtr,
+    ) -> ColumnWriterImpl<'static, FixedLenByteArrayType> {
+        let descr = Arc::new(get_test_float16_column_descr(0, 0));
+        let column_writer = get_column_writer(descr, props, page_writer);
+        get_typed_column_writer::<FixedLenByteArrayType>(column_writer)
+    }
+
+    fn get_test_float16_column_descr(max_def_level: i16, max_rep_level: i16) -> ColumnDescriptor {
+        let path = ColumnPath::from("col");
+        let tpe =
+            SchemaType::primitive_type_builder("col", FixedLenByteArrayType::get_physical_type())
+                .with_length(2)
+                .with_logical_type(Some(LogicalType::Float16))
+                .build()
+                .unwrap();
+        ColumnDescriptor::new(Arc::new(tpe), max_def_level, max_rep_level, path)
+    }
+
+    fn get_test_interval_column_writer(
+        page_writer: Box<dyn PageWriter>,
+    ) -> ColumnWriterImpl<'static, FixedLenByteArrayType> {
+        let descr = Arc::new(get_test_interval_column_descr());
+        let column_writer = get_column_writer(descr, Default::default(), page_writer);
+        get_typed_column_writer::<FixedLenByteArrayType>(column_writer)
+    }
+
+    fn get_test_interval_column_descr() -> ColumnDescriptor {
+        let path = ColumnPath::from("col");
+        let tpe =
+            SchemaType::primitive_type_builder("col", FixedLenByteArrayType::get_physical_type())
+                .with_length(12)
+                .with_converted_type(ConvertedType::INTERVAL)
+                .build()
+                .unwrap();
+        ColumnDescriptor::new(Arc::new(tpe), 0, 0, path)
+    }
+
     /// Returns column writer for UINT32 Column provided as ConvertedType only
     fn get_test_unsigned_int_given_as_converted_column_writer<'a, T: DataType>(
         page_writer: Box<dyn PageWriter + 'a>,
diff --git a/parquet/src/compression.rs b/parquet/src/compression.rs
index ee5141cbe140..a9a1afbbf213 100644
--- a/parquet/src/compression.rs
+++ b/parquet/src/compression.rs
@@ -26,9 +26,12 @@
 # Example
 
 ```no_run
-use parquet::{basic::Compression, compression::create_codec};
+use parquet::{basic::Compression, compression::{create_codec, CodecOptionsBuilder}};
 
-let mut codec = match create_codec(Compression::SNAPPY) {
+let codec_options = CodecOptionsBuilder::default()
+    .set_backward_compatible_lz4(false)
+    .build();
+let mut codec = match create_codec(Compression::SNAPPY, &codec_options) {
  Ok(Some(codec)) => codec,
  _ => panic!(),
 };
@@ -38,7 +41,7 @@ let mut compressed = vec![];
 codec.compress(&data[..], &mut compressed).unwrap();
 
 let mut output = vec![];
-codec.decompress(&compressed[..], &mut output).unwrap();
+codec.decompress(&compressed[..], &mut output, None).unwrap();
 
 assert_eq!(output, data);
 ```
@@ -57,26 +60,109 @@ pub trait Codec: Send {
     fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()>;
 
     /// Decompresses data stored in slice `input_buf` and appends output to `output_buf`.
+    ///
+    /// If the uncompress_size is provided it will allocate the exact amount of memory.
+    /// Otherwise, it will estimate the uncompressed size, allocating an amount of memory
+    /// greater or equal to the real uncompress_size.
+    ///
     /// Returns the total number of bytes written.
-    fn decompress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>)
-        -> Result<usize>;
+    fn decompress(
+        &mut self,
+        input_buf: &[u8],
+        output_buf: &mut Vec<u8>,
+        uncompress_size: Option<usize>,
+    ) -> Result<usize>;
+}
+
+/// Struct to hold `Codec` creation options.
+#[derive(Debug, PartialEq, Eq)]
+pub struct CodecOptions {
+    /// Whether or not to fallback to other LZ4 older implementations on error in LZ4_HADOOP.
+    backward_compatible_lz4: bool,
+}
+
+impl Default for CodecOptions {
+    fn default() -> Self {
+        CodecOptionsBuilder::default().build()
+    }
+}
+
+pub struct CodecOptionsBuilder {
+    /// Whether or not to fallback to other LZ4 older implementations on error in LZ4_HADOOP.
+    backward_compatible_lz4: bool,
+}
+
+impl Default for CodecOptionsBuilder {
+    fn default() -> Self {
+        Self {
+            backward_compatible_lz4: true,
+        }
+    }
+}
+
+impl CodecOptionsBuilder {
+    /// Enable/disable backward compatible LZ4.
+    ///
+    /// If backward compatible LZ4 is enable, on LZ4_HADOOP error it will fallback
+    /// to the older versions LZ4 algorithms. That is LZ4_FRAME, for backward compatibility
+    /// with files generated by older versions of this library, and LZ4_RAW, for backward
+    /// compatibility with files generated by older versions of parquet-cpp.
+    ///
+    /// If backward compatible LZ4 is disabled, on LZ4_HADOOP error it will return the error.
+    pub fn set_backward_compatible_lz4(mut self, value: bool) -> CodecOptionsBuilder {
+        self.backward_compatible_lz4 = value;
+        self
+    }
+
+    pub fn build(self) -> CodecOptions {
+        CodecOptions {
+            backward_compatible_lz4: self.backward_compatible_lz4,
+        }
+    }
+}
+
+/// Defines valid compression levels.
+pub(crate) trait CompressionLevel<T: std::fmt::Display + std::cmp::PartialOrd> {
+    const MINIMUM_LEVEL: T;
+    const MAXIMUM_LEVEL: T;
+
+    /// Tests if the provided compression level is valid.
+    fn is_valid_level(level: T) -> Result<()> {
+        let compression_range = Self::MINIMUM_LEVEL..=Self::MAXIMUM_LEVEL;
+        if compression_range.contains(&level) {
+            Ok(())
+        } else {
+            Err(ParquetError::General(format!(
+                "valid compression range {}..={} exceeded.",
+                compression_range.start(),
+                compression_range.end()
+            )))
+        }
+    }
 }
 
 /// Given the compression type `codec`, returns a codec used to compress and decompress
 /// bytes for the compression type.
 /// This returns `None` if the codec type is `UNCOMPRESSED`.
-pub fn create_codec(codec: CodecType) -> Result<Option<Box<dyn Codec>>> {
+pub fn create_codec(
+    codec: CodecType,
+    _options: &CodecOptions,
+) -> Result<Option<Box<dyn Codec>>> {
     match codec {
         #[cfg(any(feature = "brotli", test))]
-        CodecType::BROTLI => Ok(Some(Box::new(BrotliCodec::new()))),
+        CodecType::BROTLI(level) => Ok(Some(Box::new(BrotliCodec::new(level)))),
         #[cfg(any(feature = "flate2", test))]
-        CodecType::GZIP => Ok(Some(Box::new(GZipCodec::new()))),
+        CodecType::GZIP(level) => Ok(Some(Box::new(GZipCodec::new(level)))),
         #[cfg(any(feature = "snap", test))]
         CodecType::SNAPPY => Ok(Some(Box::new(SnappyCodec::new()))),
         #[cfg(any(feature = "lz4", test))]
-        CodecType::LZ4 => Ok(Some(Box::new(LZ4Codec::new()))),
+        CodecType::LZ4 => Ok(Some(Box::new(LZ4HadoopCodec::new(
+            _options.backward_compatible_lz4,
+        )))),
         #[cfg(any(feature = "zstd", test))]
-        CodecType::ZSTD => Ok(Some(Box::new(ZSTDCodec::new()))),
+        CodecType::ZSTD(level) => Ok(Some(Box::new(ZSTDCodec::new(level)))),
+        #[cfg(any(feature = "lz4", test))]
+        CodecType::LZ4_RAW => Ok(Some(Box::new(LZ4RawCodec::new()))),
         CodecType::UNCOMPRESSED => Ok(None),
         _ => Err(nyi_err!("The codec type {} is not supported yet", codec)),
     }
@@ -110,8 +196,12 @@ mod snappy_codec {
             &mut self,
             input_buf: &[u8],
             output_buf: &mut Vec<u8>,
+            uncompress_size: Option<usize>,
         ) -> Result<usize> {
-            let len = decompress_len(input_buf)?;
+            let len = match uncompress_size {
+                Some(size) => size,
+                None => decompress_len(input_buf)?,
+            };
             let offset = output_buf.len();
             output_buf.resize(offset + len, 0);
             self.decoder
@@ -144,13 +234,17 @@ mod gzip_codec {
     use crate::compression::Codec;
     use crate::errors::Result;
 
+    use super::GzipLevel;
+
     /// Codec for GZIP compression algorithm.
-    pub struct GZipCodec {}
+    pub struct GZipCodec {
+        level: GzipLevel,
+    }
 
     impl GZipCodec {
         /// Creates new GZIP compression codec.
-        pub(crate) fn new() -> Self {
-            Self {}
+        pub(crate) fn new(level: GzipLevel) -> Self {
+            Self { level }
         }
     }
 
@@ -159,13 +253,15 @@ mod gzip_codec {
             &mut self,
             input_buf: &[u8],
             output_buf: &mut Vec<u8>,
+            _uncompress_size: Option<usize>,
         ) -> Result<usize> {
-            let mut decoder = read::GzDecoder::new(input_buf);
+            let mut decoder = read::MultiGzDecoder::new(input_buf);
             decoder.read_to_end(output_buf).map_err(|e| e.into())
         }
 
         fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()> {
-            let mut encoder = write::GzEncoder::new(output_buf, Compression::default());
+            let mut encoder =
+                write::GzEncoder::new(output_buf, Compression::new(self.level.0));
             encoder.write_all(input_buf)?;
             encoder.try_finish().map_err(|e| e.into())
         }
@@ -174,6 +270,37 @@ mod gzip_codec {
 #[cfg(any(feature = "flate2", test))]
 pub use gzip_codec::*;
 
+/// Represents a valid gzip compression level.
+#[derive(Debug, Eq, PartialEq, Hash, Clone, Copy)]
+pub struct GzipLevel(u32);
+
+impl Default for GzipLevel {
+    fn default() -> Self {
+        // The default as of miniz_oxide 0.5.1 is 6 for compression level
+        // (miniz_oxide::deflate::CompressionLevel::DefaultLevel)
+        Self(6)
+    }
+}
+
+impl CompressionLevel<u32> for GzipLevel {
+    const MINIMUM_LEVEL: u32 = 0;
+    const MAXIMUM_LEVEL: u32 = 10;
+}
+
+impl GzipLevel {
+    /// Attempts to create a gzip compression level.
+    ///
+    /// Compression levels must be valid (i.e. be acceptable for [`flate2::Compression`]).
+    pub fn try_new(level: u32) -> Result<Self> {
+        Self::is_valid_level(level).map(|_| Self(level))
+    }
+
+    /// Returns the compression level.
+    pub fn compression_level(&self) -> u32 {
+        self.0
+    }
+}
+
 #[cfg(any(feature = "brotli", test))]
 mod brotli_codec {
 
@@ -182,17 +309,20 @@ mod brotli_codec {
     use crate::compression::Codec;
     use crate::errors::Result;
 
+    use super::BrotliLevel;
+
     const BROTLI_DEFAULT_BUFFER_SIZE: usize = 4096;
-    const BROTLI_DEFAULT_COMPRESSION_QUALITY: u32 = 1; // supported levels 0-9
     const BROTLI_DEFAULT_LG_WINDOW_SIZE: u32 = 22; // recommended between 20-22
 
     /// Codec for Brotli compression algorithm.
-    pub struct BrotliCodec {}
+    pub struct BrotliCodec {
+        level: BrotliLevel,
+    }
 
     impl BrotliCodec {
         /// Creates new Brotli compression codec.
-        pub(crate) fn new() -> Self {
-            Self {}
+        pub(crate) fn new(level: BrotliLevel) -> Self {
+            Self { level }
         }
     }
 
@@ -201,8 +331,10 @@ mod brotli_codec {
             &mut self,
             input_buf: &[u8],
             output_buf: &mut Vec<u8>,
+            uncompress_size: Option<usize>,
         ) -> Result<usize> {
-            brotli::Decompressor::new(input_buf, BROTLI_DEFAULT_BUFFER_SIZE)
+            let buffer_size = uncompress_size.unwrap_or(BROTLI_DEFAULT_BUFFER_SIZE);
+            brotli::Decompressor::new(input_buf, buffer_size)
                 .read_to_end(output_buf)
                 .map_err(|e| e.into())
         }
@@ -211,7 +343,7 @@ mod brotli_codec {
             let mut encoder = brotli::CompressorWriter::new(
                 output_buf,
                 BROTLI_DEFAULT_BUFFER_SIZE,
-                BROTLI_DEFAULT_COMPRESSION_QUALITY,
+                self.level.0,
                 BROTLI_DEFAULT_LG_WINDOW_SIZE,
             );
             encoder.write_all(input_buf)?;
@@ -222,12 +354,41 @@ mod brotli_codec {
 #[cfg(any(feature = "brotli", test))]
 pub use brotli_codec::*;
 
+/// Represents a valid brotli compression level.
+#[derive(Debug, Eq, PartialEq, Hash, Clone, Copy)]
+pub struct BrotliLevel(u32);
+
+impl Default for BrotliLevel {
+    fn default() -> Self {
+        Self(1)
+    }
+}
+
+impl CompressionLevel<u32> for BrotliLevel {
+    const MINIMUM_LEVEL: u32 = 0;
+    const MAXIMUM_LEVEL: u32 = 11;
+}
+
+impl BrotliLevel {
+    /// Attempts to create a brotli compression level.
+    ///
+    /// Compression levels must be valid.
+    pub fn try_new(level: u32) -> Result<Self> {
+        Self::is_valid_level(level).map(|_| Self(level))
+    }
+
+    /// Returns the compression level.
+    pub fn compression_level(&self) -> u32 {
+        self.0
+    }
+}
+
 #[cfg(any(feature = "lz4", test))]
 mod lz4_codec {
     use std::io::{Read, Write};
 
     use crate::compression::Codec;
-    use crate::errors::Result;
+    use crate::errors::{ParquetError, Result};
 
     const LZ4_BUFFER_SIZE: usize = 4096;
 
@@ -246,8 +407,9 @@ mod lz4_codec {
             &mut self,
             input_buf: &[u8],
             output_buf: &mut Vec<u8>,
+            _uncompress_size: Option<usize>,
         ) -> Result<usize> {
-            let mut decoder = lz4::Decoder::new(input_buf)?;
+            let mut decoder = lz4_flex::frame::FrameDecoder::new(input_buf);
             let mut buffer: [u8; LZ4_BUFFER_SIZE] = [0; LZ4_BUFFER_SIZE];
             let mut total_len = 0;
             loop {
@@ -262,7 +424,7 @@ mod lz4_codec {
         }
 
         fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()> {
-            let mut encoder = lz4::EncoderBuilder::new().build(output_buf)?;
+            let mut encoder = lz4_flex::frame::FrameEncoder::new(output_buf);
             let mut from = 0;
             loop {
                 let to = std::cmp::min(from + LZ4_BUFFER_SIZE, input_buf.len());
@@ -272,7 +434,10 @@ mod lz4_codec {
                     break;
                 }
             }
-            encoder.finish().1.map_err(|e| e.into())
+            match encoder.finish() {
+                Ok(_) => Ok(()),
+                Err(e) => Err(ParquetError::External(Box::new(e))),
+            }
         }
     }
 }
@@ -283,27 +448,27 @@ pub use lz4_codec::*;
 mod zstd_codec {
     use std::io::{self, Write};
 
-    use crate::compression::Codec;
+    use crate::compression::{Codec, ZstdLevel};
     use crate::errors::Result;
 
     /// Codec for Zstandard compression algorithm.
-    pub struct ZSTDCodec {}
+    pub struct ZSTDCodec {
+        level: ZstdLevel,
+    }
 
     impl ZSTDCodec {
         /// Creates new Zstandard compression codec.
-        pub(crate) fn new() -> Self {
-            Self {}
+        pub(crate) fn new(level: ZstdLevel) -> Self {
+            Self { level }
         }
     }
 
-    /// Compression level (1-21) for ZSTD. Choose 1 here for better compression speed.
-    const ZSTD_COMPRESSION_LEVEL: i32 = 1;
-
     impl Codec for ZSTDCodec {
         fn decompress(
             &mut self,
             input_buf: &[u8],
             output_buf: &mut Vec<u8>,
+            _uncompress_size: Option<usize>,
         ) -> Result<usize> {
             let mut decoder = zstd::Decoder::new(input_buf)?;
             match io::copy(&mut decoder, output_buf) {
@@ -313,7 +478,7 @@ mod zstd_codec {
         }
 
         fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()> {
-            let mut encoder = zstd::Encoder::new(output_buf, ZSTD_COMPRESSION_LEVEL)?;
+            let mut encoder = zstd::Encoder::new(output_buf, self.level.0)?;
             encoder.write_all(input_buf)?;
             match encoder.finish() {
                 Ok(_) => Ok(()),
@@ -325,15 +490,297 @@ mod zstd_codec {
 #[cfg(any(feature = "zstd", test))]
 pub use zstd_codec::*;
 
+/// Represents a valid zstd compression level.
+#[derive(Debug, Eq, PartialEq, Hash, Clone, Copy)]
+pub struct ZstdLevel(i32);
+
+impl CompressionLevel<i32> for ZstdLevel {
+    // zstd binds to C, and hence zstd::compression_level_range() is not const as this calls the
+    // underlying C library.
+    const MINIMUM_LEVEL: i32 = 1;
+    const MAXIMUM_LEVEL: i32 = 22;
+}
+
+impl ZstdLevel {
+    /// Attempts to create a zstd compression level from a given compression level.
+    ///
+    /// Compression levels must be valid (i.e. be acceptable for [`zstd::compression_level_range`]).
+    pub fn try_new(level: i32) -> Result<Self> {
+        Self::is_valid_level(level).map(|_| Self(level))
+    }
+
+    /// Returns the compression level.
+    pub fn compression_level(&self) -> i32 {
+        self.0
+    }
+}
+
+impl Default for ZstdLevel {
+    fn default() -> Self {
+        Self(1)
+    }
+}
+
+#[cfg(any(feature = "lz4", test))]
+mod lz4_raw_codec {
+    use crate::compression::Codec;
+    use crate::errors::ParquetError;
+    use crate::errors::Result;
+
+    /// Codec for LZ4 Raw compression algorithm.
+    pub struct LZ4RawCodec {}
+
+    impl LZ4RawCodec {
+        /// Creates new LZ4 Raw compression codec.
+        pub(crate) fn new() -> Self {
+            Self {}
+        }
+    }
+
+    impl Codec for LZ4RawCodec {
+        fn decompress(
+            &mut self,
+            input_buf: &[u8],
+            output_buf: &mut Vec<u8>,
+            uncompress_size: Option<usize>,
+        ) -> Result<usize> {
+            let offset = output_buf.len();
+            let required_len = match uncompress_size {
+                Some(uncompress_size) => uncompress_size,
+                None => {
+                    return Err(ParquetError::General(
+                        "LZ4RawCodec unsupported without uncompress_size".into(),
+                    ))
+                }
+            };
+            output_buf.resize(offset + required_len, 0);
+            match lz4_flex::block::decompress_into(input_buf, &mut output_buf[offset..]) {
+                Ok(n) => {
+                    if n != required_len {
+                        return Err(ParquetError::General(
+                            "LZ4RawCodec uncompress_size is not the expected one".into(),
+                        ));
+                    }
+                    Ok(n)
+                }
+                Err(e) => Err(ParquetError::External(Box::new(e))),
+            }
+        }
+
+        fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()> {
+            let offset = output_buf.len();
+            let required_len = lz4_flex::block::get_maximum_output_size(input_buf.len());
+            output_buf.resize(offset + required_len, 0);
+            match lz4_flex::block::compress_into(input_buf, &mut output_buf[offset..]) {
+                Ok(n) => {
+                    output_buf.truncate(offset + n);
+                    Ok(())
+                }
+                Err(e) => Err(ParquetError::External(Box::new(e))),
+            }
+        }
+    }
+}
+#[cfg(any(feature = "lz4", test))]
+pub use lz4_raw_codec::*;
+
+#[cfg(any(feature = "lz4", test))]
+mod lz4_hadoop_codec {
+    use crate::compression::lz4_codec::LZ4Codec;
+    use crate::compression::lz4_raw_codec::LZ4RawCodec;
+    use crate::compression::Codec;
+    use crate::errors::{ParquetError, Result};
+    use std::io;
+
+    /// Size of u32 type.
+    const SIZE_U32: usize = std::mem::size_of::<u32>();
+
+    /// Length of the LZ4_HADOOP prefix.
+    const PREFIX_LEN: usize = SIZE_U32 * 2;
+
+    /// Codec for LZ4 Hadoop compression algorithm.
+    pub struct LZ4HadoopCodec {
+        /// Whether or not to fallback to other LZ4 implementations on error.
+        /// Fallback is done to be backward compatible with older versions of this
+        /// library and older versions parquet-cpp.
+        backward_compatible_lz4: bool,
+    }
+
+    impl LZ4HadoopCodec {
+        /// Creates new LZ4 Hadoop compression codec.
+        pub(crate) fn new(backward_compatible_lz4: bool) -> Self {
+            Self {
+                backward_compatible_lz4,
+            }
+        }
+    }
+
+    /// Try to decompress the buffer as if it was compressed with the Hadoop Lz4Codec.
+    /// Adapted from pola-rs [compression.rs:try_decompress_hadoop](https://pola-rs.github.io/polars/src/parquet2/compression.rs.html#225)
+    /// Translated from the apache arrow c++ function [TryDecompressHadoop](https://github.com/apache/arrow/blob/bf18e6e4b5bb6180706b1ba0d597a65a4ce5ca48/cpp/src/arrow/util/compression_lz4.cc#L474).
+    /// Returns error if decompression failed.
+    fn try_decompress_hadoop(
+        input_buf: &[u8],
+        output_buf: &mut [u8],
+    ) -> io::Result<usize> {
+        // Parquet files written with the Hadoop Lz4Codec use their own framing.
+        // The input buffer can contain an arbitrary number of "frames", each
+        // with the following structure:
+        // - bytes 0..3: big-endian uint32_t representing the frame decompressed size
+        // - bytes 4..7: big-endian uint32_t representing the frame compressed size
+        // - bytes 8...: frame compressed data
+        //
+        // The Hadoop Lz4Codec source code can be found here:
+        // https://github.com/apache/hadoop/blob/trunk/hadoop-mapreduce-project/hadoop-mapreduce-client/hadoop-mapreduce-client-nativetask/src/main/native/src/codec/Lz4Codec.cc
+        let mut input_len = input_buf.len();
+        let mut input = input_buf;
+        let mut read_bytes = 0;
+        let mut output_len = output_buf.len();
+        let mut output: &mut [u8] = output_buf;
+        while input_len >= PREFIX_LEN {
+            let mut bytes = [0; SIZE_U32];
+            bytes.copy_from_slice(&input[0..4]);
+            let expected_decompressed_size = u32::from_be_bytes(bytes);
+            let mut bytes = [0; SIZE_U32];
+            bytes.copy_from_slice(&input[4..8]);
+            let expected_compressed_size = u32::from_be_bytes(bytes);
+            input = &input[PREFIX_LEN..];
+            input_len -= PREFIX_LEN;
+
+            if input_len < expected_compressed_size as usize {
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    "Not enough bytes for Hadoop frame",
+                ));
+            }
+
+            if output_len < expected_decompressed_size as usize {
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    "Not enough bytes to hold advertised output",
+                ));
+            }
+            let decompressed_size = lz4_flex::decompress_into(
+                &input[..expected_compressed_size as usize],
+                output,
+            )
+            .map_err(|e| ParquetError::External(Box::new(e)))?;
+            if decompressed_size != expected_decompressed_size as usize {
+                return Err(io::Error::new(
+                    io::ErrorKind::Other,
+                    "Unexpected decompressed size",
+                ));
+            }
+            input_len -= expected_compressed_size as usize;
+            output_len -= expected_decompressed_size as usize;
+            read_bytes += expected_decompressed_size as usize;
+            if input_len > expected_compressed_size as usize {
+                input = &input[expected_compressed_size as usize..];
+                output = &mut output[expected_decompressed_size as usize..];
+            } else {
+                break;
+            }
+        }
+        if input_len == 0 {
+            Ok(read_bytes)
+        } else {
+            Err(io::Error::new(
+                io::ErrorKind::Other,
+                "Not all input are consumed",
+            ))
+        }
+    }
+
+    impl Codec for LZ4HadoopCodec {
+        fn decompress(
+            &mut self,
+            input_buf: &[u8],
+            output_buf: &mut Vec<u8>,
+            uncompress_size: Option<usize>,
+        ) -> Result<usize> {
+            let output_len = output_buf.len();
+            let required_len = match uncompress_size {
+                Some(n) => n,
+                None => {
+                    return Err(ParquetError::General(
+                        "LZ4HadoopCodec unsupported without uncompress_size".into(),
+                    ))
+                }
+            };
+            output_buf.resize(output_len + required_len, 0);
+            match try_decompress_hadoop(input_buf, &mut output_buf[output_len..]) {
+                Ok(n) => {
+                    if n != required_len {
+                        return Err(ParquetError::General(
+                            "LZ4HadoopCodec uncompress_size is not the expected one"
+                                .into(),
+                        ));
+                    }
+                    Ok(n)
+                }
+                Err(e) if !self.backward_compatible_lz4 => Err(e.into()),
+                // Fallback done to be backward compatible with older versions of this
+                // library and older versions of parquet-cpp.
+                Err(_) => {
+                    // Truncate any inserted element before tryingg next algorithm.
+                    output_buf.truncate(output_len);
+                    match LZ4Codec::new().decompress(
+                        input_buf,
+                        output_buf,
+                        uncompress_size,
+                    ) {
+                        Ok(n) => Ok(n),
+                        Err(_) => {
+                            // Truncate any inserted element before tryingg next algorithm.
+                            output_buf.truncate(output_len);
+                            LZ4RawCodec::new().decompress(
+                                input_buf,
+                                output_buf,
+                                uncompress_size,
+                            )
+                        }
+                    }
+                }
+            }
+        }
+
+        fn compress(&mut self, input_buf: &[u8], output_buf: &mut Vec<u8>) -> Result<()> {
+            // Allocate memory to store the LZ4_HADOOP prefix.
+            let offset = output_buf.len();
+            output_buf.resize(offset + PREFIX_LEN, 0);
+
+            // Append LZ4_RAW compressed bytes after prefix.
+            LZ4RawCodec::new().compress(input_buf, output_buf)?;
+
+            // Prepend decompressed size and compressed size in big endian to be compatible
+            // with LZ4_HADOOP.
+            let output_buf = &mut output_buf[offset..];
+            let compressed_size = output_buf.len() - PREFIX_LEN;
+            let compressed_size = compressed_size as u32;
+            let uncompressed_size = input_buf.len() as u32;
+            output_buf[..SIZE_U32].copy_from_slice(&uncompressed_size.to_be_bytes());
+            output_buf[SIZE_U32..PREFIX_LEN]
+                .copy_from_slice(&compressed_size.to_be_bytes());
+
+            Ok(())
+        }
+    }
+}
+#[cfg(any(feature = "lz4", test))]
+pub use lz4_hadoop_codec::*;
+
 #[cfg(test)]
 mod tests {
     use super::*;
 
     use crate::util::test_common::rand_gen::random_bytes;
 
-    fn test_roundtrip(c: CodecType, data: &[u8]) {
-        let mut c1 = create_codec(c).unwrap().unwrap();
-        let mut c2 = create_codec(c).unwrap().unwrap();
+    fn test_roundtrip(c: CodecType, data: &[u8], uncompress_size: Option<usize>) {
+        let codec_options = CodecOptionsBuilder::default()
+            .set_backward_compatible_lz4(false)
+            .build();
+        let mut c1 = create_codec(c, &codec_options).unwrap().unwrap();
+        let mut c2 = create_codec(c, &codec_options).unwrap().unwrap();
 
         // Compress with c1
         let mut compressed = Vec::new();
@@ -343,7 +790,7 @@ mod tests {
 
         // Decompress with c2
         let decompressed_size = c2
-            .decompress(compressed.as_slice(), &mut decompressed)
+            .decompress(compressed.as_slice(), &mut decompressed, uncompress_size)
             .expect("Error when decompressing");
         assert_eq!(data.len(), decompressed_size);
         assert_eq!(data, decompressed.as_slice());
@@ -357,7 +804,7 @@ mod tests {
 
         // Decompress with c1
         let decompressed_size = c1
-            .decompress(compressed.as_slice(), &mut decompressed)
+            .decompress(compressed.as_slice(), &mut decompressed, uncompress_size)
             .expect("Error when decompressing");
         assert_eq!(data.len(), decompressed_size);
         assert_eq!(data, decompressed.as_slice());
@@ -376,7 +823,7 @@ mod tests {
         assert_eq!(&compressed[..4], prefix);
 
         let decompressed_size = c2
-            .decompress(&compressed[4..], &mut decompressed)
+            .decompress(&compressed[4..], &mut decompressed, uncompress_size)
             .expect("Error when decompressing");
 
         assert_eq!(data.len(), decompressed_size);
@@ -384,36 +831,62 @@ mod tests {
         assert_eq!(&decompressed[..4], prefix);
     }
 
-    fn test_codec(c: CodecType) {
+    fn test_codec_with_size(c: CodecType) {
+        let sizes = vec![100, 10000, 100000];
+        for size in sizes {
+            let data = random_bytes(size);
+            test_roundtrip(c, &data, Some(data.len()));
+        }
+    }
+
+    fn test_codec_without_size(c: CodecType) {
         let sizes = vec![100, 10000, 100000];
         for size in sizes {
             let data = random_bytes(size);
-            test_roundtrip(c, &data);
+            test_roundtrip(c, &data, None);
         }
     }
 
     #[test]
     fn test_codec_snappy() {
-        test_codec(CodecType::SNAPPY);
+        test_codec_with_size(CodecType::SNAPPY);
+        test_codec_without_size(CodecType::SNAPPY);
     }
 
     #[test]
     fn test_codec_gzip() {
-        test_codec(CodecType::GZIP);
+        for level in GzipLevel::MINIMUM_LEVEL..=GzipLevel::MAXIMUM_LEVEL {
+            let level = GzipLevel::try_new(level).unwrap();
+            test_codec_with_size(CodecType::GZIP(level));
+            test_codec_without_size(CodecType::GZIP(level));
+        }
     }
 
     #[test]
     fn test_codec_brotli() {
-        test_codec(CodecType::BROTLI);
+        for level in BrotliLevel::MINIMUM_LEVEL..=BrotliLevel::MAXIMUM_LEVEL {
+            let level = BrotliLevel::try_new(level).unwrap();
+            test_codec_with_size(CodecType::BROTLI(level));
+            test_codec_without_size(CodecType::BROTLI(level));
+        }
     }
 
     #[test]
     fn test_codec_lz4() {
-        test_codec(CodecType::LZ4);
+        test_codec_with_size(CodecType::LZ4);
     }
 
     #[test]
     fn test_codec_zstd() {
-        test_codec(CodecType::ZSTD);
+        for level in ZstdLevel::MINIMUM_LEVEL..=ZstdLevel::MAXIMUM_LEVEL {
+            let level = ZstdLevel::try_new(level).unwrap();
+            test_codec_with_size(CodecType::ZSTD(level));
+            test_codec_without_size(CodecType::ZSTD(level));
+        }
+    }
+
+    #[test]
+    fn test_codec_lz4_raw() {
+        test_codec_with_size(CodecType::LZ4_RAW);
     }
 }
diff --git a/parquet/src/data_type.rs b/parquet/src/data_type.rs
index 7870ca36a6d4..86da7a3acee4 100644
--- a/parquet/src/data_type.rs
+++ b/parquet/src/data_type.rs
@@ -17,71 +17,70 @@
 
 //! Data types that connect Parquet physical types with their Rust-specific
 //! representations.
+use bytes::Bytes;
+use half::f16;
 use std::cmp::Ordering;
 use std::fmt;
 use std::mem;
 use std::ops::{Deref, DerefMut};
 use std::str::from_utf8;
 
-use byteorder::{BigEndian, ByteOrder};
-
 use crate::basic::Type;
 use crate::column::reader::{ColumnReader, ColumnReaderImpl};
 use crate::column::writer::{ColumnWriter, ColumnWriterImpl};
 use crate::errors::{ParquetError, Result};
-use crate::util::{
-    bit_util::{from_le_slice, from_ne_slice, FromBytes},
-    memory::ByteBufferPtr,
-};
+use crate::util::bit_util::FromBytes;
 
 /// Rust representation for logical type INT96, value is backed by an array of `u32`.
 /// The type only takes 12 bytes, without extra padding.
-#[derive(Clone, Debug, PartialOrd, Default)]
+#[derive(Clone, Copy, Debug, PartialOrd, Default, PartialEq, Eq)]
 pub struct Int96 {
-    value: Option<[u32; 3]>,
+    value: [u32; 3],
 }
 
 impl Int96 {
     /// Creates new INT96 type struct with no data set.
     pub fn new() -> Self {
-        Self { value: None }
+        Self { value: [0; 3] }
     }
 
     /// Returns underlying data as slice of [`u32`].
     #[inline]
     pub fn data(&self) -> &[u32] {
-        self.value
-            .as_ref()
-            .expect("set_data should have been called")
+        &self.value
     }
 
     /// Sets data for this INT96 type.
     #[inline]
     pub fn set_data(&mut self, elem0: u32, elem1: u32, elem2: u32) {
-        self.value = Some([elem0, elem1, elem2]);
+        self.value = [elem0, elem1, elem2];
     }
 
     /// Converts this INT96 into an i64 representing the number of MILLISECONDS since Epoch
     pub fn to_i64(&self) -> i64 {
+        let (seconds, nanoseconds) = self.to_seconds_and_nanos();
+        seconds * 1_000 + nanoseconds / 1_000_000
+    }
+
+    /// Converts this INT96 into an i64 representing the number of NANOSECONDS since EPOCH
+    ///
+    /// Will wrap around on overflow
+    pub fn to_nanos(&self) -> i64 {
+        let (seconds, nanoseconds) = self.to_seconds_and_nanos();
+        seconds
+            .wrapping_mul(1_000_000_000)
+            .wrapping_add(nanoseconds)
+    }
+
+    /// Converts this INT96 to a number of seconds and nanoseconds since EPOCH
+    pub fn to_seconds_and_nanos(&self) -> (i64, i64) {
         const JULIAN_DAY_OF_EPOCH: i64 = 2_440_588;
         const SECONDS_PER_DAY: i64 = 86_400;
-        const MILLIS_PER_SECOND: i64 = 1_000;
 
         let day = self.data()[2] as i64;
         let nanoseconds = ((self.data()[1] as i64) << 32) + self.data()[0] as i64;
         let seconds = (day - JULIAN_DAY_OF_EPOCH) * SECONDS_PER_DAY;
-
-        seconds * MILLIS_PER_SECOND + nanoseconds / 1_000_000
-    }
-}
-
-impl PartialEq for Int96 {
-    fn eq(&self, other: &Int96) -> bool {
-        match (&self.value, &other.value) {
-            (Some(v1), Some(v2)) => v1 == v2,
-            (None, None) => true,
-            _ => false,
-        }
+        (seconds, nanoseconds)
     }
 }
 
@@ -105,10 +104,10 @@ impl fmt::Display for Int96 {
 /// Value is backed by a byte buffer.
 #[derive(Clone, Default)]
 pub struct ByteArray {
-    data: Option<ByteBufferPtr>,
+    data: Option<Bytes>,
 }
 
-// Special case Debug that prints out byte arrays that are vaid utf8 as &str's
+// Special case Debug that prints out byte arrays that are valid utf8 as &str's
 impl std::fmt::Debug for ByteArray {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut debug_struct = f.debug_struct("ByteArray");
@@ -132,7 +131,7 @@ impl PartialOrd for ByteArray {
             (Some(_), None) => Some(Ordering::Greater),
             (Some(self_data), Some(other_data)) => {
                 // compare slices directly
-                self_data.data().partial_cmp(other_data.data())
+                self_data.partial_cmp(&other_data)
             }
         }
     }
@@ -169,7 +168,7 @@ impl ByteArray {
 
     /// Set data from another byte buffer.
     #[inline]
-    pub fn set_data(&mut self, data: ByteBufferPtr) {
+    pub fn set_data(&mut self, data: Bytes) {
         self.data = Some(data);
     }
 
@@ -180,7 +179,7 @@ impl ByteArray {
             self.data
                 .as_ref()
                 .expect("set_data should have been called")
-                .range(start, len),
+                .slice(start..start + len),
         )
     }
 
@@ -196,7 +195,17 @@ impl ByteArray {
 impl From<Vec<u8>> for ByteArray {
     fn from(buf: Vec<u8>) -> ByteArray {
         Self {
-            data: Some(ByteBufferPtr::new(buf)),
+            data: Some(buf.into()),
+        }
+    }
+}
+
+impl<'a> From<&'a [u8]> for ByteArray {
+    fn from(b: &'a [u8]) -> ByteArray {
+        let mut v = Vec::new();
+        v.extend_from_slice(b);
+        Self {
+            data: Some(v.into()),
         }
     }
 }
@@ -206,14 +215,20 @@ impl<'a> From<&'a str> for ByteArray {
         let mut v = Vec::new();
         v.extend_from_slice(s.as_bytes());
         Self {
-            data: Some(ByteBufferPtr::new(v)),
+            data: Some(v.into()),
         }
     }
 }
 
-impl From<ByteBufferPtr> for ByteArray {
-    fn from(ptr: ByteBufferPtr) -> ByteArray {
-        Self { data: Some(ptr) }
+impl From<Bytes> for ByteArray {
+    fn from(value: Bytes) -> Self {
+        Self { data: Some(value) }
+    }
+}
+
+impl From<f16> for ByteArray {
+    fn from(value: f16) -> Self {
+        Self::from(value.to_le_bytes().as_slice())
     }
 }
 
@@ -245,7 +260,7 @@ impl fmt::Display for ByteArray {
 /// types, although there are code paths in the Rust (and potentially the C++) versions that
 /// warrant this.
 ///
-/// With this wrapper type the compiler generates more targetted code paths matching the higher
+/// With this wrapper type the compiler generates more targeted code paths matching the higher
 /// level logical types, removing the data-hazard from all decoding and encoding paths.
 #[repr(transparent)]
 #[derive(Clone, Debug, Default)]
@@ -313,6 +328,12 @@ impl From<ByteArray> for FixedLenByteArray {
     }
 }
 
+impl From<Vec<u8>> for FixedLenByteArray {
+    fn from(buf: Vec<u8>) -> FixedLenByteArray {
+        FixedLenByteArray(ByteArray::from(buf))
+    }
+}
+
 impl From<FixedLenByteArray> for ByteArray {
     fn from(other: FixedLenByteArray) -> Self {
         other.0
@@ -349,8 +370,7 @@ pub enum Decimal {
 impl Decimal {
     /// Creates new decimal value from `i32`.
     pub fn from_i32(value: i32, precision: i32, scale: i32) -> Self {
-        let mut bytes = [0; 4];
-        BigEndian::write_i32(&mut bytes, value);
+        let bytes = value.to_be_bytes();
         Decimal::Int32 {
             value: bytes,
             precision,
@@ -360,8 +380,7 @@ impl Decimal {
 
     /// Creates new decimal value from `i64`.
     pub fn from_i64(value: i64, precision: i32, scale: i32) -> Self {
-        let mut bytes = [0; 8];
-        BigEndian::write_i64(&mut bytes, value);
+        let bytes = value.to_be_bytes();
         Decimal::Int64 {
             value: bytes,
             precision,
@@ -465,7 +484,7 @@ macro_rules! gen_as_bytes {
                 unsafe {
                     std::slice::from_raw_parts(
                         self_.as_ptr() as *const u8,
-                        std::mem::size_of::<$source_ty>() * self_.len(),
+                        std::mem::size_of_val(self_),
                     )
                 }
             }
@@ -475,7 +494,7 @@ macro_rules! gen_as_bytes {
             unsafe fn slice_as_bytes_mut(self_: &mut [Self]) -> &mut [u8] {
                 std::slice::from_raw_parts_mut(
                     self_.as_mut_ptr() as *mut u8,
-                    std::mem::size_of::<$source_ty>() * self_.len(),
+                    std::mem::size_of_val(self_),
                 )
             }
         }
@@ -521,9 +540,7 @@ impl AsBytes for bool {
 
 impl AsBytes for Int96 {
     fn as_bytes(&self) -> &[u8] {
-        unsafe {
-            std::slice::from_raw_parts(self.data() as *const [u32] as *const u8, 12)
-        }
+        unsafe { std::slice::from_raw_parts(self.data() as *const [u32] as *const u8, 12) }
     }
 }
 
@@ -564,12 +581,12 @@ impl AsBytes for str {
 }
 
 pub(crate) mod private {
+    use bytes::Bytes;
+
     use crate::encodings::decoding::PlainDecoderDetails;
     use crate::util::bit_util::{read_num_bytes, BitReader, BitWriter};
-    use crate::util::memory::ByteBufferPtr;
 
     use crate::basic::Type;
-    use byteorder::ByteOrder;
     use std::convert::TryInto;
 
     use super::{ParquetError, Result, SliceAsBytes};
@@ -603,17 +620,10 @@ pub(crate) mod private {
         ) -> Result<()>;
 
         /// Establish the data that will be decoded in a buffer
-        fn set_data(
-            decoder: &mut PlainDecoderDetails,
-            data: ByteBufferPtr,
-            num_values: usize,
-        );
+        fn set_data(decoder: &mut PlainDecoderDetails, data: Bytes, num_values: usize);
 
         /// Decode the value from a given buffer for a higher level decoder
-        fn decode(
-            buffer: &mut [Self],
-            decoder: &mut PlainDecoderDetails,
-        ) -> Result<usize>;
+        fn decode(buffer: &mut [Self], decoder: &mut PlainDecoderDetails) -> Result<usize>;
 
         fn skip(decoder: &mut PlainDecoderDetails, num_values: usize) -> Result<usize>;
 
@@ -624,7 +634,7 @@ pub(crate) mod private {
 
         /// Return the value as i64 if possible
         ///
-        /// This is essentially the same as `std::convert::TryInto<i64>` but can
+        /// This is essentially the same as `std::convert::TryInto<i64>` but can't be
         /// implemented for `f32` and `f64`, types that would fail orphan rules
         fn as_i64(&self) -> Result<i64> {
             Err(general_err!("Type cannot be converted to i64"))
@@ -632,7 +642,7 @@ pub(crate) mod private {
 
         /// Return the value as u64 if possible
         ///
-        /// This is essentially the same as `std::convert::TryInto<u64>` but can
+        /// This is essentially the same as `std::convert::TryInto<u64>` but can't be
         /// implemented for `f32` and `f64`, types that would fail orphan rules
         fn as_u64(&self) -> Result<u64> {
             self.as_i64()
@@ -663,20 +673,13 @@ pub(crate) mod private {
         }
 
         #[inline]
-        fn set_data(
-            decoder: &mut PlainDecoderDetails,
-            data: ByteBufferPtr,
-            num_values: usize,
-        ) {
+        fn set_data(decoder: &mut PlainDecoderDetails, data: Bytes, num_values: usize) {
             decoder.bit_reader.replace(BitReader::new(data));
             decoder.num_values = num_values;
         }
 
         #[inline]
-        fn decode(
-            buffer: &mut [Self],
-            decoder: &mut PlainDecoderDetails,
-        ) -> Result<usize> {
+        fn decode(buffer: &mut [Self], decoder: &mut PlainDecoderDetails) -> Result<usize> {
             let bit_reader = decoder.bit_reader.as_mut().unwrap();
             let num_values = std::cmp::min(buffer.len(), decoder.num_values);
             let values_read = bit_reader.get_batch(&mut buffer[..num_values], 1);
@@ -718,7 +721,7 @@ pub(crate) mod private {
                     let raw = unsafe {
                         std::slice::from_raw_parts(
                             values.as_ptr() as *const u8,
-                            std::mem::size_of::<$ty>() * values.len(),
+                            std::mem::size_of_val(values),
                         )
                     };
                     writer.write_all(raw)?;
@@ -727,7 +730,7 @@ pub(crate) mod private {
                 }
 
                 #[inline]
-                fn set_data(decoder: &mut PlainDecoderDetails, data: ByteBufferPtr, num_values: usize) {
+                fn set_data(decoder: &mut PlainDecoderDetails, data: Bytes, num_values: usize) {
                     decoder.data.replace(data);
                     decoder.start = 0;
                     decoder.num_values = num_values;
@@ -747,7 +750,9 @@ pub(crate) mod private {
                     // SAFETY: Raw types should be as per the standard rust bit-vectors
                     unsafe {
                         let raw_buffer = &mut Self::slice_as_bytes_mut(buffer)[..bytes_to_decode];
-                        raw_buffer.copy_from_slice(data.range(decoder.start, bytes_to_decode).as_ref());
+                        raw_buffer.copy_from_slice(data.slice(
+                            decoder.start..decoder.start + bytes_to_decode
+                        ).as_ref());
                     };
                     decoder.start += bytes_to_decode;
                     decoder.num_values -= num_values;
@@ -806,10 +811,7 @@ pub(crate) mod private {
         ) -> Result<()> {
             for value in values {
                 let raw = unsafe {
-                    std::slice::from_raw_parts(
-                        value.data() as *const [u32] as *const u8,
-                        12,
-                    )
+                    std::slice::from_raw_parts(value.data() as *const [u32] as *const u8, 12)
                 };
                 writer.write_all(raw)?;
             }
@@ -817,21 +819,14 @@ pub(crate) mod private {
         }
 
         #[inline]
-        fn set_data(
-            decoder: &mut PlainDecoderDetails,
-            data: ByteBufferPtr,
-            num_values: usize,
-        ) {
+        fn set_data(decoder: &mut PlainDecoderDetails, data: Bytes, num_values: usize) {
             decoder.data.replace(data);
             decoder.start = 0;
             decoder.num_values = num_values;
         }
 
         #[inline]
-        fn decode(
-            buffer: &mut [Self],
-            decoder: &mut PlainDecoderDetails,
-        ) -> Result<usize> {
+        fn decode(buffer: &mut [Self], decoder: &mut PlainDecoderDetails) -> Result<usize> {
             // TODO - Remove the duplication between this and the general slice method
             let data = decoder
                 .data
@@ -845,15 +840,15 @@ pub(crate) mod private {
                 return Err(eof_err!("Not enough bytes to decode"));
             }
 
-            let data_range = data.range(decoder.start, bytes_to_decode);
-            let bytes: &[u8] = data_range.data();
+            let data_range = data.slice(decoder.start..decoder.start + bytes_to_decode);
+            let bytes: &[u8] = &data_range;
             decoder.start += bytes_to_decode;
 
             let mut pos = 0; // position in byte array
             for item in buffer.iter_mut().take(num_values) {
-                let elem0 = byteorder::LittleEndian::read_u32(&bytes[pos..pos + 4]);
-                let elem1 = byteorder::LittleEndian::read_u32(&bytes[pos + 4..pos + 8]);
-                let elem2 = byteorder::LittleEndian::read_u32(&bytes[pos + 8..pos + 12]);
+                let elem0 = u32::from_le_bytes(bytes[pos..pos + 4].try_into().unwrap());
+                let elem1 = u32::from_le_bytes(bytes[pos + 4..pos + 8].try_into().unwrap());
+                let elem2 = u32::from_le_bytes(bytes[pos + 8..pos + 12].try_into().unwrap());
 
                 item.set_data(elem0, elem1, elem2);
                 pos += 12;
@@ -911,21 +906,14 @@ pub(crate) mod private {
         }
 
         #[inline]
-        fn set_data(
-            decoder: &mut PlainDecoderDetails,
-            data: ByteBufferPtr,
-            num_values: usize,
-        ) {
+        fn set_data(decoder: &mut PlainDecoderDetails, data: Bytes, num_values: usize) {
             decoder.data.replace(data);
             decoder.start = 0;
             decoder.num_values = num_values;
         }
 
         #[inline]
-        fn decode(
-            buffer: &mut [Self],
-            decoder: &mut PlainDecoderDetails,
-        ) -> Result<usize> {
+        fn decode(buffer: &mut [Self], decoder: &mut PlainDecoderDetails) -> Result<usize> {
             let data = decoder
                 .data
                 .as_mut()
@@ -933,8 +921,7 @@ pub(crate) mod private {
             let num_values = std::cmp::min(buffer.len(), decoder.num_values);
             for val_array in buffer.iter_mut().take(num_values) {
                 let len: usize =
-                    read_num_bytes::<u32>(4, data.start_from(decoder.start).as_ref())
-                        as usize;
+                    read_num_bytes::<u32>(4, data.slice(decoder.start..).as_ref()) as usize;
                 decoder.start += std::mem::size_of::<u32>();
 
                 if data.len() < decoder.start + len {
@@ -943,7 +930,7 @@ pub(crate) mod private {
 
                 let val: &mut Self = val_array.as_mut_any().downcast_mut().unwrap();
 
-                val.set_data(data.range(decoder.start, len));
+                val.set_data(data.slice(decoder.start..decoder.start + len));
                 decoder.start += len;
             }
             decoder.num_values -= num_values;
@@ -960,8 +947,7 @@ pub(crate) mod private {
 
             for _ in 0..num_values {
                 let len: usize =
-                    read_num_bytes::<u32>(4, data.start_from(decoder.start).as_ref())
-                        as usize;
+                    read_num_bytes::<u32>(4, data.slice(decoder.start..).as_ref()) as usize;
                 decoder.start += std::mem::size_of::<u32>() + len;
             }
             decoder.num_values -= num_values;
@@ -1002,21 +988,14 @@ pub(crate) mod private {
         }
 
         #[inline]
-        fn set_data(
-            decoder: &mut PlainDecoderDetails,
-            data: ByteBufferPtr,
-            num_values: usize,
-        ) {
+        fn set_data(decoder: &mut PlainDecoderDetails, data: Bytes, num_values: usize) {
             decoder.data.replace(data);
             decoder.start = 0;
             decoder.num_values = num_values;
         }
 
         #[inline]
-        fn decode(
-            buffer: &mut [Self],
-            decoder: &mut PlainDecoderDetails,
-        ) -> Result<usize> {
+        fn decode(buffer: &mut [Self], decoder: &mut PlainDecoderDetails) -> Result<usize> {
             assert!(decoder.type_length > 0);
 
             let data = decoder
@@ -1032,7 +1011,7 @@ pub(crate) mod private {
                     return Err(eof_err!("Not enough bytes to decode"));
                 }
 
-                item.set_data(data.range(decoder.start, len));
+                item.set_data(data.slice(decoder.start..decoder.start + len));
                 decoder.start += len;
             }
             decoder.num_values -= num_values;
@@ -1096,9 +1075,7 @@ pub trait DataType: 'static + Send {
     where
         Self: Sized;
 
-    fn get_column_writer(
-        column_writer: ColumnWriter<'_>,
-    ) -> Option<ColumnWriterImpl<'_, Self>>
+    fn get_column_writer(column_writer: ColumnWriter<'_>) -> Option<ColumnWriterImpl<'_, Self>>
     where
         Self: Sized;
 
@@ -1141,10 +1118,8 @@ macro_rules! make_type {
                 $size
             }
 
-            fn get_column_reader(
-                column_writer: ColumnReader,
-            ) -> Option<ColumnReaderImpl<Self>> {
-                match column_writer {
+            fn get_column_reader(column_reader: ColumnReader) -> Option<ColumnReaderImpl<Self>> {
+                match column_reader {
                     ColumnReader::$reader_ident(w) => Some(w),
                     _ => None,
                 }
@@ -1209,57 +1184,15 @@ make_type!(
     mem::size_of::<FixedLenByteArray>()
 );
 
-impl FromBytes for Int96 {
-    type Buffer = [u8; 12];
-    fn from_le_bytes(bs: Self::Buffer) -> Self {
-        let mut i = Int96::new();
-        i.set_data(
-            from_le_slice(&bs[0..4]),
-            from_le_slice(&bs[4..8]),
-            from_le_slice(&bs[8..12]),
-        );
-        i
-    }
-    fn from_be_bytes(_bs: Self::Buffer) -> Self {
-        unimplemented!()
-    }
-    fn from_ne_bytes(bs: Self::Buffer) -> Self {
-        let mut i = Int96::new();
-        i.set_data(
-            from_ne_slice(&bs[0..4]),
-            from_ne_slice(&bs[4..8]),
-            from_ne_slice(&bs[8..12]),
-        );
-        i
+impl AsRef<[u8]> for ByteArray {
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
     }
 }
 
-// FIXME Needed to satisfy the constraint of many decoding functions but ByteArray does not
-// appear to actual be converted directly from bytes
-impl FromBytes for ByteArray {
-    type Buffer = [u8; 8];
-    fn from_le_bytes(bs: Self::Buffer) -> Self {
-        ByteArray::from(bs.to_vec())
-    }
-    fn from_be_bytes(_bs: Self::Buffer) -> Self {
-        unreachable!()
-    }
-    fn from_ne_bytes(bs: Self::Buffer) -> Self {
-        ByteArray::from(bs.to_vec())
-    }
-}
-
-impl FromBytes for FixedLenByteArray {
-    type Buffer = [u8; 8];
-
-    fn from_le_bytes(bs: Self::Buffer) -> Self {
-        Self(ByteArray::from(bs.to_vec()))
-    }
-    fn from_be_bytes(_bs: Self::Buffer) -> Self {
-        unreachable!()
-    }
-    fn from_ne_bytes(bs: Self::Buffer) -> Self {
-        Self(ByteArray::from(bs.to_vec()))
+impl AsRef<[u8]> for FixedLenByteArray {
+    fn as_ref(&self) -> &[u8] {
+        self.as_bytes()
     }
 }
 
@@ -1274,35 +1207,11 @@ macro_rules! ensure_phys_ty {
 }
 
 #[cfg(test)]
-#[allow(clippy::float_cmp, clippy::approx_constant)]
 mod tests {
     use super::*;
 
     #[test]
-    #[allow(clippy::string_lit_as_bytes)]
     fn test_as_bytes() {
-        assert_eq!(false.as_bytes(), &[0]);
-        assert_eq!(true.as_bytes(), &[1]);
-        assert_eq!(7_i32.as_bytes(), &[7, 0, 0, 0]);
-        assert_eq!(555_i32.as_bytes(), &[43, 2, 0, 0]);
-        assert_eq!(555_u32.as_bytes(), &[43, 2, 0, 0]);
-        assert_eq!(i32::max_value().as_bytes(), &[255, 255, 255, 127]);
-        assert_eq!(i32::min_value().as_bytes(), &[0, 0, 0, 128]);
-        assert_eq!(7_i64.as_bytes(), &[7, 0, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(555_i64.as_bytes(), &[43, 2, 0, 0, 0, 0, 0, 0]);
-        assert_eq!(
-            (i64::max_value()).as_bytes(),
-            &[255, 255, 255, 255, 255, 255, 255, 127]
-        );
-        assert_eq!((i64::min_value()).as_bytes(), &[0, 0, 0, 0, 0, 0, 0, 128]);
-        assert_eq!(3.14_f32.as_bytes(), &[195, 245, 72, 64]);
-        assert_eq!(3.14_f64.as_bytes(), &[31, 133, 235, 81, 184, 30, 9, 64]);
-        assert_eq!("hello".as_bytes(), &[b'h', b'e', b'l', b'l', b'o']);
-        assert_eq!(
-            Vec::from("hello".as_bytes()).as_bytes(),
-            &[b'h', b'e', b'l', b'l', b'o']
-        );
-
         // Test Int96
         let i96 = Int96::from(vec![1, 2, 3]);
         assert_eq!(i96.as_bytes(), &[1, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0]);
@@ -1336,7 +1245,7 @@ mod tests {
         );
         assert_eq!(ByteArray::from("ABC").data(), &[b'A', b'B', b'C']);
         assert_eq!(
-            ByteArray::from(ByteBufferPtr::new(vec![1u8, 2u8, 3u8, 4u8, 5u8])).data(),
+            ByteArray::from(Bytes::from(vec![1u8, 2u8, 3u8, 4u8, 5u8])).data(),
             &[1u8, 2u8, 3u8, 4u8, 5u8]
         );
         let buf = vec![6u8, 7u8, 8u8, 9u8, 10u8];
diff --git a/parquet/src/encodings/decoding.rs b/parquet/src/encodings/decoding.rs
index 86941ffe0eeb..a1924f72e85a 100644
--- a/parquet/src/encodings/decoding.rs
+++ b/parquet/src/encodings/decoding.rs
@@ -17,6 +17,7 @@
 
 //! Contains all supported decoders for Parquet.
 
+use bytes::Bytes;
 use num::traits::WrappingAdd;
 use num::FromPrimitive;
 use std::{cmp, marker::PhantomData, mem};
@@ -28,10 +29,9 @@ use crate::data_type::private::ParquetValueType;
 use crate::data_type::*;
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::ColumnDescPtr;
-use crate::util::{
-    bit_util::{self, BitReader},
-    memory::ByteBufferPtr,
-};
+use crate::util::bit_util::{self, BitReader};
+
+mod byte_stream_split_decoder;
 
 pub(crate) mod private {
     use super::*;
@@ -105,8 +105,32 @@ pub(crate) mod private {
         }
     }
 
-    impl GetDecoder for f32 {}
-    impl GetDecoder for f64 {}
+    impl GetDecoder for f32 {
+        fn get_decoder<T: DataType<T = Self>>(
+            descr: ColumnDescPtr,
+            encoding: Encoding,
+        ) -> Result<Box<dyn Decoder<T>>> {
+            match encoding {
+                Encoding::BYTE_STREAM_SPLIT => Ok(Box::new(
+                    byte_stream_split_decoder::ByteStreamSplitDecoder::new(),
+                )),
+                _ => get_decoder_default(descr, encoding),
+            }
+        }
+    }
+    impl GetDecoder for f64 {
+        fn get_decoder<T: DataType<T = Self>>(
+            descr: ColumnDescPtr,
+            encoding: Encoding,
+        ) -> Result<Box<dyn Decoder<T>>> {
+            match encoding {
+                Encoding::BYTE_STREAM_SPLIT => Ok(Box::new(
+                    byte_stream_split_decoder::ByteStreamSplitDecoder::new(),
+                )),
+                _ => get_decoder_default(descr, encoding),
+            }
+        }
+    }
 
     impl GetDecoder for ByteArray {
         fn get_decoder<T: DataType<T = Self>>(
@@ -145,7 +169,7 @@ pub(crate) mod private {
 pub trait Decoder<T: DataType>: Send {
     /// Sets the data to decode to be `data`, which should contain `num_values` of values
     /// to decode.
-    fn set_data(&mut self, data: ByteBufferPtr, num_values: usize) -> Result<()>;
+    fn set_data(&mut self, data: Bytes, num_values: usize) -> Result<()>;
 
     /// Consumes values from this decoder and write the results to `buffer`. This will try
     /// to fill up `buffer`.
@@ -238,7 +262,7 @@ pub struct PlainDecoderDetails {
     pub(crate) type_length: i32,
 
     // The byte array to decode from. Not set if `T` is bool.
-    pub(crate) data: Option<ByteBufferPtr>,
+    pub(crate) data: Option<Bytes>,
 
     // Read `data` bit by bit. Only set if `T` is bool.
     pub(crate) bit_reader: Option<BitReader>,
@@ -275,7 +299,7 @@ impl<T: DataType> PlainDecoder<T> {
 
 impl<T: DataType> Decoder<T> for PlainDecoder<T> {
     #[inline]
-    fn set_data(&mut self, data: ByteBufferPtr, num_values: usize) -> Result<()> {
+    fn set_data(&mut self, data: Bytes, num_values: usize) -> Result<()> {
         T::T::set_data(&mut self.inner, data, num_values);
         Ok(())
     }
@@ -350,11 +374,11 @@ impl<T: DataType> DictDecoder<T> {
 }
 
 impl<T: DataType> Decoder<T> for DictDecoder<T> {
-    fn set_data(&mut self, data: ByteBufferPtr, num_values: usize) -> Result<()> {
+    fn set_data(&mut self, data: Bytes, num_values: usize) -> Result<()> {
         // First byte in `data` is bit width
         let bit_width = data.as_ref()[0];
         let mut rle_decoder = RleDecoder::new(bit_width);
-        rle_decoder.set_data(data.start_from(1));
+        rle_decoder.set_data(data.slice(1..));
         self.num_values = num_values;
         self.rle_decoder = Some(rle_decoder);
         Ok(())
@@ -418,7 +442,7 @@ impl<T: DataType> RleValueDecoder<T> {
 
 impl<T: DataType> Decoder<T> for RleValueDecoder<T> {
     #[inline]
-    fn set_data(&mut self, data: ByteBufferPtr, num_values: usize) -> Result<()> {
+    fn set_data(&mut self, data: Bytes, num_values: usize) -> Result<()> {
         // Only support RLE value reader for boolean values with bit width of 1.
         ensure_phys_ty!(Type::BOOLEAN, "RleValueDecoder only supports BoolType");
 
@@ -426,7 +450,8 @@ impl<T: DataType> Decoder<T> for RleValueDecoder<T> {
         const I32_SIZE: usize = mem::size_of::<i32>();
         let data_size = bit_util::read_num_bytes::<i32>(I32_SIZE, data.as_ref()) as usize;
         self.decoder = RleDecoder::new(1);
-        self.decoder.set_data(data.range(I32_SIZE, data_size));
+        self.decoder
+            .set_data(data.slice(I32_SIZE..I32_SIZE + data_size));
         self.values_left = num_values;
         Ok(())
     }
@@ -551,14 +576,12 @@ where
             .get_zigzag_vlq_int()
             .ok_or_else(|| eof_err!("Not enough data to decode 'min_delta'"))?;
 
-        self.min_delta = T::T::from_i64(min_delta)
-            .ok_or_else(|| general_err!("'min_delta' too large"))?;
+        self.min_delta =
+            T::T::from_i64(min_delta).ok_or_else(|| general_err!("'min_delta' too large"))?;
 
         self.mini_block_bit_widths.clear();
-        self.bit_reader.get_aligned_bytes(
-            &mut self.mini_block_bit_widths,
-            self.mini_blocks_per_block as usize,
-        );
+        self.bit_reader
+            .get_aligned_bytes(&mut self.mini_block_bit_widths, self.mini_blocks_per_block);
 
         let mut offset = self.bit_reader.get_byte_offset();
         let mut remaining = self.values_left;
@@ -604,7 +627,7 @@ where
 {
     // # of total values is derived from encoding
     #[inline]
-    fn set_data(&mut self, data: ByteBufferPtr, _index: usize) -> Result<()> {
+    fn set_data(&mut self, data: Bytes, _index: usize) -> Result<()> {
         self.bit_reader = BitReader::new(data);
         self.initialized = true;
 
@@ -635,10 +658,8 @@ where
             .get_zigzag_vlq_int()
             .ok_or_else(|| eof_err!("Not enough data to decode 'first_value'"))?;
 
-        self.first_value = Some(
-            T::T::from_i64(first_value)
-                .ok_or_else(|| general_err!("first value too large"))?,
-        );
+        self.first_value =
+            Some(T::T::from_i64(first_value).ok_or_else(|| general_err!("first value too large"))?);
 
         if self.block_size % 128 != 0 {
             return Err(general_err!(
@@ -650,7 +671,8 @@ where
         if self.block_size % self.mini_blocks_per_block != 0 {
             return Err(general_err!(
                 "'block_size' must be a multiple of 'mini_blocks_per_block' got {} and {}",
-                self.block_size, self.mini_blocks_per_block
+                self.block_size,
+                self.mini_blocks_per_block
             ));
         }
 
@@ -811,7 +833,7 @@ pub struct DeltaLengthByteArrayDecoder<T: DataType> {
     current_idx: usize,
 
     // Concatenated byte array data
-    data: Option<ByteBufferPtr>,
+    data: Option<Bytes>,
 
     // Offset into `data`, always point to the beginning of next byte array.
     offset: usize,
@@ -844,16 +866,16 @@ impl<T: DataType> DeltaLengthByteArrayDecoder<T> {
 }
 
 impl<T: DataType> Decoder<T> for DeltaLengthByteArrayDecoder<T> {
-    fn set_data(&mut self, data: ByteBufferPtr, num_values: usize) -> Result<()> {
+    fn set_data(&mut self, data: Bytes, num_values: usize) -> Result<()> {
         match T::get_physical_type() {
             Type::BYTE_ARRAY => {
                 let mut len_decoder = DeltaBitPackDecoder::<Int32Type>::new();
-                len_decoder.set_data(data.all(), num_values)?;
+                len_decoder.set_data(data.clone(), num_values)?;
                 let num_lengths = len_decoder.values_left();
                 self.lengths.resize(num_lengths, 0);
                 len_decoder.get(&mut self.lengths[..])?;
 
-                self.data = Some(data.start_from(len_decoder.get_offset()));
+                self.data = Some(data.slice(len_decoder.get_offset()..));
                 self.offset = 0;
                 self.current_idx = 0;
                 self.num_values = num_lengths;
@@ -879,7 +901,7 @@ impl<T: DataType> Decoder<T> for DeltaLengthByteArrayDecoder<T> {
                     item.as_mut_any()
                         .downcast_mut::<ByteArray>()
                         .unwrap()
-                        .set_data(data.range(self.offset, len));
+                        .set_data(data.slice(self.offset..self.offset + len));
 
                     self.offset += len;
                     self.current_idx += 1;
@@ -977,29 +999,27 @@ impl<T: DataType> DeltaByteArrayDecoder<T> {
 }
 
 impl<T: DataType> Decoder<T> for DeltaByteArrayDecoder<T> {
-    fn set_data(&mut self, data: ByteBufferPtr, num_values: usize) -> Result<()> {
+    fn set_data(&mut self, data: Bytes, num_values: usize) -> Result<()> {
         match T::get_physical_type() {
             Type::BYTE_ARRAY | Type::FIXED_LEN_BYTE_ARRAY => {
                 let mut prefix_len_decoder = DeltaBitPackDecoder::<Int32Type>::new();
-                prefix_len_decoder.set_data(data.all(), num_values)?;
+                prefix_len_decoder.set_data(data.clone(), num_values)?;
                 let num_prefixes = prefix_len_decoder.values_left();
                 self.prefix_lengths.resize(num_prefixes, 0);
                 prefix_len_decoder.get(&mut self.prefix_lengths[..])?;
 
                 let mut suffix_decoder = DeltaLengthByteArrayDecoder::new();
                 suffix_decoder
-                    .set_data(data.start_from(prefix_len_decoder.get_offset()), num_values)?;
+                    .set_data(data.slice(prefix_len_decoder.get_offset()..), num_values)?;
                 self.suffix_decoder = Some(suffix_decoder);
                 self.num_values = num_prefixes;
                 self.current_idx = 0;
                 self.previous_value.clear();
                 Ok(())
             }
-            _ => {
-                Err(general_err!(
-                    "DeltaByteArrayDecoder only supports ByteArrayType and FixedLenByteArrayType"
-                ))
-            }
+            _ => Err(general_err!(
+                "DeltaByteArrayDecoder only supports ByteArrayType and FixedLenByteArrayType"
+            )),
         }
     }
 
@@ -1011,7 +1031,10 @@ impl<T: DataType> Decoder<T> for DeltaByteArrayDecoder<T> {
                 for item in buffer.iter_mut().take(num_values) {
                     // Process suffix
                     // TODO: this is awkward - maybe we should add a non-vectorized API?
-                    let suffix_decoder = self.suffix_decoder.as_mut().expect("decoder not initialized");
+                    let suffix_decoder = self
+                        .suffix_decoder
+                        .as_mut()
+                        .expect("decoder not initialized");
                     suffix_decoder.get(&mut v[..])?;
                     let suffix = v[0].data();
 
@@ -1023,7 +1046,7 @@ impl<T: DataType> Decoder<T> for DeltaByteArrayDecoder<T> {
                     result.extend_from_slice(&self.previous_value[0..prefix_len]);
                     result.extend_from_slice(suffix);
 
-                    let data = ByteBufferPtr::new(result.clone());
+                    let data = Bytes::from(result.clone());
 
                     match ty {
                         Type::BYTE_ARRAY => item
@@ -1046,11 +1069,9 @@ impl<T: DataType> Decoder<T> for DeltaByteArrayDecoder<T> {
                 self.num_values -= num_values;
                 Ok(num_values)
             }
-            _ => {
-                Err(general_err!(
-                    "DeltaByteArrayDecoder only supports ByteArrayType and FixedLenByteArrayType"
-                ))
-            }
+            _ => Err(general_err!(
+                "DeltaByteArrayDecoder only supports ByteArrayType and FixedLenByteArrayType"
+            )),
         }
     }
 
@@ -1069,15 +1090,14 @@ impl<T: DataType> Decoder<T> for DeltaByteArrayDecoder<T> {
 }
 
 #[cfg(test)]
-#[allow(clippy::approx_constant)]
 mod tests {
     use super::{super::encoding::*, *};
 
+    use std::f32::consts::PI as PI_f32;
+    use std::f64::consts::PI as PI_f64;
     use std::sync::Arc;
 
-    use crate::schema::types::{
-        ColumnDescPtr, ColumnDescriptor, ColumnPath, Type as SchemaType,
-    };
+    use crate::schema::types::{ColumnDescPtr, ColumnDescriptor, ColumnPath, Type as SchemaType};
     use crate::util::test_common::rand_gen::RandGen;
 
     #[test]
@@ -1085,10 +1105,7 @@ mod tests {
         // supported encodings
         create_and_check_decoder::<Int32Type>(Encoding::PLAIN, None);
         create_and_check_decoder::<Int32Type>(Encoding::DELTA_BINARY_PACKED, None);
-        create_and_check_decoder::<ByteArrayType>(
-            Encoding::DELTA_LENGTH_BYTE_ARRAY,
-            None,
-        );
+        create_and_check_decoder::<ByteArrayType>(Encoding::DELTA_LENGTH_BYTE_ARRAY, None);
         create_and_check_decoder::<ByteArrayType>(Encoding::DELTA_BYTE_ARRAY, None);
         create_and_check_decoder::<BoolType>(Encoding::RLE, None);
 
@@ -1119,6 +1136,7 @@ mod tests {
         );
 
         // unsupported
+        #[allow(deprecated)]
         create_and_check_decoder::<Int32Type>(
             Encoding::BIT_PACKED,
             Some(nyi_err!("Encoding BIT_PACKED is not supported")),
@@ -1127,36 +1145,24 @@ mod tests {
 
     #[test]
     fn test_plain_decode_int32() {
-        let data = vec![42, 18, 52];
+        let data = [42, 18, 52];
         let data_bytes = Int32Type::to_byte_array(&data[..]);
-        let mut buffer = vec![0; 3];
-        test_plain_decode::<Int32Type>(
-            ByteBufferPtr::new(data_bytes),
-            3,
-            -1,
-            &mut buffer[..],
-            &data[..],
-        );
+        let mut buffer = [0; 3];
+        test_plain_decode::<Int32Type>(Bytes::from(data_bytes), 3, -1, &mut buffer[..], &data[..]);
     }
 
     #[test]
     fn test_plain_skip_int32() {
-        let data = vec![42, 18, 52];
+        let data = [42, 18, 52];
         let data_bytes = Int32Type::to_byte_array(&data[..]);
-        test_plain_skip::<Int32Type>(
-            ByteBufferPtr::new(data_bytes),
-            3,
-            1,
-            -1,
-            &data[1..],
-        );
+        test_plain_skip::<Int32Type>(Bytes::from(data_bytes), 3, 1, -1, &data[1..]);
     }
 
     #[test]
     fn test_plain_skip_all_int32() {
-        let data = vec![42, 18, 52];
+        let data = [42, 18, 52];
         let data_bytes = Int32Type::to_byte_array(&data[..]);
-        test_plain_skip::<Int32Type>(ByteBufferPtr::new(data_bytes), 3, 5, -1, &[]);
+        test_plain_skip::<Int32Type>(Bytes::from(data_bytes), 3, 5, -1, &[]);
     }
 
     #[test]
@@ -1164,11 +1170,11 @@ mod tests {
         let data = [42, 18, 52];
         let expected_data = [0, 42, 0, 18, 0, 0, 52, 0];
         let data_bytes = Int32Type::to_byte_array(&data[..]);
-        let mut buffer = vec![0; 8];
+        let mut buffer = [0; 8];
         let num_nulls = 5;
         let valid_bits = [0b01001010];
         test_plain_decode_spaced::<Int32Type>(
-            ByteBufferPtr::new(data_bytes),
+            Bytes::from(data_bytes),
             3,
             -1,
             &mut buffer[..],
@@ -1180,201 +1186,141 @@ mod tests {
 
     #[test]
     fn test_plain_decode_int64() {
-        let data = vec![42, 18, 52];
+        let data = [42, 18, 52];
         let data_bytes = Int64Type::to_byte_array(&data[..]);
-        let mut buffer = vec![0; 3];
-        test_plain_decode::<Int64Type>(
-            ByteBufferPtr::new(data_bytes),
-            3,
-            -1,
-            &mut buffer[..],
-            &data[..],
-        );
+        let mut buffer = [0; 3];
+        test_plain_decode::<Int64Type>(Bytes::from(data_bytes), 3, -1, &mut buffer[..], &data[..]);
     }
 
     #[test]
     fn test_plain_skip_int64() {
-        let data = vec![42, 18, 52];
+        let data = [42, 18, 52];
         let data_bytes = Int64Type::to_byte_array(&data[..]);
-        test_plain_skip::<Int64Type>(
-            ByteBufferPtr::new(data_bytes),
-            3,
-            2,
-            -1,
-            &data[2..],
-        );
+        test_plain_skip::<Int64Type>(Bytes::from(data_bytes), 3, 2, -1, &data[2..]);
     }
 
     #[test]
     fn test_plain_skip_all_int64() {
-        let data = vec![42, 18, 52];
+        let data = [42, 18, 52];
         let data_bytes = Int64Type::to_byte_array(&data[..]);
-        test_plain_skip::<Int64Type>(ByteBufferPtr::new(data_bytes), 3, 3, -1, &[]);
+        test_plain_skip::<Int64Type>(Bytes::from(data_bytes), 3, 3, -1, &[]);
     }
 
     #[test]
     fn test_plain_decode_float() {
-        let data = vec![3.14, 2.414, 12.51];
+        let data = [PI_f32, 2.414, 12.51];
         let data_bytes = FloatType::to_byte_array(&data[..]);
-        let mut buffer = vec![0.0; 3];
-        test_plain_decode::<FloatType>(
-            ByteBufferPtr::new(data_bytes),
-            3,
-            -1,
-            &mut buffer[..],
-            &data[..],
-        );
+        let mut buffer = [0.0; 3];
+        test_plain_decode::<FloatType>(Bytes::from(data_bytes), 3, -1, &mut buffer[..], &data[..]);
     }
 
     #[test]
     fn test_plain_skip_float() {
-        let data = vec![3.14, 2.414, 12.51];
+        let data = [PI_f32, 2.414, 12.51];
         let data_bytes = FloatType::to_byte_array(&data[..]);
-        test_plain_skip::<FloatType>(
-            ByteBufferPtr::new(data_bytes),
-            3,
-            1,
-            -1,
-            &data[1..],
-        );
+        test_plain_skip::<FloatType>(Bytes::from(data_bytes), 3, 1, -1, &data[1..]);
     }
 
     #[test]
     fn test_plain_skip_all_float() {
-        let data = vec![3.14, 2.414, 12.51];
+        let data = [PI_f32, 2.414, 12.51];
         let data_bytes = FloatType::to_byte_array(&data[..]);
-        test_plain_skip::<FloatType>(ByteBufferPtr::new(data_bytes), 3, 4, -1, &[]);
+        test_plain_skip::<FloatType>(Bytes::from(data_bytes), 3, 4, -1, &[]);
     }
 
     #[test]
     fn test_plain_skip_double() {
-        let data = vec![3.14f64, 2.414f64, 12.51f64];
+        let data = [PI_f64, 2.414f64, 12.51f64];
         let data_bytes = DoubleType::to_byte_array(&data[..]);
-        test_plain_skip::<DoubleType>(
-            ByteBufferPtr::new(data_bytes),
-            3,
-            1,
-            -1,
-            &data[1..],
-        );
+        test_plain_skip::<DoubleType>(Bytes::from(data_bytes), 3, 1, -1, &data[1..]);
     }
 
     #[test]
     fn test_plain_skip_all_double() {
-        let data = vec![3.14f64, 2.414f64, 12.51f64];
+        let data = [PI_f64, 2.414f64, 12.51f64];
         let data_bytes = DoubleType::to_byte_array(&data[..]);
-        test_plain_skip::<DoubleType>(ByteBufferPtr::new(data_bytes), 3, 5, -1, &[]);
+        test_plain_skip::<DoubleType>(Bytes::from(data_bytes), 3, 5, -1, &[]);
     }
 
     #[test]
     fn test_plain_decode_double() {
-        let data = vec![3.14f64, 2.414f64, 12.51f64];
+        let data = [PI_f64, 2.414f64, 12.51f64];
         let data_bytes = DoubleType::to_byte_array(&data[..]);
-        let mut buffer = vec![0.0f64; 3];
-        test_plain_decode::<DoubleType>(
-            ByteBufferPtr::new(data_bytes),
-            3,
-            -1,
-            &mut buffer[..],
-            &data[..],
-        );
+        let mut buffer = [0.0f64; 3];
+        test_plain_decode::<DoubleType>(Bytes::from(data_bytes), 3, -1, &mut buffer[..], &data[..]);
     }
 
     #[test]
     fn test_plain_decode_int96() {
-        let mut data = vec![Int96::new(); 4];
+        let mut data = [Int96::new(); 4];
         data[0].set_data(11, 22, 33);
         data[1].set_data(44, 55, 66);
         data[2].set_data(10, 20, 30);
         data[3].set_data(40, 50, 60);
         let data_bytes = Int96Type::to_byte_array(&data[..]);
-        let mut buffer = vec![Int96::new(); 4];
-        test_plain_decode::<Int96Type>(
-            ByteBufferPtr::new(data_bytes),
-            4,
-            -1,
-            &mut buffer[..],
-            &data[..],
-        );
+        let mut buffer = [Int96::new(); 4];
+        test_plain_decode::<Int96Type>(Bytes::from(data_bytes), 4, -1, &mut buffer[..], &data[..]);
     }
 
     #[test]
     fn test_plain_skip_int96() {
-        let mut data = vec![Int96::new(); 4];
+        let mut data = [Int96::new(); 4];
         data[0].set_data(11, 22, 33);
         data[1].set_data(44, 55, 66);
         data[2].set_data(10, 20, 30);
         data[3].set_data(40, 50, 60);
         let data_bytes = Int96Type::to_byte_array(&data[..]);
-        test_plain_skip::<Int96Type>(
-            ByteBufferPtr::new(data_bytes),
-            4,
-            2,
-            -1,
-            &data[2..],
-        );
+        test_plain_skip::<Int96Type>(Bytes::from(data_bytes), 4, 2, -1, &data[2..]);
     }
 
     #[test]
     fn test_plain_skip_all_int96() {
-        let mut data = vec![Int96::new(); 4];
+        let mut data = [Int96::new(); 4];
         data[0].set_data(11, 22, 33);
         data[1].set_data(44, 55, 66);
         data[2].set_data(10, 20, 30);
         data[3].set_data(40, 50, 60);
         let data_bytes = Int96Type::to_byte_array(&data[..]);
-        test_plain_skip::<Int96Type>(ByteBufferPtr::new(data_bytes), 4, 8, -1, &[]);
+        test_plain_skip::<Int96Type>(Bytes::from(data_bytes), 4, 8, -1, &[]);
     }
 
     #[test]
     fn test_plain_decode_bool() {
-        let data = vec![
+        let data = [
             false, true, false, false, true, false, true, true, false, true,
         ];
         let data_bytes = BoolType::to_byte_array(&data[..]);
-        let mut buffer = vec![false; 10];
-        test_plain_decode::<BoolType>(
-            ByteBufferPtr::new(data_bytes),
-            10,
-            -1,
-            &mut buffer[..],
-            &data[..],
-        );
+        let mut buffer = [false; 10];
+        test_plain_decode::<BoolType>(Bytes::from(data_bytes), 10, -1, &mut buffer[..], &data[..]);
     }
 
     #[test]
     fn test_plain_skip_bool() {
-        let data = vec![
+        let data = [
             false, true, false, false, true, false, true, true, false, true,
         ];
         let data_bytes = BoolType::to_byte_array(&data[..]);
-        test_plain_skip::<BoolType>(
-            ByteBufferPtr::new(data_bytes),
-            10,
-            5,
-            -1,
-            &data[5..],
-        );
+        test_plain_skip::<BoolType>(Bytes::from(data_bytes), 10, 5, -1, &data[5..]);
     }
 
     #[test]
     fn test_plain_skip_all_bool() {
-        let data = vec![
+        let data = [
             false, true, false, false, true, false, true, true, false, true,
         ];
         let data_bytes = BoolType::to_byte_array(&data[..]);
-        test_plain_skip::<BoolType>(ByteBufferPtr::new(data_bytes), 10, 20, -1, &[]);
+        test_plain_skip::<BoolType>(Bytes::from(data_bytes), 10, 20, -1, &[]);
     }
 
     #[test]
     fn test_plain_decode_byte_array() {
         let mut data = vec![ByteArray::new(); 2];
-        data[0].set_data(ByteBufferPtr::new(String::from("hello").into_bytes()));
-        data[1].set_data(ByteBufferPtr::new(String::from("parquet").into_bytes()));
+        data[0].set_data(Bytes::from(String::from("hello")));
+        data[1].set_data(Bytes::from(String::from("parquet")));
         let data_bytes = ByteArrayType::to_byte_array(&data[..]);
         let mut buffer = vec![ByteArray::new(); 2];
         test_plain_decode::<ByteArrayType>(
-            ByteBufferPtr::new(data_bytes),
+            Bytes::from(data_bytes),
             2,
             -1,
             &mut buffer[..],
@@ -1385,37 +1331,31 @@ mod tests {
     #[test]
     fn test_plain_skip_byte_array() {
         let mut data = vec![ByteArray::new(); 2];
-        data[0].set_data(ByteBufferPtr::new(String::from("hello").into_bytes()));
-        data[1].set_data(ByteBufferPtr::new(String::from("parquet").into_bytes()));
+        data[0].set_data(Bytes::from(String::from("hello")));
+        data[1].set_data(Bytes::from(String::from("parquet")));
         let data_bytes = ByteArrayType::to_byte_array(&data[..]);
-        test_plain_skip::<ByteArrayType>(
-            ByteBufferPtr::new(data_bytes),
-            2,
-            1,
-            -1,
-            &data[1..],
-        );
+        test_plain_skip::<ByteArrayType>(Bytes::from(data_bytes), 2, 1, -1, &data[1..]);
     }
 
     #[test]
     fn test_plain_skip_all_byte_array() {
         let mut data = vec![ByteArray::new(); 2];
-        data[0].set_data(ByteBufferPtr::new(String::from("hello").into_bytes()));
-        data[1].set_data(ByteBufferPtr::new(String::from("parquet").into_bytes()));
+        data[0].set_data(Bytes::from(String::from("hello")));
+        data[1].set_data(Bytes::from(String::from("parquet")));
         let data_bytes = ByteArrayType::to_byte_array(&data[..]);
-        test_plain_skip::<ByteArrayType>(ByteBufferPtr::new(data_bytes), 2, 2, -1, &[]);
+        test_plain_skip::<ByteArrayType>(Bytes::from(data_bytes), 2, 2, -1, &[]);
     }
 
     #[test]
     fn test_plain_decode_fixed_len_byte_array() {
         let mut data = vec![FixedLenByteArray::default(); 3];
-        data[0].set_data(ByteBufferPtr::new(String::from("bird").into_bytes()));
-        data[1].set_data(ByteBufferPtr::new(String::from("come").into_bytes()));
-        data[2].set_data(ByteBufferPtr::new(String::from("flow").into_bytes()));
+        data[0].set_data(Bytes::from(String::from("bird")));
+        data[1].set_data(Bytes::from(String::from("come")));
+        data[2].set_data(Bytes::from(String::from("flow")));
         let data_bytes = FixedLenByteArrayType::to_byte_array(&data[..]);
         let mut buffer = vec![FixedLenByteArray::default(); 3];
         test_plain_decode::<FixedLenByteArrayType>(
-            ByteBufferPtr::new(data_bytes),
+            Bytes::from(data_bytes),
             3,
             4,
             &mut buffer[..],
@@ -1426,37 +1366,25 @@ mod tests {
     #[test]
     fn test_plain_skip_fixed_len_byte_array() {
         let mut data = vec![FixedLenByteArray::default(); 3];
-        data[0].set_data(ByteBufferPtr::new(String::from("bird").into_bytes()));
-        data[1].set_data(ByteBufferPtr::new(String::from("come").into_bytes()));
-        data[2].set_data(ByteBufferPtr::new(String::from("flow").into_bytes()));
+        data[0].set_data(Bytes::from(String::from("bird")));
+        data[1].set_data(Bytes::from(String::from("come")));
+        data[2].set_data(Bytes::from(String::from("flow")));
         let data_bytes = FixedLenByteArrayType::to_byte_array(&data[..]);
-        test_plain_skip::<FixedLenByteArrayType>(
-            ByteBufferPtr::new(data_bytes),
-            3,
-            1,
-            4,
-            &data[1..],
-        );
+        test_plain_skip::<FixedLenByteArrayType>(Bytes::from(data_bytes), 3, 1, 4, &data[1..]);
     }
 
     #[test]
     fn test_plain_skip_all_fixed_len_byte_array() {
         let mut data = vec![FixedLenByteArray::default(); 3];
-        data[0].set_data(ByteBufferPtr::new(String::from("bird").into_bytes()));
-        data[1].set_data(ByteBufferPtr::new(String::from("come").into_bytes()));
-        data[2].set_data(ByteBufferPtr::new(String::from("flow").into_bytes()));
+        data[0].set_data(Bytes::from(String::from("bird")));
+        data[1].set_data(Bytes::from(String::from("come")));
+        data[2].set_data(Bytes::from(String::from("flow")));
         let data_bytes = FixedLenByteArrayType::to_byte_array(&data[..]);
-        test_plain_skip::<FixedLenByteArrayType>(
-            ByteBufferPtr::new(data_bytes),
-            3,
-            6,
-            4,
-            &[],
-        );
+        test_plain_skip::<FixedLenByteArrayType>(Bytes::from(data_bytes), 3, 6, 4, &[]);
     }
 
     fn test_plain_decode<T: DataType>(
-        data: ByteBufferPtr,
+        data: Bytes,
         num_values: usize,
         type_length: i32,
         buffer: &mut [T::T],
@@ -1472,7 +1400,7 @@ mod tests {
     }
 
     fn test_plain_skip<T: DataType>(
-        data: ByteBufferPtr,
+        data: Bytes,
         num_values: usize,
         skip: usize,
         type_length: i32,
@@ -1500,7 +1428,7 @@ mod tests {
     }
 
     fn test_plain_decode_spaced<T: DataType>(
-        data: ByteBufferPtr,
+        data: Bytes,
         num_values: usize,
         type_length: i32,
         buffer: &mut [T::T],
@@ -1529,9 +1457,7 @@ mod tests {
     #[should_panic(expected = "RleValueDecoder only supports BoolType")]
     fn test_rle_value_decode_int32_not_supported() {
         let mut decoder = RleValueDecoder::<Int32Type>::new();
-        decoder
-            .set_data(ByteBufferPtr::new(vec![5, 0, 0, 0]), 1)
-            .unwrap();
+        decoder.set_data(Bytes::from(vec![5, 0, 0, 0]), 1).unwrap();
     }
 
     #[test]
@@ -1571,8 +1497,8 @@ mod tests {
     #[test]
     fn test_delta_bit_packed_int32_repeat() {
         let block_data = vec![
-            1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2,
-            3, 4, 5, 6, 7, 8,
+            1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5,
+            6, 7, 8,
         ];
         test_delta_bit_packed_decode::<Int32Type>(vec![block_data]);
     }
@@ -1580,8 +1506,8 @@ mod tests {
     #[test]
     fn test_skip_delta_bit_packed_int32_repeat() {
         let block_data = vec![
-            1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2,
-            3, 4, 5, 6, 7, 8,
+            1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5,
+            6, 7, 8,
         ];
         test_skip::<Int32Type>(block_data.clone(), Encoding::DELTA_BINARY_PACKED, 10);
         test_skip::<Int32Type>(block_data, Encoding::DELTA_BINARY_PACKED, 100);
@@ -1603,14 +1529,13 @@ mod tests {
     #[test]
     fn test_delta_bit_packed_int32_same_values() {
         let block_data = vec![
-            127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
-            127,
+            127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
         ];
         test_delta_bit_packed_decode::<Int32Type>(vec![block_data]);
 
         let block_data = vec![
-            -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127,
-            -127, -127, -127,
+            -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127,
+            -127, -127,
         ];
         test_delta_bit_packed_decode::<Int32Type>(vec![block_data]);
     }
@@ -1618,15 +1543,14 @@ mod tests {
     #[test]
     fn test_skip_delta_bit_packed_int32_same_values() {
         let block_data = vec![
-            127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
-            127,
+            127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
         ];
         test_skip::<Int32Type>(block_data.clone(), Encoding::DELTA_BINARY_PACKED, 5);
         test_skip::<Int32Type>(block_data, Encoding::DELTA_BINARY_PACKED, 100);
 
         let block_data = vec![
-            -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127,
-            -127, -127, -127,
+            -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127, -127,
+            -127, -127,
         ];
         test_skip::<Int32Type>(block_data.clone(), Encoding::DELTA_BINARY_PACKED, 5);
         test_skip::<Int32Type>(block_data, Encoding::DELTA_BINARY_PACKED, 100);
@@ -1726,12 +1650,11 @@ mod tests {
     #[test]
     fn test_delta_bit_packed_decoder_sample() {
         let data_bytes = vec![
-            128, 1, 4, 3, 58, 28, 6, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-            0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            128, 1, 4, 3, 58, 28, 6, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+            0, 0, 0, 0, 0, 0,
         ];
-        let buffer = ByteBufferPtr::new(data_bytes);
         let mut decoder: DeltaBitPackDecoder<Int32Type> = DeltaBitPackDecoder::new();
-        decoder.set_data(buffer, 3).unwrap();
+        decoder.set_data(data_bytes.into(), 3).unwrap();
         // check exact offsets, because when reading partial values we end up with
         // some data not being read from bit reader
         assert_eq!(decoder.get_offset(), 5);
@@ -1793,7 +1716,7 @@ mod tests {
 
         let length = data.len();
 
-        let ptr = ByteBufferPtr::new(data);
+        let ptr = Bytes::from(data);
         let mut reader = BitReader::new(ptr.clone());
         assert_eq!(reader.get_vlq_int().unwrap(), 256);
         assert_eq!(reader.get_vlq_int().unwrap(), 4);
@@ -1809,7 +1732,7 @@ mod tests {
         assert_eq!(decoder.get_offset(), length);
 
         // Test with truncated buffer
-        decoder.set_data(ptr.range(0, 12), 0).unwrap();
+        decoder.set_data(ptr.slice(..12), 0).unwrap();
         let err = decoder.get(&mut output).unwrap_err().to_string();
         assert!(
             err.contains("Expected to read 64 values from miniblock got 8"),
@@ -1853,6 +1776,38 @@ mod tests {
         test_delta_byte_array_decode(data);
     }
 
+    #[test]
+    fn test_byte_stream_split_multiple_f32() {
+        let data = vec![
+            vec![
+                f32::from_le_bytes([0xAA, 0xBB, 0xCC, 0xDD]),
+                f32::from_le_bytes([0x00, 0x11, 0x22, 0x33]),
+            ],
+            vec![f32::from_le_bytes([0xA3, 0xB4, 0xC5, 0xD6])],
+        ];
+        test_byte_stream_split_decode::<FloatType>(data);
+    }
+
+    #[test]
+    fn test_byte_stream_split_f64() {
+        let data = vec![vec![
+            f64::from_le_bytes([0, 1, 2, 3, 4, 5, 6, 7]),
+            f64::from_le_bytes([8, 9, 10, 11, 12, 13, 14, 15]),
+        ]];
+        test_byte_stream_split_decode::<DoubleType>(data);
+    }
+
+    #[test]
+    fn test_skip_byte_stream_split() {
+        let block_data = vec![0.3, 0.4, 0.1, 4.10];
+        test_skip::<FloatType>(block_data.clone(), Encoding::BYTE_STREAM_SPLIT, 2);
+        test_skip::<DoubleType>(
+            block_data.into_iter().map(|x| x as f64).collect(),
+            Encoding::BYTE_STREAM_SPLIT,
+            100,
+        );
+    }
+
     fn test_rle_value_decode<T: DataType>(data: Vec<Vec<T::T>>) {
         test_encode_decode::<T>(data, Encoding::RLE);
     }
@@ -1861,6 +1816,10 @@ mod tests {
         test_encode_decode::<T>(data, Encoding::DELTA_BINARY_PACKED);
     }
 
+    fn test_byte_stream_split_decode<T: DataType>(data: Vec<Vec<T::T>>) {
+        test_encode_decode::<T>(data, Encoding::BYTE_STREAM_SPLIT);
+    }
+
     fn test_delta_byte_array_decode(data: Vec<Vec<ByteArray>>) {
         test_encode_decode::<ByteArrayType>(data, Encoding::DELTA_BYTE_ARRAY);
     }
@@ -1937,19 +1896,17 @@ mod tests {
         }
     }
 
-    fn create_and_check_decoder<T: DataType>(
-        encoding: Encoding,
-        err: Option<ParquetError>,
-    ) {
+    fn create_and_check_decoder<T: DataType>(encoding: Encoding, err: Option<ParquetError>) {
         let descr = create_test_col_desc_ptr(-1, T::get_physical_type());
         let decoder = get_decoder::<T>(descr, encoding);
         match err {
             Some(parquet_error) => {
-                assert!(decoder.is_err());
-                assert_eq!(decoder.err().unwrap(), parquet_error);
+                assert_eq!(
+                    decoder.err().unwrap().to_string(),
+                    parquet_error.to_string()
+                );
             }
             None => {
-                assert!(decoder.is_ok());
                 assert_eq!(decoder.unwrap().encoding(), encoding);
             }
         }
diff --git a/parquet/src/encodings/decoding/byte_stream_split_decoder.rs b/parquet/src/encodings/decoding/byte_stream_split_decoder.rs
new file mode 100644
index 000000000000..98841d21ec9e
--- /dev/null
+++ b/parquet/src/encodings/decoding/byte_stream_split_decoder.rs
@@ -0,0 +1,121 @@
+// 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.
+
+use std::marker::PhantomData;
+
+use bytes::Bytes;
+
+use crate::basic::Encoding;
+use crate::data_type::{DataType, SliceAsBytes};
+use crate::errors::{ParquetError, Result};
+
+use super::Decoder;
+
+pub struct ByteStreamSplitDecoder<T: DataType> {
+    _phantom: PhantomData<T>,
+    encoded_bytes: Bytes,
+    total_num_values: usize,
+    values_decoded: usize,
+}
+
+impl<T: DataType> ByteStreamSplitDecoder<T> {
+    pub(crate) fn new() -> Self {
+        Self {
+            _phantom: PhantomData,
+            encoded_bytes: Bytes::new(),
+            total_num_values: 0,
+            values_decoded: 0,
+        }
+    }
+}
+
+// Here we assume src contains the full data (which it must, since we're
+// can only know where to split the streams once all data is collected),
+// but dst can be just a slice starting from the given index.
+// We iterate over the output bytes and fill them in from their strided
+// input byte locations.
+fn join_streams_const<const TYPE_SIZE: usize>(
+    src: &[u8],
+    dst: &mut [u8],
+    stride: usize,
+    values_decoded: usize,
+) {
+    let sub_src = &src[values_decoded..];
+    for i in 0..dst.len() / TYPE_SIZE {
+        for j in 0..TYPE_SIZE {
+            dst[i * TYPE_SIZE + j] = sub_src[i + j * stride];
+        }
+    }
+}
+
+impl<T: DataType> Decoder<T> for ByteStreamSplitDecoder<T> {
+    fn set_data(&mut self, data: Bytes, num_values: usize) -> Result<()> {
+        self.encoded_bytes = data;
+        self.total_num_values = num_values;
+        self.values_decoded = 0;
+
+        Ok(())
+    }
+
+    fn get(&mut self, buffer: &mut [<T as DataType>::T]) -> Result<usize> {
+        let total_remaining_values = self.values_left();
+        let num_values = buffer.len().min(total_remaining_values);
+        let buffer = &mut buffer[..num_values];
+
+        // SAFETY: f32 and f64 has no constraints on their internal representation, so we can modify it as we want
+        let raw_out_bytes = unsafe { <T as DataType>::T::slice_as_bytes_mut(buffer) };
+        let type_size = T::get_type_size();
+        let stride = self.encoded_bytes.len() / type_size;
+        match type_size {
+            4 => join_streams_const::<4>(
+                &self.encoded_bytes,
+                raw_out_bytes,
+                stride,
+                self.values_decoded,
+            ),
+            8 => join_streams_const::<8>(
+                &self.encoded_bytes,
+                raw_out_bytes,
+                stride,
+                self.values_decoded,
+            ),
+            _ => {
+                return Err(general_err!(
+                    "byte stream split unsupported for data types of size {} bytes",
+                    type_size
+                ));
+            }
+        }
+        self.values_decoded += num_values;
+
+        Ok(num_values)
+    }
+
+    fn values_left(&self) -> usize {
+        self.total_num_values - self.values_decoded
+    }
+
+    fn encoding(&self) -> Encoding {
+        Encoding::BYTE_STREAM_SPLIT
+    }
+
+    fn skip(&mut self, num_values: usize) -> Result<usize> {
+        let to_skip = usize::min(self.values_left(), num_values);
+        self.values_decoded += to_skip;
+        Ok(to_skip)
+    }
+}
diff --git a/parquet/src/encodings/encoding/byte_stream_split_encoder.rs b/parquet/src/encodings/encoding/byte_stream_split_encoder.rs
new file mode 100644
index 000000000000..a95487041cee
--- /dev/null
+++ b/parquet/src/encodings/encoding/byte_stream_split_encoder.rs
@@ -0,0 +1,93 @@
+// 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.
+
+use crate::basic::{Encoding, Type};
+use crate::data_type::DataType;
+use crate::data_type::SliceAsBytes;
+
+use crate::errors::{ParquetError, Result};
+
+use super::Encoder;
+
+use bytes::Bytes;
+use std::marker::PhantomData;
+
+pub struct ByteStreamSplitEncoder<T> {
+    buffer: Vec<u8>,
+    _p: PhantomData<T>,
+}
+
+impl<T: DataType> ByteStreamSplitEncoder<T> {
+    pub(crate) fn new() -> Self {
+        Self {
+            buffer: Vec::new(),
+            _p: PhantomData,
+        }
+    }
+}
+
+// Here we assume src contains the full data (which it must, since we're
+// can only know where to split the streams once all data is collected).
+// We iterate over the input bytes and write them to their strided output
+// byte locations.
+fn split_streams_const<const TYPE_SIZE: usize>(src: &[u8], dst: &mut [u8]) {
+    let stride = src.len() / TYPE_SIZE;
+    for i in 0..stride {
+        for j in 0..TYPE_SIZE {
+            dst[i + j * stride] = src[i * TYPE_SIZE + j];
+        }
+    }
+}
+
+impl<T: DataType> Encoder<T> for ByteStreamSplitEncoder<T> {
+    fn put(&mut self, values: &[T::T]) -> Result<()> {
+        self.buffer
+            .extend(<T as DataType>::T::slice_as_bytes(values));
+        ensure_phys_ty!(
+            Type::FLOAT | Type::DOUBLE,
+            "ByteStreamSplitEncoder only supports FloatType or DoubleType"
+        );
+
+        Ok(())
+    }
+
+    fn encoding(&self) -> Encoding {
+        Encoding::BYTE_STREAM_SPLIT
+    }
+
+    fn estimated_data_encoded_size(&self) -> usize {
+        self.buffer.len()
+    }
+
+    fn flush_buffer(&mut self) -> Result<Bytes> {
+        let mut encoded = vec![0; self.buffer.len()];
+        let type_size = T::get_type_size();
+        match type_size {
+            4 => split_streams_const::<4>(&self.buffer, &mut encoded),
+            8 => split_streams_const::<8>(&self.buffer, &mut encoded),
+            _ => {
+                return Err(general_err!(
+                    "byte stream split unsupported for data types of size {} bytes",
+                    type_size
+                ));
+            }
+        }
+
+        self.buffer.clear();
+        Ok(encoded.into())
+    }
+}
diff --git a/parquet/src/encodings/encoding/dict_encoder.rs b/parquet/src/encodings/encoding/dict_encoder.rs
index 18deba65e687..dafae064afbf 100644
--- a/parquet/src/encodings/encoding/dict_encoder.rs
+++ b/parquet/src/encodings/encoding/dict_encoder.rs
@@ -18,6 +18,8 @@
 // ----------------------------------------------------------------------
 // Dictionary encoding
 
+use bytes::Bytes;
+
 use crate::basic::{Encoding, Type};
 use crate::data_type::private::ParquetValueType;
 use crate::data_type::DataType;
@@ -27,7 +29,6 @@ use crate::errors::Result;
 use crate::schema::types::ColumnDescPtr;
 use crate::util::bit_util::num_required_bits;
 use crate::util::interner::{Interner, Storage};
-use crate::util::memory::ByteBufferPtr;
 
 #[derive(Debug)]
 struct KeyStorage<T: DataType> {
@@ -112,7 +113,7 @@ impl<T: DataType> DictEncoder<T> {
 
     /// Writes out the dictionary values with PLAIN encoding in a byte buffer, and return
     /// the result.
-    pub fn write_dict(&self) -> Result<ByteBufferPtr> {
+    pub fn write_dict(&self) -> Result<Bytes> {
         let mut plain_encoder = PlainEncoder::<T>::new();
         plain_encoder.put(&self.interner.storage().uniques)?;
         plain_encoder.flush_buffer()
@@ -120,18 +121,18 @@ impl<T: DataType> DictEncoder<T> {
 
     /// Writes out the dictionary values with RLE encoding in a byte buffer, and return
     /// the result.
-    pub fn write_indices(&mut self) -> Result<ByteBufferPtr> {
+    pub fn write_indices(&mut self) -> Result<Bytes> {
         let buffer_len = self.estimated_data_encoded_size();
         let mut buffer = Vec::with_capacity(buffer_len);
-        buffer.push(self.bit_width() as u8);
+        buffer.push(self.bit_width());
 
         // Write bit width in the first byte
         let mut encoder = RleEncoder::new_from_buf(self.bit_width(), buffer);
         for index in &self.indices {
-            encoder.put(*index as u64)
+            encoder.put(*index)
         }
         self.indices.clear();
-        Ok(ByteBufferPtr::new(encoder.consume()))
+        Ok(encoder.consume().into())
     }
 
     fn put_one(&mut self, value: &T::T) {
@@ -162,11 +163,10 @@ impl<T: DataType> Encoder<T> for DictEncoder<T> {
 
     fn estimated_data_encoded_size(&self) -> usize {
         let bit_width = self.bit_width();
-        1 + RleEncoder::min_buffer_size(bit_width)
-            + RleEncoder::max_buffer_size(bit_width, self.indices.len())
+        RleEncoder::max_buffer_size(bit_width, self.indices.len())
     }
 
-    fn flush_buffer(&mut self) -> Result<ByteBufferPtr> {
+    fn flush_buffer(&mut self) -> Result<Bytes> {
         self.write_indices()
     }
 }
diff --git a/parquet/src/encodings/encoding/mod.rs b/parquet/src/encodings/encoding/mod.rs
index 050f1b9f8a63..9099187a545c 100644
--- a/parquet/src/encodings/encoding/mod.rs
+++ b/parquet/src/encodings/encoding/mod.rs
@@ -24,13 +24,12 @@ use crate::data_type::private::ParquetValueType;
 use crate::data_type::*;
 use crate::encodings::rle::RleEncoder;
 use crate::errors::{ParquetError, Result};
-use crate::util::{
-    bit_util::{self, num_required_bits, BitWriter},
-    memory::ByteBufferPtr,
-};
+use crate::util::bit_util::{self, num_required_bits, BitWriter};
 
+use bytes::Bytes;
 pub use dict_encoder::DictEncoder;
 
+mod byte_stream_split_encoder;
 mod dict_encoder;
 
 // ----------------------------------------------------------------------
@@ -40,7 +39,7 @@ mod dict_encoder;
 ///
 /// Currently this allocates internal buffers for the encoded values. After done putting
 /// values, caller should call `flush_buffer()` to get an immutable buffer pointer.
-pub trait Encoder<T: DataType> {
+pub trait Encoder<T: DataType>: Send {
     /// Encodes data from `values`.
     fn put(&mut self, values: &[T::T]) -> Result<()>;
 
@@ -70,7 +69,7 @@ pub trait Encoder<T: DataType> {
 
     /// Flushes the underlying byte buffer that's being processed by this encoder, and
     /// return the immutable copy of it. This will also reset the internal state.
-    fn flush_buffer(&mut self) -> Result<ByteBufferPtr>;
+    fn flush_buffer(&mut self) -> Result<Bytes>;
 }
 
 /// Gets a encoder for the particular data type `T` and encoding `encoding`. Memory usage
@@ -87,6 +86,9 @@ pub fn get_encoder<T: DataType>(encoding: Encoding) -> Result<Box<dyn Encoder<T>
         Encoding::DELTA_BINARY_PACKED => Box::new(DeltaBitPackEncoder::new()),
         Encoding::DELTA_LENGTH_BYTE_ARRAY => Box::new(DeltaLengthByteArrayEncoder::new()),
         Encoding::DELTA_BYTE_ARRAY => Box::new(DeltaByteArrayEncoder::new()),
+        Encoding::BYTE_STREAM_SPLIT => {
+            Box::new(byte_stream_split_encoder::ByteStreamSplitEncoder::new())
+        }
         e => return Err(nyi_err!("Encoding {} is not supported", e)),
     };
     Ok(encoder)
@@ -143,7 +145,7 @@ impl<T: DataType> Encoder<T> for PlainEncoder<T> {
     }
 
     #[inline]
-    fn flush_buffer(&mut self) -> Result<ByteBufferPtr> {
+    fn flush_buffer(&mut self) -> Result<Bytes> {
         self.buffer
             .extend_from_slice(self.bit_writer.flush_buffer());
         self.bit_writer.clear();
@@ -223,7 +225,7 @@ impl<T: DataType> Encoder<T> for RleValueEncoder<T> {
     }
 
     #[inline]
-    fn flush_buffer(&mut self) -> Result<ByteBufferPtr> {
+    fn flush_buffer(&mut self) -> Result<Bytes> {
         ensure_phys_ty!(Type::BOOLEAN, "RleValueEncoder only supports BoolType");
         let rle_encoder = self
             .encoder
@@ -232,13 +234,13 @@ impl<T: DataType> Encoder<T> for RleValueEncoder<T> {
 
         // Flush all encoder buffers and raw values
         let mut buf = rle_encoder.consume();
-        assert!(buf.len() > 4, "should have had padding inserted");
+        assert!(buf.len() >= 4, "should have had padding inserted");
 
         // Note that buf does not have any offset, all data is encoded bytes
         let len = (buf.len() - 4) as i32;
         buf[..4].copy_from_slice(&len.to_le_bytes());
 
-        Ok(ByteBufferPtr::new(buf))
+        Ok(buf.into())
     }
 }
 
@@ -378,19 +380,17 @@ impl<T: DataType> DeltaBitPackEncoder<T> {
             // Compute the max delta in current mini block
             let mut max_delta = i64::MIN;
             for j in 0..n {
-                max_delta =
-                    cmp::max(max_delta, self.deltas[i * self.mini_block_size + j]);
+                max_delta = cmp::max(max_delta, self.deltas[i * self.mini_block_size + j]);
             }
 
             // Compute bit width to store (max_delta - min_delta)
-            let bit_width =
-                num_required_bits(self.subtract_u64(max_delta, min_delta)) as usize;
+            let bit_width = num_required_bits(self.subtract_u64(max_delta, min_delta)) as usize;
             self.bit_writer.write_at(offset + i, bit_width as u8);
 
             // Encode values in current mini block using min_delta and bit_width
             for j in 0..n {
-                let packed_value = self
-                    .subtract_u64(self.deltas[i * self.mini_block_size + j], min_delta);
+                let packed_value =
+                    self.subtract_u64(self.deltas[i * self.mini_block_size + j], min_delta);
                 self.bit_writer.put_value(packed_value, bit_width);
             }
 
@@ -456,7 +456,7 @@ impl<T: DataType> Encoder<T> for DeltaBitPackEncoder<T> {
         self.bit_writer.bytes_written()
     }
 
-    fn flush_buffer(&mut self) -> Result<ByteBufferPtr> {
+    fn flush_buffer(&mut self) -> Result<Bytes> {
         // Write remaining values
         self.flush_block_values()?;
         // Write page header with total values
@@ -574,8 +574,7 @@ impl<T: DataType> Encoder<T> for DeltaLengthByteArrayEncoder<T> {
                 .map(|x| x.as_any().downcast_ref::<ByteArray>().unwrap())
         };
 
-        let lengths: Vec<i32> =
-            val_it().map(|byte_array| byte_array.len() as i32).collect();
+        let lengths: Vec<i32> = val_it().map(|byte_array| byte_array.len() as i32).collect();
         self.len_encoder.put(&lengths)?;
         for byte_array in val_it() {
             self.encoded_size += byte_array.len();
@@ -597,7 +596,7 @@ impl<T: DataType> Encoder<T> for DeltaLengthByteArrayEncoder<T> {
         self.len_encoder.estimated_data_encoded_size() + self.encoded_size
     }
 
-    fn flush_buffer(&mut self) -> Result<ByteBufferPtr> {
+    fn flush_buffer(&mut self) -> Result<Bytes> {
         ensure_phys_ty!(
             Type::BYTE_ARRAY | Type::FIXED_LEN_BYTE_ARRAY,
             "DeltaLengthByteArrayEncoder only supports ByteArrayType"
@@ -605,14 +604,14 @@ impl<T: DataType> Encoder<T> for DeltaLengthByteArrayEncoder<T> {
 
         let mut total_bytes = vec![];
         let lengths = self.len_encoder.flush_buffer()?;
-        total_bytes.extend_from_slice(lengths.data());
+        total_bytes.extend_from_slice(&lengths);
         self.data.iter().for_each(|byte_array| {
             total_bytes.extend_from_slice(byte_array.data());
         });
         self.data.clear();
         self.encoded_size = 0;
 
-        Ok(ByteBufferPtr::new(total_bytes))
+        Ok(total_bytes.into())
     }
 }
 
@@ -651,14 +650,15 @@ impl<T: DataType> Encoder<T> for DeltaByteArrayEncoder<T> {
         let mut prefix_lengths: Vec<i32> = vec![];
         let mut suffixes: Vec<ByteArray> = vec![];
 
-        let values = values.iter()
+        let values = values
+            .iter()
             .map(|x| x.as_any())
             .map(|x| match T::get_physical_type() {
                 Type::BYTE_ARRAY => x.downcast_ref::<ByteArray>().unwrap(),
                 Type::FIXED_LEN_BYTE_ARRAY => x.downcast_ref::<FixedLenByteArray>().unwrap(),
                 _ => panic!(
                     "DeltaByteArrayEncoder only supports ByteArrayType and FixedLenByteArrayType"
-                )
+                ),
             });
 
         for byte_array in values {
@@ -667,8 +667,7 @@ impl<T: DataType> Encoder<T> for DeltaByteArrayEncoder<T> {
             // value
             let prefix_len = cmp::min(self.previous.len(), current.len());
             let mut match_len = 0;
-            while match_len < prefix_len && self.previous[match_len] == current[match_len]
-            {
+            while match_len < prefix_len && self.previous[match_len] == current[match_len] {
                 match_len += 1;
             }
             prefix_lengths.push(match_len as i32);
@@ -696,7 +695,7 @@ impl<T: DataType> Encoder<T> for DeltaByteArrayEncoder<T> {
             + self.suffix_writer.estimated_data_encoded_size()
     }
 
-    fn flush_buffer(&mut self) -> Result<ByteBufferPtr> {
+    fn flush_buffer(&mut self) -> Result<Bytes> {
         match T::get_physical_type() {
             Type::BYTE_ARRAY | Type::FIXED_LEN_BYTE_ARRAY => {
                 // TODO: investigate if we can merge lengths and suffixes
@@ -704,17 +703,17 @@ impl<T: DataType> Encoder<T> for DeltaByteArrayEncoder<T> {
                 let mut total_bytes = vec![];
                 // Insert lengths ...
                 let lengths = self.prefix_len_encoder.flush_buffer()?;
-                total_bytes.extend_from_slice(lengths.data());
+                total_bytes.extend_from_slice(&lengths);
                 // ... followed by suffixes
                 let suffixes = self.suffix_writer.flush_buffer()?;
-                total_bytes.extend_from_slice(suffixes.data());
+                total_bytes.extend_from_slice(&suffixes);
 
                 self.previous.clear();
-                Ok(ByteBufferPtr::new(total_bytes))
+                Ok(total_bytes.into())
             }
             _ => panic!(
                 "DeltaByteArrayEncoder only supports ByteArrayType and FixedLenByteArrayType"
-            )
+            ),
         }
     }
 }
@@ -726,9 +725,7 @@ mod tests {
     use std::sync::Arc;
 
     use crate::encodings::decoding::{get_decoder, Decoder, DictDecoder, PlainDecoder};
-    use crate::schema::types::{
-        ColumnDescPtr, ColumnDescriptor, ColumnPath, Type as SchemaType,
-    };
+    use crate::schema::types::{ColumnDescPtr, ColumnDescriptor, ColumnPath, Type as SchemaType};
     use crate::util::test_common::rand_gen::{random_bytes, RandGen};
 
     const TEST_SET_SIZE: usize = 1024;
@@ -757,6 +754,7 @@ mod tests {
         );
 
         // unsupported
+        #[allow(deprecated)]
         create_and_check_encoder::<Int32Type>(
             Encoding::BIT_PACKED,
             Some(nyi_err!("Encoding BIT_PACKED is not supported")),
@@ -794,12 +792,14 @@ mod tests {
     fn test_float() {
         FloatType::test(Encoding::PLAIN, TEST_SET_SIZE, -1);
         FloatType::test(Encoding::PLAIN_DICTIONARY, TEST_SET_SIZE, -1);
+        FloatType::test(Encoding::BYTE_STREAM_SPLIT, TEST_SET_SIZE, -1);
     }
 
     #[test]
     fn test_double() {
         DoubleType::test(Encoding::PLAIN, TEST_SET_SIZE, -1);
         DoubleType::test(Encoding::PLAIN_DICTIONARY, TEST_SET_SIZE, -1);
+        DoubleType::test(Encoding::BYTE_STREAM_SPLIT, TEST_SET_SIZE, -1);
     }
 
     #[test]
@@ -819,11 +819,7 @@ mod tests {
 
     #[test]
     fn test_dict_encoded_size() {
-        fn run_test<T: DataType>(
-            type_length: i32,
-            values: &[T::T],
-            expected_size: usize,
-        ) {
+        fn run_test<T: DataType>(type_length: i32, values: &[T::T], expected_size: usize) {
             let mut encoder = create_test_dict_encoder::<T>(type_length);
             assert_eq!(encoder.dict_encoded_size(), 0);
             encoder.put(values).unwrap();
@@ -843,13 +839,9 @@ mod tests {
         run_test::<Int96Type>(
             -1,
             &[Int96::from(vec![1, 2, 3]), Int96::from(vec![2, 3, 4])],
-            32,
-        );
-        run_test::<ByteArrayType>(
-            -1,
-            &[ByteArray::from("abcd"), ByteArray::from("efj")],
-            15,
+            24,
         );
+        run_test::<ByteArrayType>(-1, &[ByteArray::from("abcd"), ByteArray::from("efj")], 15);
         run_test::<FixedLenByteArrayType>(
             2,
             &[ByteArray::from("ab").into(), ByteArray::from("bc").into()],
@@ -888,7 +880,7 @@ mod tests {
         // DICTIONARY
         // NOTE: The final size is almost the same because the dictionary entries are
         // preserved after encoded values have been written.
-        run_test::<Int32Type>(Encoding::RLE_DICTIONARY, -1, &[123, 1024], 11, 68, 66);
+        run_test::<Int32Type>(Encoding::RLE_DICTIONARY, -1, &[123, 1024], 0, 2, 0);
 
         // DELTA_BINARY_PACKED
         run_test::<Int32Type>(Encoding::DELTA_BINARY_PACKED, -1, &[123; 1024], 0, 35, 0);
@@ -918,15 +910,45 @@ mod tests {
             3, // only suffix bytes, length encoder is not flushed yet
             0,
         );
+
+        // BYTE_STREAM_SPLIT
+        run_test::<FloatType>(Encoding::BYTE_STREAM_SPLIT, -1, &[0.1, 0.2], 0, 8, 0);
+    }
+
+    #[test]
+    fn test_byte_stream_split_example_f32() {
+        // Test data from https://github.com/apache/parquet-format/blob/2a481fe1aad64ff770e21734533bb7ef5a057dac/Encodings.md#byte-stream-split-byte_stream_split--9
+        let mut encoder = create_test_encoder::<FloatType>(Encoding::BYTE_STREAM_SPLIT);
+        let mut decoder = create_test_decoder::<FloatType>(0, Encoding::BYTE_STREAM_SPLIT);
+
+        let input = vec![
+            f32::from_le_bytes([0xAA, 0xBB, 0xCC, 0xDD]),
+            f32::from_le_bytes([0x00, 0x11, 0x22, 0x33]),
+            f32::from_le_bytes([0xA3, 0xB4, 0xC5, 0xD6]),
+        ];
+
+        encoder.put(&input).unwrap();
+        let encoded = encoder.flush_buffer().unwrap();
+
+        assert_eq!(
+            encoded,
+            Bytes::from(vec![
+                0xAA_u8, 0x00, 0xA3, 0xBB, 0x11, 0xB4, 0xCC, 0x22, 0xC5, 0xDD, 0x33, 0xD6
+            ])
+        );
+
+        let mut decoded = vec![0.0; input.len()];
+        decoder.set_data(encoded, input.len()).unwrap();
+        decoder.get(&mut decoded).unwrap();
+
+        assert_eq!(decoded, input);
     }
 
     // See: https://github.com/sunchao/parquet-rs/issues/47
     #[test]
     fn test_issue_47() {
-        let mut encoder =
-            create_test_encoder::<ByteArrayType>(Encoding::DELTA_BYTE_ARRAY);
-        let mut decoder =
-            create_test_decoder::<ByteArrayType>(0, Encoding::DELTA_BYTE_ARRAY);
+        let mut encoder = create_test_encoder::<ByteArrayType>(Encoding::DELTA_BYTE_ARRAY);
+        let mut decoder = create_test_decoder::<ByteArrayType>(0, Encoding::DELTA_BYTE_ARRAY);
 
         let input = vec![
             ByteArray::from("aa"),
@@ -937,8 +959,7 @@ mod tests {
 
         let mut output = vec![ByteArray::default(); input.len()];
 
-        let mut result =
-            put_and_get(&mut encoder, &mut decoder, &input[..2], &mut output[..2]);
+        let mut result = put_and_get(&mut encoder, &mut decoder, &input[..2], &mut output[..2]);
         assert!(
             result.is_ok(),
             "first put_and_get() failed with: {}",
@@ -1074,20 +1095,16 @@ mod tests {
         decoder.get(output)
     }
 
-    fn create_and_check_encoder<T: DataType>(
-        encoding: Encoding,
-        err: Option<ParquetError>,
-    ) {
+    fn create_and_check_encoder<T: DataType>(encoding: Encoding, err: Option<ParquetError>) {
         let encoder = get_encoder::<T>(encoding);
         match err {
             Some(parquet_error) => {
-                assert!(encoder.is_err());
-                assert_eq!(encoder.err().unwrap(), parquet_error);
-            }
-            None => {
-                assert!(encoder.is_ok());
-                assert_eq!(encoder.unwrap().encoding(), encoding);
+                assert_eq!(
+                    encoder.err().unwrap().to_string(),
+                    parquet_error.to_string()
+                )
             }
+            None => assert_eq!(encoder.unwrap().encoding(), encoding),
         }
     }
 
@@ -1109,10 +1126,7 @@ mod tests {
         get_encoder(enc).unwrap()
     }
 
-    fn create_test_decoder<T: DataType>(
-        type_len: i32,
-        enc: Encoding,
-    ) -> Box<dyn Decoder<T>> {
+    fn create_test_decoder<T: DataType>(type_len: i32, enc: Encoding) -> Box<dyn Decoder<T>> {
         let desc = create_test_col_desc_ptr(type_len, T::get_physical_type());
         get_decoder(desc, enc).unwrap()
     }
diff --git a/parquet/src/encodings/levels.rs b/parquet/src/encodings/levels.rs
index 95384926ddba..8d4e48ba16bd 100644
--- a/parquet/src/encodings/levels.rs
+++ b/parquet/src/encodings/levels.rs
@@ -15,17 +15,13 @@
 // specific language governing permissions and limitations
 // under the License.
 
-use std::{cmp, mem};
+use std::mem;
 
-use super::rle::{RleDecoder, RleEncoder};
+use super::rle::RleEncoder;
 
 use crate::basic::Encoding;
 use crate::data_type::AsBytes;
-use crate::errors::Result;
-use crate::util::{
-    bit_util::{ceil, num_required_bits, read_num_bytes, BitReader, BitWriter},
-    memory::ByteBufferPtr,
-};
+use crate::util::bit_util::{ceil, num_required_bits, BitWriter};
 
 /// Computes max buffer size for level encoder/decoder based on encoding, max
 /// repetition/definition level and number of total buffered values (includes null
@@ -38,14 +34,10 @@ pub fn max_buffer_size(
 ) -> usize {
     let bit_width = num_required_bits(max_level as u64);
     match encoding {
-        Encoding::RLE => {
-            RleEncoder::max_buffer_size(bit_width, num_buffered_values)
-                + RleEncoder::min_buffer_size(bit_width)
-        }
-        Encoding::BIT_PACKED => {
-            ceil((num_buffered_values * bit_width as usize) as i64, 8) as usize
-        }
-        _ => panic!("Unsupported encoding type {}", encoding),
+        Encoding::RLE => RleEncoder::max_buffer_size(bit_width, num_buffered_values),
+        #[allow(deprecated)]
+        Encoding::BIT_PACKED => ceil(num_buffered_values * bit_width as usize, 8),
+        _ => panic!("Unsupported encoding type {encoding}"),
     }
 }
 
@@ -75,13 +67,14 @@ impl LevelEncoder {
                 buffer.extend_from_slice(&[0; 4]);
                 LevelEncoder::Rle(RleEncoder::new_from_buf(bit_width, buffer))
             }
+            #[allow(deprecated)]
             Encoding::BIT_PACKED => {
                 // Here we set full byte buffer without adjusting for num_buffered_values,
                 // because byte buffer will already be allocated with size from
                 // `max_buffer_size()` method.
                 LevelEncoder::BitPacked(bit_width, BitWriter::new_from_buf(buffer))
             }
-            _ => panic!("Unsupported encoding type {}", encoding),
+            _ => panic!("Unsupported encoding type {encoding}"),
         }
     }
 
@@ -138,391 +131,3 @@ impl LevelEncoder {
         }
     }
 }
-
-/// Decoder for definition/repetition levels.
-/// Currently only supports RLE and BIT_PACKED encoding for Data Page v1 and
-/// RLE for Data Page v2.
-#[allow(unused)]
-pub enum LevelDecoder {
-    Rle(Option<usize>, RleDecoder),
-    RleV2(Option<usize>, RleDecoder),
-    BitPacked(Option<usize>, u8, BitReader),
-}
-
-#[allow(unused)]
-impl LevelDecoder {
-    /// Creates new level decoder based on encoding and max definition/repetition level.
-    /// This method only initializes level decoder, `set_data` method must be called
-    /// before reading any value.
-    ///
-    /// Used to encode levels for Data Page v1.
-    ///
-    /// Panics if encoding is not supported
-    pub fn v1(encoding: Encoding, max_level: i16) -> Self {
-        let bit_width = num_required_bits(max_level as u64);
-        match encoding {
-            Encoding::RLE => LevelDecoder::Rle(None, RleDecoder::new(bit_width)),
-            Encoding::BIT_PACKED => {
-                LevelDecoder::BitPacked(None, bit_width, BitReader::from(Vec::new()))
-            }
-            _ => panic!("Unsupported encoding type {}", encoding),
-        }
-    }
-
-    /// Creates new level decoder based on RLE encoding.
-    /// Used to decode Data Page v2 repetition and definition levels.
-    ///
-    /// To set data for this decoder, use `set_data_range` method.
-    pub fn v2(max_level: i16) -> Self {
-        let bit_width = num_required_bits(max_level as u64);
-        LevelDecoder::RleV2(None, RleDecoder::new(bit_width))
-    }
-
-    /// Sets data for this level decoder, and returns total number of bytes set.
-    /// This is used for Data Page v1 levels.
-    ///
-    /// `data` is encoded data as byte buffer, `num_buffered_values` represents total
-    /// number of values that is expected.
-    ///
-    /// Both RLE and BIT_PACKED level decoders set `num_buffered_values` as total number
-    /// of values that they can return and track num values.
-    #[inline]
-    pub fn set_data(&mut self, num_buffered_values: usize, data: ByteBufferPtr) -> usize {
-        match *self {
-            LevelDecoder::Rle(ref mut num_values, ref mut decoder) => {
-                *num_values = Some(num_buffered_values);
-                let i32_size = mem::size_of::<i32>();
-                let data_size = read_num_bytes::<i32>(i32_size, data.as_ref()) as usize;
-                decoder.set_data(data.range(i32_size, data_size));
-                i32_size + data_size
-            }
-            LevelDecoder::BitPacked(ref mut num_values, bit_width, ref mut decoder) => {
-                *num_values = Some(num_buffered_values);
-                // Set appropriate number of bytes: if max size is larger than buffer -
-                // set full buffer
-                let num_bytes =
-                    ceil((num_buffered_values * bit_width as usize) as i64, 8);
-                let data_size = cmp::min(num_bytes as usize, data.len());
-                decoder.reset(data.range(0, data_size));
-                data_size
-            }
-            _ => panic!(),
-        }
-    }
-
-    /// Sets byte array explicitly when start position `start` and length `len` are known
-    /// in advance. Only supported by RLE level decoder and used for Data Page v2 levels.
-    /// Returns number of total bytes set for this decoder (len).
-    #[inline]
-    pub fn set_data_range(
-        &mut self,
-        num_buffered_values: usize,
-        data: &ByteBufferPtr,
-        start: usize,
-        len: usize,
-    ) -> usize {
-        match *self {
-            LevelDecoder::RleV2(ref mut num_values, ref mut decoder) => {
-                decoder.set_data(data.range(start, len));
-                *num_values = Some(num_buffered_values);
-                len
-            }
-            _ => panic!(
-                "set_data_range() method is only supported by RLE v2 encoding type"
-            ),
-        }
-    }
-
-    /// Returns true if data is set for decoder, false otherwise.
-    #[inline]
-    pub fn is_data_set(&self) -> bool {
-        match self {
-            LevelDecoder::Rle(ref num_values, _) => num_values.is_some(),
-            LevelDecoder::RleV2(ref num_values, _) => num_values.is_some(),
-            LevelDecoder::BitPacked(ref num_values, ..) => num_values.is_some(),
-        }
-    }
-
-    /// Decodes values and puts them into `buffer`.
-    /// Returns number of values that were successfully decoded (less than or equal to
-    /// buffer length).
-    #[inline]
-    pub fn get(&mut self, buffer: &mut [i16]) -> Result<usize> {
-        assert!(self.is_data_set(), "No data set for decoding");
-        match *self {
-            LevelDecoder::Rle(ref mut num_values, ref mut decoder)
-            | LevelDecoder::RleV2(ref mut num_values, ref mut decoder) => {
-                // Max length we can read
-                let len = cmp::min(num_values.unwrap(), buffer.len());
-                let values_read = decoder.get_batch::<i16>(&mut buffer[0..len])?;
-                *num_values = num_values.map(|len| len - values_read);
-                Ok(values_read)
-            }
-            LevelDecoder::BitPacked(ref mut num_values, bit_width, ref mut decoder) => {
-                // When extracting values from bit reader, it might return more values
-                // than left because of padding to a full byte, we use
-                // num_values to track precise number of values.
-                let len = cmp::min(num_values.unwrap(), buffer.len());
-                let values_read =
-                    decoder.get_batch::<i16>(&mut buffer[..len], bit_width as usize);
-                *num_values = num_values.map(|len| len - values_read);
-                Ok(values_read)
-            }
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use crate::util::test_common::rand_gen::random_numbers_range;
-
-    fn test_internal_roundtrip(enc: Encoding, levels: &[i16], max_level: i16, v2: bool) {
-        let mut encoder = if v2 {
-            LevelEncoder::v2(max_level, levels.len())
-        } else {
-            LevelEncoder::v1(enc, max_level, levels.len())
-        };
-        encoder.put(levels);
-        let encoded_levels = encoder.consume();
-
-        let byte_buf = ByteBufferPtr::new(encoded_levels);
-        let mut decoder;
-        if v2 {
-            decoder = LevelDecoder::v2(max_level);
-            decoder.set_data_range(levels.len(), &byte_buf, 0, byte_buf.len());
-        } else {
-            decoder = LevelDecoder::v1(enc, max_level);
-            decoder.set_data(levels.len(), byte_buf);
-        };
-
-        let mut buffer = vec![0; levels.len()];
-        let num_decoded = decoder.get(&mut buffer).expect("get() should be OK");
-        assert_eq!(num_decoded, levels.len());
-        assert_eq!(buffer, levels);
-    }
-
-    // Performs incremental read until all bytes are read
-    fn test_internal_roundtrip_incremental(
-        enc: Encoding,
-        levels: &[i16],
-        max_level: i16,
-        v2: bool,
-    ) {
-        let mut encoder = if v2 {
-            LevelEncoder::v2(max_level, levels.len())
-        } else {
-            LevelEncoder::v1(enc, max_level, levels.len())
-        };
-        encoder.put(levels);
-        let encoded_levels = encoder.consume();
-
-        let byte_buf = ByteBufferPtr::new(encoded_levels);
-        let mut decoder;
-        if v2 {
-            decoder = LevelDecoder::v2(max_level);
-            decoder.set_data_range(levels.len(), &byte_buf, 0, byte_buf.len());
-        } else {
-            decoder = LevelDecoder::v1(enc, max_level);
-            decoder.set_data(levels.len(), byte_buf);
-        }
-
-        let mut buffer = vec![0; levels.len() * 2];
-        let mut total_decoded = 0;
-        let mut safe_stop = levels.len() * 2; // still terminate in case of issues in the code
-        while safe_stop > 0 {
-            safe_stop -= 1;
-            let num_decoded = decoder
-                .get(&mut buffer[total_decoded..total_decoded + 1])
-                .expect("get() should be OK");
-            if num_decoded == 0 {
-                break;
-            }
-            total_decoded += num_decoded;
-        }
-        assert!(
-            safe_stop > 0,
-            "Failed to read values incrementally, reached safe stop"
-        );
-        assert_eq!(total_decoded, levels.len());
-        assert_eq!(&buffer[0..levels.len()], levels);
-    }
-
-    // Tests encoding/decoding of values when output buffer is larger than number of
-    // encoded values
-    fn test_internal_roundtrip_underflow(
-        enc: Encoding,
-        levels: &[i16],
-        max_level: i16,
-        v2: bool,
-    ) {
-        let mut encoder = if v2 {
-            LevelEncoder::v2(max_level, levels.len())
-        } else {
-            LevelEncoder::v1(enc, max_level, levels.len())
-        };
-        // Encode only one value
-        let num_encoded = encoder.put(&levels[0..1]);
-        let encoded_levels = encoder.consume();
-        assert_eq!(num_encoded, 1);
-
-        let byte_buf = ByteBufferPtr::new(encoded_levels);
-        let mut decoder;
-        // Set one encoded value as `num_buffered_values`
-        if v2 {
-            decoder = LevelDecoder::v2(max_level);
-            decoder.set_data_range(1, &byte_buf, 0, byte_buf.len());
-        } else {
-            decoder = LevelDecoder::v1(enc, max_level);
-            decoder.set_data(1, byte_buf);
-        }
-
-        let mut buffer = vec![0; levels.len()];
-        let num_decoded = decoder.get(&mut buffer).expect("get() should be OK");
-        assert_eq!(num_decoded, num_encoded);
-        assert_eq!(buffer[0..num_decoded], levels[0..num_decoded]);
-    }
-
-    #[test]
-    fn test_roundtrip_one() {
-        let levels = vec![0, 1, 1, 1, 1, 0, 0, 0, 0, 1];
-        let max_level = 1;
-        test_internal_roundtrip(Encoding::RLE, &levels, max_level, false);
-        test_internal_roundtrip(Encoding::BIT_PACKED, &levels, max_level, false);
-        test_internal_roundtrip(Encoding::RLE, &levels, max_level, true);
-    }
-
-    #[test]
-    fn test_roundtrip() {
-        let levels = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        let max_level = 10;
-        test_internal_roundtrip(Encoding::RLE, &levels, max_level, false);
-        test_internal_roundtrip(Encoding::BIT_PACKED, &levels, max_level, false);
-        test_internal_roundtrip(Encoding::RLE, &levels, max_level, true);
-    }
-
-    #[test]
-    fn test_roundtrip_incremental() {
-        let levels = vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-        let max_level = 10;
-        test_internal_roundtrip_incremental(Encoding::RLE, &levels, max_level, false);
-        test_internal_roundtrip_incremental(
-            Encoding::BIT_PACKED,
-            &levels,
-            max_level,
-            false,
-        );
-        test_internal_roundtrip_incremental(Encoding::RLE, &levels, max_level, true);
-    }
-
-    #[test]
-    fn test_roundtrip_all_zeros() {
-        let levels = vec![0, 0, 0, 0, 0, 0, 0, 0, 0, 0];
-        let max_level = 1;
-        test_internal_roundtrip(Encoding::RLE, &levels, max_level, false);
-        test_internal_roundtrip(Encoding::BIT_PACKED, &levels, max_level, false);
-        test_internal_roundtrip(Encoding::RLE, &levels, max_level, true);
-    }
-
-    #[test]
-    fn test_roundtrip_random() {
-        // This test is mainly for bit packed level encoder/decoder
-        let mut levels = Vec::new();
-        let max_level = 5;
-        random_numbers_range::<i16>(120, 0, max_level, &mut levels);
-        test_internal_roundtrip(Encoding::RLE, &levels, max_level, false);
-        test_internal_roundtrip(Encoding::BIT_PACKED, &levels, max_level, false);
-        test_internal_roundtrip(Encoding::RLE, &levels, max_level, true);
-    }
-
-    #[test]
-    fn test_rountrip_max() {
-        let levels = vec![0, i16::MAX, i16::MAX, i16::MAX, 0];
-        let max_level = i16::MAX;
-        test_internal_roundtrip(Encoding::RLE, &levels, max_level, false);
-        test_internal_roundtrip(Encoding::BIT_PACKED, &levels, max_level, false);
-        test_internal_roundtrip(Encoding::RLE, &levels, max_level, true);
-    }
-
-    #[test]
-    fn test_roundtrip_underflow() {
-        let levels = vec![1, 1, 2, 3, 2, 1, 1, 2, 3, 1];
-        let max_level = 3;
-        test_internal_roundtrip_underflow(Encoding::RLE, &levels, max_level, false);
-        test_internal_roundtrip_underflow(
-            Encoding::BIT_PACKED,
-            &levels,
-            max_level,
-            false,
-        );
-        test_internal_roundtrip_underflow(Encoding::RLE, &levels, max_level, true);
-    }
-
-    #[test]
-    fn test_rle_decoder_set_data_range() {
-        // Buffer containing both repetition and definition levels
-        let buffer = ByteBufferPtr::new(vec![5, 198, 2, 5, 42, 168, 10, 0, 2, 3, 36, 73]);
-
-        let max_rep_level = 1;
-        let mut decoder = LevelDecoder::v2(max_rep_level);
-        assert_eq!(decoder.set_data_range(10, &buffer, 0, 3), 3);
-        let mut result = vec![0; 10];
-        let num_decoded = decoder.get(&mut result).expect("get() should be OK");
-        assert_eq!(num_decoded, 10);
-        assert_eq!(result, vec![0, 1, 1, 0, 0, 0, 1, 1, 0, 1]);
-
-        let max_def_level = 2;
-        let mut decoder = LevelDecoder::v2(max_def_level);
-        assert_eq!(decoder.set_data_range(10, &buffer, 3, 5), 5);
-        let mut result = vec![0; 10];
-        let num_decoded = decoder.get(&mut result).expect("get() should be OK");
-        assert_eq!(num_decoded, 10);
-        assert_eq!(result, vec![2, 2, 2, 0, 0, 2, 2, 2, 2, 2]);
-    }
-
-    #[test]
-    #[should_panic(
-        expected = "set_data_range() method is only supported by RLE v2 encoding type"
-    )]
-    fn test_bit_packed_decoder_set_data_range() {
-        // Buffer containing both repetition and definition levels
-        let buffer = ByteBufferPtr::new(vec![1, 2, 3, 4, 5]);
-        let max_level = 1;
-        let mut decoder = LevelDecoder::v1(Encoding::BIT_PACKED, max_level);
-        decoder.set_data_range(10, &buffer, 0, 3);
-    }
-
-    #[test]
-    fn test_bit_packed_decoder_set_data() {
-        // Test the maximum size that is assigned based on number of values and buffer
-        // length
-        let buffer = ByteBufferPtr::new(vec![1, 2, 3, 4, 5]);
-        let max_level = 1;
-        let mut decoder = LevelDecoder::v1(Encoding::BIT_PACKED, max_level);
-        // This should reset to entire buffer
-        assert_eq!(decoder.set_data(1024, buffer.all()), buffer.len());
-        // This should set smallest num bytes
-        assert_eq!(decoder.set_data(3, buffer.all()), 1);
-    }
-
-    #[test]
-    #[should_panic(expected = "No data set for decoding")]
-    fn test_rle_level_decoder_get_no_set_data() {
-        // `get()` normally panics because bit_reader is not set for RLE decoding
-        // we have explicit check now in set_data
-        let max_rep_level = 2;
-        let mut decoder = LevelDecoder::v1(Encoding::RLE, max_rep_level);
-        let mut buffer = vec![0; 16];
-        decoder.get(&mut buffer).unwrap();
-    }
-
-    #[test]
-    #[should_panic(expected = "No data set for decoding")]
-    fn test_bit_packed_level_decoder_get_no_set_data() {
-        let max_rep_level = 2;
-        let mut decoder = LevelDecoder::v1(Encoding::BIT_PACKED, max_rep_level);
-        let mut buffer = vec![0; 16];
-        decoder.get(&mut buffer).unwrap();
-    }
-}
diff --git a/parquet/src/encodings/rle.rs b/parquet/src/encodings/rle.rs
index 39a0aa4d03da..5d91c1e53d0f 100644
--- a/parquet/src/encodings/rle.rs
+++ b/parquet/src/encodings/rle.rs
@@ -17,34 +17,33 @@
 
 use std::{cmp, mem::size_of};
 
+use bytes::Bytes;
+
 use crate::errors::{ParquetError, Result};
-use crate::util::{
-    bit_util::{self, from_ne_slice, BitReader, BitWriter, FromBytes},
-    memory::ByteBufferPtr,
-};
+use crate::util::bit_util::from_le_slice;
+use crate::util::bit_util::{self, BitReader, BitWriter, FromBytes};
 
 /// Rle/Bit-Packing Hybrid Encoding
 /// The grammar for this encoding looks like the following (copied verbatim
 /// from <https://github.com/Parquet/parquet-format/blob/master/Encodings.md>):
 ///
-/// rle-bit-packed-hybrid: <length> <encoded-data>
-/// length := length of the <encoded-data> in bytes stored as 4 bytes little endian
-/// encoded-data := <run>*
-/// run := <bit-packed-run> | <rle-run>
-/// bit-packed-run := <bit-packed-header> <bit-packed-values>
-/// bit-packed-header := varint-encode(<bit-pack-count> << 1 | 1)
+/// rle-bit-packed-hybrid: `<length>` `<encoded-data>`
+/// length := length of the `<encoded-data>` in bytes stored as 4 bytes little endian
+/// encoded-data := `<run>`*
+/// run := `<bit-packed-run>` | `<rle-run>`
+/// bit-packed-run := `<bit-packed-header>` `<bit-packed-values>`
+/// bit-packed-header := varint-encode(`<bit-pack-count>` << 1 | 1)
 /// we always bit-pack a multiple of 8 values at a time, so we only store the number of
 /// values / 8
 /// bit-pack-count := (number of values in this run) / 8
 /// bit-packed-values := *see 1 below*
-/// rle-run := <rle-header> <repeated-value>
+/// rle-run := `<rle-header>` `<repeated-value>`
 /// rle-header := varint-encode( (number of times repeated) << 1)
 /// repeated-value := value that is repeated, using a fixed-width of
 /// round-up-to-next-byte(bit-width)
 
-/// Maximum groups per bit-packed run. Current value is 64.
+/// Maximum groups of 8 values per bit-packed run. Current value is 64.
 const MAX_GROUPS_PER_BIT_PACKED_RUN: usize = 1 << 6;
-const MAX_VALUES_PER_BIT_PACKED_RUN: usize = MAX_GROUPS_PER_BIT_PACKED_RUN * 8;
 
 /// A RLE/Bit-Packing hybrid encoder.
 // TODO: tracking memory usage
@@ -99,31 +98,28 @@ impl RleEncoder {
         }
     }
 
-    /// Returns the minimum buffer size needed to use the encoder for `bit_width`.
-    /// This is the maximum length of a single run for `bit_width`.
-    pub fn min_buffer_size(bit_width: u8) -> usize {
-        let max_bit_packed_run_size = 1 + bit_util::ceil(
-            (MAX_VALUES_PER_BIT_PACKED_RUN * bit_width as usize) as i64,
-            8,
-        );
-        let max_rle_run_size =
-            bit_util::MAX_VLQ_BYTE_LEN + bit_util::ceil(bit_width as i64, 8) as usize;
-        std::cmp::max(max_bit_packed_run_size as usize, max_rle_run_size)
-    }
-
-    /// Returns the maximum buffer size takes to encode `num_values` values with
+    /// Returns the maximum buffer size to encode `num_values` values with
     /// `bit_width`.
     pub fn max_buffer_size(bit_width: u8, num_values: usize) -> usize {
-        // First the maximum size for bit-packed run
-        let bytes_per_run = bit_width;
-        let num_runs = bit_util::ceil(num_values as i64, 8) as usize;
-        let bit_packed_max_size = num_runs + num_runs * bytes_per_run as usize;
+        // The maximum size occurs with the shortest possible runs of 8
+        let num_runs = bit_util::ceil(num_values, 8);
+
+        // The number of bytes in a run of 8
+        let bytes_per_run = bit_width as usize;
+
+        // The maximum size if stored as shortest possible bit packed runs of 8
+        let bit_packed_max_size = num_runs + num_runs * bytes_per_run;
+
+        // The length of `8` VLQ encoded
+        let rle_len_prefix = 1;
 
-        // Second the maximum size for RLE run
-        let min_rle_run_size = 1 + bit_util::ceil(bit_width as i64, 8) as usize;
-        let rle_max_size =
-            bit_util::ceil(num_values as i64, 8) as usize * min_rle_run_size;
-        std::cmp::max(bit_packed_max_size, rle_max_size) as usize
+        // The length of an RLE run of 8
+        let min_rle_run_size = rle_len_prefix + bit_util::ceil(bit_width as usize, 8);
+
+        // The maximum size if stored as shortest possible RLE runs of 8
+        let rle_max_size = num_runs * min_rle_run_size;
+
+        bit_packed_max_size.max(rle_max_size)
     }
 
     /// Encodes `value`, which must be representable with `bit_width` bits.
@@ -234,7 +230,7 @@ impl RleEncoder {
         self.bit_writer.put_vlq_int(indicator_value as u64);
         self.bit_writer.put_aligned(
             self.current_value,
-            bit_util::ceil(self.bit_width as i64, 8) as usize,
+            bit_util::ceil(self.bit_width as usize, 8),
         );
         self.num_buffered_values = 0;
         self.repeat_count = 0;
@@ -329,7 +325,7 @@ impl RleDecoder {
     }
 
     #[inline]
-    pub fn set_data(&mut self, data: ByteBufferPtr) {
+    pub fn set_data(&mut self, data: Bytes) {
         if let Some(ref mut bit_reader) = self.bit_reader {
             bit_reader.reset(data);
         } else {
@@ -342,6 +338,7 @@ impl RleDecoder {
     // These functions inline badly, they tend to inline and then create very large loop unrolls
     // that damage L1d-cache occupancy. This results in a ~18% performance drop
     #[inline(never)]
+    #[allow(unused)]
     pub fn get<T: FromBytes>(&mut self) -> Result<Option<T>> {
         assert!(size_of::<T>() <= 8);
 
@@ -352,7 +349,7 @@ impl RleDecoder {
         }
 
         let value = if self.rle_left > 0 {
-            let rle_value = from_ne_slice(
+            let rle_value = from_le_slice(
                 &self
                     .current_value
                     .as_mut()
@@ -384,7 +381,7 @@ impl RleDecoder {
                 let num_values =
                     cmp::min(buffer.len() - values_read, self.rle_left as usize);
                 for i in 0..num_values {
-                    let repeated_value = from_ne_slice(
+                    let repeated_value = from_le_slice(
                         &self.current_value.as_mut().unwrap().to_ne_bytes(),
                     );
                     buffer[values_read + i] = repeated_value;
@@ -476,13 +473,18 @@ impl RleDecoder {
                 let bit_reader =
                     self.bit_reader.as_mut().expect("bit_reader should be set");
 
-                let mut num_values =
-                    cmp::min(max_values - values_read, self.bit_packed_left as usize);
-
-                num_values = cmp::min(num_values, index_buf.len());
                 loop {
-                    num_values = bit_reader.get_batch::<i32>(
-                        &mut index_buf[..num_values],
+                    let to_read = index_buf
+                        .len()
+                        .min(max_values - values_read)
+                        .min(self.bit_packed_left as usize);
+
+                    if to_read == 0 {
+                        break;
+                    }
+
+                    let num_values = bit_reader.get_batch::<i32>(
+                        &mut index_buf[..to_read],
                         self.bit_width as usize,
                     );
                     if num_values == 0 {
@@ -495,7 +497,7 @@ impl RleDecoder {
                     }
                     self.bit_packed_left -= num_values as u32;
                     values_read += num_values;
-                    if num_values < index_buf.len() {
+                    if num_values < to_read {
                         break;
                     }
                 }
@@ -512,12 +514,18 @@ impl RleDecoder {
         let bit_reader = self.bit_reader.as_mut().expect("bit_reader should be set");
 
         if let Some(indicator_value) = bit_reader.get_vlq_int() {
+            // fastparquet adds padding to the end of pages. This is not spec-compliant
+            // but is handled by the C++ implementation
+            // <https://github.com/apache/arrow/blob/8074496cb41bc8ec8fe9fc814ca5576d89a6eb94/cpp/src/arrow/util/rle_encoding.h#L653>
+            if indicator_value == 0 {
+                return false;
+            }
             if indicator_value & 1 == 1 {
                 self.bit_packed_left = ((indicator_value >> 1) * 8) as u32;
             } else {
                 self.rle_left = (indicator_value >> 1) as u32;
-                let value_width = bit_util::ceil(self.bit_width as i64, 8);
-                self.current_value = bit_reader.get_aligned::<u64>(value_width as usize);
+                let value_width = bit_util::ceil(self.bit_width as usize, 8);
+                self.current_value = bit_reader.get_aligned::<u64>(value_width);
                 assert!(self.current_value.is_some());
             }
             true
@@ -531,19 +539,18 @@ impl RleDecoder {
 mod tests {
     use super::*;
 
+    use crate::util::bit_util::ceil;
     use rand::{self, distributions::Standard, thread_rng, Rng, SeedableRng};
 
-    use crate::util::memory::ByteBufferPtr;
-
     const MAX_WIDTH: usize = 32;
 
     #[test]
     fn test_rle_decode_int32() {
         // Test data: 0-7 with bit width 3
         // 00000011 10001000 11000110 11111010
-        let data = ByteBufferPtr::new(vec![0x03, 0x88, 0xC6, 0xFA]);
+        let data = vec![0x03, 0x88, 0xC6, 0xFA];
         let mut decoder: RleDecoder = RleDecoder::new(3);
-        decoder.set_data(data);
+        decoder.set_data(data.into());
         let mut buffer = vec![0; 8];
         let expected = vec![0, 1, 2, 3, 4, 5, 6, 7];
         let result = decoder.get_batch::<i32>(&mut buffer);
@@ -555,9 +562,9 @@ mod tests {
     fn test_rle_skip_int32() {
         // Test data: 0-7 with bit width 3
         // 00000011 10001000 11000110 11111010
-        let data = ByteBufferPtr::new(vec![0x03, 0x88, 0xC6, 0xFA]);
+        let data = vec![0x03, 0x88, 0xC6, 0xFA];
         let mut decoder: RleDecoder = RleDecoder::new(3);
-        decoder.set_data(data);
+        decoder.set_data(data.into());
         let expected = vec![2, 3, 4, 5, 6, 7];
         let skipped = decoder.skip(2).expect("skipping values");
         assert_eq!(skipped, 2);
@@ -588,18 +595,17 @@ mod tests {
     fn test_rle_decode_bool() {
         // RLE test data: 50 1s followed by 50 0s
         // 01100100 00000001 01100100 00000000
-        let data1 = ByteBufferPtr::new(vec![0x64, 0x01, 0x64, 0x00]);
+        let data1 = vec![0x64, 0x01, 0x64, 0x00];
 
         // Bit-packing test data: alternating 1s and 0s, 100 total
         // 100 / 8 = 13 groups
         // 00011011 10101010 ... 00001010
-        let data2 = ByteBufferPtr::new(vec![
-            0x1B, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
-            0x0A,
-        ]);
+        let data2 = vec![
+            0x1B, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x0A,
+        ];
 
         let mut decoder: RleDecoder = RleDecoder::new(1);
-        decoder.set_data(data1);
+        decoder.set_data(data1.into());
         let mut buffer = vec![false; 100];
         let mut expected = vec![];
         for i in 0..100 {
@@ -613,7 +619,7 @@ mod tests {
         assert!(result.is_ok());
         assert_eq!(buffer, expected);
 
-        decoder.set_data(data2);
+        decoder.set_data(data2.into());
         let mut buffer = vec![false; 100];
         let mut expected = vec![];
         for i in 0..100 {
@@ -632,18 +638,17 @@ mod tests {
     fn test_rle_skip_bool() {
         // RLE test data: 50 1s followed by 50 0s
         // 01100100 00000001 01100100 00000000
-        let data1 = ByteBufferPtr::new(vec![0x64, 0x01, 0x64, 0x00]);
+        let data1 = vec![0x64, 0x01, 0x64, 0x00];
 
         // Bit-packing test data: alternating 1s and 0s, 100 total
         // 100 / 8 = 13 groups
         // 00011011 10101010 ... 00001010
-        let data2 = ByteBufferPtr::new(vec![
-            0x1B, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA,
-            0x0A,
-        ]);
+        let data2 = vec![
+            0x1B, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0xAA, 0x0A,
+        ];
 
         let mut decoder: RleDecoder = RleDecoder::new(1);
-        decoder.set_data(data1);
+        decoder.set_data(data1.into());
         let mut buffer = vec![true; 50];
         let expected = vec![false; 50];
 
@@ -655,7 +660,7 @@ mod tests {
         assert_eq!(remainder, 50);
         assert_eq!(buffer, expected);
 
-        decoder.set_data(data2);
+        decoder.set_data(data2.into());
         let mut buffer = vec![false; 50];
         let mut expected = vec![];
         for i in 0..50 {
@@ -679,9 +684,9 @@ mod tests {
         // Test RLE encoding: 3 0s followed by 4 1s followed by 5 2s
         // 00000110 00000000 00001000 00000001 00001010 00000010
         let dict = vec![10, 20, 30];
-        let data = ByteBufferPtr::new(vec![0x06, 0x00, 0x08, 0x01, 0x0A, 0x02]);
+        let data = vec![0x06, 0x00, 0x08, 0x01, 0x0A, 0x02];
         let mut decoder: RleDecoder = RleDecoder::new(3);
-        decoder.set_data(data);
+        decoder.set_data(data.into());
         let mut buffer = vec![0; 12];
         let expected = vec![10, 10, 10, 20, 20, 20, 20, 30, 30, 30, 30, 30];
         let result = decoder.get_batch_with_dict::<i32>(&dict, &mut buffer, 12);
@@ -692,9 +697,9 @@ mod tests {
         // 011 100 101 011 100 101 011 100 101 100 101 101
         // 00000011 01100011 11000111 10001110 00000011 01100101 00001011
         let dict = vec!["aaa", "bbb", "ccc", "ddd", "eee", "fff"];
-        let data = ByteBufferPtr::new(vec![0x03, 0x63, 0xC7, 0x8E, 0x03, 0x65, 0x0B]);
+        let data = vec![0x03, 0x63, 0xC7, 0x8E, 0x03, 0x65, 0x0B];
         let mut decoder: RleDecoder = RleDecoder::new(3);
-        decoder.set_data(data);
+        decoder.set_data(data.into());
         let mut buffer = vec![""; 12];
         let expected = vec![
             "ddd", "eee", "fff", "ddd", "eee", "fff", "ddd", "eee", "fff", "eee", "fff",
@@ -714,9 +719,9 @@ mod tests {
         // Test RLE encoding: 3 0s followed by 4 1s followed by 5 2s
         // 00000110 00000000 00001000 00000001 00001010 00000010
         let dict = vec![10, 20, 30];
-        let data = ByteBufferPtr::new(vec![0x06, 0x00, 0x08, 0x01, 0x0A, 0x02]);
+        let data = vec![0x06, 0x00, 0x08, 0x01, 0x0A, 0x02];
         let mut decoder: RleDecoder = RleDecoder::new(3);
-        decoder.set_data(data);
+        decoder.set_data(data.into());
         let mut buffer = vec![0; 10];
         let expected = vec![10, 20, 20, 20, 20, 30, 30, 30, 30, 30];
         let skipped = decoder.skip(2).expect("skipping two values");
@@ -731,9 +736,9 @@ mod tests {
         // 011 100 101 011 100 101 011 100 101 100 101 101
         // 00000011 01100011 11000111 10001110 00000011 01100101 00001011
         let dict = vec!["aaa", "bbb", "ccc", "ddd", "eee", "fff"];
-        let data = ByteBufferPtr::new(vec![0x03, 0x63, 0xC7, 0x8E, 0x03, 0x65, 0x0B]);
+        let data = vec![0x03, 0x63, 0xC7, 0x8E, 0x03, 0x65, 0x0B];
         let mut decoder: RleDecoder = RleDecoder::new(3);
-        decoder.set_data(data);
+        decoder.set_data(data.into());
         let mut buffer = vec![""; 8];
         let expected = vec!["eee", "fff", "ddd", "eee", "fff", "eee", "fff", "fff"];
         let skipped = decoder.skip(4).expect("skipping four values");
@@ -756,7 +761,7 @@ mod tests {
         for v in values {
             encoder.put(*v as u64)
         }
-        let buffer = ByteBufferPtr::new(encoder.consume());
+        let buffer: Bytes = encoder.consume().into();
         if expected_len != -1 {
             assert_eq!(buffer.len(), expected_len as usize);
         }
@@ -766,7 +771,7 @@ mod tests {
 
         // Verify read
         let mut decoder = RleDecoder::new(bit_width);
-        decoder.set_data(buffer.all());
+        decoder.set_data(buffer.clone());
         for v in values {
             let val: i64 = decoder
                 .get()
@@ -814,7 +819,7 @@ mod tests {
             values.push(i % 2);
         }
         let num_groups = bit_util::ceil(100, 8) as u8;
-        expected_buffer.push(((num_groups << 1) as u8) | 1);
+        expected_buffer.push((num_groups << 1) | 1);
         expected_buffer.resize(expected_buffer.len() + 100 / 8, 0b10101010);
 
         // For the last 4 0 and 1's, padded with 0.
@@ -878,7 +883,7 @@ mod tests {
             (3 << 1) | 1, // bit-packed run of 3 * 8
         ];
         data.extend(std::iter::repeat(0xFF).take(20));
-        let data = ByteBufferPtr::new(data);
+        let data: Bytes = data.into();
 
         let mut decoder = RleDecoder::new(8);
         decoder.set_data(data.clone());
@@ -902,18 +907,87 @@ mod tests {
         assert!(output.iter().take(20).all(|x| *x == 255));
     }
 
+    #[test]
+    fn test_rle_padded() {
+        let values: Vec<i16> = vec![0, 1, 1, 3, 1, 0];
+        let bit_width = 2;
+        let buffer_len = RleEncoder::max_buffer_size(bit_width, values.len());
+        let mut encoder = RleEncoder::new(bit_width, buffer_len + 1);
+        for v in &values {
+            encoder.put(*v as u64)
+        }
+
+        let mut buffer = encoder.consume();
+        buffer.push(0);
+
+        let mut decoder = RleDecoder::new(bit_width);
+        decoder.set_data(buffer.into());
+
+        // We don't always reliably know how many non-null values are contained in a page
+        // and so the decoder must work correctly without a precise value count
+        let mut actual_values: Vec<i16> = vec![0; 12];
+        let r = decoder
+            .get_batch(&mut actual_values)
+            .expect("get_batch() should be OK");
+
+        // Should decode 8 values despite only encoding 6 as length of
+        // bit packed run is always multiple of 8
+        assert_eq!(r, 8);
+        assert_eq!(actual_values[..6], values);
+        assert_eq!(actual_values[6], 0);
+        assert_eq!(actual_values[7], 0);
+    }
+
+    #[test]
+    fn test_long_run() {
+        // This writer does not write runs longer than 504 values as this allows
+        // encoding the run header as a single byte
+        //
+        // This tests that the decoder correctly handles longer runs
+
+        let mut writer = BitWriter::new(1024);
+        let bit_width = 1;
+
+        // Choose a non-multiple of 8 larger than 1024 so that the length
+        // of the run is ambiguous, as the encoding only stores `num_values / 8`
+        let num_values = 2002;
+
+        // bit-packed header
+        let run_bytes = ceil(num_values * bit_width, 8) as u64;
+        writer.put_vlq_int(run_bytes << 1 | 1);
+        for _ in 0..run_bytes {
+            writer.put_aligned(0xFF_u8, 1);
+        }
+        let buffer: Bytes = writer.consume().into();
+
+        let mut decoder = RleDecoder::new(1);
+        decoder.set_data(buffer.clone());
+
+        let mut decoded: Vec<i16> = vec![0; num_values];
+        let r = decoder.get_batch(&mut decoded).unwrap();
+        assert_eq!(r, num_values);
+        assert_eq!(vec![1; num_values], decoded);
+
+        decoder.set_data(buffer);
+        let r = decoder
+            .get_batch_with_dict(&[0, 23], &mut decoded, num_values)
+            .unwrap();
+        assert_eq!(r, num_values);
+        assert_eq!(vec![23; num_values], decoded);
+    }
+
     #[test]
     fn test_rle_specific_roundtrip() {
         let bit_width = 1;
-        let buffer_len = RleEncoder::min_buffer_size(bit_width);
         let values: Vec<i16> = vec![0, 1, 1, 1, 1, 0, 0, 0, 0, 1];
+        let buffer_len = RleEncoder::max_buffer_size(bit_width, values.len());
         let mut encoder = RleEncoder::new(bit_width, buffer_len);
         for v in &values {
             encoder.put(*v as u64)
         }
         let buffer = encoder.consume();
         let mut decoder = RleDecoder::new(bit_width);
-        decoder.set_data(ByteBufferPtr::new(buffer));
+        decoder.set_data(Bytes::from(buffer));
         let mut actual_values: Vec<i16> = vec![0; values.len()];
         decoder
             .get_batch(&mut actual_values)
@@ -928,11 +1002,11 @@ mod tests {
             encoder.put(*v as u64)
         }
 
-        let buffer = ByteBufferPtr::new(encoder.consume());
+        let buffer = Bytes::from(encoder.consume());
 
         // Verify read
         let mut decoder = RleDecoder::new(bit_width);
-        decoder.set_data(buffer.all());
+        decoder.set_data(buffer.clone());
         for v in values {
             let val = decoder
                 .get::<i32>()
diff --git a/parquet/src/errors.rs b/parquet/src/errors.rs
index c4f5faaaacae..0b70266b3012 100644
--- a/parquet/src/errors.rs
+++ b/parquet/src/errors.rs
@@ -17,12 +17,16 @@
 
 //! Common Parquet errors and macros.
 
+use std::error::Error;
 use std::{cell, io, result, str};
 
-#[cfg(any(feature = "arrow", test))]
-use arrow::error::ArrowError;
+#[cfg(feature = "arrow")]
+use arrow_schema::ArrowError;
 
-#[derive(Debug, PartialEq, Clone, Eq)]
+/// Parquet error enumeration
+// Note: we don't implement PartialEq as the semantics for the
+// external variant are not well defined (#4469)
+#[derive(Debug)]
 pub enum ParquetError {
     /// General Parquet error.
     /// Returned when code violates normal workflow of working with Parquet files.
@@ -34,76 +38,82 @@ pub enum ParquetError {
     /// Returned when IO related failures occur, e.g. when there are not enough bytes to
     /// decode.
     EOF(String),
-    #[cfg(any(feature = "arrow", test))]
+    #[cfg(feature = "arrow")]
     /// Arrow error.
     /// Returned when reading into arrow or writing from arrow.
     ArrowError(String),
     IndexOutOfBound(usize, usize),
+    /// An external error variant
+    External(Box<dyn Error + Send + Sync>),
 }
 
 impl std::fmt::Display for ParquetError {
     fn fmt(&self, fmt: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match *self {
-            ParquetError::General(ref message) => {
-                write!(fmt, "Parquet error: {}", message)
+        match &self {
+            ParquetError::General(message) => {
+                write!(fmt, "Parquet error: {message}")
             }
-            ParquetError::NYI(ref message) => write!(fmt, "NYI: {}", message),
-            ParquetError::EOF(ref message) => write!(fmt, "EOF: {}", message),
-            #[cfg(any(feature = "arrow", test))]
-            ParquetError::ArrowError(ref message) => write!(fmt, "Arrow: {}", message),
-            ParquetError::IndexOutOfBound(ref index, ref bound) => {
-                write!(fmt, "Index {} out of bound: {}", index, bound)
+            ParquetError::NYI(message) => write!(fmt, "NYI: {message}"),
+            ParquetError::EOF(message) => write!(fmt, "EOF: {message}"),
+            #[cfg(feature = "arrow")]
+            ParquetError::ArrowError(message) => write!(fmt, "Arrow: {message}"),
+            ParquetError::IndexOutOfBound(index, ref bound) => {
+                write!(fmt, "Index {index} out of bound: {bound}")
             }
+            ParquetError::External(e) => write!(fmt, "External: {e}"),
         }
     }
 }
 
-impl std::error::Error for ParquetError {
-    fn cause(&self) -> Option<&dyn ::std::error::Error> {
-        None
+impl Error for ParquetError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            ParquetError::External(e) => Some(e.as_ref()),
+            _ => None,
+        }
     }
 }
 
 impl From<io::Error> for ParquetError {
     fn from(e: io::Error) -> ParquetError {
-        ParquetError::General(format!("underlying IO error: {}", e))
+        ParquetError::External(Box::new(e))
     }
 }
 
 #[cfg(any(feature = "snap", test))]
 impl From<snap::Error> for ParquetError {
     fn from(e: snap::Error) -> ParquetError {
-        ParquetError::General(format!("underlying snap error: {}", e))
+        ParquetError::External(Box::new(e))
     }
 }
 
 impl From<thrift::Error> for ParquetError {
     fn from(e: thrift::Error) -> ParquetError {
-        ParquetError::General(format!("underlying Thrift error: {}", e))
+        ParquetError::External(Box::new(e))
     }
 }
 
 impl From<cell::BorrowMutError> for ParquetError {
     fn from(e: cell::BorrowMutError) -> ParquetError {
-        ParquetError::General(format!("underlying borrow error: {}", e))
+        ParquetError::External(Box::new(e))
     }
 }
 
 impl From<str::Utf8Error> for ParquetError {
     fn from(e: str::Utf8Error) -> ParquetError {
-        ParquetError::General(format!("underlying utf8 error: {}", e))
+        ParquetError::External(Box::new(e))
     }
 }
 
-#[cfg(any(feature = "arrow", test))]
+#[cfg(feature = "arrow")]
 impl From<ArrowError> for ParquetError {
     fn from(e: ArrowError) -> ParquetError {
-        ParquetError::ArrowError(format!("underlying Arrow error: {}", e))
+        ParquetError::External(Box::new(e))
     }
 }
 
 /// A specialized `Result` for Parquet errors.
-pub type Result<T> = result::Result<T, ParquetError>;
+pub type Result<T, E = ParquetError> = result::Result<T, E>;
 
 // ----------------------------------------------------------------------
 // Conversion from `ParquetError` to other types of `Error`s
@@ -135,7 +145,7 @@ macro_rules! eof_err {
     ($fmt:expr, $($args:expr),*) => (ParquetError::EOF(format!($fmt, $($args),*)));
 }
 
-#[cfg(any(feature = "arrow", test))]
+#[cfg(feature = "arrow")]
 macro_rules! arrow_err {
     ($fmt:expr) => (ParquetError::ArrowError($fmt.to_owned()));
     ($fmt:expr, $($args:expr),*) => (ParquetError::ArrowError(format!($fmt, $($args),*)));
@@ -147,9 +157,9 @@ macro_rules! arrow_err {
 // ----------------------------------------------------------------------
 // Convert parquet error into other errors
 
-#[cfg(any(feature = "arrow", test))]
+#[cfg(feature = "arrow")]
 impl From<ParquetError> for ArrowError {
     fn from(p: ParquetError) -> Self {
-        Self::ParquetError(format!("{}", p))
+        Self::ParquetError(format!("{p}"))
     }
 }
diff --git a/parquet/src/file/footer.rs b/parquet/src/file/footer.rs
index dc1d66d0fa44..9695dbeae6e1 100644
--- a/parquet/src/file/footer.rs
+++ b/parquet/src/file/footer.rs
@@ -17,9 +17,8 @@
 
 use std::{io::Read, sync::Arc};
 
-use byteorder::{ByteOrder, LittleEndian};
-use parquet_format::{ColumnOrder as TColumnOrder, FileMetaData as TFileMetaData};
-use thrift::protocol::TCompactInputProtocol;
+use crate::format::{ColumnOrder as TColumnOrder, FileMetaData as TFileMetaData};
+use crate::thrift::{TCompactSliceInputProtocol, TSerializable};
 
 use crate::basic::ColumnOrder;
 
@@ -47,7 +46,7 @@ pub fn parse_metadata<R: ChunkReader>(chunk_reader: &R) -> Result<ParquetMetaDat
 
     let mut footer = [0_u8; 8];
     chunk_reader
-        .get_read(file_size - 8, 8)?
+        .get_read(file_size - 8)?
         .read_exact(&mut footer)?;
 
     let metadata_len = decode_footer(&footer)?;
@@ -62,29 +61,16 @@ pub fn parse_metadata<R: ChunkReader>(chunk_reader: &R) -> Result<ParquetMetaDat
         ));
     }
 
-    let mut metadata = Vec::with_capacity(metadata_len);
-
-    let read = chunk_reader
-        .get_read(file_size - footer_metadata_len as u64, metadata_len)?
-        .read_to_end(&mut metadata)?;
-
-    if read != metadata_len {
-        return Err(eof_err!(
-            "Expected to read {} bytes of metadata, got {}",
-            metadata_len,
-            read
-        ));
-    }
-
-    decode_metadata(&metadata)
+    let start = file_size - footer_metadata_len as u64;
+    decode_metadata(chunk_reader.get_bytes(start, metadata_len)?.as_ref())
 }
 
 /// Decodes [`ParquetMetaData`] from the provided bytes
-pub fn decode_metadata(metadata_read: &[u8]) -> Result<ParquetMetaData> {
+pub fn decode_metadata(buf: &[u8]) -> Result<ParquetMetaData> {
     // TODO: row group filtering
-    let mut prot = TCompactInputProtocol::new(metadata_read);
+    let mut prot = TCompactSliceInputProtocol::new(buf);
     let t_file_metadata: TFileMetaData = TFileMetaData::read_from_in_protocol(&mut prot)
-        .map_err(|e| ParquetError::General(format!("Could not parse metadata: {}", e)))?;
+        .map_err(|e| ParquetError::General(format!("Could not parse metadata: {e}")))?;
     let schema = types::from_thrift(&t_file_metadata.schema)?;
     let schema_descr = Arc::new(SchemaDescriptor::new(schema));
     let mut row_groups = Vec::new();
@@ -112,13 +98,9 @@ pub fn decode_footer(slice: &[u8; FOOTER_SIZE]) -> Result<usize> {
     }
 
     // get the metadata length from the footer
-    let metadata_len = LittleEndian::read_i32(&slice[..4]);
-    metadata_len.try_into().map_err(|_| {
-        general_err!(
-            "Invalid Parquet file. Metadata length is less than zero ({})",
-            metadata_len
-        )
-    })
+    let metadata_len = u32::from_le_bytes(slice[..4].try_into().unwrap());
+    // u32 won't be larger than usize in most cases
+    Ok(metadata_len as usize)
 }
 
 /// Parses column orders from Thrift definition.
@@ -161,17 +143,16 @@ mod tests {
 
     use crate::basic::SortOrder;
     use crate::basic::Type;
+    use crate::format::TypeDefinedOrder;
     use crate::schema::types::Type as SchemaType;
-    use parquet_format::TypeDefinedOrder;
 
     #[test]
     fn test_parse_metadata_size_smaller_than_footer() {
         let test_file = tempfile::tempfile().unwrap();
         let reader_result = parse_metadata(&test_file);
-        assert!(reader_result.is_err());
         assert_eq!(
-            reader_result.err().unwrap(),
-            general_err!("Invalid Parquet file. Size is smaller than footer")
+            reader_result.unwrap_err().to_string(),
+            "Parquet error: Invalid Parquet file. Size is smaller than footer"
         );
     }
 
@@ -179,23 +160,9 @@ mod tests {
     fn test_parse_metadata_corrupt_footer() {
         let data = Bytes::from(vec![1, 2, 3, 4, 5, 6, 7, 8]);
         let reader_result = parse_metadata(&data);
-        assert!(reader_result.is_err());
-        assert_eq!(
-            reader_result.err().unwrap(),
-            general_err!("Invalid Parquet file. Corrupt footer")
-        );
-    }
-
-    #[test]
-    fn test_parse_metadata_invalid_length() {
-        let test_file = Bytes::from(vec![0, 0, 0, 255, b'P', b'A', b'R', b'1']);
-        let reader_result = parse_metadata(&test_file);
-        assert!(reader_result.is_err());
         assert_eq!(
-            reader_result.err().unwrap(),
-            general_err!(
-                "Invalid Parquet file. Metadata length is less than zero (-16777216)"
-            )
+            reader_result.unwrap_err().to_string(),
+            "Parquet error: Invalid Parquet file. Corrupt footer"
         );
     }
 
@@ -203,19 +170,16 @@ mod tests {
     fn test_parse_metadata_invalid_start() {
         let test_file = Bytes::from(vec![255, 0, 0, 0, b'P', b'A', b'R', b'1']);
         let reader_result = parse_metadata(&test_file);
-        assert!(reader_result.is_err());
         assert_eq!(
-            reader_result.err().unwrap(),
-            general_err!(
-                "Invalid Parquet file. Reported metadata length of 255 + 8 byte footer, but file is only 8 bytes"
-            )
+            reader_result.unwrap_err().to_string(),
+            "Parquet error: Invalid Parquet file. Reported metadata length of 255 + 8 byte footer, but file is only 8 bytes"
         );
     }
 
     #[test]
     fn test_metadata_column_orders_parse() {
         // Define simple schema, we do not need to provide logical types.
-        let mut fields = vec![
+        let fields = vec![
             Arc::new(
                 SchemaType::primitive_type_builder("col1", Type::INT32)
                     .build()
@@ -228,7 +192,7 @@ mod tests {
             ),
         ];
         let schema = SchemaType::group_type_builder("schema")
-            .with_fields(&mut fields)
+            .with_fields(fields)
             .build()
             .unwrap();
         let schema_descr = SchemaDescriptor::new(Arc::new(schema));
@@ -256,8 +220,7 @@ mod tests {
         let schema = SchemaType::group_type_builder("schema").build().unwrap();
         let schema_descr = SchemaDescriptor::new(Arc::new(schema));
 
-        let t_column_orders =
-            Some(vec![TColumnOrder::TYPEORDER(TypeDefinedOrder::new())]);
+        let t_column_orders = Some(vec![TColumnOrder::TYPEORDER(TypeDefinedOrder::new())]);
 
         parse_column_orders(t_column_orders, &schema_descr);
     }
diff --git a/parquet/src/file/metadata.rs b/parquet/src/file/metadata.rs
index 018dd95d9f35..acd3a9f938c5 100644
--- a/parquet/src/file/metadata.rs
+++ b/parquet/src/file/metadata.rs
@@ -33,11 +33,12 @@
 //! [`ColumnChunkMetaData`](struct.ColumnChunkMetaData.html) has information about column
 //! chunk (primitive leaf column), including encoding/compression, number of values, etc.
 
+use std::ops::Range;
 use std::sync::Arc;
 
-use parquet_format::{
-    BoundaryOrder, ColumnChunk, ColumnIndex, ColumnMetaData, OffsetIndex, PageLocation,
-    RowGroup,
+use crate::format::{
+    BoundaryOrder, ColumnChunk, ColumnIndex, ColumnMetaData, OffsetIndex, PageLocation, RowGroup,
+    SortingColumn,
 };
 
 use crate::basic::{ColumnOrder, Compression, Encoding, Type};
@@ -50,7 +51,25 @@ use crate::schema::types::{
     Type as SchemaType,
 };
 
+/// [`Index`] for each row group of each column.
+///
+/// `column_index[row_group_number][column_number]` holds the
+/// [`Index`] corresponding to column `column_number` of row group
+/// `row_group_number`.
+///
+/// For example `column_index[2][3]` holds the [`Index`] for the forth
+/// column in the third row group of the parquet file.
 pub type ParquetColumnIndex = Vec<Vec<Index>>;
+
+/// [`PageLocation`] for each datapage of each row group of each column.
+///
+/// `offset_index[row_group_number][column_number][page_number]` holds
+/// the [`PageLocation`] corresponding to page `page_number` of column
+/// `column_number`of row group `row_group_number`.
+///
+/// For example `offset_index[2][3][4]` holds the [`PageLocation`] for
+/// the fifth page of the forth column in the third row group of the
+/// parquet file.
 pub type ParquetOffsetIndex = Vec<Vec<Vec<PageLocation>>>;
 
 /// Global Parquet metadata.
@@ -59,34 +78,36 @@ pub struct ParquetMetaData {
     file_metadata: FileMetaData,
     row_groups: Vec<RowGroupMetaData>,
     /// Page index for all pages in each column chunk
-    page_indexes: Option<ParquetColumnIndex>,
+    column_index: Option<ParquetColumnIndex>,
     /// Offset index for all pages in each column chunk
-    offset_indexes: Option<ParquetOffsetIndex>,
+    offset_index: Option<ParquetOffsetIndex>,
 }
 
 impl ParquetMetaData {
-    /// Creates Parquet metadata from file metadata and a list of row group metadata `Arc`s
-    /// for each available row group.
+    /// Creates Parquet metadata from file metadata and a list of row
+    /// group metadata
     pub fn new(file_metadata: FileMetaData, row_groups: Vec<RowGroupMetaData>) -> Self {
         ParquetMetaData {
             file_metadata,
             row_groups,
-            page_indexes: None,
-            offset_indexes: None,
+            column_index: None,
+            offset_index: None,
         }
     }
 
+    /// Creates Parquet metadata from file metadata, a list of row
+    /// group metadata, and the column index structures.
     pub fn new_with_page_index(
         file_metadata: FileMetaData,
         row_groups: Vec<RowGroupMetaData>,
-        page_indexes: Option<ParquetColumnIndex>,
-        offset_indexes: Option<ParquetOffsetIndex>,
+        column_index: Option<ParquetColumnIndex>,
+        offset_index: Option<ParquetOffsetIndex>,
     ) -> Self {
         ParquetMetaData {
             file_metadata,
             row_groups,
-            page_indexes,
-            offset_indexes,
+            column_index,
+            offset_index,
         }
     }
 
@@ -112,17 +133,41 @@ impl ParquetMetaData {
     }
 
     /// Returns page indexes in this file.
+    #[deprecated(note = "Use Self::column_index")]
     pub fn page_indexes(&self) -> Option<&ParquetColumnIndex> {
-        self.page_indexes.as_ref()
+        self.column_index.as_ref()
     }
 
-    /// Returns offset indexes in this file.
+    /// Returns the column index for this file if loaded
+    pub fn column_index(&self) -> Option<&ParquetColumnIndex> {
+        self.column_index.as_ref()
+    }
+
+    /// Returns the offset index for this file if loaded
+    #[deprecated(note = "Use Self::offset_index")]
     pub fn offset_indexes(&self) -> Option<&ParquetOffsetIndex> {
-        self.offset_indexes.as_ref()
+        self.offset_index.as_ref()
+    }
+
+    /// Returns offset indexes in this file.
+    pub fn offset_index(&self) -> Option<&ParquetOffsetIndex> {
+        self.offset_index.as_ref()
+    }
+
+    /// Override the column index
+    #[cfg(feature = "arrow")]
+    pub(crate) fn set_column_index(&mut self, index: Option<ParquetColumnIndex>) {
+        self.column_index = index;
+    }
+
+    /// Override the offset index
+    #[cfg(feature = "arrow")]
+    pub(crate) fn set_offset_index(&mut self, index: Option<ParquetOffsetIndex>) {
+        self.offset_index = index;
     }
 }
 
-pub type KeyValue = parquet_format::KeyValue;
+pub type KeyValue = crate::format::KeyValue;
 
 /// Reference counted pointer for [`FileMetaData`].
 pub type FileMetaDataPtr = Arc<FileMetaData>;
@@ -185,7 +230,9 @@ impl FileMetaData {
         self.key_value_metadata.as_ref()
     }
 
-    /// Returns Parquet ['Type`] that describes schema in this file.
+    /// Returns Parquet [`Type`] that describes schema in this file.
+    ///
+    /// [`Type`]: crate::schema::types::Type
     pub fn schema(&self) -> &SchemaType {
         self.schema_descr.root_schema()
     }
@@ -229,13 +276,16 @@ pub type RowGroupMetaDataPtr = Arc<RowGroupMetaData>;
 pub struct RowGroupMetaData {
     columns: Vec<ColumnChunkMetaData>,
     num_rows: i64,
+    sorting_columns: Option<Vec<SortingColumn>>,
     total_byte_size: i64,
     schema_descr: SchemaDescPtr,
-    page_offset_index: Option<Vec<Vec<PageLocation>>>,
+    // We can't infer from file offset of first column since there may empty columns in row group.
+    file_offset: Option<i64>,
+    ordinal: Option<i16>,
 }
 
 impl RowGroupMetaData {
-    /// Returns builer for row group metadata.
+    /// Returns builder for row group metadata.
     pub fn builder(schema_descr: SchemaDescPtr) -> RowGroupMetaDataBuilder {
         RowGroupMetaDataBuilder::new(schema_descr)
     }
@@ -260,6 +310,11 @@ impl RowGroupMetaData {
         self.num_rows
     }
 
+    /// Returns the sort ordering of the rows in this RowGroup if any
+    pub fn sorting_columns(&self) -> Option<&Vec<SortingColumn>> {
+        self.sorting_columns.as_ref()
+    }
+
     /// Total byte size of all uncompressed column data in this row group.
     pub fn total_byte_size(&self) -> i64 {
         self.total_byte_size
@@ -270,11 +325,6 @@ impl RowGroupMetaData {
         self.columns.iter().map(|c| c.total_compressed_size).sum()
     }
 
-    /// Returns reference of page offset index of all column in this row group.
-    pub fn page_offset_index(&self) -> &Option<Vec<Vec<PageLocation>>> {
-        &self.page_offset_index
-    }
-
     /// Returns reference to a schema descriptor.
     pub fn schema_descr(&self) -> &SchemaDescriptor {
         self.schema_descr.as_ref()
@@ -285,17 +335,27 @@ impl RowGroupMetaData {
         self.schema_descr.clone()
     }
 
-    /// Sets page offset index for this row group.
-    pub fn set_page_offset(&mut self, page_offset: Vec<Vec<PageLocation>>) {
-        self.page_offset_index = Some(page_offset);
+    /// Returns ordinal of this row group in file
+    #[inline(always)]
+    pub fn ordinal(&self) -> Option<i16> {
+        self.ordinal
+    }
+
+    /// Returns file offset of this row group in file.
+    #[inline(always)]
+    pub fn file_offset(&self) -> Option<i64> {
+        self.file_offset
     }
 
     /// Method to convert from Thrift.
-    pub fn from_thrift(
-        schema_descr: SchemaDescPtr,
-        mut rg: RowGroup,
-    ) -> Result<RowGroupMetaData> {
-        assert_eq!(schema_descr.num_columns(), rg.columns.len());
+    pub fn from_thrift(schema_descr: SchemaDescPtr, mut rg: RowGroup) -> Result<RowGroupMetaData> {
+        if schema_descr.num_columns() != rg.columns.len() {
+            return Err(general_err!(
+                "Column count mismatch. Schema has {} columns while Row Group has {}",
+                schema_descr.num_columns(),
+                rg.columns.len()
+            ));
+        }
         let total_byte_size = rg.total_byte_size;
         let num_rows = rg.num_rows;
         let mut columns = vec![];
@@ -303,12 +363,15 @@ impl RowGroupMetaData {
             let cc = ColumnChunkMetaData::from_thrift(d.clone(), c)?;
             columns.push(cc);
         }
+        let sorting_columns = rg.sorting_columns;
         Ok(RowGroupMetaData {
             columns,
             num_rows,
+            sorting_columns,
             total_byte_size,
             schema_descr,
-            page_offset_index: None,
+            file_offset: rg.file_offset,
+            ordinal: rg.ordinal,
         })
     }
 
@@ -318,84 +381,88 @@ impl RowGroupMetaData {
             columns: self.columns().iter().map(|v| v.to_thrift()).collect(),
             total_byte_size: self.total_byte_size,
             num_rows: self.num_rows,
-            sorting_columns: None,
-            file_offset: None,
-            total_compressed_size: None,
-            ordinal: None,
+            sorting_columns: self.sorting_columns().cloned(),
+            file_offset: self.file_offset(),
+            total_compressed_size: Some(self.compressed_size()),
+            ordinal: self.ordinal,
         }
     }
+
+    /// Converts this [`RowGroupMetaData`] into a [`RowGroupMetaDataBuilder`]
+    pub fn into_builder(self) -> RowGroupMetaDataBuilder {
+        RowGroupMetaDataBuilder(self)
+    }
 }
 
 /// Builder for row group metadata.
-pub struct RowGroupMetaDataBuilder {
-    columns: Vec<ColumnChunkMetaData>,
-    schema_descr: SchemaDescPtr,
-    num_rows: i64,
-    total_byte_size: i64,
-    page_offset_index: Option<Vec<Vec<PageLocation>>>,
-}
+pub struct RowGroupMetaDataBuilder(RowGroupMetaData);
 
 impl RowGroupMetaDataBuilder {
     /// Creates new builder from schema descriptor.
     fn new(schema_descr: SchemaDescPtr) -> Self {
-        Self {
+        Self(RowGroupMetaData {
             columns: Vec::with_capacity(schema_descr.num_columns()),
             schema_descr,
+            file_offset: None,
             num_rows: 0,
+            sorting_columns: None,
             total_byte_size: 0,
-            page_offset_index: None,
-        }
+            ordinal: None,
+        })
     }
 
     /// Sets number of rows in this row group.
     pub fn set_num_rows(mut self, value: i64) -> Self {
-        self.num_rows = value;
+        self.0.num_rows = value;
+        self
+    }
+
+    /// Sets the sorting order for columns
+    pub fn set_sorting_columns(mut self, value: Option<Vec<SortingColumn>>) -> Self {
+        self.0.sorting_columns = value;
         self
     }
 
     /// Sets total size in bytes for this row group.
     pub fn set_total_byte_size(mut self, value: i64) -> Self {
-        self.total_byte_size = value;
+        self.0.total_byte_size = value;
         self
     }
 
     /// Sets column metadata for this row group.
     pub fn set_column_metadata(mut self, value: Vec<ColumnChunkMetaData>) -> Self {
-        self.columns = value;
+        self.0.columns = value;
         self
     }
 
-    /// Sets page offset index for this row group.
-    pub fn set_page_offset(mut self, page_offset: Vec<Vec<PageLocation>>) -> Self {
-        self.page_offset_index = Some(page_offset);
+    /// Sets ordinal for this row group.
+    pub fn set_ordinal(mut self, value: i16) -> Self {
+        self.0.ordinal = Some(value);
+        self
+    }
+
+    pub fn set_file_offset(mut self, value: i64) -> Self {
+        self.0.file_offset = Some(value);
         self
     }
 
     /// Builds row group metadata.
     pub fn build(self) -> Result<RowGroupMetaData> {
-        if self.schema_descr.num_columns() != self.columns.len() {
+        if self.0.schema_descr.num_columns() != self.0.columns.len() {
             return Err(general_err!(
                 "Column length mismatch: {} != {}",
-                self.schema_descr.num_columns(),
-                self.columns.len()
+                self.0.schema_descr.num_columns(),
+                self.0.columns.len()
             ));
         }
 
-        Ok(RowGroupMetaData {
-            columns: self.columns,
-            num_rows: self.num_rows,
-            total_byte_size: self.total_byte_size,
-            schema_descr: self.schema_descr,
-            page_offset_index: self.page_offset_index,
-        })
+        Ok(self.0)
     }
 }
 
 /// Metadata for a column chunk.
 #[derive(Debug, Clone, PartialEq)]
 pub struct ColumnChunkMetaData {
-    column_type: Type,
-    column_path: ColumnPath,
     column_descr: ColumnDescPtr,
     encodings: Vec<Encoding>,
     file_path: Option<String>,
@@ -410,6 +477,7 @@ pub struct ColumnChunkMetaData {
     statistics: Option<Statistics>,
     encoding_stats: Option<Vec<PageEncodingStats>>,
     bloom_filter_offset: Option<i64>,
+    bloom_filter_length: Option<i32>,
     offset_index_offset: Option<i64>,
     offset_index_length: Option<i32>,
     column_index_offset: Option<i64>,
@@ -438,12 +506,12 @@ impl ColumnChunkMetaData {
 
     /// Type of this column. Must be primitive.
     pub fn column_type(&self) -> Type {
-        self.column_type
+        self.column_descr.physical_type()
     }
 
     /// Path (or identifier) of this column.
     pub fn column_path(&self) -> &ColumnPath {
-        &self.column_path
+        self.column_descr.path()
     }
 
     /// Descriptor for this column.
@@ -527,6 +595,11 @@ impl ColumnChunkMetaData {
         self.bloom_filter_offset
     }
 
+    /// Returns the offset for the bloom filter.
+    pub fn bloom_filter_length(&self) -> Option<i32> {
+        self.bloom_filter_length
+    }
+
     /// Returns the offset for the column index.
     pub fn column_index_offset(&self) -> Option<i64> {
         self.column_index_offset
@@ -537,6 +610,13 @@ impl ColumnChunkMetaData {
         self.column_index_length
     }
 
+    /// Returns the range for the offset index if any
+    pub(crate) fn column_index_range(&self) -> Option<Range<usize>> {
+        let offset = usize::try_from(self.column_index_offset?).ok()?;
+        let length = usize::try_from(self.column_index_length?).ok()?;
+        Some(offset..(offset + length))
+    }
+
     /// Returns the offset for the offset index.
     pub fn offset_index_offset(&self) -> Option<i64> {
         self.offset_index_offset
@@ -547,20 +627,26 @@ impl ColumnChunkMetaData {
         self.offset_index_length
     }
 
+    /// Returns the range for the offset index if any
+    pub(crate) fn offset_index_range(&self) -> Option<Range<usize>> {
+        let offset = usize::try_from(self.offset_index_offset?).ok()?;
+        let length = usize::try_from(self.offset_index_length?).ok()?;
+        Some(offset..(offset + length))
+    }
+
     /// Method to convert from Thrift.
     pub fn from_thrift(column_descr: ColumnDescPtr, cc: ColumnChunk) -> Result<Self> {
         if cc.meta_data.is_none() {
             return Err(general_err!("Expected to have column metadata"));
         }
         let mut col_metadata: ColumnMetaData = cc.meta_data.unwrap();
-        let column_type = Type::from(col_metadata.type_);
-        let column_path = ColumnPath::new(col_metadata.path_in_schema);
+        let column_type = Type::try_from(col_metadata.type_)?;
         let encodings = col_metadata
             .encodings
             .drain(0..)
-            .map(Encoding::from)
-            .collect();
-        let compression = Compression::from(col_metadata.codec);
+            .map(Encoding::try_from)
+            .collect::<Result<_>>()?;
+        let compression = Compression::try_from(col_metadata.codec)?;
         let file_path = cc.file_path;
         let file_offset = cc.file_offset;
         let num_values = col_metadata.num_values;
@@ -569,20 +655,24 @@ impl ColumnChunkMetaData {
         let data_page_offset = col_metadata.data_page_offset;
         let index_page_offset = col_metadata.index_page_offset;
         let dictionary_page_offset = col_metadata.dictionary_page_offset;
-        let statistics = statistics::from_thrift(column_type, col_metadata.statistics);
+        let statistics = statistics::from_thrift(column_type, col_metadata.statistics)?;
         let encoding_stats = col_metadata
             .encoding_stats
             .as_ref()
-            .map(|vec| vec.iter().map(page_encoding_stats::from_thrift).collect());
+            .map(|vec| {
+                vec.iter()
+                    .map(page_encoding_stats::try_from_thrift)
+                    .collect::<Result<_>>()
+            })
+            .transpose()?;
         let bloom_filter_offset = col_metadata.bloom_filter_offset;
+        let bloom_filter_length = col_metadata.bloom_filter_length;
         let offset_index_offset = cc.offset_index_offset;
         let offset_index_length = cc.offset_index_length;
         let column_index_offset = cc.column_index_offset;
         let column_index_length = cc.column_index_length;
 
         let result = ColumnChunkMetaData {
-            column_type,
-            column_path,
             column_descr,
             encodings,
             file_path,
@@ -597,6 +687,7 @@ impl ColumnChunkMetaData {
             statistics,
             encoding_stats,
             bloom_filter_offset,
+            bloom_filter_length,
             offset_index_offset,
             offset_index_length,
             column_index_offset,
@@ -625,9 +716,9 @@ impl ColumnChunkMetaData {
     /// Method to convert to Thrift `ColumnMetaData`
     pub fn to_column_metadata_thrift(&self) -> ColumnMetaData {
         ColumnMetaData {
-            type_: self.column_type.into(),
+            type_: self.column_type().into(),
             encodings: self.encodings().iter().map(|&v| v.into()).collect(),
-            path_in_schema: Vec::from(self.column_path.as_ref()),
+            path_in_schema: self.column_path().as_ref().to_vec(),
             codec: self.compression.into(),
             num_values: self.num_values,
             total_uncompressed_size: self.total_uncompressed_size,
@@ -642,36 +733,23 @@ impl ColumnChunkMetaData {
                 .as_ref()
                 .map(|vec| vec.iter().map(page_encoding_stats::to_thrift).collect()),
             bloom_filter_offset: self.bloom_filter_offset,
+            bloom_filter_length: self.bloom_filter_length,
         }
     }
+
+    /// Converts this [`ColumnChunkMetaData`] into a [`ColumnChunkMetaDataBuilder`]
+    pub fn into_builder(self) -> ColumnChunkMetaDataBuilder {
+        ColumnChunkMetaDataBuilder(self)
+    }
 }
 
 /// Builder for column chunk metadata.
-pub struct ColumnChunkMetaDataBuilder {
-    column_descr: ColumnDescPtr,
-    encodings: Vec<Encoding>,
-    file_path: Option<String>,
-    file_offset: i64,
-    num_values: i64,
-    compression: Compression,
-    total_compressed_size: i64,
-    total_uncompressed_size: i64,
-    data_page_offset: i64,
-    index_page_offset: Option<i64>,
-    dictionary_page_offset: Option<i64>,
-    statistics: Option<Statistics>,
-    encoding_stats: Option<Vec<PageEncodingStats>>,
-    bloom_filter_offset: Option<i64>,
-    offset_index_offset: Option<i64>,
-    offset_index_length: Option<i32>,
-    column_index_offset: Option<i64>,
-    column_index_length: Option<i32>,
-}
+pub struct ColumnChunkMetaDataBuilder(ColumnChunkMetaData);
 
 impl ColumnChunkMetaDataBuilder {
     /// Creates new column chunk metadata builder.
     fn new(column_descr: ColumnDescPtr) -> Self {
-        Self {
+        Self(ColumnChunkMetaData {
             column_descr,
             encodings: Vec::new(),
             file_path: None,
@@ -686,139 +764,125 @@ impl ColumnChunkMetaDataBuilder {
             statistics: None,
             encoding_stats: None,
             bloom_filter_offset: None,
+            bloom_filter_length: None,
             offset_index_offset: None,
             offset_index_length: None,
             column_index_offset: None,
             column_index_length: None,
-        }
+        })
     }
 
     /// Sets list of encodings for this column chunk.
     pub fn set_encodings(mut self, encodings: Vec<Encoding>) -> Self {
-        self.encodings = encodings;
+        self.0.encodings = encodings;
         self
     }
 
     /// Sets optional file path for this column chunk.
     pub fn set_file_path(mut self, value: String) -> Self {
-        self.file_path = Some(value);
+        self.0.file_path = Some(value);
         self
     }
 
     /// Sets file offset in bytes.
     pub fn set_file_offset(mut self, value: i64) -> Self {
-        self.file_offset = value;
+        self.0.file_offset = value;
         self
     }
 
     /// Sets number of values.
     pub fn set_num_values(mut self, value: i64) -> Self {
-        self.num_values = value;
+        self.0.num_values = value;
         self
     }
 
     /// Sets compression.
     pub fn set_compression(mut self, value: Compression) -> Self {
-        self.compression = value;
+        self.0.compression = value;
         self
     }
 
     /// Sets total compressed size in bytes.
     pub fn set_total_compressed_size(mut self, value: i64) -> Self {
-        self.total_compressed_size = value;
+        self.0.total_compressed_size = value;
         self
     }
 
     /// Sets total uncompressed size in bytes.
     pub fn set_total_uncompressed_size(mut self, value: i64) -> Self {
-        self.total_uncompressed_size = value;
+        self.0.total_uncompressed_size = value;
         self
     }
 
     /// Sets data page offset in bytes.
     pub fn set_data_page_offset(mut self, value: i64) -> Self {
-        self.data_page_offset = value;
+        self.0.data_page_offset = value;
         self
     }
 
     /// Sets optional dictionary page ofset in bytes.
     pub fn set_dictionary_page_offset(mut self, value: Option<i64>) -> Self {
-        self.dictionary_page_offset = value;
+        self.0.dictionary_page_offset = value;
         self
     }
 
     /// Sets optional index page offset in bytes.
     pub fn set_index_page_offset(mut self, value: Option<i64>) -> Self {
-        self.index_page_offset = value;
+        self.0.index_page_offset = value;
         self
     }
 
     /// Sets statistics for this column chunk.
     pub fn set_statistics(mut self, value: Statistics) -> Self {
-        self.statistics = Some(value);
+        self.0.statistics = Some(value);
         self
     }
 
     /// Sets page encoding stats for this column chunk.
     pub fn set_page_encoding_stats(mut self, value: Vec<PageEncodingStats>) -> Self {
-        self.encoding_stats = Some(value);
+        self.0.encoding_stats = Some(value);
         self
     }
 
     /// Sets optional bloom filter offset in bytes.
     pub fn set_bloom_filter_offset(mut self, value: Option<i64>) -> Self {
-        self.bloom_filter_offset = value;
+        self.0.bloom_filter_offset = value;
+        self
+    }
+
+    /// Sets optional bloom filter length in bytes.
+    pub fn set_bloom_filter_length(mut self, value: Option<i32>) -> Self {
+        self.0.bloom_filter_length = value;
         self
     }
 
     /// Sets optional offset index offset in bytes.
     pub fn set_offset_index_offset(mut self, value: Option<i64>) -> Self {
-        self.offset_index_offset = value;
+        self.0.offset_index_offset = value;
         self
     }
 
     /// Sets optional offset index length in bytes.
     pub fn set_offset_index_length(mut self, value: Option<i32>) -> Self {
-        self.offset_index_length = value;
+        self.0.offset_index_length = value;
         self
     }
 
     /// Sets optional column index offset in bytes.
     pub fn set_column_index_offset(mut self, value: Option<i64>) -> Self {
-        self.column_index_offset = value;
+        self.0.column_index_offset = value;
         self
     }
 
     /// Sets optional column index length in bytes.
     pub fn set_column_index_length(mut self, value: Option<i32>) -> Self {
-        self.column_index_length = value;
+        self.0.column_index_length = value;
         self
     }
 
     /// Builds column chunk metadata.
     pub fn build(self) -> Result<ColumnChunkMetaData> {
-        Ok(ColumnChunkMetaData {
-            column_type: self.column_descr.physical_type(),
-            column_path: self.column_descr.path().clone(),
-            column_descr: self.column_descr,
-            encodings: self.encodings,
-            file_path: self.file_path,
-            file_offset: self.file_offset,
-            num_values: self.num_values,
-            compression: self.compression,
-            total_compressed_size: self.total_compressed_size,
-            total_uncompressed_size: self.total_uncompressed_size,
-            data_page_offset: self.data_page_offset,
-            index_page_offset: self.index_page_offset,
-            dictionary_page_offset: self.dictionary_page_offset,
-            statistics: self.statistics,
-            encoding_stats: self.encoding_stats,
-            bloom_filter_offset: self.bloom_filter_offset,
-            offset_index_offset: self.offset_index_offset,
-            offset_index_length: self.offset_index_length,
-            column_index_offset: self.column_index_offset,
-            column_index_length: self.column_index_length,
-        })
+        Ok(self.0)
     }
 }
 
@@ -827,9 +891,8 @@ pub struct ColumnIndexBuilder {
     null_pages: Vec<bool>,
     min_values: Vec<Vec<u8>>,
     max_values: Vec<Vec<u8>>,
-    // TODO: calc the order for all pages in this column
-    boundary_order: BoundaryOrder,
     null_counts: Vec<i64>,
+    boundary_order: BoundaryOrder,
     // If one page can't get build index, need to ignore all index in this column
     valid: bool,
 }
@@ -846,8 +909,8 @@ impl ColumnIndexBuilder {
             null_pages: Vec::new(),
             min_values: Vec::new(),
             max_values: Vec::new(),
-            boundary_order: BoundaryOrder::Unordered,
             null_counts: Vec::new(),
+            boundary_order: BoundaryOrder::UNORDERED,
             valid: true,
         }
     }
@@ -855,16 +918,20 @@ impl ColumnIndexBuilder {
     pub fn append(
         &mut self,
         null_page: bool,
-        min_value: &[u8],
-        max_value: &[u8],
+        min_value: Vec<u8>,
+        max_value: Vec<u8>,
         null_count: i64,
     ) {
         self.null_pages.push(null_page);
-        self.min_values.push(min_value.to_vec());
-        self.max_values.push(max_value.to_vec());
+        self.min_values.push(min_value);
+        self.max_values.push(max_value);
         self.null_counts.push(null_count);
     }
 
+    pub fn set_boundary_order(&mut self, boundary_order: BoundaryOrder) {
+        self.boundary_order = boundary_order;
+    }
+
     pub fn to_invalid(&mut self) {
         self.valid = false;
     }
@@ -927,9 +994,7 @@ impl OffsetIndexBuilder {
             .iter()
             .zip(self.compressed_page_size_array.iter())
             .zip(self.first_row_index_array.iter())
-            .map(|((offset, size), row_index)| {
-                PageLocation::new(*offset, *size, *row_index)
-            })
+            .map(|((offset, size), row_index)| PageLocation::new(*offset, *size, *row_index))
             .collect::<Vec<_>>();
         OffsetIndex::new(locations)
     }
@@ -953,14 +1018,14 @@ mod tests {
             .set_num_rows(1000)
             .set_total_byte_size(2000)
             .set_column_metadata(columns)
+            .set_ordinal(1)
             .build()
             .unwrap();
 
         let row_group_exp = row_group_meta.to_thrift();
-        let row_group_res =
-            RowGroupMetaData::from_thrift(schema_descr, row_group_exp.clone())
-                .unwrap()
-                .to_thrift();
+        let row_group_res = RowGroupMetaData::from_thrift(schema_descr, row_group_exp.clone())
+            .unwrap()
+            .to_thrift();
 
         assert_eq!(row_group_res, row_group_exp);
     }
@@ -974,12 +1039,81 @@ mod tests {
         assert!(row_group_meta.is_err());
         if let Err(e) = row_group_meta {
             assert_eq!(
-                format!("{}", e),
+                format!("{e}"),
                 "Parquet error: Column length mismatch: 2 != 0"
             );
         }
     }
 
+    /// Test reading a corrupted Parquet file with 3 columns in its schema but only 2 in its row group
+    #[test]
+    fn test_row_group_metadata_thrift_corrupted() {
+        let schema_descr_2cols = Arc::new(SchemaDescriptor::new(Arc::new(
+            SchemaType::group_type_builder("schema")
+                .with_fields(vec![
+                    Arc::new(
+                        SchemaType::primitive_type_builder("a", Type::INT32)
+                            .build()
+                            .unwrap(),
+                    ),
+                    Arc::new(
+                        SchemaType::primitive_type_builder("b", Type::INT32)
+                            .build()
+                            .unwrap(),
+                    ),
+                ])
+                .build()
+                .unwrap(),
+        )));
+
+        let schema_descr_3cols = Arc::new(SchemaDescriptor::new(Arc::new(
+            SchemaType::group_type_builder("schema")
+                .with_fields(vec![
+                    Arc::new(
+                        SchemaType::primitive_type_builder("a", Type::INT32)
+                            .build()
+                            .unwrap(),
+                    ),
+                    Arc::new(
+                        SchemaType::primitive_type_builder("b", Type::INT32)
+                            .build()
+                            .unwrap(),
+                    ),
+                    Arc::new(
+                        SchemaType::primitive_type_builder("c", Type::INT32)
+                            .build()
+                            .unwrap(),
+                    ),
+                ])
+                .build()
+                .unwrap(),
+        )));
+
+        let row_group_meta_2cols = RowGroupMetaData::builder(schema_descr_2cols.clone())
+            .set_num_rows(1000)
+            .set_total_byte_size(2000)
+            .set_column_metadata(vec![
+                ColumnChunkMetaData::builder(schema_descr_2cols.column(0))
+                    .build()
+                    .unwrap(),
+                ColumnChunkMetaData::builder(schema_descr_2cols.column(1))
+                    .build()
+                    .unwrap(),
+            ])
+            .set_ordinal(1)
+            .build()
+            .unwrap();
+
+        let err =
+            RowGroupMetaData::from_thrift(schema_descr_3cols, row_group_meta_2cols.to_thrift())
+                .unwrap_err()
+                .to_string();
+        assert_eq!(
+            err,
+            "Parquet error: Column count mismatch. Schema has 3 columns while Row Group has 2"
+        );
+    }
+
     #[test]
     fn test_column_chunk_metadata_thrift_conversion() {
         let column_descr = get_test_schema_descr().column(0);
@@ -1007,6 +1141,7 @@ mod tests {
                 },
             ])
             .set_bloom_filter_offset(Some(6000))
+            .set_bloom_filter_length(Some(25))
             .set_offset_index_offset(Some(7000))
             .set_offset_index_length(Some(25))
             .set_column_index_offset(Some(8000))
@@ -1015,8 +1150,7 @@ mod tests {
             .unwrap();
 
         let col_chunk_res =
-            ColumnChunkMetaData::from_thrift(column_descr, col_metadata.to_thrift())
-                .unwrap();
+            ColumnChunkMetaData::from_thrift(column_descr, col_metadata.to_thrift()).unwrap();
 
         assert_eq!(col_chunk_res, col_metadata);
     }
@@ -1030,10 +1164,9 @@ mod tests {
             .unwrap();
 
         let col_chunk_exp = col_metadata.to_thrift();
-        let col_chunk_res =
-            ColumnChunkMetaData::from_thrift(column_descr, col_chunk_exp.clone())
-                .unwrap()
-                .to_thrift();
+        let col_chunk_res = ColumnChunkMetaData::from_thrift(column_descr, col_chunk_exp.clone())
+            .unwrap()
+            .to_thrift();
 
         assert_eq!(col_chunk_res, col_chunk_exp);
     }
@@ -1066,7 +1199,7 @@ mod tests {
     /// Returns sample schema descriptor so we can create column metadata.
     fn get_test_schema_descr() -> SchemaDescPtr {
         let schema = SchemaType::group_type_builder("schema")
-            .with_fields(&mut vec![
+            .with_fields(vec![
                 Arc::new(
                     SchemaType::primitive_type_builder("a", Type::INT32)
                         .build()
diff --git a/parquet/src/file/mod.rs b/parquet/src/file/mod.rs
index 66d8ce48e0a7..6589d2efaf8b 100644
--- a/parquet/src/file/mod.rs
+++ b/parquet/src/file/mod.rs
@@ -15,7 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Main entrypoint for working with Parquet API.
+//! Low level APIs for reading raw parquet data.
 //!
 //! Provides access to file and row group readers and writers, record API, metadata, etc.
 //!
@@ -45,9 +45,8 @@
 //!   }
 //! ";
 //! let schema = Arc::new(parse_message_type(message_type).unwrap());
-//! let props = Arc::new(WriterProperties::builder().build());
 //! let file = fs::File::create(&path).unwrap();
-//! let mut writer = SerializedFileWriter::new(file, schema, props).unwrap();
+//! let mut writer = SerializedFileWriter::new(file, schema, Default::default()).unwrap();
 //! let mut row_group_writer = writer.next_row_group().unwrap();
 //! while let Some(mut col_writer) = row_group_writer.next_column().unwrap() {
 //!     // ... write values to a column writer
@@ -92,7 +91,7 @@
 //!     .flat_map(|r| r.into_iter());
 //!
 //! for row in rows {
-//!     println!("{}", row);
+//!     println!("{}", row.unwrap());
 //! }
 //! ```
 pub mod footer;
diff --git a/parquet/src/file/page_encoding_stats.rs b/parquet/src/file/page_encoding_stats.rs
index e499a094ae00..c941d401175c 100644
--- a/parquet/src/file/page_encoding_stats.rs
+++ b/parquet/src/file/page_encoding_stats.rs
@@ -15,8 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Per-page encoding information.
+
 use crate::basic::{Encoding, PageType};
-use parquet_format::{
+use crate::errors::Result;
+use crate::format::{
     Encoding as TEncoding, PageEncodingStats as TPageEncodingStats, PageType as TPageType,
 };
 
@@ -32,16 +35,16 @@ pub struct PageEncodingStats {
 }
 
 /// Converts Thrift definition into `PageEncodingStats`.
-pub fn from_thrift(thrift_encoding_stats: &TPageEncodingStats) -> PageEncodingStats {
-    let page_type = PageType::from(thrift_encoding_stats.page_type);
-    let encoding = Encoding::from(thrift_encoding_stats.encoding);
+pub fn try_from_thrift(thrift_encoding_stats: &TPageEncodingStats) -> Result<PageEncodingStats> {
+    let page_type = PageType::try_from(thrift_encoding_stats.page_type)?;
+    let encoding = Encoding::try_from(thrift_encoding_stats.encoding)?;
     let count = thrift_encoding_stats.count;
 
-    PageEncodingStats {
+    Ok(PageEncodingStats {
         page_type,
         encoding,
         count,
-    }
+    })
 }
 
 /// Converts `PageEncodingStats` into Thrift definition.
@@ -70,6 +73,6 @@ mod tests {
             count: 1,
         };
 
-        assert_eq!(from_thrift(&to_thrift(&stats)), stats);
+        assert_eq!(try_from_thrift(&to_thrift(&stats)).unwrap(), stats);
     }
 }
diff --git a/parquet/src/file/page_index/index.rs b/parquet/src/file/page_index/index.rs
index f29b80accae2..f3a09046a63c 100644
--- a/parquet/src/file/page_index/index.rs
+++ b/parquet/src/file/page_index/index.rs
@@ -15,15 +15,24 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! [`Index`] structures holding decoded [`ColumnIndex`] information
+
 use crate::basic::Type;
 use crate::data_type::private::ParquetValueType;
-use crate::data_type::Int96;
+use crate::data_type::{ByteArray, FixedLenByteArray, Int96};
 use crate::errors::ParquetError;
+use crate::format::{BoundaryOrder, ColumnIndex};
 use crate::util::bit_util::from_le_slice;
-use parquet_format::{BoundaryOrder, ColumnIndex};
 use std::fmt::Debug;
 
-/// The statistics in one page
+/// PageIndex Statistics for one data page, as described in [Column Index].
+///
+/// One significant difference from the row group level
+/// [`Statistics`](crate::format::Statistics) is that page level
+/// statistics may not store actual column values as min and max
+/// (e.g. they may store truncated strings to save space)
+///
+/// [Column Index]: https://github.com/apache/parquet-format/blob/master/PageIndex.md
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct PageIndex<T> {
     /// The minimum value, It is None when all values are null
@@ -48,38 +57,69 @@ impl<T> PageIndex<T> {
 
 #[derive(Debug, Clone, PartialEq)]
 #[allow(non_camel_case_types)]
+/// Typed statistics for a data page in a column chunk. This structure
+/// is obtained from decoding the [ColumnIndex] in the parquet file
+/// and can be used to skip decoding pages while reading the file
+/// data.
 pub enum Index {
     /// Sometimes reading page index from parquet file
     /// will only return pageLocations without min_max index,
     /// `NONE` represents this lack of index information
     NONE,
-    BOOLEAN(BooleanIndex),
+    BOOLEAN(NativeIndex<bool>),
     INT32(NativeIndex<i32>),
     INT64(NativeIndex<i64>),
     INT96(NativeIndex<Int96>),
     FLOAT(NativeIndex<f32>),
     DOUBLE(NativeIndex<f64>),
-    BYTE_ARRAY(ByteArrayIndex),
-    FIXED_LEN_BYTE_ARRAY(ByteArrayIndex),
+    BYTE_ARRAY(NativeIndex<ByteArray>),
+    FIXED_LEN_BYTE_ARRAY(NativeIndex<FixedLenByteArray>),
+}
+
+impl Index {
+    /// Return min/max elements inside ColumnIndex are ordered or not.
+    pub fn is_sorted(&self) -> bool {
+        // 0:UNORDERED, 1:ASCENDING ,2:DESCENDING,
+        if let Some(order) = self.get_boundary_order() {
+            order.0 > (BoundaryOrder::UNORDERED.0)
+        } else {
+            false
+        }
+    }
+
+    /// Get boundary_order of this page index.
+    pub fn get_boundary_order(&self) -> Option<BoundaryOrder> {
+        match self {
+            Index::NONE => None,
+            Index::BOOLEAN(index) => Some(index.boundary_order),
+            Index::INT32(index) => Some(index.boundary_order),
+            Index::INT64(index) => Some(index.boundary_order),
+            Index::INT96(index) => Some(index.boundary_order),
+            Index::FLOAT(index) => Some(index.boundary_order),
+            Index::DOUBLE(index) => Some(index.boundary_order),
+            Index::BYTE_ARRAY(index) => Some(index.boundary_order),
+            Index::FIXED_LEN_BYTE_ARRAY(index) => Some(index.boundary_order),
+        }
+    }
 }
 
-/// An index of a column of [`Type`] physical representation
+/// Stores the [`PageIndex`] for each page of a column
 #[derive(Debug, Clone, PartialEq, Eq, Hash)]
 pub struct NativeIndex<T: ParquetValueType> {
-    /// The physical type
-    pub physical_type: Type,
     /// The indexes, one item per page
     pub indexes: Vec<PageIndex<T>>,
-    /// the order
+    /// If the min/max elements are ordered, and if so in which
+    /// direction. See [source] for details.
+    ///
+    /// [source]: https://github.com/apache/parquet-format/blob/bfc549b93e6927cb1fc425466e4084f76edc6d22/src/main/thrift/parquet.thrift#L959-L964
     pub boundary_order: BoundaryOrder,
 }
 
 impl<T: ParquetValueType> NativeIndex<T> {
+    pub const PHYSICAL_TYPE: Type = T::PHYSICAL_TYPE;
+
     /// Creates a new [`NativeIndex`]
-    pub(crate) fn try_new(
-        index: ColumnIndex,
-        physical_type: Type,
-    ) -> Result<Self, ParquetError> {
+    pub(crate) fn try_new(index: ColumnIndex) -> Result<Self, ParquetError> {
         let len = index.min_values.len();
 
         let null_counts = index
@@ -109,103 +149,6 @@ impl<T: ParquetValueType> NativeIndex<T> {
             })
             .collect::<Result<Vec<_>, ParquetError>>()?;
 
-        Ok(Self {
-            physical_type,
-            indexes,
-            boundary_order: index.boundary_order,
-        })
-    }
-}
-
-/// An index of a column of bytes type
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct ByteArrayIndex {
-    /// The physical type
-    pub physical_type: Type,
-    /// The indexes, one item per page
-    pub indexes: Vec<PageIndex<Vec<u8>>>,
-    pub boundary_order: BoundaryOrder,
-}
-
-impl ByteArrayIndex {
-    pub(crate) fn try_new(
-        index: ColumnIndex,
-        physical_type: Type,
-    ) -> Result<Self, ParquetError> {
-        let len = index.min_values.len();
-
-        let null_counts = index
-            .null_counts
-            .map(|x| x.into_iter().map(Some).collect::<Vec<_>>())
-            .unwrap_or_else(|| vec![None; len]);
-
-        let indexes = index
-            .min_values
-            .into_iter()
-            .zip(index.max_values.into_iter())
-            .zip(index.null_pages.into_iter())
-            .zip(null_counts.into_iter())
-            .map(|(((min, max), is_null), null_count)| {
-                let (min, max) = if is_null {
-                    (None, None)
-                } else {
-                    (Some(min), Some(max))
-                };
-                Ok(PageIndex {
-                    min,
-                    max,
-                    null_count,
-                })
-            })
-            .collect::<Result<Vec<_>, ParquetError>>()?;
-
-        Ok(Self {
-            physical_type,
-            indexes,
-            boundary_order: index.boundary_order,
-        })
-    }
-}
-
-/// An index of a column of boolean physical type
-#[derive(Debug, Clone, PartialEq, Eq, Hash)]
-pub struct BooleanIndex {
-    /// The indexes, one item per page
-    pub indexes: Vec<PageIndex<bool>>,
-    pub boundary_order: BoundaryOrder,
-}
-
-impl BooleanIndex {
-    pub(crate) fn try_new(index: ColumnIndex) -> Result<Self, ParquetError> {
-        let len = index.min_values.len();
-
-        let null_counts = index
-            .null_counts
-            .map(|x| x.into_iter().map(Some).collect::<Vec<_>>())
-            .unwrap_or_else(|| vec![None; len]);
-
-        let indexes = index
-            .min_values
-            .into_iter()
-            .zip(index.max_values.into_iter())
-            .zip(index.null_pages.into_iter())
-            .zip(null_counts.into_iter())
-            .map(|(((min, max), is_null), null_count)| {
-                let (min, max) = if is_null {
-                    (None, None)
-                } else {
-                    let min = min[0] != 0;
-                    let max = max[0] == 1;
-                    (Some(min), Some(max))
-                };
-                Ok(PageIndex {
-                    min,
-                    max,
-                    null_count,
-                })
-            })
-            .collect::<Result<Vec<_>, ParquetError>>()?;
-
         Ok(Self {
             indexes,
             boundary_order: index.boundary_order,
diff --git a/parquet/src/file/page_index/index_reader.rs b/parquet/src/file/page_index/index_reader.rs
index 33499e7426a5..f298601f5d59 100644
--- a/parquet/src/file/page_index/index_reader.rs
+++ b/parquet/src/file/page_index/index_reader.rs
@@ -15,149 +15,120 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Support for reading [`Index`] and [`PageLocation`] from parquet metadata.
+
 use crate::basic::Type;
 use crate::data_type::Int96;
 use crate::errors::ParquetError;
 use crate::file::metadata::ColumnChunkMetaData;
-use crate::file::page_index::index::{BooleanIndex, ByteArrayIndex, Index, NativeIndex};
+use crate::file::page_index::index::{Index, NativeIndex};
 use crate::file::reader::ChunkReader;
-use parquet_format::{ColumnIndex, OffsetIndex, PageLocation};
-use std::io::{Cursor, Read};
-use thrift::protocol::TCompactInputProtocol;
+use crate::format::{ColumnIndex, OffsetIndex, PageLocation};
+use crate::thrift::{TCompactSliceInputProtocol, TSerializable};
+use std::ops::Range;
+
+/// Computes the covering range of two optional ranges
+///
+/// For example `acc_range(Some(7..9), Some(1..3)) = Some(1..9)`
+pub(crate) fn acc_range(a: Option<Range<usize>>, b: Option<Range<usize>>) -> Option<Range<usize>> {
+    match (a, b) {
+        (Some(a), Some(b)) => Some(a.start.min(b.start)..a.end.max(b.end)),
+        (None, x) | (x, None) => x,
+    }
+}
 
-/// Read on row group's all columns indexes and change into  [`Index`]
-/// If not the format not available return an empty vector.
+/// Reads per-column [`Index`] for all columns of a row group by
+/// decoding [`ColumnIndex`] .
+///
+/// Returns a vector of `index[column_number]`.
+///
+/// Returns an empty vector if this row group does not contain a
+/// [`ColumnIndex`].
+///
+/// See [Column Index Documentation] for more details.
+///
+/// [Column Index Documentation]: https://github.com/apache/parquet-format/blob/master/PageIndex.md
 pub fn read_columns_indexes<R: ChunkReader>(
     reader: &R,
     chunks: &[ColumnChunkMetaData],
 ) -> Result<Vec<Index>, ParquetError> {
-    let (offset, lengths) = get_index_offset_and_lengths(chunks)?;
-    let length = lengths.iter().sum::<usize>();
+    let fetch = chunks
+        .iter()
+        .fold(None, |range, c| acc_range(range, c.column_index_range()));
 
-    //read all need data into buffer
-    let mut reader = reader.get_read(offset, reader.len() as usize)?;
-    let mut data = vec![0; length];
-    reader.read_exact(&mut data)?;
+    let fetch = match fetch {
+        Some(r) => r,
+        None => return Ok(vec![Index::NONE; chunks.len()]),
+    };
 
-    let mut start = 0;
-    let data = lengths.into_iter().map(|length| {
-        let r = &data[start..start + length];
-        start += length;
-        r
-    });
+    let bytes = reader.get_bytes(fetch.start as _, fetch.end - fetch.start)?;
+    let get = |r: Range<usize>| &bytes[(r.start - fetch.start)..(r.end - fetch.start)];
 
     chunks
         .iter()
-        .zip(data)
-        .map(|(chunk, data)| {
-            let column_type = chunk.column_type();
-            deserialize_column_index(data, column_type)
+        .map(|c| match c.column_index_range() {
+            Some(r) => decode_column_index(get(r), c.column_type()),
+            None => Ok(Index::NONE),
         })
         .collect()
 }
 
-/// Read on row group's all indexes and change into  [`Index`]
-/// If not the format not available return an empty vector.
+/// Reads per-page [`PageLocation`] for all columns of a row group by
+/// decoding the [`OffsetIndex`].
+///
+/// Returns a vector of `location[column_number][page_number]`
+///
+/// Return an empty vector if this row group does not contain an
+/// [`OffsetIndex]`.
+///
+/// See [Column Index Documentation] for more details.
+///
+/// [Column Index Documentation]: https://github.com/apache/parquet-format/blob/master/PageIndex.md
 pub fn read_pages_locations<R: ChunkReader>(
     reader: &R,
     chunks: &[ColumnChunkMetaData],
 ) -> Result<Vec<Vec<PageLocation>>, ParquetError> {
-    let (offset, total_length) = get_location_offset_and_total_length(chunks)?;
-
-    //read all need data into buffer
-    let mut reader = reader.get_read(offset, reader.len() as usize)?;
-    let mut data = vec![0; total_length];
-    reader.read_exact(&mut data)?;
-
-    let mut d = Cursor::new(data);
-    let mut result = vec![];
-
-    for _ in 0..chunks.len() {
-        let mut prot = TCompactInputProtocol::new(&mut d);
-        let offset = OffsetIndex::read_from_in_protocol(&mut prot)?;
-        result.push(offset.page_locations);
-    }
-    Ok(result)
-}
+    let fetch = chunks
+        .iter()
+        .fold(None, |range, c| acc_range(range, c.offset_index_range()));
 
-//Get File offsets of every ColumnChunk's page_index
-//If there are invalid offset return a zero offset with empty lengths.
-fn get_index_offset_and_lengths(
-    chunks: &[ColumnChunkMetaData],
-) -> Result<(u64, Vec<usize>), ParquetError> {
-    let first_col_metadata = if let Some(chunk) = chunks.first() {
-        chunk
-    } else {
-        return Ok((0, vec![]));
+    let fetch = match fetch {
+        Some(r) => r,
+        None => return Ok(vec![]),
     };
 
-    let offset: u64 = if let Some(offset) = first_col_metadata.column_index_offset() {
-        offset.try_into().unwrap()
-    } else {
-        return Ok((0, vec![]));
-    };
+    let bytes = reader.get_bytes(fetch.start as _, fetch.end - fetch.start)?;
+    let get = |r: Range<usize>| &bytes[(r.start - fetch.start)..(r.end - fetch.start)];
 
-    let lengths = chunks
+    chunks
         .iter()
-        .map(|x| x.column_index_length())
-        .map(|maybe_length| {
-            let index_length = maybe_length.unwrap_or(0);
-            Ok(index_length.try_into().unwrap())
+        .map(|c| match c.offset_index_range() {
+            Some(r) => decode_offset_index(get(r)),
+            None => Err(general_err!("missing offset index")),
         })
-        .collect::<Result<Vec<_>, ParquetError>>()?;
-
-    Ok((offset, lengths))
+        .collect()
 }
 
-//Get File offset of ColumnChunk's pages_locations
-//If there are invalid offset return a zero offset with zero length.
-fn get_location_offset_and_total_length(
-    chunks: &[ColumnChunkMetaData],
-) -> Result<(u64, usize), ParquetError> {
-    let metadata = if let Some(chunk) = chunks.first() {
-        chunk
-    } else {
-        return Ok((0, 0));
-    };
-
-    let offset: u64 = if let Some(offset) = metadata.offset_index_offset() {
-        offset.try_into().unwrap()
-    } else {
-        return Ok((0, 0));
-    };
-
-    let total_length = chunks
-        .iter()
-        .map(|x| x.offset_index_length().unwrap())
-        .sum::<i32>() as usize;
-    Ok((offset, total_length))
+pub(crate) fn decode_offset_index(data: &[u8]) -> Result<Vec<PageLocation>, ParquetError> {
+    let mut prot = TCompactSliceInputProtocol::new(data);
+    let offset = OffsetIndex::read_from_in_protocol(&mut prot)?;
+    Ok(offset.page_locations)
 }
 
-fn deserialize_column_index(
-    data: &[u8],
-    column_type: Type,
-) -> Result<Index, ParquetError> {
-    if data.is_empty() {
-        return Ok(Index::NONE);
-    }
-    let mut d = Cursor::new(data);
-    let mut prot = TCompactInputProtocol::new(&mut d);
+pub(crate) fn decode_column_index(data: &[u8], column_type: Type) -> Result<Index, ParquetError> {
+    let mut prot = TCompactSliceInputProtocol::new(data);
 
     let index = ColumnIndex::read_from_in_protocol(&mut prot)?;
 
     let index = match column_type {
-        Type::BOOLEAN => Index::BOOLEAN(BooleanIndex::try_new(index)?),
-        Type::INT32 => Index::INT32(NativeIndex::<i32>::try_new(index, column_type)?),
-        Type::INT64 => Index::INT64(NativeIndex::<i64>::try_new(index, column_type)?),
-        Type::INT96 => Index::INT96(NativeIndex::<Int96>::try_new(index, column_type)?),
-        Type::FLOAT => Index::FLOAT(NativeIndex::<f32>::try_new(index, column_type)?),
-        Type::DOUBLE => Index::DOUBLE(NativeIndex::<f64>::try_new(index, column_type)?),
-        Type::BYTE_ARRAY => {
-            Index::BYTE_ARRAY(ByteArrayIndex::try_new(index, column_type)?)
-        }
-        Type::FIXED_LEN_BYTE_ARRAY => {
-            Index::FIXED_LEN_BYTE_ARRAY(ByteArrayIndex::try_new(index, column_type)?)
-        }
+        Type::BOOLEAN => Index::BOOLEAN(NativeIndex::<bool>::try_new(index)?),
+        Type::INT32 => Index::INT32(NativeIndex::<i32>::try_new(index)?),
+        Type::INT64 => Index::INT64(NativeIndex::<i64>::try_new(index)?),
+        Type::INT96 => Index::INT96(NativeIndex::<Int96>::try_new(index)?),
+        Type::FLOAT => Index::FLOAT(NativeIndex::<f32>::try_new(index)?),
+        Type::DOUBLE => Index::DOUBLE(NativeIndex::<f64>::try_new(index)?),
+        Type::BYTE_ARRAY => Index::BYTE_ARRAY(NativeIndex::try_new(index)?),
+        Type::FIXED_LEN_BYTE_ARRAY => Index::FIXED_LEN_BYTE_ARRAY(NativeIndex::try_new(index)?),
     };
 
     Ok(index)
diff --git a/parquet/src/file/page_index/mod.rs b/parquet/src/file/page_index/mod.rs
index bb7808f16487..9372645d76ee 100644
--- a/parquet/src/file/page_index/mod.rs
+++ b/parquet/src/file/page_index/mod.rs
@@ -15,8 +15,9 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Page Index of "[Column Index] Layout to Support Page Skipping"
+//!
+//! [Column Index]: https://github.com/apache/parquet-format/blob/master/PageIndex.md
+
 pub mod index;
 pub mod index_reader;
-
-#[cfg(test)]
-pub(crate) mod range;
diff --git a/parquet/src/file/page_index/range.rs b/parquet/src/file/page_index/range.rs
deleted file mode 100644
index e9741ec8e7fd..000000000000
--- a/parquet/src/file/page_index/range.rs
+++ /dev/null
@@ -1,475 +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.
-use crate::errors::ParquetError;
-use parquet_format::PageLocation;
-use std::cmp::Ordering;
-use std::collections::VecDeque;
-use std::ops::RangeInclusive;
-
-type Range = RangeInclusive<usize>;
-
-pub trait RangeOps {
-    fn is_before(&self, other: &Self) -> bool;
-
-    fn is_after(&self, other: &Self) -> bool;
-
-    fn count(&self) -> usize;
-
-    fn union(left: &Range, right: &Range) -> Option<Range>;
-
-    fn intersection(left: &Range, right: &Range) -> Option<Range>;
-}
-
-impl RangeOps for Range {
-    fn is_before(&self, other: &Range) -> bool {
-        self.end() < other.start()
-    }
-
-    fn is_after(&self, other: &Range) -> bool {
-        self.start() > other.end()
-    }
-
-    fn count(&self) -> usize {
-        self.end() + 1 - self.start()
-    }
-
-    /// Return the union of the two ranges,
-    /// Return `None` if there are hole between them.
-    fn union(left: &Range, right: &Range) -> Option<Range> {
-        if left.start() <= right.start() {
-            if left.end() + 1 >= *right.start() {
-                return Some(Range::new(
-                    *left.start(),
-                    std::cmp::max(*left.end(), *right.end()),
-                ));
-            }
-        } else if right.end() + 1 >= *left.start() {
-            return Some(Range::new(
-                *right.start(),
-                std::cmp::max(*left.end(), *right.end()),
-            ));
-        }
-        None
-    }
-
-    /// Returns the intersection of the two ranges,
-    /// return null if they are not overlapped.
-    fn intersection(left: &Range, right: &Range) -> Option<Range> {
-        if left.start() <= right.start() {
-            if left.end() >= right.start() {
-                return Some(Range::new(
-                    *right.start(),
-                    std::cmp::min(*left.end(), *right.end()),
-                ));
-            }
-        } else if right.end() >= left.start() {
-            return Some(Range::new(
-                *left.start(),
-                std::cmp::min(*left.end(), *right.end()),
-            ));
-        }
-        None
-    }
-}
-
-/// Struct representing row ranges in a row-group. These row ranges are calculated as a result of using
-/// the column index on the filtering.
-#[derive(Debug, Clone)]
-pub struct RowRanges {
-    pub ranges: VecDeque<Range>,
-}
-
-impl RowRanges {
-    //create an empty RowRanges
-    pub fn new_empty() -> Self {
-        RowRanges {
-            ranges: VecDeque::new(),
-        }
-    }
-
-    pub fn count(&self) -> usize {
-        self.ranges.len()
-    }
-
-    pub fn filter_with_mask(&self, mask: &[bool]) -> Result<RowRanges, ParquetError> {
-        if self.ranges.len() != mask.len() {
-            return Err(ParquetError::General(format!(
-                "Mask size {} is not equal to number of pages {}",
-                mask.len(),
-                self.count()
-            )));
-        }
-        let vec_range = mask
-            .iter()
-            .zip(self.ranges.clone())
-            .filter_map(|(&f, r)| if f { Some(r) } else { None })
-            .collect();
-        Ok(RowRanges { ranges: vec_range })
-    }
-
-    /// Add a range to the end of the list of ranges. It maintains the disjunctive ascending order of the ranges by
-    /// trying to union the specified range to the last ranges in the list. The specified range shall be larger than
-    /// the last one or might be overlapped with some of the last ones.
-    /// [a, b] < [c, d] if b < c
-    pub fn add(&mut self, mut range: Range) {
-        let count = self.count();
-        if count > 0 {
-            for i in 1..(count + 1) {
-                let index = count - i;
-                let last = self.ranges.get(index).unwrap();
-                assert!(!last.is_after(&range), "Must add range in ascending!");
-                // try to merge range
-                match Range::union(last, &range) {
-                    None => {
-                        break;
-                    }
-                    Some(r) => {
-                        range = r;
-                        self.ranges.remove(index);
-                    }
-                }
-            }
-        }
-        self.ranges.push_back(range);
-    }
-
-    /// Calculates the union of the two specified RowRanges object. The union of two range is calculated if there are no
-    /// elements between them. Otherwise, the two disjunctive ranges are stored separately.
-    /// For example:
-    /// [113, 241] ∪ [221, 340] = [113, 330]
-    /// [113, 230] ∪ [231, 340] = [113, 340]
-    /// while
-    /// [113, 230] ∪ [232, 340] = [113, 230], [232, 340]
-    ///
-    /// The result RowRanges object will contain all the row indexes that were contained in one of the specified objects.
-    pub fn union(mut left: RowRanges, mut right: RowRanges) -> RowRanges {
-        let v1 = &mut left.ranges;
-        let v2 = &mut right.ranges;
-        let mut result = RowRanges::new_empty();
-        if v2.is_empty() {
-            left.clone()
-        } else {
-            let mut range2 = v2.pop_front().unwrap();
-            while !v1.is_empty() {
-                let range1 = v1.pop_front().unwrap();
-                if range1.is_after(&range2) {
-                    result.add(range2);
-                    range2 = range1;
-                    std::mem::swap(v1, v2);
-                } else {
-                    result.add(range1);
-                }
-            }
-
-            result.add(range2);
-            while !v2.is_empty() {
-                result.add(v2.pop_front().unwrap())
-            }
-
-            result
-        }
-    }
-
-    /// Calculates the intersection of the two specified RowRanges object. Two ranges intersect if they have common
-    /// elements otherwise the result is empty.
-    /// For example:
-    /// [113, 241] ∩ [221, 340] = [221, 241]
-    /// while
-    /// [113, 230] ∩ [231, 340] = <EMPTY>
-    ///
-    /// The result RowRanges object will contain all the row indexes there were contained in both of the specified objects
-    #[allow(clippy::mut_range_bound)]
-    pub fn intersection(left: RowRanges, right: RowRanges) -> RowRanges {
-        let mut result = RowRanges::new_empty();
-        let mut right_index = 0;
-        for l in left.ranges.iter() {
-            for i in right_index..right.ranges.len() {
-                let r = right.ranges.get(i).unwrap();
-                if l.is_before(r) {
-                    break;
-                } else if l.is_after(r) {
-                    right_index = i + 1;
-                    continue;
-                }
-                if let Some(ra) = Range::intersection(l, r) {
-                    result.add(ra);
-                }
-            }
-        }
-        result
-    }
-
-    #[allow(unused)]
-    pub fn row_count(&self) -> usize {
-        self.ranges.iter().map(|x| x.count()).sum()
-    }
-
-    pub fn is_overlapping(&self, x: &Range) -> bool {
-        self.ranges
-            .binary_search_by(|y| -> Ordering {
-                if y.is_before(x) {
-                    Ordering::Less
-                } else if y.is_after(x) {
-                    Ordering::Greater
-                } else {
-                    Ordering::Equal
-                }
-            })
-            .is_ok()
-    }
-}
-
-/// Takes an array of [`PageLocation`], and a total number of rows, and based on the provided `page_mask`
-/// returns the corresponding [`RowRanges`] to scan
-pub fn compute_row_ranges(
-    page_mask: &[bool],
-    locations: &[PageLocation],
-    total_rows: usize,
-) -> Result<RowRanges, ParquetError> {
-    if page_mask.len() != locations.len() {
-        return Err(ParquetError::General(format!(
-            "Page_mask size {} is not equal to number of locations {}",
-            page_mask.len(),
-            locations.len(),
-        )));
-    }
-    let row_ranges = page_locations_to_row_ranges(locations, total_rows)?;
-    row_ranges.filter_with_mask(page_mask)
-}
-
-fn page_locations_to_row_ranges(
-    locations: &[PageLocation],
-    total_rows: usize,
-) -> Result<RowRanges, ParquetError> {
-    if locations.is_empty() || total_rows == 0 {
-        return Ok(RowRanges::new_empty());
-    }
-
-    // If we read directly from parquet pageIndex to construct locations,
-    // the location index should be continuous
-    let mut vec_range: VecDeque<Range> = locations
-        .windows(2)
-        .map(|x| {
-            let start = x[0].first_row_index as usize;
-            let end = (x[1].first_row_index - 1) as usize;
-            Range::new(start, end)
-        })
-        .collect();
-
-    let last = Range::new(
-        locations.last().unwrap().first_row_index as usize,
-        total_rows - 1,
-    );
-    vec_range.push_back(last);
-
-    Ok(RowRanges { ranges: vec_range })
-}
-
-#[cfg(test)]
-mod tests {
-    use crate::basic::Type::INT32;
-    use crate::file::page_index::index::{NativeIndex, PageIndex};
-    use crate::file::page_index::range::{compute_row_ranges, Range, RowRanges};
-    use parquet_format::{BoundaryOrder, PageLocation};
-
-    #[test]
-    fn test_binary_search_overlap() {
-        let mut ranges = RowRanges::new_empty();
-        ranges.add(Range::new(1, 3));
-        ranges.add(Range::new(6, 7));
-
-        assert!(ranges.is_overlapping(&Range::new(1, 2)));
-        // include both [start, end]
-        assert!(ranges.is_overlapping(&Range::new(0, 1)));
-        assert!(ranges.is_overlapping(&Range::new(0, 3)));
-
-        assert!(ranges.is_overlapping(&Range::new(0, 7)));
-        assert!(ranges.is_overlapping(&Range::new(2, 7)));
-
-        assert!(!ranges.is_overlapping(&Range::new(4, 5)));
-    }
-
-    #[test]
-    fn test_add_func_ascending_disjunctive() {
-        let mut ranges_1 = RowRanges::new_empty();
-        ranges_1.add(Range::new(1, 3));
-        ranges_1.add(Range::new(5, 6));
-        ranges_1.add(Range::new(8, 9));
-        assert_eq!(ranges_1.count(), 3);
-    }
-
-    #[test]
-    fn test_add_func_ascending_merge() {
-        let mut ranges_1 = RowRanges::new_empty();
-        ranges_1.add(Range::new(1, 3));
-        ranges_1.add(Range::new(4, 5));
-        ranges_1.add(Range::new(6, 7));
-        assert_eq!(ranges_1.count(), 1);
-    }
-
-    #[test]
-    #[should_panic(expected = "Must add range in ascending!")]
-    fn test_add_func_not_ascending() {
-        let mut ranges_1 = RowRanges::new_empty();
-        ranges_1.add(Range::new(6, 7));
-        ranges_1.add(Range::new(1, 3));
-        ranges_1.add(Range::new(4, 5));
-        assert_eq!(ranges_1.count(), 1);
-    }
-
-    #[test]
-    fn test_union_func() {
-        let mut ranges_1 = RowRanges::new_empty();
-        ranges_1.add(Range::new(1, 2));
-        ranges_1.add(Range::new(3, 4));
-        ranges_1.add(Range::new(5, 6));
-
-        let mut ranges_2 = RowRanges::new_empty();
-        ranges_2.add(Range::new(2, 3));
-        ranges_2.add(Range::new(4, 5));
-        ranges_2.add(Range::new(6, 7));
-
-        let ranges = RowRanges::union(ranges_1, ranges_2);
-        assert_eq!(ranges.count(), 1);
-        let range = ranges.ranges.get(0).unwrap();
-        assert_eq!(*range.start(), 1);
-        assert_eq!(*range.end(), 7);
-
-        let mut ranges_a = RowRanges::new_empty();
-        ranges_a.add(Range::new(1, 3));
-        ranges_a.add(Range::new(5, 8));
-        ranges_a.add(Range::new(11, 12));
-
-        let mut ranges_b = RowRanges::new_empty();
-        ranges_b.add(Range::new(0, 2));
-        ranges_b.add(Range::new(6, 7));
-        ranges_b.add(Range::new(10, 11));
-
-        let ranges = RowRanges::union(ranges_a, ranges_b);
-        assert_eq!(ranges.count(), 3);
-
-        let range_1 = ranges.ranges.get(0).unwrap();
-        assert_eq!(*range_1.start(), 0);
-        assert_eq!(*range_1.end(), 3);
-        let range_2 = ranges.ranges.get(1).unwrap();
-        assert_eq!(*range_2.start(), 5);
-        assert_eq!(*range_2.end(), 8);
-        let range_3 = ranges.ranges.get(2).unwrap();
-        assert_eq!(*range_3.start(), 10);
-        assert_eq!(*range_3.end(), 12);
-    }
-
-    #[test]
-    fn test_intersection_func() {
-        let mut ranges_1 = RowRanges::new_empty();
-        ranges_1.add(Range::new(1, 2));
-        ranges_1.add(Range::new(3, 4));
-        ranges_1.add(Range::new(5, 6));
-
-        let mut ranges_2 = RowRanges::new_empty();
-        ranges_2.add(Range::new(2, 3));
-        ranges_2.add(Range::new(4, 5));
-        ranges_2.add(Range::new(6, 7));
-
-        let ranges = RowRanges::intersection(ranges_1, ranges_2);
-        assert_eq!(ranges.count(), 1);
-        let range = ranges.ranges.get(0).unwrap();
-        assert_eq!(*range.start(), 2);
-        assert_eq!(*range.end(), 6);
-
-        let mut ranges_a = RowRanges::new_empty();
-        ranges_a.add(Range::new(1, 3));
-        ranges_a.add(Range::new(5, 8));
-        ranges_a.add(Range::new(11, 12));
-
-        let mut ranges_b = RowRanges::new_empty();
-        ranges_b.add(Range::new(0, 2));
-        ranges_b.add(Range::new(6, 7));
-        ranges_b.add(Range::new(10, 11));
-
-        let ranges = RowRanges::intersection(ranges_a, ranges_b);
-        assert_eq!(ranges.count(), 3);
-
-        let range_1 = ranges.ranges.get(0).unwrap();
-        assert_eq!(*range_1.start(), 1);
-        assert_eq!(*range_1.end(), 2);
-        let range_2 = ranges.ranges.get(1).unwrap();
-        assert_eq!(*range_2.start(), 6);
-        assert_eq!(*range_2.end(), 7);
-        let range_3 = ranges.ranges.get(2).unwrap();
-        assert_eq!(*range_3.start(), 11);
-        assert_eq!(*range_3.end(), 11);
-    }
-
-    #[test]
-    fn test_compute_one() {
-        let locations = &[PageLocation {
-            offset: 50,
-            compressed_page_size: 10,
-            first_row_index: 0,
-        }];
-        let total_rows = 10;
-
-        let row_ranges = compute_row_ranges(&[true], locations, total_rows).unwrap();
-        assert_eq!(row_ranges.count(), 1);
-        assert_eq!(row_ranges.ranges.get(0).unwrap(), &Range::new(0, 9));
-    }
-
-    #[test]
-    fn test_compute_multi() {
-        let index: NativeIndex<i32> = NativeIndex {
-            physical_type: INT32,
-            indexes: vec![
-                PageIndex {
-                    min: Some(0),
-                    max: Some(10),
-                    null_count: Some(0),
-                },
-                PageIndex {
-                    min: Some(15),
-                    max: Some(20),
-                    null_count: Some(0),
-                },
-            ],
-            boundary_order: BoundaryOrder::Ascending,
-        };
-        let locations = &[
-            PageLocation {
-                offset: 100,
-                compressed_page_size: 10,
-                first_row_index: 0,
-            },
-            PageLocation {
-                offset: 200,
-                compressed_page_size: 20,
-                first_row_index: 11,
-            },
-        ];
-        let total_rows = 20;
-
-        //filter `x < 11`
-        let filter =
-            |page: &PageIndex<i32>| page.max.as_ref().map(|&x| x < 11).unwrap_or(false);
-
-        let mask = index.indexes.iter().map(filter).collect::<Vec<_>>();
-
-        let row_ranges = compute_row_ranges(&mask, locations, total_rows).unwrap();
-
-        assert_eq!(row_ranges.count(), 1);
-        assert_eq!(row_ranges.ranges.get(0).unwrap(), &Range::new(0, 10));
-    }
-}
diff --git a/parquet/src/file/properties.rs b/parquet/src/file/properties.rs
index 57dae323d892..287e73c9906a 100644
--- a/parquet/src/file/properties.rs
+++ b/parquet/src/file/properties.rs
@@ -15,55 +15,44 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Writer properties.
-//!
-//! # Usage
-//!
-//! ```rust
-//! use parquet::{
-//!     basic::{Compression, Encoding},
-//!     file::properties::*,
-//!     schema::types::ColumnPath,
-//! };
-//!
-//! // Create properties with default configuration.
-//! let props = WriterProperties::builder().build();
-//!
-//! // Use properties builder to set certain options and assemble the configuration.
-//! let props = WriterProperties::builder()
-//!     .set_writer_version(WriterVersion::PARQUET_1_0)
-//!     .set_encoding(Encoding::PLAIN)
-//!     .set_column_encoding(ColumnPath::from("col1"), Encoding::DELTA_BINARY_PACKED)
-//!     .set_compression(Compression::SNAPPY)
-//!     .build();
-//!
-//! assert_eq!(props.writer_version(), WriterVersion::PARQUET_1_0);
-//! assert_eq!(
-//!     props.encoding(&ColumnPath::from("col1")),
-//!     Some(Encoding::DELTA_BINARY_PACKED)
-//! );
-//! assert_eq!(
-//!     props.encoding(&ColumnPath::from("col2")),
-//!     Some(Encoding::PLAIN)
-//! );
-//! ```
-
+//! Configuration via [`WriterProperties`] and [`ReaderProperties`]
+use std::str::FromStr;
 use std::{collections::HashMap, sync::Arc};
 
 use crate::basic::{Compression, Encoding};
+use crate::compression::{CodecOptions, CodecOptionsBuilder};
 use crate::file::metadata::KeyValue;
+use crate::format::SortingColumn;
 use crate::schema::types::ColumnPath;
 
-const DEFAULT_PAGE_SIZE: usize = 1024 * 1024;
-const DEFAULT_WRITE_BATCH_SIZE: usize = 1024;
-const DEFAULT_WRITER_VERSION: WriterVersion = WriterVersion::PARQUET_1_0;
-const DEFAULT_COMPRESSION: Compression = Compression::UNCOMPRESSED;
-const DEFAULT_DICTIONARY_ENABLED: bool = true;
-const DEFAULT_DICTIONARY_PAGE_SIZE_LIMIT: usize = DEFAULT_PAGE_SIZE;
-const DEFAULT_STATISTICS_ENABLED: EnabledStatistics = EnabledStatistics::Page;
-const DEFAULT_MAX_STATISTICS_SIZE: usize = 4096;
-const DEFAULT_MAX_ROW_GROUP_SIZE: usize = 1024 * 1024;
-const DEFAULT_CREATED_BY: &str = env!("PARQUET_CREATED_BY");
+/// Default value for [`WriterProperties::data_page_size_limit`]
+pub const DEFAULT_PAGE_SIZE: usize = 1024 * 1024;
+/// Default value for [`WriterProperties::write_batch_size`]
+pub const DEFAULT_WRITE_BATCH_SIZE: usize = 1024;
+/// Default value for [`WriterProperties::writer_version`]
+pub const DEFAULT_WRITER_VERSION: WriterVersion = WriterVersion::PARQUET_1_0;
+/// Default value for [`WriterProperties::compression`]
+pub const DEFAULT_COMPRESSION: Compression = Compression::UNCOMPRESSED;
+/// Default value for [`WriterProperties::dictionary_enabled`]
+pub const DEFAULT_DICTIONARY_ENABLED: bool = true;
+/// Default value for [`WriterProperties::dictionary_page_size_limit`]
+pub const DEFAULT_DICTIONARY_PAGE_SIZE_LIMIT: usize = DEFAULT_PAGE_SIZE;
+/// Default value for [`WriterProperties::statistics_enabled`]
+pub const DEFAULT_STATISTICS_ENABLED: EnabledStatistics = EnabledStatistics::Page;
+/// Default value for [`WriterProperties::max_statistics_size`]
+pub const DEFAULT_MAX_STATISTICS_SIZE: usize = 4096;
+/// Default value for [`WriterProperties::max_row_group_size`]
+pub const DEFAULT_MAX_ROW_GROUP_SIZE: usize = 1024 * 1024;
+/// Default value for [`WriterProperties::created_by`]
+pub const DEFAULT_CREATED_BY: &str = concat!("parquet-rs version ", env!("CARGO_PKG_VERSION"));
+/// Default value for [`WriterProperties::column_index_truncate_length`]
+pub const DEFAULT_COLUMN_INDEX_TRUNCATE_LENGTH: Option<usize> = Some(64);
+/// Default value for [`BloomFilterProperties::fpp`]
+pub const DEFAULT_BLOOM_FILTER_FPP: f64 = 0.05;
+/// Default value for [`BloomFilterProperties::ndv`]
+pub const DEFAULT_BLOOM_FILTER_NDV: u64 = 1_000_000_u64;
+/// Default values for [`WriterProperties::statistics_truncate_length`]
+pub const DEFAULT_STATISTICS_TRUNCATE_LENGTH: Option<usize> = None;
 
 /// Parquet writer version.
 ///
@@ -85,17 +74,61 @@ impl WriterVersion {
     }
 }
 
+impl FromStr for WriterVersion {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "PARQUET_1_0" | "parquet_1_0" => Ok(WriterVersion::PARQUET_1_0),
+            "PARQUET_2_0" | "parquet_2_0" => Ok(WriterVersion::PARQUET_2_0),
+            _ => Err(format!("Invalid writer version: {}", s)),
+        }
+    }
+}
+
 /// Reference counted writer properties.
 pub type WriterPropertiesPtr = Arc<WriterProperties>;
 
-/// Writer properties.
+/// Configuration settings for writing parquet files.
 ///
 /// All properties except the key-value metadata are immutable,
 /// use [`WriterPropertiesBuilder`] to assemble these properties.
+///
+/// # Example
+///
+/// ```rust
+/// use parquet::{
+///     basic::{Compression, Encoding},
+///     file::properties::*,
+///     schema::types::ColumnPath,
+/// };
+///
+/// // Create properties with default configuration.
+/// let props = WriterProperties::default();
+///
+/// // Use properties builder to set certain options and assemble the configuration.
+/// let props = WriterProperties::builder()
+///     .set_writer_version(WriterVersion::PARQUET_1_0)
+///     .set_encoding(Encoding::PLAIN)
+///     .set_column_encoding(ColumnPath::from("col1"), Encoding::DELTA_BINARY_PACKED)
+///     .set_compression(Compression::SNAPPY)
+///     .build();
+///
+/// assert_eq!(props.writer_version(), WriterVersion::PARQUET_1_0);
+/// assert_eq!(
+///     props.encoding(&ColumnPath::from("col1")),
+///     Some(Encoding::DELTA_BINARY_PACKED)
+/// );
+/// assert_eq!(
+///     props.encoding(&ColumnPath::from("col2")),
+///     Some(Encoding::PLAIN)
+/// );
+/// ```
 #[derive(Debug, Clone)]
 pub struct WriterProperties {
-    data_pagesize_limit: usize,
-    dictionary_pagesize_limit: usize,
+    data_page_size_limit: usize,
+    dictionary_page_size_limit: usize,
+    data_page_row_count_limit: usize,
     write_batch_size: usize,
     max_row_group_size: usize,
     writer_version: WriterVersion,
@@ -103,22 +136,71 @@ pub struct WriterProperties {
     pub(crate) key_value_metadata: Option<Vec<KeyValue>>,
     default_column_properties: ColumnProperties,
     column_properties: HashMap<ColumnPath, ColumnProperties>,
+    sorting_columns: Option<Vec<SortingColumn>>,
+    column_index_truncate_length: Option<usize>,
+    statistics_truncate_length: Option<usize>,
+}
+
+impl Default for WriterProperties {
+    fn default() -> Self {
+        Self::builder().build()
+    }
 }
 
 impl WriterProperties {
+    /// Create a new [`WriterProperties`] with the default settings
+    ///
+    /// See [`WriterProperties::builder`] for customising settings
+    pub fn new() -> Self {
+        Self::default()
+    }
+
     /// Returns builder for writer properties with default values.
     pub fn builder() -> WriterPropertiesBuilder {
         WriterPropertiesBuilder::with_defaults()
     }
 
     /// Returns data page size limit.
+    ///
+    /// Note: this is a best effort limit based on the write batch size
+    #[deprecated(since = "41.0.0", note = "Use data_page_size_limit")]
     pub fn data_pagesize_limit(&self) -> usize {
-        self.data_pagesize_limit
+        self.data_page_size_limit
+    }
+
+    /// Returns data page size limit.
+    ///
+    /// Note: this is a best effort limit based on the write batch size
+    ///
+    /// For more details see [`WriterPropertiesBuilder::set_data_page_size_limit`]
+    pub fn data_page_size_limit(&self) -> usize {
+        self.data_page_size_limit
     }
 
     /// Returns dictionary page size limit.
+    ///
+    /// Note: this is a best effort limit based on the write batch size
+    #[deprecated(since = "41.0.0", note = "Use dictionary_page_size_limit")]
     pub fn dictionary_pagesize_limit(&self) -> usize {
-        self.dictionary_pagesize_limit
+        self.dictionary_page_size_limit
+    }
+
+    /// Returns dictionary page size limit.
+    ///
+    /// Note: this is a best effort limit based on the write batch size
+    ///
+    /// For more details see [`WriterPropertiesBuilder::set_dictionary_page_size_limit`]
+    pub fn dictionary_page_size_limit(&self) -> usize {
+        self.dictionary_page_size_limit
+    }
+
+    /// Returns the maximum page row count
+    ///
+    /// Note: this is a best effort limit based on the write batch size
+    ///
+    /// For more details see [`WriterPropertiesBuilder::set_data_page_row_count_limit`]
+    pub fn data_page_row_count_limit(&self) -> usize {
+        self.data_page_row_count_limit
     }
 
     /// Returns configured batch size for writes.
@@ -150,6 +232,25 @@ impl WriterProperties {
         self.key_value_metadata.as_ref()
     }
 
+    /// Returns sorting columns.
+    pub fn sorting_columns(&self) -> Option<&Vec<SortingColumn>> {
+        self.sorting_columns.as_ref()
+    }
+
+    /// Returns the maximum length of truncated min/max values in the column index.
+    ///
+    /// `None` if truncation is disabled, must be greater than 0 otherwise.
+    pub fn column_index_truncate_length(&self) -> Option<usize> {
+        self.column_index_truncate_length
+    }
+
+    /// Returns the maximum length of truncated min/max values in statistics.
+    ///
+    /// `None` if truncation is disabled, must be greater than 0 otherwise.
+    pub fn statistics_truncate_length(&self) -> Option<usize> {
+        self.statistics_truncate_length
+    }
+
     /// Returns encoding for a data page, when dictionary encoding is enabled.
     /// This is not configurable.
     #[inline]
@@ -216,12 +317,24 @@ impl WriterProperties {
             .or_else(|| self.default_column_properties.max_statistics_size())
             .unwrap_or(DEFAULT_MAX_STATISTICS_SIZE)
     }
+
+    /// Returns the [`BloomFilterProperties`] for the given column
+    ///
+    /// Returns `None` if bloom filter is disabled
+    pub fn bloom_filter_properties(&self, col: &ColumnPath) -> Option<&BloomFilterProperties> {
+        self.column_properties
+            .get(col)
+            .and_then(|c| c.bloom_filter_properties())
+            .or_else(|| self.default_column_properties.bloom_filter_properties())
+    }
 }
 
-/// Writer properties builder.
+/// Builder for parquet file writer configuration. See example on
+/// [`WriterProperties`]
 pub struct WriterPropertiesBuilder {
-    data_pagesize_limit: usize,
-    dictionary_pagesize_limit: usize,
+    data_page_size_limit: usize,
+    dictionary_page_size_limit: usize,
+    data_page_row_count_limit: usize,
     write_batch_size: usize,
     max_row_group_size: usize,
     writer_version: WriterVersion,
@@ -229,29 +342,37 @@ pub struct WriterPropertiesBuilder {
     key_value_metadata: Option<Vec<KeyValue>>,
     default_column_properties: ColumnProperties,
     column_properties: HashMap<ColumnPath, ColumnProperties>,
+    sorting_columns: Option<Vec<SortingColumn>>,
+    column_index_truncate_length: Option<usize>,
+    statistics_truncate_length: Option<usize>,
 }
 
 impl WriterPropertiesBuilder {
     /// Returns default state of the builder.
     fn with_defaults() -> Self {
         Self {
-            data_pagesize_limit: DEFAULT_PAGE_SIZE,
-            dictionary_pagesize_limit: DEFAULT_DICTIONARY_PAGE_SIZE_LIMIT,
+            data_page_size_limit: DEFAULT_PAGE_SIZE,
+            dictionary_page_size_limit: DEFAULT_DICTIONARY_PAGE_SIZE_LIMIT,
+            data_page_row_count_limit: usize::MAX,
             write_batch_size: DEFAULT_WRITE_BATCH_SIZE,
             max_row_group_size: DEFAULT_MAX_ROW_GROUP_SIZE,
             writer_version: DEFAULT_WRITER_VERSION,
             created_by: DEFAULT_CREATED_BY.to_string(),
             key_value_metadata: None,
-            default_column_properties: ColumnProperties::new(),
+            default_column_properties: Default::default(),
             column_properties: HashMap::new(),
+            sorting_columns: None,
+            column_index_truncate_length: DEFAULT_COLUMN_INDEX_TRUNCATE_LENGTH,
+            statistics_truncate_length: DEFAULT_STATISTICS_TRUNCATE_LENGTH,
         }
     }
 
     /// Finalizes the configuration and returns immutable writer properties struct.
     pub fn build(self) -> WriterProperties {
         WriterProperties {
-            data_pagesize_limit: self.data_pagesize_limit,
-            dictionary_pagesize_limit: self.dictionary_pagesize_limit,
+            data_page_size_limit: self.data_page_size_limit,
+            dictionary_page_size_limit: self.dictionary_page_size_limit,
+            data_page_row_count_limit: self.data_page_row_count_limit,
             write_batch_size: self.write_batch_size,
             max_row_group_size: self.max_row_group_size,
             writer_version: self.writer_version,
@@ -259,6 +380,9 @@ impl WriterPropertiesBuilder {
             key_value_metadata: self.key_value_metadata,
             default_column_properties: self.default_column_properties,
             column_properties: self.column_properties,
+            sorting_columns: self.sorting_columns,
+            column_index_truncate_length: self.column_index_truncate_length,
+            statistics_truncate_length: self.statistics_truncate_length,
         }
     }
 
@@ -271,19 +395,78 @@ impl WriterPropertiesBuilder {
         self
     }
 
-    /// Sets data page size limit.
+    /// Sets best effort maximum size of a data page in bytes.
+    ///
+    /// Note: this is a best effort limit based on value of
+    /// [`set_write_batch_size`](Self::set_write_batch_size).
+    #[deprecated(since = "41.0.0", note = "Use set_data_page_size_limit")]
     pub fn set_data_pagesize_limit(mut self, value: usize) -> Self {
-        self.data_pagesize_limit = value;
+        self.data_page_size_limit = value;
         self
     }
 
-    /// Sets dictionary page size limit.
+    /// Sets best effort maximum size of a data page in bytes.
+    ///
+    /// The parquet writer will attempt to limit the sizes of each
+    /// `DataPage` to this many bytes. Reducing this value will result
+    /// in larger parquet files, but may improve the effectiveness of
+    /// page index based predicate pushdown during reading.
+    ///
+    /// Note: this is a best effort limit based on value of
+    /// [`set_write_batch_size`](Self::set_write_batch_size).
+    pub fn set_data_page_size_limit(mut self, value: usize) -> Self {
+        self.data_page_size_limit = value;
+        self
+    }
+
+    /// Sets best effort maximum number of rows in a data page.
+    ///
+    /// The parquet writer will attempt to limit the number of rows in
+    /// each `DataPage` to this value. Reducing this value will result
+    /// in larger parquet files, but may improve the effectiveness of
+    /// page index based predicate pushdown during reading.
+    ///
+    /// Note: this is a best effort limit based on value of
+    /// [`set_write_batch_size`](Self::set_write_batch_size).
+    pub fn set_data_page_row_count_limit(mut self, value: usize) -> Self {
+        self.data_page_row_count_limit = value;
+        self
+    }
+
+    /// Sets best effort maximum dictionary page size, in bytes.
+    ///
+    /// Note: this is a best effort limit based on value of
+    /// [`set_write_batch_size`](Self::set_write_batch_size).
+    #[deprecated(since = "41.0.0", note = "Use set_dictionary_page_size_limit")]
     pub fn set_dictionary_pagesize_limit(mut self, value: usize) -> Self {
-        self.dictionary_pagesize_limit = value;
+        self.dictionary_page_size_limit = value;
+        self
+    }
+
+    /// Sets best effort maximum dictionary page size, in bytes.
+    ///
+    /// The parquet writer will attempt to limit the size of each
+    /// `DataPage` used to store dictionaries to this many
+    /// bytes. Reducing this value will result in larger parquet
+    /// files, but may improve the effectiveness of page index based
+    /// predicate pushdown during reading.
+    ///
+    /// Note: this is a best effort limit based on value of
+    /// [`set_write_batch_size`](Self::set_write_batch_size).
+    pub fn set_dictionary_page_size_limit(mut self, value: usize) -> Self {
+        self.dictionary_page_size_limit = value;
         self
     }
 
     /// Sets write batch size.
+    ///
+    /// For performance reasons, data for each column is written in
+    /// batches of this size.
+    ///
+    /// Additional limits such as such as
+    /// [`set_data_page_row_count_limit`](Self::set_data_page_row_count_limit)
+    /// are checked between batches, and thus the write batch size value acts as an
+    /// upper-bound on the enforcement granularity of other limits.
     pub fn set_write_batch_size(mut self, value: usize) -> Self {
         self.write_batch_size = value;
         self
@@ -308,6 +491,12 @@ impl WriterPropertiesBuilder {
         self
     }
 
+    /// Sets sorting order of rows in the row group if any
+    pub fn set_sorting_columns(mut self, value: Option<Vec<SortingColumn>>) -> Self {
+        self.sorting_columns = value;
+        self
+    }
+
     // ----------------------------------------------------------------------
     // Setters for any column (global)
 
@@ -353,15 +542,37 @@ impl WriterPropertiesBuilder {
         self
     }
 
+    /// Sets whether bloom filter is enabled for any column.
+    /// If the bloom filter is enabled previously then it is a no-op.
+    /// If the bloom filter is not yet enabled, a default set of ndv and fpp value will be used.
+    /// You can use [`set_bloom_filter_ndv`](Self::set_bloom_filter_ndv) and [`set_bloom_filter_fpp`](Self::set_bloom_filter_fpp) to further adjust the ndv and fpp.
+    pub fn set_bloom_filter_enabled(mut self, value: bool) -> Self {
+        self.default_column_properties
+            .set_bloom_filter_enabled(value);
+        self
+    }
+
+    /// Sets bloom filter false positive probability (fpp) for any column.
+    /// Implicitly [`set_bloom_filter_enabled`](Self::set_bloom_filter_enabled).
+    pub fn set_bloom_filter_fpp(mut self, value: f64) -> Self {
+        self.default_column_properties.set_bloom_filter_fpp(value);
+        self
+    }
+
+    /// Sets number of distinct values (ndv) for bloom filter for any column.
+    /// Implicitly [`set_bloom_filter_enabled`](Self::set_bloom_filter_enabled).
+    pub fn set_bloom_filter_ndv(mut self, value: u64) -> Self {
+        self.default_column_properties.set_bloom_filter_ndv(value);
+        self
+    }
+
     // ----------------------------------------------------------------------
     // Setters for a specific column
 
     /// Helper method to get existing or new mutable reference of column properties.
     #[inline]
     fn get_mut_props(&mut self, col: ColumnPath) -> &mut ColumnProperties {
-        self.column_properties
-            .entry(col)
-            .or_insert_with(ColumnProperties::new)
+        self.column_properties.entry(col).or_default()
     }
 
     /// Sets encoding for a column.
@@ -406,14 +617,56 @@ impl WriterPropertiesBuilder {
 
     /// Sets max size for statistics for a column.
     /// Takes precedence over globally defined settings.
-    pub fn set_column_max_statistics_size(
-        mut self,
-        col: ColumnPath,
-        value: usize,
-    ) -> Self {
+    pub fn set_column_max_statistics_size(mut self, col: ColumnPath, value: usize) -> Self {
         self.get_mut_props(col).set_max_statistics_size(value);
         self
     }
+
+    /// Sets whether a bloom filter should be created for a specific column.
+    /// The behavior is similar to [`set_bloom_filter_enabled`](Self::set_bloom_filter_enabled).
+    /// Takes precedence over globally defined settings.
+    pub fn set_column_bloom_filter_enabled(mut self, col: ColumnPath, value: bool) -> Self {
+        self.get_mut_props(col).set_bloom_filter_enabled(value);
+        self
+    }
+
+    /// Sets the false positive probability for bloom filter for a specific column.
+    /// The behavior is similar to [`set_bloom_filter_fpp`](Self::set_bloom_filter_fpp) but will
+    /// override the default.
+    pub fn set_column_bloom_filter_fpp(mut self, col: ColumnPath, value: f64) -> Self {
+        self.get_mut_props(col).set_bloom_filter_fpp(value);
+        self
+    }
+
+    /// Sets the number of distinct values for bloom filter for a specific column.
+    /// The behavior is similar to [`set_bloom_filter_ndv`](Self::set_bloom_filter_ndv) but will
+    /// override the default.
+    pub fn set_column_bloom_filter_ndv(mut self, col: ColumnPath, value: u64) -> Self {
+        self.get_mut_props(col).set_bloom_filter_ndv(value);
+        self
+    }
+
+    /// Sets the max length of min/max value fields in the column index. Must be greater than 0.
+    /// If set to `None` - there's no effective limit.
+    pub fn set_column_index_truncate_length(mut self, max_length: Option<usize>) -> Self {
+        if let Some(value) = max_length {
+            assert!(value > 0, "Cannot have a 0 column index truncate length. If you wish to disable min/max value truncation, set it to `None`.");
+        }
+
+        self.column_index_truncate_length = max_length;
+        self
+    }
+
+    /// Sets the max length of min/max value fields in statistics. Must be greater than 0.
+    /// If set to `None` - there's no effective limit.
+    pub fn set_statistics_truncate_length(mut self, max_length: Option<usize>) -> Self {
+        if let Some(value) = max_length {
+            assert!(value > 0, "Cannot have a 0 statistics truncate length. If you wish to disable min/max value truncation, set it to `None`.");
+        }
+
+        self.statistics_truncate_length = max_length;
+        self
+    }
 }
 
 /// Controls the level of statistics to be computed by the writer
@@ -427,37 +680,78 @@ pub enum EnabledStatistics {
     Page,
 }
 
+impl FromStr for EnabledStatistics {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "NONE" | "none" => Ok(EnabledStatistics::None),
+            "CHUNK" | "chunk" => Ok(EnabledStatistics::Chunk),
+            "PAGE" | "page" => Ok(EnabledStatistics::Page),
+            _ => Err(format!("Invalid statistics arg: {}", s)),
+        }
+    }
+}
+
 impl Default for EnabledStatistics {
     fn default() -> Self {
         DEFAULT_STATISTICS_ENABLED
     }
 }
 
+/// Controls the bloom filter to be computed by the writer.
+#[derive(Debug, Clone, PartialEq)]
+pub struct BloomFilterProperties {
+    /// False positive probability, should be always between 0 and 1 exclusive. Defaults to [`DEFAULT_BLOOM_FILTER_FPP`].
+    ///
+    /// You should set this value by calling [`WriterPropertiesBuilder::set_bloom_filter_fpp`].
+    ///
+    /// The bloom filter data structure is a trade of between disk and memory space versus fpp, the
+    /// smaller the fpp, the more memory and disk space is required, thus setting it to a reasonable value
+    /// e.g. 0.1, 0.05, or 0.001 is recommended.
+    ///
+    /// Setting to very small number diminishes the value of the filter itself, as the bitset size is
+    /// even larger than just storing the whole value. You are also expected to set `ndv` if it can
+    /// be known in advance in order to largely reduce space usage.
+    pub fpp: f64,
+    /// Number of distinct values, should be non-negative to be meaningful. Defaults to [`DEFAULT_BLOOM_FILTER_NDV`].
+    ///
+    /// You should set this value by calling [`WriterPropertiesBuilder::set_bloom_filter_ndv`].
+    ///
+    /// Usage of bloom filter is most beneficial for columns with large cardinality, so a good heuristic
+    /// is to set ndv to number of rows. However it can reduce disk size if you know in advance a smaller
+    /// number of distinct values. For very small ndv value it is probably not worth it to use bloom filter
+    /// anyway.
+    ///
+    /// Increasing this value (without increasing fpp) will result in an increase in disk or memory size.
+    pub ndv: u64,
+}
+
+impl Default for BloomFilterProperties {
+    fn default() -> Self {
+        BloomFilterProperties {
+            fpp: DEFAULT_BLOOM_FILTER_FPP,
+            ndv: DEFAULT_BLOOM_FILTER_NDV,
+        }
+    }
+}
+
 /// Container for column properties that can be changed as part of writer.
 ///
 /// If a field is `None`, it means that no specific value has been set for this column,
 /// so some subsequent or default value must be used.
-#[derive(Debug, Clone, PartialEq)]
+#[derive(Debug, Clone, Default, PartialEq)]
 struct ColumnProperties {
     encoding: Option<Encoding>,
     codec: Option<Compression>,
     dictionary_enabled: Option<bool>,
     statistics_enabled: Option<EnabledStatistics>,
     max_statistics_size: Option<usize>,
+    /// bloom filter related properties
+    bloom_filter_properties: Option<BloomFilterProperties>,
 }
 
 impl ColumnProperties {
-    /// Initialise column properties with default values.
-    fn new() -> Self {
-        Self {
-            encoding: None,
-            codec: None,
-            dictionary_enabled: None,
-            statistics_enabled: None,
-            max_statistics_size: None,
-        }
-    }
-
     /// Sets encoding for this column.
     ///
     /// If dictionary is not enabled, this is treated as a primary encoding for a column.
@@ -494,6 +788,42 @@ impl ColumnProperties {
         self.max_statistics_size = Some(value);
     }
 
+    /// If `value` is `true`, sets bloom filter properties to default values if not previously set,
+    /// otherwise it is a no-op.
+    /// If `value` is `false`, resets bloom filter properties to `None`.
+    fn set_bloom_filter_enabled(&mut self, value: bool) {
+        if value && self.bloom_filter_properties.is_none() {
+            self.bloom_filter_properties = Some(Default::default())
+        } else if !value {
+            self.bloom_filter_properties = None
+        }
+    }
+
+    /// Sets the false positive probability for bloom filter for this column, and implicitly enables
+    /// bloom filter if not previously enabled.
+    ///
+    /// # Panics
+    ///
+    /// Panics if the `value` is not between 0 and 1 exclusive
+    fn set_bloom_filter_fpp(&mut self, value: f64) {
+        assert!(
+            value > 0. && value < 1.0,
+            "fpp must be between 0 and 1 exclusive, got {value}"
+        );
+
+        self.bloom_filter_properties
+            .get_or_insert_with(Default::default)
+            .fpp = value;
+    }
+
+    /// Sets the number of distinct (unique) values for bloom filter for this column, and implicitly
+    /// enables bloom filter if not previously enabled.
+    fn set_bloom_filter_ndv(&mut self, value: u64) {
+        self.bloom_filter_properties
+            .get_or_insert_with(Default::default)
+            .ndv = value;
+    }
+
     /// Returns optional encoding for this column.
     fn encoding(&self) -> Option<Encoding> {
         self.encoding
@@ -521,6 +851,108 @@ impl ColumnProperties {
     fn max_statistics_size(&self) -> Option<usize> {
         self.max_statistics_size
     }
+
+    /// Returns the bloom filter properties, or `None` if not enabled
+    fn bloom_filter_properties(&self) -> Option<&BloomFilterProperties> {
+        self.bloom_filter_properties.as_ref()
+    }
+}
+
+/// Reference counted reader properties.
+pub type ReaderPropertiesPtr = Arc<ReaderProperties>;
+
+const DEFAULT_READ_BLOOM_FILTER: bool = false;
+
+/// Configuration settings for reading parquet files.
+///
+/// All properties are immutable and `Send` + `Sync`.
+/// Use [`ReaderPropertiesBuilder`] to assemble these properties.
+///
+/// # Example
+///
+/// ```rust
+/// use parquet::file::properties::ReaderProperties;
+///
+/// // Create properties with default configuration.
+/// let props = ReaderProperties::builder().build();
+///
+/// // Use properties builder to set certain options and assemble the configuration.
+/// let props = ReaderProperties::builder()
+///     .set_backward_compatible_lz4(false)
+///     .build();
+/// ```
+pub struct ReaderProperties {
+    codec_options: CodecOptions,
+    read_bloom_filter: bool,
+}
+
+impl ReaderProperties {
+    /// Returns builder for reader properties with default values.
+    pub fn builder() -> ReaderPropertiesBuilder {
+        ReaderPropertiesBuilder::with_defaults()
+    }
+
+    /// Returns codec options.
+    pub(crate) fn codec_options(&self) -> &CodecOptions {
+        &self.codec_options
+    }
+
+    /// Returns whether to read bloom filter
+    pub(crate) fn read_bloom_filter(&self) -> bool {
+        self.read_bloom_filter
+    }
+}
+
+/// Builder for parquet file reader configuration. See example on
+/// [`ReaderProperties`]
+pub struct ReaderPropertiesBuilder {
+    codec_options_builder: CodecOptionsBuilder,
+    read_bloom_filter: Option<bool>,
+}
+
+/// Reader properties builder.
+impl ReaderPropertiesBuilder {
+    /// Returns default state of the builder.
+    fn with_defaults() -> Self {
+        Self {
+            codec_options_builder: CodecOptionsBuilder::default(),
+            read_bloom_filter: None,
+        }
+    }
+
+    /// Finalizes the configuration and returns immutable reader properties struct.
+    pub fn build(self) -> ReaderProperties {
+        ReaderProperties {
+            codec_options: self.codec_options_builder.build(),
+            read_bloom_filter: self.read_bloom_filter.unwrap_or(DEFAULT_READ_BLOOM_FILTER),
+        }
+    }
+
+    /// Enable/disable backward compatible LZ4.
+    ///
+    /// If backward compatible LZ4 is enable, on LZ4_HADOOP error it will fallback
+    /// to the older versions LZ4 algorithms. That is LZ4_FRAME, for backward compatibility
+    /// with files generated by older versions of this library, and LZ4_RAW, for backward
+    /// compatibility with files generated by older versions of parquet-cpp.
+    ///
+    /// If backward compatible LZ4 is disabled, on LZ4_HADOOP error it will return the error.
+    pub fn set_backward_compatible_lz4(mut self, value: bool) -> Self {
+        self.codec_options_builder = self
+            .codec_options_builder
+            .set_backward_compatible_lz4(value);
+        self
+    }
+
+    /// Enable/disable reading bloom filter
+    ///
+    /// If reading bloom filter is enabled, bloom filter will be read from the file.
+    /// If reading bloom filter is disabled, bloom filter will not be read from the file.
+    ///
+    /// By default bloom filter is set to be read.
+    pub fn set_read_bloom_filter(mut self, value: bool) -> Self {
+        self.read_bloom_filter = Some(value);
+        self
+    }
 }
 
 #[cfg(test)]
@@ -535,10 +967,10 @@ mod tests {
 
     #[test]
     fn test_writer_properties_default_settings() {
-        let props = WriterProperties::builder().build();
-        assert_eq!(props.data_pagesize_limit(), DEFAULT_PAGE_SIZE);
+        let props = WriterProperties::default();
+        assert_eq!(props.data_page_size_limit(), DEFAULT_PAGE_SIZE);
         assert_eq!(
-            props.dictionary_pagesize_limit(),
+            props.dictionary_page_size_limit(),
             DEFAULT_DICTIONARY_PAGE_SIZE_LIMIT
         );
         assert_eq!(props.write_batch_size(), DEFAULT_WRITE_BATCH_SIZE);
@@ -563,6 +995,9 @@ mod tests {
             props.max_statistics_size(&ColumnPath::from("col")),
             DEFAULT_MAX_STATISTICS_SIZE
         );
+        assert!(props
+            .bloom_filter_properties(&ColumnPath::from("col"))
+            .is_none());
     }
 
     #[test]
@@ -622,8 +1057,8 @@ mod tests {
         let props = WriterProperties::builder()
             // file settings
             .set_writer_version(WriterVersion::PARQUET_2_0)
-            .set_data_pagesize_limit(10)
-            .set_dictionary_pagesize_limit(20)
+            .set_data_page_size_limit(10)
+            .set_dictionary_page_size_limit(20)
             .set_write_batch_size(30)
             .set_max_row_group_size(40)
             .set_created_by("default".to_owned())
@@ -633,7 +1068,7 @@ mod tests {
             )]))
             // global column settings
             .set_encoding(Encoding::DELTA_BINARY_PACKED)
-            .set_compression(Compression::GZIP)
+            .set_compression(Compression::GZIP(Default::default()))
             .set_dictionary_enabled(false)
             .set_statistics_enabled(EnabledStatistics::None)
             .set_max_statistics_size(50)
@@ -641,16 +1076,16 @@ mod tests {
             .set_column_encoding(ColumnPath::from("col"), Encoding::RLE)
             .set_column_compression(ColumnPath::from("col"), Compression::SNAPPY)
             .set_column_dictionary_enabled(ColumnPath::from("col"), true)
-            .set_column_statistics_enabled(
-                ColumnPath::from("col"),
-                EnabledStatistics::Chunk,
-            )
+            .set_column_statistics_enabled(ColumnPath::from("col"), EnabledStatistics::Chunk)
             .set_column_max_statistics_size(ColumnPath::from("col"), 123)
+            .set_column_bloom_filter_enabled(ColumnPath::from("col"), true)
+            .set_column_bloom_filter_ndv(ColumnPath::from("col"), 100_u64)
+            .set_column_bloom_filter_fpp(ColumnPath::from("col"), 0.1)
             .build();
 
         assert_eq!(props.writer_version(), WriterVersion::PARQUET_2_0);
-        assert_eq!(props.data_pagesize_limit(), 10);
-        assert_eq!(props.dictionary_pagesize_limit(), 20);
+        assert_eq!(props.data_page_size_limit(), 10);
+        assert_eq!(props.dictionary_page_size_limit(), 20);
         assert_eq!(props.write_batch_size(), 30);
         assert_eq!(props.max_row_group_size(), 40);
         assert_eq!(props.created_by(), "default");
@@ -665,7 +1100,10 @@ mod tests {
             props.encoding(&ColumnPath::from("a")),
             Some(Encoding::DELTA_BINARY_PACKED)
         );
-        assert_eq!(props.compression(&ColumnPath::from("a")), Compression::GZIP);
+        assert_eq!(
+            props.compression(&ColumnPath::from("a")),
+            Compression::GZIP(Default::default())
+        );
         assert!(!props.dictionary_enabled(&ColumnPath::from("a")));
         assert_eq!(
             props.statistics_enabled(&ColumnPath::from("a")),
@@ -687,13 +1125,18 @@ mod tests {
             EnabledStatistics::Chunk
         );
         assert_eq!(props.max_statistics_size(&ColumnPath::from("col")), 123);
+        assert_eq!(
+            props.bloom_filter_properties(&ColumnPath::from("col")),
+            Some(&BloomFilterProperties { fpp: 0.1, ndv: 100 })
+        );
     }
 
     #[test]
     fn test_writer_properties_builder_partial_defaults() {
         let props = WriterProperties::builder()
             .set_encoding(Encoding::DELTA_BINARY_PACKED)
-            .set_compression(Compression::GZIP)
+            .set_compression(Compression::GZIP(Default::default()))
+            .set_bloom_filter_enabled(true)
             .set_column_encoding(ColumnPath::from("col"), Encoding::RLE)
             .build();
 
@@ -703,11 +1146,115 @@ mod tests {
         );
         assert_eq!(
             props.compression(&ColumnPath::from("col")),
-            Compression::GZIP
+            Compression::GZIP(Default::default())
         );
         assert_eq!(
             props.dictionary_enabled(&ColumnPath::from("col")),
             DEFAULT_DICTIONARY_ENABLED
         );
+        assert_eq!(
+            props.bloom_filter_properties(&ColumnPath::from("col")),
+            Some(&BloomFilterProperties {
+                fpp: 0.05,
+                ndv: 1_000_000_u64
+            })
+        );
+    }
+
+    #[test]
+    fn test_writer_properties_bloom_filter_ndv_fpp_set() {
+        assert_eq!(
+            WriterProperties::builder()
+                .build()
+                .bloom_filter_properties(&ColumnPath::from("col")),
+            None
+        );
+        assert_eq!(
+            WriterProperties::builder()
+                .set_bloom_filter_ndv(100)
+                .build()
+                .bloom_filter_properties(&ColumnPath::from("col")),
+            Some(&BloomFilterProperties {
+                fpp: 0.05,
+                ndv: 100
+            })
+        );
+        assert_eq!(
+            WriterProperties::builder()
+                .set_bloom_filter_fpp(0.1)
+                .build()
+                .bloom_filter_properties(&ColumnPath::from("col")),
+            Some(&BloomFilterProperties {
+                fpp: 0.1,
+                ndv: 1_000_000_u64
+            })
+        );
+    }
+
+    #[test]
+    fn test_reader_properties_default_settings() {
+        let props = ReaderProperties::builder().build();
+
+        let codec_options = CodecOptionsBuilder::default()
+            .set_backward_compatible_lz4(true)
+            .build();
+
+        assert_eq!(props.codec_options(), &codec_options);
+        assert!(!props.read_bloom_filter());
+    }
+
+    #[test]
+    fn test_reader_properties_builder() {
+        let props = ReaderProperties::builder()
+            .set_backward_compatible_lz4(false)
+            .build();
+
+        let codec_options = CodecOptionsBuilder::default()
+            .set_backward_compatible_lz4(false)
+            .build();
+
+        assert_eq!(props.codec_options(), &codec_options);
+    }
+
+    #[test]
+    fn test_parse_writerversion() {
+        let mut writer_version = "PARQUET_1_0".parse::<WriterVersion>().unwrap();
+        assert_eq!(writer_version, WriterVersion::PARQUET_1_0);
+        writer_version = "PARQUET_2_0".parse::<WriterVersion>().unwrap();
+        assert_eq!(writer_version, WriterVersion::PARQUET_2_0);
+
+        // test lowercase
+        writer_version = "parquet_1_0".parse::<WriterVersion>().unwrap();
+        assert_eq!(writer_version, WriterVersion::PARQUET_1_0);
+
+        // test invalid version
+        match "PARQUET_-1_0".parse::<WriterVersion>() {
+            Ok(_) => panic!("Should not be able to parse PARQUET_-1_0"),
+            Err(e) => {
+                assert_eq!(e, "Invalid writer version: PARQUET_-1_0");
+            }
+        }
+    }
+
+    #[test]
+    fn test_parse_enabledstatistics() {
+        let mut enabled_statistics = "NONE".parse::<EnabledStatistics>().unwrap();
+        assert_eq!(enabled_statistics, EnabledStatistics::None);
+        enabled_statistics = "CHUNK".parse::<EnabledStatistics>().unwrap();
+        assert_eq!(enabled_statistics, EnabledStatistics::Chunk);
+        enabled_statistics = "PAGE".parse::<EnabledStatistics>().unwrap();
+        assert_eq!(enabled_statistics, EnabledStatistics::Page);
+
+        // test lowercase
+        enabled_statistics = "none".parse::<EnabledStatistics>().unwrap();
+        assert_eq!(enabled_statistics, EnabledStatistics::None);
+
+        //test invalid statistics
+        match "ChunkAndPage".parse::<EnabledStatistics>() {
+            Ok(_) => panic!("Should not be able to parse ChunkAndPage"),
+            Err(e) => {
+                assert_eq!(e, "Invalid statistics arg: ChunkAndPage");
+            }
+        }
     }
 }
diff --git a/parquet/src/file/reader.rs b/parquet/src/file/reader.rs
index d752273655c5..dd6a0fdd2312 100644
--- a/parquet/src/file/reader.rs
+++ b/parquet/src/file/reader.rs
@@ -15,18 +15,23 @@
 // specific language governing permissions and limitations
 // under the License.
 
-//! Contains file reader API and provides methods to access file metadata, row group
-//! readers to read individual column chunks, or access record iterator.
+//! File reader API and methods to access file metadata, row group
+//! readers to read individual column chunks, or access record
+//! iterator.
 
+use bytes::{Buf, Bytes};
+use std::fs::File;
+use std::io::{BufReader, Seek, SeekFrom};
 use std::{boxed::Box, io::Read, sync::Arc};
 
+use crate::bloom_filter::Sbbf;
 use crate::column::page::PageIterator;
 use crate::column::{page::PageReader, reader::ColumnReader};
 use crate::errors::{ParquetError, Result};
 use crate::file::metadata::*;
 pub use crate::file::serialized_reader::{SerializedFileReader, SerializedPageReader};
 use crate::record::reader::RowIter;
-use crate::schema::types::{ColumnDescPtr, SchemaDescPtr, Type as SchemaType};
+use crate::schema::types::Type as SchemaType;
 
 use crate::basic::Type;
 
@@ -41,13 +46,77 @@ pub trait Length {
 }
 
 /// The ChunkReader trait generates readers of chunks of a source.
-/// For a file system reader, each chunk might contain a clone of File bounded on a given range.
-/// For an object store reader, each read can be mapped to a range request.
+///
+/// For more information see [`File::try_clone`]
 pub trait ChunkReader: Length + Send + Sync {
-    type T: Read + Send;
-    /// get a serialy readeable slice of the current reader
-    /// This should fail if the slice exceeds the current bounds
-    fn get_read(&self, start: u64, length: usize) -> Result<Self::T>;
+    type T: Read;
+
+    /// Get a [`Read`] starting at the provided file offset
+    ///
+    /// Subsequent or concurrent calls to [`Self::get_read`] or [`Self::get_bytes`] may
+    /// side-effect on previously returned [`Self::T`]. Care should be taken to avoid this
+    ///
+    /// See [`File::try_clone`] for more information
+    fn get_read(&self, start: u64) -> Result<Self::T>;
+
+    /// Get a range as bytes
+    ///
+    /// Concurrent calls to [`Self::get_bytes`] may result in interleaved output
+    ///
+    /// See [`File::try_clone`] for more information
+    fn get_bytes(&self, start: u64, length: usize) -> Result<Bytes>;
+}
+
+impl Length for File {
+    fn len(&self) -> u64 {
+        self.metadata().map(|m| m.len()).unwrap_or(0u64)
+    }
+}
+
+impl ChunkReader for File {
+    type T = BufReader<File>;
+
+    fn get_read(&self, start: u64) -> Result<Self::T> {
+        let mut reader = self.try_clone()?;
+        reader.seek(SeekFrom::Start(start))?;
+        Ok(BufReader::new(self.try_clone()?))
+    }
+
+    fn get_bytes(&self, start: u64, length: usize) -> Result<Bytes> {
+        let mut buffer = Vec::with_capacity(length);
+        let mut reader = self.try_clone()?;
+        reader.seek(SeekFrom::Start(start))?;
+        let read = reader.take(length as _).read_to_end(&mut buffer)?;
+
+        if read != length {
+            return Err(eof_err!(
+                "Expected to read {} bytes, read only {}",
+                length,
+                read
+            ));
+        }
+        Ok(buffer.into())
+    }
+}
+
+impl Length for Bytes {
+    fn len(&self) -> u64 {
+        self.len() as u64
+    }
+}
+
+impl ChunkReader for Bytes {
+    type T = bytes::buf::Reader<Bytes>;
+
+    fn get_read(&self, start: u64) -> Result<Self::T> {
+        let start = start as usize;
+        Ok(self.slice(start..).reader())
+    }
+
+    fn get_bytes(&self, start: u64, length: usize) -> Result<Bytes> {
+        let start = start as usize;
+        Ok(self.slice(start..start + length))
+    }
 }
 
 // ----------------------------------------------------------------------
@@ -65,7 +134,7 @@ pub trait FileReader: Send + Sync {
     /// Get the `i`th row group reader. Note this doesn't do bound check.
     fn get_row_group(&self, i: usize) -> Result<Box<dyn RowGroupReader + '_>>;
 
-    /// Get full iterator of `Row`s from a file (over all row groups).
+    /// Get an iterator over the row in this file, see [`RowIter`] for caveats.
     ///
     /// Iterator will automatically load the next row group to advance.
     ///
@@ -92,33 +161,28 @@ pub trait RowGroupReader: Send + Sync {
         let col_descr = schema_descr.column(i);
         let col_page_reader = self.get_column_page_reader(i)?;
         let col_reader = match col_descr.physical_type() {
-            Type::BOOLEAN => ColumnReader::BoolColumnReader(ColumnReaderImpl::new(
-                col_descr,
-                col_page_reader,
-            )),
-            Type::INT32 => ColumnReader::Int32ColumnReader(ColumnReaderImpl::new(
-                col_descr,
-                col_page_reader,
-            )),
-            Type::INT64 => ColumnReader::Int64ColumnReader(ColumnReaderImpl::new(
-                col_descr,
-                col_page_reader,
-            )),
-            Type::INT96 => ColumnReader::Int96ColumnReader(ColumnReaderImpl::new(
-                col_descr,
-                col_page_reader,
-            )),
-            Type::FLOAT => ColumnReader::FloatColumnReader(ColumnReaderImpl::new(
+            Type::BOOLEAN => {
+                ColumnReader::BoolColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+            }
+            Type::INT32 => {
+                ColumnReader::Int32ColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+            }
+            Type::INT64 => {
+                ColumnReader::Int64ColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+            }
+            Type::INT96 => {
+                ColumnReader::Int96ColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+            }
+            Type::FLOAT => {
+                ColumnReader::FloatColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+            }
+            Type::DOUBLE => {
+                ColumnReader::DoubleColumnReader(ColumnReaderImpl::new(col_descr, col_page_reader))
+            }
+            Type::BYTE_ARRAY => ColumnReader::ByteArrayColumnReader(ColumnReaderImpl::new(
                 col_descr,
                 col_page_reader,
             )),
-            Type::DOUBLE => ColumnReader::DoubleColumnReader(ColumnReaderImpl::new(
-                col_descr,
-                col_page_reader,
-            )),
-            Type::BYTE_ARRAY => ColumnReader::ByteArrayColumnReader(
-                ColumnReaderImpl::new(col_descr, col_page_reader),
-            ),
             Type::FIXED_LEN_BYTE_ARRAY => ColumnReader::FixedLenByteArrayColumnReader(
                 ColumnReaderImpl::new(col_descr, col_page_reader),
             ),
@@ -126,7 +190,11 @@ pub trait RowGroupReader: Send + Sync {
         Ok(col_reader)
     }
 
-    /// Get iterator of `Row`s from this row group.
+    /// Get bloom filter for the `i`th column chunk, if present and the reader was configured
+    /// to read bloom filters.
+    fn get_column_bloom_filter(&self, i: usize) -> Option<&Sbbf>;
+
+    /// Get an iterator over the row in this file, see [`RowIter`] for caveats.
     ///
     /// Projected schema can be a subset of or equal to the file schema, when it is None,
     /// full file schema is assumed.
@@ -191,16 +259,4 @@ impl Iterator for FilePageIterator {
     }
 }
 
-impl PageIterator for FilePageIterator {
-    fn schema(&mut self) -> Result<SchemaDescPtr> {
-        Ok(self
-            .file_reader
-            .metadata()
-            .file_metadata()
-            .schema_descr_ptr())
-    }
-
-    fn column_schema(&mut self) -> Result<ColumnDescPtr> {
-        self.schema().map(|s| s.column(self.column_index))
-    }
-}
+impl PageIterator for FilePageIterator {}
diff --git a/parquet/src/file/serialized_reader.rs b/parquet/src/file/serialized_reader.rs
index 0b7451f4bea7..5c47e5a83cea 100644
--- a/parquet/src/file/serialized_reader.rs
+++ b/parquet/src/file/serialized_reader.rs
@@ -18,72 +18,30 @@
 //! Contains implementations of the reader traits FileReader, RowGroupReader and PageReader
 //! Also contains implementations of the ChunkReader for files (with buffering) and byte arrays (RAM)
 
-use bytes::{Buf, Bytes};
 use std::collections::VecDeque;
+use std::iter;
 use std::{convert::TryFrom, fs::File, io::Read, path::Path, sync::Arc};
 
-use parquet_format::{PageHeader, PageLocation, PageType};
-use thrift::protocol::TCompactInputProtocol;
-
-use crate::basic::{Compression, Encoding, Type};
+use crate::basic::{Encoding, Type};
+use crate::bloom_filter::Sbbf;
 use crate::column::page::{Page, PageMetadata, PageReader};
 use crate::compression::{create_codec, Codec};
 use crate::errors::{ParquetError, Result};
 use crate::file::page_index::index_reader;
-use crate::file::{footer, metadata::*, reader::*, statistics};
+use crate::file::{
+    footer,
+    metadata::*,
+    properties::{ReaderProperties, ReaderPropertiesPtr},
+    reader::*,
+    statistics,
+};
+use crate::format::{PageHeader, PageLocation, PageType};
 use crate::record::reader::RowIter;
 use crate::record::Row;
 use crate::schema::types::Type as SchemaType;
-use crate::util::page_util::{calculate_row_count, get_pages_readable_slices};
-use crate::util::{io::TryClone, memory::ByteBufferPtr};
-
-// export `SliceableCursor` and `FileSource` publically so clients can
-// re-use the logic in their own ParquetFileWriter wrappers
-pub use crate::util::io::FileSource;
-
-// ----------------------------------------------------------------------
-// Implementations of traits facilitating the creation of a new reader
-
-impl Length for File {
-    fn len(&self) -> u64 {
-        self.metadata().map(|m| m.len()).unwrap_or(0u64)
-    }
-}
-
-impl TryClone for File {
-    fn try_clone(&self) -> std::io::Result<Self> {
-        self.try_clone()
-    }
-}
-
-impl ChunkReader for File {
-    type T = FileSource<File>;
-
-    fn get_read(&self, start: u64, length: usize) -> Result<Self::T> {
-        Ok(FileSource::new(self, start, length))
-    }
-}
-
-impl Length for Bytes {
-    fn len(&self) -> u64 {
-        self.len() as u64
-    }
-}
-
-impl TryClone for Bytes {
-    fn try_clone(&self) -> std::io::Result<Self> {
-        Ok(self.clone())
-    }
-}
-
-impl ChunkReader for Bytes {
-    type T = bytes::buf::Reader<Bytes>;
-
-    fn get_read(&self, start: u64, length: usize) -> Result<Self::T> {
-        let start = start as usize;
-        Ok(self.slice(start..start + length).reader())
-    }
-}
+use crate::thrift::{TCompactSliceInputProtocol, TSerializable};
+use bytes::Bytes;
+use thrift::protocol::TCompactInputProtocol;
 
 impl TryFrom<File> for SerializedFileReader<File> {
     type Error = ParquetError;
@@ -118,10 +76,10 @@ impl<'a> TryFrom<&'a str> for SerializedFileReader<File> {
     }
 }
 
-/// Conversion into a [`RowIter`](crate::record::reader::RowIter)
+/// Conversion into a [`RowIter`]
 /// using the full file schema over all row groups.
 impl IntoIterator for SerializedFileReader<File> {
-    type Item = Row;
+    type Item = Result<Row>;
     type IntoIter = RowIter<'static>;
 
     fn into_iter(self) -> Self::IntoIter {
@@ -135,7 +93,8 @@ impl IntoIterator for SerializedFileReader<File> {
 /// A serialized implementation for Parquet [`FileReader`].
 pub struct SerializedFileReader<R: ChunkReader> {
     chunk_reader: Arc<R>,
-    metadata: ParquetMetaData,
+    metadata: Arc<ParquetMetaData>,
+    props: ReaderPropertiesPtr,
 }
 
 /// A predicate for filtering row groups, invoked with the metadata and index
@@ -150,6 +109,7 @@ pub type ReadGroupPredicate = Box<dyn FnMut(&RowGroupMetaData, usize) -> bool>;
 pub struct ReadOptionsBuilder {
     predicates: Vec<ReadGroupPredicate>,
     enable_page_index: bool,
+    props: Option<ReaderProperties>,
 }
 
 impl ReadOptionsBuilder {
@@ -177,17 +137,30 @@ impl ReadOptionsBuilder {
         self
     }
 
-    /// Enable page index in the reading option,
+    /// Enable reading the page index structures described in
+    /// "[Column Index] Layout to Support Page Skipping"
+    ///
+    /// [Column Index]: https://github.com/apache/parquet-format/blob/master/PageIndex.md
     pub fn with_page_index(mut self) -> Self {
         self.enable_page_index = true;
         self
     }
 
+    /// Set the [`ReaderProperties`] configuration.
+    pub fn with_reader_properties(mut self, properties: ReaderProperties) -> Self {
+        self.props = Some(properties);
+        self
+    }
+
     /// Seal the builder and return the read options
     pub fn build(self) -> ReadOptions {
+        let props = self
+            .props
+            .unwrap_or_else(|| ReaderProperties::builder().build());
         ReadOptions {
             predicates: self.predicates,
             enable_page_index: self.enable_page_index,
+            props,
         }
     }
 }
@@ -199,6 +172,7 @@ impl ReadOptionsBuilder {
 pub struct ReadOptions {
     predicates: Vec<ReadGroupPredicate>,
     enable_page_index: bool,
+    props: ReaderProperties,
 }
 
 impl<R: 'static + ChunkReader> SerializedFileReader<R> {
@@ -206,9 +180,11 @@ impl<R: 'static + ChunkReader> SerializedFileReader<R> {
     /// Returns error if Parquet file does not exist or is corrupt.
     pub fn new(chunk_reader: R) -> Result<Self> {
         let metadata = footer::parse_metadata(&chunk_reader)?;
+        let props = Arc::new(ReaderProperties::builder().build());
         Ok(Self {
             chunk_reader: Arc::new(chunk_reader),
-            metadata,
+            metadata: Arc::new(metadata),
+            props,
         })
     }
 
@@ -237,31 +213,30 @@ impl<R: 'static + ChunkReader> SerializedFileReader<R> {
             let mut offset_indexes = vec![];
 
             for rg in &mut filtered_row_groups {
-                let column_index =
-                    index_reader::read_columns_indexes(&chunk_reader, rg.columns())?;
-                let offset_index =
-                    index_reader::read_pages_locations(&chunk_reader, rg.columns())?;
-                rg.set_page_offset(offset_index.clone());
+                let column_index = index_reader::read_columns_indexes(&chunk_reader, rg.columns())?;
+                let offset_index = index_reader::read_pages_locations(&chunk_reader, rg.columns())?;
                 columns_indexes.push(column_index);
                 offset_indexes.push(offset_index);
             }
 
             Ok(Self {
                 chunk_reader: Arc::new(chunk_reader),
-                metadata: ParquetMetaData::new_with_page_index(
+                metadata: Arc::new(ParquetMetaData::new_with_page_index(
                     metadata.file_metadata().clone(),
                     filtered_row_groups,
                     Some(columns_indexes),
                     Some(offset_indexes),
-                ),
+                )),
+                props: Arc::new(options.props),
             })
         } else {
             Ok(Self {
                 chunk_reader: Arc::new(chunk_reader),
-                metadata: ParquetMetaData::new(
+                metadata: Arc::new(ParquetMetaData::new(
                     metadata.file_metadata().clone(),
                     filtered_row_groups,
-                ),
+                )),
+                props: Arc::new(options.props),
             })
         }
     }
@@ -291,11 +266,14 @@ impl<R: 'static + ChunkReader> FileReader for SerializedFileReader<R> {
     fn get_row_group(&self, i: usize) -> Result<Box<dyn RowGroupReader + '_>> {
         let row_group_metadata = self.metadata.row_group(i);
         // Row groups should be processed sequentially.
+        let props = Arc::clone(&self.props);
         let f = Arc::clone(&self.chunk_reader);
         Ok(Box::new(SerializedRowGroupReader::new(
             f,
             row_group_metadata,
-        )))
+            self.metadata.offset_index().map(|x| x[i].as_slice()),
+            props,
+        )?))
     }
 
     fn get_row_iter(&self, projection: Option<SchemaType>) -> Result<RowIter> {
@@ -307,15 +285,35 @@ impl<R: 'static + ChunkReader> FileReader for SerializedFileReader<R> {
 pub struct SerializedRowGroupReader<'a, R: ChunkReader> {
     chunk_reader: Arc<R>,
     metadata: &'a RowGroupMetaData,
+    page_locations: Option<&'a [Vec<PageLocation>]>,
+    props: ReaderPropertiesPtr,
+    bloom_filters: Vec<Option<Sbbf>>,
 }
 
 impl<'a, R: ChunkReader> SerializedRowGroupReader<'a, R> {
-    /// Creates new row group reader from a file and row group metadata.
-    fn new(chunk_reader: Arc<R>, metadata: &'a RowGroupMetaData) -> Self {
-        Self {
+    /// Creates new row group reader from a file, row group metadata and custom config.
+    pub fn new(
+        chunk_reader: Arc<R>,
+        metadata: &'a RowGroupMetaData,
+        page_locations: Option<&'a [Vec<PageLocation>]>,
+        props: ReaderPropertiesPtr,
+    ) -> Result<Self> {
+        let bloom_filters = if props.read_bloom_filter() {
+            metadata
+                .columns()
+                .iter()
+                .map(|col| Sbbf::read_from_column_chunk(col, chunk_reader.clone()))
+                .collect::<Result<Vec<_>>>()?
+        } else {
+            iter::repeat(None).take(metadata.columns().len()).collect()
+        };
+        Ok(Self {
             chunk_reader,
             metadata,
-        }
+            page_locations,
+            props,
+            bloom_filters,
+        })
     }
 }
 
@@ -331,33 +329,22 @@ impl<'a, R: 'static + ChunkReader> RowGroupReader for SerializedRowGroupReader<'
     // TODO: fix PARQUET-816
     fn get_column_page_reader(&self, i: usize) -> Result<Box<dyn PageReader>> {
         let col = self.metadata.column(i);
-        let (col_start, col_length) = col.byte_range();
-        let page_reader = if let Some(offset_index) = self.metadata.page_offset_index() {
-            let col_chunk_offset_index = &offset_index[i];
-            let (page_bufs, has_dict) = get_pages_readable_slices(
-                col_chunk_offset_index,
-                col_start,
-                self.chunk_reader.clone(),
-            )?;
-            SerializedPageReader::new_with_page_offsets(
-                col.num_values(),
-                col.compression(),
-                col.column_descr().physical_type(),
-                col_chunk_offset_index.clone(),
-                has_dict,
-                page_bufs,
-            )?
-        } else {
-            let file_chunk =
-                self.chunk_reader.get_read(col_start, col_length as usize)?;
-            SerializedPageReader::new(
-                file_chunk,
-                col.num_values(),
-                col.compression(),
-                col.column_descr().physical_type(),
-            )?
-        };
-        Ok(Box::new(page_reader))
+
+        let page_locations = self.page_locations.map(|x| x[i].clone());
+
+        let props = Arc::clone(&self.props);
+        Ok(Box::new(SerializedPageReader::new_with_properties(
+            Arc::clone(&self.chunk_reader),
+            col,
+            self.metadata.num_rows() as usize,
+            page_locations,
+            props,
+        )?))
+    }
+
+    /// get bloom filter for the `i`th column
+    fn get_column_bloom_filter(&self, i: usize) -> Option<&Sbbf> {
+        self.bloom_filters[i].as_ref()
     }
 
     fn get_row_iter(&self, projection: Option<SchemaType>) -> Result<RowIter> {
@@ -372,10 +359,34 @@ pub(crate) fn read_page_header<T: Read>(input: &mut T) -> Result<PageHeader> {
     Ok(page_header)
 }
 
+/// Reads a [`PageHeader`] from the provided [`Read`] returning the number of bytes read
+fn read_page_header_len<T: Read>(input: &mut T) -> Result<(usize, PageHeader)> {
+    /// A wrapper around a [`std::io::Read`] that keeps track of the bytes read
+    struct TrackedRead<R> {
+        inner: R,
+        bytes_read: usize,
+    }
+
+    impl<R: Read> Read for TrackedRead<R> {
+        fn read(&mut self, buf: &mut [u8]) -> std::io::Result<usize> {
+            let v = self.inner.read(buf)?;
+            self.bytes_read += v;
+            Ok(v)
+        }
+    }
+
+    let mut tracked = TrackedRead {
+        inner: input,
+        bytes_read: 0,
+    };
+    let header = read_page_header(&mut tracked)?;
+    Ok((tracked.bytes_read, header))
+}
+
 /// Decodes a [`Page`] from the provided `buffer`
 pub(crate) fn decode_page(
     page_header: PageHeader,
-    buffer: ByteBufferPtr,
+    buffer: Bytes,
     physical_type: Type,
     decompressor: Option<&mut Box<dyn Codec>>,
 ) -> Result<Page> {
@@ -389,8 +400,8 @@ pub(crate) fn decode_page(
     let mut can_decompress = true;
 
     if let Some(ref header_v2) = page_header.data_page_header_v2 {
-        offset = (header_v2.definition_levels_byte_length
-            + header_v2.repetition_levels_byte_length) as usize;
+        offset = (header_v2.definition_levels_byte_length + header_v2.repetition_levels_byte_length)
+            as usize;
         // When is_compressed flag is missing the page is considered compressed
         can_decompress = header_v2.is_compressed.unwrap_or(true);
     }
@@ -403,7 +414,11 @@ pub(crate) fn decode_page(
             let mut decompressed = Vec::with_capacity(uncompressed_size);
             let compressed = &buffer.as_ref()[offset..];
             decompressed.extend_from_slice(&buffer.as_ref()[..offset]);
-            decompressor.decompress(compressed, &mut decompressed)?;
+            decompressor.decompress(
+                compressed,
+                &mut decompressed,
+                Some(uncompressed_size - offset),
+            )?;
 
             if decompressed.len() != uncompressed_size {
                 return Err(general_err!(
@@ -413,49 +428,52 @@ pub(crate) fn decode_page(
                 ));
             }
 
-            ByteBufferPtr::new(decompressed)
+            Bytes::from(decompressed)
         }
         _ => buffer,
     };
 
     let result = match page_header.type_ {
-        PageType::DictionaryPage => {
-            assert!(page_header.dictionary_page_header.is_some());
-            let dict_header = page_header.dictionary_page_header.as_ref().unwrap();
+        PageType::DICTIONARY_PAGE => {
+            let dict_header = page_header.dictionary_page_header.as_ref().ok_or_else(|| {
+                ParquetError::General("Missing dictionary page header".to_string())
+            })?;
             let is_sorted = dict_header.is_sorted.unwrap_or(false);
             Page::DictionaryPage {
                 buf: buffer,
                 num_values: dict_header.num_values as u32,
-                encoding: Encoding::from(dict_header.encoding),
+                encoding: Encoding::try_from(dict_header.encoding)?,
                 is_sorted,
             }
         }
-        PageType::DataPage => {
-            assert!(page_header.data_page_header.is_some());
-            let header = page_header.data_page_header.unwrap();
+        PageType::DATA_PAGE => {
+            let header = page_header
+                .data_page_header
+                .ok_or_else(|| ParquetError::General("Missing V1 data page header".to_string()))?;
             Page::DataPage {
                 buf: buffer,
                 num_values: header.num_values as u32,
-                encoding: Encoding::from(header.encoding),
-                def_level_encoding: Encoding::from(header.definition_level_encoding),
-                rep_level_encoding: Encoding::from(header.repetition_level_encoding),
-                statistics: statistics::from_thrift(physical_type, header.statistics),
+                encoding: Encoding::try_from(header.encoding)?,
+                def_level_encoding: Encoding::try_from(header.definition_level_encoding)?,
+                rep_level_encoding: Encoding::try_from(header.repetition_level_encoding)?,
+                statistics: statistics::from_thrift(physical_type, header.statistics)?,
             }
         }
-        PageType::DataPageV2 => {
-            assert!(page_header.data_page_header_v2.is_some());
-            let header = page_header.data_page_header_v2.unwrap();
+        PageType::DATA_PAGE_V2 => {
+            let header = page_header
+                .data_page_header_v2
+                .ok_or_else(|| ParquetError::General("Missing V2 data page header".to_string()))?;
             let is_compressed = header.is_compressed.unwrap_or(true);
             Page::DataPageV2 {
                 buf: buffer,
                 num_values: header.num_values as u32,
-                encoding: Encoding::from(header.encoding),
+                encoding: Encoding::try_from(header.encoding)?,
                 num_nulls: header.num_nulls as u32,
                 num_rows: header.num_rows as u32,
                 def_levels_byte_len: header.definition_levels_byte_length as u32,
                 rep_levels_byte_len: header.repetition_levels_byte_length as u32,
                 is_compressed,
-                statistics: statistics::from_thrift(physical_type, header.statistics),
+                statistics: statistics::from_thrift(physical_type, header.statistics)?,
             }
         }
         _ => {
@@ -467,83 +485,98 @@ pub(crate) fn decode_page(
     Ok(result)
 }
 
-enum SerializedPages<T: Read> {
-    /// Read entire chunk
-    Chunk { buf: T },
-    /// Read operate pages which can skip.
+enum SerializedPageReaderState {
+    Values {
+        /// The current byte offset in the reader
+        offset: usize,
+
+        /// The length of the chunk in bytes
+        remaining_bytes: usize,
+
+        // If the next page header has already been "peeked", we will cache it and it`s length here
+        next_page_header: Option<Box<PageHeader>>,
+    },
     Pages {
-        offset_index: Vec<PageLocation>,
-        seen_num_data_pages: usize,
-        has_dictionary_page_to_read: bool,
-        page_bufs: VecDeque<T>,
+        /// Remaining page locations
+        page_locations: VecDeque<PageLocation>,
+        /// Remaining dictionary location if any
+        dictionary_page: Option<PageLocation>,
+        /// The total number of rows in this column chunk
+        total_rows: usize,
     },
 }
 
 /// A serialized implementation for Parquet [`PageReader`].
-pub struct SerializedPageReader<T: Read> {
-    // The file source buffer which references exactly the bytes for the column trunk
-    // to be read by this page reader.
-    buf: SerializedPages<T>,
+pub struct SerializedPageReader<R: ChunkReader> {
+    /// The chunk reader
+    reader: Arc<R>,
 
-    // The compression codec for this column chunk. Only set for non-PLAIN codec.
+    /// The compression codec for this column chunk. Only set for non-PLAIN codec.
     decompressor: Option<Box<dyn Codec>>,
 
-    // The number of values we have seen so far.
-    seen_num_values: i64,
-
-    // The number of total values in this column chunk.
-    total_num_values: i64,
-
-    // Column chunk type.
+    /// Column chunk type.
     physical_type: Type,
+
+    state: SerializedPageReaderState,
 }
 
-impl<T: Read> SerializedPageReader<T> {
-    /// Creates a new serialized page reader from file source.
+impl<R: ChunkReader> SerializedPageReader<R> {
+    /// Creates a new serialized page reader from a chunk reader and metadata
     pub fn new(
-        buf: T,
-        total_num_values: i64,
-        compression: Compression,
-        physical_type: Type,
+        reader: Arc<R>,
+        meta: &ColumnChunkMetaData,
+        total_rows: usize,
+        page_locations: Option<Vec<PageLocation>>,
     ) -> Result<Self> {
-        let decompressor = create_codec(compression)?;
-        let result = Self {
-            buf: SerializedPages::Chunk { buf },
-            total_num_values,
-            seen_num_values: 0,
-            decompressor,
-            physical_type,
-        };
-        Ok(result)
+        let props = Arc::new(ReaderProperties::builder().build());
+        SerializedPageReader::new_with_properties(reader, meta, total_rows, page_locations, props)
     }
 
-    /// Creates a new serialized page reader from file source.
-    pub fn new_with_page_offsets(
-        total_num_values: i64,
-        compression: Compression,
-        physical_type: Type,
-        offset_index: Vec<PageLocation>,
-        has_dictionary_page_to_read: bool,
-        page_bufs: VecDeque<T>,
+    /// Creates a new serialized page with custom options.
+    pub fn new_with_properties(
+        reader: Arc<R>,
+        meta: &ColumnChunkMetaData,
+        total_rows: usize,
+        page_locations: Option<Vec<PageLocation>>,
+        props: ReaderPropertiesPtr,
     ) -> Result<Self> {
-        let decompressor = create_codec(compression)?;
-        let result = Self {
-            buf: SerializedPages::Pages {
-                offset_index,
-                seen_num_data_pages: 0,
-                has_dictionary_page_to_read,
-                page_bufs,
+        let decompressor = create_codec(meta.compression(), props.codec_options())?;
+        let (start, len) = meta.byte_range();
+
+        let state = match page_locations {
+            Some(locations) => {
+                let dictionary_page = match locations.first() {
+                    Some(dict_offset) if dict_offset.offset as u64 != start => Some(PageLocation {
+                        offset: start as i64,
+                        compressed_page_size: (dict_offset.offset as u64 - start) as i32,
+                        first_row_index: 0,
+                    }),
+                    _ => None,
+                };
+
+                SerializedPageReaderState::Pages {
+                    page_locations: locations.into(),
+                    dictionary_page,
+                    total_rows,
+                }
+            }
+            None => SerializedPageReaderState::Values {
+                offset: start as usize,
+                remaining_bytes: len as usize,
+                next_page_header: None,
             },
-            total_num_values,
-            seen_num_values: 0,
-            decompressor,
-            physical_type,
         };
-        Ok(result)
+
+        Ok(Self {
+            reader,
+            decompressor,
+            state,
+            physical_type: meta.column_type(),
+        })
     }
 }
 
-impl<T: Read + Send> Iterator for SerializedPageReader<T> {
+impl<R: ChunkReader> Iterator for SerializedPageReader<R> {
     type Item = Result<Page>;
 
     fn next(&mut self) -> Option<Self::Item> {
@@ -551,150 +584,209 @@ impl<T: Read + Send> Iterator for SerializedPageReader<T> {
     }
 }
 
-impl<T: Read + Send> PageReader for SerializedPageReader<T> {
+impl<R: ChunkReader> PageReader for SerializedPageReader<R> {
     fn get_next_page(&mut self) -> Result<Option<Page>> {
-        let mut cursor;
-        let mut dictionary_cursor;
-        while self.seen_num_values < self.total_num_values {
-            match &mut self.buf {
-                SerializedPages::Chunk { buf } => {
-                    cursor = buf;
-                }
-                SerializedPages::Pages {
-                    offset_index,
-                    seen_num_data_pages,
-                    has_dictionary_page_to_read,
-                    page_bufs,
+        loop {
+            let page = match &mut self.state {
+                SerializedPageReaderState::Values {
+                    offset,
+                    remaining_bytes: remaining,
+                    next_page_header,
                 } => {
-                    if offset_index.len() <= *seen_num_data_pages {
+                    if *remaining == 0 {
                         return Ok(None);
-                    } else if *seen_num_data_pages == 0 && *has_dictionary_page_to_read {
-                        dictionary_cursor = page_bufs.pop_front().unwrap();
-                        cursor = &mut dictionary_cursor;
-                    } else {
-                        cursor = page_bufs.get_mut(*seen_num_data_pages).unwrap();
                     }
-                }
-            }
 
-            let page_header = read_page_header(cursor)?;
+                    let mut read = self.reader.get_read(*offset as u64)?;
+                    let header = if let Some(header) = next_page_header.take() {
+                        *header
+                    } else {
+                        let (header_len, header) = read_page_header_len(&mut read)?;
+                        *offset += header_len;
+                        *remaining -= header_len;
+                        header
+                    };
+                    let data_len = header.compressed_page_size as usize;
+                    *offset += data_len;
+                    *remaining -= data_len;
+
+                    if header.type_ == PageType::INDEX_PAGE {
+                        continue;
+                    }
 
-            let to_read = page_header.compressed_page_size as usize;
-            let mut buffer = Vec::with_capacity(to_read);
-            let read = cursor.take(to_read as u64).read_to_end(&mut buffer)?;
+                    let mut buffer = Vec::with_capacity(data_len);
+                    let read = read.take(data_len as u64).read_to_end(&mut buffer)?;
 
-            if read != to_read {
-                return Err(eof_err!(
-                    "Expected to read {} bytes of page, read only {}",
-                    to_read,
-                    read
-                ));
-            }
+                    if read != data_len {
+                        return Err(eof_err!(
+                            "Expected to read {} bytes of page, read only {}",
+                            data_len,
+                            read
+                        ));
+                    }
 
-            let buffer = ByteBufferPtr::new(buffer);
-            let result = match page_header.type_ {
-                PageType::DataPage | PageType::DataPageV2 => {
-                    let decoded = decode_page(
-                        page_header,
-                        buffer,
+                    decode_page(
+                        header,
+                        Bytes::from(buffer),
                         self.physical_type,
                         self.decompressor.as_mut(),
-                    )?;
-                    self.seen_num_values += decoded.num_values() as i64;
-                    if let SerializedPages::Pages {
-                        seen_num_data_pages,
-                        ..
-                    } = &mut self.buf
-                    {
-                        *seen_num_data_pages += 1;
-                    }
-                    decoded
+                    )?
                 }
-                PageType::DictionaryPage => {
-                    if let SerializedPages::Pages {
-                        has_dictionary_page_to_read,
-                        ..
-                    } = &mut self.buf
+                SerializedPageReaderState::Pages {
+                    page_locations,
+                    dictionary_page,
+                    ..
+                } => {
+                    let front = match dictionary_page
+                        .take()
+                        .or_else(|| page_locations.pop_front())
                     {
-                        *has_dictionary_page_to_read = false;
-                    }
+                        Some(front) => front,
+                        None => return Ok(None),
+                    };
+
+                    let page_len = front.compressed_page_size as usize;
+
+                    let buffer = self.reader.get_bytes(front.offset as u64, page_len)?;
+
+                    let mut prot = TCompactSliceInputProtocol::new(buffer.as_ref());
+                    let header = PageHeader::read_from_in_protocol(&mut prot)?;
+                    let offset = buffer.len() - prot.as_slice().len();
+
+                    let bytes = buffer.slice(offset..);
                     decode_page(
-                        page_header,
-                        buffer,
+                        header,
+                        bytes,
                         self.physical_type,
                         self.decompressor.as_mut(),
                     )?
                 }
-                _ => {
-                    // For unknown page type (e.g., INDEX_PAGE), skip and read next.
-                    continue;
-                }
             };
-            return Ok(Some(result));
-        }
 
-        // We are at the end of this column chunk and no more page left. Return None.
-        Ok(None)
+            return Ok(Some(page));
+        }
     }
 
     fn peek_next_page(&mut self) -> Result<Option<PageMetadata>> {
-        match &mut self.buf {
-            SerializedPages::Chunk { .. } => { Err(general_err!("Must set page_offset_index when using peek_next_page in SerializedPageReader.")) }
-            SerializedPages::Pages { offset_index, seen_num_data_pages, has_dictionary_page_to_read, .. } => {
-                if *seen_num_data_pages >= offset_index.len() {
-                    Ok(None)
-                } else if *seen_num_data_pages == 0 && *has_dictionary_page_to_read {
-                    // Will set `has_dictionary_page_to_read` false in `get_next_page`,
-                    // assume dictionary page must be read and cannot be skipped.
+        match &mut self.state {
+            SerializedPageReaderState::Values {
+                offset,
+                remaining_bytes,
+                next_page_header,
+            } => {
+                loop {
+                    if *remaining_bytes == 0 {
+                        return Ok(None);
+                    }
+                    return if let Some(header) = next_page_header.as_ref() {
+                        if let Ok(page_meta) = (&**header).try_into() {
+                            Ok(Some(page_meta))
+                        } else {
+                            // For unknown page type (e.g., INDEX_PAGE), skip and read next.
+                            *next_page_header = None;
+                            continue;
+                        }
+                    } else {
+                        let mut read = self.reader.get_read(*offset as u64)?;
+                        let (header_len, header) = read_page_header_len(&mut read)?;
+                        *offset += header_len;
+                        *remaining_bytes -= header_len;
+                        let page_meta = if let Ok(page_meta) = (&header).try_into() {
+                            Ok(Some(page_meta))
+                        } else {
+                            // For unknown page type (e.g., INDEX_PAGE), skip and read next.
+                            continue;
+                        };
+                        *next_page_header = Some(Box::new(header));
+                        page_meta
+                    };
+                }
+            }
+            SerializedPageReaderState::Pages {
+                page_locations,
+                dictionary_page,
+                total_rows,
+            } => {
+                if dictionary_page.is_some() {
                     Ok(Some(PageMetadata {
-                        num_rows: usize::MIN,
+                        num_rows: None,
+                        num_levels: None,
                         is_dict: true,
                     }))
-                } else {
-                    let row_count = calculate_row_count(
-                        offset_index,
-                        *seen_num_data_pages,
-                        self.total_num_values,
-                    )?;
+                } else if let Some(page) = page_locations.front() {
+                    let next_rows = page_locations
+                        .get(1)
+                        .map(|x| x.first_row_index as usize)
+                        .unwrap_or(*total_rows);
+
                     Ok(Some(PageMetadata {
-                        num_rows: row_count,
+                        num_rows: Some(next_rows - page.first_row_index as usize),
+                        num_levels: None,
                         is_dict: false,
                     }))
+                } else {
+                    Ok(None)
                 }
             }
         }
     }
 
     fn skip_next_page(&mut self) -> Result<()> {
-        match &mut self.buf {
-            SerializedPages::Chunk { .. } => { Err(general_err!("Must set page_offset_index when using skip_next_page in SerializedPageReader.")) }
-            SerializedPages::Pages { offset_index, seen_num_data_pages, .. } => {
-                if offset_index.len() <= *seen_num_data_pages {
-                    Err(general_err!(
-                    "seen_num_data_pages is out of bound in SerializedPageReader."
-                ))
+        match &mut self.state {
+            SerializedPageReaderState::Values {
+                offset,
+                remaining_bytes,
+                next_page_header,
+            } => {
+                if let Some(buffered_header) = next_page_header.take() {
+                    // The next page header has already been peeked, so just advance the offset
+                    *offset += buffered_header.compressed_page_size as usize;
+                    *remaining_bytes -= buffered_header.compressed_page_size as usize;
                 } else {
-                    *seen_num_data_pages += 1;
-                    // Notice: maybe need 'self.seen_num_values += xxx', for now we can not get skip values in skip_next_page.
-                    Ok(())
+                    let mut read = self.reader.get_read(*offset as u64)?;
+                    let (header_len, header) = read_page_header_len(&mut read)?;
+                    let data_page_size = header.compressed_page_size as usize;
+                    *offset += header_len + data_page_size;
+                    *remaining_bytes -= header_len + data_page_size;
                 }
+                Ok(())
+            }
+            SerializedPageReaderState::Pages { page_locations, .. } => {
+                page_locations.pop_front();
+
+                Ok(())
             }
         }
     }
+
+    fn at_record_boundary(&mut self) -> Result<bool> {
+        match &mut self.state {
+            SerializedPageReaderState::Values { .. } => Ok(self.peek_next_page()?.is_none()),
+            SerializedPageReaderState::Pages { .. } => Ok(true),
+        }
+    }
 }
 
 #[cfg(test)]
 mod tests {
-    use super::*;
+    use bytes::Bytes;
+    use std::sync::Arc;
+
+    use crate::format::BoundaryOrder;
+
     use crate::basic::{self, ColumnOrder};
+    use crate::column::reader::ColumnReader;
     use crate::data_type::private::ParquetValueType;
-    use crate::file::page_index::index::{ByteArrayIndex, Index, NativeIndex};
+    use crate::data_type::{AsBytes, FixedLenByteArrayType};
+    use crate::file::page_index::index::{Index, NativeIndex};
+    use crate::file::page_index::index_reader::{read_columns_indexes, read_pages_locations};
+    use crate::file::writer::SerializedFileWriter;
     use crate::record::RowAccessor;
     use crate::schema::parser::parse_message_type;
     use crate::util::bit_util::from_le_slice;
     use crate::util::test_common::file_util::{get_test_file, get_test_path};
-    use parquet_format::BoundaryOrder;
-    use std::sync::Arc;
+
+    use super::*;
 
     #[test]
     fn test_cursor_and_file_has_the_same_behaviour() {
@@ -711,7 +803,9 @@ mod tests {
         let file_iter = read_from_file.get_row_iter(None).unwrap();
         let cursor_iter = read_from_cursor.get_row_iter(None).unwrap();
 
-        assert!(file_iter.eq(cursor_iter));
+        for (a, b) in file_iter.zip(cursor_iter) {
+            assert_eq!(a.unwrap(), b.unwrap())
+        }
     }
 
     #[test]
@@ -751,38 +845,23 @@ mod tests {
     #[test]
     fn test_file_reader_into_iter() {
         let path = get_test_path("alltypes_plain.parquet");
-        let vec = vec![path.clone(), path]
-            .iter()
-            .map(|p| SerializedFileReader::try_from(p.as_path()).unwrap())
-            .flat_map(|r| r.into_iter())
-            .flat_map(|r| r.get_int(0))
-            .collect::<Vec<_>>();
-
-        // rows in the parquet file are not sorted by "id"
-        // each file contains [id:4, id:5, id:6, id:7, id:2, id:3, id:0, id:1]
-        assert_eq!(vec, vec![4, 5, 6, 7, 2, 3, 0, 1, 4, 5, 6, 7, 2, 3, 0, 1]);
+        let reader = SerializedFileReader::try_from(path.as_path()).unwrap();
+        let iter = reader.into_iter();
+        let values: Vec<_> = iter.flat_map(|x| x.unwrap().get_int(0)).collect();
+
+        assert_eq!(values, &[4, 5, 6, 7, 2, 3, 0, 1]);
     }
 
     #[test]
     fn test_file_reader_into_iter_project() {
         let path = get_test_path("alltypes_plain.parquet");
-        let result = vec![path]
-            .iter()
-            .map(|p| SerializedFileReader::try_from(p.as_path()).unwrap())
-            .flat_map(|r| {
-                let schema = "message schema { OPTIONAL INT32 id; }";
-                let proj = parse_message_type(schema).ok();
-
-                r.into_iter().project(proj).unwrap()
-            })
-            .map(|r| format!("{}", r))
-            .collect::<Vec<_>>()
-            .join(",");
+        let reader = SerializedFileReader::try_from(path.as_path()).unwrap();
+        let schema = "message schema { OPTIONAL INT32 id; }";
+        let proj = parse_message_type(schema).ok();
+        let iter = reader.into_iter().project(proj).unwrap();
+        let values: Vec<_> = iter.flat_map(|x| x.unwrap().get_int(0)).collect();
 
-        assert_eq!(
-            result,
-            "{id: 4},{id: 5},{id: 6},{id: 7},{id: 2},{id: 3},{id: 0},{id: 1}"
-        );
+        assert_eq!(values, &[4, 5, 6, 7, 2, 3, 0, 1]);
     }
 
     #[test]
@@ -884,7 +963,9 @@ mod tests {
                     assert_eq!(num_values, 8);
                     assert_eq!(encoding, Encoding::PLAIN_DICTIONARY);
                     assert_eq!(def_level_encoding, Encoding::RLE);
-                    assert_eq!(rep_level_encoding, Encoding::BIT_PACKED);
+                    #[allow(deprecated)]
+                    let expected_rep_level_encoding = Encoding::BIT_PACKED;
+                    assert_eq!(rep_level_encoding, expected_rep_level_encoding);
                     assert!(statistics.is_none());
                     true
                 }
@@ -1037,16 +1118,13 @@ mod tests {
 
         assert_eq!(metadata.len(), 3);
 
-        assert_eq!(metadata.get(0).unwrap().key, "parquet.proto.descriptor");
+        assert_eq!(metadata[0].key, "parquet.proto.descriptor");
 
-        assert_eq!(metadata.get(1).unwrap().key, "writer.model.name");
-        assert_eq!(metadata.get(1).unwrap().value, Some("protobuf".to_owned()));
+        assert_eq!(metadata[1].key, "writer.model.name");
+        assert_eq!(metadata[1].value, Some("protobuf".to_owned()));
 
-        assert_eq!(metadata.get(2).unwrap().key, "parquet.proto.class");
-        assert_eq!(
-            metadata.get(2).unwrap().value,
-            Some("foo.baz.Foobaz$Event".to_owned())
-        );
+        assert_eq!(metadata[2].key, "parquet.proto.class");
+        assert_eq!(metadata[2].value, Some("foo.baz.Foobaz$Event".to_owned()));
     }
 
     #[test]
@@ -1062,8 +1140,7 @@ mod tests {
         assert_eq!(col0_metadata.bloom_filter_offset().unwrap(), 192);
 
         // test page encoding stats
-        let page_encoding_stats =
-            col0_metadata.page_encoding_stats().unwrap().get(0).unwrap();
+        let page_encoding_stats = &col0_metadata.page_encoding_stats().unwrap()[0];
 
         assert_eq!(page_encoding_stats.page_type, basic::PageType::DATA_PAGE);
         assert_eq!(page_encoding_stats.encoding, Encoding::PLAIN);
@@ -1172,13 +1249,26 @@ mod tests {
         Ok(())
     }
 
+    #[test]
+    fn test_file_reader_invalid_metadata() {
+        let data = [
+            255, 172, 1, 0, 50, 82, 65, 73, 1, 0, 0, 0, 169, 168, 168, 162, 87, 255, 16, 0, 0, 0,
+            80, 65, 82, 49,
+        ];
+        let ret = SerializedFileReader::new(Bytes::copy_from_slice(&data));
+        assert_eq!(
+            ret.err().unwrap().to_string(),
+            "Parquet error: Could not parse metadata: bad data"
+        );
+    }
+
     #[test]
     // Use java parquet-tools get below pageIndex info
     // !```
     // parquet-tools column-index ./data_index_bloom_encoding_stats.parquet
     // row group 0:
     // column index for column String:
-    // Boudary order: ASCENDING
+    // Boundary order: ASCENDING
     // page-0  :
     // null count                 min                                  max
     // 0                          Hello                                today
@@ -1201,17 +1291,17 @@ mod tests {
         let metadata = reader.metadata();
         assert_eq!(metadata.num_row_groups(), 1);
 
-        let page_indexes = metadata.page_indexes().unwrap();
+        let column_index = metadata.column_index().unwrap();
 
         // only one row group
-        assert_eq!(page_indexes.len(), 1);
-        let index = if let Index::BYTE_ARRAY(index) = &page_indexes[0][0] {
+        assert_eq!(column_index.len(), 1);
+        let index = if let Index::BYTE_ARRAY(index) = &column_index[0][0] {
             index
         } else {
             unreachable!()
         };
 
-        assert_eq!(index.boundary_order, BoundaryOrder::Ascending);
+        assert_eq!(index.boundary_order, BoundaryOrder::ASCENDING);
         let index_in_pages = &index.indexes;
 
         //only one page group
@@ -1220,10 +1310,10 @@ mod tests {
         let page0 = &index_in_pages[0];
         let min = page0.min.as_ref().unwrap();
         let max = page0.max.as_ref().unwrap();
-        assert_eq!("Hello", std::str::from_utf8(min.as_slice()).unwrap());
-        assert_eq!("today", std::str::from_utf8(max.as_slice()).unwrap());
+        assert_eq!(b"Hello", min.as_bytes());
+        assert_eq!(b"today", max.as_bytes());
 
-        let offset_indexes = metadata.offset_indexes().unwrap();
+        let offset_indexes = metadata.offset_index().unwrap();
         // only one row group
         assert_eq!(offset_indexes.len(), 1);
         let offset_index = &offset_indexes[0];
@@ -1234,6 +1324,28 @@ mod tests {
         assert_eq!(0, page_offset.first_row_index);
     }
 
+    #[test]
+    fn test_page_index_reader_out_of_order() {
+        let test_file = get_test_file("alltypes_tiny_pages_plain.parquet");
+        let options = ReadOptionsBuilder::new().with_page_index().build();
+        let reader = SerializedFileReader::new_with_options(test_file, options).unwrap();
+        let metadata = reader.metadata();
+
+        let test_file = get_test_file("alltypes_tiny_pages_plain.parquet");
+        let columns = metadata.row_group(0).columns();
+        let reversed: Vec<_> = columns.iter().cloned().rev().collect();
+
+        let a = read_columns_indexes(&test_file, columns).unwrap();
+        let mut b = read_columns_indexes(&test_file, &reversed).unwrap();
+        b.reverse();
+        assert_eq!(a, b);
+
+        let a = read_pages_locations(&test_file, columns).unwrap();
+        let mut b = read_pages_locations(&test_file, &reversed).unwrap();
+        b.reverse();
+        assert_eq!(a, b);
+    }
+
     #[test]
     fn test_page_index_reader_all_type() {
         let test_file = get_test_file("alltypes_tiny_pages_plain.parquet");
@@ -1247,123 +1359,136 @@ mod tests {
         let metadata = reader.metadata();
         assert_eq!(metadata.num_row_groups(), 1);
 
-        let page_indexes = metadata.page_indexes().unwrap();
-        let row_group_offset_indexes = &metadata.offset_indexes().unwrap()[0];
+        let column_index = metadata.column_index().unwrap();
+        let row_group_offset_indexes = &metadata.offset_index().unwrap()[0];
 
         // only one row group
-        assert_eq!(page_indexes.len(), 1);
+        assert_eq!(column_index.len(), 1);
         let row_group_metadata = metadata.row_group(0);
 
         //col0->id: INT32 UNCOMPRESSED DO:0 FPO:4 SZ:37325/37325/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: 0, max: 7299, num_nulls: 0]
-        if let Index::INT32(index) = &page_indexes[0][0] {
+        assert!(!&column_index[0][0].is_sorted());
+        let boundary_order = &column_index[0][0].get_boundary_order();
+        assert!(boundary_order.is_some());
+        matches!(boundary_order.unwrap(), BoundaryOrder::UNORDERED);
+        if let Index::INT32(index) = &column_index[0][0] {
             check_native_page_index(
                 index,
                 325,
                 get_row_group_min_max_bytes(row_group_metadata, 0),
-                BoundaryOrder::Unordered,
+                BoundaryOrder::UNORDERED,
             );
             assert_eq!(row_group_offset_indexes[0].len(), 325);
         } else {
             unreachable!()
         };
         //col1->bool_col:BOOLEAN UNCOMPRESSED DO:0 FPO:37329 SZ:3022/3022/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: false, max: true, num_nulls: 0]
-        if let Index::BOOLEAN(index) = &page_indexes[0][1] {
+        assert!(&column_index[0][1].is_sorted());
+        if let Index::BOOLEAN(index) = &column_index[0][1] {
             assert_eq!(index.indexes.len(), 82);
             assert_eq!(row_group_offset_indexes[1].len(), 82);
         } else {
             unreachable!()
         };
         //col2->tinyint_col: INT32 UNCOMPRESSED DO:0 FPO:40351 SZ:37325/37325/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: 0, max: 9, num_nulls: 0]
-        if let Index::INT32(index) = &page_indexes[0][2] {
+        assert!(&column_index[0][2].is_sorted());
+        if let Index::INT32(index) = &column_index[0][2] {
             check_native_page_index(
                 index,
                 325,
                 get_row_group_min_max_bytes(row_group_metadata, 2),
-                BoundaryOrder::Ascending,
+                BoundaryOrder::ASCENDING,
             );
             assert_eq!(row_group_offset_indexes[2].len(), 325);
         } else {
             unreachable!()
         };
         //col4->smallint_col: INT32 UNCOMPRESSED DO:0 FPO:77676 SZ:37325/37325/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: 0, max: 9, num_nulls: 0]
-        if let Index::INT32(index) = &page_indexes[0][3] {
+        assert!(&column_index[0][3].is_sorted());
+        if let Index::INT32(index) = &column_index[0][3] {
             check_native_page_index(
                 index,
                 325,
                 get_row_group_min_max_bytes(row_group_metadata, 3),
-                BoundaryOrder::Ascending,
+                BoundaryOrder::ASCENDING,
             );
             assert_eq!(row_group_offset_indexes[3].len(), 325);
         } else {
             unreachable!()
         };
         //col5->smallint_col: INT32 UNCOMPRESSED DO:0 FPO:77676 SZ:37325/37325/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: 0, max: 9, num_nulls: 0]
-        if let Index::INT32(index) = &page_indexes[0][4] {
+        assert!(&column_index[0][4].is_sorted());
+        if let Index::INT32(index) = &column_index[0][4] {
             check_native_page_index(
                 index,
                 325,
                 get_row_group_min_max_bytes(row_group_metadata, 4),
-                BoundaryOrder::Ascending,
+                BoundaryOrder::ASCENDING,
             );
             assert_eq!(row_group_offset_indexes[4].len(), 325);
         } else {
             unreachable!()
         };
         //col6->bigint_col: INT64 UNCOMPRESSED DO:0 FPO:152326 SZ:71598/71598/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: 0, max: 90, num_nulls: 0]
-        if let Index::INT64(index) = &page_indexes[0][5] {
+        assert!(!&column_index[0][5].is_sorted());
+        if let Index::INT64(index) = &column_index[0][5] {
             check_native_page_index(
                 index,
                 528,
                 get_row_group_min_max_bytes(row_group_metadata, 5),
-                BoundaryOrder::Unordered,
+                BoundaryOrder::UNORDERED,
             );
             assert_eq!(row_group_offset_indexes[5].len(), 528);
         } else {
             unreachable!()
         };
         //col7->float_col: FLOAT UNCOMPRESSED DO:0 FPO:223924 SZ:37325/37325/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: -0.0, max: 9.9, num_nulls: 0]
-        if let Index::FLOAT(index) = &page_indexes[0][6] {
+        assert!(&column_index[0][6].is_sorted());
+        if let Index::FLOAT(index) = &column_index[0][6] {
             check_native_page_index(
                 index,
                 325,
                 get_row_group_min_max_bytes(row_group_metadata, 6),
-                BoundaryOrder::Ascending,
+                BoundaryOrder::ASCENDING,
             );
             assert_eq!(row_group_offset_indexes[6].len(), 325);
         } else {
             unreachable!()
         };
         //col8->double_col: DOUBLE UNCOMPRESSED DO:0 FPO:261249 SZ:71598/71598/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: -0.0, max: 90.89999999999999, num_nulls: 0]
-        if let Index::DOUBLE(index) = &page_indexes[0][7] {
+        assert!(!&column_index[0][7].is_sorted());
+        if let Index::DOUBLE(index) = &column_index[0][7] {
             check_native_page_index(
                 index,
                 528,
                 get_row_group_min_max_bytes(row_group_metadata, 7),
-                BoundaryOrder::Unordered,
+                BoundaryOrder::UNORDERED,
             );
             assert_eq!(row_group_offset_indexes[7].len(), 528);
         } else {
             unreachable!()
         };
         //col9->date_string_col: BINARY UNCOMPRESSED DO:0 FPO:332847 SZ:111948/111948/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: 01/01/09, max: 12/31/10, num_nulls: 0]
-        if let Index::BYTE_ARRAY(index) = &page_indexes[0][8] {
-            check_bytes_page_index(
+        assert!(!&column_index[0][8].is_sorted());
+        if let Index::BYTE_ARRAY(index) = &column_index[0][8] {
+            check_native_page_index(
                 index,
                 974,
                 get_row_group_min_max_bytes(row_group_metadata, 8),
-                BoundaryOrder::Unordered,
+                BoundaryOrder::UNORDERED,
             );
             assert_eq!(row_group_offset_indexes[8].len(), 974);
         } else {
             unreachable!()
         };
         //col10->string_col: BINARY UNCOMPRESSED DO:0 FPO:444795 SZ:45298/45298/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: 0, max: 9, num_nulls: 0]
-        if let Index::BYTE_ARRAY(index) = &page_indexes[0][9] {
-            check_bytes_page_index(
+        assert!(&column_index[0][9].is_sorted());
+        if let Index::BYTE_ARRAY(index) = &column_index[0][9] {
+            check_native_page_index(
                 index,
                 352,
                 get_row_group_min_max_bytes(row_group_metadata, 9),
-                BoundaryOrder::Ascending,
+                BoundaryOrder::ASCENDING,
             );
             assert_eq!(row_group_offset_indexes[9].len(), 352);
         } else {
@@ -1371,30 +1496,33 @@ mod tests {
         };
         //col11->timestamp_col: INT96 UNCOMPRESSED DO:0 FPO:490093 SZ:111948/111948/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[num_nulls: 0, min/max not defined]
         //Notice: min_max values for each page for this col not exits.
-        if let Index::NONE = &page_indexes[0][10] {
+        assert!(!&column_index[0][10].is_sorted());
+        if let Index::NONE = &column_index[0][10] {
             assert_eq!(row_group_offset_indexes[10].len(), 974);
         } else {
             unreachable!()
         };
         //col12->year: INT32 UNCOMPRESSED DO:0 FPO:602041 SZ:37325/37325/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: 2009, max: 2010, num_nulls: 0]
-        if let Index::INT32(index) = &page_indexes[0][11] {
+        assert!(&column_index[0][11].is_sorted());
+        if let Index::INT32(index) = &column_index[0][11] {
             check_native_page_index(
                 index,
                 325,
                 get_row_group_min_max_bytes(row_group_metadata, 11),
-                BoundaryOrder::Ascending,
+                BoundaryOrder::ASCENDING,
             );
             assert_eq!(row_group_offset_indexes[11].len(), 325);
         } else {
             unreachable!()
         };
         //col13->month: INT32 UNCOMPRESSED DO:0 FPO:639366 SZ:37325/37325/1.00 VC:7300 ENC:BIT_PACKED,RLE,PLAIN ST:[min: 1, max: 12, num_nulls: 0]
-        if let Index::INT32(index) = &page_indexes[0][12] {
+        assert!(!&column_index[0][12].is_sorted());
+        if let Index::INT32(index) = &column_index[0][12] {
             check_native_page_index(
                 index,
                 325,
                 get_row_group_min_max_bytes(row_group_metadata, 12),
-                BoundaryOrder::Unordered,
+                BoundaryOrder::UNORDERED,
             );
             assert_eq!(row_group_offset_indexes[12].len(), 325);
         } else {
@@ -1416,24 +1544,7 @@ mod tests {
         });
     }
 
-    fn check_bytes_page_index(
-        row_group_index: &ByteArrayIndex,
-        page_size: usize,
-        min_max: (&[u8], &[u8]),
-        boundary_order: BoundaryOrder,
-    ) {
-        assert_eq!(row_group_index.indexes.len(), page_size);
-        assert_eq!(row_group_index.boundary_order, boundary_order);
-        row_group_index.indexes.iter().all(|x| {
-            x.min.as_ref().unwrap().as_slice() >= min_max.0
-                && x.max.as_ref().unwrap().as_slice() <= min_max.1
-        });
-    }
-
-    fn get_row_group_min_max_bytes(
-        r: &RowGroupMetaData,
-        col_num: usize,
-    ) -> (&[u8], &[u8]) {
+    fn get_row_group_min_max_bytes(r: &RowGroupMetaData, col_num: usize) -> (&[u8], &[u8]) {
         let statistics = r.column(col_num).statistics().unwrap();
         (statistics.min_bytes(), statistics.max_bytes())
     }
@@ -1468,6 +1579,36 @@ mod tests {
         assert_eq!(vec.len(), 163);
     }
 
+    #[test]
+    fn test_skip_page_without_offset_index() {
+        let test_file = get_test_file("alltypes_tiny_pages_plain.parquet");
+
+        // use default SerializedFileReader without read offsetIndex
+        let reader_result = SerializedFileReader::new(test_file);
+        let reader = reader_result.unwrap();
+
+        let row_group_reader = reader.get_row_group(0).unwrap();
+
+        //use 'int_col', Boundary order: ASCENDING, total 325 pages.
+        let mut column_page_reader = row_group_reader.get_column_page_reader(4).unwrap();
+
+        let mut vec = vec![];
+
+        for i in 0..325 {
+            if i % 2 == 0 {
+                vec.push(column_page_reader.get_next_page().unwrap().unwrap());
+            } else {
+                column_page_reader.peek_next_page().unwrap().unwrap();
+                column_page_reader.skip_next_page().unwrap();
+            }
+        }
+        //check read all pages.
+        assert!(column_page_reader.peek_next_page().unwrap().is_none());
+        assert!(column_page_reader.get_next_page().unwrap().is_none());
+
+        assert_eq!(vec.len(), 163);
+    }
+
     #[test]
     fn test_peek_page_with_dictionary_page() {
         let test_file = get_test_file("alltypes_tiny_pages.parquet");
@@ -1493,11 +1634,11 @@ mod tests {
             // have checked with `parquet-tools column-index   -c string_col  ./alltypes_tiny_pages.parquet`
             // page meta has two scenarios(21, 20) of num_rows expect last page has 11 rows.
             if i != 351 {
-                assert!((meta.num_rows == 21) || (meta.num_rows == 20));
+                assert!((meta.num_rows == Some(21)) || (meta.num_rows == Some(20)));
             } else {
                 // last page first row index is 7290, total row count is 7300
                 // because first row start with zero, last page row count should be 10.
-                assert_eq!(meta.num_rows, 10);
+                assert_eq!(meta.num_rows, Some(10));
             }
             assert!(!meta.is_dict);
             vec.push(meta);
@@ -1511,4 +1652,119 @@ mod tests {
 
         assert_eq!(vec.len(), 352);
     }
+
+    #[test]
+    fn test_peek_page_with_dictionary_page_without_offset_index() {
+        let test_file = get_test_file("alltypes_tiny_pages.parquet");
+
+        let reader_result = SerializedFileReader::new(test_file);
+        let reader = reader_result.unwrap();
+        let row_group_reader = reader.get_row_group(0).unwrap();
+
+        //use 'string_col', Boundary order: UNORDERED, total 352 data ages and 1 dictionary page.
+        let mut column_page_reader = row_group_reader.get_column_page_reader(9).unwrap();
+
+        let mut vec = vec![];
+
+        let meta = column_page_reader.peek_next_page().unwrap().unwrap();
+        assert!(meta.is_dict);
+        let page = column_page_reader.get_next_page().unwrap().unwrap();
+        assert!(matches!(page.page_type(), basic::PageType::DICTIONARY_PAGE));
+
+        for i in 0..352 {
+            let meta = column_page_reader.peek_next_page().unwrap().unwrap();
+            // have checked with `parquet-tools column-index   -c string_col  ./alltypes_tiny_pages.parquet`
+            // page meta has two scenarios(21, 20) of num_rows expect last page has 11 rows.
+            if i != 351 {
+                assert!((meta.num_levels == Some(21)) || (meta.num_levels == Some(20)));
+            } else {
+                // last page first row index is 7290, total row count is 7300
+                // because first row start with zero, last page row count should be 10.
+                assert_eq!(meta.num_levels, Some(10));
+            }
+            assert!(!meta.is_dict);
+            vec.push(meta);
+            let page = column_page_reader.get_next_page().unwrap().unwrap();
+            assert!(matches!(page.page_type(), basic::PageType::DATA_PAGE));
+        }
+
+        //check read all pages.
+        assert!(column_page_reader.peek_next_page().unwrap().is_none());
+        assert!(column_page_reader.get_next_page().unwrap().is_none());
+
+        assert_eq!(vec.len(), 352);
+    }
+
+    #[test]
+    fn test_fixed_length_index() {
+        let message_type = "
+        message test_schema {
+          OPTIONAL FIXED_LEN_BYTE_ARRAY (11) value (DECIMAL(25,2));
+        }
+        ";
+
+        let schema = parse_message_type(message_type).unwrap();
+        let mut out = Vec::with_capacity(1024);
+        let mut writer =
+            SerializedFileWriter::new(&mut out, Arc::new(schema), Default::default()).unwrap();
+
+        let mut r = writer.next_row_group().unwrap();
+        let mut c = r.next_column().unwrap().unwrap();
+        c.typed::<FixedLenByteArrayType>()
+            .write_batch(
+                &[vec![0; 11].into(), vec![5; 11].into(), vec![3; 11].into()],
+                Some(&[1, 1, 0, 1]),
+                None,
+            )
+            .unwrap();
+        c.close().unwrap();
+        r.close().unwrap();
+        writer.close().unwrap();
+
+        let b = Bytes::from(out);
+        let options = ReadOptionsBuilder::new().with_page_index().build();
+        let reader = SerializedFileReader::new_with_options(b, options).unwrap();
+        let index = reader.metadata().column_index().unwrap();
+
+        // 1 row group
+        assert_eq!(index.len(), 1);
+        let c = &index[0];
+        // 1 column
+        assert_eq!(c.len(), 1);
+
+        match &c[0] {
+            Index::FIXED_LEN_BYTE_ARRAY(v) => {
+                assert_eq!(v.indexes.len(), 1);
+                let page_idx = &v.indexes[0];
+                assert_eq!(page_idx.null_count.unwrap(), 1);
+                assert_eq!(page_idx.min.as_ref().unwrap().as_ref(), &[0; 11]);
+                assert_eq!(page_idx.max.as_ref().unwrap().as_ref(), &[5; 11]);
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[test]
+    fn test_multi_gz() {
+        let file = get_test_file("concatenated_gzip_members.parquet");
+        let reader = SerializedFileReader::new(file).unwrap();
+        let row_group_reader = reader.get_row_group(0).unwrap();
+        match row_group_reader.get_column_reader(0).unwrap() {
+            ColumnReader::Int64ColumnReader(mut reader) => {
+                let mut buffer = Vec::with_capacity(1024);
+                let mut def_levels = Vec::with_capacity(1024);
+                let (num_records, num_values, num_levels) = reader
+                    .read_records(1024, Some(&mut def_levels), None, &mut buffer)
+                    .unwrap();
+
+                assert_eq!(num_records, 513);
+                assert_eq!(num_values, 513);
+                assert_eq!(num_levels, 513);
+
+                let expected: Vec<i64> = (1..514).collect();
+                assert_eq!(&buffer, &expected);
+            }
+            _ => unreachable!(),
+        }
+    }
 }
diff --git a/parquet/src/file/statistics.rs b/parquet/src/file/statistics.rs
index 5d1a01df8a6c..1bc003d48854 100644
--- a/parquet/src/file/statistics.rs
+++ b/parquet/src/file/statistics.rs
@@ -27,6 +27,8 @@
 //! assert_eq!(stats.null_count(), 3);
 //! assert!(stats.has_min_max_set());
 //! assert!(stats.is_min_max_deprecated());
+//! assert!(stats.min_is_exact());
+//! assert!(stats.max_is_exact());
 //!
 //! match stats {
 //!     Statistics::Int32(ref typed) => {
@@ -39,13 +41,13 @@
 
 use std::fmt;
 
-use byteorder::{ByteOrder, LittleEndian};
-use parquet_format::Statistics as TStatistics;
+use crate::format::Statistics as TStatistics;
 
 use crate::basic::Type;
 use crate::data_type::private::ParquetValueType;
 use crate::data_type::*;
-use crate::util::bit_util::from_ne_slice;
+use crate::errors::{ParquetError, Result};
+use crate::util::bit_util::from_le_slice;
 
 pub(crate) mod private {
     use super::*;
@@ -120,16 +122,18 @@ macro_rules! statistics_enum_func {
 pub fn from_thrift(
     physical_type: Type,
     thrift_stats: Option<TStatistics>,
-) -> Option<Statistics> {
-    match thrift_stats {
+) -> Result<Option<Statistics>> {
+    Ok(match thrift_stats {
         Some(stats) => {
             // Number of nulls recorded, when it is not available, we just mark it as 0.
             let null_count = stats.null_count.unwrap_or(0);
-            assert!(
-                null_count >= 0,
-                "Statistics null count is negative ({})",
-                null_count
-            );
+
+            if null_count < 0 {
+                return Err(ParquetError::General(format!(
+                    "Statistics null count is negative {}",
+                    null_count
+                )));
+            }
 
             // Generic null count.
             let null_count = null_count as u64;
@@ -163,15 +167,15 @@ pub fn from_thrift(
                     old_format,
                 ),
                 Type::INT32 => Statistics::int32(
-                    min.map(|data| LittleEndian::read_i32(&data)),
-                    max.map(|data| LittleEndian::read_i32(&data)),
+                    min.map(|data| i32::from_le_bytes(data[..4].try_into().unwrap())),
+                    max.map(|data| i32::from_le_bytes(data[..4].try_into().unwrap())),
                     distinct_count,
                     null_count,
                     old_format,
                 ),
                 Type::INT64 => Statistics::int64(
-                    min.map(|data| LittleEndian::read_i64(&data)),
-                    max.map(|data| LittleEndian::read_i64(&data)),
+                    min.map(|data| i64::from_le_bytes(data[..8].try_into().unwrap())),
+                    max.map(|data| i64::from_le_bytes(data[..8].try_into().unwrap())),
                     distinct_count,
                     null_count,
                     old_format,
@@ -182,48 +186,56 @@ pub fn from_thrift(
                     // min/max statistics for INT96 columns.
                     let min = min.map(|data| {
                         assert_eq!(data.len(), 12);
-                        from_ne_slice::<Int96>(&data)
+                        from_le_slice::<Int96>(&data)
                     });
                     let max = max.map(|data| {
                         assert_eq!(data.len(), 12);
-                        from_ne_slice::<Int96>(&data)
+                        from_le_slice::<Int96>(&data)
                     });
                     Statistics::int96(min, max, distinct_count, null_count, old_format)
                 }
                 Type::FLOAT => Statistics::float(
-                    min.map(|data| LittleEndian::read_f32(&data)),
-                    max.map(|data| LittleEndian::read_f32(&data)),
+                    min.map(|data| f32::from_le_bytes(data[..4].try_into().unwrap())),
+                    max.map(|data| f32::from_le_bytes(data[..4].try_into().unwrap())),
                     distinct_count,
                     null_count,
                     old_format,
                 ),
                 Type::DOUBLE => Statistics::double(
-                    min.map(|data| LittleEndian::read_f64(&data)),
-                    max.map(|data| LittleEndian::read_f64(&data)),
+                    min.map(|data| f64::from_le_bytes(data[..8].try_into().unwrap())),
+                    max.map(|data| f64::from_le_bytes(data[..8].try_into().unwrap())),
                     distinct_count,
                     null_count,
                     old_format,
                 ),
-                Type::BYTE_ARRAY => Statistics::byte_array(
-                    min.map(ByteArray::from),
-                    max.map(ByteArray::from),
-                    distinct_count,
-                    null_count,
-                    old_format,
+                Type::BYTE_ARRAY => Statistics::ByteArray(
+                    ValueStatistics::new(
+                        min.map(ByteArray::from),
+                        max.map(ByteArray::from),
+                        distinct_count,
+                        null_count,
+                        old_format,
+                    )
+                    .with_max_is_exact(stats.is_max_value_exact.unwrap_or(false))
+                    .with_min_is_exact(stats.is_min_value_exact.unwrap_or(false)),
                 ),
-                Type::FIXED_LEN_BYTE_ARRAY => Statistics::fixed_len_byte_array(
-                    min.map(ByteArray::from).map(FixedLenByteArray::from),
-                    max.map(ByteArray::from).map(FixedLenByteArray::from),
-                    distinct_count,
-                    null_count,
-                    old_format,
+                Type::FIXED_LEN_BYTE_ARRAY => Statistics::FixedLenByteArray(
+                    ValueStatistics::new(
+                        min.map(ByteArray::from).map(FixedLenByteArray::from),
+                        max.map(ByteArray::from).map(FixedLenByteArray::from),
+                        distinct_count,
+                        null_count,
+                        old_format,
+                    )
+                    .with_max_is_exact(stats.is_max_value_exact.unwrap_or(false))
+                    .with_min_is_exact(stats.is_min_value_exact.unwrap_or(false)),
                 ),
             };
 
             Some(res)
         }
         None => None,
-    }
+    })
 }
 
 // Convert Statistics into Thrift definition.
@@ -241,26 +253,36 @@ pub fn to_thrift(stats: Option<&Statistics>) -> Option<TStatistics> {
         distinct_count: stats.distinct_count().map(|value| value as i64),
         max_value: None,
         min_value: None,
+        is_max_value_exact: None,
+        is_min_value_exact: None,
     };
 
     // Get min/max if set.
-    let (min, max) = if stats.has_min_max_set() {
+    let (min, max, min_exact, max_exact) = if stats.has_min_max_set() {
         (
             Some(stats.min_bytes().to_vec()),
             Some(stats.max_bytes().to_vec()),
+            Some(stats.min_is_exact()),
+            Some(stats.max_is_exact()),
         )
     } else {
-        (None, None)
+        (None, None, None, None)
     };
 
-    if stats.is_min_max_deprecated() {
-        thrift_stats.min = min;
-        thrift_stats.max = max;
-    } else {
+    if stats.is_min_max_backwards_compatible() {
+        // Copy to deprecated min, max values for compatibility with older readers
+        thrift_stats.min = min.clone();
+        thrift_stats.max = max.clone();
+    }
+
+    if !stats.is_min_max_deprecated() {
         thrift_stats.min_value = min;
         thrift_stats.max_value = max;
     }
 
+    thrift_stats.is_min_value_exact = min_exact;
+    thrift_stats.is_max_value_exact = max_exact;
+
     Some(thrift_stats)
 }
 
@@ -330,6 +352,20 @@ impl Statistics {
         statistics_enum_func![self, is_min_max_deprecated]
     }
 
+    /// Old versions of parquet stored statistics in `min` and `max` fields, ordered
+    /// using signed comparison. This resulted in an undefined ordering for unsigned
+    /// quantities, such as booleans and unsigned integers.
+    ///
+    /// These fields were therefore deprecated in favour of `min_value` and `max_value`,
+    /// which have a type-defined sort order.
+    ///
+    /// However, not all readers have been updated. For backwards compatibility, this method
+    /// returns `true` if the statistics within this have a signed sort order, that is
+    /// compatible with being stored in the deprecated `min` and `max` fields
+    pub fn is_min_max_backwards_compatible(&self) -> bool {
+        statistics_enum_func![self, is_min_max_backwards_compatible]
+    }
+
     /// Returns optional value of number of distinct values occurring.
     /// When it is `None`, the value should be ignored.
     pub fn distinct_count(&self) -> Option<u64> {
@@ -353,6 +389,16 @@ impl Statistics {
         statistics_enum_func![self, has_min_max_set]
     }
 
+    /// Returns `true` if the min value is set, and is an exact min value.
+    pub fn min_is_exact(&self) -> bool {
+        statistics_enum_func![self, min_is_exact]
+    }
+
+    /// Returns `true` if the max value is set, and is an exact max value.
+    pub fn max_is_exact(&self) -> bool {
+        statistics_enum_func![self, max_is_exact]
+    }
+
     /// Returns slice of bytes that represent min value.
     /// Panics if min value is not set.
     pub fn min_bytes(&self) -> &[u8] {
@@ -383,14 +429,14 @@ impl Statistics {
 impl fmt::Display for Statistics {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
-            Statistics::Boolean(typed) => write!(f, "{}", typed),
-            Statistics::Int32(typed) => write!(f, "{}", typed),
-            Statistics::Int64(typed) => write!(f, "{}", typed),
-            Statistics::Int96(typed) => write!(f, "{}", typed),
-            Statistics::Float(typed) => write!(f, "{}", typed),
-            Statistics::Double(typed) => write!(f, "{}", typed),
-            Statistics::ByteArray(typed) => write!(f, "{}", typed),
-            Statistics::FixedLenByteArray(typed) => write!(f, "{}", typed),
+            Statistics::Boolean(typed) => write!(f, "{typed}"),
+            Statistics::Int32(typed) => write!(f, "{typed}"),
+            Statistics::Int64(typed) => write!(f, "{typed}"),
+            Statistics::Int96(typed) => write!(f, "{typed}"),
+            Statistics::Float(typed) => write!(f, "{typed}"),
+            Statistics::Double(typed) => write!(f, "{typed}"),
+            Statistics::ByteArray(typed) => write!(f, "{typed}"),
+            Statistics::FixedLenByteArray(typed) => write!(f, "{typed}"),
         }
     }
 }
@@ -406,7 +452,18 @@ pub struct ValueStatistics<T> {
     // Distinct count could be omitted in some cases
     distinct_count: Option<u64>,
     null_count: u64,
+
+    // Whether or not the min or max values are exact, or truncated.
+    is_max_value_exact: bool,
+    is_min_value_exact: bool,
+
+    /// If `true` populate the deprecated `min` and `max` fields instead of
+    /// `min_value` and `max_value`
     is_min_max_deprecated: bool,
+
+    /// If `true` the statistics are compatible with the deprecated `min` and
+    /// `max` fields. See [`ValueStatistics::is_min_max_backwards_compatible`]
+    is_min_max_backwards_compatible: bool,
 }
 
 impl<T: ParquetValueType> ValueStatistics<T> {
@@ -419,11 +476,48 @@ impl<T: ParquetValueType> ValueStatistics<T> {
         is_min_max_deprecated: bool,
     ) -> Self {
         Self {
+            is_max_value_exact: max.is_some(),
+            is_min_value_exact: min.is_some(),
             min,
             max,
             distinct_count,
             null_count,
             is_min_max_deprecated,
+            is_min_max_backwards_compatible: is_min_max_deprecated,
+        }
+    }
+
+    /// Set whether the stored `min` field represents the exact
+    /// minimum, or just a bound on the minimum value.
+    ///
+    /// see [`Self::min_is_exact`]
+    pub fn with_min_is_exact(self, is_min_value_exact: bool) -> Self {
+        Self {
+            is_min_value_exact,
+            ..self
+        }
+    }
+
+    /// Set whether the stored `max` field represents the exact
+    /// maximum, or just a bound on the maximum value.
+    ///
+    /// see [`Self::max_is_exact`]
+    pub fn with_max_is_exact(self, is_max_value_exact: bool) -> Self {
+        Self {
+            is_max_value_exact,
+            ..self
+        }
+    }
+
+    /// Set whether to write the deprecated `min` and `max` fields
+    /// for compatibility with older parquet writers
+    ///
+    /// This should only be enabled if the field is signed,
+    /// see [`Self::is_min_max_backwards_compatible`]
+    pub fn with_backwards_compatible_min_max(self, backwards_compatible: bool) -> Self {
+        Self {
+            is_min_max_backwards_compatible: backwards_compatible,
+            ..self
         }
     }
 
@@ -465,13 +559,23 @@ impl<T: ParquetValueType> ValueStatistics<T> {
         self.min.is_some() && self.max.is_some()
     }
 
+    /// Whether or not max value is set, and is an exact value.
+    pub fn max_is_exact(&self) -> bool {
+        self.max.is_some() && self.is_max_value_exact
+    }
+
+    /// Whether or not min value is set, and is an exact value.
+    pub fn min_is_exact(&self) -> bool {
+        self.min.is_some() && self.is_min_value_exact
+    }
+
     /// Returns optional value of number of distinct values occurring.
-    fn distinct_count(&self) -> Option<u64> {
+    pub fn distinct_count(&self) -> Option<u64> {
         self.distinct_count
     }
 
     /// Returns null count.
-    fn null_count(&self) -> u64 {
+    pub fn null_count(&self) -> u64 {
         self.null_count
     }
 
@@ -479,6 +583,20 @@ impl<T: ParquetValueType> ValueStatistics<T> {
     fn is_min_max_deprecated(&self) -> bool {
         self.is_min_max_deprecated
     }
+
+    /// Old versions of parquet stored statistics in `min` and `max` fields, ordered
+    /// using signed comparison. This resulted in an undefined ordering for unsigned
+    /// quantities, such as booleans and unsigned integers.
+    ///
+    /// These fields were therefore deprecated in favour of `min_value` and `max_value`,
+    /// which have a type-defined sort order.
+    ///
+    /// However, not all readers have been updated. For backwards compatibility, this method
+    /// returns `true` if the statistics within this have a signed sort order, that is
+    /// compatible with being stored in the deprecated `min` and `max` fields
+    pub fn is_min_max_backwards_compatible(&self) -> bool {
+        self.is_min_max_backwards_compatible
+    }
 }
 
 impl<T: ParquetValueType> fmt::Display for ValueStatistics<T> {
@@ -486,21 +604,23 @@ impl<T: ParquetValueType> fmt::Display for ValueStatistics<T> {
         write!(f, "{{")?;
         write!(f, "min: ")?;
         match self.min {
-            Some(ref value) => write!(f, "{}", value)?,
+            Some(ref value) => write!(f, "{value}")?,
             None => write!(f, "N/A")?,
         }
         write!(f, ", max: ")?;
         match self.max {
-            Some(ref value) => write!(f, "{}", value)?,
+            Some(ref value) => write!(f, "{value}")?,
             None => write!(f, "N/A")?,
         }
         write!(f, ", distinct_count: ")?;
         match self.distinct_count {
-            Some(value) => write!(f, "{}", value)?,
+            Some(value) => write!(f, "{value}")?,
             None => write!(f, "N/A")?,
         }
         write!(f, ", null_count: {}", self.null_count)?;
         write!(f, ", min_max_deprecated: {}", self.is_min_max_deprecated)?;
+        write!(f, ", max_value_exact: {}", self.is_max_value_exact)?;
+        write!(f, ", min_value_exact: {}", self.is_min_value_exact)?;
         write!(f, "}}")
     }
 }
@@ -510,12 +630,15 @@ impl<T: ParquetValueType> fmt::Debug for ValueStatistics<T> {
         write!(
             f,
             "{{min: {:?}, max: {:?}, distinct_count: {:?}, null_count: {}, \
-             min_max_deprecated: {}}}",
+             min_max_deprecated: {}, min_max_backwards_compatible: {}, max_value_exact: {}, min_value_exact: {}}}",
             self.min,
             self.max,
             self.distinct_count,
             self.null_count,
-            self.is_min_max_deprecated
+            self.is_min_max_deprecated,
+            self.is_min_max_backwards_compatible,
+            self.is_max_value_exact,
+            self.is_min_value_exact
         )
     }
 }
@@ -544,7 +667,7 @@ mod tests {
     }
 
     #[test]
-    #[should_panic(expected = "Statistics null count is negative (-10)")]
+    #[should_panic(expected = "General(\"Statistics null count is negative -10\")")]
     fn test_statistics_negative_null_count() {
         let thrift_stats = TStatistics {
             max: None,
@@ -553,31 +676,33 @@ mod tests {
             distinct_count: None,
             max_value: None,
             min_value: None,
+            is_max_value_exact: None,
+            is_min_value_exact: None,
         };
 
-        from_thrift(Type::INT32, Some(thrift_stats));
+        from_thrift(Type::INT32, Some(thrift_stats)).unwrap();
     }
 
     #[test]
     fn test_statistics_thrift_none() {
-        assert_eq!(from_thrift(Type::INT32, None), None);
-        assert_eq!(from_thrift(Type::BYTE_ARRAY, None), None);
+        assert_eq!(from_thrift(Type::INT32, None).unwrap(), None);
+        assert_eq!(from_thrift(Type::BYTE_ARRAY, None).unwrap(), None);
     }
 
     #[test]
     fn test_statistics_debug() {
         let stats = Statistics::int32(Some(1), Some(12), None, 12, true);
         assert_eq!(
-            format!("{:?}", stats),
+            format!("{stats:?}"),
             "Int32({min: Some(1), max: Some(12), distinct_count: None, null_count: 12, \
-             min_max_deprecated: true})"
+             min_max_deprecated: true, min_max_backwards_compatible: true, max_value_exact: true, min_value_exact: true})"
         );
 
         let stats = Statistics::int32(None, None, None, 7, false);
         assert_eq!(
-            format!("{:?}", stats),
+            format!("{stats:?}"),
             "Int32({min: None, max: None, distinct_count: None, null_count: 7, \
-             min_max_deprecated: false})"
+             min_max_deprecated: false, min_max_backwards_compatible: false, max_value_exact: false, min_value_exact: false})"
         )
     }
 
@@ -585,15 +710,15 @@ mod tests {
     fn test_statistics_display() {
         let stats = Statistics::int32(Some(1), Some(12), None, 12, true);
         assert_eq!(
-            format!("{}", stats),
-            "{min: 1, max: 12, distinct_count: N/A, null_count: 12, min_max_deprecated: true}"
+            format!("{stats}"),
+            "{min: 1, max: 12, distinct_count: N/A, null_count: 12, min_max_deprecated: true, max_value_exact: true, min_value_exact: true}"
         );
 
         let stats = Statistics::int64(None, None, None, 7, false);
         assert_eq!(
-            format!("{}", stats),
+            format!("{stats}"),
             "{min: N/A, max: N/A, distinct_count: N/A, null_count: 7, min_max_deprecated: \
-             false}"
+             false, max_value_exact: false, min_value_exact: false}"
         );
 
         let stats = Statistics::int96(
@@ -604,21 +729,25 @@ mod tests {
             true,
         );
         assert_eq!(
-            format!("{}", stats),
+            format!("{stats}"),
             "{min: [1, 0, 0], max: [2, 3, 4], distinct_count: N/A, null_count: 3, \
-             min_max_deprecated: true}"
+             min_max_deprecated: true, max_value_exact: true, min_value_exact: true}"
         );
 
-        let stats = Statistics::byte_array(
-            Some(ByteArray::from(vec![1u8])),
-            Some(ByteArray::from(vec![2u8])),
-            Some(5),
-            7,
-            false,
+        let stats = Statistics::ByteArray(
+            ValueStatistics::new(
+                Some(ByteArray::from(vec![1u8])),
+                Some(ByteArray::from(vec![2u8])),
+                Some(5),
+                7,
+                false,
+            )
+            .with_max_is_exact(false)
+            .with_min_is_exact(false),
         );
         assert_eq!(
-            format!("{}", stats),
-            "{min: [1], max: [2], distinct_count: 5, null_count: 7, min_max_deprecated: false}"
+            format!("{stats}"),
+            "{min: [1], max: [2], distinct_count: 5, null_count: 7, min_max_deprecated: false, max_value_exact: false, min_value_exact: false}"
         );
     }
 
@@ -654,7 +783,45 @@ mod tests {
                 Some(ByteArray::from(vec![1, 2, 3]).into()),
                 None,
                 0,
-                true
+                true,
+            )
+        );
+
+        assert!(
+            Statistics::byte_array(
+                Some(ByteArray::from(vec![1, 2, 3])),
+                Some(ByteArray::from(vec![1, 2, 3])),
+                None,
+                0,
+                true,
+            ) != Statistics::ByteArray(
+                ValueStatistics::new(
+                    Some(ByteArray::from(vec![1, 2, 3])),
+                    Some(ByteArray::from(vec![1, 2, 3])),
+                    None,
+                    0,
+                    true,
+                )
+                .with_max_is_exact(false)
+            )
+        );
+
+        assert!(
+            Statistics::fixed_len_byte_array(
+                Some(FixedLenByteArray::from(vec![1, 2, 3])),
+                Some(FixedLenByteArray::from(vec![1, 2, 3])),
+                None,
+                0,
+                true,
+            ) != Statistics::FixedLenByteArray(
+                ValueStatistics::new(
+                    Some(FixedLenByteArray::from(vec![1, 2, 3])),
+                    Some(FixedLenByteArray::from(vec![1, 2, 3])),
+                    None,
+                    0,
+                    true,
+                )
+                .with_min_is_exact(false)
             )
         );
     }
@@ -665,7 +832,7 @@ mod tests {
         fn check_stats(stats: Statistics) {
             let tpe = stats.physical_type();
             let thrift_stats = to_thrift(Some(&stats));
-            assert_eq!(from_thrift(tpe, thrift_stats), Some(stats));
+            assert_eq!(from_thrift(tpe, thrift_stats).unwrap(), Some(stats));
         }
 
         check_stats(Statistics::boolean(Some(false), Some(true), None, 7, true));
diff --git a/parquet/src/file/writer.rs b/parquet/src/file/writer.rs
index 863ccf85468d..e15a7195028f 100644
--- a/parquet/src/file/writer.rs
+++ b/parquet/src/file/writer.rs
@@ -18,41 +18,40 @@
 //! Contains file writer API, and provides methods to write row groups and columns by
 //! using row group writers and column writers respectively.
 
+use crate::bloom_filter::Sbbf;
+use crate::format as parquet;
+use crate::format::{ColumnIndex, OffsetIndex, RowGroup};
+use crate::thrift::TSerializable;
+use std::fmt::Debug;
+use std::io::{BufWriter, IoSlice, Read};
 use std::{io::Write, sync::Arc};
+use thrift::protocol::TCompactOutputProtocol;
 
-use byteorder::{ByteOrder, LittleEndian};
-use parquet_format as parquet;
-use parquet_format::{ColumnIndex, OffsetIndex, RowGroup};
-use thrift::protocol::{TCompactOutputProtocol, TOutputProtocol};
-
-use crate::basic::PageType;
-use crate::column::writer::{get_typed_column_writer_mut, ColumnWriterImpl};
+use crate::column::writer::{get_typed_column_writer_mut, ColumnCloseResult, ColumnWriterImpl};
 use crate::column::{
-    page::{CompressedPage, Page, PageWriteSpec, PageWriter},
+    page::{CompressedPage, PageWriteSpec, PageWriter},
     writer::{get_column_writer, ColumnWriter},
 };
 use crate::data_type::DataType;
 use crate::errors::{ParquetError, Result};
-use crate::file::{
-    metadata::*, properties::WriterPropertiesPtr,
-    statistics::to_thrift as statistics_to_thrift, FOOTER_SIZE, PARQUET_MAGIC,
-};
-use crate::schema::types::{
-    self, ColumnDescPtr, SchemaDescPtr, SchemaDescriptor, TypePtr,
-};
+use crate::file::reader::ChunkReader;
+use crate::file::{metadata::*, properties::WriterPropertiesPtr, PARQUET_MAGIC};
+use crate::schema::types::{self, ColumnDescPtr, SchemaDescPtr, SchemaDescriptor, TypePtr};
 
 /// A wrapper around a [`Write`] that keeps track of the number
-/// of bytes that have been written
-pub struct TrackedWrite<W> {
-    inner: W,
+/// of bytes that have been written. The given [`Write`] is wrapped
+/// with a [`BufWriter`] to optimize writing performance.
+pub struct TrackedWrite<W: Write> {
+    inner: BufWriter<W>,
     bytes_written: usize,
 }
 
 impl<W: Write> TrackedWrite<W> {
     /// Create a new [`TrackedWrite`] from a [`Write`]
     pub fn new(inner: W) -> Self {
+        let buf_write = BufWriter::new(inner);
         Self {
-            inner,
+            inner: buf_write,
             bytes_written: 0,
         }
     }
@@ -61,6 +60,13 @@ impl<W: Write> TrackedWrite<W> {
     pub fn bytes_written(&self) -> usize {
         self.bytes_written
     }
+
+    /// Returns the underlying writer.
+    pub fn into_inner(self) -> Result<W> {
+        self.inner.into_inner().map_err(|err| {
+            ParquetError::General(format!("fail to get inner writer: {:?}", err.to_string()))
+        })
+    }
 }
 
 impl<W: Write> Write for TrackedWrite<W> {
@@ -70,29 +76,26 @@ impl<W: Write> Write for TrackedWrite<W> {
         Ok(bytes)
     }
 
+    fn write_vectored(&mut self, bufs: &[IoSlice<'_>]) -> std::io::Result<usize> {
+        let bytes = self.inner.write_vectored(bufs)?;
+        self.bytes_written += bytes;
+        Ok(bytes)
+    }
+
+    fn write_all(&mut self, buf: &[u8]) -> std::io::Result<()> {
+        self.inner.write_all(buf)?;
+        self.bytes_written += buf.len();
+
+        Ok(())
+    }
+
     fn flush(&mut self) -> std::io::Result<()> {
         self.inner.flush()
     }
 }
 
-/// Callback invoked on closing a column chunk, arguments are:
-///
-/// - the number of bytes written
-/// - the number of rows written
-/// - the column chunk metadata
-/// - the column index
-/// - the offset index
-///
-pub type OnCloseColumnChunk<'a> = Box<
-    dyn FnOnce(
-            u64,
-            u64,
-            ColumnChunkMetaData,
-            Option<ColumnIndex>,
-            Option<OffsetIndex>,
-        ) -> Result<()>
-        + 'a,
->;
+/// Callback invoked on closing a column chunk
+pub type OnCloseColumnChunk<'a> = Box<dyn FnOnce(ColumnCloseResult) -> Result<()> + 'a>;
 
 /// Callback invoked on closing a row group, arguments are:
 ///
@@ -102,10 +105,12 @@ pub type OnCloseColumnChunk<'a> = Box<
 pub type OnCloseRowGroup<'a> = Box<
     dyn FnOnce(
             RowGroupMetaDataPtr,
+            Vec<Option<Sbbf>>,
             Vec<Option<ColumnIndex>>,
             Vec<Option<OffsetIndex>>,
         ) -> Result<()>
-        + 'a,
+        + 'a
+        + Send,
 >;
 
 // ----------------------------------------------------------------------
@@ -126,12 +131,27 @@ pub struct SerializedFileWriter<W: Write> {
     descr: SchemaDescPtr,
     props: WriterPropertiesPtr,
     row_groups: Vec<RowGroupMetaDataPtr>,
+    bloom_filters: Vec<Vec<Option<Sbbf>>>,
     column_indexes: Vec<Vec<Option<ColumnIndex>>>,
     offset_indexes: Vec<Vec<Option<OffsetIndex>>>,
     row_group_index: usize,
+    // kv_metadatas will be appended to `props` when `write_metadata`
+    kv_metadatas: Vec<KeyValue>,
+}
+
+impl<W: Write> Debug for SerializedFileWriter<W> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // implement Debug so this can be used with #[derive(Debug)]
+        // in client code rather than actually listing all the fields
+        f.debug_struct("SerializedFileWriter")
+            .field("descr", &self.descr)
+            .field("row_group_index", &self.row_group_index)
+            .field("kv_metadatas", &self.kv_metadatas)
+            .finish_non_exhaustive()
+    }
 }
 
-impl<W: Write> SerializedFileWriter<W> {
+impl<W: Write + Send> SerializedFileWriter<W> {
     /// Creates new file writer.
     pub fn new(buf: W, schema: TypePtr, properties: WriterPropertiesPtr) -> Result<Self> {
         let mut buf = TrackedWrite::new(buf);
@@ -142,9 +162,11 @@ impl<W: Write> SerializedFileWriter<W> {
             descr: Arc::new(SchemaDescriptor::new(schema)),
             props: properties,
             row_groups: vec![],
+            bloom_filters: vec![],
             column_indexes: Vec::new(),
             offset_indexes: Vec::new(),
             row_group_index: 0,
+            kv_metadatas: Vec::new(),
         })
     }
 
@@ -156,22 +178,28 @@ impl<W: Write> SerializedFileWriter<W> {
     /// previous row group must be finalised and closed using `RowGroupWriter::close` method.
     pub fn next_row_group(&mut self) -> Result<SerializedRowGroupWriter<'_, W>> {
         self.assert_previous_writer_closed()?;
+        let ordinal = self.row_group_index;
+
         self.row_group_index += 1;
 
         let row_groups = &mut self.row_groups;
+        let row_bloom_filters = &mut self.bloom_filters;
         let row_column_indexes = &mut self.column_indexes;
         let row_offset_indexes = &mut self.offset_indexes;
-        let on_close = |metadata, row_group_column_index, row_group_offset_index| {
-            row_groups.push(metadata);
-            row_column_indexes.push(row_group_column_index);
-            row_offset_indexes.push(row_group_offset_index);
-            Ok(())
-        };
+        let on_close =
+            |metadata, row_group_bloom_filter, row_group_column_index, row_group_offset_index| {
+                row_groups.push(metadata);
+                row_bloom_filters.push(row_group_bloom_filter);
+                row_column_indexes.push(row_group_column_index);
+                row_offset_indexes.push(row_group_offset_index);
+                Ok(())
+            };
 
         let row_group_writer = SerializedRowGroupWriter::new(
             self.descr.clone(),
             self.props.clone(),
             &mut self.buf,
+            ordinal as i16,
             Some(Box::new(on_close)),
         );
         Ok(row_group_writer)
@@ -183,12 +211,6 @@ impl<W: Write> SerializedFileWriter<W> {
     }
 
     /// Closes and finalises file writer, returning the file metadata.
-    ///
-    /// All row groups must be appended before this method is called.
-    /// No writes are allowed after this point.
-    ///
-    /// Can be called multiple times. It is up to implementation to either result in
-    /// no-op, or return an `Err` for subsequent calls.
     pub fn close(mut self) -> Result<parquet::FileMetaData> {
         self.assert_previous_writer_closed()?;
         let metadata = self.write_metadata()?;
@@ -207,14 +229,12 @@ impl<W: Write> SerializedFileWriter<W> {
         // iter each column
         // write offset index to the file
         for (row_group_idx, row_group) in row_groups.iter_mut().enumerate() {
-            for (column_idx, column_metadata) in row_group.columns.iter_mut().enumerate()
-            {
+            for (column_idx, column_metadata) in row_group.columns.iter_mut().enumerate() {
                 match &self.offset_indexes[row_group_idx][column_idx] {
                     Some(offset_index) => {
                         let start_offset = self.buf.bytes_written();
                         let mut protocol = TCompactOutputProtocol::new(&mut self.buf);
                         offset_index.write_to_out_protocol(&mut protocol)?;
-                        protocol.flush()?;
                         let end_offset = self.buf.bytes_written();
                         // set offset and index for offset index
                         column_metadata.offset_index_offset = Some(start_offset as i64);
@@ -228,20 +248,46 @@ impl<W: Write> SerializedFileWriter<W> {
         Ok(())
     }
 
+    /// Serialize all the bloom filter to the file
+    fn write_bloom_filters(&mut self, row_groups: &mut [RowGroup]) -> Result<()> {
+        // iter row group
+        // iter each column
+        // write bloom filter to the file
+        for (row_group_idx, row_group) in row_groups.iter_mut().enumerate() {
+            for (column_idx, column_chunk) in row_group.columns.iter_mut().enumerate() {
+                match &self.bloom_filters[row_group_idx][column_idx] {
+                    Some(bloom_filter) => {
+                        let start_offset = self.buf.bytes_written();
+                        bloom_filter.write(&mut self.buf)?;
+                        let end_offset = self.buf.bytes_written();
+                        // set offset and index for bloom filter
+                        let column_chunk_meta = column_chunk
+                            .meta_data
+                            .as_mut()
+                            .expect("can't have bloom filter without column metadata");
+                        column_chunk_meta.bloom_filter_offset = Some(start_offset as i64);
+                        column_chunk_meta.bloom_filter_length =
+                            Some((end_offset - start_offset) as i32);
+                    }
+                    None => {}
+                }
+            }
+        }
+        Ok(())
+    }
+
     /// Serialize all the column index to the file
     fn write_column_indexes(&mut self, row_groups: &mut [RowGroup]) -> Result<()> {
         // iter row group
         // iter each column
         // write column index to the file
         for (row_group_idx, row_group) in row_groups.iter_mut().enumerate() {
-            for (column_idx, column_metadata) in row_group.columns.iter_mut().enumerate()
-            {
+            for (column_idx, column_metadata) in row_group.columns.iter_mut().enumerate() {
                 match &self.column_indexes[row_group_idx][column_idx] {
                     Some(column_index) => {
                         let start_offset = self.buf.bytes_written();
                         let mut protocol = TCompactOutputProtocol::new(&mut self.buf);
                         column_index.write_to_out_protocol(&mut protocol)?;
-                        protocol.flush()?;
                         let end_offset = self.buf.bytes_written();
                         // set offset and index for offset index
                         column_metadata.column_index_offset = Some(start_offset as i64);
@@ -266,18 +312,38 @@ impl<W: Write> SerializedFileWriter<W> {
             .map(|v| v.to_thrift())
             .collect::<Vec<_>>();
 
+        self.write_bloom_filters(&mut row_groups)?;
         // Write column indexes and offset indexes
         self.write_column_indexes(&mut row_groups)?;
         self.write_offset_indexes(&mut row_groups)?;
 
+        let key_value_metadata = match self.props.key_value_metadata() {
+            Some(kv) => Some(kv.iter().chain(&self.kv_metadatas).cloned().collect()),
+            None if self.kv_metadatas.is_empty() => None,
+            None => Some(self.kv_metadatas.clone()),
+        };
+
+        // We only include ColumnOrder for leaf nodes.
+        // Currently only supported ColumnOrder is TypeDefinedOrder so we set this
+        // for all leaf nodes.
+        // Even if the column has an undefined sort order, such as INTERVAL, this
+        // is still technically the defined TYPEORDER so it should still be set.
+        let column_orders = (0..self.schema_descr().num_columns())
+            .map(|_| parquet::ColumnOrder::TYPEORDER(parquet::TypeDefinedOrder {}))
+            .collect();
+        // This field is optional, perhaps in cases where no min/max fields are set
+        // in any Statistics or ColumnIndex object in the whole file.
+        // But for simplicity we always set this field.
+        let column_orders = Some(column_orders);
+
         let file_metadata = parquet::FileMetaData {
             num_rows,
             row_groups,
+            key_value_metadata,
             version: self.props.writer_version().as_num(),
             schema: types::to_thrift(self.schema.as_ref())?,
-            key_value_metadata: self.props.key_value_metadata().cloned(),
             created_by: Some(self.props.created_by().to_owned()),
-            column_orders: None,
+            column_orders,
             encryption_algorithm: None,
             footer_signing_key_metadata: None,
         };
@@ -287,16 +353,14 @@ impl<W: Write> SerializedFileWriter<W> {
         {
             let mut protocol = TCompactOutputProtocol::new(&mut self.buf);
             file_metadata.write_to_out_protocol(&mut protocol)?;
-            protocol.flush()?;
         }
         let end_pos = self.buf.bytes_written();
 
         // Write footer
-        let mut footer_buffer: [u8; FOOTER_SIZE] = [0; FOOTER_SIZE];
-        let metadata_len = (end_pos - start_pos) as i32;
-        LittleEndian::write_i32(&mut footer_buffer, metadata_len);
-        (&mut footer_buffer[4..]).write_all(&PARQUET_MAGIC)?;
-        self.buf.write_all(&footer_buffer)?;
+        let metadata_len = (end_pos - start_pos) as u32;
+
+        self.buf.write_all(&metadata_len.to_le_bytes())?;
+        self.buf.write_all(&PARQUET_MAGIC)?;
         Ok(file_metadata)
     }
 
@@ -308,6 +372,33 @@ impl<W: Write> SerializedFileWriter<W> {
             Ok(())
         }
     }
+
+    pub fn append_key_value_metadata(&mut self, kv_metadata: KeyValue) {
+        self.kv_metadatas.push(kv_metadata);
+    }
+
+    /// Returns a reference to schema descriptor.
+    pub fn schema_descr(&self) -> &SchemaDescriptor {
+        &self.descr
+    }
+
+    /// Returns a reference to the writer properties
+    pub fn properties(&self) -> &WriterPropertiesPtr {
+        &self.props
+    }
+
+    /// Writes the file footer and returns the underlying writer.
+    pub fn into_inner(mut self) -> Result<W> {
+        self.assert_previous_writer_closed()?;
+        let _ = self.write_metadata()?;
+
+        self.buf.into_inner()
+    }
+
+    /// Returns the number of bytes written to this instance
+    pub fn bytes_written(&self) -> usize {
+        self.buf.bytes_written()
+    }
 }
 
 /// Parquet row group writer API.
@@ -326,30 +417,40 @@ pub struct SerializedRowGroupWriter<'a, W: Write> {
     buf: &'a mut TrackedWrite<W>,
     total_rows_written: Option<u64>,
     total_bytes_written: u64,
+    total_uncompressed_bytes: i64,
     column_index: usize,
     row_group_metadata: Option<RowGroupMetaDataPtr>,
     column_chunks: Vec<ColumnChunkMetaData>,
+    bloom_filters: Vec<Option<Sbbf>>,
     column_indexes: Vec<Option<ColumnIndex>>,
     offset_indexes: Vec<Option<OffsetIndex>>,
+    row_group_index: i16,
+    file_offset: i64,
     on_close: Option<OnCloseRowGroup<'a>>,
 }
 
-impl<'a, W: Write> SerializedRowGroupWriter<'a, W> {
+impl<'a, W: Write + Send> SerializedRowGroupWriter<'a, W> {
     /// Creates a new `SerializedRowGroupWriter` with:
     ///
     /// - `schema_descr` - the schema to write
     /// - `properties` - writer properties
     /// - `buf` - the buffer to write data to
+    /// - `row_group_index` - row group index in this parquet file.
+    /// - `file_offset` - file offset of this row group in this parquet file.
     /// - `on_close` - an optional callback that will invoked on [`Self::close`]
     pub fn new(
         schema_descr: SchemaDescPtr,
         properties: WriterPropertiesPtr,
         buf: &'a mut TrackedWrite<W>,
+        row_group_index: i16,
         on_close: Option<OnCloseRowGroup<'a>>,
     ) -> Self {
         let num_columns = schema_descr.num_columns();
+        let file_offset = buf.bytes_written() as i64;
         Self {
             buf,
+            row_group_index,
+            file_offset,
             on_close,
             total_rows_written: None,
             descr: schema_descr,
@@ -357,71 +458,78 @@ impl<'a, W: Write> SerializedRowGroupWriter<'a, W> {
             column_index: 0,
             row_group_metadata: None,
             column_chunks: Vec::with_capacity(num_columns),
+            bloom_filters: Vec::with_capacity(num_columns),
             column_indexes: Vec::with_capacity(num_columns),
             offset_indexes: Vec::with_capacity(num_columns),
             total_bytes_written: 0,
+            total_uncompressed_bytes: 0,
         }
     }
 
+    /// Advance `self.column_index` returning the next [`ColumnDescPtr`] if any
+    fn next_column_desc(&mut self) -> Option<ColumnDescPtr> {
+        let ret = self.descr.columns().get(self.column_index)?.clone();
+        self.column_index += 1;
+        Some(ret)
+    }
+
+    /// Returns [`OnCloseColumnChunk`] for the next writer
+    fn get_on_close(&mut self) -> (&mut TrackedWrite<W>, OnCloseColumnChunk<'_>) {
+        let total_bytes_written = &mut self.total_bytes_written;
+        let total_uncompressed_bytes = &mut self.total_uncompressed_bytes;
+        let total_rows_written = &mut self.total_rows_written;
+        let column_chunks = &mut self.column_chunks;
+        let column_indexes = &mut self.column_indexes;
+        let offset_indexes = &mut self.offset_indexes;
+        let bloom_filters = &mut self.bloom_filters;
+
+        let on_close = |r: ColumnCloseResult| {
+            // Update row group writer metrics
+            *total_bytes_written += r.bytes_written;
+            *total_uncompressed_bytes += r.metadata.uncompressed_size();
+            column_chunks.push(r.metadata);
+            bloom_filters.push(r.bloom_filter);
+            column_indexes.push(r.column_index);
+            offset_indexes.push(r.offset_index);
+
+            if let Some(rows) = *total_rows_written {
+                if rows != r.rows_written {
+                    return Err(general_err!(
+                        "Incorrect number of rows, expected {} != {} rows",
+                        rows,
+                        r.rows_written
+                    ));
+                }
+            } else {
+                *total_rows_written = Some(r.rows_written);
+            }
+
+            Ok(())
+        };
+        (self.buf, Box::new(on_close))
+    }
+
     /// Returns the next column writer, if available, using the factory function;
     /// otherwise returns `None`.
-    pub(crate) fn next_column_with_factory<'b, F, C>(
-        &'b mut self,
-        factory: F,
-    ) -> Result<Option<C>>
+    pub(crate) fn next_column_with_factory<'b, F, C>(&'b mut self, factory: F) -> Result<Option<C>>
     where
         F: FnOnce(
             ColumnDescPtr,
-            &'b WriterPropertiesPtr,
+            WriterPropertiesPtr,
             Box<dyn PageWriter + 'b>,
             OnCloseColumnChunk<'b>,
         ) -> Result<C>,
     {
         self.assert_previous_writer_closed()?;
-
-        if self.column_index >= self.descr.num_columns() {
-            return Ok(None);
-        }
-        let page_writer = Box::new(SerializedPageWriter::new(self.buf));
-
-        let total_bytes_written = &mut self.total_bytes_written;
-        let total_rows_written = &mut self.total_rows_written;
-        let column_chunks = &mut self.column_chunks;
-        let column_indexes = &mut self.column_indexes;
-        let offset_indexes = &mut self.offset_indexes;
-
-        let on_close =
-            |bytes_written, rows_written, metadata, column_index, offset_index| {
-                // Update row group writer metrics
-                *total_bytes_written += bytes_written;
-                column_chunks.push(metadata);
-                column_indexes.push(column_index);
-                offset_indexes.push(offset_index);
-
-                if let Some(rows) = *total_rows_written {
-                    if rows != rows_written {
-                        return Err(general_err!(
-                            "Incorrect number of rows, expected {} != {} rows",
-                            rows,
-                            rows_written
-                        ));
-                    }
-                } else {
-                    *total_rows_written = Some(rows_written);
-                }
-
-                Ok(())
-            };
-
-        let column = self.descr.column(self.column_index);
-        self.column_index += 1;
-
-        Ok(Some(factory(
-            column,
-            &self.props,
-            page_writer,
-            Box::new(on_close),
-        )?))
+        Ok(match self.next_column_desc() {
+            Some(column) => {
+                let props = self.props.clone();
+                let (buf, on_close) = self.get_on_close();
+                let page_writer = Box::new(SerializedPageWriter::new(buf));
+                Some(factory(column, props, page_writer, Box::new(on_close))?)
+            }
+            None => None,
+        })
     }
 
     /// Returns the next column writer, if available; otherwise returns `None`.
@@ -429,16 +537,82 @@ impl<'a, W: Write> SerializedRowGroupWriter<'a, W> {
     /// closed returns `Err`.
     pub fn next_column(&mut self) -> Result<Option<SerializedColumnWriter<'_>>> {
         self.next_column_with_factory(|descr, props, page_writer, on_close| {
-            let column_writer = get_column_writer(descr, props.clone(), page_writer);
+            let column_writer = get_column_writer(descr, props, page_writer);
             Ok(SerializedColumnWriter::new(column_writer, Some(on_close)))
         })
     }
 
-    /// Closes this row group writer and returns row group metadata.
-    /// After calling this method row group writer must not be used.
+    /// Append an encoded column chunk from another source without decoding it
+    ///
+    /// This can be used for efficiently concatenating or projecting parquet data,
+    /// or encoding parquet data to temporary in-memory buffers
     ///
-    /// Can be called multiple times. In subsequent calls will result in no-op and return
-    /// already created row group metadata.
+    /// See [`Self::next_column`] for writing data that isn't already encoded
+    pub fn append_column<R: ChunkReader>(
+        &mut self,
+        reader: &R,
+        mut close: ColumnCloseResult,
+    ) -> Result<()> {
+        self.assert_previous_writer_closed()?;
+        let desc = self
+            .next_column_desc()
+            .ok_or_else(|| general_err!("exhausted columns in SerializedRowGroupWriter"))?;
+
+        let metadata = close.metadata;
+
+        if metadata.column_descr() != desc.as_ref() {
+            return Err(general_err!(
+                "column descriptor mismatch, expected {:?} got {:?}",
+                desc,
+                metadata.column_descr()
+            ));
+        }
+
+        let src_dictionary_offset = metadata.dictionary_page_offset();
+        let src_data_offset = metadata.data_page_offset();
+        let src_offset = src_dictionary_offset.unwrap_or(src_data_offset);
+        let src_length = metadata.compressed_size();
+
+        let write_offset = self.buf.bytes_written();
+        let mut read = reader.get_read(src_offset as _)?.take(src_length as _);
+        let write_length = std::io::copy(&mut read, &mut self.buf)?;
+
+        if src_length as u64 != write_length {
+            return Err(general_err!(
+                "Failed to splice column data, expected {read_length} got {write_length}"
+            ));
+        }
+
+        let file_offset = self.buf.bytes_written() as i64;
+
+        let map_offset = |x| x - src_offset + write_offset as i64;
+        let mut builder = ColumnChunkMetaData::builder(metadata.column_descr_ptr())
+            .set_compression(metadata.compression())
+            .set_encodings(metadata.encodings().clone())
+            .set_file_offset(file_offset)
+            .set_total_compressed_size(metadata.compressed_size())
+            .set_total_uncompressed_size(metadata.uncompressed_size())
+            .set_num_values(metadata.num_values())
+            .set_data_page_offset(map_offset(src_data_offset))
+            .set_dictionary_page_offset(src_dictionary_offset.map(map_offset));
+
+        if let Some(statistics) = metadata.statistics() {
+            builder = builder.set_statistics(statistics.clone())
+        }
+        close.metadata = builder.build()?;
+
+        if let Some(offsets) = close.offset_index.as_mut() {
+            for location in &mut offsets.page_locations {
+                location.offset = map_offset(location.offset)
+            }
+        }
+
+        SerializedPageWriter::new(self.buf).write_metadata(&metadata)?;
+        let (_, on_close) = self.get_on_close();
+        on_close(close)
+    }
+
+    /// Closes this row group writer and returns row group metadata.
     pub fn close(mut self) -> Result<RowGroupMetaDataPtr> {
         if self.row_group_metadata.is_none() {
             self.assert_previous_writer_closed()?;
@@ -446,8 +620,11 @@ impl<'a, W: Write> SerializedRowGroupWriter<'a, W> {
             let column_chunks = std::mem::take(&mut self.column_chunks);
             let row_group_metadata = RowGroupMetaData::builder(self.descr.clone())
                 .set_column_metadata(column_chunks)
-                .set_total_byte_size(self.total_bytes_written as i64)
+                .set_total_byte_size(self.total_uncompressed_bytes)
                 .set_num_rows(self.total_rows_written.unwrap_or(0) as i64)
+                .set_sorting_columns(self.props.sorting_columns().cloned())
+                .set_ordinal(self.row_group_index)
+                .set_file_offset(self.file_offset)
                 .build()?;
 
             let metadata = Arc::new(row_group_metadata);
@@ -456,8 +633,9 @@ impl<'a, W: Write> SerializedRowGroupWriter<'a, W> {
             if let Some(on_close) = self.on_close.take() {
                 on_close(
                     metadata,
-                    self.column_indexes.clone(),
-                    self.offset_indexes.clone(),
+                    self.bloom_filters,
+                    self.column_indexes,
+                    self.offset_indexes,
                 )?
             }
         }
@@ -483,12 +661,9 @@ pub struct SerializedColumnWriter<'a> {
 }
 
 impl<'a> SerializedColumnWriter<'a> {
-    /// Create a new [`SerializedColumnWriter`] from a `[`ColumnWriter`] and an
+    /// Create a new [`SerializedColumnWriter`] from a [`ColumnWriter`] and an
     /// optional callback to be invoked on [`Self::close`]
-    pub fn new(
-        inner: ColumnWriter<'a>,
-        on_close: Option<OnCloseColumnChunk<'a>>,
-    ) -> Self {
+    pub fn new(inner: ColumnWriter<'a>, on_close: Option<OnCloseColumnChunk<'a>>) -> Self {
         Self { inner, on_close }
     }
 
@@ -502,28 +677,11 @@ impl<'a> SerializedColumnWriter<'a> {
         get_typed_column_writer_mut(&mut self.inner)
     }
 
-    /// Close this [`SerializedColumnWriter]
+    /// Close this [`SerializedColumnWriter`]
     pub fn close(mut self) -> Result<()> {
-        let (bytes_written, rows_written, metadata, column_index, offset_index) =
-            match self.inner {
-                ColumnWriter::BoolColumnWriter(typed) => typed.close()?,
-                ColumnWriter::Int32ColumnWriter(typed) => typed.close()?,
-                ColumnWriter::Int64ColumnWriter(typed) => typed.close()?,
-                ColumnWriter::Int96ColumnWriter(typed) => typed.close()?,
-                ColumnWriter::FloatColumnWriter(typed) => typed.close()?,
-                ColumnWriter::DoubleColumnWriter(typed) => typed.close()?,
-                ColumnWriter::ByteArrayColumnWriter(typed) => typed.close()?,
-                ColumnWriter::FixedLenByteArrayColumnWriter(typed) => typed.close()?,
-            };
-
+        let r = self.inner.close()?;
         if let Some(on_close) = self.on_close.take() {
-            on_close(
-                bytes_written,
-                rows_written,
-                metadata,
-                column_index,
-                offset_index,
-            )?
+            on_close(r)?
         }
 
         Ok(())
@@ -534,7 +692,7 @@ impl<'a> SerializedColumnWriter<'a> {
 /// Writes and serializes pages and metadata into output stream.
 ///
 /// `SerializedPageWriter` should not be used after calling `close()`.
-pub struct SerializedPageWriter<'a, W> {
+pub struct SerializedPageWriter<'a, W: Write> {
     sink: &'a mut TrackedWrite<W>,
 }
 
@@ -552,103 +710,36 @@ impl<'a, W: Write> SerializedPageWriter<'a, W> {
         {
             let mut protocol = TCompactOutputProtocol::new(&mut self.sink);
             header.write_to_out_protocol(&mut protocol)?;
-            protocol.flush()?;
         }
         Ok(self.sink.bytes_written() - start_pos)
     }
 }
 
-impl<'a, W: Write> PageWriter for SerializedPageWriter<'a, W> {
+impl<'a, W: Write + Send> PageWriter for SerializedPageWriter<'a, W> {
     fn write_page(&mut self, page: CompressedPage) -> Result<PageWriteSpec> {
-        let uncompressed_size = page.uncompressed_size();
-        let compressed_size = page.compressed_size();
-        let num_values = page.num_values();
-        let encoding = page.encoding();
         let page_type = page.page_type();
-
-        let mut page_header = parquet::PageHeader {
-            type_: page_type.into(),
-            uncompressed_page_size: uncompressed_size as i32,
-            compressed_page_size: compressed_size as i32,
-            // TODO: Add support for crc checksum
-            crc: None,
-            data_page_header: None,
-            index_page_header: None,
-            dictionary_page_header: None,
-            data_page_header_v2: None,
-        };
-
-        match *page.compressed_page() {
-            Page::DataPage {
-                def_level_encoding,
-                rep_level_encoding,
-                ref statistics,
-                ..
-            } => {
-                let data_page_header = parquet::DataPageHeader {
-                    num_values: num_values as i32,
-                    encoding: encoding.into(),
-                    definition_level_encoding: def_level_encoding.into(),
-                    repetition_level_encoding: rep_level_encoding.into(),
-                    statistics: statistics_to_thrift(statistics.as_ref()),
-                };
-                page_header.data_page_header = Some(data_page_header);
-            }
-            Page::DataPageV2 {
-                num_nulls,
-                num_rows,
-                def_levels_byte_len,
-                rep_levels_byte_len,
-                is_compressed,
-                ref statistics,
-                ..
-            } => {
-                let data_page_header_v2 = parquet::DataPageHeaderV2 {
-                    num_values: num_values as i32,
-                    num_nulls: num_nulls as i32,
-                    num_rows: num_rows as i32,
-                    encoding: encoding.into(),
-                    definition_levels_byte_length: def_levels_byte_len as i32,
-                    repetition_levels_byte_length: rep_levels_byte_len as i32,
-                    is_compressed: Some(is_compressed),
-                    statistics: statistics_to_thrift(statistics.as_ref()),
-                };
-                page_header.data_page_header_v2 = Some(data_page_header_v2);
-            }
-            Page::DictionaryPage { is_sorted, .. } => {
-                let dictionary_page_header = parquet::DictionaryPageHeader {
-                    num_values: num_values as i32,
-                    encoding: encoding.into(),
-                    is_sorted: Some(is_sorted),
-                };
-                page_header.dictionary_page_header = Some(dictionary_page_header);
-            }
-        }
-
         let start_pos = self.sink.bytes_written() as u64;
 
+        let page_header = page.to_thrift_header();
         let header_size = self.serialize_page_header(page_header)?;
         self.sink.write_all(page.data())?;
 
         let mut spec = PageWriteSpec::new();
         spec.page_type = page_type;
-        spec.uncompressed_size = uncompressed_size + header_size;
-        spec.compressed_size = compressed_size + header_size;
+        spec.uncompressed_size = page.uncompressed_size() + header_size;
+        spec.compressed_size = page.compressed_size() + header_size;
         spec.offset = start_pos;
         spec.bytes_written = self.sink.bytes_written() as u64 - start_pos;
-        // Number of values is incremented for data pages only
-        if page_type == PageType::DATA_PAGE || page_type == PageType::DATA_PAGE_V2 {
-            spec.num_values = num_values;
-        }
+        spec.num_values = page.num_values();
 
         Ok(spec)
     }
+
     fn write_metadata(&mut self, metadata: &ColumnChunkMetaData) -> Result<()> {
         let mut protocol = TCompactOutputProtocol::new(&mut self.sink);
         metadata
             .to_column_metadata_thrift()
             .write_to_out_protocol(&mut protocol)?;
-        protocol.flush()?;
         Ok(())
     }
 
@@ -663,26 +754,35 @@ mod tests {
     use super::*;
 
     use bytes::Bytes;
-    use std::{fs::File, io::Cursor};
+    use std::fs::File;
 
-    use crate::basic::{Compression, Encoding, LogicalType, Repetition, Type};
-    use crate::column::page::PageReader;
-    use crate::compression::{create_codec, Codec};
-    use crate::data_type::Int32Type;
+    use crate::basic::{
+        ColumnOrder, Compression, ConvertedType, Encoding, LogicalType, Repetition, SortOrder, Type,
+    };
+    use crate::column::page::{Page, PageReader};
+    use crate::column::reader::get_typed_column_reader;
+    use crate::compression::{create_codec, Codec, CodecOptionsBuilder};
+    use crate::data_type::{BoolType, Int32Type};
+    use crate::file::page_index::index::Index;
+    use crate::file::properties::EnabledStatistics;
+    use crate::file::reader::ChunkReader;
+    use crate::file::serialized_reader::ReadOptionsBuilder;
     use crate::file::{
-        properties::{WriterProperties, WriterVersion},
+        properties::{ReaderProperties, WriterProperties, WriterVersion},
         reader::{FileReader, SerializedFileReader, SerializedPageReader},
         statistics::{from_thrift, to_thrift, Statistics},
     };
-    use crate::record::RowAccessor;
-    use crate::util::memory::ByteBufferPtr;
+    use crate::format::SortingColumn;
+    use crate::record::{Row, RowAccessor};
+    use crate::schema::parser::parse_message_type;
+    use crate::schema::types::{ColumnDescriptor, ColumnPath};
 
     #[test]
     fn test_row_group_writer_error_not_all_columns_written() {
         let file = tempfile::tempfile().unwrap();
         let schema = Arc::new(
             types::Type::group_type_builder("schema")
-                .with_fields(&mut vec![Arc::new(
+                .with_fields(vec![Arc::new(
                     types::Type::primitive_type_builder("col1", Type::INT32)
                         .build()
                         .unwrap(),
@@ -690,14 +790,14 @@ mod tests {
                 .build()
                 .unwrap(),
         );
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = SerializedFileWriter::new(file, schema, props).unwrap();
         let row_group_writer = writer.next_row_group().unwrap();
         let res = row_group_writer.close();
         assert!(res.is_err());
         if let Err(err) = res {
             assert_eq!(
-                format!("{}", err),
+                format!("{err}"),
                 "Parquet error: Column length mismatch: 1 != 0"
             );
         }
@@ -708,7 +808,7 @@ mod tests {
         let file = tempfile::tempfile().unwrap();
         let schema = Arc::new(
             types::Type::group_type_builder("schema")
-                .with_fields(&mut vec![
+                .with_fields(vec![
                     Arc::new(
                         types::Type::primitive_type_builder("col1", Type::INT32)
                             .with_repetition(Repetition::REQUIRED)
@@ -725,7 +825,7 @@ mod tests {
                 .build()
                 .unwrap(),
         );
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
         let mut writer = SerializedFileWriter::new(file, schema, props).unwrap();
         let mut row_group_writer = writer.next_row_group().unwrap();
 
@@ -755,7 +855,7 @@ mod tests {
 
         let schema = Arc::new(
             types::Type::group_type_builder("schema")
-                .with_fields(&mut vec![Arc::new(
+                .with_fields(vec![Arc::new(
                     types::Type::primitive_type_builder("col1", Type::INT32)
                         .build()
                         .unwrap(),
@@ -763,22 +863,93 @@ mod tests {
                 .build()
                 .unwrap(),
         );
-        let props = Arc::new(WriterProperties::builder().build());
-        let writer =
-            SerializedFileWriter::new(file.try_clone().unwrap(), schema, props).unwrap();
+        let props = Default::default();
+        let writer = SerializedFileWriter::new(file.try_clone().unwrap(), schema, props).unwrap();
         writer.close().unwrap();
 
         let reader = SerializedFileReader::new(file).unwrap();
         assert_eq!(reader.get_row_iter(None).unwrap().count(), 0);
     }
 
+    #[test]
+    fn test_file_writer_column_orders_populated() {
+        let file = tempfile::tempfile().unwrap();
+
+        let schema = Arc::new(
+            types::Type::group_type_builder("schema")
+                .with_fields(vec![
+                    Arc::new(
+                        types::Type::primitive_type_builder("col1", Type::INT32)
+                            .build()
+                            .unwrap(),
+                    ),
+                    Arc::new(
+                        types::Type::primitive_type_builder("col2", Type::FIXED_LEN_BYTE_ARRAY)
+                            .with_converted_type(ConvertedType::INTERVAL)
+                            .with_length(12)
+                            .build()
+                            .unwrap(),
+                    ),
+                    Arc::new(
+                        types::Type::group_type_builder("nested")
+                            .with_repetition(Repetition::REQUIRED)
+                            .with_fields(vec![
+                                Arc::new(
+                                    types::Type::primitive_type_builder(
+                                        "col3",
+                                        Type::FIXED_LEN_BYTE_ARRAY,
+                                    )
+                                    .with_logical_type(Some(LogicalType::Float16))
+                                    .with_length(2)
+                                    .build()
+                                    .unwrap(),
+                                ),
+                                Arc::new(
+                                    types::Type::primitive_type_builder("col4", Type::BYTE_ARRAY)
+                                        .with_logical_type(Some(LogicalType::String))
+                                        .build()
+                                        .unwrap(),
+                                ),
+                            ])
+                            .build()
+                            .unwrap(),
+                    ),
+                ])
+                .build()
+                .unwrap(),
+        );
+
+        let props = Default::default();
+        let writer = SerializedFileWriter::new(file.try_clone().unwrap(), schema, props).unwrap();
+        writer.close().unwrap();
+
+        let reader = SerializedFileReader::new(file).unwrap();
+
+        // only leaves
+        let expected = vec![
+            // INT32
+            ColumnOrder::TYPE_DEFINED_ORDER(SortOrder::SIGNED),
+            // INTERVAL
+            ColumnOrder::TYPE_DEFINED_ORDER(SortOrder::UNDEFINED),
+            // Float16
+            ColumnOrder::TYPE_DEFINED_ORDER(SortOrder::SIGNED),
+            // String
+            ColumnOrder::TYPE_DEFINED_ORDER(SortOrder::UNSIGNED),
+        ];
+        let actual = reader.metadata().file_metadata().column_orders();
+
+        assert!(actual.is_some());
+        let actual = actual.unwrap();
+        assert_eq!(*actual, expected);
+    }
+
     #[test]
     fn test_file_writer_with_metadata() {
         let file = tempfile::tempfile().unwrap();
 
         let schema = Arc::new(
             types::Type::group_type_builder("schema")
-                .with_fields(&mut vec![Arc::new(
+                .with_fields(vec![Arc::new(
                     types::Type::primitive_type_builder("col1", Type::INT32)
                         .build()
                         .unwrap(),
@@ -794,8 +965,7 @@ mod tests {
                 )]))
                 .build(),
         );
-        let writer =
-            SerializedFileWriter::new(file.try_clone().unwrap(), schema, props).unwrap();
+        let writer = SerializedFileWriter::new(file.try_clone().unwrap(), schema, props).unwrap();
         writer.close().unwrap();
 
         let reader = SerializedFileReader::new(file).unwrap();
@@ -827,7 +997,7 @@ mod tests {
         );
         let schema = Arc::new(
             types::Type::group_type_builder("schema")
-                .with_fields(&mut vec![field.clone()])
+                .with_fields(vec![field.clone()])
                 .build()
                 .unwrap(),
         );
@@ -840,8 +1010,7 @@ mod tests {
                 .set_writer_version(WriterVersion::PARQUET_2_0)
                 .build(),
         );
-        let writer =
-            SerializedFileWriter::new(file.try_clone().unwrap(), schema, props).unwrap();
+        let writer = SerializedFileWriter::new(file.try_clone().unwrap(), schema, props).unwrap();
         writer.close().unwrap();
 
         let reader = SerializedFileReader::new(file).unwrap();
@@ -860,8 +1029,66 @@ mod tests {
         // ARROW-11803: Test that the converted and logical types have been populated
         let fields = reader.metadata().file_metadata().schema().get_fields();
         assert_eq!(fields.len(), 1);
-        let read_field = fields.get(0).unwrap();
-        assert_eq!(read_field, &field);
+        assert_eq!(fields[0], field);
+    }
+
+    #[test]
+    fn test_file_writer_with_sorting_columns_metadata() {
+        let file = tempfile::tempfile().unwrap();
+
+        let schema = Arc::new(
+            types::Type::group_type_builder("schema")
+                .with_fields(vec![
+                    Arc::new(
+                        types::Type::primitive_type_builder("col1", Type::INT32)
+                            .build()
+                            .unwrap(),
+                    ),
+                    Arc::new(
+                        types::Type::primitive_type_builder("col2", Type::INT32)
+                            .build()
+                            .unwrap(),
+                    ),
+                ])
+                .build()
+                .unwrap(),
+        );
+        let expected_result = Some(vec![SortingColumn {
+            column_idx: 0,
+            descending: false,
+            nulls_first: true,
+        }]);
+        let props = Arc::new(
+            WriterProperties::builder()
+                .set_key_value_metadata(Some(vec![KeyValue::new(
+                    "key".to_string(),
+                    "value".to_string(),
+                )]))
+                .set_sorting_columns(expected_result.clone())
+                .build(),
+        );
+        let mut writer =
+            SerializedFileWriter::new(file.try_clone().unwrap(), schema, props).unwrap();
+        let mut row_group_writer = writer.next_row_group().expect("get row group writer");
+
+        let col_writer = row_group_writer.next_column().unwrap().unwrap();
+        col_writer.close().unwrap();
+
+        let col_writer = row_group_writer.next_column().unwrap().unwrap();
+        col_writer.close().unwrap();
+
+        row_group_writer.close().unwrap();
+        writer.close().unwrap();
+
+        let reader = SerializedFileReader::new(file).unwrap();
+        let result: Vec<Option<&Vec<SortingColumn>>> = reader
+            .metadata()
+            .row_groups()
+            .iter()
+            .map(|f| f.sorting_columns())
+            .collect();
+        // validate the sorting column read match the one written above
+        assert_eq!(expected_result.as_ref(), result[0]);
     }
 
     #[test]
@@ -903,7 +1130,7 @@ mod tests {
     fn test_page_writer_data_pages() {
         let pages = vec![
             Page::DataPage {
-                buf: ByteBufferPtr::new(vec![1, 2, 3, 4, 5, 6, 7, 8]),
+                buf: Bytes::from(vec![1, 2, 3, 4, 5, 6, 7, 8]),
                 num_values: 10,
                 encoding: Encoding::DELTA_BINARY_PACKED,
                 def_level_encoding: Encoding::RLE,
@@ -911,7 +1138,7 @@ mod tests {
                 statistics: Some(Statistics::int32(Some(1), Some(3), None, 7, true)),
             },
             Page::DataPageV2 {
-                buf: ByteBufferPtr::new(vec![4; 128]),
+                buf: Bytes::from(vec![4; 128]),
                 num_values: 10,
                 encoding: Encoding::DELTA_BINARY_PACKED,
                 num_nulls: 2,
@@ -931,13 +1158,13 @@ mod tests {
     fn test_page_writer_dict_pages() {
         let pages = vec![
             Page::DictionaryPage {
-                buf: ByteBufferPtr::new(vec![1, 2, 3, 4, 5]),
+                buf: Bytes::from(vec![1, 2, 3, 4, 5]),
                 num_values: 5,
                 encoding: Encoding::RLE_DICTIONARY,
                 is_sorted: false,
             },
             Page::DataPage {
-                buf: ByteBufferPtr::new(vec![1, 2, 3, 4, 5, 6, 7, 8]),
+                buf: Bytes::from(vec![1, 2, 3, 4, 5, 6, 7, 8]),
                 num_values: 10,
                 encoding: Encoding::DELTA_BINARY_PACKED,
                 def_level_encoding: Encoding::RLE,
@@ -945,7 +1172,7 @@ mod tests {
                 statistics: Some(Statistics::int32(Some(1), Some(3), None, 7, true)),
             },
             Page::DataPageV2 {
-                buf: ByteBufferPtr::new(vec![4; 128]),
+                buf: Bytes::from(vec![4; 128]),
                 num_values: 10,
                 encoding: Encoding::DELTA_BINARY_PACKED,
                 num_nulls: 2,
@@ -967,7 +1194,10 @@ mod tests {
     fn test_page_roundtrip(pages: &[Page], codec: Compression, physical_type: Type) {
         let mut compressed_pages = vec![];
         let mut total_num_values = 0i64;
-        let mut compressor = create_codec(codec).unwrap();
+        let codec_options = CodecOptionsBuilder::default()
+            .set_backward_compatible_lz4(false)
+            .build();
+        let mut compressor = create_codec(codec, &codec_options).unwrap();
 
         for page in pages {
             let uncompressed_len = page.buffer().len();
@@ -982,18 +1212,16 @@ mod tests {
                     ref statistics,
                 } => {
                     total_num_values += num_values as i64;
-                    let output_buf = compress_helper(compressor.as_mut(), buf.data());
+                    let output_buf = compress_helper(compressor.as_mut(), buf);
 
                     Page::DataPage {
-                        buf: ByteBufferPtr::new(output_buf),
+                        buf: Bytes::from(output_buf),
                         num_values,
                         encoding,
                         def_level_encoding,
                         rep_level_encoding,
-                        statistics: from_thrift(
-                            physical_type,
-                            to_thrift(statistics.as_ref()),
-                        ),
+                        statistics: from_thrift(physical_type, to_thrift(statistics.as_ref()))
+                            .unwrap(),
                     }
                 }
                 Page::DataPageV2 {
@@ -1009,13 +1237,12 @@ mod tests {
                 } => {
                     total_num_values += num_values as i64;
                     let offset = (def_levels_byte_len + rep_levels_byte_len) as usize;
-                    let cmp_buf =
-                        compress_helper(compressor.as_mut(), &buf.data()[offset..]);
-                    let mut output_buf = Vec::from(&buf.data()[..offset]);
+                    let cmp_buf = compress_helper(compressor.as_mut(), &buf[offset..]);
+                    let mut output_buf = Vec::from(&buf[..offset]);
                     output_buf.extend_from_slice(&cmp_buf[..]);
 
                     Page::DataPageV2 {
-                        buf: ByteBufferPtr::new(output_buf),
+                        buf: Bytes::from(output_buf),
                         num_values,
                         encoding,
                         num_nulls,
@@ -1023,10 +1250,8 @@ mod tests {
                         def_levels_byte_len,
                         rep_levels_byte_len,
                         is_compressed: compressor.is_some(),
-                        statistics: from_thrift(
-                            physical_type,
-                            to_thrift(statistics.as_ref()),
-                        ),
+                        statistics: from_thrift(physical_type, to_thrift(statistics.as_ref()))
+                            .unwrap(),
                     }
                 }
                 Page::DictionaryPage {
@@ -1035,10 +1260,10 @@ mod tests {
                     encoding,
                     is_sorted,
                 } => {
-                    let output_buf = compress_helper(compressor.as_mut(), buf.data());
+                    let output_buf = compress_helper(compressor.as_mut(), buf);
 
                     Page::DictionaryPage {
-                        buf: ByteBufferPtr::new(output_buf),
+                        buf: Bytes::from(output_buf),
                         num_values,
                         encoding,
                         is_sorted,
@@ -1062,11 +1287,29 @@ mod tests {
             page_writer.close().unwrap();
         }
         {
-            let mut page_reader = SerializedPageReader::new(
-                Cursor::new(&buffer),
-                total_num_values,
-                codec,
-                physical_type,
+            let reader = bytes::Bytes::from(buffer);
+
+            let t = types::Type::primitive_type_builder("t", physical_type)
+                .build()
+                .unwrap();
+
+            let desc = ColumnDescriptor::new(Arc::new(t), 0, 0, ColumnPath::new(vec![]));
+            let meta = ColumnChunkMetaData::builder(Arc::new(desc))
+                .set_compression(codec)
+                .set_total_compressed_size(reader.len() as i64)
+                .set_num_values(total_num_values)
+                .build()
+                .unwrap();
+
+            let props = ReaderProperties::builder()
+                .set_backward_compatible_lz4(false)
+                .build();
+            let mut page_reader = SerializedPageReader::new_with_properties(
+                Arc::new(reader),
+                &meta,
+                total_num_values as usize,
+                None,
+                Arc::new(props),
             )
             .unwrap();
 
@@ -1095,22 +1338,43 @@ mod tests {
     /// Check if pages match.
     fn assert_page(left: &Page, right: &Page) {
         assert_eq!(left.page_type(), right.page_type());
-        assert_eq!(left.buffer().data(), right.buffer().data());
+        assert_eq!(&left.buffer(), &right.buffer());
         assert_eq!(left.num_values(), right.num_values());
         assert_eq!(left.encoding(), right.encoding());
         assert_eq!(to_thrift(left.statistics()), to_thrift(right.statistics()));
     }
 
-    /// File write-read roundtrip.
-    /// `data` consists of arrays of values for each row group.
-    fn test_file_roundtrip(
-        file: File,
+    /// Tests roundtrip of i32 data written using `W` and read using `R`
+    fn test_roundtrip_i32<W, R>(
+        file: W,
         data: Vec<Vec<i32>>,
-    ) -> parquet_format::FileMetaData {
+        compression: Compression,
+    ) -> crate::format::FileMetaData
+    where
+        W: Write + Send,
+        R: ChunkReader + From<W> + 'static,
+    {
+        test_roundtrip::<W, R, Int32Type, _>(file, data, |r| r.get_int(0).unwrap(), compression)
+    }
+
+    /// Tests roundtrip of data of type `D` written using `W` and read using `R`
+    /// and the provided `values` function
+    fn test_roundtrip<W, R, D, F>(
+        mut file: W,
+        data: Vec<Vec<D::T>>,
+        value: F,
+        compression: Compression,
+    ) -> crate::format::FileMetaData
+    where
+        W: Write + Send,
+        R: ChunkReader + From<W> + 'static,
+        D: DataType,
+        F: Fn(Row) -> D::T,
+    {
         let schema = Arc::new(
             types::Type::group_type_builder("schema")
-                .with_fields(&mut vec![Arc::new(
-                    types::Type::primitive_type_builder("col1", Type::INT32)
+                .with_fields(vec![Arc::new(
+                    types::Type::primitive_type_builder("col1", D::get_physical_type())
                         .with_repetition(Repetition::REQUIRED)
                         .build()
                         .unwrap(),
@@ -1118,17 +1382,20 @@ mod tests {
                 .build()
                 .unwrap(),
         );
-        let props = Arc::new(WriterProperties::builder().build());
-        let mut file_writer = assert_send(
-            SerializedFileWriter::new(file.try_clone().unwrap(), schema, props).unwrap(),
+        let props = Arc::new(
+            WriterProperties::builder()
+                .set_compression(compression)
+                .build(),
         );
+        let mut file_writer = SerializedFileWriter::new(&mut file, schema, props).unwrap();
         let mut rows: i64 = 0;
 
         for (idx, subset) in data.iter().enumerate() {
+            let row_group_file_offset = file_writer.buf.bytes_written();
             let mut row_group_writer = file_writer.next_row_group().unwrap();
             if let Some(mut writer) = row_group_writer.next_column().unwrap() {
                 rows += writer
-                    .typed::<Int32Type>()
+                    .typed::<D>()
                     .write_batch(&subset[..], None, None)
                     .unwrap() as i64;
                 writer.close().unwrap();
@@ -1136,11 +1403,13 @@ mod tests {
             let last_group = row_group_writer.close().unwrap();
             let flushed = file_writer.flushed_row_groups();
             assert_eq!(flushed.len(), idx + 1);
+            assert_eq!(Some(idx as i16), last_group.ordinal());
+            assert_eq!(Some(row_group_file_offset as i64), last_group.file_offset());
             assert_eq!(flushed[idx].as_ref(), last_group.as_ref());
         }
         let file_metadata = file_writer.close().unwrap();
 
-        let reader = assert_send(SerializedFileReader::new(file).unwrap());
+        let reader = SerializedFileReader::new(R::from(file)).unwrap();
         assert_eq!(reader.num_row_groups(), data.len());
         assert_eq!(
             reader.metadata().file_metadata().num_rows(),
@@ -1150,91 +1419,91 @@ mod tests {
         for (i, item) in data.iter().enumerate().take(reader.num_row_groups()) {
             let row_group_reader = reader.get_row_group(i).unwrap();
             let iter = row_group_reader.get_row_iter(None).unwrap();
-            let res = iter
-                .map(|elem| elem.get_int(0).unwrap())
-                .collect::<Vec<i32>>();
+            let res: Vec<_> = iter.map(|row| row.unwrap()).map(&value).collect();
+            let row_group_size = row_group_reader.metadata().total_byte_size();
+            let uncompressed_size: i64 = row_group_reader
+                .metadata()
+                .columns()
+                .iter()
+                .map(|v| v.uncompressed_size())
+                .sum();
+            assert_eq!(row_group_size, uncompressed_size);
             assert_eq!(res, *item);
         }
         file_metadata
     }
 
-    fn assert_send<T: Send>(t: T) -> T {
-        t
+    /// File write-read roundtrip.
+    /// `data` consists of arrays of values for each row group.
+    fn test_file_roundtrip(file: File, data: Vec<Vec<i32>>) -> crate::format::FileMetaData {
+        test_roundtrip_i32::<File, File>(file, data, Compression::UNCOMPRESSED)
     }
 
     #[test]
     fn test_bytes_writer_empty_row_groups() {
-        test_bytes_roundtrip(vec![]);
+        test_bytes_roundtrip(vec![], Compression::UNCOMPRESSED);
     }
 
     #[test]
     fn test_bytes_writer_single_row_group() {
-        test_bytes_roundtrip(vec![vec![1, 2, 3, 4, 5]]);
+        test_bytes_roundtrip(vec![vec![1, 2, 3, 4, 5]], Compression::UNCOMPRESSED);
     }
 
     #[test]
     fn test_bytes_writer_multiple_row_groups() {
-        test_bytes_roundtrip(vec![
-            vec![1, 2, 3, 4, 5],
-            vec![1, 2, 3],
-            vec![1],
-            vec![1, 2, 3, 4, 5, 6],
-        ]);
+        test_bytes_roundtrip(
+            vec![
+                vec![1, 2, 3, 4, 5],
+                vec![1, 2, 3],
+                vec![1],
+                vec![1, 2, 3, 4, 5, 6],
+            ],
+            Compression::UNCOMPRESSED,
+        );
     }
 
-    fn test_bytes_roundtrip(data: Vec<Vec<i32>>) {
-        let mut buffer = vec![];
+    #[test]
+    fn test_bytes_writer_single_row_group_compressed() {
+        test_bytes_roundtrip(vec![vec![1, 2, 3, 4, 5]], Compression::SNAPPY);
+    }
 
-        let schema = Arc::new(
-            types::Type::group_type_builder("schema")
-                .with_fields(&mut vec![Arc::new(
-                    types::Type::primitive_type_builder("col1", Type::INT32)
-                        .with_repetition(Repetition::REQUIRED)
-                        .build()
-                        .unwrap(),
-                )])
-                .build()
-                .unwrap(),
+    #[test]
+    fn test_bytes_writer_multiple_row_groups_compressed() {
+        test_bytes_roundtrip(
+            vec![
+                vec![1, 2, 3, 4, 5],
+                vec![1, 2, 3],
+                vec![1],
+                vec![1, 2, 3, 4, 5, 6],
+            ],
+            Compression::SNAPPY,
         );
+    }
 
-        let mut rows: i64 = 0;
-        {
-            let props = Arc::new(WriterProperties::builder().build());
-            let mut writer =
-                SerializedFileWriter::new(&mut buffer, schema, props).unwrap();
-
-            for subset in &data {
-                let mut row_group_writer = writer.next_row_group().unwrap();
-                if let Some(mut writer) = row_group_writer.next_column().unwrap() {
-                    rows += writer
-                        .typed::<Int32Type>()
-                        .write_batch(&subset[..], None, None)
-                        .unwrap() as i64;
-
-                    writer.close().unwrap();
-                }
-                row_group_writer.close().unwrap();
-            }
-            writer.close().unwrap();
-        }
+    fn test_bytes_roundtrip(data: Vec<Vec<i32>>, compression: Compression) {
+        test_roundtrip_i32::<Vec<u8>, Bytes>(Vec::with_capacity(1024), data, compression);
+    }
 
-        let reading_cursor = Bytes::from(buffer);
-        let reader = SerializedFileReader::new(reading_cursor).unwrap();
+    #[test]
+    fn test_boolean_roundtrip() {
+        let my_bool_values: Vec<_> = (0..2049).map(|idx| idx % 2 == 0).collect();
+        test_roundtrip::<Vec<u8>, Bytes, BoolType, _>(
+            Vec::with_capacity(1024),
+            vec![my_bool_values],
+            |r| r.get_bool(0).unwrap(),
+            Compression::UNCOMPRESSED,
+        );
+    }
 
-        assert_eq!(reader.num_row_groups(), data.len());
-        assert_eq!(
-            reader.metadata().file_metadata().num_rows(),
-            rows,
-            "row count in metadata not equal to number of rows written"
+    #[test]
+    fn test_boolean_compressed_roundtrip() {
+        let my_bool_values: Vec<_> = (0..2049).map(|idx| idx % 2 == 0).collect();
+        test_roundtrip::<Vec<u8>, Bytes, BoolType, _>(
+            Vec::with_capacity(1024),
+            vec![my_bool_values],
+            |r| r.get_bool(0).unwrap(),
+            Compression::SNAPPY,
         );
-        for (i, item) in data.iter().enumerate().take(reader.num_row_groups()) {
-            let row_group_reader = reader.get_row_group(i).unwrap();
-            let iter = row_group_reader.get_row_iter(None).unwrap();
-            let res = iter
-                .map(|elem| elem.get_int(0).unwrap())
-                .collect::<Vec<i32>>();
-            assert_eq!(res, *item);
-        }
     }
 
     #[test]
@@ -1251,4 +1520,266 @@ mod tests {
             })
         });
     }
+
+    fn test_kv_metadata(initial_kv: Option<Vec<KeyValue>>, final_kv: Option<Vec<KeyValue>>) {
+        let schema = Arc::new(
+            types::Type::group_type_builder("schema")
+                .with_fields(vec![Arc::new(
+                    types::Type::primitive_type_builder("col1", Type::INT32)
+                        .with_repetition(Repetition::REQUIRED)
+                        .build()
+                        .unwrap(),
+                )])
+                .build()
+                .unwrap(),
+        );
+        let mut out = Vec::with_capacity(1024);
+        let props = Arc::new(
+            WriterProperties::builder()
+                .set_key_value_metadata(initial_kv.clone())
+                .build(),
+        );
+        let mut writer = SerializedFileWriter::new(&mut out, schema, props).unwrap();
+        let mut row_group_writer = writer.next_row_group().unwrap();
+        let column = row_group_writer.next_column().unwrap().unwrap();
+        column.close().unwrap();
+        row_group_writer.close().unwrap();
+        if let Some(kvs) = &final_kv {
+            for kv in kvs {
+                writer.append_key_value_metadata(kv.clone())
+            }
+        }
+        writer.close().unwrap();
+
+        let reader = SerializedFileReader::new(Bytes::from(out)).unwrap();
+        let metadata = reader.metadata().file_metadata();
+        let keys = metadata.key_value_metadata();
+
+        match (initial_kv, final_kv) {
+            (Some(a), Some(b)) => {
+                let keys = keys.unwrap();
+                assert_eq!(keys.len(), a.len() + b.len());
+                assert_eq!(&keys[..a.len()], a.as_slice());
+                assert_eq!(&keys[a.len()..], b.as_slice());
+            }
+            (Some(v), None) => assert_eq!(keys.unwrap(), &v),
+            (None, Some(v)) if !v.is_empty() => assert_eq!(keys.unwrap(), &v),
+            _ => assert!(keys.is_none()),
+        }
+    }
+
+    #[test]
+    fn test_append_metadata() {
+        let kv1 = KeyValue::new("cupcakes".to_string(), "awesome".to_string());
+        let kv2 = KeyValue::new("bingo".to_string(), "bongo".to_string());
+
+        test_kv_metadata(None, None);
+        test_kv_metadata(Some(vec![kv1.clone()]), None);
+        test_kv_metadata(None, Some(vec![kv2.clone()]));
+        test_kv_metadata(Some(vec![kv1.clone()]), Some(vec![kv2.clone()]));
+        test_kv_metadata(Some(vec![]), Some(vec![kv2]));
+        test_kv_metadata(Some(vec![]), Some(vec![]));
+        test_kv_metadata(Some(vec![kv1]), Some(vec![]));
+        test_kv_metadata(None, Some(vec![]));
+    }
+
+    #[test]
+    fn test_backwards_compatible_statistics() {
+        let message_type = "
+            message test_schema {
+                REQUIRED INT32 decimal1 (DECIMAL(8,2));
+                REQUIRED INT32 i32 (INTEGER(32,true));
+                REQUIRED INT32 u32 (INTEGER(32,false));
+            }
+        ";
+
+        let schema = Arc::new(parse_message_type(message_type).unwrap());
+        let props = Default::default();
+        let mut writer = SerializedFileWriter::new(vec![], schema, props).unwrap();
+        let mut row_group_writer = writer.next_row_group().unwrap();
+
+        for _ in 0..3 {
+            let mut writer = row_group_writer.next_column().unwrap().unwrap();
+            writer
+                .typed::<Int32Type>()
+                .write_batch(&[1, 2, 3], None, None)
+                .unwrap();
+            writer.close().unwrap();
+        }
+        let metadata = row_group_writer.close().unwrap();
+        writer.close().unwrap();
+
+        let thrift = metadata.to_thrift();
+        let encoded_stats: Vec<_> = thrift
+            .columns
+            .into_iter()
+            .map(|x| x.meta_data.unwrap().statistics.unwrap())
+            .collect();
+
+        // decimal
+        let s = &encoded_stats[0];
+        assert_eq!(s.min.as_deref(), Some(1_i32.to_le_bytes().as_ref()));
+        assert_eq!(s.max.as_deref(), Some(3_i32.to_le_bytes().as_ref()));
+        assert_eq!(s.min_value.as_deref(), Some(1_i32.to_le_bytes().as_ref()));
+        assert_eq!(s.max_value.as_deref(), Some(3_i32.to_le_bytes().as_ref()));
+
+        // i32
+        let s = &encoded_stats[1];
+        assert_eq!(s.min.as_deref(), Some(1_i32.to_le_bytes().as_ref()));
+        assert_eq!(s.max.as_deref(), Some(3_i32.to_le_bytes().as_ref()));
+        assert_eq!(s.min_value.as_deref(), Some(1_i32.to_le_bytes().as_ref()));
+        assert_eq!(s.max_value.as_deref(), Some(3_i32.to_le_bytes().as_ref()));
+
+        // u32
+        let s = &encoded_stats[2];
+        assert_eq!(s.min.as_deref(), None);
+        assert_eq!(s.max.as_deref(), None);
+        assert_eq!(s.min_value.as_deref(), Some(1_i32.to_le_bytes().as_ref()));
+        assert_eq!(s.max_value.as_deref(), Some(3_i32.to_le_bytes().as_ref()));
+    }
+
+    #[test]
+    fn test_spliced_write() {
+        let message_type = "
+            message test_schema {
+                REQUIRED INT32 i32 (INTEGER(32,true));
+                REQUIRED INT32 u32 (INTEGER(32,false));
+            }
+        ";
+        let schema = Arc::new(parse_message_type(message_type).unwrap());
+        let props = Arc::new(WriterProperties::builder().build());
+
+        let mut file = Vec::with_capacity(1024);
+        let mut file_writer = SerializedFileWriter::new(&mut file, schema, props.clone()).unwrap();
+
+        let columns = file_writer.descr.columns();
+        let mut column_state: Vec<(_, Option<ColumnCloseResult>)> = columns
+            .iter()
+            .map(|_| (TrackedWrite::new(Vec::with_capacity(1024)), None))
+            .collect();
+
+        let mut column_state_slice = column_state.as_mut_slice();
+        let mut column_writers = Vec::with_capacity(columns.len());
+        for c in columns {
+            let ((buf, out), tail) = column_state_slice.split_first_mut().unwrap();
+            column_state_slice = tail;
+
+            let page_writer = Box::new(SerializedPageWriter::new(buf));
+            let col_writer = get_column_writer(c.clone(), props.clone(), page_writer);
+            column_writers.push(SerializedColumnWriter::new(
+                col_writer,
+                Some(Box::new(|on_close| {
+                    *out = Some(on_close);
+                    Ok(())
+                })),
+            ));
+        }
+
+        let column_data = [[1, 2, 3, 4], [7, 3, 7, 3]];
+
+        // Interleaved writing to the column writers
+        for (writer, batch) in column_writers.iter_mut().zip(column_data) {
+            let writer = writer.typed::<Int32Type>();
+            writer.write_batch(&batch, None, None).unwrap();
+        }
+
+        // Close the column writers
+        for writer in column_writers {
+            writer.close().unwrap()
+        }
+
+        // Splice column data into a row group
+        let mut row_group_writer = file_writer.next_row_group().unwrap();
+        for (write, close) in column_state {
+            let buf = Bytes::from(write.into_inner().unwrap());
+            row_group_writer
+                .append_column(&buf, close.unwrap())
+                .unwrap();
+        }
+        row_group_writer.close().unwrap();
+        file_writer.close().unwrap();
+
+        // Check data was written correctly
+        let file = Bytes::from(file);
+        let test_read = |reader: SerializedFileReader<Bytes>| {
+            let row_group = reader.get_row_group(0).unwrap();
+
+            let mut out = Vec::with_capacity(4);
+            let c1 = row_group.get_column_reader(0).unwrap();
+            let mut c1 = get_typed_column_reader::<Int32Type>(c1);
+            c1.read_records(4, None, None, &mut out).unwrap();
+            assert_eq!(out, column_data[0]);
+
+            out.clear();
+
+            let c2 = row_group.get_column_reader(1).unwrap();
+            let mut c2 = get_typed_column_reader::<Int32Type>(c2);
+            c2.read_records(4, None, None, &mut out).unwrap();
+            assert_eq!(out, column_data[1]);
+        };
+
+        let reader = SerializedFileReader::new(file.clone()).unwrap();
+        test_read(reader);
+
+        let options = ReadOptionsBuilder::new().with_page_index().build();
+        let reader = SerializedFileReader::new_with_options(file, options).unwrap();
+        test_read(reader);
+    }
+
+    #[test]
+    fn test_disabled_statistics() {
+        let message_type = "
+            message test_schema {
+                REQUIRED INT32 a;
+                REQUIRED INT32 b;
+            }
+        ";
+        let schema = Arc::new(parse_message_type(message_type).unwrap());
+        let props = WriterProperties::builder()
+            .set_statistics_enabled(EnabledStatistics::None)
+            .set_column_statistics_enabled("a".into(), EnabledStatistics::Page)
+            .build();
+        let mut file = Vec::with_capacity(1024);
+        let mut file_writer =
+            SerializedFileWriter::new(&mut file, schema, Arc::new(props)).unwrap();
+
+        let mut row_group_writer = file_writer.next_row_group().unwrap();
+        let mut a_writer = row_group_writer.next_column().unwrap().unwrap();
+        let col_writer = a_writer.typed::<Int32Type>();
+        col_writer.write_batch(&[1, 2, 3], None, None).unwrap();
+        a_writer.close().unwrap();
+
+        let mut b_writer = row_group_writer.next_column().unwrap().unwrap();
+        let col_writer = b_writer.typed::<Int32Type>();
+        col_writer.write_batch(&[4, 5, 6], None, None).unwrap();
+        b_writer.close().unwrap();
+        row_group_writer.close().unwrap();
+
+        let metadata = file_writer.close().unwrap();
+        assert_eq!(metadata.row_groups.len(), 1);
+        let row_group = &metadata.row_groups[0];
+        assert_eq!(row_group.columns.len(), 2);
+        // Column "a" has both offset and column index, as requested
+        assert!(row_group.columns[0].offset_index_offset.is_some());
+        assert!(row_group.columns[0].column_index_offset.is_some());
+        // Column "b" should only have offset index
+        assert!(row_group.columns[1].offset_index_offset.is_some());
+        assert!(row_group.columns[1].column_index_offset.is_none());
+
+        let options = ReadOptionsBuilder::new().with_page_index().build();
+        let reader = SerializedFileReader::new_with_options(Bytes::from(file), options).unwrap();
+
+        let offset_index = reader.metadata().offset_index().unwrap();
+        assert_eq!(offset_index.len(), 1); // 1 row group
+        assert_eq!(offset_index[0].len(), 2); // 2 columns
+
+        let column_index = reader.metadata().column_index().unwrap();
+        assert_eq!(column_index.len(), 1); // 1 row group
+        assert_eq!(column_index[0].len(), 2); // 2 column
+
+        let a_idx = &column_index[0][0];
+        assert!(matches!(a_idx, Index::INT32(_)), "{a_idx:?}");
+        let b_idx = &column_index[0][1];
+        assert!(matches!(b_idx, Index::NONE), "{b_idx:?}");
+    }
 }
diff --git a/parquet/src/format.rs b/parquet/src/format.rs
new file mode 100644
index 000000000000..4e1aa0b65b7c
--- /dev/null
+++ b/parquet/src/format.rs
@@ -0,0 +1,5204 @@
+// Autogenerated by Thrift Compiler (0.19.0)
+// DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
+
+#![allow(dead_code)]
+#![allow(unused_imports)]
+#![allow(unused_extern_crates)]
+#![allow(clippy::too_many_arguments, clippy::type_complexity, clippy::vec_box, clippy::wrong_self_convention)]
+#![cfg_attr(rustfmt, rustfmt_skip)]
+
+use std::cell::RefCell;
+use std::collections::{BTreeMap, BTreeSet};
+use std::convert::{From, TryFrom};
+use std::default::Default;
+use std::error::Error;
+use std::fmt;
+use std::fmt::{Display, Formatter};
+use std::rc::Rc;
+
+use thrift::OrderedFloat;
+use thrift::{ApplicationError, ApplicationErrorKind, ProtocolError, ProtocolErrorKind, TThriftClient};
+use thrift::protocol::{TFieldIdentifier, TListIdentifier, TMapIdentifier, TMessageIdentifier, TMessageType, TInputProtocol, TOutputProtocol, TSerializable, TSetIdentifier, TStructIdentifier, TType};
+use thrift::protocol::field_id;
+use thrift::protocol::verify_expected_message_type;
+use thrift::protocol::verify_expected_sequence_number;
+use thrift::protocol::verify_expected_service_call;
+use thrift::protocol::verify_required_field_exists;
+
+/// Types supported by Parquet.  These types are intended to be used in combination
+/// with the encodings to control the on disk storage format.
+/// For example INT16 is not included as a type since a good encoding of INT32
+/// would handle this.
+#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Type(pub i32);
+
+impl Type {
+  pub const BOOLEAN: Type = Type(0);
+  pub const INT32: Type = Type(1);
+  pub const INT64: Type = Type(2);
+  pub const INT96: Type = Type(3);
+  pub const FLOAT: Type = Type(4);
+  pub const DOUBLE: Type = Type(5);
+  pub const BYTE_ARRAY: Type = Type(6);
+  pub const FIXED_LEN_BYTE_ARRAY: Type = Type(7);
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::BOOLEAN,
+    Self::INT32,
+    Self::INT64,
+    Self::INT96,
+    Self::FLOAT,
+    Self::DOUBLE,
+    Self::BYTE_ARRAY,
+    Self::FIXED_LEN_BYTE_ARRAY,
+  ];
+}
+
+impl crate::thrift::TSerializable for Type {
+  #[allow(clippy::trivially_copy_pass_by_ref)]
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    o_prot.write_i32(self.0)
+  }
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Type> {
+    let enum_value = i_prot.read_i32()?;
+    Ok(Type::from(enum_value))
+  }
+}
+
+impl From<i32> for Type {
+  fn from(i: i32) -> Self {
+    match i {
+      0 => Type::BOOLEAN,
+      1 => Type::INT32,
+      2 => Type::INT64,
+      3 => Type::INT96,
+      4 => Type::FLOAT,
+      5 => Type::DOUBLE,
+      6 => Type::BYTE_ARRAY,
+      7 => Type::FIXED_LEN_BYTE_ARRAY,
+      _ => Type(i)
+    }
+  }
+}
+
+impl From<&i32> for Type {
+  fn from(i: &i32) -> Self {
+    Type::from(*i)
+  }
+}
+
+impl From<Type> for i32 {
+  fn from(e: Type) -> i32 {
+    e.0
+  }
+}
+
+impl From<&Type> for i32 {
+  fn from(e: &Type) -> i32 {
+    e.0
+  }
+}
+
+/// DEPRECATED: Common types used by frameworks(e.g. hive, pig) using parquet.
+/// ConvertedType is superseded by LogicalType.  This enum should not be extended.
+/// 
+/// See LogicalTypes.md for conversion between ConvertedType and LogicalType.
+#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ConvertedType(pub i32);
+
+impl ConvertedType {
+  /// a BYTE_ARRAY actually contains UTF8 encoded chars
+  pub const UTF8: ConvertedType = ConvertedType(0);
+  /// a map is converted as an optional field containing a repeated key/value pair
+  pub const MAP: ConvertedType = ConvertedType(1);
+  /// a key/value pair is converted into a group of two fields
+  pub const MAP_KEY_VALUE: ConvertedType = ConvertedType(2);
+  /// a list is converted into an optional field containing a repeated field for its
+  /// values
+  pub const LIST: ConvertedType = ConvertedType(3);
+  /// an enum is converted into a binary field
+  pub const ENUM: ConvertedType = ConvertedType(4);
+  /// A decimal value.
+  /// 
+  /// This may be used to annotate binary or fixed primitive types. The
+  /// underlying byte array stores the unscaled value encoded as two's
+  /// complement using big-endian byte order (the most significant byte is the
+  /// zeroth element). The value of the decimal is the value * 10^{-scale}.
+  /// 
+  /// This must be accompanied by a (maximum) precision and a scale in the
+  /// SchemaElement. The precision specifies the number of digits in the decimal
+  /// and the scale stores the location of the decimal point. For example 1.23
+  /// would have precision 3 (3 total digits) and scale 2 (the decimal point is
+  /// 2 digits over).
+  pub const DECIMAL: ConvertedType = ConvertedType(5);
+  /// A Date
+  /// 
+  /// Stored as days since Unix epoch, encoded as the INT32 physical type.
+  /// 
+  pub const DATE: ConvertedType = ConvertedType(6);
+  /// A time
+  /// 
+  /// The total number of milliseconds since midnight.  The value is stored
+  /// as an INT32 physical type.
+  pub const TIME_MILLIS: ConvertedType = ConvertedType(7);
+  /// A time.
+  /// 
+  /// The total number of microseconds since midnight.  The value is stored as
+  /// an INT64 physical type.
+  pub const TIME_MICROS: ConvertedType = ConvertedType(8);
+  /// A date/time combination
+  /// 
+  /// Date and time recorded as milliseconds since the Unix epoch.  Recorded as
+  /// a physical type of INT64.
+  pub const TIMESTAMP_MILLIS: ConvertedType = ConvertedType(9);
+  /// A date/time combination
+  /// 
+  /// Date and time recorded as microseconds since the Unix epoch.  The value is
+  /// stored as an INT64 physical type.
+  pub const TIMESTAMP_MICROS: ConvertedType = ConvertedType(10);
+  /// An unsigned integer value.
+  /// 
+  /// The number describes the maximum number of meaningful data bits in
+  /// the stored value. 8, 16 and 32 bit values are stored using the
+  /// INT32 physical type.  64 bit values are stored using the INT64
+  /// physical type.
+  /// 
+  pub const UINT_8: ConvertedType = ConvertedType(11);
+  pub const UINT_16: ConvertedType = ConvertedType(12);
+  pub const UINT_32: ConvertedType = ConvertedType(13);
+  pub const UINT_64: ConvertedType = ConvertedType(14);
+  /// A signed integer value.
+  /// 
+  /// The number describes the maximum number of meaningful data bits in
+  /// the stored value. 8, 16 and 32 bit values are stored using the
+  /// INT32 physical type.  64 bit values are stored using the INT64
+  /// physical type.
+  /// 
+  pub const INT_8: ConvertedType = ConvertedType(15);
+  pub const INT_16: ConvertedType = ConvertedType(16);
+  pub const INT_32: ConvertedType = ConvertedType(17);
+  pub const INT_64: ConvertedType = ConvertedType(18);
+  /// An embedded JSON document
+  /// 
+  /// A JSON document embedded within a single UTF8 column.
+  pub const JSON: ConvertedType = ConvertedType(19);
+  /// An embedded BSON document
+  /// 
+  /// A BSON document embedded within a single BINARY column.
+  pub const BSON: ConvertedType = ConvertedType(20);
+  /// An interval of time
+  /// 
+  /// This type annotates data stored as a FIXED_LEN_BYTE_ARRAY of length 12
+  /// This data is composed of three separate little endian unsigned
+  /// integers.  Each stores a component of a duration of time.  The first
+  /// integer identifies the number of months associated with the duration,
+  /// the second identifies the number of days associated with the duration
+  /// and the third identifies the number of milliseconds associated with
+  /// the provided duration.  This duration of time is independent of any
+  /// particular timezone or date.
+  pub const INTERVAL: ConvertedType = ConvertedType(21);
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::UTF8,
+    Self::MAP,
+    Self::MAP_KEY_VALUE,
+    Self::LIST,
+    Self::ENUM,
+    Self::DECIMAL,
+    Self::DATE,
+    Self::TIME_MILLIS,
+    Self::TIME_MICROS,
+    Self::TIMESTAMP_MILLIS,
+    Self::TIMESTAMP_MICROS,
+    Self::UINT_8,
+    Self::UINT_16,
+    Self::UINT_32,
+    Self::UINT_64,
+    Self::INT_8,
+    Self::INT_16,
+    Self::INT_32,
+    Self::INT_64,
+    Self::JSON,
+    Self::BSON,
+    Self::INTERVAL,
+  ];
+}
+
+impl crate::thrift::TSerializable for ConvertedType {
+  #[allow(clippy::trivially_copy_pass_by_ref)]
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    o_prot.write_i32(self.0)
+  }
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ConvertedType> {
+    let enum_value = i_prot.read_i32()?;
+    Ok(ConvertedType::from(enum_value))
+  }
+}
+
+impl From<i32> for ConvertedType {
+  fn from(i: i32) -> Self {
+    match i {
+      0 => ConvertedType::UTF8,
+      1 => ConvertedType::MAP,
+      2 => ConvertedType::MAP_KEY_VALUE,
+      3 => ConvertedType::LIST,
+      4 => ConvertedType::ENUM,
+      5 => ConvertedType::DECIMAL,
+      6 => ConvertedType::DATE,
+      7 => ConvertedType::TIME_MILLIS,
+      8 => ConvertedType::TIME_MICROS,
+      9 => ConvertedType::TIMESTAMP_MILLIS,
+      10 => ConvertedType::TIMESTAMP_MICROS,
+      11 => ConvertedType::UINT_8,
+      12 => ConvertedType::UINT_16,
+      13 => ConvertedType::UINT_32,
+      14 => ConvertedType::UINT_64,
+      15 => ConvertedType::INT_8,
+      16 => ConvertedType::INT_16,
+      17 => ConvertedType::INT_32,
+      18 => ConvertedType::INT_64,
+      19 => ConvertedType::JSON,
+      20 => ConvertedType::BSON,
+      21 => ConvertedType::INTERVAL,
+      _ => ConvertedType(i)
+    }
+  }
+}
+
+impl From<&i32> for ConvertedType {
+  fn from(i: &i32) -> Self {
+    ConvertedType::from(*i)
+  }
+}
+
+impl From<ConvertedType> for i32 {
+  fn from(e: ConvertedType) -> i32 {
+    e.0
+  }
+}
+
+impl From<&ConvertedType> for i32 {
+  fn from(e: &ConvertedType) -> i32 {
+    e.0
+  }
+}
+
+/// Representation of Schemas
+#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct FieldRepetitionType(pub i32);
+
+impl FieldRepetitionType {
+  /// This field is required (can not be null) and each record has exactly 1 value.
+  pub const REQUIRED: FieldRepetitionType = FieldRepetitionType(0);
+  /// The field is optional (can be null) and each record has 0 or 1 values.
+  pub const OPTIONAL: FieldRepetitionType = FieldRepetitionType(1);
+  /// The field is repeated and can contain 0 or more values
+  pub const REPEATED: FieldRepetitionType = FieldRepetitionType(2);
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::REQUIRED,
+    Self::OPTIONAL,
+    Self::REPEATED,
+  ];
+}
+
+impl crate::thrift::TSerializable for FieldRepetitionType {
+  #[allow(clippy::trivially_copy_pass_by_ref)]
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    o_prot.write_i32(self.0)
+  }
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<FieldRepetitionType> {
+    let enum_value = i_prot.read_i32()?;
+    Ok(FieldRepetitionType::from(enum_value))
+  }
+}
+
+impl From<i32> for FieldRepetitionType {
+  fn from(i: i32) -> Self {
+    match i {
+      0 => FieldRepetitionType::REQUIRED,
+      1 => FieldRepetitionType::OPTIONAL,
+      2 => FieldRepetitionType::REPEATED,
+      _ => FieldRepetitionType(i)
+    }
+  }
+}
+
+impl From<&i32> for FieldRepetitionType {
+  fn from(i: &i32) -> Self {
+    FieldRepetitionType::from(*i)
+  }
+}
+
+impl From<FieldRepetitionType> for i32 {
+  fn from(e: FieldRepetitionType) -> i32 {
+    e.0
+  }
+}
+
+impl From<&FieldRepetitionType> for i32 {
+  fn from(e: &FieldRepetitionType) -> i32 {
+    e.0
+  }
+}
+
+/// Encodings supported by Parquet.  Not all encodings are valid for all types.  These
+/// enums are also used to specify the encoding of definition and repetition levels.
+/// See the accompanying doc for the details of the more complicated encodings.
+#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Encoding(pub i32);
+
+impl Encoding {
+  /// Default encoding.
+  /// BOOLEAN - 1 bit per value. 0 is false; 1 is true.
+  /// INT32 - 4 bytes per value.  Stored as little-endian.
+  /// INT64 - 8 bytes per value.  Stored as little-endian.
+  /// FLOAT - 4 bytes per value.  IEEE. Stored as little-endian.
+  /// DOUBLE - 8 bytes per value.  IEEE. Stored as little-endian.
+  /// BYTE_ARRAY - 4 byte length stored as little endian, followed by bytes.
+  /// FIXED_LEN_BYTE_ARRAY - Just the bytes.
+  pub const PLAIN: Encoding = Encoding(0);
+  /// Deprecated: Dictionary encoding. The values in the dictionary are encoded in the
+  /// plain type.
+  /// in a data page use RLE_DICTIONARY instead.
+  /// in a Dictionary page use PLAIN instead
+  pub const PLAIN_DICTIONARY: Encoding = Encoding(2);
+  /// Group packed run length encoding. Usable for definition/repetition levels
+  /// encoding and Booleans (on one bit: 0 is false; 1 is true.)
+  pub const RLE: Encoding = Encoding(3);
+  /// Bit packed encoding.  This can only be used if the data has a known max
+  /// width.  Usable for definition/repetition levels encoding.
+  pub const BIT_PACKED: Encoding = Encoding(4);
+  /// Delta encoding for integers. This can be used for int columns and works best
+  /// on sorted data
+  pub const DELTA_BINARY_PACKED: Encoding = Encoding(5);
+  /// Encoding for byte arrays to separate the length values and the data. The lengths
+  /// are encoded using DELTA_BINARY_PACKED
+  pub const DELTA_LENGTH_BYTE_ARRAY: Encoding = Encoding(6);
+  /// Incremental-encoded byte array. Prefix lengths are encoded using DELTA_BINARY_PACKED.
+  /// Suffixes are stored as delta length byte arrays.
+  pub const DELTA_BYTE_ARRAY: Encoding = Encoding(7);
+  /// Dictionary encoding: the ids are encoded using the RLE encoding
+  pub const RLE_DICTIONARY: Encoding = Encoding(8);
+  /// Encoding for floating-point data.
+  /// K byte-streams are created where K is the size in bytes of the data type.
+  /// The individual bytes of an FP value are scattered to the corresponding stream and
+  /// the streams are concatenated.
+  /// This itself does not reduce the size of the data but can lead to better compression
+  /// afterwards.
+  pub const BYTE_STREAM_SPLIT: Encoding = Encoding(9);
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::PLAIN,
+    Self::PLAIN_DICTIONARY,
+    Self::RLE,
+    Self::BIT_PACKED,
+    Self::DELTA_BINARY_PACKED,
+    Self::DELTA_LENGTH_BYTE_ARRAY,
+    Self::DELTA_BYTE_ARRAY,
+    Self::RLE_DICTIONARY,
+    Self::BYTE_STREAM_SPLIT,
+  ];
+}
+
+impl crate::thrift::TSerializable for Encoding {
+  #[allow(clippy::trivially_copy_pass_by_ref)]
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    o_prot.write_i32(self.0)
+  }
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Encoding> {
+    let enum_value = i_prot.read_i32()?;
+    Ok(Encoding::from(enum_value))
+  }
+}
+
+impl From<i32> for Encoding {
+  fn from(i: i32) -> Self {
+    match i {
+      0 => Encoding::PLAIN,
+      2 => Encoding::PLAIN_DICTIONARY,
+      3 => Encoding::RLE,
+      4 => Encoding::BIT_PACKED,
+      5 => Encoding::DELTA_BINARY_PACKED,
+      6 => Encoding::DELTA_LENGTH_BYTE_ARRAY,
+      7 => Encoding::DELTA_BYTE_ARRAY,
+      8 => Encoding::RLE_DICTIONARY,
+      9 => Encoding::BYTE_STREAM_SPLIT,
+      _ => Encoding(i)
+    }
+  }
+}
+
+impl From<&i32> for Encoding {
+  fn from(i: &i32) -> Self {
+    Encoding::from(*i)
+  }
+}
+
+impl From<Encoding> for i32 {
+  fn from(e: Encoding) -> i32 {
+    e.0
+  }
+}
+
+impl From<&Encoding> for i32 {
+  fn from(e: &Encoding) -> i32 {
+    e.0
+  }
+}
+
+/// Supported compression algorithms.
+/// 
+/// Codecs added in format version X.Y can be read by readers based on X.Y and later.
+/// Codec support may vary between readers based on the format version and
+/// libraries available at runtime.
+/// 
+/// See Compression.md for a detailed specification of these algorithms.
+#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct CompressionCodec(pub i32);
+
+impl CompressionCodec {
+  pub const UNCOMPRESSED: CompressionCodec = CompressionCodec(0);
+  pub const SNAPPY: CompressionCodec = CompressionCodec(1);
+  pub const GZIP: CompressionCodec = CompressionCodec(2);
+  pub const LZO: CompressionCodec = CompressionCodec(3);
+  pub const BROTLI: CompressionCodec = CompressionCodec(4);
+  pub const LZ4: CompressionCodec = CompressionCodec(5);
+  pub const ZSTD: CompressionCodec = CompressionCodec(6);
+  pub const LZ4_RAW: CompressionCodec = CompressionCodec(7);
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::UNCOMPRESSED,
+    Self::SNAPPY,
+    Self::GZIP,
+    Self::LZO,
+    Self::BROTLI,
+    Self::LZ4,
+    Self::ZSTD,
+    Self::LZ4_RAW,
+  ];
+}
+
+impl crate::thrift::TSerializable for CompressionCodec {
+  #[allow(clippy::trivially_copy_pass_by_ref)]
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    o_prot.write_i32(self.0)
+  }
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<CompressionCodec> {
+    let enum_value = i_prot.read_i32()?;
+    Ok(CompressionCodec::from(enum_value))
+  }
+}
+
+impl From<i32> for CompressionCodec {
+  fn from(i: i32) -> Self {
+    match i {
+      0 => CompressionCodec::UNCOMPRESSED,
+      1 => CompressionCodec::SNAPPY,
+      2 => CompressionCodec::GZIP,
+      3 => CompressionCodec::LZO,
+      4 => CompressionCodec::BROTLI,
+      5 => CompressionCodec::LZ4,
+      6 => CompressionCodec::ZSTD,
+      7 => CompressionCodec::LZ4_RAW,
+      _ => CompressionCodec(i)
+    }
+  }
+}
+
+impl From<&i32> for CompressionCodec {
+  fn from(i: &i32) -> Self {
+    CompressionCodec::from(*i)
+  }
+}
+
+impl From<CompressionCodec> for i32 {
+  fn from(e: CompressionCodec) -> i32 {
+    e.0
+  }
+}
+
+impl From<&CompressionCodec> for i32 {
+  fn from(e: &CompressionCodec) -> i32 {
+    e.0
+  }
+}
+
+#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct PageType(pub i32);
+
+impl PageType {
+  pub const DATA_PAGE: PageType = PageType(0);
+  pub const INDEX_PAGE: PageType = PageType(1);
+  pub const DICTIONARY_PAGE: PageType = PageType(2);
+  pub const DATA_PAGE_V2: PageType = PageType(3);
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::DATA_PAGE,
+    Self::INDEX_PAGE,
+    Self::DICTIONARY_PAGE,
+    Self::DATA_PAGE_V2,
+  ];
+}
+
+impl crate::thrift::TSerializable for PageType {
+  #[allow(clippy::trivially_copy_pass_by_ref)]
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    o_prot.write_i32(self.0)
+  }
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<PageType> {
+    let enum_value = i_prot.read_i32()?;
+    Ok(PageType::from(enum_value))
+  }
+}
+
+impl From<i32> for PageType {
+  fn from(i: i32) -> Self {
+    match i {
+      0 => PageType::DATA_PAGE,
+      1 => PageType::INDEX_PAGE,
+      2 => PageType::DICTIONARY_PAGE,
+      3 => PageType::DATA_PAGE_V2,
+      _ => PageType(i)
+    }
+  }
+}
+
+impl From<&i32> for PageType {
+  fn from(i: &i32) -> Self {
+    PageType::from(*i)
+  }
+}
+
+impl From<PageType> for i32 {
+  fn from(e: PageType) -> i32 {
+    e.0
+  }
+}
+
+impl From<&PageType> for i32 {
+  fn from(e: &PageType) -> i32 {
+    e.0
+  }
+}
+
+/// Enum to annotate whether lists of min/max elements inside ColumnIndex
+/// are ordered and if so, in which direction.
+#[derive(Copy, Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct BoundaryOrder(pub i32);
+
+impl BoundaryOrder {
+  pub const UNORDERED: BoundaryOrder = BoundaryOrder(0);
+  pub const ASCENDING: BoundaryOrder = BoundaryOrder(1);
+  pub const DESCENDING: BoundaryOrder = BoundaryOrder(2);
+  pub const ENUM_VALUES: &'static [Self] = &[
+    Self::UNORDERED,
+    Self::ASCENDING,
+    Self::DESCENDING,
+  ];
+}
+
+impl crate::thrift::TSerializable for BoundaryOrder {
+  #[allow(clippy::trivially_copy_pass_by_ref)]
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    o_prot.write_i32(self.0)
+  }
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BoundaryOrder> {
+    let enum_value = i_prot.read_i32()?;
+    Ok(BoundaryOrder::from(enum_value))
+  }
+}
+
+impl From<i32> for BoundaryOrder {
+  fn from(i: i32) -> Self {
+    match i {
+      0 => BoundaryOrder::UNORDERED,
+      1 => BoundaryOrder::ASCENDING,
+      2 => BoundaryOrder::DESCENDING,
+      _ => BoundaryOrder(i)
+    }
+  }
+}
+
+impl From<&i32> for BoundaryOrder {
+  fn from(i: &i32) -> Self {
+    BoundaryOrder::from(*i)
+  }
+}
+
+impl From<BoundaryOrder> for i32 {
+  fn from(e: BoundaryOrder) -> i32 {
+    e.0
+  }
+}
+
+impl From<&BoundaryOrder> for i32 {
+  fn from(e: &BoundaryOrder) -> i32 {
+    e.0
+  }
+}
+
+//
+// Statistics
+//
+
+/// Statistics per row group and per page
+/// All fields are optional.
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Statistics {
+  /// DEPRECATED: min and max value of the column. Use min_value and max_value.
+  /// 
+  /// Values are encoded using PLAIN encoding, except that variable-length byte
+  /// arrays do not include a length prefix.
+  /// 
+  /// These fields encode min and max values determined by signed comparison
+  /// only. New files should use the correct order for a column's logical type
+  /// and store the values in the min_value and max_value fields.
+  /// 
+  /// To support older readers, these may be set when the column order is
+  /// signed.
+  pub max: Option<Vec<u8>>,
+  pub min: Option<Vec<u8>>,
+  /// count of null value in the column
+  pub null_count: Option<i64>,
+  /// count of distinct values occurring
+  pub distinct_count: Option<i64>,
+  /// Lower and upper bound values for the column, determined by its ColumnOrder.
+  /// 
+  /// These may be the actual minimum and maximum values found on a page or column
+  /// chunk, but can also be (more compact) values that do not exist on a page or
+  /// column chunk. For example, instead of storing "Blart Versenwald III", a writer
+  /// may set min_value="B", max_value="C". Such more compact values must still be
+  /// valid values within the column's logical type.
+  /// 
+  /// Values are encoded using PLAIN encoding, except that variable-length byte
+  /// arrays do not include a length prefix.
+  pub max_value: Option<Vec<u8>>,
+  pub min_value: Option<Vec<u8>>,
+  /// If true, max_value is the actual maximum value for a column
+  pub is_max_value_exact: Option<bool>,
+  /// If true, min_value is the actual minimum value for a column
+  pub is_min_value_exact: Option<bool>,
+}
+
+impl Statistics {
+  pub fn new<F1, F2, F3, F4, F5, F6, F7, F8>(max: F1, min: F2, null_count: F3, distinct_count: F4, max_value: F5, min_value: F6, is_max_value_exact: F7, is_min_value_exact: F8) -> Statistics where F1: Into<Option<Vec<u8>>>, F2: Into<Option<Vec<u8>>>, F3: Into<Option<i64>>, F4: Into<Option<i64>>, F5: Into<Option<Vec<u8>>>, F6: Into<Option<Vec<u8>>>, F7: Into<Option<bool>>, F8: Into<Option<bool>> {
+    Statistics {
+      max: max.into(),
+      min: min.into(),
+      null_count: null_count.into(),
+      distinct_count: distinct_count.into(),
+      max_value: max_value.into(),
+      min_value: min_value.into(),
+      is_max_value_exact: is_max_value_exact.into(),
+      is_min_value_exact: is_min_value_exact.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for Statistics {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Statistics> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<Vec<u8>> = None;
+    let mut f_2: Option<Vec<u8>> = None;
+    let mut f_3: Option<i64> = None;
+    let mut f_4: Option<i64> = None;
+    let mut f_5: Option<Vec<u8>> = None;
+    let mut f_6: Option<Vec<u8>> = None;
+    let mut f_7: Option<bool> = None;
+    let mut f_8: Option<bool> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_bytes()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_bytes()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_i64()?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let val = i_prot.read_i64()?;
+          f_4 = Some(val);
+        },
+        5 => {
+          let val = i_prot.read_bytes()?;
+          f_5 = Some(val);
+        },
+        6 => {
+          let val = i_prot.read_bytes()?;
+          f_6 = Some(val);
+        },
+        7 => {
+          let val = i_prot.read_bool()?;
+          f_7 = Some(val);
+        },
+        8 => {
+          let val = i_prot.read_bool()?;
+          f_8 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = Statistics {
+      max: f_1,
+      min: f_2,
+      null_count: f_3,
+      distinct_count: f_4,
+      max_value: f_5,
+      min_value: f_6,
+      is_max_value_exact: f_7,
+      is_min_value_exact: f_8,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("Statistics");
+    o_prot.write_struct_begin(&struct_ident)?;
+    if let Some(ref fld_var) = self.max {
+      o_prot.write_field_begin(&TFieldIdentifier::new("max", TType::String, 1))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.min {
+      o_prot.write_field_begin(&TFieldIdentifier::new("min", TType::String, 2))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.null_count {
+      o_prot.write_field_begin(&TFieldIdentifier::new("null_count", TType::I64, 3))?;
+      o_prot.write_i64(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.distinct_count {
+      o_prot.write_field_begin(&TFieldIdentifier::new("distinct_count", TType::I64, 4))?;
+      o_prot.write_i64(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.max_value {
+      o_prot.write_field_begin(&TFieldIdentifier::new("max_value", TType::String, 5))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.min_value {
+      o_prot.write_field_begin(&TFieldIdentifier::new("min_value", TType::String, 6))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.is_max_value_exact {
+      o_prot.write_field_begin(&TFieldIdentifier::new("is_max_value_exact", TType::Bool, 7))?;
+      o_prot.write_bool(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.is_min_value_exact {
+      o_prot.write_field_begin(&TFieldIdentifier::new("is_min_value_exact", TType::Bool, 8))?;
+      o_prot.write_bool(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// StringType
+//
+
+/// Empty structs to use as logical type annotations
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct StringType {
+}
+
+impl StringType {
+  pub fn new() -> StringType {
+    StringType {}
+  }
+}
+
+impl crate::thrift::TSerializable for StringType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<StringType> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = StringType {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("StringType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// UUIDType
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct UUIDType {
+}
+
+impl UUIDType {
+  pub fn new() -> UUIDType {
+    UUIDType {}
+  }
+}
+
+impl crate::thrift::TSerializable for UUIDType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<UUIDType> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = UUIDType {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("UUIDType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// MapType
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct MapType {
+}
+
+impl MapType {
+  pub fn new() -> MapType {
+    MapType {}
+  }
+}
+
+impl crate::thrift::TSerializable for MapType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<MapType> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = MapType {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("MapType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// ListType
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ListType {
+}
+
+impl ListType {
+  pub fn new() -> ListType {
+    ListType {}
+  }
+}
+
+impl crate::thrift::TSerializable for ListType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ListType> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = ListType {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("ListType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// EnumType
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct EnumType {
+}
+
+impl EnumType {
+  pub fn new() -> EnumType {
+    EnumType {}
+  }
+}
+
+impl crate::thrift::TSerializable for EnumType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<EnumType> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = EnumType {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("EnumType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// DateType
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct DateType {
+}
+
+impl DateType {
+  pub fn new() -> DateType {
+    DateType {}
+  }
+}
+
+impl crate::thrift::TSerializable for DateType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<DateType> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = DateType {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("DateType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// Float16Type
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Float16Type {
+}
+
+impl Float16Type {
+  pub fn new() -> Float16Type {
+    Float16Type {}
+  }
+}
+
+impl crate::thrift::TSerializable for Float16Type {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Float16Type> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = Float16Type {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("Float16Type");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// NullType
+//
+
+/// Logical type to annotate a column that is always null.
+/// 
+/// Sometimes when discovering the schema of existing data, values are always
+/// null and the physical type can't be determined. This annotation signals
+/// the case where the physical type was guessed from all null values.
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct NullType {
+}
+
+impl NullType {
+  pub fn new() -> NullType {
+    NullType {}
+  }
+}
+
+impl crate::thrift::TSerializable for NullType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<NullType> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = NullType {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("NullType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// DecimalType
+//
+
+/// Decimal logical type annotation
+/// 
+/// Scale must be zero or a positive integer less than or equal to the precision.
+/// Precision must be a non-zero positive integer.
+/// 
+/// To maintain forward-compatibility in v1, implementations using this logical
+/// type must also set scale and precision on the annotated SchemaElement.
+/// 
+/// Allowed for physical types: INT32, INT64, FIXED, and BINARY
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct DecimalType {
+  pub scale: i32,
+  pub precision: i32,
+}
+
+impl DecimalType {
+  pub fn new(scale: i32, precision: i32) -> DecimalType {
+    DecimalType {
+      scale,
+      precision,
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for DecimalType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<DecimalType> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<i32> = None;
+    let mut f_2: Option<i32> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_i32()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_i32()?;
+          f_2 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("DecimalType.scale", &f_1)?;
+    verify_required_field_exists("DecimalType.precision", &f_2)?;
+    let ret = DecimalType {
+      scale: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      precision: f_2.expect("auto-generated code should have checked for presence of required fields"),
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("DecimalType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("scale", TType::I32, 1))?;
+    o_prot.write_i32(self.scale)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("precision", TType::I32, 2))?;
+    o_prot.write_i32(self.precision)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// MilliSeconds
+//
+
+/// Time units for logical types
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct MilliSeconds {
+}
+
+impl MilliSeconds {
+  pub fn new() -> MilliSeconds {
+    MilliSeconds {}
+  }
+}
+
+impl crate::thrift::TSerializable for MilliSeconds {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<MilliSeconds> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = MilliSeconds {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("MilliSeconds");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// MicroSeconds
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct MicroSeconds {
+}
+
+impl MicroSeconds {
+  pub fn new() -> MicroSeconds {
+    MicroSeconds {}
+  }
+}
+
+impl crate::thrift::TSerializable for MicroSeconds {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<MicroSeconds> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = MicroSeconds {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("MicroSeconds");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// NanoSeconds
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct NanoSeconds {
+}
+
+impl NanoSeconds {
+  pub fn new() -> NanoSeconds {
+    NanoSeconds {}
+  }
+}
+
+impl crate::thrift::TSerializable for NanoSeconds {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<NanoSeconds> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = NanoSeconds {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("NanoSeconds");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// TimeUnit
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum TimeUnit {
+  MILLIS(MilliSeconds),
+  MICROS(MicroSeconds),
+  NANOS(NanoSeconds),
+}
+
+impl crate::thrift::TSerializable for TimeUnit {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<TimeUnit> {
+    let mut ret: Option<TimeUnit> = None;
+    let mut received_field_count = 0;
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = MilliSeconds::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(TimeUnit::MILLIS(val));
+          }
+          received_field_count += 1;
+        },
+        2 => {
+          let val = MicroSeconds::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(TimeUnit::MICROS(val));
+          }
+          received_field_count += 1;
+        },
+        3 => {
+          let val = NanoSeconds::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(TimeUnit::NANOS(val));
+          }
+          received_field_count += 1;
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+          received_field_count += 1;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    if received_field_count == 0 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received empty union from remote TimeUnit"
+          )
+        )
+      )
+    } else if received_field_count > 1 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received multiple fields for union from remote TimeUnit"
+          )
+        )
+      )
+    } else {
+      ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
+    }
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("TimeUnit");
+    o_prot.write_struct_begin(&struct_ident)?;
+    match *self {
+      TimeUnit::MILLIS(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("MILLIS", TType::Struct, 1))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      TimeUnit::MICROS(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("MICROS", TType::Struct, 2))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      TimeUnit::NANOS(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("NANOS", TType::Struct, 3))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// TimestampType
+//
+
+/// Timestamp logical type annotation
+/// 
+/// Allowed for physical types: INT64
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct TimestampType {
+  pub is_adjusted_to_u_t_c: bool,
+  pub unit: TimeUnit,
+}
+
+impl TimestampType {
+  pub fn new(is_adjusted_to_u_t_c: bool, unit: TimeUnit) -> TimestampType {
+    TimestampType {
+      is_adjusted_to_u_t_c,
+      unit,
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for TimestampType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<TimestampType> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<bool> = None;
+    let mut f_2: Option<TimeUnit> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_bool()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = TimeUnit::read_from_in_protocol(i_prot)?;
+          f_2 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("TimestampType.is_adjusted_to_u_t_c", &f_1)?;
+    verify_required_field_exists("TimestampType.unit", &f_2)?;
+    let ret = TimestampType {
+      is_adjusted_to_u_t_c: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      unit: f_2.expect("auto-generated code should have checked for presence of required fields"),
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("TimestampType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("isAdjustedToUTC", TType::Bool, 1))?;
+    o_prot.write_bool(self.is_adjusted_to_u_t_c)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("unit", TType::Struct, 2))?;
+    self.unit.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// TimeType
+//
+
+/// Time logical type annotation
+/// 
+/// Allowed for physical types: INT32 (millis), INT64 (micros, nanos)
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct TimeType {
+  pub is_adjusted_to_u_t_c: bool,
+  pub unit: TimeUnit,
+}
+
+impl TimeType {
+  pub fn new(is_adjusted_to_u_t_c: bool, unit: TimeUnit) -> TimeType {
+    TimeType {
+      is_adjusted_to_u_t_c,
+      unit,
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for TimeType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<TimeType> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<bool> = None;
+    let mut f_2: Option<TimeUnit> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_bool()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = TimeUnit::read_from_in_protocol(i_prot)?;
+          f_2 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("TimeType.is_adjusted_to_u_t_c", &f_1)?;
+    verify_required_field_exists("TimeType.unit", &f_2)?;
+    let ret = TimeType {
+      is_adjusted_to_u_t_c: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      unit: f_2.expect("auto-generated code should have checked for presence of required fields"),
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("TimeType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("isAdjustedToUTC", TType::Bool, 1))?;
+    o_prot.write_bool(self.is_adjusted_to_u_t_c)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("unit", TType::Struct, 2))?;
+    self.unit.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// IntType
+//
+
+/// Integer logical type annotation
+/// 
+/// bitWidth must be 8, 16, 32, or 64.
+/// 
+/// Allowed for physical types: INT32, INT64
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct IntType {
+  pub bit_width: i8,
+  pub is_signed: bool,
+}
+
+impl IntType {
+  pub fn new(bit_width: i8, is_signed: bool) -> IntType {
+    IntType {
+      bit_width,
+      is_signed,
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for IntType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<IntType> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<i8> = None;
+    let mut f_2: Option<bool> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_i8()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_bool()?;
+          f_2 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("IntType.bit_width", &f_1)?;
+    verify_required_field_exists("IntType.is_signed", &f_2)?;
+    let ret = IntType {
+      bit_width: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      is_signed: f_2.expect("auto-generated code should have checked for presence of required fields"),
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("IntType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("bitWidth", TType::I08, 1))?;
+    o_prot.write_i8(self.bit_width)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("isSigned", TType::Bool, 2))?;
+    o_prot.write_bool(self.is_signed)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// JsonType
+//
+
+/// Embedded JSON logical type annotation
+/// 
+/// Allowed for physical types: BINARY
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct JsonType {
+}
+
+impl JsonType {
+  pub fn new() -> JsonType {
+    JsonType {}
+  }
+}
+
+impl crate::thrift::TSerializable for JsonType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<JsonType> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = JsonType {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("JsonType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// BsonType
+//
+
+/// Embedded BSON logical type annotation
+/// 
+/// Allowed for physical types: BINARY
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct BsonType {
+}
+
+impl BsonType {
+  pub fn new() -> BsonType {
+    BsonType {}
+  }
+}
+
+impl crate::thrift::TSerializable for BsonType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BsonType> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = BsonType {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("BsonType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// LogicalType
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum LogicalType {
+  STRING(StringType),
+  MAP(MapType),
+  LIST(ListType),
+  ENUM(EnumType),
+  DECIMAL(DecimalType),
+  DATE(DateType),
+  TIME(TimeType),
+  TIMESTAMP(TimestampType),
+  INTEGER(IntType),
+  UNKNOWN(NullType),
+  JSON(JsonType),
+  BSON(BsonType),
+  UUID(UUIDType),
+  FLOAT16(Float16Type),
+}
+
+impl crate::thrift::TSerializable for LogicalType {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<LogicalType> {
+    let mut ret: Option<LogicalType> = None;
+    let mut received_field_count = 0;
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = StringType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::STRING(val));
+          }
+          received_field_count += 1;
+        },
+        2 => {
+          let val = MapType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::MAP(val));
+          }
+          received_field_count += 1;
+        },
+        3 => {
+          let val = ListType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::LIST(val));
+          }
+          received_field_count += 1;
+        },
+        4 => {
+          let val = EnumType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::ENUM(val));
+          }
+          received_field_count += 1;
+        },
+        5 => {
+          let val = DecimalType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::DECIMAL(val));
+          }
+          received_field_count += 1;
+        },
+        6 => {
+          let val = DateType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::DATE(val));
+          }
+          received_field_count += 1;
+        },
+        7 => {
+          let val = TimeType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::TIME(val));
+          }
+          received_field_count += 1;
+        },
+        8 => {
+          let val = TimestampType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::TIMESTAMP(val));
+          }
+          received_field_count += 1;
+        },
+        10 => {
+          let val = IntType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::INTEGER(val));
+          }
+          received_field_count += 1;
+        },
+        11 => {
+          let val = NullType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::UNKNOWN(val));
+          }
+          received_field_count += 1;
+        },
+        12 => {
+          let val = JsonType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::JSON(val));
+          }
+          received_field_count += 1;
+        },
+        13 => {
+          let val = BsonType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::BSON(val));
+          }
+          received_field_count += 1;
+        },
+        14 => {
+          let val = UUIDType::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::UUID(val));
+          }
+          received_field_count += 1;
+        },
+        15 => {
+          let val = Float16Type::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(LogicalType::FLOAT16(val));
+          }
+          received_field_count += 1;
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+          received_field_count += 1;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    if received_field_count == 0 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received empty union from remote LogicalType"
+          )
+        )
+      )
+    } else if received_field_count > 1 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received multiple fields for union from remote LogicalType"
+          )
+        )
+      )
+    } else {
+      ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
+    }
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("LogicalType");
+    o_prot.write_struct_begin(&struct_ident)?;
+    match *self {
+      LogicalType::STRING(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("STRING", TType::Struct, 1))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::MAP(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("MAP", TType::Struct, 2))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::LIST(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("LIST", TType::Struct, 3))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::ENUM(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("ENUM", TType::Struct, 4))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::DECIMAL(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("DECIMAL", TType::Struct, 5))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::DATE(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("DATE", TType::Struct, 6))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::TIME(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("TIME", TType::Struct, 7))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::TIMESTAMP(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("TIMESTAMP", TType::Struct, 8))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::INTEGER(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("INTEGER", TType::Struct, 10))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::UNKNOWN(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("UNKNOWN", TType::Struct, 11))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::JSON(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("JSON", TType::Struct, 12))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::BSON(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("BSON", TType::Struct, 13))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::UUID(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("UUID", TType::Struct, 14))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      LogicalType::FLOAT16(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("FLOAT16", TType::Struct, 15))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// SchemaElement
+//
+
+/// Represents a element inside a schema definition.
+///  - if it is a group (inner node) then type is undefined and num_children is defined
+///  - if it is a primitive type (leaf) then type is defined and num_children is undefined
+/// the nodes are listed in depth first traversal order.
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct SchemaElement {
+  /// Data type for this field. Not set if the current element is a non-leaf node
+  pub type_: Option<Type>,
+  /// If type is FIXED_LEN_BYTE_ARRAY, this is the byte length of the values.
+  /// Otherwise, if specified, this is the maximum bit length to store any of the values.
+  /// (e.g. a low cardinality INT col could have this set to 3).  Note that this is
+  /// in the schema, and therefore fixed for the entire file.
+  pub type_length: Option<i32>,
+  /// repetition of the field. The root of the schema does not have a repetition_type.
+  /// All other nodes must have one
+  pub repetition_type: Option<FieldRepetitionType>,
+  /// Name of the field in the schema
+  pub name: String,
+  /// Nested fields.  Since thrift does not support nested fields,
+  /// the nesting is flattened to a single list by a depth-first traversal.
+  /// The children count is used to construct the nested relationship.
+  /// This field is not set when the element is a primitive type
+  pub num_children: Option<i32>,
+  /// DEPRECATED: When the schema is the result of a conversion from another model.
+  /// Used to record the original type to help with cross conversion.
+  /// 
+  /// This is superseded by logicalType.
+  pub converted_type: Option<ConvertedType>,
+  /// DEPRECATED: Used when this column contains decimal data.
+  /// See the DECIMAL converted type for more details.
+  /// 
+  /// This is superseded by using the DecimalType annotation in logicalType.
+  pub scale: Option<i32>,
+  pub precision: Option<i32>,
+  /// When the original schema supports field ids, this will save the
+  /// original field id in the parquet schema
+  pub field_id: Option<i32>,
+  /// The logical type of this SchemaElement
+  /// 
+  /// LogicalType replaces ConvertedType, but ConvertedType is still required
+  /// for some logical types to ensure forward-compatibility in format v1.
+  pub logical_type: Option<LogicalType>,
+}
+
+impl SchemaElement {
+  pub fn new<F1, F2, F3, F5, F6, F7, F8, F9, F10>(type_: F1, type_length: F2, repetition_type: F3, name: String, num_children: F5, converted_type: F6, scale: F7, precision: F8, field_id: F9, logical_type: F10) -> SchemaElement where F1: Into<Option<Type>>, F2: Into<Option<i32>>, F3: Into<Option<FieldRepetitionType>>, F5: Into<Option<i32>>, F6: Into<Option<ConvertedType>>, F7: Into<Option<i32>>, F8: Into<Option<i32>>, F9: Into<Option<i32>>, F10: Into<Option<LogicalType>> {
+    SchemaElement {
+      type_: type_.into(),
+      type_length: type_length.into(),
+      repetition_type: repetition_type.into(),
+      name,
+      num_children: num_children.into(),
+      converted_type: converted_type.into(),
+      scale: scale.into(),
+      precision: precision.into(),
+      field_id: field_id.into(),
+      logical_type: logical_type.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for SchemaElement {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<SchemaElement> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<Type> = None;
+    let mut f_2: Option<i32> = None;
+    let mut f_3: Option<FieldRepetitionType> = None;
+    let mut f_4: Option<String> = None;
+    let mut f_5: Option<i32> = None;
+    let mut f_6: Option<ConvertedType> = None;
+    let mut f_7: Option<i32> = None;
+    let mut f_8: Option<i32> = None;
+    let mut f_9: Option<i32> = None;
+    let mut f_10: Option<LogicalType> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = Type::read_from_in_protocol(i_prot)?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_i32()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = FieldRepetitionType::read_from_in_protocol(i_prot)?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let val = i_prot.read_string()?;
+          f_4 = Some(val);
+        },
+        5 => {
+          let val = i_prot.read_i32()?;
+          f_5 = Some(val);
+        },
+        6 => {
+          let val = ConvertedType::read_from_in_protocol(i_prot)?;
+          f_6 = Some(val);
+        },
+        7 => {
+          let val = i_prot.read_i32()?;
+          f_7 = Some(val);
+        },
+        8 => {
+          let val = i_prot.read_i32()?;
+          f_8 = Some(val);
+        },
+        9 => {
+          let val = i_prot.read_i32()?;
+          f_9 = Some(val);
+        },
+        10 => {
+          let val = LogicalType::read_from_in_protocol(i_prot)?;
+          f_10 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("SchemaElement.name", &f_4)?;
+    let ret = SchemaElement {
+      type_: f_1,
+      type_length: f_2,
+      repetition_type: f_3,
+      name: f_4.expect("auto-generated code should have checked for presence of required fields"),
+      num_children: f_5,
+      converted_type: f_6,
+      scale: f_7,
+      precision: f_8,
+      field_id: f_9,
+      logical_type: f_10,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("SchemaElement");
+    o_prot.write_struct_begin(&struct_ident)?;
+    if let Some(ref fld_var) = self.type_ {
+      o_prot.write_field_begin(&TFieldIdentifier::new("type", TType::I32, 1))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.type_length {
+      o_prot.write_field_begin(&TFieldIdentifier::new("type_length", TType::I32, 2))?;
+      o_prot.write_i32(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.repetition_type {
+      o_prot.write_field_begin(&TFieldIdentifier::new("repetition_type", TType::I32, 3))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_begin(&TFieldIdentifier::new("name", TType::String, 4))?;
+    o_prot.write_string(&self.name)?;
+    o_prot.write_field_end()?;
+    if let Some(fld_var) = self.num_children {
+      o_prot.write_field_begin(&TFieldIdentifier::new("num_children", TType::I32, 5))?;
+      o_prot.write_i32(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.converted_type {
+      o_prot.write_field_begin(&TFieldIdentifier::new("converted_type", TType::I32, 6))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.scale {
+      o_prot.write_field_begin(&TFieldIdentifier::new("scale", TType::I32, 7))?;
+      o_prot.write_i32(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.precision {
+      o_prot.write_field_begin(&TFieldIdentifier::new("precision", TType::I32, 8))?;
+      o_prot.write_i32(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.field_id {
+      o_prot.write_field_begin(&TFieldIdentifier::new("field_id", TType::I32, 9))?;
+      o_prot.write_i32(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.logical_type {
+      o_prot.write_field_begin(&TFieldIdentifier::new("logicalType", TType::Struct, 10))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// DataPageHeader
+//
+
+/// Data page header
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct DataPageHeader {
+  /// Number of values, including NULLs, in this data page. *
+  pub num_values: i32,
+  /// Encoding used for this data page *
+  pub encoding: Encoding,
+  /// Encoding used for definition levels *
+  pub definition_level_encoding: Encoding,
+  /// Encoding used for repetition levels *
+  pub repetition_level_encoding: Encoding,
+  /// Optional statistics for the data in this page*
+  pub statistics: Option<Statistics>,
+}
+
+impl DataPageHeader {
+  pub fn new<F5>(num_values: i32, encoding: Encoding, definition_level_encoding: Encoding, repetition_level_encoding: Encoding, statistics: F5) -> DataPageHeader where F5: Into<Option<Statistics>> {
+    DataPageHeader {
+      num_values,
+      encoding,
+      definition_level_encoding,
+      repetition_level_encoding,
+      statistics: statistics.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for DataPageHeader {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<DataPageHeader> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<i32> = None;
+    let mut f_2: Option<Encoding> = None;
+    let mut f_3: Option<Encoding> = None;
+    let mut f_4: Option<Encoding> = None;
+    let mut f_5: Option<Statistics> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_i32()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = Encoding::read_from_in_protocol(i_prot)?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = Encoding::read_from_in_protocol(i_prot)?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let val = Encoding::read_from_in_protocol(i_prot)?;
+          f_4 = Some(val);
+        },
+        5 => {
+          let val = Statistics::read_from_in_protocol(i_prot)?;
+          f_5 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("DataPageHeader.num_values", &f_1)?;
+    verify_required_field_exists("DataPageHeader.encoding", &f_2)?;
+    verify_required_field_exists("DataPageHeader.definition_level_encoding", &f_3)?;
+    verify_required_field_exists("DataPageHeader.repetition_level_encoding", &f_4)?;
+    let ret = DataPageHeader {
+      num_values: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      encoding: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      definition_level_encoding: f_3.expect("auto-generated code should have checked for presence of required fields"),
+      repetition_level_encoding: f_4.expect("auto-generated code should have checked for presence of required fields"),
+      statistics: f_5,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("DataPageHeader");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("num_values", TType::I32, 1))?;
+    o_prot.write_i32(self.num_values)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("encoding", TType::I32, 2))?;
+    self.encoding.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("definition_level_encoding", TType::I32, 3))?;
+    self.definition_level_encoding.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("repetition_level_encoding", TType::I32, 4))?;
+    self.repetition_level_encoding.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    if let Some(ref fld_var) = self.statistics {
+      o_prot.write_field_begin(&TFieldIdentifier::new("statistics", TType::Struct, 5))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// IndexPageHeader
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct IndexPageHeader {
+}
+
+impl IndexPageHeader {
+  pub fn new() -> IndexPageHeader {
+    IndexPageHeader {}
+  }
+}
+
+impl crate::thrift::TSerializable for IndexPageHeader {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<IndexPageHeader> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = IndexPageHeader {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("IndexPageHeader");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// DictionaryPageHeader
+//
+
+/// The dictionary page must be placed at the first position of the column chunk
+/// if it is partly or completely dictionary encoded. At most one dictionary page
+/// can be placed in a column chunk.
+/// 
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct DictionaryPageHeader {
+  /// Number of values in the dictionary *
+  pub num_values: i32,
+  /// Encoding using this dictionary page *
+  pub encoding: Encoding,
+  /// If true, the entries in the dictionary are sorted in ascending order *
+  pub is_sorted: Option<bool>,
+}
+
+impl DictionaryPageHeader {
+  pub fn new<F3>(num_values: i32, encoding: Encoding, is_sorted: F3) -> DictionaryPageHeader where F3: Into<Option<bool>> {
+    DictionaryPageHeader {
+      num_values,
+      encoding,
+      is_sorted: is_sorted.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for DictionaryPageHeader {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<DictionaryPageHeader> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<i32> = None;
+    let mut f_2: Option<Encoding> = None;
+    let mut f_3: Option<bool> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_i32()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = Encoding::read_from_in_protocol(i_prot)?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_bool()?;
+          f_3 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("DictionaryPageHeader.num_values", &f_1)?;
+    verify_required_field_exists("DictionaryPageHeader.encoding", &f_2)?;
+    let ret = DictionaryPageHeader {
+      num_values: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      encoding: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      is_sorted: f_3,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("DictionaryPageHeader");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("num_values", TType::I32, 1))?;
+    o_prot.write_i32(self.num_values)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("encoding", TType::I32, 2))?;
+    self.encoding.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    if let Some(fld_var) = self.is_sorted {
+      o_prot.write_field_begin(&TFieldIdentifier::new("is_sorted", TType::Bool, 3))?;
+      o_prot.write_bool(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// DataPageHeaderV2
+//
+
+/// New page format allowing reading levels without decompressing the data
+/// Repetition and definition levels are uncompressed
+/// The remaining section containing the data is compressed if is_compressed is true
+/// 
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct DataPageHeaderV2 {
+  /// Number of values, including NULLs, in this data page. *
+  pub num_values: i32,
+  /// Number of NULL values, in this data page.
+  /// Number of non-null = num_values - num_nulls which is also the number of values in the data section *
+  pub num_nulls: i32,
+  /// Number of rows in this data page. which means pages change on record boundaries (r = 0) *
+  pub num_rows: i32,
+  /// Encoding used for data in this page *
+  pub encoding: Encoding,
+  /// length of the definition levels
+  pub definition_levels_byte_length: i32,
+  /// length of the repetition levels
+  pub repetition_levels_byte_length: i32,
+  /// whether the values are compressed.
+  /// Which means the section of the page between
+  /// definition_levels_byte_length + repetition_levels_byte_length + 1 and compressed_page_size (included)
+  /// is compressed with the compression_codec.
+  /// If missing it is considered compressed
+  pub is_compressed: Option<bool>,
+  /// optional statistics for the data in this page *
+  pub statistics: Option<Statistics>,
+}
+
+impl DataPageHeaderV2 {
+  pub fn new<F7, F8>(num_values: i32, num_nulls: i32, num_rows: i32, encoding: Encoding, definition_levels_byte_length: i32, repetition_levels_byte_length: i32, is_compressed: F7, statistics: F8) -> DataPageHeaderV2 where F7: Into<Option<bool>>, F8: Into<Option<Statistics>> {
+    DataPageHeaderV2 {
+      num_values,
+      num_nulls,
+      num_rows,
+      encoding,
+      definition_levels_byte_length,
+      repetition_levels_byte_length,
+      is_compressed: is_compressed.into(),
+      statistics: statistics.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for DataPageHeaderV2 {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<DataPageHeaderV2> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<i32> = None;
+    let mut f_2: Option<i32> = None;
+    let mut f_3: Option<i32> = None;
+    let mut f_4: Option<Encoding> = None;
+    let mut f_5: Option<i32> = None;
+    let mut f_6: Option<i32> = None;
+    let mut f_7: Option<bool> = None;
+    let mut f_8: Option<Statistics> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_i32()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_i32()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_i32()?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let val = Encoding::read_from_in_protocol(i_prot)?;
+          f_4 = Some(val);
+        },
+        5 => {
+          let val = i_prot.read_i32()?;
+          f_5 = Some(val);
+        },
+        6 => {
+          let val = i_prot.read_i32()?;
+          f_6 = Some(val);
+        },
+        7 => {
+          let val = i_prot.read_bool()?;
+          f_7 = Some(val);
+        },
+        8 => {
+          let val = Statistics::read_from_in_protocol(i_prot)?;
+          f_8 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("DataPageHeaderV2.num_values", &f_1)?;
+    verify_required_field_exists("DataPageHeaderV2.num_nulls", &f_2)?;
+    verify_required_field_exists("DataPageHeaderV2.num_rows", &f_3)?;
+    verify_required_field_exists("DataPageHeaderV2.encoding", &f_4)?;
+    verify_required_field_exists("DataPageHeaderV2.definition_levels_byte_length", &f_5)?;
+    verify_required_field_exists("DataPageHeaderV2.repetition_levels_byte_length", &f_6)?;
+    let ret = DataPageHeaderV2 {
+      num_values: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      num_nulls: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      num_rows: f_3.expect("auto-generated code should have checked for presence of required fields"),
+      encoding: f_4.expect("auto-generated code should have checked for presence of required fields"),
+      definition_levels_byte_length: f_5.expect("auto-generated code should have checked for presence of required fields"),
+      repetition_levels_byte_length: f_6.expect("auto-generated code should have checked for presence of required fields"),
+      is_compressed: f_7,
+      statistics: f_8,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("DataPageHeaderV2");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("num_values", TType::I32, 1))?;
+    o_prot.write_i32(self.num_values)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("num_nulls", TType::I32, 2))?;
+    o_prot.write_i32(self.num_nulls)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("num_rows", TType::I32, 3))?;
+    o_prot.write_i32(self.num_rows)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("encoding", TType::I32, 4))?;
+    self.encoding.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("definition_levels_byte_length", TType::I32, 5))?;
+    o_prot.write_i32(self.definition_levels_byte_length)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("repetition_levels_byte_length", TType::I32, 6))?;
+    o_prot.write_i32(self.repetition_levels_byte_length)?;
+    o_prot.write_field_end()?;
+    if let Some(fld_var) = self.is_compressed {
+      o_prot.write_field_begin(&TFieldIdentifier::new("is_compressed", TType::Bool, 7))?;
+      o_prot.write_bool(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.statistics {
+      o_prot.write_field_begin(&TFieldIdentifier::new("statistics", TType::Struct, 8))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// SplitBlockAlgorithm
+//
+
+/// Block-based algorithm type annotation. *
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct SplitBlockAlgorithm {
+}
+
+impl SplitBlockAlgorithm {
+  pub fn new() -> SplitBlockAlgorithm {
+    SplitBlockAlgorithm {}
+  }
+}
+
+impl crate::thrift::TSerializable for SplitBlockAlgorithm {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<SplitBlockAlgorithm> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = SplitBlockAlgorithm {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("SplitBlockAlgorithm");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// BloomFilterAlgorithm
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum BloomFilterAlgorithm {
+  BLOCK(SplitBlockAlgorithm),
+}
+
+impl crate::thrift::TSerializable for BloomFilterAlgorithm {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BloomFilterAlgorithm> {
+    let mut ret: Option<BloomFilterAlgorithm> = None;
+    let mut received_field_count = 0;
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = SplitBlockAlgorithm::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(BloomFilterAlgorithm::BLOCK(val));
+          }
+          received_field_count += 1;
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+          received_field_count += 1;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    if received_field_count == 0 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received empty union from remote BloomFilterAlgorithm"
+          )
+        )
+      )
+    } else if received_field_count > 1 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received multiple fields for union from remote BloomFilterAlgorithm"
+          )
+        )
+      )
+    } else {
+      ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
+    }
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("BloomFilterAlgorithm");
+    o_prot.write_struct_begin(&struct_ident)?;
+    match *self {
+      BloomFilterAlgorithm::BLOCK(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("BLOCK", TType::Struct, 1))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// XxHash
+//
+
+/// Hash strategy type annotation. xxHash is an extremely fast non-cryptographic hash
+/// algorithm. It uses 64 bits version of xxHash.
+/// 
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct XxHash {
+}
+
+impl XxHash {
+  pub fn new() -> XxHash {
+    XxHash {}
+  }
+}
+
+impl crate::thrift::TSerializable for XxHash {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<XxHash> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = XxHash {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("XxHash");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// BloomFilterHash
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum BloomFilterHash {
+  XXHASH(XxHash),
+}
+
+impl crate::thrift::TSerializable for BloomFilterHash {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BloomFilterHash> {
+    let mut ret: Option<BloomFilterHash> = None;
+    let mut received_field_count = 0;
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = XxHash::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(BloomFilterHash::XXHASH(val));
+          }
+          received_field_count += 1;
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+          received_field_count += 1;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    if received_field_count == 0 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received empty union from remote BloomFilterHash"
+          )
+        )
+      )
+    } else if received_field_count > 1 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received multiple fields for union from remote BloomFilterHash"
+          )
+        )
+      )
+    } else {
+      ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
+    }
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("BloomFilterHash");
+    o_prot.write_struct_begin(&struct_ident)?;
+    match *self {
+      BloomFilterHash::XXHASH(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("XXHASH", TType::Struct, 1))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// Uncompressed
+//
+
+/// The compression used in the Bloom filter.
+/// 
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct Uncompressed {
+}
+
+impl Uncompressed {
+  pub fn new() -> Uncompressed {
+    Uncompressed {}
+  }
+}
+
+impl crate::thrift::TSerializable for Uncompressed {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Uncompressed> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = Uncompressed {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("Uncompressed");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// BloomFilterCompression
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum BloomFilterCompression {
+  UNCOMPRESSED(Uncompressed),
+}
+
+impl crate::thrift::TSerializable for BloomFilterCompression {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BloomFilterCompression> {
+    let mut ret: Option<BloomFilterCompression> = None;
+    let mut received_field_count = 0;
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = Uncompressed::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(BloomFilterCompression::UNCOMPRESSED(val));
+          }
+          received_field_count += 1;
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+          received_field_count += 1;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    if received_field_count == 0 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received empty union from remote BloomFilterCompression"
+          )
+        )
+      )
+    } else if received_field_count > 1 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received multiple fields for union from remote BloomFilterCompression"
+          )
+        )
+      )
+    } else {
+      ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
+    }
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("BloomFilterCompression");
+    o_prot.write_struct_begin(&struct_ident)?;
+    match *self {
+      BloomFilterCompression::UNCOMPRESSED(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("UNCOMPRESSED", TType::Struct, 1))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// BloomFilterHeader
+//
+
+/// Bloom filter header is stored at beginning of Bloom filter data of each column
+/// and followed by its bitset.
+/// 
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct BloomFilterHeader {
+  /// The size of bitset in bytes *
+  pub num_bytes: i32,
+  /// The algorithm for setting bits. *
+  pub algorithm: BloomFilterAlgorithm,
+  /// The hash function used for Bloom filter. *
+  pub hash: BloomFilterHash,
+  /// The compression used in the Bloom filter *
+  pub compression: BloomFilterCompression,
+}
+
+impl BloomFilterHeader {
+  pub fn new(num_bytes: i32, algorithm: BloomFilterAlgorithm, hash: BloomFilterHash, compression: BloomFilterCompression) -> BloomFilterHeader {
+    BloomFilterHeader {
+      num_bytes,
+      algorithm,
+      hash,
+      compression,
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for BloomFilterHeader {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<BloomFilterHeader> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<i32> = None;
+    let mut f_2: Option<BloomFilterAlgorithm> = None;
+    let mut f_3: Option<BloomFilterHash> = None;
+    let mut f_4: Option<BloomFilterCompression> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_i32()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = BloomFilterAlgorithm::read_from_in_protocol(i_prot)?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = BloomFilterHash::read_from_in_protocol(i_prot)?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let val = BloomFilterCompression::read_from_in_protocol(i_prot)?;
+          f_4 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("BloomFilterHeader.num_bytes", &f_1)?;
+    verify_required_field_exists("BloomFilterHeader.algorithm", &f_2)?;
+    verify_required_field_exists("BloomFilterHeader.hash", &f_3)?;
+    verify_required_field_exists("BloomFilterHeader.compression", &f_4)?;
+    let ret = BloomFilterHeader {
+      num_bytes: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      algorithm: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      hash: f_3.expect("auto-generated code should have checked for presence of required fields"),
+      compression: f_4.expect("auto-generated code should have checked for presence of required fields"),
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("BloomFilterHeader");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("numBytes", TType::I32, 1))?;
+    o_prot.write_i32(self.num_bytes)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("algorithm", TType::Struct, 2))?;
+    self.algorithm.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("hash", TType::Struct, 3))?;
+    self.hash.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("compression", TType::Struct, 4))?;
+    self.compression.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// PageHeader
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct PageHeader {
+  /// the type of the page: indicates which of the *_header fields is set *
+  pub type_: PageType,
+  /// Uncompressed page size in bytes (not including this header) *
+  pub uncompressed_page_size: i32,
+  /// Compressed (and potentially encrypted) page size in bytes, not including this header *
+  pub compressed_page_size: i32,
+  /// The 32-bit CRC checksum for the page, to be be calculated as follows:
+  /// 
+  /// - The standard CRC32 algorithm is used (with polynomial 0x04C11DB7,
+  ///   the same as in e.g. GZip).
+  /// - All page types can have a CRC (v1 and v2 data pages, dictionary pages,
+  ///   etc.).
+  /// - The CRC is computed on the serialization binary representation of the page
+  ///   (as written to disk), excluding the page header. For example, for v1
+  ///   data pages, the CRC is computed on the concatenation of repetition levels,
+  ///   definition levels and column values (optionally compressed, optionally
+  ///   encrypted).
+  /// - The CRC computation therefore takes place after any compression
+  ///   and encryption steps, if any.
+  /// 
+  /// If enabled, this allows for disabling checksumming in HDFS if only a few
+  /// pages need to be read.
+  pub crc: Option<i32>,
+  pub data_page_header: Option<DataPageHeader>,
+  pub index_page_header: Option<IndexPageHeader>,
+  pub dictionary_page_header: Option<DictionaryPageHeader>,
+  pub data_page_header_v2: Option<DataPageHeaderV2>,
+}
+
+impl PageHeader {
+  pub fn new<F4, F5, F6, F7, F8>(type_: PageType, uncompressed_page_size: i32, compressed_page_size: i32, crc: F4, data_page_header: F5, index_page_header: F6, dictionary_page_header: F7, data_page_header_v2: F8) -> PageHeader where F4: Into<Option<i32>>, F5: Into<Option<DataPageHeader>>, F6: Into<Option<IndexPageHeader>>, F7: Into<Option<DictionaryPageHeader>>, F8: Into<Option<DataPageHeaderV2>> {
+    PageHeader {
+      type_,
+      uncompressed_page_size,
+      compressed_page_size,
+      crc: crc.into(),
+      data_page_header: data_page_header.into(),
+      index_page_header: index_page_header.into(),
+      dictionary_page_header: dictionary_page_header.into(),
+      data_page_header_v2: data_page_header_v2.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for PageHeader {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<PageHeader> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<PageType> = None;
+    let mut f_2: Option<i32> = None;
+    let mut f_3: Option<i32> = None;
+    let mut f_4: Option<i32> = None;
+    let mut f_5: Option<DataPageHeader> = None;
+    let mut f_6: Option<IndexPageHeader> = None;
+    let mut f_7: Option<DictionaryPageHeader> = None;
+    let mut f_8: Option<DataPageHeaderV2> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = PageType::read_from_in_protocol(i_prot)?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_i32()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_i32()?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let val = i_prot.read_i32()?;
+          f_4 = Some(val);
+        },
+        5 => {
+          let val = DataPageHeader::read_from_in_protocol(i_prot)?;
+          f_5 = Some(val);
+        },
+        6 => {
+          let val = IndexPageHeader::read_from_in_protocol(i_prot)?;
+          f_6 = Some(val);
+        },
+        7 => {
+          let val = DictionaryPageHeader::read_from_in_protocol(i_prot)?;
+          f_7 = Some(val);
+        },
+        8 => {
+          let val = DataPageHeaderV2::read_from_in_protocol(i_prot)?;
+          f_8 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("PageHeader.type_", &f_1)?;
+    verify_required_field_exists("PageHeader.uncompressed_page_size", &f_2)?;
+    verify_required_field_exists("PageHeader.compressed_page_size", &f_3)?;
+    let ret = PageHeader {
+      type_: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      uncompressed_page_size: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      compressed_page_size: f_3.expect("auto-generated code should have checked for presence of required fields"),
+      crc: f_4,
+      data_page_header: f_5,
+      index_page_header: f_6,
+      dictionary_page_header: f_7,
+      data_page_header_v2: f_8,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("PageHeader");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("type", TType::I32, 1))?;
+    self.type_.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("uncompressed_page_size", TType::I32, 2))?;
+    o_prot.write_i32(self.uncompressed_page_size)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("compressed_page_size", TType::I32, 3))?;
+    o_prot.write_i32(self.compressed_page_size)?;
+    o_prot.write_field_end()?;
+    if let Some(fld_var) = self.crc {
+      o_prot.write_field_begin(&TFieldIdentifier::new("crc", TType::I32, 4))?;
+      o_prot.write_i32(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.data_page_header {
+      o_prot.write_field_begin(&TFieldIdentifier::new("data_page_header", TType::Struct, 5))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.index_page_header {
+      o_prot.write_field_begin(&TFieldIdentifier::new("index_page_header", TType::Struct, 6))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.dictionary_page_header {
+      o_prot.write_field_begin(&TFieldIdentifier::new("dictionary_page_header", TType::Struct, 7))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.data_page_header_v2 {
+      o_prot.write_field_begin(&TFieldIdentifier::new("data_page_header_v2", TType::Struct, 8))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// KeyValue
+//
+
+/// Wrapper struct to store key values
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct KeyValue {
+  pub key: String,
+  pub value: Option<String>,
+}
+
+impl KeyValue {
+  pub fn new<F2>(key: String, value: F2) -> KeyValue where F2: Into<Option<String>> {
+    KeyValue {
+      key,
+      value: value.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for KeyValue {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<KeyValue> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<String> = None;
+    let mut f_2: Option<String> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_string()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_string()?;
+          f_2 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("KeyValue.key", &f_1)?;
+    let ret = KeyValue {
+      key: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      value: f_2,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("KeyValue");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("key", TType::String, 1))?;
+    o_prot.write_string(&self.key)?;
+    o_prot.write_field_end()?;
+    if let Some(ref fld_var) = self.value {
+      o_prot.write_field_begin(&TFieldIdentifier::new("value", TType::String, 2))?;
+      o_prot.write_string(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// SortingColumn
+//
+
+/// Wrapper struct to specify sort order
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct SortingColumn {
+  /// The column index (in this row group) *
+  pub column_idx: i32,
+  /// If true, indicates this column is sorted in descending order. *
+  pub descending: bool,
+  /// If true, nulls will come before non-null values, otherwise,
+  /// nulls go at the end.
+  pub nulls_first: bool,
+}
+
+impl SortingColumn {
+  pub fn new(column_idx: i32, descending: bool, nulls_first: bool) -> SortingColumn {
+    SortingColumn {
+      column_idx,
+      descending,
+      nulls_first,
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for SortingColumn {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<SortingColumn> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<i32> = None;
+    let mut f_2: Option<bool> = None;
+    let mut f_3: Option<bool> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_i32()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_bool()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_bool()?;
+          f_3 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("SortingColumn.column_idx", &f_1)?;
+    verify_required_field_exists("SortingColumn.descending", &f_2)?;
+    verify_required_field_exists("SortingColumn.nulls_first", &f_3)?;
+    let ret = SortingColumn {
+      column_idx: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      descending: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      nulls_first: f_3.expect("auto-generated code should have checked for presence of required fields"),
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("SortingColumn");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("column_idx", TType::I32, 1))?;
+    o_prot.write_i32(self.column_idx)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("descending", TType::Bool, 2))?;
+    o_prot.write_bool(self.descending)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("nulls_first", TType::Bool, 3))?;
+    o_prot.write_bool(self.nulls_first)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// PageEncodingStats
+//
+
+/// statistics of a given page type and encoding
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct PageEncodingStats {
+  /// the page type (data/dic/...) *
+  pub page_type: PageType,
+  /// encoding of the page *
+  pub encoding: Encoding,
+  /// number of pages of this type with this encoding *
+  pub count: i32,
+}
+
+impl PageEncodingStats {
+  pub fn new(page_type: PageType, encoding: Encoding, count: i32) -> PageEncodingStats {
+    PageEncodingStats {
+      page_type,
+      encoding,
+      count,
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for PageEncodingStats {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<PageEncodingStats> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<PageType> = None;
+    let mut f_2: Option<Encoding> = None;
+    let mut f_3: Option<i32> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = PageType::read_from_in_protocol(i_prot)?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = Encoding::read_from_in_protocol(i_prot)?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_i32()?;
+          f_3 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("PageEncodingStats.page_type", &f_1)?;
+    verify_required_field_exists("PageEncodingStats.encoding", &f_2)?;
+    verify_required_field_exists("PageEncodingStats.count", &f_3)?;
+    let ret = PageEncodingStats {
+      page_type: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      encoding: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      count: f_3.expect("auto-generated code should have checked for presence of required fields"),
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("PageEncodingStats");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("page_type", TType::I32, 1))?;
+    self.page_type.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("encoding", TType::I32, 2))?;
+    self.encoding.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("count", TType::I32, 3))?;
+    o_prot.write_i32(self.count)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// ColumnMetaData
+//
+
+/// Description for column metadata
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ColumnMetaData {
+  /// Type of this column *
+  pub type_: Type,
+  /// Set of all encodings used for this column. The purpose is to validate
+  /// whether we can decode those pages. *
+  pub encodings: Vec<Encoding>,
+  /// Path in schema *
+  pub path_in_schema: Vec<String>,
+  /// Compression codec *
+  pub codec: CompressionCodec,
+  /// Number of values in this column *
+  pub num_values: i64,
+  /// total byte size of all uncompressed pages in this column chunk (including the headers) *
+  pub total_uncompressed_size: i64,
+  /// total byte size of all compressed, and potentially encrypted, pages
+  /// in this column chunk (including the headers) *
+  pub total_compressed_size: i64,
+  /// Optional key/value metadata *
+  pub key_value_metadata: Option<Vec<KeyValue>>,
+  /// Byte offset from beginning of file to first data page *
+  pub data_page_offset: i64,
+  /// Byte offset from beginning of file to root index page *
+  pub index_page_offset: Option<i64>,
+  /// Byte offset from the beginning of file to first (only) dictionary page *
+  pub dictionary_page_offset: Option<i64>,
+  /// optional statistics for this column chunk
+  pub statistics: Option<Statistics>,
+  /// Set of all encodings used for pages in this column chunk.
+  /// This information can be used to determine if all data pages are
+  /// dictionary encoded for example *
+  pub encoding_stats: Option<Vec<PageEncodingStats>>,
+  /// Byte offset from beginning of file to Bloom filter data. *
+  pub bloom_filter_offset: Option<i64>,
+  /// Size of Bloom filter data including the serialized header, in bytes.
+  /// Added in 2.10 so readers may not read this field from old files and
+  /// it can be obtained after the BloomFilterHeader has been deserialized.
+  /// Writers should write this field so readers can read the bloom filter
+  /// in a single I/O.
+  pub bloom_filter_length: Option<i32>,
+}
+
+impl ColumnMetaData {
+  pub fn new<F8, F10, F11, F12, F13, F14, F15>(type_: Type, encodings: Vec<Encoding>, path_in_schema: Vec<String>, codec: CompressionCodec, num_values: i64, total_uncompressed_size: i64, total_compressed_size: i64, key_value_metadata: F8, data_page_offset: i64, index_page_offset: F10, dictionary_page_offset: F11, statistics: F12, encoding_stats: F13, bloom_filter_offset: F14, bloom_filter_length: F15) -> ColumnMetaData where F8: Into<Option<Vec<KeyValue>>>, F10: Into<Option<i64>>, F11: Into<Option<i64>>, F12: Into<Option<Statistics>>, F13: Into<Option<Vec<PageEncodingStats>>>, F14: Into<Option<i64>>, F15: Into<Option<i32>> {
+    ColumnMetaData {
+      type_,
+      encodings,
+      path_in_schema,
+      codec,
+      num_values,
+      total_uncompressed_size,
+      total_compressed_size,
+      key_value_metadata: key_value_metadata.into(),
+      data_page_offset,
+      index_page_offset: index_page_offset.into(),
+      dictionary_page_offset: dictionary_page_offset.into(),
+      statistics: statistics.into(),
+      encoding_stats: encoding_stats.into(),
+      bloom_filter_offset: bloom_filter_offset.into(),
+      bloom_filter_length: bloom_filter_length.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for ColumnMetaData {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ColumnMetaData> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<Type> = None;
+    let mut f_2: Option<Vec<Encoding>> = None;
+    let mut f_3: Option<Vec<String>> = None;
+    let mut f_4: Option<CompressionCodec> = None;
+    let mut f_5: Option<i64> = None;
+    let mut f_6: Option<i64> = None;
+    let mut f_7: Option<i64> = None;
+    let mut f_8: Option<Vec<KeyValue>> = None;
+    let mut f_9: Option<i64> = None;
+    let mut f_10: Option<i64> = None;
+    let mut f_11: Option<i64> = None;
+    let mut f_12: Option<Statistics> = None;
+    let mut f_13: Option<Vec<PageEncodingStats>> = None;
+    let mut f_14: Option<i64> = None;
+    let mut f_15: Option<i32> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = Type::read_from_in_protocol(i_prot)?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<Encoding> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_0 = Encoding::read_from_in_protocol(i_prot)?;
+            val.push(list_elem_0);
+          }
+          i_prot.read_list_end()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<String> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_1 = i_prot.read_string()?;
+            val.push(list_elem_1);
+          }
+          i_prot.read_list_end()?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let val = CompressionCodec::read_from_in_protocol(i_prot)?;
+          f_4 = Some(val);
+        },
+        5 => {
+          let val = i_prot.read_i64()?;
+          f_5 = Some(val);
+        },
+        6 => {
+          let val = i_prot.read_i64()?;
+          f_6 = Some(val);
+        },
+        7 => {
+          let val = i_prot.read_i64()?;
+          f_7 = Some(val);
+        },
+        8 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<KeyValue> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_2 = KeyValue::read_from_in_protocol(i_prot)?;
+            val.push(list_elem_2);
+          }
+          i_prot.read_list_end()?;
+          f_8 = Some(val);
+        },
+        9 => {
+          let val = i_prot.read_i64()?;
+          f_9 = Some(val);
+        },
+        10 => {
+          let val = i_prot.read_i64()?;
+          f_10 = Some(val);
+        },
+        11 => {
+          let val = i_prot.read_i64()?;
+          f_11 = Some(val);
+        },
+        12 => {
+          let val = Statistics::read_from_in_protocol(i_prot)?;
+          f_12 = Some(val);
+        },
+        13 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<PageEncodingStats> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_3 = PageEncodingStats::read_from_in_protocol(i_prot)?;
+            val.push(list_elem_3);
+          }
+          i_prot.read_list_end()?;
+          f_13 = Some(val);
+        },
+        14 => {
+          let val = i_prot.read_i64()?;
+          f_14 = Some(val);
+        },
+        15 => {
+          let val = i_prot.read_i32()?;
+          f_15 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("ColumnMetaData.type_", &f_1)?;
+    verify_required_field_exists("ColumnMetaData.encodings", &f_2)?;
+    verify_required_field_exists("ColumnMetaData.path_in_schema", &f_3)?;
+    verify_required_field_exists("ColumnMetaData.codec", &f_4)?;
+    verify_required_field_exists("ColumnMetaData.num_values", &f_5)?;
+    verify_required_field_exists("ColumnMetaData.total_uncompressed_size", &f_6)?;
+    verify_required_field_exists("ColumnMetaData.total_compressed_size", &f_7)?;
+    verify_required_field_exists("ColumnMetaData.data_page_offset", &f_9)?;
+    let ret = ColumnMetaData {
+      type_: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      encodings: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      path_in_schema: f_3.expect("auto-generated code should have checked for presence of required fields"),
+      codec: f_4.expect("auto-generated code should have checked for presence of required fields"),
+      num_values: f_5.expect("auto-generated code should have checked for presence of required fields"),
+      total_uncompressed_size: f_6.expect("auto-generated code should have checked for presence of required fields"),
+      total_compressed_size: f_7.expect("auto-generated code should have checked for presence of required fields"),
+      key_value_metadata: f_8,
+      data_page_offset: f_9.expect("auto-generated code should have checked for presence of required fields"),
+      index_page_offset: f_10,
+      dictionary_page_offset: f_11,
+      statistics: f_12,
+      encoding_stats: f_13,
+      bloom_filter_offset: f_14,
+      bloom_filter_length: f_15,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("ColumnMetaData");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("type", TType::I32, 1))?;
+    self.type_.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("encodings", TType::List, 2))?;
+    o_prot.write_list_begin(&TListIdentifier::new(TType::I32, self.encodings.len() as i32))?;
+    for e in &self.encodings {
+      e.write_to_out_protocol(o_prot)?;
+    }
+    o_prot.write_list_end()?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("path_in_schema", TType::List, 3))?;
+    o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.path_in_schema.len() as i32))?;
+    for e in &self.path_in_schema {
+      o_prot.write_string(e)?;
+    }
+    o_prot.write_list_end()?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("codec", TType::I32, 4))?;
+    self.codec.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("num_values", TType::I64, 5))?;
+    o_prot.write_i64(self.num_values)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("total_uncompressed_size", TType::I64, 6))?;
+    o_prot.write_i64(self.total_uncompressed_size)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("total_compressed_size", TType::I64, 7))?;
+    o_prot.write_i64(self.total_compressed_size)?;
+    o_prot.write_field_end()?;
+    if let Some(ref fld_var) = self.key_value_metadata {
+      o_prot.write_field_begin(&TFieldIdentifier::new("key_value_metadata", TType::List, 8))?;
+      o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
+      for e in fld_var {
+        e.write_to_out_protocol(o_prot)?;
+      }
+      o_prot.write_list_end()?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_begin(&TFieldIdentifier::new("data_page_offset", TType::I64, 9))?;
+    o_prot.write_i64(self.data_page_offset)?;
+    o_prot.write_field_end()?;
+    if let Some(fld_var) = self.index_page_offset {
+      o_prot.write_field_begin(&TFieldIdentifier::new("index_page_offset", TType::I64, 10))?;
+      o_prot.write_i64(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.dictionary_page_offset {
+      o_prot.write_field_begin(&TFieldIdentifier::new("dictionary_page_offset", TType::I64, 11))?;
+      o_prot.write_i64(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.statistics {
+      o_prot.write_field_begin(&TFieldIdentifier::new("statistics", TType::Struct, 12))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.encoding_stats {
+      o_prot.write_field_begin(&TFieldIdentifier::new("encoding_stats", TType::List, 13))?;
+      o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
+      for e in fld_var {
+        e.write_to_out_protocol(o_prot)?;
+      }
+      o_prot.write_list_end()?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.bloom_filter_offset {
+      o_prot.write_field_begin(&TFieldIdentifier::new("bloom_filter_offset", TType::I64, 14))?;
+      o_prot.write_i64(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.bloom_filter_length {
+      o_prot.write_field_begin(&TFieldIdentifier::new("bloom_filter_length", TType::I32, 15))?;
+      o_prot.write_i32(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// EncryptionWithFooterKey
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct EncryptionWithFooterKey {
+}
+
+impl EncryptionWithFooterKey {
+  pub fn new() -> EncryptionWithFooterKey {
+    EncryptionWithFooterKey {}
+  }
+}
+
+impl crate::thrift::TSerializable for EncryptionWithFooterKey {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<EncryptionWithFooterKey> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = EncryptionWithFooterKey {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("EncryptionWithFooterKey");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// EncryptionWithColumnKey
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct EncryptionWithColumnKey {
+  /// Column path in schema *
+  pub path_in_schema: Vec<String>,
+  /// Retrieval metadata of column encryption key *
+  pub key_metadata: Option<Vec<u8>>,
+}
+
+impl EncryptionWithColumnKey {
+  pub fn new<F2>(path_in_schema: Vec<String>, key_metadata: F2) -> EncryptionWithColumnKey where F2: Into<Option<Vec<u8>>> {
+    EncryptionWithColumnKey {
+      path_in_schema,
+      key_metadata: key_metadata.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for EncryptionWithColumnKey {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<EncryptionWithColumnKey> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<Vec<String>> = None;
+    let mut f_2: Option<Vec<u8>> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<String> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_4 = i_prot.read_string()?;
+            val.push(list_elem_4);
+          }
+          i_prot.read_list_end()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_bytes()?;
+          f_2 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("EncryptionWithColumnKey.path_in_schema", &f_1)?;
+    let ret = EncryptionWithColumnKey {
+      path_in_schema: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      key_metadata: f_2,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("EncryptionWithColumnKey");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("path_in_schema", TType::List, 1))?;
+    o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.path_in_schema.len() as i32))?;
+    for e in &self.path_in_schema {
+      o_prot.write_string(e)?;
+    }
+    o_prot.write_list_end()?;
+    o_prot.write_field_end()?;
+    if let Some(ref fld_var) = self.key_metadata {
+      o_prot.write_field_begin(&TFieldIdentifier::new("key_metadata", TType::String, 2))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// ColumnCryptoMetaData
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum ColumnCryptoMetaData {
+  ENCRYPTIONWITHFOOTERKEY(EncryptionWithFooterKey),
+  ENCRYPTIONWITHCOLUMNKEY(EncryptionWithColumnKey),
+}
+
+impl crate::thrift::TSerializable for ColumnCryptoMetaData {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ColumnCryptoMetaData> {
+    let mut ret: Option<ColumnCryptoMetaData> = None;
+    let mut received_field_count = 0;
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = EncryptionWithFooterKey::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(ColumnCryptoMetaData::ENCRYPTIONWITHFOOTERKEY(val));
+          }
+          received_field_count += 1;
+        },
+        2 => {
+          let val = EncryptionWithColumnKey::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(ColumnCryptoMetaData::ENCRYPTIONWITHCOLUMNKEY(val));
+          }
+          received_field_count += 1;
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+          received_field_count += 1;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    if received_field_count == 0 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received empty union from remote ColumnCryptoMetaData"
+          )
+        )
+      )
+    } else if received_field_count > 1 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received multiple fields for union from remote ColumnCryptoMetaData"
+          )
+        )
+      )
+    } else {
+      ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
+    }
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("ColumnCryptoMetaData");
+    o_prot.write_struct_begin(&struct_ident)?;
+    match *self {
+      ColumnCryptoMetaData::ENCRYPTIONWITHFOOTERKEY(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("ENCRYPTION_WITH_FOOTER_KEY", TType::Struct, 1))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      ColumnCryptoMetaData::ENCRYPTIONWITHCOLUMNKEY(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("ENCRYPTION_WITH_COLUMN_KEY", TType::Struct, 2))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// ColumnChunk
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ColumnChunk {
+  /// File where column data is stored.  If not set, assumed to be same file as
+  /// metadata.  This path is relative to the current file.
+  /// 
+  pub file_path: Option<String>,
+  /// Byte offset in file_path to the ColumnMetaData *
+  pub file_offset: i64,
+  /// Column metadata for this chunk. This is the same content as what is at
+  /// file_path/file_offset.  Having it here has it replicated in the file
+  /// metadata.
+  /// 
+  pub meta_data: Option<ColumnMetaData>,
+  /// File offset of ColumnChunk's OffsetIndex *
+  pub offset_index_offset: Option<i64>,
+  /// Size of ColumnChunk's OffsetIndex, in bytes *
+  pub offset_index_length: Option<i32>,
+  /// File offset of ColumnChunk's ColumnIndex *
+  pub column_index_offset: Option<i64>,
+  /// Size of ColumnChunk's ColumnIndex, in bytes *
+  pub column_index_length: Option<i32>,
+  /// Crypto metadata of encrypted columns *
+  pub crypto_metadata: Option<ColumnCryptoMetaData>,
+  /// Encrypted column metadata for this chunk *
+  pub encrypted_column_metadata: Option<Vec<u8>>,
+}
+
+impl ColumnChunk {
+  pub fn new<F1, F3, F4, F5, F6, F7, F8, F9>(file_path: F1, file_offset: i64, meta_data: F3, offset_index_offset: F4, offset_index_length: F5, column_index_offset: F6, column_index_length: F7, crypto_metadata: F8, encrypted_column_metadata: F9) -> ColumnChunk where F1: Into<Option<String>>, F3: Into<Option<ColumnMetaData>>, F4: Into<Option<i64>>, F5: Into<Option<i32>>, F6: Into<Option<i64>>, F7: Into<Option<i32>>, F8: Into<Option<ColumnCryptoMetaData>>, F9: Into<Option<Vec<u8>>> {
+    ColumnChunk {
+      file_path: file_path.into(),
+      file_offset,
+      meta_data: meta_data.into(),
+      offset_index_offset: offset_index_offset.into(),
+      offset_index_length: offset_index_length.into(),
+      column_index_offset: column_index_offset.into(),
+      column_index_length: column_index_length.into(),
+      crypto_metadata: crypto_metadata.into(),
+      encrypted_column_metadata: encrypted_column_metadata.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for ColumnChunk {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ColumnChunk> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<String> = None;
+    let mut f_2: Option<i64> = None;
+    let mut f_3: Option<ColumnMetaData> = None;
+    let mut f_4: Option<i64> = None;
+    let mut f_5: Option<i32> = None;
+    let mut f_6: Option<i64> = None;
+    let mut f_7: Option<i32> = None;
+    let mut f_8: Option<ColumnCryptoMetaData> = None;
+    let mut f_9: Option<Vec<u8>> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_string()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_i64()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = ColumnMetaData::read_from_in_protocol(i_prot)?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let val = i_prot.read_i64()?;
+          f_4 = Some(val);
+        },
+        5 => {
+          let val = i_prot.read_i32()?;
+          f_5 = Some(val);
+        },
+        6 => {
+          let val = i_prot.read_i64()?;
+          f_6 = Some(val);
+        },
+        7 => {
+          let val = i_prot.read_i32()?;
+          f_7 = Some(val);
+        },
+        8 => {
+          let val = ColumnCryptoMetaData::read_from_in_protocol(i_prot)?;
+          f_8 = Some(val);
+        },
+        9 => {
+          let val = i_prot.read_bytes()?;
+          f_9 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("ColumnChunk.file_offset", &f_2)?;
+    let ret = ColumnChunk {
+      file_path: f_1,
+      file_offset: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      meta_data: f_3,
+      offset_index_offset: f_4,
+      offset_index_length: f_5,
+      column_index_offset: f_6,
+      column_index_length: f_7,
+      crypto_metadata: f_8,
+      encrypted_column_metadata: f_9,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("ColumnChunk");
+    o_prot.write_struct_begin(&struct_ident)?;
+    if let Some(ref fld_var) = self.file_path {
+      o_prot.write_field_begin(&TFieldIdentifier::new("file_path", TType::String, 1))?;
+      o_prot.write_string(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_begin(&TFieldIdentifier::new("file_offset", TType::I64, 2))?;
+    o_prot.write_i64(self.file_offset)?;
+    o_prot.write_field_end()?;
+    if let Some(ref fld_var) = self.meta_data {
+      o_prot.write_field_begin(&TFieldIdentifier::new("meta_data", TType::Struct, 3))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.offset_index_offset {
+      o_prot.write_field_begin(&TFieldIdentifier::new("offset_index_offset", TType::I64, 4))?;
+      o_prot.write_i64(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.offset_index_length {
+      o_prot.write_field_begin(&TFieldIdentifier::new("offset_index_length", TType::I32, 5))?;
+      o_prot.write_i32(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.column_index_offset {
+      o_prot.write_field_begin(&TFieldIdentifier::new("column_index_offset", TType::I64, 6))?;
+      o_prot.write_i64(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.column_index_length {
+      o_prot.write_field_begin(&TFieldIdentifier::new("column_index_length", TType::I32, 7))?;
+      o_prot.write_i32(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.crypto_metadata {
+      o_prot.write_field_begin(&TFieldIdentifier::new("crypto_metadata", TType::Struct, 8))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.encrypted_column_metadata {
+      o_prot.write_field_begin(&TFieldIdentifier::new("encrypted_column_metadata", TType::String, 9))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// RowGroup
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct RowGroup {
+  /// Metadata for each column chunk in this row group.
+  /// This list must have the same order as the SchemaElement list in FileMetaData.
+  /// 
+  pub columns: Vec<ColumnChunk>,
+  /// Total byte size of all the uncompressed column data in this row group *
+  pub total_byte_size: i64,
+  /// Number of rows in this row group *
+  pub num_rows: i64,
+  /// If set, specifies a sort ordering of the rows in this RowGroup.
+  /// The sorting columns can be a subset of all the columns.
+  pub sorting_columns: Option<Vec<SortingColumn>>,
+  /// Byte offset from beginning of file to first page (data or dictionary)
+  /// in this row group *
+  pub file_offset: Option<i64>,
+  /// Total byte size of all compressed (and potentially encrypted) column data
+  /// in this row group *
+  pub total_compressed_size: Option<i64>,
+  /// Row group ordinal in the file *
+  pub ordinal: Option<i16>,
+}
+
+impl RowGroup {
+  pub fn new<F4, F5, F6, F7>(columns: Vec<ColumnChunk>, total_byte_size: i64, num_rows: i64, sorting_columns: F4, file_offset: F5, total_compressed_size: F6, ordinal: F7) -> RowGroup where F4: Into<Option<Vec<SortingColumn>>>, F5: Into<Option<i64>>, F6: Into<Option<i64>>, F7: Into<Option<i16>> {
+    RowGroup {
+      columns,
+      total_byte_size,
+      num_rows,
+      sorting_columns: sorting_columns.into(),
+      file_offset: file_offset.into(),
+      total_compressed_size: total_compressed_size.into(),
+      ordinal: ordinal.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for RowGroup {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<RowGroup> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<Vec<ColumnChunk>> = None;
+    let mut f_2: Option<i64> = None;
+    let mut f_3: Option<i64> = None;
+    let mut f_4: Option<Vec<SortingColumn>> = None;
+    let mut f_5: Option<i64> = None;
+    let mut f_6: Option<i64> = None;
+    let mut f_7: Option<i16> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<ColumnChunk> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_5 = ColumnChunk::read_from_in_protocol(i_prot)?;
+            val.push(list_elem_5);
+          }
+          i_prot.read_list_end()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_i64()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_i64()?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<SortingColumn> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_6 = SortingColumn::read_from_in_protocol(i_prot)?;
+            val.push(list_elem_6);
+          }
+          i_prot.read_list_end()?;
+          f_4 = Some(val);
+        },
+        5 => {
+          let val = i_prot.read_i64()?;
+          f_5 = Some(val);
+        },
+        6 => {
+          let val = i_prot.read_i64()?;
+          f_6 = Some(val);
+        },
+        7 => {
+          let val = i_prot.read_i16()?;
+          f_7 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("RowGroup.columns", &f_1)?;
+    verify_required_field_exists("RowGroup.total_byte_size", &f_2)?;
+    verify_required_field_exists("RowGroup.num_rows", &f_3)?;
+    let ret = RowGroup {
+      columns: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      total_byte_size: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      num_rows: f_3.expect("auto-generated code should have checked for presence of required fields"),
+      sorting_columns: f_4,
+      file_offset: f_5,
+      total_compressed_size: f_6,
+      ordinal: f_7,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("RowGroup");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("columns", TType::List, 1))?;
+    o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.columns.len() as i32))?;
+    for e in &self.columns {
+      e.write_to_out_protocol(o_prot)?;
+    }
+    o_prot.write_list_end()?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("total_byte_size", TType::I64, 2))?;
+    o_prot.write_i64(self.total_byte_size)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("num_rows", TType::I64, 3))?;
+    o_prot.write_i64(self.num_rows)?;
+    o_prot.write_field_end()?;
+    if let Some(ref fld_var) = self.sorting_columns {
+      o_prot.write_field_begin(&TFieldIdentifier::new("sorting_columns", TType::List, 4))?;
+      o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
+      for e in fld_var {
+        e.write_to_out_protocol(o_prot)?;
+      }
+      o_prot.write_list_end()?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.file_offset {
+      o_prot.write_field_begin(&TFieldIdentifier::new("file_offset", TType::I64, 5))?;
+      o_prot.write_i64(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.total_compressed_size {
+      o_prot.write_field_begin(&TFieldIdentifier::new("total_compressed_size", TType::I64, 6))?;
+      o_prot.write_i64(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.ordinal {
+      o_prot.write_field_begin(&TFieldIdentifier::new("ordinal", TType::I16, 7))?;
+      o_prot.write_i16(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// TypeDefinedOrder
+//
+
+/// Empty struct to signal the order defined by the physical or logical type
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct TypeDefinedOrder {
+}
+
+impl TypeDefinedOrder {
+  pub fn new() -> TypeDefinedOrder {
+    TypeDefinedOrder {}
+  }
+}
+
+impl crate::thrift::TSerializable for TypeDefinedOrder {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<TypeDefinedOrder> {
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      i_prot.skip(field_ident.field_type)?;
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = TypeDefinedOrder {};
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("TypeDefinedOrder");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// ColumnOrder
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum ColumnOrder {
+  TYPEORDER(TypeDefinedOrder),
+}
+
+impl crate::thrift::TSerializable for ColumnOrder {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ColumnOrder> {
+    let mut ret: Option<ColumnOrder> = None;
+    let mut received_field_count = 0;
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = TypeDefinedOrder::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(ColumnOrder::TYPEORDER(val));
+          }
+          received_field_count += 1;
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+          received_field_count += 1;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    if received_field_count == 0 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received empty union from remote ColumnOrder"
+          )
+        )
+      )
+    } else if received_field_count > 1 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received multiple fields for union from remote ColumnOrder"
+          )
+        )
+      )
+    } else {
+      ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
+    }
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("ColumnOrder");
+    o_prot.write_struct_begin(&struct_ident)?;
+    match *self {
+      ColumnOrder::TYPEORDER(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("TYPE_ORDER", TType::Struct, 1))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// PageLocation
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct PageLocation {
+  /// Offset of the page in the file *
+  pub offset: i64,
+  /// Size of the page, including header. Sum of compressed_page_size and header
+  /// length
+  pub compressed_page_size: i32,
+  /// Index within the RowGroup of the first row of the page; this means pages
+  /// change on record boundaries (r = 0).
+  pub first_row_index: i64,
+}
+
+impl PageLocation {
+  pub fn new(offset: i64, compressed_page_size: i32, first_row_index: i64) -> PageLocation {
+    PageLocation {
+      offset,
+      compressed_page_size,
+      first_row_index,
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for PageLocation {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<PageLocation> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<i64> = None;
+    let mut f_2: Option<i32> = None;
+    let mut f_3: Option<i64> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_i64()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_i32()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_i64()?;
+          f_3 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("PageLocation.offset", &f_1)?;
+    verify_required_field_exists("PageLocation.compressed_page_size", &f_2)?;
+    verify_required_field_exists("PageLocation.first_row_index", &f_3)?;
+    let ret = PageLocation {
+      offset: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      compressed_page_size: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      first_row_index: f_3.expect("auto-generated code should have checked for presence of required fields"),
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("PageLocation");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("offset", TType::I64, 1))?;
+    o_prot.write_i64(self.offset)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("compressed_page_size", TType::I32, 2))?;
+    o_prot.write_i32(self.compressed_page_size)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("first_row_index", TType::I64, 3))?;
+    o_prot.write_i64(self.first_row_index)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// OffsetIndex
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct OffsetIndex {
+  /// PageLocations, ordered by increasing PageLocation.offset. It is required
+  /// that page_locations\[i\].first_row_index < page_locations\[i+1\].first_row_index.
+  pub page_locations: Vec<PageLocation>,
+}
+
+impl OffsetIndex {
+  pub fn new(page_locations: Vec<PageLocation>) -> OffsetIndex {
+    OffsetIndex {
+      page_locations,
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for OffsetIndex {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<OffsetIndex> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<Vec<PageLocation>> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<PageLocation> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_7 = PageLocation::read_from_in_protocol(i_prot)?;
+            val.push(list_elem_7);
+          }
+          i_prot.read_list_end()?;
+          f_1 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("OffsetIndex.page_locations", &f_1)?;
+    let ret = OffsetIndex {
+      page_locations: f_1.expect("auto-generated code should have checked for presence of required fields"),
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("OffsetIndex");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("page_locations", TType::List, 1))?;
+    o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.page_locations.len() as i32))?;
+    for e in &self.page_locations {
+      e.write_to_out_protocol(o_prot)?;
+    }
+    o_prot.write_list_end()?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// ColumnIndex
+//
+
+/// Description for ColumnIndex.
+/// Each `<array-field>`\[i\] refers to the page at OffsetIndex.page_locations\[i\]
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct ColumnIndex {
+  /// A list of Boolean values to determine the validity of the corresponding
+  /// min and max values. If true, a page contains only null values, and writers
+  /// have to set the corresponding entries in min_values and max_values to
+  /// byte\[0\], so that all lists have the same length. If false, the
+  /// corresponding entries in min_values and max_values must be valid.
+  pub null_pages: Vec<bool>,
+  /// Two lists containing lower and upper bounds for the values of each page
+  /// determined by the ColumnOrder of the column. These may be the actual
+  /// minimum and maximum values found on a page, but can also be (more compact)
+  /// values that do not exist on a page. For example, instead of storing ""Blart
+  /// Versenwald III", a writer may set min_values\[i\]="B", max_values\[i\]="C".
+  /// Such more compact values must still be valid values within the column's
+  /// logical type. Readers must make sure that list entries are populated before
+  /// using them by inspecting null_pages.
+  pub min_values: Vec<Vec<u8>>,
+  pub max_values: Vec<Vec<u8>>,
+  /// Stores whether both min_values and max_values are ordered and if so, in
+  /// which direction. This allows readers to perform binary searches in both
+  /// lists. Readers cannot assume that max_values\[i\] <= min_values\[i+1\], even
+  /// if the lists are ordered.
+  pub boundary_order: BoundaryOrder,
+  /// A list containing the number of null values for each page *
+  pub null_counts: Option<Vec<i64>>,
+}
+
+impl ColumnIndex {
+  pub fn new<F5>(null_pages: Vec<bool>, min_values: Vec<Vec<u8>>, max_values: Vec<Vec<u8>>, boundary_order: BoundaryOrder, null_counts: F5) -> ColumnIndex where F5: Into<Option<Vec<i64>>> {
+    ColumnIndex {
+      null_pages,
+      min_values,
+      max_values,
+      boundary_order,
+      null_counts: null_counts.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for ColumnIndex {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<ColumnIndex> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<Vec<bool>> = None;
+    let mut f_2: Option<Vec<Vec<u8>>> = None;
+    let mut f_3: Option<Vec<Vec<u8>>> = None;
+    let mut f_4: Option<BoundaryOrder> = None;
+    let mut f_5: Option<Vec<i64>> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<bool> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_8 = i_prot.read_bool()?;
+            val.push(list_elem_8);
+          }
+          i_prot.read_list_end()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<Vec<u8>> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_9 = i_prot.read_bytes()?;
+            val.push(list_elem_9);
+          }
+          i_prot.read_list_end()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<Vec<u8>> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_10 = i_prot.read_bytes()?;
+            val.push(list_elem_10);
+          }
+          i_prot.read_list_end()?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let val = BoundaryOrder::read_from_in_protocol(i_prot)?;
+          f_4 = Some(val);
+        },
+        5 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<i64> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_11 = i_prot.read_i64()?;
+            val.push(list_elem_11);
+          }
+          i_prot.read_list_end()?;
+          f_5 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("ColumnIndex.null_pages", &f_1)?;
+    verify_required_field_exists("ColumnIndex.min_values", &f_2)?;
+    verify_required_field_exists("ColumnIndex.max_values", &f_3)?;
+    verify_required_field_exists("ColumnIndex.boundary_order", &f_4)?;
+    let ret = ColumnIndex {
+      null_pages: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      min_values: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      max_values: f_3.expect("auto-generated code should have checked for presence of required fields"),
+      boundary_order: f_4.expect("auto-generated code should have checked for presence of required fields"),
+      null_counts: f_5,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("ColumnIndex");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("null_pages", TType::List, 1))?;
+    o_prot.write_list_begin(&TListIdentifier::new(TType::Bool, self.null_pages.len() as i32))?;
+    for e in &self.null_pages {
+      o_prot.write_bool(*e)?;
+    }
+    o_prot.write_list_end()?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("min_values", TType::List, 2))?;
+    o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.min_values.len() as i32))?;
+    for e in &self.min_values {
+      o_prot.write_bytes(e)?;
+    }
+    o_prot.write_list_end()?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("max_values", TType::List, 3))?;
+    o_prot.write_list_begin(&TListIdentifier::new(TType::String, self.max_values.len() as i32))?;
+    for e in &self.max_values {
+      o_prot.write_bytes(e)?;
+    }
+    o_prot.write_list_end()?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("boundary_order", TType::I32, 4))?;
+    self.boundary_order.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    if let Some(ref fld_var) = self.null_counts {
+      o_prot.write_field_begin(&TFieldIdentifier::new("null_counts", TType::List, 5))?;
+      o_prot.write_list_begin(&TListIdentifier::new(TType::I64, fld_var.len() as i32))?;
+      for e in fld_var {
+        o_prot.write_i64(*e)?;
+      }
+      o_prot.write_list_end()?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// AesGcmV1
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct AesGcmV1 {
+  /// AAD prefix *
+  pub aad_prefix: Option<Vec<u8>>,
+  /// Unique file identifier part of AAD suffix *
+  pub aad_file_unique: Option<Vec<u8>>,
+  /// In files encrypted with AAD prefix without storing it,
+  /// readers must supply the prefix *
+  pub supply_aad_prefix: Option<bool>,
+}
+
+impl AesGcmV1 {
+  pub fn new<F1, F2, F3>(aad_prefix: F1, aad_file_unique: F2, supply_aad_prefix: F3) -> AesGcmV1 where F1: Into<Option<Vec<u8>>>, F2: Into<Option<Vec<u8>>>, F3: Into<Option<bool>> {
+    AesGcmV1 {
+      aad_prefix: aad_prefix.into(),
+      aad_file_unique: aad_file_unique.into(),
+      supply_aad_prefix: supply_aad_prefix.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for AesGcmV1 {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<AesGcmV1> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<Vec<u8>> = None;
+    let mut f_2: Option<Vec<u8>> = None;
+    let mut f_3: Option<bool> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_bytes()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_bytes()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_bool()?;
+          f_3 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = AesGcmV1 {
+      aad_prefix: f_1,
+      aad_file_unique: f_2,
+      supply_aad_prefix: f_3,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("AesGcmV1");
+    o_prot.write_struct_begin(&struct_ident)?;
+    if let Some(ref fld_var) = self.aad_prefix {
+      o_prot.write_field_begin(&TFieldIdentifier::new("aad_prefix", TType::String, 1))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.aad_file_unique {
+      o_prot.write_field_begin(&TFieldIdentifier::new("aad_file_unique", TType::String, 2))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.supply_aad_prefix {
+      o_prot.write_field_begin(&TFieldIdentifier::new("supply_aad_prefix", TType::Bool, 3))?;
+      o_prot.write_bool(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// AesGcmCtrV1
+//
+
+#[derive(Clone, Debug, Default, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct AesGcmCtrV1 {
+  /// AAD prefix *
+  pub aad_prefix: Option<Vec<u8>>,
+  /// Unique file identifier part of AAD suffix *
+  pub aad_file_unique: Option<Vec<u8>>,
+  /// In files encrypted with AAD prefix without storing it,
+  /// readers must supply the prefix *
+  pub supply_aad_prefix: Option<bool>,
+}
+
+impl AesGcmCtrV1 {
+  pub fn new<F1, F2, F3>(aad_prefix: F1, aad_file_unique: F2, supply_aad_prefix: F3) -> AesGcmCtrV1 where F1: Into<Option<Vec<u8>>>, F2: Into<Option<Vec<u8>>>, F3: Into<Option<bool>> {
+    AesGcmCtrV1 {
+      aad_prefix: aad_prefix.into(),
+      aad_file_unique: aad_file_unique.into(),
+      supply_aad_prefix: supply_aad_prefix.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for AesGcmCtrV1 {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<AesGcmCtrV1> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<Vec<u8>> = None;
+    let mut f_2: Option<Vec<u8>> = None;
+    let mut f_3: Option<bool> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_bytes()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_bytes()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_bool()?;
+          f_3 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    let ret = AesGcmCtrV1 {
+      aad_prefix: f_1,
+      aad_file_unique: f_2,
+      supply_aad_prefix: f_3,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("AesGcmCtrV1");
+    o_prot.write_struct_begin(&struct_ident)?;
+    if let Some(ref fld_var) = self.aad_prefix {
+      o_prot.write_field_begin(&TFieldIdentifier::new("aad_prefix", TType::String, 1))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.aad_file_unique {
+      o_prot.write_field_begin(&TFieldIdentifier::new("aad_file_unique", TType::String, 2))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(fld_var) = self.supply_aad_prefix {
+      o_prot.write_field_begin(&TFieldIdentifier::new("supply_aad_prefix", TType::Bool, 3))?;
+      o_prot.write_bool(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// EncryptionAlgorithm
+//
+
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub enum EncryptionAlgorithm {
+  AESGCMV1(AesGcmV1),
+  AESGCMCTRV1(AesGcmCtrV1),
+}
+
+impl crate::thrift::TSerializable for EncryptionAlgorithm {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<EncryptionAlgorithm> {
+    let mut ret: Option<EncryptionAlgorithm> = None;
+    let mut received_field_count = 0;
+    i_prot.read_struct_begin()?;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = AesGcmV1::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(EncryptionAlgorithm::AESGCMV1(val));
+          }
+          received_field_count += 1;
+        },
+        2 => {
+          let val = AesGcmCtrV1::read_from_in_protocol(i_prot)?;
+          if ret.is_none() {
+            ret = Some(EncryptionAlgorithm::AESGCMCTRV1(val));
+          }
+          received_field_count += 1;
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+          received_field_count += 1;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    if received_field_count == 0 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received empty union from remote EncryptionAlgorithm"
+          )
+        )
+      )
+    } else if received_field_count > 1 {
+      Err(
+        thrift::Error::Protocol(
+          ProtocolError::new(
+            ProtocolErrorKind::InvalidData,
+            "received multiple fields for union from remote EncryptionAlgorithm"
+          )
+        )
+      )
+    } else {
+      ret.ok_or_else(|| thrift::Error::Protocol(ProtocolError::new(ProtocolErrorKind::InvalidData, "return value should have been constructed")))
+    }
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("EncryptionAlgorithm");
+    o_prot.write_struct_begin(&struct_ident)?;
+    match *self {
+      EncryptionAlgorithm::AESGCMV1(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("AES_GCM_V1", TType::Struct, 1))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+      EncryptionAlgorithm::AESGCMCTRV1(ref f) => {
+        o_prot.write_field_begin(&TFieldIdentifier::new("AES_GCM_CTR_V1", TType::Struct, 2))?;
+        f.write_to_out_protocol(o_prot)?;
+        o_prot.write_field_end()?;
+      },
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// FileMetaData
+//
+
+/// Description for file metadata
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct FileMetaData {
+  /// Version of this file *
+  pub version: i32,
+  /// Parquet schema for this file.  This schema contains metadata for all the columns.
+  /// The schema is represented as a tree with a single root.  The nodes of the tree
+  /// are flattened to a list by doing a depth-first traversal.
+  /// The column metadata contains the path in the schema for that column which can be
+  /// used to map columns to nodes in the schema.
+  /// The first element is the root *
+  pub schema: Vec<SchemaElement>,
+  /// Number of rows in this file *
+  pub num_rows: i64,
+  /// Row groups in this file *
+  pub row_groups: Vec<RowGroup>,
+  /// Optional key/value metadata *
+  pub key_value_metadata: Option<Vec<KeyValue>>,
+  /// String for application that wrote this file.  This should be in the format
+  /// `<Application>` version `<App Version>` (build `<App Build Hash>`).
+  /// e.g. impala version 1.0 (build 6cf94d29b2b7115df4de2c06e2ab4326d721eb55)
+  /// 
+  pub created_by: Option<String>,
+  /// Sort order used for the min_value and max_value fields in the Statistics
+  /// objects and the min_values and max_values fields in the ColumnIndex
+  /// objects of each column in this file. Sort orders are listed in the order
+  /// matching the columns in the schema. The indexes are not necessary the same
+  /// though, because only leaf nodes of the schema are represented in the list
+  /// of sort orders.
+  /// 
+  /// Without column_orders, the meaning of the min_value and max_value fields
+  /// in the Statistics object and the ColumnIndex object is undefined. To ensure
+  /// well-defined behaviour, if these fields are written to a Parquet file,
+  /// column_orders must be written as well.
+  /// 
+  /// The obsolete min and max fields in the Statistics object are always sorted
+  /// by signed comparison regardless of column_orders.
+  pub column_orders: Option<Vec<ColumnOrder>>,
+  /// Encryption algorithm. This field is set only in encrypted files
+  /// with plaintext footer. Files with encrypted footer store algorithm id
+  /// in FileCryptoMetaData structure.
+  pub encryption_algorithm: Option<EncryptionAlgorithm>,
+  /// Retrieval metadata of key used for signing the footer.
+  /// Used only in encrypted files with plaintext footer.
+  pub footer_signing_key_metadata: Option<Vec<u8>>,
+}
+
+impl FileMetaData {
+  pub fn new<F5, F6, F7, F8, F9>(version: i32, schema: Vec<SchemaElement>, num_rows: i64, row_groups: Vec<RowGroup>, key_value_metadata: F5, created_by: F6, column_orders: F7, encryption_algorithm: F8, footer_signing_key_metadata: F9) -> FileMetaData where F5: Into<Option<Vec<KeyValue>>>, F6: Into<Option<String>>, F7: Into<Option<Vec<ColumnOrder>>>, F8: Into<Option<EncryptionAlgorithm>>, F9: Into<Option<Vec<u8>>> {
+    FileMetaData {
+      version,
+      schema,
+      num_rows,
+      row_groups,
+      key_value_metadata: key_value_metadata.into(),
+      created_by: created_by.into(),
+      column_orders: column_orders.into(),
+      encryption_algorithm: encryption_algorithm.into(),
+      footer_signing_key_metadata: footer_signing_key_metadata.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for FileMetaData {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<FileMetaData> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<i32> = None;
+    let mut f_2: Option<Vec<SchemaElement>> = None;
+    let mut f_3: Option<i64> = None;
+    let mut f_4: Option<Vec<RowGroup>> = None;
+    let mut f_5: Option<Vec<KeyValue>> = None;
+    let mut f_6: Option<String> = None;
+    let mut f_7: Option<Vec<ColumnOrder>> = None;
+    let mut f_8: Option<EncryptionAlgorithm> = None;
+    let mut f_9: Option<Vec<u8>> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = i_prot.read_i32()?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<SchemaElement> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_12 = SchemaElement::read_from_in_protocol(i_prot)?;
+            val.push(list_elem_12);
+          }
+          i_prot.read_list_end()?;
+          f_2 = Some(val);
+        },
+        3 => {
+          let val = i_prot.read_i64()?;
+          f_3 = Some(val);
+        },
+        4 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<RowGroup> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_13 = RowGroup::read_from_in_protocol(i_prot)?;
+            val.push(list_elem_13);
+          }
+          i_prot.read_list_end()?;
+          f_4 = Some(val);
+        },
+        5 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<KeyValue> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_14 = KeyValue::read_from_in_protocol(i_prot)?;
+            val.push(list_elem_14);
+          }
+          i_prot.read_list_end()?;
+          f_5 = Some(val);
+        },
+        6 => {
+          let val = i_prot.read_string()?;
+          f_6 = Some(val);
+        },
+        7 => {
+          let list_ident = i_prot.read_list_begin()?;
+          let mut val: Vec<ColumnOrder> = Vec::with_capacity(list_ident.size as usize);
+          for _ in 0..list_ident.size {
+            let list_elem_15 = ColumnOrder::read_from_in_protocol(i_prot)?;
+            val.push(list_elem_15);
+          }
+          i_prot.read_list_end()?;
+          f_7 = Some(val);
+        },
+        8 => {
+          let val = EncryptionAlgorithm::read_from_in_protocol(i_prot)?;
+          f_8 = Some(val);
+        },
+        9 => {
+          let val = i_prot.read_bytes()?;
+          f_9 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("FileMetaData.version", &f_1)?;
+    verify_required_field_exists("FileMetaData.schema", &f_2)?;
+    verify_required_field_exists("FileMetaData.num_rows", &f_3)?;
+    verify_required_field_exists("FileMetaData.row_groups", &f_4)?;
+    let ret = FileMetaData {
+      version: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      schema: f_2.expect("auto-generated code should have checked for presence of required fields"),
+      num_rows: f_3.expect("auto-generated code should have checked for presence of required fields"),
+      row_groups: f_4.expect("auto-generated code should have checked for presence of required fields"),
+      key_value_metadata: f_5,
+      created_by: f_6,
+      column_orders: f_7,
+      encryption_algorithm: f_8,
+      footer_signing_key_metadata: f_9,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("FileMetaData");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("version", TType::I32, 1))?;
+    o_prot.write_i32(self.version)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("schema", TType::List, 2))?;
+    o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.schema.len() as i32))?;
+    for e in &self.schema {
+      e.write_to_out_protocol(o_prot)?;
+    }
+    o_prot.write_list_end()?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("num_rows", TType::I64, 3))?;
+    o_prot.write_i64(self.num_rows)?;
+    o_prot.write_field_end()?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("row_groups", TType::List, 4))?;
+    o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, self.row_groups.len() as i32))?;
+    for e in &self.row_groups {
+      e.write_to_out_protocol(o_prot)?;
+    }
+    o_prot.write_list_end()?;
+    o_prot.write_field_end()?;
+    if let Some(ref fld_var) = self.key_value_metadata {
+      o_prot.write_field_begin(&TFieldIdentifier::new("key_value_metadata", TType::List, 5))?;
+      o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
+      for e in fld_var {
+        e.write_to_out_protocol(o_prot)?;
+      }
+      o_prot.write_list_end()?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.created_by {
+      o_prot.write_field_begin(&TFieldIdentifier::new("created_by", TType::String, 6))?;
+      o_prot.write_string(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.column_orders {
+      o_prot.write_field_begin(&TFieldIdentifier::new("column_orders", TType::List, 7))?;
+      o_prot.write_list_begin(&TListIdentifier::new(TType::Struct, fld_var.len() as i32))?;
+      for e in fld_var {
+        e.write_to_out_protocol(o_prot)?;
+      }
+      o_prot.write_list_end()?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.encryption_algorithm {
+      o_prot.write_field_begin(&TFieldIdentifier::new("encryption_algorithm", TType::Struct, 8))?;
+      fld_var.write_to_out_protocol(o_prot)?;
+      o_prot.write_field_end()?
+    }
+    if let Some(ref fld_var) = self.footer_signing_key_metadata {
+      o_prot.write_field_begin(&TFieldIdentifier::new("footer_signing_key_metadata", TType::String, 9))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
+//
+// FileCryptoMetaData
+//
+
+/// Crypto metadata for files with encrypted footer *
+#[derive(Clone, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
+pub struct FileCryptoMetaData {
+  /// Encryption algorithm. This field is only used for files
+  /// with encrypted footer. Files with plaintext footer store algorithm id
+  /// inside footer (FileMetaData structure).
+  pub encryption_algorithm: EncryptionAlgorithm,
+  /// Retrieval metadata of key used for encryption of footer,
+  /// and (possibly) columns *
+  pub key_metadata: Option<Vec<u8>>,
+}
+
+impl FileCryptoMetaData {
+  pub fn new<F2>(encryption_algorithm: EncryptionAlgorithm, key_metadata: F2) -> FileCryptoMetaData where F2: Into<Option<Vec<u8>>> {
+    FileCryptoMetaData {
+      encryption_algorithm,
+      key_metadata: key_metadata.into(),
+    }
+  }
+}
+
+impl crate::thrift::TSerializable for FileCryptoMetaData {
+  fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<FileCryptoMetaData> {
+    i_prot.read_struct_begin()?;
+    let mut f_1: Option<EncryptionAlgorithm> = None;
+    let mut f_2: Option<Vec<u8>> = None;
+    loop {
+      let field_ident = i_prot.read_field_begin()?;
+      if field_ident.field_type == TType::Stop {
+        break;
+      }
+      let field_id = field_id(&field_ident)?;
+      match field_id {
+        1 => {
+          let val = EncryptionAlgorithm::read_from_in_protocol(i_prot)?;
+          f_1 = Some(val);
+        },
+        2 => {
+          let val = i_prot.read_bytes()?;
+          f_2 = Some(val);
+        },
+        _ => {
+          i_prot.skip(field_ident.field_type)?;
+        },
+      };
+      i_prot.read_field_end()?;
+    }
+    i_prot.read_struct_end()?;
+    verify_required_field_exists("FileCryptoMetaData.encryption_algorithm", &f_1)?;
+    let ret = FileCryptoMetaData {
+      encryption_algorithm: f_1.expect("auto-generated code should have checked for presence of required fields"),
+      key_metadata: f_2,
+    };
+    Ok(ret)
+  }
+  fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()> {
+    let struct_ident = TStructIdentifier::new("FileCryptoMetaData");
+    o_prot.write_struct_begin(&struct_ident)?;
+    o_prot.write_field_begin(&TFieldIdentifier::new("encryption_algorithm", TType::Struct, 1))?;
+    self.encryption_algorithm.write_to_out_protocol(o_prot)?;
+    o_prot.write_field_end()?;
+    if let Some(ref fld_var) = self.key_metadata {
+      o_prot.write_field_begin(&TFieldIdentifier::new("key_metadata", TType::String, 2))?;
+      o_prot.write_bytes(fld_var)?;
+      o_prot.write_field_end()?
+    }
+    o_prot.write_field_stop()?;
+    o_prot.write_struct_end()
+  }
+}
+
diff --git a/parquet/src/lib.rs b/parquet/src/lib.rs
index 90fe399e78d7..db5d72634389 100644
--- a/parquet/src/lib.rs
+++ b/parquet/src/lib.rs
@@ -15,24 +15,67 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//!
 //! This crate contains the official Native Rust implementation of
 //! [Apache Parquet](https://parquet.apache.org/), part of
 //! the [Apache Arrow](https://arrow.apache.org/) project.
+//! The crate provides a number of APIs to read and write Parquet files,
+//! covering a range of use cases.
 //!
 //! Please see the [parquet crates.io](https://crates.io/crates/parquet)
 //! page for feature flags and tips to improve performance.
 //!
-//! # Getting Started
-//! Start with some examples:
+//! # Format Overview
+//!
+//! Parquet is a columnar format, which means that unlike row formats like [CSV], values are
+//! iterated along columns instead of rows. Parquet is similar in spirit to [Arrow], with Parquet
+//! focusing on storage efficiency whereas Arrow prioritizes compute efficiency.
+//!
+//! Parquet files are partitioned for scalability. Each file contains metadata,
+//! along with zero or more "row groups", each row group containing one or
+//! more columns. The APIs in this crate reflect this structure.
+//!
+//! Parquet distinguishes between "logical" and "physical" data types.
+//! For instance, strings (logical type) are stored as byte arrays (physical type).
+//! Likewise, temporal types like dates, times, timestamps, etc. (logical type)
+//! are stored as integers (physical type). This crate exposes both kinds of types.
+//!
+//! For more details about the Parquet format, see the
+//! [Parquet spec](https://github.com/apache/parquet-format/blob/master/README.md#file-format).
+//!
+//! # APIs
+//!
+//! This crate exposes a number of APIs for different use-cases.
+//!
+//! ## Read/Write Arrow
 //!
-//! 1. [mod@file] for reading and writing parquet files using the
-//! [ColumnReader](column::reader::ColumnReader) API.
+//! The [`arrow`] module allows reading and writing Parquet data to/from Arrow `RecordBatch`.
+//! This makes for a simple and performant interface to parquet data, whilst allowing workloads
+//! to leverage the wide range of data transforms provided by the [arrow] crate, and by the
+//! ecosystem of libraries and services using [Arrow] as an interop format.
 //!
-//! 2. [arrow] for reading and writing parquet files to Arrow
-//! `RecordBatch`es
+//! ## Read/Write Arrow Async
 //!
-//! 3. [arrow::async_reader] for `async` reading and writing parquet
-//! files to Arrow `RecordBatch`es (requires the `async` feature).
+//! When the `async` feature is enabled, [`arrow::async_reader`] and [`arrow::async_writer`]
+//! provide the ability to read and write [`arrow`] data asynchronously. Additionally, with the
+//! `object_store` feature is enabled, [`ParquetObjectReader`](arrow::async_reader::ParquetObjectReader)
+//! provides efficient integration with object storage services such as S3 via the [object_store]
+//! crate, automatically optimizing IO based on any predicates or projections provided.
+//!
+//! ## Read/Write Parquet
+//!
+//! Workloads needing finer-grained control, or looking to not take a dependency on arrow,
+//! can use the lower-level APIs in [`mod@file`]. These APIs expose the underlying parquet
+//! data model, and therefore require knowledge of the underlying parquet format,
+//! including the details of [Dremel] record shredding and [Logical Types]. Most workloads
+//! should prefer the arrow interfaces.
+//!
+//! [arrow]: https://docs.rs/arrow/latest/arrow/index.html
+//! [Arrow]: https://arrow.apache.org/
+//! [CSV]: https://en.wikipedia.org/wiki/Comma-separated_values
+//! [Dremel]: https://research.google/pubs/pub36632/
+//! [Logical Types]: https://github.com/apache/parquet-format/blob/master/LogicalTypes.md
+//! [object_store]: https://docs.rs/object_store/latest/object_store/
 
 /// Defines a an item with an experimental public API
 ///
@@ -61,6 +104,11 @@ macro_rules! experimental {
 pub mod errors;
 pub mod basic;
 
+/// Automatically generated code for reading parquet thrift definition.
+// see parquet/CONTRIBUTING.md for instructions on regenerating
+#[allow(clippy::derivable_impls, clippy::match_single_binding)]
+pub mod format;
+
 #[macro_use]
 pub mod data_type;
 
@@ -69,16 +117,15 @@ pub mod data_type;
 #[doc(hidden)]
 pub use self::encodings::{decoding, encoding};
 
-#[cfg(feature = "experimental")]
-#[doc(hidden)]
-pub use self::util::memory;
-
 experimental!(#[macro_use] mod util);
-#[cfg(any(feature = "arrow", test))]
+#[cfg(feature = "arrow")]
 pub mod arrow;
 pub mod column;
 experimental!(mod compression);
 experimental!(mod encodings);
+pub mod bloom_filter;
 pub mod file;
 pub mod record;
 pub mod schema;
+
+pub mod thrift;
diff --git a/parquet/src/record/api.rs b/parquet/src/record/api.rs
index 7e1c484bf881..e4f473562e01 100644
--- a/parquet/src/record/api.rs
+++ b/parquet/src/record/api.rs
@@ -20,9 +20,11 @@
 use std::fmt;
 
 use chrono::{TimeZone, Utc};
+use half::f16;
+use num::traits::Float;
 use num_bigint::{BigInt, Sign};
 
-use crate::basic::{ConvertedType, Type as PhysicalType};
+use crate::basic::{ConvertedType, LogicalType, Type as PhysicalType};
 use crate::data_type::{ByteArray, Decimal, Int96};
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::ColumnDescPtr;
@@ -66,7 +68,7 @@ impl Row {
     ///
     /// let file = File::open("/path/to/file").unwrap();
     /// let reader = SerializedFileReader::new(file).unwrap();
-    /// let row: Row = reader.get_row_iter(None).unwrap().next().unwrap();
+    /// let row: Row = reader.get_row_iter(None).unwrap().next().unwrap().unwrap();
     /// for (idx, (name, field)) in row.get_column_iter().enumerate() {
     ///     println!("column index: {}, column name: {}, column value: {}", idx, name, field);
     /// }
@@ -121,10 +123,11 @@ pub trait RowAccessor {
     fn get_ushort(&self, i: usize) -> Result<u16>;
     fn get_uint(&self, i: usize) -> Result<u32>;
     fn get_ulong(&self, i: usize) -> Result<u64>;
+    fn get_float16(&self, i: usize) -> Result<f16>;
     fn get_float(&self, i: usize) -> Result<f32>;
     fn get_double(&self, i: usize) -> Result<f64>;
-    fn get_timestamp_millis(&self, i: usize) -> Result<u64>;
-    fn get_timestamp_micros(&self, i: usize) -> Result<u64>;
+    fn get_timestamp_millis(&self, i: usize) -> Result<i64>;
+    fn get_timestamp_micros(&self, i: usize) -> Result<i64>;
     fn get_decimal(&self, i: usize) -> Result<&Decimal>;
     fn get_string(&self, i: usize) -> Result<&String>;
     fn get_bytes(&self, i: usize) -> Result<&ByteArray>;
@@ -133,7 +136,7 @@ pub trait RowAccessor {
     fn get_map(&self, i: usize) -> Result<&Map>;
 }
 
-/// Trait for formating fields within a Row.
+/// Trait for formatting fields within a Row.
 ///
 /// # Examples
 ///
@@ -146,7 +149,7 @@ pub trait RowAccessor {
 ///
 /// if let Ok(file) = File::open(&Path::new("test.parquet")) {
 ///     let reader = SerializedFileReader::new(file).unwrap();
-///     let row = reader.get_row_iter(None).unwrap().next().unwrap();
+///     let row = reader.get_row_iter(None).unwrap().next().unwrap().unwrap();
 ///     println!("column 0: {}, column 1: {}", row.fmt(0), row.fmt(1));
 /// }
 /// ```
@@ -215,13 +218,15 @@ impl RowAccessor for Row {
 
     row_primitive_accessor!(get_ulong, ULong, u64);
 
+    row_primitive_accessor!(get_float16, Float16, f16);
+
     row_primitive_accessor!(get_float, Float, f32);
 
     row_primitive_accessor!(get_double, Double, f64);
 
-    row_primitive_accessor!(get_timestamp_millis, TimestampMillis, u64);
+    row_primitive_accessor!(get_timestamp_millis, TimestampMillis, i64);
 
-    row_primitive_accessor!(get_timestamp_micros, TimestampMicros, u64);
+    row_primitive_accessor!(get_timestamp_micros, TimestampMicros, i64);
 
     row_complex_accessor!(get_decimal, Decimal, Decimal);
 
@@ -245,7 +250,7 @@ pub fn make_row(fields: Vec<(String, Field)>) -> Row {
 impl fmt::Display for Row {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{{")?;
-        for (i, &(ref key, ref value)) in self.fields.iter().enumerate() {
+        for (i, (key, value)) in self.fields.iter().enumerate() {
             key.fmt(f)?;
             write!(f, ": ")?;
             value.fmt(f)?;
@@ -293,10 +298,11 @@ pub trait ListAccessor {
     fn get_ushort(&self, i: usize) -> Result<u16>;
     fn get_uint(&self, i: usize) -> Result<u32>;
     fn get_ulong(&self, i: usize) -> Result<u64>;
+    fn get_float16(&self, i: usize) -> Result<f16>;
     fn get_float(&self, i: usize) -> Result<f32>;
     fn get_double(&self, i: usize) -> Result<f64>;
-    fn get_timestamp_millis(&self, i: usize) -> Result<u64>;
-    fn get_timestamp_micros(&self, i: usize) -> Result<u64>;
+    fn get_timestamp_millis(&self, i: usize) -> Result<i64>;
+    fn get_timestamp_micros(&self, i: usize) -> Result<i64>;
     fn get_decimal(&self, i: usize) -> Result<&Decimal>;
     fn get_string(&self, i: usize) -> Result<&String>;
     fn get_bytes(&self, i: usize) -> Result<&ByteArray>;
@@ -358,13 +364,15 @@ impl ListAccessor for List {
 
     list_primitive_accessor!(get_ulong, ULong, u64);
 
+    list_primitive_accessor!(get_float16, Float16, f16);
+
     list_primitive_accessor!(get_float, Float, f32);
 
     list_primitive_accessor!(get_double, Double, f64);
 
-    list_primitive_accessor!(get_timestamp_millis, TimestampMillis, u64);
+    list_primitive_accessor!(get_timestamp_millis, TimestampMillis, i64);
 
-    list_primitive_accessor!(get_timestamp_micros, TimestampMicros, u64);
+    list_primitive_accessor!(get_timestamp_micros, TimestampMicros, i64);
 
     list_complex_accessor!(get_decimal, Decimal, Decimal);
 
@@ -449,13 +457,15 @@ impl<'a> ListAccessor for MapList<'a> {
 
     map_list_primitive_accessor!(get_ulong, ULong, u64);
 
+    map_list_primitive_accessor!(get_float16, Float16, f16);
+
     map_list_primitive_accessor!(get_float, Float, f32);
 
     map_list_primitive_accessor!(get_double, Double, f64);
 
-    map_list_primitive_accessor!(get_timestamp_millis, TimestampMillis, u64);
+    map_list_primitive_accessor!(get_timestamp_millis, TimestampMillis, i64);
 
-    map_list_primitive_accessor!(get_timestamp_micros, TimestampMicros, u64);
+    map_list_primitive_accessor!(get_timestamp_micros, TimestampMicros, i64);
 
     list_complex_accessor!(get_decimal, Decimal, Decimal);
 
@@ -510,6 +520,8 @@ pub enum Field {
     UInt(u32),
     // Unsigned integer UINT_64.
     ULong(u64),
+    /// IEEE 16-bit floating point value.
+    Float16(f16),
     /// IEEE 32-bit floating point value.
     Float(f32),
     /// IEEE 64-bit floating point value.
@@ -522,11 +534,11 @@ pub enum Field {
     Bytes(ByteArray),
     /// Date without a time of day, stores the number of days from the
     /// Unix epoch, 1 January 1970.
-    Date(u32),
+    Date(i32),
     /// Milliseconds from the Unix epoch, 1 January 1970.
-    TimestampMillis(u64),
-    /// Microseconds from the Unix epoch, 1 Janiary 1970.
-    TimestampMicros(u64),
+    TimestampMillis(i64),
+    /// Microseconds from the Unix epoch, 1 January 1970.
+    TimestampMicros(i64),
 
     // ----------------------------------------------------------------------
     // Complex types
@@ -552,6 +564,7 @@ impl Field {
             Field::UShort(_) => "UShort",
             Field::UInt(_) => "UInt",
             Field::ULong(_) => "ULong",
+            Field::Float16(_) => "Float16",
             Field::Float(_) => "Float",
             Field::Double(_) => "Double",
             Field::Decimal(_) => "Decimal",
@@ -590,7 +603,7 @@ impl Field {
             ConvertedType::UINT_8 => Field::UByte(value as u8),
             ConvertedType::UINT_16 => Field::UShort(value as u16),
             ConvertedType::UINT_32 => Field::UInt(value as u32),
-            ConvertedType::DATE => Field::Date(value as u32),
+            ConvertedType::DATE => Field::Date(value),
             ConvertedType::DECIMAL => Field::Decimal(Decimal::from_i32(
                 value,
                 descr.type_precision(),
@@ -606,8 +619,8 @@ impl Field {
         match descr.converted_type() {
             ConvertedType::INT_64 | ConvertedType::NONE => Field::Long(value),
             ConvertedType::UINT_64 => Field::ULong(value as u64),
-            ConvertedType::TIMESTAMP_MILLIS => Field::TimestampMillis(value as u64),
-            ConvertedType::TIMESTAMP_MICROS => Field::TimestampMicros(value as u64),
+            ConvertedType::TIMESTAMP_MILLIS => Field::TimestampMillis(value),
+            ConvertedType::TIMESTAMP_MICROS => Field::TimestampMicros(value),
             ConvertedType::DECIMAL => Field::Decimal(Decimal::from_i64(
                 value,
                 descr.type_precision(),
@@ -621,7 +634,7 @@ impl Field {
     /// `Timestamp` value.
     #[inline]
     pub fn convert_int96(_descr: &ColumnDescPtr, value: Int96) -> Self {
-        Field::TimestampMillis(value.to_i64() as u64)
+        Field::TimestampMillis(value.to_i64())
     }
 
     /// Converts Parquet FLOAT type with logical type into `f32` value.
@@ -636,14 +649,20 @@ impl Field {
         Field::Double(value)
     }
 
-    /// Converts Parquet BYTE_ARRAY type with converted type into either UTF8 string or
-    /// array of bytes.
+    /// Converts Parquet BYTE_ARRAY type with converted type into a UTF8
+    /// string, decimal, float16, or an array of bytes.
     #[inline]
-    pub fn convert_byte_array(descr: &ColumnDescPtr, value: ByteArray) -> Self {
-        match descr.physical_type() {
+    pub fn convert_byte_array(descr: &ColumnDescPtr, value: ByteArray) -> Result<Self> {
+        let field = match descr.physical_type() {
             PhysicalType::BYTE_ARRAY => match descr.converted_type() {
                 ConvertedType::UTF8 | ConvertedType::ENUM | ConvertedType::JSON => {
-                    let value = String::from_utf8(value.data().to_vec()).unwrap();
+                    let value = String::from_utf8(value.data().to_vec()).map_err(|e| {
+                        general_err!(
+                            "Error reading BYTE_ARRAY as String. Bytes: {:?} Error: {:?}",
+                            value.data(),
+                            e
+                        )
+                    })?;
                     Field::Str(value)
                 }
                 ConvertedType::BSON | ConvertedType::NONE => Field::Bytes(value),
@@ -660,15 +679,29 @@ impl Field {
                     descr.type_precision(),
                     descr.type_scale(),
                 )),
+                ConvertedType::NONE if descr.logical_type() == Some(LogicalType::Float16) => {
+                    if value.len() != 2 {
+                        return Err(general_err!(
+                            "Error reading FIXED_LEN_BYTE_ARRAY as FLOAT16. Length must be 2, got {}",
+                            value.len()
+                        ));
+                    }
+                    let bytes = [value.data()[0], value.data()[1]];
+                    Field::Float16(f16::from_le_bytes(bytes))
+                }
                 ConvertedType::NONE => Field::Bytes(value),
                 _ => nyi!(descr, value),
             },
             _ => nyi!(descr, value),
-        }
+        };
+        Ok(field)
     }
 
     #[cfg(any(feature = "json", test))]
     pub fn to_json_value(&self) -> Value {
+        use base64::prelude::BASE64_STANDARD;
+        use base64::Engine;
+
         match &self {
             Field::Null => Value::Null,
             Field::Bool(b) => Value::Bool(*b),
@@ -680,6 +713,9 @@ impl Field {
             Field::UShort(n) => Value::Number(serde_json::Number::from(*n)),
             Field::UInt(n) => Value::Number(serde_json::Number::from(*n)),
             Field::ULong(n) => Value::Number(serde_json::Number::from(*n)),
+            Field::Float16(n) => serde_json::Number::from_f64(f64::from(*n))
+                .map(Value::Number)
+                .unwrap_or(Value::Null),
             Field::Float(n) => serde_json::Number::from_f64(f64::from(*n))
                 .map(Value::Number)
                 .unwrap_or(Value::Null),
@@ -688,14 +724,10 @@ impl Field {
                 .unwrap_or(Value::Null),
             Field::Decimal(n) => Value::String(convert_decimal_to_string(n)),
             Field::Str(s) => Value::String(s.to_owned()),
-            Field::Bytes(b) => Value::String(base64::encode(b.data())),
+            Field::Bytes(b) => Value::String(BASE64_STANDARD.encode(b.data())),
             Field::Date(d) => Value::String(convert_date_to_string(*d)),
-            Field::TimestampMillis(ts) => {
-                Value::String(convert_timestamp_millis_to_string(*ts))
-            }
-            Field::TimestampMicros(ts) => {
-                Value::String(convert_timestamp_micros_to_string(*ts))
-            }
+            Field::TimestampMillis(ts) => Value::String(convert_timestamp_millis_to_string(*ts)),
+            Field::TimestampMicros(ts) => Value::String(convert_timestamp_micros_to_string(*ts)),
             Field::Group(row) => row.to_json_value(),
             Field::ListInternal(fields) => {
                 Value::Array(fields.elements.iter().map(|f| f.to_json_value()).collect())
@@ -721,37 +753,46 @@ impl fmt::Display for Field {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match *self {
             Field::Null => write!(f, "null"),
-            Field::Bool(value) => write!(f, "{}", value),
-            Field::Byte(value) => write!(f, "{}", value),
-            Field::Short(value) => write!(f, "{}", value),
-            Field::Int(value) => write!(f, "{}", value),
-            Field::Long(value) => write!(f, "{}", value),
-            Field::UByte(value) => write!(f, "{}", value),
-            Field::UShort(value) => write!(f, "{}", value),
-            Field::UInt(value) => write!(f, "{}", value),
-            Field::ULong(value) => write!(f, "{}", value),
+            Field::Bool(value) => write!(f, "{value}"),
+            Field::Byte(value) => write!(f, "{value}"),
+            Field::Short(value) => write!(f, "{value}"),
+            Field::Int(value) => write!(f, "{value}"),
+            Field::Long(value) => write!(f, "{value}"),
+            Field::UByte(value) => write!(f, "{value}"),
+            Field::UShort(value) => write!(f, "{value}"),
+            Field::UInt(value) => write!(f, "{value}"),
+            Field::ULong(value) => write!(f, "{value}"),
+            Field::Float16(value) => {
+                if !value.is_finite() {
+                    write!(f, "{value}")
+                } else if value.trunc() == value {
+                    write!(f, "{value}.0")
+                } else {
+                    write!(f, "{value}")
+                }
+            }
             Field::Float(value) => {
                 if !(1e-15..=1e19).contains(&value) {
-                    write!(f, "{:E}", value)
+                    write!(f, "{value:E}")
                 } else if value.trunc() == value {
-                    write!(f, "{}.0", value)
+                    write!(f, "{value}.0")
                 } else {
-                    write!(f, "{}", value)
+                    write!(f, "{value}")
                 }
             }
             Field::Double(value) => {
                 if !(1e-15..=1e19).contains(&value) {
-                    write!(f, "{:E}", value)
+                    write!(f, "{value:E}")
                 } else if value.trunc() == value {
-                    write!(f, "{}.0", value)
+                    write!(f, "{value}.0")
                 } else {
-                    write!(f, "{}", value)
+                    write!(f, "{value}")
                 }
             }
             Field::Decimal(ref value) => {
                 write!(f, "{}", convert_decimal_to_string(value))
             }
-            Field::Str(ref value) => write!(f, "\"{}\"", value),
+            Field::Str(ref value) => write!(f, "\"{value}\""),
             Field::Bytes(ref value) => write!(f, "{:?}", value.data()),
             Field::Date(value) => write!(f, "{}", convert_date_to_string(value)),
             Field::TimestampMillis(value) => {
@@ -760,7 +801,7 @@ impl fmt::Display for Field {
             Field::TimestampMicros(value) => {
                 write!(f, "{}", convert_timestamp_micros_to_string(value))
             }
-            Field::Group(ref fields) => write!(f, "{}", fields),
+            Field::Group(ref fields) => write!(f, "{fields}"),
             Field::ListInternal(ref list) => {
                 let elems = &list.elements;
                 write!(f, "[")?;
@@ -775,7 +816,7 @@ impl fmt::Display for Field {
             Field::MapInternal(ref map) => {
                 let entries = &map.entries;
                 write!(f, "{{")?;
-                for (i, &(ref key, ref value)) in entries.iter().enumerate() {
+                for (i, (key, value)) in entries.iter().enumerate() {
                     key.fmt(f)?;
                     write!(f, " -> ")?;
                     value.fmt(f)?;
@@ -793,27 +834,37 @@ impl fmt::Display for Field {
 /// Input `value` is a number of days since the epoch in UTC.
 /// Date is displayed in local timezone.
 #[inline]
-fn convert_date_to_string(value: u32) -> String {
+fn convert_date_to_string(value: i32) -> String {
     static NUM_SECONDS_IN_DAY: i64 = 60 * 60 * 24;
-    let dt = Utc.timestamp(value as i64 * NUM_SECONDS_IN_DAY, 0).date();
-    format!("{}", dt.format("%Y-%m-%d %:z"))
+    let dt = Utc
+        .timestamp_opt(value as i64 * NUM_SECONDS_IN_DAY, 0)
+        .unwrap();
+    format!("{}", dt.format("%Y-%m-%d"))
 }
 
 /// Helper method to convert Parquet timestamp into a string.
-/// Input `value` is a number of milliseconds since the epoch in UTC.
+/// Input `value` is a number of seconds since the epoch in UTC.
 /// Datetime is displayed in local timezone.
 #[inline]
-fn convert_timestamp_millis_to_string(value: u64) -> String {
-    let dt = Utc.timestamp((value / 1000) as i64, 0);
+fn convert_timestamp_secs_to_string(value: i64) -> String {
+    let dt = Utc.timestamp_opt(value, 0).unwrap();
     format!("{}", dt.format("%Y-%m-%d %H:%M:%S %:z"))
 }
 
+/// Helper method to convert Parquet timestamp into a string.
+/// Input `value` is a number of milliseconds since the epoch in UTC.
+/// Datetime is displayed in local timezone.
+#[inline]
+fn convert_timestamp_millis_to_string(value: i64) -> String {
+    convert_timestamp_secs_to_string(value / 1000)
+}
+
 /// Helper method to convert Parquet timestamp into a string.
 /// Input `value` is a number of microseconds since the epoch in UTC.
 /// Datetime is displayed in local timezone.
 #[inline]
-fn convert_timestamp_micros_to_string(value: u64) -> String {
-    convert_timestamp_millis_to_string(value / 1000)
+fn convert_timestamp_micros_to_string(value: i64) -> String {
+    convert_timestamp_secs_to_string(value / 1000000)
 }
 
 /// Helper method to convert Parquet decimal into a string.
@@ -827,7 +878,7 @@ fn convert_decimal_to_string(decimal: &Decimal) -> String {
     let num = BigInt::from_signed_bytes_be(decimal.data());
 
     // Offset of the first digit in a string.
-    let negative = if num.sign() == Sign::Minus { 1 } else { 0 };
+    let negative = i32::from(num.sign() == Sign::Minus);
     let mut num_str = num.to_string();
     let mut point = num_str.len() as i32 - decimal.scale() - negative;
 
@@ -849,10 +900,11 @@ fn convert_decimal_to_string(decimal: &Decimal) -> String {
 }
 
 #[cfg(test)]
-#[allow(clippy::approx_constant, clippy::many_single_char_names)]
+#[allow(clippy::many_single_char_names)]
 mod tests {
     use super::*;
 
+    use std::f64::consts::PI;
     use std::sync::Arc;
 
     use crate::schema::types::{ColumnDescriptor, ColumnPath, PrimitiveTypeBuilder};
@@ -934,8 +986,7 @@ mod tests {
         let row = Field::convert_int32(&descr, 14611);
         assert_eq!(row, Field::Date(14611));
 
-        let descr =
-            make_column_descr![PhysicalType::INT32, ConvertedType::DECIMAL, 0, 8, 2];
+        let descr = make_column_descr![PhysicalType::INT32, ConvertedType::DECIMAL, 0, 8, 2];
         let row = Field::convert_int32(&descr, 444);
         assert_eq!(row, Field::Decimal(Decimal::from_i32(444, 8, 2)));
     }
@@ -950,13 +1001,11 @@ mod tests {
         let row = Field::convert_int64(&descr, 78239823);
         assert_eq!(row, Field::ULong(78239823));
 
-        let descr =
-            make_column_descr![PhysicalType::INT64, ConvertedType::TIMESTAMP_MILLIS];
+        let descr = make_column_descr![PhysicalType::INT64, ConvertedType::TIMESTAMP_MILLIS];
         let row = Field::convert_int64(&descr, 1541186529153);
         assert_eq!(row, Field::TimestampMillis(1541186529153));
 
-        let descr =
-            make_column_descr![PhysicalType::INT64, ConvertedType::TIMESTAMP_MICROS];
+        let descr = make_column_descr![PhysicalType::INT64, ConvertedType::TIMESTAMP_MICROS];
         let row = Field::convert_int64(&descr, 1541186529153123);
         assert_eq!(row, Field::TimestampMicros(1541186529153123));
 
@@ -964,8 +1013,7 @@ mod tests {
         let row = Field::convert_int64(&descr, 2222);
         assert_eq!(row, Field::Long(2222));
 
-        let descr =
-            make_column_descr![PhysicalType::INT64, ConvertedType::DECIMAL, 0, 8, 2];
+        let descr = make_column_descr![PhysicalType::INT64, ConvertedType::DECIMAL, 0, 8, 2];
         let row = Field::convert_int64(&descr, 3333);
         assert_eq!(row, Field::Decimal(Decimal::from_i64(3333, 8, 2)));
     }
@@ -1006,38 +1054,40 @@ mod tests {
         let descr = make_column_descr![PhysicalType::BYTE_ARRAY, ConvertedType::UTF8];
         let value = ByteArray::from(vec![b'A', b'B', b'C', b'D']);
         let row = Field::convert_byte_array(&descr, value);
-        assert_eq!(row, Field::Str("ABCD".to_string()));
+        assert_eq!(row.unwrap(), Field::Str("ABCD".to_string()));
 
         // ENUM
         let descr = make_column_descr![PhysicalType::BYTE_ARRAY, ConvertedType::ENUM];
         let value = ByteArray::from(vec![b'1', b'2', b'3']);
         let row = Field::convert_byte_array(&descr, value);
-        assert_eq!(row, Field::Str("123".to_string()));
+        assert_eq!(row.unwrap(), Field::Str("123".to_string()));
 
         // JSON
         let descr = make_column_descr![PhysicalType::BYTE_ARRAY, ConvertedType::JSON];
         let value = ByteArray::from(vec![b'{', b'"', b'a', b'"', b':', b'1', b'}']);
         let row = Field::convert_byte_array(&descr, value);
-        assert_eq!(row, Field::Str("{\"a\":1}".to_string()));
+        assert_eq!(row.unwrap(), Field::Str("{\"a\":1}".to_string()));
 
         // NONE
         let descr = make_column_descr![PhysicalType::BYTE_ARRAY, ConvertedType::NONE];
         let value = ByteArray::from(vec![1, 2, 3, 4, 5]);
         let row = Field::convert_byte_array(&descr, value.clone());
-        assert_eq!(row, Field::Bytes(value));
+        assert_eq!(row.unwrap(), Field::Bytes(value));
 
         // BSON
         let descr = make_column_descr![PhysicalType::BYTE_ARRAY, ConvertedType::BSON];
         let value = ByteArray::from(vec![1, 2, 3, 4, 5]);
         let row = Field::convert_byte_array(&descr, value.clone());
-        assert_eq!(row, Field::Bytes(value));
+        assert_eq!(row.unwrap(), Field::Bytes(value));
 
         // DECIMAL
-        let descr =
-            make_column_descr![PhysicalType::BYTE_ARRAY, ConvertedType::DECIMAL, 0, 8, 2];
+        let descr = make_column_descr![PhysicalType::BYTE_ARRAY, ConvertedType::DECIMAL, 0, 8, 2];
         let value = ByteArray::from(vec![207, 200]);
         let row = Field::convert_byte_array(&descr, value.clone());
-        assert_eq!(row, Field::Decimal(Decimal::from_bytes(value, 8, 2)));
+        assert_eq!(
+            row.unwrap(),
+            Field::Decimal(Decimal::from_bytes(value, 8, 2))
+        );
 
         // DECIMAL (FIXED_LEN_BYTE_ARRAY)
         let descr = make_column_descr![
@@ -1049,7 +1099,28 @@ mod tests {
         ];
         let value = ByteArray::from(vec![0, 0, 0, 0, 0, 4, 147, 224]);
         let row = Field::convert_byte_array(&descr, value.clone());
-        assert_eq!(row, Field::Decimal(Decimal::from_bytes(value, 17, 5)));
+        assert_eq!(
+            row.unwrap(),
+            Field::Decimal(Decimal::from_bytes(value, 17, 5))
+        );
+
+        // FLOAT16
+        let descr = {
+            let tpe = PrimitiveTypeBuilder::new("col", PhysicalType::FIXED_LEN_BYTE_ARRAY)
+                .with_logical_type(Some(LogicalType::Float16))
+                .with_length(2)
+                .build()
+                .unwrap();
+            Arc::new(ColumnDescriptor::new(
+                Arc::new(tpe),
+                0,
+                0,
+                ColumnPath::from("col"),
+            ))
+        };
+        let value = ByteArray::from(f16::PI);
+        let row = Field::convert_byte_array(&descr, value.clone());
+        assert_eq!(row.unwrap(), Field::Float16(f16::PI));
 
         // NONE (FIXED_LEN_BYTE_ARRAY)
         let descr = make_column_descr![
@@ -1061,19 +1132,23 @@ mod tests {
         ];
         let value = ByteArray::from(vec![1, 2, 3, 4, 5, 6]);
         let row = Field::convert_byte_array(&descr, value.clone());
-        assert_eq!(row, Field::Bytes(value));
+        assert_eq!(row.unwrap(), Field::Bytes(value));
     }
 
     #[test]
     fn test_convert_date_to_string() {
         fn check_date_conversion(y: u32, m: u32, d: u32) {
-            let datetime = chrono::NaiveDate::from_ymd(y as i32, m, d).and_hms(0, 0, 0);
+            let datetime = chrono::NaiveDate::from_ymd_opt(y as i32, m, d)
+                .unwrap()
+                .and_hms_opt(0, 0, 0)
+                .unwrap();
             let dt = Utc.from_utc_datetime(&datetime);
-            let res = convert_date_to_string((dt.timestamp() / 60 / 60 / 24) as u32);
-            let exp = format!("{}", dt.format("%Y-%m-%d %:z"));
+            let res = convert_date_to_string((dt.timestamp() / 60 / 60 / 24) as i32);
+            let exp = format!("{}", dt.format("%Y-%m-%d"));
             assert_eq!(res, exp);
         }
 
+        check_date_conversion(1969, 12, 31);
         check_date_conversion(2010, 1, 2);
         check_date_conversion(2014, 5, 1);
         check_date_conversion(2016, 2, 29);
@@ -1082,15 +1157,40 @@ mod tests {
     }
 
     #[test]
-    fn test_convert_timestamp_to_string() {
+    fn test_convert_timestamp_millis_to_string() {
+        fn check_datetime_conversion(y: u32, m: u32, d: u32, h: u32, mi: u32, s: u32) {
+            let datetime = chrono::NaiveDate::from_ymd_opt(y as i32, m, d)
+                .unwrap()
+                .and_hms_opt(h, mi, s)
+                .unwrap();
+            let dt = Utc.from_utc_datetime(&datetime);
+            let res = convert_timestamp_millis_to_string(dt.timestamp_millis());
+            let exp = format!("{}", dt.format("%Y-%m-%d %H:%M:%S %:z"));
+            assert_eq!(res, exp);
+        }
+
+        check_datetime_conversion(1969, 9, 10, 1, 2, 3);
+        check_datetime_conversion(2010, 1, 2, 13, 12, 54);
+        check_datetime_conversion(2011, 1, 3, 8, 23, 1);
+        check_datetime_conversion(2012, 4, 5, 11, 6, 32);
+        check_datetime_conversion(2013, 5, 12, 16, 38, 0);
+        check_datetime_conversion(2014, 11, 28, 21, 15, 12);
+    }
+
+    #[test]
+    fn test_convert_timestamp_micros_to_string() {
         fn check_datetime_conversion(y: u32, m: u32, d: u32, h: u32, mi: u32, s: u32) {
-            let datetime = chrono::NaiveDate::from_ymd(y as i32, m, d).and_hms(h, mi, s);
+            let datetime = chrono::NaiveDate::from_ymd_opt(y as i32, m, d)
+                .unwrap()
+                .and_hms_opt(h, mi, s)
+                .unwrap();
             let dt = Utc.from_utc_datetime(&datetime);
-            let res = convert_timestamp_millis_to_string(dt.timestamp_millis() as u64);
+            let res = convert_timestamp_micros_to_string(dt.timestamp_micros());
             let exp = format!("{}", dt.format("%Y-%m-%d %H:%M:%S %:z"));
             assert_eq!(res, exp);
         }
 
+        check_datetime_conversion(1969, 9, 10, 1, 2, 3);
         check_datetime_conversion(2010, 1, 2, 13, 12, 54);
         check_datetime_conversion(2011, 1, 3, 8, 23, 1);
         check_datetime_conversion(2012, 4, 5, 11, 6, 32);
@@ -1098,6 +1198,18 @@ mod tests {
         check_datetime_conversion(2014, 11, 28, 21, 15, 12);
     }
 
+    #[test]
+    fn test_convert_float16_to_string() {
+        assert_eq!(format!("{}", Field::Float16(f16::ONE)), "1.0");
+        assert_eq!(format!("{}", Field::Float16(f16::PI)), "3.140625");
+        assert_eq!(format!("{}", Field::Float16(f16::MAX)), "65504.0");
+        assert_eq!(format!("{}", Field::Float16(f16::NAN)), "NaN");
+        assert_eq!(format!("{}", Field::Float16(f16::INFINITY)), "inf");
+        assert_eq!(format!("{}", Field::Float16(f16::NEG_INFINITY)), "-inf");
+        assert_eq!(format!("{}", Field::Float16(f16::ZERO)), "0.0");
+        assert_eq!(format!("{}", Field::Float16(f16::NEG_ZERO)), "-0.0");
+    }
+
     #[test]
     fn test_convert_float_to_string() {
         assert_eq!(format!("{}", Field::Float(1.0)), "1.0");
@@ -1171,6 +1283,7 @@ mod tests {
         assert_eq!(format!("{}", Field::UShort(2)), "2");
         assert_eq!(format!("{}", Field::UInt(3)), "3");
         assert_eq!(format!("{}", Field::ULong(4)), "4");
+        assert_eq!(format!("{}", Field::Float16(f16::E)), "2.71875");
         assert_eq!(format!("{}", Field::Float(5.0)), "5.0");
         assert_eq!(format!("{}", Field::Float(5.1234)), "5.1234");
         assert_eq!(format!("{}", Field::Double(6.0)), "6.0");
@@ -1205,7 +1318,7 @@ mod tests {
             ("a".to_string(), Field::Str("abc".to_string())),
         ];
         let row = Field::Group(make_row(fields));
-        assert_eq!(format!("{}", row), "{x: null, Y: 2, z: 3.1, a: \"abc\"}");
+        assert_eq!(format!("{row}"), "{x: null, Y: 2, z: 3.1, a: \"abc\"}");
 
         let row = Field::ListInternal(make_list(vec![
             Field::Int(2),
@@ -1213,14 +1326,14 @@ mod tests {
             Field::Null,
             Field::Int(12),
         ]));
-        assert_eq!(format!("{}", row), "[2, 1, null, 12]");
+        assert_eq!(format!("{row}"), "[2, 1, null, 12]");
 
         let row = Field::MapInternal(make_map(vec![
             (Field::Int(1), Field::Float(1.2)),
             (Field::Int(2), Field::Float(4.5)),
             (Field::Int(3), Field::Float(2.3)),
         ]));
-        assert_eq!(format!("{}", row), "{1 -> 1.2, 2 -> 4.5, 3 -> 2.3}");
+        assert_eq!(format!("{row}"), "{1 -> 1.2, 2 -> 4.5, 3 -> 2.3}");
     }
 
     #[test]
@@ -1237,6 +1350,7 @@ mod tests {
         assert!(Field::UShort(2).is_primitive());
         assert!(Field::UInt(3).is_primitive());
         assert!(Field::ULong(4).is_primitive());
+        assert!(Field::Float16(f16::E).is_primitive());
         assert!(Field::Float(5.0).is_primitive());
         assert!(Field::Float(5.1234).is_primitive());
         assert!(Field::Double(6.0).is_primitive());
@@ -1297,6 +1411,7 @@ mod tests {
             ("15".to_string(), Field::TimestampMillis(1262391174000)),
             ("16".to_string(), Field::TimestampMicros(1262391174000000)),
             ("17".to_string(), Field::Decimal(Decimal::from_i32(4, 7, 2))),
+            ("18".to_string(), Field::Float16(f16::PI)),
         ]);
 
         assert_eq!("null", format!("{}", row.fmt(0)));
@@ -1323,6 +1438,7 @@ mod tests {
             format!("{}", row.fmt(16))
         );
         assert_eq!("0.04", format!("{}", row.fmt(17)));
+        assert_eq!("3.140625", format!("{}", row.fmt(18)));
     }
 
     #[test]
@@ -1382,6 +1498,7 @@ mod tests {
                 Field::Bytes(ByteArray::from(vec![1, 2, 3, 4, 5])),
             ),
             ("o".to_string(), Field::Decimal(Decimal::from_i32(4, 7, 2))),
+            ("p".to_string(), Field::Float16(f16::from_f32(9.1))),
         ]);
 
         assert!(!row.get_bool(1).unwrap());
@@ -1398,6 +1515,7 @@ mod tests {
         assert_eq!("abc", row.get_string(12).unwrap());
         assert_eq!(5, row.get_bytes(13).unwrap().len());
         assert_eq!(7, row.get_decimal(14).unwrap().precision());
+        assert!((f16::from_f32(9.1) - row.get_float16(15).unwrap()).abs() < f16::EPSILON);
     }
 
     #[test]
@@ -1422,6 +1540,7 @@ mod tests {
                 Field::Bytes(ByteArray::from(vec![1, 2, 3, 4, 5])),
             ),
             ("o".to_string(), Field::Decimal(Decimal::from_i32(4, 7, 2))),
+            ("p".to_string(), Field::Float16(f16::from_f32(9.1))),
         ]);
 
         for i in 0..row.len() {
@@ -1493,16 +1612,16 @@ mod tests {
         ]);
 
         assert_eq!(
-            ParquetError::General("Cannot access Group as Float".to_string()),
-            row.get_float(0).unwrap_err()
+            row.get_float(0).unwrap_err().to_string(),
+            "Parquet error: Cannot access Group as Float"
         );
         assert_eq!(
-            ParquetError::General("Cannot access ListInternal as Float".to_string()),
-            row.get_float(1).unwrap_err()
+            row.get_float(1).unwrap_err().to_string(),
+            "Parquet error: Cannot access ListInternal as Float"
         );
         assert_eq!(
-            ParquetError::General("Cannot access MapInternal as Float".to_string()),
-            row.get_float(2).unwrap_err()
+            row.get_float(2).unwrap_err().to_string(),
+            "Parquet error: Cannot access MapInternal as Float",
         );
     }
 
@@ -1536,6 +1655,9 @@ mod tests {
         let list = make_list(vec![Field::ULong(6), Field::ULong(7)]);
         assert_eq!(7, list.get_ulong(1).unwrap());
 
+        let list = make_list(vec![Field::Float16(f16::PI)]);
+        assert!((f16::PI - list.get_float16(0).unwrap()).abs() < f16::EPSILON);
+
         let list = make_list(vec![
             Field::Float(8.1),
             Field::Float(9.2),
@@ -1543,8 +1665,8 @@ mod tests {
         ]);
         assert!((10.3 - list.get_float(2).unwrap()).abs() < f32::EPSILON);
 
-        let list = make_list(vec![Field::Double(3.1415)]);
-        assert!((3.1415 - list.get_double(0).unwrap()).abs() < f64::EPSILON);
+        let list = make_list(vec![Field::Double(PI)]);
+        assert!((PI - list.get_double(0).unwrap()).abs() < f64::EPSILON);
 
         let list = make_list(vec![Field::Str("abc".to_string())]);
         assert_eq!(&"abc".to_string(), list.get_string(0).unwrap());
@@ -1586,6 +1708,9 @@ mod tests {
         let list = make_list(vec![Field::ULong(6), Field::ULong(7)]);
         assert!(list.get_float(1).is_err());
 
+        let list = make_list(vec![Field::Float16(f16::PI)]);
+        assert!(list.get_string(0).is_err());
+
         let list = make_list(vec![
             Field::Float(8.1),
             Field::Float(9.2),
@@ -1593,7 +1718,7 @@ mod tests {
         ]);
         assert!(list.get_double(2).is_err());
 
-        let list = make_list(vec![Field::Double(3.1415)]);
+        let list = make_list(vec![Field::Double(PI)]);
         assert!(list.get_string(0).is_err());
 
         let list = make_list(vec![Field::Str("abc".to_string())]);
@@ -1637,8 +1762,8 @@ mod tests {
             ("Y".to_string(), Field::Int(2)),
         ]))]);
         assert_eq!(
-            general_err!("Cannot access Group as Float".to_string()),
-            list.get_float(0).unwrap_err()
+            list.get_float(0).unwrap_err().to_string(),
+            "Parquet error: Cannot access Group as Float"
         );
 
         let list = make_list(vec![Field::ListInternal(make_list(vec![
@@ -1648,8 +1773,8 @@ mod tests {
             Field::Int(12),
         ]))]);
         assert_eq!(
-            general_err!("Cannot access ListInternal as Float".to_string()),
-            list.get_float(0).unwrap_err()
+            list.get_float(0).unwrap_err().to_string(),
+            "Parquet error: Cannot access ListInternal as Float"
         );
 
         let list = make_list(vec![Field::MapInternal(make_map(vec![
@@ -1658,8 +1783,8 @@ mod tests {
             (Field::Int(3), Field::Float(2.3)),
         ]))]);
         assert_eq!(
-            general_err!("Cannot access MapInternal as Float".to_string()),
-            list.get_float(0).unwrap_err()
+            list.get_float(0).unwrap_err().to_string(),
+            "Parquet error: Cannot access MapInternal as Float",
         );
     }
 
@@ -1721,6 +1846,10 @@ mod tests {
             Field::ULong(4).to_json_value(),
             Value::Number(serde_json::Number::from(4))
         );
+        assert_eq!(
+            Field::Float16(f16::from_f32(5.0)).to_json_value(),
+            Value::Number(serde_json::Number::from_f64(5.0).unwrap())
+        );
         assert_eq!(
             Field::Float(5.0).to_json_value(),
             Value::Number(serde_json::Number::from_f64(5.0).unwrap())
@@ -1769,11 +1898,7 @@ mod tests {
             serde_json::json!({"X": 1, "Y": 2.2, "Z": "abc"})
         );
 
-        let row = Field::ListInternal(make_list(vec![
-            Field::Int(1),
-            Field::Int(12),
-            Field::Null,
-        ]));
+        let row = Field::ListInternal(make_list(vec![Field::Int(1), Field::Int(12), Field::Null]));
         let array = vec![
             Value::Number(serde_json::Number::from(1)),
             Value::Number(serde_json::Number::from(12)),
@@ -1794,7 +1919,7 @@ mod tests {
 }
 
 #[cfg(test)]
-#[allow(clippy::approx_constant, clippy::many_single_char_names)]
+#[allow(clippy::many_single_char_names)]
 mod api_tests {
     use super::{make_list, make_map, make_row};
     use crate::record::Field;
diff --git a/parquet/src/record/mod.rs b/parquet/src/record/mod.rs
index ce83cfa2b14a..f40e91418da1 100644
--- a/parquet/src/record/mod.rs
+++ b/parquet/src/record/mod.rs
@@ -19,13 +19,14 @@
 
 mod api;
 pub mod reader;
+mod record_reader;
 mod record_writer;
 mod triplet;
 
 pub use self::{
     api::{
-        Field, List, ListAccessor, Map, MapAccessor, Row, RowAccessor, RowColumnIter,
-        RowFormatter,
+        Field, List, ListAccessor, Map, MapAccessor, Row, RowAccessor, RowColumnIter, RowFormatter,
     },
+    record_reader::RecordReader,
     record_writer::RecordWriter,
 };
diff --git a/parquet/src/record/reader.rs b/parquet/src/record/reader.rs
index 0b7e04587354..c6bf8f1f93e6 100644
--- a/parquet/src/record/reader.rs
+++ b/parquet/src/record/reader.rs
@@ -16,7 +16,7 @@
 // under the License.
 
 //! Contains implementation of record assembly and converting Parquet types into
-//! [`Row`](crate::record::Row)s.
+//! [`Row`]s.
 
 use std::{collections::HashMap, fmt, sync::Arc};
 
@@ -65,7 +65,7 @@ impl TreeBuilder {
         &self,
         descr: SchemaDescPtr,
         row_group_reader: &dyn RowGroupReader,
-    ) -> Reader {
+    ) -> Result<Reader> {
         // Prepare lookup table of column path -> original column index
         // This allows to prune columns and map schema leaf nodes to the column readers
         let mut paths: HashMap<ColumnPath, usize> = HashMap::new();
@@ -82,20 +82,14 @@ impl TreeBuilder {
         let mut path = Vec::new();
 
         for field in descr.root_schema().get_fields() {
-            let reader = self.reader_tree(
-                field.clone(),
-                &mut path,
-                0,
-                0,
-                &paths,
-                row_group_reader,
-            );
+            let reader =
+                self.reader_tree(field.clone(), &mut path, 0, 0, &paths, row_group_reader)?;
             readers.push(reader);
         }
 
         // Return group reader for message type,
         // it is always required with definition level 0
-        Reader::GroupReader(None, 0, readers)
+        Ok(Reader::GroupReader(None, 0, readers))
     }
 
     /// Creates iterator of `Row`s directly from schema descriptor and row group.
@@ -103,9 +97,9 @@ impl TreeBuilder {
         &self,
         descr: SchemaDescPtr,
         row_group_reader: &dyn RowGroupReader,
-    ) -> ReaderIter {
+    ) -> Result<ReaderIter> {
         let num_records = row_group_reader.metadata().num_rows() as usize;
-        ReaderIter::new(self.build(descr, row_group_reader), num_records)
+        ReaderIter::new(self.build(descr, row_group_reader)?, num_records)
     }
 
     /// Builds tree of readers for the current schema recursively.
@@ -117,7 +111,7 @@ impl TreeBuilder {
         mut curr_rep_level: i16,
         paths: &HashMap<ColumnPath, usize>,
         row_group_reader: &dyn RowGroupReader,
-    ) -> Reader {
+    ) -> Result<Reader> {
         assert!(field.get_basic_info().has_repetition());
         // Update current definition and repetition levels for this type
         let repetition = field.get_basic_info().repetition();
@@ -135,31 +129,27 @@ impl TreeBuilder {
         path.push(String::from(field.name()));
         let reader = if field.is_primitive() {
             let col_path = ColumnPath::new(path.to_vec());
-            let orig_index = *paths.get(&col_path).unwrap();
+            let orig_index = *paths
+                .get(&col_path)
+                .ok_or(general_err!("Path {:?} not found", col_path))?;
             let col_descr = row_group_reader
                 .metadata()
                 .column(orig_index)
                 .column_descr_ptr();
-            let col_reader = row_group_reader.get_column_reader(orig_index).unwrap();
+            let col_reader = row_group_reader.get_column_reader(orig_index)?;
             let column = TripletIter::new(col_descr, col_reader, self.batch_size);
             Reader::PrimitiveReader(field, Box::new(column))
         } else {
             match field.get_basic_info().converted_type() {
                 // List types
                 ConvertedType::LIST => {
-                    assert_eq!(
-                        field.get_fields().len(),
-                        1,
-                        "Invalid list type {:?}",
-                        field
-                    );
+                    assert_eq!(field.get_fields().len(), 1, "Invalid list type {field:?}");
 
                     let repeated_field = field.get_fields()[0].clone();
                     assert_eq!(
                         repeated_field.get_basic_info().repetition(),
                         Repetition::REPEATED,
-                        "Invalid list type {:?}",
-                        field
+                        "Invalid list type {field:?}"
                     );
 
                     if Reader::is_element_type(&repeated_field) {
@@ -171,7 +161,7 @@ impl TreeBuilder {
                             curr_rep_level,
                             paths,
                             row_group_reader,
-                        );
+                        )?;
 
                         Reader::RepeatedReader(
                             field,
@@ -191,7 +181,7 @@ impl TreeBuilder {
                             curr_rep_level + 1,
                             paths,
                             row_group_reader,
-                        );
+                        )?;
 
                         path.pop();
 
@@ -205,30 +195,22 @@ impl TreeBuilder {
                 }
                 // Map types (key-value pairs)
                 ConvertedType::MAP | ConvertedType::MAP_KEY_VALUE => {
-                    assert_eq!(
-                        field.get_fields().len(),
-                        1,
-                        "Invalid map type: {:?}",
-                        field
-                    );
+                    assert_eq!(field.get_fields().len(), 1, "Invalid map type: {field:?}");
                     assert!(
                         !field.get_fields()[0].is_primitive(),
-                        "Invalid map type: {:?}",
-                        field
+                        "Invalid map type: {field:?}"
                     );
 
                     let key_value_type = field.get_fields()[0].clone();
                     assert_eq!(
                         key_value_type.get_basic_info().repetition(),
                         Repetition::REPEATED,
-                        "Invalid map type: {:?}",
-                        field
+                        "Invalid map type: {field:?}"
                     );
                     assert_eq!(
                         key_value_type.get_fields().len(),
                         2,
-                        "Invalid map type: {:?}",
-                        field
+                        "Invalid map type: {field:?}"
                     );
 
                     path.push(String::from(key_value_type.name()));
@@ -236,8 +218,7 @@ impl TreeBuilder {
                     let key_type = &key_value_type.get_fields()[0];
                     assert!(
                         key_type.is_primitive(),
-                        "Map key type is expected to be a primitive type, but found {:?}",
-                        key_type
+                        "Map key type is expected to be a primitive type, but found {key_type:?}"
                     );
                     let key_reader = self.reader_tree(
                         key_type.clone(),
@@ -246,7 +227,7 @@ impl TreeBuilder {
                         curr_rep_level + 1,
                         paths,
                         row_group_reader,
-                    );
+                    )?;
 
                     let value_type = &key_value_type.get_fields()[1];
                     let value_reader = self.reader_tree(
@@ -256,7 +237,7 @@ impl TreeBuilder {
                         curr_rep_level + 1,
                         paths,
                         row_group_reader,
-                    );
+                    )?;
 
                     path.pop();
 
@@ -276,9 +257,8 @@ impl TreeBuilder {
                     let required_field = Type::group_type_builder(field.name())
                         .with_repetition(Repetition::REQUIRED)
                         .with_converted_type(field.get_basic_info().converted_type())
-                        .with_fields(&mut Vec::from(field.get_fields()))
-                        .build()
-                        .unwrap();
+                        .with_fields(field.get_fields().to_vec())
+                        .build()?;
 
                     path.pop();
 
@@ -289,14 +269,14 @@ impl TreeBuilder {
                         curr_rep_level,
                         paths,
                         row_group_reader,
-                    );
+                    )?;
 
-                    Reader::RepeatedReader(
+                    return Ok(Reader::RepeatedReader(
                         field,
                         curr_def_level - 1,
                         curr_rep_level - 1,
                         Box::new(reader),
-                    )
+                    ));
                 }
                 // Group types (structs)
                 _ => {
@@ -309,7 +289,7 @@ impl TreeBuilder {
                             curr_rep_level,
                             paths,
                             row_group_reader,
-                        );
+                        )?;
                         readers.push(reader);
                     }
                     Reader::GroupReader(Some(field), curr_def_level, readers)
@@ -318,7 +298,7 @@ impl TreeBuilder {
         };
         path.pop();
 
-        Reader::option(repetition, curr_def_level, reader)
+        Ok(Reader::option(repetition, curr_def_level, reader))
     }
 }
 
@@ -402,33 +382,33 @@ impl Reader {
     /// Automatically advances all necessary readers.
     /// This must be called on the root level reader (i.e., for Message type).
     /// Otherwise, it will panic.
-    fn read(&mut self) -> Row {
+    fn read(&mut self) -> Result<Row> {
         match *self {
             Reader::GroupReader(_, _, ref mut readers) => {
                 let mut fields = Vec::new();
                 for reader in readers {
-                    fields.push((String::from(reader.field_name()), reader.read_field()));
+                    fields.push((String::from(reader.field_name()), reader.read_field()?));
                 }
-                make_row(fields)
+                Ok(make_row(fields))
             }
-            _ => panic!("Cannot call read() on {}", self),
+            _ => panic!("Cannot call read() on {self}"),
         }
     }
 
     /// Reads current record as `Field` from the reader tree.
     /// Automatically advances all necessary readers.
-    fn read_field(&mut self) -> Field {
-        match *self {
+    fn read_field(&mut self) -> Result<Field> {
+        let field = match *self {
             Reader::PrimitiveReader(_, ref mut column) => {
-                let value = column.current_value();
-                column.read_next().unwrap();
+                let value = column.current_value()?;
+                column.read_next()?;
                 value
             }
             Reader::OptionReader(def_level, ref mut reader) => {
                 if reader.current_def_level() > def_level {
-                    reader.read_field()
+                    reader.read_field()?
                 } else {
-                    reader.advance_columns();
+                    reader.advance_columns()?;
                     Field::Null
                 }
             }
@@ -438,12 +418,9 @@ impl Reader {
                     if reader.repetition() != Repetition::OPTIONAL
                         || reader.current_def_level() > def_level
                     {
-                        fields.push((
-                            String::from(reader.field_name()),
-                            reader.read_field(),
-                        ));
+                        fields.push((String::from(reader.field_name()), reader.read_field()?));
                     } else {
-                        reader.advance_columns();
+                        reader.advance_columns()?;
                         fields.push((String::from(reader.field_name()), Field::Null));
                     }
                 }
@@ -454,9 +431,9 @@ impl Reader {
                 let mut elements = Vec::new();
                 loop {
                     if reader.current_def_level() > def_level {
-                        elements.push(reader.read_field());
+                        elements.push(reader.read_field()?);
                     } else {
-                        reader.advance_columns();
+                        reader.advance_columns()?;
                         // If the current definition level is equal to the definition
                         // level of this repeated type, then the
                         // result is an empty list and the repetition level
@@ -473,20 +450,14 @@ impl Reader {
                 }
                 Field::ListInternal(make_list(elements))
             }
-            Reader::KeyValueReader(
-                _,
-                def_level,
-                rep_level,
-                ref mut keys,
-                ref mut values,
-            ) => {
+            Reader::KeyValueReader(_, def_level, rep_level, ref mut keys, ref mut values) => {
                 let mut pairs = Vec::new();
                 loop {
                     if keys.current_def_level() > def_level {
-                        pairs.push((keys.read_field(), values.read_field()));
+                        pairs.push((keys.read_field()?, values.read_field()?));
                     } else {
-                        keys.advance_columns();
-                        values.advance_columns();
+                        keys.advance_columns()?;
+                        values.advance_columns()?;
                         // If the current definition level is equal to the definition
                         // level of this repeated type, then the
                         // result is an empty list and the repetition level
@@ -504,7 +475,8 @@ impl Reader {
 
                 Field::MapInternal(make_map(pairs))
             }
-        }
+        };
+        Ok(field)
     }
 
     /// Returns field name for the current reader.
@@ -578,25 +550,20 @@ impl Reader {
     }
 
     /// Advances leaf columns for the current reader.
-    fn advance_columns(&mut self) {
+    fn advance_columns(&mut self) -> Result<()> {
         match *self {
-            Reader::PrimitiveReader(_, ref mut column) => {
-                column.read_next().unwrap();
-            }
-            Reader::OptionReader(_, ref mut reader) => {
-                reader.advance_columns();
-            }
+            Reader::PrimitiveReader(_, ref mut column) => column.read_next().map(|_| ()),
+            Reader::OptionReader(_, ref mut reader) => reader.advance_columns(),
             Reader::GroupReader(_, _, ref mut readers) => {
                 for reader in readers {
-                    reader.advance_columns();
+                    reader.advance_columns()?;
                 }
+                Ok(())
             }
-            Reader::RepeatedReader(_, _, _, ref mut reader) => {
-                reader.advance_columns();
-            }
+            Reader::RepeatedReader(_, _, _, ref mut reader) => reader.advance_columns(),
             Reader::KeyValueReader(_, _, _, ref mut keys, ref mut values) => {
-                keys.advance_columns();
-                values.advance_columns();
+                keys.advance_columns()?;
+                values.advance_columns()
             }
         }
     }
@@ -611,15 +578,15 @@ impl fmt::Display for Reader {
             Reader::RepeatedReader(..) => "RepeatedReader",
             Reader::KeyValueReader(..) => "KeyValueReader",
         };
-        write!(f, "{}", s)
+        write!(f, "{s}")
     }
 }
 
 // ----------------------------------------------------------------------
 // Row iterators
 
-/// The enum Either with variants That represet a reference and a box of
-/// [`FileReader`](crate::file::reader::FileReader).
+/// The enum Either with variants That represents a reference and a box of
+/// [`FileReader`].
 enum Either<'a> {
     Left(&'a dyn FileReader),
     Right(Box<dyn FileReader>),
@@ -634,9 +601,20 @@ impl<'a> Either<'a> {
     }
 }
 
-/// Iterator of [`Row`](crate::record::Row)s.
-/// It is used either for a single row group to iterate over data in that row group, or
-/// an entire file with auto buffering of all row groups.
+/// Access parquet data as an iterator of [`Row`]
+///
+/// # Caveats
+///
+/// Parquet stores data in a columnar fashion using [Dremel] encoding, and is therefore highly
+/// optimised for reading data by column, not row. As a consequence applications concerned with
+/// performance should prefer the columnar arrow or [ColumnReader] APIs.
+///
+/// Additionally the current implementation does not correctly handle repeated fields ([#2394]),
+/// and workloads looking to handle such schema should use the other APIs.
+///
+/// [#2394]: https://github.com/apache/arrow-rs/issues/2394
+/// [ColumnReader]: crate::file::reader::RowGroupReader::get_column_reader
+/// [Dremel]: https://research.google/pubs/pub36632/
 pub struct RowIter<'a> {
     descr: SchemaDescPtr,
     tree_builder: TreeBuilder,
@@ -647,7 +625,7 @@ pub struct RowIter<'a> {
 }
 
 impl<'a> RowIter<'a> {
-    /// Creates a new iterator of [`Row`](crate::record::Row)s.
+    /// Creates a new iterator of [`Row`]s.
     fn new(
         file_reader: Option<Either<'a>>,
         row_iter: Option<ReaderIter>,
@@ -669,34 +647,28 @@ impl<'a> RowIter<'a> {
         }
     }
 
-    /// Creates iterator of [`Row`](crate::record::Row)s for all row groups in a
+    /// Creates iterator of [`Row`]s for all row groups in a
     /// file.
     pub fn from_file(proj: Option<Type>, reader: &'a dyn FileReader) -> Result<Self> {
         let either = Either::Left(reader);
-        let descr = Self::get_proj_descr(
-            proj,
-            reader.metadata().file_metadata().schema_descr_ptr(),
-        )?;
+        let descr =
+            Self::get_proj_descr(proj, reader.metadata().file_metadata().schema_descr_ptr())?;
 
         Ok(Self::new(Some(either), None, descr))
     }
 
-    /// Creates iterator of [`Row`](crate::record::Row)s for a specific row group.
-    pub fn from_row_group(
-        proj: Option<Type>,
-        reader: &'a dyn RowGroupReader,
-    ) -> Result<Self> {
+    /// Creates iterator of [`Row`]s for a specific row group.
+    pub fn from_row_group(proj: Option<Type>, reader: &'a dyn RowGroupReader) -> Result<Self> {
         let descr = Self::get_proj_descr(proj, reader.metadata().schema_descr_ptr())?;
         let tree_builder = Self::tree_builder();
-        let row_iter = tree_builder.as_iter(descr.clone(), reader);
+        let row_iter = tree_builder.as_iter(descr.clone(), reader)?;
 
         // For row group we need to set `current_row_group` >= `num_row_groups`, because
         // we only have one row group and can't buffer more.
         Ok(Self::new(None, Some(row_iter), descr))
     }
 
-    /// Creates a iterator of [`Row`](crate::record::Row)s from a
-    /// [`FileReader`](crate::file::reader::FileReader) using the full file schema.
+    /// Creates a iterator of [`Row`]s from a [`FileReader`] using the full file schema.
     pub fn from_file_into(reader: Box<dyn FileReader>) -> Self {
         let either = Either::Right(reader);
         let descr = either
@@ -708,7 +680,7 @@ impl<'a> RowIter<'a> {
         Self::new(Some(either), None, descr)
     }
 
-    /// Tries to create a iterator of [`Row`](crate::record::Row)s using projections.
+    /// Tries to create a iterator of [`Row`]s using projections.
     /// Returns a error if a file reader is not the source of this iterator.
     ///
     /// The Projected schema can be a subset of or equal to the file schema,
@@ -732,10 +704,7 @@ impl<'a> RowIter<'a> {
     /// Helper method to get schema descriptor for projected schema.
     /// If projection is None, then full schema is returned.
     #[inline]
-    fn get_proj_descr(
-        proj: Option<Type>,
-        root_descr: SchemaDescPtr,
-    ) -> Result<SchemaDescPtr> {
+    fn get_proj_descr(proj: Option<Type>, root_descr: SchemaDescPtr) -> Result<SchemaDescPtr> {
         match proj {
             Some(projection) => {
                 // check if projection is part of file schema
@@ -749,6 +718,12 @@ impl<'a> RowIter<'a> {
         }
     }
 
+    /// Sets batch size for this row iter.
+    pub fn with_batch_size(mut self, batch_size: usize) -> Self {
+        self.tree_builder = self.tree_builder.with_batch_size(batch_size);
+        self
+    }
+
     /// Returns common tree builder, so the same settings are applied to both iterators
     /// from file reader and row group.
     #[inline]
@@ -758,9 +733,9 @@ impl<'a> RowIter<'a> {
 }
 
 impl<'a> Iterator for RowIter<'a> {
-    type Item = Row;
+    type Item = Result<Row>;
 
-    fn next(&mut self) -> Option<Row> {
+    fn next(&mut self) -> Option<Result<Row>> {
         let mut row = None;
         if let Some(ref mut iter) = self.row_iter {
             row = iter.next();
@@ -775,14 +750,18 @@ impl<'a> Iterator for RowIter<'a> {
                     .get_row_group(self.current_row_group)
                     .expect("Row group is required to advance");
 
-                let mut iter = self
+                match self
                     .tree_builder
-                    .as_iter(self.descr.clone(), row_group_reader);
+                    .as_iter(self.descr.clone(), row_group_reader)
+                {
+                    Ok(mut iter) => {
+                        row = iter.next();
 
-                row = iter.next();
-
-                self.current_row_group += 1;
-                self.row_iter = Some(iter);
+                        self.current_row_group += 1;
+                        self.row_iter = Some(iter);
+                    }
+                    Err(e) => return Some(Err(e)),
+                }
             }
         }
 
@@ -790,27 +769,27 @@ impl<'a> Iterator for RowIter<'a> {
     }
 }
 
-/// Internal iterator of [`Row`](crate::record::Row)s for a reader.
+/// Internal iterator of [`Row`]s for a reader.
 pub struct ReaderIter {
     root_reader: Reader,
     records_left: usize,
 }
 
 impl ReaderIter {
-    fn new(mut root_reader: Reader, num_records: usize) -> Self {
+    fn new(mut root_reader: Reader, num_records: usize) -> Result<Self> {
         // Prepare root reader by advancing all column vectors
-        root_reader.advance_columns();
-        Self {
+        root_reader.advance_columns()?;
+        Ok(Self {
             root_reader,
             records_left: num_records,
-        }
+        })
     }
 }
 
 impl Iterator for ReaderIter {
-    type Item = Row;
+    type Item = Result<Row>;
 
-    fn next(&mut self) -> Option<Row> {
+    fn next(&mut self) -> Option<Result<Row>> {
         if self.records_left > 0 {
             self.records_left -= 1;
             Some(self.root_reader.read())
@@ -824,11 +803,14 @@ impl Iterator for ReaderIter {
 mod tests {
     use super::*;
 
-    use crate::errors::{ParquetError, Result};
+    use crate::data_type::Int64Type;
+    use crate::errors::Result;
     use crate::file::reader::{FileReader, SerializedFileReader};
-    use crate::record::api::{Field, Row, RowAccessor, RowFormatter};
+    use crate::file::writer::SerializedFileWriter;
+    use crate::record::api::{Field, Row, RowAccessor};
     use crate::schema::parser::parse_message_type;
     use crate::util::test_common::file_util::{get_test_file, get_test_path};
+    use bytes::Bytes;
     use std::convert::TryFrom;
 
     // Convenient macros to assemble row, list, map, and group.
@@ -991,17 +973,11 @@ mod tests {
                                     list![
                                         group![
                                             ("E".to_string(), Field::Int(10)),
-                                            (
-                                                "F".to_string(),
-                                                Field::Str("aaa".to_string())
-                                            )
+                                            ("F".to_string(), Field::Str("aaa".to_string()))
                                         ],
                                         group![
                                             ("E".to_string(), Field::Int(-10)),
-                                            (
-                                                "F".to_string(),
-                                                Field::Str("bbb".to_string())
-                                            )
+                                            ("F".to_string(), Field::Str("bbb".to_string()))
                                         ]
                                     ],
                                     list![group![
@@ -1081,10 +1057,7 @@ mod tests {
                                         ],
                                         group![
                                             ("E".to_string(), Field::Int(10)),
-                                            (
-                                                "F".to_string(),
-                                                Field::Str("aaa".to_string())
-                                            )
+                                            ("F".to_string(), Field::Str("aaa".to_string()))
                                         ],
                                         group![
                                             ("E".to_string(), Field::Null),
@@ -1092,10 +1065,7 @@ mod tests {
                                         ],
                                         group![
                                             ("E".to_string(), Field::Int(-10)),
-                                            (
-                                                "F".to_string(),
-                                                Field::Str("bbb".to_string())
-                                            )
+                                            ("F".to_string(), Field::Str("bbb".to_string()))
                                         ],
                                         group![
                                             ("E".to_string(), Field::Null),
@@ -1105,10 +1075,7 @@ mod tests {
                                     list![
                                         group![
                                             ("E".to_string(), Field::Int(11)),
-                                            (
-                                                "F".to_string(),
-                                                Field::Str("c".to_string())
-                                            )
+                                            ("F".to_string(), Field::Str("c".to_string()))
                                         ],
                                         Field::Null
                                     ],
@@ -1132,10 +1099,7 @@ mod tests {
                                 ),
                                 (
                                     Field::Str("g2".to_string()),
-                                    group![(
-                                        "H".to_string(),
-                                        group![("i".to_string(), list![])]
-                                    )]
+                                    group![("H".to_string(), group![("i".to_string(), list![])])]
                                 ),
                                 (Field::Str("g3".to_string()), Field::Null),
                                 (
@@ -1269,8 +1233,7 @@ mod tests {
       }
     ";
         let schema = parse_message_type(schema).unwrap();
-        let rows =
-            test_file_reader_rows("nested_maps.snappy.parquet", Some(schema)).unwrap();
+        let rows = test_file_reader_rows("nested_maps.snappy.parquet", Some(schema)).unwrap();
         let expected_rows = vec![
             row![
                 ("c".to_string(), Field::Double(1.0)),
@@ -1337,8 +1300,7 @@ mod tests {
       }
     ";
         let schema = parse_message_type(schema).unwrap();
-        let rows =
-            test_file_reader_rows("nested_maps.snappy.parquet", Some(schema)).unwrap();
+        let rows = test_file_reader_rows("nested_maps.snappy.parquet", Some(schema)).unwrap();
         let expected_rows = vec![
             row![(
                 "a".to_string(),
@@ -1404,8 +1366,7 @@ mod tests {
       }
     ";
         let schema = parse_message_type(schema).unwrap();
-        let rows =
-            test_file_reader_rows("nested_lists.snappy.parquet", Some(schema)).unwrap();
+        let rows = test_file_reader_rows("nested_lists.snappy.parquet", Some(schema)).unwrap();
         let expected_rows = vec![
             row![(
                 "a".to_string(),
@@ -1452,10 +1413,9 @@ mod tests {
     ";
         let schema = parse_message_type(schema).unwrap();
         let res = test_file_reader_rows("nested_maps.snappy.parquet", Some(schema));
-        assert!(res.is_err());
         assert_eq!(
-            res.unwrap_err(),
-            general_err!("Root schema does not contain projection")
+            res.unwrap_err().to_string(),
+            "Parquet error: Root schema does not contain projection"
         );
     }
 
@@ -1469,10 +1429,9 @@ mod tests {
     ";
         let schema = parse_message_type(schema).unwrap();
         let res = test_row_group_rows("nested_maps.snappy.parquet", Some(schema));
-        assert!(res.is_err());
         assert_eq!(
-            res.unwrap_err(),
-            general_err!("Root schema does not contain projection")
+            res.unwrap_err().to_string(),
+            "Parquet error: Root schema does not contain projection"
         );
     }
 
@@ -1500,33 +1459,26 @@ mod tests {
     #[test]
     fn test_file_reader_iter() {
         let path = get_test_path("alltypes_plain.parquet");
-        let vec = vec![path]
-            .iter()
-            .map(|p| SerializedFileReader::try_from(p.as_path()).unwrap())
-            .flat_map(|r| RowIter::from_file_into(Box::new(r)))
-            .flat_map(|r| r.get_int(0))
-            .collect::<Vec<_>>();
-
-        assert_eq!(vec, vec![4, 5, 6, 7, 2, 3, 0, 1]);
+        let reader = SerializedFileReader::try_from(path.as_path()).unwrap();
+        let iter = RowIter::from_file_into(Box::new(reader));
+
+        let values: Vec<_> = iter.flat_map(|r| r.unwrap().get_int(0)).collect();
+        assert_eq!(values, &[4, 5, 6, 7, 2, 3, 0, 1]);
     }
 
     #[test]
     fn test_file_reader_iter_projection() {
         let path = get_test_path("alltypes_plain.parquet");
-        let values = vec![path]
-            .iter()
-            .map(|p| SerializedFileReader::try_from(p.as_path()).unwrap())
-            .flat_map(|r| {
-                let schema = "message schema { OPTIONAL INT32 id; }";
-                let proj = parse_message_type(schema).ok();
-
-                RowIter::from_file_into(Box::new(r)).project(proj).unwrap()
-            })
-            .map(|r| format!("id:{}", r.fmt(0)))
-            .collect::<Vec<_>>()
-            .join(", ");
-
-        assert_eq!(values, "id:4, id:5, id:6, id:7, id:2, id:3, id:0, id:1");
+        let reader = SerializedFileReader::try_from(path.as_path()).unwrap();
+        let schema = "message schema { OPTIONAL INT32 id; }";
+        let proj = parse_message_type(schema).ok();
+
+        let iter = RowIter::from_file_into(Box::new(reader))
+            .project(proj)
+            .unwrap();
+        let values: Vec<_> = iter.flat_map(|r| r.unwrap().get_int(0)).collect();
+
+        assert_eq!(values, &[4, 5, 6, 7, 2, 3, 0, 1]);
     }
 
     #[test]
@@ -1542,10 +1494,9 @@ mod tests {
         let reader = SerializedFileReader::try_from(path.as_path()).unwrap();
         let res = RowIter::from_file_into(Box::new(reader)).project(proj);
 
-        assert!(res.is_err());
         assert_eq!(
-            res.err().unwrap(),
-            general_err!("Root schema does not contain projection")
+            res.err().unwrap().to_string(),
+            "Parquet error: Root schema does not contain projection"
         );
     }
 
@@ -1624,11 +1575,111 @@ mod tests {
         assert_eq!(rows, expected_rows);
     }
 
+    #[test]
+    fn test_tree_reader_handle_nested_repeated_fields_with_no_annotation() {
+        // Create schema
+        let schema = Arc::new(
+            parse_message_type(
+                "
+            message schema {
+                REPEATED group level1 {
+                    REPEATED group level2 {
+                        REQUIRED group level3 {
+                            REQUIRED INT64 value3;
+                        }
+                    }
+                    REQUIRED INT64 value1;
+                }
+            }",
+            )
+            .unwrap(),
+        );
+
+        // Write Parquet file to buffer
+        let mut buffer: Vec<u8> = Vec::new();
+        let mut file_writer =
+            SerializedFileWriter::new(&mut buffer, schema, Default::default()).unwrap();
+        let mut row_group_writer = file_writer.next_row_group().unwrap();
+
+        // Write column level1.level2.level3.value3
+        let mut column_writer = row_group_writer.next_column().unwrap().unwrap();
+        column_writer
+            .typed::<Int64Type>()
+            .write_batch(&[30, 31, 32], Some(&[2, 2, 2]), Some(&[0, 0, 0]))
+            .unwrap();
+        column_writer.close().unwrap();
+
+        // Write column level1.value1
+        let mut column_writer = row_group_writer.next_column().unwrap().unwrap();
+        column_writer
+            .typed::<Int64Type>()
+            .write_batch(&[10, 11, 12], Some(&[1, 1, 1]), Some(&[0, 0, 0]))
+            .unwrap();
+        column_writer.close().unwrap();
+
+        // Finalize Parquet file
+        row_group_writer.close().unwrap();
+        file_writer.close().unwrap();
+        assert_eq!(&buffer[0..4], b"PAR1");
+
+        // Read Parquet file from buffer
+        let file_reader = SerializedFileReader::new(Bytes::from(buffer)).unwrap();
+        let rows: Vec<_> = file_reader
+            .get_row_iter(None)
+            .unwrap()
+            .map(|row| row.unwrap())
+            .collect();
+
+        let expected_rows = vec![
+            row![(
+                "level1".to_string(),
+                list![group![
+                    (
+                        "level2".to_string(),
+                        list![group![(
+                            "level3".to_string(),
+                            group![("value3".to_string(), Field::Long(30))]
+                        )]]
+                    ),
+                    ("value1".to_string(), Field::Long(10))
+                ]]
+            )],
+            row![(
+                "level1".to_string(),
+                list![group![
+                    (
+                        "level2".to_string(),
+                        list![group![(
+                            "level3".to_string(),
+                            group![("value3".to_string(), Field::Long(31))]
+                        )]]
+                    ),
+                    ("value1".to_string(), Field::Long(11))
+                ]]
+            )],
+            row![(
+                "level1".to_string(),
+                list![group![
+                    (
+                        "level2".to_string(),
+                        list![group![(
+                            "level3".to_string(),
+                            group![("value3".to_string(), Field::Long(32))]
+                        )]]
+                    ),
+                    ("value1".to_string(), Field::Long(12))
+                ]]
+            )],
+        ];
+
+        assert_eq!(rows, expected_rows);
+    }
+
     fn test_file_reader_rows(file_name: &str, schema: Option<Type>) -> Result<Vec<Row>> {
         let file = get_test_file(file_name);
         let file_reader: Box<dyn FileReader> = Box::new(SerializedFileReader::new(file)?);
         let iter = file_reader.get_row_iter(schema)?;
-        Ok(iter.collect())
+        Ok(iter.map(|row| row.unwrap()).collect())
     }
 
     fn test_row_group_rows(file_name: &str, schema: Option<Type>) -> Result<Vec<Row>> {
@@ -1638,6 +1689,6 @@ mod tests {
         // group
         let row_group_reader = file_reader.get_row_group(0).unwrap();
         let iter = row_group_reader.get_row_iter(schema)?;
-        Ok(iter.collect())
+        Ok(iter.map(|row| row.unwrap()).collect())
     }
 }
diff --git a/parquet/src/record/record_reader.rs b/parquet/src/record/record_reader.rs
new file mode 100644
index 000000000000..bcfeb95dcdf4
--- /dev/null
+++ b/parquet/src/record/record_reader.rs
@@ -0,0 +1,30 @@
+// 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.
+
+use super::super::errors::ParquetError;
+use super::super::file::reader::RowGroupReader;
+
+/// read up to `max_records` records from `row_group_reader` into `self`
+/// The type parameter `T` is used to work around the rust orphan rule
+/// when implementing on types such as `Vec<T>`.
+pub trait RecordReader<T> {
+    fn read_from_row_group(
+        &mut self,
+        row_group_reader: &mut dyn RowGroupReader,
+        num_records: usize,
+    ) -> Result<(), ParquetError>;
+}
diff --git a/parquet/src/record/record_writer.rs b/parquet/src/record/record_writer.rs
index fe803a7ff4ef..0b2b95ef7dea 100644
--- a/parquet/src/record/record_writer.rs
+++ b/parquet/src/record/record_writer.rs
@@ -20,8 +20,12 @@ use crate::schema::types::TypePtr;
 use super::super::errors::ParquetError;
 use super::super::file::writer::SerializedRowGroupWriter;
 
+/// `write_to_row_group` writes from `self` into `row_group_writer`
+/// `schema` builds the schema used by `row_group_writer`
+/// The type parameter `T` is used to work around the rust orphan rule
+/// when implementing on types such as `&[T]`.
 pub trait RecordWriter<T> {
-    fn write_to_row_group<W: std::io::Write>(
+    fn write_to_row_group<W: std::io::Write + Send>(
         &self,
         row_group_writer: &mut SerializedRowGroupWriter<W>,
     ) -> Result<(), ParquetError>;
diff --git a/parquet/src/record/triplet.rs b/parquet/src/record/triplet.rs
index 5a7e2a0ca74e..902641c08bcf 100644
--- a/parquet/src/record/triplet.rs
+++ b/parquet/src/record/triplet.rs
@@ -58,32 +58,30 @@ impl TripletIter {
     /// Creates new triplet for column reader
     pub fn new(descr: ColumnDescPtr, reader: ColumnReader, batch_size: usize) -> Self {
         match descr.physical_type() {
-            PhysicalType::BOOLEAN => TripletIter::BoolTripletIter(TypedTripletIter::new(
-                descr, batch_size, reader,
-            )),
-            PhysicalType::INT32 => TripletIter::Int32TripletIter(TypedTripletIter::new(
-                descr, batch_size, reader,
-            )),
-            PhysicalType::INT64 => TripletIter::Int64TripletIter(TypedTripletIter::new(
-                descr, batch_size, reader,
-            )),
-            PhysicalType::INT96 => TripletIter::Int96TripletIter(TypedTripletIter::new(
-                descr, batch_size, reader,
-            )),
-            PhysicalType::FLOAT => TripletIter::FloatTripletIter(TypedTripletIter::new(
-                descr, batch_size, reader,
-            )),
-            PhysicalType::DOUBLE => TripletIter::DoubleTripletIter(
-                TypedTripletIter::new(descr, batch_size, reader),
-            ),
-            PhysicalType::BYTE_ARRAY => TripletIter::ByteArrayTripletIter(
+            PhysicalType::BOOLEAN => {
+                TripletIter::BoolTripletIter(TypedTripletIter::new(descr, batch_size, reader))
+            }
+            PhysicalType::INT32 => {
+                TripletIter::Int32TripletIter(TypedTripletIter::new(descr, batch_size, reader))
+            }
+            PhysicalType::INT64 => {
+                TripletIter::Int64TripletIter(TypedTripletIter::new(descr, batch_size, reader))
+            }
+            PhysicalType::INT96 => {
+                TripletIter::Int96TripletIter(TypedTripletIter::new(descr, batch_size, reader))
+            }
+            PhysicalType::FLOAT => {
+                TripletIter::FloatTripletIter(TypedTripletIter::new(descr, batch_size, reader))
+            }
+            PhysicalType::DOUBLE => {
+                TripletIter::DoubleTripletIter(TypedTripletIter::new(descr, batch_size, reader))
+            }
+            PhysicalType::BYTE_ARRAY => {
+                TripletIter::ByteArrayTripletIter(TypedTripletIter::new(descr, batch_size, reader))
+            }
+            PhysicalType::FIXED_LEN_BYTE_ARRAY => TripletIter::FixedLenByteArrayTripletIter(
                 TypedTripletIter::new(descr, batch_size, reader),
             ),
-            PhysicalType::FIXED_LEN_BYTE_ARRAY => {
-                TripletIter::FixedLenByteArrayTripletIter(TypedTripletIter::new(
-                    descr, batch_size, reader,
-                ))
-            }
         }
     }
 
@@ -136,11 +134,11 @@ impl TripletIter {
     }
 
     /// Updates non-null value for current row.
-    pub fn current_value(&self) -> Field {
+    pub fn current_value(&self) -> Result<Field> {
         if self.is_null() {
-            return Field::Null;
+            return Ok(Field::Null);
         }
-        match *self {
+        let field = match *self {
             TripletIter::BoolTripletIter(ref typed) => {
                 Field::convert_bool(typed.column_descr(), *typed.current_value())
             }
@@ -151,7 +149,7 @@ impl TripletIter {
                 Field::convert_int64(typed.column_descr(), *typed.current_value())
             }
             TripletIter::Int96TripletIter(ref typed) => {
-                Field::convert_int96(typed.column_descr(), typed.current_value().clone())
+                Field::convert_int96(typed.column_descr(), *typed.current_value())
             }
             TripletIter::FloatTripletIter(ref typed) => {
                 Field::convert_float(typed.column_descr(), *typed.current_value())
@@ -159,17 +157,15 @@ impl TripletIter {
             TripletIter::DoubleTripletIter(ref typed) => {
                 Field::convert_double(typed.column_descr(), *typed.current_value())
             }
-            TripletIter::ByteArrayTripletIter(ref typed) => Field::convert_byte_array(
-                typed.column_descr(),
-                typed.current_value().clone(),
-            ),
-            TripletIter::FixedLenByteArrayTripletIter(ref typed) => {
-                Field::convert_byte_array(
-                    typed.column_descr(),
-                    typed.current_value().clone().into(),
-                )
+            TripletIter::ByteArrayTripletIter(ref typed) => {
+                Field::convert_byte_array(typed.column_descr(), typed.current_value().clone())?
             }
-        }
+            TripletIter::FixedLenByteArrayTripletIter(ref typed) => Field::convert_byte_array(
+                typed.column_descr(),
+                typed.current_value().clone().into(),
+            )?,
+        };
+        Ok(field)
     }
 }
 
@@ -200,8 +196,7 @@ impl<T: DataType> TypedTripletIter<T> {
     fn new(descr: ColumnDescPtr, batch_size: usize, column_reader: ColumnReader) -> Self {
         assert!(
             batch_size > 0,
-            "Expected positive batch size, found: {}",
-            batch_size
+            "Expected positive batch size, found: {batch_size}"
         );
 
         let max_def_level = descr.max_def_level();
@@ -296,25 +291,30 @@ impl<T: DataType> TypedTripletIter<T> {
     fn read_next(&mut self) -> Result<bool> {
         self.curr_triplet_index += 1;
 
-        if self.curr_triplet_index >= self.triplets_left {
-            let (values_read, levels_read) = {
-                // Get slice of definition levels, if available
-                let def_levels = self.def_levels.as_mut().map(|vec| &mut vec[..]);
-
-                // Get slice of repetition levels, if available
-                let rep_levels = self.rep_levels.as_mut().map(|vec| &mut vec[..]);
+        // A loop is required to handle the case of a batch size of 1, as in such a case
+        // on reaching the end of a record, read_records will return `Ok((1, 0, 0))`
+        // and therefore not advance `self.triplets_left`
+        while self.curr_triplet_index >= self.triplets_left {
+            let (records_read, values_read, levels_read) = {
+                self.values.clear();
+                if let Some(x) = &mut self.def_levels {
+                    x.clear()
+                }
+                if let Some(x) = &mut self.rep_levels {
+                    x.clear()
+                }
 
                 // Buffer triplets
-                self.reader.read_batch(
+                self.reader.read_records(
                     self.batch_size,
-                    def_levels,
-                    rep_levels,
+                    self.def_levels.as_mut(),
+                    self.rep_levels.as_mut(),
                     &mut self.values,
                 )?
             };
 
             // No more values or levels to read
-            if values_read == 0 && levels_read == 0 {
+            if records_read == 0 && values_read == 0 && levels_read == 0 {
                 self.has_next = false;
                 return Ok(false);
             }
@@ -335,6 +335,7 @@ impl<T: DataType> TypedTripletIter<T> {
                 // Note: if values_read == 0, then spacing will not be triggered
                 let mut idx = values_read;
                 let def_levels = self.def_levels.as_ref().unwrap();
+                self.values.resize(levels_read, T::T::default());
                 for i in 0..levels_read {
                     if def_levels[levels_read - i - 1] == self.max_def_level {
                         idx -= 1; // This is done to avoid usize becoming a negative value
@@ -368,8 +369,7 @@ mod tests {
     #[test]
     #[should_panic(expected = "Expected positive batch size, found: 0")]
     fn test_triplet_zero_batch_size() {
-        let column_path =
-            ColumnPath::from(vec!["b_struct".to_string(), "b_c_int".to_string()]);
+        let column_path = ColumnPath::from(vec!["b_struct".to_string(), "b_c_int".to_string()]);
         test_column_in_file("nulls.snappy.parquet", 0, &column_path, &[], &[], &[]);
     }
 
@@ -497,7 +497,7 @@ mod tests {
         }
     }
 
-    // Check values of a selectd column in a file
+    // Check values of a selected column in a file
     fn test_column_in_file(
         file_name: &str,
         batch_size: usize,
@@ -551,7 +551,7 @@ mod tests {
         while let Ok(true) = iter.read_next() {
             assert!(iter.has_next());
             if !iter.is_null() {
-                values.push(iter.current_value());
+                values.push(iter.current_value().unwrap());
             }
             def_levels.push(iter.current_def_level());
             rep_levels.push(iter.current_rep_level());
diff --git a/parquet/src/schema/mod.rs b/parquet/src/schema/mod.rs
index 1ebee2e06e83..ead7f1d2c0f8 100644
--- a/parquet/src/schema/mod.rs
+++ b/parquet/src/schema/mod.rs
@@ -45,7 +45,7 @@
 //!     .unwrap();
 //!
 //! let schema = Type::group_type_builder("schema")
-//!     .with_fields(&mut vec![Arc::new(field_a), Arc::new(field_b)])
+//!     .with_fields(vec![Arc::new(field_a), Arc::new(field_b)])
 //!     .build()
 //!     .unwrap();
 //!
diff --git a/parquet/src/schema/parser.rs b/parquet/src/schema/parser.rs
index 140e3e08500b..dcef11aa66d4 100644
--- a/parquet/src/schema/parser.rs
+++ b/parquet/src/schema/parser.rs
@@ -17,7 +17,7 @@
 
 //! Parquet schema parser.
 //! Provides methods to parse and validate string message type into Parquet
-//! [`Type`](crate::schema::types::Type).
+//! [`Type`].
 //!
 //! # Example
 //!
@@ -44,13 +44,11 @@
 
 use std::sync::Arc;
 
-use crate::basic::{
-    ConvertedType, LogicalType, Repetition, TimeUnit, Type as PhysicalType,
-};
+use crate::basic::{ConvertedType, LogicalType, Repetition, TimeUnit, Type as PhysicalType};
 use crate::errors::{ParquetError, Result};
 use crate::schema::types::{Type, TypePtr};
 
-/// Parses message type as string into a Parquet [`Type`](crate::schema::types::Type)
+/// Parses message type as string into a Parquet [`Type`]
 /// which, for example, could be used to extract individual columns. Returns Parquet
 /// general error when parsing or validation fails.
 pub fn parse_message_type(message_type: &str) -> Result<Type> {
@@ -153,11 +151,7 @@ fn assert_token(token: Option<&str>, expected: &str) -> Result<()> {
 
 // Utility function to parse i32 or return general error.
 #[inline]
-fn parse_i32(
-    value: Option<&str>,
-    not_found_msg: &str,
-    parse_fail_msg: &str,
-) -> Result<i32> {
+fn parse_i32(value: Option<&str>, not_found_msg: &str, parse_fail_msg: &str) -> Result<i32> {
     value
         .ok_or_else(|| general_err!(not_found_msg))
         .and_then(|v| v.parse::<i32>().map_err(|_| general_err!(parse_fail_msg)))
@@ -165,11 +159,7 @@ fn parse_i32(
 
 // Utility function to parse boolean or return general error.
 #[inline]
-fn parse_bool(
-    value: Option<&str>,
-    not_found_msg: &str,
-    parse_fail_msg: &str,
-) -> Result<bool> {
+fn parse_bool(value: Option<&str>, not_found_msg: &str, parse_fail_msg: &str) -> Result<bool> {
     value
         .ok_or_else(|| general_err!(not_found_msg))
         .and_then(|v| {
@@ -205,9 +195,8 @@ impl<'a> Parser<'a> {
                     .tokenizer
                     .next()
                     .ok_or_else(|| general_err!("Expected name, found None"))?;
-                let mut fields = self.parse_child_types()?;
                 Type::group_type_builder(name)
-                    .with_fields(&mut fields)
+                    .with_fields(self.parse_child_types()?)
                     .build()
             }
             _ => Err(general_err!("Message type does not start with 'message'")),
@@ -239,9 +228,7 @@ impl<'a> Parser<'a> {
             .and_then(|v| v.to_uppercase().parse::<Repetition>())?;
 
         match self.tokenizer.next() {
-            Some(group) if group.to_uppercase() == "GROUP" => {
-                self.add_group_type(Some(repetition))
-            }
+            Some(group) if group.to_uppercase() == "GROUP" => self.add_group_type(Some(repetition)),
             Some(type_string) => {
                 let physical_type = type_string.to_uppercase().parse::<PhysicalType>()?;
                 self.add_primitive_type(repetition, physical_type)
@@ -268,10 +255,9 @@ impl<'a> Parser<'a> {
                     let upper = v.to_uppercase();
                     let logical = upper.parse::<LogicalType>();
                     match logical {
-                        Ok(logical) => Ok((
-                            Some(logical.clone()),
-                            ConvertedType::from(Some(logical)),
-                        )),
+                        Ok(logical) => {
+                            Ok((Some(logical.clone()), ConvertedType::from(Some(logical))))
+                        }
                         Err(_) => Ok((None, upper.parse::<ConvertedType>()?)),
                     }
                 })?;
@@ -290,17 +276,14 @@ impl<'a> Parser<'a> {
             None
         };
 
-        let mut fields = self.parse_child_types()?;
         let mut builder = Type::group_type_builder(name)
             .with_logical_type(logical_type)
             .with_converted_type(converted_type)
-            .with_fields(&mut fields);
+            .with_fields(self.parse_child_types()?)
+            .with_id(id);
         if let Some(rep) = repetition {
             builder = builder.with_repetition(rep);
         }
-        if let Some(id) = id {
-            builder = builder.with_id(id);
-        }
         builder.build()
     }
 
@@ -328,184 +311,187 @@ impl<'a> Parser<'a> {
             .ok_or_else(|| general_err!("Expected name, found None"))?;
 
         // Parse converted type
-        let (logical_type, converted_type, precision, scale) = if let Some("(") =
-            self.tokenizer.next()
-        {
-            let (mut logical, mut converted) = self
-                .tokenizer
-                .next()
-                .ok_or_else(|| {
-                    general_err!("Expected logical or converted type, found None")
-                })
-                .and_then(|v| {
-                    let upper = v.to_uppercase();
-                    let logical = upper.parse::<LogicalType>();
-                    match logical {
-                        Ok(logical) => Ok((
-                            Some(logical.clone()),
-                            ConvertedType::from(Some(logical)),
-                        )),
-                        Err(_) => Ok((None, upper.parse::<ConvertedType>()?)),
-                    }
-                })?;
-
-            // Parse precision and scale for decimals
-            let mut precision: i32 = -1;
-            let mut scale: i32 = -1;
-
-            // Parse the concrete logical type
-            if let Some(tpe) = &logical {
-                match tpe {
-                    LogicalType::Decimal { .. } => {
-                        if let Some("(") = self.tokenizer.next() {
-                            precision = parse_i32(
-                                self.tokenizer.next(),
-                                "Expected precision, found None",
-                                "Failed to parse precision for DECIMAL type",
-                            )?;
-                            if let Some(",") = self.tokenizer.next() {
-                                scale = parse_i32(
+        let (logical_type, converted_type, precision, scale) =
+            if let Some("(") = self.tokenizer.next() {
+                let (mut logical, mut converted) = self
+                    .tokenizer
+                    .next()
+                    .ok_or_else(|| general_err!("Expected logical or converted type, found None"))
+                    .and_then(|v| {
+                        let upper = v.to_uppercase();
+                        let logical = upper.parse::<LogicalType>();
+                        match logical {
+                            Ok(logical) => {
+                                Ok((Some(logical.clone()), ConvertedType::from(Some(logical))))
+                            }
+                            Err(_) => Ok((None, upper.parse::<ConvertedType>()?)),
+                        }
+                    })?;
+
+                // Parse precision and scale for decimals
+                let mut precision: i32 = -1;
+                let mut scale: i32 = -1;
+
+                // Parse the concrete logical type
+                if let Some(tpe) = &logical {
+                    match tpe {
+                        LogicalType::Decimal { .. } => {
+                            if let Some("(") = self.tokenizer.next() {
+                                precision = parse_i32(
                                     self.tokenizer.next(),
-                                    "Expected scale, found None",
-                                    "Failed to parse scale for DECIMAL type",
+                                    "Expected precision, found None",
+                                    "Failed to parse precision for DECIMAL type",
                                 )?;
-                                assert_token(self.tokenizer.next(), ")")?;
-                            } else {
-                                scale = 0
+                                if let Some(",") = self.tokenizer.next() {
+                                    scale = parse_i32(
+                                        self.tokenizer.next(),
+                                        "Expected scale, found None",
+                                        "Failed to parse scale for DECIMAL type",
+                                    )?;
+                                    assert_token(self.tokenizer.next(), ")")?;
+                                } else {
+                                    scale = 0
+                                }
+                                logical = Some(LogicalType::Decimal { scale, precision });
+                                converted = ConvertedType::from(logical.clone());
                             }
-                            logical = Some(LogicalType::Decimal { scale, precision });
-                            converted = ConvertedType::from(logical.clone());
                         }
-                    }
-                    LogicalType::Time { .. } => {
-                        if let Some("(") = self.tokenizer.next() {
-                            let unit = parse_timeunit(
-                                self.tokenizer.next(),
-                                "Invalid timeunit found",
-                                "Failed to parse timeunit for TIME type",
-                            )?;
-                            if let Some(",") = self.tokenizer.next() {
-                                let is_adjusted_to_u_t_c = parse_bool(
+                        LogicalType::Time { .. } => {
+                            if let Some("(") = self.tokenizer.next() {
+                                let unit = parse_timeunit(
                                     self.tokenizer.next(),
-                                    "Invalid boolean found",
-                                    "Failed to parse timezone info for TIME type",
+                                    "Invalid timeunit found",
+                                    "Failed to parse timeunit for TIME type",
                                 )?;
-                                assert_token(self.tokenizer.next(), ")")?;
-                                logical = Some(LogicalType::Time {
-                                    is_adjusted_to_u_t_c,
-                                    unit,
-                                });
-                                converted = ConvertedType::from(logical.clone());
-                            } else {
-                                // Invalid token for unit
-                                self.tokenizer.backtrack();
+                                if let Some(",") = self.tokenizer.next() {
+                                    let is_adjusted_to_u_t_c = parse_bool(
+                                        self.tokenizer.next(),
+                                        "Invalid boolean found",
+                                        "Failed to parse timezone info for TIME type",
+                                    )?;
+                                    assert_token(self.tokenizer.next(), ")")?;
+                                    logical = Some(LogicalType::Time {
+                                        is_adjusted_to_u_t_c,
+                                        unit,
+                                    });
+                                    converted = ConvertedType::from(logical.clone());
+                                } else {
+                                    // Invalid token for unit
+                                    self.tokenizer.backtrack();
+                                }
                             }
                         }
-                    }
-                    LogicalType::Timestamp { .. } => {
-                        if let Some("(") = self.tokenizer.next() {
-                            let unit = parse_timeunit(
-                                self.tokenizer.next(),
-                                "Invalid timeunit found",
-                                "Failed to parse timeunit for TIMESTAMP type",
-                            )?;
-                            if let Some(",") = self.tokenizer.next() {
-                                let is_adjusted_to_u_t_c = parse_bool(
+                        LogicalType::Timestamp { .. } => {
+                            if let Some("(") = self.tokenizer.next() {
+                                let unit = parse_timeunit(
                                     self.tokenizer.next(),
-                                    "Invalid boolean found",
-                                    "Failed to parse timezone info for TIMESTAMP type",
+                                    "Invalid timeunit found",
+                                    "Failed to parse timeunit for TIMESTAMP type",
                                 )?;
-                                assert_token(self.tokenizer.next(), ")")?;
-                                logical = Some(LogicalType::Timestamp {
-                                    is_adjusted_to_u_t_c,
-                                    unit,
-                                });
-                                converted = ConvertedType::from(logical.clone());
-                            } else {
-                                // Invalid token for unit
-                                self.tokenizer.backtrack();
+                                if let Some(",") = self.tokenizer.next() {
+                                    let is_adjusted_to_u_t_c = parse_bool(
+                                        self.tokenizer.next(),
+                                        "Invalid boolean found",
+                                        "Failed to parse timezone info for TIMESTAMP type",
+                                    )?;
+                                    assert_token(self.tokenizer.next(), ")")?;
+                                    logical = Some(LogicalType::Timestamp {
+                                        is_adjusted_to_u_t_c,
+                                        unit,
+                                    });
+                                    converted = ConvertedType::from(logical.clone());
+                                } else {
+                                    // Invalid token for unit
+                                    self.tokenizer.backtrack();
+                                }
                             }
                         }
-                    }
-                    LogicalType::Integer { .. } => {
-                        if let Some("(") = self.tokenizer.next() {
-                            let bit_width = parse_i32(
-                                self.tokenizer.next(),
-                                "Invalid bit_width found",
-                                "Failed to parse bit_width for INTEGER type",
-                            )? as i8;
-                            match physical_type {
-                                PhysicalType::INT32 => {
-                                    match bit_width {
+                        LogicalType::Integer { .. } => {
+                            if let Some("(") = self.tokenizer.next() {
+                                let bit_width = parse_i32(
+                                    self.tokenizer.next(),
+                                    "Invalid bit_width found",
+                                    "Failed to parse bit_width for INTEGER type",
+                                )? as i8;
+                                match physical_type {
+                                    PhysicalType::INT32 => match bit_width {
                                         8 | 16 | 32 => {}
                                         _ => {
-                                            return Err(general_err!("Incorrect bit width {} for INT32", bit_width))
+                                            return Err(general_err!(
+                                                "Incorrect bit width {} for INT32",
+                                                bit_width
+                                            ))
+                                        }
+                                    },
+                                    PhysicalType::INT64 => {
+                                        if bit_width != 64 {
+                                            return Err(general_err!(
+                                                "Incorrect bit width {} for INT64",
+                                                bit_width
+                                            ));
                                         }
                                     }
-                                }
-                                PhysicalType::INT64 => {
-                                    if bit_width != 64 {
-                                        return Err(general_err!("Incorrect bit width {} for INT64", bit_width))
+                                    _ => {
+                                        return Err(general_err!(
+                                        "Logical type Integer cannot be used with physical type {}",
+                                        physical_type
+                                    ))
                                     }
                                 }
-                                _ => {
-                                    return Err(general_err!("Logical type Integer cannot be used with physical type {}", physical_type))
+                                if let Some(",") = self.tokenizer.next() {
+                                    let is_signed = parse_bool(
+                                        self.tokenizer.next(),
+                                        "Invalid boolean found",
+                                        "Failed to parse is_signed for INTEGER type",
+                                    )?;
+                                    assert_token(self.tokenizer.next(), ")")?;
+                                    logical = Some(LogicalType::Integer {
+                                        bit_width,
+                                        is_signed,
+                                    });
+                                    converted = ConvertedType::from(logical.clone());
+                                } else {
+                                    // Invalid token for unit
+                                    self.tokenizer.backtrack();
                                 }
                             }
-                            if let Some(",") = self.tokenizer.next() {
-                                let is_signed = parse_bool(
-                                    self.tokenizer.next(),
-                                    "Invalid boolean found",
-                                    "Failed to parse is_signed for INTEGER type",
-                                )?;
-                                assert_token(self.tokenizer.next(), ")")?;
-                                logical = Some(LogicalType::Integer {
-                                    bit_width,
-                                    is_signed,
-                                });
-                                converted = ConvertedType::from(logical.clone());
-                            } else {
-                                // Invalid token for unit
-                                self.tokenizer.backtrack();
-                            }
                         }
+                        _ => {}
                     }
-                    _ => {}
-                }
-            } else if converted == ConvertedType::DECIMAL {
-                if let Some("(") = self.tokenizer.next() {
-                    // Parse precision
-                    precision = parse_i32(
-                        self.tokenizer.next(),
-                        "Expected precision, found None",
-                        "Failed to parse precision for DECIMAL type",
-                    )?;
-
-                    // Parse scale
-                    scale = if let Some(",") = self.tokenizer.next() {
-                        parse_i32(
+                } else if converted == ConvertedType::DECIMAL {
+                    if let Some("(") = self.tokenizer.next() {
+                        // Parse precision
+                        precision = parse_i32(
                             self.tokenizer.next(),
-                            "Expected scale, found None",
-                            "Failed to parse scale for DECIMAL type",
-                        )?
+                            "Expected precision, found None",
+                            "Failed to parse precision for DECIMAL type",
+                        )?;
+
+                        // Parse scale
+                        scale = if let Some(",") = self.tokenizer.next() {
+                            parse_i32(
+                                self.tokenizer.next(),
+                                "Expected scale, found None",
+                                "Failed to parse scale for DECIMAL type",
+                            )?
+                        } else {
+                            // Scale is not provided, set it to 0.
+                            self.tokenizer.backtrack();
+                            0
+                        };
+
+                        assert_token(self.tokenizer.next(), ")")?;
                     } else {
-                        // Scale is not provided, set it to 0.
                         self.tokenizer.backtrack();
-                        0
-                    };
-
-                    assert_token(self.tokenizer.next(), ")")?;
-                } else {
-                    self.tokenizer.backtrack();
+                    }
                 }
-            }
 
-            assert_token(self.tokenizer.next(), ")")?;
-            (logical, converted, precision, scale)
-        } else {
-            self.tokenizer.backtrack();
-            (None, ConvertedType::NONE, -1, -1)
-        };
+                assert_token(self.tokenizer.next(), ")")?;
+                (logical, converted, precision, scale)
+            } else {
+                self.tokenizer.backtrack();
+                (None, ConvertedType::NONE, -1, -1)
+            };
 
         // Parse optional id
         let id = if let Some("=") = self.tokenizer.next() {
@@ -516,17 +502,15 @@ impl<'a> Parser<'a> {
         };
         assert_token(self.tokenizer.next(), ";")?;
 
-        let mut builder = Type::primitive_type_builder(name, physical_type)
+        Type::primitive_type_builder(name, physical_type)
             .with_repetition(repetition)
             .with_logical_type(logical_type)
             .with_converted_type(converted_type)
             .with_length(length)
             .with_precision(precision)
-            .with_scale(scale);
-        if let Some(id) = id {
-            builder = builder.with_id(id);
-        }
-        builder.build()
+            .with_scale(scale)
+            .with_id(id)
+            .build()
     }
 }
 
@@ -611,12 +595,11 @@ mod tests {
         assert_eq!(
             res,
             vec![
-                "message", "schema", "{", "required", "int32", "a", ";", "optional",
-                "binary", "c", "(", "UTF8", ")", ";", "required", "group", "d", "{",
-                "required", "int32", "a", ";", "optional", "binary", "c", "(", "UTF8",
-                ")", ";", "}", "required", "group", "e", "(", "LIST", ")", "{",
-                "repeated", "group", "list", "{", "required", "int32", "element", ";",
-                "}", "}", "}"
+                "message", "schema", "{", "required", "int32", "a", ";", "optional", "binary", "c",
+                "(", "UTF8", ")", ";", "required", "group", "d", "{", "required", "int32", "a",
+                ";", "optional", "binary", "c", "(", "UTF8", ")", ";", "}", "required", "group",
+                "e", "(", "LIST", ")", "{", "repeated", "group", "list", "{", "required", "int32",
+                "element", ";", "}", "}", "}"
             ]
         );
     }
@@ -628,30 +611,26 @@ mod tests {
         assert!(assert_token(None, "b").is_err());
     }
 
-    #[test]
-    fn test_parse_message_type_invalid() {
-        let mut iter = Tokenizer::from_str("test");
-        let result = Parser {
+    fn parse(schema: &str) -> Result<Type, ParquetError> {
+        let mut iter = Tokenizer::from_str(schema);
+        Parser {
             tokenizer: &mut iter,
         }
-        .parse_message_type();
-        assert!(result.is_err());
+        .parse_message_type()
+    }
+
+    #[test]
+    fn test_parse_message_type_invalid() {
         assert_eq!(
-            result.unwrap_err().to_string(),
+            parse("test").unwrap_err().to_string(),
             "Parquet error: Message type does not start with 'message'"
         );
     }
 
     #[test]
     fn test_parse_message_type_no_name() {
-        let mut iter = Tokenizer::from_str("message");
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
-        assert!(result.is_err());
         assert_eq!(
-            result.unwrap_err().to_string(),
+            parse("message").unwrap_err().to_string(),
             "Parquet error: Expected name, found None"
         );
     }
@@ -659,46 +638,34 @@ mod tests {
     #[test]
     fn test_parse_message_type_fixed_byte_array() {
         let schema = "
-    message schema {
-      REQUIRED FIXED_LEN_BYTE_ARRAY col;
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
-        assert!(result.is_err());
+            message schema {
+              REQUIRED FIXED_LEN_BYTE_ARRAY col;
+            }
+        ";
+        assert_eq!(
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Expected '(', found token 'col'"
+        );
 
         let schema = "
-    message schema {
-      REQUIRED FIXED_LEN_BYTE_ARRAY(16) col;
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
-        assert!(result.is_ok());
+            message schema {
+              REQUIRED FIXED_LEN_BYTE_ARRAY(16) col;
+            }
+        ";
+        parse(schema).unwrap();
     }
 
     #[test]
     fn test_parse_message_type_integer() {
         // Invalid integer syntax
         let schema = "
-    message root {
-      optional int64 f1 (INTEGER());
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
+            message root {
+              optional int64 f1 (INTEGER());
+            }
+        ";
         assert_eq!(
-            result,
-            Err(general_err!("Failed to parse bit_width for INTEGER type"))
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Failed to parse bit_width for INTEGER type"
         );
 
         // Invalid integer syntax, needs both bit-width and UTC sign
@@ -707,123 +674,87 @@ mod tests {
       optional int64 f1 (INTEGER(32,));
     }
     ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
         assert_eq!(
-            result,
-            Err(general_err!("Incorrect bit width 32 for INT64"))
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Incorrect bit width 32 for INT64"
         );
 
         // Invalid integer because of non-numeric bit width
         let schema = "
-    message root {
-      optional int32 f1 (INTEGER(eight,true));
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
+            message root {
+              optional int32 f1 (INTEGER(eight,true));
+            }
+        ";
         assert_eq!(
-            result,
-            Err(general_err!("Failed to parse bit_width for INTEGER type"))
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Failed to parse bit_width for INTEGER type"
         );
 
         // Valid types
         let schema = "
-    message root {
-      optional int32 f1 (INTEGER(8,false));
-      optional int32 f2 (INTEGER(8,true));
-      optional int32 f3 (INTEGER(16,false));
-      optional int32 f4 (INTEGER(16,true));
-      optional int32 f5 (INTEGER(32,false));
-      optional int32 f6 (INTEGER(32,true));
-      optional int64 f7 (INTEGER(64,false));
-      optional int64 f7 (INTEGER(64,true));
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
-        assert!(result.is_ok());
+            message root {
+              optional int32 f1 (INTEGER(8,false));
+              optional int32 f2 (INTEGER(8,true));
+              optional int32 f3 (INTEGER(16,false));
+              optional int32 f4 (INTEGER(16,true));
+              optional int32 f5 (INTEGER(32,false));
+              optional int32 f6 (INTEGER(32,true));
+              optional int64 f7 (INTEGER(64,false));
+              optional int64 f7 (INTEGER(64,true));
+            }
+        ";
+        parse(schema).unwrap();
     }
 
     #[test]
     fn test_parse_message_type_temporal() {
         // Invalid timestamp syntax
         let schema = "
-    message root {
-      optional int64 f1 (TIMESTAMP();
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
+            message root {
+              optional int64 f1 (TIMESTAMP();
+            }
+        ";
         assert_eq!(
-            result,
-            Err(general_err!("Failed to parse timeunit for TIMESTAMP type"))
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Failed to parse timeunit for TIMESTAMP type"
         );
 
         // Invalid timestamp syntax, needs both unit and UTC adjustment
         let schema = "
-    message root {
-      optional int64 f1 (TIMESTAMP(MILLIS,));
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
+            message root {
+              optional int64 f1 (TIMESTAMP(MILLIS,));
+            }
+        ";
         assert_eq!(
-            result,
-            Err(general_err!(
-                "Failed to parse timezone info for TIMESTAMP type"
-            ))
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Failed to parse timezone info for TIMESTAMP type"
         );
 
         // Invalid timestamp because of unknown unit
         let schema = "
-    message root {
-      optional int64 f1 (TIMESTAMP(YOCTOS,));
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
+            message root {
+              optional int64 f1 (TIMESTAMP(YOCTOS,));
+            }
+        ";
+
         assert_eq!(
-            result,
-            Err(general_err!("Failed to parse timeunit for TIMESTAMP type"))
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Failed to parse timeunit for TIMESTAMP type"
         );
 
         // Valid types
         let schema = "
-    message root {
-      optional int32 f1 (DATE);
-      optional int32 f2 (TIME(MILLIS,true));
-      optional int64 f3 (TIME(MICROS,false));
-      optional int64 f4 (TIME(NANOS,true));
-      optional int64 f5 (TIMESTAMP(MILLIS,true));
-      optional int64 f6 (TIMESTAMP(MICROS,true));
-      optional int64 f7 (TIMESTAMP(NANOS,false));
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
-        assert!(result.is_ok());
+            message root {
+              optional int32 f1 (DATE);
+              optional int32 f2 (TIME(MILLIS,true));
+              optional int64 f3 (TIME(MICROS,false));
+              optional int64 f4 (TIME(NANOS,true));
+              optional int64 f5 (TIMESTAMP(MILLIS,true));
+              optional int64 f6 (TIMESTAMP(MICROS,true));
+              optional int64 f7 (TIMESTAMP(NANOS,false));
+            }
+        ";
+        parse(schema).unwrap();
     }
 
     #[test]
@@ -833,120 +764,104 @@ mod tests {
 
         // Invalid decimal syntax
         let schema = "
-    message root {
-      optional int32 f1 (DECIMAL();
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
-        assert!(result.is_err());
+            message root {
+              optional int32 f1 (DECIMAL();
+            }
+        ";
+        assert_eq!(
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Failed to parse precision for DECIMAL type"
+        );
 
         // Invalid decimal, need precision and scale
         let schema = "
-    message root {
-      optional int32 f1 (DECIMAL());
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
-        assert!(result.is_err());
+            message root {
+              optional int32 f1 (DECIMAL());
+            }
+        ";
+        assert_eq!(
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Failed to parse precision for DECIMAL type"
+        );
 
         // Invalid decimal because of `,` - has precision, needs scale
         let schema = "
-    message root {
-      optional int32 f1 (DECIMAL(8,));
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
-        assert!(result.is_err());
+            message root {
+              optional int32 f1 (DECIMAL(8,));
+            }
+        ";
+        assert_eq!(
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Failed to parse scale for DECIMAL type"
+        );
 
         // Invalid decimal because, we always require either precision or scale to be
         // specified as part of converted type
         let schema = "
-    message root {
-      optional int32 f3 (DECIMAL);
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
-        assert!(result.is_err());
+            message root {
+              optional int32 f3 (DECIMAL);
+            }
+        ";
+        assert_eq!(
+            parse(schema).unwrap_err().to_string(),
+            "Parquet error: Expected ')', found token ';'"
+        );
 
         // Valid decimal (precision, scale)
         let schema = "
-    message root {
-      optional int32 f1 (DECIMAL(8, 3));
-      optional int32 f2 (DECIMAL(8));
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let result = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type();
-        assert!(result.is_ok());
+            message root {
+              optional int32 f1 (DECIMAL(8, 3));
+              optional int32 f2 (DECIMAL(8));
+            }
+        ";
+        parse(schema).unwrap();
     }
 
     #[test]
     fn test_parse_message_type_compare_1() {
         let schema = "
-    message root {
-      optional fixed_len_byte_array(5) f1 (DECIMAL(9, 3));
-      optional fixed_len_byte_array (16) f2 (DECIMAL (38, 18));
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let message = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type()
-        .unwrap();
+            message root {
+              optional fixed_len_byte_array(5) f1 (DECIMAL(9, 3));
+              optional fixed_len_byte_array (16) f2 (DECIMAL (38, 18));
+              optional fixed_len_byte_array (2) f3 (FLOAT16);
+            }
+        ";
+        let message = parse(schema).unwrap();
 
         let expected = Type::group_type_builder("root")
-            .with_fields(&mut vec![
+            .with_fields(vec![
                 Arc::new(
-                    Type::primitive_type_builder(
-                        "f1",
-                        PhysicalType::FIXED_LEN_BYTE_ARRAY,
-                    )
-                    .with_logical_type(Some(LogicalType::Decimal {
-                        precision: 9,
-                        scale: 3,
-                    }))
-                    .with_converted_type(ConvertedType::DECIMAL)
-                    .with_length(5)
-                    .with_precision(9)
-                    .with_scale(3)
-                    .build()
-                    .unwrap(),
+                    Type::primitive_type_builder("f1", PhysicalType::FIXED_LEN_BYTE_ARRAY)
+                        .with_logical_type(Some(LogicalType::Decimal {
+                            precision: 9,
+                            scale: 3,
+                        }))
+                        .with_converted_type(ConvertedType::DECIMAL)
+                        .with_length(5)
+                        .with_precision(9)
+                        .with_scale(3)
+                        .build()
+                        .unwrap(),
                 ),
                 Arc::new(
-                    Type::primitive_type_builder(
-                        "f2",
-                        PhysicalType::FIXED_LEN_BYTE_ARRAY,
-                    )
-                    .with_logical_type(Some(LogicalType::Decimal {
-                        precision: 38,
-                        scale: 18,
-                    }))
-                    .with_converted_type(ConvertedType::DECIMAL)
-                    .with_length(16)
-                    .with_precision(38)
-                    .with_scale(18)
-                    .build()
-                    .unwrap(),
+                    Type::primitive_type_builder("f2", PhysicalType::FIXED_LEN_BYTE_ARRAY)
+                        .with_logical_type(Some(LogicalType::Decimal {
+                            precision: 38,
+                            scale: 18,
+                        }))
+                        .with_converted_type(ConvertedType::DECIMAL)
+                        .with_length(16)
+                        .with_precision(38)
+                        .with_scale(18)
+                        .build()
+                        .unwrap(),
+                ),
+                Arc::new(
+                    Type::primitive_type_builder("f3", PhysicalType::FIXED_LEN_BYTE_ARRAY)
+                        .with_logical_type(Some(LogicalType::Float16))
+                        .with_length(2)
+                        .build()
+                        .unwrap(),
                 ),
             ])
             .build()
@@ -958,47 +873,39 @@ mod tests {
     #[test]
     fn test_parse_message_type_compare_2() {
         let schema = "
-    message root {
-      required group a0 {
-        optional group a1 (LIST) {
-          repeated binary a2 (UTF8);
-        }
+            message root {
+              required group a0 {
+                optional group a1 (LIST) {
+                  repeated binary a2 (UTF8);
+                }
 
-        optional group b1 (LIST) {
-          repeated group b2 {
-            optional int32 b3;
-            optional double b4;
-          }
-        }
-      }
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let message = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type()
-        .unwrap();
+                optional group b1 (LIST) {
+                  repeated group b2 {
+                    optional int32 b3;
+                    optional double b4;
+                  }
+                }
+              }
+            }
+        ";
+        let message = parse(schema).unwrap();
 
         let expected = Type::group_type_builder("root")
-            .with_fields(&mut vec![Arc::new(
+            .with_fields(vec![Arc::new(
                 Type::group_type_builder("a0")
                     .with_repetition(Repetition::REQUIRED)
-                    .with_fields(&mut vec![
+                    .with_fields(vec![
                         Arc::new(
                             Type::group_type_builder("a1")
                                 .with_repetition(Repetition::OPTIONAL)
                                 .with_logical_type(Some(LogicalType::List))
                                 .with_converted_type(ConvertedType::LIST)
-                                .with_fields(&mut vec![Arc::new(
-                                    Type::primitive_type_builder(
-                                        "a2",
-                                        PhysicalType::BYTE_ARRAY,
-                                    )
-                                    .with_repetition(Repetition::REPEATED)
-                                    .with_converted_type(ConvertedType::UTF8)
-                                    .build()
-                                    .unwrap(),
+                                .with_fields(vec![Arc::new(
+                                    Type::primitive_type_builder("a2", PhysicalType::BYTE_ARRAY)
+                                        .with_repetition(Repetition::REPEATED)
+                                        .with_converted_type(ConvertedType::UTF8)
+                                        .build()
+                                        .unwrap(),
                                 )])
                                 .build()
                                 .unwrap(),
@@ -1008,10 +915,10 @@ mod tests {
                                 .with_repetition(Repetition::OPTIONAL)
                                 .with_logical_type(Some(LogicalType::List))
                                 .with_converted_type(ConvertedType::LIST)
-                                .with_fields(&mut vec![Arc::new(
+                                .with_fields(vec![Arc::new(
                                     Type::group_type_builder("b2")
                                         .with_repetition(Repetition::REPEATED)
-                                        .with_fields(&mut vec![
+                                        .with_fields(vec![
                                             Arc::new(
                                                 Type::primitive_type_builder(
                                                     "b3",
@@ -1048,23 +955,18 @@ mod tests {
     #[test]
     fn test_parse_message_type_compare_3() {
         let schema = "
-    message root {
-      required int32 _1 (INT_8);
-      required int32 _2 (INT_16);
-      required float _3;
-      required double _4;
-      optional int32 _5 (DATE);
-      optional binary _6 (UTF8);
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let message = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type()
-        .unwrap();
+            message root {
+              required int32 _1 (INT_8);
+              required int32 _2 (INT_16);
+              required float _3;
+              required double _4;
+              optional int32 _5 (DATE);
+              optional binary _6 (UTF8);
+            }
+        ";
+        let message = parse(schema).unwrap();
 
-        let mut fields = vec![
+        let fields = vec![
             Arc::new(
                 Type::primitive_type_builder("_1", PhysicalType::INT32)
                     .with_repetition(Repetition::REQUIRED)
@@ -1107,7 +1009,7 @@ mod tests {
         ];
 
         let expected = Type::group_type_builder("root")
-            .with_fields(&mut fields)
+            .with_fields(fields)
             .build()
             .unwrap();
         assert_eq!(message, expected);
@@ -1116,27 +1018,22 @@ mod tests {
     #[test]
     fn test_parse_message_type_compare_4() {
         let schema = "
-    message root {
-      required int32 _1 (INTEGER(8,true));
-      required int32 _2 (INTEGER(16,false));
-      required float _3;
-      required double _4;
-      optional int32 _5 (DATE);
-      optional int32 _6 (TIME(MILLIS,false));
-      optional int64 _7 (TIME(MICROS,true));
-      optional int64 _8 (TIMESTAMP(MILLIS,true));
-      optional int64 _9 (TIMESTAMP(NANOS,false));
-      optional binary _10 (STRING);
-    }
-    ";
-        let mut iter = Tokenizer::from_str(schema);
-        let message = Parser {
-            tokenizer: &mut iter,
-        }
-        .parse_message_type()
-        .unwrap();
+            message root {
+              required int32 _1 (INTEGER(8,true));
+              required int32 _2 (INTEGER(16,false));
+              required float _3;
+              required double _4;
+              optional int32 _5 (DATE);
+              optional int32 _6 (TIME(MILLIS,false));
+              optional int64 _7 (TIME(MICROS,true));
+              optional int64 _8 (TIMESTAMP(MILLIS,true));
+              optional int64 _9 (TIMESTAMP(NANOS,false));
+              optional binary _10 (STRING);
+            }
+        ";
+        let message = parse(schema).unwrap();
 
-        let mut fields = vec![
+        let fields = vec![
             Arc::new(
                 Type::primitive_type_builder("_1", PhysicalType::INT32)
                     .with_repetition(Repetition::REQUIRED)
@@ -1220,7 +1117,7 @@ mod tests {
         ];
 
         let expected = Type::group_type_builder("root")
-            .with_fields(&mut fields)
+            .with_fields(fields)
             .build()
             .unwrap();
         assert_eq!(message, expected);
diff --git a/parquet/src/schema/printer.rs b/parquet/src/schema/printer.rs
index 5cfd30dd977c..2dec8a5be9f7 100644
--- a/parquet/src/schema/printer.rs
+++ b/parquet/src/schema/printer.rs
@@ -46,13 +46,10 @@
 use std::{fmt, io};
 
 use crate::basic::{ConvertedType, LogicalType, TimeUnit, Type as PhysicalType};
-use crate::file::metadata::{
-    ColumnChunkMetaData, FileMetaData, ParquetMetaData, RowGroupMetaData,
-};
+use crate::file::metadata::{ColumnChunkMetaData, FileMetaData, ParquetMetaData, RowGroupMetaData};
 use crate::schema::types::Type;
 
-/// Prints Parquet metadata [`ParquetMetaData`](crate::file::metadata::ParquetMetaData)
-/// information.
+/// Prints Parquet metadata [`ParquetMetaData`] information.
 #[allow(unused_must_use)]
 pub fn print_parquet_metadata(out: &mut dyn io::Write, metadata: &ParquetMetaData) {
     print_file_metadata(out, metadata.file_metadata());
@@ -62,20 +59,19 @@ pub fn print_parquet_metadata(out: &mut dyn io::Write, metadata: &ParquetMetaDat
     writeln!(out, "row groups:");
     writeln!(out);
     for (i, rg) in metadata.row_groups().iter().enumerate() {
-        writeln!(out, "row group {}:", i);
+        writeln!(out, "row group {i}:");
         print_dashes(out, 80);
         print_row_group_metadata(out, rg);
     }
 }
 
-/// Prints file metadata [`FileMetaData`](crate::file::metadata::FileMetaData)
-/// information.
+/// Prints file metadata [`FileMetaData`] information.
 #[allow(unused_must_use)]
 pub fn print_file_metadata(out: &mut dyn io::Write, file_metadata: &FileMetaData) {
     writeln!(out, "version: {}", file_metadata.version());
     writeln!(out, "num of rows: {}", file_metadata.num_rows());
     if let Some(created_by) = file_metadata.created_by().as_ref() {
-        writeln!(out, "created by: {}", created_by);
+        writeln!(out, "created by: {created_by}");
     }
     if let Some(metadata) = file_metadata.key_value_metadata() {
         writeln!(out, "metadata:");
@@ -92,7 +88,7 @@ pub fn print_file_metadata(out: &mut dyn io::Write, file_metadata: &FileMetaData
     print_schema(out, schema);
 }
 
-/// Prints Parquet [`Type`](crate::schema::types::Type) information.
+/// Prints Parquet [`Type`] information.
 #[allow(unused_must_use)]
 pub fn print_schema(out: &mut dyn io::Write, tp: &Type) {
     // TODO: better if we can pass fmt::Write to Printer.
@@ -102,7 +98,7 @@ pub fn print_schema(out: &mut dyn io::Write, tp: &Type) {
         let mut printer = Printer::new(&mut s);
         printer.print(tp);
     }
-    writeln!(out, "{}", s);
+    writeln!(out, "{s}");
 }
 
 #[allow(unused_must_use)]
@@ -114,29 +110,27 @@ fn print_row_group_metadata(out: &mut dyn io::Write, rg_metadata: &RowGroupMetaD
     writeln!(out, "columns: ");
     for (i, cc) in rg_metadata.columns().iter().enumerate() {
         writeln!(out);
-        writeln!(out, "column {}:", i);
+        writeln!(out, "column {i}:");
         print_dashes(out, 80);
         print_column_chunk_metadata(out, cc);
     }
 }
 
 #[allow(unused_must_use)]
-fn print_column_chunk_metadata(
-    out: &mut dyn io::Write,
-    cc_metadata: &ColumnChunkMetaData,
-) {
+fn print_column_chunk_metadata(out: &mut dyn io::Write, cc_metadata: &ColumnChunkMetaData) {
     writeln!(out, "column type: {}", cc_metadata.column_type());
     writeln!(out, "column path: {}", cc_metadata.column_path());
     let encoding_strs: Vec<_> = cc_metadata
         .encodings()
         .iter()
-        .map(|e| format!("{}", e))
+        .map(|e| format!("{e}"))
         .collect();
     writeln!(out, "encodings: {}", encoding_strs.join(" "));
     let file_path_str = cc_metadata.file_path().unwrap_or("N/A");
-    writeln!(out, "file path: {}", file_path_str);
+    writeln!(out, "file path: {file_path_str}");
     writeln!(out, "file offset: {}", cc_metadata.file_offset());
     writeln!(out, "num of values: {}", cc_metadata.num_values());
+    writeln!(out, "compression: {}", cc_metadata.compression());
     writeln!(
         out,
         "total compressed size (in bytes): {}",
@@ -152,42 +146,47 @@ fn print_column_chunk_metadata(
         None => "N/A".to_owned(),
         Some(ipo) => ipo.to_string(),
     };
-    writeln!(out, "index page offset: {}", index_page_offset_str);
+    writeln!(out, "index page offset: {index_page_offset_str}");
     let dict_page_offset_str = match cc_metadata.dictionary_page_offset() {
         None => "N/A".to_owned(),
         Some(dpo) => dpo.to_string(),
     };
-    writeln!(out, "dictionary page offset: {}", dict_page_offset_str);
+    writeln!(out, "dictionary page offset: {dict_page_offset_str}");
     let statistics_str = match cc_metadata.statistics() {
         None => "N/A".to_owned(),
         Some(stats) => stats.to_string(),
     };
-    writeln!(out, "statistics: {}", statistics_str);
+    writeln!(out, "statistics: {statistics_str}");
     let bloom_filter_offset_str = match cc_metadata.bloom_filter_offset() {
         None => "N/A".to_owned(),
         Some(bfo) => bfo.to_string(),
     };
-    writeln!(out, "bloom filter offset: {}", bloom_filter_offset_str);
+    writeln!(out, "bloom filter offset: {bloom_filter_offset_str}");
+    let bloom_filter_length_str = match cc_metadata.bloom_filter_length() {
+        None => "N/A".to_owned(),
+        Some(bfo) => bfo.to_string(),
+    };
+    writeln!(out, "bloom filter length: {bloom_filter_length_str}");
     let offset_index_offset_str = match cc_metadata.offset_index_offset() {
         None => "N/A".to_owned(),
         Some(oio) => oio.to_string(),
     };
-    writeln!(out, "offset index offset: {}", offset_index_offset_str);
+    writeln!(out, "offset index offset: {offset_index_offset_str}");
     let offset_index_length_str = match cc_metadata.offset_index_length() {
         None => "N/A".to_owned(),
         Some(oil) => oil.to_string(),
     };
-    writeln!(out, "offset index length: {}", offset_index_length_str);
+    writeln!(out, "offset index length: {offset_index_length_str}");
     let column_index_offset_str = match cc_metadata.column_index_offset() {
         None => "N/A".to_owned(),
         Some(cio) => cio.to_string(),
     };
-    writeln!(out, "column index offset: {}", column_index_offset_str);
+    writeln!(out, "column index offset: {column_index_offset_str}");
     let column_index_length_str = match cc_metadata.column_index_length() {
         None => "N/A".to_owned(),
         Some(cil) => cil.to_string(),
     };
-    writeln!(out, "column index length: {}", column_index_length_str);
+    writeln!(out, "column index length: {column_index_length_str}");
     writeln!(out);
 }
 
@@ -242,10 +241,10 @@ fn print_logical_and_converted(
                 bit_width,
                 is_signed,
             } => {
-                format!("INTEGER({},{})", bit_width, is_signed)
+                format!("INTEGER({bit_width},{is_signed})")
             }
             LogicalType::Decimal { scale, precision } => {
-                format!("DECIMAL({},{})", precision, scale)
+                format!("DECIMAL({precision},{scale})")
             }
             LogicalType::Timestamp {
                 is_adjusted_to_u_t_c,
@@ -271,6 +270,7 @@ fn print_logical_and_converted(
             LogicalType::Enum => "ENUM".to_string(),
             LogicalType::List => "LIST".to_string(),
             LogicalType::Map => "MAP".to_string(),
+            LogicalType::Float16 => "FLOAT16".to_string(),
             LogicalType::Unknown => "UNKNOWN".to_string(),
         },
         None => {
@@ -283,15 +283,15 @@ fn print_logical_and_converted(
                     // DECIMAL(9) - DECIMAL
                     let precision_scale = match (precision, scale) {
                         (p, s) if p > 0 && s > 0 => {
-                            format!("({},{})", p, s)
+                            format!("({p},{s})")
                         }
-                        (p, 0) if p > 0 => format!("({})", p),
+                        (p, 0) if p > 0 => format!("({p})"),
                         _ => String::new(),
                     };
-                    format!("{}{}", decimal, precision_scale)
+                    format!("{decimal}{precision_scale}")
                 }
                 other_converted_type => {
-                    format!("{}", other_converted_type)
+                    format!("{other_converted_type}")
                 }
             }
         }
@@ -313,9 +313,9 @@ impl<'a> Printer<'a> {
                 let phys_type_str = match physical_type {
                     PhysicalType::FIXED_LEN_BYTE_ARRAY => {
                         // We need to include length for fixed byte array
-                        format!("{} ({})", physical_type, type_length)
+                        format!("{physical_type} ({type_length})")
                     }
-                    _ => format!("{}", physical_type),
+                    _ => format!("{physical_type}"),
                 };
                 // Also print logical type if it is available
                 // If there is a logical type, do not print converted type
@@ -358,7 +358,7 @@ impl<'a> Printer<'a> {
                         0,
                     );
                     if !logical_str.is_empty() {
-                        write!(self.output, "({}) ", logical_str);
+                        write!(self.output, "({logical_str}) ");
                     }
                     writeln!(self.output, "{{");
                 } else {
@@ -644,36 +644,39 @@ mod tests {
                 "REQUIRED FIXED_LEN_BYTE_ARRAY (16) field (UUID);",
             ),
             (
-                Type::primitive_type_builder(
-                    "decimal",
-                    PhysicalType::FIXED_LEN_BYTE_ARRAY,
-                )
-                .with_logical_type(Some(LogicalType::Decimal {
-                    precision: 32,
-                    scale: 20,
-                }))
-                .with_precision(32)
-                .with_scale(20)
-                .with_length(decimal_length_from_precision(32))
-                .with_repetition(Repetition::REPEATED)
-                .build()
-                .unwrap(),
+                Type::primitive_type_builder("decimal", PhysicalType::FIXED_LEN_BYTE_ARRAY)
+                    .with_logical_type(Some(LogicalType::Decimal {
+                        precision: 32,
+                        scale: 20,
+                    }))
+                    .with_precision(32)
+                    .with_scale(20)
+                    .with_length(decimal_length_from_precision(32))
+                    .with_repetition(Repetition::REPEATED)
+                    .build()
+                    .unwrap(),
                 "REPEATED FIXED_LEN_BYTE_ARRAY (14) decimal (DECIMAL(32,20));",
             ),
             (
-                Type::primitive_type_builder(
-                    "decimal",
-                    PhysicalType::FIXED_LEN_BYTE_ARRAY,
-                )
-                .with_converted_type(ConvertedType::DECIMAL)
-                .with_precision(19)
-                .with_scale(4)
-                .with_length(decimal_length_from_precision(19))
-                .with_repetition(Repetition::OPTIONAL)
-                .build()
-                .unwrap(),
+                Type::primitive_type_builder("decimal", PhysicalType::FIXED_LEN_BYTE_ARRAY)
+                    .with_converted_type(ConvertedType::DECIMAL)
+                    .with_precision(19)
+                    .with_scale(4)
+                    .with_length(decimal_length_from_precision(19))
+                    .with_repetition(Repetition::OPTIONAL)
+                    .build()
+                    .unwrap(),
                 "OPTIONAL FIXED_LEN_BYTE_ARRAY (9) decimal (DECIMAL(19,4));",
             ),
+            (
+                Type::primitive_type_builder("float16", PhysicalType::FIXED_LEN_BYTE_ARRAY)
+                    .with_logical_type(Some(LogicalType::Float16))
+                    .with_length(2)
+                    .with_repetition(Repetition::REQUIRED)
+                    .build()
+                    .unwrap(),
+                "REQUIRED FIXED_LEN_BYTE_ARRAY (2) float16 (FLOAT16);",
+            ),
         ];
 
         types_and_strings.into_iter().for_each(|(field, expected)| {
@@ -694,40 +697,39 @@ mod tests {
             let f1 = Type::primitive_type_builder("f1", PhysicalType::INT32)
                 .with_repetition(Repetition::REQUIRED)
                 .with_converted_type(ConvertedType::INT_32)
-                .with_id(0)
+                .with_id(Some(0))
                 .build();
             let f2 = Type::primitive_type_builder("f2", PhysicalType::BYTE_ARRAY)
                 .with_converted_type(ConvertedType::UTF8)
-                .with_id(1)
+                .with_id(Some(1))
                 .build();
             let f3 = Type::primitive_type_builder("f3", PhysicalType::BYTE_ARRAY)
                 .with_logical_type(Some(LogicalType::String))
-                .with_id(1)
+                .with_id(Some(1))
+                .build();
+            let f4 = Type::primitive_type_builder("f4", PhysicalType::FIXED_LEN_BYTE_ARRAY)
+                .with_repetition(Repetition::REPEATED)
+                .with_converted_type(ConvertedType::INTERVAL)
+                .with_length(12)
+                .with_id(Some(2))
                 .build();
-            let f4 =
-                Type::primitive_type_builder("f4", PhysicalType::FIXED_LEN_BYTE_ARRAY)
-                    .with_repetition(Repetition::REPEATED)
-                    .with_converted_type(ConvertedType::INTERVAL)
-                    .with_length(12)
-                    .with_id(2)
-                    .build();
 
-            let mut struct_fields = vec![
+            let struct_fields = vec![
                 Arc::new(f1.unwrap()),
                 Arc::new(f2.unwrap()),
                 Arc::new(f3.unwrap()),
             ];
             let field = Type::group_type_builder("field")
                 .with_repetition(Repetition::OPTIONAL)
-                .with_fields(&mut struct_fields)
-                .with_id(1)
+                .with_fields(struct_fields)
+                .with_id(Some(1))
                 .build()
                 .unwrap();
 
-            let mut fields = vec![Arc::new(field), Arc::new(f4.unwrap())];
+            let fields = vec![Arc::new(field), Arc::new(f4.unwrap())];
             let message = Type::group_type_builder("schema")
-                .with_fields(&mut fields)
-                .with_id(2)
+                .with_fields(fields)
+                .with_id(Some(2))
                 .build()
                 .unwrap();
             p.print(&message);
@@ -755,7 +757,7 @@ mod tests {
             .with_repetition(Repetition::OPTIONAL)
             .with_logical_type(Some(LogicalType::List))
             .with_converted_type(ConvertedType::LIST)
-            .with_fields(&mut vec![Arc::new(a2)])
+            .with_fields(vec![Arc::new(a2)])
             .build()
             .unwrap();
 
@@ -772,7 +774,7 @@ mod tests {
         let b2 = Type::group_type_builder("b2")
             .with_repetition(Repetition::REPEATED)
             .with_converted_type(ConvertedType::NONE)
-            .with_fields(&mut vec![Arc::new(b3), Arc::new(b4)])
+            .with_fields(vec![Arc::new(b3), Arc::new(b4)])
             .build()
             .unwrap();
 
@@ -780,18 +782,18 @@ mod tests {
             .with_repetition(Repetition::OPTIONAL)
             .with_logical_type(Some(LogicalType::List))
             .with_converted_type(ConvertedType::LIST)
-            .with_fields(&mut vec![Arc::new(b2)])
+            .with_fields(vec![Arc::new(b2)])
             .build()
             .unwrap();
 
         let a0 = Type::group_type_builder("a0")
             .with_repetition(Repetition::REQUIRED)
-            .with_fields(&mut vec![Arc::new(a1), Arc::new(b1)])
+            .with_fields(vec![Arc::new(a1), Arc::new(b1)])
             .build()
             .unwrap();
 
         let message = Type::group_type_builder("root")
-            .with_fields(&mut vec![Arc::new(a0)])
+            .with_fields(vec![Arc::new(a0)])
             .build()
             .unwrap();
 
@@ -814,7 +816,7 @@ mod tests {
 
         let field = Type::group_type_builder("field")
             .with_repetition(Repetition::OPTIONAL)
-            .with_fields(&mut vec![Arc::new(f1), Arc::new(f2)])
+            .with_fields(vec![Arc::new(f1), Arc::new(f2)])
             .build()
             .unwrap();
 
@@ -826,7 +828,7 @@ mod tests {
             .unwrap();
 
         let message = Type::group_type_builder("schema")
-            .with_fields(&mut vec![Arc::new(field), Arc::new(f3)])
+            .with_fields(vec![Arc::new(field), Arc::new(f3)])
             .build()
             .unwrap();
 
@@ -860,7 +862,7 @@ mod tests {
             .unwrap();
 
         let message = Type::group_type_builder("schema")
-            .with_fields(&mut vec![Arc::new(f1), Arc::new(f2)])
+            .with_fields(vec![Arc::new(f1), Arc::new(f2)])
             .build()
             .unwrap();
 
diff --git a/parquet/src/schema/types.rs b/parquet/src/schema/types.rs
index 823803167ca1..c913f13c174c 100644
--- a/parquet/src/schema/types.rs
+++ b/parquet/src/schema/types.rs
@@ -19,10 +19,10 @@
 
 use std::{collections::HashMap, convert::From, fmt, sync::Arc};
 
-use parquet_format::SchemaElement;
+use crate::format::SchemaElement;
 
 use crate::basic::{
-    ConvertedType, LogicalType, Repetition, TimeUnit, Type as PhysicalType,
+    ColumnOrder, ConvertedType, LogicalType, Repetition, SortOrder, TimeUnit, Type as PhysicalType,
 };
 use crate::errors::{ParquetError, Result};
 
@@ -57,10 +57,7 @@ pub enum Type {
 
 impl Type {
     /// Creates primitive type builder with provided field name and physical type.
-    pub fn primitive_type_builder(
-        name: &str,
-        physical_type: PhysicalType,
-    ) -> PrimitiveTypeBuilder {
+    pub fn primitive_type_builder(name: &str, physical_type: PhysicalType) -> PrimitiveTypeBuilder {
         PrimitiveTypeBuilder::new(name, physical_type)
     }
 
@@ -127,8 +124,7 @@ impl Type {
     /// This method can be used to check if projected columns are part of the root schema.
     pub fn check_contains(&self, sub_type: &Type) -> bool {
         // Names match, and repetitions match or not set for both
-        let basic_match = self.get_basic_info().name()
-            == sub_type.get_basic_info().name()
+        let basic_match = self.get_basic_info().name() == sub_type.get_basic_info().name()
             && (self.is_schema() && sub_type.is_schema()
                 || !self.is_schema()
                     && !sub_type.is_schema()
@@ -218,53 +214,52 @@ impl<'a> PrimitiveTypeBuilder<'a> {
         }
     }
 
-    /// Sets [`Repetition`](crate::basic::Repetition) for this field and returns itself.
-    pub fn with_repetition(mut self, repetition: Repetition) -> Self {
-        self.repetition = repetition;
-        self
+    /// Sets [`Repetition`] for this field and returns itself.
+    pub fn with_repetition(self, repetition: Repetition) -> Self {
+        Self { repetition, ..self }
     }
 
-    /// Sets [`ConvertedType`](crate::basic::ConvertedType) for this field and returns itself.
-    pub fn with_converted_type(mut self, converted_type: ConvertedType) -> Self {
-        self.converted_type = converted_type;
-        self
+    /// Sets [`ConvertedType`] for this field and returns itself.
+    pub fn with_converted_type(self, converted_type: ConvertedType) -> Self {
+        Self {
+            converted_type,
+            ..self
+        }
     }
 
-    /// Sets [`LogicalType`](crate::basic::LogicalType) for this field and returns itself.
+    /// Sets [`LogicalType`] for this field and returns itself.
     /// If only the logical type is populated for a primitive type, the converted type
     /// will be automatically populated, and can thus be omitted.
-    pub fn with_logical_type(mut self, logical_type: Option<LogicalType>) -> Self {
-        self.logical_type = logical_type;
-        self
+    pub fn with_logical_type(self, logical_type: Option<LogicalType>) -> Self {
+        Self {
+            logical_type,
+            ..self
+        }
     }
 
     /// Sets type length and returns itself.
     /// This is only applied to FIXED_LEN_BYTE_ARRAY and INT96 (INTERVAL) types, because
     /// they maintain fixed size underlying byte array.
     /// By default, value is `0`.
-    pub fn with_length(mut self, length: i32) -> Self {
-        self.length = length;
-        self
+    pub fn with_length(self, length: i32) -> Self {
+        Self { length, ..self }
     }
 
     /// Sets precision for Parquet DECIMAL physical type and returns itself.
     /// By default, it equals to `0` and used only for decimal context.
-    pub fn with_precision(mut self, precision: i32) -> Self {
-        self.precision = precision;
-        self
+    pub fn with_precision(self, precision: i32) -> Self {
+        Self { precision, ..self }
     }
 
     /// Sets scale for Parquet DECIMAL physical type and returns itself.
     /// By default, it equals to `0` and used only for decimal context.
-    pub fn with_scale(mut self, scale: i32) -> Self {
-        self.scale = scale;
-        self
+    pub fn with_scale(self, scale: i32) -> Self {
+        Self { scale, ..self }
     }
 
     /// Sets optional field id and returns itself.
-    pub fn with_id(mut self, id: i32) -> Self {
-        self.id = Some(id);
-        self
+    pub fn with_id(self, id: Option<i32>) -> Self {
+        Self { id, ..self }
     }
 
     /// Creates a new `PrimitiveType` instance from the collected attributes.
@@ -281,8 +276,9 @@ impl<'a> PrimitiveTypeBuilder<'a> {
         // Check length before logical type, since it is used for logical type validation.
         if self.physical_type == PhysicalType::FIXED_LEN_BYTE_ARRAY && self.length < 0 {
             return Err(general_err!(
-                "Invalid FIXED_LEN_BYTE_ARRAY length: {}",
-                self.length
+                "Invalid FIXED_LEN_BYTE_ARRAY length: {} for field '{}'",
+                self.length,
+                self.name
             ));
         }
 
@@ -291,13 +287,12 @@ impl<'a> PrimitiveTypeBuilder<'a> {
                 // If a converted type is populated, check that it is consistent with
                 // its logical type
                 if self.converted_type != ConvertedType::NONE {
-                    if ConvertedType::from(self.logical_type.clone())
-                        != self.converted_type
-                    {
+                    if ConvertedType::from(self.logical_type.clone()) != self.converted_type {
                         return Err(general_err!(
-                            "Logical type {:?} is imcompatible with converted type {}",
+                            "Logical type {:?} is incompatible with converted type {} for field '{}'",
                             logical_type,
-                            self.converted_type
+                            self.converted_type,
+                            self.name
                         ));
                     }
                 } else {
@@ -308,8 +303,9 @@ impl<'a> PrimitiveTypeBuilder<'a> {
                 match (logical_type, self.physical_type) {
                     (LogicalType::Map, _) | (LogicalType::List, _) => {
                         return Err(general_err!(
-                            "{:?} cannot be applied to a primitive type",
-                            logical_type
+                            "{:?} cannot be applied to a primitive type for field '{}'",
+                            logical_type,
+                            self.name
                         ));
                     }
                     (LogicalType::Enum, PhysicalType::BYTE_ARRAY) => {}
@@ -317,16 +313,18 @@ impl<'a> PrimitiveTypeBuilder<'a> {
                         // Check that scale and precision are consistent with legacy values
                         if *scale != self.scale {
                             return Err(general_err!(
-                                "DECIMAL logical type scale {} must match self.scale {}",
+                                "DECIMAL logical type scale {} must match self.scale {} for field '{}'",
                                 scale,
-                                self.scale
+                                self.scale,
+                                self.name
                             ));
                         }
                         if *precision != self.precision {
                             return Err(general_err!(
-                                "DECIMAL logical type precision {} must match self.precision {}",
+                                "DECIMAL logical type precision {} must match self.precision {} for field '{}'",
                                 precision,
-                                self.precision
+                                self.precision,
+                                self.name
                             ));
                         }
                         self.check_decimal_precision_scale()?;
@@ -342,7 +340,8 @@ impl<'a> PrimitiveTypeBuilder<'a> {
                     (LogicalType::Time { unit, .. }, PhysicalType::INT64) => {
                         if *unit == TimeUnit::MILLIS(Default::default()) {
                             return Err(general_err!(
-                                "Cannot use millisecond unit on INT64 type"
+                                "Cannot use millisecond unit on INT64 type for field '{}'",
+                                self.name
                             ));
                         }
                     }
@@ -357,11 +356,20 @@ impl<'a> PrimitiveTypeBuilder<'a> {
                     (LogicalType::Json, PhysicalType::BYTE_ARRAY) => {}
                     (LogicalType::Bson, PhysicalType::BYTE_ARRAY) => {}
                     (LogicalType::Uuid, PhysicalType::FIXED_LEN_BYTE_ARRAY) => {}
+                    (LogicalType::Float16, PhysicalType::FIXED_LEN_BYTE_ARRAY)
+                        if self.length == 2 => {}
+                    (LogicalType::Float16, PhysicalType::FIXED_LEN_BYTE_ARRAY) => {
+                        return Err(general_err!(
+                            "FLOAT16 cannot annotate field '{}' because it is not a FIXED_LEN_BYTE_ARRAY(2) field",
+                            self.name
+                        ))
+                    }
                     (a, b) => {
                         return Err(general_err!(
-                            "Cannot annotate {:?} from {} fields",
+                            "Cannot annotate {:?} from {} for field '{}'",
                             a,
-                            b
+                            b,
+                            self.name
                         ))
                     }
                 }
@@ -374,8 +382,9 @@ impl<'a> PrimitiveTypeBuilder<'a> {
             ConvertedType::UTF8 | ConvertedType::BSON | ConvertedType::JSON => {
                 if self.physical_type != PhysicalType::BYTE_ARRAY {
                     return Err(general_err!(
-                        "{} can only annotate BYTE_ARRAY fields",
-                        self.converted_type
+                        "{} cannot annotate field '{}' because it is not a BYTE_ARRAY field",
+                        self.converted_type,
+                        self.name
                     ));
                 }
             }
@@ -392,8 +401,9 @@ impl<'a> PrimitiveTypeBuilder<'a> {
             | ConvertedType::INT_32 => {
                 if self.physical_type != PhysicalType::INT32 {
                     return Err(general_err!(
-                        "{} can only annotate INT32",
-                        self.converted_type
+                        "{} cannot annotate field '{}' because it is not a INT32 field",
+                        self.converted_type,
+                        self.name
                     ));
                 }
             }
@@ -404,29 +414,33 @@ impl<'a> PrimitiveTypeBuilder<'a> {
             | ConvertedType::INT_64 => {
                 if self.physical_type != PhysicalType::INT64 {
                     return Err(general_err!(
-                        "{} can only annotate INT64",
-                        self.converted_type
+                        "{} cannot annotate field '{}' because it is not a INT64 field",
+                        self.converted_type,
+                        self.name
                     ));
                 }
             }
             ConvertedType::INTERVAL => {
-                if self.physical_type != PhysicalType::FIXED_LEN_BYTE_ARRAY
-                    || self.length != 12
-                {
+                if self.physical_type != PhysicalType::FIXED_LEN_BYTE_ARRAY || self.length != 12 {
                     return Err(general_err!(
-                        "INTERVAL can only annotate FIXED_LEN_BYTE_ARRAY(12)"
+                        "INTERVAL cannot annotate field '{}' because it is not a FIXED_LEN_BYTE_ARRAY(12) field",
+                        self.name
                     ));
                 }
             }
             ConvertedType::ENUM => {
                 if self.physical_type != PhysicalType::BYTE_ARRAY {
-                    return Err(general_err!("ENUM can only annotate BYTE_ARRAY fields"));
+                    return Err(general_err!(
+                        "ENUM cannot annotate field '{}' because it is not a BYTE_ARRAY field",
+                        self.name
+                    ));
                 }
             }
             _ => {
                 return Err(general_err!(
-                    "{} cannot be applied to a primitive type",
-                    self.converted_type
+                    "{} cannot be applied to primitive field '{}'",
+                    self.converted_type,
+                    self.name
                 ));
             }
         }
@@ -495,8 +509,7 @@ impl<'a> PrimitiveTypeBuilder<'a> {
                 }
             }
             PhysicalType::FIXED_LEN_BYTE_ARRAY => {
-                let max_precision =
-                    (2f64.powi(8 * self.length - 1) - 1f64).log10().floor() as i32;
+                let max_precision = (2f64.powi(8 * self.length - 1) - 1f64).log10().floor() as i32;
 
                 if self.precision > max_precision {
                     return Err(general_err!(
@@ -540,35 +553,37 @@ impl<'a> GroupTypeBuilder<'a> {
         }
     }
 
-    /// Sets [`Repetition`](crate::basic::Repetition) for this field and returns itself.
+    /// Sets [`Repetition`] for this field and returns itself.
     pub fn with_repetition(mut self, repetition: Repetition) -> Self {
         self.repetition = Some(repetition);
         self
     }
 
-    /// Sets [`ConvertedType`](crate::basic::ConvertedType) for this field and returns itself.
-    pub fn with_converted_type(mut self, converted_type: ConvertedType) -> Self {
-        self.converted_type = converted_type;
-        self
+    /// Sets [`ConvertedType`] for this field and returns itself.
+    pub fn with_converted_type(self, converted_type: ConvertedType) -> Self {
+        Self {
+            converted_type,
+            ..self
+        }
     }
 
-    /// Sets [`LogicalType`](crate::basic::LogicalType) for this field and returns itself.
-    pub fn with_logical_type(mut self, logical_type: Option<LogicalType>) -> Self {
-        self.logical_type = logical_type;
-        self
+    /// Sets [`LogicalType`] for this field and returns itself.
+    pub fn with_logical_type(self, logical_type: Option<LogicalType>) -> Self {
+        Self {
+            logical_type,
+            ..self
+        }
     }
 
     /// Sets a list of fields that should be child nodes of this field.
     /// Returns updated self.
-    pub fn with_fields(mut self, fields: &mut Vec<TypePtr>) -> Self {
-        self.fields.append(fields);
-        self
+    pub fn with_fields(self, fields: Vec<TypePtr>) -> Self {
+        Self { fields, ..self }
     }
 
     /// Sets optional field id and returns itself.
-    pub fn with_id(mut self, id: i32) -> Self {
-        self.id = Some(id);
-        self
+    pub fn with_id(self, id: Option<i32>) -> Self {
+        Self { id, ..self }
     }
 
     /// Creates a new `GroupType` instance from the gathered attributes.
@@ -615,18 +630,18 @@ impl BasicTypeInfo {
         self.repetition.is_some()
     }
 
-    /// Returns [`Repetition`](crate::basic::Repetition) value for the type.
+    /// Returns [`Repetition`] value for the type.
     pub fn repetition(&self) -> Repetition {
         assert!(self.repetition.is_some());
         self.repetition.unwrap()
     }
 
-    /// Returns [`ConvertedType`](crate::basic::ConvertedType) value for the type.
+    /// Returns [`ConvertedType`] value for the type.
     pub fn converted_type(&self) -> ConvertedType {
         self.converted_type
     }
 
-    /// Returns [`LogicalType`](crate::basic::LogicalType) value for the type.
+    /// Returns [`LogicalType`] value for the type.
     pub fn logical_type(&self) -> Option<LogicalType> {
         // Unlike ConvertedType, LogicalType cannot implement Copy, thus we clone it
         self.logical_type.clone()
@@ -773,12 +788,12 @@ impl ColumnDescriptor {
         &self.path
     }
 
-    /// Returns self type [`Type`](crate::schema::types::Type) for this leaf column.
+    /// Returns self type [`Type`] for this leaf column.
     pub fn self_type(&self) -> &Type {
         self.primitive_type.as_ref()
     }
 
-    /// Returns self type [`TypePtr`](crate::schema::types::TypePtr)  for this leaf
+    /// Returns self type [`TypePtr`]  for this leaf
     /// column.
     pub fn self_type_ptr(&self) -> TypePtr {
         self.primitive_type.clone()
@@ -789,12 +804,12 @@ impl ColumnDescriptor {
         self.primitive_type.name()
     }
 
-    /// Returns [`ConvertedType`](crate::basic::ConvertedType) for this column.
+    /// Returns [`ConvertedType`] for this column.
     pub fn converted_type(&self) -> ConvertedType {
         self.primitive_type.get_basic_info().converted_type()
     }
 
-    /// Returns [`LogicalType`](crate::basic::LogicalType) for this column.
+    /// Returns [`LogicalType`] for this column.
     pub fn logical_type(&self) -> Option<LogicalType> {
         self.primitive_type.get_basic_info().logical_type()
     }
@@ -834,6 +849,15 @@ impl ColumnDescriptor {
             _ => panic!("Expected primitive type!"),
         }
     }
+
+    /// Returns the sort order for this column
+    pub fn sort_order(&self) -> SortOrder {
+        ColumnOrder::get_sort_order(
+            self.logical_type(),
+            self.converted_type(),
+            self.physical_type(),
+        )
+    }
 }
 
 /// A schema descriptor. This encapsulates the top-level schemas for all the columns,
@@ -905,14 +929,13 @@ impl SchemaDescriptor {
         self.leaves.len()
     }
 
-    /// Returns column root [`Type`](crate::schema::types::Type) for a leaf position.
+    /// Returns column root [`Type`] for a leaf position.
     pub fn get_column_root(&self, i: usize) -> &Type {
         let result = self.column_root_of(i);
         result.as_ref()
     }
 
-    /// Returns column root [`Type`](crate::schema::types::Type) pointer for a leaf
-    /// position.
+    /// Returns column root [`Type`] pointer for a leaf position.
     pub fn get_column_root_ptr(&self, i: usize) -> TypePtr {
         let result = self.column_root_of(i);
         result.clone()
@@ -927,16 +950,17 @@ impl SchemaDescriptor {
             self.leaves.len()
         );
 
-        *self.leaf_to_base.get(leaf).unwrap_or_else(|| {
-            panic!("Expected a value for index {} but found None", leaf)
-        })
+        *self
+            .leaf_to_base
+            .get(leaf)
+            .unwrap_or_else(|| panic!("Expected a value for index {leaf} but found None"))
     }
 
     fn column_root_of(&self, i: usize) -> &TypePtr {
         &self.schema.get_fields()[self.get_column_root_idx(i)]
     }
 
-    /// Returns schema as [`Type`](crate::schema::types::Type).
+    /// Returns schema as [`Type`].
     pub fn root_schema(&self) -> &Type {
         self.schema.as_ref()
     }
@@ -1026,10 +1050,7 @@ pub fn from_thrift(elements: &[SchemaElement]) -> Result<TypePtr> {
 /// The first result is the starting index for the next Type after this one. If it is
 /// equal to `elements.len()`, then this Type is the last one.
 /// The second result is the result Type.
-fn from_thrift_helper(
-    elements: &[SchemaElement],
-    index: usize,
-) -> Result<(usize, TypePtr)> {
+fn from_thrift_helper(elements: &[SchemaElement], index: usize) -> Result<(usize, TypePtr)> {
     // Whether or not the current node is root (message type).
     // There is only one message type node in the schema tree.
     let is_root_node = index == 0;
@@ -1042,7 +1063,7 @@ fn from_thrift_helper(
         ));
     }
     let element = &elements[index];
-    let converted_type = ConvertedType::from(element.converted_type);
+    let converted_type = ConvertedType::try_from(element.converted_type)?;
     // LogicalType is only present in v2 Parquet files. ConvertedType is always
     // populated, regardless of the version of the file (v1 or v2).
     let logical_type = element
@@ -1063,30 +1084,50 @@ fn from_thrift_helper(
                     "Repetition level must be defined for a primitive type"
                 ));
             }
-            let repetition = Repetition::from(elements[index].repetition_type.unwrap());
-            let physical_type = PhysicalType::from(elements[index].type_.unwrap());
-            let length = elements[index].type_length.unwrap_or(-1);
-            let scale = elements[index].scale.unwrap_or(-1);
-            let precision = elements[index].precision.unwrap_or(-1);
-            let name = &elements[index].name;
-            let mut builder = Type::primitive_type_builder(name, physical_type)
-                .with_repetition(repetition)
-                .with_converted_type(converted_type)
-                .with_logical_type(logical_type)
-                .with_length(length)
-                .with_precision(precision)
-                .with_scale(scale);
-            if let Some(id) = field_id {
-                builder = builder.with_id(id);
+            let repetition = Repetition::try_from(elements[index].repetition_type.unwrap())?;
+            if let Some(type_) = elements[index].type_ {
+                let physical_type = PhysicalType::try_from(type_)?;
+                let length = elements[index].type_length.unwrap_or(-1);
+                let scale = elements[index].scale.unwrap_or(-1);
+                let precision = elements[index].precision.unwrap_or(-1);
+                let name = &elements[index].name;
+                let builder = Type::primitive_type_builder(name, physical_type)
+                    .with_repetition(repetition)
+                    .with_converted_type(converted_type)
+                    .with_logical_type(logical_type)
+                    .with_length(length)
+                    .with_precision(precision)
+                    .with_scale(scale)
+                    .with_id(field_id);
+                Ok((index + 1, Arc::new(builder.build()?)))
+            } else {
+                let mut builder = Type::group_type_builder(&elements[index].name)
+                    .with_converted_type(converted_type)
+                    .with_logical_type(logical_type)
+                    .with_id(field_id);
+                if !is_root_node {
+                    // Sometimes parquet-cpp and parquet-mr set repetition level REQUIRED or
+                    // REPEATED for root node.
+                    //
+                    // We only set repetition for group types that are not top-level message
+                    // type. According to parquet-format:
+                    //   Root of the schema does not have a repetition_type.
+                    //   All other types must have one.
+                    builder = builder.with_repetition(repetition);
+                }
+                Ok((index + 1, Arc::new(builder.build().unwrap())))
             }
-            Ok((index + 1, Arc::new(builder.build()?)))
         }
         Some(n) => {
-            let repetition = elements[index].repetition_type.map(Repetition::from);
+            let repetition = elements[index]
+                .repetition_type
+                .map(Repetition::try_from)
+                .transpose()?;
+
             let mut fields = vec![];
             let mut next_index = index + 1;
             for _ in 0..n {
-                let child_result = from_thrift_helper(elements, next_index as usize)?;
+                let child_result = from_thrift_helper(elements, next_index)?;
                 next_index = child_result.0;
                 fields.push(child_result.1);
             }
@@ -1094,7 +1135,8 @@ fn from_thrift_helper(
             let mut builder = Type::group_type_builder(&elements[index].name)
                 .with_converted_type(converted_type)
                 .with_logical_type(logical_type)
-                .with_fields(&mut fields);
+                .with_fields(fields)
+                .with_id(field_id);
             if let Some(rep) = repetition {
                 // Sometimes parquet-cpp and parquet-mr set repetition level REQUIRED or
                 // REPEATED for root node.
@@ -1107,9 +1149,6 @@ fn from_thrift_helper(
                     builder = builder.with_repetition(rep);
                 }
             }
-            if let Some(id) = field_id {
-                builder = builder.with_id(id);
-            }
             Ok((next_index, Arc::new(builder.build().unwrap())))
         }
     }
@@ -1215,7 +1254,7 @@ mod tests {
                 bit_width: 32,
                 is_signed: true,
             }))
-            .with_id(0)
+            .with_id(Some(0))
             .build();
         assert!(result.is_ok());
 
@@ -1252,8 +1291,8 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
-                "Parquet error: Cannot annotate Integer { bit_width: 8, is_signed: true } from INT64 fields"
+                format!("{e}"),
+                "Parquet error: Cannot annotate Integer { bit_width: 8, is_signed: true } from INT64 for field 'foo'"
             );
         }
 
@@ -1265,8 +1304,8 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
-                "Parquet error: BSON can only annotate BYTE_ARRAY fields"
+                format!("{e}"),
+                "Parquet error: BSON cannot annotate field 'foo' because it is not a BYTE_ARRAY field"
             );
         }
 
@@ -1279,7 +1318,7 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
+                format!("{e}"),
                 "Parquet error: DECIMAL can only annotate INT32, INT64, BYTE_ARRAY and FIXED_LEN_BYTE_ARRAY"
             );
         }
@@ -1296,8 +1335,8 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
-                "Parquet error: DECIMAL logical type scale 32 must match self.scale -1"
+                format!("{e}"),
+                "Parquet error: DECIMAL logical type scale 32 must match self.scale -1 for field 'foo'"
             );
         }
 
@@ -1310,7 +1349,7 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
+                format!("{e}"),
                 "Parquet error: Invalid DECIMAL precision: -1"
             );
         }
@@ -1324,7 +1363,7 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
+                format!("{e}"),
                 "Parquet error: Invalid DECIMAL precision: 0"
             );
         }
@@ -1337,7 +1376,7 @@ mod tests {
             .build();
         assert!(result.is_err());
         if let Err(e) = result {
-            assert_eq!(format!("{}", e), "Parquet error: Invalid DECIMAL scale: -1");
+            assert_eq!(format!("{e}"), "Parquet error: Invalid DECIMAL scale: -1");
         }
 
         result = Type::primitive_type_builder("foo", PhysicalType::BYTE_ARRAY)
@@ -1349,7 +1388,7 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
+                format!("{e}"),
                 "Parquet error: Invalid DECIMAL: scale (2) cannot be greater than precision (1)"
             );
         }
@@ -1372,7 +1411,7 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
+                format!("{e}"),
                 "Parquet error: Cannot represent INT32 as DECIMAL with precision 18"
             );
         }
@@ -1386,7 +1425,7 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
+                format!("{e}"),
                 "Parquet error: Cannot represent INT64 as DECIMAL with precision 32"
             );
         }
@@ -1401,7 +1440,7 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
+                format!("{e}"),
                 "Parquet error: Cannot represent FIXED_LEN_BYTE_ARRAY as DECIMAL with length 5 and precision 12. The max precision can only be 11"
             );
         }
@@ -1413,8 +1452,8 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
-                "Parquet error: UINT_8 can only annotate INT32"
+                format!("{e}"),
+                "Parquet error: UINT_8 cannot annotate field 'foo' because it is not a INT32 field"
             );
         }
 
@@ -1425,8 +1464,8 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
-                "Parquet error: TIME_MICROS can only annotate INT64"
+                format!("{e}"),
+                "Parquet error: TIME_MICROS cannot annotate field 'foo' because it is not a INT64 field"
             );
         }
 
@@ -1437,8 +1476,8 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
-                "Parquet error: INTERVAL can only annotate FIXED_LEN_BYTE_ARRAY(12)"
+                format!("{e}"),
+                "Parquet error: INTERVAL cannot annotate field 'foo' because it is not a FIXED_LEN_BYTE_ARRAY(12) field"
             );
         }
 
@@ -1450,8 +1489,8 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
-                "Parquet error: INTERVAL can only annotate FIXED_LEN_BYTE_ARRAY(12)"
+                format!("{e}"),
+                "Parquet error: INTERVAL cannot annotate field 'foo' because it is not a FIXED_LEN_BYTE_ARRAY(12) field"
             );
         }
 
@@ -1462,8 +1501,8 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
-                "Parquet error: ENUM can only annotate BYTE_ARRAY fields"
+                format!("{e}"),
+                "Parquet error: ENUM cannot annotate field 'foo' because it is not a BYTE_ARRAY field"
             );
         }
 
@@ -1474,8 +1513,8 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
-                "Parquet error: MAP cannot be applied to a primitive type"
+                format!("{e}"),
+                "Parquet error: MAP cannot be applied to primitive field 'foo'"
             );
         }
 
@@ -1487,8 +1526,43 @@ mod tests {
         assert!(result.is_err());
         if let Err(e) = result {
             assert_eq!(
-                format!("{}", e),
-                "Parquet error: Invalid FIXED_LEN_BYTE_ARRAY length: -1"
+                format!("{e}"),
+                "Parquet error: Invalid FIXED_LEN_BYTE_ARRAY length: -1 for field 'foo'"
+            );
+        }
+
+        result = Type::primitive_type_builder("foo", PhysicalType::FIXED_LEN_BYTE_ARRAY)
+            .with_repetition(Repetition::REQUIRED)
+            .with_logical_type(Some(LogicalType::Float16))
+            .with_length(2)
+            .build();
+        assert!(result.is_ok());
+
+        // Can't be other than FIXED_LEN_BYTE_ARRAY for physical type
+        result = Type::primitive_type_builder("foo", PhysicalType::FLOAT)
+            .with_repetition(Repetition::REQUIRED)
+            .with_logical_type(Some(LogicalType::Float16))
+            .with_length(2)
+            .build();
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert_eq!(
+                format!("{e}"),
+                "Parquet error: Cannot annotate Float16 from FLOAT for field 'foo'"
+            );
+        }
+
+        // Must have length 2
+        result = Type::primitive_type_builder("foo", PhysicalType::FIXED_LEN_BYTE_ARRAY)
+            .with_repetition(Repetition::REQUIRED)
+            .with_logical_type(Some(LogicalType::Float16))
+            .with_length(4)
+            .build();
+        assert!(result.is_err());
+        if let Err(e) = result {
+            assert_eq!(
+                format!("{e}"),
+                "Parquet error: FLOAT16 cannot annotate field 'foo' because it is not a FIXED_LEN_BYTE_ARRAY(2) field"
             );
         }
     }
@@ -1497,22 +1571,22 @@ mod tests {
     fn test_group_type() {
         let f1 = Type::primitive_type_builder("f1", PhysicalType::INT32)
             .with_converted_type(ConvertedType::INT_32)
-            .with_id(0)
+            .with_id(Some(0))
             .build();
         assert!(f1.is_ok());
         let f2 = Type::primitive_type_builder("f2", PhysicalType::BYTE_ARRAY)
             .with_converted_type(ConvertedType::UTF8)
-            .with_id(1)
+            .with_id(Some(1))
             .build();
         assert!(f2.is_ok());
 
-        let mut fields = vec![Arc::new(f1.unwrap()), Arc::new(f2.unwrap())];
+        let fields = vec![Arc::new(f1.unwrap()), Arc::new(f2.unwrap())];
 
         let result = Type::group_type_builder("foo")
             .with_repetition(Repetition::REPEATED)
             .with_logical_type(Some(LogicalType::List))
-            .with_fields(&mut fields)
-            .with_id(1)
+            .with_fields(fields)
+            .with_id(Some(1))
             .build();
         assert!(result.is_ok());
 
@@ -1593,8 +1667,7 @@ mod tests {
             .with_repetition(Repetition::REQUIRED)
             .with_converted_type(ConvertedType::INT_64)
             .build()?;
-        let item2 =
-            Type::primitive_type_builder("item2", PhysicalType::BOOLEAN).build()?;
+        let item2 = Type::primitive_type_builder("item2", PhysicalType::BOOLEAN).build()?;
         let item3 = Type::primitive_type_builder("item3", PhysicalType::INT32)
             .with_repetition(Repetition::REPEATED)
             .with_converted_type(ConvertedType::INT_32)
@@ -1602,17 +1675,17 @@ mod tests {
         let list = Type::group_type_builder("records")
             .with_repetition(Repetition::REPEATED)
             .with_converted_type(ConvertedType::LIST)
-            .with_fields(&mut vec![Arc::new(item1), Arc::new(item2), Arc::new(item3)])
+            .with_fields(vec![Arc::new(item1), Arc::new(item2), Arc::new(item3)])
             .build()?;
         let bag = Type::group_type_builder("bag")
             .with_repetition(Repetition::OPTIONAL)
-            .with_fields(&mut vec![Arc::new(list)])
+            .with_fields(vec![Arc::new(list)])
             .build()?;
         fields.push(Arc::new(bag));
 
         let schema = Type::group_type_builder("schema")
             .with_repetition(Repetition::REPEATED)
-            .with_fields(&mut fields)
+            .with_fields(fields)
             .build()?;
         let descr = SchemaDescriptor::new(Arc::new(schema));
 
@@ -1628,13 +1701,13 @@ mod tests {
         //     required int64 item1    2    1
         //     optional boolean item2  3    1
         //     repeated int32 item3    3    2
-        let ex_max_def_levels = vec![0, 1, 1, 2, 3, 3];
-        let ex_max_rep_levels = vec![0, 0, 1, 1, 1, 2];
+        let ex_max_def_levels = [0, 1, 1, 2, 3, 3];
+        let ex_max_rep_levels = [0, 0, 1, 1, 1, 2];
 
         for i in 0..nleaves {
             let col = descr.column(i);
-            assert_eq!(col.max_def_level(), ex_max_def_levels[i], "{}", i);
-            assert_eq!(col.max_rep_level(), ex_max_rep_levels[i], "{}", i);
+            assert_eq!(col.max_def_level(), ex_max_def_levels[i], "{i}");
+            assert_eq!(col.max_rep_level(), ex_max_rep_levels[i], "{i}");
         }
 
         assert_eq!(descr.column(0).path().string(), "a");
@@ -1761,13 +1834,9 @@ mod tests {
 
     // function to create a new group type for testing
     fn test_new_group_type(name: &str, repetition: Repetition, types: Vec<Type>) -> Type {
-        let mut fields = Vec::new();
-        for tpe in types {
-            fields.push(Arc::new(tpe))
-        }
         Type::group_type_builder(name)
             .with_repetition(repetition)
-            .with_fields(&mut fields)
+            .with_fields(types.into_iter().map(Arc::new).collect())
             .build()
             .unwrap()
     }
@@ -1962,7 +2031,7 @@ mod tests {
         assert!(thrift_schema.is_err());
         if let Err(e) = thrift_schema {
             assert_eq!(
-                format!("{}", e),
+                format!("{e}"),
                 "Parquet error: Root schema must be Group type"
             );
         }
@@ -1973,6 +2042,7 @@ mod tests {
         let message_type = "
     message conversions {
       REQUIRED INT64 id;
+      OPTIONAL FIXED_LEN_BYTE_ARRAY (2) f16 (FLOAT16);
       OPTIONAL group int_array_Array (LIST) {
         REPEATED group list {
           OPTIONAL group element (LIST) {
@@ -2057,8 +2127,8 @@ mod tests {
         let expected_schema = parse_message_type(message_type).unwrap();
         let mut thrift_schema = to_thrift(&expected_schema).unwrap();
         // Change all of None to Some(0)
-        for mut elem in &mut thrift_schema[..] {
-            if elem.num_children == None {
+        for elem in &mut thrift_schema[..] {
+            if elem.num_children.is_none() {
                 elem.num_children = Some(0);
             }
         }
@@ -2086,4 +2156,16 @@ mod tests {
         let result_schema = from_thrift(&thrift_schema).unwrap();
         assert_eq!(result_schema, Arc::new(expected_schema));
     }
+
+    #[test]
+    fn test_schema_from_thrift_group_has_no_child() {
+        let message_type = "message schema {}";
+
+        let expected_schema = parse_message_type(message_type).unwrap();
+        let mut thrift_schema = to_thrift(&expected_schema).unwrap();
+        thrift_schema[0].repetition_type = Some(Repetition::REQUIRED.into());
+
+        let result_schema = from_thrift(&thrift_schema).unwrap();
+        assert_eq!(result_schema, Arc::new(expected_schema));
+    }
 }
diff --git a/parquet/src/schema/visitor.rs b/parquet/src/schema/visitor.rs
index 9d28fa5e8dcd..35fde11f1fbb 100644
--- a/parquet/src/schema/visitor.rs
+++ b/parquet/src/schema/visitor.rs
@@ -49,7 +49,7 @@ pub trait TypeVisitor<R, C> {
     fn visit_list(&mut self, list_type: TypePtr, context: C) -> Result<R> {
         match list_type.as_ref() {
             Type::PrimitiveType { .. } => {
-                panic!("{:?} is a list type and must be a group type", list_type)
+                panic!("{list_type:?} is a list type and must be a group type")
             }
             Type::GroupType {
                 basic_info: _,
@@ -59,17 +59,11 @@ pub trait TypeVisitor<R, C> {
 
                 match list_item.as_ref() {
                     Type::PrimitiveType { .. } => {
-                        if list_item.get_basic_info().repetition() == Repetition::REPEATED
-                        {
-                            self.visit_list_with_item(
-                                list_type.clone(),
-                                list_item.clone(),
-                                context,
-                            )
+                        if list_item.get_basic_info().repetition() == Repetition::REPEATED {
+                            self.visit_list_with_item(list_type.clone(), list_item.clone(), context)
                         } else {
                             Err(General(
-                                "Primitive element type of list must be repeated."
-                                    .to_string(),
+                                "Primitive element type of list must be repeated.".to_string(),
                             ))
                         }
                     }
@@ -87,11 +81,7 @@ pub trait TypeVisitor<R, C> {
                                 context,
                             )
                         } else {
-                            self.visit_list_with_item(
-                                list_type.clone(),
-                                list_item.clone(),
-                                context,
-                            )
+                            self.visit_list_with_item(list_type.clone(), list_item.clone(), context)
                         }
                     }
                 }
@@ -176,11 +166,7 @@ mod tests {
             Ok(true)
         }
 
-        fn visit_map(
-            &mut self,
-            _map_type: TypePtr,
-            _context: TestVisitorContext,
-        ) -> Result<bool> {
+        fn visit_map(&mut self, _map_type: TypePtr, _context: TestVisitorContext) -> Result<bool> {
             unimplemented!()
         }
 
diff --git a/parquet/src/thrift.rs b/parquet/src/thrift.rs
new file mode 100644
index 000000000000..ad6c3f688002
--- /dev/null
+++ b/parquet/src/thrift.rs
@@ -0,0 +1,281 @@
+// 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.
+
+//! Custom thrift definitions
+
+use thrift::protocol::{
+    TFieldIdentifier, TInputProtocol, TListIdentifier, TMapIdentifier, TMessageIdentifier,
+    TOutputProtocol, TSetIdentifier, TStructIdentifier, TType,
+};
+
+/// Reads and writes the struct to Thrift protocols.
+///
+/// Unlike [`thrift::protocol::TSerializable`] this uses generics instead of trait objects
+pub trait TSerializable: Sized {
+    fn read_from_in_protocol<T: TInputProtocol>(i_prot: &mut T) -> thrift::Result<Self>;
+    fn write_to_out_protocol<T: TOutputProtocol>(&self, o_prot: &mut T) -> thrift::Result<()>;
+}
+
+/// A more performant implementation of [`TCompactInputProtocol`] that reads a slice
+///
+/// [`TCompactInputProtocol`]: thrift::protocol::TCompactInputProtocol
+pub(crate) struct TCompactSliceInputProtocol<'a> {
+    buf: &'a [u8],
+    // Identifier of the last field deserialized for a struct.
+    last_read_field_id: i16,
+    // Stack of the last read field ids (a new entry is added each time a nested struct is read).
+    read_field_id_stack: Vec<i16>,
+    // Boolean value for a field.
+    // Saved because boolean fields and their value are encoded in a single byte,
+    // and reading the field only occurs after the field id is read.
+    pending_read_bool_value: Option<bool>,
+}
+
+impl<'a> TCompactSliceInputProtocol<'a> {
+    pub fn new(buf: &'a [u8]) -> Self {
+        Self {
+            buf,
+            last_read_field_id: 0,
+            read_field_id_stack: Vec::with_capacity(16),
+            pending_read_bool_value: None,
+        }
+    }
+
+    pub fn as_slice(&self) -> &'a [u8] {
+        self.buf
+    }
+
+    fn read_vlq(&mut self) -> thrift::Result<u64> {
+        let mut in_progress = 0;
+        let mut shift = 0;
+        loop {
+            let byte = self.read_byte()?;
+            in_progress |= ((byte & 0x7F) as u64) << shift;
+            shift += 7;
+            if byte & 0x80 == 0 {
+                return Ok(in_progress);
+            }
+        }
+    }
+
+    fn read_zig_zag(&mut self) -> thrift::Result<i64> {
+        let val = self.read_vlq()?;
+        Ok((val >> 1) as i64 ^ -((val & 1) as i64))
+    }
+
+    fn read_list_set_begin(&mut self) -> thrift::Result<(TType, i32)> {
+        let header = self.read_byte()?;
+        let element_type = collection_u8_to_type(header & 0x0F)?;
+
+        let possible_element_count = (header & 0xF0) >> 4;
+        let element_count = if possible_element_count != 15 {
+            // high bits set high if count and type encoded separately
+            possible_element_count as i32
+        } else {
+            self.read_vlq()? as _
+        };
+
+        Ok((element_type, element_count))
+    }
+}
+
+impl<'a> TInputProtocol for TCompactSliceInputProtocol<'a> {
+    fn read_message_begin(&mut self) -> thrift::Result<TMessageIdentifier> {
+        unimplemented!()
+    }
+
+    fn read_message_end(&mut self) -> thrift::Result<()> {
+        unimplemented!()
+    }
+
+    fn read_struct_begin(&mut self) -> thrift::Result<Option<TStructIdentifier>> {
+        self.read_field_id_stack.push(self.last_read_field_id);
+        self.last_read_field_id = 0;
+        Ok(None)
+    }
+
+    fn read_struct_end(&mut self) -> thrift::Result<()> {
+        self.last_read_field_id = self
+            .read_field_id_stack
+            .pop()
+            .expect("should have previous field ids");
+        Ok(())
+    }
+
+    fn read_field_begin(&mut self) -> thrift::Result<TFieldIdentifier> {
+        // we can read at least one byte, which is:
+        // - the type
+        // - the field delta and the type
+        let field_type = self.read_byte()?;
+        let field_delta = (field_type & 0xF0) >> 4;
+        let field_type = match field_type & 0x0F {
+            0x01 => {
+                self.pending_read_bool_value = Some(true);
+                Ok(TType::Bool)
+            }
+            0x02 => {
+                self.pending_read_bool_value = Some(false);
+                Ok(TType::Bool)
+            }
+            ttu8 => u8_to_type(ttu8),
+        }?;
+
+        match field_type {
+            TType::Stop => Ok(
+                TFieldIdentifier::new::<Option<String>, String, Option<i16>>(
+                    None,
+                    TType::Stop,
+                    None,
+                ),
+            ),
+            _ => {
+                if field_delta != 0 {
+                    self.last_read_field_id += field_delta as i16;
+                } else {
+                    self.last_read_field_id = self.read_i16()?;
+                };
+
+                Ok(TFieldIdentifier {
+                    name: None,
+                    field_type,
+                    id: Some(self.last_read_field_id),
+                })
+            }
+        }
+    }
+
+    fn read_field_end(&mut self) -> thrift::Result<()> {
+        Ok(())
+    }
+
+    fn read_bool(&mut self) -> thrift::Result<bool> {
+        match self.pending_read_bool_value.take() {
+            Some(b) => Ok(b),
+            None => {
+                let b = self.read_byte()?;
+                match b {
+                    0x01 => Ok(true),
+                    0x02 => Ok(false),
+                    unkn => Err(thrift::Error::Protocol(thrift::ProtocolError {
+                        kind: thrift::ProtocolErrorKind::InvalidData,
+                        message: format!("cannot convert {} into bool", unkn),
+                    })),
+                }
+            }
+        }
+    }
+
+    fn read_bytes(&mut self) -> thrift::Result<Vec<u8>> {
+        let len = self.read_vlq()? as usize;
+        let ret = self.buf.get(..len).ok_or_else(eof_error)?.to_vec();
+        self.buf = &self.buf[len..];
+        Ok(ret)
+    }
+
+    fn read_i8(&mut self) -> thrift::Result<i8> {
+        Ok(self.read_byte()? as _)
+    }
+
+    fn read_i16(&mut self) -> thrift::Result<i16> {
+        Ok(self.read_zig_zag()? as _)
+    }
+
+    fn read_i32(&mut self) -> thrift::Result<i32> {
+        Ok(self.read_zig_zag()? as _)
+    }
+
+    fn read_i64(&mut self) -> thrift::Result<i64> {
+        self.read_zig_zag()
+    }
+
+    fn read_double(&mut self) -> thrift::Result<f64> {
+        let slice = (self.buf[..8]).try_into().unwrap();
+        self.buf = &self.buf[8..];
+        Ok(f64::from_le_bytes(slice))
+    }
+
+    fn read_string(&mut self) -> thrift::Result<String> {
+        let bytes = self.read_bytes()?;
+        String::from_utf8(bytes).map_err(From::from)
+    }
+
+    fn read_list_begin(&mut self) -> thrift::Result<TListIdentifier> {
+        let (element_type, element_count) = self.read_list_set_begin()?;
+        Ok(TListIdentifier::new(element_type, element_count))
+    }
+
+    fn read_list_end(&mut self) -> thrift::Result<()> {
+        Ok(())
+    }
+
+    fn read_set_begin(&mut self) -> thrift::Result<TSetIdentifier> {
+        unimplemented!()
+    }
+
+    fn read_set_end(&mut self) -> thrift::Result<()> {
+        unimplemented!()
+    }
+
+    fn read_map_begin(&mut self) -> thrift::Result<TMapIdentifier> {
+        unimplemented!()
+    }
+
+    fn read_map_end(&mut self) -> thrift::Result<()> {
+        Ok(())
+    }
+
+    #[inline]
+    fn read_byte(&mut self) -> thrift::Result<u8> {
+        let ret = *self.buf.first().ok_or_else(eof_error)?;
+        self.buf = &self.buf[1..];
+        Ok(ret)
+    }
+}
+
+fn collection_u8_to_type(b: u8) -> thrift::Result<TType> {
+    match b {
+        0x01 => Ok(TType::Bool),
+        o => u8_to_type(o),
+    }
+}
+
+fn u8_to_type(b: u8) -> thrift::Result<TType> {
+    match b {
+        0x00 => Ok(TType::Stop),
+        0x03 => Ok(TType::I08), // equivalent to TType::Byte
+        0x04 => Ok(TType::I16),
+        0x05 => Ok(TType::I32),
+        0x06 => Ok(TType::I64),
+        0x07 => Ok(TType::Double),
+        0x08 => Ok(TType::String),
+        0x09 => Ok(TType::List),
+        0x0A => Ok(TType::Set),
+        0x0B => Ok(TType::Map),
+        0x0C => Ok(TType::Struct),
+        unkn => Err(thrift::Error::Protocol(thrift::ProtocolError {
+            kind: thrift::ProtocolErrorKind::InvalidData,
+            message: format!("cannot convert {} into TType", unkn),
+        })),
+    }
+}
+
+fn eof_error() -> thrift::Error {
+    thrift::Error::Transport(thrift::TransportError {
+        kind: thrift::TransportErrorKind::EndOfFile,
+        message: "Unexpected EOF".to_string(),
+    })
+}
diff --git a/parquet/src/util/bit_pack.rs b/parquet/src/util/bit_pack.rs
index 8cea20de2539..94ab9578b991 100644
--- a/parquet/src/util/bit_pack.rs
+++ b/parquet/src/util/bit_pack.rs
@@ -106,7 +106,7 @@ mod tests {
             let mut output = [0; 8];
             unpack8(&input, &mut output, i);
             for (idx, out) in output.iter().enumerate() {
-                assert_eq!(out.trailing_ones() as usize, i, "out[{}] = {}", idx, out);
+                assert_eq!(out.trailing_ones() as usize, i, "out[{idx}] = {out}");
             }
         }
 
@@ -114,7 +114,7 @@ mod tests {
             let mut output = [0; 16];
             unpack16(&input, &mut output, i);
             for (idx, out) in output.iter().enumerate() {
-                assert_eq!(out.trailing_ones() as usize, i, "out[{}] = {}", idx, out);
+                assert_eq!(out.trailing_ones() as usize, i, "out[{idx}] = {out}");
             }
         }
 
@@ -122,7 +122,7 @@ mod tests {
             let mut output = [0; 32];
             unpack32(&input, &mut output, i);
             for (idx, out) in output.iter().enumerate() {
-                assert_eq!(out.trailing_ones() as usize, i, "out[{}] = {}", idx, out);
+                assert_eq!(out.trailing_ones() as usize, i, "out[{idx}] = {out}");
             }
         }
 
@@ -130,7 +130,7 @@ mod tests {
             let mut output = [0; 64];
             unpack64(&input, &mut output, i);
             for (idx, out) in output.iter().enumerate() {
-                assert_eq!(out.trailing_ones() as usize, i, "out[{}] = {}", idx, out);
+                assert_eq!(out.trailing_ones() as usize, i, "out[{idx}] = {out}");
             }
         }
     }
diff --git a/parquet/src/util/bit_util.rs b/parquet/src/util/bit_util.rs
index 5d76a8dbf47d..b1dd23574a19 100644
--- a/parquet/src/util/bit_util.rs
+++ b/parquet/src/util/bit_util.rs
@@ -17,37 +17,35 @@
 
 use std::{cmp, mem::size_of};
 
-use crate::data_type::AsBytes;
+use bytes::Bytes;
+
+use crate::data_type::{AsBytes, ByteArray, FixedLenByteArray, Int96};
+use crate::errors::{ParquetError, Result};
 use crate::util::bit_pack::{unpack16, unpack32, unpack64, unpack8};
-use crate::util::memory::ByteBufferPtr;
 
 #[inline]
-pub fn from_ne_slice<T: FromBytes>(bs: &[u8]) -> T {
-    let mut b = T::Buffer::default();
-    {
-        let b = b.as_mut();
-        let bs = &bs[..b.len()];
-        b.copy_from_slice(bs);
-    }
-    T::from_ne_bytes(b)
+pub fn from_le_slice<T: FromBytes>(bs: &[u8]) -> T {
+    // TODO: propagate the error (#3577)
+    T::try_from_le_slice(bs).unwrap()
 }
 
 #[inline]
-pub fn from_le_slice<T: FromBytes>(bs: &[u8]) -> T {
-    let mut b = T::Buffer::default();
-    {
-        let b = b.as_mut();
-        let bs = &bs[..b.len()];
-        b.copy_from_slice(bs);
+fn array_from_slice<const N: usize>(bs: &[u8]) -> Result<[u8; N]> {
+    // Need to slice as may be called with zero-padded values
+    match bs.get(..N) {
+        Some(b) => Ok(b.try_into().unwrap()),
+        None => Err(general_err!(
+            "error converting value, expected {} bytes got {}",
+            N,
+            bs.len()
+        )),
     }
-    T::from_le_bytes(b)
 }
 
 pub trait FromBytes: Sized {
     type Buffer: AsMut<[u8]> + Default;
+    fn try_from_le_slice(b: &[u8]) -> Result<Self>;
     fn from_le_bytes(bs: Self::Buffer) -> Self;
-    fn from_be_bytes(bs: Self::Buffer) -> Self;
-    fn from_ne_bytes(bs: Self::Buffer) -> Self;
 }
 
 macro_rules! from_le_bytes {
@@ -55,38 +53,69 @@ macro_rules! from_le_bytes {
         $(
         impl FromBytes for $ty {
             type Buffer = [u8; size_of::<Self>()];
+            fn try_from_le_slice(b: &[u8]) -> Result<Self> {
+                Ok(Self::from_le_bytes(array_from_slice(b)?))
+            }
             fn from_le_bytes(bs: Self::Buffer) -> Self {
                 <$ty>::from_le_bytes(bs)
             }
-            fn from_be_bytes(bs: Self::Buffer) -> Self {
-                <$ty>::from_be_bytes(bs)
-            }
-            fn from_ne_bytes(bs: Self::Buffer) -> Self {
-                <$ty>::from_ne_bytes(bs)
-            }
         }
         )*
     };
 }
 
+from_le_bytes! { u8, u16, u32, u64, i8, i16, i32, i64, f32, f64 }
+
 impl FromBytes for bool {
     type Buffer = [u8; 1];
+
+    fn try_from_le_slice(b: &[u8]) -> Result<Self> {
+        Ok(Self::from_le_bytes(array_from_slice(b)?))
+    }
     fn from_le_bytes(bs: Self::Buffer) -> Self {
-        Self::from_ne_bytes(bs)
+        bs[0] != 0
     }
-    fn from_be_bytes(bs: Self::Buffer) -> Self {
-        Self::from_ne_bytes(bs)
+}
+
+impl FromBytes for Int96 {
+    type Buffer = [u8; 12];
+
+    fn try_from_le_slice(b: &[u8]) -> Result<Self> {
+        Ok(Self::from_le_bytes(array_from_slice(b)?))
     }
-    fn from_ne_bytes(bs: Self::Buffer) -> Self {
-        match bs[0] {
-            0 => false,
-            1 => true,
-            _ => panic!("Invalid byte when reading bool"),
-        }
+
+    fn from_le_bytes(bs: Self::Buffer) -> Self {
+        let mut i = Int96::new();
+        i.set_data(
+            from_le_slice(&bs[0..4]),
+            from_le_slice(&bs[4..8]),
+            from_le_slice(&bs[8..12]),
+        );
+        i
     }
 }
 
-from_le_bytes! { u8, u16, u32, u64, i8, i16, i32, i64, f32, f64 }
+impl FromBytes for ByteArray {
+    type Buffer = Vec<u8>;
+
+    fn try_from_le_slice(b: &[u8]) -> Result<Self> {
+        Ok(b.to_vec().into())
+    }
+    fn from_le_bytes(bs: Self::Buffer) -> Self {
+        bs.into()
+    }
+}
+
+impl FromBytes for FixedLenByteArray {
+    type Buffer = Vec<u8>;
+
+    fn try_from_le_slice(b: &[u8]) -> Result<Self> {
+        Ok(b.to_vec().into())
+    }
+    fn from_le_bytes(bs: Self::Buffer) -> Self {
+        bs.into()
+    }
+}
 
 /// Reads `size` of bytes from `src`, and reinterprets them as type `ty`, in
 /// little-endian order.
@@ -98,7 +127,7 @@ where
     assert!(size <= src.len());
     let mut buffer = <T as FromBytes>::Buffer::default();
     buffer.as_mut()[..size].copy_from_slice(&src[..size]);
-    <T>::from_ne_bytes(buffer)
+    <T>::from_le_bytes(buffer)
 }
 
 /// Returns the ceil of value/divisor.
@@ -312,50 +341,43 @@ impl BitWriter {
 pub const MAX_VLQ_BYTE_LEN: usize = 10;
 
 pub struct BitReader {
-    // The byte buffer to read from, passed in by client
-    buffer: ByteBufferPtr,
+    /// The byte buffer to read from, passed in by client
+    buffer: Bytes,
 
-    // Bytes are memcpy'd from `buffer` and values are read from this variable.
-    // This is faster than reading values byte by byte directly from `buffer`
+    /// Bytes are memcpy'd from `buffer` and values are read from this variable.
+    /// This is faster than reading values byte by byte directly from `buffer`
+    ///
+    /// This is only populated when `self.bit_offset != 0`
     buffered_values: u64,
 
-    //
-    // End                                         Start
-    // |............|B|B|B|B|B|B|B|B|..............|
-    //                   ^          ^
-    //                 bit_offset   byte_offset
-    //
-    // Current byte offset in `buffer`
+    ///
+    /// End                                         Start
+    /// |............|B|B|B|B|B|B|B|B|..............|
+    ///                   ^          ^
+    ///                 bit_offset   byte_offset
+    ///
+    /// Current byte offset in `buffer`
     byte_offset: usize,
 
-    // Current bit offset in `buffered_values`
+    /// Current bit offset in `buffered_values`
     bit_offset: usize,
-
-    // Total number of bytes in `buffer`
-    total_bytes: usize,
 }
 
 /// Utility class to read bit/byte stream. This class can read bits or bytes that are
 /// either byte aligned or not.
 impl BitReader {
-    pub fn new(buffer: ByteBufferPtr) -> Self {
-        let total_bytes = buffer.len();
-        let num_bytes = cmp::min(8, total_bytes);
-        let buffered_values = read_num_bytes::<u64>(num_bytes, buffer.as_ref());
+    pub fn new(buffer: Bytes) -> Self {
         BitReader {
             buffer,
-            buffered_values,
+            buffered_values: 0,
             byte_offset: 0,
             bit_offset: 0,
-            total_bytes,
         }
     }
 
-    pub fn reset(&mut self, buffer: ByteBufferPtr) {
+    pub fn reset(&mut self, buffer: Bytes) {
         self.buffer = buffer;
-        self.total_bytes = self.buffer.len();
-        let num_bytes = cmp::min(8, self.total_bytes);
-        self.buffered_values = read_num_bytes::<u64>(num_bytes, self.buffer.as_ref());
+        self.buffered_values = 0;
         self.byte_offset = 0;
         self.bit_offset = 0;
     }
@@ -373,10 +395,16 @@ impl BitReader {
         assert!(num_bits <= 64);
         assert!(num_bits <= size_of::<T>() * 8);
 
-        if self.byte_offset * 8 + self.bit_offset + num_bits > self.total_bytes * 8 {
+        if self.byte_offset * 8 + self.bit_offset + num_bits > self.buffer.len() * 8 {
             return None;
         }
 
+        // If buffer is not byte aligned, `self.buffered_values` will
+        // have already been populated
+        if self.bit_offset == 0 {
+            self.load_buffered_values()
+        }
+
         let mut v = trailing_bits(self.buffered_values, self.bit_offset + num_bits)
             >> self.bit_offset;
         self.bit_offset += num_bits;
@@ -385,35 +413,18 @@ impl BitReader {
             self.byte_offset += 8;
             self.bit_offset -= 64;
 
-            self.reload_buffer_values();
-            v |= trailing_bits(self.buffered_values, self.bit_offset)
-                .wrapping_shl((num_bits - self.bit_offset) as u32);
-        }
+            // If the new bit_offset is not 0, we need to read the next 64-bit chunk
+            // to buffered_values and update `v`
+            if self.bit_offset != 0 {
+                self.load_buffered_values();
 
-        // TODO: better to avoid copying here
-        Some(from_ne_slice(v.as_bytes()))
-    }
-
-    /// Skip one value of size `num_bits`.
-    ///
-    /// Returns `false` if there are no more values to skip, `true` otherwise.
-    pub fn skip_value(&mut self, num_bits: usize) -> bool {
-        assert!(num_bits <= 64);
-
-        if self.byte_offset * 8 + self.bit_offset + num_bits > self.total_bytes * 8 {
-            return false;
-        }
-
-        self.bit_offset += num_bits;
-
-        if self.bit_offset >= 64 {
-            self.byte_offset += 8;
-            self.bit_offset -= 64;
-
-            self.reload_buffer_values();
+                v |= trailing_bits(self.buffered_values, self.bit_offset)
+                    .wrapping_shl((num_bits - self.bit_offset) as u32);
+            }
         }
 
-        true
+        // TODO: better to avoid copying here
+        Some(from_le_slice(v.as_bytes()))
     }
 
     /// Read multiple values from their packed representation where each element is represented
@@ -429,7 +440,7 @@ impl BitReader {
 
         let mut values_to_read = batch.len();
         let needed_bits = num_bits * values_to_read;
-        let remaining_bits = (self.total_bytes - self.byte_offset) * 8 - self.bit_offset;
+        let remaining_bits = (self.buffer.len() - self.byte_offset) * 8 - self.bit_offset;
         if remaining_bits < needed_bits {
             values_to_read = remaining_bits / num_bits;
         }
@@ -446,8 +457,6 @@ impl BitReader {
             }
         }
 
-        let in_buf = self.buffer.data();
-
         // Read directly into output buffer
         match size_of::<T>() {
             1 => {
@@ -455,7 +464,7 @@ impl BitReader {
                 let out = unsafe { std::slice::from_raw_parts_mut(ptr, batch.len()) };
                 while values_to_read - i >= 8 {
                     let out_slice = (&mut out[i..i + 8]).try_into().unwrap();
-                    unpack8(&in_buf[self.byte_offset..], out_slice, num_bits);
+                    unpack8(&self.buffer[self.byte_offset..], out_slice, num_bits);
                     self.byte_offset += num_bits;
                     i += 8;
                 }
@@ -465,7 +474,7 @@ impl BitReader {
                 let out = unsafe { std::slice::from_raw_parts_mut(ptr, batch.len()) };
                 while values_to_read - i >= 16 {
                     let out_slice = (&mut out[i..i + 16]).try_into().unwrap();
-                    unpack16(&in_buf[self.byte_offset..], out_slice, num_bits);
+                    unpack16(&self.buffer[self.byte_offset..], out_slice, num_bits);
                     self.byte_offset += 2 * num_bits;
                     i += 16;
                 }
@@ -475,7 +484,7 @@ impl BitReader {
                 let out = unsafe { std::slice::from_raw_parts_mut(ptr, batch.len()) };
                 while values_to_read - i >= 32 {
                     let out_slice = (&mut out[i..i + 32]).try_into().unwrap();
-                    unpack32(&in_buf[self.byte_offset..], out_slice, num_bits);
+                    unpack32(&self.buffer[self.byte_offset..], out_slice, num_bits);
                     self.byte_offset += 4 * num_bits;
                     i += 32;
                 }
@@ -485,7 +494,7 @@ impl BitReader {
                 let out = unsafe { std::slice::from_raw_parts_mut(ptr, batch.len()) };
                 while values_to_read - i >= 64 {
                     let out_slice = (&mut out[i..i + 64]).try_into().unwrap();
-                    unpack64(&in_buf[self.byte_offset..], out_slice, num_bits);
+                    unpack64(&self.buffer[self.byte_offset..], out_slice, num_bits);
                     self.byte_offset += 8 * num_bits;
                     i += 64;
                 }
@@ -496,7 +505,7 @@ impl BitReader {
         // Try to read smaller batches if possible
         if size_of::<T>() > 4 && values_to_read - i >= 32 && num_bits <= 32 {
             let mut out_buf = [0_u32; 32];
-            unpack32(&in_buf[self.byte_offset..], &mut out_buf, num_bits);
+            unpack32(&self.buffer[self.byte_offset..], &mut out_buf, num_bits);
             self.byte_offset += 4 * num_bits;
 
             for out in out_buf {
@@ -510,7 +519,7 @@ impl BitReader {
 
         if size_of::<T>() > 2 && values_to_read - i >= 16 && num_bits <= 16 {
             let mut out_buf = [0_u16; 16];
-            unpack16(&in_buf[self.byte_offset..], &mut out_buf, num_bits);
+            unpack16(&self.buffer[self.byte_offset..], &mut out_buf, num_bits);
             self.byte_offset += 2 * num_bits;
 
             for out in out_buf {
@@ -524,7 +533,7 @@ impl BitReader {
 
         if size_of::<T>() > 1 && values_to_read - i >= 8 && num_bits <= 8 {
             let mut out_buf = [0_u8; 8];
-            unpack8(&in_buf[self.byte_offset..], &mut out_buf, num_bits);
+            unpack8(&self.buffer[self.byte_offset..], &mut out_buf, num_bits);
             self.byte_offset += num_bits;
 
             for out in out_buf {
@@ -536,8 +545,6 @@ impl BitReader {
             }
         }
 
-        self.reload_buffer_values();
-
         // Read any trailing values
         while i < values_to_read {
             let value = self
@@ -556,37 +563,25 @@ impl BitReader {
     pub fn skip(&mut self, num_values: usize, num_bits: usize) -> usize {
         assert!(num_bits <= 64);
 
-        let mut num_values = num_values;
         let needed_bits = num_bits * num_values;
-        let remaining_bits = (self.total_bytes - self.byte_offset) * 8 - self.bit_offset;
-        if remaining_bits < needed_bits {
-            num_values = remaining_bits / num_bits;
-        }
-
-        let mut values_skipped = 0;
+        let remaining_bits = (self.buffer.len() - self.byte_offset) * 8 - self.bit_offset;
 
-        // First align bit offset to byte offset
-        if self.bit_offset != 0 {
-            while values_skipped < num_values && self.bit_offset != 0 {
-                self.skip_value(num_bits);
-                values_skipped += 1;
-            }
-        }
+        let values_to_read = match remaining_bits < needed_bits {
+            true => remaining_bits / num_bits,
+            false => num_values,
+        };
 
-        while num_values - values_skipped >= 32 {
-            self.byte_offset += 4 * num_bits;
-            values_skipped += 32;
-        }
+        let end_bit_offset =
+            self.byte_offset * 8 + values_to_read * num_bits + self.bit_offset;
 
-        assert!(num_values - values_skipped < 32);
+        self.byte_offset = end_bit_offset / 8;
+        self.bit_offset = end_bit_offset % 8;
 
-        self.reload_buffer_values();
-        while values_skipped < num_values {
-            self.skip_value(num_bits);
-            values_skipped += 1;
+        if self.bit_offset != 0 {
+            self.load_buffered_values()
         }
 
-        num_values
+        values_to_read
     }
 
     /// Reads up to `num_bytes` to `buf` returning the number of bytes read
@@ -596,15 +591,14 @@ impl BitReader {
         num_bytes: usize,
     ) -> usize {
         // Align to byte offset
-        self.byte_offset += ceil(self.bit_offset as i64, 8) as usize;
+        self.byte_offset = self.get_byte_offset();
         self.bit_offset = 0;
 
-        let src = &self.buffer.data()[self.byte_offset..];
+        let src = &self.buffer[self.byte_offset..];
         let to_read = num_bytes.min(src.len());
         buf.extend_from_slice(&src[..to_read]);
 
         self.byte_offset += to_read;
-        self.reload_buffer_values();
 
         to_read
     }
@@ -617,19 +611,17 @@ impl BitReader {
     /// Returns `Some` if there's enough bytes left to form a value of `T`.
     /// Otherwise `None`.
     pub fn get_aligned<T: FromBytes>(&mut self, num_bytes: usize) -> Option<T> {
-        let bytes_read = ceil(self.bit_offset, 8);
-        if self.byte_offset + bytes_read + num_bytes > self.total_bytes {
+        self.byte_offset = self.get_byte_offset();
+        self.bit_offset = 0;
+
+        if self.byte_offset + num_bytes > self.buffer.len() {
             return None;
         }
 
         // Advance byte_offset to next unread byte and read num_bytes
-        self.byte_offset += bytes_read;
-        let v = read_num_bytes::<T>(num_bytes, &self.buffer.data()[self.byte_offset..]);
+        let v = read_num_bytes::<T>(num_bytes, &self.buffer[self.byte_offset..]);
         self.byte_offset += num_bytes;
 
-        // Reset buffered_values
-        self.bit_offset = 0;
-        self.reload_buffer_values();
         Some(v)
     }
 
@@ -645,8 +637,7 @@ impl BitReader {
             shift += 7;
             assert!(
                 shift <= MAX_VLQ_BYTE_LEN * 7,
-                "Num of bytes exceed MAX_VLQ_BYTE_LEN ({})",
-                MAX_VLQ_BYTE_LEN
+                "Num of bytes exceed MAX_VLQ_BYTE_LEN ({MAX_VLQ_BYTE_LEN})"
             );
             if byte & 0x80 == 0 {
                 return Some(v);
@@ -672,17 +663,22 @@ impl BitReader {
         })
     }
 
-    fn reload_buffer_values(&mut self) {
-        let bytes_to_read = cmp::min(self.total_bytes - self.byte_offset, 8);
+    /// Loads up to the the next 8 bytes from `self.buffer` at `self.byte_offset`
+    /// into `self.buffered_values`.
+    ///
+    /// Reads fewer than 8 bytes if there are fewer than 8 bytes left
+    #[inline]
+    fn load_buffered_values(&mut self) {
+        let bytes_to_read = cmp::min(self.buffer.len() - self.byte_offset, 8);
         self.buffered_values =
-            read_num_bytes::<u64>(bytes_to_read, &self.buffer.data()[self.byte_offset..]);
+            read_num_bytes::<u64>(bytes_to_read, &self.buffer[self.byte_offset..]);
     }
 }
 
 impl From<Vec<u8>> for BitReader {
     #[inline]
     fn from(buffer: Vec<u8>) -> Self {
-        BitReader::new(ByteBufferPtr::new(buffer))
+        BitReader::new(buffer.into())
     }
 }
 
@@ -734,26 +730,6 @@ mod tests {
         assert_eq!(bit_reader.get_value::<i32>(4), Some(3));
     }
 
-    #[test]
-    fn test_bit_reader_skip_value() {
-        let buffer = vec![255, 0];
-        let mut bit_reader = BitReader::from(buffer);
-        let skipped = bit_reader.skip_value(1);
-        assert!(skipped);
-        assert_eq!(bit_reader.get_value::<i32>(1), Some(1));
-        let skipped = bit_reader.skip_value(2);
-        assert!(skipped);
-        assert_eq!(bit_reader.get_value::<i32>(2), Some(3));
-        let skipped = bit_reader.skip_value(1);
-        assert!(skipped);
-        assert_eq!(bit_reader.get_value::<i32>(4), Some(1));
-        let skipped = bit_reader.skip_value(1);
-        assert!(skipped);
-        assert_eq!(bit_reader.get_value::<i32>(4), Some(0));
-        let skipped = bit_reader.skip_value(1);
-        assert!(!skipped);
-    }
-
     #[test]
     fn test_bit_reader_skip() {
         let buffer = vec![255, 0];
@@ -786,8 +762,7 @@ mod tests {
         let buffer = vec![10, 0, 0, 0, 20, 0, 30, 0, 0, 0, 40, 0];
         let mut bit_reader = BitReader::from(buffer);
         assert_eq!(bit_reader.get_value::<i64>(32), Some(10));
-        let skipped = bit_reader.skip_value(16);
-        assert!(skipped);
+        assert_eq!(bit_reader.skip(1, 16), 1);
         assert_eq!(bit_reader.get_value::<i64>(32), Some(30));
         assert_eq!(bit_reader.get_value::<i64>(16), Some(40));
     }
@@ -795,12 +770,12 @@ mod tests {
     #[test]
     fn test_bit_reader_get_aligned() {
         // 01110101 11001011
-        let buffer = ByteBufferPtr::new(vec![0x75, 0xCB]);
-        let mut bit_reader = BitReader::new(buffer.all());
+        let buffer = Bytes::from(vec![0x75, 0xCB]);
+        let mut bit_reader = BitReader::new(buffer.clone());
         assert_eq!(bit_reader.get_value::<i32>(3), Some(5));
         assert_eq!(bit_reader.get_aligned::<i32>(1), Some(203));
         assert_eq!(bit_reader.get_value::<i32>(1), None);
-        bit_reader.reset(buffer.all());
+        bit_reader.reset(buffer.clone());
         assert_eq!(bit_reader.get_aligned::<i32>(3), None);
     }
 
@@ -969,12 +944,12 @@ mod tests {
     fn test_put_value_rand_numbers(total: usize, num_bits: usize) {
         assert!(num_bits < 64);
         let num_bytes = ceil(num_bits, 8);
-        let mut writer = BitWriter::new(num_bytes as usize * total);
+        let mut writer = BitWriter::new(num_bytes * total);
         let values: Vec<u64> = random_numbers::<u64>(total)
             .iter()
             .map(|v| v & ((1 << num_bits) - 1))
             .collect();
-        (0..total).for_each(|i| writer.put_value(values[i] as u64, num_bits));
+        (0..total).for_each(|i| writer.put_value(values[i], num_bits));
 
         let mut reader = BitReader::from(writer.consume());
         (0..total).for_each(|i| {
@@ -1010,7 +985,7 @@ mod tests {
     {
         assert!(num_bits <= 64);
         let num_bytes = ceil(num_bits, 8);
-        let mut writer = BitWriter::new(num_bytes as usize * total);
+        let mut writer = BitWriter::new(num_bytes * total);
 
         let mask = match num_bits {
             64 => u64::MAX,
@@ -1024,9 +999,9 @@ mod tests {
 
         // Generic values used to check against actual values read from `get_batch`.
         let expected_values: Vec<T> =
-            values.iter().map(|v| from_ne_slice(v.as_bytes())).collect();
+            values.iter().map(|v| from_le_slice(v.as_bytes())).collect();
 
-        (0..total).for_each(|i| writer.put_value(values[i] as u64, num_bits));
+        (0..total).for_each(|i| writer.put_value(values[i], num_bits));
 
         let buf = writer.consume();
         let mut reader = BitReader::from(buf);
@@ -1152,7 +1127,7 @@ mod tests {
     #[test]
     fn test_get_batch_zero_extend() {
         let to_read = vec![0xFF; 4];
-        let mut reader = BitReader::new(ByteBufferPtr::new(to_read));
+        let mut reader = BitReader::from(to_read);
 
         // Create a non-zeroed output buffer
         let mut output = [u64::MAX; 32];
diff --git a/parquet/src/util/interner.rs b/parquet/src/util/interner.rs
index e638237e06c5..a59ab8e7a31c 100644
--- a/parquet/src/util/interner.rs
+++ b/parquet/src/util/interner.rs
@@ -88,6 +88,7 @@ impl<S: Storage> Interner<S> {
     }
 
     /// Unwraps the inner storage
+    #[cfg(feature = "arrow")]
     pub fn into_inner(self) -> S {
         self.storage
     }
diff --git a/parquet/src/util/io.rs b/parquet/src/util/io.rs
deleted file mode 100644
index 1fb92063e27c..000000000000
--- a/parquet/src/util/io.rs
+++ /dev/null
@@ -1,267 +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.
-
-use std::{cell::RefCell, cmp, fmt, io::*};
-
-use crate::file::reader::Length;
-
-const DEFAULT_BUF_SIZE: usize = 8 * 1024;
-
-// ----------------------------------------------------------------------
-
-/// TryClone tries to clone the type and should maintain the `Seek` position of the given
-/// instance.
-pub trait TryClone: Sized {
-    /// Clones the type returning a new instance or an error if it's not possible
-    /// to clone it.
-    fn try_clone(&self) -> Result<Self>;
-}
-
-/// ParquetReader is the interface which needs to be fulfilled to be able to parse a
-/// parquet source.
-pub trait ParquetReader: Read + Seek + Length + TryClone {}
-impl<T: Read + Seek + Length + TryClone> ParquetReader for T {}
-
-// Read/Write wrappers for `File`.
-
-/// Position trait returns the current position in the stream.
-/// Should be viewed as a lighter version of `Seek` that does not allow seek operations,
-/// and does not require mutable reference for the current position.
-pub trait Position {
-    /// Returns position in the stream.
-    fn pos(&self) -> u64;
-}
-
-/// Struct that represents a slice of a file data with independent start position and
-/// length. Internally clones provided file handle, wraps with a custom implementation
-/// of BufReader that resets position before any read.
-///
-/// This is workaround and alternative for `file.try_clone()` method. It clones `File`
-/// while preserving independent position, which is not available with `try_clone()`.
-///
-/// Designed after `arrow::io::RandomAccessFile` and `std::io::BufReader`
-pub struct FileSource<R: ParquetReader> {
-    reader: RefCell<R>,
-    start: u64,     // start position in a file
-    end: u64,       // end position in a file
-    buf: Vec<u8>,   // buffer where bytes read in advance are stored
-    buf_pos: usize, // current position of the reader in the buffer
-    buf_cap: usize, // current number of bytes read into the buffer
-}
-
-impl<R: ParquetReader> fmt::Debug for FileSource<R> {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.debug_struct("FileSource")
-            .field("reader", &"OPAQUE")
-            .field("start", &self.start)
-            .field("end", &self.end)
-            .field("buf.len", &self.buf.len())
-            .field("buf_pos", &self.buf_pos)
-            .field("buf_cap", &self.buf_cap)
-            .finish()
-    }
-}
-
-impl<R: ParquetReader> FileSource<R> {
-    /// Creates new file reader with start and length from a file handle
-    pub fn new(fd: &R, start: u64, length: usize) -> Self {
-        let reader = RefCell::new(fd.try_clone().unwrap());
-        Self {
-            reader,
-            start,
-            end: start + length as u64,
-            buf: vec![0_u8; DEFAULT_BUF_SIZE],
-            buf_pos: 0,
-            buf_cap: 0,
-        }
-    }
-
-    fn fill_inner_buf(&mut self) -> Result<&[u8]> {
-        if self.buf_pos >= self.buf_cap {
-            // If we've reached the end of our internal buffer then we need to fetch
-            // some more data from the underlying reader.
-            // Branch using `>=` instead of the more correct `==`
-            // to tell the compiler that the pos..cap slice is always valid.
-            debug_assert!(self.buf_pos == self.buf_cap);
-            let mut reader = self.reader.borrow_mut();
-            reader.seek(SeekFrom::Start(self.start))?; // always seek to start before reading
-            self.buf_cap = reader.read(&mut self.buf)?;
-            self.buf_pos = 0;
-        }
-        Ok(&self.buf[self.buf_pos..self.buf_cap])
-    }
-
-    fn skip_inner_buf(&mut self, buf: &mut [u8]) -> Result<usize> {
-        // discard buffer
-        self.buf_pos = 0;
-        self.buf_cap = 0;
-        // read directly into param buffer
-        let mut reader = self.reader.borrow_mut();
-        reader.seek(SeekFrom::Start(self.start))?; // always seek to start before reading
-        let nread = reader.read(buf)?;
-        self.start += nread as u64;
-        Ok(nread)
-    }
-}
-
-impl<R: ParquetReader> Read for FileSource<R> {
-    fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
-        let bytes_to_read = cmp::min(buf.len(), (self.end - self.start) as usize);
-        let buf = &mut buf[0..bytes_to_read];
-
-        // If we don't have any buffered data and we're doing a massive read
-        // (larger than our internal buffer), bypass our internal buffer
-        // entirely.
-        if self.buf_pos == self.buf_cap && buf.len() >= self.buf.len() {
-            return self.skip_inner_buf(buf);
-        }
-        let nread = {
-            let mut rem = self.fill_inner_buf()?;
-            // copy the data from the inner buffer to the param buffer
-            rem.read(buf)?
-        };
-        // consume from buffer
-        self.buf_pos = cmp::min(self.buf_pos + nread, self.buf_cap);
-
-        self.start += nread as u64;
-        Ok(nread)
-    }
-}
-
-impl<R: ParquetReader> Position for FileSource<R> {
-    fn pos(&self) -> u64 {
-        self.start
-    }
-}
-
-impl<R: ParquetReader> Length for FileSource<R> {
-    fn len(&self) -> u64 {
-        self.end - self.start
-    }
-}
-
-// Position implementation for Cursor to use in various tests.
-impl<'a> Position for Cursor<&'a mut Vec<u8>> {
-    fn pos(&self) -> u64 {
-        self.position()
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    use std::iter;
-
-    use crate::util::test_common::file_util::get_test_file;
-
-    #[test]
-    fn test_io_read_fully() {
-        let mut buf = vec![0; 8];
-        let mut src = FileSource::new(&get_test_file("alltypes_plain.parquet"), 0, 4);
-
-        let bytes_read = src.read(&mut buf[..]).unwrap();
-        assert_eq!(bytes_read, 4);
-        assert_eq!(buf, vec![b'P', b'A', b'R', b'1', 0, 0, 0, 0]);
-    }
-
-    #[test]
-    fn test_io_read_in_chunks() {
-        let mut buf = vec![0; 4];
-        let mut src = FileSource::new(&get_test_file("alltypes_plain.parquet"), 0, 4);
-
-        let bytes_read = src.read(&mut buf[0..2]).unwrap();
-        assert_eq!(bytes_read, 2);
-        let bytes_read = src.read(&mut buf[2..]).unwrap();
-        assert_eq!(bytes_read, 2);
-        assert_eq!(buf, vec![b'P', b'A', b'R', b'1']);
-    }
-
-    #[test]
-    fn test_io_read_pos() {
-        let mut src = FileSource::new(&get_test_file("alltypes_plain.parquet"), 0, 4);
-
-        let _ = src.read(&mut [0; 1]).unwrap();
-        assert_eq!(src.pos(), 1);
-
-        let _ = src.read(&mut [0; 4]).unwrap();
-        assert_eq!(src.pos(), 4);
-    }
-
-    #[test]
-    fn test_io_read_over_limit() {
-        let mut src = FileSource::new(&get_test_file("alltypes_plain.parquet"), 0, 4);
-
-        // Read all bytes from source
-        let _ = src.read(&mut [0; 128]).unwrap();
-        assert_eq!(src.pos(), 4);
-
-        // Try reading again, should return 0 bytes.
-        let bytes_read = src.read(&mut [0; 128]).unwrap();
-        assert_eq!(bytes_read, 0);
-        assert_eq!(src.pos(), 4);
-    }
-
-    #[test]
-    fn test_io_seek_switch() {
-        let mut buf = vec![0; 4];
-        let mut file = get_test_file("alltypes_plain.parquet");
-        let mut src = FileSource::new(&file, 0, 4);
-
-        file.seek(SeekFrom::Start(5_u64))
-            .expect("File seek to a position");
-
-        let bytes_read = src.read(&mut buf[..]).unwrap();
-        assert_eq!(bytes_read, 4);
-        assert_eq!(buf, vec![b'P', b'A', b'R', b'1']);
-    }
-
-    #[test]
-    fn test_io_large_read() {
-        // Generate repeated 'abcdef' pattern and write it into a file
-        let patterned_data: Vec<u8> = iter::repeat(vec![0, 1, 2, 3, 4, 5])
-            .flatten()
-            .take(3 * DEFAULT_BUF_SIZE)
-            .collect();
-
-        let mut file = tempfile::tempfile().unwrap();
-        file.write_all(&patterned_data).unwrap();
-
-        // seek the underlying file to the first 'd'
-        file.seek(SeekFrom::Start(3)).unwrap();
-
-        // create the FileSource reader that starts at pos 1 ('b')
-        let mut chunk = FileSource::new(&file, 1, patterned_data.len() - 1);
-
-        // read the 'b' at pos 1
-        let mut res = vec![0u8; 1];
-        chunk.read_exact(&mut res).unwrap();
-        assert_eq!(res, &[1]);
-
-        // the underlying file is sought to 'e'
-        file.seek(SeekFrom::Start(4)).unwrap();
-
-        // now read large chunk that starts with 'c' (after 'b')
-        let mut res = vec![0u8; 2 * DEFAULT_BUF_SIZE];
-        chunk.read_exact(&mut res).unwrap();
-        assert_eq!(
-            res,
-            &patterned_data[2..2 + 2 * DEFAULT_BUF_SIZE],
-            "read buf and original data are not equal"
-        );
-    }
-}
diff --git a/parquet/src/util/memory.rs b/parquet/src/util/memory.rs
deleted file mode 100644
index 909878a6d538..000000000000
--- a/parquet/src/util/memory.rs
+++ /dev/null
@@ -1,143 +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.
-
-//! Utility methods and structs for working with memory.
-
-use bytes::Bytes;
-use std::{
-    fmt::{Debug, Display, Formatter, Result as FmtResult},
-    ops::Index,
-};
-
-// ----------------------------------------------------------------------
-// Immutable Buffer (BufferPtr) classes
-
-/// An representation of a slice on a reference-counting and read-only byte array.
-/// Sub-slices can be further created from this. The byte array will be released
-/// when all slices are dropped.
-///
-/// TODO: Remove and replace with [`bytes::Bytes`]
-#[derive(Clone, Debug)]
-pub struct ByteBufferPtr {
-    data: Bytes,
-}
-
-impl ByteBufferPtr {
-    /// Creates new buffer from a vector.
-    pub fn new(v: Vec<u8>) -> Self {
-        Self { data: v.into() }
-    }
-
-    /// Returns slice of data in this buffer.
-    #[inline]
-    pub fn data(&self) -> &[u8] {
-        &self.data
-    }
-
-    /// Returns length of this buffer
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.data.len()
-    }
-
-    /// Returns whether this buffer is empty
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.data.is_empty()
-    }
-
-    /// Returns a shallow copy of the buffer.
-    /// Reference counted pointer to the data is copied.
-    pub fn all(&self) -> Self {
-        self.clone()
-    }
-
-    /// Returns a shallow copy of the buffer that starts with `start` position.
-    pub fn start_from(&self, start: usize) -> Self {
-        Self {
-            data: self.data.slice(start..),
-        }
-    }
-
-    /// Returns a shallow copy that is a range slice within this buffer.
-    pub fn range(&self, start: usize, len: usize) -> Self {
-        Self {
-            data: self.data.slice(start..start + len),
-        }
-    }
-}
-
-impl Index<usize> for ByteBufferPtr {
-    type Output = u8;
-
-    fn index(&self, index: usize) -> &u8 {
-        &self.data[index]
-    }
-}
-
-impl Display for ByteBufferPtr {
-    fn fmt(&self, f: &mut Formatter) -> FmtResult {
-        write!(f, "{:?}", self.data)
-    }
-}
-
-impl AsRef<[u8]> for ByteBufferPtr {
-    #[inline]
-    fn as_ref(&self) -> &[u8] {
-        &self.data
-    }
-}
-
-impl From<Vec<u8>> for ByteBufferPtr {
-    fn from(data: Vec<u8>) -> Self {
-        Self { data: data.into() }
-    }
-}
-
-impl From<Bytes> for ByteBufferPtr {
-    fn from(data: Bytes) -> Self {
-        Self { data }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_byte_ptr() {
-        let values = (0..50).collect();
-        let ptr = ByteBufferPtr::new(values);
-        assert_eq!(ptr.len(), 50);
-        assert_eq!(ptr[40], 40);
-
-        let ptr2 = ptr.all();
-        assert_eq!(ptr2.len(), 50);
-        assert_eq!(ptr2[40], 40);
-
-        let ptr3 = ptr.start_from(20);
-        assert_eq!(ptr3.len(), 30);
-        assert_eq!(ptr3[0], 20);
-
-        let ptr4 = ptr3.range(10, 10);
-        assert_eq!(ptr4.len(), 10);
-        assert_eq!(ptr4[0], 30);
-
-        let expected: Vec<u8> = (30..40).collect();
-        assert_eq!(ptr4.as_ref(), expected.as_slice());
-    }
-}
diff --git a/parquet/src/util/mod.rs b/parquet/src/util/mod.rs
index d8ad739dbdb4..dfa1285afcf2 100644
--- a/parquet/src/util/mod.rs
+++ b/parquet/src/util/mod.rs
@@ -15,13 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
-pub mod io;
-pub mod memory;
 #[macro_use]
 pub mod bit_util;
 mod bit_pack;
 pub(crate) mod interner;
-pub(crate) mod page_util;
 #[cfg(any(test, feature = "test_common"))]
 pub(crate) mod test_common;
 
diff --git a/parquet/src/util/page_util.rs b/parquet/src/util/page_util.rs
deleted file mode 100644
index 7716b71167fb..000000000000
--- a/parquet/src/util/page_util.rs
+++ /dev/null
@@ -1,96 +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.
-
-use std::collections::VecDeque;
-use std::io::Read;
-use std::sync::Arc;
-use crate::errors::Result;
-use parquet_format::PageLocation;
-use crate::file::reader::ChunkReader;
-
-/// Use column chunk's offset index to get the `page_num` page row count.
-pub(crate) fn calculate_row_count(indexes: &[PageLocation], page_num: usize, total_row_count: i64) -> Result<usize> {
-    if page_num == indexes.len() - 1 {
-        // first_row_index start with 0, so no need to plus one additional.
-        Ok((total_row_count - indexes[page_num].first_row_index) as usize)
-    } else {
-        Ok((indexes[page_num + 1].first_row_index - indexes[page_num].first_row_index) as usize)
-    }
-}
-
-/// Use column chunk's offset index to get each page serially readable slice
-/// and a flag indicates whether having one dictionary page in this column chunk.
-pub(crate) fn get_pages_readable_slices<T: Read + Send, R: ChunkReader<T=T>>(col_chunk_offset_index: &[PageLocation], col_start: u64, chunk_reader: Arc<R>) -> Result<(VecDeque<T>, bool)> {
-    let first_data_page_offset = col_chunk_offset_index[0].offset as u64;
-    let has_dictionary_page = first_data_page_offset != col_start;
-    let mut page_readers = VecDeque::with_capacity(col_chunk_offset_index.len() + 1);
-
-    if has_dictionary_page {
-        let length = (first_data_page_offset - col_start) as usize;
-        let reader: T = chunk_reader.get_read(col_start, length)?;
-        page_readers.push_back(reader);
-    }
-
-    for index in col_chunk_offset_index {
-        let start = index.offset as u64;
-        let length = index.compressed_page_size as usize;
-        let reader: T = chunk_reader.get_read(start, length)?;
-        page_readers.push_back(reader)
-    }
-    Ok((page_readers, has_dictionary_page))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    /**
-     parquet-tools meta  ./test.parquet got:
-
-                file schema: test_schema
-        --------------------------------------------------------------------------------
-        leaf:        REQUIRED INT64 R:0 D:
-
-            row group 1: RC:256 TS:2216 OFFSET:4
-        --------------------------------------------------------------------------------
-        leaf:         INT64 UNCOMPRESSED DO:0 FPO:4 SZ:2216/2216/1.00 VC:256 ENC:PLAIN,RLE ST:[min: 0, max: 255, num_nulls not defined
-
-    parquet-tools column-index -c leaf ./test.parquet got:
-
-            offset index for column leaf:
-                              offset   compressed size       first row index
-        page-0                         4               554                     0
-        page-1                       558               554                    64
-        page-2                      1112               554                   128
-        page-3                      1666               554                   192
-
-    **/
-    #[test]
-    fn test_calculate_row_count() {
-        let total_row_count = 256;
-        let mut  indexes = vec![];
-        indexes.push(PageLocation::new(4, 554, 0));
-        indexes.push(PageLocation::new(558, 554, 64));
-        indexes.push(PageLocation::new(1112, 554, 128));
-        indexes.push(PageLocation::new(1666, 554, 192));
-        for i in 0..4 {
-            // each page should has 64 rows.
-            assert_eq!(64, calculate_row_count(indexes.as_slice(), i, total_row_count).unwrap());
-        }
-
-    }
-}
diff --git a/parquet/src/util/test_common/page_util.rs b/parquet/src/util/test_common/page_util.rs
index 243fb6f8b897..b4fed752fdc5 100644
--- a/parquet/src/util/test_common/page_util.rs
+++ b/parquet/src/util/test_common/page_util.rs
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use bytes::Bytes;
+
 use crate::basic::Encoding;
 use crate::column::page::{Page, PageIterator};
 use crate::column::page::{PageMetadata, PageReader};
@@ -22,8 +24,7 @@ use crate::data_type::DataType;
 use crate::encodings::encoding::{get_encoder, Encoder};
 use crate::encodings::levels::LevelEncoder;
 use crate::errors::Result;
-use crate::schema::types::{ColumnDescPtr, SchemaDescPtr};
-use crate::util::memory::ByteBufferPtr;
+use crate::schema::types::ColumnDescPtr;
 use std::iter::Peekable;
 use std::mem;
 
@@ -31,7 +32,7 @@ pub trait DataPageBuilder {
     fn add_rep_levels(&mut self, max_level: i16, rep_levels: &[i16]);
     fn add_def_levels(&mut self, max_level: i16, def_levels: &[i16]);
     fn add_values<T: DataType>(&mut self, encoding: Encoding, values: &[T::T]);
-    fn add_indices(&mut self, indices: ByteBufferPtr);
+    fn add_indices(&mut self, indices: Bytes);
     fn consume(self) -> Page;
 }
 
@@ -112,18 +113,18 @@ impl DataPageBuilder for DataPageBuilderImpl {
         let encoded_values = encoder
             .flush_buffer()
             .expect("consume_buffer() should be OK");
-        self.buffer.extend_from_slice(encoded_values.data());
+        self.buffer.extend_from_slice(&encoded_values);
     }
 
-    fn add_indices(&mut self, indices: ByteBufferPtr) {
+    fn add_indices(&mut self, indices: Bytes) {
         self.encoding = Some(Encoding::RLE_DICTIONARY);
-        self.buffer.extend_from_slice(indices.data());
+        self.buffer.extend_from_slice(&indices);
     }
 
     fn consume(self) -> Page {
         if self.datapage_v2 {
             Page::DataPageV2 {
-                buf: ByteBufferPtr::new(self.buffer),
+                buf: Bytes::from(self.buffer),
                 num_values: self.num_values,
                 encoding: self.encoding.unwrap(),
                 num_nulls: 0, /* set to dummy value - don't need this when reading
@@ -137,7 +138,7 @@ impl DataPageBuilder for DataPageBuilderImpl {
             }
         } else {
             Page::DataPage {
-                buf: ByteBufferPtr::new(self.buffer),
+                buf: Bytes::from(self.buffer),
                 num_values: self.num_values,
                 encoding: self.encoding.unwrap(),
                 def_level_encoding: Encoding::RLE,
@@ -170,15 +171,22 @@ impl<P: Iterator<Item = Page> + Send> PageReader for InMemoryPageReader<P> {
         if let Some(x) = self.page_iter.peek() {
             match x {
                 Page::DataPage { num_values, .. } => Ok(Some(PageMetadata {
-                    num_rows: *num_values as usize,
+                    num_rows: None,
+                    num_levels: Some(*num_values as _),
                     is_dict: false,
                 })),
-                Page::DataPageV2 { num_rows, .. } => Ok(Some(PageMetadata {
-                    num_rows: *num_rows as usize,
+                Page::DataPageV2 {
+                    num_rows,
+                    num_values,
+                    ..
+                } => Ok(Some(PageMetadata {
+                    num_rows: Some(*num_rows as _),
+                    num_levels: Some(*num_values as _),
                     is_dict: false,
                 })),
                 Page::DictionaryPage { .. } => Ok(Some(PageMetadata {
-                    num_rows: 0,
+                    num_rows: None,
+                    num_levels: None,
                     is_dict: true,
                 })),
             }
@@ -204,20 +212,12 @@ impl<P: Iterator<Item = Page> + Send> Iterator for InMemoryPageReader<P> {
 /// A utility page iterator which stores page readers in memory, used for tests.
 #[derive(Clone)]
 pub struct InMemoryPageIterator<I: Iterator<Item = Vec<Page>>> {
-    schema: SchemaDescPtr,
-    column_desc: ColumnDescPtr,
     page_reader_iter: I,
 }
 
 impl<I: Iterator<Item = Vec<Page>>> InMemoryPageIterator<I> {
-    pub fn new(
-        schema: SchemaDescPtr,
-        column_desc: ColumnDescPtr,
-        pages: impl IntoIterator<Item = Vec<Page>, IntoIter = I>,
-    ) -> Self {
+    pub fn new(pages: impl IntoIterator<Item = Vec<Page>, IntoIter = I>) -> Self {
         Self {
-            schema,
-            column_desc,
             page_reader_iter: pages.into_iter(),
         }
     }
@@ -233,12 +233,4 @@ impl<I: Iterator<Item = Vec<Page>>> Iterator for InMemoryPageIterator<I> {
     }
 }
 
-impl<I: Iterator<Item = Vec<Page>> + Send> PageIterator for InMemoryPageIterator<I> {
-    fn schema(&mut self) -> Result<SchemaDescPtr> {
-        Ok(self.schema.clone())
-    }
-
-    fn column_schema(&mut self) -> Result<ColumnDescPtr> {
-        Ok(self.column_desc.clone())
-    }
-}
+impl<I: Iterator<Item = Vec<Page>> + Send> PageIterator for InMemoryPageIterator<I> {}
diff --git a/parquet/src/util/test_common/rand_gen.rs b/parquet/src/util/test_common/rand_gen.rs
index 4e54aa7999cf..a267c34840c1 100644
--- a/parquet/src/util/test_common/rand_gen.rs
+++ b/parquet/src/util/test_common/rand_gen.rs
@@ -17,6 +17,7 @@
 
 use crate::basic::Encoding;
 use crate::column::page::Page;
+use bytes::Bytes;
 use rand::{
     distributions::{uniform::SampleUniform, Distribution, Standard},
     thread_rng, Rng,
@@ -26,7 +27,6 @@ use std::collections::VecDeque;
 use crate::data_type::*;
 use crate::encodings::encoding::{DictEncoder, Encoder};
 use crate::schema::types::ColumnDescPtr;
-use crate::util::memory::ByteBufferPtr;
 use crate::util::{DataPageBuilder, DataPageBuilderImpl};
 
 /// Random generator of data type `T` values and sequences.
@@ -90,7 +90,7 @@ impl RandGen<ByteArrayType> for ByteArrayType {
         for _ in 0..len {
             value.push(rng.gen_range(0..255));
         }
-        result.set_data(ByteBufferPtr::new(value));
+        result.set_data(Bytes::from(value));
         result
     }
 }
@@ -194,7 +194,7 @@ pub fn make_pages<T: DataType>(
             Encoding::PLAIN => {
                 pb.add_values::<T>(encoding, &values[value_range]);
             }
-            enc => panic!("Unexpected encoding {}", enc),
+            enc => panic!("Unexpected encoding {enc}"),
         }
 
         let data_page = pb.consume();
diff --git a/parquet/tests/arrow_writer_layout.rs b/parquet/tests/arrow_writer_layout.rs
new file mode 100644
index 000000000000..cd124031cfdc
--- /dev/null
+++ b/parquet/tests/arrow_writer_layout.rs
@@ -0,0 +1,542 @@
+// 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.
+
+//! Tests that the ArrowWriter correctly lays out values into multiple pages
+
+use arrow::array::{Int32Array, StringArray};
+use arrow::record_batch::RecordBatch;
+use arrow_array::builder::{Int32Builder, ListBuilder};
+use bytes::Bytes;
+use parquet::arrow::arrow_reader::{ArrowReaderOptions, ParquetRecordBatchReaderBuilder};
+use parquet::arrow::ArrowWriter;
+use parquet::basic::{Encoding, PageType};
+use parquet::file::metadata::ParquetMetaData;
+use parquet::file::properties::{ReaderProperties, WriterProperties};
+use parquet::file::reader::SerializedPageReader;
+use std::sync::Arc;
+
+struct Layout {
+    row_groups: Vec<RowGroup>,
+}
+
+struct RowGroup {
+    columns: Vec<ColumnChunk>,
+}
+
+struct ColumnChunk {
+    pages: Vec<Page>,
+    dictionary_page: Option<Page>,
+}
+
+struct Page {
+    rows: usize,
+    compressed_size: usize,
+    page_header_size: usize,
+    encoding: Encoding,
+    page_type: PageType,
+}
+
+struct LayoutTest {
+    props: WriterProperties,
+    batches: Vec<RecordBatch>,
+    layout: Layout,
+}
+
+fn do_test(test: LayoutTest) {
+    let mut buf = Vec::with_capacity(1024);
+
+    let mut writer =
+        ArrowWriter::try_new(&mut buf, test.batches[0].schema(), Some(test.props)).unwrap();
+    for batch in test.batches {
+        writer.write(&batch).unwrap();
+    }
+    writer.close().unwrap();
+    let b = Bytes::from(buf);
+
+    // Re-read file to decode column index
+    let read_options = ArrowReaderOptions::new().with_page_index(true);
+    let reader =
+        ParquetRecordBatchReaderBuilder::try_new_with_options(b.clone(), read_options).unwrap();
+
+    assert_layout(&b, reader.metadata().as_ref(), &test.layout);
+}
+
+fn assert_layout(file_reader: &Bytes, meta: &ParquetMetaData, layout: &Layout) {
+    assert_eq!(meta.row_groups().len(), layout.row_groups.len());
+    let iter = meta
+        .row_groups()
+        .iter()
+        .zip(&layout.row_groups)
+        .zip(meta.offset_index().unwrap());
+
+    for ((row_group, row_group_layout), offset_index) in iter {
+        // Check against offset index
+        assert_eq!(offset_index.len(), row_group_layout.columns.len());
+
+        for (column_index, column_layout) in offset_index.iter().zip(&row_group_layout.columns) {
+            assert_eq!(
+                column_index.len(),
+                column_layout.pages.len(),
+                "index page count mismatch"
+            );
+            for (idx, (page, page_layout)) in
+                column_index.iter().zip(&column_layout.pages).enumerate()
+            {
+                assert_eq!(
+                    page.compressed_page_size as usize,
+                    page_layout.compressed_size + page_layout.page_header_size,
+                    "index page {idx} size mismatch"
+                );
+                let next_first_row_index = column_index
+                    .get(idx + 1)
+                    .map(|x| x.first_row_index)
+                    .unwrap_or_else(|| row_group.num_rows());
+
+                let num_rows = next_first_row_index - page.first_row_index;
+                assert_eq!(
+                    num_rows as usize, page_layout.rows,
+                    "index page {idx} row count"
+                );
+            }
+        }
+
+        // Check against page data
+        assert_eq!(
+            row_group.columns().len(),
+            row_group_layout.columns.len(),
+            "column count mismatch"
+        );
+
+        let iter = row_group
+            .columns()
+            .iter()
+            .zip(&row_group_layout.columns)
+            .enumerate();
+
+        for (idx, (column, column_layout)) in iter {
+            let properties = ReaderProperties::builder()
+                .set_backward_compatible_lz4(false)
+                .build();
+            let page_reader = SerializedPageReader::new_with_properties(
+                Arc::new(file_reader.clone()),
+                column,
+                row_group.num_rows() as usize,
+                None,
+                Arc::new(properties),
+            )
+            .unwrap();
+
+            let pages = page_reader.collect::<Result<Vec<_>, _>>().unwrap();
+            assert_eq!(
+                pages.len(),
+                column_layout.pages.len() + column_layout.dictionary_page.is_some() as usize,
+                "page {idx} count mismatch"
+            );
+
+            let page_layouts = column_layout
+                .dictionary_page
+                .iter()
+                .chain(&column_layout.pages);
+
+            for (page, page_layout) in pages.iter().zip(page_layouts) {
+                assert_eq!(page.encoding(), page_layout.encoding);
+                assert_eq!(
+                    page.buffer().len(),
+                    page_layout.compressed_size,
+                    "page {idx} size mismatch"
+                );
+                assert_eq!(page.page_type(), page_layout.page_type);
+            }
+        }
+    }
+}
+
+#[test]
+fn test_primitive() {
+    let array = Arc::new(Int32Array::from_iter_values(0..2000)) as _;
+    let batch = RecordBatch::try_from_iter([("col", array)]).unwrap();
+    let props = WriterProperties::builder()
+        .set_dictionary_enabled(false)
+        .set_data_page_size_limit(1000)
+        .set_write_batch_size(10)
+        .build();
+
+    // Test spill plain encoding pages
+    do_test(LayoutTest {
+        props,
+        batches: vec![batch.clone()],
+        layout: Layout {
+            row_groups: vec![RowGroup {
+                columns: vec![ColumnChunk {
+                    pages: (0..8)
+                        .map(|_| Page {
+                            rows: 250,
+                            page_header_size: 36,
+                            compressed_size: 1000,
+                            encoding: Encoding::PLAIN,
+                            page_type: PageType::DATA_PAGE,
+                        })
+                        .collect(),
+                    dictionary_page: None,
+                }],
+            }],
+        },
+    });
+
+    // Test spill dictionary
+    let props = WriterProperties::builder()
+        .set_dictionary_enabled(true)
+        .set_dictionary_page_size_limit(1000)
+        .set_data_page_size_limit(10000)
+        .set_write_batch_size(10)
+        .build();
+
+    do_test(LayoutTest {
+        props,
+        batches: vec![batch.clone()],
+        layout: Layout {
+            row_groups: vec![RowGroup {
+                columns: vec![ColumnChunk {
+                    pages: vec![
+                        Page {
+                            rows: 250,
+                            page_header_size: 36,
+                            compressed_size: 258,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 1750,
+                            page_header_size: 36,
+                            compressed_size: 7000,
+                            encoding: Encoding::PLAIN,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                    ],
+                    dictionary_page: Some(Page {
+                        rows: 250,
+                        page_header_size: 36,
+                        compressed_size: 1000,
+                        encoding: Encoding::PLAIN,
+                        page_type: PageType::DICTIONARY_PAGE,
+                    }),
+                }],
+            }],
+        },
+    });
+
+    // Test spill dictionary encoded pages
+    let props = WriterProperties::builder()
+        .set_dictionary_enabled(true)
+        .set_dictionary_page_size_limit(10000)
+        .set_data_page_size_limit(500)
+        .set_write_batch_size(10)
+        .build();
+
+    do_test(LayoutTest {
+        props,
+        batches: vec![batch.clone()],
+        layout: Layout {
+            row_groups: vec![RowGroup {
+                columns: vec![ColumnChunk {
+                    pages: vec![
+                        Page {
+                            rows: 400,
+                            page_header_size: 36,
+                            compressed_size: 452,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 370,
+                            page_header_size: 36,
+                            compressed_size: 472,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 330,
+                            page_header_size: 36,
+                            compressed_size: 464,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 330,
+                            page_header_size: 36,
+                            compressed_size: 464,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 330,
+                            page_header_size: 36,
+                            compressed_size: 464,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 240,
+                            page_header_size: 36,
+                            compressed_size: 332,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                    ],
+                    dictionary_page: Some(Page {
+                        rows: 2000,
+                        page_header_size: 36,
+                        compressed_size: 8000,
+                        encoding: Encoding::PLAIN,
+                        page_type: PageType::DICTIONARY_PAGE,
+                    }),
+                }],
+            }],
+        },
+    });
+
+    // Test row count limit
+    let props = WriterProperties::builder()
+        .set_dictionary_enabled(false)
+        .set_data_page_row_count_limit(100)
+        .set_write_batch_size(100)
+        .build();
+
+    do_test(LayoutTest {
+        props,
+        batches: vec![batch],
+        layout: Layout {
+            row_groups: vec![RowGroup {
+                columns: vec![ColumnChunk {
+                    pages: (0..20)
+                        .map(|_| Page {
+                            rows: 100,
+                            page_header_size: 36,
+                            compressed_size: 400,
+                            encoding: Encoding::PLAIN,
+                            page_type: PageType::DATA_PAGE,
+                        })
+                        .collect(),
+                    dictionary_page: None,
+                }],
+            }],
+        },
+    });
+}
+
+#[test]
+fn test_string() {
+    let array = Arc::new(StringArray::from_iter_values(
+        (0..2000).map(|x| format!("{x:04}")),
+    )) as _;
+    let batch = RecordBatch::try_from_iter([("col", array)]).unwrap();
+    let props = WriterProperties::builder()
+        .set_dictionary_enabled(false)
+        .set_data_page_size_limit(1000)
+        .set_write_batch_size(10)
+        .build();
+
+    // Test spill plain encoding pages
+    do_test(LayoutTest {
+        props,
+        batches: vec![batch.clone()],
+        layout: Layout {
+            row_groups: vec![RowGroup {
+                columns: vec![ColumnChunk {
+                    pages: (0..15)
+                        .map(|_| Page {
+                            rows: 130,
+                            page_header_size: 36,
+                            compressed_size: 1040,
+                            encoding: Encoding::PLAIN,
+                            page_type: PageType::DATA_PAGE,
+                        })
+                        .chain(std::iter::once(Page {
+                            rows: 50,
+                            page_header_size: 35,
+                            compressed_size: 400,
+                            encoding: Encoding::PLAIN,
+                            page_type: PageType::DATA_PAGE,
+                        }))
+                        .collect(),
+                    dictionary_page: None,
+                }],
+            }],
+        },
+    });
+
+    // Test spill dictionary
+    let props = WriterProperties::builder()
+        .set_dictionary_enabled(true)
+        .set_dictionary_page_size_limit(1000)
+        .set_data_page_size_limit(10000)
+        .set_write_batch_size(10)
+        .build();
+
+    do_test(LayoutTest {
+        props,
+        batches: vec![batch.clone()],
+        layout: Layout {
+            row_groups: vec![RowGroup {
+                columns: vec![ColumnChunk {
+                    pages: vec![
+                        Page {
+                            rows: 130,
+                            page_header_size: 36,
+                            compressed_size: 138,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 1250,
+                            page_header_size: 38,
+                            compressed_size: 10000,
+                            encoding: Encoding::PLAIN,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 620,
+                            page_header_size: 36,
+                            compressed_size: 4960,
+                            encoding: Encoding::PLAIN,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                    ],
+                    dictionary_page: Some(Page {
+                        rows: 130,
+                        page_header_size: 36,
+                        compressed_size: 1040,
+                        encoding: Encoding::PLAIN,
+                        page_type: PageType::DICTIONARY_PAGE,
+                    }),
+                }],
+            }],
+        },
+    });
+
+    // Test spill dictionary encoded pages
+    let props = WriterProperties::builder()
+        .set_dictionary_enabled(true)
+        .set_dictionary_page_size_limit(20000)
+        .set_data_page_size_limit(500)
+        .set_write_batch_size(10)
+        .build();
+
+    do_test(LayoutTest {
+        props,
+        batches: vec![batch],
+        layout: Layout {
+            row_groups: vec![RowGroup {
+                columns: vec![ColumnChunk {
+                    pages: vec![
+                        Page {
+                            rows: 400,
+                            page_header_size: 36,
+                            compressed_size: 452,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 370,
+                            page_header_size: 36,
+                            compressed_size: 472,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 330,
+                            page_header_size: 36,
+                            compressed_size: 464,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 330,
+                            page_header_size: 36,
+                            compressed_size: 464,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 330,
+                            page_header_size: 36,
+                            compressed_size: 464,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                        Page {
+                            rows: 240,
+                            page_header_size: 36,
+                            compressed_size: 332,
+                            encoding: Encoding::RLE_DICTIONARY,
+                            page_type: PageType::DATA_PAGE,
+                        },
+                    ],
+                    dictionary_page: Some(Page {
+                        rows: 2000,
+                        page_header_size: 36,
+                        compressed_size: 16000,
+                        encoding: Encoding::PLAIN,
+                        page_type: PageType::DICTIONARY_PAGE,
+                    }),
+                }],
+            }],
+        },
+    });
+}
+
+#[test]
+fn test_list() {
+    let mut list = ListBuilder::new(Int32Builder::new());
+    for _ in 0..200 {
+        let values = list.values();
+        for i in 0..8 {
+            values.append_value(i);
+        }
+        list.append(true);
+    }
+    let array = Arc::new(list.finish()) as _;
+
+    let batch = RecordBatch::try_from_iter([("col", array)]).unwrap();
+    let props = WriterProperties::builder()
+        .set_dictionary_enabled(false)
+        .set_data_page_row_count_limit(20)
+        .set_write_batch_size(3)
+        .build();
+
+    // Test rows not split across pages
+    do_test(LayoutTest {
+        props,
+        batches: vec![batch],
+        layout: Layout {
+            row_groups: vec![RowGroup {
+                columns: vec![ColumnChunk {
+                    pages: (0..10)
+                        .map(|_| Page {
+                            rows: 20,
+                            page_header_size: 36,
+                            compressed_size: 672,
+                            encoding: Encoding::PLAIN,
+                            page_type: PageType::DATA_PAGE,
+                        })
+                        .collect(),
+                    dictionary_page: None,
+                }],
+            }],
+        },
+    });
+}
diff --git a/parquet/tests/boolean_writer.rs b/parquet/tests/boolean_writer.rs
deleted file mode 100644
index dc2eccfbf3c3..000000000000
--- a/parquet/tests/boolean_writer.rs
+++ /dev/null
@@ -1,89 +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.
-
-use parquet::data_type::BoolType;
-use parquet::file::properties::WriterProperties;
-use parquet::file::reader::FileReader;
-use parquet::file::serialized_reader::SerializedFileReader;
-use parquet::file::writer::SerializedFileWriter;
-use parquet::schema::parser::parse_message_type;
-use std::fs;
-use std::path::Path;
-use std::sync::{mpsc, Arc};
-use std::thread;
-use std::time::Duration;
-
-#[test]
-fn it_writes_data_without_hanging() {
-    let path = Path::new("it_writes_data_without_hanging.parquet");
-
-    let message_type = "
-  message BooleanType {
-    REQUIRED BOOLEAN DIM0;
-  }
-";
-    let schema = Arc::new(parse_message_type(message_type).expect("parse schema"));
-    let props = Arc::new(WriterProperties::builder().build());
-    let file = fs::File::create(&path).expect("create file");
-    let mut writer =
-        SerializedFileWriter::new(file, schema, props).expect("create parquet writer");
-    for _group in 0..1 {
-        let mut row_group_writer = writer.next_row_group().expect("get row group writer");
-        let values: Vec<i64> = vec![0; 2049];
-        let my_bool_values: Vec<bool> = values
-            .iter()
-            .enumerate()
-            .map(|(count, _x)| count % 2 == 0)
-            .collect();
-        while let Some(mut col_writer) =
-            row_group_writer.next_column().expect("next column")
-        {
-            col_writer
-                .typed::<BoolType>()
-                .write_batch(&my_bool_values, None, None)
-                .expect("writing bool column");
-
-            col_writer.close().expect("close column");
-        }
-        let rg_md = row_group_writer.close().expect("close row group");
-        println!("total rows written: {}", rg_md.num_rows());
-    }
-    writer.close().expect("close writer");
-
-    let bytes = fs::read(&path).expect("read file");
-    assert_eq!(&bytes[0..4], &[b'P', b'A', b'R', b'1']);
-
-    // Now that we have written our data and are happy with it, make
-    // sure we can read it back in < 5 seconds...
-    let (sender, receiver) = mpsc::channel();
-    let _t = thread::spawn(move || {
-        let file = fs::File::open(&Path::new("it_writes_data_without_hanging.parquet"))
-            .expect("open file");
-        let reader = SerializedFileReader::new(file).expect("get serialized reader");
-        let iter = reader.get_row_iter(None).expect("get iterator");
-        for record in iter {
-            println!("reading: {}", record);
-        }
-        println!("finished reading");
-        if let Ok(()) = sender.send(true) {}
-    });
-    assert_ne!(
-        Err(mpsc::RecvTimeoutError::Timeout),
-        receiver.recv_timeout(Duration::from_millis(5000))
-    );
-    fs::remove_file("it_writes_data_without_hanging.parquet").expect("remove file");
-}
diff --git a/parquet_derive/Cargo.toml b/parquet_derive/Cargo.toml
index 3f586de6928a..68d19e54c4f4 100644
--- a/parquet_derive/Cargo.toml
+++ b/parquet_derive/Cargo.toml
@@ -17,16 +17,16 @@
 
 [package]
 name = "parquet_derive"
-version = "20.0.0"
-license = "Apache-2.0"
+version = { workspace = true }
+license = { workspace = true }
 description = "Derive macros for the Rust implementation of Apache Parquet"
-homepage = "https://github.com/apache/arrow-rs"
-repository = "https://github.com/apache/arrow-rs"
-authors = ["Apache Arrow <dev@arrow.apache.org>"]
-keywords = [ "parquet" ]
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
+keywords = ["parquet"]
 readme = "README.md"
-edition = "2021"
-rust-version = "1.62"
+edition = { workspace = true }
+rust-version = { workspace = true }
 
 [lib]
 proc-macro = true
@@ -34,5 +34,5 @@ proc-macro = true
 [dependencies]
 proc-macro2 = { version = "1.0", default-features = false }
 quote = { version = "1.0", default-features = false }
-syn = { version = "1.0", default-features = false }
-parquet = { path = "../parquet", version = "20.0.0" }
+syn = { version = "2.0", features = ["extra-traits"] }
+parquet = { workspace = true }
diff --git a/parquet_derive/README.md b/parquet_derive/README.md
index 30d5e339f26c..c267a92430e0 100644
--- a/parquet_derive/README.md
+++ b/parquet_derive/README.md
@@ -19,9 +19,9 @@
 
 # Parquet Derive
 
-A crate for deriving `RecordWriter` for arbitrary, _simple_ structs. This does not generate writers for arbitrarily nested
-structures. It only works for primitives and a few generic structures and
-various levels of reference. Please see features checklist for what is currently
+A crate for deriving `RecordWriter` and `RecordReader` for arbitrary, _simple_ structs. This does not
+generate readers or writers for arbitrarily nested structures. It only works for primitives and a few
+generic structures and various levels of reference. Please see features checklist for what is currently
 supported.
 
 Derive also has some support for the chrono time library. You must must enable the `chrono` feature to get this support.
@@ -32,8 +32,8 @@ Add this to your Cargo.toml:
 
 ```toml
 [dependencies]
-parquet = "20.0.0"
-parquet_derive = "20.0.0"
+parquet = "39.0.0"
+parquet_derive = "39.0.0"
 ```
 
 and this to your crate root:
@@ -77,16 +77,55 @@ writer.close_row_group(row_group).unwrap();
 writer.close().unwrap();
 ```
 
+Example usage of deriving a `RecordReader` for your struct:
+
+```rust
+use parquet::file::{serialized_reader::SerializedFileReader, reader::FileReader};
+use parquet_derive::ParquetRecordReader;
+
+#[derive(ParquetRecordReader)]
+struct ACompleteRecord {
+    pub a_bool: bool,
+    pub a_string: String,
+    pub i16: i16,
+    pub i32: i32,
+    pub u64: u64,
+    pub isize: isize,
+    pub float: f32,
+    pub double: f64,
+    pub now: chrono::NaiveDateTime,
+    pub byte_vec: Vec<u8>,
+}
+
+// Initialize your parquet file
+let reader = SerializedFileReader::new(file).unwrap();
+let mut row_group = reader.get_row_group(0).unwrap();
+
+// create your records vector to read into
+let mut chunks: Vec<ACompleteRecord> = Vec::new();
+
+// The derived `RecordReader` takes over here
+chunks.read_from_row_group(&mut *row_group, 1).unwrap();
+```
+
 ## Features
 
 - [x] Support writing `String`, `&str`, `bool`, `i32`, `f32`, `f64`, `Vec<u8>`
 - [ ] Support writing dictionaries
 - [x] Support writing logical types like timestamp
-- [x] Derive definition_levels for `Option`
-- [ ] Derive definition levels for nested structures
+- [x] Derive definition_levels for `Option` for writing
+- [ ] Derive definition levels for nested structures for writing
 - [ ] Derive writing tuple struct
 - [ ] Derive writing `tuple` container types
 
+- [x] Support reading `String`, `&str`, `bool`, `i32`, `f32`, `f64`, `Vec<u8>`
+- [ ] Support reading/writing dictionaries
+- [x] Support reading/writing logical types like timestamp
+- [ ] Handle definition_levels for `Option` for reading
+- [ ] Handle definition levels for nested structures for reading
+- [ ] Derive reading/writing tuple struct
+- [ ] Derive reading/writing `tuple` container types
+
 ## Requirements
 
 - Same as `parquet-rs`
@@ -103,4 +142,4 @@ To compile and view in the browser, run `cargo doc --no-deps --open`.
 
 ## License
 
-Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0.
+Licensed under the Apache License, Version 2.0: http://www.apache.org/licenses/LICENSE-2.0.
\ No newline at end of file
diff --git a/parquet_derive/src/lib.rs b/parquet_derive/src/lib.rs
index fc7af20ca3f1..671a46db0f31 100644
--- a/parquet_derive/src/lib.rs
+++ b/parquet_derive/src/lib.rs
@@ -40,12 +40,11 @@ mod parquet_field;
 /// Example:
 ///
 /// ```ignore
-/// use parquet;
-/// use parquet::record::RecordWriter;
-/// use parquet::schema::parser::parse_message_type;
+/// use parquet::file::properties::WriterProperties;
+/// use parquet::file::writer::SerializedFileWriter;
 ///
 /// use std::sync::Arc;
-//
+///
 /// #[derive(ParquetRecordWriter)]
 /// struct ACompleteRecord<'a> {
 ///   pub a_bool: bool,
@@ -66,8 +65,7 @@ mod parquet_field;
 ///
 ///  let schema = samples.as_slice().schema();
 ///
-///  let props = Arc::new(WriterProperties::builder().build());
-///  let mut writer = SerializedFileWriter::new(file, schema, props).unwrap();
+///  let mut writer = SerializedFileWriter::new(file, schema, Default::default()).unwrap();
 ///
 ///  let mut row_group = writer.next_row_group().unwrap();
 ///  samples.as_slice().write_to_row_group(&mut row_group).unwrap();
@@ -97,11 +95,13 @@ pub fn parquet_record_writer(input: proc_macro::TokenStream) -> proc_macro::Toke
         field_infos.iter().map(|x| x.parquet_type()).collect();
 
     (quote! {
-    impl #generics RecordWriter<#derived_for #generics> for &[#derived_for #generics] {
-      fn write_to_row_group<W: std::io::Write>(
+    impl #generics ::parquet::record::RecordWriter<#derived_for #generics> for &[#derived_for #generics] {
+      fn write_to_row_group<W: ::std::io::Write + Send>(
         &self,
-        row_group_writer: &mut parquet::file::writer::SerializedRowGroupWriter<'_, W>
-      ) -> Result<(), parquet::errors::ParquetError> {
+        row_group_writer: &mut ::parquet::file::writer::SerializedRowGroupWriter<'_, W>
+      ) -> Result<(), ::parquet::errors::ParquetError> {
+        use ::parquet::column::writer::ColumnWriter;
+
         let mut row_group_writer = row_group_writer;
         let records = &self; // Used by all the writer snippets to be more clear
 
@@ -112,7 +112,7 @@ pub fn parquet_record_writer(input: proc_macro::TokenStream) -> proc_macro::Toke
                   #writer_snippets
                   column_writer.close()?;
               } else {
-                  return Err(parquet::errors::ParquetError::General("Failed to get next column".into()))
+                  return Err(::parquet::errors::ParquetError::General("Failed to get next column".into()))
               }
           }
         );*
@@ -120,21 +120,106 @@ pub fn parquet_record_writer(input: proc_macro::TokenStream) -> proc_macro::Toke
         Ok(())
       }
 
-      fn schema(&self) -> Result<parquet::schema::types::TypePtr, parquet::errors::ParquetError> {
-        use parquet::schema::types::Type as ParquetType;
-        use parquet::schema::types::TypePtr;
-        use parquet::basic::LogicalType;
-        use parquet::basic::*;
+      fn schema(&self) -> Result<::parquet::schema::types::TypePtr, ::parquet::errors::ParquetError> {
+        use ::parquet::schema::types::Type as ParquetType;
+        use ::parquet::schema::types::TypePtr;
+        use ::parquet::basic::LogicalType;
 
-        let mut fields: Vec<TypePtr> = Vec::new();
+        let mut fields: ::std::vec::Vec<TypePtr> = ::std::vec::Vec::new();
         #(
           #field_types
         );*;
-        let group = parquet::schema::types::Type::group_type_builder("rust_schema")
-          .with_fields(&mut fields)
+        let group = ParquetType::group_type_builder("rust_schema")
+          .with_fields(fields)
           .build()?;
         Ok(group.into())
       }
     }
   }).into()
 }
+
+/// Derive flat, simple RecordReader implementations. Works by parsing
+/// a struct tagged with `#[derive(ParquetRecordReader)]` and emitting
+/// the correct writing code for each field of the struct. Column readers
+/// are generated in the order they are defined.
+///
+/// It is up to the programmer to keep the order of the struct
+/// fields lined up with the schema.
+///
+/// Example:
+///
+/// ```ignore
+/// use parquet::file::{serialized_reader::SerializedFileReader, reader::FileReader};
+/// use parquet_derive::{ParquetRecordReader};
+///
+/// #[derive(ParquetRecordReader)]
+/// struct ACompleteRecord {
+///     pub a_bool: bool,
+///     pub a_string: String,
+/// }
+///
+/// pub fn read_some_records() -> Vec<ACompleteRecord> {
+///   let mut samples: Vec<ACompleteRecord> = Vec::new();
+///
+///   let reader = SerializedFileReader::new(file).unwrap();
+///   let mut row_group = reader.get_row_group(0).unwrap();
+///   samples.read_from_row_group(&mut *row_group, 1).unwrap();
+///   samples
+/// }
+/// ```
+///
+#[proc_macro_derive(ParquetRecordReader)]
+pub fn parquet_record_reader(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input: DeriveInput = parse_macro_input!(input as DeriveInput);
+    let fields = match input.data {
+        Data::Struct(DataStruct { fields, .. }) => fields,
+        Data::Enum(_) => unimplemented!("Enum currently is not supported"),
+        Data::Union(_) => unimplemented!("Union currently is not supported"),
+    };
+
+    let field_infos: Vec<_> = fields.iter().map(parquet_field::Field::from).collect();
+    let field_names: Vec<_> = fields.iter().map(|f| f.ident.clone()).collect();
+    let reader_snippets: Vec<proc_macro2::TokenStream> =
+        field_infos.iter().map(|x| x.reader_snippet()).collect();
+    let i: Vec<_> = (0..reader_snippets.len()).collect();
+
+    let derived_for = input.ident;
+    let generics = input.generics;
+
+    (quote! {
+
+    impl #generics ::parquet::record::RecordReader<#derived_for #generics> for Vec<#derived_for #generics> {
+      fn read_from_row_group(
+        &mut self,
+        row_group_reader: &mut dyn ::parquet::file::reader::RowGroupReader,
+        num_records: usize,
+      ) -> Result<(), ::parquet::errors::ParquetError> {
+        use ::parquet::column::reader::ColumnReader;
+
+        let mut row_group_reader = row_group_reader;
+
+        for _ in 0..num_records {
+          self.push(#derived_for {
+            #(
+              #field_names: Default::default()
+            ),*
+          })
+        }
+
+        let records = self; // Used by all the reader snippets to be more clear
+
+        #(
+          {
+              if let Ok(mut column_reader) = row_group_reader.get_column_reader(#i) {
+                  #reader_snippets
+              } else {
+                  return Err(::parquet::errors::ParquetError::General("Failed to get next column".into()))
+              }
+          }
+        );*
+
+        Ok(())
+      }
+    }
+  }).into()
+}
diff --git a/parquet_derive/src/parquet_field.rs b/parquet_derive/src/parquet_field.rs
index 835ac793e409..8d759d11c4bc 100644
--- a/parquet_derive/src/parquet_field.rs
+++ b/parquet_derive/src/parquet_field.rs
@@ -68,7 +68,7 @@ impl Field {
     ///
     /// struct Record {
     ///   a_bool: bool,
-    ///   maybe_a_bool: Option<bool>
+    ///   maybe_a_bool: `Option<bool>`
     /// }
     ///
     /// but not
@@ -92,6 +92,10 @@ impl Field {
                     Type::TypePath(_) => self.option_into_vals(),
                     _ => unimplemented!("Unsupported type encountered"),
                 },
+                Type::Vec(ref first_type) => match **first_type {
+                    Type::TypePath(_) => self.option_into_vals(),
+                    _ => unimplemented!("Unsupported type encountered"),
+                },
                 ref f => unimplemented!("Unsupported: {:#?}", f),
             },
             Type::Reference(_, ref first_type) => match **first_type {
@@ -99,11 +103,27 @@ impl Field {
                 Type::Option(ref second_type) => match **second_type {
                     Type::TypePath(_) => self.option_into_vals(),
                     Type::Reference(_, ref second_type) => match **second_type {
+                        Type::TypePath(_) => self.option_into_vals(),
+                        Type::Slice(ref second_type) => match **second_type {
+                            Type::TypePath(_) => self.option_into_vals(),
+                            ref f => unimplemented!("Unsupported: {:#?}", f),
+                        },
+                        _ => unimplemented!("Unsupported type encountered"),
+                    },
+                    Type::Vec(ref first_type) => match **first_type {
                         Type::TypePath(_) => self.option_into_vals(),
                         _ => unimplemented!("Unsupported type encountered"),
                     },
                     ref f => unimplemented!("Unsupported: {:#?}", f),
                 },
+                Type::Slice(ref second_type) => match **second_type {
+                    Type::TypePath(_) => self.copied_direct_vals(),
+                    ref f => unimplemented!("Unsupported: {:#?}", f),
+                },
+                ref f => unimplemented!("Unsupported: {:#?}", f),
+            },
+            Type::Vec(ref first_type) => match **first_type {
+                Type::TypePath(_) => self.copied_direct_vals(),
                 ref f => unimplemented!("Unsupported: {:#?}", f),
             },
             f => unimplemented!("Unsupported: {:#?}", f),
@@ -116,26 +136,51 @@ impl Field {
                 Type::Option(_) => unimplemented!("Unsupported nesting encountered"),
                 Type::Reference(_, ref second_type)
                 | Type::Vec(ref second_type)
-                | Type::Array(ref second_type) => match **second_type {
+                | Type::Array(ref second_type)
+                | Type::Slice(ref second_type) => match **second_type {
                     Type::TypePath(_) => Some(self.optional_definition_levels()),
                     _ => unimplemented!("Unsupported nesting encountered"),
                 },
             },
             Type::Reference(_, ref first_type)
             | Type::Vec(ref first_type)
-            | Type::Array(ref first_type) => match **first_type {
+            | Type::Array(ref first_type)
+            | Type::Slice(ref first_type) => match **first_type {
                 Type::TypePath(_) => None,
-                Type::Reference(_, ref second_type)
-                | Type::Vec(ref second_type)
+                Type::Vec(ref second_type)
                 | Type::Array(ref second_type)
-                | Type::Option(ref second_type) => match **second_type {
-                    Type::TypePath(_) => Some(self.optional_definition_levels()),
+                | Type::Slice(ref second_type) => match **second_type {
+                    Type::TypePath(_) => None,
                     Type::Reference(_, ref third_type) => match **third_type {
-                        Type::TypePath(_) => Some(self.optional_definition_levels()),
+                        Type::TypePath(_) => None,
                         _ => unimplemented!("Unsupported definition encountered"),
                     },
                     _ => unimplemented!("Unsupported definition encountered"),
                 },
+                Type::Reference(_, ref second_type) | Type::Option(ref second_type) => {
+                    match **second_type {
+                        Type::TypePath(_) => Some(self.optional_definition_levels()),
+                        Type::Vec(ref third_type)
+                        | Type::Array(ref third_type)
+                        | Type::Slice(ref third_type) => match **third_type {
+                            Type::TypePath(_) => Some(self.optional_definition_levels()),
+                            Type::Reference(_, ref fourth_type) => match **fourth_type {
+                                Type::TypePath(_) => Some(self.optional_definition_levels()),
+                                _ => unimplemented!("Unsupported definition encountered"),
+                            },
+                            _ => unimplemented!("Unsupported definition encountered"),
+                        },
+                        Type::Reference(_, ref third_type) => match **third_type {
+                            Type::TypePath(_) => Some(self.optional_definition_levels()),
+                            Type::Slice(ref fourth_type) => match **fourth_type {
+                                Type::TypePath(_) => Some(self.optional_definition_levels()),
+                                _ => unimplemented!("Unsupported definition encountered"),
+                            },
+                            _ => unimplemented!("Unsupported definition encountered"),
+                        },
+                        _ => unimplemented!("Unsupported definition encountered"),
+                    }
+                }
             },
         };
 
@@ -174,6 +219,69 @@ impl Field {
         }
     }
 
+    /// Takes the parsed field of the struct and emits a valid
+    /// column reader snippet. Should match exactly what you
+    /// would write by hand.
+    ///
+    /// Can only generate writers for basic structs, for example:
+    ///
+    /// struct Record {
+    ///   a_bool: bool
+    /// }
+    ///
+    /// but not
+    ///
+    /// struct UnsupportedNestedRecord {
+    ///   a_property: bool,
+    ///   nested_record: Record
+    /// }
+    ///
+    /// because this parsing logic is not sophisticated enough for definition
+    /// levels beyond 2.
+    ///
+    /// `Option` types and references not supported
+    pub fn reader_snippet(&self) -> proc_macro2::TokenStream {
+        let ident = &self.ident;
+        let column_reader = self.ty.column_reader();
+
+        // generate the code to read the column into a vector `vals`
+        let write_batch_expr = quote! {
+            let mut vals = Vec::new();
+            if let #column_reader(mut typed) = column_reader {
+                typed.read_records(num_records, None, None, &mut vals)?;
+            } else {
+                panic!("Schema and struct disagree on type for {}", stringify!{#ident});
+            }
+        };
+
+        // generate the code to convert each element of `vals` to the correct type and then write
+        // it to its field in the corresponding struct
+        let vals_writer = match &self.ty {
+            Type::TypePath(_) => self.copied_direct_fields(),
+            Type::Reference(_, ref first_type) => match **first_type {
+                Type::TypePath(_) => self.copied_direct_fields(),
+                Type::Slice(ref second_type) => match **second_type {
+                    Type::TypePath(_) => self.copied_direct_fields(),
+                    ref f => unimplemented!("Unsupported: {:#?}", f),
+                },
+                ref f => unimplemented!("Unsupported: {:#?}", f),
+            },
+            Type::Vec(ref first_type) => match **first_type {
+                Type::TypePath(_) => self.copied_direct_fields(),
+                ref f => unimplemented!("Unsupported: {:#?}", f),
+            },
+            f => unimplemented!("Unsupported: {:#?}", f),
+        };
+
+        quote! {
+            {
+                #write_batch_expr
+
+                #vals_writer
+            }
+        }
+    }
+
     pub fn parquet_type(&self) -> proc_macro2::TokenStream {
         // TODO: Support group types
         // TODO: Add length if dealing with fixedlenbinary
@@ -181,28 +289,28 @@ impl Field {
         let field_name = &self.ident.to_string();
         let physical_type = match self.ty.physical_type() {
             parquet::basic::Type::BOOLEAN => quote! {
-                parquet::basic::Type::BOOLEAN
+                ::parquet::basic::Type::BOOLEAN
             },
             parquet::basic::Type::INT32 => quote! {
-                parquet::basic::Type::INT32
+                ::parquet::basic::Type::INT32
             },
             parquet::basic::Type::INT64 => quote! {
-                parquet::basic::Type::INT64
+                ::parquet::basic::Type::INT64
             },
             parquet::basic::Type::INT96 => quote! {
-                parquet::basic::Type::INT96
+                ::parquet::basic::Type::INT96
             },
             parquet::basic::Type::FLOAT => quote! {
-                parquet::basic::Type::FLOAT
+                ::parquet::basic::Type::FLOAT
             },
             parquet::basic::Type::DOUBLE => quote! {
-                parquet::basic::Type::DOUBLE
+                ::parquet::basic::Type::DOUBLE
             },
             parquet::basic::Type::BYTE_ARRAY => quote! {
-                parquet::basic::Type::BYTE_ARRAY
+                ::parquet::basic::Type::BYTE_ARRAY
             },
             parquet::basic::Type::FIXED_LEN_BYTE_ARRAY => quote! {
-                parquet::basic::Type::FIXED_LEN_BYTE_ARRAY
+                ::parquet::basic::Type::FIXED_LEN_BYTE_ARRAY
             },
         };
         let logical_type = self.ty.logical_type();
@@ -232,8 +340,7 @@ impl Field {
     fn option_into_vals(&self) -> proc_macro2::TokenStream {
         let field_name = &self.ident;
         let is_a_byte_buf = self.is_a_byte_buf;
-        let is_a_timestamp =
-            self.third_party_type == Some(ThirdPartyType::ChronoNaiveDateTime);
+        let is_a_timestamp = self.third_party_type == Some(ThirdPartyType::ChronoNaiveDateTime);
         let is_a_date = self.third_party_type == Some(ThirdPartyType::ChronoNaiveDate);
         let is_a_uuid = self.third_party_type == Some(ThirdPartyType::Uuid);
         let copy_to_vec = !matches!(
@@ -250,7 +357,7 @@ impl Field {
         let some = if is_a_timestamp {
             quote! { Some(inner.timestamp_millis()) }
         } else if is_a_date {
-            quote! { Some(inner.signed_duration_since(chrono::NaiveDate::from_ymd(1970, 1, 1)).num_days() as i32)  }
+            quote! { Some(inner.signed_duration_since(::chrono::NaiveDate::from_ymd(1970, 1, 1)).num_days() as i32)  }
         } else if is_a_uuid {
             quote! { Some((&inner.to_string()[..]).into()) }
         } else if is_a_byte_buf {
@@ -275,28 +382,31 @@ impl Field {
         }
     }
 
+    // generates code to read `field_name` from each record into a vector `vals`
     fn copied_direct_vals(&self) -> proc_macro2::TokenStream {
         let field_name = &self.ident;
-        let is_a_byte_buf = self.is_a_byte_buf;
-        let is_a_timestamp =
-            self.third_party_type == Some(ThirdPartyType::ChronoNaiveDateTime);
-        let is_a_date = self.third_party_type == Some(ThirdPartyType::ChronoNaiveDate);
-        let is_a_uuid = self.third_party_type == Some(ThirdPartyType::Uuid);
 
-        let access = if is_a_timestamp {
-            quote! { rec.#field_name.timestamp_millis() }
-        } else if is_a_date {
-            quote! { rec.#field_name.signed_duration_since(chrono::NaiveDate::from_ymd(1970, 1, 1)).num_days() as i32 }
-        } else if is_a_uuid {
-            quote! { (&rec.#field_name.to_string()[..]).into() }
-        } else if is_a_byte_buf {
-            quote! { (&rec.#field_name[..]).into() }
-        } else {
-            // Type might need converting to a physical type
-            match self.ty.physical_type() {
-                parquet::basic::Type::INT32 => quote! { rec.#field_name as i32 },
-                parquet::basic::Type::INT64 => quote! { rec.#field_name as i64 },
-                _ => quote! { rec.#field_name },
+        let access = match self.third_party_type {
+            Some(ThirdPartyType::ChronoNaiveDateTime) => {
+                quote! { rec.#field_name.timestamp_millis() }
+            }
+            Some(ThirdPartyType::ChronoNaiveDate) => {
+                quote! { rec.#field_name.signed_duration_since(::chrono::NaiveDate::from_ymd(1970, 1, 1)).num_days() as i32 }
+            }
+            Some(ThirdPartyType::Uuid) => {
+                quote! { (&rec.#field_name.to_string()[..]).into() }
+            }
+            _ => {
+                if self.is_a_byte_buf {
+                    quote! { (&rec.#field_name[..]).into() }
+                } else {
+                    // Type might need converting to a physical type
+                    match self.ty.physical_type() {
+                        parquet::basic::Type::INT32 => quote! { rec.#field_name as i32 },
+                        parquet::basic::Type::INT64 => quote! { rec.#field_name as i64 },
+                        _ => quote! { rec.#field_name },
+                    }
+                }
             }
         };
 
@@ -305,6 +415,44 @@ impl Field {
         }
     }
 
+    // generates code to read a vector `records` into `field_name` for each record
+    fn copied_direct_fields(&self) -> proc_macro2::TokenStream {
+        let field_name = &self.ident;
+
+        let value = match self.third_party_type {
+            Some(ThirdPartyType::ChronoNaiveDateTime) => {
+                quote! { ::chrono::naive::NaiveDateTime::from_timestamp_millis(vals[i]).unwrap() }
+            }
+            Some(ThirdPartyType::ChronoNaiveDate) => {
+                // NaiveDateTime::UNIX_EPOCH.num_days_from_ce() == 719163
+                quote! {
+                    ::chrono::naive::NaiveDate::from_num_days_from_ce_opt(vals[i].saturating_add(719163)).unwrap()
+                }
+            }
+            Some(ThirdPartyType::Uuid) => {
+                quote! { ::uuid::Uuid::parse_str(vals[i].data().convert()).unwrap() }
+            }
+            _ => match &self.ty {
+                Type::TypePath(_) => match self.ty.last_part().as_str() {
+                    "String" => quote! { String::from(std::str::from_utf8(vals[i].data())
+                    .expect("invalid UTF-8 sequence")) },
+                    t => {
+                        let s: proc_macro2::TokenStream = t.parse().unwrap();
+                        quote! { vals[i] as #s }
+                    }
+                },
+                Type::Vec(_) => quote! { vals[i].data().to_vec() },
+                f => unimplemented!("Unsupported: {:#?}", f),
+            },
+        };
+
+        quote! {
+            for (i, r) in &mut records[..num_records].iter_mut().enumerate() {
+                r.#field_name = #value;
+            }
+        }
+    }
+
     fn optional_definition_levels(&self) -> proc_macro2::TokenStream {
         let field_name = &self.ident;
 
@@ -323,6 +471,7 @@ impl Field {
 enum Type {
     Array(Box<Type>),
     Option(Box<Type>),
+    Slice(Box<Type>),
     Vec(Box<Type>),
     TypePath(syn::Type),
     Reference(Option<syn::Lifetime>, Box<Type>),
@@ -336,57 +485,67 @@ impl Type {
 
         match self.physical_type() {
             BasicType::BOOLEAN => {
-                syn::parse_quote!(parquet::column::writer::ColumnWriter::BoolColumnWriter)
+                syn::parse_quote!(ColumnWriter::BoolColumnWriter)
+            }
+            BasicType::INT32 => syn::parse_quote!(ColumnWriter::Int32ColumnWriter),
+            BasicType::INT64 => syn::parse_quote!(ColumnWriter::Int64ColumnWriter),
+            BasicType::INT96 => syn::parse_quote!(ColumnWriter::Int96ColumnWriter),
+            BasicType::FLOAT => syn::parse_quote!(ColumnWriter::FloatColumnWriter),
+            BasicType::DOUBLE => syn::parse_quote!(ColumnWriter::DoubleColumnWriter),
+            BasicType::BYTE_ARRAY => {
+                syn::parse_quote!(ColumnWriter::ByteArrayColumnWriter)
+            }
+            BasicType::FIXED_LEN_BYTE_ARRAY => {
+                syn::parse_quote!(ColumnWriter::FixedLenByteArrayColumnWriter)
+            }
+        }
+    }
+
+    /// Takes a rust type and returns the appropriate
+    /// parquet-rs column reader
+    fn column_reader(&self) -> syn::TypePath {
+        use parquet::basic::Type as BasicType;
+
+        match self.physical_type() {
+            BasicType::BOOLEAN => {
+                syn::parse_quote!(ColumnReader::BoolColumnReader)
+            }
+            BasicType::INT32 => syn::parse_quote!(ColumnReader::Int32ColumnReader),
+            BasicType::INT64 => syn::parse_quote!(ColumnReader::Int64ColumnReader),
+            BasicType::INT96 => syn::parse_quote!(ColumnReader::Int96ColumnReader),
+            BasicType::FLOAT => syn::parse_quote!(ColumnReader::FloatColumnReader),
+            BasicType::DOUBLE => syn::parse_quote!(ColumnReader::DoubleColumnReader),
+            BasicType::BYTE_ARRAY => {
+                syn::parse_quote!(ColumnReader::ByteArrayColumnReader)
+            }
+            BasicType::FIXED_LEN_BYTE_ARRAY => {
+                syn::parse_quote!(ColumnReader::FixedLenByteArrayColumnReader)
             }
-            BasicType::INT32 => syn::parse_quote!(
-                parquet::column::writer::ColumnWriter::Int32ColumnWriter
-            ),
-            BasicType::INT64 => syn::parse_quote!(
-                parquet::column::writer::ColumnWriter::Int64ColumnWriter
-            ),
-            BasicType::INT96 => syn::parse_quote!(
-                parquet::column::writer::ColumnWriter::Int96ColumnWriter
-            ),
-            BasicType::FLOAT => syn::parse_quote!(
-                parquet::column::writer::ColumnWriter::FloatColumnWriter
-            ),
-            BasicType::DOUBLE => syn::parse_quote!(
-                parquet::column::writer::ColumnWriter::DoubleColumnWriter
-            ),
-            BasicType::BYTE_ARRAY => syn::parse_quote!(
-                parquet::column::writer::ColumnWriter::ByteArrayColumnWriter
-            ),
-            BasicType::FIXED_LEN_BYTE_ARRAY => syn::parse_quote!(
-                parquet::column::writer::ColumnWriter::FixedLenByteArrayColumnWriter
-            ),
         }
     }
 
     /// Helper to simplify a nested field definition to its leaf type
     ///
     /// Ex:
-    ///   Option<&String> => Type::TypePath(String)
-    ///   &Option<i32> => Type::TypePath(i32)
-    ///   Vec<Vec<u8>> => Type::Vec(u8)
+    ///   `Option<&String>` => Type::TypePath(String)
+    ///   `&Option<i32>` => Type::TypePath(i32)
+    ///   `Vec<Vec<u8>>` => Type::Vec(u8)
     ///
     /// Useful in determining the physical type of a field and the
     /// definition levels.
     fn leaf_type_recursive(&self) -> &Type {
-        self.leaf_type_recursive_helper(self, None)
+        Type::leaf_type_recursive_helper(self, None)
     }
 
-    fn leaf_type_recursive_helper<'a>(
-        &'a self,
-        ty: &'a Type,
-        parent_ty: Option<&'a Type>,
-    ) -> &Type {
+    fn leaf_type_recursive_helper<'a>(ty: &'a Type, parent_ty: Option<&'a Type>) -> &'a Type {
         match ty {
             Type::TypePath(_) => parent_ty.unwrap_or(ty),
             Type::Option(ref first_type)
             | Type::Vec(ref first_type)
             | Type::Array(ref first_type)
+            | Type::Slice(ref first_type)
             | Type::Reference(_, ref first_type) => {
-                self.leaf_type_recursive_helper(first_type, Some(ty))
+                Type::leaf_type_recursive_helper(first_type, Some(ty))
             }
         }
     }
@@ -402,6 +561,7 @@ impl Type {
             Type::Option(ref first_type)
             | Type::Vec(ref first_type)
             | Type::Array(ref first_type)
+            | Type::Slice(ref first_type)
             | Type::Reference(_, ref first_type) => match **first_type {
                 Type::TypePath(ref type_) => type_,
                 _ => unimplemented!("leaf_type() should only return shallow types"),
@@ -414,7 +574,7 @@ impl Type {
     ///
     /// Ex:
     ///   std::string::String => String
-    ///   Vec<u8> => Vec<u8>
+    ///   `Vec<u8>` => `Vec<u8>`
     ///   chrono::NaiveDateTime => NaiveDateTime
     ///
     /// Does run the risk of mis-identifying a type if import
@@ -437,7 +597,7 @@ impl Type {
     ///
     /// Ex:
     ///   [u8; 10] => FIXED_LEN_BYTE_ARRAY
-    ///   Vec<u8>  => BYTE_ARRAY
+    ///   `Vec<u8>`  => BYTE_ARRAY
     ///   String => BYTE_ARRAY
     ///   i32 => INT32
     fn physical_type(&self) -> parquet::basic::Type {
@@ -454,7 +614,7 @@ impl Type {
                     }
                 }
             }
-            Type::Vec(ref first_type) => {
+            Type::Vec(ref first_type) | Type::Slice(ref first_type) => {
                 if let Type::TypePath(_) = **first_type {
                     if last_part == "u8" {
                         return BasicType::BYTE_ARRAY;
@@ -495,7 +655,7 @@ impl Type {
                     }
                 }
             }
-            Type::Vec(ref first_type) => {
+            Type::Vec(ref first_type) | Type::Slice(ref first_type) => {
                 if let Type::TypePath(_) = **first_type {
                     if last_part == "u8" {
                         return quote! { None };
@@ -557,16 +717,16 @@ impl Type {
         let last_part = self.last_part();
 
         match last_part.trim() {
-            "NaiveDateTime" => Some(quote! { ConvertedType::TIMESTAMP_MILLIS }),
+            "NaiveDateTime" => Some(quote! { ::parquet::basic::ConvertedType::TIMESTAMP_MILLIS }),
             _ => None,
         }
     }
 
     fn repetition(&self) -> proc_macro2::TokenStream {
-        match &self {
-            Type::Option(_) => quote! { Repetition::OPTIONAL },
+        match self {
+            Type::Option(_) => quote! { ::parquet::basic::Repetition::OPTIONAL },
             Type::Reference(_, ty) => ty.repetition(),
-            _ => quote! { Repetition::REQUIRED },
+            _ => quote! { ::parquet::basic::Repetition::REQUIRED },
         }
     }
 
@@ -581,6 +741,7 @@ impl Type {
             syn::Type::Path(ref p) => Type::from_type_path(f, p),
             syn::Type::Reference(ref tr) => Type::from_type_reference(f, tr),
             syn::Type::Array(ref ta) => Type::from_type_array(f, ta),
+            syn::Type::Slice(ref ts) => Type::from_type_slice(f, ts),
             other => unimplemented!(
                 "Unable to derive {:?} - it is currently an unsupported type\n{:#?}",
                 f.ident.as_ref().unwrap(),
@@ -592,10 +753,9 @@ impl Type {
     fn from_type_path(f: &syn::Field, p: &syn::TypePath) -> Self {
         let last_segment = p.path.segments.last().unwrap();
 
-        let is_vec =
-            last_segment.ident == syn::Ident::new("Vec", proc_macro2::Span::call_site());
-        let is_option = last_segment.ident
-            == syn::Ident::new("Option", proc_macro2::Span::call_site());
+        let is_vec = last_segment.ident == syn::Ident::new("Vec", proc_macro2::Span::call_site());
+        let is_option =
+            last_segment.ident == syn::Ident::new("Option", proc_macro2::Span::call_site());
 
         if is_vec || is_option {
             let generic_type = match &last_segment.arguments {
@@ -631,6 +791,11 @@ impl Type {
         let inner_type = Type::from_type(f, ta.elem.as_ref());
         Type::Array(Box::new(inner_type))
     }
+
+    fn from_type_slice(f: &syn::Field, ts: &syn::TypeSlice) -> Self {
+        let inner_type = Type::from_type(f, ts.elem.as_ref());
+        Type::Slice(Box::new(inner_type))
+    }
 }
 
 #[cfg(test)]
@@ -666,7 +831,7 @@ mod test {
                         {
                             let vals : Vec < _ > = records . iter ( ) . map ( | rec | rec . counter as i64 ) . collect ( );
 
-                            if let parquet::column::writer::ColumnWriter::Int64ColumnWriter ( ref mut typed ) = column_writer.untyped() {
+                            if let ColumnWriter::Int64ColumnWriter ( ref mut typed ) = column_writer.untyped() {
                                 typed . write_batch ( & vals [ .. ] , None , None ) ?;
                             }  else {
                                 panic!("Schema and struct disagree on type for {}" , stringify!{ counter } )
@@ -676,13 +841,44 @@ mod test {
         )
     }
 
+    #[test]
+    fn test_generating_a_simple_reader_snippet() {
+        let snippet: proc_macro2::TokenStream = quote! {
+          struct ABoringStruct {
+            counter: usize,
+          }
+        };
+
+        let fields = extract_fields(snippet);
+        let counter = Field::from(&fields[0]);
+
+        let snippet = counter.reader_snippet().to_string();
+        assert_eq!(
+            snippet,
+            (quote! {
+                 {
+                     let mut vals = Vec::new();
+                     if let ColumnReader::Int64ColumnReader(mut typed) = column_reader {
+                         typed.read_records(num_records, None, None, &mut vals)?;
+                     } else {
+                         panic!("Schema and struct disagree on type for {}", stringify!{ counter });
+                     }
+                     for (i, r) in &mut records[..num_records].iter_mut().enumerate() {
+                         r.counter = vals[i] as usize;
+                     }
+                 }
+            })
+            .to_string()
+        )
+    }
+
     #[test]
     fn test_optional_to_writer_snippet() {
         let struct_def: proc_macro2::TokenStream = quote! {
           struct StringBorrower<'a> {
             optional_str: Option<&'a str>,
-            optional_string: &Option<String>,
-            optional_dumb_int: &Option<&i32>,
+            optional_string: Option<&String>,
+            optional_dumb_int: Option<&i32>,
           }
         };
 
@@ -703,7 +899,7 @@ mod test {
                     }
                 }).collect();
 
-                if let parquet::column::writer::ColumnWriter::ByteArrayColumnWriter ( ref mut typed ) = column_writer.untyped() {
+                if let ColumnWriter::ByteArrayColumnWriter ( ref mut typed ) = column_writer.untyped() {
                     typed . write_batch ( & vals [ .. ] , Some(&definition_levels[..]) , None ) ? ;
                 } else {
                     panic!("Schema and struct disagree on type for {}" , stringify ! { optional_str } )
@@ -727,7 +923,7 @@ mod test {
                             }
                         }).collect();
 
-                        if let parquet::column::writer::ColumnWriter::ByteArrayColumnWriter ( ref mut typed ) = column_writer.untyped() {
+                        if let ColumnWriter::ByteArrayColumnWriter ( ref mut typed ) = column_writer.untyped() {
                             typed . write_batch ( & vals [ .. ] , Some(&definition_levels[..]) , None ) ? ;
                         } else {
                             panic!("Schema and struct disagree on type for {}" , stringify ! { optional_string } )
@@ -750,7 +946,7 @@ mod test {
                             }
                         }).collect();
 
-                        if let parquet::column::writer::ColumnWriter::Int32ColumnWriter ( ref mut typed ) = column_writer.untyped() {
+                        if let ColumnWriter::Int32ColumnWriter ( ref mut typed ) = column_writer.untyped() {
                             typed . write_batch ( & vals [ .. ] , Some(&definition_levels[..]) , None ) ? ;
                         }  else {
                             panic!("Schema and struct disagree on type for {}" , stringify ! { optional_dumb_int } )
@@ -779,12 +975,34 @@ mod test {
         assert_eq!(
             column_writers,
             vec![
-                syn::parse_quote!(
-                    parquet::column::writer::ColumnWriter::BoolColumnWriter
-                ),
-                syn::parse_quote!(
-                    parquet::column::writer::ColumnWriter::ByteArrayColumnWriter
-                )
+                syn::parse_quote!(ColumnWriter::BoolColumnWriter),
+                syn::parse_quote!(ColumnWriter::ByteArrayColumnWriter)
+            ]
+        );
+    }
+
+    #[test]
+    fn test_converting_to_column_reader_type() {
+        let snippet: proc_macro2::TokenStream = quote! {
+          struct ABasicStruct {
+            yes_no: bool,
+            name: String,
+          }
+        };
+
+        let fields = extract_fields(snippet);
+        let processed: Vec<_> = fields.iter().map(Field::from).collect();
+
+        let column_readers: Vec<_> = processed
+            .iter()
+            .map(|field| field.ty.column_reader())
+            .collect();
+
+        assert_eq!(
+            column_readers,
+            vec![
+                syn::parse_quote!(ColumnReader::BoolColumnReader),
+                syn::parse_quote!(ColumnReader::ByteArrayColumnReader)
             ]
         );
     }
@@ -833,9 +1051,9 @@ mod test {
         let snippet: proc_macro2::TokenStream = quote! {
           struct LotsOfInnerTypes {
             a_vec: Vec<u8>,
-            a_option: std::option::Option<bool>,
-            a_silly_string: std::string::String,
-            a_complicated_thing: std::option::Option<std::result::Result<(),()>>,
+            a_option: ::std::option::Option<bool>,
+            a_silly_string: ::std::string::String,
+            a_complicated_thing: ::std::option::Option<::std::result::Result<(),()>>,
           }
         };
 
@@ -855,8 +1073,8 @@ mod test {
             vec![
                 "u8",
                 "bool",
-                "std :: string :: String",
-                "std :: result :: Result < () , () >"
+                ":: std :: string :: String",
+                ":: std :: result :: Result < () , () >"
             ]
         )
     }
@@ -866,13 +1084,13 @@ mod test {
         use parquet::basic::Type as BasicType;
         let snippet: proc_macro2::TokenStream = quote! {
           struct LotsOfInnerTypes {
-            a_buf: Vec<u8>,
+            a_buf: ::std::vec::Vec<u8>,
             a_number: i32,
-            a_verbose_option: std::option::Option<bool>,
-            a_silly_string: std::string::String,
+            a_verbose_option: ::std::option::Option<bool>,
+            a_silly_string: String,
             a_fix_byte_buf: [u8; 10],
-            a_complex_option: Option<&Vec<u8>>,
-            a_complex_vec: &Vec<&Option<u8>>,
+            a_complex_option: ::std::option::Option<&Vec<u8>>,
+            a_complex_vec: &::std::vec::Vec<&Option<u8>>,
           }
         };
 
@@ -901,10 +1119,10 @@ mod test {
     fn test_convert_comprehensive_owned_struct() {
         let snippet: proc_macro2::TokenStream = quote! {
           struct VecHolder {
-            a_vec: Vec<u8>,
-            a_option: std::option::Option<bool>,
-            a_silly_string: std::string::String,
-            a_complicated_thing: std::option::Option<std::result::Result<(),()>>,
+            a_vec: ::std::vec::Vec<u8>,
+            a_option: ::std::option::Option<bool>,
+            a_silly_string: ::std::string::String,
+            a_complicated_thing: ::std::option::Option<::std::result::Result<(),()>>,
           }
         };
 
@@ -916,9 +1134,9 @@ mod test {
             vec![
                 Type::Vec(Box::new(Type::TypePath(syn::parse_quote!(u8)))),
                 Type::Option(Box::new(Type::TypePath(syn::parse_quote!(bool)))),
-                Type::TypePath(syn::parse_quote!(std::string::String)),
+                Type::TypePath(syn::parse_quote!(::std::string::String)),
                 Type::Option(Box::new(Type::TypePath(
-                    syn::parse_quote!(std::result::Result<(),()>)
+                    syn::parse_quote!(::std::result::Result<(),()>)
                 ))),
             ]
         );
@@ -962,7 +1180,7 @@ mod test {
     }
 
     #[test]
-    fn test_chrono_timestamp_millis() {
+    fn test_chrono_timestamp_millis_write() {
         let snippet: proc_macro2::TokenStream = quote! {
           struct ATimestampStruct {
             henceforth: chrono::NaiveDateTime,
@@ -975,7 +1193,7 @@ mod test {
         assert_eq!(when.writer_snippet().to_string(),(quote!{
             {
                 let vals : Vec<_> = records.iter().map(|rec| rec.henceforth.timestamp_millis() ).collect();
-                if let parquet::column::writer::ColumnWriter::Int64ColumnWriter(ref mut typed) = column_writer.untyped() {
+                if let ColumnWriter::Int64ColumnWriter(ref mut typed) = column_writer.untyped() {
                     typed.write_batch(&vals[..], None, None) ?;
                 } else {
                     panic!("Schema and struct disagree on type for {}" , stringify!{ henceforth })
@@ -995,7 +1213,7 @@ mod test {
                     }
                 }).collect();
 
-                if let parquet::column::writer::ColumnWriter::Int64ColumnWriter(ref mut typed) = column_writer.untyped() {
+                if let ColumnWriter::Int64ColumnWriter(ref mut typed) = column_writer.untyped() {
                     typed.write_batch(&vals[..], Some(&definition_levels[..]), None) ?;
                 } else {
                     panic!("Schema and struct disagree on type for {}" , stringify!{ maybe_happened })
@@ -1005,7 +1223,32 @@ mod test {
     }
 
     #[test]
-    fn test_chrono_date() {
+    fn test_chrono_timestamp_millis_read() {
+        let snippet: proc_macro2::TokenStream = quote! {
+          struct ATimestampStruct {
+            henceforth: chrono::NaiveDateTime,
+          }
+        };
+
+        let fields = extract_fields(snippet);
+        let when = Field::from(&fields[0]);
+        assert_eq!(when.reader_snippet().to_string(),(quote!{
+            {
+                let mut vals = Vec::new();
+                if let ColumnReader::Int64ColumnReader(mut typed) = column_reader {
+                    typed.read_records(num_records, None, None, &mut vals)?;
+                } else {
+                    panic!("Schema and struct disagree on type for {}", stringify!{ henceforth });
+                }
+                for (i, r) in &mut records[..num_records].iter_mut().enumerate() {
+                    r.henceforth = ::chrono::naive::NaiveDateTime::from_timestamp_millis(vals[i]).unwrap();
+                }
+            }
+        }).to_string());
+    }
+
+    #[test]
+    fn test_chrono_date_write() {
         let snippet: proc_macro2::TokenStream = quote! {
           struct ATimestampStruct {
             henceforth: chrono::NaiveDate,
@@ -1017,8 +1260,8 @@ mod test {
         let when = Field::from(&fields[0]);
         assert_eq!(when.writer_snippet().to_string(),(quote!{
             {
-                let vals : Vec<_> = records.iter().map(|rec| rec.henceforth.signed_duration_since(chrono::NaiveDate::from_ymd(1970, 1, 1)).num_days() as i32).collect();
-                if let parquet::column::writer::ColumnWriter::Int32ColumnWriter(ref mut typed) = column_writer.untyped() {
+                let vals : Vec<_> = records.iter().map(|rec| rec.henceforth.signed_duration_since(::chrono::NaiveDate::from_ymd(1970, 1, 1)).num_days() as i32).collect();
+                if let ColumnWriter::Int32ColumnWriter(ref mut typed) = column_writer.untyped() {
                     typed.write_batch(&vals[..], None, None) ?;
                 } else {
                     panic!("Schema and struct disagree on type for {}" , stringify!{ henceforth })
@@ -1032,13 +1275,13 @@ mod test {
                 let definition_levels : Vec<i16> = self.iter().map(|rec| if rec.maybe_happened.is_some() { 1 } else { 0 }).collect();
                 let vals : Vec<_> = records.iter().filter_map(|rec| {
                     if let Some(inner) = rec.maybe_happened {
-                        Some(inner.signed_duration_since(chrono::NaiveDate::from_ymd(1970, 1, 1)).num_days() as i32)
+                        Some(inner.signed_duration_since(::chrono::NaiveDate::from_ymd(1970, 1, 1)).num_days() as i32)
                     } else {
                         None
                     }
                 }).collect();
 
-                if let parquet::column::writer::ColumnWriter::Int32ColumnWriter(ref mut typed) = column_writer.untyped() {
+                if let ColumnWriter::Int32ColumnWriter(ref mut typed) = column_writer.untyped() {
                     typed.write_batch(&vals[..], Some(&definition_levels[..]), None) ?;
                 } else {
                     panic!("Schema and struct disagree on type for {}" , stringify!{ maybe_happened })
@@ -1048,7 +1291,32 @@ mod test {
     }
 
     #[test]
-    fn test_uuid() {
+    fn test_chrono_date_read() {
+        let snippet: proc_macro2::TokenStream = quote! {
+          struct ATimestampStruct {
+            henceforth: chrono::NaiveDate,
+          }
+        };
+
+        let fields = extract_fields(snippet);
+        let when = Field::from(&fields[0]);
+        assert_eq!(when.reader_snippet().to_string(),(quote!{
+            {
+                let mut vals = Vec::new();
+                if let ColumnReader::Int32ColumnReader(mut typed) = column_reader {
+                    typed.read_records(num_records, None, None, &mut vals)?;
+                } else {
+                    panic!("Schema and struct disagree on type for {}", stringify!{ henceforth });
+                }
+                for (i, r) in &mut records[..num_records].iter_mut().enumerate() {
+                    r.henceforth = ::chrono::naive::NaiveDate::from_num_days_from_ce_opt(vals[i].saturating_add(719163)).unwrap();
+                }
+            }
+        }).to_string());
+    }
+
+    #[test]
+    fn test_uuid_write() {
         let snippet: proc_macro2::TokenStream = quote! {
           struct AUuidStruct {
             unique_id: uuid::Uuid,
@@ -1061,7 +1329,7 @@ mod test {
         assert_eq!(when.writer_snippet().to_string(),(quote!{
             {
                 let vals : Vec<_> = records.iter().map(|rec| (&rec.unique_id.to_string()[..]).into() ).collect();
-                if let parquet::column::writer::ColumnWriter::ByteArrayColumnWriter(ref mut typed) = column_writer.untyped() {
+                if let ColumnWriter::ByteArrayColumnWriter(ref mut typed) = column_writer.untyped() {
                     typed.write_batch(&vals[..], None, None) ?;
                 } else {
                     panic!("Schema and struct disagree on type for {}" , stringify!{ unique_id })
@@ -1081,7 +1349,7 @@ mod test {
                     }
                 }).collect();
 
-                if let parquet::column::writer::ColumnWriter::ByteArrayColumnWriter(ref mut typed) = column_writer.untyped() {
+                if let ColumnWriter::ByteArrayColumnWriter(ref mut typed) = column_writer.untyped() {
                     typed.write_batch(&vals[..], Some(&definition_levels[..]), None) ?;
                 } else {
                     panic!("Schema and struct disagree on type for {}" , stringify!{ maybe_unique_id })
@@ -1090,6 +1358,31 @@ mod test {
         }).to_string());
     }
 
+    #[test]
+    fn test_uuid_read() {
+        let snippet: proc_macro2::TokenStream = quote! {
+          struct AUuidStruct {
+            unique_id: uuid::Uuid,
+          }
+        };
+
+        let fields = extract_fields(snippet);
+        let when = Field::from(&fields[0]);
+        assert_eq!(when.reader_snippet().to_string(),(quote!{
+            {
+                let mut vals = Vec::new();
+                if let ColumnReader::ByteArrayColumnReader(mut typed) = column_reader {
+                    typed.read_records(num_records, None, None, &mut vals)?;
+                } else {
+                    panic!("Schema and struct disagree on type for {}", stringify!{ unique_id });
+                }
+                for (i, r) in &mut records[..num_records].iter_mut().enumerate() {
+                    r.unique_id = ::uuid::Uuid::parse_str(vals[i].data().convert()).unwrap();
+                }
+            }
+        }).to_string());
+    }
+
     #[test]
     fn test_converted_type() {
         let snippet: proc_macro2::TokenStream = quote! {
@@ -1105,7 +1398,7 @@ mod test {
         let converted_type = time.ty.converted_type();
         assert_eq!(
             converted_type.unwrap().to_string(),
-            quote! { ConvertedType::TIMESTAMP_MILLIS }.to_string()
+            quote! { ::parquet::basic::ConvertedType::TIMESTAMP_MILLIS }.to_string()
         );
     }
 }
diff --git a/parquet_derive_test/Cargo.toml b/parquet_derive_test/Cargo.toml
index bf3e78b247ec..a5d2e76d4503 100644
--- a/parquet_derive_test/Cargo.toml
+++ b/parquet_derive_test/Cargo.toml
@@ -17,18 +17,18 @@
 
 [package]
 name = "parquet_derive_test"
-version = "20.0.0"
-license = "Apache-2.0"
+version = { workspace = true }
+license = { workspace = true }
 description = "Integration test package for parquet-derive"
-homepage = "https://github.com/apache/arrow-rs"
-repository = "https://github.com/apache/arrow-rs"
-authors = ["Apache Arrow <dev@arrow.apache.org>"]
+homepage = { workspace = true }
+repository = { workspace = true }
+authors = { workspace = true }
 keywords = [ "parquet" ]
-edition = "2021"
+edition = { workspace = true }
 publish = false
-rust-version = "1.62"
+rust-version = { workspace = true }
 
 [dependencies]
-parquet = { path = "../parquet", version = "20.0.0", default-features = false }
-parquet_derive = { path = "../parquet_derive", version = "20.0.0", default-features = false }
-chrono = { version="0.4.19", default-features = false, features = [ "clock" ] }
+parquet = { workspace = true }
+parquet_derive = { path = "../parquet_derive", default-features = false }
+chrono = { workspace = true }
diff --git a/parquet_derive_test/src/lib.rs b/parquet_derive_test/src/lib.rs
index 189802b9a527..a8b631ecc024 100644
--- a/parquet_derive_test/src/lib.rs
+++ b/parquet_derive_test/src/lib.rs
@@ -17,12 +17,7 @@
 
 #![allow(clippy::approx_constant)]
 
-extern crate parquet;
-
-#[macro_use]
-extern crate parquet_derive;
-
-use parquet::record::RecordWriter;
+use parquet_derive::{ParquetRecordReader, ParquetRecordWriter};
 
 #[derive(ParquetRecordWriter)]
 struct ACompleteRecord<'a> {
@@ -47,17 +42,39 @@ struct ACompleteRecord<'a> {
     pub borrowed_maybe_a_string: &'a Option<String>,
     pub borrowed_maybe_a_str: &'a Option<&'a str>,
     pub now: chrono::NaiveDateTime,
+    pub byte_vec: Vec<u8>,
+    pub maybe_byte_vec: Option<Vec<u8>>,
+    pub borrowed_byte_vec: &'a [u8],
+    pub borrowed_maybe_byte_vec: &'a Option<Vec<u8>>,
+    pub borrowed_maybe_borrowed_byte_vec: &'a Option<&'a [u8]>,
+}
+
+#[derive(PartialEq, ParquetRecordWriter, ParquetRecordReader, Debug)]
+struct APartiallyCompleteRecord {
+    pub bool: bool,
+    pub string: String,
+    pub i16: i16,
+    pub i32: i32,
+    pub u64: u64,
+    pub isize: isize,
+    pub float: f32,
+    pub double: f64,
+    pub now: chrono::NaiveDateTime,
+    pub date: chrono::NaiveDate,
+    pub byte_vec: Vec<u8>,
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
+    use std::{env, fs, io::Write, sync::Arc};
+
     use parquet::{
-        file::{properties::WriterProperties, writer::SerializedFileWriter},
+        file::writer::SerializedFileWriter,
+        record::{RecordReader, RecordWriter},
         schema::parser::parse_message_type,
     };
-    use std::{env, fs, io::Write, sync::Arc};
 
     #[test]
     fn test_parquet_derive_hello() {
@@ -87,6 +104,11 @@ mod tests {
             OPTIONAL BINARY          borrowed_maybe_a_string (STRING);
             OPTIONAL BINARY          borrowed_maybe_a_str (STRING);
             REQUIRED INT64           now (TIMESTAMP_MILLIS);
+            REQUIRED BINARY          byte_vec;
+            OPTIONAL BINARY          maybe_byte_vec;
+            REQUIRED BINARY          borrowed_byte_vec;
+            OPTIONAL BINARY          borrowed_maybe_byte_vec;
+            OPTIONAL BINARY          borrowed_maybe_borrowed_byte_vec;
         }";
 
         let schema = Arc::new(parse_message_type(schema_str).unwrap());
@@ -95,6 +117,9 @@ mod tests {
         let a_borrowed_string = "cool news".to_owned();
         let maybe_a_string = Some("it's true, I'm a string".to_owned());
         let maybe_a_str = Some(&a_str[..]);
+        let borrowed_byte_vec = vec![0x68, 0x69, 0x70];
+        let borrowed_maybe_byte_vec = Some(vec![0x71, 0x72]);
+        let borrowed_maybe_borrowed_byte_vec = Some(&borrowed_byte_vec[..]);
 
         let drs: Vec<ACompleteRecord> = vec![ACompleteRecord {
             a_bool: true,
@@ -118,20 +143,74 @@ mod tests {
             borrowed_maybe_a_string: &maybe_a_string,
             borrowed_maybe_a_str: &maybe_a_str,
             now: chrono::Utc::now().naive_local(),
+            byte_vec: vec![0x65, 0x66, 0x67],
+            maybe_byte_vec: Some(vec![0x88, 0x89, 0x90]),
+            borrowed_byte_vec: &borrowed_byte_vec,
+            borrowed_maybe_byte_vec: &borrowed_maybe_byte_vec,
+            borrowed_maybe_borrowed_byte_vec: &borrowed_maybe_borrowed_byte_vec,
         }];
 
         let generated_schema = drs.as_slice().schema().unwrap();
 
         assert_eq!(&schema, &generated_schema);
 
-        let props = Arc::new(WriterProperties::builder().build());
+        let props = Default::default();
+        let mut writer = SerializedFileWriter::new(file, generated_schema, props).unwrap();
+
+        let mut row_group = writer.next_row_group().unwrap();
+        drs.as_slice().write_to_row_group(&mut row_group).unwrap();
+        row_group.close().unwrap();
+        writer.close().unwrap();
+    }
+
+    #[test]
+    fn test_parquet_derive_read_write_combined() {
+        let file = get_temp_file("test_parquet_derive_combined", &[]);
+
+        let mut drs: Vec<APartiallyCompleteRecord> = vec![APartiallyCompleteRecord {
+            bool: true,
+            string: "a string".into(),
+            i16: -45,
+            i32: 456,
+            u64: 4563424,
+            isize: -365,
+            float: 3.5,
+            double: std::f64::NAN,
+            now: chrono::Utc::now().naive_local(),
+            date: chrono::naive::NaiveDate::from_ymd_opt(2015, 3, 14).unwrap(),
+            byte_vec: vec![0x65, 0x66, 0x67],
+        }];
+
+        let mut out: Vec<APartiallyCompleteRecord> = Vec::new();
+
+        use parquet::file::{reader::FileReader, serialized_reader::SerializedFileReader};
+
+        let generated_schema = drs.as_slice().schema().unwrap();
+
+        let props = Default::default();
         let mut writer =
-            SerializedFileWriter::new(file, generated_schema, props).unwrap();
+            SerializedFileWriter::new(file.try_clone().unwrap(), generated_schema, props).unwrap();
 
         let mut row_group = writer.next_row_group().unwrap();
         drs.as_slice().write_to_row_group(&mut row_group).unwrap();
         row_group.close().unwrap();
         writer.close().unwrap();
+
+        let reader = SerializedFileReader::new(file).unwrap();
+
+        let mut row_group = reader.get_row_group(0).unwrap();
+        out.read_from_row_group(&mut *row_group, 1).unwrap();
+
+        // correct for rounding error when writing milliseconds
+        drs[0].now =
+            chrono::naive::NaiveDateTime::from_timestamp_millis(drs[0].now.timestamp_millis())
+                .unwrap();
+
+        assert!(out[0].double.is_nan()); // these three lines are necessary because NAN != NAN
+        out[0].double = 0.;
+        drs[0].double = 0.;
+
+        assert_eq!(drs[0], out[0]);
     }
 
     /// Returns file handle for a temp file in 'target' directory with a provided content
diff --git a/pre-commit.sh b/pre-commit.sh
index 5ce080793242..f82390e229a9 100755
--- a/pre-commit.sh
+++ b/pre-commit.sh
@@ -20,7 +20,7 @@
 # This file is git pre-commit hook.
 #
 # Soft link it as git hook under top dir of apache arrow git repository:
-# $ ln -s  ../../rust/pre-commit.sh .git/hooks/pre-commit
+# $ ln -s  ../../pre-commit.sh .git/hooks/pre-commit
 #
 # This file be run directly:
 # $ ./pre-commit.sh
@@ -37,14 +37,12 @@ function BYELLOW() {
 	echo "\033[1;33m$@\033[0m"
 }
 
-RUST_DIR="rust"
-
 # env GIT_DIR is set by git when run a pre-commit hook.
 if [ -z "${GIT_DIR}" ]; then
 	GIT_DIR=$(git rev-parse --show-toplevel)
 fi
 
-cd ${GIT_DIR}/${RUST_DIR}
+cd ${GIT_DIR}
 
 NUM_CHANGES=$(git diff --cached --name-only . |
 	grep -e ".*/*.rs$" |
diff --git a/rustfmt.toml b/rustfmt.toml
index 4522e520a469..585c1b612978 100644
--- a/rustfmt.toml
+++ b/rustfmt.toml
@@ -16,9 +16,3 @@
 # under the License.
 
 edition = "2021"
-max_width = 90
-
-# ignore generated files
-# ignore = [
-#    "arrow/src/ipc/gen",
-#]
diff --git a/testing b/testing
index d315f7985207..e270341fb5f3 160000
--- a/testing
+++ b/testing
@@ -1 +1 @@
-Subproject commit d315f7985207d2d67fc2c8e41053e9d97d573f4b
+Subproject commit e270341fb5f3ff785410e6286cc42898e9d6a99c